You've already forked linux-packaging-mono
0cb742dafb
Rewrite with hard-coded offsets into the PE file format to discern if a binary is PE32 or PE32+, and then to determine if it contains a "CLR Data Directory" entry that looks valid. Tested with PE32 and PE32+ compiled Mono binaries, PE32 and PE32+ native binaries, and a random assortment of garbage files. Former-commit-id: 9e7ac86ec84f653a2f79b87183efd5b0ebda001b
6509 lines
241 KiB
C#
6509 lines
241 KiB
C#
//-------------------------------------------------------------
|
||
// <copyright company=’Microsoft Corporation’>
|
||
// Copyright © Microsoft Corporation. All Rights Reserved.
|
||
// </copyright>
|
||
//-------------------------------------------------------------
|
||
// @owner=alexgor, deliant
|
||
//=================================================================
|
||
// File: Axis.cs
|
||
//
|
||
// Namespace: System.Web.UI.WebControls[Windows.Forms].Charting
|
||
//
|
||
// Classes: Axis
|
||
//
|
||
// Purpose: Axis related properties and methods. Axis class gives
|
||
// information to Common.Chart series about
|
||
// position in the Common.Chart area and keeps all necessary
|
||
// information about axes.
|
||
//
|
||
// Reviewed: GS - August 6, 2002
|
||
// AG - August 7, 2002
|
||
//
|
||
//===================================================================
|
||
|
||
#region Used namespace
|
||
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.Text;
|
||
using System.Drawing.Drawing2D;
|
||
using System.Diagnostics.CodeAnalysis;
|
||
#if Microsoft_CONTROL
|
||
using System.Windows.Forms.DataVisualization.Charting;
|
||
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;
|
||
|
||
#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.Utilities;
|
||
using System.Web.UI.DataVisualization.Charting.ChartTypes;
|
||
#endif
|
||
|
||
|
||
#endregion
|
||
|
||
#if Microsoft_CONTROL
|
||
namespace System.Windows.Forms.DataVisualization.Charting
|
||
#else
|
||
namespace System.Web.UI.DataVisualization.Charting
|
||
|
||
#endif
|
||
{
|
||
#region Axis name enumeration
|
||
|
||
/// <summary>
|
||
/// An enumeration of auto-fitting styles of the axis labels.
|
||
/// </summary>
|
||
[Flags]
|
||
public enum LabelAutoFitStyles
|
||
{
|
||
/// <summary>
|
||
/// No auto-fitting.
|
||
/// </summary>
|
||
None = 0,
|
||
/// <summary>
|
||
/// Allow font size increasing.
|
||
/// </summary>
|
||
IncreaseFont = 1,
|
||
/// <summary>
|
||
/// Allow font size decreasing.
|
||
/// </summary>
|
||
DecreaseFont = 2,
|
||
/// <summary>
|
||
/// Allow using staggered labels.
|
||
/// </summary>
|
||
StaggeredLabels = 4,
|
||
/// <summary>
|
||
/// Allow changing labels angle using values of 0, 30, 60 and 90 degrees.
|
||
/// </summary>
|
||
LabelsAngleStep30 = 8,
|
||
/// <summary>
|
||
/// Allow changing labels angle using values of 0, 45, 90 degrees.
|
||
/// </summary>
|
||
LabelsAngleStep45 = 16,
|
||
/// <summary>
|
||
/// Allow changing labels angle using values of 0 and 90 degrees.
|
||
/// </summary>
|
||
LabelsAngleStep90 = 32,
|
||
/// <summary>
|
||
/// Allow replacing spaces with the new line character.
|
||
/// </summary>
|
||
WordWrap = 64,
|
||
}
|
||
|
||
/// <summary>
|
||
/// An enumeration of axis names.
|
||
/// </summary>
|
||
public enum AxisName
|
||
{
|
||
/// <summary>
|
||
/// Primary X Axis.
|
||
/// </summary>
|
||
|
||
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "X")]
|
||
X = 0,
|
||
/// <summary>
|
||
/// Primary Y Axis.
|
||
/// </summary>
|
||
[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Y")]
|
||
Y = 1,
|
||
/// <summary>
|
||
/// Secondary X Axis.
|
||
/// </summary>
|
||
X2 = 2,
|
||
/// <summary>
|
||
/// Secondary Y Axis.
|
||
/// </summary>
|
||
Y2 = 3
|
||
}
|
||
|
||
#endregion
|
||
|
||
/// <summary>
|
||
/// The Axis class gives information to the Common.Chart series
|
||
/// about positions in the Common.Chart area and keeps all of
|
||
/// the data about the axis.
|
||
/// </summary>
|
||
[
|
||
SRDescription("DescriptionAttributeAxis_Axis"),
|
||
DefaultProperty("Enabled"),
|
||
]
|
||
#if ASPPERM_35
|
||
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
||
[AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
|
||
#endif
|
||
#if Microsoft_CONTROL
|
||
public partial class Axis : ChartNamedElement
|
||
#else
|
||
public partial class Axis : ChartNamedElement, IChartMapArea
|
||
#endif
|
||
{
|
||
#region Axis fields
|
||
|
||
/// <summary>
|
||
/// Plot area position
|
||
/// </summary>
|
||
internal ElementPosition PlotAreaPosition;
|
||
|
||
// This field synchronies Store and Reset temporary values
|
||
private bool _storeValuesEnabled = true;
|
||
|
||
private FontCache _fontCache = new FontCache();
|
||
private Font _titleFont;
|
||
private Color _titleForeColor = Color.Black;
|
||
private StringAlignment _titleAlignment = StringAlignment.Center;
|
||
private string _title = "";
|
||
private int _lineWidth = 1;
|
||
private ChartDashStyle _lineDashStyle = ChartDashStyle.Solid;
|
||
private Color _lineColor = Color.Black;
|
||
private bool _isLabelAutoFit = true;
|
||
private AxisArrowStyle _arrowStyle = AxisArrowStyle.None;
|
||
private StripLinesCollection _stripLines = null;
|
||
private bool _isMarksNextToAxis = true;
|
||
|
||
// Default text orientation
|
||
private TextOrientation _textOrientation = TextOrientation.Auto;
|
||
|
||
// Size of the axis elements in percentage
|
||
internal float titleSize = 0F;
|
||
internal float labelSize = 0F;
|
||
internal float labelNearOffset = 0F;
|
||
internal float labelFarOffset = 0F;
|
||
internal float unRotatedLabelSize = 0F;
|
||
internal float markSize = 0F;
|
||
internal float scrollBarSize = 0F;
|
||
internal float totlaGroupingLabelsSize = 0F;
|
||
internal float[] groupingLabelSizes = null;
|
||
internal float totlaGroupingLabelsSizeAdjustment = 0f;
|
||
private LabelAutoFitStyles _labelAutoFitStyle = LabelAutoFitStyles.DecreaseFont |
|
||
LabelAutoFitStyles.IncreaseFont |
|
||
LabelAutoFitStyles.LabelsAngleStep30 |
|
||
LabelAutoFitStyles.StaggeredLabels |
|
||
LabelAutoFitStyles.WordWrap;
|
||
|
||
// Auto calculated font for labels
|
||
internal Font autoLabelFont = null;
|
||
internal int autoLabelAngle = -1000;
|
||
internal int autoLabelOffset = -1;
|
||
|
||
// Labels auto fitting constants
|
||
private float _aveLabelFontSize = 10F;
|
||
private float _minLabelFontSize = 5F;
|
||
// Determines maximum label size of the chart area.
|
||
private float _maximumAutoSize = 75f;
|
||
|
||
// Chart title position rectangle
|
||
private RectangleF _titlePosition = RectangleF.Empty;
|
||
|
||
// Element spacing size
|
||
internal const float elementSpacing = 1F;
|
||
|
||
// Maximum total size of the axis's elements in percentage
|
||
private const float maxAxisElementsSize = 75F;
|
||
|
||
// Maximum size of the axis title in percentage
|
||
private const float maxAxisTitleSize = 20F;
|
||
|
||
// Maximum size of the axis second row of labels in percentage
|
||
// of the total labels size
|
||
private const float maxAxisLabelRow2Size = 45F;
|
||
|
||
// Maximum size of the axis tick marks in percentage
|
||
private const float maxAxisMarkSize = 20F;
|
||
|
||
// Minimum cached value from data series.
|
||
internal double minimumFromData = double.NaN;
|
||
|
||
// Maximum cached value from data series.
|
||
internal double maximumFromData = double.NaN;
|
||
|
||
// Flag, which tells to Set Data method to take, again values from
|
||
// data source and not to use cached values.
|
||
internal bool refreshMinMaxFromData = true;
|
||
|
||
// Flag, which tells to Set Data method to take, again values from
|
||
// data source and not to use cached values.
|
||
internal int numberOfPointsInAllSeries = 0;
|
||
|
||
// Original axis scaleView position
|
||
private double _originalViewPosition = double.NaN;
|
||
|
||
|
||
/// <summary>
|
||
/// Indicates that isInterlaced strip lines will be displayed for the axis.
|
||
/// </summary>
|
||
private bool _isInterlaced = false;
|
||
|
||
/// <summary>
|
||
/// Color used to draw isInterlaced strip lines for the axis.
|
||
/// </summary>
|
||
private Color _interlacedColor = Color.Empty;
|
||
|
||
/// <summary>
|
||
/// Axis interval offset.
|
||
/// </summary>
|
||
private double _intervalOffset = 0;
|
||
|
||
/// <summary>
|
||
/// Axis interval.
|
||
/// </summary>
|
||
internal double interval = 0;
|
||
|
||
/// <summary>
|
||
/// Axis interval units type.
|
||
/// </summary>
|
||
internal DateTimeIntervalType intervalType = DateTimeIntervalType.Auto;
|
||
|
||
/// <summary>
|
||
/// Axis interval offset units type.
|
||
/// </summary>
|
||
internal DateTimeIntervalType intervalOffsetType = DateTimeIntervalType.Auto;
|
||
|
||
/// <summary>
|
||
/// Minimum font size that can be used by the labels auto-fitting algorithm.
|
||
/// </summary>
|
||
internal int labelAutoFitMinFontSize = 6;
|
||
|
||
/// <summary>
|
||
/// Maximum font size that can be used by the labels auto-fitting algorithm.
|
||
/// </summary>
|
||
internal int labelAutoFitMaxFontSize = 10;
|
||
|
||
/// <summary>
|
||
/// Axis tooltip
|
||
/// </summary>
|
||
private string _toolTip = String.Empty;
|
||
|
||
/// <summary>
|
||
/// Axis HREF
|
||
/// </summary>
|
||
private string _url = String.Empty;
|
||
|
||
#if !Microsoft_CONTROL
|
||
|
||
|
||
/// <summary>
|
||
/// Axis map area attributes
|
||
/// </summary>
|
||
private string _mapAreaAttributes = String.Empty;
|
||
|
||
private string _postbackValue = String.Empty;
|
||
|
||
#endif
|
||
|
||
#endregion
|
||
|
||
#region Axis constructor and initialization
|
||
|
||
/// <summary>
|
||
/// Default constructor of Axis.
|
||
/// </summary>
|
||
public Axis()
|
||
: base(null, GetName(AxisName.X))
|
||
{
|
||
Initialize(AxisName.X);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Axis constructor.
|
||
/// </summary>
|
||
/// <param name="chartArea">The chart area the axis belongs to.</param>
|
||
/// <param name="axisTypeName">The type of the axis.</param>
|
||
public Axis(ChartArea chartArea, AxisName axisTypeName)
|
||
: base(chartArea, GetName(axisTypeName))
|
||
{
|
||
Initialize(axisTypeName);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Initialize axis class
|
||
/// </summary>
|
||
/// <param name="axisTypeName">Name of the axis type.</param>
|
||
private void Initialize(AxisName axisTypeName)
|
||
{
|
||
// DT: Axis could be already created. Don't recreate new labelstyle and other objects.
|
||
// Initialize axis labels
|
||
if (labelStyle == null)
|
||
{
|
||
labelStyle = new LabelStyle(this);
|
||
}
|
||
if (_customLabels == null)
|
||
{
|
||
_customLabels = new CustomLabelsCollection(this);
|
||
}
|
||
if (_scaleView == null)
|
||
{
|
||
// Create axis data scaleView object
|
||
_scaleView = new AxisScaleView(this);
|
||
}
|
||
#if Microsoft_CONTROL
|
||
if (scrollBar == null)
|
||
{
|
||
// Create axis croll bar class
|
||
scrollBar = new AxisScrollBar(this);
|
||
}
|
||
#endif // Microsoft_CONTROL
|
||
|
||
this.axisType = axisTypeName;
|
||
|
||
// Create grid & tick marks objects
|
||
if (minorTickMark == null)
|
||
{
|
||
minorTickMark = new TickMark(this, false);
|
||
}
|
||
if (majorTickMark == null)
|
||
{
|
||
majorTickMark = new TickMark(this, true);
|
||
majorTickMark.Interval = double.NaN;
|
||
majorTickMark.IntervalOffset = double.NaN;
|
||
majorTickMark.IntervalType = DateTimeIntervalType.NotSet;
|
||
majorTickMark.IntervalOffsetType = DateTimeIntervalType.NotSet;
|
||
}
|
||
if (minorGrid == null)
|
||
{
|
||
minorGrid = new Grid(this, false);
|
||
}
|
||
if (majorGrid == null)
|
||
{
|
||
majorGrid = new Grid(this, true);
|
||
majorGrid.Interval = double.NaN;
|
||
majorGrid.IntervalOffset = double.NaN;
|
||
majorGrid.IntervalType = DateTimeIntervalType.NotSet;
|
||
majorGrid.IntervalOffsetType = DateTimeIntervalType.NotSet;
|
||
}
|
||
if (this._stripLines == null)
|
||
{
|
||
this._stripLines = new StripLinesCollection(this);
|
||
}
|
||
|
||
if (_titleFont == null)
|
||
{
|
||
_titleFont = _fontCache.DefaultFont;
|
||
}
|
||
#if SUBAXES
|
||
if(this.subAxes == null)
|
||
{
|
||
this.subAxes = new SubAxisCollection(this);
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
#if Microsoft_CONTROL
|
||
|
||
// Initialize axis scroll bar class
|
||
this.ScrollBar.Initialize();
|
||
|
||
#endif // Microsoft_CONTROL
|
||
|
||
// Create collection of scale segments
|
||
if (this.scaleSegments == null)
|
||
{
|
||
this.scaleSegments = new AxisScaleSegmentCollection(this);
|
||
}
|
||
|
||
// Create scale break style
|
||
if (this.axisScaleBreakStyle == null)
|
||
{
|
||
this.axisScaleBreakStyle = new AxisScaleBreakStyle(this);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Initialize axis class
|
||
/// </summary>
|
||
/// <param name="chartArea">Chart area that the axis belongs.</param>
|
||
/// <param name="axisTypeName">Axis type.</param>
|
||
internal void Initialize(ChartArea chartArea, AxisName axisTypeName)
|
||
{
|
||
this.Initialize(axisTypeName);
|
||
this.Parent = chartArea;
|
||
this.Name = GetName(axisTypeName);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Set Axis Name
|
||
/// </summary>
|
||
internal static string GetName(AxisName axisName)
|
||
{
|
||
// Set axis name.
|
||
// NOTE: Strings below should neber be localized. Name properties in the chart are never localized
|
||
// and represent consisten object name in all locales.
|
||
switch (axisName)
|
||
{
|
||
case (AxisName.X):
|
||
return "X axis";
|
||
case (AxisName.Y):
|
||
return "Y (Value) axis";
|
||
case (AxisName.X2):
|
||
return "Secondary X axis";
|
||
case (AxisName.Y2):
|
||
return "Secondary Y (Value) axis";
|
||
}
|
||
return null;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Axis properies
|
||
|
||
// Internal
|
||
internal ChartArea ChartArea
|
||
{
|
||
get { return Parent as ChartArea; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// Text orientation.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeTitle"),
|
||
Bindable(true),
|
||
DefaultValue(TextOrientation.Auto),
|
||
SRDescription("DescriptionAttribute_TextOrientation"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public TextOrientation TextOrientation
|
||
{
|
||
get
|
||
{
|
||
return this._textOrientation;
|
||
}
|
||
set
|
||
{
|
||
this._textOrientation = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns sub-axis name.
|
||
/// </summary>
|
||
virtual internal string SubAxisName
|
||
{
|
||
get
|
||
{
|
||
return string.Empty;
|
||
}
|
||
}
|
||
|
||
#if SUBAXES
|
||
|
||
/// <summary>
|
||
/// Indicates if this axis object present the main or sub axis.
|
||
/// </summary>
|
||
virtual internal bool IsSubAxis
|
||
{
|
||
get
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private SubAxisCollection subAxes = null;
|
||
|
||
/// <summary>
|
||
/// Sub-axes collection.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeSubAxes"),
|
||
Bindable(true),
|
||
SRDescription("DescriptionAttributeSubAxes"),
|
||
#if Microsoft_CONTROL
|
||
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
||
#else
|
||
PersistenceMode(PersistenceMode.InnerProperty),
|
||
#endif
|
||
Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base)
|
||
]
|
||
virtual public SubAxisCollection SubAxes
|
||
{
|
||
get
|
||
{
|
||
return this.subAxes;
|
||
}
|
||
}
|
||
|
||
#endif // SUBAXES
|
||
|
||
/// <summary>
|
||
/// Gets or sets a flag which indicates whether interlaced strip lines will be displayed for the axis.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
DefaultValue(false),
|
||
SRDescription("DescriptionAttributeInterlaced"),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
#endif
|
||
NotifyParentPropertyAttribute(true),
|
||
]
|
||
public bool IsInterlaced
|
||
{
|
||
get
|
||
{
|
||
return _isInterlaced;
|
||
}
|
||
set
|
||
{
|
||
_isInterlaced = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the color used to draw interlaced strip lines for the axis.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
DefaultValue(typeof(Color), ""),
|
||
SRDescription("DescriptionAttributeInterlacedColor"),
|
||
NotifyParentPropertyAttribute(true),
|
||
TypeConverter(typeof(ColorConverter)),
|
||
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public Color InterlacedColor
|
||
{
|
||
get
|
||
{
|
||
return _interlacedColor;
|
||
}
|
||
set
|
||
{
|
||
_interlacedColor = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Axis name. This field is reserved for internal use only.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
Browsable(false),
|
||
DefaultValue(""),
|
||
SRDescription("DescriptionAttributeAxis_Name"),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
#endif
|
||
DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
|
||
SerializationVisibilityAttribute(SerializationVisibility.Hidden)
|
||
]
|
||
public override string Name
|
||
{
|
||
get
|
||
{
|
||
return base.Name;
|
||
}
|
||
set
|
||
{
|
||
base.Name = value;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Axis name. This field is reserved for internal use only.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
Browsable(false),
|
||
DefaultValue(""),
|
||
SRDescription("DescriptionAttributeType"),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
#endif
|
||
DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
|
||
SerializationVisibilityAttribute(SerializationVisibility.Hidden)
|
||
]
|
||
virtual public AxisName AxisName
|
||
{
|
||
get
|
||
{
|
||
return axisType;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the arrow style used for the axis.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
DefaultValue(AxisArrowStyle.None),
|
||
NotifyParentPropertyAttribute(true),
|
||
SRDescription("DescriptionAttributeArrows"),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public AxisArrowStyle ArrowStyle
|
||
{
|
||
get
|
||
{
|
||
return _arrowStyle;
|
||
}
|
||
set
|
||
{
|
||
_arrowStyle = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the properties used for the major gridlines.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeGridTickMarks"),
|
||
Bindable(true),
|
||
NotifyParentPropertyAttribute(true),
|
||
SRDescription("DescriptionAttributeMajorGrid"),
|
||
#if Microsoft_CONTROL
|
||
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
||
#else
|
||
PersistenceMode(PersistenceMode.InnerProperty),
|
||
#endif
|
||
TypeConverter(typeof(NoNameExpandableObjectConverter))
|
||
]
|
||
public Grid MajorGrid
|
||
{
|
||
get
|
||
{
|
||
return majorGrid;
|
||
}
|
||
set
|
||
{
|
||
majorGrid = value;
|
||
majorGrid.Axis = this;
|
||
majorGrid.majorGridTick = true;
|
||
|
||
if (!majorGrid.intervalChanged)
|
||
majorGrid.Interval = double.NaN;
|
||
if (!majorGrid.intervalOffsetChanged)
|
||
majorGrid.IntervalOffset = double.NaN;
|
||
if (!majorGrid.intervalTypeChanged)
|
||
majorGrid.IntervalType = DateTimeIntervalType.NotSet;
|
||
if (!majorGrid.intervalOffsetTypeChanged)
|
||
majorGrid.IntervalOffsetType = DateTimeIntervalType.NotSet;
|
||
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the properties used for the minor gridlines.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeGridTickMarks"),
|
||
Bindable(true),
|
||
NotifyParentPropertyAttribute(true),
|
||
SRDescription("DescriptionAttributeMinorGrid"),
|
||
#if Microsoft_CONTROL
|
||
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
||
#else
|
||
PersistenceMode(PersistenceMode.InnerProperty),
|
||
#endif
|
||
TypeConverter(typeof(NoNameExpandableObjectConverter))
|
||
]
|
||
public Grid MinorGrid
|
||
{
|
||
get
|
||
{
|
||
return minorGrid;
|
||
}
|
||
set
|
||
{
|
||
minorGrid = value;
|
||
minorGrid.Initialize(this, false);
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the properties used for the major tick marks.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeGridTickMarks"),
|
||
Bindable(true),
|
||
NotifyParentPropertyAttribute(true),
|
||
SRDescription("DescriptionAttributeMajorTickMark"),
|
||
#if Microsoft_CONTROL
|
||
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
||
#else
|
||
PersistenceMode(PersistenceMode.InnerProperty),
|
||
#endif
|
||
TypeConverter(typeof(NoNameExpandableObjectConverter))
|
||
]
|
||
public TickMark MajorTickMark
|
||
{
|
||
get
|
||
{
|
||
return majorTickMark;
|
||
}
|
||
set
|
||
{
|
||
majorTickMark = value;
|
||
majorTickMark.Axis = this;
|
||
majorTickMark.majorGridTick = true;
|
||
|
||
if (!majorTickMark.intervalChanged)
|
||
majorTickMark.Interval = double.NaN;
|
||
if (!majorTickMark.intervalOffsetChanged)
|
||
majorTickMark.IntervalOffset = double.NaN;
|
||
if (!majorTickMark.intervalTypeChanged)
|
||
majorTickMark.IntervalType = DateTimeIntervalType.NotSet;
|
||
if (!majorTickMark.intervalOffsetTypeChanged)
|
||
majorTickMark.IntervalOffsetType = DateTimeIntervalType.NotSet;
|
||
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the properties used for the minor tick marks.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeGridTickMarks"),
|
||
Bindable(true),
|
||
NotifyParentPropertyAttribute(true),
|
||
SRDescription("DescriptionAttributeMinorTickMark"),
|
||
#if Microsoft_CONTROL
|
||
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
||
#else
|
||
PersistenceMode(PersistenceMode.InnerProperty),
|
||
#endif
|
||
TypeConverter(typeof(NoNameExpandableObjectConverter))
|
||
]
|
||
public TickMark MinorTickMark
|
||
{
|
||
get
|
||
{
|
||
return minorTickMark;
|
||
}
|
||
set
|
||
{
|
||
minorTickMark = value;
|
||
minorTickMark.Initialize(this, false);
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets a flag which indicates whether auto-fitting of labels is enabled.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeLabels"),
|
||
Bindable(true),
|
||
DefaultValue(true),
|
||
SRDescription("DescriptionAttributeLabelsAutoFit"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
#endif
|
||
RefreshPropertiesAttribute(RefreshProperties.All)
|
||
]
|
||
public bool IsLabelAutoFit
|
||
{
|
||
get
|
||
{
|
||
return _isLabelAutoFit;
|
||
}
|
||
set
|
||
{
|
||
_isLabelAutoFit = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// Gets or sets the minimum font size that can be used by
|
||
/// the label auto-fitting algorithm.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeLabels"),
|
||
Bindable(true),
|
||
DefaultValue(6),
|
||
SRDescription("DescriptionAttributeLabelsAutoFitMinFontSize"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
#endif
|
||
RefreshPropertiesAttribute(RefreshProperties.All)
|
||
]
|
||
public int LabelAutoFitMinFontSize
|
||
{
|
||
get
|
||
{
|
||
return this.labelAutoFitMinFontSize;
|
||
}
|
||
set
|
||
{
|
||
// Font size cannot be less than 5
|
||
if(value < 5)
|
||
{
|
||
throw (new InvalidOperationException(SR.ExceptionAxisLabelsAutoFitMinFontSizeValueInvalid));
|
||
}
|
||
|
||
this.labelAutoFitMinFontSize = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the maximum font size that can be used by
|
||
/// the label auto-fitting algorithm.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeLabels"),
|
||
Bindable(true),
|
||
DefaultValue(10),
|
||
SRDescription("DescriptionAttributeLabelsAutoFitMaxFontSize"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
#endif
|
||
RefreshPropertiesAttribute(RefreshProperties.All)
|
||
]
|
||
public int LabelAutoFitMaxFontSize
|
||
{
|
||
get
|
||
{
|
||
return this.labelAutoFitMaxFontSize;
|
||
}
|
||
set
|
||
{
|
||
// Font size cannot be less than 5
|
||
if(value < 5)
|
||
{
|
||
throw (new InvalidOperationException(SR.ExceptionAxisLabelsAutoFitMaxFontSizeInvalid));
|
||
}
|
||
|
||
this.labelAutoFitMaxFontSize = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// Gets or sets the auto-fitting style used for the labels.
|
||
/// IsLabelAutoFit must be set to true.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeLabels"),
|
||
Bindable(true),
|
||
DefaultValue(LabelAutoFitStyles.DecreaseFont | LabelAutoFitStyles.IncreaseFont | LabelAutoFitStyles.LabelsAngleStep30 | LabelAutoFitStyles.StaggeredLabels | LabelAutoFitStyles.WordWrap),
|
||
SRDescription("DescriptionAttributeLabelsAutoFitStyle"),
|
||
NotifyParentPropertyAttribute(true),
|
||
Editor(Editors.FlagsEnumUITypeEditor.Editor, Editors.FlagsEnumUITypeEditor.Base),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
#endif
|
||
]
|
||
public LabelAutoFitStyles LabelAutoFitStyle
|
||
{
|
||
get
|
||
{
|
||
return this._labelAutoFitStyle;
|
||
}
|
||
set
|
||
{
|
||
this._labelAutoFitStyle = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets a flag which indicates whether
|
||
/// tick marks and labels move with the axis when
|
||
/// the crossing value changes.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
DefaultValue(true),
|
||
SRDescription("DescriptionAttributeMarksNextToAxis"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
virtual public bool IsMarksNextToAxis
|
||
{
|
||
get
|
||
{
|
||
return _isMarksNextToAxis;
|
||
}
|
||
set
|
||
{
|
||
_isMarksNextToAxis = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the axis title.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeTitle"),
|
||
Bindable(true),
|
||
DefaultValue(""),
|
||
SRDescription("DescriptionAttributeTitle6"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public string Title
|
||
{
|
||
get
|
||
{
|
||
return _title;
|
||
}
|
||
set
|
||
{
|
||
_title = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the color of the axis title.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeTitle"),
|
||
Bindable(true),
|
||
DefaultValue(typeof(Color), "Black"),
|
||
SRDescription("DescriptionAttributeTitleColor"),
|
||
NotifyParentPropertyAttribute(true),
|
||
TypeConverter(typeof(ColorConverter)),
|
||
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public Color TitleForeColor
|
||
{
|
||
get
|
||
{
|
||
return _titleForeColor;
|
||
}
|
||
set
|
||
{
|
||
_titleForeColor = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the alignment of the axis title.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeTitle"),
|
||
Bindable(true),
|
||
DefaultValue(typeof(StringAlignment), "Center"),
|
||
SRDescription("DescriptionAttributeTitleAlignment"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public StringAlignment TitleAlignment
|
||
{
|
||
get
|
||
{
|
||
return _titleAlignment;
|
||
}
|
||
set
|
||
{
|
||
_titleAlignment = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the font used for the axis title.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeTitle"),
|
||
Bindable(true),
|
||
DefaultValue(typeof(Font), "Microsoft Sans Serif, 8pt"),
|
||
SRDescription("DescriptionAttributeTitleFont"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public Font TitleFont
|
||
{
|
||
get
|
||
{
|
||
return _titleFont;
|
||
}
|
||
set
|
||
{
|
||
_titleFont = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the line color of the axis.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
DefaultValue(typeof(Color), "Black"),
|
||
SRDescription("DescriptionAttributeLineColor"),
|
||
NotifyParentPropertyAttribute(true),
|
||
TypeConverter(typeof(ColorConverter)),
|
||
Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public Color LineColor
|
||
{
|
||
get
|
||
{
|
||
return _lineColor;
|
||
}
|
||
set
|
||
{
|
||
_lineColor = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the line width of the axis.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
DefaultValue(1),
|
||
SRDescription("DescriptionAttributeLineWidth"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public int LineWidth
|
||
{
|
||
get
|
||
{
|
||
return _lineWidth;
|
||
}
|
||
set
|
||
{
|
||
if (value < 0)
|
||
{
|
||
throw (new ArgumentOutOfRangeException("value", SR.ExceptionAxisWidthIsNegative));
|
||
}
|
||
_lineWidth = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the line style of the axis.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
DefaultValue(ChartDashStyle.Solid),
|
||
SRDescription("DescriptionAttributeLineDashStyle"),
|
||
NotifyParentPropertyAttribute(true),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public ChartDashStyle LineDashStyle
|
||
{
|
||
get
|
||
{
|
||
return _lineDashStyle;
|
||
}
|
||
set
|
||
{
|
||
_lineDashStyle = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// The collection of strip lines of the axis.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeAppearance"),
|
||
Bindable(true),
|
||
SRDescription("DescriptionAttributeStripLines"),
|
||
#if Microsoft_CONTROL
|
||
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
||
#else
|
||
PersistenceMode(PersistenceMode.InnerProperty),
|
||
#endif
|
||
Editor(Editors.ChartCollectionEditor.Editor, Editors.ChartCollectionEditor.Base)
|
||
]
|
||
public StripLinesCollection StripLines
|
||
{
|
||
get
|
||
{
|
||
return _stripLines;
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Gets or sets the maximum size (in percentage) of the axis used in the automatic layout algorithm.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// This property determines the maximum size of the axis, measured as a percentage of the chart area.
|
||
/// </remarks>
|
||
[
|
||
SRCategory("CategoryAttributeLabels"),
|
||
DefaultValue(75f),
|
||
SRDescription("DescriptionAttributeAxis_MaxAutoSize"),
|
||
]
|
||
public float MaximumAutoSize
|
||
{
|
||
get
|
||
{
|
||
return this._maximumAutoSize;
|
||
}
|
||
set
|
||
{
|
||
if (value < 0f || value > 100f)
|
||
{
|
||
throw (new ArgumentOutOfRangeException("value", SR.ExceptionValueMustBeInRange("MaximumAutoSize", "0", "100")));
|
||
}
|
||
this._maximumAutoSize = value;
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region IMapAreaAttributes Properties implementation
|
||
|
||
/// <summary>
|
||
/// Tooltip of the axis.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeMapArea"),
|
||
Bindable(true),
|
||
SRDescription("DescriptionAttributeToolTip"),
|
||
DefaultValue(""),
|
||
]
|
||
public string ToolTip
|
||
{
|
||
set
|
||
{
|
||
this._toolTip = value;
|
||
}
|
||
get
|
||
{
|
||
return this._toolTip;
|
||
}
|
||
}
|
||
|
||
#if !Microsoft_CONTROL
|
||
|
||
/// <summary>
|
||
/// URL target of the axis.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeMapArea"),
|
||
Bindable(true),
|
||
SRDescription("DescriptionAttributeUrl"),
|
||
DefaultValue(""),
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
Editor(Editors.UrlValueEditor.Editor, Editors.UrlValueEditor.Base)
|
||
]
|
||
public string Url
|
||
{
|
||
set
|
||
{
|
||
this._url = value;
|
||
}
|
||
get
|
||
{
|
||
return this._url;
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Gets or sets the map area attributes.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeMapArea"),
|
||
Bindable(true),
|
||
SRDescription("DescriptionAttributeMapAreaAttributes"),
|
||
DefaultValue(""),
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
]
|
||
public string MapAreaAttributes
|
||
{
|
||
set
|
||
{
|
||
this._mapAreaAttributes = value;
|
||
}
|
||
get
|
||
{
|
||
return this._mapAreaAttributes;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets or sets the postback value which can be processed on click event.
|
||
/// </summary>
|
||
/// <value>The value which is passed to click event as argument.</value>
|
||
[DefaultValue("")]
|
||
[SRCategory(SR.Keys.CategoryAttributeMapArea)]
|
||
[SRDescription(SR.Keys.DescriptionAttributePostBackValue)]
|
||
public string PostBackValue
|
||
{
|
||
get
|
||
{
|
||
return this._postbackValue;
|
||
}
|
||
set
|
||
{
|
||
this._postbackValue = value;
|
||
}
|
||
}
|
||
|
||
|
||
#endif // !Microsoft_CONTROL
|
||
|
||
|
||
|
||
#endregion
|
||
|
||
#region Axis Interavl properies
|
||
|
||
/// <summary>
|
||
/// Axis interval size.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeInterval"),
|
||
Bindable(true),
|
||
DefaultValue(0.0),
|
||
SRDescription("DescriptionAttributeInterval4"),
|
||
RefreshPropertiesAttribute(RefreshProperties.All),
|
||
TypeConverter(typeof(AxisIntervalValueConverter)),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
#endif
|
||
]
|
||
public double Interval
|
||
{
|
||
get
|
||
{
|
||
return interval;
|
||
}
|
||
set
|
||
{
|
||
// Axis interval properties must be set
|
||
if (double.IsNaN(value))
|
||
{
|
||
interval = 0;
|
||
}
|
||
else
|
||
{
|
||
interval = value;
|
||
}
|
||
|
||
// Reset initial values
|
||
majorGrid.interval = tempMajorGridInterval;
|
||
majorTickMark.interval = tempMajorTickMarkInterval;
|
||
minorGrid.interval = tempMinorGridInterval;
|
||
minorTickMark.interval = tempMinorTickMarkInterval;
|
||
labelStyle.interval = tempLabelInterval;
|
||
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Axis interval offset.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeInterval"),
|
||
Bindable(true),
|
||
DefaultValue(0.0),
|
||
SRDescription("DescriptionAttributeIntervalOffset6"),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute),
|
||
#endif
|
||
RefreshPropertiesAttribute(RefreshProperties.All),
|
||
TypeConverter(typeof(AxisIntervalValueConverter))
|
||
]
|
||
public double IntervalOffset
|
||
{
|
||
get
|
||
{
|
||
return _intervalOffset;
|
||
}
|
||
set
|
||
{
|
||
// Axis interval properties must be set
|
||
if (double.IsNaN(value))
|
||
{
|
||
_intervalOffset = 0;
|
||
}
|
||
else
|
||
{
|
||
_intervalOffset = value;
|
||
}
|
||
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Axis interval type.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeInterval"),
|
||
Bindable(true),
|
||
DefaultValue(DateTimeIntervalType.Auto),
|
||
SRDescription("DescriptionAttributeIntervalType4"),
|
||
RefreshPropertiesAttribute(RefreshProperties.All),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public DateTimeIntervalType IntervalType
|
||
{
|
||
get
|
||
{
|
||
return intervalType;
|
||
}
|
||
set
|
||
{
|
||
// Axis interval properties must be set
|
||
if (value == DateTimeIntervalType.NotSet)
|
||
{
|
||
intervalType = DateTimeIntervalType.Auto;
|
||
}
|
||
else
|
||
{
|
||
intervalType = value;
|
||
}
|
||
|
||
// Reset initial values
|
||
majorGrid.intervalType = tempGridIntervalType;
|
||
majorTickMark.intervalType = tempTickMarkIntervalType;
|
||
labelStyle.intervalType = tempLabelIntervalType;
|
||
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Axis interval offset type.
|
||
/// </summary>
|
||
[
|
||
SRCategory("CategoryAttributeInterval"),
|
||
Bindable(true),
|
||
DefaultValue(DateTimeIntervalType.Auto),
|
||
SRDescription("DescriptionAttributeIntervalOffsetType4"),
|
||
RefreshPropertiesAttribute(RefreshProperties.All),
|
||
#if !Microsoft_CONTROL
|
||
PersistenceMode(PersistenceMode.Attribute)
|
||
#endif
|
||
]
|
||
public DateTimeIntervalType IntervalOffsetType
|
||
{
|
||
get
|
||
{
|
||
return intervalOffsetType;
|
||
}
|
||
set
|
||
{
|
||
// Axis interval properties must be set
|
||
if (value == DateTimeIntervalType.NotSet)
|
||
{
|
||
intervalOffsetType = DateTimeIntervalType.Auto;
|
||
}
|
||
else
|
||
{
|
||
intervalOffsetType = value;
|
||
}
|
||
|
||
this.Invalidate();
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Axis painting methods
|
||
|
||
/// <summary>
|
||
/// Checks if Common.Chart axis title is drawn vertically.
|
||
/// Note: From the drawing perspective stacked text orientation is not vertical.
|
||
/// </summary>
|
||
/// <returns>True if text is vertical.</returns>
|
||
private bool IsTextVertical
|
||
{
|
||
get
|
||
{
|
||
TextOrientation currentTextOrientation = this.GetTextOrientation();
|
||
return currentTextOrientation == TextOrientation.Rotated90 || currentTextOrientation == TextOrientation.Rotated270;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns axis title text orientation. If set to Auto automatically determines the
|
||
/// orientation based on the axis position.
|
||
/// </summary>
|
||
/// <returns>Current text orientation.</returns>
|
||
private TextOrientation GetTextOrientation()
|
||
{
|
||
if (this.TextOrientation == TextOrientation.Auto)
|
||
{
|
||
if (this.AxisPosition == AxisPosition.Left)
|
||
{
|
||
return TextOrientation.Rotated270;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
{
|
||
return TextOrientation.Rotated90;
|
||
}
|
||
return TextOrientation.Horizontal;
|
||
}
|
||
return this.TextOrientation;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Paint Axis elements on the back of the 3D scene.
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
internal void PrePaint(ChartGraphics graph)
|
||
{
|
||
if (enabled != false)
|
||
{
|
||
// draw axis hot region
|
||
DrawAxisLineHotRegion(graph, true);
|
||
|
||
// Paint Major Tick Marks
|
||
majorTickMark.Paint(graph, true);
|
||
|
||
// Paint Minor Tick Marks
|
||
minorTickMark.Paint(graph, true);
|
||
|
||
// Draw axis line
|
||
DrawAxisLine(graph, true);
|
||
|
||
// Paint Labels
|
||
labelStyle.Paint(graph, true);
|
||
}
|
||
|
||
#if SUBAXES
|
||
// Process all sub-axis
|
||
if(!ChartArea.Area3DStyle.Enable3D &&
|
||
!ChartArea.chartAreaIsCurcular)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.PrePaint( graph );
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
}
|
||
|
||
/// <summary>
|
||
/// Paint Axis
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
internal void Paint(ChartGraphics graph)
|
||
{
|
||
// Only Y axis is drawn in the circular Common.Chart area
|
||
if (ChartArea != null && ChartArea.chartAreaIsCurcular)
|
||
{
|
||
// Y circular axes
|
||
if (this.axisType == AxisName.Y && enabled != false)
|
||
{
|
||
ICircularChartType chartType = ChartArea.GetCircularChartType();
|
||
if (chartType != null)
|
||
{
|
||
Matrix oldMatrix = graph.Transform;
|
||
float[] axesLocation = chartType.GetYAxisLocations(ChartArea);
|
||
bool drawLabels = true;
|
||
foreach (float curentSector in axesLocation)
|
||
{
|
||
// Set graphics rotation matrix
|
||
Matrix newMatrix = oldMatrix.Clone();
|
||
newMatrix.RotateAt(
|
||
curentSector,
|
||
graph.GetAbsolutePoint(ChartArea.circularCenter));
|
||
graph.Transform = newMatrix;
|
||
|
||
// draw axis hot region
|
||
DrawAxisLineHotRegion(graph, false);
|
||
|
||
// Paint Minor Tick Marks
|
||
minorTickMark.Paint(graph, false);
|
||
|
||
// Paint Major Tick Marks
|
||
majorTickMark.Paint(graph, false);
|
||
|
||
// Draw axis line
|
||
DrawAxisLine(graph, false);
|
||
|
||
// Only first Y axis has labels
|
||
if (drawLabels)
|
||
{
|
||
drawLabels = false;
|
||
|
||
// Save current font angle
|
||
int currentAngle = labelStyle.Angle;
|
||
|
||
// Set labels text angle
|
||
if (labelStyle.Angle == 0)
|
||
{
|
||
if (curentSector >= 45f && curentSector <= 180f)
|
||
{
|
||
labelStyle.angle = -90;
|
||
}
|
||
else if (curentSector > 180f && curentSector <= 315f)
|
||
{
|
||
labelStyle.angle = 90;
|
||
}
|
||
}
|
||
|
||
// Draw labels
|
||
labelStyle.Paint(graph, false);
|
||
|
||
// Restore font angle
|
||
labelStyle.angle = currentAngle;
|
||
}
|
||
}
|
||
|
||
graph.Transform = oldMatrix;
|
||
}
|
||
}
|
||
|
||
// X circular axes
|
||
if (this.axisType == AxisName.X && enabled != false)
|
||
{
|
||
labelStyle.PaintCircular(graph);
|
||
}
|
||
|
||
DrawAxisTitle(graph);
|
||
|
||
return;
|
||
}
|
||
|
||
// If axis is disabled draw only Title
|
||
if (enabled != false)
|
||
{
|
||
|
||
// draw axis hot region
|
||
DrawAxisLineHotRegion(graph, false);
|
||
|
||
// Paint Minor Tick Marks
|
||
minorTickMark.Paint(graph, false);
|
||
|
||
// Paint Major Tick Marks
|
||
majorTickMark.Paint(graph, false);
|
||
|
||
// Draw axis line
|
||
DrawAxisLine(graph, false);
|
||
|
||
// Paint Labels
|
||
labelStyle.Paint(graph, false);
|
||
|
||
#if Microsoft_CONTROL
|
||
|
||
// Scroll bar is supoorted only in 2D charts
|
||
if (ChartArea != null && ChartArea.Area3DStyle.Enable3D == false)
|
||
{
|
||
// Draw axis scroll bar
|
||
ScrollBar.Paint(graph);
|
||
}
|
||
#endif // Microsoft_CONTROL
|
||
|
||
}
|
||
|
||
// Draw axis title
|
||
this.DrawAxisTitle(graph);
|
||
|
||
#if SUBAXES
|
||
// Process all sub-axis
|
||
if(ChartArea.IsSubAxesSupported)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.Paint( graph );
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
// Reset temp axis offset for side-by-side charts like column
|
||
this.ResetTempAxisOffset();
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// Paint Axis element when segmented axis scale feature is used.
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
internal void PaintOnSegmentedScalePassOne( ChartGraphics graph )
|
||
{
|
||
// If axis is disabled draw only Title
|
||
if( enabled != false )
|
||
{
|
||
// Paint Minor Tick Marks
|
||
minorTickMark.Paint( graph, false );
|
||
|
||
// Paint Major Tick Marks
|
||
majorTickMark.Paint( graph, false );
|
||
}
|
||
|
||
#if SUBAXES
|
||
// Process all sub-axis
|
||
if(ChartArea.IsSubAxesSupported)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.PaintOnSegmentedScalePassOne( graph );
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Paint Axis element when segmented axis scale feature is used.
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
internal void PaintOnSegmentedScalePassTwo( ChartGraphics graph )
|
||
{
|
||
// If axis is disabled draw only Title
|
||
if( enabled != false )
|
||
{
|
||
// Draw axis line
|
||
DrawAxisLine( graph, false );
|
||
|
||
// Paint Labels
|
||
labelStyle.Paint( graph, false);
|
||
}
|
||
|
||
// Draw axis title
|
||
this.DrawAxisTitle( graph );
|
||
|
||
// Reset temp axis offset for side-by-side charts like column
|
||
this.ResetTempAxisOffset();
|
||
|
||
#if SUBAXES
|
||
// Process all sub-axis
|
||
if(ChartArea.IsSubAxesSupported)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.PaintOnSegmentedScalePassTwo( graph );
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Draw axis title
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
private void DrawAxisTitle(ChartGraphics graph)
|
||
{
|
||
if (!this.enabled)
|
||
return;
|
||
|
||
// Draw axis title
|
||
if (this.Title.Length > 0)
|
||
{
|
||
Matrix oldTransform = null;
|
||
|
||
// Draw title in 3D
|
||
if (ChartArea.Area3DStyle.Enable3D && !ChartArea.chartAreaIsCurcular)
|
||
{
|
||
DrawAxis3DTitle(graph);
|
||
return;
|
||
}
|
||
|
||
string axisTitle = this.Title;
|
||
|
||
//******************************************************
|
||
//** Check axis position
|
||
//******************************************************
|
||
float axisPosition = (float)this.GetAxisPosition();
|
||
if (this.AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
if (!this.GetIsMarksNextToAxis())
|
||
{
|
||
axisPosition = ChartArea.PlotAreaPosition.Bottom;
|
||
}
|
||
axisPosition = ChartArea.PlotAreaPosition.Bottom - axisPosition;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
if (!this.GetIsMarksNextToAxis())
|
||
{
|
||
axisPosition = ChartArea.PlotAreaPosition.Y;
|
||
}
|
||
axisPosition = axisPosition - ChartArea.PlotAreaPosition.Y;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
{
|
||
if (!this.GetIsMarksNextToAxis())
|
||
{
|
||
axisPosition = ChartArea.PlotAreaPosition.Right;
|
||
}
|
||
axisPosition = ChartArea.PlotAreaPosition.Right - axisPosition;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Left)
|
||
{
|
||
if (!this.GetIsMarksNextToAxis())
|
||
{
|
||
axisPosition = ChartArea.PlotAreaPosition.X;
|
||
}
|
||
axisPosition = axisPosition - ChartArea.PlotAreaPosition.X;
|
||
}
|
||
|
||
//******************************************************
|
||
//** Adjust axis elements size with axis position
|
||
//******************************************************
|
||
// Calculate total size of axis elements
|
||
float axisSize = this.markSize + this.labelSize;
|
||
axisSize -= axisPosition;
|
||
if (axisSize < 0)
|
||
{
|
||
axisSize = 0;
|
||
}
|
||
// Set title alignment
|
||
using (StringFormat format = new StringFormat())
|
||
{
|
||
format.Alignment = this.TitleAlignment;
|
||
format.Trimming = StringTrimming.EllipsisCharacter;
|
||
// VSTS #144398
|
||
// We need to have the StringFormatFlags set to FitBlackBox as othwerwise axis titles using Fonts like
|
||
// "Algerian" or "Forte" are completly clipped (= not drawn) due to the fact that MeasureString returns
|
||
// a bounding rectangle that is too small.
|
||
format.FormatFlags |= StringFormatFlags.FitBlackBox;
|
||
|
||
// Calculate title rectangle
|
||
_titlePosition = ChartArea.PlotAreaPosition.ToRectangleF();
|
||
float titleSizeWithoutSpacing = this.titleSize - elementSpacing;
|
||
if (this.AxisPosition == AxisPosition.Left)
|
||
{
|
||
_titlePosition.X = ChartArea.PlotAreaPosition.X - titleSizeWithoutSpacing - axisSize;
|
||
_titlePosition.Y = ChartArea.PlotAreaPosition.Y;
|
||
|
||
if (!this.IsTextVertical)
|
||
{
|
||
SizeF axisTitleSize = new SizeF(titleSizeWithoutSpacing, ChartArea.PlotAreaPosition.Height);
|
||
_titlePosition.Width = axisTitleSize.Width;
|
||
_titlePosition.Height = axisTitleSize.Height;
|
||
|
||
format.Alignment = StringAlignment.Center;
|
||
if (this.TitleAlignment == StringAlignment.Far)
|
||
{
|
||
format.LineAlignment = StringAlignment.Near;
|
||
}
|
||
else if (this.TitleAlignment == StringAlignment.Near)
|
||
{
|
||
format.LineAlignment = StringAlignment.Far;
|
||
}
|
||
else
|
||
{
|
||
format.LineAlignment = StringAlignment.Center;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
SizeF axisTitleSize = graph.GetAbsoluteSize(new SizeF(titleSizeWithoutSpacing, ChartArea.PlotAreaPosition.Height));
|
||
axisTitleSize = graph.GetRelativeSize(new SizeF(axisTitleSize.Height, axisTitleSize.Width));
|
||
|
||
_titlePosition.Width = axisTitleSize.Width;
|
||
_titlePosition.Height = axisTitleSize.Height;
|
||
|
||
_titlePosition.Y += ChartArea.PlotAreaPosition.Height / 2f - _titlePosition.Height / 2f;
|
||
_titlePosition.X += titleSizeWithoutSpacing / 2f - _titlePosition.Width / 2f;
|
||
|
||
// Set graphics rotation transformation
|
||
oldTransform = this.SetRotationTransformation(graph, _titlePosition);
|
||
|
||
// Set alignment
|
||
format.LineAlignment = StringAlignment.Center;
|
||
}
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
{
|
||
_titlePosition.X = ChartArea.PlotAreaPosition.Right + axisSize;
|
||
_titlePosition.Y = ChartArea.PlotAreaPosition.Y;
|
||
|
||
if (!this.IsTextVertical)
|
||
{
|
||
SizeF axisTitleSize = new SizeF(titleSizeWithoutSpacing, ChartArea.PlotAreaPosition.Height);
|
||
_titlePosition.Width = axisTitleSize.Width;
|
||
_titlePosition.Height = axisTitleSize.Height;
|
||
|
||
format.Alignment = StringAlignment.Center;
|
||
if (this.TitleAlignment == StringAlignment.Far)
|
||
{
|
||
format.LineAlignment = StringAlignment.Near;
|
||
}
|
||
else if (this.TitleAlignment == StringAlignment.Near)
|
||
{
|
||
format.LineAlignment = StringAlignment.Far;
|
||
}
|
||
else
|
||
{
|
||
format.LineAlignment = StringAlignment.Center;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
SizeF axisTitleSize = graph.GetAbsoluteSize(new SizeF(titleSizeWithoutSpacing, ChartArea.PlotAreaPosition.Height));
|
||
axisTitleSize = graph.GetRelativeSize(new SizeF(axisTitleSize.Height, axisTitleSize.Width));
|
||
|
||
_titlePosition.Width = axisTitleSize.Width;
|
||
_titlePosition.Height = axisTitleSize.Height;
|
||
|
||
_titlePosition.Y += ChartArea.PlotAreaPosition.Height / 2f - _titlePosition.Height / 2f;
|
||
_titlePosition.X += titleSizeWithoutSpacing / 2f - _titlePosition.Width / 2f;
|
||
|
||
// Set graphics rotation transformation
|
||
oldTransform = this.SetRotationTransformation(graph, _titlePosition);
|
||
|
||
// Set alignment
|
||
format.LineAlignment = StringAlignment.Center;
|
||
}
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
_titlePosition.Y = ChartArea.PlotAreaPosition.Y - titleSizeWithoutSpacing - axisSize;
|
||
_titlePosition.Height = titleSizeWithoutSpacing;
|
||
_titlePosition.X = ChartArea.PlotAreaPosition.X;
|
||
_titlePosition.Width = ChartArea.PlotAreaPosition.Width;
|
||
|
||
if (this.IsTextVertical)
|
||
{
|
||
// Set graphics rotation transformation
|
||
oldTransform = this.SetRotationTransformation(graph, _titlePosition);
|
||
}
|
||
|
||
// Set alignment
|
||
format.LineAlignment = StringAlignment.Center;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
_titlePosition.Y = ChartArea.PlotAreaPosition.Bottom + axisSize;
|
||
_titlePosition.Height = titleSizeWithoutSpacing;
|
||
_titlePosition.X = ChartArea.PlotAreaPosition.X;
|
||
_titlePosition.Width = ChartArea.PlotAreaPosition.Width;
|
||
|
||
if (this.IsTextVertical)
|
||
{
|
||
// Set graphics rotation transformation
|
||
oldTransform = this.SetRotationTransformation(graph, _titlePosition);
|
||
}
|
||
|
||
// Set alignment
|
||
format.LineAlignment = StringAlignment.Center;
|
||
}
|
||
|
||
#if DEBUG
|
||
// TESTING CODE: Shows labels rectangle position.
|
||
// RectangleF rr = graph.GetAbsoluteRectangle(_titlePosition);
|
||
// graph.DrawRectangle(Pens.Blue, rr.X, rr.Y, rr.Width, rr.Height);
|
||
#endif // DEBUG
|
||
|
||
// Draw title
|
||
using (Brush brush = new SolidBrush(this.TitleForeColor))
|
||
{
|
||
graph.DrawStringRel(
|
||
axisTitle.Replace("\\n", "\n"),
|
||
this.TitleFont,
|
||
brush,
|
||
_titlePosition,
|
||
format,
|
||
this.GetTextOrientation());
|
||
}
|
||
}
|
||
|
||
// Process selection regions
|
||
if (this.Common.ProcessModeRegions)
|
||
{
|
||
// NOTE: Solves Issue #4423
|
||
// Transform title position coordinates using curent Graphics matrix
|
||
RectangleF transformedTitlePosition = graph.GetAbsoluteRectangle(_titlePosition);
|
||
PointF[] rectPoints = new PointF[] {
|
||
new PointF(transformedTitlePosition.X, transformedTitlePosition.Y),
|
||
new PointF(transformedTitlePosition.Right, transformedTitlePosition.Bottom) };
|
||
graph.Transform.TransformPoints(rectPoints);
|
||
transformedTitlePosition = new RectangleF(
|
||
rectPoints[0].X,
|
||
rectPoints[0].Y,
|
||
rectPoints[1].X - rectPoints[0].X,
|
||
rectPoints[1].Y - rectPoints[0].Y);
|
||
if (transformedTitlePosition.Width < 0)
|
||
{
|
||
transformedTitlePosition.Width = Math.Abs(transformedTitlePosition.Width);
|
||
transformedTitlePosition.X -= transformedTitlePosition.Width;
|
||
}
|
||
if (transformedTitlePosition.Height < 0)
|
||
{
|
||
transformedTitlePosition.Height = Math.Abs(transformedTitlePosition.Height);
|
||
transformedTitlePosition.Y -= transformedTitlePosition.Height;
|
||
}
|
||
|
||
// Add hot region
|
||
this.Common.HotRegionsList.AddHotRegion(
|
||
transformedTitlePosition, this, ChartElementType.AxisTitle, false, false);
|
||
}
|
||
|
||
// Restore old transformation
|
||
if (oldTransform != null)
|
||
{
|
||
graph.Transform = oldTransform;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Helper method which sets 90 or -90 degrees transformation in the middle of the
|
||
/// specified rectangle. It is used to draw title text rotated 90 or 270 degrees.
|
||
/// </summary>
|
||
/// <param name="graph">Chart graphics to apply transformation for.</param>
|
||
/// <param name="titlePosition">Title position.</param>
|
||
/// <returns>Old graphics transformation matrix.</returns>
|
||
private Matrix SetRotationTransformation(ChartGraphics graph, RectangleF titlePosition)
|
||
{
|
||
// Save old graphics transformation
|
||
Matrix oldTransform = graph.Transform.Clone();
|
||
|
||
// Rotate left tile 90 degrees at center
|
||
PointF center = PointF.Empty;
|
||
center.X = titlePosition.X + titlePosition.Width / 2F;
|
||
center.Y = titlePosition.Y + titlePosition.Height / 2F;
|
||
|
||
// Create and set new transformation matrix
|
||
float angle = (this.GetTextOrientation() == TextOrientation.Rotated90) ? 90f : -90f;
|
||
Matrix newMatrix = graph.Transform.Clone();
|
||
newMatrix.RotateAt(angle, graph.GetAbsolutePoint(center));
|
||
graph.Transform = newMatrix;
|
||
|
||
return oldTransform;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Draws a radial line in circular Common.Chart area.
|
||
/// </summary>
|
||
/// <param name="obj">Object requesting the painting.</param>
|
||
/// <param name="graph">Graphics path.</param>
|
||
/// <param name="color">Line color.</param>
|
||
/// <param name="width">Line width.</param>
|
||
/// <param name="style">Line style.</param>
|
||
/// <param name="position">X axis circular position.</param>
|
||
internal void DrawRadialLine(
|
||
object obj,
|
||
ChartGraphics graph,
|
||
Color color,
|
||
int width,
|
||
ChartDashStyle style,
|
||
double position)
|
||
{
|
||
// Create circle position rectangle
|
||
RectangleF rect = ChartArea.PlotAreaPosition.ToRectangleF();
|
||
rect = graph.GetAbsoluteRectangle(rect);
|
||
|
||
// Make sure the rectangle width equals rectangle height for the circle
|
||
if (rect.Width != rect.Height)
|
||
{
|
||
if (rect.Width > rect.Height)
|
||
{
|
||
rect.X += (rect.Width - rect.Height) / 2f;
|
||
rect.Width = rect.Height;
|
||
}
|
||
else
|
||
{
|
||
rect.Y += (rect.Height - rect.Width) / 2f;
|
||
rect.Height = rect.Width;
|
||
}
|
||
}
|
||
|
||
// Convert axis position to angle
|
||
float angle = ChartArea.CircularPositionToAngle(position);
|
||
|
||
// Set clipping region to the polygon
|
||
Region oldRegion = null;
|
||
if (ChartArea.CircularUsePolygons)
|
||
{
|
||
oldRegion = graph.Clip;
|
||
graph.Clip = new Region(graph.GetPolygonCirclePath(rect, ChartArea.CircularSectorsNumber));
|
||
}
|
||
|
||
// Get center point
|
||
PointF centerPoint = graph.GetAbsolutePoint(ChartArea.circularCenter);
|
||
|
||
// Set graphics rotation matrix
|
||
Matrix oldMatrix = graph.Transform;
|
||
Matrix newMatrix = oldMatrix.Clone();
|
||
newMatrix.RotateAt(
|
||
angle,
|
||
centerPoint);
|
||
graph.Transform = newMatrix;
|
||
|
||
// Draw Line
|
||
PointF endPoint = new PointF(rect.X + rect.Width / 2f, rect.Y);
|
||
graph.DrawLineAbs(color, width, style, centerPoint, endPoint);
|
||
|
||
// Process selection regions
|
||
if (this.Common.ProcessModeRegions)
|
||
{
|
||
using (GraphicsPath path = new GraphicsPath())
|
||
{
|
||
path.AddLine(centerPoint, endPoint);
|
||
path.Transform(newMatrix);
|
||
try
|
||
{
|
||
using (Pen pen = new Pen(Color.Black, width + 2))
|
||
{
|
||
path.Widen(pen);
|
||
this.Common.HotRegionsList.AddHotRegion(path, false, ChartElementType.Gridlines, obj);
|
||
}
|
||
}
|
||
catch (OutOfMemoryException)
|
||
{
|
||
// GraphicsPath.Widen incorrectly throws OutOfMemoryException
|
||
// catching here and reacting by not widening
|
||
}
|
||
catch (ArgumentException)
|
||
{
|
||
}
|
||
}
|
||
}
|
||
|
||
// Restore graphics
|
||
graph.Transform = oldMatrix;
|
||
newMatrix.Dispose();
|
||
|
||
// Restore clip region
|
||
if (ChartArea.CircularUsePolygons)
|
||
{
|
||
graph.Clip = oldRegion;
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Draws a circular line in circular Common.Chart area.
|
||
/// </summary>
|
||
/// <param name="obj">Object requesting the painting.</param>
|
||
/// <param name="graph">Graphics path.</param>
|
||
/// <param name="color">Line color.</param>
|
||
/// <param name="width">Line width.</param>
|
||
/// <param name="style">Line style.</param>
|
||
/// <param name="position">Line position.</param>
|
||
internal void DrawCircularLine(
|
||
object obj,
|
||
ChartGraphics graph,
|
||
Color color,
|
||
int width,
|
||
ChartDashStyle style,
|
||
float position
|
||
)
|
||
{
|
||
// Create circle position rectangle
|
||
RectangleF rect = ChartArea.PlotAreaPosition.ToRectangleF();
|
||
rect = graph.GetAbsoluteRectangle(rect);
|
||
|
||
// Make sure the rectangle width equals rectangle height for the circle
|
||
if (rect.Width != rect.Height)
|
||
{
|
||
if (rect.Width > rect.Height)
|
||
{
|
||
rect.X += (rect.Width - rect.Height) / 2f;
|
||
rect.Width = rect.Height;
|
||
}
|
||
else
|
||
{
|
||
rect.Y += (rect.Height - rect.Width) / 2f;
|
||
rect.Height = rect.Width;
|
||
}
|
||
}
|
||
|
||
// Inflate rectangle
|
||
PointF absPoint = graph.GetAbsolutePoint(new PointF(position, position));
|
||
float rectInflate = absPoint.Y - rect.Top;
|
||
rect.Inflate(-rectInflate, -rectInflate);
|
||
|
||
// Create circle pen
|
||
Pen circlePen = new Pen(color, width);
|
||
circlePen.DashStyle = graph.GetPenStyle(style);
|
||
|
||
// Draw circle
|
||
if (ChartArea.CircularUsePolygons)
|
||
{
|
||
// Draw eaqula sides polygon
|
||
graph.DrawCircleAbs(circlePen, null, rect, ChartArea.CircularSectorsNumber, false);
|
||
}
|
||
else
|
||
{
|
||
graph.DrawEllipse(circlePen, rect);
|
||
}
|
||
|
||
// Process selection regions
|
||
if (this.Common.ProcessModeRegions)
|
||
{
|
||
// Bounding rectangle must be more than 1 pixel by 1 pixel
|
||
if (rect.Width >= 1f && rect.Height > 1)
|
||
{
|
||
GraphicsPath path = null;
|
||
try
|
||
{
|
||
if (ChartArea.CircularUsePolygons)
|
||
{
|
||
path = graph.GetPolygonCirclePath(rect, ChartArea.CircularSectorsNumber);
|
||
}
|
||
else
|
||
{
|
||
path = new GraphicsPath();
|
||
path.AddEllipse(rect);
|
||
}
|
||
circlePen.Width += 2;
|
||
path.Widen(circlePen);
|
||
this.Common.HotRegionsList.AddHotRegion(path, false, ChartElementType.Gridlines, obj);
|
||
}
|
||
catch (OutOfMemoryException)
|
||
{
|
||
// GraphicsPath.Widen incorrectly throws OutOfMemoryException
|
||
// catching here and reacting by not widening
|
||
}
|
||
catch (ArgumentException)
|
||
{
|
||
}
|
||
finally
|
||
{
|
||
path.Dispose();
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Draw axis title in 3D.
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
private void DrawAxis3DTitle(ChartGraphics graph)
|
||
{
|
||
// Do not draw title if axis is not enabled
|
||
if (!this.enabled)
|
||
{
|
||
return;
|
||
}
|
||
|
||
string axisTitle = this.Title;
|
||
|
||
// Draw axis title
|
||
PointF rotationCenter = PointF.Empty;
|
||
int angle = 0;
|
||
|
||
// Set title alignment
|
||
using (StringFormat format = new StringFormat())
|
||
{
|
||
format.Alignment = this.TitleAlignment;
|
||
format.Trimming = StringTrimming.EllipsisCharacter;
|
||
format.FormatFlags |= StringFormatFlags.LineLimit;
|
||
|
||
// Measure title size for non-centered aligment
|
||
SizeF realTitleSize = graph.MeasureString(axisTitle.Replace("\\n", "\n"), this.TitleFont, new SizeF(10000f, 10000f), format, this.GetTextOrientation());
|
||
SizeF axisTitleSize = SizeF.Empty;
|
||
if (format.Alignment != StringAlignment.Center)
|
||
{
|
||
axisTitleSize = realTitleSize;
|
||
if (this.IsTextVertical)
|
||
{
|
||
// Switch height and width for vertical axis
|
||
float tempValue = axisTitleSize.Height;
|
||
axisTitleSize.Height = axisTitleSize.Width;
|
||
axisTitleSize.Width = tempValue;
|
||
}
|
||
|
||
// Get relative size
|
||
axisTitleSize = graph.GetRelativeSize(axisTitleSize);
|
||
|
||
// Change format aligment for the reversed mode
|
||
if (ChartArea.ReverseSeriesOrder)
|
||
{
|
||
if (format.Alignment == StringAlignment.Near)
|
||
{
|
||
format.Alignment = StringAlignment.Far;
|
||
}
|
||
else
|
||
{
|
||
format.Alignment = StringAlignment.Near;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Set text rotation angle based on the text orientation
|
||
if (this.GetTextOrientation() == TextOrientation.Rotated90)
|
||
{
|
||
angle = 90;
|
||
}
|
||
else if (this.GetTextOrientation() == TextOrientation.Rotated270)
|
||
{
|
||
angle = -90;
|
||
}
|
||
|
||
// Calculate title center point on the axis
|
||
if (this.AxisPosition == AxisPosition.Left)
|
||
{
|
||
rotationCenter = new PointF(ChartArea.PlotAreaPosition.X, ChartArea.PlotAreaPosition.Y + ChartArea.PlotAreaPosition.Height / 2f);
|
||
if (format.Alignment == StringAlignment.Near)
|
||
{
|
||
rotationCenter.Y = ChartArea.PlotAreaPosition.Bottom - axisTitleSize.Height / 2f;
|
||
}
|
||
else if (format.Alignment == StringAlignment.Far)
|
||
{
|
||
rotationCenter.Y = ChartArea.PlotAreaPosition.Y + axisTitleSize.Height / 2f;
|
||
}
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
{
|
||
rotationCenter = new PointF(ChartArea.PlotAreaPosition.Right, ChartArea.PlotAreaPosition.Y + ChartArea.PlotAreaPosition.Height / 2f);
|
||
if (format.Alignment == StringAlignment.Near)
|
||
{
|
||
rotationCenter.Y = ChartArea.PlotAreaPosition.Bottom - axisTitleSize.Height / 2f;
|
||
}
|
||
else if (format.Alignment == StringAlignment.Far)
|
||
{
|
||
rotationCenter.Y = ChartArea.PlotAreaPosition.Y + axisTitleSize.Height / 2f;
|
||
}
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
rotationCenter = new PointF(ChartArea.PlotAreaPosition.X + ChartArea.PlotAreaPosition.Width / 2f, ChartArea.PlotAreaPosition.Y);
|
||
if (format.Alignment == StringAlignment.Near)
|
||
{
|
||
rotationCenter.X = ChartArea.PlotAreaPosition.X + axisTitleSize.Width / 2f;
|
||
}
|
||
else if (format.Alignment == StringAlignment.Far)
|
||
{
|
||
rotationCenter.X = ChartArea.PlotAreaPosition.Right - axisTitleSize.Width / 2f;
|
||
}
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
rotationCenter = new PointF(ChartArea.PlotAreaPosition.X + ChartArea.PlotAreaPosition.Width / 2f, ChartArea.PlotAreaPosition.Bottom);
|
||
if (format.Alignment == StringAlignment.Near)
|
||
{
|
||
rotationCenter.X = ChartArea.PlotAreaPosition.X + axisTitleSize.Width / 2f;
|
||
}
|
||
else if (format.Alignment == StringAlignment.Far)
|
||
{
|
||
rotationCenter.X = ChartArea.PlotAreaPosition.Right - axisTitleSize.Width / 2f;
|
||
}
|
||
}
|
||
|
||
// Transform center of title coordinates and calculate axis angle
|
||
bool isOnEdge = false;
|
||
float zPosition = this.GetMarksZPosition(out isOnEdge);
|
||
Point3D[] rotationCenterPoints = null;
|
||
float angleAxis = 0;
|
||
if (this.AxisPosition == AxisPosition.Top || this.AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
rotationCenterPoints = new Point3D[] {
|
||
new Point3D(rotationCenter.X, rotationCenter.Y, zPosition),
|
||
new Point3D(rotationCenter.X - 20f, rotationCenter.Y, zPosition) };
|
||
|
||
// Transform coordinates of text rotation point
|
||
ChartArea.matrix3D.TransformPoints(rotationCenterPoints);
|
||
rotationCenter = rotationCenterPoints[0].PointF;
|
||
|
||
// Get absolute coordinates
|
||
rotationCenterPoints[0].PointF = graph.GetAbsolutePoint(rotationCenterPoints[0].PointF);
|
||
rotationCenterPoints[1].PointF = graph.GetAbsolutePoint(rotationCenterPoints[1].PointF);
|
||
|
||
// Calculate X axis angle
|
||
angleAxis = (float)Math.Atan(
|
||
(rotationCenterPoints[1].Y - rotationCenterPoints[0].Y) /
|
||
(rotationCenterPoints[1].X - rotationCenterPoints[0].X));
|
||
}
|
||
else
|
||
{
|
||
rotationCenterPoints = new Point3D[] {
|
||
new Point3D(rotationCenter.X, rotationCenter.Y, zPosition),
|
||
new Point3D(rotationCenter.X, rotationCenter.Y - 20f, zPosition) };
|
||
|
||
// Transform coordinates of text rotation point
|
||
ChartArea.matrix3D.TransformPoints(rotationCenterPoints);
|
||
rotationCenter = rotationCenterPoints[0].PointF;
|
||
|
||
// Get absolute coordinates
|
||
rotationCenterPoints[0].PointF = graph.GetAbsolutePoint(rotationCenterPoints[0].PointF);
|
||
rotationCenterPoints[1].PointF = graph.GetAbsolutePoint(rotationCenterPoints[1].PointF);
|
||
|
||
// Calculate Y axis angle
|
||
if (rotationCenterPoints[1].Y != rotationCenterPoints[0].Y)
|
||
{
|
||
angleAxis = -(float)Math.Atan(
|
||
(rotationCenterPoints[1].X - rotationCenterPoints[0].X) /
|
||
(rotationCenterPoints[1].Y - rotationCenterPoints[0].Y));
|
||
}
|
||
}
|
||
angle += (int)Math.Round(angleAxis * 180f / (float)Math.PI);
|
||
|
||
|
||
// Calculate title center offset from the axis line
|
||
float offset = this.labelSize + this.markSize + this.titleSize / 2f;
|
||
float dX = 0f, dY = 0f;
|
||
|
||
|
||
// Adjust center of title with labels, marker and title size
|
||
if (this.AxisPosition == AxisPosition.Left)
|
||
{
|
||
dX = (float)(offset * Math.Cos(angleAxis));
|
||
rotationCenter.X -= dX;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
{
|
||
dX = (float)(offset * Math.Cos(angleAxis));
|
||
rotationCenter.X += dX;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
dY = (float)(offset * Math.Cos(angleAxis));
|
||
dX = (float)(offset * Math.Sin(angleAxis));
|
||
rotationCenter.Y -= dY;
|
||
if (dY > 0)
|
||
{
|
||
rotationCenter.X += dX;
|
||
}
|
||
else
|
||
{
|
||
rotationCenter.X -= dX;
|
||
}
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
dY = (float)(offset * Math.Cos(angleAxis));
|
||
dX = (float)(offset * Math.Sin(angleAxis));
|
||
rotationCenter.Y += dY;
|
||
if (dY > 0)
|
||
{
|
||
rotationCenter.X -= dX;
|
||
}
|
||
else
|
||
{
|
||
rotationCenter.X += dX;
|
||
}
|
||
}
|
||
|
||
|
||
// Always align text in the center
|
||
format.LineAlignment = StringAlignment.Center;
|
||
format.Alignment = StringAlignment.Center;
|
||
// SQL VSTS Fix #259954, Dev10: 591135 Windows 7 crashes on empty transformation.
|
||
if (rotationCenter.IsEmpty || float.IsNaN(rotationCenter.X) || float.IsNaN(rotationCenter.Y))
|
||
{
|
||
return;
|
||
}
|
||
|
||
// Draw 3D title
|
||
using (Brush brush = new SolidBrush(this.TitleForeColor))
|
||
{
|
||
graph.DrawStringRel(
|
||
axisTitle.Replace("\\n", "\n"),
|
||
this.TitleFont,
|
||
brush,
|
||
rotationCenter,
|
||
format,
|
||
angle,
|
||
this.GetTextOrientation());
|
||
}
|
||
|
||
// Add hot region
|
||
if (Common.ProcessModeRegions)
|
||
{
|
||
using (GraphicsPath hotPath = graph.GetTranformedTextRectPath(rotationCenter, realTitleSize, angle))
|
||
{
|
||
this.Common.HotRegionsList.AddHotRegion(hotPath, false, ChartElementType.AxisTitle, this);
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Select Axis line
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics</param>
|
||
/// <param name="backElements">Back elements of the axis should be drawn in 3D scene.</param>
|
||
internal void DrawAxisLine(ChartGraphics graph, bool backElements)
|
||
{
|
||
Axis opositeAxis;
|
||
ArrowOrientation arrowOrientation = ArrowOrientation.Top;
|
||
PointF first = Point.Empty;
|
||
PointF second = Point.Empty;
|
||
|
||
// Set the position of axis
|
||
switch (AxisPosition)
|
||
{
|
||
|
||
case AxisPosition.Left:
|
||
|
||
first.X = (float)GetAxisPosition();
|
||
first.Y = PlotAreaPosition.Bottom;
|
||
second.X = (float)GetAxisPosition();
|
||
second.Y = PlotAreaPosition.Y;
|
||
if (isReversed)
|
||
arrowOrientation = ArrowOrientation.Bottom;
|
||
else
|
||
arrowOrientation = ArrowOrientation.Top;
|
||
|
||
break;
|
||
|
||
case AxisPosition.Right:
|
||
|
||
first.X = (float)GetAxisPosition();
|
||
first.Y = PlotAreaPosition.Bottom;
|
||
second.X = (float)GetAxisPosition();
|
||
second.Y = PlotAreaPosition.Y;
|
||
if (isReversed)
|
||
arrowOrientation = ArrowOrientation.Bottom;
|
||
else
|
||
arrowOrientation = ArrowOrientation.Top;
|
||
|
||
break;
|
||
|
||
case AxisPosition.Bottom:
|
||
|
||
first.X = PlotAreaPosition.X;
|
||
first.Y = (float)GetAxisPosition();
|
||
second.X = PlotAreaPosition.Right;
|
||
second.Y = (float)GetAxisPosition();
|
||
if (isReversed)
|
||
arrowOrientation = ArrowOrientation.Left;
|
||
else
|
||
arrowOrientation = ArrowOrientation.Right;
|
||
|
||
break;
|
||
|
||
case AxisPosition.Top:
|
||
|
||
first.X = PlotAreaPosition.X;
|
||
first.Y = (float)GetAxisPosition();
|
||
second.X = PlotAreaPosition.Right;
|
||
second.Y = (float)GetAxisPosition();
|
||
if (isReversed)
|
||
arrowOrientation = ArrowOrientation.Left;
|
||
else
|
||
arrowOrientation = ArrowOrientation.Right;
|
||
|
||
break;
|
||
|
||
}
|
||
|
||
// Update axis line position for circular area
|
||
if (ChartArea.chartAreaIsCurcular)
|
||
{
|
||
first.Y = PlotAreaPosition.Y + PlotAreaPosition.Height / 2f;
|
||
}
|
||
|
||
|
||
if (Common.ProcessModePaint)
|
||
{
|
||
if (!ChartArea.Area3DStyle.Enable3D || ChartArea.chartAreaIsCurcular)
|
||
{
|
||
|
||
// Start Svg/Flash Selection mode
|
||
graph.StartHotRegion( this._url, _toolTip );
|
||
|
||
// Draw the line
|
||
graph.DrawLineRel(_lineColor, _lineWidth, _lineDashStyle, first, second);
|
||
|
||
// End Svg/Flash Selection mode
|
||
graph.EndHotRegion( );
|
||
|
||
// Opposite axis. Arrow uses this axis to find
|
||
// a shift from Common.Chart area border. This shift
|
||
// depend on Tick mark size.
|
||
switch (arrowOrientation)
|
||
{
|
||
case ArrowOrientation.Left:
|
||
opositeAxis = ChartArea.AxisX;
|
||
break;
|
||
case ArrowOrientation.Right:
|
||
opositeAxis = ChartArea.AxisX2;
|
||
break;
|
||
case ArrowOrientation.Top:
|
||
opositeAxis = ChartArea.AxisY2;
|
||
break;
|
||
case ArrowOrientation.Bottom:
|
||
opositeAxis = ChartArea.AxisY;
|
||
break;
|
||
default:
|
||
opositeAxis = ChartArea.AxisX;
|
||
break;
|
||
}
|
||
|
||
// Draw arrow
|
||
PointF arrowPosition;
|
||
if (isReversed)
|
||
arrowPosition = first;
|
||
else
|
||
arrowPosition = second;
|
||
|
||
// Draw Arrow
|
||
graph.DrawArrowRel(arrowPosition, arrowOrientation, _arrowStyle, _lineColor, _lineWidth, _lineDashStyle, opositeAxis.majorTickMark.Size, _lineWidth);
|
||
}
|
||
else
|
||
{
|
||
Draw3DAxisLine(graph, first, second, (this.AxisPosition == AxisPosition.Top || this.AxisPosition == AxisPosition.Bottom), backElements);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Draws the axis line hot region.
|
||
/// </summary>
|
||
/// <param name="graph">The graph.</param>
|
||
/// <param name="backElements">set to <c>true</c> if we draw back elements.</param>
|
||
private void DrawAxisLineHotRegion(ChartGraphics graph, bool backElements)
|
||
{
|
||
if (Common.ProcessModeRegions)
|
||
{
|
||
//VSTS #229835: During the 3D rendering the axis is drawn twice:
|
||
//1. In PrePaint() both axis and backelements (labels) are drawn.
|
||
//2. In Paint() the axis is redrawn without labels and as a result it creates a second hot region which covered the labels' hotregions.
|
||
//In order to avoid this we have to suppress the hotregion drawing in the Paint using the backElements flag (it's false during the Paint)
|
||
//The circular charts and 2D charts are drawn only once in Paint() so we draw the hot regions.
|
||
if (backElements || !ChartArea.Area3DStyle.Enable3D || ChartArea.chartAreaIsCurcular)
|
||
{
|
||
DrawAxisLineHotRegion(graph);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Adds the axis hot region
|
||
/// </summary>
|
||
/// <param name="graph">The chart graphics instance.</param>
|
||
private void DrawAxisLineHotRegion(ChartGraphics graph)
|
||
{
|
||
using (GraphicsPath path = new GraphicsPath())
|
||
{
|
||
// Find the topLeft(first) and bottomRight(second) points of the hotregion rectangle
|
||
PointF first = PointF.Empty;
|
||
PointF second = PointF.Empty;
|
||
float axisPosition = (float)GetAxisPosition();
|
||
|
||
switch (this.AxisPosition)
|
||
{
|
||
case AxisPosition.Left:
|
||
first.X = axisPosition - (labelSize + markSize);
|
||
first.Y = PlotAreaPosition.Y;
|
||
second.X = axisPosition;
|
||
second.Y = PlotAreaPosition.Bottom;
|
||
break;
|
||
|
||
case AxisPosition.Right:
|
||
first.X = axisPosition;
|
||
first.Y = PlotAreaPosition.Y;
|
||
second.X = axisPosition + labelSize + markSize;
|
||
second.Y = PlotAreaPosition.Bottom;
|
||
break;
|
||
|
||
case AxisPosition.Bottom:
|
||
first.X = PlotAreaPosition.X;
|
||
first.Y = axisPosition;
|
||
second.X = PlotAreaPosition.Right;
|
||
second.Y = axisPosition + labelSize + markSize;
|
||
break;
|
||
|
||
case AxisPosition.Top:
|
||
first.X = PlotAreaPosition.X;
|
||
first.Y = axisPosition - (labelSize + markSize);
|
||
second.X = PlotAreaPosition.Right;
|
||
second.Y = axisPosition;
|
||
break;
|
||
}
|
||
|
||
// Update axis line position for circular area
|
||
if (ChartArea.chartAreaIsCurcular)
|
||
{
|
||
second.Y = PlotAreaPosition.Y + PlotAreaPosition.Height / 2f;
|
||
}
|
||
|
||
// Create rectangle and inflate it
|
||
RectangleF rect = new RectangleF(first.X, first.Y, second.X - first.X, second.Y - first.Y);
|
||
SizeF size = graph.GetRelativeSize(new SizeF(3, 3));
|
||
|
||
if (AxisPosition == AxisPosition.Top || AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
rect.Inflate(2, size.Height);
|
||
}
|
||
else
|
||
{
|
||
rect.Inflate(size.Width, 2);
|
||
}
|
||
|
||
// Get the rectangle points
|
||
PointF[] points = new PointF[] {
|
||
new PointF(rect.Left, rect.Top),
|
||
new PointF(rect.Right, rect.Top),
|
||
new PointF(rect.Right, rect.Bottom),
|
||
new PointF(rect.Left, rect.Bottom)};
|
||
|
||
// If we are dealing with the 3D - transform the rectangle
|
||
if (ChartArea.Area3DStyle.Enable3D && !ChartArea.chartAreaIsCurcular)
|
||
{
|
||
Boolean axisOnEdge = false;
|
||
float zPositon = GetMarksZPosition(out axisOnEdge);
|
||
|
||
// Convert points to 3D
|
||
Point3D[] points3D = new Point3D[points.Length];
|
||
for (int i = 0; i < points.Length; i++)
|
||
{
|
||
points3D[i] = new Point3D(points[i].X, points[i].Y, zPositon);
|
||
}
|
||
|
||
// Transform
|
||
ChartArea.matrix3D.TransformPoints(points3D);
|
||
|
||
// Convert to 2D
|
||
for (int i = 0; i < points3D.Length; i++)
|
||
{
|
||
points[i] = points3D[i].PointF;
|
||
}
|
||
}
|
||
|
||
// Transform points to absolute cooordinates
|
||
for (int i = 0; i < points.Length; i++)
|
||
{
|
||
points[i] = graph.GetAbsolutePoint(points[i]);
|
||
}
|
||
|
||
// Add the points to the path
|
||
path.AddPolygon(points);
|
||
|
||
|
||
#if Microsoft_CONTROL
|
||
Common.HotRegionsList.AddHotRegion(
|
||
graph,
|
||
path,
|
||
false,
|
||
this._toolTip,
|
||
string.Empty,
|
||
string.Empty,
|
||
string.Empty,
|
||
this,
|
||
ChartElementType.Axis);
|
||
#else
|
||
Common.HotRegionsList.AddHotRegion(
|
||
graph,
|
||
path,
|
||
false,
|
||
this._toolTip,
|
||
this._url,
|
||
this._mapAreaAttributes,
|
||
this.PostBackValue,
|
||
this,
|
||
ChartElementType.Axis);
|
||
#endif
|
||
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Draws axis line in 3D space.
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object.</param>
|
||
/// <param name="point1">First line point.</param>
|
||
/// <param name="point2">Second line point.</param>
|
||
/// <param name="horizontal">Indicates that tick mark line is horizontal</param>
|
||
/// <param name="backElements">Only back elements of axis should be drawn.</param>
|
||
private void Draw3DAxisLine(
|
||
ChartGraphics graph,
|
||
PointF point1,
|
||
PointF point2,
|
||
bool horizontal,
|
||
bool backElements
|
||
)
|
||
{
|
||
// Check if axis is positioned on the plot area adge
|
||
bool onEdge = this.IsAxisOnAreaEdge;
|
||
|
||
// Check if axis tick marks are drawn inside plotting area
|
||
bool tickMarksOnEdge = onEdge;
|
||
if (tickMarksOnEdge &&
|
||
this.MajorTickMark.TickMarkStyle == TickMarkStyle.AcrossAxis ||
|
||
this.MajorTickMark.TickMarkStyle == TickMarkStyle.InsideArea ||
|
||
this.MinorTickMark.TickMarkStyle == TickMarkStyle.AcrossAxis ||
|
||
this.MinorTickMark.TickMarkStyle == TickMarkStyle.InsideArea)
|
||
{
|
||
tickMarksOnEdge = false;
|
||
}
|
||
|
||
// Make sure first point of axis coordinates has smaller values
|
||
if ((horizontal && point1.X > point2.X) ||
|
||
(!horizontal && point1.Y > point2.Y))
|
||
{
|
||
PointF tempPoint = new PointF(point1.X, point1.Y);
|
||
point1.X = point2.X;
|
||
point1.Y = point2.Y;
|
||
point2 = tempPoint;
|
||
}
|
||
|
||
// Check if the front/back wall is on the top drawing layer
|
||
float zPositon = ChartArea.IsMainSceneWallOnFront() ? ChartArea.areaSceneDepth : 0f;
|
||
SurfaceNames surfName = ChartArea.IsMainSceneWallOnFront() ? SurfaceNames.Front : SurfaceNames.Back;
|
||
if (ChartArea.ShouldDrawOnSurface(SurfaceNames.Back, backElements, tickMarksOnEdge))
|
||
{
|
||
|
||
// Start Svg Selection mode
|
||
graph.StartHotRegion( this._url, _toolTip );
|
||
|
||
// Draw axis line on the back/front wall
|
||
graph.Draw3DLine(
|
||
ChartArea.matrix3D,
|
||
_lineColor, _lineWidth, _lineDashStyle,
|
||
new Point3D(point1.X, point1.Y, zPositon),
|
||
new Point3D(point2.X, point2.Y, zPositon),
|
||
Common,
|
||
this,
|
||
ChartElementType.Nothing
|
||
);
|
||
|
||
// End Svg Selection mode
|
||
graph.EndHotRegion();
|
||
|
||
}
|
||
|
||
// Check if the back wall is on the top drawing layer
|
||
zPositon = ChartArea.IsMainSceneWallOnFront() ? 0f : ChartArea.areaSceneDepth;
|
||
surfName = ChartArea.IsMainSceneWallOnFront() ? SurfaceNames.Back : SurfaceNames.Front;
|
||
if (ChartArea.ShouldDrawOnSurface(surfName, backElements, tickMarksOnEdge))
|
||
{
|
||
// Draw axis line on the front wall
|
||
if (!onEdge ||
|
||
(this.AxisPosition == AxisPosition.Bottom && ChartArea.IsBottomSceneWallVisible()) ||
|
||
(this.AxisPosition == AxisPosition.Left && ChartArea.IsSideSceneWallOnLeft()) ||
|
||
(this.AxisPosition == AxisPosition.Right && !ChartArea.IsSideSceneWallOnLeft()))
|
||
{
|
||
|
||
// Start Svg Selection mode
|
||
graph.StartHotRegion( this._url, _toolTip );
|
||
|
||
graph.Draw3DLine(
|
||
ChartArea.matrix3D,
|
||
_lineColor, _lineWidth, _lineDashStyle,
|
||
new Point3D(point1.X, point1.Y, zPositon),
|
||
new Point3D(point2.X, point2.Y, zPositon),
|
||
Common,
|
||
this,
|
||
ChartElementType.Nothing
|
||
);
|
||
|
||
// End Svg Selection mode
|
||
graph.EndHotRegion();
|
||
|
||
}
|
||
}
|
||
|
||
// Check if the left/top wall is on the top drawing layer
|
||
SurfaceNames surfaceName = (this.AxisPosition == AxisPosition.Left || this.AxisPosition == AxisPosition.Right) ? SurfaceNames.Top : SurfaceNames.Left;
|
||
if (ChartArea.ShouldDrawOnSurface(surfaceName, backElements, tickMarksOnEdge))
|
||
{
|
||
// Draw axis line on the left/top side walls
|
||
if (!onEdge ||
|
||
(this.AxisPosition == AxisPosition.Bottom && (ChartArea.IsBottomSceneWallVisible() || ChartArea.IsSideSceneWallOnLeft())) ||
|
||
(this.AxisPosition == AxisPosition.Left && ChartArea.IsSideSceneWallOnLeft()) ||
|
||
(this.AxisPosition == AxisPosition.Right && !ChartArea.IsSideSceneWallOnLeft()) ||
|
||
(this.AxisPosition == AxisPosition.Top && ChartArea.IsSideSceneWallOnLeft()))
|
||
{
|
||
|
||
// Start Svg Selection mode
|
||
graph.StartHotRegion( this._url, _toolTip );
|
||
|
||
graph.Draw3DLine(
|
||
ChartArea.matrix3D,
|
||
_lineColor, _lineWidth, _lineDashStyle,
|
||
new Point3D(point1.X, point1.Y, ChartArea.areaSceneDepth),
|
||
new Point3D(point1.X, point1.Y, 0f),
|
||
Common,
|
||
this,
|
||
ChartElementType.Nothing
|
||
);
|
||
|
||
// End Svg Selection mode
|
||
graph.EndHotRegion( );
|
||
|
||
}
|
||
}
|
||
|
||
// Check if the right/bottom wall is on the top drawing layer
|
||
surfaceName = (this.AxisPosition == AxisPosition.Left || this.AxisPosition == AxisPosition.Right) ? SurfaceNames.Bottom : SurfaceNames.Right;
|
||
if (ChartArea.ShouldDrawOnSurface(surfaceName, backElements, tickMarksOnEdge))
|
||
{
|
||
// Draw axis line on the bottom/right side walls
|
||
if (!onEdge ||
|
||
(this.AxisPosition == AxisPosition.Bottom && (ChartArea.IsBottomSceneWallVisible() || !ChartArea.IsSideSceneWallOnLeft())) ||
|
||
(this.AxisPosition == AxisPosition.Left && (ChartArea.IsSideSceneWallOnLeft() || ChartArea.IsBottomSceneWallVisible())) ||
|
||
(this.AxisPosition == AxisPosition.Right && (!ChartArea.IsSideSceneWallOnLeft() || ChartArea.IsBottomSceneWallVisible())) ||
|
||
(this.AxisPosition == AxisPosition.Top && !ChartArea.IsSideSceneWallOnLeft())
|
||
)
|
||
{
|
||
|
||
// Start Svg Selection mode
|
||
graph.StartHotRegion( this._url, _toolTip );
|
||
|
||
graph.Draw3DLine(
|
||
ChartArea.matrix3D,
|
||
_lineColor, _lineWidth, _lineDashStyle,
|
||
new Point3D(point2.X, point2.Y, ChartArea.areaSceneDepth),
|
||
new Point3D(point2.X, point2.Y, 0f),
|
||
Common,
|
||
this,
|
||
ChartElementType.Nothing
|
||
);
|
||
|
||
// End Svg Selection mode
|
||
graph.EndHotRegion();
|
||
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets Z position of axis tick marks and labels.
|
||
/// </summary>
|
||
/// <param name="axisOnEdge">Returns true if axis is on the edge.</param>
|
||
/// <returns>Marks Z position.</returns>
|
||
internal float GetMarksZPosition(out bool axisOnEdge)
|
||
{
|
||
axisOnEdge = this.IsAxisOnAreaEdge;
|
||
if (!this.GetIsMarksNextToAxis())
|
||
{
|
||
// Marks are forced to be on the area edge
|
||
axisOnEdge = true;
|
||
}
|
||
float wallZPosition = 0f;
|
||
if (this.AxisPosition == AxisPosition.Bottom && (ChartArea.IsBottomSceneWallVisible() || !axisOnEdge))
|
||
{
|
||
wallZPosition = ChartArea.areaSceneDepth;
|
||
}
|
||
if (this.AxisPosition == AxisPosition.Left && (ChartArea.IsSideSceneWallOnLeft() || !axisOnEdge))
|
||
{
|
||
wallZPosition = ChartArea.areaSceneDepth;
|
||
}
|
||
if (this.AxisPosition == AxisPosition.Right && (!ChartArea.IsSideSceneWallOnLeft() || !axisOnEdge))
|
||
{
|
||
wallZPosition = ChartArea.areaSceneDepth;
|
||
}
|
||
if (this.AxisPosition == AxisPosition.Top && !axisOnEdge)
|
||
{
|
||
wallZPosition = ChartArea.areaSceneDepth;
|
||
}
|
||
|
||
// Check if front wall is shown
|
||
if (ChartArea.IsMainSceneWallOnFront())
|
||
{
|
||
// Switch Z position of tick mark
|
||
wallZPosition = (wallZPosition == 0f) ? ChartArea.areaSceneDepth : 0f;
|
||
}
|
||
|
||
return wallZPosition;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Paint Axis Grid lines
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
internal void PaintGrids(ChartGraphics graph)
|
||
{
|
||
object obj;
|
||
|
||
PaintGrids(graph, out obj);
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Paint Axis Grid lines or
|
||
/// hit test function for grid lines
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
/// <param name="obj">Returns selected grid object</param>
|
||
internal void PaintGrids(ChartGraphics graph, out object obj)
|
||
{
|
||
obj = null;
|
||
|
||
#if SUBAXES
|
||
// Paint grids of sub-axis
|
||
if(!ChartArea.Area3DStyle.Enable3D &&
|
||
!ChartArea.chartAreaIsCurcular)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.PaintGrids( graph, out obj);
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
// Axis is disabled
|
||
if (enabled == false)
|
||
return;
|
||
|
||
// Paint Minor grid lines
|
||
minorGrid.Paint(graph);
|
||
|
||
// Paint Major grid lines
|
||
majorGrid.Paint(graph);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Paint Axis Strip lines
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
/// <param name="drawLinesOnly">Indicates if Lines or Stripes should be drawn.</param>
|
||
internal void PaintStrips(ChartGraphics graph, bool drawLinesOnly)
|
||
{
|
||
object obj;
|
||
PaintStrips(graph, false, 0, 0, out obj, drawLinesOnly);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Paint Axis Strip lines or
|
||
/// hit test function for Strip lines
|
||
/// </summary>
|
||
/// <param name="graph">Reference to the Chart Graphics object</param>
|
||
/// <param name="selectionMode">The selection mode is active</param>
|
||
/// <param name="x">X coordinate</param>
|
||
/// <param name="y">Y coordinate</param>
|
||
/// <param name="obj">Returns selected grid object</param>
|
||
/// <param name="drawLinesOnly">Indicates if Lines or Stripes should be drawn.</param>
|
||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "y"),
|
||
System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "x"),
|
||
System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "selectionMode")]
|
||
internal void PaintStrips(ChartGraphics graph, bool selectionMode, int x, int y, out object obj, bool drawLinesOnly)
|
||
{
|
||
obj = null;
|
||
|
||
#if SUBAXES
|
||
// Paint strips of sub-axis
|
||
if(ChartArea.IsSubAxesSupported)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.PaintStrips( graph, selectionMode, x, y, out obj, drawLinesOnly);
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
// Axis is disabled
|
||
if (enabled == false)
|
||
return;
|
||
|
||
// Add axis isInterlaced strip lines into the collection
|
||
bool interlacedStripAdded = AddInterlacedStrip();
|
||
|
||
// Draw axis strips and lines
|
||
foreach (StripLine strip in this.StripLines)
|
||
{
|
||
strip.Paint(graph, this.Common, drawLinesOnly);
|
||
}
|
||
|
||
// Remove axis isInterlaced strip line from the collection after drawing
|
||
if (interlacedStripAdded)
|
||
{
|
||
// Remove isInterlaced strips which always is the first strip line
|
||
this.StripLines.RemoveAt(0);
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Helper function which adds temp. strip lines into the collection
|
||
/// to display isInterlaced lines in axis.
|
||
/// </summary>
|
||
private bool AddInterlacedStrip()
|
||
{
|
||
bool addStrip = false;
|
||
if (this.IsInterlaced)
|
||
{
|
||
StripLine stripLine = new StripLine();
|
||
stripLine.interlaced = true;
|
||
// VSTS fix of 164115 IsInterlaced StripLines with no border are rendered with black border, regression of VSTS 136763
|
||
stripLine.BorderColor = Color.Empty;
|
||
|
||
// Get interval from grid lines, tick marks or labels
|
||
if (this.MajorGrid.Enabled && this.MajorGrid.GetInterval() != 0.0)
|
||
{
|
||
addStrip = true;
|
||
stripLine.Interval = this.MajorGrid.GetInterval() * 2.0;
|
||
stripLine.IntervalType = this.MajorGrid.GetIntervalType();
|
||
stripLine.IntervalOffset = this.MajorGrid.GetIntervalOffset();
|
||
stripLine.IntervalOffsetType = this.MajorGrid.GetIntervalOffsetType();
|
||
stripLine.StripWidth = this.MajorGrid.GetInterval();
|
||
stripLine.StripWidthType = this.MajorGrid.GetIntervalType();
|
||
}
|
||
else if (this.MajorTickMark.Enabled && this.MajorTickMark.GetInterval() != 0.0)
|
||
{
|
||
addStrip = true;
|
||
stripLine.Interval = this.MajorTickMark.GetInterval() * 2.0;
|
||
stripLine.IntervalType = this.MajorTickMark.GetIntervalType();
|
||
stripLine.IntervalOffset = this.MajorTickMark.GetIntervalOffset();
|
||
stripLine.IntervalOffsetType = this.MajorTickMark.GetIntervalOffsetType();
|
||
stripLine.StripWidth = this.MajorTickMark.GetInterval();
|
||
stripLine.StripWidthType = this.MajorTickMark.GetIntervalType();
|
||
}
|
||
else if (this.LabelStyle.Enabled && this.LabelStyle.GetInterval() != 0.0)
|
||
{
|
||
addStrip = true;
|
||
stripLine.Interval = this.LabelStyle.GetInterval() * 2.0;
|
||
stripLine.IntervalType = this.LabelStyle.GetIntervalType();
|
||
stripLine.IntervalOffset = this.LabelStyle.GetIntervalOffset();
|
||
stripLine.IntervalOffsetType = this.LabelStyle.GetIntervalOffsetType();
|
||
stripLine.StripWidth = this.LabelStyle.GetInterval();
|
||
stripLine.StripWidthType = this.LabelStyle.GetIntervalType();
|
||
}
|
||
|
||
// Insert item into the strips collection
|
||
if (addStrip)
|
||
{
|
||
// Define stip color
|
||
if (this.InterlacedColor != Color.Empty)
|
||
{
|
||
stripLine.BackColor = this.InterlacedColor;
|
||
}
|
||
else
|
||
{
|
||
// If isInterlaced strips color is not set - use darker color of the area
|
||
if (ChartArea.BackColor == Color.Empty)
|
||
{
|
||
stripLine.BackColor = (ChartArea.Area3DStyle.Enable3D) ? Color.DarkGray : Color.LightGray;
|
||
}
|
||
else if (ChartArea.BackColor == Color.Transparent)
|
||
{
|
||
if (Common.Chart.BackColor != Color.Transparent && Common.Chart.BackColor != Color.Black)
|
||
{
|
||
stripLine.BackColor = ChartGraphics.GetGradientColor(Common.Chart.BackColor, Color.Black, 0.2);
|
||
}
|
||
else
|
||
{
|
||
stripLine.BackColor = Color.LightGray;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
stripLine.BackColor = ChartGraphics.GetGradientColor(ChartArea.BackColor, Color.Black, 0.2);
|
||
}
|
||
}
|
||
|
||
// Insert strip
|
||
this.StripLines.Insert(0, stripLine);
|
||
}
|
||
}
|
||
|
||
return addStrip;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Axis parameters recalculation and resizing methods
|
||
|
||
/// <summary>
|
||
/// This method will calculate the maximum and minimum values
|
||
/// using interval on the X axis automatically. It will make a gap between
|
||
/// data points and border of the Common.Chart area.
|
||
/// Note that this method can only be called for primary or secondary X axes.
|
||
/// </summary>
|
||
public void RoundAxisValues()
|
||
{
|
||
this.roundedXValues = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// RecalculateAxesScale axis.
|
||
/// </summary>
|
||
/// <param name="position">Plotting area position.</param>
|
||
internal void ReCalc(ElementPosition position)
|
||
{
|
||
PlotAreaPosition = position;
|
||
|
||
#if SUBAXES
|
||
|
||
// Recalculate all sub-axis
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.ReCalc( position );
|
||
}
|
||
#endif // SUBAXES
|
||
}
|
||
|
||
/// <summary>
|
||
/// This method store Axis values as minimum, maximum,
|
||
/// crossing, etc. Axis auto algorithm changes these
|
||
/// values and they have to be set to default values
|
||
/// after painting.
|
||
/// </summary>
|
||
internal void StoreAxisValues()
|
||
{
|
||
tempLabels = new CustomLabelsCollection(this);
|
||
foreach (CustomLabel label in CustomLabels)
|
||
{
|
||
tempLabels.Add(label.Clone());
|
||
}
|
||
|
||
paintMode = true;
|
||
|
||
// This field synchronies the Storing and
|
||
// resetting of temporary values
|
||
if (_storeValuesEnabled)
|
||
{
|
||
|
||
tempMaximum = maximum;
|
||
tempMinimum = minimum;
|
||
tempCrossing = crossing;
|
||
tempAutoMinimum = _autoMinimum;
|
||
tempAutoMaximum = _autoMaximum;
|
||
|
||
tempMajorGridInterval = majorGrid.interval;
|
||
tempMajorTickMarkInterval = majorTickMark.interval;
|
||
|
||
tempMinorGridInterval = minorGrid.interval;
|
||
tempMinorTickMarkInterval = minorTickMark.interval;
|
||
|
||
|
||
tempGridIntervalType = majorGrid.intervalType;
|
||
tempTickMarkIntervalType = majorTickMark.intervalType;
|
||
|
||
|
||
tempLabelInterval = labelStyle.interval;
|
||
tempLabelIntervalType = labelStyle.intervalType;
|
||
|
||
// Remember original ScaleView Position
|
||
this._originalViewPosition = this.ScaleView.Position;
|
||
|
||
// This field synchronies the Storing and
|
||
// resetting of temporary values
|
||
_storeValuesEnabled = false;
|
||
}
|
||
|
||
#if SUBAXES
|
||
|
||
// Store values of all sub-axis
|
||
if(ChartArea.IsSubAxesSupported)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.StoreAxisValues( );
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// This method reset Axis values as minimum, maximum,
|
||
/// crossing, etc. Axis auto algorithm changes these
|
||
/// values and they have to be set to default values
|
||
/// after painting.
|
||
/// </summary>
|
||
internal void ResetAxisValues()
|
||
{
|
||
// Paint mode is finished
|
||
paintMode = false;
|
||
|
||
#if Microsoft_CONTROL
|
||
if(Common.Chart == null)
|
||
{
|
||
#if SUBAXES
|
||
else if(this is SubAxis)
|
||
{
|
||
if( ((SubAxis)this).parentAxis != null)
|
||
{
|
||
this.Common = ((SubAxis)this).parentAxis.Common;
|
||
Common.Chart = ((SubAxis)this).parentAxis.Common.Chart;
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
}
|
||
if(Common.Chart != null && Common.Chart.Site != null && Common.Chart.Site.DesignMode)
|
||
{
|
||
ResetAutoValues();
|
||
}
|
||
#else
|
||
ResetAutoValues();
|
||
#endif
|
||
|
||
// Reset back original custom labels
|
||
if (tempLabels != null)
|
||
{
|
||
CustomLabels.Clear();
|
||
foreach (CustomLabel label in tempLabels)
|
||
{
|
||
CustomLabels.Add(label.Clone());
|
||
}
|
||
|
||
tempLabels = null;
|
||
}
|
||
|
||
#if SUBAXES
|
||
|
||
// Reset values of all sub-axis
|
||
if(ChartArea.IsSubAxesSupported)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.ResetAxisValues( );
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Reset auto calculated axis values
|
||
/// </summary>
|
||
internal void ResetAutoValues()
|
||
{
|
||
refreshMinMaxFromData = true;
|
||
maximum = tempMaximum;
|
||
minimum = tempMinimum;
|
||
crossing = tempCrossing;
|
||
_autoMinimum = tempAutoMinimum;
|
||
_autoMaximum = tempAutoMaximum;
|
||
|
||
majorGrid.interval = tempMajorGridInterval;
|
||
majorTickMark.interval = tempMajorTickMarkInterval;
|
||
|
||
minorGrid.interval = tempMinorGridInterval;
|
||
minorTickMark.interval = tempMinorTickMarkInterval;
|
||
|
||
|
||
labelStyle.interval = tempLabelInterval;
|
||
majorGrid.intervalType = tempGridIntervalType;
|
||
majorTickMark.intervalType = tempTickMarkIntervalType;
|
||
labelStyle.intervalType = tempLabelIntervalType;
|
||
|
||
// Restore original ScaleView Position
|
||
if (Common.Chart != null)
|
||
{
|
||
if (!Common.Chart.serializing)
|
||
{
|
||
this.ScaleView.Position = this._originalViewPosition;
|
||
}
|
||
}
|
||
|
||
// This field synchronies the Storing and
|
||
// resetting of temporary values
|
||
_storeValuesEnabled = true;
|
||
|
||
#if SUBAXES
|
||
|
||
// Reset auto values of all sub-axis
|
||
if(ChartArea.IsSubAxesSupported)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.ResetAutoValues( );
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Calculate size of the axis elements like title, labels and marks.
|
||
/// </summary>
|
||
/// <param name="chartGraph">Chart graphics object.</param>
|
||
/// <param name="chartAreaPosition">The Chart area position.</param>
|
||
/// <param name="plotArea">Plotting area size.</param>
|
||
/// <param name="axesNumber">Number of axis of the same orientation.</param>
|
||
/// <param name="autoPlotPosition">Indicates that inner plot position is automatic.</param>
|
||
virtual internal void Resize(
|
||
ChartGraphics chartGraph,
|
||
ElementPosition chartAreaPosition,
|
||
RectangleF plotArea,
|
||
float axesNumber,
|
||
bool autoPlotPosition)
|
||
{
|
||
#if SUBAXES
|
||
// Resize all sub-axis
|
||
if(ChartArea.IsSubAxesSupported)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.Resize(chartGraph, chartAreaPosition, plotArea, axesNumber, autoPlotPosition);
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
|
||
#if Microsoft_CONTROL
|
||
// Disable Common.Chart invalidation
|
||
bool oldDisableInvalidates = Common.Chart.disableInvalidates;
|
||
Common.Chart.disableInvalidates = true;
|
||
#endif //Microsoft_CONTROL
|
||
|
||
// Set Common.Chart area position
|
||
PlotAreaPosition = chartAreaPosition;
|
||
|
||
// Initialize plot area size
|
||
PlotAreaPosition.FromRectangleF(plotArea);
|
||
|
||
//******************************************************
|
||
//** Calculate axis title size
|
||
//******************************************************
|
||
this.titleSize = 0F;
|
||
if (this.Title.Length > 0)
|
||
{
|
||
// Measure axis title
|
||
SizeF titleStringSize = chartGraph.MeasureStringRel(this.Title.Replace("\\n", "\n"), this.TitleFont, new SizeF(10000f, 10000f), StringFormat.GenericTypographic, this.GetTextOrientation());
|
||
|
||
// Switch Width & Heigth for vertical axes
|
||
// If axis is horizontal
|
||
float maxTitlesize = 0;
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
maxTitlesize = (plotArea.Height / 100F) * (Axis.maxAxisTitleSize / axesNumber);
|
||
if (this.IsTextVertical)
|
||
{
|
||
this.titleSize = Math.Min(titleStringSize.Width, maxTitlesize);
|
||
}
|
||
else
|
||
{
|
||
this.titleSize = Math.Min(titleStringSize.Height, maxTitlesize);
|
||
}
|
||
}
|
||
// If axis is vertical
|
||
else
|
||
{
|
||
titleStringSize = chartGraph.GetAbsoluteSize(titleStringSize);
|
||
titleStringSize = chartGraph.GetRelativeSize(new SizeF(titleStringSize.Height, titleStringSize.Width));
|
||
maxTitlesize = (plotArea.Width / 100F) * (Axis.maxAxisTitleSize / axesNumber);
|
||
if (this.IsTextVertical)
|
||
{
|
||
this.titleSize = Math.Min(titleStringSize.Width, maxTitlesize);
|
||
}
|
||
else
|
||
{
|
||
this.titleSize = Math.Min(titleStringSize.Height, maxTitlesize);
|
||
}
|
||
}
|
||
}
|
||
if (this.titleSize > 0)
|
||
{
|
||
this.titleSize += elementSpacing;
|
||
}
|
||
|
||
//*********************************************************
|
||
//** Get arrow size of the opposite axis
|
||
//*********************************************************
|
||
float arrowSize = 0F;
|
||
SizeF arrowSizePrimary = SizeF.Empty;
|
||
SizeF arrowSizeSecondary = SizeF.Empty;
|
||
ArrowOrientation arrowOrientation = ArrowOrientation.Bottom;
|
||
if (this.axisType == AxisName.X || this.axisType == AxisName.X2)
|
||
{
|
||
if (ChartArea.AxisY.ArrowStyle != AxisArrowStyle.None)
|
||
{
|
||
arrowSizePrimary = ChartArea.AxisY.GetArrowSize(out arrowOrientation);
|
||
if (!IsArrowInAxis(arrowOrientation, this.AxisPosition))
|
||
{
|
||
arrowSizePrimary = SizeF.Empty;
|
||
}
|
||
}
|
||
|
||
if (ChartArea.AxisY2.ArrowStyle != AxisArrowStyle.None)
|
||
{
|
||
arrowSizeSecondary = ChartArea.AxisY2.GetArrowSize(out arrowOrientation);
|
||
if (!IsArrowInAxis(arrowOrientation, this.AxisPosition))
|
||
{
|
||
arrowSizeSecondary = SizeF.Empty;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (ChartArea.AxisX.ArrowStyle != AxisArrowStyle.None)
|
||
{
|
||
arrowSizePrimary = ChartArea.AxisX.GetArrowSize(out arrowOrientation);
|
||
if (!IsArrowInAxis(arrowOrientation, this.AxisPosition))
|
||
{
|
||
arrowSizePrimary = SizeF.Empty;
|
||
}
|
||
}
|
||
|
||
if (ChartArea.AxisX2.ArrowStyle != AxisArrowStyle.None)
|
||
{
|
||
arrowSizeSecondary = ChartArea.AxisX2.GetArrowSize(out arrowOrientation);
|
||
if (!IsArrowInAxis(arrowOrientation, this.AxisPosition))
|
||
{
|
||
arrowSizeSecondary = SizeF.Empty;
|
||
}
|
||
}
|
||
}
|
||
|
||
// If axis is horizontal
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
arrowSize = Math.Max(arrowSizePrimary.Height, arrowSizeSecondary.Height);
|
||
}
|
||
// If axis is vertical
|
||
else
|
||
{
|
||
arrowSize = Math.Max(arrowSizePrimary.Width, arrowSizeSecondary.Width);
|
||
}
|
||
|
||
//*********************************************************
|
||
//** Calculate axis tick marks, axis thickness, arrow size
|
||
//** and scroll bar size
|
||
//*********************************************************
|
||
this.markSize = 0F;
|
||
|
||
// Get major and minor tick marks sizes
|
||
float majorTickSize = 0;
|
||
if (this.MajorTickMark.Enabled && this.MajorTickMark.TickMarkStyle != TickMarkStyle.None)
|
||
{
|
||
if (this.MajorTickMark.TickMarkStyle == TickMarkStyle.InsideArea)
|
||
{
|
||
majorTickSize = 0F;
|
||
}
|
||
else if (this.MajorTickMark.TickMarkStyle == TickMarkStyle.AcrossAxis)
|
||
{
|
||
majorTickSize = this.MajorTickMark.Size / 2F;
|
||
}
|
||
else if (this.MajorTickMark.TickMarkStyle == TickMarkStyle.OutsideArea)
|
||
{
|
||
majorTickSize = this.MajorTickMark.Size;
|
||
}
|
||
}
|
||
|
||
float minorTickSize = 0;
|
||
if (this.MinorTickMark.Enabled && this.MinorTickMark.TickMarkStyle != TickMarkStyle.None && this.MinorTickMark.GetInterval() != 0)
|
||
{
|
||
if (this.MinorTickMark.TickMarkStyle == TickMarkStyle.InsideArea)
|
||
{
|
||
minorTickSize = 0F;
|
||
}
|
||
else if (this.MinorTickMark.TickMarkStyle == TickMarkStyle.AcrossAxis)
|
||
{
|
||
minorTickSize = this.MinorTickMark.Size / 2F;
|
||
}
|
||
else if (this.MinorTickMark.TickMarkStyle == TickMarkStyle.OutsideArea)
|
||
{
|
||
minorTickSize = this.MinorTickMark.Size;
|
||
}
|
||
}
|
||
|
||
this.markSize += (float)Math.Max(majorTickSize, minorTickSize);
|
||
|
||
|
||
// Add axis line size
|
||
SizeF borderSize = chartGraph.GetRelativeSize(new SizeF(this.LineWidth, this.LineWidth));
|
||
|
||
// If axis is horizontal
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
this.markSize += borderSize.Height / 2f;
|
||
this.markSize = Math.Min(this.markSize, (plotArea.Height / 100F) * (Axis.maxAxisMarkSize / axesNumber));
|
||
}
|
||
// If axis is vertical
|
||
else
|
||
{
|
||
this.markSize += borderSize.Width / 2f;
|
||
this.markSize = Math.Min(this.markSize, (plotArea.Width / 100F) * (Axis.maxAxisMarkSize / axesNumber));
|
||
}
|
||
|
||
// Add axis scroll bar size (if it's visible)
|
||
this.scrollBarSize = 0f;
|
||
|
||
#if Microsoft_CONTROL
|
||
|
||
if (this.ScrollBar.IsVisible &&
|
||
(this.IsAxisOnAreaEdge || !this.IsMarksNextToAxis))
|
||
{
|
||
if (this.ScrollBar.IsPositionedInside)
|
||
{
|
||
this.markSize += (float)this.ScrollBar.GetScrollBarRelativeSize();
|
||
}
|
||
else
|
||
{
|
||
this.scrollBarSize = (float)this.ScrollBar.GetScrollBarRelativeSize();
|
||
}
|
||
}
|
||
|
||
#endif // Microsoft_CONTROL
|
||
|
||
|
||
//*********************************************************
|
||
//** Adjust mark size using area scene wall width
|
||
//*********************************************************
|
||
if (ChartArea.Area3DStyle.Enable3D &&
|
||
!ChartArea.chartAreaIsCurcular &&
|
||
ChartArea.BackColor != Color.Transparent &&
|
||
ChartArea.Area3DStyle.WallWidth > 0)
|
||
{
|
||
SizeF areaWallSize = chartGraph.GetRelativeSize(new SizeF(ChartArea.Area3DStyle.WallWidth, ChartArea.Area3DStyle.WallWidth));
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
this.markSize += areaWallSize.Height;
|
||
}
|
||
else
|
||
{
|
||
this.markSize += areaWallSize.Width;
|
||
}
|
||
|
||
// Ignore Max marks size for the 3D wall size.
|
||
//this.markSize = Math.Min(this.markSize, (plotArea.Width / 100F) * (Axis.maxAxisMarkSize / axesNumber));
|
||
}
|
||
|
||
//*********************************************************
|
||
//** Adjust title size and mark size using arrow size
|
||
//*********************************************************
|
||
if (arrowSize > (this.markSize + this.scrollBarSize + this.titleSize))
|
||
{
|
||
this.markSize = Math.Max(this.markSize, arrowSize - (this.markSize + this.scrollBarSize + this.titleSize));
|
||
this.markSize = Math.Min(this.markSize, (plotArea.Width / 100F) * (Axis.maxAxisMarkSize / axesNumber));
|
||
}
|
||
|
||
//*********************************************************
|
||
//** Calculate max label size
|
||
//*********************************************************
|
||
float maxLabelSize = 0;
|
||
|
||
if (!autoPlotPosition)
|
||
{
|
||
if (this.GetIsMarksNextToAxis())
|
||
{
|
||
if (this.AxisPosition == AxisPosition.Top)
|
||
maxLabelSize = (float)GetAxisPosition() - ChartArea.Position.Y;
|
||
else if (this.AxisPosition == AxisPosition.Bottom)
|
||
maxLabelSize = ChartArea.Position.Bottom - (float)GetAxisPosition();
|
||
if (this.AxisPosition == AxisPosition.Left)
|
||
maxLabelSize = (float)GetAxisPosition() - ChartArea.Position.X;
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
maxLabelSize = ChartArea.Position.Right - (float)GetAxisPosition();
|
||
}
|
||
else
|
||
{
|
||
if (this.AxisPosition == AxisPosition.Top)
|
||
maxLabelSize = plotArea.Y - ChartArea.Position.Y;
|
||
else if (this.AxisPosition == AxisPosition.Bottom)
|
||
maxLabelSize = ChartArea.Position.Bottom - plotArea.Bottom;
|
||
if (this.AxisPosition == AxisPosition.Left)
|
||
maxLabelSize = plotArea.X - ChartArea.Position.X;
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
maxLabelSize = ChartArea.Position.Right - plotArea.Right;
|
||
}
|
||
|
||
maxLabelSize *= 2F;
|
||
}
|
||
else
|
||
{
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
maxLabelSize = plotArea.Height * (_maximumAutoSize / 100f);
|
||
else
|
||
maxLabelSize = plotArea.Width * (_maximumAutoSize / 100f);
|
||
}
|
||
|
||
|
||
|
||
//******************************************************
|
||
//** First try to select the interval that will
|
||
//** generate best fit labels.
|
||
//******************************************************
|
||
|
||
|
||
|
||
// Make sure the variable interval mode is enabled and
|
||
// no custom label interval used.
|
||
if( this.Enabled != AxisEnabled.False &&
|
||
this.LabelStyle.Enabled &&
|
||
this.IsVariableLabelCountModeEnabled() )
|
||
{
|
||
// Increase font by several points when height of the font is the most important
|
||
// dimension. Use original size whenwidth is the most important size.
|
||
float extraSize = 3f;
|
||
if( (this.AxisPosition == AxisPosition.Left || this.AxisPosition == AxisPosition.Right) &&
|
||
(this.LabelStyle.Angle == 90 || this.LabelStyle.Angle == -90) )
|
||
{
|
||
extraSize = 0f;
|
||
}
|
||
if( (this.AxisPosition == AxisPosition.Top || this.AxisPosition == AxisPosition.Bottom) &&
|
||
(this.LabelStyle.Angle == 180 || this.LabelStyle.Angle == 0) )
|
||
{
|
||
extraSize = 0f;
|
||
}
|
||
|
||
// If 3D Common.Chart is used make the measurements with font several point larger
|
||
if(ChartArea.Area3DStyle.Enable3D)
|
||
{
|
||
extraSize += 1f;
|
||
}
|
||
|
||
this.autoLabelFont = Common.Chart.chartPicture.FontCache.GetFont(this.LabelStyle.Font.FontFamily,
|
||
this.LabelStyle.Font.Size + extraSize,
|
||
this.LabelStyle.Font.Style,
|
||
GraphicsUnit.Point);
|
||
|
||
// Reset angle and stagged flag used in the auto-fitting algorithm
|
||
this.autoLabelAngle = this.LabelStyle.Angle;
|
||
this.autoLabelOffset = (this.LabelStyle.IsStaggered) ? 1 : 0;
|
||
|
||
// Adjust interval
|
||
this.AdjustIntervalToFitLabels(chartGraph, autoPlotPosition, false);
|
||
}
|
||
|
||
|
||
|
||
//******************************************************
|
||
//** Automatically calculate the best font size, angle
|
||
//** and try to use offset labels.
|
||
//******************************************************
|
||
// Reset all automatic label properties
|
||
autoLabelFont = null;
|
||
autoLabelAngle = -1000;
|
||
autoLabelOffset = -1;
|
||
|
||
// For circular Common.Chart area process auto-fitting for Y Axis only
|
||
if (this.IsLabelAutoFit &&
|
||
this.LabelAutoFitStyle != LabelAutoFitStyles.None &&
|
||
!ChartArea.chartAreaIsCurcular)
|
||
{
|
||
bool fitDone = false;
|
||
bool noWordWrap = false;
|
||
|
||
// Set default font angle and labels offset flag
|
||
autoLabelAngle = 0;
|
||
autoLabelOffset = 0;
|
||
|
||
// Original labels collection
|
||
CustomLabelsCollection originalLabels = null;
|
||
|
||
// Pick up maximum font size
|
||
float size = 8f;
|
||
size = (float)Math.Max(this.LabelAutoFitMaxFontSize, this.LabelAutoFitMinFontSize);
|
||
_minLabelFontSize = Math.Min(this.LabelAutoFitMinFontSize, this.LabelAutoFitMaxFontSize);
|
||
_aveLabelFontSize = _minLabelFontSize + Math.Abs(size - _minLabelFontSize)/2f;
|
||
|
||
|
||
// Check if common font size should be used
|
||
if (ChartArea.IsSameFontSizeForAllAxes)
|
||
{
|
||
size = (float)Math.Min(size, ChartArea.axesAutoFontSize);
|
||
}
|
||
|
||
//Set new font
|
||
autoLabelFont = Common.Chart.chartPicture.FontCache.GetFont(this.LabelStyle.Font.FontFamily,
|
||
size,
|
||
this.LabelStyle.Font.Style,
|
||
GraphicsUnit.Point
|
||
);
|
||
|
||
// Check if we allowed to increase font size while auto-fitting
|
||
if ((this.LabelAutoFitStyle & LabelAutoFitStyles.IncreaseFont) != LabelAutoFitStyles.IncreaseFont)
|
||
{
|
||
// Use axis labels font as starting point
|
||
autoLabelFont = this.LabelStyle.Font;
|
||
}
|
||
|
||
// Loop while labels do not fit
|
||
float spacer = 0f;
|
||
while (!fitDone)
|
||
{
|
||
//******************************************************
|
||
//** Check if labels fit
|
||
//******************************************************
|
||
|
||
// Check if grouping labels fit should be checked
|
||
bool checkLabelsFirstRowOnly = true;
|
||
if ((this.LabelAutoFitStyle & LabelAutoFitStyles.DecreaseFont) == LabelAutoFitStyles.DecreaseFont)
|
||
{
|
||
// Only check grouping labels if we can reduce fonts size
|
||
checkLabelsFirstRowOnly = false;
|
||
}
|
||
|
||
// Check labels fit
|
||
fitDone = CheckLabelsFit(
|
||
chartGraph,
|
||
this.markSize + this.scrollBarSize + this.titleSize + spacer,
|
||
autoPlotPosition,
|
||
checkLabelsFirstRowOnly,
|
||
false);
|
||
|
||
//******************************************************
|
||
//** Adjust labels text properties to fit
|
||
//******************************************************
|
||
if (!fitDone)
|
||
{
|
||
// If font is bigger than average try to make it smaller
|
||
if (autoLabelFont.SizeInPoints >= _aveLabelFontSize &&
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.DecreaseFont) == LabelAutoFitStyles.DecreaseFont)
|
||
{
|
||
//Clean up the old font
|
||
autoLabelFont = Common.Chart.chartPicture.FontCache.GetFont(
|
||
autoLabelFont.FontFamily,
|
||
autoLabelFont.SizeInPoints - 0.5f,
|
||
autoLabelFont.Style,
|
||
GraphicsUnit.Point);
|
||
}
|
||
|
||
// Try to use offset labels (2D charts and non-circular arae only!!!)
|
||
else if (!ChartArea.Area3DStyle.Enable3D &&
|
||
!ChartArea.chartAreaIsCurcular &&
|
||
originalLabels == null &&
|
||
autoLabelAngle == 0 &&
|
||
autoLabelOffset == 0 &&
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.StaggeredLabels) == LabelAutoFitStyles.StaggeredLabels)
|
||
{
|
||
autoLabelOffset = 1;
|
||
}
|
||
|
||
// Try to insert new line characters in labels text
|
||
else if (!noWordWrap &&
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.WordWrap) == LabelAutoFitStyles.WordWrap)
|
||
{
|
||
bool changed = false;
|
||
autoLabelOffset = 0;
|
||
|
||
// Check if backup copy of the original lables was made
|
||
if (originalLabels == null)
|
||
{
|
||
// Copy current labels collection
|
||
originalLabels = new CustomLabelsCollection(this);
|
||
foreach (CustomLabel label in this.CustomLabels)
|
||
{
|
||
originalLabels.Add(label.Clone());
|
||
}
|
||
}
|
||
|
||
// Try to insert new line character into the longest label
|
||
changed = WordWrapLongestLabel(this.CustomLabels);
|
||
|
||
// Word wrapping do not solve the labels overlapping issue
|
||
if (!changed)
|
||
{
|
||
noWordWrap = true;
|
||
|
||
// Restore original labels
|
||
if (originalLabels != null)
|
||
{
|
||
this.CustomLabels.Clear();
|
||
foreach (CustomLabel label in originalLabels)
|
||
{
|
||
this.CustomLabels.Add(label.Clone());
|
||
}
|
||
|
||
originalLabels = null;
|
||
}
|
||
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
if ((spacer == 0 ||
|
||
spacer == 30f ||
|
||
spacer == 20f) &&
|
||
((this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep30) == LabelAutoFitStyles.LabelsAngleStep30 ||
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep45) == LabelAutoFitStyles.LabelsAngleStep45 ||
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep90) == LabelAutoFitStyles.LabelsAngleStep90))
|
||
{
|
||
// Try to use 90 degrees angle
|
||
autoLabelAngle = 90;
|
||
noWordWrap = false;
|
||
|
||
// Usually 55% of Common.Chart area size is allowed for labels
|
||
// Reduce that space.
|
||
if (spacer == 0f)
|
||
{
|
||
// 30
|
||
spacer = 30f;
|
||
}
|
||
else if (spacer == 30f)
|
||
{
|
||
// 20
|
||
spacer = 20f;
|
||
}
|
||
else if (spacer == 20f)
|
||
{
|
||
// 5
|
||
spacer = 5f;
|
||
}
|
||
else
|
||
{
|
||
autoLabelAngle = 0;
|
||
noWordWrap = true;
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
spacer = 0f;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Try to change font angle
|
||
else if (autoLabelAngle != 90 &&
|
||
((this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep30) == LabelAutoFitStyles.LabelsAngleStep30 ||
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep45) == LabelAutoFitStyles.LabelsAngleStep45 ||
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep90) == LabelAutoFitStyles.LabelsAngleStep90))
|
||
{
|
||
spacer = 0f;
|
||
autoLabelOffset = 0;
|
||
|
||
if ((this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep30) == LabelAutoFitStyles.LabelsAngleStep30)
|
||
{
|
||
// Increase angle by 45 degrees in 2D and 45 in 3D
|
||
autoLabelAngle += (ChartArea.Area3DStyle.Enable3D) ? 45 : 30;
|
||
}
|
||
else if ((this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep45) == LabelAutoFitStyles.LabelsAngleStep45)
|
||
{
|
||
// Increase angle by 45 degrees
|
||
autoLabelAngle += 45;
|
||
}
|
||
else if ((this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep90) == LabelAutoFitStyles.LabelsAngleStep90)
|
||
{
|
||
// Increase angle by 90 degrees
|
||
autoLabelAngle += 90;
|
||
}
|
||
}
|
||
|
||
// Try to reduce font again
|
||
else if (autoLabelFont.SizeInPoints > _minLabelFontSize &&
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.DecreaseFont) == LabelAutoFitStyles.DecreaseFont)
|
||
{
|
||
//Clean up the old font
|
||
autoLabelAngle = 0;
|
||
autoLabelFont = Common.Chart.chartPicture.FontCache.GetFont(
|
||
autoLabelFont.FontFamily,
|
||
autoLabelFont.SizeInPoints - 0.5f,
|
||
autoLabelFont.Style,
|
||
GraphicsUnit.Point);
|
||
}
|
||
|
||
// Failed to fit
|
||
else
|
||
{
|
||
// Use last font
|
||
if ((this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep30) == LabelAutoFitStyles.LabelsAngleStep30 ||
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep45) == LabelAutoFitStyles.LabelsAngleStep45 ||
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.LabelsAngleStep90) == LabelAutoFitStyles.LabelsAngleStep90)
|
||
{
|
||
// Reset angle
|
||
if (this.AxisPosition == AxisPosition.Top || this.AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
autoLabelAngle = 90;
|
||
}
|
||
else
|
||
{
|
||
autoLabelAngle = 0;
|
||
}
|
||
}
|
||
if ((this.LabelAutoFitStyle & LabelAutoFitStyles.StaggeredLabels) == LabelAutoFitStyles.StaggeredLabels)
|
||
{
|
||
// Reset offset labels
|
||
autoLabelOffset = 0;
|
||
}
|
||
fitDone = true;
|
||
}
|
||
}
|
||
else if (ChartArea.Area3DStyle.Enable3D &&
|
||
!ChartArea.chartAreaIsCurcular &&
|
||
autoLabelFont.SizeInPoints > _minLabelFontSize)
|
||
{
|
||
// Reduce auto-fit font by 1 for the 3D charts
|
||
autoLabelFont = Common.Chart.chartPicture.FontCache.GetFont(
|
||
autoLabelFont.FontFamily,
|
||
autoLabelFont.SizeInPoints - 0.5f,
|
||
autoLabelFont.Style,
|
||
GraphicsUnit.Point);
|
||
}
|
||
}
|
||
|
||
// Change the auto-fit angle for top and bottom axes from 90 to -90
|
||
if(this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
if(autoLabelAngle == 90)
|
||
{
|
||
autoLabelAngle = -90;
|
||
}
|
||
}
|
||
}
|
||
|
||
//*********************************************************
|
||
//** Calculate overall labels size
|
||
//*********************************************************
|
||
this.labelSize = 0;
|
||
|
||
// if labels are not enabled their size needs to remain zero
|
||
if (this.LabelStyle.Enabled)
|
||
{
|
||
//******************************************************
|
||
//** Calculate axis second labels row size
|
||
//******************************************************
|
||
this.labelSize = (maxAxisElementsSize) - this.markSize - this.scrollBarSize - this.titleSize;
|
||
if (this.labelSize > 0)
|
||
{
|
||
this.groupingLabelSizes = GetRequiredGroupLabelSize(chartGraph, (maxLabelSize / 100F) * maxAxisLabelRow2Size);
|
||
this.totlaGroupingLabelsSize = GetGroupLablesToatalSize();
|
||
}
|
||
|
||
//******************************************************
|
||
//** Calculate axis labels size
|
||
//******************************************************
|
||
this.labelSize -= this.totlaGroupingLabelsSize;
|
||
if (this.labelSize > 0)
|
||
{
|
||
// If axis is horizontal
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
this.labelSize = elementSpacing + GetRequiredLabelSize(chartGraph,
|
||
(maxLabelSize / 100F) * (maxAxisElementsSize - this.markSize - this.scrollBarSize - this.titleSize), out this.unRotatedLabelSize);
|
||
}
|
||
// If axis is horizontal
|
||
else
|
||
{
|
||
this.labelSize = elementSpacing + GetRequiredLabelSize(chartGraph,
|
||
(maxLabelSize / 100F) * (maxAxisElementsSize - this.markSize - this.scrollBarSize - this.titleSize), out this.unRotatedLabelSize);
|
||
}
|
||
|
||
if (!this.LabelStyle.Enabled)
|
||
{
|
||
this.labelSize -= elementSpacing;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
this.labelSize = 0;
|
||
}
|
||
|
||
this.labelSize += this.totlaGroupingLabelsSize;
|
||
}
|
||
|
||
#if SUBAXES
|
||
// Calculate offsets for all sub axes
|
||
if(!ChartArea.Area3DStyle.Enable3D &&
|
||
!ChartArea.chartAreaIsCurcular)
|
||
{
|
||
float currentOffset = this.markSize + this.labelSize + this.titleSize + this.scrollBarSize;
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
if(subAxis.Enabled != AxisEnabled.False)
|
||
{
|
||
currentOffset += (float)subAxis.LocationOffset;
|
||
subAxis.offsetFromParent = currentOffset;
|
||
currentOffset += subAxis.markSize + subAxis.labelSize + subAxis.titleSize;
|
||
}
|
||
}
|
||
}
|
||
#endif // SUBAXES
|
||
|
||
|
||
#if Microsoft_CONTROL
|
||
// Restore previous invalidation flag
|
||
Common.Chart.disableInvalidates = oldDisableInvalidates;
|
||
#endif //Microsoft_CONTROL
|
||
}
|
||
|
||
/// <summary>
|
||
/// Calculates axis interval so that labels will fit most efficiently.
|
||
/// </summary>
|
||
/// <param name="chartGraph">Chart graphics.</param>
|
||
/// <param name="autoPlotPosition">True if plot position is auto calculated.</param>
|
||
/// <param name="onlyIncreaseInterval">True if interval should only be increased.</param>
|
||
private void AdjustIntervalToFitLabels(ChartGraphics chartGraph, bool autoPlotPosition, bool onlyIncreaseInterval)
|
||
{
|
||
// Calculates axis interval so that labels will fit most efficiently.
|
||
if(this.ScaleSegments.Count == 0)
|
||
{
|
||
this.AdjustIntervalToFitLabels(chartGraph, autoPlotPosition, null, onlyIncreaseInterval);
|
||
}
|
||
else
|
||
{
|
||
// Allow values to go outside the segment boundary
|
||
this.ScaleSegments.AllowOutOfScaleValues = true;
|
||
|
||
// Adjust interval of each segment first
|
||
foreach(AxisScaleSegment axisScaleSegment in this.ScaleSegments)
|
||
{
|
||
this.AdjustIntervalToFitLabels(chartGraph, autoPlotPosition, axisScaleSegment, onlyIncreaseInterval);
|
||
}
|
||
|
||
// Fill labels using new segment intervals
|
||
bool removeLabels = true;
|
||
int segmentIndex = 0;
|
||
ArrayList removedLabels = new ArrayList();
|
||
ArrayList removedLabelsIndexes = new ArrayList();
|
||
foreach(AxisScaleSegment scaleSegment in this.ScaleSegments)
|
||
{
|
||
scaleSegment.SetTempAxisScaleAndInterval();
|
||
this.FillLabels(removeLabels);
|
||
removeLabels = false;
|
||
scaleSegment.RestoreAxisScaleAndInterval();
|
||
|
||
// Remove last label of all segmenst except of the last
|
||
if(segmentIndex < this.ScaleSegments.Count - 1 &&
|
||
this.CustomLabels.Count > 0)
|
||
{
|
||
// Remove label and save it in the list
|
||
removedLabels.Add(this.CustomLabels[this.CustomLabels.Count - 1]);
|
||
removedLabelsIndexes.Add(this.CustomLabels.Count - 1);
|
||
this.CustomLabels.RemoveAt(this.CustomLabels.Count - 1);
|
||
}
|
||
|
||
++segmentIndex;
|
||
}
|
||
|
||
// Check all previously removed last labels of each segment if there
|
||
// is enough space to fit them
|
||
int reInsertedLabelsCount = 0;
|
||
int labelIndex = 0;
|
||
foreach(CustomLabel label in removedLabels)
|
||
{
|
||
// Re-insert the label
|
||
int labelInsertIndex = (int)removedLabelsIndexes[labelIndex] + reInsertedLabelsCount;
|
||
if(labelIndex < this.CustomLabels.Count)
|
||
{
|
||
this.CustomLabels.Insert(labelInsertIndex, label);
|
||
}
|
||
else
|
||
{
|
||
this.CustomLabels.Add(label);
|
||
}
|
||
|
||
// Check labels fit. Only horizontal or vertical fit is checked depending
|
||
// on the axis orientation.
|
||
ArrayList labelPositions = new ArrayList();
|
||
bool fitDone = CheckLabelsFit(
|
||
chartGraph,
|
||
this.markSize + this.scrollBarSize + this.titleSize,
|
||
autoPlotPosition,
|
||
true,
|
||
false,
|
||
(this.AxisPosition == AxisPosition.Left || this.AxisPosition == AxisPosition.Right) ? false : true,
|
||
(this.AxisPosition == AxisPosition.Left || this.AxisPosition == AxisPosition.Right) ? true : false,
|
||
labelPositions);
|
||
|
||
// If labels fit check if any of the label positions overlap
|
||
if(fitDone)
|
||
{
|
||
for(int index = 0; fitDone && index < labelPositions.Count; index++)
|
||
{
|
||
RectangleF rect1 = (RectangleF)labelPositions[index];
|
||
for(int index2 = index + 1; fitDone && index2 < labelPositions.Count; index2++)
|
||
{
|
||
RectangleF rect2 = (RectangleF)labelPositions[index2];
|
||
if(rect1.IntersectsWith(rect2))
|
||
{
|
||
fitDone = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// If labels do not fit or overlapp - remove completly
|
||
if(!fitDone)
|
||
{
|
||
this.CustomLabels.RemoveAt(labelInsertIndex);
|
||
}
|
||
else
|
||
{
|
||
++reInsertedLabelsCount;
|
||
}
|
||
|
||
++labelIndex;
|
||
}
|
||
|
||
// Make sure now values are rounded on segment boundary
|
||
this.ScaleSegments.AllowOutOfScaleValues = false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Checks if variable count labels mode is enabled.
|
||
/// </summary>
|
||
/// <returns>True if variable count labels mode is enabled.</returns>
|
||
private bool IsVariableLabelCountModeEnabled()
|
||
{
|
||
// Make sure the variable interval mode is enabled and
|
||
// no custom label interval used.
|
||
if( (this.IntervalAutoMode == IntervalAutoMode.VariableCount || this.ScaleSegments.Count > 0) &&
|
||
!this.IsLogarithmic &&
|
||
(this.tempLabelInterval <= 0.0 || (double.IsNaN(this.tempLabelInterval) && this.Interval <= 0.0)) )
|
||
{
|
||
// This feature is not supported for charts that do not
|
||
// require X and Y axes (Pie, Radar, ...)
|
||
if(!ChartArea.requireAxes)
|
||
{
|
||
return false;
|
||
}
|
||
// This feature is not supported if the axis doesn't have data range
|
||
if (Double.IsNaN(this.minimum) || Double.IsNaN(this.maximum))
|
||
{
|
||
return false;
|
||
}
|
||
// Check if custom labels are used in the first row
|
||
bool customLabels = false;
|
||
foreach(CustomLabel label in this.CustomLabels)
|
||
{
|
||
if(label.customLabel && label.RowIndex == 0)
|
||
{
|
||
customLabels = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Proceed only if no custom labels are used in the first row
|
||
if(!customLabels)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Calculates axis interval so that labels will fit most efficiently.
|
||
/// </summary>
|
||
/// <param name="chartGraph">Chart graphics.</param>
|
||
/// <param name="autoPlotPosition">True if plot position is auto calculated.</param>
|
||
/// <param name="axisScaleSegment">Axis scale segment to process.</param>
|
||
/// <param name="onlyIncreaseInterval">True if interval should only be increased.</param>
|
||
private void AdjustIntervalToFitLabels(
|
||
ChartGraphics chartGraph,
|
||
bool autoPlotPosition,
|
||
AxisScaleSegment axisScaleSegment,
|
||
bool onlyIncreaseInterval)
|
||
{
|
||
// Re-fill the labels just for the scale segment provided
|
||
if(axisScaleSegment != null)
|
||
{
|
||
// Re-fill new axis labels
|
||
if(this.tempLabels != null)
|
||
{
|
||
this.CustomLabels.Clear();
|
||
foreach( CustomLabel label in this.tempLabels )
|
||
{
|
||
this.CustomLabels.Add(label.Clone());
|
||
}
|
||
}
|
||
|
||
// Fill labels just for the segment
|
||
axisScaleSegment.SetTempAxisScaleAndInterval();
|
||
this.FillLabels( true );
|
||
axisScaleSegment.RestoreAxisScaleAndInterval();
|
||
}
|
||
|
||
// Calculate minimum interval size
|
||
double minIntervalSzie = double.NaN;
|
||
ArrayList axisSeries = AxisScaleBreakStyle.GetAxisSeries(this);
|
||
foreach(Series series in axisSeries)
|
||
{
|
||
if(this.axisType == AxisName.X || this.axisType == AxisName.X2)
|
||
{
|
||
if(ChartHelper.IndexedSeries(series))
|
||
{
|
||
minIntervalSzie = 1.0;
|
||
}
|
||
else if(series.XValueType == ChartValueType.String ||
|
||
series.XValueType == ChartValueType.Int32 ||
|
||
series.XValueType == ChartValueType.UInt32 ||
|
||
series.XValueType == ChartValueType.UInt64 ||
|
||
series.XValueType == ChartValueType.Int64 )
|
||
{
|
||
minIntervalSzie = 1.0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(series.YValueType == ChartValueType.String ||
|
||
series.YValueType == ChartValueType.Int32 ||
|
||
series.YValueType == ChartValueType.UInt32 ||
|
||
series.YValueType == ChartValueType.UInt64 ||
|
||
series.YValueType == ChartValueType.Int64 )
|
||
{
|
||
minIntervalSzie = 1.0;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
// Iterate while interval is not found
|
||
bool firstIteration = true;
|
||
bool increaseNumberOfLabels = true;
|
||
double currentInterval = (axisScaleSegment == null) ? this.labelStyle.GetInterval() : axisScaleSegment.Interval;
|
||
DateTimeIntervalType currentIntervalType = (axisScaleSegment == null) ? this.labelStyle.GetIntervalType() : axisScaleSegment.IntervalType;
|
||
DateTimeIntervalType lastFitIntervalType = currentIntervalType;
|
||
double lastFitInterval = currentInterval;
|
||
ArrayList lastFitLabels = new ArrayList();
|
||
bool intervalFound = false;
|
||
int iterationNumber = 0;
|
||
while(!intervalFound && iterationNumber <= 1000)
|
||
{
|
||
bool fillNewLabels = true;
|
||
#if DEBUG
|
||
if(iterationNumber >= 999)
|
||
{
|
||
throw (new InvalidOperationException(SR.ExceptionAxisDynamicIntervalCalculationFailed));
|
||
}
|
||
#endif // DEBUG
|
||
|
||
// Check labels fit. Only horizontal or vertical fit is checked depending
|
||
// on the axis orientation.
|
||
bool fitDone = CheckLabelsFit(
|
||
chartGraph,
|
||
this.markSize + this.scrollBarSize + this.titleSize,
|
||
autoPlotPosition,
|
||
true,
|
||
false,
|
||
(this.AxisPosition == AxisPosition.Left || this.AxisPosition == AxisPosition.Right) ? false : true,
|
||
(this.AxisPosition == AxisPosition.Left || this.AxisPosition == AxisPosition.Right) ? true : false,
|
||
null);
|
||
|
||
// Check if we need to increase or reduce number of labels
|
||
if(firstIteration)
|
||
{
|
||
firstIteration = false;
|
||
increaseNumberOfLabels = (fitDone) ? true : false;
|
||
|
||
// Check if we can decrease the interva;
|
||
if(onlyIncreaseInterval && increaseNumberOfLabels)
|
||
{
|
||
intervalFound = true;
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// Find new interval. Value 0.0 means that interval cannot be
|
||
// reduced/increased any more and current interval should be used
|
||
double newInterval = 0.0;
|
||
DateTimeIntervalType newIntervalType = DateTimeIntervalType.Number;
|
||
if(increaseNumberOfLabels)
|
||
{
|
||
if(fitDone)
|
||
{
|
||
// Make a copy of last interval and labels collection that previously fit
|
||
lastFitInterval = currentInterval;
|
||
lastFitIntervalType = currentIntervalType;
|
||
lastFitLabels.Clear();
|
||
foreach(CustomLabel label in this.CustomLabels)
|
||
{
|
||
lastFitLabels.Add(label);
|
||
}
|
||
|
||
newIntervalType = currentIntervalType;
|
||
newInterval = this.ReduceLabelInterval(
|
||
currentInterval,
|
||
minIntervalSzie,
|
||
ref newIntervalType);
|
||
}
|
||
else
|
||
{
|
||
newInterval = lastFitInterval;
|
||
newIntervalType = lastFitIntervalType;
|
||
intervalFound = true;
|
||
|
||
// Reuse previously saved labels
|
||
fillNewLabels = false;
|
||
this.CustomLabels.Clear();
|
||
foreach(CustomLabel label in lastFitLabels)
|
||
{
|
||
this.CustomLabels.Add(label);
|
||
}
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(!fitDone && this.CustomLabels.Count > 1)
|
||
{
|
||
newIntervalType = currentIntervalType;
|
||
newInterval = this.IncreaseLabelInterval(
|
||
currentInterval,
|
||
ref newIntervalType);
|
||
}
|
||
else
|
||
{
|
||
intervalFound = true;
|
||
}
|
||
}
|
||
|
||
// Set new interval
|
||
if(newInterval != 0.0)
|
||
{
|
||
currentInterval = newInterval;
|
||
currentIntervalType = newIntervalType;
|
||
|
||
if(axisScaleSegment == null)
|
||
{
|
||
this.SetIntervalAndType(newInterval, newIntervalType);
|
||
}
|
||
else
|
||
{
|
||
axisScaleSegment.Interval = newInterval;
|
||
axisScaleSegment.IntervalType = newIntervalType;
|
||
}
|
||
|
||
// Re-fill new axis labels
|
||
if(fillNewLabels)
|
||
{
|
||
if(this.tempLabels != null)
|
||
{
|
||
this.CustomLabels.Clear();
|
||
foreach( CustomLabel label in this.tempLabels )
|
||
{
|
||
CustomLabels.Add(label.Clone());
|
||
}
|
||
}
|
||
|
||
if(axisScaleSegment == null)
|
||
{
|
||
this.FillLabels(true);
|
||
}
|
||
else
|
||
{
|
||
axisScaleSegment.SetTempAxisScaleAndInterval();
|
||
this.FillLabels( true );
|
||
axisScaleSegment.RestoreAxisScaleAndInterval();
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
intervalFound = true;
|
||
}
|
||
|
||
++iterationNumber;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Reduces current label interval, so that more labels can fit.
|
||
/// </summary>
|
||
/// <param name="oldInterval">An interval to reduce.</param>
|
||
/// <param name="minInterval">Minimum interval size.</param>
|
||
/// <param name="axisIntervalType">Interval type.</param>
|
||
/// <returns>New interval or 0.0 if interval cannot be reduced.</returns>
|
||
private double ReduceLabelInterval(
|
||
double oldInterval,
|
||
double minInterval,
|
||
ref DateTimeIntervalType axisIntervalType)
|
||
{
|
||
double newInterval = oldInterval;
|
||
|
||
// Calculate rounded interval value
|
||
double range = this.maximum - this.minimum;
|
||
int iterationIndex = 0;
|
||
if( axisIntervalType == DateTimeIntervalType.Auto ||
|
||
axisIntervalType == DateTimeIntervalType.NotSet ||
|
||
axisIntervalType == DateTimeIntervalType.Number)
|
||
{
|
||
// Process numeric scale
|
||
double devider = 2.0;
|
||
do
|
||
{
|
||
#if DEBUG
|
||
if(iterationIndex >= 99)
|
||
{
|
||
throw (new InvalidOperationException(SR.ExceptionAxisIntervalDecreasingFailed));
|
||
}
|
||
#endif // DEBUG
|
||
|
||
newInterval = CalcInterval( range / (range / (newInterval / devider)) );
|
||
if(newInterval == oldInterval)
|
||
{
|
||
devider *= 2.0;
|
||
}
|
||
|
||
++iterationIndex;
|
||
} while(newInterval == oldInterval && iterationIndex <= 100);
|
||
}
|
||
else
|
||
{
|
||
// Process date scale
|
||
if(oldInterval > 1.0 || oldInterval < 1.0)
|
||
{
|
||
if( axisIntervalType == DateTimeIntervalType.Minutes ||
|
||
axisIntervalType == DateTimeIntervalType.Seconds)
|
||
{
|
||
if(oldInterval >= 60)
|
||
{
|
||
newInterval = Math.Round(oldInterval / 2.0);
|
||
}
|
||
else if(oldInterval >= 30.0)
|
||
{
|
||
newInterval = 15.0;
|
||
}
|
||
else if(oldInterval >= 15.0)
|
||
{
|
||
newInterval = 5.0;
|
||
}
|
||
else if(oldInterval >= 5.0)
|
||
{
|
||
newInterval = 1.0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
newInterval = Math.Round(oldInterval / 2.0);
|
||
}
|
||
if(newInterval < 1.0)
|
||
{
|
||
newInterval = 1.0;
|
||
}
|
||
}
|
||
if(oldInterval == 1.0)
|
||
{
|
||
if(axisIntervalType == DateTimeIntervalType.Years)
|
||
{
|
||
newInterval = 6.0;
|
||
axisIntervalType = DateTimeIntervalType.Months;
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Months)
|
||
{
|
||
newInterval = 2.0;
|
||
axisIntervalType = DateTimeIntervalType.Weeks;
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Weeks)
|
||
{
|
||
newInterval = 2.0;
|
||
axisIntervalType = DateTimeIntervalType.Days;
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Days)
|
||
{
|
||
newInterval = 12.0;
|
||
axisIntervalType = DateTimeIntervalType.Hours;
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Hours)
|
||
{
|
||
newInterval = 30.0;
|
||
axisIntervalType = DateTimeIntervalType.Minutes;
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Minutes)
|
||
{
|
||
newInterval = 30.0;
|
||
axisIntervalType = DateTimeIntervalType.Seconds;
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Seconds)
|
||
{
|
||
newInterval = 100.0;
|
||
axisIntervalType = DateTimeIntervalType.Milliseconds;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
// Make sure interal is not less than min interval specified
|
||
if(!double.IsNaN(minInterval) && newInterval < minInterval)
|
||
{
|
||
newInterval = 0.0;
|
||
}
|
||
|
||
return newInterval;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Increases current label interval, so that less labels fit.
|
||
/// </summary>
|
||
/// <param name="oldInterval">An interval to increase.</param>
|
||
/// <param name="axisIntervalType">Interval type.</param>
|
||
/// <returns>New interval or 0.0 if interval cannot be increased.</returns>
|
||
private double IncreaseLabelInterval(
|
||
double oldInterval,
|
||
ref DateTimeIntervalType axisIntervalType)
|
||
{
|
||
double newInterval = oldInterval;
|
||
|
||
// Calculate rounded interval value
|
||
double range = this.maximum - this.minimum;
|
||
int iterationIndex = 0;
|
||
if( axisIntervalType == DateTimeIntervalType.Auto ||
|
||
axisIntervalType == DateTimeIntervalType.NotSet ||
|
||
axisIntervalType == DateTimeIntervalType.Number)
|
||
{
|
||
// Process numeric scale
|
||
double devider = 2.0;
|
||
do
|
||
{
|
||
#if DEBUG
|
||
if(iterationIndex >= 99)
|
||
{
|
||
throw (new InvalidOperationException(SR.ExceptionAxisIntervalIncreasingFailed));
|
||
}
|
||
#endif // DEBUG
|
||
|
||
newInterval = CalcInterval( range / (range / (newInterval * devider)) );
|
||
if(newInterval == oldInterval)
|
||
{
|
||
devider *= 2.0;
|
||
}
|
||
++iterationIndex;
|
||
} while(newInterval == oldInterval && iterationIndex <= 100);
|
||
}
|
||
else
|
||
{
|
||
// Process date scale
|
||
newInterval = oldInterval * 2.0;
|
||
if(axisIntervalType == DateTimeIntervalType.Years)
|
||
{
|
||
// Do nothing for years
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Months)
|
||
{
|
||
if(newInterval >= 12.0)
|
||
{
|
||
newInterval = 1.0;
|
||
axisIntervalType = DateTimeIntervalType.Years;
|
||
}
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Weeks)
|
||
{
|
||
if(newInterval >= 4.0)
|
||
{
|
||
newInterval = 1.0;
|
||
axisIntervalType = DateTimeIntervalType.Months;
|
||
}
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Days)
|
||
{
|
||
if(newInterval >= 7.0)
|
||
{
|
||
newInterval = 1.0;
|
||
axisIntervalType = DateTimeIntervalType.Weeks;
|
||
}
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Hours)
|
||
{
|
||
if(newInterval >= 60.0)
|
||
{
|
||
newInterval = 1.0;
|
||
axisIntervalType = DateTimeIntervalType.Days;
|
||
}
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Minutes)
|
||
{
|
||
if(newInterval >= 60.0)
|
||
{
|
||
newInterval = 1.0;
|
||
axisIntervalType = DateTimeIntervalType.Hours;
|
||
}
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Seconds)
|
||
{
|
||
if(newInterval >= 60.0)
|
||
{
|
||
newInterval = 1.0;
|
||
axisIntervalType = DateTimeIntervalType.Minutes;
|
||
}
|
||
}
|
||
else if(axisIntervalType == DateTimeIntervalType.Milliseconds)
|
||
{
|
||
if(newInterval >= 1000.0)
|
||
{
|
||
newInterval = 1.0;
|
||
axisIntervalType = DateTimeIntervalType.Seconds;
|
||
}
|
||
}
|
||
}
|
||
|
||
return newInterval;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Finds the longest labels with the space and inserts the new line character.
|
||
/// </summary>
|
||
/// <param name="labels">Labels collection.</param>
|
||
/// <returns>True if collection was modified.</returns>
|
||
private bool WordWrapLongestLabel(CustomLabelsCollection labels)
|
||
{
|
||
bool changed = false;
|
||
|
||
// Each label may contain several lines of text.
|
||
// Create a list that contains an array of text for each label.
|
||
ArrayList labelTextRows = new ArrayList(labels.Count);
|
||
foreach (CustomLabel label in labels)
|
||
{
|
||
labelTextRows.Add(label.Text.Split('\n'));
|
||
}
|
||
|
||
// Find the longest label with a space
|
||
int longestLabelSize = 5;
|
||
int longestLabelIndex = -1;
|
||
int longestLabelRowIndex = -1;
|
||
int index = 0;
|
||
foreach (string[] textRows in labelTextRows)
|
||
{
|
||
for (int rowIndex = 0; rowIndex < textRows.Length; rowIndex++)
|
||
{
|
||
if (textRows[rowIndex].Length > longestLabelSize && textRows[rowIndex].Trim().IndexOf(' ') > 0)
|
||
{
|
||
longestLabelSize = textRows[rowIndex].Length;
|
||
longestLabelIndex = index;
|
||
longestLabelRowIndex = rowIndex;
|
||
}
|
||
}
|
||
++index;
|
||
}
|
||
|
||
// Longest label with a space was found
|
||
if (longestLabelIndex >= 0 && longestLabelRowIndex >= 0)
|
||
{
|
||
// Try to find a space and replace it with a new line
|
||
string newText = ((string[])labelTextRows[longestLabelIndex])[longestLabelRowIndex];
|
||
for (index = 0; index < (newText.Length) / 2 - 1; index++)
|
||
{
|
||
if (newText[(newText.Length) / 2 - index] == ' ')
|
||
{
|
||
newText =
|
||
newText.Substring(0, (newText.Length) / 2 - index) +
|
||
"\n" +
|
||
newText.Substring((newText.Length) / 2 - index + 1);
|
||
changed = true;
|
||
}
|
||
else if (newText[(newText.Length) / 2 + index] == ' ')
|
||
{
|
||
newText =
|
||
newText.Substring(0, (newText.Length) / 2 + index) +
|
||
"\n" +
|
||
newText.Substring((newText.Length) / 2 + index + 1);
|
||
changed = true;
|
||
}
|
||
|
||
if (changed)
|
||
{
|
||
((string[])labelTextRows[longestLabelIndex])[longestLabelRowIndex] = newText;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Update label text
|
||
if (changed)
|
||
{
|
||
// Construct label text from multiple rows separated by "\n"
|
||
CustomLabel label = labels[longestLabelIndex];
|
||
label.Text = string.Empty;
|
||
for (int rowIndex = 0; rowIndex < ((string[])labelTextRows[longestLabelIndex]).Length; rowIndex++)
|
||
{
|
||
if (rowIndex > 0)
|
||
{
|
||
label.Text += "\n";
|
||
}
|
||
label.Text += ((string[])labelTextRows[longestLabelIndex])[rowIndex];
|
||
}
|
||
}
|
||
}
|
||
|
||
return changed;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Calculates the auto-fit font for the circular Common.Chart area axis labels.
|
||
/// </summary>
|
||
/// <param name="graph">Chart graphics object.</param>
|
||
/// <param name="axisList">List of sector labels.</param>
|
||
/// <param name="labelsStyle">Circular labels style.</param>
|
||
/// <param name="plotAreaRectAbs">Plotting area position.</param>
|
||
/// <param name="areaRectAbs">Chart area position.</param>
|
||
/// <param name="labelsSizeEstimate">Estimated size of labels.</param>
|
||
internal void GetCircularAxisLabelsAutoFitFont(
|
||
ChartGraphics graph,
|
||
ArrayList axisList,
|
||
CircularAxisLabelsStyle labelsStyle,
|
||
RectangleF plotAreaRectAbs,
|
||
RectangleF areaRectAbs,
|
||
float labelsSizeEstimate)
|
||
{
|
||
// X axis settings defines if auto-fit font should be calculated
|
||
if (!this.IsLabelAutoFit ||
|
||
this.LabelAutoFitStyle == LabelAutoFitStyles.None ||
|
||
!this.LabelStyle.Enabled)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// Set minimum font size
|
||
_minLabelFontSize = Math.Min(this.LabelAutoFitMinFontSize, this.LabelAutoFitMaxFontSize);
|
||
|
||
// Create new auto-fit font
|
||
this.autoLabelFont = Common.Chart.chartPicture.FontCache.GetFont(
|
||
this.LabelStyle.Font.FontFamily,
|
||
Math.Max(this.LabelAutoFitMaxFontSize, this.LabelAutoFitMinFontSize),
|
||
this.LabelStyle.Font.Style,
|
||
GraphicsUnit.Point);
|
||
|
||
// Check if we allowed to increase font size while auto-fitting
|
||
if ((this.LabelAutoFitStyle & LabelAutoFitStyles.IncreaseFont) != LabelAutoFitStyles.IncreaseFont)
|
||
{
|
||
// Use axis labels font as starting point
|
||
this.autoLabelFont = this.LabelStyle.Font;
|
||
}
|
||
|
||
// Loop while labels do not fit
|
||
bool fitDone = false;
|
||
while (!fitDone)
|
||
{
|
||
//******************************************************
|
||
//** Check if labels fit
|
||
//******************************************************
|
||
fitDone = CheckCircularLabelsFit(
|
||
graph,
|
||
axisList,
|
||
labelsStyle,
|
||
plotAreaRectAbs,
|
||
areaRectAbs,
|
||
labelsSizeEstimate);
|
||
|
||
//******************************************************
|
||
//** Adjust labels text properties to fit
|
||
//******************************************************
|
||
if (!fitDone)
|
||
{
|
||
// Try to reduce font size
|
||
if (autoLabelFont.SizeInPoints > _minLabelFontSize &&
|
||
(this.LabelAutoFitStyle & LabelAutoFitStyles.DecreaseFont) == LabelAutoFitStyles.DecreaseFont)
|
||
{
|
||
autoLabelFont = Common.Chart.chartPicture.FontCache.GetFont(
|
||
autoLabelFont.FontFamily,
|
||
autoLabelFont.SizeInPoints - 1,
|
||
autoLabelFont.Style,
|
||
GraphicsUnit.Point);
|
||
|
||
}
|
||
|
||
// Failed to fit
|
||
else
|
||
{
|
||
// Use last font with no angles
|
||
autoLabelAngle = 0;
|
||
autoLabelOffset = 0;
|
||
fitDone = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Checks id circular axis labels fits using current auto-fit font.
|
||
/// </summary>
|
||
/// <param name="graph">Chart graphics object.</param>
|
||
/// <param name="axisList">List of sector labels.</param>
|
||
/// <param name="labelsStyle">Circular labels style.</param>
|
||
/// <param name="plotAreaRectAbs">Plotting area position.</param>
|
||
/// <param name="areaRectAbs">Chart area position.</param>
|
||
/// <param name="labelsSizeEstimate">Estimated size of labels.</param>
|
||
/// <returns>True if labels fit.</returns>
|
||
internal bool CheckCircularLabelsFit(
|
||
ChartGraphics graph,
|
||
ArrayList axisList,
|
||
CircularAxisLabelsStyle labelsStyle,
|
||
RectangleF plotAreaRectAbs,
|
||
RectangleF areaRectAbs,
|
||
float labelsSizeEstimate)
|
||
{
|
||
bool labelsFit = true;
|
||
|
||
// Get absolute center of the area
|
||
PointF areaCenterAbs = graph.GetAbsolutePoint(ChartArea.circularCenter);
|
||
|
||
// Get absolute markers size and spacing
|
||
float spacing = graph.GetAbsolutePoint(new PointF(0, this.markSize + Axis.elementSpacing)).Y;
|
||
|
||
//*****************************************************************
|
||
//** Loop through all axis labels
|
||
//*****************************************************************
|
||
RectangleF prevLabelPosition = RectangleF.Empty;
|
||
float prevLabelSideAngle = float.NaN;
|
||
foreach (CircularChartAreaAxis axis in axisList)
|
||
{
|
||
//*****************************************************************
|
||
//** Measure label text
|
||
//*****************************************************************
|
||
SizeF textSize = graph.MeasureString(
|
||
axis.Title.Replace("\\n", "\n"),
|
||
this.autoLabelFont);
|
||
|
||
//*****************************************************************
|
||
//** Get circular style label position.
|
||
//*****************************************************************
|
||
if (labelsStyle == CircularAxisLabelsStyle.Circular ||
|
||
labelsStyle == CircularAxisLabelsStyle.Radial)
|
||
{
|
||
// Swith text size for the radial style
|
||
if (labelsStyle == CircularAxisLabelsStyle.Radial)
|
||
{
|
||
float tempValue = textSize.Width;
|
||
textSize.Width = textSize.Height;
|
||
textSize.Height = tempValue;
|
||
}
|
||
|
||
//*****************************************************************
|
||
//** Check overlapping with previous label
|
||
//*****************************************************************
|
||
|
||
// Get radius of plot area
|
||
float plotAreaRadius = areaCenterAbs.Y - plotAreaRectAbs.Y;
|
||
plotAreaRadius -= labelsSizeEstimate;
|
||
plotAreaRadius += spacing;
|
||
|
||
// Calculate angle on the side of the label
|
||
float leftSideAngle = (float)(Math.Atan((textSize.Width / 2f) / plotAreaRadius) * 180f / Math.PI);
|
||
float rightSideAngle = axis.AxisPosition + leftSideAngle;
|
||
leftSideAngle = axis.AxisPosition - leftSideAngle;
|
||
|
||
// Check if label overlap the previous label
|
||
if (!float.IsNaN(prevLabelSideAngle))
|
||
{
|
||
if (prevLabelSideAngle > leftSideAngle)
|
||
{
|
||
// Labels overlap
|
||
labelsFit = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Remember label side angle
|
||
prevLabelSideAngle = rightSideAngle - 1;
|
||
|
||
|
||
//*****************************************************************
|
||
//** Check if label is inside the Common.Chart area
|
||
//*****************************************************************
|
||
|
||
// Find the most outside point of the label
|
||
PointF outsidePoint = new PointF(areaCenterAbs.X, plotAreaRectAbs.Y);
|
||
outsidePoint.Y += labelsSizeEstimate;
|
||
outsidePoint.Y -= textSize.Height;
|
||
outsidePoint.Y -= spacing;
|
||
|
||
PointF[] rotatedPoint = new PointF[] { outsidePoint };
|
||
Matrix newMatrix = new Matrix();
|
||
newMatrix.RotateAt(axis.AxisPosition, areaCenterAbs);
|
||
newMatrix.TransformPoints(rotatedPoint);
|
||
|
||
// Check if rotated point is inside Common.Chart area
|
||
if (!areaRectAbs.Contains(rotatedPoint[0]))
|
||
{
|
||
// Label is not inside Common.Chart area
|
||
labelsFit = false;
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
//*****************************************************************
|
||
//** Get horizontal style label position.
|
||
//*****************************************************************
|
||
else if (labelsStyle == CircularAxisLabelsStyle.Horizontal)
|
||
{
|
||
// Get text angle
|
||
float textAngle = axis.AxisPosition;
|
||
if (textAngle > 180f)
|
||
{
|
||
textAngle -= 180f;
|
||
}
|
||
|
||
// Get label rotated position
|
||
PointF[] labelPosition = new PointF[] { new PointF(areaCenterAbs.X, plotAreaRectAbs.Y) };
|
||
labelPosition[0].Y += labelsSizeEstimate;
|
||
labelPosition[0].Y -= spacing;
|
||
Matrix newMatrix = new Matrix();
|
||
newMatrix.RotateAt(textAngle, areaCenterAbs);
|
||
newMatrix.TransformPoints(labelPosition);
|
||
|
||
// Calculate label position
|
||
RectangleF curLabelPosition = new RectangleF(
|
||
labelPosition[0].X,
|
||
labelPosition[0].Y - textSize.Height / 2f,
|
||
textSize.Width,
|
||
textSize.Height);
|
||
if (textAngle < 5f)
|
||
{
|
||
curLabelPosition.X = labelPosition[0].X - textSize.Width / 2f;
|
||
curLabelPosition.Y = labelPosition[0].Y - textSize.Height;
|
||
}
|
||
if (textAngle > 175f)
|
||
{
|
||
curLabelPosition.X = labelPosition[0].X - textSize.Width / 2f;
|
||
curLabelPosition.Y = labelPosition[0].Y;
|
||
}
|
||
|
||
// Decrease label rectangle
|
||
curLabelPosition.Inflate(0f, -curLabelPosition.Height * 0.15f);
|
||
|
||
// Check if label position goes outside of the Common.Chart area.
|
||
if (!areaRectAbs.Contains(curLabelPosition))
|
||
{
|
||
// Label is not inside Common.Chart area
|
||
labelsFit = false;
|
||
break;
|
||
}
|
||
|
||
// Check if label position overlap previous label position.
|
||
if (!prevLabelPosition.IsEmpty && curLabelPosition.IntersectsWith(prevLabelPosition))
|
||
{
|
||
// Label intersects with previous label
|
||
labelsFit = false;
|
||
break;
|
||
}
|
||
|
||
// Set previous point position
|
||
prevLabelPosition = curLabelPosition;
|
||
}
|
||
}
|
||
|
||
return labelsFit;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Axis labels auto-fitting methods
|
||
|
||
/// <summary>
|
||
/// Adjust labels font size at second pass of auto fitting.
|
||
/// </summary>
|
||
/// <param name="chartGraph">Chart graphics object.</param>
|
||
/// <param name="autoPlotPosition">Indicates that inner plot position is automatic.</param>
|
||
internal void AdjustLabelFontAtSecondPass(ChartGraphics chartGraph, bool autoPlotPosition)
|
||
{
|
||
#if SUBAXES
|
||
// Process all sub-axis
|
||
if(!ChartArea.Area3DStyle.Enable3D &&
|
||
!ChartArea.chartAreaIsCurcular)
|
||
{
|
||
foreach(SubAxis subAxis in this.SubAxes)
|
||
{
|
||
subAxis.AdjustLabelFontAtSecondPass(chartGraph, autoPlotPosition);
|
||
}
|
||
}
|
||
#endif //SUBAXES
|
||
|
||
|
||
//******************************************************
|
||
//** First try to select the interval that will
|
||
//** generate best fit labels.
|
||
//******************************************************
|
||
|
||
|
||
|
||
// Make sure the variable interval mode is enabled
|
||
if( this.Enabled != AxisEnabled.False &&
|
||
this.LabelStyle.Enabled &&
|
||
this.IsVariableLabelCountModeEnabled() )
|
||
{
|
||
// Set font for labels fitting
|
||
if(this.autoLabelFont == null)
|
||
{
|
||
this.autoLabelFont = this.LabelStyle.Font;
|
||
}
|
||
|
||
// Reset angle and stagged flag used in the auto-fitting algorithm
|
||
if(this.autoLabelAngle < 0)
|
||
{
|
||
this.autoLabelAngle = this.LabelStyle.Angle;
|
||
}
|
||
if(this.autoLabelOffset < 0)
|
||
{
|
||
this.autoLabelOffset = (this.LabelStyle.IsStaggered) ? 1 : 0;
|
||
}
|
||
|
||
// Check labels fit
|
||
bool fitDone = CheckLabelsFit(
|
||
chartGraph,
|
||
this.markSize + this.scrollBarSize + this.titleSize,
|
||
autoPlotPosition,
|
||
true,
|
||
true,
|
||
(this.AxisPosition == AxisPosition.Left || this.AxisPosition == AxisPosition.Right) ? false : true,
|
||
(this.AxisPosition == AxisPosition.Left || this.AxisPosition == AxisPosition.Right) ? true : false,
|
||
null);
|
||
|
||
// If there is a problem fitting labels try to reduce number of labels by
|
||
// increasing of the interval.
|
||
if(!fitDone)
|
||
{
|
||
// Adjust interval
|
||
this.AdjustIntervalToFitLabels(chartGraph, autoPlotPosition, true);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
//******************************************************
|
||
//** If labels auto-fit is on try reducing font size.
|
||
//******************************************************
|
||
|
||
totlaGroupingLabelsSizeAdjustment = 0f;
|
||
if (this.IsLabelAutoFit &&
|
||
this.LabelAutoFitStyle != LabelAutoFitStyles.None &&
|
||
this.Enabled != AxisEnabled.False)
|
||
{
|
||
bool fitDone = false;
|
||
|
||
if (autoLabelFont == null)
|
||
{
|
||
autoLabelFont = this.LabelStyle.Font;
|
||
}
|
||
|
||
// Loop while labels do not fit
|
||
float oldLabelSecondRowSize = totlaGroupingLabelsSize;
|
||
while (!fitDone)
|
||
{
|
||
//******************************************************
|
||
//** Check if labels fit
|
||
//******************************************************
|
||
fitDone = CheckLabelsFit(
|
||
chartGraph,
|
||
this.markSize + this.scrollBarSize + this.titleSize,
|
||
autoPlotPosition,
|
||
true,
|
||
true);
|
||
|
||
//******************************************************
|
||
//** Adjust labels text properties to fit
|
||
//******************************************************
|
||
if (!fitDone)
|
||
{
|
||
// Try to reduce font
|
||
if (autoLabelFont.SizeInPoints > _minLabelFontSize)
|
||
{
|
||
// Reduce auto fit font
|
||
if (ChartArea != null && ChartArea.IsSameFontSizeForAllAxes)
|
||
{
|
||
// Same font for all axes
|
||
foreach (Axis currentAxis in ChartArea.Axes)
|
||
{
|
||
if (currentAxis.enabled && currentAxis.IsLabelAutoFit && currentAxis.autoLabelFont != null)
|
||
{
|
||
currentAxis.autoLabelFont = Common.Chart.chartPicture.FontCache.GetFont(
|
||
currentAxis.autoLabelFont.FontFamily,
|
||
autoLabelFont.SizeInPoints - 1,
|
||
currentAxis.autoLabelFont.Style,
|
||
GraphicsUnit.Point);
|
||
}
|
||
}
|
||
}
|
||
else if ((this.LabelAutoFitStyle & LabelAutoFitStyles.DecreaseFont) == LabelAutoFitStyles.DecreaseFont)
|
||
{
|
||
autoLabelFont = Common.Chart.chartPicture.FontCache.GetFont(
|
||
autoLabelFont.FontFamily,
|
||
autoLabelFont.SizeInPoints - 1,
|
||
autoLabelFont.Style,
|
||
GraphicsUnit.Point);
|
||
}
|
||
else
|
||
{
|
||
// Failed to fit
|
||
fitDone = true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Failed to fit
|
||
fitDone = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
this.totlaGroupingLabelsSizeAdjustment = oldLabelSecondRowSize - totlaGroupingLabelsSize;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Check if axis is logarithmic
|
||
/// </summary>
|
||
/// <param name="yValue">Y value from data</param>
|
||
/// <returns>Corected Y value if axis is logarithmic</returns>
|
||
internal double GetLogValue(double yValue)
|
||
{
|
||
// Check if axis is logarithmic
|
||
if (this.IsLogarithmic)
|
||
{
|
||
yValue = Math.Log(yValue, this.logarithmBase);
|
||
}
|
||
|
||
return yValue;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Checks if labels fit using current auto fit properties
|
||
/// </summary>
|
||
/// <param name="chartGraph">Chart graphics object.</param>
|
||
/// <param name="otherElementsSize">Axis title and marks size.</param>
|
||
/// <param name="autoPlotPosition">Indicates auto calculation of plotting area.</param>
|
||
/// <param name="checkLabelsFirstRowOnly">Labels fit is checked during the second pass.</param>
|
||
/// <param name="secondPass">Indicates second pass of labels fitting.</param>
|
||
/// <returns>True if labels fit.</returns>
|
||
private bool CheckLabelsFit(
|
||
ChartGraphics chartGraph,
|
||
float otherElementsSize,
|
||
bool autoPlotPosition,
|
||
bool checkLabelsFirstRowOnly,
|
||
bool secondPass)
|
||
{
|
||
return this.CheckLabelsFit(
|
||
chartGraph,
|
||
otherElementsSize,
|
||
autoPlotPosition,
|
||
checkLabelsFirstRowOnly,
|
||
secondPass,
|
||
true,
|
||
true,
|
||
null);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Checks if labels fit using current auto fit properties
|
||
/// </summary>
|
||
/// <param name="chartGraph">Chart graphics object.</param>
|
||
/// <param name="otherElementsSize">Axis title and marks size.</param>
|
||
/// <param name="autoPlotPosition">Indicates auto calculation of plotting area.</param>
|
||
/// <param name="checkLabelsFirstRowOnly">Labels fit is checked during the second pass.</param>
|
||
/// <param name="secondPass">Indicates second pass of labels fitting.</param>
|
||
/// <param name="checkWidth">True if width should be checked.</param>
|
||
/// <param name="checkHeight">True if height should be checked.</param>
|
||
/// <param name="labelPositions">Returns an array of label positions.</param>
|
||
/// <returns>True if labels fit.</returns>
|
||
private bool CheckLabelsFit(
|
||
ChartGraphics chartGraph,
|
||
float otherElementsSize,
|
||
bool autoPlotPosition,
|
||
bool checkLabelsFirstRowOnly,
|
||
bool secondPass,
|
||
bool checkWidth,
|
||
bool checkHeight,
|
||
ArrayList labelPositions)
|
||
{
|
||
// Reset list of label positions
|
||
if (labelPositions != null)
|
||
{
|
||
labelPositions.Clear();
|
||
}
|
||
|
||
// Label string drawing format
|
||
using (StringFormat format = new StringFormat())
|
||
{
|
||
format.FormatFlags |= StringFormatFlags.LineLimit;
|
||
format.Trimming = StringTrimming.EllipsisCharacter;
|
||
|
||
// Initialize all labels position rectangle
|
||
RectangleF rect = RectangleF.Empty;
|
||
|
||
// Calculate max label size
|
||
float maxLabelSize = 0;
|
||
if (!autoPlotPosition)
|
||
{
|
||
if (this.GetIsMarksNextToAxis())
|
||
{
|
||
if (this.AxisPosition == AxisPosition.Top)
|
||
maxLabelSize = (float)GetAxisPosition() - ChartArea.Position.Y;
|
||
else if (this.AxisPosition == AxisPosition.Bottom)
|
||
maxLabelSize = ChartArea.Position.Bottom - (float)GetAxisPosition();
|
||
if (this.AxisPosition == AxisPosition.Left)
|
||
maxLabelSize = (float)GetAxisPosition() - ChartArea.Position.X;
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
maxLabelSize = ChartArea.Position.Right - (float)GetAxisPosition();
|
||
}
|
||
else
|
||
{
|
||
if (this.AxisPosition == AxisPosition.Top)
|
||
maxLabelSize = this.PlotAreaPosition.Y - ChartArea.Position.Y;
|
||
else if (this.AxisPosition == AxisPosition.Bottom)
|
||
maxLabelSize = ChartArea.Position.Bottom - this.PlotAreaPosition.Bottom;
|
||
if (this.AxisPosition == AxisPosition.Left)
|
||
maxLabelSize = this.PlotAreaPosition.X - ChartArea.Position.X;
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
maxLabelSize = ChartArea.Position.Right - this.PlotAreaPosition.Right;
|
||
}
|
||
maxLabelSize *= 2F;
|
||
}
|
||
else
|
||
{
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
maxLabelSize = ChartArea.Position.Height;
|
||
else
|
||
maxLabelSize = ChartArea.Position.Width;
|
||
}
|
||
|
||
// Loop through all grouping labels (all except first row)
|
||
this.totlaGroupingLabelsSize = 0;
|
||
|
||
|
||
// Get number of groups
|
||
int groupLabelLevelCount = GetGroupLabelLevelCount();
|
||
|
||
// Check ig grouping labels exist
|
||
if (groupLabelLevelCount > 0)
|
||
{
|
||
groupingLabelSizes = new float[groupLabelLevelCount];
|
||
|
||
// Loop through each level of grouping labels
|
||
bool fitResult = true;
|
||
for (int groupLevelIndex = 1; groupLevelIndex <= groupLabelLevelCount; groupLevelIndex++)
|
||
{
|
||
groupingLabelSizes[groupLevelIndex - 1] = 0f;
|
||
|
||
// Loop through all labels in the level
|
||
foreach (CustomLabel label in this.CustomLabels)
|
||
{
|
||
// Skip if label middle point is outside current scaleView
|
||
if (label.RowIndex == 0)
|
||
{
|
||
double middlePoint = (label.FromPosition + label.ToPosition) / 2.0;
|
||
if (middlePoint < this.ViewMinimum || middlePoint > this.ViewMaximum)
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if (label.RowIndex == groupLevelIndex)
|
||
{
|
||
// Calculate label rect
|
||
double fromPosition = this.GetLinearPosition(label.FromPosition);
|
||
double toPosition = this.GetLinearPosition(label.ToPosition);
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
rect.Height = (maxLabelSize / 100F) * maxAxisLabelRow2Size / groupLabelLevelCount;
|
||
rect.X = (float)Math.Min(fromPosition, toPosition);
|
||
rect.Width = (float)Math.Max(fromPosition, toPosition) - rect.X;
|
||
}
|
||
else
|
||
{
|
||
rect.Width = (maxLabelSize / 100F) * maxAxisLabelRow2Size / groupLabelLevelCount;
|
||
rect.Y = (float)Math.Min(fromPosition, toPosition);
|
||
rect.Height = (float)Math.Max(fromPosition, toPosition) - rect.Y;
|
||
}
|
||
|
||
// Measure string
|
||
SizeF axisLabelSize = chartGraph.MeasureStringRel(label.Text.Replace("\\n", "\n"), autoLabelFont);
|
||
|
||
// Add image size
|
||
if (label.Image.Length > 0)
|
||
{
|
||
SizeF imageAbsSize = new SizeF();
|
||
|
||
if (this.Common.ImageLoader.GetAdjustedImageSize(label.Image, chartGraph.Graphics, ref imageAbsSize))
|
||
{
|
||
SizeF imageRelSize = chartGraph.GetRelativeSize(imageAbsSize);
|
||
axisLabelSize.Width += imageRelSize.Width;
|
||
axisLabelSize.Height = Math.Max(axisLabelSize.Height, imageRelSize.Height);
|
||
}
|
||
}
|
||
|
||
// Add extra spacing for the box marking of the label
|
||
if (label.LabelMark == LabelMarkStyle.Box)
|
||
{
|
||
// Get relative size from pixels and add it to the label size
|
||
SizeF spacerSize = chartGraph.GetRelativeSize(new SizeF(4, 4));
|
||
axisLabelSize.Width += spacerSize.Width;
|
||
axisLabelSize.Height += spacerSize.Height;
|
||
}
|
||
|
||
// Calculate max height of the second row of labels
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
groupingLabelSizes[groupLevelIndex - 1] = (float)Math.Max(groupingLabelSizes[groupLevelIndex - 1], axisLabelSize.Height);
|
||
}
|
||
else
|
||
{
|
||
axisLabelSize.Width = chartGraph.GetAbsoluteSize(new SizeF(axisLabelSize.Height, axisLabelSize.Height)).Height;
|
||
axisLabelSize.Width = chartGraph.GetRelativeSize(new SizeF(axisLabelSize.Width, axisLabelSize.Width)).Width;
|
||
groupingLabelSizes[groupLevelIndex - 1] = (float)Math.Max(groupingLabelSizes[groupLevelIndex - 1], axisLabelSize.Width);
|
||
}
|
||
|
||
// Check if string fits
|
||
if (Math.Round(axisLabelSize.Width) >= Math.Round(rect.Width) &&
|
||
checkWidth)
|
||
{
|
||
fitResult = false;
|
||
}
|
||
if (Math.Round(axisLabelSize.Height) >= Math.Round(rect.Height) &&
|
||
checkHeight)
|
||
{
|
||
fitResult = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
this.totlaGroupingLabelsSize = this.GetGroupLablesToatalSize();
|
||
if (!fitResult && !checkLabelsFirstRowOnly)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
}
|
||
|
||
// Loop through all labels in the first row
|
||
float angle = autoLabelAngle;
|
||
int labelIndex = 0;
|
||
foreach (CustomLabel label in this.CustomLabels)
|
||
{
|
||
// Skip if label middle point is outside current scaleView
|
||
if (label.RowIndex == 0)
|
||
{
|
||
double middlePoint = (label.FromPosition + label.ToPosition) / 2.0;
|
||
if (middlePoint < this.ViewMinimum || middlePoint > this.ViewMaximum)
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if (label.RowIndex == 0)
|
||
{
|
||
|
||
// Force which scale segment to use when calculating label position
|
||
if (labelPositions != null)
|
||
{
|
||
this.ScaleSegments.EnforceSegment(this.ScaleSegments.FindScaleSegmentForAxisValue((label.FromPosition + label.ToPosition) / 2.0));
|
||
}
|
||
|
||
|
||
// Set label From and To coordinates
|
||
double fromPosition = this.GetLinearPosition(label.FromPosition);
|
||
double toPosition = this.GetLinearPosition(label.ToPosition);
|
||
|
||
|
||
// Reset scale segment to use when calculating label position
|
||
if (labelPositions != null)
|
||
{
|
||
this.ScaleSegments.EnforceSegment(null);
|
||
}
|
||
|
||
|
||
// Calculate single label position
|
||
rect.X = this.PlotAreaPosition.X;
|
||
rect.Y = (float)Math.Min(fromPosition, toPosition);
|
||
rect.Height = (float)Math.Max(fromPosition, toPosition) - rect.Y;
|
||
|
||
float maxElementSize = maxAxisElementsSize;
|
||
if (maxAxisElementsSize - this.totlaGroupingLabelsSize > 55)
|
||
{
|
||
maxElementSize = 55 + this.totlaGroupingLabelsSize;
|
||
}
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
rect.Width = (maxLabelSize / 100F) *
|
||
(maxElementSize - this.totlaGroupingLabelsSize - otherElementsSize - elementSpacing);
|
||
}
|
||
else
|
||
{
|
||
rect.Width = (maxLabelSize / 100F) *
|
||
(maxElementSize - this.totlaGroupingLabelsSize - otherElementsSize - elementSpacing);
|
||
}
|
||
|
||
// Adjust label From/To position if labels are displayed with offset
|
||
if (autoLabelOffset == 1)
|
||
{
|
||
rect.Y -= rect.Height / 2F;
|
||
rect.Height *= 2F;
|
||
rect.Width /= 2F;
|
||
}
|
||
|
||
// If horizontal axis
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
// Switch rectangle sizes
|
||
float val = rect.Height;
|
||
rect.Height = rect.Width;
|
||
rect.Width = val;
|
||
|
||
// Set vertical font for measuring
|
||
if (angle != 0)
|
||
{
|
||
format.FormatFlags |= StringFormatFlags.DirectionVertical;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Set vertical font for measuring
|
||
if (angle == 90 || angle == -90)
|
||
{
|
||
angle = 0;
|
||
format.FormatFlags |= StringFormatFlags.DirectionVertical;
|
||
}
|
||
}
|
||
|
||
// Measure label text size. Add the 'I' character to allow a little bit of spacing between labels.
|
||
SizeF axisLabelSize = chartGraph.MeasureStringRel(
|
||
label.Text.Replace("\\n", "\n") + "W",
|
||
autoLabelFont,
|
||
(secondPass) ? rect.Size : ChartArea.Position.ToRectangleF().Size,
|
||
format);
|
||
|
||
// Width and height maybe zeros if rect is too small to fit the text and
|
||
// the LineLimit format flag is set.
|
||
if (label.Text.Length > 0 &&
|
||
(axisLabelSize.Width == 0f ||
|
||
axisLabelSize.Height == 0f))
|
||
{
|
||
// Measure string without the LineLimit flag
|
||
format.FormatFlags ^= StringFormatFlags.LineLimit;
|
||
axisLabelSize = chartGraph.MeasureStringRel(
|
||
label.Text.Replace("\\n", "\n"),
|
||
autoLabelFont,
|
||
(secondPass) ? rect.Size : ChartArea.Position.ToRectangleF().Size,
|
||
format);
|
||
format.FormatFlags |= StringFormatFlags.LineLimit;
|
||
}
|
||
|
||
|
||
// Add image size
|
||
if (label.Image.Length > 0)
|
||
{
|
||
SizeF imageAbsSize = new SizeF();
|
||
|
||
if(this.Common.ImageLoader.GetAdjustedImageSize(label.Image, chartGraph.Graphics, ref imageAbsSize))
|
||
{
|
||
SizeF imageRelSize = chartGraph.GetRelativeSize(imageAbsSize);
|
||
if ((format.FormatFlags & StringFormatFlags.DirectionVertical) == StringFormatFlags.DirectionVertical)
|
||
{
|
||
axisLabelSize.Height += imageRelSize.Height;
|
||
axisLabelSize.Width = Math.Max(axisLabelSize.Width, imageRelSize.Width);
|
||
}
|
||
else
|
||
{
|
||
axisLabelSize.Width += imageRelSize.Width;
|
||
axisLabelSize.Height = Math.Max(axisLabelSize.Height, imageRelSize.Height);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Add extra spacing for the box marking of the label
|
||
if (label.LabelMark == LabelMarkStyle.Box)
|
||
{
|
||
// Get relative size from pixels and add it to the label size
|
||
SizeF spacerSize = chartGraph.GetRelativeSize(new SizeF(4, 4));
|
||
axisLabelSize.Width += spacerSize.Width;
|
||
axisLabelSize.Height += spacerSize.Height;
|
||
}
|
||
|
||
|
||
// Calculate size using label angle
|
||
float width = axisLabelSize.Width;
|
||
float height = axisLabelSize.Height;
|
||
if (angle != 0)
|
||
{
|
||
// Decrease label rectangle width by 3%
|
||
rect.Width *= 0.97f;
|
||
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
width = (float)Math.Cos((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Height;
|
||
width += (float)Math.Sin((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Width;
|
||
|
||
height = (float)Math.Sin((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Height;
|
||
height += (float)Math.Cos((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Width;
|
||
}
|
||
else
|
||
{
|
||
width = (float)Math.Cos((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Width;
|
||
width += (float)Math.Sin((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Height;
|
||
|
||
height = (float)Math.Sin((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Width;
|
||
height += (float)Math.Cos((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Height;
|
||
}
|
||
}
|
||
|
||
// Save label position
|
||
if (labelPositions != null)
|
||
{
|
||
RectangleF labelPosition = rect;
|
||
if (angle == 0F || angle == 90F || angle == -90F)
|
||
{
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
labelPosition.X = labelPosition.X + labelPosition.Width / 2f - width / 2f;
|
||
labelPosition.Width = width;
|
||
}
|
||
else
|
||
{
|
||
labelPosition.Y = labelPosition.Y + labelPosition.Height / 2f - height / 2f;
|
||
labelPosition.Height = height;
|
||
}
|
||
}
|
||
labelPositions.Add(labelPosition);
|
||
}
|
||
|
||
// Check if string fits
|
||
if (angle == 0F)
|
||
{
|
||
if (width >= rect.Width && checkWidth)
|
||
{
|
||
return false;
|
||
}
|
||
if (height >= rect.Height && checkHeight)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
if (angle == 90F || angle == -90F)
|
||
{
|
||
if (width >= rect.Width && checkWidth)
|
||
{
|
||
return false;
|
||
}
|
||
if (height >= rect.Height && checkHeight)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
if (width >= rect.Width * 2F && checkWidth)
|
||
{
|
||
return false;
|
||
}
|
||
if (height >= rect.Height * 2F && checkHeight)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (width >= rect.Width * 2F && checkWidth)
|
||
{
|
||
return false;
|
||
}
|
||
if (height >= rect.Height * 2F && checkHeight)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
++labelIndex;
|
||
}
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Calculates the best size for labels area.
|
||
/// </summary>
|
||
/// <param name="chartGraph">Chart graphics object.</param>
|
||
/// <param name="maxLabelSize">Maximum labels area size.</param>
|
||
/// <param name="resultSize">Label size without angle = 0.</param>
|
||
private float GetRequiredLabelSize(ChartGraphics chartGraph, float maxLabelSize, out float resultSize)
|
||
{
|
||
float resultRotatedSize = 0F;
|
||
resultSize = 0F;
|
||
float angle = (autoLabelAngle < -90) ? this.LabelStyle.Angle : autoLabelAngle;
|
||
labelNearOffset = float.MaxValue;
|
||
labelFarOffset = float.MinValue;
|
||
|
||
// Label string drawing format
|
||
using (StringFormat format = new StringFormat())
|
||
{
|
||
format.FormatFlags |= StringFormatFlags.LineLimit;
|
||
format.Trimming = StringTrimming.EllipsisCharacter;
|
||
|
||
// Initialize all labels position rectangle
|
||
RectangleF rectLabels = ChartArea.Position.ToRectangleF();
|
||
|
||
// Loop through all labels in the first row
|
||
foreach (CustomLabel label in this.CustomLabels)
|
||
{
|
||
// Skip if label middle point is outside current scaleView
|
||
if (label.RowIndex == 0)
|
||
{
|
||
decimal middlePoint = (decimal)(label.FromPosition + label.ToPosition) / (decimal)2.0;
|
||
if (middlePoint < (decimal)this.ViewMinimum || middlePoint > (decimal)this.ViewMaximum)
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
if (label.RowIndex == 0)
|
||
{
|
||
// Calculate single label position
|
||
RectangleF rect = rectLabels;
|
||
rect.Width = maxLabelSize;
|
||
|
||
// Set label From and To coordinates
|
||
double fromPosition = this.GetLinearPosition(label.FromPosition);
|
||
double toPosition = this.GetLinearPosition(label.ToPosition);
|
||
rect.Y = (float)Math.Min(fromPosition, toPosition);
|
||
rect.Height = (float)Math.Max(fromPosition, toPosition) - rect.Y;
|
||
|
||
// Adjust label From/To position if labels are displayed with offset
|
||
if ((autoLabelOffset == -1) ? this.LabelStyle.IsStaggered : (autoLabelOffset == 1))
|
||
{
|
||
rect.Y -= rect.Height / 2F;
|
||
rect.Height *= 2F;
|
||
}
|
||
|
||
// If horizontal axis
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
// Switch rectangle sizes
|
||
float val = rect.Height;
|
||
rect.Height = rect.Width;
|
||
rect.Width = val;
|
||
|
||
// Set vertical font for measuring
|
||
if (angle != 0)
|
||
{
|
||
format.FormatFlags |= StringFormatFlags.DirectionVertical;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Set vertical font for measuring
|
||
if (angle == 90 || angle == -90)
|
||
{
|
||
angle = 0;
|
||
format.FormatFlags |= StringFormatFlags.DirectionVertical;
|
||
}
|
||
}
|
||
|
||
// Measure label text size
|
||
rect.Width = (float)Math.Ceiling(rect.Width);
|
||
rect.Height = (float)Math.Ceiling(rect.Height);
|
||
SizeF axisLabelSize = chartGraph.MeasureStringRel(label.Text.Replace("\\n", "\n"),
|
||
(autoLabelFont != null) ? autoLabelFont : this.LabelStyle.Font,
|
||
rect.Size,
|
||
format);
|
||
|
||
// Width and height maybe zeros if rect is too small to fit the text and
|
||
// the LineLimit format flag is set.
|
||
if (axisLabelSize.Width == 0f || axisLabelSize.Height == 0f)
|
||
{
|
||
// Measure string without the LineLimit flag
|
||
format.FormatFlags ^= StringFormatFlags.LineLimit;
|
||
axisLabelSize = chartGraph.MeasureStringRel(label.Text.Replace("\\n", "\n"),
|
||
(autoLabelFont != null) ? autoLabelFont : this.LabelStyle.Font,
|
||
rect.Size,
|
||
format);
|
||
format.FormatFlags |= StringFormatFlags.LineLimit;
|
||
}
|
||
|
||
|
||
// Add image size
|
||
if (label.Image.Length > 0)
|
||
{
|
||
SizeF imageAbsSize = new SizeF();
|
||
|
||
if (this.Common.ImageLoader.GetAdjustedImageSize(label.Image, chartGraph.Graphics, ref imageAbsSize))
|
||
{
|
||
SizeF imageRelSize = chartGraph.GetRelativeSize(imageAbsSize);
|
||
|
||
if ((format.FormatFlags & StringFormatFlags.DirectionVertical) == StringFormatFlags.DirectionVertical)
|
||
{
|
||
axisLabelSize.Height += imageRelSize.Height;
|
||
axisLabelSize.Width = Math.Max(axisLabelSize.Width, imageRelSize.Width);
|
||
}
|
||
else
|
||
{
|
||
axisLabelSize.Width += imageRelSize.Width;
|
||
axisLabelSize.Height = Math.Max(axisLabelSize.Height, imageRelSize.Height);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Add extra spacing for the box marking of the label
|
||
if (label.LabelMark == LabelMarkStyle.Box)
|
||
{
|
||
// Get relative size from pixels and add it to the label size
|
||
SizeF spacerSize = chartGraph.GetRelativeSize(new SizeF(4, 4));
|
||
axisLabelSize.Width += spacerSize.Width;
|
||
axisLabelSize.Height += spacerSize.Height;
|
||
}
|
||
|
||
|
||
// Calculate size using label angle
|
||
float width = axisLabelSize.Width;
|
||
float height = axisLabelSize.Height;
|
||
if (angle != 0)
|
||
{
|
||
width = (float)Math.Cos((90 - Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Width;
|
||
width += (float)Math.Cos((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Height;
|
||
|
||
height = (float)Math.Sin((Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Height;
|
||
height += (float)Math.Sin((90 - Math.Abs(angle)) / 180F * Math.PI) * axisLabelSize.Width;
|
||
}
|
||
|
||
width = (float)Math.Ceiling(width) * 1.05f;
|
||
height = (float)Math.Ceiling(height) * 1.05f;
|
||
axisLabelSize.Width = (float)Math.Ceiling(axisLabelSize.Width) * 1.05f;
|
||
axisLabelSize.Height = (float)Math.Ceiling(axisLabelSize.Height) * 1.05f;
|
||
|
||
|
||
// If axis is horizontal
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
if (angle == 90 || angle == -90 || angle == 0)
|
||
{
|
||
resultSize = Math.Max(resultSize, axisLabelSize.Height);
|
||
resultRotatedSize = Math.Max(resultRotatedSize, axisLabelSize.Height);
|
||
|
||
// Calculate the over hang of labels on the side
|
||
labelNearOffset = (float)Math.Min(labelNearOffset, (fromPosition + toPosition) / 2f - axisLabelSize.Width / 2f);
|
||
labelFarOffset = (float)Math.Max(labelFarOffset, (fromPosition + toPosition) / 2f + axisLabelSize.Width / 2f);
|
||
|
||
}
|
||
else
|
||
{
|
||
resultSize = Math.Max(resultSize, axisLabelSize.Height);
|
||
resultRotatedSize = Math.Max(resultRotatedSize, height);
|
||
|
||
// Calculate the over hang of labels on the side
|
||
if (angle > 0)
|
||
{
|
||
labelFarOffset = (float)Math.Max(labelFarOffset, (fromPosition + toPosition) / 2f + width * 1.1f);
|
||
}
|
||
else
|
||
{
|
||
labelNearOffset = (float)Math.Min(labelNearOffset, (fromPosition + toPosition) / 2f - width * 1.1f);
|
||
}
|
||
}
|
||
}
|
||
// If axis is vertical
|
||
else
|
||
{
|
||
if (angle == 90 || angle == -90 || angle == 0)
|
||
{
|
||
resultSize = Math.Max(resultSize, axisLabelSize.Width);
|
||
resultRotatedSize = Math.Max(resultRotatedSize, axisLabelSize.Width);
|
||
|
||
// Calculate the over hang of labels on the side
|
||
labelNearOffset = (float)Math.Min(labelNearOffset, (fromPosition + toPosition) / 2f - axisLabelSize.Height / 2f);
|
||
labelFarOffset = (float)Math.Max(labelFarOffset, (fromPosition + toPosition) / 2f + axisLabelSize.Height / 2f);
|
||
}
|
||
else
|
||
{
|
||
resultSize = Math.Max(resultSize, axisLabelSize.Width);
|
||
resultRotatedSize = Math.Max(resultRotatedSize, width);
|
||
|
||
// Calculate the over hang of labels on the side
|
||
if (angle > 0)
|
||
{
|
||
labelFarOffset = (float)Math.Max(labelFarOffset, (fromPosition + toPosition) / 2f + height * 1.1f);
|
||
}
|
||
else
|
||
{
|
||
labelNearOffset = (float)Math.Min(labelNearOffset, (fromPosition + toPosition) / 2f - height * 1.1f);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Check if we exceed the maximum value
|
||
if (resultSize > maxLabelSize)
|
||
{
|
||
resultSize = maxLabelSize;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Adjust results if labels are displayed with offset
|
||
if ((autoLabelOffset == -1) ? this.LabelStyle.IsStaggered : (autoLabelOffset == 1))
|
||
{
|
||
resultSize *= 2F;
|
||
resultRotatedSize *= 2F;
|
||
|
||
// Check if we exceed the maximum value
|
||
if (resultSize > maxLabelSize)
|
||
{
|
||
resultSize = maxLabelSize;
|
||
resultRotatedSize = maxLabelSize;
|
||
}
|
||
}
|
||
|
||
// Adjust labels size for the 3D Common.Chart
|
||
if (ChartArea.Area3DStyle.Enable3D && !ChartArea.chartAreaIsCurcular)
|
||
{
|
||
// Increase labels size
|
||
resultSize *= 1.1f;
|
||
resultRotatedSize *= 1.1f;
|
||
}
|
||
|
||
return resultRotatedSize;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets total size of all grouping labels.
|
||
/// </summary>
|
||
/// <returns>Total size of all grouping labels.</returns>
|
||
internal float GetGroupLablesToatalSize()
|
||
{
|
||
float size = 0f;
|
||
if (this.groupingLabelSizes != null && this.groupingLabelSizes.Length > 0)
|
||
{
|
||
foreach (float val in this.groupingLabelSizes)
|
||
{
|
||
size += val;
|
||
}
|
||
}
|
||
|
||
return size;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets number of levels of the grouping labels.
|
||
/// </summary>
|
||
/// <returns>Number of levels of the grouping labels.</returns>
|
||
internal int GetGroupLabelLevelCount()
|
||
{
|
||
int groupLabelLevel = 0;
|
||
foreach (CustomLabel label in this.CustomLabels)
|
||
{
|
||
if (label.RowIndex > 0)
|
||
{
|
||
groupLabelLevel = Math.Max(groupLabelLevel, label.RowIndex);
|
||
}
|
||
}
|
||
|
||
return groupLabelLevel;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Calculates the best size for axis labels for all rows except first one (grouping labels).
|
||
/// </summary>
|
||
/// <param name="chartGraph">Chart graphics object.</param>
|
||
/// <param name="maxLabelSize">Maximum labels area size.</param>
|
||
/// <returns>Array of grouping label sizes for each level.</returns>
|
||
private float[] GetRequiredGroupLabelSize(ChartGraphics chartGraph, float maxLabelSize)
|
||
{
|
||
float[] resultSize = null;
|
||
|
||
// Get number of groups
|
||
int groupLabelLevelCount = GetGroupLabelLevelCount();
|
||
|
||
// Check ig grouping labels exist
|
||
if (groupLabelLevelCount > 0)
|
||
{
|
||
// Create result array
|
||
resultSize = new float[groupLabelLevelCount];
|
||
|
||
// Loop through each level of grouping labels
|
||
for (int groupLevelIndex = 1; groupLevelIndex <= groupLabelLevelCount; groupLevelIndex++)
|
||
{
|
||
resultSize[groupLevelIndex - 1] = 0f;
|
||
|
||
// Loop through all labels in the level
|
||
foreach (CustomLabel label in this.CustomLabels)
|
||
{
|
||
// Skip if label middle point is outside current scaleView
|
||
if (label.RowIndex == 0)
|
||
{
|
||
double middlePoint = (label.FromPosition + label.ToPosition) / 2.0;
|
||
if (middlePoint < this.ViewMinimum || middlePoint > this.ViewMaximum)
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if (label.RowIndex == groupLevelIndex)
|
||
{
|
||
// Measure label text size
|
||
SizeF axisLabelSize = chartGraph.MeasureStringRel(label.Text.Replace("\\n", "\n"), (autoLabelFont != null) ? autoLabelFont : this.LabelStyle.Font);
|
||
axisLabelSize.Width = (float)Math.Ceiling(axisLabelSize.Width);
|
||
axisLabelSize.Height = (float)Math.Ceiling(axisLabelSize.Height);
|
||
|
||
|
||
// Add image size
|
||
if(label.Image.Length > 0)
|
||
{
|
||
SizeF imageAbsSize = new SizeF();
|
||
|
||
if(this.Common.ImageLoader.GetAdjustedImageSize(label.Image, chartGraph.Graphics, ref imageAbsSize))
|
||
{
|
||
SizeF imageRelSize = chartGraph.GetRelativeSize(imageAbsSize);
|
||
axisLabelSize.Width += imageRelSize.Width;
|
||
axisLabelSize.Height = Math.Max(axisLabelSize.Height, imageRelSize.Height);
|
||
}
|
||
}
|
||
|
||
// Add extra spacing for the box marking of the label
|
||
if(label.LabelMark == LabelMarkStyle.Box)
|
||
{
|
||
// Get relative size from pixels and add it to the label size
|
||
SizeF spacerSize = chartGraph.GetRelativeSize(new SizeF(4, 4));
|
||
axisLabelSize.Width += spacerSize.Width;
|
||
axisLabelSize.Height += spacerSize.Height;
|
||
}
|
||
|
||
|
||
|
||
// If axis is horizontal
|
||
if (this.AxisPosition == AxisPosition.Bottom || this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
resultSize[groupLevelIndex - 1] = Math.Max(resultSize[groupLevelIndex - 1], axisLabelSize.Height);
|
||
}
|
||
// If axis is vertical
|
||
else
|
||
{
|
||
axisLabelSize.Width = chartGraph.GetAbsoluteSize(new SizeF(axisLabelSize.Height, axisLabelSize.Height)).Height;
|
||
axisLabelSize.Width = chartGraph.GetRelativeSize(new SizeF(axisLabelSize.Width, axisLabelSize.Width)).Width;
|
||
resultSize[groupLevelIndex - 1] = Math.Max(resultSize[groupLevelIndex - 1], axisLabelSize.Width);
|
||
}
|
||
|
||
// Check if we exceed the maximum value
|
||
if (resultSize[groupLevelIndex - 1] > maxLabelSize / groupLabelLevelCount)
|
||
{
|
||
// NOTE: Group Labels size limitations are removed !!!
|
||
// resultSize[groupLevelIndex - 1] = maxLabelSize / groupLabelLevelCount;
|
||
// break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return resultSize;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Axis helper methods
|
||
|
||
|
||
/// <summary>
|
||
/// Gets main or sub axis associated with this axis.
|
||
/// </summary>
|
||
/// <param name="subAxisName">Sub axis name or empty string to get the main axis.</param>
|
||
/// <returns>Main or sub axis of the main axis.</returns>
|
||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "subAxisName")]
|
||
internal Axis GetSubAxis(string subAxisName)
|
||
{
|
||
#if SUBAXES
|
||
if(!this.IsSubAxis && subAxisName.Length > 0)
|
||
{
|
||
SubAxis subAxis = this.SubAxes.FindByName(subAxisName);
|
||
if(subAxis == null)
|
||
{
|
||
throw(new InvalidOperationException( SR.ExceptionSubAxisNameNotFoundShort( subAxisName )));
|
||
}
|
||
return subAxis;
|
||
}
|
||
#endif // SUBAXES
|
||
return this;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Checks if axis marks should be next to the axis
|
||
/// </summary>
|
||
/// <returns>true if marks are next to axis.</returns>
|
||
internal bool GetIsMarksNextToAxis()
|
||
{
|
||
if (ChartArea != null && ChartArea.chartAreaIsCurcular)
|
||
{
|
||
return true;
|
||
}
|
||
return this.IsMarksNextToAxis;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets axis auto interval type.
|
||
/// </summary>
|
||
/// <returns>Axis interval type.</returns>
|
||
internal DateTimeIntervalType GetAxisIntervalType()
|
||
{
|
||
if(InternalIntervalType == DateTimeIntervalType.Auto)
|
||
{
|
||
if(GetAxisValuesType() == ChartValueType.DateTime ||
|
||
GetAxisValuesType() == ChartValueType.Date ||
|
||
GetAxisValuesType() == ChartValueType.Time ||
|
||
GetAxisValuesType() == ChartValueType.DateTimeOffset)
|
||
{
|
||
return DateTimeIntervalType.Years;
|
||
}
|
||
|
||
return DateTimeIntervalType.Number;
|
||
}
|
||
|
||
return InternalIntervalType;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets axis values type depending on the series attached
|
||
/// </summary>
|
||
/// <returns>Axis values type.</returns>
|
||
internal ChartValueType GetAxisValuesType()
|
||
{
|
||
ChartValueType type = ChartValueType.Double;
|
||
|
||
// Check all series in this Common.Chart area attached to this axis
|
||
if (this.Common != null && this.Common.DataManager.Series != null && ChartArea != null)
|
||
{
|
||
foreach (Series series in this.Common.DataManager.Series)
|
||
{
|
||
bool seriesAttached = false;
|
||
|
||
// Check series name
|
||
if (series.ChartArea == ChartArea.Name && series.IsVisible())
|
||
{
|
||
// Check if axis type of series match
|
||
if (this.axisType == AxisName.X && series.XAxisType == AxisType.Primary)
|
||
{
|
||
#if SUBAXES
|
||
if(((Axis)this).SubAxisName == series.XSubAxisName)
|
||
#endif // SUBAXES
|
||
{
|
||
seriesAttached = true;
|
||
}
|
||
}
|
||
else if (this.axisType == AxisName.X2 && series.XAxisType == AxisType.Secondary)
|
||
{
|
||
#if SUBAXES
|
||
if(((Axis)this).SubAxisName == series.XSubAxisName)
|
||
#endif // SUBAXES
|
||
{
|
||
seriesAttached = true;
|
||
}
|
||
}
|
||
else if (this.axisType == AxisName.Y && series.YAxisType == AxisType.Primary)
|
||
{
|
||
#if SUBAXES
|
||
if(((Axis)this).SubAxisName == series.YSubAxisName)
|
||
#endif // SUBAXES
|
||
{
|
||
seriesAttached = true;
|
||
}
|
||
}
|
||
else if (this.axisType == AxisName.Y2 && series.YAxisType == AxisType.Secondary)
|
||
{
|
||
#if SUBAXES
|
||
if(((Axis)this).SubAxisName == series.YSubAxisName)
|
||
#endif // SUBAXES
|
||
{
|
||
seriesAttached = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
// If series attached to this axes
|
||
if (seriesAttached)
|
||
{
|
||
if (this.axisType == AxisName.X || this.axisType == AxisName.X2)
|
||
{
|
||
type = series.XValueType;
|
||
}
|
||
else if (this.axisType == AxisName.Y || this.axisType == AxisName.Y2)
|
||
{
|
||
type = series.YValueType;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return type;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns Arrow size
|
||
/// </summary>
|
||
/// <param name="arrowOrientation">Return arrow orientation.</param>
|
||
/// <returns>Size of arrow</returns>
|
||
internal SizeF GetArrowSize(out ArrowOrientation arrowOrientation)
|
||
{
|
||
Axis opositeAxis;
|
||
double size;
|
||
double sizeOpposite;
|
||
arrowOrientation = ArrowOrientation.Top;
|
||
|
||
// Set the position of axis
|
||
switch (AxisPosition)
|
||
{
|
||
case AxisPosition.Left:
|
||
|
||
if (isReversed)
|
||
arrowOrientation = ArrowOrientation.Bottom;
|
||
else
|
||
arrowOrientation = ArrowOrientation.Top;
|
||
|
||
break;
|
||
case AxisPosition.Right:
|
||
|
||
if (isReversed)
|
||
arrowOrientation = ArrowOrientation.Bottom;
|
||
else
|
||
arrowOrientation = ArrowOrientation.Top;
|
||
|
||
break;
|
||
case AxisPosition.Bottom:
|
||
|
||
if (isReversed)
|
||
arrowOrientation = ArrowOrientation.Left;
|
||
else
|
||
arrowOrientation = ArrowOrientation.Right;
|
||
|
||
break;
|
||
case AxisPosition.Top:
|
||
|
||
if (isReversed)
|
||
arrowOrientation = ArrowOrientation.Left;
|
||
else
|
||
arrowOrientation = ArrowOrientation.Right;
|
||
|
||
break;
|
||
}
|
||
|
||
// Opposite axis. Arrow uses this axis to find
|
||
// a shift from Common.Chart area border. This shift
|
||
// depend on Tick mark size.
|
||
switch (arrowOrientation)
|
||
{
|
||
case ArrowOrientation.Left:
|
||
opositeAxis = ChartArea.AxisX;
|
||
break;
|
||
case ArrowOrientation.Right:
|
||
opositeAxis = ChartArea.AxisX2;
|
||
break;
|
||
case ArrowOrientation.Top:
|
||
opositeAxis = ChartArea.AxisY2;
|
||
break;
|
||
case ArrowOrientation.Bottom:
|
||
opositeAxis = ChartArea.AxisY;
|
||
break;
|
||
default:
|
||
opositeAxis = ChartArea.AxisX;
|
||
break;
|
||
}
|
||
|
||
// Arrow size has to have the same shape when width and height
|
||
// are changed. When the picture is resized, width of the Common.Chart
|
||
// picture is used only for arrow size.
|
||
if (arrowOrientation == ArrowOrientation.Top || arrowOrientation == ArrowOrientation.Bottom)
|
||
{
|
||
size = _lineWidth;
|
||
sizeOpposite = (double)(_lineWidth) * Common.Width / Common.Height;
|
||
}
|
||
else
|
||
{
|
||
size = (double)(_lineWidth) * Common.Width / Common.Height;
|
||
sizeOpposite = _lineWidth;
|
||
}
|
||
|
||
// Arrow is sharp triangle
|
||
if (_arrowStyle == AxisArrowStyle.SharpTriangle)
|
||
{
|
||
// Arrow direction is vertical
|
||
if (arrowOrientation == ArrowOrientation.Top || arrowOrientation == ArrowOrientation.Bottom)
|
||
return new SizeF((float)(size * 2), (float)(opositeAxis.MajorTickMark.Size + sizeOpposite * 4));
|
||
else
|
||
// Arrow direction is horizontal
|
||
return new SizeF((float)(opositeAxis.MajorTickMark.Size + sizeOpposite * 4), (float)(size * 2));
|
||
}
|
||
// There is no arrow
|
||
else if (_arrowStyle == AxisArrowStyle.None)
|
||
return new SizeF(0, 0);
|
||
else// Arrow is triangle or line type
|
||
{
|
||
// Arrow direction is vertical
|
||
if (arrowOrientation == ArrowOrientation.Top || arrowOrientation == ArrowOrientation.Bottom)
|
||
return new SizeF((float)(size * 2), (float)(opositeAxis.MajorTickMark.Size + sizeOpposite * 2));
|
||
else
|
||
// Arrow direction is horizontal
|
||
return new SizeF((float)(opositeAxis.MajorTickMark.Size + sizeOpposite * 2), (float)(size * 2));
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Checks if arrow with specified orientation will require space
|
||
/// in axis with specified position
|
||
/// </summary>
|
||
/// <param name="arrowOrientation">Arrow orientation.</param>
|
||
/// <param name="axisPosition">Axis position.</param>
|
||
/// <returns>True if arrow will be drawn in axis space</returns>
|
||
private bool IsArrowInAxis(ArrowOrientation arrowOrientation, AxisPosition axisPosition)
|
||
{
|
||
if (axisPosition == AxisPosition.Top && arrowOrientation == ArrowOrientation.Top)
|
||
return true;
|
||
else if (axisPosition == AxisPosition.Bottom && arrowOrientation == ArrowOrientation.Bottom)
|
||
return true;
|
||
if (axisPosition == AxisPosition.Left && arrowOrientation == ArrowOrientation.Left)
|
||
return true;
|
||
else if (axisPosition == AxisPosition.Right && arrowOrientation == ArrowOrientation.Right)
|
||
return true;
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// This function converts real Interval to
|
||
/// absolute Interval
|
||
/// </summary>
|
||
/// <param name="realInterval">A interval represented as double value</param>
|
||
/// <returns>A interval represented in pixels</returns>
|
||
internal float GetPixelInterval(double realInterval)
|
||
{
|
||
double chartAreaSize;
|
||
|
||
// The Chart area pixel size as double
|
||
if (AxisPosition == AxisPosition.Top || AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
chartAreaSize = PlotAreaPosition.Right - PlotAreaPosition.X;
|
||
}
|
||
else
|
||
{
|
||
chartAreaSize = PlotAreaPosition.Bottom - PlotAreaPosition.Y;
|
||
}
|
||
|
||
// Avoid division by zero.
|
||
if (ViewMaximum - ViewMinimum == 0)
|
||
{
|
||
return (float)(chartAreaSize / realInterval);
|
||
}
|
||
|
||
// The interval integer
|
||
return (float)(chartAreaSize / (ViewMaximum - ViewMinimum) * realInterval);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Find if axis is on the edge of the Common.Chart plot area
|
||
/// </summary>
|
||
internal bool IsAxisOnAreaEdge
|
||
{
|
||
get
|
||
{
|
||
double edgePosition = 0;
|
||
if (this.AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
edgePosition = PlotAreaPosition.Bottom;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Left)
|
||
{
|
||
edgePosition = PlotAreaPosition.X;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Right)
|
||
{
|
||
edgePosition = PlotAreaPosition.Right;
|
||
}
|
||
else if (this.AxisPosition == AxisPosition.Top)
|
||
{
|
||
edgePosition = PlotAreaPosition.Y;
|
||
}
|
||
|
||
// DT Fix : problems with values on edge ~0.0005
|
||
if (Math.Abs(GetAxisPosition() - edgePosition) < 0.0015)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Find axis position using crossing value.
|
||
/// </summary>
|
||
/// <returns>Relative position</returns>
|
||
internal double GetAxisPosition()
|
||
{
|
||
return GetAxisPosition(false);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Find axis position using crossing value.
|
||
/// </summary>
|
||
/// <param name="ignoreCrossing">Axis crossing should be ignored.</param>
|
||
/// <returns>Relative position</returns>
|
||
virtual internal double GetAxisPosition(bool ignoreCrossing)
|
||
{
|
||
Axis axisOpposite = GetOppositeAxis();
|
||
|
||
// Get axis position for circular Common.Chart area
|
||
if (ChartArea != null && ChartArea.chartAreaIsCurcular)
|
||
{
|
||
return PlotAreaPosition.X + PlotAreaPosition.Width / 2f;
|
||
}
|
||
|
||
// Axis is not connected with any series. There is no maximum and minimum
|
||
if (axisOpposite.maximum == axisOpposite.minimum ||
|
||
double.IsNaN(axisOpposite.maximum) ||
|
||
double.IsNaN(axisOpposite.minimum) ||
|
||
maximum == minimum ||
|
||
double.IsNaN(maximum) ||
|
||
double.IsNaN(minimum))
|
||
{
|
||
switch (AxisPosition)
|
||
{
|
||
case AxisPosition.Top:
|
||
return PlotAreaPosition.Y;
|
||
case AxisPosition.Bottom:
|
||
return PlotAreaPosition.Bottom;
|
||
case AxisPosition.Right:
|
||
return PlotAreaPosition.Right;
|
||
case AxisPosition.Left:
|
||
return PlotAreaPosition.X;
|
||
}
|
||
}
|
||
|
||
// Auto crossing enabled
|
||
if (Double.IsNaN(axisOpposite.crossing) || ignoreCrossing)
|
||
{
|
||
// Primary
|
||
if (axisType == AxisName.X || axisType == AxisName.Y)
|
||
return axisOpposite.GetLinearPosition(axisOpposite.ViewMinimum);
|
||
else // Secondary
|
||
return axisOpposite.GetLinearPosition(axisOpposite.ViewMaximum);
|
||
}
|
||
else // Auto crossing disabled
|
||
{
|
||
axisOpposite.crossing = axisOpposite.tempCrossing;
|
||
|
||
if (axisOpposite.crossing < axisOpposite.ViewMinimum)
|
||
{
|
||
axisOpposite.crossing = axisOpposite.ViewMinimum;
|
||
}
|
||
else if (axisOpposite.crossing > axisOpposite.ViewMaximum)
|
||
{
|
||
axisOpposite.crossing = axisOpposite.ViewMaximum;
|
||
}
|
||
}
|
||
|
||
return axisOpposite.GetLinearPosition(axisOpposite.crossing);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Axis 3D helper methods
|
||
|
||
/// <summary>
|
||
/// Returns angle between 2D axis line and it's 3D transformed projection.
|
||
/// </summary>
|
||
/// <returns>Axis projection angle.</returns>
|
||
internal double GetAxisProjectionAngle()
|
||
{
|
||
// Get Z position
|
||
bool axisOnEdge;
|
||
float zPosition = GetMarksZPosition(out axisOnEdge);
|
||
|
||
// Get axis position
|
||
float axisPosition = (float)GetAxisPosition();
|
||
|
||
// Create two points on the sides of the axis
|
||
Point3D[] axisPoints = new Point3D[2];
|
||
if (this.AxisPosition == AxisPosition.Top || this.AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
axisPoints[0] = new Point3D(0f, axisPosition, zPosition);
|
||
axisPoints[1] = new Point3D(100f, axisPosition, zPosition);
|
||
}
|
||
else
|
||
{
|
||
axisPoints[0] = new Point3D(axisPosition, 0f, zPosition);
|
||
axisPoints[1] = new Point3D(axisPosition, 100f, zPosition);
|
||
}
|
||
|
||
// Transform coordinates
|
||
ChartArea.matrix3D.TransformPoints(axisPoints);
|
||
|
||
// Round result
|
||
axisPoints[0].X = (float)Math.Round(axisPoints[0].X, 4);
|
||
axisPoints[0].Y = (float)Math.Round(axisPoints[0].Y, 4);
|
||
axisPoints[1].X = (float)Math.Round(axisPoints[1].X, 4);
|
||
axisPoints[1].Y = (float)Math.Round(axisPoints[1].Y, 4);
|
||
|
||
// Calculate angle
|
||
double angle = 0.0;
|
||
if (this.AxisPosition == AxisPosition.Top || this.AxisPosition == AxisPosition.Bottom)
|
||
{
|
||
angle = Math.Atan((axisPoints[1].Y - axisPoints[0].Y) / (axisPoints[1].X - axisPoints[0].X));
|
||
}
|
||
else
|
||
{
|
||
angle = Math.Atan((axisPoints[1].X - axisPoints[0].X) / (axisPoints[1].Y - axisPoints[0].Y));
|
||
}
|
||
|
||
// Conver to degrees
|
||
return (angle * 180.0) / Math.PI;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region IDisposable Members
|
||
|
||
/// <summary>
|
||
/// Releases unmanaged and - optionally - managed resources
|
||
/// </summary>
|
||
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
|
||
protected override void Dispose(bool disposing)
|
||
{
|
||
if (disposing)
|
||
{
|
||
if (_fontCache != null)
|
||
{
|
||
_fontCache.Dispose();
|
||
_fontCache = null;
|
||
}
|
||
|
||
if (labelStyle != null)
|
||
{
|
||
labelStyle.Dispose();
|
||
labelStyle = null;
|
||
}
|
||
|
||
if (_stripLines != null)
|
||
{
|
||
_stripLines.Dispose();
|
||
_stripLines = null;
|
||
}
|
||
if (_customLabels != null)
|
||
{
|
||
_customLabels.Dispose();
|
||
_customLabels = null;
|
||
}
|
||
if (tempLabels != null)
|
||
{
|
||
tempLabels.Dispose();
|
||
tempLabels = null;
|
||
}
|
||
#if Microsoft_CONTROL
|
||
if (this.scrollBar != null)
|
||
{
|
||
this.scrollBar.Dispose();
|
||
this.scrollBar = null;
|
||
}
|
||
#endif // Microsoft_CONTROL
|
||
}
|
||
base.Dispose(disposing);
|
||
}
|
||
|
||
|
||
#endregion
|
||
|
||
}
|
||
}
|