plusui-native-core 0.1.18 → 0.1.20

package/Core/Features/Browser/browser.cpp

@@ -1,182 +1,229 @@
+#include <algorithm>
 #include <iostream>
 #include <plusui/browser.hpp>
 #include <plusui/webview.hpp>
+#include <plusui/window.hpp>
+#include <vector>
+
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <shellapi.h>
+#include <windows.h>
+
+#endif
 
 namespace plusui {
 
+// Keep secondary windows alive
+static std::vector<std::shared_ptr<Window>> g_windows;
+static std::vector<std::shared_ptr<WebView>> g_webviews;
+
 struct Browser::Impl {
-    WebView* webview = nullptr;
-    std::map<std::string, std::string> routes;
-    std::string currentRoute;
-    BrowserState state;
-    
-    std::vector<NavigateCallback> navigateCallbacks;
-    std::vector<StateCallback> stateCallbacks;
-    std::vector<LoadCallback> loadStartCallbacks;
-    std::vector<LoadCallback> loadEndCallbacks;
-    std::vector<std::function<void(const std::string&)>> loadErrorCallbacks;
-    
-    void updateState() {
-        if (webview) {
-            state.url = webview->getURL();
-            state.title = webview->getTitle();
-            state.canGoBack = webview->canGoBack();
-            state.canGoForward = webview->canGoForward();
-            state.isLoading = webview->isLoading();
-            
-            for (auto& cb : stateCallbacks) {
-                cb(state);
-            }
-        }
+  WebView *webview = nullptr;
+  std::map<std::string, std::string> routes;
+  std::string currentRoute;
+  BrowserState state;
+
+  std::vector<NavigateCallback> navigateCallbacks;
+  std::vector<StateCallback> stateCallbacks;
+  std::vector<LoadCallback> loadStartCallbacks;
+  std::vector<LoadCallback> loadEndCallbacks;
+  std::vector<std::function<void(const std::string &)>> loadErrorCallbacks;
+
+  void updateState() {
+    if (webview) {
+      state.url = webview->getURL();
+      state.title = webview->getTitle();
+      state.canGoBack = webview->canGoBack();
+      state.canGoForward = webview->canGoForward();
+      state.isLoading = webview->isLoading();
+
+      for (auto &cb : stateCallbacks) {
+        cb(state);
+      }
     }
-    
-    void notifyNavigate(const std::string& url) {
-        state.url = url;
-        for (auto& cb : navigateCallbacks) {
-            cb(url);
-        }
-        updateState();
+  }
+
+  void notifyNavigate(const std::string &url) {
+    state.url = url;
+    for (auto &cb : navigateCallbacks) {
+      cb(url);
     }
+    updateState();
+  }
 };
 
 Browser::Browser() : pImpl(std::make_shared<Impl>()) {}
 
 Browser::~Browser() = default;
 
-Browser Browser::create(WebView* webview) {
-    Browser browser;
-    browser.pImpl->webview = webview;
-    
-    if (webview) {
-        webview->onNavigationStart([impl = browser.pImpl](const std::string& url) {
-            impl->notifyNavigate(url);
-            return true;
-        });
-        
-        webview->onLoadStart([impl = browser.pImpl]() {
-            impl->state.isLoading = true;
-            for (auto& cb : impl->loadStartCallbacks) {
-                cb();
-            }
+Browser Browser::create(WebView *webview) {
+  Browser browser;
+  browser.pImpl->webview = webview;
+
+  if (webview) {
+    webview->onNavigationStart([impl = browser.pImpl](const std::string &url) {
+      impl->notifyNavigate(url);
+      return true;
+    });
+
+    webview->onLoadStart([impl = browser.pImpl]() {
+      impl->state.isLoading = true;
+      for (auto &cb : impl->loadStartCallbacks) {
+        cb();
+      }
+    });
+
+    webview->onLoadEnd([impl = browser.pImpl]() {
+      impl->state.isLoading = false;
+      impl->updateState();
+      for (auto &cb : impl->loadEndCallbacks) {
+        cb();
+      }
+    });
+
+    webview->onLoadError(
+        [impl = browser.pImpl](const std::string &error, int code) {
+          (void)code; // Suppress unused warning
+          impl->state.isLoading = false;
+          for (auto &cb : impl->loadErrorCallbacks) {
+            cb(error);
+          }
         });
-        
-        webview->onLoadEnd([impl = browser.pImpl]() {
-            impl->state.isLoading = false;
-            impl->updateState();
-            for (auto& cb : impl->loadEndCallbacks) {
-                cb();
-            }
-        });
-        
-        webview->onLoadError([impl = browser.pImpl](const std::string& error, int code) {
-            (void)code; // Suppress unused warning
-            impl->state.isLoading = false;
-            for (auto& cb : impl->loadErrorCallbacks) {
-                cb(error);
-            }
-        });
-    }
-    
-    return browser;
+  }
+
+  return browser;
 }
 
-void Browser::navigate(const std::string& url) {
-    if (pImpl->webview) {
-        pImpl->webview->navigate(url);
-        pImpl->notifyNavigate(url);
-    }
+void Browser::navigate(const std::string &url) {
+  if (pImpl->webview) {
+    pImpl->webview->navigate(url);
+    pImpl->notifyNavigate(url);
+  }
 }
 
 void Browser::goBack() {
-    if (pImpl->webview && pImpl->webview->canGoBack()) {
-        pImpl->webview->goBack();
-        pImpl->updateState();
-    }
+  if (pImpl->webview && pImpl->webview->canGoBack()) {
+    pImpl->webview->goBack();
+    pImpl->updateState();
+  }
 }
 
 void Browser::goForward() {
-    if (pImpl->webview && pImpl->webview->canGoForward()) {
-        pImpl->webview->goForward();
-        pImpl->updateState();
-    }
+  if (pImpl->webview && pImpl->webview->canGoForward()) {
+    pImpl->webview->goForward();
+    pImpl->updateState();
+  }
 }
 
 void Browser::reload() {
-    if (pImpl->webview) {
-        pImpl->webview->reload();
-    }
+  if (pImpl->webview) {
+    pImpl->webview->reload();
+  }
 }
 
 void Browser::stop() {
-    if (pImpl->webview) {
-        pImpl->webview->stop();
-    }
+  if (pImpl->webview) {
+    pImpl->webview->stop();
+  }
+}
+
+void Browser::openExternal(const std::string &url) {
+#ifdef _WIN32
+  ShellExecuteA(NULL, "open", url.c_str(), NULL, NULL, SW_SHOWNORMAL);
+#elif __APPLE__
+  std::string command = "open \"" + url + "\"";
+  system(command.c_str());
+#else
+  std::string command = "xdg-open \"" + url + "\"";
+  system(command.c_str());
+#endif
+}
+
+void Browser::openNewWindow(const std::string &url) {
+  WindowConfig winConfig;
+  winConfig.title = "New Window";
+
+  auto win = std::make_shared<Window>(Window::create(winConfig));
+  win->show();
+  g_windows.push_back(win);
+
+  WebViewConfig webConfig;
+  auto wv = std::make_shared<WebView>(
+      WebView::create(win->nativeHandle(), webConfig));
+  wv->setWindow(win);
+  wv->navigate(url);
+  g_webviews.push_back(wv);
+
+  win->onClose([win, wv]() {
+    auto itW = std::find(g_windows.begin(), g_windows.end(), win);
+    if (itW != g_windows.end())
+      g_windows.erase(itW);
+
+    auto itV = std::find(g_webviews.begin(), g_webviews.end(), wv);
+    if (itV != g_webviews.end())
+      g_webviews.erase(itV);
+  });
 }
 
 std::string Browser::getURL() const {
-    return pImpl->webview ? pImpl->webview->getURL() : "";
+  return pImpl->webview ? pImpl->webview->getURL() : "";
 }
 
 std::string Browser::getTitle() const {
-    return pImpl->webview ? pImpl->webview->getTitle() : "";
+  return pImpl->webview ? pImpl->webview->getTitle() : "";
 }
 
-BrowserState Browser::getState() const {
-    return pImpl->state;
-}
+BrowserState Browser::getState() const { return pImpl->state; }
 
 bool Browser::canGoBack() const {
-    return pImpl->webview ? pImpl->webview->canGoBack() : false;
+  return pImpl->webview ? pImpl->webview->canGoBack() : false;
 }
 
 bool Browser::canGoForward() const {
-    return pImpl->webview ? pImpl->webview->canGoForward() : false;
+  return pImpl->webview ? pImpl->webview->canGoForward() : false;
 }
 
-bool Browser::isLoading() const {
-    return pImpl->state.isLoading;
-}
+bool Browser::isLoading() const { return pImpl->state.isLoading; }
 
 void Browser::onNavigate(NavigateCallback callback) {
-    pImpl->navigateCallbacks.push_back(callback);
+  pImpl->navigateCallbacks.push_back(callback);
 }
 
 void Browser::onStateChange(StateCallback callback) {
-    pImpl->stateCallbacks.push_back(callback);
+  pImpl->stateCallbacks.push_back(callback);
 }
 
 void Browser::onLoadStart(LoadCallback callback) {
-    pImpl->loadStartCallbacks.push_back(callback);
+  pImpl->loadStartCallbacks.push_back(callback);
 }
 
 void Browser::onLoadEnd(LoadCallback callback) {
-    pImpl->loadEndCallbacks.push_back(callback);
+  pImpl->loadEndCallbacks.push_back(callback);
 }
 
-void Browser::onLoadError(std::function<void(const std::string& error)> callback) {
-    pImpl->loadErrorCallbacks.push_back(callback);
+void Browser::onLoadError(
+    std::function<void(const std::string &error)> callback) {
+  pImpl->loadErrorCallbacks.push_back(callback);
 }
 
-void Browser::setRoutes(const std::map<std::string, std::string>& routes) {
-    pImpl->routes = routes;
+void Browser::setRoutes(const std::map<std::string, std::string> &routes) {
+  pImpl->routes = routes;
 }
 
-void Browser::push(const std::string& route) {
-    pImpl->currentRoute = route;
-    auto it = pImpl->routes.find(route);
-    if (it != pImpl->routes.end()) {
-        navigate(it->second);
-    } else {
-        navigate(route);
-    }
+void Browser::push(const std::string &route) {
+  pImpl->currentRoute = route;
+  auto it = pImpl->routes.find(route);
+  if (it != pImpl->routes.end()) {
+    navigate(it->second);
+  } else {
+    navigate(route);
+  }
 }
 
-void Browser::replace(const std::string& route) {
-    push(route);
-}
+void Browser::replace(const std::string &route) { push(route); }
 
-std::string Browser::getCurrentRoute() const {
-    return pImpl->currentRoute;
-}
+std::string Browser::getCurrentRoute() const { return pImpl->currentRoute; }
 
 } // namespace plusui

package/Core/Features/Browser/browser.ts

@@ -25,7 +25,7 @@ async function invoke(method: string, args?: unknown[]): Promise<unknown> {
       throw new Error('Browser API not initialized');
     }
   }
-  return _invoke(method, args);
+  return _invoke!(method, args);
 }
 
 const _navigateCallbacks: NavigateCallback[] = [];
@@ -66,6 +66,18 @@ export const browser = {
     await invoke('browser.navigate', [url]);
   },
 
+  async open(url: string): Promise<void> {
+    await invoke('browser.navigate', [url]);
+  },
+
+  async openExternal(url: string): Promise<void> {
+    await invoke('browser.openExternal', [url]);
+  },
+
+  async openNewWindow(url: string): Promise<void> {
+    await invoke('browser.openNewWindow', [url]);
+  },
+
   async goBack(): Promise<void> {
     await invoke('browser.goBack', []);
   },

package/Core/Features/WebView/webview.cpp

@@ -140,6 +140,35 @@ WebView WebView::create(void *windowHandle, const WebViewConfig &config) {
                               nullptr);
                         }
 
+                        // Disable default webview drag & drop behavior
+                        // This prevents files from being loaded in the browser
+                        // and allows the native FileDrop API to handle them instead
+                        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<
@@ -617,6 +646,45 @@ WebView WebView::create(void *windowHandle, const WebViewConfig &config) {
     [config.preferences setValue:@YES forKey:@"developerExtrasEnabled"];
   }
 
+  // Disable default drag & drop behavior to allow native FileDrop API
+  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 (!wv.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;
   wv.pImpl->wkWebView =
       [[WKWebView alloc] initWithFrame:parentView.bounds configuration:config];

package/Core/include/plusui/browser.hpp

@@ -1,66 +1,69 @@
 #pragma once
 
 #include <functional>
+#include <map>
 #include <memory>
 #include <string>
-#include <map>
 
 namespace plusui {
 
 class WebView;
 
 struct BrowserState {
-    std::string url;
-    std::string title;
-    bool canGoBack = false;
-    bool canGoForward = false;
-    bool isLoading = false;
+  std::string url;
+  std::string title;
+  bool canGoBack = false;
+  bool canGoForward = false;
+  bool isLoading = false;
 };
 
 struct RouteConfig {
-    std::string path;
-    std::string url;
+  std::string path;
+  std::string url;
 };
 
 class Browser {
 public:
-    using NavigateCallback = std::function<void(const std::string& url)>;
-    using StateCallback = std::function<void(const BrowserState& state)>;
-    using LoadCallback = std::function<void()>;
-
-    Browser();
-    ~Browser();
-
-    static Browser create(WebView* webview);
-
-    void navigate(const std::string& url);
-    void goBack();
-    void goForward();
-    void reload();
-    void stop();
-
-    std::string getURL() const;
-    std::string getTitle() const;
-    BrowserState getState() const;
-    
-    bool canGoBack() const;
-    bool canGoForward() const;
-    bool isLoading() const;
-
-    void onNavigate(NavigateCallback callback);
-    void onStateChange(StateCallback callback);
-    void onLoadStart(LoadCallback callback);
-    void onLoadEnd(LoadCallback callback);
-    void onLoadError(std::function<void(const std::string& error)> callback);
-
-    void setRoutes(const std::map<std::string, std::string>& routes);
-    void push(const std::string& route);
-    void replace(const std::string& route);
-    std::string getCurrentRoute() const;
+  using NavigateCallback = std::function<void(const std::string &url)>;
+  using StateCallback = std::function<void(const BrowserState &state)>;
+  using LoadCallback = std::function<void()>;
+
+  Browser();
+  ~Browser();
+
+  static Browser create(WebView *webview);
+
+  void navigate(const std::string &url);
+  void goBack();
+  void goForward();
+  void reload();
+  void stop();
+
+  void openExternal(const std::string &url);
+  void openNewWindow(const std::string &url);
+
+  std::string getURL() const;
+  std::string getTitle() const;
+  BrowserState getState() const;
+
+  bool canGoBack() const;
+  bool canGoForward() const;
+  bool isLoading() const;
+
+  void onNavigate(NavigateCallback callback);
+  void onStateChange(StateCallback callback);
+  void onLoadStart(LoadCallback callback);
+  void onLoadEnd(LoadCallback callback);
+  void onLoadError(std::function<void(const std::string &error)> callback);
+
+  void setRoutes(const std::map<std::string, std::string> &routes);
+  void push(const std::string &route);
+  void replace(const std::string &route);
+  std::string getCurrentRoute() const;
 
 private:
-    struct Impl;
-    std::shared_ptr<Impl> pImpl;
+  struct Impl;
+  std::shared_ptr<Impl> pImpl;
 };
 
 } // namespace plusui

package/Core/include/plusui/plusui

@@ -0,0 +1,18 @@
+/**
+ * PlusUI - Main Framework Header
+ * 
+ * Standard library style include (no .hpp extension needed)
+ * 
+ * Usage:
+ *   #include <plusui>
+ *   using namespace plusui;
+ * 
+ * This provides access to all core framework features including:
+ * - App & Window management
+ * - Browser & WebView
+ * - Events & Bindings
+ * - FileDrop, Keyboard, Clipboard
+ * - Display, Tray, Menu
+ */
+
+#include <plusui/plusui.hpp>

package/Core/include/plusui/plusui.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+/**
+ * PlusUI - Umbrella Header (Auto-generated)
+ * 
+ * This file is automatically generated by scripts/generate-umbrella-header.mjs
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ * 
+ * To regenerate: node Core/scripts/generate-umbrella-header.mjs
+ * 
+ * This umbrella header includes all PlusUI framework headers.
+ * Include this single file to access the entire framework:
+ * 
+ * Usage:
+ *   #include <plusui>  // Standard library style (recommended)
+ *   // OR
+ *   #include <plusui/plusui.hpp>
+ *   
+ *   using namespace plusui;
+ * 
+ * For faster compile times in production, you can include only
+ * the specific headers you need instead of this convenience header.
+ */
+
+#include <plusui/app.hpp>
+#include <plusui/bindings.hpp>
+#include <plusui/browser.hpp>
+#include <plusui/clipboard.hpp>
+#include <plusui/custom_bindings.hpp>
+#include <plusui/display.hpp>
+#include <plusui/events.hpp>
+#include <plusui/filedrop.hpp>
+#include <plusui/keyboard.hpp>
+#include <plusui/menu.hpp>
+#include <plusui/native_bindings.hpp>
+#include <plusui/tray.hpp>
+#include <plusui/webgpu.hpp>
+#include <plusui/webview.hpp>
+#include <plusui/window.hpp>
+#include <plusui/window_manager.hpp>

package/Core/scripts/generate-umbrella-header.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * Generate the plusui.hpp umbrella header
+ * 
+ * This script automatically scans all .hpp files in Core/include/plusui/
+ * and generates the umbrella header that includes them all.
+ * 
+ * Run this whenever you add a new header file to the framework.
+ */
+
+import { readdir, writeFile } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const includeDir = resolve(__dirname, '../include/plusui');
+const outputFile = resolve(includeDir, 'plusui.hpp');
+
+async function generateUmbrellaHeader() {
+  // Read all files in the include directory
+  const files = await readdir(includeDir);
+  
+  // Filter to only .hpp files, excluding plusui.hpp itself
+  const headerFiles = files
+    .filter(file => file.endsWith('.hpp') && file !== 'plusui.hpp')
+    .sort();
+  
+  if (headerFiles.length === 0) {
+    throw new Error('No header files found to include');
+  }
+  
+  // Generate the header content
+  const includes = headerFiles
+    .map(file => `#include <plusui/${file}>`)
+    .join('\n');
+  
+  const content = `#pragma once
+
+/**
+ * PlusUI - Umbrella Header (Auto-generated)
+ * 
+ * This file is automatically generated by scripts/generate-umbrella-header.mjs
+ * DO NOT EDIT MANUALLY - your changes will be overwritten!
+ * 
+ * To regenerate: node Core/scripts/generate-umbrella-header.mjs
+ * 
+ * This umbrella header includes all PlusUI framework headers.
+ * Include this single file to access the entire framework:
+ * 
+ * Usage:
+ *   #include <plusui>  // Standard library style (recommended)
+ *   // OR
+ *   #include <plusui/plusui.hpp>
+ *   
+ *   using namespace plusui;
+ * 
+ * For faster compile times in production, you can include only
+ * the specific headers you need instead of this convenience header.
+ */
+
+${includes}
+`;
+  
+  // Write the generated header
+  await writeFile(outputFile, content, 'utf8');
+  
+  console.log('✓ Generated plusui.hpp');
+  console.log(`  Included ${headerFiles.length} headers:`);
+  headerFiles.forEach(file => console.log(`    - ${file}`));
+}
+
+generateUmbrellaHeader().catch((error) => {
+  console.error(`Failed to generate umbrella header: ${error.message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plusui-native-core",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "PlusUI Core framework (frontend + backend implementations)",
   "type": "module",
   "files": [
@@ -8,7 +8,7 @@
     "README.md"
   ],
   "scripts": {
-    "prepack": "node scripts/sync-core.mjs"
+    "prepack": "node ../../Core/scripts/generate-umbrella-header.mjs && node scripts/sync-core.mjs"
   },
   "keywords": [
     "desktop",