getSFNTMetadata bug

[jilieryuyi]

There is a bug in getSFNTMetadata the font loading on Windows is incomplete only the first name is used, and the matching method is not sound

msya.ttf names like:

[tdewolff]

Thanks for raising this issue. Could you be more explicit? I believe the current implementation only looks for English names, and perhaps you're looking for a name in another language (Chinese)? This is more work to implement than it looks like, but I'll verify what would be required to do that.

Regarding the "matching method is not sound". Why? What problem are you having apart from the above?

[jilieryuyi]

Thanks for raising this issue. Could you be more explicit? I believe the current implementation only looks for English names, and perhaps you're looking for a name in another language (Chinese)? This is more work to implement than it looks like, but I'll verify what would be required to do that.

Regarding the "matching method is not sound". Why? What problem are you having apart from the above?

What I want to express is that a font contains multiple names, and they should all support matching these names

I have made the following attempts，but it runs slowly, try to write a simple font.ParseFont api for metadata ?

func FindSystemFonts(dirs []string) (*SystemFonts, error) {
    // TODO: use concurrency
    fonts := &SystemFonts{
        Fonts: map[string]map[Style]FontMetadata{},
    }
    walkedDirs := map[string]bool{}
    walkDir := func(dir string) error {
        return fs.WalkDir(os.DirFS(dir), ".", func(path string, d fs.DirEntry, err error) error {
            path = filepath.Join(dir, path)
            if err != nil {
                return err
            } else if d.IsDir() {
                if walkedDirs[path] {
                    return filepath.SkipDir
                }
                walkedDirs[path] = true
                return nil
            } else if !d.Type().IsRegular() {
                return nil
            }

            b, err := os.ReadFile(path)
            if err != nil {
                return nil
            }
            SFNT, err := font.ParseFont(b, 0)
            if err != nil {
                return nil
            }

            var names []string
            var style string
            for id := 0; id < 25; id++ {
                for _, record := range SFNT.Name.Get(font.NameID(id)) {
                    if id == 1 || id == 4 || id == 6 {
                        names = append(names, record.String())
                    }
                    if id == int(NameFontSubfamily) || id == int(NamePreferredSubfamily) {
                        style = record.String()
                    }
                }
            }
            var metadata FontMetadata //, err := getMetadata(f)

            metadata.Filename = path
            metadata.Families = names
            metadata.Style = ParseStyle(style)

            fonts.Add(metadata)

            return nil
        })
    }

    var Err error
    for _, dir := range dirs {
        if info, err := os.Stat(dir); os.IsNotExist(err) {
            continue
        } else if !info.IsDir() {
            continue
        }

        if err := walkDir(dir); err != nil && Err == nil {
            Err = err
        }
    }
    if Err != nil {
        return nil, Err
    }
    fonts.Generics = DefaultGenericFonts()
    return fonts, nil
}

type FontMetadata struct {
    Filename string
    Families []string
    Style    Style
}

func (s *SystemFonts) Add(metadata FontMetadata) {
    for _, Family := range metadata.Families {
        if _, ok := s.Fonts[Family]; !ok {
            s.Fonts[Family] = map[Style]FontMetadata{}
        }
        s.Fonts[Family][metadata.Style] = metadata
    }
}

func (s *SystemFonts) Match(name string, style Style) (FontMetadata, bool) {
    // expand generic font names
    families := strings.Split(name, ",")
    for i := 0; i < len(families); i++ {
        families[i] = strings.TrimSpace(families[i])
        if names, ok := s.Generics[families[i]]; ok {
            families = append(families[:i], append(names, families[i+1:]...)...)
            i += len(names) - 1
        }
    }

    families = append(families, name+" "+style.String())
    // find the first font name that exists
    var metadatas []map[Style]FontMetadata

    for _, family := range families {
        metadata, _ := s.Fonts[family]
        if metadata != nil {
            metadatas = append(metadatas, metadata)
        }
    }
    if metadatas == nil {
        return FontMetadata{}, false
    }

    // exact style match
    for _, m := range metadatas {
        if metadata, ok := m[style]; ok {
            return metadata, true
        }
    }

    styles := []Style{}
    weight := style.Weight()
    if weight == Regular {
        styles = append(styles, Medium)
    } else if weight == Medium {
        styles = append(styles, Regular)
    }
    if weight == SemiBold || weight == Bold || weight == ExtraBold || weight == Black {
        for s := weight + 1; s <= Black; s++ {
            styles = append(styles, s)
        }
        for s := weight - 1; Thin <= s; s-- {
            styles = append(styles, s)
        }
    } else {
        for s := weight - 1; Thin <= s; s-- {
            styles = append(styles, s)
        }
        for s := weight + 1; s <= Black; s++ {
            styles = append(styles, s)
        }
    }

    for _, s := range styles {
        for _, m := range metadatas {
            if metadata, ok := m[style&Italic|s]; ok {
                return metadata, true
            }
        }
    }
    return FontMetadata{}, false
}

[jilieryuyi]

try to cache system fonts, run faster

// FindSystemFont finds the path to a font from the system's fonts.
func FindSystemFont(name string, style FontStyle) (string, bool) {
    systemFonts.Lock()
    if systemFonts.SystemFonts == nil {
        systemFonts.SystemFonts, _ = loadSystemFontsCache()
        if systemFonts.SystemFonts == nil {
            systemFonts.SystemFonts, _ = font.FindSystemFonts(font.DefaultFontDirs())
            saveSystemFontsCache()
        }
    }
    systemFonts.Unlock()

    font, ok := systemFonts.Match(name, font.ParseStyleCSS(style.CSS(), style.Italic()))
    return font.Filename, ok
}

func loadSystemFontsCache() (*font.SystemFonts, error) {
    cacheDir := os.TempDir()
    cacheFile := "system_fonts.json"

    c := filepath.Join(cacheDir, cacheFile)
    data, err := os.ReadFile(c)
    if err != nil {
        return nil, err
    }

    var fonts font.SystemFonts
    err = json.Unmarshal(data, &fonts)
    if err != nil {
        return nil, err
    }

    return &fonts, err
}

func saveSystemFontsCache() {
    js, err := json.Marshal(systemFonts.SystemFonts)
    if err != nil {
        return
    }

    cacheDir := os.TempDir()
    cacheFile := "system_fonts.json"

    c := filepath.Join(cacheDir, cacheFile)
    os.WriteFile(c, []byte(js), 0777)
}

[tdewolff]

It gets cached in https://github.com/tdewolff/canvas/blob/master/font.go#L192, but perhaps that should move to the font/ subpackage...