using System;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using DevComponents.DotNetBar.SuperGrid.Primitives;
using DevComponents.DotNetBar.SuperGrid.Style;
using DevComponents.SuperGrid.TextMarkup;

namespace DevComponents.DotNetBar.SuperGrid
{
    ///<summary>
    ///ColumnGroupHeaderCollection
    ///</summary>
    [Editor("DevComponents.SuperGrid.Design.ColumnGroupHeaderCollectionEditor, DevComponents.SuperGrid.Design, Version=14.1.0.37, Culture=neutral,  PublicKeyToken=26d81176cfa2b486", typeof(UITypeEditor))]
    public class ColumnGroupHeaderCollection : CustomCollection<ColumnGroupHeader>
    {
        #region Events

        #region HeaderMarkupLinkClick

        internal event EventHandler<GroupHeaderMarkupLinkClickEventArgs> GroupHeaderMarkupLinkClick;

        #endregion

        #endregion

        #region Private variables

        private object _Parent;

        #endregion

        #region Public properties

        #region Name indexer

        ///<summary>
        /// Name indexer
        ///</summary>
        ///<param name="name"></param>
        ///<exception cref="Exception"></exception>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ColumnGroupHeader this[string name]
        {
            get
            {
                int index = FindIndexByName(name);

                return (index >= 0 ? this[index] : null);
            }

            set
            {
                int index = FindIndexByName(name);

                if (index < 0)
                    throw new Exception("Column Name not defined (" + name + ").");

                Items[index] = value;
            }
        }

        #region FindIndexByName

        private int FindIndexByName(string name)
        {
            for (int i = 0; i < Items.Count; i++)
            {
                ColumnGroupHeader item = Items[i];

                if (name != null)
                    name = name.ToUpper();

                if (item.Name != null && item.Name.ToUpper().Equals(name))
                    return (i);
            }

            return (-1);
        }

        #endregion

        #endregion

        #region Parent

        ///<summary>
        /// Parent
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public object Parent
        {
            get { return (_Parent); }
            internal set { _Parent = value; }
        }

        #endregion

        #endregion

        #region OnCollectionChanged

        /// <summary>
        /// Handles CollectionChange notifications
        /// </summary>
        /// <param name="e"></param>
        protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    foreach (INotifyPropertyChanged newValue in e.NewItems)
                    {
                        ItemChangeHandler(null, newValue);
                        PropertyChangeHandler(null, newValue);
                    }
                    break;

                case NotifyCollectionChangedAction.Remove:
                    foreach (INotifyPropertyChanged oldValue in e.OldItems)
                    {
                        ItemChangeHandler(null, oldValue);
                        PropertyChangeHandler(null, oldValue);
                    }
                    break;

                case NotifyCollectionChangedAction.Replace:
                    for (int i = 0; i < e.OldItems.Count; i++)
                    {
                        ItemChangeHandler(e.OldItems[i], e.NewItems[i]);

                        PropertyChangeHandler((INotifyPropertyChanged)e.OldItems[i],
                                              (INotifyPropertyChanged)e.NewItems[i]);
                    }
                    break;

                case NotifyCollectionChangedAction.Reset:
                    for (int i = 0; i < Items.Count; i++)
                    {
                        ItemChangeHandler(Items[i], null);
                        PropertyChangeHandler(Items[i], null);
                    }
                    break;
            }

            base.OnCollectionChanged(e);
        }

        #endregion

        #region ItemChangeHandler

        private void ItemChangeHandler(object oldValue, object newValue)
        {
            ColumnGroupHeader cgh = oldValue as ColumnGroupHeader;

            if (cgh != null)
            {
                cgh.Collection = null;
                cgh.GroupHeaderMarkupLinkClick -= CGroupHeaderMarkupLinkClick;
            }

            cgh = newValue as ColumnGroupHeader;

            if (cgh != null)
            {
                cgh.Collection = this;
                cgh.GroupHeaderMarkupLinkClick += CGroupHeaderMarkupLinkClick;
            }
        }

        #endregion

        #region CGroupHeaderMarkupLinkClick

        void CGroupHeaderMarkupLinkClick(object sender, GroupHeaderMarkupLinkClickEventArgs e)
        {
            if (GroupHeaderMarkupLinkClick != null)
                GroupHeaderMarkupLinkClick(sender, e);
        }

        #endregion

        #region PropertyChangeHandler

        private void PropertyChangeHandler(
            INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
        {
            if (oldValue != null)
                oldValue.PropertyChanged -= PropertyValueChanged;

            if (newValue != null)
                newValue.PropertyChanged += PropertyValueChanged;
        }

        #endregion

        #region PropertyValueChanged

        /// <summary>
        /// Occurs when one of element visual styles has property changes.
        /// Default implementation invalidates visual appearance of element.
        /// </summary>
        /// <param name="sender">VisualStyle that changed.</param>
        /// <param name="e">Event arguments.</param>
        protected virtual void PropertyValueChanged(object sender, PropertyChangedEventArgs e)
        {
            OnPropertyChanged(e);
        }

        #endregion

        #region INotifyPropertyChanged Members

        /// <summary>
        /// Default PropertyChanged processing
        /// </summary>
        /// <param name="s"></param>
        /// <param name="changeType">invalidate</param>
        protected void OnPropertyChangedEx(string s, VisualChangeType changeType)
        {
            OnPropertyChanged(new VisualPropertyChangedEventArgs(s, changeType));
        }

        #endregion
    }

    ///<summary>
    ///Column GroupHeader
    ///</summary>
    public class ColumnGroupHeader : INotifyPropertyChanged, IDisposable
    {
        #region Events

        #region HeaderMarkupLinkClick

        internal event EventHandler<GroupHeaderMarkupLinkClickEventArgs> GroupHeaderMarkupLinkClick;

        #endregion

        #endregion

        #region Private variables

        private int _StartDisplayIndex = -1;
        private int _EndDisplayIndex = -1;

        private int _RowHeight;
        private int _MinRowHeight;

        private int _StyleUpdateCount;

        private ColumnHeaderVisualStyles _HeaderStyles;
        private ColumnHeaderVisualStyles _EffectiveStyles;

        private ColumnGroupHeaderCollection _Collection;
        private ColumnGroupHeaderCollection _GroupHeaders;

        private string _Name;
        private string _ToolTip;
        private string _HeaderText;

        private BodyElement _HeaderTextMarkup;

        private Size _Size;
        private Size _ContentSize;
        private Size _HeaderTextSize;
        private Rectangle _BoundsRelative;

        private Shs _States;
        private Tbool _ShowColumnHeaders = Tbool.NotSet;
        private Tbool _AutoApplyGroupColors = Tbool.NotSet;

        #endregion

        ///<summary>
        ///ColumnGroupHeader
        ///</summary>
        public ColumnGroupHeader()
        {
            AllowSelection = true;
            Visible = true;
        }

        #region Public properties

        #region AllowSelection

        /// <summary>
        /// Gets or sets whether the element can be selected
        /// </summary>
        [DefaultValue(true), Category("Behavior")]
        [Description("Indicates whether the element can be selected")]
        public bool AllowSelection
        {
            get { return (TestState(Shs.AllowSelection)); }

            set
            {
                if (AllowSelection != value)
                {
                    SetState(Shs.AllowSelection, value);

                    OnPropertyChangedEx("AllowSelection", VisualChangeType.Render);
                }
            }
        }

        #endregion

        #region AutoApplyGroupColors

        ///<summary>
        /// Gets or sets whether Group Header color properties
        /// (ie. Background and TextColor) are automatically
        /// applied to group Column Headers
        ///</summary>
        [DefaultValue(Tbool.NotSet), Category("Appearance")]
        [Description("Indicates whether Group Header color properties (ie. Background and TextColor) are automatically applied to group Column Headers.")]
        public Tbool AutoApplyGroupColors
        {
            get { return (_AutoApplyGroupColors); }

            set
            {
                if (_AutoApplyGroupColors != value)
                {
                    _AutoApplyGroupColors = value;

                    OnPropertyChangedEx("AutoApplyGroupColors", VisualChangeType.Render);
                }
            }
        }

        #endregion

        #region Collection

        ///<summary>
        ///The collection the item is contained within
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ColumnGroupHeaderCollection Collection
        {
            get { return (_Collection); }
            internal set { _Collection = value; }
        }

        #endregion

        #region DisplayCount

        ///<summary>
        /// Gets the count of displayed columns
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int DisplayCount
        {
            get { return (_EndDisplayIndex - _StartDisplayIndex + 1); }
        }

        #endregion

        #region EnableHeaderMarkup

        /// <summary>
        /// Gets or sets whether text-markup support is enabled for the HeaderText
        /// </summary>
        [DefaultValue(false), Category("Appearance")]
        [Description("Indicates whether text-markup support is enabled for the HeaderText.")]
        public bool EnableHeaderMarkup
        {
            get { return (TestState(Shs.EnableHeaderMarkup)); }

            set
            {
                if (EnableHeaderMarkup != value)
                {
                    SetState(Shs.EnableHeaderMarkup, value);

                    MarkupHeaderTextChanged();

                    OnPropertyChangedEx("EnableHeaderMarkup", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region EndDisplayIndex

        ///<summary>
        /// Gets or sets the end column display index
        ///</summary>
        [DefaultValue(0), Category("Appearance")]
        [Description("Indicates the end column display index (inclusive)")]
        public int EndDisplayIndex
        {
            get { return ((_EndDisplayIndex < 0) ? 0 : _EndDisplayIndex); }

            set
            {
                if (_EndDisplayIndex != value)
                {
                    _EndDisplayIndex = value;

                    OnPropertyChangedEx("EndDisplayIndex", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region GroupHeaders

        ///<summary>
        ///Gets or sets the GroupHeaders contained under the given header
        ///</summary>
        [DefaultValue(null), Category("Appearance")]
        [Description("Indicates the GroupHeaders contained under the given header.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ColumnGroupHeaderCollection GroupHeaders
        {
            get
            {
                if (_GroupHeaders == null)
                {
                    _GroupHeaders = new ColumnGroupHeaderCollection();
                    _GroupHeaders.Parent = this;

                    PropertyChangeHandler(null, _GroupHeaders);
                    GroupCollectionChangeHandler(null, _GroupHeaders);
                }

                return (_GroupHeaders);
            }

            set
            {
                if (_GroupHeaders != value)
                {
                    PropertyChangeHandler(_GroupHeaders, value);
                    GroupCollectionChangeHandler(_GroupHeaders, value);

                    _GroupHeaders = value;

                    OnPropertyChangedEx("GroupHeaders", VisualChangeType.Layout);
                }
            }
        }

        #region _GroupHeaders

        void GroupHeadersCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            ColumnGroupHeaderCollection cgc = sender as ColumnGroupHeaderCollection;

            if (cgc != null)
            {
                if (e.Action == NotifyCollectionChangedAction.Add)
                {
                    ColumnGroupHeader parent = cgc.Parent as ColumnGroupHeader;

                    if (parent != null)
                    {
                        foreach (ColumnGroupHeader cgh in e.NewItems)
                        {
                            if (parent._StartDisplayIndex < 0 || cgh.StartDisplayIndex < parent.StartDisplayIndex)
                                parent.StartDisplayIndex = cgh.StartDisplayIndex;

                            if (parent._EndDisplayIndex < 0 || cgh.EndDisplayIndex > parent.EndDisplayIndex)
                                parent.EndDisplayIndex = cgh.EndDisplayIndex;
                        }
                    }
                }
            }
        }

        #endregion

        #endregion

        #region HeaderStyles

        /// <summary>
        /// Gets or sets the visual styles assigned to the Column Header
        /// </summary>
        [DefaultValue(null), Category("Appearance")]
        [Description("Indicates visual style assigned to the Column Header.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ColumnHeaderVisualStyles HeaderStyles
        {
            get
            {
                if (_HeaderStyles == null)
                {
                    _HeaderStyles = new ColumnHeaderVisualStyles();

                    PropertyChangeHandler(null, _HeaderStyles);
                }

                return (_HeaderStyles);
            }

            set
            {
                if (_HeaderStyles != value)
                {
                    PropertyChangeHandler(_HeaderStyles, value);

                    _HeaderStyles = value;

                    OnPropertyChangedEx("HeaderStyles", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region HeaderText

        ///<summary>
        /// Gets or sets the Header Text
        ///</summary>
        [DefaultValue(null), Category("Appearance")]
        [Description("Indicates the Header Text")]
        public string HeaderText
        {
            get { return (_HeaderText); }

            set
            {
                if (_HeaderText != value)
                {
                    _HeaderText = value;

                    MarkupHeaderTextChanged();

                    OnPropertyChangedEx("HeaderText", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region IsReadOnly

        ///<summary>
        ///Returns whether the given GroupHeader is ReadOnly (ie. all
        ///visible columns/headers it encompasses must be ReadOnly)
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsReadOnly
        {
            get
            {
                GridColumnHeader gch = GetColumnHeader();

                if (gch != null)
                    return (gch.IsGroupHeaderReadOnly(this));

                return (false);
            }
        }

        #endregion

        #region IsSelected

        ///<summary>
        ///Returns whether the given GroupHeader is selected (ie. all
        ///visible columns/headers it encompasses must be selected)
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsSelected
        {
            get
            {
                GridColumnHeader gch = GetColumnHeader();

                if (gch != null)
                    return (gch.IsGroupHeaderSelected(this));

                return (false);
            }
        }

        #endregion

        #region MinRowHeight

        ///<summary>
        /// Gets or sets the minimum height of the Header row
        ///</summary>
        [DefaultValue(0), Category("Style")]
        [Description("Indicates the minimum height of the ColumnHeader row")]
        public int MinRowHeight
        {
            get { return (_MinRowHeight); }

            set
            {
                if (_MinRowHeight != value)
                {
                    if (value < 0)
                        throw new Exception("MinRowHeight cannot be negative");

                    _MinRowHeight = value;

                    OnPropertyChangedEx("MinRowHeight", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region Name

        ///<summary>
        /// Gets or sets the GroupHeader Name
        ///</summary>
        [DefaultValue(null)]
        [Description("Indicates the GroupHeader Name")]
        public string Name
        {
            get { return (_Name); }
            set { _Name = value; }
        }

        #endregion

        #region Parent

        ///<summary>
        ///The Parent the item
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public object Parent
        {
            get
            {
                if (_Collection != null)
                    return (_Collection.Parent);

                return (null);
            }
        }

        #endregion

        #region RowHeight

        ///<summary>
        /// Gets or sets the fixed height of the header
        ///</summary>
        [DefaultValue(0), Category("Appearance")]
        [Description("Indicates the fixed height of the header")]
        public int RowHeight
        {
            get { return (_RowHeight); }

            set
            {
                if (_RowHeight != value)
                {
                    _RowHeight = value;

                    OnPropertyChangedEx("RowHeight", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ShowColumnHeaders

        ///<summary>
        /// Gets or sets whether the column headers are shown
        ///</summary>
        [DefaultValue(Tbool.NotSet), Category("Appearance")]
        [Description("Indicates whether the root column headers are shown.")]
        public Tbool ShowColumnHeaders
        {
            get { return (_ShowColumnHeaders); }

            set
            {
                if (_ShowColumnHeaders != value)
                {
                    _ShowColumnHeaders = value;

                    OnPropertyChangedEx("ShowColumnHeaders", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region StartDisplayIndex

        ///<summary>
        /// Gets or sets the start column display index
        ///</summary>
        [DefaultValue(-1), Category("Appearance")]
        [Description("Indicates the start column index")]
        public int StartDisplayIndex
        {
            get { return ((_StartDisplayIndex < 0) ? 0 : _StartDisplayIndex); }

            set
            {
                if (_StartDisplayIndex != value)
                {
                    _StartDisplayIndex = value;

                    OnPropertyChangedEx("StartDisplayIndex", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region ToolTip

        ///<summary>
        /// Gets or sets the ToolTip text for the sub header.
        ///</summary>
        [DefaultValue(null), Category("Appearance")]
        [Description("Indicates ththe ToolTip text for the sub header.")]
        public string ToolTip
        {
            get { return (_ToolTip); }

            set
            {
                if (_ToolTip != value)
                {
                    _ToolTip = value;

                    OnPropertyChanged("ToolTip");
                }
            }
        }

        #endregion

        #region Visible

        /// <summary>
        /// Get or sets whether the item is visible
        /// </summary>
        [DefaultValue(true), Category("Appearance")]
        [Description("Indicates whether item is visible")]
        public bool Visible
        {
            get { return (TestState(Shs.Visible)); }

            set
            {
                if (Visible != value)
                {
                    SetState(Shs.Visible, value);

                    OnPropertyChangedEx("Visible", VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #endregion

        #region Internal properties

        #region BoundsRelative

        // Does not include sub headers

        internal Rectangle BoundsRelative
        {
            get { return (_BoundsRelative); }
            set { _BoundsRelative = value; }
        }

        #endregion

        #region ContentSize

        internal Size ContentSize
        {
            get { return (_ContentSize); }
            set { _ContentSize = value; }
        }

        #endregion

        #region EffectiveStyles

        internal ColumnHeaderVisualStyles EffectiveStyles
        {
            get { return (_EffectiveStyles); }
            set { _EffectiveStyles = value; }
        }

        #endregion

        #region HeaderTextMarkup

        internal BodyElement HeaderTextMarkup
        {
            get { return (_HeaderTextMarkup); }
        }

        #endregion

        #region HeaderTextSize

        internal Size HeaderTextSize
        {
            get { return (_HeaderTextSize); }
            set { _HeaderTextSize = value; }
        }

        #endregion

        #region Size

        // Includes sub headers

        internal Size Size
        {
            get { return (_Size); }
            set { _Size = value; }
        }

        #endregion

        #region StyleUpdateCount

        internal int StyleUpdateCount
        {
            get { return (_StyleUpdateCount); }
            set { _StyleUpdateCount = value; }
        }

        #endregion

        #endregion

        #region TestState

        private bool TestState(Shs state)
        {
            return ((_States & state) == state);
        }

        #endregion

        #region SetState

        private void SetState(Shs state, bool value)
        {
            if (value == true)
                _States |= state;
            else
                _States &= ~state;
        }

        #endregion

        #region Contains

        internal bool Contains(int index)
        {
            return (index >= StartDisplayIndex && index <= EndDisplayIndex);
        }

        #endregion

        #region GetColumnHeader

        private GridColumnHeader GetColumnHeader()
        {
            object parent = Collection.Parent;

            while (parent.GetType() == typeof(ColumnGroupHeader))
                parent = ((ColumnGroupHeader)parent).Collection.Parent;

            return (parent as GridColumnHeader);
        }

        #endregion

        #region Markup support

        private void MarkupHeaderTextChanged()
        {
            if (_HeaderTextMarkup != null)
                _HeaderTextMarkup.HyperLinkClick -= HeaderTextMarkupLinkClick;

            _HeaderTextMarkup = null;

            if (EnableHeaderMarkup == true)
            {
                if (MarkupParser.IsMarkup(_HeaderText) == true)
                {
                    _HeaderTextMarkup = MarkupParser.Parse(_HeaderText);

                    if (_HeaderTextMarkup != null)
                        _HeaderTextMarkup.HyperLinkClick += HeaderTextMarkupLinkClick;
                }
            }
        }

        /// <summary>
        /// Occurs when a header text markup link is clicked
        /// </summary>
        protected virtual void HeaderTextMarkupLinkClick(object sender, EventArgs e)
        {
            if (GroupHeaderMarkupLinkClick != null)
            {
                HyperLink link = (HyperLink)sender;

                GroupHeaderMarkupLinkClickEventArgs ev =
                    new GroupHeaderMarkupLinkClickEventArgs(this, link);

                GroupHeaderMarkupLinkClick(this, ev);
            }
        }

        /// <summary>
        /// Gets plain Header text without text-markup (if text-markup is used in Text)
        /// </summary>
        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        public string PlainHeaderText
        {
            get { return (_HeaderTextMarkup != null ? _HeaderTextMarkup.PlainText : _HeaderText); }
        }

        #endregion

        #region GroupCollectionChangeHandler

        private void GroupCollectionChangeHandler(
            ColumnGroupHeaderCollection oldValue, ColumnGroupHeaderCollection newValue)
        {
            if (oldValue != null)
            {
                oldValue.Parent = null;
                oldValue.CollectionChanged -= GroupHeadersCollectionChanged;
            }

            if (newValue != null)
            {
                newValue.Parent = this;
                newValue.CollectionChanged += GroupHeadersCollectionChanged;
            }
        }

        #endregion

        #region PropertyChangeHandler

        private void PropertyChangeHandler(
            INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
        {
            if (oldValue != null)
                oldValue.PropertyChanged -= PropertyValueChanged;

            if (newValue != null)
                newValue.PropertyChanged += PropertyValueChanged;
        }

        #endregion

        #region PropertyValueChanged

        /// <summary>
        /// Occurs when one of element visual styles has property changes.
        /// Default implementation invalidates visual appearance of element.
        /// </summary>
        /// <param name="sender">VisualStyle that changed.</param>
        /// <param name="e">Event arguments.</param>
        protected virtual void PropertyValueChanged(object sender, PropertyChangedEventArgs e)
        {
            OnPropertyChanged(e);
        }

        #endregion

        #region INotifyPropertyChanged Members

        /// <summary>
        /// Occurs when property value has changed.
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Raises the PropertyChanged event.
        /// </summary>
        /// <param name="e">Event arguments</param>
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            PropertyChangedEventHandler eh = PropertyChanged;

            if (eh != null)
                eh(this, e);
        }

        /// <summary>
        /// Default PropertyChanged processing
        /// </summary>
        /// <param name="s"></param>
        protected void OnPropertyChanged(string s)
        {
            if (PropertyChanged != null)
                OnPropertyChanged(new VisualPropertyChangedEventArgs(s));
        }

        /// <summary>
        /// Default PropertyChanged processing
        /// </summary>
        /// <param name="s"></param>
        /// <param name="changeType">invalidate</param>
        protected void OnPropertyChangedEx(string s, VisualChangeType changeType)
        {
            if (PropertyChanged != null)
                OnPropertyChanged(new VisualPropertyChangedEventArgs(s, changeType));
        }

        #endregion

        #region GroupHeaderStates

        [Flags]
        private enum Shs
        {
            AllowSelection = (1 << 0),
            EnableHeaderMarkup = (1 << 1),
            Visible = (1 << 2),
        }

        #endregion

        #region Dispose

        /// <summary>
        /// Dispose
        /// </summary>
        public void Dispose()
        {
            if (_HeaderTextMarkup != null)
            {
                _HeaderTextMarkup.HyperLinkClick -= HeaderTextMarkupLinkClick;

                _HeaderTextMarkup = null;
            }
        }

        #endregion
    }

    #region EventArgs

    #region GroupHeaderMarkupLinkClickEventArgs

    /// <summary>
    /// GroupHeaderMarkupLinkClickEventArgs
    /// </summary>
    internal class GroupHeaderMarkupLinkClickEventArgs : EventArgs
    {
        #region Private variables

        private ColumnGroupHeader _GroupHeader;
        private HyperLink _HyperLink;

        #endregion

        ///<summary>
        /// GroupHeaderMarkupLinkClickEventArgs
        ///</summary>
        ///<param name="groupHeader"></param>
        ///<param name="hyperLink"></param>
        public GroupHeaderMarkupLinkClickEventArgs(ColumnGroupHeader groupHeader, HyperLink hyperLink)
        {
            _GroupHeader = groupHeader;
            _HyperLink = hyperLink;
        }

        #region Public properties

        /// <summary>
        /// Gets the associated GroupHeader
        /// </summary>
        public ColumnGroupHeader GroupHeader
        {
            get { return (_GroupHeader); }
        }

        /// <summary>
        /// Gets the associated HyperLink
        /// </summary>
        public HyperLink HyperLink
        {
            get { return (_HyperLink); }
        }

        #endregion
    }

    #endregion

    #endregion
}