hexapdf 0.4.0 → 0.5.0

data/examples/text_box_styling.rb

@@ -0,0 +1,72 @@
+# ## Text Box Styling
+#
+# The text used as part of a [HexaPDF::Layout::TextBox] class can be styled
+# using [HexaPDF::Layout::Style]. To do this [HexaPDF::Layout::TextFragment]
+# objects have to be created with the needed styling and then added to a text
+# box. In addition the style objects can be used for styling text boxes
+# themselves.
+#
+# This example shows how to do this and shows off the various styling option.
+#
+# Usage:
+# : `ruby text_box_styling.rb`
+#
+
+require 'hexapdf'
+
+# Wraps the text in a TextFragment using the given style.
+def fragment(text, style)
+  HexaPDF::Layout::TextFragment.new(items: style.font.decode_utf8(text),
+                                    style: style)
+end
+
+# Draws the text box at the given [x, y] position onto the canvas.
+def draw_box(box, canvas, x, y)
+  rest, height = box.fit
+  raise "Error" unless rest.empty?
+  box.draw(canvas, x, y)
+  y - height
+end
+
+sample_text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit,
+sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
+enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut
+aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit
+in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
+Excepteur sint occaecat cupidatat non proident, sunt in culpa qui
+officia deserunt mollit anim id est laborum. ".tr("\n", ' ') * 3
+
+doc = HexaPDF::Document.new
+
+heading = HexaPDF::Layout::Style.new(font: doc.fonts.load("Helvetica", variant: :bold),
+                                     font_size: 16, align: :center)
+body = HexaPDF::Layout::Style.new(font: doc.fonts.load("Times"),
+                                  font_size: 10, align: :justify,
+                                  text_indent: 20)
+body.line_spacing(:proportional, 1.5)
+standout = HexaPDF::Layout::Style.new(font: doc.fonts.load("Times", variant: :bold),
+                                      font_size: 14)
+
+canvas = doc.pages.add.canvas
+y_base = 800
+left = 50
+width = 500
+
+box = HexaPDF::Layout::TextBox.new(items: [fragment("This is a header", heading)],
+                                   width: width, style: heading)
+y_base = draw_box(box, canvas, left, y_base)
+
+box = HexaPDF::Layout::TextBox.new(items: [fragment(sample_text, body)],
+                                   width: width, style: body)
+y_base = draw_box(box, canvas, left, y_base - 20)
+
+items = [
+  fragment(sample_text[0, 50], body), fragment(sample_text[50, 15], standout),
+  fragment(sample_text[65, 150], body), fragment(sample_text[215, 50], standout),
+  fragment(sample_text[265...800], body), fragment(sample_text[800, 40], standout),
+  fragment(sample_text[840..-1], body)
+]
+box = HexaPDF::Layout::TextBox.new(items: items, width: width, style: body)
+draw_box(box, canvas, left, y_base - 20)
+
+doc.write("text_box_styling.pdf", optimize: true)

data/examples/truetype.rb

@@ -11,13 +11,12 @@
 # usual.
 #
 # Usage:
-# : `ruby truetype.pdf [FONT_FILE]`
+# : `ruby truetype.rb [FONT_FILE]`
 #
 
 require 'hexapdf'
 
 doc = HexaPDF::Document.new
-doc.config['font.on_missing_glyph'] = ->(_, f) { f.missing_glyph_id }
 doc.config['font.map'] = {
   'myfont' => {none: ARGV.shift || File.join(__dir__, '../test/data/fonts/Ubuntu-Title.ttf')},
 }
@@ -26,7 +25,7 @@ wrapper = doc.fonts.load('myfont')
 max_gid = wrapper.wrapped_font[:maxp].num_glyphs
 
 255.times do |page|
-  break unless page * 256 < wrapper.wrapped_font[:maxp].num_glyphs
+  break unless page * 256 < max_gid
   canvas = doc.pages.add.canvas
   canvas.font("Helvetica", size: 10)
   canvas.text("Font: #{wrapper.wrapped_font.full_name}", at: [50, 825])
@@ -37,7 +36,7 @@ max_gid = wrapper.wrapped_font[:maxp].num_glyphs
     canvas.show_glyphs((0..15).map do |i|
       gid = page * 256 + y * 16 + i
       glyph = wrapper.glyph(gid)
-      gid > max_gid ? [] : [glyph, -(2000 - glyph.width)]
+      gid >= max_gid ? [] : [glyph, -(2000 - glyph.width)]
     end.flatten!)
   end
 end

data/lib/hexapdf/cli/optimize.rb

@@ -87,10 +87,10 @@ module HexaPDF
         end
         doc.catalog[:Pages] = page_tree
 
-        doc.each(current: false) do |obj|
+        doc.each(current: false) do |obj, revision|
           next unless obj.kind_of?(HexaPDF::Dictionary)
           if (obj.type == :Pages || obj.type == :Page) && !retained.key?(obj.data)
-            doc.delete(obj)
+            revision.delete(obj)
           end
         end
       end

data/lib/hexapdf/configuration.rb

@@ -31,6 +31,7 @@
 # is created or manipulated using HexaPDF.
 #++
 
+require 'hexapdf/font/invalid_glyph'
 require 'hexapdf/error'
 
 module HexaPDF
@@ -159,11 +160,12 @@ module HexaPDF
   # font.on_missing_glyph::
   #    Callback hook when an UTF-8 character cannot be mapped to a glyph of a font.
   #
-  #    The value needs to be an object that responds to \#call(code_or_name, font) where
-  #    +code_or_name+ is the Unicode value or the glyph name for the missing glyph and returns a
-  #    substitute glyph name/ID to be used instead.
+  #    The value needs to be an object that responds to \#call(character, font_type, font) where
+  #    +character+ is the Unicode character for the missing glyph and returns a substitute glyph to
+  #    be used instead.
   #
-  #    The default implementation raises an error.
+  #    The default implementation returns an object of class HexaPDF::Font::InvalidGlyph which, when
+  #    not removed before encoding, will raise an error.
   #
   # font.on_missing_unicode_mapping::
   #    Callback hook when a character code point cannot be converted to a Unicode character.
@@ -233,8 +235,8 @@ module HexaPDF
   DefaultDocumentConfiguration =
     Configuration.new('document.auto_decrypt' => true,
                       'font.map' => {},
-                      'font.on_missing_glyph' => proc do |n, f|
-                        raise HexaPDF::Error, "No glyph for '#{n}' in font #{f.font_name} found"
+                      'font.on_missing_glyph' => proc do |char, _type, font|
+                        HexaPDF::Font::InvalidGlyph.new(font, char)
                       end,
                       'font.on_missing_unicode_mapping' => proc do |code_point, font|
                         raise HexaPDF::Error, "No Unicode mapping for code point #{code_point} " \

data/lib/hexapdf/content/canvas.rb

@@ -1322,10 +1322,13 @@ module HexaPDF
       #   canvas.word_spacing(amount)               => canvas
       #   canvas.word_spacing(amount) { block }     => canvas
       #
-      # The word spacing determines how much additional space is added when the ASCII space
-      # character is encountered in a text. For horizontal writing positive values increase the
-      # distance between two words, whereas for vertical writing negative values increase the
-      # distance.
+      # If the font's PDF encoding supports this, the word spacing determines how much additional
+      # space is added when the ASCII space character is encountered in a text. For horizontal
+      # writing positive values increase the distance between two words, whereas for vertical
+      # writing negative values increase the distance.
+      #
+      # Note that in HexaPDF only the standard 14 PDF Type1 fonts support this property! When using
+      # any other font, for example a TrueType font, this property has no effect.
       #
       # Returns the current word spacing value (see Content::GraphicsState#word_spacing) when no
       # argument is given. Otherwise sets the word spacing using the +amount+ argument and returns
@@ -1609,7 +1612,7 @@ module HexaPDF
       # See: PDF1.7 s9.2.2
       def font(name = nil, size: nil, **options)
         if name
-          @font = context.document.fonts.load(name, options)
+          @font = (name.respond_to?(:dict) ? name : context.document.fonts.load(name, options))
           if size
             font_size(size)
           else

data/lib/hexapdf/content/parser.rb

@@ -119,10 +119,11 @@ module HexaPDF
       def parse_number
         if (val = @ss.scan(/[+-]?\d++(?!\.)/))
           val.to_i
-        else
-          val = @ss.scan(/[+-]?(?:\d+\.\d*|\.\d+)/)
+        elsif (val = @ss.scan(/[+-]?(?:\d+\.\d*|\.\d+)/))
           val << '0'.freeze if val.getbyte(-1) == 46 # dot '.'
           Float(val)
+        else
+          parse_keyword
         end
       end
 

data/lib/hexapdf/content/processor.rb

@@ -305,7 +305,7 @@ module HexaPDF
       attr_reader :operators
 
       # The resources dictionary used during processing.
-      attr_accessor :resources
+      attr_reader :resources
 
       # The GraphicsState object containing the current graphics state.
       #
@@ -336,8 +336,19 @@ module HexaPDF
       def initialize(resources = nil)
         @operators = Operator::DEFAULT_OPERATORS.dup
         @graphics_state = GraphicsState.new
-        @resources = resources
         @graphics_object = :none
+        @original_resources = nil
+        self.resources = resources
+      end
+
+      # Sets the resources dictionary used during processing.
+      #
+      # The first time resources are set, they are also stored as the "original" resources. This is
+      # needed because form XObject don't need to have a resources dictionary and can use the page's
+      # resources dictionary instead.
+      def resources=(res)
+        @original_resources = res if @original_resources.nil?
+        @resources = res
       end
 
       # Processes the operator with the given operands.
@@ -364,7 +375,7 @@ module HexaPDF
         graphics_state.save
 
         graphics_state.ctm.premultiply(*xobject[:Matrix]) if xobject.key?(:Matrix)
-        xobject.process_contents(self)
+        xobject.process_contents(self, original_resources: @original_resources)
 
         graphics_state.restore
         self.resources = res

data/lib/hexapdf/document.rb

@@ -46,6 +46,7 @@ require 'hexapdf/writer'
 require 'hexapdf/importer'
 require 'hexapdf/image_loader'
 require 'hexapdf/font_loader'
+require 'hexapdf/layout'
 
 # == HexaPDF API Documentation
 #

data/lib/hexapdf/document/fonts.rb

@@ -67,7 +67,8 @@ module HexaPDF
         if font
           @loaded_fonts_cache[[name, options]] = font
         else
-          raise HexaPDF::Error, "The requested font '#{name}' couldn't be found"
+          raise HexaPDF::Error, "The requested font '#{name}' in variant '#{options[:variant]}' " \
+            "couldn't be found"
         end
       end
 

data/lib/hexapdf/document/pages.rb

@@ -31,6 +31,8 @@
 # is created or manipulated using HexaPDF.
 #++
 
+require 'hexapdf/error'
+
 module HexaPDF
   class Document
 
@@ -52,8 +54,29 @@ module HexaPDF
         @document.catalog.pages
       end
 
+      # :call-seq:
+      #   pages.add             -> new_page
+      #   pages.add(media_box)  -> new_page
+      #   pages.add(page)       -> page
+      #
       # Adds the page or a new empty page at the end and returns it.
+      #
+      # If no argument is given, a new page with the default dimensions (see configuration option
+      # 'page.default_media_box') is used. If the single argument is an array with four numbers
+      # (specifying the media box) or a symbol (referencing a pre-defined media box, see
+      # HexaPDF::Type::Page::PAPER_SIZE), the new page will have these dimensions.
       def add(page = nil)
+        case page
+        when Array
+          page = @document.add(Type: :Page, MediaBox: page)
+        when Symbol
+          if Type::Page::PAPER_SIZE.key?(page)
+            media_box = Type::Page::PAPER_SIZE[page].dup
+            page = @document.add(Type: :Page, MediaBox: media_box)
+          else
+            raise HexaPDF::Error, "Invalid page format specified: #{page}"
+          end
+        end
         @document.catalog.pages.add_page(page)
       end
 

data/lib/hexapdf/font/invalid_glyph.rb

@@ -0,0 +1,78 @@
+# -*- 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
+
+    # Represents an invalid glyph, i.e. a Unicode character that has no representation in the used
+    # font.
+    class InvalidGlyph
+
+      # The string that could not be represented as a glyph.
+      attr_reader :str
+
+      # Creates a new Glyph object.
+      def initialize(font, str)
+        @font = font
+        @str = str
+      end
+
+      # Returns the appropriate missing glyph id based on the used font.
+      def id
+        @font.missing_glyph_id
+      end
+      alias_method :name, :id
+
+      # Returns 0.
+      def x_min
+        0
+      end
+      alias_method :x_max, :x_min
+      alias_method :y_min, :x_min
+      alias_method :y_max, :x_min
+      alias_method :width, :x_min
+
+      # Word spacing is never applied for the invalid glyph, so +false+ is returned.
+      def apply_word_spacing?
+        false
+      end
+
+      #:nodoc:
+      def inspect
+        "#<#{self.class.name} font=#{@font.full_name.inspect} id=#{id} #{@str.inspect}>"
+      end
+
+    end
+
+  end
+end

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

@@ -32,6 +32,7 @@
 #++
 
 require 'hexapdf/font/true_type/table'
+require 'set'
 
 module HexaPDF
   module Font
@@ -45,8 +46,8 @@ module HexaPDF
         # font.ttf.table_mapping::
         #     The default mapping from table tag as symbol to table class name.
         #
-        # font.ttf.cmap.unknown_format::
-        #     Action to take when encountering unknown 'cmap' subtables. Can either be :ignore
+        # font.ttf.unknown_format::
+        #     Action to take when encountering unknown subtables. Can either be :ignore
         #     which ignores them or :raise which raises an error.
         DEFAULT_CONFIG = {
           'font.true_type.table_mapping' => {
@@ -60,8 +61,9 @@ module HexaPDF
             post: 'HexaPDF::Font::TrueType::Table::Post',
             glyf: 'HexaPDF::Font::TrueType::Table::Glyf',
             'OS/2': 'HexaPDF::Font::TrueType::Table::OS2',
+            kern: 'HexaPDF::Font::TrueType::Table::Kern',
           },
-          'font.true_type.cmap.unknown_format' => :ignore,
+          'font.true_type.unknown_format' => :ignore,
         }
 
 
@@ -93,6 +95,15 @@ module HexaPDF
           @directory ||= Table::Directory.new(self, io ? Table::Directory::SELF_ENTRY : nil)
         end
 
+        # Returns a set of features this font supports.
+        #
+        # Features that may be available are for example :kern or :liga.
+        def features
+          @features ||= Set.new.tap do |set|
+            set << :kern if self[:kern]&.horizontal_kerning_subtable
+          end
+        end
+
         # Returns the PostScript font name.
         def font_name
           self[:name][:postscript_name].preferred_record

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

@@ -53,6 +53,7 @@ module HexaPDF
         autoload(:Post, 'hexapdf/font/true_type/table/post')
         autoload(:Glyf, 'hexapdf/font/true_type/table/glyf')
         autoload(:OS2,  'hexapdf/font/true_type/table/os2')
+        autoload(:Kern, 'hexapdf/font/true_type/table/kern')
 
 
         # The time Epoch used in sfnt-formatted font files.

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

@@ -64,7 +64,7 @@ module HexaPDF
           def parse_table #:nodoc:
             @version, num_tables = read_formatted(4, 'n2')
             @tables = []
-            handle_unknown = font.config['font.true_type.cmap.unknown_format']
+            handle_unknown = font.config['font.true_type.unknown_format']
 
             num_tables.times { @tables << read_formatted(8, 'n2N') }
             offset_map = {}

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

@@ -267,6 +267,7 @@ module HexaPDF
                 offset = id_range_offsets[index]
                 if offset != 0
                   glyph_id = glyph_indexes[offset - end_codes.length + (code - start_codes[index])]
+                  glyph_id ||= 0 # Handle invalid subtable entries
                   glyph_id = (glyph_id + id_deltas[index]) % 65536 if glyph_id != 0
                 else
                   glyph_id = (code + id_deltas[index]) % 65536

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

@@ -82,6 +82,10 @@ module HexaPDF
               @raw_data = raw_data
               @number_of_contours, @x_min, @y_min, @x_max, @y_max = @raw_data.unpack('s>5')
               @number_of_contours ||= 0
+              @x_min ||= 0
+              @y_min ||= 0
+              @x_max ||= 0
+              @y_max ||= 0
               @components = nil
               @component_offsets = nil
               parse_compound_glyph if compound?