font.go

package canvas

import (
	"fmt"
	"image/color"
	"io/ioutil"
	"math"
	"os/exec"
	"reflect"
	"sync"

	"github.com/adrg/sysfont"
	"github.com/tdewolff/canvas/font"
	"github.com/tdewolff/canvas/text"
)

// FontStyle defines the font style to be used for the font. It specifies a boldness with optionally italic, e.g. FontBlack | FontItalic will specify a black boldness (a font-weight of 800 in CSS) and italic.
type FontStyle int

// see FontStyle
const (
	FontRegular    FontStyle = iota // 400
	FontExtraLight                  // 100
	FontLight                       // 200
	FontBook                        // 300
	FontMedium                      // 500
	FontSemibold                    // 600
	FontBold                        // 700
	FontBlack                       // 800
	FontExtraBlack                  // 900
	FontItalic     FontStyle = 1 << 8
)

// Weight returns the font weight (FontRegular, FontBold, ...)
func (style FontStyle) Weight() FontStyle {
	return style & 0xFF
}

// Italic returns true if italic.
func (style FontStyle) Italic() bool {
	return style&FontItalic != 0
}

// CSS returns the CSS boldness value for the font face.
func (style FontStyle) CSS() int {
	switch style.Weight() {
	case FontExtraLight:
		return 100
	case FontLight:
		return 200
	case FontBook:
		return 300
	case FontMedium:
		return 500
	case FontSemibold:
		return 600
	case FontBold:
		return 700
	case FontBlack:
		return 800
	case FontExtraBlack:
		return 900
	}
	return 400
}

// FontVariant defines the font variant to be used for the font, such as subscript or smallcaps.
type FontVariant int

// see FontVariant
const (
	FontNormal FontVariant = iota
	FontSubscript
	FontSuperscript
	FontSmallcaps
)

////////////////////////////////////////////////////////////////

// FontSubsetter holds a map between original glyph IDs and new glyph IDs in a subsetted font.
type FontSubsetter struct {
	IDs   []uint16          // old glyphIDs for increasing new glyphIDs
	IDMap map[uint16]uint16 // old to new glyphID
}

// NewFontSubsetter returns a new font subsetter.
func NewFontSubsetter() *FontSubsetter {
	return &FontSubsetter{
		IDs:   []uint16{0}, // .notdef should always be at zero
		IDMap: map[uint16]uint16{0: 0},
	}
}

// Get maps a glyphID of the original font to the subsetted font. If the glyphID is not subsetted, it will be added to the map.
func (subsetter *FontSubsetter) Get(glyphID uint16) uint16 {
	if subsetGlyphID, ok := subsetter.IDMap[glyphID]; ok {
		return subsetGlyphID
	}
	subsetGlyphID := uint16(len(subsetter.IDs))
	subsetter.IDs = append(subsetter.IDs, glyphID)
	subsetter.IDMap[glyphID] = subsetGlyphID
	return subsetGlyphID
}

// List returns all subsetted IDs in the order of appearance.
func (subsetter *FontSubsetter) List() []uint16 {
	return subsetter.IDs
}

////////////////////////////////////////////////////////////////

var sysfontFinder = struct {
	f *sysfont.Finder
	m sync.Mutex
}{}

// FindLocalFont finds the path to a font from the system's fonts.
func FindLocalFont(name string, style FontStyle) string {
	// TODO: use style to match font
	// try with fc-match first
	filename, err := exec.Command("fc-match", "--format=%{file}", name).Output()
	if err == nil {
		return string(filename)
	}

	// then use known font directories
	sysfontFinder.m.Lock()
	finder := sysfontFinder.f
	if finder == nil {
		finder = sysfont.NewFinder(&sysfont.FinderOpts{ // TODO: very slow (takes 1s)
			Extensions: []string{".ttf", ".otf", ".ttc", ".woff", ".woff2", ".eot"},
		})
		sysfontFinder.f = finder
	}
	sysfontFinder.m.Unlock()

	font := finder.Match(name)
	return font.Filename
}

// Font defines an SFNT font such as TTF or OTF.
type Font struct {
	*font.SFNT
	name       string
	style      FontStyle
	shaper     text.Shaper
	variations string
	features   string
}

// LoadLocalFont loads a font from the system's fonts.
func LoadLocalFont(name string, style FontStyle) (*Font, error) {
	return LoadFontFile(FindLocalFont(name, style), style)
}

// LoadFontFile loads a font from a file.
func LoadFontFile(filename string, style FontStyle) (*Font, error) {
	b, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, fmt.Errorf("failed to load font file '%s': %w", filename, err)
	}
	return LoadFont(b, 0, style)
}

// LoadFontCollection loads a font from a collection file and uses the font at the specified index.
func LoadFontCollection(filename string, index int, style FontStyle) (*Font, error) {
	b, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, fmt.Errorf("failed to load font file '%s': %w", filename, err)
	}
	return LoadFont(b, index, style)
}

var nonameFonts = 0

// LoadFont loads a font from memory.
func LoadFont(b []byte, index int, style FontStyle) (*Font, error) {
	SFNT, err := font.ParseFont(b, index)
	if err != nil {
		return nil, err
	}

	shaper, err := text.NewShaperSFNT(SFNT)
	if err != nil {
		return nil, err
	}

	name := ""
NameLoop:
	for _, id := range []int{6, 4, 1} {
		for _, record := range SFNT.Name.Get(font.NameID(id)) {
			name = record.String()
			break NameLoop
		}
	}
	if name == "" {
		name = fmt.Sprintf("f%d", nonameFonts)
		nonameFonts++
	}

	font := &Font{
		SFNT:   SFNT,
		name:   name,
		style:  style,
		shaper: shaper,
	}
	return font, nil
}

// Destroy should be called when using HarfBuzz to free the C resources.
func (f *Font) Destroy() {
	f.shaper.Destroy()
}

// Name returns the name of the font.
func (f *Font) Name() string {
	return f.name
}

// Style returns the style of the font.
func (f *Font) Style() FontStyle {
	return f.style
}

// SetVariations sets the font variations (not yet supported).
func (f *Font) SetVariations(variations string) {
	// TODO: support font variations
	f.variations = variations
}

// SetFeatures sets the font features (not yet supported).
func (f *Font) SetFeatures(features string) {
	// TODO: support font features
	f.features = features
}

// Face gets the font face given by the font size in points and its style. Fill can be any of Paint, color.Color, or canvas.Pattern.
func (f *Font) Face(size float64, ifill interface{}, deco ...FontDecorator) *FontFace {
	face := &FontFace{}
	face.Font = f
	face.Size = size * mmPerPt
	face.Style = f.style
	face.Variant = FontNormal

	if paint, ok := ifill.(Paint); ok {
		face.Fill = paint
	} else if pattern, ok := ifill.(Pattern); ok {
		face.Fill = Paint{Pattern: pattern}
	} else if gradient, ok := ifill.(Gradient); ok {
		face.Fill = Paint{Gradient: gradient}
	} else if col, ok := ifill.(color.Color); ok {
		face.Fill = Paint{Color: rgbaColor(col)}
	}
	face.Deco = deco
	face.Hinting = font.VerticalHinting
	face.mmPerEm = face.Size / float64(face.Font.Head.UnitsPerEm)
	return face
}

////////////////////////////////////////////////////////////////

// FontFamily contains a family of fonts (bold, italic, ...). Allowing to select an italic style as the native italic font or to use faux italic if not present.
type FontFamily struct {
	name  string
	fonts map[FontStyle]*Font
}

// NewFontFamily returns a new font family.
func NewFontFamily(name string) *FontFamily {
	return &FontFamily{
		name:  name,
		fonts: map[FontStyle]*Font{},
	}
}

// Destroy should be called when using HarfBuzz to free the C resources.
func (family *FontFamily) Destroy() {
	for _, font := range family.fonts {
		font.Destroy()
	}
}

// Name returns the name of the font family.
func (family *FontFamily) Name() string {
	return family.name
}

// SetVariations sets the font variations (not yet supported).
func (family *FontFamily) SetVariations(variations string) {
	for _, font := range family.fonts {
		font.SetVariations(variations)
	}
}

// SetFeatures sets the font features (not yet supported).
func (family *FontFamily) SetFeatures(features string) {
	for _, font := range family.fonts {
		font.SetFeatures(features)
	}
}

// LoadLocalFont loads a font from the system's fonts.
func (family *FontFamily) LoadLocalFont(name string, style FontStyle) error {
	return family.LoadFontFile(FindLocalFont(name, style), style)
}

// MustLoadLocalFont loads a font from the system's fonts and panics on error.
func (family *FontFamily) MustLoadLocalFont(name string, style FontStyle) {
	if err := family.LoadLocalFont(name, style); err != nil {
		panic(err)
	}
}

// LoadFontFile loads a font from a file.
func (family *FontFamily) LoadFontFile(filename string, style FontStyle) error {
	b, err := ioutil.ReadFile(filename)
	if err != nil {
		return fmt.Errorf("failed to load font file '%s': %w", filename, err)
	}
	return family.LoadFont(b, 0, style)
}

// MustLoadFontFile loads a font from a filea and panics on error.
func (family *FontFamily) MustLoadFontFile(filename string, style FontStyle) {
	if err := family.LoadFontFile(filename, style); err != nil {
		panic(err)
	}
}

// LoadFontCollection loads a font from a collection file and uses the font at the specified index.
func (family *FontFamily) LoadFontCollection(filename string, index int, style FontStyle) error {
	b, err := ioutil.ReadFile(filename)
	if err != nil {
		return fmt.Errorf("failed to load font file '%s': %w", filename, err)
	}
	return family.LoadFont(b, index, style)
}

// MustLoadFontCollection loads a font from a collection file and uses the font at the specified index. It panics on error.
func (family *FontFamily) MustLoadFontCollection(filename string, index int, style FontStyle) {
	if err := family.LoadFontCollection(filename, index, style); err != nil {
		panic(err)
	}
}

// LoadFont loads a font from memory.
func (family *FontFamily) LoadFont(b []byte, index int, style FontStyle) error {
	font, err := LoadFont(b, index, style)
	if err != nil {
		return err
	}
	font.name = family.name
	family.fonts[style] = font
	return nil
}

// MustLoadFont loads a font from memory. It panics on error.
func (family *FontFamily) MustLoadFont(b []byte, index int, style FontStyle) {
	if err := family.LoadFont(b, index, style); err != nil {
		panic(err)
	}
}

// Face gets the font face given by the font size in points. Other arguments that can be passed: Paint/Pattern/color.Color (=Black), FontStyle (=FontRegular), FontVariant (=FontNormal), multiple FontDecorator, and Hinting (=VerticalHinting).
func (family *FontFamily) Face(size float64, args ...interface{}) *FontFace {
	face := &FontFace{
		Fill:    Paint{Color: Black},
		Hinting: font.VerticalHinting,
	}
	for _, iarg := range args {
		switch arg := iarg.(type) {
		case Paint:
			face.Fill = arg
		case Pattern:
			face.Fill = Paint{Pattern: arg}
		case Gradient:
			face.Fill = Paint{Gradient: arg}
		case color.Color:
			face.Fill = Paint{Color: rgbaColor(arg)}
		case FontStyle:
			face.Style = arg
		case FontVariant:
			face.Variant = arg
		case FontDecorator:
			face.Deco = append(face.Deco, arg)
		case font.Hinting:
			face.Hinting = arg
		}
	}
	face.Font = family.fonts[face.Style]
	face.Size = size * mmPerPt

	if face.Variant == FontSubscript || face.Variant == FontSuperscript {
		scale := 0.583
		xOffset, yOffset := int16(0), int16(0)
		units := float64(face.Font.Head.UnitsPerEm)
		if face.Variant == FontSubscript {
			if face.Font.OS2.YSubscriptXSize != 0 {
				scale = float64(face.Font.OS2.YSubscriptXSize) / units
			}
			if face.Font.OS2.YSubscriptXOffset != 0 {
				xOffset = face.Font.OS2.YSubscriptXOffset
			}
			yOffset = int16(0.33 * units)
			if face.Font.OS2.YSubscriptYOffset != 0 {
				yOffset = -face.Font.OS2.YSubscriptYOffset
			}
		} else if face.Variant == FontSuperscript {
			if face.Font.OS2.YSuperscriptXSize != 0 {
				scale = float64(face.Font.OS2.YSuperscriptXSize) / units
			}
			if face.Font.OS2.YSuperscriptXOffset != 0 {
				xOffset = face.Font.OS2.YSuperscriptXOffset
			}
			yOffset = int16(-0.33 * units)
			if face.Font.OS2.YSuperscriptYOffset != 0 {
				yOffset = face.Font.OS2.YSuperscriptYOffset
			}
		}
		face.Size *= scale
		face.XOffset = int32(float64(xOffset) / scale)
		face.YOffset = int32(float64(yOffset) / scale)
		if face.Style&0xFF == FontExtraLight {
			face.Style = face.Style&0x100 | FontLight
		} else if face.Style&0xFF == FontLight || face.Style&0xFF == FontBook {
			face.Style = face.Style & 0x100
		} else if face.Style&0xFF == FontRegular {
			face.Style = face.Style&0x100 | FontSemibold
		} else if face.Style&0xFF == FontMedium || face.Style&0xFF == FontSemibold {
			face.Style = face.Style&0x100 | FontBold
		} else if face.Style&0xFF == FontBold {
			face.Style = face.Style&0x100 | FontBlack
		} else if face.Style&0xFF == FontBlack {
			face.Style = face.Style&0x100 | FontExtraBlack
		} else {
			face.FauxBold += 0.02
		}
		face.Font = family.fonts[face.Style]
	}

	if face.Font == nil {
		face.Font = family.fonts[FontRegular]
		if face.Font == nil {
			panic("requested font style not found")
		}
		if face.Style&0xFF == FontExtraLight {
			face.FauxBold += -0.02
		} else if face.Style&0xFF == FontLight {
			face.FauxBold += -0.01
		} else if face.Style&0xFF == FontBook {
			face.FauxBold += -0.005
		} else if face.Style&0xFF == FontMedium {
			face.FauxBold += 0.005
		} else if face.Style&0xFF == FontSemibold {
			face.FauxBold += 0.01
		} else if face.Style&0xFF == FontBold {
			face.FauxBold += 0.02
		} else if face.Style&0xFF == FontBlack {
			face.FauxBold += 0.03
		} else if face.Style&0xFF == FontExtraBlack {
			face.FauxBold += 0.04
		}
		if face.Style&FontItalic != 0 {
			if face.Font.Post.ItalicAngle != 0 {
				face.FauxItalic = math.Tan(-face.Font.Post.ItalicAngle)
			} else {
				face.FauxItalic = 0.3
			}
		}
	}
	face.mmPerEm = face.Size / float64(face.Font.Head.UnitsPerEm)
	return face
}

////////////////////////////////////////////////////////////////

// FontFace defines a font face from a given font. It specifies the font size, color, faux styles and font decorations.
type FontFace struct {
	Font *Font

	Size    float64 // in mm
	Style   FontStyle
	Variant FontVariant

	Fill    Paint
	Deco    []FontDecorator
	Hinting font.Hinting

	// faux styles for bold, italic, and sub- and superscript
	FauxBold, FauxItalic float64
	XOffset, YOffset     int32

	Language  string
	Script    text.Script
	Direction text.Direction // TODO: really needed here?

	// letter spacing
	// stroke and stroke color
	// line height
	// shadow

	mmPerEm float64 // millimeters per EM unit!
}

// Equals returns true when two font face are equal.
func (face *FontFace) Equals(other *FontFace) bool {
	return reflect.DeepEqual(face, other)
}

// Name returns the name of the underlying font.
func (face *FontFace) Name() string {
	return face.Font.name
}

// HasDecoration returns true if the font face has decorations enabled.
func (face *FontFace) HasDecoration() bool {
	return 0 < len(face.Deco)
}

// FontMetrics contains a number of metrics that define a font face. See https://developer.apple.com/library/archive/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png for an explanation of the different metrics.
type FontMetrics struct {
	LineHeight float64
	Ascent     float64
	Descent    float64
	LineGap    float64
	XHeight    float64
	CapHeight  float64

	XMin, YMin float64
	XMax, YMax float64
}

func (m FontMetrics) String() string {
	return fmt.Sprintf("{LineHeight: %v, Ascent: %v, Descent: %v, LineGap: %v, XHeight: %v, CapHeight: %v}", m.LineHeight, m.Ascent, m.Descent, m.LineGap, m.XHeight, m.CapHeight)
}

// Metrics returns the font metrics. See https://developer.apple.com/library/archive/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png for an explanation of the different metrics.
func (face *FontFace) Metrics() FontMetrics {
	sfnt := face.Font.SFNT
	return FontMetrics{
		LineHeight: face.mmPerEm * float64(sfnt.Hhea.Ascender-sfnt.Hhea.Descender+sfnt.Hhea.LineGap),
		Ascent:     face.mmPerEm * float64(sfnt.Hhea.Ascender),
		Descent:    face.mmPerEm * float64(-sfnt.Hhea.Descender),
		LineGap:    face.mmPerEm * float64(sfnt.Hhea.LineGap),
		XHeight:    face.mmPerEm * float64(sfnt.OS2.SxHeight),
		CapHeight:  face.mmPerEm * float64(sfnt.OS2.SCapHeight),
		XMin:       face.mmPerEm * float64(sfnt.Head.XMin),
		YMin:       face.mmPerEm * float64(sfnt.Head.YMin),
		XMax:       face.mmPerEm * float64(sfnt.Head.XMax),
		YMax:       face.mmPerEm * float64(sfnt.Head.YMax),
	}
}

// PPEM returns the pixels-per-EM for a given resolution of the font face.
func (face *FontFace) PPEM(resolution Resolution) uint16 {
	// ppem is for hinting purposes only, this does not influence glyph advances
	return uint16(resolution.DPMM() * face.mmPerEm * float64(face.Font.Head.UnitsPerEm))
}

// LineHeight returns the height (ascent+descent) of a line.
func (face *FontFace) LineHeight() float64 {
	metrics := face.Metrics()
	return metrics.Ascent + metrics.Descent
}

// TextWidth returns the width of a given string in millimeters.
func (face *FontFace) TextWidth(s string) float64 {
	ppem := face.PPEM(DefaultResolution)
	glyphs := face.Font.shaper.Shape(s, ppem, face.Direction, face.Script, face.Language, face.Font.features, face.Font.variations)
	return face.textWidth(glyphs)
}

func (face *FontFace) textWidth(glyphs []text.Glyph) float64 {
	w := int32(0)
	for _, glyph := range glyphs {
		if !glyph.Vertical {
			w += glyph.XAdvance
		} else {
			w -= glyph.YAdvance
		}
	}
	return face.mmPerEm * float64(w)
}

func (face *FontFace) heights(mode WritingMode) (float64, float64, float64, float64) {
	metrics := face.Metrics()
	if mode != HorizontalTB {
		ascent, descent, lineGap, xHeight := metrics.Ascent, metrics.Descent, metrics.LineGap, metrics.XHeight
		ascent -= xHeight / 2.0
		descent += xHeight / 2.0
		if mode == VerticalLR {
			ascent, descent = descent, ascent
		}
		return ascent + lineGap, ascent, descent, descent + lineGap
	}
	return metrics.Ascent + metrics.LineGap, metrics.Ascent, metrics.Descent, metrics.Descent + metrics.LineGap
}

// Decorate will return the decoration path over a given width in millimeters.
func (face *FontFace) Decorate(width float64) *Path {
	p := &Path{}
	if face.Deco != nil {
		for _, deco := range face.Deco {
			p = p.Append(deco.Decorate(face, width))
		}
	}
	return p
}

// ToPath converts a string to its glyph paths.
func (face *FontFace) ToPath(s string) (*Path, float64, error) {
	ppem := face.PPEM(DefaultResolution)
	glyphs := face.Font.shaper.Shape(s, ppem, face.Direction, face.Script, face.Language, face.Font.features, face.Font.variations)
	return face.toPath(glyphs, ppem)
}

func (face *FontFace) toPath(glyphs []text.Glyph, ppem uint16) (*Path, float64, error) {
	p := &Path{}
	f := face.mmPerEm
	x, y := face.XOffset, face.YOffset
	for _, glyph := range glyphs {
		err := face.Font.GlyphPath(p, glyph.ID, ppem, f*float64(x+glyph.XOffset), f*float64(y+glyph.YOffset), f, font.NoHinting)
		if err != nil {
			return p, 0.0, err
		}
		x += glyph.XAdvance
		y += glyph.YAdvance
	}

	if face.FauxBold != 0.0 {
		p = p.Offset(face.FauxBold*face.Size, NonZero, Tolerance)
	}
	if face.FauxItalic != 0.0 {
		p = p.Transform(Identity.Shear(face.FauxItalic, 0.0))
	}
	return p, face.mmPerEm * float64(x), nil
}

////////////////////////////////////////////////////////////////

// FontDecorator is an interface that returns a path given a font face and a width in millimeters.
type FontDecorator interface {
	Decorate(*FontFace, float64) *Path
}

const underlineDistance = 0.075
const underlineThickness = 0.05

// FontUnderline is a font decoration that draws a line under the text.
var FontUnderline FontDecorator = underline{}

type underline struct{}

func (underline) Decorate(face *FontFace, w float64) *Path {
	r := face.Size * underlineThickness
	y := -face.Size * underlineDistance
	if face.Font.Post.UnderlineThickness != 0 {
		r = face.mmPerEm * float64(face.Font.Post.UnderlineThickness)
	}
	if face.Font.Post.UnderlinePosition != 0 {
		y = face.mmPerEm * float64(face.Font.Post.UnderlinePosition)
	}
	y -= r

	p := &Path{}
	p.MoveTo(0.0, y)
	p.LineTo(w, y)
	return p.Stroke(r, ButtCap, BevelJoin, Tolerance)
}

func (underline) String() string {
	return "Underline"
}

// FontOverline is a font decoration that draws a line over the text.
var FontOverline FontDecorator = overline{}

type overline struct{}

func (overline) Decorate(face *FontFace, w float64) *Path {
	r := face.Size * underlineThickness
	y := face.Metrics().Ascent
	if face.Font.Post.UnderlineThickness != 0 {
		r = face.mmPerEm * float64(face.Font.Post.UnderlineThickness)
	}
	y -= 0.5 * r

	dx := face.FauxItalic * y
	w += face.FauxItalic * y

	p := &Path{}
	p.MoveTo(dx, y)
	p.LineTo(w, y)
	return p.Stroke(r, ButtCap, BevelJoin, Tolerance)
}

func (overline) String() string {
	return "Overline"
}

// FontStrikethrough is a font decoration that draws a line through the text.
var FontStrikethrough FontDecorator = strikethrough{}

type strikethrough struct{}

func (strikethrough) Decorate(face *FontFace, w float64) *Path {
	r := face.Size * underlineThickness
	y := face.Metrics().XHeight / 2.0
	if face.Font.OS2.YStrikeoutSize != 0 {
		r = face.mmPerEm * float64(face.Font.OS2.YStrikeoutSize)
	}
	if face.Font.OS2.YStrikeoutPosition != 0 {
		y = face.mmPerEm * float64(face.Font.OS2.YStrikeoutPosition)
	}
	y += 0.5 * r

	dx := face.FauxItalic * y
	w += face.FauxItalic * y

	p := &Path{}
	p.MoveTo(dx, y)
	p.LineTo(w, y)
	return p.Stroke(r, ButtCap, BevelJoin, Tolerance)
}

func (strikethrough) String() string {
	return "Strikethrough"
}

// FontDoubleUnderline is a font decoration that draws two lines under the text.
var FontDoubleUnderline FontDecorator = doubleUnderline{}

type doubleUnderline struct{}

func (doubleUnderline) Decorate(face *FontFace, w float64) *Path {
	r := face.Size * underlineThickness
	y := -face.Size * underlineDistance
	if face.Font.Post.UnderlineThickness != 0 {
		r = face.mmPerEm * float64(face.Font.Post.UnderlineThickness)
	}
	if face.Font.Post.UnderlinePosition != 0 {
		y = face.mmPerEm * float64(face.Font.Post.UnderlinePosition)
	}
	y -= r

	p := &Path{}
	p.MoveTo(0.0, y)
	p.LineTo(w, y)
	p.MoveTo(0.0, y-1.5*r)
	p.LineTo(w, y-1.5*r)
	return p.Stroke(r, ButtCap, BevelJoin, Tolerance)
}

func (doubleUnderline) String() string {
	return "DoubleUnderline"
}

// FontDottedUnderline is a font decoration that draws a dotted line under the text.
var FontDottedUnderline FontDecorator = dottedUnderline{}

type dottedUnderline struct{}

func (dottedUnderline) Decorate(face *FontFace, w float64) *Path {
	r := 0.5 * face.Size * underlineThickness
	y := -face.Size * underlineDistance
	if face.Font.Post.UnderlineThickness != 0 {
		r = 0.5 * face.mmPerEm * float64(face.Font.Post.UnderlineThickness)
	}
	if face.Font.Post.UnderlinePosition != 0 {
		y = face.mmPerEm * float64(face.Font.Post.UnderlinePosition)
	}
	y -= 2.0 * r
	w -= 2.0 * r
	if w < 0.0 {
		return &Path{}
	}

	d := 4.0 * r
	n := int(w/d) + 1
	p := &Path{}
	if n == 1 {
		return p.Append(Circle(r).Translate(r+w/2.0, y))
	}

	d = w / float64(n-1)
	for i := 0; i < n; i++ {
		p = p.Append(Circle(r).Translate(r+float64(i)*d, y))
	}
	return p
}

func (dottedUnderline) String() string {
	return "DottedUnderline"
}

// FontDashedUnderline is a font decoration that draws a dashed line under the text.
var FontDashedUnderline FontDecorator = dashedUnderline{}

type dashedUnderline struct{}

func (dashedUnderline) Decorate(face *FontFace, w float64) *Path {
	r := face.Size * underlineThickness
	y := -face.Size * underlineDistance
	if face.Font.Post.UnderlineThickness != 0 {
		r = face.mmPerEm * float64(face.Font.Post.UnderlineThickness)
	}
	if face.Font.Post.UnderlinePosition != 0 {
		y = face.mmPerEm * float64(face.Font.Post.UnderlinePosition)
	}
	y -= r

	d := 3.0 * r
	n := 2*int((w-d)/(2.0*d)) + 1

	p := &Path{}
	p.MoveTo(0.0, y)
	p.LineTo(w, y)
	if 2 < n {
		d = w / float64(n)
		p = p.Dash(0.0, d)
	}
	return p.Stroke(r, ButtCap, BevelJoin, Tolerance)
}

func (dashedUnderline) String() string {
	return "DashedUnderline"
}

// FontWavyUnderline is a font decoration that draws a wavy path under the text.
var FontWavyUnderline FontDecorator = wavyUnderline{}

type wavyUnderline struct{}

func (wavyUnderline) Decorate(face *FontFace, w float64) *Path {
	r := face.Size * underlineThickness
	y := -face.Size * underlineDistance
	if face.Font.Post.UnderlineThickness != 0 {
		r = face.mmPerEm * float64(face.Font.Post.UnderlineThickness)
	}
	if face.Font.Post.UnderlinePosition != 0 {
		y = face.mmPerEm * float64(face.Font.Post.UnderlinePosition)
	}
	y -= r

	dx := 0.707 * r
	w -= 2.0 * dx
	dh := -face.Size * 0.15
	d := 5.0 * r
	n := int(0.5 + w/d)
	if n == 0 {
		return &Path{}
	}
	d = w / float64(n)

	p := &Path{}
	p.MoveTo(dx, y)
	for i := 0; i < n; i++ {
		if i%2 == 0 {
			p.LineTo(dx+d/3.0, y)
			p.LineTo(dx+d, y+dh)
		} else {
			p.LineTo(dx+d/3.0, y+dh)
			p.LineTo(dx+d, y)
		}
		dx += d
	}
	return p.Stroke(r, ButtCap, MiterJoin, Tolerance)
}

func (wavyUnderline) String() string {
	return "WavyUnderline"
}

// FontSineUnderline is a font decoration that draws a wavy sine path under the text.
var FontSineUnderline FontDecorator = sineUnderline{}

type sineUnderline struct{}

func (sineUnderline) Decorate(face *FontFace, w float64) *Path {
	r := face.Size * underlineThickness
	y := -face.Size * underlineDistance
	if face.Font.Post.UnderlineThickness != 0 {
		r = face.mmPerEm * float64(face.Font.Post.UnderlineThickness)
	}
	if face.Font.Post.UnderlinePosition != 0 {
		y = face.mmPerEm * float64(face.Font.Post.UnderlinePosition)
	}
	y -= r

	w -= r
	d := 4.0 * r
	n := int(0.5 + w/d)
	if n == 0 {
		return &Path{}
	}
	d = (w - r) / float64(n)

	dx := r
	dh := -face.Size * 0.15
	y += 0.5 * dh
	p := &Path{}
	p.MoveTo(dx, y)
	for i := 0; i < n; i++ {
		if i%2 == 0 {
			p.QuadTo(dx+d*0.5, y-dh, dx+d, y)
		} else {
			p.QuadTo(dx+d*0.5, y+dh, dx+d, y)
		}
		dx += d
	}
	return p.Stroke(r, RoundCap, RoundJoin, Tolerance)
}

func (sineUnderline) String() string {
	return "SineUnderline"
}

// FontSawtoothUnderline is a font decoration that draws a wavy sawtooth path under the text.
var FontSawtoothUnderline FontDecorator = sawtoothUnderline{}

type sawtoothUnderline struct{}

func (sawtoothUnderline) Decorate(face *FontFace, w float64) *Path {
	r := face.Size * underlineThickness
	y := -face.Size * underlineDistance
	if face.Font.Post.UnderlineThickness != 0 {
		r = face.mmPerEm * float64(face.Font.Post.UnderlineThickness)
	}
	if face.Font.Post.UnderlinePosition != 0 {
		y = face.mmPerEm * float64(face.Font.Post.UnderlinePosition)
	}
	y -= r

	dx := 0.707 * r
	w -= 2.0 * dx
	dh := -face.Size * 0.15
	d := 4.0 * r
	n := int(0.5 + w/d)
	if n == 0 {
		return &Path{}
	}
	d = w / float64(n)

	p := &Path{}
	p.MoveTo(dx, y)
	for i := 0; i < n; i++ {
		if i%2 == 0 {
			p.LineTo(dx+d, y+dh)
		} else {
			p.LineTo(dx+d, y)
		}
		dx += d
	}
	return p.Stroke(r, ButtCap, MiterJoin, Tolerance)
}

func (sawtoothUnderline) String() string {
	return "SawtoothUnderline"
}