1481 lines
38 KiB
C#
1481 lines
38 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.Charts.Style;
|
|
|
|
namespace DevComponents.DotNetBar.Charts
|
|
{
|
|
/// <summary>
|
|
/// Represents the collection of ChartIndicators.
|
|
/// </summary>
|
|
[Editor("DevComponents.Charts.Design.IndicatorCollectionEditor, DevComponents.Charts.Design, " +
|
|
"Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
|
|
public class ChartIndicatorCollection : CustomNamedCollection<ChartIndicator>
|
|
{
|
|
}
|
|
|
|
#region RegressionLine
|
|
|
|
/// <summary>
|
|
/// Represents a Regression Line (a least-squares calculated series line).
|
|
/// </summary>
|
|
public class RegressionLine : ChartIndicator, IEffectiveStyle
|
|
{
|
|
#region Private variables
|
|
|
|
private RegressionLineVisualStyle _RegressionLineVisualStyle;
|
|
private EffectiveStyle<RegressionLineVisualStyle> _EffectiveStyle;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
public RegressionLine(string name)
|
|
: this()
|
|
{
|
|
Name = name;
|
|
}
|
|
|
|
public RegressionLine()
|
|
{
|
|
InitDefaultStates();
|
|
|
|
_EffectiveStyle = new EffectiveStyle<RegressionLineVisualStyle>(this);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InitDefaultStates
|
|
|
|
private void InitDefaultStates()
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region EffectiveStyle
|
|
|
|
/// <summary>
|
|
/// Gets a reference to the RegressionLine's effective (cached, composite) style.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public RegressionLineVisualStyle EffectiveStyle
|
|
{
|
|
get { return (_EffectiveStyle.Style); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IndicatorType
|
|
|
|
/// <summary>
|
|
/// Gets the RegressionLine's IndicatorType
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public override ChartIndicatorType IndicatorType
|
|
{
|
|
get { return (ChartIndicatorType.RegressionLine); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RegressionLineVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style for the RegressionLine Indicator.
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates the visual style for the RegressionLine Indicator.")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public RegressionLineVisualStyle RegressionLineVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_RegressionLineVisualStyle == null)
|
|
{
|
|
_RegressionLineVisualStyle = new RegressionLineVisualStyle();
|
|
|
|
StyleVisualChangeHandler(null, _RegressionLineVisualStyle);
|
|
}
|
|
|
|
return (_RegressionLineVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_RegressionLineVisualStyle != value)
|
|
{
|
|
RegressionLineVisualStyle oldValue = _RegressionLineVisualStyle;
|
|
|
|
_RegressionLineVisualStyle = value;
|
|
|
|
OnStyleChanged("RegressionLineVisualStyle", oldValue, value);
|
|
|
|
if (oldValue != null)
|
|
oldValue.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Style support
|
|
|
|
#region ApplyStyles
|
|
|
|
public override void ApplyStyles(BaseVisualStyle style)
|
|
{
|
|
RegressionLineVisualStyle rstyle = style as RegressionLineVisualStyle;
|
|
|
|
if (rstyle != null)
|
|
{
|
|
ApplyParentStyles(rstyle, Parent as ChartContainer);
|
|
|
|
rstyle.ApplyStyle(RegressionLineVisualStyle);
|
|
|
|
if (rstyle.LineWidth < 0)
|
|
rstyle.LineWidth = 1;
|
|
}
|
|
}
|
|
|
|
#region ApplyParentStyles
|
|
|
|
private void ApplyParentStyles(
|
|
RegressionLineVisualStyle pstyle, ChartContainer item)
|
|
{
|
|
if (item != null)
|
|
{
|
|
ApplyParentStyles(pstyle, item.Parent as ChartContainer);
|
|
|
|
ChartPanel panel = item as ChartPanel;
|
|
|
|
if (panel != null)
|
|
pstyle.ApplyStyle(panel.DefaultVisualStyles.RegressionLineVisualStyle);
|
|
}
|
|
else
|
|
{
|
|
pstyle.ApplyStyle(ChartControl.BaseVisualStyles.RegressionLineVisualStyle);
|
|
pstyle.ApplyStyle(ChartControl.DefaultVisualStyles.RegressionLineVisualStyle);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region InvalidateStyle
|
|
|
|
///<summary>
|
|
///Invalidate the cached Style
|
|
///</summary>
|
|
public void InvalidateStyle()
|
|
{
|
|
ClearEffectiveStyles();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ClearEffectiveStyles
|
|
|
|
protected override void ClearEffectiveStyles()
|
|
{
|
|
base.ClearEffectiveStyles();
|
|
|
|
if (LegendItem != null)
|
|
LegendItem.EffectiveStyles.InvalidateStyles();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StyleChanged
|
|
|
|
protected override void StyleChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
base.StyleChanged(sender, e);
|
|
|
|
if (sender is ChartLegendItemVisualStyles && LegendItem != null)
|
|
InvalidateRender(LegendItem.Bounds);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region ILegendItem
|
|
|
|
#region GetLegendItemColorEx
|
|
|
|
protected override Color GetLegendItemColorEx()
|
|
{
|
|
RegressionLineVisualStyle rstyle = EffectiveStyle;
|
|
|
|
return (rstyle.LineColor);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderLegendItemMarkerEx
|
|
|
|
protected override void RenderLegendItemMarkerEx(Graphics g,
|
|
ChartLegendItem litem, ChartLegendItemVisualStyle style)
|
|
{
|
|
RegressionLineVisualStyle rstyle = EffectiveStyle;
|
|
|
|
if (rstyle.LinePattern != LinePattern.None)
|
|
{
|
|
Rectangle bounds = litem.MarkerBounds;
|
|
|
|
int n = bounds.Height / 2;
|
|
|
|
int lineWidth = Math.Min(rstyle.LineWidth, bounds.Height);
|
|
|
|
using (Pen pen = new Pen(GetLegendItemColor(), lineWidth))
|
|
{
|
|
if (rstyle.LinePattern != LinePattern.NotSet)
|
|
pen.DashStyle = (DashStyle)rstyle.LinePattern;
|
|
|
|
g.DrawLine(pen,
|
|
new Point(bounds.X, bounds.Y + n),
|
|
new Point(bounds.Right - 1, bounds.Y + n));
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetLegendItemTextEx
|
|
|
|
protected override string GetLegendItemTextEx()
|
|
{
|
|
return ("(RegLine)");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Copy/CopyTo
|
|
|
|
public override ChartVisualElement Copy()
|
|
{
|
|
RegressionLine copy = new RegressionLine();
|
|
|
|
CopyTo(copy);
|
|
|
|
return (copy);
|
|
}
|
|
|
|
public override void CopyTo(ChartVisualElement copy)
|
|
{
|
|
RegressionLine c = copy as RegressionLine;
|
|
|
|
if (c != null)
|
|
{
|
|
base.CopyTo(c);
|
|
|
|
c.RegressionLineVisualStyle =
|
|
(_RegressionLineVisualStyle != null) ? RegressionLineVisualStyle.Copy() : null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSerialData
|
|
|
|
internal override SerialElementCollection GetSerialData(string serialName)
|
|
{
|
|
SerialElementCollection sec = new SerialElementCollection();
|
|
|
|
if (serialName != null)
|
|
{
|
|
if (serialName.Equals("") == true)
|
|
serialName = "RegressionLine";
|
|
|
|
sec.AddStartElement(serialName);
|
|
}
|
|
|
|
if (_RegressionLineVisualStyle != null && _RegressionLineVisualStyle.IsEmpty == false)
|
|
sec.AddElement(_RegressionLineVisualStyle.GetSerialData("RegressionLineVisualStyle"));
|
|
|
|
sec.AddElement(base.GetSerialData(null));
|
|
|
|
if (serialName != null)
|
|
sec.AddEndElement(serialName);
|
|
|
|
return (sec);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PutSerialData
|
|
|
|
#region ProcessValue
|
|
|
|
internal override void ProcessValue(SerialElement se)
|
|
{
|
|
switch (se.Name)
|
|
{
|
|
default:
|
|
base.ProcessValue(se);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessCollection
|
|
|
|
internal override void ProcessCollection(SerialElement se)
|
|
{
|
|
SerialElementCollection sec = se.Sec;
|
|
|
|
switch (se.Name)
|
|
{
|
|
case "RegressionLineVisualStyle":
|
|
sec.PutSerialData(RegressionLineVisualStyle);
|
|
break;
|
|
|
|
default:
|
|
base.ProcessCollection(se);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region IDisposable
|
|
|
|
public override void Dispose()
|
|
{
|
|
RegressionLineVisualStyle = null;
|
|
|
|
base.Dispose();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TrendLine
|
|
|
|
/// <summary>
|
|
/// Represents a Trend Line (a line connecting any 2 defined SeriesPoints).
|
|
/// </summary>
|
|
public class TrendLine : ChartIndicator, IEffectiveStyle
|
|
{
|
|
#region Private variables
|
|
|
|
private object _ValueX1;
|
|
private object _ValueX2;
|
|
|
|
private TrendLineVisualStyle _TrendLineVisualStyle;
|
|
private EffectiveStyle<TrendLineVisualStyle> _EffectiveStyle;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
/// <summary>
|
|
/// TrendLine
|
|
/// </summary>
|
|
public TrendLine()
|
|
{
|
|
InitDefaultStates();
|
|
|
|
_EffectiveStyle = new EffectiveStyle<TrendLineVisualStyle>(this);
|
|
}
|
|
|
|
#region Constructors
|
|
|
|
/// <summary>
|
|
/// TrendLine
|
|
/// </summary>
|
|
/// <param name="name">Name</param>
|
|
public TrendLine(string name)
|
|
: this()
|
|
{
|
|
Name = name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// TrendLine
|
|
/// </summary>
|
|
/// <param name="name">Name</param>
|
|
/// <param name="valuex1">Starting X-Axis value</param>
|
|
/// <param name="valuex2">Ending X-Axis value</param>
|
|
public TrendLine(string name, object valuex1, object valuex2)
|
|
: this(name)
|
|
{
|
|
ValueX1 = valuex1;
|
|
ValueX2 = valuex2;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region InitDefaultStates
|
|
|
|
private void InitDefaultStates()
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region EffectiveStyles
|
|
|
|
/// <summary>
|
|
/// Gets a reference to the TrendLine's effective (cached, composite) style.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public TrendLineVisualStyle EffectiveStyle
|
|
{
|
|
get { return (_EffectiveStyle.Style); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IndicatorType
|
|
|
|
/// <summary>
|
|
/// Gets the TrendLine's IndicatorType
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public override ChartIndicatorType IndicatorType
|
|
{
|
|
get { return (ChartIndicatorType.TrendLine); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TrendLineVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style for the TrendLine Indicator.
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates the visual style for the TrendLine Indicator.")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public TrendLineVisualStyle TrendLineVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_TrendLineVisualStyle == null)
|
|
{
|
|
_TrendLineVisualStyle = new TrendLineVisualStyle();
|
|
|
|
StyleVisualChangeHandler(null, _TrendLineVisualStyle);
|
|
}
|
|
|
|
return (_TrendLineVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_TrendLineVisualStyle != value)
|
|
{
|
|
TrendLineVisualStyle oldValue = _TrendLineVisualStyle;
|
|
|
|
_TrendLineVisualStyle = value;
|
|
|
|
OnStyleChanged("TrendLineVisualStyle", oldValue, value);
|
|
|
|
if (oldValue != null)
|
|
oldValue.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ValueX1
|
|
|
|
/// <summary>
|
|
/// Trendline starting X value
|
|
/// </summary>
|
|
[Category("Data")]
|
|
[Description("Indicates the Trendline starting X value.")]
|
|
[TypeConverter("DevComponents.Charts.Design.PointValueConverter," +
|
|
"DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
|
|
public object ValueX1
|
|
{
|
|
get { return (_ValueX1); }
|
|
set { _ValueX1 = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ValueX2
|
|
|
|
/// <summary>
|
|
/// Trendline ending X value
|
|
/// </summary>
|
|
[Category("Data")]
|
|
[Description("Indicates the Trendline ending X value.")]
|
|
[TypeConverter("DevComponents.Charts.Design.PointValueConverter," +
|
|
"DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf")]
|
|
public object ValueX2
|
|
{
|
|
get { return (_ValueX2); }
|
|
set { _ValueX2 = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Style support
|
|
|
|
#region ApplyStyles
|
|
|
|
public override void ApplyStyles(BaseVisualStyle style)
|
|
{
|
|
TrendLineVisualStyle tstyle = style as TrendLineVisualStyle;
|
|
|
|
if (tstyle != null)
|
|
{
|
|
ApplyParentStyles(tstyle, Parent as ChartContainer);
|
|
|
|
tstyle.ApplyStyle(TrendLineVisualStyle);
|
|
|
|
if (tstyle.LineWidth < 0)
|
|
tstyle.LineWidth = 1;
|
|
}
|
|
}
|
|
|
|
#region ApplyParentStyles
|
|
|
|
private void ApplyParentStyles( TrendLineVisualStyle pstyle, ChartContainer item)
|
|
{
|
|
if (item != null)
|
|
{
|
|
ApplyParentStyles(pstyle, item.Parent as ChartContainer);
|
|
|
|
if (item is ChartPanel)
|
|
pstyle.ApplyStyle(((ChartPanel)item).DefaultVisualStyles.TrendLineVisualStyle);
|
|
}
|
|
else
|
|
{
|
|
pstyle.ApplyStyle(ChartControl.BaseVisualStyles.TrendLineVisualStyle);
|
|
pstyle.ApplyStyle(ChartControl.DefaultVisualStyles.TrendLineVisualStyle);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region InvalidateStyle
|
|
|
|
///<summary>
|
|
///Invalidate the cached Style
|
|
///</summary>
|
|
public void InvalidateStyle()
|
|
{
|
|
ClearEffectiveStyles();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ClearEffectiveStyles
|
|
|
|
protected override void ClearEffectiveStyles()
|
|
{
|
|
base.ClearEffectiveStyles();
|
|
|
|
if (LegendItem != null)
|
|
LegendItem.EffectiveStyles.InvalidateStyles();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StyleChanged
|
|
|
|
protected override void StyleChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
base.StyleChanged(sender, e);
|
|
|
|
if (sender is ChartLegendItemVisualStyles && LegendItem != null)
|
|
InvalidateRender(LegendItem.Bounds);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region ILegendItem
|
|
|
|
#region GetLegendItemColorEx
|
|
|
|
protected override Color GetLegendItemColorEx()
|
|
{
|
|
TrendLineVisualStyle tstyle = EffectiveStyle;
|
|
|
|
return (tstyle.LineColor);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderLegendItemMarkerEx
|
|
|
|
protected override void RenderLegendItemMarkerEx(Graphics g,
|
|
ChartLegendItem litem, ChartLegendItemVisualStyle style)
|
|
{
|
|
TrendLineVisualStyle tstyle = EffectiveStyle;
|
|
|
|
if (tstyle.LinePattern != LinePattern.None)
|
|
{
|
|
Rectangle bounds = litem.MarkerBounds;
|
|
|
|
int n = bounds.Height / 2;
|
|
|
|
int lineWidth = Math.Min(tstyle.LineWidth, bounds.Height);
|
|
|
|
using (Pen pen = new Pen(GetLegendItemColor(), lineWidth))
|
|
{
|
|
if (tstyle.LinePattern != LinePattern.NotSet)
|
|
pen.DashStyle = (DashStyle)tstyle.LinePattern;
|
|
|
|
g.DrawLine(pen,
|
|
new Point(bounds.X, bounds.Y + n),
|
|
new Point(bounds.Right - 1, bounds.Y + n));
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetLegendItemTextEx
|
|
|
|
protected override string GetLegendItemTextEx()
|
|
{
|
|
return ("(TrendLine)");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Copy/CopyTo
|
|
|
|
public override ChartVisualElement Copy()
|
|
{
|
|
TrendLine copy = new TrendLine();
|
|
|
|
CopyTo(copy);
|
|
|
|
return (copy);
|
|
}
|
|
|
|
public override void CopyTo(ChartVisualElement copy)
|
|
{
|
|
TrendLine c = copy as TrendLine;
|
|
|
|
if (c != null)
|
|
{
|
|
base.CopyTo(c);
|
|
|
|
c.TrendLineVisualStyle =
|
|
(_TrendLineVisualStyle != null) ? TrendLineVisualStyle.Copy() : null;
|
|
|
|
c.ValueX1 = ValueX1;
|
|
c.ValueX2 = ValueX2;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSerialData
|
|
|
|
internal override SerialElementCollection GetSerialData(string serialName)
|
|
{
|
|
SerialElementCollection sec = new SerialElementCollection();
|
|
|
|
if (serialName != null)
|
|
{
|
|
if (serialName.Equals("") == true)
|
|
serialName = "TrendLine";
|
|
|
|
sec.AddStartElement(serialName);
|
|
}
|
|
|
|
if (_TrendLineVisualStyle != null && _TrendLineVisualStyle.IsEmpty == false)
|
|
sec.AddElement(_TrendLineVisualStyle.GetSerialData("TrendLineVisualStyle"));
|
|
|
|
sec.AddDataValue("ValueX1", ValueX1, null);
|
|
sec.AddDataValue("ValueX2", ValueX2, null);
|
|
|
|
sec.AddElement(base.GetSerialData(null));
|
|
|
|
if (serialName != null)
|
|
sec.AddEndElement(serialName);
|
|
|
|
return (sec);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PutSerialData
|
|
|
|
#region ProcessValue
|
|
|
|
internal override void ProcessValue(SerialElement se)
|
|
{
|
|
switch (se.Name)
|
|
{
|
|
case "ValueX1":
|
|
ValueX1 = se.DataValue;
|
|
break;
|
|
|
|
case "ValueX2":
|
|
ValueX2 = se.DataValue;
|
|
break;
|
|
|
|
default:
|
|
base.ProcessValue(se);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessCollection
|
|
|
|
internal override void ProcessCollection(SerialElement se)
|
|
{
|
|
SerialElementCollection sec = se.Sec;
|
|
|
|
switch (se.Name)
|
|
{
|
|
case "TrendLineVisualStyle":
|
|
sec.PutSerialData(TrendLineVisualStyle);
|
|
break;
|
|
|
|
default:
|
|
base.ProcessCollection(se);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region IDisposable
|
|
|
|
public override void Dispose()
|
|
{
|
|
TrendLineVisualStyle = null;
|
|
|
|
base.Dispose();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#endregion
|
|
|
|
public abstract class ChartIndicator : ChartVisualElement, ILegendItem
|
|
{
|
|
#region Private variables
|
|
|
|
private States _States;
|
|
|
|
private string _LegendText;
|
|
private ChartLegendItem _LegendItem;
|
|
private ChartLegendItemVisualStyles _ChartLegendItemVisualStyles;
|
|
|
|
private int _ValueYIndex;
|
|
|
|
#endregion
|
|
|
|
public ChartIndicator()
|
|
{
|
|
InitDefaultStates();
|
|
}
|
|
|
|
#region InitDefaultStates
|
|
|
|
private void InitDefaultStates()
|
|
{
|
|
SetState(States.CheckedInLegend, true);
|
|
SetState(States.ShowInLegend, true);
|
|
SetState(States.ShowInParentLegend, true);
|
|
SetState(States.ShowCheckBoxInLegend, true);
|
|
SetState(States.ShowMarkerInLegend, true);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region DisplayOnTop
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether Indicator is displayed on top of chart data.
|
|
/// </summary>
|
|
[DefaultValue(false), Category("Appearance")]
|
|
[Description("Indicates whether Indicator is displayed on top of chart data.")]
|
|
public bool DisplayOnTop
|
|
{
|
|
get { return (TestState(States.DisplayOnTop)); }
|
|
|
|
set
|
|
{
|
|
if (value != DisplayOnTop)
|
|
{
|
|
SetState(States.DisplayOnTop, value);
|
|
|
|
OnPropertyChangedEx("DisplayOnTop", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IndicatorType
|
|
|
|
/// <summary>
|
|
/// Indicator type
|
|
/// </summary>
|
|
public virtual ChartIndicatorType IndicatorType
|
|
{
|
|
get { throw new NotImplementedException(); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Intercept
|
|
|
|
/// <summary>
|
|
/// Gets the Indicator Line's Intercept (ie. the 'b' portion of 'y = mx + b').
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public double Intercept
|
|
{
|
|
get
|
|
{
|
|
ChartSeries series = Parent as ChartSeries;
|
|
|
|
if (series == null)
|
|
throw new Exception("Indicator Line not associated with a ChartSeries.");
|
|
|
|
ChartXy chartXy = series.Parent as ChartXy;
|
|
|
|
if (chartXy == null)
|
|
throw new Exception("Indicator Line not associated with a ChartXy.");
|
|
|
|
SortedSeriesPoints ssp = series.GetSortedSeriesPoints(chartXy);
|
|
|
|
ssp.SlopeIndex = ValueYIndex;
|
|
|
|
return (ssp.Intercept);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsDisplayed
|
|
|
|
///<summary>
|
|
/// Gets whether the Indicator is displayed.
|
|
///</summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public bool IsDisplayed
|
|
{
|
|
get
|
|
{
|
|
return ((Visible == true) &&
|
|
(ShowCheckBoxInLegend == false || CheckedInLegend == true));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Slope
|
|
|
|
/// <summary>
|
|
/// Gets the Indicator Line's Slope (ie. the 'm' portion of 'y = mx + b').
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public double Slope
|
|
{
|
|
get
|
|
{
|
|
ChartSeries series = Parent as ChartSeries;
|
|
|
|
if (series == null)
|
|
throw new Exception("Indicator Line not associated with a ChartSeries.");
|
|
|
|
ChartXy chartXy = series.Parent as ChartXy;
|
|
|
|
if (chartXy == null)
|
|
throw new Exception("Indicator Line not associated with a ChartXy.");
|
|
|
|
SortedSeriesPoints ssp = series.GetSortedSeriesPoints(chartXy);
|
|
|
|
ssp.SlopeIndex = ValueYIndex;
|
|
|
|
return (ssp.Slope);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ValueYIndex
|
|
|
|
/// <summary>
|
|
/// Gets or sets the ValueY index to use for the slope/intercept.
|
|
/// </summary>
|
|
[DefaultValue(0), Category("Appearance")]
|
|
[Description("Indicates the ValueY index to use for the slope/intercept.")]
|
|
public int ValueYIndex
|
|
{
|
|
get { return (_ValueYIndex); }
|
|
|
|
set
|
|
{
|
|
if (value != _ValueYIndex)
|
|
{
|
|
_ValueYIndex = value;
|
|
|
|
OnPropertyChangedEx("ValueYIndex", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region ArrangeOverride
|
|
|
|
protected override void ArrangeOverride(ChartLayoutInfo layoutInfo)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MeasureOverride
|
|
|
|
protected override void MeasureOverride(ChartLayoutInfo layoutInfo)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderOverride
|
|
|
|
protected override void RenderOverride(ChartRenderInfo renderInfo)
|
|
{
|
|
}
|
|
|
|
#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();
|
|
|
|
StyleVisualChangeHandler(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 Line is checked in the Legend.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether the Line 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.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ShowCheckBoxInLegend
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether a checkbox for the Line is shown in the Legend.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether a checkbox for the Line 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 Line is shown in the Legend.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether theLine 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 Line is shown in parent Legend(s).
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether the 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 Line Marker is shown in the Legend.
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether the Line 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>
|
|
[Description("Indicates the item's parent LegendItem.")]
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public ChartLegendItem LegendItem
|
|
{
|
|
get { return (_LegendItem); }
|
|
|
|
internal set
|
|
{
|
|
if (_LegendItem != null)
|
|
_LegendItem.Dispose();
|
|
|
|
_LegendItem = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region LegendText
|
|
|
|
///<summary>
|
|
/// Gets or sets the text to display in the legend.
|
|
///</summary>
|
|
[DefaultValue(null), Category("DataLabel")]
|
|
[Description("Indicates the text to display in the legend.")]
|
|
public string LegendText
|
|
{
|
|
get { return (_LegendText); }
|
|
|
|
set
|
|
{
|
|
if (value != _LegendText)
|
|
{
|
|
_LegendText = value;
|
|
|
|
OnPropertyChangedEx("LegendText", Style.VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetLegendItem
|
|
|
|
public ChartLegendItem GetLegendItem()
|
|
{
|
|
LegendItem = null;
|
|
|
|
if (ShowInLegend == true)
|
|
{
|
|
LegendItem = new ChartLegendItem();
|
|
|
|
if (CheckedInLegend == true)
|
|
_LegendItem.CheckState = CheckState.Checked;
|
|
|
|
_LegendItem.Name = Name;
|
|
_LegendItem.ItemText = LegendText;
|
|
|
|
if (string.IsNullOrEmpty(Name) == true &&
|
|
string.IsNullOrEmpty(_LegendItem.ItemText) == true)
|
|
{
|
|
_LegendItem.ItemText = GetLegendItemTextEx();
|
|
}
|
|
|
|
_LegendItem.ChartItems.Add(this);
|
|
}
|
|
|
|
return (_LegendItem);
|
|
}
|
|
|
|
protected virtual string GetLegendItemTextEx()
|
|
{
|
|
return ("(IndLine)");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetLegendItems
|
|
|
|
public List<ChartLegendItem> GetLegendItems()
|
|
{
|
|
List<ChartLegendItem> list = new List<ChartLegendItem>(1);
|
|
|
|
list.Add(GetLegendItem());
|
|
|
|
return (list);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetLegendItemColor
|
|
|
|
public Color GetLegendItemColor()
|
|
{
|
|
Color color = GetLegendItemColorEx();
|
|
|
|
if (color.IsEmpty == true)
|
|
{
|
|
ChartSeries series = Parent as ChartSeries;
|
|
|
|
if (series != null)
|
|
color = series.DefaultPaletteColor;
|
|
}
|
|
|
|
return (color);
|
|
}
|
|
|
|
protected virtual Color GetLegendItemColorEx()
|
|
{
|
|
return (Color.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderLegendItemMarker
|
|
|
|
public void RenderLegendItemMarker(Graphics g,
|
|
ChartLegendItem litem, ChartLegendItemVisualStyle style)
|
|
{
|
|
RenderLegendItemMarkerEx(g, litem, style);
|
|
}
|
|
|
|
protected virtual void RenderLegendItemMarkerEx(Graphics g,
|
|
ChartLegendItem litem, ChartLegendItemVisualStyle style)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region CopyTo
|
|
|
|
public override void CopyTo(ChartVisualElement copy)
|
|
{
|
|
ChartIndicator c = copy as ChartIndicator;
|
|
|
|
if (c != null)
|
|
{
|
|
base.CopyTo(c);
|
|
|
|
c.ChartLegendItemVisualStyles =
|
|
(_ChartLegendItemVisualStyles != null) ? ChartLegendItemVisualStyles.Copy() : null;
|
|
|
|
c.CheckedInLegend = CheckedInLegend;
|
|
c.LegendText = LegendText;
|
|
c.ShowCheckBoxInLegend = ShowCheckBoxInLegend;
|
|
c.ShowInLegend = ShowInLegend;
|
|
c.ShowInParentLegend = ShowInParentLegend;
|
|
c.ShowMarkerInLegend = ShowMarkerInLegend;
|
|
c.DisplayOnTop = DisplayOnTop;
|
|
c.ValueYIndex = _ValueYIndex;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSerialData
|
|
|
|
internal override SerialElementCollection GetSerialData(string serialName)
|
|
{
|
|
SerialElementCollection sec = new SerialElementCollection();
|
|
|
|
if (serialName != null)
|
|
{
|
|
if (serialName.Equals("") == true)
|
|
serialName = "ChartIndicator";
|
|
|
|
sec.AddStartElement(serialName);
|
|
}
|
|
|
|
if (_ChartLegendItemVisualStyles != null)
|
|
sec.AddElement(_ChartLegendItemVisualStyles.GetSerialData("ChartLegendItemVisualStyles"));
|
|
|
|
sec.AddValue("DisplayOnTop", DisplayOnTop, false);
|
|
|
|
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.AddValue("ValueYIndex", _ValueYIndex, 0);
|
|
|
|
sec.AddElement(base.GetSerialData(null));
|
|
|
|
if (serialName != null)
|
|
sec.AddEndElement(serialName);
|
|
|
|
return (sec);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PutSerialData
|
|
|
|
#region ProcessValue
|
|
|
|
internal override void ProcessValue(SerialElement se)
|
|
{
|
|
switch (se.Name)
|
|
{
|
|
case "CheckedInLegend":
|
|
CheckedInLegend = bool.Parse(se.StringValue);
|
|
break;
|
|
|
|
case "DisplayOnTop":
|
|
DisplayOnTop = 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;
|
|
|
|
case "ValueYIndex":
|
|
ValueYIndex = int.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 "ChartLegendItemVisualStyles":
|
|
sec.PutSerialData(ChartLegendItemVisualStyles);
|
|
break;
|
|
|
|
default:
|
|
base.ProcessCollection(se);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region States
|
|
|
|
[Flags]
|
|
private enum States : uint
|
|
{
|
|
CheckedInLegend = (1U << 1),
|
|
ShowCheckBoxInLegend = (1U << 2),
|
|
ShowInLegend = (1U << 3),
|
|
ShowInParentLegend = (1U << 4),
|
|
ShowMarkerInLegend = (1U << 5),
|
|
DisplayOnTop = (1U << 6),
|
|
}
|
|
|
|
#region TestState
|
|
|
|
private bool TestState(States state)
|
|
{
|
|
return ((_States & state) == state);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SetState
|
|
|
|
private void SetState(States state, bool value)
|
|
{
|
|
if (value == true)
|
|
_States |= state;
|
|
else
|
|
_States &= ~state;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|
|
|
|
#region enums
|
|
|
|
#region ChartIndicatorType
|
|
|
|
public enum ChartIndicatorType
|
|
{
|
|
TrendLine,
|
|
RegressionLine,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|