116 lines
3 KiB
C
116 lines
3 KiB
C
#include <assert.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "curse.h"
|
|
#include "tree.h"
|
|
|
|
/* Internal allocator method for crs_node structures.
|
|
*/
|
|
static inline struct crs_node *__alloc_node(const enum crs_nodetype type) {
|
|
struct crs_node *node = (struct crs_node *)malloc(sizeof(struct crs_node));
|
|
node->type = type;
|
|
return node;
|
|
}
|
|
|
|
/* Construct a new window node (crs_node of type NODE_WIN).
|
|
*/
|
|
static struct crs_node *init_node_window(WINDOW *win) {
|
|
struct crs_node *node = __alloc_node(NODE_WINDOW);
|
|
node->win = win;
|
|
|
|
return node;
|
|
}
|
|
|
|
static struct crs_node *init_node_abstract(struct crs_node *node1,
|
|
struct crs_node *node2,
|
|
float ratio) {
|
|
struct crs_node *node = __alloc_node(NODE_ABSTRACT);
|
|
node->ratio = ratio;
|
|
|
|
node->child[0] = node1;
|
|
node->child[1] = node2;
|
|
return node;
|
|
}
|
|
|
|
static void destroy_node(struct crs_node *node) {
|
|
if (node->type == NODE_WINDOW) {
|
|
/* Window Node */
|
|
delwin(node->win);
|
|
goto end;
|
|
}
|
|
/* Abstract Node */
|
|
destroy_node(node->child[0]);
|
|
destroy_node(node->child[1]);
|
|
|
|
end:
|
|
free(node);
|
|
}
|
|
|
|
/* 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 - invert index of the original node in the new abstract node
|
|
*/
|
|
static void bifurcate_window_node(struct crs_node **node, enum crs_axis axis,
|
|
int invert, float ratio) {
|
|
assert((*node)->type == NODE_ABSTRACT);
|
|
|
|
struct crs_node *original_node = *node;
|
|
struct crs_node *bi_node = init_node_window(); // WARNING: TODO
|
|
|
|
if (!invert) {
|
|
/* Inverted Bifurcation */
|
|
*node = init_node_abstract(bi_node, original_node, ratio);
|
|
} else {
|
|
/* Non-Inverted Bifurcation */
|
|
*node = init_node_abstract(original_node, bi_node, ratio);
|
|
}
|
|
|
|
resize_abstract_node(*node);
|
|
}
|
|
|
|
/* Collapse an abstract node, killing one child node and resizing
|
|
* the other to take its place.
|
|
*/
|
|
static void collapse_abstract_node(struct crs_node **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 crs_node *collapse_target = (*node)->child[collapse_i];
|
|
free(*node);
|
|
*node = collapse_target;
|
|
}
|
|
|
|
/*
|
|
*/
|
|
static struct crs_node *init_root_node(void) {
|
|
WINDOW *rootwin = newwin(0, 0, 0, 0);
|
|
return init_node_window(rootwin);
|
|
}
|
|
|
|
int init_tree(struct crs_tree **tree) {
|
|
*tree = (struct crs_tree *)malloc(sizeof(struct crs_tree));
|
|
|
|
/* Initialise NCurses Library & Standard Screen */
|
|
crs_init(&(*tree)->stdscr);
|
|
|
|
/* */
|
|
(*tree)->root = init_root_node();
|
|
|
|
// (*tree)->root = __alloc_node(NODE_WINDOW);
|
|
// crs_init(&(*tree)->root->win);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
void destroy_tree(struct crs_tree *tree) {
|
|
/* WARNING: is it ok to delwin(stdscr) ?? */
|
|
destroy_node(tree->root);
|
|
|
|
endwin();
|
|
}
|