Implement Generic Event Handling System for C++

[Copilot]

This PR introduces a comprehensive, type-safe generic event handling system for C++ that supports both observer patterns and callback-based event handling. The system is designed to unify and extend the existing event handling patterns found in the codebase.

Background

The existing codebase uses different event handling approaches:

• DisplayManager uses an observer pattern with DisplayListener interface
• KeyboardEventHandler uses callback-based handling with std::function

These patterns work well but are not generic or unified, leading to code duplication and inconsistent approaches across different components.

Solution

The new generic event system provides:

Core Components

• Event & TypedEvent<T>: Base classes for type-safe events with automatic type identification
• EventListener & TypedEventListener<T>: Observer pattern interfaces for event handling
• CallbackEventListener<T>: Wrapper for std::function callbacks
• EventDispatcher: Thread-safe event dispatcher supporting both synchronous and asynchronous dispatch
• EventListenerGuard: RAII helper for automatic listener cleanup

Key Features

• Type Safety: Template-based design ensures compile-time type checking
• Thread Safety: Mutex-protected operations with efficient async event processing
• Multiple Patterns: Supports both observer pattern and lambda/callback approaches
• Memory Management: Automatic cleanup and RAII-based listener management
• Performance: Minimal overhead for sync dispatch, background thread for async processing
• Exception Safety: Graceful handling of exceptions in event listeners

Usage Examples

Observer pattern:

class MyObserver : public TypedEventListener<KeyPressedEvent> {
  void OnTypedEvent(const KeyPressedEvent& event) override {
    // Handle event
  }
};

EventDispatcher dispatcher;
MyObserver observer;
dispatcher.AddListener<KeyPressedEvent>(&observer);

Callback pattern:

auto guard = AddScopedListener<KeyPressedEvent>(dispatcher,
    [](const KeyPressedEvent& event) {
        // Handle event with automatic cleanup
    });

Event dispatch:

// Synchronous - immediate dispatch
dispatcher.DispatchSync<KeyPressedEvent>(keycode);

// Asynchronous - background thread processing
dispatcher.DispatchAsync<KeyPressedEvent>(keycode);

Integration

The system is designed to work alongside existing patterns without breaking changes. The EventAwareDisplayManager example shows how existing components can be enhanced to use the new system while maintaining backward compatibility.

Common predefined events are provided (DisplayAddedEvent, KeyPressedEvent, ApplicationStartedEvent, etc.) that can be used immediately or serve as examples for custom events.

Testing

The implementation includes comprehensive tests covering:

• Basic observer and callback patterns
• Multi-event observers
• Synchronous and asynchronous dispatch
• Listener management and cleanup
• Thread safety and exception handling
• RAII-based automatic cleanup

All tests pass and demonstrate the system's reliability and performance.

Documentation

Complete documentation is provided in docs/EVENT_SYSTEM.md with usage examples, best practices, and integration guidance.

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.