Class # MenuItem ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Warning
This item was deprecated in version 2021r3. Please use `DesktopMenuItem` as a replacement.
## Description An individual menu item in a desktop project. Used by menu bars and contextual menus. ## Properties
table-centered_columns_3_and_4
| Name | Type | Read-Only | Shared | |-------------------------------------------------------------|------------------------------------|-----------|--------| | `AutoEnabled` | `Boolean` | | | | `Enabled` | `Boolean` | | | | `Handle` | `Integer` | ✓ | | | `HasAltKey` | `Boolean` | ✓ | | | `HasCheckmark` | `Boolean` | | | | `HasMacControlKey` | `Boolean` | ✓ | | | `HasMacOptionKey` | `Boolean` | ✓ | | | `HasSecondaryModifierKey` | `Boolean` | ✓ | | | `HasStandardModifierKey` | `Boolean` | ✓ | | | `Icon` | `Picture` | | | | `Index` | `Integer` | ✓ | | | `LastRowIndex` | `Integer` | ✓ | | | `Name` | `String` | | | | `Shortcut` | `String` | | | | `ShortcutKey` | `String` | ✓ | | | `Tag` | `Variant` | | | | `Value` | `String` | | | | `Visible` | `Boolean` | | | ## Methods
table-centered_column_4
| Name | Parameters | Returns | Shared | |---------------------------------------|--------------------------------------------------------------------------------------------------------------------|------------------------------------|--------| | `AddMenu` | Item As MenuItem | | | | `AddMenuAt` | Index As `Integer`, Item As MenuItem | | | | `Child` | Name As `String` | MenuItem | | | `Clone` | | MenuItem | | | `Close` | | | | | `Constructor` | Text As `String`, \[Tag As `Variant` = `Nil`\] | | | | `Count` | | `Integer` | | | `MenuAt` | Index As `Integer` | MenuItem | | | `Popup` | \[x As `Integer`, y As `Integer`\] | MenuItem | | | `Remove` | Child As MenuItem | | | | `RemoveMenuAt` | Index As `Integer` | | | ## Events
table-centered_column_4
| Name | Parameters | Returns | |-----------------------------------|------------|------------------------------------| | `Action` | | `Boolean` | | `EnableMenu` | | | ## Constants The following class constant is used to add a separator item to a menu. Use this constant to add a separator with the AddMenu or AddMenuAt methods: | Class Constant | Description | |----------------|-------------------| | TextSeparator | A menu separator. | ## Property descriptions
forsearch
MenuItem.AutoEnabled **AutoEnabled** As `Boolean` If set to `True`, the MenuItem is enabled by default, as long as the `App` object or frontmost window has a menu handler for the MenuItem. There is no need to put code in the `EnableMenu` event handler to explicitly enable an autoenabled menu item. AutoEnabled is `True` by default. When you create dynamic menus by creating a new class based on MenuItem, AutoEnabled is also `True` by default. See the example on dynamic menus on the MenuItem page.
forsearch
MenuItem.Enabled **Enabled** As `Boolean` Indicates whether or not the menu item is enabled. For MenuItems that belong to an App or Window menu, this property should only be set to True in the EnableMenuItems event handler. You can set it for MenuItems created for use by `contextual menus` or for use with the `Popup` method. This example is in the EnableMenuItems event handler and it enables a menu. ``` xojo FilePageSetup.Enabled = True ```
forsearch
MenuItem.Handle **Handle** As `Integer` Provides access to the appropriate underlying platform menu implementation. This property is read-only. If the requested handle type doesn't make sense for the platform the application is running on, a PlatformNotSupportedException is raised. **MenuItem.HandleType** enumeration: - CocoaNSMenuItem: Returns the underlying NSMenuItem. If there is a submenu, the NSMenu can be got through NSMenuItem's submenu method. - WindowsParentHMENU: Returns the HMENU of the MenuItem if it is a submenu, otherwise it returns the parent's HMENU - WindowsCommandID: Returns the unique menu item identifier for the MenuItem, used by various Win32 APIs such as GetMenuItemInfo
forsearch
MenuItem.HasAltKey **HasAltKey** As `Boolean` The Alt key on Windows and Linux keyboards. If selected, the Alt key is must be held down while pressing the value of the Key property in order to trigger the event handler for the MenuItem. This property is for Windows and Linux only. This property is read-only. Use `Shortcut` to change this value at runtime.
forsearch
MenuItem.HasCheckmark **HasCheckmark** As `Boolean` Indicates whether or not the menu item is checked.
forsearch
MenuItem.HasMacControlKey **HasMacControlKey** As `Boolean` The Control key on Mac. This property is Mac-only. If selected, the Control key must be held down while pressing the value of the `ShortcutKey` property in order to trigger the event handler of the MenuItem. This property is read-only. Use `Shortcut` to change this value at runtime.
forsearch
MenuItem.HasMacOptionKey **HasMacOptionKey** As `Boolean` The Option key on Mac. This property is Mac-only. If selected, the Option key must be held down while pressing the value of the `ShortcutKey` property to trigger the event handler of the MenuItem. This property is read-only. Use `Shortcut` to change this value at runtime.
forsearch
MenuItem.HasSecondaryModifierKey **HasSecondaryModifierKey** As `Boolean` The Shift key on all platforms. If `True`, the Shift key must be held down while pressing the value of the Key property to trigger the event handler of the MenuItem. This property is read-only. Use `Shortcut` to change this value at runtime.
forsearch
MenuItem.HasStandardModifierKey **HasStandardModifierKey** As `Boolean` The Control key on Windows and Linux and the Command key on Mac. If this property is selected, the MenuModifier key must be held down while pressing the key specified by the `ShortcutKey` property to trigger the event handler for the MenuItem. This property is read-only. Use `Shortcut` to change this value at runtime.
forsearch
MenuItem.Icon **Icon** As `Picture` A picture that is assigned to the MenuItem. On macOS and Linux, the picture appears in its original size. Resize the icon externally before adding it to the project. On Windows, the icon is resized so that its size matches the height of the item's Text. In most cases icons that are 16x16 points look best. Recent versions of Linux (that use recent version of the GNOME desktop manager), default to not showing menu icons. You can change the OS setting to display menu icons using terminal [](http://gnomeshell.wordpress.com/2011/09/11/show-and-hide-the-menu-icons/): > gsettings set org.gnome.desktop.interface menus-have-icons true The following code is in the `Open` event of the main window. The image appears to the left of the menu item's text. ``` xojo EditFind.Icon = RedApple ```
forsearch
MenuItem.Index **Index** As `Integer` The number of the selected MenuItem when it is part of an array. This property is read-only.
forsearch
MenuItem.LastRowIndex **LastRowIndex** As `Integer` The index of the last child menu item owned by this menu. This property is read-only.
forsearch
MenuItem.Name **Name** As `String` The name of the menu item. Set this property using the Menu Editor. This example sets the name of a MenuItem. ``` xojo EditMenu.Item(2).Name = "Delete" ```
forsearch
MenuItem.Shortcut **Shortcut** As `String` The keyboard shortcut for the MenuItem. Use this property to set the shortcut in code. You can also specify a shortcut in the Inspector for the MenuItem. You can use either a printable key or the following non-printable keys as shortcut keys: F1-F15, Tab, Enter, Space, Del (Delete), Return, Bksp (Backspace), Esc, Clear, PageUp, PageDown, Left, Right, Up, Down, Help, and Ins (Insert). If the shortcut key is more than one character and it is being set via code, the modifier key is not implied and must be explicitly defined. For example, the following line sets the Tab key as the shortcut key and uses the Ctrl key as the modifier. ``` xojo SpecialMyMenuItem.Shortcut = "Ctrl-Tab" ``` For macOS, use "Cmd" instead of "Ctrl." Or set the `HasStandardModifierKey` property to `True` in the IDE and pass the string literal for the desired keyboard shortcut.
forsearch
MenuItem.ShortcutKey **ShortcutKey** As `String` The shortcut key for the menu item. If this key and the selected modifier keys are held down, the event handler for the menu item will be executed as if the MenuItem itself were chosen via the mouse pointer. This property is read-only. When you use the Inspector for the Menu Editor, you specify the menu item's shortcut key by assigning a key to the Key property and (normally) at least one modifier key. The Menu Editor translates your settings into the value for the `Shortcut` property. You can use either a printable key or the following non-printable keys as shortcut keys: F1-F15, Tab, Enter, Space, Del (Delete), Return, Bksp (Backspace), Esc, Clear, PageUp, PageDown, Left, Right, Up, Down, Help, and Ins (Insert). To set the shortcut in code, use the `Shortcut` property. If the shortcut key is more than one character and it is being set via code, the modifier key is not implied and must be explicitly defined. For example, the following line sets the Tab key as the shortcut key and uses the Ctrl key as the modifier. ``` xojo SpecialMyMenuItem.Shortcut = "Ctrl-Tab" ``` For macOS, use "Cmd" instead of "Ctrl." Or set the `HasStandardModifierKey` property to `True` in the IDE and pass the string literal for the desired keyboard shortcut.
forsearch
MenuItem.Tag **Tag** As `Variant` A “hidden” value associated with the menu item. The tag is accessible via code when the user chooses the menu item but, unlike the Text property, is not displayed in the menu. It works like the RowTag property of a `PopupMenu` control. This example is in the Open event of the main window. ``` xojo EditFind.Tag = "Search" ```
forsearch
MenuItem.Value **Value** As `String` The value (text) of the menu item. This example is in the Open event of the main window. ``` xojo EditFind.Value = "Find..." ```
forsearch
MenuItem.Visible **Visible** As `Boolean` Indicates whether or not the menu item is visible. The default is `True`. If `False`, the menu item does not appear and no blank space is for it is in the menu. This property does nothing on Windows so use `RemoveMenuAt` instead. This code is in the Open event of the main window: ``` xojo EditFind.Visible = False ``` ## Method descriptions
forsearch
MenuItem.AddMenu **AddMenu**(Item As MenuItem) Adds the passed MenuItem to the menu. You can add a Separator by passing the class constant MenuItem.TextSeparator. Used to build a dynamic menu. The following code creates a contextual menu in the ConstructContextualMenu event of any `Window` or `RectControl`. This event passes in the parameter base as MenuItem. ``` xojo base.AddMenu(New MenuItem("Import")) base.AddMenu(New MenuItem("Export")) base.AddMenu(New MenuItem(MenuItem.TextSeparator)) base.AddMenu(New MenuItem("Cut")) base.AddMenu(New MenuItem("Copy")) base.AddMenu(New MenuItem("Paste")) Return True ' display the contextual menu ``` The following code creates a hierarchical menu that is added to the main menubar. It is in the Open event of the App or the window. It's easiest to create menus and menuitems using the built-in Menu Editor and enable the MenuItems using the AutoEnable property. Use code for cases such as dynamic menus and contextual menus. ``` xojo Var m, mNew As MenuItem m = Self.MenuBar mNew = New MenuItem mNew.Value = "View" mNew.Name = "View" mNew.AddMenu(New MenuItem("As Icons")) mNew.AddMenu(New MenuItem("As List")) mNew.AddMenu(New MenuItem("As Columns")) mNew.AddMenu(New MenuItem( "-" )) Var submenu As New MenuItem("Sort By") submenu.AddMenu(New MenuItem("Name")) submenu.AddMenu(New MenuItem("Kind")) submenu.AddMenu(New MenuItem("Size")) mNew.AddMenu(submenu) m.AddMenu(mNew) ```
forsearch
MenuItem.AddMenuAt **AddMenuAt**(Index As `Integer`, Item As MenuItem) Adds *Item* as a MenuItem at the position indicated by *Index*. Index is zero-based. You can add a Separator by passing the class constant MenuItem.TextSeparator. The following example adds a new item in the Edit menu with the text "Paste Special..." just below the Paste item. ``` xojo Var editPasteSpecial As New MenuItem editPasteSpecial.Text = "Paste Special..." EditMenu.AddMenuAt(5, editPasteSpecial) ```
forsearch
MenuItem.Child **Child**(Name As `String`) As MenuItem Looks up menu items by Name and returns a MenuItem. Returns `Nil` if a child is not found. The following example gets the text of the Edit \> Cut MenuItem. ``` xojo Var c As MenuItem c = EditMenu.Child("EditCut") MessageBox(c.Value) ```
forsearch
MenuItem.Clone **Clone** As MenuItem Makes a copy of the MenuItem and its `children` if any. Mac does not permit duplicate MenuItems, so you will need to create clones of any MenuItems that are now being used in two or more locations. Whenever you need to use the same MenuItem in different places, use the Clone method to create a new copy of the MenuItem and its children, if any. ``` xojo Var mi As New MenuItem("My menu item") Var myClone As MenuItem myClone = mi.Clone ' Creates an independent copy of "mi" ```
forsearch
MenuItem.Close **Close** Removes dynamically created menu items. This example closes a menu item that was previously created. ``` xojo EditSelectAll.Close ```
forsearch
MenuItem.Constructor **Constructor**(Text as `String`, \[Tag as `Variant` = `Nil`\])
Note
`Constructors` are special methods called when you create an object with the `New` keyword and pass in the parameters above.
Creates a new MenuItem that uses the passed string as its Text property and optionally adds the passed Tag. This example inserts a new item in the Edit menu with the text "Paste Special..." just below the Paste item. ``` xojo Var editPasteSpecial As New MenuItem editPasteSpecial.Text = "Paste Special..." EditMenu.AddMenuAt(5, editPasteSpecial) ``` Using this constructor, you can rewrite the code above more concisely: ``` xojo Var editPasteSpecial As New MenuItem("Paste Special...") EditMenu.AddMenuAt(5, editPasteSpecial) ``` This example illustrates how you can manipulate the menu bar at run time. By adding this example to the open even of a window it will add a new menu to menubar when the window opens. ``` xojo Var m As MenuItem Var mNew As MenuItem m = Self.MenuBar mNew = New MenuItem mNew.Text = "MyMenuText" mNew.Name = "MyMenuName" Var submenu As New MenuItem("MySub") submenu.AddMenu(New MenuItem("Submenu One")) submenu.AddMenu(New MenuItem("Submenu Two")) submenu.AddMenu(New MenuItem("Submenu three")) mNew.AddMenu(submenu) m.AddMenu(mNew) ```
forsearch
MenuItem.Count **Count** As `Integer` Returns as an `Integer` the number of children a menu owns. For a menu item, it returns the number of submenu items, if any. If there are no submenu items, it returns zero.
forsearch
MenuItem.MenuAt **MenuAt**(Index As `Integer`) As MenuItem Item returns as a MenuItem the item indicated by its index (zero-based). If the passed index is out of range, an `OutOfBoundsException` is raised. The following example gets the MenuItem corresponding to the Cut item on the Edit menu by position: ``` xojo Var c As MenuItem c = EditMenu.MenuAt(2) MessageBox(c.Value) ```
forsearch
MenuItem.Popup **Popup**(\[x As `Integer`, y As `Integer`\]) As MenuItem Displays the MenuItem as a contextual menu. If no parameters are passed, the contextual menu appears at the location of the mouse pointer. If you pass the optional parameters, the contextual menu appears at the passed location. The coordinates are global, not just in the object that handles the MouseDown event. Popup returns the selected item as a MenuItem. The selected item's Action event will be fired. If the selected item is handled by a MenuHandler that returns `True`, then PopUp will return `Nil`. The following example displays the Edit menu as a contextual menu. The code is in the MouseDown event handler of a `RectControl`. You can get the text of the selected item by accessing the Text property of the returned MenuItem. ``` xojo Var popMenu As MenuItem popMenu = EditMenu.Clone Var selectedMenu As MenuItem selectedMenu = popMenu.Popup ```
forsearch
MenuItem.Remove **Remove**(Child As MenuItem) Removes the MenuItem specified by the *name*. This code removes the Select All menu item from the Edit menu. ``` xojo EditMenu.Remove(3) ```
forsearch
MenuItem.RemoveMenuAt **RemoveMenuAt**(Index As `Integer`) Removes the MenuItem specified by its position (index). This example removes the Select All menu item from the Edit menu. ``` xojo EditMenu.RemoveMenuAt(3) ``` ## Event descriptions
forsearch
MenuItem.Action **Action** As `Boolean` Called when a MenuItem is selected. Return `True` to prevent the menu event from proceeding any further in the chain of menu handlers. Refer to the MenuItem page for an example of how a menu that is created dynamically can use the Action event.
forsearch
MenuItem.EnableMenu **EnableMenu** Called when a user selects a menu. You can use this to enable/disable/hide menus based on the context of your app. ## Notes MenuItem objects are used to create and access the properties of menu items. You can change the menu item text using the `Value` property. You can find out if a menu item is checked, or check or uncheck a menu item with the `HasCheckmark` property. You can also enable or disable a menu item using the `Enabled` property. The `Enabled` property should be set only from within an `EnableMenu` event handler. Setting it from anywhere else has no effect. Three other classes handle specialized menu items. `QuitMenuItem` is designed to manage the Menu \> File \> Quit and Menu \> File \> Exit on Windows and Linux) menu of a built application; it is enabled by default and automatically calls the `Quit` method. The `PrefsMenuItem` class is designed to handle the Preferences menu item. In macOS, this menu item is supposed to be located under the application's menu, but on other operating systems, this menu does not exist. A menu item derived from the `PrefsMenuItem` class automatically appears under the application's menu under macOS; on other operating systems is appears where you put it in the Menu Editor. The `ApplicationMenuItem` class is designed for creating menu items that appear under the application's menu on macOS. Any menu subclassed from `ApplicationMenuItem` will move to the application's menu for your macOS build but stay where it is for your other builds. MenuItems can be created on the fly using the `New` operator or the `Clone` method. --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ### Contextual menus Use The ConstructContextualMenu and ContextualMenuAction events of the `RectControl` or `Window` to create and manage contextual menus. --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ### MenuItems on macos The Mac framework does not allow a MenuItem to be used in different places, e.g. several `` MenuBar`s. Trying to do so will raise a :doc:`MenuHasParentException ``. In order to avoid the hassle of creating several times the same MenuItem, you can use the `Clone` method to make copies. --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ### Specifying the keyboard shortcut in the menu editor When you use the Properties pane in the Menu Editor, you specify the menu item's shortcut key by assigning a key to the `ShortcutKey` property and (normally) at least one modifier key. The Menu Editor translates your settings into the value for the `Shortcut` property. You can use either a printable key or the following non-printable keys as shortcut keys: F1-F15, Tab, Enter, Space, Del (Delete), Return, Bksp (Backspace), Esc, Clear, PageUp, PageDown, Left, Right, Up, Down, Help, and Ins (Insert). If the shortcut key is more than one character and it is being set via code, the modifier key is not implied and must be explicitly defined. For example, the following line sets the Tab key as the shortcut key and uses the Ctrl key as the modifier. ``` xojo SpecialMyMenuItem.Shortcut = "Ctrl-Tab" ``` For macOS, use "Cmd" instead of "Ctrl." Or set the `HasStandardModifierKey` property to `True` in the IDE and pass the string literal for the desired keyboard shortcut. Other values you can use are: "Opt", "Alt", "Shift". You can combine keys like this: ``` xojo MyMenuItem.Shortcut = "Shift-Ctrl-W" ``` When you are setting a non-printable key in the IDE, you can just enter its name from the list above and check the desired modifier key from the following list. The `ShortcutKey` property entry and the entries for the modifier keys are described in the table below. | Name | Description | |-------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `HasSecondaryModifierKey` | The Shift key on all platforms. If selected, the Shift key must be held down while pressing the value of the `ShortcutKey` property to trigger the event handler of the MenuItem. | | `ShortcutKey` | The shortcut key for the menu item. If this key and the selected modifier keys set is held down, the event handler for the menu item will be executed as if the menu item itself were chosen via the mouse pointer. | | `HasMacControlKey` | The Control key on Mac. This property is Mac-only. If selected, the Control key must be held down while pressing the value of the `ShortcutKey` property in order to trigger the event handler of the menuitem. | | `HasMacOptionKey` | The Option key on Mac. This property is Mac-only. If selected, the Option key must be held down while pressing the value of the `ShortcutKey` property to trigger the event handler of the menu item. | | `HasStandardModifierKey` | The Control key on Windows and Linux and the Command key on Mac. If this property is selected, the `HasStandardModifierKey` key must be held down while pressing the key specified by the `ShortcutKey` property to trigger the event handler for the menu item. | | `HasAltKey` | The Alt key on Windows and Linux keyboards. If selected, the Alt key is must be held down while pressing the value of the `ShortcutKey` property in order to trigger the event handler for the menu item. This property is for Windows and Linux only. | ## Sample code The following code changes the text of the EditPaste menu item to "Paste Special…": ``` xojo EditPaste.Value = "Paste Special..." ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The following code adds a new item in the Edit menu with the text "Paste Special..." just below the Paste item. ``` xojo Var EditPasteSpecial As New MenuItem EditPasteSpecial.Value = "Paste Special..." EditMenu.AddMenuAt(5, EditPasteSpecial) ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Using the constructor, you can write: ``` xojo Var EditPasteSpecial As New MenuItem("Paste Special...") EditMenu.AddMenuAt(5, EditPasteSpecial) ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The following code adds a Select All menu item to the Edit menu. ``` xojo Var EditSelectAll As New MenuItem EditSelectAll.Value = "Select All..." EditMenu.AddMenu(EditSelectAll) ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The following code gets the MenuItem corresponding to the Cut item on the Edit menu. ``` xojo Var c As MenuItem c = EditMenu.Child("EditCut") MessageBox(c.Value) ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The following code gets the MenuItem corresponding to the Cut item on the Edit menu by position: ``` xojo Var c As MenuItem c = EditMenu.MenuAt(2) MessageBox(c.Value) ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The following code removes the fourth dynamically created menu item from a menu item array named WindowItem: ``` xojo WindowItem(3).Close ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The following code assigns a value to the Tag property of a menu item: ``` xojo SearchFind.Tag = "UserSearch" ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The following code displays the Edit menu as a contextual menu. The code is in the MouseDown event handler of a `RectControl`. You can get the text of the selected item by accessing the Text property of the returned MenuItem. ``` xojo If IsContextualClick Then Var m As MenuItem m = EditMenu.Popup End If ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- In general you should create and display contextual menus using the ConstructContextualMenu and ContextualMenuAction event handlers of the `Window` and `RectControl` classes. They are fully cross-platform and don't make assumptions about how the user requested a contextual menu. The following code creates a contextual menu in the ConstructContextualMenu event of any `Window` or `RectControl`. This event passes in the parameter base as MenuItem. ``` xojo base.AddMenu(New MenuItem("Import")) base.AddMenu(New MenuItem("Export")) base.AddMenu(New MenuItem(MenuItem.TextSeparator)) base.AddMenu(New MenuItem("Cut")) base.AddMenu(New MenuItem("Copy")) base.AddMenu(New MenuItem("Paste")) Return True ' display the contextual menu ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The following code in the ContextualMenuAction event handles the menu selection. This event passes in the parameter hitItem as MenuItem. This is the selected menu item. ``` xojo Select Case hitItem.Value Case "Import" MessageBox("You chose Import") Case "Export" MessageBox("You chose export") Case "Cut" MessageBox("You chose Cut") Case "Copy" MessageBox("You chose Copy") Case "Paste" MessageBox("You chose Paste") End Select Return True ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- In certain cases you cannot specify the menu items that belong in a menu in advance. They may change depending on the context in which the application is used or on the operating system on which the application is running. A common example of this is the Font menu that is normally included in any application that supports styled text. The programmer has no way of knowing in advance which fonts happen to be installed on the user's computer. The Font menu's menuitems have to be built dynamically when the application is launched. The recommended technique is to create a subclass of MenuItem in the Project Window. To create the menuitems, you use the MenuItem's constructor to instantiate an instance of the class for each MenuItem you need. You handle the MenuItem in the `Action` event. You then write code to populate the menu with the names of the fonts installed on the user's computer. If we assume that fonts won't be added or deleted while the application is running, we can build the font list when the application launches. You can do this in the `App.Open` event or the `Open` event of a window if the menu should appear only for a particular window. This example uses the App.Open event. Before adding the App.Open event, we will add a MenuItem subclass to the project. We will name it "AddFont" and set its `Super` class to MenuItem. It will use the constructor to add each MenuItem. The constructor takes the MenuItem's text as its parameter. The optional *rowtag* parameter is not used. Since the constructor is built-in, you do not need to explicitly add a constructor to your code. The MenuItem subclass has two events, `Action` and `EnableMenu`. You do not need to use `EnableMenu` because `AutoEnabled` is `True` by default. You do need to add code to the `Action` event. This is the code that will run when a user selects a MenuItem. It serves the same purpose as the Menu Handler that is used for static menuitems. In this case, we want the menu item to set the selected text in a `TextArea` to the font that the user chose. The `Action` event is: ``` xojo TextWindow.TextArea1.SelectionFontName = Me.Value Return True ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- TextWindow is the name of the window that contains the `TextArea` and TextArea1 is the `TextArea`. The Text variable holds the font name that was passed to AddFont when the font was created. Next, we want to add code to the `Application.Open` event to create the Font menu and populate it with the name of the user's installed fonts. The following code adds the Font menu to the default menubar: ``` xojo Var m, mNew As MenuItem m = Self.MenuBar mNew = New MenuItem mNew.Value = "Fonts" mNew.Name = "FontsMenu" m.AddMenu(mNew) ``` --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- The next block of code populates the Font menu. It uses the built-in `System.FontAt` function which returns the name of the ith font on the user's computer. The code instantiates an instance of the AddFont subclass for each font: ``` xojo Var child As MenuItem If mNew = Nil Then MessageBox("Menu parent is nil!") Return End If ' build the font menu For i As Integer = 0 To System.LastFontIndex child = New AddFont(System.FontAt(i)) mNew.AddMenu(child) Next ``` ## Compatibility All project types on all supported operating systems. ## See also `Object` parent class; `ApplicationMenuItem`, `MenuHasParentException`, `PrefsMenuItem`, `QuitMenuItem` classes; `IsContextualClick`, `Application.RefreshMenuBar` functions, `New` operator.