mirror of
https://git.sr.ht/~eliasnaur/gio
synced 2026-07-01 15:45:38 +00:00
Elias Naur
ce9bcee62b
Context keeps the current Constraints and Dimensions so the layout
function scopes don't have to.
With
ctx := new(layout.Context)
a label with margins and alignment goes from
return al.Layout(ops, cs, func(cs layout.Constraints) layout.Dimensions {
in := layout.Inset{...}
return in.Layout(c, ops, cs, func(cs layout.Constraints) layout.Dimensions {
return text.Label{...}.Layout(ops, cs)
})
})
to
al.Layout(ops, ctx, func() {
in := layout.Inset{...}
in.Layout(c, ops, ctx, func() {
text.Label{...}.Layout(ops, ctx)
})
})
It was a difficult trade-off between the verbose functional approach
and the shorter but more complex Context.
Signed-off-by: Elias Naur <mail@eliasnaur.com>
119 lines
2.5 KiB
Go
119 lines
2.5 KiB
Go
// SPDX-License-Identifier: Unlicense OR MIT
|
|
|
|
package layout
|
|
|
|
import (
|
|
"image"
|
|
|
|
"gioui.org/ui"
|
|
)
|
|
|
|
// Stack lays out child elements on top of each other,
|
|
// according to an alignment direction.
|
|
type Stack struct {
|
|
// Alignment is the direction to align children
|
|
// smaller than the available space.
|
|
Alignment Direction
|
|
|
|
macro ui.MacroOp
|
|
ops *ui.Ops
|
|
constrained bool
|
|
ctx *Context
|
|
maxSZ image.Point
|
|
baseline int
|
|
}
|
|
|
|
// StackChild is the layout result of a call to End.
|
|
type StackChild struct {
|
|
macro ui.MacroOp
|
|
dims Dimensions
|
|
}
|
|
|
|
// Init a stack before calling Rigid or Expand.
|
|
func (s *Stack) Init(ops *ui.Ops, ctx *Context) *Stack {
|
|
s.ops = ops
|
|
s.ctx = ctx
|
|
s.constrained = true
|
|
s.maxSZ = image.Point{}
|
|
s.baseline = 0
|
|
return s
|
|
}
|
|
|
|
func (s *Stack) begin() {
|
|
if !s.constrained {
|
|
panic("must Init before adding a child")
|
|
}
|
|
s.macro.Record(s.ops)
|
|
}
|
|
|
|
// Rigid lays out a widget with the same constraints that were
|
|
// passed to Init.
|
|
func (s *Stack) Rigid(w Widget) StackChild {
|
|
s.begin()
|
|
dims := s.ctx.Layout(s.ctx.Constraints, w)
|
|
return s.end(dims)
|
|
}
|
|
|
|
// Expand lays out a widget with constraints that exactly match
|
|
// the biggest child previously added.
|
|
func (s *Stack) Expand(w Widget) StackChild {
|
|
s.begin()
|
|
cs := Constraints{
|
|
Width: Constraint{Min: s.maxSZ.X, Max: s.maxSZ.X},
|
|
Height: Constraint{Min: s.maxSZ.Y, Max: s.maxSZ.Y},
|
|
}
|
|
dims := s.ctx.Layout(cs, w)
|
|
return s.end(dims)
|
|
}
|
|
|
|
// End a child by specifying its dimensions.
|
|
func (s *Stack) end(dims Dimensions) StackChild {
|
|
s.macro.Stop()
|
|
if w := dims.Size.X; w > s.maxSZ.X {
|
|
s.maxSZ.X = w
|
|
}
|
|
if h := dims.Size.Y; h > s.maxSZ.Y {
|
|
s.maxSZ.Y = h
|
|
}
|
|
if s.baseline == 0 {
|
|
if b := dims.Baseline; b != dims.Size.Y {
|
|
s.baseline = b
|
|
}
|
|
}
|
|
return StackChild{s.macro, dims}
|
|
}
|
|
|
|
// Layout a list of children. The order of the children determines their laid
|
|
// out order.
|
|
func (s *Stack) Layout(children ...StackChild) {
|
|
for _, ch := range children {
|
|
sz := ch.dims.Size
|
|
var p image.Point
|
|
switch s.Alignment {
|
|
case N, S, Center:
|
|
p.X = (s.maxSZ.X - sz.X) / 2
|
|
case NE, SE, E:
|
|
p.X = s.maxSZ.X - sz.X
|
|
}
|
|
switch s.Alignment {
|
|
case W, Center, E:
|
|
p.Y = (s.maxSZ.Y - sz.Y) / 2
|
|
case SW, S, SE:
|
|
p.Y = s.maxSZ.Y - sz.Y
|
|
}
|
|
var stack ui.StackOp
|
|
stack.Push(s.ops)
|
|
ui.TransformOp{}.Offset(toPointF(p)).Add(s.ops)
|
|
ch.macro.Add(s.ops)
|
|
stack.Pop()
|
|
}
|
|
b := s.baseline
|
|
if b == 0 {
|
|
b = s.maxSZ.Y
|
|
}
|
|
s.ctx.Dimensions = Dimensions{
|
|
Size: s.maxSZ,
|
|
Baseline: b,
|
|
}
|
|
}
|