Element size resolver

example/main.odin

@@ -42,6 +42,7 @@ main :: proc() {
 				config = {
 					color = cast([4]u8)rl.GREEN,
 					label = "",
+					margin = {0.0, 4.0},
 				},
 			)
 			ui.container_end()

ui.odin

@@ -3,16 +3,16 @@ package synthas_ui
 v2 :: [2]f32
 rect2 :: struct {x, y, width, height: f32}
 
-@private rect_get_tl :: #force_inline proc(rect: rect2) -> v2 {return {rect.x, rect.y}}
+rect_get_tl :: #force_inline proc(rect: rect2) -> v2 {return {rect.x, rect.y}}
-@private rect_get_tr :: #force_inline proc(rect: rect2) -> v2 {return {rect.x + rect.width, rect.y}}
+rect_get_tr :: #force_inline proc(rect: rect2) -> v2 {return {rect.x + rect.width, rect.y}}
-@private rect_get_br :: #force_inline proc(rect: rect2) -> v2 {return {rect.x + rect.width, rect.y + rect.height}}
+rect_get_br :: #force_inline proc(rect: rect2) -> v2 {return {rect.x + rect.width, rect.y + rect.height}}
-@private rect_get_bl :: #force_inline proc(rect: rect2) -> v2 {return {rect.x, rect.y + rect.height}}
+rect_get_bl :: #force_inline proc(rect: rect2) -> v2 {return {rect.x, rect.y + rect.height}}
 
-@private rect_grow :: proc(rect: rect2, amount: v2) -> rect2 {
+rect_grow :: proc(rect: rect2, amount: v2) -> rect2 {
 	return {rect.x - amount.x / 2.0, rect.y - amount.y / 2.0, rect.width + amount.x, rect.height + amount.y}
 }
 
-@private ctx: ^Context
+ctx: ^Context
 
 Context :: struct {
 	origin: v2,
@@ -22,13 +22,7 @@ Context :: struct {
 	same_line: bool,
 }
 
-@private CONTAINER_STACK_SIZE :: 16
+CONTAINER_STACK_SIZE :: 16
-
-init :: proc(state: ^Context, element_capacity: int, allocator := context.allocator) {
-	state.containers = make(type_of(state.containers), 0, CONTAINER_STACK_SIZE, allocator)
-	state.container_last_element = make(type_of(state.container_last_element), 0, CONTAINER_STACK_SIZE, allocator)
-	state.elements = make(type_of(state.elements), 0, element_capacity, allocator)
-}
 
 Element :: struct {
 	area: rect2,
@@ -63,6 +57,12 @@ Dimensions :: struct {
 
 Axis :: enum {X, Y}
 
+init :: proc(state: ^Context, element_capacity: int, allocator := context.allocator) {
+	state.containers = make(type_of(state.containers), 0, CONTAINER_STACK_SIZE, allocator)
+	state.container_last_element = make(type_of(state.container_last_element), 0, CONTAINER_STACK_SIZE, allocator)
+	state.elements = make(type_of(state.elements), 0, element_capacity, allocator)
+}
+
 start :: proc(ui_context: ^Context, origin: v2, size: v2) {
 	ctx = ui_context
 	ctx.origin = origin
@@ -92,59 +92,64 @@ same_line :: proc() {
 	ctx.same_line = true
 }
 
-element_get_outer_area :: proc(element: Element) -> rect2 {
-	return rect_grow(element.area, element.margin * 2.0)
-}
-
-element_get_inner_area :: proc(element: Element) -> rect2 {
-	return rect_grow(element.area, -element.padding * 2.0)
-}
-
 container_begin :: proc(dimensions: Dimensions, config: ElementConfiguration) {
-	position: v2
+	area := _resolve_element_area(dimensions, config.margin)
-	if len(ctx.containers) == 0 {
+	element := Element{area = area, config = config, type = .Container}
-		position = ctx.origin + config.margin
-	} else {
-		if alignment_element := _element_container_previous(); alignment_element != nil {
-			position = rect_get_tl(element_get_inner_area(alignment_element^)) + config.margin
-		} else {
-			position = rect_get_tl(element_get_inner_area(_element_previous()^)) + config.margin
-		}
-	}
-	size := _resolve_dimensions(dimensions) - config.margin * 2.0
-	element := Element{area = rect2{**position, **size}, config = config, type = .Container}
 	_append_element(element)
 	container_index := len(ctx.elements) - 1
 	append(&ctx.containers, container_index)
 	append(&ctx.container_last_element, -1)
 }
 
-@private _append_element :: proc(element: Element) {
-	append(&ctx.elements, element)
-	ctx.container_last_element[len(ctx.containers) - 1] = len(ctx.elements) - 1
-}
-
 container_end :: proc() {
 	container := ctx.elements[pop(&ctx.containers)]
 	pop(&ctx.container_last_element)
 	// TODO: Set flex
-	outer := element_get_outer_area(container)
+	outer := _get_element_outer_area(container)
 }
 
 button :: proc(dimensions: Dimensions) {
+
 }
 
-_resolve_dimensions :: proc(dimensions: Dimensions) -> v2 {
+_append_element :: proc(element: Element) {
-	return {_resolve_size(dimensions.width, .X), _resolve_size(dimensions.height, .Y)}
+	append(&ctx.elements, element)
+	ctx.container_last_element[len(ctx.containers) - 1] = len(ctx.elements) - 1
 }
 
-_resolve_size :: proc(size: Size, axis: Axis) -> f32 {
+_get_element_outer_area :: proc(element: Element) -> rect2 {
+	return rect_grow(element.area, element.margin * 2.0)
+}
+
+_get_element_inner_area :: proc(element: Element) -> rect2 {
+	return rect_grow(element.area, -element.padding * 2.0)
+}
+
+_resolve_element_area :: proc(dimensions: Dimensions, margin: v2) -> rect2 {
+	outer_position := _resolve_element_outer_position()
+	outer_size := _resolve_element_outer_size(dimensions)
+	outer_area := rect2{**outer_position, **outer_size}
+	return rect_grow(outer_area, -margin * 2.0)
+}
+
+_resolve_element_outer_position :: proc() -> v2 {
+	if alignment_element := _element_container_previous(); alignment_element != nil {
+		return rect_get_bl(_get_element_inner_area(alignment_element^))
+	}
+	return rect_get_tl(_get_element_inner_area(_element_previous()^))
+}
+
+_resolve_element_outer_size :: proc(dimensions: Dimensions) -> v2 {
+	return {_resolve_elemment_outer_size_axis(dimensions.width, .X), _resolve_elemment_outer_size_axis(dimensions.height, .Y)}
+}
+
+_resolve_elemment_outer_size_axis :: proc(size: Size, axis: Axis) -> f32 {
 	switch value in size {
 	case Size_Pixels:
 		return cast(f32)value
 	case Size_Percentage:
 		if container := _container_current(); container != nil {
-			inner := element_get_inner_area(container^)
+			inner := _get_element_inner_area(container^)
 			container_size := inner.width if axis == .X else inner.height
 			return container_size * cast(f32)value
 		} else {