2431 lines
65 KiB
C#
2431 lines
65 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
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 GridGroupBy Row
|
|
/// </summary>
|
|
public class GridGroupByRow : GridTextRow
|
|
{
|
|
#region Constants
|
|
|
|
const int MarkerWidth = 13;
|
|
const int MarkerHeight = 7;
|
|
|
|
const int MarkerHPad = 10;
|
|
const int MarkerVPad = 12;
|
|
|
|
const int TextPad = 3;
|
|
const int TextHPad = 6;
|
|
const int TextVPad = 6;
|
|
|
|
const int BoxSpacing = 8;
|
|
const int DefaultMinRowHeight = 35;
|
|
|
|
#endregion
|
|
|
|
#region Private variables
|
|
|
|
private bool _Visible;
|
|
private bool _UseColumnHeaderColors = true;
|
|
private bool _AllowUserSort = true;
|
|
private bool _RemoveGroupOnDoubleClick = true;
|
|
|
|
private GroupBoxLayout _GroupBoxLayout = GroupBoxLayout.Hierarchical;
|
|
private GroupBoxStyle _GroupBoxStyle = GroupBoxStyle.Rectangular;
|
|
|
|
private List<GridGroupBox> _GroupBoxes;
|
|
private GroupBoxEffects _GroupBoxEffects = GroupBoxEffects.NotSet;
|
|
|
|
private bool _Dragging;
|
|
private Image _InsertMarker;
|
|
|
|
private GridGroupBox _HitGroupBox;
|
|
private GridGroupBox _LastHitGroupBox;
|
|
private GridGroupBox _MouseDownHitBox;
|
|
|
|
private HeaderArea _HitArea;
|
|
private HeaderArea _LastHitArea;
|
|
private GridColumn _HitColumn;
|
|
|
|
private FloatWindow _GroupBoxWindow;
|
|
private GridGroupBox _AfterGroupBox;
|
|
private Rectangle _InsertRect;
|
|
|
|
private FilterPopup _FilterMenu;
|
|
private ImageVisibility _FilterImageVisibility = ImageVisibility.NotSet;
|
|
|
|
private string _WatermarkText;
|
|
|
|
private int _MaxGroupBoxWidth = 200;
|
|
private int _CornerRadius = 5;
|
|
|
|
#endregion
|
|
|
|
#region Constructors
|
|
|
|
///<summary>
|
|
/// GridHeader
|
|
///</summary>
|
|
public GridGroupByRow()
|
|
: this(null)
|
|
{
|
|
}
|
|
|
|
///<summary>
|
|
/// GridHeader
|
|
///</summary>
|
|
///<param name="text"></param>
|
|
public GridGroupByRow(string text)
|
|
: base(text)
|
|
{
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region AllowUserSort
|
|
|
|
///<summary>
|
|
/// Gets or sets whether the user can change the group
|
|
/// sort direction by clicking on the associated GroupBox
|
|
///</summary>
|
|
[DefaultValue(true), Category("Behavior")]
|
|
[Description("Indicates whether the user can change the group sort direction by clicking on the associated GroupBox.")]
|
|
public bool AllowUserSort
|
|
{
|
|
get { return (_AllowUserSort); }
|
|
|
|
set
|
|
{
|
|
if (_AllowUserSort != value)
|
|
{
|
|
_AllowUserSort = value;
|
|
|
|
OnPropertyChanged("AllowUserSort");
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CornerRadius
|
|
|
|
///<summary>
|
|
/// Gets or sets the corner radius to
|
|
/// use when GroupBoxStyle is RoundedRectangular
|
|
///</summary>
|
|
[DefaultValue(5), Category("Behavior")]
|
|
[Description("Indicates the corner radius to use when GroupBoxStyle is RoundedRectangular.")]
|
|
public int CornerRadius
|
|
{
|
|
get { return (_CornerRadius); }
|
|
|
|
set
|
|
{
|
|
if (_CornerRadius != value)
|
|
{
|
|
_CornerRadius = value;
|
|
|
|
OnPropertyChangedEx("CornerRadius", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region FilterImageVisibility
|
|
|
|
/// <summary>
|
|
/// Gets or sets the visibility of the header filter image
|
|
/// </summary>
|
|
[DefaultValue(ImageVisibility.NotSet), Category("Appearance")]
|
|
[Description("Indicates the visibility of the filter image.")]
|
|
public ImageVisibility FilterImageVisibility
|
|
{
|
|
get { return (_FilterImageVisibility); }
|
|
|
|
set
|
|
{
|
|
if (_FilterImageVisibility != value)
|
|
{
|
|
_FilterImageVisibility = value;
|
|
|
|
OnPropertyChangedEx("FilterImageVisibility", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupBoxEffects
|
|
|
|
/// <summary>
|
|
/// Gets or sets the default for how columns interact with the GroupBox
|
|
/// </summary>
|
|
[DefaultValue(GroupBoxEffects.NotSet), Category("Grouping")]
|
|
[Description("Indicates the default for how columns interact with the GroupBox.")]
|
|
public GroupBoxEffects GroupBoxEffects
|
|
{
|
|
get { return (_GroupBoxEffects); }
|
|
|
|
set
|
|
{
|
|
if (_GroupBoxEffects != value)
|
|
{
|
|
_GroupBoxEffects = value;
|
|
|
|
OnPropertyChanged("GroupBoxEffects");
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupBoxLayout
|
|
|
|
/// <summary>
|
|
/// Gets or sets the group box layout (Flat, Hierarchical)
|
|
/// </summary>
|
|
[DefaultValue(GroupBoxLayout.Hierarchical), Category("Appearance")]
|
|
[Description("Indicates the group box layout (Flat, Hierarchical)")]
|
|
public GroupBoxLayout GroupBoxLayout
|
|
{
|
|
get { return (_GroupBoxLayout); }
|
|
|
|
set
|
|
{
|
|
if (_GroupBoxLayout != value)
|
|
{
|
|
_GroupBoxLayout = value;
|
|
|
|
OnPropertyChangedEx("GroupBoxLayout", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupBoxStyle
|
|
|
|
/// <summary>
|
|
/// Gets or sets the group box Style (Rectangular, RoundedRect)
|
|
/// </summary>
|
|
[DefaultValue(GroupBoxStyle.Rectangular), Category("Appearance")]
|
|
[Description("Indicates the group box Style (Rectangular, RoundedRect)")]
|
|
public GroupBoxStyle GroupBoxStyle
|
|
{
|
|
get { return (_GroupBoxStyle); }
|
|
|
|
set
|
|
{
|
|
if (_GroupBoxStyle != value)
|
|
{
|
|
_GroupBoxStyle = value;
|
|
|
|
OnPropertyChangedEx("GroupBoxStyle", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsEmpty
|
|
|
|
/// <summary>
|
|
/// Gets whether the item is empty
|
|
/// </summary>
|
|
[Browsable(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public override bool IsEmpty
|
|
{
|
|
get { return (false); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region MaxGroupBoxWidth
|
|
|
|
/// <summary>
|
|
/// Gets or sets the maximum GroupBox width, in pixels
|
|
/// </summary>
|
|
[DefaultValue(200), Category("Appearance")]
|
|
[Description("Indicates the maximum GroupBox width, in pixels.")]
|
|
public int MaxGroupBoxWidth
|
|
{
|
|
get { return (_MaxGroupBoxWidth); }
|
|
|
|
set
|
|
{
|
|
if (_MaxGroupBoxWidth != value)
|
|
{
|
|
_MaxGroupBoxWidth = value;
|
|
|
|
OnPropertyChangedEx("MaxGroupBoxWidth", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RemoveGroupOnDoubleClick
|
|
|
|
///<summary>
|
|
/// Gets or sets whether the grouping column is removed
|
|
/// when the user double clicks on the associated GroupBox
|
|
///</summary>
|
|
[DefaultValue(true), Category("Behavior")]
|
|
[Description("Indicates whether the grouping column is removed when the user double clicks on the associated GroupBox.")]
|
|
public bool RemoveGroupOnDoubleClick
|
|
{
|
|
get { return (_RemoveGroupOnDoubleClick); }
|
|
|
|
set
|
|
{
|
|
if (_RemoveGroupOnDoubleClick != value)
|
|
{
|
|
_RemoveGroupOnDoubleClick = value;
|
|
|
|
OnPropertyChanged("RemoveGroupOnDoubleClick");
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Visible
|
|
|
|
/// <summary>
|
|
/// Visible
|
|
/// </summary>
|
|
[DefaultValue(false), Category("Appearance")]
|
|
[Description("Indicates whether the item is visible")]
|
|
public override bool Visible
|
|
{
|
|
get { return (_Visible); }
|
|
|
|
set
|
|
{
|
|
if (_Visible != value)
|
|
{
|
|
_Visible = value;
|
|
|
|
OnPropertyChangedEx("Visible", VisualChangeType.Layout);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UseColumnHeaderColors
|
|
|
|
///<summary>
|
|
/// Gets or sets whether Column Header color definitions are used
|
|
///</summary>
|
|
[DefaultValue(true), Category("Appearance")]
|
|
[Description("Indicates whether Column Header color definitions are used")]
|
|
public bool UseColumnHeaderColors
|
|
{
|
|
get { return (_UseColumnHeaderColors); }
|
|
|
|
set
|
|
{
|
|
if (_UseColumnHeaderColors != value)
|
|
{
|
|
_UseColumnHeaderColors = value;
|
|
|
|
OnPropertyChangedEx("UseColumnHeaderColors", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region WatermarkText
|
|
|
|
/// <summary>
|
|
/// Gets or sets the Watermark text to use when no Grouping is active
|
|
/// </summary>
|
|
[DefaultValue(null), Category("Appearance")]
|
|
[Description("Indicates the Watermark text to use when no Grouping is active")]
|
|
public string WatermarkText
|
|
{
|
|
get { return (_WatermarkText); }
|
|
|
|
set
|
|
{
|
|
if (_WatermarkText != value)
|
|
{
|
|
_WatermarkText = value;
|
|
|
|
OnPropertyChangedEx("WatermarkText", VisualChangeType.Render);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region GetWatermarkText
|
|
|
|
private string GetWatermarkText()
|
|
{
|
|
return (_WatermarkText ?? SuperGrid.GroupByWaterMarkText);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Private properties
|
|
|
|
#region InsertMarker
|
|
|
|
private Image InsertMarker
|
|
{
|
|
get
|
|
{
|
|
if (_InsertMarker == null)
|
|
_InsertMarker = CreateInsertMarker();
|
|
|
|
return (_InsertMarker);
|
|
}
|
|
|
|
set
|
|
{
|
|
if (_InsertMarker != null)
|
|
_InsertMarker.Dispose();
|
|
|
|
_InsertMarker = value;
|
|
}
|
|
}
|
|
|
|
#region CreateInsertMarker
|
|
|
|
private Image CreateInsertMarker()
|
|
{
|
|
GroupByVisualStyle style = (GroupByVisualStyle)GetEffectiveStyle();
|
|
|
|
Image image = new Bitmap(MarkerWidth, MarkerHeight);
|
|
|
|
using (Graphics g = Graphics.FromImage(image))
|
|
{
|
|
Point[] pts =
|
|
{
|
|
new Point(0, 0),
|
|
new Point(MarkerWidth - 1, 0),
|
|
new Point(MarkerHeight - 1, MarkerHeight - 1),
|
|
new Point(0, 0),
|
|
};
|
|
|
|
using (GraphicsPath path = new GraphicsPath())
|
|
{
|
|
path.AddLines(pts);
|
|
|
|
Rectangle r = new Rectangle(0, 0, MarkerWidth, MarkerHeight);
|
|
|
|
using (Brush br = style.InsertMarkerBackground.GetBrush(r))
|
|
g.FillPath(br, path);
|
|
|
|
using (Pen pen = new Pen(style.InsertMarkerBorderColor))
|
|
g.DrawPath(pen, path);
|
|
}
|
|
}
|
|
|
|
return (image);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region MeasureRow
|
|
|
|
/// <summary>
|
|
/// MeasureRow
|
|
/// </summary>
|
|
/// <param name="layoutInfo"></param>
|
|
/// <param name="stateInfo"></param>
|
|
/// <param name="constraintSize"></param>
|
|
/// <returns></returns>
|
|
protected override Size MeasureRow(
|
|
GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize)
|
|
{
|
|
Size sizeNeeded = base.MeasureRow(layoutInfo, stateInfo, constraintSize);
|
|
|
|
GridPanel panel = stateInfo.GridPanel;
|
|
|
|
int height = GetGroupByHeight(panel);
|
|
|
|
if (RowHeight == 0)
|
|
{
|
|
int n = Dpi.Height(DefaultMinRowHeight);
|
|
|
|
if (height < n)
|
|
height = n;
|
|
}
|
|
|
|
if (height > sizeNeeded.Height)
|
|
sizeNeeded.Height = height;
|
|
|
|
return (sizeNeeded);
|
|
}
|
|
|
|
#region GetGroupByHeight
|
|
|
|
private int GetGroupByHeight(GridPanel panel)
|
|
{
|
|
if (_GroupBoxes == null)
|
|
_GroupBoxes = new List<GridGroupBox>();
|
|
else
|
|
_GroupBoxes.Clear();
|
|
|
|
GridGroupBox box = new GridGroupBox(this, null);
|
|
_GroupBoxes.Add(box);
|
|
|
|
int rowHeight = (GroupBoxLayout == GroupBoxLayout.Hierarchical)
|
|
? GetHierarchicalHeight(panel)
|
|
: GetFlatHeight(panel);
|
|
|
|
rowHeight += Dpi.Height(MarkerVPad * 2);
|
|
|
|
TextRowVisualStyle tstyle = GetEffectiveStyle();
|
|
|
|
rowHeight += Dpi.Height(tstyle.BorderThickness.Vertical +
|
|
tstyle.Padding.Vertical + tstyle.Margin.Vertical);
|
|
|
|
return (rowHeight);
|
|
}
|
|
|
|
#region GetHierarchicalHeight
|
|
|
|
private int GetHierarchicalHeight(GridPanel panel)
|
|
{
|
|
int rowHeight = 0;
|
|
int lastHeight = 0;
|
|
|
|
foreach (GridColumn column in panel.GroupColumns)
|
|
{
|
|
GridGroupBox box = new GridGroupBox(this, column);
|
|
|
|
box.GroupBoxStyle = GroupBoxStyle;
|
|
box.CornerRadius = CornerRadius;
|
|
|
|
_GroupBoxes.Add(box);
|
|
|
|
Size size = GetGroupBoxSize(box);
|
|
|
|
if (rowHeight == 0)
|
|
{
|
|
rowHeight = size.Height;
|
|
}
|
|
else
|
|
{
|
|
if (size.Height > lastHeight)
|
|
rowHeight += (size.Height - lastHeight / 2);
|
|
else
|
|
rowHeight += (size.Height / 2);
|
|
}
|
|
|
|
lastHeight = size.Height;
|
|
}
|
|
|
|
return (rowHeight);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetFlatHeight
|
|
|
|
private int GetFlatHeight(GridPanel panel)
|
|
{
|
|
int rowHeight = 0;
|
|
|
|
foreach (GridColumn column in panel.GroupColumns)
|
|
{
|
|
GridGroupBox box = new GridGroupBox(this, column);
|
|
|
|
box.GroupBoxStyle = GroupBoxStyle;
|
|
box.CornerRadius = CornerRadius;
|
|
|
|
_GroupBoxes.Add(box);
|
|
|
|
Size size = GetGroupBoxSize(box);
|
|
|
|
if (size.Height > rowHeight)
|
|
rowHeight = size.Height;
|
|
}
|
|
|
|
return (rowHeight);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetGroupBoxSize
|
|
|
|
private Size GetGroupBoxSize(GridGroupBox box)
|
|
{
|
|
Size size = new Size();
|
|
|
|
size.Width = box.Column.HeaderTextSize.Width + Dpi.Width(TextHPad);
|
|
size.Height = box.Column.HeaderTextSize.Height + Dpi.Height(TextVPad);
|
|
|
|
box.ContentSize = size;
|
|
|
|
SuperGrid.DoConfigureGroupBoxEvent(this, box);
|
|
|
|
size = box.ContentSize;
|
|
|
|
size.Width += Dpi.Width(box.Padding.Horizontal);
|
|
size.Height += Dpi.Height(box.Padding.Vertical);
|
|
|
|
int n = Dpi.Width(_MaxGroupBoxWidth);
|
|
|
|
if (size.Width > n)
|
|
size.Width = n;
|
|
|
|
size.Width += Dpi.Width(MarkerHPad + TextHPad);
|
|
|
|
if (size.Width < Dpi.Width20)
|
|
size.Width = Dpi.Width20;
|
|
|
|
if (size.Height < Dpi.Height15)
|
|
size.Height = Dpi.Height15;
|
|
|
|
box.RelativeBounds = new Rectangle(Point.Empty, size);
|
|
|
|
return (size);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region ArrangeRow
|
|
|
|
/// <summary>
|
|
/// ArrangeRow
|
|
/// </summary>
|
|
/// <param name="layoutInfo"></param>
|
|
/// <param name="stateInfo"></param>
|
|
/// <param name="layoutBounds"></param>
|
|
/// <returns></returns>
|
|
protected override Size ArrangeRow(GridLayoutInfo layoutInfo,
|
|
GridLayoutStateInfo stateInfo, Rectangle layoutBounds)
|
|
{
|
|
UpdateGroupBoxes(stateInfo.GridPanel, layoutBounds);
|
|
|
|
return (base.ArrangeRow(layoutInfo, stateInfo, layoutBounds));
|
|
}
|
|
|
|
#region UpdateGroupBoxes
|
|
|
|
private void UpdateGroupBoxes(GridPanel panel, Rectangle r)
|
|
{
|
|
TextRowVisualStyle tstyle = GetEffectiveStyle();
|
|
|
|
r = GetAdjustedBounds(tstyle, r);
|
|
r.Size = Size.Empty;
|
|
|
|
if (CanShowRowHeader(panel) == true)
|
|
r.X += panel.RowHeaderWidthEx;
|
|
|
|
r.X += Dpi.Width(MarkerWidth - MarkerHPad);
|
|
r.Y += Dpi.Height(MarkerVPad - MarkerHeight + TextPad);
|
|
|
|
GridGroupBox box = _GroupBoxes[0];
|
|
box.RelativeBounds = r;
|
|
|
|
int lastHeight = Dpi.Width(MarkerHeight);
|
|
int midline = Bounds.Y + Bounds.Height / 2 - 1;
|
|
|
|
for (int i = 1; i < _GroupBoxes.Count; i++)
|
|
{
|
|
box = _GroupBoxes[i];
|
|
|
|
r.X += (r.Width + Dpi.Width(BoxSpacing));
|
|
r.Size = box.RelativeBounds.Size;
|
|
|
|
if (GroupBoxLayout == GroupBoxLayout.Hierarchical)
|
|
{
|
|
r.Y += (r.Height > lastHeight)
|
|
? lastHeight / 2 : lastHeight - r.Height / 2;
|
|
}
|
|
else
|
|
{
|
|
r.Y = midline - (r.Height / 2);
|
|
}
|
|
|
|
UpdateGroupBoxRects(panel, box, ref r);
|
|
|
|
lastHeight = r.Height;
|
|
}
|
|
|
|
_AfterGroupBox = null;
|
|
}
|
|
|
|
#region UpdateGroupBoxRects
|
|
|
|
private void UpdateGroupBoxRects(
|
|
GridPanel panel, GridGroupBox box, ref Rectangle r)
|
|
{
|
|
Rectangle t = r;
|
|
|
|
Rectangle ts = GetSortImageBounds(panel, box.Column, t);
|
|
Rectangle tf = GetFilterImageBounds(panel, box.Column, t);
|
|
|
|
if (ts.Width > 0)
|
|
r.Width += (ts.Width + TextPad);
|
|
|
|
if (tf.Width > 0)
|
|
r.Width += (tf.Width + TextPad);
|
|
|
|
r.Width += 3;
|
|
|
|
box.RelativeBounds = r;
|
|
|
|
if (tf.IsEmpty == false && ts.IsEmpty == false)
|
|
{
|
|
if (ts.X == tf.X)
|
|
{
|
|
if (tf.X < r.X + r.Width / 2)
|
|
tf.X += ts.Width + TextPad;
|
|
else
|
|
ts.X += tf.Width + TextPad;
|
|
}
|
|
else
|
|
{
|
|
if (tf.X < r.X + r.Width / 2)
|
|
ts.X = r.Right - (ts.Width + TextPad);
|
|
else
|
|
tf.X = r.Right - (tf.Width + TextPad);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ts.Width > 0 && ts.X > r.X + r.Width / 2)
|
|
ts.X = r.Right - (ts.Width + TextPad);
|
|
|
|
if (tf.Width > 0 && tf.X > r.X + r.Width / 2)
|
|
tf.X = r.Right - (tf.Width + TextPad);
|
|
}
|
|
|
|
box.FilterImageRelBounds = tf;
|
|
box.SortImageRelBounds = ts;
|
|
}
|
|
|
|
#region GetSortImageBounds
|
|
|
|
private Rectangle GetSortImageBounds(
|
|
GridPanel panel, GridColumn column, Rectangle r)
|
|
{
|
|
if (AllowUserSort == true)
|
|
{
|
|
Image sortImage = panel.ColumnHeader.GetColumnSortImage(panel, column);
|
|
|
|
if (sortImage != null)
|
|
{
|
|
Alignment alignment = (panel.ColumnHeader.SortImageAlignment == Alignment.NotSet)
|
|
? Alignment.MiddleLeft : panel.ColumnHeader.SortImageAlignment;
|
|
|
|
return (GetImageBoundsEx(sortImage, alignment, r));
|
|
}
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetFilterImageBounds
|
|
|
|
private Rectangle GetFilterImageBounds(
|
|
GridPanel panel, GridColumn column, Rectangle r)
|
|
{
|
|
Image filterImage = null;
|
|
|
|
switch (_FilterImageVisibility)
|
|
{
|
|
case ImageVisibility.Auto:
|
|
case ImageVisibility.Always:
|
|
if (column.IsFilteringEnabled == true)
|
|
filterImage = panel.ColumnHeader.GetFilterImage(column);
|
|
break;
|
|
|
|
case ImageVisibility.NotSet:
|
|
filterImage = panel.ColumnHeader.GetColumnFilterImage(column);
|
|
break;
|
|
}
|
|
|
|
if (filterImage != null)
|
|
{
|
|
Alignment alignment = panel.ColumnHeader.FilterImageAlignment;
|
|
|
|
if (alignment == Alignment.NotSet)
|
|
alignment = Alignment.MiddleLeft;
|
|
|
|
return (GetImageBoundsEx(filterImage, alignment, r));
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetImageBoundsEx
|
|
|
|
private Rectangle GetImageBoundsEx(
|
|
Image image, Alignment alignment, Rectangle r)
|
|
{
|
|
Rectangle t = r;
|
|
t.Size = image.Size;
|
|
|
|
t.X += Dpi.Width6;
|
|
t.Y += (r.Height - t.Height) / 2;
|
|
|
|
switch (alignment)
|
|
{
|
|
case Alignment.TopLeft:
|
|
case Alignment.MiddleLeft:
|
|
case Alignment.BottomLeft:
|
|
break;
|
|
|
|
default:
|
|
t.X = r.Right + Dpi.Width3;
|
|
break;
|
|
}
|
|
|
|
return (t);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RenderRow
|
|
|
|
/// <summary>
|
|
/// RenderRow
|
|
/// </summary>
|
|
/// <param name="renderInfo"></param>
|
|
/// <param name="panel"></param>
|
|
/// <param name="r"></param>
|
|
protected override void RenderRow(
|
|
GridRenderInfo renderInfo, GridPanel panel, Rectangle r)
|
|
{
|
|
base.RenderRow(renderInfo, panel, r);
|
|
|
|
Graphics g = renderInfo.Graphics;
|
|
|
|
if (CanShowRowHeader(panel) == true)
|
|
{
|
|
r.X += panel.RowHeaderWidthEx;
|
|
r.Width -= panel.RowHeaderWidthEx;
|
|
}
|
|
|
|
Region oldClip = g.Clip;
|
|
|
|
try
|
|
{
|
|
g.SetClip(r, CombineMode.Intersect);
|
|
|
|
if (_GroupBoxes.Count > 1)
|
|
{
|
|
GridPanelVisualStyle pstyle = panel.GetEffectiveStyle();
|
|
GridGroupBox lastBox = null;
|
|
|
|
foreach (GridGroupBox box in _GroupBoxes)
|
|
{
|
|
if (box.Column != null)
|
|
{
|
|
RenderGroupBox(panel, box, lastBox, g, pstyle);
|
|
lastBox = box;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RenderWaterMarkText(panel, g);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
g.Clip = oldClip;
|
|
}
|
|
|
|
if (_InsertRect.IsEmpty == false)
|
|
g.DrawImageUnscaled(InsertMarker, _InsertRect);
|
|
}
|
|
|
|
#region RenderGroupBox
|
|
|
|
private void RenderGroupBox(GridPanel panel,
|
|
GridGroupBox box, GridGroupBox lastBox, Graphics g, GridPanelVisualStyle pstyle)
|
|
{
|
|
StyleType type = GetGroupByStyleType(box);
|
|
|
|
ColumnHeaderVisualStyle cstyle = panel.ColumnHeader.GetEffectiveStyle(box.Column, type);
|
|
GroupByVisualStyle style = GetGroupByEffectiveStyle(box);
|
|
|
|
Rectangle r = box.Bounds;
|
|
|
|
if (r.Width > 0 && r.Height > 0)
|
|
{
|
|
if (SuperGrid.DoPreRenderGroupBoxEvent(g,
|
|
this, box, RenderParts.Background, r) == false)
|
|
{
|
|
int radius = GetCornerRadius(box);
|
|
|
|
if (radius > 0 && box.GroupBoxStyle == GroupBoxStyle.RoundedRectangular)
|
|
RenderRoundedBox(g, style, cstyle, pstyle, lastBox, box, radius);
|
|
else
|
|
RenderRectBox(g, style, cstyle, pstyle, lastBox, box);
|
|
|
|
SuperGrid.DoPostRenderGroupBoxEvent(g,
|
|
this, box, RenderParts.Background, r);
|
|
}
|
|
|
|
Rectangle t = r;
|
|
|
|
RenderSortImage(g, panel, box, ref t);
|
|
RenderFilterImage(g, panel, box, ref t);
|
|
|
|
int n = box.Padding.Left + TextHPad;
|
|
|
|
t.X += n;
|
|
t.Width -= n;
|
|
|
|
if (t.Width - box.ContentSize.Width > 0)
|
|
t.Width = box.ContentSize.Width;
|
|
|
|
if (SuperGrid.DoPreRenderGroupBoxEvent(g,
|
|
this, box, RenderParts.Content, t) == false)
|
|
{
|
|
Rectangle t2 = t;
|
|
|
|
t.Y += box.Padding.Top;
|
|
t.Height = box.Column.HeaderTextSize.Height + 6;
|
|
|
|
RenderText(g, box.Column, style, cstyle, t);
|
|
|
|
SuperGrid.DoPostRenderGroupBoxEvent(g,
|
|
this, box, RenderParts.Content, t2);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region GetCornerRadius
|
|
|
|
internal int GetCornerRadius(GridGroupBox box)
|
|
{
|
|
int maxRadius = Math.Min(
|
|
box.RelativeBounds.Width, box.RelativeBounds.Height) / 2;
|
|
|
|
int radius = Math.Min(box.CornerRadius, maxRadius);
|
|
|
|
return (radius > 0 ? radius : 0);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderRoundedBox
|
|
|
|
private void RenderRoundedBox(Graphics g, GroupByVisualStyle style,
|
|
ColumnHeaderVisualStyle cstyle, GridPanelVisualStyle pstyle,
|
|
GridGroupBox leftBox, GridGroupBox box, int radius)
|
|
{
|
|
Rectangle r = box.Bounds;
|
|
|
|
using (GraphicsPath path = GetRoundedPath(r, radius))
|
|
{
|
|
SmoothingMode sm = g.SmoothingMode;
|
|
g.SmoothingMode = SmoothingMode.AntiAlias;
|
|
|
|
if (_UseColumnHeaderColors == true)
|
|
{
|
|
using (Brush br = cstyle.Background.GetBrush(r))
|
|
g.FillPath(br, path);
|
|
|
|
using (Pen pen = new Pen(pstyle.HeaderLineColor))
|
|
g.DrawPath(pen, path);
|
|
}
|
|
else
|
|
{
|
|
using (Brush br = style.GroupBoxBackground.GetBrush(r))
|
|
g.FillPath(br, path);
|
|
|
|
using (Pen pen = new Pen(style.GroupBoxBorderColor))
|
|
g.DrawPath(pen, path);
|
|
}
|
|
|
|
if (leftBox != null)
|
|
{
|
|
Region oldClip = g.Clip;
|
|
Region newClip = new Region(Bounds);
|
|
|
|
newClip.Exclude(path);
|
|
|
|
g.SetClip(newClip, CombineMode.Intersect);
|
|
|
|
try
|
|
{
|
|
if (SuperGrid.DoPreRenderGroupBoxConnectorEvent(g, this, leftBox, box) == false)
|
|
{
|
|
RenderBoxConnector(g, style, leftBox.Bounds, box.Bounds, true);
|
|
|
|
SuperGrid.DoPostRenderGroupBoxConnectorEvent(g, this, leftBox, box);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
g.Clip = oldClip;
|
|
}
|
|
}
|
|
|
|
g.SmoothingMode = sm;
|
|
}
|
|
}
|
|
|
|
#region GetRoundedPath
|
|
|
|
private GraphicsPath GetRoundedPath(Rectangle r, int radius)
|
|
{
|
|
int diameter = radius << 1;
|
|
|
|
Rectangle t = r;
|
|
t.Size = new Size(diameter, diameter);
|
|
|
|
GraphicsPath path = new GraphicsPath();
|
|
path.AddArc(t, 180, 90);
|
|
|
|
t.X = r.Right - diameter;
|
|
path.AddArc(t, 270, 90);
|
|
|
|
t.Y = r.Bottom - diameter;
|
|
path.AddArc(t, 0, 90);
|
|
|
|
t.X = r.X;
|
|
path.AddArc(t, 90, 90);
|
|
|
|
path.CloseAllFigures();
|
|
|
|
return (path);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RenderRectBox
|
|
|
|
private void RenderRectBox(Graphics g, GroupByVisualStyle style,
|
|
ColumnHeaderVisualStyle cstyle, GridPanelVisualStyle pstyle,
|
|
GridGroupBox leftBox, GridGroupBox box)
|
|
{
|
|
Rectangle r = box.Bounds;
|
|
|
|
if (_UseColumnHeaderColors == true)
|
|
{
|
|
using (Brush br = cstyle.Background.GetBrush(r))
|
|
g.FillRectangle(br, r);
|
|
|
|
using (Pen pen = new Pen(pstyle.HeaderLineColor))
|
|
g.DrawRectangle(pen, r);
|
|
}
|
|
else
|
|
{
|
|
using (Brush br = style.GroupBoxBackground.GetBrush(r))
|
|
g.FillRectangle(br, r);
|
|
|
|
using (Pen pen = new Pen(style.GroupBoxBorderColor))
|
|
g.DrawRectangle(pen, r);
|
|
}
|
|
|
|
if (leftBox != null)
|
|
{
|
|
if (SuperGrid.DoPreRenderGroupBoxConnectorEvent(g, this, leftBox, box) == false)
|
|
{
|
|
RenderBoxConnector(g, style, leftBox.Bounds, r, false);
|
|
|
|
SuperGrid.DoPostRenderGroupBoxConnectorEvent(g, this, leftBox, box);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderBoxConnector
|
|
|
|
private void RenderBoxConnector(Graphics g,
|
|
GroupByVisualStyle style, Rectangle l, Rectangle r, bool extend)
|
|
{
|
|
using (Pen pen = new Pen(style.GroupBoxConnectorColor))
|
|
{
|
|
if (GroupBoxLayout == GroupBoxLayout.Hierarchical)
|
|
{
|
|
Point pt1 = new Point(l.X + l.Width / 2, l.Bottom + 1);
|
|
Point pt2 = new Point(pt1.X, l.Bottom + (r.Bottom - l.Bottom) / 2);
|
|
Point pt3 = new Point(r.X + (extend ? 10 : -1), pt2.Y);
|
|
|
|
g.DrawLines(pen, new Point[] { pt1, pt2, pt3 });
|
|
}
|
|
else
|
|
{
|
|
Point pt1 = new Point(l.Right + 1, l.Y + l.Height / 2 + 1);
|
|
Point pt2 = new Point(r.X - 1, pt1.Y);
|
|
|
|
g.DrawLine(pen, pt1, pt2);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Render Filter/Sort Image
|
|
|
|
#region RenderSortImage
|
|
|
|
private void RenderSortImage(
|
|
Graphics g, GridPanel panel, GridGroupBox box, ref Rectangle t)
|
|
{
|
|
GridColumn column = box.Column;
|
|
Rectangle bounds = box.SortImageBounds;
|
|
|
|
if (bounds.IsEmpty == false)
|
|
{
|
|
Image sortImage =
|
|
panel.ColumnHeader.GetColumnSortImage(panel, column);
|
|
|
|
RenderImage(g, sortImage, bounds, ref t);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RenderFilterImage
|
|
|
|
private void RenderFilterImage(
|
|
Graphics g, GridPanel panel, GridGroupBox box, ref Rectangle t)
|
|
{
|
|
GridColumn column = box.Column;
|
|
Rectangle bounds = box.FilterImageBounds;
|
|
|
|
if (bounds.IsEmpty == false)
|
|
{
|
|
if (CanShowFilterImage(panel, box) == true)
|
|
{
|
|
bool inFilter;
|
|
StyleState state = GetFilterImageState(box, out inFilter);
|
|
|
|
Image filterImage =
|
|
panel.ColumnHeader.GetFilterImage(column, state, inFilter);
|
|
|
|
RenderImage(g, filterImage, bounds, ref t);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region CanShowFilterImage
|
|
|
|
private bool CanShowFilterImage(GridPanel panel, GridGroupBox box)
|
|
{
|
|
switch (_FilterImageVisibility)
|
|
{
|
|
case ImageVisibility.Auto:
|
|
if (box.Column.IsFilteringEnabled == true)
|
|
{
|
|
if (string.IsNullOrEmpty(box.Column.FilterExpr) == false)
|
|
return (true);
|
|
|
|
return (_Dragging == false && box.IsEqualTo(_HitGroupBox) == true);
|
|
}
|
|
break;
|
|
|
|
case ImageVisibility.Always:
|
|
if (box.Column.IsFilteringEnabled == true)
|
|
return (true);
|
|
break;
|
|
|
|
case ImageVisibility.NotSet:
|
|
|
|
switch (panel.ColumnHeader.FilterImageVisibility)
|
|
{
|
|
case ImageVisibility.Always:
|
|
return (true);
|
|
|
|
case ImageVisibility.Never:
|
|
return (false);
|
|
|
|
case ImageVisibility.Auto:
|
|
if (string.IsNullOrEmpty(box.Column.FilterExpr) == false)
|
|
return (true);
|
|
|
|
return (_Dragging == false && box.IsEqualTo(_HitGroupBox) == true);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetFilterImageState
|
|
|
|
private StyleState GetFilterImageState(GridGroupBox box, out bool inFilter)
|
|
{
|
|
inFilter = false;
|
|
|
|
StyleState state = StyleState.Default;
|
|
|
|
if (box.IsEqualTo(_HitGroupBox) == true)
|
|
{
|
|
state = StyleState.MouseOver;
|
|
|
|
if (_HitArea == HeaderArea.InFilterMenu)
|
|
inFilter = true;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(box.Column.FilterExpr) == false)
|
|
state |= StyleState.Selected;
|
|
|
|
return (state);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RenderImage
|
|
|
|
private void RenderImage(Graphics g,
|
|
Image image, Rectangle r, ref Rectangle t)
|
|
{
|
|
if (image != null)
|
|
{
|
|
g.DrawImageUnscaledAndClipped(image, r);
|
|
|
|
if (r.X < t.X + t.Width / 2)
|
|
{
|
|
int n = t.Right - r.Right;
|
|
|
|
t.X = r.Right;
|
|
t.Width = n;
|
|
}
|
|
else
|
|
{
|
|
int n = t.Right - r.Left;
|
|
|
|
t.Width -= n;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region RenderText
|
|
|
|
private void RenderText(Graphics g, GridColumn column,
|
|
GroupByVisualStyle style, ColumnHeaderVisualStyle cstyle, Rectangle bounds)
|
|
{
|
|
string s = column.GetHeaderText();
|
|
|
|
if (s != null)
|
|
{
|
|
if (column.HeaderTextMarkup != null)
|
|
{
|
|
RenderTextMarkup(g, column.HeaderTextMarkup, cstyle, bounds);
|
|
}
|
|
else
|
|
{
|
|
if (_UseColumnHeaderColors == true)
|
|
{
|
|
eTextFormat tf = cstyle.GetTextFormatFlags();
|
|
|
|
TextDrawing.DrawString(g, s,
|
|
cstyle.Font, cstyle.TextColor, bounds, tf);
|
|
}
|
|
else
|
|
{
|
|
eTextFormat tf = style.GetTextFormatFlags();
|
|
|
|
TextDrawing.DrawString(g, s,
|
|
cstyle.Font, style.GroupBoxTextColor, bounds, tf);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region RenderTextMarkup
|
|
|
|
private void RenderTextMarkup(Graphics g,
|
|
BodyElement textMarkup, CellVisualStyle 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 RenderWaterMarkText
|
|
|
|
private void RenderWaterMarkText(GridPanel panel, Graphics g)
|
|
{
|
|
if (AllowSelection == true)
|
|
{
|
|
string s = GetWatermarkText();
|
|
|
|
if (string.IsNullOrEmpty(s) == false)
|
|
{
|
|
GroupByVisualStyle style = (GroupByVisualStyle)GetEffectiveStyle();
|
|
Rectangle t = GetAdjustedBounds(style, Bounds);
|
|
|
|
if (CanShowRowHeader(panel) == true)
|
|
{
|
|
t.X += panel.RowHeaderWidthEx;
|
|
t.Width -= panel.RowHeaderWidthEx;
|
|
}
|
|
|
|
TextDrawing.DrawString(g, s, style.WatermarkFont, style.WatermarkTextColor,
|
|
t, eTextFormat.VerticalCenter | eTextFormat.Left);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GroupBoxWindowPaint
|
|
|
|
void GroupBoxWindowPaint(object sender, PaintEventArgs e)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
GridPanelVisualStyle pstyle = panel.GetEffectiveStyle();
|
|
|
|
RenderGroupBox(panel,
|
|
(GridGroupBox)_GroupBoxWindow.Tag, null, e.Graphics, pstyle);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Mouse support
|
|
|
|
#region InternalMouseLeave
|
|
|
|
internal override void InternalMouseLeave(EventArgs e)
|
|
{
|
|
base.InternalMouseLeave(e);
|
|
|
|
if (_LockedColumn == false)
|
|
_HitGroupBox = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseMove
|
|
|
|
internal override void InternalMouseMove(MouseEventArgs e)
|
|
{
|
|
base.InternalMouseMove(e);
|
|
|
|
SuperGrid.GridCursor = Cursors.Default;
|
|
|
|
if (AllowSelection == true)
|
|
{
|
|
Point pt = e.Location;
|
|
|
|
_LastHitArea = _HitArea;
|
|
_LastHitGroupBox = _HitGroupBox;
|
|
|
|
_HitGroupBox = GetGroupBoxAt(pt);
|
|
_HitArea = GetHitArea(pt);
|
|
|
|
if (IsMouseDown == true)
|
|
{
|
|
if (_Dragging == true)
|
|
{
|
|
DragContinue(pt);
|
|
}
|
|
else if (_MouseDownHitBox != null)
|
|
{
|
|
if (Math.Abs(MouseDownPoint.X - pt.X) > 5 ||
|
|
Math.Abs(MouseDownPoint.Y - pt.Y) > 5)
|
|
{
|
|
DragStart(_MouseDownHitBox.Column);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (_HitArea)
|
|
{
|
|
case HeaderArea.InFilterMenu:
|
|
SuperGrid.GridCursor = Cursors.Hand;
|
|
break;
|
|
|
|
default:
|
|
SuperGrid.GridCursor = Cursors.Default;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (_HitArea != _LastHitArea || _LastHitGroupBox != _HitGroupBox)
|
|
{
|
|
if (_LastHitGroupBox != null)
|
|
InvalidateRender(_LastHitGroupBox.Bounds);
|
|
|
|
if (_HitGroupBox != null)
|
|
{
|
|
if ((_LastHitGroupBox != _HitGroupBox) ||
|
|
(_HitArea == HeaderArea.InFilterMenu || _LastHitArea == HeaderArea.InFilterMenu))
|
|
{
|
|
InvalidateRender(_HitGroupBox.Bounds);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseDown
|
|
|
|
internal override void InternalMouseDown(MouseEventArgs e)
|
|
{
|
|
base.InternalMouseDown(e);
|
|
|
|
if (e.Button == MouseButtons.Left)
|
|
{
|
|
_MouseDownHitBox = _HitGroupBox;
|
|
|
|
if (_MouseDownHitBox != null)
|
|
{
|
|
Capture = true;
|
|
|
|
if (_HitGroupBox.FilterImageRelBounds.Contains(e.Location) == true)
|
|
ProcessFilterHit(_MouseDownHitBox);
|
|
else
|
|
ProcessContentHit();
|
|
|
|
InvalidateRender(_MouseDownHitBox.Bounds);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region ProcessContentHit
|
|
|
|
private void ProcessContentHit()
|
|
{
|
|
_Dragging = false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ProcessFilterHit
|
|
|
|
private bool _LockedColumn = true;
|
|
|
|
private void ProcessFilterHit(GridGroupBox box)
|
|
{
|
|
if (_FilterMenu != null)
|
|
_FilterMenu.Dispose();
|
|
|
|
_LockedColumn = true;
|
|
|
|
_FilterMenu = new FilterPopup(GridPanel);
|
|
|
|
_FilterMenu.ActivatePopup(box.Column, box.FilterImageRelBounds, ResetState);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ResetState
|
|
|
|
internal void ResetState()
|
|
{
|
|
_HitGroupBox = null;
|
|
_LockedColumn = false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseUp
|
|
|
|
internal override void InternalMouseUp(MouseEventArgs e)
|
|
{
|
|
base.InternalMouseUp(e);
|
|
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (_GroupBoxWindow != null)
|
|
{
|
|
GridGroupBox box = (GridGroupBox)_GroupBoxWindow.Tag;
|
|
|
|
if (_AfterGroupBox != null)
|
|
{
|
|
int index = _GroupBoxes.IndexOf(_AfterGroupBox);
|
|
|
|
if (box.Column.GroupBoxEffectsEx == GroupBoxEffects.Move)
|
|
box.Column.Visible = false;
|
|
|
|
panel.InsertGroup(box.Column, index);
|
|
}
|
|
else if (box.Column.GroupBoxEffectsEx != GroupBoxEffects.None)
|
|
{
|
|
if (_HitColumn != null)
|
|
{
|
|
box.Column.Visible = true;
|
|
|
|
if (_HitColumn != box.Column)
|
|
ReorderColumn(panel, box.Column);
|
|
|
|
panel.RemoveGroup(box.Column);
|
|
|
|
panel.NeedsSorted = true;
|
|
}
|
|
}
|
|
|
|
DragEnd();
|
|
}
|
|
else
|
|
{
|
|
if (_HitGroupBox != null && _HitGroupBox == _MouseDownHitBox)
|
|
{
|
|
if (_HitArea == HeaderArea.InContent)
|
|
{
|
|
if (panel.IsSortable == true && _AllowUserSort == true)
|
|
{
|
|
if ((Control.ModifierKeys & Keys.Control) != Keys.Control)
|
|
{
|
|
panel.ColumnHeader.SortColumn(panel, _HitGroupBox.Column);
|
|
|
|
SuperGrid.PostInternalMouseMove();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_MouseDownHitBox != null)
|
|
{
|
|
InvalidateRender(_MouseDownHitBox.Bounds);
|
|
|
|
_MouseDownHitBox = null;
|
|
}
|
|
}
|
|
|
|
#region ReorderColumn
|
|
|
|
private void ReorderColumn(GridPanel panel, GridColumn column)
|
|
{
|
|
GridColumnCollection columns = panel.Columns;
|
|
|
|
int[] map = columns.DisplayIndexMap;
|
|
|
|
int curIndex = columns.GetDisplayIndex(column);
|
|
int sepIndex = columns.GetDisplayIndex(_HitColumn);
|
|
|
|
bool isRight = (_InsertRect.X >
|
|
_HitColumn.Bounds.X + _HitColumn.Bounds.Width / 2);
|
|
|
|
if (curIndex > sepIndex && isRight == true && sepIndex < map.Length - 1)
|
|
sepIndex++;
|
|
|
|
else if (curIndex < sepIndex && isRight == false && sepIndex > 0)
|
|
sepIndex--;
|
|
|
|
if (sepIndex != curIndex)
|
|
{
|
|
if (sepIndex < curIndex)
|
|
{
|
|
for (int i = curIndex; i > sepIndex; i--)
|
|
map[i] = map[i - 1];
|
|
}
|
|
else
|
|
{
|
|
for (int i = curIndex; i < sepIndex; i++)
|
|
map[i] = map[i + 1];
|
|
}
|
|
|
|
map[sepIndex] = column.ColumnIndex;
|
|
|
|
for (int i = 0; i < map.Length; i++)
|
|
columns[map[i]].DisplayIndex = i;
|
|
|
|
SuperGrid.UpdateStyleCount();
|
|
SuperGrid.PrimaryGrid.InvalidateRender();
|
|
|
|
SuperGrid.DoColumnMovedEvent(panel, column);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region InternalMouseDoubleClick
|
|
|
|
internal override void InternalMouseDoubleClick(MouseEventArgs e)
|
|
{
|
|
base.InternalMouseDoubleClick(e);
|
|
|
|
if (_RemoveGroupOnDoubleClick == true)
|
|
{
|
|
GridGroupBox box = _HitGroupBox;
|
|
|
|
if (box != null && box == _MouseDownHitBox)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel.IsSortable == false || _AllowUserSort == false ||
|
|
(Control.ModifierKeys & Keys.Control) == Keys.Control)
|
|
{
|
|
panel.RemoveGroup(box.Column);
|
|
|
|
panel.NeedsSorted = true;
|
|
|
|
box.Column.Visible = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetHitArea
|
|
|
|
/// <summary>
|
|
/// GetHitArea
|
|
/// </summary>
|
|
/// <param name="pt"></param>
|
|
/// <returns></returns>
|
|
public override HeaderArea GetHitArea(Point pt)
|
|
{
|
|
if (_HitGroupBox != null)
|
|
{
|
|
if (_HitGroupBox.FilterImageRelBounds.Contains(pt))
|
|
return (HeaderArea.InFilterMenu);
|
|
|
|
return (HeaderArea.InContent);
|
|
}
|
|
|
|
HeaderArea area = base.GetHitArea(pt);
|
|
|
|
if (area != HeaderArea.InContent)
|
|
return (area);
|
|
|
|
return (HeaderArea.InWhitespace);
|
|
}
|
|
|
|
#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);
|
|
|
|
r.Y += (style.BorderThickness.Top + style.Margin.Top + style.Padding.Top);
|
|
r.Height -= (style.BorderThickness.Vertical + style.Margin.Vertical + style.Padding.Vertical);
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetScrollBounds
|
|
|
|
internal Rectangle GetScrollBounds(Rectangle r)
|
|
{
|
|
if (IsVFrozen == false)
|
|
r.Y -= VScrollOffset;
|
|
|
|
r.X -= HScrollOffset;
|
|
|
|
return (r);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetGroupBoxAt
|
|
|
|
///<summary>
|
|
/// Gets the GroupBox containing the given point
|
|
///</summary>
|
|
///<param name="pt"></param>
|
|
///<returns>GroupBox, or null</returns>
|
|
public GridGroupBox GetGroupBoxAt(Point pt)
|
|
{
|
|
foreach (GridGroupBox box in _GroupBoxes)
|
|
{
|
|
if (box.Bounds.Contains(pt) == true)
|
|
return (box);
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region FindGroupPartition
|
|
|
|
private GridGroupBox FindGroupPartition(Point pt)
|
|
{
|
|
for (int i = _GroupBoxes.Count - 1; i >= 0; i--)
|
|
{
|
|
GridGroupBox box = _GroupBoxes[i];
|
|
|
|
if (pt.X > box.Bounds.X + box.Bounds.Width / 2)
|
|
return (box);
|
|
}
|
|
|
|
return (_GroupBoxes[0]);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Drag support
|
|
|
|
#region DragStart
|
|
|
|
internal bool DragStart(GridColumn column)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel.VirtualMode == true)
|
|
return (false);
|
|
|
|
if (AllowSelection == true && panel.ColumnHeader.Visible == true &&
|
|
column.GroupBoxEffectsEx != GroupBoxEffects.None)
|
|
{
|
|
Capture = true;
|
|
|
|
_Dragging = true;
|
|
|
|
_GroupBoxWindow = new FloatWindow();
|
|
_GroupBoxWindow.Opacity = .5;
|
|
_GroupBoxWindow.Owner = SuperGrid.FindForm();
|
|
_GroupBoxWindow.Paint += GroupBoxWindowPaint;
|
|
|
|
GridGroupBox box = new GridGroupBox(this, column);
|
|
|
|
box.GroupBoxStyle = GroupBoxStyle;
|
|
box.CornerRadius = CornerRadius;
|
|
|
|
Size size = GetGroupBoxSize(box);
|
|
Rectangle r = new Rectangle(Point.Empty, size);
|
|
|
|
UpdateGroupBoxRects(GridPanel, box, ref r);
|
|
|
|
box.RelativeBounds = r;
|
|
box.IsDragBox = true;
|
|
|
|
_GroupBoxWindow.Size = r.Size;
|
|
|
|
int radius = GetCornerRadius(box);
|
|
|
|
if (radius > 0 && box.GroupBoxStyle == GroupBoxStyle.RoundedRectangular)
|
|
{
|
|
using (GraphicsPath path = GetRoundedPath(r, radius))
|
|
{
|
|
GraphicsPath cpath = (GraphicsPath)path.Clone();
|
|
|
|
using (Pen pen = new Pen(Color.Black, 2))
|
|
cpath.Widen(pen);
|
|
|
|
Region rgn = new Region(path);
|
|
rgn.Union(cpath);
|
|
|
|
_GroupBoxWindow.Region = rgn;
|
|
}
|
|
}
|
|
|
|
_GroupBoxWindow.Tag = box;
|
|
|
|
return (true);
|
|
}
|
|
|
|
return (false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DragContinue
|
|
|
|
private void DragContinue(Point pt)
|
|
{
|
|
GridGroupBox box = _GroupBoxWindow.Tag as GridGroupBox;
|
|
|
|
if (box != null)
|
|
{
|
|
Point ptStart = pt;
|
|
|
|
Size size = box.RelativeBounds.Size;
|
|
size.Width++;
|
|
size.Height++;
|
|
|
|
pt.X -= (size.Width / 2);
|
|
pt.Y -= (size.Height / 2);
|
|
|
|
pt = SuperGrid.PointToScreen(pt);
|
|
|
|
Rectangle r = new Rectangle(pt, size);
|
|
|
|
_GroupBoxWindow.Bounds = r;
|
|
|
|
if (_GroupBoxWindow.Visible == false)
|
|
_GroupBoxWindow.Show();
|
|
|
|
Rectangle t = GetInsertRect(ptStart);
|
|
|
|
if (t.Equals(_InsertRect) == false)
|
|
{
|
|
InvalidateRender(_InsertRect);
|
|
|
|
_InsertRect = t;
|
|
|
|
InvalidateRender(_InsertRect);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region GetInsertRect
|
|
|
|
private Rectangle GetInsertRect(Point pt)
|
|
{
|
|
_HitColumn = null;
|
|
_AfterGroupBox = null;
|
|
|
|
if (Bounds.Contains(pt) == true)
|
|
return (GetGroupBoxInsertRect(pt));
|
|
|
|
return (GetColumnInsertRect(pt));
|
|
}
|
|
|
|
#region GetColumnInsertRect
|
|
|
|
private Rectangle GetColumnInsertRect(Point pt)
|
|
{
|
|
GridPanel panel = GridPanel;
|
|
|
|
if (panel.Bounds.Contains(pt) == true)
|
|
{
|
|
if (pt.Y >= Bounds.Bottom && pt.Y < Bounds.Bottom + 50)
|
|
{
|
|
_HitColumn = GetHitColumn(panel, pt);
|
|
|
|
if (_HitColumn == null)
|
|
_HitColumn = panel.Columns[0];
|
|
|
|
Rectangle t = Bounds;
|
|
Rectangle s = SViewRect;
|
|
|
|
if (panel.ShowRowHeaders == true &&
|
|
RowHeaderVisibility != RowHeaderVisibility.Never)
|
|
{
|
|
t.X += panel.RowHeaderWidthEx;
|
|
}
|
|
|
|
t.X += Dpi.Width2;
|
|
t.Width = s.Right - t.X - Dpi.Width2;
|
|
|
|
Rectangle r = _HitColumn.Bounds;
|
|
|
|
if (pt.X > r.X + r.Width / 2)
|
|
r.X = r.Right;
|
|
|
|
r.X -= (MarkerWidth / 2 + 1);
|
|
r.Y = t.Bottom - MarkerHeight - 2;
|
|
|
|
r.Width = MarkerWidth;
|
|
r.Height = MarkerHeight;
|
|
|
|
if (r.X < t.X)
|
|
r.X = t.X;
|
|
|
|
if (r.X > t.Right - MarkerWidth)
|
|
r.X = t.Right - MarkerWidth;
|
|
|
|
return (r);
|
|
}
|
|
}
|
|
|
|
return (Rectangle.Empty);
|
|
}
|
|
|
|
#region GetHitColumn
|
|
|
|
private GridColumn GetHitColumn(GridPanel panel, Point pt)
|
|
{
|
|
if (panel.Bounds.Contains(pt) == true)
|
|
{
|
|
if (pt.Y >= Bounds.Bottom && pt.Y < Bounds.Bottom + 50)
|
|
{
|
|
if (panel.FirstVisibleColumn != null && pt.X < panel.FirstVisibleColumn.Bounds.X)
|
|
return (panel.FirstVisibleColumn);
|
|
|
|
foreach (GridColumn col in panel.Columns)
|
|
{
|
|
if (col.Visible == true)
|
|
{
|
|
if (pt.X >= col.Bounds.X && pt.X <= col.Bounds.Right)
|
|
return (col);
|
|
}
|
|
}
|
|
|
|
return (panel.LastVisibleColumn);
|
|
}
|
|
}
|
|
|
|
return (null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region GetGroupBoxInsertRect
|
|
|
|
private Rectangle GetGroupBoxInsertRect(Point pt)
|
|
{
|
|
Rectangle t = Bounds;
|
|
|
|
_AfterGroupBox = FindGroupPartition(pt);
|
|
|
|
pt = new Point(_AfterGroupBox.Bounds.Right, _AfterGroupBox.Bounds.Y);
|
|
|
|
if (GroupBoxLayout == GroupBoxLayout.Flat)
|
|
{
|
|
int index = _GroupBoxes.IndexOf(_AfterGroupBox);
|
|
|
|
if (index + 1 < _GroupBoxes.Count)
|
|
{
|
|
GridGroupBox beforeBox = _GroupBoxes[index + 1];
|
|
|
|
if (index == 0 || beforeBox.Bounds.Y < pt.Y)
|
|
pt.Y = beforeBox.Bounds.Y;
|
|
}
|
|
|
|
pt.X -= 2;
|
|
pt.Y -= 9;
|
|
|
|
if (pt.Y < t.Y + 6)
|
|
pt.Y = t.Y + 6;
|
|
}
|
|
else
|
|
{
|
|
pt.X += 2;
|
|
pt.Y -= 6;
|
|
|
|
if (pt.Y < t.Y + 2)
|
|
pt.Y = t.Y + 2;
|
|
}
|
|
|
|
pt.X = Math.Max(pt.X, t.X + 2);
|
|
|
|
if (pt.X + MarkerWidth + 2 > ViewRect.Right)
|
|
pt.X = ViewRect.Right - MarkerWidth - 2;
|
|
|
|
return (new Rectangle(pt.X, pt.Y, MarkerWidth, MarkerHeight));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region DragEnd
|
|
|
|
private void DragEnd()
|
|
{
|
|
_Dragging = false;
|
|
|
|
if (_GroupBoxWindow != null)
|
|
{
|
|
_GroupBoxWindow.Close();
|
|
|
|
_GroupBoxWindow = null;
|
|
_MouseDownHitBox = null;
|
|
|
|
InvalidateRender(_InsertRect);
|
|
_InsertRect = Rectangle.Empty;
|
|
|
|
SuperGrid.PostInternalMouseMove();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region CancelCapture
|
|
|
|
/// <summary>
|
|
/// CancelCapture
|
|
/// </summary>
|
|
public override void CancelCapture()
|
|
{
|
|
if (CapturedItem == this)
|
|
{
|
|
Capture = false;
|
|
|
|
DragEnd();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Style support
|
|
|
|
#region GetNewVisualStyle
|
|
|
|
/// <summary>
|
|
/// GetNewVisualStyle
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected override TextRowVisualStyle GetNewVisualStyle()
|
|
{
|
|
return (new GroupByVisualStyle());
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ApplyStyleEx
|
|
|
|
/// <summary>
|
|
/// ApplyStyleEx
|
|
/// </summary>
|
|
/// <param name="style"></param>
|
|
/// <param name="css"></param>
|
|
protected override void ApplyStyleEx(TextRowVisualStyle style, StyleType[] css)
|
|
{
|
|
GroupByVisualStyle gstyle = style as GroupByVisualStyle;
|
|
|
|
if (gstyle != null)
|
|
{
|
|
foreach (StyleType cs in css)
|
|
{
|
|
gstyle.ApplyStyle(SuperGrid.BaseVisualStyles.GroupByStyles[cs]);
|
|
gstyle.ApplyStyle(SuperGrid.DefaultVisualStyles.GroupByStyles[cs]);
|
|
gstyle.ApplyStyle(GridPanel.DefaultVisualStyles.GroupByStyles[cs]);
|
|
}
|
|
|
|
if (gstyle.GroupBoxBorderColor == Color.Empty)
|
|
gstyle.GroupBoxBorderColor = Color.Blue;
|
|
|
|
if (gstyle.WatermarkTextColor == Color.Empty)
|
|
gstyle.WatermarkTextColor = Color.Gray;
|
|
|
|
if (gstyle.WatermarkFont == null)
|
|
gstyle.WatermarkFont = SystemFonts.DefaultFont;
|
|
}
|
|
|
|
InsertMarker = null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetGroupByEffectiveStyle
|
|
|
|
private GroupByVisualStyle GetGroupByEffectiveStyle(GridGroupBox box)
|
|
{
|
|
return ((GroupByVisualStyle)
|
|
GetEffectiveStyle(GetGroupByStyleType(box)));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GetGroupByStyleType
|
|
|
|
private StyleType GetGroupByStyleType(GridGroupBox box)
|
|
{
|
|
if (IsMouseDown == true)
|
|
{
|
|
Point pt = Control.MousePosition;
|
|
pt = SuperGrid.PointToClient(pt);
|
|
|
|
if (box.FilterImageBounds.Contains(pt) == false)
|
|
{
|
|
if (box.IsDragBox == true || box.IsEqualTo(_MouseDownHitBox))
|
|
{
|
|
if (box.IsEqualTo(_HitGroupBox) == true)
|
|
return (StyleType.SelectedMouseOver);
|
|
|
|
return (StyleType.Selected);
|
|
}
|
|
|
|
return (StyleType.Default);
|
|
}
|
|
}
|
|
|
|
if (box.IsEqualTo(_HitGroupBox) == true)
|
|
return (StyleType.MouseOver);
|
|
|
|
return (StyleType.Default);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|
|
|
|
#region GridGroupBox
|
|
|
|
///<summary>
|
|
/// GroupBox definition
|
|
///</summary>
|
|
public class GridGroupBox
|
|
{
|
|
#region Private properties
|
|
|
|
private GridGroupByRow _GridGroupBy;
|
|
private GridColumn _Column;
|
|
|
|
private Rectangle _RelativeBounds;
|
|
private Rectangle _SortImageRelBounds;
|
|
private Rectangle _FilterImageRelBounds;
|
|
|
|
private Padding _Padding = new Padding(0);
|
|
private GroupBoxStyle _GroupBoxStyle = GroupBoxStyle.Rectangular;
|
|
|
|
private bool _IsDragBox;
|
|
|
|
private Size _ContentSize;
|
|
private int _CornerRadius;
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
|
|
#region Bounds
|
|
|
|
///<summary>
|
|
/// Gets the associated Bounds
|
|
///</summary>
|
|
public Rectangle Bounds
|
|
{
|
|
get
|
|
{
|
|
if (_IsDragBox == true)
|
|
return (_RelativeBounds);
|
|
|
|
return (_GridGroupBy.GetScrollBounds(_RelativeBounds));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Column
|
|
|
|
///<summary>
|
|
/// Gets the associated GridColumn
|
|
///</summary>
|
|
public GridColumn Column
|
|
{
|
|
get { return (_Column); }
|
|
internal set { _Column = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ContentSize
|
|
|
|
///<summary>
|
|
/// Gets the associated Content Size
|
|
///</summary>
|
|
public Size ContentSize
|
|
{
|
|
get { return (_ContentSize); }
|
|
set { _ContentSize = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CornerRadius
|
|
|
|
///<summary>
|
|
/// Gets or sets the corner radius to
|
|
/// use when GroupBoxStyle is RoundedRectangular
|
|
///</summary>
|
|
public int CornerRadius
|
|
{
|
|
get { return (_CornerRadius); }
|
|
set { _CornerRadius = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GridGroupBy
|
|
|
|
///<summary>
|
|
/// Gets the associated GridGroupBy object
|
|
///</summary>
|
|
public GridGroupByRow GridGroupBy
|
|
{
|
|
get { return (_GridGroupBy); }
|
|
internal set { _GridGroupBy = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupBoxStyle
|
|
|
|
///<summary>
|
|
/// GroupBox Style
|
|
///</summary>
|
|
public GroupBoxStyle GroupBoxStyle
|
|
{
|
|
get { return (_GroupBoxStyle); }
|
|
set { _GroupBoxStyle = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Padding
|
|
|
|
///<summary>
|
|
/// Content padding
|
|
///</summary>
|
|
public Padding Padding
|
|
{
|
|
get { return (_Padding); }
|
|
set { _Padding = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Internal properties
|
|
|
|
#region FilterImageBounds
|
|
|
|
internal Rectangle FilterImageBounds
|
|
{
|
|
get
|
|
{
|
|
if (_IsDragBox == true || _FilterImageRelBounds.IsEmpty)
|
|
return (_FilterImageRelBounds);
|
|
|
|
return (_GridGroupBy.GetScrollBounds(_FilterImageRelBounds));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region FilterImageRelBounds
|
|
|
|
internal Rectangle FilterImageRelBounds
|
|
{
|
|
get { return (_FilterImageRelBounds); }
|
|
set { _FilterImageRelBounds = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsDragBox
|
|
|
|
internal bool IsDragBox
|
|
{
|
|
get { return (_IsDragBox); }
|
|
set { _IsDragBox = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region RelativeBounds
|
|
|
|
internal Rectangle RelativeBounds
|
|
{
|
|
get { return (_RelativeBounds); }
|
|
set { _RelativeBounds = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SortImageBounds
|
|
|
|
internal Rectangle SortImageBounds
|
|
{
|
|
get
|
|
{
|
|
if (_IsDragBox == true || _SortImageRelBounds.IsEmpty)
|
|
return (_SortImageRelBounds);
|
|
|
|
return (_GridGroupBy.GetScrollBounds(_SortImageRelBounds));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SortImageRelBounds
|
|
|
|
internal Rectangle SortImageRelBounds
|
|
{
|
|
get { return (_SortImageRelBounds); }
|
|
set { _SortImageRelBounds = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
internal GridGroupBox(GridGroupByRow groupBy, GridColumn column)
|
|
{
|
|
_GridGroupBy = groupBy;
|
|
_Column = column;
|
|
|
|
_GroupBoxStyle = groupBy.GroupBoxStyle;
|
|
}
|
|
|
|
#region IsEqualTo
|
|
|
|
internal bool IsEqualTo(GridGroupBox box)
|
|
{
|
|
return (box != null && box.Column == Column);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region enums
|
|
|
|
#region GroupBoxEffects
|
|
|
|
///<summary>
|
|
/// GroupBoxEffects
|
|
///</summary>
|
|
public enum GroupBoxEffects
|
|
{
|
|
///<summary>
|
|
/// Not set.
|
|
///</summary>
|
|
NotSet = -1,
|
|
|
|
///<summary>
|
|
/// The Column will not interact with the GroupBox.
|
|
///</summary>
|
|
None,
|
|
|
|
///<summary>
|
|
/// The Column presentation will be copied to and
|
|
/// from the grid and associated GroupBox.
|
|
///</summary>
|
|
Copy,
|
|
|
|
///<summary>
|
|
/// The Column presentation will be moved to and
|
|
/// from the grid and associated GroupBox.
|
|
///</summary>
|
|
Move,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupBoxLayout
|
|
|
|
///<summary>
|
|
/// GroupBox Layout
|
|
///</summary>
|
|
public enum GroupBoxLayout
|
|
{
|
|
///<summary>
|
|
/// Group boxes are Flat, all on the same layout row
|
|
///</summary>
|
|
Flat,
|
|
|
|
///<summary>
|
|
/// Group boxes are oriented Hierarchically
|
|
///</summary>
|
|
Hierarchical,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region GroupBoxStyle
|
|
|
|
///<summary>
|
|
/// GroupBox Style
|
|
///</summary>
|
|
public enum GroupBoxStyle
|
|
{
|
|
///<summary>
|
|
/// Group boxes are drawn Rectangular
|
|
///</summary>
|
|
Rectangular,
|
|
|
|
///<summary>
|
|
/// Group boxes are drawn Rounded Rectangular
|
|
///</summary>
|
|
RoundedRectangular,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|