pdfrb 0.3.0 → 0.7.1

data/lib/pdfrb/document/display.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  class Document
+    # Catalog display controls. Sets viewer behavior: hide toolbar,
+    # page layout, page mode, and open-action destination.
+    #
+    # /ViewerPreferences — fine-grained viewer controls
+    # /PageLayout — how pages are laid out in the viewer
+    # /PageMode — which panels are visible on open
+    # /OpenAction — initial destination or action
+    class Display
+      PAGE_LAYOUTS = %i[
+        SinglePage OneColumn TwoColumnLeft TwoColumnRight
+        TwoPageLeft TwoPageRight
+      ].freeze
+
+      PAGE_MODES = %i[
+        UseNone UseOutlines UseThumbs FullScreen UseOC UseAttachments
+      ].freeze
+
+      NON_FULLSCREEN_PAGE_MODES = %i[UseNone UseOutlines UseThumbs UseOC].freeze
+
+      DIRECTIONS = %i[L2R R2L].freeze
+
+      attr_reader :document
+
+      def initialize(document)
+        @document = document
+      end
+
+      # @param layout [Symbol] one of PAGE_LAYOUTS.
+      def page_layout=(layout)
+        raise ArgumentError, "invalid page layout: #{layout}" unless PAGE_LAYOUTS.include?(layout)
+
+        document.catalog.value[:PageLayout] = layout
+      end
+
+      # @param mode [Symbol] one of PAGE_MODES.
+      def page_mode=(mode)
+        raise ArgumentError, "invalid page mode: #{mode}" unless PAGE_MODES.include?(mode)
+
+        document.catalog.value[:PageMode] = mode
+      end
+
+      # Set the /OpenAction destination or action.
+      # @param dest_or_action [Array, Hash, Pdfrb::Destination::Fit,
+      #   Pdfrb::Model::PdfArray] the destination array or action dict.
+      def open_action=(dest_or_action)
+        document.catalog.value[:OpenAction] = dest_or_action
+      end
+
+      # Get or set /ViewerPreferences as a keyword-hash.
+      def viewer_preferences(**opts)
+        return read_viewer_preferences if opts.empty?
+
+        vp = document.catalog.value[:ViewerPreferences]
+        vp ||= {}
+        opts.each do |key, value|
+          vp[key] = value
+        end
+        document.catalog.value[:ViewerPreferences] = vp
+      end
+
+      # Convenience: hide toolbar and menubar, fit window.
+      def presentation_mode!
+        viewer_preferences(
+          HideToolbar: true,
+          HideMenubar: true,
+          FitWindow: true,
+          CenterWindow: true,
+          DisplayDocTitle: true
+        )
+        self.page_mode = :FullScreen
+      end
+
+      private
+
+      def read_viewer_preferences
+        document.catalog.value[:ViewerPreferences] || {}
+      end
+    end
+  end
+end

data/lib/pdfrb/document/fonts.rb

@@ -1,14 +1,9 @@
 # frozen_string_literal: true
 
+require "stringio"
+
 module Pdfrb
   class Document
-    # Font facade. +add+ registers a font in the catalog /Resources
-    # (so the canvas can reference it via +Tf+) and returns the
-    # resource name to use with the canvas.
-    #
-    # Supports the 14 PDF standard Type1 fonts by name (Helvetica,
-    # Times-Roman, Courier, etc.) without embedding. Future TTF/OTF
-    # loaders (TODO 111/112) plug in via +register_loader+.
     class Fonts
       STANDARDS = %w[
         Helvetica Helvetica-Bold Helvetica-Oblique Helvetica-BoldOblique
@@ -17,78 +12,421 @@ module Pdfrb
         Symbol ZapfDingbats
       ].freeze
 
+      NO_ENCODING_FONTS = %w[Symbol ZapfDingbats].freeze
+      DEFAULT_WIDTH = 500
+
       attr_reader :document
 
       def initialize(document)
         @document = document
         @next_id = 1
-        @registry = {} # name -> resource Symbol
+        @registry = {}
+        @encodings = {}
+        @font_dicts = {}
+        @afm_metrics = {}
+        @used_codepoints = Hash.new { |h, k| h[k] = Set.new }
+        @font_streams = {}
       end
 
-      # Register a font and return the resource name (e.g. :F1).
-      #
-      # For the 14 standard fonts: pass the font name; no embedding
-      # is required. For everything else, use the loader protocol
-      # (TODO 111).
-      def add(name_or_io, **opts)
+      def add(name_or_io, **)
         name = font_name_for(name_or_io)
         cached = @registry[name]
         return cached if cached
 
         resource = next_resource_name
-        register_font(resource, name, **opts)
+        font_dict = register_font(resource, name, **)
+        @encodings[resource] = font_dict&.value&.[](:Encoding)
+        @font_dicts[resource] = font_dict
+        load_afm_metrics(resource, name)
+        if @pending_io_data
+          load_ttf_metrics(resource, @pending_io_data) unless @afm_metrics[resource]
+          @font_streams[resource] = @pending_io_data
+          @pending_io_data = nil
+        end
+        @pending_subtype = nil
+        if @afm_metrics[resource] && font_dict&.value&.[](:Widths)
+          font_dict.value[:Widths] = @afm_metrics[resource][:widths]
+        end
         @registry[name] = resource
         resource
       end
 
-      # Look up the resource name registered for a font name.
-      def [](name)
-        @registry[name]
-      end
+      def [](name); @registry[name]; end
 
-      def each(&block)
+      def each(&)
         return enum_for(:each) unless block_given?
 
-        @registry.each(&block)
+        @registry.each(&)
         self
       end
 
-      # ---- Extension point (TODOs 110-112) ----
-      #
-      # A loader is an object with `call(document, name_or_io, **opts)`
-      # that returns a Font dict + descriptor pair. Built-in loader
-      # handles the 14 standards; future loaders add TTF/OTF/CID.
-      class << self
-        def loaders
-          @loaders ||= []
+      def used_codepoints(resource); @used_codepoints[resource]; end
+      def encoding_for(resource); @encodings[resource]; end
+
+      def encode_text(text, resource)
+        text.to_s.each_codepoint { |cp| @used_codepoints[resource] << cp }
+        enc = @encodings[resource]
+        return text.to_s.b unless enc
+
+        Pdfrb::Font::Encoding.encode(enc, text.to_s)
+      end
+
+      def encodable?(text, resource); !encode_text(text, resource).include?("?"); end
+
+      def measure_text(text, font:, size:)
+        return 0 unless text && size
+
+        metrics = @afm_metrics[font]
+        return text.to_s.length * size.to_f * 0.5 unless metrics
+
+        total = text.to_s.each_char.sum do |ch|
+          byte = ch.bytes.first || 0
+          metrics[:widths][byte] || DEFAULT_WIDTH
         end
+        total * size.to_f / 1000.0
+      end
+
+      def text_width(text, _resource, size:)
+        return 0 unless text && size
+
+        res = @afm_metrics[_resource] ? _resource : (@registry[_resource.to_s] || _resource)
+        metrics = @afm_metrics[res]
+        return text.to_s.length * size.to_f * 0.5 unless metrics
+
+        upem = metrics[:units_per_em] || 1000
+        total = text.to_s.each_char.sum do |ch|
+          byte = ch.bytes.first || 0
+          metrics[:widths][byte] || DEFAULT_WIDTH
+        end
+        total * size.to_f / upem.to_f
+      end
+
+      def glyph_width(resource, codepoint)
+        metrics = @afm_metrics[resource]
+        return DEFAULT_WIDTH unless metrics
+
+        cp = codepoint.is_a?(String) ? (codepoint.each_codepoint.first || 0) : codepoint.to_i
+        return 0 if cp > 255
+
+        metrics[:widths][cp] || 0
+      end
+
+      def glyph_widths(resource, codepoints)
+        cps = codepoints.is_a?(String) ? codepoints.each_codepoint.to_a : codepoints
+        cps.map { |cp| glyph_width(resource, cp) }
+      end
+
+      def metrics_for(resource); @afm_metrics[resource]; end
+
+      def valid_font_data?(data)
+        return false unless data.is_a?(String) && data.bytesize >= 4
+
+        magic = data.byteslice(0, 4)
+        ["ttcf".b, "\x00\x01\x00\x00".b, "OTTO".b, "true".b, "typ1".b].include?(magic)
+      end
+
+      def embedded?(resource)
+        dict = @font_dicts[resource]
+        return false unless dict
+
+        desc = dict.value[:FontDescriptor]
+        return false unless desc
+
+        desc = document.object(desc) if desc.is_a?(Pdfrb::Model::Reference)
+        desc&.value&.key?(:FontFile2)
+      end
 
-        def register_loader(loader)
-          loaders.unshift(loader)
+      def subset_fonts!
+        @font_streams.each do |resource, data|
+          next unless valid_font_data?(data)
+
+          codepoints = @used_codepoints[resource]
+          next if codepoints.empty?
+
+          begin
+            ttf = Pdfrb::Font::TrueType::File.new(data)
+            subsetter = Pdfrb::Font::TrueType::Subsetter.new(ttf)
+            subset = subsetter.subset(codepoints.to_a)
+            dict = @font_dicts[resource]
+            next unless dict
+
+            desc_ref = dict.value[:FontDescriptor]
+            next unless desc_ref
+
+            desc = desc_ref.is_a?(Pdfrb::Model::Reference) ? document.object(desc_ref) : desc_ref
+            next unless desc
+
+            fd_stream = document.add({ Length: subset.bytesize }, type: Pdfrb::Model::Cos::Stream)
+            fd_stream.stream = subset
+            desc.value[:FontFile2] = Pdfrb::Model::Reference.new(fd_stream.oid, fd_stream.gen)
+          rescue StandardError
+            next
+          end
         end
       end
 
+      class << self
+        def loaders; @loaders ||= []; end
+        def register_loader(loader); loaders.unshift(loader); end
+      end
+
       register_loader ->(doc, name, **opts) {
         next nil unless STANDARDS.include?(name.to_s)
-        next nil unless opts[:embedded].nil? # standards never embed
+        next nil unless opts[:embedded].nil?
 
-        doc.add(
-          { Type: :Font, Subtype: :Type1, BaseFont: name.to_sym },
-          type: Pdfrb::Model::Type::FontType1
-        )
+        widths = Array.new(256, DEFAULT_WIDTH)
+        tu_stream = build_tounicode(doc)
+        tu_ref = Pdfrb::Model::Reference.new(tu_stream.oid, tu_stream.gen)
+        fd = doc.add({
+          Type: :FontDescriptor, FontName: name.to_sym, Flags: 32,
+          FontBBox: [0, 0, 1000, 1000], ItalicAngle: 0,
+          Ascent: 800, Descent: -200, CapHeight: 700, StemV: 80
+        }, type: Pdfrb::Model::Cos::Dictionary)
+        fd_ref = Pdfrb::Model::Reference.new(fd.oid, fd.gen)
+        font_hash = {
+          Type: :Font, Subtype: :Type1, BaseFont: name.to_sym,
+          FirstChar: 0, LastChar: 255, Widths: widths,
+          FontDescriptor: fd_ref, ToUnicode: tu_ref
+        }
+        font_hash[:Encoding] = :WinAnsiEncoding unless NO_ENCODING_FONTS.include?(name.to_s)
+        doc.add(font_hash, type: Pdfrb::Model::Type::FontType1)
       }
 
+      def self.build_tounicode(doc)
+        cmap_body = build_tounicode_cmap
+        stream = doc.add({ Length: cmap_body.bytesize }, type: Pdfrb::Model::Cos::Stream)
+        stream.stream = cmap_body
+        stream
+      end
+
+      def self.build_tounicode_cmap
+        lines = []
+        lines << "/CIDInit /ProcSet findresource begin"
+        lines << "12 dict begin"
+        lines << "begincmap"
+        lines << "/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def"
+        lines << "/CMapName /Adobe-Identity-UCS def"
+        lines << "/CMapType 2 def"
+        lines << "1 begincodespacerange"
+        lines << "<00> <FF>"
+        lines << "endcodespacerange"
+        table = Pdfrb::Font::Encoding::WinAnsiEncoding::TABLE
+        pairs = []
+        table.each_with_index { |cp, byte| pairs << format("<%02X> <%04X>", byte, cp) if cp }
+        pairs.each_slice(100) do |chunk|
+          lines << "#{chunk.length} beginbfchar"
+          lines.concat(chunk)
+          lines << "endbfchar"
+        end
+        lines << "endcmap"
+        lines << "CMapName currentdict /CMap defineresource pop"
+        lines << "end"
+        lines << "end"
+        "#{lines.join("\n")}\n"
+      end
+
       private
 
+      def load_afm_metrics(resource, name)
+        return unless STANDARDS.include?(name.to_s)
+
+        afm_path = Pdfrb::DataDir.resolve("afm", "#{name}.afm")
+        return unless File.exist?(afm_path)
+
+        begin
+          parser = Pdfrb::Font::AFMParser.from_file(afm_path)
+          widths = build_winansi_widths(parser)
+          @afm_metrics[resource] = {
+            widths: widths,
+            ascent: parser.ascender || 800,
+            descent: parser.descender || -200,
+            cap_height: parser.cap_height || 700,
+            bbox: parser.bbox || [0, 0, 1000, 1000],
+            units_per_em: 1000,
+          }
+        rescue StandardError
+          nil
+        end
+      end
+
+      def load_ttf_metrics(resource, data)
+        return unless valid_font_data?(data)
+
+        begin
+          ttf = Pdfrb::Font::TrueType::File.new(data)
+          widths = Array.new(256, DEFAULT_WIDTH)
+
+          table = Pdfrb::Font::Encoding::WinAnsiEncoding::TABLE
+          table.each_with_index do |cp, byte|
+            next unless cp
+
+            begin
+              glyph_id = ttf.cmap.glyph_id_for(cp)
+              next unless glyph_id&.positive?
+
+              w = ttf.hmtx.advance_width(glyph_id)
+              widths[byte] = w if w&.positive?
+            rescue StandardError
+              next
+            end
+          end
+
+          head = ttf.head
+          hhea = ttf.hhea
+          @afm_metrics[resource] = {
+            widths: widths,
+            ascent: hhea.ascender || 800,
+            descent: hhea.descender || -200,
+            cap_height: nil,
+            bbox: head.bbox || [0, 0, 1000, 1000],
+            units_per_em: head.units_per_em || 1000,
+          }
+        rescue StandardError
+          nil
+        end
+      end
+
+      def build_winansi_widths(parser)
+        widths = Array.new(256, DEFAULT_WIDTH)
+        (0..127).each do |byte|
+          metric = parser.char_metrics[byte]
+          widths[byte] = metric[:width].to_i if metric && metric[:width]
+        end
+        table = Pdfrb::Font::Encoding::WinAnsiEncoding::TABLE
+        (128..255).each do |byte|
+          cp = table[byte]
+          next unless cp
+
+          glyph_name = unicode_to_glyph_name(cp)
+          next unless glyph_name
+
+          metric = parser.char_metrics[glyph_name]
+          widths[byte] = metric[:width].to_i if metric && metric[:width]
+        end
+        widths
+      end
+
+      def unicode_to_glyph_name(cp)
+        return cp.chr if cp < 128
+
+        { 0x20AC => "Euro", 0x201A => "quotesinglbase", 0x0192 => "florin", 0x201E => "quotedblbase",
+          0x2026 => "ellipsis", 0x2020 => "dagger", 0x2021 => "daggerdbl", 0x02C6 => "circumflex",
+          0x2030 => "perthousand", 0x0160 => "Scaron", 0x2039 => "guilsinglleft", 0x0152 => "OE",
+          0x017D => "Zcaron", 0x2018 => "quoteleft", 0x2019 => "quoteright", 0x201C => "quotedblleft",
+          0x201D => "quotedblright", 0x2022 => "bullet", 0x2013 => "endash", 0x2014 => "emdash",
+          0x02DC => "tilde", 0x2122 => "trademark", 0x0161 => "scaron", 0x203A => "guilsinglright",
+          0x0153 => "oe", 0x017E => "zcaron", 0x0178 => "Ydieresis", 0x00A0 => "space",
+          0x00A1 => "exclamdown", 0x00A2 => "cent", 0x00A3 => "sterling", 0x00A4 => "currency",
+          0x00A5 => "yen", 0x00A6 => "brokenbar", 0x00A7 => "section", 0x00A8 => "dieresis",
+          0x00A9 => "copyright", 0x00AA => "ordfeminine", 0x00AB => "guillemotleft",
+          0x00AC => "logicalnot", 0x00AD => "hyphen", 0x00AE => "registered", 0x00AF => "macron",
+          0x00B0 => "degree", 0x00B1 => "plusminus", 0x00B2 => "twosuperior", 0x00B3 => "threesuperior",
+          0x00B4 => "acute", 0x00B5 => "mu", 0x00B6 => "paragraph", 0x00B7 => "periodcentered",
+          0x00B8 => "cedilla", 0x00B9 => "onesuperior", 0x00BA => "ordmasculine",
+          0x00BB => "guillemotright", 0x00BC => "onequarter", 0x00BD => "onehalf",
+          0x00BE => "threequarters", 0x00BF => "questiondown", 0x00C0 => "Agrave",
+          0x00C1 => "Aacute", 0x00C2 => "Acircumflex", 0x00C3 => "Atilde", 0x00C4 => "Adieresis",
+          0x00C5 => "Aring", 0x00C6 => "AE", 0x00C7 => "Ccedilla", 0x00C8 => "Egrave",
+          0x00C9 => "Eacute", 0x00CA => "Ecircumflex", 0x00CB => "Edieresis", 0x00CC => "Igrave",
+          0x00CD => "Iacute", 0x00CE => "Icircumflex", 0x00CF => "Idieresis", 0x00D0 => "Eth",
+          0x00D1 => "Ntilde", 0x00D2 => "Ograve", 0x00D3 => "Oacute", 0x00D4 => "Ocircumflex",
+          0x00D5 => "Otilde", 0x00D6 => "Odieresis", 0x00D7 => "multiply", 0x00D8 => "Oslash",
+          0x00D9 => "Ugrave", 0x00DA => "Uacute", 0x00DB => "Ucircumflex", 0x00DC => "Udieresis",
+          0x00DD => "Yacute", 0x00DE => "Thorn", 0x00DF => "germandbls", 0x00E0 => "agrave",
+          0x00E1 => "aacute", 0x00E2 => "acircumflex", 0x00E3 => "atilde", 0x00E4 => "adieresis",
+          0x00E5 => "aring", 0x00E6 => "ae", 0x00E7 => "ccedilla", 0x00E8 => "egrave",
+          0x00E9 => "eacute", 0x00EA => "ecircumflex", 0x00EB => "edieresis", 0x00EC => "igrave",
+          0x00ED => "iacute", 0x00EE => "icircumflex", 0x00EF => "idieresis", 0x00F0 => "eth",
+          0x00F1 => "ntilde", 0x00F2 => "ograve", 0x00F3 => "oacute", 0x00F4 => "ocircumflex",
+          0x00F5 => "otilde", 0x00F6 => "odieresis", 0x00F7 => "divide", 0x00F8 => "oslash",
+          0x00F9 => "ugrave", 0x00FA => "uacute", 0x00FB => "ucircumflex", 0x00FC => "udieresis",
+          0x00FD => "yacute", 0x00FE => "thorn", 0x00FF => "ydieresis" }[cp]
+      end
+
       def font_name_for(name_or_io)
         case name_or_io
-        when Symbol, String then name_or_io.to_s
+        when Symbol
+          name_or_io.to_s
+        when String
+          if File.file?(name_or_io)
+            @pending_io_data = File.binread(name_or_io)
+            @pending_subtype = true_type_subtype(@pending_io_data)
+            subset_tag = subset_tag_for(@pending_io_data)
+            base = postscript_name_for(@pending_io_data) ||
+              File.basename(name_or_io, ".*")
+            "#{subset_tag}+#{base}"
+          else
+            name_or_io.to_s
+          end
+        when IO, StringIO
+          @pending_io_data = name_or_io.read
+          @pending_subtype = true_type_subtype(@pending_io_data)
+          unless valid_font_data?(@pending_io_data)
+            Pdfrb.logger&.warn("Font data does not look like a valid TTF/OTF")
+          end
+          subset_tag = subset_tag_for(@pending_io_data)
+          base = postscript_name_for(@pending_io_data) ||
+            "EmbeddedFont#{@pending_io_data.bytesize}"
+          "#{subset_tag}+#{base}"
         else
-          raise ArgumentError,
-                "font name must be a String or Symbol; TTF/OTF IO loading lands in TODO 111"
+          raise ArgumentError, "font name must be a String, Symbol, or IO"
         end
       end
 
+      # Extract the PostScript name (name table nameID 6) from raw
+      # TTF/OTF bytes. Returns nil if the data isn't parseable or the
+      # name record is missing. Used to derive a meaningful BaseFont
+      # name (e.g. "MinionPro-Regular") instead of falling back to a
+      # size-derived placeholder.
+      def postscript_name_for(font_bytes)
+        return nil unless font_bytes && font_bytes.bytesize >= 12
+        return nil unless valid_font_data?(font_bytes)
+
+        ttf = Pdfrb::Font::TrueType::File.new(font_bytes)
+        name = ttf.name_table_parsed
+        return nil unless name
+
+        sanitize_ps_name(name.ps_name)
+      end
+
+      # PDF /BaseFont names must be a Name token: no whitespace, no
+      # delimiter chars (()[<>/{%]). Trim and substitute.
+      def sanitize_ps_name(name)
+        return nil if name.nil? || name.empty?
+
+        name.to_s.gsub(/[\s()\[\]<>{}\/%]+/, "-")
+      end
+
+      # Generate a deterministic 6-letter subset tag from the font bytes
+      # so re-embedding the same font produces the same prefix. Format
+      # is six uppercase ASCII letters derived from the SHA-1 of the
+      # first 1 KB of the font file (per PDF spec s9.6.4).
+      def subset_tag_for(font_bytes)
+        require "digest"
+        digest = Digest::SHA1.digest(font_bytes.byteslice(0, 1024) || "")
+        digest.byteslice(0, 6).bytes.each_with_object(+"") do |b, s|
+          s << ((b % 26) + 65).chr
+        end
+      end
+
+      def true_type_subtype(data)
+        magic = data&.byteslice(0, 4)
+        # Per PDF spec s9.6.2 + s9.9: magic distinguishes the two
+        # outline formats. "OTTO" means OpenType with CFF outlines,
+        # which must be embedded via /FontFile3 + /Subtype /OpenType
+        # and treated as /Subtype /Type1 (CFF) — NOT as /Subtype
+        # /TrueType, which was the bug (Issue #62).
+        return :TrueType if magic == "\x00\x01\x00\x00".b
+        return :TrueType if magic == "true".b
+        return :Type1 if magic == "OTTO".b
+
+        nil
+      end
+
+      def cff_font?(data)
+        true_type_subtype(data) == :Type1
+      end
+
       def next_resource_name
         sym = :"F#{@next_id}"
         @next_id += 1
@@ -97,16 +435,50 @@ module Pdfrb
 
       def register_font(resource, name, **opts)
         loader = self.class.loaders.find { |l| l.call(document, name, **opts) }
-        font_dict = loader ? loader.call(document, name, **opts) :
-                     default_font(name)
+        font_dict = loader ? loader.call(document, name, **opts) : default_font(name)
         attach_to_resources(resource, font_dict)
+        font_dict
       end
 
       def default_font(name)
-        document.add(
-          { Type: :Font, Subtype: :Type1, BaseFont: name.to_sym },
-          type: Pdfrb::Model::Type::FontType1
-        )
+        tu_stream = self.class.build_tounicode(document)
+        tu_ref = Pdfrb::Model::Reference.new(tu_stream.oid, tu_stream.gen)
+
+        fd = document.add({
+          Type: :FontDescriptor, FontName: name.to_sym, Flags: 32,
+          FontBBox: [0, 0, 1000, 1000], ItalicAngle: 0,
+          Ascent: 800, Descent: -200, CapHeight: 700, StemV: 80
+        }, type: Pdfrb::Model::Cos::Dictionary)
+        fd_ref = Pdfrb::Model::Reference.new(fd.oid, fd.gen)
+
+        if @pending_io_data && valid_font_data?(@pending_io_data)
+          font_file = document.add(
+            { Length: @pending_io_data.bytesize },
+            type: Pdfrb::Model::Cos::Stream
+          )
+          font_file.stream = @pending_io_data
+          # Per PDF spec s9.9: TrueType outlines → FontFile2; CFF (OTF)
+          # outlines → FontFile3 with /Subtype /OpenType. Issue #62
+          # was embedding OTF/CFF as TrueType via FontFile2.
+          if cff_font?(@pending_io_data)
+            font_file.value[:Subtype] = :OpenType
+            font_file.value[:Length1] = @pending_io_data.bytesize
+            fd.value[:FontFile3] =
+              Pdfrb::Model::Reference.new(font_file.oid, font_file.gen)
+          else
+            font_file.value[:Length1] = @pending_io_data.bytesize
+            fd.value[:FontFile2] =
+              Pdfrb::Model::Reference.new(font_file.oid, font_file.gen)
+          end
+        end
+
+        subtype = @pending_subtype || :Type1
+        document.add({
+          Type: :Font, Subtype: subtype, BaseFont: name.to_sym,
+          Encoding: :WinAnsiEncoding, FirstChar: 0, LastChar: 255,
+          Widths: Array.new(256, DEFAULT_WIDTH),
+          FontDescriptor: fd_ref, ToUnicode: tu_ref
+        }, type: subtype == :TrueType ? Pdfrb::Model::Type::FontTrueType : Pdfrb::Model::Type::FontType1)
       end
 
       def attach_to_resources(resource, font_dict)