Base class for items in a menu
Constructors
MenuItem
#Initializes a new instance of the MenuItem class with the specified command.
Remarks: This links the menu item with the specified command, and will trigger Command.Execute() when the user clicks the item, and enable/disable the menu item based on Command.Enabled. This is not a weak link, so you should not re-use the Command instance for other menu items if you are disposing this menu item.
Parameters:
| command (Command) | Command to initialize the menu item with. |
Fields
Properties
Bindings
Gets the collection of bindings that are attached to this widget
Command
#Gets or sets the command to invoke when the menu item is pressed.
Remarks: This will invoke the specified command when the menu item is pressed. The ICommand.CanExecute(object) will also used to set the enabled/disabled state of the menu item.
Value: The command to invoke.
CommandParameter
#Gets or sets the parameter to pass to the Command when executing or determining its CanExecute state.
Value: The command parameter.
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.
DataContext
Gets or sets the data context for this widget for binding
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.
Implements: DataContext
Enabled
#Gets or sets a value indicating whether this MenuItem is enabled.
Value:
true if enabled; otherwise, false.Implements: Enabled
IsDataContextChanging
Gets a value indicating that the BindableWidget.DataContext property is changing.
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.
Value:
true if the DataContext is currently changing, false otherwise.Implements: IsDataContextChanging
IsDisposed
Gets or sets a value indicating whether this Widget has been disposed.
Remarks: When the widget is disposed, it can no longer be used.
Value:
true if this instance has been disposed; otherwise, false.NativeHandle
public nint NativeHandle { get; }
Gets the native platform-specific handle for integration purposes
Value: The native handle.
Order
#Gets or sets the order that the menu item should use when inserted into a submenu.
Remarks: The order can be used to sort your menu items when added in a different order. This is useful when you have menu items added from different areas of your program.
Value: The order to use when inserting into the submenu.
Parent
Gets or sets the parent widget which this widget has been added to, if any
Remarks: When implementing child widgets that can participate in the context based binding (MVVM), You can set this to the parent widget when it is added or removed to it (usually via a collection). Note that you should typically provide a
public new [ParentWidget] Parent { get; } property so that consumers of your API cannot set the parent to an invalid value.Value: The parent widget, or null if there is no parent
Parents
Gets an enumeration of all parent widgets in the heirarchy by traversing the BindableWidget.Parent property.
inherited fromWidget
Remarks: This gets set to the current Platform.Instance during the construction of the object
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.
Example:
// 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;
});Text
#Gets or sets the text of the menu item, with mnemonics identified with &.
Value: The text with mnemonic of the menu item.
Implements: Text
Visible
#Gets or sets a value indicating whether this MenuItem is visible.
Value:
true if visible; otherwise, false.Methods
Dispose
public void Dispose()
Disposes of this widget, supressing the finalizer
Parameters:
| disposing (bool) | True if the caller called Widget.Dispose() manually, false if being called from a finalizer |
FindParent<T>
Finds a control in the parent hierarchy with the specified type and Widget.ID if specified
Parameters:
| id (string = null) | Identifier of the parent control to find, or null to ignore |
Returns: The parent if found, or null if not found
FindParent
Finds a control in the parent hierarchy with the specified type and Widget.ID if specified
GetCallback
#Gets an instance of an object used to perform callbacks to the widget from handler implementations
Returns: The callback.
Overrides: Widget.GetCallback
Initialize
protected void Initialize()
Initializes the widget handler
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.
inherited fromBindableWidget
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).
Parameters:
| e (EventArgs) | Event arguments |
OnLoad
Called when the menu is assigned to a control/window
Parameters:
| e (EventArgs) | Event arguments |
OnPreLoad
Called before the menu is assigned to a control/window
Parameters:
| e (EventArgs) | Event arguments |
inherited fromWidget
OnUnLoad
Called when the menu is removed from a control/window
Parameters:
| e (EventArgs) | Event arguments |
PerformClick
#public virtual void PerformClick()
Performs the click handler for this item.
Remarks: This performs the click by calling OnClick(EventArgs) which triggers the Click event.
PerformValidate
#public virtual void PerformValidate()
Executes the OnValidate(EventArgs) for this item.
Remarks: This allows you to manually validate the menu item to determine its enabled state.
ToString
Gets a string that represents the current object with its ID if specified.
Returns: A string value indicating the type and ID (if specified) of this widget.
Overrides: Object.ToString
Unbind
#public override void Unbind()
Unbinds any bindings in the BindableWidget.Bindings collection and removes the bindings
Remarks: When you implement IBindableWidgetContainer, this will also unbind any of its children.
Overrides: BindableWidget.Unbind
UpdateBindings
Updates all bindings in this widget
Remarks: When you implement IBindableWidgetContainer, this will also update bindings for all of its children.
Parameters:
| mode (BindingUpdateMode = BindingUpdateMode.Source) |
Events
inherited fromBindableWidget
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.
Implements: DataContextChanged
inherited fromWidget
Validate
#Occurs when the menu item is validated.
Remarks: This is used to allow enabling/disabling items before they are shown to the user. Usually, platforms will call validate on all items each time they are shown in a submenu or context menu.