layout

type Align uint8

type Anchor uint8

type Axis uint8

type Cross struct {
	// Size is how many cells across the other axis the content takes. Zero, and
	// anything larger than the region, is all of it.
	Size int
	// Align is where it sits when it is less than all of it.
	Align Align
}

type Flow struct {
	Axis Axis
	// Gap is how many cells go between one slot and the next.
	//
	// It is reserved for every join, including the ones beside a slot that ended up
	// with no room. A gap that appeared and disappeared with its neighbour's contents
	// would move every column after it whenever a value happened to be empty, and a
	// table whose columns shift as its rows change is worse than one with a wider
	// margin than it needed.
	Gap int
}

type Inset struct{ Top, Right, Bottom, Left int }

type MeasureFunc func(across int) int

type Measurer interface {
	Measure(across int) int
}

type Placement struct {
	Anchor Anchor
	// Width and Height are the layer's size in cells. Zero means as large as the
	// space allows, less Margin.
	Width, Height int
	// Margin is kept clear between the layer and the edges of the space, so a layer
	// anchored to a corner does not look stuck to it.
	Margin int
}

type Size struct{ W, H int }

type Sizing struct {
	// Fixed is an exact number of rows or columns. It wins over everything else.
	Fixed int
	// Part and Whole are a share of the whole division: Part 1 of Whole 2 is half of
	// it, whatever else is being divided and whatever those others ask for. The whole
	// is what there is to divide, which is the region less the gaps in it.
	//
	// It is not [Flex] and cannot be written as one. A share of what is left changes
	// when anything beside it changes, which is what makes it right for panes that
	// divide the slack and wrong for "this pane is half the screen" — a sentence a
	// caller means literally, and one whose answer must not move when a status bar
	// appears above it.
	Part, Whole int
	// Flex is a share of what is left after the fixed, measured and part slots have
	// taken theirs. Two slots with flex 1 and 2 split the remainder one third to two
	// thirds.
	Flex int
	// Measured asks the slot's [Measurer] how much it wants.
	Measured bool
	// Min is a floor on a flex or measured slot, so a pane cannot be squeezed into a
	// size where it shows nothing useful. It is honoured while there is room for it:
	// several floors can add up to more than the space there is.
	Min int
	// Max caps a measured slot, so content that grew without bound does not take the
	// whole region.
	Max int
}

type Slot struct {
	Size Sizing
	// Of is asked how much of the divided axis this slot wants, and is only
	// consulted when Size says the slot is measured. A measured slot with nothing to
	// ask gets its floor, which is zero unless one was set.
	Of Measurer
	// Cross is where the slot's content sits across the other axis. The zero value
	// fills it, which is what a band across a pane means and what every slot did
	// before there was a way to say otherwise.
	Cross Cross
}