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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
CLV_ListView.c
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：104k
源码类别：

VC书籍

开发平台：

Visual C++

CLV_ListView.c：源码内容
  2. ////////////////////////////////////////////////////////////////////////////////
  6. #include "stdafx.h"
  7. #include "globals.h"
  8. #include "resource.h"
  11. ////////////////////////////////////////////////////////////////////////////////
  12. //
  13. typedef enum _CIe_WindowMode
  14. {
  15.     wmQuiescent,
  16.     wmHeader_Click,
  17.     wmHeader_ChangeWidth,
  18.     wmHeader_ChangeOrder,
  20.     wmHScrollbar_DragThumb,
  21.     wmHScrollbar_Scroll_Left,
  22.     wmHScrollbar_Scroll_Right,
  23.     wmHScrollbar_Page_Left,
  24.     wmHScrollbar_Page_Right,
  26.     wmVScrollbar_DragThumb,
  27.     wmVScrollbar_Scroll_Up,
  28.     wmVScrollbar_Scroll_Down,
  29.     wmVScrollbar_Page_Up,
  30.     wmVScrollbar_Page_Down,
  32.     wmList_Click,
  33.     wmList_Drag
  35. } CIe_WindowMode;
  36. //
  37. //
  38. //
  39. typedef struct _CIs_ListView_Column
  40. {
  41.     char* m_pColumnText;
  42.     int m_iColumnWidth;
  43.     DWORD m_dwFlags;
  44.     wp_GetItemText m_pfnTextAccessor;
  45.     wp_GetItemDrawColour m_pfnGetCustomDrawColour;
  46.     CPe_ListColumnAlign m_enAlign;
  48. } CIs_ListView_Column;
  49. //
  50. //
  51. //
  52. typedef struct _CIs_ListView_Item
  53. {
  54.     DWORD m_dwFlags;
  55.     const void* m_pItemData;
  57. } CIs_ListView_Item;
  58. //
  59. //
  60. //
  61. typedef struct _CIs_ListViewData
  62. {
  63.     HWND m_hWnd;
  64.     BOOL m_bInBatch;
  65.     int m_iBatchNesting;
  66.     BOOL m_bHasFocus;
  67.     unsigned int m_iItemHeight;
  68.     int m_iNumItemsOnPage;
  69.     RECT m_rClient;
  70.     RECT m_rHeader;
  71.     RECT m_rList;
  72.     RECT m_rScrollbar_Horiz;
  73.     RECT m_rScrollbar_Horiz_Thumb;
  74.     RECT m_rScrollbar_Vert;
  75.     RECT m_rScrollbar_Vert_Thumb;
  77.     // Columns
  78.     unsigned int m_iNumColumns;
  79.     CIs_ListView_Column* m_pColumns;
  80.     unsigned int* m_piColumnOrder;
  82.     // Items
  83.     CIs_ListView_Item* m_pItems;
  84.     int m_iNumItemsInBuffer;
  85.     int m_iNumItems;
  87.     // Selection, scroll & focus
  88.     int m_iXOrigin;
  89.     int m_iXScrollExtent;
  90.     BOOL m_bScrollBarVisible_Horiz;
  91.     BOOL m_bScrollBarVisible_Vert;
  92.     int m_iFirstVisibleItem;
  93.     int m_iFocusItem;
  94.     int m_iKeyboardAnchor;
  96.     // State
  97.     CIe_WindowMode m_enWindowMode;
  98.     unsigned int m_uiAutorepeatTimer;
  99.     BOOL m_bAutoRepeatFirst;
  100.     BOOL m_bMouseOverScrollbutton;
  101.     int m_iActiveHeaderCol;
  102.     int m_iClickedItem;
  103.     POINT m_ptMouseDown;
  104.     POINT m_ptMouseDown_OnHitItem;
  105.     DWORD m_dwMouseDown_Keys;
  107.     // Callback handlers
  108.     wp_DrawBackgroundRect m_hndlr_DrawBackgroundRect;
  109.     wp_HeaderChanged m_hndlr_HeaderChanged;
  110.     wp_ItemCallback m_hndlr_ItemSelected;
  111.     wp_ItemCallback m_hndlr_ItemAction;
  112.     wp_ItemCallback m_hndlr_ItemDrag;
  113.     wp_ItemSubCallback m_hndlr_ItemRightClick;
  114.     wp_ColHeaderClick m_hndlr_ColHeaderClick;
  115.     wp_UnhandledKeyPress m_hndlr_UnhandledKeyPress;
  117. } CIs_ListViewData;
  118. //
  119. ////////////////////////////////////////////////////////////////////////////////
  122. #define CPC_HEADERCOLLAPSETHRESHOLD 8
  123. #define CPC_HEADERDRAGDISTANCE 16
  124. #define CPC_BUFFERQUANTISATION 128
  125. #define CPC_HEADERDRAG_HTWIDTH 8
  126. #define CPC_HEADERDRAG_DEFAULTWIDTH 100
  127. #define CPC_SCROLLBAR_HORIZ_LINESIZE 10
  128. #define CPC_SCROLLBAR_HORIZ_PAGESIZE 100
  129. #define CPC_SCROLLBAR_MOUSEWHEELAMOUNT 5
  130. #define CPC_TIMERID_AUTOREPEAT 1
  131. #define CPC_LISTDRAGDISTANCE 4
  132. LRESULT CALLBACK exp_ListViewWindowProc(HWND hWnd, UINT uiMessage, WPARAM wParam, LPARAM lParam);
  133. #define CLC_COOLPLAYER_LISTVIEW_WINDOWCLASSNAME "CoolPlayer_ListView"
  134. ////////////////////////////////////////////////////////////////////////////////
  135. //
  136. //
  137. //
  138. CP_HLISTVIEW CLV_Create(HWND hWndParent, const int iX, const int iY, const int iWidth, const int iHeight)
  139. {
  140.     WNDCLASS wcPlaylist;
  141.     HWND hWndWindow;
  142.     CIs_ListViewData* pListData;
  144.     wcPlaylist.style = CS_DBLCLKS;
  145.     wcPlaylist.lpfnWndProc = exp_ListViewWindowProc;
  146.     wcPlaylist.cbClsExtra = 0;
  147.     wcPlaylist.cbWndExtra = 0;
  148.     wcPlaylist.hInstance = GetModuleHandle(NULL);
  149.     wcPlaylist.hIcon = NULL; // We will explicity set our icons (so that we have a nice small icon)
  150.     wcPlaylist.hCursor = NULL;
  151.     wcPlaylist.hbrBackground = (HBRUSH)GetStockObject(HOLLOW_BRUSH); // Prevent the system drawing white over our invaid rgn before we can paint
  152.     wcPlaylist.lpszMenuName = NULL;
  153.     wcPlaylist.lpszClassName = CLC_COOLPLAYER_LISTVIEW_WINDOWCLASSNAME;
  154.     RegisterClass(&wcPlaylist);
  156.     pListData = (CIs_ListViewData*)malloc(sizeof(CIs_ListViewData));
  157.     pListData->m_bInBatch = FALSE;
  158.     pListData->m_iBatchNesting = 0;
  159.     pListData->m_bHasFocus = FALSE;
  160.     pListData->m_iNumColumns = 0;
  161.     pListData->m_pColumns = NULL;
  162.     pListData->m_piColumnOrder = NULL;
  163.     pListData->m_enWindowMode = wmQuiescent;
  164.     pListData->m_uiAutorepeatTimer = 0;
  165.     pListData->m_pItems = NULL;
  166.     pListData->m_iNumItems = 0;
  167.     pListData->m_iNumItemsInBuffer = 0;
  168.     pListData->m_iFirstVisibleItem = 0;
  169.     pListData->m_iXOrigin = 0;
  170.     pListData->m_bScrollBarVisible_Horiz = FALSE;
  171.     pListData->m_iFocusItem = CPC_INVALIDITEM;
  172.     pListData->m_iKeyboardAnchor = CPC_INVALIDITEM;
  174.     // Handlers
  175.     pListData->m_hndlr_DrawBackgroundRect = NULL;
  176.     pListData->m_hndlr_HeaderChanged = NULL;
  177.     pListData->m_hndlr_ItemSelected = NULL;
  178.     pListData->m_hndlr_ItemAction = NULL;
  179.     pListData->m_hndlr_ItemDrag = NULL;
  180.     pListData->m_hndlr_ItemRightClick = NULL;
  181.     pListData->m_hndlr_ColHeaderClick = NULL;
  182.     pListData->m_hndlr_UnhandledKeyPress = NULL;
  184.     hWndWindow = CreateWindowEx(WS_EX_ACCEPTFILES,
  185.                                 CLC_COOLPLAYER_LISTVIEW_WINDOWCLASSNAME,
  186.                                 "",
  187.                                 WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE,
  188.                                 iX, iY, iWidth, iHeight, hWndParent,
  189.                                 NULL,
  190.                                 GetModuleHandle(NULL),
  191.                                 pListData);
  194.     return (CP_HLISTVIEW)pListData;
  195. }
  196. //
  197. //
  198. //
  199. HWND CLV_GetHWND(CP_HLISTVIEW _hListData)
  200. {
  201.     CIs_ListViewData* pListData = (CIs_ListViewData*)_hListData;
  202.     CP_CHECKOBJECT(pListData);
  204.     return pListData->m_hWnd;
  205. }
  206. //
  207. //
  208. //
  209. void CLV_EmptyItems(CIs_ListViewData* pListData)
  210. {
  211.     if(pListData->m_pItems == NULL)
  212.         return;
  214.     free(pListData->m_pItems);
  215.     pListData->m_pItems = NULL;
  216.     pListData->m_iNumItems = 0;
  217.     pListData->m_iNumItemsInBuffer = 0;
  218. }
  219. //
  220. //
  221. //
  222. void CLV_InvalidateWindow(CIs_ListViewData* pListData)
  223. {
  224.     InvalidateRect(pListData->m_hWnd, NULL, FALSE);
  225. }
  226. //
  227. //
  228. //
  229. int CLV_YOffsetToItem(CIs_ListViewData* pListData, const int iYOffset)
  230. {
  231.     return pListData->m_iFirstVisibleItem
  232.            + (int)floor( (float)(iYOffset-pListData->m_rList.top) / (float)pListData->m_iItemHeight);
  233. }
  234. //
  235. //
  236. //
  237. int CLV_GetListRect_Lines(CIs_ListViewData* pListData)
  238. {
  239.     return (int)floor( (float)(pListData->m_rList.bottom-pListData->m_rList.top) / (float)pListData->m_iItemHeight);
  240. }
  241. //
  242. //
  243. //
  244. void CLV_CleanupWindowData(CIs_ListViewData* pListData)
  245. {
  246.     // Free items
  247.     CLV_EmptyItems(pListData);
  249.     // Free columns
  250.     if(pListData->m_pColumns)
  251.     {
  252.         unsigned int iColumnIDX;
  253.         for(iColumnIDX = 0; iColumnIDX < pListData->m_iNumColumns; iColumnIDX++)
  254.         {
  255.             if(pListData->m_pColumns[iColumnIDX].m_pColumnText)
  256.                 free(pListData->m_pColumns[iColumnIDX].m_pColumnText);
  257.         }
  258.     }
  260.     free(pListData);
  261. }
  262. //
  263. //
  264. //
  265. void CLV_DrawText(CPs_DrawContext* pDC, const char* pcString, const RECT* _prTarget, const CPe_ListColumnAlign enAlign)
  266. {
  267.     RECT rDraw;
  268.     UINT uiFlags;
  270.     // Skip this draw if we are totally clipped
  271.     if(_prTarget->right < pDC->m_rClip.left
  272.             || _prTarget->bottom < pDC->m_rClip.top
  273.             || _prTarget->left > pDC->m_rClip.right
  274.             || _prTarget->top > pDC->m_rClip.bottom)
  275.     {
  276.         return;
  277.     }
  279.     rDraw = *_prTarget;
  280.     if(enAlign == lcaLeft)
  281.         uiFlags = DT_LEFT;
  282.     else if(enAlign == lcaCentre)
  283.         uiFlags = DT_CENTER;
  284.     else if(enAlign == lcaRight)
  285.     {
  286.         uiFlags = DT_RIGHT;
  287.         rDraw.right -= 5;
  288.         if(rDraw.right < rDraw.left)
  289.             rDraw.right = rDraw.left;
  290.     }
  291.     else
  292.         uiFlags = 0L;
  294.     OffsetRect(&rDraw, pDC->m_ptOffset.x, pDC->m_ptOffset.y);
  295.     DrawText(pDC->m_dcDraw, pcString, -1, &rDraw, DT_WORD_ELLIPSIS | DT_NOPREFIX | uiFlags);
  296. }
  297. //
  298. //
  299. //
  300. void CLV_UpdateScrollBars(CIs_ListViewData* pListData)
  301. {
  302.     unsigned int _iColIDX;
  303.     int iListRectWidth;
  304.     int iListRectHeight_Lines;
  305.     BOOL bCountedVScrollbar;
  307.     // Get the total width
  308.     pListData->m_iXScrollExtent = 0;
  309.     for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  310.     {
  311.         unsigned int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  312.         if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  313.             continue;
  314.         pListData->m_iXScrollExtent += pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  315.     }
  317.     // Work out available width
  318.     iListRectWidth = pListData->m_rClient.right-pListData->m_rClient.left;
  320.     // - If we need a vertical scrollbar (at this point) - then take this into account
  321.     iListRectHeight_Lines = CLV_GetListRect_Lines(pListData);
  322.     if(iListRectHeight_Lines < pListData->m_iNumItems)
  323.     {
  324.         bCountedVScrollbar = TRUE;
  325.         pListData->m_rList.right = pListData->m_rClient.right - glb_pSkin->mpl_pVScrollBar_TrackUp->m_szSize.cx;
  326.         iListRectWidth -= glb_pSkin->mpl_pVScrollBar_TrackUp->m_szSize.cx;
  327.     }
  328.     else
  329.         bCountedVScrollbar = FALSE;
  331.     // No (horiz) scrollbar needed?
  332.     if(pListData->m_iXScrollExtent <= iListRectWidth)
  333.     {
  334.         pListData->m_rList.bottom = pListData->m_rClient.bottom;
  335.         if(pListData->m_bScrollBarVisible_Horiz == TRUE)
  336.             CLV_InvalidateWindow(pListData);
  337.         pListData->m_bScrollBarVisible_Horiz = FALSE;
  338.         pListData->m_iXOrigin = 0;
  339.         SetRect(&pListData->m_rScrollbar_Horiz, 0, 0, 0, 0);
  340.     }
  341.     else
  342.     {
  343.         int iTrackWidth;
  344.         int iTrackThumbWidth;
  345.         int iTrackThumbPos;
  346.         int iTrackThumbWidth_Min;
  347.         int iTrackThumbWidth_Max;
  349.         pListData->m_rList.bottom = pListData->m_rClient.bottom - glb_pSkin->mpl_pHScrollBar_TrackUp->m_szSize.cy;
  351.         // The presence of this scrollbar may require a vertical scrollbar - take this into account
  352.         if(bCountedVScrollbar == FALSE)
  353.         {
  354.             iListRectHeight_Lines = CLV_GetListRect_Lines(pListData);
  355.             if(iListRectHeight_Lines < pListData->m_iNumItems)
  356.             {
  357.                 bCountedVScrollbar = TRUE;
  358.                 pListData->m_rList.right = pListData->m_rClient.right - glb_pSkin->mpl_pVScrollBar_TrackUp->m_szSize.cx;
  359.                 iListRectWidth -= glb_pSkin->mpl_pVScrollBar_TrackUp->m_szSize.cx;
  360.             }
  361.         }
  363.         // Work out size of scroll track
  364.         iTrackWidth = iListRectWidth - (glb_pSkin->mpl_pHScrollBar_Left->m_pImage->m_szSize.cx
  365.                                         + glb_pSkin->mpl_pHScrollBar_Right->m_pImage->m_szSize.cx);
  367.         // Setup scrollbar
  368.         if(pListData->m_bScrollBarVisible_Horiz == FALSE)
  369.             CLV_InvalidateWindow(pListData);
  370.         pListData->m_bScrollBarVisible_Horiz = TRUE;
  371.         pListData->m_rScrollbar_Horiz = pListData->m_rList;
  372.         pListData->m_rScrollbar_Horiz.top = pListData->m_rList.bottom;
  373.         pListData->m_rScrollbar_Horiz.bottom = pListData->m_rClient.bottom;
  375.         // Limit scroll to fit into window
  376.         if( (pListData->m_iXOrigin + iListRectWidth) > pListData->m_iXScrollExtent)
  377.             pListData->m_iXOrigin = pListData->m_iXScrollExtent - iListRectWidth;
  379.         // Setup track rect
  380.         iTrackThumbWidth = (int)( (( (float)iListRectWidth / (float)pListData->m_iXScrollExtent ) * (float)iTrackWidth));
  381.         iTrackThumbWidth_Min = glb_pSkin->mpl_rHScrollBar_Track_Tile.left
  382.                                + (glb_pSkin->mpl_pHScrollBar_TrackUp->m_szSize.cx - glb_pSkin->mpl_rHScrollBar_Track_Tile.right);
  383.         iTrackThumbWidth_Max = (pListData->m_rScrollbar_Horiz.right - pListData->m_rScrollbar_Horiz.left);
  384.         if(iTrackThumbWidth < iTrackThumbWidth_Min)
  385.             iTrackThumbWidth = iTrackThumbWidth_Min;
  386.         if(iTrackThumbWidth > iTrackThumbWidth_Max)
  387.             iTrackThumbWidth = iTrackThumbWidth_Max;
  388.         pListData->m_rScrollbar_Horiz_Thumb = pListData->m_rScrollbar_Horiz;
  389.         iTrackThumbPos = (int)( (  ((float)pListData->m_iXOrigin / (float)(pListData->m_iXScrollExtent - iListRectWidth)) * (float)(iTrackWidth-iTrackThumbWidth)));
  390.         pListData->m_rScrollbar_Horiz_Thumb.left = iTrackThumbPos + glb_pSkin->mpl_pHScrollBar_Left->m_pImage->m_szSize.cx;
  391.         pListData->m_rScrollbar_Horiz_Thumb.right = pListData->m_rScrollbar_Horiz_Thumb.left + iTrackThumbWidth;
  393.         InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz, FALSE);
  394.     }
  396.     // Vertical scrollbar
  397.     iListRectHeight_Lines = CLV_GetListRect_Lines(pListData);
  398.     if(pListData->m_iNumItems <= iListRectHeight_Lines)
  399.     {
  400.         pListData->m_rList.right = pListData->m_rClient.right;
  401.         pListData->m_rHeader.right = pListData->m_rList.right;
  402.         if(pListData->m_bScrollBarVisible_Vert == TRUE)
  403.             CLV_InvalidateWindow(pListData);
  404.         pListData->m_bScrollBarVisible_Vert = FALSE;
  405.         pListData->m_iFirstVisibleItem = 0;
  406.         SetRect(&pListData->m_rScrollbar_Vert, 0, 0, 0, 0);
  407.     }
  408.     else
  409.     {
  410.         int iTrackHeight;
  411.         int iTrackThumbHeight;
  412.         int iTrackThumbPos;
  413.         int iTrackThumbHeight_Min;
  414.         int iTrackThumbHeight_Max;
  415.         const int iListRectHeight = pListData->m_rList.bottom - pListData->m_rList.top;
  417.         // Work out size of scroll track
  418.         iTrackHeight = iListRectHeight - (glb_pSkin->mpl_pVScrollBar_Up->m_iStateHeight
  419.                                           + glb_pSkin->mpl_pVScrollBar_Down->m_iStateHeight);
  421.         // Setup scrollbar
  422.         pListData->m_rList.right = pListData->m_rClient.right - glb_pSkin->mpl_pVScrollBar_TrackUp->m_szSize.cx;
  423.         pListData->m_rHeader.right = pListData->m_rList.right;
  424.         if(pListData->m_bScrollBarVisible_Vert == FALSE)
  425.             CLV_InvalidateWindow(pListData);
  426.         pListData->m_bScrollBarVisible_Vert = TRUE;
  427.         pListData->m_rScrollbar_Vert = pListData->m_rList;
  428.         pListData->m_rScrollbar_Vert.left = pListData->m_rList.right;
  429.         pListData->m_rScrollbar_Vert.right = pListData->m_rClient.right;
  431.         // Limit scroll to fit into window
  432.         if( (pListData->m_iFirstVisibleItem + iListRectHeight_Lines) > pListData->m_iNumItems)
  433.             pListData->m_iFirstVisibleItem = pListData->m_iNumItems - iListRectHeight_Lines;
  435.         // Setup track rect
  436.         iTrackThumbHeight = (int)( (( (float)iListRectHeight_Lines / (float)pListData->m_iNumItems ) * (float)iTrackHeight));
  437.         iTrackThumbHeight_Min = glb_pSkin->mpl_rVScrollBar_Track_Tile.top
  438.                                 + (glb_pSkin->mpl_pVScrollBar_TrackUp->m_szSize.cy - glb_pSkin->mpl_rVScrollBar_Track_Tile.bottom);
  439.         iTrackThumbHeight_Max = (pListData->m_rScrollbar_Vert.bottom - pListData->m_rScrollbar_Vert.top);
  440.         if(iTrackThumbHeight < iTrackThumbHeight_Min)
  441.             iTrackThumbHeight = iTrackThumbHeight_Min;
  442.         if(iTrackThumbHeight > iTrackThumbHeight_Max)
  443.             iTrackThumbHeight = iTrackThumbHeight_Max;
  444.         pListData->m_rScrollbar_Vert_Thumb = pListData->m_rScrollbar_Vert;
  445.         iTrackThumbPos = (int)( (  ((float)pListData->m_iFirstVisibleItem / (float)(pListData->m_iNumItems - iListRectHeight_Lines)) * (float)(iTrackHeight-iTrackThumbHeight)));
  446.         pListData->m_rScrollbar_Vert_Thumb.top = iTrackThumbPos + pListData->m_rScrollbar_Vert.top + glb_pSkin->mpl_pVScrollBar_Up->m_iStateHeight;
  447.         pListData->m_rScrollbar_Vert_Thumb.bottom = pListData->m_rScrollbar_Vert_Thumb.top + iTrackThumbHeight;
  449.         InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz, FALSE);
  450.     }
  451. }
  452. //
  453. //
  454. //
  455. void CLV_BeginBatch(CP_HLISTVIEW _hListData)
  456. {
  457.     CIs_ListViewData* pListData = (CIs_ListViewData*)_hListData;
  458.     CP_CHECKOBJECT(pListData);
  460.     pListData->m_bInBatch = TRUE;
  461.     pListData->m_iBatchNesting ++;
  462. }
  463. //
  464. //
  465. //
  466. void CLV_EndBatch(CP_HLISTVIEW _hListData)
  467. {
  468.     CIs_ListViewData* pListData = (CIs_ListViewData*)_hListData;
  469.     CP_CHECKOBJECT(pListData);
  471.     pListData->m_iBatchNesting--;
  472.     if(pListData->m_iBatchNesting == 0)
  473.     {
  474.         pListData->m_bInBatch = FALSE;
  475.         CLV_InvalidateWindow(pListData);
  476.         CLV_UpdateScrollBars(pListData);
  477.     }
  478. }
  479. //
  480. //
  481. //
  482. void CLV_Scroll_Horiz(CIs_ListViewData* pListData, const int iPixels)
  483. {
  484.     const int iListRectWidth = pListData->m_rList.right-pListData->m_rList.left;
  485.     int iNewXOrigin;
  487.     iNewXOrigin = pListData->m_iXOrigin + iPixels;
  489.     // Ensure scoll is in range
  490.     if(iNewXOrigin < 0)
  491.         iNewXOrigin = 0;
  492.     if( (iNewXOrigin + iListRectWidth) > pListData->m_iXScrollExtent)
  493.         iNewXOrigin = pListData->m_iXScrollExtent - iListRectWidth;
  495.     // Update only if we have changed the origin
  496.     if(iNewXOrigin != pListData->m_iXOrigin)
  497.     {
  498.         pListData->m_iXOrigin = iNewXOrigin;
  500.         // Update display
  501.         CLV_UpdateScrollBars(pListData);
  502.         CLV_InvalidateWindow(pListData);
  503.     }
  504. }
  505. //
  506. //
  507. //
  508. void CLV_Scroll_Vert(CIs_ListViewData* pListData, const int iLines)
  509. {
  510.     const int iListRectHeight_Lines = CLV_GetListRect_Lines(pListData);
  511.     int iNewFirstVisibleItem;
  513.     iNewFirstVisibleItem = pListData->m_iFirstVisibleItem + iLines;
  515.     // Ensure scoll is in range
  516.     if(iNewFirstVisibleItem < 0)
  517.         iNewFirstVisibleItem = 0;
  518.     if( (iNewFirstVisibleItem + iListRectHeight_Lines) > pListData->m_iNumItems)
  519.         iNewFirstVisibleItem = pListData->m_iNumItems - iListRectHeight_Lines;
  521.     // Update only if we have changed the first visible item
  522.     if(iNewFirstVisibleItem != pListData->m_iFirstVisibleItem)
  523.     {
  524.         pListData->m_iFirstVisibleItem = iNewFirstVisibleItem;
  525.         CLV_UpdateScrollBars(pListData);
  526.         CLV_InvalidateWindow(pListData);
  527.     }
  528. }
  529. //
  530. //
  531. //
  532. void CLV_UpdateWindowDims(CIs_ListViewData* pListData, const int iCX, const int iCY)
  533. {
  534.     // Work out window parts
  535.     pListData->m_rClient.top = 0;
  536.     pListData->m_rClient.left = 0;
  537.     pListData->m_rClient.right = iCX;
  538.     pListData->m_rClient.bottom = iCY;
  540.     pListData->m_rHeader.top = 0;
  541.     pListData->m_rHeader.left = 0;
  542.     pListData->m_rHeader.right = iCX;
  543.     pListData->m_rHeader.bottom = pListData->m_iItemHeight;
  545.     pListData->m_rList.top = pListData->m_rHeader.bottom;
  546.     pListData->m_rList.left = 0;
  547.     pListData->m_rList.right = iCX;
  548.     pListData->m_rList.bottom = iCY;
  550.     CLV_UpdateScrollBars(pListData);
  552.     pListData->m_iNumItemsOnPage = (int)floor( (float)(pListData->m_rList.bottom-pListData->m_rList.top) / (float)pListData->m_iItemHeight);
  553. }
  554. //
  555. //
  556. //
  557. void CLV_DrawBackgroundRect(CIs_ListViewData* pListData, CPs_DrawContext* pDC, const RECT* _prTarget)
  558. {
  559.     // Call the parent and get it to draw into this rect
  560.     RECT rDraw;
  561.     POINT ptParentOffset;
  562.     CPs_DrawContext drawcontext;
  563.     HRGN rgnClip;
  565.     // Skip this draw if there is no handler registered
  566.     if(!pListData->m_hndlr_DrawBackgroundRect)
  567.         return;
  569.     // Skip this draw if we are totally clipped
  570.     if(_prTarget->right < pDC->m_rClip.left
  571.             || _prTarget->bottom < pDC->m_rClip.top
  572.             || _prTarget->left > pDC->m_rClip.right
  573.             || _prTarget->top > pDC->m_rClip.bottom)
  574.     {
  575.         return;
  576.     }
  578.     // Get rect and clip relative to the parent's origin
  579.     IntersectRect(&rDraw, _prTarget, &pDC->m_rClip);
  581.     // Correct our draw context to bring it into our parent's domain
  582.     ptParentOffset.x = 0;
  583.     ptParentOffset.y = 0;
  584.     ClientToScreen(pListData->m_hWnd, &ptParentOffset);
  585.     ScreenToClient(GetParent(pListData->m_hWnd), &ptParentOffset);
  586.     drawcontext = *pDC;
  587.     drawcontext.m_ptOffset.x -= ptParentOffset.x;
  588.     drawcontext.m_ptOffset.y -= ptParentOffset.y;
  589.     drawcontext.m_rClip = rDraw;
  590.     OffsetRect(&drawcontext.m_rClip, ptParentOffset.x, ptParentOffset.y);
  592.     // Setup a GDI clip region
  593.     rgnClip = CreateRectRgn(rDraw.left + pDC->m_ptOffset.x, rDraw.top + pDC->m_ptOffset.y,
  594.                             rDraw.right + pDC->m_ptOffset.x, rDraw.bottom + pDC->m_ptOffset.y);
  595.     SelectClipRgn(drawcontext.m_dcDraw, rgnClip);
  596.     pListData->m_hndlr_DrawBackgroundRect(&drawcontext);
  597.     SelectClipRgn(drawcontext.m_dcDraw, NULL);
  598. }
  599. //
  600. //
  601. //
  602. void CLV_Handle_WM_PAINT(CIs_ListViewData* pListData)
  603. {
  604.     RECT rClient;
  605.     PAINTSTRUCT ps;
  606.     HDC dcPaint;
  607.     HBITMAP hbmSurface, hbmSurface_Old;
  608.     HFONT hfOld;
  609.     CPs_DrawContext drawcontext;
  610.     BOOL bAvoidFlicker;
  612.     // Do some debug checking
  613.     CP_ASSERT(pListData->m_iFocusItem == CPC_INVALIDITEM || (pListData->m_iFocusItem >= 0 && pListData->m_iFocusItem < pListData->m_iNumItems));
  615.     // Prepare for draw
  616.     dcPaint = BeginPaint(pListData->m_hWnd, &ps);
  617.     rClient = pListData->m_rClient;
  618.     GetClipBox(dcPaint, &drawcontext.m_rClip);
  620.     // Null clip rgn?
  621.     if(drawcontext.m_rClip.right == drawcontext.m_rClip.left
  622.             || drawcontext.m_rClip.top == drawcontext.m_rClip.bottom)
  623.     {
  624.         EndPaint(pListData->m_hWnd, &ps);
  625.         return;
  626.     }
  628.     bAvoidFlicker = TRUE;
  629.     if(bAvoidFlicker == TRUE)
  630.     {
  631.         hbmSurface = CreateCompatibleBitmap(dcPaint, drawcontext.m_rClip.right-drawcontext.m_rClip.left, drawcontext.m_rClip.bottom-drawcontext.m_rClip.top);
  632.         CP_ASSERT(hbmSurface);
  633.         drawcontext.m_dcDraw = CreateCompatibleDC(dcPaint);
  634.         CP_ASSERT(drawcontext.m_dcDraw);
  635.         hbmSurface_Old = (HBITMAP)SelectObject(drawcontext.m_dcDraw, hbmSurface);
  637.         drawcontext.m_ptOffset.x = -drawcontext.m_rClip.left;
  638.         drawcontext.m_ptOffset.y = -drawcontext.m_rClip.top;
  639.     }
  640.     else
  641.     {
  642.         hbmSurface = NULL;
  643.         drawcontext.m_dcDraw = dcPaint;
  644.         drawcontext.m_ptOffset.x = 0;
  645.         drawcontext.m_ptOffset.y = 0;
  646.         hbmSurface_Old = NULL;
  647.     }
  649.     // Draw header
  650.     hfOld = (HFONT)SelectObject(drawcontext.m_dcDraw, glb_pSkin->mpl_hfFont);
  651.     {
  652.         int iCursorX;
  653.         unsigned int _iColIDX;
  654.         RECT rHeaderItem;
  656.         // Draw header items
  657.         iCursorX = -pListData->m_iXOrigin;
  658.         SetTextColor(drawcontext.m_dcDraw, glb_pSkin->mpl_ListHeaderColour);
  659.         SetBkMode(drawcontext.m_dcDraw, TRANSPARENT);
  660.         for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  661.         {
  662.             int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  663.             int iTextOffset = 0;
  664.             int iNextCursorX;
  665.             if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  666.                 continue;
  668.             rHeaderItem.left = iCursorX;
  669.             rHeaderItem.right = iCursorX + pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  670.             rHeaderItem.top = pListData->m_rHeader.top;
  671.             rHeaderItem.bottom = pListData->m_rHeader.bottom;
  672.             if(rHeaderItem.right > (pListData->m_rHeader.right - CPC_HEADERCOLLAPSETHRESHOLD))
  673.                 rHeaderItem.right = pListData->m_rHeader.right;
  674.             iNextCursorX = rHeaderItem.right;
  676.             // Draw this header item down - if it's the clicked or dragged header item
  677.             if( (pListData->m_enWindowMode == wmHeader_Click || pListData->m_enWindowMode == wmHeader_ChangeOrder)
  678.                     && iColumnIDX == pListData->m_iActiveHeaderCol)
  679.             {
  680.                 iTextOffset = 1;
  681.                 CPIG_TiledFill(&drawcontext, &rHeaderItem, &glb_pSkin->mpl_rListHeader_SourceTile, glb_pSkin->mpl_pListHeader_Down, CIC_TILEDFILOPTIONS_NONE);
  682.             }
  683.             else
  684.                 CPIG_TiledFill(&drawcontext, &rHeaderItem, &glb_pSkin->mpl_rListHeader_SourceTile, glb_pSkin->mpl_pListHeader_Up, CIC_TILEDFILOPTIONS_NONE);
  686.             rHeaderItem.left += glb_pSkin->mpl_rListHeader_SourceTile.left + iTextOffset;
  687.             rHeaderItem.right -= glb_pSkin->mpl_pListHeader_Down->m_szSize.cx - glb_pSkin->mpl_rListHeader_SourceTile.right;
  688.             rHeaderItem.top += iTextOffset;
  689.             if(pListData->m_pColumns[iColumnIDX].m_pColumnText)
  690.                 CLV_DrawText(&drawcontext, pListData->m_pColumns[iColumnIDX].m_pColumnText, &rHeaderItem, pListData->m_pColumns[iColumnIDX].m_enAlign);
  692.             iCursorX = iNextCursorX;
  693.             if(iCursorX == rClient.right)
  694.                 break;
  695.         }
  697.         // Draw a dummy last column
  698.         if(iCursorX < rClient.right)
  699.         {
  700.             rHeaderItem.left = iCursorX;
  701.             rHeaderItem.right = pListData->m_rHeader.right;
  702.             rHeaderItem.top = pListData->m_rHeader.top;
  703.             rHeaderItem.bottom = pListData->m_rHeader.top + pListData->m_iItemHeight;
  704.             CPIG_TiledFill(&drawcontext, &rHeaderItem, &glb_pSkin->mpl_rListHeader_SourceTile, glb_pSkin->mpl_pListHeader_Up, CIC_TILEDFILOPTIONS_NONE);
  705.         }
  707.     }
  709.     // Draw the (horiz) scrollbar
  710.     if(pListData->m_bScrollBarVisible_Horiz == TRUE)
  711.     {
  712.         RECT rHScrollBarTrack = pListData->m_rScrollbar_Horiz;
  713.         rHScrollBarTrack.left += glb_pSkin->mpl_pHScrollBar_Left->m_pImage->m_szSize.cx;
  714.         rHScrollBarTrack.right -= glb_pSkin->mpl_pHScrollBar_Right->m_pImage->m_szSize.cx;
  716.         // Draw buttons
  717.         CPIG_DrawStateImage( &drawcontext,
  718.                              pListData->m_rScrollbar_Horiz.left,
  719.                              rHScrollBarTrack.top,
  720.                              glb_pSkin->mpl_pHScrollBar_Left,
  721.                              (pListData->m_enWindowMode == wmHScrollbar_Scroll_Left && pListData->m_bMouseOverScrollbutton)
  722.                              ? igsActive : igsQuiescent);
  723.         CPIG_DrawStateImage( &drawcontext,
  724.                              rHScrollBarTrack.right,
  725.                              rHScrollBarTrack.top,
  726.                              glb_pSkin->mpl_pHScrollBar_Right,
  727.                              (pListData->m_enWindowMode == wmHScrollbar_Scroll_Right && pListData->m_bMouseOverScrollbutton)
  728.                              ? igsActive : igsQuiescent);
  730.         // Scrollbar background
  731.         CPIG_TiledFill(&drawcontext, &rHScrollBarTrack, &glb_pSkin->mpl_rHScrollBar_Bk_Tile, glb_pSkin->mpl_pHScrollBar_Bk, CIC_TILEDFILOPTIONS_NONE);
  733.         // Track
  734.         CPIG_TiledFill( &drawcontext,
  735.                         &pListData->m_rScrollbar_Horiz_Thumb,
  736.                         &glb_pSkin->mpl_rHScrollBar_Track_Tile,
  737.                         pListData->m_enWindowMode == wmHScrollbar_DragThumb ? glb_pSkin->mpl_pHScrollBar_TrackDn : glb_pSkin->mpl_pHScrollBar_TrackUp, CIC_TILEDFILOPTIONS_NONE);
  738.     }
  740.     // Draw the (vert) scrollbar
  741.     if(pListData->m_bScrollBarVisible_Vert == TRUE)
  742.     {
  743.         RECT rHeaderPad;
  744.         RECT rVScrollBarTrack = pListData->m_rScrollbar_Vert;
  745.         rVScrollBarTrack.top += glb_pSkin->mpl_pHScrollBar_Left->m_iStateHeight;
  746.         rVScrollBarTrack.bottom -= glb_pSkin->mpl_pHScrollBar_Right->m_iStateHeight;
  748.         // Draw buttons
  749.         CPIG_DrawStateImage( &drawcontext,
  750.                              rVScrollBarTrack.left, pListData->m_rScrollbar_Vert.top,
  751.                              glb_pSkin->mpl_pVScrollBar_Up,
  752.                              (pListData->m_enWindowMode == wmVScrollbar_Scroll_Up && pListData->m_bMouseOverScrollbutton)
  753.                              ? igsActive : igsQuiescent);
  754.         CPIG_DrawStateImage( &drawcontext,
  755.                              rVScrollBarTrack.left, rVScrollBarTrack.bottom,
  756.                              glb_pSkin->mpl_pVScrollBar_Down,
  757.                              (pListData->m_enWindowMode == wmVScrollbar_Scroll_Down && pListData->m_bMouseOverScrollbutton)
  758.                              ? igsActive : igsQuiescent);
  760.         // Scrollbar background
  761.         CPIG_TiledFill(&drawcontext, &rVScrollBarTrack, &glb_pSkin->mpl_rVScrollBar_Bk_Tile, glb_pSkin->mpl_pVScrollBar_Bk, CIC_TILEDFILOPTIONS_NONE);
  763.         // Track
  764.         CPIG_TiledFill( &drawcontext,
  765.                         &pListData->m_rScrollbar_Vert_Thumb,
  766.                         &glb_pSkin->mpl_rVScrollBar_Track_Tile,
  767.                         pListData->m_enWindowMode == wmVScrollbar_DragThumb ? glb_pSkin->mpl_pVScrollBar_TrackDn : glb_pSkin->mpl_pVScrollBar_TrackUp,
  768.                         CIC_TILEDFILOPTIONS_NONE);
  770.         // Draw some background above the scrollbar (and beyond the header area)
  771.         rHeaderPad = pListData->m_rHeader;
  772.         rHeaderPad.left = rHeaderPad.right;
  773.         rHeaderPad.right = pListData->m_rClient.right;
  774.         CLV_DrawBackgroundRect(pListData, &drawcontext, &rHeaderPad);
  775.     }
  777.     // Draw a background area in the gap between the 2 scrollbars
  778.     if(pListData->m_bScrollBarVisible_Horiz == TRUE && pListData->m_bScrollBarVisible_Vert == TRUE)
  779.     {
  780.         RECT rScrollbarGap;
  781.         rScrollbarGap = pListData->m_rClient;
  782.         rScrollbarGap.top = pListData->m_rScrollbar_Vert.bottom;
  783.         rScrollbarGap.left = pListData->m_rScrollbar_Horiz.right;
  784.         CLV_DrawBackgroundRect(pListData, &drawcontext, &rScrollbarGap);
  785.     }
  787.     // Draw the list
  788.     // - clip to list rect
  789.     {
  790.         RECT rList = pListData->m_rList;
  791.         OffsetRect(&rList, drawcontext.m_ptOffset.x, drawcontext.m_ptOffset.y);
  792.         IntersectClipRect(drawcontext.m_dcDraw, rList.left, rList.top, rList.right, rList.bottom);
  793.     }
  795.     // - draw background
  796.     CPIG_TiledFill(&drawcontext, &pListData->m_rList, &glb_pSkin->mpl_rListBackground_SourceTile, glb_pSkin->mpl_pListBackground, CIC_TILEDFILOPTIONS_NONE);
  798.     // Draw the selection
  799.     {
  800.         int iItemIDX;
  801.         int iFirstVisibleItem;
  802.         int iLastVisibleItem;
  803.         BOOL bInSelection;
  804.         RECT rSelection;
  806.         // Setup bounds
  807.         iFirstVisibleItem = pListData->m_iFirstVisibleItem - 1;
  808.         iLastVisibleItem = iFirstVisibleItem + ((pListData->m_rList.bottom-pListData->m_rList.top)/pListData->m_iItemHeight) + 1;
  809.         if(iFirstVisibleItem < 0)
  810.             iFirstVisibleItem = 0;
  811.         if(iLastVisibleItem >= pListData->m_iNumItems)
  812.             iLastVisibleItem = pListData->m_iNumItems-1;
  814.         // Part initialise selection rect
  815.         rSelection.left = -pListData->m_iXOrigin + glb_pSkin->mpl_rListBackground_SourceTile.left;
  816.         rSelection.right = (pListData->m_iXScrollExtent - pListData->m_iXOrigin) - (glb_pSkin->mpl_pListBackground->m_szSize.cx - glb_pSkin->mpl_rListBackground_SourceTile.right);
  818.         // Draw selection (grouping adjacent selected items)
  819.         bInSelection = FALSE;
  820.         for(iItemIDX = iFirstVisibleItem; iItemIDX <= iLastVisibleItem; iItemIDX++)
  821.         {
  822.             // Is this item selected?
  823.             if(pListData->m_pItems[iItemIDX].m_dwFlags & CPLV_ITEMFLAG_SELECTED)
  824.             {
  825.                 // Open a new selection (if we are not in one already)
  826.                 if(bInSelection == FALSE)
  827.                 {
  828.                     bInSelection = TRUE;
  829.                     rSelection.top = (iItemIDX + 1 - pListData->m_iFirstVisibleItem) * pListData->m_iItemHeight;
  830.                 }
  831.             }
  832.             else
  833.             {
  834.                 // Are we in a selection (if so complete it)
  835.                 if(bInSelection)
  836.                 {
  837.                     bInSelection = FALSE;
  838.                     rSelection.bottom = (iItemIDX + 1 - pListData->m_iFirstVisibleItem) * pListData->m_iItemHeight;
  839.                     CPIG_TiledFill(&drawcontext, &rSelection, &glb_pSkin->mpl_rSelection_Tile, glb_pSkin->mpl_pSelection, CIC_TILEDFILOPTIONS_NONE);
  840.                 }
  841.             }
  842.         }
  844.         // Close any open groups
  845.         if(bInSelection)
  846.         {
  847.             bInSelection = FALSE;
  848.             rSelection.bottom = ((iLastVisibleItem+2) - pListData->m_iFirstVisibleItem) * pListData->m_iItemHeight;
  849.             CPIG_TiledFill(&drawcontext, &rSelection, &glb_pSkin->mpl_rSelection_Tile, glb_pSkin->mpl_pSelection, CIC_TILEDFILOPTIONS_NONE);
  850.         }
  852.         // Draw focus item
  853.         if(pListData->m_iFocusItem != CPC_INVALIDITEM
  854.                 && pListData->m_iFocusItem >= iFirstVisibleItem && pListData->m_iFocusItem <= iLastVisibleItem
  855.                 && pListData->m_bHasFocus == TRUE)
  856.         {
  857.             RECT rFocus;
  858.             rFocus = rSelection;
  859.             rFocus.top = (pListData->m_iFocusItem + 1 - pListData->m_iFirstVisibleItem) * pListData->m_iItemHeight;
  860.             rFocus.bottom = (pListData->m_iFocusItem + 2 - pListData->m_iFirstVisibleItem) * pListData->m_iItemHeight;
  861.             CPIG_TiledFill(&drawcontext, &rFocus, &glb_pSkin->mpl_rFocus_Tile, glb_pSkin->mpl_pFocus, CIC_TILEDFILOPTIONS_NOCENTRE);
  862.         }
  863.     }
  865.     // Draw the items
  866.     {
  867.         int iCursorX;
  868.         unsigned int _iColIDX;
  869.         int iFirstVisibleItem;
  870.         int iLastVisibleItem;
  871.         RECT rItem;
  873.         iFirstVisibleItem = pListData->m_iFirstVisibleItem;
  874.         iLastVisibleItem = iFirstVisibleItem + ((pListData->m_rList.bottom-pListData->m_rList.top)/pListData->m_iItemHeight);
  875.         if(iLastVisibleItem >= pListData->m_iNumItems)
  876.             iLastVisibleItem = pListData->m_iNumItems-1;
  878.         // Draw items column by column
  879.         iCursorX = -pListData->m_iXOrigin;
  880.         SetBkMode(drawcontext.m_dcDraw, TRANSPARENT);
  881.         for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  882.         {
  883.             int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  884.             int iItemIDX;
  885.             int iNextCursorX;
  886.             if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  887.                 continue;
  889.             rItem.left = iCursorX;
  890.             rItem.right = iCursorX + pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  891.             if(rItem.right > (pListData->m_rHeader.right - CPC_HEADERCOLLAPSETHRESHOLD))
  892.                 rItem.right = pListData->m_rHeader.right;
  893.             iNextCursorX = rItem.right;
  895.             // Line text up with header
  896.             rItem.left += glb_pSkin->mpl_rListHeader_SourceTile.left;
  897.             rItem.right -= glb_pSkin->mpl_pListHeader_Down->m_szSize.cx - glb_pSkin->mpl_rListHeader_SourceTile.right;
  899.             // Draw item text (if there is any and this column is inside the clip box)
  900.             if(pListData->m_pColumns[iColumnIDX].m_pfnTextAccessor
  901.                     && rItem.right > drawcontext.m_rClip.left
  902.                     && rItem.left < drawcontext.m_rClip.right)
  903.             {
  904.                 int iCursorY = pListData->m_rList.top;
  905.                 for(iItemIDX = iFirstVisibleItem; iItemIDX <= iLastVisibleItem; iItemIDX++)
  906.                 {
  907.                     // Set the text colour depending on whether we are selected
  908.                     const char* pcText = pListData->m_pColumns[iColumnIDX].m_pfnTextAccessor(pListData->m_pItems[iItemIDX].m_pItemData);
  909.                     if(pcText)
  910.                     {
  911.                         if(pListData->m_pItems[iItemIDX].m_dwFlags & CPLV_ITEMFLAG_SELECTED)
  912.                             SetTextColor(drawcontext.m_dcDraw, glb_pSkin->mpl_ListTextColour_Selected);
  913.                         else
  914.                         {
  915.                             if(pListData->m_pColumns[iColumnIDX].m_pfnGetCustomDrawColour)
  916.                             {
  917.                                 CPe_CustomDrawColour enDrawColour;
  919.                                 enDrawColour = pListData->m_pColumns[iColumnIDX].m_pfnGetCustomDrawColour(pListData->m_pItems[iItemIDX].m_pItemData);
  921.                                 if(enDrawColour == cdcNormal)
  922.                                     SetTextColor(drawcontext.m_dcDraw, glb_pSkin->mpl_ListTextColour);
  923.                                 else if(enDrawColour == cdcLowlighted)
  924.                                     SetTextColor(drawcontext.m_dcDraw, RGB(0,0,0));
  925.                                 else
  926.                                     SetTextColor(drawcontext.m_dcDraw, RGB(255,255,255));
  927.                             }
  928.                             else
  929.                                 SetTextColor(drawcontext.m_dcDraw, glb_pSkin->mpl_ListTextColour);
  930.                         }
  932.                         // Draw item's text
  933.                         rItem.top = iCursorY;
  934.                         rItem.bottom = iCursorY + pListData->m_iItemHeight;
  935.                         CLV_DrawText(&drawcontext, pcText, &rItem, pListData->m_pColumns[iColumnIDX].m_enAlign);
  936.                     }
  937.                     iCursorY += pListData->m_iItemHeight;
  938.                 }
  939.             }
  941.             iCursorX = iNextCursorX;
  942.             if(iCursorX == pListData->m_rList.right)
  943.                 break;
  944.         }
  945.     }
  947.     // Cleanup
  948.     SelectObject(drawcontext.m_dcDraw, hfOld);
  949.     if(hbmSurface)
  950.     {
  951.         BitBlt(dcPaint,
  952.                drawcontext.m_rClip.left, drawcontext.m_rClip.top,
  953.                drawcontext.m_rClip.right-drawcontext.m_rClip.left,
  954.                drawcontext.m_rClip.bottom-drawcontext.m_rClip.top,
  955.                drawcontext.m_dcDraw, 0, 0, SRCCOPY);
  956.         SelectObject(drawcontext.m_dcDraw, hbmSurface_Old);
  957.         DeleteDC(drawcontext.m_dcDraw);
  958.         DeleteObject(hbmSurface);
  959.     }
  960.     EndPaint(pListData->m_hWnd, &ps);
  961. }
  962. //
  963. //
  964. //
  965. void CLV_CalcItemHeight(CIs_ListViewData* pListData)
  966. {
  967.     HDC dcWindow;
  968.     SIZE szText;
  969.     HFONT hfOld;
  971.     dcWindow = GetDC(pListData->m_hWnd);
  972.     hfOld = (HFONT)SelectObject(dcWindow, glb_pSkin->mpl_hfFont);
  973.     GetTextExtentPoint(dcWindow, "Xy", 2, &szText);
  974.     pListData->m_iItemHeight = szText.cy;
  975.     SelectObject(dcWindow, hfOld);
  976.     ReleaseDC(pListData->m_hWnd, dcWindow);
  977. }
  978. //
  979. //
  980. //
  981. int CLV_HitTest_Header_X(CIs_ListViewData* pListData, const int iTestX)
  982. {
  983.     // We are in the header - which one?
  984.     int iCursorX;
  985.     int iLastCursorX;
  986.     unsigned int _iColIDX;
  987.     iCursorX = -pListData->m_iXOrigin;
  988.     iLastCursorX = 0;
  989.     for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  990.     {
  991.         unsigned int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  992.         if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  993.             continue;
  995.         iLastCursorX = iCursorX;
  996.         iCursorX += pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  997.         if(iCursorX > (pListData->m_rHeader.right - CPC_HEADERCOLLAPSETHRESHOLD))
  998.             iCursorX = pListData->m_rHeader.right;
  1000.         if(iTestX >= iLastCursorX && iTestX < iCursorX)
  1001.             return iColumnIDX;
  1002.     }
  1004.     return CPC_INVALIDCOLUMN;
  1005. }
  1006. //
  1007. //
  1008. //
  1009. int CLV_HitTest_HeaderSizer_X(CIs_ListViewData* pListData, const int iTestX)
  1010. {
  1011.     // We are in the header - are we near a drag boundry?
  1012.     int iCursorX;
  1013.     unsigned int _iColIDX;
  1014.     iCursorX = -pListData->m_iXOrigin;
  1015.     for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  1016.     {
  1017.         unsigned int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  1018.         int iColSizer;
  1019.         if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  1020.             continue;
  1022.         iColSizer = iCursorX + pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  1023.         if(iColSizer > (pListData->m_rHeader.right - CPC_HEADERCOLLAPSETHRESHOLD))
  1024.             iColSizer = pListData->m_rHeader.right - CPC_HEADERCOLLAPSETHRESHOLD;
  1026.         if(iTestX >= (iColSizer-CPC_HEADERDRAG_HTWIDTH) && iTestX <= (iColSizer+CPC_HEADERDRAG_HTWIDTH))
  1027.         {
  1028.             // If we cannot resize - return an invalid column
  1029.             if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_LOCKRESIZE)
  1030.                 return CPC_INVALIDCOLUMN;
  1032.             return iColumnIDX;
  1033.         }
  1035.         iCursorX = iColSizer;
  1036.     }
  1038.     return CPC_INVALIDCOLUMN;
  1039. }
  1040. //
  1041. //
  1042. //
  1043. void CLV_Handle_WM_MOUSEMOVE(CIs_ListViewData* pListData, const POINTS _ptCursor)
  1044. {
  1045.     POINT ptCursor;
  1047.     // Init
  1048.     ptCursor.x = _ptCursor.x;
  1049.     ptCursor.y = _ptCursor.y;
  1051.     if(pListData->m_enWindowMode == wmQuiescent)
  1052.     {
  1053.         // Set cursor according to where it is
  1054.         if(PtInRect(&pListData->m_rHeader, ptCursor) == TRUE)
  1055.         {
  1056.             if(CLV_HitTest_HeaderSizer_X(pListData, ptCursor.x) == CPC_INVALIDCOLUMN)
  1057.                 SetCursor(LoadCursor(NULL, IDC_ARROW)); // In a header
  1058.             else
  1059.                 SetCursor(LoadCursor(NULL, IDC_SIZEWE)); // Sizing
  1060.         }
  1061.         else
  1062.             SetCursor(LoadCursor(NULL, IDC_ARROW));
  1063.     }
  1064.     else if(pListData->m_enWindowMode == wmHeader_Click)
  1065.     {
  1066.         // If the mouse has moved beyond our drag threshold then enter into header_orderchange mode
  1067.         if(abs(ptCursor.x - pListData->m_ptMouseDown.x) > CPC_HEADERDRAGDISTANCE
  1068.                 || abs(ptCursor.y - pListData->m_ptMouseDown.y) > CPC_HEADERDRAGDISTANCE)
  1069.         {
  1070.             pListData->m_enWindowMode = wmHeader_ChangeOrder;
  1071.             InvalidateRect(pListData->m_hWnd, &pListData->m_rHeader, FALSE);
  1072.         }
  1073.     }
  1074.     else if(pListData->m_enWindowMode == wmHeader_ChangeWidth)
  1075.     {
  1076.         // Update the new column width
  1077.         // - get the start of this colunm
  1078.         unsigned int _iColIDX;
  1079.         int iCursorX;
  1080.         RECT rInvalid;
  1081.         DWORD dwNewFlags;
  1082.         int iNewWidth;
  1084.         // Find the start point of the active column
  1085.         iCursorX = -pListData->m_iXOrigin;
  1086.         for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  1087.         {
  1088.             unsigned int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  1089.             if((int)iColumnIDX == pListData->m_iActiveHeaderCol)
  1090.                 break;
  1091.             if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  1092.                 continue;
  1093.             iCursorX += pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  1094.         }
  1096.         // Invalidate only the area that needs it
  1097.         rInvalid.top = 0;
  1098.         rInvalid.bottom = pListData->m_rClient.bottom;
  1099.         rInvalid.right = pListData->m_rClient.right;
  1100.         rInvalid.left = iCursorX;
  1102.         // Perform resize
  1103.         dwNewFlags = pListData->m_pColumns[pListData->m_iActiveHeaderCol].m_dwFlags;
  1104.         iNewWidth = pListData->m_pColumns[pListData->m_iActiveHeaderCol].m_iColumnWidth;
  1105.         if(ptCursor.x > (iCursorX + CPC_HEADERDRAG_HTWIDTH) )
  1106.         {
  1107.             dwNewFlags &= (~CPLV_COLFLAG_HIDDEN);
  1108.             iNewWidth = ptCursor.x - iCursorX;
  1109.         }
  1110.         else
  1111.         {
  1112.             if(dwNewFlags & CPLV_COLFLAG_NOHIDE)
  1113.             {
  1114.                 iNewWidth = CPC_HEADERDRAG_HTWIDTH;
  1115.             }
  1116.             else
  1117.             {
  1118.                 dwNewFlags |= CPLV_COLFLAG_HIDDEN;
  1119.                 iNewWidth = CPC_HEADERDRAG_DEFAULTWIDTH;
  1120.             }
  1121.         }
  1123.         // Update dispaly only if the width (or visible state) has changed
  1124.         if(iNewWidth != pListData->m_pColumns[pListData->m_iActiveHeaderCol].m_iColumnWidth
  1125.                 || dwNewFlags != pListData->m_pColumns[pListData->m_iActiveHeaderCol].m_dwFlags)
  1126.         {
  1127.             pListData->m_pColumns[pListData->m_iActiveHeaderCol].m_dwFlags = dwNewFlags;
  1128.             pListData->m_pColumns[pListData->m_iActiveHeaderCol].m_iColumnWidth = iNewWidth;
  1129.             InvalidateRect(pListData->m_hWnd, &rInvalid, FALSE);
  1130.             CLV_UpdateScrollBars(pListData);
  1131.         }
  1133.     }
  1134.     else if(pListData->m_enWindowMode == wmHeader_ChangeOrder)
  1135.     {
  1136.         // Search for our drag rect - keep track of the threshold of the prev and next colunms
  1137.         unsigned int _iColIDX;
  1138.         int iXColStart_Prev = 0;
  1139.         int iXColEnd_Prev = 0;
  1140.         int iXColStart_Next = 0;
  1141.         int iXColEnd_Next = 0;
  1142.         int iPrevColIDX = CPC_INVALIDCOLUMN;
  1143.         int iNextColIDX = CPC_INVALIDCOLUMN;
  1144.         unsigned int iCurrentOrderIDX;
  1145.         int iActiveColumnWidth;
  1146.         int iCursorX;
  1147.         BOOL bFoundColumn;
  1149.         // Find prev and next colunms
  1150.         bFoundColumn = FALSE;
  1151.         iCursorX = -pListData->m_iXOrigin;
  1152.         iCurrentOrderIDX = 0;
  1153.         iActiveColumnWidth = 0;
  1154.         for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  1155.         {
  1156.             int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  1157.             if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  1158.                 continue;
  1160.             // Update prev and next
  1161.             if(bFoundColumn == TRUE && iNextColIDX == CPC_INVALIDCOLUMN)
  1162.             {
  1163.                 iXColStart_Next = iCursorX;
  1164.                 iXColEnd_Next = iCursorX + pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  1165.                 iNextColIDX = iColumnIDX;
  1166.             }
  1168.             if(iColumnIDX == pListData->m_iActiveHeaderCol)
  1169.             {
  1170.                 iCurrentOrderIDX = _iColIDX;
  1171.                 iActiveColumnWidth = pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  1172.                 bFoundColumn = TRUE;
  1173.             }
  1174.             else if(bFoundColumn == FALSE)
  1175.             {
  1176.                 iPrevColIDX = iColumnIDX;
  1177.                 iXColStart_Prev = iCursorX;
  1178.                 iXColEnd_Prev = iCursorX + pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  1179.             }
  1181.             iCursorX += pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  1182.         }
  1184.         // If we have dragged our mouse beyond the prev threshold - swap the order of that with the current col
  1185.         // - Only swap if the mouse will remain on top of the active column
  1186.         if(iPrevColIDX != CPC_INVALIDCOLUMN
  1187.                 && ptCursor.x < iXColEnd_Prev
  1188.                 && ptCursor.x < (iXColStart_Prev+iActiveColumnWidth))
  1189.         {
  1190.             int iTemp;
  1191.             RECT rInvalid;
  1193.             iTemp = pListData->m_piColumnOrder[iCurrentOrderIDX];
  1194.             pListData->m_piColumnOrder[iCurrentOrderIDX] = pListData->m_piColumnOrder[iCurrentOrderIDX-1];
  1195.             pListData->m_piColumnOrder[iCurrentOrderIDX-1] = iTemp;
  1197.             // Invalidate only the area that needs it
  1198.             rInvalid.top = 0;
  1199.             rInvalid.bottom = pListData->m_rClient.bottom;
  1200.             rInvalid.left = iXColStart_Prev;
  1201.             rInvalid.right = iXColEnd_Prev + iActiveColumnWidth;
  1202.             InvalidateRect(pListData->m_hWnd, &rInvalid, FALSE);
  1204.             // Send notify
  1205.             if(pListData->m_hndlr_HeaderChanged)
  1206.                 pListData->m_hndlr_HeaderChanged(pListData);
  1207.         }
  1208.         // If we have dragged our mouse beyond the next threshold - swap the order of that with the current col
  1209.         // - Only swap if the mouse will remain on top of the active column
  1210.         else if(iNextColIDX != CPC_INVALIDCOLUMN
  1211.                 && ptCursor.x > iXColStart_Next
  1212.                 && ptCursor.x > (iXColEnd_Next-iActiveColumnWidth))
  1213.         {
  1214.             int iTemp;
  1215.             RECT rInvalid;
  1217.             iTemp = pListData->m_piColumnOrder[iCurrentOrderIDX];
  1218.             pListData->m_piColumnOrder[iCurrentOrderIDX] = pListData->m_piColumnOrder[iCurrentOrderIDX+1];
  1219.             pListData->m_piColumnOrder[iCurrentOrderIDX+1] = iTemp;
  1221.             // Invalidate only the area that needs it
  1222.             rInvalid.top = 0;
  1223.             rInvalid.bottom = pListData->m_rClient.bottom;
  1224.             rInvalid.left = iXColStart_Next - iActiveColumnWidth;
  1225.             rInvalid.right = iXColEnd_Next;
  1226.             InvalidateRect(pListData->m_hWnd, &rInvalid, FALSE);
  1228.             // Send notify
  1229.             if(pListData->m_hndlr_HeaderChanged)
  1230.                 pListData->m_hndlr_HeaderChanged(pListData);
  1231.         }
  1232.     }
  1233.     else if(pListData->m_enWindowMode == wmHScrollbar_DragThumb)
  1234.     {
  1235.         if(pListData->m_ptMouseDown.x != ptCursor.x)
  1236.         {
  1237.             const int iTrackWidth = (pListData->m_rScrollbar_Horiz.right - pListData->m_rScrollbar_Horiz.left)
  1238.                                     - (glb_pSkin->mpl_pHScrollBar_Left->m_pImage->m_szSize.cx
  1239.                                        + glb_pSkin->mpl_pHScrollBar_Right->m_pImage->m_szSize.cx);
  1240.             const int iTrackThumbWidth = pListData->m_rScrollbar_Horiz_Thumb.right - pListData->m_rScrollbar_Horiz_Thumb.left;
  1241.             const int iListRectWidth = pListData->m_rList.right - pListData->m_rList.left;
  1242.             int iNewTrackPos;
  1243.             int iNewXOrigin;
  1245.             // Work out new origin based on the track drag distance
  1246.             iNewTrackPos = ptCursor.x - pListData->m_ptMouseDown_OnHitItem.x - glb_pSkin->mpl_pHScrollBar_Left->m_pImage->m_szSize.cx;
  1247.             iNewXOrigin = (int)( (  ((float)iNewTrackPos * (float)(pListData->m_iXScrollExtent - iListRectWidth)) / (float)(iTrackWidth-iTrackThumbWidth)));
  1249.             if(iNewXOrigin < 0)
  1250.                 iNewXOrigin = 0;
  1251.             else if(iNewXOrigin > (pListData->m_iXScrollExtent-iListRectWidth))
  1252.                 iNewXOrigin = pListData->m_iXScrollExtent-iListRectWidth;
  1254.             // Update only if the origin has changed
  1255.             if(iNewXOrigin != pListData->m_iXOrigin)
  1256.             {
  1257.                 pListData->m_iXOrigin = iNewXOrigin;
  1258.                 CLV_UpdateScrollBars(pListData);
  1259.                 CLV_InvalidateWindow(pListData);
  1260.             }
  1261.         }
  1262.     }
  1263.     else if(pListData->m_enWindowMode == wmHScrollbar_Scroll_Left)
  1264.     {
  1265.         // We will draw the button up if the mouse isn't over it
  1266.         BOOL bNewButtonState;
  1267.         if(PtInRect(&pListData->m_rScrollbar_Horiz, ptCursor) == TRUE
  1268.                 && ptCursor.x < (pListData->m_rScrollbar_Horiz.left + glb_pSkin->mpl_pHScrollBar_Left->m_pImage->m_szSize.cx) )
  1269.         {
  1270.             bNewButtonState = TRUE;
  1271.         }
  1272.         else
  1273.             bNewButtonState = FALSE;
  1275.         // State changed?
  1276.         if(bNewButtonState != pListData->m_bMouseOverScrollbutton)
  1277.         {
  1278.             pListData->m_bMouseOverScrollbutton = bNewButtonState;
  1279.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz, FALSE);
  1280.         }
  1281.     }
  1282.     else if(pListData->m_enWindowMode == wmHScrollbar_Scroll_Right)
  1283.     {
  1284.         // We draw the button up if the mouse isn't over it
  1285.         BOOL bNewButtonState;
  1286.         if(PtInRect(&pListData->m_rScrollbar_Horiz, ptCursor) == TRUE
  1287.                 && ptCursor.x > (pListData->m_rScrollbar_Horiz.right - glb_pSkin->mpl_pHScrollBar_Right->m_pImage->m_szSize.cx) )
  1288.         {
  1289.             bNewButtonState = TRUE;
  1290.         }
  1291.         else
  1292.             bNewButtonState = FALSE;
  1294.         // State changed?
  1295.         if(bNewButtonState != pListData->m_bMouseOverScrollbutton)
  1296.         {
  1297.             pListData->m_bMouseOverScrollbutton = bNewButtonState;
  1298.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz, FALSE);
  1299.         }
  1300.     }
  1301.     else if(pListData->m_enWindowMode == wmVScrollbar_DragThumb)
  1302.     {
  1303.         if(pListData->m_ptMouseDown.y != ptCursor.y)
  1304.         {
  1305.             const int iListRectHeight = pListData->m_rList.bottom - pListData->m_rList.top;
  1306.             const int iTrackHeight = iListRectHeight - (glb_pSkin->mpl_pVScrollBar_Up->m_iStateHeight
  1307.                                      + glb_pSkin->mpl_pVScrollBar_Down->m_iStateHeight);
  1308.             const int iTrackThumbHeight = pListData->m_rScrollbar_Vert_Thumb.bottom - pListData->m_rScrollbar_Vert_Thumb.top;
  1309.             const int iListRectHeight_Lines = CLV_GetListRect_Lines(pListData);
  1310.             int iNewTrackPos;
  1311.             int iNewFirstVisibleItem;
  1313.             // Work out new origin based on the track drag distance
  1314.             iNewTrackPos = ptCursor.y - pListData->m_ptMouseDown_OnHitItem.y - (pListData->m_rScrollbar_Vert.top+glb_pSkin->mpl_pVScrollBar_Up->m_iStateHeight);
  1315.             iNewFirstVisibleItem = (int)( ( ((float)iNewTrackPos * (float)(pListData->m_iNumItems - iListRectHeight_Lines)) / (float)(iTrackHeight-iTrackThumbHeight)) );
  1317.             if(iNewFirstVisibleItem < 0)
  1318.                 iNewFirstVisibleItem = 0;
  1319.             if( (iNewFirstVisibleItem + iListRectHeight_Lines) > pListData->m_iNumItems)
  1320.                 iNewFirstVisibleItem = pListData->m_iNumItems - iListRectHeight_Lines;
  1322.             // Update only if the origin has changed
  1323.             if(iNewFirstVisibleItem != pListData->m_iFirstVisibleItem)
  1324.             {
  1325.                 pListData->m_iFirstVisibleItem = iNewFirstVisibleItem;
  1326.                 CLV_UpdateScrollBars(pListData);
  1327.                 CLV_InvalidateWindow(pListData);
  1328.             }
  1329.         }
  1330.     }
  1331.     else if(pListData->m_enWindowMode == wmVScrollbar_Scroll_Up)
  1332.     {
  1333.         // We will draw the button up if the mouse isn't over it
  1334.         BOOL bNewButtonState;
  1335.         if(PtInRect(&pListData->m_rScrollbar_Vert, ptCursor) == TRUE
  1336.                 && ptCursor.y < (pListData->m_rScrollbar_Vert.top + glb_pSkin->mpl_pVScrollBar_Up->m_iStateHeight) )
  1337.         {
  1338.             bNewButtonState = TRUE;
  1339.         }
  1340.         else
  1341.             bNewButtonState = FALSE;
  1343.         // State changed?
  1344.         if(bNewButtonState != pListData->m_bMouseOverScrollbutton)
  1345.         {
  1346.             pListData->m_bMouseOverScrollbutton = bNewButtonState;
  1347.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Vert, FALSE);
  1348.         }
  1349.     }
  1350.     else if(pListData->m_enWindowMode == wmVScrollbar_Scroll_Down)
  1351.     {
  1352.         // We draw the button up if the mouse isn't over it
  1353.         BOOL bNewButtonState;
  1354.         if(PtInRect(&pListData->m_rScrollbar_Vert, ptCursor) == TRUE
  1355.                 && ptCursor.y > (pListData->m_rScrollbar_Vert.bottom - glb_pSkin->mpl_pVScrollBar_Down->m_iStateHeight) )
  1356.         {
  1357.             bNewButtonState = TRUE;
  1358.         }
  1359.         else
  1360.             bNewButtonState = FALSE;
  1362.         // State changed?
  1363.         if(bNewButtonState != pListData->m_bMouseOverScrollbutton)
  1364.         {
  1365.             pListData->m_bMouseOverScrollbutton = bNewButtonState;
  1366.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Vert, FALSE);
  1367.         }
  1368.     }
  1369.     else if(pListData->m_enWindowMode == wmList_Click)
  1370.     {
  1371.         // If the mouse has moved beyond our drag threshold then enter into header_orderchange mode
  1372.         if( pListData->m_iFocusItem != CPC_INVALIDITEM
  1373.                 && ((abs(ptCursor.x - pListData->m_ptMouseDown.x) > CPC_LISTDRAGDISTANCE
  1374.                      || abs(ptCursor.y - pListData->m_ptMouseDown.y) > CPC_LISTDRAGDISTANCE) )
  1375.                 && (pListData->m_pItems[pListData->m_iFocusItem].m_dwFlags & CPLV_ITEMFLAG_SELECTED))
  1377.         {
  1378.             pListData->m_enWindowMode = wmList_Drag;
  1379.             if(pListData->m_hndlr_ItemDrag && pListData->m_iFocusItem != CPC_INVALIDITEM)
  1380.                 pListData->m_hndlr_ItemDrag(pListData, pListData->m_iFocusItem, pListData->m_pItems[pListData->m_iFocusItem].m_pItemData);
  1381.         }
  1382.     }
  1383.     else
  1384.         SetCursor(LoadCursor(NULL, IDC_ARROW));
  1385. }
  1386. //
  1387. //
  1388. //
  1389. void CLV_StartAutoRepeat(CIs_ListViewData* pListData)
  1390. {
  1391.     DWORD dwRepeatDelay;
  1392.     SystemParametersInfo(SPI_GETKEYBOARDDELAY, 0, &dwRepeatDelay, 0L);
  1393.     dwRepeatDelay = 250 + (dwRepeatDelay*250);
  1394.     pListData->m_bAutoRepeatFirst = TRUE;
  1395.     pListData->m_uiAutorepeatTimer = SetTimer(pListData->m_hWnd, CPC_TIMERID_AUTOREPEAT, dwRepeatDelay, NULL);
  1396. }
  1397. //
  1398. //
  1399. //
  1400. void CLV_Handle_WM_TIMER_AUTOREPEAT(CIs_ListViewData* pListData)
  1401. {
  1402.     POINT ptCursor;
  1403.     GetCursorPos(&ptCursor);
  1404.     ScreenToClient(pListData->m_hWnd, &ptCursor);
  1406.     // Are we autorepeating in the horizontal scrollbar?
  1407.     if(PtInRect(&pListData->m_rScrollbar_Horiz, ptCursor) == TRUE)
  1408.     {
  1409.         // In left button
  1410.         if(ptCursor.x < (pListData->m_rScrollbar_Horiz.left + glb_pSkin->mpl_pHScrollBar_Left->m_pImage->m_szSize.cx)
  1411.                 && pListData->m_enWindowMode == wmHScrollbar_Scroll_Left)
  1412.         {
  1413.             CLV_Scroll_Horiz(pListData, -CPC_SCROLLBAR_HORIZ_LINESIZE);
  1414.         }
  1415.         // In right button
  1416.         else if(ptCursor.x > (pListData->m_rScrollbar_Horiz.right - glb_pSkin->mpl_pHScrollBar_Right->m_pImage->m_szSize.cx)
  1417.                 && pListData->m_enWindowMode == wmHScrollbar_Scroll_Right)
  1418.         {
  1419.             CLV_Scroll_Horiz(pListData, CPC_SCROLLBAR_HORIZ_LINESIZE);
  1420.         }
  1421.         // In left page area
  1422.         else if(ptCursor.x < pListData->m_rScrollbar_Horiz_Thumb.left
  1423.                 && pListData->m_enWindowMode == wmHScrollbar_Page_Left)
  1424.         {
  1425.             CLV_Scroll_Horiz(pListData, -CPC_SCROLLBAR_HORIZ_PAGESIZE);
  1426.         }
  1427.         // In right page area
  1428.         else if(ptCursor.x > pListData->m_rScrollbar_Horiz_Thumb.right
  1429.                 && pListData->m_enWindowMode == wmHScrollbar_Page_Right)
  1430.         {
  1431.             CLV_Scroll_Horiz(pListData, CPC_SCROLLBAR_HORIZ_PAGESIZE);
  1432.         }
  1433.     }
  1434.     // Are we autorepeating in the vertical scrollbar?
  1435.     else if(PtInRect(&pListData->m_rScrollbar_Vert, ptCursor) == TRUE)
  1436.     {
  1437.         if(ptCursor.y < (pListData->m_rScrollbar_Vert.top + glb_pSkin->mpl_pVScrollBar_Up->m_iStateHeight)
  1438.                 && pListData->m_enWindowMode == wmVScrollbar_Scroll_Up)
  1439.         {
  1440.             CLV_Scroll_Vert(pListData, -1);
  1441.         }
  1442.         // In down button
  1443.         else if(ptCursor.y > (pListData->m_rScrollbar_Vert.bottom - glb_pSkin->mpl_pVScrollBar_Down->m_iStateHeight)
  1444.                 && pListData->m_enWindowMode == wmVScrollbar_Scroll_Down)
  1445.         {
  1446.             CLV_Scroll_Vert(pListData, 1);
  1447.         }
  1448.         // In top page area
  1449.         else if(ptCursor.y < pListData->m_rScrollbar_Vert_Thumb.top
  1450.                 && pListData->m_enWindowMode == wmVScrollbar_Page_Up)
  1451.         {
  1452.             CLV_Scroll_Vert(pListData, -pListData->m_iNumItemsOnPage);
  1453.         }
  1454.         // In bottom page area
  1455.         else if(ptCursor.y > pListData->m_rScrollbar_Vert_Thumb.bottom
  1456.                 && pListData->m_enWindowMode == wmVScrollbar_Page_Down)
  1457.         {
  1458.             CLV_Scroll_Vert(pListData, pListData->m_iNumItemsOnPage);
  1459.         }
  1460.     }
  1462.     // Do we need to update the timer (after the first autorepeat delay)
  1463.     if(pListData->m_bAutoRepeatFirst)
  1464.     {
  1465.         int iRepeatDelay;
  1467.         // Make the autorepeat the same as the keyboard autorepeat
  1468.         pListData->m_bAutoRepeatFirst = FALSE;
  1469.         SystemParametersInfo(SPI_GETKEYBOARDSPEED, 0, &iRepeatDelay, 0L);
  1470.         iRepeatDelay = 400 - (iRepeatDelay*12);
  1471.         if(iRepeatDelay < 0)
  1472.             iRepeatDelay = 10;
  1473.         pListData->m_uiAutorepeatTimer = SetTimer(pListData->m_hWnd, CPC_TIMERID_AUTOREPEAT, iRepeatDelay, NULL);
  1474.     }
  1475. }
  1476. //
  1477. //
  1478. //
  1479. void CLV_InvalidateItem(CP_HLISTVIEW _hListData, const int iItemIDX)
  1480. {
  1481.     CIs_ListViewData* pListData;
  1482.     RECT rItemRect;
  1484.     pListData = (CIs_ListViewData*)_hListData;
  1485.     CP_CHECKOBJECT(pListData);
  1487.     if(iItemIDX == CPC_INVALIDITEM)
  1488.         return;
  1489.     CP_ASSERT(iItemIDX >= 0);
  1490.     CP_ASSERT(iItemIDX < pListData->m_iNumItems);
  1492.     rItemRect.left = pListData->m_rList.left;
  1493.     rItemRect.right = pListData->m_rList.right;
  1494.     rItemRect.top = pListData->m_rList.top + ( (iItemIDX - pListData->m_iFirstVisibleItem) * pListData->m_iItemHeight);
  1495.     rItemRect.bottom = rItemRect.top + pListData->m_iItemHeight;
  1497.     // Handle the possiblity that the previous/next item may be selected
  1498.     rItemRect.top -= glb_pSkin->mpl_pSelection->m_szSize.cy - glb_pSkin->mpl_rSelection_Tile.bottom;
  1499.     rItemRect.bottom += glb_pSkin->mpl_rSelection_Tile.top;
  1501.     InvalidateRect(pListData->m_hWnd, &rItemRect, FALSE);
  1502. }
  1503. //
  1504. //
  1505. //
  1506. void CLV_ItemSelChange(CIs_ListViewData* pListData, int iItemIDX)
  1507. {
  1508.     if(iItemIDX == CPC_INVALIDITEM)
  1509.         return;
  1511.     CP_ASSERT(iItemIDX >= 0);
  1512.     CP_ASSERT(iItemIDX < pListData->m_iNumItems);
  1514.     if(pListData->m_hndlr_ItemSelected
  1515.             && pListData->m_pItems[iItemIDX].m_dwFlags & CPLV_ITEMFLAG_SELECTED)
  1516.     {
  1517.         pListData->m_hndlr_ItemSelected(pListData, iItemIDX, pListData->m_pItems[iItemIDX].m_pItemData);
  1518.     }
  1519. }
  1520. //
  1521. //
  1522. //
  1523. void CLV_ActionFocusedItem(CIs_ListViewData* pListData)
  1524. {
  1525.     if(pListData->m_iFocusItem == CPC_INVALIDITEM)
  1526.         return;
  1527.     CP_ASSERT(pListData->m_iFocusItem >= 0);
  1528.     CP_ASSERT(pListData->m_iFocusItem < pListData->m_iNumItems);
  1530.     CLV_ClearSelection(pListData);
  1531.     pListData->m_pItems[pListData->m_iFocusItem].m_dwFlags |= CPLV_ITEMFLAG_SELECTED;
  1532.     CLV_ItemSelChange(pListData, pListData->m_iFocusItem);
  1533.     CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  1534.     pListData->m_iFocusItem = pListData->m_iFocusItem;
  1535.     pListData->m_iKeyboardAnchor = pListData->m_iFocusItem;
  1537.     if(pListData->m_hndlr_ItemAction)
  1538.         pListData->m_hndlr_ItemAction(pListData, pListData->m_iFocusItem, pListData->m_pItems[pListData->m_iFocusItem].m_pItemData);
  1539. }
  1540. //
  1541. //
  1542. //
  1543. void CLV_SelectRange(CIs_ListViewData* pListData, const int _iFirst, const int _iLast)
  1544. {
  1545.     int iStartRange;
  1546.     int iEndRange;
  1547.     int iItemIDX;
  1549.     if(_iFirst > _iLast)
  1550.     {
  1551.         iStartRange = _iLast;
  1552.         iEndRange = _iFirst;
  1553.     }
  1554.     else
  1555.     {
  1556.         iStartRange = _iFirst;
  1557.         iEndRange = _iLast;
  1558.     }
  1559.     CP_ASSERT(iStartRange >= 0);
  1560.     CP_ASSERT(iStartRange < pListData->m_iNumItems);
  1561.     CP_ASSERT(iEndRange >= 0);
  1562.     CP_ASSERT(iEndRange < pListData->m_iNumItems);
  1564.     for(iItemIDX = iStartRange; iItemIDX <= iEndRange; iItemIDX++)
  1565.     {
  1566.         pListData->m_pItems[iItemIDX].m_dwFlags |= CPLV_ITEMFLAG_SELECTED;
  1567.         CLV_ItemSelChange(pListData, iItemIDX);
  1568.         CLV_InvalidateItem(pListData, iItemIDX);
  1569.     }
  1570. }
  1571. //
  1572. //
  1573. //
  1574. void CLV_Handle_WM_LBUTTONDOWN(CIs_ListViewData* pListData, const POINTS _ptCursor, const DWORD dwKeys)
  1575. {
  1576.     POINT ptCursor;
  1578.     // Init
  1579.     ptCursor.x = _ptCursor.x;
  1580.     ptCursor.y = _ptCursor.y;
  1581.     pListData->m_ptMouseDown = ptCursor;
  1582.     pListData->m_dwMouseDown_Keys = dwKeys;
  1584.     // Hit test cursor
  1585.     // - in header?
  1586.     if(PtInRect(&pListData->m_rHeader, ptCursor) == TRUE)
  1587.     {
  1588.         pListData->m_iActiveHeaderCol = CLV_HitTest_HeaderSizer_X(pListData, ptCursor.x);
  1589.         if(pListData->m_iActiveHeaderCol != CPC_INVALIDCOLUMN)
  1590.         {
  1591.             // Resizing header
  1592.             SetCapture(pListData->m_hWnd);
  1593.             pListData->m_enWindowMode = wmHeader_ChangeWidth;
  1594.         }
  1595.         else
  1596.         {
  1597.             pListData->m_iActiveHeaderCol = CLV_HitTest_Header_X(pListData, ptCursor.x);
  1598.             if(pListData->m_iActiveHeaderCol != CPC_INVALIDCOLUMN)
  1599.             {
  1600.                 // Resizing header
  1601.                 SetCapture(pListData->m_hWnd);
  1602.                 pListData->m_enWindowMode = wmHeader_Click;
  1603.                 InvalidateRect(pListData->m_hWnd, &pListData->m_rHeader, FALSE);
  1604.             }
  1605.         }
  1606.     }
  1607.     // - In HScrollbar?
  1608.     else if(PtInRect(&pListData->m_rScrollbar_Horiz, ptCursor) == TRUE)
  1609.     {
  1610.         // In Thumb?
  1611.         if(PtInRect(&pListData->m_rScrollbar_Horiz_Thumb, ptCursor) == TRUE)
  1612.         {
  1613.             // Dragging thumb
  1614.             SetCapture(pListData->m_hWnd);
  1615.             pListData->m_enWindowMode = wmHScrollbar_DragThumb;
  1616.             pListData->m_ptMouseDown_OnHitItem.x = ptCursor.x - pListData->m_rScrollbar_Horiz_Thumb.left;
  1617.             pListData->m_ptMouseDown_OnHitItem.y = ptCursor.y - pListData->m_rScrollbar_Horiz_Thumb.top;
  1618.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz_Thumb, FALSE);
  1619.         }
  1620.         // In left button
  1621.         else if(ptCursor.x < (pListData->m_rScrollbar_Horiz.left + glb_pSkin->mpl_pHScrollBar_Left->m_pImage->m_szSize.cx) )
  1622.         {
  1623.             SetCapture(pListData->m_hWnd);
  1624.             pListData->m_enWindowMode = wmHScrollbar_Scroll_Left;
  1625.             CLV_Scroll_Horiz(pListData, -CPC_SCROLLBAR_HORIZ_LINESIZE);
  1626.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz, FALSE);
  1627.             pListData->m_bMouseOverScrollbutton = TRUE;
  1628.             CLV_StartAutoRepeat(pListData);
  1629.         }
  1630.         // In right button
  1631.         else if(ptCursor.x > (pListData->m_rScrollbar_Horiz.right - glb_pSkin->mpl_pHScrollBar_Right->m_pImage->m_szSize.cx) )
  1632.         {
  1633.             SetCapture(pListData->m_hWnd);
  1634.             pListData->m_enWindowMode = wmHScrollbar_Scroll_Right;
  1635.             CLV_Scroll_Horiz(pListData, CPC_SCROLLBAR_HORIZ_LINESIZE);
  1636.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz, FALSE);
  1637.             pListData->m_bMouseOverScrollbutton = TRUE;
  1638.             CLV_StartAutoRepeat(pListData);
  1639.         }
  1640.         // In left page area
  1641.         else if(ptCursor.x < pListData->m_rScrollbar_Horiz_Thumb.left)
  1642.         {
  1643.             SetCapture(pListData->m_hWnd);
  1644.             pListData->m_enWindowMode = wmHScrollbar_Page_Left;
  1645.             CLV_Scroll_Horiz(pListData, -CPC_SCROLLBAR_HORIZ_PAGESIZE);
  1646.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz, FALSE);
  1647.             CLV_StartAutoRepeat(pListData);
  1648.         }
  1649.         // In right page area
  1650.         else if(ptCursor.x > pListData->m_rScrollbar_Horiz_Thumb.right)
  1651.         {
  1652.             SetCapture(pListData->m_hWnd);
  1653.             pListData->m_enWindowMode = wmHScrollbar_Page_Right;
  1654.             CLV_Scroll_Horiz(pListData, CPC_SCROLLBAR_HORIZ_PAGESIZE);
  1655.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz, FALSE);
  1656.             CLV_StartAutoRepeat(pListData);
  1657.         }
  1658.     }
  1659.     // - In VScrollbar?
  1660.     else if(PtInRect(&pListData->m_rScrollbar_Vert, ptCursor) == TRUE)
  1661.     {
  1662.         // In Thumb?
  1663.         if(PtInRect(&pListData->m_rScrollbar_Vert_Thumb, ptCursor) == TRUE)
  1664.         {
  1665.             // Dragging thumb
  1666.             SetCapture(pListData->m_hWnd);
  1667.             pListData->m_enWindowMode = wmVScrollbar_DragThumb;
  1668.             pListData->m_ptMouseDown_OnHitItem.x = ptCursor.x - pListData->m_rScrollbar_Vert_Thumb.left;
  1669.             pListData->m_ptMouseDown_OnHitItem.y = ptCursor.y - pListData->m_rScrollbar_Vert_Thumb.top;
  1670.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Vert_Thumb, FALSE);
  1671.         }
  1672.         // In up button
  1673.         else if(ptCursor.y < (pListData->m_rScrollbar_Vert.top + glb_pSkin->mpl_pVScrollBar_Up->m_iStateHeight) )
  1674.         {
  1675.             SetCapture(pListData->m_hWnd);
  1676.             pListData->m_enWindowMode = wmVScrollbar_Scroll_Up;
  1677.             CLV_Scroll_Vert(pListData, -1);
  1678.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Vert, FALSE);
  1679.             pListData->m_bMouseOverScrollbutton = TRUE;
  1680.             CLV_StartAutoRepeat(pListData);
  1681.         }
  1682.         // In down button
  1683.         else if(ptCursor.y > (pListData->m_rScrollbar_Vert.bottom - glb_pSkin->mpl_pVScrollBar_Down->m_iStateHeight) )
  1684.         {
  1685.             SetCapture(pListData->m_hWnd);
  1686.             pListData->m_enWindowMode = wmVScrollbar_Scroll_Down;
  1687.             CLV_Scroll_Vert(pListData, 1);
  1688.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Vert, FALSE);
  1689.             pListData->m_bMouseOverScrollbutton = TRUE;
  1690.             CLV_StartAutoRepeat(pListData);
  1691.         }
  1692.         // In top page area
  1693.         else if(ptCursor.y < pListData->m_rScrollbar_Vert_Thumb.top)
  1694.         {
  1695.             SetCapture(pListData->m_hWnd);
  1696.             pListData->m_enWindowMode = wmVScrollbar_Page_Up;
  1697.             CLV_Scroll_Vert(pListData, -pListData->m_iNumItemsOnPage);
  1698.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Vert, FALSE);
  1699.             CLV_StartAutoRepeat(pListData);
  1700.         }
  1701.         // In bottom page area
  1702.         else if(ptCursor.y > pListData->m_rScrollbar_Vert_Thumb.bottom)
  1703.         {
  1704.             SetCapture(pListData->m_hWnd);
  1705.             pListData->m_enWindowMode = wmVScrollbar_Page_Down;
  1706.             CLV_Scroll_Vert(pListData, pListData->m_iNumItemsOnPage);
  1707.             InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Vert, FALSE);
  1708.             CLV_StartAutoRepeat(pListData);
  1709.         }
  1710.     }
  1711.     // In list
  1712.     if(PtInRect(&pListData->m_rList, ptCursor) == TRUE)
  1713.     {
  1714.         pListData->m_enWindowMode = wmList_Click;
  1716.         // Get the item that we have clicked
  1717.         pListData->m_iClickedItem = CLV_YOffsetToItem(pListData, ptCursor.y);
  1718.         if(pListData->m_iClickedItem < 0 || pListData->m_iClickedItem >= pListData->m_iNumItems)
  1719.             pListData->m_iClickedItem = CPC_INVALIDITEM;
  1721.         // If shift is down - select a range
  1722.         if( (dwKeys & MK_SHIFT))
  1723.         {
  1724.             int iCorrectedClickedItem;
  1726.             // If CTRL isn't down - clear the selection
  1727.             if((dwKeys & MK_CONTROL) == 0)
  1728.                 CLV_ClearSelection(pListData);
  1730.             iCorrectedClickedItem = pListData->m_iClickedItem;
  1731.             if(iCorrectedClickedItem >= pListData->m_iNumItems || iCorrectedClickedItem == CPC_INVALIDITEM)
  1732.                 iCorrectedClickedItem = pListData->m_iNumItems - 1;
  1734.             if(pListData->m_iKeyboardAnchor == CPC_INVALIDITEM)
  1735.                 pListData->m_iKeyboardAnchor = pListData->m_iFocusItem;
  1736.             if(pListData->m_iKeyboardAnchor == CPC_INVALIDITEM)
  1737.                 pListData->m_iKeyboardAnchor = iCorrectedClickedItem;
  1740.             CLV_SelectRange(pListData, pListData->m_iKeyboardAnchor, iCorrectedClickedItem);
  1741.             pListData->m_iFocusItem = iCorrectedClickedItem;
  1742.             CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  1743.         }
  1744.         else
  1745.         {
  1746.             CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  1747.             pListData->m_iFocusItem = pListData->m_iClickedItem;
  1748.             CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  1749.             pListData->m_iKeyboardAnchor = pListData->m_iFocusItem;
  1750.         }
  1752.         // ... further processing on mouse up
  1753.     }
  1754. }
  1755. //
  1756. //
  1757. //
  1758. void CLV_Handle_WM_LBUTTONDBLCLK(CIs_ListViewData* pListData, const POINTS _ptCursor)
  1759. {
  1760.     POINT ptCursor;
  1762.     // Init
  1763.     ptCursor.x = _ptCursor.x;
  1764.     ptCursor.y = _ptCursor.y;
  1765.     pListData->m_ptMouseDown = ptCursor;
  1767.     // Hit test cursor
  1768.     // - in header?
  1769.     if(PtInRect(&pListData->m_rHeader, ptCursor) == TRUE)
  1770.     {
  1771.         // A double click in the resize area?
  1772.         int iHitTestColIDX = CLV_HitTest_HeaderSizer_X(pListData, ptCursor.x);
  1773.         if(iHitTestColIDX != CPC_INVALIDCOLUMN)
  1774.         {
  1775.             int iMinWidth = CPC_HEADERDRAG_HTWIDTH<<1;
  1776.             int iItemIDX;
  1777.             HDC dcWindow;
  1778.             SIZE szText;
  1779.             HFONT hfOld;
  1781.             // Resize column according to it's contents
  1782.             dcWindow = GetDC(pListData->m_hWnd);
  1783.             hfOld = (HFONT)SelectObject(dcWindow, glb_pSkin->mpl_hfFont);
  1785.             // Ensure col is big enough for the header
  1786.             if(pListData->m_pColumns[iHitTestColIDX].m_pColumnText)
  1787.             {
  1788.                 GetTextExtentPoint(dcWindow,
  1789.                                    pListData->m_pColumns[iHitTestColIDX].m_pColumnText,
  1790.                                    strlen(pListData->m_pColumns[iHitTestColIDX].m_pColumnText),
  1791.                                    &szText);
  1792.                 szText.cx += glb_pSkin->mpl_rListHeader_SourceTile.left
  1793.                              + (glb_pSkin->mpl_pListHeader_Up->m_szSize.cx-glb_pSkin->mpl_rListHeader_SourceTile.right);
  1795.                 if(szText.cx > iMinWidth)
  1796.                     iMinWidth = szText.cx;
  1797.             }
  1799.             // Go through all the items getting their widths
  1800.             if(pListData->m_pColumns[iHitTestColIDX].m_pfnTextAccessor)
  1801.             {
  1802.                 for(iItemIDX = 0; iItemIDX < pListData->m_iNumItems; iItemIDX++)
  1803.                 {
  1804.                     const char* pcText = pListData->m_pColumns[iHitTestColIDX].m_pfnTextAccessor(pListData->m_pItems[iItemIDX].m_pItemData);
  1805.                     if(pcText)
  1806.                     {
  1807.                         GetTextExtentPoint(dcWindow,
  1808.                                            pcText, strlen(pcText),
  1809.                                            &szText);
  1810.                         szText.cx += glb_pSkin->mpl_rListHeader_SourceTile.left
  1811.                                      + (glb_pSkin->mpl_pListHeader_Down->m_szSize.cx - glb_pSkin->mpl_rListHeader_SourceTile.right);
  1813.                         if(szText.cx > iMinWidth)
  1814.                             iMinWidth = szText.cx;
  1815.                     }
  1816.                 }
  1817.             }
  1819.             SelectObject(dcWindow, hfOld);
  1820.             ReleaseDC(pListData->m_hWnd, dcWindow);
  1822.             // Update column width
  1823.             pListData->m_pColumns[iHitTestColIDX].m_iColumnWidth = iMinWidth;
  1824.             CLV_InvalidateWindow(pListData);
  1825.             CLV_UpdateScrollBars(pListData);
  1826.             SetCursor(LoadCursor(NULL, IDC_ARROW)); // In a header
  1828.             // Send notify
  1829.             if(pListData->m_hndlr_HeaderChanged)
  1830.                 pListData->m_hndlr_HeaderChanged(pListData);
  1831.         }
  1832.     }
  1833.     else if(PtInRect(&pListData->m_rList, ptCursor) == TRUE)
  1834.     {
  1835.         CLV_ActionFocusedItem(pListData);
  1836.     }
  1837. }
  1838. //
  1839. //
  1840. //
  1841. void CLV_Handle_WM_RBUTTONDOWN(CIs_ListViewData* pListData, const POINTS _ptCursor)
  1842. {
  1843.     POINT ptCursor;
  1845.     // Init
  1846.     ptCursor.x = _ptCursor.x;
  1847.     ptCursor.y = _ptCursor.y;
  1849.     // Hit test cursor
  1850.     // - in header?
  1851.     if(PtInRect(&pListData->m_rHeader, ptCursor) == TRUE)
  1852.     {
  1853.         HMENU hmPopup;
  1854.         POINT ptMouse_Screen;
  1855.         UINT uiMenuResult;
  1856.         unsigned int _iColIDX;
  1858.         // Show a popup menu of all the columns so that the visibility can be affected
  1859.         hmPopup = CreatePopupMenu();
  1861.         // Build menu
  1862.         for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  1863.         {
  1864.             UINT uiMenuFlags;
  1865.             unsigned int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  1867.             // Skip if there is no text on this column (or it's not hidable)
  1868.             if(pListData->m_pColumns[iColumnIDX].m_pColumnText == NULL
  1869.                     || pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_NOHIDE)
  1870.             {
  1871.                 continue;
  1872.             }
  1874.             if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  1875.                 uiMenuFlags = 0;
  1876.             else
  1877.                 uiMenuFlags = MF_CHECKED;
  1879.             AppendMenu(hmPopup, MF_STRING | uiMenuFlags, iColumnIDX + 1, pListData->m_pColumns[iColumnIDX].m_pColumnText);
  1880.         }
  1882.         // Show menu
  1883.         ptMouse_Screen = ptCursor;
  1884.         ClientToScreen(pListData->m_hWnd, &ptMouse_Screen);
  1885.         uiMenuResult = TrackPopupMenu(hmPopup,
  1886.                                       TPM_NONOTIFY | TPM_RETURNCMD,
  1887.                                       ptMouse_Screen.x, ptMouse_Screen.y, 0,
  1888.                                       pListData->m_hWnd, NULL);
  1890.         // If there was a result - toggle the visible state of the item in question
  1891.         if(uiMenuResult != 0)
  1892.         {
  1893.             pListData->m_pColumns[uiMenuResult-1].m_dwFlags ^= CPLV_COLFLAG_HIDDEN;
  1894.             CLV_UpdateScrollBars(pListData);
  1895.             CLV_InvalidateWindow(pListData);
  1897.             // Send notify
  1898.             if(pListData->m_hndlr_HeaderChanged)
  1899.                 pListData->m_hndlr_HeaderChanged(pListData);
  1900.         }
  1902.         DestroyMenu(hmPopup);
  1903.     }
  1904.     else if(PtInRect(&pListData->m_rList, ptCursor) == TRUE)
  1905.     {
  1906.         int iItemIDX;
  1907.         int iColumnIDX;
  1909.         // Perform hit test
  1910.         iItemIDX = CLV_YOffsetToItem(pListData, ptCursor.y);
  1911.         iColumnIDX = CLV_HitTest_Header_X(pListData, ptCursor.x);
  1913.         if(iItemIDX < 0 || iItemIDX >= pListData->m_iNumItems)
  1914.             iItemIDX = CPC_INVALIDITEM;
  1916.         if(iItemIDX != CPC_INVALIDITEM && iColumnIDX != CPC_INVALIDCOLUMN)
  1917.         {
  1918.             if(pListData->m_iFocusItem != iItemIDX)
  1919.                 CLV_SetFocusItem(pListData, iItemIDX);
  1921.             // If the hit item isn't selected - clear selection (and select this item)
  1922.             if( (pListData->m_pItems[iItemIDX].m_dwFlags & CPLV_ITEMFLAG_SELECTED) == 0)
  1923.             {
  1924.                 CLV_ClearSelection(pListData);
  1925.                 pListData->m_pItems[iItemIDX].m_dwFlags |= CPLV_ITEMFLAG_SELECTED;
  1926.                 CLV_InvalidateItem(pListData, iItemIDX);
  1927.                 CLV_ItemSelChange(pListData, iItemIDX);
  1928.             }
  1930.             // Send notify
  1931.             if(pListData->m_hndlr_ItemRightClick)
  1932.                 pListData->m_hndlr_ItemRightClick(pListData, iItemIDX, iColumnIDX, pListData->m_pItems[iItemIDX].m_pItemData);
  1933.         }
  1934.         else
  1935.             CLV_ClearSelection(pListData);
  1936.     }
  1938. }
  1939. //
  1940. //
  1941. //
  1942. void CLV_Handle_WM_LBUTTONUP(CIs_ListViewData* pListData, const POINTS _ptCursor)
  1943. {
  1944.     if(pListData->m_enWindowMode != wmQuiescent)
  1945.         ReleaseCapture();
  1947.     // Invalidate header if we are in click or drag mode (because the header item should now be draw "up)
  1948.     if(pListData->m_enWindowMode == wmHeader_Click || pListData->m_enWindowMode == wmHeader_ChangeOrder)
  1949.         InvalidateRect(pListData->m_hWnd, &pListData->m_rHeader, FALSE);
  1950.     // Invalidate thumb if we were dragging it
  1951.     else if(pListData->m_enWindowMode == wmHScrollbar_DragThumb)
  1952.         InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz_Thumb, FALSE);
  1953.     else if(pListData->m_enWindowMode == wmHScrollbar_Scroll_Left || pListData->m_enWindowMode == wmHScrollbar_Scroll_Right)
  1954.         InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Horiz, FALSE);
  1955.     else if(pListData->m_enWindowMode == wmVScrollbar_DragThumb)
  1956.         InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Vert_Thumb, FALSE);
  1957.     else if(pListData->m_enWindowMode == wmVScrollbar_Scroll_Up || pListData->m_enWindowMode == wmVScrollbar_Scroll_Down)
  1958.         InvalidateRect(pListData->m_hWnd, &pListData->m_rScrollbar_Vert, FALSE);
  1960.     // Clear the autorepeat timer if we need to
  1961.     if(pListData->m_uiAutorepeatTimer)
  1962.     {
  1963.         KillTimer(pListData->m_hWnd, pListData->m_uiAutorepeatTimer);
  1964.         pListData->m_uiAutorepeatTimer = 0;
  1965.     }
  1967.     // Send header change notify if we need to
  1968.     if(pListData->m_hndlr_HeaderChanged
  1969.             && (pListData->m_enWindowMode == wmHeader_ChangeOrder || pListData->m_enWindowMode == wmHeader_ChangeWidth) )
  1970.     {
  1971.         pListData->m_hndlr_HeaderChanged(pListData);
  1972.     }
  1974.     // Send col header click if we need to
  1975.     if(pListData->m_enWindowMode == wmHeader_Click && pListData->m_hndlr_ColHeaderClick)
  1976.         pListData->m_hndlr_ColHeaderClick(pListData, pListData->m_iActiveHeaderCol);
  1978.     // If a list item was clicked then update selection
  1979.     if(pListData->m_enWindowMode == wmList_Click
  1980.             && pListData->m_iClickedItem != CPC_INVALIDITEM
  1981.             && pListData->m_iClickedItem < pListData->m_iNumItems
  1982.             && (pListData->m_dwMouseDown_Keys & MK_SHIFT) == 0)
  1983.     {
  1984.         // If CTRL isn't down - clear the selection
  1985.         if((pListData->m_dwMouseDown_Keys & MK_CONTROL) == 0)
  1986.             CLV_ClearSelection(pListData);
  1988.         // Toggle the selection of the clicked item
  1989.         pListData->m_pItems[pListData->m_iClickedItem].m_dwFlags ^= CPLV_ITEMFLAG_SELECTED;
  1990.         CLV_ItemSelChange(pListData, pListData->m_iClickedItem);
  1991.         CLV_InvalidateItem(pListData, pListData->m_iClickedItem);
  1992.     }
  1994.     // Reset window mode
  1995.     pListData->m_enWindowMode = wmQuiescent;
  1996. }
  1997. //
  1998. //
  1999. //
  2000. void CLV_Handle_WM_KEYDOWN(CIs_ListViewData* pListData, const int iVKeyCode)
  2001. {
  2002.     const BOOL bAltIsDown = (GetAsyncKeyState(VK_MENU)  & 0x8000) ? TRUE : FALSE;
  2003.     const BOOL bCtrlIsDown = (GetAsyncKeyState(VK_CONTROL)  & 0x8000) ? TRUE : FALSE;
  2004.     const BOOL bShiftIsDown = (GetAsyncKeyState(VK_SHIFT)  & 0x8000) ? TRUE : FALSE;
  2006.     switch(iVKeyCode)
  2007.     {
  2008.     case VK_UP:
  2009.     case VK_DOWN:
  2010.     case VK_PRIOR:
  2011.     case VK_NEXT:
  2012.     case VK_HOME:
  2013.     case VK_END:
  2014.         if(bAltIsDown == FALSE)
  2015.         {
  2016.             if(pListData->m_iNumItems > 0)
  2017.             {
  2018.                 int iNewFocusItemIDX = pListData->m_iFocusItem;
  2019.                 if(iNewFocusItemIDX == CPC_INVALIDITEM)
  2020.                     iNewFocusItemIDX = 0;
  2022.                 if(iVKeyCode == VK_UP)
  2023.                     iNewFocusItemIDX--;
  2024.                 else if(iVKeyCode == VK_DOWN)
  2025.                     iNewFocusItemIDX++;
  2026.                 else if(iVKeyCode == VK_PRIOR)
  2027.                     iNewFocusItemIDX -= pListData->m_iNumItemsOnPage;
  2028.                 else if(iVKeyCode == VK_NEXT)
  2029.                     iNewFocusItemIDX += pListData->m_iNumItemsOnPage;
  2030.                 else if(iVKeyCode == VK_HOME)
  2031.                     iNewFocusItemIDX = 0;
  2032.                 else if(iVKeyCode == VK_END)
  2033.                     iNewFocusItemIDX = pListData->m_iNumItems-1;
  2035.                 if(iNewFocusItemIDX < 0)
  2036.                     iNewFocusItemIDX = 0;
  2037.                 else if(iNewFocusItemIDX >= pListData->m_iNumItems)
  2038.                     iNewFocusItemIDX = pListData->m_iNumItems - 1;
  2040.                 if(iNewFocusItemIDX != pListData->m_iFocusItem)
  2041.                 {
  2042.                     // Update selection
  2043.                     if(bCtrlIsDown == FALSE)
  2044.                     {
  2045.                         CLV_ClearSelection(pListData);
  2046.                         pListData->m_pItems[iNewFocusItemIDX].m_dwFlags |= CPLV_ITEMFLAG_SELECTED;
  2047.                         CLV_ItemSelChange(pListData, iNewFocusItemIDX);
  2048.                     }
  2050.                     if(bShiftIsDown)
  2051.                     {
  2052.                         if(pListData->m_iKeyboardAnchor == CPC_INVALIDITEM)
  2053.                         {
  2054.                             if(pListData->m_iFocusItem != CPC_INVALIDITEM)
  2055.                                 pListData->m_iKeyboardAnchor = pListData->m_iFocusItem;
  2056.                             else
  2057.                                 pListData->m_iKeyboardAnchor = iNewFocusItemIDX;
  2058.                         }
  2060.                         if(pListData->m_iFocusItem != iNewFocusItemIDX)
  2061.                             CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  2063.                         pListData->m_iFocusItem = iNewFocusItemIDX;
  2064.                         CLV_EnsureVisible(pListData, iNewFocusItemIDX);
  2065.                         CLV_SelectRange(pListData, pListData->m_iKeyboardAnchor, pListData->m_iFocusItem);
  2066.                     }
  2067.                     else
  2068.                     {
  2069.                         CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  2070.                         pListData->m_iFocusItem = iNewFocusItemIDX;
  2071.                         CLV_InvalidateItem(pListData, iNewFocusItemIDX);
  2072.                         CLV_EnsureVisible(pListData, iNewFocusItemIDX);
  2073.                         pListData->m_iKeyboardAnchor = pListData->m_iFocusItem;
  2074.                     }
  2075.                 }
  2076.                 return;
  2077.             }
  2078.         }
  2079.         break;
  2081.     case VK_SPACE:
  2082.         if(pListData->m_iFocusItem != CPC_INVALIDITEM)
  2083.         {
  2084.             if(bCtrlIsDown == TRUE)
  2085.                 pListData->m_pItems[pListData->m_iFocusItem].m_dwFlags ^= CPLV_ITEMFLAG_SELECTED;
  2086.             else
  2087.                 pListData->m_pItems[pListData->m_iFocusItem].m_dwFlags |= CPLV_ITEMFLAG_SELECTED;
  2088.             CLV_ItemSelChange(pListData, pListData->m_iFocusItem);
  2089.             CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  2090.             CLV_EnsureVisible(pListData, pListData->m_iFocusItem);
  2091.         }
  2092.         return;
  2094.     case 'A':
  2095.         if(bCtrlIsDown == TRUE && pListData->m_iNumItems > 0)
  2096.         {
  2097.             CLV_SelectRange(pListData, 0, pListData->m_iNumItems-1);
  2098.         }
  2099.         return;
  2101.     case VK_RETURN:
  2102.         CLV_ActionFocusedItem(pListData);
  2103.         return;
  2104.     }
  2106.     // Default processing to parent
  2107.     if(pListData->m_hndlr_UnhandledKeyPress)
  2108.         pListData->m_hndlr_UnhandledKeyPress(pListData, iVKeyCode, bAltIsDown, bCtrlIsDown, bShiftIsDown);
  2109. }
  2110. //
  2111. //
  2112. //
  2113. LRESULT CALLBACK exp_ListViewWindowProc(HWND hWnd, UINT uiMessage, WPARAM wParam, LPARAM lParam)
  2114. {
  2115.     CIs_ListViewData* pListData;
  2117.     // Get the window's data object
  2118.     if(uiMessage == WM_NCCREATE)
  2119.     {
  2120.         pListData = (CIs_ListViewData*)((CREATESTRUCT*)lParam)->lpCreateParams;
  2121.         pListData->m_hWnd = hWnd;
  2122.         SetWindowLong(hWnd, GWL_USERDATA, (LONG)pListData);
  2123.     }
  2124.     else
  2125.         pListData = (CIs_ListViewData*)GetWindowLong(hWnd, GWL_USERDATA);
  2126.     CP_CHECKOBJECT(pListData);
  2128.     // Message handlers
  2129.     switch(uiMessage)
  2130.     {
  2131.     case WM_CREATE:
  2132.         {
  2133.             CREATESTRUCT* pCS = (CREATESTRUCT*)lParam;
  2134.             CLV_CalcItemHeight(pListData);
  2135.             CLV_UpdateWindowDims(pListData, pCS->cx, pCS->cy);
  2136.         }
  2137.         break;
  2139.     case WM_NCDESTROY:
  2140.         CLV_CleanupWindowData(pListData);
  2141.         break;
  2143.     case WM_PAINT:
  2144.         CLV_Handle_WM_PAINT(pListData);
  2145.         return 0;
  2147.     case WM_NCCALCSIZE:
  2148.         // We do not wish to have any window area lost to captions etc (also prevent the system
  2149.         // from preserving our window contents during a resize
  2150.         return WVR_REDRAW;
  2152.     case WM_WINDOWPOSCHANGED:
  2153.         {
  2154.             const WINDOWPOS* pWP = (const WINDOWPOS*)lParam;
  2155.             CLV_UpdateWindowDims(pListData, pWP->cx, pWP->cy);
  2156.         }
  2157.         return 0;
  2159.     case WM_DROPFILES:
  2160.         return SendMessage(GetParent(pListData->m_hWnd), WM_DROPFILES, wParam, lParam);
  2162.     case WM_MOUSEMOVE:
  2163.         CLV_Handle_WM_MOUSEMOVE(pListData, MAKEPOINTS(lParam));
  2164.         return 0;
  2166.     case WM_SYSKEYDOWN:
  2167.     case WM_KEYDOWN:
  2168.         CLV_Handle_WM_KEYDOWN(pListData, (int)wParam);
  2169.         return 0;
  2171.     case WM_LBUTTONDOWN:
  2172.         SetFocus(pListData->m_hWnd);
  2173.         CLV_Handle_WM_LBUTTONDOWN(pListData, MAKEPOINTS(lParam), (DWORD)wParam);
  2174.         return 0;
  2176.     case WM_LBUTTONUP:
  2177.         CLV_Handle_WM_LBUTTONUP(pListData, MAKEPOINTS(lParam));
  2178.         return 0;
  2180.     case WM_LBUTTONDBLCLK:
  2181.         CLV_Handle_WM_LBUTTONDBLCLK(pListData, MAKEPOINTS(lParam));
  2182.         return 0;
  2184.     case WM_RBUTTONDOWN:
  2185.         SetFocus(pListData->m_hWnd);
  2186.         CLV_Handle_WM_RBUTTONDOWN(pListData, MAKEPOINTS(lParam));
  2187.         return 0;
  2189.     case WM_MOUSEWHEEL:
  2190.         if((short)HIWORD(wParam) > 0)
  2191.             CLV_Scroll_Vert(pListData, -CPC_SCROLLBAR_MOUSEWHEELAMOUNT);
  2192.         else
  2193.             CLV_Scroll_Vert(pListData, CPC_SCROLLBAR_MOUSEWHEELAMOUNT);
  2194.         return 0;
  2196.     case WM_SETFOCUS:
  2197.         pListData->m_bHasFocus = TRUE;
  2198.         if(pListData->m_iFocusItem != CPC_INVALIDITEM)
  2199.             CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  2200.         return 0;
  2202.     case WM_KILLFOCUS:
  2203.         pListData->m_bHasFocus = FALSE;
  2204.         if(pListData->m_iFocusItem != CPC_INVALIDITEM)
  2205.             CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  2206.         return 0;
  2208.     case WM_TIMER:
  2209.         if(wParam == pListData->m_uiAutorepeatTimer)
  2210.             CLV_Handle_WM_TIMER_AUTOREPEAT(pListData);
  2211.         return 0;
  2212.     }
  2214.     return DefWindowProc(hWnd, uiMessage, wParam, lParam);
  2215. }
  2216. //
  2217. //
  2218. //
  2219. void CLV_AddColumn(CP_HLISTVIEW _hListData, const char* pcTitle, const int iWidth, wp_GetItemText pfnItemTextAccessor, const DWORD dwFlags)
  2220. {
  2221.     CIs_ListViewData* pListData;
  2222.     CIs_ListView_Column* pNewColumn;
  2223.     unsigned int iNewColumnIDX;
  2224.     pListData = (CIs_ListViewData*)_hListData;
  2225.     CP_CHECKOBJECT(pListData);
  2227.     // Allocate a new column
  2228.     iNewColumnIDX = pListData->m_iNumColumns;
  2229.     pListData->m_iNumColumns++;
  2230.     pListData->m_pColumns = (CIs_ListView_Column*)realloc(pListData->m_pColumns, pListData->m_iNumColumns * sizeof(CIs_ListView_Column));
  2231.     pListData->m_piColumnOrder = (unsigned int*)realloc(pListData->m_piColumnOrder, pListData->m_iNumColumns * sizeof(unsigned int));
  2232.     pListData->m_piColumnOrder[iNewColumnIDX] = iNewColumnIDX;
  2233.     pNewColumn = pListData->m_pColumns + iNewColumnIDX;
  2235.     // Setup it's data
  2236.     STR_AllocSetString(&pNewColumn->m_pColumnText, pcTitle, FALSE);
  2237.     pNewColumn->m_iColumnWidth = iWidth;
  2238.     pNewColumn->m_dwFlags = dwFlags;
  2239.     pNewColumn->m_pfnTextAccessor = pfnItemTextAccessor;
  2240.     pNewColumn->m_pfnGetCustomDrawColour = NULL;
  2241.     pNewColumn->m_enAlign = lcaLeft;
  2243.     // Cleanup
  2244.     CLV_InvalidateWindow(pListData);
  2245.     CLV_UpdateScrollBars(pListData);
  2246. }
  2247. //
  2248. //
  2249. //
  2250. void CLV_SetColumnCustomDrawColour(CP_HLISTVIEW _hListData, const int iColumnIDX, wp_GetItemDrawColour pfnGetCustomDrawColour)
  2251. {
  2252.     CIs_ListViewData* pListData;
  2253.     pListData = (CIs_ListViewData*)_hListData;
  2254.     CP_CHECKOBJECT(pListData);
  2256.     pListData->m_pColumns[iColumnIDX].m_pfnGetCustomDrawColour = pfnGetCustomDrawColour;
  2257. }
  2258. //
  2259. //
  2260. //
  2261. void CLV_SetColumnAlign(CP_HLISTVIEW _hListData, const int iColumnIDX, const CPe_ListColumnAlign enNewAlign)
  2262. {
  2263.     CIs_ListViewData* pListData;
  2264.     pListData = (CIs_ListViewData*)_hListData;
  2265.     CP_CHECKOBJECT(pListData);
  2267.     pListData->m_pColumns[iColumnIDX].m_enAlign = enNewAlign;
  2268. }
  2269. //
  2270. //
  2271. //
  2272. int CLV_AddItem(CP_HLISTVIEW _hListData, const void* pvItemData)
  2273. {
  2274.     CIs_ListViewData* pListData;
  2275.     int iNewItemIDX;
  2276.     pListData = (CIs_ListViewData*)_hListData;
  2277.     CP_CHECKOBJECT(pListData);
  2279.     // Do we need a bigger buffer?
  2280.     if(pListData->m_iNumItemsInBuffer == pListData->m_iNumItems)
  2281.     {
  2282.         pListData->m_iNumItemsInBuffer += CPC_BUFFERQUANTISATION;
  2283.         pListData->m_pItems = (CIs_ListView_Item*)realloc(pListData->m_pItems, pListData->m_iNumItemsInBuffer * sizeof(CIs_ListView_Item));
  2284.     }
  2286.     // Actually add the item
  2287.     iNewItemIDX = pListData->m_iNumItems;
  2288.     pListData->m_iNumItems++;
  2289.     pListData->m_pItems[iNewItemIDX].m_dwFlags = CPLV_ITEMFLAG_NONE;
  2290.     pListData->m_pItems[iNewItemIDX].m_pItemData = pvItemData;
  2292.     // Update the display
  2293.     if(pListData->m_bInBatch == FALSE)
  2294.     {
  2295.         CLV_UpdateScrollBars(pListData);
  2296.         CLV_InvalidateWindow(pListData);
  2297.     }
  2299.     return iNewItemIDX;
  2300. }
  2301. //
  2302. //
  2303. //
  2304. void CLV_RemoveAllItems(CP_HLISTVIEW _hListData)
  2305. {
  2306.     CIs_ListViewData* pListData;
  2307.     pListData = (CIs_ListViewData*)_hListData;
  2308.     CP_CHECKOBJECT(pListData);
  2310.     CLV_EmptyItems(pListData);
  2311.     if(pListData->m_bInBatch == FALSE)
  2312.     {
  2313.         CLV_UpdateScrollBars(pListData);
  2314.         CLV_InvalidateWindow(pListData);
  2315.     }
  2316.     pListData->m_iFocusItem = CPC_INVALIDITEM;
  2317.     pListData->m_iKeyboardAnchor = CPC_INVALIDITEM;
  2318. }
  2319. //
  2320. //
  2321. //
  2322. int CLV_GetFocusItem(CP_HLISTVIEW _hListData)
  2323. {
  2324.     CIs_ListViewData* pListData;
  2325.     pListData = (CIs_ListViewData*)_hListData;
  2326.     CP_CHECKOBJECT(pListData);
  2328.     return pListData->m_iFocusItem;
  2329. }
  2330. //
  2331. //
  2332. //
  2333. void CLV_SetFocusItem(CP_HLISTVIEW _hListData, int iNewItemIDX)
  2334. {
  2335.     CIs_ListViewData* pListData;
  2336.     pListData = (CIs_ListViewData*)_hListData;
  2337.     CP_CHECKOBJECT(pListData);
  2339.     if(pListData->m_iFocusItem != CPC_INVALIDITEM)
  2340.         CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  2342.     pListData->m_iFocusItem = iNewItemIDX;
  2344.     if(pListData->m_iFocusItem != CPC_INVALIDITEM)
  2345.         CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  2346. }
  2347. //
  2348. //
  2349. //
  2350. void CLV_sethandler_DrawBackgroundRect(CP_HLISTVIEW _hListData, wp_DrawBackgroundRect pfnHandler)
  2351. {
  2352.     CIs_ListViewData* pListData;
  2353.     pListData = (CIs_ListViewData*)_hListData;
  2354.     CP_CHECKOBJECT(pListData);
  2356.     pListData->m_hndlr_DrawBackgroundRect = pfnHandler;
  2357. }
  2358. //
  2359. //
  2360. //
  2361. void CLV_sethandler_HeaderChanged(CP_HLISTVIEW _hListData, wp_HeaderChanged pfnHandler)
  2362. {
  2363.     CIs_ListViewData* pListData;
  2364.     pListData = (CIs_ListViewData*)_hListData;
  2365.     CP_CHECKOBJECT(pListData);
  2367.     pListData->m_hndlr_HeaderChanged = pfnHandler;
  2368. }
  2369. //
  2370. //
  2371. //
  2372. void CLV_sethandler_ItemSelected(CP_HLISTVIEW _hListData, wp_ItemCallback pfnHandler)
  2373. {
  2374.     CIs_ListViewData* pListData;
  2375.     pListData = (CIs_ListViewData*)_hListData;
  2376.     CP_CHECKOBJECT(pListData);
  2378.     pListData->m_hndlr_ItemSelected = pfnHandler;
  2379. }
  2380. //
  2381. //
  2382. //
  2383. void CLV_sethandler_ItemAction(CP_HLISTVIEW _hListData, wp_ItemCallback pfnHandler)
  2384. {
  2385.     CIs_ListViewData* pListData;
  2386.     pListData = (CIs_ListViewData*)_hListData;
  2387.     CP_CHECKOBJECT(pListData);
  2389.     pListData->m_hndlr_ItemAction = pfnHandler;
  2390. }
  2391. //
  2392. //
  2393. //
  2394. void CLV_sethandler_ItemDrag(CP_HLISTVIEW _hListData, wp_ItemCallback pfnHandler)
  2395. {
  2396.     CIs_ListViewData* pListData;
  2397.     pListData = (CIs_ListViewData*)_hListData;
  2398.     CP_CHECKOBJECT(pListData);
  2400.     pListData->m_hndlr_ItemDrag = pfnHandler;
  2401. }
  2402. //
  2403. //
  2404. //
  2405. void CLV_sethandler_ItemRightClick(CP_HLISTVIEW _hListData, wp_ItemSubCallback pfnHandler)
  2406. {
  2407.     CIs_ListViewData* pListData;
  2408.     pListData = (CIs_ListViewData*)_hListData;
  2409.     CP_CHECKOBJECT(pListData);
  2411.     pListData->m_hndlr_ItemRightClick = pfnHandler;
  2412. }
  2413. //
  2414. //
  2415. //
  2416. void CLV_sethandler_ColHeaderClick(CP_HLISTVIEW _hListData, wp_ColHeaderClick pfnHandler)
  2417. {
  2418.     CIs_ListViewData* pListData;
  2419.     pListData = (CIs_ListViewData*)_hListData;
  2420.     CP_CHECKOBJECT(pListData);
  2422.     pListData->m_hndlr_ColHeaderClick = pfnHandler;
  2423. }
  2424. //
  2425. //
  2426. //
  2427. void CLV_sethandler_UnhandledKeyPress(CP_HLISTVIEW _hListData, wp_UnhandledKeyPress pfnHandler)
  2428. {
  2429.     CIs_ListViewData* pListData;
  2430.     pListData = (CIs_ListViewData*)_hListData;
  2431.     CP_CHECKOBJECT(pListData);
  2433.     pListData->m_hndlr_UnhandledKeyPress = pfnHandler;
  2434. }
  2435. //
  2436. //
  2437. //
  2438. void CLV_GetColumnOrder(CP_HLISTVIEW _hListData, unsigned int* pOrder, const unsigned int iNumColumnsInArray)
  2439. {
  2440.     CIs_ListViewData* pListData;
  2441.     pListData = (CIs_ListViewData*)_hListData;
  2442.     CP_CHECKOBJECT(pListData);
  2443.     CP_ASSERT(iNumColumnsInArray == pListData->m_iNumColumns);
  2445.     memcpy(pOrder, pListData->m_piColumnOrder, pListData->m_iNumColumns * sizeof(*pListData->m_piColumnOrder) );
  2446. }
  2447. //
  2448. //
  2449. //
  2450. void CLV_SetColumnOrder(CP_HLISTVIEW _hListData, const unsigned int* pOrder, const unsigned int iNumColumnsInArray)
  2451. {
  2452.     CIs_ListViewData* pListData;
  2453.     pListData = (CIs_ListViewData*)_hListData;
  2454.     CP_CHECKOBJECT(pListData);
  2455.     CP_ASSERT(iNumColumnsInArray == pListData->m_iNumColumns);
  2457.     memcpy(pListData->m_piColumnOrder, pOrder, pListData->m_iNumColumns * sizeof(*pListData->m_piColumnOrder) );
  2458. }
  2459. //
  2460. //
  2461. //
  2462. void CLV_GetColumnVisibleState(CP_HLISTVIEW _hListData, BOOL* pStates, const unsigned int iNumColumnsInArray)
  2463. {
  2464.     CIs_ListViewData* pListData;
  2465.     unsigned int iColIDX;
  2466.     pListData = (CIs_ListViewData*)_hListData;
  2467.     CP_CHECKOBJECT(pListData);
  2468.     CP_ASSERT(iNumColumnsInArray == pListData->m_iNumColumns);
  2470.     for(iColIDX = 0; iColIDX < pListData->m_iNumColumns; iColIDX++)
  2471.         pStates[iColIDX] = (pListData->m_pColumns[iColIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN) ? FALSE : TRUE;
  2472. }
  2473. //
  2474. //
  2475. //
  2476. void CLV_GetColumnWidths(CP_HLISTVIEW _hListData, int* pWidths, const unsigned int iNumColumnsInArray)
  2477. {
  2478.     CIs_ListViewData* pListData;
  2479.     unsigned int iColIDX;
  2480.     pListData = (CIs_ListViewData*)_hListData;
  2481.     CP_CHECKOBJECT(pListData);
  2482.     CP_ASSERT(iNumColumnsInArray == pListData->m_iNumColumns);
  2484.     for(iColIDX = 0; iColIDX < pListData->m_iNumColumns; iColIDX++)
  2485.         pWidths[iColIDX] = pListData->m_pColumns[iColIDX].m_iColumnWidth;
  2486. }
  2487. //
  2488. //
  2489. //
  2490. void CLV_ClearSelection(CP_HLISTVIEW _hListData)
  2491. {
  2492.     CIs_ListViewData* pListData;
  2493.     int iItemIDX;
  2494.     pListData = (CIs_ListViewData*)_hListData;
  2495.     CP_CHECKOBJECT(pListData);
  2497.     for(iItemIDX = 0; iItemIDX < pListData->m_iNumItems; iItemIDX++)
  2498.     {
  2499.         if(pListData->m_bInBatch == FALSE && pListData->m_pItems[iItemIDX].m_dwFlags & CPLV_ITEMFLAG_SELECTED)
  2500.             CLV_InvalidateItem(pListData, iItemIDX);
  2502.         pListData->m_pItems[iItemIDX].m_dwFlags &= ~CPLV_ITEMFLAG_SELECTED;
  2503.         CLV_ItemSelChange(pListData, iItemIDX);
  2504.     }
  2505. }
  2506. //
  2507. //
  2508. //
  2509. int CLV_GetNextSelectedItem(CP_HLISTVIEW _hListData, const int _iSearchStart)
  2510. {
  2511.     CIs_ListViewData* pListData;
  2512.     int iItemIDX;
  2513.     int iSearchStart;
  2514.     pListData = (CIs_ListViewData*)_hListData;
  2515.     CP_CHECKOBJECT(pListData);
  2517.     // Decide on where to start the search
  2518.     if(_iSearchStart == CPC_INVALIDITEM)
  2519.         iSearchStart = 0;
  2520.     else
  2521.         iSearchStart = _iSearchStart + 1;
  2523.     // Search array for selected items
  2524.     for(iItemIDX = iSearchStart; iItemIDX < pListData->m_iNumItems; iItemIDX++)
  2525.     {
  2526.         if(pListData->m_pItems[iItemIDX].m_dwFlags & CPLV_ITEMFLAG_SELECTED)
  2527.             return iItemIDX;
  2528.     }
  2530.     return CPC_INVALIDITEM;
  2531. }
  2532. //
  2533. //
  2534. //
  2535. int CLV_GetPrevSelectedItem(CP_HLISTVIEW _hListData, const int _iSearchStart)
  2536. {
  2537.     CIs_ListViewData* pListData;
  2538.     int iItemIDX;
  2539.     int iSearchStart;
  2540.     pListData = (CIs_ListViewData*)_hListData;
  2541.     CP_CHECKOBJECT(pListData);
  2543.     // Decide on where to start the search
  2544.     if(_iSearchStart == CPC_INVALIDITEM)
  2545.         iSearchStart = pListData->m_iNumItems-1;
  2546.     else
  2547.         iSearchStart = _iSearchStart - 1;
  2549.     // Search array for selected items
  2550.     for(iItemIDX = iSearchStart; iItemIDX >= 0; iItemIDX--)
  2551.     {
  2552.         if(pListData->m_pItems[iItemIDX].m_dwFlags & CPLV_ITEMFLAG_SELECTED)
  2553.             return iItemIDX;
  2554.     }
  2556.     return CPC_INVALIDITEM;
  2557. }
  2558. //
  2559. //
  2560. //
  2561. void CLV_SetItemSelected(CP_HLISTVIEW _hListData, const int iItemIDX, const BOOL bSelected)
  2562. {
  2563.     CIs_ListViewData* pListData;
  2564.     pListData = (CIs_ListViewData*)_hListData;
  2565.     CP_CHECKOBJECT(pListData);
  2566.     CP_ASSERT(iItemIDX >= 0);
  2567.     CP_ASSERT(iItemIDX < pListData->m_iNumItems);
  2569.     if(bSelected)
  2570.         pListData->m_pItems[iItemIDX].m_dwFlags |= CPLV_ITEMFLAG_SELECTED;
  2571.     else
  2572.         pListData->m_pItems[iItemIDX].m_dwFlags &= ~CPLV_ITEMFLAG_SELECTED;
  2573.     CLV_ItemSelChange(pListData, iItemIDX);
  2574.     if(pListData->m_bInBatch == FALSE)
  2575.         CLV_InvalidateItem(pListData, iItemIDX);
  2576. }
  2577. //
  2578. //
  2579. //
  2580. BOOL CLV_IsItemSelected(CP_HLISTVIEW _hListData, const int iItemIDX)
  2581. {
  2582.     CIs_ListViewData* pListData;
  2583.     pListData = (CIs_ListViewData*)_hListData;
  2584.     CP_CHECKOBJECT(pListData);
  2585.     CP_ASSERT(iItemIDX >= 0);
  2586.     CP_ASSERT(iItemIDX < pListData->m_iNumItems);
  2588.     if(pListData->m_pItems[iItemIDX].m_dwFlags & CPLV_ITEMFLAG_SELECTED)
  2589.         return TRUE;
  2591.     return FALSE;
  2592. }
  2593. //
  2594. //
  2595. //
  2596. void CLV_SetItemData(CP_HLISTVIEW _hListData, const int iItemIDX, const void* pvItemData)
  2597. {
  2598.     CIs_ListViewData* pListData;
  2599.     pListData = (CIs_ListViewData*)_hListData;
  2600.     CP_CHECKOBJECT(pListData);
  2601.     CP_ASSERT(iItemIDX >= 0);
  2602.     CP_ASSERT(iItemIDX < pListData->m_iNumItems);
  2604.     pListData->m_pItems[iItemIDX].m_pItemData = pvItemData;
  2606.     if(pListData->m_bInBatch == FALSE)
  2607.         CLV_InvalidateItem(pListData, iItemIDX);
  2608. }
  2609. //
  2610. //
  2611. //
  2612. const void* CLV_GetItemData(CP_HLISTVIEW _hListData, const int iItemIDX)
  2613. {
  2614.     CIs_ListViewData* pListData;
  2615.     pListData = (CIs_ListViewData*)_hListData;
  2616.     CP_CHECKOBJECT(pListData);
  2617.     CP_ASSERT(iItemIDX >= 0);
  2618.     CP_ASSERT(iItemIDX < pListData->m_iNumItems);
  2620.     return pListData->m_pItems[iItemIDX].m_pItemData;
  2621. }
  2622. //
  2623. //
  2624. //
  2625. void CLV_EnsureVisible(CP_HLISTVIEW _hListData, const int iItemIDX)
  2626. {
  2627.     CIs_ListViewData* pListData;
  2629.     pListData = (CIs_ListViewData*)_hListData;
  2630.     CP_CHECKOBJECT(pListData);
  2631.     CP_ASSERT(iItemIDX >= 0);
  2632.     CP_ASSERT(iItemIDX < pListData->m_iNumItems);
  2634.     if(iItemIDX < pListData->m_iFirstVisibleItem)
  2635.     {
  2636.         pListData->m_iFirstVisibleItem = iItemIDX;
  2637.         CLV_InvalidateWindow(pListData);
  2638.         CLV_UpdateScrollBars(pListData);
  2639.     }
  2640.     else
  2641.     {
  2642.         int iListRectHeight_CompleteLines;
  2643.         iListRectHeight_CompleteLines = CLV_GetListRect_Lines(pListData) - 1;
  2644.         if(iItemIDX > (pListData->m_iFirstVisibleItem + iListRectHeight_CompleteLines) )
  2645.         {
  2646.             pListData->m_iFirstVisibleItem = iItemIDX - iListRectHeight_CompleteLines;
  2647.             CLV_InvalidateWindow(pListData);
  2648.             CLV_UpdateScrollBars(pListData);
  2649.         }
  2650.     }
  2651. }
  2652. //
  2653. //
  2654. //
  2655. void CLV_SetItem(CP_HLISTVIEW _hListData, const int iItemIDX, const void* pvItemData)
  2656. {
  2657.     CIs_ListViewData* pListData;
  2659.     pListData = (CIs_ListViewData*)_hListData;
  2660.     CP_CHECKOBJECT(pListData);
  2661.     CP_ASSERT(iItemIDX >= 0);
  2662.     CP_ASSERT(iItemIDX < pListData->m_iNumItems);
  2664.     pListData->m_pItems[iItemIDX].m_pItemData = pvItemData;
  2666. }
  2667. //
  2668. //
  2669. //
  2670. void CLV_DeleteItem(CP_HLISTVIEW _hListData, const int iItemToDelete)
  2671. {
  2672.     CIs_ListViewData* pListData;
  2673.     int iItemIDX;
  2675.     pListData = (CIs_ListViewData*)_hListData;
  2676.     CP_CHECKOBJECT(pListData);
  2677.     CP_ASSERT(iItemToDelete >= 0);
  2678.     CP_ASSERT(iItemToDelete < pListData->m_iNumItems);
  2680.     // Shunt all items down one
  2681.     if(pListData->m_iNumItems == 1)
  2682.         CLV_RemoveAllItems(_hListData);
  2683.     else
  2684.     {
  2685.         if(iItemToDelete == pListData->m_iKeyboardAnchor)
  2686.             pListData->m_iKeyboardAnchor = CPC_INVALIDITEM;
  2687.         else if(iItemToDelete < pListData->m_iKeyboardAnchor)
  2688.             pListData->m_iKeyboardAnchor--;
  2690.         // Remove item (and shunt items down)
  2691.         pListData->m_iNumItems--;
  2692.         for(iItemIDX = iItemToDelete; iItemIDX < pListData->m_iNumItems; iItemIDX++)
  2693.             pListData->m_pItems[iItemIDX] = pListData->m_pItems[iItemIDX+1];
  2695.         // Ensure that the focus and anchor items are still valid
  2696.         if(pListData->m_iFocusItem >= pListData->m_iNumItems)
  2697.         {
  2698.             pListData->m_iFocusItem = pListData->m_iNumItems - 1;
  2699.             CLV_InvalidateItem(pListData, pListData->m_iFocusItem);
  2700.         }
  2702.         // Perform invalidation
  2703.         if(pListData->m_bInBatch == FALSE)
  2704.         {
  2705.             CLV_InvalidateWindow(pListData);
  2706.             CLV_UpdateScrollBars(pListData);
  2707.         }
  2708.     }
  2709. }
  2710. //
  2711. //
  2712. //
  2713. int CLV_GetItemCount(CP_HLISTVIEW _hListData)
  2714. {
  2715.     CIs_ListViewData* pListData;
  2717.     pListData = (CIs_ListViewData*)_hListData;
  2718.     CP_CHECKOBJECT(pListData);
  2720.     return pListData->m_iNumItems;
  2721. }
  2722. //
  2723. //
  2724. //
  2725. int CLV_GetNearestItem(CP_HLISTVIEW _hListData, const POINT* ptMouse)
  2726. {
  2727.     CIs_ListViewData* pListData;
  2728.     int iHitItemIDX;
  2730.     pListData = (CIs_ListViewData*)_hListData;
  2731.     CP_CHECKOBJECT(pListData);
  2733.     if(pListData->m_iNumItems == 0)
  2734.         return CPC_INVALIDITEM;
  2736.     iHitItemIDX = CLV_YOffsetToItem(pListData, ptMouse->y);
  2737.     if(iHitItemIDX < 0)
  2738.         iHitItemIDX = 0;
  2739.     if(iHitItemIDX >= pListData->m_iNumItems)
  2740.         iHitItemIDX = pListData->m_iNumItems-1;
  2742.     return iHitItemIDX;
  2743. }
  2744. //
  2745. //
  2746. //
  2747. void CLV_GetItemSubRect(CP_HLISTVIEW _hListData, RECT* pRect, const int iTargetItemIDX, const int iTargetColumnIDX)
  2748. {
  2749.     CIs_ListViewData* pListData;
  2750.     unsigned int _iColIDX;
  2751.     int iCursorX;
  2753.     pListData = (CIs_ListViewData*)_hListData;
  2754.     CP_CHECKOBJECT(pListData);
  2755.     CP_ASSERT(iTargetItemIDX >= 0);
  2756.     CP_ASSERT(iTargetItemIDX < pListData->m_iNumItems);
  2757.     CP_ASSERT(iTargetColumnIDX >= 0);
  2758.     CP_ASSERT(iTargetColumnIDX < (int)pListData->m_iNumColumns);
  2760.     // Work out top and bottom
  2761.     pRect->top = pListData->m_rList.top + ( (iTargetItemIDX - pListData->m_iFirstVisibleItem) * pListData->m_iItemHeight);
  2762.     pRect->bottom = pRect->top + pListData->m_iItemHeight;
  2764.     iCursorX = -pListData->m_iXOrigin;
  2765.     for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  2766.     {
  2767.         int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  2768.         if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  2769.             continue;
  2771.         if(iColumnIDX == iTargetColumnIDX)
  2772.         {
  2773.             pRect->left = iCursorX;
  2774.             pRect->right = pRect->left + pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  2775.             break;
  2776.         }
  2777.         iCursorX += pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  2778.     }
  2780.     // Clip to the list rect
  2781.     if(pRect->left < pListData->m_rList.left)
  2782.         pRect->left = pListData->m_rList.left;
  2783.     if(pRect->right > pListData->m_rList.right)
  2784.         pRect->right = pListData->m_rList.right;
  2785.     if(pRect->top < pListData->m_rList.top)
  2786.         pRect->top = pListData->m_rList.top;
  2787.     if(pRect->bottom > pListData->m_rList.right)
  2788.         pRect->bottom = pListData->m_rList.bottom;
  2789. }
  2790. //
  2791. //
  2792. //
  2793. void CLV_InvalidateColumn(CP_HLISTVIEW _hListData, const int iInvalidColumnIDX)
  2794. {
  2795.     CIs_ListViewData* pListData;
  2796.     RECT rInvalid;
  2797.     unsigned int _iColIDX;
  2798.     int iCursorX;
  2800.     pListData = (CIs_ListViewData*)_hListData;
  2801.     CP_CHECKOBJECT(pListData);
  2803.     // Hidden?
  2804.     if(pListData->m_pColumns[iInvalidColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  2805.         return;
  2807.     // Find the start point of the column
  2808.     iCursorX = -pListData->m_iXOrigin;
  2809.     for(_iColIDX = 0; _iColIDX < pListData->m_iNumColumns; _iColIDX++)
  2810.     {
  2811.         unsigned int iColumnIDX = pListData->m_piColumnOrder[_iColIDX];
  2812.         if((int)iColumnIDX == iInvalidColumnIDX)
  2813.             break;
  2814.         if(pListData->m_pColumns[iColumnIDX].m_dwFlags & CPLV_COLFLAG_HIDDEN)
  2815.             continue;
  2816.         iCursorX += pListData->m_pColumns[iColumnIDX].m_iColumnWidth;
  2817.     }
  2819.     rInvalid.top = 0;
  2820.     rInvalid.bottom = pListData->m_rClient.bottom;
  2821.     rInvalid.left = iCursorX;
  2822.     rInvalid.right = rInvalid.left + pListData->m_pColumns[iInvalidColumnIDX].m_iColumnWidth;
  2823.     InvalidateRect(pListData->m_hWnd, &rInvalid, FALSE);
  2824. }
  2825. //
  2826. //
  2827. //
  2828. void CLV_Invalidate(CP_HLISTVIEW _hListData)
  2829. {
  2830.     CIs_ListViewData* pListData;
  2831.     pListData = (CIs_ListViewData*)_hListData;
  2832.     CP_CHECKOBJECT(pListData);
  2834.     InvalidateRect(pListData->m_hWnd, NULL, FALSE);
  2835. }
  2836. //
  2837. //
  2838. //