add PtrArray struct and functions, add function to find focused treenode

util.c

@@ -12,6 +12,11 @@ void wm_treenode_init(TreeNode *node, NodeType type, TreeNode *parent)
     wm_nodearray_new();
 }
 
+bool wm_treenode_is_empty(TreeNode *node)
+{
+    return (node->children.size == 0);
+}
+
 NodeArray wm_nodearray_new()
 {
     NodeArray arr;
@@ -153,6 +158,146 @@ ret:
     return clients;
 }
 
+PtrArray wm_ptrarray_new()
+{
+    PtrArray arr;
+
+    arr.capacity = 10;
+    arr.ptrs = calloc(arr.capacity, sizeof(TreeNode));
+    arr.size = 0;
+
+    return arr;
+}
+
+void wm_ptrarray_push(PtrArray *arr, void* ptr)
+{
+    assert(arr);
+
+    arr->size++;
+
+    if (arr->size >= arr->capacity) {
+        TreeNode* temp = calloc(arr->capacity, sizeof(TreeNode));
+        memcpy(temp, arr->ptrs, arr->capacity * sizeof(TreeNode));
+        free(arr->ptrs);
+        size_t old_capacity = arr->capacity;
+        arr->capacity = old_capacity * 2;
+
+        arr->ptrs = calloc(arr->capacity, sizeof(TreeNode));
+        memcpy(arr->ptrs, temp, old_capacity);
+
+        free(temp);
+        arr->ptrs[arr->size - 1] = ptr;
+        return;
+    }
+
+    arr->ptrs[arr->size - 1] = ptr;
+}
+
+bool wm_ptrarray_pop(PtrArray *arr, void **ret)
+{
+    assert(arr);
+    assert(ret);
+
+    if (arr->size == 0)
+        return false;
+
+    *ret = arr->ptrs[arr->size - 1];
+    arr->size--;
+    return true;
+}
+
+bool wm_ptrarray_pop_front(PtrArray *arr, void **ret)
+{
+    assert(arr);
+    assert(ret);
+
+    if (arr->size == 0)
+        return false;
+
+    *ret = arr->ptrs[0];
+    arr->size--;
+    memcpy(arr->ptrs, arr->ptrs+1, arr->size * sizeof(TreeNode));
+
+    return true;
+}
+
+bool wm_ptrarray_remove(PtrArray *arr, size_t index)
+{
+    assert(arr);
+
+    if (!arr)
+        return false;
+
+    if (index >= arr->size)
+        return false;
+
+    if (index == arr->size - 1) {
+        arr->size--;
+        return true;
+    }
+
+    memmove(arr->ptrs + index, arr->ptrs + index+1, arr->size-1 * sizeof(TreeNode));
+
+    return true;
+}
+
+void wm_ptrarray_free(PtrArray *arr)
+{
+    assert(arr);
+
+    arr->capacity = 0;
+    arr->size = 0;
+    free(arr->ptrs);
+}
+
+TreeNode* wm_treenode_ptr_find_focused_client_node(TreeNode *root)
+{
+    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->type == NODE_CLIENT && node->client->focused) {
+            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

@@ -28,6 +28,12 @@ typedef struct {
     size_t capacity;
 } NodeArray;
 
+typedef struct {
+    void **ptrs;
+    size_t size;
+    size_t capacity;
+} PtrArray;
+
 typedef struct {
     Client *clients;
     size_t size;
@@ -50,6 +56,7 @@ struct TreeNode {
 };
 
 void wm_treenode_init(TreeNode *node, NodeType type, TreeNode *parent);
+bool wm_treenode_is_empty(TreeNode *node);
 
 NodeArray wm_nodearray_new();
 void wm_nodearray_push(NodeArray *arr, TreeNode node);
@@ -59,6 +66,15 @@ bool wm_nodearray_remove(NodeArray *arr, size_t index);
 void wm_nodearray_free(NodeArray *arr);
 ClientArray wm_nodearray_find_clients(TreeNode *root);
 
+
+PtrArray wm_ptrarray_new();
+void wm_ptrarray_push(PtrArray *arr, void* ptr);
+bool wm_ptrarray_pop(PtrArray *arr, void **ret);
+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);
+
 ClientArray wm_clientarray_new();
 void wm_clientarray_push(ClientArray *arr, Client node);
 bool wm_clientarray_pop(ClientArray *arr, Client *ret);