- WidgetHandler<TControl, TWidget, TCallback>
- ThemedControlHandler<TControl, TWidget, TCallback>
- ThemedContainerHandler<TControl, TWidget, TCallback>
- ThemedSegmentedItemHandler<TWidget, TCallback>
Nothing matches.
public abstract class WidgetHandler<TControl, TWidget> : WidgetHandler<TWidget>, IControlObjectSource
Base platform handler for Widget objects that have a backing platform object
Remarks: This is the base class for platform handlers. It is used to help wire up events and provide base functionality of a widget.
Type parameters:
| TControl | Type of the platform-specific object |
| TWidget | Type of widget the handler is for where Widget |
Example:This example shows how to implement a platform handler for a widget
// override the class and implement widget-specific interface
public MyWidgetHandler : WidgetHandler<MyPlatformControl, MyWidget>, IMyWidget
{
// implement IStaticWidget's properties and methods
}See Also: WidgetHandler<T, W>
Properties
Remarks: This object is typically a single static instance that is used by the platform handlers to call private or protected methods on the widget, such as protected event methods e.g. protected virtual void OnClick(EventArgs e)
Value: The callback.
Connector
#Gets a weak connector class to hook up events to the underlying control
Remarks: Some frameworks (e.g. gtk, monomac, ios, android) keep track of references in a way that leak objects when there is a circular reference between the control and the handler. This is the case when registering events from the control to a method implemented in the handler. This instance can be used to connect the objects together using a weak reference to the handler, allowing controls to be garbage collected.
Value: The connector instance
DisposeControl
#Gets a value indicating that control should automatically be disposed when this widget is disposed
Gets the platform-specific control object
HasControl
#Gets a value indicating whether this instance has a Control instance.
Value:
true if this instance has a control; otherwise, false.NativeHandle
public virtual nint NativeHandle { get; }
Gets the native platform-specific handle for integration purposes
Value: The native handle.
Implements: NativeHandle
Widget
public TWidget Widget { get; }
Gets the widget that this platform handler is attached to
Methods
AttachEvent
Attaches the specified event to the platform-specific control
Remarks: Implementors should override this method to handle any events that the widget supports. Ensure to call the base class' implementation if the event is not one the specific widget supports, so the base class' events can be handled as well.
Parameters:
| id (string) | Identifier of the event |
CreateConnector
#Creates the event connector for this control
Remarks: This creates the weak connector to use for event registration and other purposes.
See Also: Connector
CreateControl
#protected virtual TControl CreateControl()
Creates the control if not already set.
Remarks: Override this to create the control instance for the handler. This makes it easy to extend existing handler implementations with different control implementations. Some platforms (e.g. Mac) require subclasses to implement/override functionality.
Returns: The control.
DetachEvent
Detaches an event from the platform-specific control, undoing WidgetHandler<TWidget>.AttachEvent(string).
Remarks: Implementors can override this for events that hold onto something worth giving back while they are attached, such as a system wide hook. Most events cost nothing to leave attached for the life of the widget, which is why the default is to refuse. Only reached for events whose remove accessor uses PropertyStore.RemoveHandlerEvent(string, Delegate), and never for an event that is attached because the widget overrides its On[Event] method.
Parameters:
| id (string) | Identifier of the event |
Returns: True if the event was detached, false if this platform can't detach it, in which case it stays attached and won't be attached again on a later subscription.
Dispose
public void Dispose()
Disposes this object
Remarks: To handle disposal logic, use the WidgetHandler<TWidget>.Dispose(bool) method.
Dispose
#Disposes this widget and the associated control if DisposeControl is
trueParameters:
| disposing (bool) | True if Dispose(bool) was called manually, false if called from the finalizer |
Overrides: WidgetHandler<TWidget>.Dispose
GetControl
#public static TControl GetControl(TWidget widget)
Gets the platform-specific control object of the specified widget using this handler
Remarks: The widget must be using a handler that returns the same control. This can be used very easily by platform code:
MyControl mycontrol;
var platformControl = MyControlHandler.GetControl(mycontrol);Parameters:
| widget (TWidget) | The widget to get the platform-specific control from |
Returns: The platform-specific control used for the specified widget
HandleEvent
Called to handle a specific event
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. Override the WidgetHandler<TWidget>.AttachEvent(string) to attach your events
Parameters:
| id (string) | ID of the event to handle |
| defaultEvent (bool = false) | True if the event is default (e.g. overridden or via an event handler subscription) |
Implements: HandleEvent
Initialize
protected virtual void Initialize()
Called to initialize this widget after it has been constructed
Remarks: Override this to initialize any of the platform objects. This is called in the widget constructor, after all of the widget's constructor code has been called.
IsEventHandled
Gets a value indicating that the specified event is handled
Parameters:
| id (string) | Identifier of the event |
Returns: True if the event is handled, otherwise false
OnInitializeComplete
protected virtual void OnInitializeComplete()
Called after initialization is complete
Remarks: Override this to perform any logic after the handler is fully initialized, but before returning from the construction of the widget. This by default applies the any styles for the handler.
UnhandleEvent
Called when the last subscriber to an event has been removed, giving WidgetHandler<TWidget>.DetachEvent(string) the chance to stop listening for it.
Remarks: Override WidgetHandler<TWidget>.DetachEvent(string) rather than this, the same way WidgetHandler<TWidget>.AttachEvent(string) is overridden rather than WidgetHandler<TWidget>.HandleEvent(string, bool).
Parameters:
| id (string) | ID of the event to stop handling |
Implements: UnhandleEvent