objects/layouts/rowcol.go

package layouts

import "image"
import "git.tebibyte.media/tomo/tomo"

var _ tomo.Layout = ContractVertical

// Row arranges boxes in a row. Boxes that share an index with a true value will
// expand, and others will contract.
type Row []bool

// Column arranges boxes in a column. Boxes that share an index with a true
// value will expand, and others will contract.
type Column []bool

func (column Column) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
	dot := image.Point { }
	for _, box := range boxes {
		minimum := box.MinimumSize()
		dot.Y += minimum.Y
		if dot.X < minimum.X {
			dot.X = minimum.X
		}
	}
	dot.Y += hints.Gap.Y * (len(boxes) - 1)
	return dot
}

func (row Row) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
	dot := image.Point { }
	for _, box := range boxes {
		minimum := box.MinimumSize()
		dot.X += minimum.X
		if dot.Y < minimum.Y {
			dot.Y = minimum.Y
		}
	}
	dot.X += hints.Gap.X * (len(boxes) - 1)
	return dot
}

func (column Column) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
	expands := func (index int) bool {
		if index >= len(column) { return false }
		return column[index]
	}

	// determine expanding box size
	expandingSize := 0.0
	if !hints.OverflowY {
		gaps       := len(boxes) - 1
		freeSpace  := float64(hints.Bounds.Dy() - hints.Gap.Y * gaps)
		nExpanding := 0; for index, box := range boxes {
			if expands(index) {
				nExpanding ++
			} else {
				freeSpace -= float64(box.MinimumSize().Y)
			}
		}
		expandingSize = freeSpace / float64(nExpanding)
	}

	// determine width
	width := 0
	if hints.OverflowX {
		for _, box := range boxes {
			minimum := box.MinimumSize()
			if width < minimum.X { width = minimum.X }
		}
	} else {
		width = hints.Bounds.Dx()
	}

	// arrange
	dot := hints.Bounds.Min
	for index, box := range boxes {
		if index > 0 { dot.Y += hints.Gap.Y }

		// determine height
		height := box.MinimumSize().Y
		if hints.OverflowY {
			if box, ok := box.(tomo.ContentBox); ok {
				height = box.RecommendedHeight(width)
			}
		} else {
			if expands(index) {
				height = int(expandingSize)
			}
		}

		// set bounds
		box.SetBounds(image.Rectangle {
			Min: dot,
			Max: dot.Add(image.Pt(width, height)),
		})
		dot.Y += height
	}
	
	height := dot.Y - hints.Bounds.Min.Y
	offset := 0
	
	switch hints.AlignY {
	case tomo.AlignMiddle:
		offset = (hints.Bounds.Dy() - height) / 2
	case tomo.AlignEnd:
		offset = hints.Bounds.Dy() - height
	}
	for _, box := range boxes {
		box.SetBounds(box.Bounds().Add(image.Pt(0, offset)))
	}
}

func (row Row) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
	expands := func (index int) bool {
		if index >= len(row) { return false }
		return row[index]
	}

	// determine expanding box size
	expandingSize := 0.0
	if !hints.OverflowY {
		gaps       := len(boxes) - 1
		freeSpace  := float64(hints.Bounds.Dx() - hints.Gap.X * gaps)
		nExpanding := 0; for index, box := range boxes {
			if expands(index) {
				nExpanding ++
			} else {
				freeSpace -= float64(box.MinimumSize().X)
			}
		}
		expandingSize = freeSpace / float64(nExpanding)
	}

	// determine height
	height := 0
	if hints.OverflowY {
		for _, box := range boxes {
			minimum := box.MinimumSize()
			if height < minimum.Y { height = minimum.Y }
		}
	} else {
		height = hints.Bounds.Dy()
	}

	// arrange
	dot := hints.Bounds.Min
	for index, box := range boxes {
		if index > 0 { dot.X += hints.Gap.X }

		// determine width
		width := box.MinimumSize().X
		if hints.OverflowY {
			if box, ok := box.(tomo.ContentBox); ok {
				width = box.RecommendedHeight(height)
			}
		} else {
			if expands(index) {
				width = int(expandingSize)
			}
		}

		// set bounds
		box.SetBounds(image.Rectangle {
			Min: dot,
			Max: dot.Add(image.Pt(width, height)),
		})
		dot.X += width
	}

	width  := dot.X - hints.Bounds.Min.X
	offset := 0
	
	switch hints.AlignX {
	case tomo.AlignMiddle:
		offset = (hints.Bounds.Dx() - width) / 2
	case tomo.AlignEnd:
		offset = hints.Bounds.Dx() - width
	}
	for _, box := range boxes {
		box.SetBounds(box.Bounds().Add(image.Pt(offset, 0)))
	}
}

func (column Column) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
	height := 0
	for _, box := range boxes {
		if box, ok := box.(tomo.ContentBox); ok {
			height += box.RecommendedHeight(width) 
		} else {
			height += box.MinimumSize().Y
		}
	}
	height += hints.Gap.Y * (len(boxes) - 1)
	return height
}

func (row Row) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
	height := 0
	for _, box := range boxes {
		minimum   := box.MinimumSize()
		boxHeight := 0
		if box, ok := box.(tomo.ContentBox); ok {
			boxHeight = box.RecommendedHeight(minimum.X)
		} else {
			boxHeight = minimum.Y
		}
		if boxHeight > height { height = boxHeight }
	}
	return height
}

func (column Column) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
	width := 0
	for _, box := range boxes {
		minimum   := box.MinimumSize()
		boxWidth := 0
		if box, ok := box.(tomo.ContentBox); ok {
			boxWidth = box.RecommendedHeight(minimum.Y)
		} else {
			boxWidth = minimum.X
		}
		if boxWidth > width { width = boxWidth }
	}
	return width
}

func (row Row) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
	width := 0
	for _, box := range boxes {
		if box, ok := box.(tomo.ContentBox); ok {
			width += box.RecommendedWidth(height)
		} else {
			width += box.MinimumSize().X
		}
	}
	width += hints.Gap.X * (len(boxes) - 1)
	return width
}