plusui-native-core 0.1.105 → 0.1.106

package/Core/Features/FileDrop/filedrop.cpp

@@ -1,324 +1,448 @@
-#include <plusui/filedrop.hpp>
-#include <memory>
-#include <mutex>
-#include <filesystem>
-#include <fstream>
-#include <unordered_map>
-#include <cctype>
-
-#ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <shlobj.h>
-#include <objidl.h>
-#include <oleidl.h>
-#include <shellapi.h>
-#elif defined(__APPLE__)
-#include <AppKit/AppKit.h>
-#include <CoreFoundation/CoreFoundation.h>
-#else
-// Linux/GTK
-#include <gtk/gtk.h>
-#endif
-
-namespace PlusUI {
-
-struct FileDrop::Impl {
-    std::mutex mtx;
-    bool enabled = true;
-    std::function<void(const std::vector<FileInfo>&)> filesDroppedCallback;
-    std::function<void()> dragEnterCallback;
-    std::function<void()> dragLeaveCallback;
-
-#ifdef _WIN32
-    HWND hwnd = nullptr;
-#endif
-};
-
-FileDrop::FileDrop() : pImpl(new Impl()) {}
-
-FileDrop::~FileDrop() { delete pImpl; }
-
-void FileDrop::setEnabled(bool enabled) {
-    std::lock_guard<std::mutex> lock(pImpl->mtx);
-    pImpl->enabled = enabled;
-
-#ifdef _WIN32
-    if (pImpl->hwnd) {
-        DragAcceptFiles(pImpl->hwnd, enabled ? TRUE : FALSE);
-    }
-#endif
-}
-
-bool FileDrop::isEnabled() const {
-    std::lock_guard<std::mutex> lock(pImpl->mtx);
-    return pImpl->enabled;
-}
-
-void FileDrop::onFilesDropped(std::function<void(const std::vector<FileInfo>&)> callback) {
-    std::lock_guard<std::mutex> lock(pImpl->mtx);
-    pImpl->filesDroppedCallback = callback;
-}
-
-void FileDrop::onDragEnter(std::function<void()> callback) {
-    std::lock_guard<std::mutex> lock(pImpl->mtx);
-    pImpl->dragEnterCallback = callback;
-}
-
-void FileDrop::onDragLeave(std::function<void()> callback) {
-    std::lock_guard<std::mutex> lock(pImpl->mtx);
-    pImpl->dragLeaveCallback = callback;
-}
-
-bool FileDrop::startDrag(const std::vector<std::string>& filePaths) {
-    if (filePaths.empty()) {
-        return false;
-    }
-
-#ifdef _WIN32
-    // Windows drag source implementation
-    // This would create an IDropSource and IDataObject to initiate drag
-    // For now, return false as full implementation requires COM setup
-    return false;
-
-#elif defined(__APPLE__)
-    @autoreleasepool {
-        // macOS drag source implementation
-        NSMutableArray* items = [NSMutableArray arrayWithCapacity:filePaths.size()];
-        
-        for (const auto& path : filePaths) {
-            NSString* nsPath = [NSString stringWithUTF8String:path.c_str()];
-            NSURL* url = [NSURL fileURLWithPath:nsPath];
-            if (url) {
-                NSDraggingItem* item = [[NSDraggingItem alloc] initWithPasteboardWriter:url];
-                [items addObject:item];
-            }
-        }
-        
-        if ([items count] > 0) {
-            // Would need NSView reference to begin dragging session
-            return true;
-        }
-        return false;
-    }
-
-#else
-    // Linux/GTK drag source implementation
-    // Would use gtk_drag_begin_with_coordinates
-    return false;
-#endif
-}
-
-void FileDrop::clearCallbacks() {
-    std::lock_guard<std::mutex> lock(pImpl->mtx);
-    pImpl->filesDroppedCallback = nullptr;
-    pImpl->dragEnterCallback = nullptr;
-    pImpl->dragLeaveCallback = nullptr;
-}
-
-// Helper function to get MIME type from file extension
-static std::string getMimeType(const std::string& filePath) {
-    namespace fs = std::filesystem;
-    fs::path p(filePath);
-    std::string ext = p.extension().string();
-    
-    // Convert to lowercase
-    for (char& c : ext) {
-        c = tolower(c);
-    }
-    
-    // Common MIME types
-    static const std::unordered_map<std::string, std::string> mimeTypes = {
-        {".txt", "text/plain"},
-        {".html", "text/html"},
-        {".htm", "text/html"},
-        {".css", "text/css"},
-        {".js", "application/javascript"},
-        {".json", "application/json"},
-        {".xml", "application/xml"},
-        {".pdf", "application/pdf"},
-        {".zip", "application/zip"},
-        {".tar", "application/x-tar"},
-        {".gz", "application/gzip"},
-        {".7z", "application/x-7z-compressed"},
-        {".png", "image/png"},
-        {".jpg", "image/jpeg"},
-        {".jpeg", "image/jpeg"},
-        {".gif", "image/gif"},
-        {".bmp", "image/bmp"},
-        {".svg", "image/svg+xml"},
-        {".webp", "image/webp"},
-        {".ico", "image/x-icon"},
-        {".mp3", "audio/mpeg"},
-        {".wav", "audio/wav"},
-        {".ogg", "audio/ogg"},
-        {".mp4", "video/mp4"},
-        {".webm", "video/webm"},
-        {".avi", "video/x-msvideo"},
-        {".mkv", "video/x-matroska"},
-        {".ttf", "font/ttf"},
-        {".otf", "font/otf"},
-        {".woff", "font/woff"},
-        {".woff2", "font/woff2"},
-    };
-    
-    auto it = mimeTypes.find(ext);
-    if (it != mimeTypes.end()) {
-        return it->second;
-    }
-    
-    return "application/octet-stream";
-}
-
-// Platform-specific helper to handle dropped files
-#ifdef _WIN32
-// Windows implementation for handling WM_DROPFILES message
-void HandleDropFiles(bool enabled,
-                     const std::function<void(const std::vector<FileInfo>&)>& filesDroppedCallback,
-                     HDROP hDrop) {
-    if (!enabled || !filesDroppedCallback) {
-        return;
-    }
-
-    std::vector<FileInfo> files;
-    UINT fileCount = DragQueryFileW(hDrop, 0xFFFFFFFF, nullptr, 0);
-
-    for (UINT i = 0; i < fileCount; ++i) {
-        UINT pathLen = DragQueryFileW(hDrop, i, nullptr, 0);
-        std::wstring wpath(pathLen, L'\0');
-        DragQueryFileW(hDrop, i, &wpath[0], pathLen + 1);
-
-        // Convert wide string to UTF-8
-        int size = WideCharToMultiByte(CP_UTF8, 0, wpath.c_str(), -1, nullptr, 0, nullptr, nullptr);
-        std::string path(size - 1, '\0');
-        WideCharToMultiByte(CP_UTF8, 0, wpath.c_str(), -1, &path[0], size, nullptr, nullptr);
-
-        FileInfo info;
-        info.path = path;
-        
-        // Get file name
-        size_t lastSlash = path.find_last_of("\\/");
-        info.name = (lastSlash != std::string::npos) ? path.substr(lastSlash + 1) : path;
-        
-        // Get file size
-        WIN32_FILE_ATTRIBUTE_DATA fileAttr;
-        if (GetFileAttributesExW(wpath.c_str(), GetFileExInfoStandard, &fileAttr)) {
-            LARGE_INTEGER size;
-            size.HighPart = fileAttr.nFileSizeHigh;
-            size.LowPart = fileAttr.nFileSizeLow;
-            info.size = static_cast<std::uint64_t>(size.QuadPart);
-        } else {
-            info.size = 0;
-        }
-        
-        // Get MIME type
-        info.type = getMimeType(path);
-        
-        files.push_back(info);
-    }
-
-    DragFinish(hDrop);
-
-    if (!files.empty() && filesDroppedCallback) {
-        filesDroppedCallback(files);
-    }
-}
-#endif
-
-#ifdef __APPLE__
-// macOS implementation using NSPasteboard and drag&drop APIs
-// This would be implemented with Objective-C++ integration with NSView
-// For now, providing the interface structure
-void HandleMacDropFiles(bool enabled,
-                        const std::function<void(const std::vector<FileInfo>&)>& filesDroppedCallback,
-                        NSArray<NSURL*>* urls) {
-    if (!enabled || !filesDroppedCallback) {
-        return;
-    }
-
-    std::vector<FileInfo> files;
-    
-    for (NSURL* url in urls) {
-        if (![url isFileURL]) continue;
-        
-        NSString* path = [url path];
-        FileInfo info;
-        info.path = [path UTF8String];
-        info.name = [[path lastPathComponent] UTF8String];
-        
-        // Get file size
-        NSError* error = nil;
-        NSDictionary* attrs = [[NSFileManager defaultManager] attributesOfItemAtPath:path error:&error];
-        if (attrs) {
-            NSNumber* fileSize = [attrs objectForKey:NSFileSize];
-            info.size = [fileSize unsignedLongLongValue];
-        } else {
-            info.size = 0;
-        }
-        
-        // Get MIME type
-        info.type = getMimeType(info.path);
-        
-        files.push_back(info);
-    }
-    
-    if (!files.empty() && filesDroppedCallback) {
-        filesDroppedCallback(files);
-    }
-}
-#endif
-
-#ifdef __linux__
-// Linux/GTK implementation
-void HandleGtkDropFiles(bool enabled,
-                        const std::function<void(const std::vector<FileInfo>&)>& filesDroppedCallback,
-                        GtkSelectionData* data) {
-    if (!enabled || !filesDroppedCallback) {
-        return;
-    }
-
-    std::vector<FileInfo> files;
-    gchar** uris = gtk_selection_data_get_uris(data);
-    
-    if (uris) {
-        for (int i = 0; uris[i] != nullptr; ++i) {
-            GFile* file = g_file_new_for_uri(uris[i]);
-            gchar* path = g_file_get_path(file);
-            
-            if (path) {
-                FileInfo info;
-                info.path = path;
-                
-                gchar* basename = g_file_get_basename(file);
-                info.name = basename;
-                g_free(basename);
-                
-                // Get file size
-                GFileInfo* fileInfo = g_file_query_info(file, G_FILE_ATTRIBUTE_STANDARD_SIZE,
-                                                       G_FILE_QUERY_INFO_NONE, nullptr, nullptr);
-                if (fileInfo) {
-                    info.size = g_file_info_get_size(fileInfo);
-                    g_object_unref(fileInfo);
-                } else {
-                    info.size = 0;
-                }
-                
-                // Get MIME type
-                info.type = getMimeType(info.path);
-                
-                files.push_back(info);
-                g_free(path);
-            }
-            
-            g_object_unref(file);
-        }
-        g_strfreev(uris);
-    }
-    
-    if (!files.empty() && filesDroppedCallback) {
-        filesDroppedCallback(files);
-    }
-}
-#endif
-
-} // namespace PlusUI
+#include <plusui/filedrop.hpp>
+#include <plusui/window.hpp>
+#include <memory>
+#include <mutex>
+#include <filesystem>
+#include <fstream>
+#include <unordered_map>
+#include <cctype>
+#include <iostream>
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <shlobj.h>
+#include <objidl.h>
+#include <oleidl.h>
+#include <shellapi.h>
+#elif defined(__APPLE__)
+#include <AppKit/AppKit.h>
+#include <CoreFoundation/CoreFoundation.h>
+#import <WebKit/WebKit.h>
+#else
+// Linux/GTK
+#include <gtk/gtk.h>
+#include <webkit2/webkit2.h>
+#endif
+
+namespace plusui {
+
+static std::string jsonEscape(const std::string &input) {
+  std::string out;
+  out.reserve(input.size() + 8);
+  for (char c : input) {
+    switch (c) {
+    case '\\': out += "\\\\"; break;
+    case '"': out += "\\\""; break;
+    case '\n': out += "\\n"; break;
+    case '\r': out += "\\r"; break;
+    case '\t': out += "\\t"; break;
+    default: out += c; break;
+    }
+  }
+  return out;
+}
+
+static std::string mimeTypeFromPath(const std::string &path) {
+  size_t dot = path.find_last_of(".");
+  if (dot == std::string::npos) return "application/octet-stream";
+  std::string ext = path.substr(dot + 1);
+  for (char &c : ext) c = (char)tolower(c);
+  if (ext == "png") return "image/png";
+  if (ext == "jpg" || ext == "jpeg") return "image/jpeg";
+  if (ext == "gif") return "image/gif";
+  if (ext == "html" || ext == "htm") return "text/html";
+  if (ext == "js") return "application/javascript";
+  if (ext == "json") return "application/json";
+  if (ext == "css") return "text/css";
+  if (ext == "txt" || ext == "md") return "text/plain";
+  if (ext == "svg") return "image/svg+xml";
+  if (ext == "pdf") return "application/pdf";
+  if (ext == "zip") return "application/zip";
+  return "application/octet-stream";
+}
+
+struct FileDrop::Impl {
+    std::mutex mtx;
+    bool enabled = true;
+    std::function<void(const std::vector<FileInfo>&)> filesDroppedCallback;
+    std::function<void()> dragEnterCallback;
+    std::function<void()> dragLeaveCallback;
+    void* nativeWindowHandle = nullptr;
+    void* nativeWebViewHandle = nullptr;
+
+#ifdef _WIN32
+    void* dropTarget = nullptr;
+#elif defined(__APPLE__)
+    // macOS specific drag context
+#elif defined(__linux__)
+    struct DropCtx {
+        WebKitWebView *wv;
+        bool entered = false;
+        gint x = 0, y = 0;
+    };
+    DropCtx* dc = nullptr;
+#endif
+};
+
+FileDrop::FileDrop() : pImpl(new Impl()) {}
+
+FileDrop::~FileDrop() {
+#ifdef __linux__
+    if (pImpl->dc) delete pImpl->dc;
+#endif
+    delete pImpl;
+}
+
+#ifdef _WIN32
+class FileDropTarget : public IDropTarget {
+    HWND m_hwnd;
+    void* m_webview;
+    ULONG m_refCount;
+    bool m_hasFiles;
+
+public:
+    FileDropTarget(HWND hwnd, void* webview) : m_hwnd(hwnd), m_webview(webview), m_refCount(1), m_hasFiles(false) {}
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject) override {
+        if (riid == IID_IUnknown || riid == IID_IDropTarget) {
+            *ppvObject = this;
+            AddRef();
+            return S_OK;
+        }
+        *ppvObject = nullptr;
+        return E_NOINTERFACE;
+    }
+    ULONG STDMETHODCALLTYPE AddRef() override { return InterlockedIncrement(&m_refCount); }
+    ULONG STDMETHODCALLTYPE Release() override {
+        ULONG ref = InterlockedDecrement(&m_refCount);
+        if (ref == 0) delete this;
+        return ref;
+    }
+
+    void screenToCSS(POINTL pt, int &cssX, int &cssY) {
+        POINT ptClient = {pt.x, pt.y};
+        ScreenToClient(m_hwnd, &ptClient);
+        
+        double dpiScale = 1.0;
+        UINT dpi = GetDpiForWindow(m_hwnd);
+        if (dpi > 0) dpiScale = static_cast<double>(dpi) / 96.0;
+        
+        cssX = static_cast<int>(ptClient.x / dpiScale);
+        cssY = static_cast<int>(ptClient.y / dpiScale);
+    }
+
+    bool hasFiles(IDataObject *pDataObj) {
+        if (!pDataObj) return false;
+        FORMATETC fmt = {CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
+        return pDataObj->QueryGetData(&fmt) == S_OK;
+    }
+
+    void execScript(const std::string &js) {
+        if (m_webview) {
+            std::wstring wjs(js.begin(), js.end());
+            ((ICoreWebView2*)m_webview)->ExecuteScript(wjs.c_str(), nullptr);
+        }
+    }
+
+    HRESULT STDMETHODCALLTYPE DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override {
+        m_hasFiles = hasFiles(pDataObj);
+        if (m_hasFiles) {
+            *pdwEffect = DROPEFFECT_COPY;
+            int cssX, cssY;
+            screenToCSS(pt, cssX, cssY);
+            execScript(
+                "(function(){"
+                "var el=document.elementFromPoint(" + std::to_string(cssX) + "," + std::to_string(cssY) + ");"
+                "var zone=el&&el.closest?el.closest('[data-dropzone]'):null;"
+                "document.querySelectorAll('.dropzone-active,.filedrop-active')"
+                ".forEach(function(z){if(z!==zone){z.classList.remove('dropzone-active');"
+                "z.classList.remove('filedrop-active');}});"
+                "if(zone){zone.classList.add('dropzone-active');zone.classList.add('filedrop-active');}"
+                "})();"
+            );
+        } else {
+            *pdwEffect = DROPEFFECT_NONE;
+        }
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override {
+        if (m_hasFiles) {
+            *pdwEffect = DROPEFFECT_COPY;
+            int cssX, cssY;
+            screenToCSS(pt, cssX, cssY);
+            execScript(
+                "(function(){"
+                "var el=document.elementFromPoint(" + std::to_string(cssX) + "," + std::to_string(cssY) + ");"
+                "var zone=el&&el.closest?el.closest('[data-dropzone]'):null;"
+                "document.querySelectorAll('.dropzone-active,.filedrop-active')"
+                ".forEach(function(z){if(z!==zone){z.classList.remove('dropzone-active');"
+                "z.classList.remove('filedrop-active');}});"
+                "if(zone){zone.classList.add('dropzone-active');zone.classList.add('filedrop-active');}"
+                "})();"
+            );
+        } else {
+            *pdwEffect = DROPEFFECT_NONE;
+        }
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE DragLeave() override {
+        execScript(
+            "(function(){"
+            "document.querySelectorAll('.dropzone-active,.filedrop-active')"
+            ".forEach(function(z){z.classList.remove('dropzone-active');"
+            "z.classList.remove('filedrop-active');});"
+            "})();"
+        );
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE Drop(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override {
+        if (!pDataObj || !m_executeScript) return E_FAIL;
+
+        FORMATETC fmt = {CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
+        STGMEDIUM stg = {};
+        
+        if (pDataObj->GetData(&fmt, &stg) != S_OK) return E_FAIL;
+
+        HDROP hDrop = static_cast<HDROP>(stg.hGlobal);
+        std::string filesJson = "[";
+        UINT fileCount = DragQueryFileW(hDrop, 0xFFFFFFFF, nullptr, 0);
+
+        for (UINT i = 0; i < fileCount; ++i) {
+            UINT pathLen = DragQueryFileW(hDrop, i, nullptr, 0);
+            std::wstring wpath(pathLen + 1, L'\0');
+            DragQueryFileW(hDrop, i, &wpath[0], pathLen + 1);
+            wpath.resize(pathLen);
+
+            int utf8Len = WideCharToMultiByte(CP_UTF8, 0, wpath.c_str(), -1, nullptr, 0, nullptr, nullptr);
+            std::string path;
+            if (utf8Len > 0) {
+                path.resize(static_cast<size_t>(utf8Len - 1));
+                WideCharToMultiByte(CP_UTF8, 0, wpath.c_str(), -1, &path[0], utf8Len, nullptr, nullptr);
+            }
+
+            std::string name = path;
+            size_t lastSlash = path.find_last_of("\\/");
+            if (lastSlash != std::string::npos) name = path.substr(lastSlash + 1);
+
+            unsigned long long sizeBytes = 0;
+            WIN32_FILE_ATTRIBUTE_DATA fileAttr;
+            if (GetFileAttributesExW(wpath.c_str(), GetFileExInfoStandard, &fileAttr)) {
+                ULARGE_INTEGER size;
+                size.HighPart = fileAttr.nFileSizeHigh;
+                size.LowPart = fileAttr.nFileSizeLow;
+                sizeBytes = size.QuadPart;
+            }
+
+            if (i > 0) filesJson += ",";
+            filesJson += "{\"path\":\"" + jsonEscape(path) + "\",\"name\":\"" +
+                         jsonEscape(name) + "\",\"type\":\"" +
+                         jsonEscape(mimeTypeFromPath(path)) +
+                         "\",\"size\":" + std::to_string(sizeBytes) + "}";
+        }
+        filesJson += "]";
+        ReleaseStgMedium(&stg);
+
+        int cssX, cssY;
+        screenToCSS(pt, cssX, cssY);
+
+        std::string eventScript =
+            "(function(){"
+            "var files=" + filesJson + ";"
+            "document.querySelectorAll('.dropzone-active,.filedrop-active')"
+            ".forEach(function(z){z.classList.remove('dropzone-active');"
+            "z.classList.remove('filedrop-active');});"
+            "window.dispatchEvent(new CustomEvent('plusui:fileDrop.filesDropped',"
+            " { detail: { files: files } }));"
+            "var el=document.elementFromPoint(" + std::to_string(cssX) + "," + std::to_string(cssY) + ");"
+            "var zone=el&&el.closest?el.closest('[data-dropzone]'):null;"
+            "var zoneName=zone?zone.getAttribute('data-dropzone'):null;"
+            "if(zoneName&&window.__plusui_fileDrop__){"
+            "window.__plusui_fileDrop__(zoneName,files);"
+            "}"
+            "})();";
+
+        execScript(eventScript);
+        *pdwEffect = DROPEFFECT_COPY;
+        return S_OK;
+    }
+};
+#endif
+
+void FileDrop::attach(void* nativeWindowHandle, void* nativeWebViewHandle) {
+    pImpl->nativeWindowHandle = nativeWindowHandle;
+    pImpl->nativeWebViewHandle = nativeWebViewHandle;
+    if (!pImpl->enabled) return;
+
+#ifdef _WIN32
+    HWND hwnd = static_cast<HWND>(nativeWindowHandle);
+    DragAcceptFiles(hwnd, TRUE);
+    FileDropTarget* target = new FileDropTarget(hwnd, nativeWebViewHandle);
+    pImpl->dropTarget = target;
+    RegisterDragDrop(hwnd, target);
+
+#elif defined(__APPLE__)
+    // We let the objective-c wrapper handle this via PlusUIView
+    // No need to redeclare standard drag drops here if it requires subclassing
+#elif defined(__linux__)
+    WebKitWebView* webView = static_cast<WebKitWebView*>(nativeWebViewHandle);
+    if (!webView) return;
+
+    gtk_drag_dest_set(GTK_WIDGET(webView), GTK_DEST_DEFAULT_ALL, nullptr, 0, GDK_ACTION_COPY);
+    gtk_drag_dest_add_uri_targets(GTK_WIDGET(webView));
+
+    pImpl->dc = new Impl::DropCtx{webView, false, 0, 0};
+
+    // drag-motion
+    static auto sDragMotion = +[](GtkWidget *, GdkDragContext *ctx, gint x, gint y, guint time, gpointer data) -> gboolean {
+        auto *dc = static_cast<Impl::DropCtx *>(data);
+        dc->x = x; dc->y = y;
+        if (!dc->entered) {
+            dc->entered = true;
+        }
+        gdk_drag_status(ctx, GDK_ACTION_COPY, time);
+        
+        std::string script = "(function(){"
+            "var el=document.elementFromPoint(" + std::to_string(x) + "," + std::to_string(y) + ");"
+            "var zone=el&&el.closest?el.closest('[data-dropzone]'):null;"
+            "document.querySelectorAll('.dropzone-active,.filedrop-active')"
+            ".forEach(function(z){if(z!==zone){z.classList.remove('dropzone-active');"
+            "z.classList.remove('filedrop-active');}});"
+            "if(zone){zone.classList.add('dropzone-active');zone.classList.add('filedrop-active');}"
+            "})();";
+        webkit_web_view_run_javascript(dc->wv, script.c_str(), nullptr, nullptr, nullptr);
+        
+        return TRUE;
+    };
+    g_signal_connect(GTK_WIDGET(webView), "drag-motion", G_CALLBACK(sDragMotion), pImpl->dc);
+
+    // drag-leave
+    static auto sDragLeave = +[](GtkWidget *, GdkDragContext *, guint, gpointer data) -> void {
+        auto *dc = static_cast<Impl::DropCtx *>(data);
+        dc->entered = false;
+        std::string script = "(function(){"
+            "document.querySelectorAll('.dropzone-active,.filedrop-active')"
+            ".forEach(function(z){z.classList.remove('dropzone-active');"
+            "z.classList.remove('filedrop-active');});})();";
+        webkit_web_view_run_javascript(dc->wv, script.c_str(), nullptr, nullptr, nullptr);
+    };
+    g_signal_connect(GTK_WIDGET(webView), "drag-leave", G_CALLBACK(sDragLeave), pImpl->dc);
+
+    // drag-drop
+    static auto sDragDrop = +[](GtkWidget *widget, GdkDragContext *ctx, gint x, gint y, guint time, gpointer data) -> gboolean {
+        auto *dc = static_cast<Impl::DropCtx *>(data);
+        dc->x = x; dc->y = y;
+        GdkAtom target = gtk_drag_dest_find_target(widget, ctx, nullptr);
+        if (target == GDK_NONE) { gtk_drag_finish(ctx, FALSE, FALSE, time); return TRUE; }
+        gtk_drag_get_data(widget, ctx, target, time);
+        return TRUE;
+    };
+    g_signal_connect(GTK_WIDGET(webView), "drag-drop", G_CALLBACK(sDragDrop), pImpl->dc);
+
+    // drag-data-received
+    static auto sDragDataRcv = +[](GtkWidget *, GdkDragContext *ctx, gint, gint, GtkSelectionData *sel, guint, guint time, gpointer data) -> void {
+        auto *dc = static_cast<Impl::DropCtx *>(data);
+        dc->entered = false;
+        gchar **uris = gtk_selection_data_get_uris(sel);
+        if (!uris) { gtk_drag_finish(ctx, FALSE, FALSE, time); return; }
+
+        std::string filesJson = "[";
+        bool first = true;
+        for (int i = 0; uris[i]; ++i) {
+            GFile *gf = g_file_new_for_uri(uris[i]);
+            gchar *path = g_file_get_path(gf);
+            if (!path) { g_object_unref(gf); continue; }
+
+            GFileInfo *fi = g_file_query_info(gf, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NONE, nullptr, nullptr);
+            guint64 fsize = fi ? (guint64)g_file_info_get_size(fi) : 0;
+            if (fi) g_object_unref(fi);
+
+            std::string fp(path);
+            std::string nm = fp.substr(fp.rfind('/') + 1);
+
+            gboolean uncertain = FALSE;
+            gchar *ct = g_content_type_guess(path, nullptr, 0, &uncertain);
+            std::string mime = ct ? std::string(ct) : "application/octet-stream";
+            g_free(ct); g_free(path); g_object_unref(gf);
+
+            if (!first) filesJson += ",";
+            filesJson += "{\"path\":\"" + jsonEscape(fp) + "\","
+                         "\"name\":\"" + jsonEscape(nm) + "\","
+                         "\"type\":\"" + jsonEscape(mime) + "\","
+                         "\"size\":" + std::to_string(fsize) + "}";
+            first = false;
+        }
+        filesJson += "]";
+        g_strfreev(uris);
+        if (first) { gtk_drag_finish(ctx, FALSE, FALSE, time); return; }
+
+        gint x = dc->x, y = dc->y;
+        std::string script =
+            "(function(){"
+            "var files=" + filesJson + ";"
+            "document.querySelectorAll('.dropzone-active,.filedrop-active')"
+            ".forEach(function(z){z.classList.remove('dropzone-active');"
+            "z.classList.remove('filedrop-active');});"
+            "window.dispatchEvent(new CustomEvent('plusui:fileDrop.filesDropped',"
+            " { detail: { files: files } }));"
+            "var el=document.elementFromPoint(" + std::to_string(x) + "," + std::to_string(y) + ");"
+            "var zone=el&&el.closest?el.closest('[data-dropzone]'):null;"
+            "var zoneName=zone?zone.getAttribute('data-dropzone'):null;"
+            "if(zoneName&&window.__plusui_fileDrop__){"
+            "window.__plusui_fileDrop__(zoneName,files);"
+            "}"
+            "})();";
+        
+        webkit_web_view_run_javascript(dc->wv, script.c_str(), nullptr, nullptr, nullptr);
+        gtk_drag_finish(ctx, TRUE, FALSE, time);
+    };
+    g_signal_connect(GTK_WIDGET(webView), "drag-data-received", G_CALLBACK(sDragDataRcv), pImpl->dc);
+#endif
+}
+
+void FileDrop::setEnabled(bool enabled) {
+    std::lock_guard<std::mutex> lock(pImpl->mtx);
+    pImpl->enabled = enabled;
+#ifdef _WIN32
+    if (pImpl->nativeWindowHandle) {
+        DragAcceptFiles(static_cast<HWND>(pImpl->nativeWindowHandle), enabled ? TRUE : FALSE);
+    }
+#endif
+}
+
+bool FileDrop::isEnabled() const {
+    std::lock_guard<std::mutex> lock(pImpl->mtx);
+    return pImpl->enabled;
+}
+
+void FileDrop::onFilesDropped(std::function<void(const std::vector<FileInfo>&)> callback) {
+    std::lock_guard<std::mutex> lock(pImpl->mtx);
+    pImpl->filesDroppedCallback = callback;
+}
+
+void FileDrop::onDragEnter(std::function<void()> callback) {
+    std::lock_guard<std::mutex> lock(pImpl->mtx);
+    pImpl->dragEnterCallback = callback;
+}
+
+void FileDrop::onDragLeave(std::function<void()> callback) {
+    std::lock_guard<std::mutex> lock(pImpl->mtx);
+    pImpl->dragLeaveCallback = callback;
+}
+
+bool FileDrop::startDrag(const std::vector<std::string>& filePaths) {
+    if (filePaths.empty()) return false;
+    return false;
+}
+
+void FileDrop::clearCallbacks() {
+    std::lock_guard<std::mutex> lock(pImpl->mtx);
+    pImpl->filesDroppedCallback = nullptr;
+    pImpl->dragEnterCallback = nullptr;
+    pImpl->dragLeaveCallback = nullptr;
+}
+
+} // namespace plusui