3rdpartylibs/fastreports.wpf/FastReport.DataVisualization/shared/General/AxisScale.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.


//
//  Purpose:	Base class for the Axis class which defines axis 
//				csale related properties and methods.
//

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using FastReport.DataVisualization.Charting.Utilities;

namespace FastReport.DataVisualization.Charting
{
    #region Axis enumerations

    /// <summary>
    /// An enumeration of the mode of automatically calculating intervals.
    /// </summary>
    public enum IntervalAutoMode
	{
		/// <summary>
		/// Fixed number of intervals always created on the axis.
		/// </summary>
		FixedCount,

		/// <summary>
		/// Number of axis intervals depends on the axis length.
		/// </summary>
		VariableCount
	}



	/// <summary>
	/// An enumeration of axis position.
	/// </summary>
	internal enum AxisPosition
	{
		/// <summary>
		/// Left position
		/// </summary>
		Left,

		/// <summary>
		/// Right position
		/// </summary>
		Right,

		/// <summary>
		/// Top position
		/// </summary>
		Top,

		/// <summary>
		/// Bottom position
		/// </summary>
		Bottom
	}

	/// <summary>
	/// An enumeration of axis arrow styles.
	/// </summary>
	public enum AxisArrowStyle
	{
		/// <summary>
		/// No arrow
		/// </summary>
		None, 
		/// <summary>
		/// Triangle type
		/// </summary>
		Triangle, 
		/// <summary>
		/// Sharp triangle type
		/// </summary>
		SharpTriangle, 
		/// <summary>
		/// Lines type
		/// </summary>
		Lines
	}

	#endregion

	/// <summary>
	/// The Axis class keeps information about minimum, maximum 
	/// and interval values and it is responsible for setting 
	/// these values automatically. It also handles
	/// logarithmic and reversed axis.
	/// </summary>
	public partial class Axis
	{
		#region Axis scale fields

		// Represents the distance between the data points and its 
		// chart area margin, Measured as a percentage of default 
		// margin size.
		internal double					margin = 100.0;
		internal double					marginView = 0.0;
		internal bool					offsetTempSet = false;

		// Used for column chart margin
		internal double					marginTemp = 0.0;
		private ArrayList				_stripLineOffsets = new ArrayList();
		

		// Data members, which store properties values
		private  bool					_isLogarithmic = false;
		internal double					logarithmBase = 10.0;
		internal bool					isReversed = false;
		internal bool					isStartedFromZero = true;
		internal TickMark				minorTickMark = null;
		internal TickMark				majorTickMark = null;
		internal Grid					minorGrid = null;
		internal Grid					majorGrid = null;
		internal bool					enabled = false;		
		internal bool					autoEnabled = true;		
		internal LabelStyle					labelStyle = null;
		private	 DateTimeIntervalType	_internalIntervalType = DateTimeIntervalType.Auto;
		internal double					maximum = Double.NaN;
		internal double					crossing = Double.NaN;
		internal double					minimum = Double.NaN;

		// Temporary Minimum and maximum values.
		internal double					tempMaximum = Double.NaN;
		internal double					tempMinimum = Double.NaN;
		internal double					tempCrossing = Double.NaN;
		internal CustomLabelsCollection	tempLabels;
		internal bool					tempAutoMaximum = true;
		internal bool					tempAutoMinimum = true;
		internal double					tempMajorGridInterval = Double.NaN;
		internal double					tempMinorGridInterval = 0.0;
		internal double					tempMajorTickMarkInterval = Double.NaN;
		internal double					tempMinorTickMarkInterval = 0.0;
		internal double					tempLabelInterval = Double.NaN;
		internal DateTimeIntervalType	tempGridIntervalType = DateTimeIntervalType.NotSet;
		internal DateTimeIntervalType	tempTickMarkIntervalType = DateTimeIntervalType.NotSet;
		internal DateTimeIntervalType	tempLabelIntervalType = DateTimeIntervalType.NotSet;

		// Paint mode
		internal bool					paintMode = false;

		// Axis type (X, Y, X2, Y2)
		internal AxisName				axisType = AxisName.X;

		// Automatic maximum value (from data point values).
		private bool					_autoMaximum = true;

		// Automatic minimum value (from data point values).
		private bool					_autoMinimum = true;
		
		/// <summary>
		/// Axis position: Left, Right, Top Bottom
		/// </summary>
		private AxisPosition			_axisPosition = AxisPosition.Left;

		/// <summary>
		/// Opposite Axis for this Axis. Necessary for Crossing.		
		/// </summary>
		internal Axis					oppositeAxis = null;

		// Axis data scaleView
		private	AxisScaleView			_scaleView = null;

		// Axis scroll bar class
		internal AxisScrollBar			scrollBar = null;

		// For scater chart X values could be rounded.
		internal bool roundedXValues = false;

		// If Axis is logarithmic value shoud be converted to 
		// linear only once.
		internal bool logarithmicConvertedToLinear = false;

		// IsLogarithmic minimum value
		internal double logarithmicMinimum;

		// IsLogarithmic maximum value
		internal double logarithmicMaximum;

		// Correction of interval because of 
		// 3D Rotation and perspective
		internal double interval3DCorrection = Double.NaN;

		// Axis coordinate convertion optimization fields
		internal bool optimizedGetPosition = false;
		internal double paintViewMax = 0.0;
		internal double paintViewMin = 0.0;
		internal double	paintRange = 0.0;
		internal double	valueMultiplier = 0.0;
		internal RectangleF	paintAreaPosition = RectangleF.Empty;
		internal double paintAreaPositionBottom = 0.0;
		internal double paintAreaPositionRight = 0.0;
		internal double paintChartAreaSize = 0.0;	



		// Determines how number of intervals automatically calculated
		private IntervalAutoMode _intervalAutoMode = IntervalAutoMode.FixedCount;

		// True if scale segments are used
		internal bool scaleSegmentsUsed = false;



		// Preffered number of intervals on the axis
		internal int  prefferedNumberofIntervals = 5;

        private Stack<Double> _intervalsStore = new Stack<Double>();

		#endregion

		#region Axis scale properties

		/// <summary>
		/// Axis position
		/// </summary>
		[
		Bindable(true),
		DefaultValue(AxisPosition.Left),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeReverse"),
		DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
		SerializationVisibilityAttribute(SerializationVisibility.Hidden)
		]
		virtual internal AxisPosition AxisPosition
		{
			get
			{
                return this._axisPosition;
			}
			set
			{
                this._axisPosition = value;
#if SUBAXES
				// Update axis position of the sub axis
				if( !((Axis)this).IsSubAxis )
				{
					foreach(SubAxis subAxis in ((Axis)this).SubAxes)
					{
						subAxis._axisPosition = value;
					}
				}

#endif // SUBAXES
                this.Invalidate();
            }
		}



		/// <summary>
        /// Gets or sets a flag which indicates whether the number of intervals
        /// on the axis is fixed or varies with the axis size.
		/// </summary>
		[
		SRCategory("CategoryAttributeInterval"),
		DefaultValue(IntervalAutoMode.FixedCount),
		SRDescription("DescriptionAttributeIntervalAutoMode"),
		]
		public IntervalAutoMode IntervalAutoMode
		{
			get
			{
				return this._intervalAutoMode;
			}
			set
			{
				this._intervalAutoMode = value;
				this.Invalidate();
                CallOnModifing();
            }
		}



		/// <summary>
		/// Gets or sets a flag which indicates whether the axis is reversed.
        /// If set to reversed, the values on the axis are in reversed sort order
        /// and the direction of values on the axis is flipped.
		/// </summary>
		[
		SRCategory("CategoryAttributeScale"),
		Bindable(true),
		DefaultValue(false),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeReverse"),
		]
		public bool IsReversed
		{
			get
			{
				return isReversed;
			}
			set
			{
				isReversed = value;
				this.Invalidate();
            }
		}

		/// <summary>
        /// Gets or sets a flag which indicates whether the minimum value
        /// of the axis will be automatically set to zero if all data point
        /// values are positive.  If there are negative data point values,
        /// the minimum value of the data points will be used.
		/// </summary>
		[
		SRCategory("CategoryAttributeScale"),
		Bindable(true),
		DefaultValue(true),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeStartFromZero3"),
		]
		public bool IsStartedFromZero
		{
			get
			{
				return isStartedFromZero;
			}
			set
			{
				isStartedFromZero = value;
				this.Invalidate();
                CallOnModifing();
            }
		}

		/// <summary>
        /// Gets or sets a flag to add a margin to the axis.
		/// If true, a space is added between the first/last data 
		/// point and the border of chart area.
		/// </summary>
		[
		SRCategory("CategoryAttributeScale"),
		Bindable(true),
		DefaultValue(true),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeMargin"),
		]
		public bool IsMarginVisible
		{
			get
			{
				if( margin > 0 )
					return true;
				else
					return false;
			}
			set
			{
				if( value == true )
					margin = 100;
				else
					margin = 0;

				this.Invalidate();
                CallOnModifing();
            }
		}

		/// <summary>
		/// Date and time interval type.
		/// </summary>
		[
		SRCategory("CategoryAttributeScale"),
		Bindable(true),
		DefaultValue(DateTimeIntervalType.Auto),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeInternalIntervalType"),
		RefreshPropertiesAttribute(RefreshProperties.All),
		]
		internal DateTimeIntervalType InternalIntervalType
		{
			get
			{
                return _internalIntervalType;
			}
			set
			{
				// Set intervals for labels, grids and tick marks. ( Auto interval type )
				if( tempMajorGridInterval <= 0.0 ||
					(double.IsNaN(tempMajorGridInterval) && ((Axis)this).Interval <= 0.0) ) 
				{
					majorGrid.intervalType = value;
				}

				if( this.tempMajorTickMarkInterval <= 0.0 ||
					(double.IsNaN(tempMajorTickMarkInterval) && ((Axis)this).Interval <= 0.0) ) 
				{
					majorTickMark.intervalType = value;
				}

				if( this.tempLabelInterval <= 0.0 ||
					(double.IsNaN(tempLabelInterval) && ((Axis)this).Interval <= 0.0) ) 
				{
					labelStyle.intervalType = value;
				}

                _internalIntervalType = value;

				this.Invalidate();
            }
		}

		/// <summary>
		/// Sets auto interval values to grids, tick marks
		/// and labels
		/// </summary>
		internal double SetInterval
		{
			set
			{
				if( tempMajorGridInterval <= 0.0 ||
					(double.IsNaN(tempMajorGridInterval) && ((Axis)this).Interval <= 0.0) ) 
				{
					majorGrid.interval = value;
				}

				if( tempMajorTickMarkInterval <= 0.0 ||
					(double.IsNaN(tempMajorTickMarkInterval) && ((Axis)this).Interval <= 0.0) ) 
				{
					majorTickMark.interval = value;
				}

				if( tempLabelInterval <= 0.0 ||
					(double.IsNaN(tempLabelInterval) && ((Axis)this).Interval <= 0.0) ) 
				{
					labelStyle.interval = value;
				}

				this.Invalidate();
			}
		}

		/// <summary>
		/// Sets auto interval values to grids, tick marks
		/// and labels
		/// </summary>
		internal void SetIntervalAndType(double newInterval, DateTimeIntervalType newIntervalType)
		{
			if( tempMajorGridInterval <= 0.0 ||
				(double.IsNaN(tempMajorGridInterval) && ((Axis)this).Interval <= 0.0) ) 
			{
				majorGrid.interval = newInterval;
				majorGrid.intervalType = newIntervalType;
			}

			if( tempMajorTickMarkInterval <= 0.0 ||
				(double.IsNaN(tempMajorTickMarkInterval) && ((Axis)this).Interval <= 0.0) ) 
			{
				majorTickMark.interval = newInterval;
				majorTickMark.intervalType = newIntervalType;
			}

			if( tempLabelInterval <= 0.0 ||
				(double.IsNaN(tempLabelInterval) && ((Axis)this).Interval <= 0.0) ) 
			{
				labelStyle.interval = newInterval;
				labelStyle.intervalType = newIntervalType;
			}

			this.Invalidate();
		}

		
		/// <summary>
		/// Gets or sets the maximum axis value.
		/// </summary>
		[

		SRCategory("CategoryAttributeScale"),
		Bindable(true),
		DefaultValue(Double.NaN),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeMaximum"),
		TypeConverter(typeof(AxisMinMaxAutoValueConverter))
		]
		public double Maximum
		{
			get
			{
				// Get maximum
                if (_isLogarithmic && logarithmicConvertedToLinear && !Double.IsNaN(maximum))
					return logarithmicMaximum;
				else
					return maximum;
			}
			set
			{
				// Split a value to maximum and auto maximum
				if( Double.IsNaN(value) )
				{
					_autoMaximum = true;
					maximum = Double.NaN;
				}
				else
				{
					// Set maximum
					maximum = value;

					// Set non linearized Maximum for logarithmic scale
					logarithmicMaximum = value;

					_autoMaximum = false;
				}

				// Reset original property value fields
				((Axis)this).tempMaximum = maximum;

				// This line is added because of Save ScaleView State August 29, 2003
				// in Web Forms. This place could cause problems with Reset Auto Values.
				((Axis)this).tempAutoMaximum = _autoMaximum;

				this.Invalidate();
                CallOnModifing();
            }
		}

		/// <summary>
		/// Gets or sets the minimum axis value
		/// </summary>
		[

		SRCategory("CategoryAttributeScale"),
		Bindable(true),
		DefaultValue(Double.NaN),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeMinimum"),
		TypeConverter(typeof(AxisMinMaxAutoValueConverter))
		]
		public double Minimum
		{
			get
			{
				// Get minimum
                if (_isLogarithmic && logarithmicConvertedToLinear && !Double.IsNaN(maximum))
					return logarithmicMinimum;
				else
					return minimum;
			}
			set
			{
				// Split a value to minimum and auto minimum
				if( Double.IsNaN(value) )
				{
					_autoMinimum = true;
					minimum = Double.NaN;
				}
				else
				{
					// Set maximum
					minimum = value;
					_autoMinimum = false;

					// Set non linearized Minimum for logarithmic scale
					logarithmicMinimum = value;
				}

				// Reset original property value fields
				((Axis)this).tempMinimum = minimum;

				// This line is added because of Save ScaleView State August 29, 2003
				// in Web Forms. This place could cause problems with Reset Auto Values.
				((Axis)this).tempAutoMinimum = _autoMinimum;

				this.Invalidate();
                CallOnModifing();
            }
		}

		/// <summary>
		/// Gets or sets the point where axis is crossed by another axis.
		/// </summary>
		[
		SRCategory("CategoryAttributeScale"),
		Bindable(true),
		DefaultValue(Double.NaN),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeCrossing"),
		TypeConverter(typeof(AxisCrossingValueConverter))
		]
		virtual public double Crossing
		{
			get
			{
				if( paintMode )
                    if (_isLogarithmic)
						return Math.Pow( this.logarithmBase, GetCrossing() );
					else
						return GetCrossing();
				else
					return crossing;
			}
			set
			{
				crossing = value;

				// Reset original property value fields
				((Axis)this).tempCrossing = crossing;

				this.Invalidate();
                CallOnModifing();
            }
		}

	
		/// <summary>
		/// Enables or disables the axis.
		/// </summary>
		[
		SRCategory("CategoryAttributeMisc"),
		Bindable(true),
		DefaultValue(typeof(AxisEnabled), "Auto"),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeEnabled7"),
		]
		public AxisEnabled Enabled
		{
			get
			{
				// Take Enabled from two fields: enabled and auto enabled
				if( autoEnabled )
				{
					return AxisEnabled.Auto;
				}
				else if( enabled )
				{
					return AxisEnabled.True;
				}
				else
				{
					return AxisEnabled.False;
				}	
			}
			set
			{ // Split Enabled to two fields: enabled and auto enabled
				if( value == AxisEnabled.Auto )
				{
					autoEnabled = true;
				}
				else if( value == AxisEnabled.True )
				{
					enabled = true;
					autoEnabled = false;
				}
				else
				{
					enabled = false;
					autoEnabled = false;
				}

				this.Invalidate();
                CallOnModifing();
            }
		}

		/// <summary>
        /// Gets or sets a flag which indicates whether the axis is logarithmic. 
		/// Zeros or negative data values are not allowed on logarithmic charts. 
		/// </summary>
		[
        SRCategory("CategoryAttributeScale"),
		Bindable(true),
		DefaultValue(false),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeLogarithmic"),
		]
		public bool IsLogarithmic
		{
			get
			{
                return _isLogarithmic;
			}
			set
			{
                _isLogarithmic = value;
				this.Invalidate();
                CallOnModifing();
            }
		}

		/// <summary>
		/// Base of the logarithm used in logarithmic scale. 
		/// By default, this value is 10.
		/// </summary>
		[
        SRCategory("CategoryAttributeScale"),
		Bindable(true),
		DefaultValue(10.0),
		NotifyParentPropertyAttribute(true),
		SRDescription("DescriptionAttributeLogarithmBase"),
		]
		public double LogarithmBase
		{
			get
			{
				return logarithmBase;
			}
			set
			{
				if( value < 2.0 )
				{
                    throw (new ArgumentOutOfRangeException("value", SR.ExceptionAxisScaleLogarithmBaseInvalid));
				}

				logarithmBase = value;
				
				this.Invalidate();
                CallOnModifing();
            }
		}

		#endregion

		#region Axis Segments and Scale Breaks Properties



		// Field that stores Axis automatic scale breaks style.
		internal AxisScaleBreakStyle axisScaleBreakStyle = null;

        /// <summary>
        /// Gets or sets the style of scale breaks.
        /// </summary>
		[
		SRCategory("CategoryAttributeScale"),
		SRDescription("DescriptionAttributeScaleBreakStyle"),
        TypeConverter(typeof(NoNameExpandableObjectConverter)),
		NotifyParentPropertyAttribute(true),
		DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
		]
		virtual public AxisScaleBreakStyle ScaleBreakStyle
		{
			get
			{
				return this.axisScaleBreakStyle;
			}
			set
			{
				this.axisScaleBreakStyle = value;
				this.axisScaleBreakStyle.axis = (Axis)this;
                //this.Invalidate();
                CallOnModifing();
            }
		}

		// Field that stores axis scale segments
		internal AxisScaleSegmentCollection scaleSegments = null;

		/// <summary>
		/// Axis scale segment collection.
		/// </summary>
		[
		SRCategory("CategoryAttributeScale"),
		Browsable(false),
		EditorBrowsable(EditorBrowsableState.Never),
		SRDescription("DescriptionAttributeAxisScaleSegmentCollection_AxisScaleSegmentCollection"),
		SerializationVisibilityAttribute(SerializationVisibility.Hidden),
		DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
#if DESIGNER
        Editor(typeof(ChartCollectionEditor), typeof(UITypeEditor))
#endif
        ]
        internal AxisScaleSegmentCollection ScaleSegments
		{
			get
			{
				return this.scaleSegments;
			}
		}

		#endregion // Axis Segments and Scale Breaks Properties

		#region Axis data scaleView properies and methods

		/// <summary>
		/// Gets or sets the scale view settings of the axis.
		/// </summary>
		[
		SRCategory("CategoryAttributeDataView"),
		Bindable(true),
		SRDescription("DescriptionAttributeView"),
		DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        TypeConverter(typeof(NoNameExpandableObjectConverter))
		]
 	    public AxisScaleView ScaleView
		{
			get
			{
				return _scaleView;
			}
			set
			{
				_scaleView = value;
				_scaleView.axis = (Axis)this;
				this.Invalidate();
                CallOnModifing();
            }
		}

		/// <summary>
		/// Gets or sets the scroll bar settings of the axis.
		/// </summary>
		[
		SRCategory("CategoryAttributeDataView"),
		Bindable(true),
		SRDescription("DescriptionAttributeScrollBar"),
		DesignerSerializationVisibility(DesignerSerializationVisibility.Content), 
        TypeConverter(typeof(NoNameExpandableObjectConverter))
		]
        public AxisScrollBar ScrollBar
		{
			get
			{
				return scrollBar;
			}
			set
			{
				scrollBar = value;
				scrollBar.axis = (Axis)this;
				this.Invalidate();
                CallOnModifing();
            }
		}

		/// <summary>
		/// Gets axis data scaleView minimum position.
		/// </summary>
		/// <returns>Axis data scaleView minimum position.</returns>
		internal double ViewMinimum
		{
            get { return _scaleView.ViewMinimum; }
		}

		/// <summary>
		/// Gets axis data scaleView minimum position.
		/// </summary>
		/// <returns>Axis data scaleView minimum position.</returns>
		internal double ViewMaximum
		{
            get { return _scaleView.ViewMaximum; }
		}

        /// <summary>
        /// Gets automatic maximum value (from data point values). 
        /// </summary>
        internal bool AutoMaximum
        {
            get { return _autoMaximum; }
        }

        /// <summary>
        /// Gets automatic minimum value (from data point values). 
        /// </summary>
        internal bool AutoMinimum
        {
            get { return _autoMinimum; }
        }

		#endregion

		#region Axis position converters methos

		/// <summary>
		/// This function converts axis value to relative position (0-100%). 
		/// If an axis has a logarithmic scale, the value is converted to a linear scale.
		/// </summary>
		/// <param name="axisValue">Value from axis.</param>
		/// <returns>Relative position (0-100%).</returns>
		public double GetPosition( double axisValue )
		{
			// Adjust for the IsLogarithmic axis
            if (_isLogarithmic && axisValue != 0.0) 
			{
				axisValue = Math.Log( axisValue, this.logarithmBase );
			}

			// Get linear position
			return GetLinearPosition(axisValue);
		}
			
		/// <summary>
		/// This function converts an axis value to relative position (0-100%). 
		/// If an axis has a logarithmic scale, the value is converted to a linear scale.
		/// </summary>
		/// <param name="axisValue">Axis value.</param>
		/// <returns>Relative position (0-100%).</returns>
		public double ValueToPosition( double axisValue )
		{
			return GetPosition( axisValue );
		}
			
		/// <summary>
		/// This function converts an axis value to a pixel position. 
        /// If an axis has a logarithmic scale, the value is converted to a linear scale.
		/// </summary>
		/// <param name="axisValue">Value from axis.</param>
		/// <returns>Pixel position.</returns>
		public double ValueToPixelPosition( double axisValue )
		{
			// Get relative value
			double val = ValueToPosition(axisValue);

			// Convert it to pixels
			if( AxisPosition == AxisPosition.Top || AxisPosition == AxisPosition.Bottom )
			{
				val *= (this.Common.ChartPicture.Width - 1) / 100F; 
			}
			else 
			{
				val *= (this.Common.ChartPicture.Height - 1) / 100F; 
			}

			return val;
		}

		/// <summary>
		/// This function converts a relative position to an axis value.
        /// If an axis has a logarithmic scale, the value is converted to a linear scale.
		/// </summary>
		/// <param name="position">Relative position (0-100%).</param>
		/// <returns>Axis value.</returns>
		public double PositionToValue( double position )
		{
			return PositionToValue(position, true);
		}

		/// <summary>
		/// This function converts a relative position to an axis value.
        /// If an axis has a logarithmic scale, the value is converted to a linear scale.
		/// </summary>
		/// <param name="position">Relative position (0-100%).</param>
		/// <param name="validateInput">Indicates if input value range should be checked.</param>
		/// <returns>Axis value.</returns>
		internal double PositionToValue( double position, bool validateInput)
		{
			// Check parameters
			if(validateInput &&
				(position < 0 || position > 100) )
			{
                throw (new ArgumentException(SR.ExceptionAxisScalePositionInvalid, "position"));
			}

			// Check if plot area position was already calculated
			if(PlotAreaPosition == null)
			{
                throw (new InvalidOperationException(SR.ExceptionAxisScalePositionToValueCallFailed));
			}

			// Convert chart picture position to plotting position
			if( AxisPosition == AxisPosition.Top || AxisPosition == AxisPosition.Bottom )
				position = position - PlotAreaPosition.X;
			else 
				position = PlotAreaPosition.Bottom - position;
			

			// The Chart area size
			double ChartArea;
			if( AxisPosition == AxisPosition.Top || AxisPosition == AxisPosition.Bottom )
				ChartArea = PlotAreaPosition.Width;
			else 
				ChartArea = PlotAreaPosition.Height;
			
		
			// The Real range as double
			double viewMax = ViewMaximum;
			double viewMin = ViewMinimum;
			double	range = viewMax - viewMin;

			// Avoid division by zero
			double axisValue = 0;
			if( range != 0 )	
			{
				// Find axis value from position
				axisValue = range / ChartArea * position;
			}
			
			// Corrected axis value for reversed
			if( isReversed )
				axisValue = viewMax - axisValue;
			else
				axisValue = viewMin + axisValue;
					
			return axisValue;
		}
			
		/// <summary>
		/// This function converts a pixel position to an axis value.
		/// If an axis has a logarithmic scale, the value is converted to a linear scale.
		/// </summary>
		/// <param name="position">Pixel position.</param>
		/// <returns>Axis value.</returns>
		public double PixelPositionToValue( double position )
		{
			// Convert it to pixels
			double val = position;
			if( AxisPosition == AxisPosition.Top || AxisPosition == AxisPosition.Bottom )
			{
				val *= 100F / ((float)(this.Common.ChartPicture.Width - 1));
			}
			else 
			{
				val *= 100F / ((float)(this.Common.ChartPicture.Height - 1));
			}

			// Get from relative position
			return PositionToValue(val);
		}

		#endregion

		#region Axis scale methods

		/// <summary>
		/// Sets axis position. Axis position depends 
		/// on crossing and reversed value.
		/// </summary>
		internal void SetAxisPosition()
		{
			// Change position of the axis
			if( GetOppositeAxis().isReversed )
			{
				if( AxisPosition == AxisPosition.Left )
					AxisPosition = AxisPosition.Right;
				else if( AxisPosition == AxisPosition.Right ) 
					AxisPosition = AxisPosition.Left;
				else if( AxisPosition == AxisPosition.Top ) 
					AxisPosition = AxisPosition.Bottom;
				else if( AxisPosition == AxisPosition.Bottom ) 
					AxisPosition = AxisPosition.Top;
			}
		}

		/// <summary>
		/// Sets temporary offset value.
		/// </summary>
		internal void SetTempAxisOffset( )
		{
            if (ChartArea.Series.Count == 0)
            {
                return;
            }
			// Conditions when this code changes margin size: Column chart, 
			// margin is turned off, Interval offset is not used for 
			// gridlines, tick marks and labels.
			Series ser = ChartArea.GetFirstSeries();
			if( ( ser.ChartType == SeriesChartType.Column || 
				ser.ChartType == SeriesChartType.StackedColumn || 
				ser.ChartType == SeriesChartType.StackedColumn100 ||
				ser.ChartType == SeriesChartType.Bar ||

                ser.ChartType == SeriesChartType.RangeBar || 
				ser.ChartType == SeriesChartType.RangeColumn || 

				ser.ChartType == SeriesChartType.StackedBar || 
				ser.ChartType == SeriesChartType.StackedBar100 ) &&
                margin != 100.0 && !offsetTempSet &&
                this._autoMinimum)
			{
                
				// Find offset correction for Column chart margin.
				double offset;
				marginTemp = margin;

				// Find point width
				// Check if series provide custom value for point width
				double pointWidthSize;
				string strWidth = ser[CustomPropertyName.PointWidth];
				if(strWidth != null)
				{
					pointWidthSize = CommonElements.ParseDouble(strWidth);
				}
				else
				{
					pointWidthSize = 0.8;
				}
		
				margin = ( pointWidthSize / 2 ) * 100;
				offset = ( margin ) / 100;
			    double contraOffset = ( 100 - margin ) / 100;
                
                if (this._intervalsStore.Count == 0) 
                {
                    this._intervalsStore.Push(this.labelStyle.intervalOffset);
                    this._intervalsStore.Push(this.majorGrid.intervalOffset);
                    this._intervalsStore.Push(this.majorTickMark.intervalOffset);
                    this._intervalsStore.Push(this.minorGrid.intervalOffset);
                    this._intervalsStore.Push(this.minorTickMark.intervalOffset);
                }

				this.labelStyle.intervalOffset = Double.IsNaN(this.labelStyle.intervalOffset) ? offset : this.labelStyle.intervalOffset + offset;
				this.majorGrid.intervalOffset = Double.IsNaN(this.majorGrid.intervalOffset) ? offset : this.majorGrid.intervalOffset + offset;
				this.majorTickMark.intervalOffset = Double.IsNaN(this.majorTickMark.intervalOffset) ? offset : this.majorTickMark.intervalOffset + offset;
                this.minorGrid.intervalOffset = Double.IsNaN(this.minorGrid.intervalOffset) ? offset : this.minorGrid.intervalOffset + offset;
                this.minorTickMark.intervalOffset = Double.IsNaN(this.minorTickMark.intervalOffset) ? offset : this.minorTickMark.intervalOffset + offset;

				foreach( StripLine strip in ((Axis)(this)).StripLines )
				{
					_stripLineOffsets.Add( strip.IntervalOffset );
					strip.IntervalOffset -= contraOffset;
				}
				offsetTempSet = true;
			}
		}

		/// <summary>
		/// Resets temporary offset value.
		/// </summary>
		internal void ResetTempAxisOffset(  )
		{
			if( this.offsetTempSet )
			{
                System.Diagnostics.Debug.Assert(this._intervalsStore.Count == 5, "Fail in interval store count");

                this.minorTickMark.intervalOffset = this._intervalsStore.Pop();
                this.minorGrid.intervalOffset = this._intervalsStore.Pop();
                this.majorTickMark.intervalOffset = this._intervalsStore.Pop();
                this.majorGrid.intervalOffset = this._intervalsStore.Pop();
                this.labelStyle.intervalOffset = this._intervalsStore.Pop();
				int index = 0;
				foreach( StripLine strip in ((Axis)(this)).StripLines )
				{
					if( _stripLineOffsets.Count > index )
					{
						strip.IntervalOffset = (double)_stripLineOffsets[index];
					}
					index++;
				}
				_stripLineOffsets.Clear();
				offsetTempSet = false;
				margin = marginTemp;
			}
		}

		/// <summary>
		/// This function will create auto maximum and minimum values 
		/// using the interval. This function will make a gap between 
		/// data points and border of the chart area.
		/// </summary>
		/// <param name="inter">Interval</param>
		/// <param name="shouldStartFromZero">True if minimum scale value should start from zero.</param>
		/// <param name="autoMax">Maximum is auto</param>
		/// <param name="autoMin">Minimum is auto</param>
		/// <param name="min">Minimum value</param>
		/// <param name="max">Maximum value</param>
		/// <returns>Interval</returns>
		internal double RoundedValues( 
			double inter, 
			bool shouldStartFromZero,
			bool autoMax, 
			bool autoMin, 
			ref double min, 
			ref double max )
		{
			// For X Axes
			if( axisType == AxisName.X || axisType == AxisName.X2 )
			{
				if( margin == 0.0 && !this.roundedXValues )
				{
					return inter;
				}
			}
			else // For Y Axes
			{
				// Avoid dividing with 0. There is no gap.
				if( margin == 0.0 )
				{
					return inter;	
				}
			}
			
			if( autoMin )
			{ // Set minimum value
				if( min < 0.0 || ( !shouldStartFromZero && !ChartArea.stacked ) )
				{
					min = (double)( ((decimal)Math.Ceiling( min / inter ) - 1m ) * (decimal)inter );
				}
				else
				{
					min = 0.0;
				}
			}
			if( autoMax )
			{// Set maximum value
				if( max <= 0.0 && shouldStartFromZero )
				{
					max = 0.0;
				}
				else
				{
					max = (double)( ((decimal)Math.Floor( max / inter ) + 1m ) *  (decimal)inter );
				}
			}
			return inter;
		}


		/// <summary>
		/// Recalculates an intelligent interval from real interval.
		/// </summary>
		/// <param name="diff">Real interval.</param>
		/// <returns>Inteligent interval.</returns>
		internal double CalcInterval( double diff )
		{
			// If the interval is zero return error
			if( diff == 0.0 )
			{
                throw (new ArgumentOutOfRangeException("diff", SR.ExceptionAxisScaleIntervalIsZero));
			}

			// If the real interval is > 1.0
			double	step = -1;
			double	temp = diff; 
			while( temp > 1.0 )
			{
				step ++;
				temp = temp / 10.0;
				if( step > 1000 )
				{
                    throw (new InvalidOperationException(SR.ExceptionAxisScaleMinimumMaximumInvalid));
				}
			}

			
			// If the real interval is < 1.0
			temp = diff; 
			if( temp < 1.0 )
			{
				step = 0;
			}

			while( temp < 1.0 )
			{
				step --;
				temp = temp * 10.0;
				if( step < -1000 )
				{
                    throw (new InvalidOperationException(SR.ExceptionAxisScaleMinimumMaximumInvalid));
				}
			}
	
			double power = (this.IsLogarithmic) ? this.logarithmBase : 10.0;
			double tempDiff = diff / Math.Pow( power, step );

			if( tempDiff < 3 )
				tempDiff = 2;
			else if( tempDiff < 7 )
				tempDiff = 5;
			else
				tempDiff = 10;

			// Make a correction of the real interval
			return  tempDiff * Math.Pow( power, step );
		}

		/// <summary>
		/// Recalculates a intelligent interval from real interval 
		/// obtained from maximum and minimum values
		/// </summary>
		/// <param name="min">Minimum</param>
		/// <param name="max">Maximum</param>
		/// <returns>Auto Interval</returns>
		private double CalcInterval( double min, double max )
		{
			// Approximated interval value
			return CalcInterval( ( max - min ) / 5 );
		}

		
		/// <summary>
		/// Recalculates a intelligent interval from real interval 
		/// obtained from maximum, minimum and date type if 
		/// the values is date-time value.
		/// </summary>
		/// <param name="min">Minimum value.</param>
		/// <param name="max">Maximum value.</param>
		/// <param name="date">True if date.</param>
		/// <param name="type">Date time interval type.</param>
		/// <param name="valuesType">AxisName of date-time values.</param>
		/// <returns>Auto Interval.</returns>
		internal double CalcInterval( 
			double min, 
			double max, 
			bool date, 
			out DateTimeIntervalType type,
			ChartValueType valuesType)
		{
			// AxisName is date time
			if( date )
			{
				DateTime dateTimeMin = DateTime.FromOADate( min );
				DateTime dateTimeMax = DateTime.FromOADate( max );
				TimeSpan timeSpan = dateTimeMax.Subtract( dateTimeMin );

				// Minutes
				double	inter = timeSpan.TotalMinutes;

				// For Range less than 60 seconds interval is 5 sec
				if( inter <= 1.0 && valuesType != ChartValueType.Date)
				{
					// Milli Seconds
					double	mlSeconds = timeSpan.TotalMilliseconds;
					if(mlSeconds <= 10)
					{
						type = DateTimeIntervalType.Milliseconds;
						return 1;
					}
					if(mlSeconds <= 50)
					{
						type = DateTimeIntervalType.Milliseconds;
						return 4;
					}
					if(mlSeconds <= 200)
					{
						type = DateTimeIntervalType.Milliseconds;
						return 20;
					}
					if(mlSeconds <= 500)
					{
						type = DateTimeIntervalType.Milliseconds;
						return 50;
					}
					
					// Seconds
					double	seconds = timeSpan.TotalSeconds;
					
					if(seconds <= 7)
					{
						type = DateTimeIntervalType.Seconds;
						return 1;
					}
					else if(seconds <= 15)
					{
						type = DateTimeIntervalType.Seconds;
						return 2;
					}
					else if(seconds <= 30)
					{
						type = DateTimeIntervalType.Seconds;
						return 5;
					}
					else if(seconds <= 60)
					{
						type = DateTimeIntervalType.Seconds;
						return 10;
					}

				}// For Range less than 120 seconds interval is 10 sec
				else if( inter <= 2.0 && valuesType != ChartValueType.Date)
				{
					type = DateTimeIntervalType.Seconds;
					return 20;
				}// For Range less than 180 seconds interval is 30 sec
				else if( inter <= 3.0 && valuesType != ChartValueType.Date)
				{
					type = DateTimeIntervalType.Seconds;
					return 30;
				}
					
				// For Range less than 10 minutes interval is 1 min
				else if( inter <= 10 && valuesType != ChartValueType.Date) 
				{
					type = DateTimeIntervalType.Minutes;
					return 1;
				}
				// For Range less than 20 minutes interval is 1 min
				else if( inter <= 20 && valuesType != ChartValueType.Date) 
				{
					type = DateTimeIntervalType.Minutes;
					return 2;
				}// For Range less than 60 minutes interval is 5 min
				else if( inter <= 60 && valuesType != ChartValueType.Date)
				{
					type = DateTimeIntervalType.Minutes;
					return 5;
				}// For Range less than 120 minutes interval is 10 min
				else if( inter <= 120 && valuesType != ChartValueType.Date)
				{
					type = DateTimeIntervalType.Minutes;
					return 10;
				}// For Range less than 180 minutes interval is 30 min
				else if( inter <= 180 && valuesType != ChartValueType.Date)
				{
					type = DateTimeIntervalType.Minutes;
					return 30;
				}
					// For Range less than 12 hours interval is 1 hour
				else if( inter <= 60*12 && valuesType != ChartValueType.Date)
				{
					type = DateTimeIntervalType.Hours;
					return 1;
				}
					// For Range less than 24 hours interval is 4 hour
				else if( inter <= 60*24 && valuesType != ChartValueType.Date)
				{
					type = DateTimeIntervalType.Hours;
					return 4;
				}
					// For Range less than 2 days interval is 6 hour
				else if( inter <= 60*24*2 && valuesType != ChartValueType.Date)
				{
					type = DateTimeIntervalType.Hours;
					return 6;
				}
					// For Range less than 3 days interval is 12 hour
				else if( inter <= 60*24*3 && valuesType != ChartValueType.Date)
				{
					type = DateTimeIntervalType.Hours;
					return 12;
				}

				// For Range less than 10 days interval is 1 day
				else if( inter <= 60*24*10 )
				{
					type = DateTimeIntervalType.Days;
					return 1;
				}
					// For Range less than 20 days interval is 2 day
				else if( inter <= 60*24*20 )
				{
					type = DateTimeIntervalType.Days;
					return 2;
				}
					// For Range less than 30 days interval is 3 day
				else if( inter <= 60*24*30 )
				{
					type = DateTimeIntervalType.Days;
					return 3;
				}
					// For Range less than 2 months interval is 1 week
				else if( inter <= 60*24*30.5*2 )
				{
					type = DateTimeIntervalType.Weeks;
					return 1;
				}
					// For Range less than 5 months interval is 2weeks
				else if( inter <= 60*24*30.5*5 )
				{
					type = DateTimeIntervalType.Weeks;
					return 2;
				}
					// For Range less than 12 months interval is 1 month
				else if( inter <= 60*24*30.5*12 )
				{
					type = DateTimeIntervalType.Months;
					return 1;
				}
					// For Range less than 24 months interval is 3 month
				else if( inter <= 60*24*30.5*24 )
				{
					type = DateTimeIntervalType.Months;
					return 3;
				}
				// For Range less than 48 months interval is 6 months 
				else if( inter <= 60*24*30.5*48 )
				{
					type = DateTimeIntervalType.Months;
					return 6;
				}	
				// For Range more than 48 months interval is year 
				else if( inter >= 60*24*30.5*48 )
				{
					type = DateTimeIntervalType.Years;
					return CalcYearInterval( inter / 60 / 24 / 365 );
				}	
			}

			 // Else numbers
			type = DateTimeIntervalType.Number;
			return CalcInterval( min, max );

		}
				
		/// <summary>
		/// Recalculates a intelligent interval for years
		/// </summary>
		/// <param name="years">Number of years</param>
		/// <returns>Interval in years</returns>
		private double CalcYearInterval( double years )
		{
			// If the interval is zero return error
			if( years <= 1.0 )
			{
                throw (new ArgumentOutOfRangeException("years", SR.ExceptionAxisScaleIntervalIsLessThen1Year));
			}

			if( years < 5 )
				return 1;
			else if( years < 10 )
				return 2;
						
			// Make a correction of the interval
			return Math.Floor( years / 5 ); 
		}

		/// <summary>
		/// This method returns the number of units 
		/// between min and max.
		/// </summary>
		/// <param name="min">Minimum.</param>
		/// <param name="max">Maximum.</param>
		/// <param name="type">Date type.</param>
		/// <returns>Number of units.</returns>
		private int GetNumOfUnits( double min, double max, DateTimeIntervalType type )
		{
            double current = ChartHelper.GetIntervalSize(min, 1, type);
			return (int)Math.Round((max - min) / current);
		}

		/// <summary>
		/// This method checks if value type is date-time.
		/// </summary>
		/// <returns>Date-time type or Auto.</returns>
		internal ChartValueType GetDateTimeType()
		{
			List<string> list = null;

			ChartValueType dateType = ChartValueType.Auto;
		
			// Check if Value type is date from first series in the axis
			if( axisType == AxisName.X )
			{ 
				// Check X axes type
				list = ChartArea.GetXAxesSeries( AxisType.Primary, ((Axis)this).SubAxisName );
				if( list.Count == 0 )
				{
					return ChartValueType.Auto;
				}

				if( Common.DataManager.Series[list[0]].IsXValueDateTime() )
				{
					dateType = Common.DataManager.Series[list[0]].XValueType;
				}
			}
			else if( axisType == AxisName.X2 )
			{ 
				// Check X2 axes type
				list = ChartArea.GetXAxesSeries( AxisType.Secondary, ((Axis)this).SubAxisName );
				if( list.Count == 0 )
				{
					return ChartValueType.Auto;
				}

				if( Common.DataManager.Series[list[0]].IsXValueDateTime() )
				{
					dateType = Common.DataManager.Series[list[0]].XValueType;
				}
			}
			else if( axisType == AxisName.Y )
			{ 
				// Check Y axes type
				list = ChartArea.GetYAxesSeries( AxisType.Primary, ((Axis)this).SubAxisName );
				if( list.Count == 0 )
				{
					return ChartValueType.Auto;
				}

				if( Common.DataManager.Series[list[0]].IsYValueDateTime() )
				{
					dateType = Common.DataManager.Series[list[0]].YValueType;
				}
			}
			else if( axisType == AxisName.Y2 )
			{ 
				// Check Y2 axes type
				list = ChartArea.GetYAxesSeries( AxisType.Secondary, ((Axis)this).SubAxisName );
				if( list.Count == 0 )
				{
					return ChartValueType.Auto;
				}

				if( Common.DataManager.Series[list[0]].IsYValueDateTime() )
				{
					dateType = Common.DataManager.Series[list[0]].YValueType;
				}
			}

			return dateType;
		}

		/// <summary>
		/// This method removes "Auto", "min", "max" from crossing
		/// value and creates a double value.
		/// </summary>
		/// <returns>Crossing value</returns>
		private double GetCrossing()
		{
			if( Double.IsNaN(crossing) )
			{
				if( Common.ChartTypeRegistry.GetChartType( (string)ChartArea.ChartTypes[0] ).ZeroCrossing )
				{
					if( ViewMinimum > 0.0 )
					{
						return ViewMinimum;
					}
					else if( ViewMaximum < 0.0 )
					{
						return ViewMaximum;
					}
					else
					{
						return 0.0;
					}
				}
				else
				{
					return ViewMinimum;
				}
			}
			else if( crossing == Double.MaxValue )
			{
				return ViewMaximum;
			}
			else if(  crossing == Double.MinValue )
			{
				return ViewMinimum;
			}

			return crossing;
		}

		/// <summary>
		/// Set auto minimum number. The minimum number 
		/// which was sent to this function will be used to 
		/// estimate a rounded minimum.
		/// </summary>
		/// <param name="min"> This value is a recommendation for the minimum value. </param>
		internal void SetAutoMinimum(double min)
		{
			// Set the minimum
			if( _autoMinimum )
			{
				minimum = min;
			}
		}
		
		/// <summary>
		/// Set auto maximum number. The maximum number 
		/// which was sent to this function will be used to 
		/// estimate a rounded maximum.
		/// </summary>
		/// <param name="max">This value is a recommendation for the maximum value.</param>
		internal void SetAutoMaximum(double max)
		{
			// Set the maximum
			if( _autoMaximum )
			{
				maximum = max;
			}
		}

		/// <summary>
		/// Find opposite axis of this axis.  What is opposite 
		/// axis depend on first series in chart area and primary 
		/// and secondary X and Y axes for the first series.
		/// </summary>
		/// <returns>Opposite axis</returns>
		internal Axis GetOppositeAxis()
		{
			// Oppoiste axis found
            if (oppositeAxis != null) 
			{
                return oppositeAxis;
			}

			List<string> list;

			switch( axisType )
			{
				// X Axis
				case AxisName.X:
					list = ChartArea.GetXAxesSeries( AxisType.Primary, ((Axis)this).SubAxisName ); 
					// There aren't data series
					if( list.Count == 0 )
                        oppositeAxis = ChartArea.AxisY;
						// Take opposite axis from the first series from chart area
					else if( Common.DataManager.Series[list[0]].YAxisType == AxisType.Primary )
                        oppositeAxis = ChartArea.AxisY.GetSubAxis(Common.DataManager.Series[list[0]].YSubAxisName);
					else
                        oppositeAxis = ChartArea.AxisY2.GetSubAxis(Common.DataManager.Series[list[0]].YSubAxisName);
					break;
					// X2 Axis
				case AxisName.X2:
					list = ChartArea.GetXAxesSeries( AxisType.Secondary, ((Axis)this).SubAxisName ); 
					// There aren't data series
					if( list.Count == 0 )
                        oppositeAxis = ChartArea.AxisY2;
						// Take opposite axis from the first series from chart area
					else if( Common.DataManager.Series[list[0]].YAxisType == AxisType.Primary)
                        oppositeAxis = ChartArea.AxisY.GetSubAxis(Common.DataManager.Series[list[0]].YSubAxisName);
					else
                        oppositeAxis = ChartArea.AxisY2.GetSubAxis(Common.DataManager.Series[list[0]].YSubAxisName);
					break;
					// Y Axis
				case AxisName.Y:
					list = ChartArea.GetYAxesSeries( AxisType.Primary, ((Axis)this).SubAxisName ); 
					// There aren't data series
					if( list.Count == 0 )
                        oppositeAxis = ChartArea.AxisX;
						// Take opposite axis from the first series from chart area
					else if( Common.DataManager.Series[list[0]].XAxisType == AxisType.Primary )
                        oppositeAxis = ChartArea.AxisX.GetSubAxis(Common.DataManager.Series[list[0]].XSubAxisName);
					else
                        oppositeAxis = ChartArea.AxisX2.GetSubAxis(Common.DataManager.Series[list[0]].XSubAxisName);
					break;
					// Y2 Axis
				case AxisName.Y2:
					list = ChartArea.GetYAxesSeries( AxisType.Secondary, ((Axis)this).SubAxisName ); 
					// There aren't data series
					if( list.Count == 0 )
                        oppositeAxis = ChartArea.AxisX2;
						// Take opposite axis from the first series from chart area
					else if( Common.DataManager.Series[list[0]].XAxisType == AxisType.Primary  )
                        oppositeAxis = ChartArea.AxisX.GetSubAxis(Common.DataManager.Series[list[0]].XSubAxisName);
					else
                        oppositeAxis = ChartArea.AxisX2.GetSubAxis(Common.DataManager.Series[list[0]].XSubAxisName);
					break;
			}
            return oppositeAxis;
		}

		/// <summary>
		/// This function converts Values from Axes to 
		/// linear relative positions.
		/// </summary>
		/// <param name="axisValue">Value from axis.</param>
		/// <returns>Relative position.</returns>
		internal double GetLinearPosition( double axisValue )
		{
			bool circularArea = (ChartArea == null || !ChartArea.chartAreaIsCurcular) ? 
				false : true;

			// Check if some value calculation is optimized
			if(!this.optimizedGetPosition)
			{
				paintViewMax = ViewMaximum;
				paintViewMin = ViewMinimum;
				paintRange = paintViewMax - paintViewMin;
				paintAreaPosition = PlotAreaPosition.ToRectangleF();

				// Update position for circular chart area
				if(circularArea)
				{
					paintAreaPosition.Width /= 2.0f;
					paintAreaPosition.Height /= 2.0f;
				}

				paintAreaPositionBottom = paintAreaPosition.Y + paintAreaPosition.Height;
				paintAreaPositionRight = paintAreaPosition.X + paintAreaPosition.Width;

				// The Chart area size
				if( AxisPosition == AxisPosition.Top || AxisPosition == AxisPosition.Bottom )
					paintChartAreaSize = paintAreaPosition.Width;
				else 
					paintChartAreaSize = paintAreaPosition.Height;

				valueMultiplier = 0.0;
				if( paintRange != 0 )
				{
					valueMultiplier = paintChartAreaSize / paintRange;
				}
			}

			// The Chart area pixel size
			double position = valueMultiplier * ( axisValue - paintViewMin);



			// Check if axis scale segments are enabled
			if(this.scaleSegmentsUsed)
			{
				AxisScaleSegment scaleSegment = this.ScaleSegments.FindScaleSegmentForAxisValue(axisValue);
				if(scaleSegment != null)
				{
					double segmentSize = 0.0;
					double segmentPosition = 0.0;
					scaleSegment.GetScalePositionAndSize(paintChartAreaSize, out segmentPosition, out segmentSize);

					// Make sure value do not exceed max possible
					if(!this.ScaleSegments.AllowOutOfScaleValues)
					{
						if(axisValue > scaleSegment.ScaleMaximum)
						{
							axisValue = scaleSegment.ScaleMaximum;
						}
						else if(axisValue < scaleSegment.ScaleMinimum)
						{
							axisValue = scaleSegment.ScaleMinimum;
						}
					}

					double segmentScaleRange = scaleSegment.ScaleMaximum - scaleSegment.ScaleMinimum;

					position = (segmentSize / segmentScaleRange) * (axisValue - scaleSegment.ScaleMinimum);
					position += segmentPosition;
				}
			}


			// Window position 
			// (Do Not use .Right or .Bottom methods below) - rounding issue!
			if( isReversed )
			{
				if( AxisPosition == AxisPosition.Top || AxisPosition == AxisPosition.Bottom )
					position = paintAreaPositionRight - position;
				else 
					position = paintAreaPosition.Y + position;
			}
			else
			{
				if( AxisPosition == AxisPosition.Top || AxisPosition == AxisPosition.Bottom )
					position = paintAreaPosition.X + position;
				else 
					position = paintAreaPositionBottom - position;
			}

			return position;
		}


		#endregion

		#region Axis estimate axis methods

		/// <summary>
		/// This function recalculates minimum maximum and interval. 
		/// The function uses current values for minimum and maximum to 
		/// find rounding values. If the value from the data source for the 
		/// maximum value is 376.5 this function will return 380. This function 
		/// also set interval type for date
		/// </summary>
		internal void EstimateAxis()
		{
			double axisInterval;

			// Check if veiw size specified without scaleView position
			if(!Double.IsNaN(this.ScaleView.Size))
			{
				// If size set only use axis minimum for scaleView position
				if(Double.IsNaN(this.ScaleView.Position))
				{
					this.ScaleView.Position = this.Minimum;
				}
			}

			// Zooming Mode
			if( !Double.IsNaN(_scaleView.Position) && !Double.IsNaN(_scaleView.Size) )
			{ 
				double viewMaximum = ViewMaximum;
				double viewMinimum = ViewMinimum;

				// IsLogarithmic axes
                if (this._isLogarithmic)
				{
					viewMaximum = Math.Pow( this.logarithmBase, viewMaximum );
					viewMinimum = Math.Pow( this.logarithmBase, viewMinimum );
				}
				else
				{
					// Add rounding and gap for maximum and minimum
					EstimateAxis( ref this.minimum, ref this.maximum, _autoMaximum, _autoMinimum );
				}

				// Find Interval for Zoom
				axisInterval = EstimateAxis( ref viewMinimum, ref viewMaximum, true, true );
			}
			else // No Zooming mode
			{ 
				// Estimate axis shoud be always called for non logarithmic axis
				axisInterval = EstimateAxis( ref this.minimum, ref this.maximum, _autoMaximum, _autoMinimum );
			}

			// Set intervals for grids, tick marks and labels
			if( axisInterval <= 0.0 )
			{
                throw (new InvalidOperationException(SR.ExceptionAxisScaleAutoIntervalInvalid));
			}
			else
			{
				// This code checks if all series in the chart area have “integer type” 
                // for specified axes, which means int, uint, long and ulong and rounds interval.
#if SUBAXES
				if( ChartArea.SeriesIntegerType( this.axisType, ((Axis)this).SubAxisName ) )
#else // SUBAXES
                if ( ChartArea.SeriesIntegerType( this.axisType, string.Empty ))
#endif // SUBAXES
                {
					axisInterval = Math.Round( axisInterval );
					if( axisInterval == 0.0 )
					{
						axisInterval = 1.0;
					}

					// Round Minimum to floor value if type is integer
					minimum = Math.Floor( minimum );
				}

				SetInterval = axisInterval;
			}	
		}
				
		/// <summary>
		/// This function recalculates minimum maximum and interval. 
		/// The function uses current values for minimum and maximum to 
		/// find rounding values. If the value from the data source for the 
		/// maximum value is 376.5 this function will return 380. This function 
		/// also set interval type for date
		/// </summary>
		/// <param name="minimumValue">Minimum</param>
		/// <param name="maximumValue">Maximum</param>
		/// <param name="autoMaximum">Maximum value is Auto</param>
		/// <param name="autoMinimum">Minimum value is Auto</param>
		/// <returns>Interval</returns>
		internal double EstimateAxis( ref double minimumValue, ref double maximumValue, bool autoMaximum, bool autoMinimum )
		{
			double axisInterval;

			// The axis minimum value is greater than the maximum value.
			if( maximumValue < minimumValue )
			{
				if(!this.Common.ChartPicture.SuppressExceptions)
				{
                    throw (new InvalidOperationException(SR.ExceptionAxisScaleMinimumValueIsGreaterThenMaximumDataPoint));
				}
				else
				{
					// Max axis scale should be always bigger
					double tempValue = maximumValue;
					maximumValue = minimumValue;
					minimumValue = tempValue;
				}
			}

			// Take Value type
			ChartValueType	dateType = GetDateTimeType();
						
			// Axis type is logarithmic
            if (_isLogarithmic)
			{
				axisInterval = EstimateLogarithmicAxis( ref minimumValue, ref maximumValue, crossing, autoMaximum, autoMinimum );
			}
			
			// Axis type is date
			else if( dateType !=  ChartValueType.Auto)
			{
				axisInterval = EstimateDateAxis( ref minimumValue, ref maximumValue, autoMaximum, autoMinimum, dateType );
			}
			
			// Axis type is number
			else 
			{
				axisInterval = EstimateNumberAxis( ref minimumValue, ref maximumValue, this.IsStartedFromZero, this.prefferedNumberofIntervals, autoMaximum, autoMinimum );
			}

			// Set intervals for grids, tick marks and labels
			if( axisInterval <= 0.0 )
			{
                throw (new InvalidOperationException(SR.ExceptionAxisScaleAutoIntervalInvalid));
			}
			else
			{
				// Set interval for Grid lines Tick Marks and labels
				SetInterval = axisInterval;
			}	

			return axisInterval;

		}

        /// <summary>
        /// This function recalculates minimum maximum and interval for 
        /// logarithmic axis. The function uses current values for minimum and 
        /// maximum to find new rounding values.
        /// </summary>
        /// <param name="minimumValue">Current Minimum value</param>
        /// <param name="maximumValue">Current Maximum value</param>
        /// <param name="crossingValue">Crossing value</param>
        /// <param name="autoMaximum">Maximum value is Auto</param>
        /// <param name="autoMinimum">Minimum value is Auto</param>
        /// <returns>Interval</returns>
		private double EstimateLogarithmicAxis( ref double minimumValue, ref double maximumValue, double crossingValue, bool autoMaximum, bool autoMinimum )
		{
			double axisInterval;

			if( !logarithmicConvertedToLinear )
			{
				// Remember values. Do not use POW function because of rounding.
				this.logarithmicMinimum = this.minimum;
				this.logarithmicMaximum = this.maximum;
			}

			// For log axis margin always turn on.
			margin = 100;

			// Supress zero and negative values with logarithmic axis exceptions
			if(this.Common != null && this.Common.Chart != null && this.Common.Chart.chartPicture.SuppressExceptions)
			{
				if (minimumValue <= 0.0 )
				{
					minimumValue = 1.0;
				}
				if (maximumValue <= 0.0 )
				{
					maximumValue = 1.0;
				}
				if (crossingValue <= 0.0 && crossingValue != Double.MinValue )
				{
					crossingValue = 1.0;
				}
			}

			// The logarithmic axes can not show negative values.
			if( minimumValue <= 0.0 || maximumValue <= 0.0 || crossingValue <= 0.0 )
			{
				if (minimumValue <= 0.0 )
                    throw (new ArgumentOutOfRangeException("minimumValue", SR.ExceptionAxisScaleLogarithmicNegativeValues));
				if (maximumValue <= 0.0 )
                    throw (new ArgumentOutOfRangeException("maximumValue", SR.ExceptionAxisScaleLogarithmicNegativeValues));
			}

			// Change crossing to linear scale
			crossingValue = Math.Log( crossingValue, this.logarithmBase );

			// Change minimum and maximum to linear scale
			minimumValue = Math.Log( minimumValue, this.logarithmBase );
			maximumValue = Math.Log( maximumValue, this.logarithmBase );

			logarithmicConvertedToLinear = true;
			
			// Find interval - Make approximately 5 grid lines and labels.
			double diff = ( maximumValue - minimumValue ) / 5;

			// Make good interval for logarithmic scale
			axisInterval = Math.Floor( diff );
			if( axisInterval == 0 ) axisInterval = 1;

			if( autoMinimum && autoMaximum )
			{
				// The maximum and minimum rounding with interval
				RoundedValues( axisInterval, this.IsStartedFromZero, autoMaximum, autoMinimum, ref minimumValue, ref maximumValue );
			}
			
			// Do not allow min/max values more than a hundred
			if(ChartArea.hundredPercent)
			{
				if(autoMinimum)
				{
					if(minimumValue < 0)	
						minimumValue = 0;
				}

				if(autoMaximum)	
				{
					if(maximumValue > 2)	
						maximumValue = 2;
				}
			}

			// Set interval for Grid lines Tick Marks and labels
			return axisInterval;
		}

		/// <summary>
		/// This function recalculates minimum maximum and interval for 
		/// Date axis. The function uses current values for minimum and 
		/// maximum to find new rounding values.
		/// </summary>
		/// <param name="minimumValue">Current Minimum value</param>
		/// <param name="maximumValue">Current Maximum value</param>
		/// <param name="autoMaximum">Maximum value is Auto</param>
		/// <param name="autoMinimum">Minimum value is Auto</param>
		/// <param name="valuesType">AxisName of date-time values.</param>
		/// <returns>Interval</returns>
		private double EstimateDateAxis( 
			ref double minimumValue, 
			ref double maximumValue, 
			bool autoMaximum, 
			bool autoMinimum,
			ChartValueType valuesType)
		{
			double axisInterval;

			double min = minimumValue;
			double max = maximumValue;

			// Find interval for this date type
            axisInterval = CalcInterval(min, max, true, out _internalIntervalType, valuesType);


			// For 3D Charts interval could be changed. After rotation 
			// projection of axis could be very small.
			if( !double.IsNaN( this.interval3DCorrection ) && 
				ChartArea.Area3DStyle.Enable3D && 
				!ChartArea.chartAreaIsCurcular)
			{
				axisInterval = Math.Floor( axisInterval / this.interval3DCorrection );

				this.interval3DCorrection = double.NaN;
			}

			// Find number of units between minimum and maximum
			int numberOfUnits = GetNumOfUnits( min, max, _internalIntervalType );

			// Make a gap between max point and axis for Y axes
			if( axisType == AxisName.Y || axisType == AxisName.Y2 ) 
			{
                if (autoMinimum && minimumValue > ChartHelper.GetIntervalSize(min, axisInterval, _internalIntervalType))
				{
					// Add gap to the minimum value from the series
					// equal half of the interval
                    minimumValue += ChartHelper.GetIntervalSize( 
						min, 
						- (axisInterval / 2.0) * margin / 100,
                        _internalIntervalType,
						null,
						0.0,
						DateTimeIntervalType.Number,
						false,
						false);

					// Align minimum sacale value on the interval
					minimumValue = ChartHelper.AlignIntervalStart(
						minimumValue, 
						axisInterval * margin / 100,
                        _internalIntervalType);
				}

				// Increase maximum if not zero. Make a space between chart type 
				// and the end of the chart area.
				if( autoMaximum && max > 0 && margin != 0.0 )
				{
					maximumValue = minimumValue + ChartHelper.GetIntervalSize( 
						minimumValue, 
						(double)((Math.Floor(numberOfUnits / axisInterval  / margin * 100)+2) * axisInterval  * margin / 100),
                        _internalIntervalType);
				}
			}

            InternalIntervalType = _internalIntervalType;

			// Set interval for Grid lines Tick Marks and labels
			return axisInterval;
		}
		
		/// <summary>
		/// This function recalculates minimum maximum and interval for 
		/// number type axis. The function uses current values for minimum and 
		/// maximum to find new rounding values.
		/// </summary>
		/// <param name="minimumValue">Current Minimum value</param>
		/// <param name="maximumValue">Current Maximum value</param>
		/// <param name="shouldStartFromZero">Should start from zero flag.</param>
		/// <param name="preferredNumberOfIntervals">Preferred number of intervals. Can be set to zero for dynamic mode.</param>
		/// <param name="autoMaximum">Maximum value is Auto</param>
		/// <param name="autoMinimum">Minimum value is Auto</param>
		/// <returns>Interval</returns>
		internal double EstimateNumberAxis( 
			ref double minimumValue, 
			ref double maximumValue, 
			bool shouldStartFromZero, 
			int preferredNumberOfIntervals,
			bool autoMaximum, 
			bool autoMinimum )
		{
			double axisInterval;
			double min = minimumValue;
			double max = maximumValue;
			double diff;

			if( !roundedXValues && ( axisType == AxisName.X || axisType == AxisName.X2 ) )
			{
				diff = ChartArea.GetPointsInterval( false, 10 );
				if( diff == 0 || ( max - min ) / diff > 20 )
				{
					diff = ( max - min ) / preferredNumberOfIntervals;
				}
					
			}
			else
			{
				diff = ( max - min ) / preferredNumberOfIntervals;
			}

            // For 3D Charts interval could be changed. After rotation 
			// projection of axis could be very small.
			if( !double.IsNaN( this.interval3DCorrection ) && 
				ChartArea.Area3DStyle.Enable3D &&
				!ChartArea.chartAreaIsCurcular)
			{
				diff = diff / this.interval3DCorrection;

				// Do not change minimum and maximum with 3D correction.
				if( max - min < diff )
				{
					diff = max - min;
				}

				this.interval3DCorrection = double.NaN;

				if( diff != 0.0 )
				{
					diff = CalcInterval( diff );
				}
			}

				
			if( autoMaximum || autoMinimum ) 
			{
				if( diff == 0 )
				{
					// Can not find interval. Minimum and maximum are same

					max = min + 1;
					diff = 0.2;
					axisInterval = 0.2;
				}
				else
				{	
					axisInterval = CalcInterval( diff );
				}
			}
			else 
			{
				axisInterval = diff;
			}

			// Case when minimum or maximum is set and interval is > maximum. 
			// Reasons overflow exception.
			if( ((Axis)this).interval != 0 && ((Axis)this).interval > axisInterval && minimumValue + ((Axis)this).interval > maximumValue )
			{
				axisInterval = ((Axis)this).interval;
				if( autoMaximum )
				{
					maximumValue = minimumValue + axisInterval;
				}

				if( autoMinimum )
				{
					minimumValue = maximumValue - axisInterval;
				}
			}

			// The maximum and minimum rounding for Y Axes
			if( axisType == AxisName.Y || axisType == AxisName.Y2 || ( roundedXValues && ( axisType == AxisName.X || axisType == AxisName.X2 )))
			{
				// Start from zero for the 100% chart types
				bool minIsZero = false;
				bool maxIsZero = false;
				if(ChartArea.hundredPercent)
				{
					minIsZero = (minimumValue == 0.0);
					maxIsZero = (maximumValue == 0.0);
				}

				// Round min/max values
				RoundedValues( axisInterval, shouldStartFromZero, autoMaximum, autoMinimum, ref minimumValue, ref maximumValue );

				// Do not allow min/max values more than a hundred
				if(ChartArea.hundredPercent)
				{
					if(autoMinimum)
					{
						if(minimumValue < -100)	
							minimumValue = -100;
						if(minIsZero)
							minimumValue = 0;
					}

					if(autoMaximum)	
					{
						if(maximumValue > 100)	
							maximumValue = 100;
						if(maxIsZero)
							maximumValue = 0;
					}
				}
			}

			// Set interval for Grid lines Tick Marks and labels
			return axisInterval;
		}

		#endregion
	}
}