actionMenu.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file actionMenu.h
//! \brief Defines the core menu class for VR-Engage
//!
//! This file contains the DtMenu class which provides the foundation for all
//! interactive menus in VR-Engage. It manages menu elements, selection state,
//! scrolling, input handling, and visual presentation. The menu system supports
//! various menu types including static menus, quick menus, and input menus for
//! both normal and VR display modes.
 
#pragma once
 
#include "vrePlayerStation/export.h"
#include "vrePlayerStation/actionMenuElement.h"
#include "vrePlayerStation/inputLogic.h"
 
#include <vreMessageManager/vreMessage.h>
 
#include <vector>
#include <string>
 
namespace makVrv
{
class DtDe;
class DtQuadProxy;
class DtTextProxy;
class DtOverlayRenderer;
class DtOsgChannel;
} // namespace makVrv
 
namespace makVre
{
class DtMenuManager;
class DtMenuAttributeBinder;
class DtMenuAttributeObserver;
class DtMenuCursor;
class DtQmlActionMenu;
//! \brief Structure holding conditions for menu display
//!
//! DtMenuDisplayConditions contains the criteria that determine when a menu
//! should be displayed. This includes contextual conditions such as player
//! posture (standing, prone, etc.) which can affect menu availability.
struct DtMenuDisplayConditions
{
   //! \brief Required player posture for menu display
   //!
   //! The posture the player must be in for this menu to be displayed.
   //! Empty string means any posture is acceptable.
   std::string myPosture;
};
 
//! \brief Core class for all interactive menus in VR-Engage
//!
//! DtMenu provides the foundation for all menus in VR-Engage. It manages a collection
//! of menu elements, handles selection state, scrolling, input processing, and
//! visual presentation. The menu system supports various types including static
//! menus, quick context-sensitive menus, and specialized input menus.
//!
//! Menus can be hierarchical, with parent-child relationships, and support both
//! keyboard/mouse and VR controller input. They can dynamically update their content
//! based on player state and context.
class PLAYERSTATION_DLL DtMenu
{
public:
   //! \brief Constructor
   //! \param mgr Reference to the menu manager
   //!
   //! Creates a new menu associated with the specified menu manager.
   //! The menu starts with no elements and is inactive (not displayed).
   DtMenu(DtMenuManager& mgr);
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of all menu resources and derived menu classes.
   virtual ~DtMenu();
 
   //! \brief Gets the menu's identifier name
   //! \return Reference to the menu's name string
   //!
   //! Returns the user-supplied name of the menu. This name is used to
   //! identify and look up the menu in the menu manager registry.
   virtual const std::string& name();
 
   //! \brief Sets the menu's identifier name
   //! \param name The name to assign to this menu
   //!
   //! Sets the user-supplied name of the menu. This name is used to
   //! identify and look up the menu in the menu manager registry.
   virtual void setName(const std::string& name);
 
   //! \brief Sets the position of the menu
   //! \param x Horizontal position in pixels from the left edge
   //! \param y Vertical position in pixels from the top edge
   //!
   //! Sets the position of the menu on the screen in pixel coordinates.
   //! The position represents the top-left corner of the menu.
   virtual void setPosition(float x, float y);
 
   //! \brief Gets the menu's horizontal position
   //! \return Horizontal position in pixels
   //!
   //! Returns the current horizontal position of the menu.
   virtual float x() const { return myX; }
 
   //! \brief Gets the menu's vertical position
   //! \return Vertical position in pixels
   //!
   //! Returns the current vertical position of the menu.
   virtual float y() const { return myY; }
 
   //! \brief Sets the size of the menu
   //! \param x Width in pixels
   //! \param y Height in pixels
   //!
   //! Sets the size of the menu in pixel dimensions.
   virtual void setSize(float x, float y);
 
   //! \brief Gets the menu's width
   //! \return Width in pixels
   //!
   //! Returns the current width of the menu.
   virtual float width() const { return myWidth; }
 
   //! \brief Gets the menu's height
   //! \return Height in pixels
   //!
   //! Returns the current height of the menu.
   virtual float height() const { return myHeight; }
 
   //! \brief Sets the active state of the menu
   //! \param active True to activate (show) the menu, false to deactivate (hide)
   //! \param saveSelection If true, preserve selection from last time the menu was open
   //! \param closeOnElementSelected If true, close menu when an element is selected
   //!
   //! Controls whether the menu is visible and interactive. When activated, the menu will
   //! either restore its previous selection (if saveSelection is true) or select the first
   //! valid element. If closeOnElementSelected is true, the menu will automatically close
   //! after an element is selected or if there are no valid selections available.
   virtual void setActive(bool active, bool saveSelection = false, bool closeOnElementSelected = false);
 
   //! \brief Checks if the menu is currently active
   //! \return True if the menu is active (visible), false otherwise
   //!
   //! Determines whether the menu is currently visible and interactive.
   virtual bool isActive() const;
 
   //! \brief Checks if the menu has any elements
   //! \return True if the menu has no elements, false if it has at least one
   //!
   //! Determines whether the menu contains any elements.
   virtual bool isEmpty() const;
 
   //! \brief Updates the menu's state and visuals
   //! \param dt Time elapsed since the last update in seconds
   //!
   //! Called once per frame to update the menu's state and refresh its visual
   //! representation. This handles animation, scrolling, and display updates.
   virtual void tick(double dt);
 
   //! \brief Initializes the input handling logic for the menu
   //!
   //! Sets up the input logic system for this menu, mapping input events (keyboard,
   //! mouse, controller buttons, etc.) to menu action handlers. This establishes
   //! all the input handlers needed for navigating and interacting with the menu,
   //! such as selection, scrolling, and item activation.
   //!
   //! This is automatically called when the menu becomes active.
   virtual void activateInputLogic();
 
   //! \brief Shuts down the input handling logic for the menu
   //!
   //! Deactivates the input logic system for this menu, removing all input handlers
   //! and cleaning up resources. This prevents the menu from responding to input
   //! events when it's no longer active.
   //!
   //! This is automatically called when the menu becomes inactive.
   virtual void deactivateInputLogic();
 
   //! \brief Gets the menu title text
   //! \return Reference to the title string
   //!
   //! Returns the title text displayed at the top of the menu.
   virtual const std::string& title() const { return myTitleString; }
 
   //! \brief Sets the menu title text
   //! \param title The title text to display
   //!
   //! Sets the title text to be displayed at the top of the menu.
   //! This is typically shown in a header area above the menu elements.
   virtual void setTitle(const std::string& title);
 
   //! \brief Gets the menu title text
   //! \return Reference to the title string
   //!
   //! Returns the title text displayed at the top of the menu.
   virtual const std::string& titleAttribute() const { return myTitleAttribute; }
 
   //! \brief Sets the menu title text
   //! \param title The title text to display
   //!
   //! Sets the title text to be displayed at the top of the menu.
   //! This is typically shown in a header area above the menu elements.
   //! \brief Sets the attribute path used for the menu title
   //! \param titleAttribute The attribute path to use for dynamically updating the menu title
   void setTitleAttribute(const std::string& titleAttribute);
 
   //! \brief Sets whether to show the menu title
   //! \param show True to show the title, false to hide it
   //!
   //! Controls the visibility of the menu title. When enabled, the title
   //! is displayed at the top of the menu. When disabled, no title is shown.
   virtual void setShowTitle(bool show);
 
   //! \brief Adds an element to the menu
   //! \param element Pointer to the menu element to add
   //!
   //! Adds the specified element to this menu. If there is no currently
   //! selected element, the new element will become the selected element
   //! if it is enabled. The menu takes ownership of the element and will
   //! delete it when the menu is destroyed or when the element is removed.
   virtual void addElement(DtMenuElement* element);
 
   //! \brief Removes an element from the menu by pointer
   //! \param element Pointer to the element to remove
   //! \return Pointer to the removed element, or NULL if not found
   //!
   //! Removes the specified element from the menu. If the removed element
   //! was the currently selected element, the selection will be updated to
   //! the nearest valid element. The caller becomes responsible for deleting
   //! the returned element to avoid memory leaks.
   virtual DtMenuElement* removeElement(DtMenuElement* element);
 
   //! \brief Removes an element from the menu by name
   //! \param name Name of the element to remove
   //! \return Pointer to the removed element, or NULL if not found
   //!
   //! Removes the element with the specified name from the menu. If the
   //! removed element was the currently selected element, the selection
   //! will be updated to the nearest valid element. The caller becomes
   //! responsible for deleting the returned element to avoid memory leaks.
   virtual DtMenuElement* removeElement(const std::string& name);
 
   //! \brief Finds a menu element by name
   //! \param name Name of the element to find
   //! \return Pointer to the found element, or NULL if not found
   //!
   //! Searches for and returns the menu element with the specified name.
   //! Returns NULL if no element with that name exists in the menu.
   virtual DtMenuElement* findElement(const std::string& name);
 
   //! \brief Gets all elements in the menu
   //! \return Vector of pointers to all menu elements
   //!
   //! Returns a vector containing pointers to all elements in the menu.
   //! The elements remain owned by the menu; the caller should not delete them.
   virtual std::vector<DtMenuElement*> elements();
 
   //! \brief Selects a menu element by index
   //! \param index Zero-based index of the element to select
   //! \return True if selection was changed to a valid element, false otherwise
   //!
   //! Attempts to select the element at the specified index. If the requested
   //! element is not enabled or does not exist, it will try to select the next
   //! enabled element. Returns true if the selection successfully changed to
   //! a valid element, false if the selection remained unchanged or no valid
   //! selection was possible.
   virtual bool selectElement(int index);
 
   //! \brief Selects a menu element by its on-screen index
   //! \param index On-screen index of the element to select (as displayed to the user)
   //!
   //! Selects the element with the specified on-screen index. On-screen indices
   //! are only assigned to visible and enabled elements, and are used for keyboard
   //! shortcuts (e.g., pressing 1-9 to select menu items 1-9).
   virtual void selectElementByOnScreenIndex(int index);
 
   //! \brief Selects a menu element by name
   //! \param name Name of the element to select
   //! \return True if the element was found and selected, false otherwise
   //!
   //! Attempts to select the element with the specified name. Returns true if
   //! the element was found and successfully selected, false if the element
   //! was not found or could not be selected (e.g., because it is disabled).
   virtual bool selectElement(const std::string& name);
 
   //! \brief Selects the next enabled element in the menu
   //! \param val Input value (typically 1.0 for full activation)
   //!
   //! Moves the selection to the next enabled element in the menu. If already
   //! at the last element, the selection will not change. The val parameter
   //! supports analog inputs (like joysticks) that may not be fully activated.
   virtual void selectNext(float val = 1);
 
   //! \brief Selects the previous enabled element in the menu
   //! \param val Input value (typically 1.0 for full activation)
   //!
   //! Moves the selection to the previous enabled element in the menu. If already
   //! at the first element, the selection will not change. The val parameter
   //! supports analog inputs (like joysticks) that may not be fully activated.
   virtual void selectPrevious(float val = 1);
 
   //! \brief Gets the currently selected menu element
   //! \return Pointer to the selected element, or nullptr if no element is selected
   //!
   //! Returns a pointer to the currently selected menu element. Returns nullptr
   //! if no element is currently selected, which can happen if the menu is empty
   //! or if no elements are enabled.
   virtual DtMenuElement* selectedElement();
 
   //! \brief Gets the index of the currently selected element
   //! \return Index of the selected element, or -1 if no element is selected
   //!
   //! Returns the index of the currently selected menu element in the list of
   //! enabled elements. Returns -1 if no element is currently selected, which can
   //! happen if the menu is empty or if no elements are enabled.
   virtual int selectedElementIndex() const { return mySelectedItem ? mySelectedItem->enabledIndex : -1; }
 
   //! \brief Clears the current selection
   //!
   //! Removes the current element selection, leaving no element selected.
   //! This is useful when you want to reset the menu state or when no
   //! element should be highlighted.
   virtual void clearSelected();
 
   //! \brief Scrolls the menu to show a specific item
   //! \param index Index of the item to scroll to
   //! \return True if successful, false otherwise
   //!
   //! Adjusts the menu scroll position to ensure the element at the specified
   //! index is visible. This automatically updates the menu visuals.
   //! Returns true if the scroll was successful, false otherwise.
   virtual bool scrollToItem(int index) { return scrollToItem(index, true); }
 
   //! \brief Scrolls the menu down one item
   //!
   //! Scrolls the menu down by one item, showing the next set of elements
   //! if the menu contains more elements than can be displayed at once.
   virtual void scrollDown();
 
   //! \brief Scrolls the menu up one item
   //!
   //! Scrolls the menu up by one item, showing the previous set of elements
   //! if the menu has been scrolled down.
   virtual void scrollUp();
 
   //! \brief Scrolls the menu by a variable amount
   //! \param val Amount to scroll, positive for down, negative for up
   //!
   //! Scrolls the menu by the specified amount. Positive values scroll down,
   //! negative values scroll up. The val parameter supports analog inputs
   //! (like joysticks) for variable-speed scrolling.
   virtual void scroll(float val);
 
   //! \brief Scrolls the menu up by a page
   //! \param val Input value (typically 1.0 for full page)
   //!
   //! Scrolls the menu up by one page (the number of visible elements).
   //! The val parameter supports analog inputs for partial page scrolling.
   virtual void pageUp(float val = 1);
 
   //! \brief Scrolls the menu down by a page
   //! \param val Input value (typically 1.0 for full page)
   //!
   //! Scrolls the menu down by one page (the number of visible elements).
   //! The val parameter supports analog inputs for partial page scrolling.
   virtual void pageDown(float val = 1);
   //! \brief Updates the enabled element list
   //!
   //! Refreshes the internal list of enabled elements based on the current state
   //! of all menu elements. This rebuilds the myEnabledItems list, recalculating
   //! which elements are visible and enabled based on their display conditions.
   //! Called automatically when menu state changes affect element visibility.
   virtual void updateElements();
 
   //! \brief Updates the visual representation of the menu
   //!
   //! Refreshes the visual display of the menu based on the current state.
   //! This updates element positions, scrolling state, and visual properties.
   //! Called automatically when the menu's state changes in a way that affects
   //! its visual appearance.
   virtual void updateVisuals();
 
   //! \brief Adds a dynamic element generator to the menu
   //! \param generator Pointer to the attribute observer that generates elements
   //!
   //! Sets an attribute observer that will dynamically generate menu elements
   //! based on attribute values. This allows menus to automatically update
   //! their contents when attributes change. The menu takes ownership of the
   //! generator and will delete it when the menu is destroyed.
   virtual void addElementGenerator(DtMenuAttributeObserver* generator);
 
   //! \brief Sets the parent menu by name
   //! \param name Name of the parent menu
   //!
   //! Establishes a parent-child relationship between menus. When this menu
   //! is closed, the parent menu will be reopened if it exists. This creates
   //! a hierarchical menu structure for navigation.
   virtual void setParent(const std::string& name);
 
   //! \brief Sets whether to inherit position from parent menu
   //! \param set True to inherit parent position, false to use own position
   //!
   //! When set to true, this menu will adopt the same position as its parent
   //! menu. This is useful for submenus that should appear in the same location
   //! as their parent menu for visual continuity.
   virtual void setInheritParentPosition(bool set);
 
   //! \brief Sets whether to inherit size from parent menu
   //! \param set True to inherit parent size, false to use own size
   //!
   //! When set to true, this menu will adopt the same size as its parent
   //! menu. This is useful for submenus that should maintain the same
   //! dimensions as their parent menu for visual consistency.
   virtual void setInheritParentSize(bool set);
 
   //! \brief Gets the name of the parent menu
   //! \return Reference to the parent menu name string
   //!
   //! Returns the name of this menu's parent menu. Returns an empty string
   //! if this menu has no parent.
   virtual const std::string& parent() const;
 
   //! \brief Closes the menu
   //! \param val Input value (typically 1.0 for full activation)
   //!
   //! Closes this menu, deactivating it and hiding it from view. If the menu
   //! has a parent, the parent menu will be activated. The val parameter
   //! supports analog inputs for partial activation.
   virtual void closeMenu(float val = 1);
 
   //! \brief Selects the currently highlighted menu element
   //! \param val Input value (typically 1.0 for full activation)
   //!
   //! Executes the action associated with the currently selected menu element.
   //! For action elements, this will trigger the action. For menu elements, this
   //! will open the submenu. The val parameter supports analog inputs for
   //! partial activation.
   virtual void select(float val = 1);
 
   //! \brief Selects a menu item by number with analog input support
   //! \param val Input value (typically 1.0 for full activation)
   //! \param num Index of the item to select (1-based)
   //!
   //! General handler for numerical item selection. This allows selecting
   //! a menu item by its displayed number. The val parameter supports analog
   //! inputs for partial activation.
   virtual void selectItem(float val, unsigned int num);
 
   //! \brief Selects the first menu item
   //! \param val Input value (typically 1.0 for full activation)
   //!
   //! Selects the first visible menu item. The val parameter supports
   //! analog inputs for partial activation.
   virtual void select1(float val);
 
   //! \brief Selects the second menu item
   //! \param val Input value (typically 1.0 for full activation)
   virtual void select2(float val);
 
   //! \brief Selects the third menu item
   //! \param val Input value (typically 1.0 for full activation)
   virtual void select3(float val);
 
   //! \brief Selects the fourth menu item
   //! \param val Input value (typically 1.0 for full activation)
   virtual void select4(float val);
 
   //! \brief Selects the fifth menu item
   //! \param val Input value (typically 1.0 for full activation)
   virtual void select5(float val);
 
   //! \brief Selects the sixth menu item
   //! \param val Input value (typically 1.0 for full activation)
   virtual void select6(float val);
 
   //! \brief Selects the seventh menu item
   //! \param val Input value (typically 1.0 for full activation)
   virtual void select7(float val);
 
   //! \brief Selects the eighth menu item
   //! \param val Input value (typically 1.0 for full activation)
   virtual void select8(float val);
 
   //! \brief Selects the ninth menu item
   //! \param val Input value (typically 1.0 for full activation)
   virtual void select9(float val);
 
   //! \brief Selects the tenth menu item
   //! \param val Input value (typically 1.0 for full activation)
   virtual void select10(float val);
 
   //! \brief Navigates back to the parent menu
   //! \param val Input value (typically 1.0 for full activation)
   //!
   //! Closes this menu and returns to the parent menu if one exists.
   //! Equivalent to pressing the Back button or Escape key. The val parameter
   //! supports analog inputs for partial activation.
   virtual void back(float val = 1);
 
   //! \brief Gets the display conditions for this menu (const version)
   //! \return Constant reference to the menu's display conditions
   //!
   //! Returns a constant reference to the conditions that determine when
   //! this menu should be displayed. These include context-sensitive
   //! conditions like player posture.
   virtual const DtMenuDisplayConditions& displayConditions() const;
 
   //! \brief Gets the display conditions for this menu (mutable version)
   //! \return Mutable reference to the menu's display conditions
   //!
   //! Returns a mutable reference to the conditions that determine when
   //! this menu should be displayed. These can be modified to change when
   //! the menu is available to the player.
   virtual DtMenuDisplayConditions& displayConditions();
 
   //! \brief Checks if a duplicate element exists in the enabled list
   //! \param element Pointer to the element to check for duplicates
   //! \return True if a duplicate exists, false otherwise
   //!
   //! Determines whether another enabled element with the same label as the
   //! specified element already exists in the menu. This is used to prevent
   //! duplicate entries in dynamically generated menus.
   virtual bool containsEnabledDuplicate(DtMenuElement* element);
 
   //! \brief Gets the menu manager for this menu
   //! \return Reference to the menu manager
   //!
   //! Returns a reference to the menu manager that controls this menu.
   //! The menu manager handles menu registration, parent-child relationships,
   //! and other menu system functionality.
   virtual DtMenuManager& manager() { return myManager; }
 
   //! \brief Menu type enumeration
   //!
   //! Defines the types of menus supported by the system:
   //! - STATIC: Standard menu that persists until explicitly closed
   //! - QUICK: Context-sensitive menu that appears temporarily based on proximity or other triggers
   enum Type
   {
      STATIC, //!< Standard persistent menu
      QUICK,  //!< Context-sensitive temporary menu
   };
 
   //! \brief Sets the menu type
   //! \param type Type of menu to set
   //!
   //! Sets the type of this menu, which affects its behavior and appearance.
   void setType(Type type) { myType = type; }
 
   //! \brief Gets the menu type
   //! \return Current menu type
   //!
   //! Returns the current type of this menu.
   Type type() { return myType; }
 
   //! \brief Removes all elements from the menu
   //!
   //! Clears the menu by removing and deleting all its elements.
   //! This resets the menu to an empty state, removing all options.
   virtual void clearElements();
 
   //! \brief Triggers an action from QML interface
   //! \param index Index of the element to trigger
   //!
   //! Executes the action associated with the element at the specified index.
   //! This is used for integration with QML-based user interfaces, allowing
   //! QML components to trigger menu actions.
   void triggerActionFromQML(int index);
 
protected:
   //! \brief Handles player controls state change messages
   //! \param msg Pointer to the message to handle
   //! \return Message handling result
   //!
   //! Processes messages about changes in player controls state. When controls
   //! are disabled, this automatically closes the menu to prevent interaction
   //! when the player cannot control the menu.
   virtual DtVreMessageResult handlePlayerControlsState(DtVreMessage* msg);
 
   //! \brief Handles menu input messages from VR controllers
   //! \param msg Pointer to the message to handle
   //! \return Message handling result
   //!
   //! Processes input messages specifically designed for VR control of menus.
   //! This provides a bridge for VR controller input to interact with menus
   //! until a more integrated VR input system is implemented.
   virtual DtVreMessageResult handleMenuInputMessage(DtVreMessage* msg);
 
   //! \brief Internal implementation of scrollToItem
   //! \param index Index of the item to scroll to
   //! \param doUpdate Whether to update the visual display after scrolling
   //! \return True if scroll was successful, false otherwise
   //!
   //! Adjusts the scroll position to ensure the element at the specified index
   //! is visible. The doUpdate parameter controls whether the menu visuals are
   //! immediately updated after scrolling, which is useful for batch operations
   //! where multiple scrolls might occur before the final update.
   virtual bool scrollToItem(int index, bool doUpdate);
 
   //! \brief Updates the ImGui-based user interface
   //!
   //! Refreshes the menu's user interface components using the ImGui framework.
   //! This handles the rendering of the menu background, elements, scrollbars,
   //! and other visual components. Called internally by the tick method when
   //! the menu needs to be visually updated.
   virtual void updateImguiUI();
 
   //! \brief Enumeration of display layers for menu rendering
   //!
   //! Defines the different visual layers used when rendering the menu, with
   //! later layers drawn on top of earlier ones. This allows proper layering
   //! of menu components for a cohesive visual appearance.
   enum Layers
   {
      HIDDEN,     //!< Layer for hidden elements (not displayed)
      BACKGROUND, //!< Background layer (drawn first)
      GRAPHIC,    //!< Graphic elements layer (drawn second)
      LABEL       //!< Text labels layer (drawn on top)
   };
 
   //! \brief Reference to the menu manager
   //!
   //! Reference to the menu manager that controls this menu. The menu manager
   //! handles menu registration, parent-child relationships, and other menu
   //! system functionality.
   DtMenuManager& myManager;
 
   //! \brief Name identifier for this menu
   //!
   //! Unique name that identifies this menu in the menu system. Used for
   //! menu lookup and parent-child relationships.
   std::string myName;
 
   //! \brief Title text displayed at the top of the menu
   //!
   //! Text shown in the menu's title bar, describing the menu's purpose.
   std::string myTitleString;
 
   //! \brief Title attribute for the menu
   //! 
   //! The attribute name to get the title's text from.
   std::string myTitleAttribute;
 
   //! \brief Name of the parent menu
   //!
   //! Name of this menu's parent menu. When this menu is closed, the parent
   //! menu will be activated if it exists. Empty string indicates no parent.
   std::string myParent;
 
   //! \brief Display conditions for this menu
   //!
   //! Conditions that determine when this menu should be displayed, such as
   //! player posture requirements.
   DtMenuDisplayConditions myDisplayConditions;
 
   //! \brief Type of this menu (STATIC or QUICK)
   //!
   //! Determines the menu's behavior and appearance. STATIC menus persist until
   //! explicitly closed, while QUICK menus are context-sensitive and temporary.
   Type myType;
 
   //! \brief Position and size of the menu in pixels
   //!
   //! Coordinates and dimensions that define the menu's location and size
   //! on the screen. The position (myX, myY) represents the top-left corner
   //! of the menu rectangle.
   float myX, myY, myWidth, myHeight;
 
   //! \brief Active state of the menu
   //!
   //! Indicates whether the menu is currently active (visible and interactive).
   bool myIsActive;
 
   //! \brief Whether to show the menu title
   //!
   //! Controls visibility of the title bar at the top of the menu.
   bool myShowTitle;
 
   //! \brief Whether to inherit size from parent menu
   //!
   //! When true, this menu adopts the same size as its parent menu.
   bool myNeedParentSize;
 
   //! \brief Whether to inherit position from parent menu
   //!
   //! When true, this menu appears at the same position as its parent menu.
   bool myNeedParentPosition;
 
   //! \brief Whether to show numerical indices for menu items
   //!
   //! When true, menu elements are displayed with numerical indices (1, 2, 3...)
   //! that can be used for keyboard shortcuts. Input menus typically disable this.
   bool myShouldShowNumbers;
 
   //! \brief Internal structure for managing menu elements
   //!
   //! Item wraps a menu element with additional state information needed for
   //! menu management, such as enabled index and ownership tracking. The Item
   //! structure takes ownership of the contained element and deletes it when
   //! the Item is destroyed.
   struct Item
   {
      //! \brief Constructor
      //! \param _element Pointer to the menu element to wrap
      //!
      //! Creates a new Item wrapping the specified menu element.
      Item(DtMenuElement* _element)
         : element(_element)
      {
      }
 
      //! \brief Destructor
      //!
      //! Deletes the wrapped menu element, ensuring proper cleanup.
      ~Item()
      {
         delete element;
         element = nullptr;
      }
 
      //! \brief Pointer to the wrapped menu element
      DtMenuElement* element;
 
      //! \brief Index of this element in the enabled elements list
      //!
      //! This is used to track the element's position in the visible menu.
      //! Only enabled elements are given an index for selection purposes.
      int enabledIndex;
 
      //! \brief Checks if the wrapped element is currently enabled
      //! \return True if the element is enabled, false otherwise
      bool isEnabled() { return element->isEnabled(); }
   };
 
   //! \brief List of all menu items, owned by this menu
   //!
   //! Vector of all menu items, including both enabled and disabled ones.
   //! The menu owns these items and is responsible for deleting them.
   std::vector<Item*> myItems;
 
   //! \brief List of currently enabled menu items
   //!
   //! Vector of pointers to enabled menu items only. These are not owned by
   //! this vector, but are references to items in myItems. This list is
   //! rebuilt whenever element states change, and is used for display and selection.
   std::vector<Item*> myEnabledItems;
 
   //! \brief Pointer to the currently selected item
   //!
   //! Points to the item that is currently selected in the menu. This is
   //! a reference to an item in myEnabledItems. Null if no item is selected.
   Item* mySelectedItem;
 
   //! \brief Pointer to the saved selection for menu reopening
   //!
   //! When a menu is closed with saveSelection=true, this stores the last
   //! selected item so it can be restored when the menu is reopened.
   Item* mySavedSelection;
 
   //! \brief Special items for scroll indicators
   //!
   //! Items representing the scroll up and scroll down indicators that
   //! appear at the top and bottom of the menu when not all items can be
   //! displayed at once.
   Item myScrollUp;
   Item myScrollDown;
 
   //! \brief Whether the menu can scroll upward
   //!
   //! Indicates if there are additional items above the currently visible ones.
   bool myCanScrollUp;
 
   //! \brief Whether the menu can scroll downward
   //!
   //! Indicates if there are additional items below the currently visible ones.
   bool myCanScrollDown;
 
   //! \brief Current scroll position in the menu
   //!
   //! Index of the first visible item in the list of enabled items.
   int myScrollOffset;
 
   //! \brief Number of items that can be displayed at once
   //!
   //! Maximum number of menu elements that can be displayed simultaneously
   //! based on menu height and element height.
   int myVisibleScrollItems;
 
   //! \brief Timer for action selection flash effect
   //!
   //! Used to create a visual flash effect when an action is selected.
   //! Counts down from a positive value to zero.
   double myActionFlash;
 
   //! \brief Whether to close the menu after an element is selected
   //!
   //! When true, the menu automatically closes after an element is selected.
   //! This is commonly used for context menus and quick menus.
   bool myCloseOnSelection;
 
   //! \brief Height of each menu element line in pixels
   //!
   //! Used for layout calculations and determining how many elements can
   //! be displayed at once.
   int myLineHeight;
 
   //! \brief Element generator for dynamic menu content
   //!
   //! Observer that dynamically generates menu elements based on attribute
   //! values. This allows the menu to update its content automatically when
   //! relevant attributes change.
   DtMenuAttributeObserver* myElementGenerator;
 
   //! \brief Input logic for menu interaction
   //!
   //! Handles input event processing for menu navigation and selection.
   //! Maps input events to menu actions like selection, scrolling, and activation.
   DtInputLogic myInputLogic;
};
 
} // namespace makVre