diff options
Diffstat (limited to 'src/ui_positioning.c')
| -rw-r--r-- | src/ui_positioning.c | 877 |
1 files changed, 877 insertions, 0 deletions
diff --git a/src/ui_positioning.c b/src/ui_positioning.c new file mode 100644 index 0000000..fc8ab0a --- /dev/null +++ b/src/ui_positioning.c @@ -0,0 +1,877 @@ +#include <SDL2/SDL.h> +#include <SDL2/SDL_image.h> +#include <SDL2/SDL_ttf.h> + +#include <stdint.h> +#define ENGINE_INTERNALS + +#include <engine/engine.h> +#include <engine/btree.h> + +static Engine_color DEFAULT_FG = {0xFF, 0xFF, 0xFF, 0xFF}; +static Engine_color DEFAULT_BG = {0x00, 0x00, 0x00, 0xFF}; +static i32 DEFAULT_PADDING = 8; +static i32 DEFAULT_MARGIN = 0; + +/* We want to keep track of the roots of the UI elements, s.t. we can resize and + * reposition the elements if needed be. */ +struct btree *GLOBAL_UIROOTS = NULL; + +extern Platform *GLOBAL_PLATFORM; + +const char *uitype_str[] = { + [uitype_container] = "uitype_container", + [uitype_button] = "uitype_button", + [uitype_title] = "uitype_title", + [uitype_text] = "uitype_text", + [uitype_MAX] = "uitype_MAX", + NULL, +}; + +const char *constraint_str[] = { + [ui_constraint_width] = "ui_constraint_width", + [ui_constraint_height] = "ui_constraint_height", + + [ui_constraint_horizontal_align] = "ui_constraint_horizontal_align", + [ui_constraint_vertical_align] = "ui_constraint_vertical_align", + + [ui_constraint_left] = "ui_constraint_left", + [ui_constraint_right] = "ui_constraint_right", + [ui_constraint_top] = "ui_constraint_top", + [ui_constraint_bottom] = "ui_constraint_bottom", +}; + +static i32 pointer_cmp(const void *a, const void *b) { + const u64 *x = a; + const u64 *y = b; + /* We just use the address as index */ + return *x - *y; +} + +static void pointer_print(const void *a) { + const u64 *t = a; + printf("%lx\n", *t); +} + +void ui_rearrange(UITree *root, v2_i32 ppos, v2_i32 psize); +i32 get_padding(UITree *t); +i32 get_margin(UITree *t); +v2_i32 get_pos(UITree *t); +v2_i32 get_size(UITree *t); + +f32 ui_size_pixel_to_percent_width(i32 pixels) { + return (f32)pixels / (f32)GLOBAL_PLATFORM->window->windowsize.x; +} + +f32 ui_size_pixel_to_percent_height(i32 pixels) { + return (f32)pixels / (f32)GLOBAL_PLATFORM->window->windowsize.y; +} + +f32 ui_size_pixel_to_percent(i32 pixels) { return ui_size_percent_height_to_pixel(pixels); } + +i32 ui_size_percent_width_to_pixel(f32 percent) { + return (i32)(percent * GLOBAL_PLATFORM->window->windowsize.x); +} + +i32 ui_size_percent_height_to_pixel(f32 percent) { + return (i32)(percent * GLOBAL_PLATFORM->window->windowsize.y); +} + +i32 ui_size_percent_to_pixel(f32 percent) {return ui_size_percent_height_to_pixel(percent); } + +i32 ui_size_to_pixel_ex(ui_size s, bool vertical, v2_i32 psize) { + if (s.type == ui_size_pixel) { + return s.pixel.value; + } else { + psize.x = MAX(1, psize.x); + psize.y = MAX(1, psize.y); + if (vertical) { + return psize.y * s.percent.value; + } + return psize.x * s.percent.value; + } +} + +i32 ui_size_to_pixel(ui_size s) { + if (s.type == ui_size_pixel) { + return s.pixel.value; + } else { + return ui_size_percent_height_to_pixel(s.percent.value); + } +} + +void ui_add(UITree *t) { + + if (GLOBAL_UIROOTS == NULL) { + GLOBAL_UIROOTS = btree_new(sizeof(void*), 16, &pointer_cmp); + } + + u64 tmp = (u64)t; + btree_insert(GLOBAL_UIROOTS, &tmp); +} + +void clear_ui(void) { + UITree *t = NULL; + while((t = btree_first(GLOBAL_UIROOTS)) != NULL) { + uitree_free(t); + if (!btree_delete(GLOBAL_UIROOTS, t)) { + WARN("Failed deletion"); + UITree *elem = (UITree*)t; + WARN("Failed to remove %s from global ui-table", uitype_str[elem->type]); + } + } +} + + +/* Unwraps the size to a v2_i32 */ +v2_i32 uitree_get_size(UITree *t) { + if (t == NULL) return (v2_i32){.x=-1, .y=-1}; + switch (t->type) { + case uitype_container: return (v2_i32){.x=t->container.w, .y=t->container.h}; + case uitype_button: return (v2_i32){.x=t->button.w, .y=t->button.h}; + case uitype_title: return (v2_i32){.x=t->title.w, .y=t->title.h}; + case uitype_text: return (v2_i32){.x=t->text.w, .y=t->text.h}; + default: return (v2_i32){.x=-1, .y=-1}; + } +} + + +/* elem_size also takes into account the padding and other stuffs */ +v2_i32 elem_size(UITree *root) { + if (root == NULL) return (v2_i32){0,0}; + + const i32 total_padding = 2 * get_padding(root); + return v2_i32_add_i(uitree_get_size(root), total_padding); +} + +v2_i32 elem_size_spacing(UITree *root) { + if (root == NULL) return (v2_i32){0,0}; + + const i32 total_margin = 2 * get_padding(root) + 2 * get_margin(root); + return v2_i32_add_i(uitree_get_size(root), total_margin); +} + +UITree *ui_container_new_ex( + Engine_color fg, + Engine_color bg, + Engine_color border, + bool direction, + struct List_ui_constraint *constraints) { + + UITree *t = malloc(sizeof(UITree)); + + t->container.type = uitype_container; + t->container.visible = true; + t->container.direction = direction; + + /* -1 == unsolved constraint */ + t->container.x = -1; + t->container.y = -1; + t->container.w = -1; + t->container.h = -1; + t->container.padding = 0; + t->container.margin = 0; + + t->container.fg = fg; + t->container.bg = bg; + t->container.bordercolor = border; + + + t->container.children = NULL; + t->container.children_len = 0; + t->container.children_size = 0; + + t->container.constraints = constraints; + + ui_rearrange(t, (v2_i32){0,0}, (v2_i32){0,0}); + + ui_add(t); + + return t; +} + +UITree *ui_container(bool direction, struct List_ui_constraint *constraints) { + return ui_container_new_ex( + /* We set border color to fg by default */ + DEFAULT_FG, DEFAULT_BG, DEFAULT_FG, direction, + constraints); +} + +UITree *ui_title(i32 font_id, const char *text, struct List_ui_constraint *constraints) { + UITree_title *t = malloc(sizeof(UITree)); + t->type = uitype_title; + + t->x = -1; + t->y = -1; + + t->padding = DEFAULT_PADDING; + t->margin = DEFAULT_MARGIN; + + t->fg = DEFAULT_FG; + + t->font_id = font_id; + t->text_original = text; + t->text_texture_index = + engine_render_text(font_id, t->fg, (char*)text, &t->texture_size, false); + + t->w = t->texture_size.x; + t->h = t->texture_size.y; + + t->constraints = constraints; + + ui_rearrange((UITree*)t, (v2_i32){0,0}, (v2_i32){0,0}); + + ui_add((UITree*)t); + + return (UITree*)t; +} + +UITree *ui_text(i32 font_id, const char *text, struct List_ui_constraint *constraints) { + UITree *t = malloc(sizeof(UITree)); + t->text.type = uitype_text; + + t->text.x = -1; + t->text.y = -1; + + t->text.padding = 0; + t->text.margin = DEFAULT_MARGIN / 2; + + t->text.fg = DEFAULT_FG; + + t->text.font_id = font_id; + t->text.text_original = text; + + /* Postpone rendering until we have a clear set of size-constraints */ + + //t->text.text_texture_index = + // engine_render_text(font_id, DEFAULT_FG, (char*)text, &t->text.texture_size, true); + + //t->text.w = t->text.texture_size.x; + //t->text.h = t->text.texture_size.y; + + t->text.constraints = constraints; + + ui_rearrange(t, (v2_i32){0,0}, (v2_i32){0,0}); + + ui_add(t); + + return t; +} + +UITree *ui_button(u64 id, i32 font_id, char *text, struct List_ui_constraint *constraints) { + UITree_button *t = malloc(sizeof(UITree)); + t->type = uitype_button; + + t->enabled = true; + t->id = id; + t->x = -1; + t->y = -1; + t->padding = DEFAULT_PADDING; + t->margin = DEFAULT_MARGIN; + + t->fg = DEFAULT_FG; + t->bg = DEFAULT_BG; + + t->font_id = font_id; + t->text_original = text; + t->text_texture_index = + engine_render_text(font_id, t->fg, (char*)text, &t->texture_size, false); + + t->w = t->texture_size.x; + t->h = t->texture_size.y; + + t->constraints = constraints; + + ui_rearrange((UITree*)t, (v2_i32){0,0}, (v2_i32){0,0}); + + ui_add((UITree*)t); + + return (UITree*)t; +} + +void uitree_free(UITree *t) { + switch (t->type) { + case uitype_container: + if (t->container.children != NULL && t->container.children_len > 0) { + for (usize i = 0; i < t->container.children_len; i++) { + uitree_free(t->container.children[i]); + } + free(t->container.children); + } + break; + case uitype_button: + case uitype_title: + case uitype_text: + free(t); + break; + default: break; + } +} + + +struct List_ui_constraint* get_constraints(UITree *t) { + switch (t->type) { + case uitype_container: return t->container.constraints; + case uitype_button: return t->button.constraints; + case uitype_title: return t->title.constraints; + case uitype_text: return t->text.constraints; + default: return NULL; + } +} + + +i32 get_padding(UITree *t) { + switch (t->type) { + case uitype_container: return t->container.padding; + case uitype_button: return t->button.padding; + case uitype_title: return t->title.padding; + case uitype_text: return t->text.padding; + default: return 0; + } +} + + +i32 get_margin(UITree *t) { + switch (t->type) { + case uitype_container: return t->container.margin; + case uitype_button: return t->button.margin; + case uitype_title: return t->title.margin; + case uitype_text: return t->text.margin; + default: return 0; + } +} + +v2_i32 get_pos(UITree *t) { + switch (t->type) { + case uitype_container: return (v2_i32){t->container.x, t->container.y}; + case uitype_button: return (v2_i32){t->button.x, t->button.y}; + case uitype_title: return (v2_i32){t->title.x, t->title.y}; + case uitype_text: return (v2_i32){t->text.x, t->text.y}; + default: return (v2_i32){0, 0}; + } +} + +v2_i32 get_size(UITree *t) { + switch (t->type) { + case uitype_container: return (v2_i32){t->container.w, t->container.h}; + case uitype_button: return (v2_i32){t->button.w, t->button.h}; + case uitype_title: return (v2_i32){t->title.w, t->title.h}; + case uitype_text: return (v2_i32){t->text.w, t->text.h}; + default: return (v2_i32){0, 0}; + } +} + +#define SETVAL(VAL, tt) { if ((VAL) > 0) t->tt = VAL; } +void uitree_set_pos(UITree *t, v2_i32 newpos) { + switch (t->type) { + case uitype_container: SETVAL( newpos.x, container.x); SETVAL( newpos.y, container.y); break; + case uitype_button: SETVAL( newpos.x, button.x ); SETVAL( newpos.y, button.y ); break; + case uitype_title: SETVAL( newpos.x, title.x ); SETVAL( newpos.y, title.y ); break; + case uitype_text: SETVAL( newpos.x, text.x ); SETVAL( newpos.y, text.y ); break; + default: return; + } +} + + +void uitree_set_size(UITree *t, v2_i32 size) { + switch (t->type) { + case uitype_container: SETVAL( size.x, container.w); SETVAL( size.y, container.h); break; + case uitype_button: SETVAL( size.x, button.w ); SETVAL( size.y, button.h ); break; + case uitype_title: SETVAL( size.x, title.w ); SETVAL( size.y, title.h ); break; + case uitype_text: SETVAL( size.x, text.w ); SETVAL( size.y, text.h ); break; + default: return; + } +} + + +bool uitree_has_constraint(UITree *t, const ui_constraint_t constraint) { + struct List_ui_constraint* c = NULL; + struct List_ui_constraint* first_constraint; + if (t == NULL) {ERROR("%s got nullptr argument!", __func__); exit(EXIT_FAILURE);} + + switch (t->type) { + case uitype_container: c = t->container.constraints; break; + case uitype_button: c = t->button.constraints; break; + case uitype_title: c = t->title.constraints; break; + case uitype_text: c = t->text.constraints; break; + default: break; + } + + first_constraint = c; + + while (c != NULL) { + if ((void*)c->next == (void*)first_constraint) { + ERROR("Infinite constraint loop detected!"); + exit(EXIT_FAILURE); + } + if (constraint == c->value.type) return true; + + c = c->next; + } + return false; +} + + +void ui_constraints_apply(UITree *t, v2_i32 ppos, v2_i32 psize) { + struct List_ui_constraint* constraints = get_constraints(t); + struct List_ui_constraint* first_constraint = constraints; + v2_i32 tsize = uitree_get_size(t); + + if (constraints == NULL) return; + + while (constraints != NULL) { + if ((void*)constraints->next == (void*)first_constraint) { + ERROR("Infinite constraint loop detected!"); + ERROR(" Type: %s", constraint_str[constraints->value.type]); + exit(EXIT_FAILURE); + } + + const constraintval_t con = constraints->value.constraint; + + switch(constraints->value.type) { + case ui_constraint_width: + { + i32 ww = ui_size_to_pixel_ex(con.width.size, false, psize); + if (con.width.size.type == ui_size_percent) ww -= 2 * get_padding(t); + /* FIXME: Resizing the window makes some elements retain their + * size on window resize. + * This is fixed by replacing MAX(...) with just `ww`, + * This in turn makes elements that are supposed to have some + * relative width not take up the full width. */ + uitree_set_size(t, (v2_i32){.x=MAX(tsize.x, ww), .y=0}); + tsize = uitree_get_size(t); + } + break; + + case ui_constraint_height: + { + i32 ww = ui_size_to_pixel_ex(con.height.size, true, psize); + if (con.height.size.type == ui_size_percent) ww -= 2 * get_padding(t); + /* FIXME: Same as above */ + uitree_set_size(t, (v2_i32){.y=MAX(tsize.y, ww), .x=0}); + tsize = uitree_get_size(t); + } + break; + + + case ui_constraint_horizontal_align: + { + const i32 size = ui_size_to_pixel_ex(con.horizontal_align.spacing, false, psize); + i32 new_x = ppos.x; + switch (con.horizontal_align.align) { + case ui_constraint_horizontal_align_left: + new_x += size + get_margin(t); + break; + case ui_constraint_horizontal_align_center: + new_x += (psize.x / 2) - (tsize.x / 2); + break; + case ui_constraint_horizontal_align_right: + new_x += psize.x - size - tsize.x - get_margin(t); + break; + } + uitree_set_pos(t, (v2_i32){.x = new_x, .y = 0}); + } + break; + + case ui_constraint_vertical_align: + { + i32 size = ui_size_to_pixel_ex(con.horizontal_align.spacing, true, psize); + i32 new_y = ppos.y; + switch (con.vertical_align.align) { + case ui_constraint_vertical_align_top: + new_y += size + get_margin(t); + break; + case ui_constraint_vertical_align_center: + new_y += ((psize.y) / 2) - (tsize.y / 2); + break; + case ui_constraint_vertical_align_bottom: + new_y += psize.y - size - tsize.y - get_margin(t); + break; + } + uitree_set_pos(t, (v2_i32){.x = 0, .y = new_y}); + } + break; + + case ui_constraint_left: + uitree_set_pos(t, (v2_i32){ + .x = ppos.x + ui_size_to_pixel_ex(con.left.pos, false, psize), + .y=0 + }); + break; + + case ui_constraint_top: + uitree_set_pos(t, (v2_i32){ + .y = ppos.y + ui_size_to_pixel_ex(con.top.pos, true, psize), + .x=0 + }); + break; + + case ui_constraint_right: + if (tsize.x > 0) + uitree_set_pos(t, (v2_i32){ + .x = ppos.x + psize.x - ui_size_to_pixel_ex(con.right.pos, false, psize) - tsize.x, + .y=0 + }); + break; + + case ui_constraint_bottom: + if (tsize.y > 0) + uitree_set_pos(t, (v2_i32){ + .y = ppos.y + psize.y - ui_size_to_pixel_ex(con.bottom.pos, true, psize) - tsize.y, + .x = 0 + }); + break; + + default: + ERROR("Unknown constraint: %d", constraints->value.type); + exit(EXIT_FAILURE); + break; + } + + constraints = constraints->next; + } +} + +void ui_rearrange_container(UITree_container *c, v2_i32 ppos, v2_i32 psize) { + struct List_ui_constraint* constraints = c->constraints; + struct List_ui_constraint* first_constraint = constraints; + bool fitwidth = !uitree_has_constraint((UITree*)c, ui_constraint_width); + bool fitheight = !uitree_has_constraint((UITree*)c, ui_constraint_height); + + if (fitwidth) c->w = 0; + if (fitheight) c->h = 0; + + ui_constraints_apply((UITree*)c, ppos, psize); + /* Apply constraints to children here? */ + { + const v2_i32 pos = v2_i32_sub_i((v2_i32){.x=c->x, .y=c->y}, 0);//c->margin); + const v2_i32 size = v2_i32_sub_i((v2_i32){.x=c->w, .y=c->h}, (2+MAX(c->children_len-1, 0)) * c->padding); + for (usize cc = 0; cc < c->children_len; cc++) { + ui_rearrange(c->children[cc], pos, size); + } + } + + /* TODO: We want to update children regardless of whether we are doing a fit + * on the size of children. Switch the conditions (fitwidth||fitheight) and + * (children_len > 0); the size-fit doesn't matter if there's no children, + * the childrens size only matters if we do a size-fit. */ + + /* If we do not have a size > -1 we need to adapt the size to all children + * and add a size constraint on the largest of one of them */ + if (fitwidth || fitheight) { + + i32 maxwidth = 2 * c->padding; + i32 maxheight = maxwidth; + + if (c->children_len > 0) { + if (c->children == NULL) { + ERROR("Container has children_len(%d) > 0 but children pointer is NULL!", c->children_len); + exit(EXIT_FAILURE); + } + + /* Calculate new posisitions and save the largest one */ + v2_i32 startpos = (v2_i32){.x=c->x + c->margin, .y=c->y + c->margin}; + v2_i32 startsize = (v2_i32){.x=c->w - (2 * c->padding), .y=c->h - (2 * c->padding)}; + + for (usize cc = 0; cc < c->children_len; cc++) { + const v2_i32 childsize = elem_size(c->children[cc]); + i32 margin = (cc + 1 == c->children_len) ? 0 : MAX(c->padding, get_margin(c->children[cc])); + + /* We just sum up in the direction we are going */ + if (c->direction == DIRECTION_HORIZONTAL) { + maxwidth += childsize.x + margin; + maxheight = MAX(childsize.y + 2 * c->padding, maxheight); + + startpos.x += childsize.x + margin; + startsize.x -= childsize.x + margin; + } else { + maxwidth = MAX(childsize.x + 2 * c->padding, maxwidth); + maxheight += childsize.y + margin; + + startpos.y += childsize.y + margin; + startsize.y -= childsize.y + margin; + } + } + + struct List_ui_constraint* constraint_head = c->constraints; + struct List_ui_constraint constraint_width; + struct List_ui_constraint constraint_height; + + if (fitwidth) { + /* Create new size constraint */ + constraint_width = (struct List_ui_constraint){ + .value = { + .type = ui_constraint_width, + .constraint.width = { + .size = ui_size_pixel_new(maxwidth), + }, + }, + .next = constraint_head, + }; + + /* Prepend it to the list of constraints */ + c->constraints = &constraint_width; + constraint_head = c->constraints; + } + if (fitheight) { + constraint_height = (struct List_ui_constraint){ + .value = { + .type = ui_constraint_height, + .constraint.height = { + .size = ui_size_pixel_new(maxheight), + }, + }, + .next = constraint_head, + }; + /* Prepend it to the list of constraints */ + c->constraints = &constraint_height; + //constraint_head = c->constraints; + /* TODO: Convert to scrollable container if the height is + * greater than some constant relative to the screen height */ + } + + /* Recurse with new constraints */ + ui_rearrange_container(c, ppos, psize); + + /* Replace the original set of constraints, as the new ones will be + * out of scope once we return from the current call frame */ + c->constraints = first_constraint; + + /* Update child elements */ + /* This is 1:1 (almost) to the previous iteration of children */ + startpos = (v2_i32){c->x + c->padding, c->y + c->padding}; + startsize = (v2_i32){c->w - 2 * c->padding, c->h - 2 * c->padding}; + + for (usize cc = 0; cc < c->children_len; cc++) { + v2_i32 childsize = elem_size(c->children[cc]); + i32 margin = MAX(c->padding, get_margin(c->children[cc])); + + v2_i32 startsize_2; + if (c->direction == DIRECTION_HORIZONTAL) { + startsize_2 = (v2_i32){childsize.x, startsize.y}; + } else { + startsize_2 = (v2_i32){startsize.x, childsize.y}; + } + ui_rearrange(c->children[cc], startpos, startsize_2); + + if (c->direction == DIRECTION_HORIZONTAL) { + maxwidth += childsize.x + margin; + maxheight = MAX(childsize.y, maxheight); + + startpos.x += childsize.x + margin; + startsize.x -= childsize.x + margin; + + } else { + maxwidth = MAX(childsize.x + 2 * c->padding, maxwidth); + maxheight += childsize.y + margin; + + startpos.y += childsize.y + margin; + startsize.y -= childsize.y + margin; + } + } + } + } +} + +void ui_rearrange_button(UITree_button *t, v2_i32 ppos, v2_i32 psize) { + t->x = ppos.x; + t->y = ppos.y; + + ui_constraints_apply((UITree*)t, ppos, psize); +} + +void ui_rearrange_title(UITree_title *t, v2_i32 ppos, v2_i32 psize) { + /*Defaults to just sit in the top-left corner of the parent*/ + t->x = ppos.x; + t->y = ppos.y; + + ui_constraints_apply((UITree*)t, ppos, psize); +} + +void ui_rearrange_text(UITree_text *t, v2_i32 ppos, v2_i32 psize) { + t->x = ppos.x; + t->y = ppos.y; + t->w = psize.x; + t->h = psize.y; + + t->texture_size.x = psize.x; + t->texture_size.y = psize.y; + + /* Free the old texture */ + /* Re-render the text */ + t->text_texture_index = + engine_render_text(t->font_id, t->fg, (char*)t->text_original, &t->texture_size, true); + + t->w = t->texture_size.x; + t->h = t->texture_size.y; + + ui_constraints_apply((UITree*)t, ppos, psize); +} + + +void ui_rearrange(UITree *root, v2_i32 ppos, v2_i32 psize) { + if (root == NULL) { + WARN("%s received a null pointer, ignoring", __func__); + return; + } + + switch (root->type) { + case uitype_container: + ui_rearrange_container(&root->container, ppos, psize); + break; + case uitype_button: + ui_rearrange_button(&root->button, ppos, psize); + break; + case uitype_title: + ui_rearrange_title(&root->title, ppos, psize); + break; + case uitype_text: + ui_rearrange_text(&root->text, ppos, psize); + break; + default: + if (root->type >= uitype_MAX) { + ERROR("Unknown uitype: %d", root->type); + exit(EXIT_FAILURE); + } else { + WARN("Rendering not implemented for %s", uitype_str[root->type]); + } + break; + } +} + +void ui_resolve_constraints(void) { + u64 *i = NULL; + struct btree_iter_t *it = NULL; + + /*absolutely bonkers way to do this*/ + if (GLOBAL_UIROOTS == NULL) { + WARN("UIROOTS not initialized"); + } + + it = btree_iter_t_new(GLOBAL_UIROOTS); + + while ((i = btree_iter(GLOBAL_UIROOTS, it)) != NULL) { + ui_rearrange((UITree*)*i, (v2_i32){0,0}, GLOBAL_PLATFORM->window->windowsize); + } + free(it); +} + +void ui_container_attach(UITree *root, UITree *child) { + if (root == NULL) { + WARN("%s received a null pointer", __func__); + return; + } + if (root->type != uitype_container) { + WARN("Trying to attach a child to a non-container UI element"); + return; + } + + UITree_container *c = &(root->container); + + static const usize size_increment = 32; + static const usize uitree_sz = sizeof(UITree*); + + if (c->children == NULL) { + /* Allocate space for children */ + c->children = malloc(uitree_sz * size_increment); + + } else if ((c->children_len + 1) * uitree_sz >= c->children_size) { + /* If there's not enough room for more children we will need to + * reallocate some more memory */ + c->children = realloc(c->children, (c->children_len + size_increment) * uitree_sz); + c->children_size += size_increment * uitree_sz; + } + + /* Finally: attach the new element */ + c->children[c->children_len++] = child; + + /* Since the child is no longer a part of the root-ui we can delete it from + * the btree-mapping */ + { + u64 tmp = (u64)child; + if (!btree_delete(GLOBAL_UIROOTS, &tmp)) { + WARN("Could not find child %p in global lookup table", child); + btree_print(GLOBAL_UIROOTS, &pointer_print); + } + } +} + +void ui_button_enable(UITree_button *b) { + b->enabled = true; + SDL_Texture *t = ((struct Resources*)GLOBAL_PLATFORM->data)->textures[b->text_texture_index]->texture; + SDL_SetTextureColorMod(t, 0xff, 0xff, 0xff); +} + +void ui_button_disable(UITree_button *b) { + b->enabled = false; + + SDL_Texture *t = ((struct Resources*)GLOBAL_PLATFORM->data)->textures[b->text_texture_index]->texture; + SDL_SetTextureColorMod(t, 0x7f, 0x7f, 0x7f); +} + +void ui_set_default_colors(Engine_color fg, Engine_color bg) { + DEFAULT_FG = fg; + DEFAULT_BG = bg; +} + +void ui_set_default_padding(i32 padding) { DEFAULT_PADDING = padding; } + +Engine_color ui_get_default_fg(void) { return DEFAULT_FG; } +Engine_color ui_get_default_bg(void) { return DEFAULT_BG; } + +bool check_point_in_rect(const v2_i32 *p, const SDL_Rect *r) { + if (p->x > r->x && p->x < r->x + r->w + && p->y > r->y && p->y < r->y + r->h) return true; + return false; +} + +u64 ui_check_click_internal(UITree *root, v2_i32 pos) { + v2_i32 ps = get_pos(root); + v2_i32 sz = get_size(root); + SDL_Rect elem_rect = {.x=ps.x, .y=ps.y + ,.w=sz.x, .h=sz.y}; + /* */ + switch (root->type) { + case uitype_container: + if (root->container.children != NULL && root->container.children_len > 0) { + const UITree_container *container = &root->container; + + if (check_point_in_rect(&pos, &elem_rect)) { + + for (usize i = 0; i < container->children_len; i++) { + u64 res = ui_check_click_internal(container->children[i], pos); + if (res != (u64)ELEM_NOT_FOUND) { + return res; + } + } + } + } + break; + case uitype_button: + if (root->button.enabled) { + WARN("Checking button"); + elem_rect.h += root->button.padding * 2; + elem_rect.w += root->button.padding * 2; + WARN("Button specs: <%d,%d>+%d,%d", elem_rect.w, elem_rect.h, elem_rect.x, elem_rect.y); + if (check_point_in_rect(&pos, &elem_rect)) { + return root->button.id; + } + } + break; + case uitype_title: + case uitype_text: + default: + break; + } + return ELEM_NOT_FOUND; +} + +u64 ui_check_click(UITree *root) { + if (!GLOBAL_PLATFORM->mouse_lclick) return NO_CLICK; + + v2_i32 pos = GLOBAL_PLATFORM->mouse_pos; + + INFO("Mousepos: <%d,%d>", pos.x, pos.y); + + return ui_check_click_internal(root, pos); +} |