add function for splitting node space, add function to remove client from tree

util.c

@@ -1,4 +1,6 @@
 #include "util.h"
+#include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 #include <assert.h>
 
@@ -17,6 +19,70 @@ bool wm_treenode_is_empty(TreeNode *node)
     return (node->children.size == 0);
 }
 
+void wm_treenode_split_space(TreeNode *node, Rect *ret1, Rect *ret2)
+{
+    assert(node);
+    assert(ret1);
+    assert(ret2);
+
+    switch (node->type) {
+    NODE_VERTICAL:
+        ret1->w = node->pos.w / 2;
+        ret1->h = node->pos.h;
+        ret2->w = node->pos.w / 2;
+        ret2->h = node->pos.h;
+
+        ret1->x = node->pos.x;
+        ret1->y = node->pos.y;
+
+        ret2->x = node->pos.x + ret1->w + 1;
+        ret2->y = node->pos.y;
+        return;
+    NODE_HORIZONTAL:
+        ret1->w = node->pos.w;
+        ret1->h = node->pos.h / 2;
+        ret2->w = node->pos.w;
+        ret2->h = node->pos.h / 2;
+
+        ret1->x = node->pos.x;
+        ret1->y = node->pos.y;
+
+        ret2->x = node->pos.x;
+        ret2->y = node->pos.y + ret1->h + 1;
+        return;
+    default:
+        fprintf(stderr, "wm: unhandled treenode type %d in %s, exiting.\n",
+                node->type, __func__);
+        abort();
+    }
+}
+
+void wm_treenode_remove_client(TreeNode *root, Client *client)
+{
+    TreeNode *client_node = wm_treenode_ptr_find_client_node(root, client);
+
+    if (client_node->parent == NULL) {
+        client_node->client = NULL;
+        wm_nodearray_clear(&client_node->children);
+        return;
+    }
+
+    TreeNode *parent = client_node->parent;
+    parent->type = NODE_CLIENT;
+    Client *other_client = NULL;
+
+    for (size_t i = 0; i < parent->children.size; i++) {
+        if (parent->children.nodes[i].type == NODE_CLIENT &&
+            parent->children.nodes[i].client != client) {
+            other_client = parent->children.nodes[i].client;
+        }
+    }
+
+    assert(other_client);
+    parent->client = other_client;
+    wm_nodearray_clear(&parent->children);
+}
+
 NodeArray wm_nodearray_new()
 {
     NodeArray arr;
@@ -80,6 +146,12 @@ bool wm_nodearray_pop_front(NodeArray *arr, TreeNode *ret)
     return true;
 }
 
+void wm_nodearray_clear(NodeArray *arr)
+{
+    arr->size = 0;
+    memset(arr->nodes, 0, arr->capacity * sizeof(TreeNode));
+}
+
 bool wm_nodearray_remove(NodeArray *arr, size_t index)
 {
     assert(arr);
@@ -298,6 +370,54 @@ ret:
     return ret;
 }
 
+TreeNode* wm_treenode_ptr_find_client_node(TreeNode *root, Client *client)
+{
+    assert(root);
+
+    TreeNode *ret = NULL;
+
+    NodeArray visited = wm_nodearray_new();
+    wm_nodearray_push(&visited, *root);
+
+    PtrArray queue = wm_ptrarray_new();
+
+    wm_ptrarray_push(&queue, root);
+
+    while (queue.size > 0) {
+        TreeNode *node;
+
+        if (!wm_ptrarray_pop_front(&queue, (void**)&node))
+            goto ret;
+
+        if (node->client == client) {
+            ret = node;
+            goto ret;
+        }
+
+        for (int i = 0; i < node->children.size; i++) {
+            TreeNode child_node = node->children.nodes[i];
+            bool _visited = false;
+
+            for (int j = 0; j < visited.size; j++) {
+                if (visited.nodes[j].children.nodes == child_node.children.nodes) {
+                    _visited = true;
+                    break;
+                }
+            }
+
+            if (!_visited) {
+                wm_nodearray_push(&visited, child_node);
+                wm_ptrarray_push(&queue, &child_node);
+            }
+        }
+    }
+
+ret:
+    wm_nodearray_free(&visited);
+    wm_ptrarray_free(&queue);
+    return ret;
+}
+
 ClientArray wm_clientarray_new()
 {
     ClientArray arr;

util.h

@@ -40,6 +40,13 @@ typedef struct {
     size_t capacity;
 } ClientArray;
 
+typedef struct {
+    int x;
+    int y;
+    int w;
+    int h;
+} Rect;
+
 struct TreeNode {
     NodeType type;
 
@@ -47,21 +54,21 @@ struct TreeNode {
 
     NodeArray children;
 
-    int x;
-    int y;
-    int w;
-    int h;
+    Rect pos;
 
     Client *client;
 };
 
 void wm_treenode_init(TreeNode *node, NodeType type, TreeNode *parent);
 bool wm_treenode_is_empty(TreeNode *node);
+void wm_treenode_split_space(TreeNode *node, Rect *ret1, Rect *ret2);
+void wm_treenode_remove_client(TreeNode *root, Client *client);
 
 NodeArray wm_nodearray_new();
 void wm_nodearray_push(NodeArray *arr, TreeNode node);
 bool wm_nodearray_pop(NodeArray *arr, TreeNode *ret);
 bool wm_nodearray_pop_front(NodeArray *arr, TreeNode *ret);
+void wm_nodearray_clear(NodeArray *arr);
 bool wm_nodearray_remove(NodeArray *arr, size_t index);
 void wm_nodearray_free(NodeArray *arr);
 ClientArray wm_nodearray_find_clients(TreeNode *root);
@@ -74,6 +81,7 @@ bool wm_ptrarray_pop_front(PtrArray *arr, void **ret);
 bool wm_ptrarray_remove(PtrArray *arr, size_t index);
 void wm_ptrarray_free(PtrArray *arr);
 TreeNode* wm_treenode_ptr_find_focused_client_node(TreeNode *root);
+TreeNode* wm_treenode_ptr_find_client_node(TreeNode *root, Client *client);
 
 ClientArray wm_clientarray_new();
 void wm_clientarray_push(ClientArray *arr, Client node);