From 3cb52c4898cb387d1e9b185479e4187f2a1a711a Mon Sep 17 00:00:00 2001 From: Isaac Freund Date: Mon, 13 Apr 2020 19:25:37 +0200 Subject: [PATCH] Parially refactor commands to take a *Seat --- src/command.zig | 164 ++++++++++++++++++++++++++++++++---------------- src/root.zig | 60 +----------------- src/seat.zig | 4 +- src/view.zig | 3 +- 4 files changed, 116 insertions(+), 115 deletions(-) diff --git a/src/command.zig b/src/command.zig index b5c237a..28023ce 100644 --- a/src/command.zig +++ b/src/command.zig @@ -2,7 +2,7 @@ const std = @import("std"); const c = @import("c.zig"); const Log = @import("log.zig").Log; -const Server = @import("server.zig").Server; +const Seat = @import("seat.zig").Seat; const View = @import("view.zig").View; const ViewStack = @import("view_stack.zig").ViewStack; @@ -14,107 +14,162 @@ pub const Arg = union { none: void, }; -pub const Command = fn (server: *Server, arg: Arg) void; +pub const Command = fn (seat: *Seat, arg: Arg) void; /// Exit the compositor, terminating the wayland session. -pub fn exitCompositor(server: *Server, arg: Arg) void { - c.wl_display_terminate(server.wl_display); +pub fn exitCompositor(seat: *Seat, arg: Arg) void { + c.wl_display_terminate(seat.input_manager.server.wl_display); } -/// Shift focus to the next visible view, wrapping if needed. -pub fn focusNextView(server: *Server, arg: Arg) void { - server.root.focusNextView(); +/// Focus the next visible view in the stack, wrapping if needed. Does +/// nothing if there is only one view in the stack. +pub fn focusNextView(seat: *Seat, arg: Arg) void { + // FIXME: this need to be rewritten the next commit adding a focus stack + //const output = self.focusedOutput(); + //if (self.focused_view) |current_focus| { + // // If there is a currently focused view, focus the next visible view in the stack. + // const current_node = @fieldParentPtr(ViewStack(View).Node, "view", current_focus); + // var it = ViewStack(View).iterator(current_node, output.current_focused_tags); + // // Skip past the current node + // _ = it.next(); + // // Focus the next visible node if there is one + // if (it.next()) |node| { + // node.view.focus(node.view.wlr_xdg_surface.surface); + // return; + // } + //} + + //// There is either no currently focused view or the last visible view in the + //// stack is focused and we need to wrap. + //var it = ViewStack(View).iterator(output.views.first, output.current_focused_tags); + //if (it.next()) |node| { + // node.view.focus(node.view.wlr_xdg_surface.surface); + //} else { + // // Otherwise clear the focus since there are no visible views + // self.clearFocus(); + //} } -/// Shift focus to the previous visible view, wrapping if needed. -pub fn focusPrevView(server: *Server, arg: Arg) void { - server.root.focusPrevView(); +/// Focus the previous view in the stack, wrapping if needed. Does nothing +/// if there is only one view in the stack. +pub fn focusPrevView(seat: *Seat, arg: Arg) void { + // FIXME: this need to be rewritten the next commit adding a focus stack + //const output = self.focusedOutput(); + //if (self.focused_view) |current_focus| { + // // If there is a currently focused view, focus the previous visible view in the stack. + // const current_node = @fieldParentPtr(ViewStack(View).Node, "view", current_focus); + // var it = ViewStack(View).reverseIterator(current_node, output.current_focused_tags); + // // Skip past the current node + // _ = it.next(); + // // Focus the previous visible node if there is one + // if (it.next()) |node| { + // node.view.focus(node.view.wlr_xdg_surface.surface); + // return; + // } + //} + + //// There is either no currently focused view or the first visible view in the + //// stack is focused and we need to wrap. + //var it = ViewStack(View).reverseIterator(output.views.last, output.current_focused_tags); + //if (it.next()) |node| { + // node.view.focus(node.view.wlr_xdg_surface.surface); + //} else { + // // Otherwise clear the focus since there are no visible views + // self.clearFocus(); + //} } /// Modify the number of master views -pub fn modifyMasterCount(server: *Server, arg: Arg) void { +pub fn modifyMasterCount(seat: *Seat, arg: Arg) void { const delta = arg.int; - const output = server.root.focusedOutput(); + const root = &seat.input_manager.server.root; + const output = root.focusedOutput(); output.master_count = @intCast( u32, std.math.max(0, @intCast(i32, output.master_count) + delta), ); - server.root.arrange(); + root.arrange(); } /// Modify the percent of the width of the screen that the master views occupy. -pub fn modifyMasterFactor(server: *Server, arg: Arg) void { +pub fn modifyMasterFactor(seat: *Seat, arg: Arg) void { const delta = arg.float; - const output = server.root.focusedOutput(); + const root = &seat.input_manager.server.root; + const output = root.focusedOutput(); const new_master_factor = std.math.min( std.math.max(output.master_factor + delta, 0.05), 0.95, ); if (new_master_factor != output.master_factor) { output.master_factor = new_master_factor; - server.root.arrange(); + root.arrange(); } } /// Bump the focused view to the top of the stack. /// TODO: if the top of the stack is focused, bump the next visible view. -pub fn zoom(server: *Server, arg: Arg) void { - if (server.root.focused_view) |current_focus| { - const output = server.root.focusedOutput(); - const node = @fieldParentPtr(ViewStack(View).Node, "view", current_focus); - if (node != output.views.first) { - output.views.remove(node); - output.views.push(node); - server.root.arrange(); - } - } +pub fn zoom(seat: *Seat, arg: Arg) void { + // FIXME rewrite after next commit adding focus stack + //if (server.root.focused_view) |current_focus| { + // const output = server.root.focusedOutput(); + // const node = @fieldParentPtr(ViewStack(View).Node, "view", current_focus); + // if (node != output.views.first) { + // output.views.remove(node); + // output.views.push(node); + // server.root.arrange(); + // } + //} } /// Switch focus to the passed tags. -pub fn focusTags(server: *Server, arg: Arg) void { +pub fn focusTags(seat: *Seat, arg: Arg) void { const tags = arg.uint; - const output = server.root.focusedOutput(); + const root = &seat.input_manager.server.root; + const output = root.focusedOutput(); output.pending_focused_tags = tags; - server.root.arrange(); + root.arrange(); } /// Toggle focus of the passsed tags. -pub fn toggleTags(server: *Server, arg: Arg) void { +pub fn toggleTags(seat: *Seat, arg: Arg) void { const tags = arg.uint; - const output = server.root.focusedOutput(); + const root = &seat.input_manager.server.root; + const output = root.focusedOutput(); const new_focused_tags = output.current_focused_tags ^ tags; if (new_focused_tags != 0) { output.pending_focused_tags = new_focused_tags; - server.root.arrange(); + root.arrange(); } } /// Set the tags of the focused view. -pub fn setFocusedViewTags(server: *Server, arg: Arg) void { - const tags = arg.uint; - if (server.root.focused_view) |view| { - if (view.current_tags != tags) { - view.pending_tags = tags; - server.root.arrange(); - } - } +pub fn setFocusedViewTags(seat: *Seat, arg: Arg) void { + // FIXME + //const tags = arg.uint; + //if (server.root.focused_view) |view| { + // if (view.current_tags != tags) { + // view.pending_tags = tags; + // server.root.arrange(); + // } + //} } /// Toggle the passed tags of the focused view -pub fn toggleFocusedViewTags(server: *Server, arg: Arg) void { - const tags = arg.uint; - if (server.root.focused_view) |view| { - const new_tags = view.current_tags ^ tags; - if (new_tags != 0) { - view.pending_tags = new_tags; - server.root.arrange(); - } - } +pub fn toggleFocusedViewTags(seat: *Seat, arg: Arg) void { + // FIXME: rewrite afet next commit adding focus stack + //const tags = arg.uint; + //if (server.root.focused_view) |view| { + // const new_tags = view.current_tags ^ tags; + // if (new_tags != 0) { + // view.pending_tags = new_tags; + // server.root.arrange(); + // } + //} } /// Spawn a program. /// TODO: make this take a program as a paramter and spawn that -pub fn spawn(server: *Server, arg: Arg) void { +pub fn spawn(seat: *Seat, arg: Arg) void { const cmd = arg.str; const argv = [_][]const u8{ "/bin/sh", "-c", cmd }; @@ -129,8 +184,9 @@ pub fn spawn(server: *Server, arg: Arg) void { } /// Close the focused view, if any. -pub fn close(server: *Server, arg: Arg) void { - if (server.root.focused_view) |view| { - view.close(); - } +pub fn close(seat: *Seat, arg: Arg) void { + // FIXME: see above + //if (server.root.focused_view) |view| { + // view.close(); + //} } diff --git a/src/root.zig b/src/root.zig index a5f2bf0..38c09f6 100644 --- a/src/root.zig +++ b/src/root.zig @@ -89,62 +89,6 @@ pub const Root = struct { self.focused_view = null; } - /// Focus the next visible view in the stack, wrapping if needed. Does - /// nothing if there is only one view in the stack. - pub fn focusNextView(self: *Self) void { - const output = self.focusedOutput(); - if (self.focused_view) |current_focus| { - // If there is a currently focused view, focus the next visible view in the stack. - const current_node = @fieldParentPtr(ViewStack(View).Node, "view", current_focus); - var it = ViewStack(View).iterator(current_node, output.current_focused_tags); - // Skip past the current node - _ = it.next(); - // Focus the next visible node if there is one - if (it.next()) |node| { - node.view.focus(node.view.wlr_xdg_surface.surface); - return; - } - } - - // There is either no currently focused view or the last visible view in the - // stack is focused and we need to wrap. - var it = ViewStack(View).iterator(output.views.first, output.current_focused_tags); - if (it.next()) |node| { - node.view.focus(node.view.wlr_xdg_surface.surface); - } else { - // Otherwise clear the focus since there are no visible views - self.clearFocus(); - } - } - - /// Focus the previous view in the stack, wrapping if needed. Does nothing - /// if there is only one view in the stack. - pub fn focusPrevView(self: *Self) void { - const output = self.focusedOutput(); - if (self.focused_view) |current_focus| { - // If there is a currently focused view, focus the previous visible view in the stack. - const current_node = @fieldParentPtr(ViewStack(View).Node, "view", current_focus); - var it = ViewStack(View).reverseIterator(current_node, output.current_focused_tags); - // Skip past the current node - _ = it.next(); - // Focus the previous visible node if there is one - if (it.next()) |node| { - node.view.focus(node.view.wlr_xdg_surface.surface); - return; - } - } - - // There is either no currently focused view or the first visible view in the - // stack is focused and we need to wrap. - var it = ViewStack(View).reverseIterator(output.views.last, output.current_focused_tags); - if (it.next()) |node| { - node.view.focus(node.view.wlr_xdg_surface.surface); - } else { - // Otherwise clear the focus since there are no visible views - self.clearFocus(); - } - } - /// Arrange all outputs and then a transaction. pub fn arrange(self: *Self) void { var it = self.outputs.first; @@ -257,7 +201,7 @@ pub const Root = struct { output.pending_focused_tags = null; self.focused_view = null; - self.focusNextView(); + Log.Error.log("FIXME: this needs to iterate over all seats and focus(null)", .{}); } var view_it = ViewStack(View).iterator(output.views.first, 0xFFFFFFFF); @@ -281,7 +225,7 @@ pub const Root = struct { if (focus == view and view.current_tags & output.current_focused_tags == 0) { - self.focusNextView(); + Log.Error.log("FIXME: this needs to iterate over all seats and focus(null)", .{}); } } } diff --git a/src/seat.zig b/src/seat.zig index 674f0eb..646945c 100644 --- a/src/seat.zig +++ b/src/seat.zig @@ -36,11 +36,11 @@ pub const Seat = struct { /// Handle any user-defined keybinding for the passed keysym and modifiers /// Returns true if the key was handled - pub fn handleKeybinding(self: Self, keysym: c.xkb_keysym_t, modifiers: u32) bool { + pub fn handleKeybinding(self: *Self, keysym: c.xkb_keysym_t, modifiers: u32) bool { for (self.input_manager.server.config.keybinds.items) |keybind| { if (modifiers == keybind.modifiers and keysym == keybind.keysym) { // Execute the bound command - keybind.command(self.input_manager.server, keybind.arg); + keybind.command(self, keybind.arg); return true; } } diff --git a/src/view.zig b/src/view.zig index 191bcf8..aa35887 100644 --- a/src/view.zig +++ b/src/view.zig @@ -145,7 +145,8 @@ pub const View = struct { // If the view being unmapped is focused if (current_focus == view) { // Focus the previous view. This clears the focus if there are no visible views. - root.focusPrevView(); + // FIXME: must be fixed in next commit adding focus stack + //root.focusPrevView(); } }