hexapdf 0.12.1 → 0.14.1

data/lib/hexapdf/revisions.rb

@@ -67,30 +67,38 @@ module HexaPDF
         object_loader = lambda {|xref_entry| parser.load_object(xref_entry) }
 
         revisions = []
-        xref_section, trailer = parser.load_revision(parser.startxref_offset)
-        revisions << Revision.new(document.wrap(trailer, type: :XXTrailer),
-                                  xref_section: xref_section, loader: object_loader)
-        seen_xref_offsets = {parser.startxref_offset => true}
-
-        while (prev = revisions[0].trailer.value[:Prev]) &&
-            !seen_xref_offsets.key?(prev)
-          # PDF1.7 s7.5.5 states that :Prev needs to be indirect, Adobe's reference 3.4.4 says it
-          # should be direct. Adobe's POV is followed here. Same with :XRefStm.
-          xref_section, trailer = parser.load_revision(prev)
-          seen_xref_offsets[prev] = true
-
-          stm = revisions[0].trailer.value[:XRefStm]
-          if stm && !seen_xref_offsets.key?(stm)
-            stm_xref_section, = parser.load_revision(stm)
-            xref_section.merge!(stm_xref_section)
-            seen_xref_offsets[stm] = true
+        begin
+          xref_section, trailer = parser.load_revision(parser.startxref_offset)
+          revisions << Revision.new(document.wrap(trailer, type: :XXTrailer),
+                                    xref_section: xref_section, loader: object_loader)
+          seen_xref_offsets = {parser.startxref_offset => true}
+
+          while (prev = revisions[0].trailer.value[:Prev]) &&
+              !seen_xref_offsets.key?(prev)
+            # PDF1.7 s7.5.5 states that :Prev needs to be indirect, Adobe's reference 3.4.4 says it
+            # should be direct. Adobe's POV is followed here. Same with :XRefStm.
+            xref_section, trailer = parser.load_revision(prev)
+            seen_xref_offsets[prev] = true
+
+            stm = revisions[0].trailer.value[:XRefStm]
+            if stm && !seen_xref_offsets.key?(stm)
+              stm_xref_section, = parser.load_revision(stm)
+              xref_section.merge!(stm_xref_section)
+              seen_xref_offsets[stm] = true
+            end
+
+            revisions.unshift(Revision.new(document.wrap(trailer, type: :XXTrailer),
+                                           xref_section: xref_section, loader: object_loader))
           end
-
-          revisions.unshift(Revision.new(document.wrap(trailer, type: :XXTrailer),
-                                         xref_section: xref_section, loader: object_loader))
+        rescue HexaPDF::MalformedPDFError
+          reconstructed_revision = parser.reconstructed_revision
+          unless revisions.empty?
+            reconstructed_revision.trailer.data.value = revisions.last.trailer.data.value
+          end
+          revisions << reconstructed_revision
         end
 
-        document.version = parser.file_header_version
+        document.version = parser.file_header_version rescue '1.0'
         new(document, initial_revisions: revisions, parser: parser)
       end
 

data/lib/hexapdf/serializer.rb

@@ -88,13 +88,39 @@ module HexaPDF
 
     # Creates a new Serializer object.
     def initialize
-      @dispatcher = Hash.new do |h, klass|
-        method = nil
-        klass.ancestors.each do |ancestor_klass|
-          method = "serialize_#{ancestor_klass.name.to_s.downcase.gsub(/::/, '_')}"
-          (h[klass] = method; break) if respond_to?(method, true)
-        end
-        method
+      @dispatcher = {
+        Hash => 'serialize_hash',
+        Array => 'serialize_array',
+        Symbol => 'serialize_symbol',
+        String => 'serialize_string',
+        Integer => 'serialize_integer',
+        Float => 'serialize_float',
+        Time => 'serialize_time',
+        TrueClass => 'serialize_trueclass',
+        FalseClass => 'serialize_falseclass',
+        NilClass => 'serialize_nilclass',
+        HexaPDF::Reference => 'serialize_hexapdf_reference',
+        HexaPDF::Object => 'serialize_hexapdf_object',
+        HexaPDF::Stream => 'serialize_hexapdf_stream',
+        HexaPDF::Dictionary => 'serialize_hexapdf_object',
+        HexaPDF::PDFArray => 'serialize_hexapdf_object',
+        HexaPDF::Rectangle => 'serialize_hexapdf_object',
+      }
+      @dispatcher.default_proc = lambda do |h, klass|
+        h[klass] = if klass <= HexaPDF::Stream
+                     "serialize_hexapdf_stream"
+                   elsif klass <= HexaPDF::Object
+                     "serialize_hexapdf_object"
+                   else
+                     method = nil
+                     klass.ancestors.each do |ancestor_klass|
+                       name = ancestor_klass.name.to_s.downcase
+                       name.gsub!(/::/, '_')
+                       method = "serialize_#{name}"
+                       break if respond_to?(method, true)
+                     end
+                     method
+                   end
       end
       @encrypter = false
       @io = nil
@@ -243,7 +269,7 @@ module HexaPDF
             else
               obj.dup
             end
-      obj.gsub!(/[\(\)\\\r]/n, STRING_ESCAPE_MAP)
+      obj.gsub!(/[()\\\r]/n, STRING_ESCAPE_MAP)
       "(#{obj})"
     end
 

data/lib/hexapdf/task/optimize.rb

@@ -129,9 +129,10 @@ module HexaPDF
             xref_stream = false
             objects_to_delete = []
             rev.each do |obj|
-              if obj.type == :ObjStm
+              case obj.type
+              when :ObjStm
                 objects_to_delete << obj
-              elsif obj.type == :XRef
+              when :XRef
                 xref_stream = true
                 objects_to_delete << obj if xref_streams == :delete
               else
@@ -150,9 +151,10 @@ module HexaPDF
             objstms = [doc.wrap({Type: :ObjStm})]
             old_objstms = []
             rev.each do |obj|
-              if obj.type == :XRef
+              case obj.type
+              when :XRef
                 xref_stream = true
-              elsif obj.type == :ObjStm
+              when :ObjStm
                 old_objstms << obj
               end
               delete_fields_with_defaults(obj)

data/lib/hexapdf/tokenizer.rb

@@ -249,17 +249,18 @@ module HexaPDF
     #
     # See: PDF1.7 s7.3.3
     def parse_number
-      if (val = @ss.scan(/[+-]?\d++(?!\.)/))
+      val = scan_until(WHITESPACE_OR_DELIMITER_RE) || @ss.scan(/.*/)
+      if val.match?(/\A[+-]?\d++(?!\.)\z/)
         tmp = val.to_i
         # Handle object references, see PDF1.7 s7.3.10
         prepare_string_scanner(10)
         tmp = Reference.new(tmp, @ss[1].to_i) if @ss.scan(REFERENCE_RE)
         tmp
-      elsif (val = @ss.scan(/[+-]?(?:\d+\.\d*|\.\d+)/))
+      elsif val.match?(/\A[+-]?(?:\d+\.\d*|\.\d+)\z/)
         val << '0' if val.getbyte(-1) == 46 # dot '.'
         Float(val)
       else
-        parse_keyword
+        TOKEN_CACHE[val] # val is keyword
       end
     end
 

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

@@ -37,6 +37,7 @@
 require 'hexapdf/error'
 require 'hexapdf/layout/style'
 require 'hexapdf/layout/text_fragment'
+require 'hexapdf/layout/text_layouter'
 
 module HexaPDF
   module Type
@@ -80,14 +81,8 @@ module HexaPDF
             else
               raise HexaPDF::Error, "Unsupported button field type"
             end
-          when :Tx
+          when :Tx, :Ch
             create_text_appearances
-          when :Ch
-            if @field.combo_box?
-              create_text_appearances
-            else
-              raise HexaPDF::Error, "List box not supported yet"
-            end
           else
             raise HexaPDF::Error, "Unsupported field type #{@field.field_type}"
           end
@@ -206,6 +201,10 @@ module HexaPDF
         # * The font, font size and font color are taken from the associated field's default
         #   appearance string. See VariableTextField.
         #
+        #   If the font is not usable by HexaPDF (which may be due to a variety of reasons, e.g. no
+        #   associated information in the form's default resources), the font specified by the
+        #   configuration option +acro_form.fallback_font+ will be used.
+        #
         # * The widget's rectangle /Rect must be defined. If the height is zero, it is auto-sized
         #   based on the font size. If additionally the font size is zero, a font size of
         #   +acro_form.default_font_size+ is used. If the width is zero, the
@@ -222,7 +221,7 @@ module HexaPDF
         def create_text_appearances
           font_name, font_size = @field.parse_default_appearance_string
           default_resources = @document.acro_form.default_resources
-          font = default_resources.font(font_name).font_wrapper
+          font = default_resources.font(font_name).font_wrapper rescue nil
           unless font
             fallback_font_name, fallback_font_options = @document.config['acro_form.fallback_font']
             if fallback_font_name
@@ -245,38 +244,35 @@ module HexaPDF
             rect.height = style.scaled_y_max - style.scaled_y_min + 2 * padding
           end
 
-          form = (@widget[:AP] ||= {})[:N] = @document.add({Type: :XObject, Subtype: :Form,
-                                                            BBox: [0, 0, rect.width, rect.height]})
+          form = (@widget[:AP] ||= {})[:N] ||= @document.add({Type: :XObject, Subtype: :Form})
+          form.value.replace({Type: :XObject, Subtype: :Form, BBox: [0, 0, rect.width, rect.height]})
+          form.contents = ''
           form[:Resources] = HexaPDF::Object.deep_copy(default_resources)
 
           canvas = form.canvas
           apply_background_and_border(border_style, canvas)
           style.font_size = calculate_font_size(font, font_size, rect, border_style)
+          style.clear_cache
 
           canvas.marked_content_sequence(:Tx) do
-            if (value = @field.field_value)
+            if @field.field_value || @field.concrete_field_type == :list_box
               canvas.save_graphics_state do
                 canvas.rectangle(padding, padding, rect.width - 2 * padding,
                                  rect.height - 2 * padding).clip_path.end_path
-                fragment = HexaPDF::Layout::TextFragment.create(value, style)
-                # Adobe seems to be left/right-aligning based on twice the border width and
-                # vertically centering based on the cap height, if enough space is available
-                x = case @field.text_alignment
-                    when :left then 2 * padding
-                    when :right then [rect.width - 2 * padding - fragment.width, 2 * padding].max
-                    when :center then [(rect.width - fragment.width) / 2.0, 2 * padding].max
-                    end
-                cap_height = font.wrapped_font.cap_height * font.scaling_factor / 1000.0 *
-                  style.font_size
-                y = padding + (rect.height - 2 * padding - cap_height) / 2.0
-                y = padding - style.scaled_font_descender if y < 0
-                fragment.draw(canvas, x, y)
+                if @field.concrete_field_type == :multiline_text_field
+                  draw_multiline_text(canvas, rect, style, padding)
+                elsif @field.concrete_field_type == :list_box
+                  draw_list_box(canvas, rect, style, padding)
+                else
+                  draw_single_line_text(canvas, rect, style, padding)
+                end
               end
             end
           end
         end
 
         alias create_combo_box_appearances create_text_appearances
+        alias create_list_box_appearances create_text_appearances
 
         private
 
@@ -337,6 +333,13 @@ module HexaPDF
                   canvas.circle(rect.width / 2.0, rect.height / 2.0, [width / 2.0, height / 2.0].min)
                 else
                   canvas.rectangle(offset, offset, width, height)
+                  if @field.concrete_field_type == :comb_text_field
+                    cell_width = rect.width.to_f / @field[:MaxLen]
+                    1.upto(@field[:MaxLen] - 1) do |i|
+                      canvas.line(i * cell_width, border_style.width,
+                                  i * cell_width, border_style.width + height)
+                    end
+                  end
                 end
               end
               canvas.stroke
@@ -381,14 +384,115 @@ module HexaPDF
           end
         end
 
+        # Draws a single line of text inside the widget's rectangle.
+        def draw_single_line_text(canvas, rect, style, padding)
+          value = @field.field_value
+          fragment = HexaPDF::Layout::TextFragment.create(value, style)
+
+          if @field.concrete_field_type == :comb_text_field
+            unless @field.key?(:MaxLen)
+              raise HexaPDF::Error, "Missing or invalid dictionary field /MaxLen for comb text field"
+            end
+            new_items = []
+            cell_width = rect.width.to_f / @field[:MaxLen]
+            scaled_cell_width = cell_width / style.scaled_font_size.to_f
+            fragment.items.each_cons(2) do |a, b|
+              new_items << a << -(scaled_cell_width - a.width / 2.0 - b.width / 2.0)
+            end
+            new_items << fragment.items.last
+            fragment.items.replace(new_items)
+            fragment.clear_cache
+            # Adobe always seems to add 1 to the first offset...
+            x_offset = 1 + (cell_width - style.scaled_item_width(fragment.items[0])) / 2.0
+            x = case @field.text_alignment
+                when :left then x_offset
+                when :right then x_offset + cell_width * (@field[:MaxLen] - value.length)
+                when :center then x_offset + cell_width * ((@field[:MaxLen] - value.length) / 2)
+                end
+          else
+            # Adobe seems to be left/right-aligning based on twice the border width
+            x = case @field.text_alignment
+                when :left then 2 * padding
+                when :right then [rect.width - 2 * padding - fragment.width, 2 * padding].max
+                when :center then [(rect.width - fragment.width) / 2.0, 2 * padding].max
+                end
+          end
+
+          # Adobe seems to be vertically centering based on the cap height, if enough space is
+          # available
+          cap_height = style.font.wrapped_font.cap_height * style.font.scaling_factor / 1000.0 *
+            style.font_size
+          y = padding + (rect.height - 2 * padding - cap_height) / 2.0
+          y = padding - style.scaled_font_descender if y < 0
+          fragment.draw(canvas, x, y)
+        end
+
+        # Draws multiple lines  of text inside the widget's rectangle.
+        def draw_multiline_text(canvas, rect, style, padding)
+          items = [Layout::TextFragment.create(@field.field_value, style)]
+          layouter = Layout::TextLayouter.new(style)
+          layouter.style.align(@field.text_alignment).line_spacing(:proportional, 1.25)
+
+          result = nil
+          if style.font_size == 0 # need to auto-size text
+            style.font_size = 12 # Adobe seems to use this as starting point
+            style.clear_cache
+            loop do
+              result = layouter.fit(items, rect.width - 4 * padding, rect.height - 4 * padding)
+              break if result.status == :success || style.font_size <= 4 # don't make text too small
+              style.font_size -= 1
+              style.clear_cache
+            end
+          else
+            result = layouter.fit(items, rect.width - 4 * padding, 2**20)
+          end
+
+          unless result.lines.empty?
+            result.draw(canvas, 2 * padding, rect.height - 2 * padding - result.lines[0].height / 2.0)
+          end
+        end
+
+        # Draws the visible option items of the list box in the widget's rectangle.
+        def draw_list_box(canvas, rect, style, padding)
+          option_items = @field.option_items
+          top_index = @field.list_box_top_index
+          items = [Layout::TextFragment.create(option_items[top_index..-1].join("\n"), style)]
+
+          indices = @field[:I] || []
+          value_indices = [@field.field_value].flatten.compact.map {|val| option_items.index(val) }
+          indices = value_indices if indices != value_indices
+
+          layouter = Layout::TextLayouter.new(style)
+          layouter.style.align(@field.text_alignment).line_spacing(:proportional, 1.25)
+          result = layouter.fit(items, rect.width - 4 * padding, rect.height)
+
+          unless result.lines.empty?
+            top_gap = style.line_spacing.gap(result.lines[0], result.lines[0])
+            line_height = style.line_spacing.baseline_distance(result.lines[0], result.lines[0])
+            canvas.fill_color(153, 193, 218) # Adobe's color for selection highlighting
+            indices.map! {|i| rect.height - padding - (i - top_index + 1) * line_height }.each do |y|
+              next if y + line_height > rect.height || y + line_height < padding
+              canvas.rectangle(padding, y, rect.width - 2 * padding, line_height)
+            end
+            canvas.fill if canvas.graphics_object == :path
+            result.draw(canvas, 2 * padding, rect.height - padding - top_gap)
+          end
+        end
+
         # Calculates the font size for text fields based on the font and font size of the default
         # appearance string, the annotation rectangle and the border style.
         def calculate_font_size(font, font_size, rect, border_style)
           if font_size == 0
-            unit_font_size = (font.wrapped_font.bounding_box[3] - font.wrapped_font.bounding_box[1]) *
-              font.scaling_factor / 1000.0
-            # The constant factor was found empirically by checking what Adobe Reader etc. do
-            (rect.height - 2 * border_style.width) / unit_font_size * 0.83
+            if @field.concrete_field_type == :multiline_text_field
+              0 # Handled by multiline drawing code
+            elsif @field.concrete_field_type == :list_box
+              12 # Seems to be Adobe's default
+            else
+              unit_font_size = (font.wrapped_font.bounding_box[3] - font.wrapped_font.bounding_box[1]) *
+                font.scaling_factor / 1000.0
+              # The constant factor was found empirically by checking what Adobe Reader etc. do
+              (rect.height - 2 * border_style.width) / unit_font_size * 0.83
+            end
           else
             font_size
           end

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

@@ -134,8 +134,8 @@ module HexaPDF
         # Check boxes:: For check boxes that are in the on state the value +true+ is returned.
         #               Otherwise +false+ is returned.
         #
-        # Radio buttons:: If no radio button is selected, +nil+ is returned. Otherwise the name of
-        #                 the specific radio button that is selected is returned.
+        # Radio buttons:: If no radio button is selected, +nil+ is returned. Otherwise the value (a
+        #                 Symbol) of the specific radio button that is selected is returned.
         def field_value
           normalized_field_value(:V)
         end
@@ -149,7 +149,8 @@ module HexaPDF
         #               +false+ for unchecking it.
         #
         # Radio buttons:: To turn all radio buttons off, provide +nil+ as value. Otherwise provide
-        #                 the name of a radio button that should be turned on.
+        #                 the value (a Symbol or an object responding to +#to_sym+) of a radio
+        #                 button that should be turned on.
         def field_value=(value)
           normalized_field_value_set(:V, value)
         end
@@ -179,7 +180,7 @@ module HexaPDF
           end
         end
 
-        # Returns the name used for setting the check box to the on state.
+        # Returns the name (a Symbol) used for setting the check box to the on state.
         #
         # Defaults to :Yes if no other name could be determined.
         def check_box_on_name
@@ -187,7 +188,8 @@ module HexaPDF
             find {|key| key != :Off } || :Yes
         end
 
-        # Returns the array of values that can be used for the field value of the radio button.
+        # Returns the array of Symbol values that can be used for the field value of the radio
+        # button.
         def radio_button_values
           each_widget.map do |widget|
             widget.appearance&.normal_appearance&.value&.each_key&.find {|key| key != :Off }
@@ -200,8 +202,8 @@ module HexaPDF
         # default appearance.
         #
         # If the widget is created for a radio button field, the +value+ argument needs to set to
-        # the value (a symbol) this widget represents. It can be used with #field_value= to set this
-        # specific widget of the radio button set to on.
+        # the value (a Symbol or an object responding to +#to_sym+) this widget represents. It can
+        # be used with #field_value= to set this specific widget of the radio button set to on.
         #
         # See: Field#create_widget, AppearanceGenerator button field methods
         def create_widget(page, defaults: true, value: nil, **values)
@@ -209,8 +211,11 @@ module HexaPDF
             if check_box?
               widget[:AP] = {N: {Yes: nil, Off: nil}}
             elsif radio_button?
-              raise ArgumentError, "Argument value has to be provided for radio buttons" unless value
-              widget[:AP] = {N: {value => nil, Off: nil}}
+              unless value.respond_to?(:to_sym)
+                raise ArgumentError, "Argument 'value' has to be provided for radio buttons " \
+                  "and needs to respond to #to_sym"
+              end
+              widget[:AP] = {N: {value.to_sym => nil, Off: nil}}
             end
             next unless defaults
             widget.border_style(color: 0, width: 1, style: (push_button? ? :beveled : :solid))
@@ -223,10 +228,12 @@ module HexaPDF
         #
         # The created appearance streams depend on the actual type of the button field. See
         # AppearanceGenerator for the details.
-        def create_appearances
+        #
+        # By setting +force+ to +true+ the creation of the appearances can be forced.
+        def create_appearances(force: false)
           appearance_generator_class = document.config.constantize('acro_form.appearance_generator')
           each_widget do |widget|
-            next if widget.appearance?
+            next if !force && widget.appearance?
             if check_box?
               appearance_generator_class.new(widget).create_check_box_appearances
             elsif radio_button?
@@ -240,6 +247,7 @@ module HexaPDF
         # Updates the widgets so that they reflect the current field value.
         def update_widgets
           return if push_button?
+          create_appearances
           value = self[:V]
           each_widget do |widget|
             widget[:AS] = (widget.appearance&.normal_appearance&.value&.key?(value) ? value : :Off)
@@ -271,8 +279,8 @@ module HexaPDF
                         value == true ? check_box_on_name : :Off
                       elsif value.nil?
                         :Off
-                      elsif radio_button_values.include?(value)
-                        value
+                      elsif radio_button_values.include?(value.to_sym)
+                        value.to_sym
                       else
                         @document.config['acro_form.on_invalid_value'].call(self, value)
                       end