开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTEditListBox.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：24k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTEditListBox.cpp：源码内容
  1. // XTEditListBox.cpp : implementation of the CXTEditListBox class.
  2. //
  3. // This file is a part of the XTREME CONTROLS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  23. #include "Common/XTPResourceManager.h"
  24. #include "Common/XTPColorManager.h"
  25. #include "Common/XTPDrawHelpers.h"
  26. #include "Common/XTPWinThemeWrapper.h"
  28. #include "Resource.h"
  29. #include "XTDefines.h"
  30. #include "XTUtil.h"
  31. #include "XTGlobal.h"
  33. #include "XTButton.h"
  34. #include "XTFlatComboBox.h"
  35. #include "XTBrowseEdit.h"
  37. #include "XTListBox.h"
  38. #include "XTEditListBox.h"
  40. #include "XTThemeManager.h"
  41. #include "XTButtonTheme.h"
  43. #ifdef _DEBUG
  44. #define new DEBUG_NEW
  45. #undef THIS_FILE
  46. static char THIS_FILE[] = __FILE__;
  47. #endif
  49. #define XT_IDC_GROUP_EDIT               200
  52. /////////////////////////////////////////////////////////////////////////////
  53. // CXTEditListBox
  54. /////////////////////////////////////////////////////////////////////////////
  56. const int BTN_OFFSET = 22;
  58. CXTEditListBox::CXTEditListBox()
  59. : m_bEnableEdit(true)
  60. , m_pParentWnd(NULL)
  61. {
  62. m_pItemEdit = NULL;
  63. m_nIndex = -1;
  64. m_bNewItem = FALSE;
  66. m_strItemDefaultText.Empty();
  68. SetListEditStyle(XT_IDS_DIRECTORIES, LBS_XT_CHOOSEDIR);
  69. }
  71. CXTEditListBox::~CXTEditListBox()
  72. {
  73. }
  75. IMPLEMENT_DYNAMIC(CXTEditListBox, CXTListBox)
  77. BEGIN_MESSAGE_MAP(CXTEditListBox, CXTListBox)
  78. //{{AFX_MSG_MAP(CXTEditListBox)
  79. ON_LBN_XT_LABELEDITEND(XT_IDC_LBOX_EDIT, OnEndLabelEdit)
  80. ON_LBN_XT_NEWITEM(XT_IDC_GROUP_EDIT, OnNewItem)
  81. ON_LBN_XT_DELETEITEM(XT_IDC_GROUP_EDIT, OnDeleteItem)
  82. ON_LBN_XT_MOVEITEMUP(XT_IDC_GROUP_EDIT, OnMoveItemUp)
  83. ON_LBN_XT_MOVEITEMDOWN(XT_IDC_GROUP_EDIT, OnMoveItemDown)
  84. ON_WM_LBUTTONDBLCLK()
  85. ON_WM_LBUTTONDOWN()
  86. ON_WM_NCLBUTTONDOWN()
  87. ON_WM_NCMBUTTONDOWN()
  88. ON_WM_NCRBUTTONDOWN()
  89. ON_WM_WINDOWPOSCHANGED()
  90. ON_LBN_XT_LABELEDITCANCEL(XT_IDC_LBOX_EDIT, OnEndLabelEdit)
  91. ON_LBN_XT_ONBROWSE(XT_IDC_LBOX_EDIT, OnItemBrowse)
  92. ON_WM_ENABLE()
  93. ON_WM_SHOWWINDOW()
  94. ON_WM_MOUSEWHEEL()
  95. ON_WM_SIZE()
  96. //}}AFX_MSG_MAP
  97. END_MESSAGE_MAP()
  100. COLORREF CXTEditListBox::GetBackColor()
  101. {
  102. return IsWindowEnabled() ?
  103. GetXtremeColor(COLOR_WINDOW) : GetXtremeColor(COLOR_3DFACE);
  104. }
  106. void CXTEditListBox::OnSize(UINT nType, int cx, int cy)
  107. {
  108. if (m_pItemEdit)
  109. {
  110. m_pItemEdit->EndLabelEdit();
  111. Invalidate(FALSE);
  112. }
  114. CXTListBox::OnSize(nType, cx, cy);
  115. }
  117. BOOL CXTEditListBox::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
  118. {
  119. if (m_pItemEdit)
  120. {
  121. m_pItemEdit->EndLabelEdit();
  122. Invalidate(FALSE);
  123. }
  124. return CXTListBox::OnMouseWheel(nFlags, zDelta, pt);
  125. }
  127. void CXTEditListBox::OnEndLabelEdit()
  128. {
  129. // Get a pointer to the owner window.
  130. CWnd* pOwner = GetOwner();
  131. ASSERT(pOwner);
  132. if (!pOwner)
  133. return;
  135. if (m_bNewItem)
  136. {
  137. // Delete the temp string.
  138. DeleteString(m_nIndex);
  140. // If the text string is empty, then send a cancel message.
  141. if (m_strItemText.IsEmpty())
  142. {
  143. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  144. LBN_XT_LABELEDITCANCEL), (LPARAM)m_hWnd);
  146. m_nIndex = LB_ERR;
  147. }
  149. // The user has entered text, send the new item message
  150. // and insert the new string.
  151. else
  152. {
  153. m_nIndex = AddString(m_strItemText);
  154. // NB: SetTopIndex below causes some confusion if you have editing session, change content
  155. // and then double click on another item - the result looks like misplaced
  156. // edit control
  157. //SetTopIndex(m_nIndex);
  160. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  161. LBN_XT_NEWITEM), (LPARAM)m_hWnd);
  162. }
  163. }
  164. else
  165. {
  166. // set the index to the current selection.
  167. m_nIndex = GetCurSel();
  169. // Get the text for the selected item.
  170. CString strItemText;
  171. GetText(m_nIndex, strItemText);
  173. // If the new string is the same as the old string,
  174. // then send a cancel message.
  175. if (strItemText == m_strItemText)
  176. {
  177. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  178. LBN_XT_LABELEDITCANCEL), (LPARAM)m_hWnd);
  179. }
  181. // The user has updated the text string, delete the
  182. // existing string and replace it with the new text.
  183. else
  184. {
  185. DWORD_PTR dwData = GetItemData(m_nIndex);
  186. DeleteString(m_nIndex);
  187. InsertString(m_nIndex, m_strItemText);
  188. SetItemData(m_nIndex, dwData);
  190. // NB: SetTopIndex below causes some confusion if you have editing session, change content
  191. // and then double click on another item - the result looks like misplaced
  192. // edit control
  193. //SetTopIndex(m_nIndex);
  195. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  196. LBN_XT_LABELEDITEND), (LPARAM)m_hWnd);
  197. }
  198. }
  200. // Set the focus back to the listbox.
  201. SetCurSel(m_nIndex);
  202. SetFocus();
  204. m_pItemEdit = NULL;
  205. }
  207. // Basically, save any edited state, then pass the browse message to the parent window
  208. void CXTEditListBox::OnItemBrowse()
  209. {
  210. m_nIndex = GetCurSel(); // Current index.
  211. int nNewIndex = m_nIndex + 1; // New index.
  213. // If there is a valid selection made, and the
  214. // selection is not the last item and...
  215. if ((m_nIndex != LB_ERR) && (nNewIndex < GetCount()))
  216. {
  217. // Save the string for the current
  218. // selection.
  219. CString strCurItem;
  220. GetText(m_nIndex, strCurItem);
  222. // Save any item data.
  223. DWORD_PTR dwCurData = GetItemData(m_nIndex);
  225. // Remove both the new and current
  226. // index items...
  227. DeleteString(m_nIndex);
  229. // then swap and re-insert them into
  230. // the list box.
  231. InsertString(nNewIndex, strCurItem);
  233. // Restore any item data.
  234. SetItemData(nNewIndex, dwCurData);
  236. // Select the item at the new index.
  237. SetCurSel(nNewIndex);
  238. }
  240. // Set the focus back to the listbox.
  241. SetFocus();
  243. CWnd* pOwner = GetOwner();
  244. ASSERT(pOwner);
  246. // Send notification to owner.
  247. if (pOwner) pOwner->SendMessage( WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  248. LBN_XT_ONBROWSE), (LPARAM)m_hWnd );
  249. }
  251. // This member function will enable editing for the a list box item.
  252. void CXTEditListBox::EditItem(int iItem)
  253. {
  254. SetFocus();
  255. SetCurSel(iItem);
  256. m_nIndex = iItem;
  257. EditListItem(FALSE);
  258. }
  260. void CXTEditListBox::GetEditItemText()
  261. {
  262. GetText(m_nIndex, m_strItemText);
  263. }
  265. void CXTEditListBox::SetEditText( LPCTSTR pcszText )
  266. {
  267. if (m_pItemEdit == NULL)
  268. {
  269. return;
  270. }
  272. m_pItemEdit->SetWindowText( pcszText );
  273. }
  275. void CXTEditListBox::EditListItem(BOOL bNewItem)
  276. {
  277. if (!m_bEnableEdit)
  278. return;
  280. CWnd* pOwner = GetOwner();
  281. ASSERT(pOwner);
  282. if (!pOwner)
  283. return;
  285. // Turn off redraw until we are ready to
  286. // create the edit field.
  287. SetRedraw(FALSE);
  289. // flush the item text string.
  290. m_strItemText = m_strItemDefaultText;
  292. // if this is a new item, add a temporary string
  293. // to the list box and set the selection to it. This
  294. // is where the in place edit box will appear.
  295. if (bNewItem || GetCurSel() == LB_ERR)
  296. {
  297. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  298. LBN_XT_PRENEWITEM), (LPARAM)m_hWnd);
  300. m_nIndex = AddString(m_strItemText);
  301. SetCurSel(m_nIndex);
  302. m_bNewItem = TRUE;
  303. }
  305. // get the text for the currently selected
  306. // item and set the new flag to FALSE.
  307. else
  308. {
  309. m_bNewItem = FALSE;
  311. int iCount = GetCount();
  312. m_nIndex = GetCurSel();
  314. if (m_nIndex >= iCount || iCount <= 0)
  315. {
  316. m_nIndex = LB_ERR;
  317. SetCurSel(LB_ERR);
  319. // turn redraw back.
  320. SetRedraw(TRUE);
  321. Invalidate();
  323. return;
  324. }
  326. GetEditItemText();
  327. }
  329. // turn redraw back.
  330. SetRedraw(TRUE);
  331. Invalidate();
  333. if (m_dwLStyle & LBS_XT_BROWSE_ONLY)
  334. {
  335. // Send notification to owner.
  336. pOwner->SendMessage( WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  337. LBN_XT_ONBROWSE), (LPARAM)m_hWnd );
  339. return;
  340. }
  342. // Get the size of the currently selected item.
  343. CRect rcItem;
  344. GetItemRect(m_nIndex, rcItem);
  345. rcItem.InflateRect(-2, 2);
  347. // create the edit box.
  348. m_pItemEdit = CreateEditControl(rcItem);
  350. // if defined, set the filter for the item edit control.
  351. if (!m_strFilter.IsEmpty())
  352. {
  353. m_pItemEdit->SetDlgFilter(m_strFilter);
  354. }
  355. if (!m_strInitialDir.IsEmpty())
  356. {
  357. m_pItemEdit->SetDlgInitialDir(m_strInitialDir);
  358. }
  359. }
  361. CXTItemEdit* CXTEditListBox::CreateEditControl(CRect rcItem)
  362. {
  363. return new CXTItemEdit(this, rcItem, m_strItemText, m_dwLStyle, true);
  364. }
  366. void CXTEditListBox::OnNewItem()
  367. {
  368. EditListItem(TRUE);
  369. }
  371. void CXTEditListBox::OnLButtonDblClk(UINT nFlags, CPoint point)
  372. {
  373. CWnd::OnLButtonDblClk(nFlags, point);
  374. EditListItem(FALSE);
  375. }
  377. void CXTEditListBox::OnDeleteItem()
  378. {
  379. DeleteItem();
  380. }
  382. void CXTEditListBox::DeleteItem()
  383. {
  384. CWnd* pOwner = GetOwner();
  385. ASSERT(pOwner);
  386. if (!pOwner)
  387. return;
  389. // Send notification to owner that we are about to delete the item
  390. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  391. LBN_XT_PREDELETEITEM), (LPARAM)m_hWnd);
  393. int nCurIndex = GetCurSel();    // Current index.
  395. // If there is a valid selection made...
  396. if (nCurIndex != LB_ERR)
  397. {
  398. // Remove the new current item.
  399. int nCount = DeleteString(nCurIndex);
  401. if ((nCount != LB_ERR) && (nCurIndex < nCount))
  402. {
  403. SetCurSel(nCurIndex);
  404. }
  405. else
  406. {
  407. SetCurSel(nCurIndex-1);
  408. }
  409. }
  411. // Set the focus back to the listbox.
  412. SetFocus();
  414. // Send notification to owner.
  415. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  416. LBN_XT_DELETEITEM), (LPARAM)m_hWnd);
  417. }
  419. void CXTEditListBox::OnMoveItemUp()
  420. {
  421. int nIndex = GetCurSel();
  423. if (nIndex != LB_ERR)
  424. MoveItemUp(nIndex);
  425. }
  427. void CXTEditListBox::MoveItemUp(int nIndex)
  428. {
  429. m_nIndex = nIndex; // Current index.
  430. int nNewIndex = m_nIndex - 1; // New index.
  432. // If there is a valid selection made, and the
  433. // selection is not the first item and...
  434. if ((m_nIndex != LB_ERR) && (m_nIndex != 0))
  435. {
  436. // Save the string for the item we are
  437. // going to swap position with.
  438. CString strItem;
  439. GetText(nNewIndex, strItem);
  441. // Save any item data.
  442. DWORD_PTR dwNewData = GetItemData(nNewIndex);
  444. // Remove both the new and current
  445. // index items...
  446. DeleteString(nNewIndex);
  448. // then swap and re-insert them into
  449. // the list box.
  450. InsertString(m_nIndex, strItem);
  452. // Restore any item data.
  453. SetItemData(m_nIndex, dwNewData);
  455. // Select the item at the new index.
  456. SetCurSel(nNewIndex);
  457. }
  459. // Set the focus back to the listbox.
  460. SetFocus();
  462. CWnd* pOwner = GetOwner();
  463. ASSERT(pOwner);
  464. if (!pOwner)
  465. return;
  467. // Send notification to owner.
  468. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  469. LBN_XT_MOVEITEMUP), (LPARAM)m_hWnd);
  470. }
  472. void CXTEditListBox::OnMoveItemDown()
  473. {
  474. int nIndex = GetCurSel();
  476. if (nIndex != LB_ERR)
  477. MoveItemDown(nIndex);
  478. }
  480. void CXTEditListBox::MoveItemDown(int nIndex)
  481. {
  482. m_nIndex = nIndex; // Current index.
  483. int nNewIndex = m_nIndex + 1; // New index.
  485. // If there is a valid selection made, and the
  486. // selection is not the last item and...
  487. if ((m_nIndex != LB_ERR) && (nNewIndex < GetCount()))
  488. {
  489. // Save the string for the current
  490. // selection.
  491. CString strCurItem;
  492. GetText(m_nIndex, strCurItem);
  494. // Save any item data.
  495. DWORD_PTR dwCurData = GetItemData(m_nIndex);
  497. // Remove both the new and current
  498. // index items...
  499. DeleteString(m_nIndex);
  501. // then swap and re-insert them into
  502. // the list box.
  503. InsertString(nNewIndex, strCurItem);
  505. // Restore any item data.
  506. SetItemData(nNewIndex, dwCurData);
  508. // Select the item at the new index.
  509. SetCurSel(nNewIndex);
  510. }
  512. // Set the focus back to the listbox.
  513. SetFocus();
  515. CWnd* pOwner = GetOwner();
  516. ASSERT(pOwner);
  517. if (!pOwner)
  518. return;
  520. // Send notification to owner.
  521. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  522. LBN_XT_MOVEITEMDOWN), (LPARAM)m_hWnd);
  523. }
  525. void CXTEditListBox::SetListEditStyle(UINT nTitle, DWORD dwLStyle/*= LBS_XT_DEFAULT*/)
  526. {
  527. CString string;
  528. VERIFY(string.LoadString(nTitle));
  529. SetListEditStyle(string, dwLStyle);
  530. }
  532. void CXTEditListBox::SetListEditStyle(LPCTSTR lpszTitle, DWORD dwLStyle/*= LBS_XT_DEFAULT*/)
  533. {
  534. m_strTitle = lpszTitle;
  535. m_dwLStyle = dwLStyle;
  537. if (m_editGroup.GetSafeHwnd())
  538. {
  539. m_editGroup.SetWindowText(m_strTitle);
  540. }
  541. }
  543. void CXTEditListBox::Initialize(bool bAutoFont/*= true*/)
  544. {
  545. CXTListBox::Initialize(bAutoFont);
  547. // get a pointer to the parent window.
  548. m_pParentWnd = GetParent();
  549. ASSERT_VALID(m_pParentWnd); // must be valid.
  551. // Create the edit toolbar group.
  552. if (!HasToolbar())
  553. return;
  555. // Create the toolbar.
  556. if (!CreateEditGroup(bAutoFont))
  557. return;
  559. // Resize the edit list which will also cause WM_WINDOWPOSCHANGED
  560. // to be called to position the toolbar.
  561. CXTPWindowRect rcWindow(this);
  562. rcWindow.top += BTN_OFFSET + ::GetSystemMetrics(SM_CXEDGE);
  563. m_pParentWnd->ScreenToClient(&rcWindow);
  565. ::SetWindowPos(GetSafeHwnd(), NULL, rcWindow.left, rcWindow.top,
  566. rcWindow.Width(), rcWindow.Height(), SWP_FRAMECHANGED);
  567. }
  569. BOOL CXTEditListBox::CreateEditGroup(bool bAutoFont)
  570. {
  571. // Create the edit button group that appears at the top of the
  572. // list edit control.
  573. DWORD dwStyle = (GetStyle() & WS_VISIBLE) | WS_CHILD |
  574. SS_CENTERIMAGE | SS_LEFT | SS_NOTIFY;
  576. if (!m_editGroup.CreateEx(WS_EX_STATICEDGE, _T("Static"), m_strTitle,
  577. dwStyle, CRect(0, 0, 0, 0), GetParent(), XT_IDC_GROUP_EDIT))
  578. {
  579. TRACE0("Unable to create caption.n");
  580. return FALSE;
  581. }
  583. m_editGroup.m_bShowUpDownButtons = ( (m_dwLStyle & LBS_XT_HIDE_UP_DOWN) == 0 );
  584. m_editGroup.m_bShowNewDeleteButtons = ( (m_dwLStyle & LBS_XT_ONLY_UP_DOWN) == 0 );
  586. m_editGroup.SetOwner(this);
  587. m_editGroup.Initialize(bAutoFont);
  589. // enable the window depending on the list box enabled state.
  590. m_editGroup.EnableWindow(IsWindowEnabled());
  592. return TRUE;
  593. }
  595. BOOL CXTEditListBox::PreTranslateMessage(MSG* pMsg)
  596. {
  597. // Send message to edit window if active.
  598. if (m_pItemEdit && ::IsWindow(m_pItemEdit->m_hWnd))
  599. {
  600. if (pMsg->wParam == VK_TAB)
  601. {
  602. SetFocus();
  603. return CWnd::PreTranslateMessage(pMsg);
  604. }
  606. return m_pItemEdit->PreTranslateMessage(pMsg);
  607. }
  609. if (pMsg->message == WM_KEYUP)
  610. {
  611. if (pMsg->wParam == VK_DELETE && GetCurSel() != LB_ERR)
  612. {
  613. OnDeleteItem();
  614. }
  615. if (pMsg->wParam == VK_INSERT)
  616. {
  617. OnNewItem();
  618. }
  619. }
  621. if (pMsg->message == WM_SYSKEYUP)
  622. {
  623. if ((pMsg->wParam == VK_UP) &&
  624. (::GetKeyState(VK_MENU) < 0) && GetCurSel() != LB_ERR)
  625. {
  626. OnMoveItemUp();
  627. }
  628. if ((pMsg->wParam == VK_DOWN) &&
  629. (::GetKeyState(VK_MENU) < 0) && GetCurSel() != LB_ERR)
  630. {
  631. OnMoveItemDown();
  632. }
  633. }
  635. return CWnd::PreTranslateMessage(pMsg);
  636. }
  638. void CXTEditListBox::OnLButtonDown(UINT nFlags, CPoint point)
  639. {
  640. CXTListBox::OnLButtonDown(nFlags, point);
  642. m_nIndex = GetCurSel();
  644. if (m_nIndex >= GetCount())
  645. {
  646. SetCurSel(GetCount() - 1);
  647. GetOwner()->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), LBN_SELCHANGE), (LPARAM)m_hWnd);
  648. }
  650. CRect rcItem;
  651. if (GetItemRect(m_nIndex, rcItem) != LB_ERR)
  652. {
  653. if (!rcItem.PtInRect(point))
  654. {
  655. CWnd* pOwner = GetOwner();
  656. ASSERT(pOwner);
  657. if (!pOwner)
  658. return;
  660. SetCurSel(-1);
  661. pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), LBN_SELCHANGE), (LPARAM)m_hWnd);
  662. }
  663. }
  664. }
  666. void CXTEditListBox::OnNcLButtonDown(UINT nHitTest, CPoint point)
  667. {
  668. if (m_pItemEdit)
  669. {
  670. m_pItemEdit->DestroyWindow();
  671. m_pItemEdit = NULL;
  672. }
  674. CListBox::OnNcLButtonDown(nHitTest, point);
  675. }
  677. void CXTEditListBox::OnNcMButtonDown(UINT nHitTest, CPoint point)
  678. {
  679. if (m_pItemEdit)
  680. {
  681. m_pItemEdit->DestroyWindow();
  682. m_pItemEdit = NULL;
  683. }
  685. CListBox::OnNcMButtonDown(nHitTest, point);
  686. }
  688. void CXTEditListBox::OnNcRButtonDown(UINT nHitTest, CPoint point)
  689. {
  690. if (m_pItemEdit)
  691. {
  692. m_pItemEdit->DestroyWindow();
  693. m_pItemEdit = NULL;
  694. }
  696. CListBox::OnNcRButtonDown(nHitTest, point);
  697. }
  699. void CXTEditListBox::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos)
  700. {
  701. CXTListBox::OnWindowPosChanged(lpwndpos);
  703. // adjust the toolbar size and location.
  704. RecalcLayout();
  705. }
  707. void CXTEditListBox::RecalcLayout()
  708. {
  709. if (HasToolbar() && ::IsWindow(m_editGroup.m_hWnd))
  710. {
  711. ASSERT_VALID(m_pParentWnd); // must be valid.
  713. CXTPWindowRect rcWindow(this);
  714. m_pParentWnd->ScreenToClient(&rcWindow);
  716. // move the group edit control.
  717. rcWindow.top -= BTN_OFFSET;
  718. rcWindow.bottom = rcWindow.top + BTN_OFFSET;
  720. ::SetWindowPos(m_editGroup.m_hWnd, NULL, rcWindow.left, rcWindow.top,
  721. rcWindow.Width(), rcWindow.Height(), SWP_FRAMECHANGED);
  722. }
  723. }
  725. void CXTEditListBox::OnEnable(BOOL bEnable)
  726. {
  727. CXTListBox::OnEnable(bEnable);
  729. if (HasToolbar() && ::IsWindow(m_editGroup.m_hWnd))
  730. m_editGroup.EnableWindow(bEnable);
  731. }
  733. void CXTEditListBox::OnShowWindow(BOOL bShow, UINT nStatus)
  734. {
  735. CXTListBox::OnShowWindow(bShow, nStatus);
  737. if (HasToolbar() && ::IsWindow(m_editGroup.m_hWnd))
  738. m_editGroup.ShowWindow(bShow ? SW_SHOW : SW_HIDE);
  739. }
  741. /////////////////////////////////////////////////////////////////////////////
  742. // CXTEditListBoxToolBar
  743. /////////////////////////////////////////////////////////////////////////////
  745. CXTEditListBoxToolBar::CXTEditListBoxToolBar()
  746. : m_bShowUpDownButtons(true)
  747. , m_bEnableEdit(true)
  748. , m_bShowNewDeleteButtons(true)
  749. {
  751. }
  753. CXTEditListBoxToolBar::~CXTEditListBoxToolBar()
  754. {
  755. }
  757. IMPLEMENT_DYNAMIC(CXTEditListBoxToolBar, CStatic)
  759. BEGIN_MESSAGE_MAP(CXTEditListBoxToolBar, CStatic)
  760. //{{AFX_MSG_MAP(CXTEditListBoxToolBar)
  761. ON_BN_CLICKED(XT_IDC_BTN_NEW, OnButtonNew)
  762. ON_BN_CLICKED(XT_IDC_BTN_DELETE, OnButtonDelete)
  763. ON_BN_CLICKED(XT_IDC_BTN_UP, OnButtonUp)
  764. ON_BN_CLICKED(XT_IDC_BTN_DOWN, OnButtonDown)
  765. ON_WM_WINDOWPOSCHANGED()
  766. ON_WM_ERASEBKGND()
  767. ON_WM_PAINT()
  768. ON_WM_ENABLE()
  769. ON_WM_SHOWWINDOW()
  770. ON_WM_NCPAINT()
  771. //}}AFX_MSG_MAP
  772. END_MESSAGE_MAP()
  774. BOOL CXTEditListBoxToolBar::PreTranslateMessage(MSG* pMsg)
  775. {
  776. // Let the ToolTip process this message.
  777. m_tooltip.RelayEvent(pMsg);
  778. return CStatic::PreTranslateMessage(pMsg);
  779. }
  781. static UINT _arButtonID[] =
  782. {
  783. XT_IDC_BTN_NEW,
  784. XT_IDC_BTN_DELETE,
  785. XT_IDC_BTN_UP,
  786. XT_IDC_BTN_DOWN,
  787. };
  789. void CXTEditListBoxToolBar::MoveButtons()
  790. {
  791. if (!::IsWindow(m_hWnd))
  792. return;
  794. // Set the initial size for the first button.
  795. CXTPClientRect rcClient(this);
  796. rcClient.left = rcClient.right-BTN_OFFSET;
  798. for (int i = _countof(m_arButton)-1; i >= 0 ; --i)
  799. {
  800. if (::IsWindow(m_arButton[i].GetSafeHwnd()))
  801. {
  802. m_arClipRect[i] = rcClient;
  804. ::SetWindowPos(m_arButton[i].GetSafeHwnd(), NULL, rcClient.left, rcClient.top,
  805. rcClient.Width(), rcClient.Height(), SWP_FRAMECHANGED);
  806. rcClient.OffsetRect(-BTN_OFFSET, 0);
  807. }
  808. else
  809. {
  810. m_arClipRect[i] = CRect(0, 0, 0, 0);
  811. }
  812. }
  814. Invalidate();
  815. }
  817. void CXTEditListBoxToolBar::SetXButtonStyle(DWORD dwxStyle, BOOL bRedraw/*= TRUE*/)
  818. {
  819. for (int i = 0; i < _countof(m_arButton); ++i)
  820. {
  821. if (::IsWindow(m_arButton[i].m_hWnd))
  822. {
  823. m_arButton[i].SetXButtonStyle(dwxStyle, bRedraw);
  824. if (dwxStyle == (BS_XT_FLAT | BS_XT_WINXP_COMPAT))
  825. m_arButton[i].SetTheme(new CXTToolbarButtonTheme);
  826. }
  827. }
  828. }
  830. void CXTEditListBoxToolBar::Initialize(bool bAutoFont/*= true*/)
  831. {
  832. // Create the ToolTip control.
  833. m_tooltip.Create(this);
  834. m_tooltip.Activate(TRUE);
  836. CImageList imageList;
  837. imageList.Create(14, 12, ILC_COLOR8 | ILC_MASK, 0, 1);
  839. CBitmap bmp;
  840. VERIFY(XTPResourceManager()->LoadBitmap(&bmp, XT_IDB_LISTEDIT));
  841. imageList.Add(&bmp, RGB(255, 0, 255));
  843. for (int i = 0; i < _countof(m_arButton); ++i)
  844. {
  845. if ((!m_bShowNewDeleteButtons) && ((i==0) || (i==1)))
  846. continue;
  848. if ((!m_bShowUpDownButtons) && ((i==2) || (i==3)))
  849. continue;
  851. if (!m_arButton[i].Create(NULL, WS_CHILD | WS_VISIBLE | BS_ICON | BS_OWNERDRAW | BS_CENTER | BS_VCENTER,
  852. CRect(0, 0, 0, 0), this, _arButtonID[i]))
  853. {
  854. TRACE0("Unable to create edit button.n");
  855. continue;
  856. }
  858. m_arIcon[i] = imageList.ExtractIcon(i);
  859. m_arButton[i].SetIcon(CSize(0), m_arIcon[i]);
  861. CString strToolTip;
  862. VERIFY(XTPResourceManager()->LoadString(&strToolTip, _arButtonID[i]));
  863. // Add tooltips to group buttons.
  864. m_tooltip.AddTool(&m_arButton[i], strToolTip);
  866. // make sure the button is Windows XP theme compatible using
  867. // the toolbar button theme.
  868. m_arButton[i].SetXButtonStyle(BS_XT_FLAT | BS_XT_WINXP_COMPAT);
  869. m_arButton[i].SetTheme(new CXTToolbarButtonTheme);
  870. }
  872. // Move the buttons to their correct location.
  873. MoveButtons();
  875. // Set the font for this window.
  876. if (bAutoFont)
  877. {
  878. SetFont(&XTAuxData().font);
  879. }
  880. }
  882. void CXTEditListBoxToolBar::SendCommand(UINT nCmdID)
  883. {
  884. if (m_bEnableEdit)
  885. {
  886. CWnd* pOwner = GetOwner();
  887. ASSERT(pOwner);
  889. if (pOwner) pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
  890. nCmdID), (LPARAM)m_hWnd);
  891. }
  892. }
  894. void CXTEditListBoxToolBar::OnButtonNew()
  895. {
  896. SendCommand(LBN_XT_NEWITEM);
  897. }
  899. void CXTEditListBoxToolBar::OnButtonDelete()
  900. {
  901. SendCommand(LBN_XT_DELETEITEM);
  902. }
  904. void CXTEditListBoxToolBar::OnButtonUp()
  905. {
  906. SendCommand(LBN_XT_MOVEITEMUP);
  907. }
  909. void CXTEditListBoxToolBar::OnButtonDown()
  910. {
  911. SendCommand(LBN_XT_MOVEITEMDOWN);
  912. }
  914. void CXTEditListBoxToolBar::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos)
  915. {
  916. CStatic::OnWindowPosChanged(lpwndpos);
  918. // Move the buttons to their correct location.
  919. MoveButtons();
  920. }
  922. BOOL CXTEditListBoxToolBar::OnEraseBkgnd(CDC* /*pDC*/)
  923. {
  924. return TRUE;
  925. }
  927. #ifndef WM_QUERYUISTATE
  928. #define WM_QUERYUISTATE     0x0129
  929. #define UISF_HIDEACCEL      0x2
  930. #endif
  932. #ifndef DT_HIDEPREFIX
  933. #define DT_HIDEPREFIX 0x00100000
  934. #endif //!DT_HIDEPREFIX
  936. void CXTEditListBoxToolBar::DrawText(CDC* pDC, CRect& rcClient)
  937. {
  938. // get the text for the control.
  939. CString strWindowText;
  940. GetWindowText(strWindowText);
  942. if (strWindowText.IsEmpty())
  943. return;
  945. // select the font into the device context.
  946. CXTPFontDC font(pDC, GetFont());
  948. CRect rcText(rcClient);
  949. rcText.left += 1;
  951. // determine if the text is drawn disabled.
  952. pDC->SetTextColor(GetXtremeColor(IsWindowEnabled() ? COLOR_BTNTEXT : COLOR_GRAYTEXT));
  953. pDC->SetBkMode(TRANSPARENT);
  955. DWORD dwFlags = DT_LEFT | DT_VCENTER | DT_SINGLELINE;
  957. if (SendMessage(WM_QUERYUISTATE) & UISF_HIDEACCEL)
  958. {
  959. dwFlags |= DT_HIDEPREFIX;
  960. }
  961. pDC->DrawText(strWindowText, rcText, dwFlags);
  962. }
  964. void CXTEditListBoxToolBar::OnNcPaint()
  965. {
  966. CXTPWinThemeWrapper wrpTreeView;
  967. wrpTreeView.OpenTheme(0, L"LISTBOX");
  968. if (wrpTreeView.IsAppThemed() && wrpTreeView.IsAppThemeReady() && (GetOwner()->GetExStyle() & WS_EX_CLIENTEDGE))
  969. {
  970. CXTPWindowRect rc(this);
  971. CXTPClientRect rcClient(this);
  973. COLORREF clr = GetXtremeColor(COLOR_BTNSHADOW);
  974. if (rc.Width() == rcClient.Width() + 2 &&
  975. SUCCEEDED(wrpTreeView.GetThemeColor(0, 0, TMT_BORDERCOLOR, &clr)))
  976. {
  977. CWindowDC dc(this);
  979. dc.FillSolidRect(0, 0, rc.Width(), 1, clr);
  980. dc.FillSolidRect(0, 0, 1, rc.Height(), clr);
  981. dc.FillSolidRect(rc.Width() - 1, 0, 1, rc.Height(), clr);
  982. dc.FillSolidRect(1, rc.Height() - 1, rc.Width() - 2, 1, GetXtremeColor(COLOR_3DFACE));
  983. return;
  984. }
  985. }
  987. Default();
  988. }
  990. void CXTEditListBoxToolBar::OnPaint()
  991. {
  992. CPaintDC dc(this); // device context for painting
  994. // Exclude the buttons from getting repainted.
  995. int i;
  996. for (i = 0; i < _countof(m_arClipRect); ++i)
  997. dc.ExcludeClipRect(&m_arClipRect[i]);
  999. CRect r;
  1000. GetClientRect(&r);
  1001. CXTPBufferDC memDC(dc, r);
  1002. memDC.FillSolidRect(r, GetXtremeColor(COLOR_3DFACE));
  1004. DrawText(&memDC, r);
  1005. }
  1007. void CXTEditListBoxToolBar::OnEnable(BOOL bEnable)
  1008. {
  1009. CStatic::OnEnable(bEnable);
  1011. for (int i = 0; i < _countof(m_arButton); ++i)
  1012. {
  1013. if (::IsWindow(m_arButton[i].GetSafeHwnd()))
  1014. {
  1015. m_arButton[i].EnableWindow(bEnable);
  1016. m_arButton[i].Invalidate();
  1017. }
  1018. }
  1020. Invalidate();
  1021. }
  1023. void CXTEditListBoxToolBar::OnShowWindow(BOOL bShow, UINT nStatus)
  1024. {
  1025. CStatic::OnShowWindow(bShow, nStatus);
  1027. for (int i = 0; i < _countof(m_arButton); ++i)
  1028. {
  1029. if (::IsWindow(m_arButton[i].GetSafeHwnd()))
  1030. m_arButton[i].ShowWindow(bShow ? SW_SHOW : SW_HIDE);
  1031. }
  1032. }