zntg/ui/paragraph.go

package ui

import (
	"strconv"
	"strings"

	"opslag.de/schobers/geom"
)

type Paragraph struct {
	Label

	width float32
	lines CachedValue
}

func BuildParagraph(text string, fn func(*Paragraph)) *Paragraph {
	var p = &Paragraph{}
	p.Text = text
	if fn != nil {
		fn(p)
	}
	return p
}

func fastFormatFloat32(f float32) string { return strconv.FormatFloat(float64(f), 'b', 32, 32) }

func (p *Paragraph) desiredSize(ctx Context) interface{} {
	font := p.Font_(ctx)

	pad := ctx.Style().Dimensions.TextPadding
	lines := p.splitInLines(ctx, p.width-2*pad)
	return geom.PtF32(p.width, float32(len(lines))*font.Height()+2*pad)
}

func (p *Paragraph) hashTextArranged(ctx Context) string {
	return p.FontName(ctx) + p.Text + fastFormatFloat32(p.Bounds().Dx())
}

func (p *Paragraph) hashTextDesired(ctx Context) string {
	return p.FontName(ctx) + p.Text + fastFormatFloat32(p.width)
}

func (p *Paragraph) splitInLines(ctx Context, width float32) []string {
	font := p.Font_(ctx)

	spaces := func(s string) []int { // creates a slice with indices where spaces can be found in string s
		var spaces []int
		offset := 0
		for {
			space := strings.Index(s[offset:], " ")
			if space == -1 {
				return spaces
			}
			offset += space
			spaces = append(spaces, offset)
			offset++
		}
	}

	fit := func(s string) string { // tries to fit as much of string s in width space.
		if font.WidthOf(s) < width {
			return s
		}
		spaces := spaces(s)
		// removes one word (delimited by spaces) at a time and tries until the result fits.
		for split := len(spaces) - 1; split >= 0; split-- {
			clipped := s[:spaces[split]]
			if font.WidthOf(clipped) < width {
				return clipped
			}
		}
		// nothing fits (returns the whole string)...
		return s
	}

	var lines []string
	for _, line := range strings.Split(p.Text, "\n") {
		if len(line) == 0 {
			lines = append(lines, line)
			continue
		}

		for len(line) > 0 {
			clipped := fit(line)
			lines = append(lines, clipped)
			line = strings.TrimLeft(line[len(clipped):], " ")
		}
	}
	return lines
}

func (p *Paragraph) updateLines(ctx Context) interface{} {
	pad := ctx.Style().Dimensions.TextPadding
	return p.splitInLines(ctx, p.Bounds().Dx()-2*pad)
}

func (p *Paragraph) DesiredSize(ctx Context, size geom.PointF32) geom.PointF32 {
	// stores the given width, is used when calculating the new desired size (and thus used in the hash method as well)
	p.width = size.X
	return p.desired.GetContext(ctx, p.desiredSize, p.hashTextDesired).(geom.PointF32)
}

func (p *Paragraph) Render(ctx Context) {
	p.RenderBackground(ctx)

	pad := ctx.Style().Dimensions.TextPadding
	width := p.Bounds().Dx() - 2*pad
	lines := p.lines.GetContext(ctx, p.updateLines, p.hashTextArranged).([]string)

	fontColor := p.TextColor(ctx)
	fontName := p.FontName(ctx)
	fontHeight := ctx.Fonts().Font(fontName).Height()
	bounds := p.bounds.Inset(pad)

	left := bounds.Min.X
	switch p.TextAlignment {
	case AlignRight:
		left = bounds.Max.X
	case AlignCenter:
		left += .5 * width
	}
	offset := bounds.Min.Y
	for _, line := range lines {
		ctx.Fonts().TextAlign(fontName, geom.PtF32(left, offset), fontColor, line, p.TextAlignment)
		offset += fontHeight
	}
}