windowpp 0.1.1

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

@@ -0,0 +1,688 @@
+// ============================================================================
+//  webview_win32.cpp — Win32 WebView2 implementation
+// ============================================================================
+
+#if defined(WIN32)
+
+#define WPP_HAS_WEBVIEW2 1
+#include "webview.h"
+#include "../../Input/input_service.h"
+#include "../../Input/Windows/win32_key_utils.h"
+#include "../../platform/win32/window_win32.h"
+#include <windows.h>
+#include <wrl.h>
+#include <wrl/client.h>
+#include <WebView2.h>
+#include <cctype>
+#include <string>
+#include <memory>
+#include <codecvt>
+#include <nlohmann/json.hpp>
+#include <shlwapi.h>
+#pragma comment(lib, "shlwapi.lib")
+
+namespace wpp {
+
+using namespace Microsoft::WRL;
+
+namespace {
+
+using json = nlohmann::json;
+
+} // namespace
+
+class Win32WebView : public WebView {
+public:
+    Win32WebView(const WebViewConfig& config, HWND parent_hwnd)
+        : config_(config), parent_hwnd_(parent_hwnd) {
+
+        RECT rc;
+        GetClientRect(parent_hwnd_, &rc);
+      int inset = config_.frameless ? 1 : 0;
+      int host_width = rc.right - rc.left - (inset * 2);
+      int host_height = rc.bottom - rc.top - (inset * 2);
+      if (host_width < 1) host_width = 1;
+      if (host_height < 1) host_height = 1;
+
+      webview_host_hwnd_ = CreateWindowExW(
+        0,
+        L"STATIC",
+        L"",
+        WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
+        inset,
+        inset,
+        host_width,
+        host_height,
+        parent_hwnd_,
+        nullptr,
+        GetModuleHandleW(nullptr),
+        nullptr);
+
+        // Convert user_data_dir to wide string (empty = let WebView2 pick default)
+        std::wstring wUserDataDir;
+        if (!config_.user_data_dir.empty()) {
+            int len = MultiByteToWideChar(CP_UTF8, 0,
+                          config_.user_data_dir.c_str(), -1, nullptr, 0);
+            if (len > 0) {
+                wUserDataDir.resize(len - 1);
+                MultiByteToWideChar(CP_UTF8, 0,
+                    config_.user_data_dir.c_str(), -1, &wUserDataDir[0], len);
+            }
+        }
+
+        HRESULT hr = CreateCoreWebView2EnvironmentWithOptions(
+            nullptr,
+            wUserDataDir.empty() ? nullptr : wUserDataDir.c_str(),
+            nullptr,
+            Callback<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>(
+                [this, rc](HRESULT result, ICoreWebView2Environment* env) -> HRESULT {
+                    if (SUCCEEDED(result) && env) {
+                        env_ = env;
+                        HRESULT hr = env_->CreateCoreWebView2Controller(
+                          webview_host_hwnd_ ? webview_host_hwnd_ : parent_hwnd_,
+                            Callback<ICoreWebView2CreateCoreWebView2ControllerCompletedHandler>(
+                                [this, rc](HRESULT result, ICoreWebView2Controller* controller) -> HRESULT {
+                                    if (SUCCEEDED(result) && controller) {
+                                        controller_ = controller;
+                                        controller_->get_CoreWebView2(&webview_);
+
+                                        controller_->put_IsVisible(TRUE);
+
+                                int inset = config_.frameless ? 1 : 0;
+                                RECT bounds = {0, 0, rc.right - rc.left - (inset * 2), rc.bottom - rc.top - (inset * 2)};
+                                if (bounds.right <= 0) bounds.right = 1;
+                                if (bounds.bottom <= 0) bounds.bottom = 1;
+                                        controller_->put_Bounds(bounds);
+
+                                        if (config_.frameless) {
+                                            ComPtr<ICoreWebView2Controller2> controller2;
+                                            controller->QueryInterface(IID_PPV_ARGS(&controller2));
+                                            if (controller2) {
+                                                COREWEBVIEW2_COLOR transparent = {0, 0, 0, 0};
+                                                controller2->put_DefaultBackgroundColor(transparent);
+                                            }
+                                        }
+
+                                        EventRegistrationToken token;
+                                        webview_->add_NavigationCompleted(
+                                            Callback<ICoreWebView2NavigationCompletedEventHandler>(
+                                                [this](ICoreWebView2*, ICoreWebView2NavigationCompletedEventArgs*) -> HRESULT {
+                                                    if (config_.on_load_finished) {
+                                                        config_.on_load_finished("load_finished");
+                                                    }
+                                                    return S_OK;
+                                                }).Get(), &token);
+
+                                        webview_->add_WebMessageReceived(
+                                            Callback<ICoreWebView2WebMessageReceivedEventHandler>(
+                                                [this](ICoreWebView2*, ICoreWebView2WebMessageReceivedEventArgs* args) -> HRESULT {
+                                                    LPWSTR message = nullptr;
+                                                    if (SUCCEEDED(args->TryGetWebMessageAsString(&message)) && message) {
+                                                        std::wstring wmsg(message);
+                                                        CoTaskMemFree(message);
+                                                        std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+                                                        std::string msg = converter.to_bytes(wmsg);
+                                                if (handle_file_drop_message(msg)) {
+                                                  return S_OK;
+                                                }
+                                                        if (config_.on_message) {
+                                                            config_.on_message(msg);
+                                                        }
+                                                    }
+                                                    return S_OK;
+                                                }).Get(), &token);
+
+                                              controller_->add_AcceleratorKeyPressed(
+                                                Callback<ICoreWebView2AcceleratorKeyPressedEventHandler>(
+                                                  [this](ICoreWebView2Controller*, ICoreWebView2AcceleratorKeyPressedEventArgs* args) -> HRESULT {
+                                                    if (!parent_hwnd_) {
+                                                      return S_OK;
+                                                    }
+
+                                                    auto* win = wpp::Win32Window::from_hwnd(parent_hwnd_);
+                                                    if (!win) {
+                                                      return S_OK;
+                                                    }
+
+                                                    COREWEBVIEW2_KEY_EVENT_KIND kind = COREWEBVIEW2_KEY_EVENT_KIND_KEY_DOWN;
+                                                    UINT virtual_key = 0;
+                                                    INT lparam = 0;
+                                                    args->get_KeyEventKind(&kind);
+                                                    args->get_VirtualKey(&virtual_key);
+                                                    args->get_KeyEventLParam(&lparam);
+
+                                                    const UINT message =
+                                                      kind == COREWEBVIEW2_KEY_EVENT_KIND_KEY_UP
+                                                        ? WM_KEYUP
+                                                        : kind == COREWEBVIEW2_KEY_EVENT_KIND_SYSTEM_KEY_UP
+                                                          ? WM_SYSKEYUP
+                                                          : kind == COREWEBVIEW2_KEY_EVENT_KIND_SYSTEM_KEY_DOWN
+                                                            ? WM_SYSKEYDOWN
+                                                            : WM_KEYDOWN;
+
+                                                    auto event = input::win32::make_key_event(
+                                                      message,
+                                                      static_cast<WPARAM>(virtual_key),
+                                                      static_cast<LPARAM>(lparam),
+                                                      win->id());
+
+                                                    input::detail::emit_key_event(event);
+
+                                                    if (event.type == input::KeyEventType::KeyDown) {
+                                                      if (win->config().on_key_down) {
+                                                        win->config().on_key_down(event);
+                                                      }
+                                                    } else if (win->config().on_key_up) {
+                                                      win->config().on_key_up(event);
+                                                    }
+                                                    return S_OK;
+                                                  }).Get(),
+                                                &token);
+
+                                        if (!config_.scrollbars) {
+                                            std::string hideScrollbarScript = R"(
+                                              (function() {
+                                                var css = "html, body { overflow: auto !important; height: 100% !important; margin: 0 !important; padding: 0 !important; } ::-webkit-scrollbar{display:none!important;width:0!important;height:0!important;}::-webkit-scrollbar-track{background:transparent!important;}::-webkit-scrollbar-thumb{background:transparent!important;}*{-ms-overflow-style:none!important;scrollbar-width:none!important;scrollbar-color:transparent transparent!important;}";
+                                                var styleId = "__wpp_hide_scrollbars";
+                                                var ensureStyle = function() {
+                                                  if (document.getElementById(styleId)) return;
+                                                  var style = document.createElement("style");
+                                                  style.id = styleId;
+                                                  style.type = "text/css";
+                                                  style.appendChild(document.createTextNode(css));
+                                                  var container = document.head || document.documentElement || document.body;
+                                                  if (container) {
+                                                    container.appendChild(style);
+                                                  }
+                                                };
+                                                ensureStyle();
+                                                document.addEventListener("DOMContentLoaded", ensureStyle);
+                                                window.addEventListener("load", ensureStyle);
+                                              })();
+                                            )";
+                                            webview_->AddScriptToExecuteOnDocumentCreated(
+                                                std::wstring(hideScrollbarScript.begin(), hideScrollbarScript.end()).c_str(),
+                                                nullptr);
+                                        }
+
+                                        std::string dropzoneScript = R"(
+                                          (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();
+                                          })();
+                                        )";
+
+                                        webview_->AddScriptToExecuteOnDocumentCreated(
+                                            std::wstring(dropzoneScript.begin(), dropzoneScript.end()).c_str(),
+                                            nullptr);
+
+                                        if (config_.file_drop) {
+                                          ComPtr<ICoreWebView2Controller4> controller4;
+                                          if (SUCCEEDED(controller_->QueryInterface(IID_PPV_ARGS(&controller4))) && controller4) {
+                                            controller4->put_AllowExternalDrop(TRUE);
+                                          }
+                                        }
+
+                                        // Custom scheme interception
+                                        // Win32/WebView2 doesn't support navigating to arbitrary custom
+                                        // schemes without environment-level registration.  Instead we map
+                                        // <scheme>://<host>/<path>  ->  https://<scheme>.localhost/<path>
+                                        // (*.localhost is always treated as a secure origin).
+                                        if (!config_.custom_scheme.empty() && config_.scheme_handler) {
+                                            std::wstring filter =
+                                                L"https://" +
+                                                std::wstring(config_.custom_scheme.begin(), config_.custom_scheme.end()) +
+                                                L".localhost/*";
+                                            webview_->AddWebResourceRequestedFilter(
+                                                filter.c_str(),
+                                                COREWEBVIEW2_WEB_RESOURCE_CONTEXT_ALL);
+
+                                            EventRegistrationToken scheme_token;
+                                            webview_->add_WebResourceRequested(
+                                                Callback<ICoreWebView2WebResourceRequestedEventHandler>(
+                                                    [this](ICoreWebView2*, ICoreWebView2WebResourceRequestedEventArgs* args) -> HRESULT {
+                                                        ComPtr<ICoreWebView2WebResourceRequest> request;
+                                                        args->get_Request(&request);
+                                                        LPWSTR uri_raw = nullptr;
+                                                        request->get_Uri(&uri_raw);
+                                                        if (!uri_raw) return S_OK;
+                                                        std::wstring wuri(uri_raw);
+                                                        CoTaskMemFree(uri_raw);
+
+                                                        // Extract path: strip "https://<scheme>.localhost"
+                                                        // Use WideCharToMultiByte for correct wide→UTF-8 conversion.
+                                                        int len = WideCharToMultiByte(
+                                                            CP_UTF8, 0, wuri.c_str(), -1,
+                                                            nullptr, 0, nullptr, nullptr);
+                                                        std::string full(len > 0 ? len - 1 : 0, '\0');
+                                                        if (len > 0) WideCharToMultiByte(
+                                                            CP_UTF8, 0, wuri.c_str(), -1,
+                                                            &full[0], len, nullptr, nullptr);
+                                                        std::string host_prefix =
+                                                            "https://" + config_.custom_scheme + ".localhost";
+                                                        std::string path = "/";
+                                                        if (full.size() > host_prefix.size() &&
+                                                            full.compare(0, host_prefix.size(), host_prefix) == 0) {
+                                                            path = full.substr(host_prefix.size());
+                                                            if (path.empty()) path = "/";
+                                                        }
+                                                        // Strip query and fragment
+                                                        auto q = path.find('?');
+                                                        if (q != std::string::npos) path.resize(q);
+                                                        auto f = path.find('#');
+                                                        if (f != std::string::npos) path.resize(f);
+                                                        if (path.empty()) path = "/";
+
+                                                        wpp::SchemeResponse resp = config_.scheme_handler(path);
+
+                                                        IStream* stream = SHCreateMemStream(
+                                                            reinterpret_cast<const BYTE*>(resp.body.data()),
+                                                            static_cast<UINT>(resp.body.size()));
+                                                        if (!stream) return S_OK;
+
+                                                        std::wstring wctype(resp.content_type.begin(), resp.content_type.end());
+                                                        std::wstring headers = L"Content-Type: " + wctype;
+                                                        ComPtr<ICoreWebView2WebResourceResponse> response;
+                                                        env_->CreateWebResourceResponse(
+                                                            stream, resp.status, L"OK",
+                                                            headers.c_str(), &response);
+                                                        stream->Release();
+                                                        args->put_Response(response.Get());
+                                                        return S_OK;
+                                                    }).Get(), &scheme_token);
+                                        }
+
+                                        if (!config_.initial_url.empty()) {
+                                            load_url(config_.initial_url);
+                                        } else if (!config_.initial_html.empty()) {
+                                            load_html(config_.initial_html);
+                                        }
+                                    }
+                                    return S_OK;
+                                }).Get());
+                    }
+                    return S_OK;
+                }).Get());
+    }
+
+    ~Win32WebView() override {
+        close();
+    }
+
+    void load_url(const std::string& url) override {
+        if (!webview_) return;
+        std::string final_url = url;
+        // Remap <custom_scheme>://host/path  ->  https://<custom_scheme>.localhost/path
+        // so that Win32 WebView2 can navigate without custom scheme registration.
+        if (!config_.custom_scheme.empty()) {
+            const std::string prefix = config_.custom_scheme + "://";
+            if (url.size() > prefix.size() &&
+                url.compare(0, prefix.size(), prefix) == 0) {
+                std::string rest  = url.substr(prefix.size());
+                auto         sl   = rest.find('/');
+                std::string  path = (sl != std::string::npos) ? rest.substr(sl) : "/";
+                final_url = "https://" + config_.custom_scheme + ".localhost" + path;
+            }
+        }
+        std::wstring wurl(final_url.begin(), final_url.end());
+        webview_->Navigate(wurl.c_str());
+    }
+
+    void load_html(const std::string& html) override {
+        if (webview_) {
+            std::wstring whtml(html.begin(), html.end());
+            webview_->NavigateToString(whtml.c_str());
+        }
+    }
+
+    void execute_script(const std::string& script) override {
+      if (webview_) {
+        std::wstring wscript(script.begin(), script.end());
+        webview_->ExecuteScript(wscript.c_str(), nullptr);
+      }
+    }
+
+    void send_message(const std::string& message) override {
+        if (webview_) {
+            std::wstring wmsg(message.begin(), message.end());
+            webview_->PostWebMessageAsString(wmsg.c_str());
+        }
+    }
+
+    void go_back() override {
+        if (webview_) webview_->GoBack();
+    }
+
+    void go_forward() override {
+        if (webview_) webview_->GoForward();
+    }
+
+    void reload() override {
+        if (webview_) webview_->Reload();
+    }
+
+    void close() override {
+        if (controller_) {
+            controller_->put_IsVisible(FALSE);
+            controller_.Reset();
+        }
+        if (webview_) {
+            webview_.Reset();
+        }
+        if (env_) {
+            env_.Reset();
+        }
+        if (webview_host_hwnd_ && IsWindow(webview_host_hwnd_)) {
+          DestroyWindow(webview_host_hwnd_);
+          webview_host_hwnd_ = nullptr;
+        }
+    }
+
+    void resize(int width, int height) override {
+        int inset = config_.frameless ? 8 : 0;
+        int host_width = width - (inset * 2);
+        int host_height = height - (inset * 2);
+        if (host_width < 1) host_width = 1;
+        if (host_height < 1) host_height = 1;
+        if (webview_host_hwnd_ && IsWindow(webview_host_hwnd_)) {
+          SetWindowPos(
+            webview_host_hwnd_,
+            nullptr,
+            inset,
+            inset,
+            host_width,
+            host_height,
+            SWPP_NOZORDER | SWPP_NOACTIVATE | SWPP_SHOWWINDOW);
+        }
+        if (controller_) {
+          RECT bounds = {0, 0, host_width, host_height};
+            controller_->put_Bounds(bounds);
+          controller_->NotifyParentWindowPositionChanged();
+        }
+    }
+
+    void set_drag_drop_enabled(bool enabled) override {
+      drag_drop_enabled_ = enabled;
+        if (controller_) {
+          ComPtr<ICoreWebView2Controller4> controller4;
+          if (SUCCEEDED(controller_->QueryInterface(IID_PPV_ARGS(&controller4))) && controller4) {
+            controller4->put_AllowExternalDrop(enabled ? TRUE : FALSE);
+          }
+        }
+        if (!webview_) return;
+        std::wstring script = enabled
+            ? L"window.__wpp_dropzone_enabled = true;"
+            : L"window.__wpp_dropzone_enabled = false; document.querySelectorAll('.wpp-dropzone-active').forEach(function(el){ el.classList.remove('wpp-dropzone-active'); });";
+        webview_->ExecuteScript(script.c_str(), nullptr);
+    }
+
+private:
+  void respond_to_bridge(const std::string& id, const json& result, const json* error = nullptr) {
+    if (!webview_) {
+      return;
+    }
+
+    std::string script = "window.__response__(" + json(id).dump() + "," + result.dump();
+    if (error) {
+      script += "," + error->dump();
+    }
+    script += ");";
+    execute_script(script);
+  }
+
+  bool handle_file_drop_message(const std::string& msg) {
+    json payload;
+    try {
+      payload = json::parse(msg);
+    } catch (...) {
+      return false;
+    }
+
+    if (!payload.is_object()) {
+      return false;
+    }
+
+    const auto method_it = payload.find("method");
+    const auto id_it = payload.find("id");
+    if (method_it == payload.end() || id_it == payload.end() || !method_it->is_string() || !id_it->is_string()) {
+      return false;
+    }
+
+    const std::string method = method_it->get<std::string>();
+    const std::string id = id_it->get<std::string>();
+    if (method == "wpp.fileDrop.setEnabled") {
+      bool enabled = true;
+      const auto params_it = payload.find("params");
+      if (params_it != payload.end() && params_it->is_array() && !params_it->empty() && (*params_it)[0].is_boolean()) {
+        enabled = (*params_it)[0].get<bool>();
+      }
+      set_drag_drop_enabled(enabled);
+      respond_to_bridge(id, nullptr);
+      return true;
+    }
+
+    if (method == "wpp.fileDrop.isEnabled") {
+      respond_to_bridge(id, drag_drop_enabled_);
+      return true;
+    }
+
+    if (method == "wpp.fileDrop.startDrag") {
+      const json error = "wpp.fileDrop.startDrag is not implemented on Win32 yet";
+      respond_to_bridge(id, nullptr, &error);
+      return true;
+    }
+
+    return false;
+  }
+
+    WebViewConfig config_;
+    HWND parent_hwnd_;
+    ComPtr<ICoreWebView2Environment> env_;
+    ComPtr<ICoreWebView2Controller> controller_;
+    ComPtr<ICoreWebView2> webview_;
+    HWND webview_host_hwnd_ = nullptr;
+    bool drag_drop_enabled_ = true;
+};
+
+std::unique_ptr<WebView> create_webview(const WebViewConfig& config, void* native_handle) {
+    HWND hwnd = static_cast<HWND>(native_handle);
+    if (!hwnd || !IsWindow(hwnd)) {
+        return nullptr;
+    }
+    return std::make_unique<Win32WebView>(config, hwnd);
+}
+
+} // namespace wpp
+
+#endif // WIN32