hexapdf 0.5.0 → 0.6.0

data/test/hexapdf/layout/test_text_fragment.rb

@@ -9,7 +9,7 @@ require 'hexapdf/layout/text_fragment'
 describe HexaPDF::Layout::TextFragment do
   before do
     @doc = HexaPDF::Document.new
-    @font = @doc.fonts.load("Times", custom_encoding: true)
+    @font = @doc.fonts.add("Times", custom_encoding: true)
   end
 
   def setup_fragment(items, text_rise = 0)
@@ -27,24 +27,139 @@ describe HexaPDF::Layout::TextFragment do
     assert_equal(13.66 + 4.34, frag.height)
   end
 
+  describe "initialize" do
+    before do
+      @items = @font.decode_utf8("Tom")
+    end
+
+    it "can use a Style object" do
+      style = HexaPDF::Layout::Style.new(font: @font, font_size: 20)
+      frag = HexaPDF::Layout::TextFragment.new(items: @items, style: style)
+      assert_equal(20, frag.style.font_size)
+    end
+
+    it "can use a style options" do
+      frag = HexaPDF::Layout::TextFragment.new(items: @items, style: {font: @font, font_size: 20})
+      assert_equal(20, frag.style.font_size)
+    end
+  end
+
   it "returns :text for valign" do
     assert_equal(:text, setup_fragment([]).valign)
   end
 
-  it "draws the text onto the canvas" do
-    setup_fragment(@font.decode_utf8('H'), 2)
-    canvas = @doc.pages.add.canvas
-    @fragment.draw(canvas, 10, 15)
-    assert_operators(canvas.contents,
-                     [[:begin_text],
-                      [:set_text_matrix, [1, 0, 0, 1, 10, 15]],
-                      [:set_font_and_size, [:F1, 20]],
-                      [:set_leading, [24.0]],
-                      [:set_horizontal_scaling, [200]],
-                      [:set_character_spacing, [1]],
-                      [:set_word_spacing, [2]],
-                      [:set_text_rise, [2]],
-                      [:show_text_with_positioning, [['!']]]])
+  describe "draw" do
+    def setup_with_style(**styles)
+      setup_fragment(@font.decode_utf8('H'), 2)
+      styles.each {|name, value| @fragment.style.send(name, value)}
+      @canvas = @doc.pages.add.canvas
+      @fragment.draw(@canvas, 10, 15)
+    end
+
+    def assert_draw_operators(*args, front: [], middle: args, back: [])
+      ops = [
+        *front,
+        [:begin_text],
+        [:set_text_matrix, [1, 0, 0, 1, 10, 15]],
+        [:set_font_and_size, [:F1, 20]],
+        [:set_leading, [24.0]],
+        [:set_horizontal_scaling, [200]],
+        [:set_character_spacing, [1]],
+        [:set_word_spacing, [2]],
+        [:set_text_rise, [2]],
+        *middle,
+        [:show_text_with_positioning, [['!']]],
+        *back,
+      ].compact
+      assert_operators(@canvas.contents, ops)
+    end
+
+    it "draws text onto the canvas" do
+      setup_with_style
+      assert_draw_operators
+    end
+
+    it "draws styled filled text" do
+      setup_with_style(fill_color: 0.5, fill_alpha: 0.5)
+      assert_draw_operators([:set_graphics_state_parameters, [:GS1]],
+                            [:set_device_gray_non_stroking_color, [0.5]])
+      assert_equal({Type: :ExtGState, CA: 1, ca: 0.5}, @canvas.resources[:ExtGState][:GS1])
+    end
+
+    it "draws style stroked text" do
+      setup_with_style(text_rendering_mode: :stroke,
+                       stroke_color: [1.0, 0, 0], stroke_alpha: 0.5, stroke_width: 2,
+                       stroke_cap_style: :round, stroke_join_style: :round, stroke_miter_limit: 5,
+                       stroke_dash_pattern: [1, 2, 3])
+      assert_draw_operators([:set_text_rendering_mode, [1]],
+                            [:set_graphics_state_parameters, [:GS1]],
+                            [:set_device_rgb_stroking_color, [1, 0, 0]],
+                            [:set_line_width, [2]],
+                            [:set_line_cap_style, [1]],
+                            [:set_line_join_style, [1]],
+                            [:set_miter_limit, [5]],
+                            [:set_line_dash_pattern, [[1, 2, 3], 0]])
+      assert_equal({Type: :ExtGState, CA: 0.5, ca: 1}, @canvas.resources[:ExtGState][:GS1])
+    end
+
+    it "invokes the underlays" do
+      setup_with_style(underlays: [proc { @canvas.stroke_color(0.5) }])
+      assert_draw_operators(front: [[:save_graphics_state],
+                                    [:concatenate_matrix, [1, 0, 0, 1, 10, 15 + @fragment.y_min]],
+                                    [:save_graphics_state],
+                                    [:set_device_gray_stroking_color, [0.5]],
+                                    [:restore_graphics_state],
+                                    [:restore_graphics_state]])
+    end
+
+    it "invokes the overlays" do
+      setup_with_style(overlays: [proc { @canvas.stroke_color(0.5) }])
+      assert_draw_operators(back: [[:end_text],
+                                   [:save_graphics_state],
+                                   [:concatenate_matrix, [1, 0, 0, 1, 10, 15 + @fragment.y_min]],
+                                   [:save_graphics_state],
+                                   [:set_device_gray_stroking_color, [0.5]],
+                                   [:restore_graphics_state],
+                                   [:restore_graphics_state]])
+    end
+
+    it "draws the underline" do
+      setup_with_style(underline: true, text_rendering_mode: :stroke,
+                       stroke_width: 5, stroke_color: [0.5], stroke_cap_style: :round,
+                       stroke_dash_pattern: 5)
+      assert_draw_operators(middle: [[:set_text_rendering_mode, [1]],
+                                     [:set_device_gray_stroking_color, [0.5]],
+                                     [:set_line_width, [5]],
+                                     [:set_line_cap_style, [1]],
+                                     [:set_line_dash_pattern, [[5], 0]]],
+        back: [[:set_device_gray_stroking_color, [0]],
+               [:set_line_width, [@fragment.style.calculated_underline_thickness]],
+               [:set_line_cap_style, [0]],
+               [:set_line_dash_pattern, [[], 0]],
+               [:end_text],
+               [:move_to, [10, 15]],
+               [:line_to, [40.88, 15]],
+               [:stroke_path]])
+    end
+
+    it "draws the strikeout line" do
+      setup_with_style(strikeout: true, text_rendering_mode: :stroke,
+                       stroke_width: 5, stroke_color: [0.5], stroke_cap_style: :round,
+                       stroke_dash_pattern: 5)
+      assert_draw_operators(middle: [[:set_text_rendering_mode, [1]],
+                                     [:set_device_gray_stroking_color, [0.5]],
+                                     [:set_line_width, [5]],
+                                     [:set_line_cap_style, [1]],
+                                     [:set_line_dash_pattern, [[5], 0]]],
+        back: [[:set_device_gray_stroking_color, [0]],
+               [:set_line_width, [@fragment.style.calculated_strikeout_thickness]],
+               [:set_line_cap_style, [0]],
+               [:set_line_dash_pattern, [[], 0]],
+               [:end_text],
+               [:move_to, [10, 21.01]],
+               [:line_to, [40.88, 21.01]],
+               [:stroke_path]])
+    end
   end
 
   describe "empty fragment" do
@@ -75,6 +190,12 @@ describe HexaPDF::Layout::TextFragment do
     it "calculates the height" do
       assert_equal(13.66 + 4.34, @fragment.height)
     end
+
+    it "draws nothing" do
+      canvas = @doc.pages.add.canvas
+      @fragment.draw(canvas, 10, 15)
+      assert_operators(canvas.contents, [])
+    end
   end
 
   describe "normal text" do

data/test/hexapdf/layout/{test_text_box.rb → test_text_layouter.rb}

@@ -5,28 +5,28 @@ require 'hexapdf/layout'
 require 'hexapdf/document'
 require_relative "../content/common"
 
-module TestTextBoxHelpers
+module TestTextLayouterHelpers
   def boxes(*dims)
     dims.map do |width, height|
-      box = HexaPDF::Layout::InlineBox.new(width, height || 0) {}
-      HexaPDF::Layout::TextBox::Box.new(box)
+      box = HexaPDF::Layout::InlineBox.create(width: width, height: height || 0) {}
+      HexaPDF::Layout::TextLayouter::Box.new(box)
     end
   end
 
   def glue(width)
-    HexaPDF::Layout::TextBox::Glue.new(HexaPDF::Layout::InlineBox.new(width, 0) {})
+    HexaPDF::Layout::TextLayouter::Glue.new(HexaPDF::Layout::InlineBox.create(width: width) {})
   end
 
   def penalty(penalty, item = nil)
     if item
-      HexaPDF::Layout::TextBox::Penalty.new(penalty, item.width, item: item)
+      HexaPDF::Layout::TextLayouter::Penalty.new(penalty, item.width, item: item)
     else
-      HexaPDF::Layout::TextBox::Penalty.new(penalty)
+      HexaPDF::Layout::TextLayouter::Penalty.new(penalty)
     end
   end
 
   def assert_box(obj, item)
-    assert_kind_of(HexaPDF::Layout::TextBox::Box, obj)
+    assert_kind_of(HexaPDF::Layout::TextLayouter::Box, obj)
     if obj.item.kind_of?(HexaPDF::Layout::InlineBox)
       assert_same(item, obj.item)
     else
@@ -36,12 +36,12 @@ module TestTextBoxHelpers
   end
 
   def assert_glue(obj, fragment)
-    assert_kind_of(HexaPDF::Layout::TextBox::Glue, obj)
+    assert_kind_of(HexaPDF::Layout::TextLayouter::Glue, obj)
     assert_same(fragment.style, obj.item.style)
   end
 
   def assert_penalty(obj, penalty, item = nil)
-    assert_kind_of(HexaPDF::Layout::TextBox::Penalty, obj)
+    assert_kind_of(HexaPDF::Layout::TextLayouter::Penalty, obj)
     assert_equal(penalty, obj.penalty)
     if item
       assert_same(item.style, obj.item.style)
@@ -50,13 +50,13 @@ module TestTextBoxHelpers
   end
 end
 
-describe HexaPDF::Layout::TextBox::SimpleTextSegmentation do
-  include TestTextBoxHelpers
+describe HexaPDF::Layout::TextLayouter::SimpleTextSegmentation do
+  include TestTextLayouterHelpers
 
   before do
     @doc = HexaPDF::Document.new
-    @font = @doc.fonts.load("Times")
-    @obj = HexaPDF::Layout::TextBox::SimpleTextSegmentation
+    @font = @doc.fonts.add("Times")
+    @obj = HexaPDF::Layout::TextLayouter::SimpleTextSegmentation
   end
 
   def setup_fragment(text, style = nil)
@@ -68,7 +68,7 @@ describe HexaPDF::Layout::TextBox::SimpleTextSegmentation do
   end
 
   it "handles InlineBox objects" do
-    input = HexaPDF::Layout::InlineBox.new(10, 10) { }
+    input = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) { }
     result = @obj.call([input, input])
     assert_equal(2, result.size)
     assert_box(result[0], input)
@@ -103,13 +103,16 @@ describe HexaPDF::Layout::TextBox::SimpleTextSegmentation do
   end
 
   it "insert a mandatory break when an Unicode line boundary characters is encountered" do
-    frag = setup_fragment("A\rB\r\nC\nD\vE\fF\u{85}G\u{2028}H\u{2029}I")
+    frag = setup_fragment("A\rB\r\nC\nD\vE\fF\u{85}G\u{2029}H\u{2028}I")
 
     result = @obj.call([frag])
     assert_equal(17, result.size)
-    [1, 3, 5, 7, 9, 11, 13, 15].each do |index|
-      assert_penalty(result[index], HexaPDF::Layout::TextBox::Penalty::MandatoryBreak.penalty)
+    [1, 3, 5, 7, 9, 11, 13].each do |index|
+      assert_penalty(result[index],
+                     HexaPDF::Layout::TextLayouter::Penalty::MandatoryParagraphBreak.penalty)
     end
+    assert_penalty(result[15],
+                   HexaPDF::Layout::TextLayouter::Penalty::MandatoryLineBreak.penalty)
   end
 
   it "insert a standard penalty after a hyphen" do
@@ -118,7 +121,7 @@ describe HexaPDF::Layout::TextBox::SimpleTextSegmentation do
     result = @obj.call([frag])
     assert_equal(12, result.size)
     [1, 3, 5, 9].each do |index|
-      assert_penalty(result[index], HexaPDF::Layout::TextBox::Penalty::Standard.penalty)
+      assert_penalty(result[index], HexaPDF::Layout::TextLayouter::Penalty::Standard.penalty)
     end
   end
 
@@ -137,7 +140,7 @@ describe HexaPDF::Layout::TextBox::SimpleTextSegmentation do
 
     result = @obj.call([frag])
     assert_equal(3, result.size)
-    assert_penalty(result[1], HexaPDF::Layout::TextBox::Penalty::Standard.penalty, hyphen)
+    assert_penalty(result[1], HexaPDF::Layout::TextLayouter::Penalty::Standard.penalty, hyphen)
   end
 
   it "insert a prohibited break penalty for non-breaking spaces" do
@@ -146,16 +149,17 @@ describe HexaPDF::Layout::TextBox::SimpleTextSegmentation do
 
     result = @obj.call([frag])
     assert_equal(3, result.size)
-    assert_penalty(result[1], HexaPDF::Layout::TextBox::Penalty::ProhibitedBreak.penalty, space)
+    assert_penalty(result[1], HexaPDF::Layout::TextLayouter::Penalty::ProhibitedBreak.penalty, space)
   end
 end
 
 # Common tests for fixed and variable width line wrapping. The including class needs to define a
-# #call(items, width = 100) method with a default with of 100.
+# #call(items, width = 100) method with a default with of 100. The optional block is called after a
+# line has been yielded by the line wrapping algorithm.
 module CommonLineWrappingTests
   extend Minitest::Spec::DSL
 
-  include TestTextBoxHelpers
+  include TestTextLayouterHelpers
 
   it "breaks before a box if it doesn't fit onto the line anymore" do
     rest, lines = call(boxes(25, 50, 25, 10))
@@ -226,7 +230,7 @@ module CommonLineWrappingTests
   end
 
   it "handles breaking at penalties with non-zero width if they fit on the line" do
-    item = HexaPDF::Layout::InlineBox.new(20, 0) {}
+    item = HexaPDF::Layout::InlineBox.create(width: 20) {}
     rest, lines = call(boxes(20, 60, 30).insert(1, penalty(0, item)).insert(-2, penalty(0, item)))
     assert(rest.empty?)
     assert_equal(2, lines.count)
@@ -236,7 +240,7 @@ module CommonLineWrappingTests
   end
 
   it "handles penalties with non-zero width if they don't fit on the line" do
-    item = HexaPDF::Layout::InlineBox.new(20, 0) {}
+    item = HexaPDF::Layout::InlineBox.create(width: 20) {}
     rest, lines = call(boxes(70) + [glue(10)] + boxes(10) + [penalty(0, item)] + boxes(30))
     assert(rest.empty?)
     assert_equal(2, lines.count)
@@ -245,7 +249,7 @@ module CommonLineWrappingTests
   end
 
   it "handles breaking at prohibited breakpoints by back-tracking to the last valid breakpoint " do
-    item = HexaPDF::Layout::InlineBox.new(20, 0) {}
+    item = HexaPDF::Layout::InlineBox.create(width: 20) {}
     rest, lines = call(boxes(70) + [glue(10)] + boxes(10) + [penalty(5000, item)] + boxes(30))
     assert(rest.empty?)
     assert_equal(2, lines.count)
@@ -254,8 +258,8 @@ module CommonLineWrappingTests
   end
 
   it "stops when nil is returned by the block: last item is a box" do
-    lines = []
-    rest = @obj.call(boxes(20, 20, 20), 20) {|line| lines << line; lines.count > 1 ? nil : true}
+    done = false
+    rest, lines = call(boxes(20, 20, 20), 20) { done ? nil : done = true }
     assert_equal(2, rest.count)
     assert_equal(2, lines.count)
   end
@@ -263,37 +267,38 @@ module CommonLineWrappingTests
   it "stops when nil is returned by the block: last item is a glue" do
     done = false
     items = boxes(20, 15, 20).insert(-2, glue(10))
-    rest = @obj.call(items, 20) { done ? nil : (done = true; 20) }
+    rest, = call(items, 20) { done ? nil : done = true }
     assert_equal(3, rest.count)
     assert_equal(15, rest[0].width)
   end
 
   it "stops when nil is returned by the block: last item is a mandatory break penalty" do
     items = boxes(20, 20).insert(-2, penalty(-5000))
-    rest = @obj.call(items, 20) { nil }
+    rest, = call(items, 20) { nil }
     assert_equal(3, rest.count)
   end
 
   it "stops when nil is returned by the block: works for the last line" do
-    lines = []
-    rest = @obj.call(boxes(20, 20), 20) {|line| lines << line; lines.count > 1 ? nil : true}
+    done = false
+    rest, lines = call(boxes(20, 20), 20) { done ? nil : done = true }
     assert_equal(1, rest.count)
     assert_equal(2, lines.count)
   end
 
 end
 
-describe HexaPDF::Layout::TextBox::SimpleLineWrapping do
+describe HexaPDF::Layout::TextLayouter::SimpleLineWrapping do
   before do
-    @obj = HexaPDF::Layout::TextBox::SimpleLineWrapping
+    @obj = HexaPDF::Layout::TextLayouter::SimpleLineWrapping
   end
 
   describe "fixed width wrapping" do
     include CommonLineWrappingTests
 
-    def call(items, width = 100)
+    def call(items, width = 100, &block)
       lines = []
-      rest = @obj.call(items, width) {|line, _| lines << line; true }
+      block ||= proc { true }
+      rest = @obj.call(items, proc { width }) {|line, item| lines << line; block.call(line, item) }
       [rest, lines]
     end
   end
@@ -301,9 +306,10 @@ describe HexaPDF::Layout::TextBox::SimpleLineWrapping do
   describe "variable width wrapping" do
     include CommonLineWrappingTests
 
-    def call(items, width = proc { 100 })
+    def call(items, width = 100, &block)
       lines = []
-      rest = @obj.call(items, width) {|line, _| lines << line; true }
+      block ||= proc { true }
+      rest = @obj.call(items, proc {|_| width }) {|line, i| lines << line; block.call(line, i) }
       [rest, lines]
     end
 
@@ -339,7 +345,7 @@ describe HexaPDF::Layout::TextBox::SimpleLineWrapping do
         end
       end
       lines = []
-      item = HexaPDF::Layout::InlineBox.new(20, 10) {}
+      item = HexaPDF::Layout::InlineBox.create(width: 20, height: 10) {}
       items = boxes([20, 10]) + [penalty(0, item)] + boxes([40, 15])
       rest = @obj.call(items, width_block) do |line|
         height += line.height
@@ -355,93 +361,121 @@ describe HexaPDF::Layout::TextBox::SimpleLineWrapping do
   end
 end
 
-describe HexaPDF::Layout::TextBox do
-  include TestTextBoxHelpers
+describe HexaPDF::Layout::TextLayouter do
+  include TestTextLayouterHelpers
 
   before do
     @doc = HexaPDF::Document.new
-    @font = @doc.fonts.load("Times")
+    @font = @doc.fonts.add("Times")
     @style = HexaPDF::Layout::Style.new(font: @font)
   end
 
   it "creates an instance from text and options" do
-    box = HexaPDF::Layout::TextBox.create("T", font: @font, width: 100, height: 100)
-    assert_equal(1, box.items.length)
-    assert_equal(@font.decode_utf8("T"), box.items[0].item.items)
+    layouter = HexaPDF::Layout::TextLayouter.create("T", font: @font, width: 100, height: 100)
+    assert_equal(1, layouter.items.length)
+    assert_equal(@font.decode_utf8("T"), layouter.items[0].item.items)
+  end
+
+  describe "initialize" do
+    it "can use a Style object" do
+      style = HexaPDF::Layout::Style.new(font: @font, font_size: 20)
+      layouter = HexaPDF::Layout::TextLayouter.new(items: [], width: 10, style: style)
+      assert_equal(20, layouter.style.font_size)
+    end
+
+    it "can use a style options" do
+      layouter = HexaPDF::Layout::TextLayouter.new(items: [], width: 10, style:
+                                                   {font: @font, font_size: 20})
+      assert_equal(20, layouter.style.font_size)
+    end
   end
 
   it "doesn't run the text segmentation algorithm on already segmented items" do
-    item = HexaPDF::Layout::InlineBox.new(20, 0) {}
-    box = HexaPDF::Layout::TextBox.new(items: [item], width: 100, height: 100)
-    items = box.items
+    item = HexaPDF::Layout::InlineBox.create(width: 20) {}
+    layouter = HexaPDF::Layout::TextLayouter.new(items: [item], width: 100, height: 100)
+    items = layouter.items
     assert_equal(1, items.length)
     assert_box(items[0], item)
 
-    box.items = items
-    assert_same(items, box.items)
+    layouter.items = items
+    assert_same(items, layouter.items)
   end
 
   describe "fit" do
     it "handles text indentation" do
-      box = HexaPDF::Layout::TextBox.new(items: boxes([20, 20], [20, 20], [20, 20]), width: 60,
-                                         style: @style)
-      box.style.text_indent = 20
-      rest, height = box.fit
-      assert_equal(60, box.lines[0].width)
-      assert_equal(20, box.lines[1].width)
-      assert(rest.empty?)
-      assert_equal(40, height)
+      items = boxes([20, 20], [20, 20], [20, 20]) +
+        [HexaPDF::Layout::TextLayouter::Penalty::MandatoryParagraphBreak] +
+        boxes([40, 20]) + [glue(20)] +
+        boxes(*([[20, 20]] * 4)) + [HexaPDF::Layout::TextLayouter::Penalty::MandatoryLineBreak] +
+        boxes(*([[20, 20]] * 4))
+      @style.text_indent = 20
+
+      [60, proc { 60 }].each do |width|
+        layouter = HexaPDF::Layout::TextLayouter.new(items: items, width: width, style: @style)
+        rest, reason = layouter.fit
+        assert_equal([40, 20, 40, 60, 20, 60, 20], layouter.lines.map(&:width))
+        assert_equal([20, 0, 20, 0, 0, 0, 0], layouter.lines.map(&:x_offset))
+        assert(rest.empty?)
+        assert_equal(:success, reason)
+      end
     end
 
     it "fits using unlimited height" do
-      box = HexaPDF::Layout::TextBox.new(items: boxes(*([[20, 20]] * 100)), width: 20,
-                                         style: @style)
-      rest, height = box.fit
+      layouter = HexaPDF::Layout::TextLayouter.new(items: boxes(*([[20, 20]] * 100)), width: 20,
+                                                   style: @style)
+      rest, reason = layouter.fit
       assert(rest.empty?)
-      assert_equal(20 * 100, height)
+      assert_equal(:success, reason)
+      assert_equal(20 * 100, layouter.actual_height)
     end
 
     it "fits using a limited height" do
-      box = HexaPDF::Layout::TextBox.new(items: boxes(*([[20, 20]] * 100)), width: 20, height: 100,
-                                         style: @style)
-      rest, height = box.fit
+      layouter = HexaPDF::Layout::TextLayouter.new(items: boxes(*([[20, 20]] * 100)), width: 20,
+                                                   height: 100, style: @style)
+      rest, reason = layouter.fit
       assert_equal(95, rest.count)
-      assert_equal(100, height)
+      assert_equal(:height, reason)
+      assert_equal(100, layouter.actual_height)
     end
 
     it "takes line spacing into account when calculating the height" do
-      box = HexaPDF::Layout::TextBox.new(items: boxes(*([[20, 20]] * 5)), width: 20, style: @style)
-      box.style.line_spacing = :double
-      rest, height = box.fit
+      layouter = HexaPDF::Layout::TextLayouter.new(items: boxes(*([[20, 20]] * 5)), width: 20,
+                                                   style: @style)
+      layouter.style.line_spacing = :double
+      rest, reason = layouter.fit
       assert(rest.empty?)
-      assert_equal(20 * (5 + 4), height)
+      assert_equal(:success, reason)
+      assert_equal(20 * (5 + 4), layouter.actual_height)
     end
 
     it "handles empty lines" do
       items = boxes([20, 20]) + [penalty(-5000)] + boxes([30, 20]) + [penalty(-5000)] * 2 +
         boxes([20, 20]) + [penalty(-5000)] * 2
-      box = HexaPDF::Layout::TextBox.new(items: items, width: 30, style: @style)
-      rest, height = box.fit
+      layouter = HexaPDF::Layout::TextLayouter.new(items: items, width: 30, style: @style)
+      rest, reason = layouter.fit
       assert(rest.empty?)
-      assert_equal(5, box.lines.count)
-      assert_equal(20 + 20 + 9 + 20 + 9, height)
+      assert_equal(:success, reason)
+      assert_equal(5, layouter.lines.count)
+      assert_equal(20 + 20 + 9 + 20 + 9, layouter.actual_height)
     end
 
     describe "fixed width" do
       it "stops if an item is wider than the available width, with unlimited height" do
-        box = HexaPDF::Layout::TextBox.new(items: boxes([20, 20], [50, 20]), width: 30,
-                                           style: @style)
-        rest, height = box.fit
+        layouter = HexaPDF::Layout::TextLayouter.new(items: boxes([20, 20], [50, 20]), width: 30,
+                                                     style: @style)
+        rest, reason = layouter.fit
         assert_equal(1, rest.count)
-        assert_equal(20, height)
+        assert_equal(:box, reason)
+        assert_equal(20, layouter.actual_height)
       end
 
-      it "stops if an item is wider than the available width, with limited height" do
-        box = HexaPDF::Layout::TextBox.new(items: boxes([20, 20], [50, 20]), width: 30, height: 100,
-                                           style: @style)
-        rest, height = box.fit
+      it "stops if a box item is wider than the available width, with limited height" do
+        layouter = HexaPDF::Layout::TextLayouter.new(items: boxes([20, 20], [50, 20]), width: 30,
+                                                     height: 100, style: @style)
+        rest, reason = layouter.fit
         assert_equal(1, rest.count)
-        assert_equal(20, height)
+        assert_equal(:box, reason)
+        assert_equal(20, layouter.actual_height)
       end
     end
 
@@ -453,13 +487,14 @@ describe HexaPDF::Layout::TextBox do
           else 40
           end
         end
-        box = HexaPDF::Layout::TextBox.new(items: boxes([20, 18]), width: width_block,
-                                           height: 100, style: @style)
-        rest, height = box.fit
+        layouter = HexaPDF::Layout::TextLayouter.new(items: boxes([20, 18]), width: width_block,
+                                                     height: 100, style: @style)
+        rest, reason = layouter.fit
         assert(rest.empty?)
-        assert_equal(1, box.lines.count)
-        assert_equal(24, box.lines[0].y_offset)
-        assert_equal(42, height)
+        assert_equal(:success, reason)
+        assert_equal(1, layouter.lines.count)
+        assert_equal(24, layouter.lines[0].y_offset)
+        assert_equal(42, layouter.actual_height)
       end
 
       it "searches for a vertical offset if an item is wider than the available width" do
@@ -470,52 +505,75 @@ describe HexaPDF::Layout::TextBox do
             40
           end
         end
-        box = HexaPDF::Layout::TextBox.new(items: boxes(*([[20, 18]] * 7)), width: width_block,
-                                           height: 100, style: @style)
-        rest, height = box.fit
+        layouter = HexaPDF::Layout::TextLayouter.new(items: boxes(*([[20, 18]] * 7)),
+                                                     width: width_block, height: 100, style: @style)
+        rest, reason = layouter.fit
         assert_equal(1, rest.count)
-        assert_equal(3, box.lines.count)
-        assert_equal(0, box.lines[0].y_offset)
-        assert_equal(18, box.lines[1].y_offset)
-        assert_equal(48, box.lines[2].y_offset)
-        assert_equal(84, height)
+        assert_equal(:height, reason)
+        assert_equal(3, layouter.lines.count)
+        assert_equal(0, layouter.lines[0].y_offset)
+        assert_equal(18, layouter.lines[1].y_offset)
+        assert_equal(48, layouter.lines[2].y_offset)
+        assert_equal(84, layouter.actual_height)
+      end
+    end
+
+    it "breaks a text fragment into parts if it is wider than the available width" do
+      [100, nil].each do |height|
+        str = " Thisisaverylongstring"
+        frag = HexaPDF::Layout::TextFragment.create(str, font: @font)
+        layouter = HexaPDF::Layout::TextLayouter.new(items: [frag], width: 20, height: height,
+                                                     style: @style)
+        rest, reason = layouter.fit
+        assert(rest.empty?)
+        assert_equal(:success, reason)
+        assert_equal(str.strip.length, layouter.lines.sum {|l| l.items.sum {|i| i.items.count}})
+        assert_equal(45, layouter.actual_height)
+
+        layouter = HexaPDF::Layout::TextLayouter.new(items: [frag], width: 1, height: height,
+                                                     style: @style)
+        rest, reason = layouter.fit
+        assert_equal(str.strip.length, rest.count)
+        assert_equal(:box, reason)
       end
     end
 
     it "post-processes lines for justification if needed" do
       frag10 = HexaPDF::Layout::TextFragment.create(" ", font: @font)
       frag10.items.freeze
-      frag10b = HexaPDF::Layout::TextBox::Box.new(frag10)
+      frag10b = HexaPDF::Layout::TextLayouter::Box.new(frag10)
       frag20 = HexaPDF::Layout::TextFragment.create(" ", font: @font, font_size: 20)
-      frag20b = HexaPDF::Layout::TextBox::Box.new(frag20)
+      frag20b = HexaPDF::Layout::TextLayouter::Box.new(frag20)
       items = boxes(20, 20, 20, 20, 30).insert(1, frag10b).insert(3, frag20b).insert(5, frag10b)
       # Width of spaces: 2.5 * 2 + 5 = 10  (from AFM file, adjusted for font size)
       # Line width: 20 * 4 + width_of_spaces = 90
       # Missing width: 100 - 90 = 10
       # -> Each space must be doubled!
 
-      box = HexaPDF::Layout::TextBox.new(items: items, width: 100)
-      box.style.align = :justify
-      rest, _height = box.fit
+      layouter = HexaPDF::Layout::TextLayouter.new(items: items, width: 100)
+      layouter.style.align = :justify
+      rest, reason = layouter.fit
       assert(rest.empty?)
-      assert_equal(9, box.lines[0].items.count)
-      assert_in_delta(100, box.lines[0].width)
-      assert_equal(-250, box.lines[0].items[1].items[0])
-      assert_equal(-250, box.lines[0].items[4].items[0])
-      assert_equal(-250, box.lines[0].items[6].items[0])
-      assert_equal(30, box.lines[1].width)
+      assert_equal(:success, reason)
+      assert_equal(9, layouter.lines[0].items.count)
+      assert_in_delta(100, layouter.lines[0].width)
+      assert_equal(-250, layouter.lines[0].items[1].items[0])
+      assert_equal(-250, layouter.lines[0].items[4].items[0])
+      assert_equal(-250, layouter.lines[0].items[6].items[0])
+      assert_equal(30, layouter.lines[1].width)
     end
 
     it "applies the optional horizontal offsets if set" do
       x_offsets = lambda {|height, line_height| height + line_height}
-      box = HexaPDF::Layout::TextBox.new(items: boxes(*([[20, 10]] * 7)), width: 60,
-                                         x_offsets: x_offsets, height: 100, style: @style)
-      rest, height = box.fit
+      layouter = HexaPDF::Layout::TextLayouter.new(items: boxes(*([[20, 10]] * 7)), width: 60,
+                                                   x_offsets: x_offsets, height: 100, style: @style)
+      rest, reason = layouter.fit
       assert(rest.empty?)
-      assert_equal(30, height)
-      assert_equal(10, box.lines[0].x_offset)
-      assert_equal(20, box.lines[1].x_offset)
-      assert_equal(30, box.lines[2].x_offset)
+      assert_equal(:success, reason)
+      assert_equal(30, layouter.actual_height)
+      assert_equal(10, layouter.lines[0].x_offset)
+      assert_equal(20, layouter.lines[1].x_offset)
+      assert_equal(30, layouter.lines[2].x_offset)
     end
   end
 
@@ -535,7 +593,7 @@ describe HexaPDF::Layout::TextBox do
       @frag = HexaPDF::Layout::TextFragment.create("This is some more text.\n" \
                                                    "This is some more text.", font: @font)
       @width = HexaPDF::Layout::TextFragment.create("This is some   ", font: @font).width
-      @box =  HexaPDF::Layout::TextBox.new(items: [@frag], width: @width)
+      @layouter = HexaPDF::Layout::TextLayouter.new(items: [@frag], width: @width)
       @canvas = @doc.pages.add.canvas
 
       @line1w = HexaPDF::Layout::TextFragment.create("This is some", font: @font).width
@@ -544,8 +602,8 @@ describe HexaPDF::Layout::TextBox do
 
     it "can horizontally align the contents to the left" do
       top = 100
-      @box.style.align = :left
-      @box.draw(@canvas, 5, top)
+      @layouter.style.align = :left
+      @layouter.draw(@canvas, 5, top)
       assert_positions(@canvas.contents,
                        [[5, top - @frag.y_max],
                         [5, top - @frag.y_max - @frag.height],
@@ -555,8 +613,8 @@ describe HexaPDF::Layout::TextBox do
 
     it "can horizontally align the contents to the center" do
       top = 100
-      @box.style.align = :center
-      @box.draw(@canvas, 5, top)
+      @layouter.style.align = :center
+      @layouter.draw(@canvas, 5, top)
       assert_positions(@canvas.contents,
                        [[5 + (@width - @line1w) / 2, top - @frag.y_max],
                         [5 + (@width - @line2w) / 2, top - @frag.y_max - @frag.height],
@@ -566,8 +624,8 @@ describe HexaPDF::Layout::TextBox do
 
     it "can horizontally align the contents to the right" do
       top = 100
-      @box.style.align = :right
-      @box.draw(@canvas, 5, top)
+      @layouter.style.align = :right
+      @layouter.draw(@canvas, 5, top)
       assert_positions(@canvas.contents,
                        [[5 + @width - @line1w, top - @frag.y_max],
                         [5 + @width - @line2w, top - @frag.y_max - @frag.height],
@@ -577,32 +635,32 @@ describe HexaPDF::Layout::TextBox do
 
     it "can justify the contents" do
       top = 100
-      @box.style.align = :justify
-      @box.draw(@canvas, 5, top)
+      @layouter.style.align = :justify
+      @layouter.draw(@canvas, 5, top)
       assert_positions(@canvas.contents,
                        [[5, top - @frag.y_max],
                         [5, top - @frag.y_max - @frag.height],
                         [5, top - @frag.y_max - @frag.height * 2],
                         [5, top - @frag.y_max - @frag.height * 3]])
-      assert_in_delta(@width, @box.lines[0].width, 0.0001)
-      assert_in_delta(@width, @box.lines[2].width, 0.0001)
+      assert_in_delta(@width, @layouter.lines[0].width, 0.0001)
+      assert_in_delta(@width, @layouter.lines[2].width, 0.0001)
     end
 
     it "doesn't justify lines ending in a mandatory break or the last line" do
-      @box.style.align = :justify
-      @box.draw(@canvas, 5, 100)
-      assert_equal(@line2w, @box.lines[1].width, 0.0001)
-      assert_equal(@line2w, @box.lines[3].width, 0.0001)
+      @layouter.style.align = :justify
+      @layouter.draw(@canvas, 5, 100)
+      assert_equal(@line2w, @layouter.lines[1].width, 0.0001)
+      assert_equal(@line2w, @layouter.lines[3].width, 0.0001)
     end
 
     it "can vertically align the contents in the center" do
       top = 100
-      @box = HexaPDF::Layout::TextBox.new(items: [@frag], width: @width, height: top)
-      @box.style.valign = :center
+      @layouter = HexaPDF::Layout::TextLayouter.new(items: [@frag], width: @width, height: top)
+      @layouter.style.valign = :center
 
-      _, height = @box.fit
-      initial_baseline = top - ((top - height) / 2) - @frag.y_max
-      @box.draw(@canvas, 5, top)
+      @layouter.fit
+      initial_baseline = top - ((top - @layouter.actual_height) / 2) - @frag.y_max
+      @layouter.draw(@canvas, 5, top)
       assert_positions(@canvas.contents,
                        [[5, initial_baseline],
                         [5, initial_baseline - @frag.height],
@@ -612,12 +670,12 @@ describe HexaPDF::Layout::TextBox do
 
     it "can vertically align the contents to the bottom" do
       top = 100
-      @box = HexaPDF::Layout::TextBox.new(items: [@frag], width: @width, height: top)
-      @box.style.valign = :bottom
+      @layouter = HexaPDF::Layout::TextLayouter.new(items: [@frag], width: @width, height: top)
+      @layouter.style.valign = :bottom
 
-      _, height = @box.fit
-      initial_baseline = height - @frag.y_max
-      @box.draw(@canvas, 5, top)
+      @layouter.fit
+      initial_baseline = @layouter.actual_height - @frag.y_max
+      @layouter.draw(@canvas, 5, top)
       assert_positions(@canvas.contents,
                        [[5, initial_baseline],
                         [5, initial_baseline - @frag.height],
@@ -626,15 +684,37 @@ describe HexaPDF::Layout::TextBox do
     end
 
     it "raises an error if vertical alignment is :center/:bottom and an unlimited height is used" do
-      @box = HexaPDF::Layout::TextBox.new(items: [@frag], width: @width)
+      @layouter = HexaPDF::Layout::TextLayouter.new(items: [@frag], width: @width)
       assert_raises(HexaPDF::Error) do
-        @box.style.valign = :center
-        @box.draw(@canvas, 0, 0)
+        @layouter.style.valign = :center
+        @layouter.draw(@canvas, 0, 0)
       end
       assert_raises(HexaPDF::Error) do
-        @box.style.valign = :bottom
-        @box.draw(@canvas, 0, 0)
+        @layouter.style.valign = :bottom
+        @layouter.draw(@canvas, 0, 0)
       end
     end
+
+    it "makes sure that text fragments don't pollute the graphics state for inline boxes" do
+      frag = HexaPDF::Layout::TextFragment.create("Demo", font: @font)
+      inline_box = HexaPDF::Layout::InlineBox.create(width: 10, height: 10) {|c, _| c.text("A")}
+      layouter = HexaPDF::Layout::TextLayouter.new(items: [frag, inline_box], width: 200)
+      assert_raises(HexaPDF::Error) { layouter.draw(@canvas, 0, 0) }
+    end
+
+    it "doesn't do unnecessary work for placeholder boxes" do
+      box1 = HexaPDF::Layout::InlineBox.create(width: 10, height: 20)
+      box2 = HexaPDF::Layout::InlineBox.create(width: 30, height: 40) { @canvas.line_width(2) }
+      layouter = HexaPDF::Layout::TextLayouter.new(items: [box1, box2], width: 200)
+      layouter.draw(@canvas, 0, 0)
+      assert_operators(@canvas.contents, [[:save_graphics_state],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:concatenate_matrix, [1, 0, 0, 1, 10, -40]],
+                                          [:set_line_width, [2]],
+                                          [:restore_graphics_state],
+                                          [:save_graphics_state],
+                                          [:restore_graphics_state]])
+    end
   end
 end