windowpp 0.1.1

package/framework/src/renderer/webview/webview_macos.mm

@@ -0,0 +1,388 @@
+// ============================================================================
+//  webview_macos.mm — macOS WKWebView implementation
+// ============================================================================
+
+#if defined(__APPLE__)
+
+#import <WebKit/WebKit.h>
+#include <memory>
+#include <string>
+
+// ─────────────────────────────────────────────────────────────────────────────
+// PWSchemeHandler — WKURLSchemeHandler that serves embedded assets.
+// Stores a copy of the C++ scheme_handler std::function as an Objective-C ivar.
+// ─────────────────────────────────────────────────────────────────────────────
+@interface PWSchemeHandler : NSObject <WKURLSchemeHandler>
+@end
+
+@implementation PWSchemeHandler {
+    std::function<wpp::SchemeResponse(const std::string&)> _handler;
+}
+
+- (instancetype)initWithHandlerFunc:
+    (std::function<wpp::SchemeResponse(const std::string&)>)handler {
+    self = [super init];
+    if (self) _handler = handler;
+    return self;
+}
+
+- (void)webView:(WKWebView*)webView
+    startURLSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask {
+    const char* rawPath =
+        urlSchemeTask.request.URL.path.UTF8String;
+    std::string path(rawPath ? rawPath : "/");
+    if (path.empty()) path = "/";
+
+    wpp::SchemeResponse resp = _handler(path);
+
+    NSData*   body        = [NSData dataWithBytes:resp.body.data()
+                                           length:resp.body.size()];
+    NSString* mimeType    = [NSString stringWithUTF8String:resp.content_type.c_str()];
+
+    NSURLResponse* response =
+        [[NSURLResponse alloc] initWithURL:urlSchemeTask.request.URL
+                                  MIMEType:mimeType
+                     expectedContentLength:(NSInteger)resp.body.size()
+                          textEncodingName:nil];
+    [urlSchemeTask didReceiveResponse:response];
+    [urlSchemeTask didReceiveData:body];
+    [urlSchemeTask didFinish];
+}
+
+- (void)webView:(WKWebView*)webView
+    stopURLSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask {
+    // Synchronous handler — nothing to cancel.
+}
+
+@end
+
+namespace wpp {
+
+namespace {
+
+NSString* 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'); });";
+}
+
+NSString* 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 MacOSWebView : public WebView {
+public:
+    MacOSWebView(const WebViewConfig& config, NSWindow* window);
+    ~MacOSWebView() 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 {
+        // macOS WebView auto-resizes via autoresizingMask
+    }
+
+    void set_drag_drop_enabled(bool enabled) override {
+        if (!webview_) return;
+        [webview_ evaluateJavaScript:wpp_dropzone_toggle_script(enabled) completionHandler:nil];
+    }
+
+private:
+    WebViewConfig config_;
+    NSWindow* window_;
+    WKWebView* webview_ = nullptr;
+};
+
+MacOSWebView::MacOSWebView(const WebViewConfig& config, NSWindow* window)
+    : config_(config), window_(window) {
+    
+    WKWebViewConfiguration* wkConfig = [[WKWebViewConfiguration alloc] init];
+    wkConfig.websiteDataStore = [WKWebsiteDataStore defaultDataStore];
+    WKUserContentController* contentController = [[WKUserContentController alloc] init];
+    WKUserScript* dropzoneUserScript = [[WKUserScript alloc]
+        initWithSource:wpp_dropzone_script()
+        injectionTime:WKUserScriptInjectionTimeAtDocumentStart
+        forMainFrameOnly:NO];
+    [contentController addUserScript:dropzoneUserScript];
+    wkConfig.userContentController = contentController;
+
+    if (!config.custom_scheme.empty() && config.scheme_handler) {
+        NSString* scheme =
+            [NSString stringWithUTF8String:config.custom_scheme.c_str()];
+        PWSchemeHandler* handler =
+            [[PWSchemeHandler alloc] initWithHandlerFunc:config.scheme_handler];
+        [wkConfig setURLSchemeHandler:handler forURLScheme:scheme];
+    }
+
+    webview_ = [[WKWebView alloc] initWithFrame:window.contentView.bounds
+                                   configuration:wkConfig];
+    webview_.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+    [window.contentView addSubview:webview_];
+    
+    if (!config_.initial_url.empty()) {
+        load_url(config_.initial_url);
+    } else if (!config_.initial_html.empty()) {
+        load_html(config_.initial_html);
+    }
+}
+
+MacOSWebView::~MacOSWebView() {
+    if (webview_) {
+        [webview_ removeFromSuperview];
+    }
+}
+
+void MacOSWebView::load_url(const std::string& url) {
+    if (!webview_) return;
+    NSURL* nsurl = [NSURL URLWithString:[NSString stringWithUTF8String:url.c_str()]];
+    if (nsurl) {
+        [webview_ loadRequest:[NSURLRequest requestWithURL:nsurl]];
+    }
+}
+
+void MacOSWebView::load_html(const std::string& html) {
+    if (!webview_) return;
+    [webview_ loadHTMLString:[NSString stringWithUTF8String:html.c_str()] baseURL:nil];
+}
+
+void MacOSWebView::execute_script(const std::string& script) {
+    if (!webview_) return;
+    NSString* js = [NSString stringWithUTF8String:script.c_str()];
+    [webview_ evaluateJavaScript:js completionHandler:nil];
+}
+
+void MacOSWebView::send_message(const std::string& message) {
+    if (!webview_) return;
+    NSString* js = [NSString stringWithFormat:@"window.webkit.messageHandlers.wpp.postMessage('%s');", message.c_str()];
+    [webview_ evaluateJavaScript:js completionHandler:nil];
+}
+
+void MacOSWebView::go_back() {
+    if (webview_) [webview_ goBack];
+}
+
+void MacOSWebView::go_forward() {
+    if (webview_) [webview_ goForward];
+}
+
+void MacOSWebView::reload() {
+    if (webview_) [webview_ reload];
+}
+
+void MacOSWebView::close() {
+    if (webview_) {
+        [webview_ removeFromSuperview];
+        webview_ = nil;
+    }
+}
+
+std::unique_ptr<WebView> create_webview(const WebViewConfig& config, void* native_handle) {
+    return std::make_unique<MacOSWebView>(config, (__bridge NSWindow*)native_handle);
+}
+
+} // namespace wpp
+
+#endif // __APPLE__