121 lines
3.1 KiB
Go
121 lines
3.1 KiB
Go
package layouts
|
|
|
|
import "math"
|
|
import "image"
|
|
import "git.tebibyte.media/tomo/tomo"
|
|
|
|
var _ tomo.Layout = new(Grid)
|
|
|
|
// Grid is a layout that arranges boxes in a grid formation with distinct rows
|
|
// and columns. It is great for creating forms.
|
|
type Grid struct {
|
|
xExpand []bool
|
|
yExpand []bool
|
|
}
|
|
|
|
// NewGrid creates a new grid layout. Rows and columns are specified as slices
|
|
// of booleans, where true means a row or column will expand and false means it
|
|
// will contract. Boxes are laid out left to right, then top to bottom. Boxes
|
|
// that go beyond the lengh of rows will be laid out according to columns, but
|
|
// they will not expand vertically.
|
|
func NewGrid (columns, rows []bool) *Grid {
|
|
this := &Grid {
|
|
xExpand: columns,
|
|
yExpand: rows,
|
|
}
|
|
return this
|
|
}
|
|
|
|
func (this *Grid) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
|
|
cols, rows := this.minimums(boxes)
|
|
size := image.Pt (
|
|
(len(cols) - 1) * hints.Gap.X,
|
|
(len(rows) - 1) * hints.Gap.Y)
|
|
for _, width := range cols { size.X += width }
|
|
for _, height := range rows { size.Y += height }
|
|
return size
|
|
}
|
|
|
|
func (this *Grid) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
|
|
xExpand := func (index int) bool {
|
|
return this.xExpand[index]
|
|
}
|
|
yExpand := func (index int) bool {
|
|
if index < len(this.yExpand) { return this.yExpand[index] }
|
|
return false
|
|
}
|
|
|
|
cols, rows := this.minimums(boxes)
|
|
expand(hints, cols, hints.Bounds.Dx(), xExpand)
|
|
expand(hints, rows, hints.Bounds.Dy(), yExpand)
|
|
|
|
position := hints.Bounds.Min
|
|
for index, box := range boxes {
|
|
col, row := index % len(cols), index / len(cols)
|
|
box.SetBounds(image.Rectangle {
|
|
Min: position,
|
|
Max: position.Add(image.Pt(cols[col], rows[row])),
|
|
})
|
|
if col == len(cols) - 1 {
|
|
position.X = hints.Bounds.Min.X
|
|
position.Y += rows[row] + hints.Gap.Y
|
|
} else {
|
|
position.X += cols[col] + hints.Gap.X
|
|
}
|
|
}
|
|
}
|
|
|
|
func (this *Grid) minimums (boxes []tomo.Box) ([]int, []int) {
|
|
nCols, nRows := this.dimensions(boxes)
|
|
cols, rows := make([]int, nCols), make([]int, nRows)
|
|
|
|
for index, box := range boxes {
|
|
col, row := index % len(cols), index / len(cols)
|
|
minimum := box.MinimumSize()
|
|
if cols[col] < minimum.X {
|
|
cols[col] = minimum.X
|
|
}
|
|
if rows[row] < minimum.Y {
|
|
rows[row] = minimum.Y
|
|
}
|
|
}
|
|
|
|
return cols, rows
|
|
}
|
|
|
|
func (this *Grid) dimensions (boxes []tomo.Box) (int, int) {
|
|
return len(this.xExpand), ceilDiv(len(boxes), len(this.xExpand))
|
|
}
|
|
|
|
func expand (hints tomo.LayoutHints, sizes []int, space int, expands func (int) bool) {
|
|
gaps := len(sizes) - 1
|
|
freeSpace := float64(space - hints.Gap.Y * gaps)
|
|
nExpanding := 0; for index, minimum := range sizes {
|
|
if expands(index) {
|
|
nExpanding ++
|
|
} else {
|
|
freeSpace -= float64(minimum)
|
|
}
|
|
}
|
|
expandingSize := freeSpace / float64(nExpanding)
|
|
for index := range sizes {
|
|
if expands(index) {
|
|
sizes[index] = int(expandingSize)
|
|
}
|
|
}
|
|
}
|
|
|
|
func ceilDiv (x, y int) int {
|
|
return int(math.Ceil(float64(x) / float64(y)))
|
|
}
|
|
|
|
func (this *Grid) RecommendedHeight (hints tomo.LayoutHints, boxes []tomo.Box, width int) int {
|
|
// TODO
|
|
return 0
|
|
}
|
|
|
|
func (this *Grid) RecommendedWidth (hints tomo.LayoutHints, boxes []tomo.Box, height int) int {
|
|
// TODO
|
|
return 0
|
|
}
|