Arranges child controls in a grid of rows and columns. The common case is a two or three column grid where the first column holds labels describing values and the remaining columns hold the controls that edit those values, which produces something that looks like the Rhino object properties pages. Children fill the grid in row major order: a new row starts every ColumnCount children, so a two column grid built by adding label, control, label, control, ... reads the way it looks. Settings can be made before or after the grid is added to a document. The ones made beforehand are held here and applied when the native grid is created.

Constructors

UserInterfaceGrid

#Since v9.0
public UserInterfaceGrid()

UserInterfaceGrid

#Since v9.0
public UserInterfaceGrid(
columnCount
)

Properties

BackgroundClaimsMouse

#Since v9.0
Whether a click where the grid has no child control belongs to the grid or to whatever is behind it. The default is false, so clicks on the padding, on the gaps between cells and on empty cells go through to the viewport, which is what a heads up display over a model wants.
public bool BackgroundClaimsMouse { get; set; }

BackgroundColor

Color the control is filled with: the face of a button, the track of a slider, the box of a check box or radio button, the field of a text box, the whole rectangle of a label, icon or grid. Color.Empty, the default, means the control chooses the color for the theme that is in use and follows the theme when it changes. Labels and icons draw no background when this is Color.Empty. A grid fills with the theme's panel color when it is a top level control, and draws no background when it is inside another control. UserInterfaceGrid.BackgroundOpacity makes the theme color see through, or turns the background off at 0.
public Color BackgroundColor { get; set; }
inherited fromUserInterfaceControl

BackgroundOpacity

#Since v9.0
How opaque the background is, from 0 (not drawn at all) to 1 (solid, the default). Leave BackgroundColor as Color.Empty and the grid uses the theme's panel color at this opacity, which gives a see through panel over the model that still follows the theme. A BackgroundColor that was set is drawn at this opacity on top of its own alpha. The border is not affected.
public double BackgroundOpacity { get; set; }

BorderColor

#Since v9.0
public Color BorderColor { get; set; }

BorderThickness

#Since v9.0
public double BorderThickness { get; set; }

BoundToActiveView

public bool BoundToActiveView { get; set; }
inherited fromUserInterfaceObjectBase

ChildCount

#Since v9.0
Number of cells that have been filled, including the empty ones added with AddEmptyCell. This is not the same as ColumnCount * RowCount.
public int ChildCount { get; }

ColumnCount

#Since v9.0
Number of columns in the grid. The default is 1. Changing the column count reflows the children that have already been added.
public int ColumnCount { get; set; }

ColumnSpacing

#Since v9.0
Space between columns in logical pixels. The default is 6.
public double ColumnSpacing { get; set; }

CornerRadius

#Since v9.0
public double CornerRadius { get; set; }

HasKeyboardFocus

Does this object have keyboard focus? An object with keyboard focus gets first refusal on what is typed in a viewport; what it does not use carries on to the command line as usual.
public bool HasKeyboardFocus { get; }
inherited fromUserInterfaceObjectBase

HorizontalAlignment

public ControlHorizontalAlignment HorizontalAlignment { get; set; }
inherited fromUserInterfaceControl

Location

public PointF Location { get; set; }
inherited fromUserInterfaceControl

RowCount

#Since v9.0
Number of rows the current children occupy, computed from the child count, the column count and any column spans.
public int RowCount { get; }

RowHeight

#Since v9.0
Height of every row in logical pixels. The default is 0, which means each row is as tall as the tallest control in it.
public double RowHeight { get; set; }

RowSeparatorColor

#Since v9.0
public Color RowSeparatorColor { get; set; }

RowSeparators

#Since v9.0
Draw a horizontal line between every pair of rows. Off by default.
public bool RowSeparators { get; set; }

RowSpacing

#Since v9.0
Space between rows in logical pixels. The default is 2.
public double RowSpacing { get; set; }

Size

public SizeF Size { get; set; }
inherited fromUserInterfaceControl

Text

public virtual string Text { get; set; }
inherited fromUserInterfaceControl

TextColor

Color used to draw the text. Color.Empty, the default, means use the standard text color for the theme that is in use.
public Color TextColor { get; set; }
inherited fromUserInterfaceControl

TextHeight

Height of the text in logical pixels. A value of 0, the default, means use the standard control font height. Controls that draw no text ignore this setting.
public float TextHeight { get; set; }
inherited fromUserInterfaceControl

TextHorizontalAlignment

Where the text sits inside the control's rectangle. This is not the same as HorizontalAlignment, which is where the control sits inside its parent.
public ControlHorizontalAlignment TextHorizontalAlignment { get; set; }
inherited fromUserInterfaceControl

TextVerticalAlignment

Where the text sits inside the control's rectangle. This is not the same as VerticalAlignment, which is where the control sits inside its parent.
public ControlVerticalAlignment TextVerticalAlignment { get; set; }
inherited fromUserInterfaceControl

Tooltip

Text shown in a tooltip when the mouse rests over this object. Null or an empty string means no tooltip, which is what an object starts with. One tooltip is on screen at a time; whichever object the mouse is over owns it.
public string Tooltip { get; set; }
inherited fromUserInterfaceObjectBase

TrackingPoint

3d location that control "sticks" to if not null
public Point3d? TrackingPoint { get; set; }
inherited fromUserInterfaceControl

VerticalAlignment

public ControlVerticalAlignment VerticalAlignment { get; set; }
inherited fromUserInterfaceControl

Visible

Is the user interface object visible? Objects that are not visible will not be drawn and will not receive mouse events
public bool Visible { get; set; }
inherited fromUserInterfaceObjectBase

Methods

AddChild

#Since v9.0
Append a control to the next cell.
public void AddChild()

AddEmptyCell

#Since v9.0
Append a cell with nothing in it. Use this to leave a hole in a row.
public void AddEmptyCell()

AddHeading

#Since v9.0
Append a label that spans every column, for a section heading.
public UserInterfaceLabel AddHeading(
text
)

AddLabel

#Since v9.0
Append a label to the next cell, which is what most first column cells are. The label is returned so that its text alignment, color or height can be adjusted.
public UserInterfaceLabel AddLabel(
text
)

Cell

#Since v9.0
Control in a cell by row and column, or null when that cell is empty. The grid has to have been added to a document for this to find anything, since it is the native grid that knows which cell a child ended up in.
public UserInterfaceControl Cell(
row,
column
)

Child

#Since v9.0
Control in a cell, or null for an empty cell or an out of range index.
public UserInterfaceControl Child(
index
)

ComputedRectangle

public RectangleF ComputedRectangle(
view,
logicalPixels
)
inherited fromUserInterfaceControl

EnableRowSeparatorBelowRow

#Since v9.0
Draw a horizontal line under one row, for a heading row that wants a rule under it when a line between every row would be too much. RowSeparators draws them all whatever this is set to.
public void EnableRowSeparatorBelowRow(
row,
on
)

GetChildColumnSpan

#Since v9.0
public int GetChildColumnSpan(
index
)

GetColumnSizing

#Since v9.0
public UserInterfaceGridColumnSizing GetColumnSizing(
column
)

GetColumnWidth

#Since v9.0
Width of a column in logical pixels as of the most recent layout. This is 0 until the grid has been drawn once.
public double GetColumnWidth(
column
)

GetComputedRowHeight

#Since v9.0
Height of a row in logical pixels as of the most recent layout. This is 0 until the grid has been drawn once.
public double GetComputedRowHeight(
row
)

InsertChild

#Since v9.0
Insert a control at a cell index, shifting the controls after it along.
public void InsertChild()

IsMouseOver

Called to test if the mouse is actively over this object
protected virtual bool IsMouseOver()
inherited fromUserInterfaceObjectBase
Return true if the mouse is over this object

IsRegistered

Is this user interface object active
public bool IsRegistered()
inherited fromUserInterfaceObjectBase

OnDraw

All user interface objects are drawn and can customize their look with the OnDraw function
protected virtual void OnDraw()
inherited fromUserInterfaceObjectBase

OnMouseClick

Called during a mouse click event on this object
protected virtual void OnMouseClick()
inherited fromUserInterfaceObjectBase

OnMouseDoubleClick

Called during a mouse double click event on this object
protected virtual void OnMouseDoubleClick()
inherited fromUserInterfaceObjectBase

OnMouseDown

Called when the mouse goes down on this object
protected virtual void OnMouseDown(
mouse
Current mouse state when this event occurs
)
inherited fromUserInterfaceObjectBase

OnMouseEnter

Called when the mouse goes over this object
protected virtual void OnMouseEnter()
inherited fromUserInterfaceObjectBase

OnMouseLeave

Called when the mouse leaves this object
protected virtual void OnMouseLeave()
inherited fromUserInterfaceObjectBase

OnMouseMove

Called when the mouse is moved
protected virtual void OnMouseMove()
inherited fromUserInterfaceObjectBase

OnMouseUp

Called when the mouse is released on this object
protected virtual void OnMouseUp()
inherited fromUserInterfaceObjectBase

OnRunCommand

Called after the above RunCommand function is called. This will be executing while inside of a Rhino command.
protected virtual Result OnRunCommand(
doc,
Document that the command is running in
mode,
Interactive or scripted mode
mouse
Mouse state that was passed to RunCommand
)
inherited fromUserInterfaceObjectBase
Result of the command. The default implementation returns Success

RegisterForAllDocuments

Make this object visible for all documents. Typically you will only have user interface objects work with single documents. For that case, call doc.ViewUserInterface.Add
public bool RegisterForAllDocuments()
inherited fromUserInterfaceObjectBase

RemoveAllChildren

#Since v9.0
Empty the grid.
public void RemoveAllChildren()

RemoveChild

#Since v9.0
Take a control out of the grid. Returns the control that was in the cell, or null for an empty cell or an out of range index.
public UserInterfaceControl RemoveChild(
index
)

RunCommand

Call RunCommand to have the virtual OnRunCommand function executed in the scope of a Rhino command. If you are modifying the document from one of the mouse functions on this object, this is the best approach to do so since changes made inside of a command are recorded for undo.
public void RunCommand(
mouse
Current mouse state. This is handed back to OnRunCommand
)
inherited fromUserInterfaceObjectBase

SetChildColumnSpan

#Since v9.0
Number of columns a cell occupies. The default is 1. Use this for a section heading or a control that runs the full width of the grid. A span is clamped to the number of columns left in the row.
public void SetChildColumnSpan(
index,
span
)

SetColumnAutoWidth

#Since v9.0
Make a column as wide as the widest control in it. Controls report their width from their computed size, so a label column sized this way is exactly as wide as its longest description.
public void SetColumnAutoWidth(
column
)

SetColumnContentAlignment

#Since v9.0
How the controls in a column sit in their cells. The default is Stretch / Center, which makes a control fill the column width and center itself in the row. Any horizontal setting other than Stretch gives the control the width it reports from its computed size.
public void SetColumnContentAlignment()

SetColumnFixedWidth

#Since v9.0
Give a column a width in logical pixels that is never resized.
public void SetColumnFixedWidth(
column,
width
)

SetColumnFlexibleWidth

#Since v9.0
Have a column share the width the fixed and auto columns do not use. With one flexible column that column gets all of the remaining width; with more than one the remainder is divided in proportion to the weights.
public void SetColumnFlexibleWidth(
column,
weight
)

SetColumnMinimumWidth

#Since v9.0
Width a column never goes below, in logical pixels. The default is 0.
public void SetColumnMinimumWidth(
column,
minimumWidth
)

SetPadding

#Since v9.0
public void SetPadding(
left,
top,
right,
bottom
)

SetPadding

#Since v9.0
Space between the edges of the grid and its cells in logical pixels. The default is 6 on all four sides.
public void SetPadding(
padding
)

SetSvg

public void SetSvg(
svg
)
inherited fromUserInterfaceControl

Unregister

Unregister this object
public void Unregister()
inherited fromUserInterfaceObjectBase