windowpp 0.1.1

package/framework/src/renderer/webview/webview_linux.cpp

@@ -0,0 +1,392 @@
+// ============================================================================
+//  webview_linux.cpp — Linux WebKitGTK implementation
+// ============================================================================
+
+#if defined(__linux__)
+
+#include "../webview.h"
+#include <webkit2/webkit2.h>
+#include <gtk/gtk.h>
+#include <cstring>
+#include <memory>
+#include <string>
+
+namespace wpp {
+
+namespace {
+
+std::string wpp_dropzone_toggle_script(bool enabled) {
+    return enabled
+        ? "window.__wpp_dropzone_enabled = true;"
+        : "window.__wpp_dropzone_enabled = false; document.querySelectorAll('.wpp-dropzone-active').forEach(function(el){ el.classList.remove('wpp-dropzone-active'); });";
+}
+
+const char* wpp_dropzone_script() {
+        return R"JS(
+            (function() {
+                if (window.__wpp_dropzone_init) return;
+                window.__wpp_dropzone_init = true;
+                window.__wpp_dropzone_enabled = true;
+
+                var activeZone = null;
+                var pendingZone = null;
+                var cachedZones = [];
+                var outerBounds = null;
+                var refreshPending = false;
+                var framePending = false;
+                var _lastHit = null;
+                var observedZones = [];
+                var resizeObserver = typeof ResizeObserver === 'function'
+                    ? new ResizeObserver(function() { scheduleRefreshZones(); })
+                    : null;
+
+                var disconnectObservedZones = function() {
+                    if (!resizeObserver) return;
+                    for (var i = 0; i < observedZones.length; i++) {
+                        resizeObserver.unobserve(observedZones[i]);
+                    }
+                    observedZones = [];
+                };
+
+                var refreshZones = function() {
+                    refreshPending = false;
+                    _lastHit = null;
+                    disconnectObservedZones();
+                    cachedZones = [];
+                    outerBounds = null;
+                    var zones = document.querySelectorAll('[data-dropzone]');
+                    for (var i = 0; i < zones.length; i++) {
+                        var zone = zones[i];
+                        var rect = zone.getBoundingClientRect();
+                        var zoneData = {
+                            element: zone,
+                            left: rect.left,
+                            top: rect.top,
+                            right: rect.right,
+                            bottom: rect.bottom
+                        };
+                        cachedZones.push(zoneData);
+                        if (resizeObserver) {
+                            resizeObserver.observe(zone);
+                            observedZones.push(zone);
+                        }
+                        if (!outerBounds) {
+                            outerBounds = {left: rect.left, top: rect.top, right: rect.right, bottom: rect.bottom};
+                        } else {
+                            outerBounds.left = Math.min(outerBounds.left, rect.left);
+                            outerBounds.top = Math.min(outerBounds.top, rect.top);
+                            outerBounds.right = Math.max(outerBounds.right, rect.right);
+                            outerBounds.bottom = Math.max(outerBounds.bottom, rect.bottom);
+                        }
+                    }
+                };
+
+                var scheduleRefreshZones = function() {
+                    if (refreshPending) return;
+                    refreshPending = true;
+                    window.requestAnimationFrame(refreshZones);
+                };
+
+                var findDropZoneAt = function(x, y) {
+                    if (!outerBounds || x < outerBounds.left || x > outerBounds.right || y < outerBounds.top || y > outerBounds.bottom) {
+                        return null;
+                    }
+                    if (_lastHit && x >= _lastHit.left && x <= _lastHit.right && y >= _lastHit.top && y <= _lastHit.bottom) {
+                        return _lastHit.element;
+                    }
+                    for (var i = cachedZones.length - 1; i >= 0; i--) {
+                        var zone = cachedZones[i];
+                        if (x >= zone.left && x <= zone.right && y >= zone.top && y <= zone.bottom) {
+                            _lastHit = zone;
+                            return zone.element;
+                        }
+                    }
+                    _lastHit = null;
+                    return null;
+                };
+
+                var updateActiveZone = function(zone) {
+                    if (activeZone === zone) return;
+                    if (activeZone) {
+                        activeZone.classList.remove('wpp-dropzone-active');
+                    }
+                    activeZone = zone;
+                    if (activeZone) {
+                        activeZone.classList.add('wpp-dropzone-active');
+                    }
+                };
+
+                var flushActiveZone = function() {
+                    framePending = false;
+                    updateActiveZone(window.__wpp_dropzone_enabled ? pendingZone : null);
+                };
+
+                var scheduleZoneUpdate = function(zone) {
+                    pendingZone = zone;
+                    if (framePending) return;
+                    framePending = true;
+                    window.requestAnimationFrame(flushActiveZone);
+                };
+
+                var setDropEffect = function(e, zone) {
+                    if (!e.dataTransfer) return;
+                    try { e.dataTransfer.dropEffect = zone ? 'copy' : 'none'; } catch (_) {}
+                };
+
+                document.addEventListener('dragenter', function(e) {
+                    if (!window.__wpp_dropzone_enabled) return;
+                    e.preventDefault();
+                    if (!cachedZones.length) refreshZones();
+                    var zone = findDropZoneAt(e.clientX, e.clientY);
+                    setDropEffect(e, zone);
+                    scheduleZoneUpdate(zone);
+                }, true);
+
+                document.addEventListener('dragover', function(e) {
+                    if (!window.__wpp_dropzone_enabled) return;
+                    e.preventDefault();
+                    var zone = findDropZoneAt(e.clientX, e.clientY);
+                    setDropEffect(e, zone);
+                    scheduleZoneUpdate(zone);
+                }, true);
+
+                document.addEventListener('dragleave', function(e) {
+                    if (!window.__wpp_dropzone_enabled) return;
+                    e.preventDefault();
+                    var related = e.relatedTarget;
+                    if (!related || related === document.documentElement || related === document.body) {
+                        pendingZone = null;
+                        framePending = false;
+                        _lastHit = null;
+                        updateActiveZone(null);
+                    }
+                }, true);
+
+                document.addEventListener('drop', function(e) {
+                    if (!window.__wpp_dropzone_enabled) return;
+                    e.preventDefault();
+                    pendingZone = null;
+                    framePending = false;
+                    var zone = findDropZoneAt(e.clientX, e.clientY);
+                    var zoneName = zone ? zone.getAttribute('data-dropzone') : null;
+                    _lastHit = null;
+                    updateActiveZone(null);
+
+                    if (zoneName && window.__wpp_fileDrop__) {
+                        var files = [];
+                        if (e.dataTransfer && e.dataTransfer.files) {
+                            for (var i = 0; i < e.dataTransfer.files.length; i++) {
+                                var file = e.dataTransfer.files[i];
+                                files.push({
+                                    name: file.name,
+                                    size: file.size,
+                                    type: file.type || 'application/octet-stream'
+                                });
+                            }
+                        }
+                        window.__wpp_fileDrop__(zoneName, files);
+                    }
+                }, true);
+                window.addEventListener('dragover', function(e) {
+                    if (!window.__wpp_dropzone_enabled) return;
+                    e.preventDefault();
+                    setDropEffect(e, findDropZoneAt(e.clientX, e.clientY));
+                }, true);
+                window.addEventListener('drop', function(e) {
+                    if (!window.__wpp_dropzone_enabled) return;
+                    e.preventDefault();
+                }, true);
+                window.addEventListener('resize', scheduleRefreshZones, true);
+                window.addEventListener('scroll', scheduleRefreshZones, true);
+                document.addEventListener('DOMContentLoaded', scheduleRefreshZones, true);
+                window.addEventListener('load', scheduleRefreshZones, true);
+                var attachMutationObserver = function() {
+                    if (typeof MutationObserver !== 'function') return;
+                    var target = document.documentElement || document.body;
+                    if (!target || typeof target.nodeType !== 'number') return;
+                    new MutationObserver(scheduleRefreshZones).observe(
+                        target,
+                        { childList: true, subtree: true, attributes: true, attributeFilter: ['data-dropzone'] }
+                    );
+                };
+                if (typeof MutationObserver === 'function') {
+                    attachMutationObserver();
+                    document.addEventListener('DOMContentLoaded', attachMutationObserver, { once: true });
+                    window.addEventListener('load', attachMutationObserver, { once: true });
+                }
+                refreshZones();
+            })();
+        )JS";
+}
+
+} // namespace
+
+class LinuxWebView : public WebView {
+public:
+    LinuxWebView(const WebViewConfig& config, xcb_window_t window);
+    ~LinuxWebView() override;
+
+    void load_url(const std::string& url) override;
+    void load_html(const std::string& html) override;
+    void execute_script(const std::string& script) override;
+    void send_message(const std::string& message) override;
+    void go_back() override;
+    void go_forward() override;
+    void reload() override;
+    void close() override;
+    void resize(int width, int height) override {
+        if (socket_) {
+            gtk_widget_set_size_request(socket_, width, height);
+        }
+    }
+
+    void set_drag_drop_enabled(bool enabled) override {
+        if (!webview_) return;
+        std::string script = wpp_dropzone_toggle_script(enabled);
+        webkit_web_view_run_javascript(WEBKIT_WEB_VIEW(webview_), script.c_str(), nullptr, nullptr, nullptr);
+    }
+
+private:
+    WebViewConfig config_;
+    xcb_window_t window_;
+    GtkWidget* webview_ = nullptr;
+    GtkWidget* socket_ = nullptr;
+    static bool gtk_init_done_;
+};
+
+bool LinuxWebView::gtk_init_done_ = false;
+
+LinuxWebView::LinuxWebView(const WebViewConfig& config, xcb_window_t window)
+    : config_(config), window_(window) {
+    
+    if (!gtk_init_done_) {
+        gtk_init(nullptr, nullptr);
+        gtk_init_done_ = true;
+    }
+
+    socket_ = gtk_socket_new();
+    gtk_widget_set_size_request(socket_, 800, 600);
+    gtk_widget_show(socket_);
+    
+    GdkDisplay* display = gdk_display_get_default();
+    GdkScreen* screen = gdk_display_get_default_screen(display);
+    GtkCssProvider* provider = gtk_css_provider_get_default();
+    gtk_css_provider_load_from_data(provider, "window { background: white; }", -1, nullptr);
+    gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+    WebKitUserContentManager* content_manager = webkit_user_content_manager_new();
+    WebKitUserScript* dropzone_script = webkit_user_script_new(
+        wpp_dropzone_script(),
+        WEBKIT_USER_CONTENT_INJECT_TOP_FRAME,
+        WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
+        nullptr,
+        nullptr);
+    webkit_user_content_manager_add_script(content_manager, dropzone_script);
+    webkit_user_script_unref(dropzone_script);
+
+    webview_ = webkit_web_view_new_with_user_content_manager(content_manager);
+    g_object_unref(content_manager);
+    gtk_container_add(GTK_CONTAINER(socket_), webview_);
+    gtk_widget_show(webview_);
+
+    gtk_socket_steal(socket_, window_);
+
+    if (!config_.custom_scheme.empty() && config_.scheme_handler) {
+        struct SchemeCallbackData {
+            std::function<wpp::SchemeResponse(const std::string&)> handler;
+        };
+        auto* data = new SchemeCallbackData{config_.scheme_handler};
+
+        webkit_web_context_register_uri_scheme(
+            webkit_web_context_get_default(),
+            config_.custom_scheme.c_str(),
+            [](WebKitURISchemeRequest* request, gpointer user_data) {
+                auto* d = static_cast<SchemeCallbackData*>(user_data);
+                const char* raw = webkit_uri_scheme_request_get_path(request);
+                std::string path(raw ? raw : "/");
+                if (path.empty()) path = "/";
+
+                wpp::SchemeResponse resp = d->handler(path);
+
+                gpointer body_copy = g_malloc(resp.body.size());
+                std::memcpy(body_copy, resp.body.data(), resp.body.size());
+                GInputStream* stream = g_memory_input_stream_new_from_data(
+                    body_copy,
+                    static_cast<gssize>(resp.body.size()),
+                    g_free);
+                webkit_uri_scheme_request_finish(
+                    request,
+                    stream,
+                    static_cast<gint64>(resp.body.size()),
+                    resp.content_type.c_str());
+                g_object_unref(stream);
+            },
+            data,
+            [](gpointer d) {
+                delete static_cast<SchemeCallbackData*>(d);
+            });
+    }
+
+    if (!config_.initial_url.empty()) {
+        load_url(config_.initial_url);
+    } else if (!config_.initial_html.empty()) {
+        load_html(config_.initial_html);
+    }
+}
+
+LinuxWebView::~LinuxWebView() {
+    if (webview_) {
+        gtk_widget_destroy(webview_);
+    }
+    if (socket_) {
+        gtk_widget_destroy(socket_);
+    }
+}
+
+void LinuxWebView::load_url(const std::string& url) {
+    if (!webview_) return;
+    webkit_web_view_load_uri(WEBKIT_WEB_VIEW(webview_), url.c_str());
+}
+
+void LinuxWebView::load_html(const std::string& html) {
+    if (!webview_) return;
+    webkit_web_view_load_html(WEBKIT_WEB_VIEW(webview_), html.c_str(), nullptr);
+}
+
+void LinuxWebView::execute_script(const std::string& script) {
+    if (!webview_) return;
+    webkit_web_view_run_javascript(WEBKIT_WEB_VIEW(webview_), script.c_str(), nullptr, nullptr, nullptr);
+}
+
+void LinuxWebView::send_message(const std::string& message) {
+    if (!webview_) return;
+    std::string js = "window.webkit.messageHandlers.wpp.postMessage('" + message + "');";
+    webkit_web_view_run_javascript(WEBKIT_WEB_VIEW(webview_), js.c_str(), nullptr, nullptr, nullptr);
+}
+
+void LinuxWebView::go_back() {
+    if (webview_) webkit_web_view_go_back(WEBKIT_WEB_VIEW(webview_));
+}
+
+void LinuxWebView::go_forward() {
+    if (webview_) webkit_web_view_go_forward(WEBKIT_WEB_VIEW(webview_));
+}
+
+void LinuxWebView::reload() {
+    if (webview_) webkit_web_view_reload(WEBKIT_WEB_VIEW(webview_));
+}
+
+void LinuxWebView::close() {
+    if (webview_) {
+        gtk_widget_destroy(webview_);
+        webview_ = nullptr;
+    }
+}
+
+std::unique_ptr<WebView> create_webview(const WebViewConfig& config, void* native_handle) {
+    return std::make_unique<LinuxWebView>(config, static_cast<xcb_window_t>(reinterpret_cast<uintptr_t>(native_handle)));
+}
+
+} // namespace wpp
+
+#endif // __linux__