(UNDER CONSTRUCTION) cursetree is now a non-binary tree yippiegit add .
also abstracted ncurses WINDOW into the ct_surface structure. and added ct_bounds to complement ct_dims.
This commit is contained in:
parent
b04f0b4aa3
commit
759920a9cc
9 changed files with 476 additions and 193 deletions
342
cursetree/node.c
342
cursetree/node.c
|
|
@ -1,153 +1,259 @@
|
|||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "ncrswrap.h"
|
||||
#include "dims.h"
|
||||
#include "node.h"
|
||||
#include "surface.h"
|
||||
|
||||
/* Internal allocator method for ct_node structures.
|
||||
*/
|
||||
static inline struct ct_node *__alloc_node(const enum ct_nodetype type) {
|
||||
static inline struct ct_node *__alloc_node(void) {
|
||||
struct ct_node *node = (struct ct_node *)malloc(sizeof(struct ct_node));
|
||||
node->type = type;
|
||||
return node;
|
||||
}
|
||||
|
||||
/* Construct a new window node (ct_node of type NODE_WIN).
|
||||
/* Returns NULL if memory allocation failed.
|
||||
*/
|
||||
struct ct_node *init_window_node(WINDOW *const win) {
|
||||
struct ct_node *node = __alloc_node(NODE_WINDOW);
|
||||
node->win = win;
|
||||
struct ct_node *new_node(struct ct_dims *const dims,
|
||||
struct ct_bounds *const bounds,
|
||||
struct ct_node *const parent) {
|
||||
struct ct_node *node = __alloc_node();
|
||||
if (node == NULL) {
|
||||
*node = (struct ct_node){
|
||||
.surface = new_surface(dims, bounds),
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
static struct ct_node *
|
||||
auto_window_node(const struct ct_dims *const dims) {
|
||||
WINDOW *win = new_window(dims->x, dims->y, dims->width, dims->height);
|
||||
return init_window_node(win);
|
||||
}
|
||||
|
||||
static struct ct_node *init_abstract_node(struct ct_node *const node0,
|
||||
struct ct_node *const node1,
|
||||
const enum ct_axis axis,
|
||||
const float ratio,
|
||||
struct ct_dims *const dims) {
|
||||
struct ct_node *node = __alloc_node(NODE_ABSTRACT);
|
||||
node->axis = axis;
|
||||
node->ratio = ratio;
|
||||
node->dims = dims;
|
||||
|
||||
node->child[0] = node0;
|
||||
node->child[1] = node1;
|
||||
return node;
|
||||
}
|
||||
|
||||
void destroy_node(struct ct_node *const node) {
|
||||
if (node->type == NODE_WINDOW) {
|
||||
/* Window Node */
|
||||
destroy_window(node->win);
|
||||
goto end;
|
||||
.parent = parent,
|
||||
.child = (struct ct_node **)malloc(NODE_INIT_CHILDREN *
|
||||
sizeof(struct ct_node *)),
|
||||
.csize = NODE_INIT_CHILDREN,
|
||||
.cindex = 0,
|
||||
.axis = AXIS_X,
|
||||
.ratio = 0,
|
||||
};
|
||||
}
|
||||
/* Abstract Node */
|
||||
assert(node->type == NODE_ABSTRACT);
|
||||
destroy_node(node->child[0]);
|
||||
destroy_node(node->child[1]);
|
||||
free(node->dims);
|
||||
|
||||
end:
|
||||
return node;
|
||||
}
|
||||
|
||||
/* WARNING: Do NOT use __destroy_node() to destroy a node's children!
|
||||
* WARNING: Use the destroy_child_node() function instead.
|
||||
*/
|
||||
void __destroy_node(struct ct_node *const node) {
|
||||
if (node == NULL)
|
||||
return;
|
||||
|
||||
// destroy children first
|
||||
for (int j = 0; j < node->cindex; j++) {
|
||||
__destroy_node(node->child[j]);
|
||||
}
|
||||
|
||||
destroy_surface(node->surface);
|
||||
free(node);
|
||||
}
|
||||
|
||||
static inline struct ct_dims *nodedims(const struct ct_node *const node) {
|
||||
struct ct_dims *dims;
|
||||
if (node->type == NODE_WINDOW) {
|
||||
/* Window Node */
|
||||
dims = windims(node->win);
|
||||
} else {
|
||||
/* Abstract Node */
|
||||
assert(node->type == NODE_ABSTRACT);
|
||||
dims = dup_dims(node->dims);
|
||||
void satisfy_node(struct ct_node *const node, struct ct_dims *const dims) {
|
||||
double axismax;
|
||||
if (IS_PARENT_NODE(node)) {
|
||||
for (int i = 0; i < node->cindex; i++) {
|
||||
if (node->axis == AXIS_X) {
|
||||
axismax += dims->width * node->child[i]->surface->bounds->wmax;
|
||||
} else {
|
||||
assert(node->axis == AXIS_Y);
|
||||
axismax += dims->width * node->child[i]->surface->bounds->hmax;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return dims;
|
||||
}
|
||||
|
||||
/* NOTE: resize_node calls wnoutrefresh(3x), which expects
|
||||
* NOTE: a call doupdate(3x) call afterwards to flush ncurses
|
||||
* NOTE: virtual screen to the physical screen.
|
||||
/*
|
||||
*/
|
||||
void resize_node(struct ct_node *const node,
|
||||
struct ct_dims *const new_dims) {
|
||||
if (node->type == NODE_WINDOW) {
|
||||
/* Window Node */
|
||||
resizemv_window(new_dims->x, new_dims->y, new_dims->width, new_dims->height,
|
||||
node->win);
|
||||
free(new_dims);
|
||||
void resize_node(struct ct_node *const node, struct ct_dims *const dims) {
|
||||
int cwidth, cheight; // child dimensions
|
||||
|
||||
wnoutrefresh(node->win);
|
||||
if (IS_PARENT_NODE(node)) {
|
||||
dims->width / node->cindex;
|
||||
}
|
||||
|
||||
resize_surface(node->surface, dims);
|
||||
|
||||
for (int j = 0; j < node->cindex; j++) {
|
||||
/* TODO */
|
||||
resize_node(node->child[j], TODO);
|
||||
}
|
||||
// bifurcate_dims(dims, node->axis, node->ratio, &dims0, &dims1);
|
||||
|
||||
// resize_node(node->child[0], dims0);
|
||||
// resize_node(node->child[1], dims1);
|
||||
}
|
||||
|
||||
static int __set_cbounds(struct ct_node *const parent,
|
||||
const struct ct_node *const child,
|
||||
const bool additive) {
|
||||
/* child and parent w/h min aliases */
|
||||
int c_wmin, c_hmin;
|
||||
int p_wmin_rel, p_hmin_rel;
|
||||
|
||||
c_wmin = child->surface->bounds->wmin;
|
||||
c_hmin = child->surface->bounds->hmin;
|
||||
|
||||
if (!additive) {
|
||||
c_wmin *= -1;
|
||||
c_hmin *= -1;
|
||||
}
|
||||
|
||||
if (child->surface->bounds->type == BOUND_RELATIVE) {
|
||||
parent->cbounds.wmin_abs++;
|
||||
parent->cbounds.hmin_abs++;
|
||||
|
||||
p_wmin_rel = parent->cbounds.wmin_rel + c_wmin;
|
||||
p_hmin_rel = parent->cbounds.hmin_rel + c_wmin;
|
||||
if (p_wmin_rel > __BOUND_REL_MAX || p_hmin_rel >= __BOUND_REL_MAX)
|
||||
return 1;
|
||||
|
||||
parent->cbounds.wmin_rel = p_wmin_rel;
|
||||
parent->cbounds.hmin_rel = p_hmin_rel;
|
||||
assert(parent->cbounds.wmin_rel > __BOUND_REL_MIN);
|
||||
assert(parent->cbounds.hmin_rel > __BOUND_REL_MIN);
|
||||
} else {
|
||||
/* Abstract Node */
|
||||
assert(node->type == NODE_ABSTRACT);
|
||||
struct ct_dims *dims0, *dims1;
|
||||
|
||||
free(node->dims);
|
||||
node->dims = new_dims;
|
||||
bifurcate_dims(new_dims, node->axis, node->ratio, &dims0, &dims1);
|
||||
|
||||
resize_node(node->child[0], dims0);
|
||||
resize_node(node->child[1], dims1);
|
||||
parent->cbounds.wmin_abs += c_wmin;
|
||||
parent->cbounds.hmin_abs += c_hmin;
|
||||
assert(parent->cbounds.wmin_abs > __BOUND_ABS_MIN);
|
||||
assert(parent->cbounds.hmin_abs > __BOUND_ABS_MIN);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Subdivide a window node's allocated region into two window nodes
|
||||
* replacing the original node with an abstract node.
|
||||
* Parameters:
|
||||
* axis - controls which direction the subdivision occurs
|
||||
* invert_axis - invert index of the original node in the new abstract node
|
||||
/* Returns:
|
||||
* 0 -> success
|
||||
* 1 -> failed (max child limit reached)
|
||||
* 2 -> failed (cumulative relative bounds surpasses 100%)
|
||||
*/
|
||||
static void __bifurcate_window_node(struct ct_node **const node,
|
||||
const enum ct_axis axis, const int invert_axis,
|
||||
const float ratio) {
|
||||
assert((*node)->type == NODE_WINDOW);
|
||||
struct ct_dims *dims0, *dims1;
|
||||
struct ct_node *node0, *node1;
|
||||
int insert_child_node(struct ct_node *const parent, struct ct_node *const child,
|
||||
const cindex i) {
|
||||
if (parent->cindex == CINDEX_MAX)
|
||||
return 1;
|
||||
else if (__set_cbounds(parent, child, true))
|
||||
return 2;
|
||||
else if (parent->cindex == parent->csize) {
|
||||
// grow child array size and clamp maximum
|
||||
parent->csize *= NODE_CHILDREN_GROWTH;
|
||||
if (parent->csize > CINDEX_MAX)
|
||||
parent->csize = CINDEX_MAX;
|
||||
|
||||
struct ct_dims *original_dims = nodedims(*node);
|
||||
if (bifurcate_dims(original_dims, axis, ratio, &dims0, &dims1)) {
|
||||
/* TODO: handle this error properly */
|
||||
free(original_dims);
|
||||
exit(1);
|
||||
return;
|
||||
parent->child =
|
||||
reallocarray(parent->child, parent->csize, sizeof(struct ct_node *));
|
||||
}
|
||||
|
||||
if (invert_axis) {
|
||||
/* Inverted Bifurcation */
|
||||
node0 = auto_window_node(dims0);
|
||||
node1 = *node;
|
||||
resize_node(node1, dims1);
|
||||
// shift all children up for insertion
|
||||
for (int j = parent->cindex; j > i; j--) {
|
||||
parent->child[j] = parent->child[j - 1];
|
||||
}
|
||||
// do insertion
|
||||
parent->child[i] = child;
|
||||
parent->cindex++;
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
/* Returns:
|
||||
* 0 -> success
|
||||
* 1 -> failed (max child limit reached)
|
||||
* 2 -> failed (cumulative relative bounds surpasses 100%)
|
||||
*/
|
||||
int append_child_node(struct ct_node *const parent,
|
||||
struct ct_node *const child) {
|
||||
return insert_child_node(parent, child, parent->cindex);
|
||||
}
|
||||
|
||||
/* Remove a child node from a parent node by index.
|
||||
* Returns NULL if an invalid index was provided, otherwise returns
|
||||
* a pointer to the child node removed.
|
||||
* NOTE: This does NOT destroy the child node and should be
|
||||
* NOTE: used when moving the child somewhere else.
|
||||
* NOTE: Otherwise use destroy_child_node() instead.
|
||||
*/
|
||||
struct ct_node *remove_child_node(struct ct_node *const parent,
|
||||
const cindex i) {
|
||||
struct ct_node *child;
|
||||
|
||||
if (i >= parent->cindex)
|
||||
return NULL;
|
||||
else if (parent->cindex <= parent->csize / NODE_CHILDREN_GROWTH) {
|
||||
// shrink child array to avoid memory bloat
|
||||
parent->csize /= NODE_CHILDREN_GROWTH;
|
||||
parent->child =
|
||||
reallocarray(parent->child, parent->csize, sizeof(struct ct_node *));
|
||||
}
|
||||
|
||||
child = &parent[i];
|
||||
// shift all children down to fill removal
|
||||
for (int j = i; j < parent->cindex; j++) {
|
||||
parent->child[j] = parent->child[j + 1];
|
||||
}
|
||||
parent->cindex--;
|
||||
__set_cbounds(parent, child, false);
|
||||
return child;
|
||||
}
|
||||
|
||||
/* Remove and destroy a child node by index.
|
||||
* Returns 1 on failure (invalid index provided), and 0 on success.
|
||||
* NOTE: Use remove_child_node() instead if the child should live.
|
||||
*/
|
||||
int destroy_child_node(struct ct_node *const parent, const cindex i) {
|
||||
struct ct_node *child = remove_child_node(parent, i);
|
||||
__destroy_node(child);
|
||||
return (child == NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns:
|
||||
* 0 -> success
|
||||
* 1 -> failed (node has no parent)
|
||||
* 2 -> failed (parent has no reference to node, CRITICAL)
|
||||
*/
|
||||
static int __index_as_child(const struct ct_node *const node,
|
||||
int *const index) {
|
||||
if (node->parent == NULL)
|
||||
return 1;
|
||||
|
||||
for (int i = 0; i < node->parent->cindex; i++) {
|
||||
if (node->parent->child[i] == node) {
|
||||
*index = i;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return 2;
|
||||
}
|
||||
|
||||
/*
|
||||
* If preserve_bounds is set then upon collapse the new node maintains the
|
||||
* original node's bounds struct. Otherwise the bounds of the child collapsed
|
||||
* onto are used.
|
||||
*/
|
||||
void collapse_node(struct ct_node **const node, const int i,
|
||||
const bool preserve_bounds) {
|
||||
assert(0 <= i && i < (*node)->cindex);
|
||||
int parent_index;
|
||||
struct ct_node *const parent = (*node)->parent;
|
||||
struct ct_node *collapse_target = remove_child_node(*node, i);
|
||||
struct ct_dims *dims = dup_dims((*node)->surface->dims);
|
||||
struct ct_bounds *bounds;
|
||||
|
||||
if (preserve_bounds) {
|
||||
bounds = dup_bounds((*node)->surface->bounds);
|
||||
rebind_surface(collapse_target->surface, bounds);
|
||||
}
|
||||
|
||||
/* Destroy original node and point to the collapse_target */
|
||||
if (__index_as_child(*node, &parent_index)) {
|
||||
/* __index_as_child fails (typically) because
|
||||
* the *node is cursetree's root node. */
|
||||
__destroy_node(*node);
|
||||
*node = collapse_target;
|
||||
} else {
|
||||
/* Non-Inverted Bifurcation */
|
||||
node0 = *node;
|
||||
node1 = auto_window_node(dims1);
|
||||
resize_node(node0, dims0);
|
||||
destroy_child_node(parent, parent_index);
|
||||
insert_child_node(parent, collapse_target, parent_index);
|
||||
}
|
||||
|
||||
*node = init_abstract_node(node0, node1, axis, ratio, original_dims);
|
||||
}
|
||||
|
||||
/* Collapse an abstract node, killing one child node and resizing
|
||||
* the other to take its place.
|
||||
*/
|
||||
static void collapse_abstract_node(struct ct_node **const node,
|
||||
const int collapse_i) {
|
||||
assert((*node)->type == NODE_ABSTRACT);
|
||||
assert(0 <= collapse_i && collapse_i < NODE_CHILD_N);
|
||||
|
||||
// WARNING: only works for NODE_CHILD_N=2 (binary trees)
|
||||
destroy_node((*node)->child[!collapse_i]);
|
||||
|
||||
struct ct_node *collapse_target = (*node)->child[collapse_i];
|
||||
free(*node);
|
||||
*node = collapse_target;
|
||||
resize_node(collapse_target, dims);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue