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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
ExtComboBox.cpp
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：115k
源码类别：

界面编程

开发平台：

Visual C++

ExtComboBox.cpp：源码内容
  1. // This is part of the Professional User Interface Suite library.
  2. // Copyright (C) 2001-2009 FOSS Software, Inc.
  3. // All rights reserved.
  4. //
  5. // http://www.prof-uis.com
  6. // mailto:support@prof-uis.com
  7. //
  8. // This source code can be used, modified and redistributed
  9. // under the terms of the license agreement that is included
  10. // in the Professional User Interface Suite package.
  11. //
  12. // Warranties and Disclaimers:
  13. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  14. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  15. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  16. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  17. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  18. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  19. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  20. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  22. #include "stdafx.h"
  24. #if (!defined __EXT_COMBO_BOX_H)
  25. #include <ExtComboBox.h>
  26. #endif
  28. #if (!defined __EXT_PAINT_MANAGER_H)
  29. #include <ExtPaintManager.h>
  30. #endif
  32. #if (!defined __EXT_MEMORY_DC_H)
  33. #include <../Src/ExtMemoryDC.h>
  34. #endif
  36. #if (!defined __EXT_POPUP_MENU_WND_H)
  37. #include <ExtPopupMenuWnd.h>
  38. #endif
  40. #if (!defined __EXT_TOOLCONTROLBAR_H)
  41. #include <ExtToolControlBar.h>
  42. #endif
  44. #if (!defined __EXT_SCROLLWND_H)
  45. #include <ExtScrollWnd.h>
  46. #endif 
  48. #if (!defined __AFXPRIV_H__)
  49. #include <AfxPriv.h>
  50. #endif
  52. #if (! defined __VSSYM32_H__)
  53. #include <vssym32/vssym32.h>
  54. #endif // (! defined __VSSYM32_H__)
  56. #ifdef _DEBUG
  57. #define new DEBUG_NEW
  58. #undef THIS_FILE
  59. static char THIS_FILE[] = __FILE__;
  60. #endif
  62. //////////////////////////////////////////////////////////////////////////
  63. // CExtComboBoxPopupListBox
  64. //////////////////////////////////////////////////////////////////////////
  66. IMPLEMENT_DYNAMIC( CExtComboBoxPopupListBox, CWnd );
  68. BEGIN_MESSAGE_MAP( CExtComboBoxPopupListBox, CWnd )
  69. //{{AFX_MSG_MAP(CExtComboBoxPopupListBox)
  70. ON_WM_MOUSEMOVE()
  71. ON_WM_LBUTTONUP()
  72. ON_WM_LBUTTONDOWN()
  73. ON_WM_LBUTTONDBLCLK()
  74. ON_WM_KEYDOWN()
  75. ON_WM_PAINT()
  76. ON_WM_ERASEBKGND()
  77. //}}AFX_MSG_MAP
  78. END_MESSAGE_MAP()
  80. CExtComboBoxPopupListBox::CExtComboBoxPopupListBox()
  81. : m_pCB( NULL )
  82. , m_hWndCB( NULL )
  83. , m_bFirstActivationInvocation( true )
  84. , m_bSimpleModeComboBox( false )
  85. , m_rcWndRestore( 0, 0, 0, 0 )
  86. {
  87. }
  89. CExtComboBoxPopupListBox::~CExtComboBoxPopupListBox()
  90. {
  91. }
  93. bool CExtComboBoxPopupListBox::_IsEnabledItem( CPoint point )
  94. {
  95. ASSERT_VALID( this );
  96. if( GetSafeHwnd() == NULL || m_hWndCB == NULL || ( ! ::IsWindow( m_hWndCB ) ) )
  97. return false;
  98. CRect rcClient;
  99. GetClientRect( rcClient );
  100. if( rcClient.PtInRect( point ) )
  101. {
  102. BOOL bOutside = FALSE;
  103. INT nIndex = ((CListBox *)this)->ItemFromPoint( point, bOutside );
  104. if( (!bOutside) 
  105. && m_pCB->LbItemIsEnabled( nIndex )
  106. )
  107. return true;
  108. return false;
  109. }
  110. return true;
  111. }
  113. void CExtComboBoxPopupListBox::OnLButtonUp( UINT nFlags, CPoint point ) 
  114. {
  115. ASSERT_VALID( this );
  116. if( ! _IsEnabledItem( point ) )
  117. return;
  118. CWnd::OnLButtonUp(nFlags, point);
  119. }
  121. void CExtComboBoxPopupListBox::OnMouseMove(UINT nFlags, CPoint point) 
  122. {
  123. ASSERT_VALID( this );
  124. if( ! _IsEnabledItem( point ) )
  125. return;
  126. CWnd::OnMouseMove(nFlags, point);
  127. }
  129. void CExtComboBoxPopupListBox::OnLButtonDown(UINT nFlags, CPoint point) 
  130. {
  131. ASSERT_VALID( this );
  132. if( ! _IsEnabledItem( point ) )
  133. return;
  134. CWnd::OnLButtonDown(nFlags, point);
  135. }
  137. void CExtComboBoxPopupListBox::OnLButtonDblClk(UINT nFlags, CPoint point) 
  138. {
  139. ASSERT_VALID( this );
  140. if( ! _IsEnabledItem( point ) )
  141. return;
  142. CWnd::OnLButtonDblClk(nFlags, point);
  143. }
  145. void CExtComboBoxPopupListBox::PreSubclassWindow()
  146. {
  147. ASSERT_VALID( this );
  148. CWnd::PreSubclassWindow();
  149. ASSERT_VALID( m_pCB );
  150. ASSERT( m_pCB->GetSafeHwnd() != NULL && m_pCB->m_hWnd == m_hWndCB );
  151. DWORD dwStyle = m_pCB->GetStyle();
  152. if( (dwStyle&CBS_SIMPLE) == CBS_SIMPLE 
  153. && (dwStyle&CBS_DROPDOWN) != CBS_DROPDOWN
  154. && (dwStyle&CBS_DROPDOWNLIST) != CBS_DROPDOWNLIST 
  155. )
  156. m_bSimpleModeComboBox = true;
  157. if( m_bSimpleModeComboBox )
  158. ModifyStyle( 0, WS_CLIPCHILDREN|WS_CLIPSIBLINGS );
  159. }
  161. void CExtComboBoxPopupListBox::PostNcDestroy()
  162. {
  163. ASSERT_VALID( this );
  164. delete this;
  165. }
  167. LRESULT CExtComboBoxPopupListBox::WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  168. {
  169. if( m_pCB != NULL && m_hWndCB != NULL && ::IsWindow( m_hWndCB ) )
  170. {
  171. LRESULT lResult = 0L;
  172. if( m_pCB->_OnCbLbPreWndProc( lResult, message, wParam, lParam ) )
  173. return lResult;
  174. }
  175. switch( message )
  176. {
  177. case WM_NCCALCSIZE:
  178. if( m_bSimpleModeComboBox)
  179. {
  180. NCCALCSIZE_PARAMS * myNCSIZE = (NCCALCSIZE_PARAMS*)lParam;
  181. CRect rcSaved = myNCSIZE->rgrc[0];
  182. LRESULT lResult = CWnd::WindowProc( message, wParam, lParam );
  183. //myNCSIZE->rgrc[0].left = rcSaved.left;
  184. myNCSIZE->rgrc[0].top = rcSaved.top;
  185. myNCSIZE->rgrc[0].bottom = rcSaved.bottom;
  186. myNCSIZE->rgrc[0].right ++;
  187. return lResult;
  188. }
  189. break;
  190. case (WM_USER+555):
  191. MoveWindow( &m_rcWndRestore );
  192. return 0L;
  193. case WM_PRINT:
  194. case WM_PRINTCLIENT:
  195. if( m_bFirstActivationInvocation )
  196. {
  197. m_bFirstActivationInvocation = false;
  198. if( ! m_bSimpleModeComboBox )
  199. {
  200. GetWindowRect( &m_rcWndRestore );
  201. MoveWindow( -32000, -32000, 0, 0 );
  202. PostMessage( (WM_USER+555) );
  203. }
  204. }
  205. if( ! m_bSimpleModeComboBox )
  206. return 0L;
  207. break;
  208. case WM_ERASEBKGND:
  209. if(  (GetStyle() & LBS_OWNERDRAWFIXED) != 0 
  210. || (GetStyle() & LBS_OWNERDRAWVARIABLE) != 0 
  211. )
  212. return TRUE;
  213. break;
  214. case WM_PAINT:
  215. if(  (GetStyle() & LBS_OWNERDRAWFIXED) != 0 
  216. || (GetStyle() & LBS_OWNERDRAWVARIABLE) != 0 
  217. )
  218. {
  219. CPaintDC dcPaint( this );
  220. CRect rcClient;
  221. GetClientRect( &rcClient );
  222. CExtMemoryDC dc( &dcPaint, &rcClient );
  223. if( m_pCB != NULL && m_hWndCB != NULL && ::IsWindow( m_hWndCB ) )
  224. {
  225. CExtPaintManager * pPM = m_pCB->PmBridge_GetPM();
  226. ASSERT_VALID( pPM );
  227. dc.FillSolidRect( &rcClient, pPM->GetColor( COLOR_WINDOW, this ) );
  228. HFONT hFont = m_pCB->OnQueryFont();
  229. if( hFont == NULL )
  230. hFont = (HFONT)pPM->m_FontNormal.GetSafeHandle();
  231. ASSERT( hFont != NULL );
  232. HFONT hOldFont = (HFONT)::SelectObject( dc.m_hDC, hFont );
  233. INT nCount = m_pCB->GetCount();
  234. INT nTopIndex = ((CListBox*)this)->GetTopIndex();
  235. for( INT nItem = nTopIndex; nItem < nCount; nItem++ )
  236. {
  237. DRAWITEMSTRUCT dis;
  238. ::memset( &dis, 0, sizeof( DRAWITEMSTRUCT ) );
  239. dis.CtlType = ODT_LISTBOX;
  240. dis.CtlID = GetDlgCtrlID();
  241. dis.itemID = nItem;
  242. dis.hDC = dc.GetSafeHdc();
  243. ((CListBox*)this)->GetItemRect( nItem, &dis.rcItem );
  244. dis.itemAction = ODA_DRAWENTIRE;
  245. dis.hwndItem = GetSafeHwnd();
  246. dis.itemData = m_pCB->GetItemData( nItem );
  247. if( rcClient.bottom < dis.rcItem.top )
  248. break;
  249. if( ((CListBox*)this)->GetSel( nItem ) > 0 )
  250. dis.itemState |= ODS_SELECTED;
  251. if( ((CListBox*)this)->GetCurSel() == nItem )
  252. dis.itemState |= ODS_FOCUS;
  253. m_pCB->SendMessage( WM_DRAWITEM, (WPARAM)GetDlgCtrlID(), (LPARAM)&dis );
  254. }
  255. ::SelectObject( dc.m_hDC, hOldFont );
  256. }
  257. return TRUE;
  258. }
  259. break;
  260. } // switch( message )
  261. HWND hWndCB = m_hWndCB, hWndOwn = m_hWnd;
  262. LRESULT lResult = CWnd::WindowProc( message, wParam, lParam );
  263. if( ! ( hWndOwn != NULL && ::IsWindow( hWndOwn ) ) )
  264. return lResult;
  265. if( hWndCB != NULL && ::IsWindow( hWndCB ) && m_pCB != NULL && LPVOID(CWnd::FromHandlePermanent(hWndCB)) == LPVOID(m_pCB) )
  266. m_pCB->_OnCbLbPostWndProc( lResult, message, wParam, lParam );
  267. LONG nFrame = RDW_FRAME;
  268. switch( message )
  269. {
  270. case WM_VSCROLL:
  271. case WM_HSCROLL:
  272. nFrame = 0L;
  273. case WM_SHOWWINDOW:
  274. case WM_WINDOWPOSCHANGED:
  275. RedrawWindow(
  276. NULL,
  277. NULL,
  278. RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|nFrame
  279. );
  280. break;
  281. } // switch( message )
  282. return lResult;
  283. }
  285. void CExtComboBoxPopupListBox::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags ) 
  286. {
  287. ASSERT_VALID( this );
  288. if( m_pCB != NULL && m_hWndCB != NULL && ::IsWindow( m_hWndCB ) && m_pCB->GetDroppedState() )
  289. {
  290. DWORD dwComboBoxType = m_pCB->GetStyle() & 0x0003L;
  291. CListBox * pListBox = ( CListBox * ) this;
  292. bool bSelChanged = false;
  293. switch( nChar )
  294. {
  295. case VK_LEFT:
  296. case VK_UP:
  297. {
  298. INT nCount = pListBox->GetCount();
  299. if( nCount == 0 )
  300. break;
  301. // Go up until we find a valid selection then set the current selection to that one
  302. INT nCurSel = pListBox->GetCurSel();
  303. INT nSel = nCurSel;
  304. bool bInitSelection = false;
  305. if( nSel < 0 && nCount > 0 )
  306. {
  307. nSel = nCount - 1;
  308. bInitSelection = true;
  309. }
  310. if( nSel != LB_ERR )
  311. {
  312. while( nSel > 0 )
  313. {
  314. INT nItem = nSel - ( bInitSelection ? 0 : 1 );
  315. if( m_pCB->LbItemIsEnabled( nItem ) )
  316. {
  317. if( nCurSel != nItem )
  318. {
  319. pListBox->SetRedraw( FALSE );
  320. INT nRealSel = pListBox->SetCurSel( nItem );
  321. if( nCurSel != nRealSel )
  322. {
  323. if( dwComboBoxType == CBS_DROPDOWNLIST )
  324. {
  325. INT nTopIndex = pListBox->GetTopIndex();
  326. m_pCB->SetCurSel( nRealSel );
  327. pListBox->SetTopIndex( nTopIndex );
  328. }
  329. else
  330. {
  331. CString sText;
  332. pListBox->GetText( nRealSel, sText );
  333. m_pCB->SetWindowText( sText );
  334. m_pCB->SetEditSel( 0, -1 );
  335. }
  336. bSelChanged = true;
  337. }
  338. pListBox->SetRedraw( TRUE );
  339. pListBox->RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_FRAME );
  340. }
  341. break;
  342. }
  343. nSel--;
  344. }
  345. }
  346. }
  347. break;
  348. case VK_RIGHT:
  349. case VK_DOWN:
  350. {
  351. INT nCount = pListBox->GetCount();
  352. if( nCount == 0 )
  353. break;
  354. // Go down until we find a valid selection then set the current selection to that one
  355. INT nCurSel = pListBox->GetCurSel();
  356. INT nSel = nCurSel;
  357. bool bInitSelection = false;
  358. if( nSel < 0 && nCount > 0 )
  359. {
  360. nSel = 0;
  361. bInitSelection = true;
  362. }
  363. if( nSel != LB_ERR )
  364. {
  365. while( nSel < nCount - 1 )
  366. {
  367. INT nItem = nSel + ( bInitSelection ? 0 : 1 );
  368. if( nItem == nCount )
  369. break;
  370. if( m_pCB->LbItemIsEnabled( nItem ) )
  371. {
  372. if( nCurSel != nItem )
  373. {
  374. pListBox->SetRedraw( FALSE );
  375. INT nRealSel = pListBox->SetCurSel( nItem );
  376. if( nCurSel != nRealSel )
  377. {
  378. if( dwComboBoxType == CBS_DROPDOWNLIST )
  379. {
  380. INT nTopIndex = pListBox->GetTopIndex();
  381. m_pCB->SetCurSel( nRealSel );
  382. pListBox->SetTopIndex( nTopIndex );
  383. }
  384. else
  385. {
  386. CString sText;
  387. pListBox->GetText( nRealSel, sText );
  388. m_pCB->SetWindowText( sText );
  389. m_pCB->SetEditSel( 0, -1 );
  390. }
  391. bSelChanged = true;
  392. }
  393. pListBox->SetRedraw( TRUE );
  394. pListBox->RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_FRAME );
  395. }
  396. break;
  397. }
  398. nSel++;
  399. }
  400. }
  401. }
  402. break;
  403. case VK_PRIOR:
  404. {
  405. INT nCount = pListBox->GetCount();
  406. if( nCount == 0 )
  407. break;
  408.   INT nTopIndex = pListBox->GetTopIndex();
  409. INT nCurSel = pListBox->GetCurSel();
  410. if( nCurSel == 0 && nTopIndex == 0 )
  411. break;
  412. SCROLLINFO _scroll_info;
  413. ::memset( &_scroll_info, 0, sizeof(SCROLLINFO) );
  414. _scroll_info.cbSize = sizeof(SCROLLINFO);
  415. if( ! pListBox->GetScrollInfo( SB_VERT, &_scroll_info ) )
  416. break;
  417. INT nNewSel = _scroll_info.nPos - _scroll_info.nPage;
  418. if( nNewSel < 0 )
  419. nNewSel = 0;
  420. if( nNewSel != nCurSel || nTopIndex != nNewSel  )
  421. {
  422. pListBox->SetRedraw( FALSE );
  423. if( nTopIndex != nNewSel )
  424. pListBox->SetTopIndex( nNewSel );
  425. if( nNewSel != nCurSel )
  426. {
  427. m_pCB->SetCurSel( nNewSel );
  428. bSelChanged = true;
  429. }
  430. if( dwComboBoxType != CBS_DROPDOWNLIST )
  431. {
  432. CString sText;
  433. pListBox->GetText( nNewSel, sText );
  434. m_pCB->SetWindowText( sText );
  435. m_pCB->SetEditSel( 0, -1 );
  436. }
  437. pListBox->SetRedraw( TRUE );
  438. pListBox->RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_FRAME );
  439. }
  440. }
  441. break;
  442. case VK_NEXT:
  443. {
  444. INT nCount = pListBox->GetCount();
  445. if( nCount == 0 )
  446. break;
  447.   INT nTopIndex = pListBox->GetTopIndex();
  448. INT nCurSel = pListBox->GetCurSel();
  449. SCROLLINFO _scroll_info;
  450. ::memset( &_scroll_info, 0, sizeof(SCROLLINFO) );
  451. _scroll_info.cbSize = sizeof(SCROLLINFO);
  452. if( ! pListBox->GetScrollInfo( SB_VERT, &_scroll_info ) )
  453. break;
  454. INT nNewTopIndex = _scroll_info.nPos + _scroll_info.nPage;
  455. INT nNewSel = nNewTopIndex + _scroll_info.nPage - 1;
  456. if( nNewSel >= nCount )
  457. nNewSel = nCount - 1;
  458. if( nNewSel != nCurSel || nNewTopIndex != nTopIndex )
  459. {
  460. pListBox->SetRedraw( FALSE );
  461. if( nNewSel != nCurSel )
  462. {
  463. m_pCB->SetCurSel( nNewSel );
  464. bSelChanged = true;
  465. }
  466. if( nNewTopIndex != nTopIndex )
  467. m_pCB->SetTopIndex( nNewTopIndex );
  468. if( dwComboBoxType != CBS_DROPDOWNLIST )
  469. {
  470. CString sText;
  471. pListBox->GetText( nNewSel, sText );
  472. m_pCB->SetWindowText( sText );
  473. m_pCB->SetEditSel( 0, -1 );
  474. }
  475. pListBox->SetRedraw( TRUE );
  476. pListBox->RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_FRAME );
  477. }
  478. }
  479. break;
  480. case VK_HOME:
  481. {
  482. INT nCount = pListBox->GetCount();
  483. if( nCount == 0 )
  484. break;
  485. // Select first non-disabled item
  486. INT nCurSel = pListBox->GetCurSel();
  487. INT nSel = 0;
  488. while( nSel < nCount - 1 )
  489. {
  490. INT nItem = nSel;
  491. if( m_pCB->LbItemIsEnabled( nItem ) )
  492. {
  493. if( nCurSel != nItem )
  494. {
  495. pListBox->SetRedraw( FALSE );
  496. INT nRealSel = pListBox->SetCurSel( nItem );
  497. if( nCurSel != nRealSel )
  498. {
  499. if( dwComboBoxType == CBS_DROPDOWNLIST )
  500. {
  501. INT nTopIndex = pListBox->GetTopIndex();
  502. m_pCB->SetCurSel( nRealSel );
  503. pListBox->SetTopIndex( nTopIndex );
  504. }
  505. else
  506. {
  507. CString sText;
  508. pListBox->GetText( nRealSel, sText );
  509. m_pCB->SetWindowText( sText );
  510. m_pCB->SetEditSel( 0, -1 );
  511. }
  512. bSelChanged = true;
  513. }
  514. pListBox->SetRedraw( TRUE );
  515. pListBox->RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_FRAME );
  516. }
  517. break;
  518. }
  519. nSel++;
  520. }
  521. }
  522. break;
  523. case VK_END:
  524. {
  525. INT nCount = pListBox->GetCount();
  526. if( nCount == 0 )
  527. break;
  528. // Select last non-disabled item
  529. INT nCurSel = pListBox->GetCurSel();
  530. INT nSel = nCount;
  531. while( nSel > 0 )
  532. {
  533. INT nItem = nSel - 1;
  534. if( m_pCB->LbItemIsEnabled( nItem ) )
  535. {
  536. if( nCurSel != nItem )
  537. {
  538. pListBox->SetRedraw( FALSE );
  539. INT nRealSel = pListBox->SetCurSel( nItem );
  540. if( nCurSel != nRealSel )
  541. {
  542. if( dwComboBoxType == CBS_DROPDOWNLIST )
  543. {
  544. INT nTopIndex = pListBox->GetTopIndex();
  545. m_pCB->SetCurSel( nRealSel );
  546. pListBox->SetTopIndex( nTopIndex );
  547. }
  548. else
  549. {
  550. CString sText;
  551. pListBox->GetText( nRealSel, sText );
  552. m_pCB->SetWindowText( sText );
  553. m_pCB->SetEditSel( 0, -1 );
  554. }
  555. bSelChanged = true;
  556. }
  557. pListBox->SetRedraw( TRUE );
  558. pListBox->RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_FRAME );
  559. }
  560. break;
  561. }
  562. nSel--;
  563. }
  564. }
  565. break;
  566. default:
  567. CWnd::OnKeyDown( nChar, nRepCnt, nFlags );
  568. return;
  569. } // switch( nChar )
  570. if( bSelChanged )
  571. {
  572. // The CBN_SELCHANGE notification message is not sent when the selection 
  573. // is changed using the CB_SETCURSEL message. 
  574. if( ! m_pCB->m_bEnableSelChangeWorkaround  )
  575. {
  576. CWnd * pWnd = m_pCB->GetParent();
  577. if( pWnd->GetSafeHwnd() != NULL )
  578. {
  579. ASSERT_VALID( pWnd );
  580. pWnd->SendMessage(
  581. WM_COMMAND,
  582. MAKEWPARAM( m_pCB->GetDlgCtrlID(), CBN_SELCHANGE ),
  583. (LPARAM) m_hWnd
  584. );
  585. }
  586. }
  587. }
  588. return;
  589. } // if( ... && m_pCB->GetDroppedState() )
  590. CWnd::OnKeyDown( nChar, nRepCnt, nFlags );
  591. }
  593. /////////////////////////////////////////////////////////////////////////////
  594. // CExtComboBoxFilterPopupListBox::LB_ITEM
  595. //////////////////////////////////////////////////////////////////////////
  597. CExtComboBoxFilterPopupListBox::LB_ITEM::LB_ITEM()
  598. {
  599. m_lParam = 0L;
  600. }
  602. CExtComboBoxFilterPopupListBox::LB_ITEM::~LB_ITEM()
  603. {
  604. }
  606. LPARAM CExtComboBoxFilterPopupListBox::LB_ITEM::LParamGet() const
  607. {
  608. return m_lParam;
  609. }
  611. void CExtComboBoxFilterPopupListBox::LB_ITEM::LParamSet( 
  612. LPARAM lParam 
  613. )
  614. {
  615. m_lParam = lParam;
  616. }
  618. //////////////////////////////////////////////////////////////////////////
  619. // CExtComboBoxFilterPopupListBox
  620. //////////////////////////////////////////////////////////////////////////
  622. IMPLEMENT_DYNAMIC( CExtComboBoxFilterPopupListBox, CListBox );
  624. BEGIN_MESSAGE_MAP(CExtComboBoxFilterPopupListBox, CListBox)
  625. //{{AFX_MSG_MAP(CExtComboBoxFilterPopupListBox)
  626. ON_WM_MOUSEACTIVATE()
  627. ON_WM_MOUSEMOVE()
  628. ON_WM_LBUTTONDOWN()
  629. ON_WM_LBUTTONUP()
  630. ON_WM_NCLBUTTONDOWN()
  631. ON_WM_SETCURSOR()
  632. ON_WM_CAPTURECHANGED()
  633. ON_WM_CANCELMODE()
  634. ON_WM_NCLBUTTONUP()
  635. ON_WM_NCCALCSIZE()
  636. ON_WM_NCPAINT()
  637. ON_WM_NCLBUTTONDBLCLK()
  638. ON_WM_LBUTTONDBLCLK()
  639. ON_WM_KEYDOWN()
  640. ON_MESSAGE( LB_ADDSTRING, OnLBAddString )
  641. ON_MESSAGE( LB_INSERTSTRING, OnLBInsertString )
  642. ON_MESSAGE( LB_DELETESTRING, OnLBDeleteString )
  643. ON_MESSAGE( LB_RESETCONTENT, OnLBResetContent )
  644. ON_MESSAGE( LB_ADDFILE, OnLBAddFile )
  645. //}}AFX_MSG_MAP
  646. ON_WM_ACTIVATEAPP()
  647. __EXT_MFC_ON_WM_NCHITTEST()
  648. END_MESSAGE_MAP()
  650. CExtComboBoxFilterPopupListBox::CExtComboBoxFilterPopupListBox(
  651. CExtComboBoxBase * pCB // = NULL
  652. )
  653. : m_pCB( pCB )
  654. , m_hWndCB( NULL )
  655. , m_hCursorSizeWE( NULL )
  656. , m_hCursorSizeNS( NULL )
  657. , m_hCursorSizeNWSE( NULL )
  658. , m_bResizingX( false )
  659. , m_bResizingY( false )
  660. , m_ptCursorPosLast( 0, 0 )
  661. {
  662. m_hCursorSizeWE = ::LoadCursor( NULL, IDC_SIZEWE );
  663. ASSERT( m_hCursorSizeWE != NULL );
  664. m_hCursorSizeNS = ::LoadCursor( NULL, IDC_SIZENS );
  665. ASSERT( m_hCursorSizeNS != NULL );
  666. m_hCursorSizeNWSE = ::LoadCursor( NULL, IDC_SIZENWSE );
  667. ASSERT( m_hCursorSizeNWSE != NULL );
  668. }
  670. CExtComboBoxFilterPopupListBox::~CExtComboBoxFilterPopupListBox()
  671. {
  672. LbItemRemoveAll();
  674. if( m_hCursorSizeWE != NULL )
  675. {
  676. ::DestroyCursor( m_hCursorSizeWE );
  677. m_hCursorSizeWE = NULL;
  678. }
  679. if( m_hCursorSizeNS != NULL )
  680. {
  681. ::DestroyCursor( m_hCursorSizeNS );
  682. m_hCursorSizeNS = NULL;
  683. }
  684. if( m_hCursorSizeNWSE != NULL )
  685. {
  686. ::DestroyCursor( m_hCursorSizeNWSE );
  687. m_hCursorSizeNWSE = NULL;
  688. }
  689. }
  690. INT CExtComboBoxFilterPopupListBox::LbItemInsert( 
  691. INT nIndex // = -1
  692. )
  693. {
  694. INT nCount = INT( m_arrLBItems.GetSize() );
  695. if( nIndex < 0 || nIndex > nCount )
  696. nIndex = nCount; // append
  698. LB_ITEM * pItem = new LB_ITEM();
  699. ASSERT( pItem != NULL );
  700. m_arrLBItems.InsertAt( nIndex, pItem );
  702. return nIndex;
  703. }
  705. bool CExtComboBoxFilterPopupListBox::LbItemRemove(
  706. LONG nIndex
  707. )
  708. {
  709. INT nCount = INT( m_arrLBItems.GetSize() );
  710. if( nIndex < 0 || nIndex >= nCount )
  711. return false;
  712. LB_ITEM * pItem = m_arrLBItems.GetAt( nIndex );
  713. ASSERT( pItem != NULL );
  714. if( pItem != NULL )
  715. {
  716. delete pItem;
  717. pItem = NULL;
  718. }
  719. m_arrLBItems.RemoveAt( nIndex );
  720. return true;
  721. }
  723. void CExtComboBoxFilterPopupListBox::LbItemRemoveAll()
  724. {
  725. while( m_arrLBItems.GetSize() > 0 )
  726. {
  727. LB_ITEM * pItem = m_arrLBItems[0];
  728. if( pItem != NULL ) 
  729. {
  730. delete pItem;
  731. pItem = NULL;
  732. }
  733. m_arrLBItems.RemoveAt(0);
  734. }
  735. }
  737. CExtComboBoxFilterPopupListBox::LB_ITEM * CExtComboBoxFilterPopupListBox::LbItemGet( 
  738. LONG nIndex 
  739. ) const
  740. {
  741. INT nCount = INT( m_arrLBItems.GetSize() );
  742. if( nIndex < 0 || nIndex >= nCount )
  743. return NULL;
  745. LB_ITEM * pItem = m_arrLBItems.GetAt( nIndex );
  746. ASSERT( pItem != NULL );
  747. return pItem;
  748. }
  750. INT CExtComboBoxFilterPopupListBox::LbItemGetIndexOf( 
  751. const LB_ITEM * pItem 
  752. ) const
  753. {
  754. INT nCount = INT( m_arrLBItems.GetSize() );
  755. for( INT nIndex = 0; nIndex < nCount; nIndex++ )
  756. {
  757. LB_ITEM * pItem2 = m_arrLBItems.GetAt( nIndex );
  758. ASSERT( pItem2 != NULL );
  759. if( pItem2 == pItem )
  760. return nIndex;
  761. }
  762. return -1;
  763. }
  765. INT CExtComboBoxFilterPopupListBox::LbItemGetCount() const
  766. {
  767. INT nCount = INT( m_arrLBItems.GetSize() );
  768. return nCount;
  769. }
  771. LRESULT CExtComboBoxFilterPopupListBox::OnLBAddString( WPARAM wParam, LPARAM lParam )
  772. {
  773. ASSERT_VALID( this );
  774. LRESULT lResult = DefWindowProc( LB_ADDSTRING, wParam, lParam );
  775. if( lResult != LB_ERR )
  776. LbItemInsert( (INT)lResult );
  777. return lResult;
  778. }
  780. LRESULT CExtComboBoxFilterPopupListBox::OnLBInsertString( WPARAM wParam, LPARAM lParam )
  781. {
  782. ASSERT_VALID( this );
  783. LRESULT lResult = DefWindowProc( LB_INSERTSTRING, wParam, lParam );
  784. if( lResult != LB_ERR )
  785. LbItemInsert( (INT)lResult );
  786. return lResult;
  787. }
  789. LRESULT CExtComboBoxFilterPopupListBox::OnLBDeleteString( WPARAM wParam, LPARAM lParam )
  790. {
  791. ASSERT_VALID( this );
  792. LRESULT lResult = DefWindowProc( LB_DELETESTRING, wParam, lParam );
  793. if( lResult != LB_ERR )
  794. LbItemRemove( (LONG)wParam );
  795. return lResult;
  796. }
  798. LRESULT CExtComboBoxFilterPopupListBox::OnLBResetContent( WPARAM wParam, LPARAM lParam )
  799. {
  800. ASSERT_VALID( this );
  801. LRESULT lResult = DefWindowProc( LB_RESETCONTENT, wParam, lParam );
  802. LbItemRemoveAll();
  803. return lResult;
  804. }
  806. LRESULT CExtComboBoxFilterPopupListBox::OnLBAddFile( WPARAM wParam, LPARAM lParam )
  807. {
  808. ASSERT_VALID( this );
  809. LRESULT lResult = DefWindowProc( LB_ADDSTRING, wParam, lParam );
  810. if( lResult != LB_ERR )
  811. LbItemInsert( (INT)lResult );
  812. return lResult;
  813. }
  815. void CExtComboBoxFilterPopupListBox::DrawItem( LPDRAWITEMSTRUCT lpDIS ) 
  816. {
  817. ASSERT_VALID( this );
  818. ASSERT( lpDIS != NULL && lpDIS->hDC != NULL );
  820. if( ! ( m_pCB != NULL && m_hWndCB != NULL && ::IsWindow( m_hWndCB ) ) )
  821. return;
  823. if( (GetStyle() & CBS_HASSTRINGS) == 0 
  824. && (GetStyle() & LBS_HASSTRINGS) == 0 
  825. )
  826. return;
  828. INT nCount = GetCount();
  829. INT nItem = lpDIS->itemID;
  830. if( nItem < 0 || nItem >= nCount )
  831. return;
  833. LB_ITEM * pFLbItem = LbItemGet( nItem );
  834. ASSERT( pFLbItem != NULL );
  835. if( pFLbItem != NULL )
  836. {
  837. CExtComboBoxBase::LB_ITEM * pLbItem = (CExtComboBoxBase::LB_ITEM *) pFLbItem->LParamGet();
  838. ASSERT( pLbItem != NULL );
  839. if( pLbItem != NULL )
  840. {
  841. CDC dc;
  842. dc.Attach( lpDIS->hDC );
  843. if( lpDIS->itemAction & (ODA_DRAWENTIRE | ODA_SELECT) )
  844. {
  845. CRect rcErase( lpDIS->rcItem );
  846. if( nItem == ( nCount - 1 ) )
  847. {
  848. CRect rcClient;
  849. GetClientRect( &rcClient );
  850. if( rcErase.bottom < rcClient.bottom )
  851. rcErase.bottom = rcClient.bottom;
  852. }
  853. dc.FillSolidRect(
  854. rcErase, 
  855. m_pCB->PmBridge_GetPM()->GetColor( COLOR_WINDOW, this )
  856. );
  857. }
  859. m_pCB->OnPopupListBoxDrawItem( 
  860. dc,
  861. lpDIS->rcItem,
  862. m_pCB->OnPopupListBoxCalcItemExtraSizes( nItem ),
  863. lpDIS->itemState,
  864. pLbItem 
  865. );
  867. dc.Detach();
  869. } // if( pLbItem != NULL )
  871. } // if( pFLbItem != NULL )
  872. }
  874. void CExtComboBoxFilterPopupListBox::MeasureItem( LPMEASUREITEMSTRUCT lpMIS ) 
  875. {
  876. if( m_pCB != NULL && m_hWndCB != NULL && ::IsWindow( m_hWndCB ) )
  877. m_pCB->OnPopupListBoxMeasureItem( lpMIS );
  878. }
  880. LRESULT CExtComboBoxFilterPopupListBox::WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  881. {
  882. switch( message )
  883. {
  884. case WM_ERASEBKGND:
  885. if(  (GetStyle() & LBS_OWNERDRAWFIXED) != 0 
  886. || (GetStyle() & LBS_OWNERDRAWVARIABLE) != 0 
  887. )
  888. return TRUE;
  889. break;
  890. case WM_PAINT:
  891. if(  (GetStyle() & LBS_OWNERDRAWFIXED) != 0 
  892. || (GetStyle() & LBS_OWNERDRAWVARIABLE) != 0 
  893. )
  894. {
  895. CPaintDC dcPaint( this );
  896. CRect rcClient;
  897. GetClientRect( &rcClient );
  898. CExtMemoryDC dc( &dcPaint, &rcClient );
  899. if( m_pCB != NULL && m_hWndCB != NULL && ::IsWindow( m_hWndCB ) )
  900. {
  901. CExtPaintManager * pPM = m_pCB->PmBridge_GetPM();
  902. ASSERT_VALID( pPM );
  903. dc.FillSolidRect( &rcClient, pPM->GetColor( COLOR_WINDOW, this ) );
  904. HFONT hFont = m_pCB->OnQueryFont();
  905. if( hFont == NULL )
  906. hFont = (HFONT)pPM->m_FontNormal.GetSafeHandle();
  907. ASSERT( hFont != NULL );
  908. HFONT hOldFont = (HFONT)::SelectObject( dc.m_hDC, hFont );
  909. INT nCount = GetCount();
  910. for( INT nItem = GetTopIndex(); nItem < nCount; nItem++ )
  911. {
  912. DRAWITEMSTRUCT dis;
  913. ::memset( &dis, 0, sizeof( DRAWITEMSTRUCT ) );
  914. dis.CtlType = ODT_LISTBOX;
  915. dis.CtlID = GetDlgCtrlID();
  916. dis.itemID = nItem;
  917. dis.hDC = dc.GetSafeHdc();
  918. GetItemRect( nItem, &dis.rcItem );
  919. dis.itemAction = ODA_DRAWENTIRE;
  920. dis.hwndItem = GetSafeHwnd();
  921. if( rcClient.bottom < dis.rcItem.top )
  922. break;
  923. if( GetSel( nItem ) > 0 )
  924. dis.itemState |= ODS_SELECTED;
  925. if( GetCurSel() == nItem )
  926. dis.itemState |= ODS_FOCUS;
  927. SendMessage( WM_DRAWITEM, (WPARAM)GetDlgCtrlID(), (LPARAM)&dis );
  928. }
  929. ::SelectObject( dc.m_hDC, hOldFont );
  930. }
  931. return TRUE;
  932. }
  933. break;
  934. }
  935. return CListBox::WindowProc( message, wParam, lParam );
  936. }
  938. void CExtComboBoxFilterPopupListBox::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags ) 
  939. {
  940. ASSERT_VALID( this );
  941. switch( nChar )
  942. {
  943. case VK_LEFT:
  944. case VK_UP:
  945. {
  946. // Go up until we find a valid selection
  947. // then set the current selection to that one
  948. INT nSel = GetCurSel();
  949. bool bInitSelection = false;
  950. INT nCount = GetCount();
  951. if( nSel < 0 && nCount > 0 )
  952. {
  953. nSel = nCount - 1;
  954. bInitSelection = true;
  955. }
  956. if( nSel != LB_ERR )
  957. {
  958. while( nSel >= 0 )
  959. {
  960. INT nItem = nSel - ( bInitSelection ? 0 : 1 );
  961. if( nItem < 0 && nCount > 0 )
  962. nItem = 0;
  964. LB_ITEM * pFLbItem = LbItemGet( nItem );
  965. ASSERT( pFLbItem != NULL );
  967. CExtComboBoxBase::LB_ITEM * pLbItem = NULL;
  968. if( pFLbItem != NULL )
  969. pLbItem = (CExtComboBoxBase::LB_ITEM *) pFLbItem->LParamGet();
  970. ASSERT( pLbItem != NULL );
  972. if( pLbItem->IsEnabled() )
  973. {
  974. SetCurSel( nItem );
  975. break;
  976. }
  977. nSel--;
  978. }
  979. }
  980. }
  981. return;
  983. case VK_RIGHT:
  984. case VK_DOWN:
  985. {
  986. // Go down until we find a valid selection
  987. // then set the current selection to that one
  988. INT nSel = GetCurSel();
  989. bool bInitSelection = false;
  990. INT nCount = GetCount();
  991. if( nSel < 0 && nCount > 0 )
  992. {
  993. nSel = 0;
  994. bInitSelection = true;
  995. }
  996. if( nSel != LB_ERR )
  997. {
  998. while( nSel <= nCount - 1 )
  999. {
  1000. INT nItem = nSel + ( bInitSelection ? 0 : 1 );
  1001. if( nItem >= nCount )
  1002. nItem = nCount - 1;
  1004. LB_ITEM * pFLbItem = LbItemGet( nItem );
  1005. ASSERT( pFLbItem != NULL );
  1007. CExtComboBoxBase::LB_ITEM * pLbItem = NULL;
  1008. if( pFLbItem != NULL )
  1009. pLbItem = (CExtComboBoxBase::LB_ITEM *) pFLbItem->LParamGet();
  1010. ASSERT( pLbItem != NULL );
  1012. if( pLbItem->IsEnabled() )
  1013. {
  1014. SetCurSel( nItem );
  1015. break;
  1016. }
  1017. nSel++;
  1018. }
  1019. }
  1020. }
  1021. return;
  1023. case VK_HOME:
  1024. case VK_PRIOR:
  1025. {
  1026. // Select first non-disabled item
  1027. INT nCount = GetCount();
  1028. INT nSel = 0;
  1029. while( nSel < nCount - 1 )
  1030. {
  1031. INT nItem = nSel;
  1033. LB_ITEM * pFLbItem = LbItemGet( nItem );
  1034. ASSERT( pFLbItem != NULL );
  1036. CExtComboBoxBase::LB_ITEM * pLbItem = NULL;
  1037. if( pFLbItem != NULL )
  1038. pLbItem = (CExtComboBoxBase::LB_ITEM *) pFLbItem->LParamGet();
  1039. ASSERT( pLbItem != NULL );
  1041. if( pLbItem->IsEnabled() )
  1042. {
  1043. SetCurSel( nItem );
  1044. break;
  1045. }
  1047. nSel++;
  1048. }
  1049. }
  1050. return;
  1052. case VK_END:
  1053. case VK_NEXT:
  1054. {
  1055. // Select last non-disabled item
  1056. INT nCount = GetCount();
  1057. INT nSel = nCount;
  1058. while( nSel > 0 )
  1059. {
  1060. INT nItem = nSel - 1;
  1062. LB_ITEM * pFLbItem = LbItemGet( nItem );
  1063. ASSERT( pFLbItem != NULL );
  1065. CExtComboBoxBase::LB_ITEM * pLbItem = NULL;
  1066. if( pFLbItem != NULL )
  1067. pLbItem = (CExtComboBoxBase::LB_ITEM *) pFLbItem->LParamGet();
  1068. ASSERT( pLbItem != NULL );
  1070. if( pLbItem->IsEnabled() )
  1071. {
  1072. SetCurSel( nItem );
  1073. break;
  1074. }
  1076. nSel--;
  1077. }
  1078. }
  1079. return;
  1081. default:
  1082. break;
  1083. }
  1085. CListBox::OnKeyDown( nChar, nRepCnt, nFlags );
  1086. }
  1088. LONG CExtComboBoxFilterPopupListBox::HitTest( 
  1089. const POINT & ptClient
  1090. ) const
  1091. {
  1092. ASSERT_VALID( this );
  1093. if( GetSafeHwnd() == NULL
  1094. || ( ! ::IsWindow( GetSafeHwnd() ) )
  1095. )
  1096. return HTNOWHERE;
  1098. CPoint ptWnd( ptClient );
  1099. ClientToScreen( &ptWnd );
  1100. CRect rcWnd;
  1101. GetWindowRect( &rcWnd );
  1103. CRect rcGrip( rcWnd );
  1104. rcGrip.top = rcGrip.bottom - ::GetSystemMetrics( SM_CYVSCROLL );
  1105. rcGrip.left = rcGrip.right - ::GetSystemMetrics( SM_CXVSCROLL );
  1106. if( rcGrip.PtInRect( ptWnd ) )
  1107. return HTBOTTOMRIGHT;
  1109. CRect rcBottom( rcWnd );
  1110. rcBottom.top = rcBottom.bottom - ::GetSystemMetrics( SM_CYEDGE );
  1111. if( rcBottom.PtInRect( ptWnd ) )
  1112. return HTBOTTOM;
  1114. CRect rcRight( rcWnd );
  1115. rcRight.left = rcRight.right - ::GetSystemMetrics( SM_CXEDGE );
  1116. if( rcRight.PtInRect( ptWnd ) )
  1117. return HTRIGHT;
  1119. if( rcWnd.PtInRect( ptWnd ) )
  1120. return HTCLIENT;
  1122. return HTNOWHERE;
  1123. }
  1125. #if _MFC_VER < 0x700
  1126. void CExtComboBoxFilterPopupListBox::OnActivateApp(BOOL bActive, HTASK hTask) 
  1127. #else
  1128. void CExtComboBoxFilterPopupListBox::OnActivateApp(BOOL bActive, DWORD hTask) 
  1129. #endif
  1130. {
  1131. CListBox::OnActivateApp(bActive, hTask);
  1132. if( ! bActive )
  1133. SendMessage( WM_CANCELMODE );
  1134. }
  1136. void CExtComboBoxFilterPopupListBox::OnCancelMode() 
  1137. {
  1138. CListBox::OnCancelMode();
  1140. if( ::GetCapture() == GetSafeHwnd() )
  1141. ::ReleaseCapture();
  1143. m_bResizingX = false;
  1144. m_bResizingY = false;
  1145. m_ptCursorPosLast = CPoint( 0, 0 );
  1147. Invalidate();
  1148. UpdateWindow();
  1149. }
  1151. void CExtComboBoxFilterPopupListBox::OnCaptureChanged(CWnd *pWnd) 
  1152. {
  1153. CListBox::OnCaptureChanged(pWnd);
  1154. if( ::GetCapture() != m_hWnd )
  1155. SendMessage( WM_CANCELMODE );
  1156. }
  1158. void CExtComboBoxFilterPopupListBox::OnLButtonDown(UINT nFlags, CPoint point) 
  1159. {
  1160. if( !_ProcessMouseClick( point, true, MK_LBUTTON ) )
  1161. CListBox::OnLButtonDown(nFlags, point);
  1162. }
  1164. void CExtComboBoxFilterPopupListBox::OnLButtonUp(UINT nFlags, CPoint point) 
  1165. {
  1166. if( !_ProcessMouseClick( point, false, MK_LBUTTON ) )
  1167. CListBox::OnLButtonUp(nFlags, point);
  1168. }
  1170. void CExtComboBoxFilterPopupListBox::OnNcLButtonDblClk(UINT nHitTest, CPoint point) 
  1171. {
  1172. if( !_ProcessMouseClick( point, true, MK_LBUTTON ) )
  1173. CListBox::OnNcLButtonDblClk(nHitTest, point);
  1174. }
  1176. void CExtComboBoxFilterPopupListBox::OnLButtonDblClk(UINT nFlags, CPoint point) 
  1177. {
  1178. if( !_ProcessMouseClick( point, true, MK_LBUTTON ) )
  1179. CListBox::OnLButtonDblClk(nFlags, point);
  1180. }
  1182. void CExtComboBoxFilterPopupListBox::OnNcLButtonDown(UINT nHitTest, CPoint point) 
  1183. {
  1184. if( !_ProcessMouseClick( point, true, MK_LBUTTON ) )
  1185. CListBox::OnNcLButtonDown(nHitTest, point);
  1186. }
  1188. void CExtComboBoxFilterPopupListBox::OnNcLButtonUp(UINT nHitTest, CPoint point) 
  1189. {
  1190. if( !_ProcessMouseClick( point, false, MK_LBUTTON ) )
  1191. CListBox::OnNcLButtonUp(nHitTest, point);
  1192. }
  1194. void CExtComboBoxFilterPopupListBox::OnMouseMove(UINT nFlags, CPoint point) 
  1195. {
  1196. if( !_ProcessMouseMove( point ) )
  1197. CListBox::OnMouseMove(nFlags, point);
  1198. }
  1200. bool CExtComboBoxFilterPopupListBox::_ProcessMouseClick(
  1201. CPoint point,
  1202. bool bButtonPressed,
  1203. INT nMouseButton // MK_... values
  1204. )
  1205. {
  1206. ASSERT_VALID( this );
  1208. // process only left mouse button clicks
  1209. if( nMouseButton != MK_LBUTTON )
  1210. return false;
  1212. // select item
  1213. if( (! bButtonPressed)
  1214. &&  (! m_bResizingX)
  1215. &&  (! m_bResizingY)
  1216. )
  1217. {
  1218. INT nCount = GetCount();
  1219. if( nCount > 0 )
  1220. {
  1221. BOOL bOutside = TRUE;
  1222. INT nHitTest = (INT) ItemFromPoint( point, bOutside );
  1223. if( !bOutside )
  1224. {
  1225. LB_ITEM * pFLbItem = LbItemGet( nHitTest );
  1226. ASSERT( pFLbItem != NULL );
  1228. CExtComboBoxBase::LB_ITEM * pLbItem = NULL;
  1229. if( pFLbItem != NULL )
  1230. pLbItem = (CExtComboBoxBase::LB_ITEM *) pFLbItem->LParamGet();
  1231. ASSERT( pLbItem != NULL );
  1233. if( pLbItem->IsEnabled() )
  1234. {
  1235. SetCurSel( nHitTest );
  1236. if( m_pCB != NULL && m_hWndCB != NULL && ::IsWindow( m_hWndCB ) )
  1237. m_pCB->OnFilterPopupListSelEndOK();
  1238. }
  1239. }
  1240. }
  1241. return true;
  1242. }
  1244. LONG nHT = HitTest( point );
  1246. m_bResizingX = false;
  1247. m_bResizingY = false;
  1248. m_ptCursorPosLast = CPoint( 0, 0 );
  1250. if( bButtonPressed )
  1251. {
  1252. if( nHT == HTBOTTOMRIGHT )
  1253. m_bResizingX = m_bResizingY = true;
  1254. if( nHT == HTRIGHT )
  1255. m_bResizingX = true;
  1256. if( nHT == HTBOTTOM )
  1257. m_bResizingY = true;
  1258. if( m_bResizingX || m_bResizingY )
  1259. {
  1260. m_ptCursorPosLast = point;
  1261. if( ::GetCapture() != GetSafeHwnd() )
  1262. ::SetCapture( GetSafeHwnd() );
  1263. return true;
  1264. }
  1265. }
  1266. else
  1267. {
  1268. if( ::GetCapture() == GetSafeHwnd() )
  1269. ::ReleaseCapture();
  1270. }
  1272. if( nHT == HTCLIENT )
  1273. return true;
  1275. return false;
  1276. }
  1278. bool CExtComboBoxFilterPopupListBox::_ProcessMouseMove( CPoint point )
  1279. {
  1280. ASSERT_VALID( this );
  1281. if( CExtPopupMenuWnd::IsMenuTracking() 
  1282. || (! CExtPopupMenuWnd::TestHoverEnabledFromActiveHWND( GetSafeHwnd() ) )
  1283. )
  1284. return false;
  1286. LONG nHT = HitTest( point );
  1287. if( nHT == HTCLIENT 
  1288. && !(m_bResizingX || m_bResizingY)
  1289. && m_ptCursorPosLast != point
  1290. )
  1291. {
  1292. INT nCount = GetCount();
  1293. if( nCount == 0 )
  1294. return true;
  1296. BOOL bOutside = TRUE;
  1297. INT nHitTest = (INT) ItemFromPoint( point, bOutside );
  1298. if( bOutside )
  1299. {
  1300. INT nTop = GetTopIndex();
  1301. if( nHitTest <= nTop )
  1302. {
  1303. if( nTop > 0 )
  1304. nHitTest--;
  1305. }
  1306. else
  1307. {
  1308. if( nCount > 0 && nHitTest >= (nCount-2) )
  1309. nHitTest++;
  1310. }
  1311. } // if( bOutside )
  1313. m_ptCursorPosLast = point;
  1315. INT nCurSel = GetCurSel();
  1316. if( nCurSel == nHitTest )
  1317. return true;
  1319. SetRedraw( FALSE );
  1320. SetCurSel( nHitTest );
  1321. SetRedraw( TRUE );
  1322. RedrawWindow(
  1323. NULL,
  1324. NULL,
  1325. RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_FRAME
  1326. );
  1328. return true;
  1329. }
  1331. // resize window
  1332. if( ( m_bResizingX || m_bResizingY )
  1333. && m_ptCursorPosLast != point
  1334. && m_pCB != NULL && m_hWndCB != NULL && ::IsWindow( m_hWndCB )
  1335. )
  1336. {
  1337. CRect rcWindow;
  1338. GetWindowRect( &rcWindow );
  1339. CRect rcWindowNew = rcWindow;
  1341. CRect rcClient;
  1342. GetClientRect( &rcClient );
  1344. CSize szMin = m_pCB->OnFilterPopupListQueryMinSize();
  1345. CSize szMax = m_pCB->OnFilterPopupListQueryMaxSize();
  1347. if( m_bResizingX 
  1348. && point.x > szMin.cx 
  1349. && ( point.x < szMax.cx || szMax.cx < 0 )
  1350. )
  1351. {
  1352. INT nOffsetX = point.x - m_ptCursorPosLast.x;
  1353. rcWindowNew.right += nOffsetX;
  1354. m_ptCursorPosLast.x += nOffsetX;
  1355. }
  1356. if( m_bResizingY 
  1357. && point.y > szMin.cy 
  1358. && ( point.y < szMax.cy || szMax.cy < 0 )
  1359. )
  1360. {
  1361. INT nOffsetY = point.y - m_ptCursorPosLast.y;
  1362. rcWindowNew.bottom += nOffsetY;
  1363. m_ptCursorPosLast.y += nOffsetY;
  1364. }
  1366. if( rcWindowNew != rcWindow )
  1367. {
  1368. SetWindowPos(
  1369. NULL,
  1370. 0,0,
  1371. rcWindowNew.Width(), rcWindowNew.Height(),
  1372. SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_NOMOVE 
  1373. | SWP_NOACTIVATE | SWP_NOSENDCHANGING
  1374. );
  1375. Invalidate( FALSE );
  1376. UpdateWindow();
  1377. }
  1378. }
  1380. return true;
  1381. }
  1383. BOOL CExtComboBoxFilterPopupListBox::OnSetCursor( CWnd * pWnd, UINT nHitTest, UINT message ) 
  1384. {
  1385. ASSERT_VALID( this );
  1387. CPoint ptClient;
  1388. ::GetCursorPos( &ptClient );
  1389. ScreenToClient( &ptClient );
  1390. LONG nHT = HitTest( ptClient );
  1392. if( nHT == HTBOTTOMRIGHT 
  1393. && m_hCursorSizeNWSE != NULL
  1394. )
  1395. {
  1396. SetCursor( m_hCursorSizeNWSE );
  1397. return TRUE;
  1398. }
  1399. if( nHT == HTRIGHT 
  1400. && m_hCursorSizeWE != NULL
  1401. )
  1402. {
  1403. SetCursor( m_hCursorSizeWE );
  1404. return TRUE;
  1405. }
  1406. if( nHT == HTBOTTOM
  1407. && m_hCursorSizeNS != NULL
  1408. )
  1409. {
  1410. SetCursor( m_hCursorSizeNS );
  1411. return TRUE;
  1412. }
  1413. return CListBox::OnSetCursor(pWnd, nHitTest, message);
  1414. }
  1416. int CExtComboBoxFilterPopupListBox::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message) 
  1417. {
  1418. if( (GetStyle()&WS_TABSTOP) == 0 )
  1419. return MA_NOACTIVATE;
  1420. return CWnd::OnMouseActivate(pDesktopWnd, nHitTest, message);
  1421. }
  1423. UINT CExtComboBoxFilterPopupListBox::OnNcHitTest( CPoint point ) 
  1424. {
  1425. CPoint ptClient = point;
  1426. ScreenToClient( &ptClient );
  1427. LONG nHT = HitTest( ptClient );
  1428. if( nHT != HTCLIENT )
  1429. return HTCLIENT;
  1430. return UINT( CListBox::OnNcHitTest(point) );
  1431. }
  1433. void CExtComboBoxFilterPopupListBox::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  1434. {
  1435. CRect & rcNcRect =
  1436. reinterpret_cast < CRect & > ( lpncsp->rgrc[0] );
  1437. rcNcRect.bottom -= 14;
  1439. CListBox::OnNcCalcSize(bCalcValidRects, lpncsp);
  1440. }
  1442. void CExtComboBoxFilterPopupListBox::OnNcPaint() 
  1443. {
  1444. ASSERT_VALID( this );
  1446. Default();
  1448. CRect rcInBarWnd, rcInBarClient;
  1449.     GetWindowRect( &rcInBarWnd );
  1450.     GetClientRect( &rcInBarClient );
  1451.     ClientToScreen( &rcInBarClient );
  1452.     if( rcInBarWnd == rcInBarClient )
  1453.         return;
  1455. CPoint ptDevOffset = -rcInBarWnd.TopLeft();
  1456.     rcInBarWnd.OffsetRect( ptDevOffset );
  1457.     rcInBarClient.OffsetRect( ptDevOffset );
  1458.    
  1459. CWindowDC dc( this );
  1461. const INT cx = ::GetSystemMetrics(SM_CXVSCROLL);
  1462. const INT cy = ::GetSystemMetrics(SM_CYHSCROLL);
  1464. DWORD dwStyle = GetStyle();
  1465. bool bHasVerticalSB = ( (dwStyle&WS_VSCROLL) != 0 ) ? true : false;
  1466. bool bHasHorizontalSB = ( (dwStyle&WS_HSCROLL) != 0 ) ? true : false;
  1468. COLORREF clrWindow =
  1469. ( m_pCB != NULL && m_hWndCB != NULL && ::IsWindow( m_hWndCB ) )
  1470. ? m_pCB->PmBridge_GetPM()->GetColor( COLOR_WINDOW, this )
  1471. : ::GetSysColor( COLOR_WINDOW )
  1472. ;
  1474.     if( bHasVerticalSB && bHasHorizontalSB )
  1475.     {
  1476. INT nNcX = rcInBarWnd.right - rcInBarClient.right - cx;
  1477. INT nNcY = rcInBarWnd.bottom - rcInBarClient.bottom - cy;
  1478.         dc.FillSolidRect(
  1479.             rcInBarWnd.right - cx - nNcX,
  1480.             rcInBarWnd.bottom - cy - nNcY,
  1481.             cx,
  1482.             cy,
  1483. clrWindow
  1484.             );
  1485.     }
  1487. CRect rcExclude( rcInBarClient );
  1488.     if( bHasVerticalSB )
  1489.         rcExclude.right += cx;
  1490.     if( bHasHorizontalSB )
  1491.         rcExclude.bottom += cy;
  1493. dc.ExcludeClipRect( &rcExclude );
  1495. rcInBarWnd.DeflateRect( 1, 1 );
  1497.     dc.FillSolidRect( &rcInBarWnd, clrWindow );
  1499. CRect rcGrip( rcInBarWnd );
  1500. g_PaintManager->PaintResizingGripper(
  1501. dc,
  1502. rcGrip,
  1503. this
  1504. );
  1506. dc.SelectClipRgn( NULL );
  1507. }
  1509. /////////////////////////////////////////////////////////////////////////////
  1510. // CExtComboEditCtrlHook
  1511. /////////////////////////////////////////////////////////////////////////////
  1513. CExtComboEditCtrlHook::CExtComboEditCtrlHook()
  1514. {
  1515. }
  1517. CExtComboEditCtrlHook::~CExtComboEditCtrlHook()
  1518. {
  1519. }
  1521. CExtComboBoxBase * CExtComboEditCtrlHook::OnQueryComboBox() const
  1522. {
  1523. ASSERT( GetSafeHwnd() != NULL );
  1524. ASSERT( ::IsWindow(GetSafeHwnd()) );
  1525. HWND hWndParent = ::GetParent( GetSafeHwnd() );
  1526. ASSERT( hWndParent != NULL );
  1527. ASSERT( ::IsWindow(hWndParent) );
  1528. CExtComboBoxBase * pCombo = 
  1529. DYNAMIC_DOWNCAST(
  1530. CExtComboBoxBase,
  1531. FromHandlePermanent(hWndParent)
  1532. );
  1533. ASSERT( pCombo != NULL );
  1534. return pCombo;
  1535. }
  1537. IMPLEMENT_DYNCREATE( CExtComboEditCtrlHook, CExtEditBase );
  1539. BEGIN_MESSAGE_MAP(CExtComboEditCtrlHook, CExtEditBase)
  1540. //{{AFX_MSG_MAP(CExtComboEditCtrlHook)
  1541. ON_WM_CONTEXTMENU()
  1542. ON_WM_DESTROY()
  1543. //}}AFX_MSG_MAP
  1544. END_MESSAGE_MAP()
  1546. LRESULT CExtComboEditCtrlHook::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  1547. {
  1548. bool bFlushAutoComplete = false;
  1550. switch( message )
  1551. {
  1552. case WM_CUT:
  1553. case WM_COPY:
  1554. case WM_PASTE:
  1555. case WM_CLEAR:
  1556. case WM_UNDO:
  1557. bFlushAutoComplete = true;
  1558. break;
  1559. case WM_COMMAND:
  1560. switch( LOWORD(wParam) )
  1561. {
  1562. case ID_EDIT_CLEAR:
  1563. case ID_EDIT_CLEAR_ALL:
  1564. case ID_EDIT_COPY:
  1565. case ID_EDIT_CUT:
  1566. case ID_EDIT_FIND:
  1567. case ID_EDIT_PASTE:
  1568. case ID_EDIT_PASTE_LINK:
  1569. case ID_EDIT_PASTE_SPECIAL:
  1570. case ID_EDIT_REPEAT:
  1571. case ID_EDIT_REPLACE:
  1572. case ID_EDIT_SELECT_ALL:
  1573. case ID_EDIT_UNDO:
  1574. case ID_EDIT_REDO:
  1575. bFlushAutoComplete = true;
  1576. break;
  1577. } // switch( LOWORD(wParam) )
  1578. break;
  1579. } // switch( message )
  1581. if( bFlushAutoComplete )
  1582. OnQueryComboBox()->m_bAutoComplete = false;
  1584. return CExtEditBase::WindowProc(message,wParam,lParam);
  1585. }
  1587. __EXT_MFC_INT_PTR CExtComboEditCtrlHook::OnToolHitTest(
  1588. CPoint point,
  1589. TOOLINFO * pTI
  1590. ) const
  1591. {
  1592. __PROF_UIS_MANAGE_STATE;
  1593. __EXT_MFC_IMPLEMENT_TT_REDIR_OnToolHitTest_EX( CExtComboEditCtrlHook, CExtToolControlBar, m_wndToolTip, point, pTI, 2 )
  1594. return CExtEditBase::OnToolHitTest( point, pTI );
  1595. }
  1597. void CExtComboEditCtrlHook::OnContextMenu(CWnd* pWnd,CPoint pos )
  1598. {
  1599. if( ! m_bHandleCtxMenus )
  1600. {
  1601. CExtEditBase::OnContextMenu( pWnd, pos );
  1602. return;
  1603. }
  1605. CExtComboBoxBase * pCombo = OnQueryComboBox();
  1606. if( pCombo == NULL )
  1607. return;
  1608. m_bHandleCtxMenus = pCombo->m_bHandleCtxMenus;
  1609. SetFocus();
  1611. CExtEditBase::OnContextMenu( pWnd, pos );
  1613. VERIFY(
  1614. pCombo->RedrawWindow(
  1615. NULL,
  1616. NULL,
  1617. RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ERASENOW | RDW_FRAME | RDW_ALLCHILDREN
  1618. )
  1619. );
  1620. }
  1622. void CExtComboEditCtrlHook::OnDestroy() 
  1623. {
  1624. //
  1625. // Afreen had problems with this code
  1626. //
  1627. //  CExtComboBoxBase * pCB = OnQueryComboBox();
  1628. //  ASSERT( pCB != NULL );
  1629. //  if( pCB != NULL )
  1630. //  {
  1631. //  ASSERT_VALID( pCB );
  1632. //  pCB->OnFilterPopupListClose();
  1633. //  }
  1634. CExtEditBase::OnDestroy();
  1635. }
  1637. COLORREF CExtComboEditCtrlHook::OnQueryBackColor() const
  1638. { 
  1639. ASSERT_VALID( this );
  1640. CExtComboBoxBase * pCB = OnQueryComboBox();
  1641. return pCB->GetBkColor(); 
  1642. }
  1644. COLORREF CExtComboEditCtrlHook::OnQueryTextColor() const
  1645. { 
  1646. ASSERT_VALID( this );
  1647. CExtComboBoxBase * pCB = OnQueryComboBox();
  1648. return pCB->GetTextColor(); 
  1649. }
  1651. /////////////////////////////////////////////////////////////////////////////
  1652. // CExtComboBoxBase::LB_ITEM::CELL
  1654. CExtComboBoxBase::LB_ITEM::CELL::CELL(
  1655. __EXT_MFC_SAFE_LPCTSTR sItemText // = NULL
  1656. )
  1657. {
  1658. m_sItemText = (sItemText != NULL) ? sItemText : _T("");
  1659. m_nLParam = 0L;
  1660. m_clrText = COLORREF( -1L );
  1661. m_clrBack = COLORREF( -1L );
  1662. }
  1664. CExtComboBoxBase::LB_ITEM::CELL::~CELL()
  1665. {
  1666. }
  1668. /////////////////////////////////////////////////////////////////////////////
  1669. // CExtComboBoxBase::LB_ITEM
  1671. CExtComboBoxBase::LB_ITEM::LB_ITEM()
  1672. {
  1673. m_bEnabled = true;
  1674. }
  1676. CExtComboBoxBase::LB_ITEM::~LB_ITEM()
  1677. {
  1678. while( m_arrItemCells.GetSize() > 0 )
  1679. {
  1680. CELL * pItemCell = m_arrItemCells[0];
  1681. if( pItemCell != NULL ) 
  1682. {
  1683. delete pItemCell;
  1684. pItemCell = NULL;
  1685. }
  1686. m_arrItemCells.RemoveAt(0);
  1687. }
  1688. }
  1690. INT CExtComboBoxBase::LB_ITEM::LbItemCellInsert(
  1691. __EXT_MFC_SAFE_LPCTSTR sItemText, // = NULL
  1692. INT nPos // = -1 // append
  1693. )
  1694. {
  1695. INT nCount = INT( m_arrItemCells.GetSize() );
  1696. if( nPos < 0 || nPos > nCount )
  1697. nPos = nCount; // append
  1699. CELL * pItemCell = new CELL( sItemText );
  1700. ASSERT( pItemCell != NULL );
  1701. m_arrItemCells.InsertAt( nPos, pItemCell );
  1703. return nPos;
  1704. }
  1706. bool CExtComboBoxBase::LB_ITEM::LbItemCellRemove(
  1707. LONG nItem
  1708. )
  1709. {
  1710. INT nCount = INT( m_arrItemCells.GetSize() );
  1711. if( nItem < 0 || nItem >= nCount )
  1712. return false;
  1713. CELL * pItemCell = m_arrItemCells.GetAt( nItem );
  1714. ASSERT( pItemCell != NULL );
  1715. if( pItemCell != NULL )
  1716. {
  1717. delete pItemCell;
  1718. pItemCell = NULL;
  1719. }
  1720. m_arrItemCells.RemoveAt( nItem );
  1721. return true;
  1722. }
  1724. CExtComboBoxBase::LB_ITEM::CELL * CExtComboBoxBase::LB_ITEM::LbItemCellGet( 
  1725. LONG nItem 
  1726. ) const
  1727. {
  1728. INT nCount = INT( m_arrItemCells.GetSize() );
  1729. if( nItem < 0 || nItem >= nCount )
  1730. return NULL;
  1732. CELL * pItemCell = m_arrItemCells.GetAt( nItem );
  1733. ASSERT( pItemCell != NULL );
  1734. return pItemCell;
  1735. }
  1737. INT CExtComboBoxBase::LB_ITEM::LbItemCellGetIndexOf( 
  1738. const CELL * pItemCell 
  1739. ) const
  1740. {
  1741. INT nCount = INT( m_arrItemCells.GetSize() );
  1742. for( INT nItem = 0; nItem < nCount; nItem++ )
  1743. {
  1744. CELL * pItemCell2 = m_arrItemCells.GetAt( nItem );
  1745. ASSERT( pItemCell2 != NULL );
  1746. if( pItemCell2 == pItemCell )
  1747. return nItem;
  1748. }
  1749. return -1;
  1750. }
  1752. INT CExtComboBoxBase::LB_ITEM::LbItemCellGetCount() const
  1753. {
  1754. INT nCount = INT( m_arrItemCells.GetSize() );
  1755. return nCount;
  1756. }
  1758. bool CExtComboBoxBase::LB_ITEM::IsEnabled() const
  1759. {
  1760. return m_bEnabled;
  1761. }
  1763. void CExtComboBoxBase::LB_ITEM::Enable(
  1764. bool bEnable // = true
  1765. )
  1766. {
  1767. m_bEnabled = bEnable;
  1768. }
  1770. /////////////////////////////////////////////////////////////////////////////
  1771. // CExtComboBoxBase
  1773. IMPLEMENT_DYNCREATE( CExtComboBoxBase, CComboBox );
  1775. CExtComboBoxBase::CExtComboBoxBase()
  1776. : m_bAutoComplete( true )
  1777. , m_bHandleCtxMenus( true )
  1778. , m_bEnableAutoComplete( true )
  1779. , m_bUseCaseSensitiveAutoComplete( false )
  1780. , m_clrBack( COLORREF(-1L) )
  1781. , m_clrBackPrev( COLORREF(-1L) )
  1782. , m_clrText( COLORREF(-1L) )
  1783. , m_pPopupListWnd( NULL )
  1784. , m_szFilterPopupListBox( -1, -1 )
  1785. , m_bEnableAutoFilter( false )
  1786. , m_bEnableSelChangeWorkaround( false )
  1787. , m_bInitialized( false )
  1788. , m_pWndPopupListBox( NULL )
  1789. , m_hWndPopupListBox( NULL )
  1790. {
  1791. EnableToolTips();
  1792. }
  1794. CExtComboBoxBase::~CExtComboBoxBase()
  1795. {
  1796. CExtAnimationSite * pAcAS = AnimationClient_SiteGet();
  1797. if( pAcAS != NULL )
  1798. pAcAS->AnimationSite_ClientRemove( this );
  1799. LbItemRemoveAll();
  1800. if( m_pWndPopupListBox != NULL )
  1801. {
  1802. if( m_hWndPopupListBox != NULL
  1803. && ::IsWindow( m_hWndPopupListBox )
  1804. && LPVOID( CWnd::FromHandlePermanent(m_hWndPopupListBox) ) == LPVOID( m_pWndPopupListBox )
  1805. )
  1806. m_pWndPopupListBox->m_pCB = NULL;
  1807. }
  1808. if( m_pPopupListWnd != NULL )
  1809. {
  1810. delete m_pPopupListWnd;
  1811. m_pPopupListWnd = NULL;
  1812. }
  1813. }
  1815. bool CExtComboBoxBase::_OnCbLbPreWndProc( LRESULT & lResult, UINT message, WPARAM wParam, LPARAM lParam )
  1816. {
  1817. lResult; message; wParam; lParam;
  1818. return false;
  1819. }
  1821. void CExtComboBoxBase::_OnCbLbPostWndProc( LRESULT lResult, UINT message, WPARAM wParam, LPARAM lParam )
  1822. {
  1823. lResult; message; wParam; lParam;
  1824. }
  1826. CExtComboBoxPopupListBox * CExtComboBoxBase::OnComboBoxPopupListBoxInstantiate()
  1827. {
  1828. ASSERT_VALID( this );
  1829. // return (new CExtComboBoxPopupListBox);
  1830. bool bSimpleMode = false;
  1831. DWORD dwStyle = GetStyle();
  1832. if( (dwStyle&CBS_SIMPLE) == CBS_SIMPLE 
  1833. && (dwStyle&CBS_DROPDOWN) != CBS_DROPDOWN
  1834. && (dwStyle&CBS_DROPDOWNLIST) != CBS_DROPDOWNLIST 
  1835. )
  1836. bSimpleMode = true;
  1837. CExtNCSB < CExtComboBoxPopupListBox > * pWndPopupListBox = new CExtNCSB < CExtComboBoxPopupListBox >;
  1838. if( bSimpleMode )
  1839. pWndPopupListBox->m_rcNcsbCustomNcAreaSizes.SetRect( 0, 0, 0, 0 );
  1840. return pWndPopupListBox;
  1841. }
  1843. CExtComboBoxPopupListBox * CExtComboBoxBase::OnComboBoxPopupListBoxQuery(
  1844. HWND hWndSubclass // = NULL
  1845. )
  1846. {
  1847. ASSERT_VALID( this );
  1848. if( GetSafeHwnd() == NULL )
  1849. return NULL;
  1850. if( m_pWndPopupListBox != NULL )
  1851. {
  1852. ASSERT_VALID( m_pWndPopupListBox );
  1853. if( hWndSubclass != NULL )
  1854. {
  1855. if( m_pWndPopupListBox->GetSafeHwnd() != hWndSubclass )
  1856. return NULL;
  1857. m_hWndPopupListBox = hWndSubclass;
  1858. }
  1859. return m_pWndPopupListBox;
  1860. }
  1861. if( hWndSubclass == NULL
  1862. || (! ::IsWindow( hWndSubclass ) )
  1863. )
  1864. return NULL;
  1865. try
  1866. {
  1867. m_pWndPopupListBox = OnComboBoxPopupListBoxInstantiate();
  1868. m_pWndPopupListBox->m_pCB = this;
  1869. m_pWndPopupListBox->m_hWndCB = m_hWnd;
  1870. VERIFY( m_pWndPopupListBox->SubclassWindow( hWndSubclass ) );
  1871. m_hWndPopupListBox = hWndSubclass;
  1872. //  m_pWndPopupListBox->RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_FRAME );
  1873. m_pWndPopupListBox->SetWindowPos(
  1874. NULL, 0, 0, 0, 0,
  1875. SWP_NOSIZE|SWP_NOMOVE
  1876. |SWP_NOZORDER|SWP_NOOWNERZORDER
  1877. |SWP_NOREPOSITION
  1878. |SWP_FRAMECHANGED
  1879. );
  1880. return m_pWndPopupListBox;
  1881. }
  1882. catch( CException * pException )
  1883. {
  1884. pException->Delete();
  1885. }
  1886. catch( ... )
  1887. {
  1888. }
  1889. return NULL;
  1890. }
  1892. BEGIN_MESSAGE_MAP(CExtComboBoxBase, CComboBox)
  1893. //{{AFX_MSG_MAP(CExtComboBoxBase)
  1894. ON_MESSAGE(CB_ADDSTRING, OnCBAddString)
  1895. ON_MESSAGE(CB_INSERTSTRING, OnCBInsertString)
  1896. ON_MESSAGE(CB_DELETESTRING, OnCBDeleteString)
  1897. ON_MESSAGE(CB_RESETCONTENT, OnCBResetContent)
  1898. ON_MESSAGE(CB_SETCURSEL, OnCBSetCurSel)
  1899. ON_WM_CTLCOLOR_REFLECT()
  1900. ON_WM_SIZE()
  1901. ON_WM_DESTROY()
  1902. ON_WM_CHARTOITEM()
  1903. ON_WM_KEYDOWN()
  1904. //}}AFX_MSG_MAP
  1905. ON_MESSAGE( WM_CTLCOLORLISTBOX, OnCtlColor )
  1906. END_MESSAGE_MAP()
  1908. /////////////////////////////////////////////////////////////////////////////
  1909. // CExtComboBoxBase message handlers
  1911. CSize CExtComboBoxBase::OnFilterPopupListQueryMinSize()
  1912. {
  1913. return CSize( 40, 20 );
  1914. }
  1916. CSize CExtComboBoxBase::OnFilterPopupListQueryMaxSize()
  1917. {
  1918. return CSize( -1, -1 );
  1919. }
  1921. CSize CExtComboBoxBase::GetFilterPopupListSize() const
  1922. {
  1923. return m_szFilterPopupListBox;
  1924. }
  1926. CSize CExtComboBoxBase::SetFilterPopupListSize( CSize szSize )
  1927. {
  1928. CSize szFilterPopupListBoxOld = m_szFilterPopupListBox;
  1929. m_szFilterPopupListBox = szSize;
  1930. return szFilterPopupListBoxOld;
  1931. }
  1933. bool CExtComboBoxBase::OnHookSpyPreTranslateMessage(
  1934. MSG * pMSG
  1935. )
  1936. {
  1937. ASSERT( pMSG != NULL );
  1938. // if( m_hWnd == NULL 
  1939. // || (!::IsWindow( m_hWnd ))
  1940. // || m_pPopupListWnd->GetSafeHwnd() == NULL 
  1941. // || (!::IsWindow( m_pPopupListWnd->m_hWnd ))
  1942. // || (!m_pPopupListWnd->IsWindowVisible())
  1943. // )
  1944. // return CExtHookSpy::OnHookSpyPreTranslateMessage( pMSG );
  1946. if( m_hWnd != NULL
  1947. && ( GetStyle() & WS_VISIBLE ) != 0
  1948. && ( pMSG->hwnd == m_hWnd 
  1949. || ::IsChild( m_hWnd, pMSG->hwnd )
  1950. || ::GetParent( m_hWnd ) == pMSG->hwnd
  1951. )
  1952. )
  1953. {
  1954. if( pMSG->message == WM_ACTIVATEAPP
  1955. || pMSG->message == WM_CANCELMODE
  1956. || pMSG->message == WM_SETFOCUS
  1957. || pMSG->message == WM_KILLFOCUS
  1958. || pMSG->message == WM_SYSCOMMAND
  1959. || pMSG->message == WM_STYLECHANGING
  1960. || pMSG->message == WM_STYLECHANGED
  1961. || pMSG->message == WM_CLOSE
  1962. || pMSG->message == WM_DESTROY
  1963. || pMSG->message == WM_NCDESTROY
  1964. || pMSG->message == WM_ENABLE
  1965. || pMSG->message == WM_SIZE
  1966. || pMSG->message == WM_NEXTDLGCTL
  1967. || pMSG->message == WM_LBUTTONDOWN
  1968. || pMSG->message == WM_RBUTTONDOWN
  1969. || pMSG->message == WM_MBUTTONDOWN
  1970. || CExtPopupMenuWnd::IsMenuTracking()
  1971. || CExtControlBar::_DraggingGetBar() != NULL
  1972. || ( ( pMSG->message == WM_WINDOWPOSCHANGING
  1973. || pMSG->message == WM_WINDOWPOSCHANGED
  1974. )
  1975. && ( ((LPWINDOWPOS)pMSG->lParam)->flags&(SWP_NOMOVE|SWP_NOSIZE) ) == 0
  1976. )
  1977. || ( ( pMSG->message == WM_ACTIVATE || pMSG->message == WM_MOUSEACTIVATE )
  1978. && (! ::IsChild( m_hWnd, pMSG->hwnd ) ) 
  1979. )
  1980. )
  1981. {
  1982. OnFilterPopupListClose();
  1983. return true;
  1984. }
  1985. }
  1987. return CExtHookSpy::OnHookSpyPreTranslateMessage( pMSG );
  1988. }
  1990. HWND CExtComboBoxBase::AnimationSite_GetSafeHWND() const
  1991. {
  1992. __PROF_UIS_MANAGE_STATE;
  1993. HWND hWnd = GetSafeHwnd();
  1994. return hWnd;
  1995. }
  1997. void CExtComboBoxBase::ShowFilterPopupList( 
  1998. CExtSafeString & sFilterText 
  1999. )
  2000. {
  2001. ASSERT_VALID( this );
  2003. if( m_pPopupListWnd->GetSafeHwnd() == NULL
  2004. || (!::IsWindow( m_pPopupListWnd->m_hWnd ))
  2005. )
  2006. m_pPopupListWnd = OnFilterPopupListCreate();
  2007. if( m_pPopupListWnd == NULL )
  2008. {
  2009. ASSERT( FALSE );
  2010. return;
  2011. }
  2012. ASSERT_VALID( m_pPopupListWnd );
  2014. OnFilterPopupListSyncContents( sFilterText );
  2016. if( sFilterText.IsEmpty()
  2017. || m_pPopupListWnd->GetCount() == 0 
  2018. )
  2019. {
  2020. OnFilterPopupListClose();
  2021. }
  2022. else
  2023. {
  2024. if( ! m_pPopupListWnd->IsWindowVisible() )
  2025. {
  2026. CRect rcWnd;
  2027. GetWindowRect( &rcWnd );
  2029. CSize szMax = OnFilterPopupListQueryMaxSize();
  2030. szMax.cx = szMax.cx > 0 ? szMax.cx : 150;
  2031. szMax.cy = szMax.cy > 0 ? szMax.cy : 100;
  2032. if( m_szFilterPopupListBox.cx < 0 )
  2033. m_szFilterPopupListBox.cx = max( rcWnd.Width(), szMax.cx );
  2034. if( m_szFilterPopupListBox.cy < 0 )
  2035. m_szFilterPopupListBox.cy = max( ::MulDiv( rcWnd.Width(), 2, 3 ), szMax.cy );
  2037. CRect rcPopupListWnd(
  2038. rcWnd.left,
  2039. rcWnd.bottom,
  2040. rcWnd.left + m_szFilterPopupListBox.cx,
  2041. rcWnd.bottom + m_szFilterPopupListBox.cy
  2042. );
  2043. rcPopupListWnd.OffsetRect( 1, 1 );
  2045. m_pPopupListWnd->SetWindowPos(
  2046. NULL,
  2047. rcWnd.left,
  2048. rcWnd.bottom,
  2049. m_szFilterPopupListBox.cx,
  2050. m_szFilterPopupListBox.cy,
  2051. SWP_SHOWWINDOW | SWP_NOZORDER | SWP_NOACTIVATE
  2052. );
  2053. }
  2054. }
  2055. }
  2057. CExtComboBoxFilterPopupListBox * CExtComboBoxBase::OnFilterPopupListCreate()
  2058. {
  2059. ASSERT_VALID( this );
  2061. if( m_pPopupListWnd->GetSafeHwnd() != NULL
  2062. && ::IsWindow( m_pPopupListWnd->m_hWnd )
  2063. )
  2064. return m_pPopupListWnd;
  2066. if( m_pPopupListWnd != NULL )
  2067. {
  2068. delete m_pPopupListWnd;
  2069. m_pPopupListWnd = NULL;
  2070. }
  2072. CExtNCSB < CExtComboBoxFilterPopupListBox > * pPopupListWnd = new CExtNCSB < CExtComboBoxFilterPopupListBox > ( true );
  2073. pPopupListWnd->m_pCB = this;
  2074. pPopupListWnd->m_hWndCB = m_hWnd;
  2075. if( pPopupListWnd == NULL )
  2076. {
  2077. ASSERT( FALSE );
  2078. return NULL;
  2079. }
  2080. ASSERT_VALID( pPopupListWnd );
  2082. if( !pPopupListWnd->CreateEx(
  2083. WS_EX_TOPMOST | WS_EX_WINDOWEDGE,
  2084. _T("LISTBOX"),
  2085. _T(""),
  2086. WS_POPUP | WS_BORDER | WS_VSCROLL | LBS_NOINTEGRALHEIGHT | LBS_HASSTRINGS | LBS_OWNERDRAWVARIABLE,
  2087. CRect(0,0,0,0),
  2088. this,
  2089. UINT(0)
  2090. )
  2091. )
  2092. {
  2093. ASSERT( FALSE );
  2094. return NULL;
  2095. }
  2097. pPopupListWnd->SetFont( 
  2098. CFont::FromHandle( (HFONT)::GetStockObject(DEFAULT_GUI_FONT) ) 
  2099. );
  2101. return pPopupListWnd;
  2102. }
  2104. void CExtComboBoxBase::OnFilterPopupListClose()
  2105. {
  2106. ASSERT_VALID( this );
  2107. if( m_pPopupListWnd->GetSafeHwnd() != NULL 
  2108. && ::IsWindow( m_pPopupListWnd->m_hWnd )
  2109. && m_pPopupListWnd->IsWindowVisible()
  2110. )
  2111. {
  2112. CRect rcWnd;
  2113. m_pPopupListWnd->GetWindowRect( &rcWnd );
  2114. m_szFilterPopupListBox = rcWnd.Size();
  2115. m_pPopupListWnd->SetWindowPos(
  2116. NULL,
  2117. 0,0,0,0,
  2118. SWP_HIDEWINDOW | SWP_NOZORDER | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE
  2119. );
  2120. }
  2121. }
  2123. void CExtComboBoxBase::OnFilterPopupListSyncContents(
  2124. CExtSafeString & sFilterText
  2125. )
  2126. {
  2127. ASSERT_VALID( this );
  2128. if( m_pPopupListWnd->GetSafeHwnd() == NULL 
  2129. || (!::IsWindow( m_pPopupListWnd->m_hWnd ))
  2130. )
  2131. return;
  2133. m_pPopupListWnd->SetRedraw( FALSE );
  2135. m_pPopupListWnd->ResetContent();
  2136. if( !sFilterText.IsEmpty() )
  2137. {
  2138. CStringArray arrTextToRemove; 
  2139. arrTextToRemove.Add( _T("http://") );
  2140. arrTextToRemove.Add( _T("http://www.") );
  2141. arrTextToRemove.Add( _T("ftp://") );
  2142. arrTextToRemove.Add( _T("ftp://www.") );
  2143. arrTextToRemove.Add( _T("file://") );
  2144. arrTextToRemove.Add( _T("www.") );
  2146. INT nLenght = sFilterText.GetLength();
  2147. CString sItemText;
  2149. INT nCount = GetCount();
  2150. for( LONG nItem = 0; nItem < nCount; nItem++ )
  2151. {
  2152. sItemText.Empty();
  2153. GetLBText( nItem, sItemText );
  2155. CString sItemTextToCompare = sItemText;
  2157. for( INT nIndex = 0; nIndex < arrTextToRemove.GetSize(); nIndex++ ) 
  2158. {
  2159. CString sTextToRemove = arrTextToRemove[ nIndex ];
  2160. INT nLenght = sTextToRemove.GetLength();
  2161. CString sItemTextPart = sItemTextToCompare.Left( nLenght );
  2162. if( sItemTextPart.CompareNoCase( sTextToRemove ) == 0 )
  2163. sItemTextToCompare.Delete( 0, nLenght );
  2164. }
  2166. if( sFilterText.CompareNoCase( sItemTextToCompare.Left( nLenght ) ) == 0 )
  2167. {
  2168. INT nItemAdded = m_pPopupListWnd->AddString( sItemText );
  2169. CExtComboBoxFilterPopupListBox::LB_ITEM * pFLbItem = 
  2170. m_pPopupListWnd->LbItemGet( nItemAdded );
  2171. ASSERT( pFLbItem != NULL );
  2172. if( pFLbItem != NULL )
  2173. {
  2174. LB_ITEM * pLbItem = LbItemGet( nItem );
  2175. pFLbItem->LParamSet( (LPARAM) pLbItem  );
  2176. }
  2177. }
  2178. }
  2179. } // if( !sFilterText.IsEmpty() )
  2181. m_pPopupListWnd->SetRedraw( TRUE );
  2182. m_pPopupListWnd->Invalidate();
  2183. m_pPopupListWnd->UpdateWindow();
  2184. }
  2186. BOOL CExtComboBoxBase::OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pLResult) 
  2187. {
  2188. ASSERT_VALID( this );
  2189. if( message == WM_COMMAND )
  2190. {
  2191. INT nCode = HIWORD(wParam);
  2192. switch( nCode )
  2193. {
  2194. case CBN_DROPDOWN:
  2195. OnFilterPopupListClose();
  2196. break;
  2197.         case CBN_SELENDOK:
  2198. {
  2199. DWORD dwWndStyle = GetStyle();
  2200. if( ( dwWndStyle & (CBS_OWNERDRAWFIXED|CBS_OWNERDRAWVARIABLE) ) == 0
  2201. || ( dwWndStyle & CBS_HASSTRINGS ) != 0
  2202. )
  2203. {
  2204. GetWindowText( m_sSavedText );
  2205. PostMessage( __EXT_COMBO_BOX_WM_USER_REALSELENDOK );
  2206. }
  2207. }
  2208. break;
  2209. case CBN_EDITUPDATE:
  2210. OnEditCtrlUpdate();
  2211.     break;
  2212. }
  2213. }
  2214. return CComboBox::OnChildNotify(message, wParam, lParam, pLResult);
  2215. }
  2217. LONG CExtComboBoxBase::FindItemExact(
  2218. __EXT_MFC_SAFE_LPCTSTR lpszString,
  2219. LONG nIndexStart // = -1
  2220. ) const
  2221. {
  2222. ASSERT_VALID( this );
  2223. LONG nCount = GetCount();
  2224. if( nIndexStart < -1 || nIndexStart >= nCount )
  2225. {
  2226. ASSERT( FALSE );
  2227. return CB_ERR;
  2228. }
  2229. LONG nItemsProcessed = 0;
  2230. LONG nItem = nIndexStart;
  2231. while( nItemsProcessed < nCount )
  2232. {
  2233. if( nItem == -1 )
  2234. nItem = 0;
  2235. else if( nItem < nCount - 1 )
  2236. nItem++;
  2237. else
  2238. nItem = 0;
  2240. CString sText;
  2241. GetLBText( nItem, sText );
  2242. if( sText.Compare( lpszString ) == 0 )
  2243. return nItem;
  2245. nItemsProcessed++;
  2246. }
  2247. return CB_ERR;
  2248. }
  2250. void CExtComboBoxBase::OnFilterPopupListSyncSelection( 
  2251. bool bSetEditSel // = true
  2252. )
  2253. {
  2254. ASSERT_VALID( this );
  2255. if( m_pPopupListWnd->GetSafeHwnd() == NULL 
  2256. || (!::IsWindow( m_pPopupListWnd->m_hWnd ))
  2257. )
  2258. return;
  2260. INT nItem = m_pPopupListWnd->GetCurSel();
  2261. CExtComboBoxFilterPopupListBox::LB_ITEM * pFLbItem = 
  2262. m_pPopupListWnd->LbItemGet( nItem );
  2263. ASSERT( pFLbItem != NULL );
  2265. CExtComboBoxBase::LB_ITEM * pLbItemNew = NULL;
  2266. if( pFLbItem != NULL )
  2267. pLbItemNew = (CExtComboBoxBase::LB_ITEM *) pFLbItem->LParamGet();
  2268. ASSERT( pLbItemNew != NULL );
  2270. INT nCount = GetCount();
  2271. for( LONG nIndex = 0; nIndex < nCount; nIndex++ )
  2272. {
  2273. LB_ITEM * pLbItem = LbItemGet( nIndex );
  2274. if( pLbItem == pLbItemNew )
  2275. {
  2276. CEdit * pEdit = GetInnerEditCtrl();
  2277. if( pEdit != NULL )
  2278. {
  2279. ASSERT_VALID( pEdit );
  2280. pEdit->SetRedraw( FALSE );
  2281. }
  2282. SetCurSel( nIndex );
  2283. // make text non-selected
  2284. if( ! bSetEditSel )
  2285. SetEditSel( -1, -1 );
  2286. if( pEdit != NULL )
  2287. {
  2288. ASSERT_VALID( pEdit );
  2289. pEdit->SetRedraw( TRUE );
  2290. pEdit->Invalidate();
  2291. pEdit->UpdateWindow();
  2292. }
  2293. break;
  2294. }
  2295. }
  2296. }
  2298. void CExtComboBoxBase::OnFilterPopupListSelChanged()
  2299. {
  2300. ASSERT_VALID( this );
  2301. OnFilterPopupListSyncSelection( false );
  2302. }
  2304. void CExtComboBoxBase::OnFilterPopupListSelEndOK()
  2305. {
  2306. ASSERT_VALID( this );
  2307. if( m_pPopupListWnd->GetSafeHwnd() == NULL 
  2308. || (!::IsWindow( m_pPopupListWnd->m_hWnd ))
  2309. )
  2310. return;
  2312. OnFilterPopupListSyncSelection( true );
  2314. OnFilterPopupListClose();
  2316. // send the CBN_SELENDOK notification
  2317. GetParent()->SendMessage( 
  2318. WM_COMMAND,
  2319. (WPARAM) MAKELONG( GetDlgCtrlID(), CBN_SELENDOK ),
  2320. (LPARAM) GetSafeHwnd()
  2321. );
  2322. }
  2324. void CExtComboBoxBase::_OnDrawComboImpl(
  2325. bool bPressed,
  2326. bool bHover,
  2327. CDC * pDC // = NULL
  2328. )
  2329. {
  2330. bPressed; bHover; pDC;
  2331. }
  2333. BOOL CExtComboBoxBase::PreTranslateMessage(MSG* pMsg) 
  2334. {
  2335. if( !CExtPopupMenuWnd::IsMenuTracking() )
  2336. {
  2337. InitToolTip();
  2338. m_wndToolTip.RelayEvent(pMsg);
  2339. }
  2341. if( m_pPopupListWnd->GetSafeHwnd() != NULL 
  2342. && ::IsWindow( m_pPopupListWnd->m_hWnd )
  2343. && m_pPopupListWnd->IsWindowVisible()
  2344. )
  2345. {
  2346. if( pMsg->message == WM_KEYDOWN 
  2347. && ( pMsg->wParam == VK_ESCAPE || pMsg->wParam == VK_RETURN )
  2348. )
  2349. {
  2350. HWND hWndFocus = ::GetFocus();
  2351. if( hWndFocus != NULL
  2352. && ( m_hWnd == hWndFocus
  2353. || ::IsChild( m_hWnd, hWndFocus )
  2354. )
  2355. )
  2356. {
  2357. if( pMsg->wParam == VK_ESCAPE )
  2358. OnFilterPopupListClose();
  2359. else if( pMsg->wParam == VK_RETURN )
  2360. {
  2361. INT nItem = m_pPopupListWnd->GetCurSel();
  2362. if( nItem == LB_ERR 
  2363. && m_pPopupListWnd->GetCount() > 0
  2364. ) 
  2365. m_pPopupListWnd->SetCurSel( 0 );
  2366. OnFilterPopupListSelEndOK();
  2367. }
  2368. return TRUE;
  2369. }
  2370. }
  2371. if( ( pMsg->message == WM_KEYDOWN 
  2372. && ( pMsg->wParam == VK_DOWN 
  2373. || pMsg->wParam == VK_UP 
  2374. || pMsg->wParam == VK_PRIOR 
  2375. || pMsg->wParam == VK_NEXT
  2376. )
  2377. )
  2378. || pMsg->message == WM_MOUSEWHEEL
  2379. )
  2380. {
  2381. INT nCurSelOld = m_pPopupListWnd->GetCurSel();
  2383. m_pPopupListWnd->SetRedraw( FALSE );
  2384. m_pPopupListWnd->SendMessage( 
  2385. pMsg->message,
  2386. pMsg->wParam,
  2387. pMsg->lParam
  2388. );
  2389. m_pPopupListWnd->SetRedraw( TRUE );
  2390. m_pPopupListWnd->RedrawWindow(
  2391. NULL,
  2392. NULL,
  2393. RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_FRAME
  2394. );
  2395. //_OnDrawComboImpl( false, false );
  2397. INT nCurSelNew = m_pPopupListWnd->GetCurSel();
  2398. if( nCurSelOld != nCurSelNew )
  2399. OnFilterPopupListSelChanged();
  2401. return TRUE;
  2402. }
  2403. }
  2405. if( m_bEnableAutoComplete )
  2406. {
  2407. if( pMsg->message == WM_SYSCHAR )
  2408. return FALSE;
  2409. if( pMsg->message == WM_KEYDOWN )
  2410. {
  2411. if( pMsg->wParam == VK_DELETE
  2412. || pMsg->wParam == VK_BACK
  2413. )
  2414. m_bAutoComplete = false;
  2415. else
  2416. m_bAutoComplete = true;
  2417. }
  2418. }
  2419. else
  2420. {
  2421. m_bAutoComplete = false;
  2422. }
  2424. return CComboBox::PreTranslateMessage(pMsg);
  2425. }
  2427. void CExtComboBoxBase::OnEditCtrlUpdate() 
  2428. {
  2429. if( m_bEnableAutoFilter )
  2430. {
  2431. CEdit * pEdit = GetInnerEditCtrl();
  2432. if( pEdit != NULL )
  2433. {
  2434. ASSERT_VALID( pEdit );
  2435. CString sFilterText;
  2436. pEdit->GetWindowText( sFilterText );
  2437. INT nStartChar = 0;
  2438. INT nEndChar = 0;
  2439. pEdit->GetSel(
  2440. nStartChar,
  2441. nEndChar 
  2442. ) ;
  2443. if( nStartChar < nEndChar )
  2444. sFilterText.Delete( nStartChar, nEndChar - nStartChar );
  2445. sFilterText.TrimLeft();
  2446. if( ! GetDroppedState() )
  2447. {
  2448. CExtSafeString _sFilterText = LPCTSTR(sFilterText);
  2449. ShowFilterPopupList( _sFilterText );
  2450. }
  2451. }
  2452. }
  2454. if( ! m_bEnableAutoComplete )
  2455. {
  2456. Default();
  2457. return;
  2458. }
  2459. PostMessage( __EXT_COMBO_BOX_WM_USER_AUTOCOMPLETE, m_bAutoComplete ? 1L : 0L, 0L );
  2460. }
  2462. void CExtComboBoxBase::OnSize(UINT nType, int cx, int cy) 
  2463. {
  2464. AnimationSite_ClientProgressStop( this );
  2465. AnimationClient_StateGet( false ).Empty();
  2466. AnimationClient_StateGet( true ).Empty();
  2467. CRect rcClient;
  2468. GetClientRect( &rcClient );
  2469. AnimationClient_TargetRectSet( rcClient );
  2471. CComboBox::OnSize( nType, cx, cy );
  2472. }
  2474. void CExtComboBoxBase::OnDestroy() 
  2475. {
  2476. HookSpyUnregister();
  2477. LbItemRemoveAll();
  2478. CComboBox::OnDestroy();
  2479. }
  2481. int CExtComboBoxBase::OnCharToItem(UINT nChar, CListBox* pListBox, UINT nIndex) 
  2482. {
  2483. INT nRet = CComboBox::OnCharToItem( nChar, pListBox, nIndex );
  2484. if( nRet >= 0 
  2485. && ( !LbItemIsEnabled( nRet ) )
  2486. )
  2487. return -2;
  2488. else
  2489. return nRet;
  2490. }
  2492. LRESULT CExtComboBoxBase::OnCtlColor(WPARAM wParam, LPARAM lParam)
  2493. {
  2494. ASSERT_VALID( this );
  2495. wParam;
  2496. bool bSimpleMode = false;
  2497. DWORD dwStyle = GetStyle();
  2498. if( (dwStyle&CBS_SIMPLE) == CBS_SIMPLE 
  2499. && (dwStyle&CBS_DROPDOWN) != CBS_DROPDOWN
  2500. && (dwStyle&CBS_DROPDOWNLIST) != CBS_DROPDOWNLIST 
  2501. )
  2502. bSimpleMode = true;
  2504. if( (!bSimpleMode)
  2505. && lParam != 0L 
  2506. && lParam != (LPARAM)m_hWnd
  2507. && FromHandlePermanent( (HWND)lParam ) == NULL
  2508. )
  2509. OnComboBoxPopupListBoxQuery( (HWND)lParam );
  2511. return Default();
  2512. }
  2514. void CExtComboBoxBase::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags ) 
  2515. {
  2516. ASSERT_VALID( this );
  2517. if( ! GetDroppedState() )
  2518. {
  2519. bool bSelChanged = false;
  2520. switch( nChar )
  2521. {
  2522. case VK_LEFT:
  2523. case VK_UP:
  2524. {
  2525. // Go up until we find a valid selection
  2526. // then set the current selection to that one
  2527. INT nCurSel = GetCurSel();
  2528. INT nSel = nCurSel;
  2529. bool bInitSelection = false;
  2530. INT nCount = GetCount();
  2531. if( nSel < 0 && nCount > 0 )
  2532. {
  2533. nSel = nCount - 1;
  2534. bInitSelection = true;
  2535. }
  2536. if( nSel != CB_ERR )
  2537. {
  2538. while( nSel > 0 )
  2539. {
  2540. INT nItem = nSel - ( bInitSelection ? 0 : 1 );
  2541. if( LbItemIsEnabled( nItem ) )
  2542. {
  2543. if( nCurSel != nItem )
  2544. {
  2545. INT nRealSel = SetCurSel( nItem );
  2546. if( nCurSel != nRealSel )
  2547. bSelChanged = true;
  2548. }
  2549. break;
  2550. }
  2551. nSel--;
  2552. }
  2553. }
  2554. }
  2555. break;
  2557. case VK_RIGHT:
  2558. case VK_DOWN:
  2559. {
  2560. // Go down until we find a valid selection
  2561. // then set the current selection to that one
  2562. INT nCurSel = GetCurSel();
  2563. INT nSel = nCurSel;
  2564. bool bInitSelection = false;
  2565. INT nCount = GetCount();
  2566. if( nSel < 0 && nCount > 0 )
  2567. {
  2568. nSel = 0;
  2569. bInitSelection = true;
  2570. }
  2571. if( nSel != CB_ERR )
  2572. {
  2573. while( nSel < nCount - 1 )
  2574. {
  2575. INT nItem = nSel + ( bInitSelection ? 0 : 1 );
  2576. if( nItem == nCount )
  2577. break;
  2578. if( LbItemIsEnabled( nItem ) )
  2579. {
  2580. if( nCurSel != nItem )
  2581. {
  2582. INT nRealSel = SetCurSel( nItem );
  2583. if( nCurSel != nRealSel )
  2584. bSelChanged = true;
  2585. }
  2586. break;
  2587. }
  2588. nSel++;
  2589. }
  2590. }
  2591. }
  2592. break;
  2594. case VK_HOME:
  2595. case VK_PRIOR:
  2596. {
  2597. // Select first non-disabled item
  2598. INT nCurSel = GetCurSel();
  2599. INT nSel = 0;
  2600. INT nCount = GetCount();
  2601. while( nSel < nCount - 1 )
  2602. {
  2603. INT nItem = nSel;
  2604. if( LbItemIsEnabled( nItem ) )
  2605. {
  2606. if( nCurSel != nItem )
  2607. {
  2608. INT nRealSel = SetCurSel( nItem );
  2609. if( nCurSel != nRealSel )
  2610. bSelChanged = true;
  2611. }
  2612. break;
  2613. }
  2614. nSel++;
  2615. }
  2616. }
  2617. break;
  2619. case VK_END:
  2620. case VK_NEXT:
  2621. {
  2622. // Select last non-disabled item
  2623. INT nCurSel = GetCurSel();
  2624. INT nCount = GetCount();
  2625. INT nSel = nCount;
  2626. while( nSel > 0 )
  2627. {
  2628. INT nItem = nSel - 1;
  2629. if( LbItemIsEnabled( nItem ) )
  2630. {
  2631. if( nCurSel != nItem )
  2632. {
  2633. INT nRealSel = SetCurSel( nItem );
  2634. if( nCurSel != nRealSel )
  2635. bSelChanged = true;
  2636. }
  2637. break;
  2638. }
  2639. nSel--;
  2640. }
  2641. }
  2642. break;
  2644. default:
  2645. CComboBox::OnKeyDown( nChar, nRepCnt, nFlags );
  2646. return;
  2647. }
  2649. if( bSelChanged )
  2650. {
  2651. // The CBN_SELCHANGE notification message is not sent when the selection 
  2652. // is changed using the CB_SETCURSEL message. 
  2653. if( ! m_bEnableSelChangeWorkaround  )
  2654. {
  2655. CWnd * pWnd = GetParent();
  2656. if( pWnd->GetSafeHwnd() != NULL )
  2657. {
  2658. ASSERT_VALID( pWnd );
  2659. pWnd->SendMessage(
  2660. WM_COMMAND,
  2661. MAKEWPARAM( GetDlgCtrlID(), CBN_SELENDOK ),
  2662. (LPARAM) m_hWnd
  2663. );
  2664. pWnd->SendMessage(
  2665. WM_COMMAND,
  2666. MAKEWPARAM( GetDlgCtrlID(), CBN_SELCHANGE ),
  2667. (LPARAM) m_hWnd
  2668. );
  2669. }
  2670. }
  2671. }
  2673. return;
  2675. } // if( ! GetDroppedState() )
  2677. CComboBox::OnKeyDown( nChar, nRepCnt, nFlags );
  2678. }
  2680. bool CExtComboBoxBase::_CreateHelper()
  2681. {
  2682. if( m_bInitialized )
  2683. return true;
  2685. OnSubclassInnerEdit();
  2686. HookSpyRegister( __EHSEF_WND_PROC_IN|__EHSEF_KEYBOARD|__EHSEF_PRE_TRANSLATION );
  2688. m_bInitialized = true;
  2690. return true;
  2691. }
  2693. LRESULT CExtComboBoxBase::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  2694. {
  2695. switch( message )
  2696. {
  2697. case WM_NOTIFY:
  2698. if( m_wndToolTip.GetSafeHwnd() != NULL
  2699. && IsWindow( m_wndToolTip.GetSafeHwnd() )
  2700. && ((LPNMHDR)lParam) != NULL
  2701. && ((LPNMHDR)lParam)->hwndFrom == m_wndToolTip.GetSafeHwnd()
  2702. && ((LPNMHDR)lParam)->code == TTN_SHOW
  2703. )
  2704. ::SetWindowPos(
  2705. m_wndToolTip.GetSafeHwnd(),
  2706. HWND_TOP,
  2707. 0,0,0,0,
  2708. SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE
  2709. );
  2710. break;
  2711. case WM_ENABLE:
  2712. {
  2713. HWND hWndEdit =
  2714. ::GetWindow( GetSafeHwnd(), GW_CHILD );
  2715. if( hWndEdit == NULL || !::IsWindow(hWndEdit) )
  2716. break;
  2717. ::EnableWindow( hWndEdit, TRUE );
  2718. ::SendMessage( hWndEdit, EM_SETREADONLY, !wParam, 0L );
  2719. Invalidate();
  2720. }
  2721. break;
  2722. case WM_CREATE:
  2723. {
  2724. LRESULT lResult =
  2725. CComboBox::WindowProc(message, wParam, lParam);;
  2726. if( ! _CreateHelper() )
  2727. {
  2728. ASSERT( FALSE );
  2729. ::AfxThrowMemoryException();
  2730. }
  2731. return lResult;
  2732. }
  2733. case __EXT_COMBO_BOX_WM_USER_REALSELENDOK:
  2734. {
  2735. CString sCurrentText;
  2736. GetWindowText( sCurrentText );
  2738. INT nIndex = FindStringExact( -1, sCurrentText );
  2739. if( nIndex >=0 
  2740. &&  ( !LbItemIsEnabled( nIndex ) ) 
  2741. )
  2742. {
  2743. SetWindowText( m_sSavedText );
  2745. // send the CBN_SELCHANGE notification
  2746. GetParent()->SendMessage( 
  2747. WM_COMMAND,
  2748. (WPARAM) MAKELONG( GetDlgCtrlID(), CBN_SELCHANGE ),
  2749. (LPARAM) GetSafeHwnd()
  2750. );
  2751. }
  2752. return 0L;
  2753. }
  2754. case __EXT_COMBO_BOX_WM_USER_AUTOCOMPLETE:
  2755. {
  2756. bool bAutoComplete = ( wParam > 0L ) ? true : false;
  2757. DWORD dwCurSel = GetEditSel();
  2758. WORD dStart = LOWORD( dwCurSel );
  2759. WORD dEnd   = HIWORD( dwCurSel );
  2761. CString str;
  2762. GetWindowText( str );
  2763. INT nLength = INT( str.GetLength() );
  2764. INT nResult = FindString( -1, str );
  2765. if( m_bUseCaseSensitiveAutoComplete && nResult >= 0 )
  2766. {
  2767. CString sItem;
  2768. INT nCount = INT( GetCount() );
  2769. for( ; 0 <= nResult && nResult < nCount; nResult ++ )
  2770. {
  2771. GetLBText( nResult, sItem );
  2772. INT nItemLength = INT( sItem.GetLength() );
  2773. if( nItemLength >= nLength )
  2774. {
  2775. if( nItemLength > nLength )
  2776. sItem = sItem.Left( nLength );
  2777. if( str == sItem )
  2778. break;
  2779. }
  2780. }
  2781. if( ! ( 0 <= nResult && nResult < nCount ) )
  2782. nResult = -1;
  2783. }
  2785. CEdit * pEdit = GetInnerEditCtrl();
  2786. if( pEdit != NULL )
  2787. {
  2788. ASSERT_VALID( pEdit );
  2789. pEdit->SetRedraw( FALSE );
  2790. }
  2792. CExtComboBoxPopupListBox * pComboBoxPopupListBox = OnComboBoxPopupListBoxQuery();
  2793. if( pComboBoxPopupListBox != NULL )
  2794. {
  2795. ASSERT_VALID( pComboBoxPopupListBox );
  2796. // pComboBoxPopupListBox->SendMessage( LB_SETCURSEL, nResult, 0 );
  2797. INT nRealSel = (INT)pComboBoxPopupListBox->SendMessage( LB_SETCURSEL, nResult, 0 );
  2798. if( nRealSel == LB_ERR )
  2799. pComboBoxPopupListBox->SendMessage( LB_SETTOPINDEX, 0, 0 );
  2800. }
  2802. CString sItem;
  2803. if( nResult >= 0 )
  2804. {
  2805. GetLBText( nResult, sItem );
  2806. if( ! bAutoComplete )
  2807. SetWindowText( str );
  2808. else
  2809. SetWindowText( sItem );
  2810. }
  2811. else 
  2812. {
  2813. SetWindowText( str );
  2814. if( dwCurSel != CB_ERR )
  2815. SetEditSel( dStart, dEnd );
  2816. }
  2818. if( dEnd < nLength 
  2819. && dwCurSel != CB_ERR 
  2820. )
  2821. SetEditSel( dStart, dEnd );
  2822. else
  2823. SetEditSel( nLength, -1 );
  2825. if( pEdit != NULL )
  2826. {
  2827. ASSERT_VALID( pEdit );
  2828. pEdit->SetRedraw( TRUE );
  2829. pEdit->Invalidate();
  2830. pEdit->UpdateWindow();
  2831. }
  2833. return 0L;
  2834. }
  2835. } // switch( message )
  2837. return CComboBox::WindowProc(message, wParam, lParam);
  2838. }
  2840. void CExtComboBoxBase::PreSubclassWindow() 
  2841. {
  2842. CComboBox::PreSubclassWindow();
  2844. if( ! _CreateHelper() )
  2845. {
  2846. ASSERT( FALSE );
  2847. ::AfxThrowMemoryException();
  2848. }
  2850. bool bSimpleMode = false;
  2851. DWORD dwStyle = GetStyle();
  2852. if( (dwStyle&CBS_SIMPLE) == CBS_SIMPLE 
  2853. && (dwStyle&CBS_DROPDOWN) != CBS_DROPDOWN
  2854. && (dwStyle&CBS_DROPDOWNLIST) != CBS_DROPDOWNLIST 
  2855. )
  2856. bSimpleMode = true;
  2857. if( bSimpleMode )
  2858. {
  2859. HWND hWnd = ::GetWindow( m_hWnd, GW_CHILD );
  2860. for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDNEXT ) )
  2861. {
  2862. TCHAR strClassName[ MAX_PATH + 1 ] = _T("");
  2863. ::GetClassName(
  2864. hWnd,
  2865. strClassName,
  2866. MAX_PATH
  2867. );
  2868. __EXT_MFC_STRLWR( strClassName, MAX_PATH );
  2869. if( _tcscmp( strClassName, _T("combolbox") ) == 0 )
  2870. {
  2871. OnComboBoxPopupListBoxQuery( hWnd );
  2872. break;
  2873. } // if( _tcscmp( strClassName, _T("combolbox") ) == 0 )
  2874. } // for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDNEXT ) )
  2875. } // if( bSimpleMode )
  2877. if( (dwStyle&WS_CLIPCHILDREN) == 0 )
  2878. ModifyStyle( 0, WS_CLIPCHILDREN, SWP_FRAMECHANGED );
  2880. // INT nCount = GetCount();
  2881. //  for( LONG nItem = 0; nItem < nCount; nItem++ )
  2882. //  {
  2883. //  LB_ITEM * pLbItem = LbItemGet( nItem );
  2884. //  if( pLbItem == NULL )
  2885. //  {
  2886. //  CString sString;
  2887. //  GetLBText( nItem, sString );
  2888. //  LbItemSet( nItem, sString );
  2889. //  }
  2890. //  }
  2891.  
  2892. AnimationSite_ClientProgressStop( this );
  2893. AnimationClient_StateGet( false ).Empty();
  2894. AnimationClient_StateGet( true ).Empty();
  2895. CRect rectButton;
  2896. GetClientRect( &rectButton );
  2897. AnimationClient_TargetRectSet( rectButton );
  2898. }
  2900. void CExtComboBoxBase::PostNcDestroy() 
  2901. {
  2902. if( m_pWndPopupListBox != NULL )
  2903. {
  2904. if( m_hWndPopupListBox != NULL
  2905. && ::IsWindow( m_hWndPopupListBox )
  2906. && LPVOID( CWnd::FromHandlePermanent(m_hWndPopupListBox) ) == LPVOID( m_pWndPopupListBox )
  2907. )
  2908. m_pWndPopupListBox->m_pCB = NULL;
  2909. }
  2910. m_pWndPopupListBox = NULL;
  2911. m_hWndPopupListBox = NULL;
  2912. CComboBox::PostNcDestroy();
  2913. }
  2915. void CExtComboBoxBase::OnSubclassInnerEdit()
  2916. {
  2917. if( m_wndInnerEditHook.GetSafeHwnd() == NULL )
  2918. {
  2919. HWND hWnd = ::GetWindow( m_hWnd, GW_CHILD );
  2920. for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDNEXT ) )
  2921. {
  2922. TCHAR strClassName[ MAX_PATH + 1 ] = _T("");
  2923. ::GetClassName(
  2924. hWnd,
  2925. strClassName,
  2926. MAX_PATH
  2927. );
  2928. __EXT_MFC_STRLWR( strClassName, MAX_PATH );
  2929. if( _tcscmp( strClassName, _T("edit") ) == 0 )
  2930. {
  2931. m_wndInnerEditHook.m_bHandleCtxMenus = m_bHandleCtxMenus;
  2932. VERIFY( m_wndInnerEditHook.SubclassWindow( hWnd ) );
  2933. break;
  2934. } // if( _tcscmp( strClassName, _T("edit") ) == 0 )
  2935. } // for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDNEXT ) )
  2936. } // if( m_wndInnerEditHook.GetSafeHwnd() == NULL )
  2937. }
  2939. __EXT_MFC_INT_PTR CExtComboBoxBase::OnToolHitTest(
  2940. CPoint point,
  2941. TOOLINFO * pTI
  2942. ) const
  2943. {
  2944. __PROF_UIS_MANAGE_STATE;
  2945. __EXT_MFC_IMPLEMENT_TT_REDIR_OnToolHitTest( CExtComboBoxBase, CExtToolControlBar );
  2946. return CComboBox::OnToolHitTest( point, pTI );
  2947. }
  2949. void CExtComboBoxBase::InitToolTip()
  2950. {
  2951. if( m_wndToolTip.m_hWnd == NULL )
  2952. {
  2953. m_wndToolTip.Create(this);
  2954. m_wndToolTip.Activate(FALSE);
  2955. }
  2956. }
  2958. void CExtComboBoxBase::ActivateTooltip(BOOL bActivate)
  2959. {
  2960. if( m_wndToolTip.GetToolCount() == 0 )
  2961. return;
  2962. m_wndToolTip.Activate(bActivate);
  2963. }
  2965. int CExtComboBoxBase::OnQueryMaxTipWidth( 
  2966. __EXT_MFC_SAFE_LPCTSTR lpszText 
  2967. )
  2968. {
  2969. lpszText;
  2970. return 250;
  2971. }
  2973. void CExtComboBoxBase::SetTooltipText(
  2974. CExtSafeString * spText,
  2975. BOOL bActivate // = TRUE
  2976. )
  2977. {
  2978. if( spText == NULL )
  2979. return;
  2980. InitToolTip();
  2981. if( m_wndToolTip.GetToolCount() == 0 )
  2982. {
  2983. CRect rectBtn; 
  2984. GetClientRect(rectBtn);
  2985. m_wndToolTip.AddTool( this, *spText, rectBtn, 1 );
  2986. }
  2987. CWnd::CancelToolTips();
  2988. m_wndToolTip.UpdateTipText( *spText, this, 1 );
  2989. m_wndToolTip.SetMaxTipWidth( -1 );
  2990. if( spText->Find( _T("r") ) >= 0 )
  2991. m_wndToolTip.SetMaxTipWidth( OnQueryMaxTipWidth( *spText ) );
  2992. m_wndToolTip.Activate(bActivate);
  2993. }
  2995. void CExtComboBoxBase::SetTooltipText(
  2996. CExtSafeString & sText,
  2997. BOOL bActivate // = TRUE
  2998. )
  2999. {
  3000. if( sText.IsEmpty() )
  3001. return;
  3002. InitToolTip();
  3003. if( m_wndToolTip.GetToolCount() == 0 )
  3004. {
  3005. CRect rectBtn; 
  3006. GetClientRect(rectBtn);
  3007. m_wndToolTip.AddTool( this, sText, rectBtn, 1 );
  3008. }
  3009. CWnd::CancelToolTips();
  3010. m_wndToolTip.UpdateTipText( sText, this, 1 );
  3011. m_wndToolTip.SetMaxTipWidth( -1 );
  3012. if( sText.Find( _T("r") ) >= 0 )
  3013. m_wndToolTip.SetMaxTipWidth( OnQueryMaxTipWidth( sText ) );
  3014. m_wndToolTip.Activate( bActivate );
  3015. }
  3017. void CExtComboBoxBase::SetTooltipText(
  3018. __EXT_MFC_SAFE_LPCTSTR sText,
  3019. BOOL bActivate // = TRUE
  3020. )
  3021. {
  3022. if( sText == NULL
  3023. || _tcslen( sText ) == 0
  3024. )
  3025. return;
  3026. InitToolTip();
  3027. if( m_wndToolTip.GetToolCount() == 0 )
  3028. {
  3029. CRect rectBtn; 
  3030. GetClientRect(rectBtn);
  3031. m_wndToolTip.AddTool(this,sText,rectBtn,1);
  3032. }
  3033. CWnd::CancelToolTips();
  3034. m_wndToolTip.UpdateTipText(sText,this,1);
  3035. m_wndToolTip.SetMaxTipWidth( -1 );
  3036. CString strText( sText );
  3037. if( strText.Find( _T("r") ) >= 0 )
  3038. m_wndToolTip.SetMaxTipWidth( OnQueryMaxTipWidth( sText ) );
  3039. m_wndToolTip.Activate(bActivate);
  3040. }
  3042. void CExtComboBoxBase::SetTooltipText(
  3043. int nId,
  3044. BOOL bActivate // = TRUE
  3045. )
  3046. {
  3047. CExtSafeString sText;
  3048. g_ResourceManager->LoadString( sText, nId );
  3049. if( ! sText.IsEmpty() )
  3050. SetTooltipText( &sText, bActivate );
  3051. }
  3054. COLORREF CExtComboBoxBase::OnQueryBackColor() const
  3055. { 
  3056. ASSERT_VALID( this );
  3057. return m_clrBack; 
  3058. }
  3060. COLORREF CExtComboBoxBase::OnQueryTextColor() const
  3061. { 
  3062. ASSERT_VALID( this );
  3063. return m_clrText; 
  3064. }
  3066. void CExtComboBoxBase::SetBkColor( 
  3067. COLORREF clrBk 
  3068. )
  3069. { 
  3070. ASSERT_VALID( this );
  3071. m_clrBack = clrBk; 
  3072. if( GetSafeHwnd() != NULL )
  3073. RedrawWindow(
  3074. NULL,
  3075. NULL,
  3076. RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ERASENOW | RDW_FRAME | RDW_ALLCHILDREN
  3077. );
  3078. }
  3080. COLORREF CExtComboBoxBase::GetBkColor() const
  3081. { 
  3082. ASSERT_VALID( this );
  3083. return OnQueryBackColor(); 
  3084. }
  3086. void CExtComboBoxBase::SetTextColor( 
  3087. COLORREF clrText 
  3088. )
  3089. { 
  3090. ASSERT_VALID( this );
  3091. m_clrText = clrText; 
  3092. if( GetSafeHwnd() != NULL )
  3093. Invalidate();
  3094. }
  3096. COLORREF CExtComboBoxBase::GetTextColor() const
  3097. { 
  3098. ASSERT_VALID( this );
  3099. return OnQueryTextColor(); 
  3100. }
  3102. HBRUSH CExtComboBoxBase::CtlColor( CDC* pDC, UINT nCtlColor )
  3103. {
  3104. ASSERT_VALID( this );
  3105. if( nCtlColor == CTLCOLOR_EDIT 
  3106. || nCtlColor == CTLCOLOR_MSGBOX
  3107. || nCtlColor == CTLCOLOR_STATIC
  3108. )
  3109. {
  3110. bool bDisabled = IsWindowEnabled() ? false : true;
  3111. CExtPaintManager * pPM = PmBridge_GetPM();
  3112. ASSERT_VALID( pPM );
  3113. COLORREF clrText = GetTextColor();
  3114. if( clrText == COLORREF(-1L) )
  3115. clrText = pPM->GetColor( bDisabled ? CExtPaintManager::CLR_TEXT_DISABLED : COLOR_WINDOWTEXT );
  3116. COLORREF clrBk = GetBkColor();
  3117. if( clrBk == COLORREF(-1L) )
  3118. clrBk = pPM->GetColor( bDisabled ? COLOR_3DFACE : COLOR_WINDOW, this );
  3119. pDC->SetBkColor( clrBk );
  3120. pDC->SetTextColor( clrText );
  3121. if( m_clrBackPrev != clrBk )
  3122. {
  3123. if( m_brBack.GetSafeHandle() != NULL )
  3124. m_brBack.DeleteObject();
  3125. m_brBack.CreateSolidBrush( clrBk );
  3126. m_clrBackPrev = clrBk;
  3127. }
  3128. return m_brBack;
  3129. }
  3130. else
  3131. return (HBRUSH)Default();
  3132. }
  3134. CEdit * CExtComboBoxBase::OnQueryInnerEditCtrl() const
  3135. {
  3136. ASSERT_VALID( this );
  3137. CEdit * pEdit = NULL;
  3138. DWORD dwWndStyle = GetStyle();
  3139. DWORD dwComboBoxType = dwWndStyle & 0x0003L;
  3140. if( dwComboBoxType != CBS_DROPDOWNLIST )
  3141. {
  3142. ( const_cast < CExtComboBoxBase * > ( this ) ) -> OnSubclassInnerEdit();
  3143. if( m_wndInnerEditHook.GetSafeHwnd() != NULL )
  3144. pEdit = (CEdit *)&m_wndInnerEditHook;
  3145. }
  3146. return pEdit;
  3147. }
  3149. CEdit * CExtComboBoxBase::GetInnerEditCtrl() const
  3150. {
  3151. ASSERT_VALID( this );
  3152. return OnQueryInnerEditCtrl();
  3153. }
  3155. INT CExtComboBoxBase::AddStringUnique( 
  3156. __EXT_MFC_SAFE_LPCTSTR lpszString 
  3157. )
  3158. {
  3159. ASSERT_VALID( this );
  3160. if( CB_ERR == FindStringExact( 0, lpszString ) )
  3161. return AddString( lpszString );
  3162. return CB_ERR;
  3163. }
  3165. LRESULT CExtComboBoxBase::OnCBAddString( WPARAM wParam, LPARAM lParam )
  3166. {
  3167. ASSERT_VALID( this );
  3168. LRESULT lResult = DefWindowProc( CB_ADDSTRING, wParam, lParam );
  3169. if( lResult != CB_ERR )
  3170. LbItemInsert( __EXT_MFC_SAFE_LPCTSTR ( LPCTSTR(LPVOID(lParam)) ), (INT)lResult );
  3171. return lResult;
  3172. }
  3174. LRESULT CExtComboBoxBase::OnCBInsertString( WPARAM wParam, LPARAM lParam )
  3175. {
  3176. ASSERT_VALID( this );
  3177. LRESULT lResult = DefWindowProc( CB_INSERTSTRING, wParam, lParam );
  3178. if( lResult != CB_ERR )
  3179. LbItemInsert( __EXT_MFC_SAFE_LPCTSTR ( LPCTSTR(LPVOID(lParam)) ), (INT)lResult );
  3180. return lResult;
  3181. }
  3183. LRESULT CExtComboBoxBase::OnCBDeleteString( WPARAM wParam, LPARAM lParam )
  3184. {
  3185. ASSERT_VALID( this );
  3186. LRESULT lResult = DefWindowProc( CB_DELETESTRING, wParam, lParam );
  3187. if( lResult != LB_ERR )
  3188. LbItemRemove( (LONG)wParam );
  3189. return lResult;
  3190. }
  3192. LRESULT CExtComboBoxBase::OnCBResetContent( WPARAM wParam, LPARAM lParam )
  3193. {
  3194. ASSERT_VALID( this );
  3195. LRESULT lResult = DefWindowProc( CB_RESETCONTENT, wParam, lParam );
  3197. LbItemRemoveAll();
  3199. // Workaround for the following issue:
  3200. // The CBN_SELCHANGE notification message is not sent when the 
  3201. // current selection is unset using the CB_RESETCONTENT message. 
  3202. if( m_bEnableSelChangeWorkaround )
  3203. {
  3204. CWnd * pWnd = GetParent();
  3205. if( pWnd->GetSafeHwnd() != NULL )
  3206. {
  3207. ASSERT_VALID( pWnd );
  3208. pWnd->SendMessage(
  3209. WM_COMMAND,
  3210. MAKEWPARAM( GetDlgCtrlID(), CBN_SELCHANGE ),
  3211. (LPARAM) m_hWnd
  3212. );
  3213. }
  3214. }
  3216. return lResult;
  3217. }
  3219. LRESULT CExtComboBoxBase::OnCBSetCurSel( WPARAM wParam, LPARAM lParam )
  3220. {
  3221. ASSERT_VALID( this );
  3223. INT nCurSel = GetCurSel();
  3224. LRESULT lResult = DefWindowProc( CB_SETCURSEL, wParam, lParam );
  3226. // Workaround for the following issue:
  3227. // The CBN_SELCHANGE notification message is not sent when the 
  3228. // current selection is set using the CB_SETCURSEL message. 
  3229. if( m_bEnableSelChangeWorkaround )
  3230. {
  3231. if( lResult != CB_ERR 
  3232. && lResult != nCurSel 
  3233. )
  3234. {
  3235. CWnd * pWnd = GetParent();
  3236. if( pWnd->GetSafeHwnd() != NULL )
  3237. {
  3238. ASSERT_VALID( pWnd );
  3239. pWnd->SendMessage(
  3240. WM_COMMAND,
  3241. MAKEWPARAM( GetDlgCtrlID(), CBN_SELENDOK ),
  3242. (LPARAM) m_hWnd
  3243. );
  3244. pWnd->SendMessage(
  3245. WM_COMMAND,
  3246. MAKEWPARAM( GetDlgCtrlID(), CBN_SELCHANGE ),
  3247. (LPARAM) m_hWnd
  3248. );
  3249. }
  3250. }
  3251. }
  3253. return lResult;
  3254. }
  3256. void CExtComboBoxBase::DeleteItem( LPDELETEITEMSTRUCT lpDIS ) 
  3257. {
  3258. ASSERT_VALID( this );
  3259. ASSERT( lpDIS->CtlType == ODT_COMBOBOX );
  3260. lpDIS;
  3261. }
  3263. int CExtComboBoxBase::CompareItem( LPCOMPAREITEMSTRUCT lpCIS )
  3264. {
  3265. ASSERT_VALID( this );
  3266. if( INT( lpCIS->itemID1 ) >= 0 
  3267. && INT( lpCIS->itemID2 ) >= 0
  3268. )
  3269. {
  3270. ASSERT( lpCIS->CtlType == ODT_COMBOBOX );
  3271. LPCTSTR lpszText1 = (LPCTSTR) lpCIS->itemData1;
  3272. ASSERT(lpszText1 != NULL);
  3273. LPCTSTR lpszText2 = (LPCTSTR) lpCIS->itemData2;
  3274. ASSERT(lpszText2 != NULL);
  3275. return lstrcmp( lpszText2, lpszText1 );
  3276. }
  3277. return 0;
  3278. }
  3280. CSize CExtComboBoxBase::OnPopupListBoxCalcItemExtraSizes(
  3281. LONG nItem
  3282. ) const
  3283. {
  3284. ASSERT_VALID( this );
  3285. nItem;
  3286. return CSize( 2, 0 );
  3287. }
  3289. CSize CExtComboBoxBase::OnPopupListBoxCalcItemCellExtraSizes() const
  3290. {
  3291. ASSERT_VALID( this );
  3292. return CSize( 4, 0 );
  3293. }
  3295. LONG CExtComboBoxBase::OnPopupListBoxQueryColumnWidth(
  3296. LONG nColNo
  3297. ) const
  3298. {
  3299. ASSERT_VALID( this );
  3300. LONG nColWidth = LbColumnWidthGet( nColNo );
  3301. if( nColWidth != 0L )
  3302. nColWidth = max( 25, nColWidth ); // minimum width
  3303. return nColWidth;
  3304. }
  3306. void CExtComboBoxBase::DrawItem( LPDRAWITEMSTRUCT lpDIS ) 
  3307. {
  3308. ASSERT_VALID( this );
  3309. ASSERT( lpDIS != NULL && lpDIS->hDC != NULL );
  3311. if( (GetStyle() & CBS_HASSTRINGS) == 0 
  3312. && (GetStyle() & LBS_HASSTRINGS) == 0 
  3313. )
  3314. return;
  3316. INT nCount = GetCount();
  3317. INT nItem = lpDIS->itemID;
  3318. if( nItem < 0 || nItem >= nCount )
  3319. return;
  3321. CDC dc;
  3322. dc.Attach( lpDIS->hDC );
  3323. if( lpDIS->itemAction & (ODA_DRAWENTIRE | ODA_SELECT) )
  3324. {
  3325. CRect rcErase( lpDIS->rcItem );
  3326. if( nItem == ( nCount - 1 ) )
  3327. {
  3328. CRect rcClient;
  3329. GetClientRect( &rcClient );
  3330. if( rcErase.bottom < rcClient.bottom )
  3331. rcErase.bottom = rcClient.bottom;
  3332. }
  3333. COLORREF clrBk = COLORREF(-1L);
  3334. if( ( lpDIS->itemState & ODS_COMBOBOXEDIT ) != 0 ) 
  3335. clrBk = GetBkColor();
  3336. if( clrBk == COLORREF(-1L) )
  3337. clrBk = PmBridge_GetPM()->GetColor( ( ! IsWindowEnabled() ) ? COLOR_3DFACE : COLOR_WINDOW, this );
  3338. dc.FillSolidRect( rcErase,  clrBk );
  3339. }
  3341. LB_ITEM * pLbItem = LbItemGet( nItem );
  3342. if( pLbItem != NULL )
  3343. {
  3344. OnPopupListBoxDrawItem( 
  3345. dc,
  3346. lpDIS->rcItem,
  3347. OnPopupListBoxCalcItemExtraSizes( nItem ),
  3348. lpDIS->itemState,
  3349. pLbItem 
  3350. );
  3351. }
  3352. else
  3353. {
  3354. CRect rcDrawItem( lpDIS->rcItem );
  3355. bool bSelected = ( lpDIS->itemState & ODS_SELECTED ) ? true : false;
  3356. if( bSelected )
  3357. dc.FillSolidRect( &rcDrawItem, PmBridge_GetPM()->GetColor( COLOR_HIGHLIGHT, this ) );
  3358. CString sText;
  3359. GetLBText( nItem, sText );
  3360. if( ! sText.IsEmpty() )
  3361. {
  3362. COLORREF clrTextOld = dc.SetTextColor( PmBridge_GetPM()->GetColor( bSelected ? COLOR_HIGHLIGHTTEXT : COLOR_BTNTEXT, this ) );
  3363. int nOldBkMode = dc.SetBkMode( TRANSPARENT );
  3364. CRect rcText( rcDrawItem );
  3365. rcText.DeflateRect( 2, 0 );
  3366. UINT nFormat = 
  3367. DT_SINGLELINE
  3368. | DT_LEFT
  3369. | DT_VCENTER
  3370. | DT_NOPREFIX
  3371. ;
  3372. if( sText.Find( _T('t') ) != -1 ) // do tabs expanding
  3373. nFormat |= DT_EXPANDTABS;
  3374. HFONT hFont = OnQueryFont();
  3375. if( hFont == NULL )
  3376. hFont = (HFONT)PmBridge_GetPM()->m_FontNormal.GetSafeHandle();
  3377. ASSERT( hFont != NULL );
  3378. HFONT hOldFont = (HFONT)::SelectObject( dc.m_hDC, hFont );
  3379. dc.DrawText( sText, &rcText, nFormat );
  3380. ::SelectObject( dc.m_hDC, hOldFont );
  3381. dc.SetBkMode( nOldBkMode );
  3382. dc.SetTextColor( clrTextOld );
  3383. } // if( ! sText.IsEmpty() )
  3384. if( bSelected )
  3385. {
  3386. COLORREF clrTextOld = dc.SetTextColor( RGB(255,255,255) );
  3387. COLORREF clrBkOld = dc.SetBkColor( RGB(0,0,0) );
  3388. dc.DrawFocusRect( &rcDrawItem );
  3389. dc.SetBkColor( clrBkOld );
  3390. dc.SetTextColor( clrTextOld );
  3391. }
  3392. }
  3393. dc.Detach();
  3394. }
  3396. void CExtComboBoxBase::MeasureItem( LPMEASUREITEMSTRUCT lpMIS ) 
  3397. {
  3398. ASSERT_VALID( this );
  3399. ASSERT( lpMIS != NULL );
  3400. if( (GetStyle() & CBS_HASSTRINGS) == 0 
  3401. && (GetStyle() & LBS_HASSTRINGS) == 0 
  3402. )
  3403. return;
  3404. lpMIS->itemWidth = lpMIS->itemHeight = 16;
  3405. INT nItem = lpMIS->itemID;
  3406. if( nItem < 0 || nItem >= GetCount() )
  3407. return;
  3408. OnPopupListBoxMeasureItem( lpMIS );
  3409. }
  3411. void CExtComboBoxBase::OnPopupListBoxDrawItem( 
  3412. CDC & dc,
  3413. const RECT & rcItem,
  3414. const CSize & szExtra,
  3415. UINT nState,
  3416. const CExtComboBoxBase::LB_ITEM * pLbItem
  3417. )
  3418. {
  3419. ASSERT_VALID( this );
  3420. ASSERT( dc.GetSafeHdc() != NULL );
  3421. if( (GetStyle() & CBS_HASSTRINGS) == 0 
  3422. && (GetStyle() & LBS_HASSTRINGS) == 0 
  3423. )
  3424. return;
  3425. bool bEnabled = true;
  3426. if( ( ! GetDroppedState() )
  3427. && ( ! IsWindowEnabled() )
  3428. )
  3429. bEnabled = false;
  3430. else if( pLbItem != NULL )
  3431. bEnabled = pLbItem->IsEnabled();
  3432. CRect rcDrawItem( rcItem );
  3433. bool bSelected = ( nState & ODS_SELECTED ) ? true : false;
  3434. if( bSelected && bEnabled )
  3435. dc.FillSolidRect( &rcDrawItem, PmBridge_GetPM()->GetColor( COLOR_HIGHLIGHT, this ) );
  3436. INT nOldBkMode = dc.SetBkMode( TRANSPARENT );
  3437. CRect rcText( rcDrawItem );
  3438. rcText.DeflateRect( szExtra );
  3439. // draw item cells
  3440. if( pLbItem != NULL )
  3441. {
  3442. INT nCount = pLbItem->LbItemCellGetCount();
  3443. for( INT nCellItem = 0; nCellItem < nCount; nCellItem++ )
  3444. {
  3445. LB_ITEM::CELL * pItemCell = pLbItem->LbItemCellGet( nCellItem );
  3446. ASSERT( pItemCell != NULL );
  3448. LONG nColWidth = OnPopupListBoxQueryColumnWidth( nCellItem );
  3449. if( nColWidth > 0L )
  3450. {
  3451. COLORREF clrBk = COLORREF(-1L);
  3452. if( ( nState & ODS_COMBOBOXEDIT ) != 0 ) 
  3453. clrBk = GetBkColor();
  3454. if( clrBk == COLORREF(-1L) )
  3455. clrBk = pItemCell->m_clrBack;
  3456. if( clrBk != COLORREF(-1L)
  3457. && ( (!bSelected) || (!bEnabled) )
  3458. )
  3459. {
  3460. dc.FillSolidRect(
  3461. &rcText,
  3462. clrBk
  3463. );
  3464. }
  3466. CString sText = pItemCell->m_sItemText;
  3467. if( !sText.IsEmpty() )
  3468. {
  3469. COLORREF clrText = COLORREF(-1L);
  3470. if( !bSelected )
  3471. clrText = pItemCell->m_clrText;
  3472. if( clrText == COLORREF(-1L) )
  3473. clrText = GetTextColor();
  3474. if( clrText == COLORREF(-1L) )
  3475. clrText = 
  3476. PmBridge_GetPM()->GetColor( 
  3477. ( bSelected && bEnabled )
  3478. ? COLOR_HIGHLIGHTTEXT 
  3479. : bEnabled
  3480. ? COLOR_BTNTEXT 
  3481. : COLOR_GRAYTEXT, 
  3482. this
  3483. );
  3484. COLORREF clrTextOld = dc.SetTextColor( clrText );
  3486. UINT nFormat = 
  3487. DT_SINGLELINE
  3488. | DT_LEFT
  3489. | DT_VCENTER
  3490. | DT_NOPREFIX
  3491. ;
  3492. if( sText.Find( _T('t') ) != -1 ) // do tabs expanding
  3493. nFormat |= DT_EXPANDTABS;
  3495. CRect rcItemText( rcText );
  3496. if( nColWidth > 0L 
  3497. && nCellItem < nCount - 1
  3498. )
  3499. rcItemText.right = rcItemText.left + nColWidth;
  3501. HFONT hFont = OnQueryFont();
  3502. if( hFont == NULL )
  3503. hFont = (HFONT)PmBridge_GetPM()->m_FontNormal.GetSafeHandle();
  3504. ASSERT( hFont != NULL );
  3505. HFONT hOldFont = (HFONT)::SelectObject( dc.m_hDC, hFont );
  3506. dc.DrawText(
  3507. sText,
  3508. &rcItemText,
  3509. (nFormat|DT_END_ELLIPSIS)
  3510. );
  3511. ::SelectObject( dc.m_hDC, hOldFont );
  3513. dc.SetTextColor( clrTextOld );
  3515. } // if( ! sText.IsEmpty() )
  3517. if( nColWidth > 0 )
  3518. rcText.left += nColWidth;
  3519. }
  3521. } // for( ...
  3522. } // if( pLbItem != NULL )
  3524. dc.SetBkMode( nOldBkMode );
  3526. if( bSelected && bEnabled )
  3527. {
  3528. COLORREF clrTextOld = 
  3529. dc.SetTextColor( RGB(255,255,255) );
  3530. COLORREF clrBkOld = dc.SetBkColor( RGB(0,0,0) );
  3531. ::DrawFocusRect( dc, &rcDrawItem );
  3532. dc.SetBkColor( clrBkOld );
  3533. dc.SetTextColor( clrTextOld );
  3534. }
  3535. }
  3537. void CExtComboBoxBase::OnPopupListBoxMeasureItem( LPMEASUREITEMSTRUCT lpMIS )
  3538. {
  3539. ASSERT_VALID( this );
  3540. ASSERT( lpMIS != NULL );
  3542. if( (GetStyle() & CBS_HASSTRINGS) == 0 
  3543. && (GetStyle() & LBS_HASSTRINGS) == 0 
  3544. )
  3545. return;
  3547. lpMIS->itemWidth = lpMIS->itemHeight = 16;
  3548. INT nItem = lpMIS->itemID;
  3549. if( nItem < 0 || nItem >= GetCount() )
  3550. return;
  3552. HFONT hFont = OnQueryFont();
  3553. if( hFont == NULL )
  3554. hFont = (HFONT)PmBridge_GetPM()->m_FontNormal.GetSafeHandle();
  3555. ASSERT( hFont != NULL );
  3557. INT nHeight = 0;
  3558. INT nWidth = 0;
  3560. LB_ITEM * pLbItem = LbItemGet( nItem );
  3561. if( pLbItem != NULL )
  3562. {
  3563. INT nCount = pLbItem->LbItemCellGetCount();
  3564. for( INT nCellItem = 0; nCellItem < nCount; nCellItem++ )
  3565. {
  3566. LB_ITEM::CELL * pItemCell = pLbItem->LbItemCellGet( nCellItem );
  3567. if( pItemCell != NULL )
  3568. {
  3569. CExtSafeString sText = pItemCell->m_sItemText;
  3570. if( !sText.IsEmpty() )
  3571. {
  3572. UINT nFormat = 
  3573. DT_SINGLELINE
  3574. | DT_LEFT
  3575. | DT_VCENTER
  3576. | DT_NOPREFIX
  3577. ;
  3578. if( sText.Find( _T('t') ) != -1 ) // do tabs expanding
  3579. nFormat |= DT_EXPANDTABS;
  3581. CWindowDC dc( NULL );
  3582. CRect rcMeasure =
  3583. CExtPaintManager::stat_CalcTextDimension( 
  3584. dc, 
  3585. *CFont::FromHandle( hFont ), 
  3586. sText,
  3587. nFormat
  3588. );
  3590. nHeight = max( nHeight, rcMeasure.Height() );
  3591. nWidth += rcMeasure.Width();
  3592. CSize szExtra = 
  3593. OnPopupListBoxCalcItemCellExtraSizes();
  3594. nWidth += szExtra.cx;
  3595. }
  3596. } // if( pItemCell != NULL )
  3597. }
  3599. }
  3600. else
  3601. {
  3602. CExtSafeString sMeasure;
  3603. GetLBText( nItem, sMeasure );
  3604. if( sMeasure.IsEmpty() )
  3605. return;
  3606. CWindowDC dc( NULL );
  3607. CRect rcMeasure =
  3608. CExtPaintManager::stat_CalcTextDimension( 
  3609. dc, 
  3610. *CFont::FromHandle( hFont ), 
  3611. sMeasure,
  3612. DT_SINGLELINE | DT_LEFT | DT_NOPREFIX
  3613. );
  3615. nWidth = rcMeasure.Width();
  3616. nHeight = rcMeasure.Height();
  3617. }
  3619. lpMIS->itemWidth = nWidth;
  3620. lpMIS->itemHeight = max( nHeight, (INT)lpMIS->itemHeight );
  3622. CSize szExtra = 
  3623. OnPopupListBoxCalcItemExtraSizes( nItem );
  3624. lpMIS->itemWidth += szExtra.cx * 2;
  3625. lpMIS->itemHeight += szExtra.cy * 2;
  3626. }
  3628. HFONT CExtComboBoxBase::OnQueryFont() const
  3629. {
  3630. ASSERT_VALID( this );
  3631. HFONT hFont = NULL;
  3632. if( GetSafeHwnd() != NULL )
  3633. hFont = (HFONT) ::SendMessage( m_hWnd, WM_GETFONT, 0L, 0L );
  3634. if( hFont == NULL )
  3635. {
  3636. HWND hWndParent = ::GetParent( m_hWnd );
  3637. if( hWndParent != NULL )
  3638. hFont = (HFONT)
  3639. ::SendMessage( hWndParent, WM_GETFONT, 0L, 0L );
  3640. } // if( hFont == NULL )
  3641. if( hFont == NULL )
  3642. {
  3643. hFont = (HFONT)::GetStockObject( DEFAULT_GUI_FONT );
  3644. if( hFont == NULL )
  3645. hFont = (HFONT)::GetStockObject( SYSTEM_FONT );
  3646. } // if( hFont == NULL )
  3647. return hFont;
  3648. }
  3650. INT CExtComboBoxBase::LbItemSet(
  3651. INT nIndex,
  3652. __EXT_MFC_SAFE_LPCTSTR lpszItem
  3653. )
  3654. {
  3655. INT nCount = INT( m_arrLBItems.GetSize() );
  3656. if( nIndex < 0 || nIndex > nCount )
  3657. return CB_ERR;
  3659. LB_ITEM * pLbItem = new LB_ITEM();
  3660. ASSERT( pLbItem != NULL );
  3661. m_arrLBItems.SetAtGrow( nIndex, pLbItem );
  3663. INT nItem = pLbItem->LbItemCellInsert( lpszItem );
  3664. LB_ITEM::CELL * pItemCell = 
  3665. pLbItem->LbItemCellGet( nItem );
  3666. ASSERT( pItemCell != NULL );
  3668. return nIndex;
  3669. }
  3671. INT CExtComboBoxBase::LbItemInsert(
  3672. __EXT_MFC_SAFE_LPCTSTR lpszItem,
  3673. INT nIndex // = -1
  3674. )
  3675. {
  3676. INT nCount = INT( m_arrLBItems.GetSize() );
  3677. if( nIndex < 0 || nIndex > nCount )
  3678. nIndex = nCount; // append
  3680. LB_ITEM * pLbItem = new LB_ITEM();
  3681. ASSERT( pLbItem != NULL );
  3682. m_arrLBItems.InsertAt( nIndex, pLbItem );
  3684. INT nItem = pLbItem->LbItemCellInsert( lpszItem );
  3685. LB_ITEM::CELL * pItemCell = 
  3686. pLbItem->LbItemCellGet( nItem );
  3687. ASSERT( pItemCell != NULL );
  3689. return nIndex;
  3690. }
  3692. bool CExtComboBoxBase::LbItemRemove(
  3693. LONG nIndex
  3694. )
  3695. {
  3696. INT nCount = INT( m_arrLBItems.GetSize() );
  3697. if( nIndex < 0 || nIndex >= nCount )
  3698. return false;
  3699. LB_ITEM * pLbItem = m_arrLBItems.GetAt( nIndex );
  3700. ASSERT( pLbItem != NULL );
  3701. if( pLbItem != NULL )
  3702. {
  3703. delete pLbItem;
  3704. pLbItem = NULL;
  3705. }
  3706. m_arrLBItems.RemoveAt( nIndex );
  3707. return true;
  3708. }
  3710. void CExtComboBoxBase::LbItemRemoveAll()
  3711. {
  3712. while( m_arrLBItems.GetSize() > 0 )
  3713. {
  3714. LB_ITEM * pLbItem = m_arrLBItems[0];
  3715. if( pLbItem != NULL ) 
  3716. {
  3717. delete pLbItem;
  3718. pLbItem = NULL;
  3719. }
  3720. m_arrLBItems.RemoveAt(0);
  3721. }
  3722. }
  3724. CExtComboBoxBase::LB_ITEM * CExtComboBoxBase::LbItemGet( 
  3725. LONG nItem
  3726. ) const
  3727. {
  3728. ASSERT_VALID( this );
  3729. INT nCount = INT( m_arrLBItems.GetSize() );
  3730. if( nItem < 0 || nItem >= nCount )
  3731. return NULL;
  3733. LB_ITEM * pLbItem = m_arrLBItems.GetAt( nItem );
  3734. ASSERT( pLbItem != NULL );
  3735. return pLbItem;
  3736. }
  3738. LONG CExtComboBoxBase::LbColumnWidthGet( 
  3739. LONG nColNo
  3740. ) const
  3741. {
  3742. ASSERT_VALID( this );
  3743. LONG nWidth = -1L;
  3744. if( ! m_mapColumnsWidth.Lookup( nColNo, nWidth ) )
  3745. return -1L;
  3746. return nWidth;
  3747. }
  3749. void CExtComboBoxBase::LbColumnWidthSet( 
  3750. LONG nColNo,
  3751. LONG nWidth
  3752. )
  3753. {
  3754. ASSERT_VALID( this );
  3755. m_mapColumnsWidth.SetAt( nColNo, nWidth );
  3756. }
  3758. bool CExtComboBoxBase::LbItemIsEnabled(
  3759. LONG nItem
  3760. ) const
  3761. {
  3762. ASSERT_VALID( this );
  3763. if( nItem < 0L 
  3764. || nItem >= GetCount() 
  3765. )
  3766. return false;
  3767. bool bEnabled = true;
  3768. LB_ITEM * pLbItem = LbItemGet( nItem );
  3769. if( pLbItem != NULL )
  3770. bEnabled = pLbItem->IsEnabled();
  3771. return bEnabled;
  3772. }
  3774. void CExtComboBoxBase::LbItemEnable(
  3775. LONG nItem,
  3776. bool bEnable // = true
  3777. )
  3778. {
  3779. ASSERT_VALID( this );
  3780. if( nItem < 0L 
  3781. || nItem >= GetCount() 
  3782. )
  3783. return;
  3784. LB_ITEM * pLbItem = LbItemGet( nItem );
  3785. if( pLbItem != NULL )
  3786. pLbItem->Enable( bEnable );
  3787. }
  3789. #define UPDATE_TIMER 1
  3790. #define UPDATE_TIMER_PERIOD 100
  3792. /////////////////////////////////////////////////////////////////////////////
  3793. // CExtComboBox
  3795. IMPLEMENT_DYNCREATE( CExtComboBox, CExtComboBoxBase );
  3797. CExtComboBox::CExtComboBox()
  3798. : CExtComboBoxBase()
  3799. , m_bLButtonDown( false )
  3800. , m_bPainted( false )
  3801. , m_dwLastStateCode( 0 )
  3802. {
  3803. }
  3805. CExtComboBox::~CExtComboBox()
  3806. {
  3807. CExtAnimationSite * pAcAS = AnimationClient_SiteGet();
  3808. if( pAcAS != NULL )
  3809. pAcAS->AnimationSite_ClientRemove( this );
  3810. }
  3812. BEGIN_MESSAGE_MAP(CExtComboBox, CExtComboBoxBase)
  3813. //{{AFX_MSG_MAP(CExtComboBox)
  3814. ON_WM_LBUTTONDOWN()
  3815. ON_WM_LBUTTONUP()
  3816. ON_WM_TIMER()
  3817. ON_WM_PAINT()
  3818. ON_WM_SETCURSOR()
  3819. ON_WM_ERASEBKGND()
  3820. ON_WM_SETFOCUS()
  3821. ON_WM_KILLFOCUS()
  3822. //}}AFX_MSG_MAP
  3823. END_MESSAGE_MAP()
  3825. /////////////////////////////////////////////////////////////////////////////
  3826. // CExtComboBox message handlers
  3828. BOOL CExtComboBox::OnSetCursor( CWnd * pWnd, UINT nHitTest, UINT message )
  3829. {
  3830. if( message == WM_MOUSEMOVE )
  3831. {
  3832. CRect rcWnd;
  3833. GetWindowRect( &rcWnd );
  3834. if( rcWnd.PtInRect( GetCurrentMessage()->pt ) )
  3835. {
  3836. SetTimer( UPDATE_TIMER, UPDATE_TIMER_PERIOD, NULL );
  3837. OnTimer( UPDATE_TIMER );
  3838. }
  3839. }
  3840. return CExtComboBoxBase::OnSetCursor(pWnd, nHitTest, message);
  3841. }
  3843. void CExtComboBox::OnLButtonDown(UINT nFlags, CPoint point)
  3844. {
  3845. m_bLButtonDown = true;
  3846. CExtComboBoxBase::OnLButtonDown(nFlags, point);
  3847. }
  3849. void CExtComboBox::OnLButtonUp(UINT nFlags, CPoint point)
  3850. {
  3851. m_bLButtonDown = false;
  3852. Invalidate();
  3853. CExtComboBoxBase::OnLButtonUp(nFlags, point);
  3854. }
  3856. bool CExtComboBox::IsFocused() const
  3857. {
  3858. bool bFocused = false;
  3859. HWND hWndFocus = ::GetFocus();
  3860. if( hWndFocus == GetSafeHwnd()
  3861. || ::IsChild( GetSafeHwnd(), hWndFocus )
  3862. )
  3863. bFocused = true;
  3864. return bFocused;
  3865. }
  3867. bool CExtComboBox::IsHovered() const
  3868. {
  3869. CPoint ptCursorPos( 0, 0 );
  3870. ::GetCursorPos( &ptCursorPos );
  3871. CRect rcItem;
  3872. GetWindowRect( &rcItem );
  3873. bool bHovered = false;
  3874. if( rcItem.PtInRect(ptCursorPos) )
  3875. bHovered = true;
  3876. return bHovered;
  3877. }
  3879. void CExtComboBox::OnSetFocus( CWnd * pOldWnd ) 
  3880. {
  3881. HWND hWndOwn = m_hWnd;
  3882. CExtComboBoxBase::OnSetFocus( pOldWnd );
  3883. if( ! ::IsWindow( hWndOwn ) )
  3884. return;
  3885. Invalidate();     
  3886. }
  3888. void CExtComboBox::OnKillFocus( CWnd * pNewWnd ) 
  3889. {
  3890. HWND hWndOwn = m_hWnd;
  3891. CExtComboBoxBase::OnKillFocus( pNewWnd );
  3892. if( ! ::IsWindow( hWndOwn ) )
  3893. return;
  3894. Invalidate();     
  3895. }
  3897. void CExtComboBox::OnTimer( __EXT_MFC_UINT_PTR nIDEvent )
  3898. {
  3899. if( UPDATE_TIMER == nIDEvent )
  3900. {
  3901. CClientDC dc( this );
  3902. if( m_bLButtonDown )
  3903. {
  3904. KillTimer( UPDATE_TIMER );
  3905. if( m_bPainted )
  3906. {
  3907. _OnDrawComboImpl( 
  3908. GetDroppedState() ? true : false, 
  3909. IsHovered(), 
  3910. &dc 
  3911. );
  3912. m_bPainted = false;
  3913. }
  3914. }
  3915. else if( !IsHovered() && !IsFocused() )
  3916. {
  3917. KillTimer( UPDATE_TIMER );
  3918. if( m_bPainted == TRUE )
  3919. {
  3920. _OnDrawComboImpl( 
  3921. false, 
  3922. false, 
  3923. &dc 
  3924. );
  3925. m_bPainted = false;
  3926. }
  3927. }
  3928. else
  3929. {
  3930. if( !m_bPainted )
  3931. {
  3932. m_bPainted = true;
  3933. _OnDrawComboImpl( 
  3934. GetDroppedState() ? true : false, 
  3935. true, 
  3936. &dc 
  3937. );
  3938. }
  3939. else
  3940. return;
  3941. }
  3942. return;
  3943. }
  3944. if( AnimationSite_OnHookTimer( UINT(nIDEvent) ) )
  3945. return;
  3946. CExtComboBoxBase::OnTimer( nIDEvent );
  3947. }
  3949. BOOL CExtComboBox::OnEraseBkgnd(CDC* pDC)
  3950. {
  3951. pDC;
  3952. return TRUE;
  3953. }
  3955. void CExtComboBox::OnPaint()
  3956. {
  3957. if( ( GetExStyle() & (WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE|WS_EX_STATICEDGE) ) != 0 )
  3958. ModifyStyleEx( WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE|WS_EX_STATICEDGE, 0, SWP_FRAMECHANGED );
  3959. COLORREF clrFillClientArea = COLORREF(-1L);
  3960. DWORD dwStyle = GetStyle();
  3961. CPaintDC dcPaint( this );
  3962. CExtPaintManager::stat_ExcludeChildAreas( dcPaint.GetSafeHdc(), GetSafeHwnd() );
  3963. CRect rcClient;
  3964. GetClientRect( &rcClient );
  3965. CExtMemoryDC dc( &dcPaint, &rcClient );
  3966. CRgn _rgn;
  3967. if( ( dwStyle & ( CBS_OWNERDRAWFIXED|CBS_OWNERDRAWVARIABLE ) ) != 0 )
  3968. {
  3969. CRect rcRgn = rcClient;
  3970. rcRgn.right -= ::GetSystemMetrics( SM_CXVSCROLL );
  3971. if( _rgn.CreateRectRgnIndirect( &rcRgn ) )
  3972. dc.SelectClipRgn( &_rgn );
  3973. }
  3974. DefWindowProc( WM_PAINT, (WPARAM)dc.GetSafeHdc(), (LPARAM)0 );
  3975. if( _rgn.GetSafeHandle() != NULL )
  3976. dc.SelectClipRgn( NULL );
  3977. if( (dwStyle&CBS_SIMPLE) == CBS_SIMPLE 
  3978. && (dwStyle&CBS_DROPDOWN) != CBS_DROPDOWN
  3979. && (dwStyle&CBS_DROPDOWNLIST) != CBS_DROPDOWNLIST
  3980. )
  3981. {
  3982. if( (! PmBridge_GetPM()->GetCb2DbTransparentMode(this) )
  3983. || (! PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  3984. )
  3985. clrFillClientArea = PmBridge_GetPM()->GetColor( CExtPaintManager::CLR_3DFACE_OUT, this );
  3986. }
  3987. if( clrFillClientArea != COLORREF(-1L) )
  3988. dc.FillSolidRect( &rcClient, clrFillClientArea );
  3989. _OnDrawComboImpl( GetDroppedState() ? true : false, IsHovered(), &dc );
  3990. }
  3992. void CExtComboBox::_OnDrawComboImpl(
  3993. bool bPressed,
  3994. bool bHover,
  3995. CDC * pDC // = NULL
  3996. )
  3997. {
  3998. if( pDC != NULL )
  3999. {
  4000. if( AnimationClient_StatePaint( *pDC ) )
  4001. return;
  4002. }
  4003. bool bCallReleaseDC = false;
  4004. if( pDC == NULL )
  4005. {
  4006. pDC = GetDC();
  4007. ASSERT( pDC != NULL );
  4008. bCallReleaseDC = true;
  4009. }
  4010. CRect rcClient;
  4011. GetClientRect( &rcClient );
  4012. bool bEnabled = IsWindowEnabled() ? true : false;
  4013. bool bPushed = ( bPressed || GetDroppedState() ) ? true : false;
  4014. if( ! bEnabled )
  4015. {
  4016. bPushed = false;
  4017. bHover = false;
  4018. }
  4019. if( CExtPopupMenuWnd::IsMenuTracking() )
  4020. bHover = false;
  4021. else if( (!IsHovered()) && IsFocused() )
  4022. bHover = true;
  4023. DWORD dwStyle = GetStyle();
  4024. if( (dwStyle&CBS_SIMPLE) == CBS_SIMPLE 
  4025. && (dwStyle&CBS_DROPDOWN) != CBS_DROPDOWN
  4026. && (dwStyle&CBS_DROPDOWNLIST) != CBS_DROPDOWNLIST
  4027. )
  4028. {
  4029. HWND hWndFocus = ::GetFocus();
  4030. CEdit * pEdit = GetInnerEditCtrl();
  4031. CExtComboBoxPopupListBox * pLB = OnComboBoxPopupListBoxQuery();
  4032. HWND hWndEdit = pEdit->GetSafeHwnd();
  4033. ASSERT( hWndEdit != NULL );
  4034. HWND hWndLB = pLB->GetSafeHwnd();
  4035. ASSERT( hWndLB != NULL );
  4036. bool bFocus = false;
  4037. if( hWndFocus != NULL
  4038. && ( hWndFocus == hWndEdit
  4039. || hWndFocus == hWndLB
  4040. )
  4041. )
  4042. bFocus = true;
  4043. bool bReadOnly = ( ( pEdit->GetStyle() & ES_READONLY ) != 0 ) ? true : false;
  4044. bool bMouseOver = false;
  4045. CRect _rcClient;
  4046. pLB->GetWindowRect( &_rcClient );
  4047. ScreenToClient( &_rcClient );
  4048. _rcClient.InflateRect( 3, 3, 3, 2 );
  4049. pDC->FillSolidRect( &_rcClient, PmBridge_GetPM()->GetColor( COLOR_WINDOW ) );
  4050. pEdit->GetClientRect( &_rcClient );
  4051. pEdit->ClientToScreen( &_rcClient );
  4052. ScreenToClient( &_rcClient );
  4053. _rcClient.InflateRect( 3, 3 );
  4054. CExtPaintManager::PAINTCONTROLFRAMEDATA _pcfdEdit(
  4055. pEdit,
  4056. _rcClient,
  4057. true,
  4058. bMouseOver,
  4059. bEnabled,
  4060. bFocus,
  4061. bReadOnly
  4062. );
  4063. PmBridge_GetPM()->PaintControlFrame( *pDC, _pcfdEdit );
  4064. }
  4065. else
  4066. {
  4067. bool bRightText = false;
  4068. if( (GetExStyle()&WS_EX_RIGHT) != 0 )
  4069. bRightText = true;
  4070. // erase are of the button that contains the drop-down arrow
  4071. CRect rcDDButton( rcClient );
  4072. if( bRightText )
  4073. {
  4074. rcDDButton.right = rcDDButton.left + ::GetSystemMetrics( SM_CXHTHUMB );
  4075. rcDDButton.right += 2;
  4076. }
  4077. else
  4078. {
  4079. rcDDButton.left = rcDDButton.right - ::GetSystemMetrics( SM_CXHTHUMB );
  4080. rcDDButton.left -= 2;
  4081. if( rcDDButton.left > rcDDButton.right )
  4082. rcDDButton.left = rcDDButton.right;
  4083. }
  4084. COLORREF clrBk = GetBkColor();
  4085. if( clrBk == COLORREF(-1L) )
  4086. clrBk = PmBridge_GetPM()->GetColor( ( ! bEnabled ) ? COLOR_3DFACE : COLOR_WINDOW, this );
  4087. pDC->FillSolidRect( &rcDDButton, clrBk );
  4088. // fix for disabled edit border inside combo box
  4089. if( (!bEnabled)
  4090. && (dwStyle&CBS_DROPDOWN) == CBS_DROPDOWN 
  4091. )
  4092. {
  4093. CWnd * pWndChild = GetWindow( GW_CHILD );
  4094. if( pWndChild != NULL )
  4095. {
  4096. ASSERT_VALID( pWndChild );
  4097. static const TCHAR szEdit[] = _T("edit");
  4098. TCHAR szCompare[ sizeof(szEdit)/sizeof(szEdit[0]) + 1 ] = _T("");
  4099. ::GetClassName( pWndChild->GetSafeHwnd(), szCompare, sizeof(szCompare)/sizeof(szCompare[0]) );
  4100. if( ! lstrcmpi( szCompare, szEdit ) )
  4101. {
  4102. CRect rcChild;
  4103. pWndChild->GetWindowRect( &rcChild );
  4104. ScreenToClient( rcChild );
  4105. rcChild.InflateRect( 1, 1 );
  4106. pDC->Draw3dRect( &rcChild, clrBk, clrBk );
  4107. }
  4108. }
  4109. }
  4110. CExtPaintManager::PAINTCOMBOFRAMEDATA _pcfd( this, rcClient, bHover, bPushed, bEnabled, bRightText );
  4111. PmBridge_GetPM()->PaintComboFrame( *pDC, _pcfd );
  4112. DWORD dwLastStateCode = 0;
  4113. if( m_bLButtonDown )
  4114. dwLastStateCode |= 0x01;
  4115. if( IsHovered() )
  4116. dwLastStateCode |= 0x02;
  4117. if( IsFocused() )
  4118. dwLastStateCode |= 0x04;
  4119. if( bPressed )
  4120. dwLastStateCode |= 0x08;
  4121. if( m_dwLastStateCode != dwLastStateCode )
  4122. {
  4123. if( AnimationClient_StateGet( true ).FromSurface( pDC->m_hDC, rcClient ) )
  4124. {
  4125. if( AnimationClient_StateGet( false ).IsEmpty() )
  4126. AnimationClient_StateGet( false ) = AnimationClient_StateGet( true );
  4127. else
  4128. AnimationSite_OnClientStateChanged( this, 0 );
  4129. }
  4130. m_dwLastStateCode = dwLastStateCode;
  4131. }
  4132. }
  4133. if( bCallReleaseDC )
  4134. ReleaseDC( pDC );
  4135. }
  4137. BOOL CExtComboBox::OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pLResult) 
  4138. {
  4139. ASSERT_VALID( this );
  4140. if( message == WM_COMMAND )
  4141. {
  4142. INT nCode = HIWORD(wParam);
  4143. switch( nCode )
  4144. {
  4145. case CBN_CLOSEUP:
  4146. Invalidate();
  4147. break;
  4148. }
  4149. }
  4150. return CExtComboBoxBase::OnChildNotify(message, wParam, lParam, pLResult);
  4151. }
  4153. LRESULT CExtComboBox::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  4154. {
  4155. if( message == WM_PRINT || message == WM_PRINTCLIENT )
  4156. {
  4157. CExtComboBoxBase::WindowProc( message, wParam, lParam );
  4158. CDC * pDC = CDC::FromHandle( (HDC)wParam );
  4159. CRect rcClient;
  4160. GetClientRect( &rcClient );
  4161. CExtMemoryDC dc( pDC, &rcClient, CExtMemoryDC::MDCOPT_TO_MEMORY|CExtMemoryDC::MDCOPT_FILL_BITS|CExtMemoryDC::MDCOPT_RTL_COMPATIBILITY );
  4162. DWORD dwStyle = GetStyle();
  4163. if( (dwStyle&CBS_SIMPLE) == CBS_SIMPLE 
  4164. && (dwStyle&CBS_DROPDOWN) != CBS_DROPDOWN
  4165. && (dwStyle&CBS_DROPDOWNLIST) != CBS_DROPDOWNLIST
  4166. )
  4167. {
  4168. if( (! PmBridge_GetPM()->GetCb2DbTransparentMode(this) )
  4169. || (! PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  4170. )
  4171. dc.FillSolidRect( &rcClient, PmBridge_GetPM()->GetColor( CExtPaintManager::CLR_3DFACE_OUT, this ) );
  4172. }
  4173. _OnDrawComboImpl( GetDroppedState() ? true : false, IsHovered(), &dc );
  4174. if( (lParam&PRF_CHILDREN) != 0 )
  4175. CExtPaintManager::stat_PrintChildren( m_hWnd, message, dc.GetSafeHdc(), lParam, false );
  4176. return (!0);
  4177. }
  4178. return CExtComboBoxBase::WindowProc( message, wParam, lParam );
  4179. }
  4181. void CExtComboBox::AnimationSite_OnProgressShutdownTimer( UINT nTimerID )
  4182. {
  4183. ASSERT_VALID( this );
  4184. CExtComboBoxBase::AnimationSite_OnProgressShutdownTimer( nTimerID );
  4185. }
  4187. const CExtAnimationParameters *
  4188. CExtComboBox::AnimationClient_OnQueryAnimationParameters(
  4189. INT eAPT // __EAPT_*** animation type
  4190. ) const
  4191. {
  4192. ASSERT_VALID( this );
  4193. eAPT;
  4194. return (&PmBridge_GetPM()->g_DefAnimationParametersEmpty);
  4195. // const CExtAnimationParameters * pAnimationParameters =
  4196. //  PmBridge_GetPM()->Animation_GetParameters(
  4197. //  eAPT,
  4198. //  (CObject*)this,
  4199. //  this
  4200. //  );
  4201. //  return pAnimationParameters;
  4202. }
  4204. //bool CExtComboBox::AnimationClient_CacheNextState(
  4205. // CDC & dc,
  4206. // const RECT & rcAcAnimationTarget,
  4207. // bool bAnimate,
  4208. // INT eAPT // __EAPT_*** animation type
  4209. // )
  4210. //{
  4211. // ASSERT_VALID( this );
  4212. // ASSERT_VALID( (&dc) );
  4213. // ASSERT( dc.GetSafeHdc() != NULL );
  4214. // ASSERT( AnimationClient_CacheGeneratorIsLocked() );
  4215. //
  4216. //DWORD dwWndStyle = GetStyle();
  4217. // if( (dwWndStyle&(CBS_OWNERDRAWFIXED|CBS_OWNERDRAWVARIABLE)) != 0 
  4218. // && (dwWndStyle & 0x0003L) == CBS_DROPDOWNLIST
  4219. // )
  4220. // {
  4221. // DefWindowProc( WM_PAINT, (WPARAM)dc.GetSafeHdc(), (LPARAM)0 );
  4222. // _OnDrawComboImpl( 
  4223. // GetDroppedState() ? true : false, 
  4224. // IsHovered(), 
  4225. // &dc 
  4226. // );
  4227. // return
  4228. // CExtComboBoxBase::AnimationClient_CacheNextState(
  4229. // dc,
  4230. // rcAcAnimationTarget,
  4231. // bAnimate,
  4232. // eAPT
  4233. // );
  4234. // }
  4235. //
  4236. // CExtPaintManager::stat_ExcludeChildAreas(
  4237. // dc.GetSafeHdc(),
  4238. // GetSafeHwnd()
  4239. // );
  4240. //CRect rcClient;
  4241. // GetClientRect( &rcClient );
  4242. // DefWindowProc( WM_PAINT, (WPARAM)dc.GetSafeHdc(), (LPARAM)0 );
  4243. //
  4244. //DWORD dwStyle = GetStyle();
  4245. // if( (dwStyle&CBS_SIMPLE) == CBS_SIMPLE 
  4246. // && (dwStyle&CBS_DROPDOWN) != CBS_DROPDOWN
  4247. // && (dwStyle&CBS_DROPDOWNLIST) != CBS_DROPDOWNLIST
  4248. // )
  4249. // {
  4250. // if( (! PmBridge_GetPM()->GetCb2DbTransparentMode(this) )
  4251. // || (! PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  4252. // )
  4253. // dc.FillSolidRect(
  4254. // &rcClient,
  4255. // PmBridge_GetPM()->GetColor(
  4256. // CExtPaintManager::CLR_3DFACE_OUT, this
  4257. // )
  4258. // );
  4259. // }
  4260. //
  4261. // _OnDrawComboImpl( 
  4262. // GetDroppedState() ? true : false, 
  4263. // IsHovered(), 
  4264. // &dc 
  4265. // );
  4266. //
  4267. // return
  4268. // CExtComboBoxBase::AnimationClient_CacheNextState(
  4269. // dc,
  4270. // rcAcAnimationTarget,
  4271. // bAnimate,
  4272. // eAPT
  4273. // );
  4274. //}
  4276. /////////////////////////////////////////////////////////////////////////////
  4277. // CExtCheckComboBox window
  4279. IMPLEMENT_DYNCREATE( CExtCheckComboBox, CExtComboBox );
  4281. CExtCheckComboBox::CExtCheckComboBox()
  4282. : m_bHaveText( false )
  4283. , m_bHaveItemHeight( false )
  4284. {
  4285. }
  4287. CExtCheckComboBox::~CExtCheckComboBox()
  4288. {
  4289. }
  4291. BEGIN_MESSAGE_MAP( CExtCheckComboBox, CExtComboBox )
  4292. //{{AFX_MSG_MAP(CExtCheckComboBox)
  4293. ON_MESSAGE( WM_GETTEXT, OnGetText )
  4294. ON_MESSAGE( WM_GETTEXTLENGTH, OnGetTextLength )
  4295. //}}AFX_MSG_MAP
  4296. END_MESSAGE_MAP()
  4298. BOOL CExtCheckComboBox::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  4299. {
  4300. dwStyle &= ~0xF;
  4301. dwStyle |= CBS_DROPDOWNLIST|CBS_OWNERDRAWVARIABLE|CBS_HASSTRINGS;
  4302. return CExtComboBox::Create( dwStyle, rect, pParentWnd, nID );
  4303. }
  4305. LRESULT CExtCheckComboBox::WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  4306. {
  4307. if( message == CB_RESETCONTENT )
  4308. m_bHaveItemHeight = m_bHaveText = false;
  4309. else
  4310. if( WM_KEYFIRST <= message && message <= WM_KEYLAST
  4311. && ( wParam == VK_UP || wParam == VK_DOWN || wParam == VK_LEFT || wParam == VK_RIGHT || wParam == VK_PRIOR || wParam == VK_NEXT || wParam == VK_HOME || wParam == VK_END )
  4312. )
  4313. {
  4314. if( ! GetDroppedState() )
  4315. {
  4316. ShowDropDown();
  4317. return 0L;
  4318. }
  4319. SetRedraw( FALSE );
  4320. LRESULT lResult = CExtComboBox::WindowProc( message, wParam, lParam );
  4321. SetRedraw( TRUE );
  4322. Invalidate( TRUE );
  4323. UpdateWindow();
  4324. //_OnDrawComboImpl( false, false );
  4325. return lResult;
  4326. }
  4327. return CExtComboBox::WindowProc( message, wParam, lParam );
  4328. }
  4330. BOOL CExtCheckComboBox::PreTranslateMessage( MSG * pMsg )
  4331. {
  4332. if( pMsg->message == WM_MOUSEWHEEL )
  4333. return TRUE;
  4334. return CExtComboBox::PreTranslateMessage( pMsg );
  4335. }
  4337. void CExtCheckComboBox::PreSubclassWindow()
  4338. {
  4339. ASSERT_VALID( this );
  4340. m_bHaveItemHeight = m_bHaveText = false;
  4341. CExtComboBox::PreSubclassWindow();
  4342. }
  4344. void CExtCheckComboBox::PostNcDestroy()
  4345. {
  4346. ASSERT_VALID( this );
  4347. m_bHaveItemHeight = m_bHaveText = false;
  4348. CExtComboBox::PostNcDestroy();
  4349. }
  4351. void CExtCheckComboBox::_OnDrawComboImpl(
  4352. bool bPressed,
  4353. bool bHover,
  4354. CDC * pDC // = NULL
  4355. )
  4356. {
  4357. if( pDC != NULL )
  4358. {
  4359. if( AnimationClient_StatePaint( *pDC ) )
  4360. return;
  4361. }
  4362. bool bCallReleaseDC = false;
  4363. if( pDC == NULL )
  4364. {
  4365. pDC = GetDC();
  4366. ASSERT( pDC != NULL );
  4367. bCallReleaseDC = true;
  4368. }
  4369. DRAWITEMSTRUCT dis;
  4370. ::memset( &dis, 0, sizeof( DRAWITEMSTRUCT ) );
  4371. dis.CtlType = ODT_LISTBOX;
  4372. dis.CtlID = GetDlgCtrlID();
  4373. dis.itemID = UINT(-1);
  4374. dis.hDC = pDC->GetSafeHdc();
  4375. CRect rc;
  4376. GetClientRect( &rc );
  4377. rc.DeflateRect(
  4378. 3,
  4379. 3,
  4380. 3 + ::GetSystemMetrics( SM_CXVSCROLL ), // + PmBridge_GetPM()->GetDropDownButtonWidth(),
  4381. 3
  4382. );
  4383. ::CopyRect( &dis.rcItem, &rc );
  4384. dis.itemAction = ODA_DRAWENTIRE;
  4385. dis.hwndItem = GetSafeHwnd();
  4386. if( ::GetFocus() == m_hWnd )
  4387. dis.itemState |= ODS_FOCUS|ODS_SELECTED;
  4388. SendMessage( 
  4389. WM_DRAWITEM, 
  4390. (WPARAM)GetDlgCtrlID(), 
  4391. (LPARAM)&dis 
  4392. );
  4393. CExtComboBox::_OnDrawComboImpl( bPressed, bHover, pDC );
  4394. if( bCallReleaseDC )
  4395. ReleaseDC( pDC );
  4396. }
  4398. void CExtCheckComboBox::OnPaintItemCheck( CDC & dc, const RECT & rcCheck, INT nIndex )
  4399. {
  4400. ASSERT_VALID( this );
  4401. ASSERT( dc.GetSafeHdc() != NULL );
  4402. if( ! dc.RectVisible(&rcCheck) )
  4403. return;
  4404. ASSERT( nIndex >= 0 && nIndex < GetCount() );
  4405. bool bCheck = CheckGet( nIndex );
  4406. bool bDefaultDrawing = true;
  4407. if( g_PaintManager.m_UxTheme.IsControlsThemed()
  4408. && g_PaintManager.m_UxTheme.OpenThemeData( GetSafeHwnd(), L"BUTTON" ) != NULL
  4409. )
  4410. {
  4411. INT nState = 0;
  4412. INT nPartID = 0;
  4413. nPartID = BP_CHECKBOX;
  4414. if( bCheck )
  4415. nState = CBS_CHECKEDNORMAL;
  4416. else
  4417. nState = CBS_UNCHECKEDNORMAL;
  4418. if( g_PaintManager.m_UxTheme. DrawThemeBackground( dc.GetSafeHdc(), nPartID, nState, &rcCheck, &rcCheck ) == S_OK )
  4419. bDefaultDrawing = false;
  4420. g_PaintManager.m_UxTheme.CloseThemeData( true );
  4421. }
  4422. if( bDefaultDrawing )
  4423. {
  4424. UINT nState = DFCS_BUTTONCHECK;
  4425. if( bCheck )
  4426. nState |= DFCS_CHECKED;
  4427. dc.DrawFrameControl( (RECT *)&rcCheck, DFC_BUTTON, nState );
  4428. } // if( bDefaultDrawing )
  4429. }
  4431. void CExtCheckComboBox::DrawItem( LPDRAWITEMSTRUCT pDIS )
  4432. {
  4433. ASSERT_VALID( this );
  4434. ASSERT( GetSafeHwnd() != NULL );
  4435. CExtPaintManager * pPM = PmBridge_GetPM();
  4436. ASSERT_VALID( pPM );
  4437. CRect rcCheck( pDIS->rcItem ), rcText( pDIS->rcItem );
  4438. CString strText;
  4439. bool bCheckPresent = true;
  4440. bool bFR = ( (pDIS->itemState & (ODS_FOCUS|ODS_SELECTED)) == (ODS_FOCUS|ODS_SELECTED) ) ? true : false;
  4441. if( LONG( pDIS->itemID ) < 0L )
  4442. {
  4443. _UpdateText();
  4444. strText = LPCTSTR(m_strText);
  4445. bCheckPresent = false;
  4446. }
  4447. else
  4448. {
  4449. CSize _sizeBox( 13, 13 );
  4450. _sizeBox.cx = pPM->UiScalingDo( _sizeBox.cx, CExtPaintManager::__EUIST_X );
  4451. _sizeBox.cy = pPM->UiScalingDo( _sizeBox.cy, CExtPaintManager::__EUIST_Y );
  4452. GetLBText( pDIS->itemID, strText );
  4453. TEXTMETRIC _tm;
  4454. ::memset( &_tm, 0, sizeof(TEXTMETRIC) );
  4455. ::GetTextMetrics( pDIS->hDC, &_tm);
  4456. rcCheck.left ++;
  4457. rcCheck.right = rcCheck.left + _sizeBox.cx;
  4458. rcCheck.bottom = rcCheck.top + _sizeBox.cy;
  4459. rcCheck.OffsetRect( 0, ( rcText.Height() - rcCheck.Height() ) / 2 );
  4460. rcText.left = rcCheck.right + 2;
  4461. }
  4462. if( bCheckPresent )
  4463. OnPaintItemCheck( *CDC::FromHandle( pDIS->hDC ), rcCheck, pDIS->itemID );
  4464. if( pDIS->itemState & ODS_SELECTED )
  4465. {
  4466. ::SetBkColor( pDIS->hDC, pPM->GetColor( COLOR_HIGHLIGHT, this ) );
  4467. ::SetTextColor( pDIS->hDC, pPM->GetColor( COLOR_HIGHLIGHTTEXT, this ) );
  4468. }
  4469. else
  4470. {
  4471. ::SetBkColor( pDIS->hDC, pPM->GetColor( COLOR_WINDOW, this ) );
  4472. ::SetTextColor( pDIS->hDC, pPM->GetColor( COLOR_WINDOWTEXT, this ) );
  4473. }
  4474. HFONT hFont = OnQueryFont();
  4475. if( hFont == NULL )
  4476. hFont = (HFONT)PmBridge_GetPM()->m_FontNormal.GetSafeHandle();
  4477. ASSERT( hFont != NULL );
  4478. HFONT hOldFont = (HFONT)::SelectObject( pDIS->hDC, hFont );
  4479. ::ExtTextOut( pDIS->hDC, 0, 0, ETO_OPAQUE, &rcText, 0, 0, 0 );
  4480. ::DrawText( pDIS->hDC, _T(" ") + strText, strText.GetLength() + 1, &rcText, DT_SINGLELINE|DT_VCENTER|DT_END_ELLIPSIS );
  4481. if( bFR )
  4482. ::DrawFocusRect( pDIS->hDC, &rcText );
  4483. ::SelectObject( pDIS->hDC, hOldFont );
  4484. }
  4486. void CExtCheckComboBox::MeasureItem( LPMEASUREITEMSTRUCT pMIS )
  4487. {
  4488. ASSERT_VALID( this );
  4489. ASSERT( GetSafeHwnd() != NULL );
  4490. CClientDC dc(this);
  4491. HFONT hFont = OnQueryFont();
  4492. if( hFont == NULL )
  4493. hFont = (HFONT)PmBridge_GetPM()->m_FontNormal.GetSafeHandle();
  4494. ASSERT( hFont != NULL );
  4495. HFONT hOldFont = (HFONT)dc.SelectObject( hFont );
  4496. TEXTMETRIC _tm;
  4497. ::memset( &_tm, 0, sizeof(TEXTMETRIC) );
  4498. dc.GetTextMetrics( &_tm );
  4499. pMIS->itemWidth = 20;
  4500. pMIS->itemHeight = _tm.tmHeight + _tm.tmExternalLeading;
  4501. pMIS->itemHeight += 2;
  4502. if( ! m_bHaveItemHeight )
  4503. {
  4504. m_bHaveItemHeight = true;
  4505. SetItemHeight( -1, pMIS->itemHeight );
  4506. }
  4507. dc.SelectObject( hOldFont );
  4508. }
  4510. LRESULT CExtCheckComboBox::OnGetText( WPARAM wParam, LPARAM lParam )
  4511. {
  4512. ASSERT_VALID( this );
  4513. ASSERT( GetSafeHwnd() != NULL );
  4514. _UpdateText();
  4515. if( lParam == 0 )
  4516. return 0;
  4517. __EXT_MFC_STRCPY( (LPTSTR)lParam, (INT)wParam, LPCTSTR(m_strText) );
  4518. LRESULT lr = LRESULT( m_strText.GetLength() );
  4519. return lr;
  4520. }
  4522. LRESULT CExtCheckComboBox::OnGetTextLength(WPARAM, LPARAM)
  4523. {
  4524. ASSERT_VALID( this );
  4525. ASSERT( GetSafeHwnd() != NULL );
  4526. _UpdateText();
  4527. LRESULT lr = LRESULT( m_strText.GetLength() );
  4528. return lr;
  4529. }
  4531. void CExtCheckComboBox::_UpdateText()
  4532. {
  4533. ASSERT_VALID( this );
  4534. ASSERT( GetSafeHwnd() != NULL );
  4535. if(  m_bHaveText )
  4536. return;
  4537. INT nIndex, nCount = GetCount();
  4538. TCHAR szBuffer[10] = _T("");
  4539. g_ResourceManager->GetLocaleInfo( LOCALE_SLIST, szBuffer, sizeof(szBuffer) );
  4540. CExtSafeString strSeparator = szBuffer;
  4541. if( strSeparator.GetLength() == 0 )
  4542. strSeparator = _T(";");
  4543. strSeparator.TrimRight();
  4544. strSeparator += _T(' ');
  4545. m_strText.Empty();
  4546. for( nIndex = 0; nIndex < nCount; nIndex++ )
  4547. {
  4548. if( ! CheckGet( nIndex ) )
  4549. continue;
  4550. CString strItem;
  4551. GetLBText( nIndex, strItem );
  4552. if( ! m_strText.IsEmpty() )
  4553. m_strText += LPCTSTR(strSeparator);
  4554. m_strText += LPCTSTR(strItem);
  4555. }
  4556. m_bHaveText = true;
  4557. }
  4559. void CExtCheckComboBox::CheckSet(
  4560. INT nIndex,
  4561. bool bCheck // = true
  4562. )
  4563. {
  4564. ASSERT_VALID( this );
  4565. if( GetSafeHwnd() == NULL )
  4566. return;
  4567. INT nResult = SetItemData( nIndex, bCheck ? 1 : 0 );
  4568. if( nResult < 0 )
  4569. return;
  4570. m_bHaveText = false;
  4571. Invalidate( FALSE );
  4572. }
  4574. bool CExtCheckComboBox::CheckGet( INT nIndex ) const
  4575. {
  4576. ASSERT_VALID( this );
  4577. if( GetSafeHwnd() == NULL )
  4578. return false;
  4579. bool bCheck = ( GetItemData( nIndex ) != 0 ) ? true : false;
  4580. return bCheck;
  4581. }
  4583. void CExtCheckComboBox::CheckAll(
  4584. bool bCheck // = true
  4585. )
  4586. {
  4587. ASSERT_VALID( this );
  4588. if( GetSafeHwnd() == NULL )
  4589. return;
  4590. INT nIndex, nCount = GetCount();
  4591. for( nIndex = 0; nIndex < nCount; nIndex++ )
  4592. CheckSet( nIndex, bCheck );
  4593. }
  4595. bool CExtCheckComboBox::_OnCbLbPreWndProc( LRESULT & lResult, UINT message, WPARAM wParam, LPARAM lParam )
  4596. {
  4597. lResult; lParam;
  4598. switch( message )
  4599. {
  4600. case WM_CHAR:
  4601. {
  4602. if( wParam == VK_SPACE)
  4603. {
  4604. CExtComboBoxPopupListBox * pLB = OnComboBoxPopupListBoxQuery();
  4605. ASSERT_VALID( pLB );
  4606. INT nIndex = INT( pLB->SendMessage( LB_GETCURSEL ) );
  4607. CRect rcItem;
  4608. pLB->SendMessage( LB_GETITEMRECT, nIndex, (LONG)(VOID *)&rcItem );
  4609. pLB->InvalidateRect( rcItem, FALSE );
  4610. CheckSet( nIndex, ! CheckGet( nIndex ) );
  4611. GetParent()->SendMessage(
  4612. WM_COMMAND,
  4613. MAKELONG( ::__EXT_MFC_GetWindowLong( m_hWnd, GWL_ID ), CBN_SELCHANGE ),
  4614. (LPARAM)m_hWnd
  4615. );
  4616. lResult = 0L;
  4617. return true;
  4618. }
  4619. }
  4620. break;
  4621. case WM_LBUTTONDOWN:
  4622. {
  4623. CExtComboBoxPopupListBox * pLB = OnComboBoxPopupListBoxQuery();
  4624. ASSERT_VALID( pLB );
  4625. CRect rcClient;
  4626. pLB->GetClientRect( &rcClient );
  4627. CPoint pt( LOWORD(lParam), HIWORD(lParam) );
  4628. if( PtInRect( rcClient, pt ) )
  4629. {
  4630. INT nItemHeight = INT( pLB->SendMessage( LB_GETITEMHEIGHT, 0, 0 ) );
  4631. INT nTopIndex   = INT( pLB->SendMessage( LB_GETTOPINDEX, 0, 0 ) );
  4632. INT nIndex = nTopIndex + pt.y / nItemHeight;
  4633. CRect rcItem;
  4634. pLB->SendMessage( LB_GETITEMRECT, nIndex, (LONG)(VOID *)&rcItem );
  4635. if( PtInRect( rcItem, pt ) )
  4636. {
  4637. pLB->InvalidateRect( rcItem, FALSE );
  4638. CheckSet(nIndex, ! CheckGet( nIndex ) );
  4639. GetParent()->SendMessage(
  4640. WM_COMMAND,
  4641. MAKELONG( ::__EXT_MFC_GetWindowLong( m_hWnd, GWL_ID ), CBN_SELCHANGE ),
  4642. (LPARAM)m_hWnd
  4643. );
  4644. }
  4645. }
  4646. }
  4647. break;
  4648. case WM_LBUTTONUP:
  4649. lResult = 0L;
  4650. return true;
  4651. } // switch( message )
  4652. return false;
  4653. }