emileclarkb/dorne
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

add (terrible) support for auto window resizing

Browse source
This commit is contained in:
Emile Clark-Boman 2025-09-12 00:17:48 +10:00
parent a90b99baa3
commit 373081a1b3
4 changed files with 94 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

2
cli/curse.h
View file

@ -15,6 +15,8 @@ enum crs_termmode {
TMODE_NORAW, TMODE_NORAW,
}; };
#define termsize(width, height) (width=COLS); (height=LINES)
int termmode(const enum crs_termmode mode); int termmode(const enum crs_termmode mode);
void init_ncurses(void); void init_ncurses(void);

50
cli/main.c
View file

@ -23,60 +23,24 @@ int main(int argc, char **argv) {
// spawnchild(&child); // spawnchild(&child);
struct crs_tree *tree; struct crs_tree *tree;
init_tree(&tree); ct_init(&tree);
init_pair(1, COLOR_CYAN, COLOR_CYAN); init_pair(1, COLOR_CYAN, COLOR_CYAN);
init_pair(2, COLOR_RED, COLOR_RED); init_pair(2, COLOR_RED, COLOR_RED);
init_pair(3, COLOR_MAGENTA, COLOR_MAGENTA);
init_pair(4, COLOR_YELLOW, COLOR_YELLOW);
init_pair(5, COLOR_GREEN, COLOR_GREEN);
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
/* BUG TODO : PROGRAM SHITS ITSELF IF RATIO MAKES WIDTH/HEIGHT 0, MAYBE CLAMP? : TODO BUG*/
bifurcate_window_node(&tree->root, AXIS_X, FALSE, 0.5); bifurcate_window_node(&tree->root, AXIS_X, FALSE, 0.5);
bifurcate_window_node(&tree->root->child[0], AXIS_X, FALSE, 0.05); wbkgd(tree->root->child[0]->win, COLOR_PAIR(1));
bifurcate_window_node(&tree->root->child[1], AXIS_Y, FALSE, 0.7); wbkgd(tree->root->child[1]->win, COLOR_PAIR(2));
bifurcate_window_node(&tree->root->child[1]->child[1], AXIS_X, FALSE, 0.9); wrefresh(tree->root->child[0]->win);
wrefresh(tree->root->child[1]->win);
wbkgd(tree->root->child[0]->child[0]->win, COLOR_PAIR(5));
wbkgd(tree->root->child[0]->child[1]->win, COLOR_PAIR(3));
wbkgd(tree->root->child[1]->child[0]->win, COLOR_PAIR(2));
wbkgd(tree->root->child[1]->child[1]->child[0]->win, COLOR_PAIR(1));
wbkgd(tree->root->child[1]->child[1]->child[1]->win, COLOR_PAIR(4));
wrefresh(tree->root->child[0]->child[0]->win);
wrefresh(tree->root->child[0]->child[1]->win);
wrefresh(tree->root->child[1]->child[0]->win);
wrefresh(tree->root->child[1]->child[1]->child[0]->win);
wrefresh(tree->root->child[1]->child[1]->child[1]->win);
/* NOTE : THIS IS VALID : NOTE */
// refresh();
// WINDOW *my_win = newwin(0, 0, 0, 0);
// wbkgd(my_win, COLOR_PAIR(1));
// wrefresh(my_win);
/* NOTE : THIS IS VALID : NOTE */
// wbkgd(tree->root->win, COLOR_PAIR(2));
// wrefresh(tree->root->win);
while (1) { while (1) {
ct_update(tree);
// refresh(); // refresh();
usleep(100000); // usleep(100000);
} }
destroy_tree(tree); destroy_tree(tree);
// endwin();
// free(tree);
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

124
cli/tree.c
View file

@ -22,16 +22,17 @@ static struct crs_node *init_window_node(WINDOW *const win) {
return node; return node;
} }
static struct crs_node *auto_window_node(const struct crs_nodedims *dims) { static struct crs_node *
auto_window_node(const struct crs_nodedims *const dims) {
WINDOW *win = newwin(dims->height, dims->width, dims->y, dims->x); WINDOW *win = newwin(dims->height, dims->width, dims->y, dims->x);
return init_window_node(win); return init_window_node(win);
} }
static struct crs_node *init_abstract_node(struct crs_node *node0, static struct crs_node *init_abstract_node(struct crs_node *const node0,
struct crs_node *node1, struct crs_node *const node1,
const enum crs_axis axis, const enum crs_axis axis,
const float ratio, const float ratio,
struct crs_nodedims *dims) { struct crs_nodedims *const dims) {
struct crs_node *node = __alloc_node(NODE_ABSTRACT); struct crs_node *node = __alloc_node(NODE_ABSTRACT);
node->axis = axis; node->axis = axis;
node->ratio = ratio; node->ratio = ratio;
@ -42,7 +43,7 @@ static struct crs_node *init_abstract_node(struct crs_node *node0,
return node; return node;
} }
static void destroy_node(struct crs_node *node) { static void destroy_node(struct crs_node *const node) {
if (node->type == NODE_WINDOW) { if (node->type == NODE_WINDOW) {
/* Window Node */ /* Window Node */
delwin(node->win); delwin(node->win);
@ -58,7 +59,22 @@ end:
free(node); free(node);
} }
static inline struct crs_nodedims *__dup_dims(const struct crs_nodedims *dims) { static inline struct crs_nodedims *__alloc_dims(int x, int y, int width,
int height) {
struct crs_nodedims *dims;
dims = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims));
*dims = (struct crs_nodedims){
.x = x,
.y = y,
.width = width,
.height = height,
};
return dims;
}
static inline struct crs_nodedims *
__dup_dims(const struct crs_nodedims *const dims) {
struct crs_nodedims *dup; struct crs_nodedims *dup;
dup = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims)); dup = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims));
memcpy(dup, dims, sizeof(struct crs_nodedims)); memcpy(dup, dims, sizeof(struct crs_nodedims));
@ -66,18 +82,33 @@ static inline struct crs_nodedims *__dup_dims(const struct crs_nodedims *dims) {
return dup; return dup;
} }
static struct crs_nodedims *get_dims(const struct crs_node *node) { static inline struct crs_nodedims *termdims(void) {
struct crs_nodedims *dims = __alloc_dims(0, 0, 0, 0);
termsize(dims->width, dims->height);
return dims;
}
static inline void nodesize(const struct crs_node *const node, int *const width,
int *const height) {
if (node->type == NODE_WINDOW) {
/* Window Node */
getmaxyx(node->win, *height, *width);
} else {
/* Abstract Node */
assert(node->type == NODE_ABSTRACT);
*width = node->dims->width;
*height = node->dims->height;
}
}
static inline struct crs_nodedims *nodedims(const struct crs_node *const node) {
struct crs_nodedims *dims; struct crs_nodedims *dims;
if (node->type == NODE_WINDOW) { if (node->type == NODE_WINDOW) {
/* Window Node */ /* Window Node */
dims = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims)); dims = (struct crs_nodedims *)malloc(sizeof(struct crs_nodedims));
// GET_WNODEDIMS();
getbegyx(node->win, dims->y, dims->x); getbegyx(node->win, dims->y, dims->x);
getmaxyx(node->win, dims->height, dims->width); 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 { } else {
/* Abstract Node */ /* Abstract Node */
assert(node->type == NODE_ABSTRACT); assert(node->type == NODE_ABSTRACT);
@ -87,30 +118,20 @@ static struct crs_nodedims *get_dims(const struct crs_node *node) {
return 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. /* Calculate the dimensions for nodes resulting from a bifurcation.
* Returns 0 on success, and 1 on failure if any width/height are 0 characters. * 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: This function does not guarantee the x,y positions returned
* WARNING: are valid screen coordinates. * WARNING: are valid screen coordinates.
*/ */
static int bifurcate_dims(const struct crs_node *parent, static int bifurcate_dims(const struct crs_nodedims *const parent_dims,
const enum crs_axis axis, const float ratio, const enum crs_axis axis, const float ratio,
struct crs_nodedims **dims0, struct crs_nodedims **const dims0,
struct crs_nodedims **dims1) { struct crs_nodedims **const dims1) {
assert(0 < ratio && ratio < 1); assert(0 < ratio && ratio < 1);
struct crs_nodedims *_dims0, *_dims1; struct crs_nodedims *_dims0, *_dims1;
_dims0 = get_dims(parent); _dims0 = __dup_dims(parent_dims);
_dims1 = __dup_dims(_dims0); _dims1 = __dup_dims(parent_dims);
printf("widthP: %d\n", _dims0->width);
printf("heightP: %d\n", _dims0->height);
if (axis == AXIS_X) { if (axis == AXIS_X) {
_dims0->width *= ratio; _dims0->width *= ratio;
@ -122,13 +143,8 @@ static int bifurcate_dims(const struct crs_node *parent,
_dims1->y += _dims0->height; _dims1->y += _dims0->height;
} }
if (!_dims0->width || !_dims0->height || !_dims1->width || !_dims1->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; return 1;
}
// propagate bifurcated dimensions // propagate bifurcated dimensions
*dims0 = _dims0; *dims0 = _dims0;
@ -136,11 +152,13 @@ static int bifurcate_dims(const struct crs_node *parent,
return 0; return 0;
} }
static void resize_node(struct crs_node *node, struct crs_nodedims *new_dims) { static void resize_node(struct crs_node *const node,
struct crs_nodedims *const new_dims) {
if (node->type == NODE_WINDOW) { if (node->type == NODE_WINDOW) {
/* Window Node */ /* Window Node */
resizemv_window(new_dims->x, new_dims->y, new_dims->width, new_dims->height, resizemv_window(new_dims->x, new_dims->y, new_dims->width, new_dims->height,
node->win); node->win);
wrefresh(node->win);
free(new_dims); free(new_dims);
} else { } else {
/* Abstract Node */ /* Abstract Node */
@ -149,7 +167,7 @@ static void resize_node(struct crs_node *node, struct crs_nodedims *new_dims) {
free(node->dims); free(node->dims);
node->dims = new_dims; node->dims = new_dims;
bifurcate_dims(node, node->axis, node->ratio, &dims0, &dims1); bifurcate_dims(new_dims, node->axis, node->ratio, &dims0, &dims1);
resize_node(node->child[0], dims0); resize_node(node->child[0], dims0);
resize_node(node->child[1], dims1); resize_node(node->child[1], dims1);
@ -162,17 +180,21 @@ static void resize_node(struct crs_node *node, struct crs_nodedims *new_dims) {
* axis - controls which direction the subdivision occurs * axis - controls which direction the subdivision occurs
* invert_axis - invert index of the original node in the new abstract node * 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, void bifurcate_window_node(struct crs_node **const node,
const int invert_axis, const float ratio) { const enum crs_axis axis, const int invert_axis,
const float ratio) {
assert((*node)->type == NODE_WINDOW); assert((*node)->type == NODE_WINDOW);
struct crs_nodedims *dims0, *dims1; struct crs_nodedims *dims0, *dims1;
struct crs_node *node0, *node1; struct crs_node *node0, *node1;
if (bifurcate_dims(*node, axis, ratio, &dims0, &dims1)) { struct crs_nodedims *original_dims = nodedims(*node);
printf("FAILED TERRIBLY THE FUCK\n"); if (bifurcate_dims(original_dims, axis, ratio, &dims0, &dims1)) {
/* TODO: handle this error properly */
free(original_dims);
exit(1); exit(1);
return; return;
} }
if (invert_axis) { if (invert_axis) {
/* Inverted Bifurcation */ /* Inverted Bifurcation */
node0 = auto_window_node(dims0); node0 = auto_window_node(dims0);
@ -185,13 +207,13 @@ void bifurcate_window_node(struct crs_node **node, const enum crs_axis axis,
resize_node(node0, dims0); resize_node(node0, dims0);
} }
*node = init_abstract_node(node0, node1, axis, ratio, (*node)->dims); *node = init_abstract_node(node0, node1, axis, ratio, original_dims);
} }
/* Collapse an abstract node, killing one child node and resizing /* Collapse an abstract node, killing one child node and resizing
* the other to take its place. * the other to take its place.
*/ */
static void collapse_abstract_node(struct crs_node **node, static void collapse_abstract_node(struct crs_node **const node,
const int collapse_i) { const int collapse_i) {
assert((*node)->type == NODE_ABSTRACT); assert((*node)->type == NODE_ABSTRACT);
assert(0 <= collapse_i && collapse_i < NODE_CHILD_N); assert(0 <= collapse_i && collapse_i < NODE_CHILD_N);
@ -213,7 +235,7 @@ static struct crs_node *init_root_node(void) {
return init_window_node(rootwin); return init_window_node(rootwin);
} }
int init_cursetree(struct crs_tree **const tree) { int ct_init(struct crs_tree **const tree) {
*tree = (struct crs_tree *)malloc(sizeof(struct crs_tree)); *tree = (struct crs_tree *)malloc(sizeof(struct crs_tree));
/* Initialise NCurses Library & Root Node */ /* Initialise NCurses Library & Root Node */
@ -224,9 +246,7 @@ int init_cursetree(struct crs_tree **const tree) {
} }
void destroy_tree(struct crs_tree *const tree) { void destroy_tree(struct crs_tree *const tree) {
/* WARNING: is it ok to delwin(stdscr) ?? */
destroy_node(tree->root); destroy_node(tree->root);
endwin(); endwin();
free(tree); free(tree);
} }
@ -234,3 +254,19 @@ void destroy_tree(struct crs_tree *const tree) {
void resize_tree(struct crs_tree *const tree, struct crs_nodedims *const dims) { void resize_tree(struct crs_tree *const tree, struct crs_nodedims *const dims) {
resize_node(tree->root, dims); resize_node(tree->root, dims);
} }
void ct_update(struct crs_tree *const tree) {
struct crs_nodedims *term_dims;
int term_width, term_height, win_width, win_height;
termsize(term_width, term_height);
nodesize(tree->root, &win_width, &win_height);
/* Check if window size has changed, I assume ncurses already binds
* a SIGWINCH handler so we can do this instead (TODO: sighandler?) */
if (win_width != term_width || win_height != term_height) {
term_dims = __alloc_dims(0, 0, term_width, term_height);
resize_tree(tree, term_dims);
/* TODO: why the fuck does this line make everything work?? */
wrefresh(tree->root->child[0]->win);
}
}

8
cli/tree.h
View file

@ -51,11 +51,13 @@ struct crs_tree {
}; };
/* === External Interface === */ /* === External Interface === */
int init_cursetree(struct crs_tree **const tree); int ct_init(struct crs_tree **const tree);
void destroy_tree(struct crs_tree *const tree); void destroy_tree(struct crs_tree *const tree);
void resize_tree(struct crs_tree *const tree, struct crs_nodedims *const dims); void resize_tree(struct crs_tree *const tree, struct crs_nodedims *const dims);
void ct_update(struct crs_tree *const tree);
void bifurcate_window_node(struct crs_node **node, const enum crs_axis axis, void bifurcate_window_node(struct crs_node **const node,
const int invert_axis, const float ratio); const enum crs_axis axis, const int invert_axis,
const float ratio);
#endif /* DORNE_TREE_H */ #endif /* DORNE_TREE_H */