plusui-native-core 0.1.104 → 0.1.106

package/Core/Features/Window/webview.cpp

@@ -1,13 +1,13 @@
-#include <fstream>
-#include <functional>
-#include <iostream>
-#include <map>
-#include <plusui/tray.hpp>
-#include <plusui/webgpu.hpp>
-#include <plusui/window.hpp>
-#include <regex>
-#include <sstream>
-
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <map>
+#include <plusui/tray.hpp>
+#include <plusui/webgpu.hpp>
+#include <plusui/window.hpp>
+#include <regex>
+#include <sstream>
+
 #ifdef _WIN32
 #pragma warning(push)
 #pragma warning(disable: 4996) // Disable sscanf deprecation warning
@@ -26,30 +26,30 @@ using namespace Microsoft::WRL;
 #include <gtk/gtk.h>
 #include <webkit2/webkit2.h>
 #endif
-
-namespace plusui {
-
-namespace {
-constexpr char kHideScrollbarsScript[] = R"(
-  (function() {
-    var css = "::-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 = "__plusui_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);
-  })();
-)";
+
+namespace plusui {
+
+namespace {
+constexpr char kHideScrollbarsScript[] = R"(
+  (function() {
+    var css = "::-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 = "__plusui_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);
+  })();
+)";
 // Build the JS snippet that dispatches a plusui:keyboard:keydown/keyup CustomEvent.
 // keyCode   — PlusUI KeyCode value
 // scancode  — raw scan/keycode from the platform
@@ -89,79 +89,79 @@ static std::string buildShortcutScript(const std::string& id) {
 
 // Note: Window::Impl is defined in window.cpp
 // This file only provides implementations for webview-specific methods
-
-Window Window::create(void *windowHandle, const WindowConfig &config) {
-  Window win;
-  win.pImpl->config = config;
-
-#ifdef _WIN32
-  HWND hwnd = static_cast<HWND>(windowHandle);
-
-  // Create WebView2 environment and controller
-  auto pImpl = win.pImpl;
-  CreateCoreWebView2EnvironmentWithOptions(
-      nullptr, nullptr, nullptr,
-      Callback<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>(
-          [hwnd, pImpl](HRESULT result,
-                        ICoreWebView2Environment *env) -> HRESULT {
-            if (FAILED(result) || !env)
-              return result;
-            env->CreateCoreWebView2Controller(
-                hwnd,
-                Callback<
-                    ICoreWebView2CreateCoreWebView2ControllerCompletedHandler>(
-                    [pImpl](HRESULT result,
-                            ICoreWebView2Controller *controller) -> HRESULT {
-                      (void)result; // Suppress unused warning
-                      if (controller != nullptr) {
-                        pImpl->controller = controller;
-                        controller->get_CoreWebView2(&pImpl->webview);
-
-                        RECT bounds;
-                        HWND parentHwnd;
-                        controller->get_ParentWindow(&parentHwnd);
-                        GetClientRect(parentHwnd, &bounds);
-                        controller->put_Bounds(bounds);
-
-                        pImpl->nativeWebView = pImpl->webview.Get();
-                        pImpl->ready = true;
-
-                        // Disable scrollbars at the control level if configured
-                        if (!pImpl->config.scrollbars) {
-                          ComPtr<ICoreWebView2Settings> settings;
-                          pImpl->webview->get_Settings(&settings);
-                          if (settings) {
-                            // Attempt to disable scrollbars if this API is available
-                            // Note: This may not be available in all WebView2 versions
-                            // The CSS injection below will serve as fallback
-                          }
-                        }
-
-                        // Inject bridge script that runs on EVERY document
-                        // (survives navigation)
-                        std::string bridgeScript = R"(
-                            window.__native_invoke__ = function(request) {
-                                if (window.chrome && window.chrome.webview) {
-                                    window.chrome.webview.postMessage(request);
-                                }
-                            };
-                        )";
-                        pImpl->webview->AddScriptToExecuteOnDocumentCreated(
-                            std::wstring(bridgeScript.begin(),
-                                         bridgeScript.end())
-                                .c_str(),
-                            nullptr);
-
-                        // Disable scrollbars if configured
-                        if (!pImpl->config.scrollbars) {
-                          std::string scrollbarScript = kHideScrollbarsScript;
-                          pImpl->webview->AddScriptToExecuteOnDocumentCreated(
-                              std::wstring(scrollbarScript.begin(),
-                                           scrollbarScript.end())
-                                  .c_str(),
-                              nullptr);
-                        }
-
+
+Window Window::create(void *windowHandle, const WindowConfig &config) {
+  Window win;
+  win.pImpl->config = config;
+
+#ifdef _WIN32
+  HWND hwnd = static_cast<HWND>(windowHandle);
+
+  // Create WebView2 environment and controller
+  auto pImpl = win.pImpl;
+  CreateCoreWebView2EnvironmentWithOptions(
+      nullptr, nullptr, nullptr,
+      Callback<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>(
+          [hwnd, pImpl](HRESULT result,
+                        ICoreWebView2Environment *env) -> HRESULT {
+            if (FAILED(result) || !env)
+              return result;
+            env->CreateCoreWebView2Controller(
+                hwnd,
+                Callback<
+                    ICoreWebView2CreateCoreWebView2ControllerCompletedHandler>(
+                    [pImpl](HRESULT result,
+                            ICoreWebView2Controller *controller) -> HRESULT {
+                      (void)result; // Suppress unused warning
+                      if (controller != nullptr) {
+                        pImpl->controller = controller;
+                        controller->get_CoreWebView2(&pImpl->webview);
+
+                        RECT bounds;
+                        HWND parentHwnd;
+                        controller->get_ParentWindow(&parentHwnd);
+                        GetClientRect(parentHwnd, &bounds);
+                        controller->put_Bounds(bounds);
+
+                        pImpl->nativeWebView = pImpl->webview.Get();
+                        pImpl->ready = true;
+
+                        // Disable scrollbars at the control level if configured
+                        if (!pImpl->config.scrollbars) {
+                          ComPtr<ICoreWebView2Settings> settings;
+                          pImpl->webview->get_Settings(&settings);
+                          if (settings) {
+                            // Attempt to disable scrollbars if this API is available
+                            // Note: This may not be available in all WebView2 versions
+                            // The CSS injection below will serve as fallback
+                          }
+                        }
+
+                        // Inject bridge script that runs on EVERY document
+                        // (survives navigation)
+                        std::string bridgeScript = R"(
+                            window.__native_invoke__ = function(request) {
+                                if (window.chrome && window.chrome.webview) {
+                                    window.chrome.webview.postMessage(request);
+                                }
+                            };
+                        )";
+                        pImpl->webview->AddScriptToExecuteOnDocumentCreated(
+                            std::wstring(bridgeScript.begin(),
+                                         bridgeScript.end())
+                                .c_str(),
+                            nullptr);
+
+                        // Disable scrollbars if configured
+                        if (!pImpl->config.scrollbars) {
+                          std::string scrollbarScript = kHideScrollbarsScript;
+                          pImpl->webview->AddScriptToExecuteOnDocumentCreated(
+                              std::wstring(scrollbarScript.begin(),
+                                           scrollbarScript.end())
+                                  .c_str(),
+                              nullptr);
+                        }
+
                         // Block browser default drag-drop behavior (prevents
                         // the browser from navigating to the dropped file)
                         // while still showing visual feedback on drop zones.
@@ -174,6 +174,7 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                               window.__plusui_dropzone_init = true;
 
                               var activeZone = null;
+                              var dragDepth = 0;
 
                               var findDropZone = function(e) {
                                 var target = null;
@@ -187,13 +188,20 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
 
                               var updateActiveZone = function(zone) {
                                 if (activeZone === zone) return;
-                                if (activeZone) activeZone.classList.remove('dropzone-active');
+                                if (activeZone) {
+                                  activeZone.classList.remove('dropzone-active');
+                                  activeZone.classList.remove('filedrop-active');
+                                }
                                 activeZone = zone;
-                                if (activeZone) activeZone.classList.add('dropzone-active');
+                                if (activeZone) {
+                                  activeZone.classList.add('dropzone-active');
+                                  activeZone.classList.add('filedrop-active');
+                                }
                               };
 
                               document.addEventListener('dragenter', function(e) {
                                 e.preventDefault();
+                                dragDepth++;
                                 var zone = findDropZone(e);
                                 updateActiveZone(zone);
                                 if (e.dataTransfer) {
@@ -212,16 +220,20 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
 
                               document.addEventListener('dragleave', function(e) {
                                 e.preventDefault();
-                                var zone = findDropZone(e);
-                                // Only remove if actually leaving the zone (relatedTarget is outside)
-                                if (e.relatedTarget && zone && !zone.contains(e.relatedTarget)) {
+                                dragDepth--;
+                                if (dragDepth <= 0) {
+                                  dragDepth = 0;
                                   updateActiveZone(null);
+                                } else {
+                                  var zone = findDropZone(e);
+                                  updateActiveZone(zone);
                                 }
                               }, true);
 
                               document.addEventListener('drop', function(e) {
                                 e.preventDefault();
                                 updateActiveZone(null);
+                                dragDepth = 0;
                               }, true);
 
                               window.addEventListener('dragover', function(e) { e.preventDefault(); }, true);
@@ -234,314 +246,314 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                   .c_str(),
                               nullptr);
                         }
-
-                        // Set up WebMessageReceived handler for JS->C++ bridge
-                        pImpl->webview->add_WebMessageReceived(
-                            Callback<
-                                ICoreWebView2WebMessageReceivedEventHandler>(
-                                [pImpl](ICoreWebView2 *sender,
-                                        ICoreWebView2WebMessageReceivedEventArgs
-                                            *args) -> HRESULT {
-                                  (void)sender; // Suppress unused warning
-                                  LPWSTR message = nullptr;
-                                  args->TryGetWebMessageAsString(&message);
-                                  if (!message)
-                                    return S_OK;
-                                  std::wstring wmsg(message);
-                                  #pragma warning(push)
-                                  #pragma warning(disable: 4244) // Suppress wchar_t to char conversion warning
-                                  std::string msg(wmsg.begin(), wmsg.end());
-                                  #pragma warning(pop)
-                                  CoTaskMemFree(message);
-
-                                  // Debug: log received message
-                                  std::cout << "[PlusUI] Received: " << msg
-                                            << std::endl;
-
-                                  // Parse JSON-RPC: {"id":"...",
-                                  // "method":"window.minimize", "params":[...]}
-                                  std::string id, method;
-                                  std::string result = "null";
-                                  bool success = false;
-
-                                  // Simple JSON parsing
-                                  auto getId = [&msg]() {
-                                    size_t pos = msg.find("\"id\"");
-                                    if (pos == std::string::npos)
-                                      return std::string();
-                                    pos = msg.find(":", pos);
-                                    if (pos == std::string::npos)
-                                      return std::string();
-                                    size_t start = msg.find("\"", pos);
-                                    if (start == std::string::npos)
-                                      return std::string();
-                                    size_t end = msg.find("\"", start + 1);
-                                    if (end == std::string::npos)
-                                      return std::string();
-                                    return msg.substr(start + 1,
-                                                      end - start - 1);
-                                  };
-                                  auto getMethod = [&msg]() {
-                                    size_t pos = msg.find("\"method\"");
-                                    if (pos == std::string::npos)
-                                      return std::string();
-                                    pos = msg.find(":", pos);
-                                    if (pos == std::string::npos)
-                                      return std::string();
-                                    size_t start = msg.find("\"", pos);
-                                    if (start == std::string::npos)
-                                      return std::string();
-                                    size_t end = msg.find("\"", start + 1);
-                                    if (end == std::string::npos)
-                                      return std::string();
-                                    return msg.substr(start + 1,
-                                                      end - start - 1);
-                                  };
-
-                                  id = getId();
-                                  method = getMethod();
-
-                                  // Route to handlers
-                                  if (method.find("window.") == 0) {
-                                    std::string winMethod = method.substr(7);
-                                    if (winMethod == "minimize") {
-                                      if (pImpl->window) pImpl->window->minimize();
-                                      success = true;
-                                    } else if (winMethod == "maximize") {
-                                      if (pImpl->window) pImpl->window->maximize();
-                                      success = true;
-                                    } else if (winMethod == "restore") {
-                                      if (pImpl->window) pImpl->window->restore();
-                                      success = true;
-                                    } else if (winMethod == "close") {
-                                      if (pImpl->window) pImpl->window->close();
-                                      success = true;
-                                    } else if (winMethod == "show") {
-                                      if (pImpl->window) pImpl->window->show();
-                                      success = true;
-                                    } else if (winMethod == "hide") {
-                                      if (pImpl->window) pImpl->window->hide();
-                                      success = true;
-                                    } else if (winMethod == "getSize") {
-                                      if (pImpl->window) {
-                                        int w, h;
-                                        pImpl->window->getSize(w, h);
-                                        result = "{\"width\":" +
-                                                 std::to_string(w) +
-                                                 ",\"height\":" +
-                                                 std::to_string(h) +
-                                                 "}";
-                                      }
-                                      success = true;
-                                    } else if (winMethod == "getPosition") {
-                                      if (pImpl->window) {
-                                        int x, y;
-                                        pImpl->window->getPosition(x, y);
-                                        result =
-                                            "{\"x\":" + std::to_string(x) +
-                                            ",\"y\":" + std::to_string(y) +
-                                            "}";
-                                      }
-                                      success = true;
-                                    } else if (winMethod == "setSize") {
-                                      // Parse params [width, height]
-                                      size_t p1 = msg.find("[");
-                                      size_t p2 = msg.find("]");
-                                      if (p1 != std::string::npos &&
-                                          p2 != std::string::npos) {
-                                        std::string params =
-                                            msg.substr(p1 + 1, p2 - p1 - 1);
-                                        int w = 0, h = 0;
-                                        sscanf(params.c_str(), "%d, %d", &w,
-                                               &h);
-                                        if (pImpl->window) pImpl->window->setSize(w, h);
-                                      }
-                                      success = true;
-                                    } else if (winMethod == "setPosition") {
-                                      size_t p1 = msg.find("[");
-                                      size_t p2 = msg.find("]");
-                                      if (p1 != std::string::npos &&
-                                          p2 != std::string::npos) {
-                                        std::string params =
-                                            msg.substr(p1 + 1, p2 - p1 - 1);
-                                        int x = 0, y = 0;
-                                        sscanf(params.c_str(), "%d, %d", &x,
-                                               &y);
-                                        if (pImpl->window) pImpl->window->setPosition(x, y);
-                                      }
-                                      success = true;
-                                    } else if (winMethod == "setTitle") {
-                                      size_t p1 = msg.find("[\"");
-                                      size_t p2 = msg.find("\"]");
-                                      if (p1 != std::string::npos &&
-                                          p2 != std::string::npos) {
-                                        std::string title =
-                                            msg.substr(p1 + 2, p2 - p1 - 2);
-                                        if (pImpl->window) pImpl->window->setTitle(title);
-                                      }
-                                      success = true;
-                                    } else if (winMethod == "setFullscreen") {
-                                      size_t p1 = msg.find("[");
-                                      size_t p2 = msg.find("]");
-                                      if (p1 != std::string::npos &&
-                                          p2 != std::string::npos) {
-                                        std::string params =
-                                            msg.substr(p1 + 1, p2 - p1 - 1);
-                                        if (pImpl->window) pImpl->window->setFullscreen(
-                                            params.find("true") !=
-                                            std::string::npos);
-                                      }
-                                      success = true;
-                                    } else if (winMethod == "setAlwaysOnTop") {
-                                      size_t p1 = msg.find("[");
-                                      size_t p2 = msg.find("]");
-                                      if (p1 != std::string::npos &&
-                                          p2 != std::string::npos) {
-                                        std::string params =
-                                            msg.substr(p1 + 1, p2 - p1 - 1);
-                                        if (pImpl->window) pImpl->window->setAlwaysOnTop(
-                                            params.find("true") !=
-                                            std::string::npos);
-                                      }
-                                      success = true;
-                                    } else if (winMethod == "setResizable") {
-                                      size_t p1 = msg.find("[");
-                                      size_t p2 = msg.find("]");
-                                      if (p1 != std::string::npos &&
-                                          p2 != std::string::npos) {
-                                        std::string params =
-                                            msg.substr(p1 + 1, p2 - p1 - 1);
-                                        if (pImpl->window) pImpl->window->setResizable(
-                                            params.find("true") !=
-                                            std::string::npos);
-                                      }
-                                      success = true;
-                                    } else if (winMethod == "isMaximized") {
-                                      result =
-                                          (pImpl->window && pImpl->window->isMaximized())
-                                              ? "true"
-                                              : "false";
-                                      success = true;
-                                    } else if (winMethod == "isMinimized") {
-                                      result =
-                                          (pImpl->window && pImpl->window->isMinimized())
-                                              ? "true"
-                                              : "false";
-                                      success = true;
-                                    } else if (winMethod == "isVisible") {
-                                      result = (pImpl->window && pImpl->window->isVisible())
-                                                   ? "true"
-                                                   : "false";
-                                      success = true;
-                                    } else if (winMethod == "center") {
-                                      if (pImpl->window) pImpl->window->center();
-                                      success = true;
-                                    }
-                                  } else if (method.find("tray.") == 0) {
-                                    std::string trayMethod = method.substr(5);
-                                    if (trayMethod == "setIcon") {
-                                      // TODO: implement
-                                      success = true;
-                                    } else if (trayMethod == "setTooltip") {
-                                      // TODO: implement
-                                      success = true;
-                                    } else if (trayMethod == "setVisible") {
-                                      // TODO: implement
-                                      success = true;
-                                    }
-                                  } else if (method.find("browser.") == 0) {
-                                    std::string browserMethod =
-                                        method.substr(8);
-                                    if (browserMethod == "navigate") {
-                                      size_t p1 = msg.find("[\"");
-                                      size_t p2 = msg.find("\"]");
-                                      if (p1 != std::string::npos &&
-                                          p2 != std::string::npos) {
-                                        std::string url =
-                                            msg.substr(p1 + 2, p2 - p1 - 2);
-                                        pImpl->webview->Navigate(
-                                            std::wstring(url.begin(), url.end())
-                                                .c_str());
-                                      }
-                                      success = true;
-                                    } else if (browserMethod == "goBack") {
-                                      pImpl->webview->GoBack();
-                                      success = true;
-                                    } else if (browserMethod == "goForward") {
-                                      pImpl->webview->GoForward();
-                                      success = true;
-                                    } else if (browserMethod == "reload") {
-                                      pImpl->webview->Reload();
-                                      success = true;
-                                    } else if (browserMethod == "stop") {
-                                      pImpl->webview->Stop();
-                                      success = true;
-                                    } else if (browserMethod == "getUrl") {
-                                      result = "\"" + pImpl->currentURL + "\"";
-                                      success = true;
-                                    } else if (browserMethod == "getTitle") {
-                                      result =
-                                          "\"" + pImpl->currentTitle + "\"";
-                                      success = true;
-                                    } else if (browserMethod == "canGoBack") {
-                                      BOOL canBack;
-                                      pImpl->webview->get_CanGoBack(&canBack);
-                                      result = canBack ? "true" : "false";
-                                      success = true;
-                                    } else if (browserMethod ==
-                                               "canGoForward") {
-                                      BOOL canForward;
-                                      pImpl->webview->get_CanGoForward(
-                                          &canForward);
-                                      result = canForward ? "true" : "false";
-                                      success = true;
-                                    }
-                                  } else if (method.find("app.") == 0) {
-                                    std::string appMethod = method.substr(4);
-                                    if (appMethod == "quit") {
-                                      if (pImpl->window) pImpl->window->close();
-                                      PostQuitMessage(0);
-                                      success = true;
-                                    }
-                                  } else if (method.find("display.") == 0) {
-                                    std::string displayMethod =
-                                        method.substr(8);
-                                    if (displayMethod == "getAll") {
-                                      result =
-                                          "[{\"id\":1,\"name\":\"Primary\","
-                                          "\"x\":0,\"y\":0,\"width\":1920,"
-                                          "\"height\":1080,\"scale\":1,"
-                                          "\"isPrimary\":true}]";
-                                      success = true;
-                                    } else if (displayMethod == "getPrimary") {
-                                      result = "{\"id\":1,\"name\":\"Primary\","
-                                               "\"x\":0,\"y\":0,\"width\":1920,"
-                                               "\"height\":1080,\"scale\":1,"
-                                               "\"isPrimary\":true}";
-                                      success = true;
-                                    } else if (displayMethod == "getCurrent") {
-                                      result = "{\"id\":1,\"name\":\"Primary\","
-                                               "\"x\":0,\"y\":0,\"width\":1920,"
-                                               "\"height\":1080,\"scale\":1,"
-                                               "\"isPrimary\":true}";
-                                      success = true;
-                                    }
-                                  } else if (method.find("clipboard.") == 0) {
-                                    std::string clipMethod = method.substr(10);
-                                    if (clipMethod == "writeText") {
-                                      size_t p1 = msg.find("[\"");
-                                      size_t p2 = msg.find("\"]");
-                                      if (p1 != std::string::npos &&
-                                          p2 != std::string::npos) {
-                                        // TODO: implement clipboard write
-                                      }
-                                      success = true;
-                                    } else if (clipMethod == "readText") {
-                                      result = "\"\"";
-                                      success = true;
-                                    } else if (clipMethod == "clear") {
-                                      success = true;
-                                    }
+
+                        // Set up WebMessageReceived handler for JS->C++ bridge
+                        pImpl->webview->add_WebMessageReceived(
+                            Callback<
+                                ICoreWebView2WebMessageReceivedEventHandler>(
+                                [pImpl](ICoreWebView2 *sender,
+                                        ICoreWebView2WebMessageReceivedEventArgs
+                                            *args) -> HRESULT {
+                                  (void)sender; // Suppress unused warning
+                                  LPWSTR message = nullptr;
+                                  args->TryGetWebMessageAsString(&message);
+                                  if (!message)
+                                    return S_OK;
+                                  std::wstring wmsg(message);
+                                  #pragma warning(push)
+                                  #pragma warning(disable: 4244) // Suppress wchar_t to char conversion warning
+                                  std::string msg(wmsg.begin(), wmsg.end());
+                                  #pragma warning(pop)
+                                  CoTaskMemFree(message);
+
+                                  // Debug: log received message
+                                  std::cout << "[PlusUI] Received: " << msg
+                                            << std::endl;
+
+                                  // Parse JSON-RPC: {"id":"...",
+                                  // "method":"window.minimize", "params":[...]}
+                                  std::string id, method;
+                                  std::string result = "null";
+                                  bool success = false;
+
+                                  // Simple JSON parsing
+                                  auto getId = [&msg]() {
+                                    size_t pos = msg.find("\"id\"");
+                                    if (pos == std::string::npos)
+                                      return std::string();
+                                    pos = msg.find(":", pos);
+                                    if (pos == std::string::npos)
+                                      return std::string();
+                                    size_t start = msg.find("\"", pos);
+                                    if (start == std::string::npos)
+                                      return std::string();
+                                    size_t end = msg.find("\"", start + 1);
+                                    if (end == std::string::npos)
+                                      return std::string();
+                                    return msg.substr(start + 1,
+                                                      end - start - 1);
+                                  };
+                                  auto getMethod = [&msg]() {
+                                    size_t pos = msg.find("\"method\"");
+                                    if (pos == std::string::npos)
+                                      return std::string();
+                                    pos = msg.find(":", pos);
+                                    if (pos == std::string::npos)
+                                      return std::string();
+                                    size_t start = msg.find("\"", pos);
+                                    if (start == std::string::npos)
+                                      return std::string();
+                                    size_t end = msg.find("\"", start + 1);
+                                    if (end == std::string::npos)
+                                      return std::string();
+                                    return msg.substr(start + 1,
+                                                      end - start - 1);
+                                  };
+
+                                  id = getId();
+                                  method = getMethod();
+
+                                  // Route to handlers
+                                  if (method.find("window.") == 0) {
+                                    std::string winMethod = method.substr(7);
+                                    if (winMethod == "minimize") {
+                                      if (pImpl->window) pImpl->window->minimize();
+                                      success = true;
+                                    } else if (winMethod == "maximize") {
+                                      if (pImpl->window) pImpl->window->maximize();
+                                      success = true;
+                                    } else if (winMethod == "restore") {
+                                      if (pImpl->window) pImpl->window->restore();
+                                      success = true;
+                                    } else if (winMethod == "close") {
+                                      if (pImpl->window) pImpl->window->close();
+                                      success = true;
+                                    } else if (winMethod == "show") {
+                                      if (pImpl->window) pImpl->window->show();
+                                      success = true;
+                                    } else if (winMethod == "hide") {
+                                      if (pImpl->window) pImpl->window->hide();
+                                      success = true;
+                                    } else if (winMethod == "getSize") {
+                                      if (pImpl->window) {
+                                        int w, h;
+                                        pImpl->window->getSize(w, h);
+                                        result = "{\"width\":" +
+                                                 std::to_string(w) +
+                                                 ",\"height\":" +
+                                                 std::to_string(h) +
+                                                 "}";
+                                      }
+                                      success = true;
+                                    } else if (winMethod == "getPosition") {
+                                      if (pImpl->window) {
+                                        int x, y;
+                                        pImpl->window->getPosition(x, y);
+                                        result =
+                                            "{\"x\":" + std::to_string(x) +
+                                            ",\"y\":" + std::to_string(y) +
+                                            "}";
+                                      }
+                                      success = true;
+                                    } else if (winMethod == "setSize") {
+                                      // Parse params [width, height]
+                                      size_t p1 = msg.find("[");
+                                      size_t p2 = msg.find("]");
+                                      if (p1 != std::string::npos &&
+                                          p2 != std::string::npos) {
+                                        std::string params =
+                                            msg.substr(p1 + 1, p2 - p1 - 1);
+                                        int w = 0, h = 0;
+                                        sscanf(params.c_str(), "%d, %d", &w,
+                                               &h);
+                                        if (pImpl->window) pImpl->window->setSize(w, h);
+                                      }
+                                      success = true;
+                                    } else if (winMethod == "setPosition") {
+                                      size_t p1 = msg.find("[");
+                                      size_t p2 = msg.find("]");
+                                      if (p1 != std::string::npos &&
+                                          p2 != std::string::npos) {
+                                        std::string params =
+                                            msg.substr(p1 + 1, p2 - p1 - 1);
+                                        int x = 0, y = 0;
+                                        sscanf(params.c_str(), "%d, %d", &x,
+                                               &y);
+                                        if (pImpl->window) pImpl->window->setPosition(x, y);
+                                      }
+                                      success = true;
+                                    } else if (winMethod == "setTitle") {
+                                      size_t p1 = msg.find("[\"");
+                                      size_t p2 = msg.find("\"]");
+                                      if (p1 != std::string::npos &&
+                                          p2 != std::string::npos) {
+                                        std::string title =
+                                            msg.substr(p1 + 2, p2 - p1 - 2);
+                                        if (pImpl->window) pImpl->window->setTitle(title);
+                                      }
+                                      success = true;
+                                    } else if (winMethod == "setFullscreen") {
+                                      size_t p1 = msg.find("[");
+                                      size_t p2 = msg.find("]");
+                                      if (p1 != std::string::npos &&
+                                          p2 != std::string::npos) {
+                                        std::string params =
+                                            msg.substr(p1 + 1, p2 - p1 - 1);
+                                        if (pImpl->window) pImpl->window->setFullscreen(
+                                            params.find("true") !=
+                                            std::string::npos);
+                                      }
+                                      success = true;
+                                    } else if (winMethod == "setAlwaysOnTop") {
+                                      size_t p1 = msg.find("[");
+                                      size_t p2 = msg.find("]");
+                                      if (p1 != std::string::npos &&
+                                          p2 != std::string::npos) {
+                                        std::string params =
+                                            msg.substr(p1 + 1, p2 - p1 - 1);
+                                        if (pImpl->window) pImpl->window->setAlwaysOnTop(
+                                            params.find("true") !=
+                                            std::string::npos);
+                                      }
+                                      success = true;
+                                    } else if (winMethod == "setResizable") {
+                                      size_t p1 = msg.find("[");
+                                      size_t p2 = msg.find("]");
+                                      if (p1 != std::string::npos &&
+                                          p2 != std::string::npos) {
+                                        std::string params =
+                                            msg.substr(p1 + 1, p2 - p1 - 1);
+                                        if (pImpl->window) pImpl->window->setResizable(
+                                            params.find("true") !=
+                                            std::string::npos);
+                                      }
+                                      success = true;
+                                    } else if (winMethod == "isMaximized") {
+                                      result =
+                                          (pImpl->window && pImpl->window->isMaximized())
+                                              ? "true"
+                                              : "false";
+                                      success = true;
+                                    } else if (winMethod == "isMinimized") {
+                                      result =
+                                          (pImpl->window && pImpl->window->isMinimized())
+                                              ? "true"
+                                              : "false";
+                                      success = true;
+                                    } else if (winMethod == "isVisible") {
+                                      result = (pImpl->window && pImpl->window->isVisible())
+                                                   ? "true"
+                                                   : "false";
+                                      success = true;
+                                    } else if (winMethod == "center") {
+                                      if (pImpl->window) pImpl->window->center();
+                                      success = true;
+                                    }
+                                  } else if (method.find("tray.") == 0) {
+                                    std::string trayMethod = method.substr(5);
+                                    if (trayMethod == "setIcon") {
+                                      // TODO: implement
+                                      success = true;
+                                    } else if (trayMethod == "setTooltip") {
+                                      // TODO: implement
+                                      success = true;
+                                    } else if (trayMethod == "setVisible") {
+                                      // TODO: implement
+                                      success = true;
+                                    }
+                                  } else if (method.find("browser.") == 0) {
+                                    std::string browserMethod =
+                                        method.substr(8);
+                                    if (browserMethod == "navigate") {
+                                      size_t p1 = msg.find("[\"");
+                                      size_t p2 = msg.find("\"]");
+                                      if (p1 != std::string::npos &&
+                                          p2 != std::string::npos) {
+                                        std::string url =
+                                            msg.substr(p1 + 2, p2 - p1 - 2);
+                                        pImpl->webview->Navigate(
+                                            std::wstring(url.begin(), url.end())
+                                                .c_str());
+                                      }
+                                      success = true;
+                                    } else if (browserMethod == "goBack") {
+                                      pImpl->webview->GoBack();
+                                      success = true;
+                                    } else if (browserMethod == "goForward") {
+                                      pImpl->webview->GoForward();
+                                      success = true;
+                                    } else if (browserMethod == "reload") {
+                                      pImpl->webview->Reload();
+                                      success = true;
+                                    } else if (browserMethod == "stop") {
+                                      pImpl->webview->Stop();
+                                      success = true;
+                                    } else if (browserMethod == "getUrl") {
+                                      result = "\"" + pImpl->currentURL + "\"";
+                                      success = true;
+                                    } else if (browserMethod == "getTitle") {
+                                      result =
+                                          "\"" + pImpl->currentTitle + "\"";
+                                      success = true;
+                                    } else if (browserMethod == "canGoBack") {
+                                      BOOL canBack;
+                                      pImpl->webview->get_CanGoBack(&canBack);
+                                      result = canBack ? "true" : "false";
+                                      success = true;
+                                    } else if (browserMethod ==
+                                               "canGoForward") {
+                                      BOOL canForward;
+                                      pImpl->webview->get_CanGoForward(
+                                          &canForward);
+                                      result = canForward ? "true" : "false";
+                                      success = true;
+                                    }
+                                  } else if (method.find("app.") == 0) {
+                                    std::string appMethod = method.substr(4);
+                                    if (appMethod == "quit") {
+                                      if (pImpl->window) pImpl->window->close();
+                                      PostQuitMessage(0);
+                                      success = true;
+                                    }
+                                  } else if (method.find("display.") == 0) {
+                                    std::string displayMethod =
+                                        method.substr(8);
+                                    if (displayMethod == "getAll") {
+                                      result =
+                                          "[{\"id\":1,\"name\":\"Primary\","
+                                          "\"x\":0,\"y\":0,\"width\":1920,"
+                                          "\"height\":1080,\"scale\":1,"
+                                          "\"isPrimary\":true}]";
+                                      success = true;
+                                    } else if (displayMethod == "getPrimary") {
+                                      result = "{\"id\":1,\"name\":\"Primary\","
+                                               "\"x\":0,\"y\":0,\"width\":1920,"
+                                               "\"height\":1080,\"scale\":1,"
+                                               "\"isPrimary\":true}";
+                                      success = true;
+                                    } else if (displayMethod == "getCurrent") {
+                                      result = "{\"id\":1,\"name\":\"Primary\","
+                                               "\"x\":0,\"y\":0,\"width\":1920,"
+                                               "\"height\":1080,\"scale\":1,"
+                                               "\"isPrimary\":true}";
+                                      success = true;
+                                    }
+                                  } else if (method.find("clipboard.") == 0) {
+                                    std::string clipMethod = method.substr(10);
+                                    if (clipMethod == "writeText") {
+                                      size_t p1 = msg.find("[\"");
+                                      size_t p2 = msg.find("\"]");
+                                      if (p1 != std::string::npos &&
+                                          p2 != std::string::npos) {
+                                        // TODO: implement clipboard write
+                                      }
+                                      success = true;
+                                    } else if (clipMethod == "readText") {
+                                      result = "\"\"";
+                                      success = true;
+                                    } else if (clipMethod == "clear") {
+                                      success = true;
+                                    }
                                    } else if (method.find("keyboard.") == 0) {
                                      // Keyboard API routing
                                      std::string kbMethod = method.substr(9);
@@ -634,38 +646,38 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                                     "method: "
                                                  << kbMethod << std::endl;
                                      }
-                                  } else if (method.find("menu.") == 0) {
-                                    // Menu API routing
-                                    std::string menuMethod = method.substr(5);
-                                    if (menuMethod == "create") {
-                                      // TODO: integrate with
-                                      // MenuBindings/ContextMenuManager
-                                      result = "\"menu_" + id + "\"";
-                                      success = true;
-                                    } else if (menuMethod == "popup") {
-                                      success = true;
-                                    } else if (menuMethod == "popupAtCursor") {
-                                      success = true;
-                                    } else if (menuMethod == "close") {
-                                      success = true;
-                                    } else if (menuMethod == "destroy") {
-                                      success = true;
-                                    } else if (menuMethod ==
-                                               "setApplicationMenu") {
-                                      // TODO: integrate with MenuBar
-                                      success = true;
-                                    } else if (menuMethod ==
-                                               "getApplicationMenu") {
-                                      result = "[]";
-                                      success = true;
-                                    } else if (menuMethod ==
-                                               "appendToMenuBar") {
-                                      success = true;
-                                    } else {
-                                      std::cout
-                                          << "[PlusUI] Unknown menu method: "
-                                          << menuMethod << std::endl;
-                                    }
+                                  } else if (method.find("menu.") == 0) {
+                                    // Menu API routing
+                                    std::string menuMethod = method.substr(5);
+                                    if (menuMethod == "create") {
+                                      // TODO: integrate with
+                                      // MenuBindings/ContextMenuManager
+                                      result = "\"menu_" + id + "\"";
+                                      success = true;
+                                    } else if (menuMethod == "popup") {
+                                      success = true;
+                                    } else if (menuMethod == "popupAtCursor") {
+                                      success = true;
+                                    } else if (menuMethod == "close") {
+                                      success = true;
+                                    } else if (menuMethod == "destroy") {
+                                      success = true;
+                                    } else if (menuMethod ==
+                                               "setApplicationMenu") {
+                                      // TODO: integrate with MenuBar
+                                      success = true;
+                                    } else if (menuMethod ==
+                                               "getApplicationMenu") {
+                                      result = "[]";
+                                      success = true;
+                                    } else if (menuMethod ==
+                                               "appendToMenuBar") {
+                                      success = true;
+                                    } else {
+                                      std::cout
+                                          << "[PlusUI] Unknown menu method: "
+                                          << menuMethod << std::endl;
+                                    }
                                   } else if (method.find("webview.") == 0) {
                                     // WebView API routing
                                     std::string webviewMethod = method.substr(8);
@@ -690,122 +702,122 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                       }
                                       success = true;
                                     }
-                                  } else if (method.find("webgpu.") == 0) {
-                                    // WebGPU API routing
-                                    std::string webgpuMethod = method.substr(
-                                        7); // Remove "webgpu." prefix
-
-                                    if (webgpuMethod == "requestAdapter") {
-                                      result = pImpl->webgpu.requestAdapter(
-                                          msg.substr(msg.find("["),
-                                                     msg.rfind("]") -
-                                                         msg.find("[") + 1));
-                                      success = true;
-                                    } else if (webgpuMethod ==
-                                               "requestDevice") {
-                                      // Extract adapterId and descriptor from
-                                      // params
-                                      size_t p1 = msg.find("[");
-                                      size_t p2 = msg.find("]");
-                                      if (p1 != std::string::npos &&
-                                          p2 != std::string::npos) {
-                                        std::string params =
-                                            msg.substr(p1 + 1, p2 - p1 - 1);
-                                        // TODO: Parse adapterId and descriptor
-                                        // properly
-                                      }
-                                      success = true;
-                                    } else if (webgpuMethod == "createBuffer") {
-                                      success = true;
-                                    } else if (webgpuMethod ==
-                                               "createTexture") {
-                                      success = true;
-                                    } else if (webgpuMethod ==
-                                               "createShaderModule") {
-                                      success = true;
-                                    } else if (webgpuMethod ==
-                                               "createRenderPipeline") {
-                                      success = true;
-                                    } else if (webgpuMethod ==
-                                               "createCommandEncoder") {
-                                      success = true;
-                                    } else if (webgpuMethod ==
-                                               "submitCommands") {
-                                      success = true;
-                                    } else {
-                                      // Unknown WebGPU method
-                                      std::cout
-                                          << "[PlusUI] Unknown WebGPU method: "
-                                          << webgpuMethod << std::endl;
-                                    }
-                                  }
-
-                                  // Send response back to JS (matches
-                                  // plusui-native-core SDK bridge)
-                                  std::string response =
-                                      "window.__response__(\"" + id + "\", " +
-                                      result + ");";
-                                  pImpl->webview->ExecuteScript(
-                                      std::wstring(response.begin(),
-                                                   response.end())
-                                          .c_str(),
-                                      nullptr);
-
-                                  return S_OK;
-                                })
-                                .Get(),
-                            nullptr);
-
-                        // Process pending scripts
-                        for (const auto &script : pImpl->pendingScripts) {
-                          pImpl->webview->ExecuteScript(
-                              std::wstring(script.begin(), script.end())
-                                  .c_str(),
-                              nullptr);
-                        }
-                        pImpl->pendingScripts.clear();
-
-                        // Process pending navigation
-                        if (!pImpl->pendingNavigation.empty()) {
-                          pImpl->webview->Navigate(
-                              std::wstring(pImpl->pendingNavigation.begin(),
-                                           pImpl->pendingNavigation.end())
-                                  .c_str());
-                          pImpl->pendingNavigation.clear();
-                        }
-
-                        // Process pending HTML
-                        if (!pImpl->pendingHTML.empty()) {
-                          pImpl->webview->NavigateToString(
-                              std::wstring(pImpl->pendingHTML.begin(),
-                                           pImpl->pendingHTML.end())
-                                  .c_str());
-                          pImpl->pendingHTML.clear();
-                        }
-
-                        // Process pending File
-                        if (!pImpl->pendingFile.empty()) {
-                          // For now, loadFile is implemented via navigate in
-                          // some versions or direct file reading. We'll handle
-                          // it via navigate for simplicity if it's already
-                          // implemented that way.
-                        }
-                      }
-                      return S_OK;
-                    })
-                    .Get());
-            return S_OK;
-          })
-          .Get());
-
-#elif defined(__APPLE__)
-  WKWebViewConfiguration *config = [[WKWebViewConfiguration alloc] init];
-  config.preferences.javaScriptEnabled = YES;
-
-  if (win.pImpl->config.devtools) {
-    [config.preferences setValue:@YES forKey:@"developerExtrasEnabled"];
-  }
-
+                                  } else if (method.find("webgpu.") == 0) {
+                                    // WebGPU API routing
+                                    std::string webgpuMethod = method.substr(
+                                        7); // Remove "webgpu." prefix
+
+                                    if (webgpuMethod == "requestAdapter") {
+                                      result = pImpl->webgpu.requestAdapter(
+                                          msg.substr(msg.find("["),
+                                                     msg.rfind("]") -
+                                                         msg.find("[") + 1));
+                                      success = true;
+                                    } else if (webgpuMethod ==
+                                               "requestDevice") {
+                                      // Extract adapterId and descriptor from
+                                      // params
+                                      size_t p1 = msg.find("[");
+                                      size_t p2 = msg.find("]");
+                                      if (p1 != std::string::npos &&
+                                          p2 != std::string::npos) {
+                                        std::string params =
+                                            msg.substr(p1 + 1, p2 - p1 - 1);
+                                        // TODO: Parse adapterId and descriptor
+                                        // properly
+                                      }
+                                      success = true;
+                                    } else if (webgpuMethod == "createBuffer") {
+                                      success = true;
+                                    } else if (webgpuMethod ==
+                                               "createTexture") {
+                                      success = true;
+                                    } else if (webgpuMethod ==
+                                               "createShaderModule") {
+                                      success = true;
+                                    } else if (webgpuMethod ==
+                                               "createRenderPipeline") {
+                                      success = true;
+                                    } else if (webgpuMethod ==
+                                               "createCommandEncoder") {
+                                      success = true;
+                                    } else if (webgpuMethod ==
+                                               "submitCommands") {
+                                      success = true;
+                                    } else {
+                                      // Unknown WebGPU method
+                                      std::cout
+                                          << "[PlusUI] Unknown WebGPU method: "
+                                          << webgpuMethod << std::endl;
+                                    }
+                                  }
+
+                                  // Send response back to JS (matches
+                                  // plusui-native-core SDK bridge)
+                                  std::string response =
+                                      "window.__response__(\"" + id + "\", " +
+                                      result + ");";
+                                  pImpl->webview->ExecuteScript(
+                                      std::wstring(response.begin(),
+                                                   response.end())
+                                          .c_str(),
+                                      nullptr);
+
+                                  return S_OK;
+                                })
+                                .Get(),
+                            nullptr);
+
+                        // Process pending scripts
+                        for (const auto &script : pImpl->pendingScripts) {
+                          pImpl->webview->ExecuteScript(
+                              std::wstring(script.begin(), script.end())
+                                  .c_str(),
+                              nullptr);
+                        }
+                        pImpl->pendingScripts.clear();
+
+                        // Process pending navigation
+                        if (!pImpl->pendingNavigation.empty()) {
+                          pImpl->webview->Navigate(
+                              std::wstring(pImpl->pendingNavigation.begin(),
+                                           pImpl->pendingNavigation.end())
+                                  .c_str());
+                          pImpl->pendingNavigation.clear();
+                        }
+
+                        // Process pending HTML
+                        if (!pImpl->pendingHTML.empty()) {
+                          pImpl->webview->NavigateToString(
+                              std::wstring(pImpl->pendingHTML.begin(),
+                                           pImpl->pendingHTML.end())
+                                  .c_str());
+                          pImpl->pendingHTML.clear();
+                        }
+
+                        // Process pending File
+                        if (!pImpl->pendingFile.empty()) {
+                          // For now, loadFile is implemented via navigate in
+                          // some versions or direct file reading. We'll handle
+                          // it via navigate for simplicity if it's already
+                          // implemented that way.
+                        }
+                      }
+                      return S_OK;
+                    })
+                    .Get());
+            return S_OK;
+          })
+          .Get());
+
+#elif defined(__APPLE__)
+  WKWebViewConfiguration *config = [[WKWebViewConfiguration alloc] init];
+  config.preferences.javaScriptEnabled = YES;
+
+  if (win.pImpl->config.devtools) {
+    [config.preferences setValue:@YES forKey:@"developerExtrasEnabled"];
+  }
+
   // Block browser default drag-drop while allowing drop zone visual feedback.
   // File delivery is handled natively by macOS drag APIs, not browser events.
   if (win.pImpl->config.disableWebviewDragDrop ||
@@ -862,18 +874,18 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
       forMainFrameOnly:NO];
     [config.userContentController addUserScript:userScript];
   }
-
-  // Hide scrollbars if disabled
-  if (!win.pImpl->config.scrollbars) {
-    NSString *scrollbarScript = [NSString stringWithUTF8String:kHideScrollbarsScript];
-
-    WKUserScript *scrollScript = [[WKUserScript alloc]
-      initWithSource:scrollbarScript
-      injectionTime:WKUserScriptInjectionTimeAtDocumentEnd
-      forMainFrameOnly:NO];
-    [config.userContentController addUserScript:scrollScript];
-  }
-
+
+  // Hide scrollbars if disabled
+  if (!win.pImpl->config.scrollbars) {
+    NSString *scrollbarScript = [NSString stringWithUTF8String:kHideScrollbarsScript];
+
+    WKUserScript *scrollScript = [[WKUserScript alloc]
+      initWithSource:scrollbarScript
+      injectionTime:WKUserScriptInjectionTimeAtDocumentEnd
+      forMainFrameOnly:NO];
+    [config.userContentController addUserScript:scrollScript];
+  }
+
   NSView *parentView = (__bridge NSView *)windowHandle;
   win.pImpl->wkWebView =
       [[WKWebView alloc] initWithFrame:parentView.bounds configuration:config];
@@ -963,406 +975,406 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
   }
 
 #endif
-
-  win.pImpl->trayManager = std::make_unique<TrayManager>();
-  win.pImpl->trayManager->setWindowHandle(windowHandle);
-
-  return win;
-}
-
-TrayManager &Window::tray() { return *pImpl->trayManager; }
-
-void Window::setWindow(std::shared_ptr<Window> win) {
-  pImpl->window = win;
-  if (!win)
-    return;
-
-  std::weak_ptr<Impl> weak_pImpl = pImpl;
-  win->onResize([weak_pImpl](int w, int h) {
-    if (auto pImpl = weak_pImpl.lock()) {
-#ifdef _WIN32
-      if (pImpl->controller) {
-        RECT bounds = {0, 0, w, h};
-        pImpl->controller->put_Bounds(bounds);
-      }
-#elif defined(__APPLE__)
-      if (pImpl->wkWebView) {
-        NSView *view = (__bridge NSView *)pImpl->wkWebView;
-        NSView *parent = [view superview];
-        if (parent) {
-          [view setFrame:[parent bounds]];
-        }
-      }
-#else
-      if (pImpl->gtkWebView) {
-        // GTK usually handles this if added to a container with expand=TRUE
-        // but we can ensure it here if it's a fixed layout parent
-        gtk_widget_set_size_request(GTK_WIDGET(pImpl->gtkWebView), w, h);
-      }
-#endif
-    }
-  });
-
-  // Trigger initial resize
-  int w, h;
-  win->getSize(w, h);
-#ifdef _WIN32
-  if (pImpl->controller) {
-    RECT bounds = {0, 0, w, h};
-    pImpl->controller->put_Bounds(bounds);
-  }
-#endif
-}
-
-void Window::on(const std::string &event,
-                 std::function<void(const std::string &)> callback) {
-  pImpl->events[event] = callback;
-}
-
-void Window::emit(const std::string &event, const std::string &data) {
-  std::string js = "window.dispatchEvent(new CustomEvent('" + event +
-                   "', {detail: " + data + "}))";
-  executeScript(js);
-}
-
-void Window::navigate(const std::string &url) {
-  pImpl->currentURL = url;
-  pImpl->loading = true;
-
-#ifdef _WIN32
-  if (pImpl->ready && pImpl->webview) {
-    pImpl->webview->Navigate(std::wstring(url.begin(), url.end()).c_str());
-  } else {
-    pImpl->pendingNavigation = url;
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    NSURL *nsurl =
-        [NSURL URLWithString:[NSString stringWithUTF8String:url.c_str()]];
-    NSURLRequest *request = [NSURLRequest requestWithURL:nsurl];
-    [pImpl->wkWebView loadRequest:request];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    webkit_web_view_load_uri(pImpl->gtkWebView, url.c_str());
-  }
-#endif
-}
-
-void Window::loadHTML(const std::string &html) {
-  loadHTML(html, "about:blank");
-}
-
-void Window::loadHTML(const std::string &html, const std::string &baseURL) {
-  pImpl->loading = true;
-
-#ifdef _WIN32
-  (void)baseURL; // Not used on Windows
-  if (pImpl->ready && pImpl->webview) {
-    pImpl->webview->NavigateToString(
-        std::wstring(html.begin(), html.end()).c_str());
-  } else {
-    pImpl->pendingHTML = html;
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    NSString *htmlString = [NSString stringWithUTF8String:html.c_str()];
-    NSURL *base =
-        [NSURL URLWithString:[NSString stringWithUTF8String:baseURL.c_str()]];
-    [pImpl->wkWebView loadHTMLString:htmlString baseURL:base];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    webkit_web_view_load_html(pImpl->gtkWebView, html.c_str(), baseURL.c_str());
-  }
-#endif
-}
-
-void Window::loadFile(const std::string &filePath) {
-  std::ifstream file(filePath);
-  if (!file) {
-    std::cerr << "PlusUI: Failed to open file: " << filePath << std::endl;
-    return;
-  }
-
-  std::stringstream buffer;
-  buffer << file.rdbuf();
-
-  // Use file:// URL as base for relative paths
-  std::string baseURL =
-      "file://" + filePath.substr(0, filePath.find_last_of("/\\") + 1);
-  loadHTML(buffer.str(), baseURL);
-}
-
-void Window::reload() {
-#ifdef _WIN32
-  if (pImpl->webview) {
-    pImpl->webview->Reload();
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    [pImpl->wkWebView reload];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    webkit_web_view_reload(pImpl->gtkWebView);
-  }
-#endif
-}
-
-void Window::stop() {
-#ifdef _WIN32
-  if (pImpl->webview) {
-    pImpl->webview->Stop();
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    [pImpl->wkWebView stopLoading];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    webkit_web_view_stop_loading(pImpl->gtkWebView);
-  }
-#endif
-}
-
-void Window::goBack() {
-#ifdef _WIN32
-  if (pImpl->webview) {
-    pImpl->webview->GoBack();
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    [pImpl->wkWebView goBack];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    webkit_web_view_go_back(pImpl->gtkWebView);
-  }
-#endif
-}
-
-void Window::goForward() {
-#ifdef _WIN32
-  if (pImpl->webview) {
-    pImpl->webview->GoForward();
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    [pImpl->wkWebView goForward];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    webkit_web_view_go_forward(pImpl->gtkWebView);
-  }
-#endif
-}
-
-bool Window::canGoBack() const {
-#ifdef _WIN32
-  if (pImpl->webview) {
-    BOOL canGoBack;
-    pImpl->webview->get_CanGoBack(&canGoBack);
-    return canGoBack;
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    return [pImpl->wkWebView canGoBack];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    return webkit_web_view_can_go_back(pImpl->gtkWebView);
-  }
-#endif
-  return false;
-}
-
-bool Window::canGoForward() const {
-#ifdef _WIN32
-  if (pImpl->webview) {
-    BOOL canGoForward;
-    pImpl->webview->get_CanGoForward(&canGoForward);
-    return canGoForward;
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    return [pImpl->wkWebView canGoForward];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    return webkit_web_view_can_go_forward(pImpl->gtkWebView);
-  }
-#endif
-  return false;
-}
-
-void Window::executeScript(const std::string &script) {
-#ifdef _WIN32
-  if (pImpl->ready && pImpl->webview) {
-    pImpl->webview->ExecuteScript(
-        std::wstring(script.begin(), script.end()).c_str(), nullptr);
-  } else {
-    pImpl->pendingScripts.push_back(script);
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    NSString *js = [NSString stringWithUTF8String:script.c_str()];
-    [pImpl->wkWebView evaluateJavaScript:js completionHandler:nil];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    webkit_web_view_run_javascript(pImpl->gtkWebView, script.c_str(), nullptr,
-                                   nullptr, nullptr);
-  }
-#endif
-}
-
-void Window::executeScript(const std::string &script,
-                            std::function<void(const std::string &)> callback) {
-#ifdef _WIN32
-  if (pImpl->webview) {
-    pImpl->webview->ExecuteScript(
-        std::wstring(script.begin(), script.end()).c_str(),
-        Callback<ICoreWebView2ExecuteScriptCompletedHandler>(
-            [callback](HRESULT error, LPCWSTR result) -> HRESULT {
-              (void)error; // Suppress unused warning
-              if (result && callback) {
-                std::wstring wstr(result);
-                callback(std::string(wstr.begin(), wstr.end()));
-              }
-              return S_OK;
-            })
-            .Get());
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    NSString *js = [NSString stringWithUTF8String:script.c_str()];
-    [pImpl->wkWebView evaluateJavaScript:js
-                       completionHandler:^(id result, NSError *error) {
-                         if (result && callback) {
-                           NSString *resultStr =
-                               [NSString stringWithFormat:@"%@", result];
-                           callback([resultStr UTF8String]);
-                         }
-                       }];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    // GTK WebKit callback handling would go here
-    webkit_web_view_run_javascript(pImpl->gtkWebView, script.c_str(), nullptr,
-                                   nullptr, nullptr);
-  }
-#endif
-}
-
-void Window::bind(const std::string &name, JSCallback callback) {
-  pImpl->bindings[name] = callback;
-
-  // Inject bridge code to expose function to JavaScript
-  std::string bridgeScript = R"(
-        window.)" + name + R"( = function(...args) {
-            return window.plusui.invoke('webview.)" +
-                             name + R"(', args);
-        };
-    )";
-
-  executeScript(bridgeScript);
-}
-
-void Window::unbind(const std::string &name) {
-  pImpl->bindings.erase(name);
-
-  std::string script = "delete window." + name + ";";
-  executeScript(script);
-}
-
-void Window::openDevTools() {
-#ifdef _WIN32
-  if (pImpl->webview) {
-    pImpl->webview->OpenDevToolsWindow();
-  }
-#elif defined(__APPLE__)
-  // macOS: Dev tools open in Safari's Web Inspector
-#else
-  if (pImpl->gtkWebView) {
-    WebKitWebInspector *inspector =
-        webkit_web_view_get_inspector(pImpl->gtkWebView);
-    webkit_web_inspector_show(inspector);
-  }
-#endif
-}
-
-void Window::closeDevTools() {
-#ifdef _WIN32
-  // WebView2 doesn't have explicit close
-#elif defined(__APPLE__)
-  // macOS: Handled by Web Inspector
-#else
-  if (pImpl->gtkWebView) {
-    WebKitWebInspector *inspector =
-        webkit_web_view_get_inspector(pImpl->gtkWebView);
-    webkit_web_inspector_close(inspector);
-  }
-#endif
-}
-
-void Window::setUserAgent(const std::string &userAgent) {
-  pImpl->userAgent = userAgent;
-
-#ifdef _WIN32
-  if (pImpl->webview) {
-    ComPtr<ICoreWebView2Settings> settings;
-    pImpl->webview->get_Settings(&settings);
-    // WebView2 user agent requires settings2 interface
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    [pImpl->wkWebView
-        setCustomUserAgent:[NSString stringWithUTF8String:userAgent.c_str()]];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    WebKitSettings *settings = webkit_web_view_get_settings(pImpl->gtkWebView);
-    webkit_settings_set_user_agent(settings, userAgent.c_str());
-  }
-#endif
-}
-
-std::string Window::getUserAgent() const { return pImpl->userAgent; }
-
-void Window::setZoom(double factor) {
-  pImpl->zoom = factor;
-
-#ifdef _WIN32
-  if (pImpl->controller) {
-    pImpl->controller->put_ZoomFactor(factor);
-  }
-#elif defined(__APPLE__)
-  if (pImpl->wkWebView) {
-    [pImpl->wkWebView setPageZoom:factor];
-  }
-#else
-  if (pImpl->gtkWebView) {
-    webkit_web_view_set_zoom_level(pImpl->gtkWebView, factor);
-  }
-#endif
-}
-
-double Window::getZoom() const { return pImpl->zoom; }
-
-void Window::injectCSS(const std::string &css) {
-  std::string script = R"(
-        (function() {
-            const style = document.createElement('style');
-            style.textContent = `)" +
-                       css + R"(`;
-            document.head.appendChild(style);
-        })();
-    )";
-
-  executeScript(script);
-}
-
+
+  win.pImpl->trayManager = std::make_unique<TrayManager>();
+  win.pImpl->trayManager->setWindowHandle(windowHandle);
+
+  return win;
+}
+
+TrayManager &Window::tray() { return *pImpl->trayManager; }
+
+void Window::setWindow(std::shared_ptr<Window> win) {
+  pImpl->window = win;
+  if (!win)
+    return;
+
+  std::weak_ptr<Impl> weak_pImpl = pImpl;
+  win->onResize([weak_pImpl](int w, int h) {
+    if (auto pImpl = weak_pImpl.lock()) {
+#ifdef _WIN32
+      if (pImpl->controller) {
+        RECT bounds = {0, 0, w, h};
+        pImpl->controller->put_Bounds(bounds);
+      }
+#elif defined(__APPLE__)
+      if (pImpl->wkWebView) {
+        NSView *view = (__bridge NSView *)pImpl->wkWebView;
+        NSView *parent = [view superview];
+        if (parent) {
+          [view setFrame:[parent bounds]];
+        }
+      }
+#else
+      if (pImpl->gtkWebView) {
+        // GTK usually handles this if added to a container with expand=TRUE
+        // but we can ensure it here if it's a fixed layout parent
+        gtk_widget_set_size_request(GTK_WIDGET(pImpl->gtkWebView), w, h);
+      }
+#endif
+    }
+  });
+
+  // Trigger initial resize
+  int w, h;
+  win->getSize(w, h);
+#ifdef _WIN32
+  if (pImpl->controller) {
+    RECT bounds = {0, 0, w, h};
+    pImpl->controller->put_Bounds(bounds);
+  }
+#endif
+}
+
+void Window::on(const std::string &event,
+                 std::function<void(const std::string &)> callback) {
+  pImpl->events[event] = callback;
+}
+
+void Window::emit(const std::string &event, const std::string &data) {
+  std::string js = "window.dispatchEvent(new CustomEvent('" + event +
+                   "', {detail: " + data + "}))";
+  executeScript(js);
+}
+
+void Window::navigate(const std::string &url) {
+  pImpl->currentURL = url;
+  pImpl->loading = true;
+
+#ifdef _WIN32
+  if (pImpl->ready && pImpl->webview) {
+    pImpl->webview->Navigate(std::wstring(url.begin(), url.end()).c_str());
+  } else {
+    pImpl->pendingNavigation = url;
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    NSURL *nsurl =
+        [NSURL URLWithString:[NSString stringWithUTF8String:url.c_str()]];
+    NSURLRequest *request = [NSURLRequest requestWithURL:nsurl];
+    [pImpl->wkWebView loadRequest:request];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    webkit_web_view_load_uri(pImpl->gtkWebView, url.c_str());
+  }
+#endif
+}
+
+void Window::loadHTML(const std::string &html) {
+  loadHTML(html, "about:blank");
+}
+
+void Window::loadHTML(const std::string &html, const std::string &baseURL) {
+  pImpl->loading = true;
+
+#ifdef _WIN32
+  (void)baseURL; // Not used on Windows
+  if (pImpl->ready && pImpl->webview) {
+    pImpl->webview->NavigateToString(
+        std::wstring(html.begin(), html.end()).c_str());
+  } else {
+    pImpl->pendingHTML = html;
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    NSString *htmlString = [NSString stringWithUTF8String:html.c_str()];
+    NSURL *base =
+        [NSURL URLWithString:[NSString stringWithUTF8String:baseURL.c_str()]];
+    [pImpl->wkWebView loadHTMLString:htmlString baseURL:base];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    webkit_web_view_load_html(pImpl->gtkWebView, html.c_str(), baseURL.c_str());
+  }
+#endif
+}
+
+void Window::loadFile(const std::string &filePath) {
+  std::ifstream file(filePath);
+  if (!file) {
+    std::cerr << "PlusUI: Failed to open file: " << filePath << std::endl;
+    return;
+  }
+
+  std::stringstream buffer;
+  buffer << file.rdbuf();
+
+  // Use file:// URL as base for relative paths
+  std::string baseURL =
+      "file://" + filePath.substr(0, filePath.find_last_of("/\\") + 1);
+  loadHTML(buffer.str(), baseURL);
+}
+
+void Window::reload() {
+#ifdef _WIN32
+  if (pImpl->webview) {
+    pImpl->webview->Reload();
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    [pImpl->wkWebView reload];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    webkit_web_view_reload(pImpl->gtkWebView);
+  }
+#endif
+}
+
+void Window::stop() {
+#ifdef _WIN32
+  if (pImpl->webview) {
+    pImpl->webview->Stop();
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    [pImpl->wkWebView stopLoading];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    webkit_web_view_stop_loading(pImpl->gtkWebView);
+  }
+#endif
+}
+
+void Window::goBack() {
+#ifdef _WIN32
+  if (pImpl->webview) {
+    pImpl->webview->GoBack();
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    [pImpl->wkWebView goBack];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    webkit_web_view_go_back(pImpl->gtkWebView);
+  }
+#endif
+}
+
+void Window::goForward() {
+#ifdef _WIN32
+  if (pImpl->webview) {
+    pImpl->webview->GoForward();
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    [pImpl->wkWebView goForward];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    webkit_web_view_go_forward(pImpl->gtkWebView);
+  }
+#endif
+}
+
+bool Window::canGoBack() const {
+#ifdef _WIN32
+  if (pImpl->webview) {
+    BOOL canGoBack;
+    pImpl->webview->get_CanGoBack(&canGoBack);
+    return canGoBack;
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    return [pImpl->wkWebView canGoBack];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    return webkit_web_view_can_go_back(pImpl->gtkWebView);
+  }
+#endif
+  return false;
+}
+
+bool Window::canGoForward() const {
+#ifdef _WIN32
+  if (pImpl->webview) {
+    BOOL canGoForward;
+    pImpl->webview->get_CanGoForward(&canGoForward);
+    return canGoForward;
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    return [pImpl->wkWebView canGoForward];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    return webkit_web_view_can_go_forward(pImpl->gtkWebView);
+  }
+#endif
+  return false;
+}
+
+void Window::executeScript(const std::string &script) {
+#ifdef _WIN32
+  if (pImpl->ready && pImpl->webview) {
+    pImpl->webview->ExecuteScript(
+        std::wstring(script.begin(), script.end()).c_str(), nullptr);
+  } else {
+    pImpl->pendingScripts.push_back(script);
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    NSString *js = [NSString stringWithUTF8String:script.c_str()];
+    [pImpl->wkWebView evaluateJavaScript:js completionHandler:nil];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    webkit_web_view_run_javascript(pImpl->gtkWebView, script.c_str(), nullptr,
+                                   nullptr, nullptr);
+  }
+#endif
+}
+
+void Window::executeScript(const std::string &script,
+                            std::function<void(const std::string &)> callback) {
+#ifdef _WIN32
+  if (pImpl->webview) {
+    pImpl->webview->ExecuteScript(
+        std::wstring(script.begin(), script.end()).c_str(),
+        Callback<ICoreWebView2ExecuteScriptCompletedHandler>(
+            [callback](HRESULT error, LPCWSTR result) -> HRESULT {
+              (void)error; // Suppress unused warning
+              if (result && callback) {
+                std::wstring wstr(result);
+                callback(std::string(wstr.begin(), wstr.end()));
+              }
+              return S_OK;
+            })
+            .Get());
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    NSString *js = [NSString stringWithUTF8String:script.c_str()];
+    [pImpl->wkWebView evaluateJavaScript:js
+                       completionHandler:^(id result, NSError *error) {
+                         if (result && callback) {
+                           NSString *resultStr =
+                               [NSString stringWithFormat:@"%@", result];
+                           callback([resultStr UTF8String]);
+                         }
+                       }];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    // GTK WebKit callback handling would go here
+    webkit_web_view_run_javascript(pImpl->gtkWebView, script.c_str(), nullptr,
+                                   nullptr, nullptr);
+  }
+#endif
+}
+
+void Window::bind(const std::string &name, JSCallback callback) {
+  pImpl->bindings[name] = callback;
+
+  // Inject bridge code to expose function to JavaScript
+  std::string bridgeScript = R"(
+        window.)" + name + R"( = function(...args) {
+            return window.plusui.invoke('webview.)" +
+                             name + R"(', args);
+        };
+    )";
+
+  executeScript(bridgeScript);
+}
+
+void Window::unbind(const std::string &name) {
+  pImpl->bindings.erase(name);
+
+  std::string script = "delete window." + name + ";";
+  executeScript(script);
+}
+
+void Window::openDevTools() {
+#ifdef _WIN32
+  if (pImpl->webview) {
+    pImpl->webview->OpenDevToolsWindow();
+  }
+#elif defined(__APPLE__)
+  // macOS: Dev tools open in Safari's Web Inspector
+#else
+  if (pImpl->gtkWebView) {
+    WebKitWebInspector *inspector =
+        webkit_web_view_get_inspector(pImpl->gtkWebView);
+    webkit_web_inspector_show(inspector);
+  }
+#endif
+}
+
+void Window::closeDevTools() {
+#ifdef _WIN32
+  // WebView2 doesn't have explicit close
+#elif defined(__APPLE__)
+  // macOS: Handled by Web Inspector
+#else
+  if (pImpl->gtkWebView) {
+    WebKitWebInspector *inspector =
+        webkit_web_view_get_inspector(pImpl->gtkWebView);
+    webkit_web_inspector_close(inspector);
+  }
+#endif
+}
+
+void Window::setUserAgent(const std::string &userAgent) {
+  pImpl->userAgent = userAgent;
+
+#ifdef _WIN32
+  if (pImpl->webview) {
+    ComPtr<ICoreWebView2Settings> settings;
+    pImpl->webview->get_Settings(&settings);
+    // WebView2 user agent requires settings2 interface
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    [pImpl->wkWebView
+        setCustomUserAgent:[NSString stringWithUTF8String:userAgent.c_str()]];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    WebKitSettings *settings = webkit_web_view_get_settings(pImpl->gtkWebView);
+    webkit_settings_set_user_agent(settings, userAgent.c_str());
+  }
+#endif
+}
+
+std::string Window::getUserAgent() const { return pImpl->userAgent; }
+
+void Window::setZoom(double factor) {
+  pImpl->zoom = factor;
+
+#ifdef _WIN32
+  if (pImpl->controller) {
+    pImpl->controller->put_ZoomFactor(factor);
+  }
+#elif defined(__APPLE__)
+  if (pImpl->wkWebView) {
+    [pImpl->wkWebView setPageZoom:factor];
+  }
+#else
+  if (pImpl->gtkWebView) {
+    webkit_web_view_set_zoom_level(pImpl->gtkWebView, factor);
+  }
+#endif
+}
+
+double Window::getZoom() const { return pImpl->zoom; }
+
+void Window::injectCSS(const std::string &css) {
+  std::string script = R"(
+        (function() {
+            const style = document.createElement('style');
+            style.textContent = `)" +
+                       css + R"(`;
+            document.head.appendChild(style);
+        })();
+    )";
+
+  executeScript(script);
+}
+
 void Window::setWebviewDragDropEnabled(bool enabled) {
   if (enabled) {
     executeScript(R"(
@@ -1430,37 +1442,37 @@ void Window::setWebviewDragDropEnabled(bool enabled) {
     )");
   }
 }
-
-void Window::onNavigationStart(NavigationCallback callback) {
-  pImpl->navigationCallback = callback;
-}
-
-void Window::onNavigationComplete(LoadCallback callback) {
-  pImpl->navigationCompleteCallback = callback;
-}
-
-void Window::onLoadStart(LoadCallback callback) {
-  pImpl->loadStartCallback = callback;
-}
-
-void Window::onLoadEnd(LoadCallback callback) {
-  pImpl->loadEndCallback = callback;
-}
-
-void Window::onLoadError(ErrorCallback callback) {
-  pImpl->errorCallback = callback;
-}
-
-void Window::onConsoleMessage(ConsoleCallback callback) {
-  pImpl->consoleCallback = callback;
-}
-
-bool Window::isLoading() const { return pImpl->loading; }
-
-std::string Window::getURL() const { return pImpl->currentURL; }
-
-std::string Window::getTitle() const { return pImpl->currentTitle; }
-
-void *Window::nativeHandle() const { return pImpl->nativeWebView; }
-
-} // namespace plusui
+
+void Window::onNavigationStart(NavigationCallback callback) {
+  pImpl->navigationCallback = callback;
+}
+
+void Window::onNavigationComplete(LoadCallback callback) {
+  pImpl->navigationCompleteCallback = callback;
+}
+
+void Window::onLoadStart(LoadCallback callback) {
+  pImpl->loadStartCallback = callback;
+}
+
+void Window::onLoadEnd(LoadCallback callback) {
+  pImpl->loadEndCallback = callback;
+}
+
+void Window::onLoadError(ErrorCallback callback) {
+  pImpl->errorCallback = callback;
+}
+
+void Window::onConsoleMessage(ConsoleCallback callback) {
+  pImpl->consoleCallback = callback;
+}
+
+bool Window::isLoading() const { return pImpl->loading; }
+
+std::string Window::getURL() const { return pImpl->currentURL; }
+
+std::string Window::getTitle() const { return pImpl->currentTitle; }
+
+void *Window::nativeHandle() const { return pImpl->nativeWebView; }
+
+} // namespace plusui