krzosa/wasm_transcript_browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ui

Browse Source
This commit is contained in:
Krzosa Karol
2025-01-13 10:31:23 +01:00
parent dd796b12f4
commit b4d3f20cad
8 changed files with 410 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

358
src/wasm_app/ui.c
View File

@@ -1,133 +1,3 @@
/*
** [ ] Choosing a keying strategy from user code
** [ ] Using parents
** [ ] Using file and line
** [ ] Keyboard friendliness
** [ ] ui_em size
** [ ] strict
*/
typedef struct ui_id_t ui_id_t;
struct ui_id_t {
u64 value;
};
typedef struct ui_code_loc_t ui_code_loc_t;
struct ui_code_loc_t {
char *file;
int line;
int counter;
};
#define UI_CODE_LOC (ui_code_loc_t){.file = __FILE__, .line = __LINE__, .counter = __COUNTER__}
typedef enum {
ui_axis2_x,
ui_axis2_y,
ui_axis2_count,
} ui_axis2_t;
typedef enum {
ui_size_kind_null,
ui_size_kind_pixels,
ui_size_kind_text_content,
ui_size_kind_percent_of_parent,
ui_size_kind_children_sum,
} ui_size_kind_t;
typedef struct ui_size_t ui_size_t;
struct ui_size_t {
ui_size_kind_t kind;
f32 value;
f32 strictness;
};
typedef enum {
ui_box_flag_none = 0,
} ui_box_flag_t;
typedef struct ui_box_t ui_box_t;
struct ui_box_t {
// recreated every frame in building code
ui_box_t *next;
ui_box_t *prev;
ui_box_t *parent;
ui_box_t *first;
ui_box_t *last;
s8_t string;
ui_size_t semantic_size[ui_axis2_count];
b32 grow_axis[ui_axis2_count];
ui_code_loc_t loc;
// preserving state
ui_id_t id; // important position!: offset(id) used for partial zeroing
u64 last_touched_event_id;
ui_box_t *hash_next;
ui_box_t *hash_prev;
// computed by layout system every frame
f32 iter_pos[ui_axis2_count];
f32 computed_rel_pos[ui_axis2_count];
f32 computed_size[ui_axis2_count];
r2f32_t rect;
// state
b32 expanded;
};
typedef struct ui_signal_t ui_signal_t;
struct ui_signal_t {
b8 clicked;
b8 double_clicked;
b8 right_clicked;
b8 pressed;
b8 released;
b8 dragging;
b8 hovering;
};
typedef enum {
ui_id_strategy_null = 0,
ui_id_strategy_use_hierarchy = set_bit(0),
ui_id_strategy_use_code_loc = set_bit(1),
ui_id_strategy_use_string = set_bit(2),
} ui_id_strategy_t;
typedef struct ui_t ui_t;
struct ui_t {
ma_arena_t *box_arena; // required to be only used for boxes
app_event_t *event;
app_frame_t *frame;
i32 allocated_boxes;
ui_box_t *box_array; // first item on arena
ui_box_t *root;
ui_box_t *top;
ui_box_t *free_first;
ui_box_t *hash_first;
ui_box_t *hash_last;
ui_id_t hot;
ui_id_t active;
STACK(ui_id_t, 256) id_stack;
int indent_stack;
ui_id_strategy_t id_strategy;
};
gb ui_t *ui = NULL;
gb_read_only ui_id_t ui_id_null;
gb_read_only ui_box_t ui_box_null;
fn b32 ui_is_null_id(ui_id_t id) { return id.value == 0; }
fn b32 ui_is_null_box(ui_box_t *box) { return box->id.value == 0; }
fn b32 ui_is_hot_box(ui_box_t *box) { return !ui_is_null_box(box) && box->id.value == ui->hot.value; }
fn b32 ui_is_active_box(ui_box_t *box) { return !ui_is_null_box(box) && box->id.value == ui->active.value; }
#define ev_left(ev) ((ev)->mouse_button == app_mouse_button_left)
#define ev_left_up(ev) ((ev)->kind == app_event_kind_mouse_up && ev_left(ev))
#define ev_left_down(ev) ((ev)->kind == app_event_kind_mouse_down && ev_left(ev))
fn s8_t ui_get_display_string(s8_t string) {
s8_t result = string;
if (s8_seek(result, s8_lit("##"), s8_seek_none, &result.len)) {
@@ -148,7 +18,7 @@ fn ui_id_t ui_find_valid_id(ui_box_t *box) {
for (ui_box_t *it = box; it; it = it->parent) {
if (!ui_is_null_box(it)) return it->id;
}
return ui_id_null;
return ui_null_id;
}
fn ui_id_t ui_find_top_id(void) {
@@ -183,11 +53,16 @@ fn void ui_push_box(ui_box_t *box) {
DLLQ_APPEND(ui->top->first, ui->top->last, box);
}
fn void ui_set_semantic_size(ui_box_t *box, ui_size_t x, ui_size_t y) {
box->semantic_size[0] = x;
box->semantic_size[1] = y;
}
fn s8_t ui_tprint_loc(ui_code_loc_t loc) {
return s8_printf(tcx.temp, "%s(%d)", loc.file, loc.line);
}
fn ui_box_t *ui_build_box_from_id(ui_code_loc_t loc, ui_id_t id) {
fn ui_box_t *ui_build_box_from_id(ui_code_loc_t loc, ui_id_t id, ui_box_flag_t flags) {
ui_box_t *box = ui_find_box(id);
if (box) {
expect (box->last_touched_event_id != ui->event->id) {
@@ -196,11 +71,13 @@ fn ui_box_t *ui_build_box_from_id(ui_code_loc_t loc, ui_id_t id) {
memory_zero(box, offsetof(ui_box_t, id));
} else {
box = ui_alloc_box();
box->created_new = true;
DLLQ_APPEND_EX(ui->hash_first, ui->hash_last, box, hash_next, hash_prev);
}
box->loc = loc;
box->last_touched_event_id = ui->event->id;
box->id = id;
box->flags = flags;
ui_push_box(box);
return box;
}
@@ -208,15 +85,15 @@ fn ui_box_t *ui_build_box_from_id(ui_code_loc_t loc, ui_id_t id) {
fn ui_id_t ui_gen_id(ui_id_strategy_t strat, ui_code_loc_t loc, s8_t string) {
assert(strat != 0);
u64 result = 42523423493;
if (strat & ui_id_strategy_use_string) {
if (is_flag_set(strat, ui_id_strategy_use_string)) {
u64 string_hash = hash_data(string);
result = hash_mix(string_hash, result);
}
if (strat & ui_id_strategy_use_hierarchy) {
if (is_flag_set(strat, ui_id_strategy_use_hierarchy)) {
ui_id_t top_id = ui_find_top_id();
result = hash_mix(top_id.value, result);
}
if (strat & ui_id_strategy_use_code_loc) {
if (is_flag_set(strat, ui_id_strategy_use_code_loc)) {
u64 file_hash = hash_data(s8_from_char(loc.file));
u64 line_hash = hash_data(s8_struct(loc.line));
u64 cont_hash = hash_data(s8_struct(loc.counter));
@@ -228,9 +105,9 @@ fn ui_id_t ui_gen_id(ui_id_strategy_t strat, ui_code_loc_t loc, s8_t string) {
return id;
}
fn ui_box_t *ui_build_box_from_string(ui_code_loc_t loc, s8_t string) {
fn ui_box_t *ui_build_box_from_string(ui_code_loc_t loc, s8_t string, ui_box_flag_t flags) {
ui_id_t id = ui_gen_id(ui->id_strategy, loc, ui_get_hash_string(string));
ui_box_t *box = ui_build_box_from_id(loc, id);
ui_box_t *box = ui_build_box_from_id(loc, id, flags);
box->string = ui_get_display_string(string);
return box;
}
@@ -257,7 +134,7 @@ fn ui_signal_t ui_signal_from_box(ui_box_t *box) {
if (inside) {
ui->hot.value = box->id.value;
} else if (!inside && ui_is_hot_box(box)) {
ui->hot = ui_id_null;
ui->hot = ui_null_id;
}
return result;
@@ -269,7 +146,7 @@ fn void ui_init(ma_arena_t *arena) {
ui = ma_push_type(arena, ui_t);
ui->box_arena = arena;
ui->root = ma_push_type(arena, ui_box_t);
ui->id_strategy = ui_id_strategy_use_string | ui_id_strategy_use_code_loc;
ui->id_strategy = flag2(ui_id_strategy_use_string, ui_id_strategy_use_code_loc);
ui->box_array = ma_push_type(arena, ui_box_t);
SLLS_PUSH(ui->free_first, ui->box_array);
@@ -320,37 +197,35 @@ fn ui_box_t *ui_pop_parent(void) {
return top;
}
fn ui_box_t *ui_spacer(ui_code_loc_t loc, char *spacing_char) {
ui_box_t *box = ui_build_box_from_id(loc, ui_id_null);
v2f32_t spacing = rn_measure_string(&rn_state.main_font, s8_from_char(spacing_char));
box->semantic_size[0] = (ui_size_t){ui_size_kind_pixels, spacing.x, 0.5};
box->semantic_size[1] = (ui_size_t){ui_size_kind_pixels, 10, 0.5};
return box;
}
fn ui_box_t *ui_push_list_container(ui_code_loc_t loc) {
ui_box_t *box = ui_build_box_from_id(loc, ui_id_null);
fn ui_box_t *ui_push_container(ui_code_loc_t loc, ui_size_t x, ui_size_t y) {
ui_box_t *box = ui_build_box_from_id(loc, ui_null_id, flag2(ui_box_flag_draw_rect, ui_box_flag_draw_border));
ui_push_top(box);
box->semantic_size[0] = (ui_size_t){ui_size_kind_children_sum, 0, 0.5};
box->semantic_size[1] = (ui_size_t){ui_size_kind_children_sum, 0, 0.5};
box->grow_axis[1] = true;
ui_set_semantic_size(box, x, y);
box->grow_axis = ui_axis2_y;
return box;
}
fn void ui_push_indent(void) { ui->indent_stack += 1; }
fn void ui_pop_indent(void) { ui->indent_stack -= 1; }
fn ui_box_t *ui_push_xcontainer(ui_code_loc_t loc, ui_size_t x, ui_size_t y) {
ui_box_t *box = ui_push_container(loc, x, y);
box->grow_axis = ui_axis2_x;
return box;
}
fn ui_box_t *ui_push_list_container(ui_code_loc_t loc, ui_size_t size) {
return ui_push_container(loc, size, ui_children_sum());
}
fn void ui_set_indented_string(ui_box_t *box, s8_t string) { box->string = s8_printf(tcx.temp, "%.*s%S", ui->indent_stack, " ", string); }
fn ui_signal_t ui_push_exp(ui_code_loc_t loc, char *str, ...) {
S8_FMT(tcx.temp, str, string);
ui_box_t *box = ui_build_box_from_string(loc, string);
box->semantic_size[0] = (ui_size_t){ui_size_kind_text_content, 0, 0.5};
box->semantic_size[1] = (ui_size_t){ui_size_kind_text_content, 0, 0.5};
ui_box_t *box = ui_build_box_from_string(loc, string, flag2(ui_box_flag_draw_rect, ui_box_flag_draw_text));
ui_set_semantic_size(box, ui_percent(100), ui_text());
if (box->created_new) box->expanded = true;
ui_signal_t signal = ui_signal_from_box(box);
if (signal.clicked) {
box->expanded = !box->expanded;
}
if (signal.clicked) box->expanded = !box->expanded;
signal.clicked = box->expanded;
if (signal.clicked) {
@@ -361,138 +236,43 @@ fn ui_signal_t ui_push_exp(ui_code_loc_t loc, char *str, ...) {
ui_set_indented_string(box, box->string);
if (signal.clicked) {
ui->indent_stack += 1;
STACK_PUSH(ui->id_stack, box->id);
}
if (signal.clicked) ui->indent_stack += 1;
return signal;
}
fn void ui_pop_exp(void) {
ui->indent_stack -= 1;
STACK_POP(ui->id_stack);
}
fn ui_box_t *ui_label(ui_code_loc_t loc, char *fmt, ...) {
S8_FMT(tcx.temp, fmt, string);
ui_box_t *box = ui_build_box_from_id(loc, ui_id_null);
ui_box_t *box = ui_build_box_from_id(loc, ui_null_id, flag2(ui_box_flag_draw_rect, ui_box_flag_draw_text));
ui_set_indented_string(box, string);
box->semantic_size[0] = (ui_size_t){ui_size_kind_text_content, 0, 0.5};
box->semantic_size[1] = (ui_size_t){ui_size_kind_text_content, 0, 0.5};
ui_set_semantic_size(box, ui_text(), ui_text());
return box;
}
typedef struct ui_preorder_iter_t ui_preorder_iter_t;
struct ui_preorder_iter_t { ui_box_t *box; };
fn ui_preorder_iter_t ui_iterate_preorder(ui_box_t *box) {
ui_preorder_iter_t iter = {box};
return iter;
}
fn b32 ui_preorder_iter_is_valid(ui_preorder_iter_t iter) {
b32 result = iter.box != NULL;
return result;
}
fn void ui_iter_advance_preorder(ui_preorder_iter_t *iter) {
if (iter->box->first) {
iter->box = iter->box->first;
return;
}
while (iter->box) {
if (iter->box->next) {
iter->box = iter->box->next;
break;
} else {
iter->box = iter->box->parent;
}
}
}
typedef struct ui_postorder_iter_t ui_postorder_iter_t;
struct ui_postorder_iter_t { ui_box_t *box; };
fn ui_postorder_iter_t ui_iterate_postorder(ui_box_t *box) {
while (box->first) {
box = box->first;
}
ui_postorder_iter_t iter = {box};
return iter;
}
fn b32 ui_postorder_iter_is_valid(ui_postorder_iter_t iter) {
b32 result = iter.box != NULL;
return result;
}
fn void ui_iter_advance_postorder(ui_postorder_iter_t *iter) {
while (iter->box) {
if (iter->box->next) {
iter->box = iter->box->next;
while (iter->box->first) {
iter->box = iter->box->first;
}
break;
} else {
iter->box = iter->box->parent;
break;
}
}
}
fn void ui_test_stringify_preorder(sb8_t *sb, ui_box_t *box) {
sb8_printf(sb, "%S\n", box->string);
for (ui_box_t *it = box->first; it; it = it->next) {
ui_test_stringify_preorder(sb, it);
}
}
fn void ui_test_stringify_postorder(sb8_t *sb, ui_box_t *box) {
for (ui_box_t *it = box->first; it; it = it->next) {
ui_test_stringify_postorder(sb, it);
}
sb8_printf(sb, "%S\n", box->string);
}
fn void ui_end_frame(void) {
for (app_event_t *ev = ui->frame->first_event; ev; ev = ev->next) {
if (ev_left_up(ev)) {
ui->active = ui_id_null;
ui->active = ui_null_id;
}
}
}
fn void ui_draw(void) {
rn_font_t *font = &rn_state.main_font;
{
ma_temp_t scratch = ma_begin_scratch();
sb8_t *sb = sb8_serial_begin(scratch.arena);
ui_test_stringify_preorder(sb, ui->root);
s8_t recursive_string = sb8_serial_end(scratch.arena, sb);
sb = sb8_serial_begin(scratch.arena);
for (ui_preorder_iter_t it = ui_iterate_preorder(ui->root); ui_preorder_iter_is_valid(it); ui_iter_advance_preorder(&it)) {
sb8_printf(sb, "%S\n", it.box->string);
}
s8_t iter_string = sb8_serial_end(scratch.arena, sb);
assert(s8_equal(recursive_string, iter_string));
ma_end_scratch(scratch);
}
ui_test_iterator();
// compute standalone sizes: (pixels, text_content)
for (ui_preorder_iter_t it = ui_iterate_preorder(ui->root); ui_preorder_iter_is_valid(it); ui_iter_advance_preorder(&it)) {
ui_box_t *box = it.box;
for (i32 i = 0; i < ui_axis2_count; i += 1) {
ui_size_t sem = box->semantic_size[i];
for (ui_axis2_t axis = 0; axis < ui_axis2_count; axis += 1) {
ui_size_t sem = box->semantic_size[axis];
if (sem.kind == ui_size_kind_pixels) {
box->computed_size[i] = sem.value;
box->computed_size[axis] = sem.value;
} else if (sem.kind == ui_size_kind_text_content) {
box->computed_size[i] = rn_measure_string(font, box->string).e[i];
box->computed_size[axis] = rn_measure_string(font, box->string).e[axis];
}
}
}
@@ -501,14 +281,14 @@ fn void ui_draw(void) {
for (ui_preorder_iter_t it = ui_iterate_preorder(ui->root); ui_preorder_iter_is_valid(it); ui_iter_advance_preorder(&it)) {
ui_box_t *box = it.box;
ui_box_t *parent = box->parent; // @todo: I'm not sure why Ryan uses a loop to find a parent with fixed size_kind
for (i32 i = 0; i < ui_axis2_count; i += 1) {
ui_size_t sem = box->semantic_size[i];
for (ui_axis2_t axis = 0; axis < ui_axis2_count; axis += 1) {
ui_size_t sem = box->semantic_size[axis];
if (sem.kind == ui_size_kind_percent_of_parent) {
assert(sem.value >= 0 && sem.value <= 1.0);
assert(parent->semantic_size[i].kind == ui_size_kind_pixels ||
parent->semantic_size[i].kind == ui_size_kind_text_content ||
parent->semantic_size[i].kind == ui_size_kind_percent_of_parent);
box->computed_size[i] = sem.value * parent->computed_size[i];
assert(sem.value >= 0 && sem.value <= 100.0);
assert(parent->semantic_size[axis].kind == ui_size_kind_pixels ||
parent->semantic_size[axis].kind == ui_size_kind_text_content ||
parent->semantic_size[axis].kind == ui_size_kind_percent_of_parent);
box->computed_size[axis] = (sem.value / 100.0f) * parent->computed_size[axis];
}
}
}
@@ -516,17 +296,16 @@ fn void ui_draw(void) {
// compute: (children_sum)
for (ui_postorder_iter_t it = ui_iterate_postorder(ui->root); ui_postorder_iter_is_valid(it); ui_iter_advance_postorder(&it)) {
ui_box_t *box = it.box;
for (i32 i = 0; i < ui_axis2_count; i += 1) {
ui_size_t sem = box->semantic_size[i];
for (ui_axis2_t axis = 0; axis < ui_axis2_count; axis += 1) {
ui_size_t sem = box->semantic_size[axis];
if (sem.kind != ui_size_kind_children_sum) continue;
b32 grow_axis = box->grow_axis[i];
for (ui_box_t *child = box->first; child; child = child->next) {
assert(child->computed_size[i] != 0.f);
if (grow_axis) {
box->computed_size[i] += child->computed_size[i];
assert(child->computed_size[axis] != 0.f);
if (box->grow_axis == axis) {
box->computed_size[axis] += child->computed_size[axis];
} else {
box->computed_size[i] = MAX(box->computed_size[i], child->computed_size[i]);
box->computed_size[axis] = MAX(box->computed_size[axis], child->computed_size[axis]);
}
}
}
@@ -540,15 +319,15 @@ fn void ui_draw(void) {
ui_box_t *parent = box->parent;
if (ui->root == box) continue; // @todo: how to remove this?
for (i32 i = 0; i < ui_axis2_count; i += 1) {
f32 *pos = &box->computed_rel_pos[i];
f32 size = box->computed_size[i];
for (ui_axis2_t axis = 0; axis < ui_axis2_count; axis += 1) {
f32 *pos = &box->computed_rel_pos[axis];
f32 size = box->computed_size[axis];
f32 parent_pos = parent->computed_rel_pos[i];
f32 *iter_pos = &parent->iter_pos[i];
f32 parent_pos = parent->computed_rel_pos[axis];
f32 *iter_pos = &parent->iter_pos[axis];
*pos = parent_pos + *iter_pos;
if (parent->grow_axis[i]) *iter_pos += size;
if (parent->grow_axis == axis) *iter_pos += size;
}
v2f32_t pos = v2f32(box->computed_rel_pos[0], box->computed_rel_pos[1]);
@@ -568,7 +347,14 @@ fn void ui_draw(void) {
rect_color = accent1_color_global;
}
rn_draw_rect(box->rect, rect_color);
rn_draw_string(font, box->rect.min, black_color_global, box->string);
if (is_flag_set(box->flags, ui_box_flag_draw_rect)) {
rn_draw_rect(box->rect, rect_color);
}
if (is_flag_set(box->flags, ui_box_flag_draw_border)) {
rn_draw_rect_border(box->rect, accent2_color_global);
}
if (is_flag_set(box->flags, ui_box_flag_draw_text)) {
rn_draw_string(font, box->rect.min, black_color_global, box->string);
}
}
}