在"详细信息视图"中隐藏Windows窗体ListView列,而不删除列或将其调整为零

Question

我在C#Net 2.0 Windows Forms中有一个ListView,在应用程序启动时大约有十列填充了数据.数据量巨大,因此不能快速重新加载.我的ListView具有详细信息视图,允许用户单独调整每列的大小.

用户应能够一次隐藏十列或多列中的任何一列,并在非特定行中随时取消隐藏列.隐藏列时不应删除数据.

我尝试了以下的事情但结果并不令人满意:

1)调整大小为0的列的大小将使其稍微消失,直到用户开始使用列.用户会意外地将其重新调整大小,因为在我的ListView中,允许用户手动调整每列的大小.

2)只是删除列出现以下问题:当我尝试将列添加回来时,列不记得它的位置和大小.这个位置是主要问题,我将尝试解释原因.如果我的用户决定首先隐藏"第2列"然后"第3列"并且用户稍后在2之前取消隐藏3,则"索引2"不存在,因此我无法在第3号索引处插入并且异常上升.即使我在删除之前记住了索引位置,也不能简单地将列放回到该索引,因为我不知道以前的列是否已经隐藏过,或者哪些列在之前和之后丢失或隐藏或未隐藏.所以场景可能是这样的:1显示,2隐藏,3隐藏,4显示,5隐藏,6隐藏,7隐藏,8显示,9隐藏,10隐藏.

可能的解决方案"1)"和"2)"在场景中自动排除.更好的是甚至使列的宽度为零,但由于我的用户应该能够随时根据需要调整列的大小,并且调整大小为零,因此无法从用户隐藏.用户将通过调整大小取消隐藏它,我的系统会认为它仍然是隐藏的等等.如果隐藏的列可以只是"重新调整大小"或者我们如何命名其他内容,它看起来不专业.

有人有更好的主意吗？为什么listView列没有"可见"或"隐藏"属性,我想知道？如果之前有人这样做,请发布解决方案.

我必须补充一点,我在添加数据时使用listview中所有列的自动调整大小.因此,下面的答案不起作用.resize事件无法检测-1的宽度.添加数据时,将调整宽度为0的"所有不可见列"的大小.由于listview会删除与列长度重叠的数据,因此我需要永久自动化它.Explorer没有这个问题,因为它使列适合数据的长度.C#没有这样的高级列表视图,这里我每次添加数据时都要将列设置为-1.在这个概念中,用于隐藏列的column.width = 0的概念不起作用.

Answer 1

好的,你的问题实际上是如何隐藏ListView列？.许多人都在网上询问过这个问题.我试过搜索很多但却找不到任何东西.我最终得到了唯一的解决方案:将列宽设置为零.这将有一些技巧:

//This will try hiding the column at index 1
listView1.Columns[1].Width = 0;
//ColumnWidthChanging event handler of your ListView
private void listView1_ColumnWidthChanging(object sender, ColumnWidthChangingEventArgs e){
  if(e.ColumnIndex == 1){
     e.Cancel = true;
     e.NewWidth = 0;
  }
}

它几乎完美地工作.然而,当用户将鼠标移动pipe到隐藏列的位置时,会出现一个Cursor指示器,通知用户这里有一个零宽度列,只需按住鼠标并拖动以调整其大小.当然,用户无法将其从Zero调整大小,因为我们正在制作Cancel它NewWidth = 0(如上面的代码那样).但Cursor通知这样的操作使它有点讨厌,这是显示问题的屏幕截图:

要解决这个问题并不容易.至少这就是我的感受.我想到了这个似乎行之有效的解决方案.我们的想法是我们必须检测鼠标是否在隐藏列的管道附近,我们必须设置Cursor = Cursors.Arrow.以下是我认为适合您的全班:

public class CustomListView : ListView
{
    [DllImport("user32")]
    private static extern bool EnumChildWindows(IntPtr parentHwnd, EnumChildProc proc, object lParam);
    delegate bool EnumChildProc(IntPtr childHwnd, object lParam);
    public CustomListView()
    {
        VisibleChanged += (s, e) =>
        {
            if (Visible && headerHandle == IntPtr.Zero&&!DesignMode)
            {
                EnumChildWindows(Handle, EnumChild, null);
                headerProc = new HeaderProc(this);
                headerProc.AssignHandle(headerHandle);
            }
        };
        columnPipeLefts[0] = 0;
    }      
    //Save the Handle to the Column Headers, a ListView has only child Window which is used to render Column headers  
    IntPtr headerHandle;
    //This is used use to hook into the message loop of the Column Headers
    HeaderProc headerProc;        
    private bool EnumChild(IntPtr childHwnd, object lParam)
    {
        headerHandle = childHwnd;
        return true;
    }
    //Updated code
    protected override void WndProc(ref Message m)
    {
        if (m.Msg == 0x101e&&hiddenColumnIndices.Contains(m.WParam.ToInt32()))//WM_SETCOLUMNWIDTH = 0x101e
        {                
            if(m.LParam.ToInt32() > 0) hiddenColumnWidths[m.WParam.ToInt32()] = m.LParam.ToInt32();                    
            return;//Discard the message changing hidden column width so that it won't be shown again.                
        }
        base.WndProc(ref m);
    }
    //Save the column indices which are hidden
    List<int> hiddenColumnIndices = new List<int>();
    //Save the width of hidden columns
    Dictionary<int, int> hiddenColumnWidths = new Dictionary<int, int>();
    //Save the Left (X-Position) of the Pipes which separate Column Headers.
    Dictionary<int, int> columnPipeLefts = new Dictionary<int, int>();
    protected override void OnColumnWidthChanging(ColumnWidthChangingEventArgs e)
    {
        if (hiddenColumnIndices.Contains(e.ColumnIndex))
        {
            e.Cancel = true;
            e.NewWidth = 0;
        }
        base.OnColumnWidthChanging(e);
    }
    //We need to update columnPipeLefts whenever the width of any column changes
    protected override void OnColumnWidthChanged(ColumnWidthChangedEventArgs e)
    {            
        base.OnColumnWidthChanged(e);
        UpdateColumnPipeLefts(Columns[e.ColumnIndex].DisplayIndex + 1);
    }
    int index = -1;
    protected override void OnColumnReordered(ColumnReorderedEventArgs e)
    {
        int i = Math.Min(e.NewDisplayIndex, e.OldDisplayIndex);
        index = index != -1 ? Math.Min(i + 1, index) : i + 1;            
        base.OnColumnReordered(e);                                
    }
    //This is used to update the columnPipeLefts every reordering columns or resizing columns.
    private void UpdateColumnPipeLefts(int fromIndex)
    {
        int w = fromIndex > 0 ? columnPipeLefts[fromIndex - 1] : 0;
        for (int i = fromIndex; i < Columns.Count; i++)
        {
            w += i > 0 ? Columns.OfType<ColumnHeader>().Where(k=>k.DisplayIndex == i - 1).Single().Width : 0;
            columnPipeLefts[i] = w;
        }
    }
    //This is used to hide a column with ColumnHeader passed in
    public void HideColumn(ColumnHeader col)
    {
        if (!hiddenColumnIndices.Contains(col.Index))
        {                
            hiddenColumnWidths[col.Index] = col.Width;//Save the current width to restore later                
            col.Width = 0;//Hide the column
            hiddenColumnIndices.Add(col.Index);
        }
    }
    //This is used to hide a column with column index passed in
    public void HideColumn(int columnIndex)
    {
        if (columnIndex < 0 || columnIndex >= Columns.Count) return;
        if (!hiddenColumnIndices.Contains(columnIndex))
        {
            hiddenColumnWidths[columnIndex] = Columns[columnIndex].Width;//Save the current width to restore later                
            Columns[columnIndex].Width = 0;//Hide the column
            hiddenColumnIndices.Add(columnIndex);
        }
    }
    //This is used to show a column with ColumnHeader passed in
    public void ShowColumn(ColumnHeader col)
    {
        hiddenColumnIndices.Remove(col.Index);
        if(hiddenColumnWidths.ContainsKey(col.Index))
           col.Width = hiddenColumnWidths[col.Index];//Restore the Width to show the column
        hiddenColumnWidths.Remove(col.Index);
    }
    //This is used to show a column with column index passed in
    public void ShowColumn(int columnIndex)
    {
        if (columnIndex < 0 || columnIndex >= Columns.Count) return;
        hiddenColumnIndices.Remove(columnIndex);
        if(hiddenColumnWidths.ContainsKey(columnIndex))
           Columns[columnIndex].Width = hiddenColumnWidths[columnIndex];//Restore the Width to show the column            
        hiddenColumnWidths.Remove(columnIndex);
    }
    //The helper class allows us to hook into the message loop of the Column Headers
    private class HeaderProc : NativeWindow
    {
        [DllImport("user32")]
        private static extern int SetCursor(IntPtr hCursor);
        public HeaderProc(CustomListView listView)
        {
            this.listView = listView;
        }
        bool mouseDown;
        CustomListView listView;
        protected override void WndProc(ref Message m)
        {                
            if (m.Msg == 0x200 && listView!=null && !mouseDown)
            {
                int x = (m.LParam.ToInt32() << 16) >> 16;
                if (IsSpottedOnAnyHiddenColumnPipe(x)) return;
            }
            if (m.Msg == 0x201) { 
                mouseDown = true;
                int x = (m.LParam.ToInt32() << 16) >> 16;
                IsSpottedOnAnyHiddenColumnPipe(x);
            }
            if (m.Msg == 0x202) mouseDown = false;
            if (m.Msg == 0xf && listView.index != -1 && MouseButtons == MouseButtons.None) { //WM_PAINT = 0xf
                listView.UpdateColumnPipeLefts(listView.index); 
                listView.index = -1; 
            };
            base.WndProc(ref m);
        }
        private bool IsSpottedOnAnyHiddenColumnPipe(int x)
        {                
            foreach (int i in listView.hiddenColumnIndices.Select(j=>listView.Columns[j].DisplayIndex))
            {
                if (x > listView.columnPipeLefts[i] - 1 && x < listView.columnPipeLefts[i] + 15)
                {
                    SetCursor(Cursors.Arrow.Handle);
                    return true;
                }
            }
            return false;
        }
    }
}