windowpp 0.1.1

package/framework/src/platform/API/App.ts

@@ -0,0 +1,156 @@
+export interface AppInfo {
+  name: string;
+  version: string;
+  identifier: string;
+}
+
+export interface Point {
+  x: number;
+  y: number;
+}
+
+export interface Size {
+  width: number;
+  height: number;
+}
+
+export interface Rect extends Point, Size {}
+
+export interface MonitorInfo {
+  name: string;
+  bounds: Rect;
+  workArea: Rect;
+  scaleFactor: number;
+  isPrimary: boolean;
+}
+
+export interface ClipboardChangedEvent {
+  name: 'clipboardChanged';
+  clipboardText: string;
+}
+
+export type AppEvent = ClipboardChangedEvent;
+
+interface PendingCall {
+  resolve: (value: any) => void;
+  reject: (reason: Error) => void;
+}
+
+let callId = 0;
+const pending = new Map<string, PendingCall>();
+const appListeners = new Set<(event: AppEvent) => void>();
+let streamEnabled = false;
+
+function getGlobal(): any {
+  if (typeof window !== 'undefined') return window;
+  if (typeof globalThis !== 'undefined') return globalThis;
+  return {};
+}
+
+const globalObject = getGlobal();
+const previousResponse = globalObject.__response__;
+const previousPlatformEvent = globalObject.__wpp_platform_event__;
+
+globalObject.__response__ = function(id: string, result: any, error?: string) {
+  const request = pending.get(id);
+  if (request) {
+    pending.delete(id);
+    if (error) {
+      request.reject(new Error(error));
+    } else {
+      request.resolve(result);
+    }
+    return;
+  }
+
+  if (previousResponse) {
+    previousResponse(id, result, error);
+  }
+};
+
+globalObject.__wpp_platform_event__ = function(eventName: string, payload: any) {
+  if (eventName === 'app') {
+    appListeners.forEach((listener) => listener(payload as AppEvent));
+  }
+
+  if (previousPlatformEvent) {
+    previousPlatformEvent(eventName, payload);
+  }
+};
+
+function invoke<T>(method: string, params: unknown[] = []): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const id = `app:${++callId}`;
+    pending.set(id, { resolve, reject });
+    const payload = JSON.stringify({ id, method, params });
+
+    if (globalObject.__native_invoke__) {
+      globalObject.__native_invoke__(payload);
+      return;
+    }
+
+    if (globalObject.chrome?.webview?.postMessage) {
+      globalObject.chrome.webview.postMessage(payload);
+      return;
+    }
+
+    pending.delete(id);
+    reject(new Error('Native bridge not available'));
+  });
+}
+
+async function ensureStreamEnabled() {
+  if (streamEnabled) {
+    return;
+  }
+  await invoke<void>('app:setEventStreamEnabled', [true]);
+  streamEnabled = true;
+}
+
+export function getInfo(): Promise<AppInfo> {
+  return invoke<AppInfo>('app:getInfo');
+}
+
+export function getMonitors(): Promise<MonitorInfo[]> {
+  return invoke<MonitorInfo[]>('app:getMonitors');
+}
+
+export function getPrimaryMonitor(): Promise<MonitorInfo> {
+  return invoke<MonitorInfo>('app:getPrimaryMonitor');
+}
+
+export function getClipboardText(): Promise<string> {
+  return invoke<string>('app:getClipboardText');
+}
+
+export function setClipboardText(text: string): Promise<void> {
+  return invoke<void>('app:setClipboardText', [text]);
+}
+
+export async function onEvent(listener: (event: AppEvent) => void): Promise<() => void> {
+  await ensureStreamEnabled();
+  appListeners.add(listener);
+  return () => {
+    appListeners.delete(listener);
+  };
+}
+
+export async function onClipboardText(listener: (text: string) => void): Promise<() => void> {
+  return onEvent((event) => {
+    if (event.name === 'clipboardChanged') {
+      listener(event.clipboardText);
+    }
+  });
+}
+
+export const app = {
+  getInfo,
+  getMonitors,
+  getPrimaryMonitor,
+  getClipboardText,
+  setClipboardText,
+  onEvent,
+  onClipboardText,
+};
+
+export default app;

package/framework/src/platform/API/Window.ts

@@ -0,0 +1,249 @@
+export type WindowState = 'normal' | 'minimized' | 'maximized' | 'fullscreen' | 'hidden';
+
+export interface Point {
+  x: number;
+  y: number;
+}
+
+export interface Size {
+  width: number;
+  height: number;
+}
+
+export interface WindowInfo {
+  id: string;
+  title: string;
+  size: Size;
+  position: Point;
+  state: WindowState;
+  visible: boolean;
+  focused: boolean;
+  scaleFactor: number;
+}
+
+export interface ResizeDetail {
+  oldSize: Size;
+  newSize: Size;
+}
+
+export interface MoveDetail {
+  oldPosition: Point;
+  newPosition: Point;
+}
+
+export interface WindowEvent {
+  name: string;
+  windowId: string;
+  window?: WindowInfo | null;
+  detail?: ResizeDetail | MoveDetail | null;
+}
+
+interface PendingCall {
+  resolve: (value: any) => void;
+  reject: (reason: Error) => void;
+}
+
+let callId = 0;
+const pending = new Map<string, PendingCall>();
+const windowListeners = new Set<(event: WindowEvent) => void>();
+let streamEnabled = false;
+
+function getGlobal(): any {
+  if (typeof window !== 'undefined') return window;
+  if (typeof globalThis !== 'undefined') return globalThis;
+  return {};
+}
+
+const globalObject = getGlobal();
+const previousResponse = globalObject.__response__;
+const previousPlatformEvent = globalObject.__wpp_platform_event__;
+
+globalObject.__response__ = function(id: string, result: any, error?: string) {
+  const request = pending.get(id);
+  if (request) {
+    pending.delete(id);
+    if (error) {
+      request.reject(new Error(error));
+    } else {
+      request.resolve(result);
+    }
+    return;
+  }
+
+  if (previousResponse) {
+    previousResponse(id, result, error);
+  }
+};
+
+globalObject.__wpp_platform_event__ = function(eventName: string, payload: any) {
+  if (eventName === 'window') {
+    windowListeners.forEach((listener) => listener(payload as WindowEvent));
+  }
+
+  if (previousPlatformEvent) {
+    previousPlatformEvent(eventName, payload);
+  }
+};
+
+function invoke<T>(method: string, params: unknown[] = []): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const id = `window:${++callId}`;
+    pending.set(id, { resolve, reject });
+    const payload = JSON.stringify({ id, method, params });
+
+    if (globalObject.__native_invoke__) {
+      globalObject.__native_invoke__(payload);
+      return;
+    }
+
+    if (globalObject.chrome?.webview?.postMessage) {
+      globalObject.chrome.webview.postMessage(payload);
+      return;
+    }
+
+    pending.delete(id);
+    reject(new Error('Native bridge not available'));
+  });
+}
+
+async function ensureStreamEnabled() {
+  if (streamEnabled) {
+    return;
+  }
+  await invoke<void>('window:setEventStreamEnabled', [true]);
+  streamEnabled = true;
+}
+
+export async function onEvent(listener: (event: WindowEvent) => void): Promise<() => void> {
+  await ensureStreamEnabled();
+  windowListeners.add(listener);
+  return () => {
+    windowListeners.delete(listener);
+  };
+}
+
+export function getCurrent(): Promise<WindowInfo> {
+  return invoke<WindowInfo>('window:getCurrent');
+}
+
+export function get(windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:get', [windowId]) : getCurrent();
+}
+
+export function list(): Promise<WindowInfo[]> {
+  return invoke<WindowInfo[]>('window:list');
+}
+
+export function setTitle(title: string, windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:setTitle', [title, windowId]) : invoke<WindowInfo>('window:setTitle', [title]);
+}
+
+export function setSize(width: number, height: number, windowId?: string): Promise<WindowInfo> {
+  return windowId
+    ? invoke<WindowInfo>('window:setSize', [width, height, windowId])
+    : invoke<WindowInfo>('window:setSize', [width, height]);
+}
+
+export function setPosition(x: number, y: number, windowId?: string): Promise<WindowInfo> {
+  return windowId
+    ? invoke<WindowInfo>('window:setPosition', [x, y, windowId])
+    : invoke<WindowInfo>('window:setPosition', [x, y]);
+}
+
+export function setMinSize(width: number, height: number, windowId?: string): Promise<WindowInfo> {
+  return windowId
+    ? invoke<WindowInfo>('window:setMinSize', [width, height, windowId])
+    : invoke<WindowInfo>('window:setMinSize', [width, height]);
+}
+
+export function setMaxSize(width: number, height: number, windowId?: string): Promise<WindowInfo> {
+  return windowId
+    ? invoke<WindowInfo>('window:setMaxSize', [width, height, windowId])
+    : invoke<WindowInfo>('window:setMaxSize', [width, height]);
+}
+
+export function setResizable(value: boolean, windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:setResizable', [value, windowId]) : invoke<WindowInfo>('window:setResizable', [value]);
+}
+
+export function setAlwaysOnTop(value: boolean, windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:setAlwaysOnTop', [value, windowId]) : invoke<WindowInfo>('window:setAlwaysOnTop', [value]);
+}
+
+export function setOpacity(value: number, windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:setOpacity', [value, windowId]) : invoke<WindowInfo>('window:setOpacity', [value]);
+}
+
+export function show(windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:show', [windowId]) : invoke<WindowInfo>('window:show');
+}
+
+export function hide(windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:hide', [windowId]) : invoke<WindowInfo>('window:hide');
+}
+
+export function close(windowId?: string): Promise<void> {
+  return windowId ? invoke<void>('window:close', [windowId]) : invoke<void>('window:close');
+}
+
+export function focus(windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:focus', [windowId]) : invoke<WindowInfo>('window:focus');
+}
+
+export function minimize(windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:minimize', [windowId]) : invoke<WindowInfo>('window:minimize');
+}
+
+export function maximize(windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:maximize', [windowId]) : invoke<WindowInfo>('window:maximize');
+}
+
+export function restore(windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:restore', [windowId]) : invoke<WindowInfo>('window:restore');
+}
+
+export function fullscreen(windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:fullscreen', [windowId]) : invoke<WindowInfo>('window:fullscreen');
+}
+
+export function center(windowId?: string): Promise<WindowInfo> {
+  return windowId ? invoke<WindowInfo>('window:center', [windowId]) : invoke<WindowInfo>('window:center');
+}
+
+export interface CreateWindowOptions {
+  title?: string;
+  width?: number;
+  height?: number;
+}
+
+export function create(url: string, options: CreateWindowOptions = {}): Promise<void> {
+  const { title = 'New Window', width = 800, height = 600 } = options;
+  return invoke<void>('window:create', [url, title, width, height]);
+}
+
+export const windowApi = {
+  onEvent,
+  getCurrent,
+  get,
+  list,
+  setTitle,
+  setSize,
+  setPosition,
+  setMinSize,
+  setMaxSize,
+  setResizable,
+  setAlwaysOnTop,
+  setOpacity,
+  show,
+  hide,
+  close,
+  focus,
+  minimize,
+  maximize,
+  restore,
+  fullscreen,
+  center,
+  create,
+};
+
+export default windowApi;

package/framework/src/platform/linux/app_linux.cpp

@@ -0,0 +1,256 @@
+// ============================================================================
+//  app_linux.cpp — Linux/X11 Application implementation
+// ============================================================================
+
+#include "app_linux.h"
+#include "../../Input/input_service.h"
+#include "../../Input/Linux/linux_key_utils.h"
+#include "../../renderer/webview/webview.h"
+#include <cstring>
+#include <glib.h>
+
+namespace wpp {
+
+LinuxApplication::LinuxApplication(const AppConfig& config) : config_(config) {
+    connection_ = xcb_connect(nullptr, nullptr);
+    int screen = 0;
+    root_ = xcb_setup_roots_iterator(xcb_get_setup(connection_)).data->root;
+
+    if (config_.tray_enabled) {
+        set_tray(config_.tray);
+    }
+}
+
+LinuxApplication::~LinuxApplication() {
+    xcb_disconnect(connection_);
+}
+
+LinuxWindow* LinuxApplication::get_window_by_native(xcb_window_t window) {
+    for (auto& entry : windows_) {
+        if (entry.second && entry.second->window() == window) {
+            return entry.second.get();
+        }
+    }
+    return nullptr;
+}
+
+Window* LinuxApplication::create_window(const WindowConfig& config) {
+    auto id = config.id.empty() ? "main" : config.id;
+
+    uint32_t value_mask = XCB_CW_EVENT_MASK;
+    uint32_t value_list[] = {
+        XCB_EVENT_MASK_KEY_PRESS |
+        XCB_EVENT_MASK_KEY_RELEASE |
+        XCB_EVENT_MASK_BUTTON_PRESS |
+        XCB_EVENT_MASK_BUTTON_RELEASE |
+        XCB_EVENT_MASK_POINTER_MOTION |
+        XCB_EVENT_MASK_EXPOSURE |
+        XCB_EVENT_MASK_STRUCTURE_NOTIFY
+    };
+
+    xcb_window_t window = xcb_generate_id(connection_);
+    xcb_create_window(connection_,
+        XCB_COPY_FROM_PARENT,
+        window,
+        root_,
+        config.x >= 0 ? config.x : 100,
+        config.y >= 0 ? config.y : 100,
+        config.width,
+        config.height,
+        0,
+        XCB_WINDOW_CLASS_INPUT_OUTPUT,
+        XCB_COPY_FROM_PARENT,
+        value_mask,
+        value_list
+    );
+
+    if (config.frameless) {
+        auto atom = linux::get_atom(connection_, "_MOTIF_WM_HINTS");
+        if (atom != XCB_NONE) {
+            uint32_t hints[5] = { 0, 0, 0, 0, 0 };
+            xcb_change_property(connection_, XCB_PROP_MODE_REPLACE, window,
+                atom, XCB_ATOM_CARDINAL, 32, 5, hints);
+        }
+    }
+
+    if (!config.title.empty()) {
+        xcb_change_property(connection_, XCB_PROP_MODE_REPLACE, window,
+            XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8,
+            config.title.size(), config.title.c_str());
+    }
+
+    if (config.initial_state != WindowState::Hidden) {
+        xcb_map_window(connection_, window);
+    }
+
+    auto window_ptr = std::make_unique<LinuxWindow>(config, window);
+
+    if (config.webview.enabled) {
+        auto webview_config = config.webview;
+        webview_config.scrollbars = config.scrollbars;
+        window_ptr->set_webview(create_webview(webview_config, reinterpret_cast<void*>(static_cast<uintptr_t>(window))));
+        if (auto* webview = window_ptr->webview()) {
+            webview->set_drag_drop_enabled(config.file_drop);
+        }
+    }
+
+    auto* ptr = window_ptr.get();
+    windows_[id] = std::move(window_ptr);
+
+    if (config.on_created) {
+        config.on_created();
+    }
+
+    return ptr;
+}
+
+Window* LinuxApplication::get_window(const std::string& id) {
+    auto it = windows_.find(id);
+    return it != windows_.end() ? it->second.get() : nullptr;
+}
+
+std::vector<Window*> LinuxApplication::all_windows() {
+    std::vector<Window*> result;
+    for (auto& [id, win] : windows_) {
+        result.push_back(win.get());
+    }
+    return result;
+}
+
+void LinuxApplication::run() {
+    running_ = true;
+    while (running_) {
+        handle_events();
+    }
+}
+
+void LinuxApplication::quit() {
+    running_ = false;
+    if (config_.on_quit) {
+        config_.on_quit();
+    }
+}
+
+void LinuxApplication::set_tray(const TrayConfig& config) {
+    tray_ = std::make_unique<LinuxTray>(config, connection_, root_);
+}
+
+void LinuxApplication::remove_tray() {
+    tray_.reset();
+}
+
+void LinuxApplication::handle_events() {
+    xcb_generic_event_t* event = xcb_poll_for_event(connection_);
+    while (event) {
+        uint8_t response_type = event->response_type & ~0x80;
+        switch (response_type) {
+            case XCB_KEY_PRESS: {
+                auto* key_event = reinterpret_cast<xcb_key_press_event_t*>(event);
+                auto* win = get_window_by_native(key_event->event);
+                if (win) {
+                    auto translated = input::linux::make_key_event(connection_, key_event, input::KeyEventType::KeyDown, win->id());
+                    input::detail::emit_key_event(translated);
+                    if (win->config().on_key_down) {
+                        win->config().on_key_down(translated);
+                    }
+                }
+                break;
+            }
+            case XCB_KEY_RELEASE: {
+                auto* key_event = reinterpret_cast<xcb_key_press_event_t*>(event);
+                auto* win = get_window_by_native(key_event->event);
+                if (win) {
+                    auto translated = input::linux::make_key_event(connection_, key_event, input::KeyEventType::KeyUp, win->id());
+                    input::detail::emit_key_event(translated);
+                    if (win->config().on_key_up) {
+                        win->config().on_key_up(translated);
+                    }
+                }
+                break;
+            }
+            case XCB_EXPOSE:
+                for (auto& [id, win] : windows_) {
+                    if (win->config().on_paint) {
+                        win->config().on_paint(win->native_handle());
+                    }
+                }
+                break;
+            case XCB_CLIENT_MESSAGE:
+                if (((xcb_client_message_event_t*)event)->type ==
+                    linux::get_atom(connection_, "WM_PROTOCOLS")) {
+                    quit();
+                }
+                break;
+        }
+        free(event);
+        event = xcb_poll_for_event(connection_);
+    }
+}
+
+std::vector<MonitorInfo> LinuxApplication::monitors() {
+    std::vector<MonitorInfo> result;
+    MonitorInfo mi;
+    mi.bounds = {0, 0, 1920, 1080};
+    mi.work_area = mi.bounds;
+    mi.scale_factor = 1.0f;
+    mi.is_primary = true;
+    mi.name = "Screen 0";
+    result.push_back(mi);
+    return result;
+}
+
+MonitorInfo LinuxApplication::primary_monitor() {
+    MonitorInfo mi;
+    mi.bounds = {0, 0, 1920, 1080};
+    mi.work_area = mi.bounds;
+    mi.scale_factor = 1.0f;
+    mi.is_primary = true;
+    mi.name = "Screen 0";
+    return mi;
+}
+
+std::string LinuxApplication::clipboard_text() {
+    return {};
+}
+
+void LinuxApplication::set_clipboard_text(const std::string& text) {
+}
+
+void LinuxApplication::send_message(const std::string& window_id,
+                                     const std::string& event,
+                                     const std::string& payload) {
+    auto it = message_handlers_.find(window_id);
+    if (it != message_handlers_.end()) {
+        for (auto& handler : it->second) {
+            handler(event, payload);
+        }
+    }
+}
+
+void LinuxApplication::on_message(const std::string& window_id, MessageHandler handler) {
+    message_handlers_[window_id].push_back(handler);
+}
+
+Application::TimerId LinuxApplication::set_timeout(uint32_t ms, std::function<void()> callback) {
+    return 0;
+}
+
+Application::TimerId LinuxApplication::set_interval(uint32_t ms, std::function<void()> callback) {
+    return 0;
+}
+
+void LinuxApplication::clear_timer(TimerId id) {
+}
+
+void LinuxApplication::dispatch(std::function<void()> fn) {
+    auto* callback = new std::function<void()>(std::move(fn));
+    g_main_context_invoke(nullptr, [](gpointer data) -> gboolean {
+        std::unique_ptr<std::function<void()>> callback_ptr(static_cast<std::function<void()>*>(data));
+        if (*callback_ptr) {
+            (*callback_ptr)();
+        }
+        return G_SOURCE_REMOVE;
+    }, callback);
+}
+
+} // namespace wpp