1732 lines
48 KiB
C#
1732 lines
48 KiB
C#
using System;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Windows.Forms;
|
|
using DevComponents.DotNetBar.SuperGrid.Primitives;
|
|
using DevComponents.DotNetBar.SuperGrid.Style;
|
|
using DevComponents.SuperGrid.TextMarkup;
|
|
|
|
namespace DevComponents.DotNetBar.SuperGrid
|
|
{
|
|
///<summary>
|
|
/// GridGroup
|
|
///</summary>
|
|
public class GridGroup : GridContainer
|
|
{
|
|
#region Static data
|
|
|
|
private static bool _dragSelection;
|
|
private static bool _dragStarted;
|
|
|
|
#endregion
|
|
|
|
#region Private variables
|
|
|
|
private GridCell _Cell;
|
|
|
|
private string _Text;
|
|
private Size _TextSize;
|
|
|
|
private Rectangle _ExpandButtonBounds;
|
|
|
|
private int _AnchorIndex;
|
|
|
|
private GroupArea _HitArea;
|
|
private GridContainer _HitItem;
|
|
private GroupArea _LastHitArea;
|
|
|
|
private GroupArea _MouseDownHitArea;
|
|
private Point _MouseDownPoint;
|
|
private GridContainer _MouseDownHitRow;
|
|
|
|
private GroupHeaderVisualStyles _GroupHeaderVisualStyles;
|
|
private GroupHeaderVisualStyles _EffectiveVisualStyles;
|
|
|
|
private int _StyleUpdateCount;
|
|
|
|
private BodyElement _GroupTextMarkup;
|
|
|
|
private object _GroupId;
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region Bounds
|
|
|
|
///<summary>
|
|
/// Bounds
|
|
///</summary>
|
|
public override Rectangle Bounds
|
|
{
|
|
get
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
Rectangle r = BoundsRelative;
|
|
|
|
if (IsVFrozen == false)
|
|
r.Y -= VScrollOffset;
|
|
|
|
if (panel.IsSubPanel == true)
|
|
r.X -= HScrollOffset;
|
|
|
|
r.Height = FixedRowHeight;
|
|
|
|
Rectangle t = ViewRect;
|
|
|
|
if (r.Right > t.Right)
|
|
r.Width -= (r.Right - t.Right);
|
|
|
|
return (r);
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Cell
|
|
|
|
///<summary>
|
|
/// Gets the Group's associated grid cell.
|
|
///</summary>
|
|
public GridCell Cell
|
|
{
|
|
get { return (_Cell); }
|
|
internal set { _Cell = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Column
|
|
|
|
///<summary>
|
|
/// Gets the Group's associated grid Column.
|
|
///</summary>
|
|
public GridColumn Column
|
|
{
|
|
get { return (_Cell != null ? _Cell.GridColumn : null); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupHeaderVisualStyles
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visual styles
|
|
/// assigned to the element. Default value is null.
|
|
/// </summary>
|
|
[DefaultValue(null), Category("Style")]
|
|
[Description("Indicates visual style assigned to the element")]
|
|
public GroupHeaderVisualStyles GroupHeaderVisualStyles
|
|
{
|
|
get
|
|
{
|
|
if (_GroupHeaderVisualStyles == null)
|
|
{
|
|
_GroupHeaderVisualStyles = new GroupHeaderVisualStyles();
|
|
|
|
GroupHeaderStyleChangeHandler(null, _GroupHeaderVisualStyles);
|
|
}
|
|
|
|
return (_GroupHeaderVisualStyles);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_GroupHeaderVisualStyles != value)
|
|
{
|
|
GroupHeaderVisualStyles oldValue = _GroupHeaderVisualStyles;
|
|
_GroupHeaderVisualStyles = value;
|
|
|
|
OnCellStyleChanged("GroupHeaderVisualStyle", oldValue, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnCellStyleChanged(string property,
|
|
GroupHeaderVisualStyles oldValue, GroupHeaderVisualStyles newValue)
|
|
{
|
|
GroupHeaderStyleChangeHandler(oldValue, newValue);
|
|
|
|
OnPropertyChanged(property);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupValue
|
|
|
|
///<summary>
|
|
/// GroupValue
|
|
///</summary>
|
|
public object GroupValue
|
|
{
|
|
get { return (_Cell != null ? _Cell.Value : 0); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region PlainText
|
|
|
|
///<summary>
|
|
/// Gets the "Plain" header Text (MiniMarkup stripped)
|
|
///</summary>
|
|
public string PlainText
|
|
{
|
|
get
|
|
{
|
|
if (_GroupTextMarkup != null)
|
|
return (_GroupTextMarkup.PlainText);
|
|
|
|
return (_Text);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Text
|
|
|
|
///<summary>
|
|
/// Text
|
|
///</summary>
|
|
public string Text
|
|
{
|
|
get { return (_Text); }
|
|
|
|
set
|
|
{
|
|
if (_Text != value)
|
|
{
|
|
_Text = value;
|
|
|
|
MarkupGroupTextChanged();
|
|
|
|
OnPropertyChangedEx("Text", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Internal properties
|
|
|
|
#region GroupId
|
|
|
|
internal object GroupId
|
|
{
|
|
get { return (_GroupId); }
|
|
set { _GroupId = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupTextMarkup
|
|
|
|
internal BodyElement GroupTextMarkup
|
|
{
|
|
get { return (_GroupTextMarkup); }
|
|
set { _GroupTextMarkup = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region MeasureOverride
|
|
|
|
#region MeasureOverride
|
|
|
|
/// <summary>
|
|
/// MeasureOverride
|
|
/// </summary>
|
|
/// <param name="layoutInfo"></param>
|
|
/// <param name="stateInfo"></param>
|
|
/// <param name="constraintSize"></param>
|
|
protected override void MeasureOverride(
|
|
GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize)
|
|
{
|
|
Size sizeNeeded = Size.Empty;
|
|
GridPanel panel = stateInfo.GridPanel;
|
|
Graphics g = layoutInfo.Graphics;
|
|
|
|
if (CanShowRowHeader(panel) == true)
|
|
sizeNeeded.Width += panel.RowHeaderWidthEx;
|
|
|
|
GroupHeaderVisualStyle style = GetSizingStyle(panel);
|
|
|
|
Size size = MeasureGroupText(g, style, constraintSize);
|
|
|
|
if (size.Height > 0)
|
|
{
|
|
size.Height += Dpi.Height8;
|
|
|
|
size.Width += Dpi.Width(style.Padding.Horizontal);
|
|
size.Height += Dpi.Height(style.Padding.Vertical);
|
|
}
|
|
|
|
size.Height = Math.Max(size.Height, Dpi.Height(panel.GroupHeaderHeight));
|
|
|
|
sizeNeeded.Width += size.Width;
|
|
sizeNeeded.Height = Math.Max(size.Height, sizeNeeded.Height);
|
|
|
|
if (panel.ShowGroupUnderline == true && size.Height > 0)
|
|
sizeNeeded.Height += Dpi.Height4;
|
|
|
|
FixedRowHeight = sizeNeeded.Height;
|
|
|
|
if (Rows != null && Expanded == true)
|
|
{
|
|
if (panel.IndentGroups == true)
|
|
{
|
|
GridLayoutStateInfo itemStateInfo = new
|
|
GridLayoutStateInfo(panel, stateInfo.IndentLevel + 1);
|
|
|
|
size = MeasureSubItems(layoutInfo, itemStateInfo, constraintSize);
|
|
}
|
|
else
|
|
{
|
|
size = MeasureSubItems(layoutInfo, stateInfo, constraintSize);
|
|
}
|
|
|
|
sizeNeeded.Width = Math.Max(size.Width, sizeNeeded.Width);
|
|
sizeNeeded.Height += size.Height;
|
|
}
|
|
|
|
Size = sizeNeeded;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MeasureGroupText
|
|
|
|
private Size MeasureGroupText(Graphics g,
|
|
GroupHeaderVisualStyle style, Size constraintSize)
|
|
{
|
|
_TextSize = Size.Empty;
|
|
|
|
if (String.IsNullOrEmpty(Text) == false)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel.IsSubPanel == false)
|
|
{
|
|
if (panel.ShowGroupExpand == true)
|
|
{
|
|
constraintSize.Width = SViewRect.Width;
|
|
|
|
int n = panel.TreeButtonIndent +
|
|
Dpi.Width(panel.LevelIndentSize.Width * IndentLevel);
|
|
|
|
constraintSize.Width -= n;
|
|
}
|
|
}
|
|
|
|
_TextSize = MeasureHeaderText(g, style, constraintSize);
|
|
}
|
|
|
|
return (_TextSize);
|
|
}
|
|
|
|
#region MeasureHeaderText
|
|
|
|
private Size MeasureHeaderText(Graphics g,
|
|
GroupHeaderVisualStyle style, Size constraintSize)
|
|
{
|
|
Size size = Size.Empty;
|
|
|
|
string s = Text;
|
|
|
|
if (string.IsNullOrEmpty(s) == false)
|
|
{
|
|
if (_GroupTextMarkup != null)
|
|
{
|
|
size = GetMarkupTextSize(g,
|
|
_GroupTextMarkup, style, constraintSize.Width);
|
|
}
|
|
else
|
|
{
|
|
eTextFormat tf = style.GetTextFormatFlags();
|
|
|
|
size = (constraintSize.IsEmpty == true)
|
|
? TextHelper.MeasureText(g, s, style.Font)
|
|
: TextHelper.MeasureText(g, s, style.Font, constraintSize, tf);
|
|
}
|
|
}
|
|
|
|
return (size);
|
|
}
|
|
|
|
#region GetMarkupTextSize
|
|
|
|
private Size GetMarkupTextSize(Graphics g,
|
|
BodyElement textMarkup, GroupHeaderVisualStyle style, int width)
|
|
{
|
|
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
|
|
|
|
#endregion
|
|
|
|
#region ArrangeOverride
|
|
|
|
/// <summary>
|
|
/// ArrangeOverride
|
|
/// </summary>
|
|
/// <param name="layoutInfo"></param>
|
|
/// <param name="stateInfo"></param>
|
|
/// <param name="layoutBounds"></param>
|
|
protected override void ArrangeOverride(GridLayoutInfo layoutInfo,
|
|
GridLayoutStateInfo stateInfo, Rectangle layoutBounds)
|
|
{
|
|
Rectangle bounds = layoutBounds;
|
|
bounds.Height = FixedRowHeight;
|
|
|
|
GridPanel panel = stateInfo.GridPanel;
|
|
IndentLevel = stateInfo.IndentLevel;
|
|
|
|
if (panel.ShowGroupExpand == true)
|
|
{
|
|
GroupHeaderVisualStyle style = GetSizingStyle(panel);
|
|
|
|
Rectangle r = bounds;
|
|
|
|
r.Width = Dpi.Width(panel.LevelIndentSize.Width);
|
|
r.Height -= Dpi.Height(style.Padding.Vertical);
|
|
|
|
int n = Dpi.Height(panel.GroupHeaderHeight);
|
|
|
|
if (r.Height < n)
|
|
r.Height = n;
|
|
|
|
if (CanShowRowHeader(panel) == true)
|
|
r.X += panel.RowHeaderWidthEx;
|
|
|
|
n = panel.TreeButtonIndent +
|
|
Dpi.Width((panel.LevelIndentSize.Width * IndentLevel) - panel.LevelIndentSize.Width);
|
|
|
|
r.X += n;
|
|
|
|
if (r.Right > BoundsRelative.Right)
|
|
r.Width -= r.Right - BoundsRelative.Right;
|
|
|
|
r.X += Dpi.Width(style.Padding.Left);
|
|
r.Y += Dpi.Height(style.Padding.Top);
|
|
|
|
Size size = panel.GetTreeButtonSize();
|
|
|
|
r.X += (r.Width - size.Width) / 2;
|
|
r.Y += (r.Height - size.Height) / 2 - 1;
|
|
|
|
r.Size = size;
|
|
|
|
_ExpandButtonBounds = r;
|
|
}
|
|
else
|
|
{
|
|
_ExpandButtonBounds = Rectangle.Empty;
|
|
}
|
|
|
|
if (Rows != null && Expanded == true)
|
|
{
|
|
bounds = layoutBounds;
|
|
|
|
bounds.Y += FixedRowHeight;
|
|
bounds.Height -= FixedRowHeight;
|
|
|
|
if (panel.IndentGroups == true)
|
|
{
|
|
GridLayoutStateInfo itemStateInfo =
|
|
new GridLayoutStateInfo(panel, stateInfo.IndentLevel + 1);
|
|
|
|
ArrangeSubItems(layoutInfo, itemStateInfo, bounds);
|
|
}
|
|
else
|
|
{
|
|
ArrangeSubItems(layoutInfo, stateInfo, bounds);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderOverride
|
|
|
|
/// <summary>
|
|
/// RenderOverride
|
|
/// </summary>
|
|
/// <param name="renderInfo"></param>
|
|
protected override void RenderOverride(GridRenderInfo renderInfo)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
Rectangle r = Bounds;
|
|
|
|
if (r.IntersectsWith(renderInfo.ClipRectangle))
|
|
{
|
|
Graphics g = renderInfo.Graphics;
|
|
GroupHeaderVisualStyle style = GetEffectiveStyle();
|
|
|
|
if (SuperGrid.DoPreRenderGroupHeaderEvent(g,
|
|
this, RenderParts.Background | RenderParts.RowHeader, r) == false)
|
|
{
|
|
RenderGroupBackground(g, style, r);
|
|
RenderRowHeader(g, panel, style, r);
|
|
|
|
SuperGrid.DoPostRenderGroupHeaderEvent(g,
|
|
this, RenderParts.Background | RenderParts.RowHeader, r);
|
|
}
|
|
|
|
if (CanShowRowHeader(panel) == true)
|
|
{
|
|
r.X += panel.RowHeaderWidthEx;
|
|
r.Width -= panel.RowHeaderWidthEx;
|
|
}
|
|
|
|
RenderHeaderExpand(g, panel, ref r);
|
|
|
|
r = GetAdjustedBounds(style, r);
|
|
|
|
int n = Dpi.Width(panel.GroupHeaderHeight);
|
|
|
|
if (r.Height < n)
|
|
r.Height = n;
|
|
|
|
if (SuperGrid.DoPreRenderGroupHeaderEvent(g,
|
|
this, RenderParts.Content, r) == false)
|
|
{
|
|
RenderHeaderText(g, style, r);
|
|
RenderHeaderUnderline(g, panel, style, r);
|
|
|
|
SuperGrid.DoPostRenderGroupHeaderEvent(g,
|
|
this, RenderParts.Content, r);
|
|
}
|
|
}
|
|
|
|
if (Rows != null && Expanded == true)
|
|
{
|
|
UpdateMergeFlags();
|
|
|
|
foreach (GridElement item in Rows)
|
|
{
|
|
if (item.Visible == true)
|
|
item.Render(renderInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region GetAdjustedBounds
|
|
|
|
private Rectangle GetAdjustedBounds(GroupHeaderVisualStyle style, Rectangle r)
|
|
{
|
|
r.X += Dpi.Width(style.Padding.Left);
|
|
r.Width -= Dpi.Width(style.Padding.Horizontal);
|
|
|
|
r.Y += Dpi.Height(style.Padding.Top + 2);
|
|
r.Height -= Dpi.Height(style.Padding.Vertical + 2);
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderRowHeader
|
|
|
|
private void RenderRowHeader(Graphics g,
|
|
GridPanel panel, GroupHeaderVisualStyle style, Rectangle r)
|
|
{
|
|
if (CanShowRowHeader(panel) == true)
|
|
{
|
|
r.Width = panel.RowHeaderWidthEx;
|
|
|
|
using (Brush br = style.RowHeaderStyle.Background.GetBrush(r))
|
|
g.FillRectangle(br, r);
|
|
|
|
GridPanelVisualStyle pstyle = panel.GetEffectiveStyle();
|
|
|
|
if (Dpi.Height1 == Dpi.Width1)
|
|
{
|
|
using (Pen pen = new Pen(style.RowHeaderStyle.BorderHighlightColor, Dpi.Height1))
|
|
{
|
|
g.DrawLine(pen, r.X + 1, r.Top, r.Right - 2, r.Top);
|
|
g.DrawLine(pen, r.X + 1, r.Top, r.X + 1, r.Bottom - 1);
|
|
}
|
|
|
|
using (Pen pen = new Pen(pstyle.HeaderLineColor, Dpi.Height1))
|
|
{
|
|
g.DrawLine(pen, r.X, r.Top - 1, r.Right - 1, r.Top - 1);
|
|
g.DrawLine(pen, r.X, r.Bottom - 1, r.Right - 2, r.Bottom - 1);
|
|
|
|
g.DrawLine(pen, r.Right - 1, r.Top, r.Right - 1, r.Bottom - 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
using (Pen pen = new Pen(style.RowHeaderStyle.BorderHighlightColor, Dpi.Height1))
|
|
g.DrawLine(pen, r.X + 1, r.Top, r.Right - 2, r.Top);
|
|
|
|
using (Pen pen = new Pen(style.RowHeaderStyle.BorderHighlightColor, Dpi.Width1))
|
|
g.DrawLine(pen, r.X + 1, r.Top, r.X + 1, r.Bottom - 1);
|
|
|
|
using (Pen pen = new Pen(pstyle.HeaderLineColor, Dpi.Height1))
|
|
{
|
|
g.DrawLine(pen, r.X, r.Top - 1, r.Right - 1, r.Top - 1);
|
|
g.DrawLine(pen, r.X, r.Bottom - 1, r.Right - 2, r.Bottom - 1);
|
|
}
|
|
|
|
using (Pen pen = new Pen(pstyle.HeaderLineColor, Dpi.Width1))
|
|
g.DrawLine(pen, r.Right - 1, r.Top, r.Right - 1, r.Bottom - 1);
|
|
}
|
|
|
|
r.X += Dpi.Width4;
|
|
r.Width -= Dpi.Width4;
|
|
|
|
int n = RenderIndicatorImage(g, panel, this, r);
|
|
|
|
r.X += n;
|
|
r.Width -= n;
|
|
|
|
if (panel.ShowRowGridIndex == true)
|
|
RenderGridIndex(g, this, style.RowHeaderStyle, r);
|
|
}
|
|
}
|
|
|
|
#region RenderIndicatorImage
|
|
|
|
private int RenderIndicatorImage(Graphics g,
|
|
GridPanel panel, GridContainer row, Rectangle r)
|
|
{
|
|
RowHeaderVisualStyle style = GetEffectiveRowStyle().RowHeaderStyle;
|
|
|
|
Image image = style.GetActiveRowImage(panel);
|
|
|
|
if (image != null)
|
|
{
|
|
if (panel.ActiveRow == row)
|
|
{
|
|
if (panel.ActiveRowIndicatorStyle == ActiveRowIndicatorStyle.Image ||
|
|
panel.ActiveRowIndicatorStyle == ActiveRowIndicatorStyle.Both)
|
|
{
|
|
Rectangle u = r;
|
|
u.Size = image.Size;
|
|
|
|
if (r.Height > u.Height)
|
|
u.Y += (r.Height - u.Height) / 2;
|
|
|
|
u.Intersect(r);
|
|
|
|
g.DrawImageUnscaledAndClipped(image, u);
|
|
}
|
|
}
|
|
|
|
return (image.Width);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderGridIndex
|
|
|
|
private void RenderGridIndex(Graphics g,
|
|
GridContainer row, RowHeaderVisualStyle style, Rectangle r)
|
|
{
|
|
string text = (row.GridIndex + row.GridPanel.RowHeaderIndexOffset).ToString();
|
|
|
|
Font font = style.Font ?? SystemFonts.DefaultFont;
|
|
|
|
r.Inflate(-2, 0);
|
|
|
|
TextDrawing.DrawString(g, text,
|
|
font, style.TextColor, r, style.GetTextFormatFlags());
|
|
|
|
return;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region CanShowRowHeader
|
|
|
|
/// <summary>
|
|
/// CanShowRowHeader
|
|
/// </summary>
|
|
/// <param name="panel"></param>
|
|
/// <returns></returns>
|
|
protected virtual bool CanShowRowHeader(GridPanel panel)
|
|
{
|
|
switch (panel.GroupRowHeaderVisibility)
|
|
{
|
|
case RowHeaderVisibility.Always:
|
|
return (true);
|
|
|
|
case RowHeaderVisibility.PanelControlled:
|
|
return (panel.ShowRowHeaders);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderGroupBackground
|
|
|
|
private void RenderGroupBackground(
|
|
Graphics g, GroupHeaderVisualStyle style, Rectangle r)
|
|
{
|
|
if (style.Background != null && style.Background.IsEmpty == false)
|
|
{
|
|
using (Brush br = style.Background.GetBrush(r))
|
|
g.FillRectangle(br, r);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderHeaderExpand
|
|
|
|
private void RenderHeaderExpand(
|
|
Graphics g, GridPanel panel, ref Rectangle r)
|
|
{
|
|
if (panel.ShowGroupExpand == true)
|
|
{
|
|
Rectangle bounds = _ExpandButtonBounds;
|
|
|
|
if (IsVFrozen == false)
|
|
bounds.Y -= VScrollOffset;
|
|
|
|
if (panel.IsSubPanel == true)
|
|
bounds.X -= HScrollOffset;
|
|
|
|
bool hot = (_HitArea == GroupArea.ExpandButton);
|
|
|
|
Image image = (Expanded == true)
|
|
? panel.GetCollapseButton(g, hot) : panel.GetExpandButton(g, hot);
|
|
|
|
ExpandDisplay.RenderButton(g, image, bounds, r);
|
|
|
|
int n = panel.TreeButtonIndent +
|
|
Dpi.Width(panel.LevelIndentSize.Width * IndentLevel);
|
|
|
|
r.X += n;
|
|
r.Width -= n;
|
|
}
|
|
else
|
|
{
|
|
r.X += Dpi.Width3;
|
|
r.Width -= Dpi.Width3;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderHeaderText
|
|
|
|
private void RenderHeaderText(Graphics g,
|
|
GroupHeaderVisualStyle style, Rectangle r)
|
|
{
|
|
eTextFormat tf = style.GetTextFormatFlags();
|
|
|
|
if (style.Alignment == Alignment.BottomLeft ||
|
|
style.Alignment == Alignment.BottomCenter ||
|
|
style.Alignment == Alignment.BottomRight)
|
|
{
|
|
r.Height -= Dpi.Height4;
|
|
}
|
|
|
|
if (r.Width > 0 && r.Height > 0)
|
|
{
|
|
if (_GroupTextMarkup != null)
|
|
RenderTextMarkup(g, _GroupTextMarkup, style, r);
|
|
else
|
|
TextDrawing.DrawString(g, Text, style.Font, style.TextColor, r, tf);
|
|
}
|
|
}
|
|
|
|
#region RenderTextMarkup
|
|
|
|
private void RenderTextMarkup(Graphics g,
|
|
BodyElement textMarkup, GroupHeaderVisualStyle 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 RenderHeaderUnderline
|
|
|
|
private void RenderHeaderUnderline(Graphics g,
|
|
GridPanel panel, GroupHeaderVisualStyle style, Rectangle r)
|
|
{
|
|
if (panel.ShowGroupUnderline == true && style.UnderlineColor.IsEmpty == false)
|
|
{
|
|
switch (style.Alignment)
|
|
{
|
|
case Alignment.MiddleLeft:
|
|
case Alignment.MiddleCenter:
|
|
case Alignment.MiddleRight:
|
|
r.Y += (r.Height + _TextSize.Height) / 2 + Dpi.Height4;
|
|
break;
|
|
|
|
case Alignment.TopLeft:
|
|
case Alignment.TopCenter:
|
|
case Alignment.TopRight:
|
|
r.Y += _TextSize.Height + Dpi.Height6;
|
|
break;
|
|
|
|
default:
|
|
r.Y = r.Bottom - _TextSize.Height / 2;
|
|
break;
|
|
}
|
|
|
|
if (r.Width > SViewRect.Width)
|
|
r.Width = SViewRect.Width;
|
|
|
|
int n = r.Width;
|
|
|
|
r.Height = Dpi.Height1;
|
|
r.Width = (int)(r.Width * .75);
|
|
|
|
Rectangle t = r;
|
|
|
|
Color color1 = style.UnderlineColor;
|
|
Color color2 = Color.Transparent;
|
|
|
|
switch (style.Alignment)
|
|
{
|
|
case Alignment.TopCenter:
|
|
case Alignment.MiddleCenter:
|
|
case Alignment.BottomCenter:
|
|
r.X += (n - r.Width) / 2;
|
|
r.Width /= 2;
|
|
|
|
color1 = Color.Transparent;
|
|
color2 = style.UnderlineColor;
|
|
break;
|
|
|
|
case Alignment.TopRight:
|
|
case Alignment.MiddleRight:
|
|
case Alignment.BottomRight:
|
|
r.X += n - r.Width;
|
|
|
|
color1 = Color.Transparent;
|
|
color2 = style.UnderlineColor;
|
|
break;
|
|
}
|
|
|
|
t.X = r.X;
|
|
|
|
if ((r.Width > 0 && r.Height > 0) && (t.Width > 0 && t.Height > 0))
|
|
{
|
|
using (LinearGradientBrush br = new
|
|
LinearGradientBrush(r, color1, color2, 0f))
|
|
{
|
|
br.WrapMode = WrapMode.TileFlipXY;
|
|
|
|
g.FillRectangle(br, t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Mouse support
|
|
|
|
#region InternalMouseEnter
|
|
|
|
internal override void InternalMouseEnter(EventArgs e)
|
|
{
|
|
base.InternalMouseEnter(e);
|
|
|
|
InvalidateRender();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseLeave
|
|
|
|
internal override void InternalMouseLeave(EventArgs e)
|
|
{
|
|
base.InternalMouseLeave(e);
|
|
|
|
InvalidateRender();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseMove
|
|
|
|
internal override void InternalMouseMove(MouseEventArgs e)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
if (IsMouseDown == true)
|
|
ProcessMouseDownMove(e, panel);
|
|
|
|
ProcessMouseMove(e, panel);
|
|
}
|
|
|
|
if (Capture == false)
|
|
base.InternalMouseMove(e);
|
|
}
|
|
|
|
#region ProcessMouseDownMove
|
|
|
|
private void ProcessMouseDownMove(MouseEventArgs e, GridPanel panel)
|
|
{
|
|
Rectangle r = ViewRect;
|
|
|
|
if (MouseDownPoint.Y < r.Y)
|
|
{
|
|
int n = SuperGrid.PrimaryGrid.FixedRowHeight -
|
|
SuperGrid.PrimaryGrid.FixedHeaderHeight;
|
|
|
|
r.Y -= n;
|
|
r.Height += n;
|
|
}
|
|
|
|
VScrollBarAdv vsb = SuperGrid.VScrollBar;
|
|
|
|
if ((e.Y >= r.Y) &&
|
|
(e.Y < r.Bottom || (vsb.Value >= vsb.Maximum - vsb.LargeChange)))
|
|
{
|
|
SuperGrid.DisableAutoScrolling();
|
|
|
|
switch (_MouseDownHitArea)
|
|
{
|
|
case GroupArea.Content:
|
|
case GroupArea.RowHeader:
|
|
_HitItem = GetRowAt(panel, e.Location);
|
|
|
|
if (_HitItem != null)
|
|
{
|
|
if (DragStarted(panel, e) == false)
|
|
{
|
|
if (panel.MultiSelect == true)
|
|
{
|
|
if (_HitItem != panel.LastProcessedItem)
|
|
ProcessExtendSelection(panel, true);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SuperGrid.EnableAutoScrolling(AutoScrollEnable.Vertical, r);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessMouseMove
|
|
|
|
internal void ProcessMouseMove(MouseEventArgs e, GridPanel panel)
|
|
{
|
|
_HitArea = GetGroupAreaAt(e);
|
|
|
|
switch (_HitArea)
|
|
{
|
|
case GroupArea.ExpandButton:
|
|
SuperGrid.GridCursor = Cursors.Hand;
|
|
break;
|
|
|
|
default:
|
|
SuperGrid.GridCursor = Cursors.Default;
|
|
break;
|
|
}
|
|
|
|
if (_LastHitArea != _HitArea)
|
|
{
|
|
_LastHitArea = _HitArea;
|
|
|
|
InvalidateRender();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DragStarted
|
|
|
|
private bool DragStarted(GridPanel panel, MouseEventArgs e)
|
|
{
|
|
if (_dragSelection == true && Capture == true)
|
|
{
|
|
if (_dragStarted == false)
|
|
{
|
|
if (DragDrop.DragStarted(_MouseDownPoint, e.Location) == true)
|
|
{
|
|
_dragStarted = true;
|
|
|
|
if (SuperGrid.DoItemDragEvent(this, e) == true)
|
|
{
|
|
_dragSelection = false;
|
|
|
|
Capture = true;
|
|
|
|
InitExtendSelection(panel);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (true);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseDown
|
|
|
|
internal override void InternalMouseDown(MouseEventArgs e)
|
|
{
|
|
_MouseDownHitArea = _HitArea;
|
|
_MouseDownHitRow = _HitItem;
|
|
_MouseDownPoint = e.Location;
|
|
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
{
|
|
GridCell ecell = SuperGrid.EditorCell;
|
|
|
|
if (ecell != null)
|
|
{
|
|
if (ecell.EndEdit() == false)
|
|
return;
|
|
}
|
|
|
|
_dragSelection = false;
|
|
_dragStarted = false;
|
|
|
|
if (_MouseDownHitArea != GroupArea.NoWhere)
|
|
{
|
|
if (_MouseDownHitArea == GroupArea.ExpandButton ||
|
|
panel.GroupHeaderClickBehavior == GroupHeaderClickBehavior.ExpandCollapse)
|
|
{
|
|
Expanded = !Expanded;
|
|
}
|
|
else
|
|
{
|
|
if (ShouldExtendSelection(panel) == true)
|
|
{
|
|
InitExtendSelection(panel);
|
|
}
|
|
else
|
|
{
|
|
if (IsMouseDown == true)
|
|
{
|
|
Capture = true;
|
|
|
|
_dragSelection = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region ShouldExtendSelection
|
|
|
|
private bool ShouldExtendSelection(GridPanel panel)
|
|
{
|
|
return (panel.SuperGrid.HasItemDragHandler == false || IsSelected == false ||
|
|
((Control.ModifierKeys & (Keys.Control | Keys.Shift)) != Keys.None));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InitExtendSelection
|
|
|
|
private void InitExtendSelection(GridPanel panel)
|
|
{
|
|
if (IsMouseSelectable() == true)
|
|
{
|
|
Capture = true;
|
|
|
|
ExtendSelectionEx(panel);
|
|
}
|
|
}
|
|
|
|
#region IsMouseSelectable
|
|
|
|
private bool IsMouseSelectable()
|
|
{
|
|
return (IsMouseSelectableEx(Control.MouseButtons));
|
|
}
|
|
|
|
private bool IsMouseSelectableEx(MouseButtons mb)
|
|
{
|
|
if ((mb & MouseButtons.Left) == MouseButtons.Left)
|
|
return (true);
|
|
|
|
return (IsSelected == false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ExtendSelectionEx
|
|
|
|
private void ExtendSelectionEx(GridPanel panel)
|
|
{
|
|
if (_MouseDownHitRow != null && _HitItem != null)
|
|
{
|
|
_AnchorIndex = _MouseDownHitRow.GridIndex;
|
|
|
|
if (panel.LastProcessedItem != this && panel.LastProcessedItem != null)
|
|
panel.LastProcessedItem.InvalidateRender();
|
|
|
|
bool ckey = panel.MultiSelect == true
|
|
? ((Control.ModifierKeys & Keys.Control) == Keys.Control)
|
|
: false;
|
|
|
|
panel.LastProcessedItem = (ckey == true) ? _HitItem : this;
|
|
|
|
ProcessExtendSelection(panel, false);
|
|
}
|
|
}
|
|
|
|
#region ProcessExtendSelection
|
|
|
|
internal void ProcessExtendSelection(GridPanel panel, bool extend)
|
|
{
|
|
bool ckey = panel.MultiSelect == true
|
|
? ((Control.ModifierKeys & Keys.Control) == Keys.Control)
|
|
: false;
|
|
|
|
if (ckey == true)
|
|
ProcessControlExtend(panel, extend);
|
|
else
|
|
ProcessNonControlExtend(panel, extend);
|
|
|
|
panel.LastProcessedItem = _HitItem;
|
|
}
|
|
|
|
#region ProcessControlExtend
|
|
|
|
private void ProcessControlExtend(GridPanel panel, bool extend)
|
|
{
|
|
if (panel.LastProcessedItem == null)
|
|
panel.LastProcessedItem = _MouseDownHitRow;
|
|
|
|
GridContainer lastRow = panel.LastProcessedItem as GridContainer;
|
|
|
|
if (lastRow != null)
|
|
{
|
|
int startIndex = lastRow.GridIndex;
|
|
int endIndex = _HitItem.GridIndex;
|
|
|
|
panel.NormalizeIndices(extend,
|
|
_AnchorIndex, ref startIndex, ref endIndex);
|
|
|
|
for (int i = startIndex; i <= endIndex; i++)
|
|
{
|
|
if (extend == false || i != _AnchorIndex)
|
|
panel.SetSelectedRows(i, 1, !panel.IsRowSelected(i));
|
|
}
|
|
|
|
InvalidateRows(panel, startIndex, endIndex, true);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessNonControlExtend
|
|
|
|
private void ProcessNonControlExtend(GridPanel panel, bool extend)
|
|
{
|
|
bool skey = (panel.MultiSelect == true) ?
|
|
((Control.ModifierKeys & Keys.Shift) == Keys.Shift) : false;
|
|
|
|
if (skey == false || panel.SelectionRowAnchor == null)
|
|
panel.SelectionRowAnchor = _MouseDownHitRow;
|
|
|
|
ExtendSelection(panel, _HitItem, extend);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseUp
|
|
|
|
/// <summary>
|
|
/// InternalMouseUp
|
|
/// </summary>
|
|
/// <param name="e"></param>
|
|
internal override void InternalMouseUp(MouseEventArgs e)
|
|
{
|
|
SuperGrid.DisableAutoScrolling();
|
|
|
|
if (ExtendDragSelection(GridPanel, e) == false)
|
|
{
|
|
if (_MouseDownHitArea == _HitArea)
|
|
{
|
|
if (_MouseDownHitArea == GroupArea.Content || _MouseDownHitArea == GroupArea.RowHeader)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (GridPanel.GroupHeaderClickBehavior == GroupHeaderClickBehavior.SelectAll)
|
|
{
|
|
bool ckey = panel.MultiSelect == true
|
|
? ((Control.ModifierKeys & Keys.Control) == Keys.Control)
|
|
: false;
|
|
|
|
ProcessSelectAll(panel, this, ckey);
|
|
}
|
|
}
|
|
|
|
SuperGrid.DoGroupHeaderClickEvent(this, _MouseDownHitArea, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region ExtendDragSelection
|
|
|
|
private bool ExtendDragSelection(GridPanel panel, MouseEventArgs e)
|
|
{
|
|
if (_dragSelection == true && Capture == true)
|
|
{
|
|
if (IsMouseSelectableEx(e.Button) == true)
|
|
{
|
|
if (_MouseDownHitRow == _HitItem)
|
|
{
|
|
ExtendSelectionEx(panel);
|
|
|
|
return (true);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessSelectAll
|
|
|
|
private void ProcessSelectAll(GridPanel panel,
|
|
GridContainer item, bool ckey)
|
|
{
|
|
if (item.Rows != null && item.Rows.Count > 0)
|
|
{
|
|
item.Expanded = true;
|
|
|
|
foreach (GridContainer row in item.Rows)
|
|
{
|
|
if (row is GridGroup)
|
|
{
|
|
ProcessSelectAll(panel, row, ckey);
|
|
}
|
|
else
|
|
{
|
|
int startIndex = ((GridContainer)item.Rows[0]).GridIndex;
|
|
int endIndex = ((GridContainer)item.Rows[item.Rows.Count - 1]).GridIndex;
|
|
|
|
if (ckey == true)
|
|
{
|
|
for (int i = startIndex; i <= endIndex; i++)
|
|
panel.SetSelectedRows(i, 1, !panel.IsRowSelected(i));
|
|
}
|
|
else
|
|
{
|
|
panel.SetSelectedRows(startIndex, endIndex - startIndex + 1, true);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseDoubleClick
|
|
|
|
internal override void InternalMouseDoubleClick(MouseEventArgs e)
|
|
{
|
|
if (_HitArea == _MouseDownHitArea)
|
|
SuperGrid.DoGroupHeaderDoubleClickEvent(this, _MouseDownHitArea, e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetGroupAreaAt
|
|
|
|
/// <summary>
|
|
/// Returns element at specified mouse coordinates
|
|
/// </summary>
|
|
/// <param name="e">Mouse event arguments</param>
|
|
/// <returns>Reference to child Group element or null
|
|
/// if no element at specified coordinates</returns>
|
|
protected virtual GroupArea GetGroupAreaAt(MouseEventArgs e)
|
|
{
|
|
return GetGroupAreaAt(e.X, e.Y);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns element at specified mouse coordinates
|
|
/// </summary>
|
|
/// <param name="x">Horizontal position</param>
|
|
/// <param name="y">Vertical position</param>
|
|
/// <returns>Reference to child element or null
|
|
/// if no element at specified coordinates</returns>
|
|
protected virtual GroupArea GetGroupAreaAt(int x, int y)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
_HitItem = GetRowAt(panel, new Point(x, y));
|
|
|
|
Rectangle r = BoundsRelative;
|
|
r.Height = FixedRowHeight;
|
|
|
|
if (IsVFrozen == false)
|
|
r.Y -= VScrollOffset;
|
|
|
|
if (panel.IsSubPanel == true)
|
|
r.X -= HScrollOffset;
|
|
|
|
if (r.Contains(x, y) == true)
|
|
{
|
|
if (panel.ShowRowHeaders == true)
|
|
{
|
|
if (x >= r.X && x < r.X + panel.RowHeaderWidthEx)
|
|
return (GroupArea.RowHeader);
|
|
}
|
|
|
|
r = _ExpandButtonBounds;
|
|
|
|
if (IsVFrozen == false)
|
|
r.Y -= VScrollOffset;
|
|
|
|
if (GridPanel.IsSubPanel == true)
|
|
r.X -= HScrollOffset;
|
|
|
|
if (r.Contains(x, y) == true)
|
|
return (GroupArea.ExpandButton);
|
|
|
|
return (GroupArea.Content);
|
|
}
|
|
|
|
return (GroupArea.NoWhere);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetRowAt
|
|
|
|
private GridContainer GetRowAt(GridPanel panel, Point pt)
|
|
{
|
|
Rectangle r = panel.ContainerBounds;
|
|
r.X -= HScrollOffset;
|
|
|
|
if (pt.X < r.X)
|
|
pt.X = r.X;
|
|
|
|
GridContainer row = panel;
|
|
GridElement item = row.InternalGetElementAt(pt.X, pt.Y);
|
|
|
|
while (item != null)
|
|
{
|
|
row = item as GridContainer;
|
|
|
|
if (row == null)
|
|
break;
|
|
|
|
if (row is GridRow)
|
|
item = ((GridRow)row).GetRowElementAt(pt.X, pt.Y, false);
|
|
else
|
|
item = row.GetElementAt(pt.X, pt.Y);
|
|
|
|
if (item is GridContainer == false)
|
|
return (row);
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InvalidateRender
|
|
|
|
/// <summary>
|
|
/// InvalidateRender
|
|
/// </summary>
|
|
public override void InvalidateRender()
|
|
{
|
|
Rectangle bounds = BoundsRelative;
|
|
|
|
if (IsVFrozen == false)
|
|
bounds.Y -= VScrollOffset;
|
|
|
|
SuperGridControl grid = SuperGrid;
|
|
|
|
if (grid != null)
|
|
grid.InvalidateRender(bounds);
|
|
|
|
OnRenderInvalid(EventArgs.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Style support routines
|
|
|
|
#region GroupHeaderStyleChangeHandler
|
|
|
|
private void GroupHeaderStyleChangeHandler(
|
|
GroupHeaderVisualStyles oldValue, GroupHeaderVisualStyles newValue)
|
|
{
|
|
if (oldValue != null)
|
|
oldValue.PropertyChanged -= StyleChanged;
|
|
|
|
if (newValue != null)
|
|
newValue.PropertyChanged += StyleChanged;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetEffectiveStyle
|
|
|
|
///<summary>
|
|
/// GetEffectiveStyle
|
|
///</summary>
|
|
///<returns></returns>
|
|
public GroupHeaderVisualStyle GetEffectiveStyle()
|
|
{
|
|
StyleState state = GetState();
|
|
|
|
return (GetEffectiveStyle(state));
|
|
}
|
|
|
|
internal GroupHeaderVisualStyle GetEffectiveStyle(StyleType styleType)
|
|
{
|
|
ValidateStyle();
|
|
|
|
return (GetStyle(styleType));
|
|
}
|
|
|
|
internal GroupHeaderVisualStyle GetEffectiveStyle(StyleState state)
|
|
{
|
|
ValidateStyle();
|
|
|
|
switch (state)
|
|
{
|
|
case StyleState.MouseOver:
|
|
return (GetStyle(StyleType.MouseOver));
|
|
|
|
case StyleState.Selected:
|
|
return (GetStyle(StyleType.Selected));
|
|
|
|
case StyleState.Selected | StyleState.MouseOver:
|
|
return (GetStyle(StyleType.SelectedMouseOver));
|
|
|
|
case StyleState.ReadOnly:
|
|
return (GetStyle(StyleType.ReadOnly));
|
|
|
|
case StyleState.ReadOnly | StyleState.MouseOver:
|
|
return (GetStyle(StyleType.ReadOnlyMouseOver));
|
|
|
|
case StyleState.ReadOnly | StyleState.Selected:
|
|
return (GetStyle(StyleType.ReadOnlySelected));
|
|
|
|
case StyleState.ReadOnly | StyleState.MouseOver | StyleState.Selected:
|
|
return (GetStyle(StyleType.ReadOnlySelectedMouseOver));
|
|
|
|
default:
|
|
return (GetStyle(StyleType.Default));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetStyle
|
|
|
|
private GroupHeaderVisualStyle GetStyle(StyleType e)
|
|
{
|
|
if (_EffectiveVisualStyles.IsValid(e) == false)
|
|
{
|
|
GroupHeaderVisualStyle style = new GroupHeaderVisualStyle();
|
|
|
|
StyleType[] css = style.GetApplyStyleTypes(e);
|
|
|
|
if (css != null)
|
|
{
|
|
foreach (StyleType cs in css)
|
|
{
|
|
style.ApplyStyle(SuperGrid.BaseVisualStyles.GroupHeaderStyles[cs]);
|
|
style.ApplyStyle(SuperGrid.DefaultVisualStyles.GroupHeaderStyles[cs]);
|
|
style.ApplyStyle(GridPanel.DefaultVisualStyles.GroupHeaderStyles[cs]);
|
|
|
|
style.ApplyStyle(GroupHeaderVisualStyles[cs]);
|
|
}
|
|
}
|
|
|
|
SuperGrid.DoGetGroupHeaderStyleEvent(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.DefaultFont;
|
|
|
|
if (style.TextColor.IsEmpty)
|
|
style.TextColor = Color.Black;
|
|
|
|
_EffectiveVisualStyles[e] = style;
|
|
}
|
|
|
|
return (_EffectiveVisualStyles[e]);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ValidateStyle
|
|
|
|
private void ValidateStyle()
|
|
{
|
|
if (_EffectiveVisualStyles == null ||
|
|
(_StyleUpdateCount != SuperGrid.StyleUpdateCount))
|
|
{
|
|
_EffectiveVisualStyles = new GroupHeaderVisualStyles();
|
|
|
|
_StyleUpdateCount = SuperGrid.StyleUpdateCount;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetState
|
|
|
|
internal StyleState GetState()
|
|
{
|
|
StyleState rowState = StyleState.Default;
|
|
|
|
if (IsMouseOver == true)
|
|
{
|
|
Point pt = SuperGrid.PointToClient(Control.MousePosition);
|
|
|
|
if (Bounds.Contains(pt) == true)
|
|
rowState |= StyleState.MouseOver;
|
|
}
|
|
|
|
if (IsSelected == true)
|
|
rowState |= StyleState.Selected;
|
|
|
|
return (rowState);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetSizingStyle
|
|
|
|
private GroupHeaderVisualStyle GetSizingStyle(GridPanel panel)
|
|
{
|
|
StyleType styleType = panel.GetSizingStyle();
|
|
|
|
if (styleType == StyleType.NotSet)
|
|
styleType = StyleType.Default;
|
|
|
|
return (GetEffectiveStyle(styleType));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region CreateItemsCollection
|
|
|
|
/// <summary>
|
|
/// Creates the GridItemsCollection that hosts the items.
|
|
/// </summary>
|
|
/// <returns>New instance of GridItemsCollection.</returns>
|
|
protected override GridItemsCollection CreateItemsCollection()
|
|
{
|
|
GridItemsCollection items = new GridItemsCollection();
|
|
|
|
items.CollectionChanged += ItemsCollectionChanged;
|
|
|
|
return (items);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DisposeItemsCollection
|
|
|
|
/// <summary>
|
|
/// DisposeItemsCollection
|
|
/// </summary>
|
|
/// <param name="items"></param>
|
|
protected override void DisposeItemsCollection(GridItemsCollection items)
|
|
{
|
|
items.CollectionChanged -= ItemsCollectionChanged;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ItemsCollectionChanged
|
|
|
|
void ItemsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
|
|
{
|
|
switch (e.Action)
|
|
{
|
|
case NotifyCollectionChangedAction.Add:
|
|
case NotifyCollectionChangedAction.Replace:
|
|
|
|
foreach (GridElement item in e.NewItems)
|
|
item.Parent = this;
|
|
break;
|
|
}
|
|
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel != null)
|
|
panel.RowCollectionChanged(e);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Markup support
|
|
|
|
private void MarkupGroupTextChanged()
|
|
{
|
|
_GroupTextMarkup = null;
|
|
|
|
if (Column != null && Column.EnableGroupHeaderMarkup == true)
|
|
{
|
|
if (MarkupParser.IsMarkup(_Text) == true)
|
|
_GroupTextMarkup = MarkupParser.Parse(_Text);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IDisposable
|
|
|
|
/// <summary>
|
|
/// Dispose
|
|
/// </summary>
|
|
public override void Dispose()
|
|
{
|
|
GroupHeaderVisualStyles = null;
|
|
|
|
Rows = null;
|
|
|
|
base.Dispose();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#region enums
|
|
|
|
#region GroupArea
|
|
|
|
///<summary>
|
|
/// GroupArea
|
|
///</summary>
|
|
public enum GroupArea
|
|
{
|
|
///<summary>
|
|
/// Content
|
|
///</summary>
|
|
Content,
|
|
|
|
///<summary>
|
|
/// ExpandButton
|
|
///</summary>
|
|
ExpandButton,
|
|
|
|
/// <summary>
|
|
/// Row Header
|
|
/// </summary>
|
|
RowHeader,
|
|
|
|
///<summary>
|
|
/// NoWhere
|
|
///</summary>
|
|
NoWhere,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
}
|