/// <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 = Size.Empty;
if (stateInfo.GridPanel.ShowRowHeaders == true)
sizeNeeded = MeasureRowHeader(stateInfo.GridPanel);
Size size = Size.Empty;
if (stateInfo.GridPanel.VirtualMode == true)
{
size.Width = GetColumnsWidth(stateInfo);
size.Height = stateInfo.GridPanel.VirtualRowHeight;
}
else
{
int rowHeight = GetRowHeight();
if (rowHeight == 0)
{
size = MeasureCells(layoutInfo, stateInfo);
}
else
{
size.Width = GetColumnsWidth(stateInfo);
size.Height = rowHeight;
}
}
sizeNeeded.Width += size.Width;
sizeNeeded.Height = Math.Max(size.Height, sizeNeeded.Height);
sizeNeeded.Height = Math.Max(sizeNeeded.Height, stateInfo.GridPanel.MinRowHeight);
sizeNeeded.Height = Math.Min(sizeNeeded.Height, stateInfo.GridPanel.MaxRowHeight);
_EffectivePreDetailRowHeight = GetRowPreDetailHeight();
_EffectivePostDetailRowHeight = GetRowPostDetailHeight();
SuperGrid.DoRowGetDetailHeightEvent(this, layoutInfo,
sizeNeeded, ref _EffectivePreDetailRowHeight, ref _EffectivePostDetailRowHeight);
sizeNeeded.Height += (_EffectivePreDetailRowHeight + _EffectivePostDetailRowHeight);
FixedRowHeight = sizeNeeded.Height;
HasVisibleItems = false;
if (Rows != null && Rows.Count > 0)
{
if (Expanded == true)
{
GridLayoutStateInfo itemStateInfo = new
GridLayoutStateInfo(stateInfo.GridPanel, stateInfo.IndentLevel + 1);
size = MeasureSubItems(layoutInfo, itemStateInfo, constraintSize);
sizeNeeded.Width = Math.Max(size.Width, sizeNeeded.Width);
sizeNeeded.Height += size.Height;
}
else
{
HasVisibleItems = AnyVisibleItems();
}
}
Size = sizeNeeded;
}
/// <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;
}
/// <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>
/// 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)
{
GridPanel panel = stateInfo.GridPanel;
if (panel.ColumnHeader.Visible == true)
panel.ColumnHeader.UpdateImageBounds(panel, this);
if (NeedsFilterScan == true || panel.NeedsFilterScan == true)
{
NeedsFilterScan = false;
if (FilterAutoScan == true)
FilterScan.BeginScan();
}
}
private Size GetMaximumCellSize(GridItemsCollection rows,
int firstRow, int lastRow, GridLayoutInfo layoutInfo, GridLayoutStateInfo layoutState)
{
Size size = Size.Empty;
for (int i = firstRow; i < lastRow; i++)
{
if (i >= rows.Count)
break;
GridContainer item = rows[i] as GridContainer;
if (item != null)
{
Size cellSize = Size.Empty;
if (item is GridRow)
{
cellSize = GetMaxRowCellSize(
(GridRow) item, layoutInfo, layoutState);
}
else if (item is GridGroup)
{
cellSize = GetMaximumCellSize(
item.Rows, 0, lastRow - i, layoutInfo, layoutState);
}
size.Width = Math.Max(size.Width, cellSize.Width);
size.Height = Math.Max(size.Height, cellSize.Height);
}
}
return (size);
}
private int GetColumnWidth(GridLayoutInfo layoutInfo,
GridLayoutStateInfo stateInfo, ColumnAutoSizeMode autoSizeMode,
IEnumerable<GridElement> items, int width, int maxHeight, ref int height)
{
GridPanel panel = GridPanel;
if (panel != null)
{
if (panel.VirtualMode == true)
{
if (panel.VirtualRowCount > 0)
{
int n = GetVirtualColumnWidthEx(layoutInfo,
stateInfo, autoSizeMode, ref height);
width = Math.Max(width, n);
}
}
else
{
int n = GetColumnWidthEx(layoutInfo,
stateInfo, autoSizeMode, items, maxHeight, ref height);
width = Math.Max(width, n);
}
}
return (width);
}
private int GetColumnWidthEx(GridLayoutInfo layoutInfo,
GridLayoutStateInfo stateInfo, ColumnAutoSizeMode autoSizeMode,
IEnumerable<GridElement> items, int maxHeight, ref int height)
{
int width = 0;
foreach (GridElement item in items)
{
GridRow row = item as GridRow;
if (row != null && row.Visible == true)
{
if (ColumnIndex < row.GridPanel.Columns.Count)
{
if (ColumnIndex < row.Cells.Count)
{
GridCell cell = row.Cells[ColumnIndex];
if (maxHeight <= 0 || height < maxHeight)
{
MeasureCell(layoutInfo, stateInfo, autoSizeMode, row, cell);
width = Math.Max(width, cell.CellSize.Width);
height += cell.Size.Height;
}
else
{
cell.NeedsMeasured = true;
}
}
else
{
width = Math.Max(width, Width);
}
}
if (row.Rows != null && row.Expanded == true)
{
GridLayoutStateInfo itemStateInfo = new
GridLayoutStateInfo(stateInfo.GridPanel, stateInfo.IndentLevel + 1);
width = GetColumnWidth(layoutInfo, itemStateInfo,
autoSizeMode, row.Rows, width, maxHeight, ref height);
}
}
else
{
if (item is GridGroup)
{
int n = GetColumnWidthEx(layoutInfo, stateInfo,
autoSizeMode, ((GridGroup) item).Rows, maxHeight, ref height);
width = Math.Max(width, n);
}
}
}
return (width);
}
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.RowHeaderWidth;
GroupHeaderVisualStyle style = GetSizingStyle(panel);
Size size = MeasureGroupText(g, style, constraintSize);
if (size.Height > 0)
{
size.Height += 8;
size.Width += style.Padding.Horizontal;
size.Height += style.Padding.Vertical;
}
size.Height = Math.Max(size.Height, panel.GroupHeaderHeight);
sizeNeeded.Width += size.Width;
sizeNeeded.Height = Math.Max(size.Height, sizeNeeded.Height);
if (panel.ShowGroupUnderline == true && size.Height > 0)
sizeNeeded.Height += 4;
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;
}
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 = panel.LevelIndentSize.Width;
r.Height -= style.Padding.Vertical;
if (r.Height < panel.GroupHeaderHeight)
r.Height = panel.GroupHeaderHeight;
if (CanShowRowHeader(panel) == true)
r.X += panel.RowHeaderWidth;
int n = panel.TreeButtonIndent +
(panel.LevelIndentSize.Width * IndentLevel) - panel.LevelIndentSize.Width;
r.X += n;
if (r.Right > BoundsRelative.Right)
r.Width -= r.Right - BoundsRelative.Right;
r.X += style.Padding.Left;
r.Y += 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);
}
}
}
private void ArrangeCells(GridLayoutInfo layoutInfo,
GridLayoutStateInfo stateInfo, Rectangle bounds)
{
GridPanel panel = stateInfo.GridPanel;
if (panel.Columns.Count > 0)
{
int indentLevel = stateInfo.IndentLevel;
GridCellCollection cells = _Cells;
GridColumnCollection columns = panel.Columns;
int j = 0;
int[] map = columns.DisplayIndexMap;
for (int i = 0; i < map.Length; i++)
{
int index = map[i];
GridColumn column = columns[index];
if (column.Visible == true)
{
if (index < cells.Count)
{
GridCell cell = cells[index];
if (panel.GroupColumns.Count > 0)
{
cell.IndentLevel = (j == 0 ? indentLevel : 0);
}
else
{
cell.IndentLevel =
(panel.PrimaryColumnIndex == index) ? indentLevel : 0;
}
bounds.Width = column.Size.Width;
cell.Arrange(layoutInfo, stateInfo, bounds);
}
j++;
bounds.X += column.Size.Width;
}
}
}
}
///<summary>
/// This routine calculates and returns the maximum
/// row height based upon the individual measured heights
/// of each cell in the row, based upon the given array of
/// columns to included in the calculation process.
///</summary>
///<returns></returns>
public int GetMaximumRowHeight(GridColumn[] columns)
{
GridPanel panel = GridPanel;
if (panel != null)
{
int maxHeight = 0;
using (Graphics g = SuperGrid.CreateGraphics())
{
GridLayoutInfo layoutInfo = new GridLayoutInfo(g, panel.BoundsRelative);
GridLayoutStateInfo layoutState = new GridLayoutStateInfo(panel, 0);
foreach (GridColumn column in columns)
{
if (column != null &&
column.ColumnIndex < Cells.Count)
{
GridCell cell = Cells[column.ColumnIndex];
if (cell != null)
{
Size oldSize = cell.Size;
cell.Measure(layoutInfo, layoutState, new Size(column.Width, 0));
if (cell.Size.Height > maxHeight)
maxHeight = cell.Size.Height;
cell.Size = oldSize;
}
}
}
}
if (maxHeight > 0)
return (maxHeight);
}
return (GetRowHeight());
}
/// <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)
{
ContainerBounds = layoutBounds;
Rectangle bounds = layoutBounds;
bounds.Height = FixedRowHeight;
GridPanel panel = stateInfo.GridPanel;
IndentLevel = stateInfo.IndentLevel;
if (panel.ShowRowHeaders == true)
bounds.X += panel.RowHeaderWidth;
ArrangeCells(layoutInfo, stateInfo, bounds);
if (Rows != null && Expanded == true)
{
bounds = layoutBounds;
bounds.Y += FixedRowHeight;
bounds.Height -= FixedRowHeight;
GridLayoutStateInfo itemStateInfo =
new GridLayoutStateInfo(panel, IndentLevel + 1);
ArrangeSubItems(layoutInfo, itemStateInfo, bounds);
}
ArrangeLayoutCount = SuperGrid.ArrangeLayoutCount;
}
private Size MeasureCells(GridLayoutInfo layoutInfo,
GridLayoutStateInfo stateInfo)
{
GridPanel panel = stateInfo.GridPanel;
Size sizeNeeded = Size.Empty;
int rowHeight = GetRowHeight();
GridCellCollection cells = _Cells;
foreach (GridCell cell in cells)
{
if (cell.ColumnIndex < panel.Columns.Count)
{
GridColumn column = panel.Columns[cell.ColumnIndex];
if (column.Visible == true)
{
ColumnAutoSizeMode mode = column.GetAutoSizeMode();
Size size = column.BoundsRelative.Size;
if ((rowHeight == 0 && mode == ColumnAutoSizeMode.Fill) ||
cell.NeedsMeasured == true || column.NeedsMeasured == true ||
NeedsMeasured == true || panel.NeedsMeasured == true)
{
cell.Measure(layoutInfo, stateInfo, size);
}
size.Height = cell.MeasuredSize.Height;
if (mode != ColumnAutoSizeMode.Fill)
size.Width = cell.MeasuredSize.Width;
if (rowHeight != 0)
size.Height = rowHeight;
cell.Size = size;
sizeNeeded.Width += cell.Size.Width;
sizeNeeded.Height = Math.Max(cell.Size.Height, sizeNeeded.Height);
}
}
}
if (sizeNeeded.IsEmpty == true)
sizeNeeded = new Size(100, rowHeight);
return (sizeNeeded);
}
private int GetColumnsWidth(GridLayoutStateInfo stateInfo)
{
int width = 0;
GridColumnCollection columns = stateInfo.GridPanel.Columns;
foreach (GridColumn column in columns)
{
if (column.Visible == true)
width += column.Size.Width;
}
return (width);
}
private void ArrangeGrid(Graphics g)
{
ArrangeLayoutCount++;
GridLayoutInfo layoutInfo = GetGridLayoutInfo(g);
GridLayoutStateInfo stateInfo = new GridLayoutStateInfo(_PrimaryGrid, 0);
Size constraintSize = Size.Empty;
_PrimaryGrid.Measure(layoutInfo, stateInfo, constraintSize);
stateInfo.PassCount++;
NeedToUpdateIndicees = false;
if (HorizontalIsOver(layoutInfo) == true && _HScrollBarVisible)
{
if(_HScrollBarVisible)
layoutInfo.ClientBounds.Height -= HScrollBarHeight;
if (VerticalIsOver(layoutInfo) == true && _VScrollBarVisible)
layoutInfo.ClientBounds.Width -= VScrollBarWidth;
_PrimaryGrid.Measure(layoutInfo, stateInfo, constraintSize);
}
else
{
if (VerticalIsOver(layoutInfo) == true && _VScrollBarVisible)
{
layoutInfo.ClientBounds.Width -= VScrollBarWidth;
_PrimaryGrid.Measure(layoutInfo, stateInfo, constraintSize);
if (HorizontalIsOver(layoutInfo) == true && _HScrollBarVisible)
layoutInfo.ClientBounds.Height -= HScrollBarHeight;
}
}
layoutInfo.ClientBounds.Width = Math.Max(0, layoutInfo.ClientBounds.Width);
layoutInfo.ClientBounds.Height = Math.Max(0, layoutInfo.ClientBounds.Height);
EnableVScrollBar(layoutInfo);
EnableHScrollBar(layoutInfo);
ViewRect = Rectangle.Empty;
_PrimaryGrid.Arrange(layoutInfo, stateInfo, layoutInfo.ClientBounds);
ViewRect = Rectangle.Empty;
UpdateScrollBars(layoutInfo);
if (_ActiveEditor != null)
EditorCell.PositionEditPanel(_ActiveEditor);
if (NonModalEditorCell != null)
NonModalEditorCell.PositionEditPanel(_ActiveNonModalEditor);
if (ActiveFilterPanel != null)
_ActiveFilterPanel.PositionEditPanel();
}
/// <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 = Size.Empty;
GridPanel panel = stateInfo.GridPanel;
sizeNeeded.Width = panel.ColumnHeader.Size.Width;
sizeNeeded.Height = (_RowHeight > 0)
? _RowHeight : MeasureHeaderHeight(panel);
Size = sizeNeeded;
}
/// <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)
{
if (NeedsResized == true || NeedsMeasured == true || stateInfo.GridPanel.NeedsMeasured == true)
{
Size sizeNeeded = Size.Empty;
ColumnAutoSizeMode autoSizeMode = GetAutoSizeMode();
int baseWidth = MinimumWidth;
switch (autoSizeMode)
{
case ColumnAutoSizeMode.AllCells:
case ColumnAutoSizeMode.DisplayedCells:
case ColumnAutoSizeMode.ColumnHeader:
baseWidth = Math.Max(baseWidth, _HeaderSize.Width);
break;
}
int height = 0;
switch (autoSizeMode)
{
case ColumnAutoSizeMode.None:
sizeNeeded.Width = Math.Max(baseWidth, Width);
break;
case ColumnAutoSizeMode.AllCells:
case ColumnAutoSizeMode.AllCellsExceptHeader:
sizeNeeded.Width = GetColumnWidth(layoutInfo, stateInfo,
autoSizeMode, stateInfo.GridPanel.Rows, baseWidth, 0, ref height);
break;
case ColumnAutoSizeMode.ColumnHeader:
sizeNeeded = new Size(baseWidth, 0);
MarkRowsToMeasure(stateInfo.GridPanel.Rows);
break;
default:
sizeNeeded.Width = GetColumnWidth(layoutInfo, stateInfo, autoSizeMode,
stateInfo.GridPanel.Rows, baseWidth, layoutInfo.ClientBounds.Height, ref height);
break;
}
Size = sizeNeeded;
NeedsResized = false;
}
}
/// <summary>
/// This method is used by the items internally to invoke the measure pass to
/// get item size. Override MeasureOverride method to perform actual measuring.
/// </summary>
/// <param name="layoutInfo">Holds contextual layout information.</param>
/// <param name="stateInfo"></param>
/// <param name="constraintSize"></param>
internal void Measure(
GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize)
{
MeasureOverride(layoutInfo, stateInfo, constraintSize);
NeedsMeasured = false;
}
private int GetVirtualColumnWidthEx(GridLayoutInfo layoutInfo,
GridLayoutStateInfo stateInfo, ColumnAutoSizeMode autoSizeMode, ref int height)
{
GridPanel panel = GridPanel;
int start = panel.FirstOnScreenRowIndex;
int end = panel.LastOnScreenRowIndex;
int width = 0;
for (int i = start; i <= end; i++)
{
GridRow row = panel.VirtualRows[i];
if (ColumnIndex < row.GridPanel.Columns.Count)
{
if (ColumnIndex < row.Cells.Count)
{
GridCell cell = row.Cells[ColumnIndex];
MeasureCell(layoutInfo, stateInfo, autoSizeMode, row, cell);
width = Math.Max(width, cell.CellSize.Width);
height += cell.Size.Height;
}
else
{
width = Math.Max(width, Width);
}
}
}
return (width);
}
/// <summary>
/// Performs the arrange pass layout of the item when
/// the final position and size of the item has been set.
/// </summary>
/// <param name="layoutInfo">Layout information.</param>
/// <param name="stateInfo"></param>
/// <param name="layoutBounds"></param>
protected abstract void ArrangeOverride(
GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Rectangle layoutBounds);
private void MeasureCell(GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo,
ColumnAutoSizeMode autoSizeMode, GridRow row, GridCell cell)
{
if (cell.NeedsMeasured || NeedsMeasured || row.NeedsMeasured)
{
int rowHeight = row.GetRowHeight();
if (rowHeight > 0)
{
Size size = new Size(Width, rowHeight);
if (autoSizeMode != ColumnAutoSizeMode.None)
{
cell.Measure(layoutInfo, stateInfo, Size.Empty);
size.Width = cell.Size.Width;
size.Width += GetColumnIndent(stateInfo.IndentLevel);
}
else
{
cell.Measure(layoutInfo, stateInfo, size);
}
cell.Size = size;
}
else
{
Size size = Size.Empty;
if (autoSizeMode == ColumnAutoSizeMode.None)
{
size.Width = Width;
size.Width -= GetColumnIndent(stateInfo.IndentLevel);
size.Width = Math.Max(1, size.Width);
}
cell.Measure(layoutInfo, stateInfo, new Size(size.Width, 0));
if (autoSizeMode != ColumnAutoSizeMode.None)
{
size = cell.Size;
size.Width += GetColumnIndent(stateInfo.IndentLevel);
cell.Size = size;
}
else
{
size = cell.Size;
size.Width = Width;
cell.Size = size;
}
}
cell.CellSize = cell.Size;
}
}
/// <summary>
/// This method is used by the items internally to invoke the arrange pass after
/// location and size of the item has been set. Override ArrangeOverride method
/// to perform internal arranging.
/// </summary>
/// <param name="layoutInfo"></param>
/// <param name="stateInfo"></param>
/// <param name="layoutBounds"></param>
internal void Arrange(
GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Rectangle layoutBounds)
{
IsLayoutValid = true;
_BoundsRelative = layoutBounds;
ArrangeOverride(layoutInfo, stateInfo, layoutBounds);
}
///<summary>
/// This routine calculates and returns the maximum cell
/// size from each cell in the column, as limited by the
/// given row scope ('AllRows' or 'OnScreenRows').
/// If 'includeHeader' is true, then the width of the header
/// is included in the max calculation.
///</summary>
///<returns>Maximum cell size.</returns>
public Size GetMaximumCellSize(RowScope scope, bool includeHeader)
{
Size size = Size.Empty;
GridPanel panel = GridPanel;
if (panel != null)
{
using (Graphics g = SuperGrid.CreateGraphics())
{
GridLayoutInfo layoutInfo = new GridLayoutInfo(g, panel.BoundsRelative);
GridLayoutStateInfo layoutState = new GridLayoutStateInfo(panel, 0);
if (includeHeader == true)
{
Size oldSize = panel.ColumnHeader.Size;
panel.ColumnHeader.MeasureHeader(layoutInfo, Size.Empty, panel, this);
size.Width = _HeaderSize.Width;
panel.ColumnHeader.Size = oldSize;
}
if (panel.VirtualMode == true)
{
int firstRow = 0;
int lastRow = panel.VirtualRowCountEx;
if (scope == RowScope.OnScreenRows)
{
firstRow = panel.FirstOnScreenRowIndex;
lastRow = panel.LastOnScreenRowIndex + 1;
}
for (int i = firstRow; i < lastRow; i++)
{
GridRow row = panel.VirtualRows[i];
GridCell cell = row.Cells[ColumnIndex];
Size oldSize = cell.Size;
cell.Measure(layoutInfo, layoutState, Size.Empty);
int n = GetColumnIndent(layoutState.IndentLevel);
size.Width = Math.Max(size.Width, cell.Size.Width + n);
size.Height = Math.Max(size.Height, cell.Size.Height);
cell.Size = oldSize;
}
}
else
{
if (panel.Rows.Count > 0)
{
int firstRow = 0;
int lastRow = panel.Rows.Count;
if (scope == RowScope.OnScreenRows)
{
firstRow = panel.FirstOnScreenRowIndex;
lastRow = firstRow + 100;
}
Size cellSize = GetMaximumCellSize(
panel.Rows, firstRow, lastRow, layoutInfo, layoutState);
size.Width = Math.Max(size.Width, cellSize.Width);
size.Height = Math.Max(size.Height, cellSize.Height);
}
}
}
}
return (size);
}
/// <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 abstract void MeasureOverride(
GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize);
private Size GetMaxRowCellSize(GridRow row,
GridLayoutInfo layoutInfo, GridLayoutStateInfo layoutState)
{
if (row.Cells.Count <= ColumnIndex)
return (Size.Empty);
GridCell cell = row.Cells[ColumnIndex];
Size oldSize = cell.Size;
cell.Measure(layoutInfo, layoutState, Size.Empty);
Size size = cell.Size;
size.Width += GetColumnIndent(layoutState.IndentLevel);
cell.Size = oldSize;
if (row.Rows.Count > 0 && row.Expanded == true)
{
layoutState.IndentLevel++;
foreach (GridContainer item in row.Rows)
{
if (item is GridRow)
{
Size cellSize =
GetMaxRowCellSize((GridRow)item, layoutInfo, layoutState);
size.Width = Math.Max(size.Width, cellSize.Width);
size.Height = Math.Max(size.Height, cellSize.Height);
}
}
layoutState.IndentLevel--;
}
return (size);
}
/// <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)
{
}
protected virtual Size MeasureRow(
GridLayoutInfo layoutInfo, GridLayoutStateInfo stateInfo, Size constraintSize)
{
Size sizeNeeded = Size.Empty;
if (IsEmpty == false)
{
GridPanel panel = stateInfo.GridPanel;
TextRowVisualStyle style = GetSizingStyle(stateInfo.GridPanel);
Alignment imageAlignment = style.ImageAlignment;
Size imageSize = style.GetImageSize(style.Image);
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.RowHeaderWidth;
switch (imageAlignment)
{
case Alignment.TopCenter:
case Alignment.MiddleCenter:
case Alignment.BottomCenter:
break;
default:
width -= imageSize.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(imageSize.Height, size.Height) + borderSize.Height;
sizeNeeded.Width = Math.Max(size.Width, imageSize.Width) + borderSize.Width;
break;
case Alignment.TopCenter:
case Alignment.BottomCenter:
sizeNeeded.Width = Math.Max(size.Width, imageSize.Width) + borderSize.Width;
sizeNeeded.Height = size.Height + imageSize.Height + borderSize.Height;
break;
default:
sizeNeeded.Width = size.Width + imageSize.Width + borderSize.Width;
sizeNeeded.Height = Math.Max(imageSize.Height, size.Height) + borderSize.Height;
break;
}
if (RowHeight > 0)
sizeNeeded.Height = RowHeight;
sizeNeeded.Height += 1;
}
return (sizeNeeded);
}
/// <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 = Size.Empty;
GridPanel panel = stateInfo.GridPanel;
if (panel.ShowRowHeaders == true)
sizeNeeded.Width += panel.RowHeaderWidth;
GridColumnCollection columns = _Columns;
foreach (GridColumn column in columns)
{
Size size = MeasureHeader(layoutInfo, constraintSize, panel, column);
if (column.Visible == true)
{
sizeNeeded.Width += size.Width;
sizeNeeded.Height = Math.Max(size.Height, sizeNeeded.Height);
}
}
if (_RowHeight > 0)
sizeNeeded.Height = _RowHeight;
Size = sizeNeeded;
}
protected virtual Size ArrangeRow(GridLayoutInfo layoutInfo,
GridLayoutStateInfo stateInfo, Rectangle layoutBounds)
{
Size size = Size;
size.Width = stateInfo.GridPanel.ColumnHeader.BoundsRelative.Width;
return (size);
}
protected override Size ArrangeRow(GridLayoutInfo layoutInfo,
GridLayoutStateInfo stateInfo, Rectangle layoutBounds)
{
UpdateGroupBoxes(stateInfo.GridPanel, layoutBounds);
return (base.ArrangeRow(layoutInfo, stateInfo, layoutBounds));
}
