hexapdf 0.20.3 → 0.21.1

data/lib/hexapdf/content/canvas.rb

@@ -2015,7 +2015,7 @@ module HexaPDF
             invoke2(:Td, offset[0], offset[1])
           end
         else
-          invoke0(:"T*")
+          invoke0(:'T*')
         end
         self
       end

data/lib/hexapdf/content/color_space.rb

@@ -296,7 +296,7 @@ module HexaPDF
           spec = if first_item.match?(/\A\h{6}\z/)
                    first_item.scan(/../).map!(&:hex)
                  elsif first_item.match?(/\A\h{3}\z/)
-                   first_item.each_char.map {|x| (x*2).hex}
+                   first_item.each_char.map {|x| (x * 2).hex }
                  elsif CSS_COLOR_NAMES.key?(first_item)
                    CSS_COLOR_NAMES[first_item]
                  else

data/lib/hexapdf/content/operator.rb

@@ -1036,14 +1036,14 @@ module HexaPDF
         s: EndPath.new('s'),
         f: EndPath.new('f'),
         F: EndPath.new('F'),
-        'f*'.to_sym => EndPath.new('f*'),
+        'f*': EndPath.new('f*'),
         B: EndPath.new('B'),
-        'B*'.to_sym => EndPath.new('B*'),
+        'B*': EndPath.new('B*'),
         b: EndPath.new('b'),
-        'b*'.to_sym => EndPath.new('b*'),
+        'b*': EndPath.new('b*'),
         n: EndPath.new('n'),
         W: ClipPath.new('W'),
-        'W*'.to_sym => ClipPath.new('W*'),
+        'W*': ClipPath.new('W*'),
 
         BI: InlineImage.new,
 
@@ -1059,10 +1059,10 @@ module HexaPDF
         Td: MoveText.new,
         TD: MoveTextAndSetLeading.new,
         Tm: SetTextMatrix.new,
-        'T*'.to_sym => MoveTextNextLine.new,
+        'T*': MoveTextNextLine.new,
         Tj: ShowText.new,
-        '\''.to_sym => MoveTextNextLineAndShowText.new,
-        '"'.to_sym => SetSpacingMoveTextNextLineAndShowText.new,
+        "'": MoveTextNextLineAndShowText.new,
+        '"': SetSpacingMoveTextNextLineAndShowText.new,
         TJ: ShowTextWithPositioning.new,
       }
       DEFAULT_OPERATORS.default_proc = proc {|h, k| h[k] = BaseOperator.new(k.to_s) }

data/lib/hexapdf/content/parser.rb

@@ -94,11 +94,11 @@ module HexaPDF
         elsif byte == 40 # (
           parse_literal_string
         elsif byte == 60 # <
-          if @string.getbyte(@ss.pos + 1) != 60
-            parse_hex_string
-          else
+          if @string.getbyte(@ss.pos + 1) == 60
             @ss.pos += 2
             TOKEN_DICT_START
+          else
+            parse_hex_string
           end
         elsif byte == 62 # >
           unless @string.getbyte(@ss.pos + 1) == 62

data/lib/hexapdf/content/processor.rb

@@ -187,7 +187,7 @@ module HexaPDF
 
         # Returns the concatenated text of the boxes.
         def string
-          @boxes.map(&:string).join('')
+          @boxes.map(&:string).join
         end
 
         # :call-seq:
@@ -260,14 +260,14 @@ module HexaPDF
         s: :close_and_stroke_path,
         f: :fill_path_non_zero,
         F: :fill_path_non_zero,
-        'f*'.to_sym => :fill_path_even_odd,
+        'f*': :fill_path_even_odd,
         B: :fill_and_stroke_path_non_zero,
-        'B*'.to_sym => :fill_and_stroke_path_even_odd,
+        'B*': :fill_and_stroke_path_even_odd,
         b: :close_fill_and_stroke_path_non_zero,
-        'b*'.to_sym => :close_fill_and_stroke_path_even_odd,
+        'b*': :close_fill_and_stroke_path_even_odd,
         n: :end_path,
         W: :clip_path_non_zero,
-        'W*'.to_sym => :clip_path_even_odd,
+        'W*': :clip_path_even_odd,
         BT: :begin_text,
         ET: :end_text,
         Tc: :set_character_spacing,
@@ -280,10 +280,10 @@ module HexaPDF
         Td: :move_text,
         TD: :move_text_and_set_leading,
         Tm: :set_text_matrix,
-        'T*'.to_sym => :move_text_next_line,
+        'T*': :move_text_next_line,
         Tj: :show_text,
-        '\''.to_sym => :move_text_next_line_and_show_text,
-        '"'.to_sym => :set_spacing_move_text_next_line_and_show_text,
+        "'": :move_text_next_line_and_show_text,
+        '"': :set_spacing_move_text_next_line_and_show_text,
         TJ: :show_text_with_positioning,
         d0: :set_glyph_width, # only for Type 3 fonts
         d1: :set_glyph_width_and_bounding_box, # only for Type 3 fonts
@@ -392,7 +392,7 @@ module HexaPDF
           data = data.each_with_object(''.b) {|obj, result| result << obj if obj.kind_of?(String) }
         end
         font = graphics_state.font
-        font.decode(data).map {|code_point| font.to_utf8(code_point) }.join('')
+        font.decode(data).map {|code_point| font.to_utf8(code_point) }.join
       end
 
       # Decodes the given text object and returns it as a CompositeBox object.

data/lib/hexapdf/document/signatures.rb

@@ -93,12 +93,12 @@ module HexaPDF
 
         # Returns the name to be set on the /Filter key when using this signing handler.
         def filter_name
-          :"Adobe.PPKLite"
+          :'Adobe.PPKLite'
         end
 
         # Returns the name to be set on the /SubFilter key when using this signing handler.
         def sub_filter_name
-          :"adbe.pkcs7.detached"
+          :'adbe.pkcs7.detached'
         end
 
         # Sets the DocMDP permissions that should be applied to the document.
@@ -171,7 +171,7 @@ module HexaPDF
       # Creates a signing handler with the given options and returns it.
       #
       # A signing handler name is mapped to a class via the 'signature.signing_handler'
-      # configuration option.
+      # configuration option. The default signing handler is DefaultHandler.
       def handler(name: :default, **options)
         handler = @document.config.constantize('signature.signing_handler', name) do
           raise HexaPDF::Error, "No signing handler named '#{name}' is available"
@@ -183,7 +183,8 @@ module HexaPDF
       #
       # This method will add a new signature to the document and write the updated document to the
       # given file or IO stream. Afterwards the document can't be modified anymore and still retain
-      # a correct digital signature; create a new document based on the file or IO stream instead.
+      # a correct digital signature. To modify the signed document (e.g. for adding another
+      # signature) create a new document based on the given file or IO stream instead.
       #
       # +signature+::
       #     Can either be a signature object (determined via the /Type key), a signature field or

data/lib/hexapdf/document.rb

@@ -638,6 +638,9 @@ module HexaPDF
     # of the keyword arguments (see HexaPDF::Document::Signatures#handler for details).
     #
     # If not changed, the default signing handler is HexaPDF::Document::Signatures::DefaultHandler.
+    #
+    # *Note*: Once signing is done the document cannot be changed anymore since it was written. If a
+    # document needs to be signed multiple times, it needs to be loaded again after writing.
     def sign(file_or_io, handler: :default, signature: nil, write_options: {}, **handler_options)
       handler = signatures.handler(name: handler, **handler_options)
       signatures.add(file_or_io, handler, signature: signature, write_options: write_options)
@@ -714,6 +717,10 @@ module HexaPDF
       end
     end
 
+    def inspect #:nodoc:
+      "<#{self.class.name}:#{object_id}>"
+    end
+
   end
 
 end

data/lib/hexapdf/encryption/aes.rb

@@ -114,10 +114,12 @@ module HexaPDF
         #
         # See: PDF1.7 s7.6.2.
         def decrypt(key, data)
-          if data.length % BLOCK_SIZE != 0 || data.length < 2 * BLOCK_SIZE
+          if data.length % BLOCK_SIZE != 0 || data.length < BLOCK_SIZE
             raise HexaPDF::EncryptionError, "Invalid data for decryption, need 32 + 16*n bytes"
           end
-          unpad(new(key, data.slice!(0, BLOCK_SIZE), :decrypt).process(data))
+          iv = data.slice!(0, BLOCK_SIZE)
+          # Handle invalid files with missing padding
+          data.empty? ? data : unpad(new(key, iv, :decrypt).process(data))
         end
 
         # Returns a Fiber object that decrypts the data from the given source fiber with the
@@ -140,11 +142,13 @@ module HexaPDF
               Fiber.yield(algorithm.process(new_data))
             end
 
-            if data.length < BLOCK_SIZE || data.length % BLOCK_SIZE != 0
+            if data.length % BLOCK_SIZE != 0
               raise HexaPDF::EncryptionError, "Invalid data for decryption, need 32 + 16*n bytes"
+            elsif data.empty?
+              data # Handle invalid files with missing padding
+            else
+              unpad(algorithm.process(data))
             end
-
-            unpad(algorithm.process(data))
           end
         end
 

data/lib/hexapdf/font/true_type/font.rb

@@ -123,7 +123,7 @@ module HexaPDF
 
         # Returns the weight of the font.
         def weight
-          self[:"OS/2"].weight_class || 0
+          self[:'OS/2'].weight_class || 0
         end
 
         # Returns the bounding of the font.
@@ -133,22 +133,22 @@ module HexaPDF
 
         # Returns the cap height of the font.
         def cap_height
-          self[:"OS/2"].cap_height
+          self[:'OS/2'].cap_height
         end
 
         # Returns the x-height of the font.
         def x_height
-          self[:"OS/2"].x_height
+          self[:'OS/2'].x_height
         end
 
         # Returns the ascender of the font.
         def ascender
-          self[:"OS/2"].typo_ascender || self[:hhea].ascent
+          self[:'OS/2'].typo_ascender || self[:hhea].ascent
         end
 
         # Returns the descender of the font.
         def descender
-          self[:"OS/2"].typo_descender || self[:hhea].descent
+          self[:'OS/2'].typo_descender || self[:hhea].descent
         end
 
         # Returns the italic angle of the font, in degrees counter-clockwise from the vertical.
@@ -176,12 +176,12 @@ module HexaPDF
 
         # Returns the distance from the baseline to the top of the strikeout line.
         def strikeout_position
-          self[:"OS/2"].strikeout_position
+          self[:'OS/2'].strikeout_position
         end
 
         # Returns the stroke width for the strikeout line.
         def strikeout_thickness
-          self[:"OS/2"].strikeout_size
+          self[:'OS/2'].strikeout_size
         end
 
         # Returns th glyph ID of the missing glyph, i.e. 0.

data/lib/hexapdf/font/true_type/optimizer.rb

@@ -55,7 +55,7 @@ module HexaPDF
             'hmtx' => font[:hmtx].raw_data,
           }
           tables['cmap'] = font[:cmap].raw_data if font[:cmap]
-          tables['cvt '] = font[:"cvt "].raw_data if font[:"cvt "]
+          tables['cvt '] = font[:'cvt '].raw_data if font[:'cvt ']
           tables['fpgm'] = font[:fpgm].raw_data if font[:fpgm]
           tables['prep'] = font[:prep].raw_data if font[:prep]
           Builder.build(tables)

data/lib/hexapdf/font/true_type/subsetter.rb

@@ -99,7 +99,7 @@ module HexaPDF
             'loca' => loca,
             'hmtx' => hmtx,
           }
-          tables['cvt '] = @font[:"cvt "].raw_data if @font[:"cvt "]
+          tables['cvt '] = @font[:'cvt '].raw_data if @font[:'cvt ']
           tables['fpgm'] = @font[:fpgm].raw_data if @font[:fpgm]
           tables['prep'] = @font[:prep].raw_data if @font[:prep]
 

data/lib/hexapdf/font/true_type/table/cmap_subtable.rb

@@ -282,12 +282,12 @@ module HexaPDF
             def self.mapper(end_codes, start_codes, id_deltas, id_range_offsets, glyph_indexes)
               compute_glyph_id = lambda do |index, code|
                 offset = id_range_offsets[index]
-                if offset != 0
+                if offset == 0
+                  glyph_id = (code + id_deltas[index]) % 65536
+                else
                   glyph_id = glyph_indexes[offset - end_codes.length + (code - start_codes[index])]
                   glyph_id ||= 0 # Handle invalid subtable entries
                   glyph_id = (glyph_id + id_deltas[index]) % 65536 if glyph_id != 0
-                else
-                  glyph_id = (code + id_deltas[index]) % 65536
                 end
                 glyph_id
               end

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -126,7 +126,6 @@ module HexaPDF
       # If +subset+ is true, the font is subset.
       def initialize(document, font, pdf_object: nil, subset: true)
         @wrapped_font = font
-        @missing_glyph_callable = document.config['font.on_missing_glyph']
 
         @subsetter = (subset ? HexaPDF::Font::TrueType::Subsetter.new(font) : nil)
 
@@ -165,12 +164,10 @@ module HexaPDF
       # Note: Although this method is public, it should normally not be used by application code!
       def glyph(id, str = nil)
         @id_to_glyph[id] ||=
-          begin
-            if id >= 0 && id < @wrapped_font[:maxp].num_glyphs
-              Glyph.new(@wrapped_font, id, str || (+'' << (@cmap.gid_to_code(id) || 0xFFFD)))
-            else
-              @missing_glyph_callable.call("\u{FFFD}", font_type, @wrapped_font)
-            end
+          if id >= 0 && id < @wrapped_font[:maxp].num_glyphs
+            Glyph.new(@wrapped_font, id, str || (+'' << (@cmap.gid_to_code(id) || 0xFFFD)))
+          else
+            @pdf_object.document.config['font.on_missing_glyph'].call("\u{FFFD}", self)
           end
       end
 
@@ -178,12 +175,10 @@ module HexaPDF
       def decode_utf8(str)
         str.codepoints.map! do |c|
           @codepoint_to_glyph[c] ||=
-            begin
-              if (gid = @cmap[c])
-                glyph(gid, +'' << c)
-              else
-                @missing_glyph_callable.call(+'' << c, font_type, @wrapped_font)
-              end
+            if (gid = @cmap[c])
+              glyph(gid, +'' << c)
+            else
+              @pdf_object.document.config['font.on_missing_glyph'].call(+'' << c, self)
             end
         end
       end
@@ -250,7 +245,7 @@ module HexaPDF
                                                  Supplement: 0},
                                  CIDToGIDMap: :Identity})
         dict = document.add({Type: :Font, Subtype: :Type0, BaseFont: cid_font[:BaseFont],
-                             Encoding: :"Identity-H", DescendantFonts: [cid_font]})
+                             Encoding: :'Identity-H', DescendantFonts: [cid_font]})
         dict.font_wrapper = self
 
         document.register_listener(:complete_objects) do

data/lib/hexapdf/font/type1/font.rb

@@ -89,19 +89,17 @@ module HexaPDF
         # Returns the built-in encoding of the font.
         def encoding
           @encoding ||=
-            begin
-              if @metrics.encoding_scheme == 'AdobeStandardEncoding'
-                Encoding.for_name(:StandardEncoding)
-              elsif font_name == 'ZapfDingbats' || font_name == 'Symbol'
-                Encoding.for_name((font_name + "Encoding").to_sym)
-              else
-                encoding = Encoding::Base.new
-                @metrics.character_metrics.each do |key, char_metric|
-                  next unless key.kind_of?(Integer) && key >= 0
-                  encoding.code_to_name[key] = char_metric.name
-                end
-                encoding
+            if @metrics.encoding_scheme == 'AdobeStandardEncoding'
+              Encoding.for_name(:StandardEncoding)
+            elsif font_name == 'ZapfDingbats' || font_name == 'Symbol'
+              Encoding.for_name("#{font_name}Encoding".to_sym)
+            else
+              encoding = Encoding::Base.new
+              @metrics.character_metrics.each do |key, char_metric|
+                next unless key.kind_of?(Integer) && key >= 0
+                encoding.code_to_name[key] = char_metric.name
               end
+              encoding
             end
         end
 

data/lib/hexapdf/font/type1_wrapper.rb

@@ -119,7 +119,6 @@ module HexaPDF
       def initialize(document, font, pdf_object: nil, custom_encoding: false)
         @wrapped_font = font
         @pdf_object = pdf_object || create_pdf_object(document)
-        @missing_glyph_callable = document.config['font.on_missing_glyph']
 
         if pdf_object
           @encoding = pdf_object.encoding
@@ -160,7 +159,7 @@ module HexaPDF
             if @wrapped_font.metrics.character_metrics.key?(name)
               Glyph.new(@wrapped_font, name, str)
             else
-              @missing_glyph_callable.call(str, font_type, @wrapped_font)
+              @pdf_object.document.config['font.on_missing_glyph'].call(str, self)
             end
           end
       end
@@ -212,24 +211,23 @@ module HexaPDF
 
       # Creates a PDF object representing the wrapped font for the given PDF document.
       def create_pdf_object(document)
-        fd = document.wrap({Type: :FontDescriptor,
-                            FontName: @wrapped_font.font_name.intern,
-                            FontWeight: @wrapped_font.weight_class,
-                            FontBBox: @wrapped_font.bounding_box,
-                            ItalicAngle: @wrapped_font.italic_angle || 0,
-                            Ascent: @wrapped_font.ascender || 0,
-                            Descent: @wrapped_font.descender || 0,
-                            CapHeight: @wrapped_font.cap_height,
-                            XHeight: @wrapped_font.x_height,
-                            StemH: @wrapped_font.dominant_horizontal_stem_width,
-                            StemV: @wrapped_font.dominant_vertical_stem_width || 0})
+        fd = document.add({Type: :FontDescriptor,
+                           FontName: @wrapped_font.font_name.intern,
+                           FontWeight: @wrapped_font.weight_class,
+                           FontBBox: @wrapped_font.bounding_box,
+                           ItalicAngle: @wrapped_font.italic_angle || 0,
+                           Ascent: @wrapped_font.ascender || 0,
+                           Descent: @wrapped_font.descender || 0,
+                           CapHeight: @wrapped_font.cap_height,
+                           XHeight: @wrapped_font.x_height,
+                           StemH: @wrapped_font.dominant_horizontal_stem_width,
+                           StemV: @wrapped_font.dominant_vertical_stem_width || 0})
         fd.flag(:fixed_pitch) if @wrapped_font.metrics.is_fixed_pitch
         fd.flag(@wrapped_font.metrics.character_set == 'Special' ? :symbolic : :nonsymbolic)
-        fd.must_be_indirect = true
 
-        dict = document.wrap({Type: :Font, Subtype: :Type1,
-                              BaseFont: @wrapped_font.font_name.intern,
-                              FontDescriptor: fd})
+        dict = document.add({Type: :Font, Subtype: :Type1,
+                             BaseFont: @wrapped_font.font_name.intern,
+                             FontDescriptor: fd})
         dict.font_wrapper = self
 
         document.register_listener(:complete_objects) do

data/lib/hexapdf/layout/box.rb

@@ -51,13 +51,16 @@ module HexaPDF
     # * If width or height is set to zero, they are determined automatically during layouting.
     class Box
 
-      # Creates a new Box object, using the provided block as drawing block (see ::new). Any
-      # additional keyword arguments are used for creating the box's Style object.
+      # Creates a new Box object, using the provided block as drawing block (see ::new).
       #
       # If +content_box+ is +true+, the width and height are taken to mean the content width and
       # height and the style's padding and border are removed from them appropriately.
-      def self.create(width: 0, height: 0, content_box: false, **style, &block)
-        style = Style.new(**style)
+      #
+      # The +style+ argument defines the Style object (see Style::create for details) for the box.
+      # Any additional keyword arguments have to be style properties and are applied to the style
+      # object.
+      def self.create(width: 0, height: 0, content_box: false, style: nil, **style_properties, &block)
+        style = Style.create(style).update(**style_properties)
         if content_box
           width += style.padding.left + style.padding.right +
             style.border.width.left + style.border.width.right
@@ -81,12 +84,12 @@ module HexaPDF
       # * Style#background_alpha
       # * Style#padding
       # * Style#border
-      # * Style#overlay_callback
-      # * Style#underlay_callback
+      # * Style#overlays
+      # * Style#underlays
       attr_reader :style
 
       # :call-seq:
-      #    Box.new(width: 0, height: 0, style: Style.new) {|canv, box| block} -> box
+      #    Box.new(width: 0, height: 0, style: nil) {|canv, box| block} -> box
       #
       # Creates a new Box object with the given width and height that uses the provided block when
       # it is asked to draw itself on a canvas (see #draw).
@@ -94,10 +97,10 @@ module HexaPDF
       # Since the final location of the box is not known beforehand, the drawing operations inside
       # the block should draw inside the rectangle (0, 0, content_width, content_height) - note that
       # the width and height of the box may not be known beforehand.
-      def initialize(width: 0, height: 0, style: Style.new, &block)
+      def initialize(width: 0, height: 0, style: nil, &block)
         @width = @initial_width = width
         @height = @initial_height = height
-        @style = (style.kind_of?(Style) ? style : Style.new(**style))
+        @style = Style.create(style)
         @draw_block = block
       end
 

data/lib/hexapdf/layout/column_box.rb

@@ -0,0 +1,168 @@
+# -*- 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-2022 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/layout/box'
+
+module HexaPDF
+  module Layout
+
+    # A ColumnBox arranges boxes in one or more columns.
+    #
+    # The number of columns as well as the size of the gap between the columns can be modified.
+    class ColumnBox < Box
+
+      # The child boxes of this ColumnBox.
+      attr_reader :children
+
+      # The number of columns.
+      # TODO: allow array with column widths later like [100, :*, :*]; same for gaps
+      attr_reader :columns
+
+      # The size of the gap between the columns.
+      attr_reader :gap
+
+      # Creates a new ColumnBox object for the given +children+ boxes.
+      def initialize(children = [], columns = 2, gap: 36, **kwargs)
+        super(**kwargs)
+        @children = children
+        @columns = columns
+        @gap = gap
+      end
+
+      # Fits the column box into the available space.
+      def fit(available_width, available_height, frame)
+        last_height_difference = 1_000_000
+        height = if style.position == :flow
+                   frame.height
+                 else
+                   (@initial_height > 0 ? @initial_height : available_height) - reserved_height
+                 end
+        while true
+          p '-'*100
+          @frames = []
+          if style.position == :flow
+            column_width = (frame.width - gap * (@columns - 1)).to_f / @columns
+            @columns.times do |col_nr|
+              left = (column_width + gap) * col_nr + frame.left
+              bottom = frame.bottom
+              rect = Geom2D::Polygon([left, bottom],
+                                     [left + column_width, bottom],
+                                     [left + column_width, bottom + height],
+                                     [left, bottom + height])
+              shape = Geom2D::Algorithms::PolygonOperation.run(frame.shape, rect, :intersection)
+              col_frame = Frame.new(left, bottom, column_width, height)
+              col_frame.shape = shape
+              @frames << col_frame
+            end
+            @frame_index = 0
+            @results = @children.map {|child_box| fit_box(child_box) }
+            @width = frame.width
+            @height = frame.height - @frames.min_by(&:y).y
+          else
+            width = (@initial_width > 0 ? @initial_width : available_width) - reserved_width
+            column_width = (width - gap * (@columns - 1)).to_f / @columns
+            @columns.times do |col_nr|
+              @frames << Frame.new((column_width + gap) * col_nr, 0, column_width, height)
+            end
+            @frame_index = 0
+            @results = @children.map {|child_box| fit_box(child_box) }
+            @width = width
+            @height = height - @frames.min_by(&:y).y
+          end
+          min_y, max_y = @frames.minmax_by(&:y).map(&:y)
+          p [height, @frames.map(&:y), last_height_difference, min_y, max_y]
+          # TOOD: @result.any?(&:empty?) only for the first run!!!! if the first run fails, we
+          # cannot balance the columns because there is too much content.
+          # TODO: another break condition is if the @results didn't change since the last run
+          p [:maybe_redo, min_y, max_y, height, last_height_difference]
+          p [@results.map {|arr| arr.all? {|r| r.status }}]
+          break if max_y != height && @results.all? {|arr| !arr.empty? && arr.all? {|r| r.success? }} &&
+            (@results.any?(&:empty?) ||
+             max_y - min_y >= last_height_difference ||
+             max_y - min_y < 0.5)
+          if max_y == 0 && min_y == 0
+            height += last_height_difference / 4.0
+          else
+            last_height_difference = max_y - min_y
+            height -= last_height_difference / 2.0
+          end
+        end
+        @results.all? {|res| res.length == 1 }
+      end
+
+      private
+
+      def fit_box(box)
+        cur_frame = @frames[@frame_index]
+        fit_results = []
+        while cur_frame
+          result = cur_frame.fit(box)
+          if result.success?
+            cur_frame.remove_area(result.mask)
+            fit_results << result
+            break
+          elsif cur_frame.full?
+            @frame_index += 1
+            break if @frame_index == @frames.length
+            cur_frame = @frames[@frame_index]
+          else
+            draw_box, box = cur_frame.split(result)
+            if draw_box
+              cur_frame.remove_area(result.mask)
+              fit_results << result
+            elsif !cur_frame.find_next_region
+              @frame_index += 1
+              break if @frame_index == @frames.length
+              cur_frame = @frames[@frame_index]
+            end
+          end
+        end
+        fit_results
+      end
+
+      # Draws the child boxes onto the canvas at position [x, y].
+      def draw_content(canvas, x, y)
+        x = y = 0 if style.position == :flow
+        @results.each do |result_boxes|
+          result_boxes.each do |result|
+            result.box.draw(canvas, x + result.x, y + result.y)
+          end
+        end
+      end
+
+    end
+
+  end
+end