mirror of
https://git.sr.ht/~eliasnaur/gio
synced 2026-07-01 07:35:40 +00:00
layout: simplify Flex API to a single Layout call
With the simplification of MacroOp, it is now possible to simplify
the Flex API to just a single Layout method, similar to List:
layout.Flex{}.Layout(gtx,
layout.Rigid(func() { ... }),
layout.Flexed(0.5, func() { ... }),
)
Signed-off-by: Elias Naur <mail@eliasnaur.com>
This commit is contained in:
Elias Naur
+12
-15
@@ -53,21 +53,18 @@ func ExampleFlex() {
|
||||
gtx := new(layout.Context)
|
||||
gtx.Reset(nil, image.Point{X: 100, Y: 100})
|
||||
|
||||
flex := layout.Flex{}
|
||||
|
||||
// Rigid 10x10 widget.
|
||||
child1 := flex.Rigid(gtx, func() {
|
||||
fmt.Printf("Rigid: %v\n", gtx.Constraints.Width)
|
||||
layoutWidget(gtx, 10, 10)
|
||||
})
|
||||
|
||||
// Child with 50% space allowance.
|
||||
child2 := flex.Flex(gtx, 0.5, func() {
|
||||
fmt.Printf("50%%: %v\n", gtx.Constraints.Width)
|
||||
layoutWidget(gtx, 10, 10)
|
||||
})
|
||||
|
||||
flex.Layout(gtx, child1, child2)
|
||||
layout.Flex{}.Layout(gtx,
|
||||
// Rigid 10x10 widget.
|
||||
layout.Rigid(func() {
|
||||
fmt.Printf("Rigid: %v\n", gtx.Constraints.Width)
|
||||
layoutWidget(gtx, 10, 10)
|
||||
}),
|
||||
// Child with 50% space allowance.
|
||||
layout.Flexed(0.5, func() {
|
||||
fmt.Printf("50%%: %v\n", gtx.Constraints.Width)
|
||||
layoutWidget(gtx, 10, 10)
|
||||
}),
|
||||
)
|
||||
|
||||
// Output:
|
||||
// Rigid: {0 100}
|
||||
|
||||
+77
-76
@@ -19,20 +19,16 @@ type Flex struct {
|
||||
Spacing Spacing
|
||||
// Alignment is the alignment in the cross axis.
|
||||
Alignment Alignment
|
||||
|
||||
size int
|
||||
rigidSize int
|
||||
// fraction is the rounding error from a Flex weighting.
|
||||
fraction float32
|
||||
|
||||
// Use an empty StackOp for tracking whether Rigid, Flex
|
||||
// is called in the same layout scope as Layout.
|
||||
begun bool
|
||||
stack op.StackOp
|
||||
}
|
||||
|
||||
// FlexChild is the layout result of a call End.
|
||||
// FlexChild is the descriptor for a Flex child.
|
||||
type FlexChild struct {
|
||||
flex bool
|
||||
weight float32
|
||||
|
||||
widget Widget
|
||||
|
||||
// Scratch space.
|
||||
macro op.MacroOp
|
||||
dims Dimensions
|
||||
}
|
||||
@@ -60,74 +56,82 @@ const (
|
||||
SpaceEvenly
|
||||
)
|
||||
|
||||
// Rigid lays out a widget with the main axis constrained to the range
|
||||
// from 0 to the remaining space.
|
||||
func (f *Flex) Rigid(gtx *Context, w Widget) FlexChild {
|
||||
f.begin(gtx.Ops)
|
||||
cs := gtx.Constraints
|
||||
mainc := axisMainConstraint(f.Axis, cs)
|
||||
mainMax := mainc.Max - f.size
|
||||
if mainMax < 0 {
|
||||
mainMax = 0
|
||||
// Rigid returns a Flex child with a maximal constraint of the
|
||||
// remaining space.
|
||||
func Rigid(widget Widget) FlexChild {
|
||||
return FlexChild{
|
||||
widget: widget,
|
||||
}
|
||||
cs = axisConstraints(f.Axis, Constraint{Max: mainMax}, axisCrossConstraint(f.Axis, cs))
|
||||
var m op.MacroOp
|
||||
m.Record(gtx.Ops)
|
||||
dims := ctxLayout(gtx, cs, w)
|
||||
m.Stop()
|
||||
f.rigidSize += axisMain(f.Axis, dims.Size)
|
||||
f.expand(dims)
|
||||
return FlexChild{m, dims}
|
||||
}
|
||||
|
||||
func (f *Flex) begin(ops *op.Ops) {
|
||||
if f.begun {
|
||||
return
|
||||
// Flexed returns a Flex child forced to take up a fraction of
|
||||
// the remaining space.
|
||||
func Flexed(weight float32, widget Widget) FlexChild {
|
||||
return FlexChild{
|
||||
flex: true,
|
||||
weight: weight,
|
||||
widget: widget,
|
||||
}
|
||||
f.stack.Push(ops)
|
||||
f.begun = true
|
||||
}
|
||||
|
||||
// Flex is like Rigid, where the main axis size is also constrained to a
|
||||
// fraction of the space not taken up by Rigid children.
|
||||
func (f *Flex) Flex(gtx *Context, weight float32, w Widget) FlexChild {
|
||||
f.begin(gtx.Ops)
|
||||
cs := gtx.Constraints
|
||||
mainc := axisMainConstraint(f.Axis, cs)
|
||||
var flexSize int
|
||||
if mainc.Max > f.size {
|
||||
flexSize = mainc.Max - f.rigidSize
|
||||
// Apply weight and add any leftover fraction from a
|
||||
// previous Flex.
|
||||
size := float32(flexSize)*weight + f.fraction
|
||||
flexSize = int(size + .5)
|
||||
f.fraction = size - float32(flexSize)
|
||||
if max := mainc.Max - f.size; flexSize > max {
|
||||
flexSize = max
|
||||
// Layout a list of children. The position of the children are
|
||||
// determined by the specified order, but Rigid children are laid out
|
||||
// before Flexed children.
|
||||
func (f Flex) Layout(gtx *Context, children ...FlexChild) {
|
||||
size := 0
|
||||
// Lay out Rigid children.
|
||||
for i, child := range children {
|
||||
if child.flex {
|
||||
continue
|
||||
}
|
||||
cs := gtx.Constraints
|
||||
mainc := axisMainConstraint(f.Axis, cs)
|
||||
mainMax := mainc.Max - size
|
||||
if mainMax < 0 {
|
||||
mainMax = 0
|
||||
}
|
||||
cs = axisConstraints(f.Axis, Constraint{Max: mainMax}, axisCrossConstraint(f.Axis, cs))
|
||||
var m op.MacroOp
|
||||
m.Record(gtx.Ops)
|
||||
dims := ctxLayout(gtx, cs, child.widget)
|
||||
m.Stop()
|
||||
sz := axisMain(f.Axis, dims.Size)
|
||||
size += sz
|
||||
children[i].macro = m
|
||||
children[i].dims = dims
|
||||
}
|
||||
submainc := Constraint{Min: flexSize, Max: flexSize}
|
||||
cs = axisConstraints(f.Axis, submainc, axisCrossConstraint(f.Axis, cs))
|
||||
var m op.MacroOp
|
||||
m.Record(gtx.Ops)
|
||||
dims := ctxLayout(gtx, cs, w)
|
||||
m.Stop()
|
||||
f.expand(dims)
|
||||
return FlexChild{m, dims}
|
||||
}
|
||||
|
||||
// End a child by specifying its dimensions. Pass the returned layout result
|
||||
// to Layout.
|
||||
func (f *Flex) expand(dims Dimensions) {
|
||||
sz := axisMain(f.Axis, dims.Size)
|
||||
f.size += sz
|
||||
}
|
||||
|
||||
// Layout a list of children. The order of the children determines their laid
|
||||
// out order.
|
||||
func (f *Flex) Layout(gtx *Context, children ...FlexChild) {
|
||||
if len(children) > 0 {
|
||||
f.stack.Pop()
|
||||
rigidSize := size
|
||||
// fraction is the rounding error from a Flex weighting.
|
||||
var fraction float32
|
||||
// Lay out Flexed children.
|
||||
for i, child := range children {
|
||||
if !child.flex {
|
||||
continue
|
||||
}
|
||||
cs := gtx.Constraints
|
||||
mainc := axisMainConstraint(f.Axis, cs)
|
||||
var flexSize int
|
||||
if mainc.Max > size {
|
||||
flexSize = mainc.Max - rigidSize
|
||||
// Apply weight and add any leftover fraction from a
|
||||
// previous Flexed.
|
||||
childSize := float32(flexSize)*child.weight + fraction
|
||||
flexSize = int(childSize + .5)
|
||||
fraction = childSize - float32(flexSize)
|
||||
if max := mainc.Max - size; flexSize > max {
|
||||
flexSize = max
|
||||
}
|
||||
}
|
||||
submainc := Constraint{Min: flexSize, Max: flexSize}
|
||||
cs = axisConstraints(f.Axis, submainc, axisCrossConstraint(f.Axis, cs))
|
||||
var m op.MacroOp
|
||||
m.Record(gtx.Ops)
|
||||
dims := ctxLayout(gtx, cs, child.widget)
|
||||
m.Stop()
|
||||
sz := axisMain(f.Axis, dims.Size)
|
||||
size += sz
|
||||
children[i].macro = m
|
||||
children[i].dims = dims
|
||||
}
|
||||
var maxCross int
|
||||
var maxBaseline int
|
||||
@@ -142,8 +146,8 @@ func (f *Flex) Layout(gtx *Context, children ...FlexChild) {
|
||||
cs := gtx.Constraints
|
||||
mainc := axisMainConstraint(f.Axis, cs)
|
||||
var space int
|
||||
if mainc.Min > f.size {
|
||||
space = mainc.Min - f.size
|
||||
if mainc.Min > size {
|
||||
space = mainc.Min - size
|
||||
}
|
||||
var mainSize int
|
||||
switch f.Spacing {
|
||||
@@ -199,9 +203,6 @@ func (f *Flex) Layout(gtx *Context, children ...FlexChild) {
|
||||
}
|
||||
sz := axisPoint(f.Axis, mainSize, maxCross)
|
||||
gtx.Dimensions = Dimensions{Size: sz, Baseline: sz.Y - maxBaseline}
|
||||
f.begun = false
|
||||
f.size = 0
|
||||
f.rigidSize = 0
|
||||
}
|
||||
|
||||
func axisPoint(a Axis, main, cross int) image.Point {
|
||||
|
||||
Reference in New Issue
Block a user