1862 lines
54 KiB
C#
1862 lines
54 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Drawing.Text;
|
|
using System.Windows.Forms;
|
|
|
|
namespace DevComponents.DotNetBar.Charts.Style
|
|
{
|
|
///<summary>
|
|
/// PieCenterVisualStyles
|
|
///</summary>
|
|
[TypeConverter(typeof(VisualStylesConverter))]
|
|
public class PieCenterVisualStyles : VisualStyles<PieCenterVisualStyle>
|
|
{
|
|
#region Copy
|
|
|
|
/// <summary>
|
|
/// Returns the copy of the style.
|
|
/// </summary>
|
|
/// <returns>Copy of the style.</returns>
|
|
public PieCenterVisualStyles Copy()
|
|
{
|
|
PieCenterVisualStyles styles = new PieCenterVisualStyles();
|
|
|
|
for (int i = 0; i < Styles.Length; i++)
|
|
{
|
|
PieCenterVisualStyle vstyle = Styles[i];
|
|
|
|
if (vstyle != null)
|
|
styles.Styles[i] = vstyle.Copy();
|
|
}
|
|
|
|
return (styles);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents the visual style of a Pie Center.
|
|
/// </summary>
|
|
[ToolboxItem(false), DesignTimeVisible(false)]
|
|
[TypeConverter(typeof(BlankExpandableObjectConverter))]
|
|
public class PieCenterVisualStyle : BaseVisualStyle
|
|
{
|
|
#region Private variables
|
|
|
|
private Tbool _AllowWrap = Tbool.NotSet;
|
|
private Alignment _Alignment = Alignment.NotSet;
|
|
|
|
private Background _Background;
|
|
private ChartLineVisualStyle _Border;
|
|
private Padding _Padding;
|
|
|
|
private Color _TextColor = Color.Empty;
|
|
private Font _Font;
|
|
|
|
private Image _Image;
|
|
private int _ImageIndex = -1;
|
|
private ImageList _ImageList;
|
|
|
|
private Padding _ImagePadding;
|
|
|
|
private Alignment _ImageAlignment = Alignment.NotSet;
|
|
private ImageOverlay _ImageOverlay = ImageOverlay.NotSet;
|
|
private ImageSizeMode _ImageSizeMode = ImageSizeMode.NotSet;
|
|
|
|
private double _ImageScale = double.NaN;
|
|
|
|
private Size _FigureSizeEx;
|
|
|
|
private Tbool _ImageInscribed = Tbool.NotSet;
|
|
private Tbool _TextInscribed = Tbool.NotSet;
|
|
|
|
private SymbolDef _SymbolDef;
|
|
private SymbolDef _ScaleSymDef;
|
|
|
|
private float _SymFontScale = -1;
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region Alignment
|
|
|
|
/// <summary>
|
|
/// Gets or sets the alignment of the text.
|
|
/// </summary>
|
|
[DefaultValue(Alignment.NotSet), Category("Appearance")]
|
|
[Description("Indicates the alignment of the text.")]
|
|
public Alignment Alignment
|
|
{
|
|
get { return (_Alignment); }
|
|
|
|
set
|
|
{
|
|
if (_Alignment != value)
|
|
{
|
|
_Alignment = value;
|
|
|
|
OnPropertyChangedEx("Alignment", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AllowWrap
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether text wrapping is permitted.
|
|
/// </summary>
|
|
[DefaultValue(Tbool.NotSet), Category("Appearance")]
|
|
[Description("Indicates whether text wrapping is permitted.")]
|
|
public Tbool AllowWrap
|
|
{
|
|
get { return (_AllowWrap); }
|
|
|
|
set
|
|
{
|
|
if (_AllowWrap != value)
|
|
{
|
|
_AllowWrap = value;
|
|
|
|
OnPropertyChangedEx("AllowWrap", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Background
|
|
|
|
/// <summary>
|
|
/// Gets or sets the background style.
|
|
/// </summary>
|
|
[Description("Indicates the background style")]
|
|
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 Border
|
|
|
|
/// <summary>
|
|
/// Gets or sets the pie center border.
|
|
/// </summary>
|
|
[Category("Style")]
|
|
[Description("Indicates the pie center border.")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
public ChartLineVisualStyle Border
|
|
{
|
|
get
|
|
{
|
|
if (_Border == null)
|
|
{
|
|
_Border = new ChartLineVisualStyle();
|
|
|
|
UpdateChangeHandler(null, _Border);
|
|
}
|
|
|
|
return (_Border);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_Border != value)
|
|
{
|
|
ChartLineVisualStyle oldValue = _Border;
|
|
|
|
_Border = value;
|
|
|
|
OnStyleChanged("Border", oldValue, value);
|
|
|
|
if (oldValue != null)
|
|
oldValue.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Font
|
|
|
|
/// <summary>
|
|
/// Gets or sets the style Font.
|
|
/// </summary>
|
|
[DefaultValue(null)]
|
|
[Description("Indicates the style Font.")]
|
|
public Font Font
|
|
{
|
|
get { return (_Font); }
|
|
|
|
set
|
|
{
|
|
if (_Font != value)
|
|
{
|
|
_Font = value;
|
|
|
|
OnPropertyChangedEx("Font", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Image
|
|
|
|
/// <summary>
|
|
/// Gets or sets the element Image.
|
|
/// </summary>
|
|
[DefaultValue(null), Category("Appearance")]
|
|
[Description("Indicates the element image.")]
|
|
public Image Image
|
|
{
|
|
get { return (_Image); }
|
|
|
|
set
|
|
{
|
|
if (_Image != value)
|
|
{
|
|
_Image = value;
|
|
|
|
OnPropertyChangedEx("Image", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageAlignment
|
|
|
|
/// <summary>
|
|
/// Gets or sets the alignment of the Image.
|
|
/// </summary>
|
|
[DefaultValue(Alignment.NotSet), Category("Appearance")]
|
|
[Description("Indicates the alignment of the Image.")]
|
|
public Alignment ImageAlignment
|
|
{
|
|
get { return (_ImageAlignment); }
|
|
|
|
set
|
|
{
|
|
if (_ImageAlignment != value)
|
|
{
|
|
_ImageAlignment = value;
|
|
|
|
OnPropertyChangedEx("ImageAlignment", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageIndex
|
|
|
|
/// <summary>
|
|
/// Gets or sets the image index.
|
|
/// </summary>
|
|
[DefaultValue(-1)]
|
|
[Category("Appearance"), Description("Indicates the image index.")]
|
|
[Editor("DevComponents.SuperGrid.Design.ImageIndexEditor, DevComponents.SuperGrid.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
|
|
[TypeConverter(typeof(ImageIndexConverter))]
|
|
public int ImageIndex
|
|
{
|
|
get { return (_ImageIndex); }
|
|
|
|
set
|
|
{
|
|
if (_ImageIndex != value)
|
|
{
|
|
_ImageIndex = value;
|
|
|
|
OnPropertyChangedEx("ImageIndex", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageInscribed
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the image is inscribed in the
|
|
/// PieCenter area (true = inscribed, false = circumscribed).
|
|
/// </summary>
|
|
[DefaultValue(Tbool.NotSet), Category("Appearance")]
|
|
[Description("Indicates whether the image is inscribed in the PieCenter area (true = inscribed, false = circumscribed).")]
|
|
public Tbool ImageInscribed
|
|
{
|
|
get { return (_ImageInscribed); }
|
|
|
|
set
|
|
{
|
|
if (_ImageInscribed != value)
|
|
{
|
|
_ImageInscribed = value;
|
|
|
|
OnPropertyChangedEx("ImageInscribed", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageList
|
|
|
|
/// <summary>
|
|
/// Gets or sets the ImageList.
|
|
/// </summary>
|
|
[Browsable(true), Category("Appearance"), DefaultValue(null)]
|
|
[Description("Indicates the ImageList.")]
|
|
public ImageList ImageList
|
|
{
|
|
get { return (_ImageList); }
|
|
|
|
set
|
|
{
|
|
if (_ImageList != value)
|
|
{
|
|
_ImageList = value;
|
|
|
|
OnPropertyChangedEx("ImageList", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageOverlay
|
|
|
|
/// <summary>
|
|
/// Gets or sets how to overlay the image with respect to the center content.
|
|
/// </summary>
|
|
[DefaultValue(ImageOverlay.NotSet), Category("Appearance")]
|
|
[Description("Indicates how to overlay the image with respect to the center content.")]
|
|
public ImageOverlay ImageOverlay
|
|
{
|
|
get { return (_ImageOverlay); }
|
|
|
|
set
|
|
{
|
|
if (_ImageOverlay != value)
|
|
{
|
|
_ImageOverlay = value;
|
|
|
|
OnPropertyChangedEx("ImageOverlay", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImagePadding
|
|
|
|
/// <summary>
|
|
/// Gets or sets the spacing between content and edges of the Image.
|
|
/// </summary>
|
|
[Description("Indicates the spacing between content and edges of the Image.")]
|
|
public Padding ImagePadding
|
|
{
|
|
get
|
|
{
|
|
if (_ImagePadding == null)
|
|
{
|
|
_ImagePadding = Padding.Empty;
|
|
|
|
UpdateChangeHandler(null, _ImagePadding);
|
|
}
|
|
|
|
return (_ImagePadding);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_ImagePadding != value)
|
|
{
|
|
UpdateChangeHandler(_ImagePadding, value);
|
|
|
|
_ImagePadding = value;
|
|
|
|
OnPropertyChangedEx("ImagePadding", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private bool ShouldSerializeImagePadding()
|
|
{
|
|
return (_ImagePadding != null && _ImagePadding.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetImagePadding()
|
|
{
|
|
ImagePadding = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageScale
|
|
|
|
/// <summary>
|
|
/// Gets or sets the 'scale' factor for the image/symbol. This property informs the
|
|
/// chart to scale the image (or symbol) based upon the available space at its offset
|
|
/// position in the slice - the image is moved in or out of the slice, the image will
|
|
/// grow of shrink accordingly.
|
|
/// </summary>
|
|
[DefaultValue(double.NaN), Category("Display")]
|
|
[Description("Indicates the 'scale' factor for the image/symbol. This property informs the chart to scale the image (or symbol) based upon the available space at its offset position in the slice - the image is moved in or out of the slice, the image will grow of shrink accordingly.")]
|
|
[Editor("DevComponents.Charts.Design.RadiusRangeValueEditor, DevComponents.Charts.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
|
|
public double ImageScale
|
|
{
|
|
get { return (_ImageScale); }
|
|
|
|
set
|
|
{
|
|
if (value != _ImageScale)
|
|
{
|
|
if (value < 0)
|
|
throw new Exception("ImageScale can not be negative.");
|
|
|
|
_ImageScale = value;
|
|
|
|
OnPropertyChangedEx("ImageScale", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageSizeMode
|
|
|
|
/// <summary>
|
|
/// Gets or sets the 'mode' used to display the image.
|
|
/// </summary>
|
|
[DefaultValue(ImageSizeMode.NotSet), Category("Appearance")]
|
|
[Description("Indicates the 'mode' used to display the image.")]
|
|
public ImageSizeMode ImageSizeMode
|
|
{
|
|
get { return (_ImageSizeMode); }
|
|
|
|
set
|
|
{
|
|
if (value!= _ImageSizeMode)
|
|
{
|
|
_ImageSizeMode = value;
|
|
|
|
OnPropertyChangedEx("ImageSizeMode", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Padding
|
|
|
|
/// <summary>
|
|
/// Gets or sets the spacing between content and edges of the Image.
|
|
/// </summary>
|
|
[Description("Indicates the spacing between content and edges of the Image.")]
|
|
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.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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 SymbolDef
|
|
|
|
/// <summary>
|
|
/// Gets or sets the element Symbol Definition. Note that Symbol definition
|
|
/// takes precedence over Image definition. Also note that the supporting Image
|
|
/// properties (such as ImageAlignment, ImageOverlay, etc) apply to a set
|
|
/// Symbol as well as to a set Image.
|
|
/// </summary>
|
|
[DefaultValue(null), Category("Appearance")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[Description("Indicates the element Symbol Definition. Note that Symbol definition takes precedence over Image definition. Also note that the supporting Image properties (such as ImageAlignment, ImageOverlay, etc) apply to a set Symbol as well as to a set Image.")]
|
|
public SymbolDef SymbolDef
|
|
{
|
|
get
|
|
{
|
|
if (_SymbolDef == null)
|
|
{
|
|
_SymbolDef = new SymbolDef();
|
|
|
|
UpdateChangeHandler(null, _SymbolDef);
|
|
}
|
|
|
|
return (_SymbolDef);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_SymbolDef != value)
|
|
{
|
|
UpdateChangeHandler(_SymbolDef, value);
|
|
|
|
_SymbolDef = value;
|
|
|
|
OnPropertyChangedEx("SymbolDef", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether property should be serialized.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private bool ShouldSerializeSymbolDef()
|
|
{
|
|
return (_SymbolDef != null && _SymbolDef.IsEmpty == false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets property to its default value.
|
|
/// </summary>
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetSymbolDef()
|
|
{
|
|
SymbolDef = 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 TextInscribed
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the Text is inscribed in the
|
|
/// PieCenter area (true = inscribed, false = circumscribed).
|
|
/// </summary>
|
|
[DefaultValue(Tbool.NotSet), Category("Appearance")]
|
|
[Description("Indicates whether the Text is inscribed in the PieCenter area (true = inscribed, false = circumscribed).")]
|
|
public Tbool TextInscribed
|
|
{
|
|
get { return (_TextInscribed); }
|
|
|
|
set
|
|
{
|
|
if (_TextInscribed != value)
|
|
{
|
|
_TextInscribed = value;
|
|
|
|
OnPropertyChangedEx("TextInscribed", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#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 ((_Alignment == Alignment.NotSet) &&
|
|
(_AllowWrap == Tbool.NotSet) &&
|
|
(_Background == null || _Background.IsEmpty == true) &&
|
|
(_Border == null || _Border.IsEmpty == true) &&
|
|
(_Font == null) &&
|
|
(_Image == null) &&
|
|
(_ImageAlignment == Alignment.NotSet) &&
|
|
(_ImageIndex == -1) &&
|
|
(_ImageInscribed == Tbool.NotSet) &&
|
|
(_ImageList == null) &&
|
|
(_ImageOverlay == ImageOverlay.NotSet) &&
|
|
(_ImagePadding == null || _ImagePadding.IsEmpty == true) &&
|
|
(double.IsNaN(_ImageScale) == true) &&
|
|
(_ImageSizeMode == Style.ImageSizeMode.NotSet) &&
|
|
(_Padding == null || _Padding.IsEmpty == true) &&
|
|
(_SymbolDef == null || _SymbolDef.IsEmpty == true) &&
|
|
(_TextColor.IsEmpty == true) &&
|
|
(_TextInscribed == Tbool.NotSet) &&
|
|
(base.IsEmpty == true));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Internal properties
|
|
|
|
#region IsOverlayImage
|
|
|
|
internal bool IsOverlayImage
|
|
{
|
|
get
|
|
{
|
|
return (_ImageOverlay == ImageOverlay.Top ||
|
|
_ImageOverlay == ImageOverlay.Middle ||
|
|
_ImageOverlay == ImageOverlay.Bottom);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsValidFigure
|
|
|
|
internal bool IsValidFigure
|
|
{
|
|
get
|
|
{
|
|
if (IsSymbolFigure == true)
|
|
return (true);
|
|
|
|
return (GetImage() != null);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsSymbolFigure
|
|
|
|
internal bool IsSymbolFigure
|
|
{
|
|
get { return (_SymbolDef != null && _SymbolDef.IsValidSymbol == true); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region FigureSizeEx
|
|
|
|
internal Size FigureSizeEx
|
|
{
|
|
get { return (_FigureSizeEx); }
|
|
set { _FigureSizeEx = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetFigure
|
|
|
|
internal object GetFigure()
|
|
{
|
|
if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
|
|
return (_SymbolDef);
|
|
|
|
return (GetImage());
|
|
}
|
|
|
|
#region GetImage
|
|
|
|
internal Image GetImage()
|
|
{
|
|
if (_Image != null)
|
|
return (_Image);
|
|
|
|
if (_ImageIndex >= 0)
|
|
{
|
|
ImageList imageList = ImageList;
|
|
|
|
if (imageList != null && _ImageIndex < imageList.Images.Count)
|
|
return (imageList.Images[_ImageIndex]);
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSymbol
|
|
|
|
internal string GetSymbol()
|
|
{
|
|
if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
|
|
return (_SymbolDef.SymbolRealized);
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetFigureSize
|
|
|
|
internal Size GetFigureSize(Graphics g)
|
|
{
|
|
Size size = Size.Empty;
|
|
|
|
if (IsSymbolFigure == true)
|
|
size = _SymbolDef.GetSymbolSize(g);
|
|
|
|
else
|
|
{
|
|
Image image = GetImage();
|
|
|
|
if (image != null)
|
|
size = Dpi.Size(image.Size);
|
|
}
|
|
|
|
return (size);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetFigureBounds
|
|
|
|
internal Rectangle GetFigureBounds(Graphics g, Rectangle r)
|
|
{
|
|
if (IsSymbolFigure == true)
|
|
return (GetSymbolBounds(g, r));
|
|
|
|
return (GetImageBounds(g, r));
|
|
}
|
|
|
|
#region GetImageBounds
|
|
|
|
internal Rectangle GetImageBounds(Graphics g, Rectangle r)
|
|
{
|
|
Image image = GetImage();
|
|
|
|
return (GetImageBounds(g, r, image));
|
|
}
|
|
|
|
private Rectangle GetImageBounds(Graphics g, Rectangle r, Image image)
|
|
{
|
|
if (image != null)
|
|
{
|
|
Size size = Dpi.Size(image.Size);
|
|
|
|
if (double.IsNaN(ImageScale) == false)
|
|
{
|
|
if (ImageScale != 1)
|
|
size = FigureSizeEx;
|
|
}
|
|
|
|
return (GetSizeBounds(r, size, ImageAlignment));
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSymbolBounds
|
|
|
|
internal Rectangle GetSymbolBounds(Graphics g, Rectangle r)
|
|
{
|
|
if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
|
|
{
|
|
Size size = _SymbolDef.GetSymbolSize(g);
|
|
|
|
if (double.IsNaN(ImageScale) == false)
|
|
{
|
|
if (ImageScale != 1)
|
|
size = FigureSizeEx;
|
|
}
|
|
|
|
return (GetSizeBounds(r, size, ImageAlignment));
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSizeBounds
|
|
|
|
internal Rectangle GetSizeBounds(Rectangle r,
|
|
Size size, Padding padding, Alignment alignment)
|
|
{
|
|
switch (alignment)
|
|
{
|
|
case Alignment.NotSet:
|
|
case Alignment.MiddleLeft:
|
|
r.Y += (r.Height - size.Height) / 2;
|
|
|
|
r.X += Dpi.Width(padding.Left);
|
|
r.Y += Dpi.Height(padding.Top - padding.Bottom);
|
|
break;
|
|
|
|
case Alignment.TopLeft:
|
|
r.X += Dpi.Width(padding.Left);
|
|
r.Y += Dpi.Height(padding.Top);
|
|
break;
|
|
|
|
case Alignment.BottomLeft:
|
|
r.Y = r.Bottom - size.Height;
|
|
|
|
r.X += Dpi.Width(padding.Left);
|
|
r.Y -= Dpi.Height(padding.Bottom);
|
|
break;
|
|
|
|
case Alignment.TopCenter:
|
|
r.X += (r.Width - size.Width) / 2;
|
|
|
|
r.X += Dpi.Width(padding.Left - padding.Right);
|
|
r.Y += Dpi.Height(padding.Top);
|
|
break;
|
|
|
|
case Alignment.MiddleCenter:
|
|
r.X += (r.Width - size.Width) / 2;
|
|
r.Y += (r.Height - size.Height) / 2;
|
|
|
|
r.X += Dpi.Width(padding.Left - padding.Right);
|
|
r.Y += Dpi.Height(padding.Top - padding.Bottom);
|
|
break;
|
|
|
|
case Alignment.BottomCenter:
|
|
r.X += (r.Width - size.Width) / 2;
|
|
r.Y = r.Bottom - size.Height;
|
|
|
|
r.X += Dpi.Width(padding.Left - padding.Right);
|
|
r.Y -= Dpi.Height(padding.Bottom);
|
|
break;
|
|
|
|
case Alignment.TopRight:
|
|
r.X = r.Right - size.Width;
|
|
|
|
r.X -= Dpi.Width(padding.Right);
|
|
r.Y += Dpi.Height(padding.Top);
|
|
break;
|
|
|
|
case Alignment.MiddleRight:
|
|
r.X = r.Right - size.Width;
|
|
r.Y += (r.Height - size.Height) / 2;
|
|
|
|
r.X -= Dpi.Width(padding.Right);
|
|
r.Y += Dpi.Height(padding.Top - padding.Bottom);
|
|
break;
|
|
|
|
case Alignment.BottomRight:
|
|
r.X = r.Right - size.Width;
|
|
r.Y = r.Bottom - size.Height;
|
|
|
|
r.X -= Dpi.Width(padding.Right);
|
|
r.Y -= Dpi.Height(padding.Bottom);
|
|
break;
|
|
}
|
|
|
|
r.Size = size;
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSizeBounds
|
|
|
|
internal Rectangle GetSizeBounds(Rectangle r, Size size, Alignment alignment)
|
|
{
|
|
switch (alignment)
|
|
{
|
|
case Alignment.NotSet:
|
|
case Alignment.MiddleLeft:
|
|
r.Y += (r.Height - size.Height) / 2;
|
|
break;
|
|
|
|
case Alignment.BottomLeft:
|
|
r.Y = r.Bottom - size.Height;
|
|
break;
|
|
|
|
case Alignment.TopCenter:
|
|
r.X += (r.Width - size.Width) / 2;
|
|
break;
|
|
|
|
case Alignment.MiddleCenter:
|
|
r.X += (r.Width - size.Width) / 2;
|
|
r.Y += (r.Height - size.Height) / 2;
|
|
break;
|
|
|
|
case Alignment.BottomCenter:
|
|
r.X += (r.Width - size.Width) / 2;
|
|
r.Y = r.Bottom - size.Height;
|
|
break;
|
|
|
|
case Alignment.TopRight:
|
|
r.X = r.Right - size.Width;
|
|
break;
|
|
|
|
case Alignment.MiddleRight:
|
|
r.X = r.Right - size.Width;
|
|
r.Y += (r.Height - size.Height) / 2;
|
|
break;
|
|
|
|
case Alignment.BottomRight:
|
|
r.X = r.Right - size.Width;
|
|
r.Y = r.Bottom - size.Height;
|
|
break;
|
|
}
|
|
|
|
r.Size = size;
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetTextBounds
|
|
|
|
internal Rectangle GetTextBounds(Rectangle r, Size size)
|
|
{
|
|
return (GetSizeBounds(r, size, ImagePadding, Alignment));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderBackgroundFigure
|
|
|
|
internal void RenderBackgroundFigure(Graphics g, Rectangle bounds)
|
|
{
|
|
RenderBackgroundFigure(g, bounds, bounds);
|
|
}
|
|
|
|
internal void RenderBackgroundFigure(Graphics g, Rectangle bounds, Rectangle clipBounds)
|
|
{
|
|
if (IsSymbolFigure == true)
|
|
RenderBackgroundSymbol(g, bounds, clipBounds);
|
|
else
|
|
RenderBackgroundImage(g, bounds, clipBounds);
|
|
}
|
|
|
|
#region RenderBackgroundImage
|
|
|
|
internal void RenderBackgroundImage(Graphics g, Rectangle bounds, Rectangle clipBounds)
|
|
{
|
|
Image image = GetImage();
|
|
|
|
if (image != null)
|
|
{
|
|
Region clip = g.Clip;
|
|
|
|
if (ImageSizeMode == ImageSizeMode.NotSet ||
|
|
ImageSizeMode == ImageSizeMode.Normal)
|
|
{
|
|
Rectangle dbounds = GetImageBounds(g, clipBounds, image);
|
|
|
|
g.SetClip(Rectangle.Intersect(bounds, dbounds), CombineMode.Intersect);
|
|
|
|
g.DrawImage(image, dbounds,
|
|
new Rectangle(Point.Empty, image.Size), GraphicsUnit.Pixel);
|
|
}
|
|
else
|
|
{
|
|
Rectangle r = GetAdjustedBounds(clipBounds, ImagePadding);
|
|
|
|
g.SetClip(r, CombineMode.Intersect);
|
|
|
|
switch (ImageSizeMode)
|
|
{
|
|
case ImageSizeMode.Stretch:
|
|
g.PixelOffsetMode = PixelOffsetMode.Half;
|
|
g.DrawImage(image, r);
|
|
g.PixelOffsetMode = PixelOffsetMode.Default;
|
|
break;
|
|
|
|
case ImageSizeMode.Tile:
|
|
RenderImageTiled(g, image, r);
|
|
break;
|
|
|
|
case ImageSizeMode.Zoom:
|
|
RenderImageZoomed(g, image, r);
|
|
break;
|
|
}
|
|
}
|
|
|
|
g.Clip = clip;
|
|
}
|
|
}
|
|
|
|
#region GetAdjustedBounds
|
|
|
|
private Rectangle GetAdjustedBounds(Rectangle bounds, Thickness padding)
|
|
{
|
|
if (padding.IsEmpty == false)
|
|
{
|
|
if (bounds.Height > padding.Vertical)
|
|
{
|
|
bounds.Y += padding.Top;
|
|
bounds.Height -= padding.Vertical;
|
|
}
|
|
|
|
if (bounds.Width > padding.Horizontal)
|
|
{
|
|
bounds.X += padding.Left;
|
|
bounds.Width -= padding.Horizontal;
|
|
}
|
|
}
|
|
|
|
return (bounds);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderImageTiled
|
|
|
|
private void RenderImageTiled(Graphics g, Image image, Rectangle bounds)
|
|
{
|
|
Size size = image.Size;
|
|
|
|
Rectangle sr = new Rectangle(Point.Empty, size);
|
|
Rectangle dr = new Rectangle(bounds.Location, size);
|
|
|
|
Rectangle r = new Rectangle();
|
|
r.X = bounds.X + bounds.Width / 2;
|
|
r.Y = bounds.Y + bounds.Height / 2;
|
|
|
|
int dx = ((bounds.Width / 2) / size.Width + 2) * size.Width;
|
|
int dy = ((bounds.Height / 2) / size.Height + 2) * size.Height;
|
|
|
|
dr.X = r.X - dx + size.Width / 2;
|
|
dr.Y = r.Y - dy + size.Height / 2;
|
|
|
|
int x = dr.X;
|
|
|
|
while (dr.Top < bounds.Bottom)
|
|
{
|
|
while (dr.Left < bounds.Right)
|
|
{
|
|
g.DrawImage(image, dr, sr, GraphicsUnit.Pixel);
|
|
|
|
dr.X += image.Size.Width;
|
|
}
|
|
|
|
dr.X = x;
|
|
dr.Y += image.Size.Height;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderImageZoomed
|
|
|
|
private void RenderImageZoomed(
|
|
Graphics g, Image image, Rectangle r)
|
|
{
|
|
SizeF size = new SizeF(image.Width / image.HorizontalResolution,
|
|
image.Height / image.VerticalResolution);
|
|
|
|
float scale = Math.Min(r.Width / size.Width, r.Height / size.Height);
|
|
|
|
size.Width *= scale;
|
|
size.Height *= scale;
|
|
|
|
Point pt = r.Location;
|
|
|
|
if (Math.Abs(r.Width - size.Width) > 2)
|
|
{
|
|
switch (ImageAlignment)
|
|
{
|
|
case Alignment.TopCenter:
|
|
case Alignment.MiddleCenter:
|
|
case Alignment.BottomCenter:
|
|
pt.X += (int)((r.Width - size.Width) / 2);
|
|
break;
|
|
|
|
case Alignment.TopRight:
|
|
case Alignment.MiddleRight:
|
|
case Alignment.BottomRight:
|
|
pt.X = (int)(r.Right - size.Width);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (ImageAlignment)
|
|
{
|
|
case Alignment.MiddleLeft:
|
|
case Alignment.MiddleCenter:
|
|
case Alignment.MiddleRight:
|
|
pt.Y += (int)((r.Height - size.Height) / 2);
|
|
break;
|
|
|
|
case Alignment.BottomLeft:
|
|
case Alignment.BottomCenter:
|
|
case Alignment.BottomRight:
|
|
pt.Y = (int)(r.Bottom - size.Height);
|
|
break;
|
|
}
|
|
}
|
|
|
|
g.PixelOffsetMode = PixelOffsetMode.Half;
|
|
|
|
g.DrawImage(image,
|
|
pt.X, pt.Y, size.Width, size.Height);
|
|
|
|
g.PixelOffsetMode = PixelOffsetMode.Default;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RenderBackgroundSymbol
|
|
|
|
internal void RenderBackgroundSymbol(Graphics g, Rectangle bounds, Rectangle clipBounds)
|
|
{
|
|
string symbol = GetSymbol();
|
|
|
|
if (symbol != null)
|
|
{
|
|
Region clip = g.Clip;
|
|
|
|
TextRenderingHint hint = g.TextRenderingHint;
|
|
g.TextRenderingHint = TextRenderingHint.AntiAlias;
|
|
|
|
bounds.X += (ImagePadding.Left - ImagePadding.Right);
|
|
bounds.Y += (ImagePadding.Top - ImagePadding.Bottom);
|
|
|
|
if (ImageSizeMode == Style.ImageSizeMode.Stretch ||
|
|
ImageSizeMode == Style.ImageSizeMode.Zoom)
|
|
{
|
|
if (_ScaleSymDef == null)
|
|
_ScaleSymDef = new SymbolDef();
|
|
|
|
float n = Math.Max(bounds.Width, bounds.Height);
|
|
|
|
if (_SymFontScale < 0)
|
|
{
|
|
_ScaleSymDef.SymbolSize = n;
|
|
_ScaleSymDef.SymbolSet = _SymbolDef.SymbolSet;
|
|
|
|
_SymFontScale = n / _ScaleSymDef.SymbolFont.Height * .8f;
|
|
}
|
|
|
|
_ScaleSymDef.SymbolSize = n * _SymFontScale;
|
|
_ScaleSymDef.SymbolSet = _SymbolDef.SymbolSet;
|
|
|
|
Rectangle t = bounds;
|
|
|
|
if (t.Height > _ScaleSymDef.SymbolFont.Height)
|
|
{
|
|
t.Height = _ScaleSymDef.SymbolFont.Height;
|
|
t.Y += (bounds.Height - _ScaleSymDef.SymbolFont.Height) / 2;
|
|
}
|
|
|
|
using (StringFormat sf = new StringFormat())
|
|
{
|
|
sf.Alignment = StringAlignment.Center;
|
|
|
|
using (Brush br = new SolidBrush(_SymbolDef.SymbolColor))
|
|
g.DrawString(_SymbolDef.SymbolRealized, _ScaleSymDef.SymbolFont, br, t, sf);
|
|
}
|
|
}
|
|
else if (ImageSizeMode == ImageSizeMode.Tile)
|
|
{
|
|
Rectangle r = GetAdjustedBounds(clipBounds, ImagePadding);
|
|
|
|
g.SetClip(r, CombineMode.Intersect);
|
|
|
|
RenderSymbolTiled(g, symbol, r);
|
|
}
|
|
else
|
|
{
|
|
Rectangle dbounds = GetSymbolBounds(g, clipBounds);
|
|
|
|
float n = Math.Max(bounds.Width, bounds.Height);
|
|
|
|
if (double.IsNaN(ImageScale) == false)
|
|
{
|
|
if (ImageScale != 1)
|
|
n = (int)(n * ImageScale);
|
|
}
|
|
|
|
n = dbounds.Width;
|
|
|
|
if (_ScaleSymDef == null)
|
|
_ScaleSymDef = new SymbolDef();
|
|
|
|
if (_SymFontScale < 0)
|
|
{
|
|
_ScaleSymDef.SymbolSize = n;
|
|
_ScaleSymDef.SymbolSet = _SymbolDef.SymbolSet;
|
|
|
|
_SymFontScale = n / _ScaleSymDef.SymbolFont.Height * .8f;
|
|
}
|
|
|
|
_ScaleSymDef.SymbolSize = n * _SymFontScale;
|
|
_ScaleSymDef.SymbolSet = _SymbolDef.SymbolSet;
|
|
|
|
Rectangle t = dbounds;
|
|
|
|
if (t.Height > _ScaleSymDef.SymbolFont.Height)
|
|
{
|
|
t.Height = _ScaleSymDef.SymbolFont.Height;
|
|
t.Y += (dbounds.Height - _ScaleSymDef.SymbolFont.Height) / 2;
|
|
}
|
|
|
|
g.SetClip(Rectangle.Intersect(bounds, t), CombineMode.Intersect);
|
|
|
|
using (Brush br = new SolidBrush(_SymbolDef.SymbolColor))
|
|
g.DrawString(symbol, _ScaleSymDef.SymbolFont, br, t);
|
|
}
|
|
|
|
g.TextRenderingHint = hint;
|
|
|
|
g.Clip = clip;
|
|
}
|
|
}
|
|
|
|
#region RenderSymbolTiled
|
|
|
|
private void RenderSymbolTiled(Graphics g, string symbol, Rectangle bounds)
|
|
{
|
|
Font font = _SymbolDef.SymbolFont;
|
|
Color color = _SymbolDef.SymbolColor;
|
|
|
|
Size size = _SymbolDef.GetSymbolSize(g);
|
|
Rectangle dr = new Rectangle(bounds.Location, size);
|
|
|
|
Rectangle r = new Rectangle();
|
|
r.X = bounds.X + bounds.Width / 2;
|
|
r.Y = bounds.Y + bounds.Height / 2;
|
|
|
|
int dx = ((bounds.Width / 2) / size.Width + 2) * size.Width;
|
|
int dy = ((bounds.Height / 2) / size.Height + 2) * size.Height;
|
|
|
|
dr.X = r.X - dx + size.Width / 2;
|
|
dr.Y = r.Y - dy + size.Height / 2;
|
|
|
|
int x = dr.X;
|
|
|
|
using (StringFormat sf = new StringFormat())
|
|
{
|
|
sf.Alignment = StringAlignment.Center;
|
|
sf.LineAlignment = StringAlignment.Center;
|
|
|
|
while (dr.Top < bounds.Bottom)
|
|
{
|
|
using (Brush br = new SolidBrush(_SymbolDef.SymbolColor))
|
|
{
|
|
while (dr.Left < bounds.Right)
|
|
{
|
|
g.DrawString(symbol, font, br, dr, sf);
|
|
|
|
dr.X += size.Width;
|
|
}
|
|
}
|
|
|
|
dr.X = x;
|
|
dr.Y += size.Height;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetStringFormatFlags
|
|
|
|
internal void GetStringFormatFlags(StringFormat sf)
|
|
{
|
|
if (AllowWrap == Tbool.False)
|
|
sf.FormatFlags |= StringFormatFlags.NoWrap;
|
|
|
|
switch (Alignment)
|
|
{
|
|
case Alignment.TopCenter:
|
|
sf.LineAlignment = StringAlignment.Near;
|
|
sf.Alignment = StringAlignment.Center;
|
|
break;
|
|
|
|
case Alignment.TopRight:
|
|
sf.LineAlignment = StringAlignment.Near;
|
|
sf.Alignment = StringAlignment.Far;
|
|
break;
|
|
|
|
case Alignment.MiddleLeft:
|
|
sf.LineAlignment = StringAlignment.Center;
|
|
sf.Alignment = StringAlignment.Near;
|
|
break;
|
|
|
|
case Alignment.MiddleCenter:
|
|
sf.LineAlignment = StringAlignment.Center;
|
|
sf.Alignment = StringAlignment.Center;
|
|
break;
|
|
|
|
case Alignment.MiddleRight:
|
|
sf.LineAlignment = StringAlignment.Center;
|
|
sf.Alignment = StringAlignment.Far;
|
|
break;
|
|
|
|
case Alignment.BottomLeft:
|
|
sf.LineAlignment = StringAlignment.Far;
|
|
sf.Alignment = StringAlignment.Near;
|
|
break;
|
|
|
|
case Alignment.BottomCenter:
|
|
sf.LineAlignment = StringAlignment.Far;
|
|
sf.Alignment = StringAlignment.Center;
|
|
break;
|
|
|
|
case Alignment.BottomRight:
|
|
sf.LineAlignment = StringAlignment.Far;
|
|
sf.Alignment = StringAlignment.Far;
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetTextFormatFlags
|
|
|
|
internal eTextFormat GetTextFormatFlags()
|
|
{
|
|
eTextFormat tf = eTextFormat.WordEllipsis |
|
|
eTextFormat.NoPadding | eTextFormat.NoPrefix;
|
|
|
|
if (AllowWrap == Tbool.True)
|
|
tf |= eTextFormat.WordBreak;
|
|
|
|
switch (Alignment)
|
|
{
|
|
case Alignment.TopCenter:
|
|
tf |= eTextFormat.HorizontalCenter;
|
|
break;
|
|
|
|
case Alignment.TopRight:
|
|
tf |= eTextFormat.Right;
|
|
break;
|
|
|
|
case Alignment.MiddleLeft:
|
|
tf |= eTextFormat.VerticalCenter;
|
|
break;
|
|
|
|
case Alignment.NotSet:
|
|
case Alignment.MiddleCenter:
|
|
tf |= eTextFormat.HorizontalCenter;
|
|
tf |= eTextFormat.VerticalCenter;
|
|
break;
|
|
|
|
case Alignment.MiddleRight:
|
|
tf |= eTextFormat.Right;
|
|
tf |= eTextFormat.VerticalCenter;
|
|
break;
|
|
|
|
case Alignment.BottomLeft:
|
|
tf |= eTextFormat.Bottom;
|
|
break;
|
|
|
|
case Alignment.BottomCenter:
|
|
tf |= eTextFormat.Bottom;
|
|
tf |= eTextFormat.HorizontalCenter;
|
|
break;
|
|
|
|
case Alignment.BottomRight:
|
|
tf |= eTextFormat.Bottom;
|
|
tf |= eTextFormat.Right;
|
|
break;
|
|
}
|
|
|
|
return (tf);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ApplyStyle
|
|
|
|
/// <summary>
|
|
/// Applies the style to instance of this style.
|
|
/// </summary>
|
|
/// <param name="style">Style to apply.</param>
|
|
public void ApplyStyle(PieCenterVisualStyle style)
|
|
{
|
|
base.ApplyStyle(style);
|
|
|
|
if (style != null)
|
|
{
|
|
if (style.Alignment != Alignment.NotSet)
|
|
Alignment = style.Alignment;
|
|
|
|
if (style.AllowWrap != Tbool.NotSet)
|
|
AllowWrap = style.AllowWrap;
|
|
|
|
if (style._Background != null && style._Background.IsEmpty == false)
|
|
Background = style._Background.Copy();
|
|
|
|
if (style._Border != null && style._Border.IsEmpty == false)
|
|
Border = style._Border.Copy();
|
|
|
|
if (style.Font != null)
|
|
Font = style.Font;
|
|
|
|
if (style.Image != null)
|
|
{
|
|
Image = style.Image;
|
|
ImageIndex = -1;
|
|
}
|
|
|
|
if (style.ImageAlignment != Alignment.NotSet)
|
|
ImageAlignment = style.ImageAlignment;
|
|
|
|
if (style.ImageIndex >= 0)
|
|
{
|
|
Image = null;
|
|
ImageIndex = style.ImageIndex;
|
|
}
|
|
|
|
if (style.ImageInscribed != Tbool.NotSet)
|
|
ImageInscribed = style.ImageInscribed;
|
|
|
|
if (style.ImageList != null)
|
|
ImageList = style.ImageList;
|
|
|
|
if (style._ImageOverlay != ImageOverlay.NotSet)
|
|
ImageOverlay = style.ImageOverlay;
|
|
|
|
if (style._ImagePadding != null && style._ImagePadding.IsEmpty == false)
|
|
ImagePadding = style._ImagePadding.Copy();
|
|
|
|
if (double.IsNaN(style._ImageScale) == false)
|
|
ImageScale = style._ImageScale;
|
|
|
|
if (style._ImageSizeMode != ImageSizeMode.NotSet)
|
|
ImageSizeMode = style.ImageSizeMode;
|
|
|
|
if (style._Padding != null && style._Padding.IsEmpty == false)
|
|
Padding = style._Padding.Copy();
|
|
|
|
if (style._SymbolDef != null && style._SymbolDef.IsEmpty == false)
|
|
SymbolDef = style._SymbolDef.Copy();
|
|
|
|
if (style._TextColor.IsEmpty == false)
|
|
TextColor = style._TextColor;
|
|
|
|
if (style._TextInscribed != Tbool.NotSet)
|
|
TextInscribed = style.TextInscribed;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ApplyDefaults
|
|
|
|
public override void ApplyDefaults()
|
|
{
|
|
if (_Alignment == Alignment.NotSet)
|
|
Alignment = Alignment.MiddleCenter;
|
|
|
|
if (_Border != null)
|
|
Border.ApplyDefaults();
|
|
|
|
if (_Font == null)
|
|
Font = SystemFonts.DefaultFont;
|
|
|
|
if (_ImageAlignment == Alignment.NotSet)
|
|
ImageAlignment = Alignment.MiddleLeft;
|
|
|
|
if (_ImageInscribed == Tbool.NotSet)
|
|
ImageInscribed = Tbool.True;
|
|
|
|
if (_ImageSizeMode == ImageSizeMode.NotSet)
|
|
ImageSizeMode = ImageSizeMode.Normal;
|
|
|
|
if (_SymbolDef != null && _SymbolDef.IsValidSymbol == true)
|
|
{
|
|
if (_SymbolDef.SymbolSize == 0)
|
|
{
|
|
if (Font != null)
|
|
SymbolDef.SymbolSize = Font.SizeInPoints;
|
|
}
|
|
|
|
if (_SymbolDef.SymbolColor.IsEmpty == true)
|
|
{
|
|
SymbolDef.SymbolColor =
|
|
(TextColor.IsEmpty == false) ? TextColor : Color.Black;
|
|
}
|
|
}
|
|
|
|
if (_TextColor.IsEmpty == true)
|
|
TextColor = Color.Black;
|
|
|
|
if (_TextInscribed == Tbool.NotSet)
|
|
TextInscribed = Tbool.True;
|
|
|
|
base.ApplyDefaults();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Copy
|
|
|
|
/// <summary>
|
|
/// Returns the copy of the style.
|
|
/// </summary>
|
|
/// <returns>Copy of the style.</returns>
|
|
public new PieCenterVisualStyle Copy()
|
|
{
|
|
PieCenterVisualStyle style = new PieCenterVisualStyle();
|
|
|
|
CopyTo(style);
|
|
|
|
return (style);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CopyTo
|
|
|
|
/// <summary>
|
|
/// Returns the copy of the style.
|
|
/// </summary>
|
|
/// <returns>Copy of the style.</returns>
|
|
public void CopyTo(PieCenterVisualStyle style)
|
|
{
|
|
base.CopyTo(style);
|
|
|
|
style.Alignment = _Alignment;
|
|
style.AllowWrap = _AllowWrap;
|
|
|
|
style.Background = (_Background == null) ? null : _Background.Copy();
|
|
style.Border = (_Border != null) ? _Border.Copy() : null;
|
|
|
|
style.Font = (_Font == null) ? null : (Font)_Font.Clone();
|
|
|
|
style.Image = _Image;
|
|
style.ImageAlignment = _ImageAlignment;
|
|
style.ImageIndex = _ImageIndex;
|
|
style.ImageInscribed = _ImageInscribed;
|
|
style.ImageList = _ImageList;
|
|
style.ImageOverlay = _ImageOverlay;
|
|
style.ImagePadding = (_ImagePadding != null) ? _ImagePadding.Copy() : null;
|
|
style.ImageScale = _ImageScale;
|
|
style.ImageSizeMode = _ImageSizeMode;
|
|
|
|
style.Padding = (_Padding != null) ? _Padding.Copy() : null;
|
|
style.SymbolDef = (_SymbolDef != null) ? _SymbolDef.Copy() : null;
|
|
|
|
style.TextColor = _TextColor;
|
|
style.TextInscribed = _TextInscribed;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSerialData
|
|
|
|
internal override SerialElementCollection GetSerialData(string serialName)
|
|
{
|
|
SerialElementCollection sec = new SerialElementCollection();
|
|
|
|
if (serialName != null)
|
|
{
|
|
if (serialName.Equals("") == true)
|
|
serialName = "PieCenterVisualStyle";
|
|
|
|
sec.AddStartElement(serialName);
|
|
}
|
|
|
|
sec.AddValue("Alignment", Alignment, Alignment.NotSet);
|
|
sec.AddValue("AllowWrap", AllowWrap, Tbool.NotSet);
|
|
|
|
if (_Background != null && _Background.IsEmpty == false)
|
|
sec.AddElement(_Background.GetSerialData("Background"));
|
|
|
|
if (_Border != null && _Border.IsEmpty == false)
|
|
sec.AddElement(_Border.GetSerialData("Border"));
|
|
|
|
if (_Font != null)
|
|
sec.AddValue("Font", XmlSerializableFont.ConvertToString(Font));
|
|
|
|
sec.AddValue("Image", Image);
|
|
sec.AddValue("ImageAlignment", ImageAlignment, Alignment.NotSet);
|
|
sec.AddValue("ImageIndex", ImageIndex, -1);
|
|
sec.AddValue("ImageInscribed", ImageInscribed, Tbool.NotSet);
|
|
|
|
if (_ImageList != null)
|
|
sec.AddValue("ImageList", XmlSerializableImageList.ConvertToString(ImageList));
|
|
|
|
sec.AddValue("ImageOverlay", ImageOverlay, ImageOverlay.NotSet);
|
|
|
|
if (_ImagePadding != null && _ImagePadding.IsEmpty == false)
|
|
sec.AddElement(_ImagePadding.GetSerialData("ImagePadding"));
|
|
|
|
sec.AddValue("ImageScale", ImageScale, double.NaN);
|
|
sec.AddValue("ImageSizeMode", ImageSizeMode, ImageSizeMode.NotSet);
|
|
|
|
if (_Padding != null && _Padding.IsEmpty == false)
|
|
sec.AddElement(_Padding.GetSerialData("Padding"));
|
|
|
|
if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
|
|
sec.AddElement(_SymbolDef.GetSerialData("SymbolDef"));
|
|
|
|
sec.AddValue("TextColor", TextColor, Color.Empty);
|
|
sec.AddValue("TextInscribed", TextInscribed, Tbool.NotSet);
|
|
|
|
sec.AddElement(base.GetSerialData(null));
|
|
|
|
if (serialName != null)
|
|
sec.AddEndElement("ContainerVisualStyle");
|
|
|
|
return (sec);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PutSerialData
|
|
|
|
#region ProcessValue
|
|
|
|
internal override void ProcessValue(SerialElement se)
|
|
{
|
|
switch (se.Name)
|
|
{
|
|
case "Alignment":
|
|
Alignment = (Alignment)se.GetValueEnum(typeof(Alignment));
|
|
break;
|
|
|
|
case "AllowWrap":
|
|
AllowWrap = (Tbool)se.GetValueEnum(typeof(Tbool));
|
|
break;
|
|
|
|
case "Font":
|
|
Font = XmlSerializableFont.ConvertFromString(se.StringValue);
|
|
break;
|
|
|
|
case "Image":
|
|
Image = se.GetValueImage();
|
|
break;
|
|
|
|
case "ImageAlignment":
|
|
ImageAlignment = (Alignment)se.GetValueEnum(typeof(Alignment));
|
|
break;
|
|
|
|
case "ImageIndex":
|
|
ImageIndex = int.Parse(se.StringValue);
|
|
break;
|
|
|
|
case "ImageInscribed":
|
|
ImageInscribed = (Tbool)se.GetValueEnum(typeof(Tbool));
|
|
break;
|
|
|
|
case "ImageList":
|
|
ImageList = XmlSerializableImageList.ConvertFromString(se.StringValue);
|
|
break;
|
|
|
|
case "ImageOverlay":
|
|
ImageOverlay = (ImageOverlay)se.GetValueEnum(typeof(ImageOverlay));
|
|
break;
|
|
|
|
case "ImageScale":
|
|
ImageScale = double.Parse(se.StringValue);
|
|
break;
|
|
|
|
case "ImageSizeMode":
|
|
ImageSizeMode = (ImageSizeMode)se.GetValueEnum(typeof(ImageSizeMode));
|
|
break;
|
|
|
|
case "TextColor":
|
|
TextColor = se.GetValueColor();
|
|
break;
|
|
|
|
case "TextInscribed":
|
|
TextInscribed = (Tbool)se.GetValueEnum(typeof(Tbool));
|
|
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 "Border":
|
|
sec.PutSerialData(Border);
|
|
break;
|
|
|
|
case "ImagePadding":
|
|
sec.PutSerialData(ImagePadding);
|
|
break;
|
|
|
|
case "Padding":
|
|
sec.PutSerialData(Padding);
|
|
break;
|
|
|
|
case "SymbolDef":
|
|
sec.PutSerialData(SymbolDef);
|
|
break;
|
|
|
|
default:
|
|
base.ProcessCollection(se);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region IDisposable
|
|
|
|
/// <summary>
|
|
/// Dispose
|
|
/// </summary>
|
|
public override void Dispose()
|
|
{
|
|
Background = null;
|
|
Border = null;
|
|
|
|
ImagePadding = null;
|
|
Padding = null;
|
|
|
|
SymbolDef = null;
|
|
_ScaleSymDef = null;
|
|
|
|
base.Dispose();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|