plusui-native-core 0.1.4 → 0.1.5

package/Core/Features/Display/display.cpp

@@ -0,0 +1,209 @@
+#ifdef _WIN32
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0601
+#endif
+#include <windows.h>
+
+#ifndef EXTERN_C
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C extern
+#endif
+#endif
+
+#include <shellapi.h>
+#include <shlobj.h>
+#include <winuser.h>
+
+#ifndef DISPLAY_DEVICE_ATTACHED_TO_SESSION
+#define DISPLAY_DEVICE_ATTACHED_TO_SESSION 0x00000001
+#endif
+#ifndef SM_CXMM
+#define SM_CXMM 43
+#endif
+#ifndef SM_CYMM
+#define SM_CYMM 44
+#endif
+
+#pragma comment(lib, "user32.lib")
+#pragma comment(lib, "shell32.lib")
+#endif
+
+#include <algorithm>
+#include <plusui/display.hpp>
+#include <vector>
+
+#ifdef __APPLE__
+#include <Cocoa/Cocoa.h>
+#include <CoreGraphics/CoreGraphics.h>
+#elif !defined(_WIN32)
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+#endif
+
+namespace plusui {
+
+struct DisplayManager::Impl {
+  std::vector<Display> displays;
+  std::function<void(const Display &)> onConnectCallback;
+  std::function<void(int)> onDisconnectCallback;
+  std::function<void(const Display &)> onChangeCallback;
+};
+
+DisplayManager::DisplayManager() : pImpl(std::make_unique<Impl>()) {
+  refresh();
+}
+
+DisplayManager::~DisplayManager() = default;
+
+DisplayManager &DisplayManager::instance() {
+  static DisplayManager inst;
+  return inst;
+}
+
+std::vector<Display> DisplayManager::getAllDisplays() {
+#ifdef _WIN32
+  pImpl->displays.clear();
+
+  int i = 0;
+  DISPLAY_DEVICEW dd = {};
+  dd.cb = sizeof(dd);
+
+  while (EnumDisplayDevicesW(nullptr, i, &dd, 0)) {
+    if (dd.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) {
+      i++;
+      continue;
+    }
+
+    Display d;
+    d.id = i;
+    // Widestring to string conversion
+    std::wstring wname(dd.DeviceName);
+    d.name = std::string(wname.begin(), wname.end());
+
+    DEVMODEW dm = {};
+    dm.dmSize = sizeof(dm);
+    if (EnumDisplaySettingsW(dd.DeviceName, ENUM_CURRENT_SETTINGS, &dm)) {
+      d.bounds.x = dm.dmPosition.x;
+      d.bounds.y = dm.dmPosition.y;
+      d.bounds.width = dm.dmPelsWidth;
+      d.bounds.height = dm.dmPelsHeight;
+      d.resolution.width = dm.dmPelsWidth;
+      d.resolution.height = dm.dmPelsHeight;
+      d.currentMode.width = dm.dmPelsWidth;
+      d.currentMode.height = dm.dmPelsHeight;
+      d.currentMode.refreshRate = dm.dmDisplayFrequency;
+    }
+
+    d.isPrimary = (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE);
+
+    HMONITOR hMon = MonitorFromWindow(nullptr, MONITOR_DEFAULTTOPRIMARY);
+    MONITORINFO mi = {};
+    mi.cbSize = sizeof(mi);
+    if (GetMonitorInfoW(hMon, &mi)) {
+      d.workArea.x = mi.rcWork.left;
+      d.workArea.y = mi.rcWork.top;
+      d.workArea.width = mi.rcWork.right - mi.rcWork.left;
+      d.workArea.height = mi.rcWork.bottom - mi.rcWork.top;
+    }
+
+    d.scaleFactor = 1.0;
+    d.isConnected = (dd.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_SESSION);
+
+    pImpl->displays.push_back(d);
+    i++;
+  }
+
+#elif defined(__APPLE__)
+  pImpl->displays.clear();
+
+  CGDirectDisplayID mainDisplay = CGMainDisplayID();
+  CGDisplayCount count;
+  CGGetActiveDisplayList(0, nullptr, &count);
+
+  std::vector<CGDirectDisplayID> displays(count);
+  CGGetActiveDisplayList(count, displays.data(), &count);
+
+  for (auto displayID : displays) {
+    Display d;
+    d.id = (int)displayID;
+    d.isPrimary = (displayID == mainDisplay);
+
+    CGRect rect = CGDisplayBounds(displayID);
+    d.bounds.x = rect.origin.x;
+    d.bounds.y = rect.origin.y;
+    d.bounds.width = rect.size.width;
+    d.bounds.height = rect.size.height;
+    d.resolution.width = rect.size.width;
+    d.resolution.height = rect.size.height;
+
+    // Work area on macOS is tricky without AppKit, but we can use NSScreen in
+    // window.cpp if needed. For now, we'll just use the full bounds.
+    d.workArea = d.bounds;
+
+    CGDisplayModeRef mode = CGDisplayCopyDisplayMode(displayID);
+    if (mode) {
+      d.currentMode.width = CGDisplayModeGetWidth(mode);
+      d.currentMode.height = CGDisplayModeGetHeight(mode);
+      d.currentMode.refreshRate = CGDisplayModeGetRefreshRate(mode);
+      CGDisplayModeRelease(mode);
+    }
+
+    d.scaleFactor = 1.0; // TODO: Get backing scale factor
+    d.isConnected = true;
+
+    pImpl->displays.push_back(d);
+  }
+#else
+  pImpl->displays.clear();
+  GdkDisplay *display = gdk_display_get_default();
+  if (display) {
+    int n = gdk_display_get_n_monitors(display);
+    for (int i = 0; i < n; i++) {
+      GdkMonitor *monitor = gdk_display_get_monitor(display, i);
+      GdkRectangle rect;
+      gdk_monitor_get_geometry(monitor, &rect);
+
+      Display d;
+      d.id = i;
+      d.isPrimary = gdk_monitor_is_primary(monitor);
+      d.bounds.x = rect.x;
+      d.bounds.y = rect.y;
+      d.bounds.width = rect.width;
+      d.bounds.height = rect.height;
+      d.resolution.width = rect.width;
+      d.resolution.height = rect.height;
+
+      gdk_monitor_get_workarea(monitor, &rect);
+      d.workArea.x = rect.x;
+      d.workArea.y = rect.y;
+      d.workArea.width = rect.width;
+      d.workArea.height = rect.height;
+
+      d.scaleFactor = gdk_monitor_get_scale_factor(monitor);
+      d.isConnected = true;
+      pImpl->displays.push_back(d);
+    }
+  }
+#endif
+  return pImpl->displays;
+}
+
+void DisplayManager::refresh() { getAllDisplays(); }
+
+void DisplayManager::onDisplayConnected(
+    std::function<void(const Display &)> callback) {
+  pImpl->onConnectCallback = callback;
+}
+
+void DisplayManager::onDisplayDisconnected(std::function<void(int)> callback) {
+  pImpl->onDisconnectCallback = callback;
+}
+
+void DisplayManager::onDisplayChanged(
+    std::function<void(const Display &)> callback) {
+  pImpl->onChangeCallback = callback;
+}
+
+} // namespace plusui

package/Core/Features/Display/display.ts

@@ -0,0 +1,104 @@
+export interface DisplayMode {
+  width: number;
+  height: number;
+  refreshRate: number;
+  bitDepth: number;
+}
+
+export interface DisplayBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface DisplayResolution {
+  width: number;
+  height: number;
+}
+
+export interface Display {
+  id: number;
+  name: string;
+  isPrimary: boolean;
+  bounds: DisplayBounds;
+  workArea: DisplayBounds;
+  resolution: DisplayResolution;
+  currentMode: DisplayMode;
+  scaleFactor: number;
+  rotation: number;
+  isInternal: boolean;
+  isConnected: boolean;
+}
+
+export class DisplayAPI {
+  constructor(
+    private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>
+  ) {}
+
+  async getAllDisplays(): Promise<Display[]> {
+    return await this.invokeFn<Display[]>('display.getAllDisplays', []);
+  }
+
+  async getPrimaryDisplay(): Promise<Display> {
+    return await this.invokeFn<Display>('display.getPrimaryDisplay', []);
+  }
+
+  async getDisplayAt(x: number, y: number): Promise<Display> {
+    return await this.invokeFn<Display>('display.getDisplayAt', [x, y]);
+  }
+
+  async getDisplayAtCursor(): Promise<Display> {
+    return await this.invokeFn<Display>('display.getDisplayAtCursor', []);
+  }
+
+  async getDisplayById(id: number): Promise<Display> {
+    return await this.invokeFn<Display>('display.getDisplayById', [id]);
+  }
+
+  async setDisplayMode(displayId: number, mode: DisplayMode): Promise<boolean> {
+    return await this.invokeFn<boolean>('display.setDisplayMode', [displayId, mode]);
+  }
+
+  async setPosition(displayId: number, x: number, y: number): Promise<boolean> {
+    return await this.invokeFn<boolean>('display.setPosition', [displayId, x, y]);
+  }
+
+  async turnOff(displayId: number): Promise<boolean> {
+    return await this.invokeFn<boolean>('display.turnOff', [displayId]);
+  }
+
+  async getScreenWidth(): Promise<number> {
+    return await this.invokeFn<number>('screen.getWidth', []);
+  }
+
+  async getScreenHeight(): Promise<number> {
+    return await this.invokeFn<number>('screen.getHeight', []);
+  }
+
+  async getScaleFactor(): Promise<number> {
+    return await this.invokeFn<number>('screen.getScaleFactor', []);
+  }
+
+  async getRefreshRate(): Promise<number> {
+    return await this.invokeFn<number>('screen.getRefreshRate', []);
+  }
+
+  onDisplayConnected(callback: (display: Display) => void): () => void {
+    return () => {};
+  }
+
+  onDisplayDisconnected(callback: (displayId: number) => void): () => void {
+    return () => {};
+  }
+
+  onDisplayChanged(callback: (display: Display) => void): () => void {
+    return () => {};
+  }
+}
+
+export function createDisplayAPI(invokeFn: (name: string, args?: unknown[]) => Promise<unknown>): DisplayAPI {
+  return new DisplayAPI(invokeFn);
+}
+
+export default DisplayAPI;

package/Core/Features/Event/Events.ts

@@ -0,0 +1,166 @@
+/**
+ * PlusUI Event System - scalable bidirectional events
+ * 
+ * Backend:
+ *   event::on("myEvent", callback)    // Listen for events from frontend
+ *   event::once("myEvent", callback)  // Listen once
+ *   event::emit("myEvent", data)      // Send events to frontend
+ * 
+ * Frontend:
+ *   const stop = event.on("myEvent", callback) // Listen + unsubscribe
+ *   event.once("myEvent", callback)            // Listen once
+ *   event.emit("myEvent", data)                // Send events to backend
+ * 
+ * Users create custom event names anywhere.
+ */
+
+type EventCallback<T = unknown> = (data: T) => void;
+type AnyEventCallback = (eventName: string, data: unknown) => void;
+export type Unsubscribe = () => void;
+
+const listeners = new Map<string, Set<EventCallback>>();
+const anyListeners = new Set<AnyEventCallback>();
+const attachedDomBridges = new Set<string>();
+
+let _invoke: ((method: string, args?: unknown[]) => Promise<unknown>) | null = null;
+
+export function setInvokeFn(fn: (method: string, args?: unknown[]) => Promise<unknown>) {
+  _invoke = fn;
+}
+
+async function invoke(method: string, args?: unknown[]): Promise<unknown> {
+  if (!_invoke) {
+    if (typeof window !== 'undefined' && (window as any).__invoke__) {
+      _invoke = (window as any).__invoke__;
+    } else {
+      throw new Error('Event API not initialized');
+    }
+  }
+  return _invoke!(method, args);
+}
+
+function validateEventName(name: string): void {
+  if (!name || !name.trim()) {
+    throw new Error('Event name must be a non-empty string');
+  }
+}
+
+function emitToLocalListeners(name: string, data: unknown): void {
+  const eventListeners = listeners.get(name);
+  if (eventListeners && eventListeners.size > 0) {
+    for (const callback of Array.from(eventListeners)) {
+      callback(data);
+    }
+  }
+
+  for (const callback of Array.from(anyListeners)) {
+    callback(name, data);
+  }
+}
+
+function ensureDomBridge(name: string): void {
+  if (typeof window === 'undefined' || attachedDomBridges.has(name)) {
+    return;
+  }
+
+  const domEvent = `plusui:event:${name}`;
+  const handler = (event: Event) => {
+    emitToLocalListeners(name, (event as CustomEvent).detail);
+  };
+
+  window.addEventListener(domEvent, handler as EventListener);
+  attachedDomBridges.add(name);
+}
+
+export const event = {
+  /**
+   * Listen for events from backend
+   * Returns an unsubscribe function.
+   */
+  on: <T = unknown>(name: string, callback: EventCallback<T>): Unsubscribe => {
+    validateEventName(name);
+
+    if (!listeners.has(name)) {
+      listeners.set(name, new Set());
+    }
+    listeners.get(name)!.add(callback as EventCallback);
+
+    ensureDomBridge(name);
+
+    return () => {
+      event.off(name, callback as EventCallback);
+    };
+  },
+
+  /**
+   * Listen once for an event from backend.
+   */
+  once: <T = unknown>(name: string, callback: EventCallback<T>): Unsubscribe => {
+    validateEventName(name);
+
+    let unsubscribe: Unsubscribe = () => {};
+    const wrapped = (data: unknown) => {
+      unsubscribe();
+      callback(data as T);
+    };
+
+    unsubscribe = event.on(name, wrapped);
+    return unsubscribe;
+  },
+
+  /**
+   * Listen to every incoming backend event that has a registered bridge.
+   */
+  onAny: (callback: AnyEventCallback): Unsubscribe => {
+    if (typeof callback !== 'function') {
+      throw new Error('onAny callback must be a function');
+    }
+
+    anyListeners.add(callback);
+
+    return () => {
+      anyListeners.delete(callback);
+    };
+  },
+
+  /**
+   * Remove one callback from a named event.
+   */
+  off: (name: string, callback: EventCallback): boolean => {
+    validateEventName(name);
+
+    const set = listeners.get(name);
+    if (!set) {
+      return false;
+    }
+
+    const removed = set.delete(callback);
+    if (set.size === 0) {
+      listeners.delete(name);
+    }
+
+    return removed;
+  },
+
+  /**
+   * Remove all listeners. If name is set, clear only that event.
+   */
+  clear: (name?: string): void => {
+    if (name === undefined) {
+      listeners.clear();
+      anyListeners.clear();
+      return;
+    }
+
+    validateEventName(name);
+    listeners.delete(name);
+  },
+
+  /**
+   * Emit events to backend.
+   */
+  emit: async (name: string, data: unknown): Promise<void> => {
+    validateEventName(name);
+    await invoke('event.emit', [name, data]);
+  },
+};

package/Core/Features/Event/events.cpp

@@ -0,0 +1,200 @@
+// Event API implementation
+#include <plusui/events.hpp>
+#include <functional>
+#include <unordered_map>
+#include <vector>
+#include <mutex>
+#include <atomic>
+#include <algorithm>
+#include <utility>
+#include <iostream>
+
+namespace plusui {
+namespace event {
+
+struct ListenerEntry {
+    ListenerId id;
+    EventCallback callback;
+    bool once;
+};
+
+struct AnyListenerEntry {
+    ListenerId id;
+    AnyEventCallback callback;
+    bool once;
+};
+
+// Event listeners registry
+static std::unordered_map<std::string, std::vector<ListenerEntry>> listeners;
+static std::vector<AnyListenerEntry> any_listeners;
+static std::mutex mutex;
+static std::atomic<ListenerId> next_listener_id{1};
+
+// Bridge to frontend (set by webview initialization)
+std::function<void(const std::string&, const EventData&)> __bridge_to_frontend__;
+
+// Listen for events from frontend
+ListenerId on(const std::string& name, EventCallback callback) {
+    if (name.empty() || !callback) {
+        return 0;
+    }
+
+    const ListenerId id = next_listener_id.fetch_add(1);
+    std::lock_guard<std::mutex> lock(mutex);
+    listeners[name].push_back({id, std::move(callback), false});
+    return id;
+}
+
+ListenerId once(const std::string& name, EventCallback callback) {
+    if (name.empty() || !callback) {
+        return 0;
+    }
+
+    const ListenerId id = next_listener_id.fetch_add(1);
+    std::lock_guard<std::mutex> lock(mutex);
+    listeners[name].push_back({id, std::move(callback), true});
+    return id;
+}
+
+ListenerId on_any(AnyEventCallback callback) {
+    if (!callback) {
+        return 0;
+    }
+
+    const ListenerId id = next_listener_id.fetch_add(1);
+    std::lock_guard<std::mutex> lock(mutex);
+    any_listeners.push_back({id, std::move(callback), false});
+    return id;
+}
+
+bool off(const std::string& name, ListenerId id) {
+    if (name.empty() || id == 0) {
+        return false;
+    }
+
+    std::lock_guard<std::mutex> lock(mutex);
+    auto it = listeners.find(name);
+    if (it == listeners.end()) {
+        return false;
+    }
+
+    auto& bucket = it->second;
+    const auto old_size = bucket.size();
+    bucket.erase(
+        std::remove_if(bucket.begin(), bucket.end(), [id](const ListenerEntry& entry) {
+            return entry.id == id;
+        }),
+        bucket.end()
+    );
+    const auto new_size = bucket.size();
+
+    if (bucket.empty()) {
+        listeners.erase(it);
+    }
+
+    return new_size != old_size;
+}
+
+bool off_any(ListenerId id) {
+    if (id == 0) {
+        return false;
+    }
+
+    std::lock_guard<std::mutex> lock(mutex);
+    const auto old_size = any_listeners.size();
+    any_listeners.erase(
+        std::remove_if(any_listeners.begin(), any_listeners.end(), [id](const AnyListenerEntry& entry) {
+            return entry.id == id;
+        }),
+        any_listeners.end()
+    );
+
+    return any_listeners.size() != old_size;
+}
+
+std::size_t off_all(const std::string& name) {
+    if (name.empty()) {
+        return 0;
+    }
+
+    std::lock_guard<std::mutex> lock(mutex);
+    auto it = listeners.find(name);
+    if (it == listeners.end()) {
+        return 0;
+    }
+
+    const auto removed = it->second.size();
+    listeners.erase(it);
+    return removed;
+}
+
+void clear() {
+    std::lock_guard<std::mutex> lock(mutex);
+    listeners.clear();
+    any_listeners.clear();
+}
+
+// Emit events to frontend
+void emit(const std::string& name, const EventData& data) {
+    if (__bridge_to_frontend__) {
+        __bridge_to_frontend__(name, data);
+    }
+}
+
+// Internal: Receive event from frontend (called by binding system)
+// This is registered as "event.emit" in the IPC handlers
+void __dispatch_from_frontend__(const std::string& name, const EventData& data) {
+    std::vector<ListenerEntry> named_callbacks;
+    std::vector<AnyListenerEntry> global_callbacks;
+
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        auto it = listeners.find(name);
+        if (it != listeners.end()) {
+            named_callbacks = it->second;
+            it->second.erase(
+                std::remove_if(it->second.begin(), it->second.end(), [](const ListenerEntry& entry) {
+                    return entry.once;
+                }),
+                it->second.end()
+            );
+
+            if (it->second.empty()) {
+                listeners.erase(it);
+            }
+        }
+
+        global_callbacks = any_listeners;
+        any_listeners.erase(
+            std::remove_if(any_listeners.begin(), any_listeners.end(), [](const AnyListenerEntry& entry) {
+                return entry.once;
+            }),
+            any_listeners.end()
+        );
+    }
+
+    for (const auto& entry : named_callbacks) {
+        try {
+            entry.callback(data);
+        } catch (const std::exception& ex) {
+            std::cerr << "[PlusUI:event] listener error for '" << name << "': " << ex.what() << std::endl;
+        } catch (...) {
+            std::cerr << "[PlusUI:event] listener error for '" << name << "': unknown exception" << std::endl;
+        }
+    }
+
+    for (const auto& entry : global_callbacks) {
+        try {
+            entry.callback(name, data);
+        } catch (const std::exception& ex) {
+            std::cerr << "[PlusUI:event] on_any listener error for '" << name << "': " << ex.what() << std::endl;
+        } catch (...) {
+            std::cerr << "[PlusUI:event] on_any listener error for '" << name << "': unknown exception" << std::endl;
+        }
+    }
+}
+
+} // namespace event
+} // namespace plusui
+
+