@zappdev/cli 0.1.0

package/native/src/platform/window.zc

@@ -0,0 +1,446 @@
+import "std/map.zc";
+
+raw {
+#ifdef __APPLE__
+    #undef panic
+#endif
+}
+
+import "stdio.h" as c_stdio;
+
+@cfg(apple)
+import "../platform/darwin/window.zc";
+
+@cfg(windows)
+import "../platform/windows/window.zc";
+
+opaque alias TitleBarStyle = int;
+
+def WINDOW_TITLEBAR_STYLE_DEFAULT: TitleBarStyle = 0;
+def WINDOW_TITLEBAR_STYLE_HIDDEN: TitleBarStyle = 1;
+def WINDOW_TITLEBAR_STYLE_HIDDEN_INSET: TitleBarStyle = 2;
+
+struct WindowOptions {
+    title: string;
+    width: int;
+    height: int;
+    x: int;
+    y: int;
+    visible: bool;
+    resizable: bool;
+    closable: bool;
+    minimizable: bool;
+    maximizable: bool;
+    fullscreen: bool;
+    borderless: bool;
+    transparent: bool;
+    hidden: bool;
+    alwaysOnTop: bool;
+    titleBarStyle: TitleBarStyle;
+    webContentInspectable: int; // -1 = inherit from app config, 0 = false, 1 = true
+}
+
+struct App;
+struct Window {
+    id: int;
+    handle: void*;
+}
+
+struct WindowSize {
+    width: int;
+    height: int;
+}
+
+struct WindowPosition {
+    x: int;
+    y: int;
+}
+
+raw {
+    #ifndef ZAPP_WINDOW_EVENT_DATA_DEFINED
+    #define ZAPP_WINDOW_EVENT_DATA_DEFINED
+    typedef struct WindowEventData {
+        int32_t event;
+        int32_t width;
+        int32_t height;
+        int32_t x;
+        int32_t y;
+    } WindowEventData;
+    #endif
+}
+
+impl Window {
+    fn on(self, event_id: int, cb: fn*(WindowEventData*) -> int) -> void {
+        zapp_window_set_event_cb(self.id, event_id, cb);
+    }
+
+    fn on_ready(self, cb: fn*(int, void*) -> void) -> void {
+        zapp_window_set_on_ready(self.id, self.handle, cb);
+    }
+
+    fn minimize(self) -> void {
+        if self.handle != NULL {
+            window_minimize(self.handle);
+        }
+    }
+
+    fn unminimize(self) -> void {
+        if self.handle != NULL {
+            window_unminimize(self.handle);
+        }
+    }
+
+    fn maximize(self) -> void {
+        if self.handle != NULL {
+            window_maximize(self.handle);
+        }
+    }
+
+    fn unmaximize(self) -> void {
+        if self.handle != NULL {
+            window_unmaximize(self.handle);
+        }
+    }
+
+    fn toggle_minimize(self) -> void {
+        if self.handle != NULL {
+            window_toggle_minimize(self.handle);
+        }
+    }
+
+    fn toggle_maximize(self) -> void {
+        if self.handle != NULL {
+            window_toggle_maximize(self.handle);
+        }
+    }
+
+    fn show(self) -> void {
+        if self.handle != NULL {
+            window_show(self.handle);
+        }
+    }
+
+    fn hide(self) -> void {
+        if self.handle != NULL {
+            window_hide(self.handle);
+        }
+    }
+
+    fn close(self) -> void {
+        if self.handle != NULL {
+            let app = (App*)app_get_active();
+            if app != NULL {
+                app.window.close(self.id);
+            }
+        }
+    }
+
+    fn destroy(self) -> void {
+        if self.handle != NULL {
+            window_force_close(self.handle);
+        }
+    }
+
+    fn is_valid(self) -> bool {
+        return self.handle != NULL;
+    }
+
+    fn size(self) -> WindowSize {
+        if self.handle != NULL {
+            return window_get_size(self.handle);
+        }
+        return WindowSize{ width: 0, height: 0 };
+    }
+
+    fn position(self) -> WindowPosition {
+        if self.handle != NULL {
+            return window_get_position(self.handle);
+        }
+        return WindowPosition{ x: 0, y: 0 };
+    }
+
+    fn is_minimized(self) -> bool {
+        if self.handle != NULL {
+            return window_is_minimized(self.handle);
+        }
+        return false;
+    }
+
+    fn is_maximized(self) -> bool {
+        if self.handle != NULL {
+            return window_is_maximized(self.handle);
+        }
+        return false;
+    }
+
+    fn is_fullscreen(self) -> bool {
+        if self.handle != NULL {
+            return window_is_fullscreen(self.handle);
+        }
+        return false;
+    }
+}
+
+struct WindowManager {
+    app: App*;
+    webContentInspectable: bool;
+    handles: Map<void*>;
+    next_id: int;
+}
+
+impl WindowManager {
+    fn new() -> Self {
+        return WindowManager{
+            app: NULL,
+            webContentInspectable: true,
+            handles: Map<void*>::new(),
+            next_id: 0,
+        };
+    }
+
+    fn create(self, options: WindowOptions*) -> Window {
+        if options.webContentInspectable < 0 {
+            if self.webContentInspectable {
+                options.webContentInspectable = 1;
+            } else {
+                options.webContentInspectable = 0;
+            }
+        }
+        let handle = window_create(options);
+        let key: char[32];
+        c_stdio::snprintf(key, 32, "win-%d", self.next_id);
+        self.handles.put(key, handle);
+        let id = self.next_id;
+        
+        window_register_numeric_id(handle, id);
+        
+        self.next_id += 1;
+        return Window{
+            id: id,
+            handle: handle,
+        };
+    }
+
+    fn set_on_ready(self, id: int, handle: void*, cb: fn*(int, void*) -> void) -> void {
+        zapp_window_set_on_ready(id, handle, cb);
+    }
+
+    fn trigger_on_ready(self, id: int) -> void {
+        zapp_window_trigger_on_ready(id);
+    }
+
+    fn get(self, id: int) -> Window {
+        let key: char[32];
+        c_stdio::snprintf(key, 32, "win-%d", id);
+        let maybe = self.handles.get(key);
+        if maybe.is_some() {
+            return Window{
+                id: id,
+                handle: maybe.unwrap(),
+            };
+        }
+        return Window{
+            id: id,
+            handle: NULL,
+        };
+    }
+
+    fn close(self, id: int) -> void {
+        let key: char[32];
+        c_stdio::snprintf(key, 32, "win-%d", id);
+        let maybe = self.handles.get(key);
+        if maybe.is_some() {
+            self.handles.remove(key);
+            window_destroy(maybe.unwrap());
+        }
+    }
+}
+
+fn window_options_default(title: string) -> WindowOptions {
+    return WindowOptions{
+        title: title,
+        width: 1200,
+        height: 800,
+        x: 0,
+        y: 0,
+        visible: true,
+        resizable: true,
+        closable: true,
+        minimizable: true,
+        maximizable: true,
+        fullscreen: false,
+        borderless: false,
+        transparent: false,
+        hidden: false,
+        alwaysOnTop: false,
+        titleBarStyle: WINDOW_TITLEBAR_STYLE_DEFAULT,
+        webContentInspectable: -1,
+    };
+}
+
+@cfg(apple)
+fn window_create(options: WindowOptions*) -> void* {
+    return darwin_window_create(options);
+}
+@cfg(windows)
+fn window_create(options: WindowOptions*) -> void* {
+    return windows_window_create(options);
+}
+
+@cfg(apple)
+fn window_destroy(window: void*) -> void { darwin_window_destroy(window); }
+@cfg(windows)
+fn window_destroy(window: void*) -> void { windows_window_destroy(window); }
+
+@cfg(apple)
+fn window_minimize(window: void*) -> void { darwin_window_minimize(window); }
+@cfg(windows)
+fn window_minimize(window: void*) -> void { windows_window_minimize(window); }
+
+@cfg(apple)
+fn window_unminimize(window: void*) -> void { darwin_window_unminimize(window); }
+@cfg(windows)
+fn window_unminimize(window: void*) -> void { windows_window_unminimize(window); }
+
+@cfg(apple)
+fn window_maximize(window: void*) -> void { darwin_window_maximize(window); }
+@cfg(windows)
+fn window_maximize(window: void*) -> void { windows_window_maximize(window); }
+
+@cfg(apple)
+fn window_unmaximize(window: void*) -> void { darwin_window_unmaximize(window); }
+@cfg(windows)
+fn window_unmaximize(window: void*) -> void { windows_window_unmaximize(window); }
+
+@cfg(apple)
+fn window_toggle_minimize(window: void*) -> void { darwin_window_toggle_minimize(window); }
+@cfg(windows)
+fn window_toggle_minimize(window: void*) -> void { windows_window_toggle_minimize(window); }
+
+@cfg(apple)
+fn window_toggle_maximize(window: void*) -> void { darwin_window_toggle_maximize(window); }
+@cfg(windows)
+fn window_toggle_maximize(window: void*) -> void { windows_window_toggle_maximize(window); }
+
+@cfg(apple)
+fn window_set_title(window: void*, title: string) -> void { darwin_window_set_title(window, title); }
+@cfg(windows)
+fn window_set_title(window: void*, title: string) -> void { windows_window_set_title(window, title); }
+
+@cfg(apple)
+fn window_set_size(window: void*, width: int, height: int) -> void { darwin_window_set_size(window, width, height); }
+@cfg(windows)
+fn window_set_size(window: void*, width: int, height: int) -> void { windows_window_set_size(window, width, height); }
+
+@cfg(apple)
+fn window_set_position(window: void*, x: int, y: int) -> void { darwin_window_set_position(window, x, y); }
+@cfg(windows)
+fn window_set_position(window: void*, x: int, y: int) -> void { windows_window_set_position(window, x, y); }
+
+@cfg(apple)
+fn window_set_fullscreen(window: void*, on: bool) -> void { darwin_window_set_fullscreen(window, on); }
+@cfg(windows)
+fn window_set_fullscreen(window: void*, on: bool) -> void { windows_window_set_fullscreen(window, on); }
+
+@cfg(apple)
+fn window_set_always_on_top(window: void*, on: bool) -> void { darwin_window_set_always_on_top(window, on); }
+@cfg(windows)
+fn window_set_always_on_top(window: void*, on: bool) -> void { windows_window_set_always_on_top(window, on); }
+
+@cfg(apple)
+fn window_register_numeric_id(window: void*, id: int) -> void { darwin_window_register_numeric_id(window, id); }
+@cfg(windows)
+fn window_register_numeric_id(window: void*, id: int) -> void { windows_window_register_numeric_id(window, id); }
+
+@cfg(apple)
+fn window_show(window: void*) -> void { darwin_window_show(window); }
+@cfg(windows)
+fn window_show(window: void*) -> void { windows_window_show(window); }
+
+@cfg(apple)
+fn window_hide(window: void*) -> void { darwin_window_hide(window); }
+@cfg(windows)
+fn window_hide(window: void*) -> void { windows_window_hide(window); }
+
+@cfg(apple)
+fn window_get_size(window: void*) -> WindowSize { return darwin_window_get_size(window); }
+@cfg(windows)
+fn window_get_size(window: void*) -> WindowSize { return windows_window_get_size(window); }
+
+@cfg(apple)
+fn window_get_position(window: void*) -> WindowPosition { return darwin_window_get_position(window); }
+@cfg(windows)
+fn window_get_position(window: void*) -> WindowPosition { return windows_window_get_position(window); }
+
+@cfg(apple)
+fn window_is_minimized(window: void*) -> bool { return darwin_window_is_minimized(window); }
+@cfg(windows)
+fn window_is_minimized(window: void*) -> bool { return windows_window_is_minimized(window); }
+
+@cfg(apple)
+fn window_is_maximized(window: void*) -> bool { return darwin_window_is_maximized(window); }
+@cfg(windows)
+fn window_is_maximized(window: void*) -> bool { return windows_window_is_maximized(window); }
+
+@cfg(apple)
+fn window_is_fullscreen(window: void*) -> bool { return darwin_window_is_fullscreen(window); }
+@cfg(windows)
+fn window_is_fullscreen(window: void*) -> bool { return windows_window_is_fullscreen(window); }
+
+@cfg(apple)
+fn window_force_close(window: void*) -> void { darwin_window_force_close(window); }
+@cfg(windows)
+fn window_force_close(window: void*) -> void { windows_window_force_close(window); }
+
+fn window_manager_trigger_on_ready(id: int) -> void {
+    let app = (App*)app_get_active();
+    if app != NULL {
+        app.window.trigger_on_ready(id);
+    }
+}
+
+raw {
+    #define ZAPP_MAX_WINDOW_CALLBACKS 64
+    #ifndef ZAPP_MAX_WINDOW_EVENT_TYPES
+    #define ZAPP_MAX_WINDOW_EVENT_TYPES 11
+    #endif
+
+    static void (*zapp_window_on_ready_cbs[ZAPP_MAX_WINDOW_CALLBACKS])(int, void*) = {0};
+    static void* zapp_window_on_ready_handles[ZAPP_MAX_WINDOW_CALLBACKS] = {0};
+    static int (*zapp_window_event_cbs[ZAPP_MAX_WINDOW_CALLBACKS][ZAPP_MAX_WINDOW_EVENT_TYPES])(WindowEventData*) = {{0}};
+
+    void zapp_window_set_on_ready(int id, void* handle, void (*cb)(int, void*)) {
+        if (id >= 0 && id < ZAPP_MAX_WINDOW_CALLBACKS) {
+            zapp_window_on_ready_cbs[id] = cb;
+            zapp_window_on_ready_handles[id] = handle;
+        }
+    }
+
+    void zapp_window_trigger_on_ready(int id) {
+        if (id >= 0 && id < ZAPP_MAX_WINDOW_CALLBACKS && zapp_window_on_ready_cbs[id] != NULL) {
+            zapp_window_on_ready_cbs[id](id, zapp_window_on_ready_handles[id]);
+        }
+    }
+
+    void zapp_window_set_event_cb(int id, int event_id, int (*cb)(WindowEventData*)) {
+        if (id >= 0 && id < ZAPP_MAX_WINDOW_CALLBACKS && event_id >= 0 && event_id < ZAPP_MAX_WINDOW_EVENT_TYPES) {
+            zapp_window_event_cbs[id][event_id] = cb;
+        }
+    }
+
+    // Returns ZAPP_EVENT_RESULT_ALLOW (0) or ZAPP_EVENT_RESULT_CANCEL (1)
+    int zapp_window_trigger_event_with_data(int id, int event_id, int w, int h, int x, int y) {
+        if (id >= 0 && id < ZAPP_MAX_WINDOW_CALLBACKS && event_id >= 0 && event_id < ZAPP_MAX_WINDOW_EVENT_TYPES) {
+            if (zapp_window_event_cbs[id][event_id] != NULL) {
+                WindowEventData data = {0};
+                data.event = event_id;
+                data.width = w;
+                data.height = h;
+                data.x = x;
+                data.y = y;
+                return zapp_window_event_cbs[id][event_id](&data);
+            }
+        }
+        return 0; // ALLOW
+    }
+}