Implement workspaces

include/sway/container.h

@@ -11,6 +11,7 @@ typedef struct sway_container swayc_t;
 extern swayc_t root_container;
 
 struct sway_view;
+struct sway_seat;
 
 /**
  * Different kinds of containers.
@@ -140,11 +141,25 @@ swayc_t *new_view(swayc_t *sibling, struct sway_view *sway_view);
 swayc_t *destroy_output(swayc_t *output);
 swayc_t *destroy_view(swayc_t *view);
 
+swayc_t *next_view_sibling(struct sway_seat *seat);
+
+/**
+ * Finds a container based on test criteria. Returns the first container that
+ * passes the test.
+ */
+swayc_t *swayc_by_test(swayc_t *container,
+		bool (*test)(swayc_t *view, void *data), void *data);
+/**
+ * Finds a parent container with the given swayc_type.
+ */
 swayc_t *swayc_parent_by_type(swayc_t *container, enum swayc_types type);
+/**
+ * Maps a container's children over a function.
+ */
+void container_map(swayc_t *container,
+		void (*f)(swayc_t *view, void *data), void *data);
 
 swayc_t *swayc_at(swayc_t *parent, double lx, double ly,
 		struct wlr_surface **surface, double *sx, double *sy);
 
-void container_map(swayc_t *container, void (*f)(swayc_t *view, void *data), void *data);
-
 #endif

include/sway/input/input-manager.h

@@ -48,4 +48,8 @@ struct sway_seat *sway_input_manager_get_default_seat(
 
 struct sway_seat *input_manager_get_seat(struct sway_input_manager *input,
 		const char *seat_name);
+
+/** Gets the last seat the user interacted with */
+struct sway_seat *input_manager_current_seat(struct sway_input_manager *input);
+
 #endif

include/sway/workspace.h

@@ -1,6 +1,20 @@
 #ifndef _SWAY_WORKSPACE_H
 #define _SWAY_WORKSPACE_H
 
+struct sway_container;
+
+extern char *prev_workspace_name;
+
 char *workspace_next_name(const char *output_name);
+swayc_t *workspace_create(const char *name);
+bool workspace_switch(swayc_t *workspace);
+
+struct sway_container *workspace_by_number(const char* name);
+swayc_t *workspace_by_name(const char*);
+
+struct sway_container *workspace_output_next(struct sway_container *current);
+struct sway_container *workspace_next(struct sway_container *current);
+struct sway_container *workspace_output_prev(struct sway_container *current);
+struct sway_container *workspace_prev(struct sway_container *current);
 
 #endif

sway/commands.c

@@ -139,6 +139,7 @@ static struct cmd_handler handlers[] = {
 	{ "reload", cmd_reload },
 	{ "seat", cmd_seat },
 	{ "set", cmd_set },
+	{ "workspace", cmd_workspace },
 };
 
 static int handler_compare(const void *_a, const void *_b) {

sway/commands/kill.c

@@ -10,11 +10,10 @@ struct cmd_results *cmd_kill(int argc, char **argv) {
 		return cmd_results_new(CMD_FAILURE, "kill",
 			"Command 'kill' cannot be used in the config file");
 	}
-	if (!sway_assert(config->handler_context.current_container,
-				"cmd_kill called without container context")) {
+	enum swayc_types type = config->handler_context.current_container->type;
+	if (type != C_VIEW || type != C_CONTAINER) {
 		return cmd_results_new(CMD_INVALID, NULL,
-				"cmd_kill called without container context "
-				"(this is a bug in sway)");
+				"Can only kill views and containers with this command");
 	}
 	// TODO close arbitrary containers without a view
 	struct sway_view *view =

sway/commands/workspace.c

@@ -0,0 +1,101 @@
+#define _XOPEN_SOURCE 500
+#include <string.h>
+#include <strings.h>
+#include "sway/commands.h"
+#include "sway/config.h"
+#include "sway/input/seat.h"
+#include "sway/workspace.h"
+#include "list.h"
+#include "log.h"
+#include "stringop.h"
+
+struct cmd_results *cmd_workspace(int argc, char **argv) {
+	struct cmd_results *error = NULL;
+	if ((error = checkarg(argc, "workspace", EXPECTED_AT_LEAST, 1))) {
+		return error;
+	}
+
+	int output_location = -1;
+
+	swayc_t *current_container = config->handler_context.current_container;
+	swayc_t *old_workspace = NULL, *old_output = NULL;
+	if (current_container) {
+		if (current_container->type == C_WORKSPACE) {
+			old_workspace = current_container;
+		} else {
+			old_workspace = swayc_parent_by_type(current_container, C_WORKSPACE);
+		}
+		old_output = swayc_parent_by_type(current_container, C_OUTPUT);
+	}
+
+	for (int i = 0; i < argc; ++i) {
+		if (strcasecmp(argv[i], "output") == 0) {
+			output_location = i;
+			break;
+		}
+	}
+	if (output_location >= 0) {
+		if ((error = checkarg(argc, "workspace", EXPECTED_EQUAL_TO, output_location + 2))) {
+			return error;
+		}
+		struct workspace_output *wso = calloc(1, sizeof(struct workspace_output));
+		if (!wso) {
+			return cmd_results_new(CMD_FAILURE, "workspace output",
+					"Unable to allocate workspace output");
+		}
+		wso->workspace = join_args(argv, argc - 2);
+		wso->output = strdup(argv[output_location + 1]);
+		int i = -1;
+		if ((i = list_seq_find(config->workspace_outputs, workspace_output_cmp_workspace, wso)) != -1) {
+			struct workspace_output *old = config->workspace_outputs->items[i];
+			free(old); // workspaces can only be assigned to a single output
+			list_del(config->workspace_outputs, i);
+		}
+		wlr_log(L_DEBUG, "Assigning workspace %s to output %s", wso->workspace, wso->output);
+		list_add(config->workspace_outputs, wso);
+	} else {
+		if (config->reading || !config->active) {
+			return cmd_results_new(CMD_DEFER, "workspace", NULL);
+		}
+		swayc_t *ws = NULL;
+		if (strcasecmp(argv[0], "number") == 0) {
+			if (!(ws = workspace_by_number(argv[1]))) {
+				char *name = join_args(argv + 1, argc - 1);
+				ws = workspace_create(name);
+				free(name);
+			}
+		} else if (strcasecmp(argv[0], "next") == 0) {
+			ws = workspace_next(old_workspace);
+		} else if (strcasecmp(argv[0], "prev") == 0) {
+			ws = workspace_prev(old_workspace);
+		} else if (strcasecmp(argv[0], "next_on_output") == 0) {
+			ws = workspace_output_next(old_output);
+		} else if (strcasecmp(argv[0], "prev_on_output") == 0) {
+			ws = workspace_output_prev(old_output);
+		} else if (strcasecmp(argv[0], "back_and_forth") == 0) {
+			// if auto_back_and_forth is enabled, workspace_switch will swap
+			// the workspaces. If we created prev_workspace here, workspace_switch
+			// would put us back on original workspace.
+			if (config->auto_back_and_forth) {
+				ws = old_workspace;
+			} else if (prev_workspace_name
+					&& !(ws = workspace_by_name(prev_workspace_name))) {
+				ws = workspace_create(prev_workspace_name);
+			}
+		} else {
+			char *name = join_args(argv, argc);
+			if (!(ws = workspace_by_name(name))) {
+				ws = workspace_create(name);
+			}
+			free(name);
+		}
+		workspace_switch(ws);
+		current_container = config->handler_context.seat->focus;
+		swayc_t *new_output = swayc_parent_by_type(current_container, C_OUTPUT);
+
+		if (config->mouse_warping && old_output != new_output) {
+			// TODO: Warp mouse
+		}
+	}
+	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+}

sway/config.c

@@ -318,10 +318,6 @@ static bool load_config(const char *path, struct sway_config *config) {
 	return true;
 }
 
-static int qstrcmp(const void* a, const void* b) {
-	return strcmp(*((char**) a), *((char**) b));
-}
-
 bool load_main_config(const char *file, bool is_active) {
 	char *path;
 	if (file != NULL) {
@@ -349,7 +345,9 @@ bool load_main_config(const char *file, bool is_active) {
 	config->reading = true;
 
 	// Read security configs
+	// TODO: Security
 	bool success = true;
+	/*
 	DIR *dir = opendir(SYSCONFDIR "/sway/security.d");
 	if (!dir) {
 		wlr_log(L_ERROR,
@@ -392,6 +390,7 @@ bool load_main_config(const char *file, bool is_active) {
 
 		free_flat_list(secconfigs);
 	}
+	*/
 
 	success = success && load_config(path, config);
 
@@ -717,3 +716,11 @@ char *do_var_replacement(char *str) {
 	}
 	return str;
 }
+
+// the naming is intentional (albeit long): a workspace_output_cmp function
+// would compare two structs in full, while this method only compares the
+// workspace.
+int workspace_output_cmp_workspace(const void *a, const void *b) {
+	const struct workspace_output *wsa = a, *wsb = b;
+	return lenient_strcmp(wsa->workspace, wsb->workspace);
+}

sway/desktop/output.c

@@ -219,8 +219,8 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
 	wlr_output_make_current(wlr_output);
 	wlr_renderer_begin(server->renderer, wlr_output);
 
-	swayc_descendants_of_type(
-			&root_container, C_VIEW, output_frame_view, soutput);
+	swayc_t *workspace = soutput->swayc->focused;
+	swayc_descendants_of_type(workspace, C_VIEW, output_frame_view, soutput);
 
 	// render unmanaged views on top
 	struct sway_view *view;

sway/desktop/xdg_shell_v6.c

@@ -124,8 +124,6 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
 	sway_surface->view = sway_view;
 	
 	// TODO:
-	// - Wire up listeners
-	// - Handle popups
 	// - Look up pid and open on appropriate workspace
 	// - Set new view to maximized so it behaves nicely
 	// - Criteria
@@ -136,11 +134,8 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
 	sway_surface->destroy.notify = handle_destroy;
 	wl_signal_add(&xdg_surface->events.destroy, &sway_surface->destroy);
 
-	// TODO: actual focus semantics
-	swayc_t *parent = root_container.children->items[0];
-	parent = parent->children->items[0]; // workspace
-
-	swayc_t *cont = new_view(parent, sway_view);
+	struct sway_seat *seat = input_manager_current_seat(input_manager);
+	swayc_t *cont = new_view(seat->focus, sway_view);
 	sway_view->swayc = cont;
 
 	arrange_windows(cont->parent, -1, -1);

sway/input/input-manager.c

@@ -23,6 +23,14 @@ struct sway_input_manager *input_manager;
 struct input_config *current_input_config = NULL;
 struct seat_config *current_seat_config = NULL;
 
+struct sway_seat *input_manager_current_seat(struct sway_input_manager *input) {
+	struct sway_seat *seat = config->handler_context.seat;
+	if (!seat) {
+		seat = sway_input_manager_get_default_seat(input_manager);
+	}
+	return seat;
+}
+
 struct sway_seat *input_manager_get_seat(
 		struct sway_input_manager *input, const char *seat_name) {
 	struct sway_seat *seat = NULL;

sway/input/seat.c

@@ -1,6 +1,7 @@
 #define _XOPEN_SOURCE 700
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_xcursor_manager.h>
+#include "sway/container.h"
 #include "sway/input/seat.h"
 #include "sway/input/cursor.h"
 #include "sway/input/input-manager.h"
@@ -81,7 +82,7 @@ static void seat_configure_keyboard(struct sway_seat *seat,
 	sway_keyboard_configure(seat_device->keyboard);
 	wlr_seat_set_keyboard(seat->wlr_seat,
 		seat_device->input_device->wlr_device);
-	if (seat->focus) {
+	if (seat->focus && seat->focus->type == C_VIEW) {
 		// force notify reenter to pick up the new configuration
 		wlr_seat_keyboard_clear_focus(seat->wlr_seat);
 		wlr_seat_keyboard_notify_enter(seat->wlr_seat,
@@ -205,10 +206,8 @@ void sway_seat_configure_xcursor(struct sway_seat *seat) {
 
 static void handle_focus_destroy(struct wl_listener *listener, void *data) {
 	struct sway_seat *seat = wl_container_of(listener, seat, focus_destroy);
-	//swayc_t *container = data;
-
-	// TODO set new focus based on the state of the tree
-	sway_seat_set_focus(seat, NULL);
+	swayc_t *container = data;
+	sway_seat_set_focus(seat, container->parent);
 }
 
 void sway_seat_set_focus(struct sway_seat *seat, swayc_t *container) {
@@ -218,11 +217,11 @@ void sway_seat_set_focus(struct sway_seat *seat, swayc_t *container) {
 		return;
 	}
 
-	if (last_focus) {
+	if (last_focus && last_focus->type == C_VIEW) {
 		wl_list_remove(&seat->focus_destroy.link);
 	}
 
-	if (container) {
+	if (container && container->type == C_VIEW) {
 		struct sway_view *view = container->sway_view;
 		view_set_activated(view, true);
 		wl_signal_add(&container->events.destroy, &seat->focus_destroy);
@@ -241,7 +240,7 @@ void sway_seat_set_focus(struct sway_seat *seat, swayc_t *container) {
 
 	seat->focus = container;
 
-	if (last_focus &&
+	if (last_focus && last_focus->type == C_VIEW &&
 			!sway_input_manager_has_focus(seat->input, last_focus)) {
 		struct sway_view *view = last_focus->sway_view;
 		view_set_activated(view, false);

sway/meson.build

@@ -35,6 +35,7 @@ sway_sources = files(
 	'commands/input/xkb_variant.c',
 	'commands/output.c',
 	'commands/reload.c',
+	'commands/workspace.c',
 	'config.c',
 	'config/output.c',
 	'config/seat.c',

sway/tree/container.c

@@ -3,10 +3,13 @@
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
+#include <wayland-server.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_wl_shell.h>
 #include "sway/config.h"
 #include "sway/container.h"
+#include "sway/input/input-manager.h"
+#include "sway/input/seat.h"
 #include "sway/layout.h"
 #include "sway/output.h"
 #include "sway/server.h"
@@ -14,6 +17,26 @@
 #include "sway/workspace.h"
 #include "log.h"
 
+swayc_t *swayc_by_test(swayc_t *container,
+		bool (*test)(swayc_t *view, void *data), void *data) {
+	if (!container->children) {
+		return NULL;
+	}
+	// TODO: floating windows
+	for (int i = 0; i < container->children->length; ++i) {
+		swayc_t *child = container->children->items[i];
+		if (test(child, data)) {
+			return child;
+		} else {
+			swayc_t *res = swayc_by_test(child, test, data);
+			if (res) {
+				return res;
+			}
+		}
+	}
+	return NULL;
+}
+
 void swayc_descendants_of_type(swayc_t *root, enum swayc_types type,
 		void (*func)(swayc_t *item, void *data), void *data) {
 	for (int i = 0; i < root->children->length; ++i) {
@@ -127,7 +150,19 @@ swayc_t *new_output(struct sway_output *sway_output) {
 	// Create workspace
 	char *ws_name = workspace_next_name(output->name);
 	wlr_log(L_DEBUG, "Creating default workspace %s", ws_name);
-	new_workspace(output, ws_name);
+	swayc_t *ws = new_workspace(output, ws_name);
+	output->focused = ws;
+	// Set each seat's focus if not already set
+	// TODO FOCUS: this is probably stupid, we shouldn't define focus in two
+	// places. We should probably put the active workspace on the sway_output
+	// struct instead of trying to do focus semantics like this
+	struct sway_seat *seat = NULL;
+	wl_list_for_each(seat, &input_manager->seats, link) {
+		if (!seat->focus) {
+			seat->focus = ws;
+		}
+	}
+
 	free(ws_name);
 	return output;
 }
@@ -159,8 +194,8 @@ swayc_t *new_view(swayc_t *sibling, struct sway_view *sway_view) {
 	}
 	const char *title = view_get_title(sway_view);
 	swayc_t *swayc = new_swayc(C_VIEW);
-	wlr_log(L_DEBUG, "Adding new view %p:%s to container %p %d",
-		swayc, title, sibling, sibling ? sibling->type : 0);
+	wlr_log(L_DEBUG, "Adding new view %p:%s to container %p %d %s",
+		swayc, title, sibling, sibling ? sibling->type : 0, sibling->name);
 	// Setup values
 	swayc->sway_view = sway_view;
 	swayc->name = title ? strdup(title) : NULL;

sway/tree/workspace.c

@@ -2,8 +2,20 @@
 #include <stdbool.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <strings.h>
 #include "sway/container.h"
+#include "sway/input/input-manager.h"
+#include "sway/input/seat.h"
+#include "sway/workspace.h"
 #include "log.h"
+#include "util.h"
+
+char *prev_workspace_name = NULL;
+struct workspace_by_number_data {
+	int len;
+	const char *cset;
+	const char *name;
+};
 
 void next_name_map(swayc_t *ws, void *data) {
 	int *count = data;
@@ -24,3 +36,202 @@ char *workspace_next_name(const char *output_name) {
 	snprintf(name, len + 1, "%d", count);
 	return name;
 }
+
+static bool _workspace_by_number(swayc_t *view, void *data) {
+	if (view->type != C_WORKSPACE) {
+		return false;
+	}
+	struct workspace_by_number_data *wbnd = data;
+	int a = strspn(view->name, wbnd->cset);
+	return a == wbnd->len && strncmp(view->name, wbnd->name, a) == 0;
+}
+
+swayc_t *workspace_by_number(const char* name) {
+	struct workspace_by_number_data wbnd = {0, "1234567890", name};
+	wbnd.len = strspn(name, wbnd.cset);
+	if (wbnd.len <= 0) {
+		return NULL;
+	}
+	return swayc_by_test(&root_container, _workspace_by_number, (void *) &wbnd);
+}
+
+static bool _workspace_by_name(swayc_t *view, void *data) {
+	return (view->type == C_WORKSPACE) &&
+		   (strcasecmp(view->name, (char *) data) == 0);
+}
+
+swayc_t *workspace_by_name(const char *name) {
+	struct sway_seat *seat = input_manager_current_seat(input_manager);
+	swayc_t *current_workspace = NULL, *current_output = NULL;
+	if (seat->focus) {
+		current_workspace = swayc_parent_by_type(seat->focus, C_WORKSPACE);
+		current_output = swayc_parent_by_type(seat->focus, C_OUTPUT);
+	}
+	if (strcmp(name, "prev") == 0) {
+		return workspace_prev(current_workspace);
+	} else if (strcmp(name, "prev_on_output") == 0) {
+		return workspace_output_prev(current_output);
+	} else if (strcmp(name, "next") == 0) {
+		return workspace_next(current_workspace);
+	} else if (strcmp(name, "next_on_output") == 0) {
+		return workspace_output_next(current_output);
+	} else if (strcmp(name, "current") == 0) {
+		return current_workspace;
+	} else {
+		return swayc_by_test(&root_container, _workspace_by_name, (void *) name);
+	}
+}
+
+swayc_t *workspace_create(const char *name) {
+	swayc_t *parent;
+	// Search for workspace<->output pair
+	int i, e = config->workspace_outputs->length;
+	for (i = 0; i < e; ++i) {
+		struct workspace_output *wso = config->workspace_outputs->items[i];
+		if (strcasecmp(wso->workspace, name) == 0) {
+			// Find output to use if it exists
+			e = root_container.children->length;
+			for (i = 0; i < e; ++i) {
+				parent = root_container.children->items[i];
+				if (strcmp(parent->name, wso->output) == 0) {
+					return new_workspace(parent, name);
+				}
+			}
+			break;
+		}
+	}
+	// Otherwise create a new one
+	struct sway_seat *seat = input_manager_current_seat(input_manager);
+	parent = seat->focus;
+	parent = swayc_parent_by_type(parent, C_OUTPUT);
+	return new_workspace(parent, name);
+}
+
+/**
+ * Get the previous or next workspace on the specified output. Wraps around at
+ * the end and beginning.  If next is false, the previous workspace is returned,
+ * otherwise the next one is returned.
+ */
+swayc_t *workspace_output_prev_next_impl(swayc_t *output, bool next) {
+	if (!sway_assert(output->type == C_OUTPUT,
+				"Argument must be an output, is %d", output->type)) {
+		return NULL;
+	}
+
+	int i;
+	for (i = 0; i < output->children->length; i++) {
+		if (output->children->items[i] == output->focused) {
+			return output->children->items[
+				wrap(i + (next ? 1 : -1), output->children->length)];
+		}
+	}
+
+	// Doesn't happen, at worst the for loop returns the previously active workspace
+	return NULL;
+}
+
+/**
+ * Get the previous or next workspace. If the first/last workspace on an output
+ * is active, proceed to the previous/next output's previous/next workspace. If
+ * next is false, the previous workspace is returned, otherwise the next one is
+ * returned.
+ */
+swayc_t *workspace_prev_next_impl(swayc_t *workspace, bool next) {
+	if (!sway_assert(workspace->type == C_WORKSPACE,
+				"Argument must be a workspace, is %d", workspace->type)) {
+		return NULL;
+	}
+
+	swayc_t *current_output = workspace->parent;
+	int offset = next ? 1 : -1;
+	int start = next ? 0 : 1;
+	int end;
+	if (next) {
+		end = current_output->children->length - 1;
+	} else {
+		end = current_output->children->length;
+	}
+	int i;
+	for (i = start; i < end; i++) {
+		if (current_output->children->items[i] == workspace) {
+			return current_output->children->items[i + offset];
+		}
+	}
+
+	// Given workspace is the first/last on the output, jump to the previous/next output
+	int num_outputs = root_container.children->length;
+	for (i = 0; i < num_outputs; i++) {
+		if (root_container.children->items[i] == current_output) {
+			swayc_t *next_output = root_container.children->items[
+				wrap(i + offset, num_outputs)];
+			return workspace_output_prev_next_impl(next_output, next);
+		}
+	}
+
+	// Doesn't happen, at worst the for loop returns the previously active workspace on the active output
+	return NULL;
+}
+
+swayc_t *workspace_output_next(swayc_t *current) {
+	return workspace_output_prev_next_impl(current, true);
+}
+
+swayc_t *workspace_next(swayc_t *current) {
+	return workspace_prev_next_impl(current, true);
+}
+
+swayc_t *workspace_output_prev(swayc_t *current) {
+	return workspace_output_prev_next_impl(current, false);
+}
+
+swayc_t *workspace_prev(swayc_t *current) {
+	return workspace_prev_next_impl(current, false);
+}
+
+bool workspace_switch(swayc_t *workspace) {
+	if (!workspace) {
+		return false;
+	}
+	struct sway_seat *seat = input_manager_current_seat(input_manager);
+	if (!seat || !seat->focus) {
+		return false;
+	}
+	swayc_t *active_ws = seat->focus;
+	if (active_ws->type != C_WORKSPACE) {
+		swayc_parent_by_type(seat->focus, C_WORKSPACE);
+	}
+
+	if (config->auto_back_and_forth
+			&& active_ws == workspace
+			&& prev_workspace_name) {
+		swayc_t *new_ws = workspace_by_name(prev_workspace_name);
+		workspace = new_ws ? new_ws : workspace_create(prev_workspace_name);
+	}
+
+	if (!prev_workspace_name || (strcmp(prev_workspace_name, active_ws->name)
+				&& active_ws != workspace)) {
+		free(prev_workspace_name);
+		prev_workspace_name = malloc(strlen(active_ws->name) + 1);
+		if (!prev_workspace_name) {
+			wlr_log(L_ERROR, "Unable to allocate previous workspace name");
+			return false;
+		}
+		strcpy(prev_workspace_name, active_ws->name);
+	}
+
+	// TODO: Deal with sticky containers
+
+	wlr_log(L_DEBUG, "Switching to workspace %p:%s", workspace, workspace->name);
+	// TODO FOCUS: Focus the last view this seat had focused on this workspace
+	if (workspace->children->length) {
+		// TODO FOCUS: This is really fucking stupid
+		sway_seat_set_focus(seat, workspace->children->items[0]);
+	} else {
+		sway_seat_set_focus(seat, workspace);
+	}
+	swayc_t *output = swayc_parent_by_type(workspace, C_OUTPUT);
+	// TODO FOCUS: take a look at this
+	output->focused = workspace;
+	arrange_windows(output, -1, -1);
+	return true;
+}