public class ThemedFontDialogHandler : WidgetHandler<Widget, FontDialog, FontDialog.ICallback>, FontDialog.IHandler
A themed handler for the FontDialog control.
Properties
Callback
public TCallback Callback { get; }
Gets the callback object for the control
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
Control
public TControl Control { get; set; }
Gets or sets the platform-specific control object
DisposeControl
Gets a value indicating that control should automatically be disposed when this widget is disposed
HasControl
Gets a value indicating whether this instance has a WidgetHandler<TControl, TWidget>.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 |
Overrides: WidgetHandler<TWidget>.AttachEvent
CreateConnector
Creates the event connector for this control
Remarks: This creates the weak connector to use for event registration and other purposes.
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 WidgetHandler<TControl, TWidget>.DisposeControl is
trueParameters:
| disposing (bool) | True if WidgetHandler<TControl, TWidget>.Dispose(bool) was called manually, false if called from the finalizer |
Overrides: WidgetHandler<TWidget>.Dispose
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.
ShowDialog
#Shows the dialog with the specified parent window, blocking until a result is returned.
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