tree-wide: auto-replace of (struct server *)

#!/bin/bash
    read -r -d '' EXPRS << EOF
    s/xwayland->server/xwayland->svr/g;

    s/\t*struct server \*server;\n//g;
    s/\t*struct server \*server =.*?;\n//gs;
    s/\t*.* = ([a-z_]*->)*server[;,]\n//g;
    s/\{\n\n/\{\n/g;
    s/\n\n+/\n\n/g;

    s/\(\s*struct server \*server\)/(void)/g;
    s/\(\s*struct server \*server,\s*/(/g;
    s/,\s*struct server \*server\)/)/g;
    s/,\s*struct server \*server,\s*/, /g;

    s/\(\s*([a-z_]*->)*server\)/()/g;
    s/\(\s*([a-z_]*->)*server,\s*/(/g;
    s/,\s*([a-z_]*->)*server\)/)/g;
    s/,\s*([a-z_]*->)*server,\s*/, /g;

    s/([a-z_]*->)*server->/g_server./g;

    s/xwayland->svr/xwayland->server/g;
    EOF

    find src include \( -name \*.c -o -name \*.h \) -exec \
        perl -0777 -i -pe "$EXPRS" \{\} \;

include/action.h

@@ -47,8 +47,7 @@ bool actions_contain_toggle_keybinds(struct wl_list *action_list);
  * direction of resize or the position of the window menu button for ShowMenu
  * action.
  */
-void actions_run(struct view *activator, struct server *server,
-	struct wl_list *actions, struct cursor_context *ctx);
+void actions_run(struct view *activator, struct wl_list *actions, struct cursor_context *ctx);
 
 void action_prompts_destroy(void);
 bool action_check_prompt_result(pid_t pid, int exit_code);

include/config/keybind.h

@@ -45,5 +45,5 @@ bool keybind_the_same(struct keybind *a, struct keybind *b);
 bool keybind_contains_keycode(struct keybind *keybind, xkb_keycode_t keycode);
 bool keybind_contains_keysym(struct keybind *keybind, xkb_keysym_t keysym);
 
-void keybind_update_keycodes(struct server *server);
+void keybind_update_keycodes(void);
 #endif /* LABWC_KEYBIND_H */

include/config/session.h

@@ -21,12 +21,12 @@ void session_environment_init(void);
  * session_autostart_init - run autostart file as shell script
  * Note: Same as `sh ~/.config/labwc/autostart` (or equivalent XDG config dir)
  */
-void session_autostart_init(struct server *server);
+void session_autostart_init(void);
 
 /**
  * session_shutdown - run session shutdown file as shell script
  * Note: Same as `sh ~/.config/labwc/shutdown` (or equivalent XDG config dir)
  */
-void session_shutdown(struct server *server);
+void session_shutdown(void);
 
 #endif /* LABWC_SESSION_H */

include/cycle.h

@@ -91,20 +91,20 @@ struct server;
 struct wlr_scene_node;
 
 /* Begin window switcher */
-void cycle_begin(struct server *server, enum lab_cycle_dir direction,
+void cycle_begin(enum lab_cycle_dir direction,
 	struct cycle_filter filter);
 
 /* Cycle the selected view in the window switcher */
-void cycle_step(struct server *server, enum lab_cycle_dir direction);
+void cycle_step(enum lab_cycle_dir direction);
 
 /* Closes the OSD */
-void cycle_finish(struct server *server, bool switch_focus);
+void cycle_finish(bool switch_focus);
 
 /* Re-initialize the window switcher */
-void cycle_reinitialize(struct server *server);
+void cycle_reinitialize(void);
 
 /* Focus the clicked window and close OSD */
-void cycle_on_cursor_release(struct server *server, struct wlr_scene_node *node);
+void cycle_on_cursor_release(struct wlr_scene_node *node);
 
 /* Used by osd.c internally to render window switcher fields */
 void cycle_osd_field_get_content(struct cycle_osd_field *field,
@@ -133,7 +133,7 @@ struct cycle_osd_impl {
 	 */
 	void (*init)(struct cycle_osd_output *osd_output);
 	/*
-	 * Update the OSD to highlight server->cycle.selected_view.
+	 * Update the OSD to highlight g_server.cycle.selected_view.
 	 */
 	void (*update)(struct cycle_osd_output *osd_output);
 };
@@ -157,7 +157,7 @@ void cycle_osd_scroll_init(struct cycle_osd_output *osd_output,
 	int nr_cols, int nr_rows, int nr_visible_rows,
 	float *border_color, float *bg_color);
 
-/* Scroll the OSD to show server->cycle.selected_view if needed */
+/* Scroll the OSD to show g_server.cycle.selected_view if needed */
 void cycle_osd_scroll_update(struct cycle_osd_output *osd_output);
 
 extern struct cycle_osd_impl cycle_osd_classic_impl;

include/debug.h

@@ -4,6 +4,6 @@
 
 struct server;
 
-void debug_dump_scene(struct server *server);
+void debug_dump_scene(void);
 
 #endif /* LABWC_DEBUG_H */

include/decorations.h

@@ -6,13 +6,13 @@ struct server;
 struct view;
 struct wlr_surface;
 
-void kde_server_decoration_init(struct server *server);
-void xdg_server_decoration_init(struct server *server);
+void kde_server_decoration_init(void);
+void xdg_server_decoration_init(void);
 
 void kde_server_decoration_update_default(void);
 void kde_server_decoration_set_view(struct view *view, struct wlr_surface *surface);
 
-void kde_server_decoration_finish(struct server *server);
-void xdg_server_decoration_finish(struct server *server);
+void kde_server_decoration_finish(void);
+void xdg_server_decoration_finish(void);
 
 #endif /* LABWC_DECORATIONS_H */

include/desktop-entry.h

@@ -6,14 +6,12 @@
 
 struct server;
 
-void desktop_entry_init(struct server *server);
-void desktop_entry_finish(struct server *server);
+void desktop_entry_init(void);
+void desktop_entry_finish(void);
 
-struct lab_img *desktop_entry_load_icon_from_app_id(
-	struct server *server, const char *app_id, int size, float scale);
+struct lab_img *desktop_entry_load_icon_from_app_id(const char *app_id, int size, float scale);
 
-struct lab_img *desktop_entry_load_icon(
-	struct server *server, const char *icon_name, int size, float scale);
+struct lab_img *desktop_entry_load_icon(const char *icon_name, int size, float scale);
 
 /**
  * desktop_entry_name_lookup() - return the application name
@@ -22,8 +20,7 @@ struct lab_img *desktop_entry_load_icon(
  * The lifetime of the returned value is the same as that
  * of sfdo_desktop_db (from `struct sfdo.desktop_db`)
  */
-const char *desktop_entry_name_lookup(struct server *server,
-	const char *app_id);
+const char *desktop_entry_name_lookup(const char *app_id);
 
 #endif /* HAVE_LIBSFDO */
 #endif /* LABWC_DESKTOP_ENTRY_H */

include/edges.h

@@ -117,6 +117,6 @@ void edges_adjust_resize_geom(struct view *view, struct border edges,
 
 bool edges_traverse_edge(struct edge current, struct edge target, struct edge edge);
 
-void edges_calculate_visibility(struct server *server, struct view *ignored_view);
+void edges_calculate_visibility(struct view *ignored_view);
 
 #endif /* LABWC_EDGES_H */

include/input/cursor.h

@@ -62,7 +62,7 @@ struct cursor_context_saved {
  *
  * If no node is found at cursor, ctx.type is set to ROOT.
  */
-struct cursor_context get_cursor_context(struct server *server);
+struct cursor_context get_cursor_context(void);
 
 /**
  * cursor_set - set cursor icon
@@ -82,7 +82,7 @@ void cursor_context_save(struct cursor_context_saved *saved_ctx,
 
 /**
  * cursor_get_resize_edges - calculate resize edge based on cursor position
- * @cursor - the current cursor (usually server->seat.cursor)
+ * @cursor - the current cursor (usually g_server.seat.cursor)
  * @cursor_context - result of get_cursor_context()
  *
  * Calculates the resize edge combination that is most appropriate based
@@ -113,7 +113,7 @@ enum lab_cursors cursor_get_from_edge(enum lab_edge resize_edges);
  * or to force an update of the cursor icon by sending an exit and enter
  * event to an already focused surface.
  */
-void cursor_update_focus(struct server *server);
+void cursor_update_focus(void);
 
 /**
  * cursor_update_image - re-set the labwc cursor image
@@ -130,7 +130,7 @@ void cursor_update_image(struct seat *seat);
  * should be notified. Parameters sx, sy holds the surface coordinates
  * in that case.
  */
-bool cursor_process_motion(struct server *server, uint32_t time, double *sx, double *sy);
+bool cursor_process_motion(uint32_t time, double *sx, double *sy);
 
 /**
  * Processes cursor button press. The return value indicates if a client

include/labwc.h

@@ -24,7 +24,6 @@ enum input_mode {
 
 struct seat {
 	struct wlr_seat *seat;
-	struct server *server;
 	struct wlr_keyboard_group *keyboard_group;
 
 	struct wl_list touch_points; /* struct touch_point.link */
@@ -317,8 +316,8 @@ struct server {
 extern struct server g_server;
 
 void xdg_popup_create(struct view *view, struct wlr_xdg_popup *wlr_popup);
-void xdg_shell_init(struct server *server);
-void xdg_shell_finish(struct server *server);
+void xdg_shell_init(void);
+void xdg_shell_finish(void);
 
 /*
  * desktop.c routines deal with a collection of views
@@ -353,14 +352,14 @@ void desktop_focus_view(struct view *view, bool raise);
 void desktop_focus_view_or_surface(struct seat *seat, struct view *view,
 	struct wlr_surface *surface, bool raise);
 
-void desktop_arrange_all_views(struct server *server);
+void desktop_arrange_all_views(void);
 void desktop_focus_output(struct output *output);
 
 /**
  * Toggles the (output local) visibility of the layershell top layer
  * based on the existence of a fullscreen window on the current workspace.
  */
-void desktop_update_top_layer_visibility(struct server *server);
+void desktop_update_top_layer_visibility(void);
 
 /**
  * desktop_focus_topmost_view() - focus the topmost view on the current
@@ -370,11 +369,11 @@ void desktop_update_top_layer_visibility(struct server *server);
  * This function is typically called when the focused view is hidden
  * (closes, is minimized, etc.) to focus the "next" view underneath.
  */
-void desktop_focus_topmost_view(struct server *server);
+void desktop_focus_topmost_view(void);
 
-void seat_init(struct server *server);
-void seat_finish(struct server *server);
-void seat_reconfigure(struct server *server);
+void seat_init(void);
+void seat_finish(void);
+void seat_reconfigure(void);
 void seat_force_focus_surface(struct seat *seat, struct wlr_surface *surface);
 void seat_focus_surface(struct seat *seat, struct wlr_surface *surface);
 
@@ -406,16 +405,15 @@ void seat_focus_override_end(struct seat *seat, bool restore_focus);
 /**
  * interactive_anchor_to_cursor() - repositions the geometry to remain
  * underneath the cursor when its size changes during interactive move.
- * This function also resizes server->grab_box and repositions it to remain
- * underneath server->grab_{x,y}.
+ * This function also resizes g_server.grab_box and repositions it to remain
+ * underneath g_server.grab_{x,y}.
  *
  * geo->{width,height} are provided by the caller.
  * geo->{x,y} are computed by this function.
  */
-void interactive_anchor_to_cursor(struct server *server, struct wlr_box *geo);
+void interactive_anchor_to_cursor(struct wlr_box *geo);
 
-void interactive_set_grab_context(struct server *server,
-	const struct cursor_context *ctx);
+void interactive_set_grab_context(const struct cursor_context *ctx);
 void interactive_begin(struct view *view, enum input_mode mode,
 	enum lab_edge edges);
 void interactive_finish(struct view *view);
@@ -433,12 +431,12 @@ bool edge_from_cursor(struct seat *seat, struct output **dest_output,
 
 void handle_tearing_new_object(struct wl_listener *listener, void *data);
 
-void server_init(struct server *server);
-void server_start(struct server *server);
-void server_finish(struct server *server);
+void server_init(void);
+void server_start(void);
+void server_finish(void);
 
 void create_constraint(struct wl_listener *listener, void *data);
-void constrain_cursor(struct server *server, struct wlr_pointer_constraint_v1
+void constrain_cursor(struct wlr_pointer_constraint_v1
 	*constraint);
 
 #endif /* LABWC_H */

include/layers.h

@@ -12,7 +12,6 @@ struct seat;
 struct lab_layer_surface {
 	struct wlr_layer_surface_v1 *layer_surface;
 	struct wlr_scene_layer_surface_v1 *scene_layer_surface;
-	struct server *server;
 
 	bool mapped;
 	/* true only inside handle_unmap() */
@@ -29,7 +28,6 @@ struct lab_layer_surface {
 struct lab_layer_popup {
 	struct wlr_xdg_popup *wlr_popup;
 	struct wlr_scene_tree *scene_tree;
-	struct server *server;
 	bool parent_was_focused;
 
 	/* To simplify moving popup nodes from the bottom to the top layer */
@@ -41,8 +39,8 @@ struct lab_layer_popup {
 	struct wl_listener reposition;
 };
 
-void layers_init(struct server *server);
-void layers_finish(struct server *server);
+void layers_init(void);
+void layers_finish(void);
 
 void layers_arrange(struct output *output);
 void layer_try_set_focus(struct seat *seat,

include/magnifier.h

@@ -14,8 +14,8 @@ enum magnify_dir {
 	MAGNIFY_DECREASE
 };
 
-void magnifier_toggle(struct server *server);
-void magnifier_set_scale(struct server *server, enum magnify_dir dir);
+void magnifier_toggle(void);
+void magnifier_set_scale(enum magnify_dir dir);
 bool output_wants_magnification(struct output *output);
 void magnifier_draw(struct output *output, struct wlr_buffer *output_buffer,
 	struct wlr_box *damage);

include/menu/menu.h

@@ -49,7 +49,6 @@ struct menu {
 		int height;
 	} size;
 	struct wl_list menuitems;
-	struct server *server;
 	struct {
 		struct menu *menu;
 		struct menuitem *item;
@@ -65,14 +64,14 @@ struct menu {
 };
 
 /* For keyboard support */
-void menu_item_select_next(struct server *server);
-void menu_item_select_previous(struct server *server);
-void menu_submenu_enter(struct server *server);
-void menu_submenu_leave(struct server *server);
-bool menu_call_selected_actions(struct server *server);
+void menu_item_select_next(void);
+void menu_item_select_previous(void);
+void menu_submenu_enter(void);
+void menu_submenu_leave(void);
+bool menu_call_selected_actions(void);
 
-void menu_init(struct server *server);
-void menu_finish(struct server *server);
+void menu_init(void);
+void menu_finish(void);
 void menu_on_view_destroy(struct view *view);
 
 /**
@@ -80,15 +79,15 @@ void menu_on_view_destroy(struct view *view);
  *
  * @id id string defined in menu.xml like "root-menu"
  */
-struct menu *menu_get_by_id(struct server *server, const char *id);
+struct menu *menu_get_by_id(const char *id);
 
 /**
  * menu_open_root - open menu on position (x, y)
  *
- * This function will close server->menu_current, open the
- * new menu and assign @menu to server->menu_current.
+ * This function will close g_server.menu_current, open the
+ * new menu and assign @menu to g_server.menu_current.
  *
- * Additionally, server->input_mode will be set to LAB_INPUT_STATE_MENU.
+ * Additionally, g_server.input_mode will be set to LAB_INPUT_STATE_MENU.
  */
 void menu_open_root(struct menu *menu, int x, int y);
 
@@ -103,14 +102,14 @@ void menu_process_cursor_motion(struct wlr_scene_node *node);
 /**
  *  menu_close_root- close root menu
  *
- * This function will close server->menu_current and set it to NULL.
- * Asserts that server->input_mode is set to LAB_INPUT_STATE_MENU.
+ * This function will close g_server.menu_current and set it to NULL.
+ * Asserts that g_server.input_mode is set to LAB_INPUT_STATE_MENU.
  *
- * Additionally, server->input_mode will be set to LAB_INPUT_STATE_PASSTHROUGH.
+ * Additionally, g_server.input_mode will be set to LAB_INPUT_STATE_PASSTHROUGH.
  */
-void menu_close_root(struct server *server);
+void menu_close_root(void);
 
 /* menu_reconfigure - reload theme and content */
-void menu_reconfigure(struct server *server);
+void menu_reconfigure(void);
 
 #endif /* LABWC_MENU_H */

include/output-virtual.h

@@ -5,9 +5,9 @@
 struct server;
 struct wlr_output;
 
-void output_virtual_add(struct server *server, const char *output_name,
+void output_virtual_add(const char *output_name,
 		struct wlr_output **store_wlr_output);
-void output_virtual_remove(struct server *server, const char *output_name);
-void output_virtual_update_fallback(struct server *server);
+void output_virtual_remove(const char *output_name);
+void output_virtual_update_fallback(void);
 
 #endif

include/output.h

@@ -9,7 +9,6 @@
 
 struct output {
 	struct wl_list link; /* server.outputs */
-	struct server *server;
 	struct wlr_output *wlr_output;
 	struct wlr_output_state pending;
 	struct wlr_scene_output *scene_output;
@@ -45,13 +44,12 @@ struct output {
 
 #undef LAB_NR_LAYERS
 
-void output_init(struct server *server);
-void output_finish(struct server *server);
-struct output *output_from_wlr_output(struct server *server,
-	struct wlr_output *wlr_output);
-struct output *output_from_name(struct server *server, const char *name);
-struct output *output_nearest_to(struct server *server, int lx, int ly);
-struct output *output_nearest_to_cursor(struct server *server);
+void output_init(void);
+void output_finish(void);
+struct output *output_from_wlr_output(struct wlr_output *wlr_output);
+struct output *output_from_name(const char *name);
+struct output *output_nearest_to(int lx, int ly);
+struct output *output_nearest_to_cursor(void);
 
 /**
  * output_get_adjacent() - get next output, in a given direction,
@@ -69,7 +67,7 @@ struct output *output_get_adjacent(struct output *output,
 
 bool output_is_usable(struct output *output);
 void output_update_usable_area(struct output *output);
-void output_update_all_usable_areas(struct server *server, bool layout_changed);
+void output_update_all_usable_areas(bool layout_changed);
 bool output_get_tearing_allowance(struct output *output);
 struct wlr_box output_usable_area_in_layout_coords(struct output *output);
 void handle_output_power_manager_set_mode(struct wl_listener *listener,

include/regions.h

@@ -26,7 +26,7 @@ struct region {
 };
 
 /* Returns true if we should show the region overlay or snap to region */
-bool regions_should_snap(struct server *server);
+bool regions_should_snap(void);
 
 /**
  * regions_reconfigure*() - re-initializes all regions from struct rc.
@@ -36,7 +36,7 @@ bool regions_should_snap(struct server *server);
  * - new output local regions are created from struct rc
  * - the region geometry is re-calculated
  */
-void regions_reconfigure(struct server *server);
+void regions_reconfigure(void);
 void regions_reconfigure_output(struct output *output);
 
 /* re-calculate the geometry based on usable area */
@@ -62,7 +62,7 @@ void regions_evacuate_output(struct output *output);
 void regions_destroy(struct seat *seat, struct wl_list *regions);
 
 /* Get output local region from cursor or name, may be NULL */
-struct region *regions_from_cursor(struct server *server);
+struct region *regions_from_cursor(void);
 struct region *regions_from_name(const char *region_name, struct output *output);
 
 #endif /* LABWC_REGIONS_H */

include/resize-indicator.h

@@ -5,7 +5,7 @@
 struct server;
 struct view;
 
-void resize_indicator_reconfigure(struct server *server);
+void resize_indicator_reconfigure(void);
 void resize_indicator_show(struct view *view);
 void resize_indicator_update(struct view *view);
 void resize_indicator_hide(struct view *view);

include/scaled-buffer/scaled-icon-buffer.h

@@ -12,7 +12,6 @@ struct wlr_scene_buffer;
 struct scaled_icon_buffer {
 	struct scaled_buffer *scaled_buffer;
 	struct wlr_scene_buffer *scene_buffer;
-	struct server *server;
 	/* for window icon */
 	struct view *view;
 	char *view_app_id;
@@ -39,8 +38,7 @@ struct scaled_icon_buffer {
  * wlr_scene_buffer (or one of its parents) is being destroyed.
  */
 struct scaled_icon_buffer *scaled_icon_buffer_create(
-	struct wlr_scene_tree *parent, struct server *server,
-	int width, int height);
+	struct wlr_scene_tree *parent, int width, int height);
 
 void scaled_icon_buffer_set_view(struct scaled_icon_buffer *self,
 	struct view *view);

include/session-lock.h

@@ -8,7 +8,6 @@ struct output;
 struct server;
 
 struct session_lock_manager {
-	struct server *server;
 	struct wlr_session_lock_manager_v1 *wlr_manager;
 	/* View re-focused on unlock */
 	struct view *last_active_view;
@@ -31,8 +30,8 @@ struct session_lock_manager {
 	struct wl_listener lock_destroy;
 };
 
-void session_lock_init(struct server *server);
+void session_lock_init(void);
 void session_lock_output_create(struct session_lock_manager *manager, struct output *output);
-void session_lock_update_for_layout_change(struct server *server);
+void session_lock_update_for_layout_change(void);
 
 #endif /* LABWC_SESSION_LOCK_H */

include/ssd.h

@@ -51,8 +51,7 @@ void ssd_set_titlebar(struct ssd *ssd, bool enabled);
 void ssd_enable_keybind_inhibit_indicator(struct ssd *ssd, bool enable);
 void ssd_enable_shade(struct ssd *ssd, bool enable);
 
-void ssd_update_hovered_button(struct server *server,
-	struct wlr_scene_node *node);
+void ssd_update_hovered_button(struct wlr_scene_node *node);
 
 void ssd_button_free(struct ssd_button *button);
 

include/theme.h

@@ -222,7 +222,7 @@ struct server;
  * @theme_name: theme-name in <theme-dir>/<theme-name>/labwc/themerc
  * Note <theme-dir> is obtained in theme-dir.c
  */
-void theme_init(struct theme *theme, struct server *server, const char *theme_name);
+void theme_init(struct theme *theme, const char *theme_name);
 
 /**
  * theme_finish - free button textures

include/view.h

@@ -135,7 +135,6 @@ struct view_impl {
 };
 
 struct view {
-	struct server *server;
 	enum view_type type;
 	const struct view_impl *impl;
 	struct wl_list link;
@@ -358,7 +357,7 @@ bool view_matches_query(struct view *view, struct view_query *query);
  * @criteria: Criteria to match against.
  * Example:
  *	struct view *view;
- *	for_each_view(view, &server->views, LAB_VIEW_CRITERIA_NONE) {
+ *	for_each_view(view, &g_server.views, LAB_VIEW_CRITERIA_NONE) {
  *		printf("%s\n", view_get_string_prop(view, "app_id"));
  *	}
  */
@@ -374,7 +373,7 @@ bool view_matches_query(struct view *view, struct view_query *query);
  * @criteria: Criteria to match against.
  * Example:
  *	struct view *view;
- *	for_each_view_reverse(view, &server->views, LAB_VIEW_CRITERIA_NONE) {
+ *	for_each_view_reverse(view, &g_server.views, LAB_VIEW_CRITERIA_NONE) {
  *		printf("%s\n", view_get_string_prop(view, "app_id"));
  *	}
  */
@@ -424,13 +423,13 @@ struct view *view_prev(struct wl_list *head, struct view *view,
  *	struct view **view;
  *	struct wl_array views;
  *	wl_array_init(&views);
- *	view_array_append(server, &views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE);
+ *	view_array_append(&views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE);
  *	wl_array_for_each(view, &views) {
  *		// Do something with *view
  *	}
  *	wl_array_release(&views);
  */
-void view_array_append(struct server *server, struct wl_array *views,
+void view_array_append(struct wl_array *views,
 	enum lab_view_criteria criteria);
 
 enum view_wants_focus view_wants_focus(struct view *view);

include/workspaces.h

@@ -12,7 +12,6 @@ struct wlr_scene_tree;
 
 struct workspace {
 	struct wl_list link; /* struct server.workspaces */
-	struct server *server;
 
 	char *name;
 	struct wlr_scene_tree *tree;
@@ -34,12 +33,12 @@ struct workspace {
 	} on_ext;
 };
 
-void workspaces_init(struct server *server);
+void workspaces_init(void);
 void workspaces_switch_to(struct workspace *target, bool update_focus);
-void workspaces_destroy(struct server *server);
+void workspaces_destroy(void);
 void workspaces_osd_hide(struct seat *seat);
 struct workspace *workspaces_find(struct workspace *anchor, const char *name,
 	bool wrap);
-void workspaces_reconfigure(struct server *server);
+void workspaces_reconfigure(void);
 
 #endif /* LABWC_WORKSPACES_H */

include/xwayland.h

@@ -11,7 +11,6 @@ struct wlr_output;
 struct wlr_output_layout;
 
 struct xwayland_unmanaged {
-	struct server *server;
 	struct wlr_xwayland_surface *xwayland_surface;
 	struct wlr_scene_node *node;
 	struct wl_list link;
@@ -67,25 +66,22 @@ struct xwayland_view {
 
 };
 
-void xwayland_unmanaged_create(struct server *server,
-	struct wlr_xwayland_surface *xsurface, bool mapped);
+void xwayland_unmanaged_create(struct wlr_xwayland_surface *xsurface, bool mapped);
 
-void xwayland_view_create(struct server *server,
-	struct wlr_xwayland_surface *xsurface, bool mapped);
+void xwayland_view_create(struct wlr_xwayland_surface *xsurface, bool mapped);
 
-void xwayland_server_init(struct server *server,
-	struct wlr_compositor *compositor);
-void xwayland_server_finish(struct server *server);
+void xwayland_server_init(struct wlr_compositor *compositor);
+void xwayland_server_finish(void);
 
 void xwayland_adjust_usable_area(struct view *view,
 	struct wlr_output_layout *layout, struct wlr_output *output,
 	struct wlr_box *usable);
 
-void xwayland_update_workarea(struct server *server);
+void xwayland_update_workarea(void);
 
-void xwayland_reset_cursor(struct server *server);
+void xwayland_reset_cursor(void);
 
-void xwayland_flush(struct server *server);
+void xwayland_flush(void);
 
 #endif /* HAVE_XWAYLAND */
 #endif /* LABWC_XWAYLAND_H */

src/action.c

@@ -741,23 +741,23 @@ action_list_free(struct wl_list *action_list)
 }
 
 static void
-show_menu(struct server *server, struct view *view, struct cursor_context *ctx,
+show_menu(struct view *view, struct cursor_context *ctx,
 		const char *menu_name, bool at_cursor,
 		const char *pos_x, const char *pos_y)
 {
-	if (server->input_mode != LAB_INPUT_STATE_PASSTHROUGH
-			&& server->input_mode != LAB_INPUT_STATE_MENU) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH
+			&& g_server.input_mode != LAB_INPUT_STATE_MENU) {
 		/* Prevent opening a menu while resizing / moving a view */
 		return;
 	}
 
-	struct menu *menu = menu_get_by_id(server, menu_name);
+	struct menu *menu = menu_get_by_id(menu_name);
 	if (!menu) {
 		return;
 	}
 
-	int x = server->seat.cursor->x;
-	int y = server->seat.cursor->y;
+	int x = g_server.seat.cursor->x;
+	int y = g_server.seat.cursor->y;
 
 	/* The client menu needs an active client */
 	bool is_client_menu = !strcasecmp(menu_name, "client-menu");
@@ -776,7 +776,7 @@ show_menu(struct server *server, struct view *view, struct cursor_context *ctx,
 			int lx, ly;
 			wlr_scene_node_coords(ctx->node, &lx, &ly);
 			/* MAX() prevents negative x when the window is maximized */
-			x = MAX(x, lx - server->theme->menu_border_width);
+			x = MAX(x, lx - g_server.theme->menu_border_width);
 		}
 	}
 
@@ -785,8 +785,7 @@ show_menu(struct server *server, struct view *view, struct cursor_context *ctx,
 	 * x/y can be number, "center" or a %percent of screen dimensions
 	 */
 	if (pos_x && pos_y) {
-		struct output *output = output_nearest_to(server,
-				server->seat.cursor->x, server->seat.cursor->y);
+		struct output *output = output_nearest_to(g_server.seat.cursor->x, g_server.seat.cursor->y);
 		struct wlr_box usable = output_usable_area_in_layout_coords(output);
 
 		if (!strcasecmp(pos_x, "center")) {
@@ -830,8 +829,7 @@ show_menu(struct server *server, struct view *view, struct cursor_context *ctx,
 }
 
 static struct view *
-view_for_action(struct view *activator, struct server *server,
-	struct action *action, struct cursor_context *ctx)
+view_for_action(struct view *activator, struct action *action, struct cursor_context *ctx)
 {
 	/* View is explicitly specified for mousebinds */
 	if (activator) {
@@ -843,17 +841,16 @@ view_for_action(struct view *activator, struct server *server,
 	case ACTION_TYPE_FOCUS:
 	case ACTION_TYPE_MOVE:
 	case ACTION_TYPE_RESIZE: {
-		*ctx = get_cursor_context(server);
+		*ctx = get_cursor_context();
 		return ctx->view;
 	}
 	default:
-		return server->active_view;
+		return g_server.active_view;
 	}
 }
 
 struct action_prompt {
 	/* Set when created */
-	struct server *server;
 	struct action *action;
 	struct view *view;
 
@@ -930,7 +927,7 @@ print_prompt_command(struct buf *buf, const char *format,
 }
 
 static void
-action_prompt_create(struct view *view, struct server *server, struct action *action)
+action_prompt_create(struct view *view, struct action *action)
 {
 	struct buf command = BUF_INIT;
 	print_prompt_command(&command, rc.prompt_command, action, rc.theme);
@@ -947,7 +944,6 @@ action_prompt_create(struct view *view, struct server *server, struct action *ac
 	close(pipe_fd);
 
 	struct action_prompt *prompt = znew(*prompt);
-	prompt->server = server;
 	prompt->action = action;
 	prompt->view = view;
 	prompt->pid = prompt_pid;
@@ -996,8 +992,7 @@ action_check_prompt_result(pid_t pid, int exit_code)
 		}
 		if (actions) {
 			wlr_log(WLR_INFO, "Running actions");
-			actions_run(prompt->view, prompt->server,
-				actions, /*cursor_ctx*/ NULL);
+			actions_run(prompt->view, actions, /*cursor_ctx*/ NULL);
 		} else {
 			wlr_log(WLR_INFO, "No actions for selected branch");
 		}
@@ -1028,14 +1023,13 @@ match_queries(struct view *view, struct action *action)
 }
 
 static struct output *
-get_target_output(struct output *output, struct server *server,
-	struct action *action)
+get_target_output(struct output *output, struct action *action)
 {
 	const char *output_name = action_get_str(action, "output", NULL);
 	struct output *target = NULL;
 
 	if (output_name) {
-		target = output_from_name(server, output_name);
+		target = output_from_name(output_name);
 	} else {
 		enum lab_edge edge =
 			action_get_int(action, "direction", LAB_EDGE_NONE);
@@ -1051,9 +1045,9 @@ get_target_output(struct output *output, struct server *server,
 }
 
 static void
-warp_cursor(struct server *server, struct view *view, const char *to, const char *x, const char *y)
+warp_cursor(struct view *view, const char *to, const char *x, const char *y)
 {
-	struct output *output = output_nearest_to_cursor(server);
+	struct output *output = output_nearest_to_cursor();
 	struct wlr_box target_area = {0};
 	int goto_x;
 	int goto_y;
@@ -1084,12 +1078,12 @@ warp_cursor(struct server *server, struct view *view, const char *to, const char
 			target_area.y + target_area.height + offset_y;
 	}
 
-	wlr_cursor_warp(server->seat.cursor, NULL, goto_x, goto_y);
-	cursor_update_focus(server);
+	wlr_cursor_warp(g_server.seat.cursor, NULL, goto_x, goto_y);
+	cursor_update_focus();
 }
 
 static void
-run_action(struct view *view, struct server *server, struct action *action,
+run_action(struct view *view, struct action *action,
 	struct cursor_context *ctx)
 {
 	switch (action->type) {
@@ -1111,7 +1105,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 		}
 		break;
 	case ACTION_TYPE_DEBUG:
-		debug_dump_scene(server);
+		debug_dump_scene();
 		break;
 	case ACTION_TYPE_EXECUTE: {
 		struct buf cmd = BUF_INIT;
@@ -1122,7 +1116,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 		break;
 	}
 	case ACTION_TYPE_EXIT:
-		wl_display_terminate(server->wl_display);
+		wl_display_terminate(g_server.wl_display);
 		break;
 	case ACTION_TYPE_MOVE_TO_EDGE:
 		if (view) {
@@ -1177,10 +1171,10 @@ run_action(struct view *view, struct server *server, struct action *action,
 			.app_id = action_get_int(action, "identifier",
 				CYCLE_APP_ID_ALL),
 		};
-		if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
-			cycle_step(server, dir);
+		if (g_server.input_mode == LAB_INPUT_STATE_CYCLE) {
+			cycle_step(dir);
 		} else {
-			cycle_begin(server, dir, filter);
+			cycle_begin(dir, filter);
 		}
 		break;
 	}
@@ -1188,7 +1182,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 		kill(getpid(), SIGHUP);
 		break;
 	case ACTION_TYPE_SHOW_MENU:
-		show_menu(server, view, ctx,
+		show_menu(view, ctx,
 			action_get_str(action, "menu", NULL),
 			action_get_bool(action, "atCursor", true),
 			action_get_str(action, "x.position", NULL),
@@ -1255,7 +1249,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 		}
 		break;
 	case ACTION_TYPE_UNFOCUS:
-		seat_focus_surface(&server->seat, NULL);
+		seat_focus_surface(&g_server.seat, NULL);
 		break;
 	case ACTION_TYPE_ICONIFY:
 		if (view) {
@@ -1279,8 +1273,8 @@ run_action(struct view *view, struct server *server, struct action *action,
 			 * set by button press handling. For keybind-triggered
 			 * Move, set it now from current cursor position.
 			 */
-			if (view != server->seat.pressed.ctx.view) {
-				interactive_set_grab_context(server, ctx);
+			if (view != g_server.seat.pressed.ctx.view) {
+				interactive_set_grab_context(ctx);
 			}
 			interactive_begin(view, LAB_INPUT_STATE_MOVE,
 				LAB_EDGE_NONE);
@@ -1300,8 +1294,8 @@ run_action(struct view *view, struct server *server, struct action *action,
 			 * set by button press handling. For keybind-triggered
 			 * Resize, set it now from current cursor position.
 			 */
-			if (view != server->seat.pressed.ctx.view) {
-				interactive_set_grab_context(server, ctx);
+			if (view != g_server.seat.pressed.ctx.view) {
+				interactive_set_grab_context(ctx);
 			}
 			interactive_begin(view, LAB_INPUT_STATE_RESIZE,
 				resize_edges);
@@ -1375,12 +1369,12 @@ run_action(struct view *view, struct server *server, struct action *action,
 		 * a required argument for both SendToDesktop and GoToDesktop.
 		 */
 		struct workspace *target_workspace = workspaces_find(
-			server->workspaces.current, to, wrap);
+			g_server.workspaces.current, to, wrap);
 		if (action->type == ACTION_TYPE_GO_TO_DESKTOP) {
 			bool toggle = action_get_bool(action, "toggle", false);
-			if (target_workspace == server->workspaces.current
+			if (target_workspace == g_server.workspaces.current
 				&& toggle) {
-				target_workspace = server->workspaces.last;
+				target_workspace = g_server.workspaces.last;
 			}
 		}
 		if (!target_workspace) {
@@ -1391,8 +1385,8 @@ run_action(struct view *view, struct server *server, struct action *action,
 			follow = action_get_bool(action, "follow", true);
 
 			/* Ensure that the focus is not on another desktop */
-			if (!follow && server->active_view == view) {
-				desktop_focus_topmost_view(server);
+			if (!follow && g_server.active_view == view) {
+				desktop_focus_topmost_view();
 			}
 		}
 		if (follow) {
@@ -1406,7 +1400,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 			break;
 		}
 		struct output *target_output =
-			get_target_output(view->output, server, action);
+			get_target_output(view->output, action);
 		if (target_output) {
 			view_move_to_output(view, target_output);
 		}
@@ -1458,9 +1452,9 @@ run_action(struct view *view, struct server *server, struct action *action,
 		}
 		break;
 	case ACTION_TYPE_FOCUS_OUTPUT: {
-		struct output *output = output_nearest_to_cursor(server);
+		struct output *output = output_nearest_to_cursor();
 		struct output *target_output =
-			get_target_output(output, server, action);
+			get_target_output(output, action);
 		if (target_output) {
 			desktop_focus_output(target_output);
 		}
@@ -1473,7 +1467,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 			 * We delay the selection and execution of the
 			 * branch until we get a response from the user.
 			 */
-			action_prompt_create(view, server, action);
+			action_prompt_create(view, action);
 		} else if (view) {
 			struct wl_list *actions;
 			if (match_queries(view, action)) {
@@ -1482,7 +1476,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 				actions = action_get_actionlist(action, "else");
 			}
 			if (actions) {
-				actions_run(view, server, actions, ctx);
+				actions_run(view, actions, ctx);
 			}
 		}
 		break;
@@ -1493,7 +1487,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 
 		struct wl_array views;
 		wl_array_init(&views);
-		view_array_append(server, &views, LAB_VIEW_CRITERIA_NONE);
+		view_array_append(&views, LAB_VIEW_CRITERIA_NONE);
 
 		struct view **item;
 		wl_array_for_each(item, &views) {
@@ -1504,14 +1498,14 @@ run_action(struct view *view, struct server *server, struct action *action,
 				actions = action_get_actionlist(action, "else");
 			}
 			if (actions) {
-				actions_run(*item, server, actions, ctx);
+				actions_run(*item, actions, ctx);
 			}
 		}
 		wl_array_release(&views);
 		if (!matches) {
 			actions = action_get_actionlist(action, "none");
 			if (actions) {
-				actions_run(view, server, actions, NULL);
+				actions_run(view, actions, NULL);
 			}
 		}
 		break;
@@ -1520,7 +1514,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 		/* TODO: rename this argument to "outputName" */
 		const char *output_name =
 			action_get_str(action, "output_name", NULL);
-		output_virtual_add(server, output_name,
+		output_virtual_add(output_name,
 				/*store_wlr_output*/ NULL);
 		break;
 	}
@@ -1528,7 +1522,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 		/* TODO: rename this argument to "outputName" */
 		const char *output_name =
 			action_get_str(action, "output_name", NULL);
-		output_virtual_remove(server, output_name);
+		output_virtual_remove(output_name);
 		break;
 	}
 	case ACTION_TYPE_AUTO_PLACE:
@@ -1575,14 +1569,14 @@ run_action(struct view *view, struct server *server, struct action *action,
 		}
 		break;
 	case ACTION_TYPE_ENABLE_SCROLL_WHEEL_EMULATION:
-		server->seat.cursor_scroll_wheel_emulation = true;
+		g_server.seat.cursor_scroll_wheel_emulation = true;
 		break;
 	case ACTION_TYPE_DISABLE_SCROLL_WHEEL_EMULATION:
-		server->seat.cursor_scroll_wheel_emulation = false;
+		g_server.seat.cursor_scroll_wheel_emulation = false;
 		break;
 	case ACTION_TYPE_TOGGLE_SCROLL_WHEEL_EMULATION:
-		server->seat.cursor_scroll_wheel_emulation =
-			!server->seat.cursor_scroll_wheel_emulation;
+		g_server.seat.cursor_scroll_wheel_emulation =
+			!g_server.seat.cursor_scroll_wheel_emulation;
 		break;
 	case ACTION_TYPE_ENABLE_TABLET_MOUSE_EMULATION:
 		rc.tablet.force_mouse_emulation = true;
@@ -1594,23 +1588,23 @@ run_action(struct view *view, struct server *server, struct action *action,
 		rc.tablet.force_mouse_emulation = !rc.tablet.force_mouse_emulation;
 		break;
 	case ACTION_TYPE_TOGGLE_MAGNIFY:
-		magnifier_toggle(server);
+		magnifier_toggle();
 		break;
 	case ACTION_TYPE_ZOOM_IN:
-		magnifier_set_scale(server, MAGNIFY_INCREASE);
+		magnifier_set_scale(MAGNIFY_INCREASE);
 		break;
 	case ACTION_TYPE_ZOOM_OUT:
-		magnifier_set_scale(server, MAGNIFY_DECREASE);
+		magnifier_set_scale(MAGNIFY_DECREASE);
 		break;
 	case ACTION_TYPE_WARP_CURSOR: {
 		const char *to = action_get_str(action, "to", "output");
 		const char *x = action_get_str(action, "x", "center");
 		const char *y = action_get_str(action, "y", "center");
-		warp_cursor(server, view, to, x, y);
+		warp_cursor(view, to, x, y);
 		break;
 	}
 	case ACTION_TYPE_HIDE_CURSOR:
-		cursor_set_visible(&server->seat, false);
+		cursor_set_visible(&g_server.seat, false);
 		break;
 	case ACTION_TYPE_INVALID:
 		wlr_log(WLR_ERROR, "Not executing unknown action");
@@ -1628,8 +1622,7 @@ run_action(struct view *view, struct server *server, struct action *action,
 }
 
 void
-actions_run(struct view *activator, struct server *server,
-	struct wl_list *actions, struct cursor_context *cursor_ctx)
+actions_run(struct view *activator, struct wl_list *actions, struct cursor_context *cursor_ctx)
 {
 	if (!actions) {
 		wlr_log(WLR_ERROR, "empty actions");
@@ -1646,7 +1639,7 @@ actions_run(struct view *activator, struct server *server,
 
 	struct action *action;
 	wl_list_for_each(action, actions, link) {
-		if (server->input_mode == LAB_INPUT_STATE_CYCLE
+		if (g_server.input_mode == LAB_INPUT_STATE_CYCLE
 				&& action->type != ACTION_TYPE_NEXT_WINDOW
 				&& action->type != ACTION_TYPE_PREVIOUS_WINDOW) {
 			wlr_log(WLR_INFO, "Only NextWindow or PreviousWindow "
@@ -1661,8 +1654,8 @@ actions_run(struct view *activator, struct server *server,
 		 * Refetch view because it may have been changed due to the
 		 * previous action
 		 */
-		struct view *view = view_for_action(activator, server, action, &ctx);
+		struct view *view = view_for_action(activator, action, &ctx);
 
-		run_action(view, server, action, &ctx);
+		run_action(view, action, &ctx);
 	}
 }

src/config/keybind.c

@@ -121,9 +121,9 @@ update_keycodes_iter(struct xkb_keymap *keymap, xkb_keycode_t key, void *data)
 }
 
 void
-keybind_update_keycodes(struct server *server)
+keybind_update_keycodes(void)
 {
-	struct xkb_state *state = server->seat.keyboard_group->keyboard.xkb_state;
+	struct xkb_state *state = g_server.seat.keyboard_group->keyboard.xkb_state;
 	struct xkb_keymap *keymap = xkb_state_get_keymap(state);
 
 	struct keybind *keybind;

src/config/session.c

@@ -185,7 +185,7 @@ backend_check_drm(struct wlr_backend *backend, void *is_drm)
 }
 
 static bool
-should_update_activation(struct server *server)
+should_update_activation(void)
 {
 	static const char *act_env = "LABWC_UPDATE_ACTIVATION_ENV";
 	char *env = getenv(act_env);
@@ -204,14 +204,14 @@ should_update_activation(struct server *server)
 
 	/* With no valid preference, update when a DRM backend is in use */
 	bool have_drm = false;
-	wlr_multi_for_each_backend(server->backend, backend_check_drm, &have_drm);
+	wlr_multi_for_each_backend(g_server.backend, backend_check_drm, &have_drm);
 	return have_drm;
 }
 
 static void
-update_activation_env(struct server *server, bool initialize)
+update_activation_env(bool initialize)
 {
-	if (!should_update_activation(server)) {
+	if (!should_update_activation()) {
 		return;
 	}
 
@@ -312,18 +312,18 @@ session_run_script(const char *script)
 }
 
 void
-session_autostart_init(struct server *server)
+session_autostart_init(void)
 {
 	/* Update dbus and systemd user environment, each may fail gracefully */
-	update_activation_env(server, /* initialize */ true);
+	update_activation_env(/* initialize */ true);
 	session_run_script("autostart");
 }
 
 void
-session_shutdown(struct server *server)
+session_shutdown(void)
 {
 	session_run_script("shutdown");
 
 	/* Clear the dbus and systemd user environment, each may fail gracefully */
-	update_activation_env(server, /* initialize */ false);
+	update_activation_env(/* initialize */ false);
 }

src/cycle/cycle.c

@@ -18,17 +18,16 @@
 #include "theme.h"
 #include "view.h"
 
-static bool init_cycle(struct server *server, struct cycle_filter filter);
-static void update_cycle(struct server *server);
-static void destroy_cycle(struct server *server);
+static bool init_cycle(struct cycle_filter filter);
+static void update_cycle(void);
+static void destroy_cycle(void);
 
 static void
 update_preview_outlines(struct view *view)
 {
 	/* Create / Update preview outline tree */
-	struct server *server = view->server;
-	struct theme *theme = server->theme;
-	struct lab_scene_rect *rect = view->server->cycle.preview_outline;
+	struct theme *theme = g_server.theme;
+	struct lab_scene_rect *rect = g_server.cycle.preview_outline;
 	if (!rect) {
 		struct lab_scene_rect_options opts = {
 			.border_colors = (float *[3]) {
@@ -39,10 +38,10 @@ update_preview_outlines(struct view *view)
 			.nr_borders = 3,
 			.border_width = theme->osd_window_switcher_preview_border_width,
 		};
-		rect = lab_scene_rect_create(&server->scene->tree, &opts);
+		rect = lab_scene_rect_create(&g_server.scene->tree, &opts);
 		wlr_scene_node_place_above(&rect->tree->node,
-			&server->cycle_preview_tree->node);
-		server->cycle.preview_outline = rect;
+			&g_server.cycle_preview_tree->node);
+		g_server.cycle.preview_outline = rect;
 	}
 
 	struct wlr_box geo = ssd_max_extents(view);
@@ -52,21 +51,21 @@ update_preview_outlines(struct view *view)
 
 /* Returns the view to select next in the window switcher. */
 static struct view *
-get_next_selected_view(struct server *server, enum lab_cycle_dir dir)
+get_next_selected_view(enum lab_cycle_dir dir)
 {
-	struct cycle_state *cycle = &server->cycle;
+	struct cycle_state *cycle = &g_server.cycle;
 	assert(cycle->selected_view);
-	assert(!wl_list_empty(&server->cycle.views));
+	assert(!wl_list_empty(&g_server.cycle.views));
 
 	struct wl_list *link;
 	if (dir == LAB_CYCLE_DIR_FORWARD) {
 		link = cycle->selected_view->cycle_link.next;
-		if (link == &server->cycle.views) {
+		if (link == &g_server.cycle.views) {
 			link = link->next;
 		}
 	} else {
 		link = cycle->selected_view->cycle_link.prev;
-		if (link == &server->cycle.views) {
+		if (link == &g_server.cycle.views) {
 			link = link->prev;
 		}
 	}
@@ -83,22 +82,22 @@ get_first_view(struct wl_list *views)
 }
 
 void
-cycle_reinitialize(struct server *server)
+cycle_reinitialize(void)
 {
-	struct cycle_state *cycle = &server->cycle;
+	struct cycle_state *cycle = &g_server.cycle;
 
-	if (server->input_mode != LAB_INPUT_STATE_CYCLE) {
+	if (g_server.input_mode != LAB_INPUT_STATE_CYCLE) {
 		/* OSD not active, no need for clean up */
 		return;
 	}
 
 	struct view *selected_view = cycle->selected_view;
 	struct view *selected_view_prev =
-		get_next_selected_view(server, LAB_CYCLE_DIR_BACKWARD);
+		get_next_selected_view(LAB_CYCLE_DIR_BACKWARD);
 	struct cycle_filter filter = cycle->filter;
 
-	destroy_cycle(server);
-	if (init_cycle(server, filter)) {
+	destroy_cycle();
+	if (init_cycle(filter)) {
 		/*
 		 * Preserve the selected view (or its previous view) if it's
 		 * still in the cycle list
@@ -110,104 +109,104 @@ cycle_reinitialize(struct server *server)
 		} else {
 			/* should be unreachable */
 			wlr_log(WLR_ERROR, "could not find view to select");
-			cycle->selected_view = get_first_view(&server->cycle.views);
+			cycle->selected_view = get_first_view(&g_server.cycle.views);
 		}
-		update_cycle(server);
+		update_cycle();
 	} else {
 		/* Failed to re-init window switcher, exit */
-		cycle_finish(server, /*switch_focus*/ false);
+		cycle_finish(/*switch_focus*/ false);
 	}
 }
 
 void
-cycle_on_cursor_release(struct server *server, struct wlr_scene_node *node)
+cycle_on_cursor_release(struct wlr_scene_node *node)
 {
-	assert(server->input_mode == LAB_INPUT_STATE_CYCLE);
+	assert(g_server.input_mode == LAB_INPUT_STATE_CYCLE);
 
 	struct cycle_osd_item *item = node_cycle_osd_item_from_node(node);
-	server->cycle.selected_view = item->view;
-	cycle_finish(server, /*switch_focus*/ true);
+	g_server.cycle.selected_view = item->view;
+	cycle_finish(/*switch_focus*/ true);
 }
 
 static void
-restore_preview_node(struct server *server)
+restore_preview_node(void)
 {
-	if (server->cycle.preview_node) {
-		wlr_scene_node_reparent(server->cycle.preview_node,
-			server->cycle.preview_dummy->parent);
-		wlr_scene_node_place_above(server->cycle.preview_node,
-			server->cycle.preview_dummy);
-		wlr_scene_node_destroy(server->cycle.preview_dummy);
+	if (g_server.cycle.preview_node) {
+		wlr_scene_node_reparent(g_server.cycle.preview_node,
+			g_server.cycle.preview_dummy->parent);
+		wlr_scene_node_place_above(g_server.cycle.preview_node,
+			g_server.cycle.preview_dummy);
+		wlr_scene_node_destroy(g_server.cycle.preview_dummy);
 
 		/* Node was disabled / minimized before, disable again */
-		if (!server->cycle.preview_was_enabled) {
-			wlr_scene_node_set_enabled(server->cycle.preview_node, false);
+		if (!g_server.cycle.preview_was_enabled) {
+			wlr_scene_node_set_enabled(g_server.cycle.preview_node, false);
 		}
-		if (server->cycle.preview_was_shaded) {
-			struct view *view = node_view_from_node(server->cycle.preview_node);
+		if (g_server.cycle.preview_was_shaded) {
+			struct view *view = node_view_from_node(g_server.cycle.preview_node);
 			view_set_shade(view, true);
 		}
-		server->cycle.preview_node = NULL;
-		server->cycle.preview_dummy = NULL;
-		server->cycle.preview_was_enabled = false;
-		server->cycle.preview_was_shaded = false;
+		g_server.cycle.preview_node = NULL;
+		g_server.cycle.preview_dummy = NULL;
+		g_server.cycle.preview_was_enabled = false;
+		g_server.cycle.preview_was_shaded = false;
 	}
 }
 
 void
-cycle_begin(struct server *server, enum lab_cycle_dir direction,
+cycle_begin(enum lab_cycle_dir direction,
 		struct cycle_filter filter)
 {
-	if (server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		return;
 	}
 
-	if (!init_cycle(server, filter)) {
+	if (!init_cycle(filter)) {
 		return;
 	}
 
-	struct view *active_view = server->active_view;
+	struct view *active_view = g_server.active_view;
 	if (active_view && active_view->cycle_link.next) {
 		/* Select the active view it's in the cycle list */
-		server->cycle.selected_view = active_view;
+		g_server.cycle.selected_view = active_view;
 	} else {
 		/* Otherwise, select the first view in the cycle list */
-		server->cycle.selected_view = get_first_view(&server->cycle.views);
+		g_server.cycle.selected_view = get_first_view(&g_server.cycle.views);
 	}
 	/* Pre-select the next view in the given direction */
-	server->cycle.selected_view = get_next_selected_view(server, direction);
+	g_server.cycle.selected_view = get_next_selected_view(direction);
 
-	seat_focus_override_begin(&server->seat,
+	seat_focus_override_begin(&g_server.seat,
 		LAB_INPUT_STATE_CYCLE, LAB_CURSOR_DEFAULT);
-	update_cycle(server);
+	update_cycle();
 
 	/* Update cursor, in case it is within the area covered by OSD */
-	cursor_update_focus(server);
+	cursor_update_focus();
 }
 
 void
-cycle_step(struct server *server, enum lab_cycle_dir direction)
+cycle_step(enum lab_cycle_dir direction)
 {
-	assert(server->input_mode == LAB_INPUT_STATE_CYCLE);
+	assert(g_server.input_mode == LAB_INPUT_STATE_CYCLE);
 
-	server->cycle.selected_view = get_next_selected_view(server, direction);
-	update_cycle(server);
+	g_server.cycle.selected_view = get_next_selected_view(direction);
+	update_cycle();
 }
 
 void
-cycle_finish(struct server *server, bool switch_focus)
+cycle_finish(bool switch_focus)
 {
-	if (server->input_mode != LAB_INPUT_STATE_CYCLE) {
+	if (g_server.input_mode != LAB_INPUT_STATE_CYCLE) {
 		return;
 	}
 
-	struct view *selected_view = server->cycle.selected_view;
-	destroy_cycle(server);
+	struct view *selected_view = g_server.cycle.selected_view;
+	destroy_cycle();
 
-	seat_focus_override_end(&server->seat, /*restore_focus*/ false);
+	seat_focus_override_end(&g_server.seat, /*restore_focus*/ false);
 
 	/* Hiding OSD may need a cursor change */
-	cursor_update_focus(server);
+	cursor_update_focus();
 
 	if (switch_focus && selected_view) {
 		if (rc.window_switcher.unshade) {
@@ -222,11 +221,10 @@ preview_selected_view(struct view *view)
 {
 	assert(view);
 	assert(view->scene_tree);
-	struct server *server = view->server;
-	struct cycle_state *cycle = &server->cycle;
+	struct cycle_state *cycle = &g_server.cycle;
 
 	/* Move previous selected node back to its original place */
-	restore_preview_node(server);
+	restore_preview_node();
 
 	cycle->preview_node = &view->scene_tree->node;
 
@@ -246,7 +244,7 @@ preview_selected_view(struct view *view)
 	}
 
 	wlr_scene_node_reparent(cycle->preview_node,
-		view->server->cycle_preview_tree);
+		g_server.cycle_preview_tree);
 
 	/* Finally raise selected node to the top */
 	wlr_scene_node_raise_to_top(cycle->preview_node);
@@ -265,8 +263,7 @@ get_osd_impl(void)
 }
 
 static uint64_t
-get_outputs_by_filter(struct server *server,
-		enum cycle_output_filter output_filter)
+get_outputs_by_filter(enum cycle_output_filter output_filter)
 {
 	struct output *output = NULL;
 
@@ -274,15 +271,15 @@ get_outputs_by_filter(struct server *server,
 	case CYCLE_OUTPUT_ALL:
 		break;
 	case CYCLE_OUTPUT_CURSOR:
-		output = output_nearest_to_cursor(server);
+		output = output_nearest_to_cursor();
 		break;
 	case CYCLE_OUTPUT_FOCUSED: {
-		struct view *view = server->active_view;
+		struct view *view = g_server.active_view;
 		if (view && output_is_usable(view->output)) {
 			output = view->output;
 		} else {
 			/* Fallback to pointer */
-			output = output_nearest_to_cursor(server);
+			output = output_nearest_to_cursor();
 		}
 		break;
 	}
@@ -327,7 +324,7 @@ handle_osd_tree_destroy(struct wl_listener *listener, void *data)
 
 /* Return false on failure */
 static bool
-init_cycle(struct server *server, struct cycle_filter filter)
+init_cycle(struct cycle_filter filter)
 {
 	enum lab_view_criteria criteria =
 		LAB_VIEW_CRITERIA_NO_SKIP_WINDOW_SWITCHER
@@ -337,15 +334,15 @@ init_cycle(struct server *server, struct cycle_filter filter)
 	}
 
 	uint64_t cycle_outputs =
-		get_outputs_by_filter(server, filter.output);
+		get_outputs_by_filter(filter.output);
 
 	const char *cycle_app_id = NULL;
-	if (filter.app_id == CYCLE_APP_ID_CURRENT && server->active_view) {
-		cycle_app_id = server->active_view->app_id;
+	if (filter.app_id == CYCLE_APP_ID_CURRENT && g_server.active_view) {
+		cycle_app_id = g_server.active_view->app_id;
 	}
 
 	struct view *view;
-	for_each_view(view, &server->views, criteria) {
+	for_each_view(view, &g_server.views, criteria) {
 		if (filter.output != CYCLE_OUTPUT_ALL) {
 			if (!view->output || !(cycle_outputs & view->output->id_bit)) {
 				continue;
@@ -356,23 +353,22 @@ init_cycle(struct server *server, struct cycle_filter filter)
 		}
 
 		if (rc.window_switcher.order == WINDOW_SWITCHER_ORDER_AGE) {
-			insert_view_ordered_by_age(&server->cycle.views, view);
+			insert_view_ordered_by_age(&g_server.cycle.views, view);
 		} else {
-			wl_list_append(&server->cycle.views, &view->cycle_link);
+			wl_list_append(&g_server.cycle.views, &view->cycle_link);
 		}
 	}
-	if (wl_list_empty(&server->cycle.views)) {
+	if (wl_list_empty(&g_server.cycle.views)) {
 		wlr_log(WLR_DEBUG, "no views to switch between");
 		return false;
 	}
-	server->cycle.filter = filter;
+	g_server.cycle.filter = filter;
 
 	if (rc.window_switcher.osd.show) {
 		/* Create OSD */
-		uint64_t osd_outputs = get_outputs_by_filter(server,
-				rc.window_switcher.osd.output_filter);
+		uint64_t osd_outputs = get_outputs_by_filter(rc.window_switcher.osd.output_filter);
 		struct output *output;
-		wl_list_for_each(output, &server->outputs, link) {
+		wl_list_for_each(output, &g_server.outputs, link) {
 			if (!(osd_outputs & output->id_bit)) {
 				continue;
 			}
@@ -381,7 +377,7 @@ init_cycle(struct server *server, struct cycle_filter filter)
 			}
 
 			struct cycle_osd_output *osd_output = znew(*osd_output);
-			wl_list_append(&server->cycle.osd_outputs, &osd_output->link);
+			wl_list_append(&g_server.cycle.osd_outputs, &osd_output->link);
 			osd_output->output = output;
 			wl_list_init(&osd_output->items);
 
@@ -397,9 +393,9 @@ init_cycle(struct server *server, struct cycle_filter filter)
 }
 
 static void
-update_cycle(struct server *server)
+update_cycle(void)
 {
-	struct cycle_state *cycle = &server->cycle;
+	struct cycle_state *cycle = &g_server.cycle;
 
 	if (rc.window_switcher.osd.show) {
 		struct cycle_osd_output *osd_output;
@@ -420,29 +416,29 @@ update_cycle(struct server *server)
 	}
 }
 
-/* Resets all the states in server->cycle */
+/* Resets all the states in g_server.cycle */
 static void
-destroy_cycle(struct server *server)
+destroy_cycle(void)
 {
 	struct cycle_osd_output *osd_output, *tmp;
-	wl_list_for_each_safe(osd_output, tmp, &server->cycle.osd_outputs, link) {
+	wl_list_for_each_safe(osd_output, tmp, &g_server.cycle.osd_outputs, link) {
 		/* calls handle_osd_tree_destroy() */
 		wlr_scene_node_destroy(&osd_output->tree->node);
 	}
 
-	restore_preview_node(server);
+	restore_preview_node();
 
-	if (server->cycle.preview_outline) {
-		wlr_scene_node_destroy(&server->cycle.preview_outline->tree->node);
+	if (g_server.cycle.preview_outline) {
+		wlr_scene_node_destroy(&g_server.cycle.preview_outline->tree->node);
 	}
 
 	struct view *view, *tmp2;
-	wl_list_for_each_safe(view, tmp2, &server->cycle.views, cycle_link) {
+	wl_list_for_each_safe(view, tmp2, &g_server.cycle.views, cycle_link) {
 		wl_list_remove(&view->cycle_link);
 		view->cycle_link = (struct wl_list){0};
 	}
 
-	server->cycle = (struct cycle_state){0};
-	wl_list_init(&server->cycle.views);
-	wl_list_init(&server->cycle.osd_outputs);
+	g_server.cycle = (struct cycle_state){0};
+	wl_list_init(&g_server.cycle.views);
+	wl_list_init(&g_server.cycle.osd_outputs);
 }

src/cycle/osd-classic.c

@@ -28,11 +28,11 @@ struct cycle_osd_classic_item {
 };
 
 static void
-create_fields_scene(struct server *server, struct view *view,
+create_fields_scene(struct view *view,
 		struct wlr_scene_tree *parent, const float *text_color,
 		const float *bg_color, int field_widths_sum, int x, int y)
 {
-	struct theme *theme = server->theme;
+	struct theme *theme = g_server.theme;
 	struct window_switcher_classic_theme *switcher_theme =
 		&theme->osd_window_switcher_classic;
 
@@ -46,8 +46,7 @@ create_fields_scene(struct server *server, struct view *view,
 			int icon_size = MIN(field_width,
 				switcher_theme->item_icon_size);
 			struct scaled_icon_buffer *icon_buffer =
-				scaled_icon_buffer_create(parent,
-					server, icon_size, icon_size);
+				scaled_icon_buffer_create(parent, icon_size, icon_size);
 			scaled_icon_buffer_set_view(icon_buffer, view);
 			node = &icon_buffer->scene_buffer->node;
 			height = icon_size;
@@ -81,17 +80,16 @@ static void
 cycle_osd_classic_init(struct cycle_osd_output *osd_output)
 {
 	struct output *output = osd_output->output;
-	struct server *server = output->server;
-	struct theme *theme = server->theme;
+	struct theme *theme = g_server.theme;
 	struct window_switcher_classic_theme *switcher_theme =
 		&theme->osd_window_switcher_classic;
 	int padding = theme->osd_border_width + switcher_theme->padding;
 	bool show_workspace = wl_list_length(&rc.workspace_config.workspaces) > 1;
-	const char *workspace_name = server->workspaces.current->name;
-	int nr_views = wl_list_length(&server->cycle.views);
+	const char *workspace_name = g_server.workspaces.current->name;
+	int nr_views = wl_list_length(&g_server.cycle.views);
 
 	struct wlr_box output_box;
-	wlr_output_layout_get_box(server->output_layout, output->wlr_output,
+	wlr_output_layout_get_box(g_server.output_layout, output->wlr_output,
 		&output_box);
 
 	int w = switcher_theme->width;
@@ -166,7 +164,7 @@ cycle_osd_classic_init(struct cycle_osd_output *osd_output)
 
 	/* Draw text for each node */
 	struct view *view;
-	wl_list_for_each(view, &server->cycle.views, cycle_link) {
+	wl_list_for_each(view, &g_server.cycle.views, cycle_link) {
 		struct cycle_osd_classic_item *item = znew(*item);
 		wl_list_append(&osd_output->items, &item->base.link);
 		item->base.view = view;
@@ -214,9 +212,9 @@ cycle_osd_classic_init(struct cycle_osd_output *osd_output)
 			w - 2 * padding, switcher_theme->item_height, (float[4]) {0});
 		wlr_scene_node_set_position(&hitbox->node, padding, y);
 
-		create_fields_scene(server, view, item->normal_tree,
+		create_fields_scene(view, item->normal_tree,
 			text_color, bg_color, field_widths_sum, x, y);
-		create_fields_scene(server, view, item->active_tree,
+		create_fields_scene(view, item->active_tree,
 			text_color, active_bg_color, field_widths_sum, x, y);
 
 		y += switcher_theme->item_height;
@@ -243,12 +241,11 @@ error:;
 static void
 cycle_osd_classic_update(struct cycle_osd_output *osd_output)
 {
-	struct server *server = osd_output->output->server;
 	cycle_osd_scroll_update(osd_output);
 
 	struct cycle_osd_classic_item *item;
 	wl_list_for_each(item, &osd_output->items, base.link) {
-		bool active = item->base.view == server->cycle.selected_view;
+		bool active = item->base.view == g_server.cycle.selected_view;
 		wlr_scene_node_set_enabled(&item->normal_tree->node, !active);
 		wlr_scene_node_set_enabled(&item->active_tree->node, active);
 	}

src/cycle/osd-field.c

@@ -45,7 +45,7 @@ static const char *
 get_desktop_name(struct view *view)
 {
 #if HAVE_LIBSFDO
-	const char *name = desktop_entry_name_lookup(view->server, view->app_id);
+	const char *name = desktop_entry_name_lookup(view->app_id);
 	if (name) {
 		return name;
 	}
@@ -148,7 +148,7 @@ static void
 field_set_output_short(struct buf *buf, struct view *view, const char *format)
 {
 	/* custom type conversion-specifier: o */
-	if (wl_list_length(&view->server->outputs) > 1 &&
+	if (wl_list_length(&g_server.outputs) > 1 &&
 			output_is_usable(view->output)) {
 		buf_add(buf, view->output->wlr_output->name);
 	}

src/cycle/osd-scroll.c

@@ -42,12 +42,10 @@ cycle_osd_scroll_init(struct cycle_osd_output *osd_output, struct wlr_box bar_ar
 static int
 get_cycle_idx(struct cycle_osd_output *osd_output)
 {
-	struct server *server = osd_output->output->server;
-
 	int idx = 0;
 	struct cycle_osd_item *item;
 	wl_list_for_each(item, &osd_output->items, link) {
-		if (item->view == server->cycle.selected_view) {
+		if (item->view == g_server.cycle.selected_view) {
 			return idx;
 		}
 		idx++;

src/cycle/osd-thumbnail.c

@@ -28,7 +28,7 @@ struct cycle_osd_thumbnail_item {
 };
 
 static void
-render_node(struct server *server, struct wlr_render_pass *pass,
+render_node(struct wlr_render_pass *pass,
 		struct wlr_scene_node *node, int x, int y)
 {
 	switch (node->type) {
@@ -36,7 +36,7 @@ render_node(struct server *server, struct wlr_render_pass *pass,
 		struct wlr_scene_tree *tree = wlr_scene_tree_from_node(node);
 		struct wlr_scene_node *child;
 		wl_list_for_each(child, &tree->children, link) {
-			render_node(server, pass, child, x + node->x, y + node->y);
+			render_node(pass, child, x + node->x, y + node->y);
 		}
 		break;
 	}
@@ -47,7 +47,7 @@ render_node(struct server *server, struct wlr_render_pass *pass,
 			break;
 		}
 		struct wlr_texture *texture = wlr_texture_from_buffer(
-			server->renderer, scene_buffer->buffer);
+			g_server.renderer, scene_buffer->buffer);
 		if (!texture) {
 			break;
 		}
@@ -82,13 +82,12 @@ render_thumb(struct output *output, struct view *view)
 		 */
 		return NULL;
 	}
-	struct server *server = output->server;
-	struct wlr_buffer *buffer = wlr_allocator_create_buffer(server->allocator,
+	struct wlr_buffer *buffer = wlr_allocator_create_buffer(g_server.allocator,
 		view->current.width, view->current.height,
 		&output->wlr_output->swapchain->format);
 	struct wlr_render_pass *pass = wlr_renderer_begin_buffer_pass(
-		server->renderer, buffer, NULL);
-	render_node(server, pass, &view->content_tree->node, 0, 0);
+		g_server.renderer, buffer, NULL);
+	render_node(pass, &view->content_tree->node, 0, 0);
 	if (!wlr_render_pass_submit(pass)) {
 		wlr_log(WLR_ERROR, "failed to submit render pass");
 		wlr_buffer_drop(buffer);
@@ -120,8 +119,7 @@ static struct cycle_osd_thumbnail_item *
 create_item_scene(struct wlr_scene_tree *parent, struct view *view,
 		struct cycle_osd_output *osd_output)
 {
-	struct server *server = osd_output->output->server;
-	struct theme *theme = server->theme;
+	struct theme *theme = g_server.theme;
 	struct window_switcher_thumbnail_theme *switcher_theme =
 		&theme->osd_window_switcher_thumbnail;
 	int padding = theme->border_width + switcher_theme->item_padding;
@@ -185,7 +183,7 @@ create_item_scene(struct wlr_scene_tree *parent, struct view *view,
 	/* icon */
 	int icon_size = switcher_theme->item_icon_size;
 	struct scaled_icon_buffer *icon_buffer =
-		scaled_icon_buffer_create(tree, server, icon_size, icon_size);
+		scaled_icon_buffer_create(tree, icon_size, icon_size);
 	scaled_icon_buffer_set_view(icon_buffer, view);
 	int x = (switcher_theme->item_width - icon_size) / 2;
 	int y = title_y - padding - icon_size + 10; /* slide by 10px */
@@ -198,7 +196,7 @@ static void
 get_items_geometry(struct output *output, int nr_thumbs,
 		int *nr_cols, int *nr_rows, int *nr_visible_rows)
 {
-	struct theme *theme = output->server->theme;
+	struct theme *theme = g_server.theme;
 	struct window_switcher_thumbnail_theme *switcher_theme =
 		&theme->osd_window_switcher_thumbnail;
 	int output_width, output_height;
@@ -234,8 +232,7 @@ static void
 cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
 {
 	struct output *output = osd_output->output;
-	struct server *server = output->server;
-	struct theme *theme = server->theme;
+	struct theme *theme = g_server.theme;
 	struct window_switcher_thumbnail_theme *switcher_theme =
 		&theme->osd_window_switcher_thumbnail;
 	int padding = theme->osd_border_width + switcher_theme->padding;
@@ -243,7 +240,7 @@ cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
 	osd_output->tree = lab_wlr_scene_tree_create(output->cycle_osd_tree);
 	osd_output->items_tree = lab_wlr_scene_tree_create(osd_output->tree);
 
-	int nr_views = wl_list_length(&server->cycle.views);
+	int nr_views = wl_list_length(&g_server.cycle.views);
 	assert(nr_views > 0);
 	int nr_cols, nr_rows, nr_visible_rows;
 	get_items_geometry(output, nr_views, &nr_cols, &nr_rows, &nr_visible_rows);
@@ -251,7 +248,7 @@ cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
 	/* items */
 	struct view *view;
 	int index = 0;
-	wl_list_for_each(view, &server->cycle.views, cycle_link) {
+	wl_list_for_each(view, &g_server.cycle.views, cycle_link) {
 		struct cycle_osd_thumbnail_item *item = create_item_scene(
 			osd_output->items_tree, view, osd_output);
 		if (!item) {
@@ -292,7 +289,7 @@ cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
 
 	/* center */
 	struct wlr_box output_box;
-	wlr_output_layout_get_box(server->output_layout, output->wlr_output,
+	wlr_output_layout_get_box(g_server.output_layout, output->wlr_output,
 		&output_box);
 	int lx = output_box.x + (output_box.width - bg_opts.width) / 2;
 	int ly = output_box.y + (output_box.height - bg_opts.height) / 2;
@@ -302,12 +299,11 @@ cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
 static void
 cycle_osd_thumbnail_update(struct cycle_osd_output *osd_output)
 {
-	struct server *server = osd_output->output->server;
 	cycle_osd_scroll_update(osd_output);
 
 	struct cycle_osd_thumbnail_item *item;
 	wl_list_for_each(item, &osd_output->items, base.link) {
-		bool active = (item->base.view == server->cycle.selected_view);
+		bool active = (item->base.view == g_server.cycle.selected_view);
 		wlr_scene_node_set_enabled(&item->active_bg->tree->node, active);
 		wlr_scene_node_set_enabled(
 			&item->active_label->scene_buffer->node, active);

src/debug.c

@@ -89,10 +89,10 @@ get_view_part(struct view *view, struct wlr_scene_node *node)
 }
 
 static struct workspace *
-get_workspace_from_node(struct server *server, struct wlr_scene_node *node)
+get_workspace_from_node(struct wlr_scene_node *node)
 {
 	struct workspace *workspace;
-	wl_list_for_each(workspace, &server->workspaces.all, link) {
+	wl_list_for_each(workspace, &g_server.workspaces.all, link) {
 		if (&workspace->tree->node == node) {
 			return workspace;
 		}
@@ -101,31 +101,31 @@ get_workspace_from_node(struct server *server, struct wlr_scene_node *node)
 }
 
 static const char *
-get_special(struct server *server, struct wlr_scene_node *node)
+get_special(struct wlr_scene_node *node)
 {
 	struct wlr_scene_tree *grand_parent =
 		node->parent ? node->parent->node.parent : NULL;
 	struct wlr_scene_tree *grand_grand_parent =
 		grand_parent ? grand_parent->node.parent : NULL;
-	if (node == &server->scene->tree.node) {
-		return "server->scene";
+	if (node == &g_server.scene->tree.node) {
+		return "g_server.scene";
 	}
-	if (node == &server->menu_tree->node) {
-		return "server->menu_tree";
+	if (node == &g_server.menu_tree->node) {
+		return "g_server.menu_tree";
 	}
-	if (node == &server->workspace_tree->node) {
-		return "server->workspace_tree";
+	if (node == &g_server.workspace_tree->node) {
+		return "g_server.workspace_tree";
 	}
-	if (node->parent == server->workspace_tree) {
-		struct workspace *workspace = get_workspace_from_node(server, node);
+	if (node->parent == g_server.workspace_tree) {
+		struct workspace *workspace = get_workspace_from_node(node);
 		if (workspace) {
 			return workspace->name;
 		}
 		return "unknown workspace";
 	}
-	if (grand_parent == server->workspace_tree) {
+	if (grand_parent == g_server.workspace_tree) {
 		struct workspace *workspace =
-			get_workspace_from_node(server, &node->parent->node);
+			get_workspace_from_node(&node->parent->node);
 		if (workspace) {
 			struct wlr_scene_tree **trees = workspace->view_trees;
 			if (node == &trees[VIEW_LAYER_NORMAL]->node) {
@@ -138,9 +138,9 @@ get_special(struct server *server, struct wlr_scene_node *node)
 		}
 		return "unknown tree";
 	}
-	if (node->parent == &server->scene->tree) {
+	if (node->parent == &g_server.scene->tree) {
 		struct output *output;
-		wl_list_for_each(output, &server->outputs, link) {
+		wl_list_for_each(output, &g_server.outputs, link) {
 			if (node == &output->cycle_osd_tree->node) {
 				return "output->osd_tree";
 			}
@@ -157,33 +157,33 @@ get_special(struct server *server, struct wlr_scene_node *node)
 			}
 		}
 	}
-	if (node == &server->xdg_popup_tree->node) {
-		return "server->xdg_popup_tree";
+	if (node == &g_server.xdg_popup_tree->node) {
+		return "g_server.xdg_popup_tree";
 	}
-	if (node == &server->seat.drag.icons->node) {
+	if (node == &g_server.seat.drag.icons->node) {
 		return "seat->drag.icons";
 	}
-	if (server->seat.overlay.rect
-			&& node == &server->seat.overlay.rect->tree->node) {
+	if (g_server.seat.overlay.rect
+			&& node == &g_server.seat.overlay.rect->tree->node) {
 		/* Created on-demand */
 		return "seat->overlay.rect";
 	}
-	if (server->seat.input_method_relay->popup_tree
-			&& node == &server->seat.input_method_relay->popup_tree->node) {
+	if (g_server.seat.input_method_relay->popup_tree
+			&& node == &g_server.seat.input_method_relay->popup_tree->node) {
 		/* Created on-demand */
 		return "seat->im_relay->popup_tree";
 	}
-	if (server->cycle.preview_outline
-			&& node == &server->cycle.preview_outline->tree->node) {
+	if (g_server.cycle.preview_outline
+			&& node == &g_server.cycle.preview_outline->tree->node) {
 		/* Created on-demand */
 		return "cycle_state->preview_outline";
 	}
 #if HAVE_XWAYLAND
-	if (node == &server->unmanaged_tree->node) {
-		return "server->unmanaged_tree";
+	if (node == &g_server.unmanaged_tree->node) {
+		return "g_server.unmanaged_tree";
 	}
 #endif
-	if (grand_grand_parent == server->workspace_tree && node->data) {
+	if (grand_grand_parent == g_server.workspace_tree && node->data) {
 		last_view = node_view_from_node(node);
 	}
 	const char *view_part = get_view_part(last_view, node);
@@ -209,10 +209,10 @@ get_center_padding(const char *text, uint8_t max_width)
 }
 
 static void
-dump_tree(struct server *server, struct wlr_scene_node *node,
+dump_tree(struct wlr_scene_node *node,
 	int pos, int x, int y)
 {
-	const char *type = get_special(server, node);
+	const char *type = get_special(node);
 
 	if (pos) {
 		printf("%*c+-- ", pos, ' ');
@@ -234,13 +234,13 @@ dump_tree(struct server *server, struct wlr_scene_node *node,
 	}
 	printf("%.*s %*c %4d  %4d  [%p]\n", max_width - 1, type, padding, ' ', x, y, node);
 
-	if ((IGNORE_MENU && node == &server->menu_tree->node)
+	if ((IGNORE_MENU && node == &g_server.menu_tree->node)
 			|| (IGNORE_SSD && last_view
 				&& ssd_debug_is_root_node(last_view->ssd, node))
-			|| (IGNORE_CYCLE_PREVIEW_OUTLINE && server->cycle.preview_outline
-				&& node == &server->cycle.preview_outline->tree->node)
-			|| (IGNORE_SNAPPING_OVERLAY && server->seat.overlay.rect
-				&& node == &server->seat.overlay.rect->tree->node)) {
+			|| (IGNORE_CYCLE_PREVIEW_OUTLINE && g_server.cycle.preview_outline
+				&& node == &g_server.cycle.preview_outline->tree->node)
+			|| (IGNORE_SNAPPING_OVERLAY && g_server.seat.overlay.rect
+				&& node == &g_server.seat.overlay.rect->tree->node)) {
 		printf("%*c%s\n", pos + 4 + INDENT_SIZE, ' ', "<skipping children>");
 		return;
 	}
@@ -249,17 +249,17 @@ dump_tree(struct server *server, struct wlr_scene_node *node,
 		struct wlr_scene_node *child;
 		struct wlr_scene_tree *tree = wlr_scene_tree_from_node(node);
 		wl_list_for_each(child, &tree->children, link) {
-			dump_tree(server, child, pos + INDENT_SIZE,
+			dump_tree(child, pos + INDENT_SIZE,
 				x + child->x, y + child->y);
 		}
 	}
 }
 
 void
-debug_dump_scene(struct server *server)
+debug_dump_scene(void)
 {
 	printf("\n");
-	dump_tree(server, &server->scene->tree.node, 0, 0, 0);
+	dump_tree(&g_server.scene->tree.node, 0, 0, 0);
 	printf("\n");
 
 	/*

src/decorations/kde-deco.c

@@ -119,10 +119,10 @@ kde_server_decoration_update_default(void)
 }
 
 void
-kde_server_decoration_init(struct server *server)
+kde_server_decoration_init(void)
 {
 	assert(!kde_deco_mgr);
-	kde_deco_mgr = wlr_server_decoration_manager_create(server->wl_display);
+	kde_deco_mgr = wlr_server_decoration_manager_create(g_server.wl_display);
 	if (!kde_deco_mgr) {
 		wlr_log(WLR_ERROR, "unable to create the kde server deco manager");
 		exit(EXIT_FAILURE);
@@ -131,12 +131,12 @@ kde_server_decoration_init(struct server *server)
 	wl_list_init(&decorations);
 	kde_server_decoration_update_default();
 
-	wl_signal_add(&kde_deco_mgr->events.new_decoration, &server->kde_server_decoration);
-	server->kde_server_decoration.notify = handle_new_server_decoration;
+	wl_signal_add(&kde_deco_mgr->events.new_decoration, &g_server.kde_server_decoration);
+	g_server.kde_server_decoration.notify = handle_new_server_decoration;
 }
 
 void
-kde_server_decoration_finish(struct server *server)
+kde_server_decoration_finish(void)
 {
-	wl_list_remove(&server->kde_server_decoration.link);
+	wl_list_remove(&g_server.kde_server_decoration.link);
 }

src/decorations/xdg-deco.c

@@ -115,22 +115,22 @@ xdg_toplevel_decoration(struct wl_listener *listener, void *data)
 }
 
 void
-xdg_server_decoration_init(struct server *server)
+xdg_server_decoration_init(void)
 {
 	struct wlr_xdg_decoration_manager_v1 *xdg_deco_mgr = NULL;
-	xdg_deco_mgr = wlr_xdg_decoration_manager_v1_create(server->wl_display);
+	xdg_deco_mgr = wlr_xdg_decoration_manager_v1_create(g_server.wl_display);
 	if (!xdg_deco_mgr) {
 		wlr_log(WLR_ERROR, "unable to create the XDG deco manager");
 		exit(EXIT_FAILURE);
 	}
 
 	wl_signal_add(&xdg_deco_mgr->events.new_toplevel_decoration,
-		&server->xdg_toplevel_decoration);
-	server->xdg_toplevel_decoration.notify = xdg_toplevel_decoration;
+		&g_server.xdg_toplevel_decoration);
+	g_server.xdg_toplevel_decoration.notify = xdg_toplevel_decoration;
 }
 
 void
-xdg_server_decoration_finish(struct server *server)
+xdg_server_decoration_finish(void)
 {
-	wl_list_remove(&server->xdg_toplevel_decoration.link);
+	wl_list_remove(&g_server.xdg_toplevel_decoration.link);
 }

src/desktop-entry.c

@@ -55,7 +55,7 @@ log_handler(enum sfdo_log_level level, const char *fmt, va_list args, void *tag)
 }
 
 void
-desktop_entry_init(struct server *server)
+desktop_entry_init(void)
 {
 	struct sfdo *sfdo = znew(*sfdo);
 
@@ -134,7 +134,7 @@ desktop_entry_init(struct server *server)
 	/* basedir_ctx is not referenced by other objects */
 	sfdo_basedir_ctx_destroy(basedir_ctx);
 
-	server->sfdo = sfdo;
+	g_server.sfdo = sfdo;
 	return;
 
 err_icon_theme:
@@ -155,9 +155,9 @@ err_basedir_ctx:
 }
 
 void
-desktop_entry_finish(struct server *server)
+desktop_entry_finish(void)
 {
-	struct sfdo *sfdo = server->sfdo;
+	struct sfdo *sfdo = g_server.sfdo;
 	if (!sfdo) {
 		return;
 	}
@@ -167,7 +167,7 @@ desktop_entry_finish(struct server *server)
 	sfdo_icon_ctx_destroy(sfdo->icon_ctx);
 	sfdo_desktop_ctx_destroy(sfdo->desktop_ctx);
 	free(sfdo);
-	server->sfdo = NULL;
+	g_server.sfdo = NULL;
 }
 
 struct icon_ctx {
@@ -348,14 +348,14 @@ convert_img_type(enum sfdo_icon_file_format fmt)
 }
 
 struct lab_img *
-desktop_entry_load_icon(struct server *server, const char *icon_name, int size, float scale)
+desktop_entry_load_icon(const char *icon_name, int size, float scale)
 {
 	/* static analyzer isn't able to detect the NULL check in string_null_or_empty() */
 	if (string_null_or_empty(icon_name) || !icon_name) {
 		return NULL;
 	}
 
-	struct sfdo *sfdo = server->sfdo;
+	struct sfdo *sfdo = g_server.sfdo;
 	if (!sfdo) {
 		return NULL;
 	}
@@ -387,14 +387,13 @@ desktop_entry_load_icon(struct server *server, const char *icon_name, int size,
 }
 
 struct lab_img *
-desktop_entry_load_icon_from_app_id(struct server *server,
-		const char *app_id, int size, float scale)
+desktop_entry_load_icon_from_app_id(const char *app_id, int size, float scale)
 {
 	if (string_null_or_empty(app_id)) {
 		return NULL;
 	}
 
-	struct sfdo *sfdo = server->sfdo;
+	struct sfdo *sfdo = g_server.sfdo;
 	if (!sfdo) {
 		return NULL;
 	}
@@ -405,22 +404,22 @@ desktop_entry_load_icon_from_app_id(struct server *server,
 		icon_name = sfdo_desktop_entry_get_icon(entry, NULL);
 	}
 
-	struct lab_img *img = desktop_entry_load_icon(server, icon_name, size, scale);
+	struct lab_img *img = desktop_entry_load_icon(icon_name, size, scale);
 	if (!img) {
 		/* Icon not defined in .desktop file or could not be loaded */
-		img = desktop_entry_load_icon(server, app_id, size, scale);
+		img = desktop_entry_load_icon(app_id, size, scale);
 	}
 	return img;
 }
 
 const char *
-desktop_entry_name_lookup(struct server *server, const char *app_id)
+desktop_entry_name_lookup(const char *app_id)
 {
 	if (string_null_or_empty(app_id)) {
 		return NULL;
 	}
 
-	struct sfdo *sfdo = server->sfdo;
+	struct sfdo *sfdo = g_server.sfdo;
 	if (!sfdo) {
 		return NULL;
 	}

src/desktop.c

@@ -23,7 +23,7 @@
 #endif
 
 void
-desktop_arrange_all_views(struct server *server)
+desktop_arrange_all_views(void)
 {
 	/*
 	 * Adjust window positions/sizes. Skip views with no size since
@@ -36,7 +36,7 @@ desktop_arrange_all_views(struct server *server)
 	 * views.
 	 */
 	struct view *view;
-	wl_list_for_each(view, &server->views, link) {
+	wl_list_for_each(view, &g_server.views, link) {
 		if (!wlr_box_empty(&view->pending)) {
 			view_adjust_for_layout_change(view);
 		}
@@ -46,7 +46,7 @@ desktop_arrange_all_views(struct server *server)
 static void
 set_or_offer_focus(struct view *view)
 {
-	struct seat *seat = &view->server->seat;
+	struct seat *seat = &g_server.seat;
 	switch (view_wants_focus(view)) {
 	case VIEW_WANTS_FOCUS_ALWAYS:
 		if (view->surface != seat->seat->keyboard_state.focused_surface) {
@@ -76,7 +76,7 @@ desktop_focus_view(struct view *view, bool raise)
 		return;
 	}
 
-	if (view->server->input_mode == LAB_INPUT_STATE_CYCLE) {
+	if (g_server.input_mode == LAB_INPUT_STATE_CYCLE) {
 		wlr_log(WLR_DEBUG, "not focusing window while window switching");
 		return;
 	}
@@ -135,10 +135,10 @@ desktop_focus_view_or_surface(struct seat *seat, struct view *view,
 }
 
 static struct view *
-desktop_topmost_focusable_view(struct server *server)
+desktop_topmost_focusable_view(void)
 {
 	struct view *view;
-	for_each_view(view, &server->views,
+	for_each_view(view, &g_server.views,
 			LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
 		if (!view->minimized) {
 			return view;
@@ -148,9 +148,9 @@ desktop_topmost_focusable_view(struct server *server)
 }
 
 void
-desktop_focus_topmost_view(struct server *server)
+desktop_focus_topmost_view(void)
 {
-	struct view *view = desktop_topmost_focusable_view(server);
+	struct view *view = desktop_topmost_focusable_view();
 	if (view) {
 		desktop_focus_view(view, /*raise*/ true);
 	} else {
@@ -158,49 +158,47 @@ desktop_focus_topmost_view(struct server *server)
 		 * Defocus previous focused surface/view if no longer
 		 * focusable (e.g. unmapped or on a different workspace).
 		 */
-		seat_focus_surface(&server->seat, NULL);
+		seat_focus_surface(&g_server.seat, NULL);
 	}
 }
 
 void
 desktop_focus_output(struct output *output)
 {
-	struct server *server = output->server;
-
-	if (!output_is_usable(output) || server->input_mode
+	if (!output_is_usable(output) || g_server.input_mode
 			!= LAB_INPUT_STATE_PASSTHROUGH) {
 		return;
 	}
 	struct view *view;
-	for_each_view(view, &server->views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
+	for_each_view(view, &g_server.views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
 		if (view->outputs & output->id_bit) {
 			desktop_focus_view(view, /*raise*/ false);
-			wlr_cursor_warp(server->seat.cursor, NULL,
+			wlr_cursor_warp(g_server.seat.cursor, NULL,
 				view->current.x + view->current.width / 2,
 				view->current.y + view->current.height / 2);
-			cursor_update_focus(server);
+			cursor_update_focus();
 			return;
 		}
 	}
 	/* No view found on desired output */
 	struct wlr_box layout_box;
-	wlr_output_layout_get_box(server->output_layout,
+	wlr_output_layout_get_box(g_server.output_layout,
 		output->wlr_output, &layout_box);
-	wlr_cursor_warp(server->seat.cursor, NULL,
+	wlr_cursor_warp(g_server.seat.cursor, NULL,
 		layout_box.x + output->usable_area.x + output->usable_area.width / 2,
 		layout_box.y + output->usable_area.y + output->usable_area.height / 2);
-	cursor_update_focus(server);
+	cursor_update_focus();
 }
 
 void
-desktop_update_top_layer_visibility(struct server *server)
+desktop_update_top_layer_visibility(void)
 {
 	struct view *view;
 	struct output *output;
 	uint32_t top = ZWLR_LAYER_SHELL_V1_LAYER_TOP;
 
 	/* Enable all top layers */
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (!output_is_usable(output)) {
 			continue;
 		}
@@ -212,7 +210,7 @@ desktop_update_top_layer_visibility(struct server *server)
 	 * any views above it
 	 */
 	uint64_t outputs_covered = 0;
-	for_each_view(view, &server->views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
+	for_each_view(view, &g_server.views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
 		if (view->minimized) {
 			continue;
 		}
@@ -262,22 +260,22 @@ avoid_edge_rounding_issues(struct cursor_context *ctx)
 
 /* TODO: make this less big and scary */
 struct cursor_context
-get_cursor_context(struct server *server)
+get_cursor_context(void)
 {
 	struct cursor_context ret = {.type = LAB_NODE_NONE};
-	struct wlr_cursor *cursor = server->seat.cursor;
+	struct wlr_cursor *cursor = g_server.seat.cursor;
 
 	/* Prevent drag icons to be on top of the hitbox detection */
-	if (server->seat.drag.active) {
-		dnd_icons_show(&server->seat, false);
+	if (g_server.seat.drag.active) {
+		dnd_icons_show(&g_server.seat, false);
 	}
 
 	struct wlr_scene_node *node =
-		wlr_scene_node_at(&server->scene->tree.node,
+		wlr_scene_node_at(&g_server.scene->tree.node,
 			cursor->x, cursor->y, &ret.sx, &ret.sy);
 
-	if (server->seat.drag.active) {
-		dnd_icons_show(&server->seat, true);
+	if (g_server.seat.drag.active) {
+		dnd_icons_show(&g_server.seat, true);
 	}
 
 	if (!node) {
@@ -292,7 +290,7 @@ get_cursor_context(struct server *server)
 #if HAVE_XWAYLAND
 	/* TODO: attach LAB_NODE_UNMANAGED node-descriptor to unmanaged surfaces */
 	if (node->type == WLR_SCENE_NODE_BUFFER) {
-		if (node->parent == server->unmanaged_tree) {
+		if (node->parent == g_server.unmanaged_tree) {
 			ret.type = LAB_NODE_UNMANAGED;
 			return ret;
 		}

src/dnd.c

@@ -68,7 +68,7 @@ handle_drag_destroy(struct wl_listener *listener, void *data)
 		return;
 	}
 
-	struct cursor_context ctx = get_cursor_context(seat->server);
+	struct cursor_context ctx = get_cursor_context();
 	if (!ctx.surface) {
 		return;
 	}
@@ -84,7 +84,7 @@ handle_drag_destroy(struct wl_listener *listener, void *data)
 void
 dnd_init(struct seat *seat)
 {
-	seat->drag.icons = lab_wlr_scene_tree_create(&seat->server->scene->tree);
+	seat->drag.icons = lab_wlr_scene_tree_create(&g_server.scene->tree);
 	wlr_scene_node_set_enabled(&seat->drag.icons->node, false);
 
 	seat->drag.events.request.notify = handle_drag_request;

src/edges.c

@@ -328,7 +328,7 @@ subtract_node_tree(struct wlr_scene_tree *tree, pixman_region32_t *available,
 }
 
 void
-edges_calculate_visibility(struct server *server, struct view *ignored_view)
+edges_calculate_visibility(struct view *ignored_view)
 {
 	/*
 	 * The region stores the available output layout space
@@ -353,17 +353,17 @@ edges_calculate_visibility(struct server *server, struct view *ignored_view)
 	 */
 	struct output *output;
 	struct wlr_box layout_box;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (!output_is_usable(output)) {
 			continue;
 		}
-		wlr_output_layout_get_box(server->output_layout,
+		wlr_output_layout_get_box(g_server.output_layout,
 			output->wlr_output, &layout_box);
 		pixman_region32_union_rect(&region, &region,
 			layout_box.x, layout_box.y, layout_box.width, layout_box.height);
 	}
 
-	subtract_node_tree(&server->scene->tree, &region, ignored_view);
+	subtract_node_tree(&g_server.scene->tree, &region, ignored_view);
 
 	pixman_region32_fini(&region);
 }
@@ -389,7 +389,7 @@ edges_find_neighbors(struct border *nearest_edges, struct view *view,
 	edges_for_target_geometry(&target_edges, view, target);
 
 	struct view *v;
-	for_each_view(v, &view->server->views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
+	for_each_view(v, &g_server.views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
 		if (v == view || v->minimized || !output_is_usable(v->output)) {
 			continue;
 		}
@@ -447,7 +447,7 @@ edges_find_outputs(struct border *nearest_edges, struct view *view,
 	edges_for_target_geometry(&target_edges, view, target);
 
 	struct output *o;
-	wl_list_for_each(o, &view->server->outputs, link) {
+	wl_list_for_each(o, &g_server.outputs, link) {
 		if (!output_is_usable(o)) {
 			continue;
 		}

src/foreign-toplevel/ext-foreign.c

@@ -59,7 +59,7 @@ void
 ext_foreign_toplevel_init(struct ext_foreign_toplevel *ext_toplevel,
 		struct view *view)
 {
-	assert(view->server->foreign_toplevel_list);
+	assert(g_server.foreign_toplevel_list);
 	ext_toplevel->view = view;
 
 	struct wlr_ext_foreign_toplevel_handle_v1_state state = {
@@ -67,7 +67,7 @@ ext_foreign_toplevel_init(struct ext_foreign_toplevel *ext_toplevel,
 		.app_id = view->app_id,
 	};
 	ext_toplevel->handle = wlr_ext_foreign_toplevel_handle_v1_create(
-		view->server->foreign_toplevel_list, &state);
+		g_server.foreign_toplevel_list, &state);
 
 	if (!ext_toplevel->handle) {
 		wlr_log(WLR_ERROR, "cannot create ext toplevel handle for (%s)",

src/foreign-toplevel/wlr-foreign.c

@@ -123,7 +123,7 @@ handle_new_outputs(struct wl_listener *listener, void *data)
 	 * wlr_foreign_toplevel handle the rest.
 	 */
 	struct output *output;
-	wl_list_for_each(output, &wlr_toplevel->view->server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (view_on_output(wlr_toplevel->view, output)) {
 			wlr_foreign_toplevel_handle_v1_output_enter(
 				wlr_toplevel->handle, output->wlr_output);
@@ -184,11 +184,11 @@ void
 wlr_foreign_toplevel_init(struct wlr_foreign_toplevel *wlr_toplevel,
 		struct view *view)
 {
-	assert(view->server->foreign_toplevel_manager);
+	assert(g_server.foreign_toplevel_manager);
 	wlr_toplevel->view = view;
 
 	wlr_toplevel->handle = wlr_foreign_toplevel_handle_v1_create(
-		view->server->foreign_toplevel_manager);
+		g_server.foreign_toplevel_manager);
 	if (!wlr_toplevel->handle) {
 		wlr_log(WLR_ERROR, "cannot create wlr foreign toplevel handle for (%s)",
 			view->title);
@@ -203,7 +203,7 @@ wlr_foreign_toplevel_init(struct wlr_foreign_toplevel *wlr_toplevel,
 	handle_minimized(&wlr_toplevel->on_view.minimized, NULL);
 	handle_fullscreened(&wlr_toplevel->on_view.fullscreened, NULL);
 	handle_activated(&wlr_toplevel->on_view.activated,
-		&(bool){view == view->server->active_view});
+		&(bool){view == g_server.active_view});
 
 	/* Client side requests */
 	CONNECT_SIGNAL(wlr_toplevel->handle, &wlr_toplevel->on, request_maximize);

src/input/cursor.c

@@ -148,7 +148,7 @@ handle_request_set_cursor(struct wl_listener *listener, void *data)
 {
 	struct seat *seat = wl_container_of(listener, seat, request_set_cursor);
 
-	if (seat->server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		/* Prevent setting a cursor image when moving or resizing */
 		return;
 	}
@@ -208,7 +208,7 @@ handle_request_set_shape(struct wl_listener *listener, void *data)
 	struct wlr_seat_client *focused_client = seat->seat->pointer_state.focused_client;
 
 	/* Prevent setting a cursor image when moving or resizing */
-	if (seat->server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		return;
 	}
 
@@ -265,12 +265,12 @@ handle_request_set_primary_selection(struct wl_listener *listener, void *data)
 }
 
 static void
-process_cursor_move(struct server *server, uint32_t time)
+process_cursor_move(uint32_t time)
 {
-	struct view *view = server->grabbed_view;
+	struct view *view = g_server.grabbed_view;
 
-	int x = server->grab_box.x + (server->seat.cursor->x - server->grab_x);
-	int y = server->grab_box.y + (server->seat.cursor->y - server->grab_y);
+	int x = g_server.grab_box.x + (g_server.seat.cursor->x - g_server.grab_x);
+	int y = g_server.grab_box.y + (g_server.seat.cursor->y - g_server.grab_y);
 
 	/* Apply resistance for maximized/tiled view */
 	bool needs_untile = resistance_unsnap_apply(view, &x, &y);
@@ -286,7 +286,7 @@ process_cursor_move(struct server *server, uint32_t time)
 			.width = view->natural_geometry.width,
 			.height = view->natural_geometry.height,
 		};
-		interactive_anchor_to_cursor(server, &new_geo);
+		interactive_anchor_to_cursor(&new_geo);
 		/* Shaded clients will not process resize events until unshaded */
 		view_set_shade(view, false);
 		view_set_maximized(view, VIEW_AXIS_NONE);
@@ -300,18 +300,18 @@ process_cursor_move(struct server *server, uint32_t time)
 	resistance_move_apply(view, &x, &y);
 
 	view_move(view, x, y);
-	overlay_update(&server->seat);
+	overlay_update(&g_server.seat);
 }
 
 static void
-process_cursor_resize(struct server *server, uint32_t time)
+process_cursor_resize(uint32_t time)
 {
 	/* Rate-limit resize events respecting monitor refresh rate */
 	static uint32_t last_resize_time = 0;
 	static struct view *last_resize_view = NULL;
 
-	assert(server->grabbed_view);
-	if (server->grabbed_view == last_resize_view) {
+	assert(g_server.grabbed_view);
+	if (g_server.grabbed_view == last_resize_view) {
 		int32_t refresh = 0;
 		if (output_is_usable(last_resize_view->output)) {
 			refresh = last_resize_view->output->wlr_output->refresh;
@@ -327,43 +327,43 @@ process_cursor_resize(struct server *server, uint32_t time)
 	}
 
 	last_resize_time = time;
-	last_resize_view = server->grabbed_view;
+	last_resize_view = g_server.grabbed_view;
 
-	double dx = server->seat.cursor->x - server->grab_x;
-	double dy = server->seat.cursor->y - server->grab_y;
+	double dx = g_server.seat.cursor->x - g_server.grab_x;
+	double dy = g_server.seat.cursor->y - g_server.grab_y;
 
-	struct view *view = server->grabbed_view;
+	struct view *view = g_server.grabbed_view;
 	struct wlr_box new_view_geo = view->current;
 
-	if (server->resize_edges & LAB_EDGE_TOP) {
+	if (g_server.resize_edges & LAB_EDGE_TOP) {
 		/* Shift y to anchor bottom edge when resizing top */
-		new_view_geo.y = server->grab_box.y + dy;
-		new_view_geo.height = server->grab_box.height - dy;
-	} else if (server->resize_edges & LAB_EDGE_BOTTOM) {
-		new_view_geo.height = server->grab_box.height + dy;
+		new_view_geo.y = g_server.grab_box.y + dy;
+		new_view_geo.height = g_server.grab_box.height - dy;
+	} else if (g_server.resize_edges & LAB_EDGE_BOTTOM) {
+		new_view_geo.height = g_server.grab_box.height + dy;
 	}
 
-	if (server->resize_edges & LAB_EDGE_LEFT) {
+	if (g_server.resize_edges & LAB_EDGE_LEFT) {
 		/* Shift x to anchor right edge when resizing left */
-		new_view_geo.x = server->grab_box.x + dx;
-		new_view_geo.width = server->grab_box.width - dx;
-	} else if (server->resize_edges & LAB_EDGE_RIGHT) {
-		new_view_geo.width = server->grab_box.width + dx;
+		new_view_geo.x = g_server.grab_box.x + dx;
+		new_view_geo.width = g_server.grab_box.width - dx;
+	} else if (g_server.resize_edges & LAB_EDGE_RIGHT) {
+		new_view_geo.width = g_server.grab_box.width + dx;
 	}
 
 	resistance_resize_apply(view, &new_view_geo);
 	view_adjust_size(view, &new_view_geo.width, &new_view_geo.height);
 
-	if (server->resize_edges & LAB_EDGE_TOP) {
+	if (g_server.resize_edges & LAB_EDGE_TOP) {
 		/* After size adjustments, make sure to anchor bottom edge */
-		new_view_geo.y = server->grab_box.y +
-			server->grab_box.height - new_view_geo.height;
+		new_view_geo.y = g_server.grab_box.y +
+			g_server.grab_box.height - new_view_geo.height;
 	}
 
-	if (server->resize_edges & LAB_EDGE_LEFT) {
+	if (g_server.resize_edges & LAB_EDGE_LEFT) {
 		/* After size adjustments, make sure to anchor bottom right */
-		new_view_geo.x = server->grab_box.x +
-			server->grab_box.width - new_view_geo.width;
+		new_view_geo.x = g_server.grab_box.x +
+			g_server.grab_box.width - new_view_geo.width;
 	}
 
 	if (rc.resize_draw_contents) {
@@ -422,7 +422,7 @@ cursor_update_image(struct seat *seat)
 			seat->server_cursor = LAB_CURSOR_DEFAULT;
 			wlr_cursor_set_xcursor(seat->cursor, seat->xcursor_manager, "");
 			wlr_seat_pointer_clear_focus(seat->seat);
-			cursor_update_focus(seat->server);
+			cursor_update_focus();
 		}
 		return;
 	}
@@ -533,15 +533,15 @@ update_pressed_surface(struct seat *seat, const struct cursor_context *ctx)
  * and process_cursor_axis()
  */
 static void
-cursor_update_common(struct server *server, const struct cursor_context *ctx,
+cursor_update_common(const struct cursor_context *ctx,
 		struct cursor_context *notified_ctx)
 {
-	struct seat *seat = &server->seat;
+	struct seat *seat = &g_server.seat;
 	struct wlr_seat *wlr_seat = seat->seat;
 
-	ssd_update_hovered_button(server, ctx->node);
+	ssd_update_hovered_button(ctx->node);
 
-	if (server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		/*
 		 * Prevent updating focus/cursor image during
 		 * interactive move/resize, window switcher and
@@ -565,8 +565,8 @@ cursor_update_common(struct server *server, const struct cursor_context *ctx,
 			int lx, ly;
 			wlr_scene_node_coords(seat->pressed.ctx.node, &lx, &ly);
 			*notified_ctx = seat->pressed.ctx;
-			notified_ctx->sx = server->seat.cursor->x - lx;
-			notified_ctx->sy = server->seat.cursor->y - ly;
+			notified_ctx->sx = g_server.seat.cursor->x - lx;
+			notified_ctx->sy = g_server.seat.cursor->y - ly;
 		}
 		return;
 	}
@@ -620,24 +620,24 @@ cursor_get_resize_edges(struct wlr_cursor *cursor, const struct cursor_context *
 }
 
 bool
-cursor_process_motion(struct server *server, uint32_t time, double *sx, double *sy)
+cursor_process_motion(uint32_t time, double *sx, double *sy)
 {
 	/* If the mode is non-passthrough, delegate to those functions. */
-	if (server->input_mode == LAB_INPUT_STATE_MOVE) {
-		process_cursor_move(server, time);
+	if (g_server.input_mode == LAB_INPUT_STATE_MOVE) {
+		process_cursor_move(time);
 		return false;
-	} else if (server->input_mode == LAB_INPUT_STATE_RESIZE) {
-		process_cursor_resize(server, time);
+	} else if (g_server.input_mode == LAB_INPUT_STATE_RESIZE) {
+		process_cursor_resize(time);
 		return false;
 	}
 
 	/* Otherwise, find view under the pointer and send the event along */
-	struct cursor_context ctx = get_cursor_context(server);
-	struct seat *seat = &server->seat;
+	struct cursor_context ctx = get_cursor_context();
+	struct seat *seat = &g_server.seat;
 
 	if (ctx.type == LAB_NODE_MENUITEM) {
 		menu_process_cursor_motion(ctx.node);
-		cursor_set(&server->seat, LAB_CURSOR_DEFAULT);
+		cursor_set(&g_server.seat, LAB_CURSOR_DEFAULT);
 		return false;
 	}
 
@@ -659,8 +659,7 @@ cursor_process_motion(struct server *server, uint32_t time, double *sx, double *
 			 * moving/resizing the wrong view
 			 */
 			mousebind->pressed_in_context = false;
-			actions_run(seat->pressed.ctx.view, server,
-				&mousebind->actions, &seat->pressed.ctx);
+			actions_run(seat->pressed.ctx.view, &mousebind->actions, &seat->pressed.ctx);
 		}
 	}
 
@@ -670,7 +669,7 @@ cursor_process_motion(struct server *server, uint32_t time, double *sx, double *
 	 * and the pressed view is set while out-of-surface dragging.
 	 */
 	struct cursor_context notified_ctx = {0};
-	cursor_update_common(server, &ctx, &notified_ctx);
+	cursor_update_common(&ctx, &notified_ctx);
 
 	if (rc.focus_follow_mouse) {
 		/*
@@ -701,10 +700,10 @@ cursor_process_motion(struct server *server, uint32_t time, double *sx, double *
 }
 
 static void
-_cursor_update_focus(struct server *server)
+_cursor_update_focus(void)
 {
 	/* Focus surface under cursor if it isn't already focused */
-	struct cursor_context ctx = get_cursor_context(server);
+	struct cursor_context ctx = get_cursor_context();
 
 	if ((ctx.view || ctx.surface) && rc.focus_follow_mouse
 			&& !rc.focus_follow_mouse_requires_movement) {
@@ -712,21 +711,21 @@ _cursor_update_focus(struct server *server)
 		 * Always focus the surface below the cursor when
 		 * followMouse=yes and followMouseRequiresMovement=no.
 		 */
-		desktop_focus_view_or_surface(&server->seat, ctx.view,
+		desktop_focus_view_or_surface(&g_server.seat, ctx.view,
 			ctx.surface, rc.raise_on_focus);
 	}
 
-	cursor_update_common(server, &ctx, NULL);
+	cursor_update_common(&ctx, NULL);
 }
 
 void
-cursor_update_focus(struct server *server)
+cursor_update_focus(void)
 {
 	/* Prevent recursion via view_move_to_front() */
 	static bool updating_focus = false;
 	if (!updating_focus) {
 		updating_focus = true;
-		_cursor_update_focus(server);
+		_cursor_update_focus();
 		updating_focus = false;
 	}
 }
@@ -735,7 +734,7 @@ static void
 warp_cursor_to_constraint_hint(struct seat *seat,
 		struct wlr_pointer_constraint_v1 *constraint)
 {
-	if (!seat->server->active_view) {
+	if (!g_server.active_view) {
 		return;
 	}
 
@@ -744,8 +743,8 @@ warp_cursor_to_constraint_hint(struct seat *seat,
 		double sx = constraint->current.cursor_hint.x;
 		double sy = constraint->current.cursor_hint.y;
 		wlr_cursor_warp(seat->cursor, NULL,
-			seat->server->active_view->current.x + sx,
-			seat->server->active_view->current.y + sy);
+			g_server.active_view->current.x + sx,
+			g_server.active_view->current.y + sy);
 
 		/* Make sure we are not sending unnecessary surface movements */
 		wlr_seat_pointer_warp(seat->seat, sx, sy);
@@ -788,26 +787,24 @@ void
 create_constraint(struct wl_listener *listener, void *data)
 {
 	struct wlr_pointer_constraint_v1 *wlr_constraint = data;
-	struct server *server = wl_container_of(listener, server,
-		new_constraint);
 	struct constraint *constraint = znew(*constraint);
 
 	constraint->constraint = wlr_constraint;
-	constraint->seat = &server->seat;
+	constraint->seat = &g_server.seat;
 	constraint->destroy.notify = handle_constraint_destroy;
 	wl_signal_add(&wlr_constraint->events.destroy, &constraint->destroy);
 
-	struct view *view = server->active_view;
+	struct view *view = g_server.active_view;
 	if (view && view->surface == wlr_constraint->surface) {
-		constrain_cursor(server, wlr_constraint);
+		constrain_cursor(wlr_constraint);
 	}
 }
 
 void
-constrain_cursor(struct server *server, struct wlr_pointer_constraint_v1
+constrain_cursor(struct wlr_pointer_constraint_v1
 		*constraint)
 {
-	struct seat *seat = &server->seat;
+	struct seat *seat = &g_server.seat;
 	if (seat->current_constraint == constraint) {
 		return;
 	}
@@ -837,7 +834,7 @@ constrain_cursor(struct server *server, struct wlr_pointer_constraint_v1
 static void
 apply_constraint(struct seat *seat, struct wlr_pointer *pointer, double *x, double *y)
 {
-	if (!seat->server->active_view) {
+	if (!g_server.active_view) {
 		return;
 	}
 	if (!seat->current_constraint
@@ -850,8 +847,8 @@ apply_constraint(struct seat *seat, struct wlr_pointer *pointer, double *x, doub
 	double sx = seat->cursor->x;
 	double sy = seat->cursor->y;
 
-	sx -= seat->server->active_view->current.x;
-	sy -= seat->server->active_view->current.y;
+	sx -= g_server.active_view->current.x;
+	sy -= g_server.active_view->current.y;
 
 	double sx_confined, sy_confined;
 	if (!wlr_region_confine(&seat->current_constraint->region, sx, sy,
@@ -892,7 +889,7 @@ preprocess_cursor_motion(struct seat *seat, struct wlr_pointer *pointer,
 	 */
 	wlr_cursor_move(seat->cursor, &pointer->base, dx, dy);
 	double sx, sy;
-	bool notify = cursor_process_motion(seat->server, time_msec, &sx, &sy);
+	bool notify = cursor_process_motion(time_msec, &sx, &sy);
 	if (notify) {
 		wlr_seat_pointer_notify_motion(seat->seat, time_msec, sx, sy);
 	}
@@ -919,7 +916,6 @@ handle_motion(struct wl_listener *listener, void *data)
 	 * _relative_ pointer motion event (i.e. a delta)
 	 */
 	struct seat *seat = wl_container_of(listener, seat, on_cursor.motion);
-	struct server *server = seat->server;
 	struct wlr_pointer_motion_event *event = data;
 	idle_manager_notify_activity(seat->seat);
 	cursor_set_visible(seat, /* visible */ true);
@@ -952,7 +948,7 @@ handle_motion(struct wl_listener *listener, void *data)
 			WL_POINTER_AXIS_SOURCE_CONTINUOUS, event->time_msec);
 	} else {
 		wlr_relative_pointer_manager_v1_send_relative_motion(
-			server->relative_pointer_manager,
+			g_server.relative_pointer_manager,
 			seat->seat, (uint64_t)event->time_msec * 1000,
 			event->delta_x, event->delta_y, event->unaccel_dx,
 			event->unaccel_dy);
@@ -990,15 +986,14 @@ handle_motion_absolute(struct wl_listener *listener, void *data)
 }
 
 static void
-process_release_mousebinding(struct server *server,
-		struct cursor_context *ctx, uint32_t button)
+process_release_mousebinding(struct cursor_context *ctx, uint32_t button)
 {
-	if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
+	if (g_server.input_mode == LAB_INPUT_STATE_CYCLE) {
 		return;
 	}
 
 	struct mousebind *mousebind;
-	uint32_t modifiers = keyboard_get_all_modifiers(&server->seat);
+	uint32_t modifiers = keyboard_get_all_modifiers(&g_server.seat);
 
 	wl_list_for_each(mousebind, &rc.mousebinds, link) {
 		if (ctx->type == LAB_NODE_CLIENT
@@ -1019,7 +1014,7 @@ process_release_mousebinding(struct server *server,
 			default:
 				continue;
 			}
-			actions_run(ctx->view, server, &mousebind->actions, ctx);
+			actions_run(ctx->view, &mousebind->actions, ctx);
 		}
 	}
 }
@@ -1059,17 +1054,17 @@ is_double_click(long double_click_speed, uint32_t button,
 }
 
 static bool
-process_press_mousebinding(struct server *server, struct cursor_context *ctx,
+process_press_mousebinding(struct cursor_context *ctx,
 		uint32_t button)
 {
-	if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
+	if (g_server.input_mode == LAB_INPUT_STATE_CYCLE) {
 		return false;
 	}
 
 	struct mousebind *mousebind;
 	bool double_click = is_double_click(rc.doubleclick_time, button, ctx);
 	bool consumed_by_frame_context = false;
-	uint32_t modifiers = keyboard_get_all_modifiers(&server->seat);
+	uint32_t modifiers = keyboard_get_all_modifiers(&g_server.seat);
 
 	wl_list_for_each(mousebind, &rc.mousebinds, link) {
 		if (ctx->type == LAB_NODE_CLIENT
@@ -1108,7 +1103,7 @@ process_press_mousebinding(struct server *server, struct cursor_context *ctx,
 			}
 			consumed_by_frame_context |= mousebind->context == LAB_NODE_FRAME;
 			consumed_by_frame_context |= mousebind->context == LAB_NODE_ALL;
-			actions_run(ctx->view, server, &mousebind->actions, ctx);
+			actions_run(ctx->view, &mousebind->actions, ctx);
 		}
 	}
 	return consumed_by_frame_context;
@@ -1138,8 +1133,7 @@ static uint32_t press_msec;
 bool
 cursor_process_button_press(struct seat *seat, uint32_t button, uint32_t time_msec)
 {
-	struct server *server = seat->server;
-	struct cursor_context ctx = get_cursor_context(server);
+	struct cursor_context ctx = get_cursor_context();
 
 	/* Used on next button release to check if it can close menu or select menu item */
 	press_msec = time_msec;
@@ -1147,10 +1141,10 @@ cursor_process_button_press(struct seat *seat, uint32_t button, uint32_t time_ms
 	if (ctx.view || ctx.surface) {
 		/* Store cursor context for later action processing */
 		cursor_context_save(&seat->pressed, &ctx);
-		interactive_set_grab_context(server, &ctx);
+		interactive_set_grab_context(&ctx);
 	}
 
-	if (server->input_mode == LAB_INPUT_STATE_MENU) {
+	if (g_server.input_mode == LAB_INPUT_STATE_MENU) {
 		/*
 		 * If menu was already opened on press, set a very small value
 		 * so subsequent release always closes menu or selects menu item.
@@ -1195,7 +1189,7 @@ cursor_process_button_press(struct seat *seat, uint32_t button, uint32_t time_ms
 
 	/* Bindings to the Frame context swallow mouse events if activated */
 	bool consumed_by_frame_context =
-		process_press_mousebinding(server, &ctx, button);
+		process_press_mousebinding(&ctx, button);
 
 	if (ctx.surface && !consumed_by_frame_context) {
 		/* Notify client with pointer focus of button press */
@@ -1210,8 +1204,7 @@ bool
 cursor_process_button_release(struct seat *seat, uint32_t button,
 		uint32_t time_msec)
 {
-	struct server *server = seat->server;
-	struct cursor_context ctx = get_cursor_context(server);
+	struct cursor_context ctx = get_cursor_context();
 	struct wlr_surface *pressed_surface = seat->pressed.ctx.surface;
 
 	/* Always notify button release event when it's not bound */
@@ -1219,26 +1212,26 @@ cursor_process_button_release(struct seat *seat, uint32_t button,
 
 	cursor_context_save(&seat->pressed, NULL);
 
-	if (server->input_mode == LAB_INPUT_STATE_MENU) {
+	if (g_server.input_mode == LAB_INPUT_STATE_MENU) {
 		/* TODO: take into account overflow of time_msec */
 		if (time_msec - press_msec > rc.menu_ignore_button_release_period) {
 			if (ctx.type == LAB_NODE_MENUITEM) {
-				menu_call_selected_actions(server);
+				menu_call_selected_actions();
 			} else {
-				menu_close_root(server);
-				cursor_update_focus(server);
+				menu_close_root();
+				cursor_update_focus();
 			}
 		}
 		return notify;
 	}
-	if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
+	if (g_server.input_mode == LAB_INPUT_STATE_CYCLE) {
 		if (ctx.type == LAB_NODE_CYCLE_OSD_ITEM) {
-			cycle_on_cursor_release(server, ctx.node);
+			cycle_on_cursor_release(ctx.node);
 		}
 		return notify;
 	}
 
-	if (server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		return notify;
 	}
 
@@ -1250,7 +1243,7 @@ cursor_process_button_release(struct seat *seat, uint32_t button,
 		return notify;
 	}
 
-	process_release_mousebinding(server, &ctx, button);
+	process_release_mousebinding(&ctx, button);
 
 	return notify;
 }
@@ -1258,8 +1251,6 @@ cursor_process_button_release(struct seat *seat, uint32_t button,
 bool
 cursor_finish_button_release(struct seat *seat, uint32_t button)
 {
-	struct server *server = seat->server;
-
 	/* Clear "pressed" status for all bindings of this mouse button */
 	struct mousebind *mousebind;
 	wl_list_for_each(mousebind, &rc.mousebinds, link) {
@@ -1270,17 +1261,17 @@ cursor_finish_button_release(struct seat *seat, uint32_t button)
 
 	lab_set_remove(&seat->bound_buttons, button);
 
-	if (server->input_mode == LAB_INPUT_STATE_MOVE
-			|| server->input_mode == LAB_INPUT_STATE_RESIZE) {
-		if (resize_outlines_enabled(server->grabbed_view)) {
-			resize_outlines_finish(server->grabbed_view);
+	if (g_server.input_mode == LAB_INPUT_STATE_MOVE
+			|| g_server.input_mode == LAB_INPUT_STATE_RESIZE) {
+		if (resize_outlines_enabled(g_server.grabbed_view)) {
+			resize_outlines_finish(g_server.grabbed_view);
 		}
 		/* Exit interactive move/resize mode */
-		interactive_finish(server->grabbed_view);
+		interactive_finish(g_server.grabbed_view);
 		return true;
-	} else if (server->grabbed_view) {
+	} else if (g_server.grabbed_view) {
 		/* Button was released without starting move/resize */
-		interactive_cancel(server->grabbed_view);
+		interactive_cancel(g_server.grabbed_view);
 	}
 
 	return false;
@@ -1370,15 +1361,15 @@ compare_delta(double delta, double delta_discrete, struct accumulated_scroll *ac
 }
 
 static bool
-process_cursor_axis(struct server *server, enum wl_pointer_axis orientation,
+process_cursor_axis(enum wl_pointer_axis orientation,
 		double delta, double delta_discrete)
 {
-	struct cursor_context ctx = get_cursor_context(server);
-	uint32_t modifiers = keyboard_get_all_modifiers(&server->seat);
+	struct cursor_context ctx = get_cursor_context();
+	uint32_t modifiers = keyboard_get_all_modifiers(&g_server.seat);
 
 	enum direction direction = LAB_DIRECTION_INVALID;
 	struct scroll_info info = compare_delta(delta, delta_discrete,
-		&server->seat.accumulated_scrolls[orientation]);
+		&g_server.seat.accumulated_scrolls[orientation]);
 
 	if (orientation == WL_POINTER_AXIS_HORIZONTAL_SCROLL) {
 		if (info.direction < 0) {
@@ -1415,7 +1406,7 @@ process_cursor_axis(struct server *server, enum wl_pointer_axis orientation,
 				 * on touchpads or hi-res mice doesn't exceed the threshold
 				 */
 				if (info.run_action) {
-					actions_run(ctx.view, server, &mousebind->actions, &ctx);
+					actions_run(ctx.view, &mousebind->actions, &ctx);
 				}
 			}
 		}
@@ -1424,7 +1415,7 @@ process_cursor_axis(struct server *server, enum wl_pointer_axis orientation,
 	/* Bindings swallow mouse events if activated */
 	if (ctx.surface && !consumed) {
 		/* Make sure we are sending the events to the surface under the cursor */
-		cursor_update_common(server, &ctx, NULL);
+		cursor_update_common(&ctx, NULL);
 
 		return true;
 	}
@@ -1440,7 +1431,6 @@ handle_axis(struct wl_listener *listener, void *data)
 	 * event, for example when you move the scroll wheel.
 	 */
 	struct seat *seat = wl_container_of(listener, seat, on_cursor.axis);
-	struct server *server = seat->server;
 	struct wlr_pointer_axis_event *event = data;
 	idle_manager_notify_activity(seat->seat);
 	cursor_set_visible(seat, /* visible */ true);
@@ -1451,7 +1441,7 @@ handle_axis(struct wl_listener *listener, void *data)
 	struct input *input = event->pointer->base.data;
 	double scroll_factor = input->scroll_factor;
 
-	bool notify = process_cursor_axis(server, event->orientation,
+	bool notify = process_cursor_axis(event->orientation,
 		event->delta, event->delta_discrete);
 
 	if (notify) {
@@ -1483,7 +1473,6 @@ cursor_emulate_axis(struct seat *seat, struct wlr_input_device *device,
 		enum wl_pointer_axis orientation, double delta, double delta_discrete,
 		enum wl_pointer_axis_source source, uint32_t time_msec)
 {
-	struct server *server = seat->server;
 	struct input *input = device->data;
 
 	double scroll_factor = 1.0;
@@ -1493,7 +1482,7 @@ cursor_emulate_axis(struct seat *seat, struct wlr_input_device *device,
 		scroll_factor = input->scroll_factor;
 	}
 
-	bool notify = process_cursor_axis(server, orientation, delta, delta_discrete);
+	bool notify = process_cursor_axis(orientation, delta, delta_discrete);
 	if (notify) {
 		/* Notify the client with pointer focus of the axis event. */
 		wlr_seat_pointer_notify_axis(seat->seat, time_msec,
@@ -1514,13 +1503,13 @@ cursor_emulate_move(struct seat *seat, struct wlr_input_device *device,
 	}
 
 	wlr_relative_pointer_manager_v1_send_relative_motion(
-		seat->server->relative_pointer_manager,
+		g_server.relative_pointer_manager,
 		seat->seat, (uint64_t)time_msec * 1000,
 		dx, dy, dx, dy);
 
 	wlr_cursor_move(seat->cursor, device, dx, dy);
 	double sx, sy;
-	bool notify = cursor_process_motion(seat->server, time_msec, &sx, &sy);
+	bool notify = cursor_process_motion(time_msec, &sx, &sy);
 	if (notify) {
 		wlr_seat_pointer_notify_motion(seat->seat, time_msec, sx, sy);
 	}
@@ -1615,7 +1604,7 @@ cursor_reload(struct seat *seat)
 {
 	cursor_load(seat);
 #if HAVE_XWAYLAND
-	xwayland_reset_cursor(seat->server);
+	xwayland_reset_cursor();
 #endif
 	cursor_update_image(seat);
 }
@@ -1643,7 +1632,7 @@ cursor_init(struct seat *seat)
 	CONNECT_SIGNAL(seat->seat, seat, request_set_cursor);
 
 	struct wlr_cursor_shape_manager_v1 *cursor_shape_manager =
-		wlr_cursor_shape_manager_v1_create(seat->server->wl_display,
+		wlr_cursor_shape_manager_v1_create(g_server.wl_display,
 			LAB_CURSOR_SHAPE_V1_VERSION);
 	if (!cursor_shape_manager) {
 		wlr_log(WLR_ERROR, "unable to create cursor_shape interface");

src/input/gestures.c

@@ -114,7 +114,7 @@ handle_hold_end(struct wl_listener *listener, void *data)
 void
 gestures_init(struct seat *seat)
 {
-	seat->pointer_gestures = wlr_pointer_gestures_v1_create(seat->server->wl_display);
+	seat->pointer_gestures = wlr_pointer_gestures_v1_create(g_server.wl_display);
 
 	CONNECT_SIGNAL(seat->cursor, seat, pinch_begin);
 	CONNECT_SIGNAL(seat->cursor, seat, pinch_update);

src/input/ime.c

@@ -179,7 +179,6 @@ static void
 update_popup_position(struct input_method_popup *popup)
 {
 	struct input_method_relay *relay = popup->relay;
-	struct server *server = relay->seat->server;
 	struct text_input *text_input = relay->active_text_input;
 
 	if (!text_input || !relay->focused_surface
@@ -220,7 +219,7 @@ update_popup_position(struct input_method_popup *popup)
 	}
 
 	struct output *output =
-		output_nearest_to(server, cursor_rect.x, cursor_rect.y);
+		output_nearest_to(cursor_rect.x, cursor_rect.y);
 	if (!output_is_usable(output)) {
 		wlr_log(WLR_ERROR,
 			"Cannot position IME popup (unusable output)");
@@ -228,7 +227,7 @@ update_popup_position(struct input_method_popup *popup)
 	}
 	struct wlr_box output_box;
 	wlr_output_layout_get_box(
-		server->output_layout, output->wlr_output, &output_box);
+		g_server.output_layout, output->wlr_output, &output_box);
 
 	/* Use xdg-positioner utilities to position popup */
 	struct wlr_xdg_positioner_rules rules = {
@@ -583,14 +582,14 @@ input_method_relay_create(struct seat *seat)
 	relay->seat = seat;
 	wl_list_init(&relay->text_inputs);
 	wl_list_init(&relay->popups);
-	relay->popup_tree = lab_wlr_scene_tree_create(&seat->server->scene->tree);
+	relay->popup_tree = lab_wlr_scene_tree_create(&g_server.scene->tree);
 
 	relay->new_text_input.notify = handle_new_text_input;
-	wl_signal_add(&seat->server->text_input_manager->events.text_input,
+	wl_signal_add(&g_server.text_input_manager->events.text_input,
 		&relay->new_text_input);
 
 	relay->new_input_method.notify = handle_new_input_method;
-	wl_signal_add(&seat->server->input_method_manager->events.input_method,
+	wl_signal_add(&g_server.input_method_manager->events.input_method,
 		&relay->new_input_method);
 
 	relay->focused_surface_destroy.notify = handle_focused_surface_destroy;

src/input/keyboard.c

@@ -52,9 +52,9 @@ keyboard_reset_current_keybind(void)
 }
 
 static void
-change_vt(struct server *server, unsigned int vt)
+change_vt(unsigned int vt)
 {
-	wlr_session_change_vt(server->session, vt);
+	wlr_session_change_vt(g_server.session, vt);
 }
 
 uint32_t
@@ -131,17 +131,16 @@ handle_modifiers(struct wl_listener *listener, void *data)
 {
 	struct keyboard *keyboard = wl_container_of(listener, keyboard, modifiers);
 	struct seat *seat = keyboard->base.seat;
-	struct server *server = seat->server;
 	struct wlr_keyboard *wlr_keyboard = keyboard->wlr_keyboard;
 
-	if (server->input_mode == LAB_INPUT_STATE_MOVE) {
+	if (g_server.input_mode == LAB_INPUT_STATE_MOVE) {
 		/* Any change to the modifier state re-enable region snap */
 		seat->region_prevent_snap = false;
 		/* Pressing/releasing modifier key may show/hide region overlay */
 		overlay_update(seat);
 	}
 
-	bool cycling = server->input_mode == LAB_INPUT_STATE_CYCLE;
+	bool cycling = g_server.input_mode == LAB_INPUT_STATE_CYCLE;
 
 	if ((cycling || seat->workspace_osd_shown_by_modifier)
 			&& !keyboard_get_all_modifiers(seat)) {
@@ -150,7 +149,7 @@ handle_modifiers(struct wl_listener *listener, void *data)
 				should_cancel_cycling_on_next_key_release = true;
 			} else {
 				should_cancel_cycling_on_next_key_release = false;
-				cycle_finish(server, /*switch_focus*/ true);
+				cycle_finish(/*switch_focus*/ true);
 			}
 		}
 		if (seat->workspace_osd_shown_by_modifier) {
@@ -188,7 +187,7 @@ handle_modifiers(struct wl_listener *listener, void *data)
 }
 
 static struct keybind *
-match_keybinding_for_sym(struct server *server, uint32_t modifiers,
+match_keybinding_for_sym(uint32_t modifiers,
 		xkb_keysym_t sym, xkb_keycode_t xkb_keycode)
 {
 	struct keybind *keybind;
@@ -196,7 +195,7 @@ match_keybinding_for_sym(struct server *server, uint32_t modifiers,
 		if (modifiers ^ keybind->modifiers) {
 			continue;
 		}
-		if (view_inhibits_actions(server->active_view, &keybind->actions)) {
+		if (view_inhibits_actions(g_server.active_view, &keybind->actions)) {
 			continue;
 		}
 		if (sym == XKB_KEY_NoSymbol) {
@@ -241,13 +240,12 @@ match_keybinding_for_sym(struct server *server, uint32_t modifiers,
  * the raw keysym fallback.
  */
 static struct keybind *
-match_keybinding(struct server *server, struct keyinfo *keyinfo,
+match_keybinding(struct keyinfo *keyinfo,
 		bool is_virtual)
 {
 	if (!is_virtual) {
 		/* First try keycodes */
-		struct keybind *keybind = match_keybinding_for_sym(server,
-			keyinfo->modifiers, XKB_KEY_NoSymbol, keyinfo->xkb_keycode);
+		struct keybind *keybind = match_keybinding_for_sym(keyinfo->modifiers, XKB_KEY_NoSymbol, keyinfo->xkb_keycode);
 		if (keybind) {
 			wlr_log(WLR_DEBUG, "keycode matched");
 			return keybind;
@@ -257,7 +255,7 @@ match_keybinding(struct server *server, struct keyinfo *keyinfo,
 	/* Then fall back to keysyms */
 	for (int i = 0; i < keyinfo->translated.nr_syms; i++) {
 		struct keybind *keybind =
-			match_keybinding_for_sym(server, keyinfo->modifiers,
+			match_keybinding_for_sym(keyinfo->modifiers,
 				keyinfo->translated.syms[i], keyinfo->xkb_keycode);
 		if (keybind) {
 			wlr_log(WLR_DEBUG, "translated keysym matched");
@@ -268,7 +266,7 @@ match_keybinding(struct server *server, struct keyinfo *keyinfo,
 	/* And finally test for keysyms without modifier */
 	for (int i = 0; i < keyinfo->raw.nr_syms; i++) {
 		struct keybind *keybind =
-			match_keybinding_for_sym(server, keyinfo->modifiers,
+			match_keybinding_for_sym(keyinfo->modifiers,
 				keyinfo->raw.syms[i], keyinfo->xkb_keycode);
 		if (keybind) {
 			wlr_log(WLR_DEBUG, "raw keysym matched");
@@ -366,7 +364,7 @@ get_keyinfo(struct wlr_keyboard *wlr_keyboard, uint32_t evdev_keycode)
 }
 
 static enum lab_key_handled
-handle_key_release(struct server *server, uint32_t evdev_keycode)
+handle_key_release(uint32_t evdev_keycode)
 {
 	/*
 	 * Release events for keys that were not bound should always be
@@ -387,7 +385,7 @@ handle_key_release(struct server *server, uint32_t evdev_keycode)
 	 */
 	if (should_cancel_cycling_on_next_key_release) {
 		should_cancel_cycling_on_next_key_release = false;
-		cycle_finish(server, /*switch_focus*/ true);
+		cycle_finish(/*switch_focus*/ true);
 	}
 
 	/*
@@ -399,7 +397,7 @@ handle_key_release(struct server *server, uint32_t evdev_keycode)
 }
 
 static bool
-handle_change_vt_key(struct server *server, struct keyboard *keyboard,
+handle_change_vt_key(struct keyboard *keyboard,
 		struct keysyms *translated)
 {
 	for (int i = 0; i < translated->nr_syms; i++) {
@@ -407,7 +405,7 @@ handle_change_vt_key(struct server *server, struct keyboard *keyboard,
 			translated->syms[i] - XKB_KEY_XF86Switch_VT_1 + 1;
 		if (vt >= 1 && vt <= 12) {
 			keyboard_cancel_keybind_repeat(keyboard);
-			change_vt(server, vt);
+			change_vt(vt);
 			return true;
 		}
 	}
@@ -415,31 +413,31 @@ handle_change_vt_key(struct server *server, struct keyboard *keyboard,
 }
 
 static void
-handle_menu_keys(struct server *server, struct keysyms *syms)
+handle_menu_keys(struct keysyms *syms)
 {
-	assert(server->input_mode == LAB_INPUT_STATE_MENU);
+	assert(g_server.input_mode == LAB_INPUT_STATE_MENU);
 
 	for (int i = 0; i < syms->nr_syms; i++) {
 		switch (syms->syms[i]) {
 		case XKB_KEY_Down:
-			menu_item_select_next(server);
+			menu_item_select_next();
 			break;
 		case XKB_KEY_Up:
-			menu_item_select_previous(server);
+			menu_item_select_previous();
 			break;
 		case XKB_KEY_Right:
-			menu_submenu_enter(server);
+			menu_submenu_enter();
 			break;
 		case XKB_KEY_Left:
-			menu_submenu_leave(server);
+			menu_submenu_leave();
 			break;
 		case XKB_KEY_Return:
 		case XKB_KEY_KP_Enter:
-			menu_call_selected_actions(server);
+			menu_call_selected_actions();
 			break;
 		case XKB_KEY_Escape:
-			menu_close_root(server);
-			cursor_update_focus(server);
+			menu_close_root();
+			cursor_update_focus();
 			break;
 		default:
 			continue;
@@ -450,7 +448,7 @@ handle_menu_keys(struct server *server, struct keysyms *syms)
 
 /* Returns true if the keystroke is consumed */
 static bool
-handle_cycle_view_key(struct server *server, struct keyinfo *keyinfo)
+handle_cycle_view_key(struct keyinfo *keyinfo)
 {
 	if (keyinfo->is_modifier) {
 		return false;
@@ -460,19 +458,19 @@ handle_cycle_view_key(struct server *server, struct keyinfo *keyinfo)
 	for (int i = 0; i < keyinfo->translated.nr_syms; i++) {
 		if (keyinfo->translated.syms[i] == XKB_KEY_Escape) {
 			/* Esc deactivates window switcher */
-			cycle_finish(server, /*switch_focus*/ false);
+			cycle_finish(/*switch_focus*/ false);
 			return true;
 		}
 		if (keyinfo->translated.syms[i] == XKB_KEY_Up
 				|| keyinfo->translated.syms[i] == XKB_KEY_Left) {
 			/* Up/Left cycles the window backward */
-			cycle_step(server, LAB_CYCLE_DIR_BACKWARD);
+			cycle_step(LAB_CYCLE_DIR_BACKWARD);
 			return true;
 		}
 		if (keyinfo->translated.syms[i] == XKB_KEY_Down
 				|| keyinfo->translated.syms[i] == XKB_KEY_Right) {
 			/* Down/Right cycles the window forward */
-			cycle_step(server, LAB_CYCLE_DIR_FORWARD);
+			cycle_step(LAB_CYCLE_DIR_FORWARD);
 			return true;
 		}
 	}
@@ -483,10 +481,9 @@ static enum lab_key_handled
 handle_compositor_keybindings(struct keyboard *keyboard,
 		struct wlr_keyboard_key_event *event)
 {
-	struct server *server = &g_server;
 	struct wlr_keyboard *wlr_keyboard = keyboard->wlr_keyboard;
 	struct keyinfo keyinfo = get_keyinfo(wlr_keyboard, event->keycode);
-	bool locked = server->session_lock_manager->locked;
+	bool locked = g_server.session_lock_manager->locked;
 
 	key_state_set_pressed(event->keycode,
 		event->state == WL_KEYBOARD_KEY_STATE_PRESSED);
@@ -498,15 +495,15 @@ handle_compositor_keybindings(struct keyboard *keyboard,
 				cur_keybind = NULL;
 				return LAB_KEY_HANDLED_TRUE;
 			}
-			actions_run(NULL, server, &cur_keybind->actions, NULL);
+			actions_run(NULL, &cur_keybind->actions, NULL);
 			return LAB_KEY_HANDLED_TRUE;
 		} else {
-			return handle_key_release(server, event->keycode);
+			return handle_key_release(event->keycode);
 		}
 	}
 
 	/* Catch C-A-F1 to C-A-F12 to change tty */
-	if (handle_change_vt_key(server, keyboard, &keyinfo.translated)) {
+	if (handle_change_vt_key(keyboard, &keyinfo.translated)) {
 		key_state_store_pressed_key_as_bound(event->keycode);
 		return LAB_KEY_HANDLED_TRUE_AND_VT_CHANGED;
 	}
@@ -517,12 +514,12 @@ handle_compositor_keybindings(struct keyboard *keyboard,
 	 * _all_ key press/releases are registered
 	 */
 	if (!locked) {
-		if (server->input_mode == LAB_INPUT_STATE_MENU) {
+		if (g_server.input_mode == LAB_INPUT_STATE_MENU) {
 			key_state_store_pressed_key_as_bound(event->keycode);
-			handle_menu_keys(server, &keyinfo.translated);
+			handle_menu_keys(&keyinfo.translated);
 			return LAB_KEY_HANDLED_TRUE;
-		} else if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
-			if (handle_cycle_view_key(server, &keyinfo)) {
+		} else if (g_server.input_mode == LAB_INPUT_STATE_CYCLE) {
+			if (handle_cycle_view_key(&keyinfo)) {
 				key_state_store_pressed_key_as_bound(event->keycode);
 				return LAB_KEY_HANDLED_TRUE;
 			}
@@ -532,7 +529,7 @@ handle_compositor_keybindings(struct keyboard *keyboard,
 	/*
 	 * Handle compositor keybinds
 	 */
-	cur_keybind = match_keybinding(server, &keyinfo, keyboard->is_virtual);
+	cur_keybind = match_keybinding(&keyinfo, keyboard->is_virtual);
 	if (cur_keybind && (!locked || cur_keybind->allow_when_locked)) {
 		/*
 		 * Update key-state before action_run() because the action
@@ -541,7 +538,7 @@ handle_compositor_keybindings(struct keyboard *keyboard,
 		 */
 		key_state_store_pressed_key_as_bound(event->keycode);
 		if (!cur_keybind->on_release) {
-			actions_run(NULL, server, &cur_keybind->actions, NULL);
+			actions_run(NULL, &cur_keybind->actions, NULL);
 		}
 		return LAB_KEY_HANDLED_TRUE;
 	}
@@ -571,7 +568,7 @@ handle_keybind_repeat(void *data)
 }
 
 static void
-start_keybind_repeat(struct server *server, struct keyboard *keyboard,
+start_keybind_repeat(struct keyboard *keyboard,
 		struct wlr_keyboard_key_event *event)
 {
 	struct wlr_keyboard *wlr_keyboard = keyboard->wlr_keyboard;
@@ -582,7 +579,7 @@ start_keybind_repeat(struct server *server, struct keyboard *keyboard,
 		keyboard->keybind_repeat_keycode = event->keycode;
 		keyboard->keybind_repeat_rate = wlr_keyboard->repeat_info.rate;
 		keyboard->keybind_repeat = wl_event_loop_add_timer(
-			server->wl_event_loop, handle_keybind_repeat, keyboard);
+			g_server.wl_event_loop, handle_keybind_repeat, keyboard);
 		wl_event_source_timer_update(keyboard->keybind_repeat,
 			wlr_keyboard->repeat_info.delay);
 	}
@@ -638,7 +635,7 @@ handle_key(struct wl_listener *listener, void *data)
 		 */
 		if (!is_modifier(keyboard->wlr_keyboard, event->keycode)
 				&& event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
-			start_keybind_repeat(seat->server, keyboard, event);
+			start_keybind_repeat(keyboard, event);
 		}
 	} else if (!input_method_keyboard_grab_forward_key(keyboard, event)) {
 		wlr_seat_set_keyboard(wlr_seat, keyboard->wlr_keyboard);
@@ -714,7 +711,7 @@ keyboard_update_layout(struct seat *seat, xkb_layout_index_t layout)
 }
 
 static void
-reset_window_keyboard_layout_groups(struct server *server)
+reset_window_keyboard_layout_groups(void)
 {
 	if (!rc.kb_layout_per_window) {
 		return;
@@ -726,15 +723,15 @@ reset_window_keyboard_layout_groups(struct server *server)
 	 * but let's keep it simple for now and just reset them all.
 	 */
 	struct view *view;
-	for_each_view(view, &server->views, LAB_VIEW_CRITERIA_NONE) {
+	for_each_view(view, &g_server.views, LAB_VIEW_CRITERIA_NONE) {
 		view->keyboard_layout = 0;
 	}
 
-	struct view *active_view = server->active_view;
+	struct view *active_view = g_server.active_view;
 	if (!active_view) {
 		return;
 	}
-	keyboard_update_layout(&server->seat, active_view->keyboard_layout);
+	keyboard_update_layout(&g_server.seat, active_view->keyboard_layout);
 }
 
 /*
@@ -742,7 +739,7 @@ reset_window_keyboard_layout_groups(struct server *server)
  * XKB_DEFAULT_OPTIONS, and friends.
  */
 static void
-set_layout(struct server *server, struct wlr_keyboard *kb)
+set_layout(struct wlr_keyboard *kb)
 {
 	static bool fallback_mode;
 
@@ -761,7 +758,7 @@ set_layout(struct server *server, struct wlr_keyboard *kb)
 	if (keymap && !layout_empty) {
 		if (!wlr_keyboard_keymaps_match(kb->keymap, keymap)) {
 			wlr_keyboard_set_keymap(kb, keymap);
-			reset_window_keyboard_layout_groups(server);
+			reset_window_keyboard_layout_groups();
 		}
 		xkb_keymap_unref(keymap);
 	} else {
@@ -771,7 +768,7 @@ set_layout(struct server *server, struct wlr_keyboard *kb)
 			wlr_log(WLR_ERROR, "entering fallback mode with layout 'us'");
 			fallback_mode = true;
 			setenv("XKB_DEFAULT_LAYOUT", "us", 1);
-			set_layout(server, kb);
+			set_layout(kb);
 		}
 	}
 	xkb_context_unref(context);
@@ -781,10 +778,10 @@ void
 keyboard_configure(struct seat *seat, struct wlr_keyboard *kb, bool is_virtual)
 {
 	if (!is_virtual) {
-		set_layout(seat->server, kb);
+		set_layout(kb);
 	}
 	wlr_keyboard_set_repeat_info(kb, rc.repeat_rate, rc.repeat_delay);
-	keybind_update_keycodes(seat->server);
+	keybind_update_keycodes();
 }
 
 void

src/input/tablet-pad.c

@@ -183,9 +183,9 @@ tablet_pad_create(struct seat *seat, struct wlr_input_device *wlr_device)
 	pad->seat = seat;
 	pad->wlr_input_device = wlr_device;
 	pad->pad = wlr_tablet_pad_from_input_device(wlr_device);
-	if (seat->server->tablet_manager) {
+	if (g_server.tablet_manager) {
 		pad->pad_v2 = wlr_tablet_pad_create(
-			seat->server->tablet_manager, seat->seat, wlr_device);
+			g_server.tablet_manager, seat->seat, wlr_device);
 	}
 	pad->pad->data = pad;
 	wlr_log(WLR_INFO, "tablet pad capabilities: %zu button(s) %zu strip(s) %zu ring(s)",

src/input/tablet.c

@@ -44,7 +44,7 @@ handle_set_cursor(struct wl_listener *listener, void *data)
 	struct wlr_seat_client *focused_client =
 		seat->seat->pointer_state.focused_client;
 
-	if (seat->server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		return;
 	}
 
@@ -76,7 +76,7 @@ tablet_tool_create(struct seat *seat,
 	struct drawing_tablet_tool *tool = znew(*tool);
 	tool->seat = seat;
 	tool->tool_v2 =
-		wlr_tablet_tool_create(seat->server->tablet_manager,
+		wlr_tablet_tool_create(g_server.tablet_manager,
 			seat->seat, wlr_tablet_tool);
 	wlr_tablet_tool->data = tool;
 	wlr_log(WLR_INFO, "tablet tool capabilities:%s%s%s%s%s%s",
@@ -239,7 +239,7 @@ tablet_get_coords(struct drawing_tablet *tablet, struct drawing_tablet_tool *too
 
 	double sx, sy;
 	struct wlr_scene_node *node =
-		wlr_scene_node_at(&tablet->seat->server->scene->tree.node, lx, ly, &sx, &sy);
+		wlr_scene_node_at(&g_server.scene->tree.node, lx, ly, &sx, &sy);
 
 	/* find the surface and return it if it accepts tablet events */
 	struct wlr_surface *surface = lab_wlr_surface_from_node(node);
@@ -275,7 +275,7 @@ notify_motion(struct drawing_tablet *tablet, struct drawing_tablet_tool *tool,
 	}
 
 	double sx, sy;
-	bool notify = cursor_process_motion(tablet->seat->server, time, &sx, &sy);
+	bool notify = cursor_process_motion(time, &sx, &sy);
 	if (notify) {
 		wlr_tablet_v2_tablet_tool_notify_motion(tool->tool_v2, sx, sy);
 		if (enter_surface) {
@@ -449,7 +449,7 @@ handle_tablet_tool_axis(struct wl_listener *listener, void *data)
 	 * Note that surface is also NULL when mouse emulation is forced.
 	 */
 	if (!is_down_mouse_emulation && ((surface
-			&& tablet->seat->server->input_mode == LAB_INPUT_STATE_PASSTHROUGH)
+			&& g_server.input_mode == LAB_INPUT_STATE_PASSTHROUGH)
 			|| wlr_tablet_tool_v2_has_implicit_grab(tool->tool_v2))) {
 		/* motion seems to be supported by all tools */
 		notify_motion(tablet, tool, surface, x, y, dx, dy, ev->time_msec);
@@ -667,8 +667,7 @@ handle_tablet_tool_button(struct wl_listener *listener, void *data)
 				if (mousebind->mouse_event == MOUSE_ACTION_PRESS
 						&& mousebind->button == button
 						&& mousebind->context == LAB_NODE_CLIENT) {
-					actions_run(view, tool->seat->server,
-						&mousebind->actions, NULL);
+					actions_run(view, &mousebind->actions, NULL);
 				}
 			}
 		}
@@ -720,9 +719,9 @@ tablet_create(struct seat *seat, struct wlr_input_device *wlr_device)
 	tablet->wlr_input_device = wlr_device;
 	tablet->tablet = wlr_tablet_from_input_device(wlr_device);
 	tablet->tablet->data = tablet;
-	if (seat->server->tablet_manager) {
+	if (g_server.tablet_manager) {
 		tablet->tablet_v2 = wlr_tablet_create(
-			seat->server->tablet_manager, seat->seat, wlr_device);
+			g_server.tablet_manager, seat->seat, wlr_device);
 	}
 	wlr_log(WLR_INFO, "tablet dimensions: %.2fmm x %.2fmm",
 		tablet->tablet->width_mm, tablet->tablet->height_mm);

src/input/touch.c

@@ -52,7 +52,7 @@ touch_get_coords(struct seat *seat, struct wlr_touch *touch, double x, double y,
 	 * This matches normal pointer/mouse behavior where the first click on
 	 * a surface closes a root/client menu.
 	 */
-	if (seat->server->input_mode == LAB_INPUT_STATE_MENU) {
+	if (g_server.input_mode == LAB_INPUT_STATE_MENU) {
 		return NULL;
 	}
 
@@ -63,7 +63,7 @@ touch_get_coords(struct seat *seat, struct wlr_touch *touch, double x, double y,
 
 	double sx, sy;
 	struct wlr_scene_node *node =
-		wlr_scene_node_at(&seat->server->scene->tree.node, lx, ly, &sx, &sy);
+		wlr_scene_node_at(&g_server.scene->tree.node, lx, ly, &sx, &sy);
 
 	*x_offset = lx - sx;
 	*y_offset = ly - sy;
@@ -169,7 +169,7 @@ handle_touch_down(struct wl_listener *listener, void *data)
 			if (mousebind->mouse_event == MOUSE_ACTION_PRESS
 					&& mousebind->button == BTN_LEFT
 					&& mousebind->context == LAB_NODE_CLIENT) {
-				actions_run(view, seat->server, &mousebind->actions, NULL);
+				actions_run(view, &mousebind->actions, NULL);
 			}
 		}
 
@@ -207,7 +207,7 @@ handle_touch_up(struct wl_listener *listener, void *data)
 			} else {
 				cursor_emulate_button(seat, BTN_LEFT,
 					WL_POINTER_BUTTON_STATE_RELEASED, event->time_msec);
-				ssd_update_hovered_button(seat->server, NULL);
+				ssd_update_hovered_button(NULL);
 			}
 			wl_list_remove(&touch_point->link);
 			zfree(touch_point);

src/interactive.c

@@ -36,22 +36,22 @@ max_move_scale(double pos_cursor, double pos_old, double size_old,
 }
 
 void
-interactive_anchor_to_cursor(struct server *server, struct wlr_box *geo)
+interactive_anchor_to_cursor(struct wlr_box *geo)
 {
-	assert(server->input_mode == LAB_INPUT_STATE_MOVE);
+	assert(g_server.input_mode == LAB_INPUT_STATE_MOVE);
 	if (wlr_box_empty(geo)) {
 		return;
 	}
 	/* Resize grab_box while anchoring it to grab_{x,y} */
-	server->grab_box.x = max_move_scale(server->grab_x, server->grab_box.x,
-		server->grab_box.width, geo->width);
-	server->grab_box.y = max_move_scale(server->grab_y, server->grab_box.y,
-		server->grab_box.height, geo->height);
-	server->grab_box.width = geo->width;
-	server->grab_box.height = geo->height;
+	g_server.grab_box.x = max_move_scale(g_server.grab_x, g_server.grab_box.x,
+		g_server.grab_box.width, geo->width);
+	g_server.grab_box.y = max_move_scale(g_server.grab_y, g_server.grab_box.y,
+		g_server.grab_box.height, geo->height);
+	g_server.grab_box.width = geo->width;
+	g_server.grab_box.height = geo->height;
 
-	geo->x = server->grab_box.x + (server->seat.cursor->x - server->grab_x);
-	geo->y = server->grab_box.y + (server->seat.cursor->y - server->grab_y);
+	geo->x = g_server.grab_box.x + (g_server.seat.cursor->x - g_server.grab_x);
+	geo->y = g_server.grab_box.y + (g_server.seat.cursor->y - g_server.grab_y);
 }
 
 /*
@@ -60,21 +60,21 @@ interactive_anchor_to_cursor(struct server *server, struct wlr_box *geo)
  * then interactive_begin() is called.
  */
 void
-interactive_set_grab_context(struct server *server, const struct cursor_context *ctx)
+interactive_set_grab_context(const struct cursor_context *ctx)
 {
 	if (!ctx->view) {
 		return;
 	}
-	if (server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		return;
 	}
 
-	server->grabbed_view = ctx->view;
-	server->grab_x = server->seat.cursor->x;
-	server->grab_y = server->seat.cursor->y;
-	server->grab_box = ctx->view->current;
-	server->resize_edges =
-		cursor_get_resize_edges(server->seat.cursor, ctx);
+	g_server.grabbed_view = ctx->view;
+	g_server.grab_x = g_server.seat.cursor->x;
+	g_server.grab_y = g_server.seat.cursor->y;
+	g_server.grab_box = ctx->view->current;
+	g_server.resize_edges =
+		cursor_get_resize_edges(g_server.seat.cursor, ctx);
 }
 
 void
@@ -86,11 +86,10 @@ interactive_begin(struct view *view, enum input_mode mode, enum lab_edge edges)
 	 * the compositor stops propagating pointer events to clients and
 	 * instead consumes them itself, to move or resize windows.
 	 */
-	struct server *server = view->server;
-	struct seat *seat = &server->seat;
+	struct seat *seat = &g_server.seat;
 
-	if (server->input_mode != LAB_INPUT_STATE_PASSTHROUGH
-			|| view != server->grabbed_view) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH
+			|| view != g_server.grabbed_view) {
 		return;
 	}
 
@@ -138,7 +137,7 @@ interactive_begin(struct view *view, enum input_mode mode, enum lab_edge edges)
 		 * Otherwise, they were set already from cursor context.
 		 */
 		if (edges != LAB_EDGE_NONE) {
-			server->resize_edges = edges;
+			g_server.resize_edges = edges;
 		}
 
 		/*
@@ -147,15 +146,15 @@ interactive_begin(struct view *view, enum input_mode mode, enum lab_edge edges)
 		 * keep the same geometry as the starting point.
 		 */
 		enum view_axis maximized = view->maximized;
-		if (server->resize_edges & LAB_EDGES_LEFT_RIGHT) {
+		if (g_server.resize_edges & LAB_EDGES_LEFT_RIGHT) {
 			maximized &= ~VIEW_AXIS_HORIZONTAL;
 		}
-		if (server->resize_edges & LAB_EDGES_TOP_BOTTOM) {
+		if (g_server.resize_edges & LAB_EDGES_TOP_BOTTOM) {
 			maximized &= ~VIEW_AXIS_VERTICAL;
 		}
 		view_set_maximized(view, maximized);
 		view_set_untiled(view);
-		cursor_shape = cursor_get_from_edge(server->resize_edges);
+		cursor_shape = cursor_get_from_edge(g_server.resize_edges);
 		break;
 	}
 	default:
@@ -175,7 +174,7 @@ interactive_begin(struct view *view, enum input_mode mode, enum lab_edge edges)
 	if (mode == LAB_INPUT_STATE_MOVE && !view_is_floating(view)
 			&& rc.unsnap_threshold <= 0) {
 		struct wlr_box natural_geo = view->natural_geometry;
-		interactive_anchor_to_cursor(server, &natural_geo);
+		interactive_anchor_to_cursor(&natural_geo);
 		/* Shaded clients will not process resize events until unshaded */
 		view_set_shade(view, false);
 		view_set_maximized(view, VIEW_AXIS_NONE);
@@ -187,7 +186,7 @@ interactive_begin(struct view *view, enum input_mode mode, enum lab_edge edges)
 		resize_indicator_show(view);
 	}
 	if (rc.window_edge_strength) {
-		edges_calculate_visibility(server, view);
+		edges_calculate_visibility(view);
 	}
 }
 
@@ -199,7 +198,7 @@ edge_from_cursor(struct seat *seat, struct output **dest_output,
 	*edge1 = LAB_EDGE_NONE;
 	*edge2 = LAB_EDGE_NONE;
 
-	if (!view_is_floating(seat->server->grabbed_view)) {
+	if (!view_is_floating(g_server.grabbed_view)) {
 		return false;
 	}
 
@@ -207,7 +206,7 @@ edge_from_cursor(struct seat *seat, struct output **dest_output,
 		return false;
 	}
 
-	struct output *output = output_nearest_to_cursor(seat->server);
+	struct output *output = output_nearest_to_cursor();
 	if (!output_is_usable(output)) {
 		wlr_log(WLR_ERROR, "output at cursor is unusable");
 		return false;
@@ -221,25 +220,25 @@ edge_from_cursor(struct seat *seat, struct output **dest_output,
 	int bottom_range = rc.snap_edge_range_outer;
 	int left_range = rc.snap_edge_range_outer;
 	int right_range = rc.snap_edge_range_outer;
-	if (wlr_output_layout_adjacent_output(seat->server->output_layout, WLR_DIRECTION_UP,
+	if (wlr_output_layout_adjacent_output(g_server.output_layout, WLR_DIRECTION_UP,
 			output->wlr_output, cursor_x, cursor_y)) {
 		top_range = rc.snap_edge_range_inner;
 	}
-	if (wlr_output_layout_adjacent_output(seat->server->output_layout, WLR_DIRECTION_DOWN,
+	if (wlr_output_layout_adjacent_output(g_server.output_layout, WLR_DIRECTION_DOWN,
 			output->wlr_output, cursor_x, cursor_y)) {
 		bottom_range = rc.snap_edge_range_inner;
 	}
-	if (wlr_output_layout_adjacent_output(seat->server->output_layout, WLR_DIRECTION_LEFT,
+	if (wlr_output_layout_adjacent_output(g_server.output_layout, WLR_DIRECTION_LEFT,
 			output->wlr_output, cursor_x, cursor_y)) {
 		left_range = rc.snap_edge_range_inner;
 	}
-	if (wlr_output_layout_adjacent_output(seat->server->output_layout, WLR_DIRECTION_RIGHT,
+	if (wlr_output_layout_adjacent_output(g_server.output_layout, WLR_DIRECTION_RIGHT,
 			output->wlr_output, cursor_x, cursor_y)) {
 		right_range = rc.snap_edge_range_inner;
 	}
 
 	/* Translate into output local coordinates */
-	wlr_output_layout_output_coords(seat->server->output_layout,
+	wlr_output_layout_output_coords(g_server.output_layout,
 		output->wlr_output, &cursor_x, &cursor_y);
 
 	struct wlr_box *area = &output->usable_area;
@@ -284,7 +283,7 @@ snap_to_edge(struct view *view)
 {
 	struct output *output;
 	enum lab_edge edge1, edge2;
-	if (!edge_from_cursor(&view->server->seat, &output, &edge1, &edge2)) {
+	if (!edge_from_cursor(&g_server.seat, &output, &edge1, &edge2)) {
 		return false;
 	}
 	enum lab_edge edge = edge1 | edge2;
@@ -304,11 +303,11 @@ snap_to_edge(struct view *view)
 static bool
 snap_to_region(struct view *view)
 {
-	if (!regions_should_snap(view->server)) {
+	if (!regions_should_snap()) {
 		return false;
 	}
 
-	struct region *region = regions_from_cursor(view->server);
+	struct region *region = regions_from_cursor();
 	if (region) {
 		view_snap_to_region(view, region);
 		return true;
@@ -321,11 +320,11 @@ interactive_finish(struct view *view)
 {
 	assert(view);
 
-	if (view->server->grabbed_view != view) {
+	if (g_server.grabbed_view != view) {
 		return;
 	}
 
-	if (view->server->input_mode == LAB_INPUT_STATE_MOVE) {
+	if (g_server.input_mode == LAB_INPUT_STATE_MOVE) {
 		if (!snap_to_region(view)) {
 			snap_to_edge(view);
 		}
@@ -344,25 +343,25 @@ interactive_cancel(struct view *view)
 {
 	assert(view);
 
-	if (view->server->grabbed_view != view) {
+	if (g_server.grabbed_view != view) {
 		return;
 	}
 
-	view->server->grabbed_view = NULL;
+	g_server.grabbed_view = NULL;
 
 	/*
 	 * It's possible that grabbed_view was set but interactive_begin()
 	 * wasn't called yet. In that case, we are done.
 	 */
-	if (view->server->input_mode != LAB_INPUT_STATE_MOVE
-			&& view->server->input_mode != LAB_INPUT_STATE_RESIZE) {
+	if (g_server.input_mode != LAB_INPUT_STATE_MOVE
+			&& g_server.input_mode != LAB_INPUT_STATE_RESIZE) {
 		return;
 	}
 
-	overlay_finish(&view->server->seat);
+	overlay_finish(&g_server.seat);
 
 	resize_indicator_hide(view);
 
 	/* Restore keyboard/pointer focus */
-	seat_focus_override_end(&view->server->seat, /*restore_focus*/ true);
+	seat_focus_override_end(&g_server.seat, /*restore_focus*/ true);
 }

src/layers.c

@@ -78,9 +78,8 @@ layers_arrange(struct output *output)
 
 	apply_override(output, &usable_area);
 
-	struct server *server = output->server;
 	struct wlr_scene_output *scene_output =
-		wlr_scene_get_scene_output(server->scene, output->wlr_output);
+		wlr_scene_get_scene_output(g_server.scene, output->wlr_output);
 	if (!scene_output) {
 		wlr_log(WLR_DEBUG, "no wlr_scene_output");
 		return;
@@ -141,10 +140,10 @@ has_exclusive_interactivity(struct wlr_scene_layer_surface_v1 *scene)
  * toplevel if one exists.
  */
 static void
-try_to_focus_next_layer_or_toplevel(struct server *server)
+try_to_focus_next_layer_or_toplevel(void)
 {
-	struct seat *seat = &server->seat;
-	struct output *output = output_nearest_to_cursor(server);
+	struct seat *seat = &g_server.seat;
+	struct output *output = output_nearest_to_cursor();
 	if (!output_is_usable(output)) {
 		goto no_output;
 	}
@@ -235,7 +234,7 @@ layer_try_set_focus(struct seat *seat, struct wlr_layer_surface_v1 *layer_surfac
 	case ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE:
 		wlr_log(WLR_DEBUG, "interactive-none '%p'", layer_surface);
 		if (seat->focused_layer == layer_surface) {
-			try_to_focus_next_layer_or_toplevel(seat->server);
+			try_to_focus_next_layer_or_toplevel();
 		}
 		break;
 	}
@@ -278,19 +277,18 @@ handle_surface_commit(struct wl_listener *listener, void *data)
 		 * cursor-button-press).
 		 */
 		if (is_on_demand(layer_surface)) {
-			struct seat *seat = &layer->server->seat;
+			struct seat *seat = &g_server.seat;
 			if (seat->focused_layer == layer_surface) {
 				/*
 				 * Must be change from EXCLUSIVE to ON_DEMAND,
 				 * so we should give us focus.
 				 */
-				struct server *server = layer->server;
-				try_to_focus_next_layer_or_toplevel(server);
+				try_to_focus_next_layer_or_toplevel();
 			}
 			goto out;
 		}
 		/* Handle EXCLUSIVE and NONE requests */
-		struct seat *seat = &layer->server->seat;
+		struct seat *seat = &g_server.seat;
 		layer_try_set_focus(seat, layer_surface);
 	}
 out:
@@ -302,7 +300,7 @@ out:
 		 * Update cursor focus here to ensure we
 		 * enter a new/moved/resized layer surface.
 		 */
-		cursor_update_focus(layer->server);
+		cursor_update_focus();
 	}
 }
 
@@ -312,7 +310,7 @@ handle_node_destroy(struct wl_listener *listener, void *data)
 	struct lab_layer_surface *layer =
 		wl_container_of(listener, layer, node_destroy);
 
-	struct seat *seat = &layer->server->seat;
+	struct seat *seat = &g_server.seat;
 
 	/*
 	 * If the surface of this node has the current keyboard focus, then we
@@ -374,11 +372,11 @@ handle_unmap(struct wl_listener *listener, void *data)
 	if (layer_surface->output) {
 		output_update_usable_area(layer_surface->output->data);
 	}
-	struct seat *seat = &layer->server->seat;
+	struct seat *seat = &g_server.seat;
 	if (seat->focused_layer == layer_surface) {
-		try_to_focus_next_layer_or_toplevel(layer->server);
+		try_to_focus_next_layer_or_toplevel();
 	}
-	cursor_update_focus(layer->server);
+	cursor_update_focus();
 
 	layer->being_unmapped = false;
 }
@@ -424,7 +422,7 @@ handle_map(struct wl_listener *listener, void *data)
 		return;
 	}
 
-	struct seat *seat = &layer->server->seat;
+	struct seat *seat = &g_server.seat;
 	layer_try_set_focus(seat, layer->scene_layer_surface->layer_surface);
 }
 
@@ -439,7 +437,7 @@ handle_popup_destroy(struct wl_listener *listener, void *data)
 {
 	struct lab_layer_popup *popup =
 		wl_container_of(listener, popup, destroy);
-	struct seat *seat = &popup->server->seat;
+	struct seat *seat = &g_server.seat;
 
 	struct wlr_xdg_popup *_popup, *tmp;
 	wl_list_for_each_safe(_popup, tmp, &popup->wlr_popup->base->popups, link) {
@@ -461,10 +459,10 @@ handle_popup_destroy(struct wl_listener *listener, void *data)
 		if (popup->parent_was_focused && popup->wlr_popup->parent) {
 			seat_force_focus_surface(seat, popup->wlr_popup->parent);
 		} else {
-			desktop_focus_topmost_view(popup->server);
+			desktop_focus_topmost_view();
 		}
 	}
-	cursor_update_focus(popup->server);
+	cursor_update_focus();
 
 	free(popup);
 }
@@ -529,8 +527,7 @@ handle_popup_commit(struct wl_listener *listener, void *data)
 		popup->commit.notify = NULL;
 
 		/* Force focus when popup was triggered by IPC */
-		struct server *server = popup->server;
-		struct seat *seat = &server->seat;
+		struct seat *seat = &g_server.seat;
 		bool requesting_grab = !!popup->wlr_popup->seat;
 		if (requesting_grab) {
 			if (surface_is_focused(seat, popup->wlr_popup->parent)) {
@@ -553,11 +550,10 @@ handle_popup_reposition(struct wl_listener *listener, void *data)
 static void handle_popup_new_popup(struct wl_listener *listener, void *data);
 
 static struct lab_layer_popup *
-create_popup(struct server *server, struct wlr_xdg_popup *wlr_popup,
+create_popup(struct wlr_xdg_popup *wlr_popup,
 		struct wlr_scene_tree *parent)
 {
 	struct lab_layer_popup *popup = znew(*popup);
-	popup->server = server;
 	popup->wlr_popup = wlr_popup;
 	popup->scene_tree =
 		wlr_scene_xdg_surface_create(parent, wlr_popup->base);
@@ -591,8 +587,7 @@ handle_popup_new_popup(struct wl_listener *listener, void *data)
 	struct lab_layer_popup *lab_layer_popup =
 		wl_container_of(listener, lab_layer_popup, new_popup);
 	struct wlr_xdg_popup *wlr_popup = data;
-	struct lab_layer_popup *new_popup = create_popup(
-		lab_layer_popup->server, wlr_popup,
+	struct lab_layer_popup *new_popup = create_popup(wlr_popup,
 		lab_layer_popup->scene_tree);
 
 	new_popup->output_toplevel_sx_box =
@@ -607,12 +602,11 @@ static void
 move_popup_to_top_layer(struct lab_layer_surface *toplevel,
 		struct lab_layer_popup *popup)
 {
-	struct server *server = toplevel->server;
 	struct wlr_output *wlr_output =
 		toplevel->scene_layer_surface->layer_surface->output;
 	struct output *output = (struct output *)wlr_output->data;
 	struct wlr_box box = { 0 };
-	wlr_output_layout_get_box(server->output_layout, wlr_output, &box);
+	wlr_output_layout_get_box(g_server.output_layout, wlr_output, &box);
 	int lx = toplevel->scene_layer_surface->tree->node.x + box.x;
 	int ly = toplevel->scene_layer_surface->tree->node.y + box.y;
 
@@ -630,7 +624,6 @@ handle_new_popup(struct wl_listener *listener, void *data)
 		wl_container_of(listener, toplevel, new_popup);
 	struct wlr_xdg_popup *wlr_popup = data;
 
-	struct server *server = toplevel->server;
 	struct wlr_scene_layer_surface_v1 *surface = toplevel->scene_layer_surface;
 	struct output *output = surface->layer_surface->output->data;
 
@@ -638,7 +631,7 @@ handle_new_popup(struct wl_listener *listener, void *data)
 	wlr_scene_node_coords(&surface->tree->node, &lx, &ly);
 
 	struct wlr_box output_box = { 0 };
-	wlr_output_layout_get_box(server->output_layout,
+	wlr_output_layout_get_box(g_server.output_layout,
 		output->wlr_output, &output_box);
 
 	/*
@@ -654,7 +647,7 @@ handle_new_popup(struct wl_listener *listener, void *data)
 		.height = output_box.height,
 	};
 	struct lab_layer_popup *popup =
-		create_popup(server, wlr_popup, surface->tree);
+		create_popup(wlr_popup, surface->tree);
 	popup->output_toplevel_sx_box = output_toplevel_sx_box;
 
 	if (surface->layer_surface->current.layer
@@ -666,12 +659,10 @@ handle_new_popup(struct wl_listener *listener, void *data)
 static void
 handle_new_layer_surface(struct wl_listener *listener, void *data)
 {
-	struct server *server = wl_container_of(
-		listener, server, new_layer_surface);
 	struct wlr_layer_surface_v1 *layer_surface = data;
 
 	if (!layer_surface->output) {
-		struct output *output = output_nearest_to_cursor(server);
+		struct output *output = output_nearest_to_cursor();
 		if (!output || !output->scene_output) {
 			/*
 			 * We are not using output_is_usable() here because
@@ -709,7 +700,6 @@ handle_new_layer_surface(struct wl_listener *listener, void *data)
 	node_descriptor_create(&surface->scene_layer_surface->tree->node,
 		LAB_NODE_LAYER_SURFACE, /*view*/ NULL, surface);
 
-	surface->server = server;
 	surface->scene_layer_surface->layer_surface = layer_surface;
 
 	surface->surface_commit.notify = handle_surface_commit;
@@ -735,17 +725,17 @@ handle_new_layer_surface(struct wl_listener *listener, void *data)
 }
 
 void
-layers_init(struct server *server)
+layers_init(void)
 {
-	server->layer_shell = wlr_layer_shell_v1_create(server->wl_display,
+	g_server.layer_shell = wlr_layer_shell_v1_create(g_server.wl_display,
 		LAB_LAYERSHELL_VERSION);
-	server->new_layer_surface.notify = handle_new_layer_surface;
-	wl_signal_add(&server->layer_shell->events.new_surface,
-		&server->new_layer_surface);
+	g_server.new_layer_surface.notify = handle_new_layer_surface;
+	wl_signal_add(&g_server.layer_shell->events.new_surface,
+		&g_server.new_layer_surface);
 }
 
 void
-layers_finish(struct server *server)
+layers_finish(void)
 {
-	wl_list_remove(&server->new_layer_surface.link);
+	wl_list_remove(&g_server.new_layer_surface.link);
 }

src/magnifier.c

@@ -41,8 +41,7 @@ box_logical_to_physical(struct wlr_box *box, struct wlr_output *output)
 void
 magnifier_draw(struct output *output, struct wlr_buffer *output_buffer, struct wlr_box *damage)
 {
-	struct server *server = output->server;
-	struct theme *theme = server->theme;
+	struct theme *theme = g_server.theme;
 	bool fullscreen = (rc.mag_width == -1 || rc.mag_height == -1);
 
 	struct wlr_box output_box = {
@@ -51,9 +50,9 @@ magnifier_draw(struct output *output, struct wlr_buffer *output_buffer, struct w
 	};
 
 	/* Cursor position in per-output logical coordinate */
-	double cursor_logical_x = server->seat.cursor->x;
-	double cursor_logical_y = server->seat.cursor->y;
-	wlr_output_layout_output_coords(server->output_layout,
+	double cursor_logical_x = g_server.seat.cursor->x;
+	double cursor_logical_y = g_server.seat.cursor->y;
+	wlr_output_layout_output_coords(g_server.output_layout,
 		output->wlr_output, &cursor_logical_x, &cursor_logical_y);
 	/* Cursor position in per-output physical coordinate */
 	struct wlr_box cursor_pos = {
@@ -96,7 +95,7 @@ magnifier_draw(struct output *output, struct wlr_buffer *output_buffer, struct w
 	}
 	if (!tmp_buffer) {
 		tmp_buffer = wlr_allocator_create_buffer(
-			server->allocator, mag_box.width, mag_box.height,
+			g_server.allocator, mag_box.width, mag_box.height,
 			&output->wlr_output->swapchain->format);
 	}
 	if (!tmp_buffer) {
@@ -105,7 +104,7 @@ magnifier_draw(struct output *output, struct wlr_buffer *output_buffer, struct w
 	}
 
 	if (!tmp_texture) {
-		tmp_texture = wlr_texture_from_buffer(server->renderer, tmp_buffer);
+		tmp_texture = wlr_texture_from_buffer(g_server.renderer, tmp_buffer);
 	}
 	if (!tmp_texture) {
 		wlr_log(WLR_ERROR, "Failed to allocate temporary magnifier texture");
@@ -116,7 +115,7 @@ magnifier_draw(struct output *output, struct wlr_buffer *output_buffer, struct w
 
 	/* Extract source region into temporary buffer */
 	struct wlr_render_pass *tmp_render_pass = wlr_renderer_begin_buffer_pass(
-		server->renderer, tmp_buffer, NULL);
+		g_server.renderer, tmp_buffer, NULL);
 	if (!tmp_render_pass) {
 		wlr_log(WLR_ERROR, "Failed to begin magnifier render pass");
 		return;
@@ -124,7 +123,7 @@ magnifier_draw(struct output *output, struct wlr_buffer *output_buffer, struct w
 
 	wlr_buffer_lock(output_buffer);
 	struct wlr_texture *output_texture = wlr_texture_from_buffer(
-		server->renderer, output_buffer);
+		g_server.renderer, output_buffer);
 	if (!output_texture) {
 		goto cleanup;
 	}
@@ -151,7 +150,7 @@ magnifier_draw(struct output *output, struct wlr_buffer *output_buffer, struct w
 
 	/* Render to the output buffer itself */
 	tmp_render_pass = wlr_renderer_begin_buffer_pass(
-		server->renderer, output_buffer, NULL);
+		g_server.renderer, output_buffer, NULL);
 	if (!tmp_render_pass) {
 		wlr_log(WLR_ERROR, "Failed to begin second magnifier render pass");
 		goto cleanup;
@@ -224,7 +223,7 @@ output_wants_magnification(struct output *output)
 {
 	static double x = -1;
 	static double y = -1;
-	struct wlr_cursor *cursor = output->server->seat.cursor;
+	struct wlr_cursor *cursor = g_server.seat.cursor;
 	if (!magnify_on) {
 		x = -1;
 		y = -1;
@@ -235,24 +234,24 @@ output_wants_magnification(struct output *output)
 	}
 	x = cursor->x;
 	y = cursor->y;
-	return output_nearest_to_cursor(output->server) == output;
+	return output_nearest_to_cursor() == output;
 }
 
 static void
-enable_magnifier(struct server *server, bool enable)
+enable_magnifier(bool enable)
 {
 	magnify_on = enable;
-	server->scene->WLR_PRIVATE.direct_scanout = enable ? false
-		: server->direct_scanout_enabled;
+	g_server.scene->WLR_PRIVATE.direct_scanout = enable ? false
+		: g_server.direct_scanout_enabled;
 }
 
 /* Toggles magnification on and off */
 void
-magnifier_toggle(struct server *server)
+magnifier_toggle(void)
 {
-	enable_magnifier(server, !magnify_on);
+	enable_magnifier(!magnify_on);
 
-	struct output *output = output_nearest_to_cursor(server);
+	struct output *output = output_nearest_to_cursor();
 	if (output) {
 		wlr_output_schedule_frame(output->wlr_output);
 	}
@@ -260,22 +259,22 @@ magnifier_toggle(struct server *server)
 
 /* Increases and decreases magnification scale */
 void
-magnifier_set_scale(struct server *server, enum magnify_dir dir)
+magnifier_set_scale(enum magnify_dir dir)
 {
-	struct output *output = output_nearest_to_cursor(server);
+	struct output *output = output_nearest_to_cursor();
 
 	if (dir == MAGNIFY_INCREASE) {
 		if (magnify_on) {
 			mag_scale += rc.mag_increment;
 		} else {
-			enable_magnifier(server, true);
+			enable_magnifier(true);
 			mag_scale = 1.0 + rc.mag_increment;
 		}
 	} else {
 		if (magnify_on && mag_scale > 1.0 + rc.mag_increment) {
 			mag_scale -= rc.mag_increment;
 		} else {
-			enable_magnifier(server, false);
+			enable_magnifier(false);
 		}
 	}
 

src/main.c

@@ -130,7 +130,6 @@ send_signal_to_labwc_pid(int signal)
 }
 
 struct idle_ctx {
-	struct server *server;
 	const char *primary_client;
 	const char *startup_cmd;
 };
@@ -143,16 +142,16 @@ idle_callback(void *data)
 
 	/* Start session-manager if one is specified by -S|--session */
 	if (ctx->primary_client) {
-		ctx->server->primary_client_pid = spawn_primary_client(ctx->primary_client);
-		if (ctx->server->primary_client_pid < 0) {
+		g_server.primary_client_pid = spawn_primary_client(ctx->primary_client);
+		if (g_server.primary_client_pid < 0) {
 			wlr_log(WLR_ERROR, "fatal error starting primary client: %s",
 				ctx->primary_client);
-			wl_display_terminate(ctx->server->wl_display);
+			wl_display_terminate(g_server.wl_display);
 			return;
 		}
 	}
 
-	session_autostart_init(ctx->server);
+	session_autostart_init();
 	if (ctx->startup_cmd) {
 		spawn_async_no_shell(ctx->startup_cmd);
 	}
@@ -255,35 +254,33 @@ main(int argc, char *argv[])
 
 	increase_nofile_limit();
 
-	struct server *server = &g_server;
-	server_init(server);
-	server_start(server);
+	server_init();
+	server_start();
 
 	struct theme theme = { 0 };
-	theme_init(&theme, server, rc.theme_name);
+	theme_init(&theme, rc.theme_name);
 	rc.theme = &theme;
-	server->theme = &theme;
+	g_server.theme = &theme;
 
-	menu_init(server);
+	menu_init();
 
 	/* Delay startup of applications until the event loop is ready */
 	struct idle_ctx idle_ctx = {
-		.server = server,
 		.primary_client = primary_client,
 		.startup_cmd = startup_cmd
 	};
-	wl_event_loop_add_idle(server->wl_event_loop, idle_callback, &idle_ctx);
+	wl_event_loop_add_idle(g_server.wl_event_loop, idle_callback, &idle_ctx);
 
-	wl_display_run(server->wl_display);
+	wl_display_run(g_server.wl_display);
 
-	session_shutdown(server);
+	session_shutdown();
 
-	menu_finish(server);
+	menu_finish();
 	theme_finish(&theme);
 	rcxml_finish();
 	font_finish();
 
-	server_finish(server);
+	server_finish();
 
 	return 0;
 }

src/menu/menu.c

@@ -54,10 +54,10 @@ struct menu_pipe_context {
 /* TODO: split this whole file into parser.c and actions.c*/
 
 static bool
-is_unique_id(struct server *server, const char *id)
+is_unique_id(const char *id)
 {
 	struct menu *menu;
-	wl_list_for_each(menu, &server->menus, link) {
+	wl_list_for_each(menu, &g_server.menus, link) {
 		if (!strcmp(menu->id, id)) {
 			return false;
 		}
@@ -66,33 +66,32 @@ is_unique_id(struct server *server, const char *id)
 }
 
 static struct menu *
-menu_create(struct server *server, struct menu *parent, const char *id,
+menu_create(struct menu *parent, const char *id,
 		const char *label)
 {
-	if (!is_unique_id(server, id)) {
+	if (!is_unique_id(id)) {
 		wlr_log(WLR_ERROR, "menu id %s already exists", id);
 	}
 
 	struct menu *menu = znew(*menu);
-	wl_list_append(&server->menus, &menu->link);
+	wl_list_append(&g_server.menus, &menu->link);
 
 	wl_list_init(&menu->menuitems);
 	menu->id = xstrdup(id);
 	menu->label = xstrdup(label ? label : id);
 	menu->parent = parent;
-	menu->server = server;
 	menu->is_pipemenu_child = waiting_for_pipe_menu;
 	return menu;
 }
 
 struct menu *
-menu_get_by_id(struct server *server, const char *id)
+menu_get_by_id(const char *id)
 {
 	if (!id) {
 		return NULL;
 	}
 	struct menu *menu;
-	wl_list_for_each(menu, &server->menus, link) {
+	wl_list_for_each(menu, &g_server.menus, link) {
 		if (!strcmp(menu->id, id)) {
 			return menu;
 		}
@@ -122,10 +121,10 @@ validate_menu(struct menu *menu)
 }
 
 static void
-validate(struct server *server)
+validate(void)
 {
 	struct menu *menu;
-	wl_list_for_each(menu, &server->menus, link) {
+	wl_list_for_each(menu, &g_server.menus, link) {
 		validate_menu(menu);
 	}
 }
@@ -136,7 +135,7 @@ item_create(struct menu *menu, const char *text, const char *icon_name, bool sho
 	assert(menu);
 	assert(text);
 
-	struct theme *theme = menu->server->theme;
+	struct theme *theme = g_server.theme;
 	struct menuitem *menuitem = znew(*menuitem);
 	menuitem->parent = menu;
 	menuitem->selectable = true;
@@ -167,7 +166,7 @@ item_create_scene_for_state(struct menuitem *item, float *text_color,
 	float *bg_color)
 {
 	struct menu *menu = item->parent;
-	struct theme *theme = menu->server->theme;
+	struct theme *theme = g_server.theme;
 
 	/* Tree to hold background and label buffers */
 	struct wlr_scene_tree *tree = lab_wlr_scene_tree_create(item->tree);
@@ -197,7 +196,7 @@ item_create_scene_for_state(struct menuitem *item, float *text_color,
 				&& item->client_list_view;
 	if (item->icon_name || show_app_icon) {
 		struct scaled_icon_buffer *icon_buffer = scaled_icon_buffer_create(
-			tree, menu->server, icon_size, icon_size);
+			tree, icon_size, icon_size);
 		if (item->icon_name) {
 			/* icon set via <menu icon="..."> */
 			scaled_icon_buffer_set_icon_name(icon_buffer, item->icon_name);
@@ -243,7 +242,7 @@ item_create_scene(struct menuitem *menuitem, int *item_y)
 	assert(menuitem);
 	assert(menuitem->type == LAB_MENU_ITEM);
 	struct menu *menu = menuitem->parent;
-	struct theme *theme = menu->server->theme;
+	struct theme *theme = g_server.theme;
 
 	/* Menu item root node */
 	menuitem->tree = lab_wlr_scene_tree_create(menu->scene_tree);
@@ -292,7 +291,7 @@ separator_create_scene(struct menuitem *menuitem, int *item_y)
 	assert(menuitem);
 	assert(menuitem->type == LAB_MENU_SEPARATOR_LINE);
 	struct menu *menu = menuitem->parent;
-	struct theme *theme = menu->server->theme;
+	struct theme *theme = g_server.theme;
 
 	/* Menu item root node */
 	menuitem->tree = lab_wlr_scene_tree_create(menu->scene_tree);
@@ -338,7 +337,7 @@ title_create_scene(struct menuitem *menuitem, int *item_y)
 	assert(menuitem);
 	assert(menuitem->type == LAB_MENU_TITLE);
 	struct menu *menu = menuitem->parent;
-	struct theme *theme = menu->server->theme;
+	struct theme *theme = g_server.theme;
 	float *bg_color = theme->menu_title_bg_color;
 	float *text_color = theme->menu_title_text_color;
 
@@ -412,11 +411,11 @@ static void
 menu_create_scene(struct menu *menu)
 {
 	struct menuitem *item;
-	struct theme *theme = menu->server->theme;
+	struct theme *theme = g_server.theme;
 
 	assert(!menu->scene_tree);
 
-	menu->scene_tree = lab_wlr_scene_tree_create(menu->server->menu_tree);
+	menu->scene_tree = lab_wlr_scene_tree_create(g_server.menu_tree);
 	wlr_scene_node_set_enabled(&menu->scene_tree->node, false);
 
 	/* Menu width is the maximum item width, capped by menu.width.{min,max} */
@@ -504,10 +503,10 @@ item_destroy(struct menuitem *item)
 	free(item);
 }
 
-static bool parse_buf(struct server *server, struct menu *menu, struct buf *buf);
+static bool parse_buf(struct menu *menu, struct buf *buf);
 static int handle_pipemenu_readable(int fd, uint32_t mask, void *_ctx);
 static int handle_pipemenu_timeout(void *_ctx);
-static void fill_menu_children(struct server *server, struct menu *parent, xmlNode *n);
+static void fill_menu_children(struct menu *parent, xmlNode *n);
 
 /*
  * <menu> elements have three different roles:
@@ -516,7 +515,7 @@ static void fill_menu_children(struct server *server, struct menu *parent, xmlNo
  *  * Menuitem of submenu type - has ID only
  */
 static void
-fill_menu(struct server *server, struct menu *parent, xmlNode *n)
+fill_menu(struct menu *parent, xmlNode *n)
 {
 	char *label = (char *)xmlGetProp(n, (const xmlChar *)"label");
 	char *icon_name = (char *)xmlGetProp(n, (const xmlChar *)"icon");
@@ -531,7 +530,7 @@ fill_menu(struct server *server, struct menu *parent, xmlNode *n)
 	if (execute && label) {
 		wlr_log(WLR_DEBUG, "pipemenu '%s:%s:%s'", id, label, execute);
 
-		struct menu *pipemenu = menu_create(server, parent, id, label);
+		struct menu *pipemenu = menu_create(parent, id, label);
 		pipemenu->execute = xstrdup(execute);
 		if (!parent) {
 			/*
@@ -568,7 +567,7 @@ fill_menu(struct server *server, struct menu *parent, xmlNode *n)
 		 * attribute to make it easier for users to define "root-menu"
 		 * and "client-menu".
 		 */
-		struct menu *menu = menu_create(server, parent, id, label);
+		struct menu *menu = menu_create(parent, id, label);
 		if (icon_name) {
 			menu->icon_name = xstrdup(icon_name);
 		}
@@ -581,7 +580,7 @@ fill_menu(struct server *server, struct menu *parent, xmlNode *n)
 				icon_name, true);
 			item->submenu = menu;
 		}
-		fill_menu_children(server, menu, n);
+		fill_menu_children(menu, n);
 	} else {
 		/*
 		 * <menu id=""> (when inside another <menu> element) creates an
@@ -598,7 +597,7 @@ fill_menu(struct server *server, struct menu *parent, xmlNode *n)
 			goto error;
 		}
 
-		struct menu *menu = menu_get_by_id(server, id);
+		struct menu *menu = menu_get_by_id(id);
 		if (!menu) {
 			wlr_log(WLR_ERROR, "no menu with id '%s'", id);
 			goto error;
@@ -636,13 +635,13 @@ fill_separator(struct menu *menu, xmlNode *n)
 
 /* parent==NULL when processing toplevel menus in menu.xml */
 static void
-fill_menu_children(struct server *server, struct menu *parent, xmlNode *n)
+fill_menu_children(struct menu *parent, xmlNode *n)
 {
 	xmlNode *child;
 	char *key, *content;
 	LAB_XML_FOR_EACH(n, child, key, content) {
 		if (!strcasecmp(key, "menu")) {
-			fill_menu(server, parent, child);
+			fill_menu(parent, child);
 		} else if (!strcasecmp(key, "separator")) {
 			if (!parent) {
 				wlr_log(WLR_ERROR,
@@ -662,7 +661,7 @@ fill_menu_children(struct server *server, struct menu *parent, xmlNode *n)
 }
 
 static bool
-parse_buf(struct server *server, struct menu *parent, struct buf *buf)
+parse_buf(struct menu *parent, struct buf *buf)
 {
 	int options = 0;
 	xmlDoc *d = xmlReadMemory(buf->data, buf->len, NULL, NULL, options);
@@ -672,7 +671,7 @@ parse_buf(struct server *server, struct menu *parent, struct buf *buf)
 	}
 
 	xmlNode *root = xmlDocGetRootElement(d);
-	fill_menu_children(server, parent, root);
+	fill_menu_children(parent, root);
 
 	xmlFreeDoc(d);
 	xmlCleanupParser();
@@ -680,7 +679,7 @@ parse_buf(struct server *server, struct menu *parent, struct buf *buf)
 }
 
 static void
-parse_xml(const char *filename, struct server *server)
+parse_xml(const char *filename)
 {
 	struct wl_list paths;
 	paths_config_create(&paths, filename);
@@ -696,7 +695,7 @@ parse_xml(const char *filename, struct server *server)
 			continue;
 		}
 		wlr_log(WLR_INFO, "read menu file %s", path->string);
-		parse_buf(server, /*parent*/ NULL, &buf);
+		parse_buf(/*parent*/ NULL, &buf);
 		buf_reset(&buf);
 		if (!should_merge_config) {
 			break;
@@ -729,8 +728,7 @@ static void
 menu_reposition(struct menu *menu, struct wlr_box anchor_rect)
 {
 	/* Get output usable area to place the menu within */
-	struct output *output = output_nearest_to(menu->server,
-		anchor_rect.x, anchor_rect.y);
+	struct output *output = output_nearest_to(anchor_rect.x, anchor_rect.y);
 	if (!output_is_usable(output)) {
 		wlr_log(WLR_ERROR, "no output found around (%d,%d)",
 			anchor_rect.x, anchor_rect.y);
@@ -775,14 +773,14 @@ menu_reposition(struct menu *menu, struct wlr_box anchor_rect)
 }
 
 static void
-menu_hide_submenu(struct server *server, const char *id)
+menu_hide_submenu(const char *id)
 {
 	struct menu *menu, *hide_menu;
-	hide_menu = menu_get_by_id(server, id);
+	hide_menu = menu_get_by_id(id);
 	if (!hide_menu) {
 		return;
 	}
-	wl_list_for_each(menu, &server->menus, link) {
+	wl_list_for_each(menu, &g_server.menus, link) {
 		struct menuitem *item, *next;
 		wl_list_for_each_safe(item, next, &menu->menuitems, link) {
 			if (item->submenu == hide_menu) {
@@ -809,9 +807,9 @@ item_add_action(struct menuitem *item, const char *action_name)
  * SendToDesktop, left/right options are included.
  */
 static void
-update_client_send_to_menu(struct server *server)
+update_client_send_to_menu(void)
 {
-	struct menu *menu = menu_get_by_id(server, "client-send-to-menu");
+	struct menu *menu = menu_get_by_id("client-send-to-menu");
 	assert(menu);
 
 	reset_menu(menu);
@@ -823,8 +821,8 @@ update_client_send_to_menu(struct server *server)
 	 * GoToDesktop will be called as part of the action.
 	 */
 	struct buf buf = BUF_INIT;
-	wl_list_for_each(workspace, &server->workspaces.all, link) {
-		if (workspace == server->workspaces.current) {
+	wl_list_for_each(workspace, &g_server.workspaces.all, link) {
+		if (workspace == g_server.workspaces.current) {
 			buf_add_fmt(&buf, ">%s<", workspace->name);
 		} else {
 			buf_add(&buf, workspace->name);
@@ -856,9 +854,9 @@ update_client_send_to_menu(struct server *server)
  * name. Active view is indicated by "*" preceding title.
  */
 static void
-update_client_list_combined_menu(struct server *server)
+update_client_list_combined_menu(void)
 {
-	struct menu *menu = menu_get_by_id(server, "client-list-combined-menu");
+	struct menu *menu = menu_get_by_id("client-list-combined-menu");
 	assert(menu);
 
 	reset_menu(menu);
@@ -868,20 +866,20 @@ update_client_list_combined_menu(struct server *server)
 	struct view *view;
 	struct buf buffer = BUF_INIT;
 
-	wl_list_for_each(workspace, &server->workspaces.all, link) {
-		buf_add_fmt(&buffer, workspace == server->workspaces.current ? ">%s<" : "%s",
+	wl_list_for_each(workspace, &g_server.workspaces.all, link) {
+		buf_add_fmt(&buffer, workspace == g_server.workspaces.current ? ">%s<" : "%s",
 				workspace->name);
 		separator_create(menu, buffer.data);
 		buf_clear(&buffer);
 
-		wl_list_for_each(view, &server->views, link) {
+		wl_list_for_each(view, &g_server.views, link) {
 			if (view->workspace == workspace) {
 				if (!view->foreign_toplevel
 						|| string_null_or_empty(view->title)) {
 					continue;
 				}
 
-				if (view == server->active_view) {
+				if (view == g_server.active_view) {
 					buf_add(&buffer, "*");
 				}
 				if (view->minimized) {
@@ -908,14 +906,14 @@ update_client_list_combined_menu(struct server *server)
 }
 
 static void
-init_rootmenu(struct server *server)
+init_rootmenu(void)
 {
-	struct menu *menu = menu_get_by_id(server, "root-menu");
+	struct menu *menu = menu_get_by_id("root-menu");
 	struct menuitem *item;
 
 	/* Default menu if no menu.xml found */
 	if (!menu) {
-		menu = menu_create(server, NULL, "root-menu", "");
+		menu = menu_create(NULL, "root-menu", "");
 
 		item = item_create(menu, _("Terminal"), NULL, false);
 		struct action *action = item_add_action(item, "Execute");
@@ -931,14 +929,14 @@ init_rootmenu(struct server *server)
 }
 
 static void
-init_windowmenu(struct server *server)
+init_windowmenu(void)
 {
-	struct menu *menu = menu_get_by_id(server, "client-menu");
+	struct menu *menu = menu_get_by_id("client-menu");
 	struct menuitem *item;
 
 	/* Default menu if no menu.xml found */
 	if (!menu) {
-		menu = menu_create(server, NULL, "client-menu", "");
+		menu = menu_create(NULL, "client-menu", "");
 		item = item_create(menu, _("Minimize"), NULL, false);
 		item_add_action(item, "Iconify");
 		item = item_create(menu, _("Maximize"), NULL, false);
@@ -954,37 +952,37 @@ init_windowmenu(struct server *server)
 
 		/* Workspace sub-menu */
 		item = item_create(menu, _("Workspace"), NULL, true);
-		item->submenu = menu_get_by_id(server, "client-send-to-menu");
+		item->submenu = menu_get_by_id("client-send-to-menu");
 
 		item = item_create(menu, _("Close"), NULL, false);
 		item_add_action(item, "Close");
 	}
 
 	if (wl_list_length(&rc.workspace_config.workspaces) == 1) {
-		menu_hide_submenu(server, "workspaces");
+		menu_hide_submenu("workspaces");
 	}
 }
 
 void
-menu_init(struct server *server)
+menu_init(void)
 {
-	wl_list_init(&server->menus);
+	wl_list_init(&g_server.menus);
 
 	/* Just create placeholder. Contents will be created when launched */
-	menu_create(server, NULL, "client-list-combined-menu", _("Windows"));
-	menu_create(server, NULL, "client-send-to-menu", _("Workspace"));
+	menu_create(NULL, "client-list-combined-menu", _("Windows"));
+	menu_create(NULL, "client-send-to-menu", _("Workspace"));
 
-	parse_xml("menu.xml", server);
-	init_rootmenu(server);
-	init_windowmenu(server);
-	validate(server);
+	parse_xml("menu.xml");
+	init_rootmenu();
+	init_windowmenu();
+	validate();
 }
 
 static void
 nullify_item_pointing_to_this_menu(struct menu *menu)
 {
 	struct menu *iter;
-	wl_list_for_each(iter, &menu->server->menus, link) {
+	wl_list_for_each(iter, &g_server.menus, link) {
 		struct menuitem *item;
 		wl_list_for_each(item, &iter->menuitems, link) {
 			if (item->submenu == menu) {
@@ -1015,8 +1013,8 @@ menu_free(struct menu *menu)
 	/* Keep items clean on pipemenu destruction */
 	nullify_item_pointing_to_this_menu(menu);
 
-	if (menu->server->menu_current == menu) {
-		menu_close_root(menu->server);
+	if (g_server.menu_current == menu) {
+		menu_close_root();
 	}
 
 	struct menuitem *item, *next;
@@ -1045,10 +1043,10 @@ menu_free(struct menu *menu)
 }
 
 void
-menu_finish(struct server *server)
+menu_finish(void)
 {
 	struct menu *menu, *tmp_menu;
-	wl_list_for_each_safe(menu, tmp_menu, &server->menus, link) {
+	wl_list_for_each_safe(menu, tmp_menu, &g_server.menus, link) {
 		menu_free(menu);
 	}
 }
@@ -1056,12 +1054,10 @@ menu_finish(struct server *server)
 void
 menu_on_view_destroy(struct view *view)
 {
-	struct server *server = view->server;
-
 	/* If the view being destroy has an open window menu, then close it */
-	if (server->menu_current
-			&& server->menu_current->triggered_by_view == view) {
-		menu_close_root(server);
+	if (g_server.menu_current
+			&& g_server.menu_current->triggered_by_view == view) {
+		menu_close_root();
 	}
 
 	/*
@@ -1071,7 +1067,7 @@ menu_on_view_destroy(struct view *view)
 	 */
 
 	/* Also nullify the destroyed view in client-list-combined-menu */
-	struct menu *menu = menu_get_by_id(server, "client-list-combined-menu");
+	struct menu *menu = menu_get_by_id("client-list-combined-menu");
 	if (menu) {
 		struct menuitem *item;
 		wl_list_for_each(item, &menu->menuitems, link) {
@@ -1109,13 +1105,13 @@ menu_set_selection(struct menu *menu, struct menuitem *item)
  * item may be selected multiple times.
  */
 static void
-reset_pipemenus(struct server *server)
+reset_pipemenus(void)
 {
 	wlr_log(WLR_DEBUG, "number of menus before close=%d",
-		wl_list_length(&server->menus));
+		wl_list_length(&g_server.menus));
 
 	struct menu *iter, *tmp;
-	wl_list_for_each_safe(iter, tmp, &server->menus, link) {
+	wl_list_for_each_safe(iter, tmp, &g_server.menus, link) {
 		if (iter->is_pipemenu_child) {
 			/* Destroy submenus of pipemenus */
 			menu_free(iter);
@@ -1129,7 +1125,7 @@ reset_pipemenus(struct server *server)
 	}
 
 	wlr_log(WLR_DEBUG, "number of menus after  close=%d",
-		wl_list_length(&server->menus));
+		wl_list_length(&g_server.menus));
 }
 
 static void
@@ -1163,9 +1159,9 @@ static void
 open_menu(struct menu *menu, struct wlr_box anchor_rect)
 {
 	if (!strcmp(menu->id, "client-list-combined-menu")) {
-		update_client_list_combined_menu(menu->server);
+		update_client_list_combined_menu();
 	} else if (!strcmp(menu->id, "client-send-to-menu")) {
-		update_client_send_to_menu(menu->server);
+		update_client_send_to_menu();
 	}
 
 	if (!menu->scene_tree) {
@@ -1183,11 +1179,11 @@ menu_open_root(struct menu *menu, int x, int y)
 {
 	assert(menu);
 
-	if (menu->server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		return;
 	}
 
-	assert(!menu->server->menu_current);
+	assert(!g_server.menu_current);
 
 	struct wlr_box anchor_rect = {.x = x, .y = y};
 	if (menu->execute) {
@@ -1196,21 +1192,20 @@ menu_open_root(struct menu *menu, int x, int y)
 		open_menu(menu, anchor_rect);
 	}
 
-	menu->server->menu_current = menu;
+	g_server.menu_current = menu;
 	selected_item = NULL;
-	seat_focus_override_begin(&menu->server->seat,
+	seat_focus_override_begin(&g_server.seat,
 		LAB_INPUT_STATE_MENU, LAB_CURSOR_DEFAULT);
 }
 
 static void
 create_pipe_menu(struct menu_pipe_context *ctx)
 {
-	struct server *server = ctx->pipemenu->server;
-	if (!parse_buf(server, ctx->pipemenu, &ctx->buf)) {
+	if (!parse_buf(ctx->pipemenu, &ctx->buf)) {
 		return;
 	}
 	/* TODO: apply validate() only for generated pipemenus */
-	validate(server);
+	validate();
 
 	/* Finally open the new submenu tree */
 	open_menu(ctx->pipemenu, ctx->anchor_rect);
@@ -1292,8 +1287,6 @@ clean_up:
 static void
 open_pipemenu_async(struct menu *pipemenu, struct wlr_box anchor_rect)
 {
-	struct server *server = pipemenu->server;
-
 	assert(!pipemenu->pipe_ctx);
 	assert(!pipemenu->scene_tree);
 
@@ -1314,10 +1307,10 @@ open_pipemenu_async(struct menu *pipemenu, struct wlr_box anchor_rect)
 	ctx->pipemenu = pipemenu;
 	pipemenu->pipe_ctx = ctx;
 
-	ctx->event_read = wl_event_loop_add_fd(server->wl_event_loop,
+	ctx->event_read = wl_event_loop_add_fd(g_server.wl_event_loop,
 		pipe_fd, WL_EVENT_READABLE, handle_pipemenu_readable, ctx);
 
-	ctx->event_timeout = wl_event_loop_add_timer(server->wl_event_loop,
+	ctx->event_timeout = wl_event_loop_add_timer(g_server.wl_event_loop,
 		handle_pipemenu_timeout, ctx);
 	wl_event_source_timer_update(ctx->event_timeout, PIPEMENU_TIMEOUT_IN_MS);
 
@@ -1358,7 +1351,7 @@ menu_process_item_selection(struct menuitem *item)
 		item->submenu->parent = item->parent;
 		/* And open the new submenu tree */
 		struct wlr_box anchor_rect =
-			get_item_anchor_rect(item->submenu->server->theme, item);
+			get_item_anchor_rect(g_server.theme, item);
 		if (item->submenu->execute && !item->submenu->scene_tree) {
 			open_pipemenu_async(item->submenu, anchor_rect);
 		} else {
@@ -1371,9 +1364,9 @@ menu_process_item_selection(struct menuitem *item)
 
 /* Get the deepest submenu with active item selection or the root menu itself */
 static struct menu *
-get_selection_leaf(struct server *server)
+get_selection_leaf(void)
 {
-	struct menu *menu = server->menu_current;
+	struct menu *menu = g_server.menu_current;
 	if (!menu) {
 		return NULL;
 	}
@@ -1390,9 +1383,9 @@ get_selection_leaf(struct server *server)
 
 /* Selects the next or previous sibling of the currently selected item */
 static void
-menu_item_select(struct server *server, bool forward)
+menu_item_select(bool forward)
 {
-	struct menu *menu = get_selection_leaf(server);
+	struct menu *menu = get_selection_leaf();
 	if (!menu) {
 		return;
 	}
@@ -1427,10 +1420,9 @@ menu_execute_item(struct menuitem *item)
 		return false;
 	}
 
-	struct server *server = item->parent->server;
-	menu_close(server->menu_current);
-	server->menu_current = NULL;
-	seat_focus_override_end(&server->seat, /*restore_focus*/ true);
+	menu_close(g_server.menu_current);
+	g_server.menu_current = NULL;
+	seat_focus_override_end(&g_server.seat, /*restore_focus*/ true);
 
 	/*
 	 * We call the actions after closing the menu so that virtual keyboard
@@ -1446,33 +1438,32 @@ menu_execute_item(struct menuitem *item)
 		if (item->client_list_view->shaded) {
 			view_set_shade(item->client_list_view, false);
 		}
-		actions_run(item->client_list_view, server, &item->actions, NULL);
+		actions_run(item->client_list_view, &item->actions, NULL);
 	} else {
-		actions_run(item->parent->triggered_by_view, server,
-				&item->actions, NULL);
+		actions_run(item->parent->triggered_by_view, &item->actions, NULL);
 	}
 
-	reset_pipemenus(server);
+	reset_pipemenus();
 	return true;
 }
 
 /* Keyboard based selection */
 void
-menu_item_select_next(struct server *server)
+menu_item_select_next(void)
 {
-	menu_item_select(server, /* forward */ true);
+	menu_item_select(/* forward */ true);
 }
 
 void
-menu_item_select_previous(struct server *server)
+menu_item_select_previous(void)
 {
-	menu_item_select(server, /* forward */ false);
+	menu_item_select(/* forward */ false);
 }
 
 bool
-menu_call_selected_actions(struct server *server)
+menu_call_selected_actions(void)
 {
-	struct menu *menu = get_selection_leaf(server);
+	struct menu *menu = get_selection_leaf();
 	if (!menu || !menu->selection.item) {
 		return false;
 	}
@@ -1482,9 +1473,9 @@ menu_call_selected_actions(struct server *server)
 
 /* Selects the first item on the submenu attached to the current selection */
 void
-menu_submenu_enter(struct server *server)
+menu_submenu_enter(void)
 {
-	struct menu *menu = get_selection_leaf(server);
+	struct menu *menu = get_selection_leaf();
 	if (!menu || !menu->selection.menu) {
 		return;
 	}
@@ -1505,9 +1496,9 @@ menu_submenu_enter(struct server *server)
 
 /* Re-selects the selected item on the parent menu of the current selection */
 void
-menu_submenu_leave(struct server *server)
+menu_submenu_leave(void)
 {
-	struct menu *menu = get_selection_leaf(server);
+	struct menu *menu = get_selection_leaf();
 	if (!menu || !menu->parent || !menu->parent->selection.item) {
 		return;
 	}
@@ -1525,21 +1516,21 @@ menu_process_cursor_motion(struct wlr_scene_node *node)
 }
 
 void
-menu_close_root(struct server *server)
+menu_close_root(void)
 {
-	assert(server->input_mode == LAB_INPUT_STATE_MENU);
-	assert(server->menu_current);
+	assert(g_server.input_mode == LAB_INPUT_STATE_MENU);
+	assert(g_server.menu_current);
 
-	menu_close(server->menu_current);
-	server->menu_current = NULL;
-	reset_pipemenus(server);
-	seat_focus_override_end(&server->seat, /*restore_focus*/ true);
+	menu_close(g_server.menu_current);
+	g_server.menu_current = NULL;
+	reset_pipemenus();
+	seat_focus_override_end(&g_server.seat, /*restore_focus*/ true);
 }
 
 void
-menu_reconfigure(struct server *server)
+menu_reconfigure(void)
 {
-	menu_finish(server);
-	server->menu_current = NULL;
-	menu_init(server);
+	menu_finish();
+	g_server.menu_current = NULL;
+	menu_init();
 }

src/output-virtual.c

@@ -12,13 +12,13 @@
 static struct wlr_output *fallback_output = NULL;
 
 void
-output_virtual_add(struct server *server, const char *output_name,
+output_virtual_add(const char *output_name,
 		struct wlr_output **store_wlr_output)
 {
 	if (output_name) {
 		/* Prevent creating outputs with the same name */
 		struct output *output;
-		wl_list_for_each(output, &server->outputs, link) {
+		wl_list_for_each(output, &g_server.outputs, link) {
 			if (wlr_output_is_headless(output->wlr_output) &&
 					!strcmp(output->wlr_output->name, output_name)) {
 				wlr_log(WLR_DEBUG,
@@ -46,13 +46,13 @@ output_virtual_add(struct server *server, const char *output_name,
 	 * we may end up calling the new output handler twice, one time manually
 	 * and one time by the headless backend when it starts up and sends the
 	 * signal for all its configured outputs. Rather than keeping a global
-	 * server->headless.started state around that we could check here we just
+	 * g_server.headless.started state around that we could check here we just
 	 * ignore duplicated new output calls in handle_new_output().
 	 */
-	wl_list_remove(&server->new_output.link);
+	wl_list_remove(&g_server.new_output.link);
 
 	struct wlr_output *wlr_output = wlr_headless_add_output(
-		server->headless.backend, 1920, 1080);
+		g_server.headless.backend, 1920, 1080);
 
 	if (!wlr_output) {
 		wlr_log(WLR_ERROR, "Failed to create virtual output %s",
@@ -69,20 +69,20 @@ output_virtual_add(struct server *server, const char *output_name,
 	}
 
 	/* Notify about the new output manually */
-	if (server->new_output.notify) {
-		server->new_output.notify(&server->new_output, wlr_output);
+	if (g_server.new_output.notify) {
+		g_server.new_output.notify(&g_server.new_output, wlr_output);
 	}
 
 restore_handler:
 	/* And finally restore output notifications */
-	wl_signal_add(&server->backend->events.new_output, &server->new_output);
+	wl_signal_add(&g_server.backend->events.new_output, &g_server.new_output);
 }
 
 void
-output_virtual_remove(struct server *server, const char *output_name)
+output_virtual_remove(const char *output_name)
 {
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (!wlr_output_is_headless(output->wlr_output)
 				|| output->wlr_output == fallback_output) {
 			continue;
@@ -109,16 +109,16 @@ output_virtual_remove(struct server *server, const char *output_name)
 }
 
 void
-output_virtual_update_fallback(struct server *server)
+output_virtual_update_fallback(void)
 {
-	struct wl_list *layout_outputs = &server->output_layout->outputs;
+	struct wl_list *layout_outputs = &g_server.output_layout->outputs;
 	const char *fallback_output_name = getenv("LABWC_FALLBACK_OUTPUT");
 
 	if (!fallback_output && wl_list_empty(layout_outputs)
 			&& !string_null_or_empty(fallback_output_name)) {
 		wlr_log(WLR_DEBUG, "adding fallback output %s", fallback_output_name);
 
-		output_virtual_add(server, fallback_output_name, &fallback_output);
+		output_virtual_add(fallback_output_name, &fallback_output);
 	} else if (fallback_output && (wl_list_length(layout_outputs) > 1
 			|| string_null_or_empty(fallback_output_name))) {
 		wlr_log(WLR_DEBUG, "destroying fallback output %s",

src/output.c

@@ -46,14 +46,12 @@
 bool
 output_get_tearing_allowance(struct output *output)
 {
-	struct server *server = output->server;
-
 	/* never allow tearing when disabled */
 	if (!rc.allow_tearing) {
 		return false;
 	}
 
-	struct view *view = server->active_view;
+	struct view *view = g_server.active_view;
 
 	/* tearing is only allowed for the output with the active view */
 	if (!view || view->output != output) {
@@ -90,7 +88,6 @@ output_apply_gamma(struct output *output)
 	assert(output);
 	assert(output->gamma_lut_changed);
 
-	struct server *server = output->server;
 	struct wlr_scene_output *scene_output = output->scene_output;
 
 	struct wlr_output_state pending;
@@ -99,7 +96,7 @@ output_apply_gamma(struct output *output)
 	output->gamma_lut_changed = false;
 	struct wlr_gamma_control_v1 *gamma_control =
 		wlr_gamma_control_manager_v1_get_control(
-			server->gamma_control_manager_v1,
+			g_server.gamma_control_manager_v1,
 			output->wlr_output);
 
 	if (!wlr_gamma_control_v1_apply(gamma_control, &pending)) {
@@ -129,7 +126,7 @@ handle_output_frame(struct wl_listener *listener, void *data)
 	/*
 	 * skip painting the session when it exists but is not active.
 	 */
-	if (output->server->session && !output->server->session->active) {
+	if (g_server.session && !g_server.session->active) {
 		return;
 	}
 
@@ -160,8 +157,7 @@ static void
 handle_output_destroy(struct wl_listener *listener, void *data)
 {
 	struct output *output = wl_container_of(listener, output, destroy);
-	struct server *server = output->server;
-	struct seat *seat = &server->seat;
+	struct seat *seat = &g_server.seat;
 	regions_evacuate_output(output);
 	regions_destroy(seat, &output->regions);
 	if (seat->overlay.active.output == output) {
@@ -185,7 +181,7 @@ handle_output_destroy(struct wl_listener *listener, void *data)
 	}
 
 	struct view *view;
-	wl_list_for_each(view, &server->views, link) {
+	wl_list_for_each(view, &g_server.views, link) {
 		if (view->output == output) {
 			view_on_output_destroy(view);
 		}
@@ -205,13 +201,13 @@ handle_output_destroy(struct wl_listener *listener, void *data)
 	 * windows and cannot be reconnected. Exit the compositor
 	 * when the last one is destroyed.
 	 */
-	if (wl_list_empty(&server->outputs) && (
+	if (wl_list_empty(&g_server.outputs) && (
 			wlr_output_is_wl(output->wlr_output)
 #if WLR_HAS_X11_BACKEND
 			|| wlr_output_is_x11(output->wlr_output)
 #endif
 	)) {
-		wl_display_terminate(server->wl_display);
+		wl_display_terminate(g_server.wl_display);
 	}
 
 	/*
@@ -260,14 +256,14 @@ handle_output_request_state(struct wl_listener *listener, void *data)
 	}
 }
 
-static void do_output_layout_change(struct server *server);
+static void do_output_layout_change(void);
 
 static void
-add_output_to_layout(struct server *server, struct output *output)
+add_output_to_layout(struct output *output)
 {
 	struct wlr_output *wlr_output = output->wlr_output;
 	struct wlr_output_layout_output *layout_output =
-		wlr_output_layout_add_auto(server->output_layout, wlr_output);
+		wlr_output_layout_add_auto(g_server.output_layout, wlr_output);
 	if (!layout_output) {
 		wlr_log(WLR_ERROR, "unable to add output to layout");
 		return;
@@ -275,7 +271,7 @@ add_output_to_layout(struct server *server, struct output *output)
 
 	if (!output->scene_output) {
 		output->scene_output =
-			wlr_scene_output_create(server->scene, wlr_output);
+			wlr_scene_output_create(g_server.scene, wlr_output);
 		if (!output->scene_output) {
 			wlr_log(WLR_ERROR, "unable to create scene output");
 			return;
@@ -285,21 +281,21 @@ add_output_to_layout(struct server *server, struct output *output)
 		 * safe to call twice, so we call it only when initially
 		 * creating the scene_output.
 		 */
-		wlr_scene_output_layout_add_output(server->scene_layout,
+		wlr_scene_output_layout_add_output(g_server.scene_layout,
 			layout_output, output->scene_output);
 	}
 
 	lab_cosmic_workspace_group_output_enter(
-		server->workspaces.cosmic_group, output->wlr_output);
+		g_server.workspaces.cosmic_group, output->wlr_output);
 	lab_ext_workspace_group_output_enter(
-		server->workspaces.ext_group, output->wlr_output);
+		g_server.workspaces.ext_group, output->wlr_output);
 
 	/* (Re-)create regions from config */
 	regions_reconfigure_output(output);
 
 	/* Create lock surface if needed */
-	if (server->session_lock_manager->locked) {
-		session_lock_output_create(server->session_lock_manager, output);
+	if (g_server.session_lock_manager->locked) {
+		session_lock_output_create(g_server.session_lock_manager, output);
 	}
 }
 
@@ -388,7 +384,7 @@ output_test_auto(struct wlr_output *wlr_output, struct wlr_output_state *state,
 }
 
 static void
-configure_new_output(struct server *server, struct output *output)
+configure_new_output(struct output *output)
 {
 	struct wlr_output *wlr_output = output->wlr_output;
 
@@ -417,17 +413,17 @@ configure_new_output(struct server *server, struct output *output)
 	 * calling do_output_layout_change(); this ensures that the
 	 * wlr_output_cursor is created for the new output.
 	 */
-	server->pending_output_layout_change++;
-	add_output_to_layout(server, output);
-	server->pending_output_layout_change--;
+	g_server.pending_output_layout_change++;
+	add_output_to_layout(output);
+	g_server.pending_output_layout_change--;
 }
 
 static uint64_t
-get_unused_output_id_bit(struct server *server)
+get_unused_output_id_bit(void)
 {
 	uint64_t used_id_bits = 0;
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		used_id_bits |= output->id_bit;
 	}
 
@@ -435,7 +431,7 @@ get_unused_output_id_bit(struct server *server)
 		return 0;
 	}
 
-	uint64_t id_bit = server->next_output_id_bit;
+	uint64_t id_bit = g_server.next_output_id_bit;
 	/*
 	 * __builtin_popcountll() should be supported by GCC & clang.
 	 * If it causes portability issues, just remove the assert.
@@ -452,7 +448,7 @@ get_unused_output_id_bit(struct server *server)
 	 * can cycle through all 64 available bits, making re-use less
 	 * frequent (on a best-effort basis).
 	 */
-	server->next_output_id_bit = (id_bit << 1) | (id_bit >> 63);
+	g_server.next_output_id_bit = (id_bit << 1) | (id_bit >> 63);
 
 	return id_bit;
 }
@@ -464,11 +460,10 @@ handle_new_output(struct wl_listener *listener, void *data)
 	 * This event is raised by the backend when a new output (aka display
 	 * or monitor) becomes available.
 	 */
-	struct server *server = wl_container_of(listener, server, new_output);
 	struct wlr_output *wlr_output = data;
 
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (output->wlr_output == wlr_output) {
 			/*
 			 * This is a duplicated notification.
@@ -480,7 +475,7 @@ handle_new_output(struct wl_listener *listener, void *data)
 		}
 	}
 
-	uint64_t id_bit = get_unused_output_id_bit(server);
+	uint64_t id_bit = get_unused_output_id_bit();
 	if (!id_bit) {
 		wlr_log(WLR_ERROR, "Cannot add more than 64 outputs");
 		return;
@@ -508,9 +503,9 @@ handle_new_output(struct wl_listener *listener, void *data)
 	 * TODO: remove once labwc starts tracking 0.20.x and the fix has been merged.
 	 */
 #if LAB_WLR_VERSION_AT_LEAST(0, 19, 1)
-	if (server->drm_lease_manager && wlr_output_is_drm(wlr_output)) {
+	if (g_server.drm_lease_manager && wlr_output_is_drm(wlr_output)) {
 		wlr_drm_lease_v1_manager_offer_output(
-			server->drm_lease_manager, wlr_output);
+			g_server.drm_lease_manager, wlr_output);
 	}
 #endif
 
@@ -526,8 +521,8 @@ handle_new_output(struct wl_listener *listener, void *data)
 	 * Configures the output created by the backend to use our allocator
 	 * and our renderer. Must be done once, before committing the output
 	 */
-	if (!wlr_output_init_render(wlr_output, server->allocator,
-			server->renderer)) {
+	if (!wlr_output_init_render(wlr_output, g_server.allocator,
+			g_server.renderer)) {
 		wlr_log(WLR_ERROR, "unable to init output renderer");
 		return;
 	}
@@ -535,11 +530,10 @@ handle_new_output(struct wl_listener *listener, void *data)
 	output = znew(*output);
 	output->wlr_output = wlr_output;
 	wlr_output->data = output;
-	output->server = server;
 	output->id_bit = id_bit;
 	output_state_init(output);
 
-	wl_list_insert(&server->outputs, &output->link);
+	wl_list_insert(&g_server.outputs, &output->link);
 
 	output->destroy.notify = handle_output_destroy;
 	wl_signal_add(&wlr_output->events.destroy, &output->destroy);
@@ -557,11 +551,11 @@ handle_new_output(struct wl_listener *listener, void *data)
 	 */
 	for (size_t i = 0; i < ARRAY_SIZE(output->layer_tree); i++) {
 		output->layer_tree[i] =
-			lab_wlr_scene_tree_create(&server->scene->tree);
+			lab_wlr_scene_tree_create(&g_server.scene->tree);
 	}
-	output->layer_popup_tree = lab_wlr_scene_tree_create(&server->scene->tree);
-	output->cycle_osd_tree = lab_wlr_scene_tree_create(&server->scene->tree);
-	output->session_lock_tree = lab_wlr_scene_tree_create(&server->scene->tree);
+	output->layer_popup_tree = lab_wlr_scene_tree_create(&g_server.scene->tree);
+	output->cycle_osd_tree = lab_wlr_scene_tree_create(&g_server.scene->tree);
+	output->session_lock_tree = lab_wlr_scene_tree_create(&g_server.scene->tree);
 
 	/*
 	 * Set the z-positions to achieve the following order (from top to
@@ -579,7 +573,7 @@ handle_new_output(struct wl_listener *listener, void *data)
 	wlr_scene_node_lower_to_bottom(&output->layer_tree[1]->node);
 	wlr_scene_node_lower_to_bottom(&output->layer_tree[0]->node);
 
-	struct wlr_scene_node *menu_node = &server->menu_tree->node;
+	struct wlr_scene_node *menu_node = &g_server.menu_tree->node;
 	wlr_scene_node_place_below(&output->layer_tree[2]->node, menu_node);
 	wlr_scene_node_place_below(&output->layer_tree[3]->node, menu_node);
 	wlr_scene_node_place_below(&output->layer_popup_tree->node, menu_node);
@@ -594,84 +588,83 @@ handle_new_output(struct wl_listener *listener, void *data)
 	 * might need tweaking if wlroots adds other output backends.
 	 */
 	if (rc.auto_enable_outputs || !wlr_output_is_drm(wlr_output)) {
-		configure_new_output(server, output);
+		configure_new_output(output);
 	}
 
-	do_output_layout_change(server);
+	do_output_layout_change();
 }
 
-static void output_manager_init(struct server *server);
+static void output_manager_init(void);
 
 void
-output_init(struct server *server)
+output_init(void)
 {
-	server->gamma_control_manager_v1 =
-		wlr_gamma_control_manager_v1_create(server->wl_display);
+	g_server.gamma_control_manager_v1 =
+		wlr_gamma_control_manager_v1_create(g_server.wl_display);
 
-	server->new_output.notify = handle_new_output;
-	wl_signal_add(&server->backend->events.new_output, &server->new_output);
+	g_server.new_output.notify = handle_new_output;
+	wl_signal_add(&g_server.backend->events.new_output, &g_server.new_output);
 
 	/*
 	 * Create an output layout, which is a wlroots utility for working with
 	 * an arrangement of screens in a physical layout.
 	 */
-	server->output_layout = wlr_output_layout_create(server->wl_display);
-	if (!server->output_layout) {
+	g_server.output_layout = wlr_output_layout_create(g_server.wl_display);
+	if (!g_server.output_layout) {
 		wlr_log(WLR_ERROR, "unable to create output layout");
 		exit(EXIT_FAILURE);
 	}
-	server->scene_layout = wlr_scene_attach_output_layout(server->scene,
-		server->output_layout);
-	if (!server->scene_layout) {
+	g_server.scene_layout = wlr_scene_attach_output_layout(g_server.scene,
+		g_server.output_layout);
+	if (!g_server.scene_layout) {
 		wlr_log(WLR_ERROR, "unable to create scene layout");
 		exit(EXIT_FAILURE);
 	}
 
 	/* Enable screen recording with wf-recorder */
-	wlr_xdg_output_manager_v1_create(server->wl_display,
-		server->output_layout);
+	wlr_xdg_output_manager_v1_create(g_server.wl_display,
+		g_server.output_layout);
 
-	wl_list_init(&server->outputs);
-	server->next_output_id_bit = (1 << 0);
+	wl_list_init(&g_server.outputs);
+	g_server.next_output_id_bit = (1 << 0);
 
-	output_manager_init(server);
+	output_manager_init();
 }
 
-static void output_manager_finish(struct server *server);
+static void output_manager_finish(void);
 
 void
-output_finish(struct server *server)
+output_finish(void)
 {
-	wl_list_remove(&server->new_output.link);
-	output_manager_finish(server);
+	wl_list_remove(&g_server.new_output.link);
+	output_manager_finish();
 }
 
 static void
-output_update_for_layout_change(struct server *server)
+output_update_for_layout_change(void)
 {
-	output_update_all_usable_areas(server, /*layout_changed*/ true);
-	session_lock_update_for_layout_change(server);
+	output_update_all_usable_areas(/*layout_changed*/ true);
+	session_lock_update_for_layout_change();
 
 	/*
 	 * "Move" each wlr_output_cursor (in per-output coordinates) to
 	 * align with the seat cursor. Re-set the cursor image so that
 	 * the cursor isn't invisible on new outputs.
 	 */
-	wlr_cursor_move(server->seat.cursor, NULL, 0, 0);
-	cursor_update_image(&server->seat);
+	wlr_cursor_move(g_server.seat.cursor, NULL, 0, 0);
+	cursor_update_image(&g_server.seat);
 }
 
 static bool
-output_config_apply(struct server *server,
-		struct wlr_output_configuration_v1 *config)
+output_config_apply(struct wlr_output_configuration_v1 *config)
 {
 	bool success = true;
-	server->pending_output_layout_change++;
+	g_server.pending_output_layout_change++;
 
 	struct wlr_output_configuration_head_v1 *head;
 	wl_list_for_each(head, &config->heads, link) {
 		struct wlr_output *o = head->state.output;
-		struct output *output = output_from_wlr_output(server, o);
+		struct output *output = output_from_wlr_output(o);
 		struct wlr_output_state *os = &output->pending;
 		bool output_enabled = head->state.enabled;
 
@@ -715,31 +708,31 @@ output_config_apply(struct server *server,
 		 * been enabled but not yet been added to the layout.
 		 */
 		bool was_in_layout =
-			!!wlr_output_layout_get(server->output_layout, o);
+			!!wlr_output_layout_get(g_server.output_layout, o);
 
 		if (output_enabled) {
 			if (!was_in_layout) {
-				add_output_to_layout(server, output);
+				add_output_to_layout(output);
 			}
 
 			struct wlr_box pos = {0};
-			wlr_output_layout_get_box(server->output_layout, o, &pos);
+			wlr_output_layout_get_box(g_server.output_layout, o, &pos);
 			if (pos.x != head->state.x || pos.y != head->state.y) {
 				/*
 				 * This overrides the automatic layout
 				 *
 				 * wlr_output_layout_add() in fact means _move()
 				 */
-				wlr_output_layout_add(server->output_layout, o,
+				wlr_output_layout_add(g_server.output_layout, o,
 					head->state.x, head->state.y);
 			}
 		} else if (was_in_layout) {
 			regions_evacuate_output(output);
 
 			lab_cosmic_workspace_group_output_leave(
-				server->workspaces.cosmic_group, output->wlr_output);
+				g_server.workspaces.cosmic_group, output->wlr_output);
 			lab_ext_workspace_group_output_leave(
-				server->workspaces.ext_group, output->wlr_output);
+				g_server.workspaces.ext_group, output->wlr_output);
 
 			/*
 			 * At time of writing, wlr_output_layout_remove()
@@ -750,13 +743,13 @@ output_config_apply(struct server *server,
 			 * calling wlr_output_layout_remove().
 			 */
 			wlr_scene_output_destroy(output->scene_output);
-			wlr_output_layout_remove(server->output_layout, o);
+			wlr_output_layout_remove(g_server.output_layout, o);
 			output->scene_output = NULL;
 		}
 	}
 
-	server->pending_output_layout_change--;
-	do_output_layout_change(server);
+	g_server.pending_output_layout_change--;
+	do_output_layout_change();
 	return success;
 }
 
@@ -835,27 +828,25 @@ handle_output_manager_test(struct wl_listener *listener, void *data)
 static void
 handle_output_manager_apply(struct wl_listener *listener, void *data)
 {
-	struct server *server =
-		wl_container_of(listener, server, output_manager_apply);
 	struct wlr_output_configuration_v1 *config = data;
 
 	bool config_is_good = verify_output_config_v1(config);
 
-	if (config_is_good && output_config_apply(server, config)) {
+	if (config_is_good && output_config_apply(config)) {
 		wlr_output_configuration_v1_send_succeeded(config);
 	} else {
 		wlr_output_configuration_v1_send_failed(config);
 	}
 	wlr_output_configuration_v1_destroy(config);
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
-		wlr_xcursor_manager_load(server->seat.xcursor_manager,
+	wl_list_for_each(output, &g_server.outputs, link) {
+		wlr_xcursor_manager_load(g_server.seat.xcursor_manager,
 			output->wlr_output->scale);
 	}
 
 	/* Re-set cursor image in case scale changed */
-	cursor_update_focus(server);
-	cursor_update_image(&server->seat);
+	cursor_update_focus();
+	cursor_update_image(&g_server.seat);
 }
 
 /*
@@ -864,7 +855,7 @@ handle_output_manager_apply(struct wl_listener *listener, void *data)
  * interface
  */
 static struct
-wlr_output_configuration_v1 *create_output_config(struct server *server)
+wlr_output_configuration_v1 *create_output_config(void)
 {
 	struct wlr_output_configuration_v1 *config =
 		wlr_output_configuration_v1_create();
@@ -874,7 +865,7 @@ wlr_output_configuration_v1 *create_output_config(struct server *server)
 	}
 
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		struct wlr_output_configuration_head_v1 *head =
 			wlr_output_configuration_head_v1_create(config,
 				output->wlr_output);
@@ -893,35 +884,32 @@ wlr_output_configuration_v1 *create_output_config(struct server *server)
 }
 
 static void
-do_output_layout_change(struct server *server)
+do_output_layout_change(void)
 {
-	if (!server->pending_output_layout_change) {
+	if (!g_server.pending_output_layout_change) {
 		struct wlr_output_configuration_v1 *config =
-			create_output_config(server);
+			create_output_config();
 		if (config) {
 			wlr_output_manager_v1_set_configuration(
-				server->output_manager, config);
+				g_server.output_manager, config);
 		} else {
 			wlr_log(WLR_ERROR,
 				"wlr_output_manager_v1_set_configuration()");
 		}
-		output_update_for_layout_change(server);
-		seat_output_layout_changed(&server->seat);
+		output_update_for_layout_change();
+		seat_output_layout_changed(&g_server.seat);
 	}
 }
 
 static void
 handle_output_layout_change(struct wl_listener *listener, void *data)
 {
-	struct server *server =
-		wl_container_of(listener, server, output_layout_change);
-
 	/* Prevents unnecessary layout recalculations */
-	server->pending_output_layout_change++;
-	output_virtual_update_fallback(server);
-	server->pending_output_layout_change--;
+	g_server.pending_output_layout_change++;
+	output_virtual_update_fallback();
+	g_server.pending_output_layout_change--;
 
-	do_output_layout_change(server);
+	do_output_layout_change();
 }
 
 static void
@@ -938,41 +926,41 @@ handle_gamma_control_set_gamma(struct wl_listener *listener, void *data)
 }
 
 static void
-output_manager_init(struct server *server)
+output_manager_init(void)
 {
-	server->output_manager = wlr_output_manager_v1_create(server->wl_display);
+	g_server.output_manager = wlr_output_manager_v1_create(g_server.wl_display);
 
-	server->output_layout_change.notify = handle_output_layout_change;
-	wl_signal_add(&server->output_layout->events.change,
-		&server->output_layout_change);
+	g_server.output_layout_change.notify = handle_output_layout_change;
+	wl_signal_add(&g_server.output_layout->events.change,
+		&g_server.output_layout_change);
 
-	server->output_manager_apply.notify = handle_output_manager_apply;
-	wl_signal_add(&server->output_manager->events.apply,
-		&server->output_manager_apply);
+	g_server.output_manager_apply.notify = handle_output_manager_apply;
+	wl_signal_add(&g_server.output_manager->events.apply,
+		&g_server.output_manager_apply);
 
-	server->output_manager_test.notify = handle_output_manager_test;
-	wl_signal_add(&server->output_manager->events.test,
-		&server->output_manager_test);
+	g_server.output_manager_test.notify = handle_output_manager_test;
+	wl_signal_add(&g_server.output_manager->events.test,
+		&g_server.output_manager_test);
 
-	server->gamma_control_set_gamma.notify = handle_gamma_control_set_gamma;
-	wl_signal_add(&server->gamma_control_manager_v1->events.set_gamma,
-		&server->gamma_control_set_gamma);
+	g_server.gamma_control_set_gamma.notify = handle_gamma_control_set_gamma;
+	wl_signal_add(&g_server.gamma_control_manager_v1->events.set_gamma,
+		&g_server.gamma_control_set_gamma);
 }
 
 static void
-output_manager_finish(struct server *server)
+output_manager_finish(void)
 {
-	wl_list_remove(&server->output_layout_change.link);
-	wl_list_remove(&server->output_manager_apply.link);
-	wl_list_remove(&server->output_manager_test.link);
-	wl_list_remove(&server->gamma_control_set_gamma.link);
+	wl_list_remove(&g_server.output_layout_change.link);
+	wl_list_remove(&g_server.output_manager_apply.link);
+	wl_list_remove(&g_server.output_manager_test.link);
+	wl_list_remove(&g_server.gamma_control_set_gamma.link);
 }
 
 struct output *
-output_from_wlr_output(struct server *server, struct wlr_output *wlr_output)
+output_from_wlr_output(struct wlr_output *wlr_output)
 {
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (output->wlr_output == wlr_output) {
 			return output;
 		}
@@ -981,10 +969,10 @@ output_from_wlr_output(struct server *server, struct wlr_output *wlr_output)
 }
 
 struct output *
-output_from_name(struct server *server, const char *name)
+output_from_name(const char *name)
 {
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (!output_is_usable(output) || !output->wlr_output->name) {
 			continue;
 		}
@@ -996,22 +984,21 @@ output_from_name(struct server *server, const char *name)
 }
 
 struct output *
-output_nearest_to(struct server *server, int lx, int ly)
+output_nearest_to(int lx, int ly)
 {
 	double closest_x, closest_y;
-	wlr_output_layout_closest_point(server->output_layout, NULL, lx, ly,
+	wlr_output_layout_closest_point(g_server.output_layout, NULL, lx, ly,
 		&closest_x, &closest_y);
 
-	return output_from_wlr_output(server,
-		wlr_output_layout_output_at(server->output_layout,
+	return output_from_wlr_output(wlr_output_layout_output_at(g_server.output_layout,
 			closest_x, closest_y));
 }
 
 struct output *
-output_nearest_to_cursor(struct server *server)
+output_nearest_to_cursor(void)
 {
-	return output_nearest_to(server, server->seat.cursor->x,
-		server->seat.cursor->y);
+	return output_nearest_to(g_server.seat.cursor->x,
+		g_server.seat.cursor->y);
 }
 
 struct output *
@@ -1035,7 +1022,7 @@ output_get_adjacent(struct output *output, enum lab_edge edge, bool wrap)
 	/* Determine any adjacent output in the appropriate direction */
 	struct wlr_output *new_output = NULL;
 	struct wlr_output *current_output = output->wlr_output;
-	struct wlr_output_layout *layout = output->server->output_layout;
+	struct wlr_output_layout *layout = g_server.output_layout;
 	/* Cast from enum lab_edge to enum wlr_direction is safe */
 	new_output = wlr_output_layout_adjacent_output(layout,
 		(enum wlr_direction)edge, current_output, lx, ly);
@@ -1058,7 +1045,7 @@ output_get_adjacent(struct output *output, enum lab_edge edge, bool wrap)
 		return NULL;
 	}
 
-	output = output_from_wlr_output(output->server, new_output);
+	output = output_from_wlr_output(new_output);
 	if (!output_is_usable(output)) {
 		wlr_log(WLR_ERROR, "invalid output in layout");
 		return NULL;
@@ -1089,10 +1076,10 @@ update_usable_area(struct output *output)
 
 #if HAVE_XWAYLAND
 	struct view *view;
-	wl_list_for_each(view, &output->server->views, link) {
+	wl_list_for_each(view, &g_server.views, link) {
 		if (view->mapped && view->type == LAB_XWAYLAND_VIEW) {
 			xwayland_adjust_usable_area(view,
-				output->server->output_layout,
+				g_server.output_layout,
 				output->wlr_output, &output->usable_area);
 		}
 	}
@@ -1106,19 +1093,19 @@ output_update_usable_area(struct output *output)
 	if (update_usable_area(output)) {
 		regions_update_geometry(output);
 #if HAVE_XWAYLAND
-		xwayland_update_workarea(output->server);
+		xwayland_update_workarea();
 #endif
-		desktop_arrange_all_views(output->server);
+		desktop_arrange_all_views();
 	}
 }
 
 void
-output_update_all_usable_areas(struct server *server, bool layout_changed)
+output_update_all_usable_areas(bool layout_changed)
 {
 	bool usable_area_changed = false;
 	struct output *output;
 
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (update_usable_area(output)) {
 			usable_area_changed = true;
 			regions_update_geometry(output);
@@ -1128,9 +1115,9 @@ output_update_all_usable_areas(struct server *server, bool layout_changed)
 	}
 	if (usable_area_changed || layout_changed) {
 #if HAVE_XWAYLAND
-		xwayland_update_workarea(server);
+		xwayland_update_workarea();
 #endif
-		desktop_arrange_all_views(server);
+		desktop_arrange_all_views();
 	}
 }
 
@@ -1142,7 +1129,7 @@ output_usable_area_in_layout_coords(struct output *output)
 	}
 	struct wlr_box box = output->usable_area;
 	double ox = 0, oy = 0;
-	wlr_output_layout_output_coords(output->server->output_layout,
+	wlr_output_layout_output_coords(g_server.output_layout,
 		output->wlr_output, &ox, &oy);
 	box.x -= ox;
 	box.y -= oy;
@@ -1152,8 +1139,6 @@ output_usable_area_in_layout_coords(struct output *output)
 void
 handle_output_power_manager_set_mode(struct wl_listener *listener, void *data)
 {
-	struct server *server = wl_container_of(listener, server,
-		output_power_manager_set_mode);
 	struct wlr_output_power_v1_set_mode_event *event = data;
 	struct output *output = event->output->data;
 	assert(output);
@@ -1176,7 +1161,7 @@ handle_output_power_manager_set_mode(struct wl_listener *listener, void *data)
 		 * Re-set the cursor image so that the cursor
 		 * isn't invisible on the newly enabled output.
 		 */
-		cursor_update_image(&server->seat);
+		cursor_update_image(&g_server.seat);
 		break;
 	}
 }

src/overlay.c

@@ -16,8 +16,7 @@ static void
 show_overlay(struct seat *seat, struct theme_snapping_overlay *overlay_theme,
 		struct wlr_box *box)
 {
-	struct server *server = seat->server;
-	struct view *view = server->grabbed_view;
+	struct view *view = g_server.grabbed_view;
 	assert(view);
 	assert(!seat->overlay.rect);
 
@@ -94,7 +93,7 @@ edge_has_adjacent_output_from_cursor(struct seat *seat, struct output *output,
 	}
 	/* Cast from enum lab_edge to enum wlr_direction is safe */
 	return wlr_output_layout_adjacent_output(
-		seat->server->output_layout, (enum wlr_direction)edge,
+		g_server.output_layout, (enum wlr_direction)edge,
 		output->wlr_output, seat->cursor->x, seat->cursor->y);
 }
 
@@ -124,7 +123,7 @@ show_edge_overlay(struct seat *seat, enum lab_edge edge1, enum lab_edge edge2,
 	if (delay > 0) {
 		if (!seat->overlay.timer) {
 			seat->overlay.timer = wl_event_loop_add_timer(
-				seat->server->wl_event_loop,
+				g_server.wl_event_loop,
 				handle_edge_overlay_timeout, seat);
 		}
 		/* Show overlay <snapping><preview><delay>ms later */
@@ -138,11 +137,9 @@ show_edge_overlay(struct seat *seat, enum lab_edge edge1, enum lab_edge edge2,
 void
 overlay_update(struct seat *seat)
 {
-	struct server *server = seat->server;
-
 	/* Region-snapping overlay */
-	if (regions_should_snap(server)) {
-		struct region *region = regions_from_cursor(server);
+	if (regions_should_snap()) {
+		struct region *region = regions_from_cursor();
 		if (region) {
 			show_region_overlay(seat, region);
 			return;

src/placement.c

@@ -46,8 +46,6 @@ count_views(struct view *view)
 {
 	assert(view);
 
-	struct server *server = view->server;
-
 	struct output *output = view->output;
 	if (!output_is_usable(output)) {
 		return 0;
@@ -56,7 +54,7 @@ count_views(struct view *view)
 	int nviews = 0;
 
 	struct view *v;
-	for_each_view(v, &server->views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
+	for_each_view(v, &g_server.views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
 		/* Ignore the target view or anything on a different output */
 		if (v == view || v->output != output) {
 			continue;
@@ -105,8 +103,6 @@ build_grid(struct overlap_bitmap *bmp, struct view *view)
 	assert(bmp);
 	assert(view);
 
-	struct server *server = view->server;
-
 	/* Always start with a fresh bitmap */
 	destroy_bitmap(bmp);
 
@@ -145,7 +141,7 @@ build_grid(struct overlap_bitmap *bmp, struct view *view)
 	int nr_cols = 2;
 
 	struct view *v;
-	for_each_view(v, &server->views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
+	for_each_view(v, &g_server.views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
 		if (v == view || v->output != output) {
 			continue;
 		}
@@ -236,8 +232,6 @@ build_overlap(struct overlap_bitmap *bmp, struct view *view)
 	assert(bmp);
 	assert(view);
 
-	struct server *server = view->server;
-
 	if (bmp->nr_rows < 1 || bmp->nr_cols < 1) {
 		return;
 	}
@@ -248,7 +242,7 @@ build_overlap(struct overlap_bitmap *bmp, struct view *view)
 	}
 
 	struct view *v;
-	for_each_view(v, &server->views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
+	for_each_view(v, &g_server.views, LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
 		if (v == view || v->output != output) {
 			continue;
 		}

src/regions.c

@@ -17,16 +17,16 @@
 #include "view.h"
 
 bool
-regions_should_snap(struct server *server)
+regions_should_snap(void)
 {
-	if (server->input_mode != LAB_INPUT_STATE_MOVE
+	if (g_server.input_mode != LAB_INPUT_STATE_MOVE
 			|| wl_list_empty(&rc.regions)
-			|| server->seat.region_prevent_snap
-			|| !view_is_floating(server->grabbed_view)) {
+			|| g_server.seat.region_prevent_snap
+			|| !view_is_floating(g_server.grabbed_view)) {
 		return false;
 	}
 
-	return keyboard_get_all_modifiers(&server->seat);
+	return keyboard_get_all_modifiers(&g_server.seat);
 }
 
 struct region *
@@ -44,14 +44,14 @@ regions_from_name(const char *region_name, struct output *output)
 }
 
 struct region *
-regions_from_cursor(struct server *server)
+regions_from_cursor(void)
 {
-	double lx = server->seat.cursor->x;
-	double ly = server->seat.cursor->y;
+	double lx = g_server.seat.cursor->x;
+	double ly = g_server.seat.cursor->y;
 
 	struct wlr_output *wlr_output = wlr_output_layout_output_at(
-		server->output_layout, lx, ly);
-	struct output *output = output_from_wlr_output(server, wlr_output);
+		g_server.output_layout, lx, ly);
+	struct output *output = output_from_wlr_output(wlr_output);
 	if (!output_is_usable(output)) {
 		return NULL;
 	}
@@ -81,7 +81,7 @@ regions_reconfigure_output(struct output *output)
 	/* Evacuate views and destroy current regions */
 	if (!wl_list_empty(&output->regions)) {
 		regions_evacuate_output(output);
-		regions_destroy(&output->server->seat, &output->regions);
+		regions_destroy(&g_server.seat, &output->regions);
 	}
 
 	/* Initialize regions from config */
@@ -100,17 +100,17 @@ regions_reconfigure_output(struct output *output)
 }
 
 void
-regions_reconfigure(struct server *server)
+regions_reconfigure(void)
 {
 	struct output *output;
 
 	/* Evacuate views and initialize regions from config */
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		regions_reconfigure_output(output);
 	}
 
 	/* Tries to match the evacuated views to the new regions */
-	desktop_arrange_all_views(server);
+	desktop_arrange_all_views();
 }
 
 void
@@ -149,7 +149,7 @@ regions_evacuate_output(struct output *output)
 {
 	assert(output);
 	struct view *view;
-	wl_list_for_each(view, &output->server->views, link) {
+	wl_list_for_each(view, &g_server.views, link) {
 		if (view->tiled_region && view->tiled_region->output == output) {
 			view_evacuate_region(view);
 		}

src/resistance.c

@@ -165,7 +165,7 @@ resistance_resize_apply(struct view *view, struct wlr_box *new_geom)
 	edges_initialize(&next_edges);
 
 	/* Use a constrained, effective geometry for snapping if appropriate */
-	enum lab_edge resize_edges = view->server->resize_edges;
+	enum lab_edge resize_edges = g_server.resize_edges;
 	struct wlr_box origin =
 		snap_constraints_effective(view, resize_edges, /* use_pending */ false);
 

src/resize-outlines.c

@@ -25,9 +25,9 @@ resize_outlines_update(struct view *view, struct wlr_box new_geo)
 	if (!outlines->rect) {
 		struct lab_scene_rect_options opts = {
 			.border_colors = (float *[3]) {
-				view->server->theme->osd_bg_color,
-				view->server->theme->osd_label_text_color,
-				view->server->theme->osd_bg_color,
+				g_server.theme->osd_bg_color,
+				g_server.theme->osd_label_text_color,
+				g_server.theme->osd_bg_color,
 			},
 			.nr_borders = 3,
 			.border_width = 1,

src/scaled-buffer/scaled-icon-buffer.c

@@ -59,8 +59,7 @@ img_to_buffer(struct lab_img *img, int width, int height, double scale)
 static struct lab_data_buffer *
 load_client_icon(struct scaled_icon_buffer *self, int icon_size, double scale)
 {
-	struct lab_img *img = desktop_entry_load_icon(self->server,
-		self->view_icon_name, icon_size, scale);
+	struct lab_img *img = desktop_entry_load_icon(self->view_icon_name, icon_size, scale);
 	if (img) {
 		wlr_log(WLR_DEBUG, "loaded icon from client icon name");
 		return img_to_buffer(img, self->width, self->height, scale);
@@ -83,8 +82,7 @@ load_client_icon(struct scaled_icon_buffer *self, int icon_size, double scale)
 static struct lab_data_buffer *
 load_server_icon(struct scaled_icon_buffer *self, int icon_size, double scale)
 {
-	struct lab_img *img = desktop_entry_load_icon_from_app_id(self->server,
-		self->view_app_id, icon_size, scale);
+	struct lab_img *img = desktop_entry_load_icon_from_app_id(self->view_app_id, icon_size, scale);
 	if (img) {
 		wlr_log(WLR_DEBUG, "loaded icon by app_id");
 		return img_to_buffer(img, self->width, self->height, scale);
@@ -106,7 +104,7 @@ _create_buffer(struct scaled_buffer *scaled_buffer, double scale)
 
 	if (self->icon_name) {
 		/* generic icon (e.g. menu icons) */
-		img = desktop_entry_load_icon(self->server, self->icon_name,
+		img = desktop_entry_load_icon(self->icon_name,
 			icon_size, scale);
 		if (img) {
 			wlr_log(WLR_DEBUG, "loaded icon by icon name");
@@ -136,7 +134,7 @@ _create_buffer(struct scaled_buffer *scaled_buffer, double scale)
 		}
 	}
 	/* If both client and server icons are unavailable, use the fallback icon */
-	img = desktop_entry_load_icon(self->server, rc.fallback_app_icon_name,
+	img = desktop_entry_load_icon(rc.fallback_app_icon_name,
 		icon_size, scale);
 	if (img) {
 		wlr_log(WLR_DEBUG, "loaded fallback icon");
@@ -215,8 +213,7 @@ static struct scaled_buffer_impl impl = {
 };
 
 struct scaled_icon_buffer *
-scaled_icon_buffer_create(struct wlr_scene_tree *parent, struct server *server,
-	int width, int height)
+scaled_icon_buffer_create(struct wlr_scene_tree *parent, int width, int height)
 {
 	assert(parent);
 	assert(width >= 0 && height >= 0);
@@ -226,7 +223,6 @@ scaled_icon_buffer_create(struct wlr_scene_tree *parent, struct server *server,
 	struct scaled_icon_buffer *self = znew(*self);
 	self->scaled_buffer = scaled_buffer;
 	self->scene_buffer = scaled_buffer->scene_buffer;
-	self->server = server;
 	self->width = width;
 	self->height = height;
 

src/seat.c

@@ -350,11 +350,11 @@ configure_libinput(struct wlr_input_device *wlr_input_device)
 }
 
 static struct wlr_output *
-output_by_name(struct server *server, const char *name)
+output_by_name(const char *name)
 {
 	assert(name);
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (!strcasecmp(output->wlr_output->name, name)) {
 			return output->wlr_output;
 		}
@@ -367,7 +367,7 @@ map_input_to_output(struct seat *seat, struct wlr_input_device *dev, char *outpu
 {
 	struct wlr_output *output = NULL;
 	if (output_name) {
-		output = output_by_name(seat->server, output_name);
+		output = output_by_name(output_name);
 	}
 	wlr_cursor_map_input_to_output(seat->cursor, dev, output);
 	wlr_cursor_map_input_to_region(seat->cursor, dev, NULL);
@@ -594,7 +594,6 @@ handle_focus_change(struct wl_listener *listener, void *data)
 {
 	struct seat *seat = wl_container_of(listener, seat, focus_change);
 	struct wlr_seat_keyboard_focus_change_event *event = data;
-	struct server *server = seat->server;
 	struct wlr_surface *surface = event->new_surface;
 	struct view *view = surface ? view_from_wlr_surface(surface) : NULL;
 
@@ -610,29 +609,28 @@ handle_focus_change(struct wl_listener *listener, void *data)
 	 * We clear the keyboard focus at the beginning of Move/Resize, window
 	 * switcher and opening menus, but don't want to deactivate the view.
 	 */
-	if (server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		return;
 	}
 
-	if (view != server->active_view) {
-		if (server->active_view) {
-			view_set_activated(server->active_view, false);
+	if (view != g_server.active_view) {
+		if (g_server.active_view) {
+			view_set_activated(g_server.active_view, false);
 		}
 		if (view) {
 			view_set_activated(view, true);
 			tablet_pad_enter_surface(seat, surface);
 		}
-		server->active_view = view;
+		g_server.active_view = view;
 	}
 }
 
 void
-seat_init(struct server *server)
+seat_init(void)
 {
-	struct seat *seat = &server->seat;
-	seat->server = server;
+	struct seat *seat = &g_server.seat;
 
-	seat->seat = wlr_seat_create(server->wl_display, "seat0");
+	seat->seat = wlr_seat_create(g_server.wl_display, "seat0");
 	if (!seat->seat) {
 		wlr_log(WLR_ERROR, "cannot allocate seat");
 		exit(EXIT_FAILURE);
@@ -642,15 +640,15 @@ seat_init(struct server *server)
 	wl_list_init(&seat->constraint_commit.link);
 	wl_list_init(&seat->inputs);
 
-	CONNECT_SIGNAL(server->backend, seat, new_input);
+	CONNECT_SIGNAL(g_server.backend, seat, new_input);
 	CONNECT_SIGNAL(&seat->seat->keyboard_state, seat, focus_change);
 
 	seat->virtual_pointer = wlr_virtual_pointer_manager_v1_create(
-		server->wl_display);
+		g_server.wl_display);
 	CONNECT_SIGNAL(seat->virtual_pointer, seat, new_virtual_pointer);
 
 	seat->virtual_keyboard = wlr_virtual_keyboard_manager_v1_create(
-		server->wl_display);
+		g_server.wl_display);
 	CONNECT_SIGNAL(seat->virtual_keyboard, seat, new_virtual_keyboard);
 
 	seat->input_method_relay = input_method_relay_create(seat);
@@ -662,7 +660,7 @@ seat_init(struct server *server)
 		wlr_log(WLR_ERROR, "unable to create cursor");
 		exit(EXIT_FAILURE);
 	}
-	wlr_cursor_attach_output_layout(seat->cursor, server->output_layout);
+	wlr_cursor_attach_output_layout(seat->cursor, g_server.output_layout);
 
 	wl_list_init(&seat->tablets);
 	wl_list_init(&seat->tablet_tools);
@@ -672,9 +670,9 @@ seat_init(struct server *server)
 }
 
 void
-seat_finish(struct server *server)
+seat_finish(void)
 {
-	struct seat *seat = &server->seat;
+	struct seat *seat = &g_server.seat;
 	wl_list_remove(&seat->new_input.link);
 	wl_list_remove(&seat->focus_change.link);
 	wl_list_remove(&seat->new_virtual_pointer.link);
@@ -729,9 +727,9 @@ seat_pointer_end_grab(struct seat *seat, struct wlr_surface *surface)
 
 /* This is called on SIGHUP (generally in response to labwc --reconfigure */
 void
-seat_reconfigure(struct server *server)
+seat_reconfigure(void)
 {
-	struct seat *seat = &server->seat;
+	struct seat *seat = &g_server.seat;
 	struct input *input;
 	cursor_reload(seat);
 	overlay_finish(seat);
@@ -762,7 +760,7 @@ seat_reconfigure(struct server *server)
 void
 seat_force_focus_surface(struct seat *seat, struct wlr_surface *surface)
 {
-	if (seat->server->session_lock_manager->locked) {
+	if (g_server.session_lock_manager->locked) {
 		return;
 	}
 	uint32_t *pressed_sent_keycodes = key_state_pressed_sent_keycodes();
@@ -789,8 +787,7 @@ seat_focus(struct seat *seat, struct wlr_surface *surface,
 	 * It should also come before the !surface condition, or the
 	 * lock screen may lose focus and become impossible to unlock.
 	 */
-	struct server *server = seat->server;
-	if (server->session_lock_manager->locked && !is_lock_surface) {
+	if (g_server.session_lock_manager->locked && !is_lock_surface) {
 		return;
 	}
 
@@ -826,16 +823,16 @@ seat_focus(struct seat *seat, struct wlr_surface *surface,
 	input_method_relay_set_focus(seat->input_method_relay, surface);
 
 	struct wlr_pointer_constraint_v1 *constraint =
-		wlr_pointer_constraints_v1_constraint_for_surface(server->constraints,
+		wlr_pointer_constraints_v1_constraint_for_surface(g_server.constraints,
 			surface, seat->seat);
-	constrain_cursor(server, constraint);
+	constrain_cursor(constraint);
 }
 
 void
 seat_focus_surface(struct seat *seat, struct wlr_surface *surface)
 {
 	/* Don't update focus while window switcher, Move/Resize and menu interaction */
-	if (seat->server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
+	if (g_server.input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
 		return;
 	}
 	seat_focus(seat, surface, /*replace_exclusive_layer*/ false,
@@ -854,7 +851,7 @@ seat_set_focus_layer(struct seat *seat, struct wlr_layer_surface_v1 *layer)
 {
 	if (!layer) {
 		seat->focused_layer = NULL;
-		desktop_focus_topmost_view(seat->server);
+		desktop_focus_topmost_view();
 		return;
 	}
 	seat_focus(seat, layer->surface, /*replace_exclusive_layer*/ true,
@@ -897,9 +894,9 @@ seat_focus_override_begin(struct seat *seat, enum input_mode input_mode,
 	enum lab_cursors cursor_shape)
 {
 	assert(!seat->focus_override.surface);
-	assert(seat->server->input_mode == LAB_INPUT_STATE_PASSTHROUGH);
+	assert(g_server.input_mode == LAB_INPUT_STATE_PASSTHROUGH);
 
-	seat->server->input_mode = input_mode;
+	g_server.input_mode = input_mode;
 
 	seat->focus_override.surface = seat->seat->keyboard_state.focused_surface;
 	if (seat->focus_override.surface) {
@@ -918,7 +915,7 @@ seat_focus_override_begin(struct seat *seat, enum input_mode input_mode,
 void
 seat_focus_override_end(struct seat *seat, bool restore_focus)
 {
-	seat->server->input_mode = LAB_INPUT_STATE_PASSTHROUGH;
+	g_server.input_mode = LAB_INPUT_STATE_PASSTHROUGH;
 
 	if (seat->focus_override.surface) {
 		if (restore_focus) {
@@ -931,6 +928,6 @@ seat_focus_override_end(struct seat *seat, bool restore_focus)
 	}
 
 	if (restore_focus) {
-		cursor_update_focus(seat->server);
+		cursor_update_focus();
 	}
 }

src/server.c

@@ -78,7 +78,7 @@
 #define LAB_WLR_PRESENTATION_TIME_VERSION 2
 
 static void
-reload_config_and_theme(struct server *server)
+reload_config_and_theme(void)
 {
 	/* Avoid UAF when dialog client is used during reconfigure */
 	action_prompts_destroy();
@@ -86,37 +86,35 @@ reload_config_and_theme(struct server *server)
 	scaled_buffer_invalidate_sharing();
 	rcxml_finish();
 	rcxml_read(rc.config_file);
-	theme_finish(server->theme);
-	theme_init(server->theme, server, rc.theme_name);
+	theme_finish(g_server.theme);
+	theme_init(g_server.theme, rc.theme_name);
 
 #if HAVE_LIBSFDO
-	desktop_entry_finish(server);
-	desktop_entry_init(server);
+	desktop_entry_finish();
+	desktop_entry_init();
 #endif
 
 	struct view *view;
-	wl_list_for_each(view, &server->views, link) {
+	wl_list_for_each(view, &g_server.views, link) {
 		view_reload_ssd(view);
 	}
 
-	cycle_finish(server, /*switch_focus*/ false);
-	menu_reconfigure(server);
-	seat_reconfigure(server);
-	regions_reconfigure(server);
-	resize_indicator_reconfigure(server);
+	cycle_finish(/*switch_focus*/ false);
+	menu_reconfigure();
+	seat_reconfigure();
+	regions_reconfigure();
+	resize_indicator_reconfigure();
 	kde_server_decoration_update_default();
-	workspaces_reconfigure(server);
+	workspaces_reconfigure();
 }
 
 static int
 handle_sighup(int signal, void *data)
 {
-	struct server *server = &g_server;
-
-	keyboard_cancel_all_keybind_repeats(&server->seat);
+	keyboard_cancel_all_keybind_repeats(&g_server.seat);
 	session_environment_init();
-	reload_config_and_theme(server);
-	output_virtual_update_fallback(server);
+	reload_config_and_theme();
+	output_virtual_update_fallback();
 	return 0;
 }
 
@@ -134,7 +132,6 @@ handle_sigchld(int signal, void *data)
 {
 	siginfo_t info;
 	info.si_pid = 0;
-	struct server *server = &g_server;
 
 	/* First call waitid() with NOWAIT which doesn't consume the zombie */
 	if (waitid(P_ALL, /*id*/ 0, &info, WEXITED | WNOHANG | WNOWAIT) == -1) {
@@ -148,8 +145,8 @@ handle_sigchld(int signal, void *data)
 
 #if HAVE_XWAYLAND
 	/* Ensure that we do not break xwayland lazy initialization */
-	if (server->xwayland && server->xwayland->server
-			&& info.si_pid == server->xwayland->server->pid) {
+	if (g_server.xwayland && g_server.xwayland->server
+			&& info.si_pid == g_server.xwayland->server->pid) {
 		return 0;
 	}
 #endif
@@ -187,9 +184,9 @@ handle_sigchld(int signal, void *data)
 			" please report", (long)info.si_pid, info.si_code);
 	}
 
-	if (info.si_pid == server->primary_client_pid) {
+	if (info.si_pid == g_server.primary_client_pid) {
 		wlr_log(WLR_INFO, "primary client %ld exited", (long)info.si_pid);
-		wl_display_terminate(server->wl_display);
+		wl_display_terminate(g_server.wl_display);
 	}
 
 	return 0;
@@ -302,13 +299,12 @@ static bool
 server_global_filter(const struct wl_client *client, const struct wl_global *global, void *data)
 {
 	const struct wl_interface *iface = wl_global_get_interface(global);
-	struct server *server = &g_server;
 	/* Silence unused var compiler warnings */
 	(void)iface;
 
 #if HAVE_XWAYLAND
-	struct wl_client *xwayland_client = (server->xwayland && server->xwayland->server)
-		? server->xwayland->server->client
+	struct wl_client *xwayland_client = (g_server.xwayland && g_server.xwayland->server)
+		? g_server.xwayland->server->client
 		: NULL;
 
 	if (client != xwayland_client && !strcmp(iface->name, xwayland_shell_v1_interface.name)) {
@@ -320,8 +316,8 @@ server_global_filter(const struct wl_client *client, const struct wl_global *glo
 	/* Do not allow security_context_manager_v1 to clients with a security context attached */
 	const struct wlr_security_context_v1_state *security_context =
 		wlr_security_context_manager_v1_lookup_client(
-			server->security_context_manager_v1, (struct wl_client *)client);
-	if (security_context && global == server->security_context_manager_v1->global) {
+			g_server.security_context_manager_v1, (struct wl_client *)client);
+	if (security_context && global == g_server.security_context_manager_v1->global) {
 		return false;
 	} else if (security_context) {
 		/*
@@ -382,41 +378,39 @@ get_headless_backend(struct wlr_backend *backend, void *data)
 static void
 handle_renderer_lost(struct wl_listener *listener, void *data)
 {
-	struct server *server = wl_container_of(listener, server, renderer_lost);
-
 	wlr_log(WLR_INFO, "Re-creating renderer after GPU reset");
 
-	struct wlr_renderer *renderer = wlr_renderer_autocreate(server->backend);
+	struct wlr_renderer *renderer = wlr_renderer_autocreate(g_server.backend);
 	if (!renderer) {
 		wlr_log(WLR_ERROR, "Unable to create renderer");
 		return;
 	}
 
 	struct wlr_allocator *allocator =
-		wlr_allocator_autocreate(server->backend, renderer);
+		wlr_allocator_autocreate(g_server.backend, renderer);
 	if (!allocator) {
 		wlr_log(WLR_ERROR, "Unable to create allocator");
 		wlr_renderer_destroy(renderer);
 		return;
 	}
 
-	struct wlr_renderer *old_renderer = server->renderer;
-	struct wlr_allocator *old_allocator = server->allocator;
-	server->renderer = renderer;
-	server->allocator = allocator;
+	struct wlr_renderer *old_renderer = g_server.renderer;
+	struct wlr_allocator *old_allocator = g_server.allocator;
+	g_server.renderer = renderer;
+	g_server.allocator = allocator;
 
-	wl_list_remove(&server->renderer_lost.link);
-	wl_signal_add(&server->renderer->events.lost, &server->renderer_lost);
+	wl_list_remove(&g_server.renderer_lost.link);
+	wl_signal_add(&g_server.renderer->events.lost, &g_server.renderer_lost);
 
-	wlr_compositor_set_renderer(server->compositor, renderer);
+	wlr_compositor_set_renderer(g_server.compositor, renderer);
 
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		wlr_output_init_render(output->wlr_output,
-			server->allocator, server->renderer);
+			g_server.allocator, g_server.renderer);
 	}
 
-	reload_config_and_theme(server);
+	reload_config_and_theme();
 
 	magnifier_reset();
 
@@ -425,29 +419,29 @@ handle_renderer_lost(struct wl_listener *listener, void *data)
 }
 
 void
-server_init(struct server *server)
+server_init(void)
 {
-	server->primary_client_pid = -1;
-	server->wl_display = wl_display_create();
-	if (!server->wl_display) {
+	g_server.primary_client_pid = -1;
+	g_server.wl_display = wl_display_create();
+	if (!g_server.wl_display) {
 		wlr_log(WLR_ERROR, "cannot allocate a wayland display");
 		exit(EXIT_FAILURE);
 	}
 	/* Increase max client buffer size to make slow clients less likely to terminate  */
-	wl_display_set_default_max_buffer_size(server->wl_display, 1024 * 1024);
+	wl_display_set_default_max_buffer_size(g_server.wl_display, 1024 * 1024);
 
-	wl_display_set_global_filter(server->wl_display, server_global_filter, NULL);
-	server->wl_event_loop = wl_display_get_event_loop(server->wl_display);
+	wl_display_set_global_filter(g_server.wl_display, server_global_filter, NULL);
+	g_server.wl_event_loop = wl_display_get_event_loop(g_server.wl_display);
 
 	/* Catch signals */
-	server->sighup_source = wl_event_loop_add_signal(
-		server->wl_event_loop, SIGHUP, handle_sighup, NULL);
-	server->sigint_source = wl_event_loop_add_signal(
-		server->wl_event_loop, SIGINT, handle_sigterm, server->wl_display);
-	server->sigterm_source = wl_event_loop_add_signal(
-		server->wl_event_loop, SIGTERM, handle_sigterm, server->wl_display);
-	server->sigchld_source = wl_event_loop_add_signal(
-		server->wl_event_loop, SIGCHLD, handle_sigchld, NULL);
+	g_server.sighup_source = wl_event_loop_add_signal(
+		g_server.wl_event_loop, SIGHUP, handle_sighup, NULL);
+	g_server.sigint_source = wl_event_loop_add_signal(
+		g_server.wl_event_loop, SIGINT, handle_sigterm, g_server.wl_display);
+	g_server.sigterm_source = wl_event_loop_add_signal(
+		g_server.wl_event_loop, SIGTERM, handle_sigterm, g_server.wl_display);
+	g_server.sigchld_source = wl_event_loop_add_signal(
+		g_server.wl_event_loop, SIGCHLD, handle_sigchld, NULL);
 
 	/*
 	 * Prevent wayland clients that request the X11 clipboard but closing
@@ -465,31 +459,31 @@ server_init(struct server *server)
 	 * backend based on the current environment, such as opening an x11
 	 * window if an x11 server is running.
 	 */
-	server->backend = wlr_backend_autocreate(
-		server->wl_event_loop, &server->session);
-	if (!server->backend) {
+	g_server.backend = wlr_backend_autocreate(
+		g_server.wl_event_loop, &g_server.session);
+	if (!g_server.backend) {
 		wlr_log(WLR_ERROR, "unable to create backend");
 		fprintf(stderr, helpful_seat_error_message);
 		exit(EXIT_FAILURE);
 	}
 
 	/* Create headless backend to enable adding virtual outputs later on */
-	wlr_multi_for_each_backend(server->backend,
-		get_headless_backend, &server->headless.backend);
+	wlr_multi_for_each_backend(g_server.backend,
+		get_headless_backend, &g_server.headless.backend);
 
-	if (!server->headless.backend) {
+	if (!g_server.headless.backend) {
 		wlr_log(WLR_DEBUG, "manually creating headless backend");
-		server->headless.backend = wlr_headless_backend_create(
-			server->wl_event_loop);
+		g_server.headless.backend = wlr_headless_backend_create(
+			g_server.wl_event_loop);
 	} else {
 		wlr_log(WLR_DEBUG, "headless backend already exists");
 	}
 
-	if (!server->headless.backend) {
+	if (!g_server.headless.backend) {
 		wlr_log(WLR_ERROR, "unable to create headless backend");
 		exit(EXIT_FAILURE);
 	}
-	wlr_multi_backend_add(server->backend, server->headless.backend);
+	wlr_multi_backend_add(g_server.backend, g_server.headless.backend);
 
 	/*
 	 * If we don't populate headless backend with a virtual output (that we
@@ -497,7 +491,7 @@ server_init(struct server *server)
 	 * later do not work properly when overlaid on real output. Content is
 	 * drawn on the virtual output, but not drawn on the real output.
 	 */
-	wlr_output_destroy(wlr_headless_add_output(server->headless.backend, 0, 0));
+	wlr_output_destroy(wlr_headless_add_output(g_server.headless.backend, 0, 0));
 
 	/*
 	 * Autocreates a renderer, either Pixman, GLES2 or Vulkan for us. The
@@ -505,38 +499,38 @@ server_init(struct server *server)
 	 * The renderer is responsible for defining the various pixel formats it
 	 * supports for shared memory, this configures that for clients.
 	 */
-	server->renderer = wlr_renderer_autocreate(server->backend);
-	if (!server->renderer) {
+	g_server.renderer = wlr_renderer_autocreate(g_server.backend);
+	if (!g_server.renderer) {
 		wlr_log(WLR_ERROR, "unable to create renderer");
 		exit(EXIT_FAILURE);
 	}
 
-	server->renderer_lost.notify = handle_renderer_lost;
-	wl_signal_add(&server->renderer->events.lost, &server->renderer_lost);
+	g_server.renderer_lost.notify = handle_renderer_lost;
+	wl_signal_add(&g_server.renderer->events.lost, &g_server.renderer_lost);
 
-	if (!wlr_renderer_init_wl_shm(server->renderer, server->wl_display)) {
+	if (!wlr_renderer_init_wl_shm(g_server.renderer, g_server.wl_display)) {
 		wlr_log(WLR_ERROR, "Failed to initialize shared memory pool");
 		exit(EXIT_FAILURE);
 	}
 
 	if (wlr_renderer_get_texture_formats(
-			server->renderer, WLR_BUFFER_CAP_DMABUF)) {
-		if (wlr_renderer_get_drm_fd(server->renderer) >= 0) {
-			wlr_drm_create(server->wl_display, server->renderer);
+			g_server.renderer, WLR_BUFFER_CAP_DMABUF)) {
+		if (wlr_renderer_get_drm_fd(g_server.renderer) >= 0) {
+			wlr_drm_create(g_server.wl_display, g_server.renderer);
 		}
-		server->linux_dmabuf = wlr_linux_dmabuf_v1_create_with_renderer(
-			server->wl_display,
+		g_server.linux_dmabuf = wlr_linux_dmabuf_v1_create_with_renderer(
+			g_server.wl_display,
 			LAB_WLR_LINUX_DMABUF_VERSION,
-			server->renderer);
+			g_server.renderer);
 	} else {
 		wlr_log(WLR_DEBUG, "unable to initialize dmabuf");
 	}
 
-	if (wlr_renderer_get_drm_fd(server->renderer) >= 0 &&
-			server->renderer->features.timeline &&
-			server->backend->features.timeline) {
-		wlr_linux_drm_syncobj_manager_v1_create(server->wl_display, 1,
-			wlr_renderer_get_drm_fd(server->renderer));
+	if (wlr_renderer_get_drm_fd(g_server.renderer) >= 0 &&
+			g_server.renderer->features.timeline &&
+			g_server.backend->features.timeline) {
+		wlr_linux_drm_syncobj_manager_v1_create(g_server.wl_display, 1,
+			wlr_renderer_get_drm_fd(g_server.renderer));
 	}
 
 	/*
@@ -544,22 +538,22 @@ server_init(struct server *server)
 	 * the renderer and the backend. It handles the buffer creation,
 	 * allowing wlroots to render onto the screen
 	 */
-	server->allocator = wlr_allocator_autocreate(
-		server->backend, server->renderer);
-	if (!server->allocator) {
+	g_server.allocator = wlr_allocator_autocreate(
+		g_server.backend, g_server.renderer);
+	if (!g_server.allocator) {
 		wlr_log(WLR_ERROR, "unable to create allocator");
 		exit(EXIT_FAILURE);
 	}
 
-	wl_list_init(&server->views);
-	wl_list_init(&server->unmanaged_surfaces);
-	wl_list_init(&server->cycle.views);
-	wl_list_init(&server->cycle.osd_outputs);
+	wl_list_init(&g_server.views);
+	wl_list_init(&g_server.unmanaged_surfaces);
+	wl_list_init(&g_server.cycle.views);
+	wl_list_init(&g_server.cycle.osd_outputs);
 
-	server->scene = wlr_scene_create();
-	die_if_null(server->scene);
+	g_server.scene = wlr_scene_create();
+	die_if_null(g_server.scene);
 
-	server->direct_scanout_enabled = server->scene->WLR_PRIVATE.direct_scanout;
+	g_server.direct_scanout_enabled = g_server.scene->WLR_PRIVATE.direct_scanout;
 
 	/*
 	 * The order in which the scene-trees below are created determines the
@@ -570,14 +564,14 @@ server_init(struct server *server)
 	 * | ---------------------------------- | -------------------------------------
 	 * | output->session_lock_tree          | session lock surfaces (e.g. swaylock)
 	 * | output->cycle_osd_tree             | window switcher's on-screen display
-	 * | server->cycle_preview_tree         | window switcher's previewed window
-	 * | server->menu_tree                  | labwc's server-side menus
+	 * | g_server.cycle_preview_tree         | window switcher's previewed window
+	 * | g_server.menu_tree                  | labwc's server-side menus
 	 * | output->layer_popup_tree           | xdg popups on layer surfaces
 	 * | output->layer_tree[3]              | overlay layer surfaces (e.g. rofi)
 	 * | output->layer_tree[2]              | top layer surfaces (e.g. waybar)
-	 * | server->unmanaged_tree             | unmanaged X11 surfaces (e.g. dmenu)
-	 * | server->xdg_popup_tree             | xdg popups on xdg windows
-	 * | server->workspace_tree             |
+	 * | g_server.unmanaged_tree             | unmanaged X11 surfaces (e.g. dmenu)
+	 * | g_server.xdg_popup_tree             | xdg popups on xdg windows
+	 * | g_server.workspace_tree             |
 	 * | + workspace->tree                  |
 	 * |   + workspace->view_trees[1]       | always-on-top xdg/X11 windows
 	 * |   + workspace->view_trees[0]       | normal xdg/X11 windows (e.g. firefox)
@@ -586,17 +580,17 @@ server_init(struct server *server)
 	 * | output->layer_tree[0]              | background layer surfaces (e.g. swaybg)
 	 */
 
-	server->workspace_tree = lab_wlr_scene_tree_create(&server->scene->tree);
-	server->xdg_popup_tree = lab_wlr_scene_tree_create(&server->scene->tree);
+	g_server.workspace_tree = lab_wlr_scene_tree_create(&g_server.scene->tree);
+	g_server.xdg_popup_tree = lab_wlr_scene_tree_create(&g_server.scene->tree);
 #if HAVE_XWAYLAND
-	server->unmanaged_tree = lab_wlr_scene_tree_create(&server->scene->tree);
+	g_server.unmanaged_tree = lab_wlr_scene_tree_create(&g_server.scene->tree);
 #endif
-	server->menu_tree = lab_wlr_scene_tree_create(&server->scene->tree);
-	server->cycle_preview_tree = lab_wlr_scene_tree_create(&server->scene->tree);
+	g_server.menu_tree = lab_wlr_scene_tree_create(&g_server.scene->tree);
+	g_server.cycle_preview_tree = lab_wlr_scene_tree_create(&g_server.scene->tree);
 
-	workspaces_init(server);
+	workspaces_init();
 
-	output_init(server);
+	output_init();
 
 	/*
 	 * Create some hands-off wlroots interfaces. The compositor is
@@ -605,16 +599,16 @@ server_init(struct server *server)
 	 * room for you to dig your fingers in and play with their behavior if
 	 * you want.
 	 */
-	server->compositor = wlr_compositor_create(server->wl_display,
-		LAB_WLR_COMPOSITOR_VERSION, server->renderer);
-	if (!server->compositor) {
+	g_server.compositor = wlr_compositor_create(g_server.wl_display,
+		LAB_WLR_COMPOSITOR_VERSION, g_server.renderer);
+	if (!g_server.compositor) {
 		wlr_log(WLR_ERROR, "unable to create the wlroots compositor");
 		exit(EXIT_FAILURE);
 	}
-	wlr_subcompositor_create(server->wl_display);
+	wlr_subcompositor_create(g_server.wl_display);
 
 	struct wlr_data_device_manager *device_manager = NULL;
-	device_manager = wlr_data_device_manager_create(server->wl_display);
+	device_manager = wlr_data_device_manager_create(g_server.wl_display);
 	if (!device_manager) {
 		wlr_log(WLR_ERROR, "unable to create data device manager");
 		exit(EXIT_FAILURE);
@@ -631,111 +625,111 @@ server_init(struct server *server)
 	 * https://wayfire.org/2020/08/04/Wayfire-0-5.html
 	 */
 	if (rc.primary_selection) {
-		wlr_primary_selection_v1_device_manager_create(server->wl_display);
+		wlr_primary_selection_v1_device_manager_create(g_server.wl_display);
 	}
 
-	server->input_method_manager = wlr_input_method_manager_v2_create(
-		server->wl_display);
-	server->text_input_manager = wlr_text_input_manager_v3_create(
-		server->wl_display);
-	seat_init(server);
-	xdg_shell_init(server);
-	kde_server_decoration_init(server);
-	xdg_server_decoration_init(server);
+	g_server.input_method_manager = wlr_input_method_manager_v2_create(
+		g_server.wl_display);
+	g_server.text_input_manager = wlr_text_input_manager_v3_create(
+		g_server.wl_display);
+	seat_init();
+	xdg_shell_init();
+	kde_server_decoration_init();
+	xdg_server_decoration_init();
 
 	struct wlr_presentation *presentation = wlr_presentation_create(
-		server->wl_display, server->backend,
+		g_server.wl_display, g_server.backend,
 		LAB_WLR_PRESENTATION_TIME_VERSION);
 	if (!presentation) {
 		wlr_log(WLR_ERROR, "unable to create presentation interface");
 		exit(EXIT_FAILURE);
 	}
-	if (server->linux_dmabuf) {
-		wlr_scene_set_linux_dmabuf_v1(server->scene, server->linux_dmabuf);
+	if (g_server.linux_dmabuf) {
+		wlr_scene_set_linux_dmabuf_v1(g_server.scene, g_server.linux_dmabuf);
 	}
 
-	wlr_export_dmabuf_manager_v1_create(server->wl_display);
-	wlr_screencopy_manager_v1_create(server->wl_display);
-	wlr_ext_image_copy_capture_manager_v1_create(server->wl_display, 1);
-	wlr_ext_output_image_capture_source_manager_v1_create(server->wl_display, 1);
-	wlr_data_control_manager_v1_create(server->wl_display);
-	wlr_ext_data_control_manager_v1_create(server->wl_display,
+	wlr_export_dmabuf_manager_v1_create(g_server.wl_display);
+	wlr_screencopy_manager_v1_create(g_server.wl_display);
+	wlr_ext_image_copy_capture_manager_v1_create(g_server.wl_display, 1);
+	wlr_ext_output_image_capture_source_manager_v1_create(g_server.wl_display, 1);
+	wlr_data_control_manager_v1_create(g_server.wl_display);
+	wlr_ext_data_control_manager_v1_create(g_server.wl_display,
 		LAB_EXT_DATA_CONTROL_VERSION);
-	server->security_context_manager_v1 =
-		wlr_security_context_manager_v1_create(server->wl_display);
-	wlr_viewporter_create(server->wl_display);
-	wlr_single_pixel_buffer_manager_v1_create(server->wl_display);
-	wlr_fractional_scale_manager_v1_create(server->wl_display,
+	g_server.security_context_manager_v1 =
+		wlr_security_context_manager_v1_create(g_server.wl_display);
+	wlr_viewporter_create(g_server.wl_display);
+	wlr_single_pixel_buffer_manager_v1_create(g_server.wl_display);
+	wlr_fractional_scale_manager_v1_create(g_server.wl_display,
 		LAB_WLR_FRACTIONAL_SCALE_V1_VERSION);
 
-	idle_manager_create(server->wl_display);
+	idle_manager_create(g_server.wl_display);
 
-	server->relative_pointer_manager = wlr_relative_pointer_manager_v1_create(
-		server->wl_display);
-	server->constraints = wlr_pointer_constraints_v1_create(
-		server->wl_display);
+	g_server.relative_pointer_manager = wlr_relative_pointer_manager_v1_create(
+		g_server.wl_display);
+	g_server.constraints = wlr_pointer_constraints_v1_create(
+		g_server.wl_display);
 
-	server->new_constraint.notify = create_constraint;
-	wl_signal_add(&server->constraints->events.new_constraint,
-		&server->new_constraint);
+	g_server.new_constraint.notify = create_constraint;
+	wl_signal_add(&g_server.constraints->events.new_constraint,
+		&g_server.new_constraint);
 
-	server->foreign_toplevel_manager =
-		wlr_foreign_toplevel_manager_v1_create(server->wl_display);
+	g_server.foreign_toplevel_manager =
+		wlr_foreign_toplevel_manager_v1_create(g_server.wl_display);
 
-	server->foreign_toplevel_list =
+	g_server.foreign_toplevel_list =
 		wlr_ext_foreign_toplevel_list_v1_create(
-			server->wl_display, LAB_EXT_FOREIGN_TOPLEVEL_LIST_VERSION);
+			g_server.wl_display, LAB_EXT_FOREIGN_TOPLEVEL_LIST_VERSION);
 
-	wlr_alpha_modifier_v1_create(server->wl_display);
+	wlr_alpha_modifier_v1_create(g_server.wl_display);
 
-	session_lock_init(server);
+	session_lock_init();
 
-	server->drm_lease_manager = wlr_drm_lease_v1_manager_create(
-		server->wl_display, server->backend);
-	if (server->drm_lease_manager) {
-		server->drm_lease_request.notify = handle_drm_lease_request;
-		wl_signal_add(&server->drm_lease_manager->events.request,
-				&server->drm_lease_request);
+	g_server.drm_lease_manager = wlr_drm_lease_v1_manager_create(
+		g_server.wl_display, g_server.backend);
+	if (g_server.drm_lease_manager) {
+		g_server.drm_lease_request.notify = handle_drm_lease_request;
+		wl_signal_add(&g_server.drm_lease_manager->events.request,
+				&g_server.drm_lease_request);
 	} else {
 		wlr_log(WLR_DEBUG, "Failed to create wlr_drm_lease_device_v1");
 		wlr_log(WLR_INFO, "VR will not be available");
 	}
 
-	server->output_power_manager_v1 =
-		wlr_output_power_manager_v1_create(server->wl_display);
-	server->output_power_manager_set_mode.notify =
+	g_server.output_power_manager_v1 =
+		wlr_output_power_manager_v1_create(g_server.wl_display);
+	g_server.output_power_manager_set_mode.notify =
 		handle_output_power_manager_set_mode;
-	wl_signal_add(&server->output_power_manager_v1->events.set_mode,
-		&server->output_power_manager_set_mode);
+	wl_signal_add(&g_server.output_power_manager_v1->events.set_mode,
+		&g_server.output_power_manager_set_mode);
 
-	server->tearing_control = wlr_tearing_control_manager_v1_create(server->wl_display, 1);
-	server->tearing_new_object.notify = handle_tearing_new_object;
-	wl_signal_add(&server->tearing_control->events.new_object, &server->tearing_new_object);
+	g_server.tearing_control = wlr_tearing_control_manager_v1_create(g_server.wl_display, 1);
+	g_server.tearing_new_object.notify = handle_tearing_new_object;
+	wl_signal_add(&g_server.tearing_control->events.new_object, &g_server.tearing_new_object);
 
-	server->tablet_manager = wlr_tablet_v2_create(server->wl_display);
+	g_server.tablet_manager = wlr_tablet_v2_create(g_server.wl_display);
 
-	layers_init(server);
+	layers_init();
 
 	/* These get cleaned up automatically on display destroy */
 	struct wlr_xdg_foreign_registry *registry =
-		wlr_xdg_foreign_registry_create(server->wl_display);
-	wlr_xdg_foreign_v1_create(server->wl_display, registry);
-	wlr_xdg_foreign_v2_create(server->wl_display, registry);
+		wlr_xdg_foreign_registry_create(g_server.wl_display);
+	wlr_xdg_foreign_v1_create(g_server.wl_display, registry);
+	wlr_xdg_foreign_v2_create(g_server.wl_display, registry);
 
 #if HAVE_LIBSFDO
-	desktop_entry_init(server);
+	desktop_entry_init();
 #endif
 
 #if HAVE_XWAYLAND
-	xwayland_server_init(server, server->compositor);
+	xwayland_server_init(g_server.compositor);
 #endif
 }
 
 void
-server_start(struct server *server)
+server_start(void)
 {
 	/* Add a Unix socket to the Wayland display. */
-	const char *socket = wl_display_add_socket_auto(server->wl_display);
+	const char *socket = wl_display_add_socket_auto(g_server.wl_display);
 	if (!socket) {
 		wlr_log_errno(WLR_ERROR, "unable to open wayland socket");
 		exit(EXIT_FAILURE);
@@ -745,13 +739,13 @@ server_start(struct server *server)
 	 * Start the backend. This will enumerate outputs and inputs, become
 	 * the DRM master, etc
 	 */
-	if (!wlr_backend_start(server->backend)) {
+	if (!wlr_backend_start(g_server.backend)) {
 		wlr_log(WLR_ERROR, "unable to start the wlroots backend");
 		exit(EXIT_FAILURE);
 	}
 
 	/* Potentially set up the initial fallback output */
-	output_virtual_update_fallback(server);
+	output_virtual_update_fallback();
 
 	if (setenv("WAYLAND_DISPLAY", socket, true) < 0) {
 		wlr_log_errno(WLR_ERROR, "unable to set WAYLAND_DISPLAY");
@@ -761,43 +755,43 @@ server_start(struct server *server)
 }
 
 void
-server_finish(struct server *server)
+server_finish(void)
 {
 #if HAVE_XWAYLAND
-	xwayland_server_finish(server);
+	xwayland_server_finish();
 #endif
 #if HAVE_LIBSFDO
-	desktop_entry_finish(server);
+	desktop_entry_finish();
 #endif
-	wl_event_source_remove(server->sighup_source);
-	wl_event_source_remove(server->sigint_source);
-	wl_event_source_remove(server->sigterm_source);
-	wl_event_source_remove(server->sigchld_source);
+	wl_event_source_remove(g_server.sighup_source);
+	wl_event_source_remove(g_server.sigint_source);
+	wl_event_source_remove(g_server.sigterm_source);
+	wl_event_source_remove(g_server.sigchld_source);
 
-	wl_display_destroy_clients(server->wl_display);
+	wl_display_destroy_clients(g_server.wl_display);
 
-	seat_finish(server);
-	output_finish(server);
-	xdg_shell_finish(server);
-	layers_finish(server);
-	kde_server_decoration_finish(server);
-	xdg_server_decoration_finish(server);
-	wl_list_remove(&server->new_constraint.link);
-	wl_list_remove(&server->output_power_manager_set_mode.link);
-	wl_list_remove(&server->tearing_new_object.link);
-	if (server->drm_lease_request.notify) {
-		wl_list_remove(&server->drm_lease_request.link);
-		server->drm_lease_request.notify = NULL;
+	seat_finish();
+	output_finish();
+	xdg_shell_finish();
+	layers_finish();
+	kde_server_decoration_finish();
+	xdg_server_decoration_finish();
+	wl_list_remove(&g_server.new_constraint.link);
+	wl_list_remove(&g_server.output_power_manager_set_mode.link);
+	wl_list_remove(&g_server.tearing_new_object.link);
+	if (g_server.drm_lease_request.notify) {
+		wl_list_remove(&g_server.drm_lease_request.link);
+		g_server.drm_lease_request.notify = NULL;
 	}
 
-	wlr_backend_destroy(server->backend);
-	wlr_allocator_destroy(server->allocator);
+	wlr_backend_destroy(g_server.backend);
+	wlr_allocator_destroy(g_server.allocator);
 
-	wl_list_remove(&server->renderer_lost.link);
-	wlr_renderer_destroy(server->renderer);
+	wl_list_remove(&g_server.renderer_lost.link);
+	wlr_renderer_destroy(g_server.renderer);
 
-	workspaces_destroy(server);
-	wlr_scene_node_destroy(&server->scene->tree.node);
+	workspaces_destroy();
+	wlr_scene_node_destroy(&g_server.scene->tree.node);
 
-	wl_display_destroy(server->wl_display);
+	wl_display_destroy(g_server.wl_display);
 }

src/session-lock.c

@@ -31,7 +31,7 @@ static void
 focus_surface(struct session_lock_manager *manager, struct wlr_surface *focused)
 {
 	manager->focused = focused;
-	seat_focus_lock_surface(&manager->server->seat, focused);
+	seat_focus_lock_surface(&g_server.seat, focused);
 }
 
 static void
@@ -59,7 +59,7 @@ static void
 update_focus(void *data)
 {
 	struct session_lock_output *output = data;
-	cursor_update_focus(output->manager->server);
+	cursor_update_focus();
 	if (!output->manager->focused) {
 		focus_surface(output->manager, output->surface->surface);
 	}
@@ -78,7 +78,7 @@ handle_surface_map(struct wl_listener *listener, void *data)
 	 * buffer has not been actually attached to the surface.
 	 */
 	wl_event_loop_add_idle(
-		output->manager->server->wl_event_loop, update_focus, output);
+		g_server.wl_event_loop, update_focus, output);
 }
 
 static void
@@ -98,7 +98,7 @@ static void
 lock_output_reconfigure(struct session_lock_output *output)
 {
 	struct wlr_box box;
-	wlr_output_layout_get_box(output->manager->server->output_layout,
+	wlr_output_layout_get_box(g_server.output_layout,
 		output->output->wlr_output, &box);
 	wlr_scene_rect_set_size(output->background, box.width, box.height);
 	if (output->surface) {
@@ -191,7 +191,7 @@ static void
 align_session_lock_tree(struct output *output)
 {
 	struct wlr_box box;
-	wlr_output_layout_get_box(output->server->output_layout,
+	wlr_output_layout_get_box(g_server.output_layout,
 		output->wlr_output, &box);
 	wlr_scene_node_set_position(&output->session_lock_tree->node, box.x, box.y);
 }
@@ -228,7 +228,7 @@ session_lock_output_create(struct session_lock_manager *manager, struct output *
 	 * already locked, blank immediately.
 	 */
 	lock_output->blank_timer =
-		wl_event_loop_add_timer(manager->server->wl_event_loop,
+		wl_event_loop_add_timer(g_server.wl_event_loop,
 			handle_output_blank_timeout, lock_output);
 	if (!manager->locked) {
 		wlr_scene_node_set_enabled(&background->node, false);
@@ -279,11 +279,11 @@ handle_lock_unlock(struct wl_listener *listener, void *data)
 	if (manager->last_active_view) {
 		desktop_focus_view(manager->last_active_view, /* raise */ false);
 	} else {
-		desktop_focus_topmost_view(manager->server);
+		desktop_focus_topmost_view();
 	}
 	manager->last_active_view = NULL;
 
-	cursor_update_focus(manager->server);
+	cursor_update_focus();
 }
 
 /* Called when session-lock is destroyed without unlock */
@@ -323,11 +323,11 @@ handle_new_session_lock(struct wl_listener *listener, void *data)
 	assert(wl_list_empty(&manager->lock_outputs));
 
 	/* Remember the focused view to restore it on unlock */
-	manager->last_active_view = manager->server->active_view;
-	seat_focus_surface(&manager->server->seat, NULL);
+	manager->last_active_view = g_server.active_view;
+	seat_focus_surface(&g_server.seat, NULL);
 
 	struct output *output;
-	wl_list_for_each(output, &manager->server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		session_lock_output_create(manager, output);
 	}
 
@@ -353,17 +353,16 @@ handle_manager_destroy(struct wl_listener *listener, void *data)
 	session_lock_destroy(manager);
 	wl_list_remove(&manager->new_lock.link);
 	wl_list_remove(&manager->destroy.link);
-	manager->server->session_lock_manager = NULL;
+	g_server.session_lock_manager = NULL;
 	free(manager);
 }
 
 void
-session_lock_init(struct server *server)
+session_lock_init(void)
 {
 	struct session_lock_manager *manager = znew(*manager);
-	server->session_lock_manager = manager;
-	manager->server = server;
-	manager->wlr_manager = wlr_session_lock_manager_v1_create(server->wl_display);
+	g_server.session_lock_manager = manager;
+	manager->wlr_manager = wlr_session_lock_manager_v1_create(g_server.wl_display);
 	wl_list_init(&manager->lock_outputs);
 
 	manager->new_lock.notify = handle_new_session_lock;
@@ -374,18 +373,18 @@ session_lock_init(struct server *server)
 }
 
 void
-session_lock_update_for_layout_change(struct server *server)
+session_lock_update_for_layout_change(void)
 {
-	if (!server->session_lock_manager->locked) {
+	if (!g_server.session_lock_manager->locked) {
 		return;
 	}
 
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		align_session_lock_tree(output);
 	}
 
-	struct session_lock_manager *manager = server->session_lock_manager;
+	struct session_lock_manager *manager = g_server.session_lock_manager;
 	struct session_lock_output *lock_output;
 	wl_list_for_each(lock_output, &manager->lock_outputs, link) {
 		lock_output_reconfigure(lock_output);

src/ssd/resize-indicator.c

@@ -62,7 +62,7 @@ wants_indicator(struct view *view)
 	assert(view);
 
 	if (rc.resize_indicator == LAB_RESIZE_INDICATOR_NON_PIXEL) {
-		if (view->server->input_mode != LAB_INPUT_STATE_RESIZE) {
+		if (g_server.input_mode != LAB_INPUT_STATE_RESIZE) {
 			return false;
 		}
 		struct view_size_hints hints = view_get_size_hints(view);
@@ -74,15 +74,15 @@ wants_indicator(struct view *view)
 }
 
 void
-resize_indicator_reconfigure(struct server *server)
+resize_indicator_reconfigure(void)
 {
 	struct view *view;
-	wl_list_for_each(view, &server->views, link) {
+	wl_list_for_each(view, &g_server.views, link) {
 		struct resize_indicator *indicator = &view->resize_indicator;
 		if (indicator->tree) {
 			resize_indicator_reconfigure_view(indicator);
 		}
-		if (view != server->grabbed_view) {
+		if (view != g_server.grabbed_view) {
 			continue;
 		}
 
@@ -143,7 +143,7 @@ void
 resize_indicator_update(struct view *view)
 {
 	assert(view);
-	assert(view == view->server->grabbed_view);
+	assert(view == g_server.grabbed_view);
 
 	if (!wants_indicator(view)) {
 		return;
@@ -173,21 +173,21 @@ resize_indicator_update(struct view *view)
 		view_box.height = view_effective_height(view, /* use_pending */ false);
 	}
 
-	if (view->server->input_mode == LAB_INPUT_STATE_RESIZE) {
+	if (g_server.input_mode == LAB_INPUT_STATE_RESIZE) {
 		struct view_size_hints hints = view_get_size_hints(view);
 		snprintf(text, sizeof(text), "%d x %d",
 			MAX(0, view_box.width - hints.base_width)
 				/ MAX(1, hints.width_inc),
 			MAX(0, view_box.height - hints.base_height)
 				/ MAX(1, hints.height_inc));
-	} else if (view->server->input_mode == LAB_INPUT_STATE_MOVE) {
+	} else if (g_server.input_mode == LAB_INPUT_STATE_MOVE) {
 		struct border margin = ssd_get_margin(view->ssd);
 		snprintf(text, sizeof(text), "%d , %d",
 			view_box.x - margin.left,
 			view_box.y - margin.top);
 	} else {
 		wlr_log(WLR_ERROR, "Invalid input mode for indicator update %u",
-			view->server->input_mode);
+			g_server.input_mode);
 		return;
 	}
 

src/ssd/ssd-border.c

@@ -17,7 +17,7 @@ ssd_border_create(struct ssd *ssd)
 	assert(!ssd->border.tree);
 
 	struct view *view = ssd->view;
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 	int width = view->current.width;
 	int height = view_effective_height(view, /* use_pending */ false);
 	int full_width = width + 2 * theme->border_width;
@@ -90,7 +90,7 @@ ssd_border_update(struct ssd *ssd)
 		ssd->margin = ssd_thickness(ssd->view);
 	}
 
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 
 	int width = view->current.width;
 	int height = view_effective_height(view, /* use_pending */ false);

src/ssd/ssd-button.c

@@ -50,8 +50,7 @@ attach_ssd_button(struct wl_list *button_parts, enum lab_node_type type,
 
 	if (type == LAB_NODE_BUTTON_WINDOW_ICON) {
 		struct scaled_icon_buffer *icon_buffer =
-			scaled_icon_buffer_create(root, view->server,
-				button_width - 2 * icon_padding, button_height);
+			scaled_icon_buffer_create(root, button_width - 2 * icon_padding, button_height);
 		assert(icon_buffer);
 		struct wlr_scene_node *icon_node = &icon_buffer->scene_buffer->node;
 		scaled_icon_buffer_set_view(icon_buffer, view);

src/ssd/ssd-extents.c

@@ -14,7 +14,7 @@ void
 ssd_extents_create(struct ssd *ssd)
 {
 	struct view *view = ssd->view;
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 
 	int border_width = MAX(0, MAX(rc.resize_minimum_area, theme->border_width));
 
@@ -100,7 +100,7 @@ ssd_extents_update(struct ssd *ssd)
 		return;
 	}
 
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 
 	int width = view->current.width;
 	int height = view_effective_height(view, /* use_pending */ false);
@@ -120,7 +120,7 @@ ssd_extents_update(struct ssd *ssd)
 	pixman_region32_t usable;
 	pixman_region32_init(&usable);
 	struct output *output;
-	wl_list_for_each(output, &view->server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (!view_on_output(view, output)) {
 			continue;
 		}

src/ssd/ssd-shadow.c

@@ -145,7 +145,7 @@ static void
 set_shadow_geometry(struct ssd *ssd)
 {
 	struct view *view = ssd->view;
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 	int titlebar_height = ssd->titlebar.height;
 	int width = view->current.width;
 	int height = view_effective_height(view, false) + titlebar_height;
@@ -203,7 +203,7 @@ ssd_shadow_create(struct ssd *ssd)
 
 	ssd->shadow.tree = lab_wlr_scene_tree_create(ssd->tree);
 
-	struct theme *theme = ssd->view->server->theme;
+	struct theme *theme = g_server.theme;
 	struct view *view = ssd->view;
 
 	enum ssd_active_state active;
@@ -256,7 +256,7 @@ ssd_shadow_update(struct ssd *ssd)
 	assert(ssd->shadow.tree);
 
 	struct view *view = ssd->view;
-	struct theme *theme = ssd->view->server->theme;
+	struct theme *theme = g_server.theme;
 	bool maximized = view->maximized == VIEW_AXIS_BOTH;
 	bool tiled_shadows = false;
 	if (rc.shadows_on_tiled) {

src/ssd/ssd-titlebar.c

@@ -27,7 +27,7 @@ void
 ssd_titlebar_create(struct ssd *ssd)
 {
 	struct view *view = ssd->view;
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 	int width = view->current.width;
 	int corner_width = ssd_get_corner_width();
 
@@ -58,7 +58,7 @@ ssd_titlebar_create(struct ssd *ssd)
 		 * TODO: remove once https://gitlab.freedesktop.org/wlroots/wlroots/-/issues/3990
 		 * is solved
 		 */
-		if (wlr_renderer_is_pixman(view->server->renderer)) {
+		if (wlr_renderer_is_pixman(g_server.renderer)) {
 			wlr_scene_buffer_set_filter_mode(
 				subtree->bar, WLR_SCALE_FILTER_NEAREST);
 		}
@@ -160,7 +160,7 @@ set_squared_corners(struct ssd *ssd, bool enable)
 	struct view *view = ssd->view;
 	int width = view->current.width;
 	int corner_width = ssd_get_corner_width();
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 
 	int x = enable ? 0 : corner_width;
 
@@ -220,7 +220,7 @@ static void
 update_visible_buttons(struct ssd *ssd)
 {
 	struct view *view = ssd->view;
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 	int width = MAX(view->current.width - 2 * theme->window_titlebar_padding_width, 0);
 	int button_width = theme->window_button_width;
 	int button_spacing = theme->window_button_spacing;
@@ -273,7 +273,7 @@ ssd_titlebar_update(struct ssd *ssd)
 	struct view *view = ssd->view;
 	int width = view->current.width;
 	int corner_width = ssd_get_corner_width();
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 
 	bool maximized = view->maximized == VIEW_AXIS_BOTH;
 	bool squared = ssd_should_be_squared(ssd);
@@ -365,7 +365,7 @@ static void
 ssd_update_title_positions(struct ssd *ssd, int offset_left, int offset_right)
 {
 	struct view *view = ssd->view;
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 	int width = view->current.width;
 	int title_bg_width = width - offset_left - offset_right;
 
@@ -413,9 +413,9 @@ static void
 get_title_offsets(struct ssd *ssd, int *offset_left, int *offset_right)
 {
 	struct ssd_titlebar_subtree *subtree = &ssd->titlebar.subtrees[SSD_ACTIVE];
-	int button_width = ssd->view->server->theme->window_button_width;
-	int button_spacing = ssd->view->server->theme->window_button_spacing;
-	int padding_width = ssd->view->server->theme->window_titlebar_padding_width;
+	int button_width = g_server.theme->window_button_width;
+	int button_spacing = g_server.theme->window_button_spacing;
+	int padding_width = g_server.theme->window_titlebar_padding_width;
 	*offset_left = padding_width;
 	*offset_right = padding_width;
 
@@ -443,7 +443,7 @@ ssd_update_title(struct ssd *ssd)
 	/* view->title is never NULL (instead it can be an empty string) */
 	assert(view->title);
 
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 	struct ssd_state_title *state = &ssd->state.title;
 	bool title_unchanged = state->text && !strcmp(view->title, state->text);
 
@@ -487,23 +487,23 @@ ssd_update_title(struct ssd *ssd)
 }
 
 void
-ssd_update_hovered_button(struct server *server, struct wlr_scene_node *node)
+ssd_update_hovered_button(struct wlr_scene_node *node)
 {
 	struct ssd_button *button = NULL;
 
 	if (node && node->data) {
 		button = node_try_ssd_button_from_node(node);
-		if (button == server->hovered_button) {
+		if (button == g_server.hovered_button) {
 			/* Cursor is still on the same button */
 			return;
 		}
 	}
 
 	/* Disable old hover */
-	if (server->hovered_button) {
-		update_button_state(server->hovered_button, LAB_BS_HOVERED, false);
+	if (g_server.hovered_button) {
+		update_button_state(g_server.hovered_button, LAB_BS_HOVERED, false);
 	}
-	server->hovered_button = button;
+	g_server.hovered_button = button;
 	if (button) {
 		update_button_state(button, LAB_BS_HOVERED, true);
 	}

src/ssd/ssd.c

@@ -39,7 +39,7 @@ ssd_thickness(struct view *view)
 		return (struct border){ 0 };
 	}
 
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 
 	if (view->maximized == VIEW_AXIS_BOTH) {
 		struct border thickness = { 0 };
@@ -101,7 +101,7 @@ ssd_get_resizing_type(const struct ssd *ssd, struct wlr_cursor *cursor)
 
 	if (view_titlebar_visible(view)) {
 		/* If the titlebar is visible, consider it part of the view */
-		int titlebar_height = view->server->theme->titlebar_height;
+		int titlebar_height = g_server.theme->titlebar_height;
 		view_box.y -= titlebar_height;
 		view_box.height += titlebar_height;
 	}
@@ -156,7 +156,7 @@ ssd_create(struct view *view, bool active)
 		LAB_NODE_SSD_ROOT, view, /*data*/ NULL);
 
 	wlr_scene_node_lower_to_bottom(&ssd->tree->node);
-	ssd->titlebar.height = view->server->theme->titlebar_height;
+	ssd->titlebar.height = g_server.theme->titlebar_height;
 	ssd_shadow_create(ssd);
 	ssd_extents_create(ssd);
 	/*
@@ -257,7 +257,7 @@ ssd_set_titlebar(struct ssd *ssd, bool enabled)
 		return;
 	}
 	wlr_scene_node_set_enabled(&ssd->titlebar.tree->node, enabled);
-	ssd->titlebar.height = enabled ? ssd->view->server->theme->titlebar_height : 0;
+	ssd->titlebar.height = enabled ? g_server.theme->titlebar_height : 0;
 	ssd_border_update(ssd);
 	ssd_extents_update(ssd);
 	ssd_shadow_update(ssd);
@@ -273,10 +273,9 @@ ssd_destroy(struct ssd *ssd)
 
 	/* Maybe reset hover view */
 	struct view *view = ssd->view;
-	struct server *server = view->server;
-	if (server->hovered_button && node_view_from_node(
-			server->hovered_button->node) == view) {
-		server->hovered_button = NULL;
+	if (g_server.hovered_button && node_view_from_node(
+			g_server.hovered_button->node) == view) {
+		g_server.hovered_button = NULL;
 	}
 
 	/* Destroy subcomponents */

src/tearing.c

@@ -40,12 +40,11 @@ handle_controller_destroy(struct wl_listener *listener, void *data)
 void
 handle_tearing_new_object(struct wl_listener *listener, void *data)
 {
-	struct server *server = wl_container_of(listener, server, tearing_new_object);
 	struct wlr_tearing_control_v1 *tearing_control = data;
 
 	enum wp_tearing_control_v1_presentation_hint hint =
 		wlr_tearing_control_manager_v1_surface_hint_from_surface
-		(server->tearing_control, tearing_control->surface);
+		(g_server.tearing_control, tearing_control->surface);
 	wlr_log(WLR_DEBUG, "New presentation hint %d received for surface %p",
 		hint, tearing_control->surface);
 

src/theme.c

@@ -529,7 +529,7 @@ parse_justification(const char *str)
  * theme_builtin() applies a theme that is similar to vanilla GTK
  */
 static void
-theme_builtin(struct theme *theme, struct server *server)
+theme_builtin(struct theme *theme)
 {
 	theme->border_width = 1;
 	theme->window_titlebar_padding_height = 0;
@@ -634,7 +634,7 @@ theme_builtin(struct theme *theme, struct server *server)
 	theme->osd_border_color[0] = FLT_MIN;
 	theme->osd_label_text_color[0] = FLT_MIN;
 
-	if (wlr_renderer_is_pixman(server->renderer)) {
+	if (wlr_renderer_is_pixman(g_server.renderer)) {
 		/* Draw only outlined overlay by default to save CPU resource */
 		theme->snapping_overlay_region.bg_enabled = false;
 		theme->snapping_overlay_edge.bg_enabled = false;
@@ -1815,13 +1815,13 @@ post_processing(struct theme *theme)
 }
 
 void
-theme_init(struct theme *theme, struct server *server, const char *theme_name)
+theme_init(struct theme *theme, const char *theme_name)
 {
 	/*
 	 * Set some default values. This is particularly important on
 	 * reconfigure as not all themes set all options
 	 */
-	theme_builtin(theme, server);
+	theme_builtin(theme);
 
 	struct wl_list paths;
 

src/view-impl-common.c

@@ -50,13 +50,12 @@ view_impl_unmap(struct view *view)
 	 * When exiting an xwayland application with multiple views
 	 * mapped, a race condition can occur: after the topmost view
 	 * is unmapped, the next view under it is offered focus, but is
-	 * also unmapped before accepting focus (so server->active_view
+	 * also unmapped before accepting focus (so g_server.active_view
 	 * remains NULL). To avoid being left with no active view at
 	 * all, check for that case also.
 	 */
-	struct server *server = view->server;
-	if (view == server->active_view || !server->active_view) {
-		desktop_focus_topmost_view(server);
+	if (view == g_server.active_view || !g_server.active_view) {
+		desktop_focus_topmost_view();
 	}
 
 	/*
@@ -72,10 +71,9 @@ view_impl_unmap(struct view *view)
 static bool
 resizing_edge(struct view *view, enum lab_edge edge)
 {
-	struct server *server = view->server;
-	return server->input_mode == LAB_INPUT_STATE_RESIZE
-		&& server->grabbed_view == view
-		&& (server->resize_edges & edge);
+	return g_server.input_mode == LAB_INPUT_STATE_RESIZE
+		&& g_server.grabbed_view == view
+		&& (g_server.resize_edges & edge);
 }
 
 void

src/view.c

@@ -69,7 +69,7 @@ security_context_from_view(struct view *view)
 	if (view && view->surface && view->surface->resource) {
 		struct wl_client *client = wl_resource_get_client(view->surface->resource);
 		return wlr_security_context_manager_v1_lookup_client(
-			view->server->security_context_manager_v1, client);
+			g_server.security_context_manager_v1, client);
 	}
 	return NULL;
 }
@@ -176,7 +176,7 @@ view_matches_query(struct view *view, struct view_query *query)
 		return false;
 	}
 
-	if (!query_tristate_match(query->focused, view->server->active_view == view)) {
+	if (!query_tristate_match(query->focused, g_server.active_view == view)) {
 		return false;
 	}
 
@@ -202,7 +202,7 @@ view_matches_query(struct view *view, struct view_query *query)
 
 	if (query->desktop) {
 		const char *view_workspace = view->workspace->name;
-		struct workspace *current = view->server->workspaces.current;
+		struct workspace *current = g_server.workspaces.current;
 
 		if (!strcasecmp(query->desktop, "other")) {
 			/* "other" means the view is NOT on the current desktop */
@@ -225,7 +225,7 @@ view_matches_query(struct view *view, struct view_query *query)
 	}
 
 	if (query->monitor) {
-		struct output *current = output_nearest_to_cursor(view->server);
+		struct output *current = output_nearest_to_cursor();
 		if (!strcasecmp(query->monitor, "current")) {
 			if (current != view->output) {
 				return false;
@@ -241,7 +241,7 @@ view_matches_query(struct view *view, struct view_query *query)
 				return false;
 			}
 		} else {
-			if (output_from_name(view->server, query->monitor)
+			if (output_from_name(query->monitor)
 					!= view->output) {
 				return false;
 			}
@@ -268,7 +268,7 @@ matches_criteria(struct view *view, enum lab_view_criteria criteria)
 		return false;
 	}
 	if (criteria & LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
-		if (view->workspace != view->server->workspaces.current) {
+		if (view->workspace != g_server.workspaces.current) {
 			return false;
 		}
 	}
@@ -338,11 +338,11 @@ view_prev(struct wl_list *head, struct view *view, enum lab_view_criteria criter
 }
 
 void
-view_array_append(struct server *server, struct wl_array *views,
+view_array_append(struct wl_array *views,
 		enum lab_view_criteria criteria)
 {
 	struct view *view;
-	for_each_view(view, &server->views, criteria) {
+	for_each_view(view, &g_server.views, criteria) {
 		struct view **entry = wl_array_add(views, sizeof(*entry));
 		if (!entry) {
 			wlr_log(WLR_ERROR, "wl_array_add(): out of memory");
@@ -446,8 +446,7 @@ view_discover_output(struct view *view, struct wlr_box *geometry)
 	}
 
 	struct output *output =
-		output_nearest_to(view->server,
-			geometry->x + geometry->width / 2,
+		output_nearest_to(geometry->x + geometry->width / 2,
 			geometry->y + geometry->height / 2);
 
 	if (output && output != view->output) {
@@ -473,10 +472,10 @@ view_set_activated(struct view *view, bool activated)
 		if (!activated) {
 			/* Store configured keyboard layout per view */
 			view->keyboard_layout =
-				view->server->seat.keyboard_group->keyboard.modifiers.group;
+				g_server.seat.keyboard_group->keyboard.modifiers.group;
 		} else {
 			/* Switch to previously stored keyboard layout */
-			keyboard_update_layout(&view->server->seat, view->keyboard_layout);
+			keyboard_update_layout(&g_server.seat, view->keyboard_layout);
 		}
 	}
 	output_set_has_fullscreen_view(view->output, view->fullscreen);
@@ -493,7 +492,7 @@ view_set_output(struct view *view, struct output *output)
 	view->output = output;
 	/* Show fullscreen views above top-layer */
 	if (view->fullscreen) {
-		desktop_update_top_layer_visibility(view->server);
+		desktop_update_top_layer_visibility();
 	}
 }
 
@@ -510,10 +509,10 @@ static void
 view_update_outputs(struct view *view)
 {
 	struct output *output;
-	struct wlr_output_layout *layout = view->server->output_layout;
+	struct wlr_output_layout *layout = g_server.output_layout;
 
 	uint64_t new_outputs = 0;
-	wl_list_for_each(output, &view->server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (output_is_usable(output) && wlr_output_layout_intersects(
 				layout, output->wlr_output, &view->current)) {
 			new_outputs |= output->id_bit;
@@ -523,7 +522,7 @@ view_update_outputs(struct view *view)
 	if (new_outputs != view->outputs) {
 		view->outputs = new_outputs;
 		wl_signal_emit_mutable(&view->events.new_outputs, NULL);
-		desktop_update_top_layer_visibility(view->server);
+		desktop_update_top_layer_visibility();
 	}
 }
 
@@ -562,8 +561,8 @@ view_moved(struct view *view)
 	}
 	view_update_outputs(view);
 	ssd_update_geometry(view->ssd);
-	cursor_update_focus(view->server);
-	if (rc.resize_indicator && view->server->grabbed_view == view) {
+	cursor_update_focus();
+	if (rc.resize_indicator && g_server.grabbed_view == view) {
 		resize_indicator_update(view);
 	}
 }
@@ -628,7 +627,7 @@ view_compute_near_cursor_position(struct view *view, struct wlr_box *geom)
 {
 	assert(view);
 
-	struct output *pending_output = output_nearest_to_cursor(view->server);
+	struct output *pending_output = output_nearest_to_cursor();
 	struct wlr_box usable = output_usable_area_in_layout_coords(pending_output);
 
 	/* Limit usable region to account for gap */
@@ -642,7 +641,7 @@ view_compute_near_cursor_position(struct view *view, struct wlr_box *geom)
 	}
 
 	struct border margin = ssd_thickness(view);
-	struct seat *seat = &view->server->seat;
+	struct seat *seat = &g_server.seat;
 
 	int total_width = geom->width + margin.left + margin.right;
 	int total_height = geom->height + margin.top + margin.bottom;
@@ -747,7 +746,7 @@ _minimize(struct view *view, bool minimized, bool *need_refocus)
 	 *   - unminimizing any mapped view
 	 */
 	*need_refocus |= (minimized ?
-		(view == view->server->active_view) : view->mapped);
+		(view == g_server.active_view) : view->mapped);
 }
 
 static void
@@ -784,10 +783,9 @@ void
 view_minimize(struct view *view, bool minimized)
 {
 	assert(view);
-	struct server *server = view->server;
 	bool need_refocus = false;
 
-	if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
+	if (g_server.input_mode == LAB_INPUT_STATE_CYCLE) {
 		wlr_log(WLR_ERROR, "not minimizing window while window switching");
 		return;
 	}
@@ -807,7 +805,7 @@ view_minimize(struct view *view, bool minimized)
 	 */
 	if (need_refocus) {
 		if (minimized) {
-			desktop_focus_topmost_view(server);
+			desktop_focus_topmost_view();
 		} else {
 			desktop_focus_view(view, /* raise */ true);
 		}
@@ -862,7 +860,7 @@ adjust_floating_geometry(struct view *view, struct wlr_box *geometry,
 
 	bool adjusted = false;
 	bool onscreen = false;
-	if (wlr_output_layout_intersects(view->server->output_layout,
+	if (wlr_output_layout_intersects(g_server.output_layout,
 			view->output->wlr_output, geometry)) {
 		/* Always make sure the titlebar starts within the usable area */
 		struct border margin = ssd_get_margin(view->ssd);
@@ -996,7 +994,7 @@ view_compute_cascaded_position(struct view *view, struct wlr_box *geom)
 	/* TODO: move this logic to rcxml.c */
 	int offset_x = rc.placement_cascade_offset_x;
 	int offset_y = rc.placement_cascade_offset_y;
-	struct theme *theme = view->server->theme;
+	struct theme *theme = g_server.theme;
 	int default_offset = theme->titlebar_height + theme->border_width + 5;
 	if (offset_x <= 0) {
 		offset_x = default_offset;
@@ -1016,7 +1014,7 @@ view_compute_cascaded_position(struct view *view, struct wlr_box *geom)
 
 		/* Iterate over views from top to bottom */
 		struct view *other_view;
-		for_each_view(other_view, &view->server->views,
+		for_each_view(other_view, &g_server.views,
 				LAB_VIEW_CRITERIA_CURRENT_WORKSPACE) {
 			struct wlr_box other = ssd_max_extents(other_view);
 			if (other_view == view
@@ -1251,7 +1249,7 @@ view_apply_fullscreen_geometry(struct view *view)
 	assert(output_is_usable(view->output));
 
 	struct wlr_box box = { 0 };
-	wlr_output_layout_get_box(view->server->output_layout,
+	wlr_output_layout_get_box(g_server.output_layout,
 		view->output->wlr_output, &box);
 	view_move_resize(view, box);
 }
@@ -1405,8 +1403,8 @@ view_set_untiled(struct view *view)
 static bool
 in_interactive_move(struct view *view)
 {
-	return (view->server->input_mode == LAB_INPUT_STATE_MOVE
-		&& view->server->grabbed_view == view);
+	return (g_server.input_mode == LAB_INPUT_STATE_MOVE
+		&& g_server.grabbed_view == view);
 }
 
 void
@@ -1600,7 +1598,7 @@ decorate(struct view *view)
 {
 	if (!view->ssd) {
 		view->ssd = ssd_create(view,
-			view == view->server->active_view);
+			view == g_server.active_view);
 	}
 }
 
@@ -1685,7 +1683,7 @@ set_fullscreen(struct view *view, bool fullscreen)
 
 	/* Show fullscreen views above top-layer */
 	if (view->output) {
-		desktop_update_top_layer_visibility(view->server);
+		desktop_update_top_layer_visibility();
 	}
 }
 
@@ -1722,7 +1720,7 @@ view_set_fullscreen(struct view *view, bool fullscreen)
 	 * scene node ending up under the cursor even if view_moved()
 	 * isn't called. Update cursor focus explicitly for that case.
 	 */
-	cursor_update_focus(view->server);
+	cursor_update_focus();
 }
 
 void
@@ -1766,8 +1764,7 @@ view_adjust_for_layout_change(struct view *view)
 	view->adjusting_for_layout_change = true;
 
 	struct wlr_box new_geo;
-	struct output *output = output_from_name(view->server,
-		view->last_placement.output_name);
+	struct output *output = output_from_name(view->last_placement.output_name);
 	if (output_is_usable(output)) {
 		/*
 		 * When the previous output (which might have been reconnected
@@ -2169,7 +2166,7 @@ static void
 move_to_front(struct view *view)
 {
 	wl_list_remove(&view->link);
-	wl_list_insert(&view->server->views, &view->link);
+	wl_list_insert(&g_server.views, &view->link);
 	wlr_scene_node_raise_to_top(&view->scene_tree->node);
 }
 
@@ -2177,7 +2174,7 @@ static void
 move_to_back(struct view *view)
 {
 	wl_list_remove(&view->link);
-	wl_list_append(&view->server->views, &view->link);
+	wl_list_append(&g_server.views, &view->link);
 	wlr_scene_node_lower_to_bottom(&view->scene_tree->node);
 }
 
@@ -2191,15 +2188,14 @@ void
 view_move_to_front(struct view *view)
 {
 	assert(view);
-	struct server *server = view->server;
-	assert(!wl_list_empty(&server->views));
+	assert(!wl_list_empty(&g_server.views));
 
 	/*
 	 * Check whether the view is already in front, or is the root
 	 * parent of the view in front (in which case we don't want to
 	 * raise it in front of its sub-view).
 	 */
-	struct view *front = wl_container_of(server->views.next, front, link);
+	struct view *front = wl_container_of(g_server.views.next, front, link);
 	if (view == front || view == view_get_root(front)) {
 		return;
 	}
@@ -2224,11 +2220,11 @@ view_move_to_front(struct view *view)
 	 * race, perform an explicit flush after restacking.
 	 */
 	if (view->type == LAB_XWAYLAND_VIEW) {
-		xwayland_flush(view->server);
+		xwayland_flush();
 	}
 #endif
-	cursor_update_focus(view->server);
-	desktop_update_top_layer_visibility(view->server);
+	cursor_update_focus();
+	desktop_update_top_layer_visibility();
 }
 
 void
@@ -2241,8 +2237,8 @@ view_move_to_back(struct view *view)
 	for_each_subview(root, move_to_back);
 	move_to_back(root);
 
-	cursor_update_focus(view->server);
-	desktop_update_top_layer_visibility(view->server);
+	cursor_update_focus();
+	desktop_update_top_layer_visibility();
 }
 
 bool
@@ -2387,7 +2383,7 @@ view_update_visibility(struct view *view)
 	 * Show top layer when a fullscreen view is hidden.
 	 * Hide it if a fullscreen view is shown (or uncovered).
 	 */
-	desktop_update_top_layer_visibility(view->server);
+	desktop_update_top_layer_visibility();
 
 	/*
 	 * We may need to disable adaptive sync if view was fullscreen.
@@ -2402,7 +2398,7 @@ view_update_visibility(struct view *view)
 
 	/* Update usable area to account for XWayland "struts" (panels) */
 	if (view_has_strut_partial(view)) {
-		output_update_all_usable_areas(view->server, false);
+		output_update_all_usable_areas(false);
 	}
 
 	/* View might have been unmapped/minimized during move/resize */
@@ -2426,7 +2422,7 @@ view_set_shade(struct view *view, bool shaded)
 	}
 
 	/* If this window is being resized, cancel the resize when shading */
-	if (shaded && view->server->input_mode == LAB_INPUT_STATE_RESIZE) {
+	if (shaded && g_server.input_mode == LAB_INPUT_STATE_RESIZE) {
 		interactive_cancel(view);
 	}
 
@@ -2490,7 +2486,6 @@ void
 view_destroy(struct view *view)
 {
 	assert(view);
-	struct server *server = view->server;
 
 	wl_signal_emit_mutable(&view->events.destroy, NULL);
 	snap_constraints_invalidate(view);
@@ -2516,16 +2511,16 @@ view_destroy(struct view *view)
 	 * This check is (in theory) redundant since interactive_cancel()
 	 * is called at unmap. Leaving it here just to be sure.
 	 */
-	if (server->grabbed_view == view) {
+	if (g_server.grabbed_view == view) {
 		interactive_cancel(view);
 	}
 
-	if (server->active_view == view) {
-		server->active_view = NULL;
+	if (g_server.active_view == view) {
+		g_server.active_view = NULL;
 	}
 
-	if (server->session_lock_manager->last_active_view == view) {
-		server->session_lock_manager->last_active_view = NULL;
+	if (g_server.session_lock_manager->last_active_view == view) {
+		g_server.session_lock_manager->last_active_view = NULL;
 	}
 
 	if (view->tiled_region_evacuate) {
@@ -2533,7 +2528,7 @@ view_destroy(struct view *view)
 	}
 
 	/* TODO: call this on map/unmap instead */
-	cycle_reinitialize(server);
+	cycle_reinitialize();
 
 	undecorate(view);
 
@@ -2565,9 +2560,9 @@ view_destroy(struct view *view)
 	zfree(view->title);
 	zfree(view->app_id);
 
-	/* Remove view from server->views */
+	/* Remove view from g_server.views */
 	wl_list_remove(&view->link);
 	free(view);
 
-	cursor_update_focus(server);
+	cursor_update_focus();
 }

src/window-rules.c

@@ -12,7 +12,7 @@
 static bool
 other_instances_exist(struct view *self, struct view_query *query)
 {
-	struct wl_list *views = &self->server->views;
+	struct wl_list *views = &g_server.views;
 	struct view *view;
 
 	wl_list_for_each(view, views, link) {
@@ -53,7 +53,7 @@ window_rules_apply(struct view *view, enum window_rule_event event)
 			continue;
 		}
 		if (view_matches_criteria(rule, view)) {
-			actions_run(view, view->server, &rule->actions, NULL);
+			actions_run(view, &rule->actions, NULL);
 		}
 	}
 }

src/workspaces.c

@@ -62,9 +62,9 @@ parse_workspace_index(const char *name)
 }
 
 static void
-_osd_update(struct server *server)
+_osd_update(void)
 {
-	struct theme *theme = server->theme;
+	struct theme *theme = g_server.theme;
 
 	/* Settings */
 	uint16_t margin = 10;
@@ -75,7 +75,7 @@ _osd_update(struct server *server)
 		theme->osd_workspace_switcher_boxes_height == 0;
 
 	/* Dimensions */
-	size_t workspace_count = wl_list_length(&server->workspaces.all);
+	size_t workspace_count = wl_list_length(&g_server.workspaces.all);
 	uint16_t marker_width = workspace_count * (rect_width + padding) - padding;
 	uint16_t width = margin * 2 + (marker_width < 200 ? 200 : marker_width);
 	uint16_t height = margin * (hide_boxes ? 2 : 3) + rect_height + font_height(&rc.font_osd);
@@ -85,7 +85,7 @@ _osd_update(struct server *server)
 	struct workspace *workspace;
 
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (!output_is_usable(output)) {
 			continue;
 		}
@@ -115,9 +115,9 @@ _osd_update(struct server *server)
 		uint16_t x;
 		if (!hide_boxes) {
 			x = (width - marker_width) / 2;
-			wl_list_for_each(workspace, &server->workspaces.all, link) {
-				bool active =  workspace == server->workspaces.current;
-				set_cairo_color(cairo, server->theme->osd_label_text_color);
+			wl_list_for_each(workspace, &g_server.workspaces.all, link) {
+				bool active =  workspace == g_server.workspaces.current;
+				set_cairo_color(cairo, g_server.theme->osd_label_text_color);
 				struct wlr_fbox fbox = {
 					.x = x,
 					.y = margin,
@@ -136,13 +136,13 @@ _osd_update(struct server *server)
 		}
 
 		/* Text */
-		set_cairo_color(cairo, server->theme->osd_label_text_color);
+		set_cairo_color(cairo, g_server.theme->osd_label_text_color);
 		PangoLayout *layout = pango_cairo_create_layout(cairo);
 		pango_context_set_round_glyph_positions(pango_layout_get_context(layout), false);
 		pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
 
 		/* Center workspace indicator on the x axis */
-		int req_width = font_width(&rc.font_osd, server->workspaces.current->name);
+		int req_width = font_width(&rc.font_osd, g_server.workspaces.current->name);
 		req_width = MIN(req_width, width - 2 * margin);
 		x = (width - req_width) / 2;
 		if (!hide_boxes) {
@@ -155,7 +155,7 @@ _osd_update(struct server *server)
 		pango_layout_set_font_description(layout, desc);
 		pango_layout_set_width(layout, req_width * PANGO_SCALE);
 		pango_font_description_free(desc);
-		pango_layout_set_text(layout, server->workspaces.current->name, -1);
+		pango_layout_set_text(layout, g_server.workspaces.current->name, -1);
 		pango_cairo_show_layout(cairo, layout);
 
 		g_object_unref(layout);
@@ -165,11 +165,11 @@ _osd_update(struct server *server)
 
 		if (!output->workspace_osd) {
 			output->workspace_osd = lab_wlr_scene_buffer_create(
-				&server->scene->tree, NULL);
+				&g_server.scene->tree, NULL);
 		}
 		/* Position the whole thing */
 		struct wlr_box output_box;
-		wlr_output_layout_get_box(output->server->output_layout,
+		wlr_output_layout_get_box(g_server.output_layout,
 			output->wlr_output, &output_box);
 		int lx = output_box.x + (output_box.width - width) / 2;
 		int ly = output_box.y + (output_box.height - height) / 2;
@@ -184,7 +184,7 @@ _osd_update(struct server *server)
 }
 
 static struct workspace *
-workspace_find_by_name(struct server *server, const char *name)
+workspace_find_by_name(const char *name)
 {
 	struct workspace *workspace;
 
@@ -192,7 +192,7 @@ workspace_find_by_name(struct server *server, const char *name)
 	size_t parsed_index = parse_workspace_index(name);
 	if (parsed_index) {
 		size_t index = 0;
-		wl_list_for_each(workspace, &server->workspaces.all, link) {
+		wl_list_for_each(workspace, &g_server.workspaces.all, link) {
 			if (parsed_index == ++index) {
 				return workspace;
 			}
@@ -200,7 +200,7 @@ workspace_find_by_name(struct server *server, const char *name)
 	}
 
 	/* by name */
-	wl_list_for_each(workspace, &server->workspaces.all, link) {
+	wl_list_for_each(workspace, &g_server.workspaces.all, link) {
 		if (!strcmp(workspace->name, name)) {
 			return workspace;
 		}
@@ -230,23 +230,22 @@ handle_ext_workspace_activate(struct wl_listener *listener, void *data)
 
 /* Internal API */
 static void
-add_workspace(struct server *server, const char *name)
+add_workspace(const char *name)
 {
 	struct workspace *workspace = znew(*workspace);
-	workspace->server = server;
 	workspace->name = xstrdup(name);
-	workspace->tree = lab_wlr_scene_tree_create(server->workspace_tree);
+	workspace->tree = lab_wlr_scene_tree_create(g_server.workspace_tree);
 	workspace->view_trees[VIEW_LAYER_ALWAYS_ON_BOTTOM] =
 		lab_wlr_scene_tree_create(workspace->tree);
 	workspace->view_trees[VIEW_LAYER_NORMAL] =
 		lab_wlr_scene_tree_create(workspace->tree);
 	workspace->view_trees[VIEW_LAYER_ALWAYS_ON_TOP] =
 		lab_wlr_scene_tree_create(workspace->tree);
-	wl_list_append(&server->workspaces.all, &workspace->link);
+	wl_list_append(&g_server.workspaces.all, &workspace->link);
 	wlr_scene_node_set_enabled(&workspace->tree->node, false);
 
 	/* cosmic */
-	workspace->cosmic_workspace = lab_cosmic_workspace_create(server->workspaces.cosmic_group);
+	workspace->cosmic_workspace = lab_cosmic_workspace_create(g_server.workspaces.cosmic_group);
 	lab_cosmic_workspace_set_name(workspace->cosmic_workspace, name);
 
 	workspace->on_cosmic.activate.notify = handle_cosmic_workspace_activate;
@@ -255,8 +254,8 @@ add_workspace(struct server *server, const char *name)
 
 	/* ext */
 	workspace->ext_workspace = lab_ext_workspace_create(
-		server->workspaces.ext_manager, /*id*/ NULL);
-	lab_ext_workspace_assign_to_group(workspace->ext_workspace, server->workspaces.ext_group);
+		g_server.workspaces.ext_manager, /*id*/ NULL);
+	lab_ext_workspace_assign_to_group(workspace->ext_workspace, g_server.workspaces.ext_group);
 	lab_ext_workspace_set_name(workspace->ext_workspace, name);
 
 	workspace->on_ext.activate.notify = handle_ext_workspace_activate;
@@ -295,11 +294,11 @@ get_next(struct workspace *current, struct wl_list *workspaces, bool wrap)
 }
 
 static bool
-workspace_has_views(struct workspace *workspace, struct server *server)
+workspace_has_views(struct workspace *workspace)
 {
 	struct view *view;
 
-	for_each_view(view, &server->views, LAB_VIEW_CRITERIA_NO_OMNIPRESENT) {
+	for_each_view(view, &g_server.views, LAB_VIEW_CRITERIA_NO_OMNIPRESENT) {
 		if (view->workspace == workspace) {
 			return true;
 		}
@@ -311,7 +310,6 @@ static struct workspace *
 get_adjacent_occupied(struct workspace *current, struct wl_list *workspaces,
 		bool wrap, bool reverse)
 {
-	struct server *server = current->server;
 	struct wl_list *start = &current->link;
 	struct wl_list *link = reverse ? start->prev : start->next;
 	bool has_wrapped = false;
@@ -340,7 +338,7 @@ get_adjacent_occupied(struct workspace *current, struct wl_list *workspaces,
 		}
 
 		/* Check if it's occupied (and not current) */
-		if (target != current && workspace_has_views(target, server)) {
+		if (target != current && workspace_has_views(target)) {
 			return target;
 		}
 
@@ -373,56 +371,56 @@ _osd_handle_timeout(void *data)
 }
 
 static void
-_osd_show(struct server *server)
+_osd_show(void)
 {
 	if (!rc.workspace_config.popuptime) {
 		return;
 	}
 
-	_osd_update(server);
+	_osd_update();
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (output_is_usable(output) && output->workspace_osd) {
 			wlr_scene_node_set_enabled(&output->workspace_osd->node, true);
 		}
 	}
-	if (keyboard_get_all_modifiers(&server->seat)) {
+	if (keyboard_get_all_modifiers(&g_server.seat)) {
 		/* Hidden by release of all modifiers */
-		server->seat.workspace_osd_shown_by_modifier = true;
+		g_server.seat.workspace_osd_shown_by_modifier = true;
 	} else {
 		/* Hidden by timer */
-		if (!server->seat.workspace_osd_timer) {
-			server->seat.workspace_osd_timer = wl_event_loop_add_timer(
-				server->wl_event_loop, _osd_handle_timeout, &server->seat);
+		if (!g_server.seat.workspace_osd_timer) {
+			g_server.seat.workspace_osd_timer = wl_event_loop_add_timer(
+				g_server.wl_event_loop, _osd_handle_timeout, &g_server.seat);
 		}
-		wl_event_source_timer_update(server->seat.workspace_osd_timer,
+		wl_event_source_timer_update(g_server.seat.workspace_osd_timer,
 			rc.workspace_config.popuptime);
 	}
 }
 
 /* Public API */
 void
-workspaces_init(struct server *server)
+workspaces_init(void)
 {
-	server->workspaces.cosmic_manager = lab_cosmic_workspace_manager_create(
-		server->wl_display, /* capabilities */ CW_CAP_WS_ACTIVATE,
+	g_server.workspaces.cosmic_manager = lab_cosmic_workspace_manager_create(
+		g_server.wl_display, /* capabilities */ CW_CAP_WS_ACTIVATE,
 		COSMIC_WORKSPACES_VERSION);
 
-	server->workspaces.ext_manager = lab_ext_workspace_manager_create(
-		server->wl_display, /* capabilities */ WS_CAP_WS_ACTIVATE,
+	g_server.workspaces.ext_manager = lab_ext_workspace_manager_create(
+		g_server.wl_display, /* capabilities */ WS_CAP_WS_ACTIVATE,
 		EXT_WORKSPACES_VERSION);
 
-	server->workspaces.cosmic_group = lab_cosmic_workspace_group_create(
-		server->workspaces.cosmic_manager);
+	g_server.workspaces.cosmic_group = lab_cosmic_workspace_group_create(
+		g_server.workspaces.cosmic_manager);
 
-	server->workspaces.ext_group = lab_ext_workspace_group_create(
-		server->workspaces.ext_manager);
+	g_server.workspaces.ext_group = lab_ext_workspace_group_create(
+		g_server.workspaces.ext_manager);
 
-	wl_list_init(&server->workspaces.all);
+	wl_list_init(&g_server.workspaces.all);
 
 	struct workspace_config *conf;
 	wl_list_for_each(conf, &rc.workspace_config.workspaces, link) {
-		add_workspace(server, conf->name);
+		add_workspace(conf->name);
 	}
 
 	/*
@@ -432,16 +430,16 @@ workspaces_init(struct server *server)
 	char *initial_name = rc.workspace_config.initial_workspace_name;
 	struct workspace *initial = NULL;
 	struct workspace *first = wl_container_of(
-		server->workspaces.all.next, first, link);
+		g_server.workspaces.all.next, first, link);
 
 	if (initial_name) {
-		initial = workspace_find_by_name(server, initial_name);
+		initial = workspace_find_by_name(initial_name);
 	}
 	if (!initial) {
 		initial = first;
 	}
 
-	server->workspaces.current = initial;
+	g_server.workspaces.current = initial;
 	wlr_scene_node_set_enabled(&initial->tree->node, true);
 	lab_cosmic_workspace_set_active(initial->cosmic_workspace, true);
 	lab_ext_workspace_set_active(initial->ext_workspace, true);
@@ -456,19 +454,18 @@ void
 workspaces_switch_to(struct workspace *target, bool update_focus)
 {
 	assert(target);
-	struct server *server = target->server;
-	if (target == server->workspaces.current) {
+	if (target == g_server.workspaces.current) {
 		return;
 	}
 
 	/* Disable the old workspace */
 	wlr_scene_node_set_enabled(
-		&server->workspaces.current->tree->node, false);
+		&g_server.workspaces.current->tree->node, false);
 
 	lab_cosmic_workspace_set_active(
-		server->workspaces.current->cosmic_workspace, false);
+		g_server.workspaces.current->cosmic_workspace, false);
 	lab_ext_workspace_set_active(
-		server->workspaces.current->ext_workspace, false);
+		g_server.workspaces.current->ext_workspace, false);
 
 	/*
 	 * Move Omnipresent views to new workspace.
@@ -476,7 +473,7 @@ workspaces_switch_to(struct workspace *target, bool update_focus)
 	 * view_is_focusable() returns false (e.g. Conky).
 	 */
 	struct view *view;
-	wl_list_for_each_reverse(view, &server->views, link) {
+	wl_list_for_each_reverse(view, &g_server.views, link) {
 		if (view->visible_on_all_workspaces) {
 			view_move_to_workspace(view, target);
 		}
@@ -486,12 +483,12 @@ workspaces_switch_to(struct workspace *target, bool update_focus)
 	wlr_scene_node_set_enabled(&target->tree->node, true);
 
 	/* Save the last visited workspace */
-	server->workspaces.last = server->workspaces.current;
+	g_server.workspaces.last = g_server.workspaces.current;
 
 	/* Make sure new views will spawn on the new workspace */
-	server->workspaces.current = target;
+	g_server.workspaces.current = target;
 
-	struct view *grabbed_view = server->grabbed_view;
+	struct view *grabbed_view = g_server.grabbed_view;
 	if (grabbed_view) {
 		view_move_to_workspace(grabbed_view, target);
 	}
@@ -501,23 +498,23 @@ workspaces_switch_to(struct workspace *target, bool update_focus)
 	 * the focus is not already on an omnipresent view.
 	 */
 	if (update_focus) {
-		struct view *active_view = server->active_view;
+		struct view *active_view = g_server.active_view;
 		if (!(active_view && active_view->visible_on_all_workspaces)) {
-			desktop_focus_topmost_view(server);
+			desktop_focus_topmost_view();
 		}
 	}
 
 	/* And finally show the OSD */
-	_osd_show(server);
+	_osd_show();
 
 	/*
 	 * Make sure we are not carrying around a
 	 * cursor image from the previous desktop
 	 */
-	cursor_update_focus(server);
+	cursor_update_focus();
 
 	/* Ensure that only currently visible fullscreen windows hide the top layer */
-	desktop_update_top_layer_visibility(server);
+	desktop_update_top_layer_visibility();
 
 	lab_cosmic_workspace_set_active(target->cosmic_workspace, true);
 	lab_ext_workspace_set_active(target->ext_workspace, true);
@@ -528,8 +525,7 @@ workspaces_osd_hide(struct seat *seat)
 {
 	assert(seat);
 	struct output *output;
-	struct server *server = seat->server;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (!output->workspace_osd) {
 			continue;
 		}
@@ -539,7 +535,7 @@ workspaces_osd_hide(struct seat *seat)
 	seat->workspace_osd_shown_by_modifier = false;
 
 	/* Update the cursor focus in case it was on top of the OSD before */
-	cursor_update_focus(server);
+	cursor_update_focus();
 }
 
 struct workspace *
@@ -549,13 +545,12 @@ workspaces_find(struct workspace *anchor, const char *name, bool wrap)
 	if (!name) {
 		return NULL;
 	}
-	struct server *server = anchor->server;
-	struct wl_list *workspaces = &server->workspaces.all;
+	struct wl_list *workspaces = &g_server.workspaces.all;
 
 	if (!strcasecmp(name, "current")) {
 		return anchor;
 	} else if (!strcasecmp(name, "last")) {
-		return server->workspaces.last;
+		return g_server.workspaces.last;
 	} else if (!strcasecmp(name, "left")) {
 		return get_prev(anchor, workspaces, wrap);
 	} else if (!strcasecmp(name, "right")) {
@@ -565,7 +560,7 @@ workspaces_find(struct workspace *anchor, const char *name, bool wrap)
 	} else if (!strcasecmp(name, "right-occupied")) {
 		return get_next_occupied(anchor, workspaces, wrap);
 	}
-	return workspace_find_by_name(server, name);
+	return workspace_find_by_name(name);
 }
 
 static void
@@ -583,7 +578,7 @@ destroy_workspace(struct workspace *workspace)
 }
 
 void
-workspaces_reconfigure(struct server *server)
+workspaces_reconfigure(void)
 {
 	/*
 	 * Compare actual workspace list with the new desired configuration to:
@@ -592,18 +587,18 @@ workspaces_reconfigure(struct server *server)
 	 *   - Destroy workspaces if fewer workspace are desired
 	 */
 
-	struct wl_list *workspace_link = server->workspaces.all.next;
+	struct wl_list *workspace_link = g_server.workspaces.all.next;
 
 	struct workspace_config *conf;
 	wl_list_for_each(conf, &rc.workspace_config.workspaces, link) {
 		struct workspace *workspace = wl_container_of(
 			workspace_link, workspace, link);
 
-		if (workspace_link == &server->workspaces.all) {
+		if (workspace_link == &g_server.workspaces.all) {
 			/* # of configured workspaces increased */
 			wlr_log(WLR_DEBUG, "Adding workspace \"%s\"",
 				conf->name);
-			add_workspace(server, conf->name);
+			add_workspace(conf->name);
 			continue;
 		}
 		if (strcmp(workspace->name, conf->name)) {
@@ -619,16 +614,16 @@ workspaces_reconfigure(struct server *server)
 		workspace_link = workspace_link->next;
 	}
 
-	if (workspace_link == &server->workspaces.all) {
+	if (workspace_link == &g_server.workspaces.all) {
 		return;
 	}
 
 	/* # of configured workspaces decreased */
-	overlay_finish(&server->seat);
+	overlay_finish(&g_server.seat);
 	struct workspace *first_workspace =
-		wl_container_of(server->workspaces.all.next, first_workspace, link);
+		wl_container_of(g_server.workspaces.all.next, first_workspace, link);
 
-	while (workspace_link != &server->workspaces.all) {
+	while (workspace_link != &g_server.workspaces.all) {
 		struct workspace *workspace = wl_container_of(
 			workspace_link, workspace, link);
 
@@ -636,18 +631,18 @@ workspaces_reconfigure(struct server *server)
 			workspace->name);
 
 		struct view *view;
-		wl_list_for_each(view, &server->views, link) {
+		wl_list_for_each(view, &g_server.views, link) {
 			if (view->workspace == workspace) {
 				view_move_to_workspace(view, first_workspace);
 			}
 		}
 
-		if (server->workspaces.current == workspace) {
+		if (g_server.workspaces.current == workspace) {
 			workspaces_switch_to(first_workspace,
 				/* update_focus */ true);
 		}
-		if (server->workspaces.last == workspace) {
-			server->workspaces.last = first_workspace;
+		if (g_server.workspaces.last == workspace) {
+			g_server.workspaces.last = first_workspace;
 		}
 
 		workspace_link = workspace_link->next;
@@ -656,11 +651,11 @@ workspaces_reconfigure(struct server *server)
 }
 
 void
-workspaces_destroy(struct server *server)
+workspaces_destroy(void)
 {
 	struct workspace *workspace, *tmp;
-	wl_list_for_each_safe(workspace, tmp, &server->workspaces.all, link) {
+	wl_list_for_each_safe(workspace, tmp, &g_server.workspaces.all, link) {
 		destroy_workspace(workspace);
 	}
-	assert(wl_list_empty(&server->workspaces.all));
+	assert(wl_list_empty(&g_server.workspaces.all));
 }

src/xdg-popup.c

@@ -30,7 +30,6 @@ static void
 popup_unconstrain(struct xdg_popup *popup)
 {
 	struct view *view = popup->parent_view;
-	struct server *server = view->server;
 
 	/* Get position of parent toplevel/popup */
 	int parent_lx, parent_ly;
@@ -46,8 +45,7 @@ popup_unconstrain(struct xdg_popup *popup)
 	 * output.
 	 */
 	struct wlr_box *popup_box = &popup->wlr_popup->scheduled.geometry;
-	struct output *output = output_nearest_to(server,
-		parent_lx + MAX(popup_box->x, 0),
+	struct output *output = output_nearest_to(parent_lx + MAX(popup_box->x, 0),
 		parent_ly + MAX(popup_box->y, 0));
 	struct wlr_box usable = output_usable_area_in_layout_coords(output);
 
@@ -91,7 +89,7 @@ handle_destroy(struct wl_listener *listener, void *data)
 		wl_list_remove(&popup->commit.link);
 	}
 
-	cursor_update_focus(popup->parent_view->server);
+	cursor_update_focus();
 
 	free(popup);
 }
@@ -151,15 +149,15 @@ xdg_popup_create(struct view *view, struct wlr_xdg_popup *wlr_popup)
 	 * this, we always set the user data field of wlr_surfaces to the
 	 * corresponding scene node.
 	 *
-	 * xdg-popups live in server->xdg_popup_tree so that they can be
+	 * xdg-popups live in g_server.xdg_popup_tree so that they can be
 	 * rendered above always-on-top windows
 	 */
 	struct wlr_scene_tree *parent_tree = NULL;
 	if (parent->role == WLR_XDG_SURFACE_ROLE_POPUP) {
 		parent_tree = parent->surface->data;
 	} else {
-		parent_tree = view->server->xdg_popup_tree;
-		wlr_scene_node_set_position(&view->server->xdg_popup_tree->node,
+		parent_tree = g_server.xdg_popup_tree;
+		wlr_scene_node_set_position(&g_server.xdg_popup_tree->node,
 			view->current.x, view->current.y);
 	}
 	wlr_popup->base->surface->data =

src/xdg.c

@@ -116,8 +116,7 @@ set_fullscreen_from_request(struct view *view,
 {
 	if (!view->fullscreen && requested->fullscreen
 			&& requested->fullscreen_output) {
-		view_set_output(view, output_from_wlr_output(view->server,
-			requested->fullscreen_output));
+		view_set_output(view, output_from_wlr_output(requested->fullscreen_output));
 	}
 	view_set_fullscreen(view, requested->fullscreen);
 }
@@ -132,11 +131,10 @@ set_initial_position(struct view *view)
 
 	view_constrain_size_to_that_of_usable_area(view);
 
-	struct server *server = view->server;
-	if (server->input_mode == LAB_INPUT_STATE_MOVE
-			&& view == server->grabbed_view) {
+	if (g_server.input_mode == LAB_INPUT_STATE_MOVE
+			&& view == g_server.grabbed_view) {
 		/* Reposition the view while anchoring it to cursor */
-		interactive_anchor_to_cursor(server, &view->pending);
+		interactive_anchor_to_cursor(&view->pending);
 	} else {
 		struct view *parent = xdg_toplevel_view_get_parent(view);
 		if (parent) {
@@ -175,7 +173,7 @@ center_fullscreen_if_needed(struct view *view)
 	}
 
 	struct wlr_box output_box = {0};
-	wlr_output_layout_get_box(view->server->output_layout,
+	wlr_output_layout_get_box(g_server.output_layout,
 		view->output->wlr_output, &output_box);
 	box_center(view->current.width, view->current.height, &output_box,
 		&output_box, &view->current.x, &view->current.y);
@@ -234,7 +232,7 @@ handle_commit(struct wl_listener *listener, void *data)
 		if (parent && output_is_usable(parent->output)) {
 			view_set_output(view, parent->output);
 		} else {
-			view_set_output(view, output_nearest_to_cursor(view->server));
+			view_set_output(view, output_nearest_to_cursor());
 		}
 
 		if (output_is_usable(view->output)) {
@@ -439,7 +437,7 @@ set_pending_configure_serial(struct view *view, uint32_t serial)
 	view->pending_configure_serial = serial;
 	if (!view->pending_configure_timeout) {
 		view->pending_configure_timeout =
-			wl_event_loop_add_timer(view->server->wl_event_loop,
+			wl_event_loop_add_timer(g_server.wl_event_loop,
 				handle_configure_timeout, view);
 	}
 	wl_event_source_timer_update(view->pending_configure_timeout,
@@ -487,7 +485,7 @@ handle_request_move(struct wl_listener *listener, void *data)
 	 * this client, to prevent the client from requesting this whenever they
 	 * want.
 	 *
-	 * Note: interactive_begin() checks that view == server->grabbed_view.
+	 * Note: interactive_begin() checks that view == g_server.grabbed_view.
 	 */
 	struct view *view = wl_container_of(listener, view, request_move);
 	interactive_begin(view, LAB_INPUT_STATE_MOVE, LAB_EDGE_NONE);
@@ -504,7 +502,7 @@ handle_request_resize(struct wl_listener *listener, void *data)
 	 * this client, to prevent the client from requesting this whenever they
 	 * want.
 	 *
-	 * Note: interactive_begin() checks that view == server->grabbed_view.
+	 * Note: interactive_begin() checks that view == g_server.grabbed_view.
 	 */
 	struct wlr_xdg_toplevel_resize_event *event = data;
 	struct view *view = wl_container_of(listener, view, request_resize);
@@ -559,13 +557,12 @@ handle_request_show_window_menu(struct wl_listener *listener, void *data)
 {
 	struct xdg_toplevel_view *xdg_toplevel_view = wl_container_of(
 		listener, xdg_toplevel_view, request_show_window_menu);
-	struct server *server = xdg_toplevel_view->base.server;
 
-	struct menu *menu = menu_get_by_id(server, "client-menu");
+	struct menu *menu = menu_get_by_id("client-menu");
 	assert(menu);
 	menu->triggered_by_view = &xdg_toplevel_view->base;
 
-	struct wlr_cursor *cursor = server->seat.cursor;
+	struct wlr_cursor *cursor = g_server.seat.cursor;
 	menu_open_root(menu, cursor->x, cursor->y);
 }
 
@@ -686,7 +683,7 @@ xdg_toplevel_view_append_children(struct view *self, struct wl_array *children)
 	struct wlr_xdg_toplevel *toplevel = xdg_toplevel_from_view(self);
 	struct view *view;
 
-	wl_list_for_each_reverse(view, &self->server->views, link) {
+	wl_list_for_each_reverse(view, &g_server.views, link) {
 		if (view == self) {
 			continue;
 		}
@@ -953,8 +950,6 @@ handle_xdg_activation_request(struct wl_listener *listener, void *data)
 static void
 handle_new_xdg_toplevel(struct wl_listener *listener, void *data)
 {
-	struct server *server =
-		wl_container_of(listener, server, new_xdg_toplevel);
 	struct wlr_xdg_toplevel *xdg_toplevel = data;
 	struct wlr_xdg_surface *xdg_surface = xdg_toplevel->base;
 
@@ -963,7 +958,6 @@ handle_new_xdg_toplevel(struct wl_listener *listener, void *data)
 	struct xdg_toplevel_view *xdg_toplevel_view = znew(*xdg_toplevel_view);
 	struct view *view = &xdg_toplevel_view->base;
 
-	view->server = server;
 	view->type = LAB_XDG_SHELL_VIEW;
 	view->impl = &xdg_toplevel_view_impl;
 	view_init(view);
@@ -978,13 +972,13 @@ handle_new_xdg_toplevel(struct wl_listener *listener, void *data)
 	 * FIXME: this may be the wrong output since the parent view isn't
 	 * known yet. The correct output will be set at initial commit.
 	 */
-	view_set_output(view, output_nearest_to_cursor(server));
+	view_set_output(view, output_nearest_to_cursor());
 	if (output_is_usable(view->output)) {
 		wlr_fractional_scale_v1_notify_scale(xdg_surface->surface,
 			view->output->wlr_output->scale);
 	}
 
-	view->workspace = server->workspaces.current;
+	view->workspace = g_server.workspaces.current;
 	view->scene_tree = lab_wlr_scene_tree_create(
 		view->workspace->view_trees[VIEW_LAYER_NORMAL]);
 	wlr_scene_node_set_enabled(&view->scene_tree->node, false);
@@ -1045,8 +1039,8 @@ handle_new_xdg_toplevel(struct wl_listener *listener, void *data)
 	CONNECT_SIGNAL(toplevel, xdg_toplevel_view, request_show_window_menu);
 	CONNECT_SIGNAL(xdg_surface, xdg_toplevel_view, new_popup);
 
-	wl_list_insert(&server->views, &view->link);
-	view->creation_id = server->next_view_creation_id++;
+	wl_list_insert(&g_server.views, &view->link);
+	view->creation_id = g_server.next_view_creation_id++;
 }
 
 static void
@@ -1080,46 +1074,46 @@ handle_xdg_toplevel_icon_set_icon(struct wl_listener *listener, void *data)
 }
 
 void
-xdg_shell_init(struct server *server)
+xdg_shell_init(void)
 {
-	server->xdg_shell = wlr_xdg_shell_create(server->wl_display,
+	g_server.xdg_shell = wlr_xdg_shell_create(g_server.wl_display,
 		LAB_XDG_SHELL_VERSION);
-	if (!server->xdg_shell) {
+	if (!g_server.xdg_shell) {
 		wlr_log(WLR_ERROR, "unable to create the XDG shell interface");
 		exit(EXIT_FAILURE);
 	}
 
-	server->new_xdg_toplevel.notify = handle_new_xdg_toplevel;
-	wl_signal_add(&server->xdg_shell->events.new_toplevel, &server->new_xdg_toplevel);
+	g_server.new_xdg_toplevel.notify = handle_new_xdg_toplevel;
+	wl_signal_add(&g_server.xdg_shell->events.new_toplevel, &g_server.new_xdg_toplevel);
 
-	server->xdg_activation = wlr_xdg_activation_v1_create(server->wl_display);
-	if (!server->xdg_activation) {
+	g_server.xdg_activation = wlr_xdg_activation_v1_create(g_server.wl_display);
+	if (!g_server.xdg_activation) {
 		wlr_log(WLR_ERROR, "unable to create xdg_activation interface");
 		exit(EXIT_FAILURE);
 	}
 
-	server->xdg_activation_request.notify = handle_xdg_activation_request;
-	wl_signal_add(&server->xdg_activation->events.request_activate,
-		&server->xdg_activation_request);
+	g_server.xdg_activation_request.notify = handle_xdg_activation_request;
+	wl_signal_add(&g_server.xdg_activation->events.request_activate,
+		&g_server.xdg_activation_request);
 
-	server->xdg_activation_new_token.notify = handle_xdg_activation_new_token;
-	wl_signal_add(&server->xdg_activation->events.new_token,
-		&server->xdg_activation_new_token);
+	g_server.xdg_activation_new_token.notify = handle_xdg_activation_new_token;
+	wl_signal_add(&g_server.xdg_activation->events.new_token,
+		&g_server.xdg_activation_new_token);
 
-	server->xdg_toplevel_icon_manager = wlr_xdg_toplevel_icon_manager_v1_create(
-		server->wl_display, 1);
-	server->xdg_toplevel_icon_set_icon.notify = handle_xdg_toplevel_icon_set_icon;
-	wl_signal_add(&server->xdg_toplevel_icon_manager->events.set_icon,
-		&server->xdg_toplevel_icon_set_icon);
+	g_server.xdg_toplevel_icon_manager = wlr_xdg_toplevel_icon_manager_v1_create(
+		g_server.wl_display, 1);
+	g_server.xdg_toplevel_icon_set_icon.notify = handle_xdg_toplevel_icon_set_icon;
+	wl_signal_add(&g_server.xdg_toplevel_icon_manager->events.set_icon,
+		&g_server.xdg_toplevel_icon_set_icon);
 
-	wlr_xdg_wm_dialog_v1_create(server->wl_display, 1);
+	wlr_xdg_wm_dialog_v1_create(g_server.wl_display, 1);
 }
 
 void
-xdg_shell_finish(struct server *server)
+xdg_shell_finish(void)
 {
-	wl_list_remove(&server->new_xdg_toplevel.link);
-	wl_list_remove(&server->xdg_activation_request.link);
-	wl_list_remove(&server->xdg_activation_new_token.link);
-	wl_list_remove(&server->xdg_toplevel_icon_set_icon.link);
+	wl_list_remove(&g_server.new_xdg_toplevel.link);
+	wl_list_remove(&g_server.xdg_activation_request.link);
+	wl_list_remove(&g_server.xdg_activation_new_token.link);
+	wl_list_remove(&g_server.xdg_toplevel_icon_set_icon.link);
 }

src/xwayland-unmanaged.c

@@ -19,7 +19,7 @@ handle_grab_focus(struct wl_listener *listener, void *data)
 	unmanaged->ever_grabbed_focus = true;
 	if (unmanaged->node) {
 		assert(unmanaged->xwayland_surface->surface);
-		seat_focus_surface(&unmanaged->server->seat,
+		seat_focus_surface(&g_server.seat,
 			unmanaged->xwayland_surface->surface);
 	}
 }
@@ -34,7 +34,7 @@ handle_request_configure(struct wl_listener *listener, void *data)
 	wlr_xwayland_surface_configure(xsurface, ev->x, ev->y, ev->width, ev->height);
 	if (unmanaged->node) {
 		wlr_scene_node_set_position(unmanaged->node, ev->x, ev->y);
-		cursor_update_focus(unmanaged->server);
+		cursor_update_focus();
 	}
 }
 
@@ -46,7 +46,7 @@ handle_set_geometry(struct wl_listener *listener, void *data)
 	struct wlr_xwayland_surface *xsurface = unmanaged->xwayland_surface;
 	if (unmanaged->node) {
 		wlr_scene_node_set_position(unmanaged->node, xsurface->x, xsurface->y);
-		cursor_update_focus(unmanaged->server);
+		cursor_update_focus();
 	}
 }
 
@@ -59,35 +59,35 @@ handle_map(struct wl_listener *listener, void *data)
 	assert(!unmanaged->node);
 
 	/* Stack new surface on top */
-	wl_list_append(&unmanaged->server->unmanaged_surfaces, &unmanaged->link);
+	wl_list_append(&g_server.unmanaged_surfaces, &unmanaged->link);
 
 	CONNECT_SIGNAL(xsurface, unmanaged, set_geometry);
 
 	if (wlr_xwayland_surface_override_redirect_wants_focus(xsurface)
 			|| unmanaged->ever_grabbed_focus) {
-		seat_focus_surface(&unmanaged->server->seat, xsurface->surface);
+		seat_focus_surface(&g_server.seat, xsurface->surface);
 	}
 
 	struct wlr_scene_surface *scene_surface = wlr_scene_surface_create(
-		unmanaged->server->unmanaged_tree, xsurface->surface);
+		g_server.unmanaged_tree, xsurface->surface);
 	die_if_null(scene_surface);
 	unmanaged->node = &scene_surface->buffer->node;
 
 	wlr_scene_node_set_position(unmanaged->node, xsurface->x, xsurface->y);
-	cursor_update_focus(unmanaged->server);
+	cursor_update_focus();
 }
 
 static void
-focus_next_surface(struct server *server, struct wlr_xwayland_surface *xsurface)
+focus_next_surface(struct wlr_xwayland_surface *xsurface)
 {
 	/* Try to focus on last created unmanaged xwayland surface */
 	struct xwayland_unmanaged *u;
-	struct wl_list *list = &server->unmanaged_surfaces;
+	struct wl_list *list = &g_server.unmanaged_surfaces;
 	wl_list_for_each_reverse(u, list, link) {
 		struct wlr_xwayland_surface *prev = u->xwayland_surface;
 		if (wlr_xwayland_surface_override_redirect_wants_focus(prev)
 				|| u->ever_grabbed_focus) {
-			seat_focus_surface(&server->seat, prev->surface);
+			seat_focus_surface(&g_server.seat, prev->surface);
 			return;
 		}
 	}
@@ -113,8 +113,8 @@ focus_next_surface(struct server *server, struct wlr_xwayland_surface *xsurface)
 	 * If modifying this logic, please test for regressions with
 	 * menus/tooltips in JetBrains CLion or similar.
 	 */
-	if (server->active_view) {
-		seat_focus_surface(&server->seat, server->active_view->surface);
+	if (g_server.active_view) {
+		seat_focus_surface(&g_server.seat, g_server.active_view->surface);
 	}
 }
 
@@ -124,7 +124,7 @@ handle_unmap(struct wl_listener *listener, void *data)
 	struct xwayland_unmanaged *unmanaged =
 		wl_container_of(listener, unmanaged, mappable.unmap);
 	struct wlr_xwayland_surface *xsurface = unmanaged->xwayland_surface;
-	struct seat *seat = &unmanaged->server->seat;
+	struct seat *seat = &g_server.seat;
 	assert(unmanaged->node);
 
 	wl_list_remove(&unmanaged->link);
@@ -138,10 +138,10 @@ handle_unmap(struct wl_listener *listener, void *data)
 	wlr_scene_node_destroy(unmanaged->node);
 	unmanaged->node = NULL;
 
-	cursor_update_focus(unmanaged->server);
+	cursor_update_focus();
 
 	if (seat->seat->keyboard_state.focused_surface == xsurface->surface) {
-		focus_next_surface(unmanaged->server, xsurface);
+		focus_next_surface(xsurface);
 	}
 }
 
@@ -194,7 +194,6 @@ handle_set_override_redirect(struct wl_listener *listener, void *data)
 	struct xwayland_unmanaged *unmanaged =
 		wl_container_of(listener, unmanaged, set_override_redirect);
 	struct wlr_xwayland_surface *xsurface = unmanaged->xwayland_surface;
-	struct server *server = unmanaged->server;
 
 	bool mapped = xsurface->surface && xsurface->surface->mapped;
 	if (mapped) {
@@ -202,7 +201,7 @@ handle_set_override_redirect(struct wl_listener *listener, void *data)
 	}
 	handle_destroy(&unmanaged->destroy, NULL);
 
-	xwayland_view_create(server, xsurface, mapped);
+	xwayland_view_create(xsurface, mapped);
 }
 
 static void
@@ -215,8 +214,7 @@ handle_request_activate(struct wl_listener *listener, void *data)
 	if (!xsurface->surface || !xsurface->surface->mapped) {
 		return;
 	}
-	struct server *server = unmanaged->server;
-	struct seat *seat = &server->seat;
+	struct seat *seat = &g_server.seat;
 
 	/*
 	 * Validate that the unmanaged surface trying to grab focus is actually
@@ -225,7 +223,7 @@ handle_request_activate(struct wl_listener *listener, void *data)
 	 * FIXME: this logic is a bit incomplete/inconsistent. Refer to
 	 * https://github.com/labwc/labwc/discussions/2821 for more info.
 	 */
-	struct view *view = server->active_view;
+	struct view *view = g_server.active_view;
 	if (view && view->type == LAB_XWAYLAND_VIEW) {
 		struct wlr_xwayland_surface *surf =
 			wlr_xwayland_surface_try_from_wlr_surface(view->surface);
@@ -238,11 +236,9 @@ handle_request_activate(struct wl_listener *listener, void *data)
 }
 
 void
-xwayland_unmanaged_create(struct server *server,
-		struct wlr_xwayland_surface *xsurface, bool mapped)
+xwayland_unmanaged_create(struct wlr_xwayland_surface *xsurface, bool mapped)
 {
 	struct xwayland_unmanaged *unmanaged = znew(*unmanaged);
-	unmanaged->server = server;
 	unmanaged->xwayland_surface = xsurface;
 	/*
 	 * xsurface->data is presumed to be a (struct view *) if set,

src/xwayland.c

@@ -234,7 +234,7 @@ ensure_initial_geometry_and_output(struct view *view)
 		 * Just use the cursor output since we don't know yet
 		 * whether the surface position is meaningful.
 		 */
-		view_set_output(view, output_nearest_to_cursor(view->server));
+		view_set_output(view, output_nearest_to_cursor());
 	}
 }
 
@@ -290,7 +290,7 @@ handle_request_move(struct wl_listener *listener, void *data)
 	 * this client, to prevent the client from requesting this whenever they
 	 * want.
 	 *
-	 * Note: interactive_begin() checks that view == server->grabbed_view.
+	 * Note: interactive_begin() checks that view == g_server.grabbed_view.
 	 */
 	struct view *view = wl_container_of(listener, view, request_move);
 	interactive_begin(view, LAB_INPUT_STATE_MOVE, LAB_EDGE_NONE);
@@ -307,7 +307,7 @@ handle_request_resize(struct wl_listener *listener, void *data)
 	 * this client, to prevent the client from requesting this whenever they
 	 * want.
 	 *
-	 * Note: interactive_begin() checks that view == server->grabbed_view.
+	 * Note: interactive_begin() checks that view == g_server.grabbed_view.
 	 */
 	struct wlr_xwayland_resize_event *event = data;
 	struct view *view = wl_container_of(listener, view, request_resize);
@@ -388,7 +388,7 @@ xwayland_view_configure(struct view *view, struct wlr_box geo)
 	 * workaround, move offscreen surfaces immediately.
 	 */
 	bool is_offscreen = !wlr_box_empty(&view->current) &&
-		!wlr_output_layout_intersects(view->server->output_layout, NULL,
+		!wlr_output_layout_intersects(g_server.output_layout, NULL,
 			&view->current);
 
 	/* If not resizing, process the move immediately */
@@ -575,14 +575,13 @@ handle_set_override_redirect(struct wl_listener *listener, void *data)
 	struct view *view = &xwayland_view->base;
 	struct wlr_xwayland_surface *xsurface = xwayland_view->xwayland_surface;
 
-	struct server *server = view->server;
 	bool mapped = xsurface->surface && xsurface->surface->mapped;
 	if (mapped) {
 		handle_unmap(&view->mappable.unmap, NULL);
 	}
 	handle_destroy(&view->destroy, xsurface);
 	/* view is invalid after this point */
-	xwayland_unmanaged_create(server, xsurface, mapped);
+	xwayland_unmanaged_create(xsurface, mapped);
 }
 
 static void
@@ -593,7 +592,7 @@ handle_set_strut_partial(struct wl_listener *listener, void *data)
 	struct view *view = &xwayland_view->base;
 
 	if (view->mapped) {
-		output_update_all_usable_areas(view->server, false);
+		output_update_all_usable_areas(false);
 	}
 }
 
@@ -659,7 +658,7 @@ handle_focus_in(struct wl_listener *listener, void *data)
 	struct xwayland_view *xwayland_view =
 		wl_container_of(listener, xwayland_view, focus_in);
 	struct view *view = &xwayland_view->base;
-	struct seat *seat = &view->server->seat;
+	struct seat *seat = &g_server.seat;
 
 	if (!view->surface) {
 		/*
@@ -879,7 +878,7 @@ handle_map(struct wl_listener *listener, void *data)
 	 */
 	if (xwayland_view->focused_before_map) {
 		xwayland_view->focused_before_map = false;
-		seat_focus_surface(&view->server->seat, view->surface);
+		seat_focus_surface(&g_server.seat, view->surface);
 	}
 
 	view_impl_map(view);
@@ -942,7 +941,7 @@ xwayland_view_append_children(struct view *self, struct wl_array *children)
 	struct wlr_xwayland_surface *surface = xwayland_surface_from_view(self);
 	struct view *view;
 
-	wl_list_for_each_reverse(view, &self->server->views, link) {
+	wl_list_for_each_reverse(view, &g_server.views, link) {
 		if (view == self) {
 			continue;
 		}
@@ -991,7 +990,7 @@ xwayland_view_set_activated(struct view *view, bool activated)
 	 * activated window, if it receives mouse/pointer events over the
 	 * parallel wayland connection first.
 	 */
-	xwayland_flush(view->server);
+	xwayland_flush();
 }
 
 static void
@@ -1043,13 +1042,11 @@ handle_always_on_top(struct wl_listener *listener, void *data)
 }
 
 void
-xwayland_view_create(struct server *server,
-		struct wlr_xwayland_surface *xsurface, bool mapped)
+xwayland_view_create(struct wlr_xwayland_surface *xsurface, bool mapped)
 {
 	struct xwayland_view *xwayland_view = znew(*xwayland_view);
 	struct view *view = &xwayland_view->base;
 
-	view->server = server;
 	view->type = LAB_XWAYLAND_VIEW;
 	view->impl = &xwayland_view_impl;
 	view_init(view);
@@ -1064,7 +1061,7 @@ xwayland_view_create(struct server *server,
 	xwayland_view->xwayland_surface = xsurface;
 	xsurface->data = view;
 
-	view->workspace = server->workspaces.current;
+	view->workspace = g_server.workspaces.current;
 	view->scene_tree = lab_wlr_scene_tree_create(
 		view->workspace->view_trees[VIEW_LAYER_NORMAL]);
 	node_descriptor_create(&view->scene_tree->node,
@@ -1096,8 +1093,8 @@ xwayland_view_create(struct server *server,
 	/* Events from the view itself */
 	CONNECT_SIGNAL(view, &xwayland_view->on_view, always_on_top);
 
-	wl_list_insert(&view->server->views, &view->link);
-	view->creation_id = view->server->next_view_creation_id++;
+	wl_list_insert(&g_server.views, &view->link);
+	view->creation_id = g_server.next_view_creation_id++;
 
 	if (xsurface->surface) {
 		handle_associate(&xwayland_view->associate, NULL);
@@ -1120,8 +1117,6 @@ xwayland_view_create(struct server *server,
 static void
 handle_new_surface(struct wl_listener *listener, void *data)
 {
-	struct server *server =
-		wl_container_of(listener, server, xwayland_new_surface);
 	struct wlr_xwayland_surface *xsurface = data;
 
 	/*
@@ -1129,17 +1124,17 @@ handle_new_surface(struct wl_listener *listener, void *data)
 	 * but add them to server.unmanaged_surfaces so that we can render them
 	 */
 	if (xsurface->override_redirect) {
-		xwayland_unmanaged_create(server, xsurface, /* mapped */ false);
+		xwayland_unmanaged_create(xsurface, /* mapped */ false);
 	} else {
-		xwayland_view_create(server, xsurface, /* mapped */ false);
+		xwayland_view_create(xsurface, /* mapped */ false);
 	}
 }
 
 static struct xwayland_view *
-xwayland_view_from_window_id(struct server *server, xcb_window_t id)
+xwayland_view_from_window_id(xcb_window_t id)
 {
 	struct view *view;
-	wl_list_for_each(view, &server->views, link) {
+	wl_list_for_each(view, &g_server.views, link) {
 		if (view->type != LAB_XWAYLAND_VIEW) {
 			continue;
 		}
@@ -1160,9 +1155,8 @@ handle_x11_event(struct wlr_xwayland *wlr_xwayland, xcb_generic_event_t *event)
 	case XCB_PROPERTY_NOTIFY: {
 		xcb_property_notify_event_t *ev = (void *)event;
 		if (ev->atom == atoms[ATOM_NET_WM_ICON]) {
-			struct server *server = wlr_xwayland->data;
 			struct xwayland_view *xwayland_view =
-				xwayland_view_from_window_id(server, ev->window);
+				xwayland_view_from_window_id(ev->window);
 			if (xwayland_view) {
 				update_icon(xwayland_view);
 			} else {
@@ -1180,10 +1174,10 @@ handle_x11_event(struct wlr_xwayland *wlr_xwayland, xcb_generic_event_t *event)
 }
 
 static void
-sync_atoms(struct server *server)
+sync_atoms(void)
 {
 	xcb_connection_t *xcb_conn =
-		wlr_xwayland_get_xwm_connection(server->xwayland);
+		wlr_xwayland_get_xwm_connection(g_server.xwayland);
 	assert(xcb_conn);
 
 	wlr_log(WLR_DEBUG, "Syncing X11 atoms");
@@ -1220,58 +1214,53 @@ handle_server_ready(struct wl_listener *listener, void *data)
 	/* Fire an Xwayland startup script if one (or many) can be found */
 	session_run_script("xinitrc");
 
-	struct server *server =
-		wl_container_of(listener, server, xwayland_server_ready);
-	sync_atoms(server);
+	sync_atoms();
 }
 
 static void
 handle_xwm_ready(struct wl_listener *listener, void *data)
 {
-	struct server *server =
-		wl_container_of(listener, server, xwayland_xwm_ready);
-	wlr_xwayland_set_seat(server->xwayland, server->seat.seat);
-	xwayland_update_workarea(server);
+	wlr_xwayland_set_seat(g_server.xwayland, g_server.seat.seat);
+	xwayland_update_workarea();
 }
 
 void
-xwayland_server_init(struct server *server, struct wlr_compositor *compositor)
+xwayland_server_init(struct wlr_compositor *compositor)
 {
-	server->xwayland =
-		wlr_xwayland_create(server->wl_display,
+	g_server.xwayland =
+		wlr_xwayland_create(g_server.wl_display,
 			compositor, /* lazy */ !rc.xwayland_persistence);
-	if (!server->xwayland) {
+	if (!g_server.xwayland) {
 		wlr_log(WLR_ERROR, "cannot create xwayland server");
 		exit(EXIT_FAILURE);
 	}
-	server->xwayland_new_surface.notify = handle_new_surface;
-	wl_signal_add(&server->xwayland->events.new_surface,
-		&server->xwayland_new_surface);
+	g_server.xwayland_new_surface.notify = handle_new_surface;
+	wl_signal_add(&g_server.xwayland->events.new_surface,
+		&g_server.xwayland_new_surface);
 
-	server->xwayland_server_ready.notify = handle_server_ready;
-	wl_signal_add(&server->xwayland->server->events.ready,
-		&server->xwayland_server_ready);
+	g_server.xwayland_server_ready.notify = handle_server_ready;
+	wl_signal_add(&g_server.xwayland->server->events.ready,
+		&g_server.xwayland_server_ready);
 
-	server->xwayland_xwm_ready.notify = handle_xwm_ready;
-	wl_signal_add(&server->xwayland->events.ready,
-		&server->xwayland_xwm_ready);
+	g_server.xwayland_xwm_ready.notify = handle_xwm_ready;
+	wl_signal_add(&g_server.xwayland->events.ready,
+		&g_server.xwayland_xwm_ready);
 
-	server->xwayland->data = server;
-	server->xwayland->user_event_handler = handle_x11_event;
+	g_server.xwayland->user_event_handler = handle_x11_event;
 
-	if (setenv("DISPLAY", server->xwayland->display_name, true) < 0) {
+	if (setenv("DISPLAY", g_server.xwayland->display_name, true) < 0) {
 		wlr_log_errno(WLR_ERROR, "unable to set DISPLAY for xwayland");
 	} else {
 		wlr_log(WLR_DEBUG, "xwayland is running on display %s",
-			server->xwayland->display_name);
+			g_server.xwayland->display_name);
 	}
 
 	struct wlr_xcursor *xcursor;
 	xcursor = wlr_xcursor_manager_get_xcursor(
-		server->seat.xcursor_manager, XCURSOR_DEFAULT, 1);
+		g_server.seat.xcursor_manager, XCURSOR_DEFAULT, 1);
 	if (xcursor) {
 		struct wlr_xcursor_image *image = xcursor->images[0];
-		wlr_xwayland_set_cursor(server->xwayland, image->buffer,
+		wlr_xwayland_set_cursor(g_server.xwayland, image->buffer,
 			image->width * 4, image->width,
 			image->height, image->hotspot_x,
 			image->hotspot_y);
@@ -1279,7 +1268,7 @@ xwayland_server_init(struct server *server, struct wlr_compositor *compositor)
 }
 
 void
-xwayland_reset_cursor(struct server *server)
+xwayland_reset_cursor(void)
 {
 	/*
 	 * As xwayland caches the pixel data when not yet started up
@@ -1299,24 +1288,24 @@ xwayland_reset_cursor(struct server *server)
 	 * - Start some X11 client
 	 */
 
-	if (!server->xwayland) {
+	if (!g_server.xwayland) {
 		return;
 	}
 
 	struct wlr_xcursor *xcursor = wlr_xcursor_manager_get_xcursor(
-		server->seat.xcursor_manager, XCURSOR_DEFAULT, 1);
+		g_server.seat.xcursor_manager, XCURSOR_DEFAULT, 1);
 
-	if (xcursor && !server->xwayland->xwm) {
+	if (xcursor && !g_server.xwayland->xwm) {
 		/* Prevents setting the cursor on an active xwayland server */
 		struct wlr_xcursor_image *image = xcursor->images[0];
-		wlr_xwayland_set_cursor(server->xwayland, image->buffer,
+		wlr_xwayland_set_cursor(g_server.xwayland, image->buffer,
 			image->width * 4, image->width,
 			image->height, image->hotspot_x,
 			image->hotspot_y);
 		return;
 	}
 
-	if (server->xwayland->cursor) {
+	if (g_server.xwayland->cursor) {
 		/*
 		 * The previous configured theme has set the
 		 * default cursor or the xwayland server is
@@ -1324,23 +1313,23 @@ xwayland_reset_cursor(struct server *server)
 		 * xcursor set that will be used on the next
 		 * xwayland destroy -> lazy startup cycle.
 		 */
-		zfree(server->xwayland->cursor);
+		zfree(g_server.xwayland->cursor);
 	}
 }
 
 void
-xwayland_server_finish(struct server *server)
+xwayland_server_finish(void)
 {
-	struct wlr_xwayland *xwayland = server->xwayland;
-	wl_list_remove(&server->xwayland_new_surface.link);
-	wl_list_remove(&server->xwayland_server_ready.link);
-	wl_list_remove(&server->xwayland_xwm_ready.link);
+	struct wlr_xwayland *xwayland = g_server.xwayland;
+	wl_list_remove(&g_server.xwayland_new_surface.link);
+	wl_list_remove(&g_server.xwayland_server_ready.link);
+	wl_list_remove(&g_server.xwayland_xwm_ready.link);
 
 	/*
-	 * Reset server->xwayland to NULL first to prevent callbacks (like
+	 * Reset g_server.xwayland to NULL first to prevent callbacks (like
 	 * server_global_filter) from accessing it as it is destroyed
 	 */
-	server->xwayland = NULL;
+	g_server.xwayland = NULL;
 	wlr_xwayland_destroy(xwayland);
 }
 
@@ -1433,18 +1422,18 @@ xwayland_adjust_usable_area(struct view *view, struct wlr_output_layout *layout,
 }
 
 void
-xwayland_update_workarea(struct server *server)
+xwayland_update_workarea(void)
 {
 	/*
 	 * Do nothing if called during destroy or before xwayland is ready.
 	 * This function will be called again from the ready signal handler.
 	 */
-	if (!server->xwayland || !server->xwayland->xwm) {
+	if (!g_server.xwayland || !g_server.xwayland->xwm) {
 		return;
 	}
 
 	struct wlr_box lb;
-	wlr_output_layout_get_box(server->output_layout, NULL, &lb);
+	wlr_output_layout_get_box(g_server.output_layout, NULL, &lb);
 
 	/* Compute outer edges of layout (excluding negative regions) */
 	int layout_left = MAX(0, lb.x);
@@ -1459,13 +1448,13 @@ xwayland_update_workarea(struct server *server)
 	int workarea_bottom = layout_bottom;
 
 	struct output *output;
-	wl_list_for_each(output, &server->outputs, link) {
+	wl_list_for_each(output, &g_server.outputs, link) {
 		if (!output_is_usable(output)) {
 			continue;
 		}
 
 		struct wlr_box ob;
-		wlr_output_layout_get_box(server->output_layout,
+		wlr_output_layout_get_box(g_server.output_layout,
 			output->wlr_output, &ob);
 
 		/* Compute edges of output */
@@ -1508,15 +1497,15 @@ xwayland_update_workarea(struct server *server)
 		.width = workarea_right - workarea_left,
 		.height = workarea_bottom - workarea_top,
 	};
-	wlr_xwayland_set_workareas(server->xwayland, &workarea, 1);
+	wlr_xwayland_set_workareas(g_server.xwayland, &workarea, 1);
 }
 
 void
-xwayland_flush(struct server *server)
+xwayland_flush(void)
 {
-	if (!server->xwayland || !server->xwayland->xwm) {
+	if (!g_server.xwayland || !g_server.xwayland->xwm) {
 		return;
 	}
 
-	xcb_flush(wlr_xwayland_get_xwm_connection(server->xwayland));
+	xcb_flush(wlr_xwayland_get_xwm_connection(g_server.xwayland));
 }