~eliasnaur/gio

ref: 48b6a73753e7ee567154297987f24a4d10485999 gio/ui/text/label.go -rw-r--r-- 3.3 KiB
48b6a737Elias Naur all: run goimports 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
// SPDX-License-Identifier: Unlicense OR MIT

package text

import (
	"image"
	"math"
	"unicode/utf8"

	"gioui.org/ui"
	"gioui.org/ui/draw"
	"gioui.org/ui/f32"
	"gioui.org/ui/layout"

	"golang.org/x/image/math/fixed"
)

type Label struct {
	Face      Face
	Src       image.Image
	Alignment Alignment
	Text      string

	it lineIterator
}

type lineIterator struct {
	Lines     []Line
	Clip      image.Rectangle
	Alignment Alignment
	Width     int
	Offset    image.Point

	y, prevDesc fixed.Int26_6
}

func (l *lineIterator) Next() (String, f32.Point, bool) {
	for len(l.Lines) > 0 {
		line := l.Lines[0]
		l.Lines = l.Lines[1:]
		x := align(l.Alignment, line.Width, l.Width) + fixed.I(l.Offset.X)
		l.y += l.prevDesc + line.Ascent
		l.prevDesc = line.Descent
		// Align baseline and line start to the pixel grid.
		off := fixed.Point26_6{X: fixed.I(x.Floor()), Y: fixed.I(l.y.Ceil())}
		x, l.y = off.X, off.Y
		off.Y += fixed.I(l.Offset.Y)
		if (off.Y + line.Bounds.Min.Y).Floor() > l.Clip.Max.Y {
			break
		}
		if (off.Y + line.Bounds.Max.Y).Ceil() < l.Clip.Min.Y {
			continue
		}
		str := line.Text
		for len(str.Advances) > 0 {
			adv := str.Advances[0]
			if (off.X + adv + line.Bounds.Max.X - line.Width).Ceil() >= l.Clip.Min.X {
				break
			}
			off.X += adv
			_, s := utf8.DecodeRuneInString(str.String)
			str.String = str.String[s:]
			str.Advances = str.Advances[1:]
		}
		n := 0
		endx := off.X
		for i, adv := range str.Advances {
			if (endx + line.Bounds.Min.X).Floor() > l.Clip.Max.X {
				str.String = str.String[:n]
				str.Advances = str.Advances[:i]
				break
			}
			_, s := utf8.DecodeRuneInString(str.String[n:])
			n += s
			endx += adv
		}
		offf := f32.Point{X: float32(off.X) / 64, Y: float32(off.Y) / 64}
		return str, offf, true
	}
	return String{}, f32.Point{}, false
}

func (l Label) Layout(cs layout.Constraints) (ui.Op, layout.Dimens) {
	textLayout := l.Face.Layout(l.Text, false, cs.Width.Max)
	lines := textLayout.Lines
	dims := linesDimens(lines)
	dims.Size = cs.Constrain(dims.Size)
	padTop, padBottom := textPadding(lines)
	clip := image.Rectangle{
		Min: image.Point{X: -ui.Inf, Y: -padTop},
		Max: image.Point{X: ui.Inf, Y: dims.Size.Y + padBottom},
	}
	var ops ui.Ops = make([]ui.Op, len(lines))[:0]
	l.it = lineIterator{
		Lines:     lines,
		Clip:      clip,
		Alignment: l.Alignment,
		Width:     dims.Size.X,
	}
	for {
		str, off, ok := l.it.Next()
		if !ok {
			break
		}
		path := l.Face.Path(str)
		lclip := toRectF(clip).Sub(off)
		op := ui.OpTransform{
			Transform: ui.Offset(off),
			Op:        draw.OpClip{Path: path, Op: draw.OpImage{Rect: lclip, Src: l.Src, SrcRect: l.Src.Bounds()}},
		}
		ops = append(ops, op)
	}
	return ops, dims
}

func itof(i int) float32 {
	switch i {
	case ui.Inf:
		return float32(math.Inf(+1))
	case -ui.Inf:
		return float32(math.Inf(-1))
	default:
		return float32(i)
	}
}

func toRectF(r image.Rectangle) f32.Rectangle {
	return f32.Rectangle{
		Min: f32.Point{X: itof(r.Min.X), Y: itof(r.Min.Y)},
		Max: f32.Point{X: itof(r.Max.X), Y: itof(r.Max.Y)},
	}
}

func textPadding(lines []Line) (padTop int, padBottom int) {
	if len(lines) > 0 {
		first := lines[0]
		if d := -first.Bounds.Min.Y - first.Ascent; d > 0 {
			padTop = d.Ceil()
		}
		last := lines[len(lines)-1]
		if d := last.Bounds.Max.Y - last.Descent; d > 0 {
			padBottom = d.Ceil()
		}
	}
	return
}