hexapdf 0.4.0 → 0.5.0

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

@@ -0,0 +1,170 @@
+# -*- 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/table'
+
+module HexaPDF
+  module Font
+    module TrueType
+      class Table
+
+        # The 'kern' table contains kerning values, i.e. values to control inter-character spacing.
+        #
+        # Restrictions:
+        #
+        # * Only subtable format 0 is supported, all other subtables are ignored.
+        #
+        # See: https://www.microsoft.com/typography/otspec/kern.htm
+        class Kern < Table
+
+          # A kerning subtable containing the actual information to do kerning.
+          class Subtable
+
+            # Creates a new subtable.
+            def initialize(pairs:, horizontal:, minimum_values:, cross_stream:)
+              @pairs = pairs
+              @horizontal = horizontal
+              @minimum_values = minimum_values
+              @cross_stream = cross_stream
+            end
+
+            # Returns the kerning value between the two glyphs, or +nil+ if there is no kerning
+            # value.
+            def kern(left, right)
+              @pairs.fetch(left, nil)&.fetch(right, nil)
+            end
+
+            # Returns +true+ if this subtable is used for horizontal kerning.
+            def horizontal?
+              @horizontal
+            end
+
+            # Returns +true+ if this subtable contains minimum values and not kerning values.
+            def minimum_values?
+              @minimum_values
+            end
+
+            # Returns +true+ if this subtable contains cross-stream values, i.e. values that are
+            # applied perpendicular to the writing direction.
+            def cross_stream?
+              @cross_stream
+            end
+
+          end
+
+          # The version of the table.
+          attr_accessor :version
+
+          # The available subtables, all instances of Subtable.
+          attr_reader :subtables
+
+          # Returns the first subtable that supports horizontal non-cross-stream kerning, or +nil+
+          # if no such subtable exists.
+          def horizontal_kerning_subtable
+            @horizontal_kerning_subtable
+          end
+
+          private
+
+          def parse_table #:nodoc:
+            @version, nr_of_subtables = read_formatted(4, 'nn')
+            subtable_parsing_method = :parse_subtable0
+            if @version == 1
+              @version = Rational(@version << 16 + nr_of_subtables, 65536)
+              nr_of_subtables = read_formatted(4, 'N').first
+              subtable_parsing_method = :parse_subtable1
+            end
+
+            @subtables = []
+            send(subtable_parsing_method, nr_of_subtables) do |length, format, options|
+              if format == 0
+                pairs = Format0.parse(io, length)
+                @subtables << Subtable.new(pairs: pairs, **options)
+              elsif font.config['font.true_type.unknown_format'] == :raise
+                raise HexaPDF::Error, "Unsupported kern subtable format: #{format}"
+              else
+                io.pos += length
+              end
+            end
+            @horizontal_kerning_subtable = @subtables.find do |t|
+              t.horizontal? && !t.minimum_values? && !t.cross_stream?
+            end
+          end
+
+          # Parses subtables for kern table version 0.
+          def parse_subtable0(nr_of_subtables)
+            nr_of_subtables.times do
+              length, format, coverage = read_formatted(6, 'x2nCC')
+              options = {horizontal: (coverage[0] == 1),
+                         minimum_values: (coverage[1] == 1),
+                         cross_stream: (coverage[2] == 1)}
+              yield(length - 6, format, options)
+            end
+          end
+
+          # Parses subtables for kern table version 1.
+          def parse_subtable1(nr_of_subtables)
+            nr_of_subtables.times do
+              length, coverage, format = read_formatted(8, 'NCC')
+              options = {horizontal: (coverage[7] == 0),
+                         minimum_values: false,
+                         cross_stream: (coverage[6] == 1)}
+              yield(length - 8, format, options)
+            end
+          end
+
+          # 'kern' subtable format 0
+          module Format0
+
+            # :call-seq:
+            #   Format0.parse(io, length)    -> pairs
+            #
+            # Parses the format 0 subtable and returns a hash of the form
+            #   {left_char: {right_char: kern_value}}
+            def self.parse(io, _length)
+              number_of_pairs = io.read(8).unpack('n').first
+              pairs = Hash.new {|h, k| h[k] = {}}
+              io.read(number_of_pairs * 6).unpack('n*').each_slice(3) do |left, right, value|
+                pairs[left][right] = (value < 0x8000 ? value : -(value ^ 0xffff) - 1)
+              end
+              pairs
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -102,7 +102,11 @@ module HexaPDF
                            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}"
+                             if font.config['font.true_type.unknown_format'] == :raise
+                               raise HexaPDF::Error, "Unsupported post table format: #{@format}"
+                             else
+                               []
+                             end
                            end
           end
 

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -33,6 +33,7 @@
 
 require 'hexapdf/font/true_type'
 require 'hexapdf/font/cmap'
+require 'hexapdf/font/invalid_glyph'
 require 'hexapdf/error'
 
 module HexaPDF
@@ -58,10 +59,34 @@ module HexaPDF
         # The glyph ID.
         attr_reader :id
 
+        # The string representation of the glyph.
+        attr_reader :str
+
         # Creates a new Glyph object.
-        def initialize(font, id)
+        def initialize(font, id, str)
           @font = font
           @id = id
+          @str = str
+        end
+
+        # Returns the glyph's minimum x coordinate.
+        def x_min
+          @x_min ||= @font[:glyf][id].x_min * 1000.0 / @font[:head].units_per_em
+        end
+
+        # Returns the glyph's maximum x coordinate.
+        def x_max
+          @x_max ||= @font[:glyf][id].x_max * 1000.0 / @font[:head].units_per_em
+        end
+
+        # Returns the glyph's minimum y coordinate.
+        def y_min
+          @y_min ||= @font[:glyf][id].y_min * 1000.0 / @font[:head].units_per_em
+        end
+
+        # Returns the glyph's maximum y coordinate.
+        def y_max
+          @y_max ||= @font[:glyf][id].y_max * 1000.0 / @font[:head].units_per_em
         end
 
         # Returns the width of the glyph.
@@ -69,11 +94,15 @@ module HexaPDF
           @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
+        # Returns +false+ since the word spacing parameter is never applied for multibyte font
+        # encodings where each glyph is encoded using two bytes.
+        def apply_word_spacing?
+          false
+        end
+
+        #:nodoc:
+        def inspect
+          "#<#{self.class.name} font=#{@font.full_name.inspect} id=#{id} #{str.inspect}>"
         end
 
       end
@@ -108,6 +137,16 @@ module HexaPDF
         @encoded_glyphs = {}
       end
 
+      # Returns the type of the font, i.e. :TrueType.
+      def font_type
+        :TrueType
+      end
+
+      # Returns the scaling factor for converting font units into PDF units.
+      def scaling_factor
+        @scaling_factor ||= 1000.0 / @wrapped_font[:head].units_per_em
+      end
+
       # Returns +true+ if the wrapped TrueType font will be subset.
       def subset?
         !@subsetter.nil?
@@ -115,14 +154,18 @@ module HexaPDF
 
       # Returns a Glyph object for the given glyph ID.
       #
+      # The optional argument +str+ should be the string representation of the glyph. Only use it if
+      # it is known,
+      #
       # Note: Although this method is public, it should normally not be used by application code!
-      def glyph(id)
+      def glyph(id, str = nil)
         @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)
+            if id >= 0 && id < @wrapped_font[:maxp].num_glyphs
+              Glyph.new(@wrapped_font, id, str || ('' << (@cmap.gid_to_code(id) || 0xFFFD)))
+            else
+              @document.config['font.on_missing_glyph'].call("\u{FFFD}", font_type, @wrapped_font)
             end
-            Glyph.new(@wrapped_font, id)
           end
       end
 
@@ -131,8 +174,11 @@ module HexaPDF
         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)
+              if (gid = @cmap[c])
+                glyph(gid, '' << c)
+              else
+                @document.config['font.on_missing_glyph'].call('' << c, font_type, @wrapped_font)
+              end
             end
         end
       end
@@ -141,6 +187,9 @@ module HexaPDF
       def encode(glyph)
         @encoded_glyphs[glyph] ||=
           begin
+            if glyph.kind_of?(InvalidGlyph)
+              raise HexaPDF::Error, "Glyph for #{glyph.str.inspect} missing"
+            end
             if @subsetter
               [@subsetter.use_glyph(glyph.id)].pack('n')
             else
@@ -158,32 +207,30 @@ module HexaPDF
       #
       # See: #complete_font_dict
       def build_font_dict
-        scaling = 1000.0 / @wrapped_font[:head].units_per_em
-
         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},
+                           FontBBox: @wrapped_font.bounding_box.map {|m| m * scaling_factor},
                            ItalicAngle: @wrapped_font.italic_angle || 0,
-                           Ascent: @wrapped_font.ascender * scaling,
-                           Descent: @wrapped_font.descender * scaling,
+                           Ascent: @wrapped_font.ascender * scaling_factor,
+                           Descent: @wrapped_font.descender * scaling_factor,
                            StemV: @wrapped_font.dominant_vertical_stem_width)
         if @wrapped_font[:'OS/2'].version >= 2
-          fd[:CapHeight] = @wrapped_font.cap_height * scaling
-          fd[:XHeight] = @wrapped_font.x_height * scaling
+          fd[:CapHeight] = @wrapped_font.cap_height * scaling_factor
+          fd[:XHeight] = @wrapped_font.x_height * scaling_factor
         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
+                             @wrapped_font[:glyf][@cmap[0x0048]].y_max * scaling_factor
                            else
-                             @wrapped_font.ascender * 0.8 * scaling
+                             @wrapped_font.ascender * 0.8 * scaling_factor
                            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
+                           @wrapped_font[:glyf][@cmap[0x0078]].y_max * scaling_factor
                          else
-                           @wrapped_font.ascender * 0.5 * scaling
+                           @wrapped_font.ascender * 0.5 * scaling_factor
                          end
         end
 
@@ -247,7 +294,7 @@ module HexaPDF
 
       # Adds the /DW and /W fields to the CIDFont dictionary.
       def complete_width_information
-        default_width = glyph(3).width.to_i
+        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!

data/lib/hexapdf/font/type1/afm_parser.rb

@@ -153,8 +153,9 @@ module HexaPDF
               char.name = $3.to_sym
               char.bbox = [$4.to_i, $5.to_i, $6.to_i, $7.to_i]
               if $8
+                @metrics.ligature_pairs[char.name] = {}
                 $8.scan(/L (\S+) (\S+)/).each do |name, ligature|
-                  char.ligatures[name] = ligature
+                  @metrics.ligature_pairs[char.name][name.to_sym] = ligature.to_sym
                 end
               end
             end
@@ -170,7 +171,7 @@ module HexaPDF
           parse_integer.times do
             read_line
             if @line =~ /KPX (\S+) (\S+) (\S+)/
-              @metrics.kerning_pairs[$1][$2] = $3.to_i
+              (@metrics.kerning_pairs[$1.to_sym] ||= {})[$2.to_sym] = $3.to_i
             end
           end
         end

data/lib/hexapdf/font/type1/character_metrics.rb

@@ -51,15 +51,6 @@ module HexaPDF
         # the lower-left corner and the x- and y-coordinates of the upper-right corner.
         attr_accessor :bbox
 
-        # Mapping of possible ligatures. This character combined with the character specified by a
-        # key forms the ligature character stored as value of that key. Both keys and values are
-        # character names.
-        attr_accessor :ligatures
-
-        def initialize #:nodoc:
-          @ligatures = {}
-        end
-
       end
 
     end

data/lib/hexapdf/font/type1/font.rb

@@ -32,6 +32,7 @@
 #++
 
 require 'forwardable'
+require 'set'
 require 'hexapdf/font/type1'
 require 'hexapdf/font/encoding'
 
@@ -117,6 +118,16 @@ module HexaPDF
           :'.notdef'
         end
 
+        # Returns a set of features this font supports.
+        #
+        # For Type1 fonts, the features that may be available :kern and :liga.
+        def features
+          @features ||= Set.new.tap do |set|
+            set << :kern unless metrics.kerning_pairs.empty?
+            set << :liga unless metrics.ligature_pairs.empty?
+          end
+        end
+
       end
 
     end

data/lib/hexapdf/font/type1/font_metrics.rb

@@ -105,9 +105,14 @@ module HexaPDF
         # mapping from the second character name to the kerning amount.
         attr_accessor :kerning_pairs
 
+        # Nested mapping of ligature pairs, ie. each key is a character name and each value is a
+        # mapping from the second character name to the ligature name.
+        attr_accessor :ligature_pairs
+
         def initialize #:nodoc:
           @character_metrics = {}
-          @kerning_pairs = Hash.new {|h, k| h[k] = {}}
+          @kerning_pairs = {}
+          @ligature_pairs = {}
         end
 
         WEIGHT_NAME_TO_NUMBER = {'Bold' => 700, 'Medium' => 500, 'Roman' => 400}.freeze #:nodoc:

data/lib/hexapdf/font/type1_wrapper.rb

@@ -49,10 +49,34 @@ module HexaPDF
         attr_reader :name
         alias_method :id, :name
 
+        # The string representation of the glyph.
+        attr_reader :str
+
         # Creates a new Glyph object.
-        def initialize(font, name)
+        def initialize(font, name, str)
           @font = font
           @name = name
+          @str = str
+        end
+
+        # Returns the glyph's minimum x coordinate.
+        def x_min
+          @font.metrics.character_metrics[name].bbox[0]
+        end
+
+        # Returns the glyph's maximum x coordinate.
+        def x_max
+          @font.metrics.character_metrics[name].bbox[2]
+        end
+
+        # Returns the glyph's minimum y coordinate.
+        def y_min
+          @font.metrics.character_metrics[name].bbox[1]
+        end
+
+        # Returns the glyph's maximum y coordinate.
+        def y_max
+          @font.metrics.character_metrics[name].bbox[3]
         end
 
         # Returns the width of the glyph.
@@ -60,11 +84,16 @@ module HexaPDF
           @width ||= @font.width(name)
         end
 
-        # Returns +true+ if the glyph represents the space character.
-        def space?
+        # Returns +true+ if the word spacing parameter needs to be applied for the glyph.
+        def apply_word_spacing?
           @name == :space
         end
 
+        #:nodoc:
+        def inspect
+          "#<#{self.class.name} font=#{@font.full_name.inspect} id=#{name.inspect} #{str.inspect}>"
+        end
+
       end
 
       private_constant :Glyph
@@ -101,14 +130,26 @@ module HexaPDF
         @encoded_glyphs = {}
       end
 
+      # Returns the type of the font, i.e. :Type1.
+      def font_type
+        :Type1
+      end
+
+      # Returns 1 since all Type1 fonts use 1000 units for the em-square.
+      def scaling_factor
+        1
+      end
+
       # Returns a Glyph object for the given glyph name.
       def glyph(name)
         @name_to_glyph[name] ||=
           begin
-            unless @wrapped_font.metrics.character_metrics.key?(name)
-              name = @document.config['font.on_missing_glyph'].call(name, @wrapped_font)
+            str = Encoding::GlyphList.name_to_unicode(name, @zapf_dingbats_opt)
+            if @wrapped_font.metrics.character_metrics.key?(name)
+              Glyph.new(@wrapped_font, name, str)
+            else
+              @document.config['font.on_missing_glyph'].call(str, font_type, @wrapped_font)
             end
-            Glyph.new(@wrapped_font, name)
           end
       end
 
@@ -118,7 +159,7 @@ module HexaPDF
           @codepoint_to_glyph[c] ||=
             begin
               name = Encoding::GlyphList.unicode_to_name('' << c, @zapf_dingbats_opt)
-              name = '' << c if name == :'.notdef'
+              name = "u" << c.to_s(16).rjust(6, '0') if name == :'.notdef'
               glyph(name)
             end
         end
@@ -128,6 +169,9 @@ module HexaPDF
       def encode(glyph)
         @encoded_glyphs[glyph.name] ||=
           begin
+            if glyph.name == @wrapped_font.missing_glyph_id
+              raise HexaPDF::Error, "Glyph for #{glyph.str.inspect} missing"
+            end
             code = @encoding.code_to_name.key(glyph.name)
             if code
               code.chr.freeze