using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using DevComponents.Charts.TextMarkup;
using DevComponents.DotNetBar.Charts.Style;

namespace DevComponents.DotNetBar.Charts
{
    /// <summary>
    /// Represents the collection of ChartContainer objects.
    /// </summary>
    [Editor("DevComponents.Charts.Design.ChartContainerCollectionEditor, DevComponents.Charts.Design, " +
            "Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
    public class ChartContainerCollection : CustomNamedCollection<ChartContainer>
    {
        public ChartContainerCollection()
        {
        }

        #region GetUniqueName

        public string GetUniqueName()
        {
            return (GetUniqueName("ChartCont"));
        }

        #endregion
    }

    /// <summary>
    /// ChartContainer
    /// </summary>
    public class ChartContainer : ChartVisualElement, ILegendData, IScrollable, IComparable
    {
        #region Private variables

        private States _States;

        private string _EmptyText;
        private BodyElement _EmptyTextMarkup;
        private ChartLegend _Legend;

        private ChartTitleCollection _Titles;

        private ScrollBarLite _VScrollBar;
        private ScrollBarLite _HScrollBar;

        private int _VScrollBarWidth = 9;
        private int _HScrollBarHeight = 9;

        private Rectangle _FrameBounds;         // Margin
        private Rectangle _ContentBounds;       // Content - chart container(s)
        private Rectangle _ContentBoundsEx;     // Content - extended content bounds

        private int _FillWeight = 100;
        private AutoSizeMode _AutoSizeMode = AutoSizeMode.NotSet;
        private Size _MinContentSize = new Size(100, 100);

        private Timer _AutoScrollTimer;
        private AutoScrollEnable _AutoScrollEnable;
        private Rectangle _ScrollRect;

        private bool _Panning;

        private int _HPanOffset;
        private int _VPanOffset;

        private ItemHitArea _HitArea;
        private ItemHitArea _MouseDownHitArea;

        private ContainerVisualStyles _ContainerVisualStyles;
        private EffectiveStyles<ContainerVisualStyle> _EffectiveContainerStyles;

        private int _MatrixDisplayOrder;
        private Rectangle _MatrixDisplayBounds;

        private int _SelectionUpdateCount = -1;

        #endregion

        public ChartContainer()
        {
            InitDefaultStates();

            SetupScrollBars();

            _EffectiveContainerStyles = new EffectiveStyles<ContainerVisualStyle>(this);
        }

        #region InitDefaultStates

        private void InitDefaultStates()
        {
            SetState(States.AutoGenSeriesCollection, true);
            SetState(States.EnablePanning, true);

            SetState(States.HScrollBarVisible, true);
            SetState(States.VScrollBarVisible, true);
        }

        #endregion

        #region Public properties

        #region AutoSizeMode

        ///<summary>
        /// Gets or sets the mode used to size the container (by FillWeight, etc).
        ///</summary>
        [DefaultValue(AutoSizeMode.NotSet), Category("Layout")]
        [Description("Indicates the mode used to size the container (by FillWeight, etc).")]
        public AutoSizeMode AutoSizeMode
        {
            get { return (_AutoSizeMode); }

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

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

        #endregion

        #region ContainerVisualStyles

        /// <summary>
        /// Gets or sets the visual styles for the container.
        /// </summary>
        [Category("Style")]
        [Description("Indicates the visual styles for the container.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ContainerVisualStyles ContainerVisualStyles
        {
            get
            {
                if (_ContainerVisualStyles == null)
                {
                    _ContainerVisualStyles = new ContainerVisualStyles();

                    StyleVisualChangeHandler(null, _ContainerVisualStyles);
                }

                return (_ContainerVisualStyles);
            }

            set
            {
                if (_ContainerVisualStyles != value)
                {
                    ContainerVisualStyles oldValue = _ContainerVisualStyles;

                    _ContainerVisualStyles = value;

                    OnStyleChanged("ContainerVisualStyles", oldValue, value);

                    if (oldValue != null)
                        oldValue.Dispose();
                }
            }
        }

        #endregion

        #region ContentBounds

        /// <summary>
        /// Gets the Content area bounding rectangle.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle ContentBounds
        {
            get { return (_ContentBounds); }
            internal set { _ContentBounds = value; }
        }

        #endregion

        #region EffectiveContainerStyle

        /// <summary>
        /// Gets a reference to the container's effective (cached, composite) styles.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public EffectiveStyles<ContainerVisualStyle> EffectiveContainerStyles
        {
            get { return (_EffectiveContainerStyles); }
        }

        #endregion

        #region EmptyText

        /// <summary>
        /// Gets or sets the Text to display when the container is empty.
        /// </summary>
        [Browsable(true), Category("Appearance"), DefaultValue(null)]
        [Description("Indicates the Text to display when the container is empty.")]
        public string EmptyText
        {
            get { return (_EmptyText); }

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

                    EmptyTextMarkupChanged();

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

        #endregion

        #region EnableEmptyTextMarkup

        /// <summary>
        /// Gets or sets whether EmptyText markup support is enabled.
        /// </summary>
        [DefaultValue(false), Category("Appearance")]
        [Description("Indicates whether EmptyText markup support is enabled.")]
        public bool EnableEmptyTextMarkup
        {
            get { return (TestState(States.EnableEmptyTextMarkup)); }

            set
            {
                if (EnableEmptyTextMarkup != value)
                {
                    SetState(States.EnableEmptyTextMarkup, value);

                    EmptyTextMarkupChanged();

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

        #region Markup support

        private void EmptyTextMarkupChanged()
        {
            _EmptyTextMarkup = null;

            if (EnableEmptyTextMarkup == true)
            {
                if (MarkupParser.IsMarkup(_EmptyText) == true)
                {
                    _EmptyTextMarkup = MarkupParser.Parse(_EmptyText);

                    if (_EmptyTextMarkup != null)
                        _EmptyTextMarkup.HyperLinkClick += EmptyTextMarkupLinkClick;
                }
            }
        }

        /// <summary>
        /// Occurs when a text markup link is clicked
        /// </summary>
        protected virtual void EmptyTextMarkupLinkClick(object sender, EventArgs e)
        {
            HyperLink link = sender as HyperLink;

            ChartControl.DoEmptyTextMarkupLinkClickEvent(this, link);
        }

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

        #endregion

        #endregion

        #region EnablePanning

        /// <summary>
        /// Gets or sets whether the container can be panned with the mouse.
        /// </summary>
        [DefaultValue(true), Category("Behavior")]
        [Description("Indicates whether the container can be panned with the mouse.")]
        public bool EnablePanning
        {
            get { return (TestState(States.EnablePanning)); }

            set
            {
                if (value != EnablePanning)
                {
                    SetState(States.EnablePanning, value);

                    OnPropertyChanged("EnablePanning");
                }
            }
        }

        #endregion

        #region EnableSelection

        /// <summary>
        /// Gets or sets whether the CONTAINER can be "selected" with the mouse.
        /// </summary>
        [DefaultValue(false), Category("Behavior")]
        [Description("Indicates whether the CONTAINER can be \"selected\" with the mouse.")]
        public bool EnableSelection
        {
            get { return (TestState(States.EnableSelection)); }

            set
            {
                if (value != EnableSelection)
                {
                    SetState(States.EnableSelection, value);

                    OnPropertyChanged("EnableSelection");
                }
            }
        }

        #endregion

        #region FillWeight

        /// <summary>
        /// Gets or sets a value which, when AutoSizeMode is Fill,
        /// represents the width of the container relative to the widths
        /// of other fill-mode containers (default value is 100).
        /// </summary>
        [DefaultValue(100), Category("Layout")]
        [Description("Indicates a value which, when AutoSizeMode is Fill, represents the width of the containers relative to the widths of other fill-mode containers (default value is 100).")]
        public int FillWeight
        {
            get { return (_FillWeight); }

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

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

        #endregion

        #region FrameBounds

        /// <summary>
        /// Gets the Frame area bounding rectangle.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle FrameBounds
        {
            get { return (_FrameBounds); }
            internal set { _FrameBounds = value; }
        }

        #endregion

        #region HScrollBar

        ///<summary>
        /// Gets a reference to the containers’s horizontal scrollbar
        ///</summary>
        [Category("ScrollBar")]
        [Description("Indicates the container’s horizontal scrollbar.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ScrollBarLite HScrollBar
        {
            get { return (_HScrollBar); }
            internal set { _HScrollBar = value; }
        }

        #endregion

        #region HScrollBarHeight

        /// <summary>
        /// Gets or sets the horizontal scrollBar height.
        /// </summary>
        [DefaultValue(9), Category("ScrollBar")]
        [Description("Indicates the horizontal scrollBar height")]
        public int HScrollBarHeight
        {
            get { return (_HScrollBarHeight); }

            set
            {
                if (value != _HScrollBarHeight)
                {
                    if (value > 0)
                    {
                        _HScrollBarHeight = value;

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

        #endregion

        #region HScrollOffset

        ///<summary>
        /// Gets or sets the horizontal scrollbar offset.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int HScrollOffset
        {
            get
            {
                if (_HScrollBar != null && _HScrollBar.Visible == true)
                    return (_HScrollBar.Value);

                return (0);
            }

            set { SetHScrollValue(value); }
        }

        #endregion

        #region HScrollBarVisible

        /// <summary>
        /// Gets or sets whether Horizontal Scrollbar is shown if needed (due to content of the control exceeding available width).
        /// </summary>
        [DefaultValue(true), Category("ScrollBar")]
        [Description("Indicates whether Horizontal Scrollbar is shown if needed (due to content of the control exceeding available width).")]
        public bool HScrollBarVisible
        {
            get { return (TestState(States.HScrollBarVisible)); }

            set
            {
                if (value != HScrollBarVisible)
                {
                    SetState(States.HScrollBarVisible, value);

                    InvalidateLayout();
                }
            }
        }

        #endregion

        #region IsSelected

        ///<summary>
        /// Gets or sets whether the container is selected.
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsSelected
        {
            get
            {
                ChartControl chartControl = ChartControl;

                if (chartControl != null)
                {
                    if (_SelectionUpdateCount == chartControl.SelectionUpdateCount)
                        return (TestState(States.IsSelected));

                    bool selected = chartControl.GetSelected(this);

                    SetState(States.IsSelected, selected);

                    _SelectionUpdateCount = chartControl.SelectionUpdateCount;
                }

                return (TestState(States.IsSelected));
            }

            set
            {
                if (value != IsSelected)
                {
                    SetState(States.IsSelected, value);

                    ChartControl chartControl = ChartControl;

                    if (chartControl != null)
                    {
                        chartControl.SetSelected(this, value);

                        InvalidateRender();
                    }
                }
            }
        }

        #endregion

        #region Legend

        /// <summary>
        /// Gets or Sets the element Legend.
        /// </summary>
        [Category("Legend")]
        [Description("Indicates the element Legend.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartLegend Legend
        {
            get
            {
                if (_Legend == null)
                    Legend = new ChartLegend();

                return (_Legend);
            }

            set
            {
                if (value != _Legend)
                {
                    if (_Legend != null)
                    {
                        _Legend.Parent = null;
                        _Legend.PropertyChanged -= LegendPropertyChanged;
                    }

                    _Legend = value;

                    if (_Legend != null)
                    {
                        _Legend.Parent = this;
                        _Legend.PropertyChanged += LegendPropertyChanged;
                    }
                }
            }
        }

        void LegendPropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            InvalidateLayout();
        }

        #endregion

        #region MatrixAlignEndColumn

        ///<summary>
        /// Gets or sets whether the container's content ending X-offset is aligned 
        /// with other containers ending in the same ChartMatrix column.
        ///</summary>
        [DefaultValue(false), Category("Matrix")]
        [Description("Indicates whether the container's content ending X-offset is aligned with other containers ending in the same ChartMatrix column.")]
        public bool MatrixAlignEndColumn
        {
            get { return (TestState(States.MatrixAlignEndColumn)); }

            set
            {
                if (value != MatrixAlignEndColumn)
                {
                    SetState(States.MatrixAlignEndColumn, value);

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

        #endregion

        #region MatrixAlignEndRow

        ///<summary>
        /// Gets or sets whether the container's content ending Y-offset is aligned 
        /// with other containers ending in the same ChartMatrix row.
        ///</summary>
        [DefaultValue(false), Category("Matrix")]
        [Description("Indicates whether the container's content ending Y-offset is aligned with other containers ending in the same ChartMatrix row.")]
        public bool MatrixAlignEndRow
        {
            get { return (TestState(States.MatrixAlignEndRow)); }

            set
            {
                if (value != MatrixAlignEndRow)
                {
                    SetState(States.MatrixAlignEndRow, value);

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

        #endregion

        #region MatrixAlignStartColumn

        ///<summary>
        /// Gets or sets whether the container's content starting X-offset is aligned 
        /// with other containers starting in the same ChartMatrix column.
        ///</summary>
        [DefaultValue(false), Category("Matrix")]
        [Description("Indicates whether the container's content starting X-offset is aligned with other containers starting in the same ChartMatrix column.")]
        public bool MatrixAlignStartColumn
        {
            get { return (TestState(States.MatrixAlignStartColumn)); }

            set
            {
                if (value != MatrixAlignStartColumn)
                {
                    SetState(States.MatrixAlignStartColumn, value);

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

        #endregion

        #region MatrixAlignStartRow

        ///<summary>
        /// Gets or sets whether the container's content starting Y-offset is aligned 
        /// with other containers starting in the same ChartMatrix row.
        ///</summary>
        [DefaultValue(false), Category("Matrix")]
        [Description("Indicates whether the container's content starting Y-offset is aligned with other containers starting in the same ChartMatrix row.")]
        public bool MatrixAlignStartRow
        {
            get { return (TestState(States.MatrixAlignStartRow)); }

            set
            {
                if (value != MatrixAlignStartRow)
                {
                    SetState(States.MatrixAlignStartRow, value);

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

        #endregion

        #region MatrixDisplayBounds

        ///<summary>
        /// Gets or sets the containers matrix display bounds (in relative units of the matrix).
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Rectangle MatrixDisplayBounds
        {
            get { return (_MatrixDisplayBounds); }

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

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

        #endregion

        #region MatrixDisplayOrder

        ///<summary>
        /// Gets or sets the containers display order in the parent matrix layout
        /// (higher values are placed on top of lower values).
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int MatrixDisplayOrder
        {
            get { return (_MatrixDisplayOrder); }

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

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

        #endregion

        #region MinContentSize

        /// <summary>
        /// Gets or sets the minimum size of the content area of the chart.
        /// </summary>
        [Category("Layout")]
        [Description("Indicates the minimum size of the content area of the chart.")]
        public Size MinContentSize
        {
            get { return (_MinContentSize); }

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

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

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        internal virtual bool ShouldSerializeMinContentSize()
        {
            return (_MinContentSize.Width != 100 || _MinContentSize.Height != 100);
        }

        [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
        internal virtual void ResetMinContentSize()
        {
            MinContentSize = new Size(100, 100);
        }

        #endregion

        #region ScrollBounds

        /// <summary>
        /// Gets the Scrollable bounds.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual Rectangle ScrollBounds
        {
            get { return (_ContentBounds); }
        }

        #endregion

        #region ScrollBoundsEx

        /// <summary>
        /// Gets the extended Scrollable bounds.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public virtual Rectangle ScrollBoundsEx
        {
            get { return (_ContentBoundsEx); }
        }

        #endregion

        #region ScrollBoundsOffset

        ///<summary>
        /// Gets the current scrollbar offset
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Point ScrollBoundsOffset
        {
            get { return (new Point(HScrollOffset, VScrollOffset)); }
        }

        #endregion

        #region Titles

        /// <summary>
        /// Gets or Sets a reference to the collection of Titles
        /// </summary>
        [Category("Appearance")]
        [Description("Indicates the collection of Titles.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartTitleCollection Titles
        {
            get
            {
                if (_Titles == null)
                {
                    _Titles = new ChartTitleCollection();

                    _Titles.CollectionChanged += TitlesCollectionChanged;
                }

                return (_Titles);
            }

            internal set
            {
                if (_Titles != null)
                    _Titles.CollectionChanged -= TitlesCollectionChanged;

                _Titles = value;

                if (_Titles != null)
                    _Titles.CollectionChanged += TitlesCollectionChanged;
            }
        }

        #region TitlesCollectionChanged

        void TitlesCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    foreach (ChartTitle title in e.NewItems)
                        title.Parent = this;
                    break;

                case NotifyCollectionChangedAction.Replace:
                    foreach (ChartTitle title in e.OldItems)
                        title.Parent = null;

                    foreach (ChartTitle title in e.NewItems)
                        title.Parent = this;
                    break;

                case NotifyCollectionChangedAction.Remove:
                    foreach (ChartTitle title in e.OldItems)
                        title.Parent = null;
                    break;
            }

            InvalidateLayout();
        }

        #endregion

        #endregion

        #region VScrollBar

        ///<summary>
        /// Gets a reference to the container’s vertical scrollbar
        ///</summary>
        [Category("ScrollBar")]
        [Description("Indicates the container’s vertical scrollbar.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ScrollBarLite VScrollBar
        {
            get { return (_VScrollBar); }
        }

        #endregion

        #region VScrollBarWidth

        /// <summary>
        /// Gets or sets the vertical scrollBar width.
        /// </summary>
        [DefaultValue(9), Category("ScrollBar")]
        [Description("Indicates the vertical scrollBar width")]
        public int VScrollBarWidth
        {
            get { return (_VScrollBarWidth); }

            set
            {
                if (value != _VScrollBarWidth)
                {
                    if (value > 0)
                    {
                        _VScrollBarWidth = value;

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

        #endregion

        #region VScrollOffset

        ///<summary>
        /// Gets the vertical scrollbar offset
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int VScrollOffset
        {
            get
            {
                if (_VScrollBar != null && _VScrollBar.Visible == true)
                    return (_VScrollBar.Value);

                return (0);
            }

            set { SetVScrollValue(value); }
        }

        #endregion

        #region VScrollBarVisible

        /// <summary>
        /// Gets or sets whether Vertical Scrollbar is shown when needed (due to the content area exceeding available height).
        /// </summary>
        [DefaultValue(true), Category("ScrollBar")]
        [Description("Indicates whether Vertical Scrollbar is shown when needed (due to the content area exceeding available height)")]
        public bool VScrollBarVisible
        {
            get { return (TestState(States.VScrollBarVisible)); }

            set
            {
                if (value != VScrollBarVisible)
                {
                    SetState(States.VScrollBarVisible, value);

                    InvalidateLayout();
                }
            }
        }

        #endregion

        #endregion

        #region Internal properties

        #region ContentBoundsEx

        internal Rectangle ContentBoundsEx
        {
            get { return (_ContentBoundsEx); }
            set { _ContentBoundsEx = value; }
        }

        #endregion

        #region EmptyTextMarkup

        internal BodyElement EmptyTextMarkup
        {
            get { return (_EmptyTextMarkup); }
            set { _EmptyTextMarkup = value; }
        }

        #endregion

        #region HitArea

        internal ItemHitArea HitArea
        {
            get { return (_HitArea); }
            set { _HitArea = value; }
        }

        #endregion

        #region IsSubPanel

        /// <summary>
        /// Gets whether the ChartPanel is a subordinate / nested panel.
        /// </summary>
        internal bool IsSubPanel
        {
            get { return (Parent != null); }
        }

        #endregion

        #region MatrixColumnAligned

        /// <summary>
        /// Gets whether the ChartContainer column was MatrixAligned.
        /// </summary>
        internal bool MatrixColumnAligned
        {
            get { return (TestState(States.MatrixColumnAligned)); }
            set { SetState(States.MatrixColumnAligned, value); }
        }

        #endregion

        #region MatrixRowAligned

        /// <summary>
        /// Gets whether the ChartContainer row was MatrixAligned.
        /// </summary>
        internal bool MatrixRowAligned
        {
            get { return (TestState(States.MatrixRowAligned)); }
            set { SetState(States.MatrixRowAligned, value); }
        }

        #endregion

        #region MouseDownHitArea

        internal ItemHitArea MouseDownHitArea
        {
            get { return (_MouseDownHitArea); }
            set { _MouseDownHitArea = value; }
        }

        #endregion

        #endregion

        #region MeasureOverride

        protected override void MeasureOverride(ChartLayoutInfo layoutInfo)
        {
            if (Legend.Visible == true)
                Legend.Measure(layoutInfo);

            foreach (ChartTitle title in Titles)
            {
                if (title.Visible == true)
                    title.Measure(layoutInfo);
            }
        }

        #endregion

        #region ArrangeOverride

        protected override void ArrangeOverride(ChartLayoutInfo layoutInfo)
        {
            if (Legend.Visible == true)
                Legend.Arrange(layoutInfo);

            foreach (ChartTitle title in Titles)
            {
                if (title.Visible == true)
                    title.Arrange(layoutInfo);
            }

            UpdateScrollBars(layoutInfo);
        }

        #endregion

        #region RenderOverride

        protected override void RenderOverride(ChartRenderInfo renderInfo)
        {
            Graphics g = renderInfo.Graphics;

            // Render Titles

            foreach (ChartTitle title in Titles)
            {
                if (title.Visible == true)
                    title.Render(renderInfo);
            }

            // Render the Legend

            if (Legend.Visible == true)
                Legend.Render(renderInfo);
        }

        #endregion

        #region RenderTextMarkup

        internal void RenderTextMarkup(Graphics g,
            Font font, Color textColor, Alignment alignment, Rectangle r)
        {
            if (textColor.IsEmpty)
                textColor = Color.Black;

            MarkupDrawContext d =
                new MarkupDrawContext(g, font, textColor, false);

            _EmptyTextMarkup.Arrange(new Rectangle(Point.Empty, r.Size), d);

            Size size = _EmptyTextMarkup.Bounds.Size;

            switch (alignment)
            {
                case Alignment.NotSet:
                case Alignment.MiddleLeft:
                case Alignment.MiddleCenter:
                case Alignment.MiddleRight:
                    if (r.Height > size.Height)
                        r.Y += (r.Height - size.Height) / 2;
                    break;

                case Alignment.BottomLeft:
                case Alignment.BottomCenter:
                case Alignment.BottomRight:
                    if (r.Height > size.Height)
                        r.Y = r.Bottom - size.Height;
                    break;
            }

            _EmptyTextMarkup.Bounds = new Rectangle(r.Location, size);

            Region oldClip = g.Clip;

            try
            {
                g.SetClip(r, CombineMode.Intersect);

                _EmptyTextMarkup.Render(d);
            }
            finally
            {
                g.Clip = oldClip;
            }
        }

        #endregion

        #region RenderEmptyText

        protected void RenderEmptyText(
            Graphics g, ContainerVisualStyle style, Rectangle bounds)
        {
            if (String.IsNullOrEmpty(EmptyText) == false)
            {
                if (EmptyTextMarkup != null)
                {
                    RenderTextMarkup(g, style.Font,
                        style.TextColor, style.Alignment, bounds);
                }
                else
                {
                    eTextFormat tf = style.GetTextFormatFlags();

                    TextDrawing.DrawString(g,
                        EmptyText, style.Font, style.TextColor, bounds, tf);
                }
            }
        }

        #endregion

        #region RenderScrollbars

        protected void RenderScrollbars(ChartRenderInfo renderInfo)
        {
            Graphics g = renderInfo.Graphics;

            if (HScrollBar.Visible == true && VScrollBar.Visible == true)
            {
                ScrollBarVisualStyle style = VScrollBar.GetEffectiveStyle();

                Rectangle r = HScrollBar.Bounds;

                r.X = VScrollBar.Bounds.X;
                r.Width = VScrollBar.Width;

                using (Brush br = style.TrackBackground.GetBrush(r))
                    g.FillRectangle(br, r);

                using (Pen pen = new Pen(style.BorderColor))
                    g.DrawRectangle(pen, r);
            }

            if (HScrollBar.Visible == true)
                HScrollBar.Render(renderInfo);

            if (VScrollBar.Visible == true)
                VScrollBar.Render(renderInfo);
        }

        #endregion

        #region Mouse handling

        #region OnMouseEnter

        protected override bool OnMouseEnter(EventArgs e)
        {
            base.OnMouseEnter(e);

            InvalidateRender();

            return (true);
        }

        #endregion

        #region OnMouseLeave

        protected override bool OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave(e);

            InvalidateRender();

            return (true);
        }

        #endregion

        #region OnMouseMove

        protected override bool OnMouseMove(MouseEventArgs e)
        {
            _HitArea = GetHitArea(e.Location);

            if (IsMouseDown == true)
                return (OnMouseDownMove(e));

            if (_HitArea == ItemHitArea.InContent)
            {
                if (EmptyTextMarkup != null)
                {
                    ChartControl.SetChartCursor = true;
                    EmptyTextMarkup.MouseMove(ChartControl, e);
                    ChartControl.SetChartCursor = false;

                    if (EmptyTextMarkup.MouseOverElement != null)
                    {
                        if (EmptyTextMarkup.MouseOverElement is HyperLink)
                            return (true);
                    }
                }

                if (EnablePanning == true &&
                    (HScrollBar.Enabled == true || VScrollBar.Enabled == true))
                {
                    ChartCursor = OpenHandCursor;

                    return (true);
                }
            }

            ChartCursor = Cursors.Default;

            return (false);
        }

        #region OnMouseDownMove

        private bool OnMouseDownMove(MouseEventArgs e)
        {
            if (_Panning == true)
            {
                ChartCursor = ClosedHandCursor;

                if (HScrollBar.Enabled == true)
                    HScrollOffset = _HPanOffset + (MouseDownPoint.X - e.Location.X);

                if (VScrollBar.Enabled == true)
                {
                    int n = (MouseDownPoint.Y - e.Location.Y);

                    if (VScrollBar.Inverted == true)
                        VScrollOffset = _VPanOffset - n;
                    else
                        VScrollOffset = _VPanOffset + n;
                }
            }

            return (true);
        }

        #endregion

        #endregion

        #region OnMouseDown

        protected override bool OnMouseDown(MouseEventArgs e)
        {
            ChartControl.Focus();

            UpdateSelection(e);

            return (OnMouseDownEx(e));
        }

        protected override bool OnMouseDownEx(MouseEventArgs e)
        {
            base.OnMouseDown(e);

            MouseDownHitArea = _HitArea;

            if (EmptyTextMarkup != null)
            {
                if (EmptyTextMarkup.MouseOverElement != null)
                {
                    EmptyTextMarkup.MouseDown(ChartControl, e);

                    return (true);
                }
            }

            if (_HitArea == ItemHitArea.InContent)
            {
                if (EnablePanning == true &&
                    (HScrollBar.Visible == true || VScrollBar.Visible == true))
                {
                    _HPanOffset = HScrollOffset;
                    _VPanOffset = VScrollOffset;

                    _Panning = true;

                    ChartCursor = ClosedHandCursor;
                    ChartControl.PostInternalMouseMove();

                    ChartControl.CapturedItem = this;

                    return (true);
                }
            }

            return (false);
        }

        #region UpdateSelection

        private void UpdateSelection(MouseEventArgs e)
        {
            ChartContainer parent = Parent as ChartContainer;

            if (parent != null && parent.EnableSelection == true)
            {
                if (IsSelected == false ||
                    ((e.Button & MouseButtons.Left) == MouseButtons.Left))
                {
                    ChartControl chartControl = ChartControl;

                    if (chartControl != null)
                    {
                        bool ctrlKey = ((Control.ModifierKeys & Keys.Control) == Keys.Control);

                        if (ctrlKey == true)
                        {
                            chartControl.SetSelected(this, !IsSelected);
                        }
                        else
                        {
                            chartControl.ClearAllSelected();

                            chartControl.SetSelected(this, true);
                        }
                    }
                }
            }
        }

        #endregion

        #endregion

        #region OnMouseUp

        protected override bool OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);

            if (EmptyTextMarkup != null)
            {
                if (EmptyTextMarkup.MouseOverElement != null)
                    EmptyTextMarkup.Click(ChartControl);
            }

            if (_Panning == true)
            {
                _Panning = false;

                ChartControl.CapturedItem = null;
            }

            return (true);
        }

        #endregion

        #region OnMouseWheel

        protected override bool OnMouseWheel(MouseEventArgs e)
        {
            if ((Control.ModifierKeys & Keys.Shift) == Keys.Shift)
                return (OnHorizontalMouseWheel(e));

            return (OnVerticalMouseWheel(e));

        }

        #region OnHorizontalMouseWheel

        private bool OnHorizontalMouseWheel(MouseEventArgs e)
        {
            if (HScrollBar.Enabled == true)
            {
                if ((e.Delta < 0 && HScrollBar.IsAtMaxumum == false) ||
                    (e.Delta > 0 && HScrollBar.IsAtMinumum == false))
                {
                    SetHWheelValue(-e.Delta);

                    return (true);
                }
            }

            return (false);
        }

        #region SetHWheelValue

        private void SetHWheelValue(int delta)
        {
            int value = delta * SystemInformation.MouseWheelScrollLines / 120;

            value *= HScrollBar.SmallChange;
            value += HScrollBar.Value;

            SetHScrollValue(value);
        }

        #endregion

        #endregion

        #region OnVerticalMouseWheel

        private bool OnVerticalMouseWheel(MouseEventArgs e)
        {
            if (VScrollBar.Enabled == true)
            {
                if (VScrollBar.Inverted == true)
                {
                    if ((e.Delta < 0 && VScrollBar.IsAtMinumum == false) ||
                        (e.Delta > 0 && VScrollBar.IsAtMaxumum == false))
                    {
                        SetVWheelValue(e.Delta);

                        return (true);
                    }
                }
                else
                {
                    if ((e.Delta < 0 && VScrollBar.IsAtMaxumum == false) ||
                        (e.Delta > 0 && VScrollBar.IsAtMinumum == false))
                    {
                        SetVWheelValue(-e.Delta);

                        return (true);
                    }
                }
            }

            return (false);
        }

        #region SetVWheelValue

        private void SetVWheelValue(int delta)
        {
            int value = delta * SystemInformation.MouseWheelScrollLines / 120;

            value *= VScrollBar.SmallChange;
            value += VScrollBar.Value;

            SetVScrollValue(value);
        }

        #endregion

        #endregion

        #endregion

        #endregion

        #region Scrollbar support

        #region SetupScrollBars

        private void SetupScrollBars()
        {
            _VScrollBar = new VScrollBarLite();
            _VScrollBar.Parent = this;
            _VScrollBar.Width = Dpi.Width(VScrollBarWidth);

            _HScrollBar = new HScrollBarLite();
            _HScrollBar.Parent = this;
            _HScrollBar.Height = Dpi.Height(HScrollBarHeight);

            _HScrollBar.Visible = false;
            _VScrollBar.Visible = false;
        }

        #endregion

        #region UpdateScrollBars

        private void UpdateScrollBars(ChartLayoutInfo layoutInfo)
        {
            Rectangle cbounds = ScrollBounds;
            Rectangle cboundsEx = ScrollBoundsEx;

            EnableHScrollBar(cbounds, cboundsEx);
            EnableVScrollBar(cbounds, cboundsEx);

            if (_HScrollBar.Enabled == true)
            {
                int widthEx = cboundsEx.Width;

                _HScrollBar.SmallChange = cbounds.Width / 20;
                _HScrollBar.Maximum = Math.Max(0, widthEx);
                _HScrollBar.LargeChange = Math.Min(cbounds.Width, _HScrollBar.Maximum);

                if (_HScrollBar.Value + _HScrollBar.LargeChange > _HScrollBar.Maximum)
                    _HScrollBar.Value = _HScrollBar.Maximum - _HScrollBar.LargeChange;

                _HScrollBar.Arrange(layoutInfo);
            }

            if (_VScrollBar.Enabled == true)
            {
                int heightEx = cboundsEx.Height;

                _VScrollBar.SmallChange = cbounds.Height / 20;
                _VScrollBar.Maximum = Math.Max(0, heightEx);
                _VScrollBar.LargeChange = Math.Min(cbounds.Height, _VScrollBar.Maximum);

                if (_VScrollBar.Value + _VScrollBar.LargeChange > _VScrollBar.Maximum)
                    _VScrollBar.Value = _VScrollBar.Maximum - _VScrollBar.LargeChange;

                _VScrollBar.Arrange(layoutInfo);
            }
        }

        #region EnableHScrollBar

        private void EnableHScrollBar(Rectangle cbounds, Rectangle cboundsEx)
        {
            bool enable = (HScrollBarVisible == true) &&
                (cboundsEx.Width > cbounds.Width);

            if ((cbounds.Height < _HScrollBar.Height + 4) || cbounds.Width <= 0)
                enable = false;

            if (enable == true)
            {
                _HScrollBar.Location = new
                    Point(cbounds.Left, cbounds.Bottom - _HScrollBar.Height - 1);

                int n = cbounds.Width - 1;

                if (_VScrollBar.Visible == true)
                    n -= _VScrollBar.Width;

                _HScrollBar.Width = n;
                _HScrollBar.Height = Dpi.Height(HScrollBarHeight);
            }
            else
            {
                _HScrollBar.Value = 0;
            }

            _HScrollBar.Enabled = enable;
            _HScrollBar.Visible = enable;
        }

        #endregion

        #region EnableVScrollBar

        private void EnableVScrollBar(Rectangle cbounds, Rectangle cboundsEx)
        {
            bool enable = (VScrollBarVisible == true) &&
                (cboundsEx.Height > cbounds.Height);

            if (cbounds.Height <= 0 || (cbounds.Width < _VScrollBar.Width + 4))
                enable = false;

            if (enable == true)
            {
                _VScrollBar.Location = new
                    Point(cbounds.Right - _VScrollBar.Width - 1, cbounds.Top);

                _VScrollBar.Height = cbounds.Height - 1;

                if (_HScrollBar.Visible == true)
                    _VScrollBar.Height -= _HScrollBar.Height;

                _VScrollBar.Width = Dpi.Width(VScrollBarWidth);
            }
            else
            {
                _VScrollBar.Value = 0;
            }

            _VScrollBar.Enabled = enable;
            _VScrollBar.Visible = enable;
        }

        #endregion

        #endregion

        #region SetVScrollValue

        internal void SetVScrollValue(int value)
        {
            if (_VScrollBar.Visible == true)
            {
                int oldValue = _VScrollBar.Value;

                value = Math.Max(value, 0);
                value = Math.Min(value, _VScrollBar.Maximum);

                _VScrollBar.Value = value;
            }
        }

        #endregion

        #region SetHScrollValue

        internal void SetHScrollValue(int value)
        {
            if (_HScrollBar.Visible == true)
            {
                int oldValue = _HScrollBar.Value;

                value = Math.Max(value, 0);
                value = Math.Min(value, _HScrollBar.Maximum);

                _HScrollBar.Value = value;
            }
        }

        #endregion

        #region AutoScrolling support

        #region EnableAutoScrolling

        internal void EnableAutoScrolling(
            AutoScrollEnable enable, Rectangle scrollRect)
        {
            if (ChartControl.Focused == true)
            {
                _AutoScrollEnable = enable;

                if ((_HScrollBar != null && _HScrollBar.Visible == true) ||
                    (_VScrollBar != null && _VScrollBar.Visible == true))
                {
                    _ScrollRect = scrollRect;

                    if (_AutoScrollTimer == null)
                    {
                        _AutoScrollTimer = new Timer();

                        _AutoScrollTimer.Interval = 10;
                        _AutoScrollTimer.Tick += AutoScrollTimerTick;
                        _AutoScrollTimer.Start();
                    }
                }
            }
        }

        #endregion

        #region DisableAutoScrolling

        internal void DisableAutoScrolling()
        {
            if (_AutoScrollTimer != null)
            {
                _AutoScrollTimer.Stop();
                _AutoScrollTimer.Tick -= AutoScrollTimerTick;

                _AutoScrollTimer = null;
            }
        }

        #endregion

        #region AutoScrollTimerTick

        private void AutoScrollTimerTick(object sender, EventArgs e)
        {
            Point pt = ChartControl.PointToClient(Cursor.Position);
            Rectangle t = _ScrollRect;

            if ((_AutoScrollEnable & AutoScrollEnable.Horizontal) == AutoScrollEnable.Horizontal &&
                (_HScrollBar != null && _HScrollBar.Visible == true))
            {
                int dx = (pt.X < t.X)
                    ? ScrollAmount(pt.X - t.X)
                    : (pt.X >= t.Right) ? ScrollAmount(pt.X - t.Right) : 0;

                SetHScrollValue(_HScrollBar.Value + dx);
            }

            if ((_AutoScrollEnable & AutoScrollEnable.Vertical) == AutoScrollEnable.Vertical &&
                (_VScrollBar != null && _VScrollBar.Visible == true))
            {
                int dy = (pt.Y < t.Top)
                    ? ScrollAmount(pt.Y - t.Top)
                    : (pt.Y >= t.Bottom) ? ScrollAmount(pt.Y - t.Bottom) : 0;

                SetVScrollValue(_VScrollBar.Value + dy);
            }
        }

        #endregion

        #region ScrollAmount

        private int ScrollAmount(int delta)
        {
            int n = Math.Abs(delta);
            int amt = 1 << ((n / 16) + 1);

            return (delta < 0 ? -amt : amt);
        }

        #endregion

        #endregion

        #endregion

        #region EnsureVisible

        /// <summary>
        /// Ensures the container is visible on screen, and optionally
        /// centered (if possible).
        /// </summary>
        /// <param name="center"></param>
        public virtual void EnsureVisible(bool center)
        {
            ChartContainer parent = Parent as ChartContainer;

            if (parent != null)
                parent.EnsureVisible(this, center);
        }

        /// <summary>
        /// Ensures that the given container "item" is visible
        /// on screen, and optionally centered (if possible).
        /// </summary>
        /// <param name="center"></param>
        public virtual void EnsureVisible(ChartContainer item, bool center)
        {
            Rectangle bounds = ContentBounds;

            bounds.X += HScrollOffset;

            if (VScrollBar.Inverted == true)
                bounds.Y -= VScrollOffset;
            else
                bounds.Y += VScrollOffset;

            if (HScrollBar.Enabled == true)
                bounds.Width -= VScrollBar.Width;

            if (VScrollBar.Enabled == true)
                bounds.Height -= HScrollBar.Height;

            bounds.Width -= Dpi.Width4;
            bounds.Height -= Dpi.Height4;

            Rectangle ibounds = item.FrameBounds;

            if (bounds.Contains(ibounds) == false)
            {
                if (HScrollBar.Enabled == true)
                {
                    if (center == true)
                    {
                        int x = (bounds.X + bounds.Right) / 2 - (ibounds.Width / 2);

                        SetHScrollValue(ibounds.X - x);
                    }
                    else
                    {
                        int x = ibounds.X;

                        if (ibounds.Right > bounds.Right)
                            x -= (ibounds.Right - bounds.Right);

                        if (x < bounds.X)
                            x = bounds.X;

                        SetHScrollValue(HScrollOffset + (ibounds.X - x));
                    }
                }

                if (VScrollBar.Enabled == true)
                {
                    if (center == true)
                    {
                        int y = (bounds.Y + bounds.Bottom) / 2;
                        y -= (ibounds.Height / 2);

                        SetVScrollValue(ibounds.Y - y);
                    }
                    else
                    {
                        int y = ibounds.Y;

                        if (ibounds.Bottom > bounds.Bottom)
                            y -= (ibounds.Bottom - bounds.Bottom);

                        if (y < bounds.Y)
                            y = bounds.Y;

                        SetVScrollValue(VScrollOffset + (ibounds.Y - y));
                    }
                }
            }

            ChartContainer parent = Parent as ChartContainer;

            if (parent != null)
                parent.EnsureVisible(this, center);
        }

        #endregion

        #region GetDisplayBounds

        /// <summary>
        /// Gets the "displayBounds" of the given rectangle (scroll
        /// adjusted bounds).
        /// </summary>
        /// <param name="bounds"></param>
        /// <returns></returns>
        public Rectangle GetDisplayBounds(Rectangle bounds)
        {
            bounds.X -= HScrollOffset;

            if (VScrollBar.Inverted == true)
                bounds.Y += VScrollOffset;
            else
                bounds.Y -= VScrollOffset;

            return (bounds);
        }

        #endregion

        #region GetElementAt

        /// <summary>
        /// Gets the element at the given Point.
        /// </summary>
        /// <param name="pt"></param>
        /// <returns></returns>
        public override ChartVisualElement GetElementAt(Point pt)
        {
            if (InScrollBar(HScrollBar, pt))
                return (HScrollBar);

            if (InScrollBar(VScrollBar, pt))
                return (VScrollBar);

            foreach (ChartTitle title in Titles)
            {
                if (title.Visible == true)
                {
                    if (title.Bounds.Contains(pt))
                        return (title);
                }
            }

            if (Legend.Visible == true)
            {
                if (Legend.FrameBounds.Contains(pt))
                {
                    ChartVisualElement item = Legend.GetElementAt(pt);

                    return (item ?? Legend);
                }
            }

            return (null);
        }

        #region InScrollBar

        private bool InScrollBar(ScrollBarLite scrollBar, Point pt)
        {
            if (scrollBar != null && scrollBar.Visible == true)
            {
                if (scrollBar.Bounds.Contains(pt))
                    return (true);
            }

            return (false);
        }

        #endregion

        #endregion

        #region GetHitArea

        /// <summary>
        /// Gets the HitArea for the given Point.
        /// </summary>
        /// <param name="pt"></param>
        /// <returns></returns>
        public override ItemHitArea GetHitArea(Point pt)
        {
            Rectangle contentBounds = GetScrollBounds(ContentBounds);

            if (contentBounds.Contains(pt))
                return (ItemHitArea.InContent);

            Rectangle frameBounds = GetScrollBounds(FrameBounds);

            if (frameBounds.Contains(pt))
                return (ItemHitArea.InFrame);

            return (ItemHitArea.None);
        }

        #endregion

        #region GetTitleByName

        /// <summary>
        /// Gets the defined Title with the given name.
        /// </summary>
        /// <param name="name"></param>
        /// <returns>ChartTitle or null</returns>
        public ChartTitle GetTitleByName(string name)
        {
            return (Titles[name]);
        }

        #endregion

        #region Style Support

        #region GetEffectiveContainerStyle

        internal ContainerVisualStyle GetEffectiveContainerStyle()
        {
            StyleState state = GetStyleState();

            return (EffectiveContainerStyles[state]);
        }

        #endregion

        #region GetStyleState

        private StyleState GetStyleState()
        {
            StyleState state = StyleState.Default;

            if (IsMouseOver == true)
                state |= StyleState.MouseOver;

            if (IsSelected == true)
                state |= StyleState.Selected;

            return (state);
        }

        #endregion

        #region ApplyStyles

        public override void ApplyStyles(BaseVisualStyle style, StyleType cs)
        {
            base.ApplyStyles(style);

            ContainerVisualStyle cstyle = style as ContainerVisualStyle;

            if (cstyle != null)
            {
                ApplyParentStyles(cstyle, Parent as ChartContainer, cs);

                cstyle.ApplyStyle(ContainerVisualStyles[cs]);
            }
        }

        #region ApplyParentStyles (ChartContainerVisualStyles)

        private void ApplyParentStyles(
            ContainerVisualStyle cstyle, ChartContainer item, StyleType cs)
        {
            if (item != null)
            {
                ApplyParentStyles(cstyle, item.Parent as ChartContainer, cs);

                ChartPanel panel = item as ChartPanel;

                if (panel != null)
                {
                    if (panel.DefaultVisualStyles.ContainerVisualStyles != null)
                        cstyle.ApplyStyle(panel.DefaultVisualStyles.ContainerVisualStyles[cs]);
                }
            }
            else
            {
                ChartControl chartControl = ChartControl;

                if (chartControl.BaseVisualStyles.ContainerVisualStyles != null)
                    cstyle.ApplyStyle(chartControl.BaseVisualStyles.ContainerVisualStyles[cs]);

                if (chartControl.DefaultVisualStyles.ContainerVisualStyles != null)
                    cstyle.ApplyStyle(chartControl.DefaultVisualStyles.ContainerVisualStyles[cs]);
            }
        }

        #endregion

        #endregion

        #region ApplyDefaults

        public override void ApplyDefaults(BaseVisualStyle style, StyleType cs)
        {
            ContainerVisualStyle cstyle = style as ContainerVisualStyle;

            if (cstyle != null)
            {
                if (cstyle.BorderPattern == null)
                    cstyle.BorderPattern = new BorderPattern(LinePattern.Solid);

                if (cstyle.DropShadow.Enabled == Tbool.NotSet)
                    cstyle.DropShadow.Enabled = Tbool.False;
            }

            base.ApplyDefaults(style, cs);
        }

        #endregion

        #region InvalidateStyle

        ///<summary>
        ///Invalidate the cached Style
        ///</summary>
        public void InvalidateStyle()
        {
            ClearEffectiveStyles();
        }

        #endregion

        #region ClearEffectiveStyles

        protected override void ClearEffectiveStyles()
        {
            _EffectiveContainerStyles.InvalidateStyles();

            if (_VScrollBar != null)
                _VScrollBar.InvalidateStyle();

            if (_HScrollBar != null)
                _HScrollBar.InvalidateStyle();
        }

        #endregion

        #endregion

        #region ILegendData

        #region GetLegendItems

        public virtual List<ChartLegendItem> GetLegendData()
        {
            return (null);
        }

        #endregion

        #endregion

        #region CompareTo

        public int CompareTo(object obj)
        {
            ChartContainer cobj = obj as ChartContainer;

            if (cobj != null)
            {
                if (this.Equals(cobj) == true)
                    return (0);
            }

            return (-1);
        }

        #endregion

        #region Copy/CopyTo

        public override ChartVisualElement Copy()
        {
            ChartContainer copy = new ChartContainer();

            CopyTo(copy);

            return (copy);
        }

        public override void CopyTo(ChartVisualElement copy)
        {
            ChartContainer c = copy as ChartContainer;

            if (c != null)
            {
                base.CopyTo(c);

                c.AutoSizeMode = AutoSizeMode;

                c.ContainerVisualStyles = (_ContainerVisualStyles != null) ? ContainerVisualStyles.Copy() : null;

                c.EmptyText = EmptyText;
                c.EnableEmptyTextMarkup = EnableEmptyTextMarkup;
                c.EnablePanning = EnablePanning;
                c.EnableSelection = EnableSelection;
                c.FillWeight = FillWeight;
                c.HScrollBarHeight = HScrollBarHeight;
                c.HScrollBarVisible = HScrollBarVisible;

                c.Legend = (_Legend != null) ? (ChartLegend)Legend.Copy() : null;

                c.MatrixAlignEndColumn = MatrixAlignEndColumn;
                c.MatrixAlignEndRow = MatrixAlignEndRow;
                c.MatrixAlignStartColumn = MatrixAlignStartColumn;
                c.MatrixAlignStartRow = MatrixAlignStartRow;
                c.MatrixDisplayBounds = MatrixDisplayBounds;
                c.MatrixDisplayOrder = MatrixDisplayOrder;
                c.MinContentSize = MinContentSize;

                c.Titles.Clear();

                foreach (ChartTitle title in Titles)
                    c.Titles.Add((ChartTitle)title.Copy());

                c.VScrollBarWidth = VScrollBarWidth;
                c.VScrollBarVisible = VScrollBarVisible;
            }
        }

        #endregion

        #region GetSerialData

        internal override SerialElementCollection GetSerialData(string serialName)
        {
            SerialElementCollection sec = new SerialElementCollection();

            if (serialName != null)
            {
                if (serialName.Equals("") == true)
                    serialName = "ChartContainer";

                sec.AddStartElement(serialName);
            }

            sec.AddValue("AutoSizeMode", AutoSizeMode, AutoSizeMode.NotSet);

            if (_ContainerVisualStyles != null && _ContainerVisualStyles.IsEmpty == false)
                sec.AddElement(_ContainerVisualStyles.GetSerialData("ContainerVisualStyles"));

            sec.AddValue("EmptyText", EmptyText, null);
            sec.AddValue("EnableEmptyTextMarkup", EnableEmptyTextMarkup, false);

            sec.AddValue("EnablePanning", EnablePanning, true);
            sec.AddValue("EnableSelection", EnableSelection, false);

            sec.AddValue("FillWeight", FillWeight, 100);

            sec.AddValue("HScrollBarHeight", HScrollBarHeight, 9);
            sec.AddValue("HScrollBarVisible", HScrollBarVisible, true);

            if (_HScrollBar != null)
                sec.AddElement(_HScrollBar.GetSerialData("HScrollBar"));

            if (_Legend != null)
                sec.AddElement(_Legend.GetSerialData("Legend"));

            sec.AddValue("MatrixAlignEndColumn", MatrixAlignEndColumn, false);
            sec.AddValue("MatrixAlignEndRow", MatrixAlignEndRow, false);
            sec.AddValue("MatrixAlignStartColumn", MatrixAlignStartColumn, false);
            sec.AddValue("MatrixAlignStartRow", MatrixAlignStartRow, false);

            ChartPanel panel = Parent as ChartPanel;

            if (panel == null || panel.AutoFillChartMatrix == false) 
            {
                if (_MatrixDisplayBounds.IsEmpty == false)
                    sec.AddValue("MatrixDisplayBounds", MatrixDisplayBounds);
            }

            sec.AddValue("MatrixDisplayOrder", MatrixDisplayOrder, 0);
            sec.AddValue("MinContentSize", MinContentSize, new Size(100,100));

            if (_Titles != null && _Titles.Count > 0)
            {
                sec.AddStartElement("Titles count=\"" + _Titles.Count + "\"");

                foreach (ChartTitle title in _Titles)
                    sec.AddElement(title.GetSerialData(""));

                sec.AddEndElement("Titles");
            }

            if (_VScrollBar != null)
                sec.AddElement(_VScrollBar.GetSerialData("VScrollBar"));

            sec.AddValue("VScrollBarWidth", VScrollBarWidth, 9);
            sec.AddValue("VScrollBarVisible", VScrollBarVisible, true);

            sec.AddElement(base.GetSerialData(null));

            if (serialName != null)
                sec.AddEndElement("ChartContainer");

            return (sec);
        }

        #endregion

        #region PutSerialData

        #region ProcessValue

        internal override void ProcessValue(SerialElement se)
        {
            switch (se.Name)
            {
                case "AutoSizeMode":
                    AutoSizeMode = (AutoSizeMode)se.GetValueEnum(typeof(AutoSizeMode));
                    break;

                case "EmptyText":
                    EmptyText = se.StringValue;
                    break;

                case "EnableEmptyTextMarkup":
                    EnableEmptyTextMarkup = bool.Parse(se.StringValue);
                    break;

                case "EnablePanning":
                    EnablePanning = bool.Parse(se.StringValue);
                    break;

                case "EnableSelection":
                    EnableSelection = bool.Parse(se.StringValue);
                    break;

                case "FillWeight":
                    FillWeight = int.Parse(se.StringValue);
                    break;

                case "HScrollBarHeight":
                    HScrollBarHeight = int.Parse(se.StringValue);
                    break;

                case "HScrollBarVisible":
                    HScrollBarVisible = bool.Parse(se.StringValue);
                    break;

                case "MatrixAlignEndColumn":
                    MatrixAlignEndColumn = bool.Parse(se.StringValue);
                    break;

                case "MatrixAlignEndRow":
                    MatrixAlignEndRow = bool.Parse(se.StringValue);
                    break;

                case "MatrixAlignStartColumn":
                    MatrixAlignStartColumn = bool.Parse(se.StringValue);
                    break;

                case "MatrixAlignStartRow":
                    MatrixAlignStartRow = bool.Parse(se.StringValue);
                    break;

                case "MatrixDisplayBounds":
                    ChartPanel panel = Parent as ChartPanel;

                    if (panel == null || panel.AutoFillChartMatrix == false)
                        MatrixDisplayBounds = se.GetValueRect();
                    break;

                case "MatrixDisplayOrder":
                    MatrixDisplayOrder = int.Parse(se.StringValue);
                    break;

                case "MinContentSize":
                    MinContentSize = se.GetValueSize();
                    break;

                case "VScrollBarWidth":
                    VScrollBarWidth = int.Parse(se.StringValue);
                    break;

                case "VScrollBarVisible":
                    VScrollBarVisible = bool.Parse(se.StringValue);
                    break;

                default:
                    base.ProcessValue(se);
                    break;
            }
        }

        #endregion

        #region ProcessCollection

        internal override void ProcessCollection(SerialElement se)
        {
            SerialElementCollection sec = se.Sec;

            switch (se.Name)
            {
                case "ChartTitle":
                    string name = sec.GetItemValue("Name");

                    ChartTitle title = GetTitleByName(name);

                    if (title != null)
                        Titles.Remove(title);

                    title = new ChartTitle(name);

                    sec.PutSerialData(title);

                    Titles.Add(title);
                    break;

                case "ContainerVisualStyles":
                    sec.PutSerialData(ContainerVisualStyles);
                    break;

                case "HScrollBar":
                    sec.PutSerialData(HScrollBar);
                    break;

                case "Legend":
                    sec.PutSerialData(Legend);
                    break;

                case "Titles":
                    sec.PutSerialData(this);
                    break;

                case "VScrollBar":
                    sec.PutSerialData(VScrollBar);
                    break;

                default:
                    base.ProcessCollection(se);
                    break;
            }
        }

        #endregion

        #endregion

        #region States

        [Flags]
        private enum States : uint
        {
            AutoGenSeriesCollection = (1U << 0),

            EnableEmptyTextMarkup = (1U << 1),
            EnablePanning = (1U << 2),

            ShowPointsToolTips = (1U << 3),
            ShowSeriesToolTips = (1U << 4),

            HScrollBarEnabled = (1U << 5),
            VScrollBarEnabled = (1U << 6),
            HScrollBarVisible = (1U << 7),
            VScrollBarVisible = (1U << 8),

            LayoutBoundsValid = (1U << 9),
            IsSelected = (1U << 10),

            MatrixAlignStartColumn = (1U << 11),
            MatrixAlignEndColumn = (1U << 12),
            MatrixAlignStartRow = (1U << 13),
            MatrixAlignEndRow = (1U << 14),

            MatrixColumnAligned = (1U << 15),
            MatrixRowAligned = (1U << 16),

            EnableSelection = (1U << 17),
        }

        #region TestState

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

        #endregion

        #region SetState

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

        #endregion

        #endregion

        #region IDisposable

        public override void Dispose()
        {
            ContainerVisualStyles = null;
            Titles = null;

            base.Dispose();
        }

        #endregion
    }

    #region enums

    #region AutoSizeMode

    /// <summary>
    /// Defines auto-sizing mode.
    /// </summary>
    public enum AutoSizeMode
    {
        /// <summary>
        /// NotSet (None is default)
        /// </summary>
        NotSet = -1,

        /// <summary>
        /// No Auto-sizing will take place.
        /// </summary>
        None,

        /// <summary>
        /// Size will be determined by the fill weight.
        /// </summary>
        Fill,
    }

    #endregion

    #endregion
}