hexapdf 0.40.0 → 0.42.0

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

@@ -39,6 +39,7 @@ require 'hexapdf/error'
 require 'hexapdf/layout/style'
 require 'hexapdf/layout/text_fragment'
 require 'hexapdf/layout/text_layouter'
+require 'hexapdf/type/acro_form/java_script_actions'
 
 module HexaPDF
   module Type
@@ -129,14 +130,20 @@ module HexaPDF
         #   widget.background_color(1)
         #   widget.marker_style(style: :circle, size: 0, color: 0)
         def create_check_box_appearances
-          appearance_keys = @widget.appearance_dict&.normal_appearance&.value&.keys || []
-          on_name = (appearance_keys - [:Off]).first
+          normal_appearance = @widget.appearance_dict&.normal_appearance
+          if !normal_appearance.kind_of?(HexaPDF::Dictionary) || normal_appearance.kind_of?(HexaPDF::Stream)
+            (@widget[:AP] ||= {})[:N] = {Off: nil}
+            normal_appearance = @widget[:AP][:N]
+            normal_appearance[@field[:V] == :Off ? :Yes : @field[:V]] = nil
+          end
+          on_name = (normal_appearance.value.keys - [:Off]).first
           unless on_name
             raise HexaPDF::Error, "Widget of button field doesn't define name for on state"
           end
 
           @widget[:AS] = (@field[:V] == on_name ? on_name : :Off)
           @widget.flag(:print)
+          @widget.unflag(:hidden)
 
           border_style = @widget.border_style
           marker_style = @widget.marker_style
@@ -206,6 +213,7 @@ module HexaPDF
 
           @widget[:AS] = :N
           @widget.flag(:print)
+          @widget.unflag(:hidden)
           rect = @widget[:Rect]
           rect.width = @document.config['acro_form.text_field.default_width'] if rect.width == 0
           if rect.height == 0
@@ -358,7 +366,7 @@ module HexaPDF
 
         # Draws a single line of text inside the widget's rectangle.
         def draw_single_line_text(canvas, width, height, style, padding)
-          value, text_color = apply_javascript_formatting(@field.field_value)
+          value, text_color = JavaScriptActions.apply_format(@field.field_value, @field[:AA]&.[](:F))
           style.fill_color = text_color if text_color
           calculate_and_apply_font_size(value, style, width, height, padding)
           line = HexaPDF::Layout::Line.new(@document.layout.text_fragments(value, style: style))
@@ -500,79 +508,6 @@ module HexaPDF
           style.clear_cache
         end
 
-        # Handles Javascript formatting routines for single-line text fields.
-        #
-        # Returns [value, nil_or_text_color] where value is the new, potentially adjusted field
-        # value and the second argument is either +nil+ or the color that should be used for the
-        # text value.
-        def apply_javascript_formatting(value)
-          format_action = @widget[:AA]&.[](:F)
-          return [value, nil] unless format_action && format_action[:S] == :JavaScript
-          if (match = AF_NUMBER_FORMAT_RE.match(format_action[:JS]))
-            apply_af_number_format(value, match)
-          else
-            [value, nil]
-          end
-        end
-
-        # Regular expression for matching the AFNumber_Format Javascript method.
-        AF_NUMBER_FORMAT_RE = /
-          \AAFNumber_Format\(
-            \s*(?<ndec>\d+)\s*,
-            \s*(?<sep_style>[0-3])\s*,
-            \s*(?<neg_style>[0-3])\s*,
-            \s*0\s*,
-            \s*(?<currency_string>".*?")\s*,
-            \s*(?<prepend>false|true)\s*
-          \);\z
-        /x
-
-        # Implements the Javascript AFNumber_Format method.
-        #
-        # See:
-        # - https://experienceleague.adobe.com/docs/experience-manager-learn/assets/FormsAPIReference.pdf
-        # - https://opensource.adobe.com/dc-acrobat-sdk-docs/library/jsapiref/JS_API_AcroJS.html#printf
-        def apply_af_number_format(value, match)
-          value = value.to_f
-          format = "%.#{match[:ndec]}f"
-          text_color = 'black'
-
-          currency_string = JSON.parse(match[:currency_string])
-          format = (match[:prepend] == 'true' ? currency_string + format : format + currency_string)
-
-          if value < 0
-            value = value.abs
-            case match[:neg_style]
-            when '0' # MinusBlack
-              format = "-#{format}"
-            when '1' # Red
-              text_color = 'red'
-            when '2' # ParensBlack
-              format = "(#{format})"
-            when '3' # ParensRed
-              format = "(#{format})"
-              text_color = 'red'
-            end
-          end
-
-          result = sprintf(format, value)
-
-          # sep_style: 0=12,345.67, 1=12345.67, 2=12.345,67, 3=12345,67
-          before_decimal_point, after_decimal_point = result.split('.')
-          if match[:sep_style] == '0' || match[:sep_style] == '2'
-            separator = (match[:sep_style] == '0' ? ',' : '.')
-            before_decimal_point.gsub!(/\B(?=(\d\d\d)+(?:[^\d]|\z))/, separator)
-          end
-          result = if after_decimal_point
-                     decimal_point = (match[:sep_style] =~ /[01]/ ? '.' : ',')
-                     "#{before_decimal_point}#{decimal_point}#{after_decimal_point}"
-                   else
-                     before_decimal_point
-                   end
-
-          [result, text_color]
-        end
-
       end
 
     end

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

@@ -165,14 +165,16 @@ module HexaPDF
         #                nothing is stored for them (e.g a no-op).
         #
         # Check boxes:: Provide +nil+ or +false+ as value to toggle all check box widgets off. If
-        #               there is only one possible value, +true+ may be used for checking the box,
-        #               i.e. toggling it to the on state. Otherwise provide the value (a Symbol or
-        #               an object responding to +#to_sym+) of the check box widget that should be
-        #               toggled on.
+        #               +true+ is provided, all check box widgets with the same name as the first
+        #               one are toggled on. Otherwise provide the value (a Symbol or an object
+        #               responding to +#to_sym+) of the check box widget that should be toggled on.
         #
         # Radio buttons:: To turn all radio buttons off, provide +nil+ as value. Otherwise provide
         #                 the value (a Symbol or an object responding to +#to_sym+) of a radio
         #                 button that should be turned on.
+        #
+        # Note that in most cases the field needs to already have widgets because the value is
+        # checked against the possibly allowed values which depend on the existing widgets.
         def field_value=(value)
           normalized_field_value_set(:V, value)
         end
@@ -303,7 +305,7 @@ module HexaPDF
                       elsif check_box?
                         if value == false
                           :Off
-                        elsif value == true && av.size == 1
+                        elsif value == true && av.size >= 1
                           av[0]
                         elsif av.include?(value.to_sym)
                           value.to_sym

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

@@ -155,6 +155,12 @@ module HexaPDF
           field.value[name].nil? ? nil : field[name]
         end
 
+        # Wraps the given +field+ object inside the correct field class and returns the wrapped
+        # object.
+        def self.wrap(document, field)
+          document.wrap(field, type: :XXAcroFormField, subtype: inherited_value(field, :FT))
+        end
+
         # Form fields must always be indirect objects.
         def must_be_indirect?
           true
@@ -236,6 +242,14 @@ module HexaPDF
           kids.nil? || kids.empty? || kids.none? {|kid| kid.key?(:T) }
         end
 
+        # Returns self.
+        #
+        # This method is only here to make it easier to get the form field when the object may
+        # either be a form field or a field widget.
+        def form_field
+          self
+        end
+
         # Returns +true+ if the field contains an embedded widget.
         def embedded_widget?
           key?(:Subtype)

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

@@ -99,11 +99,11 @@ module HexaPDF
           document.pages.each do |page|
             page.each_annotation do |annot|
               if !annot.key?(:Parent) && annot.key?(:FT)
-                result << document.wrap(annot, type: :XXAcroFormField, subtype: annot[:FT])
+                result << Field.wrap(document, annot)
               elsif annot.key?(:Parent)
                 field = annot[:Parent]
                 field = field[:Parent] while field[:Parent]
-                result << document.wrap(field, type: :XXAcroFormField)
+                result << Field.wrap(document, field)
               end
             end
           end
@@ -129,8 +129,7 @@ module HexaPDF
             array.each_with_index do |field, index|
               next if field.nil?
               unless field.respond_to?(:type) && field.type == :XXAcroFormField
-                array[index] = field = document.wrap(field, type: :XXAcroFormField,
-                                                     subtype: Field.inherited_value(field, :FT))
+                array[index] = field = Field.wrap(document, field)
               end
               if field.terminal_field?
                 yield(field)
@@ -153,8 +152,7 @@ module HexaPDF
           name.split('.').each do |part|
             field = nil
             fields&.each do |f|
-              f = document.wrap(f, type: :XXAcroFormField,
-                                subtype: Field.inherited_value(f, :FT))
+              f = Field.wrap(document, f)
               next unless f[:T] == part
               field = f
               fields = field[:Kids] unless field.terminal_field?
@@ -274,6 +272,9 @@ module HexaPDF
         #
         # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
         # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        #
+        # Before a field value other than +false+ can be assigned to the check box, a widget needs
+        # to be created.
         def create_check_box(name)
           create_field(name, :Btn, &:initialize_as_check_box)
         end
@@ -282,6 +283,9 @@ module HexaPDF
         #
         # The +name+ may contain dots to signify a field hierarchy. If so, the referenced parent
         # fields must already exist. If it doesn't contain dots, a top-level field is created.
+        #
+        # Before a field value other than +nil+ can be assigned to the radio button, at least one
+        # widget needs to be created.
         def create_radio_button(name)
           create_field(name, :Btn, &:initialize_as_radio_button)
         end
@@ -347,6 +351,45 @@ module HexaPDF
           create_field(name, :Sig) {}
         end
 
+        # Fills form fields with the values from the given +data+ hash.
+        #
+        # The keys of the +data+ hash need to be full field names and the values are the respective
+        # values, usually in string form. It is possible to specify only some of the fields of the
+        # form.
+        #
+        # What kind of values are supported for a field depends on the field type:
+        #
+        # * For fields containing text (single/multiline/comb text fields, file select fields, combo
+        #   boxes and list boxes) the value needs to be a string and it is assigned as is.
+        #
+        # * For check boxes, the values "y"/"yes"/"t"/"true" are handled as assigning +true+ to the
+        #   field, the values "n"/"no"/"f"/"false" are handled as assigning +false+ to the field,
+        #   and every other string value is assigned as is. See ButtonField#field_value= for
+        #   details.
+        #
+        # * For radio buttons the value needs to be a String or a Symbol representing the name of
+        #   the radio button widget to select.
+        def fill(data)
+          data.each do |field_name, value|
+            field = field_by_name(field_name)
+            raise HexaPDF::Error, "AcroForm field named '#{field_name}' not found" unless field
+
+            case field.concrete_field_type
+            when :single_line_text_field, :multiline_text_field, :comb_text_field, :file_select_field,
+                :combo_box, :list_box, :editable_combo_box, :radio_button
+              field.field_value = value
+            when :check_box
+              field.field_value = case value
+                                  when /\A(?:y(es)?|t(rue)?)\z/ then true
+                                  when /\A(?:n(o)?|f(alse)?)\z/ then false
+                                  else value
+                                  end
+            else
+              raise HexaPDF::Error, "AcroForm field type #{field.concrete_field_type} not yet supported"
+            end
+          end
+        end
+
         # Returns the dictionary containing the default resources for form field appearance streams.
         def default_resources
           self[:DR] ||= document.wrap({ProcSet: [:PDF, :Text, :ImageB, :ImageC, :ImageI]},
@@ -420,6 +463,26 @@ module HexaPDF
           not_flattened
         end
 
+        # Recalculates all form fields that have a calculate action applied (which are all fields
+        # listed in the /CO entry).
+        #
+        # If HexaPDF doesn't support a calculation method or an error occurs during calculation, the
+        # field value is not updated.
+        #
+        # Note that calculations are *not* done automatically when a form field's value changes
+        # since it would lead to possibly many calls to this actions. So first fill in all field
+        # values and then call this method.
+        #
+        # See: JavaScriptActions
+        def recalculate_fields
+          self[:CO]&.each do |field|
+            field = Field.wrap(document, field)
+            next unless field && (calculation_action = field[:AA]&.[](:C))
+            result = JavaScriptActions.calculate(self, calculation_action)
+            field.form_field.field_value = result if result
+          end
+        end
+
         private
 
         # Creates a new field with the full name +name+ and the field type +type+.
@@ -468,8 +531,7 @@ module HexaPDF
               end
               next false unless field.key?(:T) # Skip widgets
 
-              field = document.wrap(field, type: :XXAcroFormField,
-                                    subtype: Field.inherited_value(field, :FT))
+              field = Field.wrap(document, field)
               reject = false
               if field[:Parent] != parent
                 yield("Parent entry of field (#{field.oid},#{field.gen}) invalid", true)