void CSearchDialog::UpdateListViewHeader()
{
HWND hHeader = ListView_GetHeader(GetDlgItem(m_hDlg,IDC_LISTVIEW_SEARCHRESULTS));
HDITEM hdItem;
/* Remove the sort arrow from the column that was
previously selected. */
if(m_iPreviousSelectedColumn != -1)
{
hdItem.mask = HDI_FORMAT;
Header_GetItem(hHeader,m_iPreviousSelectedColumn,&hdItem);
if(hdItem.fmt & HDF_SORTUP)
{
hdItem.fmt &= ~HDF_SORTUP;
}
else if(hdItem.fmt & HDF_SORTDOWN)
{
hdItem.fmt &= ~HDF_SORTDOWN;
}
Header_SetItem(hHeader,m_iPreviousSelectedColumn,&hdItem);
}
int iColumn = 0;
for each(auto ci in m_sdps->m_Columns)
{
if(ci.SortMode == m_sdps->m_SortMode)
{
break;
}
iColumn++;
}
hdItem.mask = HDI_FORMAT;
Header_GetItem(hHeader,iColumn,&hdItem);
if(m_sdps->m_bSortAscending)
{
hdItem.fmt |= HDF_SORTUP;
}
else
{
hdItem.fmt |= HDF_SORTDOWN;
}
Header_SetItem(hHeader,iColumn,&hdItem);
m_iPreviousSelectedColumn = iColumn;
}
void CSysLogQuery::SetHeaderCheckbox(void)
{
BOOL fChecked = TRUE;
for(int nItem = 0;nItem < ListView_GetItemCount(m_Syslog_query);nItem++)
{
if(!ListView_GetCheckState(m_Syslog_query,nItem))
{
fChecked = FALSE;
break;
}
}
HWND header = ListView_GetHeader(m_Syslog_query);
HDITEM hdi = {0};
hdi.mask = HDI_FORMAT;
Header_GetItem(header,0,&hdi);
if (fChecked)
{
hdi.fmt |= HDF_CHECKED;
} else
{
hdi.fmt &= ~HDF_CHECKED;
}
Header_SetItem(header, 0, &hdi);
}
void playlist_view::g_remove_sort()
{
bool b_sorted;
unsigned idx;
b_sorted = g_cache.active_get_playlist_sort(idx);
if (b_sorted)
{
unsigned n, pcount = playlist_view::list_playlist.get_count();
for (n=0; n<pcount; n++)
{
playlist_view * p_playlist = playlist_view::list_playlist.get_item(n);
if (p_playlist->wnd_header)
{
HDITEM hdi;
memset(&hdi, 0, sizeof(hdi));
hdi.mask = HDI_FORMAT;
Header_GetItem(p_playlist->wnd_header, idx, &hdi);
/* FIX */
if (hdi.fmt & HDF_IMAGE) hdi.fmt ^= HDF_IMAGE;
if (hdi.fmt & HDF_BITMAP_ON_RIGHT) hdi.fmt ^= HDF_BITMAP_ON_RIGHT;
if (hdi.fmt & 0x0200) hdi.fmt ^= 0x0200;
if (hdi.fmt & 0x0400) hdi.fmt ^= 0x0400;
// hdi.fmt ^= HDF_IMAGE|HDF_BITMAP_ON_RIGHT|0x0200|0x0400;
Header_SetItem(p_playlist->wnd_header, idx, &hdi);
}
}
}
}
//***********************************************************************
// apparently this only works for ComCtl version 6.0.0.0
// I would have to use a Manifest to specify that.
// Linking a manifest requires adding a line to resource file:
// CREATEPROCESS_MANIFEST_RESOURCE_ID RT_MANIFEST "filename.manifest"
//***********************************************************************
// http://www.gamedev.net/topic/569020-set-list-view-header-sort-arrow-c-win32/
BOOL CVListView::SetHeaderSortImage(int columnIndex, SHOW_ARROW showArrow)
{
HDITEM hdrItem = { 0 };
HWND hHeader = ListView_GetHeader(hwndVListView);
if (hHeader) {
hdrItem.mask = HDI_FORMAT;
if ( Header_GetItem(hHeader, columnIndex, &hdrItem) ) {
if (showArrow == SHOW_UP_ARROW) {
hdrItem.fmt = (hdrItem.fmt & ~HDF_SORTDOWN) | HDF_SORTUP;
} else
if (showArrow == SHOW_DOWN_ARROW) {
hdrItem.fmt = (hdrItem.fmt & ~HDF_SORTUP) | HDF_SORTDOWN;
} else
{
hdrItem.fmt = hdrItem.fmt & ~(HDF_SORTDOWN | HDF_SORTUP);
}
return Header_SetItem(hHeader, columnIndex, &hdrItem);
}
}
return FALSE;
};
LRESULT
CpuFuncOnColumnClick(
__in PDIALOG_OBJECT Object,
__in NMLISTVIEW *lpNmlv
)
{
HWND hWndHeader;
int nColumnCount;
int i;
HDITEM hdi;
LISTVIEW_OBJECT *ListView;
PCPU_FORM_CONTEXT Context;
HWND hWndCtrl;
HWND hWnd;
Context = SdkGetContext(Object, CPU_FORM_CONTEXT);
ListView = Context->ListView;
if (ListView->SortOrder == SortOrderNone){
return 0;
}
if (ListView->LastClickedColumn == lpNmlv->iSubItem) {
ListView->SortOrder = (LIST_SORT_ORDER)!ListView->SortOrder;
} else {
ListView->SortOrder = SortOrderAscendent;
}
hWnd = Object->hWnd;
hWndCtrl = GetDlgItem(hWnd, IDC_LIST_FUNCTION);
hWndHeader = ListView_GetHeader(hWndCtrl);
ASSERT(hWndHeader);
nColumnCount = Header_GetItemCount(hWndHeader);
for (i = 0; i < nColumnCount; i++) {
hdi.mask = HDI_FORMAT;
Header_GetItem(hWndHeader, i, &hdi);
if (i == lpNmlv->iSubItem) {
hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
if (ListView->SortOrder == SortOrderAscendent){
hdi.fmt |= HDF_SORTUP;
} else {
hdi.fmt |= HDF_SORTDOWN;
}
} else {
hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
}
Header_SetItem(hWndHeader, i, &hdi);
}
ListView->LastClickedColumn = lpNmlv->iSubItem;
ListView_SortItemsEx(hWndCtrl, CpuFuncSortCallback, (LPARAM)hWnd);
return 0L;
}
void LoadColumnSizes(HWND hwndResults, const char *szProto)
{
HDITEM hdi;
int columnOrder[NUM_COLUMNID];
int columnCount;
char szSetting[32];
int i;
FindAddDlgData *dat;
bool colOrdersValid;
defaultColumnSizes[COLUMNID_PROTO] = GetSystemMetrics(SM_CXSMICON) + 4;
dat = (FindAddDlgData*)GetWindowLongPtr(GetParent(hwndResults), GWLP_USERDATA);
columnCount = NUM_COLUMNID;
colOrdersValid = true;
for (i=0; i < NUM_COLUMNID; i++)
{
LVCOLUMN lvc;
if (i < columnCount)
{
int bNeedsFree = FALSE;
lvc.mask = LVCF_TEXT | LVCF_WIDTH;
if (szColumnNames[i] != NULL)
lvc.pszText = TranslateTS(szColumnNames[i]);
else if (i == COLUMNID_HANDLE)
{
if (szProto)
{
bNeedsFree = TRUE;
lvc.pszText = mir_a2t((char*)CallProtoServiceInt(NULL,szProto, PS_GETCAPS, PFLAG_UNIQUEIDTEXT, 0));
}
else
lvc.pszText = _T("ID");
}
else lvc.mask &= ~LVCF_TEXT;
mir_snprintf(szSetting, SIZEOF(szSetting), "ColWidth%d", i);
lvc.cx = db_get_w(NULL, "FindAdd", szSetting, defaultColumnSizes[i]);
ListView_InsertColumn(hwndResults, i, (LPARAM)&lvc);
if (bNeedsFree)
mir_free(lvc.pszText);
}
mir_snprintf(szSetting, SIZEOF(szSetting), "ColOrder%d", i);
columnOrder[i] = db_get_b(NULL, "FindAdd", szSetting, -1);
if (columnOrder[i] == -1 || columnOrder[i] >= NUM_COLUMNID) colOrdersValid = false;
}
if (colOrdersValid)
ListView_SetColumnOrderArray(hwndResults, columnCount, columnOrder);
dat->iLastColumnSortIndex = db_get_b(NULL, "FindAdd", "SortColumn", COLUMNID_NICK);
if (dat->iLastColumnSortIndex >= columnCount) dat->iLastColumnSortIndex = COLUMNID_NICK;
dat->bSortAscending = db_get_b(NULL, "FindAdd", "SortAscending", TRUE);
hdi.mask = HDI_FORMAT;
hdi.fmt = HDF_LEFT | HDF_STRING | (dat->bSortAscending ? HDF_SORTDOWN : HDF_SORTUP);
Header_SetItem(ListView_GetHeader(hwndResults), dat->iLastColumnSortIndex, &hdi);
}
void ColumnResize (TLWndData* pWD, HD_NOTIFY* hdn) {
TLColumnItem* pci;
int i, scx, left;
HD_ITEM hdi;
RECT rcInval;
if (hdn->iButton == 0) {
rcInval = pWD->tlInval;
left = pWD->iFirstColumnWidth;
if (hdn->iItem == 0) {
scx = hdn->pitem->cxy - pWD->iFirstColumnWidth;
pWD->iFirstColumnWidth = hdn->pitem->cxy;
rcInval.right = pWD->iFirstColumnWidth + scx +1;
if (scx < 0) rcInval.left = rcInval.right - 24;
else rcInval.left = pWD->iFirstColumnWidth - 24;
}
else {
pci = pWD->columnItem;
left += pci->cx;
rcInval.left = pWD->iFirstColumnWidth;
for (i=1; i<hdn->iItem; i++) {
rcInval.left += pci->cx;
pci = pci->nextItem;
left += pci->cx;
}
scx = hdn->pitem->cxy - pci->cx;
pci->cx = hdn->pitem->cxy;
if (pci->cx >= BITMAPWIDTH)
pci->cxImageOffset = (pci->cx - BITMAPWIDTH) / 2;
else
pci->cxImageOffset = 0;
rcInval.right = left + scx +1;
}
pci = pWD->columnItem;
pWD->iTotalWidth = pWD->iFirstColumnWidth;
for (i=1; i<pWD->iNumberColumns; i++) {
pWD->iTotalWidth += pci->cx;
pci = pci->nextItem;
}
hdi.mask = HDI_WIDTH;
hdi.cxy = hdn->pitem->cxy;
Header_SetItem (pWD->hWndHeader, hdn->iItem, &hdi);
rcInval.left -= pWD->iHorizontalPos;
rcInval.right -= pWD->iHorizontalPos;
InvalidateRect (pWD->hWnd, &pWD->tlInval, FALSE);
if ((scx < 0) && (pWD->iHorizontalPos > 0)) {
i = pWD->iHorizontalPos + scx;
if (i < 0) i = 0;
SendMessage (pWD->hWnd, WM_HSCROLL,
MAKEWPARAM (SB_THUMBPOSITION, i), 0);
InvalidateRect (pWD->hWnd, &pWD->tlInval, TRUE);
}
}
}
BOOL
ListView_SortEx(HWND hListView,
int iSortingColumn,
int iSortedColumn)
{
HWND hHeader;
HDITEM hColumn;
BOOL bSortAsc;
Sort sort;
if ((GetWindowLongPtr(hListView, GWL_STYLE) & ~LVS_NOSORTHEADER) == 0)
return TRUE;
hHeader = ListView_GetHeader(hListView);
SecureZeroMemory(&hColumn, sizeof(hColumn));
if ( (iSortedColumn != -1) && (iSortedColumn != iSortingColumn) )
{
hColumn.mask = HDI_FORMAT | HDI_LPARAM;
Header_GetItem(hHeader, iSortedColumn, &hColumn);
hColumn.fmt &= ~HDF_SORTUP & ~HDF_SORTDOWN;
hColumn.lParam = 0; // 0: deactivated, 1: false, 2: true.
Header_SetItem(hHeader, iSortedColumn, &hColumn);
}
hColumn.mask = HDI_FORMAT | HDI_LPARAM;
Header_GetItem(hHeader, iSortingColumn, &hColumn);
bSortAsc = !(hColumn.lParam == 2); // 0: deactivated, 1: false, 2: true.
hColumn.fmt &= (bSortAsc ? ~HDF_SORTDOWN : ~HDF_SORTUP );
hColumn.fmt |= (bSortAsc ? HDF_SORTUP : HDF_SORTDOWN);
hColumn.lParam = (LPARAM)(bSortAsc ? 2 : 1);
Header_SetItem(hHeader, iSortingColumn, &hColumn);
/* Sort the list */
sort.bSortAsc = bSortAsc;
sort.hList = hListView;
sort.nClickedColumn = iSortingColumn;
return ListView_SortItemsEx(hListView, SortListView, (LPARAM)&sort);
}
// put the arrow on the new sort column
static void Picker_ResetHeaderSortIcon(HWND hwndPicker)
{
struct PickerInfo *pPickerInfo;
HWND hwndHeader;
HD_ITEM hdi;
int i = 0, nViewColumn = 0;
BOOL res = 0;
pPickerInfo = GetPickerInfo(hwndPicker);
hwndHeader = ListView_GetHeader(hwndPicker);
// take arrow off non-current columns
hdi.mask = HDI_FORMAT;
hdi.fmt = HDF_STRING;
for (i = 0; i < pPickerInfo->nColumnCount; i++)
{
if (i != pPickerInfo->pCallbacks->pfnGetSortColumn())
res = Header_SetItem(hwndHeader, Picker_GetViewColumnFromRealColumn(hwndPicker, i), &hdi);
}
if (GetUseXPControl())
{
// use built in sort arrows
hdi.mask = HDI_FORMAT;
hdi.fmt = HDF_STRING | (pPickerInfo->pCallbacks->pfnGetSortReverse() ? HDF_SORTDOWN : HDF_SORTUP);
}
else
{
// put our arrow icon next to the text
hdi.mask = HDI_FORMAT | HDI_IMAGE;
hdi.fmt = HDF_STRING | HDF_IMAGE | HDF_BITMAP_ON_RIGHT;
hdi.iImage = pPickerInfo->pCallbacks->pfnGetSortReverse() ? 1 : 0;
}
nViewColumn = Picker_GetViewColumnFromRealColumn(hwndPicker, pPickerInfo->pCallbacks->pfnGetSortColumn());
res = Header_SetItem(hwndHeader, nViewColumn, &hdi);
res++;
}
LRESULT
TreeListOnItemClick(
__in PTREELIST_OBJECT Object,
__in LPNMHDR lp
)
{
LPNMHEADER phdn;
ULONG ColumnCount;
ULONG Current, i;
HDITEM hdi = {0};
if (!Object->hWndSort) {
return 0;
}
phdn = (LPNMHEADER)lp;
Current = phdn->iItem;
if (Object->LastClickedColumn == Current) {
Object->SortOrder = (LIST_SORT_ORDER)!Object->SortOrder;
} else {
Object->SortOrder = SortOrderAscendent;
}
ColumnCount = Header_GetItemCount(Object->hWndHeader);
for (i = 0; i < ColumnCount; i++) {
hdi.mask = HDI_FORMAT;
Header_GetItem(Object->hWndHeader, i, &hdi);
hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
if (i == Current) {
if (Object->SortOrder == SortOrderAscendent){
hdi.fmt |= HDF_SORTUP;
} else {
hdi.fmt |= HDF_SORTDOWN;
}
}
Header_SetItem(Object->hWndHeader, i, &hdi);
}
Object->LastClickedColumn = Current;
PostMessage(Object->hWndSort, WM_TREELIST_SORT, (WPARAM)Current, 0);
return 0;
}
void ListView::sort(int columnIndex, PFNLVCOMPARE compareItem)
{
// Update parameters of sorting.
int oldSortColumnIndex = m_sortColumnIndex;
m_sortColumnIndex = columnIndex;
// make decision about order
// positive value of m_sortAscending for ascending order
// negative value of m_sortAscending for descending order
if (oldSortColumnIndex == m_sortColumnIndex) {
m_sortAscending = !m_sortAscending;
} else {
m_sortAscending = true;
}
m_compareItem = compareItem;
// Update arrow in header.
HWND hHeader = ListView_GetHeader(m_hwnd);
if (hHeader != 0) {
HDITEM hdrItem = { 0 };
hdrItem.mask = HDI_FORMAT;
// delete all header icons
if (Header_GetItem(hHeader, oldSortColumnIndex, &hdrItem)) {
hdrItem.fmt = hdrItem.fmt & ~HDF_SORTUP & ~HDF_SORTDOWN;
Header_SetItem(hHeader, oldSortColumnIndex, &hdrItem);
}
// add necessary header icon
if (Header_GetItem(hHeader, m_sortColumnIndex, &hdrItem)) {
hdrItem.fmt = hdrItem.fmt | (m_sortAscending ? HDF_SORTUP : HDF_SORTDOWN);
Header_SetItem(hHeader, m_sortColumnIndex, &hdrItem);
}
}
// Sort list of item.
sort();
}
// CSysLogQuery 消息处理程序
BOOL CSysLogQuery::OnInitDialog()
{
CDialogEx::OnInitDialog();
// TODO: 在此添加额外的初始
CRect rect;
m_Syslog_query.GetClientRect(&rect);
m_Syslog_query.SetExtendedStyle(m_Syslog_query.GetExtendedStyle() | LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_CHECKBOXES );
CImageList img_list;
img_list.Create(1,25,ILC_COLORDDB | ILC_MASK,0,0);
m_Syslog_query.SetImageList(&img_list,LVSIL_SMALL);
m_Syslog_query.InsertColumn(0,NULL,LVCFMT_CENTER,40); //添加列标题
m_Syslog_query.InsertColumn(1, _T("操作时间"), LVCFMT_CENTER,(rect.Width()-40)/3-90, 1);
m_Syslog_query.InsertColumn(2, _T("主机名"), LVCFMT_CENTER, (rect.Width()-40)/3-100, 2);
m_Syslog_query.InsertColumn(3, _T("消息内容"), LVCFMT_CENTER, (rect.Width()-40)/3+180, 3);
//m_Syslog_query.InsertColumn(4, _T("消息内容"), LVCFMT_CENTER, (rect.Width()-40)/4+150, 4);
HWND header = ListView_GetHeader(m_Syslog_query);
DWORD dwHeaderStyle = ::GetWindowLong(header, GWL_STYLE);
dwHeaderStyle |= HDS_CHECKBOXES;
::SetWindowLong(header, GWL_STYLE, dwHeaderStyle);
// Store the ID of the header control so we can handle its notification by ID
int m_HeaderId = ::GetDlgCtrlID(header);
// Now, we can update the format for the first header item,
// which corresponds to the first column
HDITEM hdi = { 0 };
hdi.mask = HDI_FORMAT;
Header_GetItem(header, 0, &hdi);
hdi.fmt |= HDF_CHECKBOX | HDF_FIXEDWIDTH;
Header_SetItem(header, 0, &hdi);
isCheckbox_log = FALSE;
memset(check_log,0,256);
i_checked_log = 0;
page = 1;
current_page = 0;
return TRUE; // return TRUE unless you set the focus to a control
// 异常: OCX 属性页应返回 FALSE
}
// Set the UP / DOWN arrow image when a column header is clicked in the Favorite Games List
void ListView_SetHeaderSortImage(HWND hLView, int nColIndex, bool bListViewAscending)
{
HWND hListViewHeader = ListView_GetHeader(hLView);
BOOL isCommonControlVersion6 = IsCommCtrlVersion6();
int nColCount = Header_GetItemCount(hListViewHeader);
for (int nIndex = 0; nIndex < nColCount; nIndex++)
{
HDITEM hi;
// I only need to retrieve the format if i'm on windows xp. If not, then i need to retrieve the bitmap also.
hi.mask = HDI_FORMAT | (isCommonControlVersion6 ? 0 : HDI_BITMAP);
Header_GetItem(hListViewHeader, nIndex, &hi);
// Set sort image to this column
if(nIndex == nColIndex)
{
// Windows xp has a easier way to show the sort order in the header: i just have to set a flag and windows will do the drawing. No windows xp, no easy way.
if (isCommonControlVersion6) {
hi.fmt &= ~(HDF_SORTDOWN|HDF_SORTUP);
hi.fmt |= bListViewAscending ? HDF_SORTUP : HDF_SORTDOWN;
} else {
UINT bitmapID = bListViewAscending ? IDB_UPARROW : IDB_DOWNARROW;
// If there's a bitmap, let's delete it.
if (hi.hbm) DeleteObject(hi.hbm);
hi.fmt |= HDF_BITMAP|HDF_BITMAP_ON_RIGHT;
hi.hbm = (HBITMAP)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(bitmapID), IMAGE_BITMAP, 0,0, LR_LOADMAP3DCOLORS);
}
} else {
// Remove sort image (if exists) from other columns.
if (isCommonControlVersion6) {
hi.fmt &= ~(HDF_SORTDOWN|HDF_SORTUP);
} else {
// If there's a bitmap, let's delete it.
if (hi.hbm) DeleteObject(hi.hbm);
// Remove flags that tell windows to look for a bitmap.
hi.mask &= ~HDI_BITMAP;
hi.fmt &= ~(HDF_BITMAP|HDF_BITMAP_ON_RIGHT);
}
}
Header_SetItem(hListViewHeader, nIndex, &hi);
}
}
void playlist_view::g_update_sort()
{
if (cfg_show_sort_arrows)
{
unsigned column;
bool descending;
bool b_sorted = g_cache.active_get_playlist_sort(column, &descending);
if (b_sorted)
{
unsigned n, pcount = list_playlist.get_count();
for (n=0; n<pcount; n++)
{
playlist_view * p_playlist = playlist_view::list_playlist.get_item(n);
if (p_playlist->wnd_header)
{
HDITEM hdi;
memset(&hdi, 0, sizeof(hdi));
hdi.mask = HDI_FORMAT;
Header_GetItem(p_playlist->wnd_header, column, &hdi);
if (mmh::osversion::is_windows_xp_or_newer())
hdi.fmt |= HDF_STRING | (descending ? 0x0200 : 0x0400);
else
{
if (!g_imagelist) create_image_list();
if (!Header_GetImageList(p_playlist->wnd_header))
Header_SetImageList(p_playlist->wnd_header, g_imagelist);
hdi.mask |= HDI_IMAGE;
hdi.fmt |= HDF_STRING|HDF_IMAGE|( (hdi.fmt & HDF_RIGHT ) ? 0 : HDF_BITMAP_ON_RIGHT);
if (descending)
{
hdi.iImage = 0;
}
else
{
hdi.iImage = 1;
}
}
Header_SetItem(p_playlist->wnd_header, column, &hdi);
}
}
}
}
}
LRESULT
TreeListOnDividerDbclk(
__in PTREELIST_OBJECT Object,
__in LPNMHDR lp
)
{
LPNMHEADER phdn;
LONG x;
HDITEM Item = {0};
int Length;
SIZE Size;
HDC hdc;
int cxEdge;
int cxIcon;
phdn = (LPNMHEADER)lp;
cxEdge = GetSystemMetrics(SM_CXEDGE);
cxIcon = GetSystemMetrics(SM_CXSMICON);
if (phdn->iItem == 0) {
TreeListGetTreeRectMostRight(Object, &x);
}
else {
TreeListGetColumnTextExtent(Object, phdn->iItem, &x);
//
// Compute header's text extent length
//
hdc = GetDC(Object->hWndTree);
Length = (int)wcslen(Object->Column[phdn->iItem].Name);
GetTextExtentPoint32(hdc, Object->Column[phdn->iItem].Name, (int)Length, &Size);
x = max(x, Size.cx + cxEdge * 2 + cxIcon);
ReleaseDC(Object->hWndTree, hdc);
}
Item.mask = HDI_ORDER | HDI_WIDTH;
Item.iOrder = phdn->iItem;
Item.cxy = x;
Header_SetItem(Object->hWndHeader, phdn->iItem, &Item);
PostMessage(Object->hWnd, WM_SIZE, 0, 0);
return 0;
}
//*****************************************************************************
void CVListView::set_header_text(uint idx, char *msg)
{
HWND hwndHeader = ListView_GetHeader(hwndVListView);
if (hwndHeader) {
HDITEM item;
item.mask = HDI_TEXT ;
#ifdef UNICODE
item.pszText = ascii2unicode(msg) ;
item.cchTextMax = _tcslen(item.pszText) ;
#else
item.pszText = msg ;
item.cchTextMax = strlen(msg) ;
#endif
item.fmt = HDF_STRING | HDF_CENTER ;
Header_SetItem(hwndHeader, idx, &item); //lint !e522
} else { //lint !e550 Symbol 'item' (line 753) not accessed
syslog("ListView_GetHeader: %s\n", get_system_message()) ;
}
}
/**
* @param hwndList - list view control.
* @param iImage - image index.
*/
void CListViewOrder::SetSortImage(HWND hwndList, int iImage)
{
_ASSERTE(m_iColumnNumber >= 0);
HWND hwndHeader = ListView_GetHeader(hwndList);
HDITEM hdi;
ZeroMemory(&hdi, sizeof(hdi));
if (iImage >= 0)
{
hdi.mask = HDI_FORMAT | HDI_IMAGE;
hdi.iImage = iImage;
hdi.fmt = HDF_LEFT | HDF_STRING | HDF_IMAGE;
}
else
{
hdi.mask = HDI_FORMAT;
hdi.fmt = HDF_LEFT | HDF_STRING;
}
Header_SetItem(hwndHeader, m_iColumnNumber, &hdi);
}
/**
* Visually indicates the sort order of a header control item.
*
* \param hwnd A handle to the header control.
* \param Index The index of the item.
* \param Order The sort order of the item.
*/
VOID PhSetHeaderSortIcon(
_In_ HWND hwnd,
_In_ INT Index,
_In_ PH_SORT_ORDER Order
)
{
ULONG count;
ULONG i;
count = Header_GetItemCount(hwnd);
if (count == -1)
return;
for (i = 0; i < count; i++)
{
HDITEM item;
item.mask = HDI_FORMAT;
Header_GetItem(hwnd, i, &item);
if (Order != NoSortOrder && i == Index)
{
if (Order == AscendingSortOrder)
{
item.fmt &= ~HDF_SORTDOWN;
item.fmt |= HDF_SORTUP;
}
else if (Order == DescendingSortOrder)
{
item.fmt &= ~HDF_SORTUP;
item.fmt |= HDF_SORTDOWN;
}
}
else
{
item.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
}
Header_SetItem(hwnd, i, &item);
}
}
VOID TreeListAutoExpand(
HWND hwndHeader,
LPNMTREEVIEW nhdr
)
{
RECT irc;
LONG cx = 0, xleft = 0;
HDITEM hdi;
HTREEITEM citem = TreeView_GetChild(nhdr->hdr.hwndFrom, nhdr->itemNew.hItem);
RtlSecureZeroMemory(&irc, sizeof(irc));
TreeView_GetItemRect(nhdr->hdr.hwndFrom, citem, &irc, TRUE);
xleft = irc.left;
while (citem) {
RtlSecureZeroMemory(&irc, sizeof(irc));
TreeView_GetItemRect(nhdr->hdr.hwndFrom, citem, &irc, TRUE);
if (irc.left < xleft)
break;
if (irc.right > cx)
cx = irc.right;
citem = TreeView_GetNextVisible(nhdr->hdr.hwndFrom, citem);
}
RtlSecureZeroMemory(&hdi, sizeof(hdi));
hdi.mask = HDI_WIDTH;
Header_GetItem(hwndHeader, 0, &hdi);
if (hdi.cxy < cx + 8)
hdi.cxy = cx + 8;
Header_SetItem(hwndHeader, 0, &hdi);
}
void lvAddHeaderCheckbox(HWND lvTarget) {
HWND header;
DWORD dwHeaderStyle;
INT iIndex;
iIndex=LVFind(LV_FINDHWND,lvTarget); if (iIndex<0) ehError();
header = ListView_GetHeader(lvTarget);
dwHeaderStyle = GetWindowLong(header, GWL_STYLE);
dwHeaderStyle |= HDS_CHECKBOXES;
SetWindowLong(header, GWL_STYLE, dwHeaderStyle);
{
// Now, we can update the format for the first header item,
// which corresponds to the first column
HDITEM hdi = { 0 };
hdi.mask = HDI_FORMAT;
Header_GetItem(header, 0, &hdi);
hdi.fmt |= HDF_CHECKBOX | HDF_FIXEDWIDTH;
Header_SetItem(header, 0, &hdi);
}
//_arsLv[iIndex].hWndHeader=ListView_GetHeader(lvTarget);//GetWindow(objCalled->hWnd, GW_CHILD);
//_arsLv[iIndex].idHeader=GetDlgCtrlID(_arsLv[iIndex].hWndHeader);
}
void DoSetRepStuff(HWND hwnd, LPINSERTITEM pfr)
{
HD_ITEM hi;
int ret;
HD_ITEM di = {
HDI_WIDTH,
50,
NULL,
NULL,
128,
HDF_CENTER|HDF_BITMAP,
0
};
HD_ITEM FAR* pitem;
HGLOBAL hglb;
int iAlloc;
hi.pszText="One";
hi.mask = pfr->mask;
hi.cxy = pfr->cxy;
if (pfr->Nullpitem)
pitem = NULL;
else
pitem = &hi;
hi.cchTextMax = pfr->cchTextMax;
hi.fmt = pfr->fmt;
hi.lParam = pfr->lParam;
if (hi.cchTextMax)
iAlloc = hi.cchTextMax;
else
iAlloc = MAX_PSZTEXT;
if (pfr->Nullhbm)
hi.hbm = NULL;
else
hi.hbm = pfr->hbm;
if (pfr->NullpszText)
hi.pszText = NULL; // can this be done ??
else {
hglb = GlobalAlloc(GPTR, iAlloc);
hi.pszText = GlobalLock(hglb);
#ifdef WIN32
strcpy(hi.pszText, pfr->pszText);
#else
_fstrcpy(hi.pszText, pfr->pszText);
#endif
}
di.pszText = "Four";
if (pfr->NullHwd)
ret = Header_SetItem(NULL, pfr->index, pitem);
else
ret = Header_SetItem(pfr->hwnd, pfr->index, pitem);
wsprintf(szDbgMsg, "%d = Header_SetItem(index = %d, \n\
mask = %x cxy = %d pszText = %s hbm = %lx cchTextMax = %d fmt = %x\n \
lParam = %ld )", ret, pfr->index, hi.mask, hi.cxy, hi.pszText, hi.hbm, hi.cchTextMax,
hi.fmt, hi.lParam);
MyDebugMsg(DM_TRACE, "%s", (LPCSTR) szDbgMsg);
SetDlgItemInt(hwnd, IDC_INSERTRET, ret, TRUE) ;
if (!pfr->NullpszText) {
GlobalUnlock(hglb);
GlobalFree(hglb);
}
/****
wsprintf(szTemp, szLongFilter, hwndFind) ;
SetDlgItemText(hwnd, ID_INSERTRET, szTemp) ;
**/
}
LRESULT
FilterOnColumnClick(
IN HWND hWnd,
IN NMLISTVIEW *lpNmlv
)
{
HWND hWndList;
HWND hWndHeader;
int ColumnCount;
int i;
HDITEM hdi;
LISTVIEW_OBJECT *Object;
PDIALOG_OBJECT Dialog;
PFILTER_CONTEXT Context;
Dialog = (PDIALOG_OBJECT)SdkGetObject(hWnd);
Context = SdkGetContext(Dialog, FILTER_CONTEXT);
Object = Context->ListObject;
ASSERT(Object != NULL);
if (Object->SortOrder == SortOrderNone){
return 0;
}
if (Object->LastClickedColumn == lpNmlv->iSubItem) {
Object->SortOrder = (LIST_SORT_ORDER)!Object->SortOrder;
} else {
Object->SortOrder = SortOrderAscendent;
}
hWndList = GetDlgItem(hWnd, IDC_LIST_FILTER);
hWndHeader = ListView_GetHeader(hWndList);
ASSERT(hWndHeader);
ColumnCount = Header_GetItemCount(hWndHeader);
for (i = 0; i < ColumnCount; i++) {
hdi.mask = HDI_FORMAT;
Header_GetItem(hWndHeader, i, &hdi);
if (i == lpNmlv->iSubItem) {
hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
if (Object->SortOrder == SortOrderAscendent){
hdi.fmt |= HDF_SORTUP;
} else {
hdi.fmt |= HDF_SORTDOWN;
}
} else {
hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
}
Header_SetItem(hWndHeader, i, &hdi);
}
Object->LastClickedColumn = lpNmlv->iSubItem;
Object->hWnd = lpNmlv->hdr.hwndFrom;
Object->CtrlId = lpNmlv->hdr.idFrom;
ListView_SortItemsEx(hWndList, FilterSortCallback, (LPARAM)Object);
return 0L;
}
static BOOL ListView_Sort(HWND hListView, int iSortingColumn, int iSortedColumn)
{
if ( (GetWindowLongPtr(hListView, GWL_STYLE) & ~LVS_NOSORTHEADER) &&
(iSortingColumn >= 0) )
{
BOOL bSortAscending;
SORT_INFO SortInfo;
HWND hHeader = ListView_GetHeader(hListView);
HDITEM hColumn = {0};
/* If we are sorting according to another column, uninitialize the old one */
if ( (iSortedColumn >= 0) && (iSortingColumn != iSortedColumn) )
{
hColumn.mask = HDI_FORMAT;
Header_GetItem(hHeader, iSortedColumn, &hColumn);
hColumn.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN);
Header_SetItem(hHeader, iSortedColumn, &hColumn);
}
/* Get the sorting state of the new column */
hColumn.mask = HDI_FORMAT;
Header_GetItem(hHeader, iSortingColumn, &hColumn);
/*
* Check whether we are sorting the list because the user clicked
* on a column, or because we are refreshing the list:
*
* iSortedColumn >= 0 - User clicked on a column; holds the
* old sorting column index.
* iSortedColumn < 0 - List being refreshed.
*/
if (iSortedColumn >= 0)
{
/* Invert the sorting direction */
bSortAscending = ((hColumn.fmt & HDF_SORTUP) == 0);
}
else
{
/*
* If the sorting state of the column is uninitialized,
* initialize it by default to ascending sorting.
*/
if ((hColumn.fmt & (HDF_SORTUP | HDF_SORTDOWN)) == 0)
hColumn.fmt |= HDF_SORTUP;
/* Keep the same sorting direction */
bSortAscending = ((hColumn.fmt & HDF_SORTUP) != 0);
}
/* Set the new column sorting state */
hColumn.fmt &= ~(bSortAscending ? HDF_SORTDOWN : HDF_SORTUP );
hColumn.fmt |= (bSortAscending ? HDF_SORTUP : HDF_SORTDOWN);
Header_SetItem(hHeader, iSortingColumn, &hColumn);
/* Sort the list */
SortInfo.iSortingColumn = iSortingColumn;
SortInfo.bSortAscending = bSortAscending;
return ListView_SortItems(hListView, CompareFunc, (LPARAM)&SortInfo);
}
else
return TRUE;
}
BOOL
AdjustClbHeadings(
IN HWND hWnd,
IN LPCLB_INFO ClbInfo,
IN LPCWSTR Headings OPTIONAL
)
/*++
Routine Description:
AdjustClbHeadings adjust the number of columns, the widths an header text
bbased on the optional Headings parameter. If Headings is NULL then the
column widths are adjusted based on the old headings and the current size
of the Clb. If Headings are supplied then they consist of ';' separated
strings, each of which is a column heading. The number of columns and their
widths is then computed based on these new headings.
Arguments:
hWnd - Supplies a window handle for this Clb.
ClbInfo - Supplies a pointer the CLB_INFO structure for this Clb.
Headings - Supplies an optional pointer to a ';' separated series of
column header strings.
Return Value:
BOOL - Returns TRUE if the adjustment was succesfully made.
--*/
{
BOOL Success;
DWORD Columns;
DWORD ColumnWidth;
DWORD i;
TCHAR Buffer[ MAX_PATH ];
LPCWSTR Heading;
RECT ClientRectHeader;
HD_ITEM hdi;
UINT iCount, j, iRight;
DbgPointerAssert( ClbInfo );
DbgAssert( ! (( ClbInfo->Columns == 0 ) && ( Headings == NULL )));
//
// If the user supplied headings, compute the new number of columns.
//
if( ARGUMENT_PRESENT( Headings )) {
//
// Initialize the column counter.
//
Columns = 0;
//
// Make a copy of the new headings in the Clb object.
//
lstrcpy( ClbInfo->Headings, Headings );
//
// Make a copy of the heading string so that it can be tokenized.
// i.e. wcstok destroys the string.
//
lstrcpy( Buffer, Headings );
//
// Grab the first token (heading).
//
Heading = _tcstok( Buffer, HEADING_SEPARATOR );
//
// For each heading...
//
while( Heading != NULL ) {
//
// Increment the number of columns.
//
Columns++;
//
// Get the next heading.
//
Heading = _tcstok( NULL, HEADING_SEPARATOR );
}
} else {
//
// Same number of Columns as before.
//
Columns = ClbInfo->Columns;
}
//
// If the number of columns in the Clb is zero (i.e. this is the first
// time it is being initialized) allocate the right edge array. Otherwise
// reallocate the existing array if the number of columns has changed.
//
if( ClbInfo->Columns == 0 ) {
ClbInfo->Right = AllocateObject( LONG, Columns );
DbgPointerAssert( ClbInfo->Right );
} else if( Columns != ClbInfo->Columns ) {
ClbInfo->Right = ReallocateObject( LONG, ClbInfo->Right, Columns );
DbgPointerAssert( ClbInfo->Right );
}
//
// Update the number of columns in the Clb (note this may be the same
// number as before).
//
ClbInfo->Columns = Columns;
//
// Compute the default column width by dividing the available space by the
// number of columns.
//
Success = GetClientRect( ClbInfo->hWndHeader, &ClientRectHeader );
DbgAssert( Success );
ColumnWidth = ( ClientRectHeader.right - ClientRectHeader.left )
/ ClbInfo->Columns;
//
// Initialize the array of right edges to the width of each column.
//
for( i = 0; i < ClbInfo->Columns; i++ ) {
ClbInfo->Right[ i ] = ColumnWidth;
}
//
// Update the existing header items
//
iCount = Header_GetItemCount(ClbInfo->hWndHeader);
j = 0;
hdi.mask = HDI_WIDTH;
while ((j < iCount) && (j < Columns)) {
hdi.cxy = ClbInfo->Right[j];
Header_SetItem (ClbInfo->hWndHeader, j, &hdi);
j++;
}
//
// Add new header items if necessary.
//
hdi.mask = HDI_WIDTH;
for (; j < Columns; j++) {
hdi.cxy = ClbInfo->Right[j];
Header_InsertItem (ClbInfo->hWndHeader, j, &hdi);
}
//
// Query the header for the array of right edges.
//
iRight = 0;
for( i = 0; i < ClbInfo->Columns - 1; i++ ) {
iRight += ClbInfo->Right[i];
ClbInfo->Right[i] = iRight;
}
ClbInfo->Right[i] = ClientRectHeader.right;
//
// Copy and parse the headings so that each column's heading
// can be set. These can be new or old headings.
//
lstrcpy( Buffer, ClbInfo->Headings );
Heading = _tcstok( Buffer, HEADING_SEPARATOR );
hdi.mask = HDI_TEXT | HDI_FORMAT;
hdi.fmt = HDF_STRING;
for( i = 0; i < ClbInfo->Columns; i++ ) {
hdi.pszText = (LPTSTR)Heading;
Header_SetItem (ClbInfo->hWndHeader, i, &hdi);
Heading = _tcstok( NULL, HEADING_SEPARATOR );
}
return TRUE;
}
VOID WINAPI HashVerifySortColumn( PHASHVERIFYCONTEXT phvctx, LPNMLISTVIEW plv )
{
if (phvctx->status != CLEANUP_COMPLETED)
return; // Sorting is available only after the worker is done
// Capture the current selection/focus state
HashVerifyReadStates(phvctx);
if (phvctx->sort.iColumn != plv->iSubItem)
{
// Change to a new column
phvctx->sort.iColumn = plv->iSubItem;
phvctx->sort.bReverse = FALSE;
qsort_s_uptr(phvctx->index, phvctx->cTotal, sizeof(PHVITEM), HashVerifySortCompare, phvctx);
}
else if (phvctx->sort.bReverse)
{
// Clicking a column thrice in a row reverts to the original file order
phvctx->sort.iColumn = -1;
phvctx->sort.bReverse = FALSE;
// We do need to validate phvctx->index to handle the edge case where
// the list is really non-empty, but we are treating it as empty because
// we could not allocate an index (qsort_s uses the given length while
// SLBuildIndex uses the actual length); this is, admittedly, a very
// extreme edge case, as it crops up only in an OOM situation where the
// user tries to click-sort an empty list view!
if (phvctx->index)
SLBuildIndex(phvctx->hList, phvctx->index);
}
else
{
// Clicking a column twice in a row reverses the order; since we are
// just reversing the order of an already-sorted column, we can just
// naively flip the index
if (phvctx->index)
{
PHVITEM pItemTemp;
PPHVITEM ppItemLow = phvctx->index;
PPHVITEM ppItemHigh = phvctx->index + phvctx->cTotal - 1;
while (ppItemHigh > ppItemLow)
{
pItemTemp = *ppItemLow;
*ppItemLow = *ppItemHigh;
*ppItemHigh = pItemTemp;
++ppItemLow;
--ppItemHigh;
}
}
phvctx->sort.bReverse = TRUE;
}
// Restore the selection/focus state
HashVerifySetStates(phvctx);
// Update the UI
{
HWND hWndHeader = ListView_GetHeader(phvctx->hWndList);
INT i;
HDITEM hdi;
hdi.mask = HDI_FORMAT;
for (i = HV_COL_FIRST; i <= HV_COL_LAST; ++i)
{
Header_GetItem(hWndHeader, i, &hdi);
hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
if (phvctx->sort.iColumn == i)
hdi.fmt |= (phvctx->sort.bReverse) ? HDF_SORTDOWN : HDF_SORTUP;
Header_SetItem(hWndHeader, i, &hdi);
}
// Invalidate all items
ListView_RedrawItems(phvctx->hWndList, 0, phvctx->cTotal);
// Set a light gray background on the sorted column
ListView_SetSelectedColumn(
phvctx->hWndList,
(phvctx->sort.iColumn != HV_COL_STATUS) ? phvctx->sort.iColumn : -1
);
// Unfortunately, the list does not automatically repaint all of the
// areas affected by SetSelectedColumn, so it is necessary to force a
// repaint of the list view's visible areas in order to avoid artifacts
InvalidateRect(phvctx->hWndList, NULL, FALSE);
}
}
BOOL
ClbSetColumnWidths(
IN HWND hWnd,
IN int ControlId,
IN LPDWORD Widths
)
/*++
Routine Description:
ClbSetColumnWidths sets the width of each column based on the supplied
widths in characters. Note that the column on the far right extends to
the edge of the Clb.
Arguments:
hWnd - Supplies the window handle for the parent window.
ControlId - Supplies the control id for this Clb for the supplied hWnd.
Widths - Supplies an array of widths, one less then the number of
columns, in characters.
Return Value:
BOOL - Returns TRUE if the widths were successfully adjusted.
--*/
{
BOOL Success;
DWORD Columns;
LPCLB_INFO ClbInfo;
HWND hWndClb;
LONG CharWidth;
LONG CharHeight;
DWORD i;
LPLONG WidthsInPixels;
LONG TotalPixels;
HDC hDCClientHeader;
HD_ITEM hdi;
UINT iRight;
//
// Validate arguments.
//
DbgHandleAssert( hWnd );
DbgPointerAssert( Widths );
//
// Retrieve information for this ColumnListBox.
//
hWndClb = GetDlgItem( hWnd, ControlId );
DbgHandleAssert( hWndClb );
ClbInfo = RestoreClbInfo( hWndClb );
DbgPointerAssert( ClbInfo );
DbgAssert( CheckSignature( ClbInfo ));
//
// Get thd HDC for the header.
//
hDCClientHeader = GetDC( ClbInfo->hWndHeader );
DbgHandleAssert( hDCClientHeader );
//
// Get the width of a character.
//
Success = GetCharMetrics(
hDCClientHeader,
&CharWidth,
&CharHeight
);
DbgAssert( Success );
//
// Release the DC for the header.
//
Success = ReleaseDC( ClbInfo->hWndHeader, hDCClientHeader );
DbgAssert( Success );
//
// Allocate an array of pixel widths, one for each column.
//
WidthsInPixels = AllocateObject( LONG, ClbInfo->Columns );
DbgPointerAssert( WidthsInPixels );
//
// Compute the width of each column (not including the rightmost) in pixels,
// and the total number of pixels used by these columns.
//
TotalPixels = 0;
for( i = 0; i < ClbInfo->Columns - 1; i++ ) {
WidthsInPixels[ i ] = Widths[ i ] * CharWidth;
TotalPixels += WidthsInPixels[ i ];
}
//
// The caller did not specify the width of the rightmost column.
//
if( Widths[ i ] == -1 ) {
RECT Rect;
//
// Set the width of the rightmost column to the remainder of the width
// of the header window.
//
Success = GetClientRect(
ClbInfo->hWndHeader,
&Rect
);
DbgAssert( Success );
WidthsInPixels[ i ] = ( Rect.right - Rect.left ) - TotalPixels;
} else {
//
// Set the width of the rightmost column to the value supplied
// by the caller.
//
WidthsInPixels[ i ] = Widths[ i ] * CharWidth;
}
//
// Tell the header window the width of each column.
//
hdi.mask = HDI_WIDTH;
for( i = 0; i < ClbInfo->Columns - 1; i++ ) {
hdi.cxy = WidthsInPixels[i];
Success = Header_SetItem(ClbInfo->hWndHeader, i, &hdi);
DbgAssert( Success );
}
//
// Calc the array of right edges.
//
iRight = 0;
for( i = 0; i < ClbInfo->Columns - 1; i++ ) {
iRight += WidthsInPixels[i];
ClbInfo->Right[i] = iRight;
}
//
// Free the array of pixel widths.
//
Success = FreeObject( WidthsInPixels );
DbgAssert( Success );
return TRUE;
}
void SearchResults::rebuild()
{
EnterCriticalSection(&lock);
static char colNames[colCount][32] = {
"Name", "Date", "Size", "Game name", "Lineup", "Length", "Mode"
};
int colPos[colCount];
getColPos(colPos);
int colOrder[colCount];
int numOrder = 0;
for (int i = 0; i < colCount; i++)
if (colPos[cfg.colOrder[i]] >= 0)
colOrder[numOrder++] = colPos[cfg.colOrder[i]];
Dictionary<uint32> selected;
for (int sel = ListView_GetNextItem(hWnd, -1, LVNI_SELECTED); sel >= 0;
sel = ListView_GetNextItem(hWnd, sel, LVNI_SELECTED))
selected.set(items[sel].path, 1);
int scrollPosX = GetScrollPos(hWnd, SB_HORZ);
int scrollPosY = GetScrollPos(hWnd, SB_VERT);
if (items.length() > 0)
{
RECT rc;
ListView_GetItemRect(hWnd, 0, &rc, LVIR_BOUNDS);
scrollPosY *= rc.bottom - rc.top;
}
setRedraw(false);
clear();
clearColumns();
for (int i = 0; i < colCount; i++)
if (colPos[i] >= 0)
insertColumn(colPos[i], colNames[i]);
if (colPos[colName] >= 0)
setColumnUTF8(colPos[colName], true);
ListView_SetColumnOrderArray(hWnd, numOrder, colOrder);
int colSort = (cfg.colSort[0] & 0x80000000 ? ~cfg.colSort[0] : cfg.colSort[0]);
if (colSort >= 0 && colSort < colCount && colPos[colSort] >= 0 && items.length() > 0)
{
HBITMAP image = NULL;
if (cfg.colSort[0] & 0x80000000)
image = getApp()->getImageLibrary()->getBitmap("SortUp");
else
image = getApp()->getImageLibrary()->getBitmap("SortDown");
if (image)
{
HWND hHeader = ListView_GetHeader(hWnd);
HDITEM hdi;
memset(&hdi, 0, sizeof hdi);
hdi.mask = HDI_FORMAT;
Header_GetItem(hHeader, colSort, &hdi);
hdi.mask |= HDI_BITMAP;
hdi.fmt |= HDF_BITMAP | HDF_BITMAP_ON_RIGHT;
hdi.hbm = image;
Header_SetItem(hHeader, colSort, &hdi);
}
}
items.sort(compItems);
for (int i = 0; i < items.length(); i++)
addItem(i, false);
for (int i = 0; i < items.length(); i++)
if (selected.has(items[i].path))
ListView_SetItemState(hWnd, i, LVIS_SELECTED, LVIS_SELECTED);
for (int i = 0; i < colCount; i++)
if (colPos[i] >= 0)
setColumnWidth(colPos[i], cfg.colWidth[i]);
setRedraw(true);
ListView_Scroll(hWnd, scrollPosX, scrollPosY);
LeaveCriticalSection(&lock);
}
LRESULT
CpuThreadOnColumnClick(
__in PDIALOG_OBJECT Object,
__in NMLISTVIEW *lpNmlv
)
{
HWND hWndHeader;
int nColumnCount;
int i;
HDITEM hdi;
LISTVIEW_OBJECT *ListView;
PCPU_FORM_CONTEXT Context;
HWND hWndCtrl;
HWND hWnd;
BOOLEAN IsThreadSort;
Context = SdkGetContext(Object, CPU_FORM_CONTEXT);
ListView = Context->ListView;
if (ListView->SortOrder == SortOrderNone){
return 0;
}
if (ListView->LastClickedColumn == lpNmlv->iSubItem) {
ListView->SortOrder = (LIST_SORT_ORDER)!ListView->SortOrder;
} else {
ListView->SortOrder = SortOrderAscendent;
}
hWnd = Object->hWnd;
hWndCtrl = lpNmlv->hdr.hwndFrom;
IsThreadSort = (lpNmlv->hdr.idFrom == IDC_LIST_CPU_THREAD_THREAD) ? TRUE : FALSE;
hWndHeader = ListView_GetHeader(hWndCtrl);
ASSERT(hWndHeader);
nColumnCount = Header_GetItemCount(hWndHeader);
for (i = 0; i < nColumnCount; i++) {
hdi.mask = HDI_FORMAT;
Header_GetItem(hWndHeader, i, &hdi);
if (i == lpNmlv->iSubItem) {
hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
if (ListView->SortOrder == SortOrderAscendent){
hdi.fmt |= HDF_SORTUP;
} else {
hdi.fmt |= HDF_SORTDOWN;
}
} else {
hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
}
Header_SetItem(hWndHeader, i, &hdi);
}
ListView->LastClickedColumn = lpNmlv->iSubItem;
if (IsThreadSort) {
ListView_SortItemsEx(hWndCtrl, CpuThreadSortThreadCallback, (LPARAM)hWnd);
} else {
ListView_SortItemsEx(hWndCtrl, CpuThreadSortPcCallback, (LPARAM)hWnd);
}
return 0L;
}
static LRESULT CALLBACK
MainWndProc(HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam)
{
PMAIN_WND_INFO Info;
LRESULT Ret = 0;
/* Get the window context */
Info = (PMAIN_WND_INFO)GetWindowLongPtr(hwnd,
GWLP_USERDATA);
if (Info == NULL && msg != WM_CREATE)
{
goto HandleDefaultMessage;
}
switch(msg)
{
case WM_CREATE:
{
Info = (PMAIN_WND_INFO)(((LPCREATESTRUCT)lParam)->lpCreateParams);
/* Initialize the main window context */
Info->hMainWnd = hwnd;
Info->SelectedItem = NO_ITEM_SELECTED;
SetWindowLongPtr(hwnd,
GWLP_USERDATA,
(LONG_PTR)Info);
if (!InitMainWnd(Info))
return -1;
/* Fill the list-view before showing the main window */
RefreshServiceList(Info);
/* Show the window */
ShowWindow(hwnd,
Info->nCmdShow);
SetFocus(Info->hListView);
}
break;
case WM_SIZE:
{
MainWndResize(Info,
LOWORD(lParam),
HIWORD(lParam));
}
break;
case WM_NOTIFY:
{
LPNMHDR pnmhdr = (LPNMHDR)lParam;
switch (pnmhdr->code)
{
case NM_DBLCLK:
{
POINT pt;
RECT rect;
GetCursorPos(&pt);
GetWindowRect(Info->hListView, &rect);
if (PtInRect(&rect, pt))
{
SendMessage(hwnd,
WM_COMMAND,
//ID_PROP,
MAKEWPARAM((WORD)ID_PROP, (WORD)0),
0);
}
//OpenPropSheet(Info);
}
break;
case NM_RETURN:
{
SendMessage(hwnd,
WM_COMMAND,
//ID_PROP,
MAKEWPARAM((WORD)ID_PROP, (WORD)0),
0);
}
break;
case LVN_COLUMNCLICK:
{
LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
HDITEM hdi;
/* get pending sort direction for clicked column */
hdi.mask = HDI_LPARAM;
(void)Header_GetItem(Info->hHeader, pnmv->iSubItem, &hdi);
/* get new sort parameters */
Info->SortSelection = pnmv->iSubItem;
Info->SortDirection = hdi.lParam;
/* set new sort direction and save */
hdi.lParam = (hdi.lParam == ORD_ASCENDING) ?
ORD_DESCENDING : ORD_ASCENDING;
(void)Header_SetItem(Info->hHeader, pnmv->iSubItem, &hdi);
(void)ListView_SortItemsEx(Info->hListView,
CompareFunc,
(LPARAM)Info);
}
break;
case LVN_ITEMCHANGED:
{
LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
if (pnmv->uNewState != 0)
{
ListViewSelectionChanged(Info, pnmv);
SetMenuAndButtonStates(Info);
}
}
break;
case TTN_GETDISPINFO:
{
LPTOOLTIPTEXT lpttt;
UINT idButton;
lpttt = (LPTOOLTIPTEXT)lParam;
/* Specify the resource identifier of the descriptive
* text for the given button. */
idButton = (UINT)lpttt->hdr.idFrom;
switch (idButton)
{
case ID_PROP:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PROP);
break;
case ID_REFRESH:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_REFRESH);
break;
case ID_EXPORT:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_EXPORT);
break;
case ID_CREATE:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_CREATE);
break;
case ID_DELETE:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_DELETE);
break;
case ID_START:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_START);
break;
case ID_STOP:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_STOP);
break;
case ID_PAUSE:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PAUSE);
break;
case ID_RESTART:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_RESTART);
break;
}
}
break;
}
}
break;
case WM_CONTEXTMENU:
{
POINT pt;
RECT lvRect;
INT xPos = GET_X_LPARAM(lParam);
INT yPos = GET_Y_LPARAM(lParam);
GetCursorPos(&pt);
/* display popup when cursor is in the list view */
GetWindowRect(Info->hListView, &lvRect);
if (PtInRect(&lvRect, pt))
{
TrackPopupMenuEx(GetSubMenu(Info->hShortcutMenu, 0),
TPM_RIGHTBUTTON,
xPos,
yPos,
Info->hMainWnd,
NULL);
}
}
break;
case WM_COMMAND:
{
MainWndCommand(Info,
LOWORD(wParam),
(HWND)lParam);
goto HandleDefaultMessage;
}
case WM_MENUSELECT:
{
if (Info->hStatus != NULL)
{
if (!MainWndMenuHint(Info,
LOWORD(wParam),
MainMenuHintTable,
sizeof(MainMenuHintTable) / sizeof(MainMenuHintTable[0]),
IDS_HINT_BLANK))
{
MainWndMenuHint(Info,
LOWORD(wParam),
SystemMenuHintTable,
sizeof(SystemMenuHintTable) / sizeof(SystemMenuHintTable[0]),
IDS_HINT_BLANK);
}
}
}
break;
case WM_ENTERMENULOOP:
{
Info->bInMenuLoop = TRUE;
UpdateMainStatusBar(Info);
break;
}
case WM_EXITMENULOOP:
{
Info->bInMenuLoop = FALSE;
UpdateMainStatusBar(Info);
break;
}
case WM_CLOSE:
{
HeapFree(ProcessHeap,
0,
Info->pAllServices);
DestroyMenu(Info->hShortcutMenu);
DestroyWindow(hwnd);
}
break;
case WM_DESTROY:
{
HeapFree(ProcessHeap,
0,
Info);
SetWindowLongPtr(hwnd,
GWLP_USERDATA,
0);
PostQuitMessage(0);
}
break;
default:
{
HandleDefaultMessage:
Ret = DefWindowProc(hwnd,
msg,
wParam,
lParam);
}
break;
}
return Ret;
}
