usecomputer 0.0.3 → 0.0.4

package/zig/src/scroll.zig

@@ -0,0 +1,213 @@
+// Cross-platform native scroll event helpers for the usecomputer Zig module.
+
+const std = @import("std");
+const builtin = @import("builtin");
+
+const c_macos = if (builtin.target.os.tag == .macos) @cImport({
+    @cInclude("CoreGraphics/CoreGraphics.h");
+    @cInclude("CoreFoundation/CoreFoundation.h");
+}) else struct {};
+
+const c_windows = if (builtin.target.os.tag == .windows) @cImport({
+    @cInclude("windows.h");
+}) else struct {};
+
+const c_x11 = if (builtin.target.os.tag == .linux) @cImport({
+    @cInclude("X11/Xlib.h");
+    @cInclude("X11/extensions/XTest.h");
+}) else struct {};
+
+pub const ScrollArgs = struct {
+    direction: []const u8,
+    amount: f64,
+    at_x: ?f64 = null,
+    at_y: ?f64 = null,
+};
+
+const ScrollDirection = enum {
+    up,
+    down,
+    left,
+    right,
+};
+
+pub fn scroll(args: ScrollArgs) !void {
+    const direction = try parseDirection(args.direction);
+    const steps = try normalizeAmount(args.amount);
+
+    switch (builtin.target.os.tag) {
+        .macos => {
+            try scrollMacos(.{ .direction = direction, .steps = steps, .at_x = args.at_x, .at_y = args.at_y });
+        },
+        .windows => {
+            try scrollWindows(.{ .direction = direction, .steps = steps, .at_x = args.at_x, .at_y = args.at_y });
+        },
+        .linux => {
+            try scrollX11(.{ .direction = direction, .steps = steps, .at_x = args.at_x, .at_y = args.at_y });
+        },
+        else => {
+            return error.UnsupportedPlatform;
+        },
+    }
+}
+
+fn parseDirection(direction: []const u8) !ScrollDirection {
+    if (std.ascii.eqlIgnoreCase(direction, "up")) {
+        return .up;
+    }
+    if (std.ascii.eqlIgnoreCase(direction, "down")) {
+        return .down;
+    }
+    if (std.ascii.eqlIgnoreCase(direction, "left")) {
+        return .left;
+    }
+    if (std.ascii.eqlIgnoreCase(direction, "right")) {
+        return .right;
+    }
+    return error.InvalidDirection;
+}
+
+fn normalizeAmount(amount: f64) !i32 {
+    if (!std.math.isFinite(amount)) {
+        return error.InvalidAmount;
+    }
+    const rounded = @as(i64, @intFromFloat(std.math.round(amount)));
+    if (rounded <= 0) {
+        return error.InvalidAmount;
+    }
+    if (rounded > std.math.maxInt(i32)) {
+        return error.AmountTooLarge;
+    }
+    return @as(i32, @intCast(rounded));
+}
+
+fn scrollMacos(args: struct {
+    direction: ScrollDirection,
+    steps: i32,
+    at_x: ?f64,
+    at_y: ?f64,
+}) !void {
+    if (args.at_x != null and args.at_y != null) {
+        const point: c_macos.CGPoint = .{ .x = args.at_x.?, .y = args.at_y.? };
+        const warp_result = c_macos.CGWarpMouseCursorPosition(point);
+        if (warp_result != c_macos.kCGErrorSuccess) {
+            return error.CGWarpMouseFailed;
+        }
+    }
+
+    var delta_y: i32 = 0;
+    var delta_x: i32 = 0;
+    switch (args.direction) {
+        .up => {
+            delta_y = args.steps;
+        },
+        .down => {
+            delta_y = -args.steps;
+        },
+        .left => {
+            delta_x = -args.steps;
+        },
+        .right => {
+            delta_x = args.steps;
+        },
+    }
+
+    const event = c_macos.CGEventCreateScrollWheelEvent(
+        null,
+        c_macos.kCGScrollEventUnitLine,
+        2,
+        delta_y,
+        delta_x,
+    );
+    if (event == null) {
+        return error.CGEventCreateFailed;
+    }
+    defer c_macos.CFRelease(event);
+
+    if (args.at_x != null and args.at_y != null) {
+        const location: c_macos.CGPoint = .{ .x = args.at_x.?, .y = args.at_y.? };
+        c_macos.CGEventSetLocation(event, location);
+    }
+
+    c_macos.CGEventPost(c_macos.kCGHIDEventTap, event);
+}
+
+fn scrollWindows(args: struct {
+    direction: ScrollDirection,
+    steps: i32,
+    at_x: ?f64,
+    at_y: ?f64,
+}) !void {
+    if (args.at_x != null and args.at_y != null) {
+        const x = @as(i64, @intFromFloat(std.math.round(args.at_x.?)));
+        const y = @as(i64, @intFromFloat(std.math.round(args.at_y.?)));
+        if (x < std.math.minInt(i32) or x > std.math.maxInt(i32) or y < std.math.minInt(i32) or y > std.math.maxInt(i32)) {
+            return error.InvalidPoint;
+        }
+        _ = c_windows.SetCursorPos(@as(c_int, @intCast(x)), @as(c_int, @intCast(y)));
+    }
+
+    var flags: u32 = 0;
+    var delta: i32 = 0;
+    switch (args.direction) {
+        .up => {
+            flags = c_windows.MOUSEEVENTF_WHEEL;
+            delta = args.steps;
+        },
+        .down => {
+            flags = c_windows.MOUSEEVENTF_WHEEL;
+            delta = -args.steps;
+        },
+        .left => {
+            flags = c_windows.MOUSEEVENTF_HWHEEL;
+            delta = -args.steps;
+        },
+        .right => {
+            flags = c_windows.MOUSEEVENTF_HWHEEL;
+            delta = args.steps;
+        },
+    }
+
+    var event = std.mem.zeroes(c_windows.INPUT);
+    event.type = c_windows.INPUT_MOUSE;
+    event.Anonymous.mi.dwFlags = flags;
+    event.Anonymous.mi.mouseData = @as(c_uint, @intCast(delta * c_windows.WHEEL_DELTA));
+    const sent = c_windows.SendInput(1, &event, @sizeOf(c_windows.INPUT));
+    if (sent == 0) {
+        return error.EventPostFailed;
+    }
+}
+
+fn scrollX11(args: struct {
+    direction: ScrollDirection,
+    steps: i32,
+    at_x: ?f64,
+    at_y: ?f64,
+}) !void {
+    const display = c_x11.XOpenDisplay(null) orelse return error.XOpenDisplayFailed;
+    defer _ = c_x11.XCloseDisplay(display);
+
+    if (args.at_x != null and args.at_y != null) {
+        const x = @as(i64, @intFromFloat(std.math.round(args.at_x.?)));
+        const y = @as(i64, @intFromFloat(std.math.round(args.at_y.?)));
+        if (x < std.math.minInt(i32) or x > std.math.maxInt(i32) or y < std.math.minInt(i32) or y > std.math.maxInt(i32)) {
+            return error.InvalidPoint;
+        }
+        _ = c_x11.XWarpPointer(display, 0, c_x11.XDefaultRootWindow(display), 0, 0, 0, 0, @as(c_int, @intCast(x)), @as(c_int, @intCast(y)));
+    }
+
+    const button_code: c_uint = switch (args.direction) {
+        .up => 4,
+        .down => 5,
+        .left => 6,
+        .right => 7,
+    };
+
+    const repeat_count: u32 = @as(u32, @intCast(args.steps));
+    var index: u32 = 0;
+    while (index < repeat_count) : (index += 1) {
+        _ = c_x11.XTestFakeButtonEvent(display, button_code, c_x11.True, c_x11.CurrentTime);
+        _ = c_x11.XTestFakeButtonEvent(display, button_code, c_x11.False, c_x11.CurrentTime);
+    }
+    _ = c_x11.XFlush(display);
+}

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;
+}