hexapdf 0.26.2 → 0.28.0

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

@@ -84,6 +84,8 @@ module HexaPDF
       # See: PDF1.7 s12.7.4.2
       class ButtonField < Field
 
+        define_type :XXAcroFormField
+
         define_field :Opt, type: PDFArray, version: '1.4'
 
         # All inheritable dictionary fields for button fields.
@@ -206,7 +208,7 @@ module HexaPDF
         # Note that this will only return useful values if there is at least one correctly set-up
         # widget.
         def allowed_values
-          (each_widget.each_with_object([]) do |widget, result|
+          (each_widget.with_object([]) do |widget, result|
              keys = widget.appearance_dict&.normal_appearance&.value&.keys
              result.concat(keys) if keys
            end - [:Off]).uniq
@@ -254,14 +256,14 @@ module HexaPDF
             normal_appearance = widget.appearance_dict&.normal_appearance
             next if !force && normal_appearance &&
               ((!push_button? && normal_appearance.value.length == 2 &&
-                normal_appearance.value.each_value.all?(HexaPDF::Stream)) ||
+                normal_appearance.each.all? {|_, v| v.kind_of?(HexaPDF::Stream) }) ||
                (push_button? && normal_appearance.kind_of?(HexaPDF::Stream)))
             if check_box?
               appearance_generator_class.new(widget).create_check_box_appearances
             elsif radio_button?
               appearance_generator_class.new(widget).create_radio_button_appearances
             else
-              raise HexaPDF::Error, "Push buttons not yet supported"
+              appearance_generator_class.new(widget).create_push_button_appearances
             end
           end
         end

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

@@ -69,6 +69,8 @@ module HexaPDF
       # See: PDF1.7 s12.7.4.4
       class ChoiceField < VariableTextField
 
+        define_type :XXAcroFormField
+
         define_field :Opt, type: PDFArray
         define_field :TI, type: Integer, default: 0
         define_field :I, type: PDFArray, version: '1.4'

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

@@ -242,8 +242,8 @@ module HexaPDF
         end
 
         # :call-seq:
-        #   field.each_widget {|widget| block}    -> field
-        #   field.each_widget                     -> Enumerator
+        #   field.each_widget(direct_only: true) {|widget| block}    -> field
+        #   field.each_widget(direct_only: true)                     -> Enumerator
         #
         # Yields each widget, i.e. visual representation, of this field.
         #
@@ -253,11 +253,17 @@ module HexaPDF
         # 2. One or more widgets are defined as children of this field.
         # 3. Widgets of *another field instance with the same full field name*.
         #
-        # Because of possibility 3 all fields of the form have to be searched to check whether there
-        # is another field with the same full field name.
+        # With the default of +direct_only+ being +true+, only the usual cases 1 and 2 are handled/
+        # If case 3 also needs to be handled, set +direct_only+ to +false+ or run the validation on
+        # the main AcroForm object (HexaPDF::Document#acro_form) before using this method (this will
+        # reduce case 3 to case 2).
+        #
+        # *Note*: Setting +direct_only+ to +false+ will have a severe performance impact since all
+        # fields of the form have to be searched to check whether there is another field with the
+        # same full field name.
         #
         # See: HexaPDF::Type::Annotations::Widget
-        def each_widget(direct_only: false, &block) # :yields: widget
+        def each_widget(direct_only: true, &block) # :yields: widget
           return to_enum(__method__, direct_only: direct_only) unless block_given?
 
           if embedded_widget?

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

@@ -125,14 +125,22 @@ module HexaPDF
         def each_field(terminal_only: true)
           return to_enum(__method__, terminal_only: terminal_only) unless block_given?
 
-          process_field = lambda do |field|
-            field = document.wrap(field, type: :XXAcroFormField,
-                                  subtype: Field.inherited_value(field, :FT))
-            yield(field) if field.terminal_field? || !terminal_only
-            field[:Kids].each(&process_field) unless field.terminal_field?
+          process_field_array = lambda do |array|
+            array.each_with_index do |field, index|
+              unless field.respond_to?(:type) && field.type == :XXAcroFormField
+                array[index] = field = document.wrap(field, type: :XXAcroFormField,
+                                                     subtype: Field.inherited_value(field, :FT))
+              end
+              if field.terminal_field?
+                yield(field)
+              else
+                yield(field) unless terminal_only
+                process_field_array.call(field[:Kids])
+              end
+            end
           end
 
-          root_fields.each(&process_field)
+          process_field_array.call(root_fields)
           self
         end
 
@@ -393,9 +401,10 @@ module HexaPDF
             fields.each {|field| field.create_appearances if field.respond_to?(:create_appearances) }
           end
 
-          not_flattened = fields.map {|field| field.each_widget.to_a }.flatten
+          not_flattened = fields.map {|field| field.each_widget(direct_only: true).to_a }.flatten
           document.pages.each {|page| not_flattened = page.flatten_annotations(not_flattened) }
-          fields -= not_flattened.map(&:form_field)
+          not_flattened.map!(&:form_field)
+          fields -= not_flattened
 
           fields.each do |field|
             (field[:Parent]&.[](:Kids) || self[:Fields]).delete(field)
@@ -448,6 +457,50 @@ module HexaPDF
         def perform_validation # :nodoc:
           super
 
+          seen = {} # used for combining field
+
+          validate_array = lambda do |parent, container|
+            container.reject! do |field|
+              if !field.kind_of?(HexaPDF::Object) || !field.kind_of?(HexaPDF::Dictionary) || field.null?
+                yield("Invalid object in AcroForm field hierarchy", true)
+                next true
+              end
+              next false unless field.key?(:T) # Skip widgets
+
+              field = document.wrap(field, type: :XXAcroFormField,
+                                    subtype: Field.inherited_value(field, :FT))
+              reject = false
+              if field[:Parent] != parent
+                yield("Parent entry of field (#{field.oid},#{field.gen}) invalid", true)
+                if field[:Parent].nil?
+                  root_fields << field
+                  reject = true
+                else
+                  field[:Parent] = parent
+                end
+              end
+
+              # Combine fields with same name
+              name = field.full_field_name
+              if (other_field = seen[name])
+                kids = other_field[:Kids] ||= []
+                kids << other_field.send(:extract_widget) if other_field.embedded_widget?
+                widgets = field.embedded_widget? ? [field.send(:extract_widget)] : field.each_widget.to_a
+                widgets.each do |widget|
+                  widget[:Parent] = other_field
+                  kids << widget
+                end
+                reject = true
+              elsif !reject
+                seen[name] = field
+              end
+
+              validate_array.call(field, field[:Kids]) if field.key?(:Kids)
+              reject
+            end
+          end
+          validate_array.call(nil, root_fields)
+
           if (da = self[:DA])
             unless self[:DR]
               yield("When the field /DA is present, the field /DR must also be present")

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

@@ -192,6 +192,8 @@ module HexaPDF
 
         end
 
+        define_type :XXAcroFormField
+
         define_field :Lock, type: :SigFieldLock, indirect: true, version: '1.5'
         define_field :SV, type: :SV, indirect: true, version: '1.5'
 

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

@@ -73,6 +73,8 @@ module HexaPDF
       # See: PDF1.7 s12.7.4.3
       class TextField < VariableTextField
 
+        define_type :XXAcroFormField
+
         define_field :MaxLen, type: Integer
 
         # All inheritable dictionary fields for text fields.
@@ -220,7 +222,15 @@ module HexaPDF
           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
+            is_cached = widget.cached?(:last_value)
+            unless force
+              if is_cached && widget.cache(:last_value) == current_value
+                next
+              elsif !is_cached && widget.appearance?
+                widget.cache(:last_value, current_value, update: true)
+                next
+              end
+            end
             widget.cache(:last_value, current_value, update: true)
             appearance_generator_class.new(widget).create_text_appearances
           end
@@ -228,7 +238,7 @@ module HexaPDF
 
         # Updates the widgets so that they reflect the current field value.
         def update_widgets
-          create_appearances
+          create_appearances(force: true)
         end
 
         private

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

@@ -224,6 +224,9 @@ module HexaPDF
           # The kind of marker that is shown inside the widget. Can either be one of the symbols
           # +:check+, +:circle+, +:cross+, +:diamond+, +:square+ or +:star+, or a one character
           # string. The latter is interpreted using the ZapfDingbats font.
+          #
+          # If an empty string is set, it is treated as if +nil+ was set, i.e. it shows the default
+          # marker for the field type.
           attr_reader :style
 
           # The size of the marker in PDF points that is shown inside the widget. The special value

data/lib/hexapdf/type/catalog.rb

@@ -65,7 +65,7 @@ module HexaPDF
                          :TwoPageLeft, :TwoPageRight]
       define_field :PageMode,          type: Symbol,     default: :UseNone,
         allowed_values: [:UseNone, :UseOutlines, :UseThumbs, :FullScreen, :UseOC, :UseAttachments]
-      define_field :Outlines,          type: Dictionary, indirect: true
+      define_field :Outlines,          type: :Outlines,  indirect: true
       define_field :Threads,           type: PDFArray,   version: '1.1'
       define_field :OpenAction,        type: [Dictionary, PDFArray], version: '1.1'
       define_field :AA,                type: Dictionary, version: '1.4'

data/lib/hexapdf/type/font_true_type.rb

@@ -35,6 +35,7 @@
 #++
 
 require 'hexapdf/type/font_simple'
+require 'hexapdf/font/true_type_wrapper'
 
 module HexaPDF
   module Type
@@ -45,6 +46,19 @@ module HexaPDF
       define_field :Subtype, type: Symbol, required: true, default: :TrueType
       define_field :BaseFont, type: Symbol, required: true
 
+      # Overrides the default to provide a font wrapper in case none is set and a complete TrueType
+      # is embedded.
+      #
+      # See: Font#font_wrapper
+      def font_wrapper
+        if (tmp = super)
+          tmp
+        elsif (font_file = self.font_file) && self[:BaseFont].to_s !~ /\A[A-Z]{6}\+/
+          font = HexaPDF::Font::TrueType::Font.new(StringIO.new(font_file.stream))
+          @font_wrapper = HexaPDF::Font::TrueTypeWrapper.new(document, font, subset: true)
+        end
+      end
+
       private
 
       def perform_validation

data/lib/hexapdf/type/object_stream.rb

@@ -179,7 +179,7 @@ module HexaPDF
           # Due to a bug in Adobe Acrobat, the Catalog may not be in an object stream if the
           # document is encrypted
           if obj.nil? || obj.null? || obj.gen != 0 || obj.kind_of?(Stream) || obj == encrypt_dict ||
-              (encrypt_dict && obj.type == :Catalog) ||
+              obj.type == :Catalog ||
               obj.type == :Sig || obj.type == :DocTimeStamp ||
               (obj.respond_to?(:key?) && obj.key?(:ByteRange) && obj.key?(:Contents))
             delete_object(objects[index])
@@ -220,7 +220,7 @@ module HexaPDF
 
       # Returns the container with the to-be-stored objects.
       def objects
-        @objects ||= 
+        @objects ||=
           begin
             @objects = {}
             parse_stream

data/lib/hexapdf/type/outline.rb

@@ -50,6 +50,8 @@ module HexaPDF
     # The outline dictionary is linked via the /Outlines entry from the Type::Catalog and can
     # directly be accessed via HexaPDF::Document#outline.
     #
+    # == Examples
+    #
     # Here is an example for creating an outline:
     #
     #   doc = HexaPDF::Document.new
@@ -62,6 +64,22 @@ module HexaPDF
     #     end
     #   end
     #
+    # Here is one for copying the complete outline from one PDF to another:
+    #
+    #   doc = HexaPDF::Document.open(ARGV[0])
+    #   target = HexaPDF::Document.new
+    #   stack = [target.outline]
+    #   doc.outline.each_item do |item, level|
+    #     if stack.size < level
+    #       stack << stack.last[:Last]
+    #     elsif stack.size > level
+    #       (stack.size - level).times { stack.pop }
+    #     end
+    #     stack.last.add_item(target.import(item))
+    #   end
+    #   # Copying all the pages so that the references work.
+    #   doc.pages.each {|page| target.pages << target.import(page) }
+    #
     # See: PDF1.7 s12.3.3
     class Outline < Dictionary
 
@@ -110,7 +128,7 @@ module HexaPDF
           node, dir = first ? [first, :Next] : [last, :Prev]
           node = node[dir] while node.key?(dir)
           self[dir == :Next ? :Last : :First] = node
-        elsif !first && !last && self[:Count]
+        elsif !first && !last && self[:Count] && self[:Count] != 0
           yield('Outline dictionary key /Count set but no items exist', true)
           delete(:Count)
         end

data/lib/hexapdf/type/outline_item.rb

@@ -126,6 +126,11 @@ module HexaPDF
                 lister: "flags", getter: "flagged?", setter: "flag", unsetter: "unflag",
                 value_getter: "self[:F]", value_setter: "self[:F]")
 
+      # Returns +true+ since outline items must always be indirect objects.
+      def must_be_indirect?
+        true
+      end
+
       # :call-seq:
       #   item.title          -> title
       #   item.title(value)   -> title
@@ -198,9 +203,46 @@ module HexaPDF
         end
       end
 
+      # Returns the outline level this item is one.
+      #
+      # The level of the items in the main outline dictionary, the root level, is 1.
+      #
+      # Here is an illustrated example of items contained in a document outline with their
+      # associated level:
+      #
+      #  Outline dictionary          0
+      #    Outline item 1            1
+      #    |- Sub item 1             2
+      #    |- Sub item 2             2
+      #       |- Sub sub item 1      3
+      #    |- Sub item 3             2
+      #    Outline item 2            1
+      def level
+        count = 0
+        temp = self
+        count += 1 while (temp = temp[:Parent])
+        count
+      end
+
+      # Returns the destination page if there is any.
+      #
+      # * If a destination is set, the associated page is returned.
+      # * If an action is set and it is a GoTo action, the associated page is returned.
+      # * Otherwise +nil+ is returned.
+      def destination_page
+        dest = self[:Dest]
+        dest = action[:D] if !dest && (action = self[:A]) && action[:S] == :GoTo
+        document.destinations.resolve(dest)&.page
+      end
+
       # Adds, as child to this item, a new outline item with the given title that performs the
       # provided action on clicking. Returns the newly added item.
       #
+      # Alternatively, it is possible to provide an already initialized outline item instead of the
+      # title. If so, the only other argument that is used is +position+. Existing fields /Prev,
+      # /Next, /First, /Last, /Parent and /Count are deleted from the given item and set
+      # appropriately.
+      #
       # If neither :destination nor :action is specified, the outline item has no associated action.
       # This is only meaningful if the new item will have children as it then acts just as a
       # container.
@@ -251,16 +293,30 @@ module HexaPDF
       #   end
       def add_item(title, destination: nil, action: nil, position: :last, open: true,
                    text_color: nil, flags: nil) # :yield: item
-        item = document.add({Parent: self}, type: :XXOutlineItem)
-        item.title(title)
-        if action
-          item.action(action)
+        if title.kind_of?(HexaPDF::Object) && title.type == :XXOutlineItem
+          item = title
+          item.delete(:Prev)
+          item.delete(:Next)
+          item.delete(:First)
+          item.delete(:Last)
+          if item[:Count] && item[:Count] >= 0
+            item[:Count] = 0
+          else
+            item.delete(:Count)
+          end
+          item[:Parent] = self
         else
-          item.destination(destination)
+          item = document.add({Parent: self}, type: :XXOutlineItem)
+          item.title(title)
+          if action
+            item.action(action)
+          else
+            item.destination(destination)
+          end
+          item.text_color(text_color) if text_color
+          item.flag(*flags) if flags
+          item[:Count] = 0 if open # Count=0 means open if items are later added
         end
-        item.text_color(text_color) if text_color
-        item.flag(*flags) if flags
-        item[:Count] = 0 if open # Count=0 means open if items are later added
 
         unless position == :last || position == :first || position.kind_of?(Integer)
           raise ArgumentError, "position must be :first, :last, or an integer"
@@ -311,18 +367,20 @@ module HexaPDF
       end
 
       # :call-seq:
-      #   item.each_item {|descendant_item| block }   -> item
-      #   item.each_item                              -> Enumerator
+      #   item.each_item {|descendant_item, level| block }   -> item
+      #   item.each_item                                     -> Enumerator
       #
       # Iterates over all descendant items of this one.
       #
-      # The items are yielded in-order, yielding first the item itself and then its descendants.
+      # The descendant items are yielded in-order, yielding first the item itself and then its
+      # descendants.
       def each_item(&block)
         return to_enum(__method__) unless block_given?
+        return self unless (item = self[:First])
 
-        item = self[:First]
+        level = self.level + 1
         while item
-          yield(item)
+          yield(item, level)
           item.each_item(&block)
           item = item[:Next]
         end
@@ -341,7 +399,7 @@ module HexaPDF
           node, dir = first ? [first, :Next] : [last, :Prev]
           node = node[dir] while node.key?(dir)
           self[dir == :Next ? :Last : :First] = node
-        elsif !first && !last && self[:Count] != 0
+        elsif !first && !last && self[:Count] && self[:Count] != 0
           yield('Outline item dictionary key /Count set but no descendants exist', true)
           delete(:Count)
         end