Avoid outputing invalid Encoding name for generated standard fonts (use font encoding instead)

pdf/internal/textencoding/simple.go

@@ -171,7 +171,11 @@ func (se SimpleEncoder) GlyphToRune(glyph string) (rune, bool) {
 // ToPdfObject returns `se` as a PdfObject
 func (se SimpleEncoder) ToPdfObject() core.PdfObject {
 	if se.differences == nil || len(se.differences) == 0 {
-		return core.MakeName(se.baseName)
+		switch se.baseName {
+		case "MacRomanEncoding", "MacExpertEncoding", "WinAnsiEncoding":
+			return core.MakeName(se.baseName)
+		}
+		return nil // Use font's built-in encoding.
 	}
 	dict := core.MakeDict()
 	dict.Set("Type", core.MakeName("Encoding"))

pdf/model/font_simple.go

@@ -300,7 +300,10 @@ func (font *pdfFontSimple) ToPdfObject() core.PdfObject {
 	if font.Encoding != nil {
 		d.Set("Encoding", font.Encoding)
 	} else if font.encoder != nil {
-		d.Set("Encoding", font.encoder.ToPdfObject())
+		encObj := font.encoder.ToPdfObject()
+		if encObj != nil {
+			d.Set("Encoding", encObj)
+		}
 	}
 
 	return font.container

pdf/model/font_test.go

@@ -147,8 +147,51 @@ func TestSimpleFonts(t *testing.T) {
 	}
 }
 
+// TestStandardFontDict tests PDF object output of standard font.
+// Importantly, this test makes sure that the output dictionary does not have an `Encoding`
+// key and uses the encoding of the standard font (ZapfEncoding in this case).
+func TestStandardFontOutputDict(t *testing.T) {
+	zapfdb, err := model.NewStandard14Font(model.ZapfDingbats)
+	if err != nil {
+		t.Fatalf("Error: %v", err)
+	}
+
+	dict, ok := core.GetDict(zapfdb.ToPdfObject())
+	if !ok {
+		t.Fatalf("not a dict")
+	}
+
+	if len(dict.Keys()) != 3 {
+		t.Fatalf("Incorrect number of keys (%d)", len(dict.Keys()))
+	}
+
+	ntype, ok := core.GetName(dict.Get("Type"))
+	if !ok {
+		t.Fatalf("invalid Type")
+	}
+	if ntype.String() != "Font" {
+		t.Fatalf("Type != Font (%s)", ntype.String())
+	}
+
+	basef, ok := core.GetName(dict.Get("BaseFont"))
+	if !ok {
+		t.Fatalf("Invalid BaseFont")
+	}
+	if basef.String() != "ZapfDingbats" {
+		t.Fatalf("BaseFont != ZapfDingbats (%s)", basef.String())
+	}
+
+	subtype, ok := core.GetName(dict.Get("Subtype"))
+	if !ok {
+		t.Fatalf("Invalid Subtype")
+	}
+	if subtype.String() != "Type1" {
+		t.Fatalf("Subtype != Type1 (%s)", subtype.String())
+	}
+}
+
 // Test loading a standard font from object and check the encoding and glyph metrics.
-func TestStandardFontEncodings(t *testing.T) {
+func TestLoadStandardFontEncodings(t *testing.T) {
 	raw := `
 	1 0 obj
 	<< /Type /Font