//extension method for setting "Sort Icon" of the listview.
public static void SetSortIcon(this System.Windows.Forms.ListView ListViewControl, int ColumnIndex, System.Windows.Forms.SortOrder Order)
{
IntPtr ColumnHeader = SendMessage(ListViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (int ColumnNumber = 0; ColumnNumber <= ListViewControl.Columns.Count - 1; ColumnNumber++)
{
IntPtr ColumnPtr = new IntPtr(ColumnNumber);
HDITEM item = new HDITEM();
item.mask = (int)HDITEM.Mask.Format;
SendMessageHDITEM(ColumnHeader, HDM_GETITEM, ColumnPtr, ref item);
if (Order != SortOrder.None && ColumnNumber == ColumnIndex)
{
switch (Order)
{
case SortOrder.Ascending:
item.fmt &= ~(int)HDITEM.Format.SortDown;
item.fmt |= (int)HDITEM.Format.SortUp;
break;
case SortOrder.Descending:
item.fmt &= ~(int)HDITEM.Format.SortUp;
item.fmt |= (int)HDITEM.Format.SortDown;
break;
}
}
else
{
item.fmt &= ~(int)HDITEM.Format.SortDown & ~(int)HDITEM.Format.SortUp;
}
SendMessageHDITEM(ColumnHeader, HDM_SETITEM, ColumnPtr, ref item);
}
}
//extension method for setting "Sort Icon" of the listview.
public static void SetSortIcon(this System.Windows.Forms.ListView ListViewControl, int ColumnIndex, System.Windows.Forms.SortOrder Order)
{
IntPtr ColumnHeader = SendMessage(ListViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (int ColumnNumber = 0; ColumnNumber <= ListViewControl.Columns.Count - 1; ColumnNumber++)
{
IntPtr ColumnPtr = new IntPtr(ColumnNumber);
HDITEM item = new HDITEM();
item.mask = (int)HDITEM.Mask.Format;
SendMessageHDITEM(ColumnHeader, HDM_GETITEM, ColumnPtr, ref item);
if (Order != System.Windows.Forms.SortOrder.None && ColumnNumber == ColumnIndex)
{
switch (Order)
{
case System.Windows.Forms.SortOrder.Ascending:
item.fmt &= ~(int)HDITEM.Format.SortDown;
item.fmt |= (int)HDITEM.Format.SortUp;
break;
case System.Windows.Forms.SortOrder.Descending:
item.fmt &= ~(int)HDITEM.Format.SortUp;
item.fmt |= (int)HDITEM.Format.SortDown;
break;
}
}
else
{
item.fmt &= ~(int)HDITEM.Format.SortDown & ~(int)HDITEM.Format.SortUp;
}
SendMessageHDITEM(ColumnHeader, HDM_SETITEM, ColumnPtr, ref item);
}
}
const int HDM_SETITEM = 0x1200 + 12; // HDM_FIRST + 12
public static void SetColumnHeaderSortIcon(this ListView listView, int colIndex, SortOrder order)
{
Assert(listView != null);
Assert(!listView.InvokeRequired);
IntPtr hColHeader = SendMessage(listView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
HDITEM hdItem = new HDITEM();
IntPtr colHeader = new IntPtr(colIndex);
hdItem.mask = HDI_FORMAT;
IntPtr rtn = SendMessageITEM(hColHeader, HDM_GETITEM, colHeader, ref hdItem);
if (order == SortOrder.Ascending)
{
hdItem.fmt &= ~HDF_SORTDOWN;
hdItem.fmt |= HDF_SORTUP;
}
else if (order == SortOrder.Descending)
{
hdItem.fmt &= ~HDF_SORTUP;
hdItem.fmt |= HDF_SORTDOWN;
}
else
{
hdItem.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
}
rtn = SendMessageITEM(hColHeader, HDM_SETITEM, colHeader, ref hdItem);
}
/// <summary>
/// Displays the sort indicators on the columns.
/// </summary>
public void RefreshSortIndicators()
{
if(_ListView.IsHandleCreated && !_UpdatedSortIndicators && ShowNativeSortIndicators) {
_UpdatedSortIndicators = true;
const uint LVM_GETHEADER = 0x1000 + 31;
var header = Window.CallSendMessage(_ListView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
if(header != IntPtr.Zero) {
for(var i = 0;i < _ListView.Columns.Count;++i) {
var isSortColumn = SortColumn == null ? i == 0 : SortColumn.Index == i;
var colIndex = new IntPtr(i);
var hditem = new HDITEM() {
mask = HDITEM.HDI_FORMAT,
};
if(Window.CallSendMessage(header, HDITEM.HDM_GETITEM, colIndex, ref hditem) != IntPtr.Zero) {
if(!isSortColumn) {
hditem.fmt &= ~(HDITEM.HDF_SORTUP | HDITEM.HDF_SORTDOWN);
} else {
if(SortAscending) {
hditem.fmt &= ~HDITEM.HDF_SORTDOWN;
hditem.fmt |= HDITEM.HDF_SORTUP;
} else {
hditem.fmt &= ~HDITEM.HDF_SORTUP;
hditem.fmt |= HDITEM.HDF_SORTDOWN;
}
}
Window.CallSendMessage(header, HDITEM.HDM_SETITEM, colIndex, ref hditem);
}
}
}
}
}
public static SortOrder GetSortIcon(this ListView listView, int columnIndex)
{
IntPtr columnHeader = SendMessage(
listView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
var item = new HDITEM {
mask = HDITEM.Mask.Format
};
if (SendMessage(columnHeader, HDM_GETITEM, new IntPtr(columnIndex), ref item) == IntPtr.Zero)
{
throw new Win32Exception();
}
if ((item.fmt & HDITEM.Format.SortUp) != 0)
{
return(SortOrder.Ascending);
}
if ((item.fmt & HDITEM.Format.SortDown) != 0)
{
return(SortOrder.Descending);
}
return(SortOrder.None);
}
private void SetSortIcons(int column, SortOrder order)
{
IntPtr hHeader = SendMessage(deviceListView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
IntPtr newColumn = new IntPtr(column);
HDITEM hdItem;
IntPtr rtn;
hdItem = new HDITEM();
hdItem.mask = HDI_FORMAT;
rtn = SendMessageITEM(hHeader, HDM_GETITEM, newColumn, ref hdItem);
switch (order)
{
case SortOrder.None:
hdItem.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
break;
case SortOrder.Ascending:
hdItem.fmt &= ~HDF_SORTDOWN;
hdItem.fmt |= HDF_SORTUP;
break;
case SortOrder.Descending:
hdItem.fmt &= ~HDF_SORTUP;
hdItem.fmt |= HDF_SORTDOWN;
break;
}
rtn = SendMessageITEM(hHeader, HDM_SETITEM, newColumn, ref hdItem);
}
/// <summary>
/// Set the Header Column image
/// </summary>
/// <param name="list">ListView</param>
/// <param name="columnIndex">Current column index</param>
/// <param name="order">Current sort order</param>
/// <param name="showImage">Display image in column (turn on/off image)</param>
public static void SetHeaderImage(ListView list, int columnIndex, SortOrder order, bool showImage)
{
IntPtr _header;
HDITEM _hdItem = new HDITEM();
int _iconNumber = 0;
//set the image index based on sort order from the smallimagelist property
if (order == SortOrder.Ascending)
{
_iconNumber = 0;
}
else
{
_iconNumber = 1;
}
//get a handle to the listview header component
_header = GetHeader(list.Handle);
//set up the required structure members
_hdItem.mask = HDI.IMAGE | HDI.FORMAT;
_hdItem.pszText = list.Columns[columnIndex].Text;
// check to show the indicator image
if (showImage)
{
_hdItem.fmt = HDF.STRING | HDF.IMAGE | HDF.BITMAP_ON_RIGHT;
_hdItem.iImage = _iconNumber;
}
else
{
_hdItem.fmt = HDF.STRING;
}
//modify the header
SendMessage(_header, HDM.SETITEM, (uint)columnIndex, ref _hdItem);
}
public ListViewSorter(SortOrder sortOrder, int col, ListView listView)
{
IntPtr hColHeader = SendMessage(listView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
HDITEM hdItem = new HDITEM();
IntPtr colHeader = new IntPtr(col);
hdItem.mask = HDI_FORMAT;
SendMessageItem(hColHeader, HDM_GETITEM, colHeader, ref hdItem);
if (sortOrder == SortOrder.Ascending)
{
hdItem.fmt &= ~HDF_SORTDOWN;
hdItem.fmt |= HDF_SORTUP;
}
else if (sortOrder == SortOrder.Descending)
{
hdItem.fmt &= ~HDF_SORTUP;
hdItem.fmt |= HDF_SORTDOWN;
}
else if (sortOrder == SortOrder.None)
{
hdItem.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
}
SendMessageItem(hColHeader, HDM_SETITEM, colHeader, ref hdItem);
this.sortOrder = sortOrder;
this.column = col;
}
public static void SetSortIcons(ListView listview1, ref int previouslySortedColumn, int newSortColumn)
{
IntPtr hHeader = SendMessage(listview1.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
IntPtr newColumn = new IntPtr(newSortColumn);
IntPtr prevColumn = new IntPtr(previouslySortedColumn);
HDITEM hdItem;
IntPtr rtn;
if (previouslySortedColumn != -1 && previouslySortedColumn != newSortColumn)
{
hdItem = new HDITEM();
hdItem.mask = HDI_FORMAT;
rtn = SendMessageITEM(hHeader, HDM_GETITEM, prevColumn, ref hdItem);
hdItem.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
rtn = SendMessageITEM(hHeader, HDM_SETITEM, prevColumn, ref hdItem);
}
hdItem = new HDITEM();
hdItem.mask = HDI_FORMAT;
rtn = SendMessageITEM(hHeader, HDM_GETITEM, newColumn, ref hdItem);
if (listview1.Sorting == SortOrder.Ascending)
{
hdItem.fmt &= ~HDF_SORTDOWN;
hdItem.fmt |= HDF_SORTUP;
}
else
{
hdItem.fmt &= ~HDF_SORTUP;
hdItem.fmt |= HDF_SORTDOWN;
}
rtn = SendMessageITEM(hHeader, HDM_SETITEM, newColumn, ref hdItem);
previouslySortedColumn = newSortColumn;
}
public static void SetSortIcon(this ListView listView, int columnIndex, SortOrder order)
{
var columnHeader = (HWND)SendMessage(listView.Handle, (uint)ListViewMessage.LVM_GETHEADER);
for (var columnNumber = 0; columnNumber <= listView.Columns.Count - 1; columnNumber++)
{
// Get current ListView column info
var lvcol = new LVCOLUMN(ListViewColumMask.LVCF_FMT);
SendMessage(listView.Handle, ListViewMessage.LVM_GETCOLUMN, columnNumber, lvcol);
// Get current header info
var hditem = new HDITEM(HeaderItemMask.HDI_FORMAT | HeaderItemMask.HDI_DI_SETITEM);
SendMessage(columnHeader, HeaderMessage.HDM_GETITEM, columnNumber, hditem);
// Update header with column info
hditem.Format |= (HeaderItemFormat)((uint)lvcol.Format & 0x1001803);
if ((lvcol.Format & ListViewColumnFormat.LVCFMT_NO_TITLE) == 0)
{
hditem.ShowText = true;
}
// Set header image info
if (order != SortOrder.None && columnNumber == columnIndex)
{
hditem.ImageDisplay = (order == SortOrder.Descending) ? HeaderItemImageDisplay.DownArrow : HeaderItemImageDisplay.UpArrow;
}
else
{
hditem.ImageDisplay = HeaderItemImageDisplay.None;
}
// Update header
SendMessage(columnHeader, HeaderMessage.HDM_SETITEM, columnNumber, hditem);
}
}
public static void SetColumnImage(ListView list, int columnIndex, SortOrder order, int imageIndex)
{
IntPtr headerControl = GetHeaderControl(list);
if (headerControl.ToInt32() != 0)
{
HDITEM hdi = new HDITEM {
mask = 4
};
IntPtr ptr2 = SendMessageHDItem(headerControl, 0x120b, columnIndex, ref hdi);
hdi.fmt &= -7681;
if (HasBuiltinSortIndicators())
{
if (order == SortOrder.Ascending)
{
hdi.fmt |= 0x400;
}
if (order == SortOrder.Descending)
{
hdi.fmt |= 0x200;
}
}
else
{
hdi.mask |= 0x20;
hdi.fmt |= 0x1800;
hdi.iImage = imageIndex;
}
ptr2 = SendMessageHDItem(headerControl, 0x120c, columnIndex, ref hdi);
}
}
public static void SetSortIcons(ListView listView, int previouslySortedColumn, int newSortColumn, SortOrder sorting) {
IntPtr headerHandle = SendMessage(listView.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
IntPtr newColumn = new IntPtr(newSortColumn);
IntPtr prevColumn = new IntPtr(previouslySortedColumn);
HDITEM hditem;
// Only update the previous item if it existed and if it was a different one.
if (previouslySortedColumn != -1 && previouslySortedColumn != newSortColumn) {
// Clear icon from the previous column.
hditem = new HDITEM();
hditem.mask = HDI_FORMAT;
ItemSendMessage(headerHandle, HDM_GETITEM, prevColumn, ref hditem);
hditem.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
ItemSendMessage(headerHandle, HDM_SETITEM, prevColumn, ref hditem);
}
// Set icon on the new column.
hditem = new HDITEM();
hditem.mask = HDI_FORMAT;
ItemSendMessage(headerHandle, HDM_GETITEM, newColumn, ref hditem);
if (sorting == SortOrder.Ascending) {
hditem.fmt &= ~HDF_SORTDOWN;
hditem.fmt |= HDF_SORTUP;
}
else {
hditem.fmt &= ~HDF_SORTUP;
hditem.fmt |= HDF_SORTDOWN;
}
ItemSendMessage(headerHandle, HDM_SETITEM, newColumn, ref hditem);
}
internal static bool Header_SetItem(IntPtr hWndHeader, int index, [In, Out] HDITEM hdi)
{
if (!(SendMessage(hWndHeader, 0x120c, new IntPtr(index), hdi) != IntPtr.Zero))
{
return(false);
}
return(true);
}
/// <summary>
/// Set a column's position
/// </summary>
/// <param name="hwndLV">handle to listview</param>
/// <param name="ColumnIndex">Column Index to set</param>
/// <param name="iOrder">Position to set</param>
public static void SetColumnPosition(IntPtr hwndLV, int ColumnIndex, int iOrder)
{
HDITEM hdi = new HDITEM();
hdi.mask = HDI.ORDER;
hdi.iOrder = iOrder;
Header_SetItem(GetHeader(hwndLV), ColumnIndex, hdi);
}
private void ShowHeaderIcon(ListView list, int columnIndex, SortOrder sortOrder)
{
if (columnIndex < 0 || columnIndex >= list.Columns.Count)
{
return;
}
IntPtr hHeader = SendMessage(list.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
ColumnHeader colHdr = list.Columns[columnIndex];
HDITEM hd = new HDITEM();
hd.mask = HDI_FORMAT;
HorizontalAlignment align = colHdr.TextAlign;
if (align == HorizontalAlignment.Left)
{
hd.fmt = HDF_LEFT | HDF_STRING | HDF_BITMAP_ON_RIGHT;
}
else if (align == HorizontalAlignment.Center)
{
hd.fmt = HDF_CENTER | HDF_STRING | HDF_BITMAP_ON_RIGHT;
}
else // HorizontalAlignment.Right
{
hd.fmt = HDF_RIGHT | HDF_STRING;
}
if (s_useNativeArrows)
{
if (sortOrder == SortOrder.Ascending)
{
hd.fmt |= HDF_SORTUP;
}
else if (sortOrder == SortOrder.Descending)
{
hd.fmt |= HDF_SORTDOWN;
}
}
else
{
hd.mask |= HDI_IMAGE;
if (sortOrder != SortOrder.None)
{
hd.fmt |= HDF_IMAGE;
}
hd.iImage = (int)sortOrder - 1;
}
SendMessage2(hHeader, HDM_SETITEM, new IntPtr(columnIndex), ref hd);
}
//---------------------------------------------------------------------
public static void SetSortIcon(this ListView listViewControl, int columnIndex, SortOrder order)
{
if (listViewControl == null)
{
throw new ArgumentNullException(nameof(listViewControl));
}
var columnHeader = SendMessage(listViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (var columnNumber = 0; columnNumber <= listViewControl.Columns.Count - 1; columnNumber++)
{
var columnPtr = new IntPtr(columnNumber);
var item = new HDITEM
{
mask = HDITEM.Mask.Format
};
if (SendMessage(columnHeader, HDM_GETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new Win32Exception();
}
if (order != SortOrder.None && columnNumber == columnIndex)
{
switch (order)
{
case SortOrder.Ascending:
{
item.fmt &= ~HDITEM.Format.SortDown;
item.fmt |= HDITEM.Format.SortUp;
}
break;
case SortOrder.Descending:
{
item.fmt &= ~HDITEM.Format.SortUp;
item.fmt |= HDITEM.Format.SortDown;
}
break;
}
}
else
{
item.fmt &= ~HDITEM.Format.SortDown & ~HDITEM.Format.SortUp;
}
if (SendMessage(columnHeader, HDM_SETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new Win32Exception();
}
}
}
public static void SetSplitButton(this Collumns column, IntPtr handle, int index)
{
var item = new HDITEM {
mask = HDITEM.Mask.Format
};
User32.SendMessage(handle, MSG.HDM_GETITEM, index, ref item);
item.fmt |= HDITEM.Format.HDF_SPLITBUTTON;
User32.SendMessage(handle, MSG.HDM_SETITEM, index, ref item);
}
/// <summary>
///
/// </summary>
/// <param name="hwndHD"></param>
/// <param name="index"></param>
/// <param name="mask"></param>
/// <returns></returns>
public static HDITEM Header_GetItem(IntPtr hwndHD, int index, HDI mask)
{
HDITEM rtn = new HDITEM();
rtn.mask = mask;
if ((mask & HDI.TEXT) == HDI.TEXT)
{
rtn.pszText = new string('\0', 512);
rtn.cchTextMax = 512;
}
SendMessage(hwndHD, HDM.GETITEM, (uint)index, ref rtn);
return(rtn);
}
private int ColumnAtIndex(int column)
{
HDITEM hd = new HDITEM();
hd.mask = (int)HeaderItemFlags.ORDER;
for (int i = 0; i < ColumnCount; i++)
{
if (Win32.SendMessage(HeaderWnd, (int)HeaderControlMessages.GETITEMA, column, ref hd) != IntPtr.Zero)
{
return(hd.iOrder);
}
}
return(0);
}
private int ColumnAtIndex(int column)
{
HDITEM hd = new HDITEM();
hd.mask = HDI_ORDER;
for (int i = 0; i < this.ColumnCount; i++)
{
if (WinAPIDllImport.SendMessage(this.HeaderWnd, HDM_GETITEMA, column, ref hd) != IntPtr.Zero)
{
return(hd.iOrder);
}
}
return(0);
}
public static void SetSortIcon(this ListView listViewControl, int columnIndex, SortOrder order)
{
IntPtr columnHeader = SendMessage(listViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (int columnNumber = 0; columnNumber <= listViewControl.Columns.Count - 1; columnNumber++)
{
var columnPtr = new IntPtr(columnNumber);
var item = new HDITEM
{
mask = HDITEM.Mask.Format
};
if (SendMessage(columnHeader, HDM_GETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new Win32Exception();
}
if (order != SortOrder.None && columnNumber == columnIndex)
{
switch (order)
{
case SortOrder.Ascending:
item.fmt &= ~HDITEM.Format.SortDown;
item.fmt |= HDITEM.Format.SortUp;
break;
case SortOrder.Descending:
item.fmt &= ~HDITEM.Format.SortUp;
item.fmt |= HDITEM.Format.SortDown;
break;
}
}
else
{
item.fmt &= ~HDITEM.Format.SortDown & ~HDITEM.Format.SortUp;
}
if (SendMessage(columnHeader, HDM_SETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new Win32Exception();
//some modify in 2019
// more great function
//;;;;;;;
}
}
}
private void SetColumnFormat(int column, HDITEM.Format format)
{
IntPtr hresult;
IntPtr columnHeader = SendMessage(this.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
HDITEM item = new HDITEM();
item.mask = HDITEM.Mask.Format;
item.fmt = format;
//hresult = SendMessage(columnHeader, HDM_GETITEM, (IntPtr) column, ref item);
//if (hresult != TRUE) return;
//item.fmt |= format;
hresult = SendMessage(columnHeader, HDM_SETITEM, (IntPtr)column, ref item);
}
protected string GetHeaderItemText(int index)
{
// I get the bug that I get on the ListView if
// I use the columns collection to retreive the text
// That's why I prefer to use the Windows API
HDITEM hdi = new HDITEM();
hdi.mask = (int)HeaderItemFlags.HDI_TEXT;
hdi.cchTextMax = BUFFER_SIZE;
hdi.pszText = Marshal.AllocHGlobal(BUFFER_SIZE);
WindowsAPI.SendMessage(hHeader, (int)HeaderControlMessages.HDM_GETITEMW, index, ref hdi);
string text = Marshal.PtrToStringAuto(hdi.pszText);
return(text);
}
/// <summary>
/// Function to set the sorting icon on the list view control.
/// </summary>
/// <param name="listViewControl">Listview to update.</param>
/// <param name="headerIndex">Column header index.</param>
/// <param name="order">Sort order.</param>
/// <exception cref="GorgonLibrary.GorgonException">Thrown if the column header was not found or could not be updated.</exception>
/// <remarks>Use this extension method to set a sorting icon for the specified column. This will give users a clue as to how the
/// list view is sorted.</remarks>
public static void SetSortIcon(this ListView listViewControl, int headerIndex, SortOrder order)
{
IntPtr columnHeader = Win32API.SendMessage(listViewControl.Handle, (uint)ListViewMessages.LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (int columnNumber = 0; columnNumber < listViewControl.Columns.Count; columnNumber++)
{
var columnPtr = new IntPtr(columnNumber);
var item = new HDITEM
{
mask = HeaderMask.Format
};
if (Win32API.SendMessage(columnHeader, (uint)HeaderMessages.HDM_GETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new GorgonException(GorgonResult.CannotEnumerate, Resources.GOR_LISTVIEW_CANNOT_FIND_HEADER);
}
if (order != SortOrder.None && columnNumber == headerIndex)
{
switch (order)
{
case SortOrder.Ascending:
item.fmt &= ~HeaderFormat.SortDown;
item.fmt |= HeaderFormat.SortUp;
break;
case SortOrder.Descending:
item.fmt &= ~HeaderFormat.SortUp;
item.fmt |= HeaderFormat.SortDown;
break;
}
}
else
{
item.fmt &= ~HeaderFormat.SortDown & ~HeaderFormat.SortUp;
}
if (Win32API.SendMessage(columnHeader, (uint)HeaderMessages.HDM_SETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new GorgonException(GorgonResult.CannotWrite, Resources.GOR_LISTVIEW_CANNOT_UPDATE_COLUMN);
}
}
}
// ReSharper restore InconsistentNaming
/// <summary>
/// Displays a sort icon (up/down caret or chevron) on the given column.
/// </summary>
/// <param name="listViewControl"></param>
/// <param name="columnIndex"></param>
/// <param name="order"></param>
/// <exception cref="Win32Exception"></exception>
public static void SetSortIcon(this ListView listViewControl, int columnIndex, SortOrder order)
{
IntPtr columnHeader = WindowAPI.SendMessage(listViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (int columnNumber = 0; columnNumber <= listViewControl.Columns.Count - 1; columnNumber++)
{
var columnPtr = new IntPtr(columnNumber);
var item = new HDITEM
{
mask = HeaderItemMask.HDI_FORMAT
};
if (WindowAPI.SendMessage(columnHeader, HDM_GETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new Win32Exception();
}
if (order != SortOrder.None && columnNumber == columnIndex)
{
switch (order)
{
case SortOrder.Ascending:
item.fmt &= ~HeaderItemFormat.HDF_SORTDOWN;
item.fmt |= HeaderItemFormat.HDF_SORTUP;
break;
case SortOrder.Descending:
item.fmt &= ~HeaderItemFormat.HDF_SORTUP;
item.fmt |= HeaderItemFormat.HDF_SORTDOWN;
break;
}
}
else
{
item.fmt &= ~HeaderItemFormat.HDF_SORTDOWN & ~HeaderItemFormat.HDF_SORTUP;
}
if (WindowAPI.SendMessage(columnHeader, HDM_SETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new Win32Exception();
}
}
}
/// <summary>
/// Function to set the sorting icon on the list view control.
/// </summary>
/// <param name="listViewControl">Listview to update.</param>
/// <param name="headerIndex">Column header index.</param>
/// <param name="order">Sort order.</param>
/// <exception cref="GorgonException">Thrown if the column header was not found or could not be updated.</exception>
/// <remarks>Use this extension method to set a sorting icon for the specified column. This will give users a clue as to how the
/// list view is sorted.</remarks>
public static void SetSortIcon(this ListView listViewControl, int headerIndex, SortOrder order)
{
IntPtr columnHeader = UserApi.SendMessage(listViewControl.Handle, LvmGetHeader, IntPtr.Zero, IntPtr.Zero);
for (int columnNumber = 0; columnNumber < listViewControl.Columns.Count; columnNumber++)
{
var columnPtr = new IntPtr(columnNumber);
var item = new HDITEM
{
mask = HeaderFormatMask
};
if (UserApi.SendMessage(columnHeader, HdmGetItem, columnPtr, ref item) == IntPtr.Zero)
{
throw new GorgonException(GorgonResult.CannotEnumerate, Resources.GOR_ERR_LISTVIEW_CANNOT_FIND_HEADER);
}
if ((order != SortOrder.None) && (columnNumber == headerIndex))
{
switch (order)
{
case SortOrder.Ascending:
item.fmt &= ~HeaderSortDown;
item.fmt |= HeaderSortUp;
break;
case SortOrder.Descending:
item.fmt &= ~HeaderSortUp;
item.fmt |= HeaderSortDown;
break;
}
}
else
{
item.fmt &= ~HeaderSortDown & ~HeaderSortUp;
}
if (UserApi.SendMessage(columnHeader, HdmSetItem, columnPtr, ref item) == IntPtr.Zero)
{
throw new GorgonException(GorgonResult.CannotWrite, Resources.GOR_ERR_LISTVIEW_CANNOT_UPDATE_COLUMN);
}
}
}
private HDITEM.Format GetColumnFormat(int column)
{
IntPtr hresult;
IntPtr columnHeader = SendMessage(this.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
HDITEM item = new HDITEM();
item.mask = HDITEM.Mask.Format;
hresult = SendMessage(columnHeader, HDM_GETITEM, (IntPtr)column, ref item);
if (hresult != TRUE)
{
throw new Win32Exception();
}
else
{
return(item.fmt);
}
}
public static void SetSortIcon(this ListView listViewControl, int columnIndex, SortOrder order)
{
IntPtr columnHeader = SendMessage(listViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
for (int columnNumber = 0; columnNumber <= listViewControl.Columns.Count - 1; columnNumber++)
{
var columnPtr = new IntPtr(columnNumber);
var item = new HDITEM
{
mask = HDITEM.Mask.Format
};
if (SendMessage(columnHeader, HDM_GETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new Win32Exception();
}
if (order != SortOrder.None && columnNumber == columnIndex)
{
switch (order)
{
case SortOrder.Ascending:
item.fmt &= ~HDITEM.Format.SortDown;
item.fmt |= HDITEM.Format.SortUp;
break;
case SortOrder.Descending:
item.fmt &= ~HDITEM.Format.SortUp;
item.fmt |= HDITEM.Format.SortDown;
break;
}
}
else
{
item.fmt &= ~HDITEM.Format.SortDown & ~HDITEM.Format.SortUp;
}
if (SendMessage(columnHeader, HDM_SETITEM, columnPtr, ref item) == IntPtr.Zero)
{
throw new Win32Exception();
}
}
}
protected void EnableSplitButtonOnColumnHeader(int column, bool enable)
{
HDITEM headerItem = new HDITEM();
headerItem.mask = HDITEM.Mask.Format;
IntPtr columnHeader = SendMessage(this.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
SendMessage(columnHeader, HDM_GETITEM, (IntPtr)column, ref headerItem);
if (enable)
{
headerItem.fmt |= HDITEM.Format.SplitButton;
}
else
{
headerItem.fmt &= ~HDITEM.Format.SplitButton;
}
IntPtr res = SendMessage(columnHeader, HDM_SETITEM, (IntPtr)column, ref headerItem);
}
public List <string> GetColumnsHeaderText(int processHandle, int headerhwnd, int colCount)
{
List <string> list = new List <string>();
uint num = 256u;
int num2 = VirtualAllocEx(processHandle, IntPtr.Zero, (uint)Marshal.SizeOf(typeof(ListViewCatecher.HDITEM)), 12288u, 4u);
int num3 = VirtualAllocEx(processHandle, IntPtr.Zero, num, 12288u, 4u);
for (int i = 0; i < colCount; i++)
{
byte[] array = new byte[num];
HDITEM hDITEM = new HDITEM();
hDITEM.mask = (uint)this.HDI_TEXT;
hDITEM.fmt = 0;
hDITEM.cchTextMax = (int)num;
hDITEM.pszText = (IntPtr)num3;
IntPtr intPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(hDITEM));
Marshal.StructureToPtr(hDITEM, intPtr, false);
uint count = 0u;
WriteProcessMemory(processHandle, num2, intPtr, Marshal.SizeOf(typeof(ListViewCatecher.HDITEM)), ref count);
SendMessage(new IntPtr(headerhwnd), 4611u, i, num2);
ReadProcessMemory(processHandle, num3, Marshal.UnsafeAddrOfPinnedArrayElement(array, 0), (int)num, ref count);
string @string = Encoding.Default.GetString(array, 0, (int)count);
string text = "";
string text2 = @string;
for (int j = 0; j < text2.Length; j++)
{
char c = text2[j];
if (c == '\0')
{
break;
}
text += c;
}
list.Add(text);
}
VirtualFreeEx(processHandle, num2, 0u, 32768u);
VirtualFreeEx(processHandle, num3, 0u, 32768u);
return(list);
}
public List <string> GetColumnsHeaderText(int processHandle, int headerhwnd, int colCount)
{
List <string> list = new List <string>();
uint dwSize = 0x100;
int lpBaseAddress = WindowsAPIHelper.VirtualAllocEx(processHandle, IntPtr.Zero, (uint)Marshal.SizeOf(typeof(HDITEM)), 0x3000, 4);
int num3 = WindowsAPIHelper.VirtualAllocEx(processHandle, IntPtr.Zero, dwSize, 0x3000, 4);
for (int i = 0; i < colCount; i++)
{
byte[] arr = new byte[dwSize];
HDITEM structure = new HDITEM
{
mask = (uint)this.HDI_TEXT,
fmt = 0,
cchTextMax = (int)dwSize,
pszText = (IntPtr)num3
};
IntPtr ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(structure));
Marshal.StructureToPtr(structure, ptr, false);
uint vNumberOfBytesRead = 0;
bool flag = WindowsAPIHelper.WriteProcessMemory(processHandle, lpBaseAddress, ptr, Marshal.SizeOf(typeof(HDITEM)), ref vNumberOfBytesRead);
WindowsAPIHelper.SendMessage(headerhwnd, 0x1203, i, lpBaseAddress);
WindowsAPIHelper.ReadProcessMemory(processHandle, num3, Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0), (int)dwSize, ref vNumberOfBytesRead);
string str = Encoding.Default.GetString(arr, 0, (int)vNumberOfBytesRead);
string item = "";
foreach (char ch in str)
{
if (ch == '\0')
{
break;
}
item = item + ch;
}
list.Add(item);
}
WindowsAPIHelper.VirtualFreeEx(processHandle, lpBaseAddress, 0, 0x8000);
WindowsAPIHelper.VirtualFreeEx(processHandle, num3, 0, 0x8000);
return(list);
}
public void SetSortArrow(int column, SortOrder sortOrder)
{
if (this.InvokeRequired)
{
this.Invoke((MethodInvoker)(() => {
this.SetSortArrow(column, sortOrder);
}));
return;
}
var pHeader = SendMessage(this.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
var pColumn = new IntPtr(column);
var headerItem = new HDITEM {
mask = HDI_FORMAT
};
SendMessage(pHeader, HDM_GETITEM, pColumn, ref headerItem);
switch (sortOrder)
{
case SortOrder.Ascending:
headerItem.fmt &= ~HDF_SORTDOWN;
headerItem.fmt |= HDF_SORTUP;
break;
case SortOrder.Descending:
headerItem.fmt &= ~HDF_SORTUP;
headerItem.fmt |= HDF_SORTDOWN;
break;
case SortOrder.None:
headerItem.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
break;
}
SendMessage(pHeader, HDM_SETITEM, pColumn, ref headerItem);
}
public const Int32 HDM_SETITEM = 0x1200 + 12; // HDM_FIRST + 12
public void SetSortIcons(int newSortColumn)
{
IntPtr hHeader = NativeMethods.SendMessage(this.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
IntPtr newColumn = new IntPtr(newSortColumn);
IntPtr prevColumn = new IntPtr(_previouslySortedColumn);
HDITEM hdItem;
IntPtr rtn;
// Only update the previous item if it existed and if it was a different one.
if (_previouslySortedColumn != -1 && _previouslySortedColumn != newSortColumn)
{
// Clear icon from the previous column.
hdItem = new HDITEM();
hdItem.mask = HDI_FORMAT;
rtn = NativeMethods.SendMessageITEM(hHeader, HDM_GETITEM, prevColumn, ref hdItem);
hdItem.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
rtn = NativeMethods.SendMessageITEM(hHeader, HDM_SETITEM, prevColumn, ref hdItem);
}
// Set icon on the new column.
hdItem = new HDITEM();
hdItem.mask = HDI_FORMAT;
rtn = NativeMethods.SendMessageITEM(hHeader, HDM_GETITEM, newColumn, ref hdItem);
if (this.Sorting == SortOrder.Ascending)
{
hdItem.fmt &= ~HDF_SORTDOWN;
hdItem.fmt |= HDF_SORTUP | HDF_BITMAP_ON_RIGHT;
}
else
{
hdItem.fmt &= ~HDF_SORTUP;
hdItem.fmt |= HDF_SORTDOWN;
}
rtn = NativeMethods.SendMessageITEM(hHeader, HDM_SETITEM, newColumn, ref hdItem);
_previouslySortedColumn = newSortColumn;
}
private static extern IntPtr ItemSendMessage(IntPtr Handle, Int32 msg, IntPtr wParam, ref HDITEM lParam);
public static extern IntPtr SendMessageHeaderItem( IntPtr hWnd, UInt32 Msg, IntPtr wParam, ref HDITEM PtrHDITEM );
public static extern IntPtr SendMessage(
IntPtr hwnd, int msg, int wParam, ref HDITEM lParam);
private bool hasIcon(int column)
{
HDITEM hi = new HDITEM();
hi.mask = HDI_FORMAT;
SendMessage(_hHeaderWnd, HDM_GETITEMA, column, ref hi);
if ((hi.fmt & HDF_IMAGE) == HDF_IMAGE)
return true;
return false;
}
private void drawText(IntPtr hdc, int column, RECT tr)
{
HDITEM hi = new HDITEM();
hi.mask = HDI_TEXT | HDI_FORMAT | HDI_IMAGE;
hi.cchTextMax = 255;
hi.pszText = new String('0', 255);
SendMessage(_hHeaderWnd, HDM_GETITEMA, column, ref hi);
if (String.IsNullOrEmpty(hi.pszText))
return;
string text = hi.pszText;
using (Graphics g = Graphics.FromHdc(hdc))
{
using (StringFormat sf = new StringFormat())
{
g.SmoothingMode = SmoothingMode.AntiAlias;
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
sf.Trimming = StringTrimming.EllipsisCharacter;
if ((hi.fmt & HDF_RIGHT) == HDF_RIGHT)
{
sf.Alignment = StringAlignment.Far;
sf.LineAlignment = StringAlignment.Center;
}
else if ((hi.fmt & HDF_CENTER) == HDF_CENTER)
{
sf.Alignment = StringAlignment.Center;
sf.LineAlignment = StringAlignment.Center;
}
else
{
sf.Alignment = StringAlignment.Near;
sf.LineAlignment = StringAlignment.Center;
}
if ((hi.fmt & HDF_IMAGE) == HDF_IMAGE)
tr.Left += 18;
if ((hi.fmt & HDF_RTLREADING) == HDF_RTLREADING)
sf.FormatFlags = StringFormatFlags.DirectionRightToLeft;
if (hasButton(column))
tr.Right -= 12;
Control ct = (ListView)Control.FromHandle(GetParent(_hHeaderWnd));
SizeF sz = g.MeasureString(text, ct.Font);
tr.Top = (tr.Bottom / 2) - (int)sz.Height;
tr.Bottom = tr.Top + (int)sz.Height;
// draw the text
using (Brush captionBrush = new SolidBrush(ct.ForeColor))
g.DrawString(text, ct.Font, captionBrush, new RectangleF(tr.Left, tr.Top + 5, tr.Right - tr.Left, tr.Bottom - tr.Top), sf);
}
}
}
private void drawSortArrow(IntPtr hdc, int column, RECT tr)
{
if (Environment.OSVersion.Version.Major > 5)
{
HDITEM hi = new HDITEM();
hi.mask = HDI_FORMAT;
SendMessage(_hHeaderWnd, HDM_GETITEMA, column, ref hi);
int left = (tr.Right - tr.Left) / 2 - 4;
Rectangle ar = new Rectangle(tr.Left + left, 0, 12, 6);
if ((hi.fmt & (HDF_SORTDOWN)) == HDF_SORTDOWN)
{
if (!drawThemeArrow(hdc, ar, true))
drawArrow(hdc, ar, true);
}
else
{
if (!drawThemeArrow(hdc, ar, false))
drawArrow(hdc, ar, false);
}
}
}
public void SetSortIcons(int newSortColumn)
{
IntPtr hHeader = SendMessage(this.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
IntPtr newColumn = new IntPtr(newSortColumn);
IntPtr prevColumn = new IntPtr(_previouslySortedColumn);
HDITEM hdItem;
IntPtr rtn;
// Only update the previous item if it existed and if it was a different one.
if (_previouslySortedColumn != -1 && _previouslySortedColumn != newSortColumn)
{
// Clear icon from the previous column.
hdItem = new HDITEM();
hdItem.mask = HDI_FORMAT;
rtn = SendMessageITEM(hHeader, HDM_GETITEM, prevColumn, ref hdItem);
hdItem.fmt &= ~HDF_SORTDOWN & ~HDF_SORTUP;
rtn = SendMessageITEM(hHeader, HDM_SETITEM, prevColumn, ref hdItem);
}
// Set icon on the new column.
hdItem = new HDITEM();
hdItem.mask = HDI_FORMAT;
rtn = SendMessageITEM(hHeader, HDM_GETITEM, newColumn, ref hdItem);
if (this.Sorting == SortOrder.Ascending)
{
hdItem.fmt &= ~HDF_SORTDOWN;
hdItem.fmt |= HDF_SORTUP | HDF_BITMAP_ON_RIGHT;
}
else
{
hdItem.fmt &= ~HDF_SORTUP;
hdItem.fmt |= HDF_SORTDOWN;
}
rtn = SendMessageITEM(hHeader, HDM_SETITEM, newColumn, ref hdItem);
_previouslySortedColumn = newSortColumn;
}
/// <summary>
/// Setup the given column of the listview to show the given image to the right of the text.
/// If the image index is -1, any previous image is cleared
/// </summary>
/// <param name="list">The listview to send a m to</param>
/// <param name="columnIndex">Index of the column to modifiy</param>
/// <param name="order"></param>
/// <param name="imageIndex">Index into the small image list</param>
public static void SetColumnImage(ListView list, int columnIndex, SortOrder order, int imageIndex)
{
IntPtr hdrCntl = NativeMethods.GetHeaderControl(list);
if (hdrCntl.ToInt32() == 0)
return;
HDITEM item = new HDITEM();
item.mask = HDI_FORMAT;
IntPtr result = SendMessageHDItem(hdrCntl, HDM_GETITEM, columnIndex, ref item);
item.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN | HDF_IMAGE | HDF_BITMAP_ON_RIGHT);
if (NativeMethods.HasBuiltinSortIndicators()) {
if (order == SortOrder.Ascending)
item.fmt |= HDF_SORTUP;
if (order == SortOrder.Descending)
item.fmt |= HDF_SORTDOWN;
}
else {
item.mask |= HDI_IMAGE;
item.fmt |= (HDF_IMAGE | HDF_BITMAP_ON_RIGHT);
item.iImage = imageIndex;
}
result = SendMessageHDItem(hdrCntl, HDM_SETITEM, columnIndex, ref item);
}
internal static extern IntPtr SendMessageHDItem(IntPtr hWnd, int nMsg,
IntPtr wParam, ref HDITEM hdItem);
/// <summary>
///
/// </summary>
/// <param name="hWnd"></param>
/// <param name="msg"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <returns></returns>
public static int SendMessage(IntPtr hWnd, Enum msg, uint wParam, ref HDITEM lParam)
{
return SendMessage(hWnd, (uint)(WM)msg, wParam, ref lParam);
}
private void ShowHeaderIcon(ListView list, int columnIndex, SortOrder sortOrder)
{
if (columnIndex < 0 || columnIndex >= list.Columns.Count)
return;
IntPtr hHeader = SendMessage(list.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
ColumnHeader colHdr = list.Columns[columnIndex];
HDITEM hd = new HDITEM();
hd.mask = HDI_FORMAT;
HorizontalAlignment align = colHdr.TextAlign;
if (align == HorizontalAlignment.Left)
hd.fmt = HDF_LEFT | HDF_STRING | HDF_BITMAP_ON_RIGHT;
else if (align == HorizontalAlignment.Center)
hd.fmt = HDF_CENTER | HDF_STRING | HDF_BITMAP_ON_RIGHT;
else // HorizontalAlignment.Right
hd.fmt = HDF_RIGHT | HDF_STRING;
if (s_useNativeArrows)
{
if (sortOrder == SortOrder.Ascending)
hd.fmt |= HDF_SORTUP;
else if (sortOrder == SortOrder.Descending)
hd.fmt |= HDF_SORTDOWN;
}
else
{
hd.mask |= HDI_IMAGE;
if (sortOrder != SortOrder.None)
hd.fmt |= HDF_IMAGE;
hd.iImage = (int)sortOrder - 1;
}
SendMessage2(hHeader, HDM_SETITEM, new IntPtr(columnIndex), ref hd);
}
/// <summary>
/// Shows the header icon.
/// </summary>
/// <param name="columnIndex">Index of the column.</param>
/// <param name="sortOrder">The sort order.</param>
protected void ShowHeaderIcon(
int columnIndex,
SortOrder sortOrder )
{
if ( columnIndex >= 0 && columnIndex < this.Columns.Count )
{
IntPtr hHeader =
SendMessage(
this.Handle,
LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero );
ColumnHeader colHdr = this.Columns[columnIndex];
HDITEM hd = new HDITEM();
hd.mask = HDI_FORMAT;
HorizontalAlignment align = colHdr.TextAlign;
if ( align == HorizontalAlignment.Left )
{
hd.fmt = HDF_LEFT | HDF_STRING | HDF_BITMAP_ON_RIGHT;
}
else if ( align == HorizontalAlignment.Center )
{
hd.fmt = HDF_CENTER | HDF_STRING | HDF_BITMAP_ON_RIGHT;
}
else
{
Debug.Assert( align == HorizontalAlignment.Right );
hd.fmt = HDF_RIGHT | HDF_STRING;
}
if ( useNativeArrows )
{
if ( sortOrder == SortOrder.Ascending )
{
hd.fmt |= HDF_SORTUP;
}
else if ( sortOrder == SortOrder.Descending )
{
hd.fmt |= HDF_SORTDOWN;
}
}
else
{
hd.mask |= HDI_IMAGE;
if ( sortOrder != SortOrder.None )
{
hd.fmt |= HDF_IMAGE;
}
hd.iImage = (int)sortOrder - 1;
}
SendMessage2(
hHeader,
HDM_SETITEM,
new IntPtr( columnIndex ),
ref hd );
}
}
private static extern IntPtr SendMessage2( IntPtr Handle, int msg, IntPtr wParam, ref HDITEM lParam );
private int columnAtIndex(int column)
{
HDITEM hd = new HDITEM();
hd.mask = HDI_ORDER;
for (int i = 0; i < ColumnCount; i++)
{
if (SendMessage(_hHeaderWnd, HDM_GETITEMA, column, ref hd) != IntPtr.Zero)
return hd.iOrder;
}
return 0;
}
static extern int SendMessage(IntPtr hWnd, uint Msg, uint wParam, ref HDITEM lParam);
private void drawIcon(IntPtr hdc, int column, RECT tr)
{
IntPtr iml = (IntPtr)SendMessage(_hHeaderWnd, HDM_GETIMAGELIST, HDIS_STATE, 0);
if (iml != IntPtr.Zero)
{
int cx = 0;
int cy = 0;
HDITEM hi = new HDITEM();
ImageList_GetIconSize(iml, out cx, out cy);
hi.mask = HDI_IMAGE;
SendMessage(_hHeaderWnd, HDM_GETITEMA, column, ref hi);
tr.Top = (tr.Bottom - cy) / 2;
tr.Left += 4;
ImageList_DrawEx(iml, hi.iImage, hdc, tr.Left, tr.Top, cx, cy, CLR_NONE, 0, ILD_TRANSPARENT);
}
}
/// <summary>
/// Set the Header Column image
/// </summary>
/// <param name="list">ListView</param>
/// <param name="columnIndex">Current column index</param>
/// <param name="order">Current sort order</param>
/// <param name="showImage">Display image in column (turn on/off image)</param>
public static void SetHeaderImage(ListView list, int columnIndex, SortOrder order, bool showImage)
{
IntPtr _header;
HDITEM _hdItem = new HDITEM();
int _iconNumber = 0;
//set the image index based on sort order from the smallimagelist property
if( order == SortOrder.Ascending )
_iconNumber = 0;
else
_iconNumber = 1;
//get a handle to the listview header component
_header = GetHeader(list.Handle);
//set up the required structure members
_hdItem.mask = HDI.IMAGE | HDI.FORMAT;
_hdItem.pszText = list.Columns[columnIndex].Text;
// check to show the indicator image
if( showImage )
{
_hdItem.fmt = HDF.STRING | HDF.IMAGE | HDF.BITMAP_ON_RIGHT;
_hdItem.iImage = _iconNumber;
}
else
_hdItem.fmt = HDF.STRING;
//modify the header
SendMessage(_header, HDM.SETITEM, (uint)columnIndex, ref _hdItem);
}
private bool hasButton(int column)
{
if (Environment.OSVersion.Version.Major > 5)
{
HDITEM hi = new HDITEM();
hi.mask = HDI_FORMAT;
SendMessage(_hHeaderWnd, HDM_GETITEMA, columnAtIndex(column), ref hi);
if ((hi.fmt & HDF_SPLITBUTTON) == HDF_SPLITBUTTON)
return true;
}
return false;
}
/// <summary>
/// Set a column's position
/// </summary>
/// <param name="hwndLV">handle to listview</param>
/// <param name="ColumnIndex">Column Index to set</param>
/// <param name="iOrder">Position to set</param>
public static void SetColumnPosition(IntPtr hwndLV, int ColumnIndex, int iOrder)
{
HDITEM hdi = new HDITEM();
hdi.mask = HDI.ORDER;
hdi.iOrder = iOrder;
Header_SetItem(GetHeader(hwndLV), ColumnIndex, hdi);
}
private bool hasSort(int column)
{
if (Environment.OSVersion.Version.Major > 5)
{
HDITEM hi = new HDITEM();
hi.mask = HDI_FORMAT;
SendMessage(_hHeaderWnd, HDM_GETITEMA, column, ref hi);
if ((hi.fmt & (HDF_SORTUP | HDF_SORTDOWN)) > 0)
return true;
}
return false;
}
public static extern IntPtr SendMessageItem(IntPtr Handle, int msg, IntPtr wParam, ref HDITEM lParam);
public static extern IntPtr SendMessage(IntPtr hWnd, UInt32 msg, IntPtr wParam, ref HDITEM lParam);
/// <summary>
///
/// </summary>
/// <param name="hwndHD"></param>
/// <param name="index"></param>
/// <param name="mask"></param>
/// <returns></returns>
public static HDITEM Header_GetItem(IntPtr hwndHD, int index, HDI mask)
{
HDITEM rtn = new HDITEM();
rtn.mask = mask;
if((mask & HDI.TEXT) == HDI.TEXT)
{
rtn.pszText = new string('\0', 512);
rtn.cchTextMax = 512;
}
SendMessage(hwndHD, HDM.GETITEM, (uint)index, ref rtn);
return rtn;
}
internal static extern IntPtr SendMessage2(IntPtr Handle, Int32 msg,
IntPtr wParam, ref HDITEM lParam);
/// <summary>
///
/// </summary>
/// <param name="hwndHD"></param>
/// <param name="index"></param>
/// <param name="hdi"></param>
/// <returns></returns>
public static bool Header_SetItem(IntPtr hwndHD, int index, HDITEM hdi)
{
return SendMessage(hwndHD, HDM.SETITEM, (uint)index, ref hdi) != 0;
}
private static extern IntPtr SendMessageHDItem(IntPtr hWnd, int msg, int wParam, ref HDITEM hdi);
public static void SetListViewHeaderArrow(ListView listView, int columnIndex, bool isAscending)
{
IntPtr header = (IntPtr)SendMessage(listView.Handle, 0x1000 + 31 /* LVM_GETHEADER */, 0, 0);
for (int i = 0; i < listView.Columns.Count; i++)
{
HDITEM hdi = new HDITEM();
hdi.mask = 0x0004 /* HDI_FORMAT */;
SendMessage(header, 0x1200 + 11 /* HDM_GETITEM */, (uint)i, ref hdi);
hdi.fmt &= ~(0x0200 /* HDF_SORTDOWN */ | 0x0400 /* HDF_SORTUP */);
if (i == columnIndex)
{
hdi.fmt |= isAscending ? 0x0400 /* HDF_SORTUP */ : 0x0200 /* HDF_SORTDOWN */;
}
SendMessage(header, 0x1200 + 12 /* HDM_SETITEM */, (uint)i, ref hdi);
}
SendMessage(listView.Handle, 0x1000 + 140 /* LVM_SETSELECTEDCOLUMN */, (uint)columnIndex, 0);
}
