Dialog<T>

Remarks: On some platforms, the abort button would be called automatically if the user presses the escape key

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: The client size differs from the Control.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 and minimize/maximize buttons. 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.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: The context menu is usually shown when the user right clicks the control, or in mobile platforms when the user taps and holds their finger down on the control.

Remarks: This can sometimes be useful to get the platform-specific object. Some handlers may not have any backing object for its functionality, so this may be null. It is more preferred to use the Widget.Handler and cast that to the platform-specific handler class which can give you additional methods and helpers to do common tasks. For example, the Application object's handler for OS X has a AddFullScreenMenuItem property to specify if you want full screen support in your app.

Remarks: Subclasses may override the standard behaviour so that hierarchy of widgets can be taken into account. For example, a Control may return the data context of a parent, if it is not set explicitly.

Remarks: On some platforms, the abort button would be called automatically if the user presses the return key on the form

Remarks: Typically when a control is disabled, the user cannot do anything with the control or any of its children. Including for example, selecting text in a text control. Certain controls can have a 'Read Only' mode, such as TextBox.ReadOnly which allow 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: This can be used to determine when to allow certain logic during the update of the data context. It is used to disable binding setters on the model when the data context changes so that a binding does not cause the view model to be updated when the state hasn't been fully set yet.

Remarks: When the widget is disposed, it can no longer be used.

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

Remarks: The Control.OnLoad(EventArgs) method sets this value to true after cascading to all children (for a Container) and calling the platform handler's implementation. It is called after adding to a loaded form, or when showing a new form. The Control.OnUnLoad(EventArgs) method will set this value to false when the control is removed from its parent

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.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: When the control is part of the visual tree (Control.IsVisualControl is true), this returns the logical parent that contains this control. Otherwise this is the same as Control.Parent.

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 window 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: Depending on the platform these buttons can be added on the left side or the right side. The lower the index the closer the button is to the edge.

Remarks: This sets the parent window that has ownership over this window. For a Dialog, this will be the window that will be disabled while the modal dialog is shown. With a Form, the specified owner will always be below the current window when shown, and will still be responsive to user input. Typically, but not always, the window will move along with the owner.

Remarks: This gets set to the current Platform.Instance during the construction of the object

Remarks: Depending on the platform these buttons can be added on the left side or the right side. The lower the index the closer the button is to the edge.

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

Remarks: Some platforms, e.g. macOS do not show a separate icon for each running window. You may also have to add the LSUIElement key to your app's Info.plist to make your app hidden in the dock. See https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/LaunchServicesKeys.html#//apple_ref/doc/uid/TP40009250-108256-TPXREF136

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: Styles allow you to attach custom platform-specific logic to a widget. In your platform-specific assembly, use Add{H} to add the style logic with the same id.

// in your UI
var control = new Button { Style = "mystyle" };

// in your platform assembly
using Eto.Mac.Forms.Controls;

Styles.AddHandler<ButtonHandler>("mystyle", handler => {
	// this is where you can use handler.Control to set properties, handle events, etc.
	handler.Control.BezelStyle = NSBezelStyle.SmallSquare;
});

Remarks: The style provider is used to style this container and its children.

Remarks: Use this to apply styles to any child controls of this container. By default, styles will apply to all children, including children of children unless DefaultStyleProvider.Inherit is set to false. Typically, you would set Inherit to false when creating composite controls that already have all their styles applied and you don't want any other styles to be inherited.

Remarks: This lists all available commands that can be mapped using the Control.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: The tab key only cycles through the controls within a window, so this has no effect for the window itself. Set Control.TabStop on the controls within the window instead.

Remarks: A common use of the tag property is to store data that is associated with the control that you can later retrieve.

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 not occupy space in the layout.

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: Some containers may use other Eto controls to layout its children, such as the StackLayout. This will return the parent control that visually contains this control as opposed to Control.Parent which will return the logical parent.

Remarks: This traverses up the parent chain to apply any cascading styles defined in parent container objects. Call this method on any child widget of a control.

Remarks: Use this to use a control directly in a native application. Note that the native application must be running the same framework as the current platform. E.g. a WinForms application can use an Eto.Forms control when using the Eto.WinForms platform. This prepares the control by firing the Control.PreLoad, Control.Load, etc. events.

Remarks: This captures all mouse events until Control.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: This is essentially a shortcut to myControl.Parent.Remove(myControl);

Remarks: This should only be called after Control.AttachNative() has been called, which is usually done by calling to ToNative(true).

Remarks: This method can be blocking on some platforms (Wpf, WinForms), and non-blocking on others (Mac, Gtk). Use the Control.DragEnd event to determine when the drag operation is completed and get its resulting DragEffects.

Remarks: This method can be blocking on some platforms (Wpf, WinForms), and non-blocking on others (Mac, Gtk). Use the Control.DragEnd event to determine when the drag operation is completed and get its resulting DragEffects.

Remarks: This is typically called from the constructor after all of the logic is completed to construct the object. If your handler interface has the AutoInitializeAttribute set to false, then you are responsible for calling this method in your constructor after calling the creation method on your custom handler.

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

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

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: You don't typically have to call this directly, but override it to apply styles to any child item(s) that may need styling at the same time. This is automatically done for any Container based control and its child controls.

Remarks: Implementors may override this to fire this event on child widgets in a heirarchy. This allows a control to be bound to its own BindableWidget.DataContext, which would be set on one of the parent control(s).

Remarks: To override default behaviour of the control, set MouseEventArgs.Handled property to true.

Remarks: This applies the cascading styles to the control and any of its children.

Remarks: This should be used from containers that use other Eto controls to layout its children but should not be part of the logical heirarchy.

Remarks: This should only be called on controls that the container owns. Otherwise, call Control.Detach()

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.SuspendLayout() before it.

Remarks: This is used by layout containers that may use other Eto controls to layout its children that shouldn't be necessary for users to be concerned about. For example, the StackLayout uses a TableLayout internally (for now), but the TableLayout should not be part of the logical tree of controls. If this is not set, then the logical parent of a child is the same as the visual parent.

Remarks: This is used by container authors to set the parent of a child before it is added to the underlying platform control. The assign parameter should call the handler method to add the child to the parent.

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.ResumeLayout() is called. Each call to SuspendLayout() must be balanced with a call to Control.ResumeLayout().

Remarks: When you implement IBindableWidgetContainer, this will also unbind any of its children.

Remarks: When you implement IBindableWidgetContainer, this will also update bindings for all of its children.

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. Note that this can be an expensive operation, so it is recommended to only call this method when necessary and after all of the controls have been added/updated.

Remarks: This may be fired in the event of a parent in the hierarchy setting the data context. For example, the Container widget fires this event when it's event is fired.

Remarks: This should perform any of the actual drop logic and update the control state to reflect the dropped data. Any cleanup should be performed in the Control.DragLeave event, which is called immediately before this event.

Remarks: For controls that you are dragging from this event is useful to know what to do with the dragged content after it is dropped in a different control or application.

Remarks: Use this event to 'clean up' any state of the control for the current drag operation. This will be called before the Control.DragDrop event.

Remarks: Note that not all controls can recieve keyboard focus.

Remarks: A control is loaded when it is part of the control hierarchy and is shown on a window. When the control is removed from the hierarchy, or the window is closed, the Control.UnLoad event will be called.

Remarks: This is a good place to reposition a Window before it is shown.

Remarks: Note that not all controls can recieve keyboard focus

Remarks: If you do not set the MouseEventArgs.Handled property to true, and the default behaviour of the control does not accept double clicks, the Control.MouseDown event will be called for each click of the mouse button. For example, if the user clicks twice in succession, the following will be called:

1. MouseDown for the first click
2. MouseDoubleClick for the second click
3. If Handled has not been set in #2, MouseDown will be called a 2nd time

Remarks: Controls will typically capture the mouse after a mouse button is pressed and will be released only after the Control.MouseUp event.

Remarks: The mouse is captured after a Control.MouseDown event within the control, and is released when the mouse button is released

Remarks: Control.KeyDown is raised by the control that has the keyboard focus and bubbles up the widget tree, so it only ever sees keys that Eto itself is routing. This is raised for every key going to the window no matter what owns the focus, including content that is not part of the widget tree at all such as a control hosted by NativeControlHost or a WebView, whose keys are handled entirely by the platform and never surface as Eto events. Use it to notice that the user is typing somewhere in a window; use Control.KeyDown to handle or suppress a key. This only observes, it never consumes: the focused control always goes on to receive the key, which is why KeyMonitorEventArgs has no way to mark the event as handled. Keys are reported as pressed, ahead of any input method, so a key that only contributes to an IME composition is still reported even though it produces no text on its own. This reports keys, not text, and the character a key produces is deliberately not included. Working out which window a key is destined for is best effort on some platforms. On Windows it is inferred from the focused window at the time the key is dispatched, which can be wrong while a platform modal or menu tracking loop is running.

Remarks: See Window.PreviewKeyDown for how this differs from Control.KeyUp, and for the caveats that apply to both.

Remarks: This event fires when the Control.Visible property changes, or when initially showing a control on a form.