hexapdf 0.12.3 → 0.14.3

data/lib/hexapdf/pdf_array.rb

@@ -65,8 +65,11 @@ module HexaPDF
     # * Returns the native Ruby object for values with class HexaPDF::Object. However, all
     #   subclasses of HexaPDF::Object are returned as is (it makes no sense, for example, to return
     #   the hash that describes the Catalog instead of the Catalog object).
+    #
+    # Note: Hash or Array values will always be returned as-is, i.e. not wrapped with Dictionary or
+    # PDFArray.
     def [](arg1, arg2 = nil)
-      data = value[arg1, *arg2]
+      data = arg2 ? value[arg1, arg2] : value[arg1]
       return if data.nil?
 
       if arg2 || arg1.kind_of?(Range)
@@ -83,7 +86,7 @@ module HexaPDF
     # subclasses) and the given data has not (including subclasses), the data is stored inside the
     # HexaPDF::Object.
     def []=(index, data)
-      if value[index].class == HexaPDF::Object && !data.kind_of?(HexaPDF::Object) &&
+      if value[index].instance_of?(HexaPDF::Object) && !data.kind_of?(HexaPDF::Object) &&
           !data.kind_of?(HexaPDF::Reference)
         value[index].value = data
       else
@@ -113,6 +116,13 @@ module HexaPDF
       value.delete_at(index)
     end
 
+    # Deletes all values from the PDFArray that are equal to the given object.
+    #
+    # Returns the last deleted item, or +nil+ if no matching item is found.
+    def delete(object)
+      value.delete(object)
+    end
+
     # :call-seq:
     #   array.slice!(index)             -> obj or nil
     #   array.slice!(start, length)     -> new_array or nil
@@ -174,9 +184,9 @@ module HexaPDF
       self
     end
 
-    # Returns a duplicate of the underlying array.
+    # Returns an array containing the preprocessed values (like in #[]).
     def to_ary
-      value.dup
+      each.to_a
     end
 
     private
@@ -196,7 +206,7 @@ module HexaPDF
         data = document.deref(data)
         value[index] = data if index
       end
-      if data.class == HexaPDF::Object || (data.kind_of?(HexaPDF::Object) && data.value.nil?)
+      if data.instance_of?(HexaPDF::Object) || (data.kind_of?(HexaPDF::Object) && data.value.nil?)
         data = data.value
       end
       data

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
 
@@ -317,6 +343,7 @@ module HexaPDF
           @io << data.freeze
         end
         @io << "\nendstream"
+        @in_object = false
 
         nil
       else
@@ -324,12 +351,12 @@ module HexaPDF
         obj.value[:Length] = data.size
 
         str = serialize_hash(obj.value)
+        @in_object = false
+
         str << "stream\n"
         str << data
         str << "\nendstream"
       end
-    ensure
-      @in_object = false
     end
 
     # Invokes the correct serialization method for the object.

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

@@ -188,6 +188,28 @@ module HexaPDF
       token
     end
 
+    # Returns a single integer or keyword token read from the current position and advances the scan
+    # pointer. If the current position doesn't contain such a token, +nil+ is returned without
+    # advancing the scan pointer. The value +NO_MORE_TOKENS+ is returned if there are no more tokens
+    # available.
+    #
+    # Initial runs of whitespace characters are ignored.
+    #
+    # Note: This is a special method meant for use with reconstructing the cross-reference table!
+    def next_integer_or_keyword
+      skip_whitespace
+      byte = @ss.string.getbyte(@ss.pos) || -1
+      if 48 <= byte && byte <= 57
+        parse_number
+      elsif (97 <= byte && byte <= 122) || (65 <= byte && byte <= 90)
+        parse_keyword
+      elsif byte == -1 # we reached the end of the file
+        NO_MORE_TOKENS
+      else
+        nil
+      end
+    end
+
     # Reads the byte (an integer) at the current position and advances the scan pointer.
     def next_byte
       prepare_string_scanner(1)

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
@@ -249,38 +244,38 @@ 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})
+          # Wrap existing object in Form class in case the PDF writer didn't include the /Subtype
+          # key; we can do this since we know this has to be a Form object
+          form = @document.wrap(form, type: :XObject, subtype: :Form) unless form[: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
 
@@ -341,6 +336,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
@@ -385,14 +387,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