hexapdf 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d9818c9cdb9673d2349c392e35b0b1460841a9d
-  data.tar.gz: cef36589c13850c4b3c1fd6fa976fb605a536bff
+  metadata.gz: 401d9b20b7b9305c334bad4951cb403ea6f4c919
+  data.tar.gz: 40cd8335bd517c1f772c3a26ebf8bb0c7a257492
 SHA512:
-  metadata.gz: e174684958b97a165844e15fdb458172c095cc4c8c1d3a2cfce9a73bd9a3bc1d367e34195d8fbe729cb61b1b71a2ab0dca0fbd91e19cc408510107fafa5c0518
-  data.tar.gz: 27a927ffbd911851187867ae59afbb31b0edabfb2edb6912b682e5af9236711aa51edc683304b0a4b6cdbfba6dd736fee8b6c11766afd8e1b631dc35c04cce30
+  metadata.gz: 1697291f44f1b7882d0b489af252b8b9cdcaae9416c770f88f325833e75f18ac6d1ef0f8fd03a47af76f1b1451475a97993f97381117e3d3c4df6a592b1e4d4d
+  data.tar.gz: a52680e4ad7f3a7568115e8d4657a1c934f9273e0ef513b023d48570d887ba4b748be4ac91ed2162a0d88f07ca08e63ae7dba7b1fa8c33692e7d6e8bc63dd09d

data/CHANGELOG.md

@@ -1,9 +1,83 @@
+## 0.6.0 - 2017-10-27
+
+### Added
+
+* [HexaPDF::Layout::Box] as base class for all layout boxes
+* More styling properties for [HexaPDF::Layout::Style]
+* Methods for checking whether styling properties in [HexaPDF::Layout::Style]
+  have been accessed or set
+* [HexaPDF::FontLoader::FromFile] to allow specifying a font file directly
+* Configuration option 'page.default_media_orientation' for settig the default
+  orientation of new pages
+* Convenience methods for getting underline and strikeout properties from fonts
+* Configuration option 'style.layers_map' for pre-defining overlay and underlay
+  callback objects for [HexaPDF::Layout::Style]
+* [HexaPDF::Type::Action] as well as specific implementations for the GoTo,
+  GoToR, Launch and URI actions
+* [HexaPDF::Type::Annotation] as well as specific implementations for the Text
+  Link annotations
+* [HexaPDF::Layout::Style::LinkLayer] for easy adding of in-document, URI and
+  file links
+
+### Changed
+
+* [HexaPDF::Layout::TextFragment] to support more styling properties
+* Cross-reference subsection parsing can handle missing whitespace
+* Renamed HexaPDF::Layout::LineFragment to [HexaPDF::Layout::Line]
+* Renamed HexaPDF::Layout::TextBox to [HexaPDF::Layout::TextLayouter]
+* [HexaPDF::Layout::TextFragment::new] and
+  [HexaPDF::Layout::TextLayouter::new] to either take a Style object or
+  style options
+* [HexaPDF::Layout::TextLayouter#fit] method signature
+* [HexaPDF::Layout::InlineBox] to wrap a generic box
+* HexaPDF::Document::Fonts#load to [HexaPDF::Document::Fonts#add] for
+  consistency
+* [HexaPDF::Document::Pages#add] to allow setting the paper orientation when
+  creating new pages
+* [HexaPDF::Filter::Predictor] to allow correcting some common problems
+  depending on the new configuration option 'filter.predictor.strict'
+* Moved configuration options 'encryption.aes', 'encryption.arc4',
+  'encryption.filter_map', 'encryption.sub_filter.map', 'filter.map',
+  'image_loader' and 'task.map' to the document specific configuration object
+* [HexaPDF::Configuration#constantize] can now dig into hierarchical values
+* [HexaPDF::Document#wrap] class resolution and configuration option structure
+  of 'object.subtype_map'
+
+### Removed
+
+* HexaPDF::Dictionary#to_hash method
+
+### Fixed
+
+* [HexaPDF::Layout::TextLayouter#fit] to split text fragment into parts if the
+  fragment doesn't fit on an empty line
+* Parsing of PDF files containing a loop with respect to cross-reference tables
+* [HexaPDF::Layout::InlineBox] to act as placeholder if no drawing block is
+  given
+* Undefined method error in [HexaPDF::Content::Canvas] by raising a proper error
+* Invalid handling of fonts by [HexaPDF::Content::Canvas] when saving and
+  restoring the graphics state
+* [HexaPDF::Layout::TextLayouter] so that text fragments don't pollute the
+  graphics state
+* [HexaPDF::Content::Operator::SetTextRenderingMode] to normalize the value
+* [HexaPDF::Stream#stream_source] to always return a decrypted stream
+* [HexaPDF::Layout::TextLayouter] to correctly indent all paragraphs, not just
+  the first one
+* One-off error in [HexaPDF::Filter::LZWDecode]
+* [HexaPDF::Configuration#merge] to duplicate array values to avoid unwanted
+  modifications
+* [HexaPDF::Dictionary#key?] to return false if the key is present but nil
+* [HexaPDF::DictionaryFields::FileSpecificationConverter] to convert hash and
+  dictionaries
+* Field /F definition in [HexaPDF::Stream]
+
+
 ## 0.5.0 - 2017-06-24
 
 ### Added
 
-* [HexaPDF::Layout::TextBox] for easy positioning and layouting of text
-* [HexaPDF::Layout::LineFragment] for single text line layout calculations
+* HexaPDF::Layout::TextBox for easy positioning and layouting of text
+* HexaPDF::Layout::LineFragment for single text line layout calculations
 * [HexaPDF::Layout::TextShaper] for text shaping functionality
 * [HexaPDF::Layout::TextFragment] for basic text metrics calculations
 * [HexaPDF::Layout::InlineBox] for fixed size inline graphics

data/CONTRIBUTERS

@@ -1,3 +1,3 @@
   Count Name
 ======= ====
-    802 Thomas Leitner <t_leitner@gmx.at>
+    882 Thomas Leitner <t_leitner@gmx.at>

data/Rakefile

@@ -66,7 +66,7 @@ namespace :dev do
     s.default_executable = 'hexapdf'
     s.add_dependency('cmdparse', '~> 3.0', '>= 3.0.3')
     s.add_development_dependency('kramdown', '~> 1.0', '>= 1.13.0')
-    s.required_ruby_version = '>= 2.3'
+    s.required_ruby_version = '>= 2.4'
 
     s.author = 'Thomas Leitner'
     s.email = 't_leitner@gmx.at'

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.0

data/examples/boxes.rb

@@ -0,0 +1,68 @@
+# ## Boxes
+#
+# The [HexaPDF::Layout::Box] class is used as the basis for all document layout
+# features.
+#
+# This example shows the basic properties that are available for all boxes, like
+# paddings, borders and and background color. It is also possible to use the
+# underlay and overlay callbacks with boxes.
+#
+# Usage:
+# : `ruby boxes.rb`
+#
+
+require 'hexapdf'
+
+doc = HexaPDF::Document.new
+
+annotate_box = lambda do |canvas, box|
+  text = ""
+  canvas.font("Times", size: 6)
+
+  if (data = box.style.padding)
+    text << "Padding (TRBL): #{data.top}, #{data.right}, #{data.bottom}, #{data.left}\n"
+  end
+  unless box.style.border.none?
+    data = box.style.border.width
+    text << "Border Width (TRBL): #{data.top}, #{data.right}, #{data.bottom}, #{data.left}\n"
+    data = box.style.border.color
+    text << "Border Color (TRBL):\n* #{data.top}\n* #{data.right}\n* #{data.bottom}\n* #{data.left}\n"
+    data = box.style.border.style
+    text << "Border Style (TRBL):\n* #{data.top}\n* #{data.right}\n* #{data.bottom}\n* #{data.left}\n"
+  end
+
+  canvas.line_width(0.1).rectangle(0, 0, box.content_width, box.content_height).stroke
+  canvas.text(text, at: [0, box.content_height - 10])
+end
+
+canvas = doc.pages.add.canvas
+
+[[1, 200], [5, 220], [15, 240]].each_with_index do |(width, red), row|
+  [[:solid, 180], [:dashed, 200], [:dashed_round, 220],
+   [:dotted, 240]].each_with_index do |(style, green), column|
+    box = HexaPDF::Layout::Box.new(content_width: 100, content_height: 100, &annotate_box)
+    box.style.border(width: width, style: style)
+    box.style.background_color([red, green, 0])
+    box.draw(canvas, 20 + 140 * column, 700 - 150 * row)
+  end
+end
+
+# The whole kitchen sink
+box = HexaPDF::Layout::Box.new(content_width: 470, content_height: 200, &annotate_box)
+box.style.background_color([255, 255, 180])
+box.style.padding([20, 5, 10, 15])
+box.style.border(width: [20, 40, 30, 15],
+                 color: [[46, 185, 206], [206, 199, 46], [188, 46, 206], [59, 206, 46]],
+                 style: [:solid, :dashed, :dashed_round, :dotted])
+box.style.underlays.add do |canv, _|
+  canv.stroke_color([255, 0, 0]).line_width(10).line_cap_style(:butt).
+    line(0, 0, box.width, box.height).line(0, box.height, box.width, 0).
+    stroke
+end
+box.style.overlays.add do |canv, _|
+  canv.stroke_color([0, 0, 255]).line_width(5).
+    rectangle(10, 10, box.width - 20, box.height - 20).stroke
+end
+box.draw(canvas, 20, 100)
+
+doc.write("boxes.pdf", optimize: true)

data/examples/graphics.rb

@@ -250,26 +250,26 @@ canvas.translate(0, 80) do
   end
 end
 
-# Reusing the already draw graphics for an XObject
-# Note that converting the page to a form XObject automatically closes all open
-# graphics states, therefore this can't be inside the above Canvas#translate
-# call
-form = doc.add(page.to_form_xobject(reference: false))
-canvas.rectangle(480, 80, form.box.width * (100 / form.box.height.to_f), 100).stroke
-canvas.xobject(form, at: [480, 80], height: 100)
-
 # A simple rainbow color band
 canvas.translate(0, 20) do
-  canvas.line_width = 10
-  freq = 0.3
-  0.upto(50) do |i|
+  canvas.line_width = 6
+  freq = 0.1
+  0.upto(100) do |i|
     r = Math.sin(freq * i) * 127 + 128
     g = Math.sin(freq * i + 2) * 127 + 128
     b = Math.sin(freq * i + 4) * 127 + 128
     canvas.stroke_color(r.to_i, g.to_i, b.to_i)
-    canvas.line(50 + i * 10, 0, 50 + i * 10, 40)
+    canvas.line(50 + i * 5, 0, 50 + i * 5, 40)
     canvas.stroke
   end
 end
 
+# Reusing the already draw graphics for an XObject
+# Note that converting the page to a form XObject automatically closes all open
+# graphics states, therefore this can't be inside the above Canvas#translate
+# call
+form = doc.add(page.to_form_xobject(reference: false))
+canvas.rectangle(480, 80, form.box.width * (100 / form.box.height.to_f), 100).stroke
+canvas.xobject(form, at: [480, 80], height: 100)
+
 doc.write('graphics.pdf', optimize: true)

data/examples/{text_box_alignment.rb → text_layouter_alignment.rb}

@@ -1,15 +1,15 @@
-# ## Text Box Alignment
+# ## Text Layouter - Alignment
 #
-# The [HexaPDF::Layout::TextBox] class can be used to easily lay out text inside
-# a rectangular area, with various horizontal and vertical alignment options.
+# The [HexaPDF::Layout::TextLayouter] class can be used to easily lay out text
+# inside a rectangular area, with various horizontal and vertical alignment
+# options.
 #
-# The text inside the box can be aligned horizontally by setting
-# [HexaPDF::Layout::Style#align] and vertically by
-# [HexaPDF::Layout::Style#valign]. In this example, a sample text is laid out in
-# all possible combinations.
+# The text can be aligned horizontally by setting [HexaPDF::Layout::Style#align]
+# and vertically by [HexaPDF::Layout::Style#valign]. In this example, a sample
+# text is laid out in all possible combinations.
 #
 # Usage:
-# : `ruby text_box_alignment.rb`
+# : `ruby text_layouter_alignment.rb`
 #
 
 require 'hexapdf'
@@ -26,9 +26,9 @@ canvas.font("Times", size: 10, variant: :bold)
 width = 100
 height = 150
 y_base = 800
-box = HexaPDF::Layout::TextBox.create(sample_text, width: width,
-                                      height: height,
-                                      font: doc.fonts.load("Times"))
+tl = HexaPDF::Layout::TextLayouter.create(sample_text, width: width,
+                                          height: height,
+                                          font: doc.fonts.add("Times"))
 
 [:left, :center, :right, :justify].each_with_index do |align, x_index|
   x = x_index * (width + 20) + 70
@@ -38,10 +38,10 @@ box = HexaPDF::Layout::TextBox.create(sample_text, width: width,
     y = y_base - (height + 30) * y_index
     canvas.text(valign.to_s, at: [20, y - height / 2]) if x_index == 0
 
-    box.style.align(align).valign(valign)
-    box.draw(canvas, x, y, fit: true)
+    tl.style.align(align).valign(valign)
+    tl.draw(canvas, x, y, fit: true)
     canvas.stroke_color(128, 0, 0).rectangle(x, y, width, -height).stroke
   end
 end
 
-doc.write("text_box_alignment.pdf", optimize: true)
+doc.write("text_layouter_alignment.pdf", optimize: true)

data/examples/text_layouter_inline_boxes.rb

@@ -0,0 +1,66 @@
+# ## Text Layouter - Inline Boxes
+#
+# The [HexaPDF::Layout::TextLayouter] class can be used to easily lay out text
+# mixed with inline boxes.
+#
+# Inline boxes are used for showing graphics that follow the flow of the text.
+# This means that their horizontal and their general vertical position is
+# determined by the text layout functionality. However, inline boxes may be
+# vertically aligned to various positions, like the baseline, the top/bottom of
+# the text and the top/bottom of the line.
+#
+# This example shows some text containing emoticons that are replaced with their
+# graphical representation, with normal smileys being aligned to the baseline
+# and winking smileys to the top of the line.
+#
+# An inline box is a simple wrapper around a generic box that adheres to the
+# necessary interface. Therefore they don't do any drawing operations themselves
+# but delegate to their wrapped box. This means, for example, that inline boxes
+# can use background colors or borders without doing anything special.
+#
+# Usage:
+# : `ruby text_layouter_inline_boxes.rb`
+#
+
+require 'hexapdf'
+
+include HexaPDF::Layout
+
+sample_text = "Lorem ipsum :-) dolor sit amet, consectetur adipiscing
+;-) elit, sed do eiusmod tempor incididunt :-) ut labore et dolore magna
+aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco
+laboris nisi ut aliquip ex ea commodo consequat ;-). Duis aute irure
+dolor in reprehenderit in voluptate velit esse cillum :-) dolore eu
+fugiat nulla pariatur. ".tr("\n", ' ') * 4
+
+doc = HexaPDF::Document.new
+emoji_smile = doc.images.add(File.join(__dir__, "emoji-smile.png"))
+emoji_wink = doc.images.add(File.join(__dir__, "emoji-wink.png"))
+size = 10
+
+items = sample_text.split(/(:-\)|;-\))/).map do |part|
+  case part
+  when ':-)'
+    style = {background_color: [162, 234, 247], padding: 2}
+    InlineBox.create(content_width: size * 2, content_height: size * 2,
+                     style: style) do |canvas, box|
+      canvas.image(emoji_smile, at: [0, 0], width: box.content_width)
+    end
+  when ';-)'
+    style = {padding: 5, margin: [0, 10],
+             border: {width: [1, 2], color: [200, 40]}}
+    InlineBox.create(content_width: size, content_height: size,
+                     valign: :top, style: style) do |canvas, box|
+      canvas.image(emoji_wink, at: [0, 0], width: box.content_width)
+    end
+  else
+    TextFragment.create(part, font: doc.fonts.add("Times"), font_size: 18)
+  end
+end
+
+layouter = TextLayouter.new(items: items, width: 500, height: 700)
+layouter.style.align = :justify
+layouter.style.line_spacing(:proportional, 1.5)
+layouter.draw(doc.pages.add.canvas, 50, 800)
+
+doc.write("text_layouter_inline_boxes.pdf")

data/examples/{text_box_line_wrapping.rb → text_layouter_line_wrapping.rb}

@@ -1,6 +1,6 @@
-# ## Text Box Line Wrapping
+# ## Text Layouter - Line Wrapping
 #
-# The [HexaPDF::Layout::TextBox] class can be used to easily lay out text,
+# The [HexaPDF::Layout::TextLayouter] class can be used to easily lay out text,
 # automatically wrapping it appropriately.
 #
 # Text is broken only at certain characters:
@@ -30,7 +30,7 @@
 # non-breaking spaces in "1 0 1".
 #
 # Usage:
-# : `ruby text_box_line_wrapping.rb`
+# : `ruby text_layout_line_wrapping.rb`
 #
 
 require 'hexapdf'
@@ -45,13 +45,12 @@ text = "Hello! Fly-fishing\nand wand\u{00AD}ering\taround - fanta\u{200B}stic" \
 x = 10
 y = 220
 [30, 60, 100, 160].each do |width|
-  box = HexaPDF::Layout::TextBox.create(text, width: width,
-                                        font: doc.fonts.load("Times"))
-  _, height = box.fit
-  box.draw(canvas, x, y)
+  layouter = HexaPDF::Layout::TextLayouter.create(text, width: width,
+                                                  font: doc.fonts.add("Times"))
+  layouter.draw(canvas, x, y)
   canvas.stroke_color(255, 0, 0).line_width(0.2)
-  canvas.rectangle(x, y, width, -height).stroke
-  y -= height + 5
+  canvas.rectangle(x, y, width, -layouter.actual_height).stroke
+  y -= layouter.actual_height + 5
 end
 
-doc.write("text_box_line_wrapping.pdf", optimize: true)
+doc.write("text_layouter_line_wrapping.pdf", optimize: true)

data/examples/{text_box_shapes.rb → text_layouter_shapes.rb}

@@ -1,8 +1,9 @@
-# ## Text Box Shapes
+# ## Text Layouter - Shapes
 #
-# The [HexaPDF::Layout::TextBox] class can be used to easily lay out text, not
-# limiting the area to a rectangle but any shape. There is only one restriction:
-# In the case of arbitrary shapes the vertical alignment has to be "top".
+# The [HexaPDF::Layout::TextLayouter] class can be used to easily lay out text,
+# not limiting the area to a rectangle but any shape. There is only one
+# restriction: In the case of arbitrary shapes the vertical alignment has to be
+# "top".
 #
 # Arbitrary shapes boil down to varying line widths and horizontal offsets from
 # left. Imagine a circle: If text is fit in a circle, the line widths start at
@@ -12,24 +13,27 @@
 #
 # Both, the line widths and the horizontal offsets can be calculated given a
 # certain height, and this is exactly what HexaPDF uses. If the `width` argument
-# to [HexaPDF::Layout::TextBox::new] is an object responding to #call (e.g. a
-# lambda), it is used for determining the line widths. And the `x_offsets`
+# to [HexaPDF::Layout::TextLayouter::new] is an object responding to #call (e.g.
+# a lambda), it is used for determining the line widths. And the `x_offsets`
 # argument can be used in a similar way for the horizontal offsets.
 #
 # This example shows text layed out in various shapes, using the above mentioned
 # techniques.
 #
 # Usage:
-# : `ruby text_box_shapes.rb`
+# : `ruby text_layouter_shapes.rb`
 #
 
 require 'hexapdf'
 
+include HexaPDF::Layout
+
 doc = HexaPDF::Document.new
 page = doc.pages.add
 canvas = page.canvas
 canvas.font("Times", size: 10, variant: :bold)
 canvas.stroke_color(255, 0, 0).line_width(0.2)
+font = doc.fonts.add("Times")
 
 sample_text = "Lorem ipsum dolor sit amet, con\u{00AD}sectetur
 adipis\u{00AD}cing elit, sed do eiusmod tempor incididunt ut labore et
@@ -58,31 +62,31 @@ left_half_circle_offsets = lambda do |height, line_height|
 end
 
 # Left: right half circle
-box = HexaPDF::Layout::TextBox.create(sample_text,
-                                      width: half_circle_widths,
-                                      height: radius * 2,
-                                      font: doc.fonts.load("Times"))
-box.draw(canvas, 0, circle_top)
+layouter = TextLayouter.create(sample_text,
+                               width: half_circle_widths,
+                               height: radius * 2,
+                               font: font)
+layouter.draw(canvas, 0, circle_top)
 canvas.circle(0, circle_top - radius, radius).stroke
 
 # Center: full circle
-box = HexaPDF::Layout::TextBox.create(sample_text,
-                                      width: circle_widths,
-                                      x_offsets: left_half_circle_offsets,
-                                      height: radius * 2,
-                                      font: doc.fonts.load("Times"),
-                                      align: :justify)
-box.draw(canvas, page.box(:media).width / 2.0 - radius, circle_top)
+layouter = TextLayouter.create(sample_text,
+                               width: circle_widths,
+                               x_offsets: left_half_circle_offsets,
+                               height: radius * 2,
+                               font: font,
+                               align: :justify)
+layouter.draw(canvas, page.box(:media).width / 2.0 - radius, circle_top)
 canvas.circle(page.box(:media).width / 2.0, circle_top - radius, radius).stroke
 
 # Right: left half circle
-box = HexaPDF::Layout::TextBox.create(sample_text,
-                                      width: half_circle_widths,
-                                      x_offsets: left_half_circle_offsets,
-                                      height: radius * 2,
-                                      font: doc.fonts.load("Times"),
-                                      align: :right)
-box.draw(canvas, page.box(:media).width - radius, circle_top)
+layouter = TextLayouter.create(sample_text,
+                               width: half_circle_widths,
+                               x_offsets: left_half_circle_offsets,
+                               height: radius * 2,
+                               font: font,
+                               align: :right)
+layouter.draw(canvas, page.box(:media).width - radius, circle_top)
 canvas.circle(page.box(:media).width, circle_top - radius, radius).stroke
 
 
@@ -107,37 +111,37 @@ left_half_diamond_offsets = lambda do |height, line_height|
 end
 
 # Left: right half diamond
-box = HexaPDF::Layout::TextBox.create(sample_text,
-                                      width: half_diamond_widths,
-                                      height: 2 * diamond_width,
-                                      font: doc.fonts.load("Times"))
-box.draw(canvas, 0, diamond_top)
+layouter = TextLayouter.create(sample_text,
+                               width: half_diamond_widths,
+                               height: 2 * diamond_width,
+                               font: font)
+layouter.draw(canvas, 0, diamond_top)
 canvas.polyline(0, diamond_top, diamond_width, diamond_top - diamond_width,
-               0, diamond_top - 2 * diamond_width).stroke
+                0, diamond_top - 2 * diamond_width).stroke
 
 # Center: full diamond
-box = HexaPDF::Layout::TextBox.create(sample_text,
-                                      width: full_diamond_widths,
-                                      x_offsets: left_half_diamond_offsets,
-                                      height: 2 * diamond_width,
-                                      font: doc.fonts.load("Times"),
-                                      align: :justify)
+layouter = TextLayouter.create(sample_text,
+                               width: full_diamond_widths,
+                               x_offsets: left_half_diamond_offsets,
+                               height: 2 * diamond_width,
+                               font: font,
+                               align: :justify)
 left = page.box(:media).width / 2.0 - diamond_width
-box.draw(canvas, left, diamond_top)
+layouter.draw(canvas, left, diamond_top)
 canvas.polyline(left + diamond_width, diamond_top,
                 left + 2 * diamond_width, diamond_top - diamond_width,
                 left + diamond_width, diamond_top - 2 * diamond_width,
                 left, diamond_top - diamond_width).close_subpath.stroke
 
 # Right: left half diamond
-box = HexaPDF::Layout::TextBox.create(sample_text,
-                                      width: half_diamond_widths,
-                                      x_offsets: left_half_diamond_offsets,
-                                      height: 2 * diamond_width,
-                                      font: doc.fonts.load("Times"),
-                                      align: :right)
+layouter = TextLayouter.create(sample_text,
+                               width: half_diamond_widths,
+                               x_offsets: left_half_diamond_offsets,
+                               height: 2 * diamond_width,
+                               font: font,
+                               align: :right)
 middle = page.box(:media).width
-box.draw(canvas, middle - diamond_width, diamond_top)
+layouter.draw(canvas, middle - diamond_width, diamond_top)
 canvas.polyline(middle, diamond_top,
                 middle - diamond_width, diamond_top - diamond_width,
                 middle, diamond_top - 2 * diamond_width).stroke
@@ -154,13 +158,13 @@ end
 sine_wave_widths = lambda do |height, line_height|
   sine_wave_height + 100 + sine_wave_offsets.call(height, line_height) * -2
 end
-box = HexaPDF::Layout::TextBox.create(sample_text,
-                                      width: sine_wave_widths,
-                                      x_offsets: sine_wave_offsets,
-                                      height: sine_wave_height,
-                                      font: doc.fonts.load("Times"),
-                                      align: :justify)
+layouter = TextLayouter.create(sample_text,
+                               width: sine_wave_widths,
+                               x_offsets: sine_wave_offsets,
+                               height: sine_wave_height,
+                               font: font,
+                               align: :justify)
 middle = page.box(:media).width / 2.0
-box.draw(canvas, middle - (sine_wave_height + 100) / 2, sine_wave_top)
+layouter.draw(canvas, middle - (sine_wave_height + 100) / 2, sine_wave_top)
 
-doc.write("text_box_shapes.pdf", optimize: true)
+doc.write("text_layouter_shapes.pdf", optimize: true)