usecomputer 0.0.3 → 0.1.0

package/zig/src/window.zig

@@ -0,0 +1,123 @@
+// Helpers for querying visible macOS windows via stable CoreGraphics APIs.
+
+const std = @import("std");
+const builtin = @import("builtin");
+
+const c = if (builtin.target.os.tag == .macos) @cImport({
+    @cInclude("CoreGraphics/CoreGraphics.h");
+    @cInclude("CoreFoundation/CoreFoundation.h");
+}) else struct {};
+
+pub const Rect = struct {
+    x: f64,
+    y: f64,
+    width: f64,
+    height: f64,
+};
+
+pub const WindowInfo = struct {
+    id: u32,
+    owner_pid: i32,
+    owner_name: []const u8,
+    title: []const u8,
+    bounds: Rect,
+};
+
+pub fn forEachVisibleWindow(
+    comptime Context: type,
+    context: *Context,
+    callback: *const fn (ctx: *Context, info: WindowInfo) anyerror!void,
+) !void {
+    if (builtin.target.os.tag != .macos) {
+        return error.UnsupportedPlatform;
+    }
+
+    const options = c.kCGWindowListOptionOnScreenOnly | c.kCGWindowListExcludeDesktopElements;
+    const windows = c.CGWindowListCopyWindowInfo(options, c.kCGNullWindowID);
+    if (windows == null) {
+        return error.WindowQueryFailed;
+    }
+    defer c.CFRelease(windows);
+
+    const count: usize = @intCast(c.CFArrayGetCount(windows));
+    var i: usize = 0;
+    while (i < count) : (i += 1) {
+        const value = c.CFArrayGetValueAtIndex(windows, @intCast(i));
+        if (value == null) {
+            continue;
+        }
+
+        const dictionary: c.CFDictionaryRef = @ptrCast(value);
+
+        var id_raw: i64 = 0;
+        if (!readNumberI64(dictionary, c.kCGWindowNumber, &id_raw)) {
+            continue;
+        }
+        if (id_raw <= 0) {
+            continue;
+        }
+
+        var owner_pid_raw: i64 = 0;
+        if (!readNumberI64(dictionary, c.kCGWindowOwnerPID, &owner_pid_raw)) {
+            owner_pid_raw = 0;
+        }
+
+        var bounds: c.CGRect = undefined;
+        if (!readBoundsRect(dictionary, &bounds)) {
+            continue;
+        }
+
+        var owner_name_buffer: [256]u8 = undefined;
+        const owner_name = readString(dictionary, c.kCGWindowOwnerName, &owner_name_buffer);
+        var title_buffer: [256]u8 = undefined;
+        const title = readString(dictionary, c.kCGWindowName, &title_buffer);
+
+        try callback(context, .{
+            .id = @intCast(id_raw),
+            .owner_pid = @intCast(owner_pid_raw),
+            .owner_name = owner_name,
+            .title = title,
+            .bounds = .{
+                .x = std.math.round(bounds.origin.x),
+                .y = std.math.round(bounds.origin.y),
+                .width = std.math.round(bounds.size.width),
+                .height = std.math.round(bounds.size.height),
+            },
+        });
+    }
+}
+
+fn readNumberI64(dictionary: c.CFDictionaryRef, key: c.CFStringRef, out: *i64) bool {
+    const value = c.CFDictionaryGetValue(dictionary, key);
+    if (value == null) {
+        return false;
+    }
+    const number: c.CFNumberRef = @ptrCast(value);
+    return c.CFNumberGetValue(number, c.kCFNumberSInt64Type, out) != 0;
+}
+
+fn readBoundsRect(dictionary: c.CFDictionaryRef, out: *c.CGRect) bool {
+    const value = c.CFDictionaryGetValue(dictionary, c.kCGWindowBounds);
+    if (value == null) {
+        return false;
+    }
+    const bounds_dictionary: c.CFDictionaryRef = @ptrCast(value);
+    return c.CGRectMakeWithDictionaryRepresentation(bounds_dictionary, out);
+}
+
+fn readString(
+    dictionary: c.CFDictionaryRef,
+    key: c.CFStringRef,
+    buffer: *[256]u8,
+) []const u8 {
+    const value = c.CFDictionaryGetValue(dictionary, key);
+    if (value == null) {
+        return "";
+    }
+    const str_ref: c.CFStringRef = @ptrCast(value);
+    if (c.CFStringGetCString(str_ref, buffer, buffer.len, c.kCFStringEncodingUTF8) == 0) {
+        return "";
+    }
+    const content = std.mem.sliceTo(buffer, 0);
+    return content;
+}