Diff
diff --git a/src/main.zig b/src/main.zig
index 4cabe96..bbd6c4a 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -200,8 +200,8 @@ pub fn main() !void {
std.debug.print("successfully became window manager\n", .{});
std.debug.print("atoms initialized with EWMH support\n", .{});
- grab_keybinds(&wm.display, &wm);
- scan_existing_windows(&wm.display, &wm);
+ grab_keybinds(&wm);
+ scan_existing_windows(&wm);
try run_autostart_commands(allocator, wm.config.autostart.items);
std.debug.print("entering event loop\n", .{});
@@ -271,8 +271,9 @@ fn initialize_default_config(cfg: *config_mod.Config) void {
cfg.add_button(.{ .click = .client_win, .mod_mask = mod_key, .button = 3, .action = .resize_mouse }) catch {};
}
-fn grab_keybinds(display: *Display, wm: *WindowManager) void {
- update_numlock_mask(display, wm);
+fn grab_keybinds(wm: *WindowManager) void {
+ const display = &wm.display;
+ update_numlock_mask(wm);
const modifiers = [_]c_uint{ 0, xlib.LockMask, wm.numlock_mask, wm.numlock_mask | xlib.LockMask };
_ = xlib.XUngrabKey(display.handle, xlib.AnyKey, xlib.AnyModifier, display.root);
@@ -318,7 +319,8 @@ fn grab_keybinds(display: *Display, wm: *WindowManager) void {
std.debug.print("grabbed {d} keybinds from config\n", .{wm.config.keybinds.items.len});
}
-fn get_state(display: *Display, window: xlib.Window, wm: *WindowManager) c_long {
+fn get_state(window: xlib.Window, wm: *WindowManager) c_long {
+ const display = &wm.display;
var actual_type: xlib.Atom = 0;
var actual_format: c_int = 0;
var num_items: c_ulong = 0;
@@ -352,7 +354,8 @@ fn get_state(display: *Display, window: xlib.Window, wm: *WindowManager) c_long
return state;
}
-fn scan_existing_windows(display: *Display, wm: *WindowManager) void {
+fn scan_existing_windows(wm: *WindowManager) void {
+ const display = &wm.display;
var root_return: xlib.Window = undefined;
var parent_return: xlib.Window = undefined;
var children: [*c]xlib.Window = undefined;
@@ -375,8 +378,8 @@ fn scan_existing_windows(display: *Display, wm: *WindowManager) void {
if (xlib.XGetTransientForHint(display.handle, children[index], &trans) != 0) {
continue;
}
- if (window_attrs.map_state == IsViewable or get_state(display, children[index], wm) == IconicState) {
- manage(display, children[index], &window_attrs, wm);
+ if (window_attrs.map_state == IsViewable or get_state(children[index], wm) == IconicState) {
+ manage(children[index], &window_attrs, wm);
}
}
@@ -388,8 +391,8 @@ fn scan_existing_windows(display: *Display, wm: *WindowManager) void {
}
var trans: xlib.Window = 0;
if (xlib.XGetTransientForHint(display.handle, children[index], &trans) != 0) {
- if (window_attrs.map_state == IsViewable or get_state(display, children[index], wm) == IconicState) {
- manage(display, children[index], &window_attrs, wm);
+ if (window_attrs.map_state == IsViewable or get_state(children[index], wm) == IconicState) {
+ manage(children[index], &window_attrs, wm);
}
}
}
@@ -409,7 +412,7 @@ fn run_event_loop(wm: *WindowManager) void {
while (wm.running) {
while (xlib.XPending(wm.display.handle) > 0) {
var event = wm.display.next_event();
- handle_event(&wm.display, &event, wm);
+ handle_event(&event, wm);
}
tick_animations(wm);
@@ -426,7 +429,7 @@ fn run_event_loop(wm: *WindowManager) void {
}
}
-fn handle_event(display: *Display, event: *xlib.XEvent, wm: *WindowManager) void {
+fn handle_event(event: *xlib.XEvent, wm: *WindowManager) void {
const event_type = events.get_event_type(event);
if (event_type == .button_press) {
@@ -434,23 +437,24 @@ fn handle_event(display: *Display, event: *xlib.XEvent, wm: *WindowManager) void
}
switch (event_type) {
- .map_request => handle_map_request(display, &event.xmaprequest, wm),
- .configure_request => handle_configure_request(display, &event.xconfigurerequest, wm),
- .key_press => handle_key_press(display, &event.xkey, wm),
- .destroy_notify => handle_destroy_notify(display, &event.xdestroywindow, wm),
- .unmap_notify => handle_unmap_notify(display, &event.xunmap, wm),
- .enter_notify => handle_enter_notify(display, &event.xcrossing, wm),
- .focus_in => handle_focus_in(display, &event.xfocus, wm),
- .motion_notify => handle_motion_notify(display, &event.xmotion, wm),
- .client_message => handle_client_message(display, &event.xclient, wm),
- .button_press => handle_button_press(display, &event.xbutton, wm),
- .expose => handle_expose(display, &event.xexpose, wm),
- .property_notify => handle_property_notify(display, &event.xproperty, wm),
+ .map_request => handle_map_request(&event.xmaprequest, wm),
+ .configure_request => handle_configure_request(&event.xconfigurerequest, wm),
+ .key_press => handle_key_press(&event.xkey, wm),
+ .destroy_notify => handle_destroy_notify(&event.xdestroywindow, wm),
+ .unmap_notify => handle_unmap_notify(&event.xunmap, wm),
+ .enter_notify => handle_enter_notify(&event.xcrossing, wm),
+ .focus_in => handle_focus_in(&event.xfocus, wm),
+ .motion_notify => handle_motion_notify(&event.xmotion, wm),
+ .client_message => handle_client_message(&event.xclient, wm),
+ .button_press => handle_button_press(&event.xbutton, wm),
+ .expose => handle_expose(&event.xexpose, wm),
+ .property_notify => handle_property_notify(&event.xproperty, wm),
else => {},
}
}
-fn handle_map_request(display: *Display, event: *xlib.XMapRequestEvent, wm: *WindowManager) void {
+fn handle_map_request(event: *xlib.XMapRequestEvent, wm: *WindowManager) void {
+ const display = &wm.display;
std.debug.print("map_request: window=0x{x}\n", .{event.window});
var window_attributes: xlib.XWindowAttributes = undefined;
@@ -464,10 +468,11 @@ fn handle_map_request(display: *Display, event: *xlib.XMapRequestEvent, wm: *Win
return;
}
- manage(display, event.window, &window_attributes, wm);
+ manage(event.window, &window_attributes, wm);
}
-fn manage(display: *Display, win: xlib.Window, window_attrs: *xlib.XWindowAttributes, wm: *WindowManager) void {
+fn manage(win: xlib.Window, window_attrs: *xlib.XWindowAttributes, wm: *WindowManager) void {
+ const display = &wm.display;
const client = client_mod.create(gpa.allocator(), win) orelse return;
var trans: xlib.Window = 0;
@@ -482,7 +487,7 @@ fn manage(display: *Display, win: xlib.Window, window_attrs: *xlib.XWindowAttrib
client.old_border_width = window_attrs.border_width;
client.border_width = wm.config.border_width;
- update_title(display, client, wm);
+ update_title(client, wm);
if (xlib.XGetTransientForHint(display.handle, win, &trans) != 0) {
if (client_mod.window_to_client(monitor_mod.monitors, trans)) |transient_client| {
@@ -493,7 +498,7 @@ fn manage(display: *Display, win: xlib.Window, window_attrs: *xlib.XWindowAttrib
if (client.monitor == null) {
client.monitor = monitor_mod.selected_monitor;
- apply_rules(display, client, wm);
+ apply_rules(client, wm);
}
const monitor = client.monitor orelse return;
@@ -511,16 +516,16 @@ fn manage(display: *Display, win: xlib.Window, window_attrs: *xlib.XWindowAttrib
_ = xlib.XSetWindowBorder(display.handle, win, wm.config.border_unfocused);
tiling.send_configure(client);
- update_window_type(display, client, wm);
- update_size_hints(display, client);
- update_wm_hints(display, client);
+ update_window_type(client, wm);
+ update_size_hints(client, wm);
+ update_wm_hints(client, wm);
_ = xlib.XSelectInput(
display.handle,
win,
xlib.EnterWindowMask | xlib.FocusChangeMask | xlib.PropertyChangeMask | xlib.StructureNotifyMask,
);
- grabbuttons(display, client, false, wm);
+ grabbuttons(client, false, wm);
if (!client.is_floating) {
client.is_floating = trans != 0 or client.is_fixed;
@@ -535,11 +540,11 @@ fn manage(display: *Display, win: xlib.Window, window_attrs: *xlib.XWindowAttrib
_ = xlib.XChangeProperty(display.handle, display.root, wm.atoms.net_client_list, xlib.XA_WINDOW, 32, xlib.PropModeAppend, @ptrCast(&client.window), 1);
_ = xlib.XMoveResizeWindow(display.handle, client.window, client.x + 2 * display.screen_width(), client.y, @intCast(client.width), @intCast(client.height));
- set_client_state(display, client, NormalState, wm);
+ set_client_state(client, NormalState, wm);
if (client.monitor == monitor_mod.selected_monitor) {
const selmon = monitor_mod.selected_monitor orelse return;
- unfocus_client(display, selmon.sel, false, wm);
+ unfocus_client(selmon.sel, false, wm);
}
monitor.sel = client;
@@ -549,11 +554,11 @@ fn manage(display: *Display, win: xlib.Window, window_attrs: *xlib.XWindowAttrib
arrange(monitor, wm);
_ = xlib.XMapWindow(display.handle, win);
- focus(display, null, wm);
+ focus(null, wm);
}
-fn handle_configure_request(display: *Display, event: *xlib.XConfigureRequestEvent, wm: *WindowManager) void {
- _ = wm;
+fn handle_configure_request(event: *xlib.XConfigureRequestEvent, wm: *WindowManager) void {
+ const display = &wm.display;
const client = client_mod.window_to_client(monitor_mod.monitors, event.window);
if (client) |managed_client| {
@@ -608,7 +613,8 @@ fn handle_configure_request(display: *Display, event: *xlib.XConfigureRequestEve
_ = xlib.XSync(display.handle, xlib.False);
}
-fn handle_key_press(display: *Display, event: *xlib.XKeyEvent, wm: *WindowManager) void {
+fn handle_key_press(event: *xlib.XKeyEvent, wm: *WindowManager) void {
+ const display = &wm.display;
const keysym = xlib.XKeycodeToKeysym(display.handle, @intCast(event.keycode), 0);
if (wm.overlay) |overlay| {
@@ -637,7 +643,7 @@ fn handle_key_press(display: *Display, event: *xlib.XKeyEvent, wm: *WindowManage
}
}
if (matches) {
- execute_action(display, keybind.action, keybind.int_arg, keybind.str_arg, wm);
+ execute_action(keybind.action, keybind.int_arg, keybind.str_arg, wm);
wm.chord.reset(display.handle);
return;
}
@@ -670,19 +676,19 @@ fn handle_key_press(display: *Display, event: *xlib.XKeyEvent, wm: *WindowManage
}
}
-fn execute_action(display: *Display, action: config_mod.Action, int_arg: i32, str_arg: ?[]const u8, wm: *WindowManager) void {
+fn execute_action(action: config_mod.Action, int_arg: i32, str_arg: ?[]const u8, wm: *WindowManager) void {
switch (action) {
.spawn_terminal => spawn_terminal(wm),
.spawn => {
if (str_arg) |cmd| spawn_command(cmd);
},
- .kill_client => kill_focused(display, wm),
+ .kill_client => kill_focused(wm),
.quit => {
std.debug.print("quit keybind pressed\n", .{});
wm.running = false;
},
- .reload_config => reload_config(display, wm),
- .restart => reload_config(display, wm),
+ .reload_config => reload_config(wm),
+ .restart => reload_config(wm),
.show_keybinds => {
if (wm.overlay) |overlay| {
const mon = wm.selected_monitor orelse wm.monitors;
@@ -691,15 +697,15 @@ fn execute_action(display: *Display, action: config_mod.Action, int_arg: i32, st
}
}
},
- .focus_next => focusstack(display, 1, wm),
- .focus_prev => focusstack(display, -1, wm),
- .move_next => movestack(display, 1, wm),
- .move_prev => movestack(display, -1, wm),
+ .focus_next => focusstack(1, wm),
+ .focus_prev => focusstack(-1, wm),
+ .move_next => movestack(1, wm),
+ .move_prev => movestack(-1, wm),
.resize_master => setmfact(@as(f32, @floatFromInt(int_arg)) / 1000.0, wm),
.inc_master => incnmaster(1, wm),
.dec_master => incnmaster(-1, wm),
- .toggle_floating => toggle_floating(display, wm),
- .toggle_fullscreen => toggle_fullscreen(display, wm),
+ .toggle_floating => toggle_floating(wm),
+ .toggle_fullscreen => toggle_fullscreen(wm),
.toggle_gaps => toggle_gaps(wm),
.cycle_layout => cycle_layout(wm),
.set_layout => set_layout(str_arg, wm),
@@ -707,35 +713,36 @@ fn execute_action(display: *Display, action: config_mod.Action, int_arg: i32, st
.set_layout_floating => set_layout_index(2, wm),
.view_tag => {
const tag_mask: u32 = @as(u32, 1) << @intCast(int_arg);
- view(display, tag_mask, wm);
+ view(tag_mask, wm);
},
- .view_next_tag => view_adjacent_tag(display, 1, wm),
- .view_prev_tag => view_adjacent_tag(display, -1, wm),
- .view_next_nonempty_tag => view_adjacent_nonempty_tag(display, 1, wm),
- .view_prev_nonempty_tag => view_adjacent_nonempty_tag(display, -1, wm),
+ .view_next_tag => view_adjacent_tag(1, wm),
+ .view_prev_tag => view_adjacent_tag(-1, wm),
+ .view_next_nonempty_tag => view_adjacent_nonempty_tag(1, wm),
+ .view_prev_nonempty_tag => view_adjacent_nonempty_tag(-1, wm),
.move_to_tag => {
const tag_mask: u32 = @as(u32, 1) << @intCast(int_arg);
- tag_client(display, tag_mask, wm);
+ tag_client(tag_mask, wm);
},
.toggle_view_tag => {
const tag_mask: u32 = @as(u32, 1) << @intCast(int_arg);
- toggle_view(display, tag_mask, wm);
+ toggle_view(tag_mask, wm);
},
.toggle_tag => {
const tag_mask: u32 = @as(u32, 1) << @intCast(int_arg);
- toggle_client_tag(display, tag_mask, wm);
+ toggle_client_tag(tag_mask, wm);
},
- .focus_monitor => focusmon(display, int_arg, wm),
- .send_to_monitor => sendmon(display, int_arg, wm),
+ .focus_monitor => focusmon(int_arg, wm),
+ .send_to_monitor => sendmon(int_arg, wm),
.scroll_left => scroll_layout(-1, wm),
.scroll_right => scroll_layout(1, wm),
}
}
-fn reload_config(display: *Display, wm: *WindowManager) void {
+fn reload_config(wm: *WindowManager) void {
+ const display = &wm.display;
std.debug.print("reloading config...\n", .{});
- ungrab_keybinds(display);
+ ungrab_keybinds(wm);
wm.config.keybinds.clearRetainingCapacity();
wm.config.buttons.clearRetainingCapacity();
@@ -766,7 +773,7 @@ fn reload_config(display: *Display, wm: *WindowManager) void {
wm.setup_bars();
rebuild_bar_blocks(wm);
- grab_keybinds(display, wm);
+ grab_keybinds(wm);
}
fn rebuild_bar_blocks(wm: *WindowManager) void {
@@ -778,7 +785,8 @@ fn rebuild_bar_blocks(wm: *WindowManager) void {
}
}
-fn ungrab_keybinds(display: *Display) void {
+fn ungrab_keybinds(wm: *WindowManager) void {
+ const display = &wm.display;
_ = xlib.XUngrabKey(display.handle, xlib.AnyKey, xlib.AnyModifier, display.root);
}
@@ -829,7 +837,7 @@ fn spawn_terminal(wm: *WindowManager) void {
}
}
-fn movestack(display: *Display, direction: i32, wm: *WindowManager) void {
+fn movestack(direction: i32, wm: *WindowManager) void {
const monitor = monitor_mod.selected_monitor orelse return;
const current = monitor.sel orelse return;
@@ -887,12 +895,12 @@ fn movestack(display: *Display, direction: i32, wm: *WindowManager) void {
if (swap_client != current) {
client_mod.swap_clients(current, swap_client);
arrange(monitor, wm);
- focus(display, current, wm);
+ focus(current, wm);
}
}
}
-fn toggle_view(display: *Display, tag_mask: u32, wm: *WindowManager) void {
+fn toggle_view(tag_mask: u32, wm: *WindowManager) void {
const monitor = monitor_mod.selected_monitor orelse return;
const new_tags = monitor.tagset[monitor.sel_tags] ^ tag_mask;
if (new_tags != 0) {
@@ -916,19 +924,19 @@ fn toggle_view(display: *Display, tag_mask: u32, wm: *WindowManager) void {
monitor.mfact = monitor.pertag.mfacts[monitor.pertag.curtag];
monitor.sel_lt = monitor.pertag.sellts[monitor.pertag.curtag];
- focus_top_client(display, monitor, wm);
+ focus_top_client(monitor, wm);
arrange(monitor, wm);
wm.invalidate_bars();
}
}
-fn toggle_client_tag(display: *Display, tag_mask: u32, wm: *WindowManager) void {
+fn toggle_client_tag(tag_mask: u32, wm: *WindowManager) void {
const monitor = monitor_mod.selected_monitor orelse return;
const client = monitor.sel orelse return;
const new_tags = client.tags ^ tag_mask;
if (new_tags != 0) {
client.tags = new_tags;
- focus_top_client(display, monitor, wm);
+ focus_top_client(monitor, wm);
arrange(monitor, wm);
wm.invalidate_bars();
}
@@ -950,12 +958,13 @@ fn toggle_gaps(wm: *WindowManager) void {
arrange(monitor, wm);
}
-fn kill_focused(display: *Display, wm: *WindowManager) void {
+fn kill_focused(wm: *WindowManager) void {
+ const display = &wm.display;
const selected = monitor_mod.selected_monitor orelse return;
const client = selected.sel orelse return;
std.debug.print("killing window: 0x{x}\n", .{client.window});
- if (!send_event(display, client, wm.atoms.wm_delete, wm)) {
+ if (!send_event(client, wm.atoms.wm_delete, wm)) {
_ = xlib.XGrabServer(display.handle);
_ = xlib.XKillClient(display.handle, client.window);
_ = xlib.XSync(display.handle, xlib.False);
@@ -963,13 +972,14 @@ fn kill_focused(display: *Display, wm: *WindowManager) void {
}
}
-fn toggle_fullscreen(display: *Display, wm: *WindowManager) void {
+fn toggle_fullscreen(wm: *WindowManager) void {
const selected = monitor_mod.selected_monitor orelse return;
const client = selected.sel orelse return;
- set_fullscreen(display, client, !client.is_fullscreen, wm);
+ set_fullscreen(client, !client.is_fullscreen, wm);
}
-fn set_fullscreen(display: *Display, client: *Client, fullscreen: bool, wm: *WindowManager) void {
+fn set_fullscreen(client: *Client, fullscreen: bool, wm: *WindowManager) void {
+ const display = &wm.display;
const monitor = client.monitor orelse return;
if (fullscreen and !client.is_fullscreen) {
@@ -1023,7 +1033,7 @@ fn set_fullscreen(display: *Display, client: *Client, fullscreen: bool, wm: *Win
}
}
-fn view(display: *Display, tag_mask: u32, wm: *WindowManager) void {
+fn view(tag_mask: u32, wm: *WindowManager) void {
const monitor = monitor_mod.selected_monitor orelse return;
if (tag_mask == monitor.tagset[monitor.sel_tags]) {
return;
@@ -1052,13 +1062,13 @@ fn view(display: *Display, tag_mask: u32, wm: *WindowManager) void {
monitor.mfact = monitor.pertag.mfacts[monitor.pertag.curtag];
monitor.sel_lt = monitor.pertag.sellts[monitor.pertag.curtag];
- focus_top_client(display, monitor, wm);
+ focus_top_client(monitor, wm);
arrange(monitor, wm);
wm.invalidate_bars();
std.debug.print("view: tag_mask={d}\n", .{monitor.tagset[monitor.sel_tags]});
}
-fn view_adjacent_tag(display: *Display, direction: i32, wm: *WindowManager) void {
+fn view_adjacent_tag(direction: i32, wm: *WindowManager) void {
const monitor = monitor_mod.selected_monitor orelse return;
const current_tag = monitor.pertag.curtag;
var new_tag: i32 = @intCast(current_tag);
@@ -1068,10 +1078,10 @@ fn view_adjacent_tag(display: *Display, direction: i32, wm: *WindowManager) void
if (new_tag > 9) new_tag = 1;
const tag_mask: u32 = @as(u32, 1) << @intCast(new_tag - 1);
- view(display, tag_mask, wm);
+ view(tag_mask, wm);
}
-fn view_adjacent_nonempty_tag(display: *Display, direction: i32, wm: *WindowManager) void {
+fn view_adjacent_nonempty_tag(direction: i32, wm: *WindowManager) void {
const monitor = monitor_mod.selected_monitor orelse return;
const current_tag = monitor.pertag.curtag;
var new_tag: i32 = @intCast(current_tag);
@@ -1084,7 +1094,7 @@ fn view_adjacent_nonempty_tag(display: *Display, direction: i32, wm: *WindowMana
const tag_mask: u32 = @as(u32, 1) << @intCast(new_tag - 1);
if (has_clients_on_tag(monitor, tag_mask)) {
- view(display, tag_mask, wm);
+ view(tag_mask, wm);
return;
}
}
@@ -1101,24 +1111,25 @@ fn has_clients_on_tag(monitor: *monitor_mod.Monitor, tag_mask: u32) bool {
return false;
}
-fn tag_client(display: *Display, tag_mask: u32, wm: *WindowManager) void {
+fn tag_client(tag_mask: u32, wm: *WindowManager) void {
const monitor = monitor_mod.selected_monitor orelse return;
const client = monitor.sel orelse return;
if (tag_mask == 0) {
return;
}
client.tags = tag_mask;
- focus_top_client(display, monitor, wm);
+ focus_top_client(monitor, wm);
arrange(monitor, wm);
wm.invalidate_bars();
std.debug.print("tag_client: window=0x{x} tag_mask={d}\n", .{ client.window, tag_mask });
}
-fn focus_top_client(display: *Display, monitor: *Monitor, wm: *WindowManager) void {
+fn focus_top_client(monitor: *Monitor, wm: *WindowManager) void {
+ const display = &wm.display;
var visible_client = monitor.stack;
while (visible_client) |client| {
if (client_mod.is_visible(client)) {
- focus(display, client, wm);
+ focus(client, wm);
return;
}
visible_client = client.stack_next;
@@ -1127,7 +1138,7 @@ fn focus_top_client(display: *Display, monitor: *Monitor, wm: *WindowManager) vo
_ = xlib.XSetInputFocus(display.handle, display.root, xlib.RevertToPointerRoot, xlib.CurrentTime);
}
-fn focusstack(display: *Display, direction: i32, wm: *WindowManager) void {
+fn focusstack(direction: i32, wm: *WindowManager) void {
const monitor = monitor_mod.selected_monitor orelse return;
const current = monitor.sel orelse return;
@@ -1175,14 +1186,14 @@ fn focusstack(display: *Display, direction: i32, wm: *WindowManager) void {
}
if (next_client) |client| {
- focus(display, client, wm);
+ focus(client, wm);
if (client.monitor) |client_monitor| {
- restack(display, client_monitor, wm);
+ restack(client_monitor, wm);
}
}
}
-fn toggle_floating(_: *Display, wm: *WindowManager) void {
+fn toggle_floating(wm: *WindowManager) void {
const monitor = monitor_mod.selected_monitor orelse return;
const client = monitor.sel orelse return;
@@ -1281,19 +1292,19 @@ fn set_layout_index(index: u32, wm: *WindowManager) void {
}
}
-fn focusmon(display: *Display, direction: i32, wm: *WindowManager) void {
+fn focusmon(direction: i32, wm: *WindowManager) void {
const selmon = monitor_mod.selected_monitor orelse return;
const target = monitor_mod.dir_to_monitor(direction) orelse return;
if (target == selmon) {
return;
}
- unfocus_client(display, selmon.sel, false, wm);
+ unfocus_client(selmon.sel, false, wm);
monitor_mod.selected_monitor = target;
- focus(display, null, wm);
+ focus(null, wm);
std.debug.print("focusmon: monitor {d}\n", .{target.num});
}
-fn sendmon(display: *Display, direction: i32, wm: *WindowManager) void {
+fn sendmon(direction: i32, wm: *WindowManager) void {
const source_monitor = monitor_mod.selected_monitor orelse return;
const client = source_monitor.sel orelse return;
const target = monitor_mod.dir_to_monitor(direction) orelse return;
@@ -1309,7 +1320,7 @@ fn sendmon(display: *Display, direction: i32, wm: *WindowManager) void {
client_mod.attach_aside(client);
client_mod.attach_stack(client);
- focus_top_client(display, source_monitor, wm);
+ focus_top_client(source_monitor, wm);
arrange(source_monitor, wm);
arrange(target, wm);
@@ -1336,7 +1347,8 @@ fn snap_y(client: *Client, new_y: i32, monitor: *Monitor) i32 {
return new_y;
}
-fn movemouse(display: *Display, wm: *WindowManager) void {
+fn movemouse(wm: *WindowManager) void {
+ const display = &wm.display;
const monitor = monitor_mod.selected_monitor orelse return;
const client = monitor.sel orelse return;
@@ -1344,7 +1356,7 @@ fn movemouse(display: *Display, wm: *WindowManager) void {
return;
}
- restack(display, monitor, wm);
+ restack(monitor, wm);
const was_floating = client.is_floating;
if (!client.is_floating) {
@@ -1422,7 +1434,7 @@ fn movemouse(display: *Display, wm: *WindowManager) void {
client_mod.attach_aside(client);
client_mod.attach_stack(client);
monitor_mod.selected_monitor = new_mon;
- focus(display, client, wm);
+ focus(client, wm);
arrange(monitor, wm);
arrange(new_mon.?, wm);
} else {
@@ -1443,7 +1455,8 @@ fn movemouse(display: *Display, wm: *WindowManager) void {
}
}
-fn resizemouse(display: *Display, wm: *WindowManager) void {
+fn resizemouse(wm: *WindowManager) void {
+ const display = &wm.display;
const monitor = monitor_mod.selected_monitor orelse return;
const client = monitor.sel orelse return;
@@ -1451,7 +1464,7 @@ fn resizemouse(display: *Display, wm: *WindowManager) void {
return;
}
- restack(display, monitor, wm);
+ restack(monitor, wm);
if (!client.is_floating) {
client.is_floating = true;
@@ -1516,7 +1529,8 @@ fn resizemouse(display: *Display, wm: *WindowManager) void {
arrange(monitor, wm);
}
-fn handle_expose(display: *Display, event: *xlib.XExposeEvent, wm: *WindowManager) void {
+fn handle_expose(event: *xlib.XExposeEvent, wm: *WindowManager) void {
+ const display = &wm.display;
if (event.count != 0) return;
if (bar_mod.window_to_bar(wm.bars, event.window)) |bar| {
bar.invalidate();
@@ -1536,17 +1550,18 @@ fn clean_mask(mask: c_uint, wm: *WindowManager) c_uint {
return mask & ~(lock | wm.numlock_mask) & (shift | ctrl | mod1 | mod2 | mod3 | mod4 | mod5);
}
-fn handle_button_press(display: *Display, event: *xlib.XButtonEvent, wm: *WindowManager) void {
+fn handle_button_press(event: *xlib.XButtonEvent, wm: *WindowManager) void {
+ const display = &wm.display;
std.debug.print("button_press: window=0x{x} subwindow=0x{x}\n", .{ event.window, event.subwindow });
const clicked_monitor = monitor_mod.window_to_monitor(display.handle, display.root, event.window);
if (clicked_monitor) |monitor| {
if (monitor != monitor_mod.selected_monitor) {
if (monitor_mod.selected_monitor) |selmon| {
- unfocus_client(display, selmon.sel, true, wm);
+ unfocus_client(selmon.sel, true, wm);
}
monitor_mod.selected_monitor = monitor;
- focus(display, null, wm);
+ focus(null, wm);
}
}
@@ -1554,16 +1569,16 @@ fn handle_button_press(display: *Display, event: *xlib.XButtonEvent, wm: *Window
const clicked_tag = bar.handle_click(display.handle, event.x, wm.config);
if (clicked_tag) |tag_index| {
const tag_mask: u32 = @as(u32, 1) << @intCast(tag_index);
- view(display, tag_mask, wm);
+ view(tag_mask, wm);
}
return;
}
const click_client = client_mod.window_to_client(monitor_mod.monitors, event.window);
if (click_client) |found_client| {
- focus(display, found_client, wm);
+ focus(found_client, wm);
if (monitor_mod.selected_monitor) |selmon| {
- restack(display, selmon, wm);
+ restack(selmon, wm);
}
_ = xlib.XAllowEvents(display.handle, xlib.ReplayPointer, xlib.CurrentTime);
}
@@ -1574,8 +1589,8 @@ fn handle_button_press(display: *Display, event: *xlib.XButtonEvent, wm: *Window
const button_clean_mask = clean_mask(button.mod_mask, wm);
if (clean_state == button_clean_mask and event.button == button.button) {
switch (button.action) {
- .move_mouse => movemouse(display, wm),
- .resize_mouse => resizemouse(display, wm),
+ .move_mouse => movemouse(wm),
+ .resize_mouse => resizemouse(wm),
.toggle_floating => {
if (click_client) |found_client| {
found_client.is_floating = !found_client.is_floating;
@@ -1590,7 +1605,7 @@ fn handle_button_press(display: *Display, event: *xlib.XButtonEvent, wm: *Window
}
}
-fn handle_client_message(display: *Display, event: *xlib.XClientMessageEvent, wm: *WindowManager) void {
+fn handle_client_message(event: *xlib.XClientMessageEvent, wm: *WindowManager) void {
const client = client_mod.window_to_client(monitor_mod.monitors, event.window) orelse return;
if (event.message_type == wm.atoms.net_wm_state) {
@@ -1604,34 +1619,34 @@ fn handle_client_message(display: *Display, event: *xlib.XClientMessageEvent, wm
const net_wm_state_toggle = 2;
if (action == net_wm_state_add) {
- set_fullscreen(display, client, true, wm);
+ set_fullscreen(client, true, wm);
} else if (action == net_wm_state_remove) {
- set_fullscreen(display, client, false, wm);
+ set_fullscreen(client, false, wm);
} else if (action == net_wm_state_toggle) {
- set_fullscreen(display, client, !client.is_fullscreen, wm);
+ set_fullscreen(client, !client.is_fullscreen, wm);
}
}
} else if (event.message_type == wm.atoms.net_active_window) {
const selected = monitor_mod.selected_monitor orelse return;
if (client != selected.sel and !client.is_urgent) {
- set_urgent(display, client, true);
+ set_urgent(client, true, wm);
}
}
}
-fn handle_destroy_notify(display: *Display, event: *xlib.XDestroyWindowEvent, wm: *WindowManager) void {
+fn handle_destroy_notify(event: *xlib.XDestroyWindowEvent, wm: *WindowManager) void {
const client = client_mod.window_to_client(monitor_mod.monitors, event.window) orelse return;
std.debug.print("destroy_notify: window=0x{x}\n", .{event.window});
- unmanage(display, client, wm);
+ unmanage(client, wm);
}
-fn handle_unmap_notify(display: *Display, event: *xlib.XUnmapEvent, wm: *WindowManager) void {
+fn handle_unmap_notify(event: *xlib.XUnmapEvent, wm: *WindowManager) void {
const client = client_mod.window_to_client(monitor_mod.monitors, event.window) orelse return;
std.debug.print("unmap_notify: window=0x{x}\n", .{event.window});
- unmanage(display, client, wm);
+ unmanage(client, wm);
}
-fn unmanage(display: *Display, client: *Client, wm: *WindowManager) void {
+fn unmanage(client: *Client, wm: *WindowManager) void {
const client_monitor = client.monitor;
var next_focus: ?*Client = null;
@@ -1671,16 +1686,17 @@ fn unmanage(display: *Display, client: *Client, wm: *WindowManager) void {
if (client_monitor) |monitor| {
if (monitor.sel) |selected| {
- focus(display, selected, wm);
+ focus(selected, wm);
}
}
client_mod.destroy(gpa.allocator(), client);
- update_client_list(display, wm);
+ update_client_list(wm);
wm.invalidate_bars();
}
-fn handle_enter_notify(display: *Display, event: *xlib.XCrossingEvent, wm: *WindowManager) void {
+fn handle_enter_notify(event: *xlib.XCrossingEvent, wm: *WindowManager) void {
+ const display = &wm.display;
if ((event.mode != xlib.NotifyNormal or event.detail == xlib.NotifyInferior) and event.window != display.root) {
return;
}
@@ -1691,7 +1707,7 @@ fn handle_enter_notify(display: *Display, event: *xlib.XCrossingEvent, wm: *Wind
if (target_mon != selmon) {
if (selmon) |sel| {
- unfocus_client(display, sel.sel, true, wm);
+ unfocus_client(sel.sel, true, wm);
}
monitor_mod.selected_monitor = target_mon;
} else if (client == null) {
@@ -1702,40 +1718,43 @@ fn handle_enter_notify(display: *Display, event: *xlib.XCrossingEvent, wm: *Wind
}
}
- focus(display, client, wm);
+ focus(client, wm);
}
-fn handle_focus_in(display: *Display, event: *xlib.XFocusChangeEvent, wm: *WindowManager) void {
+fn handle_focus_in(event: *xlib.XFocusChangeEvent, wm: *WindowManager) void {
const selmon = monitor_mod.selected_monitor orelse return;
const selected = selmon.sel orelse return;
if (event.window != selected.window) {
- set_focus(display, selected, wm);
+ set_focus(selected, wm);
}
}
-fn set_focus(display: *Display, client: *Client, wm: *WindowManager) void {
+fn set_focus(client: *Client, wm: *WindowManager) void {
+ const display = &wm.display;
if (!client.never_focus) {
_ = xlib.XSetInputFocus(display.handle, client.window, xlib.RevertToPointerRoot, xlib.CurrentTime);
_ = xlib.XChangeProperty(display.handle, display.root, wm.atoms.net_active_window, xlib.XA_WINDOW, 32, xlib.PropModeReplace, @ptrCast(&client.window), 1);
}
- _ = send_event(display, client, wm.atoms.wm_take_focus, wm);
+ _ = send_event(client, wm.atoms.wm_take_focus, wm);
}
-fn handle_motion_notify(display: *Display, event: *xlib.XMotionEvent, wm: *WindowManager) void {
+fn handle_motion_notify(event: *xlib.XMotionEvent, wm: *WindowManager) void {
+ const display = &wm.display;
if (event.window != display.root) return;
const target_mon = monitor_mod.rect_to_monitor(event.x_root, event.y_root, 1, 1);
if (target_mon != wm.last_motion_monitor and wm.last_motion_monitor != null) {
if (monitor_mod.selected_monitor) |selmon| {
- unfocus_client(display, selmon.sel, true, wm);
+ unfocus_client(selmon.sel, true, wm);
}
monitor_mod.selected_monitor = target_mon;
- focus(display, null, wm);
+ focus(null, wm);
}
wm.last_motion_monitor = target_mon;
}
-fn handle_property_notify(display: *Display, event: *xlib.XPropertyEvent, wm: *WindowManager) void {
+fn handle_property_notify(event: *xlib.XPropertyEvent, wm: *WindowManager) void {
+ const display = &wm.display;
if (event.state == xlib.PropertyDelete) {
return;
}
@@ -1755,18 +1774,19 @@ fn handle_property_notify(display: *Display, event: *xlib.XPropertyEvent, wm: *W
} else if (event.atom == xlib.XA_WM_NORMAL_HINTS) {
client.hints_valid = false;
} else if (event.atom == xlib.XA_WM_HINTS) {
- update_wm_hints(display, client);
+ update_wm_hints(client, wm);
wm.invalidate_bars();
} else if (event.atom == xlib.XA_WM_NAME or event.atom == wm.atoms.net_wm_name) {
- update_title(display, client, wm);
+ update_title(client, wm);
} else if (event.atom == wm.atoms.net_wm_window_type) {
- update_window_type(display, client, wm);
+ update_window_type(client, wm);
}
}
-fn unfocus_client(display: *Display, client: ?*Client, reset_input_focus: bool, wm: *WindowManager) void {
+fn unfocus_client(client: ?*Client, reset_input_focus: bool, wm: *WindowManager) void {
+ const display = &wm.display;
const unfocus_target = client orelse return;
- grabbuttons(display, unfocus_target, false, wm);
+ grabbuttons(unfocus_target, false, wm);
_ = xlib.XSetWindowBorder(display.handle, unfocus_target.window, wm.config.border_unfocused);
if (reset_input_focus) {
_ = xlib.XSetInputFocus(display.handle, display.root, xlib.RevertToPointerRoot, xlib.CurrentTime);
@@ -1774,12 +1794,14 @@ fn unfocus_client(display: *Display, client: ?*Client, reset_input_focus: bool,
}
}
-fn set_client_state(display: *Display, client: *Client, state: c_long, wm: *WindowManager) void {
+fn set_client_state(client: *Client, state: c_long, wm: *WindowManager) void {
+ const display = &wm.display;
var data: [2]c_long = .{ state, xlib.None };
_ = xlib.c.XChangeProperty(display.handle, client.window, wm.atoms.wm_state, xlib.XA_ATOM, 32, xlib.PropModeReplace, @ptrCast(&data), 2);
}
-fn update_numlock_mask(display: *Display, wm: *WindowManager) void {
+fn update_numlock_mask(wm: *WindowManager) void {
+ const display = &wm.display;
wm.numlock_mask = 0;
const modmap = xlib.XGetModifierMapping(display.handle);
if (modmap == null) return;
@@ -1799,8 +1821,9 @@ fn update_numlock_mask(display: *Display, wm: *WindowManager) void {
}
}
-fn grabbuttons(display: *Display, client: *Client, focused: bool, wm: *WindowManager) void {
- update_numlock_mask(display, wm);
+fn grabbuttons(client: *Client, focused: bool, wm: *WindowManager) void {
+ const display = &wm.display;
+ update_numlock_mask(wm);
const modifiers = [_]c_uint{ 0, xlib.LockMask, wm.numlock_mask, wm.numlock_mask | xlib.LockMask };
_ = xlib.XUngrabButton(display.handle, xlib.AnyButton, xlib.AnyModifier, client.window);
@@ -1838,7 +1861,8 @@ fn grabbuttons(display: *Display, client: *Client, focused: bool, wm: *WindowMan
}
}
-fn focus(display: *Display, target_client: ?*Client, wm: *WindowManager) void {
+fn focus(target_client: ?*Client, wm: *WindowManager) void {
+ const display = &wm.display;
const selmon = monitor_mod.selected_monitor orelse return;
var focus_client = target_client;
@@ -1851,7 +1875,7 @@ fn focus(display: *Display, target_client: ?*Client, wm: *WindowManager) void {
}
if (selmon.sel != null and selmon.sel != focus_client) {
- unfocus_client(display, selmon.sel, false, wm);
+ unfocus_client(selmon.sel, false, wm);
}
if (focus_client) |client| {
@@ -1859,17 +1883,17 @@ fn focus(display: *Display, target_client: ?*Client, wm: *WindowManager) void {
monitor_mod.selected_monitor = client.monitor;
}
if (client.is_urgent) {
- set_urgent(display, client, false);
+ set_urgent(client, false, wm);
}
client_mod.detach_stack(client);
client_mod.attach_stack(client);
- grabbuttons(display, client, true, wm);
+ grabbuttons(client, true, wm);
_ = xlib.XSetWindowBorder(display.handle, client.window, wm.config.border_focused);
if (!client.never_focus) {
_ = xlib.XSetInputFocus(display.handle, client.window, xlib.RevertToPointerRoot, xlib.CurrentTime);
_ = xlib.XChangeProperty(display.handle, display.root, wm.atoms.net_active_window, xlib.XA_WINDOW, 32, xlib.PropModeReplace, @ptrCast(&client.window), 1);
}
- _ = send_event(display, client, wm.atoms.wm_take_focus, wm);
+ _ = send_event(client, wm.atoms.wm_take_focus, wm);
} else {
_ = xlib.XSetInputFocus(display.handle, display.root, xlib.RevertToPointerRoot, xlib.CurrentTime);
_ = xlib.XDeleteProperty(display.handle, display.root, wm.atoms.net_active_window);
@@ -1887,7 +1911,8 @@ fn focus(display: *Display, target_client: ?*Client, wm: *WindowManager) void {
wm.invalidate_bars();
}
-fn restack(display: *Display, monitor: *Monitor, wm: *WindowManager) void {
+fn restack(monitor: *Monitor, wm: *WindowManager) void {
+ const display = &wm.display;
wm.invalidate_bars();
const selected_client = monitor.sel orelse return;
@@ -1917,13 +1942,13 @@ fn restack(display: *Display, monitor: *Monitor, wm: *WindowManager) void {
}
fn arrange(monitor: *Monitor, wm: *WindowManager) void {
- showhide(&wm.display, monitor, wm);
+ showhide(monitor, wm);
if (monitor.lt[monitor.sel_lt]) |layout| {
if (layout.arrange_fn) |arrange_fn| {
arrange_fn(monitor);
}
}
- restack(&wm.display, monitor, wm);
+ restack(monitor, wm);
}
fn tick_animations(wm: *WindowManager) void {
@@ -1975,7 +2000,8 @@ fn scroll_to_window(client: *Client, animate: bool, wm: *WindowManager) void {
}
}
-fn showhide_client(display: *Display, client: ?*Client, wm: *WindowManager) void {
+fn showhide_client(client: ?*Client, wm: *WindowManager) void {
+ const display = &wm.display;
const target = client orelse return;
if (client_mod.is_visible(target)) {
_ = xlib.XMoveWindow(display.handle, target.window, target.x, target.y);
@@ -1983,19 +2009,20 @@ fn showhide_client(display: *Display, client: ?*Client, wm: *WindowManager) void
if ((monitor.lt[monitor.sel_lt] == null or target.is_floating) and !target.is_fullscreen) {
tiling.resize(target, target.x, target.y, target.width, target.height, false);
}
- showhide_client(display, target.stack_next, wm);
+ showhide_client(target.stack_next, wm);
} else {
- showhide_client(display, target.stack_next, wm);
+ showhide_client(target.stack_next, wm);
const client_width = target.width + 2 * target.border_width;
_ = xlib.XMoveWindow(display.handle, target.window, -2 * client_width, target.y);
}
}
-fn showhide(display: *Display, monitor: *Monitor, wm: *WindowManager) void {
- showhide_client(display, monitor.stack, wm);
+fn showhide(monitor: *Monitor, wm: *WindowManager) void {
+ showhide_client(monitor.stack, wm);
}
-fn update_size_hints(display: *Display, client: *Client) void {
+fn update_size_hints(client: *Client, wm: *WindowManager) void {
+ const display = &wm.display;
var size_hints: xlib.XSizeHints = undefined;
var msize: c_long = 0;
@@ -2053,7 +2080,8 @@ fn update_size_hints(display: *Display, client: *Client) void {
client.hints_valid = true;
}
-fn update_wm_hints(display: *Display, client: *Client) void {
+fn update_wm_hints(client: *Client, wm: *WindowManager) void {
+ const display = &wm.display;
const wmh = xlib.XGetWMHints(display.handle, client.window);
if (wmh) |hints| {
defer _ = xlib.XFree(@ptrCast(hints));
@@ -2073,28 +2101,29 @@ fn update_wm_hints(display: *Display, client: *Client) void {
}
}
-fn update_window_type(display: *Display, client: *Client, wm: *WindowManager) void {
- const state = get_atom_prop(display, client, wm.atoms.net_wm_state);
- const window_type = get_atom_prop(display, client, wm.atoms.net_wm_window_type);
+fn update_window_type(client: *Client, wm: *WindowManager) void {
+ const state = get_atom_prop(client, wm.atoms.net_wm_state, wm);
+ const window_type = get_atom_prop(client, wm.atoms.net_wm_window_type, wm);
if (state == wm.atoms.net_wm_state_fullscreen) {
- set_fullscreen(display, client, true, wm);
+ set_fullscreen(client, true, wm);
}
if (window_type == wm.atoms.net_wm_window_type_dialog) {
client.is_floating = true;
}
}
-fn update_title(display: *Display, client: *Client, wm: *WindowManager) void {
- if (!get_text_prop(display, client.window, wm.atoms.net_wm_name, &client.name)) {
- _ = get_text_prop(display, client.window, xlib.XA_WM_NAME, &client.name);
+fn update_title(client: *Client, wm: *WindowManager) void {
+ if (!get_text_prop(client.window, wm.atoms.net_wm_name, &client.name, wm)) {
+ _ = get_text_prop(client.window, xlib.XA_WM_NAME, &client.name, wm);
}
if (client.name[0] == 0) {
@memcpy(client.name[0..6], "broken");
}
}
-fn get_atom_prop(display: *Display, client: *Client, prop: xlib.Atom) xlib.Atom {
+fn get_atom_prop(client: *Client, prop: xlib.Atom, wm: *WindowManager) xlib.Atom {
+ const display = &wm.display;
var actual_type: xlib.Atom = undefined;
var actual_format: c_int = undefined;
var num_items: c_ulong = undefined;
@@ -2109,7 +2138,8 @@ fn get_atom_prop(display: *Display, client: *Client, prop: xlib.Atom) xlib.Atom
return 0;
}
-fn get_text_prop(display: *Display, window: xlib.Window, atom: xlib.Atom, text: *[256]u8) bool {
+fn get_text_prop(window: xlib.Window, atom: xlib.Atom, text: *[256]u8, wm: *WindowManager) bool {
+ const display = &wm.display;
var name: xlib.XTextProperty = undefined;
text[0] = 0;
@@ -2137,7 +2167,8 @@ fn get_text_prop(display: *Display, window: xlib.Window, atom: xlib.Atom, text:
return true;
}
-fn apply_rules(display: *Display, client: *Client, wm: *WindowManager) void {
+fn apply_rules(client: *Client, wm: *WindowManager) void {
+ const display = &wm.display;
var class_hint: xlib.XClassHint = .{ .res_name = null, .res_class = null };
_ = xlib.XGetClassHint(display.handle, client.window, &class_hint);
@@ -2190,12 +2221,13 @@ fn apply_rules(display: *Display, client: *Client, wm: *WindowManager) void {
const monitor_tagset = monitor.tagset[monitor.sel_tags];
const is_tag_focused = (monitor_tagset & client.tags) == client.tags;
if (!is_tag_focused) {
- view(display, client.tags, wm);
+ view(client.tags, wm);
}
}
}
-fn update_client_list(display: *Display, wm: *WindowManager) void {
+fn update_client_list(wm: *WindowManager) void {
+ const display = &wm.display;
_ = xlib.XDeleteProperty(display.handle, display.root, wm.atoms.net_client_list);
var current_monitor = monitor_mod.monitors;
@@ -2209,7 +2241,8 @@ fn update_client_list(display: *Display, wm: *WindowManager) void {
}
}
-fn send_event(display: *Display, client: *Client, protocol: xlib.Atom, wm: *WindowManager) bool {
+fn send_event(client: *Client, protocol: xlib.Atom, wm: *WindowManager) bool {
+ const display = &wm.display;
var protocols: [*c]xlib.Atom = undefined;
var num_protocols: c_int = 0;
var exists = false;
@@ -2238,7 +2271,8 @@ fn send_event(display: *Display, client: *Client, protocol: xlib.Atom, wm: *Wind
return exists;
}
-fn set_urgent(display: *Display, client: *Client, urgent: bool) void {
+fn set_urgent(client: *Client, urgent: bool, wm: *WindowManager) void {
+ const display = &wm.display;
client.is_urgent = urgent;
const wmh = xlib.XGetWMHints(display.handle, client.window);
if (wmh) |hints| {