Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
c9f4c33ba17d1dd84b0464160c02c77ed276c6e9
SourceCode/PROMS/DotNetBar Source Code/DevComponents.DotNetBar.Charts/ChartControl/SeriesPoints.cs

5682 lines
164 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using DevComponents.DotNetBar.Charts.Style;
namespace DevComponents.DotNetBar.Charts
{
[Editor("DevComponents.Charts.Design.PieSeriesPointCollectionEditor, DevComponents.Charts.Design, " +
"Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public class PieSeriesPointCollection : CustomNamedCollection<PieSeriesPoint>
{
#region Private variables
private ISeriesPointContainer _Parent;
private PieSeriesPointCollection _PieSlices;
private PieSeriesPointCollection _OtherSlices;
private PieSeriesPoint _OtherSlicePsp;
private double _PieTotal;
private double _PieMinExtent;
private double _PieMaxExtent;
private double _PieOuterExtent;
private double _PieTotalExtent;
private double _PieAverage;
private double _PieAverageExtent;
private PieRing _PieRing;
private States _States;
#endregion
#region Public properties
#region IsOther
/// <summary>
/// Gets whether the PieSeriesPoint is the 'Other' slice collection.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool IsOther
{
get { return (TestState(States.Other)); }
internal set { SetState(States.Other, value); }
}
#endregion
#region OtherSlicePsp
/// <summary>
/// Gets the 'Other' slice PieSeriesPoint.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public PieSeriesPoint OtherSlicePsp
{
get
{
if (_OtherSlicePsp == null)
_OtherSlicePsp = new PieSeriesPoint("Other", null, null);
return (_OtherSlicePsp);
}
}
#endregion
#region OtherSlices
/// <summary>
/// Gets the 'Other' slice collection of SeriesPoints.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public PieSeriesPointCollection OtherSlices
{
get { return (_OtherSlices); }
internal set { _OtherSlices = value; }
}
#endregion
#region Parent
/// <summary>
/// Gets the parent of this item.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public ISeriesPointContainer Parent
{
get { return (_Parent); }
internal set { _Parent = value; }
}
#endregion
#region PieAverage
/// <summary>
/// Gets the average pie point 'value' (Y[0]) for the collection.
/// </summary>
/// <returns></returns>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double PieAverage
{
get { return (_PieAverage); }
internal set { _PieAverage = value; }
}
#endregion
#region PieAverageExtent
/// <summary>
/// Gets the average extent for the collection.
/// </summary>
/// <returns></returns>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double PieAverageExtent
{
get { return (_PieAverageExtent); }
internal set { _PieAverageExtent = value; }
}
#endregion
#region PieSlices
/// <summary>
/// Gets the collection of displayed Pie slices.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public PieSeriesPointCollection PieSlices
{
get { return (_PieSlices); }
internal set
{
if (_PieSlices != null)
SetOtherHandler(false);
_PieSlices = value;
if (_PieSlices != null)
SetOtherHandler(true);
}
}
#region SetOtherHandler
private void SetOtherHandler(bool notify)
{
PieSeriesPointCollection spc = _PieSlices;
foreach (PieSeriesPoint psp in spc)
{
if (psp.IsOther == true)
{
SetPointNotify(psp, notify);
break;
}
}
}
#region SetPointNotify
private void SetPointNotify(PieSeriesPoint psp, bool notify)
{
if (notify == true)
{
psp.Parent = this;
psp.PropertyChanged += Sp_PropertyChanged;
}
else
{
psp.Parent = null;
psp.PropertyChanged -= Sp_PropertyChanged;
}
}
#endregion
#region Sp_PropertyChanged
void Sp_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
VisualPropertyChangedEventArgs vce = e as VisualPropertyChangedEventArgs;
if (vce != null)
{
PieSeriesPoint psp = sender as PieSeriesPoint;
if (psp != null)
psp.NotifyVisualParent(psp, vce.ChangeType);
}
}
#endregion
#endregion
#endregion
#region PieTotal
/// <summary>
/// Gets the sum total of the pie collection 'values' (Y[0]).
/// </summary>
/// <returns></returns>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double PieTotal
{
get { return (_PieTotal); }
internal set { _PieTotal = value; }
}
#endregion
#region PieTotalExtent
/// <summary>
/// Gets the sum total of the collection 'extents' (Y[1]).
/// </summary>
/// <returns></returns>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double PieTotalExtent
{
get { return (_PieTotalExtent); }
internal set { _PieTotalExtent = value; }
}
#endregion
#region VisibleCount
///<summary>
/// Gets count of visible points in the collection.
///</summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public int VisibleCount
{
get
{
int vcount = 0;
foreach (PieSeriesPoint psp in Items)
{
if (psp.Visible == true)
vcount++;
}
return (vcount);
}
}
#endregion
#endregion
#region Internal properties
#region PieMaxExtent
internal double PieMaxExtent
{
get { return (_PieMaxExtent); }
set { _PieMaxExtent = value; }
}
#endregion
#region PieMinExtent
internal double PieMinExtent
{
get { return (_PieMinExtent); }
set { _PieMinExtent = value; }
}
#endregion
#region PieOuterExtent
internal double PieOuterExtent
{
get { return (_PieOuterExtent); }
set { _PieOuterExtent = value; }
}
#endregion
#region PieRing
internal PieRing PieRing
{
get { return (_PieRing); }
set { _PieRing = value; }
}
#endregion
#endregion
#region ClearItems
protected override void ClearItems()
{
if (Parent is PieSeriesPoint)
{
for (int i = Items.Count - 1; i >= 0; i--)
RemoveItem(i);
}
else
{
CheckReentrancy();
Items.Clear();
OnPropertyChanged(CountString);
OnPropertyChanged(ItemString);
OnCollectionReset();
}
}
#endregion
#region SetSelected
internal void SetSelected(bool select)
{
foreach (PieSeriesPoint psp in Items)
{
if (psp != null)
{
psp.IsSelected = select;
if (psp.SeriesPoints.PieSlices != null)
psp.SeriesPoints.PieSlices.SetSelected(select);
}
}
}
#endregion
#region States
[Flags]
private enum States : uint
{
Other = (1 << 0),
}
#region TestState
private bool TestState(States state)
{
return ((_States & state) == state);
}
#endregion
#region SetState
private void SetState(States state, bool value)
{
if (value == true)
_States |= state;
else
_States &= ~state;
}
#endregion
#endregion
}
#region SliceVisualLayout
[TypeConverter(typeof(BlankExpandableObjectConverter))]
public class SliceVisualLayout : INotifyPropertyChanged, IProcessSerialElement, IDisposable
{
#region Private variables
private ChartVisualElement _Parent;
private double _AngleMargin = double.NaN;
private int _RingWeight = -1;
private int _MaxSlices = -1;
private int _MinExtent = -1;
private double _MinPercent = double.NaN;
private SliceLabelOrientation _InnerLabelOrientation = SliceLabelOrientation.NotSet;
private SliceLabelCropMode _SliceLabelCropMode = SliceLabelCropMode.NotSet;
private SliceLabelVisibility _SliceLabelVisibility = SliceLabelVisibility.NotSet;
private SliceLabelDisplayMode _SliceLabelDisplayMode = SliceLabelDisplayMode.NotSet;
private ChartSliceVisualStyles _SliceVisualStyles;
private ChartSliceVisualStyles _OtherSliceVisualStyles;
private Tbool _ShowSliceWhiteSpace = Tbool.NotSet;
private string _InnerSliceLabel;
private string _OuterSliceLabel;
private double _StartAngle = double.NaN;
private double _SweepAngle = double.NaN;
private SweepDirection _SweepDirection = SweepDirection.NotSet;
private string _ToolTipText;
private PieRefLineDisplayMode _RefLineDisplayMode = PieRefLineDisplayMode.NotSet;
private Tbool _ReferenceLineDisplayOnTop = Tbool.NotSet;
internal PieReferenceLineCollection _ReferenceLines;
#endregion
public SliceVisualLayout(ChartVisualElement parent)
{
_Parent = parent;
}
#region Public properties
#region AngleMargin
/// <summary>
/// Gets or sets the margin used to offset the angle at
/// which the slice sides are rendered. This can be used to
/// create a more 'wedge' shaped slice.
/// </summary>
[Description("Indicates the margin used to offset the angle at which the slice sides are rendered. This can be used to create a more 'wedge' shaped slice.")]
[DefaultValue(double.NaN)]
[Editor("DevComponents.Charts.Design.AngleMarginRangeValueEditor, DevComponents.Charts.Design, " +
"Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public double AngleMargin
{
get { return (_AngleMargin); }
set
{
if (value != _AngleMargin)
{
_AngleMargin = value;
OnPropertyChangedEx("AngleMargin", VisualChangeType.Layout);
}
}
}
#endregion
#region InnerLabelOrientation
/// <summary>
/// Gets or sets the inner label orientation with respect to the slice.
/// </summary>
[Category("Behavior"), DefaultValue(SliceLabelOrientation.NotSet)]
[Description("Indicates the inner label orientation with respect to the slice.")]
public SliceLabelOrientation InnerLabelOrientation
{
get { return (_InnerLabelOrientation); }
set
{
if (value != _InnerLabelOrientation)
{
_InnerLabelOrientation = value;
OnPropertyChangedEx("InnerLabelOrientation", VisualChangeType.Layout);
}
}
}
#endregion
#region InnerSliceLabel
/// <summary>
/// Gets or sets the inner slice label for the pie slice. The label can be
/// straight text, or be comprised of text and formatting specifiers. The label
/// should be specified as (note that brackets denote optional elements):
/// "[text]{keyword[:format]}[text][{...}]".
///
/// Here are the formatting specifiers that can be used with both inner and
/// outer labels:
///
/// "AVG" "A" - Average (angular values).
/// "PCT" "P" - Percent of pie (angular values) - (.025 yields "2.5 %").
/// "TOT" "T" - Total of all values (angluar values).
/// "VAL" "V" - Value percent of pie (angular value) - (.025 yields ".025").
///
/// "AVGX" "AX" - Average (extent/radial values).
/// "PCTX" "PX" - Percent of pie (extent values) - (.025 yields "2.5 %").
/// "TOTX" "TX" - Total of all values (extent values).
/// "VALX" "VX" - Value percent of pie (extent value) - (.025 yields ".025").
///
/// "S" "SNAME" - Series name.
/// "X" - ValueX.
/// "Y", "Y0", "Yn" - ValueY values (where 'n' is index value).
///
/// Example use:
///
/// "{S}\\n{X:yyyy} ({Y:##,##0} - {P:Y1})"
/// "Individual cost {Y:C} and average cost {AVG:C} of goods."
///
/// </summary>
[DefaultValue(null), Category("Label")]
[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
[Description("Indicates the inner slice label for the pie slices (format specifiers {Keyword[:Format]} - " +
"S, X, Y, Y0-Yn, N, [A|AVG][X], [A|PCT][X], [A|TOT][X], [A|VAL][X]. e.g. \"{x:f2},{avg:##.##},{totx:c}\"")]
public string InnerSliceLabel
{
get { return (_InnerSliceLabel); }
set
{
if (String.Equals(value, _InnerSliceLabel) == false)
{
_InnerSliceLabel = value;
OnPropertyChangedEx("InnerSliceLabel", VisualChangeType.Layout);
}
}
}
#endregion
#region MaxSlices
/// <summary>
/// Gets or sets the maximum number of slices to represent in the pie. Any remaining values
/// are consolidated into the 'Other' slice, if shown, or are not displayed at all.
///
/// The slices are counted in the order in which they are displayed. This order is
/// affected by the ReverseSlices property.
/// </summary>
[DefaultValue(-1), Category("Display")]
[Description("Indicates the maximum number of slices to represent in the pie. Any remaining values are consolidated into the 'Other' slice, if shown, or are not displayed at all.")]
public int MaxSlices
{
get { return (_MaxSlices); }
set
{
if (value != _MaxSlices)
{
_MaxSlices = value;
OnPropertyChangedEx("MaxSlices", VisualChangeType.Recalc);
}
}
}
#endregion
#region MinExtent
///<summary>
/// Gets or sets the minimum extent for the collection.
///</summary>
[DefaultValue(-1), Category("Display")]
[Description("Indicates the minimum extent for the collection.")]
public int MinExtent
{
get { return (_MinExtent); }
set
{
if (value != _MinExtent)
{
_MinExtent = value;
OnPropertyChangedEx("MinExtent", Style.VisualChangeType.Recalc);
}
}
}
#endregion
#region MinPercent
/// <summary>
/// Gets or sets the minimum percent-of-total represented in individual slices.
/// Values less than the MinPercent are either accumulated into the 'Other' slice, if shown,
/// or left in the main pie display.
/// Range is 0–1.
/// </summary>
[DefaultValue(double.NaN), Category("Display")]
[Description("Indicates the minimum percent-of-total represented in individual slices. Values less than the MinPercent are accumulated into the 'Other' slice. Range is 0–1.")]
public double MinPercent
{
get { return (_MinPercent); }
set
{
if (value != _MinPercent)
{
_MinPercent = value;
OnPropertyChangedEx("MinPercent", VisualChangeType.Recalc);
}
}
}
#endregion
#region OtherSliceVisualStyles
/// <summary>
/// Gets or sets the default visual style for the series 'Other' slice.
/// </summary>
[Category("Style")]
[Description("Indicates the default visual style for the series 'Other' slice.")]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public ChartSliceVisualStyles OtherSliceVisualStyles
{
get
{
if (_OtherSliceVisualStyles == null)
{
_OtherSliceVisualStyles = new ChartSliceVisualStyles();
StyleChangeHandler(null, _OtherSliceVisualStyles);
}
return (_OtherSliceVisualStyles);
}
set
{
if (_OtherSliceVisualStyles != value)
{
ChartSliceVisualStyles oldValue = _OtherSliceVisualStyles;
_OtherSliceVisualStyles = value;
OnStyleChanged("OtherSliceVisualStyles", oldValue, value);
if (oldValue != null)
oldValue.Dispose();
}
}
}
#endregion
#region OuterSliceLabel
/// <summary>
/// Gets or sets the outer slice label for the pie slice. See InnerSliceLabel for
/// further notes on Format Specifiers.
/// </summary>
[DefaultValue(null), Category("Label")]
[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
[Description("Indicates the inner slice label for the pie slices. See InnerSliceLabel for further notes on Format Specifiers.")]
public string OuterSliceLabel
{
get { return (_OuterSliceLabel); }
set
{
if (String.Equals(value, _OuterSliceLabel) == false)
{
_OuterSliceLabel = value;
OnPropertyChangedEx("OuterSliceLabel", VisualChangeType.Layout);
}
}
}
#endregion
#region Parent
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public ChartVisualElement Parent
{
get { return (_Parent); }
internal set
{
_Parent = value;
UpdateRelations();
}
}
#region UpdateRelations
private void UpdateRelations()
{
foreach (PieReferenceLine line in ReferenceLines)
line.Parent = _Parent;
}
#endregion
#endregion
#region ReferenceLineDisplayMode
/// <summary>
/// Gets or sets the type of pie reference lines to display.
/// </summary>
[Category("Appearance"), DefaultValue(PieRefLineDisplayMode.NotSet)]
[Description("Indicates the type of pie reference lines to display.")]
[Editor("DevComponents.Charts.Design.FlagsEnumUIEditor, DevComponents.Charts.Design, " +
"Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public PieRefLineDisplayMode ReferenceLineDisplayMode
{
get { return (_RefLineDisplayMode); }
set
{
if (value != _RefLineDisplayMode)
{
_RefLineDisplayMode = value;
OnPropertyChangedEx("ReferenceLineDisplayMode", VisualChangeType.Render);
}
}
}
#endregion
#region ReferenceLineDisplayOnTop
/// <summary>
/// Gets or sets whether references lines are displayed on top of chart data.
/// </summary>
[DefaultValue(Tbool.NotSet), Category("Appearance")]
[Description("Indicates whether the reference lines are displayed on top of chart data.")]
public Tbool ReferenceLineDisplayOnTop
{
get { return (_ReferenceLineDisplayOnTop); }
set
{
if (value != _ReferenceLineDisplayOnTop)
{
_ReferenceLineDisplayOnTop = value;
OnPropertyChangedEx("ReferenceLineDisplayOnTop", VisualChangeType.Render);
}
}
}
#endregion
#region ReferenceLines
/// <summary>
/// Gets a reference to the collection of user defined Reference Lines.
/// </summary>
[Category("Appearance")]
[Description("Indicates the collection of user defined Reference Lines.")]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public PieReferenceLineCollection ReferenceLines
{
get
{
if (_ReferenceLines == null)
{
_ReferenceLines = new PieReferenceLineCollection();
_ReferenceLines.CollectionChanged += ReferenceLineCollectionChanged;
}
return (_ReferenceLines);
}
internal set
{
if (_ReferenceLines != null)
_ReferenceLines.CollectionChanged -= ReferenceLineCollectionChanged;
_ReferenceLines = value;
if (_ReferenceLines != null)
_ReferenceLines.CollectionChanged += ReferenceLineCollectionChanged;
}
}
#region ReferenceLineCollectionChanged
void ReferenceLineCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (ChartElement item in e.NewItems)
{
item.Parent = Parent;
item.PropertyChanged += Item_PropertyChanged;
}
break;
case NotifyCollectionChangedAction.Replace:
foreach (ChartElement item in e.OldItems)
{
item.Parent = null;
item.PropertyChanged -= Item_PropertyChanged;
}
foreach (ChartElement item in e.NewItems)
{
item.Parent = Parent;
item.PropertyChanged += Item_PropertyChanged;
}
break;
case NotifyCollectionChangedAction.Remove:
foreach (ChartElement item in e.OldItems)
{
item.Parent = null;
item.PropertyChanged -= Item_PropertyChanged;
}
break;
}
OnPropertyChangedEx("ReferenceLines", VisualChangeType.Render);
}
void Item_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
OnPropertyChanged(e);
}
#endregion
#endregion
#region RingWeight
///<summary>
/// Gets or sets the 'relative' thickness of the associated pie ring, as
/// compared to the relative thickness of other series rings
/// rings.
///</summary>
[DefaultValue(-1), Category("Layout")]
[Description("Indicates the 'relative' thickness of the associated pie ring, as compared to the relative thickness of other series rings. Default is 100.")]
public int RingWeight
{
get { return (_RingWeight); }
set
{
if (value != _RingWeight)
{
_RingWeight = value;
OnPropertyChangedEx("RingWeight", Style.VisualChangeType.Recalc);
}
}
}
#endregion
#region ShowSliceWhiteSpace
/// <summary>
/// Gets or sets whether to display, by default, the full
/// slice (includes potential area beyond slice extent). Default is false.
/// </summary>
[DefaultValue(Tbool.NotSet), Category("Display")]
[Description("Indicates whether to display, by default the full slice (includes potential area beyond slice extent). Default is false.")]
public Tbool ShowSliceWhiteSpace
{
get { return (_ShowSliceWhiteSpace); }
set
{
if (value != _ShowSliceWhiteSpace)
{
_ShowSliceWhiteSpace = value;
OnPropertyChangedEx("ShowSliceWhiteSpace", VisualChangeType.Layout);
}
}
}
#endregion
#region SliceLabelCropMode
/// <summary>
/// Gets or sets the label display mode (ie. the action taken
/// when a label needs be clipped for full display). Default is Clip.
/// </summary>
[DefaultValue(SliceLabelCropMode.NotSet), Category("Label")]
[Description("Indicates the label display mode (ie. the action taken when a label needs clipped for full display). Default is Clip.")]
public SliceLabelCropMode SliceLabelCropMode
{
get { return (_SliceLabelCropMode); }
set
{
if (value != _SliceLabelCropMode)
{
_SliceLabelCropMode = value;
OnPropertyChangedEx("SliceLabelCropMode", VisualChangeType.Layout);
}
}
}
#endregion
#region SliceLabelVisibility
/// <summary>
/// Gets or sets when the slice labels are visibly displayed.
/// </summary>
[DefaultValue(SliceLabelVisibility.NotSet), Category("Label")]
[Description("Indicates when the slice labels are visibly displayed.")]
public SliceLabelVisibility SliceLabelVisibility
{
get { return (_SliceLabelVisibility); }
set
{
if (value != _SliceLabelVisibility)
{
_SliceLabelVisibility = value;
OnPropertyChangedEx("SliceLabelVisibility", VisualChangeType.Layout);
}
}
}
#endregion
#region SliceLabelDisplayMode
/// <summary>
/// Gets or sets the label display mode, which determines
/// which slice labels (inner/outer) are displayed. Default is InnerAndOuter.
/// </summary>
[DefaultValue(SliceLabelDisplayMode.NotSet), Category("Label")]
[Description("Indicates the label display mode, which determines which slice labels (inner/outer) are displayed. Default is InnerAndOuter.")]
public SliceLabelDisplayMode SliceLabelDisplayMode
{
get { return (_SliceLabelDisplayMode); }
set
{
if (value != _SliceLabelDisplayMode)
{
_SliceLabelDisplayMode = value;
OnPropertyChangedEx("SliceLabelDisplayMode", VisualChangeType.Layout);
}
}
}
#endregion
#region SliceVisualStyles
/// <summary>
/// Gets or sets the visual styles for the slice.
/// </summary>
[Category("Style")]
[Description("Indicates the visual styles for the slice.")]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public ChartSliceVisualStyles SliceVisualStyles
{
get
{
if (_SliceVisualStyles == null)
{
_SliceVisualStyles = new ChartSliceVisualStyles();
StyleChangeHandler(null, _SliceVisualStyles);
}
return (_SliceVisualStyles);
}
set
{
if (_SliceVisualStyles != value)
{
ChartSliceVisualStyles oldValue = _SliceVisualStyles;
_SliceVisualStyles = value;
OnStyleChanged("SliceVisualStyles", oldValue, value);
if (oldValue != null)
oldValue.Dispose();
}
}
}
#endregion
#region StartAngle
/// <summary>
/// Gets or sets the start angle of the pie in degrees where 0 is right and 270 is top.
/// Defaults to 270.
/// </summary>
[DefaultValue(double.NaN), Category("Layout")]
[Description("Indicates the start angle of the pie in degrees where 0 is right and 270 is top. Defaults to 270.")]
[Editor("DevComponents.Charts.Design.AngleRangeValueEditor, DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public double StartAngle
{
get { return (_StartAngle); }
set
{
if (value != _StartAngle)
{
_StartAngle = value;
OnPropertyChangedEx("StartAngle", VisualChangeType.Layout);
}
}
}
#endregion
#region SweepAngle
/// <summary>
/// Gets or sets the sweep angle (distance from StartAngle to the
/// ending angle) of the pie in positive degrees (use SweepDirection
/// to change rotational direction).
/// </summary>
[DefaultValue(double.NaN), Category("Layout")]
[Description("Indicates the sweep angle (distance from StartAngle to the ending angle) of the pie in positive degrees (use SweepDirection to change rotational direction).")]
[Editor("DevComponents.Charts.Design.AngleRangeValueEditor, DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public double SweepAngle
{
get { return (_SweepAngle); }
set
{
if (value != _SweepAngle)
{
if (value < 0)
throw new Exception("SweepAngle cannot be negative (See SweepDirection).");
_SweepAngle = value;
OnPropertyChangedEx("SweepAngle", VisualChangeType.Layout);
}
}
}
#endregion
#region SweepDirection
/// <summary>
/// Gets or sets the direction to display the pie slices - in either a clockwise
/// or counterclockwise direction.
/// </summary>
[DefaultValue(SweepDirection.NotSet), Category("Layout")]
[Description("Indicates the direction to display the pie slices - in either a clockwise or counterclockwise direction).")]
public SweepDirection SweepDirection
{
get { return (_SweepDirection); }
set
{
if (value != _SweepDirection)
{
_SweepDirection = value;
OnPropertyChangedEx("SweepDirection", VisualChangeType.Recalc);
}
}
}
#endregion
#region ToolTipText
/// <summary>
/// Gets or sets the text to use for the point ToolTip.
/// </summary>
[DefaultValue(null), Category("Label")]
[Description("Indicates the text to use for the point ToolTip.")]
[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
public string ToolTipText
{
get { return (_ToolTipText); }
set
{
if (value != _ToolTipText)
{
_ToolTipText = value;
OnPropertyChanged("ToolTipText");
}
}
}
#endregion
#endregion
#region GetReferenceLineByName
/// <summary>
/// Gets the ReferenceLine from the given name.
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public PieReferenceLine GetReferenceLineByName(string name)
{
if (String.IsNullOrEmpty(name) == true)
return (null);
if (_ReferenceLines != null)
{
foreach (PieReferenceLine line in _ReferenceLines)
{
if (name.Equals(line.Name) == true)
return (line);
}
}
return (null);
}
#endregion
#region Style support
#region OnStyleChanged
protected virtual void OnStyleChanged(string property,
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
{
StyleChangeHandler(oldValue, newValue);
OnPropertyChanged(property);
}
#endregion
#region StyleChangeHandler
protected void StyleChangeHandler(
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
{
if (oldValue != null)
oldValue.PropertyChanged -= StyleChanged;
if (newValue != null)
newValue.PropertyChanged += StyleChanged;
}
#region StyleChanged
/// <summary>
/// Occurs when one of element visual styles has property changes.
/// Default implementation invalidates visual appearance of element.
/// </summary>
/// <param name="sender">VisualStyle that changed.</param>
/// <param name="e">Event arguments.</param>
protected void StyleChanged(object sender, PropertyChangedEventArgs e)
{
OnPropertyChanged(e);
}
#endregion
#endregion
#region INotifyPropertyChanged Members
/// <summary>
/// Occurs when property value has changed.
/// </summary>
public event PropertyChangedEventHandler PropertyChanged;
#region OnPropertyChanged
/// <summary>
/// Raises the PropertyChanged event.
/// </summary>
/// <param name="e">Event arguments</param>
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
if (PropertyChanged != null)
PropertyChanged(this, e);
}
/// <summary>
/// Default PropertyChanged processing
/// </summary>
/// <param name="s"></param>
protected void OnPropertyChanged(string s)
{
if (PropertyChanged != null)
OnPropertyChanged(new PropertyChangedEventArgs(s));
}
/// <summary>
/// Default PropertyChanged processing
/// </summary>
/// <param name="s"></param>
/// <param name="changeType">invalidate</param>
protected void OnPropertyChangedEx(string s, VisualChangeType changeType)
{
if (PropertyChanged != null)
OnPropertyChanged(new VisualPropertyChangedEventArgs(s, changeType));
}
#endregion
#endregion
#endregion
#region Copy/CopyTo
/// <summary>
/// Creates a copy of the SeriesPointsLayout
/// </summary>
/// <returns></returns>
public SliceVisualLayout Copy()
{
SliceVisualLayout copy = new SliceVisualLayout(null);
CopyTo(copy);
return (copy);
}
/// <summary>
/// Copies the item data to the given SeriesPointsLayout.
/// </summary>
/// <param name="sp"></param>
public void CopyTo(SliceVisualLayout c)
{
c.AngleMargin = AngleMargin;
c.MaxSlices = MaxSlices;
c.MinExtent = MinExtent;
c.MinPercent = MinPercent;
c.InnerLabelOrientation = _InnerLabelOrientation;
c.InnerSliceLabel = _InnerSliceLabel;
c.OtherSliceVisualStyles = (_OtherSliceVisualStyles != null) ? _OtherSliceVisualStyles.Copy() : null;
c.OuterSliceLabel = OuterSliceLabel;
foreach (PieReferenceLine line in ReferenceLines)
c.ReferenceLines.Add((PieReferenceLine)line.Copy());
c.ReferenceLineDisplayMode = _RefLineDisplayMode;
c.ReferenceLineDisplayOnTop = _ReferenceLineDisplayOnTop;
c.RingWeight = RingWeight;
c.ShowSliceWhiteSpace = _ShowSliceWhiteSpace;
c.SliceLabelCropMode = _SliceLabelCropMode;
c.SliceLabelDisplayMode = _SliceLabelDisplayMode;
c.SliceLabelVisibility = _SliceLabelVisibility;
c.SliceVisualStyles = (_SliceVisualStyles != null) ? _SliceVisualStyles.Copy() : null;
c.StartAngle = _StartAngle;
c.SweepAngle = _SweepAngle;
c.SweepDirection = _SweepDirection;
}
#endregion
#region GetSerialData
internal virtual SerialElementCollection GetSerialData()
{
return (GetSerialData(true));
}
internal virtual SerialElementCollection GetSerialData(bool root)
{
SerialElementCollection sec = new SerialElementCollection();
if (root == true)
sec.AddStartElement("SliceVisualLayout");
sec.AddValue("AngleMargin", AngleMargin, double.NaN);
sec.AddValue("MaxSlices", MaxSlices, -1);
sec.AddValue("MinExtent", MinExtent, -1);
sec.AddValue("MinPercent", MinPercent, double.NaN);
sec.AddValue("InnerLabelOrientation", InnerLabelOrientation, SliceLabelOrientation.NotSet);
sec.AddValue("InnerSliceLabel", InnerSliceLabel, null);
if (_OtherSliceVisualStyles != null && _OtherSliceVisualStyles.IsEmpty == false)
sec.AddElement(_OtherSliceVisualStyles.GetSerialData("OtherSliceVisualStyles"));
sec.AddValue("OuterSliceLabel", OuterSliceLabel, null);
if (_ReferenceLines != null && _ReferenceLines.Count > 0)
{
sec.AddStartElement("ReferenceLines count=\"" + _ReferenceLines.Count + "\"");
foreach (PieReferenceLine rline in _ReferenceLines)
sec.AddElement(rline.GetSerialData(""));
sec.AddEndElement("ReferenceLines");
}
sec.AddValue("ReferenceLineDisplayMode", ReferenceLineDisplayMode, PieRefLineDisplayMode.NotSet);
sec.AddValue("ReferenceLineDisplayOnTop", ReferenceLineDisplayOnTop, Tbool.NotSet);
sec.AddValue("RingWeight", RingWeight, -1);
sec.AddValue("ShowSliceWhiteSpace", ShowSliceWhiteSpace, Tbool.NotSet);
sec.AddValue("SliceLabelCropMode", SliceLabelCropMode, SliceLabelCropMode.NotSet);
sec.AddValue("SliceLabelDisplayMode", SliceLabelDisplayMode, SliceLabelDisplayMode.NotSet);
sec.AddValue("SliceLabelVisibility", SliceLabelVisibility, SliceLabelVisibility.NotSet);
if (_SliceVisualStyles != null && _SliceVisualStyles.IsEmpty == false)
sec.AddElement(_SliceVisualStyles.GetSerialData("SliceVisualStyles"));
sec.AddValue("StartAngle", StartAngle, double.NaN);
sec.AddValue("SweepAngle", SweepAngle, double.NaN);
sec.AddValue("SweepDirection", SweepDirection, SweepDirection.NotSet);
if (root == true)
sec.AddEndElement("SliceVisualLayout");
return (sec);
}
#endregion
#region PutSerialData
#region ProcessValue
void IProcessSerialElement.ProcessValue(SerialElement se)
{
switch (se.Name)
{
case "AngleMargin":
AngleMargin = double.Parse(se.StringValue);
break;
case "InnerLabelOrientation":
InnerLabelOrientation = (SliceLabelOrientation)se.GetValueEnum(typeof(SliceLabelOrientation));
break;
case "InnerSliceLabel":
InnerSliceLabel = se.StringValue;
break;
case "MaxSlices":
MaxSlices = int.Parse(se.StringValue);
break;
case "MinExtent":
MinExtent = int.Parse(se.StringValue);
break;
case "MinPercent":
MinPercent = double.Parse(se.StringValue);
break;
case "OuterSliceLabel":
OuterSliceLabel = se.StringValue;
break;
case "ReferenceLineDisplayMode":
ReferenceLineDisplayMode = (PieRefLineDisplayMode)se.GetValueEnum(typeof(PieRefLineDisplayMode));
break;
case "ReferenceLineDisplayOnTop":
ReferenceLineDisplayOnTop = (Tbool)se.GetValueEnum(typeof(Tbool));
break;
case "RingWeight":
RingWeight = int.Parse(se.StringValue);
break;
case "ShowSliceWhiteSpace":
ShowSliceWhiteSpace = (Tbool)se.GetValueEnum(typeof(Tbool));
break;
case "SliceLabelCropMode":
SliceLabelCropMode = (SliceLabelCropMode)se.GetValueEnum(typeof(SliceLabelCropMode));
break;
case "SliceLabelDisplayMode":
SliceLabelDisplayMode = (SliceLabelDisplayMode)se.GetValueEnum(typeof(SliceLabelDisplayMode));
break;
case "SliceLabelVisibility":
SliceLabelVisibility = (SliceLabelVisibility)se.GetValueEnum(typeof(SliceLabelVisibility));
break;
case "StartAngle":
StartAngle = double.Parse(se.StringValue);
break;
case "SweepAngle":
SweepAngle = double.Parse(se.StringValue);
break;
case "SweepDirection":
SweepDirection = (SweepDirection)se.GetValueEnum(typeof(SweepDirection));
break;
}
}
#endregion
#region ProcessCollection
void IProcessSerialElement.ProcessCollection(SerialElement se)
{
SerialElementCollection sec = se.Sec;
switch (se.Name)
{
case "OtherSliceVisualStyles":
sec.PutSerialData(OtherSliceVisualStyles);
break;
case "ReferenceLine":
PieReferenceLine line = GetReferenceLineByName(se.Name);
if (line != null)
sec.PutSerialData(line);
break;
case "ReferenceLines":
sec.PutSerialData(this);
break;
case "SliceVisualStyles":
sec.PutSerialData(SliceVisualStyles);
break;
}
}
#endregion
#endregion
#region IDispose
public virtual void Dispose()
{
ReferenceLines = null;
OtherSliceVisualStyles = null;
SliceVisualStyles = null;
Parent = null;
}
#endregion
}
#region ISeriesPointContainer
public interface ISeriesPointContainer
{
SliceVisualLayout SubSliceVisualLayout { get; set; }
}
#endregion
#endregion
#region PieSeriesPoint
[DesignTimeVisible(false), ToolboxItem(false)]
public class PieSeriesPoint : SeriesPoint,
IEffectiveStyle, INotifyPropertyChanged, ILegendItem, ILegendItemEx, ISeriesPointContainer, INamed
{
#region Private variables
private object _Parent;
private int _OrdinalValue;
private ChartControl _ChartControl;
private int _LocalUpdateCount;
private string _InnerSliceLabel;
private string _OuterSliceLabel;
private double _DetachedOffset = double.NaN;
private double _StartAngle = double.NaN;
private double _SweepAngle = double.NaN;
private double _AngleMarginExx;
private double _StartAngleEx;
private double _SweepAngleEx;
private Point _SliceCenter;
private double _SliceExtent;
private double _SliceValue;
private int _InnerRadius;
private int _OuterRadius;
private Rectangle _PathBounds;
private Rectangle _LastPathBounds;
private PieRing _PieRing;
private PieSeriesPoint _RootPsp;
private ChartSliceVisualStyles _SliceVisualStyles;
private EffectiveStyles<ChartSliceVisualStyle> _EffectiveSliceStyles;
private ChartSliceVisualStyle _LastEffectiveStyle;
private Color _DefaultPaletteColor = Color.Empty;
private ushort _LayoutUpdateCount;
private Rectangle _InscribedRect;
private List<WordPosLine> _WordPosLines;
private RectangleF[] _CharBounds;
private PieLabel _PieLabel;
private ChartLegendItem _LegendItem;
private string _LegendText;
private ChartLegendItemVisualStyles _ChartLegendItemVisualStyles;
private string _Name;
private string _ToolTipText;
private PieSeriesPointCollection _SeriesPoints;
private SliceVisualLayout _SliceVisualLayout;
private States _States;
// ---- Cached items
private double _AngleMarginEx;
private SliceLabelCropMode _SliceLabelCropModeEx;
private SliceLabelDisplayMode _SliceLabelDisplayModeEx;
private SliceLabelOrientation _InnerLabelOrientationEx;
private SliceLabelVisibility _SliceLabelVisibilityEx;
private string _InnerSliceLabelEx;
private string _OuterSliceLabelEx;
private int _MaxSlicesEx;
private int _MinExtentEx;
private double _MinPercentEx;
private int _RingWeightEx;
private PieRefLineDisplayMode _ReferenceLineDisplayModeEx;
private List<PieReferenceLine> _ReferenceLinesEx;
private string _ToolTipTextEx;
#endregion
#region Constructors
public PieSeriesPoint()
: this(0, 0)
{
}
/// <summary>
/// PieSeriesPoint
/// </summary>
/// <param name="xValue"></param>
/// <param name="yValue"></param>
public PieSeriesPoint(object xValue, object yValue)
: base(xValue, yValue)
{
InitDefaultStates();
_EffectiveSliceStyles = new EffectiveStyles<ChartSliceVisualStyle>(this);
}
/// <summary>
/// PieSeriesPoint
/// </summary>
/// <param name="xValue"></param>
/// <param name="yValue"></param>
public PieSeriesPoint(object xValue, object[] yValue)
: base(xValue, yValue)
{
InitDefaultStates();
_EffectiveSliceStyles = new EffectiveStyles<ChartSliceVisualStyle>(this);
}
/// <summary>
/// PieSeriesPoint
/// </summary>
/// <param name="xValue"></param>
/// <param name="yValue1">angular value</param>
/// <param name="yValue2">yValue2=radial</param>
public PieSeriesPoint(object xValue, object yValue1, object yValue2)
: base(xValue, yValue1, yValue2)
{
InitDefaultStates();
_EffectiveSliceStyles = new EffectiveStyles<ChartSliceVisualStyle>(this);
}
#endregion
#region InitDefaultStates
private void InitDefaultStates()
{
SetState(States.AllowDetach, true);
SetState(States.AllowSelect, true);
SetState(States.CheckedInLegend, true);
SetState(States.ShowInLegend, true);
SetState(States.ShowInParentLegend, true);
SetState(States.ShowMarkerInLegend, true);
}
#endregion
#region Public properties
#region ActualStartAngle
/// <summary>
/// Gets the actual, calculated starting angle for the slice.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double ActualStartAngle
{
get { return (StartAngleEx); }
}
#endregion
#region ActualSweepAngle
/// <summary>
/// Gets the actual, calculated sweep angle for the slice.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double ActualSweepAngle
{
get { return (SweepAngleEx); }
}
#endregion
#region AllowDetach
/// <summary>
/// Gets or sets whether the element can be 'detached' from
/// the center of the pie by the user. Defaults to true.
/// </summary>
[DefaultValue(true), Category("Behavior")]
[Description("Indicates whether the element can be 'detached' from the center of the pie by the user. Defaults to true.")]
public bool AllowDetach
{
get { return (TestState(States.AllowDetach)); }
set
{
if (value != AllowDetach)
{
SetState(States.AllowDetach, value);
OnPropertyChanged("AllowDetach");
}
}
}
#endregion
#region AllowSelect
/// <summary>
/// Gets or sets whether the element can be selected by clicking on it. Defaults to true.
/// </summary>
[DefaultValue(true), Category("Behavior")]
[Description("Indicates whether the element can be selected by clicking on it. Defaults to true.")]
public bool AllowSelect
{
get { return (TestState(States.AllowSelect)); }
set
{
if (value != AllowSelect)
{
SetState(States.AllowSelect, value);
OnPropertyChanged("AllowSliceSelect");
}
}
}
#endregion
#region CenterAngle
/// <summary>
/// Gets the Center Angle for the slice.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double CenterAngle
{
get { return ((StartAngleEx + SweepAngleEx / 2) + 360000) % 360; }
}
#endregion
#region ChartSeries
/// <summary>
/// Gets the associated ChartSeries.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public PieSeries ChartSeries
{
get { return (_PieRing != null ? _PieRing.ChartSeries : null); }
}
#endregion
#region DefaultPaletteColor
/// <summary>
/// Gets the default palette color assigned to the point when it
/// is arranged in the pie.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[Description("Indicates the default palette color assigned to the point when it is arranged in the pie.")]
public Color DefaultPaletteColor
{
get { return (_DefaultPaletteColor); }
internal set
{
if (value != _DefaultPaletteColor)
{
_DefaultPaletteColor = value;
ClearEffectiveStyles();
OnPropertyChangedEx("DetachedOffset", VisualChangeType.Render);
}
}
}
#endregion
#region DetachedOffset
/// <summary>
/// Gets or sets the offset distance of the slice from the pie center, as measured
/// by a percentage of the pie radius (if between 0 and 1), or absolute pixel amount (if >= 1).
/// </summary>
[DefaultValue(double.NaN), Category("Appearance")]
[Description("Indicates the offset distance of the slice from the pie center, as measured by a percentage of the pie radius (if between 0 and 1), or absolute pixel amount (if >= 1).")]
[Editor("DevComponents.Charts.Design.RadiusRangeValueEditor, DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public double DetachedOffset
{
get { return (_DetachedOffset); }
set
{
if (value != _DetachedOffset)
{
_DetachedOffset = value;
OnPropertyChangedEx("DetachedOffset", VisualChangeType.Layout);
}
}
}
#endregion
#region EffectiveSliceStyles
/// <summary>
/// Gets a reference to the Effective (cached, composite) Slice styles.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public EffectiveStyles<ChartSliceVisualStyle> EffectiveSliceStyles
{
get { return (_EffectiveSliceStyles); }
}
#endregion
#region ExtentRadius
/// <summary>
/// Gets the actual, calculated extent radius of the slice (the
/// radius between the inner and outer radius - ValuesY[1]).
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double ExtentRadius
{
get
{
int width = OuterRadius - InnerRadius;
int extendWidth = (int)(SliceExtent * width);
return (InnerRadius + extendWidth);
}
}
#endregion
#region InnerRadius
/// <summary>
/// Gets the actual, inner radius of the slice.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public int InnerRadius
{
get { return (_InnerRadius); }
internal set { _InnerRadius = value; }
}
#endregion
#region InnerSliceLabel
/// <summary>
/// Gets or sets the inner slice label for the pie slice. The label can be
/// straight text, or be comprised of text and formatting specifiers. The label
/// should be specified as "Some text {Keyword:Format} more text [{...:...}]".
///
/// Here are the formatting specifiers that can be used with both inner and
/// outer labels:
///
/// "AVG" "A" - Average (angular values).
/// "PCT" "P" - Percent of pie (angular values) - (.025 yields "2.5 %").
/// "TOT" "T" - Total of all values (angluar values).
/// "VAL" "V" - Value percent of pie (angular value) - (.025 yields ".025").
///
/// "AVGX" "AX" - Average (extent/radial values).
/// "PCTX" "PX" - Percent of pie (extent values) - (.025 yields "2.5 %").
/// "TOTX" "TX" - Total of all values (extent values).
/// "VALX" "VX" - Value percent of pie (extent value) - (.025 yields ".025").
///
/// "S" "SNAME" - Series name.
/// "X" - ValueX.
/// "Y", "Y0", "Yn" - ValueY values (where 'n' is index value).
///
/// Examples:
///
/// "{S}\\n{X:yyyy} ({Y:##,##0} - {P:Y1})"
/// "Individual cost {Y:C} and average cost {AVG:C} of goods."
///
/// </summary>
[DefaultValue(null), Category("Label")]
[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
[Description("Indicates the inner slice label for the pie slices (format specifiers {Keyword[:Format]} - " +
"S, X, Y, Y0-Yn, N, [A|AVG][X], [A|PCT][X], [A|TOT][X], [A|VAL][X]. e.g. \"{x:f2},{avg:##.##},{totx:c}\"")]
public string InnerSliceLabel
{
get { return (_InnerSliceLabel); }
set
{
if (String.Equals(value, _InnerSliceLabel) == false)
{
_InnerSliceLabel = value;
OnPropertyChangedEx("InnerSliceLabel", VisualChangeType.Layout);
}
}
}
#endregion
#region IsDetached
/// <summary>
/// Gets or sets whether the slice is 'detached' from the center of the pie. This can be
/// used to create emphasis or to highlight a slice of the pie.
/// </summary>
[DefaultValue(false), Category("Appearance")]
[Description("Indicates whether the slice is 'detached' from the center of the pie.")]
public bool IsDetached
{
get { return (TestState(States.Detached)); }
set
{
if (value != IsDetached)
{
SetState(States.Detached, value);
OnPropertyChangedEx("IsDetached", VisualChangeType.Layout);
}
}
}
#endregion
#region IsDisplayed
///<summary>
/// Gets whether the series point is displayed
/// based upon its Visibility and Legend state.
///</summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool IsDisplayed
{
get { return (Visible == true && IsDisplayedEx == true); }
}
#endregion
#region IsEmptyPoint
/// <summary>
/// Gets or sets whether the point is an 'Empty' (or missing) Point.
/// </summary>
[DefaultValue(false), Category("Data")]
[Description("Indicates whether the point is an 'Empty' (or missing) Point.")]
public override bool IsEmptyPoint
{
get { return (base.IsEmptyPoint); }
set
{
if (value != base.IsEmptyPoint)
{
base.IsEmptyPoint = value;
OnPropertyChangedEx("IsEmptyPoint", VisualChangeType.Recalc);
}
}
}
#endregion
#region IsInOther
/// <summary>
/// Gets whether the slice is in the 'Other' slice.
/// </summary>
[DefaultValue(false), Category("Appearance")]
[Description("Indicates whether the slice is in the 'Other' slice.")]
public bool IsInOther
{
get { return (TestState(States.IsInOther)); }
set
{
if (value != IsInOther)
{
SetState(States.IsInOther, value);
OnPropertyChangedEx("IsInOther", VisualChangeType.Layout);
}
}
}
#endregion
#region IsOther
/// <summary>
/// Gets whether the slice is the 'Other' slice.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[Description("Indicates whether the slice is the 'Other' slice.")]
public bool IsOther
{
get { return (TestState(States.IsOther)); }
internal set { SetState(States.IsOther, value); }
}
#endregion
#region IsSelected
/// <summary>
/// Gets or sets whether the slice is selected.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[Description("Indicates whether the slice is selected.")]
public bool IsSelected
{
get { return (TestState(States.Selected)); }
set
{
if (value != IsSelected)
{
SetState(States.Selected, value);
OnPropertyChangedEx("IsSelected", VisualChangeType.Render);
PieSeries series = ChartSeries;
if (series != null)
{
PieChart pieChart = series.Parent as PieChart;
if (pieChart != null)
pieChart.GlobalSelectionCount++;
}
}
}
}
#endregion
#region Name
/// <summary>
/// Gets or sets the Name of the item.
/// </summary>
[DefaultValue(null)]
[Description("Indicates the Name of the item.")]
public virtual string Name
{
get { return (_Name); }
set { _Name = value; }
}
#endregion
#region OrdinalValue
/// <summary>
/// Gets the ordial value for the point (the ordinal value when added
/// to the PieSeriesPoint Collection
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public int OrdinalValue
{
get { return (_OrdinalValue); }
internal set { _OrdinalValue = value; }
}
#endregion
#region OuterRadius
/// <summary>
/// Gets the actual, outer radius of the slice.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public int OuterRadius
{
get { return (_OuterRadius); }
internal set { _OuterRadius = value; }
}
#endregion
#region OuterSliceLabel
/// <summary>
/// Gets or sets the outer slice label for the pie slice. See InnerSliceLabel for
/// further notes on Format Specifiers.
/// </summary>
[DefaultValue(null), Category("Label")]
[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
[Description("Indicates the inner slice label for the pie slices. See InnerSliceLabel for further notes on Format Specifiers.")]
public string OuterSliceLabel
{
get { return (_OuterSliceLabel); }
set
{
if (String.Equals(value, _OuterSliceLabel) == false)
{
_OuterSliceLabel = value;
OnPropertyChangedEx("OuterSliceLabel", VisualChangeType.Layout);
}
}
}
#endregion
#region Parent
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[Description("Indicates the item Parent.")]
public object Parent
{
get { return (_Parent); }
internal set
{
_Parent = value;
_RootPsp = null;
if (value != null)
{
PieSeriesPointCollection psp = value as PieSeriesPointCollection;
if (psp != null)
SubSliceVisualLayout.Parent = psp.Parent as ChartVisualElement;
}
}
}
#endregion
#region PieRing
/// <summary>
/// Gets the items associated PieRing (if applicable).
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public PieRing PieRing
{
get { return (_PieRing); }
internal set { _PieRing = value; }
}
#endregion
#region SeriesPoints
///<summary>
/// Gets the nested series point data collection.
///</summary>
[Category("Data")]
[Description("Indicates the nested series point data collection.")]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public PieSeriesPointCollection SeriesPoints
{
get
{
if (_SeriesPoints == null)
SeriesPoints = new PieSeriesPointCollection();
return (_SeriesPoints);
}
set
{
if (value != _SeriesPoints)
{
if (_SeriesPoints != null)
{
_SeriesPoints.Parent = null;
_SeriesPoints.CollectionChanged -= SeriesPoints_CollectionChanged;
}
_SeriesPoints = value;
if (_SeriesPoints != null)
{
_SeriesPoints.Parent = this;
_SeriesPoints.CollectionChanged += SeriesPoints_CollectionChanged;
}
OnPropertyChangedEx("SeriesPoints", VisualChangeType.Layout);
}
}
}
#region SeriesPoints_CollectionChanged
void SeriesPoints_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
SetSpcNotify(e.OldItems, false);
SetSpcNotify(e.NewItems, true);
OnPropertyChangedEx("SeriesPoints", Style.VisualChangeType.Layout);
}
#region SetPointNotify
private void SetSpcNotify(IList list, bool notify)
{
if (list != null)
{
foreach (PieSeriesPoint psp in list)
{
if (psp != null)
{
if (notify == true)
{
psp.Parent = SeriesPoints;
psp.PropertyChanged += Spc_PropertyChanged;
}
else
{
psp.Parent = null;
psp.PropertyChanged -= Spc_PropertyChanged;
}
}
}
}
}
#endregion
#region Spc_PropertyChanged
void Spc_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e is VisualPropertyChangedEventArgs)
OnPropertyChanged(e);
}
#endregion
#endregion
#endregion
#region SliceCenter
/// <summary>
/// Gets the slice center origin point.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Point SliceCenter
{
get { return (_SliceCenter); }
internal set { _SliceCenter = value; }
}
#endregion
#region SliceExtent
/// <summary>
/// Gets the calculated slice extent value (the relative
/// percent-of-total ValuesY[1] value for the slice).
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double SliceExtent
{
get { return (_SliceExtent); }
internal set { _SliceExtent = value; }
}
#endregion
#region SliceValue
/// <summary>
/// Gets the calculated slice value (the relative
/// percent-of-total ValuesY[0] value for the slice).
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public double SliceValue
{
get { return (_SliceValue); }
internal set { _SliceValue = value; }
}
#endregion
#region SliceVisualStyles
/// <summary>
/// Gets or sets the visual styles for the slice.
/// </summary>
[Category("Style")]
[Description("Indicates the visual styles for the slice.")]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public ChartSliceVisualStyles SliceVisualStyles
{
get
{
if (_SliceVisualStyles == null)
{
_SliceVisualStyles = new ChartSliceVisualStyles();
StyleChangeHandler(null, _SliceVisualStyles);
}
return (_SliceVisualStyles);
}
set
{
if (_SliceVisualStyles != value)
{
ChartSliceVisualStyles oldValue = _SliceVisualStyles;
_SliceVisualStyles = value;
OnStyleChanged("SliceVisualStyles", oldValue, value);
if (oldValue != null)
oldValue.Dispose();
}
}
}
#endregion
#region StartAngle
///<summary>
/// Gets or sets the starting angle of the slice. For subsequent slices,
/// the default is the ending angle of the previous slice. Specify a value
/// for the StartAngle if you want the next slice to start at an angle that
/// is different from the previous ending angle.
///</summary>
[DefaultValue(double.NaN), Category("Layout")]
[Description("Indicates the starting angle of the slice. For subsequent slices, the default is the ending angle of the previous slice. Specify a value for the StartAngle if you want the next slice to start at an angle that is different from the previous ending angle.")]
[Editor("DevComponents.Charts.Design.AngleRangeValueEditor, DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public double StartAngle
{
get { return (_StartAngle); }
set
{
if (value != _StartAngle)
{
_StartAngle = value;
OnPropertyChangedEx("StartAngle", Style.VisualChangeType.Layout);
}
}
}
#endregion
#region SubSliceVisualLayout
/// <summary>
/// Gets or sets the layout of the subordinate (or nested) slices.
/// </summary>
[Category("Layout")]
[Description("Indicates the layout of the subordinate (or nested) slices.")]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public SliceVisualLayout SubSliceVisualLayout
{
get
{
if (_SliceVisualLayout == null)
SubSliceVisualLayout = new SliceVisualLayout(null);
return (_SliceVisualLayout);
}
set
{
if (value != _SliceVisualLayout)
{
if (_SliceVisualLayout != null)
_SliceVisualLayout.PropertyChanged -= SliceVisualLayout_PropertyChanged;
_SliceVisualLayout = value;
if (_SliceVisualLayout != null)
{
_SliceVisualLayout.SliceVisualStyles.Default.Tag = "PSP_Def";
_SliceVisualLayout.SliceVisualStyles.MouseOver.Tag = "PSP_Mov";
_SliceVisualLayout.SliceVisualStyles.Selected.Tag = "PSP_Sel";
_SliceVisualLayout.SliceVisualStyles.SelectedMouseOver.Tag = "PSP_Smo";
_SliceVisualLayout.PropertyChanged += SliceVisualLayout_PropertyChanged;
}
OnPropertyChangedEx("SubSliceVisualLayout", VisualChangeType.Recalc);
}
}
}
#region SliceVisualLayout_PropertyChanged
void SliceVisualLayout_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e is VisualPropertyChangedEventArgs)
OnPropertyChanged(e);
}
#endregion
#endregion
#region SweepAngle
///<summary>
/// Gets or sets the sweep angle of the slice (angle size, in degrees).
///</summary>
[DefaultValue(double.NaN), Category("Layout")]
[Description("Indicates the sweep angle of the slice (angle size, in degrees).")]
[Editor("DevComponents.Charts.Design.AngleRangeValueEditor, DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public double SweepAngle
{
get { return (_SweepAngle); }
set
{
if (value != _SweepAngle)
{
if (value < 0)
throw new Exception("SweepAngle cannot be negative.");
_SweepAngle = value;
OnPropertyChangedEx("SweepAngle", Style.VisualChangeType.Layout);
}
}
}
#endregion
#region ToolTipText
/// <summary>
/// Gets or sets the text to use for the point ToolTip.
/// </summary>
[DefaultValue(null), Category("Label")]
[Description("Indicates the text to use for the point ToolTip.")]
[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
public string ToolTipText
{
get { return (_ToolTipText); }
set
{
if (value != _ToolTipText)
{
_ToolTipText = value;
OnPropertyChanged("ToolTipText");
}
}
}
#endregion
#region Visible
/// <summary>
/// Gets or sets whether the point is Visible.
/// </summary>
[DefaultValue(true), Category("Appearance")]
[Description("Indicates whether the point is Visible.")]
public override bool Visible
{
get { return (base.Visible); }
set
{
if (value != base.Visible)
{
base.Visible = value;
OnPropertyChangedEx("Visible", VisualChangeType.Recalc);
}
}
}
#endregion
#endregion
#region Internal properties
#region AngleMarginExx
internal double AngleMarginExx
{
get { return (_AngleMarginExx); }
set { _AngleMarginExx = value; }
}
#endregion
#region AngleMarginEx
internal double AngleMarginEx
{
get { UpdatePropertyCache(); return (_AngleMarginEx); }
set { _AngleMarginEx = value; }
}
#endregion
#region Bounds
internal Rectangle Bounds
{
get
{
Rectangle r = new Rectangle();
r.Location = _SliceCenter;
r.Inflate(OuterRadius, OuterRadius);
return (r);
}
}
#endregion
#region CharBounds
internal RectangleF[] CharBounds
{
get
{
VerifyLayoutUpdateCount();
return (_CharBounds);
}
set { _CharBounds = value; }
}
#endregion
#region HasExtent
internal bool HasExtent
{
get { return (TestState(States.HasExtent)); }
set { SetState(States.HasExtent, value); }
}
#endregion
#region InnerLabelClipped
internal bool InnerLabelClipped
{
get { return (TestState(States.InnerLabelClipped)); }
set { SetState(States.InnerLabelClipped, value); }
}
#endregion
#region InnerLabelDisplayed
internal bool InnerLabelDisplayed
{
get { return (TestState(States.InnerLabelDisplayed)); }
set { SetState(States.InnerLabelDisplayed, value); }
}
#endregion
#region InnerLabelOrientationEx
internal SliceLabelOrientation InnerLabelOrientationEx
{
get { UpdatePropertyCache(); return (_InnerLabelOrientationEx); }
set { _InnerLabelOrientationEx = value; }
}
#endregion
#region InnerSliceLabelEx
internal string InnerSliceLabelEx
{
get { UpdatePropertyCache(); return (_InnerSliceLabelEx); }
set { _InnerSliceLabelEx = value; }
}
#endregion
#region InscribedRect
internal Rectangle InscribedRect
{
get
{
VerifyLayoutUpdateCount();
return (_InscribedRect);
}
set
{
_InscribedRect = value;
InscribedRectValid = true;
}
}
#endregion
#region InscribedRectValid
internal bool InscribedRectValid
{
get
{
VerifyLayoutUpdateCount();
return (TestState(States.InscribedRectValid));
}
set
{
SetState(States.InscribedRectValid, value);
if (value == false)
_InscribedRect = Rectangle.Empty;
}
}
#endregion
#region IsDisplayable
internal bool IsDisplayable
{
get
{
if (Visible == false || IsEmpty == true)
return (false);
if (IsInOtherEx == false)
{
object item = Parent;
while (item != null)
{
if (item is PieSeriesPointCollection)
{
if (((PieSeriesPointCollection)item).IsOther == true)
{
IsInOtherEx = true;
break;
}
item = ((PieSeriesPointCollection)item).Parent;
}
else if (item is PieSeriesPoint)
{
if (((PieSeriesPoint)item).IsInOtherEx == true)
{
IsInOtherEx = true;
break;
}
item = ((PieSeriesPoint)item).Parent;
}
else
{
break;
}
}
}
return (IsInOtherEx == false);
}
}
#endregion
#region IsDisplayedEx
internal bool IsDisplayedEx
{
get
{
if (Visible == true)
{
if (ChartSeries != null)
{
PieChart pieChart = ChartSeries.Parent as PieChart;
if (pieChart != null)
{
ItemCheckAction ica = (pieChart != null)
? pieChart.Legend.ItemCheckAction : ItemCheckAction.ShowItem;
return ((ica == ItemCheckAction.None ||
(ShowCheckBoxInLegend == false || CheckedInLegend == true)));
}
}
}
return (false);
}
}
#endregion
#region IsInOtherEx
internal bool IsInOtherEx
{
get { return (TestState(States.IsInOtherEx)); }
set { SetState(States.IsInOtherEx, value); }
}
#endregion
#region IsOffset
internal bool IsOffset
{
get { return (TestState(States.IsOffset)); }
set { SetState(States.IsOffset, value); }
}
#endregion
#region IsEnabled
internal bool IsEnabled
{
get
{
PieRing pieRing = PieRing;
if (pieRing != null)
{
if (pieRing.IsEnabled == true)
return (pieRing.IsDisplayed);
}
return (false);
}
}
#endregion
#region LastPathBounds
internal Rectangle LastPathBounds
{
get { return (_LastPathBounds); }
set { _LastPathBounds = value; }
}
#endregion
#region MaxSlicesEx
internal int MaxSlicesEx
{
get { UpdatePropertyCache(); return (_MaxSlicesEx); }
set { _MaxSlicesEx = value; }
}
#endregion
#region MinExtentEx
internal int MinExtentEx
{
get { UpdatePropertyCache(); return (_MinExtentEx); }
set { _MinExtentEx = value; }
}
#endregion
#region MinPercentEx
internal double MinPercentEx
{
get { UpdatePropertyCache(); return (_MinPercentEx); }
set { _MinPercentEx = value; }
}
#endregion
#region OuterSliceLabelEx
internal string OuterSliceLabelEx
{
get { UpdatePropertyCache(); return (_OuterSliceLabelEx); }
set { _OuterSliceLabelEx = value; }
}
#endregion
#region PathBounds
internal Rectangle PathBounds
{
get { return (_PathBounds); }
set { _PathBounds = value; }
}
#endregion
#region PieLabel
internal PieLabel PieLabel
{
get { return (_PieLabel); }
set { _PieLabel = value; }
}
#endregion
#region ReferenceLineDisplayModeEx
internal PieRefLineDisplayMode ReferenceLineDisplayModeEx
{
get { UpdatePropertyCache(); return (_ReferenceLineDisplayModeEx); }
set { _ReferenceLineDisplayModeEx = value; }
}
#endregion
#region ReferenceLineDisplayOnTopEx
internal bool ReferenceLineDisplayOnTopEx
{
get
{
UpdatePropertyCache();
return (TestState(States.ReferenceLineDisplayOnTop));
}
set { SetState(States.ReferenceLineDisplayOnTop, value); }
}
#endregion
#region ReferenceLinesEx
internal List<PieReferenceLine> ReferenceLinesEx
{
get { UpdatePropertyCache(); return (_ReferenceLinesEx); }
set { _ReferenceLinesEx = value; }
}
#endregion
#region RenderCount
private int _RenderCount;
internal int RenderCount
{
get { return (_RenderCount); }
set { _RenderCount = value; }
}
#endregion
#region RingWeightEx
internal int RingWeightEx
{
get { UpdatePropertyCache(); return (_RingWeightEx); }
set { _RingWeightEx = value; }
}
#endregion
#region RootPsp
internal PieSeriesPoint RootPsp
{
get
{
if (_RootPsp == null)
_RootPsp = GetRootPsp();
return (_RootPsp);
}
}
#region GetRootPsp
private PieSeriesPoint GetRootPsp()
{
if (PieRing.RingLevel > 0)
{
PieSeriesPointCollection spc = Parent as PieSeriesPointCollection;
if (spc != null)
{
PieSeriesPoint psp = spc.Parent as PieSeriesPoint;
if (psp != null)
return (psp.RootPsp);
}
}
return (this);
}
#endregion
#endregion
#region ShowSliceWhiteSpaceEx
internal bool ShowSliceWhiteSpaceEx
{
get
{
UpdatePropertyCache();
return (TestState(States.ShowSliceWhiteSpaceEx));
}
set { SetState(States.ShowSliceWhiteSpaceEx, value); }
}
#endregion
#region SliceLabelCropModeEx
internal SliceLabelCropMode SliceLabelCropModeEx
{
get { UpdatePropertyCache(); return (_SliceLabelCropModeEx); }
set { _SliceLabelCropModeEx = value; }
}
#endregion
#region SliceLabelDisplayModeEx
internal SliceLabelDisplayMode SliceLabelDisplayModeEx
{
get { UpdatePropertyCache(); return (_SliceLabelDisplayModeEx); }
set { _SliceLabelDisplayModeEx = value; }
}
#endregion
#region SliceLabelVisibilityEx
internal SliceLabelVisibility SliceLabelVisibilityEx
{
get { UpdatePropertyCache(); return (_SliceLabelVisibilityEx); }
set { _SliceLabelVisibilityEx = value; }
}
#endregion
#region StartAngleEx
internal double StartAngleEx
{
get { return (_StartAngleEx); }
set { _StartAngleEx = value; }
}
#endregion
#region SweepAngleEx
internal double SweepAngleEx
{
get { return (_SweepAngleEx); }
set { _SweepAngleEx = value; }
}
#endregion
#region ToolTipTextEx
internal string ToolTipTextEx
{
get { UpdatePropertyCache(); return (_ToolTipTextEx); }
set { _ToolTipTextEx = value; }
}
#endregion
#region WordPosLines
internal List<WordPosLine> WordPosLines
{
get
{
VerifyLayoutUpdateCount();
return (_WordPosLines);
}
set { _WordPosLines = value; }
}
#endregion
#endregion
#region VerifyLayoutUpdateCount
private void VerifyLayoutUpdateCount()
{
PieSeries series = ChartSeries;
if (series != null)
{
ChartControl chartControl = series.ChartControl;
if (chartControl != null)
{
if (_LayoutUpdateCount != chartControl.LayoutUpdateCount)
{
_WordPosLines = null;
InscribedRectValid = false;
_LayoutUpdateCount = chartControl.LayoutUpdateCount;
}
}
}
}
#endregion
#region UpdatePropertyCache
private void UpdatePropertyCache()
{
if (ChartControl != null)
{
if (_LocalUpdateCount != ChartControl.GlobalUpdateCount)
{
PieSeriesPointCollection spc = Parent as PieSeriesPointCollection;
if (spc != null)
{
PieSeries pieSeries = this.ChartSeries;
PieChart pieChart = pieSeries.Parent as PieChart;
_AngleMarginEx = GetAngleMarginEx(pieChart, pieSeries, spc.Parent);
_InnerLabelOrientationEx = GetSliceLabelOrientationEx(pieChart, pieSeries, spc.Parent);
_InnerSliceLabelEx = GetInnerSliceLabelEx(pieChart, pieSeries, spc.Parent);
_MaxSlicesEx = GetMaxSlicesEx(pieChart, pieSeries, spc.Parent);
_MinExtentEx = GetMinExtentEx(pieChart, pieSeries, spc.Parent);
_MinPercentEx = GetMinPercentEx(pieChart, pieSeries, spc.Parent);
_OuterSliceLabelEx = GetOuterSliceLabelEx(pieChart, pieSeries, spc.Parent);
_ReferenceLineDisplayModeEx = GetReferenceLineDisplayModeEx(pieChart, pieSeries, spc.Parent);
_ReferenceLinesEx = GetReferenceLinesEx(pieChart, pieSeries, spc.Parent);
_RingWeightEx = GetRingWeightEx(pieChart, pieSeries, spc.Parent);
SetState(States.ReferenceLineDisplayOnTop, GetReferenceLineDisplayOnTopEx(pieChart, pieSeries, spc.Parent));
SetState(States.ShowSliceWhiteSpaceEx, GetShowSliceWhiteSpaceEx(pieChart, pieSeries, spc.Parent));
_SliceLabelCropModeEx = GetSliceLabelCropModeEx(pieChart, pieSeries, spc.Parent);
_SliceLabelDisplayModeEx = GetSliceLabelDisplayModeEx(pieChart, pieSeries, spc.Parent);
_SliceLabelVisibilityEx = GetSliceLabelVisibilityEx(pieChart, pieSeries, spc.Parent);
_ToolTipTextEx = GetToolTipTextEx(pieChart, pieSeries, spc.Parent);
}
_LocalUpdateCount = ChartControl.GlobalUpdateCount;
}
}
}
#region GetAngleMarginEx
private double GetAngleMarginEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (double.IsNaN(psp.SubSliceVisualLayout.AngleMargin) == false)
return (psp.SubSliceVisualLayout.AngleMargin);
psp = GetParentPsp(psp);
}
if (double.IsNaN(pieSeries.SubSliceVisualLayout.AngleMargin) == false)
return (pieSeries.SubSliceVisualLayout.AngleMargin);
if (double.IsNaN(pieChart.SubSliceVisualLayout.AngleMargin) == false)
return (pieChart.SubSliceVisualLayout.AngleMargin);
return (0);
}
#endregion
#region GetInnerSliceLabelEx
private string GetInnerSliceLabelEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
CharBounds = null;
if (InnerSliceLabel != null)
return (InnerSliceLabel);
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.InnerSliceLabel != null)
return (psp.SubSliceVisualLayout.InnerSliceLabel);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.InnerSliceLabel != null)
return (pieSeries.SubSliceVisualLayout.InnerSliceLabel);
if (pieChart.SubSliceVisualLayout.InnerSliceLabel != null)
return (pieChart.SubSliceVisualLayout.InnerSliceLabel);
return ("{X}");
}
#endregion
#region GetMaxSlicesEx
private int GetMaxSlicesEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.MaxSlices >= 0)
return (psp.SubSliceVisualLayout.MaxSlices);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.MaxSlices >= 0)
return (pieSeries.SubSliceVisualLayout.MaxSlices);
if (pieChart.SubSliceVisualLayout.MaxSlices >= 0)
return (pieChart.SubSliceVisualLayout.MaxSlices);
return (100);
}
#endregion
#region GetMinExtentEx
private int GetMinExtentEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.MinExtent >= 0)
return (psp.SubSliceVisualLayout.MinExtent);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.MinExtent >= 0)
return (pieSeries.SubSliceVisualLayout.MinExtent);
if (pieChart.SubSliceVisualLayout.MinExtent >= 0)
return (pieChart.SubSliceVisualLayout.MinExtent);
return (0);
}
#endregion
#region GetMinPercentEx
private double GetMinPercentEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (double.IsNaN(psp.SubSliceVisualLayout.MinPercent) == false)
return (psp.SubSliceVisualLayout.MinPercent);
psp = GetParentPsp(psp);
}
if (double.IsNaN(pieSeries.SubSliceVisualLayout.MinPercent) == false)
return (pieSeries.SubSliceVisualLayout.MinPercent);
if (double.IsNaN(pieChart.SubSliceVisualLayout.MinPercent) == false)
return (pieChart.SubSliceVisualLayout.MinPercent);
return (.04d);
}
#endregion
#region GetOuterSliceLabelEx
private string GetOuterSliceLabelEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
if (OuterSliceLabel != null)
return (OuterSliceLabel);
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.OuterSliceLabel != null)
return (psp.SubSliceVisualLayout.OuterSliceLabel);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.OuterSliceLabel != null)
return (pieSeries.SubSliceVisualLayout.OuterSliceLabel);
if (pieChart.SubSliceVisualLayout.OuterSliceLabel != null)
return (pieChart.SubSliceVisualLayout.OuterSliceLabel);
return ("{X}");
}
#endregion
#region GetReferenceLineDisplayModeEx
private PieRefLineDisplayMode GetReferenceLineDisplayModeEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.ReferenceLineDisplayMode != PieRefLineDisplayMode.NotSet)
return (psp.SubSliceVisualLayout.ReferenceLineDisplayMode);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.ReferenceLineDisplayMode != PieRefLineDisplayMode.NotSet)
return (pieSeries.SubSliceVisualLayout.ReferenceLineDisplayMode);
if (pieChart.SubSliceVisualLayout.ReferenceLineDisplayMode != PieRefLineDisplayMode.NotSet)
return (pieChart.SubSliceVisualLayout.ReferenceLineDisplayMode);
return (PieRefLineDisplayMode.None);
}
#endregion
#region GetReferenceLineDisplayOnTopEx
private bool GetReferenceLineDisplayOnTopEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.ReferenceLineDisplayOnTop != Tbool.NotSet)
return (psp.SubSliceVisualLayout.ReferenceLineDisplayOnTop == Tbool.True);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.ReferenceLineDisplayOnTop != Tbool.NotSet)
return (pieSeries.SubSliceVisualLayout.ReferenceLineDisplayOnTop == Tbool.True);
return (pieChart.SubSliceVisualLayout.ReferenceLineDisplayOnTop != Tbool.False);
}
#endregion
#region GetReferenceLinesEx
private List<PieReferenceLine> GetReferenceLinesEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
List<PieReferenceLine> lines = new List<PieReferenceLine>();
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout._ReferenceLines != null)
AddReferenceLines(lines, psp.SubSliceVisualLayout.ReferenceLines);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout._ReferenceLines != null)
AddReferenceLines(lines, pieSeries.SubSliceVisualLayout.ReferenceLines);
if (pieChart.SubSliceVisualLayout._ReferenceLines != null)
AddReferenceLines(lines, pieChart.SubSliceVisualLayout.ReferenceLines);
return (lines);
}
#region AddReferenceLines
private void AddReferenceLines(
List<PieReferenceLine> lines, PieReferenceLineCollection rlc)
{
foreach (PieReferenceLine line in rlc)
lines.Add(line);
}
#endregion
#endregion
#region GetRingWeightEx
private int GetRingWeightEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.RingWeight >= 0)
return (psp.SubSliceVisualLayout.RingWeight);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.RingWeight >= 0)
return (pieSeries.SubSliceVisualLayout.RingWeight);
if (pieChart.SubSliceVisualLayout.RingWeight >= 0)
return (pieChart.SubSliceVisualLayout.RingWeight);
return (100);
}
#endregion
#region GetShowSliceWhiteSpaceEx
private bool GetShowSliceWhiteSpaceEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.ShowSliceWhiteSpace != Tbool.NotSet)
return (psp.SubSliceVisualLayout.ShowSliceWhiteSpace == Tbool.True);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.ShowSliceWhiteSpace != Tbool.NotSet)
return (pieSeries.SubSliceVisualLayout.ShowSliceWhiteSpace == Tbool.True);
return (pieChart.SubSliceVisualLayout.ShowSliceWhiteSpace == Tbool.True);
}
#endregion
#region GetSliceLabelCropModeEx
private SliceLabelCropMode GetSliceLabelCropModeEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.SliceLabelCropMode != SliceLabelCropMode.NotSet)
return (psp.SubSliceVisualLayout.SliceLabelCropMode);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.SliceLabelCropMode != SliceLabelCropMode.NotSet)
return (pieSeries.SubSliceVisualLayout.SliceLabelCropMode);
if (pieChart.SubSliceVisualLayout.SliceLabelCropMode != SliceLabelCropMode.NotSet)
return (pieChart.SubSliceVisualLayout.SliceLabelCropMode);
return (SliceLabelCropMode.Clip);
}
#endregion
#region GetSliceLabelDisplayModeEx
private SliceLabelDisplayMode GetSliceLabelDisplayModeEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.SliceLabelDisplayMode != SliceLabelDisplayMode.NotSet)
return (psp.SubSliceVisualLayout.SliceLabelDisplayMode);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.SliceLabelDisplayMode != SliceLabelDisplayMode.NotSet)
return (pieSeries.SubSliceVisualLayout.SliceLabelDisplayMode);
if (pieChart.SubSliceVisualLayout.SliceLabelDisplayMode != SliceLabelDisplayMode.NotSet)
return (pieChart.SubSliceVisualLayout.SliceLabelDisplayMode);
return (SliceLabelDisplayMode.InnerAndOuter);
}
#endregion
#region GetSliceLabelOrientationEx
private SliceLabelOrientation GetSliceLabelOrientationEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.InnerLabelOrientation != SliceLabelOrientation.NotSet)
return (psp.SubSliceVisualLayout.InnerLabelOrientation);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.InnerLabelOrientation != SliceLabelOrientation.NotSet)
return (pieSeries.SubSliceVisualLayout.InnerLabelOrientation);
if (pieChart.SubSliceVisualLayout.InnerLabelOrientation != SliceLabelOrientation.NotSet)
return (pieChart.SubSliceVisualLayout.InnerLabelOrientation);
return (SliceLabelOrientation.Adaptive);
}
#endregion
#region GetSliceLabelVisibilityEx
private SliceLabelVisibility GetSliceLabelVisibilityEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.SliceLabelVisibility != SliceLabelVisibility.NotSet)
return (psp.SubSliceVisualLayout.SliceLabelVisibility);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.SliceLabelVisibility != SliceLabelVisibility.NotSet)
return (pieSeries.SubSliceVisualLayout.SliceLabelVisibility);
if (pieChart.SubSliceVisualLayout.SliceLabelVisibility != SliceLabelVisibility.NotSet)
return (pieChart.SubSliceVisualLayout.SliceLabelVisibility);
return (SliceLabelVisibility.NotSet);
}
#endregion
#region GetToolTipTextEx
private string GetToolTipTextEx(
PieChart pieChart, PieSeries pieSeries, object item)
{
PieSeriesPoint psp = item as PieSeriesPoint;
while (psp != null)
{
if (psp.SubSliceVisualLayout.ToolTipText != null)
return (psp.SubSliceVisualLayout.ToolTipText);
psp = GetParentPsp(psp);
}
if (pieSeries.SubSliceVisualLayout.ToolTipText != null)
return (pieSeries.SubSliceVisualLayout.ToolTipText);
if (pieChart.SubSliceVisualLayout.ToolTipText != null)
return (pieChart.SubSliceVisualLayout.ToolTipText);
return ("{x}");
}
#endregion
#region GetParentPsp
private PieSeriesPoint GetParentPsp(PieSeriesPoint psp)
{
PieSeriesPointCollection spc = psp.Parent as PieSeriesPointCollection;
return (spc != null) ? spc.Parent as PieSeriesPoint : null;
}
#endregion
#endregion
#region GetRayEndPoint
internal Point GetRayEndPoint(double angle, double radius)
{
Point pt = SliceCenter;
double radians = MathHelper.ToRadians(angle);
pt.X += (int)(Math.Cos(radians) * radius);
pt.Y += (int)(Math.Sin(radians) * radius);
return (pt);
}
#endregion
#region GetLabelText
internal string GetLabelText(string pattern)
{
pattern = pattern.Replace("\\n", "\n");
pattern = pattern.Replace("\\r", "\r");
Regex regex = new Regex("{([^}]*)}");
MatchCollection mc = regex.Matches(pattern);
StringBuilder sb = new StringBuilder();
int index = 0;
foreach (Match ma in mc)
{
if (ma.Index > index)
sb.Append(pattern.Substring(index, ma.Index - index));
sb.Append(ProcessSliceLabelFmt(ma.Value));
index = ma.Index + ma.Length;
}
if (index < pattern.Length)
sb.Append(pattern.Substring(index));
return (sb.ToString());
}
#region ProcessSliceLabelFmt
/// "AVG" "A" - Average (angular values).
/// "PCT" "P" - Percent of pie (angular values) - (.025 yields "2.5 %").
/// "TOT" "T" - Total of all values (angluar values).
/// "VAL" "V" - Value percent of pie (angular value) - (.025 yields ".025").
///
/// "AVGX" "AX" - Average (extent/radial values).
/// "PCTX" "PX" - Percent of pie (extent values) - (.025 yields "2.5 %").
/// "TOTX" "TX" - Total of all values (extent values).
/// "VALX" "VX" - Value percent of pie (extent value) - (.025 yields ".025").
///
/// "S" "SNAME" - Series name.
/// "X" - ValueX.
/// "Y", "Y0", "Yn" - ValueY values (where 'n' is index value).
///
/// Use: {format[:specifier]}
private string ProcessSliceLabelFmt(string pattern)
{
string s = pattern.Substring(1, pattern.Length - 2);
int n = s.IndexOf(':');
if ((uint)n > s.Length - 1)
n = s.Length;
string placeHolder = s.Substring(0, n).Trim().ToUpper();
string formatSpecifier = (n + 1 < s.Length) ? s.Substring(n + 1) : "";
try
{
PieSeriesPointCollection spc = Parent as PieSeriesPointCollection;
switch (placeHolder)
{
case "A":
case "AVG":
if (spc != null)
return (GetSliceLabelText(spc.PieAverage, formatSpecifier));
break;
case "AX":
case "AVGX":
if (spc != null)
return (GetSliceLabelText(spc.PieAverageExtent, formatSpecifier));
break;
case "N":
case "NAME":
if (string.IsNullOrEmpty(formatSpecifier) == false)
return (String.Format(formatSpecifier, Name));
return (Name);
case "P":
case "PCT":
if (string.IsNullOrEmpty(formatSpecifier) == false)
return (SliceValue.ToString(formatSpecifier));
return (GetSliceLabelText(SliceValue, "P"));
case "PX":
case "PCTX":
if (string.IsNullOrEmpty(formatSpecifier) == false)
return (SliceExtent.ToString(formatSpecifier));
return (GetSliceLabelText(SliceExtent, "P"));
case "S":
case "SNAME":
string sname = ChartSeries != null ? ChartSeries.Name : "";
if (string.IsNullOrEmpty(formatSpecifier) == false)
return (String.Format(formatSpecifier, sname));
return (sname);
case "T":
case "TOTA":
if (spc != null)
return (GetSliceLabelText(spc.PieTotal, formatSpecifier));
break;
case "TX":
case "TOTX":
if (spc != null)
return (GetSliceLabelText(spc.PieTotalExtent, formatSpecifier));
break;
case "V":
case "VAL":
return (GetSliceLabelText(SliceValue, formatSpecifier));
case "VX":
case "VALX":
return (GetSliceLabelText(SliceExtent, formatSpecifier));
case "X":
return (GetSliceLabelText(ValueX, formatSpecifier));
case "Y":
case "Y0":
if (ValueY != null && ValueY.Length > 0)
return (GetSliceLabelText(ValueY[0], formatSpecifier));
return ("");
default:
if (placeHolder.StartsWith("Y") == true)
{
int index = int.Parse(placeHolder.Substring(1));
if (ValueY != null && ValueY.Length > index)
return (GetSliceLabelText(ValueY[index], formatSpecifier));
}
return (s);
}
}
catch
{
}
return (s);
}
#region GetSliceLabelText
private string GetSliceLabelText(object value, string format)
{
if (value is string)
{
if (string.IsNullOrEmpty(format) == true)
return ((string)value);
return (String.Format(format, value));
}
else
{
double d = Convert.ToDouble(value);
if (string.IsNullOrEmpty(format) == false)
return (d.ToString(format));
return (d.ToString("F3"));
}
}
#endregion
#endregion
#endregion
#region Style handling
#region GetEffectiveSliceStyle
public ChartSliceVisualStyle
GetEffectiveSliceStyle(PieChart pieChart, PieSeries series)
{
StyleState state = StyleState.Default;
if (series.IsHighLightedPsp(pieChart, this) == true)
state |= StyleState.MouseOver;
if (IsSelected == true)
state |= StyleState.Selected;
ChartSliceVisualStyle estyle = EffectiveSliceStyles[state];
if (_WordPosLines != null)
{
if (_LastEffectiveStyle != null)
{
if (EqualFonts(estyle.SliceInnerLabelStyle.Font,
_LastEffectiveStyle.SliceInnerLabelStyle.Font) == false)
{
_CharBounds = null;
_WordPosLines = null;
}
}
_LastEffectiveStyle = estyle;
}
return (estyle);
}
#region EqualFonts
private bool EqualFonts(Font font1, Font font2)
{
if (font1 == null || font2 == null)
return (false);
return (font1.Name == font2.Name &&
font1.SizeInPoints == font2.SizeInPoints &&
font1.Style == font2.Style);
}
#endregion
#endregion
#region ApplyStyles
public void ApplyStyles(BaseVisualStyle style)
{
}
public void ApplyStyles(BaseVisualStyle style, StyleType cs)
{
ChartSliceVisualStyle sstyle = style as ChartSliceVisualStyle;
if (sstyle != null)
{
PieSeriesPointCollection spc = Parent as PieSeriesPointCollection;
PieSeries series = ChartSeries;
if (IsOther == true)
{
ApplyOtherParentStyles(sstyle, cs, series.Parent as ChartContainer);
sstyle.ApplyStyle(series.SubSliceVisualLayout.OtherSliceVisualStyles[cs]);
ApplyOtherParentPspStyle(sstyle, cs, this);
}
else
{
ApplyParentStyles(sstyle, cs, series.Parent as ChartContainer);
sstyle.ApplyStyle(series.SubSliceVisualLayout.SliceVisualStyles[cs]);
ApplyParentPspStyle(sstyle, cs, this);
}
sstyle.ApplyStyle(SliceVisualStyles[cs]);
}
}
#region ApplyOtherParentStyles
private void ApplyOtherParentStyles(
ChartSliceVisualStyle sstyle, StyleType cs, ChartContainer item)
{
if (item != null)
{
ApplyOtherParentStyles(sstyle, cs, item.Parent as ChartContainer);
ChartPanel panel = item as ChartPanel;
if (panel != null)
{
sstyle.ApplyStyle(panel.DefaultVisualStyles.OtherSliceVisualStyles[cs]);
}
else
{
PieChart pieChart = item as PieChart;
if (pieChart != null)
sstyle.ApplyStyle(pieChart.SubSliceVisualLayout.OtherSliceVisualStyles[cs]);
}
}
else
{
ChartControl chartControl = ChartControl;
if (chartControl != null)
{
sstyle.ApplyStyle(chartControl.BaseVisualStyles.OtherSliceVisualStyles[cs]);
sstyle.ApplyStyle(chartControl.DefaultVisualStyles.OtherSliceVisualStyles[cs]);
}
}
}
#endregion
#region ApplyOtherParentPspStyle
private void ApplyOtherParentPspStyle(
ChartSliceVisualStyle sstyle, StyleType cs, PieSeriesPoint psp)
{
psp = GetParentPsp(psp);
if (psp != null)
{
ApplyOtherParentPspStyle(sstyle, cs, psp);
sstyle.ApplyStyle(psp.SubSliceVisualLayout.OtherSliceVisualStyles[cs]);
}
}
#endregion
#region ApplyParentStyles
private void ApplyParentStyles(
ChartSliceVisualStyle sstyle, StyleType cs, ChartContainer item)
{
if (item != null)
{
ApplyParentStyles(sstyle, cs, item.Parent as ChartContainer);
if (item is PieChart)
sstyle.ApplyStyle(((PieChart)item).SubSliceVisualLayout.SliceVisualStyles[cs]);
if (item is ChartPanel)
sstyle.ApplyStyle(((ChartPanel)item).DefaultVisualStyles.SliceVisualStyles[cs]);
}
else
{
ChartControl chartControl = ChartControl;
if (chartControl != null)
{
sstyle.ApplyStyle(ChartControl.BaseVisualStyles.SliceVisualStyles[cs]);
sstyle.ApplyStyle(ChartControl.DefaultVisualStyles.SliceVisualStyles[cs]);
}
}
}
#endregion
#region ApplyParentPspStyle
private void ApplyParentPspStyle(
ChartSliceVisualStyle sstyle, StyleType cs, PieSeriesPoint psp)
{
psp = GetParentPsp(psp);
if (psp != null)
{
ApplyParentPspStyle(sstyle, cs, psp);
sstyle.ApplyStyle(psp.SubSliceVisualLayout.SliceVisualStyles[cs]);
}
}
#endregion
#endregion
#region ApplyDefaults
public void ApplyDefaults(BaseVisualStyle style, StyleType styleType)
{
ChartSliceVisualStyle sstyle = style as ChartSliceVisualStyle;
if (sstyle != null)
{
HatchFillType hatch = HatchFillType.LightUpwardDiagonal;
switch (styleType)
{
case StyleType.Default:
if (sstyle.Background.IsEmpty == true)
sstyle.Background = new Background(DefaultPaletteColor);
if (sstyle.WhiteSpaceBackground.IsEmpty == true)
sstyle.WhiteSpaceBackground = new Background(Color.FromArgb(100, DefaultPaletteColor));
if (sstyle.WhiteSpaceBorder.LinePattern == LinePattern.NotSet)
sstyle.WhiteSpaceBorder.LinePattern = LinePattern.Solid;
break;
case StyleType.MouseOver:
if (sstyle.Background.IsEmpty == true)
sstyle.Background = new Background(ControlPaint.Light(DefaultPaletteColor));
if (sstyle.WhiteSpaceBackground.IsEmpty == true)
sstyle.WhiteSpaceBackground = new Background(Color.FromArgb(50, DefaultPaletteColor));
if (sstyle.WhiteSpaceBorder.LinePattern == LinePattern.NotSet)
sstyle.WhiteSpaceBorder.LinePattern = LinePattern.Solid;
break;
case StyleType.Selected:
if (sstyle.Background.IsEmpty == true)
{
sstyle.Background = new Background(Color.White, DefaultPaletteColor);
sstyle.Background.HatchFillType = hatch;
}
if (sstyle.Border.LineWidth < 0)
sstyle.Border.LineWidth = 2;
if (sstyle.WhiteSpaceBackground.IsEmpty == true)
{
sstyle.WhiteSpaceBackground = new Background(Color.White, Color.FromArgb(100, DefaultPaletteColor));
sstyle.WhiteSpaceBackground.HatchFillType = hatch;
}
if (sstyle.WhiteSpaceBorder.LineWidth < 0)
sstyle.WhiteSpaceBorder.LineWidth = 2;
break;
case StyleType.SelectedMouseOver:
if (sstyle.Background.IsEmpty == true)
{
sstyle.Background = new Background(Color.White, ControlPaint.Light(DefaultPaletteColor));
sstyle.Background.HatchFillType = hatch;
}
if (sstyle.Border.LineWidth < 0)
sstyle.Border.LineWidth = 2;
if (sstyle.WhiteSpaceBackground.IsEmpty == true)
{
sstyle.WhiteSpaceBackground = new Background(Color.White, Color.FromArgb(50, DefaultPaletteColor));
sstyle.WhiteSpaceBackground.HatchFillType = hatch;
}
if (sstyle.WhiteSpaceBorder.LineWidth < 0)
sstyle.WhiteSpaceBorder.LineWidth = 2;
break;
}
if (sstyle.Border.LineColor.IsEmpty == true)
sstyle.Border.LineColor = DefaultPaletteColor;
if (sstyle.WhiteSpaceBorder.LineColor.IsEmpty == true)
sstyle.WhiteSpaceBorder.LineColor = DefaultPaletteColor;
if (sstyle.ExtentAverageRefLineStyle.LineColor.IsEmpty == true)
sstyle.ExtentAverageRefLineStyle.LineColor = Color.DimGray;
if (sstyle.ExtentMinRefLineStyle.LineColor.IsEmpty == true)
sstyle.ExtentMinRefLineStyle.LineColor = Color.DimGray;
if (sstyle.ExtentMaxRefLineStyle.LineColor.IsEmpty == true)
sstyle.ExtentMaxRefLineStyle.LineColor = Color.DimGray;
if (sstyle.ExtentOuterRefLineStyle.LineColor.IsEmpty == true)
sstyle.ExtentOuterRefLineStyle.LineColor = Color.DimGray;
if (sstyle.SliceOuterLabelStyle.TextColor.IsEmpty == true)
sstyle.SliceOuterLabelStyle.TextColor = DefaultPaletteColor;
sstyle.ApplyDefaults();
}
}
#endregion
#region GetElementStyle
public virtual void GetElementStyle(
IEffectiveStyle chartElement, StyleType styleType, ref BaseVisualStyle style)
{
ChartControl chartControl = ChartControl;
if (chartControl != null)
chartControl.DoGetPieSeriesPointStyleEvent(this, styleType, ref style);
}
#endregion
#region ChartControl
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public ChartControl ChartControl
{
get
{
if (_ChartControl == null)
{
if (ChartSeries != null)
_ChartControl = ChartSeries.ChartControl;
}
return (_ChartControl);
}
}
#endregion
#region ClearEffectiveStyles
protected void ClearEffectiveStyles()
{
_EffectiveSliceStyles.InvalidateStyles();
}
#endregion
#region OnStyleChanged
protected virtual void OnStyleChanged(string property,
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
{
StyleChangeHandler(oldValue, newValue);
OnPropertyChanged(property);
}
#endregion
#region StyleChangeHandler
protected void StyleChangeHandler(
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
{
if (oldValue != null)
oldValue.PropertyChanged -= StyleChanged;
if (newValue != null)
newValue.PropertyChanged += StyleChanged;
}
#region StyleChanged
/// <summary>
/// Occurs when one of element visual styles has property changes.
/// Default implementation invalidates visual appearance of element.
/// </summary>
/// <param name="sender">VisualStyle that changed.</param>
/// <param name="e">Event arguments.</param>
protected void StyleChanged(object sender, PropertyChangedEventArgs e)
{
VisualChangeType changeType = ((VisualPropertyChangedEventArgs)e).ChangeType;
PieSeries series = ChartSeries;
if (series != null)
{
if (series.ChartControl != null)
series.ChartControl.GlobalUpdateCount++;
if (changeType == VisualChangeType.Layout)
series.InvalidateLayout();
else
series.InvalidateRender();
}
}
#endregion
#endregion
#endregion
#region ILegendItem
#region ChartLegendItemVisualStyles
/// <summary>
/// Gets or sets the visual styles for the Legend item.
/// </summary>
[Category("Style")]
[Description("Indicates the visual styles for the Legend item.")]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public ChartLegendItemVisualStyles ChartLegendItemVisualStyles
{
get
{
if (_ChartLegendItemVisualStyles == null)
{
_ChartLegendItemVisualStyles = new ChartLegendItemVisualStyles();
StyleChangeHandler(null, _ChartLegendItemVisualStyles);
}
return (_ChartLegendItemVisualStyles);
}
set
{
if (_ChartLegendItemVisualStyles != value)
{
ChartLegendItemVisualStyles oldValue = _ChartLegendItemVisualStyles;
_ChartLegendItemVisualStyles = value;
OnStyleChanged("ChartLegendItemVisualStyles", oldValue, value);
if (oldValue != null)
oldValue.Dispose();
}
}
}
#endregion
#region CheckedInLegend
/// <summary>
/// Gets or sets whether the item is checked in the Legend.
/// </summary>
[DefaultValue(true), Category("Legend")]
[Description("Indicates whether the item is checked in the Legend.")]
public bool CheckedInLegend
{
get { return (TestState(States.CheckedInLegend)); }
set
{
if (value != CheckedInLegend)
{
SetState(States.CheckedInLegend, value);
if (LegendItem != null)
LegendItem.UpdateCheckState();
OnPropertyChangedEx("CheckedInLegend", VisualChangeType.Layout);
}
}
}
#endregion
#region ShowCheckBoxInLegend
/// <summary>
/// Gets or sets whether a checkbox for the item is shown in the Legend.
/// </summary>
[DefaultValue(false), Category("Legend")]
[Description("Indicates whether a checkbox for the item is shown in the Legend.")]
public bool ShowCheckBoxInLegend
{
get { return (TestState(States.ShowCheckBoxInLegend)); }
set
{
if (value != ShowCheckBoxInLegend)
{
SetState(States.ShowCheckBoxInLegend, value);
OnPropertyChangedEx("ShowCheckBoxInLegend", VisualChangeType.Layout);
}
}
}
#endregion
#region ShowInLegend
/// <summary>
/// Gets or sets whether the item is shown in the Legend.
/// </summary>
[DefaultValue(true), Category("Legend")]
[Description("Indicates whether the item is shown in the Legend.")]
public bool ShowInLegend
{
get { return (TestState(States.ShowInLegend)); }
set
{
if (value != ShowInLegend)
{
SetState(States.ShowInLegend, value);
OnPropertyChangedEx("ShowInLegend", VisualChangeType.Layout);
}
}
}
#endregion
#region ShowInParentLegend
/// <summary>
/// Gets or sets whether the item Line is shown in parent Legend(s).
/// </summary>
[DefaultValue(true), Category("Legend")]
[Description("Indicates whether the item Line is shown in parent Legend(s).")]
public bool ShowInParentLegend
{
get { return (TestState(States.ShowInParentLegend)); }
set
{
if (value != ShowInParentLegend)
{
SetState(States.ShowInParentLegend, value);
OnPropertyChangedEx("ShowInParentLegend", VisualChangeType.Layout);
}
}
}
#endregion
#region ShowMarkerInLegend
/// <summary>
/// Gets or sets whether the item Marker is shown in the Legend.
/// </summary>
[DefaultValue(true), Category("Legend")]
[Description("Indicates whether the item Marker is shown in the Legend.")]
public bool ShowMarkerInLegend
{
get { return (TestState(States.ShowMarkerInLegend)); }
set
{
if (value != ShowMarkerInLegend)
{
SetState(States.ShowMarkerInLegend, value);
OnPropertyChangedEx("ShowMarkerInLegend", VisualChangeType.Layout);
}
}
}
#endregion
#region LegendItem
///<summary>
/// Gets the item's parent LegendItem.
///</summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[Description("Indicates the item's parent LegendItem.")]
public ChartLegendItem LegendItem
{
get
{
if (_LegendItem == null)
{
_LegendItem = new ChartLegendItem();
_LegendItem.Name = (ValueX != null ? ValueX.ToString() : "");
if (string.IsNullOrEmpty(_LegendItem.Name) == true)
_LegendItem.Name = "(Psp)";
_LegendItem.ChartItems.Add(this);
}
return (_LegendItem);
}
internal set { _LegendItem = value; }
}
#endregion
#region LegendText
///<summary>
/// Gets or sets the text to display in the legend.
///</summary>
[DefaultValue(null), Category("Legend")]
[Description("Indicates the text to display in the legend.")]
[NotifyParentProperty(true)]
public string LegendText
{
get { return (_LegendText); }
set
{
if (value != _LegendText)
{
_LegendText = value;
OnPropertyChangedEx("LegendText", Style.VisualChangeType.Layout);
}
}
}
#endregion
#region GetLegendItem
/// <summary>
/// Creates the LegendItem for the item.
/// </summary>
/// <returns></returns>
public ChartLegendItem GetLegendItem()
{
ChartLegendItem item = LegendItem;
if (ShowInLegend == true)
{
item.CheckState = (CheckedInLegend == true)
? CheckState.Checked : CheckState.Unchecked;
item.ItemText = LegendText;
item.IsEnabled = IsEnabled;
}
return (item);
}
#endregion
#region GetLegendItems
/// <summary>
/// Creates a list of legend items associated with
/// the item.
/// </summary>
/// <returns></returns>
public List<ChartLegendItem> GetLegendItems()
{
List<ChartLegendItem> list = null;
ChartLegendItem litem = GetLegendItem();
if (litem != null)
{
list = new List<ChartLegendItem>(1);
list.Add(litem);
}
return (list);
}
#endregion
#region GetLegendItemColor
/// <summary>
/// Gets the default color associated with the legend item.
/// </summary>
/// <returns></returns>
public Color GetLegendItemColor()
{
ChartSliceVisualStyle sstyle = EffectiveSliceStyles[StyleState.Default];
Color color = sstyle.Background.Color1;
if (color.IsEmpty == false)
return (color);
return (Color.DimGray);
}
#endregion
#region RenderLegendItemMarker
/// <summary>
/// Renders the Legend item Marker.
/// </summary>
/// <param name="g"></param>
/// <param name="litem"></param>
/// <param name="style"></param>
public void RenderLegendItemMarker(Graphics g,
ChartLegendItem litem, ChartLegendItemVisualStyle style)
{
ChartSliceVisualStyle sstyle = EffectiveSliceStyles[StyleState.Default];
Rectangle r = litem.MarkerBounds;
r.Inflate(-1, -1);
g.SmoothingMode = SmoothingMode.AntiAlias;
using (GraphicsPath path = new GraphicsPath())
{
Point pt = new Point(r.Right - 2, r.Bottom - 2);
r.Height += (r.Height - 4);
r.Width += (r.Width - 4);
path.AddArc(r, 180, 90);
path.AddLine(pt, pt);
path.CloseFigure();
if (IsEnabled == true)
{
if (sstyle.Background.IsEmpty == true)
{
g.FillPath(Brushes.LightPink, path);
}
else
{
using (Brush br = sstyle.Background.GetBrush(r))
g.FillPath(br, path);
if (sstyle.Background.Color1.IsEmpty == false)
{
using (Pen pen = new Pen(sstyle.Background.Color1))
g.DrawPath(pen, path);
}
}
}
else
{
Background back = style.DisabledMarkerBackground;
if (back.IsEmpty == true)
{
using (Brush br = new SolidBrush(Color.LightGray))
g.FillPath(br, path);
}
else
{
using (Brush br = back.GetBrush(r))
g.FillPath(br, path);
if (back.Color1.IsEmpty == false)
{
using (Pen pen = new Pen(sstyle.Background.Color1))
g.DrawPath(pen, path);
}
}
}
}
}
#endregion
#region TrackLegendItem
/// <summary>
/// Gets whether legend item tracking is enabled.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool TrackLegendItem
{
get
{
if (ChartSeries != null)
return (ChartSeries.TrackLegendItem);
return (false);
}
}
#endregion
#region FormatItemText
/// <summary>
/// Formats the provided item text.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public string FormatItemText(string text)
{
return (GetLabelText(text));
}
#endregion
#endregion
#region States
[Flags]
private enum States : uint
{
AllowDetach = (1U << 0),
AllowSelect = (1U << 1),
Detached = (1U << 2),
Selected = (1U << 3),
IsOther = (1U << 4),
IsInOther = (1U << 5),
IsInOtherEx = (1U << 6),
InnerLabelClipped = (1U << 7),
InnerLabelDisplayed = (1U << 8),
IsOffset = (1U << 9),
InscribedRectValid = (1 << 10),
CheckedInLegend = (1U << 11),
ShowInLegend = (1U << 12),
ShowInParentLegend = (1U << 13),
ShowCheckBoxInLegend = (1U << 14),
ShowMarkerInLegend = (1U << 15),
ReferenceLineDisplayOnTop = (1U << 16),
ShowSliceWhiteSpaceEx = (1U << 17),
HasExtent = (1U << 18),
}
#region TestState
private bool TestState(States state)
{
return ((_States & state) == state);
}
#endregion
#region SetState
private void SetState(States state, bool value)
{
if (value == true)
_States |= state;
else
_States &= ~state;
}
#endregion
#endregion
#region Copy/CopyTo
/// <summary>
/// Creates a copy of the PieSeriesPoint
/// </summary>
/// <returns></returns>
public new PieSeriesPoint Copy()
{
PieSeriesPoint copy = new PieSeriesPoint(ValueX, 0);
CopyTo(copy);
return (copy);
}
/// <summary>
/// Copies the item data to the given PieSeriesPoint.
/// </summary>
/// <param name="sp"></param>
public void CopyTo(PieSeriesPoint c)
{
base.CopyTo(c);
c.AllowDetach = AllowDetach;
c.AllowSelect = AllowSelect;
c.DetachedOffset = DetachedOffset;
c.InnerSliceLabel = InnerSliceLabel;
c.IsDetached = IsDetached;
c.IsInOther = IsInOther;
c.IsSelected = IsSelected;
c.Name = Name;
c.OuterSliceLabel = OuterSliceLabel;
if (_SeriesPoints != null)
{
PieSeriesPointCollection spc = SeriesPoints;
if (spc.Count > 0)
{
foreach (PieSeriesPoint psp in spc)
{
PieSeriesPoint pspCopy = psp.Copy();
c.SeriesPoints.Add(pspCopy);
}
}
}
c.SubSliceVisualLayout = (_SliceVisualLayout != null) ? _SliceVisualLayout.Copy() : null;
c.SliceVisualStyles = (_SliceVisualStyles != null) ? _SliceVisualStyles.Copy() : null;
c.StartAngle = StartAngle;
c.SweepAngle = SweepAngle;
c.CheckedInLegend = CheckedInLegend;
c.LegendText = LegendText;
c.ShowCheckBoxInLegend = ShowCheckBoxInLegend;
c.ShowInLegend = ShowInLegend;
c.ShowInParentLegend = ShowInParentLegend;
c.ShowMarkerInLegend = ShowMarkerInLegend;
}
#endregion
#region GetSerialData
internal override SerialElementCollection GetSerialData(bool root)
{
SerialElementCollection sec = new SerialElementCollection();
if (root == true)
sec.AddStartElement("SeriesPoint");
sec.AddValue("AllowDetach", AllowDetach, true);
sec.AddValue("AllowSelect", AllowSelect, true);
sec.AddValue("DetachedOffset", DetachedOffset, double.NaN);
sec.AddValue("InnerSliceLabel", InnerSliceLabel, null);
sec.AddValue("IsDetached", IsDetached, false);
sec.AddValue("IsInOther", IsInOther, false);
sec.AddValue("IsSelected", IsSelected, false);
sec.AddValue("Name", Name, null);
sec.AddValue("OuterSliceLabel", OuterSliceLabel, null);
sec.AddValue("StartAngle", StartAngle, double.NaN);
sec.AddValue("SweepAngle", SweepAngle, double.NaN);
if (_SeriesPoints != null)
{
PieSeriesPointCollection spc = SeriesPoints;
if (spc.Count > 0)
{
sec.AddStartElement("SeriesPoints count=\"" + spc.Count + "\"");
foreach (PieSeriesPoint psp in spc)
sec.AddElement(psp.GetSerialData());
sec.AddEndElement("SeriesPoints");
}
}
if (_SliceVisualLayout != null)
sec.AddElement(_SliceVisualLayout.GetSerialData());
if (_SliceVisualStyles != null && _SliceVisualStyles.IsEmpty == false)
sec.AddElement(_SliceVisualStyles.GetSerialData("SliceVisualStyles"));
sec.AddValue("CheckedInLegend", CheckedInLegend, true);
sec.AddValue("LegendText", LegendText, null);
sec.AddValue("ShowCheckBoxInLegend", ShowCheckBoxInLegend, true);
sec.AddValue("ShowInLegend", ShowInLegend, true);
sec.AddValue("ShowInParentLegend", ShowInParentLegend, true);
sec.AddValue("ShowMarkerInLegend", ShowMarkerInLegend, true);
sec.AddElement(base.GetSerialData(false));
if (root == true)
sec.AddEndElement("SeriesPoint");
return (sec);
}
#endregion
#region PutSerialData
#region ProcessValue
internal override void ProcessValue(SerialElement se)
{
switch (se.Name)
{
case "AllowDetach":
AllowDetach = bool.Parse(se.StringValue);
break;
case "AllowSelect":
AllowSelect = bool.Parse(se.StringValue);
break;
case "DetachedOffset":
DetachedOffset = double.Parse(se.StringValue);
break;
case "InnerSliceLabel":
InnerSliceLabel = se.StringValue;
break;
case "IsDetached":
IsDetached = bool.Parse(se.StringValue);
break;
case "IsInOther":
IsInOther = bool.Parse(se.StringValue);
break;
case "IsSelected":
IsSelected = bool.Parse(se.StringValue);
break;
case "Name":
Name = se.StringValue;
break;
case "OuterSliceLabel":
OuterSliceLabel = se.StringValue;
break;
case "StartAngle":
StartAngle = double.Parse(se.StringValue);
break;
case "SweepAngle":
SweepAngle = double.Parse(se.StringValue);
break;
case "CheckedInLegend":
CheckedInLegend = bool.Parse(se.StringValue);
break;
case "LegendText":
LegendText = se.StringValue;
break;
case "ShowCheckBoxInLegend":
ShowCheckBoxInLegend = bool.Parse(se.StringValue);
break;
case "ShowInLegend":
ShowInLegend = bool.Parse(se.StringValue);
break;
case "ShowInParentLegend":
ShowInParentLegend = bool.Parse(se.StringValue);
break;
case "ShowMarkerInLegend":
ShowMarkerInLegend = bool.Parse(se.StringValue);
break;
default:
base.ProcessValue(se);
break;
}
}
#endregion
#region ProcessCollection
internal override void ProcessCollection(SerialElement se)
{
SerialElementCollection sec = se.Sec;
switch (se.Name)
{
case "SeriesPoints":
if (se.ArrayCount > 0)
{
SeriesPoints = new PieSeriesPointCollection();
sec.PutSerialData(this);
}
break;
case "SeriesPoint":
PieSeriesPoint sp = new PieSeriesPoint();
sec.PutSerialData(sp);
SeriesPoints.Add(sp);
break;
case "SliceVisualLayout":
sec.PutSerialData(SubSliceVisualLayout);
break;
case "SliceVisualStyles":
se.Sec.PutSerialData(SliceVisualStyles);
break;
default:
base.ProcessCollection(se);
break;
}
}
#endregion
#endregion
#region INotifyPropertyChanged Members
/// <summary>
/// Occurs when property value has changed.
/// </summary>
public event PropertyChangedEventHandler PropertyChanged;
#region OnPropertyChanged
/// <summary>
/// Raises the PropertyChanged event.
/// </summary>
/// <param name="e">Event arguments</param>
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
if (PropertyChanged != null)
PropertyChanged(this, e);
VisualPropertyChangedEventArgs vce = e as VisualPropertyChangedEventArgs;
if (vce != null)
NotifyVisualParent(this, vce.ChangeType);
}
/// <summary>
/// Default PropertyChanged processing
/// </summary>
/// <param name="s"></param>
protected void OnPropertyChanged(string s)
{
if (PropertyChanged != null)
OnPropertyChanged(new PropertyChangedEventArgs(s));
}
/// <summary>
/// Default PropertyChanged processing
/// </summary>
/// <param name="s"></param>
/// <param name="changeType">invalidate</param>
protected void OnPropertyChangedEx(string s, VisualChangeType changeType)
{
if (PropertyChanged != null)
OnPropertyChanged(new VisualPropertyChangedEventArgs(s, changeType));
}
#endregion
#region NotifyVisualParent
internal void NotifyVisualParent(object sender, VisualChangeType vct)
{
ChartVisualElement cve = GetParentCve(sender);
if (cve != null)
{
if (vct == VisualChangeType.Recalc)
{
cve.InvalidateRecalc();
cve.InvalidateLayout();
}
else if (vct == VisualChangeType.Layout)
{
cve.InvalidateLayout();
}
else
{
PieSeriesPoint psp = (PieSeriesPoint)sender;
cve.InvalidateRender(psp.PathBounds);
if (psp.PieLabel != null)
{
if (psp.PieLabel.Bounds.IsEmpty == false)
{
cve.InvalidateRender(psp.PieLabel.Bounds);
if (psp.PieLabel.ConnectorBounds.IsEmpty == false)
cve.InvalidateRender(psp.PieLabel.ConnectorBounds);
}
}
}
}
}
#region GetParentCve
private ChartVisualElement GetParentCve(object sender)
{
object parent = sender;
while (parent != null)
{
if (parent is ChartVisualElement)
break;
if (parent is PieSeriesPoint)
parent = ((PieSeriesPoint)parent).Parent;
else if (parent is PieSeriesPointCollection)
parent = ((PieSeriesPointCollection)parent).Parent;
else
parent = null;
}
return ((ChartVisualElement)parent);
}
#endregion
#endregion
#endregion
#region InvalidateRender
public void InvalidateRender()
{
ChartVisualElement cve = GetParentCve(Parent);
if (cve != null)
{
cve.InvalidateRender(PathBounds);
if (PieLabel != null)
{
if (PieLabel.Bounds.IsEmpty == false)
{
cve.InvalidateRender(PieLabel.Bounds);
if (PieLabel.ConnectorBounds.IsEmpty == false)
cve.InvalidateRender(PieLabel.ConnectorBounds);
}
}
}
}
#endregion
#region IDispose
public override void Dispose()
{
SubSliceVisualLayout = null;
SliceVisualStyles = null;
base.Dispose();
}
#endregion
}
#endregion
[Editor("DevComponents.Charts.Design.SeriesPointCollectionEditor, DevComponents.Charts.Design, " +
"Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public class SeriesPointCollection : CustomCollection<SeriesPoint>
{
}
#region SeriesPoint
[DesignTimeVisible(false), ToolboxItem(false)]
public class SeriesPoint : IProcessSerialElement, IDisposable
{
#region Private variables
private object _ValueX;
private object[] _ValueY;
private Point[] _Point;
private int _SeriesValidationCount;
private Size _PointSize;
private States _States;
private object _DataItem;
private object _Tag;
#endregion
#region Constructors
public SeriesPoint()
: this(0, 0)
{
}
public SeriesPoint(object xValue)
{
_Point = new Point[1];
ValueX = xValue;
InitDefaultStates();
}
public SeriesPoint(object xValue, object yValue)
{
_ValueY = new object[1];
_Point = new Point[1];
ValueX = xValue;
_ValueY[0] = yValue;
InitDefaultStates();
}
public SeriesPoint(object xValue, object yValue, object size)
{
_ValueY = new object[2];
_Point = new Point[1];
ValueX = xValue;
_ValueY[0] = yValue;
_ValueY[1] = size;
InitDefaultStates();
}
public SeriesPoint(object xValue, object yValue, object size, object intensity)
{
_ValueY = new object[3];
_Point = new Point[1];
ValueX = xValue;
_ValueY[0] = yValue;
_ValueY[1] = size;
_ValueY[2] = intensity;
InitDefaultStates();
}
public SeriesPoint(object xValue, object[] yValue)
{
_ValueY = new object[yValue.Length];
_Point = new Point[yValue.Length];
ValueX = xValue;
for (int i = 0; i < yValue.Length; i++)
{
_ValueY[i] = yValue[i];
if (i > 0)
{
if (IsQuantitativeYValue != IsQuantitativeValue(yValue[i]))
throw new ArgumentException("Cannot have mixed qualitative/quantitative yValues");
}
}
InitDefaultStates();
}
#endregion
#region InitDefaultStates
private void InitDefaultStates()
{
SetState(States.Visible, true);
}
#endregion
#region Public properties
#region DataItem
///<summary>
/// Gets the object to which the Point is bound.
///</summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public object DataItem
{
get { return (_DataItem); }
internal set { _DataItem = value; }
}
#endregion
#region IsEmpty
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool IsEmpty
{
get { return (IsEmptyPoint || IsEmptyValue); }
}
#endregion
#region IsEmptyPoint
/// <summary>
/// Gets or sets whether the point is an 'Empty' (or missing) Point.
/// </summary>
[DefaultValue(false)]
public virtual bool IsEmptyPoint
{
get { return (TestState(States.IsEmptyPoint)); }
set { SetState(States.IsEmptyPoint, value); }
}
#endregion
#region IsEmptyValue
/// <summary>
/// Gets whether the point is an 'Empty' value.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool IsEmptyValue
{
get { return (TestState(States.IsEmptyValue)); }
internal set { SetState(States.IsEmptyValue, value); }
}
#endregion
#region IsQualitativeXValue
/// <summary>
/// Gets whether the X Value is a Qualitative value.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool IsQualitativeXValue
{
get { return (TestState(States.IsQualitativeXValue)); }
internal set { SetState(States.IsQualitativeXValue, value); }
}
#endregion
#region IsQualitativeYValue
/// <summary>
/// Gets whether the Y Values are a Qualitative values.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool IsQualitativeYValue
{
get { return (IsQuantitativeYValue == false); }
}
#endregion
#region IsQuantitativeXValue
/// <summary>
/// Gets whether the X Value is a Quantitative value.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool IsQuantitativeXValue
{
get { return (!IsQualitativeXValue); }
internal set { IsQualitativeXValue = !value; }
}
#endregion
#region IsQuantitativeYValue
/// <summary>
/// Gets whether the Y Values are Quantitative values.
/// </summary>
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool IsQuantitativeYValue
{
get
{
if (_ValueY != null && _ValueY.Length > 0)
return (IsQuantitativeValue(_ValueY[0]));
return (true);
}
}
#endregion
#region Tag
///<summary>
/// Gets or sets user-defined data associated with the point
///</summary>
[DefaultValue(null)]
[Description("Indicates the user-defined data associated with the point.")]
[TypeConverter("DevComponents.Charts.Design.PointValueConverter, DevComponents.Charts.Design," +
"Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
public object Tag
{
get { return (_Tag); }
set { _Tag = value; }
}
#endregion
#region ValueX
/// <summary>
/// Gets or sets the X-Axis Value.
/// </summary>
[Category("Data")]
[Description("Indicates the X-Axis Value.")]
[TypeConverter("DevComponents.Charts.Design.PointValueConverter, DevComponents.Charts.Design," +
"Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
public object ValueX
{
get { return (_ValueX); }
set
{
_ValueX = value;
IsQuantitativeXValue = IsQuantitativeValue(value);
}
}
#endregion
#region ValueY
/// <summary>
/// Gets or sets the Y-Axis Values.
/// </summary>
[Category("Data")]
[Description("Indicates the Y-Axis Values.")]
[Editor("DevComponents.Charts.Design.SeriesPointValueEditor, DevComponents.Charts.Design, " +
"Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
public object[] ValueY
{
get { return (_ValueY); }
set { _ValueY = value; }
}
#endregion
#region Visible
/// <summary>
/// Gets or sets whether the point is Visible.
/// </summary>
[DefaultValue(true)]
public virtual bool Visible
{
get { return (TestState(States.Visible)); }
set { SetState(States.Visible, value); }
}
#endregion
#endregion
#region Internal properties
#region Point
internal Point[] Point
{
get { return (_Point); }
set { _Point = value; }
}
#endregion
#region PointSize
internal Size PointSize
{
get { return (_PointSize); }
set { _PointSize = value; }
}
#endregion
#region SeriesValidationCount
internal int SeriesValidationCount
{
get { return (_SeriesValidationCount); }
set { _SeriesValidationCount = value; }
}
#endregion
#endregion
#region InvalidatePoints
internal void InvalidatePoints()
{
if (_Point != null)
_Point = new Point[_Point.Length];
}
#endregion
#region IsQuantitativeValue
private bool IsQuantitativeValue(object value)
{
if (value is string || value is bool || value is char)
return (false);
return (true);
}
#endregion
#region IsQualitativeValue
private bool IsQualitativeValue(object value)
{
return (IsQuantitativeValue(value) == false);
}
#endregion
#region GetScaleType
public static ScaleType GetScaleType(Type dataType)
{
if (dataType == typeof(DateTime))
return (ScaleType.DateTime);
if (dataType == typeof(string) || dataType == typeof(bool) || dataType == typeof(char))
return (ScaleType.Qualitative);
return (ScaleType.Quantitative);
}
#endregion
#region Copy/CopyTo
/// <summary>
/// Creates a copy of the SeriesPoint
/// </summary>
/// <returns></returns>
public SeriesPoint Copy()
{
SeriesPoint copy = new SeriesPoint(ValueX);
CopyTo(copy);
return (copy);
}
/// <summary>
/// Copies the item data to the given SeriesPoint.
/// </summary>
/// <param name="sp"></param>
public void CopyTo(SeriesPoint sp)
{
sp.IsEmptyPoint = IsEmptyPoint;
sp.Tag = Tag;
sp.ValueX = ValueX;
if (ValueY != null)
{
sp.ValueY = new object[ValueY.Length];
sp.Point = new Point[ValueY.Length];
for (int i = 0; i < ValueY.Length; i++)
sp.ValueY[i] = ValueY[i];
}
}
#endregion
#region GetSerialData
internal virtual SerialElementCollection GetSerialData()
{
return (GetSerialData(true));
}
internal virtual SerialElementCollection GetSerialData(bool root)
{
SerialElementCollection sec = new SerialElementCollection();
if (root == true)
sec.AddStartElement("SeriesPoint");
sec.AddDataValue("Tag", Tag, null);
sec.AddDataValue("ValueX", ValueX);
if (ValueY != null)
{
if (ValueY.Length == 1)
{
sec.AddDataValue("ValueY0", ValueY[0]);
}
else
{
sec.AddStartElement("ValueYs count=\"" + ValueY.Length + "\"");
for (int i = 0; i < ValueY.Length; i++)
sec.AddDataValue("ValueY", ValueY[i]);
sec.AddEndElement("ValueYs");
}
}
if (root == true)
sec.AddEndElement("SeriesPoint");
return (sec);
}
#endregion
#region PutSerialData
#region ProcessValue
void IProcessSerialElement.ProcessValue(SerialElement se)
{
ProcessValue(se);
}
internal virtual void ProcessValue(SerialElement se)
{
switch (se.Name)
{
case "Tag":
Tag = se.DataValue;
break;
case "ValueX":
ValueX = se.DataValue;
break;
case "ValueY":
ValueY[se.ValueIndex] = se.DataValue;
break;
case "ValueY0":
ValueY = new object[1];
ValueY[0] = se.DataValue;
break;
default:
throw new Exception("Unknown Serial Value (" + se.Name + ")");
}
}
#endregion
#region ProcessCollection
void IProcessSerialElement.ProcessCollection(SerialElement se)
{
ProcessCollection(se);
}
internal virtual void ProcessCollection(SerialElement se)
{
switch (se.Name)
{
case "ValueYs":
if (se.ArrayCount > 0)
{
ValueY = new object[se.ArrayCount];
se.Sec.PutSerialData(this);
}
break;
default:
throw new Exception("Unknown Serial Collection (" + se.Name + ")");
}
}
#endregion
#endregion
#region States
[Flags]
private enum States : uint
{
IsQualitativeXValue = (1U << 0),
IsQualitativeYValue = (1U << 1),
IsEmptyPoint = (1U << 2),
IsEmptyValue = (1U << 3),
Visible = (1U << 4),
}
#region TestState
private bool TestState(States state)
{
return ((_States & state) == state);
}
#endregion
#region SetState
private void SetState(States state, bool value)
{
if (value == true)
_States |= state;
else
_States &= ~state;
}
#endregion
#endregion
#region ToString
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append("SeriesPoint (");
sb.Append(FormatToStringValue(ValueX));
sb.Append(",");
if (ValueY != null && ValueY.Length > 0)
{
if (ValueY.Length > 1)
sb.Append("[");
foreach (object value in ValueY)
{
sb.Append(FormatToStringValue(value));
sb.Append(",");
}
sb.Length--;
if (ValueY.Length > 1)
sb.Append("]");
}
sb.Append(")");
return (sb.ToString());
}
#region FormatToStringValue
private string FormatToStringValue(object value)
{
if (value == null)
return ("<null>");
if (value is string)
return ("\"" + value + "\"");
if (value is int)
return (value.ToString());
if (value is DateTime)
return (value.ToString());
return (String.Format("{0:0.0###############}", value));
}
#endregion
#endregion
#region IDispose
public virtual void Dispose()
{
}
#endregion
}
#region PointValueConvertor
///<summary>
/// PointValueConvertor
///</summary>
public class PointValueConvertor : BlankExpandableObjectConverter
{
public override object ConvertTo(
ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(string))
{
if (value == null)
return ("<null>");
if (value is string)
return ("\"" + value + "\"");
if (value is int)
return (value.ToString());
if (value is DateTime)
return (value.ToString());
return (String.Format("{0:0.0}", value));
}
return (base.ConvertTo(context, culture, value, destinationType));
}
}
#endregion
#endregion
}
Reference in New Issue View Git Blame Copy Permalink