ListCtrl.h
上传用户:sztopon
上传日期:2014-01-21
资源大小:55k
文件大小:111k
源码类别:

ListView/ListBox

开发平台:

Visual C++

  1. /////////////////////////////////////////////////////////////////////////////
  2. // 
  3. // CListCtrl - A WTL list control with Windows Vista style item selection.
  4. //
  5. // Revision:      1.5
  6. // Last modified: 9th April 2006
  7. //
  8. /////////////////////////////////////////////////////////////////////////////
  9. #pragma once
  10. #include <set>
  11. #include <algorithm>
  12. #include <atltheme.h>
  13. #include <atlctrlx.h>
  14. #include "DragDrop.h"
  15. #include "DropArrows.h"
  16. #include "TitleTip.h"
  17. #include "ListEdit.h"
  18. #include "ListCombo.h"
  19. #include "ListDate.h"
  20. using namespace std;
  21. struct CListColumn
  22. {
  23. CString m_strText;
  24. int m_nWidth;
  25. BOOL m_bFixed;
  26. UINT m_nFormat;
  27. UINT m_nFlags;
  28. int m_nImage;
  29. int m_nIndex;
  30. CListArray < CString > m_aComboList;
  31. };
  32. template < class T >
  33. class CListImpl : public CWindowImpl< CListImpl< T > >,
  34.   public CDoubleBufferImpl< CListImpl< T > >
  35. {
  36. public:
  37. CListImpl()
  38. {
  39. m_bShowHeader = TRUE;
  40. m_bShowThemed = TRUE;
  41. m_bSortAscending = TRUE;
  42. m_bButtonDown = FALSE;
  43. m_bMouseOver = FALSE;
  44. m_bColumnSizing = FALSE;
  45. m_bBeginSelect = FALSE;
  46. m_bSingleSelect = FALSE;
  47. m_bFocusSubItem = FALSE;
  48. m_bGroupSelect = FALSE;
  49. m_bEnableHorizScroll = FALSE;
  50. m_bEnableVertScroll = FALSE;
  51. m_bShowHorizScroll = TRUE;
  52. m_bShowVertScroll = TRUE;
  53. m_bShowSort = TRUE;
  54. m_bResizeTimer = FALSE;
  55. m_bDragDrop = FALSE;
  56. m_bSmoothScroll = TRUE;
  57. m_bEditItem = FALSE;
  58. m_bScrolling = FALSE;
  59. m_bScrollDown = FALSE;
  60. m_bTileBackground = FALSE;
  61. m_nMouseWheelScroll = 3;
  62. m_nTotalWidth = 0;
  63. m_nHeaderHeight = 0;
  64. m_nItemHeight = 0;
  65. m_nFirstSelected = NULL_ITEM;
  66. m_nFocusItem = NULL_ITEM;
  67. m_nFocusSubItem = NULL_SUBITEM;
  68. m_nHotItem = NULL_ITEM;
  69. m_nHotSubItem = NULL_SUBITEM;
  70. m_nTitleTipItem = NULL_ITEM;
  71. m_nTitleTipSubItem = NULL_SUBITEM;
  72. m_nSortColumn = NULL_COLUMN;
  73. m_nHighlightColumn = NULL_COLUMN;
  74. m_nDragColumn = NULL_COLUMN;
  75. m_nHotColumn = NULL_COLUMN;
  76. m_nHotDivider = NULL_COLUMN;
  77. m_nColumnSizing = NULL_COLUMN;
  78. m_nScrollOffset = 0;
  79. m_nScrollDelta = 0;
  80. m_nScrollUnit = 0;
  81. m_nStartScrollPos = 0;
  82. m_nStartSize = 0;
  83. m_nStartPos = 0;
  84. m_ptDownPoint = 0;
  85. m_ptSelectPoint = 0;
  86. m_rcGroupSelect = 0;
  87. m_dwSearchTick = 0;
  88. m_dwScrollTick = 0;
  89. m_strSearchString = _T( "" );
  90. }
  91. ~CListImpl()
  92. {
  93. }
  94. protected:
  95. BOOL m_bShowHeader;
  96. BOOL m_bShowThemed;
  97. BOOL m_bShowSort;
  98. BOOL m_bSortAscending;
  99. BOOL m_bButtonDown;
  100. BOOL m_bMouseOver;
  101. BOOL m_bColumnSizing;
  102. BOOL m_bBeginSelect;
  103. BOOL m_bSingleSelect;
  104. BOOL m_bFocusSubItem;
  105. BOOL m_bGroupSelect;
  106. BOOL m_bShowHorizScroll;
  107. BOOL m_bShowVertScroll;
  108. BOOL m_bEnableHorizScroll;
  109. BOOL m_bEnableVertScroll;
  110. BOOL m_bResizeTimer;
  111. BOOL m_bDragDrop;
  112. BOOL m_bSmoothScroll;
  113. BOOL m_bEditItem;
  114. BOOL m_bScrolling;
  115. BOOL m_bScrollDown;
  116. BOOL m_bTileBackground;
  117. CPoint m_ptDownPoint;
  118. CPoint m_ptSelectPoint;
  119. CRect m_rcGroupSelect;
  120. int m_nItemHeight;
  121. int m_nHeaderHeight;
  122. int m_nFirstSelected;
  123. int m_nFocusItem;
  124. int m_nFocusSubItem;
  125. int m_nHotItem;
  126. int m_nHotSubItem;
  127. int m_nTitleTipItem;
  128. int m_nTitleTipSubItem;
  129. int m_nMouseWheelScroll;
  130. int m_nTotalWidth;
  131. int m_nSortColumn;
  132. int m_nDragColumn;
  133. int m_nHighlightColumn;
  134. int m_nHotColumn;
  135. int m_nHotDivider;
  136. int m_nColumnSizing;
  137. int m_nScrollOffset;
  138. int m_nScrollDelta;
  139. int m_nScrollUnit;
  140. int m_nStartScrollPos;
  141. int m_nStartSize;
  142. int m_nStartPos;
  143. DWORD m_dwSearchTick;
  144. DWORD m_dwScrollTick;
  145. CString m_strSearchString;
  146. CBitmap m_bmpScrollList;
  147. CBitmap m_bmpBackground;
  148. UINT m_nHeaderClipboardFormat;
  149. COLORREF m_rgbBackground;
  150. COLORREF m_rgbHeaderBackground;
  151. COLORREF m_rgbHeaderBorder;
  152. COLORREF m_rgbHeaderShadow;
  153. COLORREF m_rgbHeaderText;
  154. COLORREF m_rgbHeaderHighlight;
  155. COLORREF m_rgbSelectedItem;
  156. COLORREF m_rgbSelectedText;
  157. COLORREF m_rgbItemText;
  158. COLORREF m_rgbSelectOuter;
  159. COLORREF m_rgbSelectInner;
  160. COLORREF m_rgbSelectTop;
  161. COLORREF m_rgbSelectBottom;
  162. COLORREF m_rgbNoFocusTop;
  163. COLORREF m_rgbNoFocusBottom;
  164. COLORREF m_rgbNoFocusOuter;
  165. COLORREF m_rgbNoFocusInner;
  166. COLORREF m_rgbFocusTop;
  167. COLORREF m_rgbFocusBottom;
  168. COLORREF m_rgbProgressTop;
  169. COLORREF m_rgbProgressBottom;
  170. COLORREF m_rgbItemFocus;
  171. COLORREF m_rgbHyperLink;
  172. CTheme m_thmHeader;
  173. CTheme m_thmProgress;
  174. CCursor m_curDivider;
  175. CCursor m_curHyperLink;
  176. CFont m_fntListFont;
  177. CFont m_fntUnderlineFont;
  178. CImageList m_ilListItems;
  179. CImageList m_ilItemImages;
  180. CDragDrop < CListImpl > m_oleDragDrop;
  181. CToolTipCtrl m_ttToolTip;
  182. CDropArrows m_wndDropArrows;
  183. CTitleTip m_wndTitleTip;
  184. CListEdit m_wndItemEdit;
  185. CListCombo m_wndItemCombo;
  186. CListDate m_wndItemDate;
  187. CListArray < CListColumn > m_aColumns;
  188. set < int > m_setSelectedItems;
  189. public:
  190. BOOL SubclassWindow( HWND hWnd )
  191. {
  192. T* pT = static_cast<T*>(this);
  193. return CWindowImpl< CListImpl >::SubclassWindow( hWnd ) ? pT->Initialise() : FALSE;
  194. }
  195. void RegisterClass()
  196. {
  197. T* pT = static_cast<T*>(this);
  198. pT->GetWndClassInfo().m_wc.lpfnWndProc = m_pfnSuperWindowProc;
  199. pT->GetWndClassInfo().Register( &m_pfnSuperWindowProc );
  200. }
  201. BOOL Initialise()
  202. {
  203. // load list images
  204. if ( !m_ilListItems.CreateFromImage( IDB_LISTITEMS, 16, 0, RGB( 255, 0, 255 ), IMAGE_BITMAP, LR_CREATEDIBSECTION ) )
  205. return FALSE;
  206. if ( m_curDivider.LoadCursor( IDC_DIVIDER ) == NULL )
  207. return FALSE;
  208. if ( m_curHyperLink.LoadCursor( IDC_HYPERLINK ) == NULL )
  209. return FALSE;
  210. // load interface settings
  211. if ( !LoadSettings() )
  212. return FALSE;
  213. // give control a static border
  214. ModifyStyle( WS_BORDER, WS_CLIPCHILDREN );
  215. ModifyStyleEx( WS_EX_CLIENTEDGE, WS_EX_STATICEDGE, SWP_FRAMECHANGED );
  216. // register drag drop
  217. m_oleDragDrop.Register( this );
  218. m_oleDragDrop.AddTargetFormat( m_nHeaderClipboardFormat );
  219. m_oleDragDrop.AddSourceFormat( m_nHeaderClipboardFormat );
  220. // create the tooltip
  221. if ( !m_ttToolTip.Create( m_hWnd ) )
  222. return FALSE;
  223. m_ttToolTip.SetMaxTipWidth( SHRT_MAX );
  224. return TRUE;
  225. }
  226. BOOL LoadSettings()
  227. {
  228. m_rgbBackground = GetSysColor( COLOR_WINDOW );
  229. m_rgbHeaderBackground = GetSysColor( COLOR_BTNFACE );
  230. m_rgbHeaderBorder = GetSysColor( COLOR_3DHIGHLIGHT );
  231. m_rgbHeaderShadow = GetSysColor( COLOR_3DSHADOW );
  232. m_rgbHeaderText = GetSysColor( COLOR_WINDOWTEXT );
  233. m_rgbHeaderHighlight = RGB( 130, 140, 180 );
  234. m_rgbSelectedItem = GetSysColor( COLOR_HIGHLIGHT );
  235. m_rgbSelectedText = GetSysColor( COLOR_HIGHLIGHTTEXT );
  236. m_rgbItemText = GetSysColor( COLOR_WINDOWTEXT );
  237. m_rgbSelectOuter = RGB( 170, 200, 245 );
  238. m_rgbSelectInner = RGB( 230, 250, 250 );
  239. m_rgbSelectTop = RGB( 210, 240, 250 );
  240. m_rgbSelectBottom = RGB( 185, 215, 250 );
  241. m_rgbNoFocusTop = RGB( 250, 250, 250 );
  242. m_rgbNoFocusBottom = RGB( 235, 235, 235 );
  243. m_rgbNoFocusOuter = RGB( 220, 220, 220 );
  244. m_rgbNoFocusInner = RGB( 245, 245, 245 );
  245. m_rgbFocusTop = RGB( 235, 245, 245 );
  246. m_rgbFocusBottom = RGB( 225, 235, 245 );
  247. m_rgbProgressTop = RGB( 170, 240, 170 );
  248. m_rgbProgressBottom = RGB( 45, 210, 50 );
  249. m_rgbItemFocus = RGB( 180, 190, 210 );
  250. m_rgbHyperLink = RGB( 0, 0, 200 );
  251. m_nHeaderClipboardFormat = RegisterClipboardFormat( _T( "HEADERCLIPBOARDFORMAT" ) );
  252. // get number of lines to scroll
  253. SystemParametersInfo( SPI_GETWHEELSCROLLLINES, 0, &m_nMouseWheelScroll, 0 );
  254. // get system message font
  255. CLogFont logFont;
  256. logFont.SetMessageBoxFont();
  257. if ( !m_fntListFont.IsNull() )
  258. m_fntListFont.DeleteObject();
  259. if ( m_fntListFont.CreateFontIndirect( &logFont ) == NULL )
  260. return FALSE;
  261. // get system underline font
  262. logFont.lfUnderline = BYTE(TRUE);
  263. if ( !m_fntUnderlineFont.IsNull() )
  264. m_fntUnderlineFont.DeleteObject();
  265. if ( m_fntUnderlineFont.CreateFontIndirect( &logFont ) == NULL )
  266. return FALSE;
  267. CClientDC dcClient( m_hWnd );
  268. HFONT hOldFont = dcClient.SelectFont( m_fntListFont );
  269. CSize sizeExtent;
  270. if ( !dcClient.GetTextExtent( _T( "Height" ), -1, &sizeExtent ) )
  271. return FALSE;
  272. dcClient.SelectFont( hOldFont );
  273. // has system font changed
  274. if ( m_nItemHeight != sizeExtent.cy + ITEM_HEIGHT_MARGIN )
  275. {
  276. m_nItemHeight = sizeExtent.cy + ITEM_HEIGHT_MARGIN;
  277. m_nHeaderHeight = m_nItemHeight;
  278. // create drop arrows window
  279. if ( m_wndDropArrows.IsWindow() )
  280. m_wndDropArrows.DestroyWindow();
  281. if ( !m_wndDropArrows.Create( m_hWnd, m_nHeaderHeight, TRUE ) )
  282. return FALSE;
  283. }
  284. // open header theme
  285. if ( !m_thmHeader.IsThemeNull() )
  286. m_thmHeader.CloseThemeData();
  287. m_thmHeader.OpenThemeData( m_hWnd, L"HEADER" );
  288. // open progress theme
  289. if ( !m_thmProgress.IsThemeNull() )
  290. m_thmProgress.CloseThemeData();
  291. m_thmProgress.OpenThemeData( m_hWnd, L"PROGRESS" );
  292. // create titletip window
  293. if ( m_wndTitleTip.IsWindow() )
  294. m_wndTitleTip.DestroyWindow();
  295. if ( !m_wndTitleTip.Create( m_hWnd, m_bShowThemed ) )
  296. return FALSE;
  297. return TRUE;
  298. }
  299. void ShowThemed( BOOL bShowThemed = TRUE )
  300. {
  301. m_bShowThemed = bShowThemed;
  302. LoadSettings();
  303. Invalidate();
  304. }
  305. void ShowHeader( BOOL bShowHeader = TRUE )
  306. {
  307. m_bShowHeader = bShowHeader;
  308. ResetScrollBars();
  309. Invalidate();
  310. }
  311. void ShowHeaderSort( BOOL bShowSort = TRUE )
  312. {
  313. m_bShowSort = bShowSort;
  314. Invalidate();
  315. }
  316. void SetSingleSelect( BOOL bSingleSelect = TRUE )
  317. {
  318. m_bSingleSelect = bSingleSelect;
  319. Invalidate();
  320. }
  321. void SetFocusSubItem( BOOL bFocusSubItem = TRUE )
  322. {
  323. m_bFocusSubItem = bFocusSubItem;
  324. Invalidate();
  325. }
  326. void SetDragDrop( BOOL bDragDrop = TRUE )
  327. {
  328. m_bDragDrop = bDragDrop;
  329. }
  330. void SetSmoothScroll( BOOL bSmoothScroll = TRUE )
  331. {
  332. m_bSmoothScroll = bSmoothScroll;
  333. }
  334. void SetBackgroundImage( HBITMAP hBackgroundImage, BOOL bTileImage = FALSE )
  335. {
  336. m_bmpBackground = hBackgroundImage;
  337. m_bTileBackground = bTileImage;
  338. }
  339. void SetImageList( CImageList& ilItemImages )
  340. {
  341. m_ilItemImages = ilItemImages;
  342. }
  343. UINT ValidateFlags( UINT nFlags )
  344. {
  345. if ( nFlags & ITEM_FLAGS_CENTRE )
  346. nFlags &= ~( ITEM_FLAGS_LEFT | ITEM_FLAGS_RIGHT );
  347. if ( nFlags & ITEM_FLAGS_RIGHT )
  348. nFlags &= ~ITEM_FLAGS_LEFT;
  349. if ( nFlags & ITEM_FLAGS_DATE_ONLY )
  350. nFlags &= ~ITEM_FLAGS_TIME_ONLY;
  351. if ( nFlags & ( ITEM_FLAGS_EDIT_NUMBER | ITEM_FLAGS_EDIT_FLOAT ) )
  352. nFlags &= ~ITEM_FLAGS_EDIT_UPPER;
  353. if ( !( nFlags & ( ITEM_FLAGS_EDIT_NUMBER | ITEM_FLAGS_EDIT_FLOAT ) ) )
  354. nFlags &= ~( ITEM_FLAGS_EDIT_NEGATIVE | ITEM_FLAGS_EDIT_OPERATOR );
  355. if ( nFlags & ITEM_FLAGS_COMBO_EDIT )
  356. nFlags &= ~( ITEM_FLAGS_DATE_ONLY | ITEM_FLAGS_TIME_ONLY | ITEM_FLAGS_DATETIME_NONE );
  357. return nFlags;
  358. }
  359. void AddColumn( CListColumn& listColumn )
  360. {
  361. // minimum column width
  362. if ( listColumn.m_strText.IsEmpty() && listColumn.m_nImage != ITEM_IMAGE_NONE )
  363. {
  364. CSize sizeIcon;
  365. m_ilListItems.GetIconSize( sizeIcon );
  366. listColumn.m_nWidth = sizeIcon.cx + 5;
  367. listColumn.m_nFlags |= ITEM_FLAGS_CENTRE;
  368. }
  369. // correct incompatible flag mask values
  370. listColumn.m_nFlags = ValidateFlags( listColumn.m_nFlags );
  371. // initial data index
  372. listColumn.m_nIndex = GetColumnCount();
  373. m_aColumns.Add( listColumn );
  374. ResetScrollBars();
  375. Invalidate();
  376. }
  377. void AddColumn( LPCTSTR lpszText, int nWidth = 0, int nImage = ITEM_IMAGE_NONE, BOOL bFixed = FALSE, UINT nFormat = ITEM_FORMAT_NONE, UINT nFlags = ITEM_FLAGS_NONE )
  378. {
  379. CListColumn listColumn;
  380. listColumn.m_strText = lpszText;
  381. listColumn.m_nWidth = nWidth;
  382. listColumn.m_bFixed = bFixed;
  383. listColumn.m_nFormat = nFormat;
  384. listColumn.m_nFlags = nFlags;
  385. listColumn.m_nImage = nImage;
  386. AddColumn( listColumn );
  387. }
  388. int GetColumnCount()
  389. {
  390. return m_aColumns.GetSize();
  391. }
  392. BOOL GetColumn( int nColumn, CListColumn& listColumn )
  393. {
  394. if ( nColumn < 0 || nColumn >= GetColumnCount() ) 
  395. return FALSE;
  396. listColumn = m_aColumns[ nColumn ];
  397. return TRUE;
  398. }
  399. int GetTotalWidth( BOOL bRecalc = FALSE )
  400. {
  401. if ( bRecalc )
  402. {
  403. m_nTotalWidth = 0;
  404. for ( int nColumn = 0; nColumn < GetColumnCount(); nColumn++ )
  405. m_nTotalWidth += GetColumnWidth( nColumn );
  406. }
  407. return m_nTotalWidth - 1;
  408. }
  409. int GetTotalHeight()
  410. {
  411. T* pT = static_cast<T*>(this);
  412. return max( ( pT->GetItemCount() * m_nItemHeight ) + ( m_bShowHeader ? m_nHeaderHeight : 0 ), 1 );
  413. }
  414. BOOL SetColumnWidth( int nColumn, int nWidth )
  415. {
  416. if ( nColumn < 0 || nColumn >= GetColumnCount() ) 
  417. return FALSE;
  418. // set new column size if not fixed
  419. if ( !m_aColumns[ nColumn ].m_bFixed )
  420. {
  421. m_aColumns[ nColumn ].m_nWidth = nWidth;
  422. ResetScrollBars();
  423. Invalidate();
  424. }
  425. return TRUE;
  426. }
  427. int GetColumnWidth( int nColumn )
  428. {
  429. CListColumn listColumn;
  430. return GetColumn( nColumn, listColumn ) ? listColumn.m_nWidth : 0;
  431. }
  432. int GetColumnIndex( int nColumn )
  433. {
  434. CListColumn listColumn;
  435. return GetColumn( nColumn, listColumn ) ? listColumn.m_nIndex : 0;
  436. }
  437. int IndexToOrder( int nIndex )
  438. {
  439. for ( int nColumn = 0; nColumn < GetColumnCount(); nColumn++ )
  440. {
  441. if ( GetColumnIndex( nColumn ) == nIndex )
  442. return nColumn;
  443. }
  444. return -1;
  445. }
  446. BOOL SetColumnFormat( int nColumn, UINT nFormat, UINT nFlags = ITEM_FLAGS_NONE )
  447. {
  448. if ( nColumn < 0 || nColumn >= GetColumnCount() ) 
  449. return FALSE;
  450. m_aColumns[ nColumn ].m_nFormat = nFormat;
  451. m_aColumns[ nColumn ].m_nFlags = ValidateFlags( nFlags );
  452. return TRUE;
  453. }
  454. BOOL SetColumnFormat( int nColumn, UINT nFormat, UINT nFlags, CListArray < CString >& aComboList )
  455. {
  456. if ( nColumn < 0 || nColumn >= GetColumnCount() ) 
  457. return FALSE;
  458. m_aColumns[ nColumn ].m_nFormat = nFormat;
  459. m_aColumns[ nColumn ].m_nFlags = ValidateFlags( nFlags );
  460. m_aColumns[ nColumn ].m_aComboList = aComboList;
  461. return TRUE;
  462. }
  463. UINT GetColumnFormat( int nColumn )
  464. {
  465. CListColumn listColumn;
  466. return GetColumn( nColumn, listColumn ) ? listColumn.m_nFormat : ITEM_FORMAT_NONE;
  467. }
  468. UINT GetColumnFlags( int nColumn )
  469. {
  470. CListColumn listColumn;
  471. return GetColumn( nColumn, listColumn ) ? listColumn.m_nFlags : ITEM_FLAGS_NONE;
  472. }
  473. BOOL GetColumnComboList( int nColumn, CListArray < CString >& aComboList )
  474. {
  475. CListColumn listColumn;
  476. if ( !GetColumn( nColumn, listColumn ) )
  477. return FALSE;
  478. aComboList = listColumn.m_aComboList;
  479. return !aComboList.IsEmpty();
  480. }
  481. BOOL GetColumnRect( int nColumn, CRect& rcColumn )
  482. {
  483. if ( nColumn < 0 || nColumn >= GetColumnCount() ) 
  484. return FALSE;
  485. GetClientRect( rcColumn );
  486. rcColumn.bottom = m_nHeaderHeight;
  487. for ( int nColumnOrder = 0; nColumnOrder < GetColumnCount(); nColumnOrder++ )
  488. {
  489. int nWidth = GetColumnWidth( nColumnOrder );
  490. if ( nColumn == nColumnOrder )
  491. {
  492. rcColumn.right = rcColumn.left + nWidth;
  493. break;
  494. }
  495. rcColumn.left += nWidth;
  496. }
  497. // offset column by scroll position
  498. rcColumn.OffsetRect( -GetScrollPos( SB_HORZ ), 0 );
  499. return TRUE;
  500. }
  501. BOOL AddItem()
  502. {
  503. ResetScrollBars();
  504. return Invalidate();
  505. }
  506. BOOL DeleteItem( int nItem )
  507. {
  508. m_setSelectedItems.erase( nItem );
  509. ResetScrollBars();
  510. return Invalidate();
  511. }
  512. BOOL DeleteAllItems()
  513. {
  514. m_setSelectedItems.clear();
  515. ResetScrollBars();
  516. return Invalidate();
  517. }
  518. int GetItemCount()
  519. {
  520. ATLASSERT( FALSE ); // must be implemented in a derived class
  521. return 0;
  522. }
  523. CString GetItemText( int nItem, int nSubItem )
  524. {
  525. ATLASSERT( FALSE ); // must be implemented in a derived class
  526. return _T( "" );
  527. }
  528. BOOL GetItemDate( int nItem, int nSubItem, SYSTEMTIME& stItemDate )
  529. {
  530. T* pT = static_cast<T*>(this);
  531. ZeroMemory( &stItemDate, sizeof( SYSTEMTIME ) );
  532. CString strItemText = pT->GetItemText( nItem, nSubItem );
  533. if ( strItemText.IsEmpty() )
  534. return FALSE;
  535. // get date-time from item text: yyyymmddhhmmss
  536. stItemDate.wYear = _ttoi( strItemText.Left( 4 ) );
  537. stItemDate.wMonth = _ttoi( strItemText.Mid( 4, 2 ) );
  538. stItemDate.wDay = _ttoi( strItemText.Mid( 6, 2 ) );
  539. stItemDate.wHour = _ttoi( strItemText.Mid( 8, 2 ) );
  540. stItemDate.wMinute = _ttoi( strItemText.Mid( 10, 2 ) );
  541. stItemDate.wSecond = _ttoi( strItemText.Mid( 12, 2 ) );
  542. stItemDate.wMilliseconds = 0;
  543. return TRUE;
  544. }
  545. int GetItemImage( int nItem, int nSubItem )
  546. {
  547. return ITEM_IMAGE_NONE; // may be implemented in a derived class
  548. }
  549. UINT GetItemFormat( int nItem, int nSubItem )
  550. {
  551. return GetColumnFormat( IndexToOrder( nSubItem ) ); // may be implemented in a derived class
  552. }
  553. UINT GetItemFlags( int nItem, int nSubItem )
  554. {
  555. return GetColumnFlags( IndexToOrder( nSubItem ) ); // may be implemented in a derived class
  556. }
  557. BOOL GetItemComboList( int nItem, int nSubItem, CListArray < CString >& aComboList )
  558. {
  559. return GetColumnComboList( IndexToOrder( nSubItem ), aComboList ); // may be implemented in a derived class
  560. }
  561. HFONT GetItemFont( int nItem, int nSubItem )
  562. {
  563. return m_fntListFont; // may be implemented in a derived class
  564. }
  565. BOOL GetItemColours( int nItem, int nSubItem, COLORREF& rgbBackground, COLORREF& rgbText )
  566. {
  567. rgbBackground = m_rgbBackground;
  568. rgbText = m_rgbItemText;
  569. return TRUE;
  570. }
  571. CString GetItemToolTip( int nItem, int nSubItem )
  572. {
  573. return _T( "" ); // may be implemented in a derived class
  574. }
  575. BOOL SetItemText( int nItem, int nSubItem, LPCTSTR lpszText )
  576. {
  577. ATLASSERT( FALSE ); // must be implemented in a derived class
  578. return FALSE;
  579. }
  580. BOOL SetItemComboIndex( int nItem, int nSubItem, int nIndex )
  581. {
  582. ATLASSERT( FALSE ); // must be implemented in a derived class
  583. return FALSE;
  584. }
  585. BOOL SetItemDate( int nItem, int nSubItem, SYSTEMTIME& stItemDate )
  586. {
  587. T* pT = static_cast<T*>(this);
  588. // set date-time in format (yyyymmddhhmmss)
  589. CString strFormatDate;
  590. strFormatDate.Format( _T( "%04d%02d%02d%02d%02d%02d" ), stItemDate.wYear, stItemDate.wMonth, stItemDate.wDay, stItemDate.wHour, stItemDate.wMinute, stItemDate.wSecond );
  591. return pT->SetItemText( nItem, nSubItem, strFormatDate );
  592. }
  593. BOOL SetItemCheck( int nItem, int nSubItem, int nCheckValue )
  594. {
  595. T* pT = static_cast<T*>(this);
  596. switch ( pT->GetItemFormat( nItem, nSubItem ) )
  597. {
  598. case ITEM_FORMAT_CHECKBOX: return pT->SetItemText( nItem, nSubItem, nCheckValue > 0 ? _T( "1" ) : _T( "0" ) );
  599. case ITEM_FORMAT_CHECKBOX_3STATE: if ( nCheckValue < 0 )
  600. return pT->SetItemText( nItem, nSubItem, _T( "-1" ) );
  601. if ( nCheckValue > 0 )
  602. return pT->SetItemText( nItem, nSubItem, _T( "1" ) );
  603. return pT->SetItemText( nItem, nSubItem, _T( "0" ) );
  604. }
  605. return FALSE;
  606. }
  607. BOOL SetItemImage( int nItem, int nSubItem, int nImage )
  608. {
  609. ATLASSERT( FALSE ); // must be implemented in a derived class
  610. return FALSE;
  611. }
  612. BOOL SetItemFormat( int nItem, int nSubItem, UINT nFormat, UINT nFlags = ITEM_FLAGS_NONE )
  613. {
  614. ATLASSERT( FALSE ); // must be implemented in a derived class
  615. return FALSE;
  616. }
  617. BOOL SetItemFormat( int nItem, int nSubItem, UINT nFormat, UINT nFlags, CListArray < CString >& aComboList )
  618. {
  619. ATLASSERT( FALSE ); // must be implemented in a derived class
  620. return FALSE;
  621. }
  622. BOOL SetItemFont( int nItem, int nSubItem, HFONT hFont )
  623. {
  624. ATLASSERT( FALSE ); // must be implemented in a derived class
  625. return FALSE;
  626. }
  627. BOOL SetItemColours( int nItem, int nSubItem, COLORREF rgbBackground, COLORREF rgbText )
  628. {
  629. ATLASSERT( FALSE ); // must be implemented in a derived class
  630. return FALSE;
  631. }
  632. void ReverseItems()
  633. {
  634. ATLASSERT( FALSE ); // must be implemented in a derived class
  635. }
  636. void SortItems( int nColumn, BOOL bAscending )
  637. {
  638. ATLASSERT( FALSE ); // must be implemented in a derived class
  639. }
  640. BOOL GetItemRect( int nItem, int nSubItem, CRect& rcItem )
  641. {
  642. T* pT = static_cast<T*>(this);
  643. int nTopItem = GetTopItem();
  644. if ( nItem < nTopItem || nItem >= pT->GetItemCount() || nItem >= nTopItem + GetCountPerPage() )
  645. return FALSE;
  646. CRect rcClient;
  647. GetClientRect( rcClient );
  648. // calculate item rect based on scroll position
  649. rcItem = rcClient;
  650. rcItem.top = ( m_bShowHeader ? m_nHeaderHeight : 0 ) + ( ( nItem - nTopItem ) * m_nItemHeight );
  651. rcItem.bottom = rcItem.top + m_nItemHeight;
  652. rcItem.right = min( rcClient.right, GetTotalWidth() );
  653. if ( nSubItem != NULL_SUBITEM )
  654. {
  655. CRect rcColumn;
  656. if ( !GetColumnRect( nSubItem, rcColumn ) )
  657. return FALSE;
  658. rcItem.left = rcColumn.left;
  659. rcItem.right = rcColumn.right;
  660. }
  661. return TRUE;
  662. }
  663. BOOL GetItemRect( int nItem, CRect& rcItem )
  664. {
  665. return GetItemRect( nItem, NULL_SUBITEM, rcItem );
  666. }
  667. BOOL InvalidateItem( int nItem, int nSubItem = NULL_SUBITEM )
  668. {
  669. CRect rcItem;
  670. return GetItemRect( nItem, nSubItem, rcItem ) ? InvalidateRect( rcItem ) : FALSE;
  671. }
  672. BOOL InvalidateHeader()
  673. {
  674. if ( !m_bShowHeader )
  675. return TRUE;
  676. CRect rcHeader;
  677. if ( !GetClientRect( rcHeader ) )
  678. return FALSE;
  679. rcHeader.bottom = m_nHeaderHeight;
  680. return InvalidateRect( rcHeader );
  681. }
  682. int GetTopItem()
  683. {
  684. return (int)( GetScrollPos( SB_VERT ) / m_nItemHeight );
  685. }
  686. int GetCountPerPage( BOOL bPartial = TRUE )
  687. {
  688. CRect rcClient;
  689. GetClientRect( rcClient );
  690. rcClient.top = ( m_bShowHeader ? m_nHeaderHeight : 0 );
  691. // calculate number of items per control height (include partial item)
  692. div_t divHeight = div( rcClient.Height(), m_nItemHeight );
  693. // round up to nearest item count
  694. return max( bPartial && divHeight.rem > 0 ? divHeight.quot + 1 : divHeight.quot, 1 );
  695. }
  696. BOOL IsItemVisible( int nItem, int nSubItem = NULL_SUBITEM, BOOL bPartial = TRUE )
  697. {
  698. T* pT = static_cast<T*>(this);
  699. int nTopItem = GetTopItem();
  700. if ( nItem < nTopItem || nItem >= pT->GetItemCount() )
  701. return FALSE;
  702. // check whether item is visible
  703. if ( nItem < nTopItem || nItem >= nTopItem + GetCountPerPage( bPartial ) )
  704. return FALSE;
  705. // check whether subitem is visible
  706. if ( m_bFocusSubItem && nSubItem != NULL_SUBITEM )
  707. {
  708. CRect rcColumn;
  709. if ( !GetColumnRect( nSubItem, rcColumn ) )
  710. return FALSE;
  711. CRect rcClient;
  712. GetClientRect( rcClient );
  713. if ( rcColumn.left < rcClient.left || rcColumn.right > rcClient.right )
  714. return FALSE;
  715. }
  716. return TRUE;
  717. }
  718. BOOL EnsureItemVisible( int nItem, int nSubItem = NULL_SUBITEM )
  719. {
  720. if ( IsItemVisible( nItem, nSubItem, FALSE ) )
  721. return TRUE;
  722. HideTitleTip();
  723. CRect rcClient;
  724. GetClientRect( rcClient );
  725. rcClient.top = ( m_bShowHeader ? m_nHeaderHeight : 0 );
  726. CRect rcItem;
  727. rcItem.top = ( m_bShowHeader ? m_nHeaderHeight : 0 ) + ( ( nItem - GetTopItem() ) * m_nItemHeight );
  728. rcItem.bottom = rcItem.top + m_nItemHeight;
  729. if ( rcItem.top < rcClient.top || rcItem.bottom > rcClient.bottom )
  730. {
  731. int nScrollItem = NULL_ITEM;
  732. // scroll list up/down to include item
  733. if ( rcItem.top < rcClient.top || rcItem.Height() > rcClient.Height() )
  734. nScrollItem = nItem;
  735. else if ( rcItem.bottom > rcClient.bottom )
  736. nScrollItem = nItem - ( GetCountPerPage( FALSE ) - 1 );
  737. if ( nScrollItem != NULL_ITEM )
  738. SetScrollPos( SB_VERT, nScrollItem * m_nItemHeight );
  739. }
  740. if ( m_bFocusSubItem && nSubItem != NULL_SUBITEM )
  741. {
  742. CRect rcColumn;
  743. if ( !GetColumnRect( nSubItem, rcColumn ) )
  744. return FALSE;
  745. CRect rcClient;
  746. GetClientRect( rcClient );
  747. int nScrollPos = 0;
  748. // scroll list left/right to include subitem
  749. if ( rcColumn.Width() > rcClient.Width() || rcColumn.left < 0 )
  750. nScrollPos = rcColumn.left;
  751. else if ( rcColumn.right > rcClient.right )
  752. nScrollPos = rcColumn.right - rcClient.right;
  753. if ( nScrollPos != 0 )
  754. SetScrollPos( SB_HORZ, GetScrollPos( SB_HORZ ) + nScrollPos );
  755. }
  756. return Invalidate();
  757. }
  758. void ShowScrollBar( int nScrollBar, BOOL bShow = TRUE )
  759. {
  760. switch ( nScrollBar )
  761. {
  762. case SB_HORZ: m_bShowHorizScroll = bShow;
  763. break;
  764. case SB_VERT: m_bShowVertScroll = bShow;
  765. break;
  766. case SB_BOTH: m_bShowHorizScroll = bShow;
  767. m_bShowVertScroll = bShow;
  768. break;
  769. }
  770. ResetScrollBars();
  771. Invalidate();
  772. }
  773. void ResetScrollBars( int nScrollBar = SB_BOTH, int nScrollPos = -1, BOOL bRecalc = TRUE )
  774. {
  775. T* pT = static_cast<T*>(this);
  776. CRect rcClient;
  777. GetClientRect( rcClient );
  778. SCROLLINFO infoScroll;
  779. infoScroll.cbSize = sizeof( SCROLLINFO );
  780. infoScroll.fMask = nScrollPos < 0 ? SIF_PAGE | SIF_RANGE : SIF_PAGE | SIF_RANGE | SIF_POS;
  781. infoScroll.nPos = nScrollPos;
  782. infoScroll.nMin = 0;
  783. if ( ( nScrollBar == SB_BOTH || nScrollBar == SB_VERT ) && m_bShowVertScroll )
  784. {
  785. infoScroll.nMax = ( pT->GetItemCount() * m_nItemHeight ) + ( m_bShowHeader ? m_nHeaderHeight : 0 );
  786. infoScroll.nPage = rcClient.Height() - ( m_bShowHeader ? m_nHeaderHeight : 0 );
  787. // are we within client range?
  788. if ( (UINT)infoScroll.nMax <= infoScroll.nPage + ( m_bShowHeader ? m_nHeaderHeight : 0 ) )
  789. infoScroll.nMax = 0;
  790.     
  791. // set vertical scroll bar
  792. m_bEnableVertScroll = SetScrollInfo( SB_VERT, &infoScroll, TRUE ) ? ( infoScroll.nMax > 0 ) : FALSE;
  793. }
  794. if ( ( nScrollBar == SB_BOTH || nScrollBar == SB_HORZ ) && m_bShowHorizScroll )
  795. {
  796. infoScroll.nMax = GetTotalWidth( bRecalc );
  797. infoScroll.nPage = rcClient.Width();
  798. // are we within client range?
  799. if ( infoScroll.nPage >= (UINT)infoScroll.nMax )
  800. infoScroll.nMax = 0;
  801. // set horizontal scroll bar
  802. m_bEnableHorizScroll = SetScrollInfo( SB_HORZ, &infoScroll, TRUE ) ? ( infoScroll.nMax > (int)infoScroll.nPage ) : FALSE;
  803. }
  804. }
  805. BOOL IsScrollBarVisible( int nScrollBar )
  806. {
  807. switch ( nScrollBar )
  808. {
  809. case SB_HORZ: return m_bEnableHorizScroll;
  810. case SB_VERT: return m_bEnableVertScroll;
  811. case SB_BOTH: return ( m_bEnableHorizScroll && m_bEnableVertScroll );
  812. default: return FALSE;
  813. }
  814. }
  815. BOOL ResetSelected()
  816. {
  817. m_setSelectedItems.clear();
  818. m_nFocusItem = NULL_ITEM;
  819. m_nFocusSubItem = NULL_SUBITEM;
  820. m_nFirstSelected = NULL_ITEM;
  821. return Invalidate();
  822. }
  823. BOOL SelectItem( int nItem, int nSubItem = NULL_SUBITEM, UINT nFlags = 0 )
  824. {
  825. T* pT = static_cast<T*>(this);
  826. if ( nItem < 0 || nItem >= pT->GetItemCount() )
  827. return FALSE;
  828. BOOL bSelectItem = TRUE;
  829. BOOL bSelectRange = !m_bSingleSelect && ( nFlags & MK_SHIFT );
  830. BOOL bNewSelect = !( bSelectRange || ( nFlags & MK_CONTROL ) );
  831. BOOL bEnsureVisible = FALSE;
  832. // are we starting a new select sequence?
  833. if ( bNewSelect || bSelectRange )
  834. {
  835. // are we simply reselecting the same item?
  836. if ( m_setSelectedItems.size() == 1 && *m_setSelectedItems.begin() == nItem )
  837. {
  838. bSelectItem = FALSE;
  839. m_nFirstSelected = nItem;
  840. m_nFocusItem = nItem;
  841. m_nFocusSubItem = nSubItem;
  842. }
  843. else
  844. m_setSelectedItems.clear();
  845. }
  846. else // we adding to or removing from select sequence
  847. {
  848. if ( m_bSingleSelect )
  849. m_setSelectedItems.clear();
  850. set < int >::iterator posSelectedItem = m_setSelectedItems.find( nItem );
  851. // is this item already selected?
  852. if ( posSelectedItem != m_setSelectedItems.end() )
  853. {
  854. bSelectItem = FALSE;
  855. m_setSelectedItems.erase( posSelectedItem );
  856. m_nFirstSelected = nItem;
  857. m_nFocusItem = nItem;
  858. m_nFocusSubItem = m_setSelectedItems.size() > 1 ? NULL_SUBITEM : nSubItem;
  859. }
  860. }
  861. // are we adding this item to the select sequence?
  862. if ( bSelectItem )
  863. {
  864. bEnsureVisible = TRUE;
  865. if ( bSelectRange )
  866. {
  867. if ( m_nFirstSelected == NULL_ITEM )
  868. m_nFirstSelected = nItem;
  869. for ( int nSelectedItem = min( m_nFirstSelected, nItem ); nSelectedItem <= max( m_nFirstSelected, nItem ); nSelectedItem++ )
  870. m_setSelectedItems.insert( nSelectedItem );
  871. }
  872. else
  873. {
  874. m_nFirstSelected = nItem;
  875. m_setSelectedItems.insert( nItem );
  876. }
  877. m_nFocusItem = nItem;
  878. m_nFocusSubItem = m_setSelectedItems.size() > 1 ? NULL_SUBITEM : nSubItem;
  879. // notify parent of selected item
  880. NotifyParent( m_nFocusItem, m_nFocusSubItem, LCN_SELECTED );
  881. }
  882. // start visible timer (scrolls list to partially hidden item)
  883. if ( !IsItemVisible( nItem, m_setSelectedItems.size() > 1 ? NULL_SUBITEM : nSubItem, FALSE ) )
  884. SetTimer( ITEM_VISIBLE_TIMER, ITEM_VISIBLE_PERIOD );
  885. else if ( m_nFocusItem != NULL_ITEM && m_nFocusSubItem != NULL_SUBITEM )
  886. EditItem( m_nFocusItem, m_nFocusSubItem );
  887. return Invalidate();
  888. }
  889. BOOL IsSelected( int nItem )
  890. {
  891. set < int >::iterator posSelectedItem = m_setSelectedItems.find( nItem );
  892. return ( posSelectedItem != m_setSelectedItems.end() );
  893. }
  894. BOOL GetSelectedItems( CListArray < int >& aSelectedItems )
  895. {
  896. aSelectedItems.RemoveAll();
  897. for ( set < int >::iterator posSelectedItem = m_setSelectedItems.begin(); posSelectedItem != m_setSelectedItems.end(); ++posSelectedItem )
  898. aSelectedItems.Add( *posSelectedItem );
  899. return !aSelectedItems.IsEmpty();
  900. }
  901. BOOL SetFocusItem( int nItem, int nSubItem = NULL_SUBITEM )
  902. {
  903. m_nFocusItem = nItem;
  904. m_nFocusSubItem = nSubItem;
  905. return EnsureItemVisible( m_nFocusItem, m_nFocusSubItem );
  906. }
  907. BOOL GetFocusItem( int& nItem, int& nSubItem )
  908. {
  909. nItem = IsSelected( m_nFocusItem ) ? m_nFocusItem : ( m_setSelectedItems.empty() ? NULL_ITEM : *m_setSelectedItems.begin() );
  910. nSubItem = !m_bFocusSubItem || nItem == NULL_ITEM ? NULL_SUBITEM : m_nFocusSubItem;
  911. return ( nItem != NULL_ITEM );
  912. }
  913. int GetFocusItem()
  914. {
  915. return IsSelected( m_nFocusItem ) ? m_nFocusItem : ( m_setSelectedItems.empty() ? NULL_ITEM : *m_setSelectedItems.begin() );
  916. }
  917. BOOL HitTestHeader( CPoint point, int& nColumn, UINT& nFlags )
  918. {
  919. // reset hittest flags
  920. nFlags = HITTEST_FLAG_NONE;
  921. if ( !m_bShowHeader )
  922. return FALSE;
  923. CRect rcClient;
  924. if ( !GetClientRect( rcClient ) )
  925. return FALSE;
  926. // are we over the header?
  927. if ( point.y < rcClient.top || point.y > m_nHeaderHeight )
  928. return FALSE;
  929. int nDividerPos = 0;
  930. int nColumnCount = GetColumnCount();
  931. // get hit-test subitem
  932. for ( nColumn = 0; nColumn < nColumnCount; nColumn++ )
  933. {
  934. int nColumnWidth = GetColumnWidth( nColumn );
  935. nDividerPos += nColumnWidth;
  936. // offset divider position with current scroll position
  937. int nRelativePos = nDividerPos - GetScrollPos( SB_HORZ );
  938. // are we over the divider zone?
  939. if ( point.x >= nRelativePos - DRAG_HEADER_OFFSET - 1 && point.x <= nRelativePos + DRAG_HEADER_OFFSET )
  940. {
  941. nFlags |= HITTEST_FLAG_HEADER_DIVIDER;
  942. // are we to the left of the divider (or over last column divider)?
  943. if ( ( point.x >= nRelativePos - DRAG_HEADER_OFFSET - 1 && point.x < nRelativePos ) || nColumn + 1 >= nColumnCount - 1 )
  944. {
  945. nFlags |= HITTEST_FLAG_HEADER_LEFT;
  946. return TRUE;
  947. }
  948. // find last zero-length column after this column
  949. for ( int nNextColumn = nColumn + 1; nNextColumn < nColumnCount; nNextColumn++ )
  950. {
  951. if ( GetColumnWidth( nNextColumn ) > 0 )
  952. break;
  953. nColumn = nNextColumn;
  954. }
  955. nFlags |= HITTEST_FLAG_HEADER_RIGHT;
  956. return TRUE;
  957. }
  958. // are we over a column?
  959. if ( point.x > nRelativePos - nColumnWidth && point.x < nRelativePos )
  960. return TRUE;
  961. }
  962. return FALSE;
  963. }
  964. BOOL HitTest( CPoint point, int& nItem, int& nSubItem )
  965. {
  966. T* pT = static_cast<T*>(this);
  967. // are we over the header?
  968. if ( point.y < ( m_bShowHeader ? m_nHeaderHeight : 0 ) )
  969. return FALSE;
  970. // calculate hit test item
  971. nItem = GetTopItem() + (int)( ( point.y - ( m_bShowHeader ? m_nHeaderHeight : 0 ) ) / m_nItemHeight );
  972. if ( nItem < 0 || nItem >= pT->GetItemCount() )
  973. return FALSE;
  974. int nTotalWidth = 0;
  975. int nColumnCount = GetColumnCount();
  976. // get hit-test subitem
  977. for ( nSubItem = 0; nSubItem < nColumnCount; nSubItem++ )
  978. {
  979. int nColumnWidth = GetColumnWidth( nSubItem );
  980. nTotalWidth += nColumnWidth;
  981. // offset position with current scroll position
  982. int nRelativePos = nTotalWidth - GetScrollPos( SB_HORZ );
  983. // are we over a subitem?
  984. if ( point.x > nRelativePos - nColumnWidth && point.x < nRelativePos )
  985. return TRUE;
  986. }
  987. return FALSE;
  988. }
  989. BOOL AutoSizeColumn( int nColumn )
  990. {
  991. T* pT = static_cast<T*>(this);
  992. CListColumn listColumn;
  993. if ( !GetColumn( nColumn, listColumn ) || listColumn.m_bFixed )
  994. return FALSE;
  995. CClientDC dcClient( m_hWnd );
  996. HFONT hOldFont = dcClient.SelectFont( m_fntListFont );
  997. // set to column text width if zero-length
  998. CSize sizeExtent;
  999. if ( !dcClient.GetTextExtent( listColumn.m_strText, -1, &sizeExtent ) )
  1000. return FALSE;
  1001. int nMaxWidth = sizeExtent.cx + ITEM_WIDTH_MARGIN;
  1002. CSize sizeIcon = 0;
  1003. if ( !m_ilItemImages.IsNull() )
  1004. m_ilItemImages.GetIconSize( sizeIcon );
  1005. // calculate maximum column width required
  1006. for ( int nItem = 0; nItem < pT->GetItemCount(); nItem++ )
  1007. {
  1008. if ( !dcClient.GetTextExtent( pT->GetItemText( nItem, listColumn.m_nIndex ), -1, &sizeExtent ) )
  1009. return FALSE;
  1010. if ( !m_ilItemImages.IsNull() && pT->GetItemImage( nItem, listColumn.m_nIndex ) != ITEM_IMAGE_NONE )
  1011. sizeExtent.cx += sizeIcon.cx;
  1012. nMaxWidth = max( nMaxWidth, (int)sizeExtent.cx + ITEM_WIDTH_MARGIN );
  1013. }
  1014. dcClient.SelectFont( hOldFont );
  1015. return SetColumnWidth( nColumn, nMaxWidth );
  1016. }
  1017. void ResizeColumn( BOOL bColumnScroll = FALSE )
  1018. {
  1019. HideTitleTip();
  1020. int nCurrentPos = GET_X_LPARAM( GetMessagePos() );
  1021. CRect rcClient;
  1022. GetClientRect( rcClient );
  1023. int nScrollLimit = GetTotalWidth() - rcClient.Width();
  1024. if ( bColumnScroll )
  1025. {
  1026. // have we finished scrolling list to accommodate new column size?
  1027. if ( !m_bColumnSizing || !m_bEnableHorizScroll || nCurrentPos - m_nStartScrollPos > 0 )
  1028. {
  1029. KillTimer( RESIZE_COLUMN_TIMER );
  1030. // reset resize start point
  1031. m_nStartPos = nCurrentPos;
  1032. m_bResizeTimer = FALSE;
  1033. }
  1034. else if ( nCurrentPos < m_nStartPos && GetScrollPos( SB_HORZ ) >= nScrollLimit )
  1035. {
  1036. // reset start column size
  1037. m_nStartSize = max( GetColumnWidth( m_nColumnSizing ) + ( nCurrentPos - m_nStartScrollPos ), 0 );
  1038. // resize column
  1039. SetColumnWidth( m_nColumnSizing, m_nStartSize );
  1040. }
  1041. }
  1042. else
  1043. {
  1044. int nColumnSize = max( m_nStartSize + ( nCurrentPos - m_nStartPos ), 0 );
  1045. // are we scrolled fully to the right and wanting to reduce the size of a column?
  1046. if ( m_bEnableHorizScroll && GetScrollPos( SB_HORZ ) >= nScrollLimit && nColumnSize < GetColumnWidth( m_nColumnSizing ) )
  1047. {
  1048. if ( !m_bResizeTimer )
  1049. {
  1050. // only start the scroll timer once
  1051. m_bResizeTimer = TRUE;
  1052. // set new start scroll position
  1053. m_nStartScrollPos = nCurrentPos;
  1054. // start column resize / scroll timer
  1055. SetTimer( RESIZE_COLUMN_TIMER, RESIZE_COLUMN_PERIOD );
  1056. }
  1057. }
  1058. else
  1059. {
  1060. // resizing is done in scroll timer (if started)
  1061. if ( !m_bResizeTimer )
  1062. SetColumnWidth( m_nColumnSizing, nColumnSize );
  1063. }
  1064. }
  1065. }
  1066. void DragColumn()
  1067. {
  1068. HideTitleTip();
  1069. CRect rcColumn;
  1070. if ( !GetColumnRect( m_nHighlightColumn, rcColumn ) )
  1071. return;
  1072. CRect rcHeaderItem( rcColumn );
  1073. rcHeaderItem.MoveToXY( 0, 0 );
  1074. CListColumn listColumn;
  1075. if ( !GetColumn( m_nHighlightColumn, listColumn ) )
  1076. return;
  1077. // store drag column
  1078. m_nDragColumn = m_nHighlightColumn;
  1079. CClientDC dcClient( m_hWnd );
  1080. CDC dcHeader;
  1081. dcHeader.CreateCompatibleDC( dcClient );
  1082. int nContextState = dcHeader.SaveDC();
  1083. // create drag header bitmap
  1084. CBitmapHandle bmpHeader;
  1085. bmpHeader.CreateCompatibleBitmap( dcClient, rcHeaderItem.Width(), rcHeaderItem.Height() );
  1086. dcHeader.SelectBitmap( bmpHeader );
  1087. if ( m_bShowThemed && !m_thmHeader.IsThemeNull() )
  1088. m_thmHeader.DrawThemeBackground( dcHeader, HP_HEADERITEM, HIS_PRESSED, rcHeaderItem, NULL );
  1089. else
  1090. {
  1091. dcHeader.SetBkColor( m_rgbHeaderBackground );
  1092. dcHeader.ExtTextOut( rcHeaderItem.left, rcHeaderItem.top, ETO_OPAQUE, rcHeaderItem, _T( "" ), 0, NULL );
  1093. dcHeader.Draw3dRect( rcHeaderItem, m_rgbHeaderBorder, m_rgbHeaderShadow );
  1094. }
  1095. CRect rcHeaderText( rcHeaderItem );
  1096. rcHeaderText.left += m_nHighlightColumn == 0 ? 4 : 3;
  1097. rcHeaderText.OffsetRect( 0, 1 );
  1098. // margin header text
  1099. rcHeaderText.DeflateRect( 4, 0, 5, 0 );
  1100. // has this header item an associated image?
  1101. if ( listColumn.m_nImage != ITEM_IMAGE_NONE )
  1102. {
  1103. CSize sizeIcon;
  1104. m_ilListItems.GetIconSize( sizeIcon );
  1105. CRect rcHeaderImage;
  1106. rcHeaderImage.left = listColumn.m_strText.IsEmpty() ? ( ( rcHeaderText.left + rcHeaderText.right ) / 2 ) - ( sizeIcon.cx / 2 ) - ( ( !m_bShowThemed || m_thmHeader.IsThemeNull() ) ? 0 : 1 ) : rcHeaderText.left;
  1107. rcHeaderImage.right = min( rcHeaderImage.left + sizeIcon.cx, rcHeaderItem.right );
  1108. rcHeaderImage.top = ( ( rcHeaderItem.top + rcHeaderItem.bottom ) / 2 ) - ( sizeIcon.cy / 2 );
  1109. rcHeaderImage.bottom = min( rcHeaderImage.top + sizeIcon.cy, rcHeaderItem.bottom );
  1110. m_ilListItems.DrawEx( listColumn.m_nImage, dcHeader, rcHeaderImage, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT );
  1111. // offset header text (for image)
  1112. rcHeaderText.left += sizeIcon.cx + 4;
  1113. }
  1114. dcHeader.SelectFont( m_fntListFont );
  1115. dcHeader.SetTextColor( m_rgbHeaderText );
  1116. dcHeader.SetBkMode( TRANSPARENT );
  1117. UINT nFormat = DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_END_ELLIPSIS;
  1118. if ( listColumn.m_nFlags & ITEM_FLAGS_CENTRE )
  1119. nFormat |= DT_CENTER;
  1120. else if ( listColumn.m_nFlags & ITEM_FLAGS_RIGHT )
  1121. nFormat |= DT_RIGHT;
  1122. else
  1123. nFormat |= DT_LEFT;
  1124. // draw header text
  1125. if ( !listColumn.m_strText.IsEmpty() )
  1126. dcHeader.DrawText( listColumn.m_strText, listColumn.m_strText.GetLength(), rcHeaderText, nFormat );
  1127. dcHeader.RestoreDC( nContextState );
  1128. SHDRAGIMAGE shDragImage;
  1129. ZeroMemory( &shDragImage, sizeof( SHDRAGIMAGE ) );
  1130. shDragImage.sizeDragImage.cx = rcHeaderItem.Width();
  1131. shDragImage.sizeDragImage.cy = rcHeaderItem.Height();
  1132. shDragImage.ptOffset.x = rcColumn.Width() / 2;
  1133. shDragImage.ptOffset.y = rcColumn.Height() / 2;
  1134. shDragImage.hbmpDragImage = bmpHeader;
  1135. shDragImage.crColorKey = m_rgbBackground;
  1136. // start header drag operation
  1137. m_oleDragDrop.DoDragDrop( &shDragImage, DROPEFFECT_MOVE );
  1138. // hide drop arrows after moving column
  1139. m_wndDropArrows.Hide();
  1140. if ( m_bButtonDown )
  1141. {
  1142. ReleaseCapture();
  1143. m_bButtonDown = FALSE;
  1144. m_bBeginSelect = FALSE;
  1145. m_ptDownPoint = 0;
  1146. m_ptSelectPoint = 0;
  1147. }
  1148. // finish moving a column
  1149. if ( m_nHighlightColumn != NULL_COLUMN )
  1150. {
  1151. m_nHighlightColumn = NULL_COLUMN;
  1152. InvalidateHeader();
  1153. }
  1154. m_nDragColumn = NULL_COLUMN;
  1155. }
  1156. BOOL DropColumn( CPoint point )
  1157. {
  1158. if ( !m_bShowHeader )
  1159. return FALSE;
  1160. m_nHotDivider = NULL_COLUMN;
  1161. m_nHotColumn = NULL_COLUMN;
  1162. UINT nHeaderFlags = HITTEST_FLAG_NONE;
  1163. // are we over the header?
  1164. if ( HitTestHeader( point, m_nHotColumn, nHeaderFlags ) )
  1165. {
  1166. CRect rcColumn;
  1167. if ( !GetColumnRect( m_nHotColumn, rcColumn ) )
  1168. return FALSE;
  1169. m_nHotDivider = point.x < ( ( rcColumn.left + rcColumn.right ) / 2 ) ? m_nHotColumn : m_nHotColumn + 1;
  1170. if ( m_nHotDivider == m_nDragColumn || m_nHotDivider == m_nDragColumn + 1 )
  1171. m_nHotDivider = NULL_COLUMN;
  1172. }
  1173. if ( m_nHotDivider != NULL_COLUMN )
  1174. {
  1175. CRect rcHeader;
  1176. GetClientRect( rcHeader );
  1177. rcHeader.bottom = m_nHeaderHeight;
  1178. CPoint ptDivider( 0, rcHeader.Height() / 2 );
  1179. CRect rcColumn;
  1180. int nColumnCount = GetColumnCount();
  1181. // set closest divider position
  1182. if ( GetColumnRect( m_nHotDivider < nColumnCount ? m_nHotDivider : nColumnCount - 1, rcColumn ) )
  1183. ptDivider.x = m_nHotDivider < nColumnCount ? rcColumn.left : rcColumn.right;
  1184. ClientToScreen( &ptDivider );
  1185. // track drop window
  1186. m_wndDropArrows.Show( ptDivider );
  1187. return TRUE;
  1188. }
  1189. m_wndDropArrows.Hide();
  1190. return FALSE;
  1191. }
  1192. BOOL SortColumn( int nColumn )
  1193. {
  1194. T* pT = static_cast<T*>(this);
  1195. if ( !m_bShowHeader || !m_bShowSort )
  1196. return FALSE;
  1197. BOOL bReverseSort = FALSE;
  1198. int nSortIndex = GetColumnIndex( nColumn );
  1199. CWaitCursor curWait;
  1200. if ( nSortIndex != m_nSortColumn )
  1201. {
  1202. // sort by new column
  1203. m_bSortAscending = TRUE;
  1204. m_nSortColumn = nSortIndex;
  1205. pT->SortItems( m_nSortColumn, m_bSortAscending );
  1206. }
  1207. else
  1208. {
  1209. // toggle sort order if sorting same column
  1210. m_bSortAscending = !m_bSortAscending;
  1211. pT->ReverseItems();
  1212. }
  1213. return ResetSelected();
  1214. }
  1215. BOOL GetSortColumn( int& nColumn, BOOL& bAscending )
  1216. {
  1217. if ( !m_bShowHeader || !m_bShowSort || m_nSortColumn == NULL_COLUMN )
  1218. return FALSE;
  1219. nColumn = m_nSortColumn;
  1220. bAscending = m_bSortAscending;
  1221. return TRUE;
  1222. }
  1223. BOOL DragItem()
  1224. {
  1225. ATLASSERT( FALSE ); // must be implemented in a derived class
  1226. return FALSE;
  1227. }
  1228. BOOL GroupSelect( CPoint point )
  1229. {
  1230. HideTitleTip();
  1231. int nHorzScroll = GetScrollPos( SB_HORZ );
  1232. int nVertScroll = GetScrollPos( SB_VERT );
  1233. m_rcGroupSelect.left = min( m_ptSelectPoint.x, point.x + nHorzScroll );
  1234. m_rcGroupSelect.right = max( m_ptSelectPoint.x, point.x + nHorzScroll );
  1235. m_rcGroupSelect.top = min( m_ptSelectPoint.y, point.y + nVertScroll );
  1236. m_rcGroupSelect.bottom = max( m_ptSelectPoint.y, point.y + nVertScroll );
  1237. if ( m_rcGroupSelect.IsRectEmpty() )
  1238. return FALSE;
  1239. // select items in group
  1240. AutoSelect( point );
  1241. // start auto scroll timer
  1242. SetTimer( ITEM_AUTOSCROLL_TIMER, ITEM_SCROLL_PERIOD );
  1243. DWORD dwCurrentTick = GetTickCount();
  1244. // timer messages are a low priority, therefore we need to simulate the timer when moving the mouse
  1245. if ( ( dwCurrentTick - m_dwScrollTick ) > ITEM_SCROLL_PERIOD - 10 )
  1246. {
  1247. if ( AutoScroll( point ) )
  1248. m_dwScrollTick = dwCurrentTick;
  1249. }
  1250. // redraw list immediately
  1251. return RedrawWindow();
  1252. }
  1253. void AutoSelect( CPoint point )
  1254. {
  1255. m_setSelectedItems.clear();
  1256. if ( m_rcGroupSelect.left < GetTotalWidth() )
  1257. {
  1258. int nHorzScroll = GetScrollPos( SB_HORZ );
  1259. int nVertScroll = GetScrollPos( SB_VERT );
  1260. CRect rcGroupSelect( m_rcGroupSelect );
  1261. rcGroupSelect.OffsetRect( -nHorzScroll, -nVertScroll );
  1262. int nTopItem = GetTopItem();
  1263. int nLastItem = nTopItem + ( ( rcGroupSelect.bottom - ( m_bShowHeader ? m_nHeaderHeight : 0 ) ) / m_nItemHeight );
  1264. nTopItem += ( ( rcGroupSelect.top - ( m_bShowHeader ? m_nHeaderHeight : 0 ) ) / m_nItemHeight ) - ( ( rcGroupSelect.top < 0 ) ? 1 : 0 );
  1265. for ( int nItem = nTopItem; nItem <= nLastItem; nItem++ )
  1266. {
  1267. if ( m_setSelectedItems.empty() )
  1268. m_nFirstSelected = nItem;
  1269. m_setSelectedItems.insert( nItem );
  1270. m_nFocusItem = nItem;
  1271. m_nFocusSubItem = NULL_SUBITEM;
  1272. }
  1273. }
  1274. if ( m_setSelectedItems.empty() )
  1275. m_nFirstSelected = NULL_ITEM;
  1276. }
  1277. BOOL AutoScroll( CPoint point )
  1278. {
  1279. CRect rcClient;
  1280. GetClientRect( rcClient );
  1281. rcClient.top = ( m_bShowHeader ? m_nHeaderHeight : 0 );
  1282. int nHorzScroll = GetScrollPos( SB_HORZ );
  1283. int nVertScroll = GetScrollPos( SB_VERT );
  1284. BOOL bAutoScroll = FALSE;
  1285. if ( point.y < rcClient.top )
  1286. {
  1287. SendMessage( WM_VSCROLL, MAKEWPARAM( SB_LINEUP, 0 ) );
  1288. int nAutoScroll = GetScrollPos( SB_VERT );
  1289. if ( nVertScroll != nAutoScroll )
  1290. {
  1291. m_rcGroupSelect.top = rcClient.top + nAutoScroll - 1;
  1292. m_rcGroupSelect.bottom = max( m_ptSelectPoint.y, point.y + nAutoScroll - 1 );
  1293. bAutoScroll = TRUE;
  1294. }
  1295. }
  1296. if ( point.y > rcClient.bottom )
  1297. {
  1298. SendMessage( WM_VSCROLL, MAKEWPARAM( SB_LINEDOWN, 0 ) );
  1299. int nAutoScroll = GetScrollPos( SB_VERT );
  1300. if ( nVertScroll != nAutoScroll )
  1301. {
  1302. m_rcGroupSelect.top = min( m_ptSelectPoint.y, point.y + nAutoScroll + 1 );
  1303. m_rcGroupSelect.bottom = rcClient.bottom + nAutoScroll + 1;
  1304. bAutoScroll = TRUE;
  1305. }
  1306. }
  1307. if ( point.x < rcClient.left )
  1308. {
  1309. SendMessage( WM_HSCROLL, MAKEWPARAM( SB_LINELEFT, 0 ) );
  1310. int nAutoScroll = GetScrollPos( SB_HORZ );
  1311. if ( nHorzScroll != nAutoScroll )
  1312. {
  1313. m_rcGroupSelect.left = rcClient.left + nAutoScroll - 1;
  1314. m_rcGroupSelect.right = max( m_ptSelectPoint.x, point.x + nAutoScroll - 1 );
  1315. bAutoScroll = TRUE;
  1316. }
  1317. }
  1318. if ( point.x > rcClient.right )
  1319. {
  1320. SendMessage( WM_HSCROLL, MAKEWPARAM( SB_LINERIGHT, 0 ) );
  1321. int nAutoScroll = GetScrollPos( SB_HORZ );
  1322. if ( nHorzScroll != nAutoScroll )
  1323. {
  1324. m_rcGroupSelect.left = min( m_ptSelectPoint.x, point.x + nAutoScroll + 1 );
  1325. m_rcGroupSelect.right = rcClient.right + nAutoScroll + 1;
  1326. bAutoScroll = TRUE;
  1327. }
  1328. }
  1329. // was scrolling performed?
  1330. return bAutoScroll;
  1331. }
  1332. BOOL BeginScroll( int nBeginItem, int nEndItem )
  1333. {
  1334. T* pT = static_cast<T*>(this);
  1335. // any scroll required?
  1336. if ( nBeginItem == nEndItem )
  1337. return FALSE;
  1338. // calculate scroll offset
  1339. m_nScrollOffset = abs( nEndItem - nBeginItem ) * m_nItemHeight;
  1340. m_nScrollUnit = min( max( m_nScrollOffset / m_nItemHeight, ITEM_SCROLL_UNIT_MIN ), ITEM_SCROLL_UNIT_MAX );
  1341. m_nScrollDelta = ( m_nScrollOffset - m_nScrollUnit ) / m_nScrollUnit;
  1342. m_bScrollDown = ( nBeginItem < nEndItem );
  1343. CClientDC dcClient( m_hWnd );
  1344. CDC dcScrollList;
  1345. dcScrollList.CreateCompatibleDC( dcClient );
  1346. int nContextState = dcScrollList.SaveDC();
  1347. CRect rcScrollList;
  1348. GetClientRect( rcScrollList );
  1349. rcScrollList.bottom = ( GetCountPerPage() + abs( nEndItem - nBeginItem ) ) * m_nItemHeight;
  1350. if ( !m_bmpScrollList.IsNull() )
  1351. m_bmpScrollList.DeleteObject();
  1352. m_bmpScrollList.CreateCompatibleBitmap( dcClient, rcScrollList.Width(), rcScrollList.Height() ); 
  1353. dcScrollList.SelectBitmap( m_bmpScrollList );
  1354. pT->DrawBkgnd( dcScrollList.m_hDC );
  1355. CRect rcItem;
  1356. rcItem.left = -GetScrollPos( SB_HORZ );
  1357. rcItem.right = GetTotalWidth();
  1358. rcItem.top = 0;
  1359. rcItem.bottom = rcItem.top;
  1360. // draw all visible items into bitmap
  1361. for ( int nItem = min( nBeginItem, nEndItem ); nItem < pT->GetItemCount(); rcItem.top = rcItem.bottom, nItem++ )
  1362. {
  1363. rcItem.bottom = rcItem.top + m_nItemHeight;
  1364. if ( rcItem.top > rcScrollList.bottom )
  1365. break;
  1366. // may be implemented in a derived class
  1367. pT->DrawItem( dcScrollList.m_hDC, nItem, rcItem );
  1368. }
  1369. dcScrollList.RestoreDC( nContextState );
  1370. ScrollList();
  1371. // start scrolling timer
  1372. SetTimer( ITEM_SCROLL_TIMER, ITEM_SCROLL_PERIOD );
  1373. return TRUE;
  1374. }
  1375. BOOL EndScroll()
  1376. {
  1377. KillTimer( ITEM_SCROLL_TIMER );
  1378. if ( !m_bmpScrollList.IsNull() )
  1379. m_bmpScrollList.DeleteObject();
  1380. return Invalidate();
  1381. }
  1382. BOOL ScrollList()
  1383. {
  1384. if ( m_nScrollOffset <= m_nScrollUnit )
  1385. m_nScrollOffset--;
  1386. else
  1387. {
  1388. m_nScrollOffset -= m_nScrollDelta;
  1389. if ( m_nScrollOffset < m_nScrollDelta )
  1390. m_nScrollOffset = m_nScrollUnit;
  1391. }
  1392. if ( m_bmpScrollList.IsNull() || m_nScrollOffset < 0 )
  1393. return FALSE;
  1394. CClientDC dcClient( m_hWnd );
  1395. CDC dcScrollList;
  1396. dcScrollList.CreateCompatibleDC( dcClient );
  1397. CRect rcClient;
  1398. GetClientRect( rcClient );
  1399. rcClient.top = ( m_bShowHeader ? m_nHeaderHeight : 0 );
  1400. HBITMAP hOldBitmap = dcScrollList.SelectBitmap( m_bmpScrollList );
  1401. CSize sizScrollBitmap;
  1402. m_bmpScrollList.GetSize( sizScrollBitmap );
  1403. // draw scrolled list
  1404. dcClient.BitBlt( 0, rcClient.top, rcClient.Width(), rcClient.Height(), dcScrollList, 0, m_bScrollDown ? ( sizScrollBitmap.cy - ( GetCountPerPage() * m_nItemHeight ) - m_nScrollOffset ) : m_nScrollOffset, SRCCOPY );
  1405. dcScrollList.SelectBitmap( hOldBitmap );
  1406. return TRUE;
  1407. }
  1408. BOOL EditItem( int nItem, int nSubItem = NULL_SUBITEM )
  1409. {
  1410. T* pT = static_cast<T*>(this);
  1411. if ( !EnsureItemVisible( nItem, nSubItem ) )
  1412. return FALSE;
  1413. if ( GetFocus() != m_hWnd )
  1414. return FALSE;
  1415. CRect rcSubItem;
  1416. if ( !GetItemRect( nItem, nSubItem, rcSubItem ) )
  1417. return FALSE;
  1418. int nIndex = GetColumnIndex( nSubItem );
  1419. if ( pT->GetItemFlags( nItem, nIndex ) & ITEM_FLAGS_READ_ONLY )
  1420. return TRUE;
  1421. switch ( pT->GetItemFormat( nItem, nIndex ) )
  1422. {
  1423. case ITEM_FORMAT_EDIT: m_bEditItem = TRUE;
  1424. if ( !RedrawWindow() )
  1425. return FALSE;
  1426. if ( !m_wndItemEdit.Create( m_hWnd, nItem, nSubItem, rcSubItem, pT->GetItemFlags( nItem, nIndex ), pT->GetItemText( nItem, nIndex ) ) )
  1427. return FALSE;
  1428. break;
  1429. case ITEM_FORMAT_DATETIME: {
  1430. m_bEditItem = TRUE;
  1431. if ( !RedrawWindow() )
  1432. return FALSE;
  1433. SYSTEMTIME stItemDate;
  1434. GetItemDate( nItem, nIndex, stItemDate );
  1435. if ( !m_wndItemDate.Create( m_hWnd, nItem, nSubItem, rcSubItem, pT->GetItemFlags( nItem, nIndex ), stItemDate ) )
  1436. return FALSE;
  1437. }
  1438. break;
  1439. case ITEM_FORMAT_COMBO: {
  1440. m_bEditItem = TRUE;
  1441. if ( !RedrawWindow() )
  1442. return FALSE;
  1443. CListArray < CString > aComboList;
  1444. if ( !pT->GetItemComboList( nItem, nIndex, aComboList ) )
  1445. return FALSE;
  1446. if ( !m_wndItemCombo.Create( m_hWnd, nItem, nSubItem, rcSubItem, pT->GetItemFlags( nItem, nIndex ), pT->GetItemText( nItem, nIndex ), m_bShowThemed, aComboList ) )
  1447. return FALSE;
  1448. }
  1449. break;
  1450. }
  1451. return TRUE;
  1452. }
  1453. CString FormatDate( SYSTEMTIME& stFormatDate )
  1454. {
  1455. if ( stFormatDate.wYear == 0 )
  1456. return _T( "" );
  1457. // format date to local format
  1458. TCHAR szDateFormat[ DATE_STRING ];
  1459. return GetDateFormat( LOCALE_USER_DEFAULT, DATE_SHORTDATE, &stFormatDate, NULL, szDateFormat, DATE_STRING ) == 0 ? _T( "" ) : szDateFormat;
  1460. }
  1461. CString FormatTime( SYSTEMTIME& stFormatDate )
  1462. {
  1463. SYSTEMTIME stFormatTime = stFormatDate;
  1464. stFormatTime.wYear = 0;
  1465. stFormatTime.wMonth = 0;
  1466. stFormatTime.wDay = 0;
  1467. // format time to local format
  1468. TCHAR szTimeFormat[ DATE_STRING ];
  1469. return GetTimeFormat( LOCALE_USER_DEFAULT, 0, &stFormatTime, NULL, szTimeFormat, DATE_STRING ) == 0 ? _T( "" ) : szTimeFormat;
  1470. }
  1471. void NotifyParent( int nItem, int nSubItem, int nMessage )
  1472. {
  1473. T* pT = static_cast<T*>(this);
  1474. CListNotify listNotify;
  1475. listNotify.m_hdrNotify.hwndFrom = pT->m_hWnd;
  1476. listNotify.m_hdrNotify.idFrom = pT->GetDlgCtrlID();
  1477. listNotify.m_hdrNotify.code = nMessage;
  1478. listNotify.m_nItem = nItem;
  1479. listNotify.m_nSubItem = GetColumnIndex( nSubItem );
  1480. listNotify.m_nExitChar = 0;
  1481. listNotify.m_lpszItemText = NULL;
  1482. listNotify.m_lpItemDate = NULL;
  1483. // forward notification to parent
  1484. FORWARD_WM_NOTIFY( pT->GetParent(), listNotify.m_hdrNotify.idFrom, &listNotify.m_hdrNotify, ::SendMessage );
  1485. }
  1486. BOOL ShowTitleTip( CPoint point, int nItem, int nSubItem )
  1487. {
  1488. T* pT = static_cast<T*>(this);
  1489. // do not show titletip if editing
  1490. if ( m_bEditItem )
  1491. return FALSE;
  1492. // is titletip already shown for this item?
  1493. if ( nItem == m_nTitleTipItem && nSubItem == m_nTitleTipSubItem )
  1494. return FALSE;
  1495. CRect rcSubItem;
  1496. if ( !GetItemRect( nItem, nSubItem, rcSubItem ) )
  1497. {
  1498. HideTitleTip();
  1499. return FALSE;
  1500. }
  1501. int nIndex = GetColumnIndex( nSubItem );
  1502. CRect rcItemText( rcSubItem );
  1503. // margin item text
  1504. rcItemText.left += nSubItem == 0 ? 4 : 3;
  1505. rcItemText.DeflateRect( 4, 0 );
  1506. // offset item text (for image)
  1507. if ( !m_ilItemImages.IsNull() && pT->GetItemImage( nItem, nIndex ) != ITEM_IMAGE_NONE )
  1508. {
  1509. CSize sizeIcon;
  1510. m_ilItemImages.GetIconSize( sizeIcon );
  1511. rcItemText.left += sizeIcon.cx + 4;
  1512. }
  1513. // is current cursor position over item text (not over an icon)?
  1514. if ( !rcItemText.PtInRect( point ) )
  1515. return FALSE;
  1516. CString strItemText;
  1517. switch ( pT->GetItemFormat( nItem, nIndex ) )
  1518. {
  1519. case ITEM_FORMAT_CHECKBOX:
  1520. case ITEM_FORMAT_CHECKBOX_3STATE:
  1521. case ITEM_FORMAT_PROGRESS: break; // no titletip for checkboxes or progress
  1522. case ITEM_FORMAT_DATETIME: {
  1523. SYSTEMTIME stItemDate;
  1524. if ( !GetItemDate( nItem, nIndex, stItemDate ) )
  1525. break;
  1526. UINT nItemFlags = pT->GetItemFlags( nItem, nIndex );
  1527. if ( nItemFlags & ITEM_FLAGS_DATE_ONLY )
  1528. strItemText = FormatDate( stItemDate );
  1529. else if ( nItemFlags & ITEM_FLAGS_TIME_ONLY )
  1530. strItemText = FormatTime( stItemDate );
  1531. else
  1532. strItemText = FormatDate( stItemDate ) + _T( " " ) + FormatTime( stItemDate );
  1533. }
  1534. break;
  1535. default: strItemText = pT->GetItemText( nItem, nIndex );
  1536. break;
  1537. }
  1538. if ( strItemText.IsEmpty() )
  1539. {
  1540. HideTitleTip();
  1541. return FALSE;
  1542. }
  1543. ClientToScreen( rcItemText );
  1544. if ( !m_wndTitleTip.Show( rcItemText, strItemText, pT->GetItemToolTip( nItem, nIndex ) ) )
  1545. {
  1546. HideTitleTip();
  1547. return FALSE;
  1548. }
  1549. m_nTitleTipItem = nItem;
  1550. m_nTitleTipSubItem = nSubItem;
  1551. return TRUE;
  1552. }
  1553. BOOL HideTitleTip( BOOL bResetItem = TRUE )
  1554. {
  1555. if ( bResetItem )
  1556. {
  1557. m_nTitleTipItem = NULL_ITEM;
  1558. m_nTitleTipSubItem = NULL_SUBITEM;
  1559. }
  1560. return m_wndTitleTip.Hide();
  1561. }
  1562. BEGIN_MSG_MAP_EX(CListImpl)
  1563. MSG_WM_CREATE(OnCreate)
  1564. MSG_WM_DESTROY(OnDestroy)
  1565. MSG_WM_SETFOCUS(OnSetFocus)
  1566. MSG_WM_KILLFOCUS(OnKillFocus)
  1567. MSG_WM_GETDLGCODE(OnGetDlgCode)
  1568. MSG_WM_SIZE(OnSize)
  1569. MSG_WM_HSCROLL(OnHScroll)
  1570. MSG_WM_VSCROLL(OnVScroll)
  1571. MSG_WM_CANCELMODE(OnCancelMode)
  1572. MESSAGE_RANGE_HANDLER_EX(WM_MOUSEFIRST,WM_MOUSELAST,OnMouseRange)
  1573. MSG_WM_LBUTTONDOWN(OnLButtonDown)
  1574. MSG_WM_LBUTTONUP(OnLButtonUp)
  1575. MSG_WM_LBUTTONDBLCLK(OnLButtonDblClk)
  1576. MSG_WM_RBUTTONDOWN(OnRButtonDown)
  1577. MSG_WM_RBUTTONUP(OnRButtonUp)
  1578. MSG_WM_MOUSEMOVE(OnMouseMove)
  1579. MSG_WM_MOUSELEAVE(OnMouseLeave)
  1580. MSG_WM_MOUSEWHEEL(OnMouseWheel)
  1581. MSG_WM_TIMER(OnTimer)
  1582. MSG_WM_KEYDOWN(OnKeyDown)
  1583. MSG_WM_SYSKEYDOWN(OnSysKeyDown)
  1584. MSG_WM_SETTINGCHANGE(OnSettingsChange)
  1585. MSG_WM_SYSCOLORCHANGE(OnSettingsChange)
  1586. MSG_WM_FONTCHANGE(OnSettingsChange)
  1587. MSG_WM_THEMECHANGED(OnSettingsChange)
  1588. NOTIFY_CODE_HANDLER_EX(LCN_ENDEDIT,OnEndEdit)
  1589. MESSAGE_HANDLER(WM_CTLCOLORLISTBOX, OnCtlColorListBox)
  1590. MESSAGE_HANDLER(WM_CTLCOLOREDIT, OnCtlColorListBox)
  1591. CHAIN_MSG_MAP(CDoubleBufferImpl< CListImpl >)
  1592. REFLECT_NOTIFICATIONS()
  1593. END_MSG_MAP_EX()
  1594. int OnCreate( LPCREATESTRUCT lpCreateStruct )
  1595. {
  1596. T* pT = static_cast<T*>(this);
  1597. return pT->Initialise() ? 0 : -1;
  1598. }
  1599. void OnDestroy()
  1600. {
  1601. m_oleDragDrop.Revoke();
  1602. if ( m_wndDropArrows.IsWindow() )
  1603. m_wndDropArrows.DestroyWindow();
  1604. if ( m_wndTitleTip.IsWindow() )
  1605. m_wndTitleTip.DestroyWindow();
  1606. if ( m_wndItemEdit.IsWindow() )
  1607. m_wndItemEdit.DestroyWindow();
  1608. if ( m_wndItemCombo.IsWindow() )
  1609. m_wndItemCombo.DestroyWindow();
  1610. if ( m_wndItemDate.IsWindow() )
  1611. m_wndItemDate.DestroyWindow();
  1612. if ( m_ttToolTip.IsWindow() )
  1613. m_ttToolTip.DestroyWindow();
  1614. }
  1615. void OnSetFocus( HWND hOldWnd )
  1616. {
  1617. Invalidate();
  1618. }
  1619. void OnKillFocus( HWND hNewWnd )
  1620. {
  1621. Invalidate();
  1622. }
  1623. UINT OnGetDlgCode( LPMSG lpMessage )
  1624. {
  1625. return DLGC_WANTARROWS | DLGC_WANTTAB | DLGC_WANTCHARS;
  1626. }
  1627. void OnSize( UINT nType, CSize size )
  1628. {
  1629. // stop any pending scroll
  1630. EndScroll();
  1631. // end any pending edit
  1632. if ( m_bEditItem )
  1633. SetFocus();
  1634. ResetScrollBars( SB_BOTH, -1, FALSE );
  1635. Invalidate();
  1636. }
  1637. void OnHScroll( int nSBCode, short nPos, HWND hScrollBar )
  1638. {
  1639. // stop any pending scroll
  1640. EndScroll();
  1641. // end any pending edit
  1642. if ( m_bEditItem )
  1643. SetFocus();
  1644. HideTitleTip();
  1645. CRect rcClient;
  1646. GetClientRect( rcClient );
  1647. int nScrollPos = GetScrollPos( SB_HORZ );
  1648. switch ( nSBCode )
  1649. {
  1650. case SB_LEFT: nScrollPos = 0;
  1651. break;
  1652. case SB_LINELEFT: nScrollPos = max( nScrollPos - ITEM_SCROLL_OFFSET, 0 );
  1653. break;
  1654. case SB_PAGELEFT: nScrollPos = max( nScrollPos - rcClient.Width(), 0 );
  1655. break;
  1656. case SB_RIGHT: nScrollPos = rcClient.Width();
  1657. break;
  1658. case SB_LINERIGHT: nScrollPos = min( nScrollPos + ITEM_SCROLL_OFFSET, GetTotalWidth() );
  1659. break;
  1660. case SB_PAGERIGHT: nScrollPos = min( nScrollPos + rcClient.Width(), GetTotalWidth() );
  1661. break;
  1662. case SB_THUMBPOSITION:
  1663. case SB_THUMBTRACK: {
  1664. SCROLLINFO infoScroll;
  1665. ZeroMemory( &infoScroll, sizeof( SCROLLINFO ) );
  1666. infoScroll.cbSize = sizeof( SCROLLINFO );
  1667. infoScroll.fMask = SIF_TRACKPOS;
  1668. // get 32-bit scroll position
  1669. if ( !GetScrollInfo( SB_HORZ, &infoScroll ) )
  1670. return;
  1671. // has scroll position changed?
  1672. if ( infoScroll.nTrackPos == nScrollPos )
  1673. return;
  1674. nScrollPos = infoScroll.nTrackPos;
  1675. }
  1676. break;
  1677. default: return;
  1678. }
  1679. ResetScrollBars( SB_HORZ, nScrollPos, FALSE );
  1680. Invalidate();
  1681. }
  1682. void OnVScroll( int nSBCode, short nPos, HWND hScrollBar )
  1683. {
  1684. T* pT = static_cast<T*>(this);
  1685. // end any pending edit
  1686. if ( m_bEditItem )
  1687. SetFocus();
  1688. HideTitleTip();
  1689. CRect rcClient;
  1690. GetClientRect( rcClient );
  1691. rcClient.top = ( m_bShowHeader ? m_nHeaderHeight : 0 );
  1692. int nScrollPos = GetScrollPos( SB_VERT );
  1693. BOOL bScrollList = m_bSmoothScroll;
  1694. switch ( nSBCode )
  1695. {
  1696. case SB_TOP: nScrollPos = 0;
  1697. bScrollList = FALSE;
  1698. break;
  1699. case SB_LINEUP: nScrollPos = max( nScrollPos - m_nItemHeight, 0 );
  1700. break;
  1701. case SB_PAGEUP: nScrollPos = max( nScrollPos - rcClient.Height(), 0 );
  1702. break;
  1703. case SB_BOTTOM: nScrollPos = pT->GetItemCount() * m_nItemHeight;
  1704. bScrollList = FALSE;
  1705. break;
  1706. case SB_LINEDOWN: nScrollPos += m_nItemHeight;
  1707. break;
  1708. case SB_PAGEDOWN: nScrollPos += rcClient.Height();
  1709. break;
  1710. case SB_THUMBTRACK:
  1711. case SB_THUMBPOSITION: {
  1712. SCROLLINFO infoScroll;
  1713. ZeroMemory( &infoScroll, sizeof( SCROLLINFO ) );
  1714. infoScroll.cbSize = sizeof( SCROLLINFO );
  1715. infoScroll.fMask = SIF_TRACKPOS;
  1716. // get 32-bit scroll position
  1717. if ( !GetScrollInfo( SB_VERT, &infoScroll ) )
  1718. return;
  1719. // has scroll position changed?
  1720. if ( infoScroll.nTrackPos == nScrollPos )
  1721. return;
  1722. nScrollPos = infoScroll.nTrackPos;
  1723. bScrollList = FALSE;
  1724. }
  1725. break;
  1726. case SB_ENDSCROLL: m_bScrolling = FALSE;
  1727. default: return;
  1728. }
  1729. // store original top item before scrolling
  1730. int nTopItem = GetTopItem();
  1731. ResetScrollBars( SB_VERT, nScrollPos, FALSE );
  1732. if ( bScrollList && !m_bScrolling )
  1733. m_bScrolling = BeginScroll( nTopItem, GetTopItem() );
  1734. else
  1735. EndScroll();
  1736. }
  1737. void OnCancelMode() 
  1738. {
  1739. if ( m_bButtonDown )
  1740. ReleaseCapture();
  1741. HideTitleTip();
  1742. m_wndDropArrows.Hide();
  1743. m_nDragColumn = NULL_COLUMN;
  1744. m_nHighlightColumn = NULL_COLUMN;
  1745. }
  1746. LRESULT OnMouseRange( UINT nMessage, WPARAM wParam, LPARAM lParam )
  1747. {
  1748. if ( m_ttToolTip.IsWindow() )
  1749. {
  1750. MSG msgRelay = { m_hWnd, nMessage, wParam, lParam };
  1751. m_ttToolTip.RelayEvent( &msgRelay );
  1752. }
  1753. SetMsgHandled( FALSE );
  1754. return 0;
  1755. }
  1756. void OnLButtonDown( UINT nFlags, CPoint point )
  1757. {
  1758. T* pT = static_cast<T*>(this);
  1759. HideTitleTip( FALSE );
  1760. m_bButtonDown = TRUE;
  1761. m_ptDownPoint = point;
  1762. m_ptSelectPoint = CPoint( point.x + GetScrollPos( SB_HORZ ), point.y + GetScrollPos( SB_VERT ) );
  1763. // stop any pending scroll
  1764. EndScroll();
  1765. SetFocus();
  1766. // capture all mouse input
  1767. SetCapture();
  1768. int nColumn = NULL_COLUMN;
  1769. UINT nHeaderFlags = HITTEST_FLAG_NONE;
  1770. // are we over the header?
  1771. if ( HitTestHeader( point, nColumn, nHeaderFlags ) )
  1772. {
  1773. CListColumn listColumn;
  1774. if ( !GetColumn( nColumn, listColumn ) )
  1775. return;
  1776. if ( !listColumn.m_bFixed && ( nHeaderFlags & HITTEST_FLAG_HEADER_DIVIDER ) )
  1777. {
  1778. SetCursor( m_curDivider );
  1779. // begin column resizing
  1780. m_bColumnSizing = TRUE;
  1781. m_nColumnSizing = nColumn;
  1782. m_nStartSize = listColumn.m_nWidth;
  1783. m_nStartPos = GET_X_LPARAM( GetMessagePos() );
  1784. }
  1785. else
  1786. {
  1787. m_nHighlightColumn = nColumn;
  1788. InvalidateHeader();
  1789. }
  1790. return;
  1791. }
  1792. int nItem = NULL_ITEM;
  1793. int nSubItem = NULL_SUBITEM;
  1794. if ( !HitTest( point, nItem, nSubItem ) )
  1795. {
  1796. m_nFirstSelected = NULL_ITEM;
  1797. m_bBeginSelect = TRUE;
  1798. }
  1799. else
  1800. {
  1801. // do not begin group select from first columns
  1802. if ( !( nFlags & MK_SHIFT ) && !( nFlags & MK_CONTROL ) && nSubItem != 0 )
  1803. {
  1804. m_bBeginSelect = TRUE;
  1805. m_nFirstSelected = nItem;
  1806. }
  1807. // only select item if not already selected
  1808. if ( ( nFlags & MK_SHIFT ) || ( nFlags & MK_CONTROL ) || !IsSelected( nItem ) || m_setSelectedItems.size() <= 1 )
  1809. SelectItem( nItem, nSubItem, nFlags );
  1810. int nIndex = GetColumnIndex( nSubItem );
  1811. if ( !( pT->GetItemFlags( nItem, nIndex ) & ITEM_FLAGS_READ_ONLY ) )
  1812. {
  1813. switch ( pT->GetItemFormat( nItem, nIndex ) )
  1814. {
  1815. case ITEM_FORMAT_CHECKBOX: m_bBeginSelect = FALSE;
  1816. pT->SetItemText( nItem, nIndex, _ttoi( pT->GetItemText( nItem, nIndex ) ) > 0 ? _T( "0" ) : _T( "1" ) );
  1817. NotifyParent( nItem, nSubItem, LCN_MODIFIED );
  1818. InvalidateItem( nItem );
  1819. break;
  1820. case ITEM_FORMAT_CHECKBOX_3STATE: {
  1821. m_bBeginSelect = FALSE;
  1822. int nCheckImage = _ttoi( pT->GetItemText( nItem, nIndex ) );
  1823. if ( nCheckImage < 0 )
  1824. pT->SetItemText( nItem, nIndex, _T( "0" ) );
  1825. else if ( nCheckImage > 0 )
  1826. pT->SetItemText( nItem, nIndex, _T( "-1" ) );
  1827. else
  1828. pT->SetItemText( nItem, nIndex, _T( "1" ) );
  1829. NotifyParent( nItem, nSubItem, LCN_MODIFIED );
  1830. InvalidateItem( nItem );
  1831. }
  1832. break;
  1833. case ITEM_FORMAT_HYPERLINK: m_bBeginSelect = FALSE;
  1834. SetCursor( m_curHyperLink );
  1835. NotifyParent( nItem, nSubItem, LCN_HYPERLINK );
  1836. break;
  1837. }
  1838. }
  1839. }
  1840. }
  1841. void OnLButtonUp( UINT nFlags, CPoint point )
  1842. {
  1843. if ( m_bButtonDown )
  1844. ReleaseCapture();
  1845. // finish resizing or selecting a column
  1846. if ( m_bColumnSizing || m_nHighlightColumn != NULL_COLUMN )
  1847. {
  1848. // are we changing the sort order?
  1849. if ( !m_bColumnSizing && m_nHighlightColumn != NULL_COLUMN )
  1850. SortColumn( m_nHighlightColumn );
  1851. m_bColumnSizing = FALSE;
  1852. m_nColumnSizing = NULL_COLUMN;
  1853. m_nHighlightColumn = NULL_COLUMN;
  1854. m_nStartSize = 0;
  1855. m_nStartPos = 0;
  1856. InvalidateHeader();
  1857. }
  1858. m_bBeginSelect = FALSE;
  1859. m_bButtonDown = FALSE;
  1860. m_ptDownPoint = 0;
  1861. m_ptSelectPoint = 0;
  1862. // have we finished a group select?
  1863. if ( m_bGroupSelect )
  1864. {
  1865. m_bGroupSelect = FALSE;
  1866. Invalidate();
  1867. }
  1868. else
  1869. {
  1870. int nItem = NULL_ITEM;
  1871. int nSubItem = NULL_SUBITEM;
  1872. // de-select item if current item is selected
  1873. if ( HitTest( point, nItem, nSubItem ) && IsSelected( nItem ) && m_setSelectedItems.size() > 1 && !( nFlags & MK_SHIFT ) && !( nFlags & MK_CONTROL ) )
  1874. SelectItem( nItem, nSubItem, nFlags );
  1875. // notify parent of left-click item
  1876. NotifyParent( nItem, nSubItem, LCN_LEFTCLICK );
  1877. }
  1878. }
  1879. void OnLButtonDblClk( UINT nFlags, CPoint point ) 
  1880. {
  1881. HideTitleTip( FALSE );
  1882. // handle double-clicks (for drawing)
  1883. SendMessage( WM_LBUTTONDOWN, 0, MAKELPARAM( point.x, point.y ) );
  1884. int nColumn = NULL_COLUMN;
  1885. UINT nHeaderFlags = HITTEST_FLAG_NONE;
  1886. // resize column if double-click on a divider
  1887. if ( HitTestHeader( point, nColumn, nHeaderFlags ) && ( nHeaderFlags & HITTEST_FLAG_HEADER_DIVIDER ) )
  1888. AutoSizeColumn( nColumn );
  1889. int nItem = NULL_ITEM;
  1890. int nSubItem = NULL_SUBITEM;
  1891. HitTest( point, nItem, nSubItem );
  1892. // notify parent of double-clicked item
  1893. NotifyParent( nItem, nSubItem, LCN_DBLCLICK );
  1894. }
  1895. void OnRButtonDown( UINT nFlags, CPoint point ) 
  1896. {
  1897. // stop any pending scroll
  1898. EndScroll();
  1899. SetFocus();
  1900. HideTitleTip( FALSE );
  1901. int nItem = NULL_ITEM;
  1902. int nSubItem = NULL_SUBITEM;
  1903. // only select item if not already selected (de-select in OnLButtonUp)
  1904. if ( HitTest( point, nItem, nSubItem ) && !IsSelected( nItem ) )
  1905. SelectItem( nItem, nSubItem, nFlags );
  1906. }
  1907. void OnRButtonUp( UINT nFlags, CPoint point )
  1908. {
  1909. int nItem = NULL_ITEM;
  1910. int nSubItem = NULL_SUBITEM;
  1911. if ( !HitTest( point, nItem, nSubItem ) )
  1912. ResetSelected();
  1913. // notify parent of right-click item
  1914. NotifyParent( nItem, nSubItem, LCN_RIGHTCLICK );
  1915. }
  1916. void OnMouseMove( UINT nFlags, CPoint point )
  1917. {
  1918. T* pT = static_cast<T*>(this);
  1919. if ( !( nFlags & MK_LBUTTON ) )
  1920. {
  1921. if ( m_bButtonDown )
  1922. ReleaseCapture();
  1923. m_bButtonDown = FALSE;
  1924. }
  1925. if ( !m_bMouseOver )
  1926. {
  1927. m_bMouseOver = TRUE;
  1928. TRACKMOUSEEVENT trkMouse;
  1929. trkMouse.cbSize = sizeof( TRACKMOUSEEVENT );
  1930. trkMouse.dwFlags = TME_LEAVE;
  1931. trkMouse.hwndTrack = m_hWnd;
  1932. // notify when the mouse leaves button
  1933. _TrackMouseEvent( &trkMouse );
  1934. }
  1935. if ( m_bButtonDown )
  1936. {
  1937. // are we resizing a column?
  1938. if ( m_bColumnSizing )
  1939. {
  1940. ResizeColumn();
  1941. return;
  1942. }
  1943. // are we beginning to drag a column? 
  1944. if ( m_nHighlightColumn != NULL_COLUMN && ( point.x < m_ptDownPoint.x - DRAG_HEADER_OFFSET || point.x > m_ptDownPoint.x + DRAG_HEADER_OFFSET || point.y < m_ptDownPoint.y - DRAG_HEADER_OFFSET || point.y > m_ptDownPoint.y + DRAG_HEADER_OFFSET ) )
  1945. {
  1946. DragColumn();
  1947. return;
  1948. }
  1949. // are we beginning a group select or dragging an item?
  1950. if ( point.x < m_ptDownPoint.x - DRAG_ITEM_OFFSET || point.x > m_ptDownPoint.x + DRAG_ITEM_OFFSET || point.y < m_ptDownPoint.y - DRAG_ITEM_OFFSET || point.y > m_ptDownPoint.y + DRAG_ITEM_OFFSET )
  1951. {
  1952. if ( m_bBeginSelect || !m_bDragDrop )
  1953. m_bGroupSelect = ( !m_bSingleSelect && !m_bEditItem );
  1954. else
  1955. {
  1956. int nItem = NULL_ITEM;
  1957. int nSubItem = NULL_SUBITEM;
  1958. if ( HitTest( point, nItem, nSubItem ) )
  1959. {
  1960. // select the drag item (if not already selected)
  1961. if ( !IsSelected( nItem ) )
  1962. SelectItem( nItem, nSubItem, nFlags );
  1963. // begin drag item operation
  1964. pT->DragItem();
  1965. }
  1966. }
  1967. }
  1968. if ( m_bGroupSelect )
  1969. {
  1970. GroupSelect( point );
  1971. return;
  1972. }
  1973. }
  1974. else
  1975. {
  1976. int nColumn = NULL_COLUMN;
  1977. UINT nHeaderFlags = HITTEST_FLAG_NONE;
  1978. // are we over the header?
  1979. BOOL bHitTestHeader = HitTestHeader( point, nColumn, nHeaderFlags );
  1980. if ( m_bShowThemed && !m_thmHeader.IsThemeNull() )
  1981. {
  1982. if ( bHitTestHeader && m_nHotColumn != nColumn )
  1983. {
  1984. m_nHotColumn = nColumn;
  1985. InvalidateHeader();
  1986. }
  1987. else if ( !bHitTestHeader && m_nHotColumn != NULL_COLUMN )
  1988. {
  1989. m_nHotColumn = NULL_COLUMN;
  1990. InvalidateHeader();
  1991. }
  1992. }
  1993. if ( bHitTestHeader )
  1994. {
  1995. HideTitleTip();
  1996. CListColumn listColumn;
  1997. if ( GetColumn( nColumn, listColumn ) && !listColumn.m_bFixed && ( nHeaderFlags & HITTEST_FLAG_HEADER_DIVIDER ) )
  1998. SetCursor( m_curDivider );
  1999. return;
  2000. }
  2001. int nItem = NULL_ITEM;
  2002. int nSubItem = NULL_SUBITEM;
  2003. if ( !HitTest( point, nItem, nSubItem ) )
  2004. {
  2005. if ( m_nHotItem != NULL_ITEM && m_nHotSubItem != NULL_SUBITEM )
  2006. {
  2007. // redraw old hot item
  2008. int nIndex = GetColumnIndex( m_nHotSubItem );
  2009. if ( pT->GetItemFormat( m_nHotItem, nIndex ) == ITEM_FORMAT_HYPERLINK && !( pT->GetItemFlags( m_nHotItem, nIndex ) & ITEM_FLAGS_READ_ONLY ) )
  2010. InvalidateItem( m_nHotItem, m_nHotSubItem );
  2011. }
  2012. m_ttToolTip.Activate( FALSE );
  2013. m_ttToolTip.DelTool( m_hWnd, TOOLTIP_TOOL_ID );
  2014. m_nHotItem = NULL_ITEM;
  2015. m_nHotSubItem = NULL_SUBITEM;
  2016. HideTitleTip();
  2017. }
  2018. else
  2019. {
  2020. // has the hot item changed?
  2021. if ( nItem != m_nHotItem || nSubItem != m_nHotSubItem )
  2022. {
  2023. // redraw old hot item
  2024. int nIndex = GetColumnIndex( m_nHotSubItem );
  2025. if ( pT->GetItemFormat( m_nHotItem, nIndex ) == ITEM_FORMAT_HYPERLINK && !( pT->GetItemFlags( m_nHotItem, nIndex ) & ITEM_FLAGS_READ_ONLY ) )
  2026. InvalidateItem( m_nHotItem, m_nHotSubItem );
  2027. m_nHotItem = nItem;
  2028. m_nHotSubItem = nSubItem;
  2029. }
  2030. int nIndex = GetColumnIndex( m_nHotSubItem );
  2031. UINT nItemFormat = pT->GetItemFormat( m_nHotItem, nIndex );
  2032. UINT nItemFlags = pT->GetItemFlags( m_nHotItem, nIndex );
  2033. // draw new hot hyperlink item
  2034. if ( nItemFormat == ITEM_FORMAT_HYPERLINK && !( nItemFlags & ITEM_FLAGS_READ_ONLY ) )
  2035. {
  2036. InvalidateItem( m_nHotItem, m_nHotSubItem );
  2037. SetCursor( m_curHyperLink );
  2038. }
  2039. // get tooltip for this item
  2040. CString strToolTip = pT->GetItemToolTip( m_nHotItem, nIndex );
  2041. CRect rcSubItem;
  2042. if ( !strToolTip.IsEmpty() && GetItemRect( m_nHotItem, rcSubItem ) )
  2043. {
  2044. m_ttToolTip.Activate( TRUE );
  2045. m_ttToolTip.AddTool( m_hWnd, (LPCTSTR)strToolTip.Left( SHRT_MAX ), rcSubItem, TOOLTIP_TOOL_ID );
  2046. }
  2047. else
  2048. {
  2049. m_ttToolTip.Activate( FALSE );
  2050. m_ttToolTip.DelTool( m_hWnd, TOOLTIP_TOOL_ID );
  2051. }
  2052. // show titletips for this item
  2053. ShowTitleTip( point, m_nHotItem, m_nHotSubItem );
  2054. }
  2055. }
  2056. }
  2057. void OnMouseLeave()
  2058. {
  2059. m_bMouseOver = FALSE;
  2060. if ( m_nHotColumn != NULL_COLUMN )
  2061. {
  2062. m_nHotColumn = NULL_COLUMN;
  2063. InvalidateHeader();
  2064. }
  2065. if ( m_nHotItem != NULL_ITEM || m_nHotSubItem != NULL_SUBITEM )
  2066. {
  2067. m_nHotItem = NULL_ITEM;
  2068. m_nHotSubItem = NULL_SUBITEM;
  2069. Invalidate();
  2070. }
  2071. }
  2072. BOOL OnMouseWheel( UINT nFlags, short nDelta, CPoint point )
  2073. {
  2074. HideTitleTip();
  2075. // end any pending edit
  2076. if ( m_bEditItem )
  2077. SetFocus();
  2078. int nRowsScrolled = m_nMouseWheelScroll * nDelta / 120;
  2079. int nScrollPos = GetScrollPos( SB_VERT );
  2080. if ( nRowsScrolled > 0 )
  2081. nScrollPos = max( nScrollPos - ( nRowsScrolled * m_nItemHeight ), 0 );
  2082. else
  2083. nScrollPos += ( -nRowsScrolled * m_nItemHeight );
  2084. ResetScrollBars( SB_VERT, nScrollPos, FALSE );
  2085. Invalidate();
  2086. return TRUE;
  2087. }
  2088. void OnTimer( UINT nIDEvent, TIMERPROC timer )
  2089. {
  2090. switch ( nIDEvent )
  2091. {
  2092. case RESIZE_COLUMN_TIMER: ResizeColumn( TRUE );
  2093. break;
  2094. case ITEM_VISIBLE_TIMER: {
  2095. KillTimer( ITEM_VISIBLE_TIMER );
  2096. int nFocusItem = NULL_ITEM;
  2097. int nFocusSubItem = NULL_SUBITEM;
  2098. // get current focus item
  2099. if ( !GetFocusItem( nFocusItem, nFocusSubItem ) )
  2100. break;
  2101. // make sure current focus item is visible before editing
  2102. if ( !EditItem( nFocusItem, nFocusSubItem ) )
  2103. break;
  2104. }
  2105. break;
  2106. case ITEM_AUTOSCROLL_TIMER: if ( !m_bGroupSelect )
  2107. KillTimer( ITEM_AUTOSCROLL_TIMER );
  2108. else
  2109. {
  2110. DWORD dwPoint = GetMessagePos();
  2111. CPoint ptMouse( GET_X_LPARAM( dwPoint ), GET_Y_LPARAM( dwPoint ) );
  2112. ScreenToClient( &ptMouse );
  2113. // automatically scroll when group selecting
  2114. AutoScroll( ptMouse );
  2115. AutoSelect( ptMouse );
  2116. }
  2117. break;
  2118. case ITEM_SCROLL_TIMER: if ( !ScrollList() )
  2119. EndScroll();
  2120. break;
  2121. }
  2122. }
  2123. void OnKeyDown( TCHAR nChar, UINT nRepCnt, UINT nFlags )
  2124. {
  2125. T* pT = static_cast<T*>(this);
  2126. // stop any pending scroll
  2127. EndScroll();
  2128. BOOL bCtrlKey = ( ( GetKeyState( VK_CONTROL ) & 0x8000 ) != 0 );
  2129. BOOL bShiftKey = ( ( GetKeyState( VK_SHIFT ) & 0x8000 ) != 0 );
  2130. CRect rcClient;
  2131. GetClientRect( rcClient );
  2132. int nFocusItem = NULL_ITEM;
  2133. int nFocusSubItem = NULL_SUBITEM;
  2134. GetFocusItem( nFocusItem, nFocusSubItem );
  2135. switch ( nChar )
  2136. {
  2137. case VK_DOWN: SetFocusItem( min( nFocusItem + 1, pT->GetItemCount() - 1 ), nFocusSubItem );
  2138. break;
  2139. case VK_UP: SetFocusItem( max( nFocusItem - 1, 0 ), nFocusSubItem );
  2140. break;
  2141. case VK_NEXT: SetFocusItem( min( nFocusItem + GetCountPerPage( FALSE ) - 1, pT->GetItemCount() - 1 ), nFocusSubItem );
  2142. break;
  2143. case VK_PRIOR: SetFocusItem( max( nFocusItem - GetCountPerPage( FALSE ) + 1, 0 ), nFocusSubItem );
  2144. break;
  2145. case VK_HOME: SetFocusItem( 0, nFocusSubItem );
  2146. break;
  2147. case VK_END: SetFocusItem( pT->GetItemCount() - 1, nFocusSubItem );
  2148. break;
  2149. case VK_LEFT: if ( m_bFocusSubItem )
  2150. SetFocusItem( nFocusItem, max( nFocusSubItem - 1, 0 ) );
  2151. else
  2152. SetScrollPos( SB_HORZ, max( GetScrollPos( SB_HORZ ) - ( bCtrlKey ? ITEM_SCROLL_OFFSET * 10 : ITEM_SCROLL_OFFSET ), 0 ) );
  2153. break;
  2154. case VK_RIGHT: if ( m_bFocusSubItem )
  2155. SetFocusItem( nFocusItem, min( nFocusSubItem + 1, GetColumnCount() - 1 ) );
  2156. else
  2157. SetScrollPos( SB_HORZ, min( GetScrollPos( SB_HORZ ) + ( bCtrlKey ? ITEM_SCROLL_OFFSET * 10 : ITEM_SCROLL_OFFSET ), rcClient.Width() ) );
  2158. break;
  2159. case VK_TAB: if ( !bCtrlKey && m_bFocusSubItem )
  2160. SetFocusItem( nFocusItem, bShiftKey ? max( nFocusSubItem - 1, 0 ) : min( nFocusSubItem + 1, GetColumnCount() - 1 ) );
  2161. break;
  2162. default: if ( nChar == VK_SPACE )
  2163. {
  2164. int nIndex = GetColumnIndex( nFocusSubItem );
  2165. if ( !( pT->GetItemFlags( nFocusItem, nIndex ) & ITEM_FLAGS_READ_ONLY ) )
  2166. {
  2167. switch ( pT->GetItemFormat( nFocusItem, nIndex ) )
  2168. {
  2169. case ITEM_FORMAT_CHECKBOX: pT->SetItemText( nFocusItem, nIndex, _ttoi( pT->GetItemText( nFocusItem, nIndex ) ) > 0 ? _T( "0" ) : _T( "1" ) );
  2170. NotifyParent( nFocusItem, nFocusSubItem, LCN_MODIFIED );
  2171. InvalidateItem( nFocusItem );
  2172. return;
  2173. case ITEM_FORMAT_CHECKBOX_3STATE: {
  2174. int nCheckImage = _ttoi( pT->GetItemText( nFocusItem, nIndex ) );
  2175. if ( nCheckImage < 0 )
  2176. pT->SetItemText( nFocusItem, nIndex, _T( "0" ) );
  2177. else if ( nCheckImage > 0 )
  2178. pT->SetItemText( nFocusItem, nIndex, _T( "-1" ) );
  2179. else
  2180. pT->SetItemText( nFocusItem, nIndex, _T( "1" ) );
  2181. NotifyParent( nFocusItem, nFocusSubItem, LCN_MODIFIED );
  2182. InvalidateItem( nFocusItem );
  2183. }
  2184. return;
  2185. }
  2186. }
  2187. }
  2188. if ( bCtrlKey && nChar == _T( 'A' ) && !m_bSingleSelect )
  2189. {
  2190. m_setSelectedItems.clear();
  2191. for ( int nItem = 0; nItem < pT->GetItemCount(); nItem++ )
  2192. m_setSelectedItems.insert( nItem );
  2193. Invalidate();
  2194. return;
  2195. }
  2196. if ( !bCtrlKey && iswprint( nChar ) && iswupper( nChar ) )
  2197. {
  2198. int nSortIndex = GetColumnIndex( m_nSortColumn );
  2199. int nStartItem = nFocusItem + 1;
  2200. DWORD dwCurrentTick = GetTickCount();
  2201. CString strStart;
  2202. strStart += nChar;
  2203. // has there been another keypress since last search period?
  2204. if ( ( dwCurrentTick - m_dwSearchTick ) < SEARCH_PERIOD )
  2205. {
  2206. if ( m_strSearchString.Left( 1 ) != strStart )
  2207. m_strSearchString += nChar;
  2208. CString strFocusText = pT->GetItemText( nFocusItem, nSortIndex );
  2209. // are we continuing to type characters under current focus item?
  2210. if ( m_strSearchString.GetLength() > 1 && m_strSearchString.CompareNoCase( strFocusText.Left( m_strSearchString.GetLength() ) ) == 0 )
  2211. {
  2212. m_dwSearchTick = GetTickCount();
  2213. return;
  2214. }
  2215. }
  2216. else
  2217. {
  2218. if ( m_strSearchString.Left( 1 ) != strStart )
  2219. nStartItem = 0;
  2220. m_strSearchString = strStart;
  2221. }
  2222. m_dwSearchTick = GetTickCount();
  2223. // scan for next search string
  2224. for ( int nFirst = nStartItem; nFirst < pT->GetItemCount(); nFirst++ )
  2225. {
  2226. CString strItemText = pT->GetItemText( nFirst, nSortIndex );
  2227. if ( m_strSearchString.CompareNoCase( strItemText.Left( m_strSearchString.GetLength() ) ) == 0 )
  2228. {
  2229. SelectItem( nFirst, nFocusSubItem, TRUE );
  2230. EnsureItemVisible( nFirst, nFocusSubItem );
  2231. return;
  2232. }
  2233. }
  2234. // re-scan from top if not found search string
  2235. for ( int nSecond = 0; nSecond < pT->GetItemCount(); nSecond++ )
  2236. {
  2237. CString strItemText = pT->GetItemText( nSecond, nSortIndex );
  2238. if ( m_strSearchString.CompareNoCase( strItemText.Left( m_strSearchString.GetLength() ) ) == 0 )
  2239. {
  2240. SelectItem( nSecond, nFocusSubItem, TRUE );
  2241. EnsureItemVisible( nSecond, nFocusSubItem );
  2242. return;
  2243. }
  2244. }
  2245. }
  2246. return;
  2247. }
  2248. if ( !bCtrlKey )
  2249. SelectItem( m_nFocusItem, m_nFocusSubItem, bShiftKey ? MK_SHIFT : 0 );
  2250. }
  2251. void OnSysKeyDown( TCHAR nChar, UINT nRepCnt, UINT nFlags )
  2252. {
  2253. HideTitleTip( FALSE );
  2254. SetMsgHandled( FALSE );
  2255. }
  2256. void OnSettingsChange( UINT nFlags, LPCTSTR lpszSection )
  2257. {
  2258. OnSettingsChange();
  2259. }
  2260. void OnSettingsChange()
  2261. {
  2262. LoadSettings();
  2263. ResetScrollBars();
  2264. Invalidate();
  2265. }
  2266. LRESULT OnCtlColorListBox( UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
  2267. {
  2268. return DefWindowProc( nMsg, wParam, lParam );
  2269. }
  2270. LRESULT OnEndEdit( LPNMHDR lpNMHDR )
  2271. {
  2272. T* pT = static_cast<T*>(this);
  2273. CListNotify *pListNotify = reinterpret_cast<CListNotify *>( lpNMHDR );
  2274. m_bEditItem = FALSE;
  2275. int nIndex = GetColumnIndex( pListNotify->m_nSubItem );
  2276. switch ( pListNotify->m_nExitChar )
  2277. {
  2278. case VK_ESCAPE: break; // do nothing
  2279. case VK_DELETE: pT->SetItemText( pListNotify->m_nItem, nIndex, _T( "" ) );
  2280. NotifyParent( pListNotify->m_nItem, pListNotify->m_nSubItem, LCN_MODIFIED );
  2281. break;
  2282. default: if ( pListNotify->m_lpItemDate == NULL )
  2283. pT->SetItemText( pListNotify->m_nItem, nIndex, pListNotify->m_lpszItemText );
  2284. else
  2285. {
  2286. if ( _ttoi( pListNotify->m_lpszItemText ) == 0 )
  2287. pT->SetItemText( pListNotify->m_nItem, nIndex, _T( "" ) );
  2288. else
  2289. pT->SetItemDate( pListNotify->m_nItem, nIndex, *pListNotify->m_lpItemDate );
  2290. }
  2291. if ( pListNotify->m_nExitChar == VK_TAB )
  2292. PostMessage( WM_KEYDOWN, (WPARAM)VK_TAB );
  2293. NotifyParent( pListNotify->m_nItem, pListNotify->m_nSubItem, LCN_MODIFIED );
  2294. break;
  2295. }
  2296. InvalidateItem( pListNotify->m_nItem );
  2297. return 0;
  2298. }
  2299. DWORD OnDragEnter( FORMATETC& FormatEtc, STGMEDIUM& StgMedium, DWORD dwKeyState, CPoint point )
  2300. {
  2301. DWORD dwEffect = DROPEFFECT_NONE;
  2302. if ( FormatEtc.cfFormat == m_nHeaderClipboardFormat )
  2303. {
  2304. LPBYTE lpDragHeader = (LPBYTE)GlobalLock( StgMedium.hGlobal );
  2305. if ( lpDragHeader == NULL )
  2306. return DROPEFFECT_NONE;
  2307. // dragged column must originate from this control
  2308. if ( *( (HWND*)lpDragHeader ) == m_hWnd )
  2309. dwEffect = DropColumn( point ) ? DROPEFFECT_MOVE : DROPEFFECT_NONE;
  2310. GlobalUnlock( StgMedium.hGlobal );
  2311. }
  2312. return dwEffect;
  2313. }
  2314. DWORD OnDragOver( FORMATETC& FormatEtc, STGMEDIUM& StgMedium, DWORD dwKeyState, CPoint point )
  2315. {
  2316. DWORD dwEffect = DROPEFFECT_NONE;
  2317. if ( FormatEtc.cfFormat == m_nHeaderClipboardFormat )
  2318. {
  2319. LPBYTE lpDragHeader = (LPBYTE)GlobalLock( StgMedium.hGlobal );
  2320. if ( lpDragHeader == NULL )
  2321. return DROPEFFECT_NONE;
  2322. // dragged column must originate from this control
  2323. if ( *( (HWND*)lpDragHeader ) == m_hWnd )
  2324. dwEffect = DropColumn( point ) ? DROPEFFECT_MOVE : DROPEFFECT_NONE;
  2325. GlobalUnlock( StgMedium.hGlobal );
  2326. }
  2327. return dwEffect;
  2328. }
  2329. BOOL OnDrop( FORMATETC& FormatEtc, STGMEDIUM& StgMedium, DWORD dwEffect, CPoint point )
  2330. {
  2331. if ( FormatEtc.cfFormat == m_nHeaderClipboardFormat )
  2332. {
  2333. if ( m_nDragColumn != NULL_COLUMN && m_nHotDivider != NULL_COLUMN )
  2334. {
  2335. CListColumn listColumn;
  2336. if ( !GetColumn( m_nDragColumn, listColumn ) )
  2337. return FALSE;
  2338. // move column to new position
  2339. m_aColumns.RemoveAt( m_nDragColumn );
  2340. m_aColumns.InsertAt( ( m_nDragColumn < m_nHotColumn ? ( m_nHotDivider == 0 ? 0 : m_nHotDivider - 1 ) : m_nHotDivider ), listColumn );
  2341. Invalidate();
  2342. }
  2343. return TRUE;
  2344. }
  2345. // not supported
  2346. return FALSE;
  2347. }
  2348. void OnDragLeave()
  2349. {
  2350. }
  2351. BOOL OnRenderData( FORMATETC& FormatEtc, STGMEDIUM *pStgMedium, BOOL bDropComplete )
  2352. {
  2353. if ( FormatEtc.cfFormat == m_nHeaderClipboardFormat )
  2354. {
  2355. pStgMedium->tymed = TYMED_HGLOBAL;
  2356. pStgMedium->hGlobal = GlobalAlloc( GMEM_MOVEABLE, sizeof( HWND ) );
  2357. if ( pStgMedium->hGlobal == NULL )
  2358. return FALSE;
  2359. LPBYTE lpDragHeader = (LPBYTE)GlobalLock( pStgMedium->hGlobal );
  2360. if ( lpDragHeader == NULL )
  2361. return FALSE;
  2362. // store this window handle
  2363. *( (HWND*)lpDragHeader ) = m_hWnd;
  2364. GlobalUnlock( pStgMedium->hGlobal );
  2365. return TRUE;
  2366. }
  2367. return FALSE;
  2368. }
  2369. void DoPaint( CDCHandle dcPaint )
  2370. {
  2371. T* pT = static_cast<T*>(this);
  2372. int nContextState = dcPaint.SaveDC();
  2373. pT->DrawBkgnd( dcPaint );
  2374. pT->DrawList( dcPaint );
  2375. pT->DrawSelect( dcPaint );
  2376. pT->DrawHeader( dcPaint );
  2377. dcPaint.RestoreDC( nContextState );
  2378. }
  2379. void DrawBkgnd( CDCHandle dcPaint )
  2380. {
  2381. CRect rcClip;
  2382. if ( dcPaint.GetClipBox( rcClip ) == ERROR )
  2383. return;
  2384. dcPaint.SetBkColor( m_rgbBackground );
  2385. dcPaint.ExtTextOut( rcClip.left, rcClip.top, ETO_OPAQUE, rcClip, _T( "" ), 0, NULL );
  2386. CRect rcClient;
  2387. GetClientRect( rcClient );
  2388. rcClient.top = ( m_bShowHeader ? m_nHeaderHeight : 0 );
  2389. if ( !m_bmpBackground.IsNull() && rcClip.bottom > rcClient.top )
  2390. {
  2391. CSize sizBackground;
  2392. m_bmpBackground.GetSize( sizBackground );
  2393. CDC dcBackgroundImage;
  2394. dcBackgroundImage.CreateCompatibleDC( dcPaint );
  2395. HBITMAP hOldBitmap = dcBackgroundImage.SelectBitmap( m_bmpBackground );
  2396. if ( m_bTileBackground )
  2397. {
  2398. // calculate tile image maximum rows and columns
  2399. div_t divRows = div( rcClient.Height(), sizBackground.cy );
  2400. int nTileRows = divRows.rem > 0 ? divRows.quot + 1 : divRows.quot;
  2401. div_t divColumns = div( rcClient.Width(), sizBackground.cx );
  2402. int nTileColumns = divColumns.rem > 0 ? divColumns.quot + 1 : divColumns.quot;
  2403. // draw tiled background image
  2404. for ( int nRow = 0; nRow <= nTileRows; nRow++ )
  2405. {
  2406. for ( int nColumn = 0; nColumn <= nTileColumns; nColumn++ )
  2407. dcPaint.BitBlt( nColumn * sizBackground.cx, nRow * sizBackground.cy, sizBackground.cx, sizBackground.cy, dcBackgroundImage, 0, 0, SRCCOPY );
  2408. }
  2409. }
  2410. else
  2411. {
  2412. CRect rcCentreImage( rcClient );
  2413. // horizontally centre image if smaller than the client width
  2414. if ( sizBackground.cx < rcClient.Width() )
  2415. {
  2416. rcCentreImage.left = ( rcClient.Width() / 2 ) - (int)( sizBackground.cx / 2 );
  2417. rcCentreImage.right = rcCentreImage.left + sizBackground.cx;
  2418. }
  2419. // vertically centre image if smaller than the client height
  2420. if ( sizBackground.cy + 16 < rcClient.Height() )
  2421. {
  2422. rcCentreImage.top = ( rcClient.Height() / 2 ) - (int)( ( sizBackground.cy + 16 ) / 2 );
  2423. rcCentreImage.bottom = rcCentreImage.top + sizBackground.cy;
  2424. }
  2425. // draw centred background image
  2426. dcPaint.BitBlt( rcCentreImage.left, rcCentreImage.top, rcCentreImage.Width(), rcCentreImage.Height(), dcBackgroundImage, 0, 0, SRCCOPY );
  2427. }
  2428. dcBackgroundImage.SelectBitmap( hOldBitmap );
  2429. }
  2430. }
  2431. void DrawHeader( CDCHandle dcPaint )
  2432. {
  2433. if ( !m_bShowHeader )
  2434. return;
  2435. CRect rcClip;
  2436. if ( dcPaint.GetClipBox( rcClip ) == ERROR )
  2437. return;
  2438. CRect rcHeader;
  2439. GetClientRect( rcHeader );
  2440. rcHeader.bottom = m_nHeaderHeight;
  2441. if ( rcClip.top > rcHeader.bottom )
  2442. return;
  2443. if ( !m_bShowThemed || m_thmHeader.IsThemeNull() )
  2444. {
  2445. dcPaint.SetBkColor( m_rgbHeaderBackground );
  2446. dcPaint.ExtTextOut( rcHeader.left, rcHeader.top, ETO_OPAQUE, rcHeader, _T( "" ), 0, NULL );
  2447. }
  2448. CPen penHighlight;
  2449. penHighlight.CreatePen( PS_SOLID, 1, m_rgbHeaderBorder );
  2450. CPen penShadow;
  2451. penShadow.CreatePen( PS_SOLID, 1, m_rgbHeaderShadow );
  2452. CRect rcHeaderItem( rcHeader );
  2453. rcHeaderItem.OffsetRect( -GetScrollPos( SB_HORZ ), 0 );
  2454. int nHeaderWidth = 0;
  2455. for ( int nColumn = 0, nColumnCount = GetColumnCount(); nColumn < nColumnCount; rcHeaderItem.left = rcHeaderItem.right, nColumn++ )
  2456. {
  2457. CListColumn listColumn;
  2458. if ( !GetColumn( nColumn, listColumn ) )
  2459. break;
  2460. rcHeaderItem.right = rcHeaderItem.left + listColumn.m_nWidth;
  2461. nHeaderWidth += rcHeaderItem.Width();
  2462. if ( rcHeaderItem.right < rcClip.left )
  2463. continue;
  2464. if ( rcHeaderItem.left > rcClip.right )
  2465. break;
  2466. // draw header and divider
  2467. if ( m_bShowThemed && !m_thmHeader.IsThemeNull() )
  2468. m_thmHeader.DrawThemeBackground( dcPaint, HP_HEADERITEM, nColumn == m_nHighlightColumn ? HIS_PRESSED : ( nColumn == m_nHotColumn ? HIS_HOT : HIS_NORMAL ), rcHeaderItem, NULL );
  2469. else
  2470. {
  2471. if ( nColumn == m_nHighlightColumn )
  2472. {
  2473. dcPaint.SetBkColor( m_rgbHeaderHighlight );
  2474. dcPaint.ExtTextOut( rcHeaderItem.left, rcHeaderItem.top, ETO_OPAQUE, rcHeaderItem, _T( "" ), 0, NULL );
  2475. }
  2476. dcPaint.SelectPen( penShadow );
  2477. dcPaint.MoveTo( rcHeaderItem.right - 1, rcHeaderItem.top + 4 );
  2478. dcPaint.LineTo( rcHeaderItem.right - 1, m_nHeaderHeight - 4 );
  2479. dcPaint.SelectPen( penHighlight );
  2480. dcPaint.MoveTo( rcHeaderItem.right, rcHeaderItem.top + 4 );
  2481. dcPaint.LineTo( rcHeaderItem.right, m_nHeaderHeight - 4 );
  2482. }
  2483. CRect rcHeaderText( rcHeaderItem );
  2484. rcHeaderText.left += nColumn == 0 ? 4 : 3;
  2485. rcHeaderText.OffsetRect( 0, 1 );
  2486. BOOL bShowArrow = m_bShowSort && ( rcHeaderItem.Width() > 15 );
  2487. // offset text bounding rectangle to account for sorting arrow
  2488. if ( bShowArrow && !listColumn.m_bFixed && listColumn.m_nIndex == m_nSortColumn )
  2489. rcHeaderText.right -= 15;
  2490. // margin header text
  2491. rcHeaderText.DeflateRect( 4, 0, 5, 0 );
  2492. // has this header item an associated image?
  2493. if ( listColumn.m_nImage != ITEM_IMAGE_NONE )
  2494. {
  2495. CSize sizeIcon;
  2496. m_ilListItems.GetIconSize( sizeIcon );
  2497. CRect rcHeaderImage;
  2498. rcHeaderImage.left = listColumn.m_strText.IsEmpty() ? ( ( rcHeaderText.left + rcHeaderText.right ) / 2 ) - ( sizeIcon.cx / 2 ) - ( ( !m_bShowThemed || m_thmHeader.IsThemeNull() ) ? 0 : 1 ) : rcHeaderText.left;
  2499. rcHeaderImage.right = min( rcHeaderImage.left + sizeIcon.cx, rcHeaderItem.right - 2 );
  2500. rcHeaderImage.top = ( ( rcHeaderItem.top + rcHeaderItem.bottom ) / 2 ) - ( sizeIcon.cy / 2 );
  2501. rcHeaderImage.bottom = min( rcHeaderImage.top + sizeIcon.cy, rcHeaderItem.bottom );
  2502. m_ilListItems.DrawEx( listColumn.m_nImage, dcPaint, rcHeaderImage, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT );
  2503. // offset header text (for image)
  2504. rcHeaderText.left += sizeIcon.cx + 4;
  2505. }
  2506. dcPaint.SelectFont( m_fntListFont );
  2507. dcPaint.SetTextColor( m_rgbHeaderText );
  2508. dcPaint.SetBkMode( TRANSPARENT );
  2509. UINT nFormat = DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_END_ELLIPSIS;
  2510. if ( listColumn.m_nFlags & ITEM_FLAGS_CENTRE )
  2511. nFormat |= DT_CENTER;
  2512. else if ( listColumn.m_nFlags & ITEM_FLAGS_RIGHT )
  2513. nFormat |= DT_RIGHT;
  2514. else
  2515. nFormat |= DT_LEFT;
  2516. // draw header text
  2517. if ( !rcHeaderText.IsRectEmpty() && !listColumn.m_strText.IsEmpty() )
  2518. dcPaint.DrawText( listColumn.m_strText, listColumn.m_strText.GetLength(), rcHeaderText, nFormat );
  2519. // draw sorting arrow
  2520. if ( bShowArrow && !listColumn.m_bFixed && listColumn.m_nIndex == m_nSortColumn )
  2521. {
  2522. CSize sizeIcon;
  2523. m_ilListItems.GetIconSize( sizeIcon );
  2524. CRect rcSortArrow;
  2525. rcSortArrow.left = rcHeaderText.right + 4;
  2526. rcSortArrow.right = min( rcSortArrow.left + sizeIcon.cx, rcHeaderItem.right );
  2527. rcSortArrow.top = rcHeaderItem.Height() / 2 - 3;
  2528. rcSortArrow.bottom = min( rcSortArrow.top + sizeIcon.cy, rcHeaderItem.bottom );
  2529. m_ilListItems.DrawEx( m_bSortAscending ? ITEM_IMAGE_UP : ITEM_IMAGE_DOWN, dcPaint, rcSortArrow, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT );
  2530. }
  2531. }
  2532. // draw remaining blank header
  2533. if ( m_bShowThemed && !m_thmHeader.IsThemeNull() && nHeaderWidth < rcHeader.Width() )
  2534. m_thmHeader.DrawThemeBackground( dcPaint, HP_HEADERITEM, HIS_NORMAL, CRect( nHeaderWidth, rcHeader.top, rcHeader.right + 2, rcHeader.bottom ), NULL );
  2535. // draw a frame around all header columns
  2536. if ( ( !m_bShowThemed || m_thmHeader.IsThemeNull() ) && nHeaderWidth > 0 )
  2537. dcPaint.Draw3dRect( CRect( rcHeader.left, rcHeader.top, rcHeader.right + 2, rcHeader.bottom ), m_rgbHeaderBorder, m_rgbHeaderShadow );
  2538. }
  2539. void DrawRoundRect( CDCHandle dcPaint, CRect& rcRect, COLORREF rgbOuter, COLORREF rgbInner )
  2540. {
  2541. CRect rcRoundRect( rcRect );
  2542. CPen penBorder;
  2543. penBorder.CreatePen( PS_SOLID, 1, rgbOuter );
  2544. CBrush bshInterior;
  2545. bshInterior.CreateSolidBrush( m_rgbBackground );
  2546. dcPaint.SelectPen( penBorder );
  2547. dcPaint.SelectBrush( bshInterior );
  2548. dcPaint.RoundRect( rcRoundRect, CPoint( 5, 5 ) );
  2549. rcRoundRect.DeflateRect( 1, 1 );
  2550. CPen penInnerBorder;
  2551. penInnerBorder.CreatePen( PS_SOLID, 1, rgbInner );
  2552. dcPaint.SelectPen( penInnerBorder );
  2553. dcPaint.RoundRect( rcRoundRect, CPoint( 2, 2 ) );
  2554. }
  2555. void DrawGradient( CDCHandle dcPaint, CRect& rcRect, COLORREF rgbTop, COLORREF rgbBottom )
  2556. {
  2557. GRADIENT_RECT grdRect = { 0, 1 };
  2558. TRIVERTEX triVertext[ 2 ] = {
  2559. rcRect.left,
  2560. rcRect.top,
  2561. GetRValue( rgbTop ) << 8,
  2562. GetGValue( rgbTop ) << 8,
  2563. GetBValue( rgbTop ) << 8,
  2564. 0x0000,
  2565. rcRect.right,
  2566. rcRect.bottom,
  2567. GetRValue( rgbBottom ) << 8,
  2568. GetGValue( rgbBottom ) << 8,
  2569. GetBValue( rgbBottom ) << 8,
  2570. 0x0000
  2571. };
  2572. dcPaint.GradientFill( triVertext, 2, &grdRect, 1, GRADIENT_FILL_RECT_V );
  2573. }
  2574. void DrawList( CDCHandle dcPaint )
  2575. {
  2576. T* pT = static_cast<T*>(this);
  2577. CRect rcClip;
  2578. if ( dcPaint.GetClipBox( rcClip ) == ERROR )
  2579. return;
  2580. CRect rcItem;
  2581. rcItem.left = -GetScrollPos( SB_HORZ );
  2582. rcItem.right = GetTotalWidth();
  2583. rcItem.top = ( m_bShowHeader ? m_nHeaderHeight : 0 );
  2584. rcItem.bottom = rcItem.top;
  2585. // draw all visible items
  2586. for ( int nItem = GetTopItem(); nItem < pT->GetItemCount(); rcItem.top = rcItem.bottom, nItem++ )
  2587. {
  2588. rcItem.bottom = rcItem.top + m_nItemHeight;
  2589. if ( rcItem.bottom < rcClip.top || rcItem.right < rcClip.left )
  2590. continue;
  2591. if ( rcItem.top > rcClip.bottom || rcItem.left > rcClip.right )
  2592. break;
  2593. // may be implemented in a derived class
  2594. pT->DrawItem( dcPaint, nItem, rcItem );
  2595. }
  2596. }
  2597. void DrawItem( CDCHandle dcPaint, int nItem, CRect& rcItem )
  2598. {
  2599. T* pT = static_cast<T*>(this);
  2600. CRect rcClip;
  2601. if ( dcPaint.GetClipBox( rcClip ) == ERROR )
  2602. return;
  2603. int nFocusItem = NULL_ITEM;
  2604. int nFocusSubItem = NULL_SUBITEM;
  2605. GetFocusItem( nFocusItem, nFocusSubItem );
  2606. BOOL bSelectedItem = IsSelected( nItem );
  2607. BOOL bControlFocus = ( GetFocus() == m_hWnd || m_bEditItem );
  2608. // draw selected background
  2609. if ( bSelectedItem )
  2610. {
  2611. if ( m_bShowThemed && !m_thmHeader.IsThemeNull() )
  2612. {
  2613. // draw select border
  2614. DrawRoundRect( dcPaint, rcItem, bControlFocus ? m_rgbSelectOuter : m_rgbNoFocusOuter, bControlFocus ? m_rgbSelectInner : m_rgbNoFocusInner );
  2615. CRect rcSelect( rcItem );
  2616. rcSelect.DeflateRect( 2, 2 );
  2617. // fill selected area
  2618. DrawGradient( dcPaint, rcSelect, bControlFocus ? m_rgbSelectTop : m_rgbNoFocusTop, bControlFocus ? m_rgbSelectBottom : m_rgbNoFocusBottom );
  2619. }
  2620. else
  2621. {
  2622. dcPaint.SetBkColor( m_rgbSelectedItem );
  2623. dcPaint.ExtTextOut( rcItem.left, rcItem.top, ETO_OPAQUE, rcItem, _T( "" ), 0, NULL );
  2624. }
  2625. }
  2626. CRect rcSubItem( rcItem );
  2627. rcSubItem.right = rcSubItem.left;
  2628. for ( int nSubItem = 0, nColumnCount = GetColumnCount(); nSubItem < nColumnCount; rcSubItem.left = rcSubItem.right + 1, nSubItem++ )
  2629. {
  2630. CListColumn listColumn;
  2631. if ( !GetColumn( nSubItem, listColumn ) )
  2632. break;
  2633. rcSubItem.right = rcSubItem.left + listColumn.m_nWidth - 1;
  2634. if ( rcSubItem.right < rcClip.left || rcSubItem.Width() == 0 )
  2635. continue;
  2636. if ( rcSubItem.left > rcClip.right )
  2637. break;
  2638. CString strItemText = pT->GetItemText( nItem, listColumn.m_nIndex );
  2639. int nItemImage = pT->GetItemImage( nItem, listColumn.m_nIndex );
  2640. UINT nItemFormat = pT->GetItemFormat( nItem, listColumn.m_nIndex );
  2641. UINT nItemFlags = pT->GetItemFlags( nItem, listColumn.m_nIndex );
  2642. // custom draw subitem format
  2643. if ( nItemFormat == ITEM_FORMAT_CUSTOM )
  2644. {
  2645. pT->DrawCustomItem( dcPaint, nItem, nSubItem, rcSubItem );
  2646. return;
  2647. }
  2648. BOOL bFocusSubItem = ( m_bFocusSubItem && nFocusItem == nItem && nFocusSubItem == nSubItem );
  2649. COLORREF rgbBackground = m_rgbBackground;
  2650. COLORREF rgbText = m_rgbItemText;
  2651. if ( bFocusSubItem )
  2652. {
  2653. if ( m_bShowThemed && !m_thmHeader.IsThemeNull() )
  2654. {
  2655. // only draw subitem focus if control has focus
  2656. if ( bControlFocus )
  2657. {
  2658. // draw select border
  2659. DrawRoundRect( dcPaint, rcSubItem, bControlFocus ? m_rgbSelectOuter : m_rgbNoFocusOuter, bControlFocus ? m_rgbSelectInner : m_rgbNoFocusInner );
  2660. CRect rcSelect( rcSubItem );
  2661. rcSelect.DeflateRect( 2, 2 );
  2662. // fill selected area
  2663. if ( !m_bEditItem )
  2664. DrawGradient( dcPaint, rcSelect, m_rgbFocusTop, m_rgbFocusBottom );
  2665. else
  2666. {
  2667. dcPaint.SetBkColor( m_rgbBackground );
  2668. dcPaint.ExtTextOut( rcSelect.left, rcSelect.top, ETO_OPAQUE, rcSelect, _T( "" ), 0, NULL );
  2669. }
  2670. }
  2671. }
  2672. else
  2673. {
  2674. dcPaint.SetBkColor( m_bEditItem ? m_rgbBackground : m_rgbItemFocus );
  2675. dcPaint.ExtTextOut( rcSubItem.left, rcSubItem.top, ETO_OPAQUE, rcSubItem, _T( "" ), 0, NULL );
  2676. if ( m_bEditItem )
  2677. {
  2678. CBrush bshSelectFrame;
  2679. bshSelectFrame.CreateSolidBrush( m_rgbItemFocus );
  2680. dcPaint.FrameRect( rcSubItem, bshSelectFrame );
  2681. }
  2682. }
  2683. }
  2684. else if ( pT->GetItemColours( nItem, nSubItem, rgbBackground, rgbText ) && rgbBackground != m_rgbBackground )
  2685. {
  2686. CPen penBorder;
  2687. penBorder.CreatePen( PS_SOLID, 1, rgbBackground );
  2688. CBrush bshInterior;
  2689. bshInterior.CreateSolidBrush( rgbBackground );
  2690. dcPaint.SelectPen( penBorder );
  2691. dcPaint.SelectBrush( bshInterior );
  2692. dcPaint.RoundRect( rcSubItem, CPoint( 3, 3 ) );
  2693. }
  2694. CRect rcItemText( rcSubItem );
  2695. // margin item text
  2696. rcItemText.left += nSubItem == 0 ? 4 : 3;
  2697. rcItemText.DeflateRect( 4, 0 );
  2698. // draw subitem image if supplied
  2699. if ( !m_ilItemImages.IsNull() && nItemImage != ITEM_IMAGE_NONE && ( !m_bEditItem || ( m_bEditItem && !bFocusSubItem ) ) )
  2700. {
  2701. CSize sizeIcon;
  2702. m_ilItemImages.GetIconSize( sizeIcon );
  2703. CRect rcItemImage;
  2704. rcItemImage.left = strItemText.IsEmpty() ? ( ( rcItemText.left + rcItemText.right ) / 2 ) - ( sizeIcon.cx / 2 ) - ( ( !m_bShowThemed || m_thmHeader.IsThemeNull() ) ? 0 : 1 ) : rcItemText.left;
  2705. rcItemImage.right = min( rcItemImage.left + sizeIcon.cx, rcSubItem.right );
  2706. rcItemImage.top = ( ( rcSubItem.top + rcSubItem.bottom ) / 2 ) - ( sizeIcon.cy / 2 );
  2707. rcItemImage.bottom = min( rcItemImage.top + sizeIcon.cy, rcSubItem.bottom );
  2708. m_ilItemImages.DrawEx( nItemImage, dcPaint, rcItemImage, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT );
  2709. // offset item text (for image)
  2710. rcItemText.left += sizeIcon.cx + 4;
  2711. }
  2712. if ( rcItemText.IsRectEmpty() )
  2713. continue;
  2714. dcPaint.SelectFont( pT->GetItemFont( nItem, nSubItem ) );
  2715. dcPaint.SetTextColor( ( ( !m_bShowThemed || m_thmHeader.IsThemeNull() ) && bSelectedItem && !bFocusSubItem ) ? m_rgbSelectedText : rgbText );
  2716. dcPaint.SetBkMode( TRANSPARENT );
  2717. UINT nFormat = DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_END_ELLIPSIS;
  2718. if ( nItemFlags & ITEM_FLAGS_CENTRE )
  2719. nFormat |= DT_CENTER;
  2720. else if ( nItemFlags & ITEM_FLAGS_RIGHT )
  2721. nFormat |= DT_RIGHT;
  2722. else
  2723. nFormat |= DT_LEFT;
  2724. switch ( nItemFormat )
  2725. {
  2726. case ITEM_FORMAT_DATETIME: if ( !strItemText.IsEmpty() )
  2727. {
  2728. SYSTEMTIME stItemDate;
  2729. if ( !GetItemDate( nItem, listColumn.m_nIndex, stItemDate ) )
  2730. break;
  2731. CString strItemDate;
  2732. if ( nItemFlags & ITEM_FLAGS_DATE_ONLY )
  2733. strItemDate = FormatDate( stItemDate );
  2734. else if ( nItemFlags & ITEM_FLAGS_TIME_ONLY )
  2735. strItemDate = FormatTime( stItemDate );
  2736. else
  2737. strItemDate = FormatDate( stItemDate ) + _T( " " ) + FormatTime( stItemDate );
  2738. dcPaint.DrawText( strItemDate, strItemDate.GetLength(), rcItemText, nFormat );
  2739. }
  2740. break;
  2741. case ITEM_FORMAT_CHECKBOX:
  2742. case ITEM_FORMAT_CHECKBOX_3STATE: {
  2743. CSize sizeIcon;
  2744. m_ilListItems.GetIconSize( sizeIcon );
  2745. CRect rcCheckBox;
  2746. rcCheckBox.left = ( ( rcItemText.left + rcItemText.right ) / 2 ) - ( sizeIcon.cx / 2 ) - 1;
  2747. rcCheckBox.right = min( rcCheckBox.left + sizeIcon.cx, rcSubItem.right );
  2748. rcCheckBox.top = ( ( rcSubItem.top + rcSubItem.bottom ) / 2 ) - ( sizeIcon.cy / 2 );
  2749. rcCheckBox.bottom = min( rcCheckBox.top + sizeIcon.cy, rcSubItem.bottom );
  2750. int nCheckValue = _ttoi( strItemText );
  2751. if ( nItemFormat == ITEM_FORMAT_CHECKBOX )
  2752. m_ilListItems.DrawEx( nCheckValue > 0 ? ITEM_IMAGE_CHECK_ON : ITEM_IMAGE_CHECK_OFF, dcPaint, rcCheckBox, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT );
  2753. else
  2754. {
  2755. int nCheckImage = ITEM_IMAGE_3STATE_UNDEF;
  2756. if ( nCheckValue < 0 )
  2757. nCheckImage = ITEM_IMAGE_3STATE_OFF;
  2758. else if ( nCheckValue > 0 )
  2759. nCheckImage = ITEM_IMAGE_3STATE_ON;
  2760. m_ilListItems.DrawEx( nCheckImage, dcPaint, rcCheckBox, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT );
  2761. }
  2762. }
  2763. break;
  2764. case ITEM_FORMAT_PROGRESS: if ( m_bShowThemed && !m_thmProgress.IsThemeNull() && !( nItemFlags & ITEM_FLAGS_PROGRESS_SOLID ) )
  2765. {
  2766. // draw progress frame
  2767. CRect rcProgress( rcSubItem );
  2768. rcProgress.DeflateRect( 3, 2 );
  2769. m_thmProgress.DrawThemeBackground( dcPaint, PP_BAR, 0, rcProgress, NULL );
  2770. // draw progress bar
  2771. rcProgress.DeflateRect( 3, 3, 2, 3 );
  2772. rcProgress.right = rcProgress.left + (int)( (double)rcProgress.Width() * ( ( max( min( _tstof( strItemText ), 100 ), 0 ) ) / 100.0 ) );
  2773. m_thmProgress.DrawThemeBackground( dcPaint, PP_CHUNK, 0, rcProgress, NULL );
  2774. }
  2775. else
  2776. {
  2777. CRect rcProgress( rcSubItem );
  2778. rcProgress.DeflateRect( 3, 2 );
  2779. // draw progress border
  2780. DrawRoundRect( dcPaint, rcProgress, m_rgbHeaderShadow, m_rgbHeaderBackground );
  2781. // fill progress bar area
  2782. rcProgress.DeflateRect( 3, 3 );
  2783. rcProgress.right = rcProgress.left + (int)( (double)rcProgress.Width() * ( ( max( min( _tstof( strItemText ), 100 ), 0 ) ) / 100.0 ) );
  2784. DrawGradient( dcPaint, rcProgress, m_rgbProgressTop, m_rgbProgressBottom );
  2785. }
  2786. break;
  2787. case ITEM_FORMAT_HYPERLINK: if ( nItem == m_nHotItem && nSubItem == m_nHotSubItem && !( nItemFlags & ITEM_FLAGS_READ_ONLY ) )
  2788. {
  2789. dcPaint.SelectFont( m_fntUnderlineFont );
  2790. dcPaint.SetTextColor( m_rgbHyperLink );
  2791. }
  2792. default: // draw item text
  2793. if ( !strItemText.IsEmpty() )
  2794. dcPaint.DrawText( strItemText, strItemText.GetLength(), rcItemText, nFormat );
  2795. break;
  2796. }
  2797. }
  2798. }
  2799. void DrawSelect( CDCHandle dcPaint )
  2800. {
  2801. if ( !m_bGroupSelect )
  2802. return;
  2803. int nHorzScroll = GetScrollPos( SB_HORZ );
  2804. int nVertScroll = GetScrollPos( SB_VERT );
  2805. CRect rcGroupSelect( m_rcGroupSelect );
  2806. rcGroupSelect.OffsetRect( -nHorzScroll, -nVertScroll );
  2807. CRect rcClient;
  2808. GetClientRect( rcClient );
  2809. rcClient.top = ( m_bShowHeader ? m_nHeaderHeight : 0 );
  2810. // limit box to list client area if scrolled to limits
  2811. if ( nHorzScroll > ( GetTotalWidth() - rcClient.Width() ) )
  2812. rcGroupSelect.right = min( rcClient.right, rcGroupSelect.right );
  2813. if ( nHorzScroll == 0 )
  2814. rcGroupSelect.left = max( rcClient.left, rcGroupSelect.left );
  2815. if ( nVertScroll > ( GetTotalHeight() - rcClient.Height() ) )
  2816. rcGroupSelect.bottom = min( rcClient.bottom, rcGroupSelect.bottom );
  2817. if ( nVertScroll == 0 )
  2818. rcGroupSelect.top = max( rcClient.top, rcGroupSelect.top );
  2819. // limit bitmap to client area
  2820. CRect rcSelectArea( rcGroupSelect );
  2821. rcSelectArea.IntersectRect( rcSelectArea, rcClient );
  2822. CDC dcBackground;
  2823. dcBackground.CreateCompatibleDC( dcPaint );
  2824. int nBackgroundContext = dcBackground.SaveDC();
  2825. CBitmap bmpBackground;
  2826. bmpBackground.CreateCompatibleBitmap( dcPaint, rcSelectArea.Width(), rcSelectArea.Height() ); 
  2827. dcBackground.SelectBitmap( bmpBackground );
  2828. // take a copy of existing backgroud
  2829. dcBackground.BitBlt( 0, 0, rcSelectArea.Width(), rcSelectArea.Height(), dcPaint, rcSelectArea.left, rcSelectArea.top, SRCCOPY );
  2830. CDC dcGroupSelect;
  2831. dcGroupSelect.CreateCompatibleDC( dcPaint );
  2832. int nGroupSelectContext = dcGroupSelect.SaveDC();
  2833. CBitmap bmpGroupSelect;
  2834. bmpGroupSelect.CreateCompatibleBitmap( dcPaint, rcSelectArea.Width(), rcSelectArea.Height() ); 
  2835. dcGroupSelect.SelectBitmap( bmpGroupSelect );
  2836. // draw group select box
  2837. dcGroupSelect.SetBkColor( ( !m_bShowThemed || m_thmHeader.IsThemeNull() ) ? m_rgbItemFocus : m_rgbSelectedItem );
  2838. dcGroupSelect.ExtTextOut( 0, 0, ETO_OPAQUE, CRect( CPoint( 0 ), rcSelectArea.Size() ), _T( "" ), 0, NULL );
  2839. BLENDFUNCTION blendFunction;
  2840. blendFunction.BlendOp = AC_SRC_OVER;
  2841. blendFunction.BlendFlags = 0;
  2842. blendFunction.SourceConstantAlpha = 180;
  2843. blendFunction.AlphaFormat = 0;
  2844. // blend existing background with selection box
  2845. dcGroupSelect.AlphaBlend( 0, 0, rcSelectArea.Width(), rcSelectArea.Height(), dcBackground, 0, 0, rcSelectArea.Width(), rcSelectArea.Height(), blendFunction ); 
  2846. // draw blended selection box
  2847. dcPaint.BitBlt( rcSelectArea.left, rcSelectArea.top, rcSelectArea.Width(), rcSelectArea.Height(), dcGroupSelect, 0, 0, SRCCOPY );
  2848. // draw selection box frame
  2849. CBrush bshSelectFrame;
  2850. bshSelectFrame.CreateSolidBrush( ( !m_bShowThemed || m_thmHeader.IsThemeNull() ) ? m_rgbItemText : m_rgbSelectedItem );
  2851. dcPaint.FrameRect( rcGroupSelect, bshSelectFrame );
  2852. dcBackground.RestoreDC( nBackgroundContext );
  2853. dcGroupSelect.RestoreDC( nGroupSelectContext );
  2854. }
  2855. void DrawCustomItem( CDCHandle dcPaint, int nItem, int nSubItem, CRect& rcSubItem )
  2856. {
  2857. ATLASSERT( FALSE ); // must be implemented in a derived class
  2858. }
  2859. };
  2860. struct CSubItem
  2861. {
  2862. CString m_strText;
  2863. int m_nImage;
  2864. UINT m_nFormat;
  2865. UINT m_nFlags;
  2866. CListArray < CString > m_aComboList;
  2867. HFONT m_hFont;
  2868. COLORREF m_rgbBackground;
  2869. COLORREF m_rgbText;
  2870. };
  2871. template < class TData = DWORD >
  2872. struct CListItem
  2873. {
  2874. CListArray < CSubItem > m_aSubItems;
  2875. CString m_strToolTip;
  2876. TData m_tData;
  2877. };
  2878. template < class TData >
  2879. class CListCtrlData : public CListImpl< CListCtrlData< TData > >
  2880. {
  2881. public:
  2882. DECLARE_WND_CLASS( _T( "ListCtrl" ) )
  2883. protected:
  2884. CListArray < CListItem< TData > > m_aItems;
  2885. public:
  2886. int AddItem( CListItem< TData >& listItem )
  2887. {
  2888. if ( !m_aItems.Add( listItem ) )
  2889. return -1;
  2890. return CListImpl< CListCtrlData >::AddItem() ? GetItemCount() - 1 : -1;
  2891. }
  2892. int AddItem( LPCTSTR lpszText, int nImage = ITEM_IMAGE_NONE, UINT nFormat = ITEM_FORMAT_NONE, UINT nFlags = ITEM_FLAGS_NONE )
  2893. {
  2894. CSubItem listSubItem;
  2895. listSubItem.m_nImage = ITEM_IMAGE_NONE;
  2896. listSubItem.m_nFormat = nFormat;
  2897. listSubItem.m_nFlags = ValidateFlags( nFlags );
  2898. listSubItem.m_hFont = NULL;
  2899. listSubItem.m_rgbBackground = m_rgbBackground;
  2900. listSubItem.m_rgbText = m_rgbItemText;
  2901. CListItem< TData > listItem;
  2902. for ( int nSubItem = 0; nSubItem < GetColumnCount(); nSubItem++ )
  2903. listItem.m_aSubItems.Add( listSubItem );
  2904. // set item details for first subitem
  2905. listItem.m_aSubItems[ 0 ].m_strText = lpszText;
  2906. listItem.m_aSubItems[ 0 ].m_nImage = nImage;
  2907. return AddItem( listItem );
  2908. }
  2909. BOOL DeleteItem( int nItem )
  2910. {
  2911. if ( nItem < 0 || nItem >= GetItemCount() ) 
  2912. return FALSE;
  2913. return m_aItems.RemoveAt( nItem ) ? CListImpl< CListCtrlData >::DeleteItem( nItem ) : FALSE;
  2914. }
  2915. BOOL DeleteAllItems()
  2916. {
  2917. m_aItems.RemoveAll();
  2918. return CListImpl< CListCtrlData >::DeleteAllItems();
  2919. }
  2920. int GetItemCount()
  2921. {
  2922. return m_aItems.GetSize();
  2923. }
  2924. BOOL GetItem( int nItem, CListItem< TData >& listItem )
  2925. {
  2926. if ( nItem < 0 || nItem >= GetItemCount() ) 
  2927. return FALSE;
  2928. listItem = m_aItems[ nItem ];
  2929. return TRUE;
  2930. }
  2931. BOOL GetSubItem( int nItem, int nSubItem, CSubItem& listSubItem )
  2932. {
  2933. CListItem< TData > listItem;
  2934. if ( !GetItem( nItem, listItem ) )
  2935. return FALSE;
  2936. if ( nSubItem < 0 || nSubItem >= (int)listItem.m_aSubItems.GetSize() )
  2937. return FALSE;
  2938. listSubItem = listItem.m_aSubItems[ nSubItem ];
  2939. return TRUE;
  2940. }
  2941. CString GetItemText( int nItem, int nSubItem )
  2942. {
  2943. CSubItem listSubItem;
  2944. return GetSubItem( nItem, nSubItem, listSubItem ) ? listSubItem.m_strText : _T( "" );
  2945. }
  2946. int GetItemImage( int nItem, int nSubItem )
  2947. {
  2948. CSubItem listSubItem;
  2949. return GetSubItem( nItem, nSubItem, listSubItem ) ? listSubItem.m_nImage : ITEM_IMAGE_NONE;
  2950. }
  2951. UINT GetItemFormat( int nItem, int nSubItem )
  2952. {
  2953. CSubItem listSubItem;
  2954. if ( !GetSubItem( nItem, nSubItem, listSubItem ) )
  2955. return FALSE;
  2956. return listSubItem.m_nFormat == ITEM_FORMAT_NONE ? GetColumnFormat( IndexToOrder( nSubItem ) ) : listSubItem.m_nFormat;
  2957. }
  2958. UINT GetItemFlags( int nItem, int nSubItem )
  2959. {
  2960. CSubItem listSubItem;
  2961. if ( !GetSubItem( nItem, nSubItem, listSubItem ) )
  2962. return FALSE;
  2963. return listSubItem.m_nFlags == ITEM_FLAGS_NONE ? GetColumnFlags( IndexToOrder( nSubItem ) ) : listSubItem.m_nFlags;
  2964. }
  2965. BOOL GetItemComboList( int nItem, int nSubItem, CListArray < CString >& aComboList )
  2966. {
  2967. CSubItem listSubItem;
  2968. if ( !GetSubItem( nItem, nSubItem, listSubItem ) )
  2969. return FALSE;
  2970. aComboList = listSubItem.m_aComboList;
  2971. return aComboList.IsEmpty() ? GetColumnComboList( IndexToOrder( nSubItem ), aComboList ) : !aComboList.IsEmpty();
  2972. }
  2973. HFONT GetItemFont( int nItem, int nSubItem )
  2974. {
  2975. CSubItem listSubItem;
  2976. if ( !GetSubItem( nItem, nSubItem, listSubItem ) )
  2977. return FALSE;
  2978. return listSubItem.m_hFont == NULL ? CListImpl< CListCtrlData >::GetItemFont( nItem, nSubItem ) : listSubItem.m_hFont;
  2979. }
  2980. BOOL GetItemColours( int nItem, int nSubItem, COLORREF& rgbBackground, COLORREF& rgbText )
  2981. {
  2982. CSubItem listSubItem;
  2983. if ( !GetSubItem( nItem, nSubItem, listSubItem ) )
  2984. return FALSE;
  2985. rgbBackground = listSubItem.m_rgbBackground;
  2986. rgbText = listSubItem.m_rgbText;
  2987. return TRUE;
  2988. }
  2989. CString GetItemToolTip( int nItem, int nSubItem )
  2990. {
  2991. CListItem< TData > listItem;
  2992. return GetItem( nItem, listItem ) ? listItem.m_strToolTip : _T( "" );
  2993. }
  2994. BOOL GetItemData( int nItem, TData& tData )
  2995. {
  2996. CListItem< TData > listItem;
  2997. if ( !GetItem( nItem, listItem ) )
  2998. return FALSE;
  2999. tData = listItem.m_tData;
  3000. return TRUE;
  3001. }
  3002. BOOL SetItemText( int nItem, int nSubItem, LPCTSTR lpszText )
  3003. {
  3004. if ( nItem < 0 || nItem >= GetItemCount() ) 
  3005. return FALSE;
  3006. if ( nSubItem < 0 || nSubItem >= (int)m_aItems[ nItem ].m_aSubItems.GetSize() )
  3007. return FALSE;
  3008. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_strText = lpszText;
  3009. return TRUE;
  3010. }
  3011. BOOL SetItemComboIndex( int nItem, int nSubItem, int nIndex )
  3012. {
  3013. CListArray < CString > aComboList;
  3014. if ( !GetItemComboList( nItem, nSubItem, aComboList ) )
  3015. return FALSE;
  3016. return SetItemText( nItem, nSubItem, nIndex < 0 || nIndex >= aComboList.GetSize() ? _T( "" ) : aComboList[ nIndex ] );
  3017. }
  3018. BOOL SetItemImage( int nItem, int nSubItem, int nImage )
  3019. {
  3020. if ( nItem < 0 || nItem >= GetItemCount() ) 
  3021. return FALSE;
  3022. if ( nSubItem < 0 || nSubItem >= (int)m_aItems[ nItem ].m_aSubItems.GetSize() )
  3023. return FALSE;
  3024. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_nImage = nImage;
  3025. return TRUE;
  3026. }
  3027. BOOL SetItemFormat( int nItem, int nSubItem, UINT nFormat, UINT nFlags = ITEM_FLAGS_NONE )
  3028. {
  3029. if ( nItem < 0 || nItem >= GetItemCount() ) 
  3030. return FALSE;
  3031. if ( nSubItem < 0 || nSubItem >= (int)m_aItems[ nItem ].m_aSubItems.GetSize() )
  3032. return FALSE;
  3033. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_nFormat = nFormat;
  3034. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_nFlags = nFlags;
  3035. return TRUE;
  3036. }
  3037. BOOL SetItemFormat( int nItem, int nSubItem, UINT nFormat, UINT nFlags, CListArray < CString >& aComboList )
  3038. {
  3039. if ( nItem < 0 || nItem >= GetItemCount() ) 
  3040. return FALSE;
  3041. if ( nSubItem < 0 || nSubItem >= (int)m_aItems[ nItem ].m_aSubItems.GetSize() )
  3042. return FALSE;
  3043. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_nFormat = nFormat;
  3044. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_nFlags = nFlags;
  3045. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_aComboList = aComboList;
  3046. return TRUE;
  3047. }
  3048. BOOL SetItemFont( int nItem, int nSubItem, HFONT hFont )
  3049. {
  3050. if ( nItem < 0 || nItem >= GetItemCount() ) 
  3051. return FALSE;
  3052. if ( nSubItem < 0 || nSubItem >= (int)m_aItems[ nItem ].m_aSubItems.GetSize() )
  3053. return FALSE;
  3054. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_hFont = hFont;
  3055. return TRUE;
  3056. }
  3057. BOOL SetItemColours( int nItem, int nSubItem, COLORREF rgbBackground, COLORREF rgbText )
  3058. {
  3059. if ( nItem < 0 || nItem >= GetItemCount() )
  3060. return FALSE;
  3061. if ( nSubItem < 0 || nSubItem >= (int)m_aItems[ nItem ].m_aSubItems.GetSize() )
  3062. return FALSE;
  3063. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_rgbBackground = rgbBackground;
  3064. m_aItems[ nItem ].m_aSubItems[ nSubItem ].m_rgbText = rgbText;
  3065. return TRUE;
  3066. }
  3067. void ReverseItems()
  3068. {
  3069. m_aItems.Reverse();
  3070. }
  3071. class CompareItem
  3072. {
  3073. public:
  3074. CompareItem( int nColumn ) : m_nColumn( nColumn ) {}
  3075. inline bool operator() ( const CListItem< TData >& listItem1, const CListItem< TData >& listItem2 )
  3076. {
  3077. return ( listItem1.m_aSubItems[ m_nColumn ].m_strText.Compare( listItem2.m_aSubItems[ m_nColumn ].m_strText ) < 0 );
  3078. }
  3079. protected:
  3080. int m_nColumn;
  3081. };
  3082. void SortItems( int nColumn, BOOL bAscending )
  3083. {
  3084. m_aItems.Sort( CompareItem( nColumn ) );
  3085. }
  3086. BOOL SetItemToolTip( int nItem, LPCTSTR lpszToolTip )
  3087. {
  3088. if ( nItem < 0 || nItem >= GetItemCount() ) 
  3089. return FALSE;
  3090. m_aItems[ nItem ].m_strToolTip = lpszToolTip;
  3091. return TRUE;
  3092. }
  3093. BOOL SetItemData( int nItem, TData& tData )
  3094. {
  3095. if ( nItem < 0 || nItem >= GetItemCount() ) 
  3096. return FALSE;
  3097. m_aItems[ nItem ].m_tData = tData;
  3098. return TRUE;
  3099. }
  3100. };
  3101. typedef CListCtrlData< DWORD > CListCtrl;