15 files changed, 273 insertions, 71 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d190cd8b..3ed6fc02 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -69,3 +69,11 @@ INSTALL(
   FILES ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/sway.5
   DESTINATION ${CMAKE_INSTALL_PREFIX}/share/man/man5
 )
+
+INSTALL(
+  FILES ${PROJECT_SOURCE_DIR}/sway.desktop
+  DESTINATION ${CMAKE_INSTALL_PREFIX}/share/wayland-sessions/)
+
+INSTALL(
+  FILES ${PROJECT_SOURCE_DIR}/sway-xorg.desktop
+  DESTINATION ${CMAKE_INSTALL_PREFIX}/share/xsessions/)
diff --git a/include/container.h b/include/container.h
index d3026011..3598067c 100644
--- a/include/container.h
+++ b/include/container.h
@@ -55,6 +55,7 @@ struct sway_container {
         struct sway_container *focused;
 };
 
+// Container Creation
 
 swayc_t *new_output(wlc_handle handle);
 swayc_t *new_workspace(swayc_t *output, const char *name);
@@ -65,13 +66,23 @@ swayc_t *new_view(swayc_t *sibling, wlc_handle handle);
 // Creates view as a new floating view which is in the active workspace
 swayc_t *new_floating_view(wlc_handle handle);
 
+// Container Destroying
 
 swayc_t *destroy_output(swayc_t *output);
 // Destroys workspace if empty and returns parent pointer, else returns NULL
 swayc_t *destroy_workspace(swayc_t *workspace);
+// Destroyes container and all parent container if they are empty, returns
+// topmost non-empty parent. returns NULL otherwise
 swayc_t *destroy_container(swayc_t *container);
+// Destroys view and all empty parent containers. return topmost non-empty
+// parent
 swayc_t *destroy_view(swayc_t *view);
 
+// Container Lookup
+
+swayc_t *swayc_parent_by_type(swayc_t *container, enum swayc_types);
+swayc_t *swayc_parent_by_layout(swayc_t *container, enum swayc_layouts);
+
 swayc_t *find_container(swayc_t *container, bool (*test)(swayc_t *view, void *data), void *data);
 void container_map(swayc_t *, void (*f)(swayc_t *, void *), void *);
 
diff --git a/include/input_state.h b/include/input_state.h
index 7119c68b..27dd6cff 100644
--- a/include/input_state.h
+++ b/include/input_state.h
@@ -48,6 +48,7 @@ extern struct pointer_state {
 
 void start_floating(swayc_t *view);
 void reset_floating(swayc_t *view);
+void input_init(void);
 
 #endif
 
diff --git a/include/stringop.h b/include/stringop.h
index a5346829..4300f9ed 100644
--- a/include/stringop.h
+++ b/include/stringop.h
@@ -10,5 +10,6 @@ char *code_strchr(const char *string, char delimiter);
 char *code_strstr(const char *haystack, const char *needle);
 int unescape_string(char *string);
 char *join_args(char **argv, int argc);
+char *join_list(list_t *list, char *separator);
 
 #endif
diff --git a/sway-xorg.desktop b/sway-xorg.desktop
new file mode 100644
index 00000000..e93a4284
--- /dev/null
+++ b/sway-xorg.desktop
@@ -0,0 +1,5 @@
+[Desktop Entry]
+Name=Sway (Xorg)
+Comment=SirCmpwn's Wayland window manager
+Exec=sway
+Type=Application
diff --git a/sway.desktop b/sway.desktop
new file mode 100644
index 00000000..98c9af29
--- /dev/null
+++ b/sway.desktop
@@ -0,0 +1,5 @@
+[Desktop Entry]
+Name=Sway
+Comment=SirCmpwn's Wayland window manager
+Exec=sway
+Type=Application
diff --git a/sway/commands.c b/sway/commands.c
index 0f743b4e..d1bbdc89 100644
--- a/sway/commands.c
+++ b/sway/commands.c
@@ -390,7 +390,6 @@ static bool cmd_layout(struct sway_config *config, int argc, char **argv) {
                 return false;
         }
         swayc_t *parent = get_focused_container(&root_container);
-
         while (parent->type == C_VIEW) {
                 parent = parent->parent;
         }
@@ -665,9 +664,7 @@ static bool cmd_fullscreen(struct sway_config *config, int argc, char **argv) {
         // Resize workspace if going from  fullscreen -> notfullscreen
         // otherwise just resize container
         if (current) {
-                while (container->type != C_WORKSPACE) {
-                        container = container->parent;
-                }
+                container = swayc_parent_by_type(container, C_WORKSPACE);
         }
         // Only resize container when going into fullscreen
         arrange_windows(container, -1, -1);
diff --git a/sway/config.c b/sway/config.c
index 9f65e8a2..0afb0205 100644
--- a/sway/config.c
+++ b/sway/config.c
@@ -9,6 +9,7 @@
 #include "commands.h"
 #include "config.h"
 #include "layout.h"
+#include "input_state.h"
 
 struct sway_config *config;
 
@@ -147,6 +148,8 @@ _continue:
 bool load_config(const char *file) {
         sway_log(L_INFO, "Loading config");
 
+        input_init();
+
         char *path;
         if (file != NULL) {
                 path = strdup(file);
diff --git a/sway/container.c b/sway/container.c
index 4559a5f5..7ccc2e09 100644
--- a/sway/container.c
+++ b/sway/container.c
@@ -8,6 +8,8 @@
 #include "layout.h"
 #include "log.h"
 
+#define ASSERT_NONNULL(PTR) \
+        sway_assert (PTR, "%s: " #PTR "must be non-null", __func__)
 
 static swayc_t *new_swayc(enum swayc_types type) {
         swayc_t *c = calloc(1, sizeof(swayc_t));
@@ -20,37 +22,40 @@ static swayc_t *new_swayc(enum swayc_types type) {
         return c;
 }
 
-static void free_swayc(swayc_t *c) {
+static void free_swayc(swayc_t *cont) {
+        if (!ASSERT_NONNULL(cont)) {
+                return;
+        }
         // TODO does not properly handle containers with children,
         // TODO but functions that call this usually check for that
-        if (c->children) {
-                if (c->children->length) {
+        if (cont->children) {
+                if (cont->children->length) {
                         int i;
-                        for (i = 0; i < c->children->length; ++i) {
-                                free_swayc(c->children->items[i]);
+                        for (i = 0; i < cont->children->length; ++i) {
+                                free_swayc(cont->children->items[i]);
                         }
                 }
-                list_free(c->children);
+                list_free(cont->children);
         }
-        if (c->floating) {
-                if (c->floating->length) {
+        if (cont->floating) {
+                if (cont->floating->length) {
                         int i;
-                        for (i = 0; i < c->floating->length; ++i) {
-                                free_swayc(c->floating->items[i]);
+                        for (i = 0; i < cont->floating->length; ++i) {
+                                free_swayc(cont->floating->items[i]);
                         }
                 }
-                list_free(c->floating);
+                list_free(cont->floating);
         }
-        if (c->parent) {
-                remove_child(c);
+        if (cont->parent) {
+                remove_child(cont);
         }
-        if (c->name) {
-                free(c->name);
+        if (cont->name) {
+                free(cont->name);
         }
-        free(c);
+        free(cont);
 }
 
-/* New containers */
+// New containers
 
 static bool workspace_test(swayc_t *view, void *name) {
         return strcasecmp(view->name, (char *)name) == 0;
@@ -103,6 +108,9 @@ swayc_t *new_output(wlc_handle handle) {
 }
 
 swayc_t *new_workspace(swayc_t *output, const char *name) {
+        if (!ASSERT_NONNULL(output)) {
+                return NULL;
+        }
         sway_log(L_DEBUG, "Added workspace %s for output %u", name, (unsigned int)output->handle);
         swayc_t *workspace = new_swayc(C_WORKSPACE);
 
@@ -120,6 +128,9 @@ swayc_t *new_workspace(swayc_t *output, const char *name) {
 }
 
 swayc_t *new_container(swayc_t *child, enum swayc_layouts layout) {
+        if (!ASSERT_NONNULL(child)) {
+                return NULL;
+        }
         swayc_t *cont = new_swayc(C_CONTAINER);
 
         sway_log(L_DEBUG, "creating container %p around %p", cont, child);
@@ -162,6 +173,9 @@ swayc_t *new_container(swayc_t *child, enum swayc_layouts layout) {
 }
 
 swayc_t *new_view(swayc_t *sibling, wlc_handle handle) {
+        if (!ASSERT_NONNULL(sibling)) {
+                return NULL;
+        }
         const char *title = wlc_view_get_title(handle);
         swayc_t *view = new_swayc(C_VIEW);
         sway_log(L_DEBUG, "Adding new view %lu:%s to container %p %d",
@@ -172,14 +186,14 @@ swayc_t *new_view(swayc_t *sibling, wlc_handle handle) {
         view->visible = true;
         view->is_focused = true;
         // Setup geometry
+        const struct wlc_geometry* geometry = wlc_view_get_geometry(handle);
         view->width = 0;
         view->height = 0;
+        view->desired_width = geometry->size.w;
+        view->desired_height = geometry->size.h;
 
         view->gaps = config->gaps_inner;
 
-        view->desired_width = -1;
-        view->desired_height = -1;
-
         view->is_floating = false;
 
         if (sibling->type == C_WORKSPACE) {
@@ -225,9 +239,12 @@ swayc_t *new_floating_view(wlc_handle handle) {
         return view;
 }
 
-/* Destroy container */
+// Destroy container
 
 swayc_t *destroy_output(swayc_t *output) {
+        if (!ASSERT_NONNULL(output)) {
+                return NULL;
+        }
         if (output->children->length == 0) {
                 // TODO move workspaces to other outputs
         }
@@ -237,23 +254,21 @@ swayc_t *destroy_output(swayc_t *output) {
 }
 
 swayc_t *destroy_workspace(swayc_t *workspace) {
+        if (!ASSERT_NONNULL(workspace)) {
+                return NULL;
+        }
         // NOTE: This is called from elsewhere without checking children length
         // TODO move containers to other workspaces?
         // for now just dont delete
         
         // Do not destroy this if it's the last workspace on this output
-        swayc_t *output = workspace->parent;
-        while (output && output->type != C_OUTPUT) {
-                output = output->parent;
-        }
-        if (output) {
-                if (output->children->length == 1) {
-                        return NULL;
-                }
+        swayc_t *output = swayc_parent_by_type(workspace, C_OUTPUT);
+        if (output && output->children->length == 1) {
+                return NULL;
         }
 
         if (workspace->children->length == 0) {
-                sway_log(L_DEBUG, "Workspace: Destroying workspace '%s'", workspace->name);
+                sway_log(L_DEBUG, "%s: '%s'", __func__, workspace->name);
                 swayc_t *parent = workspace->parent;
                 free_swayc(workspace);
                 return parent;
@@ -262,6 +277,9 @@ swayc_t *destroy_workspace(swayc_t *workspace) {
 }
 
 swayc_t *destroy_container(swayc_t *container) {
+        if (!ASSERT_NONNULL(container)) {
+                return NULL;
+        }
         while (container->children->length == 0 && container->type == C_CONTAINER) {
                 sway_log(L_DEBUG, "Container: Destroying container '%p'", container);
                 swayc_t *parent = container->parent;
@@ -272,8 +290,7 @@ swayc_t *destroy_container(swayc_t *container) {
 }
 
 swayc_t *destroy_view(swayc_t *view) {
-        if (view == NULL) {
-                sway_log(L_DEBUG, "Warning: NULL passed into destroy_view");
+        if (!ASSERT_NONNULL(view)) {
                 return NULL;
         }
         sway_log(L_DEBUG, "Destroying view '%p'", view);
@@ -287,6 +304,34 @@ swayc_t *destroy_view(swayc_t *view) {
         return parent;
 }
 
+// Container lookup
+
+swayc_t *swayc_parent_by_type(swayc_t *container, enum swayc_types type) {
+        if (!ASSERT_NONNULL(container)) {
+                return NULL;
+        }
+        if (!sway_assert(type < C_TYPES && type >= C_ROOT, "%s: invalid type", __func__)) {
+                return NULL;
+        }
+        do {
+                container = container->parent;
+        } while(container && container->type != type);
+        return container;
+}
+
+swayc_t *swayc_parent_by_layout(swayc_t *container, enum swayc_layouts layout) {
+        if (!ASSERT_NONNULL(container)) {
+                return NULL;
+        }
+        if (!sway_assert(layout < L_LAYOUTS && layout >= L_NONE, "%s: invalid layout", __func__)) {
+                return NULL;
+        }
+        do {
+                container = container->parent;
+        } while (container && container->layout != layout);
+        return container;
+}
+
 swayc_t *find_container(swayc_t *container, bool (*test)(swayc_t *view, void *data), void *data) {
         if (!container->children) {
                 return NULL;
@@ -316,25 +361,27 @@ swayc_t *find_container(swayc_t *container, bool (*test)(swayc_t *view, void *da
 }
 
 void container_map(swayc_t *container, void (*f)(swayc_t *view, void *data), void *data) {
-        if (!container || !container->children || !container->children->length)  {
-                return;
-        }
-        int i;
-        for (i = 0; i < container->children->length; ++i) {
-                swayc_t *child = container->children->items[i];
-                f(child, data);
-                container_map(child, f, data);
-        }
-        if (container->type == C_WORKSPACE) {
-                for (i = 0; i < container->floating->length; ++i) {
-                        swayc_t *child = container->floating->items[i];
+        if (container && container->children && container->children->length)  {
+                int i;
+                for (i = 0; i < container->children->length; ++i) {
+                        swayc_t *child = container->children->items[i];
                         f(child, data);
                         container_map(child, f, data);
                 }
+                if (container->type == C_WORKSPACE) {
+                        for (i = 0; i < container->floating->length; ++i) {
+                                swayc_t *child = container->floating->items[i];
+                                f(child, data);
+                                container_map(child, f, data);
+                        }
+                }
         }
 }
 
 void set_view_visibility(swayc_t *view, void *data) {
+        if (!ASSERT_NONNULL(view)) {
+                return;
+        }
         uint32_t *p = data;
         if (view->type == C_VIEW) {
                 wlc_view_set_mask(view->handle, *p);
@@ -348,6 +395,9 @@ void set_view_visibility(swayc_t *view, void *data) {
 }
 
 void reset_gaps(swayc_t *view, void *data) {
+        if (!ASSERT_NONNULL(view)) {
+                return;
+        }
         if (view->type == C_OUTPUT) {
                 view->gaps = config->gaps_outer;
         }
diff --git a/sway/handlers.c b/sway/handlers.c
index 571dd2a6..53eae439 100644
--- a/sway/handlers.c
+++ b/sway/handlers.c
@@ -21,10 +21,7 @@ static struct wlc_origin mouse_origin;
 static bool pointer_test(swayc_t *view, void *_origin) {
         const struct wlc_origin *origin = _origin;
         // Determine the output that the view is under
-        swayc_t *parent = view;
-        while (parent->type != C_OUTPUT) {
-                parent = parent->parent;
-        }
+        swayc_t *parent = swayc_parent_by_type(view, C_OUTPUT);
         if (origin->x >= view->x && origin->y >= view->y
                 && origin->x < view->x + view->width && origin->y < view->y + view->height
                 && view->visible && parent == root_container.focused) {
@@ -192,10 +189,7 @@ static bool handle_view_created(wlc_handle handle) {
 
         if (newview) {
                 set_focused_container(newview);
-                swayc_t *output = newview->parent;
-                while (output && output->type != C_OUTPUT) {
-                        output = output->parent;
-                }
+                swayc_t *output = swayc_parent_by_type(newview, C_OUTPUT);
                 arrange_windows(output, -1, -1);
         }
         return true;
@@ -263,10 +257,7 @@ static void handle_view_state_request(wlc_handle view, enum wlc_view_state_bit s
                         arrange_windows(c->parent, -1, -1);
                         // Set it as focused window for that workspace if its going fullscreen
                         if (toggle) {
-                                swayc_t *ws = c;
-                                while (ws->type != C_WORKSPACE) {
-                                        ws = ws->parent;
-                                }
+                                swayc_t *ws = swayc_parent_by_type(c, C_WORKSPACE);
                                 // Set ws focus to c
                                 set_focused_container_for(ws, c);
                         }
diff --git a/sway/input_state.c b/sway/input_state.c
index e592cfc1..ef5d6df0 100644
--- a/sway/input_state.c
+++ b/sway/input_state.c
@@ -8,6 +8,13 @@
 
 static keycode key_state_array[KEY_STATE_MAX_LENGTH];
 
+void input_init(void) {
+        int i;
+        for (i = 0; i < KEY_STATE_MAX_LENGTH; ++i) {
+                key_state_array[i] = 0;
+        }
+}
+
 static uint8_t find_key(keycode key) {
         int i;
         for (i = 0; i < KEY_STATE_MAX_LENGTH; ++i) {
diff --git a/sway/ipc.c b/sway/ipc.c
index 505c17f8..39e580cd 100644
--- a/sway/ipc.c
+++ b/sway/ipc.c
@@ -11,10 +11,13 @@
 #include <stropts.h>
 #include <sys/ioctl.h>
 #include <fcntl.h>
+#include <ctype.h>
 #include "ipc.h"
 #include "log.h"
 #include "config.h"
 #include "commands.h"
+#include "list.h"
+#include "stringop.h"
 
 static int ipc_socket = -1;
 static struct wlc_event_source *ipc_event_source =  NULL;
@@ -37,6 +40,10 @@ int ipc_client_handle_readable(int client_fd, uint32_t mask, void *data);
 void ipc_client_disconnect(struct ipc_client *client);
 void ipc_client_handle_command(struct ipc_client *client);
 bool ipc_send_reply(struct ipc_client *client, const char *payload, uint32_t payload_length);
+void ipc_get_workspaces_callback(swayc_t *container, void *data);
+void ipc_get_outputs_callback(swayc_t *container, void *data);
+
+char *json_list(list_t *items);
 
 void ipc_init(void) {
         ipc_socket = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
@@ -195,6 +202,26 @@ void ipc_client_handle_command(struct ipc_client *client) {
                 ipc_send_reply(client, reply, (uint32_t) length);
                 break;
         }
+        case IPC_GET_WORKSPACES:
+        {
+                list_t *workspaces = create_list();
+                container_map(&root_container, ipc_get_workspaces_callback, workspaces);
+                char *json = json_list(workspaces);
+                free_flat_list(workspaces);
+                ipc_send_reply(client, json, strlen(json));
+                free(json);
+                break;
+        }
+        case IPC_GET_OUTPUTS:
+        {
+                list_t *outputs = create_list();
+                container_map(&root_container, ipc_get_outputs_callback, outputs);
+                char *json = json_list(outputs);
+                free_flat_list(outputs);
+                ipc_send_reply(client, json, strlen(json));
+                free(json);
+                break;
+        }
         default:
                 sway_log(L_INFO, "Unknown IPC command type %i", client->current_command);
                 ipc_client_disconnect(client);
@@ -227,3 +254,68 @@ bool ipc_send_reply(struct ipc_client *client, const char *payload, uint32_t pay
 
         return true;
 }
+
+char *json_list(list_t *items) {
+        char *json_elements = join_list(items, ",");
+        size_t len = strlen(json_elements);
+        char *json = malloc(len + 3);
+        json[0] = '[';
+        memcpy(json + 1, json_elements, len);
+        json[len+1] = ']';
+        json[len+2] = '\0';
+        free(json_elements);
+        return json;
+}
+
+void ipc_get_workspaces_callback(swayc_t *container, void *data) {
+        if (container->type == C_WORKSPACE) {
+                char *json = malloc(512); // Output should usually be around 180 chars
+                int num = isdigit(container->name[0]) ? atoi(container->name) : -1;
+                // TODO: escape the name (quotation marks, unicode)
+                sprintf(json,
+                        "{"
+                                "\"num\":%d,"
+                                "\"name\":\"%s\","
+                                "\"visible\":%s,"
+                                "\"focused\":%s,"
+                                "\"rect\":{"
+                                        "\"x\":%d,"
+                                        "\"y\":%d,"
+                                        "\"width\":%d,"
+                                        "\"height\":%d"
+                                "},"
+                                "\"output\":\"%s\","
+                                "\"urgent\":%s"
+                        "}",
+                        num, container->name, container->visible ? "true" : "false", container->is_focused ? "true" : "false",
+                        container->x, container->y, container->width, container->height,
+                        container->parent->name, "false" // TODO: urgent hint
+                );
+                list_add((list_t *)data, json);
+        }
+}
+
+void ipc_get_outputs_callback(swayc_t *container, void *data) {
+        if (container->type == C_OUTPUT) {
+                char *json = malloc(512); // Output should usually be around 130 chars
+                // TODO: escape the name (quotation marks, unicode)
+                sprintf(json,
+                        "{"
+                                "\"name\":\"%s\","
+                                "\"active\":%s,"
+                                "\"primary\":%s,"
+                                "\"rect\":{"
+                                        "\"x\":%d,"
+                                        "\"y\":%d,"
+                                        "\"width\":%d,"
+                                        "\"height\":%d"
+                                "},"
+                                "\"current_workspace\":\"%s\""
+                        "}",
+                        container->name, "true", "false", // TODO: active, primary
+                        container->x, container->y, container->width, container->height,
+                        container->focused ? container->focused->name : ""
+                );
+                list_add((list_t *)data, json);
+        }
+}
diff --git a/sway/layout.c b/sway/layout.c
index 12b27987..35aa4942 100644
--- a/sway/layout.c
+++ b/sway/layout.c
@@ -161,10 +161,7 @@ void arrange_windows(swayc_t *container, double width, double height) {
                                 }
                         };
                         if (wlc_view_get_state(container->handle) & WLC_BIT_FULLSCREEN) {
-                                swayc_t *parent = container;
-                                while (parent->type != C_OUTPUT) {
-                                        parent = parent->parent;
-                                }
+                                swayc_t *parent = swayc_parent_by_type(container, C_OUTPUT);
                                 geometry.origin.x = 0;
                                 geometry.origin.y = 0;
                                 geometry.size.w = parent->width;
@@ -263,10 +260,7 @@ void arrange_windows(swayc_t *container, double width, double height) {
                                         }
                                 };
                                 if (wlc_view_get_state(view->handle) & WLC_BIT_FULLSCREEN) {
-                                        swayc_t *parent = view;
-                                        while (parent->type != C_OUTPUT) {
-                                                parent = parent->parent;
-                                        }
+                                        swayc_t *parent = swayc_parent_by_type(view, C_OUTPUT);
                                         geometry.origin.x = 0;
                                         geometry.origin.y = 0;
                                         geometry.size.w = parent->width;
diff --git a/sway/stringop.c b/sway/stringop.c
index 1dff97bf..c39e2c34 100644
--- a/sway/stringop.c
+++ b/sway/stringop.c
@@ -4,6 +4,7 @@
 #include "string.h"
 #include "list.h"
 #include <strings.h>
+#include <log.h>
 
 /* Note: This returns 8 characters for trimmed_start per tab character. */
 char *strip_whitespace(char *_str, int *trimmed_start) {
@@ -197,3 +198,41 @@ char *join_args(char **argv, int argc) {
         res[len - 1] = '\0';
         return res;
 }
+
+/*
+ * Join a list of strings, adding separator in between. Separator can be NULL.
+ */
+char *join_list(list_t *list, char *separator) {
+        if (!sway_assert(list != NULL, "list != NULL") || list->length == 0) {
+                return NULL;
+        }
+
+        size_t len = 1; // NULL terminator
+        size_t sep_len = 0;
+        if (separator != NULL) {
+                sep_len = strlen(separator);
+                len += (list->length - 1) * sep_len;
+        }
+
+        for (int i = 0; i < list->length; i++) {
+                len += strlen(list->items[i]);
+        }
+
+        char *res = malloc(len);
+
+        char *p = res + strlen(list->items[0]);
+        strcpy(res, list->items[0]);
+
+        for (int i = 1; i < list->length; i++) {
+                if (sep_len) {
+                        memcpy(p, separator, sep_len);
+                        p += sep_len;
+                }
+                strcpy(p, list->items[i]);
+                p += strlen(list->items[i]);
+        }
+
+        *p = '\0';
+
+        return res;
+}
diff --git a/sway/workspace.c b/sway/workspace.c
index 0f44d3b0..d436da8e 100644
--- a/sway/workspace.c
+++ b/sway/workspace.c
@@ -75,9 +75,7 @@ char *workspace_next_name(void) {
 
 swayc_t *workspace_create(const char* name) {
         swayc_t *parent = get_focused_container(&root_container);
-        while (parent->type != C_OUTPUT) {
-                parent = parent->parent;
-        }
+        parent = swayc_parent_by_type(parent, C_OUTPUT);
         return new_workspace(parent, name);
 }