899 lines
24 KiB
C#
899 lines
24 KiB
C#
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.SuperGrid.Primitives;
|
|
|
|
namespace DevComponents.DotNetBar.SuperGrid.Style
|
|
{
|
|
///<summary>
|
|
/// CellVisualStyles
|
|
///</summary>
|
|
[TypeConverter(typeof(VisualStylesConverter))]
|
|
public class CellVisualStyles : VisualStyles<CellVisualStyle>
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents the visual style of an element.
|
|
/// </summary>
|
|
[TypeConverter(typeof(VisualStylesConverter))]
|
|
public class CellVisualStyle : VisualStyle
|
|
{
|
|
#region Private variables
|
|
|
|
private Tbool _AllowWrap = Tbool.NotSet;
|
|
private Tbool _AllowMultiLine = Tbool.NotSet;
|
|
private Alignment _Alignment = Alignment.NotSet;
|
|
|
|
private Image _Image;
|
|
private int _ImageIndex = -1;
|
|
private Padding _ImagePadding;
|
|
private Alignment _ImageAlignment = Alignment.NotSet;
|
|
private ImageHighlightMode _ImageHighlightMode = ImageHighlightMode.NotSet;
|
|
private ImageOverlay _ImageOverlay = ImageOverlay.NotSet;
|
|
|
|
private SymbolDef _SymbolDef;
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region Alignment
|
|
|
|
/// <summary>
|
|
/// Gets or sets the alignment of the content within the cell
|
|
/// </summary>
|
|
[DefaultValue(Alignment.NotSet), Category("Appearance")]
|
|
[Description("Indicates the alignment of the content within the cell.")]
|
|
public Alignment Alignment
|
|
{
|
|
get { return (_Alignment); }
|
|
|
|
set
|
|
{
|
|
if (_Alignment != value)
|
|
{
|
|
_Alignment = value;
|
|
|
|
OnPropertyChangedEx("Alignment", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AllowMultiLine
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether multiple text lines (via "\r\n" inclusion)
|
|
/// are displayed when text wrapping (AllowWrap) is disabled.
|
|
/// </summary>
|
|
[DefaultValue(Tbool.NotSet), Category("Appearance")]
|
|
[Description("Indicates whether multiple text lines (via '\r\n' inclusion) are displayed when text wrapping (AllowWrap) is disabled.")]
|
|
public Tbool AllowMultiLine
|
|
{
|
|
get { return (_AllowMultiLine); }
|
|
|
|
set
|
|
{
|
|
if (_AllowMultiLine != value)
|
|
{
|
|
_AllowMultiLine = value;
|
|
|
|
OnPropertyChangedEx("AllowMultiLine", 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 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 within the cell
|
|
/// </summary>
|
|
[DefaultValue(Alignment.NotSet), Category("Appearance")]
|
|
[Description("Indicates the alignment of the Image within the cell.")]
|
|
public Alignment ImageAlignment
|
|
{
|
|
get { return (_ImageAlignment); }
|
|
|
|
set
|
|
{
|
|
if (_ImageAlignment != value)
|
|
{
|
|
_ImageAlignment = value;
|
|
|
|
OnPropertyChangedEx("ImageAlignment", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageHighlightMode
|
|
|
|
/// <summary>
|
|
/// Gets or sets how cell images are
|
|
/// highlighted when the cell is selected
|
|
/// </summary>
|
|
[DefaultValue(ImageHighlightMode.NotSet), Category("Style")]
|
|
[Description("Indicates how cell images are highlighted when the cell is selected")]
|
|
public ImageHighlightMode ImageHighlightMode
|
|
{
|
|
get { return (_ImageHighlightMode); }
|
|
|
|
set
|
|
{
|
|
if (value != _ImageHighlightMode)
|
|
{
|
|
_ImageHighlightMode = value;
|
|
|
|
OnPropertyChangedEx("ImageHighlightMode", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageIndex
|
|
|
|
/// <summary>
|
|
/// Gets or sets the image index
|
|
/// </summary>
|
|
[Browsable(true), 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=26d81176cfa2b486", typeof(UITypeEditor))]
|
|
[TypeConverter(typeof(ImageIndexConverter))]
|
|
public int ImageIndex
|
|
{
|
|
get { return (_ImageIndex); }
|
|
|
|
set
|
|
{
|
|
if (_ImageIndex != value)
|
|
{
|
|
_ImageIndex = value;
|
|
|
|
OnPropertyChangedEx("ImageIndex", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
private void ResetImageIndex()
|
|
{
|
|
ImageIndex = -1;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageOverlay
|
|
|
|
/// <summary>
|
|
/// Gets or sets how to overlay the cell image with respect to cell content
|
|
/// </summary>
|
|
[DefaultValue(ImageOverlay.NotSet), Category("Appearance")]
|
|
[Description("Indicates how to overlay the cell image with respect to cell 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 SymbolDef
|
|
|
|
/// <summary>
|
|
/// Gets or sets the element Symbol Definition. Note that
|
|
/// Symbol definition takes precedence over Image definition.
|
|
/// </summary>
|
|
[DefaultValue(null), Category("Appearance")]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
[Description("Indicates the element Symbol Definition. Note that Symbol definition takes precedence over Image definition.")]
|
|
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 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) &&
|
|
(_Image == null) &&
|
|
(_ImageAlignment == Alignment.NotSet) &&
|
|
(_ImageHighlightMode == ImageHighlightMode.NotSet) &&
|
|
(_ImageIndex == -1) &&
|
|
(_ImageOverlay == ImageOverlay.NotSet) &&
|
|
(_ImagePadding == null || _ImagePadding.IsEmpty == true) &&
|
|
|
|
(base.IsEmpty == true));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Internal properties
|
|
|
|
#region IsOverlayImage
|
|
|
|
internal bool IsOverlayImage
|
|
{
|
|
get
|
|
{
|
|
return (_ImageOverlay == ImageOverlay.Top ||
|
|
_ImageOverlay == ImageOverlay.Bottom);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsSymbolFigure
|
|
|
|
internal bool IsSymbolFigure
|
|
{
|
|
get { return (_SymbolDef != null && _SymbolDef.IsValidSymbol == 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(CellVisualStyle style)
|
|
{
|
|
if (style != null)
|
|
{
|
|
base.ApplyStyle(style);
|
|
|
|
if (style.Alignment != Alignment.NotSet)
|
|
_Alignment = style.Alignment;
|
|
|
|
if (style.AllowWrap != Tbool.NotSet)
|
|
_AllowWrap = style.AllowWrap;
|
|
|
|
if (style.AllowMultiLine != Tbool.NotSet)
|
|
_AllowMultiLine = style.AllowMultiLine;
|
|
|
|
if (style.ImageIndex >= 0)
|
|
{
|
|
_Image = null;
|
|
_ImageIndex = style.ImageIndex;
|
|
}
|
|
|
|
if (style.Image != null)
|
|
{
|
|
_Image = style.Image;
|
|
_ImageIndex = -1;
|
|
}
|
|
|
|
if (style.ImageAlignment != Alignment.NotSet)
|
|
_ImageAlignment = style.ImageAlignment;
|
|
|
|
if (style.ImageHighlightMode != ImageHighlightMode.NotSet)
|
|
_ImageHighlightMode = style.ImageHighlightMode;
|
|
|
|
if (style._ImagePadding != null && style._ImagePadding.IsEmpty == false)
|
|
_ImagePadding = style._ImagePadding.Copy();
|
|
|
|
if (style.ImageOverlay != ImageOverlay.NotSet)
|
|
_ImageOverlay = style.ImageOverlay;
|
|
|
|
if (style._SymbolDef != null && style._SymbolDef.IsEmpty == false)
|
|
_SymbolDef = style._SymbolDef.Copy();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ApplyDefaults
|
|
|
|
internal void ApplyDefaults()
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetTextFormatFlags
|
|
|
|
internal virtual eTextFormat GetTextFormatFlags()
|
|
{
|
|
eTextFormat tf = eTextFormat.WordEllipsis |
|
|
eTextFormat.NoPadding | eTextFormat.NoPrefix;
|
|
|
|
if (AllowWrap == Tbool.True)
|
|
{
|
|
tf |= eTextFormat.WordBreak;
|
|
}
|
|
else
|
|
{
|
|
if (AllowMultiLine != Tbool.True)
|
|
tf |= eTextFormat.SingleLine;
|
|
}
|
|
|
|
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.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 IsValidFigure
|
|
|
|
internal bool IsValidFigure(GridPanel panel)
|
|
{
|
|
if (IsSymbolFigure == true)
|
|
return (true);
|
|
|
|
return (GetImage(panel) != null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetFigure
|
|
|
|
internal object GetFigure(GridPanel panel)
|
|
{
|
|
if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
|
|
return (_SymbolDef);
|
|
|
|
return (GetImage(panel));
|
|
}
|
|
|
|
#region GetImage
|
|
|
|
private Image GetImage(GridPanel panel)
|
|
{
|
|
if (_Image != null)
|
|
return (_Image);
|
|
|
|
if (_ImageIndex >= 0 && panel != null)
|
|
{
|
|
ImageList imageList = panel.ImageList;
|
|
|
|
if (imageList != null && _ImageIndex < imageList.Images.Count)
|
|
return (imageList.Images[_ImageIndex]);
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSymbol
|
|
|
|
private string GetSymbol()
|
|
{
|
|
if (_SymbolDef != null && _SymbolDef.IsEmpty == false)
|
|
return (_SymbolDef.SymbolRealized);
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetFigureSize
|
|
|
|
internal Size GetFigureSize(GridPanel panel)
|
|
{
|
|
Size size = GetFigureSizeEx(panel);
|
|
|
|
if (size.IsEmpty == false)
|
|
{
|
|
size.Width += Dpi.Width(ImagePadding.Horizontal);
|
|
size.Height += Dpi.Height(ImagePadding.Vertical);
|
|
}
|
|
|
|
return (size);
|
|
}
|
|
|
|
internal Size GetFigureSizeEx(GridPanel panel)
|
|
{
|
|
Size size = Size.Empty;
|
|
|
|
if (IsSymbolFigure == true)
|
|
{
|
|
size = _SymbolDef.GetSymbolSize(panel.SuperGrid);
|
|
}
|
|
else
|
|
{
|
|
Image image = GetImage(panel);
|
|
|
|
if (image != null)
|
|
size = Dpi.Size(image.Size);
|
|
}
|
|
|
|
return (size);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetFigureBounds
|
|
|
|
internal Rectangle GetFigureBounds(GridPanel panel, Rectangle r)
|
|
{
|
|
Size size = GetFigureSize(panel);
|
|
|
|
return (GetSizeBounds(panel, r, size));
|
|
}
|
|
|
|
#region GetSizeBounds
|
|
|
|
private Rectangle GetSizeBounds(GridPanel panel, Rectangle r, Size size)
|
|
{
|
|
bool overlay = IsOverlayImage;
|
|
|
|
switch (ImageAlignment)
|
|
{
|
|
case Alignment.TopLeft:
|
|
if (overlay == false)
|
|
r.X -= size.Width;
|
|
break;
|
|
|
|
case Alignment.NotSet:
|
|
case Alignment.MiddleLeft:
|
|
if (overlay == false)
|
|
r.X -= size.Width;
|
|
|
|
r.Y += (r.Height - size.Height) / 2;
|
|
break;
|
|
|
|
case Alignment.BottomLeft:
|
|
if (overlay == false)
|
|
r.X -= size.Width;
|
|
|
|
r.Y = r.Bottom - size.Height;
|
|
break;
|
|
|
|
case Alignment.TopCenter:
|
|
r.X += (r.Width - size.Width) / 2;
|
|
|
|
if (overlay == false)
|
|
r.Y -= size.Height;
|
|
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;
|
|
|
|
if (overlay == true)
|
|
r.Y -= size.Height;
|
|
break;
|
|
|
|
case Alignment.TopRight:
|
|
r.X = r.Right;
|
|
|
|
if (overlay == true)
|
|
r.X -= size.Width;
|
|
break;
|
|
|
|
case Alignment.MiddleRight:
|
|
r.X = r.Right;
|
|
|
|
if (overlay == true)
|
|
r.X -= size.Width;
|
|
|
|
r.Y += (r.Height - size.Height) / 2;
|
|
|
|
break;
|
|
|
|
case Alignment.BottomRight:
|
|
r.X = r.Right;
|
|
r.Y = r.Bottom - size.Height;
|
|
|
|
if (overlay == true)
|
|
r.X -= size.Width;
|
|
break;
|
|
}
|
|
|
|
r.Size = GetFigureSizeEx(panel);
|
|
|
|
r.X += ImagePadding.Left;
|
|
r.Y += ImagePadding.Top;
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetNonFigureBounds
|
|
|
|
internal Rectangle GetNonFigureBounds(GridPanel panel, Rectangle r)
|
|
{
|
|
object figure = GetFigure(panel);
|
|
|
|
if (figure != null)
|
|
{
|
|
if (IsOverlayImage == false)
|
|
{
|
|
Size size = GetFigureSize(panel);
|
|
|
|
switch (ImageAlignment)
|
|
{
|
|
case Alignment.TopCenter:
|
|
r.Y += size.Height;
|
|
r.Height -= size.Height;
|
|
break;
|
|
|
|
case Alignment.MiddleCenter:
|
|
break;
|
|
|
|
case Alignment.BottomCenter:
|
|
r.Height -= size.Height;
|
|
break;
|
|
|
|
case Alignment.TopRight:
|
|
case Alignment.MiddleRight:
|
|
case Alignment.BottomRight:
|
|
r.Width -= size.Width;
|
|
break;
|
|
|
|
default:
|
|
r.X += size.Width;
|
|
r.Width -= size.Width;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderFigure
|
|
|
|
internal void RenderFigure(Graphics g, GridPanel panel, Rectangle r)
|
|
{
|
|
RenderFigure(g, GetFigure(panel), r);
|
|
}
|
|
|
|
internal void RenderFigure(Graphics g, object figure, Rectangle r)
|
|
{
|
|
if (r.Width > 0 && r.Height > 0)
|
|
{
|
|
if (figure is Image)
|
|
{
|
|
g.DrawImageUnscaledAndClipped((Image)figure, r);
|
|
}
|
|
else if (figure is SymbolDef)
|
|
{
|
|
SymbolDef sd = (SymbolDef)figure;
|
|
|
|
using (Brush br = new SolidBrush(sd.SymbolColor))
|
|
g.DrawString(sd.SymbolRealized, sd.SymbolFont, br, r);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Copy
|
|
|
|
/// <summary>
|
|
/// Returns the copy of the style.
|
|
/// </summary>
|
|
/// <returns>Copy of the style.</returns>
|
|
public new CellVisualStyle Copy()
|
|
{
|
|
CellVisualStyle style = new CellVisualStyle();
|
|
|
|
CopyTo(style);
|
|
|
|
return (style);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CopyTo
|
|
|
|
/// <summary>
|
|
/// Returns the copy of the style.
|
|
/// </summary>
|
|
/// <returns>Copy of the style.</returns>
|
|
public void CopyTo(CellVisualStyle style)
|
|
{
|
|
base.CopyTo(style);
|
|
|
|
style.Alignment = _Alignment;
|
|
style.AllowWrap = _AllowWrap;
|
|
style.AllowMultiLine = _AllowMultiLine;
|
|
|
|
style.Image = _Image;
|
|
style.ImageAlignment = _ImageAlignment;
|
|
style.ImageHighlightMode = _ImageHighlightMode;
|
|
style.ImageIndex = _ImageIndex;
|
|
style.ImageOverlay = _ImageOverlay;
|
|
style.ImagePadding = (_ImagePadding != null) ? _ImagePadding.Copy() : null;
|
|
|
|
style.SymbolDef = (_SymbolDef != null) ? _SymbolDef.Copy() : null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IDisposable
|
|
|
|
/// <summary>
|
|
/// Dispose
|
|
/// </summary>
|
|
public override void Dispose()
|
|
{
|
|
ImagePadding = null;
|
|
SymbolDef = null;
|
|
|
|
base.Dispose();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#region VisualPropertyChangedEventArgs
|
|
|
|
/// <summary>
|
|
/// Represents visual property changed event arguments.
|
|
/// </summary>
|
|
public class VisualPropertyChangedEventArgs : PropertyChangedEventArgs
|
|
{
|
|
#region Public data
|
|
|
|
/// <summary>
|
|
/// Gets the change type.
|
|
/// </summary>
|
|
public readonly VisualChangeType ChangeType;
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the VisualPropertyChangedEventArgs class.
|
|
/// </summary>
|
|
public VisualPropertyChangedEventArgs(string propertyName)
|
|
: base(propertyName)
|
|
{
|
|
ChangeType = VisualChangeType.Layout;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the VisualPropertyChangedEventArgs class.
|
|
/// </summary>
|
|
public VisualPropertyChangedEventArgs(string propertyName, VisualChangeType changeType)
|
|
: base(propertyName)
|
|
{
|
|
ChangeType = changeType;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|