RadMenu

Initializes a new instance of the RadMenu class. RadMenu can be horizontal or vertical. You can add, remove, and disable menu items at run-time. It offers full theming support, allowing you to easily construct a variety of stunning visual effects. You can nest any other RadControl within a RadMenu. For example, you can create a menu with an embedded textbox or combobox.

Gets or sets a value indicating whether all menu items will appear with the same height, using the height of the tallest item in the collection.

Gets or sets a value indicating whether this menu allows merging with other RadMenu instances to create a unified menu structure.

Gets or sets a value indicating whether the menu automatically adjusts its size to fit its content.

public override bool AutoSize { get; set; }

Overrides: RadControl.AutoSize

Gets or sets the background color of the menu. Note that RadMenu consists of multiple visual elements and separate settings are provided to customize their appearance, so this property might be ignored.

public override Color BackColor { get; set; }

Overrides: RadControl.BackColor

Gets the default size of the control.

protected override Size DefaultSize { get; }

Overrides: Control.DefaultSize

Gets or sets which edge of the parent container the menu is docked to.

public override DockStyle Dock { get; set; }

Overrides: Control.Dock

Gets or sets the easing type used for dropdown animations when DropDownAnimationEnabled is true.

Gets or sets a value indicating whether dropdown animations are enabled when submenu items are displayed.

Gets or sets the number of frames used for dropdown animations when DropDownAnimationEnabled is true.

Gets or sets a value indicating whether this RadMenu handles MDI (Multiple Document Interface) menu functionality and system buttons for child forms.

Gets the collection of root menu items that are displayed in the menu. Root items are top-level menu items that have no parent item and can contain child items as submenus.

[RadEditItemsAction]
[RadNewItem("Type here", true, true, false)]
[Browsable(true)]
public override RadItemOwnerCollection Items { get; }

Overrides: RadItemsControl.Items

Gets the instance of RadMenuElement wrapped by this control. RadMenuElement is the main element in the hierarchy tree and encapsulates the actual functionality of RadMenu.

Gets or sets the Orientation of menu items, determining whether they are arranged horizontally or vertically.

Gets or sets a value indicating whether keystrokes that do not match any registered mnemonic are propagated to other controls while the menu's keyboard cues are visible (i.e. after the Alt key is pressed). When false, such keystrokes are consumed by the menu and not dispatched to other controls such as a focused text box. The default is true, preserving existing behavior.

Gets or sets a value indicating whether menu items should be stretched to fill the available space in the menu.

Gets or sets a value indicating whether the Alt or F10 keys can be used to highlight and activate the menu for keyboard navigation.

Determines whether the base ProcessDialogKey(Keys) implementation should handle the key. Always returns false, since dialog keys are fully handled by this menu.

protected override bool CallBaseProcessDialogKey(Keys keyData)

Overrides: RadItemsControl.CallBaseProcessDialogKey(Keys)

Determines whether the specified menu item can currently be processed (selected/clicked).

Determines whether the specified character can be processed as a mnemonic for any menu item.

public override bool CanProcessMnemonic(char keyData)

Overrides: RadItemsControl.CanProcessMnemonic(char)

Creates an accessibility instance for the menu control to support assistive technologies and screen readers.

protected override AccessibleObject CreateAccessibilityInstance()

Overrides: Control.CreateAccessibilityInstance()

Creates and initializes the child elements of the menu, including the RadMenuElement and its event handlers.

protected override void CreateChildItems(RadElement parent)

Overrides: RadControl.CreateChildItems(RadElement)

Creates the root element of the control.

protected override RootRadElement CreateRootElement()

Overrides: RadControl.CreateRootElement()

Releases the resources used by the control, unregistering the message filter listener and detaching form/items event handlers.

protected override void Dispose(bool disposing)

Overrides: RadControl.Dispose(bool)

Recursively finds the deepest currently selected item across this menu and any shown child popups.

Recursively searches for the menu item, including nested drop-down items, whose mnemonic matches the specified character.

Initializes the root element with default property values for the menu.

protected override void InitializeRootElement(RootRadElement rootElement)

Overrides: RadControl.InitializeRootElement(RootRadElement)

Merges the specified RadMenu with this menu, combining their menu items according to merge settings.

Raises the AllItemsEqualHeightChanged event when the equal height setting for menu items changes.

Called when the control handle is created. Sets up MDI functionality and system button handling if the parent form is an MDI container.

protected override void OnHandleCreated(EventArgs e)

Overrides: Control.OnHandleCreated(EventArgs)

Detaches the click handlers registered for MDI list items when the control's window handle is destroyed.

protected override void OnHandleDestroyed(EventArgs e)

Overrides: RadControl.OnHandleDestroyed(EventArgs)

Handles item deselection, updating whether child items should continue to be shown based on the deselected item's popup and enabled state.

protected override void OnItemDeselected(ItemSelectedEventArgs args)

Overrides: RadItemsControl.OnItemDeselected(ItemSelectedEventArgs)

Handles item selection, marking the item as selected and notifying accessibility clients.

protected override void OnItemSelected(ItemSelectedEventArgs args)

Overrides: RadItemsControl.OnItemSelected(ItemSelectedEventArgs)

Handles the leave event, deactivating the menu state and hiding any shown child popups.

protected override void OnLeave(EventArgs e)

Overrides: Control.OnLeave(EventArgs)

Handles control load, subscribing to the parent form's Deactivate event and registering with the RadMessageFilter to track menu-wide mouse activity.

protected override void OnLoad(Size desiredSize)

Overrides: RadControl.OnLoad(Size)

Called when the menu state changes, handling the transition between different RadMenu.RadMenuState values.

Handles the mouse down event, activating the menu item located at the click position.

protected override void OnMouseDown(MouseEventArgs e)

Overrides: RadControl.OnMouseDown(MouseEventArgs)

Handles the mouse move event, updating item selection and showing/hiding child popups as the pointer moves between menu items.

protected override void OnMouseMove(MouseEventArgs e)

Overrides: RadControl.OnMouseMove(MouseEventArgs)

Raises the OrientationChanged event when the menu orientation changes.

Raises the TextOrientationChanged event when the text orientation property value changes.

Activates keyboard-driven selection state and selects the specified menu item in response to a mouse-down interaction.

Preprocesses a raw mouse Windows message, deactivating the currently shown keyboard-cue selection when the pointer moves outside the active item's bounds.

Processes an arrow key press, dispatching to left/right or up/down navigation logic based on the menu's Orientation.

protected override bool ProcessArrowKey(Keys keyCode)

Overrides: RadItemsControl.ProcessArrowKey(Keys)

Does nothing; the menu's size is managed entirely by its layout rather than by the AutoSize mechanism.

protected override void ProcessAutoSizeChanged(bool value)

Overrides: RadControl.ProcessAutoSizeChanged(bool)

Processes command keys, deactivating the menu and deselecting the current item when Escape is pressed while no popups are open.

protected override bool ProcessCmdKey(ref Message m, Keys keyData)

Overrides: RadItemsControl.ProcessCmdKey(ref Message, Keys)

Processes Coded UI test messages, exposing the item count and child-node presence for automated testing scenarios.

protected override void ProcessCodedUIMessage(ref IPCMessage request)

Overrides: RadControl.ProcessCodedUIMessage(ref IPCMessage)

Processes dialog keys, activating the selected item's click or closing its popup when the Enter key is pressed.

protected override bool ProcessDialogKey(Keys keyData)

Overrides: RadItemsControl.ProcessDialogKey(Keys)

Handles the first stage of system-key (Alt) mnemonic activation, toggling the menu's keyboard-cues visible state.

Determines whether the specified element should receive focus. Always returns false, since focus is managed internally by the menu.

protected override bool ProcessFocusRequested(RadElement element)

Overrides: RadControl.ProcessFocusRequested(RadElement)

Processes the left or right arrow key, moving selection between top-level items and showing the newly selected item's child popup when applicable.

protected override bool ProcessLeftRightArrowKey(bool right)

Overrides: RadItemsControl.ProcessLeftRightArrowKey(bool)

Processes a mnemonic character, selecting the matching menu item when the menu is displaying keyboard cues.

protected override bool ProcessMnemonic(char charCode)

Overrides: RadControl.ProcessMnemonic(char)

Handles the second stage of system-key mnemonic activation, including the F10 key, toggling the menu's keyboard-active selection state.

Processes the up or down arrow key, expanding the current item's child popup when applicable.

protected override bool ProcessUpDownArrowKey(bool down)

Overrides: RadItemsControl.ProcessUpDownArrowKey(bool)

Resets theme value overrides for the BackColor property, restoring default theme behavior.

protected override void ResetBackColorThemeOverrides()

Overrides: RadControl.ResetBackColorThemeOverrides()

Sets theme value overrides for the BackColor property of the menu.

protected override void SetBackColorThemeOverrides()

Overrides: RadControl.SetBackColorThemeOverrides()

Sets the current state of the menu for mnemonic and keyboard processing.

Removes the merge relationship with the specified RadMenu, restoring the original menu structure.

Occurs when the AllItemsEqualHeight property value changes, indicating a change in the height uniformity setting for menu items.

Occurs when the Orientation property value changes, indicating a change in the layout direction of menu items.

Occurs when the text orientation property value changes, affecting how text is displayed within menu items.