using System;
using System.Text;
using System.Drawing;
using System.ComponentModel;
using System.Windows.Forms;

namespace DevComponents.DotNetBar.Controls
{
    /// <summary>
    /// Represents the Check Box control with extended styles.
    /// </summary>
    [ToolboxBitmap(typeof(CheckBoxX), "Controls.CheckBoxX.ico"), ToolboxItem(true), DefaultEvent("CheckedChanged"), System.Runtime.InteropServices.ComVisible(false), Designer("DevComponents.DotNetBar.Design.CheckBoxXDesigner, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf")]
    public class CheckBoxX : BaseItemControl, ICommandSource
    {
        #region Private Variables
        private const string DefaultCheckValueUnchecked = "N";
        private const string DefaultCheckValueChecked = "Y";
        private const object DefaultCheckValueIndeterminate = null;

        private CheckBoxItem m_CheckBox = null;
        private object m_CheckValue = DefaultCheckValueUnchecked;

        private object m_CheckValueUnchecked = DefaultCheckValueUnchecked;
        private object m_CheckValueChecked = DefaultCheckValueChecked;
        private object m_CheckValueIndeterminate = DefaultCheckValueIndeterminate;
        private bool m_ConsiderEmptyStringAsNull = true;
        #endregion

        #region Events
        /// <summary>
        /// Occurs before Checked property is changed and allows you to cancel the change.
        /// </summary>
        public event CheckBoxXChangeEventHandler CheckedChanging;
        
        /// <summary>
        /// Occurs after Checked property is changed with extended information.
        /// </summary>
        public event CheckBoxXChangeEventHandler CheckedChangedEx;

        /// <summary>
        /// Occurs after Checked property is changed. This event is provided for the Windows Forms data binding support. You can use CheckedChangedEx to get extended information about the changed.
        /// </summary>
        public event EventHandler CheckedChanged;

        /// <summary>
        /// Occurs after Checked property is changed. This event is provided for the Windows Forms data binding support. You can use CheckedChangedEx to get extended information about the changed.
        /// </summary>
        public event EventHandler CheckValueChanged;
        #endregion

        #region Constructor, Dispose
        public CheckBoxX()
        {
            this.SetStyle(ControlStyles.Selectable, true);
            m_CheckBox = new CheckBoxItem();
            m_CheckBox.VerticalPadding = 0;
            m_CheckBox.Style = eDotNetBarStyle.Office2007;
            m_CheckBox.CheckedChanging += new CheckBoxChangeEventHandler(OnCheckedChanging);
            m_CheckBox.CheckedChanged += new CheckBoxChangeEventHandler(OnCheckedChanged);
            this.HostItem = m_CheckBox;
        }

        #endregion

        #region Internal Implementation
        /// <summary>
        /// Gets or sets the size of the check or radio sign. Default value is 13x13. Minimum value is 6x6.
        /// </summary>
        [Category("Appearance"), Description("Indicates size of the check or radio sign. Default value is 13x13.")]
        public Size CheckSignSize
        {
            get { return m_CheckBox.CheckSignSize; }
            set { m_CheckBox.CheckSignSize = value; this.RecalcLayout(); this.Invalidate(); }
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeCheckSignSize()
        {
            return m_CheckBox.ShouldSerializeCheckSignSize();
        }
        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetCheckSignSize()
        {
            this.CheckSignSize = new Size(13, 13);
        }

        /// <summary>
        /// Gets or sets whether text-markup support is enabled for controls Text property. Default value is true.
        /// Set this property to false to display HTML or other markup in the control instead of it being parsed as text-markup.
        /// </summary>
        [DefaultValue(true), Category("Appearance"), Description("Indicates whether text-markup support is enabled for controls Text property.")]
        public bool EnableMarkup
        {
            get { return m_CheckBox.EnableMarkup; }
            set
            {
                m_CheckBox.EnableMarkup = value;
            }
        }
        protected override MouseButtons MouseDownFocusButtons
        {
            get { return MouseButtons.Left | MouseButtons.Right | MouseButtons.Middle | MouseButtons.XButton1 | MouseButtons.XButton2; }
        }
        //protected override void OnMouseDown(MouseEventArgs e)
        //{
        //    if (!this.Focused)
        //        this.Select();
        //    base.OnMouseDown(e);
        //}

        //protected override void OnEnter(EventArgs e)
        //{
        //    if (this.CheckBoxStyle == eCheckBoxStyle.RadioButton && Control.MouseButtons == MouseButtons.None && WinApi.GetKeyState(9) < 0 && this.AutoCheck)
        //    {
        //        m_CheckBox.SetChecked(true, eEventSource.Keyboard);
        //    }
        //    base.OnEnter(e);
        //}

        /// <summary>
        /// Invokes the CheckedChanged event.
        /// </summary>
        private void OnCheckedChanged(object sender, CheckBoxChangeEventArgs e)
        {
            CheckBoxX previous = null;
            if (m_CheckBox.CheckBoxStyle == eCheckBoxStyle.RadioButton && m_CheckBox.Checked && this.Parent != null)
            {
                foreach (Control c in this.Parent.Controls)
                {
                    if (c == this)
                    {
                        //c.TabStop = true;
                        continue;
                    }
                    CheckBoxX b = c as CheckBoxX;
                    if (b != null && b.Checked && b.CheckBoxStyle == eCheckBoxStyle.RadioButton)
                    {
                        b.Checked = false;
                        //b.TabStop = false;
                        previous = b;
                    }
                }
            }

            if (this.Command != null)
                this.Command.Checked = this.Checked;

            CheckBoxXChangeEventArgs e1 = new CheckBoxXChangeEventArgs(previous, this, e.EventSource);

            if (CheckedChangedEx != null)
                CheckedChangedEx(this, e1);

            if (CheckedChanged != null)
                CheckedChanged(this, new EventArgs());

            if (GetCheckState(m_CheckValue) != this.CheckState)
                m_CheckValue = GetCheckValue(this.CheckState);

            if (CheckValueChanged != null)
                CheckValueChanged(this, new EventArgs());

            ExecuteCommand();
        }

        /// <summary>
        /// Invokes CheckedChanging event.
        /// </summary>
        private void OnCheckedChanging(object sender, CheckBoxChangeEventArgs e)
        {
            CheckBoxXChangeEventArgs e1 = new CheckBoxXChangeEventArgs(null, this, e.EventSource);

            if (m_CheckBox.CheckBoxStyle == eCheckBoxStyle.RadioButton && !m_CheckBox.Checked && this.Parent != null)
            {
                CheckBoxX b = null;
                foreach (Control c in this.Parent.Controls)
                {
                    if (c == this)
                        continue;
                    b = c as CheckBoxX;
                    if (b != null && b.Checked && b.CheckBoxStyle == eCheckBoxStyle.RadioButton)
                    {
                        break;
                    }
                }
                e1 = new CheckBoxXChangeEventArgs(b, this, e.EventSource);
            }

            if (CheckedChanging != null)
            {
                CheckedChanging(this, e1);
                e.Cancel = e1.Cancel;
            }
        }

        /// <summary>
        /// Gets or sets the appearance style of the item. Default value is CheckBox. Item can also assume the style of radio-button.
        /// </summary>
        [Browsable(true), DefaultValue(eCheckBoxStyle.CheckBox), Category("Appearance"), Description("Indicates appearance style of the item. Default value is CheckBox. Item can also assume the style of radio-button.")]
        public eCheckBoxStyle CheckBoxStyle
        {
            get { return m_CheckBox.CheckBoxStyle; }
            set
            {
                m_CheckBox.CheckBoxStyle = value;
            }
        }

        /// <summary>
        /// Gets or sets the check box position relative to the text. Default value is Left.
        /// </summary>
        [Browsable(true), DefaultValue(eCheckBoxPosition.Left), Category("Appearance"), Description("Indicates the check box position relative to the text.")]
        public eCheckBoxPosition CheckBoxPosition
        {
            get { return m_CheckBox.CheckBoxPosition; }
            set
            {
                m_CheckBox.CheckBoxPosition = value;
            }
        }

        /// <summary>
        /// Gets or set a value indicating whether the button is in the checked state.
        /// </summary>
        [Browsable(true), Bindable(true), DevCoBrowsable(true), Category("Appearance"), Description("Indicates whether item is checked or not."), DefaultValue(false)]
        public virtual bool Checked
        {
            get
            {
                return m_CheckBox.Checked;
            }
            set
            {
                m_CheckBox.Checked = value;
            }
        }

        /// <summary>
        /// Gets or sets whether text assigned to the check box is visible. Default value is true.
        /// </summary>
        [Browsable(true), DefaultValue(true), Category("Appearance"), Description("Indicates whether text assigned to the check box is visible.")]
        public bool TextVisible
        {
            get { return m_CheckBox.TextVisible; }
            set
            {
                m_CheckBox.TextVisible = value;
                this.RecalcLayout();
            }
        }

        /// <summary>
        /// Gets or sets the text color. Default value is Color.Empty which indicates that default color is used.
        /// </summary>
        [Browsable(true), Category("Appearance"), Description("Indicates text color.")]
        public Color TextColor
        {
            get { return m_CheckBox.TextColor; }
            set
            {
                m_CheckBox.TextColor = value;
            }
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public bool ShouldSerializeTextColor()
        {
            return !m_CheckBox.TextColor.IsEmpty;
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public void ResetTextColor()
        {
            this.TextColor = Color.Empty;
        }

        [Browsable(false)]
        public override Color ForeColor
        {
            get
            {
                return base.ForeColor;
            }
            set
            {
                base.ForeColor = value;
            }
        }

        protected override void OnKeyDown(KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Space && this.Enabled && this.AutoCheck)
            {
                if (this.CheckBoxStyle == eCheckBoxStyle.CheckBox)
                    SetChecked(!this.Checked, eEventSource.Keyboard);
                else if (!this.Checked)
                    SetChecked(true, eEventSource.Keyboard);
            }
            base.OnKeyDown(e);
        }

        private void SetChecked(bool newValue, eEventSource source)
        {
            m_CheckBox.SetChecked(newValue, source);
        }

        private void SetChecked(CheckState newValue, eEventSource source)
        {
            m_CheckBox.SetChecked(newValue, source);
        }

        /// <summary>
        /// Gets or sets the text associated with the control.
        /// </summary>
        [Browsable(true), Editor("DevComponents.DotNetBar.Design.TextMarkupUIEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(System.Drawing.Design.UITypeEditor)), Category("Appearance"), Description("Indicates text associated with this button.."), Localizable(true), DefaultValue("")]
        public override string Text
        {
            get { return base.Text; }
            set { base.Text = value; }
        }

#if FRAMEWORK20
        [Localizable(true), Browsable(false)]
        public new System.Windows.Forms.Padding Padding
        {
            get { return base.Padding; }
            set { base.Padding = value; }
        }

        public override Size GetPreferredSize(Size proposedSize)
        {
            if (!BarFunctions.IsHandleValid(this))
                return base.GetPreferredSize(proposedSize);
            if (this.Text.Length == 0)
                return base.GetPreferredSize(proposedSize);

            m_CheckBox.RecalcSize();
            Size s = m_CheckBox.Size;
            s.Width += 2;
            s.Height += 2;
            if (!this.TextVisible) s.Width += 2;
            m_CheckBox.Bounds = GetItemBounds();
            return s;
        }

        /// <summary>
        /// Gets or sets a value indicating whether the control is automatically resized to display its entire contents. You can set MaximumSize.Width property to set the maximum width used by the control.
        /// </summary>
        [Browsable(true), DefaultValue(false), EditorBrowsable(EditorBrowsableState.Always), DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public override bool AutoSize
        {
            get
            {
                return base.AutoSize;
            }
            set
            {
                if (this.AutoSize != value)
                {
                    base.AutoSize = value;
                    AdjustSize();
                }
            }
        }

        protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
        {
            if (this.AutoSize)
            {
                Size preferredSize = base.PreferredSize;
                width = preferredSize.Width;
                height = preferredSize.Height;
            }
            base.SetBoundsCore(x, y, width, height, specified);
        }

        private void AdjustSize()
        {
            if (this.AutoSize)
            {
                this.Size = base.PreferredSize;
            }
        }

        protected override void OnTextChanged(EventArgs e)
        {
            base.OnTextChanged(e);
            this.AdjustSize();
        }

        protected override void OnHandleCreated(EventArgs e)
        {
            base.OnHandleCreated(e);
            if (this.AutoSize)
                this.AdjustSize();
        }
#endif

        /// <summary>
        /// Gets or sets a value indicating whether the CheckBox will allow three check states rather than two. If the ThreeState property is set to true
        /// CheckState property should be used instead of Checked property to set the extended state of the control.
        /// </summary>
        [Browsable(true), Category("Behavior"), DefaultValue(false), Description("Indicates whether the CheckBox will allow three check states rather than two.")]
        public bool ThreeState
        {
            get { return m_CheckBox.ThreeState; }
            set { m_CheckBox.ThreeState = value; }
        }

        /// <summary>
        /// Specifies the state of a control, such as a check box, that can be checked, unchecked, or set to an indeterminate state. 
        /// </summary>
        [Browsable(true), Category("Behavior"), DefaultValue(CheckState.Unchecked), Description("Specifies the state of a control, such as a check box, that can be checked, unchecked, or set to an indeterminate state")]
        public CheckState CheckState
        {
            get { return m_CheckBox.CheckState; }
            set { m_CheckBox.CheckState = value; }
        }

        /// <summary>
        /// Gets the underlying CheckBoxItem
        /// </summary>
        internal CheckBoxItem CheckBoxItem
        {
            get { return (m_CheckBox); }
        }

        private bool _EnableMnemonicWithAltKeyOnly = false;
        /// <summary>
        /// Gets or sets whether mnemonic character assigned to control is processed only if Alt key is pressed. Default value is false which indicate that Alt key is not required.
        /// </summary>
        [DefaultValue(false), Category("Behavior"), Description("Indicates whether mnemonic character assigned to control is processed only if Alt key is pressed")]
        public bool EnableMnemonicWithAltKeyOnly
        {
            get { return _EnableMnemonicWithAltKeyOnly; }
            set
            {
                _EnableMnemonicWithAltKeyOnly = value;
            }
        }

        protected override bool ProcessMnemonic(char charCode)
        {
            if (AutoCheck && CanSelect && IsMnemonic(charCode, this.Text) && this.Enabled &&
                (!_EnableMnemonicWithAltKeyOnly || Control.ModifierKeys == Keys.Alt || this.Focused) && !m_CheckBox.IsUsingTextMarkup)
            {
                if (Focus())
                {
                    if (this.CheckBoxStyle == eCheckBoxStyle.CheckBox)
                        SetChecked(!this.Checked, eEventSource.Keyboard);
                    else if (!this.Checked)
                        SetChecked(true, eEventSource.Keyboard);
                    return true;
                }
            }
            return false;
        }
        #endregion

        #region Data-Binding Support
        /// <summary>
        /// Gets or set whether the Checked values and the item appearance are automatically changed when the Check-Box is clicked. Default value is true.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Description("Indicates whether the Checked values and the item appearance are automatically changed when the Check-Box is clicked.")]
        public bool AutoCheck
        {
            get { return m_CheckBox.AutoCheck; }
            set
            {
                m_CheckBox.AutoCheck = value;
            }
        }
        /// <summary>
        /// Gets or sets the object that represents the Checked state of control.
        /// </summary>
        [DefaultValue("N"), Bindable(true), RefreshProperties(RefreshProperties.All), TypeConverter(typeof(StringConverter)), Description("Indicates object that represents the Checked state of control.")]
        public object CheckValue
        {
            get { return m_CheckValue; }
            set
            {
                m_CheckValue = value;
                OnCheckValueChanged();
            }
        }

        private void OnCheckValueChanged()
        {
            CheckState cs = GetCheckState(m_CheckValue);
            this.CheckState = cs;
        }

        private bool IsNull(object value)
        {
            return value == null || value is string && (string)value == string.Empty && m_ConsiderEmptyStringAsNull ||
                value == DBNull.Value;
        }

        private object GetCheckValue(CheckState cs)
        {
            if (cs == CheckState.Indeterminate)
                return m_CheckValueIndeterminate;

            if (cs == CheckState.Unchecked)
                return m_CheckValueUnchecked;

            return m_CheckValueChecked;
        }

        private CheckState GetCheckState(object value)
        {
            if (m_CheckValueIndeterminate == null && IsNull(value) || m_CheckValueIndeterminate!=null && m_CheckValueIndeterminate.Equals(value))
            {
                return CheckState.Indeterminate;
            }
            else if (m_CheckValueChecked == null && IsNull(value) || m_CheckValueChecked!=null && m_CheckValueChecked.Equals(value))
            {
                return CheckState.Checked;
            }
            else if (m_CheckValueUnchecked == null && IsNull(value) || m_CheckValueUnchecked!=null && m_CheckValueUnchecked.Equals(value))
            {
                return CheckState.Unchecked;
            }
            else
            {
                if (value is System.Data.SqlTypes.SqlBoolean)
                {
                    System.Data.SqlTypes.SqlBoolean sqlBool = (System.Data.SqlTypes.SqlBoolean)value;
                    if (sqlBool.IsTrue)
                        return CheckState.Checked;
                    else if (sqlBool.IsNull)
                        return CheckState.Indeterminate;
                    else
                        return CheckState.Unchecked;
                }
                else if (value is int? && this.ThreeState)
                {
                    if (value == null) return CheckState.Indeterminate;
                    if (((int?)value).Value == 0)
                        return CheckState.Unchecked;
                    return CheckState.Checked;
                }
                else if (value is int)
                {
                    if (this.ThreeState && (int)value == -1)
                        return CheckState.Indeterminate;
                    return ((int)value) == 0 ? CheckState.Unchecked : CheckState.Checked;
                }
                else if (value is long)
                {
                    if (this.ThreeState && (long)value == -1)
                        return CheckState.Indeterminate;
                    return ((long)value) == 0 ? CheckState.Unchecked : CheckState.Checked;
                }
                else if (value is short)
                {
                    if (this.ThreeState && (short)value == -1)
                        return CheckState.Indeterminate;
                    return ((short)value) == 0 ? CheckState.Unchecked : CheckState.Checked;
                }
                else if (value is float)
                {
                    if (this.ThreeState && (float)value == -1)
                        return CheckState.Indeterminate;
                    return ((float)value) == 0 ? CheckState.Unchecked : CheckState.Checked;
                }
                else if (value is double)
                {
                    if (this.ThreeState && (double)value == -1)
                        return CheckState.Indeterminate;
                    return ((double)value) == 0 ? CheckState.Unchecked : CheckState.Checked;
                }
                else if (value is byte)
                {
                    return ((byte)value) == 0 ? CheckState.Unchecked : CheckState.Checked;
                }
                else if (value is uint)
                {
                    return ((uint)value) == 0 ? CheckState.Unchecked : CheckState.Checked;
                }
                else if (value is ulong)
                {
                    return ((ulong)value) == 0 ? CheckState.Unchecked : CheckState.Checked;
                }
                else if (value is bool)
                {
                    return ((bool)value) == false ? CheckState.Unchecked : CheckState.Checked;
                }
                
                return CheckState.Indeterminate;
            }
        }

        /// <summary>
        /// Gets or sets whether empty string is consider as null value during CheckValue value comparison. Default value is true.
        /// </summary>
        [DefaultValue(true), Category("Behavior"), Browsable(true), Description("Indicates whether empty string is consider as null value during CheckValue value comparison.")]
        public bool ConsiderEmptyStringAsNull
        {
            get { return m_ConsiderEmptyStringAsNull; }
            set { m_ConsiderEmptyStringAsNull = value; }
        }

        /// <summary>
        /// Gets or sets the value that represents the Indeterminate state of check box when CheckValue property is set to that value. Default value is null.
        /// </summary>
        [Browsable(true), DefaultValue(null), Category("Behavior"), TypeConverter(typeof(StringConverter)), Description("Represents the Indeterminate state value of check box when CheckValue property is set to that value")]
        public object CheckValueIndeterminate
        {
            get { return m_CheckValueIndeterminate; }
            set { m_CheckValueIndeterminate = value; OnCheckValueChanged(); }
        }

        /// <summary>
        /// Gets or sets the value that represents the Checked state of check box when CheckValue property is set to that value. Default value is null.
        /// </summary>
        [Browsable(true), DefaultValue("Y"), Category("Behavior"), TypeConverter(typeof(StringConverter)), Description("Represents the Checked state value of check box when CheckValue property is set to that value")]
        public object CheckValueChecked
        {
            get { return m_CheckValueChecked; }
            set { m_CheckValueChecked = value; OnCheckValueChanged(); }
        }

        /// <summary>
        /// Gets or sets the value that represents the Unchecked state of check box when CheckValue property is set to that value. Default value is null.
        /// </summary>
        [Browsable(true), DefaultValue("N"), Category("Behavior"), TypeConverter(typeof(StringConverter)), Description("Represents the Unchecked state value of check box when CheckValue property is set to that value")]
        public object CheckValueUnchecked
        {
            get { return m_CheckValueUnchecked; }
            set { m_CheckValueUnchecked = value; OnCheckValueChanged(); }
        }

        /// <summary>
        /// Gets or sets the custom image that is displayed instead default check box representation when check box is checked.
        /// </summary>
        [DefaultValue(null), Category("CheckBox Images"), Description("Indicates custom image that is displayed instead default check box representation when check box is checked")]
        public Image CheckBoxImageChecked
        {
            get { return m_CheckBox.CheckBoxImageChecked; }
            set
            {
                m_CheckBox.CheckBoxImageChecked = value;
            }
        }
        /// <summary>
        /// Gets or sets the custom image that is displayed instead default check box representation when check box is unchecked.
        /// </summary>
        [DefaultValue(null), Category("CheckBox Images"), Description("Indicates custom image that is displayed instead default check box representation when check box is unchecked")]
        public Image CheckBoxImageUnChecked
        {
            get { return m_CheckBox.CheckBoxImageUnChecked; }
            set
            {
                m_CheckBox.CheckBoxImageUnChecked = value;
            }
        }
        /// <summary>
        /// Gets or sets the custom image that is displayed instead default check box representation when check box is in indeterminate state.
        /// </summary>
        [DefaultValue(null), Category("CheckBox Images"), Description("Indicates custom image that is displayed instead default check box representation when check box is in indeterminate state")]
        public Image CheckBoxImageIndeterminate
        {
            get { return m_CheckBox.CheckBoxImageIndeterminate; }
            set
            {
                m_CheckBox.CheckBoxImageIndeterminate = value;
            }
        }
        #endregion

        #region ICommandSource Members
        protected virtual void ExecuteCommand()
        {
            if (_Command == null) return;
            CommandManager.ExecuteCommand(this);
        }

        /// <summary>
        /// Gets or sets the command assigned to the item. Default value is null.
        /// <remarks>Note that if this property is set to null Enabled property will be set to false automatically to disable the item.</remarks>
        /// </summary>
        [DefaultValue(null), Category("Commands"), Description("Indicates the command assigned to the item.")]
        public Command Command
        {
            get { return (Command)((ICommandSource)this).Command; }
            set
            {
                ((ICommandSource)this).Command = value;
            }
        }

        private ICommand _Command = null;
        //[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        ICommand ICommandSource.Command
        {
            get
            {
                return _Command;
            }
            set
            {
                bool changed = false;
                if (_Command != value)
                    changed = true;

                if (_Command != null)
                    CommandManager.UnRegisterCommandSource(this, _Command);
                _Command = value;
                if (value != null)
                    CommandManager.RegisterCommand(this, value);
                if (changed)
                    OnCommandChanged();
            }
        }

        /// <summary>
        /// Called when Command property value changes.
        /// </summary>
        protected virtual void OnCommandChanged()
        {
            Command command = this.Command;
            if (command != null && command.Checked != this.Checked)
            {
                SetChecked(command.Checked, eEventSource.Code);
            }
        }

        private object _CommandParameter = null;
        /// <summary>
        /// Gets or sets user defined data value that can be passed to the command when it is executed.
        /// </summary>
        [Browsable(true), DefaultValue(null), Category("Commands"), Description("Indicates user defined data value that can be passed to the command when it is executed."), System.ComponentModel.TypeConverter(typeof(System.ComponentModel.StringConverter)), System.ComponentModel.Localizable(true)]
        public object CommandParameter
        {
            get
            {
                return _CommandParameter;
            }
            set
            {
                _CommandParameter = value;
            }
        }

        #endregion
    }

    /// <summary>
    /// Delegate for OptionGroupChanging event.
    /// </summary>
    public delegate void CheckBoxXChangeEventHandler(object sender, CheckBoxXChangeEventArgs e);

    #region CheckBoxXChangeEventArgs
    /// <summary>
    /// Represents event arguments for OptionGroupChanging event.
    /// </summary>
    public class CheckBoxXChangeEventArgs : EventArgs
    {
        /// <summary>
        /// Set to true to cancel the checking on NewChecked button.
        /// </summary>
        public bool Cancel = false;
        /// <summary>
        /// Check-box that will become checked if operation is not cancelled.
        /// </summary>
        public readonly CheckBoxX NewChecked;
        /// <summary>
        /// Check-box that is currently checked and which will be unchecked if operation is not cancelled. This property will have only valid values for eCheckBoxStyle.RadioButton style CheckBoxItems.
        /// </summary>
        public readonly CheckBoxX OldChecked;
        /// <summary>
        /// Indicates the action that has caused the event.
        /// </summary>
        public readonly eEventSource EventSource = eEventSource.Code;

        /// <summary>
        /// Default constructor.
        /// </summary>
        public CheckBoxXChangeEventArgs(CheckBoxX oldchecked, CheckBoxX newchecked, eEventSource eventSource)
        {
            NewChecked = newchecked;
            OldChecked = oldchecked;
            EventSource = eventSource;
        }
    }
    #endregion
}