741 lines
21 KiB
Plaintext
741 lines
21 KiB
Plaintext
package ui
|
|
|
|
import "core:fmt"
|
|
import "core:strings"
|
|
import "core:math"
|
|
import "vendor:sdl2"
|
|
|
|
import "../core"
|
|
import "../theme"
|
|
|
|
Context :: struct {
|
|
root: ^Box,
|
|
current_parent: ^Box,
|
|
persistent: map[Key]^Box,
|
|
current_interaction_index: int,
|
|
|
|
clips: [dynamic]Rect,
|
|
renderer: ^sdl2.Renderer,
|
|
|
|
mouse_x: int,
|
|
mouse_y: int,
|
|
|
|
mouse_left_down: bool,
|
|
last_mouse_left_down: bool,
|
|
|
|
mouse_right_down: bool,
|
|
last_mouse_right_down: bool,
|
|
}
|
|
|
|
Rect :: struct {
|
|
pos: [2]int,
|
|
size: [2]int,
|
|
}
|
|
|
|
Key :: struct {
|
|
label: string,
|
|
value: int,
|
|
}
|
|
|
|
Interaction :: struct {
|
|
hovering: bool,
|
|
clicked: bool,
|
|
}
|
|
|
|
Flag :: enum {
|
|
Clickable,
|
|
Hoverable,
|
|
Scrollable,
|
|
DrawText,
|
|
DrawBorder,
|
|
DrawBackground,
|
|
Floating,
|
|
CustomDrawFunc,
|
|
}
|
|
|
|
SemanticSizeKind :: enum {
|
|
FitText = 0,
|
|
Exact,
|
|
ChildrenSum,
|
|
Fill,
|
|
PercentOfParent,
|
|
}
|
|
|
|
SemanticSize :: struct {
|
|
kind: SemanticSizeKind,
|
|
value: int,
|
|
}
|
|
|
|
Axis :: enum {
|
|
Horizontal = 0,
|
|
Vertical = 1,
|
|
}
|
|
|
|
CustomDrawFunc :: proc(state: ^core.State, box: ^Box, user_data: rawptr);
|
|
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,
|
|
|
|
hot: int,
|
|
active: int,
|
|
|
|
custom_draw_func: CustomDrawFunc,
|
|
user_data: rawptr,
|
|
}
|
|
|
|
init :: proc(renderer: ^sdl2.Renderer) -> Context {
|
|
root := new(Box);
|
|
root.key = gen_key(nil, "root", 69);
|
|
|
|
return Context {
|
|
root = root,
|
|
current_parent = root,
|
|
persistent = make(map[Key]^Box),
|
|
clips = make([dynamic]Rect),
|
|
renderer = renderer,
|
|
};
|
|
}
|
|
|
|
gen_key :: proc(ctx: ^Context, label: string, value: int) -> Key {
|
|
key_label := ""
|
|
if ctx != nil && (ctx.current_parent == nil || len(ctx.current_parent.key.label) < 1) {
|
|
key_label = strings.clone(label);
|
|
} else if ctx != nil {
|
|
key_label = fmt.aprintf("%s:%s", ctx.current_parent.key.label, label);
|
|
} else {
|
|
key_label = fmt.aprintf("%s",label);
|
|
}
|
|
|
|
return Key {
|
|
label = key_label,
|
|
value = value,
|
|
};
|
|
}
|
|
|
|
@(private)
|
|
make_box :: proc(ctx: ^Context, key: Key, label: string, flags: bit_set[Flag], axis: Axis, semantic_size: [2]SemanticSize) -> ^Box {
|
|
box: ^Box = nil;
|
|
|
|
if cached_box, exists := ctx.persistent[key]; exists {
|
|
if cached_box.last_interacted_index < ctx.current_interaction_index {
|
|
old_cached_box := ctx.persistent[key];
|
|
free(old_cached_box);
|
|
box = new(Box);
|
|
|
|
ctx.persistent[key] = box;
|
|
} else {
|
|
box = cached_box;
|
|
}
|
|
} else {
|
|
box = new(Box);
|
|
ctx.persistent[key] = box;
|
|
}
|
|
|
|
box.key = key;
|
|
box.label = label;
|
|
|
|
box.first = nil;
|
|
box.last = nil;
|
|
box.next = nil;
|
|
box.prev = ctx.current_parent.last;
|
|
box.parent = ctx.current_parent;
|
|
box.flags = flags;
|
|
box.axis = axis;
|
|
box.semantic_size = semantic_size;
|
|
|
|
if ctx.current_parent.last != nil {
|
|
ctx.current_parent.last.next = box;
|
|
}
|
|
if ctx.current_parent.first == nil {
|
|
ctx.current_parent.first = box;
|
|
}
|
|
|
|
ctx.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,
|
|
}
|
|
};
|
|
|
|
Fill :[2]SemanticSize: {
|
|
SemanticSize {
|
|
kind = .Fill,
|
|
},
|
|
SemanticSize {
|
|
kind = .Fill,
|
|
}
|
|
};
|
|
|
|
push_box :: proc(ctx: ^Context, label: string, flags: bit_set[Flag], axis: Axis = .Horizontal, semantic_size: [2]SemanticSize = FitText, value: int = 0) -> ^Box {
|
|
key := gen_key(ctx, label, value);
|
|
box := make_box(ctx, key, label, flags, axis, semantic_size);
|
|
|
|
return box;
|
|
}
|
|
|
|
push_parent :: proc(ctx: ^Context, box: ^Box) {
|
|
ctx.current_parent = box;
|
|
}
|
|
|
|
pop_parent :: proc(ctx: ^Context) {
|
|
if ctx.current_parent.parent != nil {
|
|
ctx.current_parent = ctx.current_parent.parent;
|
|
}
|
|
}
|
|
|
|
test_box :: proc(ctx: ^Context, box: ^Box) -> Interaction {
|
|
hovering: bool;
|
|
|
|
mouse_is_clicked := !ctx.last_mouse_left_down && ctx.mouse_left_down;
|
|
|
|
if ctx.mouse_x >= box.computed_pos.x && ctx.mouse_x <= box.computed_pos.x + box.computed_size.x &&
|
|
ctx.mouse_y >= box.computed_pos.y && ctx.mouse_y <= box.computed_pos.y + box.computed_size.y
|
|
{
|
|
hovering = true;
|
|
}
|
|
|
|
if hovering {
|
|
box.hot += 1;
|
|
} else {
|
|
box.hot = 0;
|
|
}
|
|
|
|
return Interaction {
|
|
hovering = hovering,
|
|
clicked = hovering && mouse_is_clicked,
|
|
};
|
|
}
|
|
|
|
delete_box_children :: proc(ctx: ^Context, box: ^Box, keep_persistent: bool = true) {
|
|
iter := BoxIter { box.first, 0 };
|
|
|
|
for box in iterate_box(&iter) {
|
|
delete_box(ctx, box, keep_persistent);
|
|
}
|
|
}
|
|
|
|
delete_box :: proc(ctx: ^Context, box: ^Box, keep_persistent: bool = true) {
|
|
delete_box_children(ctx, box, keep_persistent);
|
|
|
|
if !(box.key in ctx.persistent) || !keep_persistent {
|
|
delete(box.key.label);
|
|
free(box);
|
|
}
|
|
}
|
|
|
|
prune :: proc(ctx: ^Context) {
|
|
iter := BoxIter { ctx.root.first, 0 };
|
|
|
|
for box in iterate_box(&iter) {
|
|
delete_box_children(ctx, box);
|
|
|
|
if !(box.key in ctx.persistent) {
|
|
free(box);
|
|
}
|
|
}
|
|
|
|
computed_pos := ctx.root.computed_pos;
|
|
computed_size := ctx.root.computed_size;
|
|
root_key := ctx.root.key;
|
|
|
|
ctx.root.first = nil;
|
|
ctx.root.last = nil;
|
|
ctx.root.next = nil;
|
|
ctx.root.prev = nil;
|
|
ctx.root.parent = nil;
|
|
ctx.current_parent = ctx.root;
|
|
}
|
|
|
|
// TODO: consider not using `ctx` here
|
|
ancestor_size :: proc(ctx: ^Context, box: ^Box, axis: Axis) -> int {
|
|
if box == nil || box.parent == nil || .Floating in box.flags {
|
|
return ctx.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(ctx, box.parent, axis);
|
|
}
|
|
|
|
return 1337;
|
|
}
|
|
|
|
prev_non_floating_sibling :: proc(ctx: ^Context, box: ^Box) -> ^Box {
|
|
if box == nil {
|
|
return nil;
|
|
} else if box.prev == nil {
|
|
return nil;
|
|
} else if !(.Floating in box.prev.flags) {
|
|
return box.prev;
|
|
} else {
|
|
return prev_non_floating_sibling(ctx, box.prev);
|
|
}
|
|
}
|
|
|
|
compute_layout :: proc(ctx: ^Context, canvas_size: [2]int, font_width: int, font_height: int, box: ^Box) {
|
|
if box == nil { return; }
|
|
|
|
axis := Axis.Horizontal;
|
|
if box.parent != nil && !(.Floating in box.flags) {
|
|
axis = box.parent.axis;
|
|
box.computed_pos = box.parent.computed_pos;
|
|
}
|
|
|
|
if .Floating in box.flags {
|
|
// box.computed_pos = {0,0};
|
|
} else if box.prev != nil {
|
|
prev := prev_non_floating_sibling(ctx, box);
|
|
|
|
if prev != nil {
|
|
box.computed_pos[axis] = prev.computed_pos[axis] + prev.computed_size[axis];
|
|
}
|
|
}
|
|
|
|
post_compute_size := [2]bool { false, false };
|
|
compute_children := true;
|
|
if box == ctx.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;
|
|
post_compute_size[int(Axis.Horizontal)] = true;
|
|
// 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(ctx, 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;
|
|
post_compute_size[Axis.Vertical] = true;
|
|
|
|
// 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(ctx, 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) {
|
|
if .Floating in child.flags { continue; }
|
|
|
|
compute_layout(ctx, 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 true || 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 false && 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(ctx, canvas_size, font_width, font_height, child);
|
|
|
|
if child.label == "2" {
|
|
fmt.println(child.label, child.computed_size, box.label, our_size, child_size, number_of_fills);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if post_compute_size[Axis.Horizontal] {
|
|
box.computed_size[Axis.Horizontal] = 0;
|
|
|
|
iter := BoxIter { box.first, 0 };
|
|
for child in iterate_box(&iter) {
|
|
switch box.axis {
|
|
case .Horizontal: {
|
|
box.computed_size[Axis.Horizontal] += child.computed_size[Axis.Horizontal];
|
|
}
|
|
case .Vertical: {
|
|
if child.computed_size[Axis.Horizontal] > box.computed_size[Axis.Horizontal] {
|
|
box.computed_size[Axis.Horizontal] = child.computed_size[Axis.Horizontal];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if post_compute_size[Axis.Vertical] {
|
|
box.computed_size[Axis.Vertical] = 0;
|
|
|
|
iter := BoxIter { box.first, 0 };
|
|
for child in iterate_box(&iter) {
|
|
switch box.axis {
|
|
case .Horizontal: {
|
|
if child.computed_size[Axis.Vertical] > box.computed_size[Axis.Vertical] {
|
|
box.computed_size[Axis.Vertical] = child.computed_size[Axis.Vertical];
|
|
}
|
|
}
|
|
case .Vertical: {
|
|
box.computed_size[Axis.Vertical] += child.computed_size[Axis.Vertical];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
push_clip :: proc(ctx: ^Context, pos: [2]int, size: [2]int) {
|
|
rect := Rect { pos, size };
|
|
|
|
if len(ctx.clips) > 0 {
|
|
parent_rect := ctx.clips[len(ctx.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;
|
|
}
|
|
}
|
|
|
|
sdl2.RenderSetClipRect(ctx.renderer, &sdl2.Rect {
|
|
i32(rect.pos.x),
|
|
i32(rect.pos.y),
|
|
i32(rect.size.x),
|
|
i32(rect.size.y)
|
|
});
|
|
|
|
// raylib.BeginScissorMode(
|
|
// i32(rect.pos.x),
|
|
// i32(rect.pos.y),
|
|
// i32(rect.size.x),
|
|
// i32(rect.size.y)
|
|
// );
|
|
|
|
append(&ctx.clips, rect);
|
|
}
|
|
|
|
pop_clip :: proc(ctx: ^Context) {
|
|
//raylib.EndScissorMode();
|
|
|
|
if len(ctx.clips) > 0 {
|
|
rect := pop(&ctx.clips);
|
|
|
|
sdl2.RenderSetClipRect(ctx.renderer, &sdl2.Rect {
|
|
i32(rect.pos.x),
|
|
i32(rect.pos.y),
|
|
i32(rect.size.x),
|
|
i32(rect.size.y)
|
|
});
|
|
// raylib.BeginScissorMode(
|
|
// i32(rect.pos.x),
|
|
// i32(rect.pos.y),
|
|
// i32(rect.size.x),
|
|
// i32(rect.size.y)
|
|
// );
|
|
} else {
|
|
sdl2.RenderSetClipRect(ctx.renderer, nil);
|
|
}
|
|
}
|
|
|
|
draw :: proc(ctx: ^Context, state: ^core.State, font_width: int, font_height: int, box: ^Box) {
|
|
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(ctx, box.computed_pos, box.computed_size);
|
|
defer pop_clip(ctx);
|
|
|
|
if .Hoverable in box.flags && box.hot > 0 {
|
|
core.draw_rect(
|
|
state,
|
|
box.computed_pos.x,
|
|
box.computed_pos.y,
|
|
box.computed_size.x,
|
|
box.computed_size.y,
|
|
.Background2
|
|
);
|
|
}
|
|
else if .DrawBackground in box.flags {
|
|
core.draw_rect(
|
|
state,
|
|
box.computed_pos.x,
|
|
box.computed_pos.y,
|
|
box.computed_size.x,
|
|
box.computed_size.y,
|
|
.Background1
|
|
);
|
|
}
|
|
|
|
if .DrawBorder in box.flags {
|
|
core.draw_rect_outline(
|
|
state,
|
|
box.computed_pos.x,
|
|
box.computed_pos.y,
|
|
box.computed_size.x,
|
|
box.computed_size.y,
|
|
.Background4
|
|
);
|
|
}
|
|
if .DrawText in box.flags {
|
|
core.draw_text(state, box.label, box.computed_pos.x, box.computed_pos.y);
|
|
}
|
|
|
|
if .CustomDrawFunc in box.flags && box.custom_draw_func != nil {
|
|
box.custom_draw_func(state, box, box.user_data);
|
|
}
|
|
|
|
iter := BoxIter { box.first, 0 };
|
|
for child in iterate_box(&iter) {
|
|
draw(ctx, state, 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(ctx: ^Context, 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(ctx, box, depth+1);
|
|
}
|
|
|
|
if depth == 0 {
|
|
fmt.println("persistent");
|
|
for p in ctx.persistent {
|
|
fmt.println(p);
|
|
}
|
|
}
|
|
}
|
|
|
|
spacer :: proc(ctx: ^Context, label: string, flags: bit_set[Flag] = {}, semantic_size: [2]SemanticSize = {{.Fill, 0}, {.Fill,0}}) -> ^Box {
|
|
return push_box(ctx, label, flags, semantic_size = semantic_size);
|
|
}
|
|
|
|
push_floating :: proc(ctx: ^Context, label: string, pos: [2]int, flags: bit_set[Flag] = {.Floating}, axis: Axis = .Vertical, semantic_size: [2]SemanticSize = Fill) -> ^Box {
|
|
box := push_box(ctx, label, flags, semantic_size = semantic_size);
|
|
box.computed_pos = pos;
|
|
|
|
return box;
|
|
}
|
|
|
|
push_rect :: proc(ctx: ^Context, label: string, border: bool = true, axis: Axis = .Vertical, semantic_size: [2]SemanticSize = Fill) -> ^Box {
|
|
return push_box(ctx, label, {.DrawBackground, .DrawBorder if border else nil}, axis, semantic_size = semantic_size);
|
|
}
|
|
|
|
label :: proc(ctx: ^Context, label: string) -> Interaction {
|
|
box := push_box(ctx, label, {.DrawText});
|
|
|
|
return test_box(ctx, box);
|
|
}
|
|
|
|
button :: proc(ctx: ^Context, label: string) -> Interaction {
|
|
box := push_box(ctx, label, {.Clickable, .Hoverable, .DrawText, .DrawBorder, .DrawBackground});
|
|
|
|
return test_box(ctx, box);
|
|
}
|
|
|
|
custom :: proc(ctx: ^Context, label: string, draw_func: CustomDrawFunc, user_data: rawptr) -> Interaction {
|
|
box := push_box(ctx, label, {.DrawBorder, .CustomDrawFunc}, semantic_size = { make_semantic_size(.Fill), make_semantic_size(.Fill) });
|
|
box.custom_draw_func = draw_func;
|
|
box.user_data = user_data;
|
|
|
|
return test_box(ctx, box);
|
|
}
|
|
|
|
two_buttons_test :: proc(ctx: ^Context, label1: string, label2: string) {
|
|
push_parent(ctx, push_box(ctx, "TWO BUTTONS TEST", {.DrawBorder}, .Vertical, semantic_size = {make_semantic_size(.PercentOfParent, 100), { .Fill, 256}}));
|
|
|
|
button(ctx, "Row 1");
|
|
button(ctx, "Row 2");
|
|
button(ctx, label1);
|
|
button(ctx, label2);
|
|
button(ctx, "Row 5");
|
|
button(ctx, "Row 6");
|
|
|
|
{
|
|
push_parent(ctx, push_box(ctx, "two_button_container_inner", {.DrawBorder}, semantic_size = {make_semantic_size(.Fill, 0), { .Fill, 64}}));
|
|
defer pop_parent(ctx);
|
|
|
|
push_box(ctx, "1", {.DrawText, .DrawBackground, .DrawBorder}, semantic_size = {make_semantic_size(.Fill, 100), { .FitText, 256}})
|
|
push_box(ctx, "2", {.DrawText, .DrawBackground, .DrawBorder}, semantic_size = {make_semantic_size(.Fill, 100), { .FitText, 256}})
|
|
|
|
{
|
|
push_parent(ctx, push_box(ctx, "two_button_container_inner_inner", {.DrawBorder}, .Vertical, semantic_size = {make_semantic_size(.Fill, 50), { .ChildrenSum, 256}}));
|
|
defer pop_parent(ctx);
|
|
|
|
button(ctx, "this is a test button");
|
|
button(ctx, "me in the middle");
|
|
button(ctx, "look at me, I'm a test button too");
|
|
}
|
|
|
|
push_box(ctx, "End", {.DrawBorder, .DrawBackground, .DrawText}, .Horizontal, semantic_size = {make_semantic_size(.Fill, 0), { .FitText, 0}})
|
|
}
|
|
button(ctx, "Help me I'm falling");
|
|
pop_parent(ctx);
|
|
}
|