simplier .clang-format and fix swap focus

.clang-format

@@ -1,183 +1,17 @@
-
-# FreeBSD .clang-format
-
----
-BasedOnStyle: WebKit
-AlignAfterOpenBracket: DontAlign
-AlignConsecutiveMacros: AcrossEmptyLines
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Left
-AlignOperands: false
-AlignTrailingComments: true
-AllowAllArgumentsOnNextLine: false
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: Never
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: InlineOnly
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterReturnType: TopLevelDefinitions
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: MultiLine
-BinPackArguments: true
-BinPackParameters: true
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: WebKit
-BreakBeforeTernaryOperators: false
-BreakStringLiterals: false
-PenaltyBreakAssignment: 100
-PenaltyBreakBeforeFirstCallParameter: 100
-CompactNamespaces: true
-DerivePointerAlignment: false
-DisableFormat: false
-ForEachMacros:
-  - ARB_ARRFOREACH
-  - ARB_ARRFOREACH_REVWCOND
-  - ARB_ARRFOREACH_REVERSE
-  - ARB_FOREACH
-  - ARB_FOREACH_FROM
-  - ARB_FOREACH_SAFE
-  - ARB_FOREACH_REVERSE
-  - ARB_FOREACH_REVERSE_FROM
-  - ARB_FOREACH_REVERSE_SAFE
-  - BIT_FOREACH_ISCLR
-  - BIT_FOREACH_ISSET
-  - CPU_FOREACH
-  - CPU_FOREACH_ISCLR
-  - CPU_FOREACH_ISSET
-  - FOREACH_THREAD_IN_PROC
-  - FOREACH_PROC_IN_SYSTEM
-  - FOREACH_PRISON_CHILD
-  - FOREACH_PRISON_DESCENDANT
-  - FOREACH_PRISON_DESCENDANT_LOCKED
-  - FOREACH_PRISON_DESCENDANT_LOCKED_LEVEL
-  - MNT_VNODE_FOREACH_ALL
-  - MNT_VNODE_FOREACH_ACTIVE
-  - RB_FOREACH
-  - RB_FOREACH_FROM
-  - RB_FOREACH_SAFE
-  - RB_FOREACH_REVERSE
-  - RB_FOREACH_REVERSE_FROM
-  - RB_FOREACH_REVERSE_SAFE
-  - SLIST_FOREACH
-  - SLIST_FOREACH_FROM
-  - SLIST_FOREACH_FROM_SAFE
-  - SLIST_FOREACH_SAFE
-  - SLIST_FOREACH_PREVPTR
-  - SPLAY_FOREACH
-  - LIST_FOREACH
-  - LIST_FOREACH_FROM
-  - LIST_FOREACH_FROM_SAFE
-  - LIST_FOREACH_SAFE
-  - STAILQ_FOREACH
-  - STAILQ_FOREACH_FROM
-  - STAILQ_FOREACH_FROM_SAFE
-  - STAILQ_FOREACH_SAFE
-  - TAILQ_FOREACH
-  - TAILQ_FOREACH_FROM
-  - TAILQ_FOREACH_FROM_SAFE
-  - TAILQ_FOREACH_REVERSE
-  - TAILQ_FOREACH_REVERSE_FROM
-  - TAILQ_FOREACH_REVERSE_FROM_SAFE
-  - TAILQ_FOREACH_REVERSE_SAFE
-  - TAILQ_FOREACH_SAFE
-  - VM_MAP_ENTRY_FOREACH
-  - VM_PAGE_DUMP_FOREACH
-SpaceBeforeParens: ControlStatementsExceptForEachMacros
-IndentCaseLabels: false
-IndentPPDirectives: None
-Language: Cpp
-NamespaceIndentation: None
-PointerAlignment: Right
-ContinuationIndentWidth: 4
-IndentWidth: 8
-TabWidth: 8
-ColumnLimit: 80
-UseTab: Always
-SpaceAfterCStyleCast: false
-IncludeBlocks: Regroup
-IncludeCategories:
-  - Regex: '^\"opt_.*\.h\"'
-    Priority: 1
-    SortPriority: 10
-  - Regex: '^<sys/cdefs\.h>'
-    Priority: 2
-    SortPriority: 20
-  - Regex: '^<sys/types\.h>'
-    Priority: 2
-    SortPriority: 21
-  - Regex: '^<sys/param\.h>'
-    Priority: 2
-    SortPriority: 22
-  - Regex: '^<sys/systm\.h>'
-    Priority: 2
-    SortPriority: 23
-  - Regex: '^<sys.*/'
-    Priority: 2
-    SortPriority: 24
-  - Regex: '^<vm/vm\.h>'
-    Priority: 3
-    SortPriority: 30
-  - Regex: '^<vm/'
-    Priority: 3
-    SortPriority: 31
-  - Regex: '^<machine/'
-    Priority: 4
-    SortPriority: 40
-  - Regex: '^<(x86|amd64|i386|xen)/'
-    Priority: 5
-    SortPriority: 50
-  - Regex: '^<dev/'
-    Priority: 6
-    SortPriority: 60
-  - Regex: '^<net.*/'
-    Priority: 7
-    SortPriority: 70
-  - Regex: '^<protocols/'
-    Priority: 7
-    SortPriority: 71
-  - Regex: '^<(fs|nfs(|client|server)|ufs)/'
-    Priority: 8
-    SortPriority: 80
-  - Regex: '^<[^/].*'
-    Priority: 9
-    SortPriority: 90
-  - Regex: '^\".*\"'
-    Priority: 10
-    SortPriority: 100
-IncludeIsMainRegex: 'BLAH_DONT_MATCH_ANYTHING'
+BasedOnStyle: LLVM
+IndentWidth: 4
+TabWidth: 4
+UseTab: Never
+ColumnLimit: 120
+AllowShortFunctionsOnASingleLine: false
 SortIncludes: true
-KeepEmptyLinesAtTheStartOfBlocks: false
-TypenameMacros:
-  - ARB_ELMTYPE
-  - ARB_HEAD
-  - ARB8_HEAD
-  - ARB16_HEAD
-  - ARB32_HEAD
-  - ARB_ENTRY
-  - ARB8_ENTRY
-  - ARB16_ENTRY
-  - ARB32_ENTRY
-  - LIST_CLASS_ENTRY
-  - LIST_CLASS_HEAD
-  - LIST_ENTRY
-  - LIST_HEAD
-  - QUEUE_TYPEOF
-  - RB_ENTRY
-  - RB_HEAD
-  - SLIST_CLASS_HEAD
-  - SLIST_CLASS_ENTRY
-  - SLIST_HEAD
-  - SLIST_ENTRY
-  - SMR_POINTER
-  - SPLAY_ENTRY
-  - SPLAY_HEAD
-  - STAILQ_CLASS_ENTRY
-  - STAILQ_CLASS_HEAD
-  - STAILQ_ENTRY
-  - STAILQ_HEAD
-  - TAILQ_CLASS_ENTRY
-  - TAILQ_CLASS_HEAD
-  - TAILQ_ENTRY
-  - TAILQ_HEAD
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterFunction: true
+  AfterControlStatement: false
+  AfterClass: false
+  AfterNamespace: false
+  AfterEnum: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false

config.mk

@@ -4,7 +4,7 @@ XLIBS = xcb xcb-icccm
 # tools
 PKG_CONFIG ?= pkg-config
 CC ?= clang
-CLANG_FORMAT ?= clang-format22
+CLANG_FORMAT ?= clang-format
 
 PKGS = wayland-server xkbcommon libinput $(XLIBS)
 

include/config.h

@@ -28,16 +28,7 @@ static const float unfocused_bc[4] = { 0.28, 0.28, 0.28, 1.0 };
 #define LOGO WLR_MODIFIER_LOGO
 
 static const char *workspaces[] = {
-	"1",
-	"2",
-	"3",
-	"4",
-	"5",
-	"6",
-	"7",
-	"8",
-	"9",
-	"10",
+    "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
 };
 
 static const absn_keybind keybinds[] = {
@@ -77,20 +68,14 @@ static const absn_keybind keybinds[] = {
 
     {ALT | SHIFT, XKB_KEY_exclam, move_focus_to_workspace, {.v = "1"}},
     {ALT | SHIFT, XKB_KEY_at, move_focus_to_workspace, {.v = "2"}},
-	{ ALT | SHIFT, XKB_KEY_numbersign, move_focus_to_workspace,
-	    { .v = "3" } },
+    {ALT | SHIFT, XKB_KEY_numbersign, move_focus_to_workspace, {.v = "3"}},
     {ALT | SHIFT, XKB_KEY_dollar, move_focus_to_workspace, {.v = "4"}},
     {ALT | SHIFT, XKB_KEY_percent, move_focus_to_workspace, {.v = "5"}},
-	{ ALT | SHIFT, XKB_KEY_asciicircum, move_focus_to_workspace,
-	    { .v = "6" } },
-	{ ALT | SHIFT, XKB_KEY_ampersand, move_focus_to_workspace,
-	    { .v = "7" } },
-	{ ALT | SHIFT, XKB_KEY_asterisk, move_focus_to_workspace,
-	    { .v = "8" } },
-	{ ALT | SHIFT, XKB_KEY_parenleft, move_focus_to_workspace,
-	    { .v = "9" } },
-	{ ALT | SHIFT, XKB_KEY_parenright, move_focus_to_workspace,
-	    { .v = "10" } },
+    {ALT | SHIFT, XKB_KEY_asciicircum, move_focus_to_workspace, {.v = "6"}},
+    {ALT | SHIFT, XKB_KEY_ampersand, move_focus_to_workspace, {.v = "7"}},
+    {ALT | SHIFT, XKB_KEY_asterisk, move_focus_to_workspace, {.v = "8"}},
+    {ALT | SHIFT, XKB_KEY_parenleft, move_focus_to_workspace, {.v = "9"}},
+    {ALT | SHIFT, XKB_KEY_parenright, move_focus_to_workspace, {.v = "10"}},
 };
 
 #endif

include/toplevel.h

@@ -3,8 +3,8 @@
 
 #include "types.h"
 
-absn_toplevel *toplevel_at(absn_server *server, double lx, double ly,
-    struct wlr_surface **surface, double *sx, double *sy);
+absn_toplevel *toplevel_at(absn_server *server, double lx, double ly, struct wlr_surface **surface, double *sx,
+                           double *sy);
 
 bool toplevel_is_unmanaged(absn_toplevel *toplevel);
 

src/absinthe.c

@@ -24,8 +24,7 @@
 #include "server.h"
 #include "types.h"
 
-static int
-setup(absn_server *server)
+static int setup(absn_server *server)
 {
     wlr_log_init(WLR_DEBUG, NULL);
     server->display = wl_display_create();
@@ -34,9 +33,7 @@ setup(absn_server *server)
         return 1;
     }
 
-	server->backend = wlr_backend_autocreate(wl_display_get_event_loop(
-						     server->display),
-	    NULL);
+    server->backend = wlr_backend_autocreate(wl_display_get_event_loop(server->display), NULL);
     if (!server->backend) {
         wlr_log(WLR_ERROR, "Failed to create wlr_backend");
         return 1;
@@ -51,25 +48,21 @@ setup(absn_server *server)
     wlr_renderer_init_wl_shm(server->renderer, server->display);
 
     server->scene = wlr_scene_create();
-	if (wlr_renderer_get_texture_formats(server->renderer,
-		WLR_BUFFER_CAP_DMABUF)) {
+    if (wlr_renderer_get_texture_formats(server->renderer, WLR_BUFFER_CAP_DMABUF)) {
         wlr_drm_create(server->display, server->renderer);
         wlr_scene_set_linux_dmabuf_v1(server->scene,
-		    wlr_linux_dmabuf_v1_create_with_renderer(server->display, 5,
-			server->renderer));
+                                      wlr_linux_dmabuf_v1_create_with_renderer(server->display, 5, server->renderer));
     }
     server->bg = wlr_scene_rect_create(&server->scene->tree, 0, 0, bgcolor);
 
-	server->allocator = wlr_allocator_autocreate(server->backend,
-	    server->renderer);
+    server->allocator = wlr_allocator_autocreate(server->backend, server->renderer);
     if (!server->allocator) {
         wlr_log(WLR_ERROR, "Failed to create wlr_allocator");
         return 1;
     }
 
     /* wlroots managers */
-	server->compositor = wlr_compositor_create(server->display, 6,
-	    server->renderer);
+    server->compositor = wlr_compositor_create(server->display, 6, server->renderer);
     wlr_subcompositor_create(server->display);
     wlr_data_device_manager_create(server->display);
     wlr_screencopy_manager_v1_create(server->display);
@@ -82,13 +75,10 @@ setup(absn_server *server)
     wlr_export_dmabuf_manager_v1_create(server->display);
     wlr_ext_foreign_toplevel_list_v1_create(server->display, 1);
 
-	wlr_server_decoration_manager_set_default_mode(
-	    wlr_server_decoration_manager_create(server->display),
+    wlr_server_decoration_manager_set_default_mode(wlr_server_decoration_manager_create(server->display),
                                                    WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
-	server->xdg_deco_mgr = wlr_xdg_decoration_manager_v1_create(
-	    server->display);
-	LISTEN(server->new_xdg_deco, new_xdg_decoration,
-	    server->xdg_deco_mgr->events.new_toplevel_decoration);
+    server->xdg_deco_mgr = wlr_xdg_decoration_manager_v1_create(server->display);
+    LISTEN(server->new_xdg_deco, new_xdg_decoration, server->xdg_deco_mgr->events.new_toplevel_decoration);
 
     /* toplevels lists */
     wl_list_init(&server->toplevels);
@@ -96,27 +86,21 @@ setup(absn_server *server)
 
     /* output */
     wl_list_init(&server->outputs);
-	LISTEN(server->new_output, new_output,
-	    server->backend->events.new_output);
+    LISTEN(server->new_output, new_output, server->backend->events.new_output);
 
     server->output_layout = wlr_output_layout_create(server->display);
-	LISTEN(server->layout_change, output_layout_change,
-	    server->output_layout->events.change);
+    LISTEN(server->layout_change, output_layout_change, server->output_layout->events.change);
 
     server->output_mgr = wlr_output_manager_v1_create(server->display);
 
-	wlr_xdg_output_manager_v1_create(server->display,
-	    server->output_layout);
+    wlr_xdg_output_manager_v1_create(server->display, server->output_layout);
 
-	server->scene_layout = wlr_scene_attach_output_layout(server->scene,
-	    server->output_layout);
+    server->scene_layout = wlr_scene_attach_output_layout(server->scene, server->output_layout);
 
     /* xdg_shell */
     server->xdg_shell = wlr_xdg_shell_create(server->display, 6);
-	LISTEN(server->new_xdg_toplevel, new_xdg_toplevel,
-	    server->xdg_shell->events.new_toplevel);
-	LISTEN(server->new_xdg_popup, new_xdg_popup,
-	    server->xdg_shell->events.new_popup);
+    LISTEN(server->new_xdg_toplevel, new_xdg_toplevel, server->xdg_shell->events.new_toplevel);
+    LISTEN(server->new_xdg_popup, new_xdg_popup, server->xdg_shell->events.new_popup);
 
     /* cursor */
     server->cursor = wlr_cursor_create();
@@ -125,26 +109,19 @@ setup(absn_server *server)
     server->cursor_mgr = wlr_xcursor_manager_create(NULL, 24);
 
     server->cursor_mode = CURSOR_PASSTHROUGH;
-	LISTEN(server->cursor_motion, cursor_motion,
-	    server->cursor->events.motion);
-	LISTEN(server->cursor_motion_abs, cursor_motion_abs,
-	    server->cursor->events.motion_absolute);
-	LISTEN(server->cursor_button, cursor_button,
-	    server->cursor->events.button);
+    LISTEN(server->cursor_motion, cursor_motion, server->cursor->events.motion);
+    LISTEN(server->cursor_motion_abs, cursor_motion_abs, server->cursor->events.motion_absolute);
+    LISTEN(server->cursor_button, cursor_button, server->cursor->events.button);
     LISTEN(server->cursor_axis, cursor_axis, server->cursor->events.axis);
-	LISTEN(server->cursor_frame, cursor_frame,
-	    server->cursor->events.frame);
+    LISTEN(server->cursor_frame, cursor_frame, server->cursor->events.frame);
 
     /* keyboard */
     wl_list_init(&server->keyboards);
     server->seat = wlr_seat_create(server->display, "seat0");
     LISTEN(server->new_input, new_input, server->backend->events.new_input);
-	LISTEN(server->request_cursor, request_cursor,
-	    server->seat->events.request_set_cursor);
-	LISTEN(server->pointer_focus_change, pointer_focus_change,
-	    server->seat->pointer_state.events.focus_change);
-	LISTEN(server->request_set_selection, request_cursor,
-	    server->seat->events.request_set_selection);
+    LISTEN(server->request_cursor, request_cursor, server->seat->events.request_set_cursor);
+    LISTEN(server->pointer_focus_change, pointer_focus_change, server->seat->pointer_state.events.focus_change);
+    LISTEN(server->request_set_selection, request_cursor, server->seat->events.request_set_selection);
 
     /* layer shell */
     server->layer_shell = wlr_layer_shell_v1_create(server->display, 1);
@@ -165,19 +142,14 @@ setup(absn_server *server)
 
     unsetenv("DISPLAY");
 #ifdef XWAYLAND
-	if ((server->xwayland = wlr_xwayland_create(server->display,
-		 server->compositor, 1))) {
-		LISTEN(server->xw_ready, xwayland_ready,
-		    server->xwayland->events.ready);
-		LISTEN(server->xw_new_surface, xwayland_new_surface,
-		    server->xwayland->events.new_surface);
+    if ((server->xwayland = wlr_xwayland_create(server->display, server->compositor, 1))) {
+        LISTEN(server->xw_ready, xwayland_ready, server->xwayland->events.ready);
+        LISTEN(server->xw_new_surface, xwayland_new_surface, server->xwayland->events.new_surface);
 
         setenv("DISPLAY", server->xwayland->display_name, 1);
-		wlr_log(WLR_INFO, "Running XWayland, DISPLAY=%s",
-		    server->xwayland->display_name);
+        wlr_log(WLR_INFO, "Running XWayland, DISPLAY=%s", server->xwayland->display_name);
     } else {
-		wlr_log(WLR_ERROR,
-		    "Failed to setup XWayland, continuing without it");
+        wlr_log(WLR_ERROR, "Failed to setup XWayland, continuing without it");
     }
 #endif
 
@@ -201,8 +173,7 @@ setup(absn_server *server)
     return 0;
 }
 
-static void
-cleanup(absn_server *server)
+static void cleanup(absn_server *server)
 {
     wl_display_destroy_clients(server->display);
 
@@ -234,8 +205,7 @@ cleanup(absn_server *server)
     wl_display_destroy(server->display);
 }
 
-int
-main(void)
+int main(void)
 {
     absn_server server = {0};
     int err = setup(&server);

src/cursor.c

@@ -5,19 +5,16 @@
 #include "toplevel.h"
 #include "types.h"
 
-void
-reset_cursor_mode(absn_server *server)
+void reset_cursor_mode(absn_server *server)
 {
     server->cursor_mode = CURSOR_PASSTHROUGH;
     wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "default");
     if (server->focused_toplevel) {
-		wlr_xdg_toplevel_set_resizing(server->focused_toplevel->xdg,
-		    false);
+        wlr_xdg_toplevel_set_resizing(server->focused_toplevel->xdg, false);
     }
 }
 
-static void
-process_cursor_move(absn_server *server)
+static void process_cursor_move(absn_server *server)
 {
     struct absn_toplevel *toplevel = server->focused_toplevel;
 
@@ -38,8 +35,7 @@ process_cursor_move(absn_server *server)
         toplevel_set_floating(toplevel, true);
 }
 
-static void
-apply_resize(absn_toplevel *toplevel, struct wlr_box *new_geom)
+static void apply_resize(absn_toplevel *toplevel, struct wlr_box *new_geom)
 {
     if (toplevel->type == TOPLEVEL_XDG) {
         int32_t min_width = toplevel->xdg->current.min_width;
@@ -54,14 +50,12 @@ apply_resize(absn_toplevel *toplevel, struct wlr_box *new_geom)
         if (max_height == 0)
             max_height = 10000;
 
-		if (!(new_geom->width >= min_width &&
-			new_geom->width <= max_width)) {
+        if (!(new_geom->width >= min_width && new_geom->width <= max_width)) {
             new_geom->width = toplevel->geom.width;
             new_geom->x = toplevel->geom.x;
         }
 
-		if (!(new_geom->height >= min_height &&
-			new_geom->height <= max_height)) {
+        if (!(new_geom->height >= min_height && new_geom->height <= max_height)) {
             new_geom->height = toplevel->geom.height;
             new_geom->y = toplevel->geom.y;
         }
@@ -70,8 +64,7 @@ apply_resize(absn_toplevel *toplevel, struct wlr_box *new_geom)
     toplevel_set_geom(toplevel, new_geom);
 }
 
-static void
-process_cursor_resize(absn_server *server)
+static void process_cursor_resize(absn_server *server)
 {
     struct absn_toplevel *toplevel = server->focused_toplevel;
 
@@ -136,13 +129,11 @@ process_cursor_resize(absn_server *server)
     }
 }
 
-void
-process_cursor_motion(absn_server *server, uint32_t time)
+void process_cursor_motion(absn_server *server, uint32_t time)
 {
     double sx, sy;
     struct wlr_surface *surface = NULL;
-	toplevel_at(server, server->cursor->x, server->cursor->y, &surface, &sx,
-	    &sy);
+    toplevel_at(server, server->cursor->x, server->cursor->y, &surface, &sx, &sy);
     struct wlr_seat *seat = server->seat;
 
     if (server->cursor_mode == CURSOR_MOVE) {

src/focus.c

@@ -6,8 +6,7 @@
 #include "toplevel.h"
 #include "types.h"
 
-void
-unfocus_toplevel(absn_toplevel *toplevel)
+void unfocus_toplevel(absn_toplevel *toplevel)
 {
     if (!toplevel)
         return;
@@ -17,8 +16,7 @@ unfocus_toplevel(absn_toplevel *toplevel)
     toplevel_set_border_color(toplevel, unfocused_bc);
 }
 
-void
-focus_toplevel(absn_toplevel *toplevel)
+void focus_toplevel(absn_toplevel *toplevel)
 {
     if (!toplevel)
         return;
@@ -51,23 +49,19 @@ focus_toplevel(absn_toplevel *toplevel)
     toplevel_set_border_color(toplevel, focused_bc);
 
     if (keyboard)
-		wlr_seat_keyboard_notify_enter(seat, surface,
-		    keyboard->keycodes, keyboard->num_keycodes,
-		    &keyboard->modifiers);
+        wlr_seat_keyboard_notify_enter(seat, surface, keyboard->keycodes, keyboard->num_keycodes, &keyboard->modifiers);
 }
 
 /*
  * get first toplevel on monitor
  * (last focused toplevel)
  */
-absn_toplevel *
-focus_get_topmost(absn_server *server)
+absn_toplevel *focus_get_topmost(absn_server *server)
 {
     absn_toplevel *toplevel;
     wl_list_for_each(toplevel, &server->focus_stack, flink)
     {
-		if (toplevel &&
-		    toplevel->workspace == server->focused_output->workspace)
+        if (toplevel && toplevel->workspace == server->focused_output->workspace)
             return toplevel;
     }
     return NULL;

src/keybinds.c

@@ -9,8 +9,7 @@
 #include "toplevel.h"
 #include "types.h"
 
-void
-run(absn_server *server, const absn_arg *arg)
+void run(absn_server *server, const absn_arg *arg)
 {
     UNUSED(server);
     if (fork() == 0) {
@@ -19,8 +18,7 @@ run(absn_server *server, const absn_arg *arg)
     }
 }
 
-void
-kill_focus(absn_server *server, const absn_arg *arg)
+void kill_focus(absn_server *server, const absn_arg *arg)
 {
     UNUSED(arg);
     if (!server->focused_toplevel)
@@ -38,8 +36,7 @@ kill_focus(absn_server *server, const absn_arg *arg)
     }
 }
 
-void
-cycle_focus(absn_server *server, const absn_arg *arg)
+void cycle_focus(absn_server *server, const absn_arg *arg)
 {
     absn_toplevel *toplevel = focus_get_topmost(server);
     if (!toplevel || toplevel->fullscreen)
@@ -62,17 +59,30 @@ cycle_focus(absn_server *server, const absn_arg *arg)
     focus_toplevel(new_focus);
 }
 
-void
-swap_focus(absn_server *server, const absn_arg *arg)
+void swap_focus(absn_server *server, const absn_arg *arg)
 {
 
     absn_toplevel *toplevel = focus_get_topmost(server);
     if (!toplevel || toplevel->fullscreen || toplevel->floating)
         return;
 
-	absn_toplevel *swap;
+    absn_toplevel *temp = NULL;
+    absn_toplevel *first = NULL;
+    absn_toplevel *last = NULL;
+
+    wl_list_for_each(temp, &server->toplevels, link) {
+        if (temp->workspace == toplevel->workspace)
+            last = temp;
+        if (!first && temp->workspace == toplevel->workspace)
+            first = temp;
+    }
+
+    if (first == last)
+        return;
+
+    absn_toplevel *swap = NULL;
     if (arg->i > 0) {
-		if (server->toplevels.prev == &toplevel->link) {
+        if (toplevel == last) {
             wl_list_remove(&toplevel->link);
             wl_list_insert(&server->toplevels, &toplevel->link);
             goto arrange;
@@ -87,7 +97,7 @@ swap_focus(absn_server *server, const absn_arg *arg)
         wl_list_remove(&toplevel->link);
         wl_list_insert(&swap->link, &toplevel->link);
     } else {
-		if (server->toplevels.next == &toplevel->link) {
+        if (toplevel == first) {
             wl_list_remove(&toplevel->link);
             wl_list_insert(server->toplevels.prev, &toplevel->link);
             goto arrange;
@@ -107,8 +117,7 @@ arrange:
     layout_arrange(toplevel->output);
 }
 
-void
-toggle_fullscreen(absn_server *server, const absn_arg *arg)
+void toggle_fullscreen(absn_server *server, const absn_arg *arg)
 {
     UNUSED(arg);
     if (!server->focused_toplevel)
@@ -118,8 +127,7 @@ toggle_fullscreen(absn_server *server, const absn_arg *arg)
     toplevel_set_fullscreen(focus, !focus->fullscreen);
 }
 
-void
-increase_master_width(absn_server *server, const absn_arg *arg)
+void increase_master_width(absn_server *server, const absn_arg *arg)
 {
     absn_workspace *workspace = server->focused_output->workspace;
 
@@ -130,8 +138,7 @@ increase_master_width(absn_server *server, const absn_arg *arg)
     layout_arrange(workspace->output);
 }
 
-void
-increase_master_count(absn_server *server, const absn_arg *arg)
+void increase_master_count(absn_server *server, const absn_arg *arg)
 {
     absn_workspace *workspace = server->focused_output->workspace;
 
@@ -142,8 +149,7 @@ increase_master_count(absn_server *server, const absn_arg *arg)
     layout_arrange(workspace->output);
 }
 
-void
-switch_workspace(absn_server *server, const absn_arg *arg)
+void switch_workspace(absn_server *server, const absn_arg *arg)
 {
     int i;
     for (i = 0; i < server->workspaces_count; ++i) {
@@ -178,9 +184,7 @@ switch_workspace(absn_server *server, const absn_arg *arg)
             focus = toplevel; /* found it */
         }
 
-		if (toplevel && toplevel->workspace == &server->workspaces[i] &&
-				toplevel->fullscreen)
-		{
+        if (toplevel && toplevel->workspace == &server->workspaces[i] && toplevel->fullscreen) {
             /* overwrite if there is a fullscreen window */
             focus = toplevel;
             break;
@@ -207,8 +211,7 @@ switch_workspace(absn_server *server, const absn_arg *arg)
     layout_arrange(server->focused_output);
 }
 
-void
-move_focus_to_workspace(absn_server *server, const absn_arg *arg)
+void move_focus_to_workspace(absn_server *server, const absn_arg *arg)
 {
     if (!server->focused_toplevel)
         return;
@@ -237,15 +240,13 @@ move_focus_to_workspace(absn_server *server, const absn_arg *arg)
     layout_arrange(server->focused_toplevel->output);
 }
 
-void
-set_layout(absn_server *server, const absn_arg *arg)
+void set_layout(absn_server *server, const absn_arg *arg)
 {
     server->focused_output->workspace->layout = arg->i;
     layout_arrange(server->focused_output);
 }
 
-noreturn void
-quit(absn_server *server, const absn_arg *arg)
+noreturn void quit(absn_server *server, const absn_arg *arg)
 {
     UNUSED(arg);
     wl_display_terminate(server->display);

src/keyboard.c

@@ -8,26 +8,21 @@
 #include "config.h"
 #include "types.h"
 
-void
-handle_modifiers(struct wl_listener *listener, void *data)
+void handle_modifiers(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_keyboard *keyboard = wl_container_of(listener, keyboard,
-	    modifiers);
+    absn_keyboard *keyboard = wl_container_of(listener, keyboard, modifiers);
 
     wlr_seat_set_keyboard(keyboard->server->seat, keyboard->wlr);
-	wlr_seat_keyboard_notify_modifiers(keyboard->server->seat,
-	    &keyboard->wlr->modifiers);
+    wlr_seat_keyboard_notify_modifiers(keyboard->server->seat, &keyboard->wlr->modifiers);
 }
 
-static bool
-handle_keybind(absn_server *server, uint32_t mods, xkb_keysym_t keysym)
+static bool handle_keybind(absn_server *server, uint32_t mods, xkb_keysym_t keysym)
 {
     int nkeyb = sizeof(keybinds) / sizeof(keybinds[0]);
     for (int i = 0; i < nkeyb; ++i) {
         if (CLEANMASK(keybinds[i].mods) == CLEANMASK(mods) &&
-		    xkb_keysym_to_lower(keybinds[i].keysym) ==
-			xkb_keysym_to_lower(keysym)) {
+            xkb_keysym_to_lower(keybinds[i].keysym) == xkb_keysym_to_lower(keysym)) {
             keybinds[i].cb(server, &keybinds[i].arg);
             return true;
         }
@@ -35,8 +30,7 @@ handle_keybind(absn_server *server, uint32_t mods, xkb_keysym_t keysym)
     return false;
 }
 
-void
-handle_key(struct wl_listener *listener, void *data)
+void handle_key(struct wl_listener *listener, void *data)
 {
     absn_keyboard *keyboard = wl_container_of(listener, keyboard, key);
     struct wlr_keyboard_key_event *event = data;
@@ -45,15 +39,12 @@ handle_key(struct wl_listener *listener, void *data)
     uint32_t code = event->keycode + 8;
     uint32_t mods = wlr_keyboard_get_modifiers(keyboard->wlr);
     const xkb_keysym_t *syms;
-	int nsyms = xkb_state_key_get_syms(keyboard->wlr->xkb_state, code,
-	    &syms);
+    int nsyms = xkb_state_key_get_syms(keyboard->wlr->xkb_state, code, &syms);
 
     bool handled = false;
     if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
         for (int i = 0; i < nsyms; ++i) {
-			handled = handle_keybind(keyboard->server, mods,
-				      syms[i]) ||
-			    handled;
+            handled = handle_keybind(keyboard->server, mods, syms[i]) || handled;
         }
     }
 
@@ -61,16 +52,13 @@ handle_key(struct wl_listener *listener, void *data)
         return;
 
     wlr_seat_set_keyboard(keyboard->server->seat, keyboard->wlr);
-	wlr_seat_keyboard_notify_key(keyboard->server->seat, event->time_msec,
-	    event->keycode, event->state);
+    wlr_seat_keyboard_notify_key(keyboard->server->seat, event->time_msec, event->keycode, event->state);
 }
 
-void
-handle_destroy(struct wl_listener *listener, void *data)
+void handle_destroy(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_keyboard *keyboard = wl_container_of(listener, keyboard,
-	    modifiers);
+    absn_keyboard *keyboard = wl_container_of(listener, keyboard, modifiers);
 
     wl_list_remove(&keyboard->modifiers.link);
     wl_list_remove(&keyboard->key.link);

src/layer-surface.c

@@ -1,39 +1,33 @@
 #include "types.h"
 
-void
-layer_surface_map(struct wl_listener *listener, void *data)
+void layer_surface_map(struct wl_listener *listener, void *data)
 {
     UNUSED(listener);
     UNUSED(data);
 }
 
-void
-layer_surface_unmap(struct wl_listener *listener, void *data)
+void layer_surface_unmap(struct wl_listener *listener, void *data)
 {
     UNUSED(listener);
     UNUSED(data);
 }
 
-void
-layer_surface_commit(struct wl_listener *listener, void *data)
+void layer_surface_commit(struct wl_listener *listener, void *data)
 {
     UNUSED(listener);
     UNUSED(data);
 }
 
-void
-layer_surface_new_popup(struct wl_listener *listener, void *data)
+void layer_surface_new_popup(struct wl_listener *listener, void *data)
 {
     UNUSED(listener);
     UNUSED(data);
 }
 
-void
-layer_surface_destroy(struct wl_listener *listener, void *data)
+void layer_surface_destroy(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_layer_surface *layer_surface = wl_container_of(listener,
-	    layer_surface, destroy);
+    absn_layer_surface *layer_surface = wl_container_of(listener, layer_surface, destroy);
 
     wl_list_remove(&layer_surface->link);
     wl_list_remove(&layer_surface->map.link);

src/layout.c

@@ -6,30 +6,25 @@
 #include "types.h"
 
 /* returns number of toplevels on workspace */
-static int
-prepare_output(struct absn_output *output)
+static int prepare_output(struct absn_output *output)
 {
     int res = 0;
     absn_toplevel *toplevel;
     wl_list_for_each(toplevel, &output->server->toplevels, link)
     {
         if (toplevel->workspace == output->workspace) {
-			wlr_scene_node_set_enabled(&toplevel->scene_tree->node,
-			    true);
+            wlr_scene_node_set_enabled(&toplevel->scene_tree->node, true);
             if (!toplevel->floating && !toplevel->fullscreen)
                 res++;
-		} else if (toplevel->output == output &&
-		    toplevel->workspace != output->workspace) {
-			wlr_scene_node_set_enabled(&toplevel->scene_tree->node,
-			    false);
+        } else if (toplevel->output == output && toplevel->workspace != output->workspace) {
+            wlr_scene_node_set_enabled(&toplevel->scene_tree->node, false);
         }
     }
 
     return res;
 }
 
-static void
-tile(struct absn_output *output)
+static void tile(struct absn_output *output)
 {
     int toplevels_count = prepare_output(output);
 
@@ -43,14 +38,11 @@ tile(struct absn_output *output)
     if (toplevels_count == 1) {
         wl_list_for_each(toplevel, &output->server->toplevels, link)
         {
-			if (toplevel->workspace == output->workspace &&
-			    !toplevel->floating && !toplevel->fullscreen)
+            if (toplevel->workspace == output->workspace && !toplevel->floating && !toplevel->fullscreen)
                 break;
         }
-		new_geom.x = output->geom.x + og,
-		new_geom.y = output->geom.y + og,
-		new_geom.width = output->geom.width - 2 * og,
-		new_geom.height = output->geom.height - 2 * og,
+        new_geom.x = output->geom.x + og, new_geom.y = output->geom.y + og,
+        new_geom.width = output->geom.width - 2 * og, new_geom.height = output->geom.height - 2 * og,
 
         toplevel_set_geom(toplevel, &new_geom);
         return;
@@ -62,9 +54,8 @@ tile(struct absn_output *output)
     int mcount = output->workspace->count;
     float msize = output->workspace->size;
 
-	int32_t main_stack_width = (toplevels_count <= mcount) ?
-	    output->geom.width - 2 * og :
-	    msize * (output->geom.width - 2 * og);
+    int32_t main_stack_width =
+        (toplevels_count <= mcount) ? output->geom.width - 2 * og : msize * (output->geom.width - 2 * og);
     int32_t w = output->geom.width - main_stack_width - 2 * og - lg;
 
     int32_t pure_h;
@@ -83,8 +74,7 @@ tile(struct absn_output *output)
 
         wl_list_for_each(toplevel, &output->server->toplevels, link)
         {
-			if (toplevel->workspace != output->workspace ||
-			    toplevel->floating || toplevel->fullscreen)
+            if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
                 continue;
 
             cur_h = h + (i < r ? 1 : 0);
@@ -105,8 +95,7 @@ tile(struct absn_output *output)
 
     wl_list_for_each(toplevel, &output->server->toplevels, link)
     {
-		if (toplevel->workspace != output->workspace ||
-		    toplevel->floating || toplevel->fullscreen)
+        if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
             continue;
 
         if (i < mcount) {
@@ -137,8 +126,7 @@ tile(struct absn_output *output)
 
             cur_h = h + (i - mcount < r ? 1 : 0);
 
-			new_geom.x = output->geom.x + main_stack_width + lg +
-			    og;
+            new_geom.x = output->geom.x + main_stack_width + lg + og;
             new_geom.y = output->geom.y + dy;
             new_geom.width = w;
             new_geom.height = cur_h;
@@ -152,8 +140,7 @@ tile(struct absn_output *output)
     }
 }
 
-static void
-tile_left(struct absn_output *output)
+static void tile_left(struct absn_output *output)
 {
     int toplevels_count = prepare_output(output);
 
@@ -167,14 +154,11 @@ tile_left(struct absn_output *output)
     if (toplevels_count == 1) {
         wl_list_for_each(toplevel, &output->server->toplevels, link)
         {
-			if (toplevel->workspace == output->workspace &&
-			    !toplevel->floating && !toplevel->fullscreen)
+            if (toplevel->workspace == output->workspace && !toplevel->floating && !toplevel->fullscreen)
                 break;
         }
-		new_geom.x = output->geom.x + og,
-		new_geom.y = output->geom.y + og,
-		new_geom.width = output->geom.width - 2 * og,
-		new_geom.height = output->geom.height - 2 * og,
+        new_geom.x = output->geom.x + og, new_geom.y = output->geom.y + og,
+        new_geom.width = output->geom.width - 2 * og, new_geom.height = output->geom.height - 2 * og,
 
         toplevel_set_geom(toplevel, &new_geom);
         return;
@@ -186,9 +170,8 @@ tile_left(struct absn_output *output)
     int mcount = output->workspace->count;
     float msize = output->workspace->size;
 
-	int32_t main_stack_width = (toplevels_count <= mcount) ?
-	    output->geom.width - 2 * og :
-	    msize * (output->geom.width - 2 * og);
+    int32_t main_stack_width =
+        (toplevels_count <= mcount) ? output->geom.width - 2 * og : msize * (output->geom.width - 2 * og);
     int32_t w = output->geom.width - main_stack_width - 2 * og - lg;
 
     int32_t pure_h;
@@ -207,8 +190,7 @@ tile_left(struct absn_output *output)
 
         wl_list_for_each(toplevel, &output->server->toplevels, link)
         {
-			if (toplevel->workspace != output->workspace ||
-			    toplevel->floating || toplevel->fullscreen)
+            if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
                 continue;
 
             cur_h = h + (i < r ? 1 : 0);
@@ -229,8 +211,7 @@ tile_left(struct absn_output *output)
 
     wl_list_for_each(toplevel, &output->server->toplevels, link)
     {
-		if (toplevel->workspace != output->workspace ||
-		    toplevel->floating || toplevel->fullscreen)
+        if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
             continue;
 
         if (i < mcount) {
@@ -275,8 +256,7 @@ tile_left(struct absn_output *output)
     }
 }
 
-static void
-monocle(struct absn_output *output)
+static void monocle(struct absn_output *output)
 {
     int toplevels_count = prepare_output(output);
 
@@ -295,16 +275,14 @@ monocle(struct absn_output *output)
     absn_toplevel *toplevel;
     wl_list_for_each(toplevel, &output->server->toplevels, link)
     {
-		if (toplevel->workspace != output->workspace ||
-		    toplevel->floating || toplevel->fullscreen)
+        if (toplevel->workspace != output->workspace || toplevel->floating || toplevel->fullscreen)
             continue;
 
         toplevel_set_geom(toplevel, &new_geom);
     }
 }
 
-void
-layout_arrange(struct absn_output *output)
+void layout_arrange(struct absn_output *output)
 {
     if (!output)
         return;

src/output.c

@@ -6,16 +6,14 @@
 #include "toplevel.h"
 #include "types.h"
 
-void
-output_frame(struct wl_listener *listener, void *data)
+void output_frame(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     struct timespec now;
     absn_output *output = wl_container_of(listener, output, frame);
 
     struct wlr_scene *scene = output->server->scene;
-	struct wlr_scene_output *scene_output =
-	    wlr_scene_get_scene_output(scene, output->wlr);
+    struct wlr_scene_output *scene_output = wlr_scene_get_scene_output(scene, output->wlr);
 
     absn_toplevel *toplevel;
     wl_list_for_each(toplevel, &output->server->toplevels, link)
@@ -31,21 +29,17 @@ skip:
     wlr_scene_output_send_frame_done(scene_output, &now);
 }
 
-void
-output_request_state(struct wl_listener *listener, void *data)
+void output_request_state(struct wl_listener *listener, void *data)
 {
-	struct absn_output *output = wl_container_of(listener, output,
-	    request_state);
+    struct absn_output *output = wl_container_of(listener, output, request_state);
     const struct wlr_output_event_request_state *event = data;
     wlr_output_commit_state(output->wlr, event->state);
 }
 
-void
-output_destroy(struct wl_listener *listener, void *data)
+void output_destroy(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	struct absn_output *output = wl_container_of(listener, output,
-	    request_state);
+    struct absn_output *output = wl_container_of(listener, output, request_state);
 
     wl_list_remove(&output->frame.link);
     wl_list_remove(&output->request_state.link);
@@ -54,13 +48,11 @@ output_destroy(struct wl_listener *listener, void *data)
     free(output);
 }
 
-void
-output_layout_change(struct wl_listener *listener, void *data)
+void output_layout_change(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     absn_server *server = wl_container_of(listener, server, layout_change);
-	struct wlr_output_configuration_v1 *config =
-	    wlr_output_configuration_v1_create();
+    struct wlr_output_configuration_v1 *config = wlr_output_configuration_v1_create();
 
     absn_toplevel *toplevel = NULL;
     absn_output *output;
@@ -70,8 +62,7 @@ output_layout_change(struct wl_listener *listener, void *data)
     {
         if (output->wlr->enabled)
             continue;
-		config_head = wlr_output_configuration_head_v1_create(config,
-		    output->wlr);
+        config_head = wlr_output_configuration_head_v1_create(config, output->wlr);
         config_head->state.enabled = 0;
         wlr_output_layout_remove(server->output_layout, output->wlr);
 
@@ -81,34 +72,26 @@ output_layout_change(struct wl_listener *listener, void *data)
 
     wl_list_for_each(output, &server->outputs, link)
     {
-		if (output->wlr->enabled &&
-		    !wlr_output_layout_get(server->output_layout, output->wlr))
-			wlr_output_layout_add_auto(server->output_layout,
-			    toplevel->output->wlr);
+        if (output->wlr->enabled && !wlr_output_layout_get(server->output_layout, output->wlr))
+            wlr_output_layout_add_auto(server->output_layout, toplevel->output->wlr);
     }
 
     struct wlr_box layout_geom;
     wlr_output_layout_get_box(server->output_layout, NULL, &layout_geom);
 
-	wlr_scene_node_set_position(&server->bg->node, layout_geom.x,
-	    layout_geom.y);
-	wlr_scene_rect_set_size(server->bg, layout_geom.width,
-	    layout_geom.height);
+    wlr_scene_node_set_position(&server->bg->node, layout_geom.x, layout_geom.y);
+    wlr_scene_rect_set_size(server->bg, layout_geom.width, layout_geom.height);
 
     wl_list_for_each(output, &server->outputs, link)
     {
         if (!output->wlr->enabled)
             continue;
-		config_head = wlr_output_configuration_head_v1_create(config,
-		    output->wlr);
+        config_head = wlr_output_configuration_head_v1_create(config, output->wlr);
 
-		wlr_output_layout_get_box(server->output_layout, output->wlr,
-		    &output->geom);
+        wlr_output_layout_get_box(server->output_layout, output->wlr, &output->geom);
 
-		if ((toplevel = focus_get_topmost(server)) &&
-		    toplevel->fullscreen)
-			toplevel_set_size(toplevel, output->geom.width,
-			    output->geom.height);
+        if ((toplevel = focus_get_topmost(server)) && toplevel->fullscreen)
+            toplevel_set_size(toplevel, output->geom.width, output->geom.height);
 
         config_head->state.x = output->geom.x;
         config_head->state.y = output->geom.y;
@@ -132,18 +115,15 @@ output_layout_change(struct wl_listener *listener, void *data)
     wlr_output_manager_v1_set_configuration(server->output_mgr, config);
 }
 
-void
-update_focused_output(absn_server *server)
+void update_focused_output(absn_server *server)
 {
     absn_output *output;
     int32_t cursor_x = server->cursor->x;
     int32_t cursor_y = server->cursor->y;
     wl_list_for_each(output, &server->outputs, link)
     {
-		bool cursor_in_output_x = cursor_x >= output->geom.x &&
-		    cursor_x <= output->geom.x + output->geom.width;
-		bool cursor_in_output_y = cursor_y >= output->geom.y &&
-		    cursor_y <= output->geom.y + output->geom.height;
+        bool cursor_in_output_x = cursor_x >= output->geom.x && cursor_x <= output->geom.x + output->geom.width;
+        bool cursor_in_output_y = cursor_y >= output->geom.y && cursor_y <= output->geom.y + output->geom.height;
         if (cursor_in_output_x && cursor_in_output_y) {
             server->focused_output = output;
             break;

src/seat.c

@@ -3,36 +3,28 @@
 
 #include "types.h"
 
-void
-request_cursor(struct wl_listener *listener, void *data)
+void request_cursor(struct wl_listener *listener, void *data)
 {
     absn_server *server = wl_container_of(listener, server, request_cursor);
     struct wlr_seat_pointer_request_set_cursor_event *event = data;
-	struct wlr_seat_client *client =
-	    server->seat->pointer_state.focused_client;
+    struct wlr_seat_client *client = server->seat->pointer_state.focused_client;
 
     if (client == event->seat_client)
-		wlr_cursor_set_surface(server->cursor, event->surface,
-		    event->hotspot_x, event->hotspot_y);
+        wlr_cursor_set_surface(server->cursor, event->surface, event->hotspot_x, event->hotspot_y);
 }
 
-void
-pointer_focus_change(struct wl_listener *listener, void *data)
+void pointer_focus_change(struct wl_listener *listener, void *data)
 {
-	absn_server *server = wl_container_of(listener, server,
-	    pointer_focus_change);
+    absn_server *server = wl_container_of(listener, server, pointer_focus_change);
     struct wlr_seat_pointer_focus_change_event *event = data;
 
     if (!event->new_surface)
-		wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr,
-		    "default");
+        wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "default");
 }
 
-void
-request_set_selection(struct wl_listener *listener, void *data)
+void request_set_selection(struct wl_listener *listener, void *data)
 {
-	absn_server *server = wl_container_of(listener, server,
-	    request_set_selection);
+    absn_server *server = wl_container_of(listener, server, request_set_selection);
     struct wlr_seat_request_set_selection_event *event = data;
 
     wlr_seat_set_selection(server->seat, event->source, event->serial);

src/server.c

@@ -23,8 +23,7 @@
 #include "xwayland.h"
 #endif
 
-void
-new_output(struct wl_listener *listener, void *data)
+void new_output(struct wl_listener *listener, void *data)
 {
     absn_server *server = wl_container_of(listener, server, new_output);
     struct wlr_output *wlr_output = data;
@@ -55,8 +54,7 @@ new_output(struct wl_listener *listener, void *data)
     }
 
     LISTEN(output->frame, output_frame, wlr_output->events.frame);
-	LISTEN(output->request_state, output_request_state,
-	    wlr_output->events.request_state);
+    LISTEN(output->request_state, output_request_state, wlr_output->events.request_state);
     LISTEN(output->destroy, output_destroy, wlr_output->events.destroy);
 
     wl_list_insert(&server->outputs, &output->link);
@@ -64,21 +62,15 @@ new_output(struct wl_listener *listener, void *data)
     for (int i = 0; i < 4; ++i)
         wl_list_init(&output->layers[i]);
 
-	struct wlr_output_layout_output *l_layout =
-	    wlr_output_layout_add_auto(server->output_layout, output->wlr);
-	struct wlr_scene_output *scene_output =
-	    wlr_scene_output_create(server->scene, wlr_output);
-	wlr_scene_output_layout_add_output(server->scene_layout, l_layout,
-	    scene_output);
-	wlr_output_layout_get_box(server->output_layout, output->wlr,
-	    &output->geom);
+    struct wlr_output_layout_output *l_layout = wlr_output_layout_add_auto(server->output_layout, output->wlr);
+    struct wlr_scene_output *scene_output = wlr_scene_output_create(server->scene, wlr_output);
+    wlr_scene_output_layout_add_output(server->scene_layout, l_layout, scene_output);
+    wlr_output_layout_get_box(server->output_layout, output->wlr, &output->geom);
 }
 
-void
-new_xdg_toplevel(struct wl_listener *listener, void *data)
+void new_xdg_toplevel(struct wl_listener *listener, void *data)
 {
-	absn_server *server = wl_container_of(listener, server,
-	    new_xdg_toplevel);
+    absn_server *server = wl_container_of(listener, server, new_xdg_toplevel);
     struct wlr_xdg_toplevel *xdg_toplevel = data;
 
     absn_toplevel *toplevel = calloc(1, sizeof(*toplevel));
@@ -90,26 +82,17 @@ new_xdg_toplevel(struct wl_listener *listener, void *data)
 
     wlr_surface_set_preferred_buffer_scale(toplevel->xdg->base->surface, 1);
 
-	LISTEN(toplevel->commit, toplevel_commit,
-	    xdg_toplevel->base->surface->events.commit);
-	LISTEN(toplevel->map, toplevel_map,
-	    xdg_toplevel->base->surface->events.map);
-	LISTEN(toplevel->unmap, toplevel_unmap,
-	    xdg_toplevel->base->surface->events.unmap);
-	LISTEN(toplevel->destroy, toplevel_destroy,
-	    xdg_toplevel->events.destroy);
-	LISTEN(toplevel->request_move, toplevel_request_move,
-	    xdg_toplevel->events.request_move);
-	LISTEN(toplevel->request_resize, toplevel_request_resize,
-	    xdg_toplevel->events.request_resize);
-	LISTEN(toplevel->request_maximize, toplevel_request_maximize,
-	    xdg_toplevel->events.request_maximize);
-	LISTEN(toplevel->request_fullscreen, toplevel_request_fullscreen,
-	    xdg_toplevel->events.request_fullscreen);
+    LISTEN(toplevel->commit, toplevel_commit, xdg_toplevel->base->surface->events.commit);
+    LISTEN(toplevel->map, toplevel_map, xdg_toplevel->base->surface->events.map);
+    LISTEN(toplevel->unmap, toplevel_unmap, xdg_toplevel->base->surface->events.unmap);
+    LISTEN(toplevel->destroy, toplevel_destroy, xdg_toplevel->events.destroy);
+    LISTEN(toplevel->request_move, toplevel_request_move, xdg_toplevel->events.request_move);
+    LISTEN(toplevel->request_resize, toplevel_request_resize, xdg_toplevel->events.request_resize);
+    LISTEN(toplevel->request_maximize, toplevel_request_maximize, xdg_toplevel->events.request_maximize);
+    LISTEN(toplevel->request_fullscreen, toplevel_request_fullscreen, xdg_toplevel->events.request_fullscreen);
 }
 
-void
-new_xdg_popup(struct wl_listener *listener, void *data)
+void new_xdg_popup(struct wl_listener *listener, void *data)
 {
     absn_server *server = wl_container_of(listener, server, new_xdg_popup);
     struct wlr_xdg_popup *xdg_popup = data;
@@ -117,78 +100,60 @@ new_xdg_popup(struct wl_listener *listener, void *data)
     absn_popup *popup = calloc(1, sizeof(*popup));
     popup->wlr = xdg_popup;
 
-	struct wlr_xdg_surface *parent = wlr_xdg_surface_try_from_wlr_surface(
-	    xdg_popup->parent);
+    struct wlr_xdg_surface *parent = wlr_xdg_surface_try_from_wlr_surface(xdg_popup->parent);
     absn_toplevel *parent_toplevel = parent->data;
     struct wlr_scene_tree *parent_tree = parent_toplevel->scene_tree;
-	xdg_popup->base->data = wlr_scene_xdg_surface_create(parent_tree,
-	    xdg_popup->base);
+    xdg_popup->base->data = wlr_scene_xdg_surface_create(parent_tree, xdg_popup->base);
 
-	LISTEN(popup->commit, xdg_popup_commit,
-	    xdg_popup->base->surface->events.commit);
-	LISTEN(popup->destroy, xdg_popup_destroy,
-	    xdg_popup->base->surface->events.destroy);
+    LISTEN(popup->commit, xdg_popup_commit, xdg_popup->base->surface->events.commit);
+    LISTEN(popup->destroy, xdg_popup_destroy, xdg_popup->base->surface->events.destroy);
 }
 
-void
-new_xdg_decoration(struct wl_listener *listener, void *data)
+void new_xdg_decoration(struct wl_listener *listener, void *data)
 {
     UNUSED(listener);
     struct wlr_xdg_toplevel_decoration_v1 *deco = data;
     absn_toplevel *toplevel = deco->toplevel->base->data;
     toplevel->deco = deco;
 
-	LISTEN(toplevel->deco_request_mode, deco_request_mode,
-	    deco->events.request_mode);
+    LISTEN(toplevel->deco_request_mode, deco_request_mode, deco->events.request_mode);
     LISTEN(toplevel->deco_destroy, deco_destroy, deco->events.destroy);
 
     /* Forse server side decoration mode */
     deco_request_mode(&toplevel->deco_request_mode, toplevel->deco);
 }
 
-void
-new_layer_surface(struct wl_listener *listener, void *data)
+void new_layer_surface(struct wl_listener *listener, void *data)
 {
-	absn_server *server = wl_container_of(listener, server,
-	    new_layer_surface);
+    absn_server *server = wl_container_of(listener, server, new_layer_surface);
     struct wlr_layer_surface_v1 *surface = data;
 
-	if (!surface->output &&
-	    !(surface->output = server->focused_output->wlr)) {
+    if (!surface->output && !(surface->output = server->focused_output->wlr)) {
         wlr_layer_surface_v1_destroy(surface);
         return;
     }
 
     absn_layer_surface *layer_surface = calloc(1, sizeof(*layer_surface));
 
-	LISTEN(layer_surface->map, layer_surface_map,
-	    surface->surface->events.map);
-	LISTEN(layer_surface->unmap, layer_surface_unmap,
-	    surface->surface->events.unmap);
-	LISTEN(layer_surface->commit, layer_surface_commit,
-	    surface->surface->events.commit);
-	LISTEN(layer_surface->new_popup, layer_surface_new_popup,
-	    surface->events.new_popup);
-	LISTEN(layer_surface->destroy, layer_surface_destroy,
-	    surface->surface->events.destroy);
+    LISTEN(layer_surface->map, layer_surface_map, surface->surface->events.map);
+    LISTEN(layer_surface->unmap, layer_surface_unmap, surface->surface->events.unmap);
+    LISTEN(layer_surface->commit, layer_surface_commit, surface->surface->events.commit);
+    LISTEN(layer_surface->new_popup, layer_surface_new_popup, surface->events.new_popup);
+    LISTEN(layer_surface->destroy, layer_surface_destroy, surface->surface->events.destroy);
 
     layer_surface->wlr = surface;
     layer_surface->output = surface->output->data;
 
-	struct wlr_scene_tree *scene_layer =
-	    server->layers[layermap[surface->pending.layer]];
-	layer_surface->scene_layer =
-	    wlr_scene_layer_surface_v1_create(scene_layer, surface);
+    struct wlr_scene_tree *scene_layer = server->layers[layermap[surface->pending.layer]];
+    layer_surface->scene_layer = wlr_scene_layer_surface_v1_create(scene_layer, surface);
     layer_surface->scene_tree = layer_surface->scene_layer->tree;
 
-	wl_list_insert(&layer_surface->output->layers[surface->pending.layer],
-	    &layer_surface->link);
+    wl_list_insert(&layer_surface->output->layers[surface->pending.layer], &layer_surface->link);
     wlr_surface_send_enter(surface->surface, surface->output);
 }
 
 #ifdef XWAYLAND
-void
-xwayland_ready(struct wl_listener *listener, void *data)
+void xwayland_ready(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     absn_server *server = wl_container_of(listener, server, xw_ready);
@@ -196,18 +161,13 @@ xwayland_ready(struct wl_listener *listener, void *data)
     wlr_xwayland_set_seat(server->xwayland, server->seat);
 
     struct wlr_xcursor *xcursor;
-	if ((xcursor = wlr_xcursor_manager_get_xcursor(server->cursor_mgr,
-		 "default", 1))) {
-		struct wlr_buffer *buffer = wlr_xcursor_image_get_buffer(
-		    xcursor->images[0]);
-		wlr_xwayland_set_cursor(server->xwayland, buffer,
-		    xcursor->images[0]->hotspot_x,
-		    xcursor->images[0]->hotspot_y);
+    if ((xcursor = wlr_xcursor_manager_get_xcursor(server->cursor_mgr, "default", 1))) {
+        struct wlr_buffer *buffer = wlr_xcursor_image_get_buffer(xcursor->images[0]);
+        wlr_xwayland_set_cursor(server->xwayland, buffer, xcursor->images[0]->hotspot_x, xcursor->images[0]->hotspot_y);
     }
 }
 
-void
-xwayland_new_surface(struct wl_listener *listener, void *data)
+void xwayland_new_surface(struct wl_listener *listener, void *data)
 {
     absn_server *server = wl_container_of(listener, server, xw_new_surface);
     struct wlr_xwayland_surface *surface = data;
@@ -220,49 +180,36 @@ xwayland_new_surface(struct wl_listener *listener, void *data)
     surface->data = toplevel;
 
     LISTEN(toplevel->destroy, toplevel_destroy, surface->events.destroy);
-	LISTEN(toplevel->request_maximize, toplevel_request_maximize,
-	    surface->events.request_maximize);
-	LISTEN(toplevel->request_fullscreen, toplevel_request_fullscreen,
-	    surface->events.request_fullscreen);
+    LISTEN(toplevel->request_maximize, toplevel_request_maximize, surface->events.request_maximize);
+    LISTEN(toplevel->request_fullscreen, toplevel_request_fullscreen, surface->events.request_fullscreen);
 
-	LISTEN(toplevel->xw_activate, xwayland_activate,
-	    surface->events.request_activate);
-	LISTEN(toplevel->xw_associate, xwayland_associate,
-	    surface->events.associate);
-	LISTEN(toplevel->xw_dissociate, xwayland_dissociate,
-	    surface->events.dissociate);
-	LISTEN(toplevel->xw_configure, xwayland_configure,
-	    surface->events.request_configure);
-	LISTEN(toplevel->xw_set_hints, xwayland_set_hints,
-	    surface->events.set_hints);
+    LISTEN(toplevel->xw_activate, xwayland_activate, surface->events.request_activate);
+    LISTEN(toplevel->xw_associate, xwayland_associate, surface->events.associate);
+    LISTEN(toplevel->xw_dissociate, xwayland_dissociate, surface->events.dissociate);
+    LISTEN(toplevel->xw_configure, xwayland_configure, surface->events.request_configure);
+    LISTEN(toplevel->xw_set_hints, xwayland_set_hints, surface->events.set_hints);
 }
 #endif
 
-void
-cursor_motion(struct wl_listener *listener, void *data)
+void cursor_motion(struct wl_listener *listener, void *data)
 {
     absn_server *server = wl_container_of(listener, server, cursor_motion);
     struct wlr_pointer_motion_event *event = data;
     update_focused_output(server);
-	wlr_cursor_move(server->cursor, &event->pointer->base, event->delta_x,
-	    event->delta_y);
+    wlr_cursor_move(server->cursor, &event->pointer->base, event->delta_x, event->delta_y);
     process_cursor_motion(server, event->time_msec);
 }
 
-void
-cursor_motion_abs(struct wl_listener *listener, void *data)
+void cursor_motion_abs(struct wl_listener *listener, void *data)
 {
-	absn_server *server = wl_container_of(listener, server,
-	    cursor_motion_abs);
+    absn_server *server = wl_container_of(listener, server, cursor_motion_abs);
     struct wlr_pointer_motion_absolute_event *event = data;
     update_focused_output(server);
-	wlr_cursor_warp_absolute(server->cursor, &event->pointer->base,
-	    event->x, event->y);
+    wlr_cursor_warp_absolute(server->cursor, &event->pointer->base, event->x, event->y);
     process_cursor_motion(server, event->time_msec);
 }
 
-void
-cursor_button(struct wl_listener *listener, void *data)
+void cursor_button(struct wl_listener *listener, void *data)
 {
     absn_server *server = wl_container_of(listener, server, cursor_button);
     struct wlr_pointer_button_event *event = data;
@@ -273,20 +220,17 @@ cursor_button(struct wl_listener *listener, void *data)
     } else {
         double sx, sy;
         struct wlr_surface *surface = NULL;
-		absn_toplevel *toplevel = toplevel_at(server, server->cursor->x,
-		    server->cursor->y, &surface, &sx, &sy);
+        absn_toplevel *toplevel = toplevel_at(server, server->cursor->x, server->cursor->y, &surface, &sx, &sy);
 
         if (!toplevel)
             goto handle;
 
-		struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(
-		    server->seat);
+        struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(server->seat);
         uint32_t mods = wlr_keyboard_get_modifiers(keyboard);
         if (mods & CURSOR_MOD) {
             if (event->button == CURSOR_MOVE_BUTTON) {
                 server->cursor_mode = CURSOR_MOVE;
-				wlr_cursor_set_xcursor(server->cursor,
-				    server->cursor_mgr, "all-scroll");
+                wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "all-scroll");
                 handled = true;
             } else if (event->button == CURSOR_RESIZE_BUTTON) {
                 server->cursor_mode = CURSOR_RESIZE;
@@ -311,25 +255,18 @@ cursor_button(struct wl_listener *listener, void *data)
         int32_t width = toplevel->xdg->base->geometry.width;
         int32_t height = toplevel->xdg->base->geometry.height;
 
-		if (server->grab_x > (lx + width / 2) &&
-		    server->grab_y > (ly + height / 2)) {
+        if (server->grab_x > (lx + width / 2) && server->grab_y > (ly + height / 2)) {
             server->resize_corner = BOTTOM_RIGHT;
-			wlr_cursor_set_xcursor(server->cursor,
-			    server->cursor_mgr, "se-resize");
-		} else if (server->grab_x < (lx + width / 2) &&
-		    server->grab_y > (ly + height / 2)) {
+            wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "se-resize");
+        } else if (server->grab_x < (lx + width / 2) && server->grab_y > (ly + height / 2)) {
             server->resize_corner = BOTTOM_LEFT;
-			wlr_cursor_set_xcursor(server->cursor,
-			    server->cursor_mgr, "sw-resize");
-		} else if (server->grab_x > (lx + width / 2) &&
-		    server->grab_y < (ly + height / 2)) {
+            wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "sw-resize");
+        } else if (server->grab_x > (lx + width / 2) && server->grab_y < (ly + height / 2)) {
             server->resize_corner = TOP_RIGHT;
-			wlr_cursor_set_xcursor(server->cursor,
-			    server->cursor_mgr, "ne-resize");
+            wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "ne-resize");
         } else {
             server->resize_corner = TOP_LEFT;
-			wlr_cursor_set_xcursor(server->cursor,
-			    server->cursor_mgr, "nw-resize");
+            wlr_cursor_set_xcursor(server->cursor, server->cursor_mgr, "nw-resize");
         }
 
         wlr_xdg_toplevel_set_resizing(toplevel->xdg, true);
@@ -337,66 +274,55 @@ cursor_button(struct wl_listener *listener, void *data)
 
 handle:
     if (!handled) {
-		wlr_seat_pointer_notify_button(server->seat, event->time_msec,
-		    event->button, event->state);
+        wlr_seat_pointer_notify_button(server->seat, event->time_msec, event->button, event->state);
     }
 }
 
-void
-cursor_axis(struct wl_listener *listener, void *data)
+void cursor_axis(struct wl_listener *listener, void *data)
 {
     absn_server *server = wl_container_of(listener, server, cursor_axis);
     struct wlr_pointer_axis_event *event = data;
-	wlr_seat_pointer_notify_axis(server->seat, event->time_msec,
-	    event->orientation, event->delta, event->delta_discrete,
-	    event->source, event->relative_direction);
+    wlr_seat_pointer_notify_axis(server->seat, event->time_msec, event->orientation, event->delta,
+                                 event->delta_discrete, event->source, event->relative_direction);
 }
 
-void
-cursor_frame(struct wl_listener *listener, void *data)
+void cursor_frame(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     absn_server *server = wl_container_of(listener, server, cursor_frame);
     wlr_seat_pointer_notify_frame(server->seat);
 }
 
-static void
-new_keyboard(absn_server *server, struct wlr_input_device *device)
+static void new_keyboard(absn_server *server, struct wlr_input_device *device)
 {
-	struct wlr_keyboard *wlr_keyboard = wlr_keyboard_from_input_device(
-	    device);
+    struct wlr_keyboard *wlr_keyboard = wlr_keyboard_from_input_device(device);
     absn_keyboard *keyboard = calloc(1, sizeof(*keyboard));
     keyboard->server = server;
     keyboard->wlr = wlr_keyboard;
 
     struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
-	struct xkb_keymap *keymap = xkb_keymap_new_from_names(context, NULL,
-	    XKB_KEYMAP_COMPILE_NO_FLAGS);
+    struct xkb_keymap *keymap = xkb_keymap_new_from_names(context, NULL, XKB_KEYMAP_COMPILE_NO_FLAGS);
 
     wlr_keyboard_set_keymap(wlr_keyboard, keymap);
     xkb_keymap_unref(keymap);
     xkb_context_unref(context);
     wlr_keyboard_set_repeat_info(wlr_keyboard, 25, 600);
 
-	LISTEN(keyboard->modifiers, handle_modifiers,
-	    wlr_keyboard->events.modifiers);
+    LISTEN(keyboard->modifiers, handle_modifiers, wlr_keyboard->events.modifiers);
     LISTEN(keyboard->key, handle_key, wlr_keyboard->events.key);
-	LISTEN(keyboard->destroy, handle_destroy,
-	    wlr_keyboard->base.events.destroy);
+    LISTEN(keyboard->destroy, handle_destroy, wlr_keyboard->base.events.destroy);
 
     wlr_seat_set_keyboard(server->seat, wlr_keyboard);
 
     wl_list_insert(&server->keyboards, &keyboard->link);
 }
 
-static void
-new_pointer(absn_server *server, struct wlr_input_device *device)
+static void new_pointer(absn_server *server, struct wlr_input_device *device)
 {
     wlr_cursor_attach_input_device(server->cursor, device);
 }
 
-void
-new_input(struct wl_listener *listener, void *data)
+void new_input(struct wl_listener *listener, void *data)
 {
     absn_server *server = wl_container_of(listener, server, new_input);
     struct wlr_input_device *device = data;

src/toplevel-handlers.c

@@ -7,25 +7,19 @@
 #include "output.h"
 #include "toplevel.h"
 
-void
-toplevel_map(struct wl_listener *listener, void *data)
+void toplevel_map(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     absn_toplevel *toplevel = wl_container_of(listener, toplevel, map);
     absn_server *server = toplevel->server;
 
-	toplevel->scene_tree = wlr_scene_tree_create(
-	    server->layers[LAYER_TILE]);
+    toplevel->scene_tree = wlr_scene_tree_create(server->layers[LAYER_TILE]);
     toplevel->scene_tree->node.data = toplevel;
-	wlr_scene_node_set_enabled(&toplevel->scene_tree->node,
-	    toplevel_is_unmanaged(toplevel));
+    wlr_scene_node_set_enabled(&toplevel->scene_tree->node, toplevel_is_unmanaged(toplevel));
 
     if (toplevel->type != TOPLEVEL_X11 &&
-	    wl_resource_get_version(toplevel->xdg->resource) >=
-		XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION) {
-		wlr_xdg_toplevel_set_tiled(toplevel->xdg,
-		    WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT |
-			WLR_EDGE_RIGHT);
+        wl_resource_get_version(toplevel->xdg->resource) >= XDG_TOPLEVEL_STATE_TILED_RIGHT_SINCE_VERSION) {
+        wlr_xdg_toplevel_set_tiled(toplevel->xdg, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
     } else {
         wlr_xdg_toplevel_set_maximized(toplevel->xdg, true);
     }
@@ -34,13 +28,11 @@ toplevel_map(struct wl_listener *listener, void *data)
 
 #ifdef XWAYLAND
     if (toplevel->type == TOPLEVEL_X11) {
-		toplevel->scene_surface = wlr_scene_subsurface_tree_create(
-		    toplevel->scene_tree, toplevel->xw->surface);
+        toplevel->scene_surface = wlr_scene_subsurface_tree_create(toplevel->scene_tree, toplevel->xw->surface);
     } else
 #endif
     {
-		toplevel->scene_surface = wlr_scene_xdg_surface_create(
-		    toplevel->scene_tree, toplevel->xdg->base);
+        toplevel->scene_surface = wlr_scene_xdg_surface_create(toplevel->scene_tree, toplevel->xdg->base);
     }
     toplevel->scene_surface->node.data = toplevel;
 
@@ -48,8 +40,7 @@ toplevel_map(struct wl_listener *listener, void *data)
     toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : TOPLEVEL_BW;
 
     for (int i = 0; i < 4; ++i) {
-		toplevel->border[i] = wlr_scene_rect_create(
-		    toplevel->scene_tree, 0, 0, unfocused_bc);
+        toplevel->border[i] = wlr_scene_rect_create(toplevel->scene_tree, 0, 0, unfocused_bc);
         toplevel->border[i]->node.data = toplevel;
     }
 
@@ -65,8 +56,7 @@ toplevel_map(struct wl_listener *listener, void *data)
     focus_toplevel(focus_get_topmost(toplevel->server));
 }
 
-void
-toplevel_unmap(struct wl_listener *listener, void *data)
+void toplevel_unmap(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     absn_toplevel *toplevel = wl_container_of(listener, toplevel, unmap);
@@ -85,8 +75,7 @@ toplevel_unmap(struct wl_listener *listener, void *data)
     wlr_scene_node_destroy(&toplevel->scene_tree->node);
 }
 
-void
-toplevel_destroy(struct wl_listener *listener, void *data)
+void toplevel_destroy(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     absn_toplevel *toplevel = wl_container_of(listener, toplevel, destroy);
@@ -115,41 +104,33 @@ toplevel_destroy(struct wl_listener *listener, void *data)
     free(toplevel);
 }
 
-void
-toplevel_request_move(struct wl_listener *listener, void *data)
+void toplevel_request_move(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    request_move);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, request_move);
     if (toplevel->xdg->base->initialized)
         wlr_xdg_surface_schedule_configure(toplevel->xdg->base);
 }
 
-void
-toplevel_request_resize(struct wl_listener *listener, void *data)
+void toplevel_request_resize(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    request_resize);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, request_resize);
     if (toplevel->xdg->base->initialized)
         wlr_xdg_surface_schedule_configure(toplevel->xdg->base);
 }
 
-void
-toplevel_request_maximize(struct wl_listener *listener, void *data)
+void toplevel_request_maximize(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    request_maximize);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, request_maximize);
     if (toplevel->xdg->base->initialized)
         wlr_xdg_surface_schedule_configure(toplevel->xdg->base);
 }
 
-void
-toplevel_request_fullscreen(struct wl_listener *listener, void *data)
+void toplevel_request_fullscreen(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    request_fullscreen);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, request_fullscreen);
     toplevel_set_fullscreen(toplevel, toplevel->xdg->requested.fullscreen);
 }

src/toplevel.c

@@ -12,12 +12,10 @@
  * its surface and coordinates inside of it
  * to process input event
  */
-absn_toplevel *
-toplevel_at(absn_server *server, double lx, double ly,
-    struct wlr_surface **surface, double *sx, double *sy)
+absn_toplevel *toplevel_at(absn_server *server, double lx, double ly, struct wlr_surface **surface, double *sx,
+                           double *sy)
 {
-	struct wlr_scene_node *node =
-	    wlr_scene_node_at(&server->scene->tree.node, lx, ly, sx, sy);
+    struct wlr_scene_node *node = wlr_scene_node_at(&server->scene->tree.node, lx, ly, sx, sy);
     if (!node) {
         return NULL;
     }
@@ -53,8 +51,7 @@ toplevel_at(absn_server *server, double lx, double ly,
  * move or resize it and just draw it
  * where it wants
  */
-bool
-toplevel_is_unmanaged(absn_toplevel *toplevel)
+bool toplevel_is_unmanaged(absn_toplevel *toplevel)
 {
 #ifdef XWAYLAND
     if (toplevel->type == TOPLEVEL_X11)
@@ -64,8 +61,7 @@ toplevel_is_unmanaged(absn_toplevel *toplevel)
 }
 
 /* used only to get initial window size */
-void
-toplevel_get_geom(absn_toplevel *toplevel)
+void toplevel_get_geom(absn_toplevel *toplevel)
 {
 #ifdef XWAYLAND
     if (toplevel->type == TOPLEVEL_X11) {
@@ -80,44 +76,35 @@ toplevel_get_geom(absn_toplevel *toplevel)
     }
 }
 
-static void
-toplevel_update_borders_geom(absn_toplevel *toplevel)
+static void toplevel_update_borders_geom(absn_toplevel *toplevel)
 {
     int32_t bw = toplevel->bw;
 
-	if (toplevel->geom.width - 2 * bw < 0 ||
-	    toplevel->geom.height - 2 * bw < 0)
+    if (toplevel->geom.width - 2 * bw < 0 || toplevel->geom.height - 2 * bw < 0)
         return;
 
-	wlr_scene_node_set_position(&toplevel->scene_tree->node,
-	    toplevel->geom.x, toplevel->geom.y);
+    wlr_scene_node_set_position(&toplevel->scene_tree->node, toplevel->geom.x, toplevel->geom.y);
     wlr_scene_node_set_position(&toplevel->scene_surface->node, bw, bw);
 
-	wlr_scene_rect_set_size(toplevel->border[0],
-	    toplevel->geom.width - 2 * bw, bw);
-	wlr_scene_rect_set_size(toplevel->border[1],
-	    toplevel->geom.width - 2 * bw, bw);
+    wlr_scene_rect_set_size(toplevel->border[0], toplevel->geom.width - 2 * bw, bw);
+    wlr_scene_rect_set_size(toplevel->border[1], toplevel->geom.width - 2 * bw, bw);
     wlr_scene_rect_set_size(toplevel->border[2], bw, toplevel->geom.height);
     wlr_scene_rect_set_size(toplevel->border[3], bw, toplevel->geom.height);
 
     wlr_scene_node_set_position(&toplevel->border[0]->node, bw, 0);
-	wlr_scene_node_set_position(&toplevel->border[1]->node, bw,
-	    toplevel->geom.height - bw);
+    wlr_scene_node_set_position(&toplevel->border[1]->node, bw, toplevel->geom.height - bw);
     wlr_scene_node_set_position(&toplevel->border[2]->node, 0, 0);
-	wlr_scene_node_set_position(&toplevel->border[3]->node,
-	    toplevel->geom.width - bw, 0);
+    wlr_scene_node_set_position(&toplevel->border[3]->node, toplevel->geom.width - bw, 0);
 }
 
-void
-toplevel_set_pos(absn_toplevel *toplevel, int32_t x, int32_t y)
+void toplevel_set_pos(absn_toplevel *toplevel, int32_t x, int32_t y)
 {
     toplevel->geom.x = x;
     toplevel->geom.y = y;
     wlr_scene_node_set_position(&toplevel->scene_tree->node, x, y);
 }
 
-void
-toplevel_set_size(absn_toplevel *toplevel, int32_t width, int32_t height)
+void toplevel_set_size(absn_toplevel *toplevel, int32_t width, int32_t height)
 {
     if (width <= 2 * toplevel->bw || height <= 2 * toplevel->bw ||
         (width == toplevel->geom.width && height == toplevel->geom.height))
@@ -135,36 +122,30 @@ toplevel_set_size(absn_toplevel *toplevel, int32_t width, int32_t height)
     };
 
     if (toplevel->type == TOPLEVEL_XDG) {
-		if (wl_resource_get_version(toplevel->xdg->resource) >=
-		    XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION)
-			wlr_xdg_toplevel_set_bounds(toplevel->xdg, width,
-			    height);
-		toplevel->resizing = wlr_xdg_toplevel_set_size(toplevel->xdg,
-		    width - 2 * toplevel->bw, height - 2 * toplevel->bw);
+        if (wl_resource_get_version(toplevel->xdg->resource) >= XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION)
+            wlr_xdg_toplevel_set_bounds(toplevel->xdg, width, height);
+        toplevel->resizing =
+            wlr_xdg_toplevel_set_size(toplevel->xdg, width - 2 * toplevel->bw, height - 2 * toplevel->bw);
     }
 #ifdef XWAYLAND
     else if (toplevel->type == TOPLEVEL_X11) {
-		wlr_xwayland_surface_configure(toplevel->xw, toplevel->geom.x,
-		    toplevel->geom.y, width - 2 * toplevel->bw,
+        wlr_xwayland_surface_configure(toplevel->xw, toplevel->geom.x, toplevel->geom.y, width - 2 * toplevel->bw,
                                        height - 2 * toplevel->bw);
         /* manually update position */
         toplevel_set_pos(toplevel, toplevel->geom.x, toplevel->geom.y);
     }
 #endif
 
-	wlr_scene_subsurface_tree_set_clip(&toplevel->scene_surface->node,
-	    &clip);
+    wlr_scene_subsurface_tree_set_clip(&toplevel->scene_surface->node, &clip);
 }
 
-void
-toplevel_set_geom(absn_toplevel *toplevel, struct wlr_box *geom)
+void toplevel_set_geom(absn_toplevel *toplevel, struct wlr_box *geom)
 {
     toplevel_set_pos(toplevel, geom->x, geom->y);
     toplevel_set_size(toplevel, geom->width, geom->height);
 }
 
-void
-toplevel_set_floating(absn_toplevel *toplevel, bool floating)
+void toplevel_set_floating(absn_toplevel *toplevel, bool floating)
 {
     if (!toplevel || toplevel->floating == floating)
         return;
@@ -172,17 +153,14 @@ toplevel_set_floating(absn_toplevel *toplevel, bool floating)
     toplevel->floating = floating;
 
     if (floating)
-		wlr_scene_node_reparent(&toplevel->scene_tree->node,
-		    toplevel->server->layers[LAYER_FLOAT]);
+        wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_FLOAT]);
     else
-		wlr_scene_node_reparent(&toplevel->scene_tree->node,
-		    toplevel->server->layers[LAYER_TILE]);
+        wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_TILE]);
 
     layout_arrange(toplevel->output);
 }
 
-void
-toplevel_set_fullscreen(absn_toplevel *toplevel, bool fullscreen)
+void toplevel_set_fullscreen(absn_toplevel *toplevel, bool fullscreen)
 {
     if (!toplevel || toplevel->fullscreen == fullscreen)
         return;
@@ -196,18 +174,14 @@ toplevel_set_fullscreen(absn_toplevel *toplevel, bool fullscreen)
         toplevel->bw = 0;
         toplevel_set_geom(toplevel, &output->geom);
 
-		wlr_scene_node_reparent(&toplevel->scene_tree->node,
-		    toplevel->server->layers[LAYER_FULLSCREEN]);
+        wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_FULLSCREEN]);
     } else {
-		toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 :
-								 TOPLEVEL_BW;
+        toplevel->bw = toplevel_is_unmanaged(toplevel) ? 0 : TOPLEVEL_BW;
         toplevel_set_geom(toplevel, &toplevel->prev_geom);
         if (toplevel->floating)
-			wlr_scene_node_reparent(&toplevel->scene_tree->node,
-			    toplevel->server->layers[LAYER_FLOAT]);
+            wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_FLOAT]);
         else
-			wlr_scene_node_reparent(&toplevel->scene_tree->node,
-			    toplevel->server->layers[LAYER_TILE]);
+            wlr_scene_node_reparent(&toplevel->scene_tree->node, toplevel->server->layers[LAYER_TILE]);
     }
 
     toplevel_update_borders_geom(toplevel);
@@ -215,8 +189,7 @@ toplevel_set_fullscreen(absn_toplevel *toplevel, bool fullscreen)
     layout_arrange(toplevel->output);
 }
 
-void
-toplevel_set_border_color(absn_toplevel *toplevel, const float color[4])
+void toplevel_set_border_color(absn_toplevel *toplevel, const float color[4])
 {
     if (!toplevel)
         return;

src/xdg-decoration.c

@@ -2,23 +2,18 @@
 
 #include "types.h"
 
-void
-deco_request_mode(struct wl_listener *listener, void *data)
+void deco_request_mode(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    deco_request_mode);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, deco_request_mode);
     if (toplevel->xdg->base->initialized)
-		wlr_xdg_toplevel_decoration_v1_set_mode(toplevel->deco,
-		    WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
+        wlr_xdg_toplevel_decoration_v1_set_mode(toplevel->deco, WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
 }
 
-void
-deco_destroy(struct wl_listener *listener, void *data)
+void deco_destroy(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    deco_destroy);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, deco_destroy);
 
     wl_list_remove(&toplevel->deco_request_mode.link);
     wl_list_remove(&toplevel->deco_destroy.link);

src/xdg-popup.c

@@ -3,8 +3,7 @@
 
 #include "types.h"
 
-void
-xdg_popup_commit(struct wl_listener *listener, void *data)
+void xdg_popup_commit(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     absn_popup *popup = wl_container_of(listener, popup, commit);
@@ -13,8 +12,7 @@ xdg_popup_commit(struct wl_listener *listener, void *data)
         wlr_xdg_surface_schedule_configure(popup->wlr->base);
 }
 
-void
-xdg_popup_destroy(struct wl_listener *listener, void *data)
+void xdg_popup_destroy(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     absn_popup *popup = wl_container_of(listener, popup, destroy);

src/xdg-toplevel.c

@@ -5,8 +5,7 @@
 #include "types.h"
 #include "xdg-decoration.h"
 
-void
-toplevel_commit(struct wl_listener *listener, void *data)
+void toplevel_commit(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
     absn_toplevel *toplevel = wl_container_of(listener, toplevel, commit);
@@ -16,16 +15,13 @@ toplevel_commit(struct wl_listener *listener, void *data)
 
         /* forse server side decoration mode */
         if (toplevel->deco)
-			deco_request_mode(&toplevel->deco_request_mode,
-			    toplevel->deco);
+            deco_request_mode(&toplevel->deco_request_mode, toplevel->deco);
         /* let client set initial size */
-		toplevel->resizing = wlr_xdg_toplevel_set_size(toplevel->xdg, 0,
-		    0);
+        toplevel->resizing = wlr_xdg_toplevel_set_size(toplevel->xdg, 0, 0);
         return;
     }
 
-	bool resizing = toplevel->resizing &&
-	    toplevel->resizing <= toplevel->xdg->base->current.configure_serial;
+    bool resizing = toplevel->resizing && toplevel->resizing <= toplevel->xdg->base->current.configure_serial;
 
     /* remove pending resize */
     if (resizing)
@@ -37,6 +33,5 @@ toplevel_commit(struct wl_listener *listener, void *data)
         .width = toplevel->geom.width - toplevel->bw,
         .height = toplevel->geom.height - toplevel->bw,
     };
-	wlr_scene_subsurface_tree_set_clip(&toplevel->scene_surface->node,
-	    &clip);
+    wlr_scene_subsurface_tree_set_clip(&toplevel->scene_surface->node, &clip);
 }

src/xwayland.c

@@ -1,69 +1,56 @@
 #ifdef XWAYLAND
 
+#include "xwayland.h"
 #include "toplevel-handlers.h"
 #include "toplevel.h"
 #include "types.h"
-#include "xwayland.h"
 
-void
-xwayland_activate(struct wl_listener *listener, void *data)
+void xwayland_activate(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    xw_activate);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, xw_activate);
 
     if (!toplevel_is_unmanaged(toplevel))
         wlr_xwayland_surface_activate(toplevel->xw, 1);
 }
 
-void
-xwayland_associate(struct wl_listener *listener, void *data)
+void xwayland_associate(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    xw_associate);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, xw_associate);
 
     LISTEN(toplevel->map, toplevel_map, toplevel->xw->surface->events.map);
-	LISTEN(toplevel->unmap, toplevel_unmap,
-	    toplevel->xw->surface->events.unmap);
+    LISTEN(toplevel->unmap, toplevel_unmap, toplevel->xw->surface->events.unmap);
 }
 
-void
-xwayland_dissociate(struct wl_listener *listener, void *data)
+void xwayland_dissociate(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    xw_dissociate);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, xw_dissociate);
 
     wl_list_remove(&toplevel->map.link);
     wl_list_remove(&toplevel->unmap.link);
 }
 
-void
-xwayland_configure(struct wl_listener *listener, void *data)
+void xwayland_configure(struct wl_listener *listener, void *data)
 {
     UNUSED(data);
-	absn_toplevel *toplevel = wl_container_of(listener, toplevel,
-	    xw_configure);
+    absn_toplevel *toplevel = wl_container_of(listener, toplevel, xw_configure);
     struct wlr_xwayland_surface_configure_event *event = data;
 
     if (!toplevel->xw->surface || !toplevel->xw->surface->mapped) {
-		wlr_xwayland_surface_configure(toplevel->xw, event->x, event->y,
-		    event->width, event->height);
+        wlr_xwayland_surface_configure(toplevel->xw, event->x, event->y, event->width, event->height);
         return;
     }
 
     if (toplevel_is_unmanaged(toplevel)) {
-		wlr_scene_node_set_position(&toplevel->scene_tree->node,
-		    event->x, event->y);
-		wlr_xwayland_surface_configure(toplevel->xw, event->x, event->y,
-		    event->width, event->height);
+        wlr_scene_node_set_position(&toplevel->scene_tree->node, event->x, event->y);
+        wlr_xwayland_surface_configure(toplevel->xw, event->x, event->y, event->width, event->height);
         return;
     }
 }
 
-void
-xwayland_set_hints(struct wl_listener *listener, void *data)
+void xwayland_set_hints(struct wl_listener *listener, void *data)
 {
     UNUSED(listener);
     UNUSED(data);