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.DotNetBar.Charts.Style;

namespace DevComponents.DotNetBar.Charts
{
    /// <summary>
    /// Represents the collection of Chart AxesX.
    /// </summary>
    [Editor("DevComponents.Charts.Design.ChartAxesCollectionEditor, DevComponents.Charts.Design, " +
            "Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
    public class ChartAxesXCollection : ChartAxesCollection
    {
        public ChartAxesXCollection()
            : base(AxisOrientation.X)
        {
        }

        #region GetUniqueName

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

        #endregion
    }

    /// <summary>
    /// Represents the collection of Chart AxesY.
    /// </summary>
    [Editor("DevComponents.Charts.Design.ChartAxesCollectionEditor, DevComponents.Charts.Design, " +
            "Version=14.1.0.37, Culture=neutral,  PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
    public class ChartAxesYCollection : ChartAxesCollection
    {
        public ChartAxesYCollection()
            : base(AxisOrientation.Y)
        {
        }

        #region GetUniqueName

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

        #endregion
    }

    /// <summary>
    /// Represents the collection of Chart Axes.
    /// </summary>
    public class ChartAxesCollection : CustomNamedCollection<ChartAxis>
    {
        #region Private variables

        private AxisOrientation _AxisOrientation;

        #endregion

        public ChartAxesCollection(AxisOrientation axisOrientation)
        {
            _AxisOrientation = axisOrientation;
        }

        #region Public properties

        #region AxisOrientation

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public AxisOrientation AxisOrientation
        {
            get { return (_AxisOrientation); }
        }

        #endregion

        #endregion

        #region InsertItem

        protected override void InsertItem(int index, ChartAxis item)
        {
            if (item.IsPrimaryAxis == true)
                throw new Exception("Primary Axes cannot be added as Ancillary Axes.");

 	        base.InsertItem(index, item);
        }

        #endregion
    }

    #region ChartAxisX

    /// <summary>
    /// Represents an X-Axis element.
    /// </summary>
    [TypeConverter(typeof(BlankExpandableObjectConverter))]
    public class ChartAxisX : ChartAxis
    {
        #region Constructors

        public ChartAxisX()
            : base(AxisOrientation.X)
        {
        }

        public ChartAxisX(string name)
            : base(AxisOrientation.X)
        {
            Name = name;
        }

        public ChartAxisX(string name, object minValue, object maxValue)
            : base(AxisOrientation.X)
        {
            Name = name;

            MinValue = minValue;
            MaxValue = MaxValue;
        }

        #endregion

        #region Public properties

        #region MajorGridLines

        ///<summary>
        /// Gets the axis MajorGridLines element.
        ///</summary>
        [Description("Indicates the MajorGridLines element.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public override ChartMajorGridLines MajorGridLines
        {
            get
            {
                if (_MajorGridLines == null)
                {
                    _MajorGridLines = new ChartMajorGridLinesX();
                    _MajorGridLines.Parent = this;
                }

                return (_MajorGridLines);
            }
        }

        #endregion

        #region MajorTickmarks

        ///<summary>
        /// Gets the axis MajorTickmarks element.
        ///</summary>
        [Description("Indicates the MajorTickmarks element.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public override MajorTickmarks MajorTickmarks
        {
            get
            {
                if (_MajorTickmarks == null)
                {
                    _MajorTickmarks = new MajorTickmarksX();
                    _MajorTickmarks.Parent = this;
                }

                return (_MajorTickmarks);
            }
        }

        #endregion

        #region MinorGridLines

        ///<summary>
        /// Gets the axis MinorGridLines element.
        ///</summary>
        [Description("Indicates the MinorGridLines element.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public override ChartMinorGridLines MinorGridLines
        {
            get
            {
                if (_MinorGridLines == null)
                {
                    _MinorGridLines = new ChartMinorGridLinesX();
                    _MinorGridLines.Parent = this;
                }

                return (_MinorGridLines);
            }
        }

        #endregion

        #region MinorTickmarks

        ///<summary>
        /// Gets the axis MinorTickmarks element.
        ///</summary>
        [Description("Indicates the MinorTickmarks element.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public override MinorTickmarks MinorTickmarks
        {
            get
            {
                if (_MinorTickmarks == null)
                {
                    _MinorTickmarks = new MinorTickmarksX();
                    _MinorTickmarks.Parent = this;
                }

                return (_MinorTickmarks);
            }
        }

        #endregion

        #endregion

        #region MeasureOverride

        protected override void MeasureOverride(ChartLayoutInfo layoutInfo)
        {
            ChartXy chartXy = Parent as ChartXy;

            ChartAxisVisualStyle astyle = EffectiveAxisStyle;
            AxisAlignment axisAlignment = GetAxisAlignment();
            
            Rectangle bounds = layoutInfo.LayoutBounds;

            if (Visible == true)
            {
                MeasureTitle(layoutInfo, axisAlignment);

                int width = Math.Max(layoutInfo.LayoutBounds.Width, Dpi.Width(chartXy.MinContentSize.Width));

                int tickmarkLen = MeasureTickmarks(layoutInfo, width);

                bounds.Height = GetMeasuredHeight();

                layoutInfo.LayoutBounds.Height -= tickmarkLen;

                if (axisAlignment == AxisAlignment.Far)
                {
                    layoutInfo.LayoutBounds.Y += tickmarkLen;
                }
                else
                {
                    bounds.Y = layoutInfo.LayoutBounds.Bottom;

                    if (EdgeAxis == true)
                    {
                        bounds.Y--;

                        if (chartXy.DropShadowDisplayed == true)
                            layoutInfo.LayoutBounds.Height += 3;
                    }
                }
            }
            else
            {
                int width = Math.Max(layoutInfo.LayoutBounds.Width, Dpi.Width(chartXy.MinContentSize.Width));

                MeasureTickmarks(layoutInfo, width);

                bounds.Height = 0;
            }

            CalcAxisBounds(layoutInfo, axisAlignment, bounds);

            BoundsRelative = bounds;

            base.MeasureOverride(layoutInfo);
        }

        #region MeasureTitle

        protected void MeasureTitle(
            ChartLayoutInfo layoutInfo, AxisAlignment axisAlignment)
        {
            if (Title.Visible == true)
            {
                Title.XyAlignment = (axisAlignment == AxisAlignment.Near)
                    ? XyAlignment.Bottom : XyAlignment.Top;

                Title.Measure(layoutInfo);
            }
        }

        #endregion

        #region MeasureTickmarks

        protected virtual int MeasureTickmarks(ChartLayoutInfo layoutInfo, int width)
        {
            CalcMajorSpacing(layoutInfo, width);

            MajorTickmarks.TickmarkLayout = TickmarkLayout;
            MinorTickmarks.TickmarkLayout = TickmarkLayout;

            MajorTickmarks.Measure(layoutInfo);
            MinorTickmarks.Measure(layoutInfo);

            return (Math.Max(MajorTickmarks.Size.Height,
                             MinorTickmarks.Size.Height));
        }

        #endregion

        #region GetMeasuredHeight

        private int GetMeasuredHeight()
        {
            int height = Math.Max(MajorTickmarks.Size.Height,
                MinorTickmarks.Size.Height);

            if (Title.Visible == true)
                height += Title.Size.Height;

            return (height);
        }

        #endregion

        #region CalcAxisBounds

        private void CalcAxisBounds(ChartLayoutInfo layoutInfo,
            AxisAlignment axisAlignment, Rectangle bounds)
        {
            ChartXy chartXy = Parent as ChartXy;

            int labelHeight = 0;
            int tmInnerLength = 0;
            int tmOuterLength = 0;

            if (TickmarkLayout.MajorCount > 0)
            {
                labelHeight = MajorTickmarks.GetTotalLabelHeight();

                tmOuterLength = Dpi.Width(GetMaxTickMarkLength(false));
                tmInnerLength = Dpi.Width(GetMaxTickMarkLength(true));

                if (axisAlignment == AxisAlignment.Near)
                {
                    if (EdgeAxis == true)
                    {
                        if (chartXy.HScrollBar.Visible == true)
                            tmInnerLength += (chartXy.HScrollBar.Height + 1);

                        bounds.Y -= tmInnerLength;
                    }
                }
                else
                {
                    if (Title.Visible == true)
                        bounds.Y += Title.Size.Height;
                }

                bounds.Height = (labelHeight + tmOuterLength + tmInnerLength + 1);

                AxisBounds = bounds;

                Rectangle r = bounds;
                r.Height = 1;

                if (axisAlignment == AxisAlignment.Near)
                {
                    r.Y += tmInnerLength;

                    if (EdgeAxis == false)
                        r.Y += 1;
                }
                else
                {
                    r.Y = bounds.Bottom - tmInnerLength - 1;
                }

                AxisLineBounds = r;
            }
        }

        #endregion

        #endregion

        #region ArrangeOverride

        protected override void ArrangeOverride(ChartLayoutInfo layoutInfo)
        {
            ChartXy chartXy = Parent as ChartXy;

            // Let the axis bounds extend into the chart's frame
            // area as much as possible for better label display.

            Rectangle r = AxisBounds;
            r.Width = chartXy.ContentBounds.Width;

            int n1 = r.X - chartXy.FrameBounds.X;
            int n2 = chartXy.FrameBounds.Right - r.Right;

            r.X = chartXy.FrameBounds.X;
            r.Width += (n1 + n2);

            AxisBounds = r;

            r = AxisLineBounds;
            r.Width = chartXy.ContentBounds.Width;
            AxisLineBounds = r;

            base.ArrangeOverride(layoutInfo);
        }

        #endregion

        #region RenderOverride

        protected override void RenderOverride(ChartRenderInfo renderInfo)
        {
            if (Visible == true)
            {
                base.RenderOverride(renderInfo);

                Graphics g = renderInfo.Graphics;
                ChartAxisVisualStyle astyle = EffectiveAxisStyle;

                if (TickmarkLayout.MajorCount > 0)
                {
                    Rectangle axisBounds = GetScrollBounds(AxisBounds);

                    Region clip = g.Clip;
                    g.SetClip(axisBounds, CombineMode.Intersect);

                    MajorTickmarks.Render(renderInfo);
                    MinorTickmarks.Render(renderInfo);

                    RenderAxisLine(g, astyle);

                    g.Clip = clip;
                }
            }
        }

        #region RenderAxisLine

        private void RenderAxisLine(Graphics g, ChartAxisVisualStyle astyle)
        {
            if (astyle.AxisColor.IsEmpty == false &&
                astyle.AxisColor.Equals(Color.Transparent) == false)
            {
                Rectangle alBounds = GetScrollBounds(AxisLineBounds);

                using (Pen pen = new Pen(astyle.AxisColor, Dpi.Height1))
                    g.DrawLine(pen, alBounds.X, alBounds.Y, alBounds.Right - 1, alBounds.Y);
            }
        }

        #endregion

        #endregion

        #region RenderCrosshairLabel (Point)

        internal override void RenderCrosshairLabel(Graphics g, Point pt)
        {
            TickmarkLayout layout = TickmarkLayout;

            if (layout != null && layout.Ticks != null && layout.Ticks.Length > 0)
            {
                TickmarkTick tick = layout.Ticks[0];
                CrosshairValueVisualStyle lstyle = EffectiveCrosshairLabelStyle;

                string text = GetCrosshairLabel(pt, layout, tick, lstyle);

                if (string.IsNullOrEmpty(text) == false)
                {
                    Rectangle r = GetCrosshairBounds(g, text, pt, lstyle);

                    lstyle.RenderBackground(g, r);
                    lstyle.RenderBorder(g, r);

                    if (lstyle.DropShadow.Enabled == Tbool.True)
                        lstyle.DropShadow.RenderDropShadow(g, r, true, true);

                    using (StringFormat sf = new StringFormat())
                    {
                        sf.Alignment = StringAlignment.Center;
                        sf.LineAlignment = StringAlignment.Center;

                        using (Brush br = new SolidBrush(lstyle.TextColor))
                            g.DrawString(text, lstyle.Font, br, r, sf);
                    }
                }
            }
        }

        #region GetCrosshairLabel

        private string GetCrosshairLabel(Point pt,
            TickmarkLayout layout, TickmarkTick tick, CrosshairValueVisualStyle lstyle)
        {
            object value = null;

            switch (ScaleType)
            {
                case ScaleType.DateTime:
                    value = GetValueFromPoint(layout, pt);
                    break;

                case ScaleType.Qualitative:
                    pt = GetChartPoint(pt);

                    int n = (int)Math.Floor((pt.X - (layout.NearMargin + layout.MarginOffset -
                        layout.MajorInterval / 2 + tick.TickPoint.X)) / (layout.MajorInterval * layout.MajorSpacing));

                    n += tick.Index;

                    if ((uint)n < QualitativeValues.Count)
                        value = QualitativeValues[n];
                    break;

                case ScaleType.Quantitative:
                    double dvalue = Convert.ToDouble(GetValueFromPoint(layout, pt));

                    if (DotPlotAxis == true && Math.Floor(layout.MajorSpacing) == layout.MajorSpacing)
                        dvalue = Math.Floor(dvalue + .5);

                    value = dvalue;
                    break;
            }

            return (GetCrosshairLabel(value, lstyle));
        }

        #endregion

        #region GetCrosshairBounds

        private Rectangle GetCrosshairBounds(Graphics g,
            string text, Point pt, CrosshairValueVisualStyle lstyle)
        {
            Rectangle bounds = GetScrollBounds(MajorTickmarks.LabelBounds);
            Rectangle r = bounds; 

            SizeF sizef = g.MeasureString(text, lstyle.Font);

            r.Width = (int)(sizef.Width + 2);
            r.Height = (int)(sizef.Height + 2);

            r.X = pt.X - (int)(sizef.Width / 2);
            r.Y--;

            AxisAlignment axisalignment = GetAxisAlignment();

            if (lstyle.Margin.IsEmpty == false)
            {
                if (axisalignment == AxisAlignment.Near)
                    r.Y += lstyle.Margin.Top;
                else
                    r.Y -= lstyle.Margin.Bottom;
            }

            if (axisalignment == AxisAlignment.Near)
                r.Y += (lstyle.BorderThickness.Vertical);
            else
                r.Y -= (lstyle.BorderThickness.Vertical);

            r.Height += lstyle.BorderThickness.Vertical;

            if (lstyle.Padding.IsEmpty == false)
            {
                if (axisalignment == AxisAlignment.Far)
                    r.Y -= lstyle.Padding.Vertical;

                r.Height += lstyle.Padding.Vertical;

                r.X -= lstyle.Padding.Left;
                r.Width += lstyle.Padding.Horizontal;
            }

            if (r.Bottom > bounds.Bottom)
                r.Y -= (r.Bottom - bounds.Bottom);

            if (r.Right > bounds.Right)
                r.X -= (r.Right - bounds.Right);

            return (r);
        }

        #endregion

        #endregion

        #region RenderCrosshairLabel (CrosshairPoint)

        internal override void RenderCrosshairLabel(Graphics g, CrosshairPoint cp)
        {
            CrosshairValueVisualStyle lstyle = EffectiveCrosshairLabelStyle;

            string text = (cp.ChartSeries.IsRotated == false)
                ? GetCrosshairLabel(cp.SeriesPoint.ValueX, lstyle)
                : GetCrosshairLabel(cp.SeriesPoint.ValueY[cp.ValueIndex], lstyle);

            if (string.IsNullOrEmpty(text) == false)
            {
                Rectangle r = GetCrosshairBounds(g, text, cp.Point, lstyle);

                lstyle.RenderBackground(g, r);
                lstyle.RenderBorder(g, r);

                if (lstyle.DropShadow.Enabled == Tbool.True)
                    lstyle.DropShadow.RenderDropShadow(g, r, true, true);

                using (StringFormat sf = new StringFormat())
                {
                    sf.Alignment = StringAlignment.Center;
                    sf.LineAlignment = StringAlignment.Center;

                    using (Brush br = new SolidBrush(lstyle.TextColor))
                        g.DrawString(text, lstyle.Font, br, r, sf);
                }
            }
        }

        #endregion

        #region RenderBackground

        internal override void RenderBackground(ChartRenderInfo renderInfo, Rectangle scContentBounds)
        {
            if (UseAlternateBackground == true)
            {
                if (TickmarkLayout.Ticks != null)
                {
                    Graphics g = renderInfo.Graphics;
                    ChartXy chartXy = Parent as ChartXy;

                    Point pt = chartXy.GetLocalAdjustedPoint(Point.Empty);

                    if (ScaleType == ScaleType.Qualitative)
                        pt.X -= (int)(TickmarkLayout.MajorInterval / 2);

                    ChartAxisVisualStyle astyle = EffectiveAxisStyle;

                    if (astyle.AlternateBackground.IsSolidBrush == true)
                    {
                        using (Brush br = astyle.AlternateBackground.GetBrush(Rectangle.Empty))
                        {
                            RenderAltBackground(g,
                                scContentBounds, pt, TickmarkLayout, astyle, br);
                        }
                    }
                    else
                    {
                        RenderAltBackground(g,
                            scContentBounds, pt, TickmarkLayout, astyle, null);
                    }
                }
            }
        }

        #region RenderAltBackground

        private void RenderAltBackground(Graphics g, Rectangle scContentBounds, 
            Point pt, TickmarkLayout TickmarkLayout, ChartAxisVisualStyle astyle, Brush br)
        {
            foreach (TickmarkTick tmi in TickmarkLayout.Ticks)
            {
                double value = GetTickmarkAltValue(tmi);
                int n = (int)(Math.Ceiling(value / TickmarkLayout.MajorSpacing));

                if (n % 2 == 0)
                {
                    Rectangle r = scContentBounds;
                    r.X = tmi.TickPoint.X + pt.X;
                    r.Width = (int)TickmarkLayout.MajorInterval + 1;

                    if (br == null)
                    {
                        using (Brush br2 = astyle.AlternateBackground.GetBrush(r))
                            g.FillRectangle(br2, r);
                    }
                    else
                    {
                        g.FillRectangle(br, r);
                    }
                }
            }
        }

        #endregion

        #endregion

        #region RenderStripes

        internal override void RenderStripes(ChartRenderInfo renderInfo, Rectangle scContentBounds)
        {
            if (AxisStripes.Count > 0)
            {
                Graphics g = renderInfo.Graphics;
                ChartXy chartXy = Parent as ChartXy;

                Point pt = chartXy.GetLocalAdjustedPoint(Point.Empty);

                foreach (AxisStripe stripe in AxisStripes)
                {
                    if (stripe.IsDisplayed == true)
                    {
                        if (stripe.MinValue != stripe.MaxValue)
                        {
                            int x1 = chartXy.GetDataPointX(this, stripe.MinValue);
                            int x2 = chartXy.GetDataPointX(this, stripe.MaxValue);

                            Rectangle r = scContentBounds;
                            r.X = (x1 + pt.X);
                            r.Width = (x2 - x1);

                            RenderStripe(g, r, stripe);
                        }
                    }
                }
            }
        }

        #endregion

        #region UpdateRangeValues

        internal override void UpdateRangeValues(ChartXy chartXy)
        {
            bool seriesSeen = false;

            foreach (ChartSeries series in chartXy.ChartSeries)
            {
                if (series.AxisX == this)
                {
                    if (series.SeriesPoints.Count > 0)
                        UpdateRangeValuesEx(chartXy, series, ref seriesSeen);
                }
            }

            if (seriesSeen == false)
            {
                foreach (ChartSeries series in chartXy.ChartSeries)
                {
                    if (series.AxisX == null)
                    {
                        if (series.SeriesPoints.Count > 0)
                            UpdateRangeValuesEx(chartXy, series, ref seriesSeen);
                    }
                }
            }
        }

        #region UpdateRangeValuesEx

        private void UpdateRangeValuesEx(ChartXy chartXy, ChartSeries series, ref bool seriesSeen)
        {
            if (ActualMinValue == null)
            {
                ActualMinValue = series.MinValueX;
                ActualMaxValue = series.MaxValueX;
            }
            else
            {
                if (chartXy.DataCompare(series.MinValueX, ActualMinValue) < 0)
                    ActualMinValue = series.MinValueX;

                if (chartXy.DataCompare(series.MaxValueX, ActualMaxValue) > 0)
                    ActualMaxValue = series.MaxValueX;
            }

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

                ScaleType = series.ActualScaleTypeX;
            }
            else
            {
                if (series.ActualScaleTypeX != ScaleType)
                {
                    string s = "XAxis cannot contain series with differing ScaleTypes";

                    if (String.IsNullOrEmpty(Name) == false)
                        s += " (" + Name + ")";

                    throw new Exception(s);
                }
            }

            if (ScaleType == ScaleType.Qualitative)
            {
                if (series.IsRotated == true)
                {
                    foreach (object o in series.QualitativeYValues)
                    {
                        if (QualitativeValues.Contains(o) == false)
                            QualitativeValues.Add(o);
                    }
                }
                else
                {
                    foreach (object o in series.QualitativeXValues)
                    {
                        if (QualitativeValues.Contains(o) == false)
                            QualitativeValues.Add(o);
                    }
                }

                if (QualitativeValues.Count - 1 > (int)ActualMaxValue)
                    ActualMaxValue = QualitativeValues.Count - 1;
            }
        }

        #endregion

        #endregion

        #region GetValueFromPoint

        internal override object GetValueFromPoint(TickmarkLayout layout, Point pt)
        {
            if (layout.Ticks != null)
            {
                pt = GetChartPoint(pt);

                TickmarkTick lastTick = null;

                foreach (TickmarkTick tick in layout.Ticks)
                {
                    if (tick.TickPoint.X == pt.X)
                        return (tick.Value);

                    if (tick.TickPoint.X > pt.X)
                    {
                        if (lastTick != null)
                        {
                            double d = ((double)tick.TickPoint.X - lastTick.TickPoint.X) / (layout.MinorCount + 1);

                            for (int i = 1; i <= layout.MinorCount; i++)
                            {
                                int x = (int)(lastTick.TickPoint.X + (d * i));

                                if (x >= pt.X)
                                    break;
                            }
                        }
                        break;
                    }

                    lastTick = tick;
                }

                int dx = pt.X - Bounds.X;

                switch (ScaleType)
                {
                    case ScaleType.Qualitative:
                        return (layout.MajorSpacing * ((dx + layout.MarginOffset) /
                            layout.MajorInterval) + (int)layout.BaseValue);

                    case ScaleType.DateTime:
                        return (GetDateTimePointValue(layout, dx));

                    default:
                        return (layout.MajorSpacing * ((dx + layout.MarginOffset) /
                            layout.MajorInterval) + Convert.ToDouble(layout.BaseValue));
                }
            }

            return (null);
        }

        #endregion

        #region GetPointFromValue

        /// <summary>
        /// Gets the chart Point from the given axis data value.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public override Point GetPointFromValue(object value)
        {
            return (new Point(GetDisplayValue(value), 0));
        }

        #endregion

        #region GetDisplayValue

        internal override int GetDisplayValue(object axisValue)
        {
            ChartXy chartXy = Parent as ChartXy;

            return (chartXy.GetDataPointX(this, axisValue));
        }

        #endregion

        #region EnsureVisible

        /// <summary>
        /// Ensures the given data value is visible and
        /// optionally centered on screen.
        /// </summary>
        /// <param name="value"></param>
        public override void EnsureVisible(object value, bool center)
        {
            ChartXy chartXy = Parent as ChartXy;

            if (chartXy != null)
            {
                if (chartXy.ChartControl != null)
                {
                    if (chartXy.ChartControl.LayoutValid == false)
                        chartXy.ChartControl.UpdateLayout();

                    Rectangle cbounds = chartXy.ContentBounds;

                    int x = GetDisplayValue(value);

                    if (center == true)
                    {
                        int n = (x - cbounds.Width / 2) - cbounds.X;

                        chartXy.HScrollOffset = n;
                    }
                    else
                    {
                        int n = cbounds.X + chartXy.HScrollOffset + 20;

                        if (x < n)
                        {
                            chartXy.HScrollOffset += (x - n);
                        }
                        else
                        {
                            n = cbounds.Right + chartXy.HScrollOffset - 20;

                            if (x > n)
                                chartXy.HScrollOffset += (x - n);
                        }
                    }
                }
            }
        }

        #endregion

        #region Copy/CopyTo

        /// <summary>
        /// Creates a copy of the axis.
        /// </summary>
        /// <returns></returns>
        public override ChartVisualElement Copy()
        {
            ChartAxisX copy = new ChartAxisX();

            CopyTo(copy);

            return (copy);
        }

        /// <summary>
        /// Copies the current axis properties to the
        /// given "copy" axis.
        /// </summary>
        /// <param name="copy"></param>
        public override void CopyTo(ChartVisualElement copy)
        {
            ChartAxisX c = copy as ChartAxisX;

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

                MajorGridLines.CopyTo(c.MajorGridLines);
                MinorGridLines.CopyTo(c.MinorGridLines);

                MajorTickmarks.CopyTo(c.MajorTickmarks);
                MinorTickmarks.CopyTo(c.MinorTickmarks);
            }
        }

        #endregion

        #region GetSerialData

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

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

                sec.AddStartElement(serialName);
            }

            sec.AddElement(MajorGridLines.GetSerialData("MajorGridLines"));
            sec.AddElement(MinorGridLines.GetSerialData("MinorGridLines"));
            sec.AddElement(MajorTickmarks.GetSerialData("MajorTickmarks"));
            sec.AddElement(MinorTickmarks.GetSerialData("MinorTickmarks"));

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

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

            return (sec);
        }

        #endregion

        #region PutSerialData

        #region ProcessCollection

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

            switch (se.Name)
            {
                case "MajorGridLines":
                    sec.PutSerialData(MajorGridLines);
                    break;

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

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

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

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

        #endregion

        #endregion
    }

    #endregion

    #region ChartAxisY

    /// <summary>
    /// Represents a Y-Axis element.
    /// </summary>
    [TypeConverter(typeof(BlankExpandableObjectConverter))]
    public class ChartAxisY : ChartAxis
    {
        #region Constructors

        public ChartAxisY()
            : base(AxisOrientation.Y)
        {
        }

        public ChartAxisY(string name)
            : base(AxisOrientation.Y)
        {
            Name = name;
        }

        public ChartAxisY(string name, object minValue, object maxValue)
            : base(AxisOrientation.Y)
        {
            Name = name;

            MinValue = minValue;
            MaxValue = MaxValue;
        }

        #endregion

        #region Public properties

        #region MajorGridLines

        ///<summary>
        /// Gets the axis MajorGridLines element.
        ///</summary>
        [Description("Indicates the MajorGridLines element.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public override ChartMajorGridLines MajorGridLines
        {
            get
            {
                if (_MajorGridLines == null)
                {
                    _MajorGridLines = new ChartMajorGridLinesY();
                    _MajorGridLines.Parent = this;
                }

                return (_MajorGridLines);
            }
        }

        #endregion

        #region MajorTickmarks

        ///<summary>
        /// Gets the axis MajorTickmarks element.
        ///</summary>
        [Description("Indicates the MajorTickmarks element.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public override MajorTickmarks MajorTickmarks
        {
            get
            {
                if (_MajorTickmarks == null)
                {
                    _MajorTickmarks = new MajorTickmarksY();
                    _MajorTickmarks.Parent = this;
                }

                return (_MajorTickmarks);
            }
        }

        #endregion

        #region MinorGridLines

        ///<summary>
        /// Gets the axis MinorGridLines element.
        ///</summary>
        [Description("Indicates the MinorGridLines element.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public override ChartMinorGridLines MinorGridLines
        {
            get
            {
                if (_MinorGridLines == null)
                {
                    _MinorGridLines = new ChartMinorGridLinesY();
                    _MinorGridLines.Parent = this;
                }

                return (_MinorGridLines);
            }
        }

        #endregion

        #region MinorTickmarks

        ///<summary>
        /// Gets the axis MinorTickmarks element.
        ///</summary>
        [Description("Indicates the MinorTickmarks element.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public override MinorTickmarks MinorTickmarks
        {
            get
            {
                if (_MinorTickmarks == null)
                {
                    _MinorTickmarks = new MinorTickmarksY();
                    _MinorTickmarks.Parent = this;
                }

                return (_MinorTickmarks);
            }
        }

        #endregion

        #endregion

        #region MeasureOverride

        protected override void MeasureOverride(ChartLayoutInfo layoutInfo)
        {
            ChartXy chartXy = Parent as ChartXy;

            ChartAxisVisualStyle astyle = EffectiveAxisStyle;
            AxisAlignment axisAlignment = GetAxisAlignment();

            Rectangle bounds = layoutInfo.LayoutBounds;

            if (Visible == true)
            {
                MeasureTitle(layoutInfo, axisAlignment);

                int height = Math.Max(layoutInfo.LayoutBounds.Height, Dpi.Height((chartXy.MinContentSize.Height)));
                int tickmarkLen = MeasureTickmarks(layoutInfo, height);

                bounds.Width = GetMeasuredWidth();

                layoutInfo.LayoutBounds.Width -= tickmarkLen;

                if (axisAlignment == AxisAlignment.Far)
                {
                    layoutInfo.LayoutBounds.X += tickmarkLen;
                }
                else
                {
                    bounds.X = layoutInfo.LayoutBounds.Right;

                    if (EdgeAxis == true)
                    {
                        bounds.X -= 1;

                        if (chartXy.DropShadowDisplayed == true)
                            layoutInfo.LayoutBounds.Width += 3;
                    }
                }
            }
            else
            {
                int height = Math.Max(layoutInfo.LayoutBounds.Height, Dpi.Height(chartXy.MinContentSize.Height));
                int tickmarkLen = MeasureTickmarks(layoutInfo, height);

                bounds.Width = 0;
            }

            CalcAxisBounds(layoutInfo, axisAlignment, bounds);

            BoundsRelative = bounds;

            base.MeasureOverride(layoutInfo);
        }

        #region MeasureTitle

        protected void MeasureTitle(
            ChartLayoutInfo layoutInfo, AxisAlignment axisAlignment)
        {
            if (Title.Visible == true)
            {
                Title.XyAlignment = (axisAlignment == AxisAlignment.Near)
                    ? XyAlignment.Right : XyAlignment.Left;

                Title.Measure(layoutInfo);
            }
        }

        #endregion

        #region MeasureTickmarks

        protected virtual int MeasureTickmarks(ChartLayoutInfo layoutInfo, int height)
        {
            CalcMajorSpacing(layoutInfo, height);

            MajorTickmarks.TickmarkLayout = TickmarkLayout;
            MinorTickmarks.TickmarkLayout = TickmarkLayout;

            MajorTickmarks.Measure(layoutInfo);
            MinorTickmarks.Measure(layoutInfo);

            return (Math.Max(MajorTickmarks.Size.Width,
                             MinorTickmarks.Size.Width));
        }

        #endregion

        #region GetMeasuredWidth

        private int GetMeasuredWidth()
        {
            int width = Math.Max(MajorTickmarks.Size.Width,
                MinorTickmarks.Size.Width);

            if (Title.Visible == true)
                width += Title.Size.Width;

            return (width);
        }

        #endregion

        #region CalcAxisBounds

        private void CalcAxisBounds(ChartLayoutInfo layoutInfo,
            AxisAlignment axisAlignment, Rectangle bounds)
        {
            int labelWidth = 0;
            int tmInnerLength = 0;
            int tmOuterLength = 0;

            if (TickmarkLayout.MajorCount > 0)
            {
                labelWidth = MajorTickmarks.GetTotalLabelWidth();

                tmOuterLength = Dpi.Width(GetMaxTickMarkLength(false));
                tmInnerLength = Dpi.Width(GetMaxTickMarkLength(true));

                if (axisAlignment == AxisAlignment.Near)
                {
                    if (EdgeAxis == true)
                    {
                        ChartXy chartXy = Parent as ChartXy;

                        if (chartXy.VScrollBar.Visible == true)
                            tmInnerLength += (chartXy.VScrollBar.Width + 1);

                        bounds.X -= tmInnerLength;
                    }
                }
                else
                {
                    if (Title.Visible == true)
                        bounds.X += Title.Size.Width;
                }

                bounds.Width = (labelWidth + tmOuterLength + tmInnerLength + 1);

                AxisBounds = bounds;

                Rectangle r = bounds;
                r.Width = 1;

                if (axisAlignment == AxisAlignment.Near)
                {
                    r.X += tmInnerLength;

                    if (EdgeAxis == false)
                        r.X += 1;
                }
                else
                {
                    r.X = bounds.Right - tmInnerLength - 1;
                }

                AxisLineBounds = r;
            }
        }

        #endregion

        #endregion

        #region ArrangeOverride

        protected override void ArrangeOverride(ChartLayoutInfo layoutInfo)
        {
            ChartXy chartXy = Parent as ChartXy;

            // Let the axis bounds extend into the chart's frame
            // area as much as possible for better label display.

            Rectangle r = AxisBounds;
            r.Height = chartXy.ContentBounds.Height;

            int n1 = r.Y - chartXy.FrameBounds.Y;
            int n2 = chartXy.FrameBounds.Bottom - r.Bottom;

            r.Y = chartXy.FrameBounds.Y;
            r.Height += (n1 + n2);

            AxisBounds = r;

            r = AxisLineBounds;
            r.Height = chartXy.ContentBounds.Height;
            AxisLineBounds = r;

            base.ArrangeOverride(layoutInfo);
        }

        #endregion

        #region RenderOverride

        protected override void RenderOverride(ChartRenderInfo renderInfo)
        {
            base.RenderOverride(renderInfo);

            Graphics g = renderInfo.Graphics;
            ChartAxisVisualStyle astyle = EffectiveAxisStyle;

            if (TickmarkLayout.MajorCount > 0)
            {
                Rectangle axisBounds = GetScrollBounds(AxisBounds);

                Region clip = g.Clip;
                g.SetClip(axisBounds, CombineMode.Intersect);

                MajorTickmarks.Render(renderInfo);
                MinorTickmarks.Render(renderInfo);

                RenderAxisLine(g, astyle);

                g.Clip = clip;
            }
        }

        #region RenderAxisLine

        private void RenderAxisLine(Graphics g, ChartAxisVisualStyle astyle)
        {
            if (astyle.AxisColor.IsEmpty == false &&
                astyle.AxisColor.Equals(Color.Transparent) == false)
            {
                Rectangle alBounds = GetScrollBounds(AxisLineBounds);

                using (Pen pen = new Pen(astyle.AxisColor, Dpi.Width1))
                    g.DrawLine(pen, alBounds.X, alBounds.Y, alBounds.X, alBounds.Bottom - 1);
            }
        }

        #endregion

        #endregion

        #region RenderCrosshairLabel (Point)

        internal override void RenderCrosshairLabel(Graphics g, Point pt)
        {
            TickmarkLayout layout = TickmarkLayout;

            if (layout != null && layout.Ticks != null && layout.Ticks.Length > 0)
            {
                TickmarkTick tick = layout.Ticks[0];
                CrosshairValueVisualStyle lstyle = EffectiveCrosshairLabelStyle;

                string text = GetCrosshairLabel(pt, layout, tick, lstyle);

                if (string.IsNullOrEmpty(text) == false)
                {
                    Rectangle r = GetCrosshairBounds(g, text, pt, lstyle);

                    lstyle.RenderBackground(g, r);
                    lstyle.RenderBorder(g, r);

                    if (lstyle.DropShadow.Enabled == Tbool.True)
                        lstyle.DropShadow.RenderDropShadow(g, r, true, true);

                    using (StringFormat sf = new StringFormat())
                    {
                        sf.Alignment = StringAlignment.Center;
                        sf.LineAlignment = StringAlignment.Center;

                        using (Brush br = new SolidBrush(lstyle.TextColor))
                            g.DrawString(text, lstyle.Font, br, r, sf);
                    }
                }
            }
        }

        #region GetCrosshairLabel

        private string GetCrosshairLabel(Point pt,
            TickmarkLayout layout, TickmarkTick tick, CrosshairValueVisualStyle lstyle)
        {
            object value = null;

            switch (ScaleType)
            {
                case ScaleType.DateTime:
                    value = GetValueFromPoint(layout, pt);
                    break;

                case ScaleType.Qualitative:
                    pt = GetChartPoint(pt);

                    int n = (int)Math.Floor(((tick.TickPoint.Y - layout.NearMargin - layout.MarginOffset +
                        layout.MajorInterval / 2) - pt.Y) / (layout.MajorInterval * layout.MajorSpacing));

                    n += tick.Index;

                    if ((uint)n < QualitativeValues.Count)
                        value = QualitativeValues[n];
                    break;

                case ScaleType.Quantitative:
                    double dvalue = (Double)GetValueFromPoint(layout, pt);

                    if (DotPlotAxis == true && Math.Floor(layout.MajorSpacing) == layout.MajorSpacing)
                        dvalue = Math.Floor(dvalue + .5);

                    value = dvalue;
                    break;
            }

            return (GetCrosshairLabel(value, lstyle));
        }

        #endregion

        #region GetCrosshairBounds

        private Rectangle GetCrosshairBounds(Graphics g,
            string text, Point pt, CrosshairValueVisualStyle lstyle)
        {
            ChartXy chartXy = (ChartXy)Parent;

            AxisAlignment axisalignment = GetAxisAlignment();
            Rectangle r = GetScrollBounds(MajorTickmarks.LabelBounds);
            ChartXyVisualStyle cstyle = chartXy.EffectiveChartStyle;

            if (axisalignment == AxisAlignment.Far)
            {
                r.X -= cstyle.Padding.Left;
                r.Width += cstyle.Padding.Left;
            }
            else
            {
                r.Width += cstyle.Padding.Right;
            }

            SizeF sizef = g.MeasureString(text, lstyle.Font);

            int width = (int) sizef.Width + 2;

            if (Visible == true)
                width = Math.Min(r.Width, width);
            
            if (axisalignment == AxisAlignment.Far)
                r.X = Math.Max(r.X, r.Right - width);

            r.Width = width;

            r.Y = pt.Y - (int)(sizef.Height / 2) - 2 - lstyle.BorderThickness.Top;
            r.Height = (int)sizef.Height;

            if (lstyle.Margin.IsEmpty == false)
            {
                if (axisalignment == AxisAlignment.Near)
                    r.Y += lstyle.Margin.Top;
                else
                    r.Y -= lstyle.Margin.Bottom;
            }

            if (axisalignment == AxisAlignment.Near)
                r.X += (lstyle.BorderThickness.Horizontal);
            else
                r.X -= (lstyle.BorderThickness.Horizontal);

            r.Width += lstyle.BorderThickness.Horizontal;
            r.Height += lstyle.BorderThickness.Vertical;

            if (lstyle.Padding.IsEmpty == false)
            {
                if (axisalignment == AxisAlignment.Far)
                    r.Y -= lstyle.Padding.Vertical;

                r.Height += lstyle.Padding.Vertical;

                r.X -= lstyle.Padding.Left;
                r.Width += lstyle.Padding.Horizontal;
            }

            return (r);
        }

        #endregion

        #endregion

        #region RenderCrosshairLabel (CrosshairPoint)

        internal override void RenderCrosshairLabel(Graphics g, CrosshairPoint cp)
        {
            if ((DotPlotAxis == true) ||
                (cp.SeriesPoint.ValueY == null || cp.SeriesPoint.ValueY.Length == 0))
            {
                RenderCrosshairLabel(g, cp.Point);
            }
            else
            {
                CrosshairValueVisualStyle lstyle = EffectiveCrosshairLabelStyle;

                string text = (cp.ChartSeries.IsRotated == true)
                    ? GetCrosshairLabel(cp.SeriesPoint.ValueX, lstyle)
                    : GetCrosshairLabel(cp.SeriesPoint.ValueY[cp.ValueIndex], lstyle);

                if (string.IsNullOrEmpty(text) == false)
                {
                    Rectangle r = GetCrosshairBounds(g, text, cp.Point, lstyle);

                    lstyle.RenderBackground(g, r);
                    lstyle.RenderBorder(g, r);

                    if (lstyle.DropShadow.Enabled == Tbool.True)
                        lstyle.DropShadow.RenderDropShadow(g, r, true, true);

                    using (StringFormat sf = new StringFormat())
                    {
                        sf.Alignment = StringAlignment.Center;
                        sf.LineAlignment = StringAlignment.Center;

                        using (Brush br = new SolidBrush(lstyle.TextColor))
                            g.DrawString(text, lstyle.Font, br, r, sf);
                    }
                }
            }
        }

        #endregion

        #region RenderBackground

        internal override void RenderBackground(ChartRenderInfo renderInfo, Rectangle scContentBounds)
        {
            if (UseAlternateBackground == true)
            {
                if (TickmarkLayout.Ticks != null)
                {
                    Graphics g = renderInfo.Graphics;
                    ChartXy chartXy = Parent as ChartXy;

                    Point pt = chartXy.GetLocalAdjustedPoint(Point.Empty);

                    if (ScaleType == ScaleType.Qualitative)
                        pt.Y -= (int)(TickmarkLayout.MajorInterval / 2);

                    ChartAxisVisualStyle astyle = EffectiveAxisStyle;

                    if (astyle.AlternateBackground.IsSolidBrush == true)
                    {
                        using (Brush br = astyle.AlternateBackground.GetBrush(Rectangle.Empty))
                        {
                            RenderAltBackground(g,
                                scContentBounds, pt, TickmarkLayout, astyle, br);
                        }
                    }
                    else
                    {
                        RenderAltBackground(g,
                            scContentBounds, pt, TickmarkLayout, astyle, null);
                    }
                }
            }
        }

        #region RenderAltBackground

        private void RenderAltBackground(Graphics g, Rectangle scContentBounds,
            Point pt, TickmarkLayout TickmarkLayout, ChartAxisVisualStyle astyle, Brush br)
        {
            foreach (TickmarkTick tmi in TickmarkLayout.Ticks)
            {
                double value = GetTickmarkAltValue(tmi);
                int n = (int)(Math.Ceiling(value / TickmarkLayout.MajorSpacing));

                if (n % 2 == 0)
                {
                    Rectangle r = scContentBounds;
                    r.Y = tmi.TickPoint.Y + pt.Y;
                    r.Height = (int)TickmarkLayout.MajorInterval + 1;

                    if (br == null)
                    {
                        using (Brush br2 = astyle.AlternateBackground.GetBrush(r))
                            g.FillRectangle(br2, r);
                    }
                    else
                    {
                        g.FillRectangle(br, r);
                    }
                }
            }
        }

        #endregion

        #endregion

        #region RenderStripes

        internal override void RenderStripes(ChartRenderInfo renderInfo, Rectangle scContentBounds)
        {
            if (AxisStripes.Count > 0)
            {
                Graphics g = renderInfo.Graphics;
                ChartXy chartXy = Parent as ChartXy;

                Point pt = chartXy.GetLocalAdjustedPoint(Point.Empty);

                foreach (AxisStripe stripe in AxisStripes)
                {
                    if (stripe.IsDisplayed == true)
                    {
                        int y2 = chartXy.GetDataPointY(this, stripe.MinValue);
                        int y1 = chartXy.GetDataPointY(this, stripe.MaxValue);

                        Rectangle r = scContentBounds;
                        r.Y = (y1 + pt.Y);
                        r.Height = (y2 - y1) + 1;

                        RenderStripe(g, r, stripe);
                    }
                }
            }
        }

        #endregion

        #region UpdateRangeValues

        internal override void UpdateRangeValues(ChartXy chartXy)
        {
            bool seriesSeen = false;

            foreach (ChartSeries series in chartXy.ChartSeries)
            {
                if (series.AxisY == this)
                {
                    if (series.SeriesPoints.Count > 0)
                        UpdateRangeValuesEx(chartXy, series, ref seriesSeen);
                }
            }

            if (seriesSeen == false)
            {
                foreach (ChartSeries series in chartXy.ChartSeries)
                {
                    if (series.AxisY == null)
                    {
                        if (series.SeriesPoints.Count > 0)
                            UpdateRangeValuesEx(chartXy, series, ref seriesSeen);
                    }
                }
            }
        }

        #region UpdateRangeValuesEx

        private void UpdateRangeValuesEx(ChartXy chartXy, ChartSeries series, ref bool seriesSeen)
        {
            if (ActualMinValue == null)
            {
                ActualMinValue = series.MinValueY;
                ActualMaxValue = series.MaxValueY;
            }
            else
            {
                if (chartXy.DataCompare(series.MinValueY, ActualMinValue) < 0)
                    ActualMinValue = series.MinValueY;

                if (chartXy.DataCompare(series.MaxValueY, ActualMaxValue) > 0)
                    ActualMaxValue = series.MaxValueY;
            }

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

                ScaleType = series.ActualScaleTypeY;
            }
            else
            {
                if (series.ActualScaleTypeY != ScaleType)
                {
                    string s = "YAxis cannot contain series with differing ScaleTypes";

                    if (String.IsNullOrEmpty(Name) == false)
                        s += " (" + Name + ")";

                    throw new Exception(s);
                }
            }

            if (ScaleType == ScaleType.Qualitative)
            {
                if (series.IsRotated == true)
                {
                    foreach (object o in series.QualitativeXValues)
                    {
                        if (QualitativeValues.Contains(o) == false)
                            QualitativeValues.Add(o);
                    }
                }
                else
                {
                    foreach (object o in series.QualitativeYValues)
                    {
                        if (QualitativeValues.Contains(o) == false)
                            QualitativeValues.Add(o);
                    }
                }

                if (QualitativeValues.Count - 1 > (int)ActualMaxValue)
                    ActualMaxValue = QualitativeValues.Count - 1;
            }
        }

        #endregion

        #endregion

        #region GetValueFromPoint

        internal override object GetValueFromPoint(TickmarkLayout layout, Point pt)
        {
            pt = GetChartPoint(pt);

            TickmarkTick lastTick = null;

            foreach (TickmarkTick tick in layout.Ticks)
            {
                if (tick.TickPoint.Y == pt.Y)
                    return (Convert.ToDouble(tick.Value));

                if (tick.TickPoint.Y < pt.Y)
                {
                    if (lastTick != null)
                    {
                        double d = ((double)lastTick.TickPoint.Y - tick.TickPoint.Y) / (layout.MinorCount + 1);

                        for (int i = 1; i <= layout.MinorCount; i++)
                        {
                            int y = (int)(lastTick.TickPoint.Y - (d * i));

                            if (y == pt.Y)
                                return (Convert.ToDouble(lastTick.Value) + (layout.MajorSpacing / (layout.MinorCount + 1) * i));

                            if (y < pt.Y)
                                break;
                        }
                    }
                    break;
                }

                lastTick = tick;
            }

            int dy = Bounds.Bottom - pt.Y;

            switch (ScaleType)
            {
                case ScaleType.Qualitative:
                    return (layout.MajorSpacing * ((dy + layout.MarginOffset) / 
                        layout.MajorInterval) + (int)layout.BaseValue);

                case ScaleType.DateTime:
                    return (GetDateTimePointValue(layout, dy));

                default:
                    return (layout.MajorSpacing * ((dy + layout.MarginOffset) / 
                        layout.MajorInterval) + Convert.ToDouble(layout.BaseValue));
            }
        }

        #endregion

        #region GetPointFromValue

        /// <summary>
        /// Gets the chart Point from the given axis data value.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public override Point GetPointFromValue(object value)
        {
            return (new Point(0, GetDisplayValue(value)));
        }

        #endregion

        #region GetDisplayValue

        internal override int GetDisplayValue(object axisValue)
        {
            ChartXy chartXy = Parent as ChartXy;

            return (chartXy.GetDataPointY(this, axisValue));
        }

        #endregion

        #region EnsureVisible

        /// <summary>
        /// Ensures the given data value is visible and
        /// optionally centered on screen.
        /// </summary>
        /// <param name="value"></param>
        public override void EnsureVisible(object value, bool center)
        {
            ChartXy chartXy = Parent as ChartXy;

            if (chartXy != null)
            {
                if (chartXy.ChartControl != null)
                {
                    if (chartXy.ChartControl.LayoutValid == false)
                        chartXy.ChartControl.UpdateLayout();

                    Rectangle cbounds = chartXy.ContentBounds;

                    int y = GetDisplayValue(value);

                    if (center == true)
                    {
                        int n = cbounds.Y - (y - cbounds.Height / 2);

                        chartXy.VScrollOffset = n;
                    }
                    else
                    {
                        int n = cbounds.Y - chartXy.VScrollOffset + 20;

                        if (y < n)
                        {
                            chartXy.VScrollOffset += (n - y);
                        }
                        else
                        {
                            n = cbounds.Bottom - chartXy.VScrollOffset - 20;

                            if (y > n)
                                chartXy.VScrollOffset -= (y - n);
                        }
                    }
                }
            }
        }

        #endregion

        #region Copy/CopyTo

        /// <summary>
        /// Creates a copy of the axis.
        /// </summary>
        /// <returns></returns>
        public override ChartVisualElement Copy()
        {
            ChartAxisY copy = new ChartAxisY();

            CopyTo(copy);

            return (copy);
        }

        /// <summary>
        /// Copies each axis property to the given "copy".
        /// </summary>
        /// <param name="copy"></param>
        public override void CopyTo(ChartVisualElement copy)
        {
            ChartAxisY c = copy as ChartAxisY;

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

                MajorGridLines.CopyTo(c.MajorGridLines);
                MinorGridLines.CopyTo(c.MinorGridLines);

                MajorTickmarks.CopyTo(c.MajorTickmarks);
                MinorTickmarks.CopyTo(c.MinorTickmarks);
            }
        }

        #endregion

        #region GetSerialData

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

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

                sec.AddStartElement(serialName);
            }

            sec.AddElement(MajorGridLines.GetSerialData("MajorGridLines"));
            sec.AddElement(MinorGridLines.GetSerialData("MinorGridLines"));
            sec.AddElement(MajorTickmarks.GetSerialData("MajorTickmarks"));
            sec.AddElement(MinorTickmarks.GetSerialData("MinorTickmarks"));

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

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

            return (sec);
        }

        #endregion

        #region PutSerialData

        #region ProcessCollection

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

            switch (se.Name)
            {
                case "MajorGridLines":
                    sec.PutSerialData(MajorGridLines);
                    break;

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

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

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

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

        #endregion

        #endregion
    }

    #endregion

    #region ChartAxis

    [TypeConverter(typeof(BlankExpandableObjectConverter))]
    abstract public class ChartAxis : ChartVisualElement
    {
        #region Private variables

        private States _States;

        private AxisOrientation _AxisOrientation = AxisOrientation.X;
        private AxisAlignment _AxisAlignment = AxisAlignment.NotSet;
        private SortDirection _QualitativeSortDirection = SortDirection.None;

        private int _AxisMargins = -1;
        private int _AxisNearMargin = -1;
        private int _AxisFarMargin = -1;

        private AxisStripeCollection _AxisStripes;

        private object _MinValue = null;
        private object _MaxValue = null;

        private object _ActualMinValue;
        private object _ActualMaxValue;

        private double _GridSpacing;
        private double _GridInterval;
        private int _MinGridInterval = 10;

        private AxisTitle _Title;
        private ReferenceLineCollection _ReferenceLines;

        private TickmarkLayout _TickmarkLayout;
        private TickmarkLayout _LastTickmarkLayout;

        private Rectangle _AxisBounds;
        private Rectangle _AxisLineBounds;

        private ChartAxisVisualStyle _ChartAxisVisualStyle;
        private EffectiveStyle<ChartAxisVisualStyle> _EffectiveAxisStyle;

        private CrosshairValueVisualStyle _CrosshairLabelVisualStyle;
        private EffectiveStyle<CrosshairValueVisualStyle> _EffectiveCrosshairLabelStyle;

        private List<object> _QualitativeValues;
        private DateTimeUnits _DateTimeUnits = DateTimeUnits.Days;
        private DateTimeUnits _DateTimeUnitsLimit = DateTimeUnits.Years;
        private DateTimeUnits _ActualDateTimeUnits = DateTimeUnits.Days;

        private ScaleType _ScaleType;

        private AxisBar[] _AxisBars;
     
        #endregion

        #region Protected variables

        protected MajorTickmarks _MajorTickmarks;
        protected MinorTickmarks _MinorTickmarks;

        protected ChartMajorGridLines _MajorGridLines;
        protected ChartMinorGridLines _MinorGridLines;
        
        #endregion

        public ChartAxis(AxisOrientation orientation)
        {
            InitDefaultStates();

            _AxisOrientation = orientation;

            _EffectiveAxisStyle = new EffectiveStyle<ChartAxisVisualStyle>(this);
            _EffectiveCrosshairLabelStyle = new EffectiveStyle<CrosshairValueVisualStyle>(this);

            _AxisBars = new AxisBar[(int)AxisBarType.MaxBarCount];

            for (int i = 0; i < _AxisBars.Length; i++)
                _AxisBars[i] = new AxisBar();
        }

        #region InitDefaultStates

        private void InitDefaultStates()
        {
            SetState(States.AutoCalcBarMargins, true);
            SetState(States.SeriesRangeChanged, true);
            SetState(States.UseAutoMinGridInterval, true);
        }

        #endregion

        #region Public properties

        #region ActualDateTimeUnits

        /// <summary>
        /// Gets the actual axis display units for DateTime data (as determined by
        /// either the DateTimeUnits property or actual inspection of the associated data).
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public DateTimeUnits ActualDateTimeUnits
        {
            get { return (_ActualDateTimeUnits); }
            internal set { _ActualDateTimeUnits = value; }
        }

        #endregion

        #region ActualMaxValue

        /// <summary>
        /// Gets the actual, axis max data value (as determined by
        /// either the MaxValue property or actual inspection of the associated data).
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public object ActualMaxValue
        {
            get { return (_ActualMaxValue); }
            internal set { _ActualMaxValue = value; }
        }

        #endregion

        #region ActualMinValue

        /// <summary>
        /// Gets the actual, axis min data value (as determined by
        /// either the MinValue property or actual inspection of the associated data).
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public object ActualMinValue
        {
            get { return (_ActualMinValue); }
            internal set { _ActualMinValue = value; }
        }

        #endregion

        #region AutoCalcBarMargins

        /// <summary>
        /// Gets or sets whether axis Bar Margins are calculated and used.
        /// </summary>
        [DefaultValue(true), Category("Appearance")]
        [Description("Indicates whether axis Bar Margins are calculated and used.")]
        public bool AutoCalcBarMargins
        {
            get { return (TestState(States.AutoCalcBarMargins)); }

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

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

        #endregion

        #region AxisAlignment

        /// <summary>
        /// Gets or sets the axis alignment.
        /// </summary>
        [DefaultValue(AxisAlignment.NotSet), Category("Layout")]
        [Description("Indicates the axis alignment.")]
        public AxisAlignment AxisAlignment
        {
            get { return (_AxisAlignment); }

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

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

        #endregion

        #region AxisFarMargin

        ///<summary>
        /// Gets or sets the far/ending margin for the axis. When set ( >= 0 ), the
        /// value overrides the general AxisMargins setting.
        ///</summary>
        [DefaultValue(-1), Category("Layout")]
        [Description("Indicates the far/ending margin for the axis. When set ( >= 0 ), the value overrides the general AxisMargins setting.")]
        public int AxisFarMargin
        {
            get { return (_AxisFarMargin); }

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

                    OnPropertyChangedEx("AxisFarMargin", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region AxisMargins

        ///<summary>
        /// Gets or sets the near/beginning and far/ending pixel margins for the axis
        /// (ignored when set to < 0).
        ///</summary>
        [DefaultValue(-1), Category("Layout")]
        [Description("Indicates the near/beginning and far/ending margins for the axis (ignored when set to < 0).")]
        public int AxisMargins
        {
            get { return (_AxisMargins); }

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

                    OnPropertyChangedEx("AxisMargins", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region AxisNearMargin

        ///<summary>
        /// Gets or sets the near/beginning margin for the axis. When set ( >= 0 ), the
        /// value overrides the general AxisMargins setting.
        ///</summary>
        [DefaultValue(-1), Category("Layout")]
        [Description("Indicates the near/beginning margin for the axis. When set ( >= 0 ), the value overrides the general AxisMargins setting.")]
        public int AxisNearMargin
        {
            get { return (_AxisNearMargin); }

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

                    OnPropertyChangedEx("AxisNearMargin", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region AxisOrientation

        ///<summary>
        /// Gets the axis orientation (X/Y).
        ///</summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public AxisOrientation AxisOrientation
        {
            get { return (_AxisOrientation); }
        }

        #endregion

        #region AxisStripes

        /// <summary>
        /// Gets a reference to the collection of AxisStripes associated with the axis.
        /// </summary>
        [Category("Appearance")]
        [Description("Indicates the collection of AxisStripes associated with the axis.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public AxisStripeCollection AxisStripes
        {
            get
            {
                if (_AxisStripes == null)
                {
                    _AxisStripes = new AxisStripeCollection();

                    _AxisStripes.CollectionChanged += AxisStripeCollectionChanged;
                }

                return (_AxisStripes);
            }

            internal set
            {
                if (_AxisStripes != null)
                    _AxisStripes.CollectionChanged -= AxisStripeCollectionChanged;

                _AxisStripes = value;

                if (_AxisStripes != null)
                    _AxisStripes.CollectionChanged += AxisStripeCollectionChanged;
            }
        }

        #region AxisStripeCollectionChanged

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

                case NotifyCollectionChangedAction.Replace:
                    foreach (ChartElement item in e.OldItems)
                        item.Parent = null;

                    foreach (ChartElement item in e.NewItems)
                        item.Parent = this;
                    break;

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

            InvalidateLayout();
        }

        #endregion

        #endregion

        #region ChartAxisVisualStyle

        /// <summary>
        /// Gets or sets the visual style for the Axis.
        /// </summary>
        [Category("Style")]
        [Description("Indicates the visual style for the Axis.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ChartAxisVisualStyle ChartAxisVisualStyle
        {
            get
            {
                if (_ChartAxisVisualStyle == null)
                {
                    _ChartAxisVisualStyle = new ChartAxisVisualStyle();

                    StyleVisualChangeHandler(null, _ChartAxisVisualStyle);
                }

                return (_ChartAxisVisualStyle);
            }

            set
            {
                if (_ChartAxisVisualStyle != value)
                {
                    ChartAxisVisualStyle oldValue = _ChartAxisVisualStyle;

                    _ChartAxisVisualStyle = value;

                    OnStyleChanged("ChartAxisVisualStyle", oldValue, value);

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

        #endregion

        #region CrosshairLabelVisualStyle

        /// <summary>
        /// Gets or sets the visual style to be used for Crosshair elements associated with the axis.
        /// </summary>
        [Category("Style")]
        [Description("Indicates the visual style to be used for Crosshair elements associated with the axis.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public CrosshairValueVisualStyle CrosshairLabelVisualStyle
        {
            get
            {
                if (_CrosshairLabelVisualStyle == null)
                {
                    _CrosshairLabelVisualStyle = new CrosshairValueVisualStyle();

                    StyleVisualChangeHandler(null, _CrosshairLabelVisualStyle);
                }

                return (_CrosshairLabelVisualStyle);
            }

            set
            {
                if (_CrosshairLabelVisualStyle != value)
                {
                    CrosshairValueVisualStyle oldValue = _CrosshairLabelVisualStyle;
                    _CrosshairLabelVisualStyle = value;

                    OnStyleChanged("CrosshairLabelVisualStyle", oldValue, value);
                }
            }
        }

        #endregion

        #region DateTimeUnits

        /// <summary>
        /// Gets or sets the axis display units for DateTime data.
        /// </summary>
        [DefaultValue(DateTimeUnits.Days), Category("Data")]
        [Description("Indicates the axis display units for DateTime data.")]
        public DateTimeUnits DateTimeUnits
        {
            get { return (_DateTimeUnits); }

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

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

        #endregion

        #region DateTimeUnitsLimit

        /// <summary>
        /// Gets or sets the limiting axis display units for DateTime data (the
        /// max DateTime units the chart will, if needed, promote the display to).
        /// </summary>
        [DefaultValue(DateTimeUnits.Years), Category("Data")]
        [Description("Indicates the limiting axis display units for DateTime data (the max DateTime units the chart will, if needed, promote the display to).")]
        public DateTimeUnits DateTimeUnitsLimit
        {
            get { return (_DateTimeUnitsLimit); }

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

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

        #endregion

        #region EffectiveAxisStyle

        /// <summary>
        /// Gets a reference to the Axis' Effective (cached, composite) style.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ChartAxisVisualStyle EffectiveAxisStyle
        {
            get { return (_EffectiveAxisStyle.Style); }
        }

        #endregion

        #region EffectiveCrosshairLabelStyle

        /// <summary>
        /// Gets a reference to the CrosshairLabel's Effective (cached, composite) style.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public CrosshairValueVisualStyle EffectiveCrosshairLabelStyle
        {
            get { return (_EffectiveCrosshairLabelStyle.Style); }
        }

        #endregion

        #region GridInterval

        ///<summary>
        /// Gets or sets the grid interval (the distance between MajorTickmarks, in pixels)
        ///</summary>
        [Description("Indicates the grid interval (the distance between MajorTickmarks, in pixels).")]
        [DefaultValue(0.0d), Category("Layout")]
        public double GridInterval
        {
            get { return (_GridInterval); }

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

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

        #endregion

        #region GridSpacing

        ///<summary>
        /// Gets or sets the numerical spacing between MajorTickmarks (such as 1, 10, 100, ...).
        ///</summary>
        [Description("Indicates the numerical spacing between MajorTickmarks (such as 1, 10, 100, ...).")]
        [DefaultValue(0.0d), Category("Layout")]
        public double GridSpacing
        {
            get { return (_GridSpacing); }

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

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

        #endregion

        #region IsPrimaryAxis

        /// <summary>
        /// Gets whether the axis is the Primary axis.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsPrimaryAxis
        {
            get { return (TestState(States.PrimaryAxis)); }
            internal set { SetState(States.PrimaryAxis, value); }
        }

        #endregion

        #region MajorGridLines

        ///<summary>
        /// Gets the axis MajorGridLines element.
        ///</summary>
        [Description("Indicates the MajorGridLines element."), Category("Appearance")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public virtual ChartMajorGridLines MajorGridLines
        {
            get { return (_MajorGridLines); }
        }

        #endregion

        #region MajorTickmarks

        ///<summary>
        /// Gets the axis MajorTickmarks element.
        ///</summary>
        [Description("Indicates the MajorTickmarks element."), Category("Appearance")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public virtual MajorTickmarks MajorTickmarks
        {
            get { return (_MajorTickmarks); }
        }

        #endregion

        #region MaxValue

        ///<summary>
        /// Gets or sets the maximum axis data value.
        ///</summary>
        [DefaultValue(null), Category("Data")]
        [Description("Indicates the maximum axis data value.")]
        [TypeConverter("DevComponents.Charts.Design.PointValueConverter," +
            "DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
        public object MaxValue
        {
            get { return (_MaxValue); }

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

                    OnPropertyChangedEx("MaxValue", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region MinorGridLines

        ///<summary>
        /// Gets the axis MinorGridLines element.
        ///</summary>
        [Description("Indicates the MinorGridLines element."), Category("Appearance")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public virtual ChartMinorGridLines MinorGridLines
        {
            get { return (_MinorGridLines); }
        }

        #endregion

        #region MinGridInterval

        ///<summary>
        /// Gets or sets the minimum grid interval size. This is the distance (in pixels)
        /// between tickmark layout items.
        ///</summary>
        [DefaultValue(10), Category("Layout")]
        [Description("Indicates the minimum grid interval size. This is the distance (in pixels) between tickmark layout items.")]
        public int MinGridInterval
        {
            get { return (_MinGridInterval); }

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

                    OnPropertyChangedEx("MinGridInterval", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region MinorTickmarks

        ///<summary>
        /// Gets the axis MinorTickmarks element.
        ///</summary>
        [Description("Indicates the MinorTickmarks element."), Category("Appearance")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public virtual MinorTickmarks MinorTickmarks
        {
             get { return (_MinorTickmarks); }
        }

        #endregion

        #region MinValue

        ///<summary>
        /// Gets or sets the minimum axis data value.
        ///</summary>
        [DefaultValue(null), Category("Data")]
        [Description("Indicates the minimum axis data value.")]
        [TypeConverter("DevComponents.Charts.Design.PointValueConverter," +
            "DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
        public object MinValue
        {
            get { return (_MinValue); }

            set
            {
                if (value != _MinValue)
                {
                    _MinValue = value;
                        
                    OnPropertyChangedEx("MinValue", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region QualitativeSortDirection

        ///<summary>
        /// Gets or sets the sort direction for Qualitative axis values.
        ///</summary>
        [DefaultValue(SortDirection.None), Category("Data")]
        [Description("Indicates the sort direction for Qualitative axis values.")]
        public SortDirection QualitativeSortDirection
        {
            get { return (_QualitativeSortDirection); }

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

                    RefreshRangeValues();

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

        #endregion

        #region ReferenceLines

        /// <summary>
        /// Gets a reference to the collection of axis Reference Lines
        /// </summary>
        [Category("Appearance")]
        [Description("Indicates the collection of axis Reference Lines.")]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ReferenceLineCollection ReferenceLines
        {
            get
            {
                if (_ReferenceLines == null)
                {
                    _ReferenceLines = new ReferenceLineCollection();

                    _ReferenceLines.CollectionChanged += ReferenceLineCollectionChanged;
                }

                return (_ReferenceLines);
            }

            internal set
            {
                if (_ReferenceLines != null)
                    _ReferenceLines.CollectionChanged -= ReferenceLineCollectionChanged;

                _ReferenceLines = value;

                if (_ReferenceLines != null)
                    _ReferenceLines.CollectionChanged += ReferenceLineCollectionChanged;
            }
        }

        #region ReferenceLineCollectionChanged

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

                case NotifyCollectionChangedAction.Replace:
                    foreach (ChartElement item in e.OldItems)
                        item.Parent = null;

                    foreach (ChartElement item in e.NewItems)
                        item.Parent = this;
                    break;

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

            InvalidateRender();
        }

        #endregion

        #endregion

        #region Title

        ///<summary>
        /// Gets or sets the Axis Title.
        ///</summary>
        [Category("Layout")]
        [Description("Indicates the Axis Title.")]
        [TypeConverter(typeof(BlankExpandableObjectConverter))]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public AxisTitle Title
        {
            get
            {
                if (_Title == null)
                {
                    _Title = new AxisTitle();
                    _Title.Parent = this;
                }

                return (_Title);
            }

            set
            {
                if (value != _Title)
                {
                    _Title = value;
                    _Title.Parent = (value != null) ? this : null;

                    OnPropertyChangedEx("Title", Style.VisualChangeType.Layout);
                }
            }
        }

        #endregion

        #region UseAlternateBackground

        /// <summary>
        /// Gets or sets whether the axis utilizes the alternate background color.
        /// </summary>
        [DefaultValue(false), Category("Appearance")]
        [Description("Indicates whether the axis utilizes the alternate background color.")]
        public bool UseAlternateBackground
        {
            get { return (TestState(States.UseAlternateBackground)); }

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

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

        #endregion

        #region UseAutoMinGridInterval

        /// <summary>
        /// Gets or sets whether the auto-calculated minimum grid interval
        /// will be used in determining the axis major tickmark interval.
        /// </summary>
        [DefaultValue(true), Category("Appearance")]
        [Description("Indicates whether the auto-calculated minimum grid interval will be used in determining the axis major tickmark interval.")]
        public bool UseAutoMinGridInterval
        {
            get { return (TestState(States.UseAutoMinGridInterval)); }

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

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

        #endregion

        #endregion

        #region Internal properties

        #region AxisBars

        internal AxisBar[] AxisBars
        {
            get { return (_AxisBars); }
        }

        #endregion

        #region AxisBounds

        internal Rectangle AxisBounds
        {
            get { return (_AxisBounds); }
            set { _AxisBounds = value; }
        }

        #endregion

        #region AxisLineBounds

        internal Rectangle AxisLineBounds
        {
            get { return (_AxisLineBounds); }
            set { _AxisLineBounds = value; }
        }

        #endregion

        #region DotPlotAxis

        internal bool DotPlotAxis
        {
            get { return (TestState(States.DotPlotAxis)); }
            set { SetState(States.DotPlotAxis, value); }
        }

        #endregion

        #region EdgeAxis

        internal bool EdgeAxis
        {
            get { return (TestState(States.EdgeAxis)); }
            set { SetState(States.EdgeAxis, value); }
        }

        #endregion

        #region LastTickmarkLayout

        internal TickmarkLayout LastTickmarkLayout
        {
            get { return (_LastTickmarkLayout); }
            set { _LastTickmarkLayout = value; }
        }

        #endregion

        #region QualitativeValues

        internal List<object> QualitativeValues
        {
            get
            {
                if (_QualitativeValues == null)
                    _QualitativeValues = new List<object>();

                return (_QualitativeValues);
            }

            set { _QualitativeValues = value; }
        }

        #endregion

        #region ScaleType

        internal ScaleType ScaleType
        {
            get { return (_ScaleType); }
            set { _ScaleType = value; }
        }

        #endregion

        #region SeriesRangeChanged

        internal bool SeriesRangeChanged
        {
            get { return (TestState(States.SeriesRangeChanged)); }
            set { SetState(States.SeriesRangeChanged, value); }
        }

        #endregion

        #region TickmarkLayout

        internal TickmarkLayout TickmarkLayout
        {
            get { return(_TickmarkLayout); }
            set { _TickmarkLayout = value; }
        }

        #endregion

        #endregion

        #region MeasureOverride

        protected override void MeasureOverride(ChartLayoutInfo layoutInfo)
        {
            MeasureReferenceLines(layoutInfo);
        }

        protected void MeasureReferenceLines(ChartLayoutInfo layoutInfo)
        {
            Rectangle layoutBounds = layoutInfo.LayoutBounds;

            foreach (ReferenceLine line in ReferenceLines)
            {
                layoutInfo.LayoutBounds = BoundsRelative;

                line.Measure(layoutInfo);
            }

            layoutInfo.LayoutBounds = layoutBounds;
        }

        #endregion

        #region ArrangeOverride

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

            MajorTickmarks.Arrange(layoutInfo);
            MinorTickmarks.Arrange(layoutInfo);

            MajorGridLines.TickmarkLayout = TickmarkLayout;
            MinorGridLines.TickmarkLayout = TickmarkLayout;

            MajorGridLines.Arrange(layoutInfo);
            MinorGridLines.Arrange(layoutInfo);

            ArrangeReferenceLines(layoutInfo);
        }

        #region ArrangeReferenceLines

        private void ArrangeReferenceLines(ChartLayoutInfo layoutInfo)
        {
            Rectangle layoutBounds = layoutInfo.LayoutBounds;

            foreach (ReferenceLine line in ReferenceLines)
            {
                layoutInfo.LayoutBounds = BoundsRelative;

                line.Arrange(layoutInfo);
            }

            layoutInfo.LayoutBounds = layoutBounds;
        }

        #endregion

        #endregion

        #region RenderOverride

        protected override void RenderOverride(ChartRenderInfo renderInfo)
        {
            ChartAxisVisualStyle astyle = EffectiveAxisStyle;

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

        #endregion

        #region Render

        internal override void Render(ChartRenderInfo renderInfo)
        {
            if (Displayed == true)
            {
                Rectangle bounds = GetScrollBounds(AxisBounds);

                if (renderInfo.ClipRectangle.IntersectsWith(bounds))
                    RenderOverride(renderInfo);
            }
        }

        #endregion

        #region RenderCrosshairLabel

        internal virtual void RenderCrosshairLabel(Graphics g, Point pt)
        {
        }

        internal virtual void RenderCrosshairLabel(Graphics g, CrosshairPoint cp)
        {
        }

        #region GetCrosshairLabel

        internal string GetCrosshairLabel(object value, CrosshairValueVisualStyle lstyle)
        {
            string label = "";

            if (value != null)
            {
                TickmarkLabelVisualStyle tstyle = MajorTickmarks.EffectiveLabelStyle;

                try
                {
                    switch (ScaleType)
                    {
                        case ScaleType.DateTime:
                            DateTime dtvalue = (DateTime)value;

                            if (string.IsNullOrEmpty(lstyle.TextFormat) == false)
                                label = dtvalue.ToString(lstyle.TextFormat);

                            else if (string.IsNullOrEmpty(tstyle.TextFormat) == false)
                                label = dtvalue.ToString(tstyle.TextFormat);
                            else
                                label = GetDateTimeLabel(dtvalue);
                            break;

                        case ScaleType.Qualitative:
                            if (string.IsNullOrEmpty(lstyle.TextFormat) == false)
                                label = string.Format(lstyle.TextFormat, value);

                            else if (string.IsNullOrEmpty(tstyle.TextFormat) == false)
                                label = string.Format(tstyle.TextFormat, value);
                            else
                                label = value.ToString();
                            break;

                        default:
                            double d = Convert.ToDouble(value);

                            if (string.IsNullOrEmpty(lstyle.TextFormat) == false)
                                label = d.ToString(lstyle.TextFormat);

                            else if (string.IsNullOrEmpty(tstyle.TextFormat) == false)
                                label = d.ToString(tstyle.TextFormat);

                            else if (value is int)
                                label = ((int)value).ToString();

                            else
                                label = d.ToString("F6");

                            break;
                    }
                }
                catch
                {
                }
            }

            ChartControl chartControl = ChartControl;

            if (chartControl != null)
                chartControl.DoGetCrosshairAxisLabelEvent(this, value, ref label);

            return (label);
        }

        #endregion

        #endregion

        #region RenderBackground

        internal virtual void RenderBackground(
            ChartRenderInfo renderInfo, Rectangle scContentBounds)
        {
        }

        #endregion

        #region RenderStripes

        internal virtual void RenderStripes(
            ChartRenderInfo renderInfo, Rectangle scContentBounds)
        {
        }

        #endregion

        #region RenderStripe

        protected void RenderStripe(
            Graphics g, Rectangle bounds, AxisStripe stripe)
        {
            if (bounds.Width > 0 && bounds.Height > 0)
            {
                AxisStripeVisualStyle astyle = stripe.AxisStripeVisualStyle;

                if (astyle.Background.IsEmpty == true)
                {
                    g.FillRectangle(Brushes.LightPink, bounds);
                }
                else
                {
                    using (Brush br = astyle.Background.GetBrush(bounds))
                        g.FillRectangle(br, bounds);
                }
            }
        }

        #endregion

        #region CalcMajorSpacing

        protected void CalcMajorSpacing(ChartLayoutInfo layoutInfo, int width)
        {
            ChartXy chartXy = Parent as ChartXy;

            if (chartXy.DropShadowDisplayed == true)
                width -= 3;

            if (AxisOrientation == AxisOrientation.X)
            {
                if (chartXy.VScrollBar.Visible == true)
                    width -= chartXy.VScrollBar.Width;
            }
            else
            {
                if (chartXy.HScrollBar.Visible == true)
                    width -= chartXy.HScrollBar.Height;
            }

            TickmarkLayout layout = new TickmarkLayout();

            layout.MinValue = GetMinValue();
            layout.MaxValue = GetMaxValue();

            if (layout.MinValue != null && layout.MaxValue != null)
            {
                ScaleType scaleType = ScaleType;
                
                if (ScaleType == ScaleType.NotSet)
                    ScaleType = SeriesPoint.GetScaleType(layout.MinValue.GetType());

                layout.MinorCount = MinorTickmarks.TickmarkCount;

                if (ScaleType != ScaleType.NotSet)
                {
                    switch (ScaleType)
                    {
                        case ScaleType.DateTime:
                            CalcMajorDateTimeSpacing(chartXy, layout, width);
                            break;

                        case ScaleType.Qualitative:
                            CalcMajorQualitativeSpacing(layout, width);
                            break;

                        default:
                            CalcMajorQuantitativeSpacing(chartXy, layout, width);
                            break;
                    }
                }

                if (AxisOrientation == AxisOrientation.Y)
                {
                    if (chartXy.HScrollBar.Visible == true)
                        layout.MarginOffset -= chartXy.HScrollBarHeight;
                }
            }

            TickmarkLayout = layout;
        }

        #region CalcMajorDateTimeSpacing

        private void CalcMajorDateTimeSpacing(
            ChartXy chartXy, TickmarkLayout layout, int width)
        {
            DateTime dtMinValue = (DateTime)layout.MinValue;
            DateTime dtMaxValue = (DateTime)layout.MaxValue;

            DateTime odtMinValue = dtMinValue;

            if (width > 0 && dtMinValue < dtMaxValue)
            {
                DateTime ominValue = dtMinValue;

                width = SetLayoutMargin(layout, width) - 2;

                CalcDateTimeSpacing(chartXy, layout, dtMinValue, dtMaxValue, width);

                if (AutoCalcBarMargins == true)
                {
                    ChartSeries barSeries = GetBarSeries(chartXy);

                    if (barSeries != null)
                    {
                        if ((barSeries.IsRotated == false && AxisOrientation == AxisOrientation.X) ||
                            (barSeries.IsRotated == true && AxisOrientation == AxisOrientation.Y))
                        {
                            int n = (int)(width / layout.MajorCount / 2 / layout.MajorSpacing);

                            layout.NearMargin += n;
                            layout.FarMargin += n;

                            width -= (n * 2);

                            layout.MajorInterval = (double)width / layout.MajorCount;
                        }
                    }
                }
                else
                {
                    layout.MajorInterval = (double)width / layout.MajorCount;
                }

                if (UseAutoMinGridInterval == true)
                {
                    if (layout.MajorInterval <= 3)
                        layout.MajorInterval = 3;
                }

                dtMinValue = AdjustDateTimeBase(layout, dtMinValue);

                UpdateDateTimeMargins(layout, ref dtMinValue, ref dtMaxValue);

                double offset = GetDateTimeRange(ActualDateTimeUnits, dtMinValue, ominValue);

                int moff = (int)((layout.MajorInterval * offset) / layout.MajorSpacing - layout.NearMargin - 1);

                layout.MarginOffset = moff;

                layout.MinValue = dtMinValue;
                layout.MaxValue = dtMaxValue;
            }
        }

        #region AdjustDateTimeBase

        private DateTime AdjustDateTimeBase(TickmarkLayout layout, DateTime dtValue)
        {
            switch (ActualDateTimeUnits)
            {
                case DateTimeUnits.Milliseconds:
                    dtValue = dtValue.AddMilliseconds(-dtValue.Millisecond % layout.GridSpacing);
                    break;

                case DateTimeUnits.Seconds:
                    dtValue = new DateTime(dtValue.Year, dtValue.Month, dtValue.Day, dtValue.Hour, dtValue.Minute, dtValue.Second);
                    dtValue = dtValue.AddSeconds(-dtValue.Second % layout.GridSpacing);
                    break;

                case DateTimeUnits.Minutes:
                    dtValue = new DateTime(dtValue.Year, dtValue.Month, dtValue.Day, dtValue.Hour, dtValue.Minute, 0);
                    dtValue = dtValue.AddMinutes(-dtValue.Minute % layout.GridSpacing);
                    break;

                case DateTimeUnits.Hours:
                    dtValue = new DateTime(dtValue.Year, dtValue.Month, dtValue.Day, dtValue.Hour, 0, 0);
                    dtValue = dtValue.AddHours(-dtValue.Hour % layout.GridSpacing);
                    break;

                case DateTimeUnits.Days:
                    dtValue = new DateTime(dtValue.Year, dtValue.Month, dtValue.Day);
                    dtValue = dtValue.AddDays(-dtValue.Day % layout.GridSpacing);
                    break;

                case DateTimeUnits.Months:
                    dtValue = new DateTime(dtValue.Year, dtValue.Month, 1);
                    dtValue = dtValue.AddMonths(-(int)(dtValue.Month % layout.GridSpacing));
                    break;

                case DateTimeUnits.Years:
                    dtValue = new DateTime(dtValue.Year, 1, 1);
                    dtValue = dtValue.AddYears(-(int)(dtValue.Year % layout.GridSpacing));
                    break;

                default:
                    dtValue = dtValue.AddTicks(-(long)(dtValue.Millisecond % layout.GridSpacing));
                    break;
            }

            return (dtValue);
        }

        #endregion

        #region CalcDateTimeSpacing

        private void CalcDateTimeSpacing(ChartXy chartXy,
            TickmarkLayout layout, DateTime dtMinValue, DateTime dtMaxValue, int width)
        {
            DateTimeUnits adtu = DateTimeUnits;

            double range = GetDateTimeRange(adtu, dtMinValue, dtMaxValue);

            if (GridSpacing <= 0)
            {
                layout.GridSpacing = 1;
                layout.MajorSpacing = layout.GridSpacing;
            }
            else
            {
                layout.GridSpacing = GridSpacing;
                layout.MajorSpacing = layout.GridSpacing;
            }

            CalcDateTimeInterval(layout, range, width);

            double minorInterval = layout.MajorInterval / (MinorTickmarks.TickmarkCount + 1);

            if (minorInterval > 0)
            {
                ChartSeries barSeries = GetBarSeries(chartXy);

                while (minorInterval < MinGridInterval)
                {
                    if ((barSeries == null) && (int)adtu < (int)DateTimeUnitsLimit)
                    {
                        adtu = GetNextDateTimeUnit(adtu, dtMinValue, dtMaxValue);
                        range = GetDateTimeRange(adtu, dtMinValue, dtMaxValue);

                        CalcDateTimeInterval(layout, range, width);

                        minorInterval = layout.MajorInterval / (MinorTickmarks.TickmarkCount + 1);
                    }
                    else
                    {
                        if (GridSpacing > 0)
                            break;

                        minorInterval *= 2;
                        layout.MajorSpacing *= 2;
                    }
                }

                ActualDateTimeUnits = adtu;

                CalcDateTimeInterval(layout, range, width);
            }
        }

        #region CalcDateTimeInterval

        private void CalcDateTimeInterval(TickmarkLayout layout, double range, int width)
        {
            double d = range / layout.MajorSpacing;

            layout.MajorCount = (int)Math.Ceiling(d);
            layout.MajorInterval = (double)width / d;

            if (layout.MajorCount <= 0)
                layout.MajorCount = 1;
        }

        #endregion

        #region GetNextDateTimeUnit

        private DateTimeUnits GetNextDateTimeUnit(
            DateTimeUnits adtu, DateTime dtMinValue, DateTime dtMaxValue)
        {
            switch (adtu)
            {
                case DateTimeUnits.Ticks:
                    return (DateTimeUnits.Milliseconds);

                case DateTimeUnits.Milliseconds:
                    return (DateTimeUnits.Seconds);

                case DateTimeUnits.Seconds:
                    return (DateTimeUnits.Minutes);

                case DateTimeUnits.Minutes:
                    return (DateTimeUnits.Hours);

                case DateTimeUnits.Hours:
                    return (DateTimeUnits.Days);

                case DateTimeUnits.Days:
                    return (DateTimeUnits.Months);

                default:
                    return (DateTimeUnits.Years);
            }
        }

        #endregion

        #endregion

        #region AddDateTimeOffset

        private DateTime AddDateTimeOffset(DateTime dtValue, int offset)
        {
            switch (ActualDateTimeUnits)
            {
                case DateTimeUnits.Milliseconds:
                    dtValue = dtValue.AddMilliseconds(offset);
                    break;

                case DateTimeUnits.Seconds:
                    dtValue = dtValue.AddSeconds(offset);
                    break;

                case DateTimeUnits.Minutes:
                    dtValue = dtValue.AddMinutes(offset);
                    break;

                case DateTimeUnits.Hours:
                    dtValue = dtValue.AddHours(offset);
                    break;

                case DateTimeUnits.Days:
                    dtValue = dtValue.AddDays(offset);
                    break;

                case DateTimeUnits.Months:
                    dtValue = dtValue.AddMonths(offset);
                    break;

                case DateTimeUnits.Years:
                    dtValue = dtValue.AddYears(offset);
                    break;

                default:
                    dtValue = dtValue.AddTicks(offset);
                    break;
            }

            return (dtValue);
        }

        #endregion

        #region UpdateDateTimeMargins

        private void UpdateDateTimeMargins(
            TickmarkLayout layout, ref DateTime dtMinValue, ref DateTime dtMaxValue)
        {
            if (layout.NearMargin > 0)
            {
                int marginCount = (int)Math.Ceiling(layout.NearMargin / layout.MajorInterval);

                layout.MajorCount += marginCount;

                dtMinValue = AddDateTimeOffset(dtMinValue, -(int)(marginCount * 1)); //layout.MajorSpacing));
            }

            if (layout.FarMargin > 0)
            {
                int marginCount = (int)Math.Ceiling(layout.FarMargin / layout.MajorInterval);

                layout.MajorCount += marginCount;

                dtMaxValue = AddDateTimeOffset(dtMaxValue, (int)(marginCount * 1)); //layout.MajorSpacing));
            }
        }

        #endregion

        #region GetDateTimeRange

        private double GetDateTimeRange(
            DateTimeUnits dtu, DateTime dtMinValue, DateTime dtMaxValue)
        {
            TimeSpan ts = dtMaxValue - dtMinValue;

            switch (dtu)
            {
                case DateTimeUnits.Milliseconds:
                    return (ts.TotalMilliseconds);

                case DateTimeUnits.Seconds:
                    return (ts.TotalSeconds);

                case DateTimeUnits.Minutes:
                    return (ts.TotalMinutes);

                case DateTimeUnits.Hours:
                    return (ts.TotalHours);

                case DateTimeUnits.Days:
                    return (ts.TotalDays);

                case DateTimeUnits.Months:
                    return (CalcDateTimeMonths(dtMinValue, dtMaxValue));

                case DateTimeUnits.Years:
                    return (CalcDateTimeYears(dtMinValue, dtMaxValue));

                default:
                    return (dtMaxValue.Ticks - dtMinValue.Ticks);
            }
        }

        #region CalcDateTimeYears

        internal double CalcDateTimeYears(DateTime dtMinValue, DateTime dtMaxValue)
        {
            int years = dtMaxValue.Year - dtMinValue.Year;

            DateTime last = dtMinValue.AddYears(years);

            if (last > dtMaxValue)
            {
                last = last.AddYears(-1);
                years--;
            }

            DateTime next = last.AddYears(1);

            double yearDays = (next - last).Days;
            double days = (dtMaxValue - last).Days;

            return ((double)years + (days / yearDays));
        }

        #endregion

        #region CalcDateTimeMonths

        internal double CalcDateTimeMonths(DateTime dtMinValue, DateTime dtMaxValue)
        {
            // Rough estimation...

            TimeSpan ts = dtMaxValue - dtMinValue;

            return ((double)ts.Days / 30);
        }

        #endregion

        #endregion

        #endregion

        #region CalcMajorQuantitativeSpacing

        private void CalcMajorQuantitativeSpacing(
            ChartXy chartXy, TickmarkLayout layout, int width)
        {
            Type otype = layout.MinValue.GetType();

            double dminValue = Convert.ToDouble(layout.MinValue);
            double dmaxValue = Convert.ToDouble(layout.MaxValue);

            if (AutoCalcBarMargins == true)
            {
                ChartSeries barSeries = GetFullBarSeries(chartXy);

                if (barSeries != null)
                {
                    if (barSeries.IsRotated == true && AxisOrientation == AxisOrientation.X ||
                        barSeries.IsRotated == false && AxisOrientation == AxisOrientation.Y)
                    {
                        double origin = Convert.ToDouble((chartXy.BarOrigin ?? 0));

                        dminValue = Math.Min(origin, dminValue);
                    }
                }
            }

            double ominValue = dminValue;

            if (dminValue == dmaxValue)
                dmaxValue++;

            if (width > 0 && dminValue <= dmaxValue)
            {
                width = SetLayoutMargin(layout, width);

                double range = Math.Abs(dmaxValue - dminValue);

                CalcQuantitativeSpacing(chartXy, layout, range, width);

                if (UseAutoMinGridInterval == true)
                {
                    if (layout.MajorInterval < 3)
                        layout.MajorInterval = 3;
                }

                UpdateQuantitativeMargins(layout, otype, ref dminValue, ref dmaxValue);

                // Make sure zero is included on the axis

                int n = dminValue < 0 ? -1 : 1;

                if (dminValue < 0)
                    dminValue -= ((dminValue % layout.MajorSpacing) + layout.MajorSpacing);

                else if (dminValue > 0)
                    dminValue -= (dminValue % layout.MajorSpacing);

                int moff = 0;

                double delta = Math.Floor(Math.Abs(dminValue) / layout.MajorSpacing);
                double value = (int)delta * layout.MajorSpacing * n;
                double offset = Math.Abs(value - ominValue);

                moff = (int)((layout.MajorInterval * offset) / layout.MajorSpacing - layout.NearMargin);

                layout.MarginOffset = moff;

                layout.MinValue = Convert.ChangeType(dminValue, otype);
                layout.MaxValue = Convert.ChangeType(dmaxValue, otype);
            }
        }

        #region CalcQuantitativeSpacing

        void CalcQuantitativeSpacing(
            ChartXy chartXy, TickmarkLayout layout, double range, int width)
        {
            if (GridSpacing <= 0)
            {
                // User has not specified a spacing, so calculate it for them based
                // upon powers of 10 (10, 100, 1000, etc)
                // 
                // MajorSpacing is set to a multiple of the GridSpacing (based upon
                // the calculated minor tickmark interval)

                layout.GridSpacing = Math.Pow(10, Math.Floor(Math.Log10(range / 10)));

                if (layout.GridSpacing < 1)
                    layout.GridSpacing = 1;

                if (layout.MinValue is int)
                    layout.GridSpacing = Math.Ceiling(layout.GridSpacing);

                layout.MajorSpacing = layout.GridSpacing;

                layout.MajorCount = (int)Math.Ceiling(range / layout.MajorSpacing);
                layout.MajorInterval = (double)width / layout.MajorCount;
            }
            else
            {
                layout.GridSpacing = GridSpacing;
                layout.MajorSpacing = layout.GridSpacing;

                layout.MajorCount = (int)Math.Ceiling(range / layout.MajorSpacing);
                layout.MajorInterval = (double)width / layout.MajorCount;
            }

            double gridInterval = GridInterval;
            double pxp = (range < 1) ? width : ((double)width / range);

            ChartSeries dpSeries = GetChartDotPlotSeries(chartXy);

            if (dpSeries != null)
            {
                // Calculate the default dot plot spacing

                gridInterval = CalcDotPlotSpacing(
                    chartXy, layout, range, ref width, dpSeries);

                double count = range / layout.MajorSpacing;

                layout.MajorCount = (int)Math.Ceiling(count);

                pxp = (double)width / range;

                DotPlotAxis = true;
            }
            else
            {
                ChartSeries barSeries = GetBarSeries(chartXy);

                if (barSeries != null)
                {
                    if ((barSeries.IsRotated == false && AxisOrientation == AxisOrientation.X) ||
                        (barSeries.IsRotated == true && AxisOrientation == AxisOrientation.Y))
                    {
                        int n = (int)(pxp / 2) + 1;

                        layout.NearMargin += n;
                        layout.FarMargin += n;

                        width -= (n * 2);

                        layout.MajorInterval = (double)width / layout.MajorCount;

                        pxp = (double)width / (range);
                    }
                }

                double minorInterval = layout.MajorInterval / (MinorTickmarks.TickmarkCount + 1);

                if (minorInterval > 0)
                {
                    while (minorInterval < MinGridInterval)
                    {
                        minorInterval *= 2;
                        layout.MajorSpacing *= 2;
                    }
                }

                gridInterval = layout.MajorInterval;

                double dminValue = Convert.ToDouble(layout.MinValue);
                double dmaxValue = Convert.ToDouble(layout.MaxValue);

                double maxp = (int)(dmaxValue / layout.MajorSpacing) * layout.MajorSpacing;

                if (maxp < dmaxValue)
                    maxp += layout.MajorSpacing;

                double minp = (int)(dminValue / layout.MajorSpacing) * layout.MajorSpacing;

                if (minp > dminValue)
                    minp -= layout.MajorSpacing;

                layout.MajorCount = (int)Math.Ceiling((maxp - minp) / layout.MajorSpacing);

                layout.MinValue = minp;
                layout.MaxValue = maxp;

                DotPlotAxis = false;
            }

            if (GridInterval > 0)
            {
                layout.MajorInterval = GridInterval;
            }
            else
            {
                if (AxisCanExpand(dpSeries) == true)
                    gridInterval = Math.Max(gridInterval, pxp * layout.MajorSpacing);

                layout.MajorInterval = Math.Max(gridInterval, 1);
            }
        }

        #region GetChartDotPlotSeries

        private ChartSeries GetChartDotPlotSeries(ChartXy chartXy)
        {
            foreach (ChartSeries series in chartXy.ChartSeries)
            {
                if ((series.SeriesType == SeriesType.VerticalDot) ||
                    (series.SeriesType == SeriesType.HorizontalDot))
                {
                    return (series);
                }
            }

            return (null);
        }

        #endregion

        #region CalcDotPlotSpacing

        private double CalcDotPlotSpacing(ChartXy chartXy,
            TickmarkLayout layout, double range, ref int width, ChartSeries dpSeries)
        {
            // If we previously added a default margin, back it back out
            // since we are going to adjust the margin based upon the orientation
            // and size of the marker

            if (AxisMargins < 0)
            {
                width += ((layout.NearMargin * 2) - Dpi.Width10);
                layout.NearMargin = Dpi.Width5;
            }

            Size dotSize = chartXy.GetMaxDotPlotMarkerSize();
            DotPlotType dotTypes = chartXy.GetDotPlotTypes();

            return (AxisOrientation == AxisOrientation.X)
                ? CalcXDotPlotSpacing(chartXy, layout, range, ref width, dpSeries, dotTypes, dotSize)
                : CalcYDotPlotSpacing(chartXy, layout, range, ref width, dpSeries, dotTypes, dotSize);
        }

        #region CalcXDotPlotSpacing

        private double CalcXDotPlotSpacing(ChartXy chartXy, TickmarkLayout layout,
            double range, ref int width, ChartSeries dpSeries, DotPlotType dotTypes, Size dotSize)
        {
            if ((dotTypes & DotPlotType.Vertical) == DotPlotType.Vertical)
            {
                int n = dotSize.Width / 2;

                layout.NearMargin += n;
                width -= (n * 2);
            }

            layout.MajorSpacing = (GridSpacing <= 0) ? 1 : GridSpacing;

            double gridInterval = Math.Max(layout.MajorSpacing, 1) * dotSize.Width;

            if (MinGridInterval > 0)
            {
                while (gridInterval < Dpi.Width(MinGridInterval))
                {
                    gridInterval *= 2;
                    layout.MajorSpacing *= 2;
                }
            }

            Size size = chartXy.MinQualitativeSize;

            double count = range;

            if ((dotTypes & DotPlotType.Vertical) == DotPlotType.Vertical)
                count = range / dpSeries.DotPlotIndexValue;

            size.Width = (int)(dotSize.Width * count + layout.NearMargin * 2);

            if (chartXy.VScrollBar.Enabled == true)
                size.Width += chartXy.VScrollBar.Width;

            chartXy.MinQualitativeSize = size;

            return (gridInterval);
        }

        #endregion

        #region CalcYDotPlotSpacing

        private double CalcYDotPlotSpacing(ChartXy chartXy, TickmarkLayout layout,
            double range, ref int width, ChartSeries dpSeries, DotPlotType dotTypes, Size dotSize)
        {
            if ((dotTypes & DotPlotType.Horizontal) == DotPlotType.Horizontal)
            {
                int n = dotSize.Height / 2;

                layout.NearMargin += n;
                width -= (n * 2);
            }

            layout.MajorSpacing = (GridSpacing <= 0) ? 1 : GridSpacing;

            double gridInterval = layout.MajorSpacing * dotSize.Height;

            if (MinGridInterval > 0)
            {
                while (gridInterval < MinGridInterval)
                {
                    gridInterval *= 2;
                    layout.MajorSpacing *= 2;
                }
            }

            Size size = chartXy.MinQualitativeSize;

            double count = range;

            if ((dotTypes & DotPlotType.Horizontal) == DotPlotType.Horizontal)
                count = range / dpSeries.DotPlotIndexValue;

            size.Height = (int)(dotSize.Height * count + layout.NearMargin * 2);

            if (chartXy.HScrollBar.Enabled == true)
                size.Height += chartXy.HScrollBar.Height;

            chartXy.MinQualitativeSize = size;

            return (gridInterval);
        }

        #endregion

        #endregion

        #region AxisCanExpand

        private bool AxisCanExpand(ChartSeries dpSeries)
        {
            return ((dpSeries == null) ||
                    (AxisOrientation == AxisOrientation.X && dpSeries.SeriesType == SeriesType.VerticalDot) ||
                    (AxisOrientation == AxisOrientation.Y && dpSeries.SeriesType == SeriesType.HorizontalDot));
        }

        #endregion

        #endregion

        #region UpdateQuantitativeMargins

        private void UpdateQuantitativeMargins(
            TickmarkLayout layout, Type otype, ref double dminValue, ref double dmaxValue)
        {
            if (layout.NearMargin > 0)
            {
                int marginCount = (int)Math.Ceiling(layout.NearMargin / layout.MajorInterval);

                layout.MajorCount += marginCount;

                if (otype == typeof(Int32))
                {
                    if (dminValue - (marginCount * layout.MajorSpacing) > Int32.MinValue)
                        dminValue -= (marginCount * layout.MajorSpacing);
                }
                else
                {
                    dminValue -= (marginCount * layout.MajorSpacing);
                }
            }

            if (layout.FarMargin > 0)
            {
                int marginCount = (int)Math.Ceiling(layout.FarMargin / layout.MajorInterval);

                layout.MajorCount += marginCount;

                if (otype == typeof(Int32))
                {
                    if (dmaxValue + (marginCount * layout.MajorSpacing) < Int32.MaxValue)
                        dmaxValue += (marginCount * layout.MajorSpacing);
                }
                else
                {
                    dmaxValue += (marginCount * layout.MajorSpacing);
                }
            }
        }

        #endregion

        #endregion

        #region CalcMajorQualitativeSpacing

        private void CalcMajorQualitativeSpacing(TickmarkLayout layout, int width)
        {
            int iminValue = (int)layout.MinValue;
            int imaxValue = (int)layout.MaxValue;

            int ominValue = iminValue;

            if (width > 0 && iminValue <= imaxValue)
            {
                width = SetLayoutMargin(layout, width);

                double range = Math.Abs(imaxValue - iminValue) + 1;

                CalcQualitativeSpacing(layout, range, width);

                if (UseAutoMinGridInterval == true)
                {
                    if (layout.MajorInterval <= 3)
                        layout.MajorInterval = 3;
                }

                UpdateQualitativeMargins(layout, ref iminValue, ref imaxValue);

                // Make sure zero is included on the axis

                iminValue -= (int)(iminValue % layout.MajorSpacing);

                int moff = 0;

                int n = iminValue < 0 ? -1 : 1;

                double delta = Math.Floor(Math.Abs(iminValue) / layout.GridSpacing);
                double value = (int)delta * layout.GridSpacing * n;
                double offset = Math.Abs(value - ominValue);

                moff = (int)((layout.MajorInterval * offset) / layout.MajorSpacing - layout.NearMargin);

                layout.MarginOffset = moff;

                layout.MinValue = iminValue;
                layout.MaxValue = imaxValue;
            }
        }

        #region CalcQualitativeSpacing

        private void CalcQualitativeSpacing(
            TickmarkLayout layout, double range, int width)
        {
            ChartXy chartXy = Parent as ChartXy;

            layout.GridSpacing = 1;
            layout.MajorSpacing = layout.GridSpacing;

            layout.MajorCount = (int)range;
            layout.MajorInterval = (double)width / layout.MajorCount;

            if (layout.MinorCount > 0)
            {
                double minorInterval = layout.MajorInterval / (layout.MinorCount + 1);

                if (minorInterval > 0)
                {
                    while (minorInterval < MinGridInterval)
                    {
                        minorInterval *= 2;
                        layout.MinorCount /= 2;
                    }
                }
            }

            List<int> groupIds = GetSeriesGroupIds(chartXy);

            int colWidth = int.MinValue;

            foreach (int groupId in groupIds)
            {
                int n = chartXy.GetQualitativeColumnWidth(this, groupId);

                if (n > colWidth)
                    colWidth = n;
            }

            if (UseAutoMinGridInterval == false)
            {
                if (colWidth > layout.MajorInterval)
                    colWidth = (int)layout.MajorInterval;
            }

            if (colWidth < MinGridInterval)
                colWidth = MinGridInterval;

            int minWidth = colWidth * (layout.MajorCount);

            if (AxisOrientation == AxisOrientation.X)
            {
                if (chartXy.MinQualitativeSize.Width != minWidth)
                {
                    Size size = chartXy.MinQualitativeSize;
                    size.Width = minWidth + layout.NearMargin;
                    chartXy.MinQualitativeSize = size;

                    // Force a layout change when the next 
                    // layout invalidation arrives

                    LastTickmarkLayout = null;
                }
            }
            else
            {
                if (chartXy.MinQualitativeSize.Height != minWidth)
                {
                    Size size = chartXy.MinQualitativeSize;
                    size.Height = minWidth + layout.NearMargin;
                    chartXy.MinQualitativeSize = size;

                    LastTickmarkLayout = null;
                }
            }

            width += layout.NearMargin;
            minWidth = Math.Max(width, minWidth) - layout.NearMargin;

            layout.MajorInterval = (double)minWidth / layout.MajorCount;

            if (layout.MajorInterval < MinGridInterval)
            {
                layout.MajorInterval = MinGridInterval;

                minWidth = (int)(layout.MajorInterval * (layout.MajorCount - 0));
            }

            layout.MajorInterval = (double)minWidth / (layout.MajorCount - 0);

            foreach (int groupId in groupIds)
            {
                chartXy.AdjustQualitativeOffsets(this,
                    groupId, colWidth, (int)(layout.MajorInterval));
            }

            layout.NearMargin += (int)(layout.MajorInterval / 2);
        }

        #region GetSeriesGroupIds

        private List<int> GetSeriesGroupIds(ChartXy chartXy)
        {
            List<int> groupIds = new List<int>();

            foreach (ChartSeries series in chartXy.ChartSeries)
            {
                if (groupIds.Contains(series.GroupId) == false)
                    groupIds.Add(series.GroupId);
            }

            return (groupIds);
        }

        #endregion

        #endregion

        #region UpdateQualitativeMargins

        private void UpdateQualitativeMargins(
            TickmarkLayout layout, ref int iminValue, ref int imaxValue)
        {
            if (layout.NearMargin > 0)
            {
                int marginCount = (int)Math.Ceiling(layout.NearMargin / layout.MajorInterval);

                layout.MajorCount += marginCount;

                iminValue -= (int)(marginCount * layout.MajorSpacing);
            }

            if (layout.FarMargin > 0)
            {
                int marginCount = (int)Math.Ceiling(layout.FarMargin / layout.MajorInterval);

                layout.MajorCount += marginCount;

                imaxValue += (int)(marginCount * layout.MajorSpacing);
            }
        }

        #endregion

        #endregion

        #region SetLayoutMargin

        private int SetLayoutMargin(TickmarkLayout layout, int width)
        {
            layout.NearMargin = (AxisNearMargin >= 0) ? AxisNearMargin : AxisMargins >= 0 ? AxisMargins : 20;
            layout.FarMargin = (AxisFarMargin >= 0) ? AxisFarMargin : AxisMargins >= 0 ? AxisMargins : 20;

            layout.NearMargin = Dpi.Width(layout.NearMargin);
            layout.FarMargin = Dpi.Width(layout.FarMargin);

            layout.NearMargin = Math.Min(layout.NearMargin, width / 3);
            layout.FarMargin = Math.Min(layout.FarMargin, width / 3);

            if (layout.NearMargin > 0)
                width -= (layout.NearMargin + 1);

            if (layout.FarMargin > 0)
                width -= (layout.FarMargin + 1);

            return (width);
        }

        #endregion

        #region GetBarSeries

        private ChartSeries GetBarSeries(ChartXy chartXy)
        {
            foreach (ChartSeries series in chartXy.ChartSeries)
            {
                if (series.Visible == true)
                {
                    if (series.IsBarSeries == true)
                        return (series);
                }
            }

            return (null);
        }

        #endregion

        #region GetFullBarSeries

        private ChartSeries GetFullBarSeries(ChartXy chartXy)
        {
            foreach (ChartSeries series in chartXy.ChartSeries)
            {
                if (series.Visible == true)
                {
                    if (series.SeriesType == SeriesType.HorizontalBar ||
                        series.SeriesType == SeriesType.VerticalBar)
                    {
                        if (AxisOrientation == AxisOrientation.X)
                        {
                            if (series.AxisX == this || (series.AxisX == null && chartXy.AxisX == this))
                                return (series);
                        }
                        else
                        {
                            if (series.AxisY == this || (series.AxisY == null && chartXy.AxisY == this))
                                return (series);
                        }
                    }
                }
            }

            return (null);
        }

        #endregion

        #endregion

        #region GetMaxTickMarkLength

        protected int GetMaxTickMarkLength(bool inner)
        {
            int majorLength = MajorTickmarks.GetMaxTickmarkLength(this, inner);
            int minorLength = MinorTickmarks.GetMaxTickmarkLength(this, inner);

            int maxlen = Math.Max(majorLength, minorLength);

            return (maxlen);
        }

        #endregion

        #region GetAxisAlignment

        internal AxisAlignment GetAxisAlignment()
        {
            if (AxisAlignment == AxisAlignment.NotSet)
                return (IsPrimaryAxis ? AxisAlignment.Near : AxisAlignment.Far);

            return (AxisAlignment);
        }

        #endregion

        #region GetMinValue

        internal object GetMinValue()
        {
            UpdateRangeValues();

            if (MinValue != null)
            {
                if (ScaleType != ScaleType.NotSet)
                {
                    if (SeriesPoint.GetScaleType(MinValue.GetType()) != ScaleType)
                    {
                        if (IsDesignerHosted == false)
                            throw new Exception("MinValue ScaleType must match Axis ScaleType");

                        return (ActualMinValue);
                    }
                }

                return (MinValue);
            }

            return (ActualMinValue);
        }

        #endregion

        #region GetMaxValue

        internal object GetMaxValue()
        {
            UpdateRangeValues();

            if (MaxValue != null)
            {
                if (ScaleType != ScaleType.NotSet)
                {
                    if (SeriesPoint.GetScaleType(MaxValue.GetType()) != ScaleType)
                    {
                        if (IsDesignerHosted == false)
                            throw new Exception("MaxValue ScaleType must match Axis ScaleType");

                        return (ActualMaxValue);
                    }
                }

                return (MaxValue);
            }

            return (ActualMaxValue);
        }

        #endregion

        #region UpdateRangeValues

        internal void UpdateRangeValues()
        {
            if (SeriesRangeChanged == true)
            {
                SeriesRangeChanged = false;

                ActualMinValue = null;
                ActualMaxValue = null;

                QualitativeValues.Clear();

                ChartXy chartXy = Parent as ChartXy;

                if (chartXy != null)
                {
                    if (chartXy.ChartSeries.Count > 0)
                    {
                        UpdateRangeValues(chartXy);

                        if (QualitativeValues.Count > 1)
                        {
                            if (QualitativeSortDirection != SortDirection.None)
                            {
                                QualitativeValues.Sort(new 
                                    ObjComparer(this, QualitativeSortDirection == SortDirection.Ascending));
                            }
                        }
                    }
                }
            }
        }

        internal virtual void UpdateRangeValues(ChartXy chartXy)
        {
        }

        #region ObjComparer

        private class ObjComparer : IComparer<object>
        {
            private ChartVisualElement _ChartElement;
            private ChartControl _ChartControl;

            private bool _Ascending;

            public ObjComparer(ChartVisualElement chartElement, bool ascending)
            {
                _ChartElement = chartElement;
                _ChartControl = chartElement.ChartControl;

                _Ascending = ascending;
            }

            public int Compare(object v1, object v2)
            {
                int sval = 0;

                if (_ChartControl.DoCompareElementsEvent(_ChartElement, v1, v2, ref sval) == true)
                    return (sval);

                if (v1 is IComparable)
                {
                    sval = ((IComparable)v1).CompareTo(v2);

                    if (sval != 0)
                        return (_Ascending == true) ? sval : -sval;
                }

                return (sval);
            }
        }

        #endregion

        #endregion

        #region ValidateAxis

        internal bool ValidateAxis()
        {
            bool altered = false;

            if (LastTickmarkLayout == null || TickmarkLayout == null)
                altered = true;

            else if ((TickmarkLayout.MinValue != LastTickmarkLayout.MinValue) ||
                (TickmarkLayout.MaxValue != LastTickmarkLayout.MaxValue) ||
                (TickmarkLayout.MajorInterval != LastTickmarkLayout.MajorInterval) ||
                (TickmarkLayout.MajorSpacing != LastTickmarkLayout.MajorSpacing) ||
                (TickmarkLayout.MarginOffset != LastTickmarkLayout.MarginOffset))
            {
                altered = true;
            }

            LastTickmarkLayout = TickmarkLayout;

            return (altered);
        }

        #endregion

        #region GetChartPoint

        protected Point GetChartPoint(Point pt)
        {
            ChartXy chartXy = Parent as ChartXy;

            pt.X += ScrollOffset.X;
            pt.X -= (chartXy.HScrollBar.Inverted == true ? chartXy.HScrollOffset : -chartXy.HScrollOffset);

            pt.Y += ScrollOffset.Y;
            pt.Y -= (chartXy.VScrollBar.Inverted == true ? chartXy.VScrollOffset : -chartXy.VScrollOffset);

            return (pt);
        }

        #endregion

        #region GetDisplayValue

        virtual internal int GetDisplayValue(object axisValue)
        {
            return (0);
        }

        #endregion

        #region GetDateTime

        internal DateTime GetDateTime(DateTime dt, double delta)
        {
            switch (ActualDateTimeUnits)
            {
                case DateTimeUnits.Milliseconds:
                    return (dt.AddMilliseconds(delta));

                case DateTimeUnits.Seconds:
                    return (dt.AddSeconds(delta));

                case DateTimeUnits.Minutes:
                    return (dt.AddMinutes(delta));

                case DateTimeUnits.Hours:
                    return (dt.AddHours(delta));

                case DateTimeUnits.Days:
                    return (dt.AddDays(delta));

                case DateTimeUnits.Months:
                    dt = dt.AddMonths((int)delta);
                    dt = dt.AddDays((delta - (int)delta) * 31);

                    return (dt);

                case DateTimeUnits.Years:
                    return (dt.AddYears((int)delta));

                default:
                    return (dt.AddTicks((long)delta));
            }
        }

        #endregion

        #region GetDateTimeValue

        internal long GetDateTimeValue(DateTime dtValue)
        {
            switch (ActualDateTimeUnits)
            {
                case DateTimeUnits.Milliseconds:
                    return (dtValue.Millisecond);

                case DateTimeUnits.Seconds:
                    return (dtValue.Second);

                case DateTimeUnits.Minutes:
                    return (dtValue.Minute);

                case DateTimeUnits.Hours:
                    return (dtValue.Hour);

                case DateTimeUnits.Days:
                    return (dtValue.Day);

                case DateTimeUnits.Months:
                    return (dtValue.Month);

                case DateTimeUnits.Years:
                    return (dtValue.Year);

                default:
                    return (dtValue.Ticks);
            }
        }

        #endregion

        #region GetDateTimePointValue

        internal DateTime GetDateTimePointValue(TickmarkLayout layout, int dz)
        {
            double delta = (double)(layout.MajorSpacing * ((dz + layout.MarginOffset) / layout.MajorInterval));

            return (GetDateTime((DateTime)layout.BaseValue, delta));
        }

        #endregion

        #region GetDateTimeLabel

        internal string GetDateTimeLabel(DateTime dt)
        {
            switch (ActualDateTimeUnits)
            {
                case DateTimeUnits.Ticks:
                    return (dt.Ticks.ToString());

                case DateTimeUnits.Milliseconds:
                    return (dt.Millisecond.ToString());

                case DateTimeUnits.Seconds:
                    return (dt.Second.ToString());

                case DateTimeUnits.Minutes:
                    return (dt.Minute.ToString());

                case DateTimeUnits.Hours:
                    return (dt.ToShortTimeString());

                case DateTimeUnits.Days:
                    return (dt.ToShortDateString());

                case DateTimeUnits.Months:
                    return (dt.Month + "/" + dt.Year);

                default:
                    return (dt.Year.ToString());
            }
        }

        #endregion

        #region GetTickmarkAltValue

        internal double GetTickmarkAltValue(TickmarkTick tick)
        {
            switch (ScaleType)
            {
                case ScaleType.DateTime:
                    DateTime dt = AddDateTimeOffset((DateTime)tick.Value, (int)(TickmarkLayout.MajorSpacing / 2));

                    return (GetDateTimeValue(dt));

                case ScaleType.Qualitative:
                    return ((int)tick.Value + TickmarkLayout.MajorSpacing / 2);

                default:
                    return (Convert.ToDouble(tick.Value) + TickmarkLayout.MajorSpacing / 2);
            }
        }

        #endregion

        #region GetLegendData

        internal void GetLegendData(List<ChartLegendItem> legendData)
        {
            foreach (ReferenceLine line in ReferenceLines)
            {
                if (line.Visible == true)
                {
                    List<ChartLegendItem> items = line.GetLegendItems();

                    if (items != null && items.Count > 0)
                        legendData.AddRange(items);
                }
            }

            foreach (AxisStripe stripe in AxisStripes)
            {
                if (stripe.Visible == true)
                {
                    List<ChartLegendItem> items = stripe.GetLegendItems();

                    if (items != null && items.Count > 0)
                        legendData.AddRange(items);
                }
            }
        }

        #endregion

        #region GetPointFromValue

        /// <summary>
        /// Gets the chart Point from the given data value.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public virtual Point GetPointFromValue(object value)
        {
            return (Point.Empty);
        }

        #endregion

        #region GetValueFromPoint

        /// <summary>
        /// Gets the "Data" value from the given Chart Point.
        /// </summary>
        /// <param name="pt"></param>
        /// <returns></returns>
        public object GetValueFromPoint(Point pt)
        {
            TickmarkLayout layout = TickmarkLayout;

            return (GetValueFromPoint(layout, pt));
        }

        internal virtual object GetValueFromPoint(TickmarkLayout layout, Point pt)
        {
            return (null);
        }

        #endregion

        #region GetReferenceLineByName

        /// <summary>
        /// Gets the ReferenceLine from the given name.
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public ReferenceLine GetReferenceLineByName(string name)
        {
            if (String.IsNullOrEmpty(name) == true)
                return (null);

            if (_ReferenceLines != null)
            {
                foreach (ReferenceLine line in _ReferenceLines)
                {
                    if (name.Equals(line.Name) == true)
                        return (line);
                }
            }

            return (null);
        }

        #endregion

        #region GetStripeByName

        /// <summary>
        /// Gets the AxisStripe from the given name.
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public AxisStripe GetStripeByName(string name)
        {
            if (String.IsNullOrEmpty(name) == true)
                return (null);

            if (_AxisStripes != null)
            {
                foreach (AxisStripe stripe in _AxisStripes)
                {
                    if (name.Equals(stripe.Name) == true)
                        return (stripe);
                }
            }

            return (null);
        }

        #endregion

        #region EnsureVisible

        /// <summary>
        /// Ensures the given data value is visible on screen.
        /// </summary>
        /// <param name="value"></param>
        public void EnsureVisible(object value)
        {
            EnsureVisible(value, false);
        }

        /// <summary>
        /// Ensures the given data value is visible and
        /// optionally centered on screen.
        /// </summary>
        /// <param name="value"></param>
        public virtual void EnsureVisible(object value, bool center)
        {
        }

        #endregion

        #region Style Support

        #region ApplyStyles

        public override void ApplyStyles(BaseVisualStyle style)
        {
            ChartAxisVisualStyle astyle = style as ChartAxisVisualStyle;

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

                astyle.ApplyStyle(ChartAxisVisualStyle);
                astyle.ApplyDefaults();
            }
            else if (style is CrosshairValueVisualStyle)
            {
                CrosshairValueVisualStyle cstyle = (CrosshairValueVisualStyle)style;

                ApplyParentStyles(cstyle, Parent as ChartContainer);

                cstyle.ApplyStyle(CrosshairLabelVisualStyle);
                cstyle.ApplyDefaults();
            }
        }

        #region ApplyParentStyles (ChartAxisVisualStyle)

        private void ApplyParentStyles(
            ChartAxisVisualStyle astyle, ChartContainer item)
        {
            if (item != null)
            {
                ApplyParentStyles(astyle, item.Parent as ChartContainer);

                ChartPanel cp = item as ChartPanel;

                if (cp != null)
                {
                    if (_AxisOrientation == AxisOrientation.X)
                        astyle.ApplyStyle(cp.DefaultVisualStyles.ChartXAxisVisualStyle);
                    else
                        astyle.ApplyStyle(cp.DefaultVisualStyles.ChartYAxisVisualStyle);
                }
            }
            else
            {
                if (_AxisOrientation == AxisOrientation.X)
                {
                    astyle.ApplyStyle(ChartControl.BaseVisualStyles.ChartXAxisVisualStyle);
                    astyle.ApplyStyle(ChartControl.DefaultVisualStyles.ChartXAxisVisualStyle);
                }
                else
                {
                    astyle.ApplyStyle(ChartControl.BaseVisualStyles.ChartYAxisVisualStyle);
                    astyle.ApplyStyle(ChartControl.DefaultVisualStyles.ChartYAxisVisualStyle);
                }
            }
        }

        #endregion

        #region ApplyParentStyles (CrosshairLabelVisualStyle)

        private void ApplyParentStyles(
            CrosshairValueVisualStyle pstyle, ChartContainer item)
        {
            if (item != null)
            {
                ApplyParentStyles(pstyle, item.Parent as ChartContainer);

                if (item is ChartPanel)
                    pstyle.ApplyStyle(((ChartPanel)item).DefaultVisualStyles.CrosshairLabelVisualStyle);

                else if (item is ChartXy)
                    pstyle.ApplyStyle(((ChartXy)item).ChartCrosshair.CrosshairLabelVisualStyle);
            }
            else
            {
                pstyle.ApplyStyle(ChartControl.BaseVisualStyles.CrosshairLabelVisualStyle);
                pstyle.ApplyStyle(ChartControl.DefaultVisualStyles.CrosshairLabelVisualStyle);
            }
        }

        #endregion

        #endregion

        #region InvalidateStyle

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

        #endregion

        #region ClearEffectiveStyles

        protected override void ClearEffectiveStyles()
        {
            base.ClearEffectiveStyles();

            _EffectiveAxisStyle.InvalidateStyle();
        }

        #endregion

        #endregion

        #region InvalidateRender

        /// <summary>
        /// Invalidate the axis for rendering purposes.
        /// </summary>
        public override void InvalidateRender()
        {
            base.InvalidateRender();

            ChartXy chartXy = Parent as ChartXy;

            if (chartXy != null)
                chartXy.InvalidateRender();
        }

        #endregion

        #region RefreshRangeValues

        /// <summary>
        /// Causes an invalidation and refresh of the range values for the axis.
        /// </summary>
        public void RefreshRangeValues()
        {
            SeriesRangeChanged = true;

            InvalidateLayout();
        }

        #endregion

        #region Copy/CopyTo

        /// <summary>
        /// Copies the axis elements to the given "copy"
        /// </summary>
        /// <param name="copy"></param>
        public override void CopyTo(ChartVisualElement copy)
        {
            ChartAxis c = copy as ChartAxis;

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

                c.AxisAlignment = AxisAlignment;

                c.AxisFarMargin = AxisFarMargin;
                c.AxisMargins = AxisMargins;
                c.AxisNearMargin = AxisNearMargin;

                foreach (AxisStripe stripe in AxisStripes)
                    c.AxisStripes.Add((AxisStripe)stripe.Copy());

                c.ChartAxisVisualStyle = (_ChartAxisVisualStyle != null) ? ChartAxisVisualStyle.Copy() : null;
                c.CrosshairLabelVisualStyle = (_CrosshairLabelVisualStyle != null) ? CrosshairLabelVisualStyle.Copy() : null;

                c.DateTimeUnits = DateTimeUnits;
                c.GridInterval = GridInterval;
                c.GridSpacing = GridSpacing;

                c.MinGridInterval = MinGridInterval;

                c.MaxValue = MaxValue;
                c.MinValue = MinValue;

                foreach (ReferenceLine line in ReferenceLines)
                    c.ReferenceLines.Add((ReferenceLine)line.Copy());

                Title.CopyTo(c.Title);

                c.UseAlternateBackground = UseAlternateBackground;
            }
        }

        #endregion

        #region GetSerialData

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

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

                sec.AddStartElement(serialName);
            }

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

            sec.AddValue("AxisFarMargin", AxisFarMargin, -1);
            sec.AddValue("AxisMargins", AxisMargins, -1);
            sec.AddValue("AxisNearMargin", AxisNearMargin, -1);

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

                foreach (AxisStripe stripe in _AxisStripes)
                    sec.AddElement(stripe.GetSerialData(""));

                sec.AddEndElement("AxisStripes");
            }

            if (_ChartAxisVisualStyle != null && _ChartAxisVisualStyle.IsEmpty == false)
                sec.AddElement(_ChartAxisVisualStyle.GetSerialData("ChartAxisVisualStyle"));

            if (_CrosshairLabelVisualStyle != null && _CrosshairLabelVisualStyle.IsEmpty == false)
                sec.AddElement(_CrosshairLabelVisualStyle.GetSerialData("CrosshairLabelVisualStyle"));

            sec.AddValue("DateTimeUnits", DateTimeUnits, DateTimeUnits.Days);

            sec.AddValue("GridInterval", GridInterval, 0.0d);
            sec.AddValue("GridSpacing", GridSpacing, 0.0d);
            sec.AddValue("MinGridInterval", MinGridInterval, 10);

            sec.AddDataValue("MaxValue", MaxValue, null);
            sec.AddDataValue("MinValue", MinValue, null);

            sec.AddValue("QualitativeSortDirection", QualitativeSortDirection, SortDirection.None);

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

                foreach (ReferenceLine rline in _ReferenceLines)
                    sec.AddElement(rline.GetSerialData(""));

                sec.AddEndElement("ReferenceLines");
            }

            if (_Title != null)
                sec.AddElement(_Title.GetSerialData("Title"));

            sec.AddValue("UseAlternateBackground", UseAlternateBackground, false);

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

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

            return (sec);
        }

        #endregion

        #region PutSerialData

        #region ProcessValue

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

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

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

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

                case "DateTimeUnits":
                    DateTimeUnits = (DateTimeUnits)se.GetValueEnum(typeof(DateTimeUnits));
                    break;

                case "GridInterval":
                    GridInterval = double.Parse(se.StringValue);
                    break;

                case "GridSpacing":
                    GridSpacing = double.Parse(se.StringValue);
                    break;

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

                case "MaxValue":
                    MaxValue = se.DataValue;
                    break;

                case "MinValue":
                    MinValue = se.DataValue;
                    break;

                case "QualitativeSortDirection":
                    QualitativeSortDirection = (SortDirection)se.GetValueEnum(typeof(SortDirection));
                    break;

                case "UseAlternateBackground":
                    UseAlternateBackground = 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 "AxisStripes":
                case "ReferenceLines":
                    sec.PutSerialData(this);
                    break;

                case "AxisStripe":
                    AxisStripe stripe = GetStripeByName(se.Name);

                    if (stripe != null)
                        sec.PutSerialData(stripe);
                    break;

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

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

                case "ReferenceLine":
                    ReferenceLine line = GetReferenceLineByName(se.Name);

                    if (line != null)
                        sec.PutSerialData(line);
                    break;

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

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

        #endregion

        #endregion

        #region States

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

            DotPlotAxis = (1U << 1),
            EdgeAxis = (1U << 2),
            PrimaryAxis = (1U << 3),

            SeriesRangeChanged = (1U << 4),

            UseAlternateBackground = (1U << 5),
            UseAutoMinGridInterval = (1U << 6),
        }

        #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 ToString

        public override string ToString()
        {
            if (String.IsNullOrEmpty(Name) == false)
                return (Name);

            return (base.ToString());
        }

        #endregion

        #region IDisposable

        public override void Dispose()
        {
            AxisStripes = null;
            ChartAxisVisualStyle = null;
            CrosshairLabelVisualStyle = null;
            ReferenceLines = null;
            Title = null;

            base.Dispose();
        }

        #endregion
    }

    #endregion

    #region TickmarkLayout

    internal class TickmarkLayout
    {
        public object MinValue;
        public object MaxValue;

        public object BaseValue;

        public int NearMargin;
        public int FarMargin;
        public int MarginOffset;

        public int MajorCount;
        public int MinorCount;

        public double GridSpacing;
        public double MajorSpacing;
        public double MajorInterval;

        public int TickmarkStart;
        public int TickmarkEnd;

        public TickmarkTick[] Ticks;
    }

    #endregion

    #region TickmarkTick

    internal class TickmarkTick
    {
        public int Index;
        public object Value;
        public Point TickPoint;

        public string Label;
        public Size LabelSize;
        public Point LabelPoint;
        public int LabelIndex;
        public Color LabelColor;

        public SizeF TextSize;

        public bool LabelVisible;
    }

    #endregion

    #region AxisBar

    internal class AxisBar
    {
        public int BarCount;
        public int BarOffset;
        public int BarTotalWidth;

        public double BarTotal;

        public void Reset()
        {
            BarCount = 0;
            BarTotal = 0;
            BarTotalWidth = 0;

            BarOffset = int.MinValue;
        }
    }

    #endregion

    public class AxisTitle : ChartTitle
    {
        #region XyAlignment

        [Browsable(false)]
        [Bindable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new XyAlignment XyAlignment
        {
            get { return (base.XyAlignment); }
            set { base.XyAlignment = value; }
        }

        #endregion
    }

    [Obsolete]
    public class AsixTitle : AxisTitle
    {
    }

    #region Enums

    #region AxisAlignment

    public enum AxisAlignment
    {
        /// <summary>
        /// Default is determined by the Axis (X/Y).
        /// </summary>
        NotSet = -1,

        /// <summary>
        /// Axis is displayed at the right or bottom side of the chart.
        /// </summary>
        Near,

        /// <summary>
        /// Axis is displayed at the left or top side of the chart.
        /// </summary>
        Far,
    }

    #endregion

    #region AxisBarType

    internal enum AxisBarType
    {
        Bar,
        HiLoBar,

        MaxBarCount
    }

    #endregion

    #region AxisOrientation

    /// <summary>
    /// AxisOrientation.
    /// </summary>
    public enum AxisOrientation
    {
        /// <summary>
        /// X Axis
        /// </summary>
        X,

        /// <summary>
        /// Y Axis
        /// </summary>
        Y,
    }

    #endregion

    #region DateTimeUnits

    /// <summary>
    /// DateTimeUnits
    /// </summary>
    public enum DateTimeUnits
    {
        Ticks,
        Milliseconds,
        Seconds,
        Minutes,
        Hours,
        Days,
        Months,
        Years,
    }

    #endregion

    #region MarginLayout

    public enum MarginLayout
    {
        /// <summary>
        /// No Margins will be displayed.
        /// </summary>
        None,

        /// <summary>
        /// Margin is displayed at the right or bottom side of the axis.
        /// </summary>
        Near,

        /// <summary>
        /// Margin is displayed at the left or top side of the axis.
        /// </summary>
        Far,

        /// <summary>
        /// Both Near and Far margins are displayed.
        /// </summary>
        Both,
    }

    #endregion

    #region OriginOffsetMode

    /// <summary>
    /// Mode for setting the axis origin, or offset from its
    /// normal position.
    /// </summary>
    public enum OriginOffsetMode
    {
        /// <summary>
        /// No offset
        /// </summary>
        None,

        /// <summary>
        /// Origin is shifted by an absolute amount (OriginOffset)
        /// </summary>
        Absolute,

        /// <summary>
        /// Origin is shifted relative to the major scale amounts.
        /// </summary>
        Relative,

        /// <summary>
        /// Origin is shifted a percentage of the total axis length.
        /// </summary>
        Percent,
    }

    #endregion

    #region OverlapLabelMode

    public enum OverlapLabelMode
    {
        /// <summary>
        /// Default is to Hide overlapping labels.
        /// </summary>
        NotSet = 0,

        /// <summary>
        /// Overlapping labels will be staggered.
        /// </summary>
        Stagger,

        /// <summary>
        /// Overlapping labels may be hidden.
        /// </summary>
        Hide,
    }

    #endregion

    #endregion
}