Control.IHandler
References- ThemedContainerHandler<TControl, TWidget, TCallback>
- ThemedControlHandler<TControl, TWidget, TCallback>
- ThemedContainerHandler<TControl, TWidget, TCallback>
Nothing matches.
Handler interface for Control
Properties
BackgroundColor
#Gets or sets the color for the background of the control
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.
Value: The color of the background.
Enabled
#Gets or sets a value indicating whether this Control is enabled and accepts user input.
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.
Value:
true if enabled; otherwise, false.HasFocus
#Gets a value indicating whether this instance has the keyboard input focus.
Value:
true if this instance has focus; otherwise, false.Remarks: Some platforms may use this to identify controls (e.g. web)
IsMouseCaptured
#Gets a value indicating this control currently has mouse capture
Remarks: Mouse capture can happen during a handled MouseDown event until MouseUp, or it can be captured explicitly via CaptureMouse().
Location
#Gets the location of the control as positioned by the container
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.
Value: The current location of the control
NativeHandle
nint NativeHandle { get; }
Gets the native platform-specific handle for integration purposes
Value: The native handle.
Size
#Gets or sets the size of the control. Use -1 to specify auto sizing for either the width and/or height.
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.
Value: The current size of the control
SupportedPlatformCommands
#Gets the supported platform commands that can be used to hook up system functions to user defined logic
Remarks: This lists all available commands that can be mapped using the MapPlatformCommand(string, Command) method of the control.
Value: The supported platform commands.
See Also: MapPlatformCommand(string, Command)
TabIndex
#Gets or sets the tab index order for this control within its container.
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.
Value: The index of the control in the tab order.
Gets or sets a value indicating whether the user can get to this control using the tab key.
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.Value:
true to include the control in the tab order (the default); false to skip it.Visible
#Gets or sets a value indicating whether this Control is visible to the user.
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.
Value:
true if visible; otherwise, false.VisualControls
#Gets an enumeration of controls that are in the visual tree.
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.
Value: The visual controls.
Methods
CaptureMouse
#Captures all mouse events to this control.
Remarks: This captures all mouse events until ReleaseMouseCapture() is called. Note that not all platforms will allow a mouse capture unless the mouse is currently down.
Returns:
true if the mouse was captured, false otherwise.void ClearGestures()
Removes all gestures from the control.
DoDragDrop
#Starts drag operation using this control as drag source.
Parameters:
| data (DataObject) | Drag data. |
| allowedEffects (DragEffects) | Allowed effects. |
| image (Image) | Custom drag image |
| cursorOffset (PointF) | Offset of the cursor to the drag image |
Focus
#void Focus()
Attempts to set the keyboard input focus to this control, or the first child that accepts focus
GetPreferredSize
#Gets the preferred size of this control given the specified
availableSize.Parameters:
| availableSize (SizeF) | The available size to determine the preferred size |
Returns: The preferred size this control would like to be, which can be larger than the specified
availableSize.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.
Initialize
void Initialize()
Called after the widget is constructed
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()
Invalidate
#Queues a repaint of the entire control on the screen
Remarks: This is only useful when the control is visible.
Parameters:
| invalidateChildren (bool) | True to invalidate all children, false to only invalidate the container |
Invalidate
#Queues a repaint of the specified
rect of the controlMapPlatformCommand
#Specifies a command to execute for a platform-specific command
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.SupportedPlatformCommandsParameters:
| systemCommand (string) | System command. |
| command (Command) | Command to execute, or null to restore to the default behavior |
See Also: SupportedPlatformCommands
Example:This example shows how to extend a control with cut/copy/paste for the mac platform:
var drawable = new Drawable();
if (drawable.Generator.IsMac)
{
drawable.MapPlatformCommand("cut", new MyCutCommand());
drawable.MapPlatformCommand("copy", new MyCopyCommand());
drawable.MapPlatformCommand("paste", new MyPasteCommand());
}OnUnLoad
#Called when the control is unloaded, which is when it is not currently on a displayed window
PointFromScreen
#Converts a point from screen space to control space.
Parameters:
| point (PointF) | Point in screen space |
Returns: The point in control space
PointToScreen
#Converts a point from control space to screen space
Parameters:
| point (PointF) | Point in control space |
Returns: The point in screen space
ReleaseMouseCapture
#void ReleaseMouseCapture()
Releases the mouse capture after a call to CaptureMouse().
ResumeLayout
#void ResumeLayout()
Resumes the layout after it has been suspended, and performs a layout
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 SuspendLayout() before it.
SetParent
#Called when the parent of the control has been set
SuspendLayout
#void SuspendLayout()
Suspends the layout of child controls
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 ResumeLayout() is called. Each call to SuspendLayout() must be balanced with a call to ResumeLayout().
UnhandleEvent
Called when the last subscriber to an event has been removed, so the platform can stop listening for it.
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.
Parameters:
| id (string) | ID of the event to stop handling |
UpdateLayout
#void UpdateLayout()
Updates the layout of this control if necessary.
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.