<legend id='CkKDN'><style id='CkKDN'><dir id='CkKDN'><q id='CkKDN'></q></dir></style></legend>

    <small id='CkKDN'></small><noframes id='CkKDN'>

    <i id='CkKDN'><tr id='CkKDN'><dt id='CkKDN'><q id='CkKDN'><span id='CkKDN'><b id='CkKDN'><form id='CkKDN'><ins id='CkKDN'></ins><ul id='CkKDN'></ul><sub id='CkKDN'></sub></form><legend id='CkKDN'></legend><bdo id='CkKDN'><pre id='CkKDN'><center id='CkKDN'></center></pre></bdo></b><th id='CkKDN'></th></span></q></dt></tr></i><div id='CkKDN'><tfoot id='CkKDN'></tfoot><dl id='CkKDN'><fieldset id='CkKDN'></fieldset></dl></div>
  • <tfoot id='CkKDN'></tfoot>

          <bdo id='CkKDN'></bdo><ul id='CkKDN'></ul>
      1. 如何禁用列表框中的选定项目

        How To Disable Selected Item In List Box(如何禁用列表框中的选定项目)

            <tbody id='AvxQa'></tbody>

            <small id='AvxQa'></small><noframes id='AvxQa'>

            • <bdo id='AvxQa'></bdo><ul id='AvxQa'></ul>
              <legend id='AvxQa'><style id='AvxQa'><dir id='AvxQa'><q id='AvxQa'></q></dir></style></legend>

            • <tfoot id='AvxQa'></tfoot>
            • <i id='AvxQa'><tr id='AvxQa'><dt id='AvxQa'><q id='AvxQa'><span id='AvxQa'><b id='AvxQa'><form id='AvxQa'><ins id='AvxQa'></ins><ul id='AvxQa'></ul><sub id='AvxQa'></sub></form><legend id='AvxQa'></legend><bdo id='AvxQa'><pre id='AvxQa'><center id='AvxQa'></center></pre></bdo></b><th id='AvxQa'></th></span></q></dt></tr></i><div id='AvxQa'><tfoot id='AvxQa'></tfoot><dl id='AvxQa'><fieldset id='AvxQa'></fieldset></dl></div>
                  本文介绍了如何禁用列表框中的选定项目的处理方法,对大家解决问题具有一定的参考价值,需要的朋友们下面随着跟版网的小编来一起学习吧!

                  问题描述

                  我的 WinForms 应用程序中有一个 ListBox,我想禁用该列表中的某些项目,例如,如果我右键单击一个项目,它会被禁用,如果我左键单击一个禁用的项目,它应该被启用.我怎样才能做到这一点?非常感谢

                  I have a ListBox in my WinForms application and I want to disable some items on that list, for example if I right click on an item , it gets disabled and if I left click on a disabled item it should be enabled. How can I do this? Thanks very much

                  推荐答案

                  我找到了办法.为此,我们必须创建一个自定义 ListBox 控件.:)

                  I found a way. We must create a custom ListBox Control to do this. :)

                  使用它,您可以启用或禁用带有项目索引的项目.

                  With it, you can enable or disable items with item index.

                  using System;
                  using System.Collections.Generic;
                  using System.Text;
                  using System.Windows.Forms;
                  using System.Drawing;
                  using System.Collections;
                  using System.ComponentModel;
                  using System.Globalization;
                  using System.Security;
                  using System.Runtime.InteropServices;
                  
                  namespace Netdev.Windows.Forms
                  {
                      public class ListBox : System.Windows.Forms.ListBox
                      {
                          public event EventHandler<IndexEventArgs> DisabledItemSelected;
                          protected virtual void OnDisabledItemSelected(object sender, IndexEventArgs e)
                          {
                              if (DisabledItemSelected != null)
                              {
                                  DisabledItemSelected(sender, e);
                              }
                          }
                          public ListBox()
                          {
                  
                              DrawMode = System.Windows.Forms.DrawMode.OwnerDrawFixed;
                              disabledIndices = new DisabledIndexCollection(this);
                          }
                  
                          private int originalHeight = 0;
                          private bool fontChanged = false;
                  
                          protected override void OnFontChanged(EventArgs e)
                          {
                              base.OnFontChanged(e);
                              fontChanged = true;
                              this.ItemHeight = FontHeight;
                              this.Height = GetPreferredHeight();
                              fontChanged = false;
                  
                          }
                  
                          protected override void OnResize(EventArgs e)
                          {
                              base.OnResize(e);
                              if (!fontChanged)
                                  this.originalHeight = this.Height;
                          }
                  
                          public void DisableItem(int index)
                          {
                              disabledIndices.Add(index);
                          }
                  
                          public void EnableItem(int index)
                          {
                              disabledIndices.Remove(index);
                          }
                  
                  
                  
                          private int GetPreferredHeight()
                          {
                              if (!IntegralHeight)
                                  return this.Height;
                  
                              int currentHeight = this.originalHeight;
                              int preferredHeight = PreferredHeight;
                              if (currentHeight < preferredHeight)
                              {
                                  // Calculate how many items currentheigh can hold.
                                  int number = currentHeight / ItemHeight;
                  
                                  if (number < Items.Count)
                                  {
                                      preferredHeight = number * ItemHeight;
                                      int delta = currentHeight - preferredHeight;
                                      if (ItemHeight / 2 <= delta)
                                      {
                                          preferredHeight += ItemHeight;
                                      }
                                      preferredHeight += (SystemInformation.BorderSize.Height * 4) + 3;
                                  }
                                  else
                                  {
                                      preferredHeight = currentHeight;
                                  }
                              }
                              else
                                  preferredHeight = currentHeight;
                  
                              return preferredHeight;
                  
                          }
                  
                          protected override void OnSelectedIndexChanged(EventArgs e)
                          {
                              int currentSelectedIndex = SelectedIndex;
                              List<int> selectedDisabledIndices = new List<int>();
                  
                              for (int i = 0; i < SelectedIndices.Count; i++)
                              {
                                  if (disabledIndices.Contains(SelectedIndices[i]))
                                  {
                                      selectedDisabledIndices.Add(SelectedIndices[i]);
                                      SelectedIndices.Remove(SelectedIndices[i]);
                                  }
                              }
                              foreach (int index in selectedDisabledIndices)
                              {
                                  IndexEventArgs args = new IndexEventArgs(index);
                                  OnDisabledItemSelected(this, args);
                              }
                              if (currentSelectedIndex == SelectedIndex)
                                  base.OnSelectedIndexChanged(e);
                          }
                  
                          protected override void OnDrawItem(System.Windows.Forms.DrawItemEventArgs e)
                          {
                              base.OnDrawItem(e);
                              if (DesignMode && Items.Count == 0)
                              {
                                  return;
                              }
                  
                              if (e.Index != ListBox.NoMatches)
                              {
                                  object item = this.Items[e.Index];
                                  if (disabledIndices.Contains(e.Index))
                                  {
                                      e.Graphics.FillRectangle(SystemBrushes.InactiveBorder, e.Bounds);
                                      if (item != null)
                                      {
                                          e.Graphics.DrawString(item.ToString(), e.Font, SystemBrushes.GrayText, e.Bounds);
                                      }
                                  }
                                  else
                                  {
                                      if (SelectionMode == System.Windows.Forms.SelectionMode.None)
                                      {
                                          e.Graphics.FillRectangle(SystemBrushes.Window, e.Bounds);
                                          if (item != null)
                                          {
                                              e.Graphics.DrawString(item.ToString(), e.Font, SystemBrushes.WindowText, e.Bounds);
                                          }
                                      }
                                      else
                                      {
                                          if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
                                          {
                                              e.Graphics.FillRectangle(SystemBrushes.Highlight, e.Bounds);
                                              e.DrawFocusRectangle();
                                              if (item != null)
                                              {
                                                  e.Graphics.DrawString(item.ToString(), e.Font, SystemBrushes.HighlightText, e.Bounds);
                                              }
                                          }
                                          else
                                          {
                                              e.Graphics.FillRectangle(SystemBrushes.Window, e.Bounds);
                                              if (item != null)
                                              {
                                                  e.Graphics.DrawString(item.ToString(), e.Font, SystemBrushes.WindowText, e.Bounds);
                                              }
                                          }
                                      }
                                  }
                              }
                          }
                  
                          private DisabledIndexCollection disabledIndices;
                  
                          public DisabledIndexCollection DisabledIndices
                          {
                              get { return disabledIndices; }
                          }
                  
                          public class DisabledIndexCollection : IList, ICollection, IEnumerable
                          {
                              // Fields
                              private ListBox owner;
                              private List<int> innerList = new List<int>();
                  
                  
                              // Methods
                              public DisabledIndexCollection(ListBox owner)
                              {
                                  this.owner = owner;
                              }
                  
                              public void Add(int index)
                              {
                                  if (((this.owner != null) && (this.owner.Items != null)) && ((index != -1) && !this.Contains(index)))
                                  {
                                      innerList.Add(index);
                                      this.owner.SetSelected(index, false);
                                  }
                              }
                  
                              public void Clear()
                              {
                                  if (this.owner != null)
                                  {
                                      innerList.Clear();
                                  }
                              }
                  
                              public bool Contains(int selectedIndex)
                              {
                                  return (this.IndexOf(selectedIndex) != -1);
                              }
                  
                              public void CopyTo(Array destination, int index)
                              {
                                  int count = this.Count;
                                  for (int i = 0; i < count; i++)
                                  {
                                      destination.SetValue(this[i], (int)(i + index));
                                  }
                              }
                  
                              public IEnumerator GetEnumerator()
                              {
                                  return new SelectedIndexEnumerator(this);
                              }
                  
                              public int IndexOf(int selectedIndex)
                              {
                                  if ((selectedIndex >= 0) && (selectedIndex < this.owner.Items.Count))
                                  {
                                      for (int index = 0; index < innerList.Count; index++)
                                      {
                                          if (innerList[index] == selectedIndex)
                                              return index;
                                      }
                                  }
                                  return -1;
                              }
                  
                              public void Remove(int index)
                              {
                                  if (((this.owner != null) && (this.owner.Items != null)) && ((index != -1) && this.Contains(index)))
                                  {
                                      innerList.Remove(index);
                                      this.owner.SetSelected(index, false);
                                  }
                              }
                  
                              int IList.Add(object value)
                              {
                                  throw new NotSupportedException("ListBoxSelectedIndexCollectionIsReadOnly");
                              }
                  
                              void IList.Clear()
                              {
                                  throw new NotSupportedException("ListBoxSelectedIndexCollectionIsReadOnly");
                              }
                  
                              bool IList.Contains(object selectedIndex)
                              {
                                  return ((selectedIndex is int) && this.Contains((int)selectedIndex));
                              }
                  
                              int IList.IndexOf(object selectedIndex)
                              {
                                  if (selectedIndex is int)
                                  {
                                      return this.IndexOf((int)selectedIndex);
                                  }
                                  return -1;
                              }
                  
                              void IList.Insert(int index, object value)
                              {
                                  throw new NotSupportedException("ListBoxSelectedIndexCollectionIsReadOnly");
                              }
                  
                              void IList.Remove(object value)
                              {
                                  throw new NotSupportedException("ListBoxSelectedIndexCollectionIsReadOnly");
                              }
                  
                              void IList.RemoveAt(int index)
                              {
                                  throw new NotSupportedException("ListBoxSelectedIndexCollectionIsReadOnly");
                              }
                  
                              // Properties
                              [Browsable(false)]
                              public int Count
                              {
                                  get
                                  {
                                      return this.innerList.Count;
                                  }
                              }
                  
                              public bool IsReadOnly
                              {
                                  get
                                  {
                                      return true;
                                  }
                              }
                  
                              public int this[int index]
                              {
                                  get
                                  {
                                      return IndexOf(index);
                                  }
                              }
                  
                              bool ICollection.IsSynchronized
                              {
                                  get
                                  {
                                      return true;
                                  }
                              }
                  
                              object ICollection.SyncRoot
                              {
                                  get
                                  {
                                      return this;
                                  }
                              }
                  
                              bool IList.IsFixedSize
                              {
                                  get
                                  {
                                      return true;
                                  }
                              }
                  
                              object IList.this[int index]
                              {
                                  get
                                  {
                                      return this[index];
                                  }
                                  set
                                  {
                                      throw new NotSupportedException("ListBoxSelectedIndexCollectionIsReadOnly");
                                  }
                              }
                  
                              // Nested Types
                              private class SelectedIndexEnumerator : IEnumerator
                              {
                                  // Fields
                                  private int current;
                                  private ListBox.DisabledIndexCollection items;
                  
                                  // Methods
                                  public SelectedIndexEnumerator(ListBox.DisabledIndexCollection items)
                                  {
                                      this.items = items;
                                      this.current = -1;
                                  }
                  
                                  bool IEnumerator.MoveNext()
                                  {
                                      if (this.current < (this.items.Count - 1))
                                      {
                                          this.current++;
                                          return true;
                                      }
                                      this.current = this.items.Count;
                                      return false;
                                  }
                  
                                  void IEnumerator.Reset()
                                  {
                                      this.current = -1;
                                  }
                  
                                  // Properties
                                  object IEnumerator.Current
                                  {
                                      get
                                      {
                                          if ((this.current == -1) || (this.current == this.items.Count))
                                          {
                                              throw new InvalidOperationException("ListEnumCurrentOutOfRange");
                                          }
                                          return this.items[this.current];
                                      }
                                  }
                              }
                          }
                  
                          public new void SetSelected(int index, bool value)
                          {
                              int num = (this.Items == null) ? 0 : this.Items.Count;
                              if ((index < 0) || (index >= num))
                              {
                                  throw new ArgumentOutOfRangeException("index");
                              }
                              if (this.SelectionMode == SelectionMode.None)
                              {
                                  throw new InvalidOperationException("ListBoxInvalidSelectionMode");
                              }
                              if (!disabledIndices.Contains(index))
                              {
                                  if (!value)
                                  {
                                      if (SelectedIndices.Contains(index))
                                          SelectedIndices.Remove(index);
                                  }
                                  else
                                  {
                                      base.SetSelected(index, value);
                                  }
                              }
                              // Selected index deoes not change, however we should redraw the disabled item.
                              else
                              {
                                  if (!value)
                                  {
                                      // Remove selected item if it is in the list of selected indices.
                                      if (SelectedIndices.Contains(index))
                                          SelectedIndices.Remove(index);
                                  }
                  
                              }
                              Invalidate(GetItemRectangle(index));
                          }
                      }
                  
                      public class IndexEventArgs : EventArgs
                      {
                          private int index;
                          public int Index
                          {
                              get
                              {
                                  return index;
                              }
                  
                              set
                              {
                                  index = value ;
                              }
                          }
                          public IndexEventArgs(int index)
                          {
                              Index = index;
                          }
                      }
                  }
                  

                  使用方法:

                  • 将自定义控件添加到您的工具箱并拖动到您的表单上
                  • 在列表框上使用此方法 listBox1.DisableItem(index);listBox1.EnableItem(index);
                  • 通过以下链接下载此内容

                  下载源

                  这篇关于如何禁用列表框中的选定项目的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持跟版网!

                  本站部分内容来源互联网,如果有图片或者内容侵犯了您的权益,请联系我们,我们会在确认后第一时间进行删除!

                  相关文档推荐

                  Populate ListBox with a IEnumrable on another thread (winforms)(在另一个线程(winforms)上使用 IEnumrable 填充 ListBox)
                  listbox selected item give me quot; System.Data.DataRowViewquot; , C# winforms(列表框选择的项目给我quot;System.Data.DataRowView, C# Winforms)
                  Cannot remove items from ListBox(无法从列表框中删除项目)
                  Preventing ListBox scrolling to top when updated(更新时防止列表框滚动到顶部)
                  Drag and drop from list to canvas on windows phone with MVVM(使用 MVVM 在 Windows 手机上从列表拖放到画布)
                  Deselection on a WPF listbox with extended selection mode(具有扩展选择模式的 WPF 列表框上的取消选择)

                  <legend id='TRzFk'><style id='TRzFk'><dir id='TRzFk'><q id='TRzFk'></q></dir></style></legend>
                  • <bdo id='TRzFk'></bdo><ul id='TRzFk'></ul>
                    <i id='TRzFk'><tr id='TRzFk'><dt id='TRzFk'><q id='TRzFk'><span id='TRzFk'><b id='TRzFk'><form id='TRzFk'><ins id='TRzFk'></ins><ul id='TRzFk'></ul><sub id='TRzFk'></sub></form><legend id='TRzFk'></legend><bdo id='TRzFk'><pre id='TRzFk'><center id='TRzFk'></center></pre></bdo></b><th id='TRzFk'></th></span></q></dt></tr></i><div id='TRzFk'><tfoot id='TRzFk'></tfoot><dl id='TRzFk'><fieldset id='TRzFk'></fieldset></dl></div>

                    • <small id='TRzFk'></small><noframes id='TRzFk'>

                      <tfoot id='TRzFk'></tfoot>
                        <tbody id='TRzFk'></tbody>