779 lines
22 KiB
C#
779 lines
22 KiB
C#
using System.ComponentModel;
|
|
using System.Drawing;
|
|
|
|
namespace DevComponents.DotNetBar.Charts.Style
|
|
{
|
|
/// <summary>
|
|
/// Represents the visual style of an element.
|
|
/// </summary>
|
|
[TypeConverter(typeof(VisualStylesConverter))]
|
|
public class CrosshairVisualStyle : BaseVisualStyle
|
|
{
|
|
#region Private variables
|
|
|
|
private Background _Background;
|
|
private Color _BorderColor = Color.Empty;
|
|
private LinePattern _BorderPattern = LinePattern.NotSet;
|
|
private int _BorderThickness;
|
|
|
|
private Color _TextColor = Color.Empty;
|
|
|
|
private ChartLineVisualStyle _ValueXLineStyle;
|
|
private ChartLineVisualStyle _ValueYLineStyle;
|
|
|
|
private Font _GroupHeaderFont;
|
|
private Color _GroupHeaderTextColor = Color.Empty;
|
|
|
|
private Font _Font;
|
|
private Padding _Margin;
|
|
private Padding _Padding;
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region Background
|
|
|
|
/// <summary>
|
|
/// Gets or sets the style background.
|
|
/// </summary>
|
|
[Description("Indicates the style background")]
|
|
public Background Background
|
|
{
|
|
get
|
|
{
|
|
if (_Background == null)
|
|
{
|
|
_Background = Background.Empty;
|
|
|
|
UpdateChangeHandler(null, _Background);
|
|
}
|
|
|
|
return (_Background);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_Background != value)
|
|
{
|
|
UpdateChangeHandler(_Background, value);
|
|
|
|
_Background = value;
|
|
|
|
OnPropertyChangedEx("Background", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private bool ShouldSerializeBackground()
|
|
{
|
|
return (_Background != null && _Background.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetBackground()
|
|
{
|
|
Background = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BorderColor
|
|
|
|
/// <summary>
|
|
/// Gets or sets the style border color.
|
|
/// </summary>
|
|
[Description("Indicates the style Border Color")]
|
|
public Color BorderColor
|
|
{
|
|
get { return (_BorderColor); }
|
|
|
|
set
|
|
{
|
|
if (_BorderColor != value)
|
|
{
|
|
_BorderColor = value;
|
|
|
|
OnPropertyChangedEx("BorderColor", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private bool ShouldSerializeBorderColor()
|
|
{
|
|
return (_BorderColor.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetBorderColor()
|
|
{
|
|
BorderColor = Color.Empty;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BorderPattern
|
|
|
|
/// <summary>
|
|
/// Gets or sets the style border pattern (Solid, Dash, ...)
|
|
/// </summary>
|
|
[DefaultValue(LinePattern.NotSet)]
|
|
[Description("Indicates the style border pattern (Solid, Dash, ...)")]
|
|
public LinePattern BorderPattern
|
|
{
|
|
get { return (_BorderPattern); }
|
|
|
|
set
|
|
{
|
|
if (_BorderPattern != value)
|
|
{
|
|
_BorderPattern = value;
|
|
|
|
OnPropertyChangedEx("BorderPattern", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BorderThickness
|
|
|
|
/// <summary>
|
|
/// Gets or sets the style border thickness.
|
|
/// </summary>
|
|
[DefaultValue(0)]
|
|
[Description("Indicates the style border thickness")]
|
|
public int BorderThickness
|
|
{
|
|
get { return (_BorderThickness); }
|
|
|
|
set
|
|
{
|
|
if (_BorderThickness != value)
|
|
{
|
|
_BorderThickness = value;
|
|
|
|
OnPropertyChangedEx("BorderThickness", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupHeaderFont
|
|
|
|
/// <summary>
|
|
/// Gets or sets the GroupHeader Font
|
|
/// </summary>
|
|
[DefaultValue(null)]
|
|
[Description("Indicates the GroupHeader Font")]
|
|
public Font GroupHeaderFont
|
|
{
|
|
get { return (_GroupHeaderFont); }
|
|
|
|
set
|
|
{
|
|
if (_GroupHeaderFont != value)
|
|
{
|
|
_GroupHeaderFont = value;
|
|
|
|
OnPropertyChangedEx("GroupHeaderFont", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupHeaderTextColor
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Color of the GroupHeaderText.
|
|
/// </summary>
|
|
[Category("Appearance")]
|
|
[Description("Indicates the Color of the GroupHeaderText.")]
|
|
public Color GroupHeaderTextColor
|
|
{
|
|
get { return (_GroupHeaderTextColor); }
|
|
|
|
set
|
|
{
|
|
if (_GroupHeaderTextColor != value)
|
|
{
|
|
_GroupHeaderTextColor = value;
|
|
|
|
OnPropertyChangedEx("GroupHeaderTextColor", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private bool ShouldSerializeGroupHeaderTextColor()
|
|
{
|
|
return (_GroupHeaderTextColor.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetGroupHeaderTextColor()
|
|
{
|
|
GroupHeaderTextColor = Color.Empty;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Font
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Font
|
|
/// </summary>
|
|
[DefaultValue(null)]
|
|
[Description("Indicates the Font")]
|
|
public Font Font
|
|
{
|
|
get { return (_Font); }
|
|
|
|
set
|
|
{
|
|
if (_Font != value)
|
|
{
|
|
_Font = value;
|
|
|
|
OnPropertyChangedEx("Font", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Margin
|
|
|
|
/// <summary>
|
|
/// Gets or sets the spacing between the border and outside content.
|
|
/// </summary>
|
|
[Description("Indicates the spacing between the border and outside content")]
|
|
public Padding Margin
|
|
{
|
|
get
|
|
{
|
|
if (_Margin == null)
|
|
{
|
|
_Margin = Padding.Empty;
|
|
|
|
UpdateChangeHandler(null, _Margin);
|
|
}
|
|
|
|
return (_Margin);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_Margin != value)
|
|
{
|
|
UpdateChangeHandler(_Margin, value);
|
|
|
|
_Margin = value;
|
|
|
|
OnPropertyChangedEx("Margin", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private bool ShouldSerializeMargin()
|
|
{
|
|
return (_Margin != null && _Margin.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetMargin()
|
|
{
|
|
Margin = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Padding
|
|
|
|
/// <summary>
|
|
/// Gets or sets spacing between the content and edges of the element.
|
|
/// </summary>
|
|
[Description("Indicates the spacing between the content and edges of the element")]
|
|
public Padding Padding
|
|
{
|
|
get
|
|
{
|
|
if (_Padding == null)
|
|
{
|
|
_Padding = Padding.Empty;
|
|
|
|
UpdateChangeHandler(null, _Padding);
|
|
}
|
|
|
|
return (_Padding);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_Padding != value)
|
|
{
|
|
UpdateChangeHandler(_Padding, value);
|
|
|
|
_Padding = value;
|
|
|
|
OnPropertyChangedEx("Padding", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private bool ShouldSerializePadding()
|
|
{
|
|
return (_Padding != null && _Padding.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetPadding()
|
|
{
|
|
Padding = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region TextColor
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Text color
|
|
/// </summary>
|
|
[Description("Indicates the Text color")]
|
|
public Color TextColor
|
|
{
|
|
get { return (_TextColor); }
|
|
|
|
set
|
|
{
|
|
if (_TextColor != value)
|
|
{
|
|
_TextColor = value;
|
|
|
|
OnPropertyChangedEx("TextColor", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private bool ShouldSerializeTextColor()
|
|
{
|
|
return (_TextColor.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetTextColor()
|
|
{
|
|
TextColor = Color.Empty;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ValueXLineStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style for the X Value Line.
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates the visual style for the X Value Line.")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartLineVisualStyle ValueXLineStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ValueXLineStyle == null)
|
|
{
|
|
_ValueXLineStyle = new ChartLineVisualStyle();
|
|
|
|
UpdateChangeHandler(null, _ValueXLineStyle);
|
|
}
|
|
|
|
return (_ValueXLineStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ValueXLineStyle != value)
|
|
{
|
|
ChartLineVisualStyle oldValue = _ValueXLineStyle;
|
|
|
|
_ValueXLineStyle = value;
|
|
|
|
OnStyleChanged("ValueXLineStyle", oldValue, value);
|
|
|
|
if (oldValue != null)
|
|
oldValue.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ValueYLineStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual style for the Y Value Line.
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates the visual style for the Y Value Line.")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartLineVisualStyle ValueYLineStyle
|
|
{
|
|
get
|
|
{
|
|
if (_ValueYLineStyle == null)
|
|
{
|
|
_ValueYLineStyle = new ChartLineVisualStyle();
|
|
|
|
UpdateChangeHandler(null, _ValueYLineStyle);
|
|
}
|
|
|
|
return (_ValueYLineStyle);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ValueYLineStyle != value)
|
|
{
|
|
ChartLineVisualStyle oldValue = _ValueYLineStyle;
|
|
|
|
_ValueYLineStyle = value;
|
|
|
|
OnStyleChanged("ValueYLineStyle", oldValue, value);
|
|
|
|
if (oldValue != null)
|
|
oldValue.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsEmpty
|
|
|
|
/// <summary>
|
|
/// Gets whether the style is logically Empty.
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
[Description("Gets whether the style is logically Empty.")]
|
|
public override bool IsEmpty
|
|
{
|
|
get
|
|
{
|
|
return ((_Background == null || _Background.IsEmpty == true) &&
|
|
(_BorderColor.IsEmpty == true) &&
|
|
(_BorderPattern == LinePattern.NotSet) &&
|
|
(_BorderThickness <= 0) &&
|
|
(_GroupHeaderFont == null) &&
|
|
(_Font == null) &&
|
|
(_GroupHeaderTextColor.IsEmpty == true) &&
|
|
(_Margin == null || _Margin.IsEmpty == true) &&
|
|
(_Padding == null || _Padding.IsEmpty == true) &&
|
|
(_TextColor.IsEmpty == true) &&
|
|
(_ValueXLineStyle == null || _ValueXLineStyle.IsEmpty) &&
|
|
(_ValueYLineStyle == null || _ValueYLineStyle.IsEmpty) &&
|
|
(base.IsEmpty == true));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region ApplyStyle
|
|
|
|
/// <summary>
|
|
/// Applies the style to instance of this style.
|
|
/// </summary>
|
|
/// <param name="style">Style to apply.</param>
|
|
public void ApplyStyle(CrosshairVisualStyle style)
|
|
{
|
|
if (style != null)
|
|
{
|
|
base.ApplyStyle(style);
|
|
|
|
if (style._Background != null && style._Background.IsEmpty == false)
|
|
Background = style._Background.Copy();
|
|
|
|
if (style._BorderColor.IsEmpty == false)
|
|
BorderColor = style._BorderColor;
|
|
|
|
if (style._BorderPattern != LinePattern.NotSet)
|
|
BorderPattern = style._BorderPattern;
|
|
|
|
if (style._BorderThickness > 0)
|
|
BorderThickness = style._BorderThickness;
|
|
|
|
if (style.GroupHeaderFont != null)
|
|
GroupHeaderFont = style.GroupHeaderFont;
|
|
|
|
if (style._Font != null)
|
|
Font = style.Font;
|
|
|
|
if (style.GroupHeaderTextColor.IsEmpty == false)
|
|
GroupHeaderTextColor = style.GroupHeaderTextColor;
|
|
|
|
if (style._Margin != null && style._Margin.IsEmpty == false)
|
|
Margin = style.Margin.Copy();
|
|
|
|
if (style._Padding != null && style._Padding.IsEmpty == false)
|
|
Padding = style.Padding.Copy();
|
|
|
|
if (style._TextColor.IsEmpty == false)
|
|
TextColor = style._TextColor;
|
|
|
|
if (style._ValueXLineStyle != null && style.ValueXLineStyle.IsEmpty == false)
|
|
ValueXLineStyle.ApplyStyle(style.ValueXLineStyle);
|
|
|
|
if (style._ValueYLineStyle != null && style.ValueYLineStyle.IsEmpty == false)
|
|
ValueYLineStyle.ApplyStyle(style.ValueYLineStyle);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Copy
|
|
|
|
/// <summary>
|
|
/// Returns the copy of the style.
|
|
/// </summary>
|
|
/// <returns>Copy of the style.</returns>
|
|
public new CrosshairVisualStyle Copy()
|
|
{
|
|
CrosshairVisualStyle style = new CrosshairVisualStyle();
|
|
|
|
CopyTo(style);
|
|
|
|
return (style);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CopyTo
|
|
|
|
/// <summary>
|
|
/// Returns the copy of the style.
|
|
/// </summary>
|
|
/// <returns>Copy of the style.</returns>
|
|
public void CopyTo(CrosshairVisualStyle style)
|
|
{
|
|
base.CopyTo(style);
|
|
|
|
style.Background = (_Background != null) ? _Background.Copy() : null;
|
|
|
|
style.BorderColor = _BorderColor;
|
|
style.BorderPattern = _BorderPattern;
|
|
style.BorderThickness = _BorderThickness;
|
|
|
|
style.GroupHeaderFont = (_GroupHeaderFont != null) ? (Font)_GroupHeaderFont.Clone() : null;
|
|
style.GroupHeaderTextColor = _GroupHeaderTextColor;
|
|
|
|
style.Font = (_Font != null) ? (Font)_Font.Clone() : null;
|
|
style.Margin = (_Margin != null) ? _Margin.Copy() : null;
|
|
style.Padding = (_Padding != null) ? _Padding.Copy() : null;
|
|
|
|
style.TextColor = _TextColor;
|
|
|
|
style.ValueXLineStyle = (_ValueXLineStyle != null) ? _ValueXLineStyle.Copy() : null;
|
|
style.ValueYLineStyle = (_ValueYLineStyle != null) ? _ValueYLineStyle.Copy() : null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSerialData
|
|
|
|
internal override SerialElementCollection GetSerialData(string serialName)
|
|
{
|
|
SerialElementCollection sec = new SerialElementCollection();
|
|
|
|
if (serialName != null)
|
|
{
|
|
if (serialName.Equals("") == true)
|
|
serialName = "CrosshairVisualStyle";
|
|
|
|
sec.AddStartElement(serialName);
|
|
}
|
|
|
|
if (_Background != null && _Background.IsEmpty == false)
|
|
sec.AddElement(_Background.GetSerialData("Background"));
|
|
|
|
sec.AddValue("BorderColor", BorderColor, Color.Empty);
|
|
sec.AddValue("BorderPattern", BorderPattern, LinePattern.NotSet);
|
|
sec.AddValue("BorderThickness", BorderThickness, 0);
|
|
|
|
if (_GroupHeaderFont != null)
|
|
sec.AddValue("GroupHeaderFont", XmlSerializableFont.ConvertToString(GroupHeaderFont));
|
|
|
|
sec.AddValue("GroupHeaderTextColor", GroupHeaderTextColor, Color.Empty);
|
|
|
|
if (_Font != null)
|
|
sec.AddValue("Font", XmlSerializableFont.ConvertToString(Font));
|
|
|
|
if (_Margin != null && _Margin.IsEmpty == false)
|
|
sec.AddElement(_Margin.GetSerialData("Margin"));
|
|
|
|
if (_Padding != null && _Padding.IsEmpty == false)
|
|
sec.AddElement(_Padding.GetSerialData("Padding"));
|
|
|
|
sec.AddValue("TextColor", TextColor, Color.Empty);
|
|
|
|
if (_ValueXLineStyle != null && _ValueXLineStyle.IsEmpty == false)
|
|
sec.AddElement(_ValueXLineStyle.GetSerialData("ValueXLineStyle"));
|
|
|
|
if (_ValueYLineStyle != null && _ValueYLineStyle.IsEmpty == false)
|
|
sec.AddElement(_ValueYLineStyle.GetSerialData("ValueYLineStyle"));
|
|
|
|
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 "BorderColor":
|
|
BorderColor = se.GetValueColor();
|
|
break;
|
|
|
|
case "BorderPattern":
|
|
BorderPattern = (LinePattern)se.GetValueEnum(typeof(LinePattern));
|
|
break;
|
|
|
|
case "BorderThickness":
|
|
BorderThickness = int.Parse(se.StringValue);
|
|
break;
|
|
|
|
case "GroupHeaderFont":
|
|
GroupHeaderFont = XmlSerializableFont.ConvertFromString(se.StringValue);
|
|
break;
|
|
|
|
case "GroupHeaderTextColor":
|
|
GroupHeaderTextColor = se.GetValueColor();
|
|
break;
|
|
|
|
case "Font":
|
|
Font = XmlSerializableFont.ConvertFromString(se.StringValue);
|
|
break;
|
|
|
|
case "TextColor":
|
|
TextColor = se.GetValueColor();
|
|
break;
|
|
|
|
default:
|
|
base.ProcessValue(se);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessCollection
|
|
|
|
internal override void ProcessCollection(SerialElement se)
|
|
{
|
|
SerialElementCollection sec = se.Sec;
|
|
|
|
switch (se.Name)
|
|
{
|
|
case "Background":
|
|
sec.PutSerialData(Background);
|
|
break;
|
|
|
|
case "Margin":
|
|
sec.PutSerialData(Margin);
|
|
break;
|
|
|
|
case "Padding":
|
|
sec.PutSerialData(Padding);
|
|
break;
|
|
|
|
case "ValueXLineStyle":
|
|
sec.PutSerialData(ValueXLineStyle);
|
|
break;
|
|
|
|
case "ValueYLineStyle":
|
|
sec.PutSerialData(ValueYLineStyle);
|
|
break;
|
|
|
|
default:
|
|
base.ProcessCollection(se);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region IDisposable
|
|
|
|
/// <summary>
|
|
/// Dispose
|
|
/// </summary>
|
|
public override void Dispose()
|
|
{
|
|
Margin = null;
|
|
Padding = null;
|
|
ValueXLineStyle = null;
|
|
ValueYLineStyle = null;
|
|
|
|
base.Dispose();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|