Stepper

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: On some platforms and controls, such as macOS, the context menu can have additional items added by the system. Also the menu may appear when pressing different keys, such as a control-click on macOS, or when pressing the menu key on Windows keyboards. There is also some other semantic differences of using this vs. showing a context menu manually, such as on Windows, right clicking on a TextBox or TextArea will keep the selection visible, whereas this would not be the case if you showed the context menu manually.

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: 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: 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: A control's location is set by the container. This can be used to determine where the control is for overlaying floating windows, menus, etc.

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 gets set to the current Platform.Instance during the construction of the object

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: 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: 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(). This is useful for composite controls where only part of the control should be in the tab order, such as the spinner of a TextStepper or NumericStepper. The tab key only cycles through the controls within a window, so this has no effect for a Window. Note that on Gtk this maps directly to whether the underlying widget can be focused, so it also prevents the control from being focused by clicking on it, and controls that never accept focus (such as a Label) will report false. On iOS and Android this has no effect.

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

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: 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. Alternatively, implement IBindableWidgetContainer for your widget and this will trigger any events on the children automatically. 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 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 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: This event fires when the Control.Visible property changes, or when initially showing a control on a form.