Some text improvements including falling back to system fonts

internal/painter/font.go

@@ -11,11 +11,15 @@ import (
  "github.com/go-text/render"
  "github.com/go-text/typesetting/di"
  "github.com/go-text/typesetting/font"
+ "github.com/go-text/typesetting/fontscan"
+ "github.com/go-text/typesetting/language"
+ "github.com/go-text/typesetting/opentype/api/metadata"
  "github.com/go-text/typesetting/shaping"
  "golang.org/x/image/math/fixed"
 
  "fyne.io/fyne/v2"
  "fyne.io/fyne/v2/internal/cache"
+ "fyne.io/fyne/v2/lang"
  "fyne.io/fyne/v2/theme"
 )
 
@@ -26,40 +30,103 @@ const (
  fontTabSpaceSize = 10
 )
 
+var (
+ fm *fontscan.FontMap
+ mapLock = sync.Mutex{}
+ load sync.Once
+)
+
+func loadMap() {
+ fm = fontscan.NewFontMap(noopLogger{})
+ err := loadSystemFonts(fm)
+ if err != nil {
+ fm = nil // just don't fallback
+ }
+}
+
+func lookupLangFont(family string, aspect metadata.Aspect) font.Face {
+ mapLock.Lock()
+ defer mapLock.Unlock()
+ load.Do(loadMap)
+ if fm == nil {
+ return nil
+ }
+
+ fm.SetQuery(fontscan.Query{Families: []string{family}, Aspect: aspect})
+ l, _ := fontscan.NewLangID(language.Language(lang.SystemLocale().LanguageString()))
+ return fm.ResolveFaceForLang(l)
+}
+
+func lookupRuneFont(r rune, family string, aspect metadata.Aspect) font.Face {
+ mapLock.Lock()
+ defer mapLock.Unlock()
+ load.Do(loadMap)
+ if fm == nil {
+ return nil
+ }
+
+ fm.SetQuery(fontscan.Query{Families: []string{family}, Aspect: aspect})
+ return fm.ResolveFace(r)
+}
+
+func lookupFaces(theme, fallback fyne.Resource, family string, style fyne.TextStyle) (faces *dynamicFontMap) {
+ f1 := loadMeasureFont(theme)
+ if theme == fallback {
+ faces = &dynamicFontMap{family: family, faces: []font.Face{f1}}
+ } else {
+ f2 := loadMeasureFont(fallback)
+ faces = &dynamicFontMap{family: family, faces: []font.Face{f1, f2}}
+ }
+
+ aspect := metadata.Aspect{Style: metadata.StyleNormal}
+ if style.Italic {
+ aspect.Style = metadata.StyleItalic
+ }
+ if style.Bold {
+ aspect.Weight = metadata.WeightBold
+ }
+
+ local := lookupLangFont(family, aspect)
+ if local != nil {
+ faces.addFace(local)
+ }
+
+ return faces
+}
+
 // CachedFontFace returns a Font face held in memory. These are loaded from the current theme.
 func CachedFontFace(style fyne.TextStyle, fontDP float32, texScale float32) *FontCacheItem {
  val, ok := fontCache.Load(style)
  if !ok {
- var f1, f2 font.Face
+ var faces *dynamicFontMap
  switch {
  case style.Monospace:
- f1 = loadMeasureFont(theme.TextMonospaceFont())
- f2 = loadMeasureFont(theme.DefaultTextMonospaceFont())
+ faces = lookupFaces(theme.TextMonospaceFont(), theme.DefaultTextMonospaceFont(), fontscan.Monospace, style)
  case style.Bold:
  if style.Italic {
- f1 = loadMeasureFont(theme.TextBoldItalicFont())
- f2 = loadMeasureFont(theme.DefaultTextBoldItalicFont())
+ faces = lookupFaces(theme.TextBoldItalicFont(), theme.DefaultTextBoldItalicFont(), fontscan.SansSerif, style)
  } else {
- f1 = loadMeasureFont(theme.TextBoldFont())
- f2 = loadMeasureFont(theme.DefaultTextBoldFont())
+ faces = lookupFaces(theme.TextBoldFont(), theme.DefaultTextBoldFont(), fontscan.SansSerif, style)
  }
  case style.Italic:
- f1 = loadMeasureFont(theme.TextItalicFont())
- f2 = loadMeasureFont(theme.DefaultTextItalicFont())
+ faces = lookupFaces(theme.TextItalicFont(), theme.DefaultTextItalicFont(), fontscan.SansSerif, style)
  case style.Symbol:
- f1 = loadMeasureFont(theme.SymbolFont())
- f2 = loadMeasureFont(theme.DefaultSymbolFont())
+ th := theme.SymbolFont()
+ fallback := theme.DefaultSymbolFont()
+ f1 := loadMeasureFont(th)
+
+ if th == fallback {
+ faces = &dynamicFontMap{family: fontscan.SansSerif, faces: []font.Face{f1}}
+ } else {
+ f2 := loadMeasureFont(fallback)
+ faces = &dynamicFontMap{family: fontscan.SansSerif, faces: []font.Face{f1, f2}}
+ }
  default:
- f1 = loadMeasureFont(theme.TextFont())
- f2 = loadMeasureFont(theme.DefaultTextFont())
+ faces = lookupFaces(theme.TextFont(), theme.DefaultTextFont(), fontscan.SansSerif, style)
  }
 
- if f1 == nil {
- f1 = f2
- }
- faces := []font.Face{f1, f2}
- if emoji := theme.DefaultEmojiFont(); emoji != nil {
- faces = append(faces, loadMeasureFont(emoji))
+ if emoji := theme.DefaultEmojiFont(); !style.Symbol && emoji != nil {
+ faces.addFace(loadMeasureFont(emoji)) // TODO only one emoji - maybe others too
  }
  val = &FontCacheItem{Fonts: faces}
  fontCache.Store(style, val)
@@ -75,29 +142,22 @@ func ClearFontCache() {
 }
 
 // DrawString draws a string into an image.
-func DrawString(dst draw.Image, s string, color color.Color, f []font.Face, fontSize, scale float32, tabWidth int) {
+func DrawString(dst draw.Image, s string, color color.Color, f shaping.Fontmap, fontSize, scale float32, style fyne.TextStyle) {
  r := render.Renderer{
  FontSize: fontSize,
  PixScale: scale,
  Color: color,
  }
 
- // TODO avoid shaping twice!
- sh := &shaping.HarfbuzzShaper{}
- out := sh.Shape(shaping.Input{
- Text: []rune(s),
- RunStart: 0,
- RunEnd: len(s),
- Face: f[0],
- Size: fixed.I(int(fontSize * r.PixScale)),
- })
-
  advance := float32(0)
- y := int(math.Ceil(float64(fixed266ToFloat32(out.LineBounds.Ascent))))
- walkString(f, s, float32ToFixed266(fontSize), tabWidth, &advance, scale, func(run shaping.Output, x float32) {
+ y := math.MinInt
+ walkString(f, s, float32ToFixed266(fontSize), style, &advance, scale, func(run shaping.Output, x float32) {
+ if y == math.MinInt {
+ y = int(math.Ceil(float64(fixed266ToFloat32(run.LineBounds.Ascent) * r.PixScale)))
+ }
  if len(run.Glyphs) == 1 {
  if run.Glyphs[0].GlyphID == 0 {
- r.DrawStringAt(string([]rune{0xfffd}), dst, int(x), y, f[0])
+ r.DrawStringAt(string([]rune{0xfffd}), dst, int(x), y, f.ResolveFace(0xfffd))
  return
  }
  }
@@ -118,8 +178,8 @@ func loadMeasureFont(data fyne.Resource) font.Face {
 
 // MeasureString returns how far dot would advance by drawing s with f.
 // Tabs are translated into a dot location change.
-func MeasureString(f []font.Face, s string, textSize float32, tabWidth int) (size fyne.Size, advance float32) {
- return walkString(f, s, float32ToFixed266(textSize), tabWidth, &advance, 1, func(shaping.Output, float32) {})
+func MeasureString(f shaping.Fontmap, s string, textSize float32, style fyne.TextStyle) (size fyne.Size, advance float32) {
+ return walkString(f, s, float32ToFixed266(textSize), style, &advance, 1, func(shaping.Output, float32) {})
 }
 
 // RenderedTextSize looks up how big a string would be if drawn on screen.
@@ -145,7 +205,7 @@ func float32ToFixed266(f float32) fixed.Int26_6 {
 
 func measureText(text string, fontSize float32, style fyne.TextStyle) (fyne.Size, float32) {
  face := CachedFontFace(style, fontSize, 1)
- return MeasureString(face.Fonts, text, fontSize, style.TabWidth)
+ return MeasureString(face.Fonts, text, fontSize, style)
 }
 
 func tabStop(spacew, x float32, tabWidth int) float32 {
@@ -158,7 +218,7 @@ func tabStop(spacew, x float32, tabWidth int) float32 {
  return tabw * float32(tabs)
 }
 
-func walkString(faces []font.Face, s string, textSize fixed.Int26_6, tabWidth int, advance *float32, scale float32,
+func walkString(faces shaping.Fontmap, s string, textSize fixed.Int26_6, style fyne.TextStyle, advance *float32, scale float32,
  cb func(run shaping.Output, x float32)) (size fyne.Size, base float32) {
  s = strings.ReplaceAll(s, "\r", "")
 
@@ -168,7 +228,7 @@ func walkString(faces []font.Face, s string, textSize fixed.Int26_6, tabWidth in
  RunStart: 0,
  RunEnd: 1,
  Direction: di.DirectionLTR,
- Face: faces[0],
+ Face: faces.ResolveFace(' '),
  Size: textSize,
  }
  shaper := &shaping.HarfbuzzShaper{}
@@ -180,7 +240,10 @@ func walkString(faces []font.Face, s string, textSize fixed.Int26_6, tabWidth in
 
  x := float32(0)
  spacew := scale * fontTabSpaceSize
- ins := shaping.SplitByFontGlyphs(in, faces)
+ if style.Monospace {
+ spacew = scale * fixed266ToFloat32(out.Advance)
+ }
+ ins := shaping.SplitByFace(in, faces)
  for _, in := range ins {
  inEnd := in.RunEnd
 
@@ -189,10 +252,9 @@ func walkString(faces []font.Face, s string, textSize fixed.Int26_6, tabWidth in
  if r == '\t' {
  if pending {
  in.RunEnd = i
- out = shaper.Shape(in)
- x = shapeCallback(shaper, in, out, x, scale, cb)
+ x = shapeCallback(shaper, in, x, scale, cb)
  }
- x = tabStop(spacew, x, tabWidth)
+ x = tabStop(spacew, x, style.TabWidth)
 
  in.RunStart = i + 1
  in.RunEnd = inEnd
@@ -202,16 +264,16 @@ func walkString(faces []font.Face, s string, textSize fixed.Int26_6, tabWidth in
  }
  }
 
- x = shapeCallback(shaper, in, out, x, scale, cb)
+ x = shapeCallback(shaper, in, x, scale, cb)
  }
 
  *advance = x
  return fyne.NewSize(*advance, fixed266ToFloat32(out.LineBounds.LineThickness())),
  fixed266ToFloat32(out.LineBounds.Ascent)
 }
 
-func shapeCallback(shaper shaping.Shaper, in shaping.Input, out shaping.Output, x, scale float32, cb func(shaping.Output, float32)) float32 {
- out = shaper.Shape(in)
+func shapeCallback(shaper shaping.Shaper, in shaping.Input, x, scale float32, cb func(shaping.Output, float32)) float32 {
+ out := shaper.Shape(in)
  glyphs := out.Glyphs
  start := 0
  pending := false
@@ -248,7 +310,37 @@ func shapeCallback(shaper shaping.Shaper, in shaping.Input, out shaping.Output,
 }
 
 type FontCacheItem struct {
- Fonts []font.Face
+ Fonts shaping.Fontmap
 }
 
 var fontCache = &sync.Map{} // map[fyne.TextStyle]*FontCacheItem
+
+type noopLogger struct{}
+
+func (n noopLogger) Printf(string, ...interface{}) {}
+
+type dynamicFontMap struct {
+ faces []font.Face
+ family string
+}
+
+func (d *dynamicFontMap) ResolveFace(r rune) font.Face {
+
+ for _, f := range d.faces {
+ if _, ok := f.NominalGlyph(r); ok {
+ return f
+ }
+ }
+
+ toAdd := lookupRuneFont(r, d.family, metadata.Aspect{})
+ if toAdd != nil {
+ d.addFace(toAdd)
+ return toAdd
+ }
+
+ return d.faces[0]
+}
+
+func (d *dynamicFontMap) addFace(f font.Face) {
+ d.faces = append(d.faces, f)
+}

internal/painter/font_internal_test.go

@@ -1,5 +1,9 @@
+//go:build test
+
 package painter
 
+import "github.com/go-text/typesetting/fontscan"
+
 //
 //func Test_compositeFace_Close(t *testing.T) {
 // chosenFont := &truetype.Font{}
@@ -334,3 +338,7 @@ package painter
 // f.IndexInvoked = true
 // return f.IndexFunc(r)
 //}
+
+func loadSystemFonts(fm *fontscan.FontMap) error {
+ return nil
+}

internal/painter/font_prod.go

@@ -0,0 +1,21 @@
+//go:build !test
+
+package painter
+
+import (
+ "os"
+ "path/filepath"
+ "runtime"
+
+ "github.com/go-text/typesetting/fontscan"
+)
+
+func loadSystemFonts(fm *fontscan.FontMap) error {
+ cacheDir := ""
+ if runtime.GOOS == "android" {
+ parent := os.Getenv("FILESDIR")
+ cacheDir = filepath.Join(parent, "fontcache")
+ }
+
+ return fm.UseSystemFonts(cacheDir)
+}

internal/painter/font_test.go

@@ -10,6 +10,7 @@ import (
  "fyne.io/fyne/v2"
  "fyne.io/fyne/v2/canvas"
  "fyne.io/fyne/v2/internal/painter"
+ intTest "fyne.io/fyne/v2/internal/test"
  "fyne.io/fyne/v2/test"
 )
 
@@ -28,8 +29,8 @@ func TestCachedFontFace(t *testing.T) {
  t.Run(name, func(t *testing.T) {
  got := painter.CachedFontFace(tt.style, 14, 1)
  for _, r := range tt.runes {
- _, ok := got.Fonts[0].NominalGlyph(r)
- assert.True(t, ok, "symbol Font should include: %c", r)
+ f := got.Fonts.ResolveFace(r)
+ assert.NotNil(t, f, "symbol Font should include: %c", r)
  }
  })
  }
@@ -77,7 +78,9 @@ func TestDrawString(t *testing.T) {
  t.Run(name, func(t *testing.T) {
  img := image.NewNRGBA(image.Rect(0, 0, 300, 100))
  f := painter.CachedFontFace(tt.style, tt.size, 1)
- painter.DrawString(img, tt.string, tt.color, f.Fonts, tt.size, 1, tt.tabWidth)
+
+ fontMap := &intTest.FontMap{f.Fonts.ResolveFace(' ')} // first (ascii) font
+ painter.DrawString(img, tt.string, tt.color, fontMap, tt.size, 1, fyne.TextStyle{TabWidth: tt.tabWidth})
  test.AssertImageMatches(t, "font/"+tt.want, img)
  })
  }
@@ -114,8 +117,9 @@ func TestMeasureString(t *testing.T) {
  },
  } {
  t.Run(name, func(t *testing.T) {
- face := painter.CachedFontFace(tt.style, tt.size, 1)
- got, _ := painter.MeasureString(face.Fonts, tt.string, tt.size, tt.tabWidth)
+ faces := painter.CachedFontFace(tt.style, tt.size, 1)
+ fontMap := &intTest.FontMap{faces.Fonts.ResolveFace(' ')} // first (ascii) font
+ got, _ := painter.MeasureString(fontMap, tt.string, tt.size, fyne.TextStyle{TabWidth: tt.tabWidth})
  assert.Equal(t, tt.want, got.Width)
  })
  }

internal/painter/gl/texture.go

@@ -153,7 +153,7 @@ func (p *painter) newGlTextTexture(obj fyne.CanvasObject) Texture {
  img := image.NewNRGBA(image.Rect(0, 0, width, height))
 
  face := paint.CachedFontFace(text.TextStyle, text.TextSize*p.canvas.Scale(), p.texScale)
- paint.DrawString(img, text.Text, color, face.Fonts, text.TextSize, p.pixScale, text.TextStyle.TabWidth)
+ paint.DrawString(img, text.Text, color, face.Fonts, text.TextSize, p.pixScale, text.TextStyle)
  return p.imgToTexture(img, canvas.ImageScaleSmooth)
 }
 

internal/painter/software/draw.go

@@ -143,7 +143,7 @@ func drawText(c fyne.Canvas, text *canvas.Text, pos fyne.Position, base *image.N
  }
 
  face := painter.CachedFontFace(text.TextStyle, text.TextSize*c.Scale(), 1)
- painter.DrawString(txtImg, text.Text, color, face.Fonts, text.TextSize, c.Scale(), text.TextStyle.TabWidth)
+ painter.DrawString(txtImg, text.Text, color, face.Fonts, text.TextSize, c.Scale(), text.TextStyle)
 
  size := text.Size()
  offsetX := float32(0)