hexapdf 0.1.0

data/lib/hexapdf/font/true_type/table/post.rb

@@ -0,0 +1,230 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+require 'hexapdf/font/true_type/table'
+
+module HexaPDF
+  module Font
+    module TrueType
+      class Table
+
+        # The 'post' table contains information for using a font on a PostScript printer.
+        #
+        # post format 2.5 is currently not implemented because use of the format is deprecated since
+        # 2000 in the specification and no font with a format 2.5 post subtable was available for
+        # testing.
+        #
+        # See: https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6post.html
+        class Post < Table
+
+          # The format of the table (a Rational).
+          attr_accessor :format
+
+          # The italic angle (a Rational).
+          attr_accessor :italic_angle
+
+          # The suggested distance of the top of the underline from the baseline (negative values
+          # indicate underlines below the baseline).
+          attr_accessor :underline_position
+
+          # The suggested thickness for underlines.
+          attr_accessor :underline_thickness
+
+          # Specifies whether the font is proportional (value is 0) or monospaced (value is not 0).
+          attr_accessor :is_fixed_pitch
+
+          # Returns +true+ if the font is monospaced.
+          #
+          # See: #is_fixed_pitch
+          def is_fixed_pitch?
+            @is_fixed_pitch != 0
+          end
+
+          # Minimum memory usage when a font is downloaded.
+          attr_accessor :min_mem_type42
+
+          # Maximum memory usage when a font is downloaded.
+          attr_accessor :max_mem_type42
+
+          # Minimum memory usage when a Type1 font is downloaded.
+          attr_accessor :min_mem_type1
+
+          # Maximum memory usage when a Type1 font is downloaded.
+          attr_accessor :max_mem_type1
+
+          # Returns the name for the given glpyh id or ".notdef" if the given glyph id has no name.
+          def [](glyph_id)
+            @glyph_names[glyph_id] || '.notdef'.freeze
+          end
+
+          private
+
+          def parse_table #:nodoc:
+            @format = read_fixed
+            @italic_angle = read_fixed
+            @underline_position, @underline_thickness, @is_fixed_pitch, @min_mem_type42,
+              @max_mem_type42, @min_mem_type1, @max_mem_type1 = read_formatted(24, 's>2N5')
+
+            sub_table_length = directory_entry.length - 32
+            @glyph_names = case @format
+                           when 1 then Format1.parse(io, sub_table_length)
+                           when 2 then Format2.parse(io, sub_table_length)
+                           when 3 then Format3.parse(io, sub_table_length)
+                           when 4 then Format4.parse(io, sub_table_length)
+                           else
+                             raise HexaPDF::Error, "Unsupported post table format: #{@format}"
+                           end
+          end
+
+          def load_default #:nodoc:
+            @format = 1.to_r
+            @italic_angle = 0.to_r
+            @underline_position = @underline_thickness = @is_fixed_pitch = @min_mem_type42 =
+              @max_mem_type42 = @min_mem_type1 = @max_mem_type1 = 0
+            @glyph_names = {}
+          end
+
+
+          # 'post' table format 1
+          module Format1
+
+            # The 258 predefined glyph names in the standard Macintosh ordering.
+            GLYPH_NAMES = %w[
+              .notdef .null nonmarkingreturn space exclam quotedbl numbersign dollar percent
+              ampersand quotesingle parenleft parenright asterisk plus comma hyphen period slash
+              zero one two three four five six seven eight nine colon semicolon less equal greater
+              question at A B C D E F G H I J K L M N O P Q R S T U V W X Y Z bracketleft backslash
+              bracketright asciicircum underscore grave a b c d e f g h i j k l m n o p q r s t u v
+              w x y z braceleft bar braceright asciitilde Adieresis Aring Ccedilla Eacute Ntilde
+              Odieresis Udieresis aacute agrave acircumflex adieresis atilde aring ccedilla eacute
+              egrave ecircumflex edieresis iacute igrave icircumflex idieresis ntilde oacute ograve
+              ocircumflex odieresis otilde uacute ugrave ucircumflex udieresis dagger degree cent
+              sterling section bullet paragraph germandbls registered copyright trademark acute
+              dieresis notequal AE Oslash infinity plusminus lessequal greaterequal yen mu
+              partialdiff summation product pi integral ordfeminine ordmasculine Omega ae oslash
+              questiondown exclamdown logicalnot radical florin approxequal Delta guillemotleft
+              guillemotright ellipsis nonbreakingspace Agrave Atilde Otilde OE oe endash emdash
+              quotedblleft quotedblright quoteleft quoteright divide lozenge ydieresis Ydieresis
+              fraction currency guilsinglleft guilsinglright fi fl daggerdbl periodcentered
+              quotesinglbase quotedblbase perthousand Acircumflex Ecircumflex Aacute Edieresis
+              Egrave Iacute Icircumflex Idieresis Igrave Oacute Ocircumflex apple Ograve Uacute
+              Ucircumflex Ugrave dotlessi circumflex tilde macron breve dotaccent ring cedilla
+              hungarumlaut ogonek caron Lslash lslash Scaron scaron Zcaron zcaron brokenbar Eth eth
+              Yacute yacute Thorn thorn minus multiply onesuperior twosuperior threesuperior onehalf
+              onequarter threequarters franc Gbreve gbreve Idotaccent Scedilla scedilla Cacute
+              cacute Ccaron ccaron dcroat
+            ].freeze
+
+            # :call-seq:
+            #   Format1.parse(io, length)    -> glyph_names
+            #
+            # Returns the array containing the 258 predefined glpyh names.
+            def self.parse(_io, _length)
+              GLYPH_NAMES
+            end
+
+          end
+
+
+          # 'post' table format 2
+          module Format2
+
+            # :call-seq:
+            #   Format2.parse(io, length)    -> glyph_names
+            #
+            # Parses the format 2 post subtable from the given IO at the current position and
+            # returns the contained glyph name map.
+            def self.parse(io, length)
+              end_pos = io.pos + length
+              num_glyphs = io.read(2).unpack('n').first
+              glyph_name_index = io.read(2 * num_glyphs).unpack('n*')
+              names = []
+              names << io.read(io.getbyte).force_encoding(::Encoding::UTF_8) while io.pos < end_pos
+              mapper(glyph_name_index, names)
+            end
+
+            def self.mapper(glyph_name_index, names) #:nodoc:
+              lambda do |glyph_id|
+                name_index = glyph_name_index[glyph_id]
+                if !name_index
+                  nil
+                elsif name_index <= 257
+                  Format1::GLYPH_NAMES[name_index]
+                else
+                  names[name_index - 258]
+                end
+              end
+            end
+
+          end
+
+
+          # 'post' table format 3
+          module Format3
+
+            # :call-seq:
+            #   Format3.parse(io, length)    -> glyph_names
+            #
+            # Since the post table format 3 does not contain any valid glyph names, an empty array
+            # is returned.
+            def self.parse(_io, _length)
+              [].freeze
+            end
+
+          end
+
+
+          # 'post' table format 4
+          module Format4
+
+            # :call-seq:
+            #   Format4.parse(io, length)    -> glyph_names
+            #
+            # Parses the format 4 post subtable from the given IO at the current position and
+            # returns a lambda mapping the glyph id to a character code.
+            def self.parse(io, length)
+              mapper(io.read(length).unpack('n*'))
+            end
+
+            def self.mapper(char_codes) #:nodoc:
+              lambda {|glyph_id| char_codes[glyph_id] || 0xFFFF }
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/hexapdf/font/true_type/table.rb

@@ -0,0 +1,155 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+require 'hexapdf/error'
+
+module HexaPDF
+  module Font
+    module TrueType
+
+      # Implementation of a generic table inside a sfnt-formatted font file.
+      #
+      # See: https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6.html
+      class Table
+
+        autoload(:Directory, 'hexapdf/font/true_type/table/directory')
+        autoload(:Head, 'hexapdf/font/true_type/table/head')
+        autoload(:Cmap, 'hexapdf/font/true_type/table/cmap')
+        autoload(:Hhea, 'hexapdf/font/true_type/table/hhea')
+        autoload(:Hmtx, 'hexapdf/font/true_type/table/hmtx')
+        autoload(:Loca, 'hexapdf/font/true_type/table/loca')
+        autoload(:Maxp, 'hexapdf/font/true_type/table/maxp')
+        autoload(:Name, 'hexapdf/font/true_type/table/name')
+        autoload(:Post, 'hexapdf/font/true_type/table/post')
+        autoload(:Glyf, 'hexapdf/font/true_type/table/glyf')
+        autoload(:OS2,  'hexapdf/font/true_type/table/os2')
+
+
+        # The time Epoch used in sfnt-formatted font files.
+        TIME_EPOCH = Time.new(1904, 1, 1)
+
+        # Calculates the checksum for the given data.
+        def self.calculate_checksum(data)
+          data.unpack('N*').inject(0) {|sum, long| sum + long} % 2**32
+        end
+
+
+        # The TrueType font object associated with this table.
+        attr_reader :font
+
+        # Creates a new Table object for the given font and initializes it by either reading the
+        # data from the font's associated IO stream if +entry+ is given or by using default values.
+        #
+        # See: #parse_table, #load_default
+        def initialize(font, entry = nil)
+          @font = font
+          @directory_entry = entry
+          entry ? load_from_io : load_default
+        end
+
+        # Returns the directory entry for this table.
+        #
+        # See: Directory
+        def directory_entry
+          @directory_entry
+        end
+
+        # Returns +true+ if the checksum stored in the directory entry of the table matches the
+        # tables data.
+        def checksum_valid?
+          unless directory_entry
+            raise HexaPDF::Error, "Can't verify the checksum, no directory entry available"
+          end
+
+          data = with_io_pos(directory_entry.offset) { io.read(directory_entry.length) }
+          directory_entry.checksum == self.class.calculate_checksum(data)
+        end
+
+        private
+
+        # The IO stream of the associated font object.
+        def io
+          @font.io
+        end
+
+        # Loads the data for this table from the IO stream of the associated font object into this
+        # object.
+        #
+        # See #parse_table for more information.
+        def load_from_io
+          with_io_pos(directory_entry.offset) { parse_table }
+        end
+
+        # Parses the table with the IO position already at the correct offset.
+        #
+        # This method does the actual work of parsing a table entry and must be implemented by
+        # subclasses.
+        #
+        # See: #load_from_io
+        def parse_table
+          # noop for unsupported tables
+        end
+
+        # Uses default values to populate the table.
+        #
+        # This method must be implemented by subclasses.
+        def load_default
+          # noop for unsupported tables
+        end
+
+        # Sets the IO cursor to the given position while yielding to the block and returns the
+        # block's return value.
+        def with_io_pos(pos)
+          old_pos = io.pos
+          io.pos = pos
+          yield
+        ensure
+          io.pos = old_pos
+        end
+
+        # Reads +count+ bytes from the current position of the font's associated IO stream, unpacks
+        # them using the provided format specifier and returns the result.
+        def read_formatted(count, format)
+          io.read(count).unpack(format)
+        end
+
+        # Reads a 16.16-bit signed fixed-point integer and returns a Rational as result.
+        def read_fixed
+          Rational(io.read(4).unpack('N').first, 65536)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hexapdf/font/true_type.rb

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+module HexaPDF
+  module Font
+
+    # This module provides classes for handling TrueType fonts.
+    #
+    # Note that currently not all parts of the file format are supported, only those needed for
+    # using the fonts with PDF.
+    module TrueType
+
+      autoload(:Font, 'hexapdf/font/true_type/font')
+
+    end
+
+  end
+end

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -0,0 +1,240 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+require 'hexapdf/font/true_type'
+require 'hexapdf/font/cmap'
+require 'hexapdf/error'
+
+module HexaPDF
+  module Font
+
+    # This class wraps a generic TrueType font object and provides the methods needed for working
+    # with the font in a PDF context.
+    #
+    # TrueType fonts can be represented in two ways in PDF: As a simple font with Subtype TrueType
+    # or as a composite font using a Type2 CIDFont. The wrapper only supports the composite font
+    # case because:
+    #
+    # * By using a composite font more than 256 characters can be encoded with one font object.
+    # * Fonts for vertical writing can potentially be used.
+    # * The PDF specification recommends using a composite font (see PDF1.7 s9.9 at the end).
+    #
+    # Additionally, TrueType fonts are *always* embedded.
+    class TrueTypeWrapper
+
+      # Represents a single glyph of the wrapped font.
+      class Glyph
+
+        # The glyph ID.
+        attr_reader :id
+
+        # Creates a new Glyph object.
+        def initialize(font, id)
+          @font = font
+          @id = id
+        end
+
+        # Returns the width of the glyph.
+        def width
+          @width ||= @font[:hmtx][id].advance_width * 1000.0 / @font[:head].units_per_em
+        end
+
+        # Returns +true+ if the glyph represents the space character.
+        def space?
+          # Accoding to http://scripts.sil.org/iws-chapter08 and
+          # https://www.microsoft.com/typography/otspec/recom.htm
+          @id == 3
+        end
+
+      end
+
+      private_constant :Glyph
+
+
+      # Returns the wrapped TrueType font object.
+      attr_reader :wrapped_font
+
+      # Returns the PDF font dictionary representing the wrapped font.
+      attr_reader :dict
+
+      # Creates a new object wrapping the TrueType font for the PDF document.
+      def initialize(document, font)
+        @document = document
+        @wrapped_font = font
+
+        @cmap = font[:cmap].preferred_table
+        if @cmap.nil?
+          raise HexaPDF::Error, "No mapping table for Unicode characters found for TTF " \
+            "font #{font.full_name}"
+        end
+        @dict = build_font_dict
+        @document.register_listener(:complete_objects, &method(:complete_font_dict))
+
+        @id_to_glyph = {}
+        @codepoint_to_glyph = {}
+        @encoded_glyphs = {}
+      end
+
+      # Returns a Glyph object for the given glyph ID.
+      #
+      # Note: Although this method is public, it should normally not be used by application code!
+      def glyph(id)
+        @id_to_glyph[id] ||=
+          begin
+            if id < 0 || id >= @wrapped_font[:maxp].num_glyphs
+              id = @document.config['font.on_missing_glyph'].call(0xFFFD, @wrapped_font)
+            end
+            Glyph.new(@wrapped_font, id)
+          end
+      end
+
+      # Returns an array of glyph objects representing the characters in the UTF-8 encoded string.
+      def decode_utf8(str)
+        str.each_codepoint.map do |c|
+          @codepoint_to_glyph[c] ||=
+            begin
+              gid = @cmap[c] || @document.config['font.on_missing_glyph'].call(c, @wrapped_font)
+              glyph(gid)
+            end
+        end
+      end
+
+      # Encodes the glyph and returns the code string.
+      def encode(glyph)
+        @encoded_glyphs[glyph] ||= [glyph.id].pack('n')
+      end
+
+      private
+
+      # Builds a Type0 font object representing the TrueType font.
+      #
+      # The returned font object contains only information available at build time, so no
+      # information about glyph specific attributes like width.
+      #
+      # See: #complete_font_dict
+      def build_font_dict
+        scaling = 1000.0 / @wrapped_font[:head].units_per_em
+
+        embedded_font = @document.add({Length1: @wrapped_font.io.size},
+                                      stream: HexaPDF::StreamData.new(@wrapped_font.io))
+        fd = @document.add(Type: :FontDescriptor,
+                           FontName: @wrapped_font.font_name.intern,
+                           FontWeight: @wrapped_font.weight,
+                           Flags: 0,
+                           FontBBox: @wrapped_font.bounding_box.map {|m| m * scaling},
+                           ItalicAngle: @wrapped_font.italic_angle || 0,
+                           Ascent: @wrapped_font.ascender * scaling,
+                           Descent: @wrapped_font.descender * scaling,
+                           StemV: @wrapped_font.dominant_vertical_stem_width,
+                           FontFile2: embedded_font)
+        if @wrapped_font[:'OS/2'].version >= 2
+          fd[:CapHeight] = @wrapped_font.cap_height * scaling
+          fd[:XHeight] = @wrapped_font.x_height * scaling
+        else # estimate values
+          # Estimate as per https://www.microsoft.com/typography/otspec/os2.htm#ch
+          fd[:CapHeight] = if @cmap[0x0048] # H
+                             @wrapped_font[:glyf][@cmap[0x0048]].y_max * scaling
+                           else
+                             @wrapped_font.ascender * 0.8 * scaling
+                           end
+          # Estimate as per https://www.microsoft.com/typography/otspec/os2.htm#xh
+          fd[:XHeight] = if @cmap[0x0078] # x
+                           @wrapped_font[:glyf][@cmap[0x0078]].y_max * scaling
+                         else
+                           @wrapped_font.ascender * 0.5 * scaling
+                         end
+        end
+
+        fd.flag(:fixed_pitch) if @wrapped_font[:post].is_fixed_pitch? ||
+          @wrapped_font[:hhea].num_of_long_hor_metrics == 1
+        fd.flag(:italic) if @wrapped_font[:'OS/2'].selection_include?(:italic) ||
+          @wrapped_font[:'OS/2'].selection_include?(:oblique)
+        fd.flag(:symbolic)
+
+        cid_font = @document.add(Type: :Font, Subtype: :CIDFontType2,
+                                 BaseFont: @wrapped_font.font_name.intern, FontDescriptor: fd,
+                                 CIDSystemInfo: {Registry: "Adobe", Ordering: "Identity",
+                                                 Supplement: 0},
+                                 CIDToGIDMap: :Identity)
+        @document.add(Type: :Font, Subtype: :Type0, BaseFont: cid_font[:BaseFont],
+                      Encoding: :"Identity-H", DescendantFonts: [cid_font])
+      end
+
+      # Makes sure that the Type0 font object as well as the CIDFont object contain all the needed
+      # information.
+      def complete_font_dict
+        complete_width_information
+        create_to_unicode_cmap
+      end
+
+      # Adds the /DW and /W fields to the CIDFont dictionary.
+      def complete_width_information
+        cid_font = @dict[:DescendantFonts].first
+        cid_font[:DW] = default_width = glyph(3).width
+
+        glyphs = @encoded_glyphs.keys.reject {|g| g.width == default_width}.sort_by(&:id)
+        if glyphs.length > 0
+          cid_font[:W] = widths = []
+          last_id = -10
+          cur_widths = nil
+          glyphs.each do |glyph|
+            gid = glyph.id
+            if last_id + 1 != gid
+              cur_widths = []
+              widths << gid << cur_widths
+            end
+            cur_widths << glyph.width
+            last_id = gid
+          end
+        end
+      end
+
+      # Creates the /ToUnicode CMap and updates the font dictionary so that text extraction works
+      # correctly.
+      def create_to_unicode_cmap
+        stream = HexaPDF::StreamData.new do
+          mapping = @encoded_glyphs.keys.sort_by(&:id).map do |glyph|
+            # Using 0xFFFD as mentioned in Adobe #5411, last line before section 1.5
+            [glyph.id, @cmap.gid_to_code(glyph.id) || 0xFFFD]
+          end
+          HexaPDF::Font::CMap.create_to_unicode_cmap(mapping)
+        end
+        stream_obj = @document.add({}, stream: stream)
+        stream_obj.set_filter(:FlateDecode)
+        @dict[:ToUnicode] = stream_obj
+      end
+
+    end
+
+  end
+end