FloatingForm.IHandler

Remarks: Note that if you set both dimensions of the Size and/or Container.ClientSize, this will be set to false.

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: Where the platform provides an API to set both the size and location at once, handlers should use it so the window is repositioned and resized in a single operation instead of two separate steps.

Remarks: This is useful for windows that provide interaction but do not steal focus from the current window, such as a tooltip, popover, etc.

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: Note that on some platforms (e.g. Windows) this also hides the system menu if Window.IHandler.Minimizable and Window.IHandler.Maximizable are also false. Note that this does not prevent the window from being closed, to do that use the Window.Closing event.

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: The icon should have many variations, such as 16x16, 24x24, 32x32, 48x48, 64x64, etc. This ensures that the many places it is used (title bar, task bar, switch window, etc) all have optimized icon sizes. For OS X, the application icon is specified in the .app bundle, not by this value.

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: Note that in multi-monitor setups, the origin of the location is at the upper-left of Screen.PrimaryScreen. Also note, that on Linux systems running GTK via Wayland, the location is relative to the Window.Owner when one is set and the Window.IHandler.WindowStyle is WindowStyle.None; otherwise it will always point to 0, 0 and setting it to different values will have no effect. Using Control.PointToScreen(PointF) on a control within the Window.Owner can be used to position the window relative to specific elements of the owner.

Remarks: This indicates the number of pixels per logical pixel. All units in Eto.Forms such as control size, drawing operations, etc are in logical pixels. When not in high DPI, this will be 1.0; Retina displays in OS X will return 2; and in windows this matches the scale set in the monitor settings. Use the Window.LogicalPixelSizeChanged to detect when the window is moved to a display with a different DPI.

Remarks: This may hide or disable the minimize button on the title bar.

Remarks: Some platforms have a global menu bar (e.g. ubuntu, OS X). When the winow is in focus, the global menu bar will be changed to reflect the menu assigned.

Remarks: This may hide or disable the maximize button on the title bar.

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

Remarks: This is useful to retrieve the desired size and position of the window even though it is currently maximized or minimized.

Remarks: When true, the form will become the active/focussed window when the Form.IHandler.Show() method is called. When false, the form will show but will not get focus until the user clicks on the form.

Remarks: Some platforms, e.g. OS X do not show a separate icon for each running window.

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: The title of the window is displayed to the user usually at the top of the window, but in cases where you show a window in a mobile environment, this may be the title shown in a navigation controller.

Remarks: Note that each window can only have a single tool bar

Remarks: The window should be above all other windows when this is true. In some platforms, this will show above all other windows only when the application has focus.

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: Note that once a window is closed, it cannot be shown again in most platforms.

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.