From f01eb452a93f7b0e7449b39694f6978a77449017 Mon Sep 17 00:00:00 2001 From: Patrick Cleavelin Date: Sun, 18 Feb 2024 14:39:28 -0600 Subject: [PATCH] get dragging working properly with clicking --- plugins/lua/view.lua | 164 ++++++++++++++++++++++++++++--------------- src/core/gfx.odin | 15 ++++ src/main.odin | 70 +++++++++--------- src/ui/imm.odin | 124 ++++++++++++-------------------- 4 files changed, 202 insertions(+), 171 deletions(-) diff --git a/plugins/lua/view.lua b/plugins/lua/view.lua index 587b5fa..3e94bb8 100644 --- a/plugins/lua/view.lua +++ b/plugins/lua/view.lua @@ -14,6 +14,9 @@ local CodeViews = {} local MovingTab = nil local MovingTabDest = nil +local LastMouseX = 0 +local LastMouseY = 0 + function buffer_list_iter() local idx = 0 return function () @@ -42,15 +45,25 @@ function lerp(from, to, rate) return (1 - rate) * from + rate*to end +function remove_buffer_from_code_view(code_view_index, file_path) + if code_view_index ~= nil and CodeViews[code_view_index] ~= nil then + CodeViews[code_view_index].tabs[file_path] = nil + k,v = pairs(CodeViews[code_view_index].tabs)(CodeViews[code_view_index].tabs) + CodeViews[code_view_index].current_tab = k + end +end + function add_buffer_to_code_view(code_view_index, file_path, buffer_index) if code_view_index == nil then code_view_index = 1 ActiveCodeView = 1 end + -- A new code view is being created if CodeViews[code_view_index] == nil then CodeViews[code_view_index] = {} CodeViews[code_view_index].tabs = {} + CodeViews[code_view_index].width = UI.Fill end ActiveCodeView = code_view_index @@ -63,7 +76,7 @@ end function ui_sidebar(ctx) SideBarSmoothedWidth = lerp(SideBarSmoothedWidth, SideBarWidth, 0.3) - tabs = UI.push_rect(ctx, "for some reason it chooses this as the parent", false, false, UI.Vertical, UI.Exact(SideBarSmoothedWidth), UI.Fill) + tabs, _ = UI.push_rect(ctx, "for some reason it chooses this as the parent", false, false, UI.Vertical, UI.Exact(SideBarSmoothedWidth), UI.Fill) UI.push_parent(ctx, tabs) UI.push_rect(ctx, "padded top open files", false, false, UI.Horizontal, UI.Fill, UI.Exact(8)) UI.push_parent(ctx, UI.push_rect(ctx, "padded open files", false, false, UI.Horizontal, UI.Fill, UI.ChildrenSum)) @@ -82,6 +95,7 @@ function ui_sidebar(ctx) if UI.advanced_button(ctx, " x ", flags, UI.FitText, UI.FitText).clicked then print("hahah, you can't close buffers yet silly") + Editor.set_current_buffer_from_index(i) add_buffer_to_code_view(ActiveCodeView+1, buffer_info.file_path, i) end @@ -104,71 +118,81 @@ function ui_code_view(ctx, code_view_index) local code_view = CodeViews[code_view_index] local is_tab_dest = MovingTab ~= nil and ActiveCodeView ~= code_view_index - UI.push_parent(ctx, UI.push_rect(ctx, code_view_index.." code view", ActiveCodeView ~= code_view_index, true, UI.Vertical, UI.Fill, UI.Fill)) - if is_tab_dest then - tab_dest_region = UI.push_box(ctx, "code view tab dest", {"Hoverable"}, UI.Vertical, UI.Fill, UI.Fill) - tab_dest_interaction = UI.box_interaction(ctx, tab_dest_region) - UI.push_parent(ctx, tab_dest_region) + code_view_rect, code_view_interaction = UI.push_rect(ctx, code_view_index.." code view", ActiveCodeView ~= code_view_index, true, UI.Vertical, code_view.width, UI.Fill) - -- if tab_dest_interaction - end + UI.push_parent(ctx, code_view_rect) + tab_dest_flags = {} + if is_tab_dest then tab_dest_flags = {"Hoverable"} end - UI.push_parent(ctx, UI.push_rect(ctx, "tabs", false, true, UI.Horizontal, UI.Fill, UI.ChildrenSum)) - for k,v in pairs(code_view.tabs) do - show_border = v["buffer_index"] ~= code_view.current_buffer_index - background = not show_border - flags = {"Clickable", "Hoverable", "DrawText"} - - UI.push_parent(ctx, UI.push_rect(ctx, k.." tab container", background, show_border, UI.Horizontal, UI.ChildrenSum, UI.ChildrenSum)) - tab_button = UI.advanced_button(ctx, " "..k.." ", flags, UI.FitText, UI.Exact(32)) - if tab_button.clicked then - ActiveCodeView = code_view_index - code_view.current_tab = k - end - - local bb = "false" - if is_tab_dest then bb = "true" end - -- print("our code view "..code_view_index.." - "..k.." - is tab dest "..bb) - - if tab_button.dragging then - if MovingTab == nil then - MovingTab = {} - MovingTab["code_view_index"] = code_view_index - MovingTab["tab"] = k - end - - UI.push_parent(ctx, UI.push_floating(ctx, "dragging tab", x-(96/2), y-(32/2))) - UI.advanced_button(ctx, " "..k.." ", flags, UI.FitText, UI.Exact(32)) - UI.pop_parent(ctx) - elseif MovingTab ~= nil and MovingTab["code_view_index"] == code_view_index and MovingTab["tab"] == k then - -- Editor.quit() - --print("attempting to move tab "..MovingTab["code_view_index"].." - "..MovingTab["tab"]) - if MovingTabDest ~= nil then - print("attempting to place tab at code view "..MovingTabDest.code_view_index) - - MovingTabDest = nil - end - - MovingTab = nil - end - UI.pop_parent(ctx) + tab_dest_region, tab_dest_interaction = UI.push_box(ctx, "code view tab dest", tab_dest_flags, UI.Vertical, UI.Fill, UI.Fill) + UI.push_parent(ctx, tab_dest_region) + if is_tab_dest then + if tab_dest_interaction.hovering then + MovingTabDest = code_view_index + end end - UI.pop_parent(ctx) - current_tab = code_view.current_tab - buffer_index = code_view.tabs[current_tab].buffer_index + UI.push_parent(ctx, UI.push_rect(ctx, "tabs", false, false, UI.Horizontal, UI.Fill, UI.ChildrenSum)) + for k,v in pairs(code_view.tabs) do + show_border = k ~= code_view.current_tab + background = show_border + flags = {"Clickable", "DrawText"} + if show_border then + table.insert(flags, 1, "DrawBorder") + table.insert(flags, 1, "Hoverable") + end - UI.buffer(ctx, buffer_index) + UI.push_parent(ctx, UI.push_rect(ctx, k.." tab container", background, false, UI.Horizontal, UI.ChildrenSum, UI.ChildrenSum)) + tab_button = UI.advanced_button(ctx, " "..k.." ", flags, UI.FitText, UI.Exact(32)) + if tab_button.clicked or tab_button.dragging then + ActiveCodeView = code_view_index + code_view.current_tab = k - if is_tab_dest then + Editor.set_current_buffer_from_index(v["buffer_index"]) + end + + if tab_button.dragging then + if MovingTab == nil then + MovingTab = {} + MovingTab["code_view_index"] = code_view_index + MovingTab["tab"] = k + end + + UI.push_parent(ctx, UI.push_floating(ctx, "dragging tab", x-(96/2), y-(32/2))) + UI.advanced_button(ctx, " "..k.." ", {"DrawText", "DrawBorder", "DrawBackground"}, UI.FitText, UI.Exact(32)) + UI.pop_parent(ctx) + elseif MovingTab ~= nil and MovingTab["code_view_index"] == code_view_index and MovingTab["tab"] == k then + if MovingTabDest ~= nil then + add_buffer_to_code_view(MovingTabDest, k, v["buffer_index"]) + remove_buffer_from_code_view(code_view_index, k) + + MovingTabDest = nil + end + + MovingTab = nil + end + UI.pop_parent(ctx) + end UI.pop_parent(ctx) - end + + current_tab = code_view.current_tab + if code_view.tabs[current_tab] ~= nil then + buffer_index = code_view.tabs[current_tab].buffer_index + + UI.buffer(ctx, buffer_index) + end + + UI.pop_parent(ctx) UI.pop_parent(ctx) + + return code_view_interaction end function render_ui_window(ctx) current_buffer_index = Editor.get_current_buffer_index() x,y = UI.get_mouse_pos(ctx) + delta_x = LastMouseX - x + delta_y = LastMouseY - y numFrames = 7 CurrentPreviewBufferIndex = current_buffer_index @@ -176,7 +200,7 @@ function render_ui_window(ctx) if not SidebarClosed or SideBarSmoothedWidth > 2 then ui_sidebar(ctx) end - if UI.advanced_button(ctx, "side bar grab handle", {"DrawBorder", "Hoverable"}, UI.Exact(16), UI.Fill).dragging then + if UI.advanced_button(ctx, "side bar grab handle", {"DrawBorder", "Hoverable"}, UI.Exact(16), UI.Fill).dragging then SideBarWidth = x-8 if SideBarWidth < 32 then @@ -192,11 +216,36 @@ function render_ui_window(ctx) end end - for k in ipairs(CodeViews) do - ui_code_view(ctx, k) + for k,v in ipairs(CodeViews) do + code_view_interaction = ui_code_view(ctx, k) + + if next(CodeViews, k) ~= nil then + interaction = UI.advanced_button(ctx, k.."code view grab handle", {"DrawBorder", "Hoverable"}, UI.Exact(16), UI.Fill) + if interaction.dragging then + local width = math.max(32, x - code_view_interaction.box_pos.x) + v.width = UI.Exact(width) + elseif interaction.clicked then + v.width = UI.Fill + end + else + v.width = UI.Fill + end + end + + for k,v in ipairs(CodeViews) do + if next(v.tabs) == nil then + table.remove(CodeViews, k) + + if ActiveCodeView > k then + ActiveCodeView = ActiveCodeView - 1 + end + end end render_buffer_search(ctx) + + LastMouseX = x + LastMouseY = y end function render_buffer_search(ctx) @@ -259,6 +308,9 @@ function OnInit() )}, {Editor.Key.Enter, "Switch to Buffer", ( function () + buffer_info = Editor.buffer_info_from_index(BufferSearchIndex) + add_buffer_to_code_view(ActiveCodeView, buffer_info.file_path, BufferSearchIndex) + Editor.set_current_buffer_from_index(BufferSearchIndex) Editor.request_window_close() BufferSearchOpen = false diff --git a/src/core/gfx.odin b/src/core/gfx.odin index aa0d9df..17bb911 100644 --- a/src/core/gfx.odin +++ b/src/core/gfx.odin @@ -120,6 +120,21 @@ draw_rect :: proc(state: ^State, x,y,w,h: int, color: theme.PaletteColor) { sdl2.RenderFillRect(state.sdl_renderer, &sdl2.Rect { i32(x), i32(y), i32(w), i32(h) }); } +draw_rect_blend :: proc(state: ^State, x,y,w,h: int, color_from: theme.PaletteColor, color_to: theme.PaletteColor, t: f32) { + color_from := theme.get_palette_color(color_from); + color_to := theme.get_palette_color(color_to); + + color_from_f32: [4]f32 = { f32(color_from.r), f32(color_from.g), f32(color_from.b), f32(color_from.a) }; + color_to_f32: [4]f32 = { f32(color_to.r), f32(color_to.g), f32(color_to.b), f32(color_to.a) }; + + color_f32 := (1 - t) * color_from_f32 + t * color_to_f32; + + color: [4]u8 = { u8(color_f32.r), u8(color_f32.g), u8(color_f32.b), u8(color_f32.a) }; + + sdl2.SetRenderDrawColor(state.sdl_renderer, color.r, color.g, color.b, color.a); + sdl2.RenderFillRect(state.sdl_renderer, &sdl2.Rect { i32(x), i32(y), i32(w), i32(h) }); +} + draw_codepoint :: proc(state: ^State, codepoint: rune, x,y: int, color: theme.PaletteColor) { color := theme.get_palette_color(color); diff --git a/src/main.odin b/src/main.odin index 923eee1..10034fa 100644 --- a/src/main.odin +++ b/src/main.odin @@ -301,13 +301,16 @@ ui_file_buffer :: proc(ctx: ^ui.Context, buffer: ^FileBuffer) -> ui.Interaction }; relative_file_path, _ := filepath.rel(state.directory, buffer.file_path, context.temp_allocator) - ui.push_parent(ctx, ui.push_box(ctx, relative_file_path, {}, .Vertical, semantic_size = {ui.make_semantic_size(.Fill), ui.make_semantic_size(.Fill)})); + + buffer_container, _ := ui.push_box(ctx, relative_file_path, {}, .Vertical, semantic_size = {ui.make_semantic_size(.Fill), ui.make_semantic_size(.Fill)}); + ui.push_parent(ctx, buffer_container); defer ui.pop_parent(ctx); interaction := ui.custom(ctx, "buffer1", draw_func, transmute(rawptr)buffer); { - ui.push_parent(ctx, ui.push_box(ctx, "buffer info", {}, semantic_size = {ui.make_semantic_size(.Fill), ui.make_semantic_size(.Exact, state.source_font_height)})); + info_box, _ := ui.push_box(ctx, "buffer info", {}, semantic_size = {ui.make_semantic_size(.Fill), ui.make_semantic_size(.Exact, state.source_font_height)}); + ui.push_parent(ctx, info_box); defer ui.pop_parent(ctx); ui.label(ctx, relative_file_path); @@ -825,7 +828,8 @@ init_plugin_vtable :: proc(ui_context: ^ui.Context) -> plugin.Plugin { ui_context := transmute(^ui.Context)ui_context; label := strings.clone(string(label), context.temp_allocator); - return ui.push_floating(ui_context, label, pos); + floating, _ := ui.push_floating(ui_context, label, pos); + return floating; }, rect = proc "c" (ui_context: rawptr, label: cstring, background: bool, border: bool, axis: plugin.UiAxis, size: [2]plugin.UiSemanticSize) -> plugin.UiBox { context = state.ctx; @@ -843,7 +847,8 @@ init_plugin_vtable :: proc(ui_context: ^ui.Context) -> plugin.Plugin { }, }; - return ui.push_rect(ui_context, label, background, border, ui.Axis(axis), size); + rect, _ := ui.push_rect(ui_context, label, background, border, ui.Axis(axis), size); + return rect; }, label = proc "c" (ui_context: rawptr, label: cstring) -> plugin.UiInteraction { @@ -1251,6 +1256,16 @@ main :: proc() { lua.pushboolean(L, b32(interaction.dragging)); lua.setfield(L, -2, "dragging"); + + lua.newtable(L); + { + lua.pushinteger(L, lua.Integer(interaction.box_pos.x)); + lua.setfield(L, -2, "x"); + + lua.pushinteger(L, lua.Integer(interaction.box_pos.y)); + lua.setfield(L, -2, "y"); + } + lua.setfield(L, -2, "box_pos"); } } @@ -1339,9 +1354,10 @@ main :: proc() { x := int(lua.L_checkinteger(L, 3)); y := int(lua.L_checkinteger(L, 4)); - box := ui.push_floating(ui_ctx, strings.clone(string(label), context.temp_allocator), {x,y}); + box, interaction := ui.push_floating(ui_ctx, strings.clone(string(label), context.temp_allocator), {x,y}); lua.pushlightuserdata(L, box); - return 1; + push_lua_box_interaction(L, interaction); + return 2; } return i32(lua.ERRRUN); @@ -1363,16 +1379,18 @@ main :: proc() { semantic_width := get_lua_semantic_size(L, 5); semantic_height := get_lua_semantic_size(L, 6); - box := ui.push_box(ui_ctx, strings.clone(string(label), context.temp_allocator), flags, axis, { semantic_width, semantic_height }); + box, interaction := ui.push_box(ui_ctx, strings.clone(string(label), context.temp_allocator), flags, axis, { semantic_width, semantic_height }); + lua.pushlightuserdata(L, box); - return 1; + push_lua_box_interaction(L, interaction) + return 2; } return i32(lua.ERRRUN); } }, lua.L_Reg { - "box_interaction", + "_box_interaction", proc "c" (L: ^lua.State) -> i32 { context = state.ctx; @@ -1408,35 +1426,10 @@ main :: proc() { semantic_width := get_lua_semantic_size(L, 6); semantic_height := get_lua_semantic_size(L, 7); - box := ui.push_rect(ui_ctx, strings.clone(string(label), context.temp_allocator), background, border, axis, { semantic_width, semantic_height }); + box, interaction := ui.push_rect(ui_ctx, strings.clone(string(label), context.temp_allocator), background, border, axis, { semantic_width, semantic_height }); lua.pushlightuserdata(L, box); - return 1; - } - - return i32(lua.ERRRUN); - } - }, - lua.L_Reg { - "push_centered", - proc "c" (L: ^lua.State) -> i32 { - - context = state.ctx; - - lua.L_checktype(L, 1, i32(lua.TLIGHTUSERDATA)); - lua.pushvalue(L, 1); - ui_ctx := transmute(^ui.Context)lua.touserdata(L, -1); - if ui_ctx != nil { - label := lua.L_checkstring(L, 2); - background := bool(lua.toboolean(L, 3)); - border := bool(lua.toboolean(L, 4)); - axis := ui.Axis(lua.L_checkinteger(L, 5)); - - semantic_width := get_lua_semantic_size(L, 6); - semantic_height := get_lua_semantic_size(L, 7); - - box := ui.push_centered(ui_ctx, strings.clone(string(label), context.temp_allocator), {.DrawBackground if background else nil, .DrawBorder if border else nil}, axis, { semantic_width, semantic_height }); - lua.pushlightuserdata(L, box); - return 1; + push_lua_box_interaction(L, interaction) + return 2; } return i32(lua.ERRRUN); @@ -1772,6 +1765,9 @@ main :: proc() { ui_context.last_mouse_left_down = ui_context.mouse_left_down; ui_context.last_mouse_right_down = ui_context.mouse_right_down; + ui_context.last_mouse_x = ui_context.mouse_x; + ui_context.last_mouse_y = ui_context.mouse_y; + sdl_event: sdl2.Event; for(sdl2.PollEvent(&sdl_event)) { if sdl_event.type == .QUIT { diff --git a/src/ui/imm.odin b/src/ui/imm.odin index bd0d815..4153b99 100644 --- a/src/ui/imm.odin +++ b/src/ui/imm.odin @@ -17,6 +17,9 @@ Context :: struct { clips: [dynamic]Rect, renderer: ^sdl2.Renderer, + last_mouse_x: int, + last_mouse_y: int, + mouse_x: int, mouse_y: int, @@ -41,6 +44,9 @@ Interaction :: struct { hovering: bool, clicked: bool, dragging: bool, + + box_pos: [2]int, + box_size: [2]int, } Flag :: enum { @@ -93,6 +99,8 @@ Box :: struct { computed_size: [2]int, computed_pos: [2]int, + scroll_offset: int, + hot: int, active: int, @@ -215,11 +223,12 @@ Fill :[2]SemanticSize: { } }; -push_box :: proc(ctx: ^Context, label: string, flags: bit_set[Flag], axis: Axis = .Horizontal, semantic_size: [2]SemanticSize = FitText) -> ^Box { +push_box :: proc(ctx: ^Context, label: string, flags: bit_set[Flag], axis: Axis = .Horizontal, semantic_size: [2]SemanticSize = FitText) -> (^Box, Interaction) { key := gen_key(ctx, label, 0); box := make_box(ctx, key, label, flags, axis, semantic_size); + interaction := test_box(ctx, box); - return box; + return box, interaction; } push_parent :: proc(ctx: ^Context, box: ^Box) { @@ -236,11 +245,19 @@ test_box :: proc(ctx: ^Context, box: ^Box) -> Interaction { hovering: bool; mouse_is_clicked := !ctx.last_mouse_left_down && ctx.mouse_left_down; + mouse_is_released := ctx.last_mouse_left_down && !ctx.mouse_left_down; + mouse_is_dragging := !mouse_is_clicked && ctx.mouse_left_down && (ctx.last_mouse_x != ctx.mouse_x || ctx.last_mouse_y != ctx.mouse_y); 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 box.parent != nil && ctx.mouse_x >= box.parent.computed_pos.x && ctx.mouse_x <= box.parent.computed_pos.x + box.parent.computed_size.x && + ctx.mouse_y >= box.parent.computed_pos.y && ctx.mouse_y <= box.parent.computed_pos.y + box.parent.computed_size.y + { + hovering = true; + } else if box.parent == nil { + hovering = true; + } } if hovering || box.active > 0 { @@ -249,9 +266,11 @@ test_box :: proc(ctx: ^Context, box: ^Box) -> Interaction { box.hot = 0; } - if hovering && mouse_is_clicked { + if hovering && mouse_is_clicked && !mouse_is_dragging { + box.active = 1; + } else if hovering && mouse_is_dragging && box.active > 0 { box.active += 1; - } else if !ctx.mouse_left_down { + } else if !ctx.mouse_left_down && !mouse_is_released { box.active = 0; } @@ -260,8 +279,11 @@ test_box :: proc(ctx: ^Context, box: ^Box) -> Interaction { } return Interaction { hovering = hovering || box.active > 0, - clicked = hovering && mouse_is_clicked, - dragging = box.active > 0 + clicked = hovering && mouse_is_released && box.active > 0, + dragging = box.active > 1, + + box_pos = box.computed_pos, + box_size = box.computed_size, }; } @@ -345,7 +367,7 @@ compute_layout :: proc(ctx: ^Context, canvas_size: [2]int, font_width: int, font axis := Axis.Horizontal; if box.parent != nil && !(.Floating in box.flags) { axis = box.parent.axis; - box.computed_pos = box.parent.computed_pos; + box.computed_pos = box.parent.computed_pos - { 0, box.parent.scroll_offset }; } if .Floating in box.flags { @@ -538,13 +560,15 @@ draw :: proc(ctx: ^Context, state: ^core.State, font_width: int, font_height: in defer pop_clip(ctx); if .Hoverable in box.flags && box.hot > 0 { - core.draw_rect( + core.draw_rect_blend( state, box.computed_pos.x, box.computed_pos.y, box.computed_size.x, box.computed_size.y, - .Background2 + .Background1, + .Background2, + f32(math.min(box.hot, 20))/20.0 ); } else if .DrawBackground in box.flags { core.draw_rect( @@ -628,50 +652,26 @@ debug_print :: proc(ctx: ^Context, box: ^Box, depth: int = 0) { } spacer :: proc(ctx: ^Context, label: string, flags: bit_set[Flag] = {}, semantic_size: [2]SemanticSize = {{.Fill, 0}, {.Fill,0}}) -> Interaction { - box := push_box(ctx, label, flags, semantic_size = semantic_size); + box, interaction := push_box(ctx, label, flags, semantic_size = semantic_size); - return test_box(ctx, box); + return interaction; } -push_floating :: proc(ctx: ^Context, label: string, pos: [2]int, flags: bit_set[Flag] = {.Floating}, axis: Axis = .Horizontal, semantic_size: [2]SemanticSize = Fill) -> ^Box { - box := 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 = .Horizontal, semantic_size: [2]SemanticSize = Fill) -> (^Box, Interaction) { + box, interaction := push_box(ctx, label, flags, semantic_size = semantic_size); box.computed_pos = pos; - return box; + return box, interaction; } -push_rect :: proc(ctx: ^Context, label: string, background: bool = true, border: bool = true, axis: Axis = .Vertical, semantic_size: [2]SemanticSize = Fill) -> ^Box { +push_rect :: proc(ctx: ^Context, label: string, background: bool = true, border: bool = true, axis: Axis = .Vertical, semantic_size: [2]SemanticSize = Fill) -> (^Box, Interaction) { return push_box(ctx, label, {.DrawBackground if background else nil, .DrawBorder if border else nil}, axis, semantic_size = semantic_size); } -push_centered :: proc(ctx: ^Context, label: string, flags: bit_set[Flag], axis: Axis = .Horizontal, semantic_size: [2]SemanticSize = FitText) -> ^Box { - box: ^Box; - - push_parent(ctx, push_box(ctx, label, {}, semantic_size = { {.Fill,0}, semantic_size.y })) - { - defer pop_parent(ctx); - - spacer(ctx, "left spacer"); - halfway_centered := push_rect(ctx, "halfway centered", false, false, .Vertical, { {.Fill, 0}, {.Fill,0} }); - - push_parent(ctx, halfway_centered); - { - defer pop_parent(ctx); - - spacer(ctx, "top spacer"); - box = push_box(ctx, label, flags, axis, FitText); - spacer(ctx, "bottom spacer"); - } - spacer(ctx, "right spacer"); - } - - return box; -} - label :: proc(ctx: ^Context, label: string) -> Interaction { - box := push_box(ctx, label, {.DrawText}); + box, interaction := push_box(ctx, label, {.DrawText}); - return test_box(ctx, box); + return interaction; } button :: proc(ctx: ^Context, label: string) -> Interaction { @@ -679,47 +679,15 @@ button :: proc(ctx: ^Context, label: string) -> Interaction { } advanced_button :: proc(ctx: ^Context, label: string, flags: bit_set[Flag] = {.Clickable, .Hoverable, .DrawText, .DrawBorder, .DrawBackground}, semantic_size: [2]SemanticSize = FitText) -> Interaction { - box := push_box(ctx, label, flags, semantic_size = semantic_size); + box, interaction := push_box(ctx, label, flags, semantic_size = semantic_size); - return test_box(ctx, box); + return interaction; } custom :: proc(ctx: ^Context, label: string, draw_func: CustomDrawFunc, user_data: rawptr) -> Interaction { - box := push_box(ctx, label, {.CustomDrawFunc}, semantic_size = { make_semantic_size(.Fill), make_semantic_size(.Fill) }); + box, interaction := push_box(ctx, label, {.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); + return interaction; }