windowpp 0.1.1

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

@@ -0,0 +1,64 @@
+// ============================================================================
+//  app_linux.h — Linux/X11 Application implementation
+// ============================================================================
+
+#pragma once
+
+#include <xcb/xcb.h>
+#include <map>
+#include <memory>
+#include <functional>
+#include "window_linux.h"
+#include "tray_linux.h"
+#include "windowpp.h"
+
+namespace wpp {
+
+class LinuxApplication : public Application {
+public:
+    LinuxApplication(const AppConfig& config);
+    ~LinuxApplication() override;
+
+    Window* create_window(const WindowConfig& config) override;
+    Window* get_window(const std::string& id) override;
+    std::vector<Window*> all_windows() override;
+
+    void run() override;
+    void quit() override;
+    void set_tray(const TrayConfig& config) override;
+    void remove_tray() override;
+
+    std::vector<MonitorInfo> monitors() override;
+    MonitorInfo primary_monitor() override;
+
+    std::string clipboard_text() override;
+    void set_clipboard_text(const std::string& text) override;
+
+    void send_message(const std::string& window_id,
+                      const std::string& event,
+                      const std::string& payload) override;
+    void on_message(const std::string& window_id, MessageHandler handler) override;
+
+    TimerId set_timeout(uint32_t ms, std::function<void()> callback) override;
+    TimerId set_interval(uint32_t ms, std::function<void()> callback) override;
+    void clear_timer(TimerId id) override;
+
+    void dispatch(std::function<void()> fn) override;
+
+    xcb_connection_t* connection() const { return connection_; }
+    xcb_window_t root() const { return root_; }
+
+private:
+    AppConfig config_;
+    xcb_connection_t* connection_;
+    xcb_window_t root_;
+    std::map<std::string, std::unique_ptr<LinuxWindow>> windows_;
+    std::unique_ptr<LinuxTray> tray_;
+    std::map<std::string, std::vector<MessageHandler>> message_handlers_;
+    bool running_ = false;
+
+    void handle_events();
+    LinuxWindow* get_window_by_native(xcb_window_t window);
+};
+
+} // namespace wpp

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

@@ -0,0 +1,26 @@
+// ============================================================================
+//  linux_helpers.cpp — Linux/X11 helper utilities
+// ============================================================================
+
+#include "linux_helpers.h"
+
+namespace wpp {
+namespace linux {
+
+xcb_atom_t get_atom(xcb_connection_t* conn, const char* name) {
+    xcb_atom_t atom = XCB_NONE;
+    auto len = strlen(name);
+    xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(
+        conn,
+        xcb_intern_atom(conn, len > 3 ? 1 : 0, len, name),
+        nullptr
+    );
+    if (reply) {
+        atom = reply->atom;
+        free(reply);
+    }
+    return atom;
+}
+
+} // namespace linux
+} // namespace wpp

package/framework/src/platform/linux/linux_helpers.h

@@ -0,0 +1,19 @@
+// ============================================================================
+//  linux_helpers.h — Linux/X11 helper utilities
+// ============================================================================
+
+#pragma once
+
+#include <xcb/xcb.h>
+#include <string>
+
+namespace wpp {
+namespace linux {
+
+inline std::string to_utf8(const std::string& str) { return str; }
+inline std::string from_utf8(const char* str) { return str ? str : ""; }
+
+xcb_atom_t get_atom(xcb_connection_t* conn, const char* name);
+
+} // namespace linux
+} // namespace wpp

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

@@ -0,0 +1,21 @@
+// ============================================================================
+//  tray_linux.cpp — Linux System Tray implementation
+// ============================================================================
+
+#include "tray_linux.h"
+
+namespace wpp {
+
+LinuxTray::LinuxTray(const TrayConfig& config, xcb_connection_t* conn, xcb_window_t root)
+    : config_(config), connection_(conn), root_(root) {
+#ifdef WPP_HAS_APPINDICATOR
+    // Uses appindicator3-0.1 when available
+#endif
+}
+
+LinuxTray::~LinuxTray() {
+#ifdef WPP_HAS_APPINDICATOR
+#endif
+}
+
+} // namespace wpp

package/framework/src/platform/linux/tray_linux.h

@@ -0,0 +1,26 @@
+// ============================================================================
+//  tray_linux.h — Linux System Tray implementation (StatusNotifierItem/AppIndicator)
+// ============================================================================
+
+#pragma once
+
+#include <xcb/xcb.h>
+#include "windowpp.h"
+
+namespace wpp {
+
+class LinuxTray {
+public:
+    LinuxTray(const TrayConfig& config, xcb_connection_t* conn, xcb_window_t root);
+    ~LinuxTray();
+
+private:
+    TrayConfig config_;
+    xcb_connection_t* connection_;
+    xcb_window_t root_;
+#ifdef WPP_HAS_APPINDICATOR
+    void* indicator_;
+#endif
+};
+
+} // namespace wpp

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

@@ -0,0 +1,256 @@
+// ============================================================================
+//  window_linux.cpp — Linux/X11 Window implementation
+// ============================================================================
+
+#include "window_linux.h"
+#include <cstring>
+
+namespace wpp {
+
+LinuxWindow::LinuxWindow(const WindowConfig& config, xcb_window_t window)
+    : config_(config), window_(window) {
+    connection_ = xcb_connect(nullptr, nullptr);
+}
+
+LinuxWindow::~LinuxWindow() {
+    xcb_destroy_window(connection_, window_);
+    xcb_disconnect(connection_);
+}
+
+std::string LinuxWindow::title() const {
+    auto reply = xcb_get_property_reply(
+        connection_,
+        xcb_get_property(connection_, 0, window_,
+            XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 0, 1024),
+        nullptr);
+    if (reply && reply->value_len > 0) {
+        std::string result((const char*)xcb_get_property_value(reply), reply->value_len);
+        free(reply);
+        return result;
+    }
+    return {};
+}
+
+Size LinuxWindow::size() const {
+    auto reply = xcb_get_geometry_reply(connection_,
+        xcb_get_geometry(connection_, window_), nullptr);
+    if (reply) {
+        Size s = { (int)reply->width, (int)reply->height };
+        free(reply);
+        return s;
+    }
+    return {0, 0};
+}
+
+Point LinuxWindow::position() const {
+    auto reply = xcb_get_geometry_reply(connection_,
+        xcb_get_geometry(connection_, window_), nullptr);
+    if (reply) {
+        Point p = { (int)reply->x, (int)reply->y };
+        free(reply);
+        return p;
+    }
+    return {0, 0};
+}
+
+WindowState LinuxWindow::state() const {
+    return WindowState::Normal;
+}
+
+bool LinuxWindow::is_visible() const {
+    auto reply = xcb_get_window_attributes_reply(connection_,
+        xcb_get_window_attributes(connection_, window_), nullptr);
+    if (reply) {
+        bool visible = reply->map_state == XCB_MAP_STATE_VIEWABLE;
+        free(reply);
+        return visible;
+    }
+    return false;
+}
+
+bool LinuxWindow::is_focused() const {
+    auto reply = xcb_get_input_focus_reply(connection_,
+        xcb_get_input_focus(connection_), nullptr);
+    if (reply) {
+        bool focused = reply->focus == window_;
+        free(reply);
+        return focused;
+    }
+    return false;
+}
+
+float LinuxWindow::scale_factor() const {
+    return 1.0f;
+}
+
+void LinuxWindow::set_title(const std::string& title) {
+    xcb_change_property(connection_, XCB_PROP_MODE_REPLACE, window_,
+        XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8, title.size(), title.c_str());
+}
+
+void LinuxWindow::set_size(int w, int h) {
+    uint32_t values[] = { (uint32_t)w, (uint32_t)h };
+    xcb_configure_window(connection_, window_,
+        XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);
+}
+
+void LinuxWindow::set_position(int x, int y) {
+    uint32_t values[] = { (uint32_t)x, (uint32_t)y };
+    xcb_configure_window(connection_, window_,
+        XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, values);
+}
+
+void LinuxWindow::set_min_size(int w, int h) {
+    config_.min_width = w;
+    config_.min_height = h;
+}
+
+void LinuxWindow::set_max_size(int w, int h) {
+    config_.max_width = w;
+    config_.max_height = h;
+}
+
+void LinuxWindow::set_resizable(bool v) {
+    config_.resizable = v;
+}
+
+void LinuxWindow::set_always_on_top(bool v) {
+    uint32_t stack_mode = v ? XCB_STACK_MODE_ABOVE : XCB_STACK_MODE_BELOW;
+    xcb_configure_window(connection_, window_, XCB_CONFIG_WINDOW_STACK_MODE, &stack_mode);
+}
+
+void LinuxWindow::set_opacity(float v) {
+    uint32_t opacity = static_cast<uint32_t>(v * 0xFFFFFFFF);
+    auto atom = linux::get_atom(connection_, "_NET_WM_WINDOW_OPACITY");
+    if (atom != XCB_NONE) {
+        xcb_change_property(connection_, XCB_PROP_MODE_REPLACE, window_,
+            atom, XCB_ATOM_CARDINAL, 32, 1, &opacity);
+    }
+}
+
+void LinuxWindow::set_background(Color c) {
+    config_.background = c;
+    uint32_t color = (c.r << 16) | (c.g << 8) | c.b;
+    xcb_change_window_attributes(connection_, window_,
+        XCB_CW_BACK_PIXEL, &color);
+}
+
+void LinuxWindow::set_cursor(CursorType c) {
+    uint32_t cursor_id = 0;
+    switch (c) {
+        case CursorType::Arrow:      cursor_id = 0; break;
+        case CursorType::Hand:        cursor_id = 2; break;
+        case CursorType::IBeam:       cursor_id = 4; break;
+        case CursorType::Crosshair:   cursor_id = 8; break;
+        case CursorType::ResizeNS:    cursor_id = 14; break;
+        case CursorType::ResizeEW:    cursor_id = 12; break;
+        case CursorType::ResizeNWSE:  cursor_id = 18; break;
+        case CursorType::ResizeNESW:  cursor_id = 16; break;
+        case CursorType::Move:        cursor_id = 20; break;
+        case CursorType::NotAllowed:  cursor_id = 22; break;
+        default:                       cursor_id = 0; break;
+    }
+}
+
+void LinuxWindow::show() {
+    xcb_map_window(connection_, window_);
+    if (config_.on_shown) config_.on_shown();
+}
+
+void LinuxWindow::hide() {
+    xcb_unmap_window(connection_, window_);
+    if (config_.on_hidden) config_.on_hidden();
+}
+
+void LinuxWindow::close() {
+    if (config_.on_close_requested && !config_.on_close_requested()) {
+        return;
+    }
+    xcb_destroy_window(connection_, window_);
+    if (config_.on_closed) config_.on_closed();
+}
+
+void LinuxWindow::focus() {
+    xcb_set_input_focus(connection_, XCB_INPUT_FOCUS_PARENT, window_, XCB_CURRENT_TIME);
+}
+
+void LinuxWindow::minimize() {
+    xcb_iconify_window(connection_, window_, 0);
+}
+
+void LinuxWindow::maximize() {
+    auto reply = xcb_get_property_reply(connection_,
+        xcb_get_property(connection_, 0, window_,
+            linux::get_atom(connection_, "_NET_WM_STATE"),
+            XCB_ATOM_ATOM, 0, 32), nullptr);
+    free(reply);
+}
+
+void LinuxWindow::restore() {
+    xcb_map_window(connection_, window_);
+}
+
+void LinuxWindow::fullscreen() {
+}
+
+void LinuxWindow::center() {
+}
+
+void LinuxWindow::request_repaint() {
+    uint32_t values[] = { XCB_BACKING_STORE_NOT_USEFUL };
+    xcb_change_window_attributes(connection_, window_, XCB_CW_BACKING_STORE, values);
+}
+
+void LinuxWindow::start_drag() {
+    auto atom = linux::get_atom(connection_, "_NET_WM_MOVERESIZE");
+    xcb_client_message_event_t event = {};
+    event.response_type = XCB_CLIENT_MESSAGE;
+    event.window = window_;
+    event.type = atom;
+    event.format = 32;
+    event.data.data32[0] = 0;
+    event.data.data32[1] = 0;
+    event.data.data32[2] = 8;
+    xcb_send_event(connection_, 0, window_,
+        XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_BUTTON_PRESS,
+        (const char*)&event);
+}
+
+void LinuxWindow::start_resize(HitTestRegion edge) {
+    int direction = 0;
+    switch (edge) {
+        case HitTestRegion::ResizeTop:        direction = 1; break;
+        case HitTestRegion::ResizeBottom:     direction = 5; break;
+        case HitTestRegion::ResizeLeft:        direction = 7; break;
+        case HitTestRegion::ResizeRight:       direction = 3; break;
+        case HitTestRegion::ResizeTopLeft:     direction = 0; break;
+        case HitTestRegion::ResizeTopRight:    direction = 2; break;
+        case HitTestRegion::ResizeBottomLeft:  direction = 6; break;
+        case HitTestRegion::ResizeBottomRight: direction = 4; break;
+        default: return;
+    }
+    auto atom = linux::get_atom(connection_, "_NET_WM_MOVERESIZE");
+    xcb_client_message_event_t event = {};
+    event.response_type = XCB_CLIENT_MESSAGE;
+    event.window = window_;
+    event.type = atom;
+    event.format = 32;
+    event.data.data32[0] = 0;
+    event.data.data32[1] = direction;
+    event.data.data32[2] = 0;
+    xcb_send_event(connection_, 0, window_,
+        XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_BUTTON_PRESS,
+        (const char*)&event);
+}
+
+HitTestRegion LinuxWindow::hit_test(Point cursor) {
+    if (config_.on_hit_test) {
+        return config_.on_hit_test(cursor);
+    }
+    return default_hit_test(cursor, size(),
+                            config_.resize_border_width,
+                            config_.caption_height,
+                            config_.resizable);
+}
+
+} // namespace wpp

package/framework/src/platform/linux/window_linux.h

@@ -0,0 +1,70 @@
+// ============================================================================
+//  window_linux.h — Linux/X11 Window implementation
+// ============================================================================
+
+#pragma once
+
+#include <xcb/xcb.h>
+#include <map>
+#include <functional>
+#include <memory>
+#include "linux_helpers.h"
+#include "windowpp.h"
+
+namespace wpp {
+
+class LinuxWindow : public Window {
+public:
+    LinuxWindow(const WindowConfig& config, xcb_window_t window);
+    ~LinuxWindow() override;
+
+    std::string id() const override { return config_.id; }
+    std::string title() const override;
+    Size size() const override;
+    Point position() const override;
+    WindowState state() const override;
+    bool is_visible() const override;
+    bool is_focused() const override;
+    float scale_factor() const override;
+    void* native_handle() const override { return reinterpret_cast<void*>(window_); }
+
+    void set_title(const std::string& title) override;
+    void set_size(int w, int h) override;
+    void set_position(int x, int y) override;
+    void set_min_size(int w, int h) override;
+    void set_max_size(int w, int h) override;
+    void set_resizable(bool v) override;
+    void set_always_on_top(bool v) override;
+    void set_opacity(float v) override;
+    void set_background(Color c) override;
+    void set_cursor(CursorType c) override;
+
+    void show() override;
+    void hide() override;
+    void close() override;
+    void focus() override;
+    void minimize() override;
+    void maximize() override;
+    void restore() override;
+    void fullscreen() override;
+    void center() override;
+    void request_repaint() override;
+    void start_drag() override;
+    void start_resize(HitTestRegion edge) override;
+
+    WebView* webview() override { return webview_.get(); }
+    void set_webview(std::unique_ptr<WebView> wv) { webview_ = std::move(wv); }
+
+    xcb_window_t window() const { return window_; }
+    const WindowConfig& config() const { return config_; }
+
+    HitTestRegion hit_test(Point cursor);
+
+private:
+    WindowConfig config_;
+    xcb_window_t window_;
+    xcb_connection_t* connection_;
+    std::unique_ptr<WebView> webview_;
+};
+
+} // namespace wpp

package/framework/src/platform/macos/app_macos.h

@@ -0,0 +1,59 @@
+// ============================================================================
+//  app_macos.h — macOS/Cocoa Application implementation
+// ============================================================================
+
+#pragma once
+
+#import <Cocoa/Cocoa.h>
+#include <map>
+#include <memory>
+#include <functional>
+#include "window_macos.h"
+#include "tray_macos.h"
+#include "windowpp.h"
+
+@class PWAppDelegate;
+
+namespace wpp {
+
+class MacOSApplication : public Application {
+public:
+    MacOSApplication(const AppConfig& config);
+    ~MacOSApplication() override;
+
+    Window* create_window(const WindowConfig& config) override;
+    Window* get_window(const std::string& id) override;
+    std::vector<Window*> all_windows() override;
+
+    void run() override;
+    void quit() override;
+    void set_tray(const TrayConfig& config) override;
+    void remove_tray() override;
+
+    std::vector<MonitorInfo> monitors() override;
+    MonitorInfo primary_monitor() override;
+
+    std::string clipboard_text() override;
+    void set_clipboard_text(const std::string& text) override;
+
+    void send_message(const std::string& window_id,
+                      const std::string& event,
+                      const std::string& payload) override;
+    void on_message(const std::string& window_id, MessageHandler handler) override;
+
+    TimerId set_timeout(uint32_t ms, std::function<void()> callback) override;
+    TimerId set_interval(uint32_t ms, std::function<void()> callback) override;
+    void clear_timer(TimerId id) override;
+
+    void dispatch(std::function<void()> fn) override;
+
+private:
+    AppConfig config_;
+    NSApplication* app_;
+    PWAppDelegate* delegate_;
+    std::map<std::string, std::unique_ptr<MacOSWindow>> windows_;
+    std::unique_ptr<MacOSTray> tray_;
+    std::map<std::string, std::vector<MessageHandler>> message_handlers_;
+};
+
+} // namespace wpp