Replace MenuItemSelectedEvent with MenuItemClickedEvent

lijy91 · lijy91 · commit a570cf00de3a · 2025-09-06T11:03:40.000+08:00
Update all menu item event listeners to use MenuItemClickedEvent instead
of MenuItemSelectedEvent or MenuItemStateChangedEvent. Menu item state
management is now handled by the application.
diff --git a/examples/menu_example/main.cpp b/examples/menu_example/main.cpp
@@ -35,34 +35,30 @@ int main() {
         std::cout << "Setting up event listeners..." << std::endl;
         
         // Listen to menu item selection events
-        fileItem->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
-            std::cout << "[EVENT] Menu item selected: " << event.GetItemText() 
+        fileItem->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
+            std::cout << "[EVENT] Menu item clicked: " << event.GetItemText() 
                       << " (ID: " << event.GetItemId() << ")" << std::endl;
         });
         
-        checkboxItem->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
+        checkboxItem->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
             std::cout << "[EVENT] Checkbox item clicked: " << event.GetItemText() 
-                      << " (ID: " << event.GetItemId() << ")" << std::endl;
+                      << " (ID: " << event.GetItemId() << ") - Handle state manually" << std::endl;
         });
         
-        // Listen to state change events for checkable items
-        checkboxItem->AddListener<MenuItemStateChangedEvent>([](const MenuItemStateChangedEvent& event) {
-            std::cout << "[EVENT] Checkbox state changed: ID " << event.GetItemId() 
-                      << ", checked: " << (event.IsChecked() ? "true" : "false") << std::endl;
-        });
+        // Note: State management is now handled by the application
         
-        radioItem1->AddListener<MenuItemStateChangedEvent>([](const MenuItemStateChangedEvent& event) {
-            std::cout << "[EVENT] Radio item 1 state changed: ID " << event.GetItemId() 
-                      << ", checked: " << (event.IsChecked() ? "true" : "false") << std::endl;
+        radioItem1->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
+            std::cout << "[EVENT] Radio item 1 clicked: ID " << event.GetItemId() 
+                      << " - Handle state manually" << std::endl;
         });
         
-        radioItem2->AddListener<MenuItemStateChangedEvent>([](const MenuItemStateChangedEvent& event) {
-            std::cout << "[EVENT] Radio item 2 state changed: ID " << event.GetItemId() 
-                      << ", checked: " << (event.IsChecked() ? "true" : "false") << std::endl;
+        radioItem2->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
+            std::cout << "[EVENT] Radio item 2 clicked: ID " << event.GetItemId() 
+                      << " - Handle state manually" << std::endl;
         });
         
-        exitItem->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
-            std::cout << "[EVENT] Exit item selected: " << event.GetItemText() << std::endl;
+        exitItem->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
+            std::cout << "[EVENT] Exit item clicked: " << event.GetItemText() << std::endl;
             std::cout << "Application should exit now..." << std::endl;
         });
         
@@ -122,12 +118,12 @@ int main() {
         auto submenuItem1 = MenuItem::Create("Submenu Item 1", MenuItemType::Normal);
         auto submenuItem2 = MenuItem::Create("Submenu Item 2", MenuItemType::Normal);
         
-        submenuItem1->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
-            std::cout << "[EVENT] Submenu item selected: " << event.GetItemText() << std::endl;
+        submenuItem1->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
+            std::cout << "[EVENT] Submenu item clicked: " << event.GetItemText() << std::endl;
         });
         
-        submenuItem2->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
-            std::cout << "[EVENT] Submenu item selected: " << event.GetItemText() << std::endl;
+        submenuItem2->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
+            std::cout << "[EVENT] Submenu item clicked: " << event.GetItemText() << std::endl;
         });
         
         submenu->AddItem(submenuItem1);
@@ -148,7 +144,7 @@ int main() {
         std::cout << "This example demonstrates:" << std::endl;
         std::cout << "1. Creating menus and menu items with different types" << std::endl;
         std::cout << "2. Using the new event system with AddListener<EventType>()" << std::endl;
-        std::cout << "3. Handling MenuItemSelectedEvent and MenuItemStateChangedEvent" << std::endl;
+        std::cout << "3. Handling MenuItemClickedEvent (state managed by application)" << std::endl;
         std::cout << "4. Handling MenuOpenedEvent and MenuClosedEvent" << std::endl;
         std::cout << "5. Programmatic event triggering" << std::endl;
         std::cout << "6. Submenu support with event propagation" << std::endl;
diff --git a/examples/tray_icon_example/main.cpp b/examples/tray_icon_example/main.cpp
@@ -14,7 +14,7 @@
 using namespace nativeapi;
 using nativeapi::Menu;
 using nativeapi::MenuItem;
-using nativeapi::MenuItemSelectedEvent;
+using nativeapi::MenuItemClickedEvent;
 using nativeapi::MenuItemType;
 
 int main() {
@@ -69,7 +69,7 @@ int main() {
     
     // Add menu items
     auto status_item = MenuItem::Create("Status: Running", MenuItemType::Normal);
-    status_item->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
+    status_item->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
         std::cout << "Status clicked from context menu" << std::endl;
     });
     context_menu->AddItem(status_item);
@@ -79,15 +79,15 @@ int main() {
 
     // Add settings item
     auto settings_item = MenuItem::Create("Settings...", MenuItemType::Normal);
-    settings_item->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
+    settings_item->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
         std::cout << "Settings clicked from context menu" << std::endl;
         std::cout << "Opening settings dialog..." << std::endl;
     });
     context_menu->AddItem(settings_item);
 
     // Add about item
     auto about_item = MenuItem::Create("About", MenuItemType::Normal);
-    about_item->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
+    about_item->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
         std::cout << "About clicked from context menu" << std::endl;
         std::cout << "TrayIcon Example v1.0 - Native API Demo" << std::endl;
     });
@@ -99,7 +99,7 @@ int main() {
     // Add exit item
     auto exit_item = MenuItem::Create("Exit", MenuItemType::Normal);
     bool* should_exit = new bool(false);
-    exit_item->AddListener<MenuItemSelectedEvent>([should_exit](const MenuItemSelectedEvent& event) {
+    exit_item->AddListener<MenuItemClickedEvent>([should_exit](const MenuItemClickedEvent& event) {
         std::cout << "Exit clicked from context menu" << std::endl;
         *should_exit = true;
     });
diff --git a/examples/window_example/main.cpp b/examples/window_example/main.cpp
@@ -8,7 +8,7 @@ using nativeapi::DisplayManager;
 using nativeapi::DisplayRemovedEvent;
 using nativeapi::Menu;
 using nativeapi::MenuItem;
-using nativeapi::MenuItemSelectedEvent;
+using nativeapi::MenuItemClickedEvent;
 using nativeapi::MenuItemType;
 using nativeapi::TrayIcon;
 using nativeapi::TrayManager;
@@ -81,7 +81,7 @@ int main() {
 
     // Add menu items
     auto show_window_item = MenuItem::Create("Show Window", MenuItemType::Normal);
-    show_window_item->AddListener<MenuItemSelectedEvent>([window_ptr](const MenuItemSelectedEvent& event) {
+    show_window_item->AddListener<MenuItemClickedEvent>([window_ptr](const MenuItemClickedEvent& event) {
       std::cout << "Show Window clicked from context menu" << std::endl;
       if (window_ptr) {
         window_ptr->Show();
@@ -91,7 +91,7 @@ int main() {
     context_menu->AddItem(show_window_item);
 
     auto hide_window_item = MenuItem::Create("Hide Window", MenuItemType::Normal);
-    hide_window_item->AddListener<MenuItemSelectedEvent>([window_ptr](const MenuItemSelectedEvent& event) {
+    hide_window_item->AddListener<MenuItemClickedEvent>([window_ptr](const MenuItemClickedEvent& event) {
       std::cout << "Hide Window clicked from context menu" << std::endl;
       if (window_ptr) {
         window_ptr->Hide();
@@ -104,7 +104,7 @@ int main() {
 
     // Add about item
     auto about_item = MenuItem::Create("About", MenuItemType::Normal);
-    about_item->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
+    about_item->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
       std::cout << "About clicked from context menu" << std::endl;
       std::cout << "Window Example v1.0 - Native API Demo" << std::endl;
     });
@@ -115,7 +115,7 @@ int main() {
 
     // Add exit item
     auto exit_item = MenuItem::Create("Exit", MenuItemType::Normal);
-    exit_item->AddListener<MenuItemSelectedEvent>([&window_manager](const MenuItemSelectedEvent& event) {
+    exit_item->AddListener<MenuItemClickedEvent>([&window_manager](const MenuItemClickedEvent& event) {
       std::cout << "Exit clicked from context menu" << std::endl;
       // Get all windows and destroy them to trigger app exit
       auto windows = window_manager.GetAll();
diff --git a/src/capi/menu_c.cpp b/src/capi/menu_c.cpp
@@ -440,7 +440,7 @@ int native_menu_item_add_listener(native_menu_item_t item, native_menu_item_even
     
     // Add the appropriate event listener based on event type
     if (event_type == NATIVE_MENU_ITEM_EVENT_SELECTED) {
-      menu_item->AddListener<MenuItemSelectedEvent>([item, listener_id](const MenuItemSelectedEvent& event) {
+      menu_item->AddListener<MenuItemClickedEvent>([item, listener_id](const MenuItemClickedEvent& event) {
         // Find the listener data
         auto item_it = g_menu_item_listeners.find(item);
         if (item_it != g_menu_item_listeners.end()) {
@@ -456,15 +456,15 @@ int native_menu_item_add_listener(native_menu_item_t item, native_menu_item_even
         }
       });
     } else if (event_type == NATIVE_MENU_ITEM_EVENT_STATE_CHANGED) {
-      menu_item->AddListener<MenuItemStateChangedEvent>([item, listener_id](const MenuItemStateChangedEvent& event) {
+      menu_item->AddListener<MenuItemClickedEvent>([item, listener_id](const MenuItemClickedEvent& event) {
         // Find the listener data
         auto item_it = g_menu_item_listeners.find(item);
         if (item_it != g_menu_item_listeners.end()) {
           auto listener_it = item_it->second.find(listener_id);
           if (listener_it != item_it->second.end()) {
             native_menu_item_state_changed_event_t c_event = {};
             c_event.item_id = event.GetItemId();
-            c_event.checked = event.IsChecked();
+            c_event.checked = false; // Application should manage checkbox/radio state
             
             listener_it->second->callback(&c_event, listener_it->second->user_data);
           }
diff --git a/src/menu.h b/src/menu.h
@@ -132,16 +132,16 @@ class Menu;
  * auto item = MenuItem::Create("Open File", MenuItemType::Normal);
  * item->SetIcon("data:image/png;base64,...");
  * item->SetAccelerator(KeyboardAccelerator("O", KeyboardAccelerator::Ctrl));
- * item->AddListener<MenuItemSelectedEvent>([](const MenuItemSelectedEvent& event) {
+ * item->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
  *     // Handle menu item click
  *     std::cout << "Opening file..." << std::endl;
  * });
  *
  * // Create a checkbox item
  * auto checkbox = MenuItem::Create("Show Toolbar", MenuItemType::Checkbox);
  * checkbox->SetChecked(true);
- * checkbox->AddListener<MenuItemStateChangedEvent>([](const MenuItemStateChangedEvent& event) {
- *     std::cout << "Toolbar visibility: " << event.IsChecked() << std::endl;
+ * checkbox->AddListener<MenuItemClickedEvent>([](const MenuItemClickedEvent& event) {
+ *     std::cout << "Toolbar clicked, handle state change manually" << std::endl;
  * });
  * ```
  */
diff --git a/src/menu_event.h b/src/menu_event.h
@@ -10,70 +10,85 @@ typedef long MenuID;
 typedef long MenuItemID;
 
 /**
- * @brief Menu item selection event.
+ * @brief Menu opened event.
  *
- * This event is fired when a menu item is clicked or activated.
- * Contains information about which menu item was selected.
+ * This event is fired when a menu has been displayed.
  */
-class MenuItemSelectedEvent : public TypedEvent<MenuItemSelectedEvent> {
+class MenuOpenedEvent : public TypedEvent<MenuOpenedEvent> {
  public:
-  MenuItemSelectedEvent(MenuItemID item_id, const std::string& item_text)
-      : item_id_(item_id), item_text_(item_text) {}
+  MenuOpenedEvent(MenuID menu_id) : menu_id_(menu_id) {}
 
-  MenuItemID GetItemId() const { return item_id_; }
-  const std::string& GetItemText() const { return item_text_; }
+  MenuID GetMenuId() const { return menu_id_; }
 
  private:
-  MenuItemID item_id_;
-  std::string item_text_;
+  MenuID menu_id_;
+};
+
+/**
+ * @brief Menu closed event.
+ *
+ * This event is fired when a menu has been hidden or closed.
+ */
+class MenuClosedEvent : public TypedEvent<MenuClosedEvent> {
+ public:
+  MenuClosedEvent(MenuID menu_id) : menu_id_(menu_id) {}
+
+  MenuID GetMenuId() const { return menu_id_; }
+
+ private:
+  MenuID menu_id_;
 };
 
 /**
- * @brief Menu item state change event.
+ * @brief Menu item clicked event.
  *
- * This event is fired when a checkable menu item's state changes.
+ * This event is fired when a menu item is clicked or activated.
+ * Contains information about which menu item was clicked.
  */
-class MenuItemStateChangedEvent : public TypedEvent<MenuItemStateChangedEvent> {
+class MenuItemClickedEvent : public TypedEvent<MenuItemClickedEvent> {
  public:
-  MenuItemStateChangedEvent(MenuItemID item_id, bool checked)
-      : item_id_(item_id), checked_(checked) {}
+  MenuItemClickedEvent(MenuItemID item_id, const std::string& item_text)
+      : item_id_(item_id), item_text_(item_text) {}
 
   MenuItemID GetItemId() const { return item_id_; }
-  bool IsChecked() const { return checked_; }
+  const std::string& GetItemText() const { return item_text_; }
 
  private:
   MenuItemID item_id_;
-  bool checked_;
+  std::string item_text_;
 };
 
+
 /**
- * @brief Menu opened event.
+ * @brief Menu item submenu opened event.
  *
- * This event is fired when a menu has been displayed.
+ * This event is fired when a menu item's submenu has been displayed.
  */
-class MenuOpenedEvent : public TypedEvent<MenuOpenedEvent> {
+class MenuItemSubmenuOpenedEvent
+    : public TypedEvent<MenuItemSubmenuOpenedEvent> {
  public:
-  MenuOpenedEvent(MenuID menu_id) : menu_id_(menu_id) {}
+  MenuItemSubmenuOpenedEvent(MenuItemID item_id) : item_id_(item_id) {}
 
-  MenuID GetMenuId() const { return menu_id_; }
+  MenuItemID GetItemId() const { return item_id_; }
 
  private:
-  MenuID menu_id_;
+  MenuItemID item_id_;
 };
 
 /**
- * @brief Menu closed event.
+ * @brief Menu item submenu closed event.
  *
- * This event is fired when a menu has been hidden or closed.
+ * This event is fired when a menu item's submenu has been hidden or closed.
  */
-class MenuClosedEvent : public TypedEvent<MenuClosedEvent> {
+class MenuItemSubmenuClosedEvent
+    : public TypedEvent<MenuItemSubmenuClosedEvent> {
  public:
-  MenuClosedEvent(MenuID menu_id) : menu_id_(menu_id) {}
+  MenuItemSubmenuClosedEvent(MenuItemID item_id) : item_id_(item_id) {}
 
-  MenuID GetMenuId() const { return menu_id_; }
+  MenuItemID GetItemId() const { return item_id_; }
 
  private:
-  MenuID menu_id_;
+  MenuItemID item_id_;
 };
 
 }  // namespace nativeapi
diff --git a/src/platform/macos/menu_macos.mm b/src/platform/macos/menu_macos.mm
@@ -400,11 +400,12 @@ - (void)menuDidClose:(NSMenu *)menu {
 }
 
 void MenuItem::EmitSelectedEvent(const std::string& item_text) {
-    EmitSync<MenuItemSelectedEvent>(id, item_text);
+    EmitSync<MenuItemClickedEvent>(id, item_text);
 }
 
 void MenuItem::EmitStateChangedEvent(bool checked) {
-    EmitSync<MenuItemStateChangedEvent>(id, checked);
+    // Now just emit clicked event, application manages state
+    EmitSync<MenuItemClickedEvent>(id, pimpl_->text_);
 }
 
 // Menu::Impl implementation

Original file line number	Diff line number	Diff line change
`@@ -400,11 +400,12 @@ - (void)menuDidClose:(NSMenu *)menu {`
`400`	`400`	`}`
`401`	`401`
`402`	`402`	`void MenuItem::EmitSelectedEvent(const std::string& item_text) {`
`403`		`- EmitSync<MenuItemSelectedEvent>(id, item_text);`
	`403`	`+ EmitSync<MenuItemClickedEvent>(id, item_text);`
`404`	`404`	`}`
`405`	`405`
`406`	`406`	`void MenuItem::EmitStateChangedEvent(bool checked) {`
`407`		`- EmitSync<MenuItemStateChangedEvent>(id, checked);`
	`407`	`+ // Now just emit clicked event, application manages state`
	`408`	`+ EmitSync<MenuItemClickedEvent>(id, pimpl_->text_);`
`408`	`409`	`}`
`409`	`410`
`410`	`411`	`// Menu::Impl implementation`