koma/wm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rewrite NodeArray: use heap allocated struct pointer, remove unused ClientArray functions

Browse Source
This commit is contained in:
Akos Horvath
2023-12-29 19:08:58 +01:00
parent ff1c32bb33
commit 70d06f7888
5 changed files with 322 additions and 437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/client.c
View File

@ -41,11 +41,11 @@ XWindowChanges wm_client_to_xwchanges(Client *c)
Client* wm_client_find(Wm *wm, Window w) Client* wm_client_find(Wm *wm, Window w)
{ {
PtrArray clients = wm_treenode_find_client_nodes_ptr(wm->smon->workspaces[wm->smon->selws].tree); NodeArray *clients = wm_treenode_find_client_nodes(CURRENT_WS(wm).tree);
Client *ret = NULL; Client *ret = NULL;
for (size_t i = 0; i < clients.size; i++) { for (size_t i = 0; i < clients->size; i++) {
Client *c = ((TreeNode*)clients.ptrs[i])->client; Client *c = ((TreeNode*)clients->nodes[i])->client;
if (c->window == w) { if (c->window == w) {
ret = c; ret = c;
goto ret; goto ret;
@ -53,7 +53,7 @@ Client* wm_client_find(Wm *wm, Window w)
} }
ret: ret:
wm_ptrarray_free(&clients); wm_nodearray_free(clients);
return ret; return ret;
} }
@ -367,7 +367,7 @@ Client* wm_client_get_dir_rel_c(Client *c, int dir)
return NULL; return NULL;
} }
PtrArray client_nodes = wm_treenode_find_client_nodes_ptr(c->ws->tree); NodeArray *client_nodes = wm_treenode_find_client_nodes(c->ws->tree);
x+=dx*5; x+=dx*5;
y+=dy*5; y+=dy*5;
@ -375,8 +375,8 @@ Client* wm_client_get_dir_rel_c(Client *c, int dir)
x+=dx*2; x+=dx*2;
y+=dy*2; y+=dy*2;
for (size_t i = 0; i < client_nodes.size; i++) { for (size_t i = 0; i < client_nodes->size; i++) {
Client *r = ((TreeNode**)client_nodes.ptrs)[i]->client; Client *r = ((TreeNode**)client_nodes->nodes)[i]->client;
if ((x > r->x && x < r->x+r->w) && (y > r->y && y < r->y+r->h)) { if ((x > r->x && x < r->x+r->w) && (y > r->y && y < r->y+r->h)) {
DEBUG_PRINT("%s ", __func__) DEBUG_PRINT("%s ", __func__)
DEBUG_PRINT("found window %d in direction ", (int)c->window) DEBUG_PRINT("found window %d in direction ", (int)c->window)
@ -390,7 +390,7 @@ Client* wm_client_get_dir_rel_c(Client *c, int dir)
(y > 0 && y < c->m->info.height)); (y > 0 && y < c->m->info.height));
ret: ret:
wm_ptrarray_free(&client_nodes); wm_nodearray_free(client_nodes);
DEBUG_PRINT("%s returning %p\n", __func__, (void*)ret); DEBUG_PRINT("%s returning %p\n", __func__, (void*)ret);
return ret; return ret;
} }
@ -438,18 +438,18 @@ void wm_monitor_clients_border(Wm *wm, Monitor *m)
{ {
DEBUG_PRINT("%s\n", __func__) DEBUG_PRINT("%s\n", __func__)
RETURN_IF_NULL(m); RETURN_IF_NULL(m);
PtrArray clients = wm_treenode_find_client_nodes_ptr(m->workspaces[m->selws].tree); NodeArray *clients = wm_treenode_find_client_nodes(m->workspaces[m->selws].tree);
if (clients.size == 0) if (clients->size == 0)
return; return;
for (size_t i = 0; i < clients.size; i++) { for (size_t i = 0; i < clients->size; i++) {
Client *client = ((TreeNode*)clients.ptrs[i])->client; Client *client = ((TreeNode*)clients->nodes[i])->client;
DEBUG_PRINT("monitor border c: %p\n", (void*)client) DEBUG_PRINT("monitor border c: %p\n", (void*)client)
DEBUG_PRINT("monitor border c window: %ld\n", client->window) DEBUG_PRINT("monitor border c window: %ld\n", client->window)
wm_client_border(wm, client); wm_client_border(wm, client);
} }
wm_ptrarray_free(&clients); wm_nodearray_free(clients);
} }
bool wm_client_is_focused(Wm *wm, Client *c) bool wm_client_is_focused(Wm *wm, Client *c)

270
src/tests.c
View File

@ -7,18 +7,7 @@
// store a copy of the nodes created in test2_setup, to check if any // store a copy of the nodes created in test2_setup, to check if any
// of the tests modified them // of the tests modified them
static PtrArray test_group2_nodes_copy = {0}; static NodeArray *test_group2_nodes_copy = NULL;
static void test_wm_treenode_new(void **state)
{
TreeNode *node = wm_treenode_new(NODE_VERTICAL, NULL);
assert_null(node->client);
assert_non_null(node->children.nodes);
assert_int_equal(node->children.size, 0);
assert_int_equal(node->type, NODE_VERTICAL);
wm_treenode_free(node);
}
static void test_wm_nodearray_push(void **state) static void test_wm_nodearray_push(void **state)
{ {
@ -30,51 +19,90 @@ static void test_wm_nodearray_push(void **state)
assert_null(node->parent); assert_null(node->parent);
assert_ptr_equal(node1->parent, node); assert_ptr_equal(node1->parent, node);
wm_nodearray_push(&node->children, node1); wm_nodearray_push(node->children, node1);
assert_int_equal(node->children.size, 1); assert_int_equal(node->children->size, 1);
assert_ptr_equal(node->children.nodes[0], node1); assert_ptr_equal(node->children->nodes[0], node1);
assert_int_equal(node1->id, 123); assert_int_equal(node1->id, 123);
assert_int_equal(node->children.nodes[0]->id, 123); assert_int_equal(node->children->nodes[0]->id, 123);
wm_treenode_free(node); wm_treenode_free(node);
wm_treenode_free(node1); wm_treenode_free(node1);
} }
static void test_wm_find_client_nodes_ptr(void **state) static void test_wm_treenode_new(void **state)
{ {
TreeNode *root = wm_treenode_new(NODE_VERTICAL, NULL); TreeNode *node = wm_treenode_new(NODE_VERTICAL, NULL);
TreeNode *node1 = wm_treenode_new(NODE_CLIENT, NULL); assert_null(node->client);
TreeNode *node2 = wm_treenode_new(NODE_CLIENT, NULL); assert_non_null(node->children->nodes);
assert_int_equal(node->children->size, 0);
assert_int_equal(node->type, NODE_VERTICAL);
node1->client = (Client*)0x123; wm_treenode_free(node);
node2->client = (Client*)0x456;
const unsigned long ids[] = {123, 456};
node1->id = ids[0];
node2->id = ids[1];
wm_nodearray_push(&root->children, node1);
wm_nodearray_push(&root->children, node2);
assert_int_equal(root->children.size, 2);
assert_ptr_equal(root->children.nodes[0], node1);
assert_ptr_equal(root->children.nodes[1], node2);
PtrArray client_ptrs = wm_treenode_find_client_nodes_ptr(root);
assert_int_equal(client_ptrs.size, 2);
assert_in_set(((TreeNode*)client_ptrs.ptrs[0])->id, ids, 2);
assert_in_set(((TreeNode*)client_ptrs.ptrs[1])->id, ids, 2);
wm_treenode_free(root);
wm_treenode_free(node1);
wm_treenode_free(node2);
wm_ptrarray_free(&client_ptrs);
} }
static void test_wm_all_nodes_to_ptrarray(void **state) static void test_wm_treenode_split_space(void **state)
{
/* vertical */
TreeNode *parent = wm_treenode_new(NODE_VERTICAL, NULL);
parent->pos.x = 0;
parent->pos.y = 0;
parent->pos.w = 200;
parent->pos.h = 200;
TreeNode *child1 = wm_treenode_new(NODE_CLIENT, parent);
TreeNode *child2 = wm_treenode_new(NODE_CLIENT, parent);
wm_treenode_split_space(parent, &child1->pos, &child2->pos);
assert_int_equal(child1->pos.x, 0);
assert_int_equal(child1->pos.y, 0);
assert_int_equal(child1->pos.w, 100);
assert_int_equal(child1->pos.h, 200);
assert_int_equal(child2->pos.x, 100);
assert_int_equal(child2->pos.y, 0);
assert_int_equal(child2->pos.w, 100);
assert_int_equal(child2->pos.h, 200);
wm_treenode_free(parent);
wm_treenode_free(child1);
wm_treenode_free(child2);
/* horizontal */
parent = wm_treenode_new(NODE_HORIZONTAL, NULL);
parent->pos.x = 0;
parent->pos.y = 0;
parent->pos.w = 200;
parent->pos.h = 200;
child1 = wm_treenode_new(NODE_CLIENT, parent);
child2 = wm_treenode_new(NODE_CLIENT, parent);
wm_treenode_split_space(parent, &child1->pos, &child2->pos);
assert_int_equal(child1->pos.x, 0);
assert_int_equal(child1->pos.y, 0);
assert_int_equal(child1->pos.w, 200);
assert_int_equal(child1->pos.h, 100);
assert_int_equal(child2->pos.x, 0);
assert_int_equal(child2->pos.y, 100);
assert_int_equal(child2->pos.w, 200);
assert_int_equal(child2->pos.h, 100);
wm_treenode_free(parent);
wm_treenode_free(child1);
wm_treenode_free(child2);
}
static void test_wm_all_nodes_to_array(void **state)
{ {
TreeNode *root = wm_treenode_new(NODE_VERTICAL, NULL); TreeNode *root = wm_treenode_new(NODE_VERTICAL, NULL);
TreeNode *node1 = wm_treenode_new(NODE_CLIENT, NULL); TreeNode *node1 = wm_treenode_new(NODE_CLIENT, NULL);
@ -88,28 +116,61 @@ static void test_wm_all_nodes_to_ptrarray(void **state)
node2->id = ids[2]; node2->id = ids[2];
node3->id = ids[3]; node3->id = ids[3];
wm_nodearray_push(&root->children, node1); wm_nodearray_push(root->children, node1);
wm_nodearray_push(&root->children, node2); wm_nodearray_push(root->children, node2);
wm_nodearray_push(&root->children, node3); wm_nodearray_push(root->children, node3);
assert_int_equal(root->children.size, 3); assert_int_equal(root->children->size, 3);
assert_ptr_equal(root->children.nodes[0], node1); assert_ptr_equal(root->children->nodes[0], node1);
assert_ptr_equal(root->children.nodes[1], node2); assert_ptr_equal(root->children->nodes[1], node2);
assert_ptr_equal(root->children.nodes[2], node3); assert_ptr_equal(root->children->nodes[2], node3);
PtrArray all_nodes = wm_all_nodes_to_ptrarray(root); NodeArray *all_nodes = wm_all_nodes_to_array(root);
assert_int_equal(all_nodes.size, 4); assert_int_equal(all_nodes->size, 4);
assert_in_set(((TreeNode*)all_nodes.ptrs[0])->id, ids, 4); assert_in_set(((TreeNode*)all_nodes->nodes[0])->id, ids, 4);
assert_in_set(((TreeNode*)all_nodes.ptrs[1])->id, ids, 4); assert_in_set(((TreeNode*)all_nodes->nodes[1])->id, ids, 4);
assert_in_set(((TreeNode*)all_nodes.ptrs[2])->id, ids, 4); assert_in_set(((TreeNode*)all_nodes->nodes[2])->id, ids, 4);
assert_in_set(((TreeNode*)all_nodes.ptrs[3])->id, ids, 4); assert_in_set(((TreeNode*)all_nodes->nodes[3])->id, ids, 4);
wm_treenode_free(root); wm_treenode_free(root);
wm_treenode_free(node1); wm_treenode_free(node1);
wm_treenode_free(node2); wm_treenode_free(node2);
wm_treenode_free(node3); wm_treenode_free(node3);
wm_ptrarray_free(&all_nodes); wm_nodearray_free(all_nodes);
}
static void test_wm_find_client_nodes(void **state)
{
TreeNode *root = wm_treenode_new(NODE_VERTICAL, NULL);
TreeNode *node1 = wm_treenode_new(NODE_CLIENT, NULL);
TreeNode *node2 = wm_treenode_new(NODE_CLIENT, NULL);
node1->client = (Client*)0x123;
node2->client = (Client*)0x456;
const unsigned long ids[] = {123, 456};
node1->id = ids[0];
node2->id = ids[1];
wm_nodearray_push(root->children, node1);
wm_nodearray_push(root->children, node2);
assert_int_equal(root->children->size, 2);
assert_ptr_equal(root->children->nodes[0], node1);
assert_ptr_equal(root->children->nodes[1], node2);
NodeArray *client_nodes = wm_treenode_find_client_nodes(root);
assert_int_equal(client_nodes->size, 2);
assert_in_set((client_nodes->nodes[0])->id, ids, 2);
assert_in_set((client_nodes->nodes[1])->id, ids, 2);
wm_treenode_free(root);
wm_treenode_free(node1);
wm_treenode_free(node2);
wm_nodearray_free(client_nodes);
} }
static void test_wm_postorder_traversal(void **state) static void test_wm_postorder_traversal(void **state)
@ -136,13 +197,13 @@ static void test_wm_postorder_traversal(void **state)
static void test_wm_treenode_lmd(void **state) static void test_wm_treenode_lmd(void **state)
{ {
TreeNode *node1 = (TreeNode*)*state; TreeNode *node1 = (TreeNode*)*state;
TreeNode *node2 = node1->children.nodes[0]; TreeNode *node2 = node1->children->nodes[0];
TreeNode *node3 = node1->children.nodes[1]; TreeNode *node3 = node1->children->nodes[1];
TreeNode *node4 = node2->children.nodes[0]; TreeNode *node4 = node2->children->nodes[0];
TreeNode *node5 = node2->children.nodes[1]; TreeNode *node5 = node2->children->nodes[1];
TreeNode *node6 = node2->children.nodes[2]; TreeNode *node6 = node2->children->nodes[2];
TreeNode *node7 = node3->children.nodes[0]; TreeNode *node7 = node3->children->nodes[0];
TreeNode *node8 = node3->children.nodes[1]; TreeNode *node8 = node3->children->nodes[1];
assert_int_equal(wm_treenode_lmd(node1)->id, node4->id); assert_int_equal(wm_treenode_lmd(node1)->id, node4->id);
assert_int_equal(wm_treenode_lmd(node2)->id, node4->id); assert_int_equal(wm_treenode_lmd(node2)->id, node4->id);
@ -225,13 +286,13 @@ static int test2_setup(void **state)
TreeNode *node7 = wm_treenode_new(NODE_VERTICAL, node3); TreeNode *node7 = wm_treenode_new(NODE_VERTICAL, node3);
TreeNode *node8 = wm_treenode_new(NODE_VERTICAL, node3); TreeNode *node8 = wm_treenode_new(NODE_VERTICAL, node3);
wm_nodearray_push(&node1->children, node2); wm_nodearray_push(node1->children, node2);
wm_nodearray_push(&node1->children, node3); wm_nodearray_push(node1->children, node3);
wm_nodearray_push(&node2->children, node4); wm_nodearray_push(node2->children, node4);
wm_nodearray_push(&node2->children, node5); wm_nodearray_push(node2->children, node5);
wm_nodearray_push(&node2->children, node6); wm_nodearray_push(node2->children, node6);
wm_nodearray_push(&node3->children, node7); wm_nodearray_push(node3->children, node7);
wm_nodearray_push(&node3->children, node8); wm_nodearray_push(node3->children, node8);
node1->id = 1; node1->id = 1;
node2->id = 2; node2->id = 2;
@ -251,54 +312,54 @@ static int test2_setup(void **state)
assert_ptr_equal(node7->parent, node3); assert_ptr_equal(node7->parent, node3);
assert_ptr_equal(node8->parent, node3); assert_ptr_equal(node8->parent, node3);
assert_int_equal(node1->children.size, 2); assert_int_equal(node1->children->size, 2);
assert_int_equal(node2->children.size, 3); assert_int_equal(node2->children->size, 3);
assert_int_equal(node3->children.size, 2); assert_int_equal(node3->children->size, 2);
assert_int_equal(node1->id, 1); assert_int_equal(node1->id, 1);
assert_int_equal(node1->children.nodes[0]->id, 2); assert_int_equal(node1->children->nodes[0]->id, 2);
assert_int_equal(node1->children.nodes[1]->id, 3); assert_int_equal(node1->children->nodes[1]->id, 3);
assert_int_equal(node2->children.nodes[0]->id, 4); assert_int_equal(node2->children->nodes[0]->id, 4);
assert_int_equal(node2->children.nodes[1]->id, 5); assert_int_equal(node2->children->nodes[1]->id, 5);
assert_int_equal(node2->children.nodes[2]->id, 6); assert_int_equal(node2->children->nodes[2]->id, 6);
assert_int_equal(node3->children.nodes[0]->id, 7); assert_int_equal(node3->children->nodes[0]->id, 7);
assert_int_equal(node3->children.nodes[1]->id, 8); assert_int_equal(node3->children->nodes[1]->id, 8);
*state = node1; *state = node1;
PtrArray nodes = wm_all_nodes_to_ptrarray((TreeNode*)*state); NodeArray *nodes = wm_all_nodes_to_array((TreeNode*)*state);
PtrArray nodes_copy = wm_ptrarray_new(); test_group2_nodes_copy = wm_nodearray_new();
for (size_t i = 0; i < nodes.size; i++) { for (size_t i = 0; i < nodes->size; i++) {
TreeNode *node_copy = malloc(sizeof(TreeNode)); TreeNode *node_copy = malloc(sizeof(TreeNode));
*node_copy = *((TreeNode**)nodes.ptrs)[i]; *node_copy = *(nodes->nodes)[i];
wm_ptrarray_push(&nodes_copy, node_copy); wm_nodearray_push(test_group2_nodes_copy, node_copy);
} }
test_group2_nodes_copy = nodes_copy; wm_nodearray_free(nodes);
wm_ptrarray_free(&nodes);
return 0; return 0;
} }
static int test2_teardown(void **state) static int test2_teardown(void **state)
{ {
PtrArray nodes = wm_all_nodes_to_ptrarray((TreeNode*)*state); NodeArray *nodes = wm_all_nodes_to_array((TreeNode*)*state);
assert_non_null(test_group2_nodes_copy);
// check if any of the original nodes were modified // check if any of the original nodes were modified
for (size_t i = 0; i < test_group2_nodes_copy.size; i++) { for (size_t i = 0; i < test_group2_nodes_copy->size; i++) {
TreeNode *node_copy = ((TreeNode**)test_group2_nodes_copy.ptrs)[i]; TreeNode *node_copy = ((TreeNode**)test_group2_nodes_copy->nodes)[i];
assert_memory_equal(node_copy, nodes.ptrs[i], sizeof(TreeNode)); assert_memory_equal(node_copy, nodes->nodes[i], sizeof(TreeNode));
} }
for (size_t i = 0; i < nodes.size; i++) { for (size_t i = 0; i < nodes->size; i++) {
wm_treenode_free(nodes.ptrs[i]); wm_treenode_free(nodes->nodes[i]);
free((TreeNode*)test_group2_nodes_copy.ptrs[i]); free((TreeNode*)test_group2_nodes_copy->nodes[i]);
} }
wm_ptrarray_free(&nodes); wm_nodearray_free(nodes);
wm_ptrarray_free(&test_group2_nodes_copy); wm_nodearray_free(test_group2_nodes_copy);
return 0; return 0;
} }
@ -306,10 +367,11 @@ static int test2_teardown(void **state)
int main(void) int main(void)
{ {
const struct CMUnitTest test_group1[] = { const struct CMUnitTest test_group1[] = {
cmocka_unit_test(test_wm_treenode_new),
cmocka_unit_test(test_wm_nodearray_push), cmocka_unit_test(test_wm_nodearray_push),
cmocka_unit_test(test_wm_find_client_nodes_ptr), cmocka_unit_test(test_wm_treenode_new),
cmocka_unit_test(test_wm_all_nodes_to_ptrarray), cmocka_unit_test(test_wm_treenode_split_space),
cmocka_unit_test(test_wm_all_nodes_to_array),
cmocka_unit_test(test_wm_find_client_nodes),
}; };
const struct CMUnitTest test_group2[] = { const struct CMUnitTest test_group2[] = {

386
src/util.c
View File

@ -29,15 +29,15 @@ TreeNode* wm_treenode_new(NodeType type, TreeNode *parent)
void wm_treenode_free(TreeNode *node) void wm_treenode_free(TreeNode *node)
{ {
wm_nodearray_clear(&node->children); wm_nodearray_clear(node->children);
__wm_nodearray_free(&node->children); wm_nodearray_free(node->children);
free(node); free(node);
} }
bool wm_treenode_is_empty(TreeNode *node) bool wm_treenode_is_empty(TreeNode *node)
{ {
DEBUG_PRINT("%s\n", __func__); DEBUG_PRINT("%s\n", __func__);
return (node->children.size == 0); return (node->children->size == 0);
} }
void wm_treenode_split_space(TreeNode *node, Rect *ret1, Rect *ret2) void wm_treenode_split_space(TreeNode *node, Rect *ret1, Rect *ret2)
@ -83,10 +83,10 @@ void wm_treenode_recalculate_space(TreeNode *node)
{ {
assert(node); assert(node);
assert(node->children.size == 2); assert(node->children->size == 2);
wm_treenode_split_space(node, &node->children.nodes[0]->pos, wm_treenode_split_space(node, &node->children->nodes[0]->pos,
&node->children.nodes[1]->pos); &node->children->nodes[1]->pos);
} }
void wm_treenode_swap(TreeNode *root, TreeNode *node1, TreeNode* node2) void wm_treenode_swap(TreeNode *root, TreeNode *node1, TreeNode* node2)
@ -135,8 +135,8 @@ char* wm_treenode_to_str(TreeNode *node)
json_object_object_add(jobj, "parent", json_object_new_uint64((uint64_t)node->parent)); json_object_object_add(jobj, "parent", json_object_new_uint64((uint64_t)node->parent));
json_object_object_add(jobj, "children", json_object_new_array()); json_object_object_add(jobj, "children", json_object_new_array());
for (size_t i = 0; i < node->children.size; i++) { for (size_t i = 0; i < node->children->size; i++) {
char *child_str = wm_treenode_to_str(node->children.nodes[i]); char *child_str = wm_treenode_to_str(node->children->nodes[i]);
json_object_array_add(json_object_object_get(jobj, "children"), json_object_array_add(json_object_object_get(jobj, "children"),
json_tokener_parse(child_str)); json_tokener_parse(child_str));
free(child_str); free(child_str);
@ -225,9 +225,9 @@ TreeNode* wm_treenode_lmd(TreeNode *node)
{ {
assert(node); assert(node);
if (node->children.size == 0) return node; if (node->children->size == 0) return node;
return wm_treenode_lmd(node->children.nodes[0]); return wm_treenode_lmd(node->children->nodes[0]);
} }
PtrArray wm_treenode_all_lmds(TreeNode *node) PtrArray wm_treenode_all_lmds(TreeNode *node)
@ -271,8 +271,8 @@ PtrArray wm_postorder_traversal(TreeNode *tree)
wm_ptrarray_push(&stack, n); wm_ptrarray_push(&stack, n);
root_index = 0; root_index = 0;
if (root->children.size >= 1) if (root->children->size >= 1)
root = root->children.nodes[0]; root = root->children->nodes[0];
else root = NULL; else root = NULL;
continue; continue;
@ -285,7 +285,7 @@ PtrArray wm_postorder_traversal(TreeNode *tree)
wm_ptrarray_push(&ret, n.node); wm_ptrarray_push(&ret, n.node);
while (stack.size > 0 && n.index == ((NodeWithIndex**)stack.ptrs) while (stack.size > 0 && n.index == ((NodeWithIndex**)stack.ptrs)
[stack.size-1]->node->children.size - 1) { [stack.size-1]->node->children->size - 1) {
wm_ptrarray_pop(&stack, (void**)&nptr); wm_ptrarray_pop(&stack, (void**)&nptr);
n = *nptr; n = *nptr;
free(nptr); free(nptr);
@ -295,7 +295,7 @@ PtrArray wm_postorder_traversal(TreeNode *tree)
if (stack.size > 0) { if (stack.size > 0) {
root = ((NodeWithIndex**)stack.ptrs)[stack.size-1]->node root = ((NodeWithIndex**)stack.ptrs)[stack.size-1]->node
->children.nodes[n.index + 1]; ->children->nodes[n.index + 1];
root_index = n.index + 1; root_index = n.index + 1;
} }
} }
@ -346,36 +346,36 @@ void wm_tree_to_DOT(TreeNode *root, const char *filename)
fprintf(fp, "digraph {\n"); fprintf(fp, "digraph {\n");
PtrArray all_nodes = wm_all_nodes_to_ptrarray(root); NodeArray *all_nodes = wm_all_nodes_to_array(root);
NodeArray printed_nodes = wm_nodearray_new(); NodeArray *printed_nodes = wm_nodearray_new();
const int bufsize = 100; const int bufsize = 100;
char buf1[bufsize]; char buf1[bufsize];
char buf2[bufsize]; char buf2[bufsize];
for (size_t i = 0; i < all_nodes.size; i++) { for (size_t i = 0; i < all_nodes->size; i++) {
TreeNode *node = all_nodes.ptrs[i]; TreeNode *node = all_nodes->nodes[i];
bool contains = false; bool contains = false;
for (size_t j = 0; j < printed_nodes.size; j++) { for (size_t j = 0; j < printed_nodes->size; j++) {
if (printed_nodes.nodes[j]->id == node->id) if (printed_nodes->nodes[j]->id == node->id)
contains = true; contains = true;
} }
if (contains) if (contains)
continue; continue;
for (size_t j = 0; j < node->children.size; j++) { for (size_t j = 0; j < node->children->size; j++) {
memset(buf1, 0, bufsize); memset(buf1, 0, bufsize);
memset(buf2, 0, bufsize); memset(buf2, 0, bufsize);
wm_node_type_to_str(node->type, buf1, bufsize); wm_node_type_to_str(node->type, buf1, bufsize);
wm_node_type_to_str(node->children.nodes[j]->type, buf2, bufsize); wm_node_type_to_str(node->children->nodes[j]->type, buf2, bufsize);
fprintf(fp, "_%d_%s -> _%d_%s;\n", node->id, buf1, fprintf(fp, "_%d_%s -> _%d_%s;\n", node->id, buf1,
node->children.nodes[j]->id, buf2); node->children->nodes[j]->id, buf2);
} }
wm_nodearray_push(&printed_nodes, node); wm_nodearray_push(printed_nodes, node);
} }
fprintf(fp, "}"); fprintf(fp, "}");
@ -383,14 +383,14 @@ void wm_tree_to_DOT(TreeNode *root, const char *filename)
fflush(fp); fflush(fp);
fclose(fp); fclose(fp);
__wm_nodearray_free(&printed_nodes); wm_nodearray_free(printed_nodes);
wm_ptrarray_free(&all_nodes); wm_nodearray_free(all_nodes);
} }
int wm_get_node_index(TreeNode *parent, unsigned int node_id) int wm_get_node_index(TreeNode *parent, unsigned int node_id)
{ {
for (size_t i = 0; i < parent->children.size; i++) { for (size_t i = 0; i < parent->children->size; i++) {
if (node_id == parent->children.nodes[i]->id) if (node_id == parent->children->nodes[i]->id)
return i; return i;
} }
@ -412,15 +412,15 @@ void wm_treenode_remove_node(Wm *wm, TreeNode *root, TreeNode *node)
return; return;
} }
for (size_t i = 0; i < parent->children.size; i++) { for (size_t i = 0; i < parent->children->size; i++) {
if (parent->children.nodes[i]->type == NODE_CLIENT && if (parent->children->nodes[i]->type == NODE_CLIENT &&
parent->children.nodes[i] != node) { parent->children->nodes[i] != node) {
parent->type = NODE_CLIENT; parent->type = NODE_CLIENT;
parent->client = parent->children.nodes[i]->client; parent->client = parent->children->nodes[i]->client;
wm_treenode_free(node); wm_treenode_free(node);
wm_treenode_free(parent->children.nodes[i]); wm_treenode_free(parent->children->nodes[i]);
wm_nodearray_clear(&parent->children); wm_nodearray_clear(parent->children);
return; return;
} }
} }
@ -448,28 +448,28 @@ void wm_treenode_remove_node(Wm *wm, TreeNode *root, TreeNode *node)
.h = node->client->ws->monitor->info.height - wm->config.border_width*2 - dock_y, .h = node->client->ws->monitor->info.height - wm->config.border_width*2 - dock_y,
}; };
assert(node->client->ws->tree->children.size == 2); assert(node->client->ws->tree->children->size == 2);
wm_treenode_split_space(node->client->ws->tree, &node->client->ws->tree->children.nodes[0]->pos, wm_treenode_split_space(node->client->ws->tree, &node->client->ws->tree->children->nodes[0]->pos,
&node->client->ws->tree->children.nodes[1]->pos); &node->client->ws->tree->children->nodes[1]->pos);
} else { } else {
sibling_node->parent = parent->parent; sibling_node->parent = parent->parent;
*parent = *sibling_node; *parent = *sibling_node;
for (size_t i = 0; i < parent->children.size; i++) { for (size_t i = 0; i < parent->children->size; i++) {
parent->children.nodes[i]->parent = parent; parent->children->nodes[i]->parent = parent;
} }
wm_treenode_recalculate_space(parent->parent); wm_treenode_recalculate_space(parent->parent);
wm_treenode_recalculate_space(parent); wm_treenode_recalculate_space(parent);
} }
assert(node->client->ws->tree->children.size >= 1); assert(node->client->ws->tree->children->size >= 1);
} }
TreeNode* wm_treenode_split_get_sibling(TreeNode *node) TreeNode* wm_treenode_split_get_sibling(TreeNode *node)
{ {
for (size_t i = 0; i < node->parent->children.size; i++) { for (size_t i = 0; i < node->parent->children->size; i++) {
TreeNode *sibling_node = node->parent->children.nodes[i]; TreeNode *sibling_node = node->parent->children->nodes[i];
if (sibling_node->id != node->id) { if (sibling_node->id != node->id) {
return sibling_node; return sibling_node;
} }
@ -492,15 +492,15 @@ TreeNode* wm_treenode_remove_client(Wm *wm, TreeNode *root, Client *client)
TreeNode *node = client_node->parent; TreeNode *node = client_node->parent;
for (size_t i = 0; i < node->children.size; i++) { for (size_t i = 0; i < node->children->size; i++) {
if (node->children.nodes[i]->type == NODE_CLIENT && if (node->children->nodes[i]->type == NODE_CLIENT &&
node->children.nodes[i]->client != client) { node->children->nodes[i]->client != client) {
node->type = NODE_CLIENT; node->type = NODE_CLIENT;
node->client = node->children.nodes[i]->client; node->client = node->children->nodes[i]->client;
wm_treenode_free(client_node); wm_treenode_free(client_node);
wm_treenode_free(node->children.nodes[i]); wm_treenode_free(node->children->nodes[i]);
wm_nodearray_clear(&node->children); wm_nodearray_clear(node->children);
return node; return node;
} }
} }
@ -527,32 +527,32 @@ TreeNode* wm_treenode_remove_client(Wm *wm, TreeNode *root, Client *client)
.h = client->ws->monitor->info.height - wm->config.border_width*2 - dock_y, .h = client->ws->monitor->info.height - wm->config.border_width*2 - dock_y,
}; };
assert(client->ws->tree->children.size == 2); assert(client->ws->tree->children->size == 2);
wm_treenode_split_space(client->ws->tree, &client->ws->tree->children.nodes[0]->pos, wm_treenode_split_space(client->ws->tree, &client->ws->tree->children->nodes[0]->pos,
&client->ws->tree->children.nodes[1]->pos); &client->ws->tree->children->nodes[1]->pos);
} else { } else {
sibling_node->parent = node->parent; sibling_node->parent = node->parent;
*node = *sibling_node; *node = *sibling_node;
for (size_t i = 0; i < node->children.size; i++) { for (size_t i = 0; i < node->children->size; i++) {
node->children.nodes[i]->parent = node; node->children->nodes[i]->parent = node;
} }
wm_treenode_recalculate_space(node->parent); wm_treenode_recalculate_space(node->parent);
wm_treenode_recalculate_space(node); wm_treenode_recalculate_space(node);
} }
assert(client->ws->tree->children.size >= 1); assert(client->ws->tree->children->size >= 1);
return node->children.nodes[0]; return node->children->nodes[0];
} }
NodeArray wm_nodearray_new() NodeArray* wm_nodearray_new()
{ {
NodeArray arr; NodeArray *arr = calloc(1, sizeof(NodeArray));
arr.capacity = 10; arr->capacity = 10;
arr.nodes = calloc(arr.capacity, sizeof(TreeNode*)); arr->nodes = calloc(arr->capacity, sizeof(TreeNode*));
arr.size = 0; arr->size = 0;
return arr; return arr;
} }
@ -581,7 +581,7 @@ void wm_nodearray_push(NodeArray *arr, TreeNode *node)
arr->nodes[arr->size - 1] = node; arr->nodes[arr->size - 1] = node;
} }
bool wm_nodearray_pop(NodeArray *arr, TreeNode *ret) bool wm_nodearray_pop(NodeArray *arr, TreeNode **ret)
{ {
DEBUG_PRINT("%s\n", __func__); DEBUG_PRINT("%s\n", __func__);
assert(arr); assert(arr);
@ -590,12 +590,12 @@ bool wm_nodearray_pop(NodeArray *arr, TreeNode *ret)
if (arr->size == 0) if (arr->size == 0)
return false; return false;
ret = arr->nodes[arr->size - 1]; *ret = arr->nodes[arr->size - 1];
arr->size--; arr->size--;
return true; return true;
} }
bool wm_nodearray_pop_front(NodeArray *arr, TreeNode *ret) bool wm_nodearray_pop_front(NodeArray *arr, TreeNode **ret)
{ {
assert(arr); assert(arr);
assert(ret); assert(ret);
@ -603,7 +603,7 @@ bool wm_nodearray_pop_front(NodeArray *arr, TreeNode *ret)
if (arr->size == 0) if (arr->size == 0)
return false; return false;
ret = arr->nodes[0]; *ret = arr->nodes[0];
arr->size--; arr->size--;
memmove(arr->nodes, arr->nodes+1, arr->size * sizeof(TreeNode*)); memmove(arr->nodes, arr->nodes+1, arr->size * sizeof(TreeNode*));
@ -638,63 +638,14 @@ bool wm_nodearray_remove(NodeArray *arr, size_t index)
return true; return true;
} }
void __wm_nodearray_free(NodeArray *arr) void wm_nodearray_free(NodeArray *arr)
{ {
// DEBUG_PRINT("%s\n", __func__);
assert(arr); assert(arr);
arr->capacity = 0; arr->capacity = 0;
arr->size = 0; arr->size = 0;
free(arr->nodes); free(arr->nodes);
} free(arr);
// breadth-first search for finding client nodes in tree
ClientArray wm_nodearray_find_clients(TreeNode *root)
{
DEBUG_PRINT("%s\n", __func__);
assert(root);
/* storing visited nodes in an array and searching is
not optimal, but this is not a performance-critical function. */
NodeArray visited = wm_nodearray_new();
wm_nodearray_push(&visited, root);
NodeArray queue = wm_nodearray_new();
ClientArray clients = wm_clientarray_new();
wm_nodearray_push(&queue, root);
while (queue.size > 0) {
TreeNode node;
if (!wm_nodearray_pop_front(&queue, &node))
goto ret;
if (node.type == NODE_CLIENT)
wm_clientarray_push(&clients, *node.client);
for (size_t i = 0; i < node.children.size; i++) {
TreeNode *child_node = node.children.nodes[i];
bool _visited = false;
for (size_t j = 0; j < visited.size; j++) {
if (visited.nodes[j]->id == child_node->id) {
_visited = true;
break;
}
}
if (!_visited) {
wm_nodearray_push(&visited, child_node);
wm_nodearray_push(&queue, child_node);
}
}
}
ret:
__wm_nodearray_free(&visited);
__wm_nodearray_free(&queue);
return clients;
} }
PtrArray wm_ptrarray_new() PtrArray wm_ptrarray_new()
@ -801,8 +752,8 @@ TreeNode* wm_treenode_ptr_find_focused_client_node(TreeNode *root)
TreeNode *ret = NULL; TreeNode *ret = NULL;
NodeArray visited = wm_nodearray_new(); NodeArray *visited = wm_nodearray_new();
wm_nodearray_push(&visited, root); wm_nodearray_push(visited, root);
PtrArray queue = wm_ptrarray_new(); PtrArray queue = wm_ptrarray_new();
@ -819,26 +770,26 @@ TreeNode* wm_treenode_ptr_find_focused_client_node(TreeNode *root)
goto ret; goto ret;
} }
for (size_t i = 0; i < node->children.size; i++) { for (size_t i = 0; i < node->children->size; i++) {
TreeNode *child_node = node->children.nodes[i]; TreeNode *child_node = node->children->nodes[i];
bool _visited = false; bool _visited = false;
for (size_t j = 0; j < visited.size; j++) { for (size_t j = 0; j < visited->size; j++) {
if (visited.nodes[j]->id == child_node->id) { if (visited->nodes[j]->id == child_node->id) {
_visited = true; _visited = true;
break; break;
} }
} }
if (!_visited) { if (!_visited) {
wm_nodearray_push(&visited, child_node); wm_nodearray_push(visited, child_node);
wm_ptrarray_push(&queue, child_node); wm_ptrarray_push(&queue, child_node);
} }
} }
} }
ret: ret:
__wm_nodearray_free(&visited); wm_nodearray_free(visited);
wm_ptrarray_free(&queue); wm_ptrarray_free(&queue);
return ret; return ret;
} }
@ -849,10 +800,10 @@ TreeNode* wm_treenode_ptr_find_client_node(TreeNode *root, Client *client)
assert(client); assert(client);
TreeNode *ret = NULL; TreeNode *ret = NULL;
PtrArray client_nodes = wm_treenode_find_client_nodes_ptr(root); NodeArray *client_nodes = wm_treenode_find_client_nodes(root);
for (size_t i = 0; i < client_nodes.size; i++) { for (size_t i = 0; i < client_nodes->size; i++) {
TreeNode *node = (TreeNode*)client_nodes.ptrs[i]; TreeNode *node = (TreeNode*)client_nodes->nodes[i];
if (node->client == client) { if (node->client == client) {
ret = node; ret = node;
goto ret; goto ret;
@ -860,182 +811,69 @@ TreeNode* wm_treenode_ptr_find_client_node(TreeNode *root, Client *client)
} }
ret: ret:
wm_ptrarray_free(&client_nodes); wm_nodearray_free(client_nodes);
return ret; return ret;
} }
PtrArray wm_treenode_find_client_nodes_ptr(TreeNode *root) NodeArray *wm_treenode_find_client_nodes(TreeNode *root)
{
assert(root);
NodeArray *ret = wm_nodearray_new();
NodeArray *all_nodes = wm_all_nodes_to_array(root);
for (size_t i = 0; i < all_nodes->size; i++) {
TreeNode *node = all_nodes->nodes[i];
if (node->type == NODE_CLIENT && node->client)
wm_nodearray_push(ret, node);
}
wm_nodearray_free(all_nodes);
return ret;
}
NodeArray* wm_all_nodes_to_array(TreeNode *root)
{ {
DEBUG_PRINT("%s\n", __func__); DEBUG_PRINT("%s\n", __func__);
assert(root); assert(root);
PtrArray ret = wm_ptrarray_new(); NodeArray *ret = wm_nodearray_new();
NodeArray visited = wm_nodearray_new(); NodeArray *visited = wm_nodearray_new();
wm_nodearray_push(&visited, root); wm_nodearray_push(visited, root);
PtrArray queue = wm_ptrarray_new(); NodeArray *queue = wm_nodearray_new();
wm_ptrarray_push(&queue, root); wm_nodearray_push(queue, root);
while (queue.size > 0) { while (queue->size > 0) {
TreeNode *node; TreeNode *node;
if (!wm_ptrarray_pop_front(&queue, (void**)&node)) if (!wm_nodearray_pop_front(queue, &node))
goto ret; goto ret;
if (node->type == NODE_CLIENT && node->client != NULL) wm_nodearray_push(ret, node);
wm_ptrarray_push(&ret, node);
for (size_t i = 0; i < node->children.size; i++) { for (size_t i = 0; i < node->children->size; i++) {
TreeNode *child_node = node->children.nodes[i]; TreeNode *child_node = node->children->nodes[i];
bool _visited = false; bool _visited = false;
for (size_t j = 0; j < visited.size; j++) { for (size_t j = 0; j < visited->size; j++) {
if (visited.nodes[j]->id == child_node->id) { if (visited->nodes[j]->id == child_node->id) {
_visited = true; _visited = true;
break; break;
} }
} }
if (!_visited) { if (!_visited) {
wm_nodearray_push(&visited, child_node); wm_nodearray_push(visited, child_node);
wm_ptrarray_push(&queue, child_node); wm_nodearray_push(queue, child_node);
} }
} }
} }
ret: ret:
__wm_nodearray_free(&visited); wm_nodearray_free(visited);
wm_ptrarray_free(&queue); wm_nodearray_free(queue);
return ret; return ret;
} }
PtrArray wm_all_nodes_to_ptrarray(TreeNode *root)
{
DEBUG_PRINT("%s\n", __func__);
assert(root);
PtrArray ret = wm_ptrarray_new();
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;
wm_ptrarray_push(&ret, node);
for (size_t i = 0; i < node->children.size; i++) {
TreeNode *child_node = node->children.nodes[i];
bool _visited = false;
for (size_t j = 0; j < visited.size; j++) {
if (visited.nodes[j]->id == child_node->id) {
_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;
arr.capacity = 10;
arr.clients = calloc(arr.capacity, sizeof(TreeNode));
arr.size = 0;
return arr;
}
void wm_clientarray_push(ClientArray *arr, Client node)
{
DEBUG_PRINT("%s\n", __func__);
assert(arr);
arr->size++;
if (arr->size >= arr->capacity) {
Client* temp = calloc(arr->capacity, sizeof(Client));
memcpy(temp, arr->clients, arr->capacity * sizeof(Client));
free(arr->clients);
size_t old_capacity = arr->capacity;
arr->capacity = old_capacity * 2;
arr->clients = calloc(arr->capacity, sizeof(Client));
memcpy(arr->clients, temp, old_capacity * sizeof(Client));
free(temp);
arr->clients[arr->size - 1] = node;
return;
}
arr->clients[arr->size - 1] = node;
}
bool wm_clientarray_pop(ClientArray *arr, Client *ret)
{
DEBUG_PRINT("%s\n", __func__);
assert(arr);
if (!ret || !arr)
return false;
if (arr->size == 0)
return false;
*ret = arr->clients[arr->size - 1];
arr->size--;
return true;
}
bool wm_clientarray_remove(ClientArray *arr, size_t index)
{
DEBUG_PRINT("%s\n", __func__);
assert(arr);
if (!arr)
return false;
if (index >= arr->size)
return false;
if (index == arr->size - 1) {
arr->size--;
return true;
}
memmove(arr->clients + index, arr->clients + index+1, arr->size-1 * sizeof(Client));
return true;
}
void wm_clientarray_free(ClientArray *arr)
{
DEBUG_PRINT("%s\n", __func__);
assert(arr);
arr->capacity = 0;
arr->size = 0;
free(arr->clients);
}

35
src/util.h
View File

@ -35,12 +35,6 @@ typedef struct {
size_t capacity; size_t capacity;
} PtrArray; } PtrArray;
typedef struct {
Client *clients;
size_t size;
size_t capacity;
} ClientArray;
typedef struct { typedef struct {
int x; int x;
int y; int y;
@ -53,7 +47,7 @@ struct TreeNode {
TreeNode *parent; TreeNode *parent;
NodeArray children; NodeArray *children;
Rect pos; Rect pos;
@ -66,6 +60,14 @@ typedef struct {
char *str; char *str;
} WmWorkspaceToStrRet; } WmWorkspaceToStrRet;
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);
TreeNode* wm_treenode_new(NodeType type, TreeNode *parent); TreeNode* wm_treenode_new(NodeType type, TreeNode *parent);
void wm_treenode_free(TreeNode *node); void wm_treenode_free(TreeNode *node);
bool wm_treenode_is_empty(TreeNode *node); bool wm_treenode_is_empty(TreeNode *node);
@ -80,15 +82,6 @@ void wm_node_type_to_str(NodeType type, char *buf, size_t bufsize);
char* wm_treenode_to_str(TreeNode *node); char* wm_treenode_to_str(TreeNode *node);
void wm_treenode_print(TreeNode *node); void wm_treenode_print(TreeNode *node);
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);
PtrArray wm_ptrarray_new(); PtrArray wm_ptrarray_new();
void wm_ptrarray_push(PtrArray *arr, void* ptr); void wm_ptrarray_push(PtrArray *arr, void* ptr);
bool wm_ptrarray_pop(PtrArray *arr, void **ret); bool wm_ptrarray_pop(PtrArray *arr, void **ret);
@ -97,9 +90,9 @@ bool wm_ptrarray_remove(PtrArray *arr, size_t index);
void wm_ptrarray_free(PtrArray *arr); void wm_ptrarray_free(PtrArray *arr);
TreeNode* wm_treenode_ptr_find_focused_client_node(TreeNode *root); TreeNode* wm_treenode_ptr_find_focused_client_node(TreeNode *root);
TreeNode* wm_treenode_ptr_find_client_node(TreeNode *root, Client *client); TreeNode* wm_treenode_ptr_find_client_node(TreeNode *root, Client *client);
PtrArray wm_treenode_find_client_nodes_ptr(TreeNode *root); NodeArray* wm_treenode_find_client_nodes(TreeNode *root);
TreeNode* wm_treenode_split_get_sibling(TreeNode *node); TreeNode* wm_treenode_split_get_sibling(TreeNode *node);
PtrArray wm_all_nodes_to_ptrarray(TreeNode *root); NodeArray* wm_all_nodes_to_array(TreeNode *root);
void wm_log_state(Wm *wm, const char *prefixstr, const char* logfile); void wm_log_state(Wm *wm, const char *prefixstr, const char* logfile);
TreeNode* wm_treenode_lmd(TreeNode *node); TreeNode* wm_treenode_lmd(TreeNode *node);
@ -108,10 +101,4 @@ PtrArray wm_postorder_traversal(TreeNode *tree);
bool wm_is_treenode_keyroot(TreeNode *node); bool wm_is_treenode_keyroot(TreeNode *node);
PtrArray wm_treenode_all_keyroots(TreeNode *node); PtrArray wm_treenode_all_keyroots(TreeNode *node);
ClientArray wm_clientarray_new();
void wm_clientarray_push(ClientArray *arr, Client node);
bool wm_clientarray_pop(ClientArray *arr, Client *ret);
bool wm_clientarray_remove(ClientArray *arr, size_t index);
void wm_clientarray_free(ClientArray *arr);
#endif #endif

42
src/wm.c
View File

@ -218,8 +218,8 @@ void wm_ws_tree_insert_client(Wm *wm, Workspace *ws, Client *client)
child2->client = client; child2->client = client;
focused_node->client = NULL; focused_node->client = NULL;
wm_nodearray_push(&focused_node->children, child1); wm_nodearray_push(focused_node->children, child1);
wm_nodearray_push(&focused_node->children, child2); wm_nodearray_push(focused_node->children, child2);
} }
void wm_switch_ws(Wm *wm, size_t ws) void wm_switch_ws(Wm *wm, size_t ws)
@ -233,11 +233,10 @@ void wm_switch_ws(Wm *wm, size_t ws)
DEBUG_PRINT("switching to ws %ld, clients:", ws); DEBUG_PRINT("switching to ws %ld, clients:", ws);
wm_treenode_print(wm->smon->workspaces[ws].tree); wm_treenode_print(wm->smon->workspaces[ws].tree);
PtrArray current_ws_clients = wm_treenode_find_client_nodes_ptr( NodeArray *current_ws_clients = wm_treenode_find_client_nodes(CURRENT_WS(wm).tree);
wm->smon->workspaces[wm->smon->selws].tree);
for (size_t i = 0; i < current_ws_clients.size; i++) { for (size_t i = 0; i < current_ws_clients->size; i++) {
c = ((TreeNode**)current_ws_clients.ptrs)[i]->client; c = ((TreeNode**)current_ws_clients->nodes)[i]->client;
assert(c); assert(c);
if (c->ws->index == wm->smon->selws) { if (c->ws->index == wm->smon->selws) {
DEBUG_PRINT("wm_switch_ws hide client selws: %ld\n", c->ws->index) DEBUG_PRINT("wm_switch_ws hide client selws: %ld\n", c->ws->index)
@ -250,11 +249,10 @@ void wm_switch_ws(Wm *wm, size_t ws)
wm_client_set_atom(wm, &wm-> root, "_NET_CURRENT_DESKTOP", wm_client_set_atom(wm, &wm-> root, "_NET_CURRENT_DESKTOP",
(unsigned char*) &(ws), XA_CARDINAL, 1); (unsigned char*) &(ws), XA_CARDINAL, 1);
PtrArray switch_ws_clients = wm_treenode_find_client_nodes_ptr( NodeArray *switch_ws_clients = wm_treenode_find_client_nodes(CURRENT_WS(wm).tree);
wm->smon->workspaces[wm->smon->selws].tree);
for (size_t i = 0; i < switch_ws_clients.size; i++) { for (size_t i = 0; i < switch_ws_clients->size; i++) {
c = ((TreeNode**)switch_ws_clients.ptrs)[i]->client; c = ((TreeNode**)switch_ws_clients->nodes)[i]->client;
if (c->ws->index == wm->smon->selws) { if (c->ws->index == wm->smon->selws) {
wscc++; wscc++;
wm_client_show(wm, c); wm_client_show(wm, c);
@ -268,8 +266,8 @@ void wm_switch_ws(Wm *wm, size_t ws)
wm_layout(wm, wm->smon); wm_layout(wm, wm->smon);
wm_ptrarray_free(&current_ws_clients); wm_nodearray_free(current_ws_clients);
wm_ptrarray_free(&switch_ws_clients); wm_nodearray_free(switch_ws_clients);
} }
void wm_move_client_ws(Wm *wm, int ws) void wm_move_client_ws(Wm *wm, int ws)
@ -303,12 +301,12 @@ void wm_layout(Wm *wm, Monitor *m)
DEBUG_PRINT("%s\n", __func__); DEBUG_PRINT("%s\n", __func__);
Workspace *ws = &m->workspaces[m->selws]; Workspace *ws = &m->workspaces[m->selws];
PtrArray clients = wm_treenode_find_client_nodes_ptr(ws->tree); NodeArray *clients = wm_treenode_find_client_nodes(ws->tree);
if (clients.size == 0) if (clients->size == 0)
goto ret; goto ret;
for (i = 0; i < clients.size; i++) { for (i = 0; i < clients->size; i++) {
TreeNode *node = clients.ptrs[i]; TreeNode *node = clients->nodes[i];
Client *client = node->client; Client *client = node->client;
assert(client); assert(client);
@ -323,7 +321,7 @@ void wm_layout(Wm *wm, Monitor *m)
wm_client_show(wm, client); wm_client_show(wm, client);
} }
wm_client_focus(wm, ((TreeNode*)clients.ptrs[0])->client); wm_client_focus(wm, ((TreeNode*)clients->nodes[0])->client);
XEvent e; XEvent e;
XSync(wm->display, False); XSync(wm->display, False);
@ -332,7 +330,7 @@ void wm_layout(Wm *wm, Monitor *m)
wm_monitor_clients_border(wm, m); wm_monitor_clients_border(wm, m);
ret: ret:
wm_ptrarray_free(&clients); wm_nodearray_free(clients);
} }
Client *wm_get_last_client(Wm *wm, Monitor m) Client *wm_get_last_client(Wm *wm, Monitor m)
@ -482,16 +480,16 @@ void wm_exit(Wm *wm)
for (size_t i = 0; i < wm->wm_mc; i++) { for (size_t i = 0; i < wm->wm_mc; i++) {
for (size_t j = 0; j < wm->monitors[i].wscount; j++) { for (size_t j = 0; j < wm->monitors[i].wscount; j++) {
PtrArray clients = wm_treenode_find_client_nodes_ptr( NodeArray *clients = wm_treenode_find_client_nodes(
wm->monitors[i].workspaces[j].tree); wm->monitors[i].workspaces[j].tree);
for (size_t k = 0; k < clients.size; k++) { for (size_t k = 0; k < clients->size; k++) {
Client *c = ((TreeNode*)clients.ptrs[k])->client; Client *c = ((TreeNode*)clients->nodes[k])->client;
XKillClient(wm->display, c->window); XKillClient(wm->display, c->window);
DEBUG_PRINT("freeing client %p\n", (void*)c); DEBUG_PRINT("freeing client %p\n", (void*)c);
wm_client_free(wm, c); wm_client_free(wm, c);
} }
wm_ptrarray_free(&clients); wm_nodearray_free(clients);
} }
} }