Refactor event system for type-erased listeners

Removed TypedEvent and TypedEventListener in favor of a simplified Event base class and type-erased listener wrappers. Updated all event classes to inherit directly from Event and removed type index methods. EventEmitter now manages listeners using type-erased wrappers, improving type safety and flexibility. Cleaned up macOS tray icon menu delegate logic and ensured context menu cleanup via event listeners.

Author: lijy91

src/display_event.h

@@ -55,16 +55,6 @@ class DisplayAddedEvent : public DisplayEvent {
    * Get a string representation of the event type
    */
   std::string GetTypeName() const override { return "DisplayAddedEvent"; }
-
-  /**
-   * Get the static type index for this event type
-   */
-  static std::type_index GetStaticType() { return std::type_index(typeid(DisplayAddedEvent)); }
-
-  /**
-   * Get the type index for this event instance
-   */
-  std::type_index GetType() const { return GetStaticType(); }
 };
 
 /**
@@ -80,16 +70,6 @@ class DisplayRemovedEvent : public DisplayEvent {
    * Get a string representation of the event type
    */
   std::string GetTypeName() const override { return "DisplayRemovedEvent"; }
-
-  /**
-   * Get the static type index for this event type
-   */
-  static std::type_index GetStaticType() { return std::type_index(typeid(DisplayRemovedEvent)); }
-
-  /**
-   * Get the type index for this event instance
-   */
-  std::type_index GetType() const { return GetStaticType(); }
 };
 
 /**
@@ -119,16 +99,6 @@ class DisplayChangedEvent : public DisplayEvent {
    */
   std::string GetTypeName() const override { return "DisplayChangedEvent"; }
 
-  /**
-   * Get the static type index for this event type
-   */
-  static std::type_index GetStaticType() { return std::type_index(typeid(DisplayChangedEvent)); }
-
-  /**
-   * Get the type index for this event instance
-   */
-  std::type_index GetType() const { return GetStaticType(); }
-
  private:
   Display old_display_;
 };

src/foundation/event.h

@@ -4,8 +4,6 @@
 #include <functional>
 #include <memory>
 #include <string>
-#include <typeindex>
-#include <unordered_map>
 
 namespace nativeapi {
 
@@ -29,68 +27,67 @@ class Event {
 };
 
 /**
- * Template for typed events. This provides type safety and automatic
- * type identification for events.
+ * Generic event listener interface providing type-safe event handling.
+ *
+ * This interface supports both generic and specific event handling:
+ * - Use EventListener<Event> to handle all event types (requires manual type checking)
+ * - Use EventListener<SpecificEventType> for compile-time type safety with specific events
+ *
+ * Example:
+ * ```cpp
+ * class MyListener : public EventListener<MyCustomEvent> {
+ * public:
+ *   void OnEvent(const MyCustomEvent& event) override {
+ *     // Handle the event with full type safety
+ *   }
+ * };
+ * ```
  */
 template <typename T>
-class TypedEvent : public Event {
- public:
-  static std::type_index GetStaticType() { return std::type_index(typeid(T)); }
-
-  std::type_index GetType() const { return GetStaticType(); }
-
-  std::string GetTypeName() const override { return typeid(T).name(); }
-};
-
-/**
- * Generic event listener interface that can handle any event type.
- * This is the base interface for the observer pattern.
- */
 class EventListener {
  public:
   virtual ~EventListener() = default;
 
   /**
-   * Handle an event. Implementations should check the event type
-   * and cast appropriately.
+   * Handles an incoming event of type T.
+   *
+   * The event parameter is guaranteed to be of type T or a subtype.
+   * Implementation should process the event according to the listener's logic.
    */
-  virtual void OnEvent(const Event& event) = 0;
+  virtual void OnEvent(const T& event) = 0;
 };
 
 /**
- * Template for typed event listeners. This provides type safety
- * by automatically casting events to the correct type.
+ * A callback-based event listener that wraps function callbacks into the EventListener interface.
+ *
+ * This implementation allows using function references, lambda functions, or any callable
+ * as event handlers without requiring a full class implementation. It's particularly useful
+ * for simple event handling scenarios or when you want to use inline functions.
+ *
+ * Example usage:
+ * ```cpp
+ * // Using a lambda function
+ * auto listener = std::make_unique<CallbackEventListener<MyEvent>>(
+ *     [](const MyEvent& event) { std::cout << "Received: " << event << std::endl; });
+ *
+ * // Using a function reference
+ * void handleMyEvent(const MyEvent& event) { // handle event }
+ * auto listener = std::make_unique<CallbackEventListener<MyEvent>>(handleMyEvent);
+ * ```
  */
-template <typename EventType>
-class TypedEventListener : public EventListener {
+template <typename T>
+class CallbackEventListener : public EventListener<T> {
  public:
-  virtual ~TypedEventListener() = default;
-
-  void OnEvent(const Event& event) override {
-    // Check if this is the correct event type
-    if (auto typed_event = dynamic_cast<const EventType*>(&event)) {
-      OnTypedEvent(*typed_event);
-    }
-  }
+  using CallbackType = std::function<void(const T&)>;
 
   /**
-   * Handle a typed event. Subclasses should override this method.
+   * Creates a new callback-based event listener with the specified callback function.
+   *
+   * The callback must accept a single parameter of type T and return void.
    */
-  virtual void OnTypedEvent(const EventType& event) = 0;
-};
-
-/**
- * Callback-based event handler that wraps std::function callbacks.
- * This allows using lambda functions or function pointers as event handlers.
- */
-template <typename EventType>
-class CallbackEventListener : public TypedEventListener<EventType> {
- public:
-  using CallbackType = std::function<void(const EventType&)>;
-
   explicit CallbackEventListener(CallbackType callback) : callback_(std::move(callback)) {}
 
-  void OnTypedEvent(const EventType& event) override {
+  void OnEvent(const T& event) override {
     if (callback_) {
       callback_(event);
     }

src/foundation/event_emitter.cpp

@@ -13,15 +13,15 @@ EventEmitter::~EventEmitter() {
 }
 
 size_t EventEmitter::AddListener(std::type_index event_type,
-                                 EventListener* listener) {
+                                 std::unique_ptr<EventListenerBase> listener) {
   if (!listener) {
     return 0;  // Invalid listener
   }
 
   std::lock_guard<std::mutex> lock(listeners_mutex_);
   size_t listener_id = next_listener_id_.fetch_add(1);
 
-  listeners_[event_type].push_back({listener, listener_id});
+  listeners_[event_type].push_back({std::move(listener), listener_id});
 
   return listener_id;
 }
@@ -57,7 +57,7 @@ void EventEmitter::RemoveAllListeners() {
 
 void EventEmitter::EmitSync(const Event& event) {
   std::type_index event_type = typeid(event);
-  std::vector<EventListener*> listeners_copy;
+  std::vector<EventListenerBase*> listeners_copy;
 
   // Copy listeners to avoid holding the lock during dispatch
   {
@@ -66,7 +66,7 @@ void EventEmitter::EmitSync(const Event& event) {
     if (it != listeners_.end()) {
       listeners_copy.reserve(it->second.size());
       for (const auto& info : it->second) {
-        listeners_copy.push_back(info.listener);
+        listeners_copy.push_back(info.listener.get());
       }
     }
   }

src/foundation/event_emitter.h

@@ -52,8 +52,21 @@ class EventEmitter {
    * @return A unique listener ID that can be used to remove the listener
    */
   template <typename EventType>
-  size_t AddListener(TypedEventListener<EventType>* listener) {
-    return AddListener(TypedEvent<EventType>::GetStaticType(), listener);
+  size_t AddListener(EventListener<EventType>* listener) {
+    // Create a wrapper that handles the type conversion
+    struct TypedListenerWrapper : public EventListenerBase {
+      EventListener<EventType>* listener_;
+
+      TypedListenerWrapper(EventListener<EventType>* listener) : listener_(listener) {}
+
+      void OnEvent(const Event& event) override {
+        if (auto typed_event = dynamic_cast<const EventType*>(&event)) {
+          listener_->OnEvent(*typed_event);
+        }
+      }
+    };
+
+    return AddListener(typeid(EventType), std::make_unique<TypedListenerWrapper>(listener));
   }
 
   /**
@@ -64,18 +77,22 @@ class EventEmitter {
    */
   template <typename EventType>
   size_t AddListener(std::function<void(const EventType&)> callback) {
-    auto callback_listener =
-        std::make_unique<CallbackEventListener<EventType>>(std::move(callback));
-    auto listener_ptr = callback_listener.get();
-
-    // Store the callback listener first, then add it
-    {
-      std::lock_guard<std::mutex> lock(listeners_mutex_);
-      callback_listeners_.emplace_back(std::move(callback_listener));
-    }
-
-    // Use the type-erased method to avoid infinite recursion
-    return AddListener(TypedEvent<EventType>::GetStaticType(), listener_ptr);
+    // Create a wrapper that handles the callback and type conversion
+    struct CallbackListenerWrapper : public EventListenerBase {
+      std::function<void(const EventType&)> callback_;
+
+      CallbackListenerWrapper(std::function<void(const EventType&)> callback)
+          : callback_(std::move(callback)) {}
+
+      void OnEvent(const Event& event) override {
+        if (auto typed_event = dynamic_cast<const EventType*>(&event)) {
+          callback_(*typed_event);
+        }
+      }
+    };
+
+    return AddListener(typeid(EventType),
+                       std::make_unique<CallbackListenerWrapper>(std::move(callback)));
   }
 
   /**
@@ -91,7 +108,7 @@ class EventEmitter {
    */
   template <typename EventType>
   void RemoveAllListeners() {
-    RemoveAllListeners(TypedEvent<EventType>::GetStaticType());
+    RemoveAllListeners(typeid(EventType));
   }
 
   /**
@@ -104,7 +121,7 @@ class EventEmitter {
    */
   template <typename EventType>
   size_t GetListenerCount() const {
-    return GetListenerCount(TypedEvent<EventType>::GetStaticType());
+    return GetListenerCount(typeid(EventType));
   }
 
   /**
@@ -173,13 +190,19 @@ class EventEmitter {
   }
 
  private:
+  // Base interface for type-erased listeners
+  struct EventListenerBase {
+    virtual ~EventListenerBase() = default;
+    virtual void OnEvent(const Event& event) = 0;
+  };
+
   struct ListenerInfo {
-    EventListener* listener;
+    std::unique_ptr<EventListenerBase> listener;
     size_t id;
   };
 
   // Type-erased methods for internal use
-  size_t AddListener(std::type_index event_type, EventListener* listener);
+  size_t AddListener(std::type_index event_type, std::unique_ptr<EventListenerBase> listener);
   void RemoveAllListeners(std::type_index event_type);
   size_t GetListenerCount(std::type_index event_type) const;
 
@@ -191,7 +214,7 @@ class EventEmitter {
   std::unordered_map<std::type_index, std::vector<ListenerInfo>> listeners_;
 
   // Storage for callback listeners to manage their lifetime
-  std::vector<std::unique_ptr<EventListener>> callback_listeners_;
+  std::vector<std::unique_ptr<EventListenerBase>> callback_listeners_;
 
   // Async event processing
   std::mutex queue_mutex_;
@@ -212,9 +235,10 @@ class EventEmitter {
  * DEFINE_EVENT(MyEvent) {
  *   std::string message;
  *   int code;
+ *   std::string GetTypeName() const override { return "MyEvent"; }
  * };
  */
-#define DEFINE_EVENT(EventName) class EventName : public TypedEvent<EventName>
+#define DEFINE_EVENT(EventName) class EventName : public Event
 
 /**
  * Helper macro to begin defining an event with custom constructor.
@@ -224,10 +248,11 @@ class EventEmitter {
  *   std::string message;
  *   int code;
  *   MyEvent(std::string msg, int c) : message(std::move(msg)), code(c) {}
+ *   std::string GetTypeName() const override { return "MyEvent"; }
  * DEFINE_EVENT_END();
  */
-#define DEFINE_EVENT_BEGIN(EventName)              \
-  class EventName : public TypedEvent<EventName> { \
+#define DEFINE_EVENT_BEGIN(EventName) \
+  class EventName : public Event {    \
    public:
 
 #define DEFINE_EVENT_END() \
@@ -237,11 +262,12 @@ class EventEmitter {
 /**
  * Simpler macro for events with basic data members.
  * Creates a constructor that initializes all members.
+ * Note: You must implement GetTypeName() in the class body.
  */
-#define SIMPLE_EVENT(EventName, ...)               \
-  class EventName : public TypedEvent<EventName> { \
-   public:                                         \
-    __VA_ARGS__                                    \
+#define SIMPLE_EVENT(EventName, ...) \
+  class EventName : public Event {   \
+   public:                           \
+    __VA_ARGS__                      \
   };
 
 }  // namespace nativeapi