plusui-native-core 0.1.0

package/Core/src/app.cpp

@@ -0,0 +1,311 @@
+#include "app.hpp"
+#include "webview.h"
+#include <map>
+#include <mutex>
+#include <iostream>
+
+namespace plusui {
+
+struct App::Impl {
+    webview_t wv = nullptr;
+    bool running = false;
+};
+
+App::App() : pImpl(std::make_unique<Impl>()) {}
+App::~App() {
+    if (pImpl->wv) {
+        webview_destroy(pImpl->wv);
+    }
+}
+
+void App::run() {
+    if (pImpl->wv) {
+        pImpl->running = true;
+        webview_run(pImpl->wv);
+    }
+}
+
+void App::quit() {
+    if (pImpl->wv) {
+        webview_terminate(pImpl->wv);
+    }
+}
+
+App::Builder& App::Builder::title(const std::string& t) { config.title = t; return *this; }
+App::Builder& App::Builder::width(int w) { config.width = w; return *this; }
+App::Builder& App::Builder::height(int h) { config.height = h; return *this; }
+App::Builder& App::Builder::resizable(bool r) { config.resizable = r; return *this; }
+App::Builder& App::Builder::devtools(bool d) { config.devtools = d; return *this; }
+App::Builder& App::Builder::trayIcon(const std::string& icon) { config.trayIconPath = icon; return *this; }
+App::Builder& App::Builder::trayTooltip(const std::string& tooltip) { config.trayTooltip = tooltip; return *this; }
+App::Builder& App::Builder::alwaysOnTop(bool top) { config.alwaysOnTop = top; return *this; }
+App::Builder& App::Builder::centered(bool center) { config.centered = center; return *this; }
+App::Builder& App::Builder::transparent(bool transparent) { config.transparent = transparent; return *this; }
+App::Builder& App::Builder::decorations(bool decorations) { config.decorations = decorations; return *this; }
+App::Builder& App::Builder::skipTaskbar(bool skip) { config.skipTaskbar = skip; return *this; }
+
+struct WebView::Impl {
+    webview_t wv;
+    std::unique_ptr<TrayManager> trayManager;
+    std::unique_ptr<WindowManager> windowManager;
+    std::map<std::string, std::function<void(const std::string&)>> events;
+    std::mutex events_mutex;
+    std::map<std::string, std::function<std::string(const std::string&)>> bindings;
+    std::mutex bindings_mutex;
+
+    static void binding_callback(const char* seq, const char* req, void* arg) {
+        auto self = static_cast<Impl*>(arg);
+        std::string req_str(req);
+        
+        size_t id_start = req_str.find("\"id\":");
+        size_t method_start = req_str.find("\"method\":");
+        size_t params_start = req_str.find("\"params\":");
+        
+        if (id_start != std::string::npos && method_start != std::string::npos) {
+            size_t method_start_q = req_str.find("\"", method_start + 8);
+            size_t method_end_q = req_str.find("\"", method_start + 9);
+            std::string method = req_str.substr(method_start + 9, method_end_q - method_start - 9);
+            
+            size_t id_start_v = req_str.find(":", id_start);
+            size_t id_end = req_str.find_first_of(",}", id_start_v + 1);
+            std::string id_str = req_str.substr(id_start_v + 1, id_end - id_start_v - 1);
+            
+            std::string params = "[]";
+            if (params_start != std::string::npos) {
+                size_t params_start_b = req_str.find("[", params_start);
+                size_t params_end = req_str.find("]", params_start);
+                if (params_start_b != std::string::npos && params_end != std::string::npos) {
+                    params = req_str.substr(params_start_b, params_end - params_start_b + 1);
+                }
+            }
+            
+            std::lock_guard lock(self->bindings_mutex);
+            auto it = self->bindings.find(method);
+            if (it != self->bindings.end()) {
+                std::string result = it->second(params);
+                webview_return(self->wv, id_str.c_str(), 0, result.c_str());
+            }
+        }
+    }
+};
+
+WebView::WebView(const App::Builder::Config& config) : pImpl(std::make_unique<Impl>()) {
+    pImpl->wv = webview_create(config.devtools ? 1 : 0, nullptr);
+    
+    if (pImpl->wv) {
+        webview_set_title(pImpl->wv, config.title.c_str());
+        webview_set_size(pImpl->wv, config.width, config.height, 
+            config.resizable ? WEBVIEW_HINT_NONE : WEBVIEW_HINT_FIXED);
+
+        void* nativeWin = webview_get_window(pImpl->wv);
+        pImpl->windowManager = std::make_unique<WindowManager>(nativeWin);
+        pImpl->trayManager = std::make_unique<TrayManager>();
+
+        if (config.alwaysOnTop) {
+            pImpl->windowManager->setAlwaysOnTop(true);
+        }
+        if (config.centered) {
+            pImpl->windowManager->setCenter();
+        }
+        if (!config.decorations) {
+            pImpl->windowManager->setDecorations(false);
+        }
+        if (config.skipTaskbar) {
+            pImpl->windowManager->setSkipTaskbar(true);
+        }
+        if (config.transparent) {
+            pImpl->windowManager->setTransparency(0.0);
+        }
+        if (!config.trayIconPath.empty()) {
+            pImpl->trayManager->setIcon(config.trayIconPath);
+            pImpl->trayManager->setVisible(true);
+        }
+        if (!config.trayTooltip.empty()) {
+            pImpl->trayManager->setTooltip(config.trayTooltip);
+        }
+
+        pImpl->bindings["window.setSize"] = [this](const std::string& params) {
+            int w = 800, h = 600;
+            sscanf(params.c_str(), "[%d,%d]", &w, &h);
+            pImpl->windowManager->setSize(w, h);
+            return "true";
+        };
+        pImpl->bindings["window.setPosition"] = [this](const std::string& params) {
+            int x = 0, y = 0;
+            sscanf(params.c_str(), "[%d,%d]", &x, &y);
+            pImpl->windowManager->setPosition(x, y);
+            return "true";
+        };
+        pImpl->bindings["window.setTitle"] = [this](const std::string& params) {
+            std::string title = params.substr(1, params.length() - 2);
+            pImpl->windowManager->setTitle(title);
+            return "true";
+        };
+        pImpl->bindings["window.setFullscreen"] = [this](const std::string& params) {
+            bool fs = params == "[true]";
+            pImpl->windowManager->setFullscreen(fs);
+            return "true";
+        };
+        pImpl->bindings["window.setAlwaysOnTop"] = [this](const std::string& params) {
+            bool top = params == "[true]";
+            pImpl->windowManager->setAlwaysOnTop(top);
+            return "true";
+        };
+        pImpl->bindings["window.setResizable"] = [this](const std::string& params) {
+            bool r = params == "[true]";
+            pImpl->windowManager->setResizable(r);
+            return "true";
+        };
+        pImpl->bindings["window.setTransparency"] = [this](const std::string& params) {
+            double alpha = 1.0;
+            sscanf(params.c_str(), "[%lf]", &alpha);
+            pImpl->windowManager->setTransparency(alpha);
+            return "true";
+        };
+        pImpl->bindings["window.minimize"] = [this](const std::string&) {
+            pImpl->windowManager->minimize();
+            return "true";
+        };
+        pImpl->bindings["window.maximize"] = [this](const std::string&) {
+            pImpl->windowManager->maximize();
+            return "true";
+        };
+        pImpl->bindings["window.restore"] = [this](const std::string&) {
+            pImpl->windowManager->restore();
+            return "true";
+        };
+        pImpl->bindings["window.show"] = [this](const std::string&) {
+            pImpl->windowManager->show();
+            return "true";
+        };
+        pImpl->bindings["window.hide"] = [this](const std::string&) {
+            pImpl->windowManager->hide();
+            return "true";
+        };
+        pImpl->bindings["window.close"] = [this](const std::string&) {
+            pImpl->windowManager->close();
+            return "true";
+        };
+        pImpl->bindings["window.isMaximized"] = [this](const std::string&) {
+            return pImpl->windowManager->isMaximized() ? "true" : "false";
+        };
+        pImpl->bindings["window.isMinimized"] = [this](const std::string&) {
+            return pImpl->windowManager->isMinimized() ? "true" : "false";
+        };
+        pImpl->bindings["window.isVisible"] = [this](const std::string&) {
+            return pImpl->windowManager->isVisible() ? "true" : "false";
+        };
+        pImpl->bindings["window.getSize"] = [this](const std::string&) {
+            auto size = pImpl->windowManager->getSize();
+            return "{\"width\":" + std::to_string(size.width) + ",\"height\":" + std::to_string(size.height) + "}";
+        };
+        pImpl->bindings["window.getPosition"] = [this](const std::string&) {
+            auto pos = pImpl->windowManager->getPosition();
+            return "{\"x\":" + std::to_string(pos.x) + ",\"y\":" + std::to_string(pos.y) + "}";
+        };
+
+        pImpl->bindings["tray.setIcon"] = [this](const std::string& params) {
+            std::string path = params.substr(1, params.length() - 2);
+            pImpl->trayManager->setIcon(path);
+            return "true";
+        };
+        pImpl->bindings["tray.setTooltip"] = [this](const std::string& params) {
+            std::string tooltip = params.substr(1, params.length() - 2);
+            pImpl->trayManager->setTooltip(tooltip);
+            return "true";
+        };
+        pImpl->bindings["tray.setVisible"] = [this](const std::string& params) {
+            bool visible = params == "[true]";
+            pImpl->trayManager->setVisible(visible);
+            return "true";
+        };
+
+        webview_bind(pImpl->wv, "plusui_invoke", [](const char* seq, const char* req, void* arg) {
+            auto self = static_cast<Impl*>(arg);
+            std::string req_str(req);
+            
+            size_t id_start = req_str.find("\"id\":");
+            size_t method_start = req_str.find("\"method\":");
+            size_t params_start = req_str.find("\"params\":");
+            
+            if (id_start != std::string::npos && method_start != std::string::npos) {
+                size_t method_start_q = req_str.find("\"", method_start + 8);
+                size_t method_end_q = req_str.find("\"", method_start + 9);
+                std::string method = req_str.substr(method_start + 9, method_end_q - method_start - 9);
+                
+                size_t id_start_v = req_str.find(":", id_start);
+                size_t id_end = req_str.find_first_of(",}", id_start_v + 1);
+                std::string id_str = req_str.substr(id_start_v + 1, id_end - id_start_v - 1);
+                
+                std::string params = "[]";
+                if (params_start != std::string::npos) {
+                    size_t params_start_b = req_str.find("[", params_start);
+                    size_t params_end = req_str.find("]", params_start);
+                    if (params_start_b != std::string::npos && params_end != std::string::npos) {
+                        params = req_str.substr(params_start_b, params_end - params_start_b + 1);
+                    }
+                }
+                
+                std::lock_guard lock(self->bindings_mutex);
+                auto it = self->bindings.find(method);
+                if (it != self->bindings.end()) {
+                    std::string result = it->second(params);
+                    webview_return(self->wv, id_str.c_str(), 0, result.c_str());
+                }
+            }
+        }, pImpl.get());
+    }
+}
+
+WebView::~WebView() = default;
+
+void WebView::navigate(const std::string& url) {
+    if (pImpl->wv) {
+        webview_navigate(pImpl->wv, url.c_str());
+    }
+}
+
+void WebView::loadHTML(const std::string& html) {
+    navigate("data:text/html," + html);
+}
+
+void WebView::loadFile(const std::string& path) {
+    navigate("file://" + path);
+}
+
+void WebView::eval(const std::string& js) {
+    if (pImpl->wv) {
+        webview_eval(pImpl->wv, js.c_str());
+    }
+}
+
+void WebView::on(const std::string& event, std::function<void(const std::string&)> callback) {
+    std::lock_guard lock(pImpl->events_mutex);
+    pImpl->events[event] = callback;
+}
+
+void WebView::emit(const std::string& event, const std::string& data) {
+    std::string js = "window.dispatchEvent(new CustomEvent('" + event + "', {detail: " + data + "}))";
+    eval(js);
+}
+
+void* WebView::nativeWindow() {
+    if (pImpl->wv) {
+        return webview_get_window(pImpl->wv);
+    }
+    return nullptr;
+}
+
+TrayManager& WebView::tray() {
+    return *pImpl->trayManager;
+}
+
+WindowManager& WebView::window() {
+    return *pImpl->windowManager;
+}
+
+App::Builder createApp() {
+    return App::Builder();
+}
+
+}