2023-02-15 16:17:17 -07:00
|
|
|
package textdraw
|
|
|
|
|
|
|
|
import "unicode"
|
|
|
|
import "golang.org/x/image/font"
|
|
|
|
import "golang.org/x/image/math/fixed"
|
|
|
|
|
|
|
|
// Align specifies a text alignment method.
|
|
|
|
type Align int
|
|
|
|
|
|
|
|
const (
|
|
|
|
// AlignLeft aligns the start of each line to the beginning point
|
|
|
|
// of each dot.
|
|
|
|
AlignLeft Align = iota
|
|
|
|
AlignRight
|
|
|
|
AlignCenter
|
|
|
|
AlignJustify
|
|
|
|
)
|
|
|
|
|
|
|
|
// RuneLayout contains layout information for a single rune relative to its
|
|
|
|
// word.
|
|
|
|
type RuneLayout struct {
|
|
|
|
X fixed.Int26_6
|
|
|
|
Width fixed.Int26_6
|
|
|
|
Rune rune
|
|
|
|
}
|
|
|
|
|
|
|
|
// WordLayout contains layout information for a single word relative to its
|
|
|
|
// line.
|
|
|
|
type WordLayout struct {
|
|
|
|
X fixed.Int26_6
|
|
|
|
Width fixed.Int26_6
|
|
|
|
SpaceAfter fixed.Int26_6
|
|
|
|
Runes []RuneLayout
|
|
|
|
}
|
|
|
|
|
|
|
|
// DoWord consumes exactly one word from the given string, and produces a word
|
|
|
|
// layout according to the given font. It returns the remaining text as well.
|
|
|
|
func DoWord (text []rune, face font.Face) (word WordLayout, remaining []rune) {
|
|
|
|
remaining = text
|
|
|
|
gettingSpace := false
|
|
|
|
x := fixed.Int26_6(0)
|
|
|
|
lastRune := rune(-1)
|
|
|
|
for _, char := range text {
|
|
|
|
// if we run into a line break, we must break out immediately
|
|
|
|
// because it is not DoWord's job to handle that.
|
|
|
|
if char == '\n' { break }
|
|
|
|
|
|
|
|
// if we suddenly run into spaces, and then run into a word
|
|
|
|
// again, we must break out immediately.
|
|
|
|
if unicode.IsSpace(char) {
|
|
|
|
gettingSpace = true
|
|
|
|
} else if gettingSpace {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
// apply kerning
|
|
|
|
if lastRune >= 0 { x += face.Kern(lastRune, char) }
|
|
|
|
lastRune = char
|
|
|
|
|
|
|
|
// consume and process the rune
|
|
|
|
remaining = remaining[1:]
|
|
|
|
_, advance, ok := face.GlyphBounds(char)
|
|
|
|
if !ok { continue }
|
|
|
|
word.Runes = append (word.Runes, RuneLayout {
|
|
|
|
X: x,
|
|
|
|
Width: advance,
|
|
|
|
Rune: char,
|
|
|
|
})
|
|
|
|
|
|
|
|
// advance
|
|
|
|
if gettingSpace {
|
|
|
|
word.SpaceAfter += advance
|
|
|
|
} else {
|
|
|
|
word.Width += advance
|
|
|
|
}
|
|
|
|
x += advance
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// LastRune returns the last rune in the word.
|
|
|
|
func (word WordLayout) LastRune () rune {
|
|
|
|
if word.Runes == nil {
|
|
|
|
return -1
|
|
|
|
} else {
|
|
|
|
return word.Runes[len(word.Runes) - 1].Rune
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FirstRune returns the last rune in the word.
|
|
|
|
func (word WordLayout) FirstRune () rune {
|
|
|
|
if word.Runes == nil {
|
|
|
|
return -1
|
|
|
|
} else {
|
|
|
|
return word.Runes[0].Rune
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// LineLayout contains layout information for a single line.
|
|
|
|
type LineLayout struct {
|
2023-03-16 18:24:33 -06:00
|
|
|
Y fixed.Int26_6
|
|
|
|
Width fixed.Int26_6
|
|
|
|
ContentWidth fixed.Int26_6
|
|
|
|
SpaceAfter fixed.Int26_6
|
|
|
|
Words []WordLayout
|
2023-02-15 16:17:17 -07:00
|
|
|
BreakAfter bool
|
|
|
|
}
|
|
|
|
|
|
|
|
// DoLine consumes exactly one line from the given string, and produces a line
|
|
|
|
// layout according to the given font. It returns the remaining text as well. If
|
|
|
|
// maxWidth is greater than zero, this function will stop processing words once
|
|
|
|
// the limit is crossed. The word which would have crossed over the limit will
|
|
|
|
// not be processed.
|
|
|
|
func DoLine (text []rune, face font.Face, maxWidth fixed.Int26_6) (line LineLayout, remaining []rune) {
|
2023-02-15 23:55:00 -07:00
|
|
|
remaining = text
|
|
|
|
x := fixed.Int26_6(0)
|
|
|
|
lastWord := WordLayout { }
|
|
|
|
isFirstWord := true
|
2023-02-15 16:17:17 -07:00
|
|
|
for {
|
|
|
|
// process one word
|
|
|
|
word, remainingFromWord := DoWord(remaining, face)
|
|
|
|
word.X = x
|
2023-02-15 23:55:00 -07:00
|
|
|
x += word.Width
|
2023-02-15 16:17:17 -07:00
|
|
|
|
|
|
|
// if we have gone over the maximum width, stop processing
|
|
|
|
// words (if maxWidth is even specified)
|
2023-02-15 23:55:00 -07:00
|
|
|
if !isFirstWord && maxWidth > 0 && x > maxWidth {
|
|
|
|
break
|
|
|
|
}
|
2023-02-15 16:17:17 -07:00
|
|
|
|
2023-02-15 23:55:00 -07:00
|
|
|
x += word.SpaceAfter
|
2023-02-15 16:17:17 -07:00
|
|
|
remaining = remainingFromWord
|
|
|
|
|
|
|
|
// if the word actually has contents, add it
|
|
|
|
if word.Runes != nil {
|
|
|
|
lastWord = word
|
|
|
|
line.Words = append(line.Words, word)
|
|
|
|
}
|
|
|
|
|
|
|
|
// if we have hit the end of the line, stop processing words
|
|
|
|
if len(remaining) == 0 { break }
|
|
|
|
if remaining[0] == '\n' {
|
|
|
|
line.BreakAfter = true
|
|
|
|
remaining = remaining[1:]
|
|
|
|
break
|
|
|
|
}
|
2023-02-15 23:55:00 -07:00
|
|
|
|
|
|
|
isFirstWord = false
|
2023-02-15 16:17:17 -07:00
|
|
|
}
|
|
|
|
|
2023-03-16 18:24:33 -06:00
|
|
|
// set the width of the line's content.
|
|
|
|
line.ContentWidth = lastWord.X + lastWord.Width
|
|
|
|
|
2023-02-15 16:17:17 -07:00
|
|
|
// set the line's width. this is subject to be overridden by the
|
|
|
|
// TypeSetter to match the longest line.
|
|
|
|
if maxWidth > 0 {
|
|
|
|
line.Width = maxWidth
|
|
|
|
} else {
|
2023-03-16 18:24:33 -06:00
|
|
|
line.Width = line.ContentWidth
|
2023-02-15 16:17:17 -07:00
|
|
|
line.SpaceAfter = lastWord.SpaceAfter
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Align aligns the text in the line according to the specified alignment
|
|
|
|
// method.
|
|
|
|
func (line *LineLayout) Align (align Align) {
|
2023-03-16 18:24:33 -06:00
|
|
|
if len(line.Words) == 0 { return }
|
|
|
|
|
|
|
|
if align == AlignJustify {
|
|
|
|
line.justify()
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
leftOffset := -line.Words[0].X
|
|
|
|
|
|
|
|
if align == AlignCenter {
|
|
|
|
leftOffset += (line.Width - line.ContentWidth) / 2
|
|
|
|
} else if align == AlignRight {
|
|
|
|
leftOffset += line.Width - line.ContentWidth
|
|
|
|
}
|
|
|
|
|
|
|
|
for index := range line.Words {
|
|
|
|
line.Words[index].X += leftOffset
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (line *LineLayout) justify () {
|
|
|
|
if len(line.Words) < 2 {
|
|
|
|
line.Align(AlignLeft)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// We are going to be moving the words, so we can't take SpaceAfter into
|
|
|
|
// account.
|
|
|
|
trueContentWidth := fixed.Int26_6(0)
|
|
|
|
for _, word := range line.Words {
|
|
|
|
trueContentWidth += word.Width
|
|
|
|
}
|
|
|
|
|
|
|
|
spaceCount := fixed.Int26_6(len(line.Words) - 1)
|
|
|
|
spacePerWord := (line.Width - trueContentWidth) / spaceCount
|
|
|
|
x := fixed.Int26_6(0)
|
|
|
|
for index, word := range line.Words {
|
|
|
|
line.Words[index].X = x
|
|
|
|
x += spacePerWord + word.Width
|
|
|
|
}
|
2023-02-15 16:17:17 -07:00
|
|
|
}
|