1348 lines
44 KiB
C#
1348 lines
44 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
|
|
namespace DevComponents.DotNetBar.Charts.Style
|
|
{
|
|
/// <summary>
|
|
/// Defines set of default visual styles that are defined on the container control.
|
|
/// </summary>
|
|
[TypeConverter(typeof(VisualStylesConverter))]
|
|
public class DefaultVisualStyles : IProcessSerialElement, INotifyPropertyChanged, IDisposable
|
|
{
|
|
#region Private variables
|
|
|
|
// Multi state style definitions
|
|
|
|
private ContainerVisualStyles _ContainerVisualStyles;
|
|
|
|
private ChartLegendVisualStyles _ChartLegendVisualStyles;
|
|
private ChartLegendItemVisualStyles _ChartLegendItemVisualStyles;
|
|
|
|
private ChartSliceVisualStyles _SliceVisualStyles;
|
|
private ChartSliceVisualStyles _OtherSliceVisualStyles;
|
|
|
|
private ScrollBarVisualStyles _HScrollBarVisualStyles;
|
|
private ScrollBarVisualStyles _VScrollBarVisualStyles;
|
|
|
|
// Single state style definitions
|
|
|
|
private ChartAxisVisualStyle _ChartXAxisVisualStyle;
|
|
private ChartAxisVisualStyle _ChartYAxisVisualStyle;
|
|
|
|
private ChartPanelVisualStyle _ChartPanelVisualStyle;
|
|
private ChartSeriesVisualStyle _ChartSeriesVisualStyle;
|
|
private ChartTickmarkVisualStyle _ChartTickmarkVisualStyle;
|
|
private ChartTitleVisualStyle _ChartTitleVisualStyle;
|
|
private ChartXyVisualStyle _ChartXyVisualStyle;
|
|
private DataLabelVisualStyle _DataLabelVisualStyle;
|
|
|
|
private CrosshairValueVisualStyle _CrosshairLabelVisualStyle;
|
|
private CrosshairVisualStyle _CrosshairVisualStyle;
|
|
|
|
private DividerLineVisualStyle _DividerLineVisualStyle;
|
|
private PieGridLineVisualStyle _GridLineVisualStyle;
|
|
private PieChartVisualStyle _PieChartVisualStyle;
|
|
|
|
private ReferenceLineVisualStyle _ReferenceLineVisualStyle;
|
|
private RegressionLineVisualStyle _RegressionLineVisualStyle;
|
|
private TrendLineVisualStyle _TrendLineVisualStyle;
|
|
|
|
private TickmarkLabelVisualStyle _TickmarkLabelVisualStyle;
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region ChartLegendItemVisualStyles
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual styles to be used for ChartLegendItem elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual styles to be used for ChartLegendI tem elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartLegendItemVisualStyles ChartLegendItemVisualStyles
|
|
{
|
|
get
|
|
{
|
|
if (_ChartLegendItemVisualStyles == null)
|
|
{
|
|
_ChartLegendItemVisualStyles = new ChartLegendItemVisualStyles();
|
|
|
|
StyleChangeHandler(null, _ChartLegendItemVisualStyles);
|
|
}
|
|
|
|
return (_ChartLegendItemVisualStyles);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value != _ChartLegendItemVisualStyles)
|
|
{
|
|
ChartLegendItemVisualStyles oldValue = _ChartLegendItemVisualStyles;
|
|
_ChartLegendItemVisualStyles = value;
|
|
|
|
OnStyleChanged("ChartLegendVisualStyles", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ChartLegendVisualStyles
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual styles to be used for ChartLegend elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual styles to be used for ChartLegend elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartLegendVisualStyles ChartLegendVisualStyles
|
|
{
|
|
get
|
|
{
|
|
if (_ChartLegendVisualStyles == null)
|
|
{
|
|
_ChartLegendVisualStyles = new ChartLegendVisualStyles();
|
|
|
|
StyleChangeHandler(null, _ChartLegendVisualStyles);
|
|
}
|
|
|
|
return (_ChartLegendVisualStyles);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value != _ChartLegendVisualStyles)
|
|
{
|
|
ChartLegendVisualStyles oldValue = _ChartLegendVisualStyles;
|
|
_ChartLegendVisualStyles = value;
|
|
|
|
OnStyleChanged("ChartLegendVisualStyles", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ChartPanelVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for ChartPanel elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for ChartPanel elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartPanelVisualStyle ChartPanelVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ChartPanelVisualStyle == null)
|
|
{
|
|
_ChartPanelVisualStyle = new ChartPanelVisualStyle();
|
|
|
|
StyleChangeHandler(null, _ChartPanelVisualStyle);
|
|
}
|
|
|
|
return (_ChartPanelVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ChartPanelVisualStyle != value)
|
|
{
|
|
ChartPanelVisualStyle oldValue = _ChartPanelVisualStyle;
|
|
_ChartPanelVisualStyle = value;
|
|
|
|
OnStyleChanged("ChartPanelVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ChartSeriesVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for ChartSeries elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for ChartSeries elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartSeriesVisualStyle ChartSeriesVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ChartSeriesVisualStyle == null)
|
|
{
|
|
_ChartSeriesVisualStyle = new ChartSeriesVisualStyle();
|
|
|
|
StyleChangeHandler(null, _ChartSeriesVisualStyle);
|
|
}
|
|
|
|
return (_ChartSeriesVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value != _ChartSeriesVisualStyle)
|
|
{
|
|
ChartSeriesVisualStyle oldValue = _ChartSeriesVisualStyle;
|
|
_ChartSeriesVisualStyle = value;
|
|
|
|
OnStyleChanged("ChartSeriesVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ChartTickmarkVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for chart Tickmark elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for chart Tickmark elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartTickmarkVisualStyle ChartTickmarkVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ChartTickmarkVisualStyle == null)
|
|
{
|
|
_ChartTickmarkVisualStyle = new ChartTickmarkVisualStyle();
|
|
|
|
StyleChangeHandler(null, _ChartTickmarkVisualStyle);
|
|
}
|
|
|
|
return (_ChartTickmarkVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ChartTickmarkVisualStyle != value)
|
|
{
|
|
ChartTickmarkVisualStyle oldValue = _ChartTickmarkVisualStyle;
|
|
_ChartTickmarkVisualStyle = value;
|
|
|
|
OnStyleChanged("ChartTickmarkVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ChartTitleVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for ChartTitle elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for ChartTitle elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartTitleVisualStyle ChartTitleVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ChartTitleVisualStyle == null)
|
|
{
|
|
_ChartTitleVisualStyle = new ChartTitleVisualStyle();
|
|
|
|
StyleChangeHandler(null, _ChartTitleVisualStyle);
|
|
}
|
|
|
|
return (_ChartTitleVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ChartTitleVisualStyle != value)
|
|
{
|
|
ChartTitleVisualStyle oldValue = _ChartTitleVisualStyle;
|
|
_ChartTitleVisualStyle = value;
|
|
|
|
OnStyleChanged("ChartTitleVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ChartXAxisVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for X Axis elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for X Axis elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartAxisVisualStyle ChartXAxisVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ChartXAxisVisualStyle == null)
|
|
{
|
|
_ChartXAxisVisualStyle = new ChartAxisVisualStyle();
|
|
|
|
StyleChangeHandler(null, _ChartXAxisVisualStyle);
|
|
}
|
|
|
|
return (_ChartXAxisVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ChartXAxisVisualStyle != value)
|
|
{
|
|
ChartAxisVisualStyle oldValue = _ChartXAxisVisualStyle;
|
|
_ChartXAxisVisualStyle = value;
|
|
|
|
OnStyleChanged("ChartXAxisVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ChartXyVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for XyChart elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for XyChart elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartXyVisualStyle ChartXyVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ChartXyVisualStyle == null)
|
|
{
|
|
_ChartXyVisualStyle = new ChartXyVisualStyle();
|
|
|
|
StyleChangeHandler(null, _ChartXyVisualStyle);
|
|
}
|
|
|
|
return (_ChartXyVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ChartXyVisualStyle != value)
|
|
{
|
|
ChartXyVisualStyle oldValue = _ChartXyVisualStyle;
|
|
_ChartXyVisualStyle = value;
|
|
|
|
OnStyleChanged("ChartXyVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ChartYAxisVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for Y Axis elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for Y Axis elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartAxisVisualStyle ChartYAxisVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ChartYAxisVisualStyle == null)
|
|
{
|
|
_ChartYAxisVisualStyle = new ChartAxisVisualStyle();
|
|
|
|
StyleChangeHandler(null, _ChartYAxisVisualStyle);
|
|
}
|
|
|
|
return (_ChartYAxisVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ChartYAxisVisualStyle != value)
|
|
{
|
|
ChartAxisVisualStyle oldValue = _ChartYAxisVisualStyle;
|
|
_ChartYAxisVisualStyle = value;
|
|
|
|
OnStyleChanged("ChartYAxisVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ContainerVisualStyles
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual stylse to be used for Chart Container elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual styles to be used for XyChart elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ContainerVisualStyles ContainerVisualStyles
|
|
{
|
|
get
|
|
{
|
|
if (_ContainerVisualStyles == null)
|
|
{
|
|
_ContainerVisualStyles = new ContainerVisualStyles();
|
|
|
|
StyleChangeHandler(null, _ContainerVisualStyles);
|
|
}
|
|
|
|
return (_ContainerVisualStyles);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ContainerVisualStyles != value)
|
|
{
|
|
ContainerVisualStyles oldValue = _ContainerVisualStyles;
|
|
_ContainerVisualStyles = value;
|
|
|
|
OnStyleChanged("ContainerVisualStyles", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CrosshairLabelVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for Crosshair label elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for Crosshair label elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public CrosshairValueVisualStyle CrosshairLabelVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_CrosshairLabelVisualStyle == null)
|
|
{
|
|
_CrosshairLabelVisualStyle = new CrosshairValueVisualStyle();
|
|
|
|
StyleChangeHandler(null, _CrosshairLabelVisualStyle);
|
|
}
|
|
|
|
return (_CrosshairLabelVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_CrosshairLabelVisualStyle != value)
|
|
{
|
|
CrosshairValueVisualStyle oldValue = _CrosshairLabelVisualStyle;
|
|
_CrosshairLabelVisualStyle = value;
|
|
|
|
OnStyleChanged("CrosshairLabelVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CrosshairVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for Crosshair elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for Crosshair elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public CrosshairVisualStyle CrosshairVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_CrosshairVisualStyle == null)
|
|
{
|
|
_CrosshairVisualStyle = new CrosshairVisualStyle();
|
|
|
|
StyleChangeHandler(null, _CrosshairVisualStyle);
|
|
}
|
|
|
|
return (_CrosshairVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_CrosshairVisualStyle != value)
|
|
{
|
|
CrosshairVisualStyle oldValue = _CrosshairVisualStyle;
|
|
_CrosshairVisualStyle = value;
|
|
|
|
OnStyleChanged("CrosshairVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DataLabelVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for DataLabel elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for DataLabel elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public DataLabelVisualStyle DataLabelVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_DataLabelVisualStyle == null)
|
|
{
|
|
_DataLabelVisualStyle = new DataLabelVisualStyle();
|
|
|
|
StyleChangeHandler(null, _DataLabelVisualStyle);
|
|
}
|
|
|
|
return (_DataLabelVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value != _DataLabelVisualStyle)
|
|
{
|
|
DataLabelVisualStyle oldValue = _DataLabelVisualStyle;
|
|
_DataLabelVisualStyle = value;
|
|
|
|
OnStyleChanged("DataLabelVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DividerLineVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for DividerLine elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for DividerLine elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public DividerLineVisualStyle DividerLineVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_DividerLineVisualStyle == null)
|
|
{
|
|
_DividerLineVisualStyle = new DividerLineVisualStyle();
|
|
|
|
StyleChangeHandler(null, _DividerLineVisualStyle);
|
|
}
|
|
|
|
return (_DividerLineVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_DividerLineVisualStyle != value)
|
|
{
|
|
DividerLineVisualStyle oldValue = _DividerLineVisualStyle;
|
|
_DividerLineVisualStyle = value;
|
|
|
|
OnStyleChanged("DividerLineVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GridLineVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for GridLine elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for GridLine elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public PieGridLineVisualStyle GridLineVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_GridLineVisualStyle == null)
|
|
{
|
|
_GridLineVisualStyle = new PieGridLineVisualStyle();
|
|
|
|
StyleChangeHandler(null, _GridLineVisualStyle);
|
|
}
|
|
|
|
return (_GridLineVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_GridLineVisualStyle != value)
|
|
{
|
|
PieGridLineVisualStyle oldValue = _GridLineVisualStyle;
|
|
_GridLineVisualStyle = value;
|
|
|
|
OnStyleChanged("GridLinesVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region HScrollBarVisualStyles
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual styles to be used for Horizontal ScrollBar elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual styles to be used for Horizontal ScrollBar elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ScrollBarVisualStyles HScrollBarVisualStyles
|
|
{
|
|
get
|
|
{
|
|
if (_HScrollBarVisualStyles == null)
|
|
{
|
|
_HScrollBarVisualStyles = new ScrollBarVisualStyles();
|
|
|
|
StyleChangeHandler(null, _HScrollBarVisualStyles);
|
|
}
|
|
|
|
return (_HScrollBarVisualStyles);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_HScrollBarVisualStyles != value)
|
|
{
|
|
ScrollBarVisualStyles oldValue = _HScrollBarVisualStyles;
|
|
_HScrollBarVisualStyles = value;
|
|
|
|
OnStyleChanged("HScrollBarVisualStyles", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#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 PieChartVisualStyles
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for PieChart elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for PieChart elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public PieChartVisualStyle PieChartVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_PieChartVisualStyle == null)
|
|
{
|
|
_PieChartVisualStyle = new PieChartVisualStyle();
|
|
|
|
StyleChangeHandler(null, _PieChartVisualStyle);
|
|
}
|
|
|
|
return (_PieChartVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_PieChartVisualStyle != value)
|
|
{
|
|
PieChartVisualStyle oldValue = _PieChartVisualStyle;
|
|
_PieChartVisualStyle = value;
|
|
|
|
OnStyleChanged("PieChartVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ReferenceLineVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for ReferenceLine elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for ReferenceLine elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ReferenceLineVisualStyle ReferenceLineVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ReferenceLineVisualStyle == null)
|
|
{
|
|
_ReferenceLineVisualStyle = new ReferenceLineVisualStyle();
|
|
|
|
StyleChangeHandler(null, _ReferenceLineVisualStyle);
|
|
}
|
|
|
|
return (_ReferenceLineVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ReferenceLineVisualStyle != value)
|
|
{
|
|
ReferenceLineVisualStyle oldValue = _ReferenceLineVisualStyle;
|
|
_ReferenceLineVisualStyle = value;
|
|
|
|
OnStyleChanged("ReferenceLineVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RegressionLineVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for RegressionIndicator elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for RegressionIndicator elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public RegressionLineVisualStyle RegressionLineVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_RegressionLineVisualStyle == null)
|
|
{
|
|
_RegressionLineVisualStyle = new RegressionLineVisualStyle();
|
|
|
|
StyleChangeHandler(null, _RegressionLineVisualStyle);
|
|
}
|
|
|
|
return (_RegressionLineVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_RegressionLineVisualStyle != value)
|
|
{
|
|
RegressionLineVisualStyle oldValue = _RegressionLineVisualStyle;
|
|
_RegressionLineVisualStyle = value;
|
|
|
|
OnStyleChanged("RegressionLineVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SliceVisualStyles
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for Pie Slice elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for Pie Slice elements")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartSliceVisualStyles SliceVisualStyles
|
|
{
|
|
get
|
|
{
|
|
if (_SliceVisualStyles == null)
|
|
{
|
|
_SliceVisualStyles = new ChartSliceVisualStyles();
|
|
|
|
StyleChangeHandler(null, _SliceVisualStyles);
|
|
}
|
|
|
|
return (_SliceVisualStyles);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value != _SliceVisualStyles)
|
|
{
|
|
ChartSliceVisualStyles oldValue = _SliceVisualStyles;
|
|
_SliceVisualStyles = value;
|
|
|
|
OnStyleChanged("SliceVisualStyles", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TickmarkLabelVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual styles to be used for Axis Lable
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual styles to be used for Axis Lable ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public TickmarkLabelVisualStyle TickmarkLabelVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_TickmarkLabelVisualStyle == null)
|
|
{
|
|
_TickmarkLabelVisualStyle = new TickmarkLabelVisualStyle();
|
|
|
|
StyleChangeHandler(null, _TickmarkLabelVisualStyle);
|
|
}
|
|
|
|
return (_TickmarkLabelVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_TickmarkLabelVisualStyle != value)
|
|
{
|
|
TickmarkLabelVisualStyle oldValue = _TickmarkLabelVisualStyle;
|
|
_TickmarkLabelVisualStyle = value;
|
|
|
|
OnStyleChanged("TickmarkLabelVisualStyles", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TrendLineVisualStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style to be used for TrendLine elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual style to be used for TrendLine elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public TrendLineVisualStyle TrendLineVisualStyle
|
|
{
|
|
get
|
|
{
|
|
if (_TrendLineVisualStyle == null)
|
|
{
|
|
_TrendLineVisualStyle = new TrendLineVisualStyle();
|
|
|
|
StyleChangeHandler(null, _TrendLineVisualStyle);
|
|
}
|
|
|
|
return (_TrendLineVisualStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_TrendLineVisualStyle != value)
|
|
{
|
|
TrendLineVisualStyle oldValue = _TrendLineVisualStyle;
|
|
_TrendLineVisualStyle = value;
|
|
|
|
OnStyleChanged("TrendLineVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region VScrollBarVisualStyles
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual styles to be used for Vertical ScrollBar elements
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates visual styles to be used for Vertical ScrollBar elements ")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ScrollBarVisualStyles VScrollBarVisualStyles
|
|
{
|
|
get
|
|
{
|
|
if (_VScrollBarVisualStyles == null)
|
|
{
|
|
_VScrollBarVisualStyles = new ScrollBarVisualStyles();
|
|
|
|
StyleChangeHandler(null, _VScrollBarVisualStyles);
|
|
}
|
|
|
|
return (_VScrollBarVisualStyles);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_VScrollBarVisualStyles != value)
|
|
{
|
|
ScrollBarVisualStyles oldValue = _VScrollBarVisualStyles;
|
|
_VScrollBarVisualStyles = value;
|
|
|
|
OnStyleChanged("VScrollBarVisualStyles", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsEmpty
|
|
|
|
/// <summary>
|
|
/// Gets whether the style collection is logically Empty.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
[Description("Gets whether the style collection is logically Empty.")]
|
|
public bool IsEmpty
|
|
{
|
|
get
|
|
{
|
|
if (_ChartLegendItemVisualStyles != null && _ChartLegendItemVisualStyles.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ChartLegendVisualStyles != null && _ChartLegendVisualStyles.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ChartPanelVisualStyle != null && _ChartPanelVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_HScrollBarVisualStyles != null && _HScrollBarVisualStyles.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_VScrollBarVisualStyles != null && _VScrollBarVisualStyles.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ChartSeriesVisualStyle != null && _ChartSeriesVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ChartTickmarkVisualStyle != null && _ChartTickmarkVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ChartTitleVisualStyle != null && _ChartTitleVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ChartXAxisVisualStyle != null && _ChartXAxisVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ChartXyVisualStyle != null && _ChartXyVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ChartYAxisVisualStyle != null && _ChartYAxisVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ContainerVisualStyles != null && _ContainerVisualStyles.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_CrosshairLabelVisualStyle != null && _CrosshairLabelVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_CrosshairVisualStyle != null && _CrosshairVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_DataLabelVisualStyle != null && _DataLabelVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_DividerLineVisualStyle != null && _DividerLineVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_GridLineVisualStyle != null && _GridLineVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_ReferenceLineVisualStyle != null && _ReferenceLineVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_TickmarkLabelVisualStyle != null && _TickmarkLabelVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
if (_TrendLineVisualStyle != null && _TrendLineVisualStyle.IsEmpty == false)
|
|
return (false);
|
|
|
|
return (true);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region OnStyleChanged
|
|
|
|
private void OnStyleChanged(string property,
|
|
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
|
|
{
|
|
StyleChangeHandler(oldValue, newValue);
|
|
|
|
OnPropertyChanged(new VisualPropertyChangedEventArgs(property));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region StyleChangeHandler
|
|
|
|
private void StyleChangeHandler(
|
|
INotifyPropertyChanged oldValue, INotifyPropertyChanged newValue)
|
|
{
|
|
if (oldValue != null)
|
|
oldValue.PropertyChanged -= StyleChanged;
|
|
|
|
if (newValue != null)
|
|
newValue.PropertyChanged += StyleChanged;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#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 virtual void StyleChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
OnPropertyChanged(e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Copy/CopyTo
|
|
|
|
public DefaultVisualStyles Copy()
|
|
{
|
|
DefaultVisualStyles copy = new DefaultVisualStyles();
|
|
|
|
CopyTo(copy);
|
|
|
|
return (copy);
|
|
}
|
|
|
|
public void CopyTo(DefaultVisualStyles c)
|
|
{
|
|
for (int i = 0; i < ChartLegendItemVisualStyles.Styles.Length; i++)
|
|
{
|
|
if (ChartLegendItemVisualStyles.Styles[i] != null)
|
|
c.ChartLegendItemVisualStyles.Styles[i] = ChartLegendItemVisualStyles.Styles[i].Copy();
|
|
}
|
|
|
|
for (int i = 0; i < ChartLegendVisualStyles.Styles.Length; i++)
|
|
{
|
|
if (ChartLegendVisualStyles.Styles[i] != null)
|
|
c.ChartLegendVisualStyles.Styles[i] = ChartLegendVisualStyles.Styles[i].Copy();
|
|
}
|
|
|
|
ChartPanelVisualStyle.CopyTo(c.ChartPanelVisualStyle);
|
|
ChartSeriesVisualStyle.CopyTo(c.ChartSeriesVisualStyle);
|
|
ChartTickmarkVisualStyle.CopyTo(c.ChartTickmarkVisualStyle);
|
|
ChartTitleVisualStyle.CopyTo(c.ChartTitleVisualStyle);
|
|
ChartXAxisVisualStyle.CopyTo(c.ChartXAxisVisualStyle);
|
|
ChartXyVisualStyle.CopyTo(c.ChartXyVisualStyle);
|
|
ChartYAxisVisualStyle.CopyTo(c.ChartYAxisVisualStyle);
|
|
|
|
for (int i = 0; i < ContainerVisualStyles.Styles.Length; i++)
|
|
{
|
|
if (ContainerVisualStyles.Styles[i] != null)
|
|
c.ContainerVisualStyles.Styles[i] = ContainerVisualStyles.Styles[i].Copy();
|
|
}
|
|
|
|
CrosshairLabelVisualStyle.CopyTo(c.CrosshairLabelVisualStyle);
|
|
CrosshairVisualStyle.CopyTo(c.CrosshairVisualStyle);
|
|
DataLabelVisualStyle.CopyTo(c.DataLabelVisualStyle);
|
|
DividerLineVisualStyle.CopyTo(c.DividerLineVisualStyle);
|
|
GridLineVisualStyle.CopyTo(c.GridLineVisualStyle);
|
|
|
|
for (int i = 0; i < HScrollBarVisualStyles.Styles.Length; i++)
|
|
{
|
|
if (HScrollBarVisualStyles.Styles[i] != null)
|
|
c.HScrollBarVisualStyles.Styles[i] = HScrollBarVisualStyles.Styles[i].Copy();
|
|
}
|
|
|
|
for (int i = 0; i < OtherSliceVisualStyles.Styles.Length; i++)
|
|
{
|
|
if (OtherSliceVisualStyles.Styles[i] != null)
|
|
c.OtherSliceVisualStyles.Styles[i] = OtherSliceVisualStyles.Styles[i].Copy();
|
|
}
|
|
|
|
PieChartVisualStyle.CopyTo(c.PieChartVisualStyle);
|
|
ReferenceLineVisualStyle.CopyTo(c.ReferenceLineVisualStyle);
|
|
RegressionLineVisualStyle.CopyTo(c.RegressionLineVisualStyle);
|
|
|
|
for (int i = 0; i < SliceVisualStyles.Styles.Length; i++)
|
|
{
|
|
if (SliceVisualStyles.Styles[i] != null)
|
|
c.SliceVisualStyles.Styles[i] = SliceVisualStyles.Styles[i].Copy();
|
|
}
|
|
|
|
TickmarkLabelVisualStyle.CopyTo(c.TickmarkLabelVisualStyle);
|
|
TrendLineVisualStyle.CopyTo(c.TrendLineVisualStyle);
|
|
|
|
for (int i = 0; i < VScrollBarVisualStyles.Styles.Length; i++)
|
|
{
|
|
if (VScrollBarVisualStyles.Styles[i] != null)
|
|
c.VScrollBarVisualStyles.Styles[i] = VScrollBarVisualStyles.Styles[i].Copy();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSerialData
|
|
|
|
internal SerialElementCollection GetSerialData()
|
|
{
|
|
return (GetSerialData(true));
|
|
}
|
|
|
|
internal SerialElementCollection GetSerialData(bool root)
|
|
{
|
|
SerialElementCollection sec = new SerialElementCollection();
|
|
|
|
if (root == true)
|
|
sec.AddStartElement("DefaultVisualStyles");
|
|
|
|
if (_ChartLegendItemVisualStyles != null && _ChartLegendItemVisualStyles.IsEmpty == false)
|
|
sec.AddElement(_ChartLegendItemVisualStyles.GetSerialData("ChartLegendItemVisualStyles"));
|
|
|
|
if (_ChartLegendVisualStyles != null && _ChartLegendVisualStyles.IsEmpty == false)
|
|
sec.AddElement(_ChartLegendVisualStyles.GetSerialData("ChartLegendVisualStyles"));
|
|
|
|
sec.AddElement(_ChartPanelVisualStyle);
|
|
sec.AddElement(_ChartSeriesVisualStyle);
|
|
sec.AddElement(_ChartTickmarkVisualStyle);
|
|
sec.AddElement(_ChartTitleVisualStyle);
|
|
sec.AddElement(_ChartXAxisVisualStyle);
|
|
sec.AddElement(_ChartXyVisualStyle);
|
|
sec.AddElement(_ChartYAxisVisualStyle);
|
|
|
|
if (_ContainerVisualStyles != null && _ContainerVisualStyles.IsEmpty == false)
|
|
sec.AddElement(_ContainerVisualStyles.GetSerialData("ContainerVisualStyles"));
|
|
|
|
sec.AddElement(_CrosshairLabelVisualStyle);
|
|
sec.AddElement(_CrosshairVisualStyle);
|
|
sec.AddElement(_DataLabelVisualStyle);
|
|
sec.AddElement(_DividerLineVisualStyle);
|
|
sec.AddElement(_GridLineVisualStyle);
|
|
|
|
if (_HScrollBarVisualStyles != null && _HScrollBarVisualStyles.IsEmpty == false)
|
|
sec.AddElement(_HScrollBarVisualStyles.GetSerialData("HScrollBarVisualStyles"));
|
|
|
|
if (_OtherSliceVisualStyles != null && _OtherSliceVisualStyles.IsEmpty == false)
|
|
sec.AddElement(_OtherSliceVisualStyles.GetSerialData("OtherSliceVisualStyles"));
|
|
|
|
sec.AddElement(_PieChartVisualStyle);
|
|
sec.AddElement(_ReferenceLineVisualStyle);
|
|
sec.AddElement(_RegressionLineVisualStyle);
|
|
|
|
if (_SliceVisualStyles != null && _SliceVisualStyles.IsEmpty == false)
|
|
sec.AddElement(_SliceVisualStyles.GetSerialData("SliceVisualStyles"));
|
|
|
|
sec.AddElement(_TickmarkLabelVisualStyle);
|
|
sec.AddElement(_TrendLineVisualStyle);
|
|
|
|
if (_VScrollBarVisualStyles != null && _VScrollBarVisualStyles.IsEmpty == false)
|
|
sec.AddElement(_VScrollBarVisualStyles.GetSerialData("VScrollBarVisualStyles"));
|
|
|
|
if (root == true)
|
|
sec.AddEndElement("DefaultVisualStyles");
|
|
|
|
return (sec);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PutSerialData
|
|
|
|
#region ProcessValue
|
|
|
|
void IProcessSerialElement.ProcessValue(SerialElement se)
|
|
{
|
|
throw new Exception("Unknown Serial Value (" + se.Name + ")");
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessCollection
|
|
|
|
void IProcessSerialElement.ProcessCollection(SerialElement se)
|
|
{
|
|
switch (se.Name)
|
|
{
|
|
case "ChartLegendItemVisualStyles":
|
|
se.Sec.PutSerialData(ChartLegendItemVisualStyles);
|
|
break;
|
|
|
|
case "ChartLegendVisualStyles":
|
|
se.Sec.PutSerialData(ChartLegendVisualStyles);
|
|
break;
|
|
|
|
case "ChartPanelVisualStyle":
|
|
se.Sec.PutSerialData(ChartPanelVisualStyle);
|
|
break;
|
|
|
|
case "ChartSeriesVisualStyle":
|
|
se.Sec.PutSerialData(ChartSeriesVisualStyle);
|
|
break;
|
|
|
|
case "ChartTickmarkVisualStyle":
|
|
se.Sec.PutSerialData(ChartTickmarkVisualStyle);
|
|
break;
|
|
|
|
case "ChartTitleVisualStyle":
|
|
se.Sec.PutSerialData(ChartTitleVisualStyle);
|
|
break;
|
|
|
|
case "ChartXAxisVisualStyle":
|
|
se.Sec.PutSerialData(ChartXAxisVisualStyle);
|
|
break;
|
|
|
|
case "ChartXyVisualStyle":
|
|
se.Sec.PutSerialData(ChartXyVisualStyle);
|
|
break;
|
|
|
|
case "ChartYAxisVisualStyle":
|
|
se.Sec.PutSerialData(ChartYAxisVisualStyle);
|
|
break;
|
|
|
|
case "ContainerVisualStyles":
|
|
se.Sec.PutSerialData(ContainerVisualStyles);
|
|
break;
|
|
|
|
case "CrosshairLabelVisualStyle":
|
|
se.Sec.PutSerialData(CrosshairLabelVisualStyle);
|
|
break;
|
|
|
|
case "CrosshairVisualStyle":
|
|
se.Sec.PutSerialData(CrosshairVisualStyle);
|
|
break;
|
|
|
|
case "DataLabelVisualStyle":
|
|
se.Sec.PutSerialData(DataLabelVisualStyle);
|
|
break;
|
|
|
|
case "DividerLineVisualStyle":
|
|
se.Sec.PutSerialData(DividerLineVisualStyle);
|
|
break;
|
|
|
|
case "GridLineVisualStyle":
|
|
se.Sec.PutSerialData(GridLineVisualStyle);
|
|
break;
|
|
|
|
case "HScrollBarVisualStyles":
|
|
se.Sec.PutSerialData(HScrollBarVisualStyles);
|
|
break;
|
|
|
|
case "OtherSliceVisualStyles":
|
|
se.Sec.PutSerialData(OtherSliceVisualStyles);
|
|
break;
|
|
|
|
case "PieChartVisualStyle":
|
|
se.Sec.PutSerialData(PieChartVisualStyle);
|
|
break;
|
|
|
|
case "ReferenceLineVisualStyle":
|
|
se.Sec.PutSerialData(ReferenceLineVisualStyle);
|
|
break;
|
|
|
|
case "RegressionLineVisualStyle":
|
|
se.Sec.PutSerialData(RegressionLineVisualStyle);
|
|
break;
|
|
|
|
case "SliceVisualStyles":
|
|
se.Sec.PutSerialData(SliceVisualStyles);
|
|
break;
|
|
|
|
case "TickmarkLableVisualStyle":
|
|
se.Sec.PutSerialData(TickmarkLabelVisualStyle);
|
|
break;
|
|
|
|
case "TrendLineVisualStyle":
|
|
se.Sec.PutSerialData(TrendLineVisualStyle);
|
|
break;
|
|
|
|
case "VScrollBarVisualStyles":
|
|
se.Sec.PutSerialData(VScrollBarVisualStyles);
|
|
break;
|
|
|
|
default:
|
|
throw new Exception("Unknown Serial Collection (" + se.Name + ")");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region INotifyPropertyChanged Members
|
|
|
|
/// <summary>
|
|
/// Occurs when property value has changed.
|
|
/// </summary>
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
/// <summary>
|
|
/// Raises the PropertyChanged event.
|
|
/// </summary>
|
|
/// <param name="e">Event arguments</param>
|
|
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
|
|
{
|
|
PropertyChangedEventHandler eh = PropertyChanged;
|
|
|
|
if (eh != null)
|
|
eh(this, e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IDisposable
|
|
|
|
/// <summary>
|
|
/// Dispose
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
ChartPanelVisualStyle = null;
|
|
ChartTitleVisualStyle = null;
|
|
|
|
ChartXAxisVisualStyle = null;
|
|
ChartYAxisVisualStyle = null;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|