hexapdf 0.27.0 → 0.29.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,7 +401,7 @@ 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) }
           not_flattened.map!(&:form_field)
           fields -= not_flattened
@@ -449,6 +457,8 @@ 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?
@@ -469,6 +479,22 @@ module HexaPDF
                   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

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/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

@@ -128,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/page.rb

@@ -267,6 +267,7 @@ module HexaPDF
           raise ArgumentError, "Page rotation has to be multiple of 90 degrees"
         end
 
+        # /Rotate and therefore cw_angle is angle in clockwise orientation
         cw_angle = (self[:Rotate] - angle) % 360
 
         if flatten
@@ -274,27 +275,41 @@ module HexaPDF
           return if cw_angle == 0
 
           matrix = case cw_angle
-                   when 90
-                     HexaPDF::Content::TransformationMatrix.new(0, -1, 1, 0)
-                   when 180
-                     HexaPDF::Content::TransformationMatrix.new(-1, 0, 0, -1)
-                   when 270
-                     HexaPDF::Content::TransformationMatrix.new(0, 1, -1, 0)
+                   when 90  then Content::TransformationMatrix.new(0, -1, 1, 0, -box.bottom, box.right)
+                   when 180 then Content::TransformationMatrix.new(-1, 0, 0, -1, box.right, box.top)
+                   when 270 then Content::TransformationMatrix.new(0, 1, -1, 0, box.top, -box.left)
                    end
 
-          [:MediaBox, :CropBox, :BleedBox, :TrimBox, :ArtBox].each do |box_name|
-            next unless key?(box_name)
-            box = self[box_name]
+          rotate_box = lambda do |box|
             llx, lly, urx, ury = \
               case cw_angle
-              when 90
-                [box.right, box.bottom, box.left, box.top]
-              when 180
-                [box.right, box.top, box.left, box.bottom]
-              when 270
-                [box.left, box.top, box.right, box.bottom]
+              when 90  then [box.right, box.bottom, box.left, box.top]
+              when 180 then [box.right, box.top, box.left, box.bottom]
+              when 270 then [box.left, box.top, box.right, box.bottom]
               end
-            self[box_name].value = matrix.evaluate(llx, lly).concat(matrix.evaluate(urx, ury))
+            box.value.replace(matrix.evaluate(llx, lly).concat(matrix.evaluate(urx, ury)))
+          end
+
+          [:MediaBox, :CropBox, :BleedBox, :TrimBox, :ArtBox].each do |box_name|
+            next unless key?(box_name)
+            rotate_box.call(self[box_name])
+          end
+
+          each_annotation do |annot|
+            rotate_box.call(annot[:Rect])
+            if (quad_points = annot[:QuadPoints])
+              quad_points = quad_points.value if quad_points.respond_to?(:value)
+              result = []
+              quad_points.each_slice(2) {|x, y| result.concat(matrix.evaluate(x, y)) }
+              quad_points.replace(result)
+            end
+            if (appearance = annot.appearance)
+              appearance[:Matrix] = matrix.dup.premultiply(*appearance[:Matrix].value).to_a
+            end
+            if annot[:Subtype] == :Widget
+              app_ch = annot[:MK] ||= document.wrap({}, type: :XXAppearanceCharacteristics)
+              app_ch[:R] = (app_ch[:R] + 360 - cw_angle) % 360
+            end
           end
 
           before_contents = document.add({}, stream: " q #{matrix.to_a.join(' ')} cm ")
@@ -519,15 +534,15 @@ module HexaPDF
       # If an annotation is a form field widget, only the widget will be deleted but not the form
       # field itself.
       def flatten_annotations(annotations = self[:Annots])
-        return [] unless key?(:Annots)
+        not_flattened = (annotations || []).to_ary
+        return not_flattened unless key?(:Annots)
 
-        not_flattened = annotations.to_ary
         annotations = not_flattened & self[:Annots] if annotations != self[:Annots]
         return not_flattened if annotations.empty?
 
         canvas = self.canvas(type: :overlay)
-        canvas.save_graphics_state
         if (pos = canvas.graphics_state.ctm.evaluate(0, 0)) != [0, 0]
+          canvas.save_graphics_state
           canvas.translate(-pos[0], -pos[1])
         end
 
@@ -546,36 +561,31 @@ module HexaPDF
 
           rect = annotation[:Rect]
           box = appearance.box
-          matrix = appearance[:Matrix]
-
-          # Adjust position based on matrix
-          pos = [rect.left - matrix[4], rect.bottom - matrix[5]]
-
-          # In case of a rotation we need to counter the default translation in #xobject by adding
-          # box.left and box.bottom, and then translate the origin for the rotation
-          angle = (-Math.atan2(matrix[2], matrix[0]) * 180 / Math::PI).to_i
-          case angle
-          when 0
-            # Nothing to do, no rotation
-          when 90
-            pos[0] += box.top + box.left
-            pos[1] += -box.left + box.bottom
-          when -90
-            pos[0] += -box.bottom + box.left
-            pos[1] += box.right + box.bottom
-          when 180, -180
-            pos[0] += box.right + box.left
-            pos[1] += box.top + box.bottom
-          else
-            not_flattened << annotation
-            next
-          end
 
-          width, height = (angle.abs == 90 ? [rect.height, rect.width] : [rect.width, rect.height])
-          canvas.xobject(appearance, at: pos, width: width, height: height)
+          # PDF1.7 12.5.5 algorithm
+          # Step a) Calculate smallest rectangle containing transformed bounding box
+          matrix = HexaPDF::Content::TransformationMatrix.new(*appearance[:Matrix].value)
+          llx, lly = matrix.evaluate(box.left, box.bottom)
+          ulx, uly = matrix.evaluate(box.left, box.top)
+          lrx, lry = matrix.evaluate(box.right, box.bottom)
+          left, right = [llx, ulx, lrx, lrx + (ulx - llx)].minmax
+          bottom, top = [lly, uly, lry, lry + (uly - lly)].minmax
+
+          # Step b) Fit calculated rectangle to annotation rectangle by translating/scaling
+          a = HexaPDF::Content::TransformationMatrix.new
+          a.translate(rect.left - left, rect.bottom - bottom)
+          a.scale(rect.width.fdiv(right - left), rect.height.fdiv(top - bottom))
+
+          # Step c) Premultiply form matrix - done implicitly when drawing the XObject
+
+          canvas.transform(*a) do
+            # Use [box.left, box.bottom] to counter default translation in #xobject since that
+            # is already taken care of in matrix a
+            canvas.xobject(appearance, at: [box.left, box.bottom])
+          end
           to_delete << annotation
         end
-        canvas.restore_graphics_state
+        canvas.restore_graphics_state unless pos == [0, 0]
 
         to_delete.each do |annotation|
           if annotation[:Subtype] == :Widget

data/lib/hexapdf/type.rb

@@ -72,7 +72,6 @@ module HexaPDF
     autoload(:FontType3, 'hexapdf/type/font_type3')
     autoload(:IconFit, 'hexapdf/type/icon_fit')
     autoload(:AcroForm, 'hexapdf/type/acro_form')
-    autoload(:Signature, 'hexapdf/type/signature')
     autoload(:Outline, 'hexapdf/type/outline')
     autoload(:OutlineItem, 'hexapdf/type/outline_item')
     autoload(:PageLabel, 'hexapdf/type/page_label')

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.27.0'
+  VERSION = '0.29.0'
 
 end

data/lib/hexapdf/writer.rb

@@ -114,7 +114,7 @@ module HexaPDF
         @document.catalog[:Version] = @document.version.to_sym
       end
       @document.revisions.each do |rev|
-        rev.each_modified_object {|obj| revision.send(:add_without_check, obj) }
+        rev.each_modified_object(all: true) {|obj| revision.send(:add_without_check, obj) }
       end
 
       write_revision(revision, parser.startxref_offset)
@@ -135,8 +135,7 @@ module HexaPDF
 
       revision = @document.revisions.add
       @document.revisions.all[0..-2].each do |rev|
-        rev.each_modified_object {|obj| revision.send(:add_without_check, obj) }
-        rev.reset_objects
+        rev.each_modified_object(delete: true) {|obj| revision.send(:add_without_check, obj) }
       end
       @document.revisions.merge(-2..-1)
     end

data/test/hexapdf/content/test_canvas.rb

@@ -934,6 +934,11 @@ describe HexaPDF::Content::Canvas do
                                         [:restore_graphics_state]])
     end
 
+    it "correctly serializes the form when no transformation is needed" do
+      @canvas.image(@form, at: [100, 50])
+      assert_operators(@page.contents, [[:paint_xobject, [:XO1]]])
+    end
+
     it "doesn't do anything if the form's width or height is zero" do
       @form[:BBox] = [100, 50, 100, 200]
       @canvas.xobject(@form, at: [0, 0])

data/test/hexapdf/{type/signature → digital_signature}/common.rb

@@ -6,7 +6,7 @@ module HexaPDF
     class Certificates
 
       def ca_key
-        @ca_key ||= OpenSSL::PKey::RSA.new(512)
+        @ca_key ||= OpenSSL::PKey::RSA.new(2048)
       end
 
       def ca_certificate
@@ -36,13 +36,17 @@ module HexaPDF
       end
 
       def signer_key
-        @signer_key ||= OpenSSL::PKey::RSA.new(512)
+        @signer_key ||= OpenSSL::PKey::RSA.new(2048)
+      end
+
+      def dsa_signer_key
+        @dsa_signer_key ||= OpenSSL::PKey::DSA.new(2048)
       end
 
       def signer_certificate
         @signer_certificate ||=
           begin
-            name = OpenSSL::X509::Name.parse('/CN=signer/DC=gettalong')
+            name = OpenSSL::X509::Name.parse('/CN=RSA signer/DC=gettalong')
 
             signer_cert = OpenSSL::X509::Certificate.new
             signer_cert.serial = 2
@@ -65,6 +69,30 @@ module HexaPDF
           end
       end
 
+      def dsa_signer_certificate
+        @dsa_signer_certificate ||=
+          begin
+            signer_cert = OpenSSL::X509::Certificate.new
+            signer_cert.serial = 3
+            signer_cert.version = 2
+            signer_cert.not_before = Time.now - 86400
+            signer_cert.not_after = Time.now + 86400
+            signer_cert.public_key = dsa_signer_key.public_key
+            signer_cert.subject = OpenSSL::X509::Name.parse('/CN=DSA signer/DC=gettalong')
+            signer_cert.issuer = ca_certificate.subject
+
+            extension_factory = OpenSSL::X509::ExtensionFactory.new
+            extension_factory.subject_certificate = signer_cert
+            extension_factory.issuer_certificate = ca_certificate
+            signer_cert.add_extension(extension_factory.create_extension('subjectKeyIdentifier', 'hash'))
+            signer_cert.add_extension(extension_factory.create_extension('basicConstraints', 'CA:FALSE'))
+            signer_cert.add_extension(extension_factory.create_extension('keyUsage', 'digitalSignature'))
+            signer_cert.sign(ca_key, OpenSSL::Digest.new('SHA1'))
+
+            signer_cert
+          end
+      end
+
       def timestamp_certificate
         @timestamp_certificate ||=
           begin
@@ -85,7 +113,8 @@ module HexaPDF
             signer_cert.add_extension(extension_factory.create_extension('subjectKeyIdentifier', 'hash'))
             signer_cert.add_extension(extension_factory.create_extension('basicConstraints', 'CA:FALSE'))
             signer_cert.add_extension(extension_factory.create_extension('keyUsage', 'digitalSignature'))
-            signer_cert.add_extension(extension_factory.create_extension('extendedKeyUsage', 'timeStamping', true))
+            signer_cert.add_extension(extension_factory.create_extension('extendedKeyUsage',
+                                                                         'timeStamping', true))
             signer_cert.sign(ca_key, OpenSSL::Digest.new('SHA1'))
 
             signer_cert
@@ -117,6 +146,7 @@ module HexaPDF
         end
         Thread.new { @tsa_server.start }
       end
+
     end
 
   end