plusui-native-core 0.1.23 → 0.1.26

package/Core/CMakeLists.txt

@@ -24,8 +24,8 @@ add_library(plusui STATIC
     Features/Bindings/CustomBindings/custom_bindings.cpp
     Features/App/app.cpp
     Features/Window/window.cpp
-    Features/WindowManager/window_manager.cpp
-    Features/WebView/webview.cpp
+    Features/Window/window_manager.cpp
+    Features/Window/webview.cpp
     Features/Browser/browser.cpp
     Features/Display/display.cpp
     Features/Tray/tray.cpp

package/Core/Features/App/app.cpp

@@ -5,7 +5,7 @@
 
 #include <plusui/app.hpp>
 #include <plusui/tray.hpp>
-#include <plusui/webview.hpp>
+#include <plusui/window.hpp>
 #include <plusui/window.hpp>
 #include <plusui/window_manager.hpp>
 
@@ -90,8 +90,12 @@ App::Builder &App::Builder::scrollbars(bool show) {
   config.scrollbars = show;
   return *this;
 }
+App::Builder &App::Builder::enableFileDrop(bool enable) {
+  config.enableFileDrop = enable;
+  return *this;
+}
 
-WebView App::Builder::build() {
+Window App::Builder::build() {
   WindowConfig winConfig;
   winConfig.title = config.title;
   winConfig.width = config.width;
@@ -102,26 +106,25 @@ WebView App::Builder::build() {
   winConfig.transparent = config.transparent;
   winConfig.decorations = config.decorations;
   winConfig.skipTaskbar = config.skipTaskbar;
+  winConfig.enableFileDrop = config.enableFileDrop;
+  
+  // WebView configuration (now part of WindowConfig)
+  winConfig.devtools = config.devtools;
+  winConfig.scrollbars = config.scrollbars;
+  winConfig.disableWebviewDragDrop = config.enableFileDrop;  // Auto-disable webview drag when FileDrop enabled
 
-  auto win = std::make_shared<Window>(Window::create(winConfig));
-  win->show();
-
-  WebViewConfig webConfig;
-  webConfig.devtools = config.devtools;
-  webConfig.scrollbars = config.scrollbars;
-
-  WebView wv = WebView::create(win->nativeHandle(), webConfig);
-  wv.setWindow(win);
+  Window win = Window::create(winConfig);
+  win.show();
 
   if (!config.trayIconPath.empty()) {
-    wv.tray().setIcon(config.trayIconPath);
-    wv.tray().setVisible(true);
+    win.tray().setIcon(config.trayIconPath);
+    win.tray().setVisible(true);
     if (!config.trayTooltip.empty()) {
-      wv.tray().setTooltip(config.trayTooltip);
+      win.tray().setTooltip(config.trayTooltip);
     }
   }
 
-  return wv;
+  return win;
 }
 
 App::Builder createApp() { return App::Builder(); }

package/Core/Features/App/app.ts

@@ -11,6 +11,8 @@ export interface AppConfig {
   transparent?: boolean;
   decorations?: boolean;
   skipTaskbar?: boolean;
+  scrollbars?: boolean;
+  enableFileDrop?: boolean;
 }
 
 export interface InvokeOptions {

package/Core/Features/Browser/browser.cpp

@@ -1,7 +1,7 @@
 #include <algorithm>
 #include <iostream>
 #include <plusui/browser.hpp>
-#include <plusui/webview.hpp>
+#include <plusui/window.hpp>
 #include <plusui/window.hpp>
 #include <vector>
 

package/Core/Features/Menu/menu.cpp

@@ -1,6 +1,6 @@
 #include <iostream>
 #include <plusui/menu.hpp>
-#include <plusui/webview.hpp>
+#include <plusui/window.hpp>
 #include <sstream>
 
 #ifdef _WIN32

package/Core/Features/{WebView → Window}/webview.cpp

@@ -3,7 +3,7 @@
 #include <map>
 #include <plusui/tray.hpp>
 #include <plusui/webgpu.hpp>
-#include <plusui/webview.hpp>
+#include <plusui/window.hpp>
 #include <plusui/window.hpp>
 #include <plusui/window_manager.hpp>
 #include <regex>
@@ -26,11 +26,12 @@ using namespace Microsoft::WRL;
 
 namespace plusui {
 
-struct WebView::Impl {
+struct Window::Impl {
   void *nativeWebView = nullptr;
-  WebViewConfig config;
+  WindowConfig config;
   std::string currentURL;
   std::string currentTitle;
+  std::string userAgent;  // Advanced webview setting
   bool loading = false;
   double zoom = 1.0;
   bool ready = false;
@@ -43,7 +44,6 @@ struct WebView::Impl {
 
   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
 
@@ -64,22 +64,22 @@ struct WebView::Impl {
 #endif
 };
 
-WebView::WebView() : pImpl(std::shared_ptr<Impl>(new Impl())) {}
+Window::Window() : pImpl(std::shared_ptr<Impl>(new Impl())) {}
 
-WebView::~WebView() = default;
+Window::~Window() = default;
 
-WebView::WebView(WebView &&other) noexcept = default;
-WebView &WebView::operator=(WebView &&other) noexcept = default;
+Window::Window(Window &&other) noexcept = default;
+Window &Window::operator=(Window &&other) noexcept = default;
 
-WebView WebView::create(void *windowHandle, const WebViewConfig &config) {
-  WebView wv;
-  wv.pImpl->config = config;
+Window Window::create(void *windowHandle, const WindowConfig &config) {
+  Window win;
+  win.pImpl->config = config;
 
 #ifdef _WIN32
   HWND hwnd = static_cast<HWND>(windowHandle);
 
   // Create WebView2 environment and controller
-  auto pImpl = wv.pImpl;
+  auto pImpl = win.pImpl;
   CreateCoreWebView2EnvironmentWithOptions(
       nullptr, nullptr, nullptr,
       Callback<ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler>(
@@ -140,34 +140,36 @@ WebView WebView::create(void *windowHandle, const WebViewConfig &config) {
                               nullptr);
                         }
 
-                        // Disable default webview drag & drop behavior
+                        // 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
-                        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);
+                        if (pImpl->config.disableWebviewDragDrop) {
+                          std::string disableDragDropScript = R"(
+                              (function() {
+                                  // Prevent default drag and drop behavior on document/window
+                                  ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(function(eventName) {
+                                      document.addEventListener(eventName, function(e) {
+                                          // Only prevent default on document.body or document.documentElement
+                                          // to allow custom drop zones to still work
+                                          if (e.target === document.body || e.target === document.documentElement || e.target === document) {
+                                              e.preventDefault();
+                                              e.stopPropagation();
+                                          }
+                                      }, true);
+                                      
+                                      window.addEventListener(eventName, function(e) {
+                                          e.preventDefault();
+                                          e.stopPropagation();
+                                      }, true);
+                                  });
+                              })();
+                          )";
+                          pImpl->webview->AddScriptToExecuteOnDocumentCreated(
+                              std::wstring(disableDragDropScript.begin(),
+                                           disableDragDropScript.end())
+                                  .c_str(),
+                              nullptr);
+                        }
 
                         // Set up WebMessageReceived handler for JS->C++ bridge
                         pImpl->webview->add_WebMessageReceived(
@@ -530,6 +532,32 @@ WebView WebView::create(void *windowHandle, const WebViewConfig &config) {
                                           << "[PlusUI] Unknown menu method: "
                                           << menuMethod << std::endl;
                                     }
+                                  } else if (method.find("webview.") == 0) {
+                                    // WebView API routing
+                                    std::string webviewMethod = method.substr(8);
+                                    if (webviewMethod == "setWebviewDragDropEnabled") {
+                                      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);
+                                        bool enabled = params.find("true") != std::string::npos;
+                                        // Note: Need to call this on the WebView instance
+                                        // This is a placeholder - actual implementation needs WebView reference
+                                        // For now, execute script directly
+                                        std::string script;
+                                        if (enabled) {
+                                          script = "(function() { if (window.__plusui_dragDropDisabled) { delete window.__plusui_dragDropDisabled; } })();";
+                                        } else {
+                                          script = "(function() { if (window.__plusui_dragDropDisabled) return; window.__plusui_dragDropDisabled = true; ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(function(eventName) { document.addEventListener(eventName, function(e) { if (e.target === document.body || e.target === document.documentElement || e.target === document) { e.preventDefault(); e.stopPropagation(); } }, true); window.addEventListener(eventName, function(e) { e.preventDefault(); e.stopPropagation(); }, true); }); })();";
+                                        }
+                                        pImpl->webview->ExecuteScript(
+                                            std::wstring(script.begin(), script.end()).c_str(),
+                                            nullptr);
+                                      }
+                                      success = true;
+                                    }
                                   } else if (method.find("webgpu.") == 0) {
                                     // WebGPU API routing
                                     std::string webgpuMethod = method.substr(
@@ -642,34 +670,36 @@ WebView WebView::create(void *windowHandle, const WebViewConfig &config) {
   WKWebViewConfiguration *config = [[WKWebViewConfiguration alloc] init];
   config.preferences.javaScriptEnabled = YES;
 
-  if (wv.pImpl->config.devtools) {
+  if (win.pImpl->config.devtools) {
     [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) {"
+  // Disable webview drag & drop behavior to allow native FileDrop API
+  if (win.pImpl->config.disableWebviewDragDrop) {
+    NSString *disableDragDropScript = @"(function() {"
+      "['dragenter', 'dragover', 'dragleave', 'drop'].forEach(function(eventName) {"
+        "document.addEventListener(eventName, function(e) {"
+          "if (e.target === document.body || e.target === document.documentElement || e.target === document) {"
+            "e.preventDefault();"
+            "e.stopPropagation();"
+          "}"
+        "}, true);"
+        "window.addEventListener(eventName, function(e) {"
           "e.preventDefault();"
           "e.stopPropagation();"
-        "}"
-      "}, true);"
-      "window.addEventListener(eventName, function(e) {"
-        "e.preventDefault();"
-        "e.stopPropagation();"
-      "}, true);"
-    "});"
-  "})();";
-  
-  WKUserScript *userScript = [[WKUserScript alloc] 
-    initWithSource:disableDragDropScript 
-    injectionTime:WKUserScriptInjectionTimeAtDocumentEnd 
-    forMainFrameOnly:NO];
-  [config.userContentController addUserScript:userScript];
+        "}, true);"
+      "});"
+    "})();";
+    
+    WKUserScript *userScript = [[WKUserScript alloc] 
+      initWithSource:disableDragDropScript 
+      injectionTime:WKUserScriptInjectionTimeAtDocumentEnd 
+      forMainFrameOnly:NO];
+    [config.userContentController addUserScript:userScript];
+  }
 
   // Hide scrollbars if disabled
-  if (!wv.pImpl->config.scrollbars) {
+  if (!win.pImpl->config.scrollbars) {
     NSString *scrollbarScript = @"(function() {"
       "var css = 'html, body { overflow: hidden !important; margin: 0 !important; padding: 0 !important; } ::-webkit-scrollbar { display: none !important; width: 0 !important; height: 0 !important; }';"
       "var style = document.createElement('style');"
@@ -686,25 +716,25 @@ WebView WebView::create(void *windowHandle, const WebViewConfig &config) {
   }
 
   NSView *parentView = (__bridge NSView *)windowHandle;
-  wv.pImpl->wkWebView =
+  win.pImpl->wkWebView =
       [[WKWebView alloc] initWithFrame:parentView.bounds configuration:config];
-  [parentView addSubview:wv.pImpl->wkWebView];
+  [parentView addSubview:win.pImpl->wkWebView];
 
-  wv.pImpl->nativeWebView = (__bridge void *)wv.pImpl->wkWebView;
+  win.pImpl->nativeWebView = (__bridge void *)win.pImpl->wkWebView;
 
 #endif
 
-  wv.pImpl->windowManager = std::make_unique<WindowManager>(windowHandle);
-  wv.pImpl->trayManager = std::make_unique<TrayManager>();
-  wv.pImpl->trayManager->setWindowHandle(windowHandle);
+  win.pImpl->windowManager = std::make_unique<WindowManager>(windowHandle);
+  win.pImpl->trayManager = std::make_unique<TrayManager>();
+  win.pImpl->trayManager->setWindowHandle(windowHandle);
 
-  return wv;
+  return win;
 }
 
-TrayManager &WebView::tray() { return *pImpl->trayManager; }
-WindowManager &WebView::window() { return *pImpl->windowManager; }
+TrayManager &Window::tray() { return *pImpl->trayManager; }
+WindowManager &Window::window() { return *pImpl->windowManager; }
 
-void WebView::setWindow(std::shared_ptr<Window> win) {
+void Window::setWindow(std::shared_ptr<Window> win) {
   pImpl->window = win;
   if (!win)
     return;
@@ -746,18 +776,18 @@ void WebView::setWindow(std::shared_ptr<Window> win) {
 #endif
 }
 
-void WebView::on(const std::string &event,
+void Window::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) {
+void Window::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) {
+void Window::navigate(const std::string &url) {
   pImpl->currentURL = url;
   pImpl->loading = true;
 
@@ -781,11 +811,11 @@ void WebView::navigate(const std::string &url) {
 #endif
 }
 
-void WebView::loadHTML(const std::string &html) {
+void Window::loadHTML(const std::string &html) {
   loadHTML(html, "about:blank");
 }
 
-void WebView::loadHTML(const std::string &html, const std::string &baseURL) {
+void Window::loadHTML(const std::string &html, const std::string &baseURL) {
   pImpl->loading = true;
 
 #ifdef _WIN32
@@ -810,7 +840,7 @@ void WebView::loadHTML(const std::string &html, const std::string &baseURL) {
 #endif
 }
 
-void WebView::loadFile(const std::string &filePath) {
+void Window::loadFile(const std::string &filePath) {
   std::ifstream file(filePath);
   if (!file) {
     std::cerr << "PlusUI: Failed to open file: " << filePath << std::endl;
@@ -826,7 +856,7 @@ void WebView::loadFile(const std::string &filePath) {
   loadHTML(buffer.str(), baseURL);
 }
 
-void WebView::reload() {
+void Window::reload() {
 #ifdef _WIN32
   if (pImpl->webview) {
     pImpl->webview->Reload();
@@ -842,7 +872,7 @@ void WebView::reload() {
 #endif
 }
 
-void WebView::stop() {
+void Window::stop() {
 #ifdef _WIN32
   if (pImpl->webview) {
     pImpl->webview->Stop();
@@ -858,7 +888,7 @@ void WebView::stop() {
 #endif
 }
 
-void WebView::goBack() {
+void Window::goBack() {
 #ifdef _WIN32
   if (pImpl->webview) {
     pImpl->webview->GoBack();
@@ -874,7 +904,7 @@ void WebView::goBack() {
 #endif
 }
 
-void WebView::goForward() {
+void Window::goForward() {
 #ifdef _WIN32
   if (pImpl->webview) {
     pImpl->webview->GoForward();
@@ -890,7 +920,7 @@ void WebView::goForward() {
 #endif
 }
 
-bool WebView::canGoBack() const {
+bool Window::canGoBack() const {
 #ifdef _WIN32
   if (pImpl->webview) {
     BOOL canGoBack;
@@ -909,7 +939,7 @@ bool WebView::canGoBack() const {
   return false;
 }
 
-bool WebView::canGoForward() const {
+bool Window::canGoForward() const {
 #ifdef _WIN32
   if (pImpl->webview) {
     BOOL canGoForward;
@@ -928,7 +958,7 @@ bool WebView::canGoForward() const {
   return false;
 }
 
-void WebView::executeScript(const std::string &script) {
+void Window::executeScript(const std::string &script) {
 #ifdef _WIN32
   if (pImpl->ready && pImpl->webview) {
     pImpl->webview->ExecuteScript(
@@ -949,7 +979,7 @@ void WebView::executeScript(const std::string &script) {
 #endif
 }
 
-void WebView::executeScript(const std::string &script,
+void Window::executeScript(const std::string &script,
                             std::function<void(const std::string &)> callback) {
 #ifdef _WIN32
   if (pImpl->webview) {
@@ -987,7 +1017,7 @@ void WebView::executeScript(const std::string &script,
 #endif
 }
 
-void WebView::bind(const std::string &name, JSCallback callback) {
+void Window::bind(const std::string &name, JSCallback callback) {
   pImpl->bindings[name] = callback;
 
   // Inject bridge code to expose function to JavaScript
@@ -1001,14 +1031,14 @@ void WebView::bind(const std::string &name, JSCallback callback) {
   executeScript(bridgeScript);
 }
 
-void WebView::unbind(const std::string &name) {
+void Window::unbind(const std::string &name) {
   pImpl->bindings.erase(name);
 
   std::string script = "delete window." + name + ";";
   executeScript(script);
 }
 
-void WebView::openDevTools() {
+void Window::openDevTools() {
 #ifdef _WIN32
   if (pImpl->webview) {
     pImpl->webview->OpenDevToolsWindow();
@@ -1024,7 +1054,7 @@ void WebView::openDevTools() {
 #endif
 }
 
-void WebView::closeDevTools() {
+void Window::closeDevTools() {
 #ifdef _WIN32
   // WebView2 doesn't have explicit close
 #elif defined(__APPLE__)
@@ -1038,8 +1068,8 @@ void WebView::closeDevTools() {
 #endif
 }
 
-void WebView::setUserAgent(const std::string &userAgent) {
-  pImpl->config.userAgent = userAgent;
+void Window::setUserAgent(const std::string &userAgent) {
+  pImpl->userAgent = userAgent;
 
 #ifdef _WIN32
   if (pImpl->webview) {
@@ -1060,9 +1090,9 @@ void WebView::setUserAgent(const std::string &userAgent) {
 #endif
 }
 
-std::string WebView::getUserAgent() const { return pImpl->config.userAgent; }
+std::string Window::getUserAgent() const { return pImpl->userAgent; }
 
-void WebView::setZoom(double factor) {
+void Window::setZoom(double factor) {
   pImpl->zoom = factor;
 
 #ifdef _WIN32
@@ -1080,9 +1110,9 @@ void WebView::setZoom(double factor) {
 #endif
 }
 
-double WebView::getZoom() const { return pImpl->zoom; }
+double Window::getZoom() const { return pImpl->zoom; }
 
-void WebView::injectCSS(const std::string &css) {
+void Window::injectCSS(const std::string &css) {
   std::string script = R"(
         (function() {
             const style = document.createElement('style');
@@ -1095,36 +1125,75 @@ void WebView::injectCSS(const std::string &css) {
   executeScript(script);
 }
 
-void WebView::onNavigationStart(NavigationCallback callback) {
+void Window::setWebviewDragDropEnabled(bool enabled) {
+  std::string script;
+  
+  if (enabled) {
+    // Enable webview drag-drop by removing our prevention handlers
+    script = R"(
+      (function() {
+        if (window.__plusui_dragDropDisabled) {
+          delete window.__plusui_dragDropDisabled;
+        }
+      })();
+    )";
+  } else {
+    // Disable webview drag-drop by preventing default behavior
+    script = R"(
+      (function() {
+        if (window.__plusui_dragDropDisabled) return; // Already disabled
+        window.__plusui_dragDropDisabled = true;
+        
+        ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(function(eventName) {
+          document.addEventListener(eventName, function(e) {
+            if (e.target === document.body || e.target === document.documentElement || e.target === document) {
+              e.preventDefault();
+              e.stopPropagation();
+            }
+          }, true);
+          
+          window.addEventListener(eventName, function(e) {
+            e.preventDefault();
+            e.stopPropagation();
+          }, true);
+        });
+      })();
+    )";
+  }
+  
+  executeScript(script);
+}
+
+void Window::onNavigationStart(NavigationCallback callback) {
   pImpl->navigationCallback = callback;
 }
 
-void WebView::onNavigationComplete(LoadCallback callback) {
+void Window::onNavigationComplete(LoadCallback callback) {
   pImpl->navigationCompleteCallback = callback;
 }
 
-void WebView::onLoadStart(LoadCallback callback) {
+void Window::onLoadStart(LoadCallback callback) {
   pImpl->loadStartCallback = callback;
 }
 
-void WebView::onLoadEnd(LoadCallback callback) {
+void Window::onLoadEnd(LoadCallback callback) {
   pImpl->loadEndCallback = callback;
 }
 
-void WebView::onLoadError(ErrorCallback callback) {
+void Window::onLoadError(ErrorCallback callback) {
   pImpl->errorCallback = callback;
 }
 
-void WebView::onConsoleMessage(ConsoleCallback callback) {
+void Window::onConsoleMessage(ConsoleCallback callback) {
   pImpl->consoleCallback = callback;
 }
 
-bool WebView::isLoading() const { return pImpl->loading; }
+bool Window::isLoading() const { return pImpl->loading; }
 
-std::string WebView::getURL() const { return pImpl->currentURL; }
+std::string Window::getURL() const { return pImpl->currentURL; }
 
-std::string WebView::getTitle() const { return pImpl->currentTitle; }
+std::string Window::getTitle() const { return pImpl->currentTitle; }
 
-void *WebView::nativeHandle() const { return pImpl->nativeWebView; }
+void *Window::nativeHandle() const { return pImpl->nativeWebView; }
 
 } // namespace plusui

package/Core/Features/{WebView → Window}/webview.ts

@@ -20,6 +20,7 @@ export interface WebViewConfig {
   allowRemoteContent?: boolean;
   dataPath?: string;
   cacheSize?: number; // MB
+  disableWebviewDragDrop?: boolean; // Disable webview drag-drop (auto-set by WindowConfig.enableFileDrop)
 }
 
 export type WindowId = number;
@@ -71,6 +72,7 @@ export interface WebViewAPI {
   getZoom(): Promise<number>;
   setBackgroundColor(r: number, g: number, b: number, a?: number): Promise<void>;
   setScrollbarsVisible(visible: boolean): Promise<void>;
+  setWebviewDragDropEnabled(enabled: boolean): Promise<void>;  // Runtime toggle for webview drag-drop
 
   // CSS injection
   injectCSS(css: string): Promise<void>;
@@ -300,6 +302,10 @@ export class WebView implements WebViewAPI {
     await this.invokeFn('webview.setScrollbarsVisible', [visible]);
   }
 
+  async setWebviewDragDropEnabled(enabled: boolean): Promise<void> {
+    await this.invokeFn('webview.setWebviewDragDropEnabled', [enabled]);
+  }
+
   // CSS injection
   async injectCSS(css: string): Promise<void> {
     await this.invokeFn('webview.injectCSS', [css]);

package/Core/include/plusui/app.hpp

@@ -2,7 +2,7 @@
 #define PLUSUI_APP_H
 
 #include "tray.hpp"
-#include "webview.hpp"
+#include "window.hpp"
 #include "window_manager.hpp"
 #include <functional>
 #include <future>
@@ -42,6 +42,7 @@ public:
     bool decorations = true;
     bool skipTaskbar = false;
     bool scrollbars = true;
+    bool enableFileDrop = true;
   };
 
   Builder();
@@ -59,8 +60,9 @@ public:
   Builder &decorations(bool decorations);
   Builder &skipTaskbar(bool skip);
   Builder &scrollbars(bool show);
+  Builder &enableFileDrop(bool enable);
 
-  WebView build();
+  Window build();
 
 private:
   Config config;

package/Core/include/plusui/plusui.hpp

@@ -35,6 +35,5 @@
 #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/include/plusui/window.hpp

@@ -1,13 +1,19 @@
 #pragma once
 
 #include <functional>
+#include <future>
+#include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace plusui {
 
+class TrayManager;
+class WindowManager;
+
 struct WindowConfig {
+  // Window properties
   std::string title = "PlusUI Window";
   int x = -1;
   int y = -1;
@@ -29,6 +35,20 @@ struct WindowConfig {
   bool skipTaskbar = false;
   double opacity = 1.0;
   bool fullscreen = false;
+  bool enableFileDrop = true;  // Enable native FileDrop API (auto-disables webview drag-drop)
+  
+  // WebView properties
+  std::string userAgent = "";
+  bool devtools = true;
+  bool contextMenu = true;
+  bool javascript = true;
+  bool webSecurity = true;
+  bool allowFileAccess = false;
+  bool allowRemoteContent = true;
+  std::string dataPath = "";
+  int cacheSize = 100; // MB
+  bool scrollbars = true;  // Show/hide scrollbars
+  bool disableWebviewDragDrop = true;  // Disable webview drag-drop (usually set by enableFileDrop)
 };
 
 struct WindowState {
@@ -103,6 +123,83 @@ public:
 
   void *nativeHandle() const;
 
+  // WebView methods (content loading)
+  using StringCallback = std::function<void(const std::string &result)>;
+  using BoolCallback = std::function<bool(const std::string &url)>;
+  using ErrorCallback = std::function<void(const std::string &error, int code)>;
+  using ConsoleCallback = std::function<void(
+      const std::string &message, int level, const std::string &source)>;
+  using JSCallback = std::function<std::string(const std::string &args)>;
+  using NavigationCallback = std::function<bool(const std::string &url)>;
+  using LoadCallback = std::function<void()>;
+
+  void loadURL(const std::string &url);
+  void loadHTML(const std::string &html);
+  void loadHTML(const std::string &html, const std::string &baseURL);
+  void loadFile(const std::string &filePath);
+  void navigate(const std::string &url);
+
+  // Navigation
+  void reload();
+  void stop();
+  void goBack();
+  void goForward();
+  bool canGoBack() const;
+  bool canGoForward() const;
+
+  // Scripting
+  void executeScript(const std::string &script);
+  void executeScript(const std::string &script, StringCallback callback);
+  void eval(const std::string &js) {
+    executeScript(js);
+  } // Alias for compatibility
+
+  template <typename T> std::future<T> evaluate(const std::string &js) {
+    // Implementation in cpp or inline
+    return std::future<T>();
+  }
+
+  // Bindings
+  void bind(const std::string &name, JSCallback callback);
+  void unbind(const std::string &name);
+
+  template <typename F> void expose(const std::string &name, F &&callback) {
+    // Implementation for simplified expose
+  }
+
+  // Dev tools
+  void openDevTools();
+  void closeDevTools();
+
+  // Events
+  void on(const std::string &event,
+          std::function<void(const std::string &)> callback);
+  void emit(const std::string &event, const std::string &data = "");
+
+  // WebView settings
+  void setUserAgent(const std::string &userAgent);
+  std::string getUserAgent() const;
+  void setZoom(double factor);
+  double getZoom() const;
+  void injectCSS(const std::string &css);
+  void setWebviewDragDropEnabled(bool enabled);  // Enable/disable webview drag-drop at runtime
+
+  // WebView callbacks
+  void onNavigationStart(NavigationCallback callback);
+  void onNavigationComplete(LoadCallback callback);
+  void onLoadStart(LoadCallback callback);
+  void onLoadEnd(LoadCallback callback);
+  void onLoadError(ErrorCallback callback);
+  void onConsoleMessage(ConsoleCallback callback);
+
+  // WebView state
+  bool isLoading() const;
+  std::string getURL() const;
+
+  // Features
+  TrayManager &tray();
+  WindowManager &windowManager();
+
 private:
   struct Impl;
   std::shared_ptr<Impl> pImpl;

package/package.json

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

package/Core/include/plusui/webview.hpp

@@ -1,142 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <future>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace plusui {
-
-class TrayManager;
-class WindowManager;
-class Window;
-
-struct WebViewConfig {
-  std::string userAgent = "";
-  bool devtools = true;
-  bool contextMenu = true;
-  bool javascript = true;
-  bool webSecurity = true;
-  bool allowFileAccess = false;
-  bool allowRemoteContent = true;
-  std::string dataPath = "";
-  int cacheSize = 100; // MB
-  bool scrollbars = true;  // Show/hide scrollbars
-
-  // App Builder style config
-  std::string title;
-  int width = 800;
-  int height = 600;
-  bool resizable = true;
-};
-
-class WebView {
-public:
-  using WindowId = uint64_t;
-
-  // Callback types
-  using VoidCallback = std::function<void()>;
-  using StringCallback = std::function<void(const std::string &result)>;
-  using BoolCallback = std::function<bool(const std::string &url)>;
-  using ErrorCallback = std::function<void(const std::string &error, int code)>;
-  using ConsoleCallback = std::function<void(
-      const std::string &message, int level, const std::string &source)>;
-  using JSCallback = std::function<std::string(const std::string &args)>;
-  using NavigationCallback = std::function<bool(const std::string &url)>;
-  using LoadCallback = std::function<void()>;
-
-  WebView();
-  // Constructor used by App::Builder
-  struct AppConfig;
-  // WebView(const AppConfig& config); // We'll handle this via create or
-  // similar
-
-  ~WebView();
-
-  // Move only
-  WebView(WebView &&other) noexcept;
-  WebView &operator=(WebView &&other) noexcept;
-  WebView(const WebView &) = delete;
-  WebView &operator=(const WebView &) = delete;
-
-  static WebView create(void *windowHandle, const WebViewConfig &config = {});
-
-  // Content loading
-  void loadURL(const std::string &url);
-  void loadHTML(const std::string &html);
-  void loadHTML(const std::string &html, const std::string &baseURL);
-  void loadFile(const std::string &filePath);
-  void navigate(const std::string &url);
-
-  // Navigation
-  void reload();
-  void stop();
-  void goBack();
-  void goForward();
-  bool canGoBack() const;
-  bool canGoForward() const;
-
-  // Scripting
-  void executeScript(const std::string &script);
-  void executeScript(const std::string &script, StringCallback callback);
-  void eval(const std::string &js) {
-    executeScript(js);
-  } // Alias for compatibility
-
-  template <typename T> std::future<T> evaluate(const std::string &js) {
-    // Implementation in cpp or inline
-    return std::future<T>();
-  }
-
-  // Bindings
-  void bind(const std::string &name, JSCallback callback);
-  void unbind(const std::string &name);
-
-  template <typename F> void expose(const std::string &name, F &&callback) {
-    // Implementation for simplified expose
-  }
-
-  // Dev tools
-  void openDevTools();
-  void closeDevTools();
-
-  // Events
-  void on(const std::string &event,
-          std::function<void(const std::string &)> callback);
-  void emit(const std::string &event, const std::string &data = "");
-
-  // Settings
-  void setUserAgent(const std::string &userAgent);
-  std::string getUserAgent() const;
-  void setZoom(double factor);
-  double getZoom() const;
-  void injectCSS(const std::string &css);
-
-  // Callbacks
-  void onNavigationStart(NavigationCallback callback);
-  void onNavigationComplete(LoadCallback callback);
-  void onLoadStart(LoadCallback callback);
-  void onLoadEnd(LoadCallback callback);
-  void onLoadError(ErrorCallback callback);
-  void onConsoleMessage(ConsoleCallback callback);
-
-  // State
-  bool isLoading() const;
-  std::string getURL() const;
-  std::string getTitle() const;
-  void *nativeHandle() const;
-  void *nativeWindow() { return nativeHandle(); } // Alias
-
-  // Features
-  void setWindow(std::shared_ptr<Window> win);
-  TrayManager &tray();
-  WindowManager &window();
-
-private:
-  struct Impl;
-  std::shared_ptr<Impl> pImpl;
-};
-
-} // namespace plusui