hexapdf 0.3.0 → 0.4.0

data/lib/hexapdf/type/font.rb

@@ -51,28 +51,48 @@ module HexaPDF
         true
       end
 
-      # Returns the UTF-8 string for the given character code, or an empty string if no mapping was
-      # found.
+      # Returns the UTF-8 string for the given character code, or calls the configuration option
+      # 'font.on_missing_unicode_mapping' if no mapping was found.
       def to_utf8(code)
-        if to_unicode_cmap
-          to_unicode_cmap.to_unicode(code)
+        to_unicode_cmap && to_unicode_cmap.to_unicode(code) || missing_unicode_mapping(code)
+      end
+
+      # Returns the bounding box of the font or +nil+ if it is not found.
+      def bounding_box
+        if key?(:FontDescriptor) && self[:FontDescriptor].key?(:FontBBox)
+          self[:FontDescriptor][:FontBBox].value
         else
-          ''.freeze
+          nil
         end
       end
 
+      # Returns +true+ if the font is embedded.
+      def embedded?
+        dict = self[:FontDescriptor]
+        dict && (dict[:FontFile] || dict[:FontFile2] || dict[:FontFile3])
+      end
+
+      # Returns the embeeded font file object or +nil+ if the font is not embedded.
+      def font_file
+        embedded?
+      end
+
       private
 
       # Parses and caches the ToUnicode CMap.
       def to_unicode_cmap
-        unless defined?(@to_unicode_cmap)
-          @to_unicode_cmap = if key?(:ToUnicode)
-                               HexaPDF::Font::CMap.parse(self[:ToUnicode].stream)
-                             else
-                               nil
-                             end
+        document.cache(@data, :to_unicode_cmap) do
+          if key?(:ToUnicode)
+            HexaPDF::Font::CMap.parse(self[:ToUnicode].stream)
+          else
+            nil
+          end
         end
-        @to_unicode_cmap
+      end
+
+      # Calls the configured proc for handling missing unicode mappings.
+      def missing_unicode_mapping(code)
+        @document.config['font.on_missing_unicode_mapping'].call(code, self)
       end
 
     end

data/lib/hexapdf/type/font_simple.rb

@@ -54,31 +54,30 @@ module HexaPDF
       #
       # Note that the encoding is cached internally when accessed the first time.
       def encoding
-        @encoding ||=
-          begin
-            case (val = self[:Encoding])
-            when Symbol
-              encoding = HexaPDF::Font::Encoding.for_name(val)
-              encoding = encoding_from_font if encoding.nil?
-              encoding
-            when HexaPDF::Dictionary, Hash
-              encoding = val[:BaseEncoding]
-              encoding = HexaPDF::Font::Encoding.for_name(encoding) if encoding
-              unless encoding
-                if embedded? || symbolic?
-                  encoding = encoding_from_font
-                else
-                  encoding = HexaPDF::Font::Encoding.for_name(:StandardEncoding)
-                end
+        document.cache(@data, :encoding) do
+          case (val = self[:Encoding])
+          when Symbol
+            encoding = HexaPDF::Font::Encoding.for_name(val)
+            encoding = encoding_from_font if encoding.nil?
+            encoding
+          when HexaPDF::Dictionary, Hash
+            encoding = val[:BaseEncoding]
+            encoding = HexaPDF::Font::Encoding.for_name(encoding) if encoding
+            unless encoding
+              if embedded? || symbolic?
+                encoding = encoding_from_font
+              else
+                encoding = HexaPDF::Font::Encoding.for_name(:StandardEncoding)
               end
-              encoding = difference_encoding(encoding, val[:Differences]) if val.key?(:Differences)
-              encoding
-            when nil
-              encoding_from_font
-            else
-              raise HexaPDF::Error, "Unknown value for font's encoding: #{self[:Encoding]}"
             end
+            encoding = difference_encoding(encoding, val[:Differences]) if val.key?(:Differences)
+            encoding
+          when nil
+            encoding_from_font
+          else
+            raise HexaPDF::Error, "Unknown value for font's encoding: #{self[:Encoding]}"
           end
+        end
       end
 
       # Decodes the given string into an array of character codes.
@@ -86,12 +85,11 @@ module HexaPDF
         string.bytes
       end
 
-      # Returns the UTF-8 string for the given character code, or an empty string if no mapping was
-      # found.
+      # Returns the UTF-8 string for the given character code, or calls the configuration option
+      # 'font.on_missing_unicode_mapping' if no mapping was found.
       def to_utf8(code)
-        str = super
-        str = encoding.unicode(code) if str.empty?
-        str
+        (to_unicode_cmap && to_unicode_cmap.to_unicode(code)) ||
+          encoding.unicode(code) || missing_unicode_mapping(code)
       end
 
       # Returns the unscaled width of the given code point in glyph units, or 0 if the width for
@@ -110,32 +108,26 @@ module HexaPDF
         end
       end
 
-      # Returns the bounding box of the font or +nil+ if it is not found.
-      def bounding_box
-        if key?(:FontDescriptor) && self[:FontDescriptor].key?(:FontBBox)
-          self[:FontDescriptor][:FontBBox].value
-        else
-          nil
-        end
-      end
-
       # Returns the writing mode which is always :horizontal for simple fonts like Type1.
       def writing_mode
         :horizontal
       end
 
-      # Returns +true+ if the font is embedded.
-      def embedded?
-        dict = self[:FontDescriptor]
-        dict && (dict[:FontFile] || dict[:FontFile2] || dict[:FontFile3])
-      end
-
       # Returns +true+ if the font is a symbolic font, +false+ if it is not, and +nil+ if it is
       # not known.
       def symbolic?
         self[:FontDescriptor] && self[:FontDescriptor].flagged?(:symbolic) || nil
       end
 
+      # Returns whether word spacing is applicable when using this font.
+      #
+      # Always returns +true+ for simple fonts.
+      #
+      # See: PDF1.7 s9.3.3
+      def word_spacing_applicable?
+        true
+      end
+
       private
 
       # Tries to read the encoding from the embedded font.

data/lib/hexapdf/type/font_type0.rb

@@ -0,0 +1,148 @@
+# -*- 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'
+require 'hexapdf/stream'
+require 'hexapdf/font/cmap'
+
+module HexaPDF
+  module Type
+
+    # Represents a composite PDF font.
+    #
+    # Composites fonts wrap a descendant CIDFont and use CIDs to identify glyphs. A CID can be
+    # encoded in one or more bytes and an associated CMap specifies how this encoding is done.
+    # Composite fonts also allow for vertical writing mode and support TrueType as well as OpenType
+    # fonts.
+    #
+    # See: PDF1.7 s9.7
+    class FontType0 < Font
+
+      define_field :Subtype, type: Symbol, required: true, default: :Type0
+      define_field :Encoding, type: [Symbol, Stream], required: true
+      define_field :DescendantFonts, type: Array, required: true
+
+      # Returns the CID font of this type 0 font.
+      def descendant_font
+        document.cache(@data, :descendant_font) { document.deref(self[:DescendantFonts][0]) }
+      end
+
+      # Returns the writing mode which is either :horizontal or :vertical.
+      def writing_mode
+        cmap.wmode == 0 ? :horizontal : :vertical
+      end
+
+      # Decodes the given string into an array of CIDs.
+      def decode(string)
+        cmap.read_codes(string)
+      end
+
+      # Returns the UTF-8 string for the given code, or calls the configuration option
+      # 'font.on_missing_unicode_mapping' if no mapping was found.
+      def to_utf8(code)
+        (to_unicode_cmap && to_unicode_cmap.to_unicode(code)) ||
+          (ucs2_cmap && ucs2_cmap.to_unicode(code)) || missing_unicode_mapping(code)
+      end
+
+      # Returns the unscaled width of the given CID in glyph units, or 0 if the width for the code
+      # point is missing.
+      def width(code)
+        descendant_font.width(cmap.to_cid(code))
+      end
+
+      # Returns the bounding box of the font or +nil+ if it is not found.
+      def bounding_box
+        descendant_font.bounding_box
+      end
+
+      # Returns +true+ if the font is embedded.
+      def embedded?
+        descendant_font.embedded?
+      end
+
+      # Returns the embeeded font file object or +nil+ if the font is not embedded.
+      def font_file
+        descendant_font.font_file
+      end
+
+      # Returns whether word spacing is applicable when using this font.
+      #
+      # Note that the return value is cached when accessed the first time.
+      #
+      # See: PDF1.7 s9.3.3
+      def word_spacing_applicable?
+        @word_spacing_applicable ||= ((cmap.read_codes("\x20".freeze) && true) rescue false)
+      end
+
+      private
+
+      # Returns the CMap used for decoding strings for this font.
+      #
+      # Note that the CMap is cached internally when accessed the first time.
+      def cmap
+        document.cache(@data, :cmap) do
+          val = self[:Encoding]
+          if val.kind_of?(Symbol)
+            HexaPDF::Font::CMap.for_name(val.to_s)
+          elsif val.kind_of?(HexaPDF::Stream)
+            HexaPDF::Font::CMap.parse(val.stream)
+          else
+            raise HexaPDF::Error, "Unknown value for font's encoding: #{self[:Encoding]}"
+          end
+        end
+      end
+
+      # Returns the UCS-2 CMap used for extracting text when no ToUnicode CMap is available, or
+      # +nil+ if the UCS-2 CMap could not be determined.
+      #
+      # Note that the CMap is cached internally when accessed the first time.
+      #
+      # See: PDF1.7 s9.10.2
+      def ucs2_cmap
+        document.cache(@data, :ucs2_cmap) do
+          encoding = self[:Encoding]
+          system_info = descendant_font[:CIDSystemInfo]
+          registry = system_info[:Registry]
+          ordering = system_info[:Ordering]
+          if (encoding.kind_of?(Symbol) && HexaPDF::Font::CMap.predefined?(encoding.to_s) &&
+            encoding != :"Identity-H" && encoding != :"Identity-V") ||
+              (registry == "Adobe" && ['GB1', 'CNS1', 'Japan1', 'Korea1'].include?(ordering))
+            HexaPDF::Font::CMap.for_name("#{registry}-#{ordering}-UCS2")
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/type/form.rb

@@ -105,15 +105,15 @@ module HexaPDF
       #
       # *Note* that a canvas can only be retrieved for initially empty form XObjects!
       def canvas
-        unless defined?(@canvas)
+        document.cache(@data, :canvas) do
           unless stream.empty?
             raise HexaPDF::Error, "Cannot create a canvas for a form XObjects with contents"
           end
-          @canvas = Content::Canvas.new(self)
-          self.stream = @canvas.stream_data
+          canvas = Content::Canvas.new(self)
+          self.stream = canvas.stream_data
           set_filter(:FlateDecode)
+          canvas
         end
-        @canvas
       end
 
     end

data/lib/hexapdf/type/page.rb

@@ -135,7 +135,7 @@ module HexaPDF
       define_field :TemplateInstantiated, type: Symbol, version: '1.5'
       define_field :PresSteps,            type: Dictionary, version: '1.5'
       define_field :UserUnit,             type: Numeric, version: '1.6'
-      define_field :VP,                   type: Dictionary, version: '1.6'
+      define_field :VP,                   type: Array, version: '1.6'
 
       # Returns +true+ since page objects must always be indirect.
       def must_be_indirect?
@@ -234,7 +234,8 @@ module HexaPDF
         end
       end
 
-      # Returns the resource dictionary which is automatically created if it doesn't exist.
+      # Returns the possibly inherited resource dictionary which is automatically created if it
+      # doesn't exist.
       def resources
         self[:Resources] ||= document.wrap({}, type: :XXResources)
       end
@@ -277,8 +278,8 @@ module HexaPDF
         unless [:page, :overlay, :underlay].include?(type)
           raise ArgumentError, "Invalid value for 'type', expected: :page, :underlay or :overlay"
         end
-        @canvas_cache ||= {}
-        return @canvas_cache[type] if @canvas_cache.key?(type)
+        cache_key = "#{type}_canvas".intern
+        return document.cache(@data, cache_key) if document.cached?(@data, cache_key)
 
         if type == :page && key?(:Contents)
           raise HexaPDF::Error, "Cannot get the canvas for a page with contents"
@@ -286,18 +287,18 @@ module HexaPDF
 
         contents = self[:Contents]
         if contents.nil?
-          @canvas_cache[:page] = Content::Canvas.new(self)
+          page_canvas = document.cache(@data, :page_canvas, Content::Canvas.new(self))
           self[:Contents] = document.add({Filter: :FlateDecode},
-                                         stream: @canvas_cache[:page].stream_data)
+                                         stream: page_canvas.stream_data)
         end
 
         if type == :overlay || type == :underlay
-          @canvas_cache[:overlay] = Content::Canvas.new(self)
-          @canvas_cache[:underlay] = Content::Canvas.new(self)
+          underlay_canvas = document.cache(@data, :underlay_canvas, Content::Canvas.new(self))
+          overlay_canvas = document.cache(@data, :overlay_canvas, Content::Canvas.new(self))
 
           stream = HexaPDF::StreamData.new do
             Fiber.yield(" q ")
-            fiber = @canvas_cache[:underlay].stream_data.fiber
+            fiber = underlay_canvas.stream_data.fiber
             while fiber.alive? && (data = fiber.resume)
               Fiber.yield(data)
             end
@@ -307,7 +308,7 @@ module HexaPDF
 
           stream = HexaPDF::StreamData.new do
             Fiber.yield(" Q ")
-            fiber = @canvas_cache[:overlay].stream_data.fiber
+            fiber = overlay_canvas.stream_data.fiber
             while fiber.alive? && (data = fiber.resume)
               Fiber.yield(data)
             end
@@ -317,7 +318,7 @@ module HexaPDF
           self[:Contents] = [underlay, *self[:Contents], overlay]
         end
 
-        @canvas_cache[type]
+        document.cache(@data, cache_key)
       end
 
       # Creates a Form XObject from the page's dictionary and contents for the given PDF document.

data/lib/hexapdf/type/resources.rb

@@ -154,6 +154,20 @@ module HexaPDF
         object_setter(:Font, 'F'.freeze, object)
       end
 
+      # Returns the property list stored under the given name.
+      #
+      # If the property list is not found, an error is raised.
+      def property_list(name)
+        object_getter(:Properties, name)
+      end
+
+      # Adds the property list to the resources and returns the name under which it is stored.
+      #
+      # If there already exists a name for the given property list, it is just returned.
+      def add_property_list(dict)
+        object_setter(:Properties, 'P'.freeze, dict)
+      end
+
       private
 
       # Helper method for returning an entry of a subdictionary.

data/lib/hexapdf/utils/graphics_helpers.rb

@@ -0,0 +1,77 @@
+# -*- 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 Utils
+
+    # This module provides some helper functions for graphics.
+    module GraphicsHelpers
+
+      module_function
+
+      # Calculates and returns the requested dimensions for the rectangular object with the given
+      # +width+ and +height+ based on the following: options:
+      #
+      # +rwidth+::
+      #     The requested width. If +rheight+ is not specified, it is chosen so that the aspect
+      #     ratio is maintained
+      #
+      # +rheight+::
+      #     The requested height. If +rwidth+ is not specified, it is chosen so that the aspect
+      #     ratio is maintained
+      def calculate_dimensions(width, height, rwidth: nil, rheight: nil)
+        if rwidth && rheight
+          [rwidth, rheight]
+        elsif rwidth
+          [rwidth, height * rwidth / width.to_f]
+        elsif rheight
+          [width * rheight / height.to_f, rheight]
+        else
+          [width, height]
+        end
+      end
+
+      # Given two points p0 = (x0, y0) and p1 = (x1, y1), returns the point on the line through
+      # these points that is +distance+ units away from p0.
+      #
+      #   v = p1 - p0
+      #   result = p0 + distance * v/norm(v)
+      def point_on_line(x0, y0, x1, y1, distance:)
+        norm = Math.sqrt((x1 - x0)**2 + (y1 - y0)**2)
+        [x0 + distance / norm * (x1 - x0), y0 + distance / norm * (y1 - y0)]
+      end
+
+    end
+
+  end
+end