diff options
Diffstat (limited to 'src/command.zig')
| -rw-r--r-- | src/command.zig | 157 |
1 files changed, 157 insertions, 0 deletions
diff --git a/src/command.zig b/src/command.zig new file mode 100644 index 0000000..745c86c --- /dev/null +++ b/src/command.zig @@ -0,0 +1,157 @@ +// This file is part of river, a dynamic tiling wayland compositor. +// +// Copyright 2020 Isaac Freund +// +// 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 Seat = @import("Seat.zig"); + +const impl = struct { + const close = @import("command/close.zig").close; + const exit = @import("command/exit.zig").exit; + const focus = @import("command/focus.zig").focus; + const focusAllTags = @import("command/focus_all_tags.zig").focusAllTags; + const focusOutput = @import("command/focus_output.zig").focusOutput; + const focusTag = @import("command/focus_tag.zig").focusTag; + const layout = @import("command/layout.zig").layout; + const modMasterCount = @import("command/mod_master_count.zig").modMasterCount; + const modMasterFactor = @import("command/mod_master_factor.zig").modMasterFactor; + const mode = @import("command/mode.zig").mode; + const sendToOutput = @import("command/send_to_output.zig").sendToOutput; + const spawn = @import("command/spawn.zig").spawn; + const tagView = @import("command/tag_view.zig").tagView; + const tagViewAllTags = @import("command/tag_view_all_tags.zig").tagViewAllTags; + const toggleFloat = @import("command/toggle_float.zig").toggleFloat; + const toggleTagFocus = @import("command/toggle_tag_focus.zig").toggleTagFocus; + const toggleViewTag = @import("command/toggle_view_tag.zig").toggleViewTag; + const zoom = @import("command/zoom.zig").zoom; +}; + +pub const Direction = enum { + Next, + Prev, + + pub fn parse(str: []const u8) error{InvalidDirection}!Direction { + return if (std.mem.eql(u8, str, "next")) + Direction.Next + else if (std.mem.eql(u8, str, "previous")) + Direction.Prev + else + error.InvalidDirection; + } +}; + +const Arg = union(enum) { + int: i32, + uint: u32, + float: f64, + str: []const u8, + direction: Direction, + none: void, + + fn parse( + arg_type: @TagType(Arg), + args: []const []const u8, + allocator: *std.mem.Allocator, + ) !Arg { + switch (arg_type) { + .int, .uint, .float, .direction => { + if (args.len == 0) return error.NotEnoughArguments; + if (args.len > 1) return error.TooManyArguments; + return switch (arg_type) { + .int => .{ .int = try std.fmt.parseInt(i32, args[0], 10) }, + .uint => .{ .uint = try std.fmt.parseInt(u32, args[0], 10) }, + .float => .{ .float = try std.fmt.parseFloat(f64, args[0]) }, + .direction => if (std.mem.eql(u8, args[0], "next")) + Arg{ .direction = .Next } + else if (std.mem.eql(u8, args[0], "previous")) + Arg{ .direction = .Prev } + else + error.InvalidDirection, + else => unreachable, + }; + }, + .str => { + if (args.len == 0) return error.NotEnoughArguments; + return Arg{ .str = try std.mem.join(allocator, " ", args) }; + }, + .none => return if (args.len == 0) .{ .none = {} } else error.TooManyArguments, + } + } +}; + +const Definition = struct { + name: []const u8, + impl: fn (*std.mem.Allocator, *Seat, []const []const u8, *[]const u8) Error!void, +}; + +// TODO: this could be replaced with a comptime hashmap +// zig fmt: off +const str_to_impl_fn = [_]Definition{ + .{ .name = "close", .impl = impl.close }, + .{ .name = "exit", .impl = impl.exit }, + .{ .name = "focus", .impl = impl.focus }, + .{ .name = "focus_all_tags", .impl = impl.focusAllTags }, + .{ .name = "focus_output", .impl = impl.focusOutput }, + .{ .name = "focus_tag", .impl = impl.focusTag }, + .{ .name = "layout", .impl = impl.layout}, + .{ .name = "mod_master_count", .impl = impl.modMasterCount }, + .{ .name = "mod_master_factor", .impl = impl.modMasterFactor }, + .{ .name = "mode", .impl = impl.mode }, + .{ .name = "send_to_output", .impl = impl.sendToOutput }, + .{ .name = "spawn", .impl = impl.spawn }, + .{ .name = "tag_view", .impl = impl.tagView }, + .{ .name = "tag_view_all_tags", .impl = impl.tagViewAllTags }, + .{ .name = "toggle_float", .impl = impl.toggleFloat }, + .{ .name = "toggle_tag_focus", .impl = impl.toggleTagFocus }, + .{ .name = "toggle_view_tag", .impl = impl.toggleViewTag }, + .{ .name = "zoom", .impl = impl.zoom }, +}; +// zig fmt: on + +pub const Error = error{ + NoCommand, + UnknownCommand, + NotEnoughArguments, + TooManyArguments, + Overflow, + InvalidCharacter, + InvalidDirection, + OutOfMemory, + CommandFailed, +}; + +/// Run a command for the given Seat. The `args` parameter is similar to the +/// classic argv in that the command to be run is passed as the first argument. +/// If the command fails with Error.CommandFailed, a failure message will be +/// allocated and the slice pointed to by the `failure_message` parameter will +/// be set to point to it. The caller is responsible for freeing this message +/// in the case of failure. +pub fn run( + allocator: *std.mem.Allocator, + seat: *Seat, + args: []const []const u8, + failure_message: *[]const u8, +) Error!void { + if (args.len == 0) return Error.NoCommand; + + const name = args[0]; + const impl_fn = for (str_to_impl_fn) |definition| { + if (std.mem.eql(u8, name, definition.name)) break definition.impl; + } else return Error.UnknownCommand; + + try impl_fn(allocator, seat, args, failure_message); +} |