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

fixed missing gaps showing

Browse source
This commit is contained in:
Emile Clark-Boman 2025-09-16 23:08:44 +10:00
parent dce97e6b3e
commit 9a6786b2b5
3 changed files with 58 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

48
cli/main.c
View file

@ -5,6 +5,12 @@
#include <ncursesw/ncurses.h> #include <ncursesw/ncurses.h>
#include "cursetree.h" #include "cursetree.h"
#include "surface.h"
#define nprintsfdims(nout, i, label, nin) \
(mvwprintw((nout)->surface->win, (i), 0, "%s@(%d,%d) %dx%d", (label), \
(nin)->surface->dims->x, (nin)->surface->dims->y, \
(nin)->surface->dims->width, (nin)->surface->dims->height))
int main(int argc, char **argv) { int main(int argc, char **argv) {
struct ct_tree *tree; struct ct_tree *tree;
@ -13,37 +19,47 @@ int main(int argc, char **argv) {
init_pair(1, COLOR_BLACK, COLOR_CYAN); init_pair(1, COLOR_BLACK, COLOR_CYAN);
init_pair(2, COLOR_BLACK, COLOR_RED); init_pair(2, COLOR_BLACK, COLOR_RED);
init_pair(3, COLOR_BLACK, COLOR_GREEN); init_pair(3, COLOR_BLACK, COLOR_GREEN);
init_pair(4, COLOR_BLACK, COLOR_MAGENTA);
init_pair(5, COLOR_BLACK, COLOR_YELLOW);
// wbkgd(tree->root->surface->win, COLOR_PAIR(1));
// wrefresh(tree->root->surface->win);
struct ct_node *const child1 = new_node(bounds_none(), tree->root); struct ct_node *const child1 = new_node(bounds_none(), tree->root);
struct ct_node *const child2 = new_node(bounds_none(), tree->root); struct ct_node *const child2 = new_node(bounds_none(), tree->root);
struct ct_node *const child3 = new_node(bounds_none(), tree->root); struct ct_node *const child3 = new_node(bounds_none(), tree->root);
struct ct_node *const child4 = new_node(bounds_none(), tree->root);
struct ct_node *const child5 = new_node(bounds_none(), tree->root);
append_child_node(tree->root, child1); append_child_node(tree->root, child1);
append_child_node(tree->root, child2); append_child_node(tree->root, child2);
append_child_node(tree->root, child3); append_child_node(tree->root, child3);
append_child_node(tree->root, child4);
append_child_node(tree->root, child5);
wbkgd(child1->surface->win, COLOR_PAIR(1)); wbkgd(child1->surface->win, COLOR_PAIR(1));
wbkgd(child2->surface->win, COLOR_PAIR(2)); wbkgd(child2->surface->win, COLOR_PAIR(2));
wbkgd(child3->surface->win, COLOR_PAIR(3)); wbkgd(child3->surface->win, COLOR_PAIR(3));
wbkgd(child4->surface->win, COLOR_PAIR(4));
wbkgd(child5->surface->win, COLOR_PAIR(5));
// wrefresh(child1->surface->win); child3->axis = AXIS_Y;
struct ct_node *const child3_1 = new_node(bounds_none(), child3);
mvwprintw(child2->surface->win, 0, 0, "1@(%d,%d) %dx%d\n", struct ct_node *const child3_2 = new_node(bounds_none(), child3);
child1->surface->dims->x, child1->surface->dims->y, append_child_node(child3, child3_1);
child1->surface->dims->width, child1->surface->dims->height); append_child_node(child3, child3_2);
mvwprintw(child2->surface->win, 1, 0, "2@(%d,%d) %dx%d\n", wbkgd(child3_1->surface->win, COLOR_PAIR(1));
child2->surface->dims->x, child2->surface->dims->y, wbkgd(child3_2->surface->win, COLOR_PAIR(5));
child2->surface->dims->width, child2->surface->dims->height);
mvwprintw(child2->surface->win, 1, 0, "2@(%d,%d) %dx%d\n",
child3->surface->dims->x, child3->surface->dims->y,
child3->surface->dims->width, child3->surface->dims->height);
while (1) { while (1) {
nprintsfdims(child2, 0, "R", tree->root);
nprintsfdims(child2, 1, "1", child1);
nprintsfdims(child2, 2, "2", child2);
nprintsfdims(child2, 3, "3", child3);
nprintsfdims(child2, 4, "4", child4);
nprintsfdims(child2, 5, "5", child5);
nprintsfdims(child2, 7, "3_1", child3_1);
nprintsfdims(child2, 8, "3_2", child3_2);
ct_update(tree); ct_update(tree);
// napms(100);
} }
destroy_tree(tree); destroy_tree(tree);

34
cursetree/dims.c
View file

@ -86,37 +86,3 @@ struct ct_bounds *dup_bounds(const struct ct_bounds *const bounds) {
return dup; return dup;
} }
/* 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.
*/
// int bifurcate_dims(const struct ct_dims *const parent_dims,
// const enum ct_axis axis, const float ratio,
// struct ct_dims **const dims0, struct ct_dims **const
// dims1) {
// assert(0 < ratio && ratio < 1);
// struct ct_dims *_dims0, *_dims1;
// _dims0 = dup_dims(parent_dims);
// _dims1 = dup_dims(parent_dims);
// 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)
// return 1;
// // propagate bifurcated dimensions
// *dims0 = _dims0;
// *dims1 = _dims1;
// return 0;
// }

56
cursetree/node.c
View file

@ -103,42 +103,36 @@ int resize_node(struct ct_node *const node, struct ct_dims *dims) {
} }
int axm_size, axm_free; int axm_size, axm_free;
/* DEBUG: WARNING :DEBUG */ size_t bounds_axm_min_offset, bounds_axm_max_offset;
// size_t bounds_axm_min_offset, bounds_axm_max_offset; size_t dims_axm_pos_offset, dims_axm_size_offset;
// size_t dims_axm_pos_offset, dims_axm_size_offset;
if (node->axis == AXIS_X) { if (node->axis == AXIS_X) {
axm_free = dims->width; axm_free = dims->width;
axm_size = dims->width; axm_size = dims->width;
/* DEBUG: WARNING :DEBUG */ dims_axm_pos_offset = offsetof(struct ct_dims, x);
// dims_axm_pos_offset = offsetof(struct ct_dims, x); dims_axm_size_offset = offsetof(struct ct_dims, width);
// dims_axm_size_offset = offsetof(struct ct_dims, width); bounds_axm_min_offset = offsetof(struct ct_bounds, wmin);
// bounds_axm_min_offset = offsetof(struct ct_bounds, wmin); bounds_axm_max_offset = offsetof(struct ct_bounds, wmax);
// bounds_axm_max_offset = offsetof(struct ct_bounds, wmax);
} else { } else {
assert(node->axis == AXIS_Y); assert(node->axis == AXIS_Y);
axm_free = dims->height; axm_free = dims->height;
axm_size = dims->height; axm_size = dims->height;
/* DEBUG: WARNING :DEBUG */ dims_axm_pos_offset = offsetof(struct ct_dims, y);
// dims_axm_pos_offset = offsetof(struct ct_dims, y); dims_axm_size_offset = offsetof(struct ct_dims, height);
// dims_axm_size_offset = offsetof(struct ct_dims, height); bounds_axm_min_offset = offsetof(struct ct_bounds, hmin);
// bounds_axm_min_offset = offsetof(struct ct_bounds, hmin); bounds_axm_max_offset = offsetof(struct ct_bounds, hmax);
// bounds_axm_max_offset = offsetof(struct ct_bounds, hmax);
} }
struct ct_spdims cspdims[node->cindex]; struct ct_spdims cspdims[node->cindex];
cindex parts_n = node->cindex; cindex parts_n = node->cindex;
memset(cspdims, 0, sizeof(struct ct_spdims) * node->cindex); memset(cspdims, 0, sizeof(struct ct_spdims) * node->cindex);
for (int i = 0; i < node->cindex; i++) { for (int i = 0; i < node->cindex; i++) {
/* DEBUG: WARNING :DEBUG */ cspdims[i].min = *(int *)((char *)node->child[i]->surface->bounds +
// cspdims[i].min = bounds_axm_min_offset);
// *(int *)(node->child[i]->surface->bounds + bounds_axm_min_offset); cspdims[i].max = *(int *)((char *)node->child[i]->surface->bounds +
// cspdims[i].max = bounds_axm_max_offset);
// *(int *)(node->child[i]->surface->bounds + bounds_axm_max_offset);
cspdims[i].min = node->child[i]->surface->bounds->wmin;
cspdims[i].max = node->child[i]->surface->bounds->wmax;
if (node->child[i]->surface->bounds->type == BOUND_RELATIVE) { if (node->child[i]->surface->bounds->type == BOUND_RELATIVE) {
cspdims[i].min *= axm_size; cspdims[i].min *= axm_size;
@ -149,14 +143,15 @@ int resize_node(struct ct_node *const node, struct ct_dims *dims) {
} }
int split, new_size; int split, new_size;
while (parts_n) { while (axm_free && parts_n) {
split = axm_free / parts_n; split = (axm_free > parts_n) ? (axm_free / parts_n) : 1;
for (int i = 0; i < node->cindex; i++) { for (int i = 0; i < node->cindex; i++) {
if (cspdims[i].fixed) if (cspdims[i].fixed)
continue; continue;
new_size = new_size =
clampi(cspdims[i].axm_size + split, cspdims[i].min, cspdims[i].max); clampi(cspdims[i].axm_size + split, cspdims[i].min, cspdims[i].max);
if (new_size == cspdims[i].axm_size) { if (new_size == cspdims[i].axm_size) {
cspdims[i].fixed = true; cspdims[i].fixed = true;
parts_n--; parts_n--;
@ -165,22 +160,23 @@ int resize_node(struct ct_node *const node, struct ct_dims *dims) {
axm_free -= (new_size - cspdims[i].axm_size); axm_free -= (new_size - cspdims[i].axm_size);
cspdims[i].axm_size = new_size; cspdims[i].axm_size = new_size;
if (axm_free == 0)
break;
} }
} }
struct ct_dims *cdims = dup_dims(dims); struct ct_dims *cdims = dup_dims(dims);
/* NOTE: the statements below are done implicitly by dup_dims */ /* NOTE: the statements below are done implicitly by dup_dims */
// *(int*)(cdims + dims_axm_pos_offset) = *(int*)(dims + dims_axm_pos_offset); // *(int*)(cdims + dims_axm_pos_offset) = *(int*)(dims +
// *(int*)(cdims + dims_axo_pos_offset) = *(int*)(dims + dims_axo_pos_offset); // dims_axm_pos_offset);
// *(int*)(cdims + dims_axo_pos_offset) = *(int*)(dims +
// dims_axo_pos_offset);
// *(int*)(cdims + dims_axo_size_offset) = axo_size; // *(int*)(cdims + dims_axo_size_offset) = axo_size;
for (int i = 0; i < node->cindex; i++) { for (int i = 0; i < node->cindex; i++) {
/* DEBUG: WARNING :DEBUG */ *(int *)((char *)cdims + dims_axm_size_offset) = cspdims[i].axm_size;
// *(int *)(cdims + dims_axm_size_offset) = cspdims[i].axm_size;
cdims->width = cspdims[i].axm_size;
resize_node(node->child[i], dup_dims(cdims)); resize_node(node->child[i], dup_dims(cdims));
/* DEBUG: WARNING :DEBUG */ *(int *)((char *)cdims + dims_axm_pos_offset) += cspdims[i].axm_size;
// *(int *)(cdims + dims_axm_pos_offset) += cspdims[i].axm_size;
cdims->x += cspdims[i].axm_size;
} }
free(cdims); free(cdims);