windowpp 0.1.1

package/framework/src/platform/win32/tray_win32.h

@@ -0,0 +1,30 @@
+// ============================================================================
+//  tray_win32.h — Win32 System Tray implementation
+// ============================================================================
+
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#include <shellapi.h>
+#include <windowpp/windowpp.h>
+
+namespace wpp {
+
+class Win32Tray {
+public:
+    Win32Tray(const TrayConfig& config, HWND app_hwnd);
+    ~Win32Tray();
+
+private:
+    TrayConfig config_;
+    HWND app_hwnd_;
+    NOTIFYICONDATAW nid_;
+    HMENU menu_;
+
+    void update_menu();
+    static LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
+};
+
+} // namespace wpp

package/framework/src/platform/win32/win32_helpers.h

@@ -0,0 +1,61 @@
+// ============================================================================
+//  win32_helpers.h — Win32 helper utilities
+// ============================================================================
+
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#include <dwmapi.h>
+#include <string>
+
+namespace wpp {
+namespace win32 {
+
+inline std::wstring to_wide(const std::string& str) {
+    if (str.empty()) return {};
+    int size = MultiByteToWideChar(CP_UTF8, 0, str.data(), (int)str.size(), nullptr, 0);
+    std::wstring result(size, 0);
+    MultiByteToWideChar(CP_UTF8, 0, str.data(), (int)str.size(), result.data(), size);
+    return result;
+}
+
+inline std::string from_wide(const std::wstring& wstr) {
+    if (wstr.empty()) return {};
+    int size = WideCharToMultiByte(CP_UTF8, 0, wstr.data(), (int)wstr.size(), nullptr, 0, nullptr, nullptr);
+    std::string result(size, 0);
+    WideCharToMultiByte(CP_UTF8, 0, wstr.data(), (int)wstr.size(), result.data(), size, nullptr, nullptr);
+    return result;
+}
+
+struct WindowClass {
+    WNDCLASSEXW wc = {};
+    ATOM atom = 0;
+
+    WindowClass(const std::string& name, WNDPROC proc) {
+        wc.cbSize = sizeof(WNDCLASSEXW);
+        wc.style = CS_HREDRAW | CS_VREDRAW;
+        wc.lpfnWndProc = proc;
+        wc.hInstance = GetModuleHandleW(nullptr);
+        wc.hCursor = LoadCursorW(nullptr, IDC_ARROW);
+        std::wstring wname = to_wide(name);
+        wc.lpszClassName = wname.c_str();
+        atom = RegisterClassExW(&wc);
+    }
+
+    ~WindowClass() {
+        if (atom) UnregisterClassW(MAKEINTATOM(atom), GetModuleHandleW(nullptr));
+    }
+};
+
+inline void set_window_long_ptr(HWND hwnd, int index, LONG_PTR value) {
+    SetWindowLongPtrW(hwnd, index, value);
+}
+
+inline LONG_PTR get_window_long_ptr(HWND hwnd, int index) {
+    return GetWindowLongPtrW(hwnd, index);
+}
+
+} // namespace win32
+} // namespace wpp

package/framework/src/platform/win32/window_win32.cpp

@@ -0,0 +1,267 @@
+// ============================================================================
+//  window_win32.cpp — Win32 Window implementation
+// ============================================================================
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include "window_win32.h"
+#include "win32_helpers.h"
+#include <algorithm>
+
+namespace wpp {
+
+namespace {
+
+constexpr wchar_t kWindowPPProp[] = L"WPP_WIN32_WINDOW_PTR";
+
+}
+
+Win32Window::Win32Window(const WindowConfig& config, HWND hwnd)
+    : config_(config), hwnd_(hwnd) {
+    if (hwnd_) {
+        SetPropW(hwnd_, kWindowPPProp, this);
+    }
+}
+
+Win32Window::~Win32Window() {
+    if (hwnd_ && IsWindow(hwnd_)) {
+        RemovePropW(hwnd_, kWindowPPProp);
+    }
+    if (hwnd_ && IsWindow(hwnd_)) {
+        DestroyWindow(hwnd_);
+    }
+}
+
+std::string Win32Window::title() const {
+    wchar_t buf[512];
+    GetWindowTextW(hwnd_, buf, 512);
+    return win32::from_wide(buf);
+}
+
+Size Win32Window::size() const {
+    RECT r;
+    GetWindowRect(hwnd_, &r);
+    return { (int)(r.right - r.left), (int)(r.bottom - r.top) };
+}
+
+Point Win32Window::position() const {
+    RECT r;
+    GetWindowRect(hwnd_, &r);
+    return { (int)r.left, (int)r.top };
+}
+
+WindowState Win32Window::state() const {
+    if (!IsWindowVisible(hwnd_)) return WindowState::Hidden;
+    WINDOWPLACEMENT wpp = {};
+    wpp.length = sizeof(wpp);
+    GetWindowPlacement(hwnd_, &wpp);
+    switch (wpp.showCmd) {
+        case SW_SHOWMAXIMIZED: return WindowState::Maximized;
+        case SW_SHOWMINIMIZED: return WindowState::Minimized;
+        default: return WindowState::Normal;
+    }
+}
+
+bool Win32Window::is_visible() const {
+    return IsWindowVisible(hwnd_) != 0;
+}
+
+bool Win32Window::is_focused() const {
+    return GetForegroundWindow() == hwnd_;
+}
+
+float Win32Window::scale_factor() const {
+    UINT dpi = GetDpiForWindow(hwnd_);
+    return dpi / 96.0f;
+}
+
+void Win32Window::set_title(const std::string& title) {
+    SetWindowTextW(hwnd_, win32::to_wide(title).c_str());
+}
+
+void Win32Window::set_size(int w, int h) {
+    SetWindowPos(hwnd_, nullptr, 0, 0, w, h, SWPP_NOZORDER | SWPP_NOMOVE);
+}
+
+void Win32Window::set_position(int x, int y) {
+    SetWindowPos(hwnd_, nullptr, x, y, 0, 0, SWPP_NOZORDER | SWPP_NOSIZE);
+}
+
+void Win32Window::set_min_size(int w, int h) {
+    config_.min_width = w;
+    config_.min_height = h;
+}
+
+void Win32Window::set_max_size(int w, int h) {
+    config_.max_width = w;
+    config_.max_height = h;
+}
+
+void Win32Window::set_resizable(bool v) {
+    config_.resizable = v;
+    if (v) {
+        SetWindowLongPtr(hwnd_, GWL_STYLE,
+            GetWindowLongPtr(hwnd_, GWL_STYLE) | WS_THICKFRAME);
+    } else {
+        SetWindowLongPtr(hwnd_, GWL_STYLE,
+            GetWindowLongPtr(hwnd_, GWL_STYLE) & ~WS_THICKFRAME);
+    }
+}
+
+void Win32Window::set_always_on_top(bool v) {
+    SetWindowPos(hwnd_, v ? HWND_TOPMOST : HWND_NOTOPMOST,
+                 0, 0, 0, 0, SWPP_NOMOVE | SWPP_NOSIZE);
+}
+
+void Win32Window::set_opacity(float v) {
+    SetLayeredWindowAttributes(hwnd_, 0, (BYTE)(v * 255), LWA_ALPHA);
+}
+
+void Win32Window::set_background(Color c) {
+    config_.background = c;
+}
+
+void Win32Window::set_cursor(CursorType c) {
+    LPCWSTR id;
+    switch (c) {
+        case CursorType::Arrow:      id = IDC_ARROW; break;
+        case CursorType::Hand:       id = IDC_HAND; break;
+        case CursorType::IBeam:      id = IDC_IBEAM; break;
+        case CursorType::Crosshair:  id = IDC_CROSS; break;
+        case CursorType::ResizeNS:   id = IDC_SIZENS; break;
+        case CursorType::ResizeEW:   id = IDC_SIZEWE; break;
+        case CursorType::ResizeNWSE: id = IDC_SIZENWSE; break;
+        case CursorType::ResizeNESW: id = IDC_SIZENESW; break;
+        case CursorType::Move:       id = IDC_SIZEALL; break;
+        case CursorType::NotAllowed: id = IDC_NO; break;
+        case CursorType::Wait:       id = IDC_WAIT; break;
+        default:                      id = IDC_ARROW; break;
+    }
+    SetCursor(LoadCursorW(nullptr, id));
+}
+
+void Win32Window::show() {
+    ShowWindow(hwnd_, SW_SHOW);
+    if (config_.on_shown) config_.on_shown();
+}
+
+void Win32Window::hide() {
+    ShowWindow(hwnd_, SW_HIDE);
+    if (config_.on_hidden) config_.on_hidden();
+}
+
+void Win32Window::close() {
+    if (hwnd_) SendMessage(hwnd_, WM_CLOSE, 0, 0);
+}
+
+void Win32Window::focus() {
+    SetForegroundWindow(hwnd_);
+    SetFocus(hwnd_);
+}
+
+void Win32Window::minimize() {
+    ShowWindow(hwnd_, SW_MINIMIZE);
+}
+
+void Win32Window::maximize() {
+    ShowWindow(hwnd_, SW_MAXIMIZE);
+}
+
+void Win32Window::restore() {
+    ShowWindow(hwnd_, SW_RESTORE);
+}
+
+void Win32Window::fullscreen() {
+    WindowState s = state();
+    if (s == WindowState::Fullscreen) {
+        restore();
+    } else {
+        RECT r;
+        MONITORINFO mi = { sizeof(mi) };
+        GetMonitorInfoW(MonitorFromWindow(hwnd_, MONITOR_DEFAULTTONEAREST), &mi);
+        r = mi.rcMonitor;
+        SetWindowPos(hwnd_, HWND_TOP, r.left, r.top,
+                     r.right - r.left, r.bottom - r.top, SWPP_NOZORDER);
+    }
+}
+
+void Win32Window::center() {
+    RECT r;
+    GetWindowRect(hwnd_, &r);
+    int w = r.right - r.left;
+    int h = r.bottom - r.top;
+    MONITORINFO mi = { sizeof(mi) };
+    GetMonitorInfoW(MonitorFromWindow(hwnd_, MONITOR_DEFAULTTONEAREST), &mi);
+    int x = mi.rcWork.left + (mi.rcWork.right - mi.rcWork.left - w) / 2;
+    int y = mi.rcWork.top + (mi.rcWork.bottom - mi.rcWork.top - h) / 2;
+    SetWindowPos(hwnd_, nullptr, x, y, 0, 0, SWPP_NOZORDER | SWPP_NOSIZE);
+}
+
+void Win32Window::request_repaint() {
+    InvalidateRect(hwnd_, nullptr, TRUE);
+}
+
+void Win32Window::start_drag() {
+    ReleaseCapture();
+    SendMessage(hwnd_, WM_NCLBUTTONDOWN, HTCAPTION, 0);
+}
+
+void Win32Window::start_resize(HitTestRegion edge) {
+    ReleaseCapture();
+    WPARAM cmd = 0;
+    switch (edge) {
+        case HitTestRegion::ResizeTop:        cmd = HTTOP; break;
+        case HitTestRegion::ResizeBottom:     cmd = HTBOTTOM; break;
+        case HitTestRegion::ResizeLeft:        cmd = HTLEFT; break;
+        case HitTestRegion::ResizeRight:       cmd = HTRIGHT; break;
+        case HitTestRegion::ResizeTopLeft:     cmd = HTTOPLEFT; break;
+        case HitTestRegion::ResizeTopRight:    cmd = HTTOPRIGHT; break;
+        case HitTestRegion::ResizeBottomLeft:  cmd = HTBOTTOMLEFT; break;
+        case HitTestRegion::ResizeBottomRight: cmd = HTBOTTOMRIGHT; break;
+        default: return;
+    }
+    SendMessage(hwnd_, WM_NCLBUTTONDOWN, cmd, 0);
+}
+
+HitTestRegion Win32Window::hit_test(Point cursor) {
+    if (config_.on_hit_test) {
+        return config_.on_hit_test(cursor);
+    }
+    Size win_size = size();
+    int w = win_size.width;
+    int h = win_size.height;
+    int b = config_.resize_border_width;
+
+    bool at_left = cursor.x < b;
+    bool at_right = cursor.x >= w - b;
+    bool at_top = cursor.y < b;
+    bool at_bottom = cursor.y >= h - b;
+
+    if (config_.resizable) {
+        if (at_top && at_left) return HitTestRegion::ResizeTopLeft;
+        if (at_top && at_right) return HitTestRegion::ResizeTopRight;
+        if (at_bottom && at_left) return HitTestRegion::ResizeBottomLeft;
+        if (at_bottom && at_right) return HitTestRegion::ResizeBottomRight;
+        if (at_top) return HitTestRegion::ResizeTop;
+        if (at_bottom) return HitTestRegion::ResizeBottom;
+        if (at_left) return HitTestRegion::ResizeLeft;
+        if (at_right) return HitTestRegion::ResizeRight;
+    }
+
+    if (cursor.y < config_.caption_height) {
+        return HitTestRegion::Caption;
+    }
+    return HitTestRegion::Client;
+}
+
+void Win32Window::resize_webview(int w, int h) {
+    if (webview_) {
+        webview_->resize(w, h);
+    }
+}
+
+Win32Window* Win32Window::from_hwnd(HWND hwnd) {
+    return reinterpret_cast<Win32Window*>(GetPropW(hwnd, kWindowPPProp));
+}
+
+} // namespace wpp

package/framework/src/platform/win32/window_win32.h

@@ -0,0 +1,79 @@
+// ============================================================================
+//  window_win32.h — Win32 Window implementation
+// ============================================================================
+
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#include <dwmapi.h>
+#include <map>
+#include <functional>
+#include <memory>
+#include "win32_helpers.h"
+#include <windowpp/windowpp.h>
+
+namespace wpp {
+
+class Win32Window : public Window {
+public:
+    Win32Window(const WindowConfig& config, HWND hwnd);
+    ~Win32Window() override;
+
+    std::string id() const override { return config_.id; }
+    std::string title() const override;
+    Size size() const override;
+    Point position() const override;
+    WindowState state() const override;
+    bool is_visible() const override;
+    bool is_focused() const override;
+    float scale_factor() const override;
+    void* native_handle() const override { return hwnd_; }
+
+    void set_title(const std::string& title) override;
+    void set_size(int w, int h) override;
+    void set_position(int x, int y) override;
+    void set_min_size(int w, int h) override;
+    void set_max_size(int w, int h) override;
+    void set_resizable(bool v) override;
+    void set_always_on_top(bool v) override;
+    void set_opacity(float v) override;
+    void set_background(Color c) override;
+    void set_cursor(CursorType c) override;
+
+    void show() override;
+    void hide() override;
+    void close() override;
+    void focus() override;
+    void minimize() override;
+    void maximize() override;
+    void restore() override;
+    void fullscreen() override;
+    void center() override;
+    void request_repaint() override;
+    void start_drag() override;
+    void start_resize(HitTestRegion edge) override;
+
+    WebView* webview() override { return webview_.get(); }
+    void set_webview(std::unique_ptr<WebView> wv) { webview_ = std::move(wv); }
+    void resize_webview(int w, int h);
+
+    HWND hwnd() const { return hwnd_; }
+    const WindowConfig& config() const { return config_; }
+    void nullify_hwnd() { hwnd_ = nullptr; }
+
+    HitTestRegion hit_test(Point cursor);
+
+    static Win32Window* from_hwnd(HWND hwnd);
+
+private:
+    WindowConfig config_;
+    HWND hwnd_;
+    bool is_tracking_mouse_ = false;
+    std::map<uint64_t, std::function<void()>> timers_;
+    uint64_t next_timer_id_ = 1;
+    std::unique_ptr<WebView> webview_;
+};
+
+} // namespace wpp

package/framework/src/renderer/webgpu.h

@@ -0,0 +1,128 @@
+// ============================================================================
+//  WindowPP — WebGPU Renderer Integration
+//  File: src/renderer/webgpu.h
+//
+//  Cross-platform WebGPU surface creation from a native WindowPP handle.
+//  Works on Windows (HWND), macOS (NSWindow → CAMetalLayer), Linux (X11).
+//
+//  Backend options (link one):
+//    • Dawn   — https://dawn.googlesource.com/dawn   (Google / C++)
+//    • wgpu   — https://github.com/gfx-rs/wgpu-native (Rust / C bindings)
+//
+//  Usage:
+//    #include <windowpp/windowpp.h>
+//    #include <renderer/webgpu.h>
+//
+//    WGPUInstance instance = wgpuCreateInstance(nullptr);
+//    WGPUSurface  surface  = wpp::renderer::create_webgpu_surface(instance,
+//                                window->native_handle());
+//
+//  Works standalone in any wpp::Window — no WebView required.
+//  Also usable inside a WebView if the WebView exposes a native GPU surface.
+// ============================================================================
+
+#pragma once
+
+#include <webgpu/webgpu.h>
+
+// ── Platform headers ─────────────────────────────────────────────────────────
+
+#if defined(_WIN32)
+#   ifndef WIN32_LEAN_AND_MEAN
+#       define WIN32_LEAN_AND_MEAN
+#   endif
+#   ifndef NOMINMAX
+#       define NOMINMAX
+#   endif
+#   include <windows.h>
+
+#elif defined(__APPLE__)
+#   include <objc/runtime.h>
+#   include <objc/message.h>
+
+#elif defined(__linux__)
+#   include <X11/Xlib.h>
+#   include <cstdint>
+#endif
+
+namespace wpp {
+namespace renderer {
+
+// ── Surface creation ─────────────────────────────────────────────────────────
+
+// Creates a WGPUSurface for the given native window handle.
+//
+// Pass the value returned by wpp::Window::native_handle():
+//   Windows  → HWND
+//   macOS    → NSWindow*
+//   Linux    → X11 Window (cast to void*)
+//
+// On Linux the X11 Display is opened automatically via XOpenDisplay(nullptr).
+// If you manage the Display yourself, use create_webgpu_surface_x11() below.
+
+inline WGPUSurface create_webgpu_surface(WGPUInstance instance, void* native_handle) {
+#if defined(_WIN32)
+
+    WGPUSurfaceDescriptorFromWindowsHWND platform = {};
+    platform.chain.sType = WGPUSType_SurfaceDescriptorFromWindowsHWND;
+    platform.hinstance   = GetModuleHandleW(nullptr);
+    platform.hwnd        = native_handle;
+
+    WGPUSurfaceDescriptor desc = {};
+    desc.nextInChain = reinterpret_cast<WGPUChainedStruct*>(&platform);
+    return wgpuInstanceCreateSurface(instance, &desc);
+
+#elif defined(__APPLE__)
+
+    // native_handle is NSWindow* — extract the CAMetalLayer from its contentView
+    id ns_window    = reinterpret_cast<id>(native_handle);
+    id content_view = reinterpret_cast<id(*)(id, SEL)>(objc_msgSend)(
+                          ns_window, sel_registerName("contentView"));
+    id metal_layer  = reinterpret_cast<id(*)(id, SEL)>(objc_msgSend)(
+                          content_view, sel_registerName("layer"));
+
+    WGPUSurfaceDescriptorFromMetalLayer platform = {};
+    platform.chain.sType = WGPUSType_SurfaceDescriptorFromMetalLayer;
+    platform.layer       = metal_layer;
+
+    WGPUSurfaceDescriptor desc = {};
+    desc.nextInChain = reinterpret_cast<WGPUChainedStruct*>(&platform);
+    return wgpuInstanceCreateSurface(instance, &desc);
+
+#elif defined(__linux__)
+
+    Display* display = XOpenDisplay(nullptr);
+    return create_webgpu_surface_x11(instance, display, native_handle, false);
+
+#else
+    (void)instance; (void)native_handle;
+    return nullptr;
+#endif
+}
+
+// ── Linux: explicit Display overload ────────────────────────────────────────
+
+#if defined(__linux__)
+// Use this variant when you already hold an X11 Display* (avoids opening
+// a second connection).  Set owns_display=true to have it closed for you.
+inline WGPUSurface create_webgpu_surface_x11(WGPUInstance    instance,
+                                              Display*        display,
+                                              void*           native_handle,
+                                              bool            owns_display = false) {
+    WGPUSurfaceDescriptorFromXlibWindow platform = {};
+    platform.chain.sType = WGPUSType_SurfaceDescriptorFromXlibWindow;
+    platform.display     = display;
+    platform.window      = static_cast<uint32_t>(
+                               reinterpret_cast<uintptr_t>(native_handle));
+
+    WGPUSurfaceDescriptor desc = {};
+    desc.nextInChain = reinterpret_cast<WGPUChainedStruct*>(&platform);
+    WGPUSurface surface = wgpuInstanceCreateSurface(instance, &desc);
+
+    if (owns_display && display) XCloseDisplay(display);
+    return surface;
+}
+#endif
+
+} // namespace renderer
+} // namespace wpp