Window.IHandler

Remarks: Note that on some platforms (e.g. Mac), setting the background color of a control can change the performance characteristics of the control and its children, since it must enable layers to do so.

Remarks: The client size differs from the Size in that it excludes the decorations of the container, such as the title bar and border around a Window, or the title and line around a GroupBox.

Remarks: The main content will be offset by the Panel.IHandler.Padding value specified, and will take up the entire content area of the control. Some controls may have decorations that will surround the content, such as a GroupBox, TabControl, or Window

Remarks: Typically when a control is disabled, the user cannot do anything with the control (including for example, selecting text in a text control). Certain controls can have a 'Read Only' mode, such as TextBox.ReadOnly which allows the user to select text, but not change its contents.

Remarks: Some platforms may use this to identify controls (e.g. web)

Remarks: Mouse capture can happen during a handled MouseDown event until MouseUp, or it can be captured explicitly via Control.IHandler.CaptureMouse().

Remarks: This is mainly used when you want to use Eto controls in your handler, such as with the ThemedContainerHandler<TContainer, TWidget, TCallback>

Remarks: Setting the size of controls is entirely optional as most controls will size themselves appropriately. When specifying a size, it will be used as the desired size of the control. The container will reposition and resize the control depending on the available size. For a Window, it is preferred to set the Container.ClientSize instead, as various platforms have different sizes of window decorations, toolbars, etc.

Remarks: This lists all available commands that can be mapped using the Control.IHandler.MapPlatformCommand(string, Command) method of the control.

Remarks: This sets the order when using the tab key to cycle through controls Note that some platforms (Gtk and WinForms) may not support setting the context of the tab order to StackLayout or DynamicLayout containers and may not behave exactly as expected. Use the PlatformFeatures.TabIndexWithCustomContainers flag to determine if it is supported.

Remarks: When false, the control is skipped when cycling through controls with the tab key, but can still be focused by clicking on it or by calling Control.Focus(). Note that on Gtk this also prevents the control from being focused by clicking on it, and on iOS and Android this has no effect.

Remarks: When the visibility of a control is set to false, it will still occupy space in the layout, but not be shown. The only exception is for controls like the Splitter, which will hide a pane if the visibility of one of the panels is changed.

Remarks: This is used to specify which controls are contained by this instance that are part of the visual tree. This should include all controls including non-logical Eto controls used for layout.

Remarks: This captures all mouse events until Control.IHandler.ReleaseMouseCapture() is called. Note that not all platforms will allow a mouse capture unless the mouse is currently down.

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.

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()

Remarks: This is only useful when the control is visible.

Remarks: This is only useful when the control is visible.

Remarks: Some platforms have specific system-defined commands that can be associated with a control. For example, the Mac platform's cut/copy/paste functionality is defined by the system, and if you want to hook into it, you can use this to map it to your own defined logic. The valid values of the systemCommand parameter are defined by each platform, and a list can be retrieved using Control.SupportedPlatformCommands

var drawable = new Drawable();
if (drawable.Generator.IsMac)
{
	drawable.MapPlatformCommand("cut", new MyCutCommand());
	drawable.MapPlatformCommand("copy", new MyCopyCommand());
	drawable.MapPlatformCommand("paste", new MyPasteCommand());
}

Remarks: This can be used to optimize some platforms while adding, removing, or changing many child controls at once. Each call to ResumeLayout() must be balanced with a call to Control.IHandler.SuspendLayout() before it.

Remarks: This can be used to optimize some platforms while adding, removing, or changing many child controls at once. It disables the calculation of control positioning until Control.IHandler.ResumeLayout() is called. Each call to SuspendLayout() must be balanced with a call to Control.IHandler.ResumeLayout().

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.

Remarks: This will ensure the control has had all of its layout applied so you can use its position and size right after this call. Most platforms (except WinForms) use a deferred layout system so that after adding your control to the form dynamically it won't get laid out until the next idle loop. This is useful when you need to know the dimensions of the control immediately.