macOS: update zig and c structs for quick terminal size

Applying the feedback given by @pluiedev to use an enum to specify the
type of quick terminal size configuration given (pixels or percentage).
Updated the Swift code to work with the enum as well.

include/ghostty.h

@@ -446,11 +446,20 @@ typedef struct {
 } ghostty_config_palette_s;
 
 // config.QuickTerminalSize
+typedef enum {
+  GHOSTTY_QUICK_TERMINAL_SIZE_NONE,
+  GHOSTTY_QUICK_TERMINAL_SIZE_PERCENTAGE,
+  GHOSTTY_QUICK_TERMINAL_SIZE_PIXELS,
+} ghostty_quick_terminal_size_e;
+
 typedef struct {
-  uint8_t primary_type;    // 0 = none, 1 = percentage, 2 = pixels
+  ghostty_quick_terminal_size_e type;
-  float primary_value;
+  uint32_t value;
-  uint8_t secondary_type;  // 0 = none, 1 = percentage, 2 = pixels
+} ghostty_quick_terminal_size_u;
-  float secondary_value;
+
+typedef struct {
+  ghostty_quick_terminal_size_u primary;
+  ghostty_quick_terminal_size_u secondary;
 } ghostty_config_quick_terminal_size_s;
 
 // apprt.Target.Key

macos/Sources/Features/QuickTerminal/QuickTerminalSize.swift

@@ -1,4 +1,3 @@
-import Cocoa
 import GhosttyKit
 
 struct QuickTerminalSize {
@@ -11,20 +10,25 @@ struct QuickTerminalSize {
     }
 
     init(from cStruct: ghostty_config_quick_terminal_size_s) {
-        self.primary = cStruct.primary_type == 0 ? nil : Size(type: cStruct.primary_type, value: cStruct.primary_value)
+        self.primary = Size(from: cStruct.primary)
-        self.secondary = cStruct.secondary_type == 0 ? nil : Size(type: cStruct.secondary_type, value: cStruct.secondary_value)
+        self.secondary = Size(from: cStruct.secondary)
     }
 
     enum Size {
         case percentage(Float)
         case pixels(UInt32)
 
-        init?(type: UInt8, value: Float) {
+        init?(from cStruct: ghostty_quick_terminal_size_u) {
-            switch type {
+            switch cStruct.type {
-            case 1:
+            case GHOSTTY_QUICK_TERMINAL_SIZE_NONE:
-                self = .percentage(value)
+                return nil
-            case 2:
+            case GHOSTTY_QUICK_TERMINAL_SIZE_PERCENTAGE:
-                self = .pixels(UInt32(value))
+                let floatValue = withUnsafePointer(to: cStruct.value) { ptr in
+                    ptr.withMemoryRebound(to: Float.self, capacity: 1) { $0.pointee }
+                }
+                self = .percentage(floatValue)
+            case GHOSTTY_QUICK_TERMINAL_SIZE_PIXELS:
+                self = .pixels(cStruct.value)
             default:
                 return nil
             }

src/config/Config.zig

@@ -6707,30 +6707,39 @@ pub const QuickTerminalSize = struct {
 
     /// C API structure for QuickTerminalSize
     pub const C = extern struct {
-        primary_type: u8, // 0 = none, 1 = percentage, 2 = pixels
+        primary: CSize,
-        primary_value: f32,
+        secondary: CSize,
-        secondary_type: u8, // 0 = none, 1 = percentage, 2 = pixels
+    };
-        secondary_value: f32,
+
+    pub const CSize = extern struct {
+        type: Type,
+        value: u32,
+
+        pub const Type = enum(u8) { none, percentage, pixels };
+
+        fn none() CSize {
+            return .{ .type = .none, .value = 0 };
+        }
+
+        fn percentage(v: f32) CSize {
+            return .{ .type = .percentage, .value = @bitCast(v) };
+        }
+
+        fn pixels(v: u32) CSize {
+            return .{ .type = .pixels, .value = v };
+        }
     };
 
     pub fn cval(self: QuickTerminalSize) C {
         return .{
-            .primary_type = if (self.primary) |p| switch (p) {
+            .primary = if (self.primary) |p| switch (p) {
-                .percentage => 1,
+                .percentage => |v| CSize.percentage(v),
-                .pixels => 2,
+                .pixels => |v| CSize.pixels(v),
-            } else 0,
+            } else CSize.none(),
-            .primary_value = if (self.primary) |p| switch (p) {
+            .secondary = if (self.secondary) |s| switch (s) {
-                .percentage => |v| v,
+                .percentage => |v| CSize.percentage(v),
-                .pixels => |v| @floatFromInt(v),
+                .pixels => |v| CSize.pixels(v),
-            } else 0,
+            } else CSize.none(),
-            .secondary_type = if (self.secondary) |s| switch (s) {
-                .percentage => 1,
-                .pixels => 2,
-            } else 0,
-            .secondary_value = if (self.secondary) |s| switch (s) {
-                .percentage => |v| v,
-                .pixels => |v| @floatFromInt(v),
-            } else 0,
         };
     }