hexapdf 0.12.0 → 0.14.0

data/lib/hexapdf/layout/text_shaper.rb

@@ -68,9 +68,10 @@ module HexaPDF
           text_fragment.clear_cache
         end
         if text_fragment.style.font_features[:kern] && font.wrapped_font.features.include?(:kern)
-          if font.font_type == :TrueType
+          case font.font_type
+          when :TrueType
             process_true_type_kerning(text_fragment)
-          elsif font.font_type == :Type1
+          when :Type1
             process_type1_kerning(text_fragment)
           end
           text_fragment.clear_cache

data/lib/hexapdf/object.rb

@@ -122,9 +122,6 @@ module HexaPDF
 
     include Comparable
 
-    # A list of classes whose objects cannot be duplicated.
-    NOT_DUPLICATABLE_CLASSES = [NilClass, FalseClass, TrueClass, Symbol, Integer, Float].freeze
-
     # :call-seq:
     #   HexaPDF::Object.deep_copy(object)    -> copy
     #
@@ -139,8 +136,6 @@ module HexaPDF
         (object.indirect? || object.must_be_indirect? ? object : deep_copy(object.value))
       when HexaPDF::Reference
         object
-      when *NOT_DUPLICATABLE_CLASSES
-        object
       else
         object.dup
       end
@@ -251,29 +246,31 @@ module HexaPDF
     end
 
     # :call-seq:
-    #   obj.validate(auto_correct: true)                               -> true or false
-    #   obj.validate(auto_correct: true) {|msg, correctable| block }   -> true or false
+    #   obj.validate(auto_correct: true)                                    -> true or false
+    #   obj.validate(auto_correct: true) {|msg, correctable, obj| block }   -> true or false
     #
-    # Validates the object and, optionally, corrects problems when the option +auto_correct+ is set.
-    # The validation routine itself has to be implemented in the #perform_validation method - see
-    # its documentation for more information.
+    # Validates the object, optionally corrects problems when the option +auto_correct+ is set and
+    # returns +true+ if the object is deemed valid and +false+ otherwise.
     #
     # If a block is given, it is called on validation problems with a problem description and
-    # whether the problem is correctable.
+    # whether the problem is automatically correctable. The third argument to the block is usually
+    # this object but may be another object if during auto-correction a new object was created and
+    # validated.
     #
-    # Returns +true+ if the object is deemed valid and +false+ otherwise.
+    # The validation routine itself has to be implemented in the #perform_validation method - see
+    # its documentation for more information.
     #
     # *Note*: Even if the return value is +true+ there may be problems since HexaPDF doesn't
     # currently implement the full PDF spec. However, if the return value is +false+, there is
     # certainly a problem!
     def validate(auto_correct: true)
-      catch do |catch_tag|
-        perform_validation do |msg, correctable|
-          yield(msg, correctable) if block_given?
-          throw(catch_tag, false) unless auto_correct && correctable
-        end
-        true
+      result = true
+      perform_validation do |msg, correctable, object|
+        yield(msg, correctable, object || self) if block_given?
+        result = false unless correctable
+        return false unless auto_correct
       end
+      result
     end
 
     # Makes a deep copy of the source PDF object and resets the object identifier.
@@ -287,6 +284,28 @@ module HexaPDF
       obj
     end
 
+    # Caches and returns the given +value+ or the value of the block under the given cache key. If
+    # there is already a cached value for the key and +update+ is +false+, it is just returned.
+    #
+    # Set +update+ to +true+ to force an update of the cached value.
+    #
+    # This uses Document#cache internally.
+    def cache(key, value = Document::UNSET, update: false, &block)
+      document.cache(@data, key, value, update: update, &block)
+    end
+
+    # Returns +true+ if there is a cached value for the given key.
+    #
+    # This uses Document#cached? internally.
+    def cached?(key)
+      document.cached?(@data, key)
+    end
+
+    # Clears the cache for this object.
+    def clear_cache
+      document.clear_cache(@data)
+    end
+
     # Compares this object to another object.
     #
     # If the other object does not respond to +oid+ or +gen+, +nil+ is returned. Otherwise objects
@@ -339,17 +358,25 @@ module HexaPDF
     # are also performed!
     #
     # When the validation routine finds that the object is invalid, it has to yield a problem
-    # description and whether the problem can be corrected. After yielding, the problem has to be
-    # corrected which poses no problem because the #validate method makes sure that the yield only
-    # returns if the problem is actually correctable and if it should be corrected.
+    # description and whether the problem can be corrected. An optional third argument may contain
+    # the object that gets validated if it is different from this object (may happen when
+    # auto-correction is used).
     #
-    # Here is a sample validation routine for stream objects:
+    # After yielding, the problem has to be corrected if it is correctable. If it is not correctable
+    # and not correcting would lead to exceptions the method has to return early.
+    #
+    # Here is a sample validation routine for a dictionary object type:
     #
     #   def perform_validation
     #     super
-    #     unless value.kind_of?(Hash)
-    #       yield("A stream object needs a Hash as value")
-    #       self.value = {}
+    #
+    #     if value[:SomeKey].length != 7
+    #       yield("Length of /SomeKey is invalid")
+    #       # No need to return early here because following check doesn't rely on /SomeKey
+    #     end
+    #
+    #     if value[:OtherKey] % 2 == 0
+    #       yield("/OtherKey needs to contain an odd number of elements")
     #     end
     #   end
     def perform_validation(&block)

data/lib/hexapdf/parser.rb

@@ -59,6 +59,7 @@ module HexaPDF
       @tokenizer = Tokenizer.new(io)
       @document = document
       @object_stream_data = {}
+      @reconstructed_revision = nil
       retrieve_pdf_header_offset_and_version
     end
 
@@ -86,6 +87,8 @@ module HexaPDF
       end
 
       @document.wrap(obj, oid: oid, gen: gen, stream: stream)
+    rescue HexaPDF::MalformedPDFError
+      reconstructed_revision.object(xref_entry)
     end
 
     # Parses the indirect object at the specified offset.
@@ -235,14 +238,14 @@ module HexaPDF
         @tokenizer.skip_whitespace
         start.upto(start + number_of_entries - 1) do |oid|
           pos, gen, type = @tokenizer.next_xref_entry do |matched_size|
-            maybe_raise("Invalid cross-reference subsection entry", pos: @tokenizer.pos,
-                        force: matched_size == 20)
+            maybe_raise("Invalid cross-reference entry", pos: @tokenizer.pos,
+                        force: !matched_size)
           end
           if xref.entry?(oid)
             next
           elsif type == 'n'
             if pos == 0 || gen > 65535
-              maybe_raise("Invalid in use cross-reference entry in cross-reference section",
+              maybe_raise("Invalid in use cross-reference entry",
                           pos: @tokenizer.pos)
               xref.add_free_entry(oid, gen)
             else
@@ -264,6 +267,27 @@ module HexaPDF
         raise_malformed("Trailer is #{trailer.class} instead of dictionary ", pos: @tokenizer.pos)
       end
 
+      unless trailer[:Prev] || xref.max_oid == 0 || xref.entry?(0)
+        first_entry = xref[xref.oids[0]]
+        test_entry = xref[xref.oids[-1]]
+        @tokenizer.pos = test_entry.pos + @header_offset
+        test_oid = @tokenizer.next_token
+        first_oid = first_entry.oid
+
+        force_failure = !first_entry.free? || first_entry.gen != 65535 ||
+          !test_oid.kind_of?(Integer) || xref.oids[-1] - test_oid != first_oid
+        maybe_raise("Main cross-reference section has invalid numbering",
+                    pos: offset + @header_offset, force: force_failure)
+
+        new_xref = XRefSection.new
+        xref.oids.each do |oid|
+          entry = xref[oid]
+          entry.oid -= first_oid
+          new_xref.send(:[]=, entry.oid, entry.gen, entry)
+        end
+        xref = new_xref
+      end
+
       [xref, trailer]
     end
 
@@ -313,6 +337,11 @@ module HexaPDF
       @startxref_offset = lines[eof_index - 1].to_i
     end
 
+    # Returns the reconstructed revision.
+    def reconstructed_revision
+      @reconstructed_revision ||= reconstruct_revision
+    end
+
     # Returns the PDF version number that is stored in the file header.
     #
     # See: PDF1.7 s7.5.2
@@ -338,6 +367,61 @@ module HexaPDF
       @header_version = $1
     end
 
+    # Tries to reconstruct the PDF document's main cross-reference table by serially parsing the
+    # file and returning a Revision object for loading the found objects.
+    #
+    # If the file contains multiple cross-reference sections, all objects will be put into a single
+    # cross-reference table, later objects overwriting prior ones.
+    def reconstruct_revision
+      raise unless @document.config['parser.try_xref_reconstruction']
+      msg = "#{$!} - trying cross-reference table reconstruction"
+      @document.config['parser.on_correctable_error'].call(@document, msg, @tokenizer.pos)
+
+      xref = XRefSection.new
+      @tokenizer.pos = 0
+      while true
+        @tokenizer.skip_whitespace
+        pos = @tokenizer.pos
+        @tokenizer.scan_until(/(\n|\r\n?)+/)
+        next_new_line_pos = @tokenizer.pos
+        @tokenizer.pos = pos
+
+        token = @tokenizer.next_token rescue nil
+        if token.kind_of?(Integer)
+          gen = @tokenizer.next_token rescue nil
+          tok = @tokenizer.next_token rescue nil
+          if @tokenizer.pos > next_new_line_pos
+            @tokenizer.pos = next_new_line_pos
+          elsif gen.kind_of?(Integer) && tok.kind_of?(Tokenizer::Token) && tok == 'obj'
+            xref.add_in_use_entry(token, gen, pos)
+            @tokenizer.scan_until(/(?:\n|\r\n?)endobj\b/)
+          end
+        elsif token.kind_of?(Tokenizer::Token) && token == 'trailer'
+          obj = @tokenizer.next_object rescue nil
+          # Use last trailer found in case of multiple revisions but use first trailer in case of
+          # linearized file.
+          trailer = obj if obj.kind_of?(Hash) && (obj.key?(:Prev) || trailer.nil?)
+        elsif token == Tokenizer::NO_MORE_TOKENS
+          break
+        else
+          @tokenizer.pos = next_new_line_pos
+        end
+      end
+
+      trailer&.delete(:Prev) # no need for this and may wreak havoc
+      if !trailer || trailer.empty?
+        raise_malformed("Could not reconstruct malformed PDF because trailer was not found", pos: 0)
+      end
+
+      loader = lambda do |xref_entry|
+        obj, oid, gen, stream = parse_indirect_object(xref_entry.pos)
+        @document.wrap(obj, oid: oid, gen: gen, stream: stream)
+      end
+
+      Revision.new(@document.wrap(trailer, type: :XXTrailer), xref_section: xref,
+                   loader: loader)
+    end
+
     # Raises a HexaPDF::MalformedPDFError with the given message and source position.
     def raise_malformed(msg, pos: nil)
       raise HexaPDF::MalformedPDFError.new(msg, pos: pos)

data/lib/hexapdf/pdf_array.rb

@@ -83,7 +83,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 +113,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 +181,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 +203,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

@@ -243,7 +243,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