hexapdf 0.35.1 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a7769176f4b753c876ecfb95a6cd2a954249388a7da9e308fbd8c25ba071c9b
-  data.tar.gz: f39b081ab1408fd08a3dff88f8aa3417283e98478b3e9fad60a692afb16e92c1
+  metadata.gz: b7cec7494ffe5e4f8031e5a05f2a31da13741879ff138513f737048880702389
+  data.tar.gz: 238a71920dcd9bde03497a22f0583bf72f11d358176f28217214f86ca835764d
 SHA512:
-  metadata.gz: 21fcdbd57cdcf436edd1de50f0268d05573b92b70edd1eafeb00af0414eed3cbaa8f107ac1310419a29a113dc5a33ec991fa49a4fa0b47edea1bd2eb7afb0768
-  data.tar.gz: 0c6732024ebd325a4216fe8e4a2fdc69d51365b873ec53c926a9a1e575730cdb6d5f45eea5cd211c1cb2a21afd16cb75f3a1782411a2971eed7afe2f61708dfd
+  metadata.gz: 7850251dba07dbae11c280bc87852c91aa72e166da7983c4b4a1508a4c76d99306eaacbc108dad8f0ba54246a2fe6648714cd8bfd5f6d9bddeb0ec67abab9867
+  data.tar.gz: dace9a43ef57a0d27d33218ef4dc6503a961edfc2c96c04c16ebeb0d8675e09373c21908d159c992c4d2125499bdd1818acdf1150c86106e23888552210f4fc8

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 0.36.0 - 2024-01-20
+
+### Added
+
+* [HexaPDF::Layout::ContainerBox] for grouping child boxes together
+
+### Changed
+
+* [HexaPDF::Layout::Frame::FitResult#draw] to allow drawing at an offset
+* [HexaPDF::Layout::Box#fit] to delegate the actual content fitting to the
+  `#fit_content` method
+* [HexaPDF::Document::Layout#box] to allow using the block as drawing block for
+  the base box class
+
+### Fixed
+
+* [HexaPDF::Type::FontSimple#to_utf8] to work in case the font's encoding cannot
+  be retrieved
+
+
 ## 0.35.1 - 2024-01-11
 
 ### Added

data/lib/hexapdf/configuration.rb

@@ -545,6 +545,7 @@ module HexaPDF
                         column: 'HexaPDF::Layout::ColumnBox',
                         list: 'HexaPDF::Layout::ListBox',
                         table: 'HexaPDF::Layout::TableBox',
+                        container: 'HexaPDF::Layout::ContainerBox',
                       },
                       'page.default_media_box' => :A4,
                       'page.default_media_orientation' => :portrait,

data/lib/hexapdf/document/layout.rb

@@ -238,10 +238,12 @@ module HexaPDF
       #
       # The +name+ argument refers to the registered name of the box class that is looked up in the
       # 'layout.boxes.map' configuration option. The +box_options+ are passed as-is to the
-      # initialization method of that box class
+      # initialization method of that box class.
       #
       # If a block is provided, a ChildrenCollector is yielded and the collected children are passed
-      # to the box initialization method via the :children keyword argument.
+      # to the box initialization method via the :children keyword argument. There is one exception
+      # to this rule in case +name+ is +base+: The provided block is passed to the initialization
+      # method of the base box class to function as drawing method.
       #
       # See #text_box for details on +width+, +height+ and +style+ (note that there is no
       # +style_properties+ argument).
@@ -252,12 +254,19 @@ module HexaPDF
       #   layout.box(:column) do |column|            # column box with one child
       #     column.lorem_ipsum
       #   end
-      def box(name, width: 0, height: 0, style: nil, **box_options, &block)
-        if block_given? && !box_options.key?(:children)
-          box_options[:children] = ChildrenCollector.collect(self, &block)
+      #   layout.box(width: 100) do |canvas, box|
+      #     canvas.line(0, 0, box.content_width, box.content_height).stroke
+      #   end
+      def box(name = :base, width: 0, height: 0, style: nil, **box_options, &block)
+        if block_given?
+          if name == :base
+            box_block = block
+          elsif !box_options.key?(:children)
+            box_options[:children] = ChildrenCollector.collect(self, &block)
+          end
         end
         box_class_for_name(name).new(width: width, height: height,
-                                     style: retrieve_style(style), **box_options)
+                                     style: retrieve_style(style), **box_options, &box_block)
       end
 
       # Creates an array of HexaPDF::Layout::TextFragment objects for the given +text+.

data/lib/hexapdf/layout/box.rb

@@ -60,28 +60,59 @@ module HexaPDF
     # instantiated from the common convenience method HexaPDF::Document::Layout#box. To use this
     # facility subclasses need to be registered with the configuration option 'layout.boxes.map'.
     #
-    # The methods #fit, #supports_position_flow?, #split or #split_content, #empty?, and #draw or
-    # #draw_content need to be customized according to the subclass's use case.
-    #
-    # #fit:: This method should return +true+ if fitting was successful. Additionally, the
-    #        @fit_successful instance variable needs to be set to the fit result as it is used in
-    #        #split.
+    # The methods #supports_position_flow?, #empty?, #fit or #fit_content, #split or #split_content,
+    # and #draw or #draw_content need to be customized according to the subclass's use case (also
+    # see the documentation of the methods besides the informatione below):
     #
     # #supports_position_flow?::
-    #        If the subclass supports the value :flow of the 'position' style property, this method
-    #        needs to be overridden to return +true+.
+    #     If the subclass supports the value :flow of the 'position' style property, this method
+    #     needs to be overridden to return +true+.
+    #
+    # #empty?::
+    #     This method should return +true+ if the subclass won't draw anything when #draw is called.
+    #
+    # #fit::
+    #     This method should return +true+ if fitting was successful. Additionally, the
+    #     @fit_successful instance variable needs to be set to the fit result as it is used in
+    #     #split.
+    #
+    #     The default implementation provides code common to most use-cases and delegates the
+    #     specifics to the #fit_content method which needs to return +true+ if fitting was
+    #     successful.
+    #
+    # #split::
+    #     This method splits the content so that the current region is used as good as possible. The
+    #     default implementation should be fine for most use-cases, so only #split_content needs to
+    #     be implemented. The method #create_split_box should be used for getting a basic cloned
+    #     box.
+    #
+    # #draw::
+    #     This method draws the content and the default implementation already handles things like
+    #     drawing the border and background. So it should not be overridden. The box specific
+    #     drawing commands should be implemented in the #draw_content method.
+    #
+    # 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).
     #
-    # #split:: This method splits the content so that the current region is used as good as
-    #          possible. The default implementation should be fine for most use-cases, so only
-    #          #split_content needs to be implemented. The method #create_split_box should be used
-    #          for getting a basic cloned box.
+    # +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.
     #
-    # #empty?:: This method should return +true+ if the subclass won't draw anything when #draw is
-    #           called.
+    # +create_split_box+::
+    #     Creates a new box based on this one and resets the internal data back to their original
+    #     values.
     #
-    # #draw:: This method draws the content and the default implementation already handles things
-    #         like drawing the border and background. Therefore it's best to implement #draw_content
-    #         which should just draw the content.
+    #     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.
     class Box
 
       include HexaPDF::Utils
@@ -162,7 +193,8 @@ module HexaPDF
         @split_box = false
       end
 
-      # Returns +true+ if this is a split box, i.e. the rest of another box after it was split.
+      # Returns the set truthy value if this is a split box, i.e. the rest of another box after it
+      # was split.
       def split_box?
         @split_box
       end
@@ -184,18 +216,34 @@ module HexaPDF
         height < 0 ? 0 : height
       end
 
-      # Fits the box into the Frame and returns +true+ if fitting was successful.
+      # Fits the box into the *frame* and returns +true+ if fitting was successful.
       #
       # The arguments +available_width+ and +available_height+ are the width and height of the
-      # current region of the frame. The frame itself is provided as third argument.
+      # current region of the frame, adjusted for this box. The frame itself is provided as third
+      # argument.
       #
-      # The default implementation uses the available width and height for the box width and height
-      # if they were initially set to 0. Otherwise the specified dimensions are used.
-      def fit(available_width, available_height, _frame)
+      # The default implementation uses the given available width and height for the box width and
+      # height if they were initially set to 0. Otherwise the intially specified dimensions are
+      # used. Then the #fit_content method is called which allows sub-classes to fit their content.
+      #
+      # The following variables are set that may later be used during splitting or drawing:
+      #
+      # * (@fit_x, @fit_y): The lower-left corner of the content box where fitting was done. Can be
+      #   used to adjust the drawing position in #draw/#draw_content if necessary.
+      # * @fit_successful: +true+ if fitting was successful.
+      def fit(available_width, available_height, frame)
         @width = (@initial_width > 0 ? @initial_width : available_width)
         @height = (@initial_height > 0 ? @initial_height : available_height)
         @fit_successful = (float_compare(@width, available_width) <= 0 &&
                            float_compare(@height, available_height) <= 0)
+        return unless @fit_successful
+
+        @fit_successful = fit_content(available_width, available_height, frame)
+
+        @fit_x = frame.x + reserved_width_left
+        @fit_y = frame.y - @height + reserved_height_bottom
+
+        @fit_successful
       end
 
       # Tries to split the box into two, the first of which needs to fit into the current region of
@@ -237,6 +285,8 @@ module HexaPDF
       # arguments. Subclasses can specify an on-demand drawing method by setting the +@draw_block+
       # instance variable to +nil+ or a valid block. This is useful to avoid unnecessary set-up
       # operations when the block does nothing.
+      #
+      # Alternatively, if a #draw_content method is defined, this method is called.
       def draw(canvas, x, y)
         if (oc = properties['optional_content'])
           canvas.optional_content(oc)
@@ -316,12 +366,26 @@ module HexaPDF
         result
       end
 
-      # Draws the content of the box at position [x, y] which is the bottom-left corner of the
-      # content box.
-      def draw_content(canvas, x, y)
-        if @draw_block
-          canvas.translate(x, y) { @draw_block.call(canvas, self) }
-        end
+      # 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
+
+      # Updates the height of the box using the content height returned by the block.
+      def update_content_height
+        return if @initial_height > 0
+        @height = yield + reserved_height
+      end
+
+      # Fits the content of the box and returns whether fitting was successful.
+      #
+      # This is just a stub implementation that returns +true+. Subclasses should override it to
+      # provide the box specific behaviour.
+      #
+      # See #fit for details.
+      def fit_content(available_width, available_height, frame)
+        true
       end
 
       # Splits the content of the box.
@@ -335,6 +399,17 @@ module HexaPDF
         [nil, self]
       end
 
+      # Draws the content of the box at position [x, y] which is the bottom-left corner of the
+      # content box.
+      #
+      # This implementation uses the drawing block provided on initialization, if set, to draw the
+      # contents. Subclasses should override it to provide box specific behaviour.
+      def draw_content(canvas, x, y)
+        if @draw_block
+          canvas.translate(x, y) { @draw_block.call(canvas, self) }
+        end
+      end
+
       # Creates a new box based on this one and resets the data back to their original values.
       #
       # The variable +@split_box+ is set to +split_box_value+ (defaults to +true+) to make the new

data/lib/hexapdf/layout/container_box.rb

@@ -0,0 +1,159 @@
+# -*- 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-2023 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'
+require 'hexapdf/layout/box_fitter'
+require 'hexapdf/layout/frame'
+
+module HexaPDF
+  module Layout
+
+    # This is a simple container box for laying out a number of boxes together. It is registered
+    # under the :container name.
+    #
+    # The box does not support the value :flow for the style property position, so the child boxes
+    # are laid out in the current region only. Since the boxes should be laid out together, if any
+    # box doesn't fit, the whole container doesn't fit. Splitting the container is also not possible
+    # for the same reason.
+    #
+    # By default the child boxes are laid out from top to bottom by default. By appropriately
+    # setting the style properties 'mask_mode', 'align' and 'valign', it is possible to lay out the
+    # children bottom to top, left to right, or right to left:
+    #
+    # * The standard top to bottom layout:
+    #
+    #     #>pdf-composer100
+    #     composer.container do |container|
+    #       container.box(:base, height: 20, style: {background_color: "hp-blue-dark"})
+    #       container.box(:base, height: 20, style: {background_color: "hp-blue"})
+    #       container.box(:base, height: 20, style: {background_color: "hp-blue-light"})
+    #     end
+    #
+    # * The bottom to top layout (using valign = :bottom to fill up from the bottom and mask_mode =
+    #   :fill_horizontal to only remove the area to the left and right of the box):
+    #
+    #     #>pdf-composer100
+    #     composer.container do |container|
+    #       container.box(:base, height: 20, style: {background_color: "hp-blue-dark",
+    #                                                mask_mode: :fill_horizontal, valign: :bottom})
+    #       container.box(:base, height: 20, style: {background_color: "hp-blue",
+    #                                                mask_mode: :fill_horizontal, valign: :bottom})
+    #       container.box(:base, height: 20, style: {background_color: "hp-blue-light",
+    #                                                mask_mode: :fill_horizontal, valign: :bottom})
+    #     end
+    #
+    # * The left to right layout (using mask_mode = :fill_vertical to fill the area to the top and
+    #   bottom of the box):
+    #
+    #     #>pdf-composer100
+    #     composer.container do |container|
+    #       container.box(:base, width: 20, style: {background_color: "hp-blue-dark",
+    #                                               mask_mode: :fill_vertical})
+    #       container.box(:base, width: 20, style: {background_color: "hp-blue",
+    #                                               mask_mode: :fill_vertical})
+    #       container.box(:base, width: 20, style: {background_color: "hp-blue-light",
+    #                                               mask_mode: :fill_vertical})
+    #     end
+    #
+    # * The right to left layout (using align = :right to fill up from the right and mask_mode =
+    #   :fill_vertical to fill the area to the top and bottom of the box):
+    #
+    #     #>pdf-composer100
+    #     composer.container do |container|
+    #       container.box(:base, width: 20, style: {background_color: "hp-blue-dark",
+    #                                               mask_mode: :fill_vertical, align: :right})
+    #       container.box(:base, width: 20, style: {background_color: "hp-blue",
+    #                                               mask_mode: :fill_vertical, align: :right})
+    #       container.box(:base, width: 20, style: {background_color: "hp-blue-light",
+    #                                               mask_mode: :fill_vertical, align: :right})
+    #     end
+    class ContainerBox < Box
+
+      # The child boxes of this ContainerBox. They need to be finalized before #fit is called.
+      attr_reader :children
+
+      # Creates a new container box, optionally accepting an array of child boxes.
+      #
+      # Example:
+      #
+      #   #>pdf-composer100
+      #   composer.text("A paragraph here")
+      #   composer.container(height: 40, style: {border: {width: 1}, padding: 5,
+      #                                          align: :center}) do |container|
+      #     container.text("Some", mask_mode: :fill_vertical)
+      #     container.text("text", mask_mode: :fill_vertical, valign: :center)
+      #     container.text("here", mask_mode: :fill_vertical, valign: :bottom)
+      #   end
+      #   composer.text("Another paragraph")
+      def initialize(children: [], **kwargs)
+        super(**kwargs)
+        @children = children
+      end
+
+      # Returns +true+ if no box was fitted into the container.
+      def empty?
+        super && (!@box_fitter || @box_fitter.fit_results.empty?)
+      end
+
+      private
+
+      # Fits the children into the container.
+      def fit_content(available_width, available_height, frame)
+        my_frame = Frame.new(frame.x + reserved_width_left, frame.y - @height + reserved_height_bottom,
+                             content_width, content_height, context: frame.context)
+        @box_fitter = BoxFitter.new([my_frame])
+        children.each {|box| @box_fitter.fit(box) }
+
+        if @box_fitter.fit_successful?
+          update_content_width do
+            result = @box_fitter.fit_results.max_by {|result| result.mask.x + result.mask.width }
+            children.size > 0 ? result.mask.x + result.mask.width - my_frame.left : 0
+          end
+          update_content_height { @box_fitter.content_heights.max }
+          true
+        end
+      end
+
+      # Draws the image onto the canvas at position [x, y].
+      def draw_content(canvas, x, y)
+        dx = x - @fit_x
+        dy = y - @fit_y
+        @box_fitter.fit_results.each {|result| result.draw(canvas, dx: dx, dy: dy) }
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/layout/frame.rb

@@ -128,17 +128,20 @@ module HexaPDF
           @success
         end
 
-        # Draws the #box onto the canvas at (#x, #y).
+        # Draws the #box onto the canvas at (#x + *dx*, #y + *dy*).
+        #
+        # The relative offset (dx, dy) is useful when rendering results that were accumulated and
+        # then need to be moved because the container holding them changes its position.
         #
         # The configuration option "debug" can be used to add visual debug output with respect to
         # box placement.
-        def draw(canvas)
+        def draw(canvas, dx: 0, dy: 0)
           doc = canvas.context.document
           if doc.config['debug']
             name = "#{box.class} (#{x.to_i},#{y.to_i}-#{box.width.to_i}x#{box.height.to_i})"
             ocg = doc.optional_content.ocg(name)
             canvas.optional_content(ocg) do
-              canvas.save_graphics_state do
+              canvas.translate(dx, dy) do
                 canvas.fill_color("green").stroke_color("darkgreen").
                   opacity(fill_alpha: 0.1, stroke_alpha: 0.2).
                   draw(:geom2d, object: mask, path_only: true).fill_stroke
@@ -146,7 +149,7 @@ module HexaPDF
             end
             doc.optional_content.default_configuration.add_ocg_to_ui(ocg, path: 'Debug')
           end
-          box.draw(canvas, x, y)
+          box.draw(canvas, x + dx, y + dy)
         end
 
       end

data/lib/hexapdf/layout/list_box.rb

@@ -232,7 +232,8 @@ module HexaPDF
 
           if index != 0 || !split_box? || @split_box == :show_first_marker
             box = item_marker_box(frame.document, index)
-            break unless box.fit(content_indentation, height, nil)
+            marker_frame = Frame.new(0, 0, content_indentation, height, context: frame.context)
+            break unless box.fit(content_indentation, height, marker_frame)
             item_result.marker = box
             item_result.marker_pos_x = item_frame.x - content_indentation
             item_result.height = box.height

data/lib/hexapdf/layout.rb

@@ -58,6 +58,7 @@ module HexaPDF
     autoload(:ListBox, 'hexapdf/layout/list_box')
     autoload(:PageStyle, 'hexapdf/layout/page_style')
     autoload(:TableBox, 'hexapdf/layout/table_box')
+    autoload(:ContainerBox, 'hexapdf/layout/container_box')
 
   end
 

data/lib/hexapdf/type/font_simple.rb

@@ -95,7 +95,8 @@ module HexaPDF
       # Returns the UTF-8 string for the given character code, or calls the configuration option
       # 'font.on_missing_unicode_mapping' if no mapping was found.
       def to_utf8(code)
-        to_unicode_cmap&.to_unicode(code) || encoding.unicode(code) || missing_unicode_mapping(code)
+        to_unicode_cmap&.to_unicode(code) || (encoding.unicode(code) rescue nil) ||
+          missing_unicode_mapping(code)
       end
 
       # Returns the unscaled width of the given code point in glyph units, or 0 if the width for

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.35.1'
+  VERSION = '0.36.0'
 
 end

data/test/hexapdf/document/test_layout.rb

@@ -175,6 +175,12 @@ describe HexaPDF::Document::Layout do
       assert_equal(2, box.children.size)
     end
 
+    it "uses the provided block as drawing block for the base box class if name=:base" do
+      block = proc {}
+      box = @layout.box(width: 100, &block)
+      assert_equal(block, box.instance_variable_get(:@draw_block))
+    end
+
     it "fails if the name is not registered" do
       assert_raises(HexaPDF::Error) { @layout.box(:unknown) }
     end

data/test/hexapdf/layout/test_box.rb

@@ -5,6 +5,12 @@ require 'hexapdf/document'
 require 'hexapdf/layout/box'
 
 describe HexaPDF::Layout::Box do
+  before do
+    @frame = Object.new
+    def @frame.x; 0; end
+    def @frame.y; 100; end
+  end
+
   def create_box(**args, &block)
     HexaPDF::Layout::Box.new(**args, &block)
   end
@@ -70,15 +76,13 @@ describe HexaPDF::Layout::Box do
   end
 
   describe "fit" do
-    before do
-      @frame = Object.new
-    end
-
     it "fits a fixed sized box" do
-      box = create_box(width: 50, height: 50)
+      box = create_box(width: 50, height: 50, style: {padding: 5})
       assert(box.fit(100, 100, @frame))
       assert_equal(50, box.width)
       assert_equal(50, box.height)
+      assert_equal(5, box.instance_variable_get(:@fit_x))
+      assert_equal(55, box.instance_variable_get(:@fit_y))
     end
 
     it "uses the maximum available width" do
@@ -106,49 +110,71 @@ describe HexaPDF::Layout::Box do
       box = create_box(width: 101)
       refute(box.fit(100, 100, @frame))
     end
+
+    it "can use the #content_width/#content_height helper methods" do
+      box = create_box
+      box.define_singleton_method(:fit_content) do |aw, ah, frame|
+        update_content_width { 10 }
+        update_content_height { 20 }
+        true
+      end
+      assert(box.fit(100, 100, @frame))
+      assert_equal(10, box.width)
+      assert_equal(20, box.height)
+
+      box = create_box(width: 30, height: 50)
+      box.define_singleton_method(:fit_content) do |aw, ah, frame|
+        update_content_width { 10 }
+        update_content_height { 20 }
+        true
+      end
+      assert(box.fit(100, 100, @frame))
+      assert_equal(30, box.width)
+      assert_equal(50, box.height)
+    end
   end
 
   describe "split" do
     before do
       @box = create_box(width: 100, height: 100)
-      @box.fit(100, 100, nil)
+      @box.fit(100, 100, @frame)
     end
 
     it "doesn't need to be split if it completely fits" do
-      assert_equal([@box, nil], @box.split(100, 100, nil))
+      assert_equal([@box, nil], @box.split(100, 100, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit and its width is greater than the available width" do
       @box.fit(90, 100, nil)
-      assert_equal([nil, @box], @box.split(50, 150, nil))
+      assert_equal([nil, @box], @box.split(50, 150, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit and its height is greater than the available height" do
       @box.fit(90, 100, nil)
-      assert_equal([nil, @box], @box.split(150, 50, nil))
+      assert_equal([nil, @box], @box.split(150, 50, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit and its content width is zero" do
       box = create_box(width: 0, height: 100)
-      assert_equal([nil, box], box.split(150, 150, nil))
+      assert_equal([nil, box], box.split(150, 150, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit and its content height is zero" do
       box = create_box(width: 100, height: 0)
-      assert_equal([nil, box], box.split(150, 150, nil))
+      assert_equal([nil, box], box.split(150, 150, @frame))
     end
 
     it "can't be split if it doesn't (completely) fit as the default implementation " \
       "knows nothing about the content" do
       @box.style.position = :flow # make sure we would generally be splitable
       @box.fit(90, 100, nil)
-      assert_equal([nil, @box], @box.split(150, 150, nil))
+      assert_equal([nil, @box], @box.split(150, 150, @frame))
     end
   end
 
   it "can create a cloned box for splitting" do
     box = create_box
-    box.fit(100, 100, nil)
+    box.fit(100, 100, @frame)
     cloned_box = box.send(:create_split_box)
     assert(cloned_box.split_box?)
     refute(cloned_box.instance_variable_get(:@fit_successful))

data/test/hexapdf/layout/test_container_box.rb

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/layout/container_box'
+
+describe HexaPDF::Layout::ContainerBox do
+  before do
+    @doc = HexaPDF::Document.new
+    @frame = HexaPDF::Layout::Frame.new(0, 0, 100, 100)
+  end
+
+  def create_box(children, **kwargs)
+    HexaPDF::Layout::ContainerBox.new(children: Array(children), **kwargs)
+  end
+
+  def check_box(box, width, height, fit_pos = nil)
+    assert(box.fit(@frame.available_width, @frame.available_height, @frame), "box didn't fit")
+    assert_equal(width, box.width, "box width")
+    assert_equal(height, box.height, "box height")
+    if fit_pos
+      box_fitter = box.instance_variable_get(:@box_fitter)
+      assert_equal(fit_pos.size, box_fitter.fit_results.size)
+      fit_pos.each_with_index do |(x, y), index|
+        assert_equal(x, box_fitter.fit_results[index].x, "result[#{index}].x")
+        assert_equal(y, box_fitter.fit_results[index].y, "result[#{index}].y")
+      end
+    end
+  end
+
+  describe "empty?" do
+    it "is empty if nothing is fit yet" do
+      assert(create_box([]).empty?)
+    end
+
+    it "is empty if no box fits" do
+      box = create_box(@doc.layout.box(width: 110))
+      box.fit(@frame.available_width, @frame.available_height, @frame)
+      assert(box.empty?)
+    end
+
+    it "is not empty if at least one box fits" do
+      box = create_box(@doc.layout.box(width: 50, height: 20))
+      check_box(box, 100, 20)
+      refute(box.empty?)
+    end
+  end
+
+  describe "fit_content" do
+    it "fits the children according to their mask_mode, valign, and align style properties" do
+      box = create_box([@doc.layout.box(height: 20),
+                        @doc.layout.box(height: 20, style: {valign: :bottom, mask_mode: :fill_horizontal}),
+                        @doc.layout.box(width: 20, style: {align: :right, mask_mode: :fill_vertical})])
+      check_box(box, 100, 100, [[0, 80], [0, 0], [80, 20]])
+    end
+
+    it "respects the initially set width/height as well as border/padding" do
+      box = create_box(@doc.layout.box(height: 20), height: 50, width: 40,
+                       style: {padding: 2, border: {width: 3}})
+      check_box(box, 40, 50, [[5, 75]])
+    end
+  end
+
+  describe "draw_content" do
+    before do
+      @canvas = @doc.pages.add.canvas
+    end
+
+    it "draws the result onto the canvas" do
+      child_box = @doc.layout.box(height: 20) do |canvas, b|
+        canvas.line(0, 0, b.content_width, b.content_height).end_path
+      end
+      box = create_box(child_box)
+      box.fit(100, 100, @frame)
+      box.draw(@canvas, 0, 50)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 0, 50]],
+                                          [:move_to, [0, 0]],
+                                          [:line_to, [100, 20]],
+                                          [:end_path],
+                                          [:restore_graphics_state]])
+    end
+  end
+end

data/test/hexapdf/layout/test_frame.rb

@@ -13,10 +13,11 @@ describe HexaPDF::Layout::Frame::FitResult do
     result = HexaPDF::Layout::Frame::FitResult.new(box)
     result.mask = Geom2D::Rectangle(0, 0, 20, 20)
     result.x = result.y = 0
-    result.draw(canvas)
+    result.draw(canvas, dx: 10, dy: 15)
     assert_equal(<<~CONTENTS, canvas.contents)
       /OC /P1 BDC
       q
+      1 0 0 1 10 15 cm
       0.0 0.501961 0.0 rg
       0.0 0.392157 0.0 RG
       /GS1 gs
@@ -25,7 +26,7 @@ describe HexaPDF::Layout::Frame::FitResult do
       Q
       EMC
       q
-      1 0 0 1 0 0 cm
+      1 0 0 1 10 15 cm
       Q
     CONTENTS
     ocg = doc.optional_content.ocgs.first

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.35.1)>>
+      <</Producer(HexaPDF version 0.36.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.35.1)>>
+      <</Producer(HexaPDF version 0.36.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream

data/test/hexapdf/type/test_font_simple.rb

@@ -116,9 +116,17 @@ describe HexaPDF::Type::FontSimple do
       assert_equal(" ", @font.to_utf8(32))
     end
 
+    it "swallows errors during retrieving the font's encoding" do
+      @font.delete(:ToUnicode)
+      @font.delete(:Encoding)
+      err = assert_raises(HexaPDF::Error) { @font.to_utf8(32) }
+      assert_match(/No Unicode mapping/, err.message)
+    end
+
     it "calls the configured proc if no correct mapping could be found" do
       @font.delete(:ToUnicode)
-      assert_raises(HexaPDF::Error) { @font.to_utf8(0) }
+      err = assert_raises(HexaPDF::Error) { @font.to_utf8(0) }
+      assert_match(/No Unicode mapping/, err.message)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.35.1
+  version: 0.36.0
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-10 00:00:00.000000000 Z
+date: 2024-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -434,6 +434,7 @@ files:
 - lib/hexapdf/layout/box.rb
 - lib/hexapdf/layout/box_fitter.rb
 - lib/hexapdf/layout/column_box.rb
+- lib/hexapdf/layout/container_box.rb
 - lib/hexapdf/layout/frame.rb
 - lib/hexapdf/layout/image_box.rb
 - lib/hexapdf/layout/inline_box.rb
@@ -695,6 +696,7 @@ files:
 - test/hexapdf/layout/test_box.rb
 - test/hexapdf/layout/test_box_fitter.rb
 - test/hexapdf/layout/test_column_box.rb
+- test/hexapdf/layout/test_container_box.rb
 - test/hexapdf/layout/test_frame.rb
 - test/hexapdf/layout/test_image_box.rb
 - test/hexapdf/layout/test_inline_box.rb