windowpp 0.1.1

package/framework/src/platform/macos/app_macos.mm

@@ -0,0 +1,223 @@
+// ============================================================================
+//  app_macos.mm — macOS/Cocoa Application implementation
+// ============================================================================
+
+#import "app_macos.h"
+#include <dispatch/dispatch.h>
+#include "../../renderer/webview/webview.h"
+
+@interface PWAppDelegate : NSObject <NSApplicationDelegate> {
+    wpp::MacOSApplication* _app;
+}
+- (instancetype)initWithApp:(wpp::MacOSApplication*)app;
+@end
+
+@implementation PWAppDelegate
+- (instancetype)initWithApp:(wpp::MacOSApplication*)app {
+    self = [super init];
+    _app = app;
+    return self;
+}
+- (void)applicationDidFinishLaunching:(NSNotification*)notification {
+    if (_app->config().on_ready) {
+        _app->config().on_ready();
+    }
+}
+- (void)applicationWillTerminate:(NSNotification*)notification {
+    if (_app->config().on_quit) {
+        _app->config().on_quit();
+    }
+}
+- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication*)sender {
+    return _app->config().quit_on_last_close;
+}
+@end
+
+namespace wpp {
+
+MacOSApplication::MacOSApplication(const AppConfig& config) : config_(config) {
+    app_ = [NSApplication sharedApplication];
+    delegate_ = [[PWAppDelegate alloc] initWithApp:this];
+    app_.delegate = delegate_;
+    
+    [app_ setActivationPolicy:NSApplicationActivationPolicyRegular];
+    [app_ activateIgnoringOtherApps:YES];
+
+    if (config_.tray_enabled) {
+        set_tray(config_.tray);
+    }
+}
+
+MacOSApplication::~MacOSApplication() {
+    app_.delegate = nil;
+}
+
+Window* MacOSApplication::create_window(const WindowConfig& config) {
+    auto id = config.id.empty() ? "main" : config.id;
+
+    NSWindow* window = create_macos_native_window(config);
+
+    if (config.frameless) {
+        window.opaque = NO;
+        window.backgroundColor = [NSColor clearColor];
+        window.hasShadow = YES;
+    }
+
+    if (!config.title.empty()) {
+        window.title = macos::to_ns(config.title);
+    }
+
+    if (config.always_on_top) {
+        window.level = NSWindowLevel(NSIntegerMax);
+    }
+
+    window.minSize = NSMakeSize(config.min_width > 0 ? config.min_width : 0,
+                                config.min_height > 0 ? config.min_height : 0);
+    window.maxSize = NSMakeSize(config.max_width > 0 ? config.max_width : 10000,
+                                config.max_height > 0 ? config.max_height : 10000);
+
+    auto window_ptr = std::make_unique<MacOSWindow>(config, window);
+
+    if (config.webview.enabled) {
+        auto webview_config = config.webview;
+        webview_config.scrollbars = config.scrollbars;
+        window_ptr->set_webview(create_webview(webview_config, (__bridge void*)window));
+        if (auto* webview = window_ptr->webview()) {
+            webview->set_drag_drop_enabled(config.file_drop);
+        }
+    }
+
+    auto* ptr = window_ptr.get();
+    windows_[id] = std::move(window_ptr);
+
+    if (config.initial_state != WindowState::Hidden) {
+        [window makeKeyAndOrderFront:nil];
+    }
+
+    if (config.on_created) {
+        config.on_created();
+    }
+
+    return ptr;
+}
+
+Window* MacOSApplication::get_window(const std::string& id) {
+    auto it = windows_.find(id);
+    return it != windows_.end() ? it->second.get() : nullptr;
+}
+
+std::vector<Window*> MacOSApplication::all_windows() {
+    std::vector<Window*> result;
+    for (auto& [id, win] : windows_) {
+        result.push_back(win.get());
+    }
+    return result;
+}
+
+void MacOSApplication::run() {
+    [app_ run];
+}
+
+void MacOSApplication::quit() {
+    [app_ terminate:nil];
+}
+
+void MacOSApplication::set_tray(const TrayConfig& config) {
+    tray_ = std::make_unique<MacOSTray>(config);
+}
+
+void MacOSApplication::remove_tray() {
+    tray_.reset();
+}
+
+std::vector<MonitorInfo> MacOSApplication::monitors() {
+    std::vector<MonitorInfo> result;
+    for (NSScreen* screen in [NSScreen screens]) {
+        MonitorInfo mi;
+        mi.name = [[screen localizedName] UTF8String];
+        mi.bounds = {
+            (int)screen.frame.origin.x,
+            (int)screen.frame.origin.y,
+            (int)screen.frame.size.width,
+            (int)screen.frame.size.height
+        };
+        mi.work_area = {
+            (int)screen.visibleFrame.origin.x,
+            (int)screen.visibleFrame.origin.y,
+            (int)screen.visibleFrame.size.width,
+            (int)screen.visibleFrame.size.height
+        };
+        mi.scale_factor = screen.backingScaleFactor;
+        mi.is_primary = (screen == [NSScreen primaryScreen]);
+        result.push_back(mi);
+    }
+    return result;
+}
+
+MonitorInfo MacOSApplication::primary_monitor() {
+    MonitorInfo mi;
+    NSScreen* screen = [NSScreen primaryScreen];
+    mi.name = [[screen localizedName] UTF8String];
+    mi.bounds = {
+        (int)screen.frame.origin.x,
+        (int)screen.frame.origin.y,
+        (int)screen.frame.size.width,
+        (int)screen.frame.size.height
+    };
+    mi.work_area = {
+        (int)screen.visibleFrame.origin.x,
+        (int)screen.visibleFrame.origin.y,
+        (int)screen.visibleFrame.size.width,
+        (int)screen.visibleFrame.size.height
+    };
+    mi.scale_factor = screen.backingScaleFactor;
+    mi.is_primary = YES;
+    return mi;
+}
+
+std::string MacOSApplication::clipboard_text() {
+    return [[NSPasteboard generalPasteboard].string UTF8String] ?: "";
+}
+
+void MacOSApplication::set_clipboard_text(const std::string& text) {
+    [[NSPasteboard generalPasteboard] clearContents];
+    [[NSPasteboard generalPasteboard] setString:macos::to_ns(text) forType:NSPasteboardTypeString];
+}
+
+void MacOSApplication::send_message(const std::string& window_id,
+                                   const std::string& event,
+                                   const std::string& payload) {
+    auto it = message_handlers_.find(window_id);
+    if (it != message_handlers_.end()) {
+        for (auto& handler : it->second) {
+            handler(event, payload);
+        }
+    }
+}
+
+void MacOSApplication::on_message(const std::string& window_id, MessageHandler handler) {
+    message_handlers_[window_id].push_back(handler);
+}
+
+Application::TimerId MacOSApplication::set_timeout(uint32_t ms, std::function<void()> callback) {
+    return 0;
+}
+
+Application::TimerId MacOSApplication::set_interval(uint32_t ms, std::function<void()> callback) {
+    return 0;
+}
+
+void MacOSApplication::clear_timer(TimerId id) {
+}
+
+void MacOSApplication::dispatch(std::function<void()> fn) {
+    auto* callback = new std::function<void()>(std::move(fn));
+    dispatch_async(dispatch_get_main_queue(), ^{
+        std::unique_ptr<std::function<void()>> callback_ptr(callback);
+        if (*callback_ptr) {
+            (*callback_ptr)();
+        }
+    });
+}
+
+} // namespace wpp

package/framework/src/platform/macos/macos_helpers.h

@@ -0,0 +1,21 @@
+// ============================================================================
+//  macos_helpers.h — macOS/Cocoa helper utilities
+// ============================================================================
+
+#pragma once
+
+#import <Cocoa/Cocoa.h>
+
+namespace wpp {
+namespace macos {
+
+inline NSString* to_ns(const std::string& str) {
+    return [NSString stringWithUTF8String:str.c_str()];
+}
+
+inline std::string from_ns(NSString* str) {
+    return str ? [str UTF8String] : "";
+}
+
+} // namespace macos
+} // namespace wpp

package/framework/src/platform/macos/tray_macos.h

@@ -0,0 +1,22 @@
+// ============================================================================
+//  tray_macos.h — macOS System Tray implementation
+// ============================================================================
+
+#pragma once
+
+#import <Cocoa/Cocoa.h>
+#include "windowpp.h"
+
+namespace wpp {
+
+class MacOSTray {
+public:
+    MacOSTray(const TrayConfig& config);
+    ~MacOSTray();
+
+private:
+    TrayConfig config_;
+    NSStatusItem* item_;
+};
+
+} // namespace wpp

package/framework/src/platform/macos/tray_macos.mm

@@ -0,0 +1,53 @@
+// ============================================================================
+//  tray_macos.mm — macOS System Tray implementation
+// ============================================================================
+
+#import "tray_macos.h"
+#include "macos_helpers.h"
+
+@interface PWTrayMenuDelegate : NSObject <NSMenuDelegate> {
+    wpp::TrayConfig _config;
+}
+- (instancetype)initWithConfig:(wpp::TrayConfig)config;
+@end
+
+@implementation PWTrayMenuDelegate
+- (instancetype)initWithConfig:(wpp::TrayConfig)config {
+    self = [super init];
+    _config = config;
+    return self;
+}
+@end
+
+namespace wpp {
+
+MacOSTray::MacOSTray(const TrayConfig& config) : config_(config) {
+    item_ = [[NSStatusBar systemStatusBar] statusItemWithLength:NSVariableStatusItemLength];
+    
+    if (!config.icon_path.empty()) {
+        item_.button.image = [NSImage imageNamed:macos::to_ns(config.icon_path)];
+    } else {
+        item_.button.title = @"PW";
+    }
+    
+    NSMenu* menu = [[NSMenu alloc] init];
+    for (size_t i = 0; i < config.menu.size(); ++i) {
+        const auto& menuItem = config.menu[i];
+        if (menuItem.is_separator) {
+            [menu addItem:[NSMenuItem separatorItem]];
+        } else {
+            NSMenuItem* item = [[NSMenuItem alloc] initWithTitle:macos::to_ns(menuItem.label)
+                                                         action:nil
+                                                  keyEquivalent:@""];
+            item.enabled = menuItem.enabled;
+            [menu addItem:item];
+        }
+    }
+    item_.menu = menu;
+}
+
+MacOSTray::~MacOSTray() {
+    [[NSStatusBar systemStatusBar] removeStatusItem:item_];
+}
+
+} // namespace wpp

package/framework/src/platform/macos/window_macos.h

@@ -0,0 +1,74 @@
+// ============================================================================
+//  window_macos.h — macOS/Cocoa Window implementation
+// ============================================================================
+
+#pragma once
+
+#import <Cocoa/Cocoa.h>
+#include <map>
+#include <functional>
+#include <memory>
+#include "macos_helpers.h"
+#include "windowpp.h"
+
+@class PWWindowDelegate;
+
+namespace wpp {
+
+class MacOSWindow : public Window {
+public:
+    MacOSWindow(const WindowConfig& config, NSWindow* window);
+    ~MacOSWindow() 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 (__bridge void*)window_; }
+
+    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); }
+
+    NSWindow* window() const { return window_; }
+    const WindowConfig& config() const { return config_; }
+
+    HitTestRegion hit_test(Point cursor);
+
+private:
+    WindowConfig config_;
+    NSWindow* window_;
+    PWWindowDelegate* delegate_;
+    std::unique_ptr<WebView> webview_;
+};
+
+NSWindow* create_macos_native_window(const WindowConfig& config);
+
+} // namespace wpp

package/framework/src/platform/macos/window_macos.mm

@@ -0,0 +1,318 @@
+// ============================================================================
+//  window_macos.mm — macOS/Cocoa Window implementation
+// ============================================================================
+
+#import "window_macos.h"
+#include "../../Input/input_service.h"
+#include "../../Input/MacOS/macos_key_utils.h"
+#include <algorithm>
+
+@interface PWInputWindow : NSWindow {
+    wpp::MacOSWindow* _plusWindow;
+}
+- (void)setWindowPPRef:(wpp::MacOSWindow*)window;
+@end
+
+@implementation PWInputWindow
+- (void)setWindowPPRef:(wpp::MacOSWindow*)window {
+    _plusWindow = window;
+}
+
+- (void)sendEvent:(NSEvent*)event {
+    if (_plusWindow) {
+        switch (event.type) {
+            case NSEventTypeKeyDown: {
+                auto translated = wpp::input::macos::make_key_event(event, _plusWindow->id(), wpp::input::KeyEventType::KeyDown);
+                wpp::input::detail::emit_key_event(translated);
+                if (_plusWindow->config().on_key_down) {
+                    _plusWindow->config().on_key_down(translated);
+                }
+                break;
+            }
+            case NSEventTypeKeyUp: {
+                auto translated = wpp::input::macos::make_key_event(event, _plusWindow->id(), wpp::input::KeyEventType::KeyUp);
+                wpp::input::detail::emit_key_event(translated);
+                if (_plusWindow->config().on_key_up) {
+                    _plusWindow->config().on_key_up(translated);
+                }
+                break;
+            }
+            case NSEventTypeFlagsChanged: {
+                auto translated = wpp::input::macos::make_flags_changed_event(event, _plusWindow->id());
+                wpp::input::detail::emit_key_event(translated);
+                if (translated.type == wpp::input::KeyEventType::KeyDown) {
+                    if (_plusWindow->config().on_key_down) {
+                        _plusWindow->config().on_key_down(translated);
+                    }
+                } else if (_plusWindow->config().on_key_up) {
+                    _plusWindow->config().on_key_up(translated);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    [super sendEvent:event];
+}
+@end
+
+@interface PWWindowDelegate : NSObject <NSWindowDelegate> {
+    wpp::MacOSWindow* _window;
+}
+- (instancetype)initWithWindow:(wpp::MacOSWindow*)window;
+@end
+
+@implementation PWWindowDelegate
+- (instancetype)initWithWindow:(wpp::MacOSWindow*)window {
+    self = [super init];
+    _window = window;
+    return self;
+}
+- (void)windowDidResize:(NSNotification*)notification {
+    if (_window->config().on_resize) {
+        NSSize size = _window->window().frame.size;
+        _window->config().on_resize({{0, 0}, {(int)size.width, (int)size.height}});
+    }
+}
+- (void)windowDidMove:(NSNotification*)notification {
+    if (_window->config().on_move) {
+        NSPoint pos = _window->window().frame.origin;
+        _window->config().on_move({{(int)pos.x, (int)pos.y}, {(int)pos.x, (int)pos.y}});
+    }
+}
+- (void)windowWillClose:(NSNotification*)notification {
+    if (_window->config().on_close_requested && !_window->config().on_close_requested()) {
+        return;
+    }
+    if (_window->config().on_closed) {
+        _window->config().on_closed();
+    }
+}
+@end
+
+namespace wpp {
+
+NSWindow* create_macos_native_window(const WindowConfig& config) {
+    NSRect frame = NSMakeRect(
+        config.x >= 0 ? config.x : 100,
+        config.y >= 0 ? config.y : 100,
+        config.width,
+        config.height
+    );
+
+    NSWindowStyleMask styleMask = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable;
+    if (config.resizable) styleMask |= NSWindowStyleMaskResizable;
+    if (config.minimizable) styleMask |= NSWindowStyleMaskMiniaturizable;
+
+    if (config.frameless) {
+        styleMask = NSWindowStyleMaskBorderless | NSWindowStyleMaskResizable;
+    }
+
+    PWInputWindow* window = [[PWInputWindow alloc] initWithContentRect:frame
+                                                             styleMask:styleMask
+                                                               backing:NSBackingStoreBuffered
+                                                                 defer:NO];
+
+    if (config.frameless) {
+        window.opaque = NO;
+        window.backgroundColor = [NSColor clearColor];
+        window.hasShadow = YES;
+    }
+
+    return window;
+}
+
+MacOSWindow::MacOSWindow(const WindowConfig& config, NSWindow* window)
+    : config_(config), window_(window) {
+    delegate_ = [[PWWindowDelegate alloc] initWithWindow:this];
+    window_.delegate = delegate_;
+    if ([window_ respondsToSelector:@selector(setWindowPPRef:)]) {
+        [(PWInputWindow*)window_ setWindowPPRef:this];
+    }
+}
+
+MacOSWindow::~MacOSWindow() {
+    [window_ close];
+}
+
+std::string MacOSWindow::title() const {
+    return macos::from_ns(window_.title);
+}
+
+Size MacOSWindow::size() const {
+    NSRect frame = window_.frame;
+    return {(int)frame.size.width, (int)frame.size.height};
+}
+
+Point MacOSWindow::position() const {
+    NSRect frame = window_.frame;
+    return {(int)frame.origin.x, (int)frame.origin.y};
+}
+
+WindowState MacOSWindow::state() const {
+    if (!window_.isVisible) return WindowState::Hidden;
+    if (window_.isZoomed) return WindowState::Maximized;
+    if (window_.isMiniaturized) return WindowState::Minimized;
+    return WindowState::Normal;
+}
+
+bool MacOSWindow::is_visible() const {
+    return window_.isVisible;
+}
+
+bool MacOSWindow::is_focused() const {
+    return [NSApp keyWindow] == window_;
+}
+
+float MacOSWindow::scale_factor() const {
+    return window_.backingScaleFactor;
+}
+
+void MacOSWindow::set_title(const std::string& title) {
+    window_.title = macos::to_ns(title);
+}
+
+void MacOSWindow::set_size(int w, int h) {
+    NSRect frame = window_.frame;
+    frame.size.width = w;
+    frame.size.height = h;
+    [window_ setFrame:frame display:YES];
+}
+
+void MacOSWindow::set_position(int x, int y) {
+    NSRect frame = window_.frame;
+    frame.origin.x = x;
+    frame.origin.y = y;
+    [window_ setFrame:frame display:YES];
+}
+
+void MacOSWindow::set_min_size(int w, int h) {
+    config_.min_width = w;
+    config_.min_height = h;
+    window_.minSize = NSMakeSize(w, h);
+}
+
+void MacOSWindow::set_max_size(int w, int h) {
+    config_.max_width = w;
+    config_.max_height = h;
+    window_.maxSize = NSMakeSize(w, h);
+}
+
+void MacOSWindow::set_resizable(bool v) {
+    config_.resizable = v;
+    if (v) {
+        window_.styleMask |= NSWindowStyleMaskResizable;
+    } else {
+        window_.styleMask &= ~NSWindowStyleMaskResizable;
+    }
+}
+
+void MacOSWindow::set_always_on_top(bool v) {
+    window_.level = v ? NSWindowLevel(NSIntegerMax) : NSNormalWindowLevel;
+}
+
+void MacOSWindow::set_opacity(float v) {
+    window_.alphaValue = v;
+}
+
+void MacOSWindow::set_background(Color c) {
+    config_.background = c;
+    window_.backgroundColor = [NSColor colorWithRed:c.r/255.0 green:c.g/255.0 blue:c.b/255.0 alpha:c.a/255.0];
+}
+
+void MacOSWindow::set_cursor(CursorType c) {
+    NSCursor* cursor;
+    switch (c) {
+        case CursorType::Arrow:      cursor = [NSCursor arrowCursor]; break;
+        case CursorType::Hand:       cursor = [NSCursor pointingHandCursor]; break;
+        case CursorType::IBeam:      cursor = [NSCursor IBeamCursor]; break;
+        case CursorType::Crosshair:  cursor = [NSCursor crosshairCursor]; break;
+        case CursorType::ResizeNS:   cursor = [NSCursor resizeUpDownCursor]; break;
+        case CursorType::ResizeEW:   cursor = [NSCursor resizeLeftRightCursor]; break;
+        default:                     cursor = [NSCursor arrowCursor]; break;
+    }
+    [cursor set];
+}
+
+void MacOSWindow::show() {
+    [window_ makeKeyAndOrderFront:nil];
+    if (config_.on_shown) config_.on_shown();
+}
+
+void MacOSWindow::hide() {
+    [window_ orderOut:nil];
+    if (config_.on_hidden) config_.on_hidden();
+}
+
+void MacOSWindow::close() {
+    if (config_.on_close_requested && !config_.on_close_requested()) {
+        return;
+    }
+    [window_ close];
+    if (config_.on_closed) config_.on_closed();
+}
+
+void MacOSWindow::focus() {
+    [window_ makeKeyWindow];
+}
+
+void MacOSWindow::minimize() {
+    [window_ miniaturize:nil];
+}
+
+void MacOSWindow::maximize() {
+    [window_ zoom:nil];
+}
+
+void MacOSWindow::restore() {
+    [window_ deminiaturize:nil];
+}
+
+void MacOSWindow::fullscreen() {
+    if (window_.styleMask & NSWindowStyleMaskFullScreen) {
+        [window_ toggleFullScreen:nil];
+    }
+}
+
+void MacOSWindow::center() {
+    [window_ center];
+}
+
+void MacOSWindow::request_repaint() {
+    [window_ display];
+}
+
+void MacOSWindow::start_drag() {
+    [window_ performWindowDragWithEvent:nil];
+}
+
+void MacOSWindow::start_resize(HitTestRegion edge) {
+    NSSize minSize = window_.minSize;
+    NSSize maxSize = window_.maxSize;
+    
+    NSPoint corner = NSZeroPoint;
+    switch (edge) {
+        case HitTestRegion::ResizeTopLeft:      corner = NSMakePoint(0, 1); break;
+        case HitTestRegion::ResizeTopRight:     corner = NSMakePoint(1, 1); break;
+        case HitTestRegion::ResizeBottomLeft:   corner = NSMakePoint(0, 0); break;
+        case HitTestRegion::ResizeBottomRight:  corner = NSMakePoint(1, 0); break;
+        case HitTestRegion::ResizeTop:          corner = NSMakePoint(0.5, 1); break;
+        case HitTestRegion::ResizeBottom:       corner = NSMakePoint(0.5, 0); break;
+        case HitTestRegion::ResizeLeft:         corner = NSMakePoint(0, 0.5); break;
+        case HitTestRegion::ResizeRight:        corner = NSMakePoint(1, 0.5); break;
+        default: return;
+    }
+}
+
+HitTestRegion MacOSWindow::hit_test(Point cursor) {
+    if (config_.on_hit_test) {
+        return config_.on_hit_test(cursor);
+    }
+    return default_hit_test(cursor, size(),
+                           config_.resize_border_width,
+                           config_.caption_height,
+                           config_.resizable);
+}
+
+} // namespace wpp