Font

Font rasterizes all text in a document and handles the wrapping and positionion of text within a texture.

flowchart LR;
    LoadFont-->State.Text.Font;
    State.Text.Font-->State;
    State-->Render;

# GetFontPath?(go)

# tryLoadSystemFont?(go)

# sortByLength?(go)

# GetFontSize?(go)

# LoadFont?(go)

# MeasureText?(go)

# MeasureSpace?(go)

# MeasureLongest?(go)

# getSystemFonts?(go)

# getWindowsFontPaths?(go)

# getMacFontPaths?(go)

# getLinuxFontPaths?(go)

# getFontsRecursively?(go)

# Render?(go)

# drawString?(go)

# wrap?(go)

# drawLine?(go)

# getLines?(go)

  1package font
  2
  3import (
  4	"fmt"
  5	"gui/element"
  6	"image"
  7	"image/color"
  8	"image/draw"
  9	"io/ioutil"
 10	"os"
 11	"path/filepath"
 12	"runtime"
 13	"sort"
 14	"strconv"
 15	"strings"
 16
 17	"github.com/golang/freetype/truetype"
 18	"golang.org/x/image/font"
 19	"golang.org/x/image/math/fixed"
 20)
 21
 22// LoadSystemFont loads a font from the system fonts directory or loads a specific font by name
 23func GetFontPath(fontName string, bold, italic bool) string {
 24
 25	if len(fontName) == 0 {
 26		fontName = "serif"
 27	}
 28
 29	// Check if a special font family is requested
 30	switch fontName {
 31	case "sans-serif":
 32		return tryLoadSystemFont("Arial", bold, italic)
 33	case "monospace":
 34		return tryLoadSystemFont("Andle Mono", bold, italic)
 35	case "serif":
 36		return tryLoadSystemFont("Georgia", bold, italic)
 37	}
 38
 39	// Use the default font if the specified font is not found
 40	return tryLoadSystemFont(fontName, bold, italic)
 41}
 42
 43var allFonts, _ = getSystemFonts()
 44
 45func tryLoadSystemFont(fontName string, bold, italic bool) string {
 46	font := fontName
 47	if bold {
 48		font += " Bold"
 49	}
 50	if italic {
 51		font += " Italic"
 52	}
 53	for _, v := range allFonts {
 54		if strings.Contains(v, "/"+font) {
 55			return v
 56		}
 57	}
 58
 59	return ""
 60}
 61
 62func sortByLength(strings []string) {
 63	sort.Slice(strings, func(i, j int) bool {
 64		return len(strings[i]) < len(strings[j])
 65	})
 66}
 67
 68func GetFontSize(css map[string]string) float32 {
 69	fL := len(css["font-size"])
 70
 71	var fs float32 = 16
 72
 73	if fL > 0 {
 74		if css["font-size"][fL-2:] == "px" {
 75			fs64, _ := strconv.ParseFloat(css["font-size"][0:fL-2], 32)
 76			fs = float32(fs64)
 77		}
 78		if css["font-size"][fL-2:] == "em" {
 79			fs64, _ := strconv.ParseFloat(css["font-size"][0:fL-2], 32)
 80			fs = float32(fs64)
 81		}
 82	}
 83
 84	return fs
 85}
 86
 87func LoadFont(fontName string, fontSize int, bold, italic bool) (font.Face, error) {
 88	// Use a TrueType font file for the specified font name
 89	fontFile := GetFontPath(fontName, bold, italic)
 90
 91	// Read the font file
 92	fontData, err := os.ReadFile(fontFile)
 93	if err != nil {
 94		return nil, err
 95	}
 96
 97	// Parse the TrueType font data
 98	fnt, err := truetype.Parse(fontData)
 99	if err != nil {
100		return nil, err
101	}
102
103	options := truetype.Options{
104		Size:    float64(fontSize),
105		DPI:     72,
106		Hinting: font.HintingNone,
107	}
108
109	// Create a new font face with the specified size
110	return truetype.NewFace(fnt, &options), nil
111}
112
113func MeasureText(s *element.State, text string) int {
114	t := s.Text
115	var width fixed.Int26_6
116
117	for _, runeValue := range text {
118		if runeValue == ' ' {
119			// Handle spaces separately, add word spacing
120			width += fixed.I(t.WordSpacing)
121		} else {
122			adv, ok := t.Font.GlyphAdvance(runeValue)
123			if !ok {
124				continue
125			}
126
127			// Update the total width with the glyph advance and bounds
128			width += adv + fixed.I(t.LetterSpacing)
129		}
130	}
131
132	return width.Round()
133}
134
135func getSystemFonts() ([]string, error) {
136	var fontPaths []string
137
138	switch runtime.GOOS {
139	case "windows":
140		fontPaths = append(fontPaths, getWindowsFontPaths()...)
141	case "darwin":
142		fontPaths = append(fontPaths, getMacFontPaths()...)
143	case "linux":
144		fontPaths = append(fontPaths, getLinuxFontPaths()...)
145	default:
146		return nil, fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
147	}
148
149	sortByLength(fontPaths)
150
151	return fontPaths, nil
152}
153
154func getWindowsFontPaths() []string {
155	var fontPaths []string
156
157	// System Fonts
158	systemFontsDir := "C:\\Windows\\Fonts"
159	getFontsRecursively(systemFontsDir, &fontPaths)
160
161	// User Fonts
162	userFontsDir := os.ExpandEnv("%APPDATA%\\Microsoft\\Windows\\Fonts")
163	getFontsRecursively(userFontsDir, &fontPaths)
164
165	return fontPaths
166}
167
168func getMacFontPaths() []string {
169	var fontPaths []string
170
171	// System Fonts
172	systemFontsDirs := []string{"/System/Library/Fonts", "/Library/Fonts"}
173	for _, dir := range systemFontsDirs {
174		getFontsRecursively(dir, &fontPaths)
175	}
176
177	// User Fonts
178	userFontsDir := filepath.Join(os.Getenv("HOME"), "Library/Fonts")
179	getFontsRecursively(userFontsDir, &fontPaths)
180
181	return fontPaths
182}
183
184func getLinuxFontPaths() []string {
185	var fontPaths []string
186
187	// System Fonts
188	systemFontsDirs := []string{"/usr/share/fonts", "/usr/local/share/fonts"}
189	for _, dir := range systemFontsDirs {
190		getFontsRecursively(dir, &fontPaths)
191	}
192
193	// User Fonts
194	userFontsDir := filepath.Join(os.Getenv("HOME"), ".fonts")
195	getFontsRecursively(userFontsDir, &fontPaths)
196
197	return fontPaths
198}
199
200func getFontsRecursively(dir string, fontPaths *[]string) {
201	files, err := ioutil.ReadDir(dir)
202	if err != nil {
203		fmt.Println("Error reading directory:", err)
204		return
205	}
206
207	for _, file := range files {
208		path := filepath.Join(dir, file.Name())
209		if file.IsDir() {
210			getFontsRecursively(path, fontPaths)
211		} else if strings.HasSuffix(strings.ToLower(file.Name()), ".ttf") {
212			*fontPaths = append(*fontPaths, path)
213		}
214	}
215}
216
217func Render(s *element.State) (*image.RGBA, int) {
218	t := &s.Text
219	// fmt.Println(lines)
220
221	if t.LineHeight == 0 {
222		t.LineHeight = t.EM + 3
223	}
224
225	width := MeasureText(s, t.Text+" ")
226
227	// Use fully transparent color for the background
228	img := image.NewRGBA(image.Rect(0, 0, width, t.LineHeight))
229
230	// fmt.Println(t.Width, t.LineHeight, (len(lines)))
231
232	r, g, b, a := t.Color.RGBA()
233
234	draw.Draw(img, img.Bounds(), &image.Uniform{color.RGBA{uint8(r), uint8(g), uint8(b), uint8(0)}}, image.Point{}, draw.Over)
235	// fmt.Println(int(t.Font.Metrics().Ascent))
236	dot := fixed.Point26_6{X: fixed.I(0), Y: (fixed.I(t.LineHeight+(t.EM/2)) / 2)}
237
238	dr := &font.Drawer{
239		Dst:  img,
240		Src:  &image.Uniform{color.RGBA{uint8(r), uint8(g), uint8(b), uint8(a)}},
241		Face: t.Font,
242		Dot:  dot,
243	}
244	t.Image = img
245
246	drawString(*t, dr, t.Text, width)
247
248	return t.Image, width
249}
250
251func drawString(t element.Text, dr *font.Drawer, v string, lineWidth int) {
252	underlinePosition := dr.Dot
253	for _, ch := range v {
254		if ch == ' ' {
255			// Handle spaces separately, add word spacing
256			dr.Dot.X += fixed.I(t.WordSpacing)
257		} else {
258			dr.DrawString(string(ch))
259			dr.Dot.X += fixed.I(t.LetterSpacing)
260		}
261	}
262	if t.Underlined || t.Overlined || t.LineThrough {
263
264		underlinePosition.X = 0
265		baseLineY := underlinePosition.Y
266
267		if t.Underlined {
268			underlinePosition.Y = baseLineY + t.Font.Metrics().Descent
269			drawLine(t.Image, underlinePosition, fixed.Int26_6(lineWidth), t.DecorationThickness, t.DecorationColor)
270		}
271		if t.LineThrough {
272			underlinePosition.Y = baseLineY - (t.Font.Metrics().Descent)
273			drawLine(t.Image, underlinePosition, fixed.Int26_6(lineWidth), t.DecorationThickness, t.DecorationColor)
274		}
275		if t.Overlined {
276			underlinePosition.Y = baseLineY - t.Font.Metrics().Descent*3
277			drawLine(t.Image, underlinePosition, fixed.Int26_6(lineWidth), t.DecorationThickness, t.DecorationColor)
278		}
279	}
280}
281
282func drawLine(img draw.Image, start fixed.Point26_6, width fixed.Int26_6, thickness int, col color.Color) {
283	// Bresenham's line algorithm
284	x0, y0 := start.X.Round(), start.Y.Round()
285	x1 := x0 + int(width)
286	y1 := y0
287	dx := abs(x1 - x0)
288	dy := abs(y1 - y0)
289	sx, sy := 1, 1
290
291	if x0 > x1 {
292		sx = -1
293	}
294	if y0 > y1 {
295		sy = -1
296	}
297
298	err := dx - dy
299
300	for {
301		for i := 0; i < thickness; i++ {
302			img.Set(x0, (y0-(thickness/2))+i, col)
303		}
304
305		if x0 == x1 && y0 == y1 {
306			break
307		}
308
309		e2 := 2 * err
310		if e2 > -dy {
311			err -= dy
312			x0 += sx
313		}
314		if e2 < dx {
315			err += dx
316			y0 += sy
317		}
318	}
319}
320
321func abs(x int) int {
322	if x < 0 {
323		return -x
324	}
325	return x
326}
327
328func Min(a, b float32) float32 {
329	if a < b {
330		return a
331	} else {
332		return b
333	}
334}