macos: Fix compile errors

zenith391 · zenith391 · commit 0ec01e218788 · 2023-10-16T18:40:33.000+02:00
diff --git a/.gitmodules b/.gitmodules
diff --git a/examples/test-backend.zig b/examples/test-backend.zig
@@ -9,8 +9,6 @@ pub fn main() !void {
     try window.set(
         capy.row(.{}, .{}),
     );
-    var row = capy.label(.{ .text = "test" });
-    _ = row;
 
     // window.resize(800, 450);
     window.show();
diff --git a/src/backends/macos/backend.zig b/src/backends/macos/backend.zig
@@ -8,8 +8,9 @@ const EventFunctions = shared.EventFunctions(@This());
 const EventType = shared.BackendEventType;
 const BackendError = shared.BackendError;
 const MouseButton = shared.MouseButton;
-//pub const PeerType = *c.GtkWidget;
-pub const PeerType = *opaque {};
+
+// pub const PeerType = *opaque {};
+pub const PeerType = objc.id;
 
 var activeWindows = std.atomic.Atomic(usize).init(0);
 var hasInit: bool = false;
@@ -40,14 +41,62 @@ pub const EventUserData = struct {
     focusOnClick: bool = false,
 };
 
+var test_data = EventUserData{ .peer = undefined };
 pub inline fn getEventUserData(peer: PeerType) *EventUserData {
     _ = peer;
+    return &test_data;
     //return @ptrCast(*EventUserData, @alignCast(@alignOf(EventUserData), c.g_object_get_data(@ptrCast(*c.GObject, peer), "eventUserData").?));
 }
 
 pub fn Events(comptime T: type) type {
-    _ = T;
-    return struct {};
+    return struct {
+        const Self = @This();
+
+        pub fn setUserData(self: *T, data: anytype) void {
+            comptime {
+                if (!std.meta.trait.isSingleItemPtr(@TypeOf(data))) {
+                    @compileError(std.fmt.comptimePrint("Expected single item pointer, got {s}", .{@typeName(@TypeOf(data))}));
+                }
+            }
+
+            getEventUserData(self.peer).userdata = @intFromPtr(data);
+        }
+
+        pub inline fn setCallback(self: *T, comptime eType: EventType, cb: anytype) !void {
+            const data = &getEventUserData(self.peer).user;
+            switch (eType) {
+                .Click => data.clickHandler = cb,
+                .Draw => data.drawHandler = cb,
+                .MouseButton => data.mouseButtonHandler = cb,
+                .MouseMotion => data.mouseMotionHandler = cb,
+                .Scroll => data.scrollHandler = cb,
+                .TextChanged => data.changedTextHandler = cb,
+                .Resize => data.resizeHandler = cb,
+                .KeyType => data.keyTypeHandler = cb,
+                .KeyPress => data.keyPressHandler = cb,
+                .PropertyChange => data.propertyChangeHandler = cb,
+            }
+        }
+
+        pub fn setOpacity(self: *const T, opacity: f32) void {
+            _ = opacity;
+            _ = self;
+        }
+
+        pub fn getWidth(self: *const T) u32 {
+            _ = self;
+            return 100;
+        }
+
+        pub fn getHeight(self: *const T) u32 {
+            _ = self;
+            return 100;
+        }
+
+        pub fn deinit(self: *const T) void {
+            _ = self;
+        }
+    };
 }
 
 pub const Window = struct {
@@ -59,7 +108,7 @@ pub const Window = struct {
 
     pub fn create() BackendError!Window {
         const NSWindow = objc.getClass("NSWindow") catch return BackendError.InitializationError;
-        const rect = objc.NSRectMake(100, 100, 200, 200);
+        const rect = objc.NSRect.make(100, 100, 200, 200);
         const style = AppKit.NSWindowStyleMask.Titled | AppKit.NSWindowStyleMask.Closable | AppKit.NSWindowStyleMask.Miniaturizable | AppKit.NSWindowStyleMask.Resizable;
 
         std.log.info("make new rect", .{});
@@ -82,7 +131,12 @@ pub const Window = struct {
     }
 
     pub fn resize(self: *Window, width: c_int, height: c_int) void {
-        const frame = objc.NSRectMake(100, 100, @as(objc.CGFloat, @floatFromInt(width)), @as(objc.CGFloat, @floatFromInt(height)));
+        const frame = objc.NSRect.make(
+            100,
+            100,
+            @as(objc.CGFloat, @floatFromInt(width)),
+            @as(objc.CGFloat, @floatFromInt(height)),
+        );
         // TODO: resize animation can be handled using a DataWrapper on the user-facing API
         _ = objc.msgSendByName(void, self.peer, "setFrame:display:", .{ frame, true }) catch unreachable;
     }
@@ -117,6 +171,51 @@ pub const Window = struct {
     }
 };
 
+pub const Container = struct {
+    peer: objc.id,
+
+    pub usingnamespace Events(Container);
+
+    pub fn create() BackendError!Container {
+        return Container{ .peer = undefined };
+    }
+
+    pub fn add(self: *const Container, peer: PeerType) void {
+        _ = peer;
+        _ = self;
+    }
+
+    pub fn remove(self: *const Container, peer: PeerType) void {
+        _ = peer;
+        _ = self;
+    }
+
+    pub fn move(self: *const Container, peer: PeerType, x: u32, y: u32) void {
+        _ = y;
+        _ = x;
+        _ = peer;
+        _ = self;
+    }
+
+    pub fn resize(self: *const Container, peer: PeerType, w: u32, h: u32) void {
+        _ = h;
+        _ = w;
+        _ = peer;
+        _ = self;
+    }
+
+    pub fn setTabOrder(self: *const Container, peers: []const PeerType) void {
+        _ = peers;
+        _ = self;
+    }
+};
+
+pub const Canvas = struct {
+    pub usingnamespace Events(Canvas);
+
+    pub const DrawContext = struct {};
+};
+
 pub fn postEmptyEvent() void {
     @panic("TODO: postEmptyEvent");
 }
diff --git a/src/backends/macos/objc.zig b/src/backends/macos/objc.zig
@@ -13,36 +13,36 @@ pub fn msgSend(comptime ReturnType: type, target: anytype, selector: SEL, args:
         const FnType = blk: {
             {
                 // TODO(hazeycode): replace this hack with the more generalised code above once it doens't crash the compiler
-                break :blk switch (args_meta.len) {
+                break :blk *const switch (args_meta.len) {
                     0 => fn (@TypeOf(target), SEL) callconv(.C) ReturnType,
-                    1 => fn (@TypeOf(target), SEL, args_meta[0].field_type) callconv(.C) ReturnType,
-                    2 => fn (@TypeOf(target), SEL, args_meta[0].field_type, args_meta[1].field_type) callconv(.C) ReturnType,
-                    3 => fn (@TypeOf(target), SEL, args_meta[0].field_type, args_meta[1].field_type, args_meta[2].field_type) callconv(.C) ReturnType,
-                    4 => fn (@TypeOf(target), SEL, args_meta[0].field_type, args_meta[1].field_type, args_meta[2].field_type, args_meta[3].field_type) callconv(.C) ReturnType,
-                    5 => fn (@TypeOf(target), SEL, args_meta[0].field_type, args_meta[1].field_type, args_meta[2].field_type, args_meta[3].field_type, args_meta[4].field_type) callconv(.C) ReturnType,
+                    1 => fn (@TypeOf(target), SEL, args_meta[0].type) callconv(.C) ReturnType,
+                    2 => fn (@TypeOf(target), SEL, args_meta[0].type, args_meta[1].type) callconv(.C) ReturnType,
+                    3 => fn (@TypeOf(target), SEL, args_meta[0].type, args_meta[1].type, args_meta[2].type) callconv(.C) ReturnType,
+                    4 => fn (@TypeOf(target), SEL, args_meta[0].type, args_meta[1].type, args_meta[2].type, args_meta[3].type) callconv(.C) ReturnType,
+                    5 => fn (@TypeOf(target), SEL, args_meta[0].type, args_meta[1].type, args_meta[2].type, args_meta[3].type, args_meta[4].type) callconv(.C) ReturnType,
                     else => @compileError("Unsupported number of args: add more variants in zig-objcrt/src/message.zig"),
                 };
             }
         };
         // NOTE: func is a var because making it const causes a compile error which I believe is a compiler bug
-        var func = @as(FnType, @ptrCast(c.objc_msgSend));
-        return @call(.{}, func, .{ target, selector } ++ args);
+        var func = @as(FnType, @ptrCast(&c.objc_msgSend));
+        return @call(.auto, func, .{ target, selector } ++ args);
     } else {
         const FnType = blk: {
             {
                 // TODO(hazeycode): replace this hack with the more generalised code above once it doens't crash the compiler
-                break :blk switch (args_meta.len) {
+                break :blk *const switch (args_meta.len) {
                     0 => fn (*ReturnType, @TypeOf(target), SEL) callconv(.C) void,
-                    1 => fn (*ReturnType, @TypeOf(target), SEL, args_meta[0].field_type) callconv(.C) void,
-                    2 => fn (*ReturnType, @TypeOf(target), SEL, args_meta[0].field_type, args_meta[1].field_type) callconv(.C) void,
+                    1 => fn (*ReturnType, @TypeOf(target), SEL, args_meta[0].type) callconv(.C) void,
+                    2 => fn (*ReturnType, @TypeOf(target), SEL, args_meta[0].type, args_meta[1].type) callconv(.C) void,
                     else => @compileError("Unsupported number of args: add more variants in zig-objcrt/src/message.zig"),
                 };
             }
         };
         // NOTE: func is a var because making it const causes a compile error which I believe is a compiler bug
-        var func = @as(FnType, @ptrCast(c.objc_msgSend_stret));
+        var func = @as(FnType, @ptrCast(&c.objc_msgSend_stret));
         var stret: ReturnType = undefined;
-        _ = @call(.{}, func, .{ &stret, target, selector } ++ args);
+        _ = @call(.auto, func, .{ &stret, target, selector } ++ args);
         return stret;
     }
 }
@@ -143,20 +143,13 @@ pub fn getClass(class_name: [:0]const u8) Error!Class {
     return c.objc_getClass(class_name) orelse Error.ClassNotRegisteredWithRuntime;
 }
 
-pub const CGFloat = switch (@import("builtin").cpu.arch.ptrBitWidth()) {
+pub const CGFloat = switch (@import("builtin").target.ptrBitWidth()) {
     64 => f64,
     32 => f32,
     else => unreachable,
 };
 
 pub const NSRect = CGRect;
-pub const NSRectMake = CGRectMake;
-pub fn CGRectMake(x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat) CGRect {
-    return CGRect{
-        .origin = .{ .x = x, .y = y },
-        .size = .{ .width = width, .height = height },
-    };
-}
 
 pub const CGPoint = extern struct {
     x: CGFloat,
@@ -171,4 +164,11 @@ pub const CGSize = extern struct {
 pub const CGRect = extern struct {
     origin: CGPoint,
     size: CGSize,
+
+    pub fn make(x: CGFloat, y: CGFloat, w: CGFloat, h: CGFloat) CGRect {
+        return .{
+            .origin = .{ .x = x, .y = y },
+            .size = .{ .width = w, .height = h },
+        };
+    }
 };
diff --git a/src/data.zig b/src/data.zig
@@ -126,13 +126,15 @@ pub fn Atom(comptime T: type) type {
         onChange: ChangeListenerList = .{},
         /// List of all Atoms this one is bound to.
         bindings: BindingList = .{},
+
         /// This boolean is used to protect from recursive relations between wrappers
         /// For example if there are two two-way binded data wrappers A and B:
         /// When A is set, B is set too. Since B is set, it will set A too. A is set, it will set B too, and so on..
         /// To prevent that, the bindLock is set to true when setting the value of the other.
         /// If the lock is equal to true, set() returns without calling the other. For example:
         /// When A is set, it sets the lock to true and sets B. Since B is set, it will set A too.
         /// A notices that bindLock is already set to true, and thus returns.
+        /// TODO: make the bind lock more general and just use it for any change, and explicit how this favors completeness instead of consistency (in case an onChange triggers set method manually)
         bindLock: std.atomic.Atomic(bool) = std.atomic.Atomic(bool).init(false),
 
         /// If dependOn has been called, this is a pointer to the callback function
diff --git a/src/internal.zig b/src/internal.zig
@@ -578,7 +578,6 @@ pub fn Events(comptime T: type) type {
         /// When the value is changed in the opacity data wrapper
         fn opacityChanged(newValue: f32, userdata: usize) void {
             const widget = @as(*T, @ptrFromInt(userdata));
-            std.log.info("opaccity changed to {d}", .{newValue});
             if (widget.peer) |*peer| {
                 peer.setOpacity(newValue);
             }

Original file line number	Diff line number	Diff line change
`@@ -578,7 +578,6 @@ pub fn Events(comptime T: type) type {`
`578`	`578`	`/// When the value is changed in the opacity data wrapper`
`579`	`579`	`fn opacityChanged(newValue: f32, userdata: usize) void {`
`580`	`580`	`const widget = @as(*T, @ptrFromInt(userdata));`
`581`		`- std.log.info("opaccity changed to {d}", .{newValue});`
`582`	`581`	`if (widget.peer) \|*peer\| {`
`583`	`582`	`peer.setOpacity(newValue);`
`584`	`583`	`}`