245 lines
6.9 KiB
C
245 lines
6.9 KiB
C
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <string.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_window_node(WINDOW *const win) {
|
|
struct crs_node *node = __alloc_node(NODE_WINDOW);
|
|
node->win = win;
|
|
|
|
return node;
|
|
}
|
|
|
|
static struct crs_node *auto_window_node(const struct crs_nodedims *dims) {
|
|
WINDOW *win = newwin(dims->height, dims->width, dims->y, dims->x);
|
|
return init_window_node(win);
|
|
}
|
|
|
|
static struct crs_node *init_abstract_node(struct crs_node *node0,
|
|
struct crs_node *node1,
|
|
const enum crs_axis axis,
|
|
const float ratio,
|
|
struct crs_nodedims *dims) {
|
|
struct crs_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;
|
|
}
|
|
|
|
static void destroy_node(struct crs_node *node) {
|
|
if (node->type == NODE_WINDOW) {
|
|
/* Window Node */
|
|
delwin(node->win);
|
|
goto end;
|
|
}
|
|
/* Abstract Node */
|
|
assert(node->type == NODE_ABSTRACT);
|
|
destroy_node(node->child[0]);
|
|
destroy_node(node->child[1]);
|
|
free(node->dims);
|
|
|
|
end:
|
|
free(node);
|
|
}
|
|
|
|
static inline struct crs_nodedims *__dup_dims(const struct crs_nodedims *dims) {
|
|
struct crs_nodedims *dup;
|
|
dup = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims));
|
|
memcpy(dup, dims, sizeof(struct crs_nodedims));
|
|
|
|
return dup;
|
|
}
|
|
|
|
static struct crs_nodedims *get_dims(const struct crs_node *node) {
|
|
struct crs_nodedims *dims;
|
|
if (node->type == NODE_WINDOW) {
|
|
/* Window Node */
|
|
dims = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims));
|
|
// GET_WNODEDIMS();
|
|
getbegyx(node->win, dims->y, dims->x);
|
|
getmaxyx(node->win, dims->height, dims->width);
|
|
printf("getx: %d\n", dims->x);
|
|
printf("gety: %d\n", dims->y);
|
|
printf("getwidth: %d\n", dims->width);
|
|
printf("getheight: %d\n", dims->height);
|
|
} else {
|
|
/* Abstract Node */
|
|
assert(node->type == NODE_ABSTRACT);
|
|
dims = __dup_dims(node->dims);
|
|
}
|
|
|
|
return dims;
|
|
}
|
|
|
|
struct crs_nodedims term_dims(void) {
|
|
struct crs_nodedims dims;
|
|
getbegyx(stdscr, dims.y, dims.x);
|
|
getmaxyx(stdscr, dims.height, dims.width);
|
|
return dims;
|
|
}
|
|
|
|
/* Calculate the dimensions for nodes resulting from a bifurcation.
|
|
* Returns 0 on success, and 1 on failure if any width/height are 0 characters.
|
|
* WARNING: This function does not guarantee the x,y positions returned
|
|
* WARNING: are valid screen coordinates.
|
|
*/
|
|
static int bifurcate_dims(const struct crs_node *parent,
|
|
const enum crs_axis axis, const float ratio,
|
|
struct crs_nodedims **dims0,
|
|
struct crs_nodedims **dims1) {
|
|
assert(0 < ratio && ratio < 1);
|
|
struct crs_nodedims *_dims0, *_dims1;
|
|
|
|
_dims0 = get_dims(parent);
|
|
_dims1 = __dup_dims(_dims0);
|
|
|
|
printf("widthP: %d\n", _dims0->width);
|
|
printf("heightP: %d\n", _dims0->height);
|
|
|
|
if (axis == AXIS_X) {
|
|
_dims0->width *= ratio;
|
|
_dims1->width -= _dims0->width;
|
|
_dims1->x += _dims0->width;
|
|
} else {
|
|
_dims0->height *= ratio;
|
|
_dims1->height -= _dims0->height;
|
|
_dims1->y += _dims0->height;
|
|
}
|
|
|
|
if (!_dims0->width || !_dims0->height || !_dims1->width || !_dims1->height) {
|
|
printf("width0: %d\n", _dims0->width);
|
|
printf("height0: %d\n", _dims0->height);
|
|
printf("width1: %d\n", _dims1->width);
|
|
printf("height1: %d\n", _dims1->height);
|
|
return 1;
|
|
}
|
|
|
|
// propagate bifurcated dimensions
|
|
*dims0 = _dims0;
|
|
*dims1 = _dims1;
|
|
return 0;
|
|
}
|
|
|
|
static void resize_node(struct crs_node *node, struct crs_nodedims *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);
|
|
} else {
|
|
/* Abstract Node */
|
|
assert(node->type == NODE_ABSTRACT);
|
|
struct crs_nodedims *dims0, *dims1;
|
|
|
|
free(node->dims);
|
|
node->dims = new_dims;
|
|
bifurcate_dims(node, node->axis, node->ratio, &dims0, &dims1);
|
|
|
|
resize_node(node->child[0], dims0);
|
|
resize_node(node->child[1], dims1);
|
|
}
|
|
}
|
|
|
|
/* 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
|
|
*/
|
|
void bifurcate_window_node(struct crs_node **node, const enum crs_axis axis,
|
|
const int invert_axis, const float ratio) {
|
|
assert((*node)->type == NODE_WINDOW);
|
|
struct crs_nodedims *dims0, *dims1;
|
|
struct crs_node *node0, *node1;
|
|
|
|
if (bifurcate_dims(*node, axis, ratio, &dims0, &dims1)) {
|
|
printf("FAILED TERRIBLY THE FUCK\n");
|
|
exit(1);
|
|
return;
|
|
}
|
|
if (invert_axis) {
|
|
/* Inverted Bifurcation */
|
|
node0 = auto_window_node(dims0);
|
|
node1 = *node;
|
|
resize_node(node1, dims1);
|
|
} else {
|
|
/* Non-Inverted Bifurcation */
|
|
node0 = *node;
|
|
node1 = auto_window_node(dims1);
|
|
resize_node(node0, dims0);
|
|
}
|
|
|
|
*node = init_abstract_node(node0, node1, axis, ratio, (*node)->dims);
|
|
}
|
|
|
|
/* 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) {
|
|
struct crs_nodedims rootdims;
|
|
WINDOW *rootwin;
|
|
|
|
// rootdims = term_dims();
|
|
// rootwin = new_window(rootdims.x, rootdims.y,
|
|
// rootdims.height, rootdims.height);
|
|
// rootwin = new_window(0, 0, 0, 0);
|
|
rootwin = root_window();
|
|
return init_window_node(rootwin);
|
|
}
|
|
|
|
int init_tree(struct crs_tree **const tree) {
|
|
*tree = (struct crs_tree *)malloc(sizeof(struct crs_tree));
|
|
|
|
/* Initialise NCurses Library & Standard Screen */
|
|
init_ncurses();
|
|
|
|
(*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 *const tree) {
|
|
/* WARNING: is it ok to delwin(stdscr) ?? */
|
|
destroy_node(tree->root);
|
|
|
|
endwin();
|
|
free(tree);
|
|
}
|
|
|
|
void resize_tree(struct crs_tree *const tree, struct crs_nodedims *const dims) {
|
|
resize_node(tree->root, dims);
|
|
}
|