hexapdf 0.5.0 → 0.6.0

data/lib/hexapdf/layout/text_fragment.rb

@@ -70,14 +70,38 @@ module HexaPDF
 
       # The style to be applied.
       #
-      # Only the following properties are used: Style#font, Style#font_size,
-      # Style#horizontal_scaling, Style#character_spacing, Style#word_spacing and Style#text_rise.
+      # Only the following properties are used:
+      #
+      # * Style#font
+      # * Style#font_size
+      # * Style#horizontal_scaling
+      # * Style#character_spacing
+      # * Style#word_spacing
+      # * Style#text_rise
+      # * Style#text_rendering_mode
+      # * Style#subscript
+      # * Style#superscript
+      # * Style#underline
+      # * Style#strikeout
+      # * Style#fill_color
+      # * Style#fill_alpha
+      # * Style#stroke_color
+      # * Style#stroke_alpha
+      # * Style#stroke_width
+      # * Style#stroke_cap_style
+      # * Style#stroke_join_style
+      # * Style#stroke_miter_limit
+      # * Style#stroke_dash_pattern
+      # * Style#underlay_callback
+      # * Style#overlay_callback
       attr_reader :style
 
       # Creates a new TextFragment object with the given items and style.
+      #
+      # The argument +style+ can either be a Style object or a hash of style options.
       def initialize(items:, style: Style.new)
         @items = items || []
-        @style = style
+        @style = (style.kind_of?(Style) ? style : Style.new(style))
       end
 
       # Draws the text onto the canvas at the given position.
@@ -85,13 +109,57 @@ module HexaPDF
       # Before the text is drawn using HexaPDF::Content;:Canvas#show_glyphs, the text properties
       # mentioned in the description of #style are set.
       def draw(canvas, x, y)
+        return if items.empty?
+
+        style.underlays.draw(canvas, x, y + y_min, self)
+
+        # Set general font related graphics state
         canvas.move_text_cursor(offset: [x, y])
-        canvas.font(style.font, size: style.font_size).
+        canvas.font(style.font, size: style.calculated_font_size).
           horizontal_scaling(style.horizontal_scaling).
           character_spacing(style.character_spacing).
           word_spacing(style.word_spacing).
-          text_rise(style.text_rise)
+          text_rise(style.calculated_text_rise).
+          text_rendering_mode(style.text_rendering_mode)
+
+        # Set fill and/or stroke related graphics state
+        canvas.opacity(fill_alpha: style.fill_alpha, stroke_alpha: style.stroke_alpha)
+        trm = canvas.text_rendering_mode
+        if trm.value.even? # text is filled
+          canvas.fill_color(style.fill_color)
+        end
+        if trm == :stroke || trm == :fill_stroke || trm == :stroke_clip || trm == :fill_stroke_clip
+          canvas.stroke_color(style.stroke_color).
+            line_width(style.stroke_width).
+            line_cap_style(style.stroke_cap_style).
+            line_join_style(style.stroke_join_style).
+            miter_limit(style.stroke_miter_limit).
+            line_dash_pattern(style.stroke_dash_pattern)
+        end
+
         canvas.show_glyphs_only(items)
+
+        if style.underline
+          y_offset = style.calculated_underline_position
+          canvas.stroke_color(style.fill_color).
+            line_width(style.calculated_underline_thickness).
+            line_cap_style(:butt).
+            line_dash_pattern(0).
+            line(x, y + y_offset, x + width, y + y_offset).
+            stroke
+        end
+
+        if style.strikeout
+          y_offset = style.calculated_strikeout_position
+          canvas.stroke_color(style.fill_color).
+            line_width(style.calculated_strikeout_thickness).
+            line_cap_style(:butt).
+            line_dash_pattern(0).
+            line(x, y + y_offset, x + width, y + y_offset).
+            stroke
+        end
+
+        style.overlays.draw(canvas, x, y + y_min, self)
       end
 
       # The minimum x-coordinate of the first glyph.
@@ -106,24 +174,24 @@ module HexaPDF
 
       # The minimum y-coordinate, calculated using the scaled descender of the font.
       def y_min
-        @y_min ||= style.scaled_font_descender + style.text_rise
+        @y_min ||= style.scaled_font_descender + style.calculated_text_rise
       end
 
       # The maximum y-coordinate, calculated using the scaled ascender of the font.
       def y_max
-        @y_max ||= style.scaled_font_ascender + style.text_rise
+        @y_max ||= style.scaled_font_ascender + style.calculated_text_rise
       end
 
       # The minimum y-coordinate of any item.
       def exact_y_min
-        @exact_y_min ||= (@items.min_by(&:y_min)&.y_min || 0) * style.font_size / 1000.0 +
-          style.text_rise
+        @exact_y_min ||= (@items.min_by(&:y_min)&.y_min || 0) *
+          style.calculated_font_size / 1000.0 + style.calculated_text_rise
       end
 
       # The maximum y-coordinate of any item.
       def exact_y_max
-        @exact_y_max ||= (@items.max_by(&:y_max)&.y_max || 0) * style.font_size / 1000.0 +
-          style.text_rise
+        @exact_y_max ||= (@items.max_by(&:y_max)&.y_max || 0) *
+          style.calculated_font_size / 1000.0 + style.calculated_text_rise
       end
 
       # The width of the text fragment.
@@ -148,7 +216,7 @@ module HexaPDF
 
       # Returns the vertical alignment inside a line which is always :text for text fragments.
       #
-      # See LineFragment for details.
+      # See Line for details.
       def valign
         :text
       end

data/lib/hexapdf/layout/{text_box.rb → text_layouter.rb}

@@ -34,7 +34,7 @@
 require 'hexapdf/error'
 require 'hexapdf/layout/text_fragment'
 require 'hexapdf/layout/inline_box'
-require 'hexapdf/layout/line_fragment'
+require 'hexapdf/layout/line'
 require 'hexapdf/layout/numeric_refinements'
 
 module HexaPDF
@@ -54,14 +54,14 @@ module HexaPDF
     #
     # Laying out text consists of two phases:
     #
-    # 1. The items of the text box are broken into pieces which are wrapped into Box, Glue or
-    #    Penalty objects. Additional Penalty objects marking line breaking opportunities are
-    #    inserted where needed. This step is done by the SimpleTextSegmentation module.
+    # 1. The items are broken into pieces which are wrapped into Box, Glue or Penalty objects.
+    #    Additional Penalty objects marking line breaking opportunities are inserted where needed.
+    #    This step is done by the SimpleTextSegmentation module.
     #
     # 2. The pieces are arranged into lines using a very simple algorithm that just puts the maximum
     #    number of consecutive pieces into each line. This step is done by the SimpleLineWrapping
     #    module.
-    class TextBox
+    class TextLayouter
 
       using NumericRefinements
 
@@ -81,6 +81,11 @@ module HexaPDF
           @item.width
         end
 
+        # The height of the item.
+        def height
+          @item.height
+        end
+
         # Returns :box.
         def type
           :box
@@ -127,6 +132,12 @@ module HexaPDF
         # All numbers greater than this one are deemed infinite.
         INFINITY = 1000
 
+        # The penalty value for a mandatory paragraph break.
+        PARAGRAPH_BREAK = -INFINITY - 1_000_000
+
+        # The penalty value for a mandatory line break.
+        LINE_BREAK = -INFINITY - 1_000_001
+
         # The penalty for breaking at this point.
         attr_reader :penalty
 
@@ -148,8 +159,11 @@ module HexaPDF
           :penalty
         end
 
-        # Singleton object describing a Penalty for a mandatory break.
-        MandatoryBreak = new(-Penalty::INFINITY)
+        # Singleton object describing a Penalty for a mandatory paragraph break.
+        MandatoryParagraphBreak = new(PARAGRAPH_BREAK)
+
+        # Singleton object describing a Penalty for a mandatory line break.
+        MandatoryLineBreak = new(LINE_BREAK)
 
         # Singleton object describing a Penalty for a prohibited break.
         ProhibitedBreak = new(Penalty::INFINITY)
@@ -217,11 +231,13 @@ module HexaPDF
                     glues[item.style] ||=
                       Glue.new(TextFragment.new(items: [glyph].freeze, style: item.style))
                     result << glues[item.style]
-                  when "\n", "\v", "\f", "\u{85}", "\u{2028}", "\u{2029}"
-                    result << Penalty::MandatoryBreak
+                  when "\n", "\v", "\f", "\u{85}", "\u{2029}"
+                    result << Penalty::MandatoryParagraphBreak
+                  when "\u{2028}"
+                    result << Penalty::MandatoryLineBreak
                   when "\r"
                     if item.items[i + 1]&.kind_of?(Numeric) || item.items[i + 1].str != "\n"
-                      result << Penalty::MandatoryBreak
+                      result << Penalty::MandatoryParagraphBreak
                     end
                   when '-'
                     result << Penalty::Standard
@@ -255,32 +271,35 @@ module HexaPDF
       class SimpleLineWrapping
 
         # :call-seq:
-        #   SimpleLineWrapping.call(items, available_width) {|line, item| block }   -> rest
+        #   SimpleLineWrapping.call(items, width_block) {|line, item| block }   -> rest
         #
         # Arranges the items into lines.
         #
-        # The +available_width+ argument can either be a simple number or a callable object:
+        # The +width_block+ argument has to be a callable object that returns the width of the line:
         #
-        # * If all lines should have the same width, the +available_width+ argument should be a
-        #   number. This is the general case.
+        # * If the line width doesn't depend on the height or the vertical position of the line
+        #   (i.e. fixed line width), the +width_block+ should have an arity of zero. However, this
+        #   doesn't mean that the block is called only once; it is actually called before each new
+        #   line (e.g. for varying line widths that don't depend on the line height; one common case
+        #   is the indentation of the first line). This is the general case.
         #
-        # * However, if lines should have varying lengths (e.g. for flowing text around shapes), the
-        #   +available_width+ argument should be an object responding to #call(line_height) where
+        # * However, if lines should have varying widths (e.g. for flowing text around shapes), the
+        #   +width_block+ argument should be an object responding to #call(line_height) where
         #   +line_height+ is the height of the currently layed out line. The caller is responsible
-        #   for tracking the height of the already layed out lines. The result of the method call
-        #   should be the available width.
+        #   for tracking the height of the already layed out lines. This method involves more work
+        #   and is therefore slower.
         #
         # Regardless of whether varying line widths are used or not, each time a line is finished,
-        # it is yielded to the caller. The second argument +item+ is the TextFragment or InlineBox
-        # that doesn't fit anymore, or +nil+ in case of mandatory line breaks or when the line break
-        # occured at a glue item. If the yielded line is empty and the yielded item is not +nil+,
-        # this single item doesn't fit into the available width; the caller has to handle this
-        # situation, e.g. by stopping.
+        # it is yielded to the caller. The second argument +item+ is the item that caused the line
+        # break (e.g. a Box, Glue or Penalty). The return value should be truthy if line wrapping
+        # should continue, or falsy if it should stop. If the yielded line is empty and the yielded
+        # item is a box item, this single item didn't fit into the available width; the caller has
+        # to handle this situation, e.g. by stopping.
         #
         # After the algorithm is finished, it returns the unused items.
-        def self.call(items, available_width, &block)
-          obj = new(items, available_width)
-          if available_width.respond_to?(:call)
+        def self.call(items, width_block, &block)
+          obj = new(items, width_block)
+          if width_block.arity == 1
             obj.variable_width_wrapping(&block)
           else
             obj.fixed_width_wrapping(&block)
@@ -291,9 +310,10 @@ module HexaPDF
 
         # Creates a new line wrapping object that arranges the +items+ on lines with the given
         # width.
-        def initialize(items, available_width)
+        def initialize(items, width_block)
           @items = items
-          @available_width = @width_block = available_width
+          @width_block = width_block
+          @available_width = @width_block.call(0)
           @line_items = []
           @width = 0
           @glue_items = []
@@ -302,11 +322,11 @@ module HexaPDF
           @last_breakpoint_line_items_index = 0
           @break_prohibited_state = false
 
-          @height_calc = LineFragment::HeightCalculator.new
+          @height_calc = Line::HeightCalculator.new
           @line_height = 0
         end
 
-        # Peforms the line wrapping with a fixed width.
+        # Peforms line wrapping with a fixed width per line, with line height playing no role.
         def fixed_width_wrapping
           index = 0
 
@@ -318,18 +338,18 @@ module HexaPDF
                   index = reset_line_to_last_breakpoint_state
                   item = @items[index]
                 end
-                break unless yield(create_line, item.item)
+                break unless yield(create_line, item)
                 reset_after_line_break(index)
                 redo
               end
             when :glue
               unless add_glue_item(item.item, index)
-                break unless yield(create_line, nil)
+                break unless yield(create_line, item)
                 reset_after_line_break(index + 1)
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
-                break unless yield(create_unjustified_line, nil)
+                break unless yield(create_unjustified_line, item)
                 reset_after_line_break(index + 1)
               elsif item.penalty >= Penalty::INFINITY
                 @break_prohibited_state = true
@@ -365,7 +385,6 @@ module HexaPDF
         # Performs the line wrapping with variable widths.
         def variable_width_wrapping
           index = 0
-          @available_width = @width_block.call(@line_height)
 
           while (item = @items[index])
             case item.type
@@ -382,18 +401,18 @@ module HexaPDF
                   index = reset_line_to_last_breakpoint_state
                   item = @items[index]
                 end
-                break unless yield(create_line, item.item)
+                break unless yield(create_line, item)
                 reset_after_line_break(index)
                 redo
               end
             when :glue
               unless add_glue_item(item.item, index)
-                break unless yield(create_line, nil)
+                break unless yield(create_line, item)
                 reset_after_line_break(index + 1)
               end
             when :penalty
               if item.penalty <= -Penalty::INFINITY
-                break unless yield(create_unjustified_line, nil)
+                break unless yield(create_unjustified_line, item)
                 reset_after_line_break(index + 1)
               elsif item.penalty >= Penalty::INFINITY
                 @break_prohibited_state = true
@@ -474,12 +493,12 @@ module HexaPDF
           @width + item.width <= @available_width
         end
 
-        # Creates a LineFragment object from the current line items.
+        # Creates a Line object from the current line items.
         def create_line
-          LineFragment.new(@line_items)
+          Line.new(@line_items)
         end
 
-        # Creates a LineFragment object from the current line items that ignores line justification.
+        # Creates a Line object from the current line items that ignores line justification.
         def create_unjustified_line
           create_line.tap(&:ignore_justification!)
         end
@@ -494,6 +513,7 @@ module HexaPDF
           @last_breakpoint_index = index
           @last_breakpoint_line_items_index = 0
           @break_prohibited_state = false
+          @available_width = @width_block.call(0)
 
           @line_height = 0
           @height_calc.reset
@@ -502,12 +522,12 @@ module HexaPDF
       end
 
 
-      # Creates a new TextBox object for the given text and returns it.
+      # Creates a new TextLayouter object for the given text and returns it.
       #
       # See ::new for information on +height+.
       #
-      # The style of the text box can be specified using additional options, of which font is
-      # mandatory.
+      # The style that gets applied to the text and the layout itself can be specified using
+      # additional options, of which font is mandatory.
       def self.create(text, width:, height: nil, x_offsets: nil, **options)
         frag = TextFragment.create(text, **options)
         new(items: [frag], width: width, height: height, x_offsets: x_offsets, style: frag.style)
@@ -519,19 +539,19 @@ module HexaPDF
       # Style#text_segmentation_algorithm, Style#text_line_wrapping_algorithm
       attr_reader :style
 
-      # The items (TextFragment and InlineBox objects) of the text box that should be layed out.
+      # The items (TextFragment and InlineBox objects) that should be layed out.
       attr_reader :items
 
-      # Array of LineFragment objects describing the lines of the text box.
+      # Array of Line objects describing the layed out lines.
       #
       # The array is only valid after #fit was called.
       attr_reader :lines
 
-      # The actual height of the text box. Can be +nil+ if the items have not been layed out yet,
-      # i.e. if #fit has not been called.
+      # The actual height of the layed out text. Can be +nil+ if the items have not been layed out
+      # yet, i.e. if #fit has not been called.
       attr_reader :actual_height
 
-      # Creates a new TextBox object with the given width containing the given items.
+      # Creates a new TextLayouter object with the given width containing the given items.
       #
       # The width can either be a simple number specifying a fixed width, or an object that responds
       # to #call(height, line_height) where +height+ is the bottom of last line and +line_height+ is
@@ -539,12 +559,15 @@ module HexaPDF
       # these height restrictions.
       #
       # The optional +x_offsets+ argument works like +width+ but can be used to specify (varying)
-      # offsets from the left of the box (e.g. when the left side of the text should follow a
-      # certain shape).
+      # offsets from the left side (e.g. when the left side of the text should follow a certain
+      # shape).
+      #
+      # The height is optional and if not specified means that the text layout has infinite height.
       #
-      # The height is optional and if not specified means that the text box has infinite height.
+      # The +style+ argument can either be a Style object or a hash of style options. See #style for
+      # the properties that are used by the layouter.
       def initialize(items: [], width:, height: nil, x_offsets: nil, style: Style.new)
-        @style = style
+        @style = (style.kind_of?(Style) ? style : Style.new(style))
         @lines = []
         self.items = items
         @width = width
@@ -552,7 +575,7 @@ module HexaPDF
         @x_offsets = x_offsets && (x_offsets.respond_to?(:call) ? x_offsets : proc { x_offsets })
       end
 
-      # Sets the items to be arranged by the text box, clearing the internal state.
+      # Sets the items to be arranged by the text layouter, clearing the internal state.
       #
       # If the items array contains items before text segmentation, the text segmentation algorithm
       # is automatically applied.
@@ -566,80 +589,105 @@ module HexaPDF
       end
 
       # :call-seq:
-      #   text_box.fit  -> [remaining_items, actual_height]
+      #   text_layouter.fit  -> [remaining_items, reason]
       #
-      # Fits the items into the text box and returns the remaining items as well as the actual
-      # height needed.
+      # Fits the items into the set area and returns the remaining items as well as the reason why
+      # there are remaining items.
       #
-      # Note: If the text box height has not been set and variable line widths are used, no search
-      # for a possible vertical offset is done in case a single item doesn't fit.
+      # The reason can be +:success+ if there are no remaining items, +:box+ if a single text or
+      # inline box item is too wide to fit alone on a line, or +:height+ if there was not enough
+      # height for all items.
+      #
+      # The fitted lines can be retrieved via #lines and the total height via #actual_height.
+      #
+      # Note: If no height has been set and variable line widths are used, no search for a possible
+      # vertical offset is done in case a single item doesn't fit.
       #
       # This method is automatically called as part of the drawing routine but it can also be used
-      # by itself to determine the actual height of the text box.
+      # by itself to determine the actual height of the layed out text.
       def fit
         @lines.clear
         @actual_height = 0
-        y_offset = 0
-
-        items = @items
-        if style.text_indent != 0
-          items = [Box.new(InlineBox.new(style.text_indent, 0) { })].concat(items)
-        end
-
-        if @width.respond_to?(:call)
-          width_arg = proc {|h| @width.call(@actual_height, h)}
-          width_block = @width
-        else
-          width_arg = @width
-          width_block = proc { @width }
-        end
 
-        rest = style.text_line_wrapping_algorithm.call(items, width_arg) do |line, item|
-          line << TextFragment.new(items: [], style: style) if item.nil? && line.items.empty?
-          new_height = @actual_height + line.height +
-            (@lines.empty? ? 0 : style.line_spacing.gap(@lines.last, line))
-
-          if new_height <= @height && !line.items.empty?
-            # valid line found, use it
-            cur_width = width_block.call(@actual_height, line.height)
-            line.x_offset = horizontal_alignment_offset(line, cur_width)
-            line.x_offset += @x_offsets.call(@actual_height, line.height) if @x_offsets
-            line.y_offset =  if y_offset
-                               y_offset + (@lines.last ? -@lines.last.y_min + line.y_max : 0)
-                             else
-                               style.line_spacing.baseline_distance(@lines.last, line)
-                             end
-            @actual_height = new_height
-            @lines << line
-            y_offset = nil
-            true
-          elsif new_height <= @height && @height != Float::INFINITY
-            # some height left but item didn't fit on the line, search downwards for usable space
-            new_height = @actual_height
-            while item.width > width_block.call(new_height, item.height) && new_height <= @height
-              new_height += item.height / 3
-            end
-            if new_height + item.height <= @height
-              y_offset = new_height - @actual_height
+        rest = @items
+        y_offset = 0
+        indent = (style.text_indent != 0 ? style.text_indent : 0)
+        width_block = if @width.respond_to?(:call)
+                        proc {|h| @width.call(@actual_height, h) - indent }
+                      else
+                        proc { @width - indent }
+                      end
+
+        while true
+          too_wide_box = nil
+
+          rest = style.text_line_wrapping_algorithm.call(rest, width_block) do |line, item|
+            line << TextFragment.new(items: [], style: style) if item&.type != :box && line.items.empty?
+            new_height = @actual_height + line.height +
+              (@lines.empty? ? 0 : style.line_spacing.gap(@lines.last, line))
+
+            if new_height > @height
+              nil
+            elsif !line.items.empty?
+              # valid line found, use it
+              cur_width = width_block.call(line.height)
+              line.x_offset = indent + horizontal_alignment_offset(line, cur_width)
+              line.x_offset += @x_offsets.call(@actual_height, line.height) if @x_offsets
+              line.y_offset =  if y_offset
+                                 y_offset + (@lines.last ? -@lines.last.y_min + line.y_max : 0)
+                               else
+                                 style.line_spacing.baseline_distance(@lines.last, line)
+                               end
               @actual_height = new_height
+              @lines << line
+              y_offset = nil
+              indent = if item&.type == :penalty && item.penalty == Penalty::PARAGRAPH_BREAK
+                         style.text_indent
+                       else
+                         0
+                       end
               true
+            elsif @height != Float::INFINITY
+              # some height left but item didn't fit on the line, search downwards for usable space
+              old_height = @actual_height
+              while item.width > width_block.call(item.height) && @actual_height <= @height
+                @actual_height += item.height / 3
+              end
+              if @actual_height + item.height <= @height
+                y_offset = @actual_height - old_height
+                true
+              else
+                @actual_height = old_height
+                too_wide_box = item
+                nil
+              end
             else
+              too_wide_box = item
               nil
             end
+          end
+
+          if too_wide_box && too_wide_box.item.kind_of?(TextFragment) &&
+              too_wide_box.item.items.size > 1
+            rest[0..rest.index(too_wide_box)] = too_wide_box.item.items.map do |item|
+              Box.new(TextFragment.new(items: [item], style: too_wide_box.item.style))
+            end
+            too_wide_box = nil
           else
-            nil
+            reason = (too_wide_box ? :box : (rest.empty? ? :success : :height))
+            break
           end
         end
 
-        [rest, @actual_height]
+        [rest, reason]
       end
 
-      # Draws the text box onto the canvas with the top-left corner being at [x, y].
+      # Draws the layed out text onto the canvas with the top-left corner being at [x, y].
       #
       # Depending on the value of +fit+ the text may also be fitted:
       #
       # * If +true+, then #fit is always called.
-      # * If +:if_needed+, then #fit is only called if it has been called before.
+      # * If +:if_needed+, then #fit is only called if it has not been called before.
       # * If +false+, then #fit is never called.
       def draw(canvas, x, y, fit: :if_needed)
         self.fit if fit == true || (!@actual_height && fit == :if_needed)
@@ -649,7 +697,15 @@ module HexaPDF
           y -= initial_baseline_offset + @lines.first.y_offset
           @lines.each_with_index do |line, index|
             line_x = x + line.x_offset
-            line.each {|item, item_x, item_y| item.draw(canvas, line_x + item_x, y + item_y) }
+            line.each do |item, item_x, item_y|
+              if item.kind_of?(TextFragment)
+                item.draw(canvas, line_x + item_x, y + item_y)
+              elsif !item.empty?
+                canvas.restore_graphics_state
+                item.draw(canvas, line_x + item_x, y + item_y)
+                canvas.save_graphics_state
+              end
+            end
             y -= @lines[index + 1].y_offset if @lines[index + 1]
           end
         end
@@ -657,20 +713,19 @@ module HexaPDF
 
       private
 
-      # Returns the initial baseline offset from the top of the text box, based on the valign style
-      # option.
+      # Returns the initial baseline offset from the top, based on the valign style option.
       def initial_baseline_offset
         case style.valign
         when :top
           @lines.first.y_max
         when :center
           if @height == Float::INFINITY
-            raise HexaPDF::Error, "Can't vertically align a text box with unlimited height"
+            raise HexaPDF::Error, "Can't vertically align when using unlimited height"
           end
           (@height - @actual_height) / 2.0 + @lines.first.y_max
         when :bottom
           if @height == Float::INFINITY
-            raise HexaPDF::Error, "Can't vertically align a text box with unlimited height"
+            raise HexaPDF::Error, "Can't vertically align when using unlimited height"
           end
           (@height - @actual_height) + @lines.first.y_max
         end