plusui-native-core 0.1.34 → 0.1.35

package/Core/CMakeLists.txt

@@ -24,7 +24,6 @@ add_library(plusui STATIC
     Features/Bindings/CustomBindings/custom_bindings.cpp
     Features/App/app.cpp
     Features/Window/window.cpp
-    # Features/Window/webview.cpp  # TODO: Resolve duplicate symbol definitions with window.cpp
     Features/Browser/browser.cpp
     Features/Display/display.cpp
     Features/Tray/tray.cpp

package/Core/Features/App/app.cpp

@@ -105,24 +105,29 @@ Window App::Builder::build() {
   winConfig.decorations = config.decorations;
   winConfig.skipTaskbar = config.skipTaskbar;
   winConfig.enableFileDrop = config.enableFileDrop;
-  
+
   // WebView configuration (now part of WindowConfig)
   winConfig.devtools = config.devtools;
   winConfig.scrollbars = config.scrollbars;
   winConfig.disableWebviewDragDrop = config.enableFileDrop;  // Auto-disable webview drag when FileDrop enabled
 
-  Window win = Window::create(winConfig);
-  win.show();
+  // Create native window
+  auto nativeWinPtr = std::make_shared<Window>(Window::create(winConfig));
+  nativeWinPtr->show();
+
+  // Create embedded webview window inside the native window
+  Window webviewWin = Window::create(nativeWinPtr->nativeHandle(), winConfig);
+  webviewWin.setWindow(nativeWinPtr);
 
   if (!config.trayIconPath.empty()) {
-    win.tray().setIcon(config.trayIconPath);
-    win.tray().setVisible(true);
+    nativeWinPtr->tray().setIcon(config.trayIconPath);
+    nativeWinPtr->tray().setVisible(true);
     if (!config.trayTooltip.empty()) {
-      win.tray().setTooltip(config.trayTooltip);
+      nativeWinPtr->tray().setTooltip(config.trayTooltip);
     }
   }
 
-  return win;
+  return webviewWin;
 }
 
 App::Builder createApp() { return App::Builder(); }

package/Core/Features/Window/webview.cpp

@@ -25,50 +25,8 @@ using namespace Microsoft::WRL;
 
 namespace plusui {
 
-struct Window::Impl {
-  void *nativeWebView = nullptr;
-  WindowConfig config;
-  std::string currentURL;
-  std::string currentTitle;
-  std::shared_ptr<Window> window; // Keep the native window alive
-  std::string userAgent;  // Advanced webview setting
-  bool loading = false;
-  double zoom = 1.0;
-  bool ready = false;
-  std::vector<std::string> pendingScripts;
-  std::string pendingNavigation;
-  std::string pendingHTML;
-  std::string pendingFile;
-
-  std::map<std::string, JSCallback> bindings;
-
-  std::unique_ptr<TrayManager> trayManager;
-  std::map<std::string, std::function<void(const std::string &)>> events;
-  WebGPU webgpu; // WebGPU support
-
-  NavigationCallback navigationCallback;
-  LoadCallback loadStartCallback;
-  LoadCallback loadEndCallback;
-  LoadCallback navigationCompleteCallback;
-  ErrorCallback errorCallback;
-  ConsoleCallback consoleCallback;
-
-#ifdef _WIN32
-  ComPtr<ICoreWebView2Controller> controller;
-  ComPtr<ICoreWebView2> webview;
-#elif defined(__APPLE__)
-  WKWebView *wkWebView = nullptr;
-#else
-  WebKitWebView *gtkWebView = nullptr;
-#endif
-};
-
-Window::Window() : pImpl(std::shared_ptr<Impl>(new Impl())) {}
-
-Window::~Window() = default;
-
-Window::Window(Window &&other) noexcept = default;
-Window &Window::operator=(Window &&other) noexcept = default;
+// 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;

package/Core/Features/Window/window.cpp

@@ -1,15 +1,29 @@
+#include <fstream>
+#include <functional>
 #include <iostream>
 #include <map>
 #include <plusui/display.hpp>
+#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)
+#include <WebView2.h>
 #include <windows.h>
+#include <wrl.h>
+using namespace Microsoft::WRL;
+#pragma warning(pop)
 #elif defined(__APPLE__)
 #include <Cocoa/Cocoa.h>
 #include <objc/objc-runtime.h>
+#import <WebKit/WebKit.h>
 #else
 #include <gtk/gtk.h>
+#include <webkit2/webkit2.h>
 #endif
 
 #include <stb_image.h>
@@ -18,9 +32,33 @@ namespace plusui {
 
 struct Window::Impl {
   void *nativeWindow = nullptr;
+  void *nativeWebView = nullptr;
   WindowConfig config;
   WindowState state;
 
+  // WebView-specific members
+  std::string currentURL;
+  std::string currentTitle;
+  std::shared_ptr<Window> window;
+  std::string userAgent;
+  bool loading = false;
+  double zoom = 1.0;
+  bool ready = false;
+  std::vector<std::string> pendingScripts;
+  std::string pendingNavigation;
+  std::string pendingHTML;
+  std::string pendingFile;
+  std::map<std::string, JSCallback> bindings;
+  std::unique_ptr<TrayManager> trayManager;
+  std::map<std::string, std::function<void(const std::string &)>> events;
+  WebGPU webgpu;
+  NavigationCallback navigationCallback;
+  LoadCallback loadStartCallback;
+  LoadCallback loadEndCallback;
+  LoadCallback navigationCompleteCallback;
+  ErrorCallback errorCallback;
+  ConsoleCallback consoleCallback;
+
   std::vector<MoveCallback> moveCallbacks;
   std::vector<ResizeCallback> resizeCallbacks;
   std::vector<CloseCallback> closeCallbacks;
@@ -30,6 +68,8 @@ struct Window::Impl {
 #ifdef _WIN32
   HWND hwnd = nullptr;
   WNDPROC originalProc = nullptr;
+  ComPtr<ICoreWebView2Controller> controller;
+  ComPtr<ICoreWebView2> webview;
 
   static LRESULT CALLBACK wndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
     Impl *impl = nullptr;
@@ -79,6 +119,10 @@ struct Window::Impl {
     }
     return DefWindowProc(hwnd, msg, wp, lp);
   }
+#elif defined(__APPLE__)
+  WKWebView *wkWebView = nullptr;
+#else
+  WebKitWebView *gtkWebView = nullptr;
 #endif
 };
 
@@ -86,6 +130,9 @@ Window::Window() : pImpl(std::shared_ptr<Impl>(new Impl())) {}
 
 Window::~Window() = default;
 
+Window::Window(Window &&other) noexcept = default;
+Window &Window::operator=(Window &&other) noexcept = default;
+
 Window Window::create(const WindowConfig &config) {
   Window w;
   w.pImpl->config = config;
@@ -198,6 +245,18 @@ Window Window::create(const WindowConfig &config) {
   w.pImpl->nativeWindow = (void *)gtkwin;
 #endif
 
+  // Initialize tray manager for native windows
+  w.pImpl->trayManager = std::make_unique<TrayManager>();
+#ifdef _WIN32
+  if (w.pImpl->hwnd) {
+    w.pImpl->trayManager->setWindowHandle((void *)w.pImpl->hwnd);
+  }
+#elif defined(__APPLE__)
+  w.pImpl->trayManager->setWindowHandle(w.pImpl->nativeWindow);
+#else
+  w.pImpl->trayManager->setWindowHandle(w.pImpl->nativeWindow);
+#endif
+
   return w;
 }
 
@@ -220,7 +279,10 @@ void Window::setTitle(const std::string &title) {
 #endif
 }
 
-std::string Window::getTitle() const { return pImpl->config.title; }
+std::string Window::getTitle() const {
+  if (!pImpl->currentTitle.empty()) return pImpl->currentTitle;
+  return pImpl->config.title;
+}
 
 void Window::setSize(int width, int height) {
   pImpl->config.width = width;
@@ -677,4 +739,979 @@ void Window::onStateChange(StateCallback callback) {
 
 void *Window::nativeHandle() const { return pImpl->nativeWindow; }
 
+// WebView-specific implementations
+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;
+
+                        // 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);
+
+                        // Inject scrollbar hiding CSS if disabled
+                        if (!pImpl->config.scrollbars) {
+                          std::string scrollbarScript = R"(
+                                (function() {
+                                    var css = 'html, body { overflow: hidden !important; margin: 0 !important; padding: 0 !important; } ::-webkit-scrollbar { display: none !important; width: 0 !important; height: 0 !important; }';
+                                    var style = document.createElement('style');
+                                    style.type = 'text/css';
+                                    style.appendChild(document.createTextNode(css));
+                                    (document.head || document.documentElement).appendChild(style);
+                                })();
+                            )";
+                          pImpl->webview->AddScriptToExecuteOnDocumentCreated(
+                              std::wstring(scrollbarScript.begin(),
+                                           scrollbarScript.end())
+                                  .c_str(),
+                              nullptr);
+                        }
+
+                        // Disable webview drag & drop behavior if requested
+                        // This prevents files from being loaded in the browser
+                        // and allows the native FileDrop API to handle them instead
+                        if (pImpl->config.disableWebviewDragDrop) {
+                          std::string disableDragDropScript = R"(
+                              (function() {
+                                  // Prevent default drag and drop behavior on document/window
+                                  ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(function(eventName) {
+                                      document.addEventListener(eventName, function(e) {
+                                          // Only prevent default on document.body or document.documentElement
+                                          // to allow custom drop zones to still work
+                                          if (e.target === document.body || e.target === document.documentElement || e.target === document) {
+                                              e.preventDefault();
+                                              e.stopPropagation();
+                                          }
+                                      }, true);
+
+                                      window.addEventListener(eventName, function(e) {
+                                          e.preventDefault();
+                                          e.stopPropagation();
+                                      }, true);
+                                  });
+                              })();
+                          )";
+                          pImpl->webview->AddScriptToExecuteOnDocumentCreated(
+                              std::wstring(disableDragDropScript.begin(),
+                                           disableDragDropScript.end())
+                                  .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("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;
+                                    }
+                                  }
+
+                                  // 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"];
+  }
+
+  // Disable webview drag & drop behavior to allow native FileDrop API
+  if (win.pImpl->config.disableWebviewDragDrop) {
+    NSString *disableDragDropScript = @"(function() {"
+      "['dragenter', 'dragover', 'dragleave', 'drop'].forEach(function(eventName) {"
+        "document.addEventListener(eventName, function(e) {"
+          "if (e.target === document.body || e.target === document.documentElement || e.target === document) {"
+            "e.preventDefault();"
+            "e.stopPropagation();"
+          "}"
+        "}, true);"
+        "window.addEventListener(eventName, function(e) {"
+          "e.preventDefault();"
+          "e.stopPropagation();"
+        "}, true);"
+      "});"
+    "})();";
+
+    WKUserScript *userScript = [[WKUserScript alloc]
+      initWithSource:disableDragDropScript
+      injectionTime:WKUserScriptInjectionTimeAtDocumentEnd
+      forMainFrameOnly:NO];
+    [config.userContentController addUserScript:userScript];
+  }
+
+  // Hide scrollbars if disabled
+  if (!win.pImpl->config.scrollbars) {
+    NSString *scrollbarScript = @"(function() {"
+      "var css = 'html, body { overflow: hidden !important; margin: 0 !important; padding: 0 !important; } ::-webkit-scrollbar { display: none !important; width: 0 !important; height: 0 !important; }';"
+      "var style = document.createElement('style');"
+      "style.type = 'text/css';"
+      "style.appendChild(document.createTextNode(css));"
+      "(document.head || document.documentElement).appendChild(style);"
+    "})();";
+
+    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];
+  [parentView addSubview:win.pImpl->wkWebView];
+
+  win.pImpl->nativeWebView = (__bridge void *)win.pImpl->wkWebView;
+
+#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
+
+  // Apply scrollbar hiding CSS if configured
+  if (!pImpl->config.scrollbars) {
+    std::string hideScrollbars = R"(
+      (function() {
+        document.documentElement.style.overflow = 'hidden';
+        document.documentElement.style.margin = '0';
+        document.documentElement.style.padding = '0';
+        document.body.style.overflow = 'hidden';
+        document.body.style.margin = '0';
+        document.body.style.padding = '0';
+      })();
+    )";
+    // Schedule this to run after a short delay to ensure DOM is ready
+#ifdef _WIN32
+    if (pImpl->ready && pImpl->webview) {
+      pImpl->webview->ExecuteScript(
+          std::wstring(hideScrollbars.begin(), hideScrollbars.end()).c_str(),
+          nullptr);
+    }
+#elif defined(__APPLE__)
+    if (pImpl->wkWebView) {
+      NSString *js = [NSString stringWithUTF8String:hideScrollbars.c_str()];
+      [pImpl->wkWebView evaluateJavaScript:js completionHandler:nil];
+    }
+#else
+    if (pImpl->gtkWebView) {
+      webkit_web_view_run_javascript(pImpl->gtkWebView, hideScrollbars.c_str(),
+                                     nullptr, nullptr, nullptr);
+    }
+#endif
+  }
+}
+
+void Window::loadURL(const std::string &url) {
+  navigate(url);
+}
+
+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.id = 'plusui-injected-css-' + Date.now();
+            style.textContent = `)" +
+                       css + R"(`;
+            if (document.head) {
+              document.head.appendChild(style);
+            } else {
+              document.documentElement.appendChild(style);
+            }
+        })();
+    )";
+
+  executeScript(script);
+}
+
+void Window::setWebviewDragDropEnabled(bool enabled) {
+  std::string script;
+
+  if (enabled) {
+    // Enable webview drag-drop by removing our prevention handlers
+    script = R"(
+      (function() {
+        if (window.__plusui_dragDropDisabled) {
+          delete window.__plusui_dragDropDisabled;
+        }
+      })();
+    )";
+  } else {
+    // Disable webview drag-drop by preventing default behavior
+    script = R"(
+      (function() {
+        if (window.__plusui_dragDropDisabled) return; // Already disabled
+        window.__plusui_dragDropDisabled = true;
+
+        ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(function(eventName) {
+          document.addEventListener(eventName, function(e) {
+            if (e.target === document.body || e.target === document.documentElement || e.target === document) {
+              e.preventDefault();
+              e.stopPropagation();
+            }
+          }, true);
+
+          window.addEventListener(eventName, function(e) {
+            e.preventDefault();
+            e.stopPropagation();
+          }, true);
+        });
+      })();
+    )";
+  }
+
+  executeScript(script);
+}
+
+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; }
+
 } // namespace plusui

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plusui-native-core",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "PlusUI Core framework (frontend + backend implementations)",
   "type": "module",
   "files": [