ShuriZma
/
project64
mirror of https://github.com/project64/project64.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
project64/Source/Project64/UserInterface/WTLControls/ClistCtrl/ListCtrl.h

3911 lines
125 KiB
C++
Raw Blame History

// CListCtrl - A WTL list control with Windows Vista style item selection
// Revision: 1.5
// Last modified: 2nd November 2016
#pragma once
#include <algorithm>
#include <set>
#pragma warning(push)
#pragma warning(disable : 4838) // warning C4838: conversion from 'int' to 'UINT' requires a narrowing conversion
#include <wtl/atlctrlx.h>
#include <wtl/atlframe.h>
#include <wtl/atlgdi.h>
#include <wtl/atlmisc.h>
#pragma warning(pop)
#include "DragDrop.h"
#include "DropArrows.h"
#include "ListCombo.h"
#include "ListDate.h"
#include "ListEdit.h"
#include "TitleTip.h"
struct CListColumn
{
stdstr m_strText;
int m_nWidth;
BOOL m_bFixed;
UINT m_nFormat;
UINT m_nFlags;
int m_nImage;
int m_nIndex;
CListArray<stdstr> m_aComboList;
};
template <class T>
class CListImpl : public CWindowImpl<CListImpl<T>>, public CDoubleBufferImpl<CListImpl<T>>
{
public:
CListImpl()
{
m_bSortEnabled = TRUE; // Added by Rowan 05/12/2006
m_bRightClickSelect = FALSE; // Shygoo 11/02/2016
m_bShowHeader = TRUE;
m_bSortAscending = TRUE;
m_bButtonDown = FALSE;
m_bMouseOver = FALSE;
m_bColumnSizing = FALSE;
m_bBeginSelect = FALSE;
m_bSingleSelect = FALSE;
m_bFocusSubItem = FALSE;
m_bGroupSelect = FALSE;
m_bEnableHorizScroll = FALSE;
m_bEnableVertScroll = FALSE;
m_bShowHorizScroll = TRUE;
m_bShowVertScroll = TRUE;
m_bShowSort = TRUE;
m_bResizeTimer = FALSE;
m_bDragDrop = FALSE;
m_bSmoothScroll = TRUE;
m_bEditItem = FALSE;
m_bScrolling = FALSE;
m_bScrollDown = FALSE;
m_bTileBackground = FALSE;
m_nMouseWheelScroll = 3;
m_nTotalWidth = 0;
m_nHeaderHeight = 0;
m_nItemHeight = 0;
m_nFirstSelected = NULL_ITEM;
m_nFocusItem = NULL_ITEM;
m_nFocusSubItem = NULL_SUBITEM;
m_nHotItem = NULL_ITEM;
m_nHotSubItem = NULL_SUBITEM;
m_nTitleTipItem = NULL_ITEM;
m_nTitleTipSubItem = NULL_SUBITEM;
m_nSortColumn = NULL_COLUMN;
m_nHighlightColumn = NULL_COLUMN;
m_nDragColumn = NULL_COLUMN;
m_nHotColumn = NULL_COLUMN;
m_nHotDivider = NULL_COLUMN;
m_nColumnSizing = NULL_COLUMN;
m_nScrollOffset = 0;
m_nScrollDelta = 0;
m_nScrollUnit = 0;
m_nStartScrollPos = 0;
m_nStartSize = 0;
m_nStartPos = 0;
m_ptDownPoint = 0;
m_ptSelectPoint = 0;
m_rcGroupSelect = 0;
m_dwSearchTick = 0;
m_dwScrollTick = 0;
m_strSearchString = _T( "" );
}
~CListImpl()
{
if (m_wndItemEdit.IsWindow())
{
// Patch memory window crash
m_wndItemEdit.UnsubclassWindow();
}
}
protected:
BOOL m_bSortEnabled; // Added by Rowan 05/12/2006 to disable sorting
BOOL m_bRightClickSelect; // Shygoo 11/02/2016
BOOL m_bShowHeader;
BOOL m_bShowSort;
BOOL m_bSortAscending;
BOOL m_bButtonDown;
BOOL m_bMouseOver;
BOOL m_bColumnSizing;
BOOL m_bBeginSelect;
BOOL m_bSingleSelect;
BOOL m_bFocusSubItem;
BOOL m_bGroupSelect;
BOOL m_bShowHorizScroll;
BOOL m_bShowVertScroll;
BOOL m_bEnableHorizScroll;
BOOL m_bEnableVertScroll;
BOOL m_bResizeTimer;
BOOL m_bDragDrop;
BOOL m_bSmoothScroll;
BOOL m_bEditItem;
BOOL m_bScrolling;
BOOL m_bScrollDown;
BOOL m_bTileBackground;
CPoint m_ptDownPoint;
CPoint m_ptSelectPoint;
CRect m_rcGroupSelect;
int m_nItemHeight;
int m_nHeaderHeight;
int m_nFirstSelected;
int m_nFocusItem;
int m_nFocusSubItem;
int m_nHotItem;
int m_nHotSubItem;
int m_nTitleTipItem;
int m_nTitleTipSubItem;
int m_nMouseWheelScroll;
int m_nTotalWidth;
int m_nSortColumn;
int m_nDragColumn;
int m_nHighlightColumn;
int m_nHotColumn;
int m_nHotDivider;
int m_nColumnSizing;
int m_nScrollOffset;
int m_nScrollDelta;
int m_nScrollUnit;
int m_nStartScrollPos;
int m_nStartSize;
int m_nStartPos;
DWORD m_dwSearchTick;
DWORD m_dwScrollTick;
stdstr m_strSearchString;
CBitmap m_bmpScrollList;
CBitmap m_bmpBackground;
CLIPFORMAT m_nHeaderClipboardFormat;
COLORREF m_rgbBackground;
COLORREF m_rgbHeaderBackground;
COLORREF m_rgbHeaderBorder;
COLORREF m_rgbHeaderShadow;
COLORREF m_rgbHeaderText;
COLORREF m_rgbHeaderHighlight;
COLORREF m_rgbSelectedItem;
COLORREF m_rgbSelectedText;
COLORREF m_rgbItemText;
COLORREF m_rgbSelectOuter;
COLORREF m_rgbSelectInner;
COLORREF m_rgbSelectTop;
COLORREF m_rgbSelectBottom;
COLORREF m_rgbNoFocusTop;
COLORREF m_rgbNoFocusBottom;
COLORREF m_rgbNoFocusOuter;
COLORREF m_rgbNoFocusInner;
COLORREF m_rgbFocusTop;
COLORREF m_rgbFocusBottom;
COLORREF m_rgbProgressTop;
COLORREF m_rgbProgressBottom;
COLORREF m_rgbItemFocus;
COLORREF m_rgbHyperLink;
CCursor m_curDivider;
CCursor m_curHyperLink;
CFont m_fntListFont;
CFont m_fntUnderlineFont;
CImageList m_ilListItems;
CImageList m_ilItemImages;
CDragDrop<CListImpl> m_oleDragDrop;
CToolTipCtrl m_ttToolTip;
CDropArrows m_wndDropArrows;
CTitleTip m_wndTitleTip;
CListEdit m_wndItemEdit;
CListCombo m_wndItemCombo;
CListDate m_wndItemDate;
CListArray<CListColumn> m_aColumns;
set<int> m_setSelectedItems;
public:
BOOL SubclassWindow(HWND hWnd)
{
T * pT;
pT = static_cast<T *>(this);
return CWindowImpl<CListImpl>::SubclassWindow(hWnd) ? pT->Initialise() : FALSE;
}
void RegisterClass()
{
T * pT = static_cast<T *>(this);
pT = pT;
pT->GetWndClassInfo().m_wc.lpfnWndProc = m_pfnSuperWindowProc;
pT->GetWndClassInfo().Register(&m_pfnSuperWindowProc);
}
BOOL Initialise()
{
// Load list images
if (!m_ilListItems.CreateFromImage(IDB_LISTITEMS, 16, 0, RGB(255, 0, 255), IMAGE_BITMAP, LR_CREATEDIBSECTION))
return FALSE;
if (m_curDivider.LoadCursor(IDC_DIVIDER) == nullptr)
return FALSE;
if (m_curHyperLink.LoadCursor(IDC_HYPERLINK) == nullptr)
return FALSE;
// Load interface settings
if (!LoadSettings())
return FALSE;
// Give control a static border
ModifyStyle(WS_BORDER, WS_CLIPCHILDREN);
ModifyStyleEx(WS_EX_CLIENTEDGE, WS_EX_STATICEDGE, SWP_FRAMECHANGED);
// Register drag drop
m_oleDragDrop.Register(this);
m_oleDragDrop.AddTargetFormat(m_nHeaderClipboardFormat);
m_oleDragDrop.AddSourceFormat(m_nHeaderClipboardFormat);
// Create the tooltip
if (!m_ttToolTip.Create(m_hWnd))
return FALSE;
m_ttToolTip.SetMaxTipWidth(SHRT_MAX);
return TRUE;
}
BOOL LoadSettings()
{
m_rgbBackground = GetSysColor(COLOR_WINDOW);
m_rgbHeaderBackground = GetSysColor(COLOR_BTNFACE);
m_rgbHeaderBorder = GetSysColor(COLOR_3DHIGHLIGHT);
m_rgbHeaderShadow = GetSysColor(COLOR_3DSHADOW);
m_rgbHeaderText = GetSysColor(COLOR_WINDOWTEXT);
m_rgbHeaderHighlight = RGB(130, 140, 180);
m_rgbSelectedItem = GetSysColor(COLOR_HIGHLIGHT);
m_rgbSelectedText = GetSysColor(COLOR_HIGHLIGHTTEXT);
m_rgbItemText = GetSysColor(COLOR_WINDOWTEXT);
m_rgbSelectOuter = RGB(170, 200, 245);
m_rgbSelectInner = RGB(230, 250, 250);
m_rgbSelectTop = RGB(210, 240, 250);
m_rgbSelectBottom = RGB(185, 215, 250);
m_rgbNoFocusTop = RGB(250, 250, 250);
m_rgbNoFocusBottom = RGB(235, 235, 235);
m_rgbNoFocusOuter = RGB(220, 220, 220);
m_rgbNoFocusInner = RGB(245, 245, 245);
m_rgbFocusTop = RGB(235, 245, 245);
m_rgbFocusBottom = RGB(225, 235, 245);
m_rgbProgressTop = RGB(170, 240, 170);
m_rgbProgressBottom = RGB(45, 210, 50);
m_rgbItemFocus = RGB(180, 190, 210);
m_rgbHyperLink = RGB(0, 0, 200);
m_nHeaderClipboardFormat = (CLIPFORMAT)RegisterClipboardFormat(_T( "HEADERCLIPBOARDFORMAT" ));
// Get number of lines to scroll
#if (_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400)
SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &m_nMouseWheelScroll, 0);
#endif
// Get system message font
CLogFont logFont;
logFont.SetMessageBoxFont();
if (!m_fntListFont.IsNull())
m_fntListFont.DeleteObject();
if (m_fntListFont.CreateFontIndirect(&logFont) == nullptr)
return FALSE;
// Get system underline font
logFont.lfUnderline = BYTE(TRUE);
if (!m_fntUnderlineFont.IsNull())
m_fntUnderlineFont.DeleteObject();
if (m_fntUnderlineFont.CreateFontIndirect(&logFont) == nullptr)
return FALSE;
CClientDC dcClient(m_hWnd);
HFONT hOldFont = dcClient.SelectFont(m_fntListFont);
CSize sizeExtent;
if (!dcClient.GetTextExtent(_T( "Height" ), -1, &sizeExtent))
return FALSE;
dcClient.SelectFont(hOldFont);
// Has system font changed?
if (m_nItemHeight != sizeExtent.cy + ITEM_HEIGHT_MARGIN)
{
m_nItemHeight = sizeExtent.cy + ITEM_HEIGHT_MARGIN;
m_nHeaderHeight = m_nItemHeight;
// Create drop arrows window
if (m_wndDropArrows.IsWindow())
m_wndDropArrows.DestroyWindow();
if (!m_wndDropArrows.Create(m_hWnd, m_nHeaderHeight, TRUE))
return FALSE;
}
// Create title tip window
if (m_wndTitleTip.IsWindow())
m_wndTitleTip.DestroyWindow();
if (!m_wndTitleTip.Create(m_hWnd))
return FALSE;
return TRUE;
}
// Added by Rowan 05/12/2006
void SetSortEnabled(BOOL bSortEnabled)
{
m_bSortEnabled = bSortEnabled;
}
// Shygoo 11/02/2016
void SetRightClickSelect(BOOL bRightClickSelect = TRUE)
{
m_bRightClickSelect = bRightClickSelect;
}
void ShowHeader(BOOL bShowHeader = TRUE)
{
m_bShowHeader = bShowHeader;
ResetScrollBars();
Invalidate();
}
void ShowHeaderSort(BOOL bShowSort = TRUE)
{
m_bShowSort = bShowSort;
Invalidate();
}
void SetSingleSelect(BOOL bSingleSelect = TRUE)
{
m_bSingleSelect = bSingleSelect;
Invalidate();
}
void SetFocusSubItem(BOOL bFocusSubItem = TRUE)
{
m_bFocusSubItem = bFocusSubItem;
Invalidate();
}
void SetDragDrop(BOOL bDragDrop = TRUE)
{
m_bDragDrop = bDragDrop;
}
void SetSmoothScroll(BOOL bSmoothScroll = TRUE)
{
m_bSmoothScroll = bSmoothScroll;
}
void SetBackgroundImage(HBITMAP hBackgroundImage, BOOL bTileImage = FALSE)
{
m_bmpBackground = hBackgroundImage;
m_bTileBackground = bTileImage;
}
void SetImageList(CImageList & ilItemImages)
{
m_ilItemImages = ilItemImages;
}
UINT ValidateFlags(UINT nFlags)
{
if (nFlags & ITEM_FLAGS_CENTRE)
nFlags &= ~(ITEM_FLAGS_LEFT | ITEM_FLAGS_RIGHT);
if (nFlags & ITEM_FLAGS_RIGHT)
nFlags &= ~ITEM_FLAGS_LEFT;
if (nFlags & ITEM_FLAGS_DATE_ONLY)
nFlags &= ~ITEM_FLAGS_TIME_ONLY;
if (nFlags & (ITEM_FLAGS_EDIT_NUMBER | ITEM_FLAGS_EDIT_FLOAT))
nFlags &= ~ITEM_FLAGS_EDIT_UPPER;
if (!(nFlags & (ITEM_FLAGS_EDIT_NUMBER | ITEM_FLAGS_EDIT_FLOAT)))
nFlags &= ~(ITEM_FLAGS_EDIT_NEGATIVE | ITEM_FLAGS_EDIT_OPERATOR);
if (nFlags & ITEM_FLAGS_COMBO_EDIT)
nFlags &= ~(ITEM_FLAGS_DATE_ONLY | ITEM_FLAGS_TIME_ONLY | ITEM_FLAGS_DATETIME_NONE);
return nFlags;
}
void AddColumn(CListColumn & listColumn)
{
// Minimum column width
if (listColumn.m_strText.empty() && listColumn.m_nImage != ITEM_IMAGE_NONE)
{
CSize sizeIcon;
m_ilListItems.GetIconSize(sizeIcon);
listColumn.m_nWidth = sizeIcon.cx + 5;
listColumn.m_nFlags |= ITEM_FLAGS_CENTRE;
}
// Correct incompatible flag mask values
listColumn.m_nFlags = ValidateFlags(listColumn.m_nFlags);
// Initial data index
listColumn.m_nIndex = GetColumnCount();
m_aColumns.Add(listColumn);
ResetScrollBars();
Invalidate();
}
void AddColumn(LPCTSTR lpszText, int nWidth = 0, int nImage = ITEM_IMAGE_NONE, BOOL bFixed = FALSE, UINT nFormat = ITEM_FORMAT_NONE, UINT nFlags = ITEM_FLAGS_NONE)
{
CListColumn listColumn;
listColumn.m_strText = lpszText;
listColumn.m_nWidth = nWidth;
listColumn.m_bFixed = bFixed;
listColumn.m_nFormat = nFormat;
listColumn.m_nFlags = nFlags;
listColumn.m_nImage = nImage;
AddColumn(listColumn);
}
void RemoveAllCoumns(void)
{
m_aColumns.RemoveAll();
ResetScrollBars();
Invalidate();
}
BOOL GetHasEditItem()
{
return m_bEditItem;
}
int GetColumnCount()
{
return m_aColumns.GetSize();
}
BOOL GetColumn(int nColumn, CListColumn & listColumn)
{
if (nColumn < 0 || nColumn >= GetColumnCount())
return FALSE;
listColumn = m_aColumns[nColumn];
return TRUE;
}
int GetTotalWidth(BOOL bRecalc = FALSE)
{
if (bRecalc)
{
m_nTotalWidth = 0;
for (int nColumn = 0; nColumn < GetColumnCount(); nColumn++)
m_nTotalWidth += GetColumnWidth(nColumn);
}
return m_nTotalWidth - 1;
}
int GetTotalHeight()
{
T * pT = static_cast<T *>(this);
return max((pT->GetItemCount() * m_nItemHeight) + (m_bShowHeader ? m_nHeaderHeight : 0), 1);
}
BOOL SetColumnWidth(int nColumn, int nWidth)
{
if (nColumn < 0 || nColumn >= GetColumnCount())
return FALSE;
// Set new column size if not fixed
if (!m_aColumns[nColumn].m_bFixed)
{
m_aColumns[nColumn].m_nWidth = nWidth;
ResetScrollBars();
Invalidate();
}
return TRUE;
}
int GetColumnWidth(int nColumn)
{
CListColumn listColumn;
return GetColumn(nColumn, listColumn) ? listColumn.m_nWidth : 0;
}
int GetColumnIndex(int nColumn)
{
CListColumn listColumn;
return GetColumn(nColumn, listColumn) ? listColumn.m_nIndex : 0;
}
int IndexToOrder(int nIndex)
{
for (int nColumn = 0; nColumn < GetColumnCount(); nColumn++)
{
if (GetColumnIndex(nColumn) == nIndex)
return nColumn;
}
return -1;
}
BOOL SetColumnFormat(int nColumn, UINT nFormat, UINT nFlags = ITEM_FLAGS_NONE)
{
if (nColumn < 0 || nColumn >= GetColumnCount())
return FALSE;
m_aColumns[nColumn].m_nFormat = nFormat;
m_aColumns[nColumn].m_nFlags = ValidateFlags(nFlags);
return TRUE;
}
BOOL SetColumnFormat(int nColumn, UINT nFormat, UINT nFlags, CListArray<stdstr> & aComboList)
{
if (nColumn < 0 || nColumn >= GetColumnCount())
return FALSE;
m_aColumns[nColumn].m_nFormat = nFormat;
m_aColumns[nColumn].m_nFlags = ValidateFlags(nFlags);
m_aColumns[nColumn].m_aComboList = aComboList;
return TRUE;
}
UINT GetColumnFormat(int nColumn)
{
CListColumn listColumn;
return GetColumn(nColumn, listColumn) ? listColumn.m_nFormat : ITEM_FORMAT_NONE;
}
UINT GetColumnFlags(int nColumn)
{
CListColumn listColumn;
return GetColumn(nColumn, listColumn) ? listColumn.m_nFlags : ITEM_FLAGS_NONE;
}
BOOL GetColumnComboList(int nColumn, CListArray<stdstr> & aComboList)
{
CListColumn listColumn;
if (!GetColumn(nColumn, listColumn))
return FALSE;
aComboList = listColumn.m_aComboList;
return !aComboList.IsEmpty();
}
BOOL GetColumnRect(int nColumn, CRect & rcColumn)
{
if (nColumn < 0 || nColumn >= GetColumnCount())
return FALSE;
GetClientRect(rcColumn);
rcColumn.bottom = m_nHeaderHeight;
for (int nColumnOrder = 0; nColumnOrder < GetColumnCount(); nColumnOrder++)
{
int nWidth = GetColumnWidth(nColumnOrder);
if (nColumn == nColumnOrder)
{
rcColumn.right = rcColumn.left + nWidth;
break;
}
rcColumn.left += nWidth;
}
// Offset column by scroll position
rcColumn.OffsetRect(-GetScrollPos(SB_HORZ), 0);
return TRUE;
}
BOOL AddItem()
{
ResetScrollBars();
return Invalidate();
}
BOOL DeleteItem(int nItem)
{
m_setSelectedItems.erase(nItem);
ResetScrollBars();
return Invalidate();
}
BOOL DeleteAllItems()
{
m_setSelectedItems.clear();
ResetScrollBars();
return Invalidate();
}
int GetItemCount()
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return 0;
}
stdstr GetItemText(int nItem, int nSubItem)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return _T( "" );
}
BOOL GetItemDate(int nItem, int nSubItem, SYSTEMTIME & stItemDate)
{
T * pT = static_cast<T *>(this);
ZeroMemory(&stItemDate, sizeof(SYSTEMTIME));
stdstr strItemText = pT->GetItemText(nItem, nSubItem);
if (strItemText.empty())
return FALSE;
// Get date and time from item text: yyyymmddhhmmss
stItemDate.wYear = (WORD)_ttoi(strItemText.substr(0, 4).c_str());
stItemDate.wMonth = (WORD)_ttoi(strItemText.substr(4, 2).c_str());
stItemDate.wDay = (WORD)_ttoi(strItemText.substr(6, 2).c_str());
stItemDate.wHour = (WORD)_ttoi(strItemText.substr(8, 2).c_str());
stItemDate.wMinute = (WORD)_ttoi(strItemText.substr(10, 2).c_str());
stItemDate.wSecond = (WORD)_ttoi(strItemText.substr(12, 2).c_str());
stItemDate.wMilliseconds = 0;
return TRUE;
}
int GetItemImage(int nItem, int nSubItem)
{
return ITEM_IMAGE_NONE; // May be implemented in a derived class
}
UINT GetItemFormat(int nItem, int nSubItem)
{
return GetColumnFormat(IndexToOrder(nSubItem)); // May be implemented in a derived class
}
UINT GetItemFlags(int nItem, int nSubItem)
{
return GetColumnFlags(IndexToOrder(nSubItem)); // May be implemented in a derived class
}
BOOL GetItemComboList(int nItem, int nSubItem, CListArray<stdstr> & aComboList)
{
return GetColumnComboList(IndexToOrder(nSubItem), aComboList); // May be implemented in a derived class
}
HFONT GetItemFont(int /*nItem*/, int /*nSubItem*/)
{
return m_fntListFont; // May be implemented in a derived class
}
BOOL GetItemColours(int nItem, int nSubItem, COLORREF & rgbBackground, COLORREF & rgbText)
{
rgbBackground = m_rgbBackground;
rgbText = m_rgbItemText;
return TRUE;
}
stdstr virtual GetItemToolTip(int /*nItem*/, int /*nSubItem*/)
{
return _T( "" ); // May be implemented in a derived class
}
stdstr virtual GetHeaderToolTip(int /*column*/)
{
return _T(""); // Implemented by child class
}
BOOL SetItemText(int nItem, int nSubItem, LPCTSTR lpszText)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return FALSE;
}
BOOL SetItemComboIndex(int nItem, int nSubItem, int nIndex)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return FALSE;
}
BOOL SetItemDate(int nItem, int nSubItem, SYSTEMTIME & stItemDate)
{
T * pT = static_cast<T *>(this);
// Set date and time in format (yyyymmddhhmmss)
stdstr strFormatDate;
strFormatDate.Format(_T( "%04d%02d%02d%02d%02d%02d" ), stItemDate.wYear, stItemDate.wMonth, stItemDate.wDay, stItemDate.wHour, stItemDate.wMinute, stItemDate.wSecond);
return pT->SetItemText(nItem, nSubItem, strFormatDate.c_str());
}
BOOL SetItemCheck(int nItem, int nSubItem, int nCheckValue)
{
T * pT = static_cast<T *>(this);
switch (pT->GetItemFormat(nItem, nSubItem))
{
case ITEM_FORMAT_CHECKBOX: return pT->SetItemText(nItem, nSubItem, nCheckValue > 0 ? _T( "1" ) : _T( "0" ));
case ITEM_FORMAT_CHECKBOX_3STATE:
if (nCheckValue < 0)
return pT->SetItemText(nItem, nSubItem, _T( "-1" ));
if (nCheckValue > 0)
return pT->SetItemText(nItem, nSubItem, _T( "1" ));
return pT->SetItemText(nItem, nSubItem, _T( "0" ));
}
return FALSE;
}
BOOL SetItemImage(int nItem, int nSubItem, int nImage)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return FALSE;
}
BOOL SetItemFormat(int nItem, int nSubItem, UINT nFormat, UINT nFlags = ITEM_FLAGS_NONE)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return FALSE;
}
BOOL SetItemFormat(int nItem, int nSubItem, UINT nFormat, UINT nFlags, CListArray<stdstr> & aComboList)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return FALSE;
}
BOOL SetItemFont(int nItem, int nSubItem, HFONT hFont)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return FALSE;
}
BOOL SetItemColours(int nItem, int nSubItem, COLORREF rgbBackground, COLORREF rgbText)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return FALSE;
}
void ReverseItems()
{
ATLASSERT(FALSE); // Must be implemented in a derived class
}
void SortItems(int nColumn, BOOL bAscending)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
}
BOOL GetItemRect(int nItem, int nSubItem, CRect & rcItem)
{
T * pT = static_cast<T *>(this);
int nTopItem = GetTopItem();
if (nItem < nTopItem || nItem >= pT->GetItemCount() || nItem >= nTopItem + GetCountPerPage())
return FALSE;
CRect rcClient;
GetClientRect(rcClient);
// Calculate item rect based on scroll position
rcItem = rcClient;
rcItem.top = (m_bShowHeader ? m_nHeaderHeight : 0) + ((nItem - nTopItem) * m_nItemHeight);
rcItem.bottom = rcItem.top + m_nItemHeight;
rcItem.right = min(rcClient.right, GetTotalWidth());
if (nSubItem != NULL_SUBITEM)
{
CRect rcColumn;
if (!GetColumnRect(nSubItem, rcColumn))
return FALSE;
rcItem.left = rcColumn.left;
rcItem.right = rcColumn.right;
}
return TRUE;
}
BOOL GetItemRect(int nItem, CRect & rcItem)
{
return GetItemRect(nItem, NULL_SUBITEM, rcItem);
}
BOOL InvalidateItem(int nItem, int nSubItem = NULL_SUBITEM)
{
CRect rcItem;
return GetItemRect(nItem, nSubItem, rcItem) ? InvalidateRect(rcItem) : FALSE;
}
BOOL InvalidateHeader()
{
if (!m_bShowHeader)
return TRUE;
CRect rcHeader;
if (!GetClientRect(rcHeader))
return FALSE;
rcHeader.bottom = m_nHeaderHeight;
return InvalidateRect(rcHeader);
}
int GetTopItem()
{
return (int)(GetScrollPos(SB_VERT) / m_nItemHeight);
}
int GetCountPerPage(BOOL bPartial = TRUE)
{
CRect rcClient;
GetClientRect(rcClient);
rcClient.top = (m_bShowHeader ? m_nHeaderHeight : 0);
// Calculate number of items per control height (include partial item)
div_t divHeight = div(rcClient.Height(), m_nItemHeight);
// Round up to nearest item count
return max(bPartial && divHeight.rem > 0 ? divHeight.quot + 1 : divHeight.quot, 1);
}
BOOL IsItemVisible(int nItem, int nSubItem = NULL_SUBITEM, BOOL bPartial = TRUE)
{
T * pT = static_cast<T *>(this);
int nTopItem = GetTopItem();
if (nItem < nTopItem || nItem >= pT->GetItemCount())
return FALSE;
// Check whether item is visible
if (nItem < nTopItem || nItem >= nTopItem + GetCountPerPage(bPartial))
return FALSE;
// Check whether subitem is visible
if (m_bFocusSubItem && nSubItem != NULL_SUBITEM)
{
CRect rcColumn;
if (!GetColumnRect(nSubItem, rcColumn))
return FALSE;
CRect rcClient;
GetClientRect(rcClient);
if (rcColumn.left < rcClient.left || rcColumn.right > rcClient.right)
return FALSE;
}
return TRUE;
}
BOOL EnsureItemVisible(int nItem, int nSubItem = NULL_SUBITEM)
{
if (IsItemVisible(nItem, nSubItem, FALSE))
return TRUE;
HideTitleTip();
CRect rcClient;
GetClientRect(rcClient);
rcClient.top = (m_bShowHeader ? m_nHeaderHeight : 0);
CRect rcItem;
rcItem.top = (m_bShowHeader ? m_nHeaderHeight : 0) + ((nItem - GetTopItem()) * m_nItemHeight);
rcItem.bottom = rcItem.top + m_nItemHeight;
if (rcItem.top < rcClient.top || rcItem.bottom > rcClient.bottom)
{
int nScrollItem = NULL_ITEM;
// Scroll list up/down to include item
if (rcItem.top < rcClient.top || rcItem.Height() > rcClient.Height())
nScrollItem = nItem;
else if (rcItem.bottom > rcClient.bottom)
nScrollItem = nItem - (GetCountPerPage(FALSE) - 1);
if (nScrollItem != NULL_ITEM)
SetScrollPos(SB_VERT, nScrollItem * m_nItemHeight);
}
if (m_bFocusSubItem && nSubItem != NULL_SUBITEM)
{
CRect rcColumn;
if (!GetColumnRect(nSubItem, rcColumn))
return FALSE;
GetClientRect(rcClient);
int nScrollPos = 0;
// Scroll list left/right to include subitem
if (rcColumn.Width() > rcClient.Width() || rcColumn.left < 0)
nScrollPos = rcColumn.left;
else if (rcColumn.right > rcClient.right)
nScrollPos = rcColumn.right - rcClient.right;
if (nScrollPos != 0)
SetScrollPos(SB_HORZ, GetScrollPos(SB_HORZ) + nScrollPos);
}
return Invalidate();
}
void ShowScrollBar(int nScrollBar, BOOL bShow = TRUE)
{
switch (nScrollBar)
{
case SB_HORZ:
m_bShowHorizScroll = bShow;
break;
case SB_VERT:
m_bShowVertScroll = bShow;
break;
case SB_BOTH:
m_bShowHorizScroll = bShow;
m_bShowVertScroll = bShow;
break;
}
ResetScrollBars();
Invalidate();
}
void ResetScrollBars(int nScrollBar = SB_BOTH, int nScrollPos = -1, BOOL bRecalc = TRUE)
{
T * pT = static_cast<T *>(this);
CRect rcClient;
GetClientRect(rcClient);
SCROLLINFO infoScroll;
infoScroll.cbSize = sizeof(SCROLLINFO);
infoScroll.fMask = nScrollPos < 0 ? SIF_PAGE | SIF_RANGE : SIF_PAGE | SIF_RANGE | SIF_POS;
infoScroll.nPos = nScrollPos;
infoScroll.nMin = 0;
if ((nScrollBar == SB_BOTH || nScrollBar == SB_VERT) && m_bShowVertScroll)
{
infoScroll.nMax = (pT->GetItemCount() * m_nItemHeight) + (m_bShowHeader ? m_nHeaderHeight : 0);
infoScroll.nPage = rcClient.Height() - (m_bShowHeader ? m_nHeaderHeight : 0);
// Are we within client range?
if ((UINT)infoScroll.nMax <= infoScroll.nPage + (m_bShowHeader ? m_nHeaderHeight : 0))
infoScroll.nMax = 0;
// Set vertical scroll bar
m_bEnableVertScroll = SetScrollInfo(SB_VERT, &infoScroll, TRUE) ? (infoScroll.nMax > 0) : FALSE;
}
if ((nScrollBar == SB_BOTH || nScrollBar == SB_HORZ) && m_bShowHorizScroll)
{
infoScroll.nMax = GetTotalWidth(bRecalc);
infoScroll.nPage = rcClient.Width();
// Are we within client range?
if (infoScroll.nPage >= (UINT)infoScroll.nMax)
infoScroll.nMax = 0;
// Set horizontal scroll bar
m_bEnableHorizScroll = SetScrollInfo(SB_HORZ, &infoScroll, TRUE) ? (infoScroll.nMax > (int)infoScroll.nPage) : FALSE;
}
}
BOOL IsScrollBarVisible(int nScrollBar)
{
switch (nScrollBar)
{
case SB_HORZ: return m_bEnableHorizScroll;
case SB_VERT: return m_bEnableVertScroll;
case SB_BOTH: return (m_bEnableHorizScroll && m_bEnableVertScroll);
default: return FALSE;
}
}
BOOL ResetSelected()
{
m_setSelectedItems.clear();
m_nFocusItem = NULL_ITEM;
m_nFocusSubItem = NULL_SUBITEM;
m_nFirstSelected = NULL_ITEM;
return Invalidate();
}
BOOL SelectItem(int nItem, int nSubItem = NULL_SUBITEM, UINT nFlags = 0)
{
T * pT = static_cast<T *>(this);
if (nItem < 0 || nItem >= pT->GetItemCount())
return FALSE;
BOOL bSelectItem = TRUE;
BOOL bSelectRange = !m_bSingleSelect && (nFlags & MK_SHIFT);
BOOL bNewSelect = !(bSelectRange || (nFlags & MK_CONTROL));
BOOL bEnsureVisible = FALSE;
// Are we starting a new select sequence?
if (bNewSelect || bSelectRange)
{
// Are we simply reselecting the same item?
if (m_setSelectedItems.size() == 1 && *m_setSelectedItems.begin() == nItem)
{
bSelectItem = FALSE;
m_nFirstSelected = nItem;
m_nFocusItem = nItem;
m_nFocusSubItem = nSubItem;
}
else
m_setSelectedItems.clear();
}
else // We adding to or removing from select sequence
{
if (m_bSingleSelect)
m_setSelectedItems.clear();
set<int>::iterator posSelectedItem = m_setSelectedItems.find(nItem);
// Is this item already selected?
if (posSelectedItem != m_setSelectedItems.end())
{
bSelectItem = FALSE;
m_setSelectedItems.erase(posSelectedItem);
m_nFirstSelected = nItem;
m_nFocusItem = nItem;
m_nFocusSubItem = m_setSelectedItems.size() > 1 ? NULL_SUBITEM : nSubItem;
}
}
// Are we adding this item to the select sequence?
if (bSelectItem)
{
bEnsureVisible = TRUE;
if (bSelectRange)
{
if (m_nFirstSelected == NULL_ITEM)
m_nFirstSelected = nItem;
for (int nSelectedItem = min(m_nFirstSelected, nItem); nSelectedItem <= max(m_nFirstSelected, nItem); nSelectedItem++)
m_setSelectedItems.insert(nSelectedItem);
}
else
{
m_nFirstSelected = nItem;
m_setSelectedItems.insert(nItem);
}
m_nFocusItem = nItem;
m_nFocusSubItem = m_setSelectedItems.size() > 1 ? NULL_SUBITEM : nSubItem;
// Notify parent of selected item
NotifyParent(m_nFocusItem, m_nFocusSubItem, LCN_SELECTED);
}
// Start visible timer (scrolls list to partially hidden item)
if (!IsItemVisible(nItem, m_setSelectedItems.size() > 1 ? NULL_SUBITEM : nSubItem, FALSE))
SetTimer(ITEM_VISIBLE_TIMER, ITEM_VISIBLE_PERIOD);
else if (m_nFocusItem != NULL_ITEM && m_nFocusSubItem != NULL_SUBITEM)
EditItem(m_nFocusItem, m_nFocusSubItem);
return Invalidate();
}
BOOL IsSelected(int nItem)
{
set<int>::iterator posSelectedItem = m_setSelectedItems.find(nItem);
return (posSelectedItem != m_setSelectedItems.end());
}
BOOL GetSelectedItems(CListArray<int> & aSelectedItems)
{
aSelectedItems.RemoveAll();
for (set<int>::iterator posSelectedItem = m_setSelectedItems.begin(); posSelectedItem != m_setSelectedItems.end(); ++posSelectedItem)
aSelectedItems.Add(*posSelectedItem);
return !aSelectedItems.IsEmpty();
}
BOOL SetFocusItem(int nItem, int nSubItem = NULL_SUBITEM)
{
m_nFocusItem = nItem;
m_nFocusSubItem = nSubItem;
return EnsureItemVisible(m_nFocusItem, m_nFocusSubItem);
}
BOOL GetFocusItem(int & nItem, int & nSubItem)
{
nItem = IsSelected(m_nFocusItem) ? m_nFocusItem : (m_setSelectedItems.empty() ? NULL_ITEM : *m_setSelectedItems.begin());
nSubItem = !m_bFocusSubItem || nItem == NULL_ITEM ? NULL_SUBITEM : m_nFocusSubItem;
return (nItem != NULL_ITEM);
}
int GetFocusItem()
{
return IsSelected(m_nFocusItem) ? m_nFocusItem : (m_setSelectedItems.empty() ? NULL_ITEM : *m_setSelectedItems.begin());
}
BOOL HitTestHeader(CPoint point, int & nColumn, UINT & nFlags)
{
// Reset hit test flags
nFlags = HITTEST_FLAG_NONE;
if (!m_bShowHeader)
return FALSE;
CRect rcClient;
if (!GetClientRect(rcClient))
return FALSE;
// Are we over the header?
if (point.y < rcClient.top || point.y > m_nHeaderHeight)
return FALSE;
int nDividerPos = 0;
int nColumnCount = GetColumnCount();
// Get hit test subitem
for (nColumn = 0; nColumn < nColumnCount; nColumn++)
{
int nColumnWidth = GetColumnWidth(nColumn);
nDividerPos += nColumnWidth;
// Offset divider position with current scroll position
int nRelativePos = nDividerPos - GetScrollPos(SB_HORZ);
// Are we over the divider zone?
if (point.x >= nRelativePos - DRAG_HEADER_OFFSET - 1 && point.x <= nRelativePos + DRAG_HEADER_OFFSET)
{
nFlags |= HITTEST_FLAG_HEADER_DIVIDER;
// Are we to the left of the divider (or over last column divider)?
if ((point.x >= nRelativePos - DRAG_HEADER_OFFSET - 1 && point.x < nRelativePos) || nColumn + 1 >= nColumnCount - 1)
{
nFlags |= HITTEST_FLAG_HEADER_LEFT;
return TRUE;
}
// Find last zero-length column after this column
for (int nNextColumn = nColumn + 1; nNextColumn < nColumnCount; nNextColumn++)
{
if (GetColumnWidth(nNextColumn) > 0)
break;
nColumn = nNextColumn;
}
nFlags |= HITTEST_FLAG_HEADER_RIGHT;
return TRUE;
}
// Are we over a column?
if (point.x > nRelativePos - nColumnWidth && point.x < nRelativePos)
return TRUE;
}
return FALSE;
}
BOOL HitTest(CPoint point, int & nItem, int & nSubItem)
{
T * pT = static_cast<T *>(this);
// Are we over the header?
if (point.y < (m_bShowHeader ? m_nHeaderHeight : 0))
return FALSE;
// Calculate hit test item
nItem = GetTopItem() + (int)((point.y - (m_bShowHeader ? m_nHeaderHeight : 0)) / m_nItemHeight);
if (nItem < 0 || nItem >= pT->GetItemCount())
return FALSE;
int nTotalWidth = 0;
int nColumnCount = GetColumnCount();
// Get hit test subitem
for (nSubItem = 0; nSubItem < nColumnCount; nSubItem++)
{
int nColumnWidth = GetColumnWidth(nSubItem);
nTotalWidth += nColumnWidth;
// Offset position with current scroll position
int nRelativePos = nTotalWidth - GetScrollPos(SB_HORZ);
// Are we over a subitem?
if (point.x > nRelativePos - nColumnWidth && point.x < nRelativePos)
return TRUE;
}
return FALSE;
}
BOOL AutoSizeColumn(int nColumn)
{
T * pT = static_cast<T *>(this);
CListColumn listColumn;
if (!GetColumn(nColumn, listColumn) || listColumn.m_bFixed)
return FALSE;
CClientDC dcClient(m_hWnd);
HFONT hOldFont = dcClient.SelectFont(m_fntListFont);
// Set to column text width if zero-length
CSize sizeExtent;
if (!dcClient.GetTextExtent(listColumn.m_strText.c_str(), -1, &sizeExtent))
return FALSE;
int nMaxWidth = sizeExtent.cx + ITEM_WIDTH_MARGIN;
CSize sizeIcon = 0;
if (!m_ilItemImages.IsNull())
m_ilItemImages.GetIconSize(sizeIcon);
// Calculate maximum column width required
for (int nItem = 0; nItem < pT->GetItemCount(); nItem++)
{
if (!dcClient.GetTextExtent(pT->GetItemText(nItem, listColumn.m_nIndex), -1, &sizeExtent))
return FALSE;
if (!m_ilItemImages.IsNull() && pT->GetItemImage(nItem, listColumn.m_nIndex) != ITEM_IMAGE_NONE)
sizeExtent.cx += sizeIcon.cx;
nMaxWidth = max(nMaxWidth, (int)sizeExtent.cx + ITEM_WIDTH_MARGIN);
}
dcClient.SelectFont(hOldFont);
return SetColumnWidth(nColumn, nMaxWidth);
}
void ResizeColumn(BOOL bColumnScroll = FALSE)
{
HideTitleTip();
int nCurrentPos = GET_X_LPARAM(GetMessagePos());
CRect rcClient;
GetClientRect(rcClient);
int nScrollLimit = GetTotalWidth() - rcClient.Width();
if (bColumnScroll)
{
// Have we finished scrolling list to accommodate new column size?
if (!m_bColumnSizing || !m_bEnableHorizScroll || nCurrentPos - m_nStartScrollPos > 0)
{
KillTimer(RESIZE_COLUMN_TIMER);
// Reset resize start point
m_nStartPos = nCurrentPos;
m_bResizeTimer = FALSE;
}
else if (nCurrentPos < m_nStartPos && GetScrollPos(SB_HORZ) >= nScrollLimit)
{
// Reset start column size
m_nStartSize = max(GetColumnWidth(m_nColumnSizing) + (nCurrentPos - m_nStartScrollPos), 0);
// Resize column
SetColumnWidth(m_nColumnSizing, m_nStartSize);
}
}
else
{
int nColumnSize = max(m_nStartSize + (nCurrentPos - m_nStartPos), 0);
// Are we scrolled fully to the right and wanting to reduce the size of a column?
if (m_bEnableHorizScroll && GetScrollPos(SB_HORZ) >= nScrollLimit && nColumnSize < GetColumnWidth(m_nColumnSizing))
{
if (!m_bResizeTimer)
{
// Only start the scroll timer once
m_bResizeTimer = TRUE;
// Set new start scroll position
m_nStartScrollPos = nCurrentPos;
// Start column resize / scroll timer
SetTimer(RESIZE_COLUMN_TIMER, RESIZE_COLUMN_PERIOD);
}
}
else
{
// Resizing is done in scroll timer (if started)
if (!m_bResizeTimer)
SetColumnWidth(m_nColumnSizing, nColumnSize);
}
}
}
void DragColumn()
{
HideTitleTip();
CRect rcColumn;
if (!GetColumnRect(m_nHighlightColumn, rcColumn))
return;
CRect rcHeaderItem(rcColumn);
rcHeaderItem.MoveToXY(0, 0);
CListColumn listColumn;
if (!GetColumn(m_nHighlightColumn, listColumn))
return;
// Store drag column
m_nDragColumn = m_nHighlightColumn;
CClientDC dcClient(m_hWnd);
CDC dcHeader;
dcHeader.CreateCompatibleDC(dcClient);
int nContextState = dcHeader.SaveDC();
// Create drag header bitmap
CBitmapHandle bmpHeader;
bmpHeader.CreateCompatibleBitmap(dcClient, rcHeaderItem.Width(), rcHeaderItem.Height());
dcHeader.SelectBitmap(bmpHeader);
dcHeader.SetBkColor(m_rgbHeaderBackground);
dcHeader.ExtTextOut(rcHeaderItem.left, rcHeaderItem.top, ETO_OPAQUE, rcHeaderItem, _T( "" ), 0, nullptr);
dcHeader.Draw3dRect(rcHeaderItem, m_rgbHeaderBorder, m_rgbHeaderShadow);
CRect rcHeaderText(rcHeaderItem);
rcHeaderText.left += m_nHighlightColumn == 0 ? 4 : 3;
rcHeaderText.OffsetRect(0, 1);
// Margin header text
rcHeaderText.DeflateRect(4, 0, 5, 0);
// Has this header item an associated image?
if (listColumn.m_nImage != ITEM_IMAGE_NONE)
{
CSize sizeIcon;
m_ilListItems.GetIconSize(sizeIcon);
CRect rcHeaderImage;
rcHeaderImage.left = listColumn.m_strText.empty() ? ((rcHeaderText.left + rcHeaderText.right) / 2) - (sizeIcon.cx / 2) - (0) : rcHeaderText.left;
rcHeaderImage.right = min(rcHeaderImage.left + sizeIcon.cx, rcHeaderItem.right);
rcHeaderImage.top = ((rcHeaderItem.top + rcHeaderItem.bottom) / 2) - (sizeIcon.cy / 2);
rcHeaderImage.bottom = min(rcHeaderImage.top + sizeIcon.cy, rcHeaderItem.bottom);
m_ilListItems.DrawEx(listColumn.m_nImage, dcHeader, rcHeaderImage, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT);
// Offset header text (for image)
rcHeaderText.left += sizeIcon.cx + 4;
}
dcHeader.SelectFont(m_fntListFont);
dcHeader.SetTextColor(m_rgbHeaderText);
dcHeader.SetBkMode(TRANSPARENT);
UINT nFormat = DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_END_ELLIPSIS;
if (listColumn.m_nFlags & ITEM_FLAGS_CENTRE)
nFormat |= DT_CENTER;
else if (listColumn.m_nFlags & ITEM_FLAGS_RIGHT)
nFormat |= DT_RIGHT;
else
nFormat |= DT_LEFT;
// Draw header text
if (!listColumn.m_strText.empty())
dcHeader.DrawText(listColumn.m_strText.c_str(), (int)listColumn.m_strText.length(), rcHeaderText, nFormat);
dcHeader.RestoreDC(nContextState);
SHDRAGIMAGE shDragImage;
ZeroMemory(&shDragImage, sizeof(SHDRAGIMAGE));
shDragImage.sizeDragImage.cx = rcHeaderItem.Width();
shDragImage.sizeDragImage.cy = rcHeaderItem.Height();
shDragImage.ptOffset.x = rcColumn.Width() / 2;
shDragImage.ptOffset.y = rcColumn.Height() / 2;
shDragImage.hbmpDragImage = bmpHeader;
shDragImage.crColorKey = m_rgbBackground;
// Start header drag operation
m_oleDragDrop.DoDragDrop(&shDragImage, DROPEFFECT_MOVE);
// Hide drop arrows after moving column
m_wndDropArrows.Hide();
if (m_bButtonDown)
{
ReleaseCapture();
m_bButtonDown = FALSE;
m_bBeginSelect = FALSE;
m_ptDownPoint = 0;
m_ptSelectPoint = 0;
}
// Finish moving a column
if (m_nHighlightColumn != NULL_COLUMN)
{
m_nHighlightColumn = NULL_COLUMN;
InvalidateHeader();
}
m_nDragColumn = NULL_COLUMN;
}
BOOL DropColumn(CPoint point)
{
if (!m_bShowHeader)
return FALSE;
m_nHotDivider = NULL_COLUMN;
m_nHotColumn = NULL_COLUMN;
UINT nHeaderFlags = HITTEST_FLAG_NONE;
// Are we over the header?
if (HitTestHeader(point, m_nHotColumn, nHeaderFlags))
{
CRect rcColumn;
if (!GetColumnRect(m_nHotColumn, rcColumn))
return FALSE;
m_nHotDivider = point.x < ((rcColumn.left + rcColumn.right) / 2) ? m_nHotColumn : m_nHotColumn + 1;
if (m_nHotDivider == m_nDragColumn || m_nHotDivider == m_nDragColumn + 1)
m_nHotDivider = NULL_COLUMN;
}
if (m_nHotDivider != NULL_COLUMN)
{
CRect rcHeader;
GetClientRect(rcHeader);
rcHeader.bottom = m_nHeaderHeight;
CPoint ptDivider(0, rcHeader.Height() / 2);
CRect rcColumn;
int nColumnCount = GetColumnCount();
// Set closest divider position
if (GetColumnRect(m_nHotDivider < nColumnCount ? m_nHotDivider : nColumnCount - 1, rcColumn))
ptDivider.x = m_nHotDivider < nColumnCount ? rcColumn.left : rcColumn.right;
ClientToScreen(&ptDivider);
// Track drop window
m_wndDropArrows.Show(ptDivider);
return TRUE;
}
m_wndDropArrows.Hide();
return FALSE;
}
BOOL SortColumn(int nColumn)
{
T * pT = static_cast<T *>(this);
if (!m_bShowHeader || !m_bShowSort)
return FALSE;
int nSortIndex = GetColumnIndex(nColumn);
CWaitCursor curWait;
if (nSortIndex != m_nSortColumn)
{
// Sort by new column
m_bSortAscending = TRUE;
m_nSortColumn = nSortIndex;
pT->SortItems(m_nSortColumn, m_bSortAscending);
}
else
{
// Toggle sort order if sorting same column
m_bSortAscending = !m_bSortAscending;
pT->ReverseItems();
}
return ResetSelected();
}
BOOL GetSortColumn(int & nColumn, BOOL & bAscending)
{
if (!m_bShowHeader || !m_bShowSort || m_nSortColumn == NULL_COLUMN)
return FALSE;
nColumn = m_nSortColumn;
bAscending = m_bSortAscending;
return TRUE;
}
BOOL DragItem()
{
ATLASSERT(FALSE); // Must be implemented in a derived class
return FALSE;
}
BOOL GroupSelect(CPoint point)
{
HideTitleTip();
int nHorzScroll = GetScrollPos(SB_HORZ);
int nVertScroll = GetScrollPos(SB_VERT);
m_rcGroupSelect.left = min(m_ptSelectPoint.x, point.x + nHorzScroll);
m_rcGroupSelect.right = max(m_ptSelectPoint.x, point.x + nHorzScroll);
m_rcGroupSelect.top = min(m_ptSelectPoint.y, point.y + nVertScroll);
m_rcGroupSelect.bottom = max(m_ptSelectPoint.y, point.y + nVertScroll);
if (m_rcGroupSelect.IsRectEmpty())
return FALSE;
// Select items in group
AutoSelect(point);
// Start auto scroll timer
SetTimer(ITEM_AUTOSCROLL_TIMER, ITEM_SCROLL_PERIOD);
DWORD dwCurrentTick = GetTickCount();
// Timer messages are a low priority, therefore we need to simulate the timer when moving the mouse
if ((dwCurrentTick - m_dwScrollTick) > ITEM_SCROLL_PERIOD - 10)
{
if (AutoScroll(point))
m_dwScrollTick = dwCurrentTick;
}
// Redraw list immediately
return RedrawWindow();
}
void AutoSelect(CPoint /*point*/)
{
m_setSelectedItems.clear();
if (m_rcGroupSelect.left < GetTotalWidth())
{
int nHorzScroll = GetScrollPos(SB_HORZ);
int nVertScroll = GetScrollPos(SB_VERT);
CRect rcGroupSelect(m_rcGroupSelect);
rcGroupSelect.OffsetRect(-nHorzScroll, -nVertScroll);
int nTopItem = GetTopItem();
int nLastItem = nTopItem + ((rcGroupSelect.bottom - (m_bShowHeader ? m_nHeaderHeight : 0)) / m_nItemHeight);
nTopItem += ((rcGroupSelect.top - (m_bShowHeader ? m_nHeaderHeight : 0)) / m_nItemHeight) - ((rcGroupSelect.top < 0) ? 1 : 0);
for (int nItem = nTopItem; nItem <= nLastItem; nItem++)
{
if (m_setSelectedItems.empty())
m_nFirstSelected = nItem;
m_setSelectedItems.insert(nItem);
m_nFocusItem = nItem;
m_nFocusSubItem = NULL_SUBITEM;
}
}
if (m_setSelectedItems.empty())
m_nFirstSelected = NULL_ITEM;
}
BOOL AutoScroll(CPoint point)
{
CRect rcClient;
GetClientRect(rcClient);
rcClient.top = (m_bShowHeader ? m_nHeaderHeight : 0);
int nHorzScroll = GetScrollPos(SB_HORZ);
int nVertScroll = GetScrollPos(SB_VERT);
BOOL bAutoScroll = FALSE;
if (point.y < rcClient.top)
{
SendMessage(WM_VSCROLL, MAKEWPARAM(SB_LINEUP, 0));
int nAutoScroll = GetScrollPos(SB_VERT);
if (nVertScroll != nAutoScroll)
{
m_rcGroupSelect.top = rcClient.top + nAutoScroll - 1;
m_rcGroupSelect.bottom = max(m_ptSelectPoint.y, point.y + nAutoScroll - 1);
bAutoScroll = TRUE;
}
}
if (point.y > rcClient.bottom)
{
SendMessage(WM_VSCROLL, MAKEWPARAM(SB_LINEDOWN, 0));
int nAutoScroll = GetScrollPos(SB_VERT);
if (nVertScroll != nAutoScroll)
{
m_rcGroupSelect.top = min(m_ptSelectPoint.y, point.y + nAutoScroll + 1);
m_rcGroupSelect.bottom = rcClient.bottom + nAutoScroll + 1;
bAutoScroll = TRUE;
}
}
if (point.x < rcClient.left)
{
SendMessage(WM_HSCROLL, MAKEWPARAM(SB_LINELEFT, 0));
int nAutoScroll = GetScrollPos(SB_HORZ);
if (nHorzScroll != nAutoScroll)
{
m_rcGroupSelect.left = rcClient.left + nAutoScroll - 1;
m_rcGroupSelect.right = max(m_ptSelectPoint.x, point.x + nAutoScroll - 1);
bAutoScroll = TRUE;
}
}
if (point.x > rcClient.right)
{
SendMessage(WM_HSCROLL, MAKEWPARAM(SB_LINERIGHT, 0));
int nAutoScroll = GetScrollPos(SB_HORZ);
if (nHorzScroll != nAutoScroll)
{
m_rcGroupSelect.left = min(m_ptSelectPoint.x, point.x + nAutoScroll + 1);
m_rcGroupSelect.right = rcClient.right + nAutoScroll + 1;
bAutoScroll = TRUE;
}
}
// Was the scrolling performed?
return bAutoScroll;
}
BOOL BeginScroll(int nBeginItem, int nEndItem)
{
T * pT = static_cast<T *>(this);
// Any scroll required?
if (nBeginItem == nEndItem)
return FALSE;
// Calculate scroll offset
m_nScrollOffset = abs(nEndItem - nBeginItem) * m_nItemHeight;
m_nScrollUnit = min(max(m_nScrollOffset / m_nItemHeight, ITEM_SCROLL_UNIT_MIN), ITEM_SCROLL_UNIT_MAX);
m_nScrollDelta = (m_nScrollOffset - m_nScrollUnit) / m_nScrollUnit;
m_bScrollDown = (nBeginItem < nEndItem);
CClientDC dcClient(m_hWnd);
CDC dcScrollList;
dcScrollList.CreateCompatibleDC(dcClient);
int nContextState = dcScrollList.SaveDC();
CRect rcScrollList;
GetClientRect(rcScrollList);
rcScrollList.bottom = (GetCountPerPage() + abs(nEndItem - nBeginItem)) * m_nItemHeight;
if (!m_bmpScrollList.IsNull())
m_bmpScrollList.DeleteObject();
m_bmpScrollList.CreateCompatibleBitmap(dcClient, rcScrollList.Width(), rcScrollList.Height());
dcScrollList.SelectBitmap(m_bmpScrollList);
pT->DrawBkgnd(dcScrollList.m_hDC);
CRect rcItem;
rcItem.left = -GetScrollPos(SB_HORZ);
rcItem.right = GetTotalWidth();
rcItem.top = 0;
rcItem.bottom = rcItem.top;
// Draw all visible items into bitmap
for (int nItem = min(nBeginItem, nEndItem); nItem < pT->GetItemCount(); rcItem.top = rcItem.bottom, nItem++)
{
rcItem.bottom = rcItem.top + m_nItemHeight;
if (rcItem.top > rcScrollList.bottom)
break;
// May be implemented in a derived class
pT->DrawItem(dcScrollList.m_hDC, nItem, rcItem);
}
dcScrollList.RestoreDC(nContextState);
ScrollList();
// Start scrolling timer
SetTimer(ITEM_SCROLL_TIMER, ITEM_SCROLL_PERIOD);
return TRUE;
}
BOOL EndScroll()
{
KillTimer(ITEM_SCROLL_TIMER);
if (!m_bmpScrollList.IsNull())
m_bmpScrollList.DeleteObject();
return Invalidate();
}
BOOL ScrollList()
{
if (m_nScrollOffset <= m_nScrollUnit)
m_nScrollOffset--;
else
{
m_nScrollOffset -= m_nScrollDelta;
if (m_nScrollOffset < m_nScrollDelta)
m_nScrollOffset = m_nScrollUnit;
}
if (m_bmpScrollList.IsNull() || m_nScrollOffset < 0)
return FALSE;
CClientDC dcClient(m_hWnd);
CDC dcScrollList;
dcScrollList.CreateCompatibleDC(dcClient);
CRect rcClient;
GetClientRect(rcClient);
rcClient.top = (m_bShowHeader ? m_nHeaderHeight : 0);
HBITMAP hOldBitmap = dcScrollList.SelectBitmap(m_bmpScrollList);
CSize sizScrollBitmap;
m_bmpScrollList.GetSize(sizScrollBitmap);
// Draw scrolled list
dcClient.BitBlt(0, rcClient.top, rcClient.Width(), rcClient.Height(), dcScrollList, 0, m_bScrollDown ? (sizScrollBitmap.cy - (GetCountPerPage() * m_nItemHeight) - m_nScrollOffset) : m_nScrollOffset, SRCCOPY);
dcScrollList.SelectBitmap(hOldBitmap);
return TRUE;
}
BOOL EditItem(int nItem, int nSubItem = NULL_SUBITEM)
{
T * pT = static_cast<T *>(this);
if (!EnsureItemVisible(nItem, nSubItem))
return FALSE;
if (GetFocus() != m_hWnd)
return FALSE;
CRect rcSubItem;
if (!GetItemRect(nItem, nSubItem, rcSubItem))
return FALSE;
int nIndex = GetColumnIndex(nSubItem);
if (pT->GetItemFlags(nItem, nIndex) & ITEM_FLAGS_READ_ONLY)
return TRUE;
switch (pT->GetItemFormat(nItem, nIndex))
{
case ITEM_FORMAT_EDIT:
m_bEditItem = TRUE;
if (!RedrawWindow())
return FALSE;
if (!m_wndItemEdit.Create(m_hWnd, nItem, nSubItem, rcSubItem, pT->GetItemFlags(nItem, nIndex), pT->GetItemText(nItem, nIndex), pT->GetItemMaxEditLen(nItem, nIndex)))
return FALSE;
m_wndItemEdit.SetFont(GetItemFont(nItem, nIndex));
break;
case ITEM_FORMAT_DATETIME:
{
m_bEditItem = TRUE;
if (!RedrawWindow())
return FALSE;
SYSTEMTIME stItemDate;
GetItemDate(nItem, nIndex, stItemDate);
if (!m_wndItemDate.Create(m_hWnd, nItem, nSubItem, rcSubItem, pT->GetItemFlags(nItem, nIndex), stItemDate))
return FALSE;
}
break;
case ITEM_FORMAT_COMBO:
{
m_bEditItem = TRUE;
if (!RedrawWindow())
return FALSE;
CListArray<stdstr> aComboList;
if (!pT->GetItemComboList(nItem, nIndex, aComboList))
return FALSE;
if (!m_wndItemCombo.Create(m_hWnd, nItem, nSubItem, rcSubItem, pT->GetItemFlags(nItem, nIndex), pT->GetItemText(nItem, nIndex), aComboList))
return FALSE;
}
break;
}
return TRUE;
}
stdstr FormatDate(SYSTEMTIME & stFormatDate)
{
if (stFormatDate.wYear == 0)
return _T( "" );
// Format date to local format
TCHAR szDateFormat[DATE_STRING];
return GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &stFormatDate, nullptr, szDateFormat, DATE_STRING) == 0 ? _T( "" ) : szDateFormat;
}
stdstr FormatTime(SYSTEMTIME & stFormatDate)
{
SYSTEMTIME stFormatTime = stFormatDate;
stFormatTime.wYear = 0;
stFormatTime.wMonth = 0;
stFormatTime.wDay = 0;
// Format time to local format
TCHAR szTimeFormat[DATE_STRING];
return GetTimeFormat(LOCALE_USER_DEFAULT, 0, &stFormatTime, nullptr, szTimeFormat, DATE_STRING) == 0 ? _T( "" ) : szTimeFormat;
}
void NotifyParent(int nItem, int nSubItem, int nMessage)
{
T * pT = static_cast<T *>(this);
CListNotify listNotify;
listNotify.m_hdrNotify.hwndFrom = pT->m_hWnd;
listNotify.m_hdrNotify.idFrom = pT->GetDlgCtrlID();
listNotify.m_hdrNotify.code = nMessage;
listNotify.m_nItem = nItem;
listNotify.m_nSubItem = GetColumnIndex(nSubItem);
listNotify.m_nExitChar = 0;
listNotify.m_lpszItemText = nullptr;
listNotify.m_lpItemDate = nullptr;
// Forward notification to parent
FORWARD_WM_NOTIFY(pT->GetParent(), listNotify.m_hdrNotify.idFrom, &listNotify.m_hdrNotify, ::SendMessage);
}
BOOL ShowTitleTip(CPoint point, int nItem, int nSubItem)
{
T * pT = static_cast<T *>(this);
// Do not show title tip if editing
if (m_bEditItem)
return FALSE;
// Is title tip already shown for this item?
if (nItem == m_nTitleTipItem && nSubItem == m_nTitleTipSubItem)
return FALSE;
CRect rcSubItem;
if (!GetItemRect(nItem, nSubItem, rcSubItem))
{
HideTitleTip();
return FALSE;
}
int nIndex = GetColumnIndex(nSubItem);
CRect rcItemText(rcSubItem);
// margin item text
// rcItemText.left += nSubItem == 0 ? 4 : 3;
// rcItemText.DeflateRect( 4, 0 );
// Offset item text (for image)
if (!m_ilItemImages.IsNull() && pT->GetItemImage(nItem, nIndex) != ITEM_IMAGE_NONE)
{
CSize sizeIcon;
m_ilItemImages.GetIconSize(sizeIcon);
rcItemText.left += sizeIcon.cx + 4;
}
// Is current cursor position over item text (not over an icon)?
if (!rcItemText.PtInRect(point))
return FALSE;
stdstr strItemText;
switch (pT->GetItemFormat(nItem, nIndex))
{
case ITEM_FORMAT_CHECKBOX:
case ITEM_FORMAT_CHECKBOX_3STATE:
case ITEM_FORMAT_PROGRESS: break; // No title tip for checkboxes or progress
case ITEM_FORMAT_DATETIME:
{
SYSTEMTIME stItemDate;
if (!GetItemDate(nItem, nIndex, stItemDate))
break;
UINT nItemFlags = pT->GetItemFlags(nItem, nIndex);
if (nItemFlags & ITEM_FLAGS_DATE_ONLY)
strItemText = FormatDate(stItemDate);
else if (nItemFlags & ITEM_FLAGS_TIME_ONLY)
strItemText = FormatTime(stItemDate);
else
strItemText = FormatDate(stItemDate) + _T( " " ) + FormatTime(stItemDate);
}
break;
default:
strItemText = pT->GetItemText(nItem, nIndex);
break;
}
if (strItemText.empty())
{
HideTitleTip();
return FALSE;
}
ClientToScreen(rcItemText);
if (!m_wndTitleTip.Show(rcItemText, strItemText.c_str(), pT->GetItemToolTip(nItem, nIndex).c_str()))
{
HideTitleTip();
return FALSE;
}
m_nTitleTipItem = nItem;
m_nTitleTipSubItem = nSubItem;
return TRUE;
}
BOOL HideTitleTip(BOOL bResetItem = TRUE)
{
if (bResetItem)
{
m_nTitleTipItem = NULL_ITEM;
m_nTitleTipSubItem = NULL_SUBITEM;
}
return m_wndTitleTip.Hide();
}
BEGIN_MSG_MAP_EX(CListImpl)
MSG_WM_CREATE(OnCreate)
MSG_WM_DESTROY(OnDestroy)
MSG_WM_SETFOCUS(OnSetFocus)
MSG_WM_KILLFOCUS(OnKillFocus)
MSG_WM_GETDLGCODE(OnGetDlgCode)
MSG_WM_SIZE(OnSize)
MSG_WM_HSCROLL(OnHScroll)
MSG_WM_VSCROLL(OnVScroll)
MSG_WM_CANCELMODE(OnCancelMode)
MESSAGE_RANGE_HANDLER_EX(WM_MOUSEFIRST, WM_MOUSELAST, OnMouseRange)
MSG_WM_LBUTTONDOWN(OnLButtonDown)
MSG_WM_LBUTTONUP(OnLButtonUp)
MSG_WM_LBUTTONDBLCLK(OnLButtonDblClk)
MSG_WM_RBUTTONDOWN(OnRButtonDown)
MSG_WM_RBUTTONUP(OnRButtonUp)
MSG_WM_MOUSEMOVE(OnMouseMove)
#if (_WIN32_WINNT >= 0x0400)
MSG_WM_MOUSELEAVE(OnMouseLeave)
MSG_WM_MOUSEWHEEL(OnMouseWheel)
#endif
MSG_WM_TIMER(OnTimer)
MSG_WM_KEYDOWN(OnKeyDown)
MSG_WM_SYSKEYDOWN(OnSysKeyDown)
MSG_WM_SETTINGCHANGE(OnSettingsChange)
MSG_WM_SYSCOLORCHANGE(OnSettingsChange)
MSG_WM_FONTCHANGE(OnSettingsChange)
//MSG_WM_THEMECHANGED(OnSettingsChange)
NOTIFY_CODE_HANDLER_EX(LCN_ENDEDIT, OnEndEdit)
MESSAGE_HANDLER(WM_CTLCOLORLISTBOX, OnCtlColorListBox)
MESSAGE_HANDLER(WM_CTLCOLOREDIT, OnCtlColorListBox)
CHAIN_MSG_MAP(CDoubleBufferImpl<CListImpl>)
REFLECT_NOTIFICATIONS()
END_MSG_MAP()
int OnCreate(LPCREATESTRUCT /*lpCreateStruct*/)
{
T * pT = static_cast<T *>(this);
return pT->Initialise() ? 0 : -1;
}
void OnDestroy()
{
m_oleDragDrop.Revoke();
if (m_wndDropArrows.IsWindow())
m_wndDropArrows.DestroyWindow();
if (m_wndTitleTip.IsWindow())
m_wndTitleTip.DestroyWindow();
if (m_wndItemEdit.IsWindow())
m_wndItemEdit.DestroyWindow();
if (m_wndItemCombo.IsWindow())
m_wndItemCombo.DestroyWindow();
if (m_wndItemDate.IsWindow())
m_wndItemDate.DestroyWindow();
if (m_ttToolTip.IsWindow())
m_ttToolTip.DestroyWindow();
}
void OnSetFocus(HWND /*hOldWnd*/)
{
Invalidate();
}
void OnKillFocus(HWND /*hNewWnd*/)
{
Invalidate();
}
UINT OnGetDlgCode(LPMSG /*lpMessage*/)
{
return DLGC_WANTARROWS | DLGC_WANTTAB | DLGC_WANTCHARS;
}
void OnSize(UINT /*nType*/, CSize /*size*/)
{
// Stop any pending scroll
EndScroll();
// End any pending edit
if (m_bEditItem)
SetFocus();
ResetScrollBars(SB_BOTH, -1, FALSE);
Invalidate();
}
void OnHScroll(int nSBCode, short /*nPos*/, HWND /*hScrollBar*/)
{
// Stop any pending scroll
EndScroll();
// End any pending edit
if (m_bEditItem)
SetFocus();
HideTitleTip();
CRect rcClient;
GetClientRect(rcClient);
int nScrollPos = GetScrollPos(SB_HORZ);
switch (nSBCode)
{
case SB_LEFT:
nScrollPos = 0;
break;
case SB_LINELEFT:
nScrollPos = max(nScrollPos - ITEM_SCROLL_OFFSET, 0);
break;
case SB_PAGELEFT:
nScrollPos = max(nScrollPos - rcClient.Width(), 0);
break;
case SB_RIGHT:
nScrollPos = rcClient.Width();
break;
case SB_LINERIGHT:
nScrollPos = min(nScrollPos + ITEM_SCROLL_OFFSET, GetTotalWidth());
break;
case SB_PAGERIGHT:
nScrollPos = min(nScrollPos + rcClient.Width(), GetTotalWidth());
break;
case SB_THUMBPOSITION:
case SB_THUMBTRACK:
{
SCROLLINFO infoScroll;
ZeroMemory(&infoScroll, sizeof(SCROLLINFO));
infoScroll.cbSize = sizeof(SCROLLINFO);
infoScroll.fMask = SIF_TRACKPOS;
// Get 32-bit scroll position
if (!GetScrollInfo(SB_HORZ, &infoScroll))
return;
// Has scroll position changed?
if (infoScroll.nTrackPos == nScrollPos)
return;
nScrollPos = infoScroll.nTrackPos;
}
break;
default: return;
}
ResetScrollBars(SB_HORZ, nScrollPos, FALSE);
Invalidate();
}
void OnVScroll(int nSBCode, short /*nPos*/, HWND /*hScrollBar*/)
{
T * pT = static_cast<T *>(this);
// End any pending edit
if (m_bEditItem)
SetFocus();
HideTitleTip();
CRect rcClient;
GetClientRect(rcClient);
rcClient.top = (m_bShowHeader ? m_nHeaderHeight : 0);
int nScrollPos = GetScrollPos(SB_VERT);
BOOL bScrollList = m_bSmoothScroll;
switch (nSBCode)
{
case SB_TOP:
nScrollPos = 0;
bScrollList = FALSE;
break;
case SB_LINEUP:
nScrollPos = max(nScrollPos - m_nItemHeight, 0);
break;
case SB_PAGEUP:
nScrollPos = max(nScrollPos - rcClient.Height(), 0);
break;
case SB_BOTTOM:
nScrollPos = pT->GetItemCount() * m_nItemHeight;
bScrollList = FALSE;
break;
case SB_LINEDOWN:
nScrollPos += m_nItemHeight;
break;
case SB_PAGEDOWN:
nScrollPos += rcClient.Height();
break;
case SB_THUMBTRACK:
case SB_THUMBPOSITION:
{
SCROLLINFO infoScroll;
ZeroMemory(&infoScroll, sizeof(SCROLLINFO));
infoScroll.cbSize = sizeof(SCROLLINFO);
infoScroll.fMask = SIF_TRACKPOS;
// Get 32-bit scroll position
if (!GetScrollInfo(SB_VERT, &infoScroll))
return;
// Has scroll position changed?
if (infoScroll.nTrackPos == nScrollPos)
return;
nScrollPos = infoScroll.nTrackPos;
bScrollList = FALSE;
}
break;
case SB_ENDSCROLL: m_bScrolling = FALSE;
default: return;
}
// Store original top item before scrolling
int nTopItem = GetTopItem();
ResetScrollBars(SB_VERT, nScrollPos, FALSE);
if (bScrollList && !m_bScrolling)
m_bScrolling = BeginScroll(nTopItem, GetTopItem());
else
EndScroll();
}
void OnCancelMode()
{
if (m_bButtonDown)
ReleaseCapture();
HideTitleTip();
m_wndDropArrows.Hide();
m_nDragColumn = NULL_COLUMN;
m_nHighlightColumn = NULL_COLUMN;
}
LRESULT OnMouseRange(UINT nMessage, WPARAM wParam, LPARAM lParam)
{
if (m_ttToolTip.IsWindow())
{
MSG msgRelay = {m_hWnd, nMessage, wParam, lParam};
m_ttToolTip.RelayEvent(&msgRelay);
}
SetMsgHandled(FALSE);
return 0;
}
void OnLButtonDown(UINT nFlags, CPoint point)
{
T * pT = static_cast<T *>(this);
// TODO: Fix?
// We have a bug here with setcapture() and the tooltip notifying the parent with mouse messages.
// Hard to explain, but what I think happens is that this click is sent by the tooltip, which then
// releases capture, so it gets no more mouse events, thus not receiving the actual double click
// on the tool tip, and what results is two single clicks for this parent control.
// Not sure how to fix - Rowan
// Explorer doesn't actually hide the tip when clicked on, so we can remove this code and it shouldn't really matter
//HideTitleTip(FALSE);
m_bButtonDown = TRUE;
m_ptDownPoint = point;
m_ptSelectPoint = CPoint(point.x + GetScrollPos(SB_HORZ), point.y + GetScrollPos(SB_VERT));
// Stop any pending scroll
EndScroll();
SetFocus();
// Capture all mouse input
SetCapture();
int nColumn = NULL_COLUMN;
UINT nHeaderFlags = HITTEST_FLAG_NONE;
// Are we over the header?
if (HitTestHeader(point, nColumn, nHeaderFlags))
{
CListColumn listColumn;
if (!GetColumn(nColumn, listColumn))
return;
if (!listColumn.m_bFixed && (nHeaderFlags & HITTEST_FLAG_HEADER_DIVIDER))
{
SetCursor(m_curDivider);
// Begin column resizing
m_bColumnSizing = TRUE;
m_nColumnSizing = nColumn;
m_nStartSize = listColumn.m_nWidth;
m_nStartPos = GET_X_LPARAM(GetMessagePos());
}
else if (m_bSortEnabled) // Added by Rowan 05/12/2006
{
m_nHighlightColumn = nColumn;
InvalidateHeader();
}
return;
}
int nItem = NULL_ITEM;
int nSubItem = NULL_SUBITEM;
if (!HitTest(point, nItem, nSubItem))
{
m_nFirstSelected = NULL_ITEM;
m_bBeginSelect = TRUE;
}
else
{
// Do not begin group select from first columns
if (!(nFlags & MK_SHIFT) && !(nFlags & MK_CONTROL) && nSubItem != 0)
{
m_bBeginSelect = TRUE;
m_nFirstSelected = nItem;
}
// Only select item if not already selected
if ((nFlags & MK_SHIFT) || (nFlags & MK_CONTROL) || !IsSelected(nItem) || m_setSelectedItems.size() <= 1)
SelectItem(nItem, nSubItem, nFlags);
int nIndex = GetColumnIndex(nSubItem);
if (!(pT->GetItemFlags(nItem, nIndex) & ITEM_FLAGS_READ_ONLY))
{
switch (pT->GetItemFormat(nItem, nIndex))
{
case ITEM_FORMAT_CHECKBOX:
m_bBeginSelect = FALSE;
pT->SetItemText(nItem, nIndex, _ttoi(pT->GetItemText(nItem, nIndex)) > 0 ? _T( "0" ) : _T( "1" ));
NotifyParent(nItem, nSubItem, LCN_MODIFIED);
InvalidateItem(nItem);
break;
case ITEM_FORMAT_CHECKBOX_3STATE:
{
m_bBeginSelect = FALSE;
int nCheckImage = _ttoi(pT->GetItemText(nItem, nIndex));
if (nCheckImage < 0)
pT->SetItemText(nItem, nIndex, _T( "0" ));
else if (nCheckImage > 0)
pT->SetItemText(nItem, nIndex, _T( "-1" ));
else
pT->SetItemText(nItem, nIndex, _T( "1" ));
NotifyParent(nItem, nSubItem, LCN_MODIFIED);
InvalidateItem(nItem);
}
break;
case ITEM_FORMAT_HYPERLINK:
m_bBeginSelect = FALSE;
SetCursor(m_curHyperLink);
NotifyParent(nItem, nSubItem, LCN_HYPERLINK);
break;
}
if ((pT->GetItemFlags(nItem, nIndex) & ITEM_FLAGS_HIT_NOTIFY) != 0)
{
NotifyParent(nItem, nSubItem, LCN_HITTEST);
}
}
}
}
void OnLButtonUp(UINT nFlags, CPoint point)
{
if (m_bButtonDown)
ReleaseCapture();
// Finish resizing or selecting a column
if (m_bColumnSizing || m_nHighlightColumn != NULL_COLUMN)
{
// Are we changing the sort order?
if (!m_bColumnSizing && m_nHighlightColumn != NULL_COLUMN && m_bSortEnabled) // Changed by Rowan 05/12/2006
//if ( !m_bColumnSizing && m_nHighlightColumn != NULL_COLUMN)
SortColumn(m_nHighlightColumn);
m_bColumnSizing = FALSE;
m_nColumnSizing = NULL_COLUMN;
m_nHighlightColumn = NULL_COLUMN;
m_nStartSize = 0;
m_nStartPos = 0;
InvalidateHeader();
}
m_bBeginSelect = FALSE;
m_bButtonDown = FALSE;
m_ptDownPoint = 0;
m_ptSelectPoint = 0;
// Have we finished a group select?
if (m_bGroupSelect)
{
m_bGroupSelect = FALSE;
Invalidate();
}
else
{
int nItem = NULL_ITEM;
int nSubItem = NULL_SUBITEM;
// Deselect item if current item is selected
if (HitTest(point, nItem, nSubItem) && IsSelected(nItem) && m_setSelectedItems.size() > 1 && !(nFlags & MK_SHIFT) && !(nFlags & MK_CONTROL))
SelectItem(nItem, nSubItem, nFlags);
// Notify parent of left-click item
NotifyParent(nItem, nSubItem, LCN_LEFTCLICK);
}
}
void OnLButtonDblClk(UINT /*nFlags*/, CPoint point)
{
HideTitleTip(FALSE);
// Handle double-clicks (for drawing)
SendMessage(WM_LBUTTONDOWN, 0, MAKELPARAM(point.x, point.y));
int nColumn = NULL_COLUMN;
UINT nHeaderFlags = HITTEST_FLAG_NONE;
// Resize column if double-click on a divider
if (HitTestHeader(point, nColumn, nHeaderFlags) && (nHeaderFlags & HITTEST_FLAG_HEADER_DIVIDER))
AutoSizeColumn(nColumn);
int nItem = NULL_ITEM;
int nSubItem = NULL_SUBITEM;
HitTest(point, nItem, nSubItem);
//WriteTraceF(TraceInfo, "List Ctrl Double Click, Item: %d", nItem);
// Notify parent of double-clicked item
NotifyParent(nItem, nSubItem, LCN_DBLCLICK);
}
void OnRButtonDown(UINT nFlags, CPoint point)
{
// Stop any pending scroll
EndScroll();
SetFocus();
HideTitleTip(FALSE);
int nItem = NULL_ITEM;
int nSubItem = NULL_SUBITEM;
if (m_bRightClickSelect)
{
// Only select item if not already selected (deselect in OnLButtonUp)
if (HitTest(point, nItem, nSubItem) && !IsSelected(nItem))
SelectItem(nItem, nSubItem, nFlags);
}
}
void OnRButtonUp(UINT /*nFlags*/, CPoint point)
{
int nItem = NULL_ITEM;
int nSubItem = NULL_SUBITEM;
if (!HitTest(point, nItem, nSubItem))
ResetSelected();
// Notify parent of right-click item
NotifyParent(nItem, nSubItem, LCN_RIGHTCLICK);
}
void OnMouseMove(UINT nFlags, CPoint point)
{
T * pT = static_cast<T *>(this);
if (!(nFlags & MK_LBUTTON))
{
if (m_bButtonDown)
ReleaseCapture();
m_bButtonDown = FALSE;
}
if (!m_bMouseOver)
{
m_bMouseOver = TRUE;
TRACKMOUSEEVENT trkMouse;
trkMouse.cbSize = sizeof(TRACKMOUSEEVENT);
trkMouse.dwFlags = TME_LEAVE;
trkMouse.hwndTrack = m_hWnd;
// Notify when the mouse leaves button
_TrackMouseEvent(&trkMouse);
}
if (m_bButtonDown)
{
// Are we resizing a column?
if (m_bColumnSizing)
{
ResizeColumn();
return;
}
// Are we beginning to drag a column?
if (m_nHighlightColumn != NULL_COLUMN && (point.x < m_ptDownPoint.x - DRAG_HEADER_OFFSET || point.x > m_ptDownPoint.x + DRAG_HEADER_OFFSET || point.y < m_ptDownPoint.y - DRAG_HEADER_OFFSET || point.y > m_ptDownPoint.y + DRAG_HEADER_OFFSET))
{
DragColumn();
return;
}
// Are we beginning a group select or dragging an item?
if (point.x < m_ptDownPoint.x - DRAG_ITEM_OFFSET || point.x > m_ptDownPoint.x + DRAG_ITEM_OFFSET || point.y < m_ptDownPoint.y - DRAG_ITEM_OFFSET || point.y > m_ptDownPoint.y + DRAG_ITEM_OFFSET)
{
if (m_bBeginSelect || !m_bDragDrop)
m_bGroupSelect = (!m_bSingleSelect && !m_bEditItem);
else
{
int nItem = NULL_ITEM;
int nSubItem = NULL_SUBITEM;
if (HitTest(point, nItem, nSubItem))
{
// Select the drag item (if not already selected)
if (!IsSelected(nItem))
SelectItem(nItem, nSubItem, nFlags);
// Begin drag item operation
pT->DragItem();
}
}
}
if (m_bGroupSelect)
{
GroupSelect(point);
return;
}
}
else
{
int nColumn = NULL_COLUMN;
UINT nHeaderFlags = HITTEST_FLAG_NONE;
// Are we over the header?
BOOL bHitTestHeader = HitTestHeader(point, nColumn, nHeaderFlags);
if (bHitTestHeader)
{
HideTitleTip();
CListColumn listColumn;
if (GetColumn(nColumn, listColumn) && !listColumn.m_bFixed && (nHeaderFlags & HITTEST_FLAG_HEADER_DIVIDER))
SetCursor(m_curDivider);
else
{
// Get tooltip for this item
stdstr strToolTip = pT->GetHeaderToolTip(nColumn);
if (!strToolTip.empty())
{
CRect rcColumn;
if (!GetColumnRect(nColumn, rcColumn))
return;
rcColumn.bottom = m_nHeaderHeight;
m_ttToolTip.Activate(TRUE);
m_ttToolTip.AddTool(m_hWnd, (LPCTSTR)strToolTip.c_str(), rcColumn, TOOLTIP_TOOL_ID);
}
}
return;
}
int nItem = NULL_ITEM;
int nSubItem = NULL_SUBITEM;
if (!HitTest(point, nItem, nSubItem))
{
if (m_nHotItem != NULL_ITEM && m_nHotSubItem != NULL_SUBITEM)
{
// Redraw old hot item
int nIndex = GetColumnIndex(m_nHotSubItem);
if (pT->GetItemFormat(m_nHotItem, nIndex) == ITEM_FORMAT_HYPERLINK && !(pT->GetItemFlags(m_nHotItem, nIndex) & ITEM_FLAGS_READ_ONLY))
InvalidateItem(m_nHotItem, m_nHotSubItem);
}
m_ttToolTip.Activate(FALSE);
m_ttToolTip.DelTool(m_hWnd, TOOLTIP_TOOL_ID);
m_nHotItem = NULL_ITEM;
m_nHotSubItem = NULL_SUBITEM;
HideTitleTip();
}
else
{
// Has the hot item changed?
if (nItem != m_nHotItem || nSubItem != m_nHotSubItem)
{
// Redraw old hot item
int nIndex = GetColumnIndex(m_nHotSubItem);
if (pT->GetItemFormat(m_nHotItem, nIndex) == ITEM_FORMAT_HYPERLINK && !(pT->GetItemFlags(m_nHotItem, nIndex) & ITEM_FLAGS_READ_ONLY))
InvalidateItem(m_nHotItem, m_nHotSubItem);
m_nHotItem = nItem;
m_nHotSubItem = nSubItem;
NotifyParent(nItem, nSubItem, LCN_HOTITEMCHANGED);
}
int nIndex = GetColumnIndex(m_nHotSubItem);
UINT nItemFormat = pT->GetItemFormat(m_nHotItem, nIndex);
UINT nItemFlags = pT->GetItemFlags(m_nHotItem, nIndex);
// Draw new hot hyperlink item
if (nItemFormat == ITEM_FORMAT_HYPERLINK && !(nItemFlags & ITEM_FLAGS_READ_ONLY))
{
InvalidateItem(m_nHotItem, m_nHotSubItem);
SetCursor(m_curHyperLink);
}
// Get tooltip for this item
stdstr strToolTip = pT->GetItemToolTip(m_nHotItem, nIndex);
CRect rcSubItem;
if (!strToolTip.empty() && GetItemRect(m_nHotItem, rcSubItem))
{
m_ttToolTip.Activate(TRUE);
m_ttToolTip.AddTool(m_hWnd, (LPCTSTR)strToolTip.substr(0, SHRT_MAX).c_str(), rcSubItem, TOOLTIP_TOOL_ID);
}
else
{
m_ttToolTip.Activate(FALSE);
m_ttToolTip.DelTool(m_hWnd, TOOLTIP_TOOL_ID);
}
// Show title tips for this item
ShowTitleTip(point, m_nHotItem, m_nHotSubItem);
}
}
}
void OnMouseLeave()
{
m_bMouseOver = FALSE;
if (m_nHotColumn != NULL_COLUMN)
{
m_nHotColumn = NULL_COLUMN;
InvalidateHeader();
}
if (m_nHotItem != NULL_ITEM || m_nHotSubItem != NULL_SUBITEM)
{
m_nHotItem = NULL_ITEM;
m_nHotSubItem = NULL_SUBITEM;
Invalidate();
}
}
BOOL OnMouseWheel(UINT /*nFlags*/, short nDelta, CPoint /*point*/)
{
HideTitleTip();
// End any pending edit
if (m_bEditItem)
SetFocus();
int nRowsScrolled = m_nMouseWheelScroll * nDelta / 120;
int nScrollPos = GetScrollPos(SB_VERT);
if (nRowsScrolled > 0)
nScrollPos = max(nScrollPos - (nRowsScrolled * m_nItemHeight), 0);
else
nScrollPos += (-nRowsScrolled * m_nItemHeight);
ResetScrollBars(SB_VERT, nScrollPos, FALSE);
Invalidate();
return TRUE;
}
void OnTimer(UINT_PTR nIDEvent)
{
switch (nIDEvent)
{
case RESIZE_COLUMN_TIMER:
ResizeColumn(TRUE);
break;
case ITEM_VISIBLE_TIMER:
{
KillTimer(ITEM_VISIBLE_TIMER);
int nFocusItem = NULL_ITEM;
int nFocusSubItem = NULL_SUBITEM;
// Get current focus item
if (!GetFocusItem(nFocusItem, nFocusSubItem))
break;
// Make sure current focus item is visible before editing
if (!EditItem(nFocusItem, nFocusSubItem))
break;
}
break;
case ITEM_AUTOSCROLL_TIMER:
if (!m_bGroupSelect)
KillTimer(ITEM_AUTOSCROLL_TIMER);
else
{
DWORD dwPoint = GetMessagePos();
CPoint ptMouse(GET_X_LPARAM(dwPoint), GET_Y_LPARAM(dwPoint));
ScreenToClient(&ptMouse);
// Automatically scroll when group selecting
AutoScroll(ptMouse);
AutoSelect(ptMouse);
}
break;
case ITEM_SCROLL_TIMER:
if (!ScrollList())
EndScroll();
break;
}
}
void OnKeyDown(TCHAR nChar, UINT /*nRepCnt*/, UINT /*nFlags*/)
{
T * pT = static_cast<T *>(this);
// Stop any pending scroll
EndScroll();
BOOL bCtrlKey = ((GetKeyState(VK_CONTROL) & 0x8000) != 0);
BOOL bShiftKey = ((GetKeyState(VK_SHIFT) & 0x8000) != 0);
CRect rcClient;
GetClientRect(rcClient);
int nFocusItem = NULL_ITEM;
int nFocusSubItem = NULL_SUBITEM;
GetFocusItem(nFocusItem, nFocusSubItem);
switch (nChar)
{
case VK_DOWN:
SetFocusItem(min(nFocusItem + 1, pT->GetItemCount() - 1), nFocusSubItem);
break;
case VK_UP:
SetFocusItem(max(nFocusItem - 1, 0), nFocusSubItem);
break;
case VK_NEXT:
SetFocusItem(min(nFocusItem + GetCountPerPage(FALSE) - 1, pT->GetItemCount() - 1), nFocusSubItem);
break;
case VK_PRIOR:
SetFocusItem(max(nFocusItem - GetCountPerPage(FALSE) + 1, 0), nFocusSubItem);
break;
case VK_HOME:
SetFocusItem(0, nFocusSubItem);
break;
case VK_END:
SetFocusItem(pT->GetItemCount() - 1, nFocusSubItem);
break;
case VK_LEFT:
if (m_bFocusSubItem)
SetFocusItem(nFocusItem, max(nFocusSubItem - 1, 0));
else
SetScrollPos(SB_HORZ, max(GetScrollPos(SB_HORZ) - (bCtrlKey ? ITEM_SCROLL_OFFSET * 10 : ITEM_SCROLL_OFFSET), 0));
break;
case VK_RIGHT:
if (m_bFocusSubItem)
SetFocusItem(nFocusItem, min(nFocusSubItem + 1, GetColumnCount() - 1));
else
SetScrollPos(SB_HORZ, min(GetScrollPos(SB_HORZ) + (bCtrlKey ? ITEM_SCROLL_OFFSET * 10 : ITEM_SCROLL_OFFSET), rcClient.Width()));
break;
case VK_TAB:
if (!bCtrlKey && m_bFocusSubItem)
SetFocusItem(nFocusItem, bShiftKey ? max(nFocusSubItem - 1, 0) : min(nFocusSubItem + 1, GetColumnCount() - 1));
break;
default:
if (nChar == VK_SPACE)
{
int nIndex = GetColumnIndex(nFocusSubItem);
if (!(pT->GetItemFlags(nFocusItem, nIndex) & ITEM_FLAGS_READ_ONLY))
{
switch (pT->GetItemFormat(nFocusItem, nIndex))
{
case ITEM_FORMAT_CHECKBOX:
pT->SetItemText(nFocusItem, nIndex, _ttoi(pT->GetItemText(nFocusItem, nIndex)) > 0 ? _T( "0" ) : _T( "1" ));
NotifyParent(nFocusItem, nFocusSubItem, LCN_MODIFIED);
InvalidateItem(nFocusItem);
return;
case ITEM_FORMAT_CHECKBOX_3STATE:
{
int nCheckImage = _ttoi(pT->GetItemText(nFocusItem, nIndex));
if (nCheckImage < 0)
pT->SetItemText(nFocusItem, nIndex, _T( "0" ));
else if (nCheckImage > 0)
pT->SetItemText(nFocusItem, nIndex, _T( "-1" ));
else
pT->SetItemText(nFocusItem, nIndex, _T( "1" ));
NotifyParent(nFocusItem, nFocusSubItem, LCN_MODIFIED);
InvalidateItem(nFocusItem);
}
return;
}
}
}
if (bCtrlKey && nChar == _T('A') && !m_bSingleSelect)
{
m_setSelectedItems.clear();
for (int nItem = 0; nItem < pT->GetItemCount(); nItem++)
m_setSelectedItems.insert(nItem);
Invalidate();
return;
}
if (!bCtrlKey && iswprint(nChar) && iswupper(nChar))
{
int nSortIndex = GetColumnIndex(m_nSortColumn);
int nStartItem = nFocusItem + 1;
DWORD dwCurrentTick = GetTickCount();
stdstr strStart;
strStart += nChar;
// Has there been another keypress since last search period?
if ((dwCurrentTick - m_dwSearchTick) < SEARCH_PERIOD)
{
if (m_strSearchString.substr(0, 1) != strStart)
m_strSearchString += nChar;
stdstr strFocusText = pT->GetItemText(nFocusItem, nSortIndex);
// Are we continuing to type characters under current focus item?
if (m_strSearchString.length() > 1 && _tcsicmp(m_strSearchString.c_str(), strFocusText.substr(0, m_strSearchString.length()).c_str()) == 0)
{
m_dwSearchTick = GetTickCount();
return;
}
}
else
{
if (m_strSearchString.substr(0, 1) != strStart)
nStartItem = 0;
m_strSearchString = strStart;
}
m_dwSearchTick = GetTickCount();
// Scan for next search string
for (int nFirst = nStartItem; nFirst < pT->GetItemCount(); nFirst++)
{
stdstr strItemText = pT->GetItemText(nFirst, nSortIndex);
if (_tcsicmp(m_strSearchString.c_str(), strItemText.substr(0, m_strSearchString.length()).c_str()) == 0)
{
SelectItem(nFirst, nFocusSubItem, TRUE);
EnsureItemVisible(nFirst, nFocusSubItem);
return;
}
}
// Rescan from top if not found search string
for (int nSecond = 0; nSecond < pT->GetItemCount(); nSecond++)
{
stdstr strItemText = pT->GetItemText(nSecond, nSortIndex);
if (_tcsicmp(m_strSearchString.c_str(), strItemText.substr(0, m_strSearchString.length()).c_str()) == 0)
{
SelectItem(nSecond, nFocusSubItem, TRUE);
EnsureItemVisible(nSecond, nFocusSubItem);
return;
}
}
}
return;
}
if (!bCtrlKey)
SelectItem(m_nFocusItem, m_nFocusSubItem, bShiftKey ? MK_SHIFT : 0);
}
void OnSysKeyDown(TCHAR /*nChar*/, UINT /*nRepCnt*/, UINT /*nFlags*/)
{
HideTitleTip(FALSE);
SetMsgHandled(FALSE);
}
void OnSettingsChange(UINT /*nFlags*/, LPCTSTR /*lpszSection*/)
{
OnSettingsChange();
}
void OnSettingsChange()
{
LoadSettings();
ResetScrollBars();
Invalidate();
}
LRESULT OnCtlColorListBox(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL & /*bHandled*/)
{
return DefWindowProc(nMsg, wParam, lParam);
}
LRESULT OnEndEdit(LPNMHDR lpNMHDR)
{
T * pT = static_cast<T *>(this);
CListNotify * pListNotify = reinterpret_cast<CListNotify *>(lpNMHDR);
m_bEditItem = FALSE;
int nIndex = GetColumnIndex(pListNotify->m_nSubItem);
switch (pListNotify->m_nExitChar)
{
case VK_ESCAPE: break; // Do nothing
case VK_DELETE:
pT->SetItemText(pListNotify->m_nItem, nIndex, _T( "" ));
NotifyParent(pListNotify->m_nItem, pListNotify->m_nSubItem, LCN_MODIFIED);
break;
default:
if (pListNotify->m_lpItemDate == nullptr)
pT->SetItemText(pListNotify->m_nItem, nIndex, pListNotify->m_lpszItemText);
else
{
if (_ttoi(pListNotify->m_lpszItemText) == 0)
pT->SetItemText(pListNotify->m_nItem, nIndex, _T( "" ));
else
pT->SetItemDate(pListNotify->m_nItem, nIndex, *pListNotify->m_lpItemDate);
}
if (pListNotify->m_nExitChar == VK_TAB)
PostMessage(WM_KEYDOWN, (WPARAM)VK_TAB);
NotifyParent(pListNotify->m_nItem, pListNotify->m_nSubItem, LCN_MODIFIED);
break;
}
InvalidateItem(pListNotify->m_nItem);
return 0;
}
DWORD OnDragEnter(FORMATETC & FormatEtc, STGMEDIUM & StgMedium, DWORD /*dwKeyState*/, CPoint point)
{
DWORD dwEffect = DROPEFFECT_NONE;
if (FormatEtc.cfFormat == m_nHeaderClipboardFormat)
{
LPBYTE lpDragHeader = (LPBYTE)GlobalLock(StgMedium.hGlobal);
if (lpDragHeader == nullptr)
return DROPEFFECT_NONE;
// Dragged column must originate from this control
if (*((HWND *)lpDragHeader) == m_hWnd)
dwEffect = DropColumn(point) ? DROPEFFECT_MOVE : DROPEFFECT_NONE;
GlobalUnlock(StgMedium.hGlobal);
}
return dwEffect;
}
DWORD OnDragOver(FORMATETC & FormatEtc, STGMEDIUM & StgMedium, DWORD /*dwKeyState*/, CPoint point)
{
DWORD dwEffect = DROPEFFECT_NONE;
if (FormatEtc.cfFormat == m_nHeaderClipboardFormat)
{
LPBYTE lpDragHeader = (LPBYTE)GlobalLock(StgMedium.hGlobal);
if (lpDragHeader == nullptr)
return DROPEFFECT_NONE;
// Dragged column must originate from this control
if (*((HWND *)lpDragHeader) == m_hWnd)
dwEffect = DropColumn(point) ? DROPEFFECT_MOVE : DROPEFFECT_NONE;
GlobalUnlock(StgMedium.hGlobal);
}
return dwEffect;
}
BOOL OnDrop(FORMATETC & FormatEtc, STGMEDIUM & /*StgMedium*/, DWORD /*dwEffect*/, CPoint /*point*/)
{
if (FormatEtc.cfFormat == m_nHeaderClipboardFormat)
{
if (m_nDragColumn != NULL_COLUMN && m_nHotDivider != NULL_COLUMN)
{
CListColumn listColumn;
if (!GetColumn(m_nDragColumn, listColumn))
return FALSE;
// Move column to new position
m_aColumns.RemoveAt(m_nDragColumn);
m_aColumns.InsertAt((m_nDragColumn < m_nHotColumn ? (m_nHotDivider == 0 ? 0 : m_nHotDivider - 1) : m_nHotDivider), listColumn);
Invalidate();
}
return TRUE;
}
// Not supported
return FALSE;
}
void OnDragLeave()
{
}
BOOL OnRenderData(FORMATETC & FormatEtc, STGMEDIUM * pStgMedium, BOOL /*bDropComplete*/)
{
if (FormatEtc.cfFormat == m_nHeaderClipboardFormat)
{
pStgMedium->tymed = TYMED_HGLOBAL;
pStgMedium->hGlobal = GlobalAlloc(GMEM_MOVEABLE, sizeof(HWND));
if (pStgMedium->hGlobal == nullptr)
return FALSE;
LPBYTE lpDragHeader = (LPBYTE)GlobalLock(pStgMedium->hGlobal);
if (lpDragHeader == nullptr)
return FALSE;
// Store this window handle
*((HWND *)lpDragHeader) = m_hWnd;
GlobalUnlock(pStgMedium->hGlobal);
return TRUE;
}
return FALSE;
}
void DoPaint(CDCHandle dcPaint)
{
T * pT = static_cast<T *>(this);
int nContextState = dcPaint.SaveDC();
pT->DrawBkgnd(dcPaint);
pT->DrawList(dcPaint);
pT->DrawSelect(dcPaint);
pT->DrawHeader(dcPaint);
dcPaint.RestoreDC(nContextState);
}
void DrawBkgnd(CDCHandle dcPaint)
{
CRect rcClip;
if (dcPaint.GetClipBox(rcClip) == ERROR)
return;
dcPaint.SetBkColor(m_rgbBackground);
dcPaint.ExtTextOut(rcClip.left, rcClip.top, ETO_OPAQUE, rcClip, _T( "" ), 0, nullptr);
CRect rcClient;
GetClientRect(rcClient);
rcClient.top = (m_bShowHeader ? m_nHeaderHeight : 0);
if (!m_bmpBackground.IsNull() && rcClip.bottom > rcClient.top)
{
CSize sizBackground;
m_bmpBackground.GetSize(sizBackground);
CDC dcBackgroundImage;
dcBackgroundImage.CreateCompatibleDC(dcPaint);
HBITMAP hOldBitmap = dcBackgroundImage.SelectBitmap(m_bmpBackground);
if (m_bTileBackground)
{
// Calculate tile image maximum rows and columns
div_t divRows = div((int)rcClient.Height(), (int)sizBackground.cy);
int nTileRows = divRows.rem > 0 ? divRows.quot + 1 : divRows.quot;
div_t divColumns = div((int)rcClient.Width(), (int)sizBackground.cx);
int nTileColumns = divColumns.rem > 0 ? divColumns.quot + 1 : divColumns.quot;
// Draw tiled background image
for (int nRow = 0; nRow <= nTileRows; nRow++)
{
for (int nColumn = 0; nColumn <= nTileColumns; nColumn++)
dcPaint.BitBlt(nColumn * sizBackground.cx, nRow * sizBackground.cy, sizBackground.cx, sizBackground.cy, dcBackgroundImage, 0, 0, SRCCOPY);
}
}
else
{
CRect rcCentreImage(rcClient);
// Horizontally center image if smaller than the client width
if (sizBackground.cx < rcClient.Width())
{
rcCentreImage.left = (rcClient.Width() / 2) - (int)(sizBackground.cx / 2);
rcCentreImage.right = rcCentreImage.left + sizBackground.cx;
}
// Vertically center image if smaller than the client height
if (sizBackground.cy + 16 < rcClient.Height())
{
rcCentreImage.top = (rcClient.Height() / 2) - (int)((sizBackground.cy + 16) / 2);
rcCentreImage.bottom = rcCentreImage.top + sizBackground.cy;
}
// Draw centered background image
dcPaint.BitBlt(rcCentreImage.left, rcCentreImage.top, rcCentreImage.Width(), rcCentreImage.Height(), dcBackgroundImage, 0, 0, SRCCOPY);
}
dcBackgroundImage.SelectBitmap(hOldBitmap);
}
}
void DrawHeader(CDCHandle dcPaint)
{
if (!m_bShowHeader)
return;
CRect rcClip;
if (dcPaint.GetClipBox(rcClip) == ERROR)
return;
CRect rcHeader;
GetClientRect(rcHeader);
rcHeader.bottom = m_nHeaderHeight;
if (rcClip.top > rcHeader.bottom)
return;
dcPaint.SetBkColor(m_rgbHeaderBackground);
dcPaint.ExtTextOut(rcHeader.left, rcHeader.top, ETO_OPAQUE, rcHeader, _T( "" ), 0, nullptr);
CPen penHighlight;
penHighlight.CreatePen(PS_SOLID, 1, m_rgbHeaderBorder);
CPen penShadow;
penShadow.CreatePen(PS_SOLID, 1, m_rgbHeaderShadow);
CRect rcHeaderItem(rcHeader);
rcHeaderItem.OffsetRect(-GetScrollPos(SB_HORZ), 0);
int nHeaderWidth = 0;
for (int nColumn = 0, nColumnCount = GetColumnCount(); nColumn < nColumnCount; rcHeaderItem.left = rcHeaderItem.right, nColumn++)
{
CListColumn listColumn;
if (!GetColumn(nColumn, listColumn))
break;
rcHeaderItem.right = rcHeaderItem.left + listColumn.m_nWidth;
nHeaderWidth += rcHeaderItem.Width();
if (rcHeaderItem.right < rcClip.left)
continue;
if (rcHeaderItem.left > rcClip.right)
break;
// Draw header and divider
if (nColumn == m_nHighlightColumn)
{
dcPaint.SetBkColor(m_rgbHeaderHighlight);
dcPaint.ExtTextOut(rcHeaderItem.left, rcHeaderItem.top, ETO_OPAQUE, rcHeaderItem, _T( "" ), 0, nullptr);
}
dcPaint.SelectPen(penShadow);
dcPaint.MoveTo(rcHeaderItem.right - 1, rcHeaderItem.top + 1);
dcPaint.LineTo(rcHeaderItem.right - 1, m_nHeaderHeight - 1);
dcPaint.SelectPen(penHighlight);
dcPaint.MoveTo(rcHeaderItem.right, rcHeaderItem.top + 1);
dcPaint.LineTo(rcHeaderItem.right, m_nHeaderHeight - 1);
CRect rcHeaderText(rcHeaderItem);
rcHeaderText.left += nColumn == 0 ? 4 : 3;
rcHeaderText.OffsetRect(0, 1);
BOOL bShowArrow = m_bShowSort && (rcHeaderItem.Width() > 15);
if (listColumn.m_nImage == ITEM_IMAGE_NONE)
{
// Offset text bounding rectangle to account for sorting arrow
if (bShowArrow && !listColumn.m_bFixed && listColumn.m_nIndex == m_nSortColumn)
rcHeaderText.right -= 15;
}
// Margin header text
rcHeaderText.DeflateRect(4, 0, 5, 0);
// Has this header item an associated image?
if (listColumn.m_nImage != ITEM_IMAGE_NONE)
{
CSize sizeIcon;
m_ilListItems.GetIconSize(sizeIcon);
CRect rcHeaderImage;
rcHeaderImage.left = listColumn.m_strText.empty() ? ((rcHeaderText.left + rcHeaderText.right) / 2) - (sizeIcon.cx / 2) - (0) : rcHeaderText.left;
rcHeaderImage.right = min(rcHeaderImage.left + sizeIcon.cx, rcHeaderItem.right - 2);
rcHeaderImage.top = ((rcHeaderItem.top + rcHeaderItem.bottom) / 2) - (sizeIcon.cy / 2);
rcHeaderImage.bottom = min(rcHeaderImage.top + sizeIcon.cy, rcHeaderItem.bottom);
if (listColumn.m_nIndex == m_nSortColumn)
m_ilListItems.DrawEx(listColumn.m_nImage, dcPaint, rcHeaderImage, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT | ILD_SELECTED);
else
m_ilListItems.DrawEx(listColumn.m_nImage, dcPaint, rcHeaderImage, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT);
// Offset header text (for image)
rcHeaderText.left += sizeIcon.cx + 4;
}
dcPaint.SelectFont(m_fntListFont);
dcPaint.SetTextColor(m_rgbHeaderText);
dcPaint.SetBkMode(TRANSPARENT);
UINT nFormat = DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_END_ELLIPSIS;
if (listColumn.m_nFlags & ITEM_FLAGS_CENTRE)
nFormat |= DT_CENTER;
else if (listColumn.m_nFlags & ITEM_FLAGS_RIGHT)
nFormat |= DT_RIGHT;
else
nFormat |= DT_LEFT;
// Draw header text
if (!rcHeaderText.IsRectEmpty() && !listColumn.m_strText.empty())
dcPaint.DrawText(listColumn.m_strText.c_str(), (int)listColumn.m_strText.length(), rcHeaderText, nFormat);
// Draw sorting arrow
if (bShowArrow && !listColumn.m_bFixed && listColumn.m_nIndex == m_nSortColumn)
{
CSize sizeIcon;
m_ilListItems.GetIconSize(sizeIcon);
CRect rcSortArrow;
rcSortArrow.left = rcHeaderText.right + 4;
rcSortArrow.right = min(rcSortArrow.left + sizeIcon.cx, rcHeaderItem.right);
rcSortArrow.top = rcHeaderItem.Height() / 2 - 3;
rcSortArrow.bottom = min(rcSortArrow.top + sizeIcon.cy, rcHeaderItem.bottom);
m_ilListItems.DrawEx(m_bSortAscending ? ITEM_IMAGE_UP : ITEM_IMAGE_DOWN, dcPaint, rcSortArrow, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT);
}
}
// Draw a frame around all header columns
if (nHeaderWidth > 0)
dcPaint.Draw3dRect(CRect(rcHeader.left, rcHeader.top, rcHeader.right + 2, rcHeader.bottom), m_rgbHeaderBorder, m_rgbHeaderShadow);
}
void DrawRoundRect(CDCHandle dcPaint, CRect & rcRect, COLORREF rgbOuter, COLORREF rgbInner)
{
CRect rcRoundRect(rcRect);
CPen penBorder;
penBorder.CreatePen(PS_SOLID, 1, rgbOuter);
CBrush bshInterior;
bshInterior.CreateSolidBrush(m_rgbBackground);
dcPaint.SelectPen(penBorder);
dcPaint.SelectBrush(bshInterior);
dcPaint.RoundRect(rcRoundRect, CPoint(5, 5));
rcRoundRect.DeflateRect(1, 1);
CPen penInnerBorder;
penInnerBorder.CreatePen(PS_SOLID, 1, rgbInner);
dcPaint.SelectPen(penInnerBorder);
dcPaint.RoundRect(rcRoundRect, CPoint(2, 2));
}
void DrawGradient(CDCHandle dcPaint, CRect & rcRect, COLORREF rgbTop, COLORREF rgbBottom)
{
GRADIENT_RECT grdRect = {0, 1};
TRIVERTEX triVertext[2] = {
rcRect.left,
rcRect.top,
(COLOR16)(GetRValue(rgbTop) << 8),
(COLOR16)(GetGValue(rgbTop) << 8),
(COLOR16)(GetBValue(rgbTop) << 8),
(COLOR16)(0x0000),
rcRect.right,
rcRect.bottom,
(COLOR16)(GetRValue(rgbBottom) << 8),
(COLOR16)(GetGValue(rgbBottom) << 8),
(COLOR16)(GetBValue(rgbBottom) << 8),
(COLOR16)(0x0000)};
dcPaint.GradientFill(triVertext, 2, &grdRect, 1, GRADIENT_FILL_RECT_V);
}
void DrawList(CDCHandle dcPaint)
{
T * pT = static_cast<T *>(this);
CRect rcClip;
if (dcPaint.GetClipBox(rcClip) == ERROR)
return;
CRect rcItem;
rcItem.left = -GetScrollPos(SB_HORZ);
rcItem.right = GetTotalWidth();
rcItem.top = (m_bShowHeader ? m_nHeaderHeight : 0);
rcItem.bottom = rcItem.top;
// Draw all visible items
for (int nItem = GetTopItem(); nItem < pT->GetItemCount(); rcItem.top = rcItem.bottom, nItem++)
{
rcItem.bottom = rcItem.top + m_nItemHeight;
if (rcItem.bottom < rcClip.top || rcItem.right < rcClip.left)
continue;
if (rcItem.top > rcClip.bottom || rcItem.left > rcClip.right)
break;
// May be implemented in a derived class
pT->DrawItem(dcPaint, nItem, rcItem);
}
}
void DrawItem(CDCHandle dcPaint, int nItem, CRect & rcItem)
{
T * pT = static_cast<T *>(this);
CRect rcClip;
if (dcPaint.GetClipBox(rcClip) == ERROR)
return;
int nFocusItem = NULL_ITEM;
int nFocusSubItem = NULL_SUBITEM;
GetFocusItem(nFocusItem, nFocusSubItem);
BOOL bSelectedItem = IsSelected(nItem);
//BOOL bControlFocus = ( GetFocus() == m_hWnd || m_bEditItem );
// Draw selected background
if (bSelectedItem)
{
dcPaint.SetBkColor(m_rgbSelectedItem);
dcPaint.ExtTextOut(rcItem.left, rcItem.top, ETO_OPAQUE, rcItem, _T( "" ), 0, nullptr);
}
CRect rcSubItem(rcItem);
rcSubItem.right = rcSubItem.left;
for (int nSubItem = 0, nColumnCount = GetColumnCount(); nSubItem < nColumnCount; rcSubItem.left = rcSubItem.right + 1, nSubItem++)
{
CListColumn listColumn;
if (!GetColumn(nSubItem, listColumn))
break;
rcSubItem.right = rcSubItem.left + listColumn.m_nWidth - 1;
if (rcSubItem.right < rcClip.left || rcSubItem.Width() == 0)
continue;
if (rcSubItem.left > rcClip.right)
break;
LPCTSTR strItemText = pT->GetItemText(nItem, listColumn.m_nIndex);
int nItemImage = pT->GetItemImage(nItem, listColumn.m_nIndex);
UINT nItemFormat = pT->GetItemFormat(nItem, listColumn.m_nIndex);
UINT nItemFlags = pT->GetItemFlags(nItem, listColumn.m_nIndex);
// Custom draw subitem format
if (nItemFormat == ITEM_FORMAT_CUSTOM)
{
pT->DrawCustomItem(dcPaint, nItem, nSubItem, rcSubItem);
return;
}
BOOL bFocusSubItem = (m_bFocusSubItem && nFocusItem == nItem && nFocusSubItem == nSubItem);
COLORREF rgbBackground = m_rgbBackground;
COLORREF rgbText = m_rgbItemText;
if (bFocusSubItem)
{
dcPaint.SetBkColor(m_bEditItem ? m_rgbBackground : m_rgbItemFocus);
dcPaint.ExtTextOut(rcSubItem.left, rcSubItem.top, ETO_OPAQUE, rcSubItem, _T( "" ), 0, nullptr);
if (m_bEditItem)
{
CBrush bshSelectFrame;
bshSelectFrame.CreateSolidBrush(m_rgbItemFocus);
dcPaint.FrameRect(rcSubItem, bshSelectFrame);
}
}
else if (pT->GetItemColours(nItem, nSubItem, rgbBackground, rgbText) && rgbBackground != m_rgbBackground)
{
CPen penBorder;
penBorder.CreatePen(PS_SOLID, 1, rgbBackground);
CBrush bshInterior;
bshInterior.CreateSolidBrush(rgbBackground);
dcPaint.SelectPen(penBorder);
dcPaint.SelectBrush(bshInterior);
dcPaint.RoundRect(rcSubItem, CPoint(3, 3));
}
CRect rcItemText(rcSubItem);
// margin item text
//rcItemText.left += nSubItem == 0 ? 4 : 3;
//rcItemText.DeflateRect( 4, 0 );
// Draw subitem image if supplied
if (!m_ilItemImages.IsNull() && nItemImage != ITEM_IMAGE_NONE && (!m_bEditItem || (m_bEditItem && !bFocusSubItem)))
{
CSize sizeIcon;
m_ilItemImages.GetIconSize(sizeIcon);
CRect rcItemImage;
rcItemImage.left = (strItemText[0] == 0) ? ((rcItemText.left + rcItemText.right) / 2) - (sizeIcon.cx / 2) - (0) : rcItemText.left;
rcItemImage.right = min(rcItemImage.left + sizeIcon.cx, rcSubItem.right);
rcItemImage.top = ((rcSubItem.top + rcSubItem.bottom) / 2) - (sizeIcon.cy / 2);
rcItemImage.bottom = min(rcItemImage.top + sizeIcon.cy, rcSubItem.bottom);
m_ilItemImages.DrawEx(nItemImage, dcPaint, rcItemImage, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT);
// Offset item text (for image)
rcItemText.left += sizeIcon.cx + 4;
}
if (rcItemText.IsRectEmpty())
continue;
COLORREF rgbSelectedText = m_rgbSelectedText;
pT->GetItemSelectedColours(nItem, nSubItem, rgbSelectedText);
dcPaint.SelectFont(pT->GetItemFont(nItem, nSubItem));
dcPaint.SetTextColor((bSelectedItem && !bFocusSubItem) ? rgbSelectedText : rgbText);
dcPaint.SetBkMode(TRANSPARENT);
UINT nFormat = DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_END_ELLIPSIS;
if (nItemFlags & ITEM_FLAGS_CENTRE)
nFormat |= DT_CENTER;
else if (nItemFlags & ITEM_FLAGS_RIGHT)
nFormat |= DT_RIGHT;
else
nFormat |= DT_LEFT;
switch (nItemFormat)
{
case ITEM_FORMAT_DATETIME:
if (strItemText[0] != 0)
{
SYSTEMTIME stItemDate;
if (!GetItemDate(nItem, listColumn.m_nIndex, stItemDate))
break;
stdstr strItemDate;
if (nItemFlags & ITEM_FLAGS_DATE_ONLY)
strItemDate = FormatDate(stItemDate);
else if (nItemFlags & ITEM_FLAGS_TIME_ONLY)
strItemDate = FormatTime(stItemDate);
else
strItemDate = FormatDate(stItemDate) + _T( " " ) + FormatTime(stItemDate);
dcPaint.DrawText(strItemDate.c_str(), (int)strItemDate.length(), rcItemText, nFormat);
}
break;
case ITEM_FORMAT_CHECKBOX:
case ITEM_FORMAT_CHECKBOX_3STATE:
{
CSize sizeIcon;
m_ilListItems.GetIconSize(sizeIcon);
CRect rcCheckBox;
rcCheckBox.left = ((rcItemText.left + rcItemText.right) / 2) - (sizeIcon.cx / 2) - 1;
rcCheckBox.right = min(rcCheckBox.left + sizeIcon.cx, rcSubItem.right);
rcCheckBox.top = ((rcSubItem.top + rcSubItem.bottom) / 2) - (sizeIcon.cy / 2);
rcCheckBox.bottom = min(rcCheckBox.top + sizeIcon.cy, rcSubItem.bottom);
int nCheckValue = _ttoi(strItemText);
if (nItemFormat == ITEM_FORMAT_CHECKBOX)
m_ilListItems.DrawEx(nCheckValue > 0 ? ITEM_IMAGE_CHECK_ON : ITEM_IMAGE_CHECK_OFF, dcPaint, rcCheckBox, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT);
else
{
int nCheckImage = ITEM_IMAGE_3STATE_UNDEF;
if (nCheckValue < 0)
nCheckImage = ITEM_IMAGE_3STATE_OFF;
else if (nCheckValue > 0)
nCheckImage = ITEM_IMAGE_3STATE_ON;
m_ilListItems.DrawEx(nCheckImage, dcPaint, rcCheckBox, CLR_DEFAULT, CLR_DEFAULT, ILD_TRANSPARENT);
}
}
break;
case ITEM_FORMAT_PROGRESS:
{
CRect rcProgress(rcSubItem);
rcProgress.DeflateRect(3, 2);
// Draw progress border
DrawRoundRect(dcPaint, rcProgress, m_rgbHeaderShadow, m_rgbHeaderBackground);
// Fill progress bar area
rcProgress.DeflateRect(3, 3);
rcProgress.right = rcProgress.left + (int)((double)rcProgress.Width() * ((max(min(atof(strItemText), 100), 0)) / 100.0));
DrawGradient(dcPaint, rcProgress, m_rgbProgressTop, m_rgbProgressBottom);
}
break;
case ITEM_FORMAT_HYPERLINK:
if (nItem == m_nHotItem && nSubItem == m_nHotSubItem && !(nItemFlags & ITEM_FLAGS_READ_ONLY))
{
dcPaint.SelectFont(m_fntUnderlineFont);
dcPaint.SetTextColor(m_rgbHyperLink);
}
default: // Draw item text
{
size_t len = strlen(strItemText);
if (len > 0)
dcPaint.DrawText(strItemText, (int)len, rcItemText, nFormat);
}
break;
}
}
}
void DrawSelect(CDCHandle dcPaint)
{
if (!m_bGroupSelect)
return;
int nHorzScroll = GetScrollPos(SB_HORZ);
int nVertScroll = GetScrollPos(SB_VERT);
CRect rcGroupSelect(m_rcGroupSelect);
rcGroupSelect.OffsetRect(-nHorzScroll, -nVertScroll);
CRect rcClient;
GetClientRect(rcClient);
rcClient.top = (m_bShowHeader ? m_nHeaderHeight : 0);
// Limit box to list client area if scrolled to limits
if (nHorzScroll > (GetTotalWidth() - rcClient.Width()))
rcGroupSelect.right = min(rcClient.right, rcGroupSelect.right);
if (nHorzScroll == 0)
rcGroupSelect.left = max(rcClient.left, rcGroupSelect.left);
if (nVertScroll > (GetTotalHeight() - rcClient.Height()))
rcGroupSelect.bottom = min(rcClient.bottom, rcGroupSelect.bottom);
if (nVertScroll == 0)
rcGroupSelect.top = max(rcClient.top, rcGroupSelect.top);
// Limit bitmap to client area
CRect rcSelectArea(rcGroupSelect);
rcSelectArea.IntersectRect(rcSelectArea, rcClient);
CDC dcBackground;
dcBackground.CreateCompatibleDC(dcPaint);
int nBackgroundContext = dcBackground.SaveDC();
CBitmap bmpBackground;
bmpBackground.CreateCompatibleBitmap(dcPaint, rcSelectArea.Width(), rcSelectArea.Height());
dcBackground.SelectBitmap(bmpBackground);
// Take a copy of existing background
dcBackground.BitBlt(0, 0, rcSelectArea.Width(), rcSelectArea.Height(), dcPaint, rcSelectArea.left, rcSelectArea.top, SRCCOPY);
CDC dcGroupSelect;
dcGroupSelect.CreateCompatibleDC(dcPaint);
int nGroupSelectContext = dcGroupSelect.SaveDC();
CBitmap bmpGroupSelect;
bmpGroupSelect.CreateCompatibleBitmap(dcPaint, rcSelectArea.Width(), rcSelectArea.Height());
dcGroupSelect.SelectBitmap(bmpGroupSelect);
// Draw group select box
dcGroupSelect.SetBkColor(m_rgbItemFocus);
dcGroupSelect.ExtTextOut(0, 0, ETO_OPAQUE, CRect(CPoint(0), rcSelectArea.Size()), _T( "" ), 0, nullptr);
BLENDFUNCTION blendFunction;
blendFunction.BlendOp = AC_SRC_OVER;
blendFunction.BlendFlags = 0;
blendFunction.SourceConstantAlpha = 180;
blendFunction.AlphaFormat = 0;
// Blend existing background with selection box
dcGroupSelect.AlphaBlend(0, 0, rcSelectArea.Width(), rcSelectArea.Height(), dcBackground, 0, 0, rcSelectArea.Width(), rcSelectArea.Height(), blendFunction);
// Draw blended selection box
dcPaint.BitBlt(rcSelectArea.left, rcSelectArea.top, rcSelectArea.Width(), rcSelectArea.Height(), dcGroupSelect, 0, 0, SRCCOPY);
// Draw selection box frame
CBrush bshSelectFrame;
bshSelectFrame.CreateSolidBrush(m_rgbItemText);
dcPaint.FrameRect(rcGroupSelect, bshSelectFrame);
dcBackground.RestoreDC(nBackgroundContext);
dcGroupSelect.RestoreDC(nGroupSelectContext);
}
void DrawCustomItem(CDCHandle dcPaint, int /*nItem*/, int /*nSubItem*/, CRect & /*rcSubItem*/)
{
ATLASSERT(FALSE); // Must be implemented in a derived class
}
};
struct CSubItem
{
stdstr m_strText;
int m_nImage;
UINT m_nFormat;
UINT m_nFlags;
UINT m_nMaxEditLen;
CListArray<stdstr> m_aComboList;
HFONT m_hFont;
COLORREF m_rgbBackground;
COLORREF m_rgbText;
COLORREF m_rgbSelectedText;
};
template <class TData = DWORD>
struct CListItem
{
CListArray<CSubItem> m_aSubItems;
stdstr m_strToolTip;
TData m_tData;
};
template <class TData>
class CListCtrlData : public CListImpl<CListCtrlData<TData>>
{
public:
DECLARE_WND_CLASS(_T( "ListCtrl" ))
protected:
CListArray<CListItem<TData>> m_aItems;
public:
int AddItem(CListItem<TData> & listItem)
{
if (!m_aItems.Add(listItem))
return -1;
return CListImpl<CListCtrlData>::AddItem() ? GetItemCount() - 1 : -1;
}
int AddItemAt(CListItem<TData> & listItem, int Index)
{
if (Index < 0)
{
Index = 0;
}
if (Index > GetItemCount())
{
Index = GetItemCount();
}
if (!m_aItems.AddAt(listItem, Index))
return -1;
return CListImpl<CListCtrlData>::AddItem() ? Index : -1;
}
int AddItem(LPCTSTR lpszText, int nImage = ITEM_IMAGE_NONE, UINT nFormat = ITEM_FORMAT_NONE, UINT nFlags = ITEM_FLAGS_NONE)
{
CSubItem listSubItem;
listSubItem.m_nImage = ITEM_IMAGE_NONE;
listSubItem.m_nFormat = nFormat;
listSubItem.m_nFlags = ValidateFlags(nFlags);
listSubItem.m_hFont = nullptr;
listSubItem.m_rgbBackground = m_rgbBackground;
listSubItem.m_rgbText = m_rgbItemText;
listSubItem.m_rgbSelectedText = m_rgbSelectedText;
listSubItem.m_nMaxEditLen = -1;
CListItem<TData> listItem;
for (int nSubItem = 0; nSubItem < GetColumnCount(); nSubItem++)
listItem.m_aSubItems.Add(listSubItem);
// Set item details for first subitem
listItem.m_aSubItems[0].m_strText = lpszText;
listItem.m_aSubItems[0].m_nImage = nImage;
return AddItem(listItem);
}
int AddItemAt(int Index, LPCTSTR lpszText, int nImage = ITEM_IMAGE_NONE, UINT nFormat = ITEM_FORMAT_NONE, UINT nFlags = ITEM_FLAGS_NONE)
{
CSubItem listSubItem;
listSubItem.m_nImage = ITEM_IMAGE_NONE;
listSubItem.m_nFormat = nFormat;
listSubItem.m_nFlags = ValidateFlags(nFlags);
listSubItem.m_hFont = nullptr;
listSubItem.m_rgbBackground = m_rgbBackground;
listSubItem.m_rgbText = m_rgbItemText;
listSubItem.m_rgbSelectedText = m_rgbSelectedText;
listSubItem.m_nMaxEditLen = (UINT)-1;
CListItem<TData> listItem;
for (int nSubItem = 0; nSubItem < GetColumnCount(); nSubItem++)
listItem.m_aSubItems.Add(listSubItem);
// Set item details for first subitem
listItem.m_aSubItems[0].m_strText = lpszText;
listItem.m_aSubItems[0].m_nImage = nImage;
return AddItemAt(listItem, Index);
}
BOOL DeleteItem(int nItem)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
return m_aItems.RemoveAt(nItem) ? CListImpl<CListCtrlData>::DeleteItem(nItem) : FALSE;
}
BOOL DeleteAllItems()
{
m_aItems.RemoveAll();
return CListImpl<CListCtrlData>::DeleteAllItems();
}
int GetItemCount()
{
return m_aItems.GetSize();
}
BOOL GetItem(int nItem, CListItem<TData> & listItem)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
listItem = m_aItems[nItem];
return TRUE;
}
BOOL GetItem(int nItem, CListItem<TData> *& listItem)
{
if (nItem < 0 || nItem >= GetItemCount())
{
listItem = nullptr;
return FALSE;
}
listItem = &m_aItems[nItem];
return TRUE;
}
BOOL GetSubItem(int nItem, int nSubItem, CSubItem & listSubItem)
{
CListItem<TData> * listItem;
if (!GetItem(nItem, listItem))
return FALSE;
if (nSubItem < 0 || nSubItem >= (int)listItem->m_aSubItems.GetSize())
return FALSE;
listSubItem = listItem->m_aSubItems[nSubItem];
return TRUE;
}
BOOL GetSubItem(int nItem, int nSubItem, CSubItem *& listSubItem)
{
CListItem<TData> * listItem;
if (!GetItem(nItem, listItem))
{
listSubItem = nullptr;
return FALSE;
}
if (nSubItem < 0 || nSubItem >= (int)listItem->m_aSubItems.GetSize())
{
listSubItem = nullptr;
return FALSE;
}
listSubItem = &listItem->m_aSubItems[nSubItem];
return TRUE;
}
LPCTSTR GetItemText(int nItem, int nSubItem)
{
CSubItem * listSubItem;
return GetSubItem(nItem, nSubItem, listSubItem) ? listSubItem->m_strText.c_str() : _T( "" );
}
UINT GetItemMaxEditLen(int nItem, int nSubItem)
{
CSubItem * listSubItem;
return GetSubItem(nItem, nSubItem, listSubItem) ? listSubItem->m_nMaxEditLen : 0;
}
int GetItemImage(int nItem, int nSubItem)
{
CSubItem * listSubItem;
return GetSubItem(nItem, nSubItem, listSubItem) ? listSubItem->m_nImage : ITEM_IMAGE_NONE;
}
UINT GetItemFormat(int nItem, int nSubItem)
{
CSubItem * listSubItem;
if (!GetSubItem(nItem, nSubItem, listSubItem))
return FALSE;
return listSubItem->m_nFormat == ITEM_FORMAT_NONE ? GetColumnFormat(IndexToOrder(nSubItem)) : listSubItem->m_nFormat;
}
UINT GetItemFlags(int nItem, int nSubItem)
{
CSubItem * listSubItem;
if (!GetSubItem(nItem, nSubItem, listSubItem))
return FALSE;
return listSubItem->m_nFlags == ITEM_FLAGS_NONE ? GetColumnFlags(IndexToOrder(nSubItem)) : listSubItem->m_nFlags;
}
BOOL GetItemComboList(int nItem, int nSubItem, CListArray<stdstr> & aComboList)
{
CSubItem listSubItem;
if (!GetSubItem(nItem, nSubItem, listSubItem))
return FALSE;
aComboList = listSubItem.m_aComboList;
return aComboList.IsEmpty() ? GetColumnComboList(IndexToOrder(nSubItem), aComboList) : !aComboList.IsEmpty();
}
HFONT GetItemFont(int nItem, int nSubItem)
{
CSubItem * listSubItem;
if (!GetSubItem(nItem, nSubItem, listSubItem))
return FALSE;
return listSubItem->m_hFont == nullptr ? CListImpl<CListCtrlData>::GetItemFont(nItem, nSubItem) : listSubItem->m_hFont;
}
BOOL GetItemColours(int nItem, int nSubItem, COLORREF & rgbBackground, COLORREF & rgbText)
{
CSubItem * listSubItem;
if (!GetSubItem(nItem, nSubItem, listSubItem))
return FALSE;
rgbBackground = listSubItem->m_rgbBackground;
rgbText = listSubItem->m_rgbText;
return TRUE;
}
BOOL GetItemSelectedColours(int nItem, int nSubItem, COLORREF & rgbSelectedText)
{
CSubItem * listSubItem;
if (!GetSubItem(nItem, nSubItem, listSubItem))
return FALSE;
rgbSelectedText = listSubItem->m_rgbSelectedText;
return TRUE;
}
stdstr GetItemToolTip(int nItem, int /*nSubItem*/)
{
CListItem<TData> listItem;
return GetItem(nItem, listItem) ? listItem.m_strToolTip : _T( "" );
}
BOOL GetItemData(int nItem, TData & tData)
{
CListItem<TData> listItem;
if (!GetItem(nItem, listItem))
return FALSE;
tData = listItem.m_tData;
return TRUE;
}
BOOL SetItemText(int nItem, int nSubItem, LPCTSTR lpszText, bool bInvalidateItem = true)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
if (nSubItem < 0 || nSubItem >= (int)m_aItems[nItem].m_aSubItems.GetSize())
return FALSE;
m_aItems[nItem].m_aSubItems[nSubItem].m_strText = lpszText;
if (bInvalidateItem)
InvalidateItem(nItem, nSubItem);
return TRUE;
}
BOOL SetItemComboIndex(int nItem, int nSubItem, int nIndex)
{
CListArray<stdstr> aComboList;
if (!GetItemComboList(nItem, nSubItem, aComboList))
return FALSE;
return SetItemText(nItem, nSubItem, nIndex < 0 || nIndex >= aComboList.GetSize() ? _T( "" ) : aComboList[nIndex]);
}
BOOL SetItemImage(int nItem, int nSubItem, int nImage)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
if (nSubItem < 0 || nSubItem >= (int)m_aItems[nItem].m_aSubItems.GetSize())
return FALSE;
m_aItems[nItem].m_aSubItems[nSubItem].m_nImage = nImage;
return TRUE;
}
BOOL SetItemFormat(int nItem, int nSubItem, UINT nFormat, UINT nFlags = ITEM_FLAGS_NONE)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
if (nSubItem < 0 || nSubItem >= (int)m_aItems[nItem].m_aSubItems.GetSize())
return FALSE;
m_aItems[nItem].m_aSubItems[nSubItem].m_nFormat = nFormat;
m_aItems[nItem].m_aSubItems[nSubItem].m_nFlags = nFlags;
return TRUE;
}
BOOL SetItemFormat(int nItem, int nSubItem, UINT nFormat, UINT nFlags, CListArray<stdstr> & aComboList)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
if (nSubItem < 0 || nSubItem >= (int)m_aItems[nItem].m_aSubItems.GetSize())
return FALSE;
m_aItems[nItem].m_aSubItems[nSubItem].m_nFormat = nFormat;
m_aItems[nItem].m_aSubItems[nSubItem].m_nFlags = nFlags;
m_aItems[nItem].m_aSubItems[nSubItem].m_aComboList = aComboList;
return TRUE;
}
BOOL SetItemMaxEditLen(int nItem, int nSubItem, UINT nMaxEditLen)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
if (nSubItem < 0 || nSubItem >= (int)m_aItems[nItem].m_aSubItems.GetSize())
return FALSE;
m_aItems[nItem].m_aSubItems[nSubItem].m_nMaxEditLen = nMaxEditLen;
return TRUE;
}
BOOL SetItemFont(int nItem, int nSubItem, HFONT hFont)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
if (nSubItem < 0 || nSubItem >= (int)m_aItems[nItem].m_aSubItems.GetSize())
return FALSE;
m_aItems[nItem].m_aSubItems[nSubItem].m_hFont = hFont;
return TRUE;
}
BOOL SetItemColours(int nItem, int nSubItem, COLORREF rgbBackground, COLORREF rgbText)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
if (nSubItem < 0 || nSubItem >= (int)m_aItems[nItem].m_aSubItems.GetSize())
return FALSE;
m_aItems[nItem].m_aSubItems[nSubItem].m_rgbBackground = rgbBackground;
m_aItems[nItem].m_aSubItems[nSubItem].m_rgbText = rgbText;
return TRUE;
}
BOOL SetItemHighlightColours(int nItem, int nSubItem, COLORREF rgbSelectedText)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
if (nSubItem < 0 || nSubItem >= (int)m_aItems[nItem].m_aSubItems.GetSize())
return FALSE;
m_aItems[nItem].m_aSubItems[nSubItem].m_rgbSelectedText = rgbSelectedText;
return TRUE;
}
void ReverseItems()
{
m_aItems.Reverse();
}
class CompareItem
{
public:
CompareItem(int nColumn) :
m_nColumn(nColumn)
{
}
inline bool operator()(const CListItem<TData> & listItem1, const CListItem<TData> & listItem2)
{
return (_tcscmp(listItem1.m_aSubItems[m_nColumn].m_strText.c_str(), listItem2.m_aSubItems[m_nColumn].m_strText.c_str()) < 0);
}
protected:
int m_nColumn;
};
void SortItems(int nColumn, BOOL /*bAscending*/)
{
m_aItems.Sort(CompareItem(nColumn));
}
BOOL SetItemToolTip(int nItem, LPCTSTR lpszToolTip)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
m_aItems[nItem].m_strToolTip = lpszToolTip;
return TRUE;
}
BOOL SetItemData(int nItem, TData & tData)
{
if (nItem < 0 || nItem >= GetItemCount())
return FALSE;
m_aItems[nItem].m_tData = tData;
return TRUE;
}
};
typedef CListCtrlData<DWORD> CListCtrl;
Reference in New Issue View Git Blame Copy Permalink