windowpp 0.1.1

package/framework/src/platform/platform_bridge.h

@@ -0,0 +1,514 @@
+#pragma once
+
+#include <condition_variable>
+#include <functional>
+#include <future>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#include <windowpp/windowpp.h>
+
+#include "../FileSystem/filesystem_json.h"
+
+namespace wpp::platform_api {
+
+using EvalFn = std::function<void(const std::string& js)>;
+using DispatchFn = std::function<void(std::function<void()>)>;
+using CreateWindowFn = std::function<void(const std::string& url, const std::string& title, int width, int height)>;
+
+class PlatformBridge {
+public:
+    PlatformBridge(EvalFn eval_fn,
+                   DispatchFn dispatch_fn,
+                   Application& app,
+                   AppConfig app_config,
+                   std::string current_window_id)
+        : eval_(std::move(eval_fn)),
+          dispatch_(std::move(dispatch_fn)),
+          app_(app),
+          app_config_(std::move(app_config)),
+          current_window_id_(std::move(current_window_id)) {}
+
+    void set_create_window_fn(CreateWindowFn fn) {
+        create_window_fn_ = std::move(fn);
+    }
+
+    ~PlatformBridge() {
+        {
+            std::lock_guard<std::mutex> lock(clipboard_mutex_);
+            clipboard_stop_ = true;
+        }
+        clipboard_cv_.notify_all();
+        if (clipboard_thread_.joinable()) {
+            clipboard_thread_.join();
+        }
+    }
+
+    void dispatch(const std::string& raw) {
+        std::string id;
+        std::string method;
+        std::vector<wpp::fs::JsonValue> params;
+
+        try {
+            auto env = wpp::fs::JsonValue::parse(raw);
+            id = env["id"].as_string();
+            method = env["method"].as_string();
+            params = env["params"].as_array();
+        } catch (...) {
+            return;
+        }
+
+        const bool is_app_method = method.rfind("app:", 0) == 0;
+        const bool is_window_method = method.rfind("window:", 0) == 0;
+        if (!is_app_method && !is_window_method) {
+            return;
+        }
+
+        auto reply_ok = [this, &id](const std::string& json_result) {
+            eval_("window.__response__(" + wpp::fs::JsonValue::to_js_argument(id) + "," + json_result + ")");
+        };
+
+        auto reply_err = [this, &id](const std::string& msg) {
+            eval_(
+                "window.__response__(" + wpp::fs::JsonValue::to_js_argument(id) + ",null," +
+                wpp::fs::JsonValue::to_js_argument(msg) + ")");
+        };
+
+        try {
+            if (method == "app:getInfo") {
+                reply_ok(app_info_to_json());
+
+            } else if (method == "app:getMonitors") {
+                reply_ok(monitors_to_json(app_.monitors()));
+
+            } else if (method == "app:getPrimaryMonitor") {
+                reply_ok(monitor_to_json(app_.primary_monitor()));
+
+            } else if (method == "app:getClipboardText") {
+                reply_ok(wpp::fs::JsonValue::dump_value(app_.clipboard_text()));
+
+            } else if (method == "app:setClipboardText") {
+                if (params.empty()) {
+                    throw std::runtime_error("Expected clipboard text");
+                }
+                app_.set_clipboard_text(params[0].as_string());
+                publish_clipboard_change(params[0].as_string(), true);
+                reply_ok("null");
+
+            } else if (method == "app:setEventStreamEnabled") {
+                app_stream_enabled_ = !params.empty() && params[0].as_bool();
+                if (app_stream_enabled_) {
+                    ensure_clipboard_poller_started();
+                    // Called directly on the main (IPC) thread — do NOT use
+                    // read_clipboard_text_on_ui_thread() here; that dispatches back to
+                    // this same thread and would deadlock.
+                    publish_clipboard_change(app_.clipboard_text(), false);
+                }
+                reply_ok("null");
+
+            } else if (method == "window:setEventStreamEnabled") {
+                stream_enabled_ = !params.empty() && params[0].as_bool();
+                reply_ok("null");
+
+            } else if (method == "window:getCurrent") {
+                reply_ok(window_to_json(require_window(current_window_id_)));
+
+            } else if (method == "window:get") {
+                reply_ok(window_to_json(require_window(resolve_window_id(params, 0))));
+
+            } else if (method == "window:list") {
+                reply_ok(windows_to_json(app_.all_windows()));
+
+            } else if (method == "window:setTitle") {
+                auto* window = require_window(resolve_window_id(params, 1));
+                if (params.empty()) {
+                    throw std::runtime_error("Expected title");
+                }
+                window->set_title(params[0].as_string());
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:setSize") {
+                auto* window = require_window(resolve_window_id(params, 2));
+                if (params.size() < 2) {
+                    throw std::runtime_error("Expected width and height");
+                }
+                window->set_size(params[0].as_int(), params[1].as_int());
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:setPosition") {
+                auto* window = require_window(resolve_window_id(params, 2));
+                if (params.size() < 2) {
+                    throw std::runtime_error("Expected x and y");
+                }
+                window->set_position(params[0].as_int(), params[1].as_int());
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:setMinSize") {
+                auto* window = require_window(resolve_window_id(params, 2));
+                if (params.size() < 2) {
+                    throw std::runtime_error("Expected width and height");
+                }
+                window->set_min_size(params[0].as_int(), params[1].as_int());
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:setMaxSize") {
+                auto* window = require_window(resolve_window_id(params, 2));
+                if (params.size() < 2) {
+                    throw std::runtime_error("Expected width and height");
+                }
+                window->set_max_size(params[0].as_int(), params[1].as_int());
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:setResizable") {
+                auto* window = require_window(resolve_window_id(params, 1));
+                if (params.empty()) {
+                    throw std::runtime_error("Expected boolean value");
+                }
+                window->set_resizable(params[0].as_bool());
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:setAlwaysOnTop") {
+                auto* window = require_window(resolve_window_id(params, 1));
+                if (params.empty()) {
+                    throw std::runtime_error("Expected boolean value");
+                }
+                window->set_always_on_top(params[0].as_bool());
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:setOpacity") {
+                auto* window = require_window(resolve_window_id(params, 1));
+                if (params.empty()) {
+                    throw std::runtime_error("Expected opacity value");
+                }
+                window->set_opacity(static_cast<float>(params[0].as_double()));
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:show") {
+                auto* window = require_window(resolve_window_id(params, 0));
+                window->show();
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:hide") {
+                auto* window = require_window(resolve_window_id(params, 0));
+                window->hide();
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:close") {
+                auto* window = require_window(resolve_window_id(params, 0));
+                window->close();
+                reply_ok("null");
+
+            } else if (method == "window:focus") {
+                auto* window = require_window(resolve_window_id(params, 0));
+                window->focus();
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:minimize") {
+                auto* window = require_window(resolve_window_id(params, 0));
+                window->minimize();
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:maximize") {
+                auto* window = require_window(resolve_window_id(params, 0));
+                window->maximize();
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:restore") {
+                auto* window = require_window(resolve_window_id(params, 0));
+                window->restore();
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:fullscreen") {
+                auto* window = require_window(resolve_window_id(params, 0));
+                window->fullscreen();
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:center") {
+                auto* window = require_window(resolve_window_id(params, 0));
+                window->center();
+                reply_ok(window_to_json(window));
+
+            } else if (method == "window:create") {
+                if (params.empty()) {
+                    throw std::runtime_error("Expected URL");
+                }
+                std::string url   = params[0].as_string();
+                std::string title = params.size() > 1 ? params[1].as_string() : "New Window";
+                int width         = params.size() > 2 ? params[2].as_int()    : 800;
+                int height        = params.size() > 3 ? params[3].as_int()    : 600;
+                if (!create_window_fn_) {
+                    throw std::runtime_error("window:create is not configured");
+                }
+                dispatch_([this, url, title, width, height]() {
+                    create_window_fn_(url, title, width, height);
+                });
+                reply_ok("null");
+
+            } else {
+                throw std::runtime_error("Unsupported platform API method: " + method);
+            }
+        } catch (const std::exception& e) {
+            reply_err(e.what());
+        } catch (...) {
+            reply_err("Unknown error in platform bridge");
+        }
+    }
+
+    void emit_window_event(const std::string& event_name,
+                           const std::string& window_id,
+                           const std::string& detail_json = "null") {
+        if (!stream_enabled_) {
+            return;
+        }
+
+        std::string payload = "{";
+        payload += "\"name\":" + wpp::fs::JsonValue::dump_value(event_name);
+        payload += ",\"windowId\":" + wpp::fs::JsonValue::dump_value(window_id);
+        if (auto* window = app_.get_window(window_id)) {
+            payload += ",\"window\":" + window_to_json(window);
+        }
+        payload += ",\"detail\":" + detail_json;
+        payload += "}";
+        emit_event("window", payload);
+    }
+
+    void emit_resize_event(const std::string& window_id, const ResizeEvent& event) {
+        emit_window_event(window_id.empty() ? "resize" : "resize", window_id, resize_event_to_json(event));
+    }
+
+    void emit_move_event(const std::string& window_id, const MoveEvent& event) {
+        emit_window_event("move", window_id, move_event_to_json(event));
+    }
+
+private:
+    static std::string point_to_json(Point point) {
+        return std::string("{\"x\":") + std::to_string(point.x) + ",\"y\":" + std::to_string(point.y) + "}";
+    }
+
+    static std::string size_to_json(Size size) {
+        return std::string("{\"width\":") + std::to_string(size.width) + ",\"height\":" + std::to_string(size.height) + "}";
+    }
+
+    static std::string rect_to_json(Rect rect) {
+        return std::string("{\"x\":") + std::to_string(rect.x) +
+               ",\"y\":" + std::to_string(rect.y) +
+               ",\"width\":" + std::to_string(rect.width) +
+               ",\"height\":" + std::to_string(rect.height) + "}";
+    }
+
+    static std::string state_to_string(WindowState state) {
+        switch (state) {
+            case WindowState::Normal: return "normal";
+            case WindowState::Minimized: return "minimized";
+            case WindowState::Maximized: return "maximized";
+            case WindowState::Fullscreen: return "fullscreen";
+            case WindowState::Hidden: return "hidden";
+            default: return "normal";
+        }
+    }
+
+    static std::string monitor_to_json(const MonitorInfo& monitor) {
+        std::string json = "{";
+        json += "\"name\":" + wpp::fs::JsonValue::dump_value(monitor.name);
+        json += ",\"bounds\":" + rect_to_json(monitor.bounds);
+        json += ",\"workArea\":" + rect_to_json(monitor.work_area);
+        json += ",\"scaleFactor\":" + std::to_string(monitor.scale_factor);
+        json += ",\"isPrimary\":" + std::string(monitor.is_primary ? "true" : "false");
+        json += "}";
+        return json;
+    }
+
+    static std::string monitors_to_json(const std::vector<MonitorInfo>& monitors) {
+        std::string json = "[";
+        for (size_t index = 0; index < monitors.size(); ++index) {
+            if (index > 0) {
+                json += ',';
+            }
+            json += monitor_to_json(monitors[index]);
+        }
+        json += "]";
+        return json;
+    }
+
+    std::string app_info_to_json() const {
+        std::string json = "{";
+        json += "\"name\":" + wpp::fs::JsonValue::dump_value(app_config_.name);
+        json += ",\"version\":" + wpp::fs::JsonValue::dump_value(app_config_.version);
+        json += ",\"identifier\":" + wpp::fs::JsonValue::dump_value(app_config_.identifier);
+        json += "}";
+        return json;
+    }
+
+    std::string app_event_to_json(const std::string& name, const std::string& clipboard_text) const {
+        std::string json = "{";
+        json += "\"name\":" + wpp::fs::JsonValue::dump_value(name);
+        json += ",\"clipboardText\":" + wpp::fs::JsonValue::dump_value(clipboard_text);
+        json += "}";
+        return json;
+    }
+
+    std::string window_to_json(Window* window) const {
+        if (!window) {
+            return "null";
+        }
+
+        std::string json = "{";
+        json += "\"id\":" + wpp::fs::JsonValue::dump_value(window->id());
+        json += ",\"title\":" + wpp::fs::JsonValue::dump_value(window->title());
+        json += ",\"size\":" + size_to_json(window->size());
+        json += ",\"position\":" + point_to_json(window->position());
+        json += ",\"state\":" + wpp::fs::JsonValue::dump_value(state_to_string(window->state()));
+        json += ",\"visible\":" + std::string(window->is_visible() ? "true" : "false");
+        json += ",\"focused\":" + std::string(window->is_focused() ? "true" : "false");
+        json += ",\"scaleFactor\":" + std::to_string(window->scale_factor());
+        json += "}";
+        return json;
+    }
+
+    std::string windows_to_json(const std::vector<Window*>& windows) const {
+        std::string json = "[";
+        for (size_t index = 0; index < windows.size(); ++index) {
+            if (index > 0) {
+                json += ',';
+            }
+            json += window_to_json(windows[index]);
+        }
+        json += "]";
+        return json;
+    }
+
+    static std::string resize_event_to_json(const ResizeEvent& event) {
+        return std::string("{\"oldSize\":") + size_to_json(event.old_size) +
+               ",\"newSize\":" + size_to_json(event.new_size) + "}";
+    }
+
+    static std::string move_event_to_json(const MoveEvent& event) {
+        return std::string("{\"oldPosition\":") + point_to_json(event.old_position) +
+               ",\"newPosition\":" + point_to_json(event.new_position) + "}";
+    }
+
+    std::string resolve_window_id(const std::vector<wpp::fs::JsonValue>& params, size_t index) const {
+        if (params.size() > index) {
+            return params[index].as_string();
+        }
+        return current_window_id_;
+    }
+
+    Window* require_window(const std::string& id) const {
+        auto* window = app_.get_window(id.empty() ? current_window_id_ : id);
+        if (!window) {
+            throw std::runtime_error("Window not found: " + (id.empty() ? current_window_id_ : id));
+        }
+        return window;
+    }
+
+    void emit_event(const std::string& event_name, const std::string& json_payload) {
+        std::string script = "window.__wpp_platform_event__ && window.__wpp_platform_event__(" +
+                             wpp::fs::JsonValue::to_js_argument(event_name) + "," +
+                             json_payload + ")";
+        if (dispatch_) {
+            dispatch_([eval = eval_, script = std::move(script)]() {
+                eval(script);
+            });
+            return;
+        }
+        eval_(script);
+    }
+
+    void ensure_clipboard_poller_started() {
+        std::lock_guard<std::mutex> lock(clipboard_mutex_);
+        if (clipboard_poller_started_) {
+            return;
+        }
+        clipboard_poller_started_ = true;
+        clipboard_thread_ = std::thread([this]() {
+            clipboard_poll_loop();
+        });
+    }
+
+    void clipboard_poll_loop() {
+        std::unique_lock<std::mutex> lock(clipboard_mutex_);
+        while (!clipboard_stop_) {
+            clipboard_cv_.wait_for(lock, std::chrono::milliseconds(800));
+            if (clipboard_stop_) {
+                break;
+            }
+            if (!app_stream_enabled_) {
+                continue;
+            }
+            lock.unlock();
+            const auto clipboard_text = read_clipboard_text_on_ui_thread();
+            publish_clipboard_change(clipboard_text, false);
+            lock.lock();
+        }
+    }
+
+    std::string read_clipboard_text_on_ui_thread() {
+        if (!dispatch_) {
+            return app_.clipboard_text();
+        }
+
+        auto promise = std::make_shared<std::promise<std::string>>();
+        auto future = promise->get_future();
+        dispatch_([this, promise]() {
+            try {
+                promise->set_value(app_.clipboard_text());
+            } catch (...) {
+                try {
+                    promise->set_exception(std::current_exception());
+                } catch (...) {
+                }
+            }
+        });
+
+        try {
+            return future.get();
+        } catch (...) {
+            return {};
+        }
+    }
+
+    void publish_clipboard_change(const std::string& clipboard_text, bool force_emit) {
+        if (!app_stream_enabled_) {
+            return;
+        }
+
+        bool should_emit = force_emit;
+        {
+            std::lock_guard<std::mutex> lock(clipboard_mutex_);
+            if (!clipboard_initialized_ || clipboard_last_text_ != clipboard_text) {
+                clipboard_initialized_ = true;
+                clipboard_last_text_ = clipboard_text;
+                should_emit = true;
+            }
+        }
+
+        if (!should_emit) {
+            return;
+        }
+
+        emit_event("app", app_event_to_json("clipboardChanged", clipboard_text));
+    }
+
+    EvalFn eval_;
+    DispatchFn dispatch_;
+    CreateWindowFn create_window_fn_;
+    Application& app_;
+    AppConfig app_config_;
+    std::string current_window_id_;
+    std::mutex clipboard_mutex_;
+    std::condition_variable clipboard_cv_;
+    std::thread clipboard_thread_;
+    bool clipboard_stop_ = false;
+    bool clipboard_poller_started_ = false;
+    bool clipboard_initialized_ = false;
+    bool app_stream_enabled_ = false;
+    std::string clipboard_last_text_;
+    bool stream_enabled_ = false;
+};
+
+} // namespace wpp::platform_api

package/framework/src/platform/platform_factory.cpp

@@ -0,0 +1,33 @@
+// ============================================================================
+//  platform_factory.cpp — Creates platform-specific Application instance
+// ============================================================================
+
+#include "platform_factory.h"
+
+#if defined(WIN32)
+#include "win32/app_win32.h"
+#elif defined(__APPLE__)
+#include "macos/app_macos.h"
+#elif defined(__linux__)
+#include "linux/app_linux.h"
+#else
+#error "Unsupported platform"
+#endif
+
+namespace wpp {
+
+#if defined(WIN32)
+std::unique_ptr<Application> PlatformFactory::create_application(const AppConfig& config) {
+    return std::make_unique<Win32Application>(config);
+}
+#elif defined(__APPLE__)
+std::unique_ptr<Application> PlatformFactory::create_application(const AppConfig& config) {
+    return std::make_unique<MacOSApplication>(config);
+}
+#elif defined(__linux__)
+std::unique_ptr<Application> PlatformFactory::create_application(const AppConfig& config) {
+    return std::make_unique<LinuxApplication>(config);
+}
+#endif
+
+} // namespace wpp

package/framework/src/platform/platform_factory.h

@@ -0,0 +1,19 @@
+// ============================================================================
+//  platform_factory.h — Creates platform-specific Application instance
+// ============================================================================
+
+#pragma once
+
+#include <memory>
+
+namespace wpp {
+
+class Application;
+class AppConfig;
+
+class PlatformFactory {
+public:
+    static std::unique_ptr<Application> create_application(const AppConfig& config);
+};
+
+} // namespace wpp