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

move ui to ui/

Browse Source
This commit is contained in:
Krzosa Karol
2025-01-18 12:03:33 +01:00
parent 469c0c8ec3
commit 9a70640a6e
5 changed files with 4 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/wasm_app/main.c
View File

@@ -1,6 +1,6 @@
#include "core/core_inc.h"
#include "app/app.h"
#include "ui.h"
#include "ui/ui.h"
#include "core/core_inc.c"
#include "app/app.c"
@@ -25,8 +25,8 @@
#include "render/render_opengl.c"
#include "wasm_app.gen.c"
#include "ui_iter.c"
#include "ui.c"
#include "ui/ui_iter.c"
#include "ui/ui.c"
fn void app_init(f32 dpr) {
ma_arena_t *perm = &tcx._perm;

611
src/wasm_app/ui.c
View File

@@ -1,611 +0,0 @@
fn s8_t ui_tprint_loc(ui_code_loc_t loc) {
return s8_printf(tcx.temp, "%s(%d)", loc.file, loc.line);
}
fn s8_t ui_get_display_string(s8_t string) {
s8_t result = string;
s8_seek(result, s8_lit("##"), s8_seek_none, &result.len);
return result;
}
fn s8_t ui_get_hash_string(s8_t string) {
i64 len = 0;
if (s8_seek(string, s8_lit("##"), s8_seek_none, &len)) {
string = s8_skip(string, len + 2);
}
return string;
}
fn ui_id_t ui_id_from_string(s8_t string) {
u64 value = hash_data(string);
ui_id_t result = {value};
return result;
}
fn u64 ui_hash_code_loc(ui_code_loc_t loc) {
u64 result = 4242843;
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));
result = hash_mix(result, file_hash);
result = hash_mix(result, line_hash);
result = hash_mix(result, cont_hash);
return result;
}
fn ui_id_t ui_id_from_code_loc(ui_code_loc_t loc) {
u64 id = ui_hash_code_loc(loc);
ui_id_t result = {id};
return result;
}
fn u64 ui_hash_from_stack(void) {
u64 result = 34294923;
for (i32 i = 0; i < ui->id_stack.len; i += 1) {
result = hash_mix(result, ui->id_stack.data[i].value);
}
return result;
}
fn ui_id_t ui_id(s8_t string) {
string = ui_get_hash_string(string);
u64 string_hash = hash_data(string);
u64 stack_hash = ui_hash_from_stack();
u64 result = hash_mix(string_hash, stack_hash);
return (ui_id_t){result};
}
fn ui_id_t ui_idf(char *str, ...) {
S8_FMT(tcx.temp, str, string);
return ui_id(string);
}
fn void ui_push_id(ui_id_t id) { STACK_PUSH(ui->id_stack, id); }
fn void ui_pop_id(void) { STACK_POP(ui->id_stack); }
fn void ui_push_id_string(s8_t string) { ui_push_id(ui_id(string)); }
fn void ui_push_top(ui_box_t *new_top) { assert(new_top->parent == ui->top); ui->top = new_top; ui_push_id(new_top->id); }
fn void ui_pop_top(void) { ui->top = ui->top->parent; ui_pop_id(); }
fn ui_box_t *ui_alloc_box(void) {
ui_box_t *box = NULL;
if (ui->free_first) {
SLLS_POP_AND_STORE(ui->free_first, box);
} else {
box = ma_push_type(ui->box_arena, ui_box_t);
ui->allocated_boxes += 1;
}
return box;
}
fn ui_box_t *ui_find_box(ui_id_t id) {
if (id.value == 0) return NULL;
for (ui_box_t *it = ui->hash_first; it; it = it->hash_next) {
if (it->id.value == id.value) {
return it;
}
}
return NULL;
}
fn void ui_push_box(ui_box_t *parent, ui_box_t *box) {
box->parent = parent;
DLLQ_APPEND(parent->first, parent->last, box);
parent->node_count += 1;
}
fn r2f32_t ui_next_rect(ui_op_t op, r2f32_t *rect, v2f32_t required_size) {
switch (op) {
case ui_op_cut_top: return r2f32_cut_top_no_squash(rect, required_size.y); break;
case ui_op_cut_bottom: return r2f32_cut_bottom_no_squash(rect, required_size.y); break;
case ui_op_cut_left: return r2f32_cut_left_no_squash(rect, required_size.x); break;
case ui_op_cut_right: return r2f32_cut_right_no_squash(rect, required_size.x); break;
case ui_op_idle: break;
default_is_invalid;
}
return (r2f32_t){0};
}
fn ui_box_t *ui_build_box_from_id(ui_code_loc_t loc, ui_box_flags_t flags, ui_id_t id) {
ui_box_t *box = ui_find_box(id);
if (box) {
expect (box->last_touched_event_id != ui->event->id) {
fatalf("likely ui id collision between: %S and %S", ui_tprint_loc(loc), ui_tprint_loc(box->loc));
}
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;
box->text_align = ui->pref_text_align;
ui_push_box(ui->top, box);
return box;
}
fn ui_box_t *ui_build_box_from_string(ui_code_loc_t loc, ui_box_flags_t flags, s8_t string) {
ui_id_t id = ui_id(string);
ui_box_t *box = ui_build_box_from_id(loc, flags, id);
box->string = ui_get_display_string(string);
v2f32_t string_size = rn_measure_string(rn_state.main_font, box->string);
string_size.x += ui_em(1);
r2f32_t rect = ui_next_rect(ui->top->op, &ui->top->rect, string_size);
ui_set_rect(box, rect);
return box;
}
#define ui_boxf(flags, ...) ui__boxf(UILOC, flags, __VA_ARGS__)
fn ui_box_t *ui__boxf(ui_code_loc_t loc, ui_box_flags_t flags, char *str, ...) {
S8_FMT(tcx.temp, str, string);
ui_box_t *box = ui_build_box_from_string(loc, flags, string);
return box;
}
fn ui_signal_t ui_signal_from_box(ui_box_t *box) {
ui_signal_t result = {box};
app_event_t *ev = ui->event;
b32 move = ev->kind == app_event_kind_mouse_move;
b32 inside = r2f32_contains(box->final_rect, ev->mouse_pos);
if (ui_is_active_box(box)) {
result.dragging = true;
if (ev_left_up(ev)) {
if (ui_is_hot_box(box)) {
result.clicked = true;
} else {
ui->active.value = 0;
}
}
} else if (ui_is_hot_box(box) && ev_left_down(ev)) {
ui->active = box->id;
}
if (inside) {
ui->hot.value = box->id.value;
} else if (!inside && ui_is_hot_box(box)) {
ui->hot = ui_null_id;
}
return result;
}
#define ui_button(...) ui__button(UILOC, __VA_ARGS__)
fn ui_signal_t ui__button(ui_code_loc_t loc, char *str, ...) {
S8_FMT(tcx.temp, str, string);
ui_box_t *box = ui_build_box_from_string(loc, (ui_box_flags_t){ .draw_border = true, .draw_rect = true, .draw_text = true }, string);
ui_signal_t signal = ui_signal_from_box(box);
return signal;
}
#define ui_list_button(...) ui__list_button(UILOC, __VA_ARGS__)
fn ui_signal_t ui__list_button(ui_code_loc_t loc, char *str, ...) {
S8_FMT(tcx.temp, str, string);
ui_box_t *box = ui_build_box_from_string(loc, (ui_box_flags_t){ .draw_text = true }, string);
ui_signal_t signal = ui_signal_from_box(box);
return signal;
}
#define ui_label(...) ui__label(UILOC, __VA_ARGS__)
fn ui_box_t *ui__label(ui_code_loc_t loc, char *str, ...) {
S8_FMT(tcx.temp, str, string);
ui_box_t *box = ui_build_box_from_string(loc, (ui_box_flags_t){ .draw_text = true }, string);
return box;
}
#define ui_begin_expander(...) ui__begin_expander(UILOC, __VA_ARGS__)
fn ui_signal_t ui__begin_expander(ui_code_loc_t loc, char *str, ...) {
S8_FMT(tcx.temp, str, string);
ui_box_t *box = ui_build_box_from_string(loc, (ui_box_flags_t){ .draw_text = true }, string);
if (box->created_new) box->expanded = true;
ui_signal_t signal = ui_signal_from_box(box);
if (signal.clicked) box->expanded = !box->expanded;
signal.clicked = box->expanded;
if ( box->expanded) box->string = s8_printf(tcx.temp, "* %S", box->string);
if (!box->expanded) box->string = s8_printf(tcx.temp, "> %S", box->string);
if (box->expanded) {
r2f32_cut_left(&ui->top->rect, ui_em(0.5f));
ui_push_id(box->id);
}
return signal;
}
fn void ui_end_expander(void) {
r2f32_add_left(&ui->top->rect, ui_em(0.5f));
ui_pop_id();
}
fn void ui_begin_build(ui_code_loc_t loc, app_event_t *ev, r2f32_t window_rect) {
ui->event = ev;
for (ui_box_t *box = ui->hash_first, *next = NULL; box; box = next) {
next = box->hash_next;
if (box->id.value == 0) {
DLLQ_REMOVE_EX(ui->hash_first, ui->hash_last, box, hash_next, hash_prev);
zero_struct(box);
SLLS_PUSH(ui->free_first, box);
}
}
zero_struct(&ui->root);
ui->root.full_rect = ui->root.rect = window_rect;
ui->top = &ui->root;
ui->root.loc = loc;
}
fn void ui_end_build(void) {
assert(ui->top == &ui->root);
for (ui_box_t *box = ui->hash_first, *next = NULL; box; box = next) {
next = box->hash_next;
b32 touched_box_during_update = ui->event->id <= box->last_touched_event_id;
if (!touched_box_during_update) {
DLLQ_REMOVE_EX(ui->hash_first, ui->hash_last, box, hash_next, hash_prev);
zero_struct(box);
SLLS_PUSH(ui->free_first, box);
}
}
}
fn r2f32_t window_rect_from_frame(app_frame_t *frame) {
r2f32_t window_rect = r2f32(0, 0, frame->window_size.x, frame->window_size.y);
return window_rect;
}
fn void ui__draw_box(app_frame_t *frame, ui_box_t *box) {
box->final_rect = box->full_rect;
r2f32_t rect = box->final_rect;
v4f32_t rect_color = primary_color_global;
v4f32_t text_color = black_color_global;
if (ui_is_hot_box(box)) {
rect_color = secondary_color_global;
text_color = accent2_color_global;
}
if (ui_is_active_box(box)) {
rect_color = accent1_color_global;
text_color = accent1_color_global;
}
if (box->flags.draw_rect) {
rn_draw_rect(rect, rect_color);
}
if (box->flags.draw_border) {
rn_draw_rect_border(rect, accent2_color_global);
}
if (box->flags.draw_text) {
v2f32_t string_size = rn_measure_string(rn_state.main_font, box->string);
v2f32_t rect_size = r2f32_get_size(rect);
v2f32_t rect_string_diff = v2f32_sub(rect_size, string_size);
v2f32_t center_pos = v2f32_divs(rect_string_diff, 2);
v2f32_t pos_in_rect = v2f32(0, center_pos.y);
if (box->text_align == ui_text_align_center) {
pos_in_rect = center_pos;
}
v2f32_t pos = v2f32_add(pos_in_rect, rect.min);
rn_draw_string(rn_state.main_font, pos, text_color, box->string);
}
r2f32_t prev_clip_rect = ui->clip_rect;
if (box->flags.clip_rect) {
ui->clip_rect = box->full_rect;
rn_set_clip(ui->clip_rect);
}
for (ui_box_t *it = box->first; it; it = it->next) {
ui__draw_box(frame, it);
}
if (box->flags.clip_rect) {
ui->clip_rect = prev_clip_rect;
rn_set_clip(ui->clip_rect);
}
}
fn void ui_draw(app_frame_t *frame) {
ui->clip_rect = window_rect_from_frame(frame);
rn_set_clip(ui->clip_rect);
ui__draw_box(frame, &ui->root);
}
fn void ui_demo_init(ma_arena_t *arena) {
ui = ma_push_type(arena, ui_t);
ui->box_arena = ma_push_arena(arena, mib(1));
}
fn void ui_serial_subtype(void *p, type_t *type, s8_t name) {
assert(type->kind != type_kind_invalid);
switch(type->kind) {
case type_kind_i8: {
i8 *n = (i8 *)p;
if (ui_list_button("%S: %d##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (i8)delta;
}
return;
} break;
case type_kind_i16: {
i16 *n = (i16 *)p;
if (ui_list_button("%S: %d##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (i16)delta;
}
return;
} break;
case type_kind_i32: {
i32 *n = (i32 *)p;
if (ui_list_button("%S: %d##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (i32)delta;
}
return;
} break;
case type_kind_i64: {
i64 *n = (i64 *)p;
if (ui_list_button("%S: %lld##slider%S", name, (long long)*n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (i64)delta;
}
return;
} break;
case type_kind_u8: {
u8 *n = (u8 *)p;
if (ui_list_button("%S: %u##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (u8)delta;
}
return;
} break;
case type_kind_u16: {
u16 *n = (u16 *)p;
if (ui_list_button("%S: %u##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (u16)delta;
}
return;
} break;
case type_kind_u32: {
u32 *n = (u32 *)p;
if (ui_list_button("%S: %u##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (u32)delta;
}
return;
} break;
case type_kind_u64: {
u64 *n = (u64 *)p;
if (ui_list_button("%S: %llu##slider%S", name, (unsigned long long)*n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (u64)delta;
}
return;
} break;
case type_kind_b8: {
b8 *n = (b8 *)p;
if (ui_list_button("%S: %s", name, *n ? "true" : "false").clicked) {
*n = !*n;
}
return;
} break;
case type_kind_b16: {
b16 *n = (b16 *)p;
if (ui_list_button("%S: %s", name, *n ? "true" : "false").clicked) {
*n = !*n;
}
return;
} break;
case type_kind_b32: {
b32 *n = (b32 *)p;
if (ui_list_button("%S: %s", name, *n ? "true" : "false").clicked) {
*n = !*n;
}
return;
} break;
case type_kind_b64: {
b64 *n = (b64 *)p;
if (ui_list_button("%S: %s", name, *n ? "true" : "false").clicked) {
*n = !*n;
}
return;
} break;
case type_kind_f32: {
f32 *n = (f32 *)p;
if (ui_list_button("%S: %f##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += delta;
}
return;
} break;
case type_kind_f64: {
f64 *n = (f64 *)p;
if (ui_list_button("%S: %f##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += delta;
}
return;
} break;
case type_kind_isize: {
isize *n = (isize *)p;
if (ui_list_button("%S: %lld##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (isize)delta;
}
return;;
} break;
case type_kind_usize: {
usize *n = (usize *)p;
if (ui_list_button("%S: %llu##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (usize)delta;
}
return;;
} break;
case type_kind_int: {
int *n = (int *)p;
if (ui_list_button("%S: %d##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (int)delta;
}
return;;
} break;
case type_kind_char: {
char *n = (char *)p;
if (ui_list_button("%S: %c##slider%S", name, *n, name).dragging) {
f32 delta = ui->event->mouse_delta.x;
n[0] += (char)delta;
}
return;;
} break;
}
if (type->kind == type_kind_pointer) {
ui_label("%S: %S = %llx", name, type->name, *(usize *)p);
return;
}
if (type->kind == type_kind_enum) {
i64 value = ti_enum_read_value(p, type);
s8_t string_value = ti_enum_value_to_name(value, type);
if (ui_list_button("%S: %S = %S", name, type->name, string_value).clicked) {
i64 new_value = ti_enum_next_value(p, value, type);
ti_enum_write_value(p, new_value, type);
}
return;
}
if (type->kind == type_kind_array) {
defer_if (ui_begin_expander("%S:", name).clicked, ui_end_expander()) {
for (i32 i = 0; i < type->count; i += 1) {
ma_temp_t scratch = ma_begin_scratch();
s8_t index_name = s8_printf(scratch.arena, "[%d]", i);
void *tmp = ti_extract_array_idx(p, type, i);
ui_serial_subtype(tmp, type->base, index_name);
ma_end_scratch(scratch);
}
}
return;
}
if (type->kind == type_kind_struct) {
defer_if (ui_begin_expander("%S:", name).clicked, ui_end_expander()) {
for (i32 i = 0; i < type->count; i += 1) {
type_member_t *tm = type->members + i;
void *tmp = ti_extract_member(p, tm);
ui_serial_subtype(tmp, tm->type, tm->name);
}
}
return;
} else {
ui_label("%S: %S", name, type->name);
}
}
fn void ui_serial_type(void *p, type_t *type) {
ui_serial_subtype(p, type, type->name);
}
gb app_event_t ui_test_event;
fn void ui_demo_update(app_frame_t *frame) {
for (app_event_t *ev = frame->first_event; ev; ev = ev->next) {
ui_begin_build(UILOC, ev, window_rect_from_frame(frame));
ui->top->op = ui_op_idle;
ui_box_t *scroller_box = ui_boxf((ui_box_flags_t){.draw_rect = true, .clip_rect = true}, "scroller");
ui_set_rect(scroller_box, r2f32_cut_right(&ui->top->rect, ui_em(0.5f)));
ui_box_t *item_box = ui_boxf((ui_box_flags_t){.draw_rect = true, .clip_rect = true}, "item_box");
ui_set_rect(item_box, r2f32_cut_left(&ui->top->rect, ui_max));
static f32 scroller_value;
defer_block(ui_push_top(item_box), ui_pop_top()) {
for (i32 i = 0; i < lengthof(tweak_table); i += 1) {
mt_tweak_t *tweak = tweak_table + i;
if (s8_starts_with(tweak->name, s8_lit("_"), false)) continue;
if (tweak->type->kind == type_kind_b32) {
b32 *n = (b32 *)tweak->ptr;
if (ui_list_button("%S: %s##slider%S", tweak->name, *n ? "true" : "false", tweak->name).clicked) {
*n = !*n;
}
} else if (tweak->type->kind == type_kind_f32) {
f32 *n = (f32 *)tweak->ptr;
ui_signal_t signal = ui_list_button("%S: %f##slider%S", tweak->name, *n, tweak->name);
if (signal.dragging) {
f32 size = tweak->max - tweak->min;
v2f32_t string_size = rn_measure_string(rn_state.main_font, signal.box->string);
f32 delta = (ui->event->mouse_delta.x / string_size.x) * size;
*n = CLAMP(*n + delta, tweak->min, tweak->max);
}
} else_is_invalid;
}
ui_serial_type(&ui_test_event, type(app_event_t));
defer_if (ui_begin_expander("app_event_t").clicked, ui_end_expander()) {
for (int i = 0; i < 2; i += 1) {
ui_label("kind: app_event_kind_t##a%d", i);
ui_label("ctrl: b8##ds%d", i);
ui_label("shift: b8##f%d", i);
defer_if (ui_begin_expander("pos: v3f32_t##gg%d", i).clicked, ui_end_expander()) {
ui_label("x: f64 = value##hgt%d", i);
ui_label("y: f64 = value##r%d", i);
ui_label("z: f64 = value##yr%d", i);
}
defer_if (ui_begin_expander("mouse_pos: v2f32_t##i2%d", i).clicked, ui_end_expander()) {
ui_label("x: f64 = value##i3%d", i);
ui_label("y: f64 = value##i4%d", i);
}
}
}
}
// @todo: fix scroller to match mouse
defer_block(ui_push_top(scroller_box), ui_pop_top()) {
f32 item_count = (f32)item_box->node_count;
f32 all_items_size = item_count * rn_state.main_font->size;
f32 item_box_size = r2f32_get_size(ui->top->full_rect).y;
f32 scroller_box_size = r2f32_get_size(scroller_box->full_rect).y;
f32 scroller_size = CLAMP(item_box_size / all_items_size, 0, 1.0f);
f32 scrollable_space = (1 - scroller_size);
f32 scroller_norm = scroller_value / (all_items_size);
f32 scroller_percent = scroller_norm * scrollable_space;
f32 scroller_second = scrollable_space - scroller_percent;
r2f32_cut_top(&ui->top->rect, scroller_percent * scroller_box_size);
ui_box_t *box = ui_build_box_from_id(UILOC, (ui_box_flags_t){.draw_border = true, .draw_rect = true}, ui_idf("slider"));
ui_set_rect(box, r2f32_cut_top(&ui->top->rect, scroller_size * scroller_box_size));
ui_signal_t signal = ui_signal_from_box(box);
if (signal.dragging) {
scroller_value += (ev->mouse_delta.y / item_box_size * 2) * (all_items_size);
scroller_value = CLAMP(scroller_value, 0, all_items_size);
}
if (ev->kind == app_event_kind_mouse_wheel) {
scroller_value -= ev->mouse_wheel_delta.y;
scroller_value = CLAMP(scroller_value, 0, all_items_size);
}
for (ui_box_t *it = item_box->first; it; it = it->next) {
it->full_rect.min.y -= scroller_value;
it->full_rect.max.y -= scroller_value;
it->rect.min.y -= scroller_value;
it->rect.max.y -= scroller_value;
}
}
ui_end_build();
}
rn_begin();
ui_draw(frame);
rn_draw_stringf(rn_state.main_font, v2f32(0, frame->window_size.y - rn_state.main_font->size), black_color_global, "boxes: %d", ui->allocated_boxes);
rn_end(frame->window_size, white_color_global);
// End frame
for (app_event_t *ev = frame->first_event; ev; ev = ev->next) {
if (ev_left_up(ev)) {
ui->active = ui_null_id;
}
}
}

116
src/wasm_app/ui.h
View File

@@ -1,116 +0,0 @@
typedef struct ui_code_loc_t ui_code_loc_t;
struct ui_code_loc_t {
char *file;
int line;
int counter;
};
typedef struct ui_id_t ui_id_t;
struct ui_id_t {
u64 value;
};
typedef struct ui_box_flags_t ui_box_flags_t;
struct ui_box_flags_t {
b8 draw_rect: 1;
b8 draw_border: 1;
b8 draw_text: 1;
b8 clip_rect : 1;
};
typedef enum {
ui_text_align_left,
ui_text_align_center,
} ui_text_align_t;
typedef enum {
ui_op_cut_top,
ui_op_cut_bottom,
ui_op_cut_left,
ui_op_cut_right,
ui_op_idle,
} ui_op_t;
typedef struct ui_box_t ui_box_t;
struct ui_box_t {
ui_box_t *next;
ui_box_t *prev;
ui_box_t *first;
ui_box_t *last;
ui_box_t *parent;
i32 node_count;
ui_code_loc_t loc;
s8_t string;
ui_box_flags_t flags;
b8 created_new;
ui_text_align_t text_align;
ui_op_t op;
r2f32_t full_rect;
r2f32_t rect;
// state
ui_id_t id;
ui_box_t *hash_next;
ui_box_t *hash_prev;
u64 last_touched_event_id;
r2f32_t final_rect;
b32 expanded;
};
typedef struct ui_signal_t ui_signal_t;
struct ui_signal_t {
ui_box_t *box;
b8 clicked;
b8 dragging;
};
typedef struct ui_t ui_t;
struct ui_t {
// building
ui_box_t root;
ui_box_t *top;
app_event_t *event;
stack_t(ui_id_t, 32) id_stack;
ui_text_align_t pref_text_align;
// allocation
ma_arena_t *box_arena;
i32 allocated_boxes;
ui_box_t *free_first;
ui_box_t *hash_first;
ui_box_t *hash_last;
// interaction
ui_id_t hot;
ui_id_t active;
// drawing
r2f32_t clip_rect;
};
ui_t *ui;
gb_read_only ui_id_t ui_null_id;
gb_read_only ui_box_t ui_null_box;
gb_read_only ui_box_flags_t ui_null_flags;
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 void ui_set_rect(ui_box_t *box, r2f32_t rect) { box->rect = box->full_rect = rect; }
#define UILOC (ui_code_loc_t){.file = __FILE__, .line = __LINE__, .counter = __COUNTER__}
#define ui_em(x) ((x) * rn_state.main_font->size)
#define ui_max 200000000.f
#define ui_box_flags(...) (ui_box_flag_t){__VA_ARGS__}

110
src/wasm_app/ui_iter.c
View File

@@ -1,110 +0,0 @@
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_test_iterator(void) {
{
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_are_equal(recursive_string, iter_string));
ma_end_scratch(scratch);
}
{
ma_temp_t scratch = ma_begin_scratch();
sb8_t *sb = sb8_serial_begin(scratch.arena);
ui_test_stringify_postorder(sb, &ui->root);
s8_t recursive_string = sb8_serial_end(scratch.arena, sb);
sb = sb8_serial_begin(scratch.arena);
for (ui_postorder_iter_t it = ui_iterate_postorder(&ui->root); ui_postorder_iter_is_valid(it); ui_iter_advance_postorder(&it)) {
sb8_printf(sb, "%S\n", it.box->string);
}
s8_t iter_string = sb8_serial_end(scratch.arena, sb);
assert(s8_are_equal(recursive_string, iter_string));
ma_end_scratch(scratch);
}
}