hexapdf 0.45.0 → 0.47.0

data/lib/hexapdf/document/layout.rb

@@ -77,9 +77,9 @@ module HexaPDF
     #
     # One style property, Layout::Style#font, is handled specially:
     #
-    # * If no font is set on a style, the font "Times" is automatically set because otherwise there
-    #   would be problems with text drawing operations (font is the only style property that has no
-    #   valid default value).
+    # * If no font is set on a style, the default font specified via the configuration option
+    #   'font.default' is automatically set because otherwise there would be problems with text
+    #   drawing operations (font is the only style property that has no valid default value).
     #
     # * Standard style objects only allow font wrapper objects to be set via the Layout::Style#font
     #   method. This class makes usage easier by allowing strings or an array [name, options_hash]
@@ -151,7 +151,9 @@ module HexaPDF
         # :nodoc:
         def method_missing(name, *args, **kwargs, &block)
           if @layout.box_creation_method?(name)
-            @children << @layout.send(name, *args, **kwargs, &block)
+            box = @layout.send(name, *args, **kwargs, &block)
+            @children << box
+            box
           else
             super
           end
@@ -354,6 +356,7 @@ module HexaPDF
                                       width: width, height: height, properties: properties,
                                       style: box_style)
       end
+      alias text text_box
 
       # Creates a HexaPDF::Layout::TextBox like #text_box but allows parts of the text to be
       # formatted differently.
@@ -456,6 +459,7 @@ module HexaPDF
         box_class_for_name(:text).new(items: data, width: width, height: height,
                                       properties: properties, style: box_style)
       end
+      alias formatted_text formatted_text_box
 
       # Creates a HexaPDF::Layout::ImageBox for the given image.
       #
@@ -477,6 +481,7 @@ module HexaPDF
         box_class_for_name(:image).new(image: image, width: width, height: height,
                                        properties: properties, style: style)
       end
+      alias image image_box
 
       # This helper class is used by Layout#table_box to allow specifying the keyword arguments used
       # when converting cell data to box instances.
@@ -495,8 +500,25 @@ module HexaPDF
           @number_of_columns = number_of_columns
         end
 
-        # Stores the keyword arguments in +args+ for the given 0-based rows and columns which can
-        # either be a single number or a range of numbers.
+        # Stores the hash +args+ containing styling properties for the cells specified via the given
+        # 0-based rows and columns.
+        #
+        # Rows and columns can either be single numbers, ranges of numbers or stepped ranges (i.e.
+        # Enumerator::ArithmeticSequence instances).
+        #
+        # Examples:
+        #
+        #   # Gray background for all cells
+        #   args[] = {cell: {background_color: "gray"}}
+        #
+        #   # Cell at (2, 3) gets a bigger font size
+        #   args[2, 3] = {font_size: 50}
+        #
+        #   # First column of every row has bold font
+        #   args[0..-1, 0] = {font: 'Helvetica bold'}
+        #
+        #   # Every second row has a blue background
+        #   args[(0..-1).step(2)] = {cell: {background_color: "blue"}}
         def []=(rows = 0..-1, cols = 0..-1, args)
           rows = adjust_range(rows.kind_of?(Integer) ? rows..rows : rows, @number_of_rows)
           cols = adjust_range(cols.kind_of?(Integer) ? cols..cols : cols, @number_of_columns)
@@ -509,7 +531,7 @@ module HexaPDF
         # is merged.
         def retrieve_arguments_for(row, col)
           @argument_infos.each_with_object({}) do |arg_info, result|
-            next unless arg_info.rows.cover?(row) && arg_info.cols.cover?(col)
+            next unless arg_info.rows.include?(row) && arg_info.cols.include?(col)
             if arg_info.args[:cell]
               arg_info.args[:cell] = (result[:cell] || {}).merge(arg_info.args[:cell])
             end
@@ -522,7 +544,8 @@ module HexaPDF
         # Adjusts the +range+ so that both the begin and the end of the range are zero or positive
         # integers smaller than +max+.
         def adjust_range(range, max)
-          (range.begin % max)..(range.end % max)
+          r = (range.begin % max)..(range.end % max)
+          range.kind_of?(Range) ? r : r.step(range.step)
         end
 
       end
@@ -540,7 +563,8 @@ module HexaPDF
       # Additional arguments for the #text_box invocations can be specified using the optional block
       # that yields a CellArgumentCollector instance. This allows customization of the text boxes.
       # By specifying the special key +:cell+ it is also possible to assign style properties to the
-      # cells themselves.
+      # cells themselves, irrespective of the type of content of the cells. See
+      # CellArgumentCollector#[]= for details.
       #
       # See HexaPDF::Layout::TableBox::new for details on +column_widths+, +header+, +footer+, and
       # +cell_style+.
@@ -586,6 +610,7 @@ module HexaPDF
                                        footer: footer, cell_style: cell_style, width: width,
                                        height: height, properties: properties, style: style)
       end
+      alias table table_box
 
       LOREM_IPSUM = [ # :nodoc:
         "Lorem ipsum dolor sit amet, con\u{00AD}sectetur adipis\u{00AD}cing elit, sed " \
@@ -605,22 +630,13 @@ module HexaPDF
       def lorem_ipsum_box(sentences: 4, count: 1, **text_box_properties)
         text_box(([LOREM_IPSUM[0, sentences].join(" ")] * count).join("\n\n"), **text_box_properties)
       end
+      alias lorem_ipsum lorem_ipsum_box
 
-      BOX_METHOD_NAMES = [:text, :formatted_text, :image, :table, :lorem_ipsum] #:nodoc:
-
-      # Allows creating boxes using more convenient method names:
-      #
-      # * #text for #text_box
-      # * #formatted_text for #formatted_text_box
-      # * #image for #image_box
-      # * #lorem_ipsum for #lorem_ipsum_box
-      # * The name of a pre-defined box class like #column will invoke #box appropriately. Same if
-      #   used with a '_box' suffix.
+      # Allows creating boxes using more convenient method names: The name of a pre-defined box
+      # class like #column will invoke #box appropriately. Same if used with a '_box' suffix.
       def method_missing(name, *args, **kwargs, &block)
         name_without_box = name.to_s.sub(/_box$/, '').intern
-        if BOX_METHOD_NAMES.include?(name)
-          send("#{name}_box", *args, **kwargs, &block)
-        elsif @document.config['layout.boxes.map'].key?(name_without_box)
+        if @document.config['layout.boxes.map'].key?(name_without_box)
           box(name_without_box, *args, **kwargs, &block)
         else
           super
@@ -632,6 +648,8 @@ module HexaPDF
         box_creation_method?(name) || super
       end
 
+      BOX_METHOD_NAMES = [:text, :formatted_text, :image, :table, :lorem_ipsum] #:nodoc:
+
       # :nodoc:
       def box_creation_method?(name)
         name = name.to_s.sub(/_box$/, '').intern
@@ -648,8 +666,8 @@ module HexaPDF
         end
       end
 
-      # Retrieves the appropriate HexaPDF::Layout::Style object based on the +style+ and +properties+
-      # arguments.
+      # Retrieves the appropriate HexaPDF::Layout::Style object based on the +style+ and
+      # +properties+ arguments.
       #
       # The +style+ argument specifies the style to retrieve. It can either be a registered style
       # name (see #style), a hash with style properties or +nil+. In the latter case the registered
@@ -658,15 +676,18 @@ module HexaPDF
       # If the +properties+ hash is not empty, the retrieved style is duplicated and the properties
       # hash is applied to it.
       #
-      # Finally, a default font (the one from the :base style or otherwise 'Times') is set if
-      # necessary to ensure that the style object works in all cases.
+      # Finally, a default font (the one from the :base style or otherwise the one set using the
+      # configuration option 'font.default') is set if necessary to ensure that the style object
+      # works in all cases.
       def retrieve_style(style, properties = nil)
         if style.kind_of?(Symbol) && !@styles.key?(style)
           raise HexaPDF::Error, "Style #{style} not defined"
         end
         style = HexaPDF::Layout::Style.create(@styles[style] || style || @styles[:base])
         style = style.dup.update(**properties) unless properties.nil? || properties.empty?
-        style.font(@styles[:base].font? && @styles[:base].font || 'Times') unless style.font?
+        unless style.font?
+          style.font(@styles[:base].font? && @styles[:base].font || @document.config['font.default'])
+        end
         unless style.font.respond_to?(:pdf_object)
           name, options = *style.font
           style.font(@document.fonts.add(name, **(options || {})))

data/lib/hexapdf/document.rb

@@ -278,8 +278,9 @@ module HexaPDF
     # If the same argument is provided in multiple invocations, the import is done only once and
     # the previously imported object is returned.
     #
-    # Note: If you first create a PDF document from scratch and then want to import objects from it
-    # into another PDF document, you need to run the following on the source document:
+    # Note: If you first create a PDF document from scratch or if you modify an existing document,
+    # and then want to import objects from it into another PDF document, you need to run the
+    # following on the source document:
     #
     #   doc.dispatch_message(:complete_objects)
     #   doc.validate
@@ -701,6 +702,27 @@ module HexaPDF
       result
     end
 
+    # Returns an in-memory copy of the PDF document.
+    #
+    # In the context of this method this means that the returned PDF document contains the same PDF
+    # object tree as this document, starting at the trailer. A possibly set encryption is not
+    # transferred to the returned document.
+    #
+    # Note: If this PDF document was created from scratch or if it is an existing document that was
+    # modified, the following commands need to be run on this document beforehand:
+    #
+    #   doc.dispatch_message(:complete_objects)
+    #   doc.validate
+    #
+    # This ensures that all the necessary PDF structures set-up correctly.
+    def duplicate
+      dest = HexaPDF::Document.new
+      dupped_trailer = HexaPDF::Importer.copy(dest, trailer, allow_all: true)
+      dest.revisions.current.trailer.value.replace(dupped_trailer.value)
+      dest.trailer.delete(:Encrypt)
+      dest
+    end
+
     # :call-seq:
     #   doc.write(filename, incremental: false, validate: true, update_fields: true, optimize: false)
     #   doc.write(io, incremental: false, validate: true, update_fields: true, optimize: false)

data/lib/hexapdf/encryption/standard_security_handler.rb

@@ -106,6 +106,10 @@ module HexaPDF
     # password is supplied. To open such an encrypted PDF file, the +decryption_opts+ provided to
     # HexaPDF::Document.new needs to contain a :password key with the password.
     #
+    # **Note**: While HexaPDF supports reading files encrypted with revision 5, it doesn't support
+    # writing such files. This is no problem in practice since revision 5 was an inofficial Adobe
+    # extension to PDF 1.7 and revision 6 specified in PDF 2.0 is practically the same.
+    #
     # See: PDF2.0 s7.6.4
     class StandardSecurityHandler < SecurityHandler
 
@@ -340,13 +344,13 @@ module HexaPDF
       # Uses the given password (or the default password if none given) to retrieve the encryption
       # key.
       #
-      # If the optional +check_permissions+ argument is +true+, the permissions for files
-      # encrypted with revision 6 are checked. Otherwise, permission changes are ignored.
+      # If the optional +check_permissions+ argument is +true+, the permissions for files encrypted
+      # with revision 5 or 6 are checked. Otherwise, permission changes are ignored.
       def prepare_decryption(password: '', check_permissions: true)
         if dict[:Filter] != :Standard
           raise(HexaPDF::UnsupportedEncryptionError,
                 "Invalid /Filter value #{dict[:Filter]} for standard security handler")
-        elsif ![2, 3, 4, 6].include?(dict[:R])
+        elsif ![2, 3, 4, 5, 6].include?(dict[:R])
           raise(HexaPDF::UnsupportedEncryptionError,
                 "Invalid /R value #{dict[:R]} for standard security handler")
         elsif dict[:R] <= 4 && !document.trailer[:ID].kind_of?(PDFArray)
@@ -369,7 +373,7 @@ module HexaPDF
           raise HexaPDF::EncryptionError, "Invalid password specified"
         end
 
-        check_perms_field(encryption_key) if check_permissions && dict[:R] == 6
+        check_perms_field(encryption_key) if check_permissions && dict[:R] >= 5
 
         encryption_key
       end
@@ -396,8 +400,8 @@ module HexaPDF
       # For revisions <= 4 this is the *only* way for generating the encryption key needed to
       # encrypt or decrypt a file.
       #
-      # For revision 6 the file encryption key is a string of random bytes that has been encrypted
-      # with the user password. If the password is the owner password,
+      # For revision 5 and 6 the file encryption key is a string of random bytes that has been
+      # encrypted with the user password. If the password is the owner password,
       # #compute_owner_encryption_key has to be used instead.
       #
       # See: PDF2.0 s7.6.4.3.2 (algorithm 2), PDF2.0 s7.6.4.3.3 (algorithm 2.A (a)-(b),(e))
@@ -416,7 +420,7 @@ module HexaPDF
           end
 
           data[0, n]
-        elsif dict[:R] == 6
+        elsif dict[:R] <= 6
           key = compute_hash(password, dict[:U][40, 8])
           aes_algorithm.new(key, "\0" * 16, :decrypt).process(dict[:UE])
         end
@@ -427,15 +431,15 @@ module HexaPDF
       # For revisions <= 4 this is done by first retrieving the user password through the use of
       # the owner password and then using the #compute_user_encryption_key method.
       #
-      # For revision 6 the file encryption key is a string of random bytes that has been encrypted
-      # with the owner password. If the password is the user password, #compute_user_encryption_key
-      # has to be used.
+      # For revisions 5 and 6 the file encryption key is a string of random bytes that has been
+      # encrypted with the owner password. If the password is the user password,
+      # #compute_user_encryption_key has to be used.
       #
       # See: PDF2.0 s7.6.4.3.2 (algorithm 2.A (a)-(d))
       def compute_owner_encryption_key(password)
         if dict[:R] <= 4
           compute_user_encryption_key(user_password_from_owner_password(password))
-        elsif dict[:R] == 6
+        elsif dict[:R] <= 6
           key = compute_hash(password, dict[:O][40, 8], dict[:U])
           aes_algorithm.new(key, "\0" * 16, :decrypt).process(dict[:OE])
         end
@@ -447,7 +451,7 @@ module HexaPDF
       # the owner password. For revision 6 the /O value is a hash computed from the password and
       # the /U value with added validation and key salts.
       #
-      # *Attention*: If revision 6 is used, the /U value has to be computed and set before this
+      # *Attention*: If revision 5 or 6 is used, the /U value has to be computed and set before this
       # method is used, otherwise the return value is incorrect!
       #
       # See: PDF2.0 s7.6.4.4.2 (algorithm 3), PDF2.0 s7.6.4.4.8 (algorithm 9 (a))
@@ -465,14 +469,14 @@ module HexaPDF
           end
 
           data
-        elsif dict[:R] == 6
+        elsif dict[:R] <= 6
           validation_salt = random_bytes(8)
           key_salt = random_bytes(8)
           compute_hash(owner_password, validation_salt, dict[:U]) << validation_salt << key_salt
         end
       end
 
-      # Computes the encryption dictionary's /OE (owner encryption key) value (for revision 6
+      # Computes the encryption dictionary's /OE (owner encryption key) value (for revisions 5 and 6
       # only).
       #
       # Short explanation: Encrypts the file encryption key with a key based on the password and
@@ -487,7 +491,7 @@ module HexaPDF
       # Computes the encryption dictionary's /U (user password) value.
       #
       # Short explanation: For revisions <= 4, the password padding string is encrypted with a key
-      # based on the user password. For revision 6 the /U value is a hash computed from the
+      # based on the user password. For revisions 5 and 6 the /U value is a hash computed from the
       # password with added validation and key salts.
       #
       # See: PDF2.0 s7.6.4.4.3 (algorithm 4 for R=2), PDF s7.6.4.4.4 (algorithm 5 for R=3 and R=4)
@@ -502,14 +506,14 @@ module HexaPDF
           data = arc4_algorithm.encrypt(key, data)
           19.times {|i| data = arc4_algorithm.encrypt(xor_key(key, i + 1), data) }
           data << "hexapdfhexapdfhe"
-        elsif dict[:R] == 6
+        elsif dict[:R] <= 6
           validation_salt = random_bytes(8)
           key_salt = random_bytes(8)
           compute_hash(password, validation_salt) << validation_salt << key_salt
         end
       end
 
-      # Computes the encryption dictionary's /UE (user encryption key) value (for revision 6
+      # Computes the encryption dictionary's /UE (user encryption key) value (for revision 5 and 6
       # only).
       #
       # Short explanation: Encrypts the file encryption key with a key based on the password and
@@ -521,7 +525,8 @@ module HexaPDF
         aes_algorithm.new(key, "\0" * 16, :encrypt).process(file_encryption_key)
       end
 
-      # Computes the encryption dictionary's /Perms (permissions) value (for revision 6 only).
+      # Computes the encryption dictionary's /Perms (permissions) value (for revisions 5 and 6
+      # only).
       #
       # Uses /P and /EncryptMetadata values, so these have to be set beforehand.
       #
@@ -543,7 +548,7 @@ module HexaPDF
           compute_u_field(password) == dict[:U]
         elsif dict[:R] <= 4
           compute_u_field(password)[0, 16] == dict[:U][0, 16]
-        elsif dict[:R] == 6
+        elsif dict[:R] <= 6
           compute_hash(password, dict[:U][32, 8]) == dict[:U][0, 32]
         end
       end
@@ -554,14 +559,14 @@ module HexaPDF
       def owner_password_valid?(password)
         if dict[:R] <= 4
           user_password_valid?(user_password_from_owner_password(password))
-        elsif dict[:R] == 6
+        elsif dict[:R] <= 6
           compute_hash(password, dict[:O][32, 8], dict[:U]) == dict[:O][0, 32]
         end
       end
 
       # Checks if the decrypted /Perms entry matches the /P and /EncryptMetadata entries.
       #
-      # This method can only be used for revision 6.
+      # This method can only be used for revisions 5 and 6.
       #
       # See: PDF2.0 s7.6.4.4.12 (algorithm 13)
       def check_perms_field(encryption_key)
@@ -596,17 +601,18 @@ module HexaPDF
       end
 
       # Computes a hash that is used extensively for all operations in security handlers of
-      # revision 6.
+      # revision 5 and 6.
       #
       # Note: The original input (as defined by the spec) is calculated as
       # "#{password}#{salt}#{user_key}" where +user_key+ has to be empty when doing operations
       # with the user password.
       #
-      # See: PDF2.0 s7.6.4.3.4 (algorithm 2.B)
+      # See: PDF2.0 s7.6.4.3.4 (algorithm 2.B) and ADB Extension Level 3 s3.5.2
       def compute_hash(password, salt, user_key = '')
         k = Digest::SHA256.digest("#{password}#{salt}#{user_key}")
-        e = ''
+        return k if dict[:R] == 5
 
+        e = ''
         i = 0
         while i < 64 || e.getbyte(-1) > i - 32
           k1 = "#{password}#{k}#{user_key}" * 64
@@ -627,7 +633,7 @@ module HexaPDF
       # * For revisions <= 4, the password is converted into ISO-8859-1 encoding, padded with
       #   PASSWORD_PADDING and truncated to a maximum of 32 bytes.
       #
-      # * For revision 6 the password is converted into UTF-8 encoding that is normalized
+      # * For revision 5 and 6 the password is converted into UTF-8 encoding that is normalized
       #   according to the PDF2.0 specification.
       #
       # See: PDF2.0 s7.6.4.3.2 (algorithm 2 step a)),
@@ -636,7 +642,7 @@ module HexaPDF
         if dict[:R] <= 4
           password.to_s[0, 32].encode(Encoding::ISO_8859_1).force_encoding(Encoding::BINARY).
             ljust(32, PASSWORD_PADDING)
-        elsif dict[:R] == 6
+        elsif dict[:R] <= 6
           password.to_s.encode(Encoding::UTF_8).force_encoding(Encoding::BINARY)[0, 127]
         end
       rescue Encoding::UndefinedConversionError => e

data/lib/hexapdf/importer.rb

@@ -71,14 +71,18 @@ module HexaPDF
     # Imports the given +object+ (belonging to the +source+ document) by completely copying it and
     # all referenced objects into the +destination+ object.
     #
+    # If the +allow_all+ argument is set to +true+, then the usually omitted catalog and page tree
+    # node objects (see the class description for details) are also copied which allows one to make
+    # an in-memory duplicate of a HexaPDF::Document object.
+    #
     # Specifying +source+ is optionial if it can be determined through +object+.
     #
     # After the operation is finished, all state is discarded. This means that another call to this
     # method for the same object will yield a new - and different - object. This is in contrast to
     # using ::for together with #import which remembers and returns already imported objects (which
     # is generally what one wants).
-    def self.copy(destination, object, source: nil)
-      new(NullableWeakRef.new(destination)).import(object, source: source)
+    def self.copy(destination, object, allow_all: false, source: nil)
+      new(NullableWeakRef.new(destination), allow_all: allow_all).import(object, source: source)
     end
 
     private_class_method :new
@@ -86,9 +90,10 @@ module HexaPDF
     attr_reader :destination #:nodoc:
 
     # Initializes a new importer that can import objects to the +destination+ document.
-    def initialize(destination)
+    def initialize(destination, allow_all: false)
       @destination = destination
       @mapper = {}
+      @allow_all = allow_all
     end
 
     SourceWrapper = Struct.new(:source) #:nodoc:
@@ -136,7 +141,7 @@ module HexaPDF
         internal_import(wrapper.source.object(object), wrapper)
       when HexaPDF::Object
         wrapper.source ||= object.document
-        if object.type == :Catalog || object.type == :Pages
+        if object.null? || (!@allow_all && (object.type == :Catalog || object.type == :Pages))
           @mapper[object.data] = nil
         elsif (mapped_object = @mapper[object.data]&.__getobj__) && !mapped_object.null?
           mapped_object
@@ -149,7 +154,12 @@ module HexaPDF
           obj.data.gen = 0
           @destination.add(obj) if object.indirect?
 
-          obj.data.stream = obj.data.stream.dup if obj.data.stream.kind_of?(String)
+          stream = obj.data.stream
+          if stream.kind_of?(String)
+            obj.data.stream = stream.dup
+          elsif stream&.source.kind_of?(FiberDoubleForString)
+            obj.data.stream = stream.fiber.resume.dup
+          end
           obj.data.value = duplicate(obj.data.value, wrapper)
           obj.data.value.update(duplicate(object.copy_inherited_values, wrapper)) if object.type == :Page
           obj

data/lib/hexapdf/layout/box.rb

@@ -69,6 +69,10 @@ module HexaPDF
     #     If the subclass supports the value :flow of the 'position' style property, this method
     #     needs to be overridden to return +true+.
     #
+    #     Additionally, if a box object uses flow positioning, #fit_result.x should be set to the
+    #     correct value since Frame#fit can't determine this and uses Frame#left in the absence of a
+    #     set value.
+    #
     # #empty?::
     #     This method should return +true+ if the subclass won't draw anything when #draw is called.
     #
@@ -89,28 +93,13 @@ module HexaPDF
     #     This method draws the box specific content and is called from #draw which already handles
     #     things like drawing the border and background. So #draw should usually not be overridden.
     #
-    # This base class provides various private helper methods for use in the above methods:
-    #
-    # +reserved_width+, +reserved_height+::
-    #     Returns the width respectively the height of the reserved space inside the box that is
-    #     used for the border and padding.
-    #
-    # +reserved_width_left+, +reserved_width_right+, +reserved_height_top+,
-    # +reserved_height_bottom+::
-    #     Returns the reserved space inside the box at the specified edge (left, right, top,
-    #     bottom).
-    #
-    # +update_content_width+, +update_content_height+::
-    #     Takes a block that should return the content width respectively height and sets the box's
-    #     width respectively height accordingly.
-    #
-    # +create_split_box+::
-    #     Creates a new box based on this one and resets the internal data back to their original
-    #     values.
+    # This base class also provides various protected helper methods for use in the above methods:
     #
-    #     The keyword argument +split_box_value+ (defaults to +true+) is used to set the
-    #     +@split_box+ variable to make the new box aware that it is a split box. This can be set to
-    #     any other truthy value to convey more meaning.
+    # * #reserved_width, #reserved_height
+    # * #reserved_width_left, #reserved_width_right, #reserved_height_top,
+    #   #reserved_height_bottom
+    # * #update_content_width, #update_content_height
+    # * #create_split_box
     class Box
 
       include HexaPDF::Utils
@@ -352,7 +341,9 @@ module HexaPDF
                     available_height
                   end
         return @fit_result if !position_flow && (float_compare(@width, available_width) > 0 ||
-                                                 float_compare(@height, available_height) > 0)
+                                                 float_compare(@height, available_height) > 0 ||
+                                                 @width - reserved_width < 0 ||
+                                                 @height - reserved_height < 0)
 
         fit_content(available_width, available_height, frame)
 
@@ -432,7 +423,7 @@ module HexaPDF
           (style.overlays? && !style.overlays.none?))
       end
 
-      private
+      protected
 
       # Returns the width that is reserved by the padding and border style properties.
       def reserved_width
@@ -480,12 +471,18 @@ module HexaPDF
         result
       end
 
+      # :call-seq:
+      #   update_content_width { block }
+      #
       # Updates the width of the box using the content width returned by the block.
       def update_content_width
         return if @initial_width > 0
         @width = yield + reserved_width
       end
 
+      # :call-seq:
+      #   update_content_height { block }
+      #
       # Updates the height of the box using the content height returned by the block.
       def update_content_height
         return if @initial_height > 0
@@ -494,13 +491,12 @@ module HexaPDF
 
       # Fits the content of the box and returns whether fitting was successful.
       #
-      # This is just a stub implementation that sets the #fit_result status to success if the
-      # content rectangle is not degenerate. Subclasses should override it to provide the box
-      # specific behaviour.
+      # This is just a stub implementation that sets the #fit_result status to success. Subclasses
+      # should override it to provide the box specific behaviour.
       #
       # See #fit for details.
       def fit_content(_available_width, _available_height, _frame)
-        fit_result.success! if content_width > 0 && content_height > 0
+        fit_result.success!
       end
 
       # Splits the content of the box.
@@ -525,7 +521,8 @@ module HexaPDF
         end
       end
 
-      # Creates a new box based on this one and resets the data back to their original values.
+      # Creates a new box based on this one and resets the internal data back to their original
+      # values.
       #
       # The variable +@split_box+ is set to +split_box_value+ (defaults to +true+) to make the new
       # box aware that it is a split box. If needed, subclasses can set the variable to other truthy

data/lib/hexapdf/layout/frame.rb

@@ -252,7 +252,7 @@ module HexaPDF
                   end
                 end
           when :flow
-            x = 0
+            x = fit_result.x || left
             y = @y - height
           else
             raise HexaPDF::Error, "Invalid value '#{position}' for style property position"

data/lib/hexapdf/layout/inline_box.rb

@@ -43,14 +43,12 @@ module HexaPDF
     # An InlineBox wraps a regular Box so that it can be used as an item for a Line. This enables
     # inline graphics.
     #
-    # Complete box auto-sizing is not possible since the available space cannot be determined
-    # beforehand! This means the box *must* have at least its width set. The height may either also
-    # be set or determined during fitting.
+    # When an inline box gets placed on a line, the method #fit_wrapped_box is called to fit the
+    # wrapped box. This allows the wrapped box to correctly set its width and height which are
+    # needed by the TextLayouter algorithm.
     #
-    # Fitting of the wrapped box via #fit_wrapped_box needs to be done before accessing any other
-    # method that uses the wrapped box. For fitting, a frame is used that has the width of the
-    # wrapped box and its height, or if not set, a practically infinite height. In the latter case
-    # the height *must* be set during fitting.
+    # Note: It is *mandatory* that the wrapped box sets its width and height without relying on the
+    # dimensions of the frame's current region.
     class InlineBox
 
       # Creates an InlineBox that wraps a basic Box. All arguments (except +valign+) and the block
@@ -74,7 +72,6 @@ module HexaPDF
       # The +valign+ argument can be used to specify the vertical alignment of the box relative to
       # other items in the Line.
       def initialize(box, valign: :baseline)
-        raise HexaPDF::Error, "Width of box not set" if box.width == 0
         @box = box
         @valign = valign
       end
@@ -102,8 +99,7 @@ module HexaPDF
       # Draws the wrapped box. If the box has margins specified, the x and y offsets are correctly
       # adjusted.
       def draw(canvas, x, y)
-        canvas.translate(x - @fit_result.x + box.style.margin.left,
-                         y - @fit_result.y + box.style.margin.bottom) { @fit_result.draw(canvas) }
+        @fit_result.draw(canvas, dx: x, dy: y)
       end
 
       # The minimum x-coordinate which is always 0.
@@ -129,19 +125,17 @@ module HexaPDF
       # Fits the wrapped box.
       #
       # If the +frame+ argument is +nil+, a custom frame is created. Otherwise the given +frame+ is
-      # used for the fitting operation.
-      def fit_wrapped_box(frame)
-        frame = if frame
-                  frame.child_frame(0, 0, box.width, box.height == 0 ? 100_000 : box.height)
-                else
-                  Frame.new(0, 0, box.width, box.height == 0 ? 100_000 : box.height)
-                end
-        @fit_result = frame.fit(box)
-        if !@fit_result.success?
-          raise HexaPDF::Error, "Box for inline use could not be fit"
-        elsif box.height > 99_000
-          raise HexaPDF::Error, "Box for inline use has no valid height set after fitting"
-        end
+      # used for creating an appropriate child frame for the fitting operation.
+      #
+      # After this operation the caller is responsible for checking the actual width and height of
+      # the inline box and whether it really fits.
+      def fit_wrapped_box(frame = nil)
+        @fit_result = box.fit(100_000, 100_000, frame || Frame.new(0, 0, 100_000, 100_000))
+        margin = box.style.margin if box.style.margin?
+        @fit_result.x = margin&.left.to_i
+        @fit_result.y = margin&.bottom.to_i
+        @fit_result.mask = Geom2D::Rectangle(0, 0, @fit_result.x + box.width + margin&.right.to_i,
+                                             @fit_result.y + box.height + margin&.top.to_i)
       end
 
     end