This repository has been archived on 2023-08-08. You can view files and clone it, but cannot push or open issues or pull requests.
tomo-old/layouts/basic/dialog.go

188 lines
4.6 KiB
Go
Raw Normal View History

2023-02-01 23:47:31 -07:00
package basicLayouts
2023-01-10 23:56:05 -07:00
import "image"
2023-02-01 23:47:31 -07:00
import "git.tebibyte.media/sashakoshka/tomo/layouts"
import "git.tebibyte.media/sashakoshka/tomo/elements"
2023-01-10 23:56:05 -07:00
// Dialog arranges elements in the form of a dialog box. The first element is
// positioned above as the main focus of the dialog, and is set to expand
// regardless of whether it is expanding or not. The remaining elements are
// arranged at the bottom in a row called the control row, which is aligned to
// the right, the last element being the rightmost one.
2023-01-10 23:56:05 -07:00
type Dialog struct {
// If Gap is true, a gap will be placed between each element.
Gap bool
// If Pad is true, there will be padding running along the inside of the
// layout's border.
Pad bool
}
2023-01-31 16:39:17 -07:00
// Arrange arranges a list of entries into a dialog.
2023-02-01 23:47:31 -07:00
func (layout Dialog) Arrange (
entries []layouts.LayoutEntry,
margin int,
bounds image.Rectangle,
) {
if layout.Pad { bounds = bounds.Inset(margin) }
2023-01-31 16:39:17 -07:00
2023-01-10 23:56:05 -07:00
controlRowWidth, controlRowHeight := 0, 0
if len(entries) > 1 {
controlRowWidth,
2023-02-01 23:47:31 -07:00
controlRowHeight = layout.minimumSizeOfControlRow (
entries[1:], margin)
2023-01-10 23:56:05 -07:00
}
if len(entries) > 0 {
2023-01-31 16:57:29 -07:00
main := entries[0]
main.Bounds.Min = bounds.Min
2023-01-31 16:39:17 -07:00
mainHeight := bounds.Dy() - controlRowHeight
2023-01-10 23:56:05 -07:00
if layout.Gap {
2023-02-01 23:47:31 -07:00
mainHeight -= margin
2023-01-10 23:56:05 -07:00
}
2023-01-31 16:57:29 -07:00
main.Bounds.Max = main.Bounds.Min.Add(image.Pt(bounds.Dx(), mainHeight))
entries[0] = main
2023-01-10 23:56:05 -07:00
}
if len(entries) > 1 {
2023-01-31 16:39:17 -07:00
freeSpace := bounds.Dx()
2023-01-10 23:56:05 -07:00
expandingElements := 0
// count the number of expanding elements and the amount of free
// space for them to collectively occupy
for index, entry := range entries[1:] {
if entry.Expand {
expandingElements ++
} else {
entryMinWidth, _ := entry.MinimumSize()
freeSpace -= entryMinWidth
}
if index > 0 && layout.Gap {
2023-02-01 23:47:31 -07:00
freeSpace -= margin
2023-01-10 23:56:05 -07:00
}
}
expandingElementWidth := 0
if expandingElements > 0 {
expandingElementWidth = freeSpace / expandingElements
}
// determine starting position and dimensions for control row
2023-01-31 16:57:29 -07:00
dot := image.Pt(bounds.Min.X, bounds.Max.Y - controlRowHeight)
2023-01-10 23:56:05 -07:00
if expandingElements == 0 {
2023-01-31 16:57:29 -07:00
dot.X = bounds.Max.X - controlRowWidth
2023-01-10 23:56:05 -07:00
}
// set the size and position of each element in the control row
for index, entry := range entries[1:] {
2023-02-01 23:47:31 -07:00
if index > 0 && layout.Gap { dot.X += margin }
2023-01-10 23:56:05 -07:00
2023-01-31 16:57:29 -07:00
entry.Bounds.Min = dot
2023-01-10 23:56:05 -07:00
entryWidth := 0
if entry.Expand {
entryWidth = expandingElementWidth
} else {
entryWidth, _ = entry.MinimumSize()
}
2023-01-31 16:57:29 -07:00
dot.X += entryWidth
entryBounds := entry.Bounds
2023-01-10 23:56:05 -07:00
if entryBounds.Dy() != controlRowHeight ||
entryBounds.Dx() != entryWidth {
2023-01-31 16:57:29 -07:00
entry.Bounds.Max = entryBounds.Min.Add (
image.Pt(entryWidth, controlRowHeight))
2023-01-10 23:56:05 -07:00
}
2023-01-31 16:57:29 -07:00
entries[index + 1] = entry
2023-01-10 23:56:05 -07:00
}
}
}
// MinimumSize returns the minimum width and height that will be needed to
// arrange the given list of entries.
func (layout Dialog) MinimumSize (
2023-02-01 23:47:31 -07:00
entries []layouts.LayoutEntry,
margin int,
) (
width, height int,
) {
2023-01-10 23:56:05 -07:00
if len(entries) > 0 {
mainChildHeight := 0
width, mainChildHeight = entries[0].MinimumSize()
height += mainChildHeight
}
if len(entries) > 1 {
2023-02-01 23:47:31 -07:00
if layout.Gap { height += margin }
2023-01-10 23:56:05 -07:00
additionalWidth,
2023-02-01 23:47:31 -07:00
additionalHeight := layout.minimumSizeOfControlRow (
entries[1:], margin)
2023-01-10 23:56:05 -07:00
height += additionalHeight
if additionalWidth > width {
width = additionalWidth
}
}
if layout.Pad {
2023-02-01 23:47:31 -07:00
width += margin * 2
height += margin * 2
2023-01-10 23:56:05 -07:00
}
return
}
2023-01-19 14:54:49 -07:00
// FlexibleHeightFor Returns the minimum height the layout needs to lay out the
// specified elements at the given width, taking into account flexible elements.
func (layout Dialog) FlexibleHeightFor (
2023-02-01 23:47:31 -07:00
entries []layouts.LayoutEntry,
margin int,
2023-01-17 13:55:16 -07:00
width int,
) (
height int,
) {
if layout.Pad {
2023-02-01 23:47:31 -07:00
width -= margin * 2
2023-01-17 13:55:16 -07:00
}
if len(entries) > 0 {
mainChildHeight := 0
2023-02-01 23:47:31 -07:00
if child, flexible := entries[0].Element.(elements.Flexible); flexible {
2023-01-19 14:54:49 -07:00
mainChildHeight = child.FlexibleHeightFor(width)
2023-01-17 13:55:16 -07:00
} else {
_, mainChildHeight = entries[0].MinimumSize()
}
height += mainChildHeight
}
if len(entries) > 1 {
2023-02-01 23:47:31 -07:00
if layout.Gap { height += margin }
_, additionalHeight := layout.minimumSizeOfControlRow (
entries[1:], margin)
2023-01-17 13:55:16 -07:00
height += additionalHeight
}
if layout.Pad {
2023-02-01 23:47:31 -07:00
height += margin * 2
2023-01-17 13:55:16 -07:00
}
return
}
// TODO: possibly flatten this method to account for flexible elements within
// the control row.
func (layout Dialog) minimumSizeOfControlRow (
2023-02-01 23:47:31 -07:00
entries []layouts.LayoutEntry,
margin int,
2023-01-10 23:56:05 -07:00
) (
width, height int,
) {
for index, entry := range entries {
entryWidth, entryHeight := entry.MinimumSize()
if entryHeight > height {
height = entryHeight
}
width += entryWidth
if layout.Gap && index > 0 {
2023-02-01 23:47:31 -07:00
width += margin
2023-01-10 23:56:05 -07:00
}
}
return
}