Step 170: UI event bus

editor/src/UIEventBus.h

@@ -0,0 +1,103 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+enum class UIEventType {
+    ASTChanged,
+    BufferSwitched,
+    DiagnosticsUpdated,
+    ThemeChanged,
+    SettingsChanged,
+    FileModified,
+    AgentConnected,
+    NotificationPosted
+};
+
+struct UIEvent {
+    UIEventType type = UIEventType::ASTChanged;
+    std::string path;
+    std::string detail;
+    double timestamp = 0.0;
+};
+
+class UIEventBus {
+public:
+    using Handler = std::function<void(const UIEvent&)>;
+
+    int subscribe(UIEventType type, Handler handler) {
+        int id = ++nextId;
+        handlers[keyFor(type)].push_back({id, std::move(handler)});
+        return id;
+    }
+
+    void publish(UIEventType type,
+                 const std::string& path = {},
+                 const std::string& detail = {},
+                 double nowSeconds = 0.0) {
+        UIEvent ev;
+        ev.type = type;
+        ev.path = path;
+        ev.detail = detail;
+        ev.timestamp = nowSeconds;
+        dispatch(ev);
+    }
+
+    void publishDebounced(UIEventType type,
+                          const std::string& path,
+                          const std::string& detail,
+                          double nowSeconds,
+                          double delaySeconds) {
+        PendingEvent& pendingEvent = pending[keyFor(type)];
+        pendingEvent.event.type = type;
+        pendingEvent.event.path = path;
+        pendingEvent.event.detail = detail;
+        pendingEvent.event.timestamp = nowSeconds;
+        pendingEvent.readyAt = nowSeconds + delaySeconds;
+    }
+
+    void tick(double nowSeconds) {
+        std::vector<int> ready;
+        ready.reserve(pending.size());
+        for (const auto& kv : pending) {
+            if (nowSeconds >= kv.second.readyAt) {
+                ready.push_back(kv.first);
+            }
+        }
+        for (int key : ready) {
+            auto it = pending.find(key);
+            if (it == pending.end()) continue;
+            dispatch(it->second.event);
+            pending.erase(it);
+        }
+    }
+
+private:
+    struct HandlerEntry {
+        int id = 0;
+        Handler fn;
+    };
+
+    struct PendingEvent {
+        UIEvent event;
+        double readyAt = 0.0;
+    };
+
+    int nextId = 0;
+    std::unordered_map<int, std::vector<HandlerEntry>> handlers;
+    std::unordered_map<int, PendingEvent> pending;
+
+    static int keyFor(UIEventType type) {
+        return static_cast<int>(type);
+    }
+
+    void dispatch(const UIEvent& ev) {
+        auto it = handlers.find(keyFor(ev.type));
+        if (it == handlers.end()) return;
+        for (const auto& entry : it->second) {
+            if (entry.fn) entry.fn(ev);
+        }
+    }
+};