plusui-native-core 0.1.52 → 0.1.53

package/Core/Features/Window/window.cpp

@@ -3,7 +3,6 @@
 #include <iostream>
 #include <map>
 #include <plusui/display.hpp>
-#include <plusui/events.hpp>
 #include <plusui/tray.hpp>
 #include <plusui/webgpu.hpp>
 #include <plusui/window.hpp>
@@ -12,7 +11,7 @@
 
 #ifdef _WIN32
 #pragma warning(push)
-#pragma warning(disable: 4996)
+#pragma warning(disable : 4996)
 #include <WebView2.h>
 #include <windows.h>
 #include <wrl.h>
@@ -20,8 +19,9 @@ using namespace Microsoft::WRL;
 #pragma warning(pop)
 #elif defined(__APPLE__)
 #include <Cocoa/Cocoa.h>
-#include <objc/objc-runtime.h>
 #import <WebKit/WebKit.h>
+#include <objc/objc-runtime.h>
+
 #else
 #include <gtk/gtk.h>
 #include <webkit2/webkit2.h>
@@ -89,14 +89,22 @@ static std::string mimeTypeFromPath(const std::string &path) {
   std::string ext = path.substr(dot);
   for (char &ch : ext)
     ch = static_cast<char>(tolower(static_cast<unsigned char>(ch)));
-  if (ext == ".png") return "image/png";
-  if (ext == ".jpg" || ext == ".jpeg") return "image/jpeg";
-  if (ext == ".gif") return "image/gif";
-  if (ext == ".webp") return "image/webp";
-  if (ext == ".svg") return "image/svg+xml";
-  if (ext == ".txt") return "text/plain";
-  if (ext == ".json") return "application/json";
-  if (ext == ".pdf") return "application/pdf";
+  if (ext == ".png")
+    return "image/png";
+  if (ext == ".jpg" || ext == ".jpeg")
+    return "image/jpeg";
+  if (ext == ".gif")
+    return "image/gif";
+  if (ext == ".webp")
+    return "image/webp";
+  if (ext == ".svg")
+    return "image/svg+xml";
+  if (ext == ".txt")
+    return "text/plain";
+  if (ext == ".json")
+    return "application/json";
+  if (ext == ".pdf")
+    return "application/pdf";
   return "application/octet-stream";
 }
 #endif
@@ -120,9 +128,7 @@ struct Window::Impl {
   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;
@@ -130,6 +136,8 @@ struct Window::Impl {
   LoadCallback navigationCompleteCallback;
   ErrorCallback errorCallback;
   ConsoleCallback consoleCallback;
+  MessageCallback messageCallback;
+  FileDropCallback fileDropCallback;
 
   std::vector<MoveCallback> moveCallbacks;
   std::vector<ResizeCallback> resizeCallbacks;
@@ -230,11 +238,10 @@ struct Window::Impl {
 
           if (i > 0)
             filesJson += ",";
-          filesJson +=
-              "{\"path\":\"" + jsonEscape(path) + "\",\"name\":\"" +
-              jsonEscape(name) + "\",\"type\":\"" +
-              jsonEscape(mimeTypeFromPath(path)) + "\",\"size\":" +
-              std::to_string(sizeBytes) + "}";
+          filesJson += "{\"path\":\"" + jsonEscape(path) + "\",\"name\":\"" +
+                       jsonEscape(name) + "\",\"type\":\"" +
+                       jsonEscape(mimeTypeFromPath(path)) +
+                       "\",\"size\":" + std::to_string(sizeBytes) + "}";
         }
         filesJson += "]";
 
@@ -250,7 +257,8 @@ struct Window::Impl {
             ");"
             "if(!el) return false;"
             "if(!el.closest) return false;"
-            "return !!el.closest('[data-dropzone=\\\"true\\\"], .filedrop-zone, .dropzone');"
+            "return !!el.closest('[data-dropzone=\\\"true\\\"], "
+            ".filedrop-zone, .dropzone');"
             "}catch(_){return false;}})();";
 
         targetImpl->webview->ExecuteScript(
@@ -270,11 +278,14 @@ struct Window::Impl {
                     return S_OK;
 
                   std::string eventScript =
-                      "window.dispatchEvent(new CustomEvent('plusui:fileDrop.filesDropped',"
+                      "window.dispatchEvent(new "
+                      "CustomEvent('plusui:fileDrop.filesDropped',"
                       " { detail: { files: " +
                       filesJson + " } }));";
 
-                  event::emit("fileDrop.filesDropped", filesJson);
+                  if (targetImpl->fileDropCallback) {
+                    targetImpl->fileDropCallback(filesJson);
+                  }
 
                   targetImpl->webview->ExecuteScript(
                       std::wstring(eventScript.begin(), eventScript.end())
@@ -466,7 +477,8 @@ void Window::setTitle(const std::string &title) {
 }
 
 std::string Window::getTitle() const {
-  if (!pImpl->currentTitle.empty()) return pImpl->currentTitle;
+  if (!pImpl->currentTitle.empty())
+    return pImpl->currentTitle;
   return pImpl->config.title;
 }
 
@@ -965,13 +977,13 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                         GetClientRect(parentHwnd, &bounds);
                         controller->put_Bounds(bounds);
                         Window::Impl::embeddedWebviewByParent[parentHwnd] =
-                          pImpl.get();
+                            pImpl.get();
 
                         ComPtr<ICoreWebView2Controller4> controller4;
                         if (controller &&
-                          SUCCEEDED(controller->QueryInterface(
-                            IID_PPV_ARGS(&controller4))) &&
-                          controller4) {
+                            SUCCEEDED(controller->QueryInterface(
+                                IID_PPV_ARGS(&controller4))) &&
+                            controller4) {
                           bool allowExternalDrop =
                               !(pImpl->config.enableFileDrop ||
                                 pImpl->config.disableWebviewDragDrop);
@@ -1009,7 +1021,8 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
 
                         // 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
+                        // and allows the native FileDrop API to handle them
+                        // instead
                         if (pImpl->config.disableWebviewDragDrop) {
                           std::string disableDragDropScript = R"(
                             (function() {
@@ -1084,16 +1097,30 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                   if (!message)
                                     return S_OK;
                                   std::wstring wmsg(message);
-                                  #pragma warning(push)
-                                  #pragma warning(disable: 4244) // Suppress wchar_t to char conversion warning
+#pragma warning(push)
+#pragma warning(disable : 4244) // Suppress wchar_t to char conversion warning
                                   std::string msg(wmsg.begin(), wmsg.end());
-                                  #pragma warning(pop)
+#pragma warning(pop)
                                   CoTaskMemFree(message);
 
                                   // Debug: log received message
                                   std::cout << "[PlusUI] Received: " << msg
                                             << std::endl;
 
+                                  // New Generic Message Handler
+                                  if (pImpl->messageCallback) {
+                                    pImpl->messageCallback(msg);
+                                    // If handled by generic handler, do we
+                                    // stop? For now, let's allow legacy to run
+                                    // too for backward compat UNLESS the
+                                    // message is clearly for the new system.
+                                    // The new system uses "kind" field.
+                                    if (msg.find("\"kind\"") !=
+                                        std::string::npos) {
+                                      return S_OK;
+                                    }
+                                  }
+
                                   // Parse JSON-RPC: {"id":"...",
                                   // "method":"window.minimize", "params":[...]}
                                   std::string id, method;
@@ -1141,42 +1168,46 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                   if (method.find("window.") == 0) {
                                     std::string winMethod = method.substr(7);
                                     if (winMethod == "minimize") {
-                                      if (pImpl->window) pImpl->window->minimize();
+                                      if (pImpl->window)
+                                        pImpl->window->minimize();
                                       success = true;
                                     } else if (winMethod == "maximize") {
-                                      if (pImpl->window) pImpl->window->maximize();
+                                      if (pImpl->window)
+                                        pImpl->window->maximize();
                                       success = true;
                                     } else if (winMethod == "restore") {
-                                      if (pImpl->window) pImpl->window->restore();
+                                      if (pImpl->window)
+                                        pImpl->window->restore();
                                       success = true;
                                     } else if (winMethod == "close") {
-                                      if (pImpl->window) pImpl->window->close();
+                                      if (pImpl->window)
+                                        pImpl->window->close();
                                       success = true;
                                     } else if (winMethod == "show") {
-                                      if (pImpl->window) pImpl->window->show();
+                                      if (pImpl->window)
+                                        pImpl->window->show();
                                       success = true;
                                     } else if (winMethod == "hide") {
-                                      if (pImpl->window) pImpl->window->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) +
-                                                 "}";
+                                        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) +
-                                            "}";
+                                        result = "{\"x\":" + std::to_string(x) +
+                                                 ",\"y\":" + std::to_string(y) +
+                                                 "}";
                                       }
                                       success = true;
                                     } else if (winMethod == "setSize") {
@@ -1190,7 +1221,8 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                         int w = 0, h = 0;
                                         sscanf(params.c_str(), "%d, %d", &w,
                                                &h);
-                                        if (pImpl->window) pImpl->window->setSize(w, h);
+                                        if (pImpl->window)
+                                          pImpl->window->setSize(w, h);
                                       }
                                       success = true;
                                     } else if (winMethod == "setPosition") {
@@ -1203,7 +1235,8 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                         int x = 0, y = 0;
                                         sscanf(params.c_str(), "%d, %d", &x,
                                                &y);
-                                        if (pImpl->window) pImpl->window->setPosition(x, y);
+                                        if (pImpl->window)
+                                          pImpl->window->setPosition(x, y);
                                       }
                                       success = true;
                                     } else if (winMethod == "setTitle") {
@@ -1213,7 +1246,8 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           p2 != std::string::npos) {
                                         std::string title =
                                             msg.substr(p1 + 2, p2 - p1 - 2);
-                                        if (pImpl->window) pImpl->window->setTitle(title);
+                                        if (pImpl->window)
+                                          pImpl->window->setTitle(title);
                                       }
                                       success = true;
                                     } else if (winMethod == "setFullscreen") {
@@ -1223,9 +1257,10 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           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);
+                                        if (pImpl->window)
+                                          pImpl->window->setFullscreen(
+                                              params.find("true") !=
+                                              std::string::npos);
                                       }
                                       success = true;
                                     } else if (winMethod == "setAlwaysOnTop") {
@@ -1235,9 +1270,10 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           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);
+                                        if (pImpl->window)
+                                          pImpl->window->setAlwaysOnTop(
+                                              params.find("true") !=
+                                              std::string::npos);
                                       }
                                       success = true;
                                     } else if (winMethod == "setResizable") {
@@ -1247,30 +1283,33 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           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);
+                                        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";
+                                      result = (pImpl->window &&
+                                                pImpl->window->isMaximized())
+                                                   ? "true"
+                                                   : "false";
                                       success = true;
                                     } else if (winMethod == "isMinimized") {
-                                      result =
-                                          (pImpl->window && pImpl->window->isMinimized())
-                                              ? "true"
-                                              : "false";
+                                      result = (pImpl->window &&
+                                                pImpl->window->isMinimized())
+                                                   ? "true"
+                                                   : "false";
                                       success = true;
                                     } else if (winMethod == "isVisible") {
-                                      result = (pImpl->window && pImpl->window->isVisible())
+                                      result = (pImpl->window &&
+                                                pImpl->window->isVisible())
                                                    ? "true"
                                                    : "false";
                                       success = true;
                                     } else if (winMethod == "center") {
-                                      if (pImpl->window) pImpl->window->center();
+                                      if (pImpl->window)
+                                        pImpl->window->center();
                                       success = true;
                                     }
                                   } else if (method.find("browser.") == 0) {
@@ -1321,7 +1360,8 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                       success = true;
                                     }
                                   } else if (method.find("fileDrop.") == 0) {
-                                    std::string fileDropMethod = method.substr(9);
+                                    std::string fileDropMethod =
+                                        method.substr(9);
                                     if (fileDropMethod == "setEnabled") {
                                       size_t p1 = msg.find("[");
                                       size_t p2 = msg.find("]");
@@ -1329,9 +1369,8 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           p2 != std::string::npos) {
                                         std::string params =
                                             msg.substr(p1 + 1, p2 - p1 - 1);
-                                        bool enabled =
-                                            params.find("true") !=
-                                            std::string::npos;
+                                        bool enabled = params.find("true") !=
+                                                       std::string::npos;
                                         pImpl->config.enableFileDrop = enabled;
 
                                         HWND targetHwnd = nullptr;
@@ -1355,10 +1394,10 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
                                           if (SUCCEEDED(pImpl->controller.As(
                                                   &controller4)) &&
                                               controller4) {
-                                            bool allowExternalDrop =
-                                                !(pImpl->config.enableFileDrop ||
-                                                  pImpl->config
-                                                      .disableWebviewDragDrop);
+                                            bool allowExternalDrop = !(
+                                                pImpl->config.enableFileDrop ||
+                                                pImpl->config
+                                                    .disableWebviewDragDrop);
                                             controller4->put_AllowExternalDrop(
                                                 allowExternalDrop ? TRUE
                                                                   : FALSE);
@@ -1448,56 +1487,68 @@ Window Window::create(void *windowHandle, const WindowConfig &config) {
 
   // Disable webview drag & drop behavior to allow native FileDrop API
   if (win.pImpl->config.disableWebviewDragDrop) {
-    NSString *disableDragDropScript = @"(function() {"
-      "if (window.__plusui_nativeFileDropOnly) return;"
-      "window.__plusui_nativeFileDropOnly = true;"
-      "var isOverDropZone = function(e) {"
-        "if (!e) return false;"
-        "var target = null;"
-        "if (typeof e.clientX === 'number' && typeof e.clientY === 'number' && document.elementFromPoint) { target = document.elementFromPoint(e.clientX, e.clientY); }"
-        "if (!target && e.target && e.target.nodeType === 1) { target = e.target; }"
-        "if (!target || !target.closest) return false;"
-        "return !!target.closest('[data-dropzone=\\\"true\\\"], .filedrop-zone, .dropzone');"
-      "};"
-      "var zoneActive = false;"
-      "var emitZoneState = function(next) {"
-        "if (next === zoneActive) return;"
-        "zoneActive = next;"
-        "window.dispatchEvent(new CustomEvent(next ? 'plusui:fileDrop.dragEnter' : 'plusui:fileDrop.dragLeave', { detail: {} }));"
-      "};"
-      "var block = function(e) {"
-        "if (!e) return false;"
-        "var overDropZone = isOverDropZone(e);"
-        "if (e.type === 'drop') { emitZoneState(false); } else { emitZoneState(overDropZone); }"
-        "e.preventDefault();"
-        "e.stopPropagation();"
-        "if (typeof e.stopImmediatePropagation === 'function') e.stopImmediatePropagation();"
-        "if (e.dataTransfer) { try { e.dataTransfer.dropEffect = overDropZone ? 'copy' : 'none'; } catch (_) {} }"
-        "return false;"
-      "};"
-      "window.__plusui_dragDropEvents = ['dragenter','dragover','dragleave','drop'];"
-      "window.__plusui_dragDropBlocker = block;"
-      "window.__plusui_dragDropEvents.forEach(function(eventName) {"
-        "window.addEventListener(eventName, block, true);"
-        "document.addEventListener(eventName, block, true);"
-      "});"
-    "})();";
+    NSString *disableDragDropScript =
+        @"(function() {"
+         "if (window.__plusui_nativeFileDropOnly) return;"
+         "window.__plusui_nativeFileDropOnly = true;"
+         "var isOverDropZone = function(e) {"
+         "if (!e) return false;"
+         "var target = null;"
+         "if (typeof e.clientX === 'number' && typeof e.clientY === 'number' "
+         "&& document.elementFromPoint) { target = "
+         "document.elementFromPoint(e.clientX, e.clientY); }"
+         "if (!target && e.target && e.target.nodeType === 1) { target = "
+         "e.target; }"
+         "if (!target || !target.closest) return false;"
+         "return !!target.closest('[data-dropzone=\\\"true\\\"], "
+         ".filedrop-zone, .dropzone');"
+         "};"
+         "var zoneActive = false;"
+         "var emitZoneState = function(next) {"
+         "if (next === zoneActive) return;"
+         "zoneActive = next;"
+         "window.dispatchEvent(new CustomEvent(next ? "
+         "'plusui:fileDrop.dragEnter' : 'plusui:fileDrop.dragLeave', { detail: "
+         "{} }));"
+         "};"
+         "var block = function(e) {"
+         "if (!e) return false;"
+         "var overDropZone = isOverDropZone(e);"
+         "if (e.type === 'drop') { emitZoneState(false); } else { "
+         "emitZoneState(overDropZone); }"
+         "e.preventDefault();"
+         "e.stopPropagation();"
+         "if (typeof e.stopImmediatePropagation === 'function') "
+         "e.stopImmediatePropagation();"
+         "if (e.dataTransfer) { try { e.dataTransfer.dropEffect = overDropZone "
+         "? 'copy' : 'none'; } catch (_) {} }"
+         "return false;"
+         "};"
+         "window.__plusui_dragDropEvents = "
+         "['dragenter','dragover','dragleave','drop'];"
+         "window.__plusui_dragDropBlocker = block;"
+         "window.__plusui_dragDropEvents.forEach(function(eventName) {"
+         "window.addEventListener(eventName, block, true);"
+         "document.addEventListener(eventName, block, true);"
+         "});"
+         "})();";
 
     WKUserScript *userScript = [[WKUserScript alloc]
-      initWithSource:disableDragDropScript
-      injectionTime:WKUserScriptInjectionTimeAtDocumentEnd
-      forMainFrameOnly:NO];
+          initWithSource:disableDragDropScript
+           injectionTime:WKUserScriptInjectionTimeAtDocumentEnd
+        forMainFrameOnly:NO];
     [config.userContentController addUserScript:userScript];
   }
 
   // Hide scrollbars if disabled
   if (!win.pImpl->config.scrollbars) {
-    NSString *scrollbarScript = [NSString stringWithUTF8String:kHideScrollbarsScript];
+    NSString *scrollbarScript =
+        [NSString stringWithUTF8String:kHideScrollbarsScript];
 
     WKUserScript *scrollScript = [[WKUserScript alloc]
-      initWithSource:scrollbarScript
-      injectionTime:WKUserScriptInjectionTimeAtDocumentEnd
-      forMainFrameOnly:NO];
+          initWithSource:scrollbarScript
+           injectionTime:WKUserScriptInjectionTimeAtDocumentEnd
+        forMainFrameOnly:NO];
     [config.userContentController addUserScript:scrollScript];
   }
 
@@ -1560,17 +1611,6 @@ void Window::setWindow(std::shared_ptr<Window> win) {
 #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;
@@ -1595,10 +1635,27 @@ void Window::navigate(const std::string &url) {
 #endif
 }
 
-void Window::loadURL(const std::string &url) {
-  navigate(url);
+void Window::onMessage(MessageCallback callback) {
+  pImpl->messageCallback = callback;
+}
+
+void Window::postMessage(const std::string &message) {
+#ifdef _WIN32
+  if (pImpl->webview) {
+    std::wstring wmsg(message.begin(), message.end());
+    pImpl->webview->PostWebMessageAsJson(wmsg.c_str());
+  }
+#elif defined(__APPLE__)
+  // TODO: formatting for Apple
+#endif
+}
+
+void Window::onFileDrop(FileDropCallback callback) {
+  pImpl->fileDropCallback = callback;
 }
 
+void Window::loadURL(const std::string &url) { navigate(url); }
+
 void Window::loadHTML(const std::string &html) {
   loadHTML(html, "about:blank");
 }
@@ -1768,7 +1825,7 @@ void Window::executeScript(const std::string &script) {
 }
 
 void Window::executeScript(const std::string &script,
-                            std::function<void(const std::string &)> callback) {
+                           std::function<void(const std::string &)> callback) {
 #ifdef _WIN32
   if (pImpl->webview) {
     pImpl->webview->ExecuteScript(
@@ -1805,27 +1862,6 @@ void Window::executeScript(const std::string &script,
 #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) {