updates

Author: seehuhn

examples/font/cff-glyphs/main.go

@@ -222,7 +222,7 @@ func (ctx *illustrator) Show(fnt *cff.Font, pageSize *pdf.Rectangle) error {
 		page.TextFirstLine(ctx.pageSize.LLx+22, ctx.pageSize.URy-30)
 		page.TextShow(strings.Join(label, ", "))
 		if g.Name != "" {
-			rr := names.ToUnicode(g.Name, false)
+			rr := []rune(names.ToUnicode(g.Name, ""))
 			if len(rr) == 1 {
 				runeName := runenames.Name(rr[0])
 				page.TextSecondLine(0, -15)

examples/viewer-tests/ttf-encoding/font.go

@@ -208,7 +208,7 @@ func (fb *fontBuilder) BuildFont(enc *encInfo) (font.Font, error) {
 		for i := range 3 {
 			code := markerString[i]
 			name := pdfenc.WinAnsi.Encoding[code]
-			uni := names.ToUnicode(name, false)
+			uni := names.ToUnicode(name, "")
 			if len(uni) != 1 {
 				panic(fmt.Sprintf("expected 1 rune for %s, got %d", name, len(uni)))
 			}

font/cff/composite.go

@@ -172,7 +172,10 @@ func (e *embeddedComposite) Finish(rm *pdf.ResourceManager) error {
 			m[code] = val.Text
 		}
 	}
-	toUnicode := cmap.NewToUnicodeFile(e.CIDEncoder.Codec(), m)
+	toUnicode, err := cmap.NewToUnicodeFile(e.CIDEncoder.Codec().CodeSpaceRange(), m)
+	if err != nil {
+		return err
+	}
 
 	// Simple CFF fonts can only have one private dict, and ...
 	canUseSimple := len(subsetOutlines.Private) == 1
@@ -230,13 +233,8 @@ func (e *embeddedComposite) Finish(rm *pdf.ResourceManager) error {
 
 	isSymbolic := false
 	for _, info := range e.CIDEncoder.MappedCodes() {
-		// TODO(voss): if the font is simple, use the existing glyph names
-		rr := []rune(info.Text)
-		if len(rr) != 1 {
-			isSymbolic = true
-			break
-		}
-		glyphName := names.FromUnicode(rr[0])
+		// TODO(voss): if the font is simple, use the existing glyph names?
+		glyphName := names.FromUnicode(info.Text)
 		if !pdfenc.StandardLatin.Has[glyphName] {
 			isSymbolic = true
 			break
@@ -284,7 +282,7 @@ func (e *embeddedComposite) Finish(rm *pdf.ResourceManager) error {
 		FontRef:         rm.Out.Alloc(),
 	}
 
-	err := dict.WriteToPDF(rm, e.Ref)
+	err = dict.WriteToPDF(rm, e.Ref)
 	if err != nil {
 		return err
 	}

font/cff/simple.go

@@ -18,27 +18,18 @@ package cff
 
 import (
 	"fmt"
-	"iter"
 	"math"
-	"math/bits"
-	"slices"
-	"strings"
-
-	"golang.org/x/exp/maps"
 
 	"seehuhn.de/go/geom/matrix"
 
-	"seehuhn.de/go/postscript/cid"
-	"seehuhn.de/go/postscript/type1/names"
-
 	"seehuhn.de/go/sfnt/cff"
 	"seehuhn.de/go/sfnt/glyph"
 	"seehuhn.de/go/sfnt/os2"
 
 	"seehuhn.de/go/pdf"
 	"seehuhn.de/go/pdf/font"
 	"seehuhn.de/go/pdf/font/dict"
-	"seehuhn.de/go/pdf/font/encoding"
+	"seehuhn.de/go/pdf/font/encoding/simpleenc"
 	"seehuhn.de/go/pdf/font/glyphdata"
 	"seehuhn.de/go/pdf/font/glyphdata/cffglyphs"
 	"seehuhn.de/go/pdf/font/pdfenc"
@@ -69,183 +60,16 @@ type embeddedSimple struct {
 	CapHeight float64 // PDF glyph space units
 	XHeight   float64 // PDF glyph space units
 
-	gd       *GlyphData
-	finished bool
-}
-
-type codeInfo struct {
-	Width float64
-	Text  string
-}
-
-type GlyphData struct {
-	code          map[glyphKey]byte
-	info          map[byte]*codeInfo
-	notdef        *codeInfo
-	GlyphName     map[glyph.ID]string
-	glyphNameUsed map[string]bool
-
-	isZapfDingbats bool
-	encoding       *pdfenc.Encoding
-}
+	*simpleenc.Simple
 
-type glyphKey struct {
-	gid  glyph.ID
-	text string
-}
-
-// newGlyphData creates a glyphData and registers the .notdef glyph.
-func newGlyphData(notdefWidth float64, isZapfDingbats bool, base *pdfenc.Encoding) *GlyphData {
-	gd := &GlyphData{
-		code:           make(map[glyphKey]byte),
-		info:           make(map[byte]*codeInfo),
-		notdef:         &codeInfo{Width: notdefWidth},
-		GlyphName:      make(map[glyph.ID]string),
-		glyphNameUsed:  make(map[string]bool),
-		isZapfDingbats: isZapfDingbats,
-		encoding:       base,
-	}
-	gd.GlyphName[0] = ".notdef"
-	gd.glyphNameUsed[".notdef"] = true
-	return gd
-}
-
-// GetCode looks up the code for a (gid,text) pair, returning the code byte
-// and whether it already exists.
-func (gd *GlyphData) GetCode(gid glyph.ID, text string) (byte, bool) {
-	k := glyphKey{gid: gid, text: text}
-	c, ok := gd.code[k]
-	return c, ok
-}
-
-// new method added to GlyphData
-func (gd *GlyphData) SetCode(gid glyph.ID, text string, c byte) {
-	gd.code[glyphKey{gid: gid, text: text}] = c
-}
-
-// GetData returns the CID, width and text for the given code,
-// substituting .notdef if it doesn't exist.
-func (gd *GlyphData) GetData(c byte) (cid.CID, float64, string) {
-	info, ok := gd.info[c]
-	if !ok {
-		info = gd.notdef
-		return 0, info.Width, info.Text
-	}
-	return cid.CID(c) + 1, info.Width, info.Text
-}
-
-// AllocateCode finds a free code slot (0–255) for the glyph, then stores the
-// corresponding codeInfo in gd.info.
-func (gd *GlyphData) AllocateCode(gid glyph.ID, defaultGlyphName, text string, width float64) byte {
-	if len(gd.code) >= 256 {
-		return 0
-	}
-
-	glyphName := gd.makeGlyphName(gid, defaultGlyphName, text)
-
-	var r rune
-	rr := names.ToUnicode(glyphName, gd.isZapfDingbats)
-	if len(rr) > 0 {
-		r = rr[0]
-	}
-	bestScore := -1
-	bestCode := byte(0)
-	for codeInt := 0; codeInt < 256; codeInt++ {
-		code := byte(codeInt)
-		if _, used := gd.info[code]; used {
-			continue
-		}
-		score := 0
-		stdName := gd.encoding.Encoding[code]
-		if stdName == glyphName {
-			bestCode = code
-			break
-		} else if stdName == ".notdef" || stdName == "" {
-			score += 100
-		} else if !(code == 32 && glyphName != "space") {
-			score += 10
-		}
-		score += bits.TrailingZeros16(uint16(r) ^ uint16(code))
-		if score > bestScore {
-			bestScore = score
-			bestCode = code
-		}
-	}
-	gd.info[bestCode] = &codeInfo{Width: width, Text: text}
-	return bestCode
-}
-
-// makeGlyphName returns a name for the given glyph, adding any needed suffix.
-func (gd *GlyphData) makeGlyphName(gid glyph.ID, defaultGlyphName, text string) string {
-	if name, ok := gd.GlyphName[gid]; ok {
-		return name
-	}
-	name := defaultGlyphName
-	if name == "" {
-		var parts []string
-		for _, r := range text {
-			parts = append(parts, names.FromUnicode(r))
-		}
-		if len(parts) > 0 {
-			name = strings.Join(parts, "_")
-		}
-	}
-	alt := 0
-	base := name
-nameLoop:
-	for {
-		if len(name) <= 31 && !gd.glyphNameUsed[name] {
-			break
-		}
-		if len(name) > 31 {
-			for idx := len(gd.glyphNameUsed); idx >= 0; idx-- {
-				name = fmt.Sprintf("orn%03d", idx)
-				if !gd.glyphNameUsed[name] {
-					break nameLoop
-				}
-			}
-		}
-		alt++
-		name = fmt.Sprintf("%s.alt%d", base, alt)
-	}
-	gd.GlyphName[gid] = name
-	gd.glyphNameUsed[name] = true
-	return name
-}
-
-// Overflow checks if more than 256 codes have been allocated.
-func (gd *GlyphData) Overflow() bool {
-	return len(gd.code) > 256
-}
-
-// Subset returns a sorted list of the glyphs used in this encoding.
-func (gd *GlyphData) Subset() []glyph.ID {
-	gidIsUsed := make(map[glyph.ID]struct{})
-	gidIsUsed[0] = struct{}{} // always include .notdef
-	for k := range gd.code {
-		gidIsUsed[k.gid] = struct{}{}
-	}
-	glyphs := maps.Keys(gidIsUsed)
-	slices.Sort(glyphs)
-	return glyphs
-}
-
-func (gd *GlyphData) Encoding() encoding.Simple {
-	enc := make(map[byte]string)
-	for k, c := range gd.code {
-		enc[c] = gd.GlyphName[k.gid]
-	}
-	return func(c byte) string { return enc[c] }
-}
-
-func (gd *GlyphData) MissingWidth() float64 {
-	return gd.notdef.Width
+	finished bool
 }
 
 func newEmbeddedSimple(ref pdf.Reference, f *Instance) *embeddedSimple {
 	e := &embeddedSimple{
-		Ref:       ref,
-		Font:      f.Font,
+		Ref:  ref,
+		Font: f.Font,
+
 		Stretch:   f.Stretch,
 		Weight:    f.Weight,
 		IsSerif:   f.IsSerif,
@@ -255,44 +79,33 @@ func newEmbeddedSimple(ref pdf.Reference, f *Instance) *embeddedSimple {
 		Leading:   f.Leading,
 		CapHeight: f.CapHeight,
 		XHeight:   f.XHeight,
-		gd: newGlyphData(
+
+		Simple: simpleenc.NewSimple(
 			math.Round(f.Font.GlyphWidthPDF(0)),
-			f.Font.FontName == "ZapfDingbats",
+			f.Font.FontName,
 			&pdfenc.WinAnsi,
 		),
 	}
-
 	return e
 }
 
-func (*embeddedSimple) WritingMode() font.WritingMode {
-	return font.Horizontal
-}
-
-func (e *embeddedSimple) Codes(s pdf.String) iter.Seq[*font.Code] {
-	return func(yield func(*font.Code) bool) {
-		var code font.Code
-		for _, c := range s {
-			code.CID, code.Width, code.Text = e.gd.GetData(c)
-			code.UseWordSpacing = (c == 0x20)
-			if !yield(&code) {
-				return
-			}
-		}
-	}
-}
-
 func (e *embeddedSimple) AppendEncoded(s pdf.String, gid glyph.ID, text string) (pdf.String, float64) {
-	c, ok := e.gd.GetCode(gid, text)
+	c, ok := e.Simple.GetCode(gid, text)
 	if !ok {
-		if !e.finished {
-			width := math.Round(e.Font.GlyphWidthPDF(gid))
-			c = e.gd.AllocateCode(gid, e.Font.Outlines.Glyphs[gid].Name, text, width)
+		if e.finished {
+			return s, 0
+		}
+
+		glyphName := e.Font.Outlines.Glyphs[gid].Name
+		width := math.Round(e.Font.GlyphWidthPDF(gid))
+		var err error
+		c, err = e.Simple.AllocateCode(gid, glyphName, text, width)
+		if err != nil {
+			return s, 0
 		}
-		e.gd.SetCode(gid, text, c)
 	}
 
-	_, w, _ := e.gd.GetData(c)
+	w := e.Simple.Width(c)
 	return append(s, c), w / 1000
 }
 
@@ -302,16 +115,17 @@ func (e *embeddedSimple) Finish(rm *pdf.ResourceManager) error {
 	}
 	e.finished = true
 
-	if e.gd.Overflow() {
-		return fmt.Errorf("too many distinct glyphs used in font %q", e.Font.FontName)
+	if err := e.Simple.Error(); err != nil {
+		return pdf.Errorf("font %q: %w", e.Font.FontName, err)
 	}
 
 	fontInfo := e.Font.FontInfo
 	outlines := e.Font.Outlines
 
 	// subset the font, if needed
-	glyphs := e.gd.Subset()
+	glyphs := e.Simple.Glyphs()
 	subsetTag := subset.Tag(glyphs, outlines.NumGlyphs())
+
 	var subsetOutlines *cff.Outlines
 	if subsetTag != "" {
 		subsetOutlines = outlines.Subset(glyphs)
@@ -332,7 +146,7 @@ func (e *embeddedSimple) Finish(rm *pdf.ResourceManager) error {
 	subsetOutlines.FontMatrices = nil
 	for gid, origGID := range glyphs { // fill in the glyph names
 		g := subsetOutlines.Glyphs[gid]
-		glyphName := e.gd.GlyphName[origGID]
+		glyphName := e.Simple.GlyphName(origGID)
 		if g.Name == glyphName {
 			continue
 		}
@@ -357,7 +171,7 @@ func (e *embeddedSimple) Finish(rm *pdf.ResourceManager) error {
 		if gid == 0 {
 			continue
 		}
-		if !pdfenc.StandardLatin.Has[e.gd.GlyphName[gid]] {
+		if !pdfenc.StandardLatin.Has[e.Simple.GlyphName(gid)] {
 			isSymbolic = true
 			break
 		}
@@ -386,18 +200,19 @@ func (e *embeddedSimple) Finish(rm *pdf.ResourceManager) error {
 		XHeight:      e.XHeight,
 		StemV:        math.Round(subsetCFF.Private[0].StdVW * qh),
 		StemH:        math.Round(subsetCFF.Private[0].StdHW * qv),
-		MissingWidth: e.gd.MissingWidth(),
+		MissingWidth: e.Simple.DefaultWidth(),
 	}
 	dict := dict.Type1{
 		PostScriptName: e.Font.FontName,
 		SubsetTag:      subsetTag,
 		Descriptor:     fd,
-		Encoding:       e.gd.Encoding(),
+		Encoding:       e.Simple.Encoding(),
 		FontType:       glyphdata.CFFSimple,
 		FontRef:        rm.Out.Alloc(),
 	}
-	for c := range 256 {
-		_, dict.Width[c], dict.Text[c] = e.gd.GetData(byte(c))
+	for c, info := range e.Simple.MappedCodes() {
+		dict.Width[c] = info.Width
+		dict.Text[c] = info.Text
 	}
 
 	err := dict.WriteToPDF(rm, e.Ref)