windowpp 0.1.1

package/framework/src/common/paths.cpp

@@ -0,0 +1,75 @@
+// ============================================================================
+//  paths.cpp — Cross-platform app data / user data directory helpers
+// ============================================================================
+
+#include <windowpp/windowpp.h>
+
+#if defined(_WIN32)
+#  include <windows.h>
+#  include <shlobj.h>       // SHGetKnownFolderPath
+#  pragma comment(lib, "shell32.lib")
+#elif defined(__APPLE__)
+#  include <sys/types.h>
+#  include <pwd.h>
+#  include <unistd.h>
+#else  // Linux / BSD
+#  include <cstdlib>
+#  include <sys/types.h>
+#  include <pwd.h>
+#  include <unistd.h>
+#endif
+
+#include <string>
+
+namespace wpp {
+namespace paths {
+
+std::string app_data_dir(const std::string& app_name) {
+    std::string base;
+
+#if defined(_WIN32)
+    // %APPDATA%  →  C:\Users\<user>\AppData\Roaming
+    PWSTR path_ptr = nullptr;
+    if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_RoamingAppData,
+                                        KF_FLAG_CREATE, nullptr, &path_ptr))) {
+        // Convert wide to UTF-8
+        int len = WideCharToMultiByte(CP_UTF8, 0, path_ptr, -1,
+                                      nullptr, 0, nullptr, nullptr);
+        base.resize(len > 0 ? len - 1 : 0);
+        if (len > 0)
+            WideCharToMultiByte(CP_UTF8, 0, path_ptr, -1,
+                                &base[0], len, nullptr, nullptr);
+        CoTaskMemFree(path_ptr);
+    }
+    return base.empty() ? app_name : base + "\\" + app_name;
+
+#elif defined(__APPLE__)
+    // ~/Library/Application Support/<AppName>
+    const char* home = std::getenv("HOME");
+    if (!home) {
+        struct passwd* wpp = getpwuid(getuid());
+        if (wpp) home = wpp->wpp_dir;
+    }
+    if (home)
+        return std::string(home) + "/Library/Application Support/" + app_name;
+    return app_name;
+
+#else
+    // $XDG_DATA_HOME/<AppName>  or  ~/.local/share/<AppName>
+    const char* xdg = std::getenv("XDG_DATA_HOME");
+    if (xdg && *xdg)
+        return std::string(xdg) + "/" + app_name;
+
+    const char* home = std::getenv("HOME");
+    if (!home) {
+        struct passwd* wpp = getpwuid(getuid());
+        if (wpp) home = wpp->wpp_dir;
+    }
+    if (home)
+        return std::string(home) + "/.local/share/" + app_name;
+    return app_name;
+#endif
+}
+
+} // namespace paths
+} // namespace wpp

package/framework/src/filedrop/filedrop.cpp

@@ -0,0 +1,316 @@
+#include <wpp/filedrop.hpp>
+#include <wpp/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 wpp {
+
+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;
+    ULONG m_refCount;
+    bool m_hasFiles;
+    double m_dpiScale;
+    std::function<void(const std::vector<FileInfo>&, int, int)> m_onDrop;
+    std::function<void(int, int)> m_onDragEnter;
+    std::function<void(int, int)> m_onDragOver;
+    std::function<void()> m_onDragLeave;
+
+public:
+    FileDropTarget(HWND hwnd) : m_hwnd(hwnd), m_refCount(1), m_hasFiles(false), m_dpiScale(1.0) {}
+
+    void setCallbacks(
+        std::function<void(const std::vector<FileInfo>&, int, int)> onDrop,
+        std::function<void(int, int)> onDragEnter,
+        std::function<void(int, int)> onDragOver,
+        std::function<void()> onDragLeave
+    ) {
+        m_onDrop = onDrop;
+        m_onDragEnter = onDragEnter;
+        m_onDragOver = onDragOver;
+        m_onDragLeave = onDragLeave;
+    }
+
+    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);
+        cssX = static_cast<int>(ptClient.x / m_dpiScale);
+        cssY = static_cast<int>(ptClient.y / m_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;
+    }
+
+    HRESULT STDMETHODCALLTYPE DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override {
+        m_hasFiles = hasFiles(pDataObj);
+        UINT dpi = GetDpiForWindow(m_hwnd);
+        m_dpiScale = (dpi > 0) ? static_cast<double>(dpi) / 96.0 : 1.0;
+        if (m_hasFiles) {
+            *pdwEffect = DROPEFFECT_COPY;
+            if (m_onDragEnter) {
+                int cssX, cssY;
+                screenToCSS(pt, cssX, cssY);
+                m_onDragEnter(cssX, cssY);
+            }
+        } else {
+            *pdwEffect = DROPEFFECT_NONE;
+        }
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override {
+        if (m_hasFiles) {
+            *pdwEffect = DROPEFFECT_COPY;
+            if (m_onDragOver) {
+                int cssX, cssY;
+                screenToCSS(pt, cssX, cssY);
+                m_onDragOver(cssX, cssY);
+            }
+        } else {
+            *pdwEffect = DROPEFFECT_NONE;
+        }
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE DragLeave() override {
+        if (m_onDragLeave) {
+            m_onDragLeave();
+        }
+        return S_OK;
+    }
+
+    HRESULT STDMETHODCALLTYPE Drop(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) override {
+        if (!pDataObj) 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::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 + 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;
+            }
+
+            FileInfo fi;
+            fi.path = path;
+            fi.name = name;
+            fi.type = mimeTypeFromPath(path);
+            fi.size = sizeBytes;
+            files.push_back(fi);
+        }
+        ReleaseStgMedium(&stg);
+
+        int cssX, cssY;
+        screenToCSS(pt, cssX, cssY);
+
+        if (m_onDrop) {
+            m_onDrop(files, cssX, cssY);
+        }
+
+        *pdwEffect = DROPEFFECT_COPY;
+        return S_OK;
+    }
+};
+#endif
+
+void FileDrop::attach(void* nativeWindowHandle) {
+    pImpl->nativeWindowHandle = nativeWindowHandle;
+    if (!pImpl->enabled) return;
+
+#ifdef _WIN32
+    HWND hwnd = static_cast<HWND>(nativeWindowHandle);
+    DragAcceptFiles(hwnd, TRUE);
+    FileDropTarget* target = new FileDropTarget(hwnd);
+    
+    auto onDrop = [this](const std::vector<FileInfo>& files, int cssX, int cssY) {
+        if (pImpl->filesDroppedCallback) {
+            pImpl->filesDroppedCallback(files);
+        }
+    };
+    
+    auto onDragEnter = [this](int cssX, int cssY) {
+        if (pImpl->dragEnterCallback) {
+            pImpl->dragEnterCallback();
+        }
+    };
+    
+    auto onDragLeave = [this]() {
+        if (pImpl->dragLeaveCallback) {
+            pImpl->dragLeaveCallback();
+        }
+    };
+    
+    target->setCallbacks(onDrop, onDragEnter, {}, onDragLeave);
+    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__)
+    // Linux implementation without WebKit - would need custom IPC
+    (void)nativeWindowHandle;
+#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 wpp