hexapdf 0.3.0 → 0.4.0

data/lib/hexapdf/font/encoding/base.rb

@@ -61,8 +61,8 @@ module HexaPDF
           @code_to_name.fetch(code, :'.notdef')
         end
 
-        # Returns the Unicode value in UTF-8 for the given code, or an empty string if the code
-        # cannot be mapped.
+        # Returns the Unicode value in UTF-8 for the given code, or +nil+ if the code cannot be
+        # mapped.
         #
         # Note that this method caches the result of the Unicode mapping and therefore should only
         # be called after all codes have been defined.

data/lib/hexapdf/font/encoding/glyph_list.rb

@@ -71,8 +71,8 @@ module HexaPDF
           load
         end
 
-        # Maps the given name to a string by following the Adobe Glyph Specification. An empty
-        # string is returned if the name has no correct mapping.
+        # Maps the given name to a string by following the Adobe Glyph Specification. Returns +nil+
+        # if the name has no correct mapping.
         #
         # If this method is invoked when dealing with the ZapfDingbats font, the +zapf_dingbats+
         # option needs to be set to +true+.
@@ -88,8 +88,6 @@ module HexaPDF
             name = name.to_s
             if name =~ /\Auni([0-9A-F]{4})\Z/ || name =~ /\Au([0-9A-f]{4,6})\Z/
               '' << $1.hex
-            else
-              ''
             end
           end
         end

data/lib/hexapdf/font/true_type.rb

@@ -45,6 +45,7 @@ module HexaPDF
 
       autoload(:Font, 'hexapdf/font/true_type/font')
       autoload(:Subsetter, 'hexapdf/font/true_type/subsetter')
+      autoload(:Optimizer, 'hexapdf/font/true_type/optimizer')
 
     end
 

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

@@ -0,0 +1,75 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2017 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
+    module TrueType
+
+      # Builds a TrueType font file given a hash of TrueType tables.
+      module Builder
+
+        # Returns a TrueType font file representing the given TrueType tables (a hash mapping table
+        # names (strings) to table data).
+        def self.build(tables)
+          search_range = 2**(tables.length.bit_length - 1) * 16
+          entry_selector = tables.length.bit_length - 1
+          range_shift = tables.length * 16 - search_range
+
+          font_data = "\x0\x1\x0\x0".b + \
+            [tables.length, search_range, entry_selector, range_shift].pack('n4')
+
+          offset = font_data.length + tables.length * 16
+          checksum = Table.calculate_checksum(font_data)
+
+          # prepare head table for checksumming
+          tables['head'][8, 4] = "\0\0\0\0"
+
+          tables.each do |tag, data|
+            table_checksum = Table.calculate_checksum(data)
+            # tag, offset, data.length are all 32bit uint, table_checksum for header and body
+            checksum += tag.unpack('N').first + 2 * table_checksum + offset + data.length
+            font_data << [tag, table_checksum, offset, data.length].pack('a4N3')
+            offset += data.length
+          end
+
+          tables['head'][8, 4] = [0xB1B0AFBA - checksum].pack('N')
+          tables.each_value {|data| font_data << data}
+
+          font_data
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2017 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/builder'
+
+module HexaPDF
+  module Font
+    module TrueType
+
+      # Provides methods for optimizing a TrueType font file in various ways.
+      module Optimizer
+
+        # Returns for the given font a TrueType font file as binary string that is optimized for use
+        # in a PDF (i.e. only the essential tables are retained).
+        def self.build_for_pdf(font)
+          tables = {
+            'head' => font[:head].raw_data,
+            'hhea' => font[:hhea].raw_data,
+            'maxp' => font[:maxp].raw_data,
+            'glyf' => font[:glyf].raw_data,
+            'loca' => font[:loca].raw_data,
+            'hmtx' => font[:hmtx].raw_data,
+          }
+          tables['cmap'] = font[:cmap].raw_data if font[:cmap]
+          tables['cvt '] = font[:"cvt "].raw_data if font[:"cvt "]
+          tables['fpgm'] = font[:fpgm].raw_data if font[:fpgm]
+          tables['prep'] = font[:prep].raw_data if font[:prep]
+          Builder.build(tables)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -31,6 +31,8 @@
 # is created or manipulated using HexaPDF.
 #++
 
+require 'hexapdf/font/true_type/builder'
+
 module HexaPDF
   module Font
     module TrueType
@@ -61,6 +63,12 @@ module HexaPDF
           @glyph_map[glyph_id] = @last_id
         end
 
+        # Returns the new subset glyph ID for the given glyph ID, or +nil+ if the glyph isn't
+        # subset.
+        def subset_glyph_id(glyph_id)
+          @glyph_map[glyph_id]
+        end
+
         # Builds the subset font file and returns it as a binary string.
         def build_font
           glyf, locations = build_glyf_table
@@ -82,28 +90,7 @@ module HexaPDF
           tables['fpgm'] = @font[:fpgm].raw_data if @font[:fpgm]
           tables['prep'] = @font[:prep].raw_data if @font[:prep]
 
-          search_range = 2**(tables.length.bit_length - 1) * 16
-          entry_selector = tables.length.bit_length - 1
-          range_shift = tables.length * 16 - search_range
-
-          font_data = "\x0\x1\x0\x0".b + \
-            [tables.length, search_range, entry_selector, range_shift].pack('n4')
-
-          offset = font_data.length + tables.length * 16
-          checksum = Table.calculate_checksum(font_data)
-
-          tables.each do |tag, data|
-            table_checksum = Table.calculate_checksum(data)
-            # tag, offset, data.length are all 32bit uint, table_checksum for header and body
-            checksum += tag.unpack('N').first + 2 * table_checksum + offset + data.length
-            font_data << [tag, table_checksum, offset, data.length].pack('a4N3')
-            offset += data.length
-          end
-
-          head[8, 4] = [0xB1B0AFBA - checksum].pack('N')
-          tables.each_value {|data| font_data << data}
-
-          font_data
+          Builder.build(tables)
         end
 
         private

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -247,34 +247,22 @@ module HexaPDF
 
       # 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)
-        unless glyphs.empty?
-          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
+        default_width = glyph(3).width.to_i
+        widths = @encoded_glyphs.keys.reject {|g| g.width == default_width}.map! do |glyph|
+          [(@subsetter ? @subsetter.subset_glyph_id(glyph.id) : glyph.id), glyph.width]
+        end.sort!
+        @dict[:DescendantFonts].first.set_widths(widths, default_width: default_width)
       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|
+          mapping = @encoded_glyphs.keys.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
+            [(@subsetter ? @subsetter.subset_glyph_id(glyph.id) : glyph.id),
+             @cmap.gid_to_code(glyph.id) || 0xFFFD]
+          end.sort_by(&:first)
           HexaPDF::Font::CMap.create_to_unicode_cmap(mapping)
         end
         stream_obj = @document.add({}, stream: stream)

data/lib/hexapdf/font_loader.rb

@@ -68,7 +68,7 @@ module HexaPDF
   #
   # decode_utf8(str)::
   #     This method needs to convert the given string into an array of glyph objects. The glyph
-  #     objects themselves are treated as opaque objects by HexaPDF::Content::Canvas.
+  #     objects themselves have to respond to \#width which should return their horizontal width.
   #
   # encode(glyph)::
   #     This method takes a single glyph object, that needs to be compatible with the font wrapper,

data/lib/hexapdf/importer.rb

@@ -116,7 +116,7 @@ module HexaPDF
           @mapper[object.data] = nil
         else
           obj = @mapper[object.data] = object.dup
-          obj.document = @destination
+          obj.document = @destination.__getobj__
           obj.instance_variable_set(:@data, obj.data.dup)
           obj.data.oid = 0
           obj.data.gen = 0

data/lib/hexapdf/serializer.rb

@@ -231,10 +231,12 @@ module HexaPDF
     def serialize_string(obj)
       if @encrypter && @object.kind_of?(HexaPDF::Object) && @object.indirect?
         obj = encrypter.encrypt_string(obj, @object)
-      elsif obj.encoding != Encoding::BINARY && obj =~ /[^ -~\t\r\n]/
-        obj = "\xFE\xFF".b << obj.encode(Encoding::UTF_16BE).force_encoding(Encoding::BINARY)
       elsif obj.encoding != Encoding::BINARY
-        obj = obj.b
+        obj = if obj =~ /[^ -~\t\r\n]/
+                "\xFE\xFF".b << obj.encode(Encoding::UTF_16BE).force_encoding(Encoding::BINARY)
+              else
+                obj.b
+              end
       end
       "(" << obj.gsub(/[\(\)\\\r]/n) {|m| STRING_ESCAPE_MAP[m]} << ")".freeze
     end

data/lib/hexapdf/type.rb

@@ -61,6 +61,8 @@ module HexaPDF
     autoload(:FontSimple, 'hexapdf/type/font_simple')
     autoload(:FontType1, 'hexapdf/type/font_type1')
     autoload(:FontTrueType, 'hexapdf/type/font_true_type')
+    autoload(:FontType0, 'hexapdf/type/font_type0')
+    autoload(:CIDFont, 'hexapdf/type/cid_font')
 
   end
 

data/lib/hexapdf/type/cid_font.rb

@@ -0,0 +1,120 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2017 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/type/font'
+
+module HexaPDF
+  module Type
+
+    # Represents a generic CIDFont which can only be used as a descendant font of a composite PDF
+    # font.
+    #
+    # See: PDF1.7 s9.7.4
+    class CIDFont < Font
+
+      DEFAULT_WIDTH = 1000 # :nodoc:
+
+      define_field :CIDSystemInfo,   type: [Hash, Dictionary], required: true
+      define_field :FontDescriptor,  type: :FontDescriptor, indirect: true, required: true
+      define_field :DW,              type: Integer, default: DEFAULT_WIDTH
+      define_field :W,               type: Array
+      define_field :DW2,             type: Array, default: [880, -1100]
+      define_field :W2,              type: Array
+
+
+      # Returns the unscaled width of the given CID in glyph units, or 0 if the width for the CID is
+      # missing.
+      #
+      # Note that in contrast to other fonts, the argument must *not* be a code point but a CID!
+      def width(cid)
+        widths[cid] || value[:DW] || DEFAULT_WIDTH
+      end
+
+      # Sets the /W and /DW keys using the given array of [CID, width] pairs and an optional default
+      # width.
+      #
+      # See: PDF1.7 s9.7.4.3
+      def set_widths(widths, default_width: DEFAULT_WIDTH)
+        if widths.empty?
+          (default_width == DEFAULT_WIDTH ? delete(:DW) : self[:DW] = default_width)
+          delete(:W)
+        else
+          self[:DW] = default_width.to_i unless default_width == DEFAULT_WIDTH
+          self[:W] = w = []
+          last_cid = -10
+          cur_widths = nil
+          widths.each do |cid, width|
+            if last_cid + 1 != cid
+              cur_widths = []
+              w << cid << cur_widths
+            end
+            cur_widths << width.to_i
+            last_cid = cid
+          end
+        end
+      end
+
+      private
+
+      # Returns a hash mapping CIDs to their respective width.
+      #
+      # Note that the hash is cached internally when accessed the first time.
+      #
+      # See: PDF1.7 s9.7.4.3
+      def widths
+        document.cache(@data, :widths) do
+          result = {}
+          index = 0
+          array = self[:W] || []
+
+          while index < array.size
+            entry = array[index]
+            value = array[index + 1]
+            if value.kind_of?(Array)
+              value.each_with_index {|width, i| result[entry + i] = width}
+              index += 2
+            else
+              width = array[index + 2]
+              entry.upto(value) {|cid| result[cid] = width}
+              index += 3
+            end
+          end
+
+          result
+        end
+      end
+
+    end
+
+  end
+end