plusui-native-core 0.1.4 → 0.1.5

package/Core/Features/WebView/webview.cpp

@@ -0,0 +1,1052 @@
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <plusui/tray.hpp>
+#include <plusui/webgpu.hpp>
+#include <plusui/webview.hpp>
+#include <plusui/window.hpp>
+#include <plusui/window_manager.hpp>
+#include <regex>
+#include <sstream>
+
+#ifdef _WIN32
+#include <WebView2.h>
+#include <windows.h>
+#include <wrl.h>
+using namespace Microsoft::WRL;
+#elif defined(__APPLE__)
+#import <WebKit/WebKit.h>
+#import <objc/objc-runtime.h>
+#else
+#include <webkit2/webkit2.h>
+#endif
+
+namespace plusui {
+
+struct WebView::Impl {
+  void *nativeWebView = nullptr;
+  WebViewConfig config;
+  std::string currentURL;
+  std::string currentTitle;
+  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::unique_ptr<WindowManager> windowManager;
+  std::shared_ptr<Window> window; // Keep the window alive
+  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
+};
+
+WebView::WebView() : pImpl(std::shared_ptr<Impl>(new Impl())) {}
+
+WebView::~WebView() = default;
+
+WebView::WebView(WebView &&other) noexcept = default;
+WebView &WebView::operator=(WebView &&other) noexcept = default;
+
+WebView WebView::create(void *windowHandle, const WebViewConfig &config) {
+  WebView wv;
+  wv.pImpl->config = config;
+
+#ifdef _WIN32
+  HWND hwnd = static_cast<HWND>(windowHandle);
+
+  // Create WebView2 environment and controller
+  auto pImpl = wv.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 {
+                      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);
+                        }
+
+                        // Set up WebMessageReceived handler for JS->C++ bridge
+                        pImpl->webview->add_WebMessageReceived(
+                            Callback<
+                                ICoreWebView2WebMessageReceivedEventHandler>(
+                                [pImpl](ICoreWebView2 *sender,
+                                        ICoreWebView2WebMessageReceivedEventArgs
+                                            *args) -> HRESULT {
+                                  LPWSTR message = nullptr;
+                                  args->TryGetWebMessageAsString(&message);
+                                  if (!message)
+                                    return S_OK;
+                                  std::wstring wmsg(message);
+                                  std::string msg(wmsg.begin(), wmsg.end());
+                                  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") {
+                                      pImpl->windowManager->minimize();
+                                      success = true;
+                                    } else if (winMethod == "maximize") {
+                                      pImpl->windowManager->maximize();
+                                      success = true;
+                                    } else if (winMethod == "restore") {
+                                      pImpl->windowManager->restore();
+                                      success = true;
+                                    } else if (winMethod == "close") {
+                                      pImpl->windowManager->close();
+                                      success = true;
+                                    } else if (winMethod == "show") {
+                                      pImpl->windowManager->show();
+                                      success = true;
+                                    } else if (winMethod == "hide") {
+                                      pImpl->windowManager->hide();
+                                      success = true;
+                                    } else if (winMethod == "getSize") {
+                                      auto size =
+                                          pImpl->windowManager->getSize();
+                                      result = "{\"width\":" +
+                                               std::to_string(size.width) +
+                                               ",\"height\":" +
+                                               std::to_string(size.height) +
+                                               "}";
+                                      success = true;
+                                    } else if (winMethod == "getPosition") {
+                                      auto pos =
+                                          pImpl->windowManager->getPosition();
+                                      result =
+                                          "{\"x\":" + std::to_string(pos.x) +
+                                          ",\"y\":" + std::to_string(pos.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);
+                                        pImpl->windowManager->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);
+                                        pImpl->windowManager->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);
+                                        pImpl->windowManager->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);
+                                        pImpl->windowManager->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);
+                                        pImpl->windowManager->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);
+                                        pImpl->windowManager->setResizable(
+                                            params.find("true") !=
+                                            std::string::npos);
+                                      }
+                                      success = true;
+                                    } else if (winMethod == "isMaximized") {
+                                      result =
+                                          pImpl->windowManager->isMaximized()
+                                              ? "true"
+                                              : "false";
+                                      success = true;
+                                    } else if (winMethod == "isMinimized") {
+                                      result =
+                                          pImpl->windowManager->isMinimized()
+                                              ? "true"
+                                              : "false";
+                                      success = true;
+                                    } else if (winMethod == "isVisible") {
+                                      result = pImpl->windowManager->isVisible()
+                                                   ? "true"
+                                                   : "false";
+                                      success = true;
+                                    } else if (winMethod == "center") {
+                                      pImpl->windowManager->setCenter();
+                                      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") {
+                                      pImpl->windowManager->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);
+                                    if (kbMethod == "isKeyPressed") {
+                                      result = "false";
+                                      success = true;
+                                    } else if (kbMethod == "registerShortcut") {
+                                      // TODO: integrate with ShortcutManager
+                                      result = "true";
+                                      success = true;
+                                    } else if (kbMethod ==
+                                               "unregisterShortcut") {
+                                      result = "true";
+                                      success = true;
+                                    } else if (kbMethod == "clearShortcuts") {
+                                      success = true;
+                                    } else if (kbMethod == "setAutoRepeat") {
+                                      success = true;
+                                    } else if (kbMethod == "getAutoRepeat") {
+                                      result = "true";
+                                      success = true;
+                                    } else {
+                                      std::cout << "[PlusUI] Unknown keyboard "
+                                                   "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("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 (wv.pImpl->config.devtools) {
+    [config.preferences setValue:@YES forKey:@"developerExtrasEnabled"];
+  }
+
+  NSView *parentView = (__bridge NSView *)windowHandle;
+  wv.pImpl->wkWebView =
+      [[WKWebView alloc] initWithFrame:parentView.bounds configuration:config];
+  [parentView addSubview:wv.pImpl->wkWebView];
+
+  wv.pImpl->nativeWebView = (__bridge void *)wv.pImpl->wkWebView;
+
+#endif
+
+  wv.pImpl->windowManager = std::make_unique<WindowManager>(windowHandle);
+  wv.pImpl->trayManager = std::make_unique<TrayManager>();
+  wv.pImpl->trayManager->setWindowHandle(windowHandle);
+
+  return wv;
+}
+
+TrayManager &WebView::tray() { return *pImpl->trayManager; }
+WindowManager &WebView::window() { return *pImpl->windowManager; }
+
+void WebView::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 WebView::on(const std::string &event,
+                 std::function<void(const std::string &)> callback) {
+  pImpl->events[event] = callback;
+}
+
+void WebView::emit(const std::string &event, const std::string &data) {
+  std::string js = "window.dispatchEvent(new CustomEvent('" + event +
+                   "', {detail: " + data + "}))";
+  executeScript(js);
+}
+
+void WebView::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 WebView::loadHTML(const std::string &html) {
+  loadHTML(html, "about:blank");
+}
+
+void WebView::loadHTML(const std::string &html, const std::string &baseURL) {
+  pImpl->loading = true;
+
+#ifdef _WIN32
+  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 WebView::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 WebView::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 WebView::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 WebView::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 WebView::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 WebView::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 WebView::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 WebView::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 WebView::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 {
+              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 WebView::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 WebView::unbind(const std::string &name) {
+  pImpl->bindings.erase(name);
+
+  std::string script = "delete window." + name + ";";
+  executeScript(script);
+}
+
+void WebView::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 WebView::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 WebView::setUserAgent(const std::string &userAgent) {
+  pImpl->config.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 WebView::getUserAgent() const { return pImpl->config.userAgent; }
+
+void WebView::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 WebView::getZoom() const { return pImpl->zoom; }
+
+void WebView::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 WebView::onNavigationStart(NavigationCallback callback) {
+  pImpl->navigationCallback = callback;
+}
+
+void WebView::onNavigationComplete(LoadCallback callback) {
+  pImpl->navigationCompleteCallback = callback;
+}
+
+void WebView::onLoadStart(LoadCallback callback) {
+  pImpl->loadStartCallback = callback;
+}
+
+void WebView::onLoadEnd(LoadCallback callback) {
+  pImpl->loadEndCallback = callback;
+}
+
+void WebView::onLoadError(ErrorCallback callback) {
+  pImpl->errorCallback = callback;
+}
+
+void WebView::onConsoleMessage(ConsoleCallback callback) {
+  pImpl->consoleCallback = callback;
+}
+
+bool WebView::isLoading() const { return pImpl->loading; }
+
+std::string WebView::getURL() const { return pImpl->currentURL; }
+
+std::string WebView::getTitle() const { return pImpl->currentTitle; }
+
+void *WebView::nativeHandle() const { return pImpl->nativeWebView; }
+
+} // namespace plusui