public void SetSortIcon(int columnIndex, SortOrder order)
        {
            IntPtr columnHeader = this.HeaderHandle;

            for (int columnNumber = 0; columnNumber <= this.Columns.Count - 1; columnNumber++)
            {
                // Get current listview column info
                var lvcol = new NativeMethods.LVCOLUMN(NativeMethods.ListViewColumMask.Fmt);
                NativeMethods.SendMessage(this.Handle, NativeMethods.ListViewMessage.GetColumn, columnNumber, lvcol);

                // Get current header info
                var hditem = new NativeMethods.HDITEM(NativeMethods.HeaderItemMask.Format | NativeMethods.HeaderItemMask.DISetItem);
                NativeMethods.SendMessage(columnHeader, NativeMethods.HeaderMessage.GetItem, columnNumber, hditem);

                // Update header with column info
                hditem.Format |= (NativeMethods.HeaderItemFormat)((uint)lvcol.Format & 0x1001803);
                if ((lvcol.Format & NativeMethods.ListViewColumnFormat.NoTitle) == 0)
                {
                    hditem.ShowText = true;
                }

                // Set header image info
                if (!(order == SortOrder.None) && columnNumber == columnIndex)
                {
                    hditem.ImageDisplay = (order == System.Windows.Forms.SortOrder.Descending) ? NativeMethods.HeaderItemImageDisplay.DownArrow : NativeMethods.HeaderItemImageDisplay.UpArrow;
                }
                else
                {
                    hditem.ImageDisplay = NativeMethods.HeaderItemImageDisplay.None;
                }

                // Update header
                NativeMethods.SendMessage(columnHeader, NativeMethods.HeaderMessage.SetItem, columnNumber, hditem);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Shows the arrow on the specified header, according to the
        /// sorting order.
        /// </summary>
        /// <param name="list">ListView control.</param>
        /// <param name="columnIndex">Index of column.</param>
        /// <param name="sortOrder">Sorting order. SortOrder.None to hide the
        /// arrow.</param>
        private static void ShowHeaderIcon(ListView list, int columnIndex, SortOrder sortOrder)
        {
            if (columnIndex < 0 || columnIndex >= list.Columns.Count)
            {
                return;
            }

            IntPtr hHeader = NativeMethods.SendMessage(list.Handle,
                                                       NativeMethods.LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);

            ColumnHeader colHdr = list.Columns[columnIndex];

            NativeMethods.HDITEM hd = new NativeMethods.HDITEM();
            hd.mask = NativeMethods.HDI_FORMAT;

            HorizontalAlignment align = colHdr.TextAlign;

            if (align == HorizontalAlignment.Left)
            {
                hd.fmt = NativeMethods.HDF_LEFT | NativeMethods.HDF_STRING |
                         NativeMethods.HDF_BITMAP_ON_RIGHT;
            }
            else if (align == HorizontalAlignment.Center)
            {
                hd.fmt = NativeMethods.HDF_CENTER | NativeMethods.HDF_STRING |
                         NativeMethods.HDF_BITMAP_ON_RIGHT;
            }
            else
            {
                hd.fmt = NativeMethods.HDF_RIGHT | NativeMethods.HDF_STRING;
            }

            if (nativeArrows)
            {
                if (sortOrder == SortOrder.Ascending)
                {
                    hd.fmt |= NativeMethods.HDF_SORTUP;
                }
                else if (sortOrder == SortOrder.Descending)
                {
                    hd.fmt |= NativeMethods.HDF_SORTDOWN;
                }
            }
            else
            {
                hd.mask |= NativeMethods.HDI_IMAGE;

                if (sortOrder != SortOrder.None)
                {
                    hd.fmt |= NativeMethods.HDF_IMAGE;
                }

                hd.iImage = (int)sortOrder - 1;
            }

            NativeMethods.SendMessage2(hHeader, NativeMethods.HDM_SETITEM,
                                       new IntPtr(columnIndex), ref hd);
        }
Esempio n. 3
0
        public void SetSortIcon(int column, SortIcon mode)
        {
            if (DesignMode || !IsHandleCreated || View != View.Details)
            {
                return;
            }

            if (column < 0 || column > Columns.Count)
            {
                throw new ArgumentOutOfRangeException("column", column, "Invalid column number");
            }

            IntPtr hHeader = NativeMethods.SendMessage(Handle, NativeMethods.LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);
            IntPtr col     = new IntPtr(column);

            NativeMethods.HDITEM hdItem = new NativeMethods.HDITEM();
            IntPtr rtn;

            // Only update the previous item if it existed and if it was a different one.
            hdItem.mask = NativeMethods.HDI_FORMAT;
            rtn         = NativeMethods.SendMessage(hHeader, NativeMethods.HDM_GETITEM, col, ref hdItem);

            hdItem.mask = NativeMethods.HDI_FORMAT;
            hdItem.fmt &= ~(NativeMethods.HDF_SORTDOWN | NativeMethods.HDF_SORTUP | NativeMethods.HDF_CHECKBOX | NativeMethods.HDF_CHECKED);
            switch (mode)
            {
            case SortIcon.Ascending:
                hdItem.fmt |= NativeMethods.HDF_SORTUP;
                break;

            case SortIcon.Descending:
                hdItem.fmt |= NativeMethods.HDF_SORTDOWN;
                break;
            }

            if (column == 0 && CheckBoxes && ShowSelectAllCheckBox && VSVersion.VistaOrLater)
            {
                if (!_setHeaderStyle)
                {
                    _setHeaderStyle = true;
                    int style = NativeMethods.GetWindowLongW(hHeader, NativeMethods.GWL_STYLE);

                    NativeMethods.SetWindowLongW(hHeader, NativeMethods.GWL_STYLE, style | NativeMethods.HDS_CHECKBOXES);
                }

                hdItem.fmt |= NativeMethods.HDF_CHECKBOX;

                if (SelectAllChecked)
                {
                    hdItem.fmt |= NativeMethods.HDF_CHECKED;
                }
            }

            rtn = NativeMethods.SendMessage(hHeader, NativeMethods.HDM_SETITEM, col, ref hdItem);

            GC.KeepAlive(HeaderHeight);
        }
        private int GetItemFromIndex(int index)
        {
            NativeMethods.HDITEM item = new NativeMethods.HDITEM();
            item.Init();
            item.mask = NativeMethods.HDI_ORDER;

            // Send the message...
            if (!XSendMessage.GetItem(_hwnd, index, ref item))
            {
                return(-1);
            }

            return(item.iOrder);
        }
            // This is new with v6 comctrl on Vista
            private bool IsSplitButton()
            {
                NativeMethods.HDITEM item = new NativeMethods.HDITEM();
                item.Init();
                item.mask = NativeMethods.HDI_FORMAT;

                // Send the message...
                if (XSendMessage.GetItem(_hwnd, _item, ref item))
                {
                    if ((item.fmt & NativeMethods.HDF_SPLITBUTTON) != 0)
                    {
                        return(true);
                    }
                }

                return(false);
            }
Esempio n. 6
0
        public void SetSortIcon(int columnIndex, SortOrder order)
        {
            IntPtr columnHeader = NativeMethods.SendMessage(Handle, NativeMethods.LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);

            for (int columnNumber = 0; columnNumber <= Columns.Count - 1; columnNumber++)
            {
                var columnPtr = new IntPtr(columnNumber);
                var item      = new NativeMethods.HDITEM
                {
                    mask = NativeMethods.HDITEM.Mask.Format
                };

                if (NativeMethods.SendMessage(columnHeader, NativeMethods.HDM_GETITEM, columnPtr, ref item) == IntPtr.Zero)
                {
                    throw new Win32Exception();
                }

                if (order != SortOrder.None && columnNumber == columnIndex)
                {
                    switch (order)
                    {
                    case SortOrder.Ascending:
                        item.fmt &= ~NativeMethods.HDITEM.Format.SortDown;
                        item.fmt |= NativeMethods.HDITEM.Format.SortUp;
                        break;

                    case SortOrder.Descending:
                        item.fmt &= ~NativeMethods.HDITEM.Format.SortUp;
                        item.fmt |= NativeMethods.HDITEM.Format.SortDown;
                        break;
                    }
                }
                else
                {
                    item.fmt &= ~NativeMethods.HDITEM.Format.SortDown & ~NativeMethods.HDITEM.Format.SortUp;
                }

                if (NativeMethods.SendMessage(columnHeader, NativeMethods.HDM_SETITEM, columnPtr, ref item) == IntPtr.Zero)
                {
                    throw new Win32Exception();
                }
            }
        }
        private void SortListViewItems(int columnIndex)
        {
            if (columnIndex < 0 || columnIndex >= this.artifactListView.Columns.Count)
                return;

            ListItemComparer listItemComparer = new ListItemComparer((columnIndex == 0) ? true : false, this.sortListViewAscending);
            this.artifactListView.ListViewItemSorter = listItemComparer;

            if (this.artifactListView.SelectedItems.Count > 0)
                this.artifactListView.SelectedItems[0].EnsureVisible();

            //Update the bitmap for the sorted column
            IntPtr headerWindow = NativeMethods.ListView_GetHeader(this.artifactListView.Handle);
            NativeMethods.HDITEM headerItem = new NativeMethods.HDITEM();
            headerItem.mask = NativeMethods.HDI_FORMAT | NativeMethods.HDI_BITMAP;
            for (int i = 0; i < this.artifactListView.Columns.Count; i++)
            {
                if (NativeMethods.Header_GetItem(headerWindow, i, headerItem))
                {
                    headerItem.fmt &= ~(NativeMethods.HDF_BITMAP | NativeMethods.HDF_BITMAP_ON_RIGHT);
                    headerItem.hbm = IntPtr.Zero;
                    NativeMethods.Header_SetItem(headerWindow, i, headerItem);
                }
            }

            if (NativeMethods.Header_GetItem(headerWindow, columnIndex, headerItem))
            {
                headerItem.mask = NativeMethods.HDI_FORMAT | NativeMethods.HDI_BITMAP;
                headerItem.fmt |= NativeMethods.HDF_BITMAP | NativeMethods.HDF_BITMAP_ON_RIGHT;
                headerItem.hbm = (this.sortListViewAscending) ? this.bitmapSortUp : this.bitmapSortDown;
                NativeMethods.Header_SetItem(headerWindow, columnIndex, headerItem);
            }
        }
Esempio n. 8
0
        public static bool SetSortIcon(ListView lv, int iColumn, SortOrder so)
        {
            if (lv == null)
            {
                Debug.Assert(false); return(false);
            }

            try
            {
                IntPtr hHeader = NativeMethods.SendMessage(lv.Handle,
                                                           NativeMethods.LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero);

                for (int i = 0; i < lv.Columns.Count; ++i)
                {
                    int nGetMsg = ((WinUtil.IsWindows2000 || WinUtil.IsWindowsXP ||
                                    WinUtil.IsAtLeastWindowsVista) ? NativeMethods.HDM_GETITEMW :
                                   NativeMethods.HDM_GETITEMA);
                    int nSetMsg = ((WinUtil.IsWindows2000 || WinUtil.IsWindowsXP ||
                                    WinUtil.IsAtLeastWindowsVista) ? NativeMethods.HDM_SETITEMW :
                                   NativeMethods.HDM_SETITEMA);
                    IntPtr pColIndex = new IntPtr(i);

                    NativeMethods.HDITEM hdItem = new NativeMethods.HDITEM();
                    hdItem.mask = NativeMethods.HDI_FORMAT;

                    if (NativeMethods.SendMessageHDItem(hHeader, nGetMsg, pColIndex,
                                                        ref hdItem) == IntPtr.Zero)
                    {
                        Debug.Assert(false);
                    }

                    if ((i != iColumn) || (so == SortOrder.None))
                    {
                        hdItem.fmt &= (~NativeMethods.HDF_SORTUP &
                                       ~NativeMethods.HDF_SORTDOWN);
                    }
                    else
                    {
                        if (so == SortOrder.Ascending)
                        {
                            hdItem.fmt &= ~NativeMethods.HDF_SORTDOWN;
                            hdItem.fmt |= NativeMethods.HDF_SORTUP;
                        }
                        else                         // SortOrder.Descending
                        {
                            hdItem.fmt &= ~NativeMethods.HDF_SORTUP;
                            hdItem.fmt |= NativeMethods.HDF_SORTDOWN;
                        }
                    }

                    Debug.Assert(hdItem.mask == NativeMethods.HDI_FORMAT);
                    if (NativeMethods.SendMessageHDItem(hHeader, nSetMsg, pColIndex,
                                                        ref hdItem) == IntPtr.Zero)
                    {
                        Debug.Assert(false);
                    }
                }
            }
            catch (Exception) { Debug.Assert(false); return(false); }

            return(true);
        }