diff --git a/cagebreak.c b/cagebreak.c
index 63147f7..b5e1f9f 100644
--- a/cagebreak.c
+++ b/cagebreak.c
@@ -16,29 +16,29 @@
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <sys/wait.h>
 #include <string.h>
+#include <sys/wait.h>
 #include <unistd.h>
-#include <wayland-server-core.h>
 #include <wayland-client.h>
+#include <wayland-server-core.h>
 #include <wlr/backend.h>
-#include <wlr/types/wlr_scene.h>
 #include <wlr/render/allocator.h>
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_compositor.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_data_control_v1.h>
-#include <wlr/types/wlr_primary_selection_v1.h>
 #include <wlr/types/wlr_data_device.h>
 #include <wlr/types/wlr_export_dmabuf_v1.h>
 #include <wlr/types/wlr_gamma_control_v1.h>
 #include <wlr/types/wlr_idle.h>
-#include <wlr/types/wlr_viewporter.h>
-#include <wlr/types/wlr_presentation_time.h>
 #include <wlr/types/wlr_idle_inhibit_v1.h>
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_presentation_time.h>
+#include <wlr/types/wlr_primary_selection_v1.h>
+#include <wlr/types/wlr_scene.h>
 #include <wlr/types/wlr_screencopy_v1.h>
 #include <wlr/types/wlr_server_decoration.h>
+#include <wlr/types/wlr_viewporter.h>
 #if CG_HAS_XWAYLAND
 #include <wlr/types/wlr_xcursor_manager.h>
 #endif
@@ -226,7 +226,7 @@ get_config_file() {
 
 int
 main(int argc, char *argv[]) {
-	printf("This is cagebreak, version %s\n",CG_VERSION);
+	printf("This is cagebreak, version %s\n", CG_VERSION);
 	struct cg_server server = {0};
 	struct wl_event_loop *event_loop = NULL;
 	struct wl_event_source *sigint_source = NULL;
@@ -341,14 +341,15 @@ main(int argc, char *argv[]) {
 	}
 
 	server.renderer = wlr_renderer_autocreate(backend);
-	if (!server.renderer) {
+	if(!server.renderer) {
 		wlr_log(WLR_ERROR, "Unable to create the wlroots renderer");
 		ret = 1;
 		goto end;
 	}
 
-	server.allocator = wlr_allocator_autocreate(server.backend, server.renderer);
-	if (!server.allocator) {
+	server.allocator =
+	    wlr_allocator_autocreate(server.backend, server.renderer);
+	if(!server.allocator) {
 		wlr_log(WLR_ERROR, "Unable to create the wlroots allocator");
 		ret = 1;
 		goto end;
@@ -374,7 +375,7 @@ main(int argc, char *argv[]) {
 	}
 
 	server.scene = wlr_scene_create();
-	if (!server.scene) {
+	if(!server.scene) {
 		wlr_log(WLR_ERROR, "Unable to create scene");
 		ret = 1;
 		goto end;
@@ -468,28 +469,28 @@ main(int argc, char *argv[]) {
 	    server_decoration_manager, WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
 
 	viewporter = wlr_viewporter_create(server.wl_display);
-	if (!viewporter) {
+	if(!viewporter) {
 		wlr_log(WLR_ERROR, "Unable to create the viewporter interface");
 		ret = 1;
 		goto end;
 	}
 
 	presentation = wlr_presentation_create(server.wl_display, server.backend);
-	if (!presentation) {
+	if(!presentation) {
 		wlr_log(WLR_ERROR, "Unable to create the presentation interface");
 		ret = 1;
 		goto end;
 	}
 	wlr_scene_set_presentation(server.scene, presentation);
 
-	export_dmabuf_manager = wlr_export_dmabuf_manager_v1_create(server.wl_display);
-	if (!export_dmabuf_manager) {
+	export_dmabuf_manager =
+	    wlr_export_dmabuf_manager_v1_create(server.wl_display);
+	if(!export_dmabuf_manager) {
 		wlr_log(WLR_ERROR, "Unable to create the export DMABUF manager");
 		ret = 1;
 		goto end;
 	}
 
-
 	screencopy_manager = wlr_screencopy_manager_v1_create(server.wl_display);
 	if(!screencopy_manager) {
 		wlr_log(WLR_ERROR, "Unable to create the screencopy manager");
@@ -506,7 +507,8 @@ main(int argc, char *argv[]) {
 	}
 
 	if(!wlr_primary_selection_v1_device_manager_create(server.wl_display)) {
-		wlr_log(WLR_ERROR, "Unable to create the primary selection device manager");
+		wlr_log(WLR_ERROR,
+		        "Unable to create the primary selection device manager");
 		ret = 1;
 		goto end;
 	}
diff --git a/keybinding.c b/keybinding.c
index 0ba174c..dee4f1f 100644
--- a/keybinding.c
+++ b/keybinding.c
@@ -1,25 +1,25 @@
 #define _POSIX_C_SOURCE 200809L
 
 #include <string.h>
-#include <unistd.h>
 #include <sys/wait.h>
+#include <unistd.h>
 #include <wayland-server-core.h>
 #include <wlr/backend/multi.h>
 #include <wlr/backend/session.h>
+#include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_output_damage.h>
 #include <wlr/types/wlr_output_layout.h>
-#include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_scene.h>
 #include <wlr/util/log.h>
 
 #include "input.h"
-#include "util.h"
 #include "input_manager.h"
 #include "keybinding.h"
 #include "message.h"
 #include "output.h"
 #include "seat.h"
 #include "server.h"
+#include "util.h"
 #include "view.h"
 #include "workspace.h"
 
@@ -145,10 +145,12 @@ is_between_strict(int a, int b, int x) {
 struct cg_tile *
 find_right_tile(const struct cg_tile *tile) {
 	struct cg_tile *it = tile->next;
-	int center=tile->tile.y+tile->tile.height/2;
+	int center = tile->tile.y + tile->tile.height / 2;
 	while(it != tile) {
-		if(it->tile.x== tile->tile.x+tile->tile.width) {
-			if(is_between_strict(it->tile.y,it->tile.y+it->tile.height,center)||it->tile.y+it->tile.height==center) {
+		if(it->tile.x == tile->tile.x + tile->tile.width) {
+			if(is_between_strict(it->tile.y, it->tile.y + it->tile.height,
+			                     center) ||
+			   it->tile.y + it->tile.height == center) {
 				return it;
 			}
 		}
@@ -160,10 +162,12 @@ find_right_tile(const struct cg_tile *tile) {
 struct cg_tile *
 find_left_tile(const struct cg_tile *tile) {
 	struct cg_tile *it = tile->next;
-	int center=tile->tile.y+tile->tile.height/2;
+	int center = tile->tile.y + tile->tile.height / 2;
 	while(it != tile) {
-		if(it->tile.x+it->tile.width == tile->tile.x) {
-			if(is_between_strict(it->tile.y,it->tile.y+it->tile.height,center)||it->tile.y+it->tile.height==center) {
+		if(it->tile.x + it->tile.width == tile->tile.x) {
+			if(is_between_strict(it->tile.y, it->tile.y + it->tile.height,
+			                     center) ||
+			   it->tile.y + it->tile.height == center) {
 				return it;
 			}
 		}
@@ -175,10 +179,12 @@ find_left_tile(const struct cg_tile *tile) {
 struct cg_tile *
 find_top_tile(const struct cg_tile *tile) {
 	struct cg_tile *it = tile->next;
-	int center=tile->tile.x+tile->tile.width/2;
+	int center = tile->tile.x + tile->tile.width / 2;
 	while(it != tile) {
-		if(it->tile.y+it->tile.height == tile->tile.y) {
-			if(is_between_strict(it->tile.x,it->tile.x+it->tile.width,center)||it->tile.x+it->tile.width==center) {
+		if(it->tile.y + it->tile.height == tile->tile.y) {
+			if(is_between_strict(it->tile.x, it->tile.x + it->tile.width,
+			                     center) ||
+			   it->tile.x + it->tile.width == center) {
 				return it;
 			}
 		}
@@ -190,10 +196,12 @@ find_top_tile(const struct cg_tile *tile) {
 struct cg_tile *
 find_bottom_tile(const struct cg_tile *tile) {
 	struct cg_tile *it = tile->next;
-	int center=tile->tile.x+tile->tile.width/2;
+	int center = tile->tile.x + tile->tile.width / 2;
 	while(it != tile) {
-		if(it->tile.y == tile->tile.y+tile->tile.height) {
-			if(is_between_strict(it->tile.x,it->tile.x+it->tile.width,center)||it->tile.x+it->tile.width==center) {
+		if(it->tile.y == tile->tile.y + tile->tile.height) {
+			if(is_between_strict(it->tile.x, it->tile.x + it->tile.width,
+			                     center) ||
+			   it->tile.x + it->tile.width == center) {
 				return it;
 			}
 		}
@@ -223,11 +231,11 @@ swap_tile(struct cg_tile *tile,
 		view_maximize(swap_tile->view, swap_tile);
 	}
 	seat_set_focus(server->seat, swap_tile->view);
-	ipc_send_event(
-	    tile->workspace->output->server,
-	    "{\"event_name\":\"swap_tile\",\"tile_id\":\"%d\",\"swap_tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
-	    tile->id, swap_tile->id, tile->workspace->num + 1,
-	    tile->workspace->output->wlr_output->name);
+	ipc_send_event(tile->workspace->output->server,
+	               "{\"event_name\":\"swap_tile\",\"tile_id\":\"%d\",\"swap_"
+	               "tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
+	               tile->id, swap_tile->id, tile->workspace->num + 1,
+	               tile->workspace->output->wlr_output->name);
 }
 
 void
@@ -372,7 +380,9 @@ resize(struct cg_tile *tile, const struct cg_tile *parent, int coord_offset,
 		view_maximize(tile->view, tile);
 	}
 	ipc_send_event(tile->workspace->output->server,
-	               "{\"event_name\":\"resize_tile\",\"tile_id\":\"%d\",\"old_dims\":\"[%d;%d;%d;%d]\",\"new_dims\":\"[%d;%d;%d;%d]\",\"workspace\":\"%d\",\"output\":\"%s\"}",
+	               "{\"event_name\":\"resize_tile\",\"tile_id\":\"%d\",\"old_"
+	               "dims\":\"[%d;%d;%d;%d]\",\"new_dims\":\"[%d;%d;%d;%d]\","
+	               "\"workspace\":\"%d\",\"output\":\"%s\"}",
 	               tile->id, old_x, old_y, old_height, old_width, tile->tile.x,
 	               tile->tile.y, tile->tile.height, tile->tile.width,
 	               tile->workspace->num + 1,
@@ -470,15 +480,18 @@ keybinding_workspace_fullscreen(struct cg_server *server) {
 	struct cg_output *output = server->curr_output;
 
 	struct cg_view *it = NULL, *tmp = NULL;
-	wl_list_for_each_safe(it, tmp, &output->workspaces[output->curr_workspace]->views,
-	                 link) {
+	wl_list_for_each_safe(
+	    it, tmp, &output->workspaces[output->curr_workspace]->views, link) {
 		if(view_is_visible(it)) {
 			if(current_view == NULL) {
 				current_view = it;
 			}
-			if(&it->link!=&output->workspaces[output->curr_workspace]->views) {
+			if(&it->link !=
+			   &output->workspaces[output->curr_workspace]->views) {
 				wl_list_remove(&it->link);
-				wl_list_insert(&output->workspaces[output->curr_workspace]->views, &it->link);
+				wl_list_insert(
+				    &output->workspaces[output->curr_workspace]->views,
+				    &it->link);
 			}
 		}
 	}
@@ -500,7 +513,8 @@ keybinding_workspace_fullscreen(struct cg_server *server) {
 
 	seat_set_focus(server->seat, current_view);
 	ipc_send_event(output->server,
-	               "{\"event_name\":\"fullscreen\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
+	               "{\"event_name\":\"fullscreen\",\"tile_id\":\"%d\","
+	               "\"workspace\":\"%d\",\"output\":\"%s\"}",
 	               output->workspaces[output->curr_workspace]->focused_tile->id,
 	               output->workspaces[output->curr_workspace]->num + 1,
 	               output->wlr_output->name);
@@ -594,7 +608,8 @@ keybinding_split_output(struct cg_output *output, bool vertical) {
 	}
 	ipc_send_event(
 	    output->server,
-	    "{\"event_name\":\"split\",\"tile_id\":\"%d\",\"new_tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\",\"vertical\":\"%d\"}",
+	    "{\"event_name\":\"split\",\"tile_id\":\"%d\",\"new_tile_id\":\"%d\","
+	    "\"workspace\":\"%d\",\"output\":\"%s\",\"vertical\":\"%d\"}",
 	    curr_workspace->focused_tile->id, new_tile->id, curr_workspace->num + 1,
 	    curr_workspace->output->wlr_output->name, vertical);
 }
@@ -610,7 +625,8 @@ keybinding_close_view(struct cg_view *view) {
 	uint32_t ws = view->workspace->num;
 	view->impl->close(view);
 	ipc_send_event(outp->server,
-	               "{\"event_name\":\"close\",\"view_id\":\"%d\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
+	               "{\"event_name\":\"close\",\"view_id\":\"%d\",\"tile_id\":"
+	               "\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
 	               view_id, tile_id, ws + 1, outp->wlr_output->name);
 }
 
@@ -659,9 +675,11 @@ keybinding_cycle_outputs(struct cg_server *server, bool reverse) {
 		}
 	}
 	set_output(server, output);
-	ipc_send_event(
-	    output->server, "{\"event_name\":\"cycle_outputs\",\"old_output\":\"%s\",\"new_output\":\"%s\",\"reverse\":\"%d\"}",
-	    old_output->wlr_output->name, output->wlr_output->name, reverse);
+	ipc_send_event(output->server,
+	               "{\"event_name\":\"cycle_outputs\",\"old_output\":\"%s\","
+	               "\"new_output\":\"%s\",\"reverse\":\"%d\"}",
+	               old_output->wlr_output->name, output->wlr_output->name,
+	               reverse);
 }
 
 /* Cycle through views, whereby the workspace does not change */
@@ -704,11 +722,16 @@ keybinding_cycle_views(struct cg_server *server, bool reverse, bool ipc) {
 	    next_view->link.prev, curr_workspace->focused_tile->view, link);
 	seat_set_focus(server->seat, next_view);
 	if(ipc) {
-	ipc_send_event(curr_workspace->output->server,
-	               "{\"event_name\":\"cycle_views\",\"old_view_id\":\"%d\",\"new_view_id\":\"%d\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
-	               current_view->link.next==curr_workspace->views.next?-1:(int) current_view->id, next_view==NULL?-1:(int) next_view->id, next_view->tile->id,
-	               curr_workspace->num + 1,
-	               curr_workspace->output->wlr_output->name);
+		ipc_send_event(curr_workspace->output->server,
+		               "{\"event_name\":\"cycle_views\",\"old_view_id\":\"%d\","
+		               "\"new_view_id\":\"%d\",\"tile_id\":\"%d\","
+		               "\"workspace\":\"%d\",\"output\":\"%s\"}",
+		               current_view->link.next == curr_workspace->views.next
+		                   ? -1
+		                   : (int)current_view->id,
+		               next_view == NULL ? -1 : (int)next_view->id,
+		               next_view->tile->id, curr_workspace->num + 1,
+		               curr_workspace->output->wlr_output->name);
 	}
 }
 
@@ -727,7 +750,8 @@ keybinding_cycle_tiles(struct cg_server *server, bool reverse) {
 	seat_set_focus(server->seat, next_view);
 	ipc_send_event(
 	    output->server,
-	    "{\"event_name\":\"cycle_tiles\",\"old_tile_id\":\"%d\",\"new_tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
+	    "{\"event_name\":\"cycle_tiles\",\"old_tile_id\":\"%d\",\"new_tile_"
+	    "id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\"}",
 	    old_tile->id, workspace->focused_tile->id, workspace->num + 1,
 	    output->wlr_output->name);
 }
@@ -742,12 +766,13 @@ keybinding_switch_ws(struct cg_server *server, uint32_t ws) {
 	}
 	struct cg_output *output = server->curr_output;
 	uint32_t old_ws = server->curr_output->curr_workspace;
-	workspace_focus(output,ws);
+	workspace_focus(output, ws);
 	seat_set_focus(server->seat,
 	               server->curr_output->workspaces[ws]->focused_tile->view);
 	message_printf(server->curr_output, "Workspace %d", ws + 1);
 	ipc_send_event(output->server,
-	               "{\"event_name\":\"switch_ws\",\"old_workspace\":\"%d\",\"new_workspace\":\"%d\",\"output\":\"%s\"}",
+	               "{\"event_name\":\"switch_ws\",\"old_workspace\":\"%d\","
+	               "\"new_workspace\":\"%d\",\"output\":\"%s\"}",
 	               old_ws + 1, ws + 1, output->wlr_output->name);
 	return 0;
 }
@@ -772,17 +797,19 @@ struct dyn_str {
 	char **str_arr;
 };
 
-/*Note that inp is in an invalid state after calling the function * and should no longer be used.*/
-char *dyn_str_to_str(struct dyn_str *inp) {
-	char *outp=calloc(inp->len+1,sizeof(char));
+/*Note that inp is in an invalid state after calling the function * and should
+ * no longer be used.*/
+char *
+dyn_str_to_str(struct dyn_str *inp) {
+	char *outp = calloc(inp->len + 1, sizeof(char));
 	if(outp == NULL) {
 		return NULL;
 	}
-	outp[inp->len]='\0';
-	uint32_t tmp_pos=0;
-	for(uint32_t i=0;i<inp->cur_pos;++i) {
-		strcat(outp+tmp_pos,inp->str_arr[i]);
-		tmp_pos+=strlen(inp->str_arr[i]);
+	outp[inp->len] = '\0';
+	uint32_t tmp_pos = 0;
+	for(uint32_t i = 0; i < inp->cur_pos; ++i) {
+		strcat(outp + tmp_pos, inp->str_arr[i]);
+		tmp_pos += strlen(inp->str_arr[i]);
 		free(inp->str_arr[i]);
 	}
 	free(inp->str_arr);
@@ -797,89 +824,98 @@ print_str(struct dyn_str *outp, const char *fmt, ...) {
 	if(ret == NULL) {
 		return -1;
 	}
-	outp->str_arr[outp->cur_pos]=ret;
+	outp->str_arr[outp->cur_pos] = ret;
 	++outp->cur_pos;
-	outp->len+=strlen(ret);
+	outp->len += strlen(ret);
 	return 0;
 }
 
 void
-print_modes(struct dyn_str *str,char **modes) {
-	uint32_t len=0;
-	char **tmp=modes;
-	uint32_t nmemb=0;
-	while(*tmp!=NULL) {
-		len+=strlen(*tmp);
+print_modes(struct dyn_str *str, char **modes) {
+	uint32_t len = 0;
+	char **tmp = modes;
+	uint32_t nmemb = 0;
+	while(*tmp != NULL) {
+		len += strlen(*tmp);
 		++nmemb;
 		++tmp;
 	}
-	/* We are assuming here that we have at least one mode, which is given by the initialization of cagebreak */
-	char *modes_str=calloc(len+3*(nmemb-1)+1, sizeof(char));
-	modes_str[len+nmemb-1]='\0';
-	uint32_t tmp_pos=0;
-	for(uint32_t i=0;i<nmemb;++i) {
-		if(i!=0) {
-			strcat(modes_str+tmp_pos,"\",\"");
-			tmp_pos+=3;
+	/* We are assuming here that we have at least one mode, which is given by
+	 * the initialization of cagebreak */
+	char *modes_str = calloc(len + 3 * (nmemb - 1) + 1, sizeof(char));
+	modes_str[len + nmemb - 1] = '\0';
+	uint32_t tmp_pos = 0;
+	for(uint32_t i = 0; i < nmemb; ++i) {
+		if(i != 0) {
+			strcat(modes_str + tmp_pos, "\",\"");
+			tmp_pos += 3;
 		}
-		strcat(modes_str+tmp_pos,modes[i]);
-		tmp_pos+=strlen(modes[i]);
+		strcat(modes_str + tmp_pos, modes[i]);
+		tmp_pos += strlen(modes[i]);
 	}
-	print_str(str,"\"modes\":[\"%s\"],\n",modes_str);
+	print_str(str, "\"modes\":[\"%s\"],\n", modes_str);
 	free(modes_str);
 }
 
-char *print_view(struct cg_view *view) {
+char *
+print_view(struct cg_view *view) {
 	struct dyn_str outp_str;
-	outp_str.len=0;
-	outp_str.cur_pos=0;
-	uint32_t nmemb=4;
-	outp_str.str_arr=calloc(nmemb,sizeof(char *));
-	print_str(&outp_str,"\"id\": %d,\n",view->id);
-	char *title_str=view->impl->get_title(view);
-	print_str(&outp_str,"\"title\": \"%s\",\n",title_str==NULL?"":title_str);
-	print_str(&outp_str,"\"coords\": [\"x\":%d,\"y\":%d],\n",view->ox,view->oy);
+	outp_str.len = 0;
+	outp_str.cur_pos = 0;
+	uint32_t nmemb = 4;
+	outp_str.str_arr = calloc(nmemb, sizeof(char *));
+	print_str(&outp_str, "\"id\": %d,\n", view->id);
+	char *title_str = view->impl->get_title(view);
+	print_str(&outp_str, "\"title\": \"%s\",\n",
+	          title_str == NULL ? "" : title_str);
+	print_str(&outp_str, "\"coords\": [\"x\":%d,\"y\":%d],\n", view->ox,
+	          view->oy);
 #if CG_HAS_XWAYLAND
-	print_str(&outp_str,"\"type\": \"%s\",\n",view->type==CG_XWAYLAND_VIEW?"xwayland":"xdg");
+	print_str(&outp_str, "\"type\": \"%s\",\n",
+	          view->type == CG_XWAYLAND_VIEW ? "xwayland" : "xdg");
 #else
-	print_str(&outp_str,"\"type\": \"xdg\",\n");
+	print_str(&outp_str, "\"type\": \"xdg\",\n");
 #endif
 	return dyn_str_to_str(&outp_str);
 }
 
-char *print_tile(struct cg_tile *tile) {
+char *
+print_tile(struct cg_tile *tile) {
 	struct dyn_str outp_str;
-	outp_str.len=0;
-	outp_str.cur_pos=0;
-	uint32_t nmemb=4;
-	outp_str.str_arr=calloc(nmemb,sizeof(char *));
-	print_str(&outp_str,"\"id\": %d,\n",tile->id);
-	print_str(&outp_str,"\"coords\": [\"x\":%d,\"y\":%d],\n",tile->tile.x,tile->tile.y);
-	print_str(&outp_str,"\"size\": [\"width\":%d,\"height\":%d],\n",tile->tile.width,tile->tile.height);
-	print_str(&outp_str,"\"view\": \"%d\",\n",tile->view==NULL?-1:(int)tile->view->id);
+	outp_str.len = 0;
+	outp_str.cur_pos = 0;
+	uint32_t nmemb = 4;
+	outp_str.str_arr = calloc(nmemb, sizeof(char *));
+	print_str(&outp_str, "\"id\": %d,\n", tile->id);
+	print_str(&outp_str, "\"coords\": [\"x\":%d,\"y\":%d],\n", tile->tile.x,
+	          tile->tile.y);
+	print_str(&outp_str, "\"size\": [\"width\":%d,\"height\":%d],\n",
+	          tile->tile.width, tile->tile.height);
+	print_str(&outp_str, "\"view\": \"%d\",\n",
+	          tile->view == NULL ? -1 : (int)tile->view->id);
 	return dyn_str_to_str(&outp_str);
 }
 
 char *
 print_views(struct cg_workspace *ws) {
 	struct dyn_str outp_str;
-	outp_str.len=0;
-	outp_str.cur_pos=0;
-	uint32_t nviews=wl_list_length(&ws->views);
-	if(nviews==0) {
+	outp_str.len = 0;
+	outp_str.cur_pos = 0;
+	uint32_t nviews = wl_list_length(&ws->views);
+	if(nviews == 0) {
 		return strdup("{}");
 	}
-	outp_str.str_arr=calloc(2*nviews-1,sizeof(char *));
+	outp_str.str_arr = calloc(2 * nviews - 1, sizeof(char *));
 	struct cg_view *it;
-	uint32_t count=0;
-	wl_list_for_each(it,&ws->views,link) {
-		if(count!=0) {
-			print_str(&outp_str,",");
+	uint32_t count = 0;
+	wl_list_for_each(it, &ws->views, link) {
+		if(count != 0) {
+			print_str(&outp_str, ",");
 		}
 		++count;
-		char *view_str=print_view(it);
-		if(view_str!=NULL) {
-			print_str(&outp_str,"{\n%s\n}",view_str);
+		char *view_str = print_view(it);
+		if(view_str != NULL) {
+			print_str(&outp_str, "{\n%s\n}", view_str);
 			free(view_str);
 		}
 	}
@@ -889,27 +925,29 @@ print_views(struct cg_workspace *ws) {
 char *
 print_tiles(struct cg_workspace *ws) {
 	struct dyn_str outp_str;
-	outp_str.len=0;
-	outp_str.cur_pos=0;
-	uint32_t ntiles=0;
-	bool first=true;
-	for(struct cg_tile *tile=ws->focused_tile;first||tile!=ws->focused_tile;tile=tile->next) {
-		first=false;
+	outp_str.len = 0;
+	outp_str.cur_pos = 0;
+	uint32_t ntiles = 0;
+	bool first = true;
+	for(struct cg_tile *tile = ws->focused_tile;
+	    first || tile != ws->focused_tile; tile = tile->next) {
+		first = false;
 		++ntiles;
 	}
-	if(ntiles==0) {
+	if(ntiles == 0) {
 		return strdup("{}");
 	}
-	outp_str.str_arr=calloc(2*ntiles-1,sizeof(char *));
-	first=true;
-	for(struct cg_tile *tile=ws->focused_tile;first||tile!=ws->focused_tile;tile=tile->next) {
-		if(first==false) {
-			print_str(&outp_str,",");
+	outp_str.str_arr = calloc(2 * ntiles - 1, sizeof(char *));
+	first = true;
+	for(struct cg_tile *tile = ws->focused_tile;
+	    first || tile != ws->focused_tile; tile = tile->next) {
+		if(first == false) {
+			print_str(&outp_str, ",");
 		}
-		first=false;
-		char *tile_str=print_tile(tile);
-		if(tile_str!=NULL) {
-			print_str(&outp_str,"{\n%s\n}",tile_str);
+		first = false;
+		char *tile_str = print_tile(tile);
+		if(tile_str != NULL) {
+			print_str(&outp_str, "{\n%s\n}", tile_str);
 			free(tile_str);
 		}
 	}
@@ -919,41 +957,41 @@ print_tiles(struct cg_workspace *ws) {
 char *
 print_workspace(struct cg_workspace *ws) {
 	struct dyn_str outp_str;
-	outp_str.len=0;
-	outp_str.cur_pos=0;
-	uint32_t nmemb=6;
-	outp_str.str_arr=calloc(nmemb,sizeof(char *));
-	print_str(&outp_str,"\"views\": [");
-	char *views_str=print_views(ws);
-	if(views_str!=NULL) {
-		print_str(&outp_str,"%s",views_str);
+	outp_str.len = 0;
+	outp_str.cur_pos = 0;
+	uint32_t nmemb = 6;
+	outp_str.str_arr = calloc(nmemb, sizeof(char *));
+	print_str(&outp_str, "\"views\": [");
+	char *views_str = print_views(ws);
+	if(views_str != NULL) {
+		print_str(&outp_str, "%s", views_str);
 		free(views_str);
 	}
-	print_str(&outp_str,"],");
-	print_str(&outp_str,"\"tiles\": [");
-	char *tiles_str=print_tiles(ws);
-	if(tiles_str!=NULL) {
-		print_str(&outp_str,"%s",tiles_str);
+	print_str(&outp_str, "],");
+	print_str(&outp_str, "\"tiles\": [");
+	char *tiles_str = print_tiles(ws);
+	if(tiles_str != NULL) {
+		print_str(&outp_str, "%s", tiles_str);
 		free(tiles_str);
 	}
-	print_str(&outp_str,"]");
+	print_str(&outp_str, "]");
 	return dyn_str_to_str(&outp_str);
 }
 
 char *
 print_workspaces(struct cg_output *outp) {
 	struct dyn_str outp_str;
-	outp_str.len=0;
-	outp_str.cur_pos=0;
-	outp_str.str_arr=calloc((2*outp->server->nws-1)+2,sizeof(char *));
+	outp_str.len = 0;
+	outp_str.cur_pos = 0;
+	outp_str.str_arr = calloc((2 * outp->server->nws - 1) + 2, sizeof(char *));
 	print_str(&outp_str, "\"workspaces\": [");
-	for(int i=0;i<outp->server->nws;++i) {
-		if(i!=0) {
-			print_str(&outp_str,",");
+	for(int i = 0; i < outp->server->nws; ++i) {
+		if(i != 0) {
+			print_str(&outp_str, ",");
 		}
-		char *ws=print_workspace(outp->workspaces[i]);
+		char *ws = print_workspace(outp->workspaces[i]);
 		if(ws != NULL) {
-			print_str(&outp_str,"{%s}",ws);
+			print_str(&outp_str, "{%s}", ws);
 			free(ws);
 		}
 	}
@@ -964,42 +1002,42 @@ print_workspaces(struct cg_output *outp) {
 char *
 print_output(struct cg_output *outp) {
 	struct dyn_str outp_str;
-	outp_str.len=0;
-	outp_str.cur_pos=0;
-	uint32_t nmemb=5;
-	outp_str.str_arr=calloc(nmemb,sizeof(char *));
-	print_str(&outp_str,"\"%s\": {\n",outp->wlr_output->name);
-	print_str(&outp_str,"\"priority\": %d,\n",outp->priority);
-	print_str(&outp_str,"\"curr_workspace\": %d,\n",outp->curr_workspace);
-	char *workspaces_str=print_workspaces(outp);
-	if(workspaces_str!=NULL) {
-		print_str(&outp_str, "%s",workspaces_str);
+	outp_str.len = 0;
+	outp_str.cur_pos = 0;
+	uint32_t nmemb = 5;
+	outp_str.str_arr = calloc(nmemb, sizeof(char *));
+	print_str(&outp_str, "\"%s\": {\n", outp->wlr_output->name);
+	print_str(&outp_str, "\"priority\": %d,\n", outp->priority);
+	print_str(&outp_str, "\"curr_workspace\": %d,\n", outp->curr_workspace);
+	char *workspaces_str = print_workspaces(outp);
+	if(workspaces_str != NULL) {
+		print_str(&outp_str, "%s", workspaces_str);
 		free(workspaces_str);
 	}
-	print_str(&outp_str,"}");
+	print_str(&outp_str, "}");
 	return dyn_str_to_str(&outp_str);
 }
 
 char *
 print_outputs(struct cg_server *server) {
-	uint32_t noutps=wl_list_length(&server->outputs);
+	uint32_t noutps = wl_list_length(&server->outputs);
 	struct dyn_str outp_str;
-	outp_str.len=0;
-	outp_str.cur_pos=0;
-	outp_str.str_arr=calloc((2*noutps-1)+2,sizeof(char *));
+	outp_str.len = 0;
+	outp_str.cur_pos = 0;
+	outp_str.str_arr = calloc((2 * noutps - 1) + 2, sizeof(char *));
 	print_str(&outp_str, "\"outputs\": [");
 	struct cg_output *it;
-	uint32_t count=0;
-	wl_list_for_each(it,&server->outputs,link) {
-		if(count!=0) {
-			print_str(&outp_str,",");
+	uint32_t count = 0;
+	wl_list_for_each(it, &server->outputs, link) {
+		if(count != 0) {
+			print_str(&outp_str, ",");
 		}
 		++count;
-		char *outp=print_output(it);
+		char *outp = print_output(it);
 		if(outp == NULL) {
 			continue;
 		}
-		print_str(&outp_str,"%s",outp);
+		print_str(&outp_str, "%s", outp);
 		free(outp);
 	}
 	print_str(&outp_str, "],\n");
@@ -1009,26 +1047,29 @@ print_outputs(struct cg_server *server) {
 void
 keybinding_dump(struct cg_server *server) {
 	struct dyn_str str;
-	str.len=0;
-	str.cur_pos=0;
-	uint32_t nmemb=10;
-	str.str_arr=calloc(nmemb,sizeof(char *));
+	str.len = 0;
+	str.cur_pos = 0;
+	uint32_t nmemb = 10;
+	str.str_arr = calloc(nmemb, sizeof(char *));
 
-	print_str(&str,"{");
-	print_str(&str,"\"nws\":%d,\n",server->nws);
-	print_str(&str,"\"bg_color\":[%f,%f,%f,%f],\n",server->bg_color[0],server->bg_color[1],server->bg_color[2],server->bg_color[3]);
-	print_str(&str,"\"views_curr_id\":%d,\n",server->views_curr_id);
-	print_str(&str,"\"tiles_curr_id\":%d,\n",server->tiles_curr_id);
-	print_str(&str,"\"curr_output\":%s,\n",server->curr_output->wlr_output->name);
-	print_modes(&str,server->modes);
-	char *outps_str=print_outputs(server);
-	print_str(&str,"%s",outps_str);
+	print_str(&str, "{");
+	print_str(&str, "\"nws\":%d,\n", server->nws);
+	print_str(&str, "\"bg_color\":[%f,%f,%f,%f],\n", server->bg_color[0],
+	          server->bg_color[1], server->bg_color[2], server->bg_color[3]);
+	print_str(&str, "\"views_curr_id\":%d,\n", server->views_curr_id);
+	print_str(&str, "\"tiles_curr_id\":%d,\n", server->tiles_curr_id);
+	print_str(&str, "\"curr_output\":%s,\n",
+	          server->curr_output->wlr_output->name);
+	print_modes(&str, server->modes);
+	char *outps_str = print_outputs(server);
+	print_str(&str, "%s", outps_str);
 	free(outps_str);
-	print_str(&str,"\"cursor_coords\":{\"x\":%f,\"y\":%f},\n",server->seat->cursor->x,server->seat->cursor->y);
-	print_str(&str,"}");
+	print_str(&str, "\"cursor_coords\":{\"x\":%f,\"y\":%f},\n",
+	          server->seat->cursor->x, server->seat->cursor->y);
+	print_str(&str, "}");
 
-	char *send_str=dyn_str_to_str(&str);
-	if(send_str==NULL) {
+	char *send_str = dyn_str_to_str(&str);
+	if(send_str == NULL) {
 		wlr_log(WLR_ERROR, "Unable to create output string for \"dump\".");
 	}
 	ipc_send_event(server, send_str);
@@ -1065,7 +1106,7 @@ keybinding_move_view_to_cycle_output(struct cg_server *server, bool reverse) {
 		wl_list_remove(&view->link);
 		server->curr_output->workspaces[server->curr_output->curr_workspace]
 		    ->focused_tile->view = NULL;
-		keybinding_cycle_views(server, false,false);
+		keybinding_cycle_views(server, false, false);
 		if(server->curr_output->workspaces[server->curr_output->curr_workspace]
 		       ->focused_tile->view == NULL) {
 			seat_set_focus(server->seat, NULL);
@@ -1073,7 +1114,9 @@ keybinding_move_view_to_cycle_output(struct cg_server *server, bool reverse) {
 	}
 	keybinding_cycle_outputs(server, reverse);
 	if(view != NULL) {
-		struct cg_workspace *ws=server->curr_output->workspaces[server->curr_output->curr_workspace];
+		struct cg_workspace *ws =
+		    server->curr_output
+		        ->workspaces[server->curr_output->curr_workspace];
 		wl_list_insert(&ws->views, &view->link);
 		ws->focused_tile->view = view;
 		wlr_scene_node_reparent(view->scene_node, &ws->scene->node);
@@ -1082,11 +1125,11 @@ keybinding_move_view_to_cycle_output(struct cg_server *server, bool reverse) {
 		view_maximize(view, view->tile);
 		seat_set_focus(server->seat, view);
 	}
-	ipc_send_event(
-	    server,
-	    "{\"event_name\":\"move_view_cycle_output\",\"view_id\":\"%d\",\"old_output\":\"%s\",\"new_output\":\"%s\"}",
-	    view->id, old_outp->wlr_output->name,
-	    server->curr_output->wlr_output->name);
+	ipc_send_event(server,
+	               "{\"event_name\":\"move_view_cycle_output\",\"view_id\":\"%"
+	               "d\",\"old_output\":\"%s\",\"new_output\":\"%s\"}",
+	               view->id, old_outp->wlr_output->name,
+	               server->curr_output->wlr_output->name);
 }
 
 void
@@ -1132,7 +1175,7 @@ keybinding_set_nws(struct cg_server *server, int nws) {
 		}
 
 		if(output->curr_workspace >= nws) {
-			workspace_focus(output,nws-1);
+			workspace_focus(output, nws - 1);
 		}
 	}
 	server->nws = nws;
@@ -1140,8 +1183,10 @@ keybinding_set_nws(struct cg_server *server, int nws) {
 	    server->seat,
 	    server->curr_output->workspaces[server->curr_output->curr_workspace]
 	        ->focused_tile->view);
-	ipc_send_event(server, "{\"event_name\":\"set_nws\",\"old_nws\":\"%d\",\"new_nws\":\"%d\"}", old_nws,
-	               server->nws);
+	ipc_send_event(
+	    server,
+	    "{\"event_name\":\"set_nws\",\"old_nws\":\"%d\",\"new_nws\":\"%d\"}",
+	    old_nws, server->nws);
 }
 
 void
@@ -1158,29 +1203,34 @@ keybinding_definemode(struct cg_server *server, char *mode) {
 	server->modes[length] = NULL;
 
 	server->modes[length - 1] = strdup(mode);
-	ipc_send_event(server, "{\"event_name\":\"definemode\",\"mode\":\"%s\"}", mode);
+	ipc_send_event(server, "{\"event_name\":\"definemode\",\"mode\":\"%s\"}",
+	               mode);
 }
 
 void
 keybinding_definekey(struct cg_server *server, struct keybinding *kb) {
 	keybinding_list_push(server->keybindings, kb);
-	ipc_send_event(server, "{\"event_name\":\"definekey\",\"modifiers\":\"%d\",\"key\":\"%d\",\"command\":\"%d\"}",
+	ipc_send_event(server,
+	               "{\"event_name\":\"definekey\",\"modifiers\":\"%d\",\"key\":"
+	               "\"%d\",\"command\":\"%d\"}",
 	               kb->modifiers, kb->key, kb->action);
 }
 
 void
 keybinding_set_background(struct cg_server *server, float *bg) {
-	ipc_send_event(server, "{\"event_name\":\"background\",\"old_bg\":\"[%f,%f,%f]\",\"new_bg\":\"[%f,%f,%f]\"}",
+	ipc_send_event(server,
+	               "{\"event_name\":\"background\",\"old_bg\":\"[%f,%f,%f]\","
+	               "\"new_bg\":\"[%f,%f,%f]\"}",
 	               server->bg_color[0], server->bg_color[1],
 	               server->bg_color[2], bg[0], bg[1], bg[2]);
 	server->bg_color[0] = bg[0];
 	server->bg_color[1] = bg[1];
 	server->bg_color[2] = bg[2];
-	struct cg_output *it=NULL;
-	wl_list_for_each(it,&server->outputs,link) {
+	struct cg_output *it = NULL;
+	wl_list_for_each(it, &server->outputs, link) {
 		wlr_scene_rect_set_color(it->bg, server->bg_color);
 	}
-	wl_list_for_each(it,&server->disabled_outputs,link) {
+	wl_list_for_each(it, &server->disabled_outputs, link) {
 		wlr_scene_rect_set_color(it->bg, server->bg_color);
 	}
 }
@@ -1193,7 +1243,9 @@ keybinding_switch_output(struct cg_server *server, int output) {
 	wl_list_for_each(it, &server->outputs, link) {
 		if(count == output) {
 			set_output(server, it);
-			ipc_send_event(server, "{\"event_name\":\"switch_output\",\"old_output\":\"%s\",\"new_output\":\"%s\"}",
+			ipc_send_event(server,
+			               "{\"event_name\":\"switch_output\",\"old_output\":"
+			               "\"%s\",\"new_output\":\"%s\"}",
 			               old_outp->wlr_output->name, it->wlr_output->name);
 			return;
 		}
@@ -1213,7 +1265,7 @@ keybinding_move_view_to_output(struct cg_server *server, int output_num) {
 		wl_list_remove(&view->link);
 		server->curr_output->workspaces[server->curr_output->curr_workspace]
 		    ->focused_tile->view = NULL;
-		keybinding_cycle_views(server, false,false);
+		keybinding_cycle_views(server, false, false);
 		if(server->curr_output->workspaces[server->curr_output->curr_workspace]
 		       ->focused_tile->view == NULL) {
 			seat_set_focus(server->seat, NULL);
@@ -1237,10 +1289,12 @@ keybinding_move_view_to_output(struct cg_server *server, int output_num) {
 		view_title = view->impl->get_title(view);
 		view_id = view->id;
 	}
-	ipc_send_event(server,
-	               "{\"event_name\":\"move_view_to_output\",\"view_id\":\"%d\",\"old_output\":\"%s\",\"new_output\":\"%s\",\"view_title\":\"%s\"}",
-	               view_id, old_outp->wlr_output->name,
-	               server->curr_output->wlr_output->name, view_title);
+	ipc_send_event(
+	    server,
+	    "{\"event_name\":\"move_view_to_output\",\"view_id\":\"%d\",\"old_"
+	    "output\":\"%s\",\"new_output\":\"%s\",\"view_title\":\"%s\"}",
+	    view_id, old_outp->wlr_output->name,
+	    server->curr_output->wlr_output->name, view_title);
 }
 
 void
@@ -1272,10 +1326,12 @@ keybinding_move_view_to_workspace(struct cg_server *server, uint32_t ws) {
 		seat_set_focus(server->seat, view);
 	}
 	ipc_send_event(server,
-	               "{\"event_name\":\"move_view_to_ws\",\"view_id\":\"%d\",\"old_workspace\":\"%d\",\"new_workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
-	               view==NULL?-1:(int)view->id, old_ws, ws,
+	               "{\"event_name\":\"move_view_to_ws\",\"view_id\":\"%d\","
+	               "\"old_workspace\":\"%d\",\"new_workspace\":\"%d\","
+	               "\"output\":\"%s\",\"view_title\":\"%s\"}",
+	               view == NULL ? -1 : (int)view->id, old_ws, ws,
 	               server->curr_output->wlr_output->name,
-	               view==NULL?"":view->impl->get_title(view));
+	               view == NULL ? "" : view->impl->get_title(view));
 }
 
 void
@@ -1324,16 +1380,20 @@ keybinding_configure_output(struct cg_server *server,
 	wl_list_for_each_safe(output, tmp_output, &server->outputs, link) {
 		if(strcmp(config->output_name, output->wlr_output->name) == 0) {
 			output_configure(server, output);
-			ipc_send_event(output->server, "{\"event_name\":\"configure_output\",\"output\":\"%s\"}",
-			               cfg->output_name);
+			ipc_send_event(
+			    output->server,
+			    "{\"event_name\":\"configure_output\",\"output\":\"%s\"}",
+			    cfg->output_name);
 			return;
 		}
 	}
 	wl_list_for_each_safe(output, tmp_output, &server->disabled_outputs, link) {
 		if(strcmp(config->output_name, output->wlr_output->name) == 0) {
 			output_configure(server, output);
-			ipc_send_event(output->server, "{\"event_name\":\"configure_output\",\"output\":\"%s\"}",
-			               cfg->output_name);
+			ipc_send_event(
+			    output->server,
+			    "{\"event_name\":\"configure_output\",\"output\":\"%s\"}",
+			    cfg->output_name);
 			return;
 		}
 	}
@@ -1343,7 +1403,9 @@ void
 keybinding_configure_input(struct cg_server *server,
                            struct cg_input_config *cfg) {
 	cg_input_apply_config(cfg, server);
-	ipc_send_event(server, "{\"event_name\":\"configure_input\",\"input\":\"%s\"}", cfg->identifier);
+	ipc_send_event(server,
+	               "{\"event_name\":\"configure_input\",\"input\":\"%s\"}",
+	               cfg->identifier);
 }
 
 void
@@ -1394,21 +1456,19 @@ run_action(enum keybinding_action action, struct cg_server *server,
 	case KEYBINDING_SPLIT_VERTICAL:
 		keybinding_split_vertical(server);
 		break;
-	case KEYBINDING_RUN_COMMAND:
-		{
-			int pid;
-			if((pid=fork()) == 0) {
-				if(fork() == 0) {
-					into_process(data.c);
-				}
-				_exit(0);
-			} else if(pid > 0) {
-				waitpid(pid,NULL,0);
+	case KEYBINDING_RUN_COMMAND: {
+		int pid;
+		if((pid = fork()) == 0) {
+			if(fork() == 0) {
+				into_process(data.c);
 			}
+			_exit(0);
+		} else if(pid > 0) {
+			waitpid(pid, NULL, 0);
 		}
-		break;
+	} break;
 	case KEYBINDING_CYCLE_VIEWS:
-		keybinding_cycle_views(server, data.b,true);
+		keybinding_cycle_views(server, data.b, true);
 		break;
 	case KEYBINDING_CYCLE_TILES:
 		keybinding_cycle_tiles(server, data.b);
@@ -1426,7 +1486,9 @@ run_action(enum keybinding_action action, struct cg_server *server,
 		server->seat->mode = data.u;
 		break;
 	case KEYBINDING_SWITCH_DEFAULT_MODE:
-		ipc_send_event(server, "{\"event_name\":\"switch_default_mode\",\"old_mode\":\"%d\",\"mode\":\"%d\"}",
+		ipc_send_event(server,
+		               "{\"event_name\":\"switch_default_mode\",\"old_mode\":"
+		               "\"%d\",\"mode\":\"%d\"}",
 		               server->seat->default_mode, data.u);
 		server->seat->mode = data.u;
 		server->seat->default_mode = data.u;
@@ -1443,7 +1505,7 @@ run_action(enum keybinding_action action, struct cg_server *server,
 		keybinding_show_info(server);
 		break;
 	case KEYBINDING_DISPLAY_MESSAGE:
-		keybinding_display_message(server,data.c);
+		keybinding_display_message(server, data.c);
 		break;
 	case KEYBINDING_RESIZE_TILE_HORIZONTAL:
 		resize_tile(server, data.i, 0);
diff --git a/message.c b/message.c
index 8e8e0d1..435ded1 100644
--- a/message.c
+++ b/message.c
@@ -1,17 +1,17 @@
 #include <cairo/cairo.h>
 #include <drm_fourcc.h>
 #include <pango/pangocairo.h>
+#include <sys/mman.h>
 #include <unistd.h>
 #include <wayland-client.h>
 #include <wlr/backend.h>
+#include <wlr/render/allocator.h>
+#include <wlr/render/drm_format_set.h>
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_output_damage.h>
 #include <wlr/types/wlr_output_layout.h>
-#include <wlr/util/log.h>
-#include <sys/mman.h>
-#include <wlr/render/allocator.h>
 #include <wlr/types/wlr_scene.h>
-#include <wlr/render/drm_format_set.h>
+#include <wlr/util/log.h>
 
 #include "message.h"
 #include "output.h"
@@ -26,14 +26,17 @@ struct msg_buffer {
 	size_t stride;
 };
 
-static void msg_buffer_destroy(struct wlr_buffer *wlr_buffer) {
+static void
+msg_buffer_destroy(struct wlr_buffer *wlr_buffer) {
 	struct msg_buffer *buffer = wl_container_of(wlr_buffer, buffer, base);
 	free(buffer->data);
 	free(buffer);
 }
 
-static bool msg_buffer_begin_data_ptr_access(struct wlr_buffer *wlr_buffer,
-		uint32_t flags, void **data, uint32_t *format, size_t *stride) {
+static bool
+msg_buffer_begin_data_ptr_access(struct wlr_buffer *wlr_buffer, uint32_t flags,
+                                 void **data, uint32_t *format,
+                                 size_t *stride) {
 	struct msg_buffer *buffer = wl_container_of(wlr_buffer, buffer, base);
 	if(data != NULL) {
 		*data = (void *)buffer->data;
@@ -47,19 +50,21 @@ static bool msg_buffer_begin_data_ptr_access(struct wlr_buffer *wlr_buffer,
 	return true;
 }
 
-static void msg_buffer_end_data_ptr_access(struct wlr_buffer *wlr_buffer) {
+static void
+msg_buffer_end_data_ptr_access(struct wlr_buffer *wlr_buffer) {
 	// This space is intentionally left blank
 }
 
 static const struct wlr_buffer_impl msg_buffer_impl = {
-	.destroy = msg_buffer_destroy,
-	.begin_data_ptr_access = msg_buffer_begin_data_ptr_access,
-	.end_data_ptr_access = msg_buffer_end_data_ptr_access,
+    .destroy = msg_buffer_destroy,
+    .begin_data_ptr_access = msg_buffer_begin_data_ptr_access,
+    .end_data_ptr_access = msg_buffer_end_data_ptr_access,
 };
 
-static struct msg_buffer *msg_buffer_create(uint32_t width, uint32_t height, uint32_t stride) {
+static struct msg_buffer *
+msg_buffer_create(uint32_t width, uint32_t height, uint32_t stride) {
 	struct msg_buffer *buffer = calloc(1, sizeof(*buffer));
-	if (buffer == NULL) {
+	if(buffer == NULL) {
 		return NULL;
 	}
 
@@ -68,7 +73,7 @@ static struct msg_buffer *msg_buffer_create(uint32_t width, uint32_t height, uin
 	buffer->stride = stride;
 
 	buffer->data = malloc(buffer->stride * height);
-	if (buffer->data == NULL) {
+	if(buffer->data == NULL) {
 		free(buffer);
 		return NULL;
 	}
@@ -150,14 +155,16 @@ create_message_texture(const char *string, const struct cg_output *output) {
 	unsigned char *data = cairo_image_surface_get_data(surface);
 	int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);
 
-	struct msg_buffer *buf=msg_buffer_create(width, height,stride);
+	struct msg_buffer *buf = msg_buffer_create(width, height, stride);
 	void *data_ptr;
 
-	if(!wlr_buffer_begin_data_ptr_access(&buf->base, WLR_BUFFER_DATA_PTR_ACCESS_WRITE,&data_ptr,NULL,NULL)) {
+	if(!wlr_buffer_begin_data_ptr_access(&buf->base,
+	                                     WLR_BUFFER_DATA_PTR_ACCESS_WRITE,
+	                                     &data_ptr, NULL, NULL)) {
 		wlr_log(WLR_ERROR, "Failed to get pointer access to message buffer");
 		return NULL;
 	}
-	memcpy(data_ptr,data,stride*height);
+	memcpy(data_ptr, data, stride * height);
 	wlr_buffer_end_data_ptr_access(&buf->base);
 
 	cairo_surface_destroy(surface);
@@ -217,12 +224,15 @@ message_set_output(struct cg_output *output, const char *string,
 		break;
 	}
 
-	message->message=wlr_scene_buffer_create(&output->scene_output->scene->node,&buf->base);
+	message->message =
+	    wlr_scene_buffer_create(&output->scene_output->scene->node, &buf->base);
 	wlr_scene_node_raise_to_top(&message->message->node);
-	wlr_scene_node_set_enabled(&message->message->node,true);
+	wlr_scene_node_set_enabled(&message->message->node, true);
 	struct wlr_box *outp_box = wlr_output_layout_get_box(
 	    output->server->output_layout, output->wlr_output);
-	wlr_scene_node_set_position(&message->message->node, message->position->x+outp_box->x, message->position->y+outp_box->y);
+	wlr_scene_node_set_position(&message->message->node,
+	                            message->position->x + outp_box->x,
+	                            message->position->y + outp_box->y);
 }
 
 void
@@ -279,7 +289,7 @@ message_clear(struct cg_output *output) {
 	struct cg_message *message, *tmp;
 	wl_list_for_each_safe(message, tmp, &output->messages, link) {
 		wl_list_remove(&message->link);
-		struct wlr_buffer *buf=message->message->buffer;
+		struct wlr_buffer *buf = message->message->buffer;
 		wlr_scene_node_destroy(&message->message->node);
 		free(message->position);
 		buf->impl->destroy(buf);
diff --git a/output.c b/output.c
index 7bc77bc..4694875 100644
--- a/output.c
+++ b/output.c
@@ -25,9 +25,9 @@
 #include <wlr/types/wlr_output.h>
 #include <wlr/types/wlr_output_damage.h>
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_scene.h>
 #include <wlr/types/wlr_surface.h>
 #include <wlr/types/wlr_xcursor_manager.h>
-#include <wlr/types/wlr_scene.h>
 #include <wlr/util/log.h>
 #include <wlr/util/region.h>
 #if CG_HAS_XWAYLAND
@@ -71,14 +71,16 @@ output_clear(struct cg_output *output) {
 				first = false;
 				tile->view = NULL;
 			}
-			struct cg_workspace *ws=server->curr_output->workspaces[server->curr_output->curr_workspace];
+			struct cg_workspace *ws =
+			    server->curr_output
+			        ->workspaces[server->curr_output->curr_workspace];
 			wl_list_for_each_safe(view, view_tmp, &output->workspaces[i]->views,
 			                      link) {
 				wl_list_remove(&view->link);
 				if(wl_list_empty(&server->outputs)) {
 					view->impl->destroy(view);
 				} else {
-					wl_list_insert(&ws->views,&view->link);
+					wl_list_insert(&ws->views, &view->link);
 					wlr_scene_node_reparent(view->scene_node, &ws->scene->node);
 					view->workspace = ws;
 					view->tile = ws->focused_tile;
@@ -126,7 +128,9 @@ output_destroy(struct cg_output *output) {
 	free(output);
 
 	if(outp_name != NULL) {
-		ipc_send_event(server, "{\"event_name\":\"new_output\",\"output\":\"%s\"}", outp_name);
+		ipc_send_event(server,
+		               "{\"event_name\":\"new_output\",\"output\":\"%s\"}",
+		               outp_name);
 		free(outp_name);
 	} else {
 		wlr_log(WLR_ERROR,
@@ -145,13 +149,13 @@ handle_output_destroy(struct wl_listener *listener, void *data) {
 
 static void
 handle_output_frame(struct wl_listener *listener, void *data) {
-	struct cg_output *output=wl_container_of(listener, output, frame);
+	struct cg_output *output = wl_container_of(listener, output, frame);
 	if(!output->wlr_output->enabled) {
 		return;
 	}
 	wlr_scene_output_commit(output->scene_output);
 
-	struct timespec now={0};
+	struct timespec now = {0};
 	clock_gettime(CLOCK_MONOTONIC, &now);
 	wlr_scene_output_send_frame_done(output->scene_output, &now);
 }
@@ -201,7 +205,10 @@ output_set_mode(struct wlr_output *output, int width, int height,
 	}
 	wlr_output_set_mode(output, best);
 	if(!wlr_output_test(output)) {
-		wlr_log(WLR_ERROR, "Unable to assign configured mode to %s, picking arbitrary available mode",output->name);
+		wlr_log(WLR_ERROR,
+		        "Unable to assign configured mode to %s, picking arbitrary "
+		        "available mode",
+		        output->name);
 		struct wlr_output_mode *mode;
 		wl_list_for_each(mode, &output->modes, link) {
 			if(mode == best) {
@@ -286,18 +293,20 @@ output_configure(struct cg_server *server, struct cg_output *output) {
 		}
 	}
 	struct wlr_scene_output *scene_output;
-	wl_list_for_each(scene_output,&output->server->scene->outputs,link) {
+	wl_list_for_each(scene_output, &output->server->scene->outputs, link) {
 		if(scene_output->output == wlr_output) {
-			output->scene_output=scene_output;
+			output->scene_output = scene_output;
 			break;
 		}
 	}
-	if(output->bg!=NULL) {
+	if(output->bg != NULL) {
 		wlr_scene_node_destroy(&output->bg->node);
 	}
-	output->bg=wlr_scene_rect_create(&output->scene_output->scene->node, output->wlr_output->width,output->wlr_output->height, server->bg_color);
-	struct wlr_box *box = wlr_output_layout_get_box(
-	    server->output_layout, output->wlr_output);
+	output->bg = wlr_scene_rect_create(
+	    &output->scene_output->scene->node, output->wlr_output->width,
+	    output->wlr_output->height, server->bg_color);
+	struct wlr_box *box =
+	    wlr_output_layout_get_box(server->output_layout, output->wlr_output);
 	wlr_scene_node_set_position(&output->bg->node, box->x, box->y);
 	wlr_scene_node_lower_to_bottom(&output->bg->node);
 }
@@ -349,7 +358,8 @@ handle_new_output(struct wl_listener *listener, void *data) {
 	struct cg_server *server = wl_container_of(listener, server, new_output);
 	struct wlr_output *wlr_output = data;
 
-	if(!wlr_output_init_render(wlr_output,server->allocator,server->renderer)) {
+	if(!wlr_output_init_render(wlr_output, server->allocator,
+	                           server->renderer)) {
 		wlr_log(WLR_ERROR, "Failed to initialize output rendering");
 		return;
 	}
@@ -400,7 +410,7 @@ handle_new_output(struct wl_listener *listener, void *data) {
 	}
 
 	wlr_scene_node_raise_to_top(&output->workspaces[0]->scene->node);
-	workspace_focus(output,0);
+	workspace_focus(output, 0);
 
 	/* We are the first output. Set the current output to this one. */
 	if(server->curr_output == NULL) {
@@ -418,8 +428,10 @@ handle_new_output(struct wl_listener *listener, void *data) {
 	wl_signal_add(&wlr_output->events.commit, &output->commit);
 	output->mode.notify = handle_output_mode;
 	wl_signal_add(&wlr_output->events.mode, &output->mode);
-	ipc_send_event(server, "{\"event_name\":\"new_output\",\"output\":\"%s\",\"priority\":\"%d\"}",
-	               output->wlr_output->name, output->priority);
+	ipc_send_event(
+	    server,
+	    "{\"event_name\":\"new_output\",\"output\":\"%s\",\"priority\":\"%d\"}",
+	    output->wlr_output->name, output->priority);
 }
 #if CG_HAS_FANALYZE
 #pragma GCC diagnostic pop
diff --git a/parse.c b/parse.c
index 32eb363..9cf68c2 100644
--- a/parse.c
+++ b/parse.c
@@ -736,8 +736,9 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
 	} else if(strcmp(action, "message") == 0) {
 		keybinding->action = KEYBINDING_DISPLAY_MESSAGE;
 		if(saveptr == NULL) {
-			*errstr = log_error("Not enough paramaters to \"message\". Expected "
-			                    "string to display.");
+			*errstr =
+			    log_error("Not enough paramaters to \"message\". Expected "
+			              "string to display.");
 			return -1;
 		}
 		keybinding->data.c = strdup(saveptr);
@@ -873,8 +874,7 @@ parse_command(struct cg_server *server, struct keybinding *keybinding,
 		keybinding->action = KEYBINDING_SWITCH_MODE;
 		char *mode = strtok_r(NULL, " ", &saveptr);
 		if(mode == NULL) {
-			*errstr =
-			    log_error("Expected mode after \"mode\". Got nothing.");
+			*errstr = log_error("Expected mode after \"mode\". Got nothing.");
 			return -1;
 		}
 		int mode_idx = get_mode_index_from_name(server->modes, mode);
diff --git a/seat.c b/seat.c
index 4f82743..f928fa4 100644
--- a/seat.c
+++ b/seat.c
@@ -510,12 +510,14 @@ handle_touch_down(struct wl_listener *listener, void *data) {
 	                                     event->y, &lx, &ly);
 
 	double sx, sy;
-	struct wlr_scene_node *node=wlr_scene_node_at(&seat->server->scene->node, lx,ly,&sx,&sy);
+	struct wlr_scene_node *node =
+	    wlr_scene_node_at(&seat->server->scene->node, lx, ly, &sx, &sy);
 
 	uint32_t serial = 0;
-	if(node&&node->type == WLR_SCENE_NODE_SURFACE) {
+	if(node && node->type == WLR_SCENE_NODE_SURFACE) {
 		serial = wlr_seat_touch_notify_down(
-		    seat->seat, wlr_scene_surface_from_node(node)->surface, event->time_msec, event->touch_id, sx, sy);
+		    seat->seat, wlr_scene_surface_from_node(node)->surface,
+		    event->time_msec, event->touch_id, sx, sy);
 	}
 
 	if(serial && wlr_seat_touch_num_points(seat->seat) == 1) {
@@ -554,11 +556,13 @@ handle_touch_motion(struct wl_listener *listener, void *data) {
 	                                     event->y, &lx, &ly);
 
 	double sx, sy;
-	struct wlr_scene_node *node=wlr_scene_node_at(&seat->server->scene->node, lx,ly,&sx,&sy);
+	struct wlr_scene_node *node =
+	    wlr_scene_node_at(&seat->server->scene->node, lx, ly, &sx, &sy);
 
-	if(node&&node->type == WLR_SCENE_NODE_SURFACE) {
-		wlr_seat_touch_point_focus(seat->seat, wlr_scene_surface_from_node(node)->surface, event->time_msec,
-		                           event->touch_id, sx, sy);
+	if(node && node->type == WLR_SCENE_NODE_SURFACE) {
+		wlr_seat_touch_point_focus(seat->seat,
+		                           wlr_scene_surface_from_node(node)->surface,
+		                           event->time_msec, event->touch_id, sx, sy);
 		wlr_seat_touch_notify_motion(seat->seat, event->time_msec,
 		                             event->touch_id, sx, sy);
 	} else {
@@ -609,11 +613,11 @@ process_cursor_motion(struct cg_seat *seat, uint32_t time) {
 	struct wlr_seat *wlr_seat = seat->seat;
 	struct wlr_surface *surface = NULL;
 
-	struct wlr_scene_node *node=wlr_scene_node_at(&seat->server->scene->node, seat->cursor->x,seat->cursor->y,&sx,&sy);
+	struct wlr_scene_node *node = wlr_scene_node_at(
+	    &seat->server->scene->node, seat->cursor->x, seat->cursor->y, &sx, &sy);
 
-
-	if(node&&node->type == WLR_SCENE_NODE_SURFACE) {
-		surface=wlr_scene_surface_from_node(node)->surface;
+	if(node && node->type == WLR_SCENE_NODE_SURFACE) {
+		surface = wlr_scene_surface_from_node(node)->surface;
 		wlr_seat_pointer_notify_enter(wlr_seat, surface, sx, sy);
 
 		bool focus_changed = wlr_seat->pointer_state.focused_surface != surface;
@@ -676,7 +680,8 @@ drag_icon_update_position(struct cg_drag_icon *drag_icon) {
 		drag_icon->ly = seat->touch_ly;
 		break;
 	}
-	wlr_scene_node_set_position(drag_icon->scene_node, drag_icon->lx, drag_icon->ly);
+	wlr_scene_node_set_position(drag_icon->scene_node, drag_icon->lx,
+	                            drag_icon->ly);
 }
 
 static void
@@ -732,7 +737,8 @@ handle_start_drag(struct wl_listener *listener, void *data) {
 	}
 	drag_icon->seat = seat;
 	drag_icon->wlr_drag_icon = wlr_drag_icon;
-	drag_icon->scene_node = wlr_scene_subsurface_tree_create(&seat->server->scene->node, wlr_drag_icon->surface);
+	drag_icon->scene_node = wlr_scene_subsurface_tree_create(
+	    &seat->server->scene->node, wlr_drag_icon->surface);
 	if(!drag_icon->scene_node) {
 		free(drag_icon);
 		return;
@@ -966,5 +972,6 @@ seat_set_focus(struct cg_seat *seat, struct cg_view *view) {
 	process_cursor_motion(seat, -1);
 	struct wlr_box *box = wlr_output_layout_get_box(
 	    server->output_layout, view->workspace->output->wlr_output);
-	wlr_scene_node_set_position(&view->workspace->output->bg->node, box->x, box->y);
+	wlr_scene_node_set_position(&view->workspace->output->bg->node, box->x,
+	                            box->y);
 }
diff --git a/server.c b/server.c
index 242fd30..e554a3c 100644
--- a/server.c
+++ b/server.c
@@ -12,8 +12,8 @@
 #include <stdio.h>
 #include <string.h>
 #include <wayland-server-core.h>
-#include <wlr/util/box.h>
 #include <wlr/types/wlr_output.h>
+#include <wlr/util/box.h>
 
 #include "input_manager.h"
 #include "output.h"
diff --git a/util.c b/util.c
index 4ed180b..95e1ea4 100644
--- a/util.c
+++ b/util.c
@@ -10,8 +10,8 @@
 #include <wlr/util/box.h>
 
 #include "util.h"
-#include <stdlib.h>
 #include <math.h>
+#include <stdlib.h>
 
 int
 scale_length(int length, int offset, double scale) {
diff --git a/view.c b/view.c
index 9025c3c..e5f61d8 100644
--- a/view.c
+++ b/view.c
@@ -12,13 +12,13 @@
 #include <stdbool.h>
 #include <string.h>
 #include <wayland-server-core.h>
-#include <wlr/util/box.h>
 #include <wlr/types/wlr_compositor.h>
 #include <wlr/types/wlr_output.h>
 #include <wlr/types/wlr_output_damage.h>
-#include <wlr/types/wlr_surface.h>
-#include <wlr/types/wlr_scene.h>
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_scene.h>
+#include <wlr/types/wlr_surface.h>
+#include <wlr/util/box.h>
 
 #include "ipc_server.h"
 #include "output.h"
@@ -99,7 +99,8 @@ view_maximize(struct cg_view *view, struct cg_tile *tile) {
 	view->oy = tile->tile.y;
 	struct wlr_box *box = wlr_output_layout_get_box(
 	    view->server->output_layout, view->workspace->output->wlr_output);
-	wlr_scene_node_set_position(view->scene_node, view->ox+box->x, view->oy+box->y);
+	wlr_scene_node_set_position(view->scene_node, view->ox + box->x,
+	                            view->oy + box->y);
 	view->impl->maximize(view, tile->tile.width, tile->tile.height);
 	view->tile = tile;
 	wlr_scene_node_raise_to_top(view->scene_node);
@@ -119,9 +120,9 @@ view_unmap(struct cg_view *view) {
 	}
 
 	if(view->tile == NULL) {
-		tile_id=-1;
+		tile_id = -1;
 	} else {
-		tile_id=view->tile->id;
+		tile_id = view->tile->id;
 	}
 
 	wlr_scene_node_destroy(view->scene_node);
@@ -161,9 +162,11 @@ view_unmap(struct cg_view *view) {
 	wl_list_remove(&view->link);
 
 	view->wlr_surface = NULL;
-	ipc_send_event(view->workspace->server,
-	               "{\"event_name\":\"view_unmap\",\"view_id\":\"%d\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
-	               id, tile_id, ws + 1, output_name, title);
+	ipc_send_event(
+	    view->workspace->server,
+	    "{\"event_name\":\"view_unmap\",\"view_id\":\"%d\",\"tile_id\":\"%d\","
+	    "\"workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
+	    id, tile_id, ws + 1, output_name, title);
 }
 
 void
@@ -172,12 +175,13 @@ view_map(struct cg_view *view, struct wlr_surface *surface,
 	struct cg_output *output = ws->output;
 	view->wlr_surface = surface;
 
-	view->scene_node=wlr_scene_subsurface_tree_create(&ws->scene->node, surface);
+	view->scene_node =
+	    wlr_scene_subsurface_tree_create(&ws->scene->node, surface);
 	if(!view->scene_node) {
 		wl_resource_post_no_memory(surface->resource);
 		return;
 	}
-	view->scene_node->data=view;
+	view->scene_node->data = view;
 	view->workspace = ws;
 
 #if CG_HAS_XWAYLAND
@@ -187,7 +191,8 @@ view_map(struct cg_view *view, struct wlr_surface *surface,
 		wl_list_insert(&ws->unmanaged_views, &view->link);
 		struct wlr_box *box = wlr_output_layout_get_box(
 		    view->server->output_layout, view->workspace->output->wlr_output);
-		wlr_scene_node_set_position(view->scene_node, view->ox+box->x, view->oy+box->y);
+		wlr_scene_node_set_position(view->scene_node, view->ox + box->x,
+		                            view->oy + box->y);
 	} else
 #endif
 	{
@@ -196,15 +201,16 @@ view_map(struct cg_view *view, struct wlr_surface *surface,
 		wl_list_insert(&ws->views, &view->link);
 	}
 	seat_set_focus(output->server->seat, view);
-	int tile_id=0;
-	if(view->tile==NULL) {
-		tile_id=-1;
+	int tile_id = 0;
+	if(view->tile == NULL) {
+		tile_id = -1;
 	} else {
-		tile_id=view->tile->id;
+		tile_id = view->tile->id;
 	}
 	ipc_send_event(
 	    output->server,
-	    "{\"event_name\":\"view_map\",\"view_id\":\"%d\",\"tile_id\":\"%d\",\"workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
+	    "{\"event_name\":\"view_map\",\"view_id\":\"%d\",\"tile_id\":\"%d\","
+	    "\"workspace\":\"%d\",\"output\":\"%s\",\"view_title\":\"%s\"}",
 	    view->id, tile_id, view->workspace->num + 1,
 	    view->workspace->output->wlr_output->name, view->impl->get_title(view));
 }
diff --git a/view.h b/view.h
index 9484d58..47a5221 100644
--- a/view.h
+++ b/view.h
@@ -20,7 +20,7 @@ enum cg_view_type {
 struct cg_view {
 	struct cg_workspace *workspace;
 	struct cg_server *server;
-	struct wl_list link;     // server::views
+	struct wl_list link; // server::views
 	struct wlr_surface *wlr_surface;
 	struct cg_tile *tile;
 	struct wlr_scene_node *scene_node;
diff --git a/workspace.c b/workspace.c
index 4000545..6b23921 100644
--- a/workspace.c
+++ b/workspace.c
@@ -12,8 +12,8 @@
 #include <stdlib.h>
 #include <wayland-server-core.h>
 #include <wlr/types/wlr_output_layout.h>
-#include <wlr/util/log.h>
 #include <wlr/types/wlr_scene.h>
+#include <wlr/util/log.h>
 
 #include "message.h"
 #include "output.h"
@@ -58,7 +58,8 @@ full_screen_workspace(struct cg_output *output) {
 	}
 	workspace->server = output->server;
 	workspace->num = -1;
-	workspace->scene = wlr_scene_tree_create(&output->scene_output->scene->node);
+	workspace->scene =
+	    wlr_scene_tree_create(&output->scene_output->scene->node);
 	if(full_screen_workspace_tiles(output->server->output_layout,
 	                               output->wlr_output, workspace,
 	                               &output->server->tiles_curr_id) != 0) {
@@ -100,7 +101,9 @@ workspace_free(struct cg_workspace *workspace) {
 
 void
 workspace_focus(struct cg_output *outp, int ws) {
-	wlr_scene_node_place_above(&outp->bg->node,&outp->workspaces[outp->curr_workspace]->scene->node);
-	wlr_scene_node_place_above(&outp->workspaces[ws]->scene->node,&outp->bg->node);
-	outp->curr_workspace=ws;
+	wlr_scene_node_place_above(
+	    &outp->bg->node, &outp->workspaces[outp->curr_workspace]->scene->node);
+	wlr_scene_node_place_above(&outp->workspaces[ws]->scene->node,
+	                           &outp->bg->node);
+	outp->curr_workspace = ws;
 }
diff --git a/xdg_shell.c b/xdg_shell.c
index b5bc24b..c6ce196 100644
--- a/xdg_shell.c
+++ b/xdg_shell.c
@@ -9,16 +9,16 @@
 
 #define _POSIX_C_SOURCE 200809L
 
-#include <stdbool.h>
 #include <assert.h>
+#include <stdbool.h>
 #include <wayland-server-core.h>
-#include <wlr/util/box.h>
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_scene.h>
 #include <wlr/types/wlr_xdg_decoration_v1.h>
 #include <wlr/types/wlr_xdg_shell.h>
+#include <wlr/util/box.h>
 #include <wlr/util/edges.h>
 #include <wlr/util/log.h>
-#include <wlr/types/wlr_scene.h>
 
 #include "output.h"
 #include "server.h"
@@ -29,26 +29,28 @@
 static struct cg_view *
 popup_get_view(struct wlr_xdg_popup *popup) {
 	while(true) {
-		if(popup->parent == NULL || !wlr_surface_is_xdg_surface(popup->parent)) {
+		if(popup->parent == NULL ||
+		   !wlr_surface_is_xdg_surface(popup->parent)) {
 			return NULL;
 		}
-		struct wlr_xdg_surface *xdg_surface = wlr_xdg_surface_from_wlr_surface(popup->parent);
+		struct wlr_xdg_surface *xdg_surface =
+		    wlr_xdg_surface_from_wlr_surface(popup->parent);
 		switch(xdg_surface->role) {
-			case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
-				return xdg_surface->data;
-			case WLR_XDG_SURFACE_ROLE_POPUP:
-				popup=xdg_surface->popup;
-				break;
-			case WLR_XDG_SURFACE_ROLE_NONE:
-				return NULL;
+		case WLR_XDG_SURFACE_ROLE_TOPLEVEL:
+			return xdg_surface->data;
+		case WLR_XDG_SURFACE_ROLE_POPUP:
+			popup = xdg_surface->popup;
+			break;
+		case WLR_XDG_SURFACE_ROLE_NONE:
+			return NULL;
 		}
 	}
 }
 
 static void
-xdg_decoration_handle_destroy(struct wl_listener *listener, void *data)
-{
-	struct cg_xdg_decoration *xdg_decoration = wl_container_of(listener, xdg_decoration, destroy);
+xdg_decoration_handle_destroy(struct wl_listener *listener, void *data) {
+	struct cg_xdg_decoration *xdg_decoration =
+	    wl_container_of(listener, xdg_decoration, destroy);
 
 	wl_list_remove(&xdg_decoration->destroy.link);
 	wl_list_remove(&xdg_decoration->request_mode.link);
@@ -196,31 +198,31 @@ handle_xdg_shell_surface_destroy(struct wl_listener *listener, void *_data) {
 	view_destroy(view);
 }
 
-static const struct cg_view_impl xdg_shell_view_impl = {
-    .get_title = get_title,
-    .is_primary = is_primary,
-    .activate = activate,
-    .close = close,
-    .maximize = maximize,
-    .destroy = destroy
-};
-
+static const struct cg_view_impl xdg_shell_view_impl = {.get_title = get_title,
+                                                        .is_primary =
+                                                            is_primary,
+                                                        .activate = activate,
+                                                        .close = close,
+                                                        .maximize = maximize,
+                                                        .destroy = destroy};
 
 void
-handle_xdg_shell_surface_new(struct wl_listener *listener, void *data)
-{
-	struct cg_server *server = wl_container_of(listener, server, new_xdg_shell_surface);
+handle_xdg_shell_surface_new(struct wl_listener *listener, void *data) {
+	struct cg_server *server =
+	    wl_container_of(listener, server, new_xdg_shell_surface);
 	struct wlr_xdg_surface *xdg_surface = data;
 
-	switch (xdg_surface->role) {
+	switch(xdg_surface->role) {
 	case WLR_XDG_SURFACE_ROLE_TOPLEVEL:;
-		struct cg_xdg_shell_view *xdg_shell_view = calloc(1, sizeof(struct cg_xdg_shell_view));
-		if (!xdg_shell_view) {
+		struct cg_xdg_shell_view *xdg_shell_view =
+		    calloc(1, sizeof(struct cg_xdg_shell_view));
+		if(!xdg_shell_view) {
 			wlr_log(WLR_ERROR, "Failed to allocate XDG Shell view");
 			return;
 		}
 
-		view_init(&xdg_shell_view->view, CG_XDG_SHELL_VIEW, &xdg_shell_view_impl,server);
+		view_init(&xdg_shell_view->view, CG_XDG_SHELL_VIEW,
+		          &xdg_shell_view_impl, server);
 
 		xdg_shell_view->xdg_surface = xdg_surface;
 
@@ -230,21 +232,24 @@ handle_xdg_shell_surface_new(struct wl_listener *listener, void *data)
 		wl_signal_add(&xdg_surface->events.unmap, &xdg_shell_view->unmap);
 		xdg_shell_view->destroy.notify = handle_xdg_shell_surface_destroy;
 		wl_signal_add(&xdg_surface->events.destroy, &xdg_shell_view->destroy);
-		xdg_shell_view->request_fullscreen.notify = handle_xdg_shell_surface_request_fullscreen;
-		wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen, &xdg_shell_view->request_fullscreen);
+		xdg_shell_view->request_fullscreen.notify =
+		    handle_xdg_shell_surface_request_fullscreen;
+		wl_signal_add(&xdg_surface->toplevel->events.request_fullscreen,
+		              &xdg_shell_view->request_fullscreen);
 
 		xdg_surface->data = xdg_shell_view;
 		break;
 	case WLR_XDG_SURFACE_ROLE_POPUP:;
 		struct wlr_xdg_popup *popup = xdg_surface->popup;
 		struct cg_view *view = popup_get_view(popup);
-		if (view == NULL) {
+		if(view == NULL) {
 			return;
 		}
 
 		struct wlr_scene_node *parent_scene_node = NULL;
-		struct wlr_xdg_surface *parent = wlr_xdg_surface_from_wlr_surface(popup->parent);
-		switch (parent->role) {
+		struct wlr_xdg_surface *parent =
+		    wlr_xdg_surface_from_wlr_surface(popup->parent);
+		switch(parent->role) {
 		case WLR_XDG_SURFACE_ROLE_TOPLEVEL:;
 			parent_scene_node = view->scene_node;
 			break;
@@ -254,13 +259,15 @@ handle_xdg_shell_surface_new(struct wl_listener *listener, void *data)
 		case WLR_XDG_SURFACE_ROLE_NONE:
 			break;
 		}
-		if (parent_scene_node == NULL) {
+		if(parent_scene_node == NULL) {
 			return;
 		}
 
-		struct wlr_scene_node *popup_scene_node = wlr_scene_xdg_surface_create(parent_scene_node, xdg_surface);
-		if (popup_scene_node == NULL) {
-			wlr_log(WLR_ERROR, "Failed to allocate scene-graph node for XDG popup");
+		struct wlr_scene_node *popup_scene_node =
+		    wlr_scene_xdg_surface_create(parent_scene_node, xdg_surface);
+		if(popup_scene_node == NULL) {
+			wlr_log(WLR_ERROR,
+			        "Failed to allocate scene-graph node for XDG popup");
 			return;
 		}
 
diff --git a/xwayland.c b/xwayland.c
index c3c3a57..12f38e9 100644
--- a/xwayland.c
+++ b/xwayland.c
@@ -89,8 +89,9 @@ maximize(struct cg_view *view, int width, int height) {
 
 	struct wlr_box *output_box = wlr_output_layout_get_box(
 	    view->server->output_layout, view->server->curr_output->wlr_output);
-	wlr_xwayland_surface_configure(xwayland_view->xwayland_surface, view->ox+output_box->x,
-	                               view->oy+output_box->y, width, height);
+	wlr_xwayland_surface_configure(xwayland_view->xwayland_surface,
+	                               view->ox + output_box->x,
+	                               view->oy + output_box->y, width, height);
 	wlr_xwayland_surface_set_maximized(xwayland_view->xwayland_surface, true);
 }
 
@@ -129,8 +130,8 @@ handle_xwayland_surface_map(struct wl_listener *listener, void *_data) {
 		struct wlr_output_layout *output_layout = view->server->output_layout;
 		struct wlr_box *output_box = wlr_output_layout_get_box(
 		    output_layout, view->server->curr_output->wlr_output);
-		view->ox = xwayland_view->xwayland_surface->x-output_box->x;
-		view->oy = xwayland_view->xwayland_surface->y-output_box->y;
+		view->ox = xwayland_view->xwayland_surface->x - output_box->x;
+		view->oy = xwayland_view->xwayland_surface->y - output_box->y;
 	}
 
 	view_map(view, xwayland_view->xwayland_surface->surface,