1550 lines
44 KiB
C#
1550 lines
44 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Design;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.SuperGrid.Style;
|
|
using DevComponents.SuperGrid.TextMarkup;
|
|
|
|
namespace DevComponents.DotNetBar.SuperGrid
|
|
{
|
|
/// <summary>
|
|
/// Defines the grid column header
|
|
/// </summary>
|
|
[TypeConverter(typeof(BlankExpandableObjectConverter))]
|
|
public abstract class GridTextRow : GridElement
|
|
{
|
|
#region Private variables
|
|
|
|
private string _Text;
|
|
private bool _EnableMarkup = true;
|
|
private BodyElement _TextMarkup;
|
|
|
|
private int _RowHeight;
|
|
|
|
private HeaderArea _HitArea;
|
|
private HeaderArea _MouseDownHitArea;
|
|
|
|
private RowHeaderVisibility
|
|
_RowHeaderVisibility = RowHeaderVisibility.PanelControlled;
|
|
|
|
private TextRowVisualStyles _EffectiveRowStyles;
|
|
private int _StyleUpdateCount;
|
|
|
|
private Image _BackgroundImage;
|
|
private GridBackgroundImageLayout _BackgroundImageLayout = GridBackgroundImageLayout.Tile;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
///<summary>
|
|
/// GridHeader
|
|
///</summary>
|
|
protected GridTextRow()
|
|
{
|
|
}
|
|
|
|
///<summary>
|
|
/// GridHeader
|
|
///</summary>
|
|
///<param name="text"></param>
|
|
protected GridTextRow(string text)
|
|
{
|
|
_Text = text;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region BackgroundImage
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Background Image
|
|
/// </summary>
|
|
[DefaultValue(null), Category("Appearance")]
|
|
[Description("Indicates the Background Image")]
|
|
public Image BackgroundImage
|
|
{
|
|
get { return (_BackgroundImage); }
|
|
|
|
set
|
|
{
|
|
if (_BackgroundImage != value)
|
|
{
|
|
_BackgroundImage = value;
|
|
|
|
OnPropertyChangedEx("BackgroundImage", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BackgroundImageLayout
|
|
|
|
/// <summary>
|
|
/// Gets or sets the layout of the Background Image
|
|
/// </summary>
|
|
[DefaultValue(GridBackgroundImageLayout.Tile), Category("Appearance")]
|
|
[Description("Indicates the layout of the Background Image")]
|
|
public GridBackgroundImageLayout BackgroundImageLayout
|
|
{
|
|
get { return (_BackgroundImageLayout); }
|
|
|
|
set
|
|
{
|
|
if (_BackgroundImageLayout != value)
|
|
{
|
|
_BackgroundImageLayout = value;
|
|
|
|
OnPropertyChangedEx("BackgroundImageLayout", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Bounds
|
|
|
|
///<summary>
|
|
/// Gets the scroll adjusted bounds
|
|
///</summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public override Rectangle Bounds
|
|
{
|
|
get
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
Rectangle r = BoundsRelative;
|
|
|
|
if (panel.IsSubPanel == true)
|
|
{
|
|
r.X -= HScrollOffset;
|
|
|
|
if (IsVFrozen == false)
|
|
r.Y -= VScrollOffset;
|
|
}
|
|
|
|
return (r);
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region EnableMarkup
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether text-markup support is enabled
|
|
/// </summary>
|
|
[DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether text-markup support is enabled.")]
|
|
public bool EnableMarkup
|
|
{
|
|
get { return (_EnableMarkup); }
|
|
|
|
set
|
|
{
|
|
if (_EnableMarkup != value)
|
|
{
|
|
_EnableMarkup = value;
|
|
|
|
MarkupTextChanged();
|
|
|
|
OnPropertyChangedEx("EnableMarkup", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ImageBounds
|
|
|
|
/// <summary>
|
|
/// Gets whether the item is empty
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public Rectangle ImageBounds
|
|
{
|
|
get
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
TextRowVisualStyle style = GetEffectiveStyle();
|
|
|
|
object figure = style.GetFigure(panel);
|
|
|
|
if (figure != null)
|
|
{
|
|
Rectangle tb, ib;
|
|
GetItemBounds(panel, style, Bounds, out tb, out ib);
|
|
|
|
return (ib);
|
|
}
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsEmpty
|
|
|
|
/// <summary>
|
|
/// Gets whether the item is empty
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public virtual bool IsEmpty
|
|
{
|
|
get { return (string.IsNullOrEmpty(_Text) == true); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RowHeight
|
|
|
|
/// <summary>
|
|
/// Gets or sets the row height (0 to auto-size)
|
|
/// </summary>
|
|
[DefaultValue(0), Category("Appearance")]
|
|
[Description("Indicates the row height (0 to auto-size)")]
|
|
public int RowHeight
|
|
{
|
|
get { return (_RowHeight); }
|
|
|
|
set
|
|
{
|
|
if (_RowHeight != value)
|
|
{
|
|
_RowHeight = value;
|
|
|
|
OnPropertyChangedEx("RowHeight", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RowHeaderVisibility
|
|
|
|
/// <summary>
|
|
/// Gets or sets whether the RowHeader is displayed
|
|
/// </summary>
|
|
[DefaultValue(RowHeaderVisibility.PanelControlled), Category("Appearance")]
|
|
[Description("Indicates whether the RowHeader is displayed")]
|
|
public virtual RowHeaderVisibility RowHeaderVisibility
|
|
{
|
|
get { return (_RowHeaderVisibility); }
|
|
|
|
set
|
|
{
|
|
if (value != _RowHeaderVisibility)
|
|
{
|
|
_RowHeaderVisibility = value;
|
|
|
|
OnPropertyChangedEx("RowHeaderVisibility", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Text
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Text
|
|
/// </summary>
|
|
[Localizable(true), DefaultValue(null), Category("Appearance")]
|
|
[Description("Indicates the Text.")]
|
|
[Editor("DevComponents.DotNetBar.Design.TextMarkupUIEditor, DevComponents.DotNetBar.Design, Version=14.1.0.37, Culture=neutral, PublicKeyToken=90f470f34c89ccaf", typeof(UITypeEditor))]
|
|
public string Text
|
|
{
|
|
get { return (_Text); }
|
|
|
|
set
|
|
{
|
|
if (_Text != value)
|
|
{
|
|
_Text = value;
|
|
|
|
MarkupTextChanged();
|
|
|
|
OnPropertyChangedEx("Text", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region MeasureOverride
|
|
|
|
/// <summary>
|
|
/// Performs the layout of the item and sets the Size property to size that item will take.
|
|
/// </summary>
|
|
/// <param name="layoutInfo">Layout information.</param>
|
|
/// <param name="stateInfo"></param>
|
|
/// <param name="constraintSize"></param>
|
|
protected override void MeasureOverride(
|
|
GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize)
|
|
{
|
|
Size sizeNeeded = MeasureRow(layoutInfo, stateInfo, constraintSize);
|
|
|
|
if (constraintSize.Width > 0)
|
|
sizeNeeded.Width = constraintSize.Width;
|
|
|
|
Size = sizeNeeded;
|
|
}
|
|
|
|
#region MeasureRow
|
|
|
|
/// <summary>
|
|
/// MeasureRow
|
|
/// </summary>
|
|
/// <param name="layoutInfo"></param>
|
|
/// <param name="stateInfo"></param>
|
|
/// <param name="constraintSize"></param>
|
|
/// <returns></returns>
|
|
protected virtual Size MeasureRow(
|
|
GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize)
|
|
{
|
|
Size sizeNeeded = Size.Empty;
|
|
|
|
if (RowHeight > 0 || IsEmpty == false)
|
|
{
|
|
GridPanel panel = stateInfo.GridPanel;
|
|
|
|
TextRowVisualStyle style = GetSizingStyle(panel);
|
|
Size figureSize = style.GetFigureSize(panel);
|
|
|
|
Alignment imageAlignment = style.ImageAlignment;
|
|
|
|
if (style.IsOverlayImage == true)
|
|
imageAlignment = Alignment.MiddleCenter;
|
|
|
|
int width = constraintSize.Width;
|
|
|
|
if (width > 0)
|
|
{
|
|
if (panel.IsSubPanel == false)
|
|
width = ViewRect.Width;
|
|
|
|
if (CanShowRowHeader(panel) == true)
|
|
width -= panel.RowHeaderWidthEx;
|
|
|
|
switch (imageAlignment)
|
|
{
|
|
case Alignment.TopCenter:
|
|
case Alignment.MiddleCenter:
|
|
case Alignment.BottomCenter:
|
|
break;
|
|
|
|
default:
|
|
width -= figureSize.Width;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Size borderSize = style.GetBorderSize(true);
|
|
|
|
if (constraintSize.Width > 0)
|
|
width -= borderSize.Width;
|
|
|
|
Size size = GetTextSize(layoutInfo, style, width);
|
|
|
|
switch (imageAlignment)
|
|
{
|
|
case Alignment.MiddleCenter:
|
|
sizeNeeded.Height = Math.Max(figureSize.Height, size.Height) + borderSize.Height;
|
|
sizeNeeded.Width = Math.Max(size.Width, figureSize.Width) + borderSize.Width;
|
|
break;
|
|
|
|
case Alignment.TopCenter:
|
|
case Alignment.BottomCenter:
|
|
sizeNeeded.Width = Math.Max(size.Width, figureSize.Width) + borderSize.Width;
|
|
sizeNeeded.Height = size.Height + figureSize.Height + borderSize.Height;
|
|
break;
|
|
|
|
default:
|
|
sizeNeeded.Width = size.Width + figureSize.Width + borderSize.Width;
|
|
sizeNeeded.Height = Math.Max(figureSize.Height, size.Height) + borderSize.Height;
|
|
break;
|
|
}
|
|
|
|
if (RowHeight > 0)
|
|
sizeNeeded.Height = Dpi.Width(RowHeight);
|
|
else
|
|
sizeNeeded.Height += Dpi.Width1;
|
|
}
|
|
|
|
return (sizeNeeded);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetTextSize
|
|
|
|
private Size GetTextSize(
|
|
GridLayoutInfo layoutInfo, TextRowVisualStyle style, int width)
|
|
{
|
|
Size size = Size.Empty;
|
|
|
|
if (string.IsNullOrEmpty(_Text) == false)
|
|
{
|
|
if (_TextMarkup != null)
|
|
{
|
|
size = GetMarkupTextSize(layoutInfo, style, width);
|
|
}
|
|
else
|
|
{
|
|
eTextFormat tf = style.GetTextFormatFlags();
|
|
|
|
if (width <= 0)
|
|
{
|
|
if (style.AllowWrap == Tbool.True)
|
|
tf &= ~eTextFormat.WordBreak;
|
|
}
|
|
|
|
size = TextHelper.MeasureText(
|
|
layoutInfo.Graphics, _Text, style.Font, new Size(width, 0), tf);
|
|
}
|
|
}
|
|
|
|
return (size);
|
|
}
|
|
|
|
#region GetMarkupTextSize
|
|
|
|
private Size GetMarkupTextSize(
|
|
GridLayoutInfo layoutInfo, TextRowVisualStyle style, int width)
|
|
{
|
|
Graphics g = layoutInfo.Graphics;
|
|
|
|
MarkupDrawContext d =
|
|
new MarkupDrawContext(g, style.Font, style.TextColor, false);
|
|
|
|
_TextMarkup.InvalidateElementsSize();
|
|
_TextMarkup.Measure(new Size(width, 0), d);
|
|
|
|
return (_TextMarkup.Bounds.Size);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetSizingStyle
|
|
|
|
/// <summary>
|
|
/// GetSizingStyle
|
|
/// </summary>
|
|
/// <param name="panel"></param>
|
|
/// <returns></returns>
|
|
protected TextRowVisualStyle GetSizingStyle(GridPanel panel)
|
|
{
|
|
StyleType style = panel.GetSizingStyle();
|
|
|
|
if (style == StyleType.NotSet)
|
|
style = StyleType.Default;
|
|
|
|
return (GetEffectiveStyle(style));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ArrangeOverride
|
|
|
|
/// <summary>
|
|
/// Performs the arrange pass layout of the item
|
|
/// when final position and size of the item has been set
|
|
/// </summary>
|
|
/// <param name="layoutInfo">Layout information.</param>
|
|
/// <param name="stateInfo"></param>
|
|
/// <param name="layoutBounds">Layout bounds</param>
|
|
protected override void ArrangeOverride(GridLayoutInfo layoutInfo,
|
|
GridLayoutStateInfo stateInfo, Rectangle layoutBounds)
|
|
{
|
|
Size = ArrangeRow(layoutInfo, stateInfo, layoutBounds);
|
|
}
|
|
|
|
/// <summary>
|
|
/// ArrangeRow
|
|
/// </summary>
|
|
/// <param name="layoutInfo"></param>
|
|
/// <param name="stateInfo"></param>
|
|
/// <param name="layoutBounds"></param>
|
|
/// <returns></returns>
|
|
protected virtual Size ArrangeRow(GridLayoutInfo layoutInfo,
|
|
GridLayoutStateInfo stateInfo, Rectangle layoutBounds)
|
|
{
|
|
Size size = Size;
|
|
|
|
size.Width = stateInfo.GridPanel.ColumnHeader.BoundsRelative.Width;
|
|
|
|
return (size);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderOverride
|
|
|
|
/// <summary>
|
|
/// Performs drawing of the item and its children.
|
|
/// </summary>
|
|
/// <param name="renderInfo">Holds contextual rendering information.</param>
|
|
protected override void RenderOverride(GridRenderInfo renderInfo)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
Rectangle bounds = Bounds;
|
|
|
|
if (bounds.Height > 0)
|
|
{
|
|
Rectangle r = bounds;
|
|
r.Inflate(2, 2);
|
|
|
|
if (r.IntersectsWith(renderInfo.ClipRectangle))
|
|
RenderRow(renderInfo, panel, bounds);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region RenderRow
|
|
|
|
/// <summary>
|
|
/// RenderRow
|
|
/// </summary>
|
|
/// <param name="renderInfo"></param>
|
|
/// <param name="panel"></param>
|
|
/// <param name="r"></param>
|
|
protected virtual void RenderRow(
|
|
GridRenderInfo renderInfo, GridPanel panel, Rectangle r)
|
|
{
|
|
Graphics g = renderInfo.Graphics;
|
|
|
|
TextRowVisualStyle style = GetEffectiveStyle();
|
|
GridPanelVisualStyle pstyle = panel.GetEffectiveStyle();
|
|
|
|
object figure = style.GetFigure(panel);
|
|
|
|
Rectangle tb, ib;
|
|
r = GetItemBounds(panel, style, r, out tb, out ib);
|
|
|
|
if (r.Width > 1 && r.Height > 1)
|
|
{
|
|
if (SuperGrid.DoPreRenderTextRowEvent(g, this, RenderParts.Background, r) == false)
|
|
{
|
|
RenderRowBackground(g, style, r);
|
|
SuperGrid.DoPostRenderTextRowEvent(g, this, RenderParts.Background, r);
|
|
}
|
|
|
|
RenderBorder(g, panel, pstyle, r);
|
|
|
|
if (SuperGrid.DoPreRenderTextRowEvent(g, this, RenderParts.Border, r) == false)
|
|
{
|
|
RenderRowBorder(g, style, r);
|
|
SuperGrid.DoPostRenderTextRowEvent(g, this, RenderParts.Border, r);
|
|
}
|
|
}
|
|
|
|
if (style.ImageOverlay != ImageOverlay.Top)
|
|
style.RenderFigure(g, panel, ib);
|
|
|
|
if (tb.Width > 0 && tb.Height > 0)
|
|
{
|
|
if (SuperGrid.DoPreRenderTextRowEvent(g, this, RenderParts.Content, r) == false)
|
|
{
|
|
RenderRowText(g, style, tb);
|
|
SuperGrid.DoPostRenderTextRowEvent(g, this, RenderParts.Content, tb);
|
|
}
|
|
}
|
|
|
|
if (ib.Width > 0 && ib.Height > 0)
|
|
{
|
|
if (style.ImageOverlay == ImageOverlay.Top)
|
|
style.RenderFigure(g, panel, ib);
|
|
}
|
|
|
|
if (SuperGrid.DoPreRenderTextRowEvent(g, this, RenderParts.RowHeader, r) == false)
|
|
{
|
|
RenderRowHeader(g, panel, pstyle, r);
|
|
SuperGrid.DoPostRenderTextRowEvent(g, this, RenderParts.RowHeader, r);
|
|
}
|
|
}
|
|
|
|
#region GetItemBounds
|
|
|
|
private Rectangle GetItemBounds(GridPanel panel,
|
|
TextRowVisualStyle style, Rectangle r, out Rectangle tb, out Rectangle ib)
|
|
{
|
|
Rectangle v = ViewRect;
|
|
|
|
if (panel.IsSubPanel == false)
|
|
{
|
|
r.X = Math.Max(r.X, v.X);
|
|
r.Width = v.Width;
|
|
}
|
|
|
|
if (CanShowRowHeader(panel) == true)
|
|
{
|
|
r.X += panel.RowHeaderWidthEx;
|
|
r.Width -= panel.RowHeaderWidthEx;
|
|
}
|
|
|
|
tb = GetAdjustedBounds(style, style.GetNonFigureBounds(panel, r));
|
|
ib = style.GetFigureBounds(panel, tb);
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetAdjustedBounds
|
|
|
|
private Rectangle GetAdjustedBounds(TextRowVisualStyle style, Rectangle r)
|
|
{
|
|
r.X += (style.BorderThickness.Left + style.Margin.Left + style.Padding.Left);
|
|
r.Width -= (style.BorderThickness.Horizontal + style.Margin.Horizontal + style.Padding.Horizontal + 1);
|
|
|
|
r.Y += (style.BorderThickness.Top + style.Margin.Top + style.Padding.Top);
|
|
r.Height -= (style.BorderThickness.Vertical + style.Margin.Vertical + style.Padding.Vertical + 1);
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderRowBackground
|
|
|
|
/// <summary>
|
|
/// RenderRowBackground
|
|
/// </summary>
|
|
/// <param name="g"></param>
|
|
/// <param name="style"></param>
|
|
/// <param name="r"></param>
|
|
protected void RenderRowBackground(
|
|
Graphics g, TextRowVisualStyle style, Rectangle r)
|
|
{
|
|
r.Width--;
|
|
r.Height--;
|
|
|
|
using (Brush br = style.Background.GetBrush(r))
|
|
g.FillRectangle(br, r);
|
|
|
|
if (_BackgroundImage != null)
|
|
{
|
|
Rectangle sr = r;
|
|
sr.Location = Point.Empty;
|
|
|
|
switch (_BackgroundImageLayout)
|
|
{
|
|
case GridBackgroundImageLayout.TopRight:
|
|
OffsetRight(ref sr, ref r);
|
|
g.DrawImage(_BackgroundImage, r, sr, GraphicsUnit.Pixel);
|
|
break;
|
|
|
|
case GridBackgroundImageLayout.BottomLeft:
|
|
OffsetBottom(ref sr, ref r);
|
|
g.DrawImage(_BackgroundImage, r, sr, GraphicsUnit.Pixel);
|
|
break;
|
|
|
|
case GridBackgroundImageLayout.BottomRight:
|
|
OffsetRight(ref sr, ref r);
|
|
OffsetBottom(ref sr, ref r);
|
|
g.DrawImage(_BackgroundImage, r, sr, GraphicsUnit.Pixel);
|
|
break;
|
|
|
|
case GridBackgroundImageLayout.Center:
|
|
RenderImageCentered(g, _BackgroundImage, r);
|
|
break;
|
|
|
|
case GridBackgroundImageLayout.Stretch:
|
|
g.DrawImage(_BackgroundImage, r);
|
|
break;
|
|
|
|
case GridBackgroundImageLayout.Zoom:
|
|
RenderImageScaled(g, _BackgroundImage, r);
|
|
break;
|
|
|
|
case GridBackgroundImageLayout.Tile:
|
|
using (TextureBrush tbr = new TextureBrush(_BackgroundImage))
|
|
{
|
|
tbr.TranslateTransform(r.X, r.Y);
|
|
g.FillRectangle(tbr, r);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
g.DrawImage(_BackgroundImage, r, sr, GraphicsUnit.Pixel);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#region OffsetRight
|
|
|
|
private void OffsetRight(ref Rectangle sr, ref Rectangle r)
|
|
{
|
|
if (_BackgroundImage.Width > r.Width)
|
|
sr.X += (_BackgroundImage.Width - r.Width);
|
|
else
|
|
r.X += (r.Width - _BackgroundImage.Width);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region OffsetBottom
|
|
|
|
private void OffsetBottom(ref Rectangle sr, ref Rectangle r)
|
|
{
|
|
if (_BackgroundImage.Height > r.Height)
|
|
sr.Y += (_BackgroundImage.Height - r.Height);
|
|
else
|
|
r.Y += (r.Height - _BackgroundImage.Height);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderImageCentered
|
|
|
|
private void RenderImageCentered(Graphics g, Image image, Rectangle r)
|
|
{
|
|
Rectangle sr = r;
|
|
sr.Location = Point.Empty;
|
|
|
|
if (image.Width > r.Width)
|
|
sr.X += (image.Width - r.Width) / 2;
|
|
else
|
|
r.X += (r.Width - image.Width) / 2;
|
|
|
|
if (image.Height > r.Height)
|
|
sr.Y += (image.Height - r.Height) / 2;
|
|
else
|
|
r.Y += (r.Height - image.Height) / 2;
|
|
|
|
g.DrawImage(image, r, sr, GraphicsUnit.Pixel);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderImageScaled
|
|
|
|
private void RenderImageScaled(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;
|
|
|
|
g.DrawImage(image, r.X + (r.Width - size.Width) / 2,
|
|
r.Y + (r.Height - size.Height) / 2,
|
|
size.Width, size.Height);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RenderBorder
|
|
|
|
/// <summary>
|
|
/// RenderBorder
|
|
/// </summary>
|
|
/// <param name="g"></param>
|
|
/// <param name="panel"></param>
|
|
/// <param name="pstyle"></param>
|
|
/// <param name="r"></param>
|
|
protected virtual void RenderBorder(Graphics g,
|
|
GridPanel panel, GridPanelVisualStyle pstyle, Rectangle r)
|
|
{
|
|
using (Pen pen = new Pen(pstyle.HeaderLineColor))
|
|
{
|
|
g.DrawLine(pen, r.X, r.Y - 1, r.Right - 1, r.Y - 1);
|
|
g.DrawLine(pen, r.X, r.Bottom - 1, r.Right - 1, r.Bottom - 1);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderRowBorder
|
|
|
|
/// <summary>
|
|
/// RenderRowBorder
|
|
/// </summary>
|
|
/// <param name="g"></param>
|
|
/// <param name="style"></param>
|
|
/// <param name="r"></param>
|
|
protected void RenderRowBorder(Graphics g, TextRowVisualStyle style, Rectangle r)
|
|
{
|
|
if (style.BorderPattern == null ||
|
|
style.BorderThickness == null || style.BorderColor == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Rectangle t = r;
|
|
t.X += style.Margin.Left;
|
|
t.Width -= style.Margin.Horizontal;
|
|
|
|
t.Y += style.Margin.Top;
|
|
t.Height -= style.Margin.Vertical;
|
|
|
|
if (style.BorderColor.IsUniform == true &&
|
|
style.BorderThickness.IsUniform == true && style.BorderPattern.IsUniform == true)
|
|
{
|
|
if (style.BorderThickness.Top > 0 && style.BorderColor.Top.IsEmpty == false)
|
|
{
|
|
t.Width -= style.BorderThickness.Top;
|
|
t.Height -= style.BorderThickness.Top;
|
|
|
|
using (Pen pen = new
|
|
Pen(style.BorderColor.Top, style.BorderThickness.Top))
|
|
{
|
|
LinePattern pattern = (style.BorderPattern.Top == LinePattern.NotSet)
|
|
? LinePattern.Solid : style.BorderPattern.Top;
|
|
|
|
pen.DashStyle = (DashStyle)pattern;
|
|
|
|
g.DrawRectangle(pen, t);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Pen[] pens = style.GetBorderPens();
|
|
|
|
if (pens[(int)BorderSide.Right] != null)
|
|
{
|
|
int right = t.Right - (style.BorderThickness.Right / 2);
|
|
|
|
g.DrawLine(pens[(int)BorderSide.Right], right, t.Top, right, t.Bottom);
|
|
}
|
|
|
|
if (pens[(int)BorderSide.Bottom] != null)
|
|
{
|
|
int bottom = t.Bottom - ((style.BorderThickness.Bottom - 1) / 2);
|
|
|
|
g.DrawLine(pens[(int)BorderSide.Bottom], t.X, bottom, t.Right, bottom);
|
|
}
|
|
|
|
if (pens[(int)BorderSide.Left] != null)
|
|
g.DrawLine(pens[(int)BorderSide.Left], t.X, t.Top, t.X, t.Bottom);
|
|
|
|
if (pens[(int)BorderSide.Top] != null)
|
|
g.DrawLine(pens[(int)BorderSide.Top], t.X, t.Top, t.Right, t.Top);
|
|
|
|
foreach (Pen pen in pens)
|
|
{
|
|
if (pen != null)
|
|
pen.Dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderRowText
|
|
|
|
/// <summary>
|
|
/// RenderRowText
|
|
/// </summary>
|
|
/// <param name="g"></param>
|
|
/// <param name="style"></param>
|
|
/// <param name="r"></param>
|
|
protected void RenderRowText(Graphics g,
|
|
TextRowVisualStyle style, Rectangle r)
|
|
{
|
|
string s = _Text;
|
|
|
|
if (string.IsNullOrEmpty(s) == false)
|
|
{
|
|
if (r.Width > 0 && r.Height > 0)
|
|
{
|
|
if (_TextMarkup != null)
|
|
{
|
|
RenderTextMarkup(g, style, r);
|
|
}
|
|
else
|
|
{
|
|
eTextFormat tf = style.GetTextFormatFlags();
|
|
|
|
TextDrawing.DrawString(g, s, style.Font, style.TextColor, r, tf);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region RenderTextMarkup
|
|
|
|
private void RenderTextMarkup(
|
|
Graphics g, TextRowVisualStyle style, Rectangle r)
|
|
{
|
|
MarkupDrawContext d =
|
|
new MarkupDrawContext(g, style.Font, style.TextColor, false);
|
|
|
|
_TextMarkup.Arrange(new Rectangle(r.Location, r.Size), d);
|
|
|
|
Size size = _TextMarkup.Bounds.Size;
|
|
|
|
switch (style.Alignment)
|
|
{
|
|
case Alignment.MiddleLeft:
|
|
case Alignment.MiddleCenter:
|
|
case Alignment.MiddleRight:
|
|
if (r.Height > size.Height)
|
|
r.Y += (r.Height - size.Height)/2;
|
|
break;
|
|
|
|
default:
|
|
if (r.Height > size.Height)
|
|
r.Y = r.Bottom - size.Height;
|
|
break;
|
|
}
|
|
|
|
_TextMarkup.Bounds = new Rectangle(r.Location, size);
|
|
|
|
Region oldClip = g.Clip;
|
|
|
|
try
|
|
{
|
|
g.SetClip(r, CombineMode.Intersect);
|
|
|
|
_TextMarkup.Render(d);
|
|
}
|
|
finally
|
|
{
|
|
g.Clip = oldClip;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RenderRowHeader
|
|
|
|
/// <summary>
|
|
/// RenderRowHeader
|
|
/// </summary>
|
|
/// <param name="g"></param>
|
|
/// <param name="panel"></param>
|
|
/// <param name="pstyle"></param>
|
|
/// <param name="r"></param>
|
|
protected virtual void RenderRowHeader(Graphics g,
|
|
GridPanel panel, GridPanelVisualStyle pstyle, Rectangle r)
|
|
{
|
|
if (CanShowRowHeader(panel) == true)
|
|
{
|
|
r.X -= panel.RowHeaderWidthEx;
|
|
r.Width = panel.RowHeaderWidthEx - 1;
|
|
|
|
if (r.Width > 0 && r.Height > 0)
|
|
{
|
|
TextRowVisualStyle style = GetEffectiveRowHeaderStyle();
|
|
|
|
using (Brush br = style.RowHeaderStyle.Background.GetBrush(r))
|
|
{
|
|
if (br != null)
|
|
g.FillRectangle(br, r);
|
|
}
|
|
|
|
if (Dpi.Width1 == Dpi.Height1)
|
|
{
|
|
using (Pen pen = new Pen(style.RowHeaderStyle.BorderHighlightColor, Dpi.Height1))
|
|
{
|
|
g.DrawLine(pen, r.X, r.Y, r.Right, r.Y);
|
|
|
|
g.DrawLine(pen, r.X, r.Y, r.X, r.Bottom);
|
|
}
|
|
|
|
using (Pen pen = new Pen(pstyle.HeaderLineColor, Dpi.Height1))
|
|
{
|
|
g.DrawLine(pen, r.X, r.Y - 1, r.Right, r.Y - 1);
|
|
g.DrawLine(pen, r.X, r.Bottom - 1, r.Right, r.Bottom - 1);
|
|
|
|
g.DrawLine(pen, r.Right, r.Y, r.Right, r.Bottom - 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
using (Pen pen = new Pen(style.RowHeaderStyle.BorderHighlightColor, Dpi.Height1))
|
|
g.DrawLine(pen, r.X, r.Y, r.Right, r.Y);
|
|
|
|
using (Pen pen = new Pen(style.RowHeaderStyle.BorderHighlightColor, Dpi.Width1))
|
|
g.DrawLine(pen, r.X, r.Y, r.X, r.Bottom);
|
|
|
|
using (Pen pen = new Pen(pstyle.HeaderLineColor, Dpi.Height1))
|
|
{
|
|
g.DrawLine(pen, r.X, r.Y - 1, r.Right, r.Y - 1);
|
|
g.DrawLine(pen, r.X, r.Bottom - 1, r.Right, r.Bottom - 1);
|
|
}
|
|
|
|
using (Pen pen = new Pen(pstyle.HeaderLineColor, Dpi.Width1))
|
|
g.DrawLine(pen, r.Right, r.Y, r.Right, r.Bottom - 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Mouse events
|
|
|
|
#region InternalMouseEnter
|
|
|
|
internal override void InternalMouseEnter(EventArgs e)
|
|
{
|
|
base.InternalMouseEnter(e);
|
|
|
|
InvalidateRender();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseLeave
|
|
|
|
internal override void InternalMouseLeave(EventArgs e)
|
|
{
|
|
_HitArea = HeaderArea.NoWhere;
|
|
|
|
InvalidateRender();
|
|
|
|
base.InternalMouseLeave(e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseMove
|
|
|
|
internal override void InternalMouseMove(MouseEventArgs e)
|
|
{
|
|
SuperGrid.GridCursor = Cursors.Default;
|
|
|
|
HeaderArea area = GetHitArea(e.Location);
|
|
|
|
if (_HitArea != area)
|
|
{
|
|
_HitArea = area;
|
|
|
|
InvalidateRender();
|
|
}
|
|
|
|
if (AllowSelection == true)
|
|
{
|
|
if (_TextMarkup != null)
|
|
_TextMarkup.MouseMove(SuperGrid, e);
|
|
}
|
|
|
|
base.InternalMouseMove(e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseDown
|
|
|
|
internal override void InternalMouseDown(MouseEventArgs e)
|
|
{
|
|
_MouseDownHitArea = _HitArea;
|
|
|
|
base.InternalMouseDown(e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseUp
|
|
|
|
internal override void InternalMouseUp(MouseEventArgs e)
|
|
{
|
|
if (AllowSelection == true)
|
|
{
|
|
if (_HitArea == _MouseDownHitArea)
|
|
{
|
|
switch (_HitArea)
|
|
{
|
|
case HeaderArea.InRowHeader:
|
|
SuperGrid.DoTextRowHeaderClickEvent(this, e);
|
|
break;
|
|
|
|
case HeaderArea.InContent:
|
|
SuperGrid.DoTextRowClickEvent(this, e);
|
|
break;
|
|
|
|
case HeaderArea.InMarkup:
|
|
SuperGrid.DoTextRowClickEvent(this, e);
|
|
|
|
if (_TextMarkup != null)
|
|
_TextMarkup.Click(SuperGrid);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
base.InternalMouseUp(e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region CanShowRowHeader
|
|
|
|
/// <summary>
|
|
/// CanShowRowHeader
|
|
/// </summary>
|
|
/// <param name="panel"></param>
|
|
/// <returns></returns>
|
|
protected virtual bool CanShowRowHeader(GridPanel panel)
|
|
{
|
|
switch (_RowHeaderVisibility)
|
|
{
|
|
case RowHeaderVisibility.Always:
|
|
return (true);
|
|
|
|
case RowHeaderVisibility.PanelControlled:
|
|
return (panel.ShowRowHeaders);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetHitArea
|
|
|
|
///<summary>
|
|
/// GetHitArea
|
|
///</summary>
|
|
///<param name="pt"></param>
|
|
///<returns></returns>
|
|
public virtual HeaderArea GetHitArea(Point pt)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
if (CanShowRowHeader(panel) == true)
|
|
{
|
|
Rectangle r = GetRowHeaderBounds(panel);
|
|
|
|
if (r.Contains(pt) == true)
|
|
return (HeaderArea.InRowHeader);
|
|
}
|
|
}
|
|
|
|
if (_TextMarkup != null)
|
|
{
|
|
if (_TextMarkup.MouseOverElement != null)
|
|
return (HeaderArea.InMarkup);
|
|
}
|
|
|
|
return (HeaderArea.InContent);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetRowHeaderBounds
|
|
|
|
private Rectangle GetRowHeaderBounds(GridPanel panel)
|
|
{
|
|
if (panel.ShowRowHeaders == true)
|
|
{
|
|
Rectangle r = BoundsRelative;
|
|
|
|
r.Location = panel.PointToScroll(r.Location);
|
|
r.Width = Dpi.Width(panel.RowHeaderWidthEx + 2);
|
|
|
|
return (r);
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Style support routines
|
|
|
|
#region GetEffectiveStyle
|
|
|
|
internal TextRowVisualStyle GetEffectiveStyle()
|
|
{
|
|
ValidateRowStyle();
|
|
|
|
StyleState rowState = GetRowState();
|
|
|
|
switch (rowState)
|
|
{
|
|
case StyleState.MouseOver:
|
|
return (GetStyleEx(StyleType.MouseOver));
|
|
|
|
case StyleState.Selected:
|
|
return (GetStyleEx(StyleType.Selected));
|
|
|
|
case StyleState.Selected | StyleState.MouseOver:
|
|
return (GetStyleEx(StyleType.SelectedMouseOver));
|
|
|
|
case StyleState.ReadOnly:
|
|
return (GetStyleEx(StyleType.ReadOnly));
|
|
|
|
case StyleState.ReadOnly | StyleState.MouseOver:
|
|
return (GetStyleEx(StyleType.ReadOnlyMouseOver));
|
|
|
|
case StyleState.ReadOnly | StyleState.Selected:
|
|
return (GetStyleEx(StyleType.ReadOnlySelected));
|
|
|
|
case StyleState.ReadOnly | StyleState.MouseOver | StyleState.Selected:
|
|
return (GetStyleEx(StyleType.ReadOnlySelectedMouseOver));
|
|
|
|
default:
|
|
return (GetStyleEx(StyleType.Default));
|
|
}
|
|
}
|
|
|
|
internal TextRowVisualStyle GetEffectiveStyle(StyleType type)
|
|
{
|
|
ValidateRowStyle();
|
|
|
|
return (GetStyleEx(type));
|
|
}
|
|
|
|
#region GetRowState
|
|
|
|
private StyleState GetRowState()
|
|
{
|
|
StyleState rowState = StyleState.Default;
|
|
|
|
if (IsMouseOver == true)
|
|
rowState |= StyleState.MouseOver;
|
|
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
if (panel == SuperGrid.ActiveGrid)
|
|
rowState |= StyleState.Selected;
|
|
|
|
if (panel.ReadOnly == true)
|
|
rowState |= StyleState.ReadOnly;
|
|
}
|
|
|
|
return (rowState);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetEffectiveRowHeaderStyle
|
|
|
|
internal TextRowVisualStyle GetEffectiveRowHeaderStyle()
|
|
{
|
|
ValidateRowStyle();
|
|
|
|
StyleState rowState = GetRowHeaderState();
|
|
|
|
switch (rowState)
|
|
{
|
|
case StyleState.MouseOver:
|
|
return (GetStyleEx(StyleType.MouseOver));
|
|
|
|
case StyleState.Selected:
|
|
return (GetStyleEx(StyleType.Selected));
|
|
|
|
case StyleState.Selected | StyleState.MouseOver:
|
|
return (GetStyleEx(StyleType.SelectedMouseOver));
|
|
|
|
case StyleState.ReadOnly:
|
|
return (GetStyleEx(StyleType.ReadOnly));
|
|
|
|
case StyleState.ReadOnly | StyleState.MouseOver:
|
|
return (GetStyleEx(StyleType.ReadOnlyMouseOver));
|
|
|
|
case StyleState.ReadOnly | StyleState.Selected:
|
|
return (GetStyleEx(StyleType.ReadOnlySelected));
|
|
|
|
case StyleState.ReadOnly | StyleState.MouseOver | StyleState.Selected:
|
|
return (GetStyleEx(StyleType.ReadOnlySelectedMouseOver));
|
|
|
|
default:
|
|
return (GetStyleEx(StyleType.Default));
|
|
}
|
|
}
|
|
|
|
#region GetRowHeaderState
|
|
|
|
private StyleState GetRowHeaderState()
|
|
{
|
|
StyleState rowState = StyleState.Default;
|
|
|
|
if (_HitArea == HeaderArea.InRowHeader)
|
|
rowState |= StyleState.MouseOver;
|
|
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
if (panel.ReadOnly == true)
|
|
rowState |= StyleState.ReadOnly;
|
|
|
|
if (panel == SuperGrid.ActiveGrid)
|
|
rowState |= StyleState.Selected;
|
|
}
|
|
|
|
return (rowState);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetStyleEx
|
|
|
|
private TextRowVisualStyle GetStyleEx(StyleType e)
|
|
{
|
|
if (_EffectiveRowStyles.IsValid(e) == false)
|
|
{
|
|
TextRowVisualStyle style = GetNewVisualStyle();
|
|
|
|
StyleType[] css = style.GetApplyStyleTypes(e);
|
|
|
|
if (css != null)
|
|
ApplyStyleEx(style, css);
|
|
|
|
SuperGrid.DoGetTextRowStyleEvent(this, e, ref style);
|
|
|
|
if (style.Background == null || style.Background.IsEmpty == true)
|
|
style.Background = new Background(Color.White);
|
|
|
|
if (style.Font == null)
|
|
style.Font = SystemFonts.CaptionFont;
|
|
|
|
style.ApplyDefaults();
|
|
|
|
_EffectiveRowStyles[e] = style;
|
|
}
|
|
|
|
return (_EffectiveRowStyles[e]);
|
|
}
|
|
|
|
#region GetNewVisualStyle
|
|
|
|
/// <summary>
|
|
/// GetNewVisualStyle
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected virtual TextRowVisualStyle GetNewVisualStyle()
|
|
{
|
|
return (new TextRowVisualStyle());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ApplyStyleEx
|
|
|
|
/// <summary>
|
|
/// ApplyStyleEx
|
|
/// </summary>
|
|
/// <param name="style"></param>
|
|
/// <param name="css"></param>
|
|
protected virtual void ApplyStyleEx(TextRowVisualStyle style, StyleType[] css)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ValidateRowStyle
|
|
|
|
private void ValidateRowStyle()
|
|
{
|
|
if (_EffectiveRowStyles == null ||
|
|
(_StyleUpdateCount != SuperGrid.StyleUpdateCount))
|
|
{
|
|
_EffectiveRowStyles = new TextRowVisualStyles();
|
|
|
|
_StyleUpdateCount = SuperGrid.StyleUpdateCount;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region InvalidateRender
|
|
|
|
/// <summary>
|
|
/// InvalidateRender
|
|
/// </summary>
|
|
public override void InvalidateRender()
|
|
{
|
|
if (SuperGrid != null)
|
|
InvalidateRender(Bounds);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ToString
|
|
|
|
/// <summary>
|
|
/// ToString
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override string ToString()
|
|
{
|
|
string s = base.ToString();
|
|
|
|
if (String.IsNullOrEmpty(_Text) == false)
|
|
s += ": (\"" + _Text + "\")";
|
|
|
|
return (s);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Markup support
|
|
|
|
private void MarkupTextChanged()
|
|
{
|
|
_TextMarkup = null;
|
|
|
|
if (_EnableMarkup == true)
|
|
{
|
|
if (MarkupParser.IsMarkup(_Text) == true)
|
|
{
|
|
_TextMarkup = MarkupParser.Parse(_Text);
|
|
|
|
if (_TextMarkup != null)
|
|
_TextMarkup.HyperLinkClick += TextMarkupLinkClick;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Occurs when a text markup link is clicked
|
|
/// </summary>
|
|
protected virtual void TextMarkupLinkClick(object sender, EventArgs e)
|
|
{
|
|
HyperLink link = sender as HyperLink;
|
|
|
|
SuperGrid.DoTextRowMarkupLinkClickEvent(this, link);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets plain text without text-markup (if text-markup is used in Text)
|
|
/// </summary>
|
|
[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
|
|
public string PlainText
|
|
{
|
|
get { return (_TextMarkup != null ? _TextMarkup.PlainText : Text); }
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#region enums
|
|
|
|
#region GridBackgroundImageLayout
|
|
|
|
///<summary>
|
|
/// Background Image Layout
|
|
///</summary>
|
|
public enum GridBackgroundImageLayout
|
|
{
|
|
///<summary>
|
|
/// Image is Top Left aligned and unscaled
|
|
///</summary>
|
|
TopLeft,
|
|
|
|
///<summary>
|
|
/// Image is Top Right aligned and unscaled
|
|
///</summary>
|
|
TopRight,
|
|
|
|
///<summary>
|
|
/// Image is Bottom Left aligned and unscaled
|
|
///</summary>
|
|
BottomLeft,
|
|
|
|
///<summary>
|
|
/// Image is Bottom Right aligned and unscaled
|
|
///</summary>
|
|
BottomRight,
|
|
|
|
///<summary>
|
|
/// Image is Centered and unscaled
|
|
///</summary>
|
|
Center,
|
|
|
|
///<summary>
|
|
/// Image is Stretched to fill the area
|
|
///</summary>
|
|
Stretch,
|
|
|
|
///<summary>
|
|
/// Image is unscaled and tiled
|
|
///</summary>
|
|
Tile,
|
|
|
|
///<summary>
|
|
/// Image is proportionally scaled to fit
|
|
///</summary>
|
|
Zoom,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RowHeaderVisibility
|
|
|
|
///<summary>
|
|
/// RowHeaderVisibility
|
|
///</summary>
|
|
public enum RowHeaderVisibility
|
|
{
|
|
///<summary>
|
|
/// Always visible
|
|
///</summary>
|
|
Always,
|
|
|
|
///<summary>
|
|
/// Never visible
|
|
///</summary>
|
|
Never,
|
|
|
|
///<summary>
|
|
/// Controlled via Panel.ShowRowHeaders
|
|
///</summary>
|
|
PanelControlled,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|