river-options: remove protocol

This protocol involves far too much accidental complexity. The original
motivating use-case was to provide a convenient way to send arbitrary
data to layout clients at runtime in order to avoid layout clients
needing to implement their own IPC and do this over a side-channel.
Instead of implementing a quite complex but still rigid options protocol
and storing this state in the compositor, instead we will simply add
events to the layout protocol to support this use case.

Consider the status quo event sequence:

1. send get_option_handle request (riverctl)
2. roundtrip waiting for first event (riverctl)
3. send set_foo_value request (riverctl)
4. receive set_foo_value request (river)
5. send foo_value event to all current handles (river)
6. receive foo_value event (rivertile)
7. send parameters_changed request (rivertile)
8. receive parameters_changed request (river)
9. send layout_demand (river)

And compare with the event sequence after the proposed change:

1. send set_foo_value request (riverctl)
2. receive set_foo_value request (river)
3. send set_foo_value event (river)
4. send layout_demand (river)

This requires *much* less back and forth between the server and clients
and is clearly much simpler.

1 files changed, 0 insertions, 320 deletions

diff --git a/riverctl/options.zig b/riverctl/options.zig
deleted file mode 100644
index 9501610..0000000
--- a/riverctl/options.zig
+++ /dev/null
@@ -1,320 +0,0 @@
-// This file is part of river, a dynamic tiling wayland compositor.
-//
-// Copyright 2021 The River Developers
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const os = std.os;
-const math = std.math;
-const mem = std.mem;
-const fmt = std.fmt;
-
-const wayland = @import("wayland");
-const wl = wayland.client.wl;
-const river = wayland.client.river;
-const zriver = wayland.client.zriver;
-const zxdg = wayland.client.zxdg;
-
-const root = @import("root");
-
-const Args = @import("args.zig").Args;
-const FlagDef = @import("args.zig").FlagDef;
-const Globals = @import("main.zig").Globals;
-const Output = @import("main.zig").Output;
-
-const ValueType = enum {
-    int,
-    uint,
-    fixed,
-    string,
-};
-
-const Context = struct {
-    display: *wl.Display,
-    key: [*:0]const u8,
-    raw_value: [*:0]const u8,
-    output: ?*Output,
-};
-
-pub fn declareOption(display: *wl.Display, globals: *Globals) !void {
-    // https://github.com/ziglang/zig/issues/7807
-    const argv: [][*:0]const u8 = os.argv;
-    const args = Args(3, &[_]FlagDef{}).parse(argv[2..]);
-
-    const key = args.positionals[0];
-    const value_type = std.meta.stringToEnum(ValueType, mem.span(args.positionals[1])) orelse {
-        root.printErrorExit(
-            "'{}' is not a valid type, must be int, uint, fixed, or string",
-            .{args.positionals[1]},
-        );
-    };
-    const raw_value = args.positionals[2];
-
-    const options_manager = globals.options_manager orelse return error.RiverOptionsManagerNotAdvertised;
-
-    switch (value_type) {
-        .int => options_manager.declareIntOption(key, parseInt(raw_value)),
-        .uint => options_manager.declareUintOption(key, parseUint(raw_value)),
-        .fixed => options_manager.declareFixedOption(key, parseFixed(raw_value)),
-        .string => options_manager.declareStringOption(key, raw_value),
-    }
-
-    _ = try display.flush();
-}
-
-fn parseInt(raw_value: [*:0]const u8) i32 {
-    return fmt.parseInt(i32, mem.span(raw_value), 10) catch
-        root.printErrorExit("{} is not a valid int", .{raw_value});
-}
-
-fn parseUint(raw_value: [*:0]const u8) u32 {
-    return fmt.parseInt(u32, mem.span(raw_value), 10) catch
-        root.printErrorExit("{} is not a valid uint", .{raw_value});
-}
-
-fn parseFixed(raw_value: [*:0]const u8) wl.Fixed {
-    return wl.Fixed.fromDouble(fmt.parseFloat(f64, mem.span(raw_value)) catch
-        root.printErrorExit("{} is not a valid fixed", .{raw_value}));
-}
-
-pub fn getOption(display: *wl.Display, globals: *Globals) !void {
-    // https://github.com/ziglang/zig/issues/7807
-    const argv: [][*:0]const u8 = os.argv;
-    const args = Args(1, &[_]FlagDef{
-        .{ .name = "-output", .kind = .arg },
-        .{ .name = "-focused-output", .kind = .boolean },
-    }).parse(argv[2..]);
-
-    const output = if (args.argFlag("-output")) |o|
-        try parseOutputName(display, globals, o)
-    else if (args.boolFlag("-focused-output"))
-        try getFocusedOutput(display, globals)
-    else
-        null;
-
-    const ctx = Context{
-        .display = display,
-        .key = args.positionals[0],
-        .raw_value = undefined,
-        .output = output,
-    };
-
-    const options_manager = globals.options_manager orelse return error.RiverOptionsManagerNotAdvertised;
-    const handle = try options_manager.getOptionHandle(ctx.key, if (ctx.output) |o| o.wl_output else null);
-    handle.setListener(*const Context, getOptionListener, &ctx) catch unreachable;
-
-    // We always exit when our listener is called
-    while (true) _ = try display.dispatch();
-}
-
-pub fn setOption(display: *wl.Display, globals: *Globals) !void {
-    // https://github.com/ziglang/zig/issues/7807
-    const argv: [][*:0]const u8 = os.argv;
-    const args = Args(2, &[_]FlagDef{
-        .{ .name = "-output", .kind = .arg },
-        .{ .name = "-focused-output", .kind = .boolean },
-    }).parse(argv[2..]);
-
-    const output = if (args.argFlag("-output")) |o|
-        try parseOutputName(display, globals, o)
-    else if (args.boolFlag("-focused-output"))
-        try getFocusedOutput(display, globals)
-    else
-        null;
-
-    const ctx = Context{
-        .display = display,
-        .key = args.positionals[0],
-        .raw_value = args.positionals[1],
-        .output = output,
-    };
-
-    const options_manager = globals.options_manager orelse return error.RiverOptionsManagerNotAdvertised;
-    const handle = try options_manager.getOptionHandle(ctx.key, if (ctx.output) |o| o.wl_output else null);
-    handle.setListener(*const Context, setOptionListener, &ctx) catch unreachable;
-
-    // We always exit when our listener is called
-    while (true) _ = try display.dispatch();
-}
-
-pub fn unsetOption(display: *wl.Display, globals: *Globals) !void {
-    // https://github.com/ziglang/zig/issues/7807
-    const argv: [][*:0]const u8 = os.argv;
-    const args = Args(1, &[_]FlagDef{
-        .{ .name = "-output", .kind = .arg },
-        .{ .name = "-focused-output", .kind = .boolean },
-    }).parse(argv[2..]);
-
-    const output = if (args.argFlag("-output")) |o|
-        try parseOutputName(display, globals, o)
-    else if (args.boolFlag("-focused-output"))
-        try getFocusedOutput(display, globals)
-    else
-        root.printErrorExit("unset requires either -output or -focused-output", .{});
-
-    const key = args.positionals[0];
-
-    const options_manager = globals.options_manager orelse return error.RiverOptionsManagerNotAdvertised;
-
-    options_manager.unsetOption(key, output.wl_output);
-
-    _ = try display.flush();
-}
-
-pub fn modOption(display: *wl.Display, globals: *Globals) !void {
-    // https://github.com/ziglang/zig/issues/7807
-    const argv: [][*:0]const u8 = os.argv;
-    const args = Args(2, &[_]FlagDef{
-        .{ .name = "-output", .kind = .arg },
-        .{ .name = "-focused-output", .kind = .boolean },
-    }).parse(argv[2..]);
-
-    const output = if (args.argFlag("-output")) |o|
-        try parseOutputName(display, globals, o)
-    else if (args.boolFlag("-focused-output"))
-        try getFocusedOutput(display, globals)
-    else
-        null;
-
-    const ctx = Context{
-        .display = display,
-        .key = args.positionals[0],
-        .raw_value = args.positionals[1],
-        .output = output,
-    };
-
-    const options_manager = globals.options_manager orelse return error.RiverOptionsManagerNotAdvertised;
-    const handle = try options_manager.getOptionHandle(ctx.key, if (ctx.output) |o| o.wl_output else null);
-    handle.setListener(*const Context, modOptionListener, &ctx) catch unreachable;
-
-    // We always exit when our listener is called
-    while (true) _ = try display.dispatch();
-}
-
-fn parseOutputName(display: *wl.Display, globals: *Globals, output_name: [*:0]const u8) !*Output {
-    const output_manager = globals.output_manager orelse return error.XdgOutputNotAdvertised;
-    for (globals.outputs.items) |*output| {
-        const xdg_output = try output_manager.getXdgOutput(output.wl_output);
-        xdg_output.setListener(*Output, xdgOutputListener, output) catch unreachable;
-    }
-    _ = try display.roundtrip();
-
-    for (globals.outputs.items) |*output| {
-        if (mem.eql(u8, output.name, mem.span(output_name))) return output;
-    }
-    root.printErrorExit("unknown output '{}'", .{output_name});
-}
-
-fn xdgOutputListener(xdg_output: *zxdg.OutputV1, event: zxdg.OutputV1.Event, output: *Output) void {
-    switch (event) {
-        .name => |ev| output.name = std.heap.c_allocator.dupe(u8, mem.span(ev.name)) catch @panic("out of memory"),
-        else => {},
-    }
-}
-
-fn getFocusedOutput(display: *wl.Display, globals: *Globals) !*Output {
-    const status_manager = globals.status_manager orelse return error.RiverStatusManagerNotAdvertised;
-    const seat = globals.seat orelse return error.SeatNotAdverstised;
-    const seat_status = try status_manager.getRiverSeatStatus(seat);
-    var result: ?*wl.Output = null;
-    seat_status.setListener(*?*wl.Output, seatStatusListener, &result) catch unreachable;
-    _ = try display.roundtrip();
-    const wl_output = if (result) |output| output else return error.NoOutputFocused;
-    for (globals.outputs.items) |*output| {
-        if (output.wl_output == wl_output) return output;
-    } else unreachable;
-}
-
-fn seatStatusListener(seat_status: *zriver.SeatStatusV1, event: zriver.SeatStatusV1.Event, result: *?*wl.Output) void {
-    switch (event) {
-        .focused_output => |ev| result.* = ev.output,
-        .unfocused_output, .focused_view => {},
-    }
-}
-
-fn getOptionListener(
-    handle: *river.OptionHandleV2,
-    event: river.OptionHandleV2.Event,
-    ctx: *const Context,
-) void {
-    switch (event) {
-        .undeclared => root.printErrorExit("option '{}' has not been declared", .{ctx.key}),
-        .int_value => |ev| printOutputExit("{}", .{ev.value}),
-        .uint_value => |ev| printOutputExit("{}", .{ev.value}),
-        .fixed_value => |ev| printOutputExit("{d}", .{ev.value.toDouble()}),
-        .string_value => |ev| if (ev.value) |s| printOutputExit("{}", .{s}) else os.exit(0),
-    }
-}
-
-fn printOutputExit(comptime format: []const u8, args: anytype) noreturn {
-    const stdout = std.io.getStdOut().writer();
-    stdout.print(format ++ "\n", args) catch os.exit(1);
-    os.exit(0);
-}
-
-fn setOptionListener(
-    handle: *river.OptionHandleV2,
-    event: river.OptionHandleV2.Event,
-    ctx: *const Context,
-) void {
-    switch (event) {
-        .undeclared => root.printErrorExit("option '{}' has not been declared", .{ctx.key}),
-        .int_value => |ev| handle.setIntValue(parseInt(ctx.raw_value)),
-        .uint_value => |ev| handle.setUintValue(parseUint(ctx.raw_value)),
-        .fixed_value => |ev| handle.setFixedValue(parseFixed(ctx.raw_value)),
-        .string_value => |ev| handle.setStringValue(if (ctx.raw_value[0] == 0) null else ctx.raw_value),
-    }
-    _ = ctx.display.flush() catch os.exit(1);
-    os.exit(0);
-}
-
-fn modOptionListener(
-    handle: *river.OptionHandleV2,
-    event: river.OptionHandleV2.Event,
-    ctx: *const Context,
-) void {
-    switch (event) {
-        .undeclared => root.printErrorExit("option '{}' has not been declared", .{ctx.key}),
-        .int_value => |ev| modIntValueRaw(handle, ev.value, ctx.raw_value),
-        .uint_value => |ev| modUintValueRaw(handle, ev.value, ctx.raw_value),
-        .fixed_value => |ev| modFixedValueRaw(handle, ev.value, ctx.raw_value),
-        .string_value => root.printErrorExit("can not modify string options, use set-option to overwrite them", .{}),
-    }
-    _ = ctx.display.flush() catch os.exit(1);
-    os.exit(0);
-}
-
-fn modIntValueRaw(handle: *river.OptionHandleV2, current: i32, raw_value: [*:0]const u8) void {
-    const mod = fmt.parseInt(i32, mem.span(raw_value), 10) catch
-        root.printErrorExit("{} is not a valid int modifier", .{raw_value});
-    const new_value = math.add(i32, current, mod) catch
-        root.printErrorExit("provided value of {d} would overflow option if added", .{mod});
-    handle.setIntValue(new_value);
-}
-
-fn modUintValueRaw(handle: *river.OptionHandleV2, current: u32, raw_value: [*:0]const u8) void {
-    // We need to allow negative mod values, but the value of the option may
-    // never be below zero.
-    const mod = fmt.parseInt(i32, mem.span(raw_value), 10) catch
-        root.printErrorExit("{} is not a valid uint modifier", .{raw_value});
-    const new = @intCast(i32, current) + mod;
-    handle.setUintValue(if (new < 0) 0 else @intCast(u32, new));
-}
-
-fn modFixedValueRaw(handle: *river.OptionHandleV2, current: wl.Fixed, raw_value: [*:0]const u8) void {
-    const mod = fmt.parseFloat(f64, mem.span(raw_value)) catch
-        root.printErrorExit("{} is not a valid fixed modifier", .{raw_value});
-    handle.setFixedValue(wl.Fixed.fromDouble(current.toDouble() + mod));
-}