IMEX.mes.wcf/DK.Basics/WFControls/11_Standard/06_CheckedListBox/CalCheckAllListBox.cs


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Runtime;
using System.Windows.Forms;
using Dongke.WinForm.Utilities;

namespace Dongke.WinForm.Controls
{
    /// <summary>
    /// 全选复选框列表控件
    /// </summary>
    [ToolboxBitmap(typeof(CheckedListBox))]
    [DefaultBindingProperty("SelectedValue"), DefaultProperty("Items"), DefaultEvent("ItemChecked")]
    [LookupBindingProperties("DataSource", "DisplayMember", "ValueMember", "SelectedValue")]
    //[Designer("System.Windows.Forms.Design.ListBoxDesigner, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
    public partial class CalCheckAllListBox : UserControl, IDKControl, IPopupControl, IDataVerifiable, IAsyncControl
    {
        #region 事件声明
        #region HasErrorChanged
        /// <summary>
        /// 当 HasError 属性的值更改时发生。
        /// </summary>
        private static readonly object EventHasErrorChanged = new object();

        /// <summary>
        /// 当 HasError 属性的值更改时发生。
        /// </summary>
        [Description("当 HasError 属性的值更改时发生。"), Category("CustomerEx")]
        public event EventHandler HasErrorChanged
        {
            add
            {
                base.Events.AddHandler(EventHasErrorChanged, value);
            }
            remove
            {
                base.Events.RemoveHandler(EventHasErrorChanged, value);
            }
        }
        #endregion
        #endregion

        #region 成员变量
        /// <summary>
        /// 是否全部选择
        /// </summary>
        private bool? _isCheckAll = null;
        /// <summary>
        /// 不确定选中时，选中的Item的Index
        /// </summary>
        private List<int> _indeterminateIndices = new List<int>();
        /// <summary>
        /// 焦点是否进入控件
        /// </summary>
        private bool _entered = false;
        /// <summary>
        /// 鼠标是否进入控件
        /// </summary>
        private bool _mouseOver = false;
        /// <summary>
        /// 边框颜色
        /// </summary>
        private Color? _borderColor = null;
        //private bool _isAllChecked = false;
        #endregion

        #region 构造函数
        /// <summary>
        /// 扩展的复选框列表控件：可以全部选择
        /// </summary>
        public CalCheckAllListBox()
        {
            this.InitializeComponent();
            base.BackColor = SystemColors.Window;
            base.BorderStyle = BorderStyle.FixedSingle;
            this.chkAll.MouseWheel += chkAll_MouseWheel;
            this.chkAll.GotFocus += chkAll_GotFocus;
        }
        #endregion

        #region 实现
        #region ListControl
        #region 属性
        /// <summary>
        /// 获取或设置控件的数据源
        /// </summary>
        [Description("获取或设置控件的数据源。"), Category("ListControl")]
        [AttributeProvider(typeof(IListSource))]
        [DefaultValue(null)]
        [RefreshProperties(RefreshProperties.Repaint)]
        public object DataSource
        {
            get
            {
                return this.cklItem.DataSource;
            }
            set
            {
                this.cklItem.DataSource = value;
            }
        }

        /// <summary>
        /// 获取或设置控件的显示的属性
        /// </summary>
        [Description("获取或设置控件的显示的属性。"), Category("ListControl")]
        //[DefaultValue(null)]
        [DefaultValue("")]
        [Editor("System.Windows.Forms.Design.DataMemberFieldEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
        [TypeConverter("System.Windows.Forms.Design.DataMemberFieldConverter, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")]
        public string DisplayMember
        {
            get
            {
                return this.cklItem.DisplayMember;
            }
            set
            {
                this.cklItem.DisplayMember = value;
            }
        }

        /// <summary>
        /// 获取或设置提供自定义格式设置行为的 System.IFormatProvider。
        /// </summary>
        [Description("获取或设置提供自定义格式设置行为的 System.IFormatProvider。"), Category("ListControl")]
        [Browsable(false)]
        [DefaultValue(null)]
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public IFormatProvider FormatInfo
        {
            get
            {
                return this.cklItem.FormatInfo;
            }
            set
            {
                this.cklItem.FormatInfo = value;
            }
        }

        /// <summary>
        /// 获取或设置格式说明符字符，指示如何显示值。
        /// </summary>
        [Description("获取或设置格式说明符字符，指示如何显示值。"), Category("ListControl")]
        [DefaultValue("")]
        [Editor("System.Windows.Forms.Design.FormatStringEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
        [MergableProperty(false)]
        public string FormatString
        {
            get
            {
                return this.cklItem.FormatString;
            }
            set
            {
                this.cklItem.FormatString = value;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示是否将格式设置应用于控件的 DisplayMember 属性。
        /// </summary>
        [Description("获取或设置一个值，该值指示是否将格式设置应用于控件的 DisplayMember 属性。"), Category("ListControl")]
        [DefaultValue(false)]
        public bool FormattingEnabled
        {
            get
            {
                return this.cklItem.FormattingEnabled;
            }
            set
            {
                this.cklItem.FormattingEnabled = value;
            }
        }

        /// <summary>
        /// 获取或设置由 DisplayMember 属性指定的成员属性的值。
        /// </summary>
        [Description("获取或设置由 DisplayMember 属性指定的成员属性的值。"), Category("ListControl")]
        [Bindable(true)]
        [Browsable(false)]
        [DefaultValue(null)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public object SelectedValue
        {
            get
            {
                return this.cklItem.SelectedValue;
            }
            set
            {
                this.cklItem.SelectedValue = value;
            }
        }

        /// <summary>
        /// 获取或设置一个属性，该属性将用作控件中的项的实际值。
        /// </summary>
        [Description("获取或设置一个属性，该属性将用作控件中的项的实际值。"), Category("ListControl")]
        //[DefaultValue(null)]
        [DefaultValue("")]
        [Editor("System.Windows.Forms.Design.DataMemberFieldEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
        public string ValueMember
        {
            get
            {
                return this.cklItem.ValueMember;
            }
            set
            {
                this.cklItem.ValueMember = value;
            }
        }
        #endregion

        #region 事件声明
        /// <summary>
        /// 当 DataSource 更改时发。
        /// </summary>
        [Description("当 DataSource 更改时发。"), Category("ListControl")]
        public event EventHandler DataSourceChanged
        {
            add
            {
                this.cklItem.DataSourceChanged += value;
            }
            remove
            {
                this.cklItem.DataSourceChanged -= value;
            }
        }

        /// <summary>
        /// 当 DisplayMember 属性更改时发生。
        /// </summary>
        [Description("当 DisplayMember 属性更改时发生。"), Category("ListControl")]
        public event EventHandler DisplayMemberChanged
        {
            add
            {
                this.cklItem.DisplayMemberChanged += value;
            }
            remove
            {
                this.cklItem.DisplayMemberChanged -= value;
            }
        }

        /// <summary>
        /// 在该控件绑定到数据值时发生。
        /// </summary>
        [Description("在该控件绑定到数据值时发生。"), Category("ListControl")]
        public event ListControlConvertEventHandler Format
        {
            add
            {
                this.cklItem.Format += value;
            }
            remove
            {
                this.cklItem.Format -= value;
            }
        }

        /// <summary>
        /// 当 FormatInfo 属性的值更改时发生。
        /// </summary>
        [Description("当 FormatInfo 属性的值更改时发生。"), Category("ListControl")]
        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public event EventHandler FormatInfoChanged
        {
            add
            {
                this.cklItem.FormatInfoChanged += value;
            }
            remove
            {
                this.cklItem.FormatInfoChanged -= value;
            }
        }

        /// <summary>
        /// 当 FormatString 属性的值更改时发生。
        /// </summary>
        [Description("当 FormatString 属性的值更改时发生。"), Category("ListControl")]
        public event EventHandler FormatStringChanged
        {
            add
            {
                this.cklItem.FormatStringChanged += value;
            }
            remove
            {
                this.cklItem.FormatStringChanged -= value;
            }
        }

        /// <summary>
        /// 当 FormattingEnabled 属性的值更改时发生。
        /// </summary>
        [Description("当 FormattingEnabled 属性的值更改时发生。"), Category("ListControl")]
        public event EventHandler FormattingEnabledChanged
        {
            add
            {
                this.cklItem.FormattingEnabledChanged += value;
            }
            remove
            {
                this.cklItem.FormattingEnabledChanged -= value;
            }
        }

        /// <summary>
        /// 当 SelectedValue 属性更改时发生。
        /// </summary>
        [Description("当 SelectedValue 属性更改时发生。"), Category("ListControl")]
        public event EventHandler SelectedValueChanged
        {
            add
            {
                this.cklItem.SelectedValueChanged += value;
            }
            remove
            {
                this.cklItem.SelectedValueChanged -= value;
            }
        }

        /// <summary>
        /// 当 ValueMember 属性更改时发生。
        /// </summary>
        [Description("当 ValueMember 属性更改时发生。"), Category("ListControl")]
        public event EventHandler ValueMemberChanged
        {
            add
            {
                this.cklItem.ValueMemberChanged += value;
            }
            remove
            {
                this.cklItem.ValueMemberChanged -= value;
            }
        }
        #endregion

        #region 公共方法
        /// <summary>
        /// 返回指定项的文本表示形式。
        /// </summary>
        /// <param name="item">从中获取要显示的内容的对象</param>
        /// <returns>
        /// 如果未指定 DisplayMember 属性，则由 GetItemText(System.Object)
        /// 返回的值是此项的 ToString 方法的值。否则，该方法返回在 DisplayMember
        /// 属性中指定的成员的字符串值，该成员被指定给在 item 参数中指定的对象。
        /// </returns>
        public string GetItemText(object item)
        {
            return this.cklItem.GetItemText(item);
        }
        #endregion
        #endregion

        #region ListBox
        #region 属性
        /// <summary>
        /// 获取或设置多列显示中列的宽度。
        /// </summary>
        [Description("获取或设置多列显示中列的宽度。"), Category("ListBox")]
        [DefaultValue(0)]
        [Localizable(true)]
        public int ColumnWidth
        {
            get
            {
                return this.cklItem.ColumnWidth;
            }
            set
            {
                this.cklItem.ColumnWidth = value;
            }
        }

        /// <summary>
        /// 获取控件中的项之间的制表符的宽度。
        /// </summary>
        [Description("获取控件中的项之间的制表符的宽度。"), Category("ListBox")]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ListBox.IntegerCollection CustomTabOffsets
        {
            get
            {
                return this.cklItem.CustomTabOffsets;
            }
        }

        /// <summary>
        /// 获取或设置控件的水平滚动条可滚动的宽度。
        /// </summary>
        [Description("获取或设置控件的水平滚动条可滚动的宽度。"), Category("ListBox")]
        [DefaultValue(0)]
        [Localizable(true)]
        public int HorizontalExtent
        {
            get
            {
                return this.cklItem.HorizontalExtent;
            }
            set
            {
                this.cklItem.HorizontalExtent = value;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示是否在控件中显示水平滚动条。
        /// </summary>
        [Description("获取或设置一个值，该值指示是否在控件中显示水平滚动条。"), Category("ListBox")]
        [DefaultValue(false)]
        [Localizable(true)]
        public bool HorizontalScrollbar
        {
            get
            {
                return this.cklItem.HorizontalScrollbar;
            }
            set
            {
                this.cklItem.HorizontalScrollbar = value;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示控件是否应调整大小以避免只显示项的局部。
        /// </summary>
        [Description("获取或设置一个值，该值指示控件是否应调整大小以避免只显示项的局部。"), Category("ListBox")]
        [DefaultValue(true)]
        [Localizable(true)]
        [RefreshProperties(RefreshProperties.Repaint)]
        public bool IntegralHeight
        {
            get
            {
                return this.cklItem.IntegralHeight;
            }
            set
            {
                this.cklItem.IntegralHeight = value;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示控件是否支持多列。
        /// </summary>
        [Description("获取或设置一个值，该值指示控件是否支持多列。"), Category("ListBox")]
        [DefaultValue(false)]
        public bool MultiColumn
        {
            get
            {
                return this.cklItem.MultiColumn;
            }
            set
            {
                this.cklItem.MultiColumn = value;
            }
        }

        /// <summary>
        /// 获取控件中所有项的组合高度。
        /// </summary>
        [Description("获取控件中所有项的组合高度。"), Category("ListBox")]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public int PreferredHeight
        {
            get
            {
                return this.cklItem.PreferredHeight;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示是否任何时候都显示垂直滚动条。
        /// </summary>
        [Description("获取或设置一个值，该值指示是否任何时候都显示垂直滚动条。"), Category("ListBox")]
        [DefaultValue(false)]
        [Localizable(true)]
        public bool ScrollAlwaysVisible
        {
            get
            {
                return this.cklItem.ScrollAlwaysVisible;
            }
            set
            {
                this.cklItem.ScrollAlwaysVisible = value;
            }
        }

        /// <summary>
        /// 获取或设置控件中当前选定项的从零开始的索引。
        /// </summary>
        [Description("获取或设置控件中当前选定项的从零开始的索引。"), Category("ListBox")]
        [Bindable(true)]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual int SelectedIndex
        {
            get
            {
                return this.cklItem.SelectedIndex;
            }
            set
            {
                this.cklItem.SelectedIndex = value;
            }
        }

        /// <summary>
        /// 获取一个集合，该集合包含控件中所有当前选定项的从零开始的索引。
        /// </summary>
        [Description("获取一个集合，该集合包含控件中所有当前选定项的从零开始的索引。"), Category("ListBox")]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ListBox.SelectedIndexCollection SelectedIndices
        {
            get
            {
                return this.cklItem.SelectedIndices;
            }
        }

        /// <summary>
        /// 获取或设置控件中的当前选定项。
        /// </summary>
        [Description("获取或设置控件中的当前选定项。"), Category("ListBox")]
        [Bindable(true)]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public object SelectedItem
        {
            get
            {
                return this.cklItem.SelectedItem;
            }
            set
            {
                this.cklItem.SelectedItem = value;
            }
        }

        /// <summary>
        /// 获取包含控件中当前选定项的集合。
        /// </summary>
        [Description("获取包含控件中当前选定项的集合。"), Category("ListBox")]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ListBox.SelectedObjectCollection SelectedItems
        {
            get
            {
                return this.cklItem.SelectedItems;
            }
        }

        /// <summary>
        /// 获取或设置在控件中选择项所用的方法。
        /// </summary>
        [Description("获取或设置在控件中选择项所用的方法。"), Category("ListBox")]
        [DefaultValue(typeof(SelectionMode), "One")]
        public virtual SelectionMode SelectionMode
        {
            get
            {
                return this.cklItem.SelectionMode;
            }
            set
            {
                this.cklItem.SelectionMode = value;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示控件中的项是否按字母顺序排序。
        /// </summary>
        [Description("获取或设置一个值，该值指示控件中的项是否按字母顺序排序。"), Category("ListBox")]
        [DefaultValue(false)]
        public bool Sorted
        {
            get
            {
                return this.cklItem.Sorted;
            }
            set
            {
                this.cklItem.Sorted = value;
            }
        }

        /// <summary>
        /// 获取或搜索控件中当前选定项的文本。
        /// </summary>
        [Description("获取或搜索控件中当前选定项的文本。"), Category("ListBox")]
        [Bindable(false)]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public virtual string ItemText
        {
            get
            {
                return this.cklItem.Text;
            }
            set
            {
                this.cklItem.Text = value;
            }
        }

        /// <summary>
        /// 获取或设置控件中第一个可见项的索引。
        /// </summary>
        [Description("获取或设置控件中第一个可见项的索引。"), Category("ListBox")]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int TopIndex
        {
            get
            {
                return this.cklItem.TopIndex;
            }
            set
            {
                this.cklItem.TopIndex = value;
            }
        }

        /// <summary>
        /// 获取或设置一个值，它指示控件在通过使用 CustomTabOffsets 整数数组绘制字符串时是否识别并展开制表符。
        /// </summary>
        [Description("获取或设置一个值，它指示控件在通过使用 CustomTabOffsets 整数数组绘制字符串时是否识别并展开制表符。"), Category("ListBox")]
        [Browsable(false)]
        [DefaultValue(false)]
        public bool UseCustomTabOffsets
        {
            get
            {
                return this.cklItem.UseCustomTabOffsets;
            }
            set
            {
                this.cklItem.UseCustomTabOffsets = value;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示控件在绘制其字符串时是否可识别和展开制表符。
        /// </summary>
        [Description("获取或设置一个值，该值指示控件在绘制其字符串时是否可识别和展开制表符。"), Category("ListBox")]
        [DefaultValue(true)]
        public bool UseTabStops
        {
            get
            {
                return this.cklItem.UseTabStops;
            }
            set
            {
                this.cklItem.UseTabStops = value;
            }
        }

        #region Never
        /*
		[Description(""), Category("CustomerEx")]
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public Padding ItemPadding
		{
			get
			{
				return base.Padding;
			}
			set
			{
			}
		}
		*/
        /*
        /// <summary>
        /// 获取或设置控件的绘图模式。
        /// </summary>
        [Description("获取或设置控件的绘图模式。"), Category("CustomerEx")]
        //[Browsable(false)]
        //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //[EditorBrowsable(EditorBrowsableState.Never)]
        [RefreshProperties(RefreshProperties.Repaint)]
        [DefaultValue(typeof(DrawMode), "Normal")]
        public virtual DrawMode DrawMode
        {
            get
            {
                return this.clstItem.DrawMode;
            }
            set
            {
                this.clstItem.DrawMode = value;
            }
        }

        /// <summary>
        /// 获取或设置控件中项的高度。
        /// </summary>
        [Description("获取或设置控件中项的高度。"), Category("CustomerEx")]
        //[Browsable(false)]
        //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //[EditorBrowsable(EditorBrowsableState.Never)]
        //[DefaultValue(13)]
        [DefaultValue(16)]
        [Localizable(true)]
        [RefreshProperties(RefreshProperties.Repaint)]
        public virtual int ItemHeight
        {
            get
            {
                return this.clstItem.ItemHeight;
            }
            set
            {
                this.clstItem.ItemHeight = value;
                //this.pnlItem.Height = this.clstItem.ItemHeight + 2;
            }
        }

        /// <summary>
        /// 获取控件的项
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        [Description("获取控件的项。"), Category("CustomerEx")]
        //[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Editor("System.Windows.Forms.Design.ListControlStringCollectionEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
        [Localizable(true)]
        [MergableProperty(false)]
        //public ListBox.ObjectCollection Items
        public ListBox.ObjectCollection ListBoxItems
        {
            get
            {
                return this.clstItem.Items;
            }
        }
        */
        #endregion
        #endregion

        #region 事件声明
        /// <summary>
        /// 在单击 Item 控件时发生。
        /// </summary>
        [Description("在单击 Item 控件时发生。"), Category("ListBox")]
        [Browsable(true)]
        [EditorBrowsable(EditorBrowsableState.Always)]
        public event EventHandler ItemClick
        {
            add
            {
                this.cklItem.Click += value;
            }
            remove
            {
                this.cklItem.Click -= value;
            }
        }

        /// <summary>
        /// 在所有者绘制的 Item 在视觉外观更改时发生。
        /// </summary>
        [Description("在所有者绘制的 Item 在视觉外观更改时发生。"), Category("ListBox")]
        public event DrawItemEventHandler DrawItem
        {
            add
            {
                this.cklItem.DrawItem += value;
            }
            remove
            {
                this.cklItem.DrawItem -= value;
            }
        }

        /// <summary>
        /// 当用户使用鼠标指针单击 Item 控件时发生。
        /// </summary>
        [Description("当用户使用鼠标指针单击 Item 控件时发生。"), Category("ListBox")]
        [Browsable(true)]
        [EditorBrowsable(EditorBrowsableState.Always)]
        public event MouseEventHandler ItemMouseClick
        {
            add
            {
                this.cklItem.MouseClick += value;
            }
            remove
            {
                this.cklItem.MouseClick -= value;
            }
        }

        /// <summary>
        /// 在 SelectedIndex 属性或 SelectedIndices集合更改后发生。
        /// </summary>
        [Description("在 SelectedIndex 属性或 SelectedIndices集合更改后发生。"), Category("ListBox")]
        public event EventHandler SelectedIndexChanged
        {
            add
            {
                this.cklItem.SelectedIndexChanged += value;
            }
            remove
            {
                this.cklItem.SelectedIndexChanged -= value;
            }
        }

        /// <summary>
        /// 当 Text 属性更改时发生。
        /// </summary>
        [Description("当 Text 属性更改时发生。"), Category("ListBox")]
        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public event EventHandler ItemTextChanged
        {
            add
            {
                this.cklItem.TextChanged += value;
            }
            remove
            {
                this.cklItem.TextChanged -= value;
            }
        }

        #region Never
        /*
		/// <summary>
		/// 当 Padding 属性的值更改时发生。
		/// </summary>
		[Description("当 Padding 属性的值更改时发生。"), Category("CustomerEx")]
		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public event EventHandler ItemPaddingChanged
		{
			add
			{
				this.clstItem.PaddingChanged += value;
			}
			remove
			{
				this.clstItem.PaddingChanged -= value;
			}
		}

		/// <summary>
		/// 在绘制 Item 控件时发生。
		/// </summary>
		[Description("在绘制 Item 控件时发生。"), Category("CustomerEx")]
		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public event PaintEventHandler ItemPaint
		{
			add
			{
				this.clstItem.Paint += value;
			}
			remove
			{
				this.clstItem.Paint -= value;
			}
		}
		*/
        /*
        /// <summary>
        /// 创建所有者描述的控件和确定列表项的大小时发生。
        /// </summary>
        //[Browsable(false)]
        //[EditorBrowsable(EditorBrowsableState.Never)]
        [Description("创建所有者描述的控件和确定列表项的大小时发生。"), Category("CustomerEx")]
        public event MeasureItemEventHandler MeasureItem
        {
            add
            {
                this.clstItem.MeasureItem += value;
            }
            remove
            {
                this.clstItem.MeasureItem -= value;
            }
        }
        */
        #endregion
        #endregion

        #region 公共方法
        /// <summary>
        /// 当向控件中一次添加一个项时，通过防止该控件绘图来维护性能，直到调用 EndUpdate() 方法为止。
        /// </summary>
        public void BeginUpdate()
        {
            this.cklItem.BeginUpdate();
        }

        /// <summary>
        /// 取消选择控件中的所有项。
        /// </summary>
        public void ClearSelected()
        {
            this.cklItem.ClearSelected();
        }

        /// <summary>
        /// 在 BeginUpdate() 方法挂起绘制后，该方法恢复绘制控件。
        /// </summary>
        public void EndUpdate()
        {
            this.cklItem.EndUpdate();
        }

        /// <summary>
        /// 查找 Item 中以指定字符串开始的第一个项。
        /// </summary>
        /// <param name="s">要搜索的文本</param>
        /// <returns>找到的第一个项的从零开始的索引；如果找不到匹配项，则返回 ListBox.NoMatches。</returns>
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        public int FindString(string s)
        {
            return this.cklItem.FindString(s);
        }

        /// <summary>
        /// 查找 Item 中以指定字符串开头的第一个项。搜索从特定的起始索引处开始。
        /// </summary>
        /// <param name="s">要搜索的文本</param>
        /// <param name="startIndex">项的从零开始的索引，该项在要搜索的第一个项之前。设置为负一 (-1) 以从控件的开始处进行搜索。</param>
        /// <returns>找到的第一个项的从零开始的索引；如果找不到匹配项，则返回 ListBox.NoMatches。</returns>
        public int FindString(string s, int startIndex)
        {
            return this.cklItem.FindString(s, startIndex);
        }

        /// <summary>
        /// 查找 Item 中第一个精确匹配指定字符串的项。
        /// </summary>
        /// <param name="s">要搜索的文本</param>
        /// <returns>找到的第一个项的从零开始的索引；如果找不到匹配项，则返回 ListBox.NoMatches。</returns>
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        public int FindStringExact(string s)
        {
            return this.cklItem.FindStringExact(s);
        }

        /// <summary>
        /// 查找 Item 中第一个精确匹配指定字符串的项。搜索从特定的起始索引处开始。
        /// </summary>
        /// <param name="s">要搜索的文本</param>
        /// <param name="startIndex">项的从零开始的索引，该项在要搜索的第一个项之前。设置为负一 (-1) 以从控件的开始处进行搜索。</param>
        /// <returns>找到的第一个项的从零开始的索引；如果找不到匹配项，则返回 ListBox.NoMatches。</returns>
        public int FindStringExact(string s, int startIndex)
        {
            return this.cklItem.FindStringExact(s, startIndex);
        }

        /// <summary>
        /// 返回 Item 中某项的高度。
        /// </summary>
        /// <param name="index">要返回其高度的项的从零开始的索引</param>
        /// <returns>指定的项的高度，以像素为单位</returns>
        public int GetItemHeight(int index)
        {
            return this.cklItem.GetItemHeight(index);
        }

        /// <summary>
        /// 返回控件中的项的边框。
        /// </summary>
        /// <param name="index">要返回其边框的项的从零开始的索引</param>
        /// <returns>表示指定项的边框</returns>
        public Rectangle GetItemRectangle(int index)
        {
            return this.cklItem.GetItemRectangle(index);
        }

        /// <summary>
        /// 返回一个值，该值指示是否选定了指定的项
        /// </summary>
        /// <param name="index">项的从零开始的索引，根据该索引确定该项是否被选定</param>
        /// <returns>如果当前在控件中选定了指定的项，则为 true；否则为 false。</returns>
        public bool GetSelected(int index)
        {
            return this.cklItem.GetSelected(index);
        }

        /// <summary>
        /// 返回指定坐标处的项的从零开始的索引
        /// </summary>
        /// <param name="p">System.Drawing.Point 对象，包含用于获取项索引的坐标</param>
        /// <returns>在指定坐标处找到的项的从零开始的索引；如果找不到匹配项，则返回 ListBox.NoMatches。</returns>
        public int IndexFromPoint(Point p)
        {
            return this.cklItem.IndexFromPoint(p);
        }

        /// <summary>
        /// 返回指定坐标处的项的从零开始的索引。
        /// </summary>
        /// <param name="x">要搜索的位置的 x 坐标</param>
        /// <param name="y">要搜索的位置的 y 坐标</param>
        /// <returns>在指定坐标处找到的项的从零开始的索引；如果找不到匹配项，则返回 ListBox.NoMatches。</returns>
        public int IndexFromPoint(int x, int y)
        {
            return this.cklItem.IndexFromPoint(x, y);
        }

        /// <summary>
        /// 强制控件使其工作区无效并立即重绘自己和任何子控件。
        /// </summary>
        public virtual void ItemRefresh()
        {
            this.cklItem.Refresh();
        }

        /// <summary>
        /// 
        /// </summary>
        public virtual void ItemResetBackColor()
        {
            this.cklItem.ResetBackColor();
        }

        /// <summary>
        /// 
        /// </summary>
        public virtual void ItemResetForeColor()
        {
            this.cklItem.ResetForeColor();
        }

        /// <summary>
        /// 选择或清除对 Item 中指定项的选定。
        /// </summary>
        /// <param name="index">Item中要选择或清除对其选定的项的从零开始的索引</param>
        /// <param name="value">如果为 true，则选择指定的项；否则为 false</param>
        public void SetSelected(int index, bool value)
        {
            this.cklItem.SetSelected(index, value);
        }

        /// <summary>
        /// 返回控件的字符串表示形式。
        /// </summary>
        /// <returns>一个字符串，它描述控件类型、控件中的项计数，如果该计数不为 0，则还描述控件中第一项的 Text 属性</returns>
        public new string ToString()
        {
            return this.cklItem.ToString();
        }
        #endregion
        #endregion

        #region CheckedListBox
        #region 属性
        /// <summary>
        /// 该控件中选中索引的集合。
        /// </summary>
        [Description("该控件中选中索引的集合。"), Category("CheckedListBox")]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public CheckedListBox.CheckedIndexCollection CheckedIndices
        {
            get
            {
                return this.cklItem.CheckedIndices;
            }
        }

        /// <summary>
        /// 该控件中选中项的集合。
        /// </summary>
        [Description("该控件中选中项的集合。"), Category("CheckedListBox")]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public CheckedListBox.CheckedItemCollection CheckedItems
        {
            get
            {
                return this.cklItem.CheckedItems;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示当选定项时是否应切换复选框。
        /// </summary>
        [Description("获取或设置一个值，该值指示当选定项时是否应切换复选框。"), Category("CheckedListBox")]
        [DefaultValue(true)]
        public bool CheckOnClick
        {
            get
            {
                return this.cklItem.CheckOnClick;
            }
            set
            {
                this.cklItem.CheckOnClick = value;
            }
        }

        /// <summary>
        /// 获取该控件中项的集合。
        /// </summary>
        [Description("获取该控件中项的集合。"), Category("CheckedListBox")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [Editor("System.Windows.Forms.Design.ListControlStringCollectionEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor))]
        [Localizable(true)]
        [MergableProperty(false)]
        public CheckedListBox.ObjectCollection Items
        {
            get
            {
                return this.cklItem.Items;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示复选框是否有 Flat 或 Normal 的 System.Windows.Forms.ButtonState。
        /// </summary>
        [Description("获取或设置一个值，该值指示复选框是否有 Flat 或 Normal 的 System.Windows.Forms.ButtonState。"), Category("CheckedListBox")]
        [DefaultValue(false)]
        public bool ThreeDCheckBoxes
        {
            get
            {
                return this.cklItem.ThreeDCheckBoxes;
            }
            set
            {
                this.cklItem.ThreeDCheckBoxes = value;
            }
        }

        /// <summary>
        ///  获取或设置一个值，该值确定是使用 System.Drawing.Graphics 类 (GDI+) 还是 System.Windows.Forms.TextRenderer 类 (GDI) 呈现文本。
        /// </summary>
        [Description("获取或设置一个值，该值确定是使用 System.Drawing.Graphics 类 (GDI+) 还是 System.Windows.Forms.TextRenderer 类 (GDI) 呈现文本。"), Category("CheckedListBox")]
        [DefaultValue(false)]
        public bool UseCompatibleTextRendering
        {
            get
            {
                return this.cklItem.UseCompatibleTextRendering;
            }
            set
            {
                this.cklItem.UseCompatibleTextRendering = value;
                this.chkAll.UseCompatibleTextRendering = value;
            }
        }

        /*
        //
        // 摘要: 
        //     获取一个值，该值表示 System.Windows.Forms.CheckedListBox 的绘制元素的模式。此属性与该类无关。
        //
        // 返回结果: 
        //     通常为 Normal 的 System.Windows.Forms.DrawMode。
        //[Browsable(false)]
        //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //[EditorBrowsable(EditorBrowsableState.Never)]
        //public override DrawMode DrawMode
        //{
        //	get;
        //	set;
        //}
        //
        // 摘要: 
        //     获取项区域的高度。
        //
        // 返回结果: 
        //     项区域的高度（以像素为单位）。
        //[Browsable(false)]
        //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //[EditorBrowsable(EditorBrowsableState.Never)]
        //public override int ItemHeight
        //{
        //	get;
        //	set;
        //}
        */
        #endregion

        #region 事件声明
        /// <summary>
        /// 当某项的选中状态更改时发生。
        /// </summary>
        [Description("当某项的选中状态更改时发生。"), Category("CheckedListBox")]
        public event ItemCheckEventHandler ItemCheck
        {
            add
            {
                this.cklItem.ItemCheck += value;
            }
            remove
            {
                this.cklItem.ItemCheck -= value;
            }
        }
        /*
        ///// <summary>
        ///// 当用户单击 Item 控件时发生。
        ///// </summary>
        //[Description("当用户单击 Item 控件时发生。"), Category("CustomerEx")]
        //[Browsable(true)]
        //[EditorBrowsable(EditorBrowsableState.Always)]
        //public event EventHandler ItemClick
        //{
        //	add
        //	{
        //		this.clstItem.Click += value;
        //	}
        //	remove
        //	{
        //		this.clstItem.Click -= value;
        //	}
        //}
        ///// <summary>
        ///// 当用户使用鼠标单击 Item 控件时发生。
        ///// </summary>
        //[Description("当用户使用鼠标单击 Item 控件时发生。"), Category("CustomerEx")]
        //[Browsable(true)]
        //[EditorBrowsable(EditorBrowsableState.Always)]
        //public event MouseEventHandler ItemMouseClick
        //{
        //	add
        //	{
        //		this.clstItem.MouseClick += value;
        //	}
        //	remove
        //	{
        //		this.clstItem.MouseClick -= value;
        //	}
        //}
        */
        /*
        //
        // 摘要: 
        //     在所有者描述的 System.Windows.Forms.CheckedListBox 的可视方位更改时发生。此事件与此类无关。
        //[Browsable(false)]
        //[EditorBrowsable(EditorBrowsableState.Never)]
        //public event DrawItemEventHandler DrawItem;
        //
        // 摘要: 
        //     创建所有者描述的 System.Windows.Forms.ListBox 和确定列表项的大小时发生。此事件与此类无关。
        //[Browsable(false)]
        //[EditorBrowsable(EditorBrowsableState.Never)]
        //public event MeasureItemEventHandler MeasureItem;
        */
        #endregion

        #region 公共方法
        /// <summary>
        /// 返回指示指定项是否选中的值。
        /// </summary>
        /// <param name="index">项的索引</param>
        /// <returns>如果选中该项，则为 true；否则为 false。</returns>
        public bool GetItemChecked(int index)
        {
            return this.cklItem.GetItemChecked(index);
        }

        /// <summary>
        /// 返回指示当前项的复选状态的值。
        /// </summary>
        /// <param name="index">要获取其选中值的项的索引</param>
        /// <returns>System.Windows.Forms.CheckState 值之一。</returns>
        public CheckState GetItemCheckState(int index)
        {
            return this.cklItem.GetItemCheckState(index);
        }

        /// <summary>
        /// 将指定索引处的项的 System.Windows.Forms.CheckState 设置为 Checked。
        /// </summary>
        /// <param name="index">要为其设置复选状态的项的索引</param>
        /// <param name="value">若要将该项设置为选中，则为 true；否则为 false</param>
        public void SetItemChecked(int index, bool value)
        {
            this.cklItem.SetItemChecked(index, value);
        }

        /// <summary>
        /// 设置指定索引处项的复选状态。
        /// </summary>
        /// <param name="index">要为其设置状态的项的索引</param>
        /// <param name="value">System.Windows.Forms.CheckState 值之一</param>
        public void SetItemCheckState(int index, CheckState value)
        {
            this.cklItem.SetItemCheckState(index, value);
        }
        #endregion
        #endregion

        #region CklCheckedListBox
        #region 属性
        /// <summary>
        /// 获取选中的文本
        /// </summary>
        [Description("获取选中的文本。"), Category("CklCheckedListBox")]
        [DefaultValue(null)]
        public string[] CheckedTexts
        {
            get
            {
                return this.cklItem.CheckedTexts;
            }
        }

        /// <summary>
        /// 获取选中的值
        /// </summary>
        [Description("获取选中的值。"), Category("CklCheckedListBox")]
        [DefaultValue(null)]
        public object[] CheckedValues
        {
            get
            {
                return this.cklItem.CheckedValues;
            }
        }

        /// <summary>
        /// 获取选中项的文本表示形式，用【,】隔开。
        /// </summary>
        [Description("获取选中项的文本表示形式，用【,】隔开。"), Category("CklCheckedListBox")]
        [DefaultValue(null)]
        public string CheckedText
        {
            get
            {
                return this.cklItem.CheckedText;
            }
        }

        /// <summary>
        /// 获取选中项的值，用【,】隔开
        /// </summary>
        [Description("获取选中项的值，用【,】隔开。"), Category("CklCheckedListBox")]
        [DefaultValue(null)]
        public string CheckedValue
        {
            get
            {
                return this.cklItem.CheckedValue;
            }
        }

        ///// <summary>
        ///// 获取或设置控件是否单项选中。
        ///// </summary>
        //[Description("获取或设置控件是否单项选中。"), Category("CustomerEx")]
        //[DefaultValue(false)]
        ////[Browsable(false)]
        //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        //[EditorBrowsable(EditorBrowsableState.Never)]
        //public bool SimpleChecked
        //{
        //    get
        //    {
        //        return this.cklItem.SimpleChecked;
        //    }
        //    set
        //    {
        //        this.cklItem.SimpleChecked = value;
        //    }
        //}

        /// <summary>
        /// 获取一个值，该值指示控件是否有输入焦点。
        /// </summary>
        [DefaultValue(false)]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public virtual bool Entered
        {
            get
            {
                return this._entered;
            }
            protected set
            {
                if (this._entered != value)
                {
                    this._entered = value;
                    this.InvalidateBorder();
                }
            }
        }

        /// <summary>
        /// 获取一个值，该值指示鼠标是否在控件上方。
        /// </summary>
        [DefaultValue(false)]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public virtual bool MouseOver
        {
            get
            {
                return this._mouseOver;
            }
            protected set
            {
                if (this._mouseOver != value)
                {
                    this._mouseOver = value;
                    this.InvalidateBorder();
                }
            }
        }
        #endregion

        #region 事件处理
        /// <summary>
        /// 当某项的选中状态更改后发生。
        /// </summary>
        [Description("当某项的选中状态更改后发生。"), Category("CklCheckedListBox")]
        public event ItemCheckedEventHandler ItemChecked
        {
            add
            {
                this.cklItem.ItemChecked += value;
            }
            remove
            {
                this.cklItem.ItemChecked -= value;
            }
        }
        #endregion

        #region 公有方法
        /// <summary>
        /// 返回指定项的成员属性的值
        /// </summary>
        /// <param name="item">项</param>
        /// <returns>值</returns>
        public virtual object GetItemValue(object item)
        {
            return this.cklItem.GetItemValue(item);
        }

        /// <summary>
        /// 返回选中项的文本表示形式
        /// </summary>
        /// <returns>选中项的文本</returns>
        public virtual List<string> GetCheckedItemTexts()
        {
            return this.cklItem.GetCheckedItemTexts();
        }

        /// <summary>
        /// 返回选中项的成员属性的值
        /// </summary>
        /// <returns>选中项的值</returns>
        public virtual List<object> GetCheckedItemValues()
        {
            return this.cklItem.GetCheckedItemValues();
        }

        /// <summary>
        /// 返回选中项的成员属性的值
        /// </summary>
        /// <returns>选中项的值</returns>
        public virtual List<T> GetCheckedItemValues<T>()
        {
            return this.cklItem.GetCheckedItemValues<T>();
        }

        /// <summary>
        /// 设置全部项目选中状态
        /// </summary>
        /// <param name="value">若要将该项设置为选中，则为 true；否则为 false</param>
        public virtual void SetAllItemsChecked(bool value)
        {
            //this.chkAll.Checked = value;
            if (value)
            {
                this.chkAll.CheckState = CheckState.Checked;
            }
            else
            {
                this.chkAll.CheckState = CheckState.Unchecked;
            }
        }

        /// <summary>
        /// 设置全部项目选中状态
        /// </summary>
        /// <param name="value">若要将该项设置为选中，则为 true；否则为 false</param>
        public virtual void SetAllItemsChecked(CheckState value)
        {
            this.chkAll.CheckState = value;
        }

        /// <summary>
        /// 获取全部项目的选中状态
        /// </summary>
        /// <returns>选中状态</returns>
        public virtual CheckState GetItemsCheckState()
        {
            //return this.cklItem.GetItemsCheckState();
            return this.chkAll.CheckState;
        }

        /// <summary>
        /// 选中指定项目
        /// </summary>
        /// <param name="items">要为其设置复选状态的项</param>
        /// <param name="value">若要将该项设置为选中，则为 true；否则为 false</param>
        public virtual void SetItemCheckedByItem(bool value, params object[] items)
        {
            this.cklItem.SetItemCheckedByItem(value, items);
        }

        /// <summary>
        /// 选中指定值的项目
        /// </summary>
        /// <param name="itemValues">要为其设置复选状态的项的值</param>
        /// <param name="value">若要将该项设置为选中，则为 true；否则为 false</param>
        public virtual void SetItemCheckedByValue(bool value, params object[] itemValues)
        {
            this.cklItem.SetItemCheckedByValue(value, itemValues);
        }

        /// <summary>
        /// 将指定索引处的项的 System.Windows.Forms.CheckState 设置为 Checked
        /// </summary>
        /// <param name="value">若要将该项设置为选中，则为 true；否则为 false</param>
        /// <param name="indexs">要为其设置复选状态的项的索引</param>
        public void SetItemChecked(bool value, params int[] indexs)
        {
            this.cklItem.SetItemChecked(value, indexs);
        }

        /*
        /// <summary>
        /// 设置指定索引处项的复选状态
        /// </summary>
        /// <param name="index">要为其设置状态的项的索引</param>
        /// <param name="value"></param>
        public void SetItemChecked(int index, bool value)
        {
            this.clstItem.SetItemChecked(index, value);
        }

        /// <summary>
        /// 设置指定索引处项的复选状态
        /// </summary>
        /// <param name="index">要为其设置状态的项的索引</param>
        /// <param name="value">System.Windows.Forms.CheckState 值之一</param>
        public void SetItemCheckState(int index, CheckState value)
        {
            this.clstItem.SetItemChecked(index, value);
        }
        */
        #endregion
        #endregion
        #endregion

        #region 属性
        #region CustomerEx
        /// <summary>
        /// 获取或设置全选CheckBox的Text。
        /// </summary>
        [Description("获取或设置全选CheckBox的Text。"), Category("CustomerEx")]
        [DefaultValue("全部")]
        public string TextAll
        {
            get
            {
                return this.chkAll.Text;
            }
            set
            {
                this.chkAll.Text = value;
            }
        }

        /// <summary>
        /// 获取或设置一个值，该值指示此全选是否允许三种复选状态而不是两种。
        /// </summary>
        [Description("获取或设置一个值，该值指示此全选是否允许三种复选状态而不是两种。"), Category("CustomerEx")]
        [DefaultValue(false)]
        public bool ThreeState
        {
            get
            {
                return this.chkAll.ThreeState;
            }
            set
            {
                this.chkAll.ThreeState = value;
                if (!value)
                {
                    this._indeterminateIndices.Clear();
                }
            }
        }

        /// <summary>
        /// 获取或设置控件的背景色。
        /// </summary>
        //[Description("获取或设置控件的背景色。"), Category("CustomerEx")]
        [DefaultValue(typeof(Color), "Window")]
        public override Color BackColor
        {
            get
            {
                Color bc = base.BackColor;
                if (bc.IsEmpty)
                {
                    return SystemColors.Window;
                }
                return bc;
            }
            set
            {
                if (value.IsEmpty)
                {
                    base.BackColor = SystemColors.Window;
                }
                else
                {
                    base.BackColor = value;
                }
            }
        }

        /// <summary>
        /// 获取或设置用户控件的边框样式
        /// </summary>
        //[Description("获取或设置用户控件的边框样式。"), Category("CustomerEx")]
        [Browsable(true)]
        [EditorBrowsable(EditorBrowsableState.Always)]
        [DefaultValue(typeof(BorderStyle), "FixedSingle")]
        public new BorderStyle BorderStyle
        {
            get
            {
                return base.BorderStyle;
            }
            set
            {
                base.BorderStyle = value;
            }
        }

        /// <summary>
        /// 获取或设置全部项目的选中状态。
        /// </summary>
        [DefaultValue(typeof(CheckState), "Unchecked")]
        [Description("获取或设置全部项目的选中状态。"), Category("CustomerEx")]
        public CheckState CheckedState
        {
            get
            {
                return this.chkAll.CheckState;
            }
            set
            {
                this.chkAll.CheckState = value;
            }
        }
        #endregion
        #endregion

        #region 重写事件
        #region 属性改变
        /// <summary>
        /// 引发 HasErrorChanged 事件
        /// </summary>
        /// <param name="e">包含事件数据的 EventArgs</param>
        protected virtual void OnHasErrorChanged(EventArgs e)
        {
            EventHandler eventHandler = (EventHandler)base.Events[EventHasErrorChanged];
            if (eventHandler != null)
            {
                eventHandler(this, e);
            }
        }

        /// <summary>
        /// 字体改变事件
        /// </summary>
        /// <param name="e"></param>
        protected override void OnFontChanged(EventArgs e)
        {
            base.OnAutoSizeChanged(e);
            this.chkAll.Font = this.Font;
            this.cklItem.Font = this.Font;
        }

        /// <summary>
        /// 背景色改变事件
        /// </summary>
        /// <param name="e"></param>
        protected override void OnBackColorChanged(EventArgs e)
        {
            base.OnBackColorChanged(e);
            this.pnlAll.BackColor = this.BackColor;
            this.pnlItem.BackColor = this.BackColor;
            this.chkAll.BackColor = this.BackColor;
            this.cklItem.BackColor = this.BackColor;
        }

        /// <summary>
        /// 字体颜色改变
        /// </summary>
        /// <param name="e"></param>
        protected override void OnForeColorChanged(EventArgs e)
        {
            base.OnForeColorChanged(e);
            this.pnlAll.ForeColor = this.ForeColor;
            this.pnlItem.ForeColor = this.ForeColor;
            this.chkAll.ForeColor = this.ForeColor;
            this.cklItem.ForeColor = this.ForeColor;
        }

        /// <summary>
        /// ImeMode改变
        /// </summary>
        /// <param name="e"></param>
        protected override void OnImeModeChanged(EventArgs e)
        {
            base.OnImeModeChanged(e);
            this.pnlAll.ImeMode = this.ImeMode;
            this.pnlItem.ImeMode = this.ImeMode;
            this.chkAll.ImeMode = this.ImeMode;
            this.cklItem.ImeMode = this.ImeMode;
        }

        /// <summary>
        /// RightToLeft改变
        /// </summary>
        /// <param name="e"></param>
        protected override void OnRightToLeftChanged(EventArgs e)
        {
            base.OnRightToLeftChanged(e);
            this.pnlAll.RightToLeft = this.RightToLeft;
            this.pnlItem.RightToLeft = this.RightToLeft;
            this.chkAll.RightToLeft = this.RightToLeft;
            this.cklItem.RightToLeft = this.RightToLeft;
        }
        #endregion

        #region 键盘事件
        #endregion

        #region 焦点事件
        /// <summary>
        /// 输入焦点进入控件
        /// </summary>
        /// <param name="e"></param>
        protected override void OnEnter(EventArgs e)
        {
            this.Entered = true;
            base.OnEnter(e);
        }

        /// <summary>
        /// 获得焦点
        /// </summary>
        /// <param name="e"></param>
        protected override void OnGotFocus(EventArgs e)
        {
            base.OnGotFocus(e);
        }

        /// <summary>
        /// 失去焦点
        /// </summary>
        /// <param name="e"></param>
        protected override void OnLostFocus(EventArgs e)
        {
            base.OnLostFocus(e);
        }

        /// <summary>
        /// 输入焦点离开控件
        /// </summary>
        /// <param name="e"></param>
        protected override void OnLeave(EventArgs e)
        {
            base.OnLeave(e);
            //this.Entered = false;
        }

        /// <summary>
        /// 控件正在验证
        /// </summary>
        /// <param name="e"></param>
        protected override void OnValidating(CancelEventArgs e)
        {
            base.OnValidating(e);
            if (this.HasError && !this._canLostFocusOnError)
            {
                e.Cancel = true;
            }
        }

        /// <summary>
        /// 控件完成验证
        /// </summary>
        /// <param name="e"></param>
        protected override void OnValidated(EventArgs e)
        {
            this.Entered = false;
            base.OnValidated(e);
        }
        #endregion

        #region 鼠标事件
        /// <summary>
        /// 鼠标进入控件
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseEnter(EventArgs e)
        {
            this.MouseOver = true;
            base.OnMouseEnter(e);
        }

        /// <summary>
        /// 鼠标离开控件
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave(e);
            this.MouseOver = false;
        }

        /// <summary>
        /// 鼠标移动
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);
        }

        /// <summary>
        /// 鼠标按下
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);
        }

        /// <summary>
        /// 鼠标抬起
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
        }
        #endregion
        #endregion

        #region 重写方法
        /// <summary>
        /// 处理 Windows 消息
        /// </summary>
        /// <param name="m">要处理的 Windows System.Windows.Forms.Message</param>
        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);

            if (m.Msg == (int)WindowsMessage.WM_PAINT ||
                m.Msg == (int)WindowsMessage.WM_NCPAINT ||
                m.Msg == (int)WindowsMessage.WM_CTLCOLOREDIT)
            {
                //this.WmBorderPaint(ref m);
                BorderColorPaint.WmBorderPaint(this._borderColor, this.Width, this.Height, ref m);
            }
        }
        #endregion

        #region 事件处理
        /// <summary>
        /// 获得焦点
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cklItem_Enter(object sender, EventArgs e)
        {
            this.OnEnter(e);
        }

        /// <summary>
        /// 焦点离开
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cklItem_Leave(object sender, EventArgs e)
        {
            this.OnLeave(e);
        }

        /// <summary>
        /// 鼠标进入控件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cklItem_MouseEnter(object sender, EventArgs e)
        {
            this.OnMouseEnter(e);
        }

        /// <summary>
        /// 鼠标离开控件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cklItem_MouseLeave(object sender, EventArgs e)
        {
            this.OnMouseLeave(e);
        }

        /// <summary>
        /// 全部选择
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void pnlAll_Click(object sender, EventArgs e)
        {
            if (this.chkAll.ThreeState)
            {
                int cs = (int)this.chkAll.CheckState + 1;
                cs = cs > 2 ? 0 : cs;
                this.chkAll.CheckState = (CheckState)cs;
            }
            else
            {
                this.chkAll.Checked = !this.chkAll.Checked;
            }
        }

        /// <summary>
        /// 全部选择状态改变
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void chkAll_CheckedChanged(object sender, EventArgs e)
        {
            //if (this._isCheckAll.HasValue && !this._isCheckAll.Value)
            //{
            //    return;
            //}
            //this._isCheckAll = true;
            //if (this._mustInput)
            //{
            //    CheckState cs = this.cklItem.GetItemsCheckState();
            //    if (cs != CheckState.Checked)
            //    {
            //        this.cklItem.SetItemsChecked(true);
            //    }
            //    this._isCheckAll = false;
            //    this.chkAll.Checked = true;
            //    this._isCheckAll = null;

            //    this.ValidateData();
            //    return;
            //}
            //this.cklItem.SetItemsChecked(this.chkAll.Checked);
            //this._isCheckAll = null;
        }

        /// <summary>
        /// 全部选择状态改变
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void chkAll_CheckStateChanged(object sender, EventArgs e)
        {
            if (this._isCheckAll.HasValue)
            {
                return;
            }
            if (this.cklItem.Items.Count == 0)
            {
                this._isCheckAll = false;
                this.chkAll.Checked = false;
                this._isCheckAll = null;
                return;
            }
            this._isCheckAll = true;
            switch (this.chkAll.CheckState)
            {
                case CheckState.Checked:
                    if (this.cklItem.SimpleChecked)
                    {
                        this._isCheckAll = null;
                        this.cklItem.ResetMustOrSimpleChecked();
                        this._isCheckAll = false;
                        this.chkAll.CheckState = this.cklItem.GetItemsCheckState();
                        this._isCheckAll = null;
                        return;
                    }
                    else
                    {
                        this.cklItem.SetItemsChecked(true);
                    }
                    break;
                case CheckState.Unchecked:
                    if (this._mustInput)
                    {
                        this._isCheckAll = null;
                        this.chkAll.Checked = true;
                        return;
                    }
                    this.cklItem.SetItemsChecked(false);
                    break;
                case CheckState.Indeterminate:
                    if (this.cklItem.SimpleChecked)
                    {
                        this._isCheckAll = null;
                        this.cklItem.ResetMustOrSimpleChecked();
                        this._isCheckAll = false;
                        this.chkAll.CheckState = this.cklItem.GetItemsCheckState();
                        this._isCheckAll = null;
                        return;
                    }
                    else
                    {
                        if (this._indeterminateIndices != null &&
                            this._indeterminateIndices.Count > 0)
                        {
                            this._isCheckAll = true;
                            for (int i = 0; i < this.cklItem.Items.Count; i++)
                            {
                                this.SetItemChecked(this._indeterminateIndices.Contains(i), i);
                            }
                        }
                        else
                        {
                            this._isCheckAll = null;
                            this.chkAll.Checked = false;
                            return;
                        }
                    }
                    break;
                default:
                    break;

            }
            this._isCheckAll = null;
            this.ValidateData();
        }

        /// <summary>
        /// 项目选择状态改变
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cklItem_ItemChecked(object sender, ItemCheckEventArgs e)
        {
            if (this._isCheckAll.HasValue)
            {
                return;
            }

            this._isCheckAll = false;
            this.chkAll.CheckState = this.cklItem.GetItemsCheckState();

            if (this.chkAll.ThreeState)
            {
                // 点击项目变成全选状态时，是否记录-不记录。
                //this._indeterminateIndices.Clear();
                if (this.chkAll.CheckState == CheckState.Indeterminate)
                {
                    // 点击项目变成全选状态时，是否记录-记录。
                    this._indeterminateIndices.Clear();
                    foreach (int checkedIndex in this.cklItem.CheckedIndices)
                    {
                        this._indeterminateIndices.Add(checkedIndex);
                    }
                }
            }
            this._isCheckAll = null;
            if (this._mustInput)
            {
                this.ValidateData();
            }
        }

        /// <summary>
        /// 验证有错误时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cklItem_HasErrorChanged(object sender, EventArgs e)
        {
            this.OnHasErrorChanged(e);
            this.InvalidateBorder();
        }

        /// <summary>
        /// 键盘按下事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void chkAll_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
        {
            switch (e.KeyCode)
            {
                case Keys.Up:
                case Keys.Left:
                case Keys.Down:
                case Keys.Right:
                    if (this.cklItem.Items.Count > 0)
                    {
                        this.cklItem.Focus();
                        if (this.cklItem.SelectedIndex == -1)
                        {
                            this.cklItem.SelectedIndex = 0;
                        }
                    }
                    break;
                default:
                    break;
            }
        }

        /// <summary>
        /// 在移动鼠标滚轮并且控件有焦点时发生
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void chkAll_MouseWheel(object sender, MouseEventArgs e)
        {
            //if (e.Delta > 0)
            //{
            //    this.lstItem.SelectPrevItem();
            //}
            //else
            //{
            //    this.lstItem.SelectNextItem();
            //}
            if (this.cklItem.Items.Count > 0)
            {
                this.cklItem.Focus();
                if (this.cklItem.SelectedIndex == -1)
                {
                    this.cklItem.SelectedIndex = 0;
                }
            }
        }

        /// <summary>
        /// 无选择项目
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cklItem_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (this.cklItem.SelectedIndex == -1)
            {
                this.chkAll.Focus();
            }
        }

        /// <summary>
        /// 全选checkbox获得焦点
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void chkAll_GotFocus(object sender, EventArgs e)
        {
            this.cklItem.SelectedIndex = -1;
        }
        #endregion

        #region 公有方法
        /// <summary>
        /// 第一个控件获得焦点
        /// </summary>
        public void FocusOnShown()
        {
            this.chkAll.Focus();
        }
        #endregion

        #region 保护方法
        /// <summary>
        /// 设置Item选中状态
        /// </summary>
        protected virtual void ResetMustChecked()
        {
            this.cklItem.ResetMustOrSimpleChecked();
        }
        #endregion

        #region 内部方法
        #endregion

        #region 私有方法
        /// <summary>
        /// 使父控件的指定区域无效（将其添加到控件的更新区域，下次绘制操作时将重新绘制更新区域），并向父控件发送绘制消息。
        /// </summary>
        private void InvalidateBorder()
        {
            Color? borderColor = BorderColorPaint.GetBorderColor(this as IDataVerifiable, this._entered, this._mouseOver);

            if (borderColor != this._borderColor)
            {
                this._borderColor = borderColor;
                if (this.Parent == null)
                {
                    this.Invalidate();
                }
                else
                {
                    this.Parent.Invalidate(this.Bounds, true);
                }
            }
        }
        #endregion

        #region IDataVerifiable 成员
        #region 成员变量
        /// <summary>
        /// 显示边框颜色
        /// </summary>
        private bool _showBorderColor = true;
        /// <summary>
        /// 控件的项目名
        /// </summary>
        private string _itemName = null;
        /// <summary>
        /// 控件是否是必须输入项目
        /// </summary>
        private bool _mustInput = false;
        /// <summary>
        /// 控件在验证输入错误时，如何提示
        /// </summary>
        private InputErrorAlert _errorAlert = InputErrorAlert.Validated;
        /// <summary>
        /// 是否显示必须输入项目的提示
        /// </summary>
        private bool _showMustInputAlert = true;
        /// <summary>
        /// 验证不通过时，焦点能否离开
        /// </summary>
        private bool _canLostFocusOnError = true;
        /// <summary>
        /// 验证是否有错误
        /// </summary>
        private bool _hasError = false;
        /// <summary>
        /// 是否自定义错误
        /// </summary>
        private bool _hasCustomerError = false;
        /// <summary>
        /// 错误编码
        /// </summary>
        private ControlErrorCode _errorCode = ControlErrorCode.DKC_0000;
        /// <summary>
        /// 错误消息
        /// </summary>
        private string _errorMessage = null;
        /// <summary>
        /// 自定义错误消息
        /// </summary>
        private string _customerErrorMessage = null;
        #endregion

        #region 属性
        /// <summary>
        /// 获取或设置控件是否显示边框颜色。
        /// </summary>
        [Description("获取或设置控件是否显示边框颜色。"), Category("IDataVerifiable")]
        [DefaultValue(true)]
        public bool ShowBorderColor
        {
            get
            {
                return this._showBorderColor;
            }
            set
            {
                if (this._showBorderColor != value)
                {
                    this._showBorderColor = value;
                    this.InvalidateBorder();
                }
            }
        }

        /// <summary>
        /// 获取或设置控件的项目名
        /// </summary>
        [Description("获取或设置控件的项目名。"), Category("IDataVerifiable")]
        [DefaultValue(null)]
        public string CDItemName
        {
            get
            {
                return this._itemName;
            }
            set
            {
                this._itemName = value;
            }
        }

        /// <summary>
        /// 获取或设置控件是否必须选中项目。
        /// </summary>
        [Description("获取或设置控件是否必须选中项目。"), Category("IDataVerifiable")]
        [DefaultValue(false)]
        public bool MustInput
        {
            get
            {
                return this._mustInput;
            }
            set
            {
                if (this._mustInput != value)
                {
                    this._mustInput = value;
                    this.cklItem.MustInput = value;
                    if (this._mustInput && this._showMustInputAlert)
                    {
                        this.InvalidateBorder();
                    }
                }
            }
        }

        /// <summary>
        /// 获取或设置控件是否必须选中项目。
        /// </summary>
        [Description("获取或设置控件在验证输入错误时，如何提示。"), Category("IDataVerifiable")]
        [DefaultValue(typeof(InputErrorAlert), "Validated")]
        public InputErrorAlert InputErrorAlert
        {
            get
            {
                return this._errorAlert;
            }
            set
            {
                if (this._errorAlert != value)
                {
                    this._errorAlert = value;
                    this.InvalidateBorder();
                }
            }
        }

        /// <summary>
        /// 获取或设置控件是否显示必须输入项目提示
        /// </summary>
        [Description("获取或设置控件是否显示必须输入项目提示。"), Category("IDataVerifiable")]
        [DefaultValue(true)]
        public bool ShowMustInputAlert
        {
            get
            {
                return this._showMustInputAlert;
            }
            set
            {
                if (this._showMustInputAlert != value)
                {
                    this._showMustInputAlert = value;
                    this.InvalidateBorder();
                }
            }
        }

        /// <summary>
        /// 获取或设置当验证不通过时，控件是否可以失去焦点
        /// </summary>
        [Description("获取或设置当验证不通过时，控件是否可以失去焦点。"), Category("IDataVerifiable")]
        [DefaultValue(true)]
        public bool CanLostFocusOnError
        {
            get
            {
                return this._canLostFocusOnError;
            }
            set
            {
                this._canLostFocusOnError = value;
            }
        }

        /// <summary>
        /// 获取控件校验时是否有错误
        /// </summary>
        [Description("获取控件校验时是否有错误。"), Category("IDataVerifiable")]
        [DefaultValue(false)]
        public bool HasError
        {
            get
            {
                return this._hasCustomerError || this._hasError || this.cklItem.HasError;
            }
        }

        /// <summary>
        /// 获取控件校验时的错误编码
        /// </summary>
        [Description("获取控件校验时的错误编码。"), Category("IDataVerifiable")]
        [DefaultValue(typeof(ControlErrorCode), "DKC_0000")]
        public ControlErrorCode ErrorCode
        {
            get
            {
                //return this._hasCustomerError ? ControlErrorCode.DKC_C001 : this._errorCode;
                return this._hasCustomerError ? ControlErrorCode.DKC_C001 : this.cklItem.ErrorCode;
            }
        }

        /// <summary>
        /// 获取控件校验时的错误消息
        /// </summary>
        [Description("获取控件校验时的错误编码。"), Category("IDataVerifiable")]
        [DefaultValue(null)]
        public string ErrorMessage
        {
            get
            {
                //return this._hasCustomerError ? this._customerErrorMessage : this._errorMessage;
                return this._hasCustomerError ? this._customerErrorMessage : this.cklItem.ErrorMessage;
            }
        }
        #endregion

        #region 公有方法
        /// <summary>
        /// 设置自定义错误
        /// </summary>
        /// <param name="hasError">输入是否有错误</param>
        /// <param name="errorMessage">错误消息</param>
        public virtual void SetCustomerError(bool hasError, string errorMessage)
        {
            if (this._hasCustomerError != hasError ||
                this._customerErrorMessage != errorMessage)
            {
                this._hasCustomerError = hasError;
                this._customerErrorMessage = errorMessage;
                this.OnHasErrorChanged(EventArgs.Empty);
                this.InvalidateBorder();
            }
        }

        /// <summary>
        /// 清除自定义错误
        /// </summary>
        public virtual void ClearCustomerError()
        {
            this.SetCustomerError(false, null);
        }

        /// <summary>
        /// 验证输入内容
        /// </summary>
        /// <returns>验证结果</returns>
        public virtual bool ValidateData()
        {
            //bool result = this.cklItem.ValidateData();
            //this.InvalidateBorder();
            //return result;
            if (this._mustInput && this.CheckedState == CheckState.Unchecked)
            {
                this.SetError(true, ControlErrorCode.DKC_0001, this.CDItemName);
                return false;
            }

            this.ClearError();
            return true;
        }

        /// <summary>
        /// 清除输入项
        /// </summary>
        public virtual void ClearValue()
        {
            this.chkAll.Checked = false;
            this._indeterminateIndices.Clear();
        }
        #endregion

        #region 保护方法
        /// <summary>
        /// 设置验证不通过错误
        /// </summary>
        /// <param name="hasError">是否有错误</param>
        /// <param name="code">错误编码</param>
        /// <param name="args">设置格式的对象</param>
        protected void SetError(bool hasError, ControlErrorCode code, params object[] args)
        {
            if (this._hasError != hasError ||
                this._errorCode != code)
            {
                this._hasError = hasError;
                this._errorCode = code;
                if (args != null && args.Length > 0)
                {
                    this._errorMessage = string.Format(code.GetDescription(), args);
                }
                else
                {
                    this._errorMessage = code.GetDescription();
                }
                this.OnHasErrorChanged(EventArgs.Empty);
                this.InvalidateBorder();
            }
        }

        /// <summary>
        /// 清除验证不通过错误
        /// </summary>
        protected void ClearError()
        {
            this.SetError(false, ControlErrorCode.DKC_0000);
        }
        #endregion
        #endregion

        #region IAsyncControl 成员
        #region 成员变量
        /// <summary>
        /// 异步处理开始时，控件状态
        /// </summary>
        private bool _asyncBeginStatus = false;
        private bool _asyncBeginFocused = false;
        private Control _activeControl = null;
        #endregion

        #region 公有方法
        /// <summary>
        /// 开始异步处理
        /// </summary>
        /// <param name="doFocus">是否处理焦点</param>
        public virtual void BeginAsync(ref bool doFocus)
        {
            this._asyncBeginFocused = false;
            //if (doFocus && this.Focused)
            if (doFocus && this.ActiveControl != null)
            {
                this._asyncBeginFocused = true;
                this._activeControl = this.ActiveControl;
                doFocus = false;
            }
            this._asyncBeginStatus = this.Enabled;
            this.Enabled = false;
        }

        /// <summary>
        /// 结束异步处理
        /// </summary>
        public virtual void EndAsync()
        {
            this.Enabled = this._asyncBeginStatus;
            if (this._asyncBeginFocused)
            {
                //this.Focus();
                this.ActiveControl = this._activeControl;
                this._activeControl = null;
            }
        }
        #endregion
        #endregion
    }
}