2021-11-09 18:44:33 +00:00
|
|
|
const std = @import("std");
|
2022-01-05 18:24:14 +00:00
|
|
|
const Clipboard = @import("clipboard.zig");
|
2022-01-03 19:09:08 +00:00
|
|
|
|
2021-11-09 18:44:33 +00:00
|
|
|
const c = @cImport({
|
|
|
|
@cInclude("limits.h");
|
|
|
|
@cInclude("X11/Xlib.h");
|
|
|
|
@cInclude("X11/extensions/Xfixes.h");
|
|
|
|
});
|
|
|
|
|
2021-11-17 18:56:09 +00:00
|
|
|
pub fn main() !u8 {
|
|
|
|
var watch = false;
|
|
|
|
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
|
|
|
defer _ = gpa.deinit();
|
2022-01-03 19:09:08 +00:00
|
|
|
const allocator = gpa.allocator();
|
2021-11-17 18:56:09 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2022-01-05 18:24:14 +00:00
|
|
|
var clip = try Clipboard.init(allocator);
|
|
|
|
defer clip.deinit();
|
|
|
|
clipboardAction(allocator, watch, &clip) catch return 1;
|
2021-11-17 18:56:09 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-01-05 18:24:14 +00:00
|
|
|
fn clipboardAction(allocator: std.mem.Allocator, watch: bool, clip: *Clipboard) !void {
|
2021-11-17 18:56:09 +00:00
|
|
|
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
|
2022-01-05 18:24:14 +00:00
|
|
|
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));
|
2021-11-17 18:56:09 +00:00
|
|
|
if (!result) return error.ClipboardActionFailed;
|
|
|
|
}
|
|
|
|
|
2022-01-05 18:24:14 +00:00
|
|
|
fn watchClip(allocator: std.mem.Allocator, display: *c.Display, window: c.Window, bufname: [*c]const u8, clip: *Clipboard) !void {
|
2021-11-17 18:56:09 +00:00
|
|
|
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)
|
|
|
|
{
|
2022-01-05 18:24:14 +00:00
|
|
|
if (!try printSelection(allocator, display, window, bufname, "UTF8_STRING", clip))
|
|
|
|
_ = try printSelection(allocator, display, window, bufname, "STRING", clip);
|
2021-11-17 18:56:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-05 18:24:14 +00:00
|
|
|
fn printSelection(
|
|
|
|
allocator: std.mem.Allocator,
|
|
|
|
display: *c.Display,
|
|
|
|
window: c.Window,
|
|
|
|
bufname: [*c]const u8,
|
|
|
|
fmtname: [*c]const u8,
|
|
|
|
clip: *Clipboard,
|
|
|
|
) !bool {
|
2021-11-09 18:44:33 +00:00
|
|
|
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)
|
2022-01-05 18:24:14 +00:00
|
|
|
_ = async clip.clipboardChanged(std.mem.span(result)); // TODO: Ensure we don't start queueing these things up
|
2021-11-09 18:44:33 +00:00
|
|
|
|
|
|
|
if (fmtid == incrid) {
|
|
|
|
ressize = 1;
|
2022-01-03 19:09:08 +00:00
|
|
|
var arena_allocator = std.heap.ArenaAllocator.init(allocator);
|
2021-11-17 18:56:09 +00:00
|
|
|
defer arena_allocator.deinit();
|
2022-01-03 19:09:08 +00:00
|
|
|
var local_allocator = arena_allocator.allocator();
|
|
|
|
var buffer = std.ArrayList(u8).init(local_allocator);
|
2021-11-17 18:56:09 +00:00
|
|
|
defer buffer.deinit();
|
2021-11-09 18:44:33 +00:00
|
|
|
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);
|
2021-11-17 18:56:09 +00:00
|
|
|
//defer _ = c.XFree(result); // Creates double free error, but not sure why
|
2022-01-03 19:09:08 +00:00
|
|
|
try buffer.appendSlice(try std.fmt.allocPrint(local_allocator, "{s}", .{result}));
|
2021-11-09 18:44:33 +00:00
|
|
|
}
|
2022-01-05 18:24:14 +00:00
|
|
|
_ = async clip.clipboardChanged(buffer.items);
|
2021-11-09 18:44:33 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
} else // request failed, e.g. owner can't convert to the target format
|
|
|
|
return false;
|
|
|
|
}
|