hexapdf 0.14.4 → 0.15.4

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

@@ -315,6 +315,7 @@ module HexaPDF
 
           if embedded_widget?
             WIDGET_FIELDS.each {|key| delete(key) }
+            document.revisions.each {|revision| break if revision.update(self)}
           else
             self[:Kids].delete_at(widget_index)
             document.delete(widget)

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

@@ -331,6 +331,43 @@ module HexaPDF
           end
         end
 
+        # Flattens the whole interactive form or only the given fields, and returns the fields that
+        # couldn't be flattened.
+        #
+        # Flattening means making the appearance streams of the field widgets part of the respective
+        # page's content stream and removing the fields themselves.
+        #
+        # If the whole interactive form is flattened, the form object itself is also removed if all
+        # fields were flattened.
+        #
+        # The +create_appearances+ argument controls whether missing appearances should
+        # automatically be created.
+        #
+        # See: HexaPDF::Type::Page#flatten_annotations
+        def flatten(fields: nil, create_appearances: true)
+          remove_form = fields.nil?
+          fields ||= each_field.to_a
+          if create_appearances
+            fields.each {|field| field.create_appearances if field.respond_to?(:create_appearances) }
+          end
+
+          not_flattened = fields.map {|field| field.each_widget.to_a }.flatten
+          document.pages.each {|page| not_flattened = page.flatten_annotations(not_flattened) }
+          fields -= not_flattened.map(&:form_field)
+
+          fields.each do |field|
+            (field[:Parent]&.[](:Kids) || self[:Fields]).delete(field)
+            document.delete(field)
+          end
+
+          if remove_form && not_flattened.empty?
+            document.catalog.delete(:AcroForm)
+            document.delete(self)
+          end
+
+          not_flattened
+        end
+
         private
 
         # Helper method for bit field getter access.

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

@@ -0,0 +1,223 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2021 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.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/type/acro_form/field'
+require 'hexapdf/type/acro_form/appearance_generator'
+
+module HexaPDF
+  module Type
+    module AcroForm
+
+      # AcroForm signature fields represent a digital signature.
+      #
+      # It serves two purposes: To visually display the signature and to hold the information of the
+      # digital signature itself.
+      #
+      # If the signature should not be visible, the associated widget annotation should have zero
+      # width and height; and/or the 'hidden' or 'no_view' flags of the annotation should be set.
+      #
+      # See: PDF1.7 s12.7.4.5
+      class SignatureField < Field
+
+        # A signature field lock dictionary specifies a set of form fields that should be locked
+        # once the associated signature field is signed.
+        #
+        # See: PDF1.7 s12.7.4.5
+        class LockDictionary < Dictionary
+
+          define_type :SigFieldLock
+
+          define_field :Type,   type: Symbol, default: type
+          define_field :Action, type: Symbol, required: true,
+            allowed_values: [:All, :Include, :Exclude]
+          define_field :Fields, type: PDFArray
+
+          private
+
+          def perform_validation #:nodoc:
+            if self[:Action] != :All && !key?(:Fields)
+              yield("The /Fields key of the signature lock dictionary is missing")
+            end
+          end
+
+        end
+
+        # A seed value dictionary contains information that constrains the properties of a signature
+        # that is applied to the associated signature field.
+        #
+        # == Flags
+        #
+        # If a flag is set it means that the associated entry is a required constraint. Otherwise it
+        # is optional.
+        #
+        # The available flags are: filter, sub_filter, v, reasons, legal_attestation, add_rev_info
+        # and digest_method.
+        #
+        # See: PDF1.7 s12.7.4.5
+        class SeedValueDictionary < Dictionary
+
+          extend Utils::BitField
+
+          define_type :SV
+
+          define_field :Type,             type: Symbol, default: type
+          define_field :Ff,               type: Integer, default: 0
+          define_field :Filter,           type: Symbol
+          define_field :SubFilter,        type: PDFArray
+          define_field :DigestMethod,     type: PDFArray, version: '1.7'
+          define_field :V,                type: Float
+          define_field :Cert,             type: :SVCert
+          define_field :Reasons,          type: PDFArray
+          define_field :MDP,              type: Dictionary, version: '1.6'
+          define_field :TimeStamp,        type: Dictionary, version: '1.6'
+          define_field :LegalAttestation, type: PDFArray, version: '1.6'
+          define_field :AddRevInfo,       type: Boolean, version: '1.7'
+
+          ##
+          # :method: flags
+          #
+          # Returns an array of flag names representing the set bit flags.
+          #
+
+          ##
+          # :method: flagged?
+          # :call-seq:
+          #   flagged?(flag)
+          #
+          # Returns +true+ if the given flag is set. The argument can either be the flag name or the
+          # bit index.
+          #
+
+          ##
+          # :method: flag
+          # :call-seq:
+          #   flag(*flags, clear_existing: false)
+          #
+          # Sets the given flags, given as flag names or bit indices. If +clear_existing+ is +true+,
+          # all prior flags will be cleared.
+          #
+          bit_field(:flags, {filter: 0, sub_filter: 1, v: 2, reasons: 3, legal_attestation: 4,
+                             add_rev_info: 5, digest_method: 6},
+                    lister: "flags", getter: "flagged?", setter: "flag", unsetter: "unflag",
+                    value_getter: "self[:Ff]", value_setter: "self[:Ff]")
+
+        end
+
+        # A certificate seed value dictionary contains information about the characteristics of the
+        # certificate that shall be used when signing.
+        #
+        # == Flags
+        #
+        # The flags describe the entries that a signer is required to use.
+        #
+        # The available flags are: subject, issuer, oid, subject_dn, reserved,  key_usage and url.
+        #
+        # See: PDF1.7 s12.7.4.5
+        class CertificateSeedValueDictionary < Dictionary
+
+          extend Utils::BitField
+
+          define_type :SVCert
+
+          define_field :Type,      type: Symbol, default: type
+          define_field :Ff,        type: Integer, default: 0
+          define_field :Subject,   type: PDFArray
+          define_field :SubjectDN, type: PDFArray, version: '1.7'
+          define_field :KeyUsage,  type: PDFArray, version: '1.7'
+          define_field :Issuer,    type: PDFArray
+          define_field :OID,       type: PDFArray
+          define_field :URL,       type: String
+          define_field :URLType,   type: Symbol, default: :Browser
+
+          ##
+          # :method: flags
+          #
+          # Returns an array of flag names representing the set bit flags.
+          #
+
+          ##
+          # :method: flagged?
+          # :call-seq:
+          #   flagged?(flag)
+          #
+          # Returns +true+ if the given flag is set. The argument can either be the flag name or the
+          # bit index.
+          #
+
+          ##
+          # :method: flag
+          # :call-seq:
+          #   flag(*flags, clear_existing: false)
+          #
+          # Sets the given flags, given as flag names or bit indices. If +clear_existing+ is +true+,
+          # all prior flags will be cleared.
+          #
+          bit_field(:flags, {subject: 0, issuer: 1, oid: 2, subject_dn: 3, reserved: 4,
+                             key_usage: 5, url: 6},
+                    lister: "flags", getter: "flagged?", setter: "flag", unsetter: "unflag",
+                    value_getter: "self[:Ff]", value_setter: "self[:Ff]")
+
+        end
+
+        define_field :Lock, type: :SigFieldLock, indirect: true, version: '1.5'
+        define_field :SV, type: :SV, indirect: true, version: '1.5'
+
+        # Returns the associated signature dictionary or +nil+ if the signature is not filled in.
+        def field_value
+          self[:V]
+        end
+
+        # Sets the signature dictionary as value of this signature field.
+        def field_value=(sig_dict)
+          self[:V] = sig_dict
+        end
+
+        private
+
+        def perform_validation #:nodoc:
+          if field_type != :Sig
+            yield("Field /FT of AcroForm signature field has to be :Sig", true)
+            self[:FT] = :Sig
+          end
+
+          super
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hexapdf/type/annotation.rb

@@ -125,20 +125,29 @@ module HexaPDF
 
       # Returns the AppearanceDictionary instance associated with the annotation or +nil+ if none is
       # set.
-      def appearance
+      def appearance_dict
         self[:AP]
       end
 
-      # Returns +true+ if the widget's normal appearance exists.
+      # Returns the annotation's appearance stream of the given type (:normal, :rollover, or :down)
+      # or +nil+ if it doesn't exist.
       #
-      # Note that this checks only if the appearance exists but not if the structure of the
-      # appearance dictionary conforms to the expectations of the annotation.
-      def appearance?
-        return false unless (normal_appearance = appearance&.normal_appearance)
-        normal_appearance.kind_of?(HexaPDF::Stream) ||
-          (!normal_appearance.empty? &&
-           normal_appearance.each.all? {|_k, v| v.kind_of?(HexaPDF::Stream) })
+      # The appearance state is taken into account if necessary.
+      def appearance(type = :normal)
+        entry = appearance_dict&.send("#{type}_appearance")
+        if entry.kind_of?(HexaPDF::Dictionary) && !entry.kind_of?(HexaPDF::Stream)
+          entry = entry[self[:AS]]
+        end
+        return unless entry.kind_of?(HexaPDF::Stream)
+
+        if entry.type == :XObject && entry[:Subtype] == :Form
+          entry
+        elsif (entry[:Type].nil? || entry[:Type] == :XObject) &&
+            (entry[:Subtype].nil? || entry[:Subtype] == :Form) && entry[:BBox]
+          document.wrap(entry, type: :XObject, subtype: :Form)
+        end
       end
+      alias appearance? appearance
 
       private
 

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

@@ -112,7 +112,9 @@ module HexaPDF
         def background_color(*color)
           if color.empty?
             components = self[:MK]&.[](:BG)
-            components.nil? ? nil : Content::ColorSpace.prenormalized_device_color(components)
+            if components && !components.empty?
+              Content::ColorSpace.prenormalized_device_color(components)
+            end
           else
             color = Content::ColorSpace.device_color_from_specification(color)
             (self[:MK] ||= {})[:BG] = color.components

data/lib/hexapdf/type/font_descriptor.rb

@@ -57,8 +57,7 @@ module HexaPDF
       define_field :FontStretch,  type: Symbol, version: '1.5',
         allowed_values: [:UltraCondensed, :ExtraCondensed, :Condensed, :SemiCondensed,
                          :Normal, :SemiExpanded, :Expanded, :ExtraExpanded, :UltraExpanded]
-      define_field :FontWeight,   type: Numeric, version: '1.5',
-        allowed_values: [100, 200, 300, 400, 500, 600, 700, 800, 900]
+      define_field :FontWeight,   type: Numeric, version: '1.5'
       define_field :Flags,        type: Integer, required: true
       define_field :FontBBox,     type: Rectangle
       define_field :ItalicAngle,  type: Numeric, required: true
@@ -98,12 +97,20 @@ module HexaPDF
         self[:Flags] = value
       end
 
+      ALLOWED_FONT_WEIGHTS = [100, 200, 300, 400, 500, 600, 700, 800, 900] #:nodoc:
+
       def perform_validation #:nodoc:
         super
         if [self[:FontFile], self[:FontFile2], self[:FontFile3]].compact.size > 1
           yield("Only one of /FontFile, /FontFile2 or /FontFile3 may be set", false)
         end
 
+        font_weight = self[:FontWeight]
+        if font_weight && !ALLOWED_FONT_WEIGHTS.include?(font_weight)
+          yield("Field FontWeight does not contain an allowed value", true)
+          delete(:FontWeight)
+        end
+
         descent = self[:Descent]
         if descent && descent > 0
           yield("The /Descent value needs to be a negative number", true)

data/lib/hexapdf/type/page.rb

@@ -465,6 +465,87 @@ module HexaPDF
         document.wrap(dict, stream: stream)
       end
 
+      # Flattens all or the given annotations of the page. Returns an array with all the annotations
+      # that couldn't be flattened because they don't have an appearance stream.
+      #
+      # Flattening means making the appearances of the annotations part of the content stream of the
+      # page and deleting the annotations themselves. Invisible and hidden fields are deleted but
+      # not rendered into the content stream.
+      #
+      # 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
+        annotations = not_flattened & self[:Annots] if annotations != self[:Annots]
+        return not_flattened if annotations.empty?
+
+        canvas = self.canvas(type: :overlay)
+        canvas.save_graphics_state
+        media_box = box(:media)
+        if media_box.left != 0 || media_box.bottom != 0
+          canvas.translate(-media_box.left, -media_box.bottom) # revert initial translation of origin
+        end
+
+        to_delete = []
+        not_flattened -= annotations
+        annotations.each do |annotation|
+          annotation = document.wrap(annotation, type: :Annot)
+          appearance = annotation.appearance
+          if annotation.flagged?(:hidden) || annotation.flagged?(:invisible)
+            to_delete << annotation
+            next
+          elsif !appearance
+            not_flattened << annotation
+            next
+          end
+
+          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)
+          to_delete << annotation
+        end
+        canvas.restore_graphics_state
+
+        to_delete.each do |annotation|
+          if annotation[:Subtype] == :Widget
+            annotation.form_field.delete_widget(annotation)
+          else
+            self[:Annots].delete(annotation)
+            document.delete(annotation)
+          end
+        end
+
+        not_flattened
+      end
+
       private
 
       # Ensures that the required inheritable fields are set.