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

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

对话框与窗口

开发平台：

Visual C++

XTPControlComboBox.cpp：源码内容
  1. // XTPControlComboBox.cpp : implementation of the CXTPControlComboBox class.
  2. //
  3. // This file is a part of the XTREME COMMANDBARS 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/XTPDrawHelpers.h"
  24. #include "Common/XTPColorManager.h"
  25. #include "Common/XTPPropExchange.h"
  26. #include "Common/XTPVC80Helpers.h"
  27. #include "Common/XTPImageManager.h"
  28. #include "Common/XTPToolTipContext.h"
  30. #include "XTPControlComboBox.h"
  31. #include "XTPCommandBar.h"
  32. #include "XTPToolBar.h"
  33. #include "XTPCommandBars.h"
  34. #include "XTPPaintManager.h"
  35. #include "XTPMouseManager.h"
  36. #include "XTPControls.h"
  37. #include "XTPKeyboardManager.h"
  39. #ifdef _DEBUG
  40. #define new DEBUG_NEW
  41. #undef THIS_FILE
  42. static char THIS_FILE[] = __FILE__;
  43. #endif
  46. CXTPEdit::CRichEditContext::CRichEditContext()
  47. {
  48. m_hInstance = LoadLibraryA("RICHED20.DLL");
  49. m_bRichEdit2 = TRUE;
  51. if (m_hInstance)
  52. {
  53. #ifdef _UNICODE
  54. m_strClassName = _T("RichEdit20W");
  55. #else
  56. m_strClassName = _T("RichEdit20A");
  57. #endif
  58. }
  59. else
  60. {
  61. m_hInstance = LoadLibraryA("RICHED32.DLL");
  62. m_strClassName = _T("RICHEDIT");
  63. m_bRichEdit2 = FALSE;
  64. }
  65. }
  67. CXTPEdit::CRichEditContext::~CRichEditContext()
  68. {
  69. }
  71. CXTPEdit::CRichEditContext& CXTPEdit::GetRichEditContext()
  72. {
  73. static CRichEditContext s_RichContext;
  74. return s_RichContext;
  75. }
  77. // CXTPEdit
  79. IMPLEMENT_DYNCREATE(CXTPEdit, CEdit)
  81. CXTPEdit::CXTPEdit()
  82. {
  83. m_bImeMode = FALSE;
  84. m_bComposited = FALSE;
  85. m_bIgonoreEditChanged = FALSE;
  86. }
  88. BOOL CXTPEdit::IsCommandEnabled(UINT nID)
  89. {
  90. if (nID == ID_EDIT_PASTE)
  91. {
  92. return ((GetStyle() & (ES_READONLY | WS_DISABLED)) == 0) && ::IsClipboardFormatAvailable(CF_TEXT);
  93. }
  94. else if (nID == ID_EDIT_CUT || nID == ID_EDIT_COPY)
  95. {
  96. int nStartChar, nEndChar;
  97. GetSel(nStartChar, nEndChar);
  98. return (nStartChar != nEndChar) && ((nID == ID_EDIT_COPY) || ((GetStyle() & (ES_READONLY | WS_DISABLED)) == 0));
  99. }
  100. return TRUE;
  101. }
  103. BOOL CXTPEdit::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* /*pHandlerInfo*/)
  104. {
  105. if ((nID == ID_EDIT_PASTE || nID == ID_EDIT_CUT || nID == ID_EDIT_COPY) && (nCode == CN_UPDATE_COMMAND_UI))
  106. {
  107. CCmdUI* pCmdUI = (CCmdUI*)pExtra;
  108. pCmdUI->Enable(IsCommandEnabled(nID));
  109. return TRUE;
  110. }
  112. return FALSE;
  113. }
  115. BOOL CXTPEdit::OnCommand(WPARAM wParam, LPARAM)
  116. {
  117. UINT nID = LOWORD(wParam);
  119. if (nID == ID_EDIT_PASTE) Paste();
  120. else if (nID == ID_EDIT_COPY) Copy();
  121. else if (nID == ID_EDIT_CUT) Cut();
  122. else return FALSE;
  124. return TRUE;
  125. }
  127. BOOL CXTPEdit::ShowContextMenu(CXTPControl* pControl, CPoint point)
  128. {
  129. CString strPrompt;
  130. if (!strPrompt.LoadString(ID_EDIT_CUT))
  131. return FALSE;
  133. CXTPCommandBar* pParentBar = pControl->GetParent();
  135. CXTPCommandBars* pCommandBars = pParentBar->GetCommandBars();
  137. CXTPMouseManager* pMouseManager = pCommandBars ? pCommandBars->GetMouseManager() : XTPMouseManager();
  138. pMouseManager->UnlockMouseMove();
  140. ClientToScreen(&point);
  142. MSG msg;
  143. if (PeekMessage(&msg, m_hWnd, EM_SETSEL, EM_SETSEL, PM_NOREMOVE))
  144. {
  145. SendMessage(EM_SETSEL, 0, -1);
  146. }
  148. CXTPPopupBar* pPopupBar = CXTPPopupBar::CreatePopupBar(pCommandBars);
  149. CXTPControl* pControlCut = pPopupBar->GetControls()->Add(xtpControlButton, ID_EDIT_CUT);
  150. pControlCut->SetEnabled(IsCommandEnabled(ID_EDIT_CUT));
  151. CXTPControl* pControlCopy = pPopupBar->GetControls()->Add(xtpControlButton, ID_EDIT_COPY);
  152. pControlCopy->SetEnabled(IsCommandEnabled(ID_EDIT_COPY));
  153. CXTPControl* pControlPaste = pPopupBar->GetControls()->Add(xtpControlButton, ID_EDIT_PASTE);
  154. pControlPaste->SetEnabled(IsCommandEnabled(ID_EDIT_PASTE));
  156. pPopupBar->SetGrabFocus(FALSE);
  158. int nAlign = pControl->GetParent()->GetExStyle() & (WS_EX_LAYOUTRTL | WS_EX_RIGHT) ? TPM_RIGHTALIGN : TPM_LEFTALIGN;
  161. int nCommand = CXTPCommandBars::TrackPopupMenu(pPopupBar, TPM_NONOTIFY | TPM_RECURSE | TPM_RETURNCMD | nAlign, point.x, point.y, this, NULL, this);
  163. if (nCommand > 0)
  164. {
  165. OnCommand(nCommand, 0);
  166. }
  168. pMouseManager->LockMouseMove();
  170. pPopupBar->InternalRelease();
  172. if (pParentBar->GetSafeHwnd())
  173. {
  174. pParentBar->Redraw();
  175. pParentBar->UpdateWindow();
  176. }
  178. return TRUE;
  179. }
  181. BOOL CXTPEdit::CreateEdit(DWORD dwStyle, CWnd* pParentWnd)
  182. {
  183. if (GetRichEditContext().m_hInstance)
  184. {
  185. BOOL bResult = CWnd::Create(GetRichEditContext().m_strClassName, 0, dwStyle, CRect(0, 0, 0, 0), pParentWnd, 0);
  186. SendMessage(EM_SETEVENTMASK, 0, ENM_CHANGE);
  187. SendMessage(EM_SETTEXTMODE, TM_PLAINTEXT | TM_SINGLELEVELUNDO);
  189. return bResult;
  190. }
  192. return Create(dwStyle, CRect(0, 0, 0, 0), pParentWnd, 0);
  193. }
  195. BOOL CXTPEdit::IsDialogCode(UINT nChar, LPARAM lParam)
  196. {
  197. const BOOL bNavigateKeys = (nChar == VK_BACK) || (nChar >= VK_PRIOR && nChar <= VK_DELETE) ||
  198. ((nChar == 'C' || nChar == 'V' || nChar == 'X' || nChar == 'Z') && (GetKeyState(VK_CONTROL) < 0));
  200. if (!bNavigateKeys)
  201. return FALSE;
  203. MSG msg;
  204. msg.message = WM_KEYDOWN;
  205. msg.hwnd = m_hWnd;
  206. msg.wParam = (WPARAM)nChar;
  207. msg.lParam = lParam;
  209. if (IsDialogMessage(&msg))
  210. return TRUE;
  212. return FALSE;
  213. }
  215. void CXTPEdit::SetWindowTextEx(LPCTSTR lpszString)
  216. {
  217. m_bIgonoreEditChanged = TRUE;
  218. SetWindowText(0);
  219. m_bIgonoreEditChanged = FALSE;
  220. SetWindowText(lpszString);
  221. }
  224. void CXTPEdit::GetWindowTextEx(CString& rString)
  225. {
  226. #ifdef _UNICODE
  227. if (GetRichEditContext().m_bRichEdit2)
  228. {
  229. GETTEXTLENGTHEX gtl =
  230. {
  231. GTL_DEFAULT, 1200
  232. };
  234. int nLen = (int)SendMessage(EM_GETTEXTLENGTHEX, (WPARAM)&gtl);
  236. if (nLen > 0)
  237. {
  238. GETTEXTEX gt =
  239. {
  240. (nLen + 1) * sizeof(TCHAR), GT_DEFAULT, 1200, 0, 0
  241. };
  243. SendMessage(EM_GETTEXTEX, (WPARAM)&gt, (LPARAM)rString.GetBufferSetLength(nLen));
  244. rString.ReleaseBuffer();
  245. }
  246. else
  247. {
  248. rString.Empty();
  249. }
  250. }
  251. else
  252. #endif
  253. {
  254. GetWindowText(rString);
  255. }
  256. }
  258. BEGIN_MESSAGE_MAP(CXTPEdit, CEdit)
  259. ON_MESSAGE_VOID(WM_IME_STARTCOMPOSITION, OnImeStartComposition)
  260. ON_MESSAGE_VOID(WM_IME_ENDCOMPOSITION, OnImeEndComposition)
  261. ON_WM_KILLFOCUS()
  262. ON_WM_PAINT()
  263. END_MESSAGE_MAP()
  265. void CXTPEdit::OnImeStartComposition()
  266. {
  267. Default();
  268. m_bImeMode = TRUE;
  269. }
  271. void CXTPEdit::OnImeEndComposition()
  272. {
  273. Default();
  274. m_bImeMode = FALSE;
  275. }
  277. void CXTPEdit::OnKillFocus(CWnd* pNewWnd)
  278. {
  279. CEdit::OnKillFocus(pNewWnd);
  280. m_bImeMode = FALSE;
  281. }
  283. void CXTPEdit::OnPaint()
  284. {
  285. Default();
  287. if (m_bComposited)
  288. {
  289. CClientDC dc(this);
  290. CXTPPaintManager::FillCompositeAlpha(&dc, CXTPClientRect(this));
  291. }
  292. }
  295. //////////////////////////////////////////////////////////////////////////
  296. // CXTPControlComboBoxAutoCompleteWnd
  299. HHOOK CXTPControlComboBoxAutoCompleteWnd::m_hHookMessage = 0;
  300. CXTPControlComboBoxAutoCompleteWnd* CXTPControlComboBoxAutoCompleteWnd::m_pWndMonitor = 0;
  302. #define WM_XTP_SHELLAUTOCOMPLETESTART (WM_XTP_COMMANDBARS_BASE + 30)
  304. CXTPControlComboBoxAutoCompleteWnd::CXTPControlComboBoxAutoCompleteWnd()
  305. {
  306. m_hWndAutoComplete = 0;
  307. m_hWndEdit = 0;
  308. }
  310. CXTPControlComboBoxAutoCompleteWnd::~CXTPControlComboBoxAutoCompleteWnd()
  311. {
  312. SetupMessageHook(FALSE);
  313. SetAutoCompeteHandle(NULL);
  314. }
  316. BOOL CXTPControlComboBoxAutoCompleteWnd::IsDialogCode(UINT nChar, LPARAM lParam)
  317. {
  318. if (!m_hWndAutoComplete)
  319. return FALSE;
  321. if (! ((nChar == VK_UP || nChar == VK_DOWN || nChar == VK_NEXT || nChar == VK_PRIOR) && (GetKeyState(VK_MENU) >= 0)))
  322. return FALSE;
  324. HWND hWnd = ::GetWindow(m_hWndAutoComplete, GW_CHILD);
  325. hWnd = ::GetWindow(hWnd, GW_HWNDLAST);
  327. MSG msg;
  328. msg.message = WM_KEYDOWN;
  329. msg.hwnd = hWnd;
  330. msg.wParam = (WPARAM)nChar;
  331. msg.lParam = lParam;
  333. if (::IsDialogMessage(m_hWndAutoComplete, &msg))
  334. return TRUE;
  336. return FALSE;
  337. }
  340. HRESULT CXTPControlComboBoxAutoCompleteWnd::ShellAutoComplete(HWND hEdit, DWORD dwFlags)
  341. {
  342. m_hWndEdit = hEdit;
  343. HRESULT hResult = E_FAIL;
  345. HMODULE hLib = LoadLibraryA("shlwapi.dll");
  346. if (hLib)
  347. {
  348. typedef HRESULT (STDAPICALLTYPE *SHAUTOCOMPLETE)(HWND hwndEdit, DWORD dwFlags);
  350. SHAUTOCOMPLETE _SHAutoComplete = NULL;
  351. _SHAutoComplete = (SHAUTOCOMPLETE)GetProcAddress(hLib, "SHAutoComplete");
  353. if (_SHAutoComplete)
  354. {
  355. hResult = _SHAutoComplete(hEdit, dwFlags);
  356. }
  358. FreeLibrary(hLib);
  359. }
  361. return hResult;
  362. }
  364. void CXTPControlComboBoxAutoCompleteWnd::CloseWindow()
  365. {
  366. if (m_hWndAutoComplete)
  367. {
  368. ShowWindow(m_hWndAutoComplete, SW_HIDE);
  369. }
  370. }
  372. void CXTPControlComboBoxAutoCompleteWnd::SetAutoCompeteHandle(HWND hWnd)
  373. {
  374. if (m_hWndAutoComplete == hWnd)
  375. return;
  377. if (hWnd)
  378. {
  379. XTPMouseManager()->AddTrustedWindow(hWnd);
  380. }
  381. else
  382. {
  383. XTPMouseManager()->RemoveTrustedWindow(m_hWndAutoComplete);
  384. }
  386. m_hWndAutoComplete = hWnd;
  387. }
  389. void CXTPControlComboBoxAutoCompleteWnd::SetupMessageHook(BOOL bSetup)
  390. {
  391. if (bSetup && m_hHookMessage == 0)
  392. {
  393. ASSERT(m_pWndMonitor == NULL);
  394. m_hHookMessage = SetWindowsHookEx(WH_CALLWNDPROC, CallWndProc, AfxGetInstanceHandle(), GetCurrentThreadId());
  395. XTPKeyboardManager()->HookKeyboard(this);
  396. m_pWndMonitor = this;
  397. }
  399. if (!bSetup && m_hHookMessage && (m_pWndMonitor == this))
  400. {
  401. UnhookWindowsHookEx(m_hHookMessage);
  402. XTPKeyboardManager()->UnhookKeyboard(m_pWndMonitor);
  403. m_hHookMessage = 0;
  404. m_pWndMonitor = NULL;
  405. }
  407. if (!bSetup)
  408. {
  409. SetAutoCompeteHandle(NULL);
  410. }
  411. }
  413. int CXTPControlComboBoxAutoCompleteWnd::OnHookMessage(HWND /*hWnd*/, UINT nMessage, WPARAM& /*wParam*/, LPARAM& /*lParam*/, LRESULT& /*lResult*/)
  414. {
  415. if (nMessage == WM_MOUSEWHEEL && m_hWndAutoComplete)
  416. return FALSE_EXIT;
  418. return FALSE;
  419. }
  421. LRESULT CALLBACK CXTPControlComboBoxAutoCompleteWnd::CallWndProc(int code, WPARAM wParam, LPARAM lParam)
  422. {
  423. CWPSTRUCT* pMSG = (CWPSTRUCT*)lParam;
  425. if (pMSG && m_pWndMonitor && pMSG->message == WM_WINDOWPOSCHANGING)
  426. {
  427. const HWND& hWndAutoComplete = m_pWndMonitor->m_hWndAutoComplete;
  428. WINDOWPOS* pWindowPos = (WINDOWPOS*)pMSG->lParam;
  430. if ((hWndAutoComplete != 0 && hWndAutoComplete == pWindowPos->hwnd) && (pWindowPos->flags & SWP_HIDEWINDOW))
  431. {
  432. m_pWndMonitor->SetAutoCompeteHandle(NULL);
  433. }
  434. else if ((hWndAutoComplete == 0) && (pWindowPos->flags & SWP_SHOWWINDOW))
  435. {
  436. HWND hWnd = pWindowPos->hwnd;
  437. TCHAR szClassName[255];
  438. ::GetClassName(hWnd, szClassName, 255);
  440. if (_tcscmp(szClassName, _T("Auto-Suggest Dropdown")) == 0)
  441. {
  442. m_pWndMonitor->SetAutoCompeteHandle(hWnd);
  443. PostMessage(m_pWndMonitor->m_hWndEdit, WM_XTP_SHELLAUTOCOMPLETESTART, 0, 0);
  444. }
  445. }
  446. }
  448. return CallNextHookEx(m_hHookMessage, code, wParam, lParam);
  449. }
  453. // CXTPControlComboBox
  455. IMPLEMENT_XTP_CONTROL(CXTPControlComboBox, CXTPControlPopup)
  457. CXTPControlComboBox::CXTPControlComboBox(CXTPCommandBars* pCommandBars)
  458. {
  459. EnableAutomation();
  461. m_controlType = xtpControlComboBox;
  462. m_bDropDown = FALSE;
  463. m_comboStyle = xtpComboNormal;
  464. m_nWidth = 100;
  465. m_nLabelWidth = 0;
  466. m_nThumbWidth = 0;
  467. m_pEdit = NULL;
  468. m_strEditText = _T("");
  469. m_nCurSel = m_nLastSel = -1;
  470. m_bDelayReposition = FALSE;
  471. m_bDelayDestroy = FALSE;
  472. m_bIgnoreAutoComplete = m_bAutoComplete = FALSE;
  473. m_bFocused = FALSE;
  474. m_nDropDownItemCount = 12;
  475. m_bIgnoreSelection = FALSE;
  477. m_pCommandBar = new CXTPControlComboBoxList();
  478. m_pCommandBar->SetCommandBars(pCommandBars);
  480. ((CXTPControlComboBoxList*)m_pCommandBar)->CreateListBox();
  482. m_dwShellAutoCompleteFlags = 0;
  484. m_pAutoCompleteWnd = NULL;
  485. m_nEditIconId = 0;
  486. m_bSelEndOk = FALSE;
  487. m_bEditChanged = TRUE;
  489. m_dwEditStyle = 0;
  490. }
  492. CXTPControlComboBox::~CXTPControlComboBox()
  493. {
  494. if (m_pEdit)
  495. {
  496. delete m_pEdit;
  497. }
  498. SAFE_DELETE(m_pAutoCompleteWnd);
  499. }
  501. CString CXTPControlComboBox::GetEditText() const
  502. {
  503. CString strEditText = _GetEditText();
  505. return strEditText == GetEditHint() ? _T("") : strEditText;
  506. }
  508. CString CXTPControlComboBox::_GetEditText() const
  509. {
  510. if (m_pEdit && m_pEdit->GetSafeHwnd() && m_bEditChanged)
  511. {
  512. m_pEdit->GetWindowTextEx(m_strEditText);
  513. m_bEditChanged = FALSE;
  514. }
  516. return m_strEditText;
  517. }
  519. void CXTPControlComboBox::SetEditText(const CString& strText)
  520. {
  521. _SetEditText(strText.IsEmpty() ? GetEditHint() : strText);
  522. }
  524. void CXTPControlComboBox::_SetEditText(const CString& strText)
  525. {
  526. if (m_pEdit && m_pEdit->GetSafeHwnd() && _GetEditText() != strText)
  527. {
  528. m_pEdit->SetWindowTextEx(strText);
  529. }
  530. m_strEditText = strText;
  531. m_bEditChanged = FALSE;
  532. }
  534. void CXTPControlComboBox::SetEditHint(LPCTSTR lpszEditHint)
  535. {
  536. if (!GetEditHint().IsEmpty() && _GetEditText() == GetEditHint())
  537. {
  538. _SetEditText(_T(""));
  539. }
  541. m_strEditHint = lpszEditHint;
  543. if (_GetEditText().IsEmpty() && !GetEditHint().IsEmpty())
  544. {
  545. _SetEditText(GetEditHint());
  546. }
  547. }
  549. BOOL CXTPControlComboBox::IsImageVisible() const
  550. {
  551. if (GetParent()->GetType() == xtpBarTypePopup)
  552. return GetImage(0) != NULL;
  554. BOOL bImageVisible = (CXTPControl::GetStyle() == xtpButtonIcon || CXTPControl::GetStyle() == xtpButtonIconAndCaption)
  555. && (GetImage(0) != NULL);
  557. return bImageVisible;
  558. }
  560. BOOL CXTPControlComboBox::IsCaptionVisible() const
  561. {
  562. if (GetParent()->GetType() == xtpBarTypePopup)
  563. return TRUE;
  565. if (GetCaption().IsEmpty())
  566. return FALSE;
  568. XTPButtonStyle buttonStyle = CXTPControl::GetStyle();
  570. if ((buttonStyle == xtpButtonCaption) || (buttonStyle == xtpButtonIconAndCaption) || (buttonStyle == xtpButtonIconAndCaptionBelow))
  571. return TRUE;
  573. return m_comboStyle == xtpComboLabel;
  574. }
  576. CString CXTPControlComboBox::GetEditHint() const
  577. {
  578. return !m_strEditHint.IsEmpty() ? m_strEditHint : m_pAction ? m_pAction->GetEditHint() : _T("");
  579. }
  581. void CXTPControlComboBox::UpdatePopupSelection()
  582. {
  583. CEdit* pEdit = GetEditCtrl();
  584. CXTPControlComboBoxPopupBar* pPopupBar = GetComboBoxPopupBar();
  586. if (!m_bIgnoreSelection && pEdit && pEdit->GetSafeHwnd() && pPopupBar)
  587. {
  588. CString strWindowText = _GetEditText();
  590. int nIndex = pPopupBar->FindStringExact(0, strWindowText);
  591. if (nIndex != LB_ERR)
  592. pPopupBar->SetCurSel(nIndex);
  593. else
  594. {
  595. nIndex = pPopupBar->FindString(0, strWindowText);
  596. pPopupBar->SetTopIndex(nIndex);
  597. pPopupBar->SetCurSel(nIndex);
  598. pPopupBar->SetCurSel(-1);
  599. }
  600. }
  601. }
  603. void CXTPControlComboBox::OnEditChanged()
  604. {
  605. CEdit* pEdit = GetEditCtrl();
  607. CXTPControlComboBoxPopupBar* pPopupBar = GetComboBoxPopupBar();
  609. if (!m_bIgnoreSelection && m_bAutoComplete && !m_bIgnoreAutoComplete && pEdit && pEdit->GetSafeHwnd() && pPopupBar)
  610. {
  611. CString strWindowText = _GetEditText();
  612. int nLength = strWindowText.GetLength();
  614. if (nLength > 0)
  615. {
  616. // Currently selected range
  617. int nStart = 0, nEnd = 0;
  618. pEdit->GetSel(nStart, nEnd);
  620. if (nStart == nEnd && nLength == nEnd)
  621. {
  622. int nIndex = pPopupBar->FindString(0, strWindowText);
  623. if (nIndex != LB_ERR)
  624. {
  625. CString strWindowTextNew;
  626. pPopupBar->GetText(nIndex, strWindowTextNew);
  628. _SetEditText(strWindowTextNew);
  629. pEdit->SetSel(strWindowTextNew.GetLength(), nLength);
  630. }
  632. }
  633. }
  634. m_bIgnoreAutoComplete = TRUE;
  635. }
  637. UpdatePopupSelection();
  639. NotifySite(CBN_EDITCHANGE);
  640. }
  644. void CXTPControlComboBox::OnSelChanged()
  645. {
  646. m_bIgnoreSelection = TRUE;
  647. _SetEditText(GetListBoxText());
  648. m_bIgnoreSelection = FALSE;
  650. RedrawParent(FALSE);
  652. NotifySite(CBN_SELCHANGE);
  653. }
  655. BOOL CXTPControlComboBox::OnHookMouseWheel(UINT /*nFlags*/, short zDelta, CPoint /*pt*/)
  656. {
  657. if (!IsFocused())
  658. return FALSE;
  660. if (GetDroppedState())
  661. return FALSE;
  663. if (m_pAutoCompleteWnd)
  664. return FALSE;
  666. if (!IsValidList())
  667. return FALSE;
  669. ((CXTPControlComboBoxPopupBar*)m_pCommandBar)->ProcessHookKeyDown(this, zDelta > 0 ? VK_UP : VK_DOWN, 0);
  670. return TRUE;
  671. }
  673. BOOL CXTPControlComboBox::OnHookKeyDown(UINT nChar, LPARAM lParam)
  674. {
  675. ASSERT(IsFocused());
  677. if (!IsFocused())
  678. return FALSE;
  680. m_bIgnoreAutoComplete = (nChar == VK_DELETE) || (nChar == VK_BACK);
  682. if (m_pEdit && m_pEdit->m_bImeMode)
  683. return FALSE_EXIT;
  685. if (nChar == VK_TAB && ((m_pAutoCompleteWnd == NULL) || ((m_dwShellAutoCompleteFlags & SHACF_USETAB) == 0)))
  686. return FALSE;
  688. if (nChar == VK_RETURN)
  689. return FALSE;
  691. if (nChar == VK_ESCAPE)
  692. {
  693. m_pCommandBar->OnTrackLost();
  695. SetCurSel(m_nLastSel);
  696. SetEditText(m_strLastText);
  698. SetFocused(FALSE);
  700. return GetParent()->GetType() == xtpBarTypePopup;
  701. }
  703. if (m_pEdit && m_pEdit->GetSafeHwnd() && GetKeyState(VK_MENU) < 0 && GetKeyState(VK_CONTROL) >= 0)
  704. {
  705. CXTPCommandBars* pCommandBars = m_pParent->GetCommandBars();
  706. if (pCommandBars && pCommandBars->OnFrameAccel((TCHAR)nChar))
  707. return TRUE;
  708. }
  710. if ((nChar == VK_F4 && GetKeyState(VK_MENU) >= 0) || ((nChar == VK_UP || nChar == VK_DOWN) && GetKeyState(VK_MENU) < 0))
  711. {
  712. OnClick(FALSE);
  713. return TRUE;
  714. }
  716. if (m_pAutoCompleteWnd && m_pAutoCompleteWnd->IsDialogCode(nChar, lParam))
  717. return TRUE;
  719. if ((!m_pEdit || (nChar == VK_UP || nChar == VK_DOWN || nChar == VK_NEXT || nChar == VK_PRIOR) && (GetKeyState(VK_MENU) >= 0)) && IsValidList())
  720. {
  721. ((CXTPControlComboBoxPopupBar*)m_pCommandBar)->ProcessHookKeyDown(this, nChar, lParam);
  722. return TRUE;
  723. }
  725. if (m_pEdit && m_pEdit->GetSafeHwnd() && m_pEdit->IsDialogCode(nChar, lParam))
  726. {
  727. return TRUE;
  728. }
  730. return FALSE_EXIT;
  731. }
  733. BOOL CXTPControlComboBox::GetDropDownListStyle() const
  734. {
  735. return m_pEdit != NULL;
  736. }
  738. CXTPControlComboBoxEditCtrl* CXTPControlComboBox::CreateEditControl()
  739. {
  740. return new CXTPControlComboBoxEditCtrl();
  741. }
  743. void CXTPControlComboBox::SetDropDownListStyle(BOOL bSet)
  744. {
  745. m_bDropDown = bSet;
  747. if (bSet && m_pEdit == NULL)
  748. {
  749. m_pEdit = CreateEditControl();
  750. m_pEdit->m_pControl = this;
  751. }
  752. else if (!bSet && m_pEdit != NULL)
  753. {
  754. delete m_pEdit;
  755. m_pEdit = NULL;
  756. }
  757. }
  759. void CXTPControlComboBox::EnableShellAutoComplete(DWORD dwFlags /*= SHACF_FILESYSTEM | SHACF_URLALL*/)
  760. {
  761. m_dwShellAutoCompleteFlags = dwFlags;
  762. SAFE_DELETE(m_pAutoCompleteWnd);
  764. if (m_pEdit->GetSafeHwnd() && dwFlags)
  765. {
  766. m_pAutoCompleteWnd = new CXTPControlComboBoxAutoCompleteWnd();
  768. if (FAILED(m_pAutoCompleteWnd->ShellAutoComplete(m_pEdit->GetSafeHwnd(), m_dwShellAutoCompleteFlags)))
  769. {
  770. SAFE_DELETE(m_pAutoCompleteWnd);
  771. }
  772. }
  773. }
  775. void CXTPControlComboBox::EnableAutoComplete(BOOL bAutoComplete /*= TRUE*/)
  776. {
  777. m_bAutoComplete = bAutoComplete;
  778. }
  781. void CXTPControlComboBox::SetRect(CRect rcControl)
  782. {
  783. CString strEditText = GetEditText();
  785. if (m_bDelayDestroy && m_pEdit && m_pEdit->GetSafeHwnd())
  786. {
  787. m_pEdit->DestroyWindow();
  788. m_bDelayDestroy = FALSE;
  789. }
  790. if (m_pEdit && m_pEdit->GetSafeHwnd() && m_pEdit->GetExStyle() & WS_EX_LAYOUTRTL)
  791. {
  792. m_pEdit->DestroyWindow();
  793. }
  795. if (m_pEdit && m_pEdit->GetSafeHwnd() && m_pEdit->GetParent() != m_pParent)
  796. {
  797. m_pEdit->DestroyWindow();
  798. }
  800. if (m_rcControl == rcControl && !(m_pEdit && !m_pEdit->GetSafeHwnd()) && (m_bDelayReposition == FALSE))
  801. {
  802. if (!(m_pEdit && m_pEdit->GetSafeHwnd() && m_pEdit->GetParent() != m_pParent))
  803. return;
  804. }
  806. m_rcControl = rcControl;
  808. if (m_pEdit)
  809. {
  810. if (!m_pEdit->GetSafeHwnd())
  811. {
  812. m_pEdit->CreateEdit(WS_CHILD | ES_AUTOHSCROLL | m_dwEditStyle, m_pParent);
  814. if (!GetEnabled()) m_pEdit->EnableWindow(FALSE);
  816. if (m_dwShellAutoCompleteFlags != 0) EnableShellAutoComplete(m_dwShellAutoCompleteFlags);
  817. }
  819. m_pEdit->SetFont(GetPaintManager()->GetIconFont(), FALSE);
  820. m_pEdit->SetMargins(0, 0);
  821. m_pEdit->UpdateCharFormat();
  822. if (m_pEdit->GetSafeHwnd() != ::GetFocus()) SetEditText(strEditText);
  823. m_pEdit->m_bComposited = HasDwmCompositedRect();
  825. rcControl.DeflateRect(m_nLabelWidth + 1 + 3, 3, m_nThumbWidth + 3, 3);
  826. DeflateEditRect(rcControl);
  827. m_pEdit->MoveWindow(rcControl);
  828. ShowHideEditControl();
  829. }
  830. m_bDelayReposition = FALSE;
  831. }
  833. void CXTPControlComboBox::ShowHideEditControl()
  834. {
  835. if (m_pEdit && m_pEdit->GetSafeHwnd())
  836. {
  837. m_pEdit->SetWindowPos(0, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE
  838. | (m_pControls && m_pParent && IsVisible() && m_pParent->GetSafeHwnd() ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
  839. }
  840. }
  842. void CXTPControlComboBox::OnRemoved()
  843. {
  844. ShowHideEditControl();
  846. if (!m_pControls && m_pEdit && m_pEdit->GetSafeHwnd())
  847. {
  848. m_pEdit->DestroyWindow();
  849. }
  851. CXTPControlPopup::OnRemoved();
  852. }
  854. void CXTPControlComboBox::SetEnabled(BOOL bEnabled)
  855. {
  856. if (bEnabled != m_bEnabled)
  857. {
  858. m_bEnabled = bEnabled;
  859. if (m_pEdit && m_pEdit->GetSafeHwnd())
  860. {
  861. m_pEdit->EnableWindow(GetEnabled());
  862. m_pEdit->UpdateCharFormat();
  863. }
  865. RedrawParent();
  866. }
  867. }
  869. void CXTPControlComboBox::SetParent(CXTPCommandBar* pParent)
  870. {
  871. if (pParent != m_pParent && pParent)
  872. {
  873. CWnd* pSite = pParent->GetSite();
  874. if (pSite)
  875. SetWindowLongPtr(m_pCommandBar->GetSafeHwnd(), GWLP_HWNDPARENT, (LONG_PTR)pSite->GetSafeHwnd());
  876. }
  877. if (!pParent && m_pEdit && m_pEdit->GetSafeHwnd())
  878. {
  879. m_pEdit->DestroyWindow();
  881. }
  882. CXTPControlPopup::SetParent(pParent);
  883. }
  885. BOOL  CXTPControlComboBox::OnSetSelected(int bSelected)
  886. {
  887. if (!CXTPControl::OnSetSelected(bSelected))
  888. return FALSE;
  890. if (!bSelected)
  891. {
  892. SetFocused(FALSE);
  893. }
  895. if (!bSelected && m_bPopup && GetParent()->GetPosition() != xtpBarPopup)
  896. {
  897. m_pParent->SetPopuped(-1);
  898. }
  900. if (m_pEdit->GetSafeHwnd())
  901. {
  902. m_pEdit->UpdateCharFormat();
  903. }
  905. return TRUE;
  906. }
  908. BOOL CXTPControlComboBox::HasFocus() const
  909. {
  910. return IsFocused() || (m_pCommandBar->IsTrackingMode()) || m_pParent->GetCommandBars()->GetMouseManager()->IsMouseLocked();
  911. }
  913. BOOL CXTPControlComboBox::IsFocusable() const
  914. {
  915. return TRUE;
  916. }
  918. void CXTPControlComboBox::OnClick(BOOL bKeyboard , CPoint pt)
  919. {
  920. if (m_pEdit && m_pEdit->m_bImeMode)
  921. return;
  923. if (IsCustomizeMode())
  924. {
  925. m_pParent->SetPopuped(-1);
  926. m_pParent->SetSelected(-1);
  927. CustomizeStartDrag(pt);
  928. }
  929. else if (bKeyboard && GetEnabled())
  930. {
  931. if (IsFocused())
  932. {
  933. OnExecute();
  934. }
  935. else
  936. {
  937. SetFocused(TRUE);
  938. }
  939. }
  940. else if (m_bPopup && IsFocused())
  941. {
  942. m_pParent->SetPopuped(-1);
  944. }
  945. else CXTPControlPopup::OnClick(bKeyboard, pt);
  946. }
  948. void CXTPControlComboBox::OnUnderlineActivate()
  949. {
  950. m_pParent->HideKeyboardTips();
  951. SetFocused(TRUE);
  952. }
  954. void CXTPControlComboBox::OnMouseHover()
  955. {
  956. }
  958. void CXTPControlComboBox::SetHideFlags(DWORD dwFlags)
  959. {
  960. if (m_dwHideFlags != dwFlags)
  961. {
  962. m_dwHideFlags = dwFlags;
  964. ShowHideEditControl();
  965. DelayLayoutParent();
  966. }
  967. }
  969. void CXTPControlComboBox::OnActionChanged(int nProperty)
  970. {
  971. if (nProperty == 2)    // Visible
  972. {
  973. ShowHideEditControl();
  974. }
  976. if (nProperty == 0 && m_pEdit && m_pEdit->GetSafeHwnd())    // Enabled
  977. {
  978. m_pEdit->EnableWindow(GetEnabled());
  979. m_pEdit->UpdateCharFormat();
  980. }
  982. if (nProperty == 4) // EditHint
  983. {
  984. if (_GetEditText().IsEmpty() && !GetEditHint().IsEmpty())
  985. {
  986. _SetEditText(GetEditHint());
  987. }
  988. }
  989. }
  991. void CXTPControlComboBox::OnActionChanging(int nProperty)
  992. {
  993. if (nProperty == 4 && !GetEditHint().IsEmpty() && _GetEditText() == GetEditHint())
  994. {
  995. _SetEditText(_T(""));
  996. }
  997. }
  999. void CXTPControlComboBox::OnCalcDynamicSize(DWORD dwMode)
  1000. {
  1001. if (dwMode & LM_VERTDOCK) SetHideFlags(m_dwHideFlags | xtpHideDockingPosition);
  1002. else SetHideFlags(m_dwHideFlags & ~xtpHideDockingPosition);
  1003. }
  1005. DWORD CXTPControlComboBox::GetEditStyle() const
  1006. {
  1007. return m_dwEditStyle;
  1008. }
  1010. void CXTPControlComboBox::SetEditStyle(DWORD dwStyle)
  1011. {
  1012. m_dwEditStyle = dwStyle;
  1014. if (m_pEdit && m_pEdit->GetSafeHwnd())
  1015. {
  1016. m_bDelayDestroy = TRUE;
  1017. DelayLayoutParent();
  1018. }
  1019. }
  1022. void CXTPControlComboBox::Copy(CXTPControl* pControl, BOOL bRecursive)
  1023. {
  1024. CXTPControlComboBox* pControlCombo = DYNAMIC_DOWNCAST(CXTPControlComboBox, pControl);
  1025. ASSERT(pControlCombo);
  1026. if (!pControlCombo)
  1027. {
  1028. CXTPControlPopup::Copy(pControl, bRecursive);
  1029. return;
  1030. }
  1032. m_dwEditStyle = pControlCombo->m_dwEditStyle;
  1033. m_comboStyle = pControlCombo->m_comboStyle;
  1035. SetEditText(pControlCombo->GetEditText());
  1036. SetEditHint(pControlCombo->m_strEditHint);
  1037. SetDropDownListStyle(pControlCombo->m_pEdit != NULL);
  1038. m_bAutoComplete = pControlCombo->m_bAutoComplete;
  1039. EnableShellAutoComplete(pControlCombo->m_dwShellAutoCompleteFlags);
  1040. m_nEditIconId = pControlCombo->m_nEditIconId;
  1041. m_nDropDownItemCount = pControlCombo->m_nDropDownItemCount;
  1043. CXTPControlPopup::Copy(pControl, bRecursive);
  1044. }
  1046. BOOL CXTPControlComboBox::Compare(CXTPControl* pOther)
  1047. {
  1048. if (!CXTPControlPopup::Compare(pOther))
  1049. return FALSE;
  1051. if (!pOther->IsKindOf(RUNTIME_CLASS(CXTPControlComboBox)))
  1052. return FALSE;
  1054. return TRUE;
  1055. }
  1057. CString CXTPControlComboBox::GetListBoxText() const
  1058. {
  1059. CXTPControlComboBoxPopupBar* pPopupBar = GetComboBoxPopupBar();
  1061. if (!pPopupBar)
  1062. return _T("");
  1064. int nSel = pPopupBar->GetCurSel();
  1065. CString str;
  1066. if (nSel >= 0)
  1067. pPopupBar->GetText(nSel, str);
  1068. return str;
  1069. }
  1071. BOOL CXTPControlComboBox::IsValidList() const
  1072. {
  1073. return GetComboBoxPopupBar() != NULL;
  1074. }
  1076. CXTPControlComboBoxPopupBar* CXTPControlComboBox::GetComboBoxPopupBar() const
  1077. {
  1078. return DYNAMIC_DOWNCAST(CXTPControlComboBoxPopupBar, m_pCommandBar);
  1079. }
  1081. int CXTPControlComboBox::GetCurSel() const
  1082. {
  1083. CXTPControlComboBoxPopupBar* pPopupBar = GetComboBoxPopupBar();
  1084. return pPopupBar ? pPopupBar->GetCurSel() : m_nCurSel;
  1085. }
  1087. void CXTPControlComboBox::SetCurSel(int nIndex)
  1088. {
  1089. if ((GetCurSel() != nIndex) || (m_nCurSel != nIndex))
  1090. {
  1091. m_nCurSel = nIndex;
  1093. CXTPControlComboBoxPopupBar* pPopupBar = GetComboBoxPopupBar();
  1094. if (pPopupBar)
  1095. {
  1096. pPopupBar->SetCurSel(nIndex);
  1097. }
  1099. OnSelChanged();
  1100. }
  1101. }
  1103. BOOL CXTPControlComboBox::IsFocused() const
  1104. {
  1105. return m_bFocused;
  1106. }
  1108. void CXTPControlComboBox::SetFocused(BOOL bFocused)
  1109. {
  1110. if (m_bFocused == bFocused)
  1111. return;
  1113. m_bFocused = bFocused;
  1115. if (bFocused)
  1116. {
  1117. m_nLastSel = GetCurSel();
  1118. m_bSelEndOk = FALSE;
  1120. if (m_pEdit->GetSafeHwnd() && ::GetFocus() != m_pEdit->GetSafeHwnd())
  1121. m_pEdit->SetFocus();
  1123. m_pParent->SetTrackingMode(TRUE, FALSE);
  1124. m_pParent->SetSelected(m_nIndex);
  1126. XTPMouseManager()->LockMouseMove();
  1128. NotifySite(CBN_SETFOCUS);
  1129. }
  1130. else
  1131. {
  1132. if (!m_bSelEndOk && !GetDroppedState() && !m_pEdit)
  1133. {
  1134. SetCurSel(m_nLastSel);
  1135. NotifySite(CBN_SELENDCANCEL);
  1136. }
  1139. if (m_pEdit->GetSafeHwnd() && ::GetFocus() == m_pEdit->GetSafeHwnd())
  1140. ::SetFocus(m_pParent->GetTrackFocus());
  1142. XTPMouseManager()->UnlockMouseMove();
  1144. NotifySite(CBN_KILLFOCUS);
  1145. }
  1147. RedrawParent(FALSE);
  1148. }
  1151. void CXTPControlComboBox::OnSetFocus(CWnd* pOldWnd)
  1152. {
  1153. if (!GetEditHint().IsEmpty() && m_pEdit->GetSafeHwnd() && GetEditHint() == _GetEditText())
  1154. {
  1155. _SetEditText(_T(""));
  1156. }
  1158. m_strLastText = GetEditText();
  1161. m_bIgnoreAutoComplete = TRUE;
  1162. UpdatePopupSelection();
  1164. if (m_pParent->GetTrackFocus() == 0)
  1165. m_pParent->SetTrackFocus(pOldWnd ? pOldWnd->GetSafeHwnd() : m_pParent->GetSite()->GetSafeHwnd());
  1167. if (!m_bPopup)
  1168. m_pParent->SetPopuped(-1);
  1170. SetFocused(TRUE);
  1171. if (m_pAutoCompleteWnd) m_pAutoCompleteWnd->SetupMessageHook(TRUE);
  1172. }
  1174. void CXTPControlComboBox::OnKillFocus()
  1175. {
  1176. if (!GetEditHint().IsEmpty() && m_pEdit->GetSafeHwnd() && _GetEditText().IsEmpty())
  1177. {
  1178. _SetEditText(GetEditHint());
  1179. }
  1181. SetFocused(FALSE);
  1183. if (GetDroppedState())
  1184. m_pParent->SetPopuped(-1);
  1186. if (m_pAutoCompleteWnd) m_pAutoCompleteWnd->SetupMessageHook(FALSE);
  1187. }
  1189. BOOL CXTPControlComboBox::GetDroppedState() const
  1190. {
  1191. return m_bPopup;
  1192. //return m_pCommandBar->IsTrackingMode() && ((CXTPPopupBar*)m_pCommandBar)->GetControlPopup() == (CXTPControlPopup*)this;
  1193. }
  1195. BOOL CXTPControlComboBox::OnSetPopup(BOOL bPopup)
  1196. {
  1197. if (bPopup)
  1198. {
  1199. m_bSelEndOk = FALSE;
  1200. m_nLastSel = GetCurSel();
  1201. }
  1202. else if (!IsFocused() && m_pEdit == NULL && !m_bSelEndOk)
  1203. {
  1204. SetCurSel(m_nLastSel);
  1205. }
  1207. if (!bPopup && !m_bSelEndOk)
  1208. {
  1209. NotifySite(CBN_SELENDCANCEL);
  1210. }
  1213. if (m_pAutoCompleteWnd && bPopup) m_pAutoCompleteWnd->CloseWindow();
  1215. m_bPopup = bPopup;
  1216. if (bPopup && GetEditCtrl()) GetEditCtrl()->SetFocus();
  1218. return CXTPControlPopup::OnSetPopup(bPopup);
  1219. }
  1221. void CXTPControlComboBox::OnExecute()
  1222. {
  1223. if (GetCurSel() != -1 && (GetDroppedState() || (!m_pEdit && IsFocused())))
  1224. NotifySite(CBN_SELENDOK);
  1226. m_bSelEndOk = TRUE;
  1228. m_nLastSel = GetCurSel();
  1230. CXTPControlPopup::OnExecute();
  1231. }
  1233. CHARFORMAT2 CXTPControlComboBox::GetDefaultCharFormat()
  1234. {
  1235. CHARFORMAT2 cf;
  1236. ZeroMemory(&cf, sizeof(CHARFORMAT2));
  1237. cf.dwMask = CFM_COLOR | CFM_BACKCOLOR;
  1239. if (GetEnabled())
  1240. {
  1241. cf.crTextColor = GetXtremeColor(COLOR_WINDOWTEXT);
  1243. if (!GetEditHint().IsEmpty() && GetEditHint() == _GetEditText())
  1244. {
  1245. cf.crTextColor = GetXtremeColor(COLOR_GRAYTEXT);
  1246. }
  1247. }
  1248. else
  1249. {
  1250. cf.crTextColor = GetXtremeColor(COLOR_GRAYTEXT);
  1251. }
  1253. cf.crBackColor = GetPaintManager()->GetControlEditBackColor(this);
  1255. return cf;
  1256. }
  1258. void CXTPControlComboBox::ModifyListBoxStyle(DWORD dwRemove, DWORD dwAdd)
  1259. {
  1260. if (IsValidList())
  1261. {
  1262. CXTPControlComboBoxList* pComboBoxList = ((CXTPControlComboBoxList*)m_pCommandBar);
  1264. pComboBoxList->m_dwStyle |= dwAdd;
  1265. pComboBoxList->m_dwStyle &= ~dwRemove;
  1267. pComboBoxList->DestroyWindow();
  1268. pComboBoxList->CreateListBox();
  1269. }
  1270. }
  1273. //////////////////////////////////////////////////////////////////////////
  1274. // CXTPControlComboBoxPopup
  1277. IMPLEMENT_XTP_COMMANDBAR(CXTPControlComboBoxPopupBar, CXTPPopupBar)
  1279. CXTPControlComboBoxPopupBar::CXTPControlComboBoxPopupBar()
  1280. {
  1281. m_bComboBar = TRUE;
  1282. m_bGrabFocus = FALSE;
  1283. }
  1285. BOOL CXTPControlComboBoxPopupBar::ProcessHookKeyDown(CXTPControlComboBox* pComboBox, UINT nChar, LPARAM lParam)
  1286. {
  1287. int nSel = GetCurSel();
  1289. if (pComboBox->GetEditCtrl())
  1290. {
  1291. if ((GetKeyState(VK_MENU) >= 0) && (nChar == VK_UP || nChar == VK_DOWN || nChar == VK_PRIOR || nChar == VK_NEXT))
  1292. {
  1293. CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  1294. }
  1295. else
  1296. {
  1297. return FALSE;
  1298. }
  1299. }
  1300. else
  1301. {
  1302. if ((nChar == VK_F4 && GetKeyState(VK_MENU) >= 0) || ((nChar == VK_UP || nChar == VK_DOWN) && GetKeyState(VK_MENU) < 0))
  1303. {
  1304. return FALSE;
  1305. }
  1306. else
  1307. {
  1308. CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  1309. }
  1310. }
  1312. if (nSel != GetCurSel())
  1313. {
  1314. pComboBox->OnSelChanged();
  1315. if (pComboBox->GetEditCtrl()->GetSafeHwnd()) pComboBox->GetEditCtrl()->SetSel(0, -1);
  1316. }
  1317. return TRUE;
  1318. }
  1320. BOOL CXTPControlComboBoxPopupBar::OnHookKeyDown(UINT nChar, LPARAM lParam)
  1321. {
  1322. ASSERT(m_pControlPopup);
  1323. CXTPControlComboBox* pComboBox = ((CXTPControlComboBox*)m_pControlPopup);
  1324. if (!pComboBox)
  1325. return CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  1327. if (nChar == VK_ESCAPE)
  1328. {
  1329. if (pComboBox->IsFocused())
  1330. return FALSE;
  1332. return CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  1333. }
  1335. if (nChar == VK_TAB) return FALSE;
  1337. return ProcessHookKeyDown(pComboBox, nChar, lParam);
  1338. }
  1340. //////////////////////////////////////////////////////////////////////////
  1341. // CXTPControlComboBoxList
  1343. CXTPControlComboBoxList::CXTPControlComboBoxList()
  1344. {
  1345. m_barPosition = xtpBarListBox;
  1346. m_nMRUWidth = 0;
  1347. m_bGrabFocus = FALSE;
  1348. m_dwStyle = 0;
  1349. m_nListIconId = -1;
  1350. }
  1352. BEGIN_MESSAGE_MAP(CXTPControlComboBoxList, CXTPPopupBar)
  1353. ON_WM_LBUTTONUP()
  1354. ON_WM_NCPAINT()
  1355. ON_WM_ERASEBKGND()
  1356. ON_WM_MOUSEMOVE()
  1357. ON_WM_LBUTTONDOWN()
  1358. ON_WM_DRAWITEM_REFLECT()
  1359. ON_WM_MEASUREITEM_REFLECT()
  1360. END_MESSAGE_MAP()
  1363. IMPLEMENT_XTP_COMMANDBAR(CXTPControlComboBoxList, CXTPControlComboBoxPopupBar)
  1366. void CXTPControlComboBoxList::CreateListBox()
  1367. {
  1368. DWORD dwStyle = m_dwStyle & ~CBRS_GRIPPER;
  1370. CWnd* pSite = GetSite();
  1372. if (pSite && ((dwStyle & (LBS_OWNERDRAWFIXED|LBS_OWNERDRAWVARIABLE)) != 0))
  1373. {
  1374. CreateEx(WS_EX_CLIENTEDGE|WS_EX_TOOLWINDOW, _T("LISTBOX"), _T(""),
  1375. WS_CHILD | WS_VSCROLL | WS_CLIPCHILDREN | dwStyle | LBS_NOTIFY,
  1376. CRect(0, 0, 0, 0), pSite, 0);
  1378. SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, 0 );
  1379. ModifyStyle(WS_CHILD, WS_POPUP);
  1380. SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, (LONG_PTR)(pSite->m_hWnd));
  1381. }
  1382. else
  1383. {
  1384. CreateEx(WS_EX_CLIENTEDGE | WS_EX_TOOLWINDOW, _T("LISTBOX"), _T(""),
  1385. WS_POPUP | WS_VSCROLL | WS_CLIPCHILDREN | dwStyle, CRect(0, 0, 0, 0), 0, 0);
  1386. }
  1388. if (m_pCommandBars && m_nListIconId != -1)
  1389. {
  1390. CXTPImageManagerIcon* pIcon = GetImageManager()->GetImage(m_nListIconId, 0);
  1391. if (pIcon)
  1392. {
  1393. ((CListBox*)this)->SetItemHeight(-1, pIcon->GetHeight() + 4);
  1394. }
  1395. }
  1396. }
  1398. void CXTPControlComboBoxList::DrawItem (LPDRAWITEMSTRUCT lpDrawItemStruct)
  1399. {
  1400. CXTPControlComboBox* pComboBox = (CXTPControlComboBox*)m_pControlPopup;
  1401. if (pComboBox) pComboBox->DrawItem(lpDrawItemStruct);
  1402. }
  1404. void CXTPControlComboBoxList::MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
  1405. {
  1406. CXTPControlComboBox* pComboBox = (CXTPControlComboBox*)m_pControlPopup;
  1407. if (pComboBox) pComboBox->MeasureItem(lpMeasureItemStruct);
  1408. }
  1410. void CXTPControlComboBoxList::OnLButtonDown(UINT /*nFlags*/, CPoint /*point*/)
  1411. {
  1412. // do nothing.
  1413. }
  1415. int CXTPControlComboBoxList::OnHookMessage(HWND hWnd, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  1416. {
  1417. if (nMessage == WM_MOUSEWHEEL)
  1418. {
  1419. CWnd::DefWindowProc(WM_MOUSEWHEEL, wParam, lParam);
  1420. return TRUE;
  1421. }
  1422. return CXTPCommandBar::OnHookMessage(hWnd, nMessage, wParam, lParam, lResult);
  1423. }
  1426. void CXTPControlComboBoxList::OnNcPaint()
  1427. {
  1428. CXTPPaintManager* pPaintManager = GetPaintManager();
  1430. Default();
  1431. CWindowDC dc(this);
  1432. CXTPWindowRect rc(this);
  1433. rc.OffsetRect(-rc.TopLeft());
  1434. dc.Draw3dRect(rc, pPaintManager->GetXtremeColor(XPCOLOR_MENUBAR_BORDER), pPaintManager->GetXtremeColor(XPCOLOR_MENUBAR_BORDER));
  1436. rc.DeflateRect(1, 1);
  1437. dc.Draw3dRect(rc, GetXtremeColor(COLOR_WINDOW), GetXtremeColor(COLOR_WINDOW));
  1439. }
  1441. BOOL CXTPControlComboBoxList::OnEraseBkgnd(CDC* pDC)
  1442. {
  1443. return CWnd::OnEraseBkgnd(pDC);
  1444. }
  1446. void CXTPControlComboBoxList::OnLButtonUp(UINT /*nFlags*/, CPoint /*point*/)
  1447. {
  1448. CXTPControlComboBox* pComboBox = (CXTPControlComboBox*)m_pControlPopup;
  1450. pComboBox->OnSelChanged();
  1451. pComboBox->OnExecute();
  1452. }
  1454. BOOL CXTPControlComboBoxList::SetTrackingMode(int bMode, BOOL bSelectFirst, BOOL bKeyboard)
  1455. {
  1456. if (!CXTPCommandBar::SetTrackingMode(bMode, bSelectFirst, bKeyboard))
  1457. return FALSE;
  1459. CXTPControlComboBox* pComboBox = ((CXTPControlComboBox*)m_pControlPopup);
  1461. if (!bMode)
  1462. {
  1463. pComboBox->NotifySite(CBN_CLOSEUP);
  1465. XTPMouseManager()->UnlockMouseMove();
  1466. ShowWindow(SW_HIDE);
  1468. if (GetParentCommandBar())
  1469. GetParentCommandBar()->SetPopuped(-1);
  1471. m_pControlPopup = 0;
  1473. }
  1474. else
  1475. {
  1476. XTPMouseManager()->LockMouseMove();
  1478. pComboBox->UpdatePopupSelection();
  1480. pComboBox->NotifySite(CBN_DROPDOWN);
  1481. }
  1484. return TRUE;
  1485. }
  1487. CListBox* CXTPControlComboBoxList::GetListBoxCtrl() const
  1488. {
  1489. return (CListBox*)this;
  1490. }
  1492. BOOL CXTPControlComboBoxList::ProcessHookKeyDown(CXTPControlComboBox* pComboBox, UINT nChar, LPARAM lParam)
  1493. {
  1494. int nSel = GetCurSel();
  1496. if (pComboBox->GetEditCtrl())
  1497. {
  1498. if ((GetKeyState(VK_MENU) >= 0) && (nChar == VK_UP || nChar == VK_DOWN || nChar == VK_PRIOR || nChar == VK_NEXT))
  1499. {
  1500. CWnd::DefWindowProc(WM_KEYDOWN, (WPARAM)nChar, lParam);
  1501. }
  1502. else
  1503. {
  1504. return FALSE;
  1505. }
  1506. }
  1507. else
  1508. {
  1509. if ((nChar == VK_F4 && GetKeyState(VK_MENU) >= 0) || ((nChar == VK_UP || nChar == VK_DOWN) && GetKeyState(VK_MENU) < 0))
  1510. {
  1511. return FALSE;
  1512. }
  1513. else
  1514. {
  1515. MSG msg;
  1516. msg.message = WM_KEYDOWN;
  1517. msg.hwnd = m_hWnd;
  1518. msg.wParam = (WPARAM)nChar;
  1519. msg.lParam = lParam;
  1521. ::IsDialogMessage(m_hWnd, &msg);
  1523. if (PeekMessage(&msg, m_hWnd, WM_CHAR, WM_CHAR, PM_REMOVE))
  1524. {
  1525. CWnd::DefWindowProc(WM_CHAR, msg.wParam, msg.lParam);
  1526. }
  1527. }
  1528. }
  1530. if (nSel != GetCurSel())
  1531. {
  1532. pComboBox->OnSelChanged();
  1533. if (pComboBox->GetEditCtrl()->GetSafeHwnd()) pComboBox->GetEditCtrl()->SetSel(0, -1);
  1534. }
  1535. return TRUE;
  1536. }
  1538. BOOL CXTPControlComboBoxList::OnHookKeyDown(UINT nChar, LPARAM lParam)
  1539. {
  1540. ASSERT(m_pControlPopup);
  1541. CXTPControlComboBox* pComboBox = ((CXTPControlComboBox*)m_pControlPopup);
  1542. if (!pComboBox)
  1543. return CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  1545. if (nChar == VK_ESCAPE)
  1546. {
  1547. if (pComboBox->IsFocused())
  1548. return FALSE;
  1550. return CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  1551. }
  1553. if (nChar == VK_TAB) return FALSE;
  1555. if (nChar == VK_RETURN)
  1556. {
  1557. m_pControlPopup->OnExecute();
  1558. return TRUE;
  1559. }
  1561. return ProcessHookKeyDown(pComboBox, nChar, lParam);
  1562. }
  1564. void CXTPControlComboBoxList::OnMouseMove(UINT nFlags, CPoint point)
  1565. {
  1566. BOOL bOutside;
  1567. UINT nItem = GetListBoxCtrl()->ItemFromPoint(point, bOutside);
  1569. if (!bOutside && GetCurSel() != (int)nItem)
  1570. SetCurSel(nItem);
  1572. CXTPPopupBar::OnMouseMove(nFlags, point);
  1573. }
  1577. BOOL CXTPControlComboBoxList::Popup(CXTPControlPopup* pControlPopup, BOOL /*bSelectFirst*/)
  1578. {
  1579. m_pControlPopup = pControlPopup;
  1581. SetFont(GetPaintManager()->GetIconFont());
  1583. CWnd* pWndOwner = GetOwnerSite();
  1584. if (pWndOwner) pWndOwner->SendMessage(WM_XTP_INITCOMMANDSPOPUP, 0, (LPARAM)this);
  1586. CXTPCommandBars* pCommandBars = GetCommandBars();
  1588. if (pCommandBars && pCommandBars->IsLayoutRTL())
  1589. ModifyStyleEx(WS_EX_LAYOUTRTL, WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR | WS_EX_RTLREADING);
  1590. else ModifyStyleEx(WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR | WS_EX_RTLREADING, 0);
  1592. SetTrackingMode(TRUE, FALSE);
  1594. UpdateFlags();
  1596. CRect rcControl = pControlPopup->GetRect();
  1598. int nItemHeight = GetListBoxCtrl()->GetItemHeight(0);
  1599. int nHeight = min (((CXTPControlComboBox*)m_pControlPopup)->m_nDropDownItemCount,
  1600. max(1, GetListBoxCtrl()->GetCount())) * nItemHeight + 4;
  1601. int nWidth = m_nMRUWidth <= 0 ? rcControl.Width() : m_nMRUWidth;
  1602. UpdateLocation(CSize(nWidth, nHeight));
  1604. EnableWindow();
  1606. return TRUE;
  1607. }
  1609. void CXTPControlComboBoxList::DrawCommandBar(CDC* pDC, CRect /*rcClipBox*/)
  1610. {
  1611. pDC->FillSolidRect(CXTPClientRect(this), GetXtremeColor(COLOR_WINDOW));
  1612. CWnd::DefWindowProc(WM_PAINT, (WPARAM)pDC->m_hDC, 0);
  1613. }
  1615. //////////////////////////////////////////////////////////////////////////
  1616. // CXTPControlComboBoxEditCtrl
  1618. BEGIN_MESSAGE_MAP(CXTPControlComboBoxEditCtrl, CXTPEdit)
  1619. ON_WM_SETFOCUS()
  1620. ON_WM_MOUSEMOVE()
  1621. ON_WM_KILLFOCUS()
  1622. ON_WM_DESTROY()
  1623. ON_WM_LBUTTONDOWN()
  1624. ON_WM_RBUTTONDOWN()
  1625. ON_WM_CONTEXTMENU()
  1626. ON_WM_KEYDOWN()
  1627. ON_MESSAGE(XTP_TTM_WINDOWFROMPOINT, OnWindowFromPoint)
  1628. ON_MESSAGE_VOID(WM_XTP_SHELLAUTOCOMPLETESTART, OnShellAutoCompleteStart)
  1629. ON_CONTROL_REFLECT(EN_CHANGE, OnEditChanged)
  1630. END_MESSAGE_MAP()
  1632. void CXTPControlComboBoxEditCtrl::OnEditChanged()
  1633. {
  1634. m_pControl->m_bEditChanged = TRUE;
  1636. if (::GetFocus() == m_hWnd && !m_bIgonoreEditChanged)
  1637. m_pControl->OnEditChanged();
  1639. SetMargins(0, 0);
  1640. UpdateCharFormat();
  1641. }
  1643. void CXTPControlComboBoxEditCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  1644. {
  1645. if (nChar == VK_RETURN && ::GetFocus() == m_hWnd)
  1646. {
  1647. m_pControl->OnExecute();
  1648. return;
  1649. }
  1651. CXTPEdit::OnKeyDown(nChar, nRepCnt, nFlags);
  1652. }
  1654. void CXTPControlComboBoxEditCtrl::UpdateCharFormat()
  1655. {
  1656. CHARFORMAT2 cf = m_pControl->GetDefaultCharFormat();
  1657. cf.cbSize = GetRichEditContext().m_bRichEdit2 ? sizeof(CHARFORMAT2) : sizeof(CHARFORMAT);
  1659. ::SendMessage(m_hWnd, EM_SETCHARFORMAT, 0, (LPARAM)&cf);
  1660. ::SendMessage(m_hWnd, EM_SETBKGNDCOLOR, FALSE, cf.crBackColor);
  1661. }
  1663. void CXTPControlComboBoxEditCtrl::OnShellAutoCompleteStart()
  1664. {
  1665. m_pControl->GetCommandBar()->OnTrackLost();
  1666. }
  1668. void CXTPControlComboBoxEditCtrl::OnContextMenu(CWnd* /*pWnd*/, CPoint /*point*/)
  1669. {
  1670. }
  1672. void CXTPControlComboBoxEditCtrl::OnRButtonDown(UINT nFlags, CPoint point)
  1673. {
  1674. if (m_pControl->IsCustomizeMode())
  1675. {
  1676. ClientToScreen(&point);
  1677. m_pControl->GetParent()->ScreenToClient(&point);
  1679. m_pControl->GetParent()->OnRButtonDown(nFlags, point);
  1680. return;
  1681. }
  1683. m_pControl->GetCommandBar()->OnTrackLost();
  1684. m_pControl->SetFocused(TRUE);
  1686. if (!ShowContextMenu(m_pControl, point))
  1687. CXTPEdit::OnRButtonDown(nFlags, point);
  1688. }
  1690. void CXTPControlComboBoxEditCtrl::OnLButtonDown(UINT nFlags, CPoint point)
  1691. {
  1692. if (m_pControl->IsCustomizeMode())
  1693. {
  1694. if (m_pControl->IsCustomizeMovable())
  1695. m_pControl->OnClick();
  1696. }
  1697. else CEdit::OnLButtonDown(nFlags, point);
  1698. }
  1700. void CXTPControlComboBoxEditCtrl::OnDestroy()
  1701. {
  1702. GetWindowTextEx(m_pControl->m_strEditText);
  1703. CEdit::OnDestroy();
  1704. }
  1706. BOOL CXTPControlComboBoxEditCtrl::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1707. {
  1708. CXTPCommandBar* pCommandBar = m_pControl->GetParent();
  1710. if (pCommandBar)
  1711. {
  1712. pCommandBar->FilterToolTipMessage(message, wParam, lParam);
  1713. }
  1715. return CWnd::OnWndMsg(message, wParam, lParam, pResult);
  1716. }
  1718. LRESULT CXTPControlComboBoxEditCtrl::OnWindowFromPoint(WPARAM, LPARAM)
  1719. {
  1720. return 1;
  1721. }
  1723. void CXTPControlComboBoxEditCtrl::OnSetFocus(CWnd* pOldWnd)
  1724. {
  1725. if (!m_pControl->IsCustomizeMode())
  1726. {
  1727. m_pControl->OnSetFocus(pOldWnd);
  1728. CEdit::OnSetFocus(pOldWnd);
  1730. SetSel(0, 0);
  1731. ::PostMessage(m_hWnd, EM_SETSEL, 0, -1);
  1732. }
  1733. }
  1735. void CXTPControlComboBoxEditCtrl::OnKillFocus(CWnd* pNewWnd)
  1736. {
  1737. CXTPEdit::OnKillFocus(pNewWnd);
  1738. m_pControl->OnKillFocus();
  1739. }
  1741. void CXTPControlComboBoxEditCtrl::OnMouseMove(UINT nFlags, CPoint point)
  1742. {
  1743. CEdit::OnMouseMove(nFlags, point);
  1745. MapWindowPoints(m_pControl->GetParent(), &point, 1);
  1746. m_pControl->GetParent()->OnMouseMove(nFlags, point);
  1747. }
  1749. //////////////////////////////////////////////////////////////////////////
  1750. // CXTPControlComboBoxList
  1752. void CXTPControlComboBoxList::Copy(CXTPCommandBar* pCommandBar, BOOL bRecursive)
  1753. {
  1754. CXTPPopupBar::Copy(pCommandBar, bRecursive);
  1756. m_nListIconId = ((CXTPControlComboBoxList*)pCommandBar)->m_nListIconId;
  1758. if (!m_hWnd)
  1759. CreateListBox();
  1761. CListBox* pListBox = (CListBox*)(CXTPControlComboBoxList*)pCommandBar;
  1762. DWORD dwCount = pListBox->m_hWnd ? pListBox->GetCount() : 0;
  1764. for (UINT i = 0; i < dwCount; i++)
  1765. {
  1766. CString str;
  1767. pListBox->GetText(i, str);
  1768. GetListBoxCtrl()->AddString(str);
  1769. }
  1771. }
  1773. void CXTPControlComboBoxList::DoPropExchange(CXTPPropExchange* pPX)
  1774. {
  1775. CXTPPopupBar::DoPropExchange(pPX);
  1777. if (pPX->GetSchema() > _XTP_SCHEMA_110)
  1778. {
  1779. PX_Int(pPX, _T("ListIconId"), m_nListIconId, -1);
  1780. }
  1782. CListBox* pThis = (CListBox*)this;
  1783. CString str;
  1785. CXTPPropExchangeSection secItems(pPX->GetSection(_T("Items")));
  1787. if (pPX->IsStoring())
  1788. {
  1789. if (m_hWnd)
  1790. {
  1791. DWORD dwCount = pThis->GetCount();
  1792. secItems->WriteCount(dwCount);
  1794. for (int i = 0; i < (int)dwCount; i++)
  1795. {
  1796. pThis->GetText(i, str);
  1798. CString strSection;
  1799. strSection.Format(_T("Item%i"), i);
  1800. PX_String(&secItems, strSection, str, _T(""));
  1802. }
  1803. }
  1804. else
  1805. {
  1806. pPX->WriteCount(0);
  1807. }
  1808. }
  1809. else
  1810. {
  1811. if (!m_hWnd)
  1812. CreateListBox();
  1814. DWORD nNewCount = secItems->ReadCount();
  1815. for (DWORD i = 0; i < nNewCount; i++)
  1816. {
  1817. CString strSection;
  1818. strSection.Format(_T("Item%i"), i);
  1820. PX_String(&secItems, strSection, str, _T(""));
  1821. pThis->AddString(str);
  1822. }
  1823. }
  1824. }
  1827. void CXTPControlComboBox::OnMouseMove(CPoint point)
  1828. {
  1829. CXTPControlPopup::OnMouseMove(point);
  1831. if (GetEnabled() && m_bSelected)
  1832. {
  1833. CRect rcButon(GetRect());
  1834. rcButon.left = rcButon.right - m_nThumbWidth;
  1836. if (rcButon.PtInRect(point) && m_bSelected != TRUE_SPLITDROPDOWN)
  1837. {
  1838. m_bSelected = TRUE_SPLITDROPDOWN;
  1839. RedrawParent(FALSE);
  1840. }
  1841. else if (!rcButon.PtInRect(point) && m_bSelected == TRUE_SPLITDROPDOWN)
  1842. {
  1843. m_bSelected = TRUE;
  1844. RedrawParent(FALSE);
  1845. }
  1846. }
  1847. }
  1849. void CXTPControlComboBox::SetListIconId(int nId)
  1850. {
  1851. if (m_pParent) GetCommandBar()->SetCommandBars(m_pParent->GetCommandBars());
  1853. if (IsValidList())
  1854. {
  1855. CXTPControlComboBoxList* pComboBoxList = ((CXTPControlComboBoxList*)m_pCommandBar);
  1856. pComboBoxList->m_nListIconId = nId;
  1858. ModifyListBoxStyle(0, LBS_OWNERDRAWFIXED | LBS_HASSTRINGS);
  1859. }
  1860. }
  1862. int CXTPControlComboBox::GetListIconId() const
  1863. {
  1864. return IsValidList() ?  ((CXTPControlComboBoxList*)m_pCommandBar)->m_nListIconId : -1;
  1865. }
  1867. int CXTPControlComboBox::GetDropDownWidth() const
  1868. {
  1869. return m_pCommandBar->GetWidth();
  1870. }
  1872. int CXTPControlComboBox::GetCustomizeMinWidth() const
  1873. {
  1874. return m_nLabelWidth + m_nThumbWidth + 5;
  1876. }
  1878. void CXTPControlComboBox::DeflateEditRect(CRect& rcControl)
  1879. {
  1880. if (m_nEditIconId > 0)
  1881. {
  1882. CXTPImageManagerIcon* pIcon = m_pParent->GetImageManager()->GetImage(m_nEditIconId, 0);
  1883. if (pIcon)
  1884. rcControl.left += pIcon->GetWidth() + 2;
  1885. }
  1886. }
  1888. void CXTPControlComboBox::DrawEditText(CDC* pDC, CRect rcText)
  1889. {
  1890. if (!GetEditCtrl() && GetEnabled() && IsFocused())
  1891. {
  1892. CRect rcFocus(rcText.left - 1, rcText.top + 1, rcText.right - 1, rcText.bottom - 1);
  1893. pDC->FillSolidRect(rcFocus, GetXtremeColor(COLOR_HIGHLIGHT));
  1894. }
  1896. if (m_nEditIconId > 0)
  1897. {
  1898. CXTPImageManagerIcon* pIcon = m_pParent->GetImageManager()->GetImage(m_nEditIconId, 0);
  1899. if (pIcon)
  1900. {
  1901. pIcon->Draw(pDC, CPoint(rcText.left, rcText.CenterPoint().y - pIcon->GetHeight() / 2), GetEnabled() ? pIcon->GetIcon() : pIcon->GetDisabledIcon());
  1902. rcText.left += pIcon->GetWidth() + 2;
  1903. }
  1904. }
  1906. if (GetEditCtrl())
  1907. return;
  1909. CString strListBoxText = GetListBoxText();
  1911. if (!strListBoxText.IsEmpty())
  1912. {
  1913. pDC->SetTextColor(GetXtremeColor(!GetEnabled() ? COLOR_GRAYTEXT: IsFocused() ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT));
  1914. pDC->DrawText(strListBoxText, rcText, DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
  1915. }
  1916. else if (!GetEditHint().IsEmpty() && GetEnabled() && !IsFocused())
  1917. {
  1918. pDC->SetTextColor(GetXtremeColor(COLOR_GRAYTEXT));
  1919. pDC->DrawText(GetEditHint(), rcText, DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
  1920. }
  1921. }
  1923. void CXTPControlComboBox::MeasureItem(LPMEASUREITEMSTRUCT /*lpMeasureItemStruct*/)
  1924. {
  1926. }
  1928. void CXTPControlComboBox::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  1929. {
  1930. CString strText;
  1931. GetLBText(lpDrawItemStruct->itemID, strText);
  1933. CRect rc(&lpDrawItemStruct->rcItem);
  1935. ASSERT(lpDrawItemStruct->CtlType == ODT_LISTBOX);
  1937. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  1939. BOOL bSelected = lpDrawItemStruct->itemState & ODS_SELECTED;
  1940. CXTPPaintManager* pPaintManager = GetPaintManager();
  1942. COLORREF crOldTextColor = pDC->SetTextColor(pPaintManager->GetRectangleTextColor(bSelected, FALSE, TRUE, FALSE, FALSE, xtpBarTypePopup, xtpBarPopup));
  1944. if (bSelected)
  1945. pPaintManager->DrawRectangle(pDC, rc, TRUE, FALSE, TRUE, FALSE, FALSE, xtpBarTypePopup, xtpBarPopup);
  1946. else
  1947. pDC->FillSolidRect(rc, pPaintManager->GetXtremeColor(COLOR_WINDOW));
  1949. int nListIconId = GetListIconId();
  1950. if (nListIconId != -1)
  1951. {
  1952. CXTPImageManager* pImageManager = GetCommandBar()->GetImageManager();
  1953. CXTPImageManagerIcon* pImage = pImageManager->GetImage(nListIconId + lpDrawItemStruct->itemID, 0);
  1955. if (pImage)
  1956. {
  1957. pImage->Draw(pDC, CPoint(rc.left + 2, (rc.top + rc.bottom - pImage->GetHeight()) / 2),
  1958. pImage->GetIcon(bSelected ? xtpImageHot : xtpImageNormal));
  1959. rc.left += pImage->GetWidth() + 2;
  1960. }
  1961. }
  1963. CXTPFontDC font(pDC, pPaintManager->GetIconFont());
  1965. pDC->SetBkMode(TRANSPARENT);
  1966. rc.left += 3;
  1967. pDC->DrawText(strText, rc, DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
  1969. pDC->SetTextColor(crOldTextColor);
  1970. }