GridColumn.IHandler

References
public interface GridColumn.IHandler : Widget.IHandler
Handler interface for the GridColumn.

Properties

AutoSize

#
bool AutoSize { get; set; }
Gets or sets a value indicating whether this column will auto size to the content of the grid.
Remarks: This usually will only auto size based on the visible content to be as performant as possible.
true to auto size the column; otherwise, false.

CellToolTipBinding

#
IIndirectBinding<string> CellToolTipBinding { get; set; }
Gets or sets the binding to use to get the tooltip for each cell in this column.

DataCell

#
Cell DataCell { get; set; }
Gets or sets the cell for the content of the column.

DisplayIndex

#
int DisplayIndex { get; set; }
Gets or sets the index of the column in display order, or -1 to use the order they are added.
Remarks: This value must be within the range of the total number of columns that are added.

Editable

#
bool Editable { get; set; }
Gets or sets a value indicating whether the user can edit the contents of the cells, if the DataCell allows it.

Expand

#
bool Expand { get; set; }
Gets or sets a value indicating whether this column should expand to fill the available space in the Grid
Remarks: If more than one column has this set, they will share the space evenly.
true to expand the column; otherwise, false

HeaderText

#
string HeaderText { get; set; }
Gets or sets the text to display in the header of the column.

HeaderTextAlignment

#
TextAlignment HeaderTextAlignment { get; set; }
Gets or sets a value to specify the header text alignment for this column

HeaderToolTip

#
string HeaderToolTip { get; set; }
Gets or sets the tooltip to display when the user moves the cursor over the header of this column.

ID

string ID { get; set; }
Gets or sets an ID for the widget
inherited fromWidget.IHandler
Remarks: Some platforms may use this to identify controls (e.g. web)

MaxWidth

#
int MaxWidth { get; set; }
Gets or sets the maximum width for the column

MinWidth

#
int MinWidth { get; set; }
Gets or sets the minimum width for the column

NativeHandle

nint NativeHandle { get; }
Gets the native platform-specific handle for integration purposes
inherited fromWidget.IHandler

Resizable

#
bool Resizable { get; set; }
Gets or sets a value indicating whether the column is resizable by the user.

Sortable

#
bool Sortable { get; set; }
Gets or sets a value indicating whether the user can click on the header.

Visible

#
bool Visible { get; set; }
Gets or sets a value indicating whether this column is visible.

Width

#
int Width { get; set; }
Gets or sets the initial width of the column.

Methods

HandleEvent

void HandleEvent(string id, bool defaultEvent = false)
Called to handle a specific event
inherited fromWidget.IHandler
Remarks: Most events are late bound by this method. Instead of wiring all events, this will be called with an event string that is defined by the control. This is called automatically when attaching to events, but must be called manually when users of the control only override the event's On... method.
id (string)ID of the event to handle
defaultEvent (bool = false)True if the event is default (e.g. overridden or via an event handler subscription)

Initialize

void Initialize()
Called after the widget is constructed
inherited fromWidget.IHandler
Remarks: This gets called automatically after the control is constructed and the Widget.IHandler.Widget and Widget.Platform properties are set. When the handler has specialized construction methods, then the AutoInitializeAttribute can be used to disable automatic initialization. In this case, it is the responsibility of the subclass to call Widget.Initialize()

UnhandleEvent

virtual void UnhandleEvent(string id)
Called when the last subscriber to an event has been removed, so the platform can stop listening for it.
inherited fromWidget.IHandler
Remarks: Only reached for events whose remove accessor uses PropertyStore.RemoveHandlerEvent(string, Delegate), and only for events that were attached because something subscribed to them. An event attached because the widget overrides its On[Event] method is never detached, since it has to keep firing regardless. Most events stay attached for the life of the widget, which costs nothing. Detaching is worth wiring up for the few that hold onto something expensive or process wide while they are attached, such as a system wide hook. Handlers deriving from WidgetHandler<TWidget> get an implementation of this that dispatches to WidgetHandler<TWidget>.DetachEvent(string), which is what to override.
id (string)ID of the event to stop handling