hexapdf 0.12.0 → 0.14.0

data/lib/hexapdf/type/acro_form/text_field.rb

@@ -44,6 +44,9 @@ module HexaPDF
       # AcroForm text fields provide a box or space to fill-in data entered from keyboard. The text
       # may be restricted to a single line or can span multiple lines.
       #
+      # A special type of single-line text field is the comb text field. This type of field divides
+      # the existing space into /MaxLen equally spaced positions.
+      #
       # == Type Specific Field Flags
       #
       # :multiline:: If set, the text field may contain multiple lines.
@@ -88,6 +91,63 @@ module HexaPDF
           }
         ).freeze
 
+        # Initializes the text field to be a multiline text field.
+        #
+        # This method should only be called directly after creating a new text field because it
+        # doesn't completely reset the object.
+        def initialize_as_multiline_text_field
+          flag(:multiline)
+          unflag(:file_select, :comb, :password)
+        end
+
+        # Initializes the text field to be a comb text field.
+        #
+        # This method should only be called directly after creating a new text field because it
+        # doesn't completely reset the object.
+        def initialize_as_comb_text_field
+          flag(:comb)
+          unflag(:file_select, :multiline, :password)
+        end
+
+        # Initializes the text field to be a password field.
+        #
+        # This method should only be called directly after creating a new text field because it
+        # doesn't completely reset the object.
+        def initialize_as_password_field
+          delete(:V)
+          flag(:password)
+          unflag(:comb, :multiline, :file_select)
+        end
+
+        # Initializes the text field to be a file select field.
+        #
+        # This method should only be called directly after creating a new text field because it
+        # doesn't completely reset the object.
+        def initialize_as_file_select_field
+          flag(:file_select)
+          unflag(:comb, :multiline, :password)
+        end
+
+        # Returns +true+ if this field is a multiline text field.
+        def multiline_text_field?
+          flagged?(:multiline) && !(flagged?(:file_select) || flagged?(:comb) || flagged?(:password))
+        end
+
+        # Returns +true+ if this field is a comb text field.
+        def comb_text_field?
+          flagged?(:comb) && !(flagged?(:file_select) || flagged?(:multiline) || flagged?(:password))
+        end
+
+        # Returns +true+ if this field is a password field.
+        def password_field?
+          flagged?(:password) && !(flagged?(:file_select) || flagged?(:multiline) || flagged?(:comb))
+        end
+
+        # Returns +true+ if this field is a file select field.
+        def file_select_field?
+          flagged?(:file_select) && !(flagged?(:password) || flagged?(:multiline) || flagged?(:comb))
+        end
+
         # Returns the field value, i.e. the text contents of the field, or +nil+ if no value is set.
         #
         # Note that modifying the returned value *might not* modify the text contents in case it is
@@ -147,11 +207,16 @@ module HexaPDF
         #
         # For information on how this is done see AppearanceGenerator.
         #
-        # Note that an appearance for a text field widget is *always* created even if there is an
-        # existing one to make sure the current field value is properly represented.
-        def create_appearances
+        # Note that no new appearances are created if the field value hasn't changed between
+        # invocations.
+        #
+        # By setting +force+ to +true+ the creation of the appearances can be forced.
+        def create_appearances(force: false)
+          current_value = field_value
           appearance_generator_class = document.config.constantize('acro_form.appearance_generator')
           each_widget do |widget|
+            next if !force && widget.cached?(:last_value) && widget.cache(:last_value) == current_value
+            widget.cache(:last_value, current_value, update: true)
             appearance_generator_class.new(widget).create_text_appearances
           end
         end
@@ -173,8 +238,9 @@ module HexaPDF
 
           if self[:V] && !(self[:V].kind_of?(String) || self[:V].kind_of?(HexaPDF::Stream))
             yield("Text field doesn't contain text but #{self[:V].class} object")
+            return
           end
-          if (max_len = self[:MaxLen]) && field_value.length > max_len
+          if (max_len = self[:MaxLen]) && field_value && field_value.length > max_len
             yield("Text contents of field '#{full_field_name}' is too long")
           end
         end

data/lib/hexapdf/type/actions/uri.rb

@@ -53,9 +53,10 @@ module HexaPDF
 
         def perform_validation #:nodoc:
           super
-          unless self[:URI].ascii_only?
+          uri = self[:URI]
+          if uri && !uri.ascii_only?
             yield("URIs have to contain ASCII characters only", true)
-            uri = self[:URI].dup.force_encoding(Encoding::BINARY)
+            uri = uri.dup.force_encoding(Encoding::BINARY)
             uri.encode!(Encoding::US_ASCII, fallback: lambda {|c| "%#{c.ord.to_s(16).upcase}" })
             self[:URI] = uri
           end

data/lib/hexapdf/type/annotations/widget.rb

@@ -307,10 +307,9 @@ module HexaPDF
             color = [0]
             if (da = self[:DA] || field[:DA])
               HexaPDF::Content::Parser.parse(da) do |obj, params|
-                if obj == :rg || obj == :g || obj == :k
-                  color = params.dup
-                elsif obj == :Tf
-                  size = params[1]
+                case obj
+                when :rg, :g, :k then color = params.dup
+                when :Tf then size = params[1]
                 end
               end
             end

data/lib/hexapdf/type/catalog.rb

@@ -120,12 +120,12 @@ module HexaPDF
       private
 
       # Ensures that there is a valid page tree.
-      def perform_validation
+      def perform_validation(&block)
         super
         unless key?(:Pages)
           yield("A PDF document needs a page tree", true)
           value[:Pages] = document.add({Type: :Pages})
-          value[:Pages].validate {|msg, correctable| yield(msg, correctable) }
+          value[:Pages].validate(&block)
         end
       end
 

data/lib/hexapdf/type/cid_font.rb

@@ -95,7 +95,7 @@ module HexaPDF
       #
       # See: PDF1.7 s9.7.4.3
       def widths
-        document.cache(@data, :widths) do
+        cache(:widths) do
           result = {}
           index = 0
           array = self[:W] || []

data/lib/hexapdf/type/file_specification.rb

@@ -220,7 +220,7 @@ module HexaPDF
 
         if document.catalog.key?(:Names) && document.catalog[:Names].key?(:EmbeddedFiles)
           tree = document.catalog[:Names][:EmbeddedFiles]
-          tree.each_entry.find_all {|_, spec| document.deref(spec) == self }.each do |(name, _)|
+          tree.each_entry.find_all {|_, spec| spec == self }.each do |(name, _)|
             tree.delete_entry(name)
           end
         end

data/lib/hexapdf/type/font.rb

@@ -102,7 +102,7 @@ module HexaPDF
 
       # Parses and caches the ToUnicode CMap.
       def to_unicode_cmap
-        document.cache(@data, :to_unicode_cmap) do
+        cache(:to_unicode_cmap) do
           if key?(:ToUnicode)
             HexaPDF::Font::CMap.parse(self[:ToUnicode].stream)
           else

data/lib/hexapdf/type/font_simple.rb

@@ -57,7 +57,7 @@ module HexaPDF
       #
       # Note that the encoding is cached internally when accessed the first time.
       def encoding
-        document.cache(@data, :encoding) do
+        cache(:encoding) do
           case (val = self[:Encoding])
           when Symbol
             encoding = HexaPDF::Font::Encoding.for_name(val)
@@ -170,7 +170,9 @@ module HexaPDF
         [:FirstChar, :LastChar, :Widths].each do |field|
           yield("Required field #{field} is not set", false) if self[field].nil?
         end
-        if self[:Widths].length != (self[:LastChar] - self[:FirstChar] + 1)
+
+        if key?(:Widths) && key?(:LastChar) && key?(:FirstChar) &&
+            self[:Widths].length != (self[:LastChar] - self[:FirstChar] + 1)
           yield("Invalid number of entries in field Widths", false)
         end
       end

data/lib/hexapdf/type/font_true_type.rb

@@ -48,8 +48,12 @@ module HexaPDF
       private
 
       def perform_validation
-        super
-        yield("Required field FontDescriptor is not set", false) if self[:FontDescriptor].nil?
+        std_font = FontType1::StandardFonts.standard_font?(self[:BaseFont])
+        super(ignore_missing_font_fields: std_font)
+
+        if self[:FontDescriptor].nil? && !std_font
+          yield("Required field FontDescriptor is not set", false)
+        end
       end
 
     end

data/lib/hexapdf/type/font_type0.rb

@@ -58,8 +58,8 @@ module HexaPDF
 
       # Returns the CID font of this type 0 font.
       def descendant_font
-        document.cache(@data, :descendant_font) do
-          document.wrap(document.deref(self[:DescendantFonts][0]))
+        cache(:descendant_font) do
+          document.wrap(self[:DescendantFonts][0])
         end
       end
 
@@ -116,7 +116,7 @@ module HexaPDF
       #
       # Note that the CMap is cached internally when accessed the first time.
       def cmap
-        document.cache(@data, :cmap) do
+        cache(:cmap) do
           val = self[:Encoding]
           if val.kind_of?(Symbol)
             HexaPDF::Font::CMap.for_name(val.to_s)
@@ -135,7 +135,7 @@ module HexaPDF
       #
       # See: PDF1.7 s9.10.2
       def ucs2_cmap
-        document.cache(@data, :ucs2_cmap) do
+        cache(:ucs2_cmap) do
           encoding = self[:Encoding]
           system_info = descendant_font[:CIDSystemInfo]
           registry = system_info[:Registry]

data/lib/hexapdf/type/form.rb

@@ -94,14 +94,18 @@ module HexaPDF
 
       # Replaces the contents of the form XObject with the given string.
       #
+      # This also clears the cache to avoid returning invalid objects.
+      #
       # Note: This is the same as #stream= but here for interface compatibility with Page.
       def contents=(data)
         self.stream = data
+        clear_cache
       end
 
       # Returns the resource dictionary which is automatically created if it doesn't exist.
       def resources
-        self[:Resources] ||= document.wrap({}, type: :XXResources)
+        self[:Resources] ||= document.wrap({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]},
+                                           type: :XXResources)
       end
 
       # Processes the content stream of the form XObject with the given processor object.
@@ -126,13 +130,22 @@ module HexaPDF
       # The canvas object is cached once it is created so that its graphics state is correctly
       # retained without the need for parsing its contents.
       #
+      # If the bounding box of the form XObject doesn't have its origin at (0, 0), the canvas origin
+      # is translated into the bottom left corner so that this detail doesn't matter when using the
+      # canvas. This means that the canvas' origin is always at the bottom left corner of the
+      # bounding box.
+      #
       # *Note* that a canvas can only be retrieved for initially empty form XObjects!
       def canvas
-        document.cache(@data, :canvas) do
+        cache(:canvas) do
           unless stream.empty?
             raise HexaPDF::Error, "Cannot create a canvas for a form XObjects with contents"
           end
+
           canvas = Content::Canvas.new(self)
+          if box.left != 0 || box.bottom != 0
+            canvas.save_graphics_state.translate(box.left, box.bottom)
+          end
           self.stream = canvas.stream_data
           set_filter(:FlateDecode)
           canvas

data/lib/hexapdf/type/image.rb

@@ -150,7 +150,7 @@ module HexaPDF
         color_space, = *self[:ColorSpace]
         if color_space == :Indexed
           result.indexed = true
-          color_space, = *document.deref(self[:ColorSpace][1])
+          color_space, = *self[:ColorSpace][1]
         end
         case color_space
         when :DeviceRGB, :CalRGB
@@ -240,7 +240,7 @@ module HexaPDF
         end
 
         if color_type == ImageLoader::PNG::INDEXED
-          palette_data = document.deref(self[:ColorSpace][3])
+          palette_data = self[:ColorSpace][3]
           palette_data = palette_data.stream unless palette_data.kind_of?(String)
           palette = ''.b
           if info.color_space == :rgb

data/lib/hexapdf/type/page.rb

@@ -304,7 +304,7 @@ module HexaPDF
       def contents
         Array(self[:Contents]).each_with_object("".b) do |content_stream, content|
           content << " " unless content.empty?
-          content << document.deref(content_stream).stream
+          content << content_stream.stream
         end
       end
 
@@ -323,10 +323,11 @@ module HexaPDF
         end
       end
 
-      # Returns the possibly inherited resource dictionary which is automatically created if it
+      # Returns the, possibly inherited, resource dictionary which is automatically created if it
       # doesn't exist.
       def resources
-        self[:Resources] ||= document.wrap({}, type: :XXResources)
+        self[:Resources] ||= document.wrap({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]},
+                                           type: :XXResources)
       end
 
       # Processes the content streams associated with the page with the given processor object.
@@ -344,8 +345,7 @@ module HexaPDF
         node = self
         while (parent_node = node[:Parent])
           parent_node[:Kids].each do |kid|
-            kid = document.deref(kid)
-            break if kid.data == node.data
+            break if kid == node
             idx += (kid.type == :Page ? 1 : kid[:Count])
           end
           node = parent_node
@@ -353,11 +353,26 @@ module HexaPDF
         idx
       end
 
+      # Returns all parent nodes of the page up to the root of the page tree.
+      #
+      # The direct parent is the first node in the array and the root node the last.
+      def ancestor_nodes
+        parent = self[:Parent]
+        result = [parent]
+        result << parent while (parent = parent[:Parent])
+        result
+      end
+
       # Returns the requested type of canvas for the page.
       #
       # The canvas object is cached once it is created so that its graphics state is correctly
       # retained without the need for parsing its contents.
       #
+      # If the media box of the page doesn't have its origin at (0, 0), the canvas origin is
+      # translated into the bottom left corner so that this detail doesn't matter when using the
+      # canvas. This means that the canvas' origin is always at the bottom left corner of the media
+      # box.
+      #
       # type::
       #    Can either be
       #    * :page for getting the canvas for the page itself (only valid for initially empty pages)
@@ -368,22 +383,31 @@ module HexaPDF
           raise ArgumentError, "Invalid value for 'type', expected: :page, :underlay or :overlay"
         end
         cache_key = "#{type}_canvas".intern
-        return document.cache(@data, cache_key) if document.cached?(@data, cache_key)
+        return cache(cache_key) if cached?(cache_key)
 
         if type == :page && key?(:Contents)
           raise HexaPDF::Error, "Cannot get the canvas for a page with contents"
         end
 
+        create_canvas = lambda do
+          Content::Canvas.new(self).tap do |canvas|
+            media_box = box(:media)
+            if media_box.left != 0 || media_box.bottom != 0
+              canvas.translate(media_box.left, media_box.bottom)
+            end
+          end
+        end
+
         contents = self[:Contents]
         if contents.nil?
-          page_canvas = document.cache(@data, :page_canvas, Content::Canvas.new(self))
+          page_canvas = cache(:page_canvas, create_canvas.call)
           self[:Contents] = document.add({Filter: :FlateDecode},
                                          stream: page_canvas.stream_data)
         end
 
         if type == :overlay || type == :underlay
-          underlay_canvas = document.cache(@data, :underlay_canvas, Content::Canvas.new(self))
-          overlay_canvas = document.cache(@data, :overlay_canvas, Content::Canvas.new(self))
+          underlay_canvas = cache(:underlay_canvas, create_canvas.call)
+          overlay_canvas = cache(:overlay_canvas, create_canvas.call)
 
           stream = HexaPDF::StreamData.new do
             Fiber.yield(" q ")
@@ -396,18 +420,19 @@ module HexaPDF
           underlay = document.add({Filter: :FlateDecode}, stream: stream)
 
           stream = HexaPDF::StreamData.new do
-            Fiber.yield(" Q ")
+            Fiber.yield(" Q q ")
             fiber = overlay_canvas.stream_data.fiber
             while fiber.alive? && (data = fiber.resume)
               Fiber.yield(data)
             end
+            " Q "
           end
           overlay = document.add({Filter: :FlateDecode}, stream: stream)
 
           self[:Contents] = [underlay, *self[:Contents], overlay]
         end
 
-        document.cache(@data, cache_key)
+        cache(cache_key)
       end
 
       # Creates a Form XObject from the page's dictionary and contents for the given PDF document.
@@ -448,8 +473,7 @@ module HexaPDF
         REQUIRED_INHERITABLE_FIELDS.each do |name|
           next if self[name]
           yield("Inheritable page field #{name} not set", name == :Resources)
-          self[:Resources] = {}
-          self[:Resources].validate(&block)
+          resources.validate(&block) if name == :Ressources
         end
       end
 

data/lib/hexapdf/type/page_tree_node.rb

@@ -172,11 +172,10 @@ module HexaPDF
         return unless page && !page.null? && page[:Parent]
 
         parent = page[:Parent]
-        index = parent[:Kids].index {|kid| kid.data == page.data }
+        index = parent[:Kids].index(page)
 
         if index
-          ancestors = [parent]
-          ancestors << parent while (parent = parent[:Parent])
+          ancestors = page.ancestor_nodes
           return nil unless ancestors.include?(self)
 
           page[:Parent][:Kids].delete_at(index)
@@ -188,6 +187,31 @@ module HexaPDF
         end
       end
 
+      # :call-seq:
+      #   pages.move_page(page, to_index)
+      #   pages.move_page(index, to_index)
+      #
+      # Moves the given page or the page at the position specified by the zero-based index to the
+      # +to_index+ position.
+      #
+      # If the page that should be moved, doesn't exist or is invalid, an error is raised.
+      #
+      # Negative indices count backwards from the end, i.e. -1 is the last page. When using a
+      # negative index, the page will be moved after that element. So using an index of -1 will
+      # move the page after the last page.
+      def move_page(page, to_index)
+        page = self.page(page) if page.kind_of?(Integer)
+        if page.nil? || page.null? || !page[:Parent] ||
+            !(ancestors = page.ancestor_nodes).include?(self)
+          raise HexaPDF::Error, "The page to be moved doesn't exist in this page tree"
+        end
+
+        parent = page[:Parent]
+        insert_page(to_index, page)
+        ancestors.each {|node| node[:Count] -= 1 }
+        parent[:Kids].delete(page)
+      end
+
       # :call-seq:
       #   pages.each_page {|page| block }   -> pages
       #   pages.each_page                   -> Enumerator
@@ -222,7 +246,7 @@ module HexaPDF
       # Ensures that the /Count and /Parent fields of the whole page tree are set up correctly and
       # that there is at least one page node. This is therefore only done for the root node of the
       # page tree!
-      def perform_validation
+      def perform_validation(&block)
         super
         return if key?(:Parent)
 
@@ -255,7 +279,7 @@ module HexaPDF
 
         if self[:Count] == 0
           yield("A PDF document needs at least one page", true)
-          add_page.validate {|msg, correctable| yield(msg, correctable) }
+          add_page.validate(&block)
         end
       end