Revert "Merge pull request #1653 from swaywm/revert-1647-refactor-tree"

This reverts commit 472e81f35d689d67cda241acafda91c688d61046, reversing
changes made to 6b7841b11ff4cd35f54d69dc92029855893e5ce0.

1 files changed, 51 insertions, 41 deletions

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