Revert "Refactor tree"

sway/tree/workspace.c

@@ -3,10 +3,10 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <strings.h>
-#include "sway/tree/container.h"
+#include "sway/container.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/seat.h"
-#include "sway/tree/workspace.h"
+#include "sway/workspace.h"
 #include "log.h"
 #include "util.h"
 
@@ -17,7 +17,7 @@ struct workspace_by_number_data {
 	const char *name;
 };
 
-void next_name_map(struct sway_container *ws, void *data) {
+void next_name_map(swayc_t *ws, void *data) {
 	int *count = data;
 	++count;
 }
@@ -37,7 +37,7 @@ char *workspace_next_name(const char *output_name) {
 	return name;
 }
 
-static bool _workspace_by_number(struct sway_container *view, void *data) {
+static bool _workspace_by_number(swayc_t *view, void *data) {
 	if (view->type != C_WORKSPACE) {
 		return false;
 	}
@@ -46,28 +46,27 @@ static bool _workspace_by_number(struct sway_container *view, void *data) {
 	return a == wbnd->len && strncmp(view->name, wbnd->name, a) == 0;
 }
 
-struct sway_container *workspace_by_number(const char* name) {
+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 container_find(&root_container,
-			_workspace_by_number, (void *) &wbnd);
+	return swayc_by_test(&root_container, _workspace_by_number, (void *) &wbnd);
 }
 
-static bool _workspace_by_name(struct sway_container *view, void *data) {
+static bool _workspace_by_name(swayc_t *view, void *data) {
 	return (view->type == C_WORKSPACE) &&
 		   (strcasecmp(view->name, (char *) data) == 0);
 }
 
-struct sway_container *workspace_by_name(const char *name) {
+swayc_t *workspace_by_name(const char *name) {
 	struct sway_seat *seat = input_manager_current_seat(input_manager);
-	struct sway_container *current_workspace = NULL, *current_output = NULL;
-	struct sway_container *focus = sway_seat_get_focus(seat);
+	swayc_t *current_workspace = NULL, *current_output = NULL;
+	swayc_t *focus = sway_seat_get_focus(seat);
 	if (focus) {
-		current_workspace = container_parent(focus, C_WORKSPACE);
-		current_output = container_parent(focus, C_OUTPUT);
+		current_workspace = swayc_parent_by_type(focus, C_WORKSPACE);
+		current_output = swayc_parent_by_type(focus, C_OUTPUT);
 	}
 	if (strcmp(name, "prev") == 0) {
 		return workspace_prev(current_workspace);
@@ -80,13 +79,12 @@ struct sway_container *workspace_by_name(const char *name) {
 	} else if (strcmp(name, "current") == 0) {
 		return current_workspace;
 	} else {
-		return container_find(&root_container, _workspace_by_name,
-				(void *)name);
+		return swayc_by_test(&root_container, _workspace_by_name, (void *) name);
 	}
 }
 
-struct sway_container *workspace_create(const char *name) {
-	struct sway_container *parent;
+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) {
@@ -97,7 +95,7 @@ struct sway_container *workspace_create(const char *name) {
 			for (i = 0; i < e; ++i) {
 				parent = root_container.children->items[i];
 				if (strcmp(parent->name, wso->output) == 0) {
-					return container_workspace_create(parent, name);
+					return new_workspace(parent, name);
 				}
 			}
 			break;
@@ -105,11 +103,10 @@ struct sway_container *workspace_create(const char *name) {
 	}
 	// Otherwise create a new one
 	struct sway_seat *seat = input_manager_current_seat(input_manager);
-	struct sway_container *focus =
-		sway_seat_get_focus_inactive(seat, &root_container);
+	swayc_t *focus = sway_seat_get_focus_inactive(seat, &root_container);
 	parent = focus;
-	parent = container_parent(parent, C_OUTPUT);
-	return container_workspace_create(parent, name);
+	parent = swayc_parent_by_type(parent, C_OUTPUT);
+	return new_workspace(parent, name);
 }
 
 /**
@@ -117,18 +114,17 @@ struct sway_container *workspace_create(const char *name) {
  * the end and beginning.  If next is false, the previous workspace is returned,
  * otherwise the next one is returned.
  */
-struct sway_container *workspace_output_prev_next_impl(
-		struct sway_container *output, bool next) {
+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;
 	}
 
 	struct sway_seat *seat = input_manager_current_seat(input_manager);
-	struct sway_container *focus = sway_seat_get_focus_inactive(seat, output);
-	struct sway_container *workspace = (focus->type == C_WORKSPACE ?
+	swayc_t *focus = sway_seat_get_focus_inactive(seat, output);
+	swayc_t *workspace = (focus->type == C_WORKSPACE ?
 			focus :
-			container_parent(focus, C_WORKSPACE));
+			swayc_parent_by_type(focus, C_WORKSPACE));
 
 	int i;
 	for (i = 0; i < output->children->length; i++) {
@@ -138,8 +134,7 @@ struct sway_container *workspace_output_prev_next_impl(
 		}
 	}
 
-	// Doesn't happen, at worst the for loop returns the previously active
-	// workspace
+	// Doesn't happen, at worst the for loop returns the previously active workspace
 	return NULL;
 }
 
@@ -149,14 +144,13 @@ struct sway_container *workspace_output_prev_next_impl(
  * next is false, the previous workspace is returned, otherwise the next one is
  * returned.
  */
-struct sway_container *workspace_prev_next_impl(
-		struct sway_container *workspace, bool next) {
+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;
 	}
 
-	struct sway_container *current_output = workspace->parent;
+	swayc_t *current_output = workspace->parent;
 	int offset = next ? 1 : -1;
 	int start = next ? 0 : 1;
 	int end;
@@ -172,57 +166,54 @@ struct sway_container *workspace_prev_next_impl(
 		}
 	}
 
-	// Given workspace is the first/last on the output, jump to the
-	// previous/next output
+	// 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) {
-			struct sway_container *next_output = root_container.children->items[
+			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
+	// Doesn't happen, at worst the for loop returns the previously active workspace on the active output
 	return NULL;
 }
 
-struct sway_container *workspace_output_next(struct sway_container *current) {
+swayc_t *workspace_output_next(swayc_t *current) {
 	return workspace_output_prev_next_impl(current, true);
 }
 
-struct sway_container *workspace_next(struct sway_container *current) {
+swayc_t *workspace_next(swayc_t *current) {
 	return workspace_prev_next_impl(current, true);
 }
 
-struct sway_container *workspace_output_prev(struct sway_container *current) {
+swayc_t *workspace_output_prev(swayc_t *current) {
 	return workspace_output_prev_next_impl(current, false);
 }
 
-struct sway_container *workspace_prev(struct sway_container *current) {
+swayc_t *workspace_prev(swayc_t *current) {
 	return workspace_prev_next_impl(current, false);
 }
 
-bool workspace_switch(struct sway_container *workspace) {
+bool workspace_switch(swayc_t *workspace) {
 	if (!workspace) {
 		return false;
 	}
 	struct sway_seat *seat = input_manager_current_seat(input_manager);
-	struct sway_container *focus =
-		sway_seat_get_focus_inactive(seat, &root_container);
+	swayc_t *focus = sway_seat_get_focus_inactive(seat, &root_container);
 	if (!seat || !focus) {
 		return false;
 	}
-	struct sway_container *active_ws = focus;
+	swayc_t *active_ws = focus;
 	if (active_ws->type != C_WORKSPACE) {
-		container_parent(focus, C_WORKSPACE);
+		swayc_parent_by_type(focus, C_WORKSPACE);
 	}
 
 	if (config->auto_back_and_forth
 			&& active_ws == workspace
 			&& prev_workspace_name) {
-		struct sway_container *new_ws = workspace_by_name(prev_workspace_name);
+		swayc_t *new_ws = workspace_by_name(prev_workspace_name);
 		workspace = new_ws ? new_ws : workspace_create(prev_workspace_name);
 	}
 
@@ -239,14 +230,13 @@ bool workspace_switch(struct sway_container *workspace) {
 
 	// TODO: Deal with sticky containers
 
-	wlr_log(L_DEBUG, "Switching to workspace %p:%s",
-		workspace, workspace->name);
-	struct sway_container *next = sway_seat_get_focus_inactive(seat, workspace);
+	wlr_log(L_DEBUG, "Switching to workspace %p:%s", workspace, workspace->name);
+	swayc_t *next = sway_seat_get_focus_inactive(seat, workspace);
 	if (next == NULL) {
 		next = workspace;
 	}
 	sway_seat_set_focus(seat, next);
-	struct sway_container *output = container_parent(workspace, C_OUTPUT);
+	swayc_t *output = swayc_parent_by_type(workspace, C_OUTPUT);
 	arrange_windows(output, -1, -1);
 	return true;
 }