Separeted grow height and width, but still bugged

1 files changed, 45 insertions, 44 deletions

diff --git a/src/tafl/tafl.odin b/src/tafl/tafl.odin
index e17a5b7..1088823 100644
--- a/src/tafl/tafl.odin
+++ b/src/tafl/tafl.odin
@@ -86,9 +86,13 @@ __tafl_close :: proc(tafl : ^Tafl) {
 	total_child_gap := max(tafl.children.len - 1, 0) * tafl.child_gap
 	switch tafl.layout {
 		case .LEFT_TO_RIGHT:
-			tafl.width += total_child_gap
+			if tafl.sizing.width.type == .FIT {
+				tafl.width += total_child_gap
+			}
 		case .TOP_TO_BOTTOM:
-			tafl.height += total_child_gap
+			if tafl.sizing.height.type == .FIT {
+				tafl.height += total_child_gap
+			}
 	}
 	
 	parent : ^Tafl = tafl.parent
@@ -144,65 +148,58 @@ __tafl_close :: proc(tafl : ^Tafl) {
 
 // TODO: Make sure the fit sizing mode actually works, and make min and max sizes work with it
 // TODO: Support multiple growing tǫfl
-grow_children :: proc(parent : ^Tafl) {
+
+grow_children_width :: proc(parent : ^Tafl) {
+	parent_width : int = parent.width
+	padding_width : int = parent.padding.left + parent.padding.right
 	
-	// X is the layout direction, Y is across the layout direction.
-	// So that LEFT_TO_RIGHT means X = width,
-	//     and TOP_TO_BOTTOM means X = height
+	remaining_width : int = parent_width - padding_width
 	
-	parent_x : ^int
-	parent_y : ^int
-	padding_x : int
-	padding_y : int
 	switch parent.layout {
 		case .LEFT_TO_RIGHT:
-			parent_x = &parent.width
-			parent_y = &parent.height
-			padding_x = parent.padding.left + parent.padding.right
-			padding_y = parent.padding.top  + parent.padding.bottom
+			for child in children_of(parent) {
+				remaining_width -= child.width
+			}
 		case .TOP_TO_BOTTOM:
-			parent_x = &parent.height
-			parent_y = &parent.width
-			padding_x = parent.padding.top  + parent.padding.bottom
-			padding_y = parent.padding.left + parent.padding.right
+			for child in children_of(parent) {
+				remaining_width = min(child.width, parent.sizing.width.max)
+			}
 	}
-	remaining_x : int = parent_x^ - padding_x
-	remaining_y : int = parent_y^ - padding_y
 	
-	for child in children_of(parent) {
-		switch parent.layout {
-			case .LEFT_TO_RIGHT:
-				remaining_x -= child.width
-			case .TOP_TO_BOTTOM:
-				remaining_x -= child.height
+	remaining_width -= max(parent.children.len - 1, 0) * parent.child_gap
+	
+	for child_again in children_of(parent) {
+		if child_again.sizing.width.type == .GROW {
+			child_again.width += remaining_width
 		}
 	}
-	//                                                              THE FUCK?
-	//                                                                  v
-	remaining_x -= max(parent.children.len - 1, 0) * parent.child_gap
+}
+grow_children_height :: proc(parent : ^Tafl) {
+	parent_height : int = parent.height
+	padding_height : int = parent.padding.top + parent.padding.bottom
+	
+	remaining_height : int = parent_height - padding_height
 	
 	switch parent.layout {
 		case .LEFT_TO_RIGHT:
-			for child_again in children_of(parent) {
-				if child_again.sizing.width.type == .GROW {
-					child_again.width += remaining_x
-				}
-				if child_again.sizing.height.type == .GROW {
-					child_again.height += remaining_y - child_again.height
-				}
+			for child in children_of(parent) {
+				remaining_height = min(child.height, parent.sizing.height.max)
 			}
+			remaining_height -= max(parent.children.len - 1, 0) * parent.child_gap
 		case .TOP_TO_BOTTOM:
-			for child_again in children_of(parent) {
-				if child_again.sizing.width.type == .GROW {
-					child_again.width += remaining_y - child_again.width
-				}
-				if child_again.sizing.height.type == .GROW {
-					child_again.height += remaining_x
-				}
+			for child in children_of(parent) {
+				remaining_height -= child.height
 			}
 	}
+	
+	for child_again in children_of(parent) {
+		if child_again.sizing.height.type == .GROW {
+			child_again.height += remaining_height
+		}
+	}
 }
 
+
 position_children :: proc(parent: ^Tafl) {
 	switch parent.layout {
 		case .LEFT_TO_RIGHT:
@@ -252,7 +249,11 @@ render :: proc() {
 grow_pass :: proc() {
 	#reverse for tafl_index in child_index_buffer[:child_index_buffer_len] {
 		tafl := &tafl_elements[tafl_index]
-		grow_children(tafl)
+		grow_children_width(tafl)
+	}
+	#reverse for tafl_index in child_index_buffer[:child_index_buffer_len] {
+		tafl := &tafl_elements[tafl_index]
+		grow_children_height(tafl)
 	}
 }