clipboard/src/main-linux.zig

const std = @import("std");
const Clipboard = @import("clipboard.zig");

const c = @cImport({
    @cInclude("limits.h");
    @cInclude("X11/Xlib.h");
    @cInclude("X11/extensions/Xfixes.h");
});

pub fn main() !u8 {
    var watch = false;
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    var args = std.process.args();
    defer args.deinit();
    while (args.next(allocator)) |arg_or_err| {
        const arg = try arg_or_err;
        defer allocator.free(arg);
        if (std.mem.eql(u8, arg, "-w")) {
            watch = true;
            break;
        }
    }
    var clip = try Clipboard.init(allocator);
    defer clip.deinit();
    clipboardAction(allocator, watch, &clip) catch return 1;
    return 0;
}

fn clipboardAction(allocator: std.mem.Allocator, watch: bool, clip: *Clipboard) !void {
    var display: *c.Display = c.XOpenDisplay(null).?;
    defer _ = c.XCloseDisplay(display);
    const default_screen = c.XDefaultScreen(display);
    var color = c.XBlackPixel(display, default_screen);
    var window = c.XCreateSimpleWindow(display, c.XDefaultRootWindow(display), 0, 0, 1, 1, 0, color, color);
    defer _ = c.XDestroyWindow(display, window);
    // Watch will not return
    if (watch) try watchClip(allocator, display, window, "CLIPBOARD", clip);
    var result = (try printSelection(allocator, display, window, "CLIPBOARD", "UTF8_STRING", clip)) or
        (try printSelection(allocator, display, window, "CLIPBOARD", "STRING", clip));
    if (!result) return error.ClipboardActionFailed;
}

fn watchClip(allocator: std.mem.Allocator, display: *c.Display, window: c.Window, bufname: [*c]const u8, clip: *Clipboard) !void {
    var event_base: c_int = undefined;
    var error_base: c_int = undefined;
    var event: c.XEvent = undefined;
    var bufid = c.XInternAtom(display, bufname, c.False);

    _ = c.XFixesQueryExtension(display, &event_base, &error_base);
    _ = c.XFixesSelectSelectionInput(display, c.XDefaultRootWindow(display), bufid, c.XFixesSetSelectionOwnerNotifyMask);

    while (true) {
        _ = c.XNextEvent(display, &event);

        if (event.type == event_base + c.XFixesSelectionNotify and
            event.xselection.property == bufid)
        {
            if (!try printSelection(allocator, display, window, bufname, "UTF8_STRING", clip))
                _ = try printSelection(allocator, display, window, bufname, "STRING", clip);
        }
    }
}

fn printSelection(
    allocator: std.mem.Allocator,
    display: *c.Display,
    window: c.Window,
    bufname: [*c]const u8,
    fmtname: [*c]const u8,
    clip: *Clipboard,
) !bool {
    var ressize: c_ulong = undefined;
    var restail: c_ulong = undefined;
    var resbits: c_int = undefined;
    var bufid = c.XInternAtom(display, bufname, c.False);
    var fmtid = c.XInternAtom(display, fmtname, c.False);
    var propid = c.XInternAtom(display, "XSEL_DATA", c.False);
    var incrid = c.XInternAtom(display, "INCR", c.False);
    var event: c.XEvent = undefined;

    _ = c.XSelectInput(display, window, c.PropertyChangeMask);
    _ = c.XConvertSelection(display, bufid, fmtid, propid, window, c.CurrentTime);
    _ = c.XNextEvent(display, &event);
    while (event.type != c.SelectionNotify or event.xselection.selection != bufid)
        _ = c.XNextEvent(display, &event);

    if (event.xselection.property > 0) {
        var result: [*c]u8 = undefined;
        _ = c.XGetWindowProperty(display, window, propid, 0, c.LONG_MAX / 4, c.True, c.AnyPropertyType, &fmtid, &resbits, &ressize, &restail, &result);
        defer _ = c.XFree(result);
        if (fmtid != incrid)
            _ = async clip.clipboardChanged(std.mem.span(result)); // TODO: Ensure we don't start queueing these things up

        if (fmtid == incrid) {
            ressize = 1;
            var arena_allocator = std.heap.ArenaAllocator.init(allocator);
            defer arena_allocator.deinit();
            var local_allocator = arena_allocator.allocator();
            var buffer = std.ArrayList(u8).init(local_allocator);
            defer buffer.deinit();
            while (ressize > 0) {
                _ = c.XNextEvent(display, &event);
                while (event.type != c.PropertyNotify or event.xproperty.atom != propid or event.xproperty.state != c.PropertyNewValue) {
                    _ = c.XNextEvent(display, &event);
                }

                _ = c.XGetWindowProperty(display, window, propid, 0, c.LONG_MAX / 4, c.True, c.AnyPropertyType, &fmtid, &resbits, &ressize, &restail, &result);
                //defer _ = c.XFree(result); // Creates double free error, but not sure why
                try buffer.appendSlice(try std.fmt.allocPrint(local_allocator, "{s}", .{result}));
            }
            _ = async clip.clipboardChanged(buffer.items);
        }
        return true;
    } else // request failed, e.g. owner can't convert to the target format
    return false;
}