//-------------------------------------------------------------
// <copyright company=’Microsoft Corporation’>
//   Copyright © Microsoft Corporation. All Rights Reserved.
// </copyright>
//-------------------------------------------------------------
// @owner=alexgor, deliant
//=================================================================
//  File:		AxisScaleSegments.cs
//
//  Namespace:	System.Web.UI.WebControls[Windows.Forms].Charting
//
//	Classes:	AxisScaleSegment, AxisScaleSegmentCollection
//
//  Purpose:	
//
//	Reviewed:	
//
//===================================================================

#region Used namespaces

using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Data;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.Globalization;
#if Microsoft_CONTROL

	using System.Windows.Forms.DataVisualization.Charting.Data;
	using System.Windows.Forms.DataVisualization.Charting.ChartTypes;
	using System.Windows.Forms.DataVisualization.Charting.Utilities;
	using System.Windows.Forms.DataVisualization.Charting.Borders3D;
	using System.Windows.Forms.DataVisualization.Charting;

#else
	using System.Web;
	using System.Web.UI;
	using System.Web.UI.DataVisualization.Charting;
	using System.Web.UI.DataVisualization.Charting.Data;
	using System.Web.UI.DataVisualization.Charting.ChartTypes;
	using System.Web.UI.DataVisualization.Charting.Utilities;
#endif

#endregion

#if Microsoft_CONTROL
	namespace System.Windows.Forms.DataVisualization.Charting
#else
namespace System.Web.UI.DataVisualization.Charting

#endif
{
	/// <summary>
	/// <b>AxisScaleSegment</b> class represents a single segment of the axis with
	/// it's own scale and intervals.
	/// </summary>
	[
	SRDescription("DescriptionAttributeAxisScaleSegment_AxisScaleSegment"),
	]
     internal class AxisScaleSegment
	{
		#region Fields

		// Associated axis
		internal Axis axis = null;

		// Axis segment position in percent of the axis size
		private double _position = 0.0;

		// Axis segment size in percent of the axis size
		private double _size = 0.0;

		// Axis segment spacing in percent of the axis size
		private double _spacing = 0.0;

		// Axis segment scale minimum value
		private double _scaleMinimum = 0.0;

		// Axis segment scale maximum value
		private double _scaleMaximum = 0.0;

		// Axis segment interval offset.
		private double _intervalOffset = 0;

		// Axis segment interval.
		private double _interval = 0;

		// Axis segment interval units type.
		private DateTimeIntervalType _intervalType = DateTimeIntervalType.Auto;

		// Axis segment interval offset units type.
		private DateTimeIntervalType _intervalOffsetType = DateTimeIntervalType.Auto;

		// Object associated with the segment
		private object _tag = null;

		// Stack used to save/load axis settings
		private Stack	_oldAxisSettings = new Stack();

		#endregion // Fields

		#region Constructor

		/// <summary>
		/// Default object constructor.
		/// </summary>
		public AxisScaleSegment()
		{
		}

		#endregion // Constructor

		#region Properties

		/// <summary>
		/// Axis segment position in axis size percentage.
		/// </summary>
		[
		SRCategory("CategoryAttributeMisc"),
		DefaultValue(0.0),
		SRDescription("DescriptionAttributeAxisScaleSegment_Position"),
		]
		public double Position
		{
			get
			{
				return this._position;
			}
			set
			{
				if(value < 0.0 || value > 100.0)
				{
                    throw (new ArgumentOutOfRangeException("value", SR.ExceptionAxisScaleSegmentsPositionInvalid));
				}
				this._position = value;
			}
		}

		/// <summary>
		/// Axis segment size in axis size percentage.
		/// </summary>
		[
		SRCategory("CategoryAttributeMisc"),
		DefaultValue(0.0),
		SRDescription("DescriptionAttributeAxisScaleSegment_Size"),
		]
		public double Size
		{
			get
			{
				return this._size;
			}
			set
			{
				if(value < 0.0 || value > 100.0)
				{
                    throw (new ArgumentOutOfRangeException("value", SR.ExceptionAxisScaleSegmentsSizeInvalid));
					}
				this._size = value;
			}
		}

		/// <summary>
		/// Axis segment spacing in axis size percentage.
		/// </summary>
		[
		SRCategory("CategoryAttributeMisc"),
		DefaultValue(0.0),
		SRDescription("DescriptionAttributeAxisScaleSegment_Spacing"),
		]
		public double Spacing
		{
			get
			{
				return this._spacing;
			}
			set
			{
				if(value < 0.0 || value > 100.0)
				{
                    throw (new ArgumentOutOfRangeException("value", SR.ExceptionAxisScaleSegmentsSpacingInvalid));
				}
				this._spacing = value;
			}
		}

		/// <summary>
		/// Axis segment scale maximum value.
		/// </summary>
		[
		SRCategory("CategoryAttributeMisc"),
		DefaultValue(0.0),
		SRDescription("DescriptionAttributeAxisScaleSegment_ScaleMaximum"),
		]
		public double ScaleMaximum
		{
			get
			{
				return this._scaleMaximum;
			}
			set
			{
				this._scaleMaximum = value;
			}
		}

		/// <summary>
		/// Axis segment scale minimum value.
		/// </summary>
		[
		SRCategory("CategoryAttributeMisc"),
		DefaultValue(0.0),
		SRDescription("DescriptionAttributeAxisScaleSegment_ScaleMinimum"),
		]
		public double ScaleMinimum
		{
			get
			{
				return this._scaleMinimum;
			}
			set
			{
				this._scaleMinimum = value;
			}
		}


		/// <summary>
		/// Axis segment interval size.
		/// </summary>
		[
		SRCategory("CategoryAttributeInterval"),
		DefaultValue(0.0),
		SRDescription("DescriptionAttributeAxisScaleSegment_Interval"),
		TypeConverter(typeof(AxisIntervalValueConverter)),
		]
		public double Interval
		{
			get
			{
				return this._interval;
			}
			set
			{
				// Axis interval properties must be set
				if(double.IsNaN(value))
				{
					this._interval = 0;
				}
				else
				{
					this._interval = value;
				}
			}
		}

		/// <summary>
		/// Axis segment interval offset.
		/// </summary>
		[
		SRCategory("CategoryAttributeInterval"),
		DefaultValue(0.0),
		SRDescription("DescriptionAttributeAxisScaleSegment_IntervalOffset"),
		TypeConverter(typeof(AxisIntervalValueConverter))
		]
		public double IntervalOffset
		{
			get
			{
				return _intervalOffset;
			}
		}

		/// <summary>
		/// Axis segment interval type.
		/// </summary>
		[
		SRCategory("CategoryAttributeInterval"),
		DefaultValue(DateTimeIntervalType.Auto),
		SRDescription("DescriptionAttributeAxisScaleSegment_IntervalType"),
		]
		public DateTimeIntervalType IntervalType
		{
			get
			{
				return this._intervalType;
			}
			set
			{
				// Axis interval properties must be set
				if(value == DateTimeIntervalType.NotSet)
				{
					this._intervalType = DateTimeIntervalType.Auto;
				}
				else
				{
					_intervalType = value;
				}
			}
		}

		/// <summary>
		/// Axis segment interval offset type.
		/// </summary>
		[
		SRCategory("CategoryAttributeInterval"),
		DefaultValue(DateTimeIntervalType.Auto),
		SRDescription("DescriptionAttributeAxisScaleSegment_IntervalOffsetType"),
		]
		public DateTimeIntervalType IntervalOffsetType
		{
			get
			{
				return this._intervalOffsetType;
			}
		}

		/// <summary>
		/// Object associated with axis scale segment.
		/// </summary>
		[
		SRCategory("CategoryAttributeMisc"),
		Browsable(false),
		DefaultValue(null),
		SRDescription("DescriptionAttributeAxisScaleSegment_Tag"),
		DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
		SerializationVisibility(SerializationVisibility.Hidden),
		]
		public object Tag
		{
			get
			{
				return this._tag;
			}
			set
			{
				this._tag = value;
			}
		}

		#endregion // Properties

		#region Break Line Painting Methods

        /// <summary>
        /// Paints the axis break line.
        /// </summary>
        /// <param name="graph">Chart graphics to use.</param>
        /// <param name="nextSegment">Axis scale segment next to current.</param>
		internal void PaintBreakLine(ChartGraphics graph, AxisScaleSegment nextSegment)
		{
			// Get break line position 
			RectangleF breakPosition = this.GetBreakLinePosition(graph, nextSegment);

			// Get top line graphics path
			GraphicsPath breakLinePathTop = this.GetBreakLinePath(breakPosition, true);
			GraphicsPath breakLinePathBottom = null;

			// Clear break line space using chart color behind the area
			if(breakPosition.Width > 0f && breakPosition.Height > 0f)
			{
				// Get bottom line graphics path
				breakLinePathBottom = this.GetBreakLinePath(breakPosition, false);

				// Clear plotting area background
				using(GraphicsPath fillPath = new GraphicsPath())
				{
					// Create fill path out of top and bottom break lines
					fillPath.AddPath(breakLinePathTop, true);
					fillPath.Reverse();
					fillPath.AddPath(breakLinePathBottom, true);
					fillPath.CloseAllFigures();

					// Use chart back color to fill the area
					using(Brush fillBrush = this.GetChartFillBrush(graph))
					{
						graph.FillPath(fillBrush, fillPath);

						// Check if shadow exsits in chart area
						if( this.axis.ChartArea.ShadowOffset != 0 && !this.axis.ChartArea.ShadowColor.IsEmpty)
						{
							// Clear shadow
							RectangleF shadowPartRect = breakPosition;
							if( this.axis.AxisPosition == AxisPosition.Right || this.axis.AxisPosition == AxisPosition.Left )
							{
								shadowPartRect.Y += this.axis.ChartArea.ShadowOffset;
								shadowPartRect.Height -= this.axis.ChartArea.ShadowOffset;
								shadowPartRect.X = shadowPartRect.Right - 1;
								shadowPartRect.Width = this.axis.ChartArea.ShadowOffset + 2;
							}
							else
							{
								shadowPartRect.X += this.axis.ChartArea.ShadowOffset;
								shadowPartRect.Width -= this.axis.ChartArea.ShadowOffset;
								shadowPartRect.Y = shadowPartRect.Bottom - 1;
								shadowPartRect.Height = this.axis.ChartArea.ShadowOffset + 2;
							}
							graph.FillRectangle(fillBrush, shadowPartRect);

							// Draw new shadow
							using(GraphicsPath shadowPath = new GraphicsPath())
							{
								shadowPath.AddPath(breakLinePathTop, false);

								// Define maximum size
								float size = this.axis.ChartArea.ShadowOffset;
								if( this.axis.AxisPosition == AxisPosition.Right || this.axis.AxisPosition == AxisPosition.Left )
								{
									size = Math.Min(size, breakPosition.Height);
								}
								else
								{
									size = Math.Min(size, breakPosition.Width);
								}

								// Define step to increase transperancy
								int transparencyStep = (int)(this.axis.ChartArea.ShadowColor.A / size);

								// Set clip region to achieve spacing of the shadow
								// Start with the plotting rectangle position
								RectangleF clipRegion = graph.GetAbsoluteRectangle(this.axis.PlotAreaPosition.ToRectangleF());
								if( this.axis.AxisPosition == AxisPosition.Right || this.axis.AxisPosition == AxisPosition.Left )
								{
									clipRegion.X += this.axis.ChartArea.ShadowOffset;
									clipRegion.Width += this.axis.ChartArea.ShadowOffset;
								}
								else
								{
									clipRegion.Y += this.axis.ChartArea.ShadowOffset;
									clipRegion.Height += this.axis.ChartArea.ShadowOffset;
								}
								graph.SetClip(graph.GetRelativeRectangle(clipRegion));

								// Draw several lines to form shadow
								for(int index = 0; index < size; index ++)
								{
									using(Matrix newMatrix = new Matrix())
									{
										// Shift top break line by 1 pixel
										if( this.axis.AxisPosition == AxisPosition.Right || this.axis.AxisPosition == AxisPosition.Left )
										{
											newMatrix.Translate(0f, 1f);
										}
										else
										{
											newMatrix.Translate(1f, 0f);
										}
										shadowPath.Transform(newMatrix);
									}

									// Get line color
									Color color = Color.FromArgb(
										this.axis.ChartArea.ShadowColor.A - transparencyStep * index, 
										this.axis.ChartArea.ShadowColor);

									using(Pen shadowPen = new Pen(color, 1))
									{
										// Draw shadow
										graph.DrawPath(shadowPen, shadowPath);
									}
								}

								graph.ResetClip();
							}
						}
					}
				}
			}

			// Draw Separator Line(s)
			if(this.axis.ScaleBreakStyle.BreakLineStyle != BreakLineStyle.None)
			{
				using(Pen pen = new Pen(this.axis.ScaleBreakStyle.LineColor, this.axis.ScaleBreakStyle.LineWidth))
				{
					// Set line style
					pen.DashStyle = graph.GetPenStyle(this.axis.ScaleBreakStyle.LineDashStyle);

					// Draw break lines
					graph.DrawPath(pen, breakLinePathTop);
					if(breakPosition.Width > 0f && breakPosition.Height > 0f)
					{
						graph.DrawPath(pen, breakLinePathBottom);
					}
				}
			}

			// Dispose break line paths
			breakLinePathTop.Dispose();
			breakLinePathTop = null;
			if(breakLinePathBottom != null)
			{
				breakLinePathBottom.Dispose();
				breakLinePathBottom = null;
			}

		}

		/// <summary>
		/// Get fill brush used to fill axis break lines spacing.
		/// </summary>
		/// <param name="graph">chart graphics.</param>
		/// <returns>Fill brush.</returns>
		private Brush GetChartFillBrush(ChartGraphics graph)
		{
			Chart chart = this.axis.ChartArea.Common.Chart;
			Brush brush = null;

			if( chart.BackGradientStyle == GradientStyle.None )
			{
				brush = new SolidBrush(chart.BackColor);
			}
			else
			{
				// If a gradient type is set create a brush with gradient
                brush = graph.GetGradientBrush(new RectangleF(0, 0, chart.chartPicture.Width - 1, chart.chartPicture.Height - 1), chart.BackColor, chart.BackSecondaryColor, chart.BackGradientStyle);
			}

			if( chart.BackHatchStyle != ChartHatchStyle.None )
			{
				brush = graph.GetHatchBrush( chart.BackHatchStyle, chart.BackColor, chart.BackSecondaryColor );
			}

			if( chart.BackImage.Length > 0 && 
				chart.BackImageWrapMode != ChartImageWrapMode.Unscaled && 
				chart.BackImageWrapMode != ChartImageWrapMode.Scaled)
			{
				brush = graph.GetTextureBrush(chart.BackImage, chart.BackImageTransparentColor, chart.BackImageWrapMode, chart.BackColor );
			}

			return brush;
		}

		/// <summary>
		/// Gets a path of the break line for specified position.
		/// </summary>
		/// <param name="breakLinePosition">Break line position.</param>
		/// <param name="top">Indicates if top or bottom break line path should be retrieved.</param>
		/// <returns>Graphics path with break line path.</returns>
		private GraphicsPath GetBreakLinePath(RectangleF breakLinePosition, bool top)
		{
			GraphicsPath path = new GraphicsPath();

			if(this.axis.ScaleBreakStyle.BreakLineStyle == BreakLineStyle.Wave)
			{
				PointF[] points = null;
				int pointNumber = 0;
				if( this.axis.AxisPosition == AxisPosition.Right || this.axis.AxisPosition == AxisPosition.Left )
				{
					float startX = breakLinePosition.X;
					float endX = breakLinePosition.Right;
					float y = (top) ? breakLinePosition.Y : breakLinePosition.Bottom;
					pointNumber = ((int)(endX - startX) / 40) * 2 ;
					if(pointNumber < 2)
					{
						pointNumber = 2;
					}
					float step = (endX - startX) / pointNumber;
					points = new PointF[pointNumber + 1];
					for(int pointIndex = 1; pointIndex < pointNumber + 1; pointIndex++)
					{
						points[pointIndex] = new PointF(
							startX + pointIndex * step, 
							y + ((pointIndex%2 == 0) ? -2f : 2f) );
					}
					
					points[0] = new PointF(startX, y);
					points[points.Length - 1] = new PointF(endX, y);
				}
				else
				{
					float startY = breakLinePosition.Y;
					float endY = breakLinePosition.Bottom;
					float x = (top) ? breakLinePosition.X : breakLinePosition.Right;
					pointNumber = ((int)(endY - startY) / 40) * 2 ;
					if(pointNumber < 2)
					{
						pointNumber = 2;
					}
					float step = (endY - startY) / pointNumber;
					points = new PointF[pointNumber + 1];
					for(int pointIndex = 1; pointIndex < pointNumber + 1; pointIndex++)
					{
						points[pointIndex] = new PointF(
							x + ((pointIndex%2 == 0) ? -2f : 2f),
							startY + pointIndex * step);
					}
					
					points[0] = new PointF(x, startY);
					points[points.Length - 1] = new PointF(x, endY);
				}

				path.AddCurve(points, 0, pointNumber, 0.8f);
			}
			else if(this.axis.ScaleBreakStyle.BreakLineStyle == BreakLineStyle.Ragged)
			{
				PointF[] points = null;
				Random rand = new Random(435657);
				if( this.axis.AxisPosition == AxisPosition.Right || this.axis.AxisPosition == AxisPosition.Left )
				{
					float startX = breakLinePosition.X;
					float endX = breakLinePosition.Right;
					float y = (top) ? breakLinePosition.Y : breakLinePosition.Bottom;
					float step = 10f;
					int pointNumber = (int)((endX - startX) / step);
					if(pointNumber < 2)
					{
						pointNumber = 2;
					}
					points = new PointF[pointNumber];
					
					for(int pointIndex = 1; pointIndex < pointNumber - 1; pointIndex++)
					{
						points[pointIndex] = new PointF(
							startX + pointIndex * step, 
							y + rand.Next(-3, 3) );
					}
					
					points[0] = new PointF(startX, y);
					points[points.Length - 1] = new PointF(endX, y);
				}
				else
				{
					float startY = breakLinePosition.Y;
					float endY = breakLinePosition.Bottom;
					float x = (top) ? breakLinePosition.X : breakLinePosition.Right;
					float step = 10f;
					int pointNumber = (int)((endY - startY) / step);
					if(pointNumber < 2)
					{
						pointNumber = 2;
					}
					points = new PointF[pointNumber];
					
					for(int pointIndex = 1; pointIndex < pointNumber - 1; pointIndex++)
					{
						points[pointIndex] = new PointF(
							x + rand.Next(-3, 3),
							startY + pointIndex * step );
					}
					
					points[0] = new PointF(x, startY);
					points[points.Length - 1] = new PointF(x, endY);
				}

				path.AddLines(points);
			}
			else
			{
				if( this.axis.AxisPosition == AxisPosition.Right || this.axis.AxisPosition == AxisPosition.Left )
				{
					if(top)
					{
						path.AddLine(breakLinePosition.X, breakLinePosition.Y, breakLinePosition.Right, breakLinePosition.Y);
					}
					else
					{
						path.AddLine(breakLinePosition.X, breakLinePosition.Bottom, breakLinePosition.Right, breakLinePosition.Bottom);
					}
				}
				else
				{
					if(top)
					{
						path.AddLine(breakLinePosition.X, breakLinePosition.Y, breakLinePosition.X, breakLinePosition.Bottom);
					}
					else
					{
						path.AddLine(breakLinePosition.Right, breakLinePosition.Y, breakLinePosition.Right, breakLinePosition.Bottom);
					}
				}
			}
			return path;
		}

		/// <summary>
		/// Gets position of the axis break line. Break line may be shown as a single 
		/// line or two lines separated with a spacing.
		/// </summary>
		/// <param name="graph">Chart graphics.</param>
		/// <param name="nextSegment">Next segment reference.</param>
		/// <returns>Position of the axis break line in pixel coordinates.</returns>
		internal RectangleF GetBreakLinePosition(ChartGraphics graph, AxisScaleSegment nextSegment)
		{
			// Start with the plotting rectangle position
			RectangleF breakPosition = this.axis.PlotAreaPosition.ToRectangleF();

			// Find maximum scale value of the current segment and minimuj of the next
			double from = this.axis.GetLinearPosition(nextSegment.ScaleMinimum);
			double to = this.axis.GetLinearPosition(this.ScaleMaximum);
			if( this.axis.AxisPosition == AxisPosition.Right || this.axis.AxisPosition == AxisPosition.Left )
			{
				breakPosition.Y = (float)Math.Min(from, to);
				breakPosition.Height = (float)Math.Max(from, to);
			}
			else
			{
				breakPosition.X = (float)Math.Min(from, to);
				breakPosition.Width = (float)Math.Max(from, to);;
			}

			// Convert to pixels
			breakPosition = Rectangle.Round(graph.GetAbsoluteRectangle(breakPosition));

			// Add border width
			if( this.axis.AxisPosition == AxisPosition.Right || this.axis.AxisPosition == AxisPosition.Left )
			{
				breakPosition.Height = (float)Math.Abs(breakPosition.Y - breakPosition.Height);
				breakPosition.X -= this.axis.ChartArea.BorderWidth;
				breakPosition.Width += 2 * this.axis.ChartArea.BorderWidth;
			}
			else
			{
				breakPosition.Width = (float)Math.Abs(breakPosition.X - breakPosition.Width);
				breakPosition.Y -= this.axis.ChartArea.BorderWidth;
				breakPosition.Height += 2 * this.axis.ChartArea.BorderWidth;
			}

			return breakPosition;
		}

		#endregion // Break Line Painting Methods

		#region Helper Methods

		/// <summary>
		/// Gets segment scale position and size in relative coordinates.
		/// Method takes in consideration segment spacing and space required fro separatorType.
		/// </summary>
		/// <param name="plotAreaSize">Plotting area size in relative coordinates.</param>
		/// <param name="scalePosition">Returns scale position.</param>
		/// <param name="scaleSize">Returns scale size.</param>
		internal void GetScalePositionAndSize(double plotAreaSize, out double scalePosition, out double scaleSize)
		{
			scaleSize = (this.Size - this.Spacing) * (plotAreaSize / 100.0);
			scalePosition = this.Position * (plotAreaSize / 100.0);
		}

		/// <summary>
		/// Saves axis settings and set them from the current segment.
		/// </summary>
		internal void SetTempAxisScaleAndInterval()
		{
			// Save current axis settings
			if(_oldAxisSettings.Count == 0)
			{
				_oldAxisSettings.Push(this.axis.maximum);
				_oldAxisSettings.Push(this.axis.minimum);

				_oldAxisSettings.Push(this.axis.majorGrid.interval);
				_oldAxisSettings.Push(this.axis.majorGrid.intervalType);
				_oldAxisSettings.Push(this.axis.majorGrid.intervalOffset);
				_oldAxisSettings.Push(this.axis.majorGrid.intervalOffsetType);

				_oldAxisSettings.Push(this.axis.majorTickMark.interval);
				_oldAxisSettings.Push(this.axis.majorTickMark.intervalType);
				_oldAxisSettings.Push(this.axis.majorTickMark.intervalOffset);
				_oldAxisSettings.Push(this.axis.majorTickMark.intervalOffsetType);

				_oldAxisSettings.Push(this.axis.LabelStyle.interval);
				_oldAxisSettings.Push(this.axis.LabelStyle.intervalType);
				_oldAxisSettings.Push(this.axis.LabelStyle.intervalOffset);
				_oldAxisSettings.Push(this.axis.LabelStyle.intervalOffsetType);
			}

			// Copy settings from the segment into the axis
			this.axis.maximum = this.ScaleMaximum;
			this.axis.minimum = this.ScaleMinimum;

			this.axis.majorGrid.interval = this.Interval;
			this.axis.majorGrid.intervalType = this.IntervalType;
			this.axis.majorGrid.intervalOffset = this.IntervalOffset;
			this.axis.majorGrid.intervalOffsetType = this.IntervalOffsetType;

			this.axis.majorTickMark.interval = this.Interval;
			this.axis.majorTickMark.intervalType = this.IntervalType;
			this.axis.majorTickMark.intervalOffset = this.IntervalOffset;
			this.axis.majorTickMark.intervalOffsetType = this.IntervalOffsetType;

			this.axis.LabelStyle.interval = this.Interval;
			this.axis.LabelStyle.intervalType = this.IntervalType;
			this.axis.LabelStyle.intervalOffset = this.IntervalOffset;
			this.axis.LabelStyle.intervalOffsetType = this.IntervalOffsetType;
		}

		/// <summary>
		/// Restore previously saved axis settings.
		/// </summary>
		internal void RestoreAxisScaleAndInterval()
		{
			if(_oldAxisSettings.Count > 0)
			{
				this.axis.LabelStyle.intervalOffsetType = (DateTimeIntervalType)_oldAxisSettings.Pop();
				this.axis.LabelStyle.intervalOffset = (double)_oldAxisSettings.Pop();
				this.axis.LabelStyle.intervalType = (DateTimeIntervalType)_oldAxisSettings.Pop();
				this.axis.LabelStyle.interval = (double)_oldAxisSettings.Pop();

				this.axis.majorTickMark.intervalOffsetType = (DateTimeIntervalType)_oldAxisSettings.Pop();
				this.axis.majorTickMark.intervalOffset = (double)_oldAxisSettings.Pop();
				this.axis.majorTickMark.intervalType = (DateTimeIntervalType)_oldAxisSettings.Pop();
				this.axis.majorTickMark.interval = (double)_oldAxisSettings.Pop();

				this.axis.majorGrid.intervalOffsetType = (DateTimeIntervalType)_oldAxisSettings.Pop();
				this.axis.majorGrid.intervalOffset = (double)_oldAxisSettings.Pop();
				this.axis.majorGrid.intervalType = (DateTimeIntervalType)_oldAxisSettings.Pop();
				this.axis.majorGrid.interval = (double)_oldAxisSettings.Pop();

				this.axis.minimum = (double)_oldAxisSettings.Pop();
				this.axis.maximum = (double)_oldAxisSettings.Pop();
			}
		}

		#endregion // Helper Methods

	}

	/// <summary>
	/// <b>AxisScaleSegmentCollection</b> is a class that stores collection of axis segments.
	/// </summary>
	[
	SRDescription("DescriptionAttributeAxisScaleSegmentCollection_AxisScaleSegmentCollection"),
	]
	internal class AxisScaleSegmentCollection : CollectionBase
	{
		#region Fields

		// Axis this segment collection belongs to.
		private Axis _axis = null;

		// Segment which is always used to convert scale values.
		// This value is set tmporarly when only one segment has 
		// to handle all the values.
		private AxisScaleSegment _enforcedSegment = null;

		// Indicates that values allowed to be outside of the scale segment.
		// Otherwise they will be rounded to Min and Max values.
		internal bool AllowOutOfScaleValues = false;

		#endregion // Fields

		#region Construction and Initialization

		/// <summary>
		/// Default public constructor.
		/// </summary>
		/// <remarks>
		/// This constructor is for internal use and should not be part of documentation.
		/// </remarks>
		public AxisScaleSegmentCollection()
		{
		}

		/// <summary>
		/// Default public constructor.
		/// </summary>
		/// <remarks>
		/// This constructor is for internal use and should not be part of documentation.
		/// </remarks>
		/// <param name="axis">
		/// Chart axis this collection belongs to
		/// </param>
		internal AxisScaleSegmentCollection(Axis axis)
		{
			this._axis = axis;
		}

		#endregion // Construction and Initialization

		#region Indexer

		/// <summary>
		/// Axis scale segment collection indexer.
		/// </summary>
		/// <remarks>
		/// The <b>AxisScaleSegment</b> object index can be provided as a parameter. Returns the <see cref="AxisScaleSegment"/> object. 
		/// </remarks>
		[
		SRDescription("DescriptionAttributeAxisScaleSegmentCollection_Item"),
		]
		public AxisScaleSegment this[int index] 
		{
			get 
			{ 
				return (AxisScaleSegment)this.List[(int)index]; 
			} 
		}

		#endregion // Indexer

		#region Collection Add and Insert methods

		/// <summary>
		/// Adds a segment to the end of the collection.
		/// </summary>
		/// <param name="segment">
		/// <see cref="AxisScaleSegment"/> object to add.
		/// </param>
		/// <returns>
		/// Index of the newly added object.
		/// </returns>
		public int Add(AxisScaleSegment segment)
		{
			return this.List.Add(segment);
		}


		#endregion // Collection Add and Insert methods

		#region Items Inserting and Removing Notification methods

		/// <summary>
		/// After new item inserted.
		/// </summary>
		/// <param name="index">Item index.</param>
		/// <param name="value">Item object.</param>
		/// <remarks>
		/// This is an internal method and should not be part of the documentation.
		/// </remarks>
		protected override void OnInsertComplete(int index, object value)
		{
			((AxisScaleSegment)value).axis  = this._axis;
		}

		/// <summary>
		/// After items is set.
		/// </summary>
		/// <param name="index">The zero-based index at which oldValue can be found.</param>
		/// <param name="oldValue">The value to replace with newValue.</param>
		/// <param name="newValue">The new value of the element at index.</param>
		/// <remarks>
		/// This is an internal method and should not be part of the documentation.
		/// </remarks>
		protected override void OnSetComplete(int index, object oldValue, object newValue)
		{
			((AxisScaleSegment)newValue).axis  = this._axis;
		}

		#endregion

		#region Helper Methods

        /// <summary>
        /// Ensures that specified axis scale segment is used for all coordinate transformations.
        /// Set tot NULL to reset.
        /// </summary>
        /// <param name="segment"></param>
		internal void EnforceSegment(AxisScaleSegment segment)
		{
			this._enforcedSegment = segment;
		}

		/// <summary>
		/// Find axis scale segment that should be used to translate axis value to relative coordinates.
		/// </summary>
		/// <param name="axisValue">Axis value to convert.</param>
		/// <returns>Scale segment to use for the convertion.</returns>
		public AxisScaleSegment FindScaleSegmentForAxisValue(double axisValue)
		{
			// Check if no segments defined
			if(this.List.Count == 0)
			{
				return null;
			}

			// Check if segment enforcment is enabled
			if(_enforcedSegment != null)
			{
				return _enforcedSegment;
			}

			// Iterate through all segments
			for(int index = 0; index < this.Count; index++)
			{
				if(axisValue < this[index].ScaleMinimum)
				{
					if(index == 0)
					{
						return this[index];
					}
					else
					{
						// Find the segment which is "closer" to the value
						if( Math.Abs(this[index].ScaleMinimum - axisValue) < Math.Abs(axisValue - this[index - 1].ScaleMaximum))
						{
							return this[index];
						}
						else
						{
							return this[index - 1];
						}
					}
				}

				if(axisValue <= this[index].ScaleMaximum)
				{
					return this[index];
				}
				else if(index == this.Count - 1)
				{
					return this[index];
				}
			}

			return null;
		}

		#endregion // Helper Methods
	}
}