570 lines
15 KiB
Plaintext
570 lines
15 KiB
Plaintext
package ui
|
|
|
|
import "core:fmt"
|
|
import "core:strings"
|
|
import "core:math"
|
|
import "vendor:raylib"
|
|
|
|
import "../theme"
|
|
|
|
root: ^Box = nil;
|
|
current_parent: ^Box = nil;
|
|
persistent: map[Key]^Box = nil;
|
|
current_interaction_index: int = 0;
|
|
|
|
clips: [dynamic]Rect = nil;
|
|
|
|
Rect :: struct {
|
|
pos: [2]int,
|
|
size: [2]int,
|
|
}
|
|
|
|
Key :: struct {
|
|
label: string,
|
|
value: int,
|
|
}
|
|
|
|
Interaction :: struct {
|
|
clicked: bool,
|
|
}
|
|
|
|
Flag :: enum {
|
|
Clickable,
|
|
Hoverable,
|
|
Scrollable,
|
|
DrawText,
|
|
DrawBorder,
|
|
DrawBackground,
|
|
}
|
|
|
|
SemanticSizeKind :: enum {
|
|
FitText,
|
|
Exact,
|
|
ChildrenSum,
|
|
Fill,
|
|
PercentOfParent,
|
|
}
|
|
|
|
SemanticSize :: struct {
|
|
kind: SemanticSizeKind,
|
|
value: int,
|
|
}
|
|
|
|
Axis :: enum {
|
|
Horizontal = 0,
|
|
Vertical = 1,
|
|
}
|
|
|
|
Box :: struct {
|
|
first: ^Box,
|
|
last: ^Box,
|
|
next: ^Box,
|
|
prev: ^Box,
|
|
parent: ^Box,
|
|
|
|
key: Key,
|
|
last_interacted_index: int,
|
|
|
|
flags: bit_set[Flag],
|
|
|
|
label: string,
|
|
|
|
axis: Axis,
|
|
semantic_size: [2]SemanticSize,
|
|
computed_size: [2]int,
|
|
|
|
computed_pos: [2]int
|
|
}
|
|
|
|
init :: proc() {
|
|
if persistent == nil {
|
|
persistent = make(map[Key]^Box);
|
|
}
|
|
|
|
if clips == nil {
|
|
clips = make([dynamic]Rect);
|
|
}
|
|
|
|
root = new(Box);
|
|
root.key = gen_key("root", 69);
|
|
current_parent = root;
|
|
}
|
|
|
|
gen_key :: proc(label: string, value: int) -> Key {
|
|
key_label := ""
|
|
if current_parent == nil || len(current_parent.key.label) < 1 {
|
|
key_label = strings.clone(label);
|
|
} else {
|
|
key_label = fmt.aprintf("%s:%s", current_parent.key.label, label);
|
|
}
|
|
|
|
return Key {
|
|
label = key_label,
|
|
value = value,
|
|
};
|
|
}
|
|
|
|
make_box :: proc(key: Key, label: string, flags: bit_set[Flag], axis: Axis, semantic_size: [2]SemanticSize) -> ^Box {
|
|
box: ^Box = nil;
|
|
|
|
if cached_box, exists := persistent[key]; exists {
|
|
if cached_box.last_interacted_index < current_interaction_index {
|
|
old_cached_box := persistent[key];
|
|
free(old_cached_box);
|
|
box = new(Box);
|
|
|
|
persistent[key] = box;
|
|
} else {
|
|
box = cached_box;
|
|
}
|
|
} else {
|
|
box = new(Box);
|
|
persistent[key] = box;
|
|
}
|
|
|
|
box.key = key;
|
|
box.label = label;
|
|
|
|
box.first = nil;
|
|
box.last = nil;
|
|
box.next = nil;
|
|
box.prev = current_parent.last;
|
|
box.parent = current_parent;
|
|
box.flags = flags;
|
|
box.axis = axis;
|
|
box.semantic_size = semantic_size;
|
|
box.computed_pos = {};
|
|
box.computed_size = {};
|
|
|
|
if current_parent.last != nil {
|
|
current_parent.last.next = box;
|
|
}
|
|
if current_parent.first == nil {
|
|
current_parent.first = box;
|
|
}
|
|
|
|
current_parent.last = box;
|
|
|
|
return box;
|
|
}
|
|
|
|
make_semantic_size :: proc(kind: SemanticSizeKind, value: int = 0) -> SemanticSize {
|
|
return SemanticSize {
|
|
kind = kind,
|
|
value = value
|
|
};
|
|
}
|
|
|
|
FitText :[2]SemanticSize: {
|
|
SemanticSize {
|
|
kind = .FitText,
|
|
},
|
|
SemanticSize {
|
|
kind = .FitText,
|
|
}
|
|
};
|
|
|
|
ChildrenSum :[2]SemanticSize: {
|
|
SemanticSize {
|
|
kind = .ChildrenSum,
|
|
},
|
|
SemanticSize {
|
|
kind = .ChildrenSum,
|
|
}
|
|
};
|
|
|
|
push_box :: proc(label: string, flags: bit_set[Flag], axis: Axis = .Horizontal, semantic_size: [2]SemanticSize = FitText, value: int = 0) -> ^Box {
|
|
key := gen_key(label, value);
|
|
box := make_box(key, label, flags, axis, semantic_size);
|
|
|
|
return box;
|
|
}
|
|
|
|
push_parent :: proc(box: ^Box) {
|
|
current_parent = box;
|
|
}
|
|
|
|
pop_parent :: proc() {
|
|
if current_parent.parent != nil {
|
|
current_parent = current_parent.parent;
|
|
}
|
|
}
|
|
|
|
test_box :: proc(box: ^Box) -> Interaction {
|
|
return Interaction {
|
|
clicked = false,
|
|
};
|
|
}
|
|
|
|
delete_box_children :: proc(box: ^Box, keep_persistent: bool = true) {
|
|
iter := BoxIter { box.first, 0 };
|
|
|
|
for box in iterate_box(&iter) {
|
|
delete_box(box, keep_persistent);
|
|
}
|
|
}
|
|
|
|
delete_box :: proc(box: ^Box, keep_persistent: bool = true) {
|
|
delete_box_children(box, keep_persistent);
|
|
|
|
if !(box.key in persistent) || !keep_persistent {
|
|
delete(box.key.label);
|
|
free(box);
|
|
}
|
|
}
|
|
|
|
prune :: proc() {
|
|
iter := BoxIter { root.first, 0 };
|
|
|
|
for box in iterate_box(&iter) {
|
|
delete_box_children(box);
|
|
|
|
if !(box.key in persistent) {
|
|
free(box);
|
|
}
|
|
}
|
|
|
|
root_key := root.key;
|
|
root^ = {
|
|
key = root_key,
|
|
};
|
|
current_parent = root;
|
|
}
|
|
|
|
ancestor_size :: proc(box: ^Box, axis: Axis) -> int {
|
|
if box == nil || box.parent == nil {
|
|
return root.computed_size[axis];
|
|
}
|
|
|
|
switch box.parent.semantic_size[axis].kind {
|
|
case .FitText: fallthrough
|
|
case .Exact: fallthrough
|
|
case .Fill: fallthrough
|
|
case .PercentOfParent:
|
|
return box.parent.computed_size[axis];
|
|
|
|
case .ChildrenSum:
|
|
return ancestor_size(box.parent, axis);
|
|
}
|
|
|
|
return 1337;
|
|
}
|
|
|
|
compute_layout :: proc(canvas_size: [2]int, font_width: int, font_height: int, box: ^Box = root) {
|
|
if box == nil { return; }
|
|
|
|
axis := Axis.Horizontal;
|
|
if box.parent != nil {
|
|
axis = box.parent.axis;
|
|
box.computed_pos = box.parent.computed_pos;
|
|
}
|
|
|
|
if box.prev != nil {
|
|
box.computed_pos[axis] = box.prev.computed_pos[axis] + box.prev.computed_size[axis];
|
|
}
|
|
|
|
compute_children := true;
|
|
if box == root {
|
|
box.computed_size = canvas_size;
|
|
} else {
|
|
switch box.semantic_size.x.kind {
|
|
case .FitText: {
|
|
// TODO: don't use hardcoded font size
|
|
box.computed_size.x = len(box.label) * font_width;
|
|
}
|
|
case .Exact: {
|
|
box.computed_size.x = box.semantic_size.x.value;
|
|
}
|
|
case .ChildrenSum: {
|
|
compute_children = false;
|
|
box.computed_size.x = 0;
|
|
|
|
iter := BoxIter { box.first, 0 };
|
|
for child in iterate_box(&iter) {
|
|
compute_layout(canvas_size, font_width, font_height, child);
|
|
|
|
switch box.axis {
|
|
case .Horizontal: {
|
|
box.computed_size.x += child.computed_size.x;
|
|
}
|
|
case .Vertical: {
|
|
if child.computed_size.x > box.computed_size.x {
|
|
box.computed_size.x = child.computed_size.x;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case .Fill: {
|
|
}
|
|
case .PercentOfParent: {
|
|
box.computed_size.x = int(f32(ancestor_size(box, .Horizontal))*(f32(box.semantic_size.x.value)/100.0));
|
|
}
|
|
}
|
|
switch box.semantic_size.y.kind {
|
|
case .FitText: {
|
|
// TODO: don't use hardcoded font size
|
|
box.computed_size.y = font_height;
|
|
}
|
|
case .Exact: {
|
|
box.computed_size.y = box.semantic_size.y.value;
|
|
}
|
|
case .ChildrenSum: {
|
|
compute_children = false;
|
|
should_post_compute := false;
|
|
number_of_fills := 0;
|
|
box.computed_size.y = 0;
|
|
parent_size := ancestor_size(box, .Vertical);
|
|
|
|
iter := BoxIter { box.first, 0 };
|
|
for child in iterate_box(&iter) {
|
|
compute_layout(canvas_size, font_width, font_height, child);
|
|
|
|
if child.semantic_size.y.kind == .Fill {
|
|
number_of_fills += 1;
|
|
should_post_compute := true;
|
|
}
|
|
|
|
switch box.axis {
|
|
case .Horizontal: {
|
|
if child.computed_size.y > box.computed_size.y {
|
|
box.computed_size.y = child.computed_size.y;
|
|
}
|
|
}
|
|
case .Vertical: {
|
|
box.computed_size.y += child.computed_size.y;
|
|
}
|
|
}
|
|
}
|
|
|
|
// if should_post_compute {
|
|
// iter := BoxIter { box.first, 0 };
|
|
// for child in iterate_box(&iter) {
|
|
// if compute_layout(canvas_size, font_width, font_height, child) {
|
|
// child.computed_size.y = (parent_size - box.computed_size.y) / number_of_fills;
|
|
// }
|
|
// }
|
|
// }
|
|
}
|
|
case .Fill: {
|
|
}
|
|
case .PercentOfParent: {
|
|
box.computed_size.y = int(f32(ancestor_size(box, .Vertical))*(f32(box.semantic_size.y.value)/100.0));
|
|
}
|
|
}
|
|
}
|
|
|
|
if compute_children {
|
|
iter := BoxIter { box.first, 0 };
|
|
should_post_compute := false;
|
|
child_size: [2]int = {0,0};
|
|
|
|
// NOTE: the number of fills for the opposite axis of this box needs to be 1
|
|
// because it will never get incremented in the loop below and cause a divide by zero
|
|
// and the number of fills for the axis of the box needs to start at zero or else it will
|
|
// be n+1 causing incorrect sizes
|
|
number_of_fills: [2]int = {1,1};
|
|
number_of_fills[box.axis] = 0;
|
|
|
|
our_size := box.computed_size;
|
|
|
|
for child in iterate_box(&iter) {
|
|
compute_layout(canvas_size, font_width, font_height, child);
|
|
if child.semantic_size[box.axis].kind == .Fill {
|
|
number_of_fills[box.axis] += 1;
|
|
should_post_compute = true;
|
|
} else {
|
|
child_size[box.axis] += child.computed_size[box.axis];
|
|
}
|
|
}
|
|
|
|
if should_post_compute {
|
|
iter := BoxIter { box.first, 0 };
|
|
for child in iterate_box(&iter) {
|
|
for axis in 0..<2 {
|
|
if child.semantic_size[axis].kind == .Fill {
|
|
if child_size[axis] >= our_size[axis] {
|
|
child.computed_size[axis] = our_size[axis] / number_of_fills[axis];
|
|
} else {
|
|
child.computed_size[axis] = (our_size[axis] - child_size[axis]) / number_of_fills[axis];
|
|
}
|
|
}
|
|
}
|
|
|
|
compute_layout(canvas_size, font_width, font_height, child);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
push_clip :: proc(pos: [2]int, size: [2]int) {
|
|
rect := Rect { pos, size };
|
|
|
|
if len(clips) > 0 {
|
|
parent_rect := clips[len(clips)-1];
|
|
|
|
if rect.pos.x >= parent_rect.pos.x &&
|
|
rect.pos.y >= parent_rect.pos.y &&
|
|
rect.pos.x < parent_rect.pos.x + parent_rect.size.x &&
|
|
rect.pos.y < parent_rect.pos.y + parent_rect.size.y
|
|
{
|
|
//rect.pos.x = math.max(rect.pos.x, parent_rect.pos.x);
|
|
//rect.pos.y = math.max(rect.pos.y, parent_rect.pos.y);
|
|
|
|
rect.size.x = math.min(rect.pos.x + rect.size.x, parent_rect.pos.x + parent_rect.size.x);
|
|
rect.size.y = math.min(rect.pos.y + rect.size.y, parent_rect.pos.y + parent_rect.size.y);
|
|
|
|
rect.size.x -= rect.pos.x;
|
|
rect.size.y -= rect.pos.y;
|
|
} else {
|
|
rect = parent_rect;
|
|
}
|
|
}
|
|
|
|
raylib.BeginScissorMode(
|
|
i32(rect.pos.x),
|
|
i32(rect.pos.y),
|
|
i32(rect.size.x),
|
|
i32(rect.size.y)
|
|
);
|
|
|
|
append(&clips, rect);
|
|
}
|
|
|
|
pop_clip :: proc() {
|
|
raylib.EndScissorMode();
|
|
|
|
if len(clips) > 0 {
|
|
rect := pop(&clips);
|
|
|
|
raylib.BeginScissorMode(
|
|
i32(rect.pos.x),
|
|
i32(rect.pos.y),
|
|
i32(rect.size.x),
|
|
i32(rect.size.y)
|
|
);
|
|
}
|
|
}
|
|
|
|
draw :: proc(font: raylib.Font, font_width: int, font_height: int, box: ^Box = root) {
|
|
if box == nil { return; }
|
|
|
|
// NOTE: for some reason if you place this right before the
|
|
// for loop, the clipping only works for the first child. Compiler bug?
|
|
push_clip(box.computed_pos, box.computed_size);
|
|
defer pop_clip();
|
|
|
|
if .DrawBorder in box.flags {
|
|
raylib.DrawRectangleLines(
|
|
i32(box.computed_pos.x),
|
|
i32(box.computed_pos.y),
|
|
i32(box.computed_size.x),
|
|
i32(box.computed_size.y),
|
|
theme.get_palette_raylib_color(.Background4)
|
|
);
|
|
}
|
|
if .DrawBackground in box.flags {
|
|
raylib.DrawRectangle(
|
|
i32(box.computed_pos.x),
|
|
i32(box.computed_pos.y),
|
|
i32(box.computed_size.x),
|
|
i32(box.computed_size.y),
|
|
theme.get_palette_raylib_color(.Background1)
|
|
);
|
|
}
|
|
if .DrawText in box.flags {
|
|
for codepoint, index in box.label {
|
|
raylib.DrawTextCodepoint(
|
|
font,
|
|
rune(codepoint),
|
|
raylib.Vector2 { f32(box.computed_pos.x + index * font_width), f32(box.computed_pos.y) },
|
|
f32(font_height),
|
|
theme.get_palette_raylib_color(.Foreground1)
|
|
);
|
|
}
|
|
}
|
|
|
|
iter := BoxIter { box.first, 0 };
|
|
for child in iterate_box(&iter) {
|
|
draw(font, font_width, font_height, child);
|
|
}
|
|
}
|
|
|
|
BoxIter :: struct {
|
|
box: ^Box,
|
|
index: int,
|
|
}
|
|
|
|
iterate_box :: proc(iter: ^BoxIter, print: bool = false) -> (box: ^Box, idx: int, cond: bool) {
|
|
if iter.box == nil {
|
|
return nil, iter.index, false;
|
|
}
|
|
|
|
box = iter.box;
|
|
idx = iter.index;
|
|
|
|
iter.box = iter.box.next;
|
|
iter.index += 1;
|
|
|
|
return box, iter.index, true;
|
|
}
|
|
|
|
debug_print :: proc(box: ^Box, depth: int = 0) {
|
|
iter := BoxIter { box.first, 0 };
|
|
|
|
for box, idx in iterate_box(&iter, true) {
|
|
for _ in 0..<(depth*6) {
|
|
fmt.print("-");
|
|
}
|
|
if depth > 0 {
|
|
fmt.print(">");
|
|
}
|
|
fmt.println(idx, "Box", box.label, "#", box.key.label, "first", transmute(rawptr)box.first, "parent", transmute(rawptr)box.parent, box.computed_size);
|
|
debug_print(box, depth+1);
|
|
}
|
|
|
|
if depth == 0 {
|
|
fmt.println("persistent");
|
|
for p in persistent {
|
|
fmt.println(p);
|
|
}
|
|
}
|
|
}
|
|
|
|
spacer :: proc(label: string) -> ^Box {
|
|
return push_box(label, {}, semantic_size = {make_semantic_size(.Fill, 0), make_semantic_size(.Fill, 0)});
|
|
}
|
|
|
|
button :: proc(label: string) -> Interaction {
|
|
box := push_box(label, {.Clickable, .Hoverable, .DrawText, .DrawBorder, .DrawBackground});
|
|
|
|
return test_box(box);
|
|
}
|
|
|
|
two_buttons_test :: proc(label1: string, label2: string) {
|
|
push_parent(push_box("two_button_container", {.DrawBorder}, .Vertical, semantic_size = ChildrenSum));
|
|
|
|
button("1");
|
|
button("2");
|
|
button(label1);
|
|
button(label2);
|
|
button("5");
|
|
button("6");
|
|
|
|
push_parent(push_box("two_button_container_inner", {.DrawBorder}, semantic_size = ChildrenSum));
|
|
button("second first button");
|
|
{
|
|
push_parent(push_box("two_button_container_inner", {.DrawBorder}, .Vertical, semantic_size = {make_semantic_size(.PercentOfParent, 50), { .Exact, 256}}));
|
|
defer pop_parent();
|
|
|
|
button("first inner most button");
|
|
button("inner_button2");
|
|
button("inner_button3");
|
|
}
|
|
button("inner_button3");
|
|
|
|
pop_parent();
|
|
button("Help me I'm falling");
|
|
pop_parent();
|
|
}
|