~eliasnaur/gio

ref: 320579814f859836c2fcf141ea2ade1b5a1b01b4 gio/ui/layout/layout.go -rw-r--r-- 4.0 KiB
32057981Elias Naur ui: rename Config.Val to Pixels 2 years ago
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
// SPDX-License-Identifier: Unlicense OR MIT

package layout

import (
	"image"

	"gioui.org/ui"
)

type Constraints struct {
	Width  Constraint
	Height Constraint
}

type Constraint struct {
	Min, Max int
}

type Dimens struct {
	Size     image.Point
	Baseline int
}

type Axis uint8

const (
	Horizontal Axis = iota
	Vertical
)

func (c Constraint) Constrain(v int) int {
	if v < c.Min {
		return c.Min
	} else if v > c.Max {
		return c.Max
	}
	return v
}

func (c Constraints) Constrain(p image.Point) image.Point {
	return image.Point{X: c.Width.Constrain(p.X), Y: c.Height.Constrain(p.Y)}
}

func (c Constraints) Expand() Constraints {
	return Constraints{Width: c.Width.Expand(), Height: c.Height.Expand()}
}

func (c Constraint) Expand() Constraint {
	return Constraint{Min: c.Max, Max: c.Max}
}

func (c Constraints) Loose() Constraints {
	return Constraints{Width: c.Width.Loose(), Height: c.Height.Loose()}
}

func (c Constraints) Exact(width, height int) Constraints {
	if height != 0 {
		if c.Height.Min < height {
			c.Height.Min = height
		}
		if height < c.Height.Max {
			c.Height.Max = height
		}
	}
	if width != 0 {
		if c.Width.Min < width {
			c.Width.Min = width
		}
		if width < c.Width.Max {
			c.Width.Max = width
		}
	}
	return c
}

func (c Constraint) Loose() Constraint {
	return Constraint{Max: c.Max}
}

// ExactConstraints returns the rigid constraints that represents the
// given dimensions.
func ExactConstraints(size image.Point) Constraints {
	return Constraints{
		Width:  Constraint{Min: size.X, Max: size.X},
		Height: Constraint{Min: size.Y, Max: size.Y},
	}
}

type Insets struct {
	Top, Right, Bottom, Left ui.Value

	top, right, bottom, left int
	ops                      *ui.Ops
	begun                    bool
	cs                       Constraints
}

func (in *Insets) Begin(c *ui.Config, ops *ui.Ops, cs Constraints) Constraints {
	if in.begun {
		panic("must End before Begin")
	}
	in.top = c.Pixels(in.Top)
	in.right = c.Pixels(in.Right)
	in.bottom = c.Pixels(in.Bottom)
	in.left = c.Pixels(in.Left)
	in.begun = true
	in.ops = ops
	in.cs = cs
	mcs := cs
	if mcs.Width.Max != ui.Inf {
		mcs.Width.Min -= in.left + in.right
		mcs.Width.Max -= in.left + in.right
		if mcs.Width.Min < 0 {
			mcs.Width.Min = 0
		}
		if mcs.Width.Max < mcs.Width.Min {
			mcs.Width.Max = mcs.Width.Min
		}
	}
	if mcs.Height.Max != ui.Inf {
		mcs.Height.Min -= in.top + in.bottom
		mcs.Height.Max -= in.top + in.bottom
		if mcs.Height.Min < 0 {
			mcs.Height.Min = 0
		}
		if mcs.Height.Max < mcs.Height.Min {
			mcs.Height.Max = mcs.Height.Min
		}
	}
	ui.PushOp{}.Add(ops)
	ui.TransformOp{Transform: ui.Offset(toPointF(image.Point{X: in.left, Y: in.top}))}.Add(ops)
	return mcs
}

func (in *Insets) End(dims Dimens) Dimens {
	if !in.begun {
		panic("must Begin before End")
	}
	in.begun = false
	ops := in.ops
	ui.PopOp{}.Add(ops)
	return Dimens{
		Size:     in.cs.Constrain(dims.Size.Add(image.Point{X: in.right + in.left, Y: in.top + in.bottom})),
		Baseline: dims.Baseline + in.top,
	}
}

func EqualInsets(v ui.Value) Insets {
	return Insets{Top: v, Right: v, Bottom: v, Left: v}
}

type Align struct {
	Alignment Direction

	ops   *ui.Ops
	begun bool
	cs    Constraints
}

func (a *Align) Begin(ops *ui.Ops, cs Constraints) Constraints {
	if a.begun {
		panic("must End before Begin")
	}
	a.begun = true
	a.ops = ops
	a.cs = cs
	ops.Begin()
	return cs.Loose()
}

func (a *Align) End(dims Dimens) Dimens {
	if !a.begun {
		panic("must Begin before End")
	}
	a.begun = false
	ops := a.ops
	block := ops.End()
	sz := dims.Size
	if a.cs.Width.Max != ui.Inf {
		sz.X = a.cs.Width.Max
	}
	if a.cs.Height.Max != ui.Inf {
		sz.Y = a.cs.Height.Max
	}
	var p image.Point
	switch a.Alignment {
	case N, S, Center:
		p.X = (sz.X - dims.Size.X) / 2
	case NE, SE, E:
		p.X = sz.X - dims.Size.X
	}
	switch a.Alignment {
	case W, Center, E:
		p.Y = (sz.Y - dims.Size.Y) / 2
	case SW, S, SE:
		p.Y = sz.Y - dims.Size.Y
	}
	ui.PushOp{}.Add(ops)
	ui.TransformOp{Transform: ui.Offset(toPointF(p))}.Add(ops)
	block.Add(ops)
	ui.PopOp{}.Add(ops)
	return Dimens{
		Size:     sz,
		Baseline: dims.Baseline,
	}
}