hexapdf 0.5.0 → 0.6.0

data/lib/hexapdf/layout/inline_box.rb

@@ -31,52 +31,61 @@
 # is created or manipulated using HexaPDF.
 #++
 
+require 'hexapdf/layout/box'
+
 module HexaPDF
   module Layout
 
-    # An InlineBox can be used as an item for a LineFragment so that inline graphics are possible.
-    # The box *must* have a fixed size!
+    # An InlineBox wraps a regular Box so that it can be used as an item for a Line. This enables
+    # inline graphics.
+    #
+    # The wrapped box *must* have a fixed size!
     class InlineBox
 
-      # The width of the box.
-      attr_reader :width
-
-      # The height of the box.
-      attr_reader :height
+      # Creates an InlineBox that wraps a basic Box. All arguments (except +valign+) and the block
+      # are passed to Box::new.
+      #
+      # See ::new for the +valign+ argument.
+      def self.create(valign: :baseline, **args, &block)
+        new(Box.new(**args, &block), valign: valign)
+      end
 
       # The vertical alignment of the box.
       #
-      # Can be any supported value except :text - see LineFragment for all possible values.
+      # Can be any supported value except :text - see Line for all possible values.
       attr_reader :valign
 
-      # :call-seq:
-      #    InlineBox.new(width, height, valign: :baseline) {|box, canvas| block}      -> inline_box
-      #
-      # Creates a new InlineBox object that uses the provided block when it is asked to draw itself
-      # on a canvas (see #draw).
-      #
-      # Since the final location of the box is not known beforehand, the drawing operations inside
-      # the block should draw inside the rectangle (0, 0, width, height).
+      # The wrapped Box object.
+      attr_reader :box
+
+      # Creates a new InlineBox object wrapping +box+.
       #
       # The +valign+ argument can be used to specify the vertical alignment of the box relative to
-      # other items in the LineFragment - see #valign and LineFragment.
-      def initialize(width, height, valign: :baseline, &block)
-        @width = width
-        @height = height
+      # other items in the Line.
+      def initialize(box, valign: :baseline)
+        @box = box
         @valign = valign
-        @draw_block = block
       end
 
-      # :call-seq:
-      #   box.draw(canvas, x, y)    -> block_result
-      #
-      # Draws the contents of the box onto the canvas at the position (x, y), and returns the result
-      # of the drawing block (see #initialize).
-      #
-      # The coordinate system is translated so that the origin is at (x, y) during the drawing
-      # operations.
+      # Returns +true+ if this inline box is just a placeholder without drawing operations.
+      def empty?
+        box.empty?
+      end
+
+      # Returns the width of the wrapped box plus its left and right margins.
+      def width
+        box.width + box.style.margin.left + box.style.margin.right
+      end
+
+      # Returns the height of the wrapped box plus its top and bottom margins.
+      def height
+        box.height + box.style.margin.top + box.style.margin.bottom
+      end
+
+      # Draws the wrapped box. If the box has margins specified, the x and y offsets are correctly
+      # adjusted.
       def draw(canvas, x, y)
-        canvas.translate(x, y) { @draw_block.call(self, canvas) }
+        box.draw(canvas, x + box.style.margin.left, y + box.style.margin.bottom)
       end
 
       # The minimum x-coordinate which is always 0.
@@ -84,7 +93,7 @@ module HexaPDF
         0
       end
 
-      # The maximum x-coordinate which is equivalent to the width of the box.
+      # The maximum x-coordinate which is equivalent to the width of the inline box.
       def x_max
         width
       end

data/lib/hexapdf/layout/{line_fragment.rb → line.rb}

@@ -37,26 +37,25 @@ require 'hexapdf/layout/text_fragment'
 module HexaPDF
   module Layout
 
-    # A LineFragment describes a line of text and can contain TextFragment objects or InlineBox
-    # objects.
+    # A Line describes a line of text and can contain TextFragment objects or InlineBox objects.
     #
     # The items of a line fragment are aligned along the x-axis which coincides with the text
     # baseline. The vertical alignment is determined by the value of the #valign method:
     #
     # :text_top::
-    #     Align the top of the box with the top of the text of the LineFragment.
+    #     Align the top of the box with the top of the text of the Line.
     #
     # :text_bottom::
-    #     Align the bottom of the box with the bottom of the text of the LineFragment.
+    #     Align the bottom of the box with the bottom of the text of the Line.
     #
     # :baseline::
-    #     Align the bottom of the box with the baseline of the LineFragment.
+    #     Align the bottom of the box with the baseline of the Line.
     #
     # :top::
-    #     Align the top of the box with the top of the LineFragment.
+    #     Align the top of the box with the top of the Line.
     #
     # :bottom::
-    #     Align the bottom of the box with the bottom of the LineFragment.
+    #     Align the bottom of the box with the bottom of the Line.
     #
     # :text::
     #     This is a special alignment value for text fragment objects. The text fragment is aligned
@@ -86,7 +85,7 @@ module HexaPDF
     # implemented:
     #
     # #height:: The height of the item.
-    class LineFragment
+    class Line
 
       # Helper class for calculating the needed vertical dimensions of a line.
       class HeightCalculator
@@ -122,7 +121,7 @@ module HexaPDF
 
         # Returns the result of the calculations, the array [y_min, y_max, text_y_min, text_y_max].
         #
-        # See LineFragment for their meaning.
+        # See Line for their meaning.
         def result
           y_min = [@text_y_max - @max_text_top_height, @text_y_min].min
           y_max = [@text_y_min + @max_text_bottom_height, @max_base_height, @text_y_max].max
@@ -180,7 +179,7 @@ module HexaPDF
       # the baseline of this line.
       attr_accessor :y_offset
 
-      # Creates a new LineFragment object, adding all given items to it.
+      # Creates a new Line object, adding all given items to it.
       def initialize(items = [])
         @items = []
         items.each {|i| add(i)}
@@ -211,7 +210,7 @@ module HexaPDF
       alias :<< :add
 
       # :call-seq:
-      #   line_fragment.each {|item, x, y| block }
+      #   line.each {|item, x, y| block }
       #
       # Yields each item together with its horizontal offset from 0 and vertical offset from the
       # baseline.
@@ -287,7 +286,7 @@ module HexaPDF
       end
 
       # :call-seq:
-      #   line_fragment.clear_cache   -> line_fragment
+      #   line.clear_cache   -> line
       #
       # Clears all cached values.
       #
@@ -300,7 +299,7 @@ module HexaPDF
       private
 
       # :call-seq:
-      #    line_fragment.calculate_y_dimensions     -> [y_min, y_max, text_y_min, text_y_max]
+      #    line.calculate_y_dimensions     -> [y_min, y_max, text_y_min, text_y_max]
       #
       # Calculates all y-values and returns them as array.
       #

data/lib/hexapdf/layout/style.rb

@@ -32,6 +32,7 @@
 #++
 
 require 'hexapdf/error'
+require 'hexapdf/content/graphics_state'
 
 module HexaPDF
   module Layout
@@ -40,6 +41,13 @@ module HexaPDF
     #
     # Each property except #font has a default value, so only the desired properties need to be
     # changed.
+    #
+    # Each property has three associated methods:
+    #
+    # property_name:: Getter method.
+    # property_name(*args) and property_name=:: Setter method.
+    # property_name?:: Tester method to see if a value has been set or if the default value has
+    #                  already been used.
     class Style
 
       # Defines how the distance between the baselines of two adjacent text lines is determined:
@@ -92,7 +100,7 @@ module HexaPDF
           end
         end
 
-        # Returns the distance between the baselines of the two given LineFragment objects.
+        # Returns the distance between the baselines of the two given Line objects.
         def baseline_distance(line1, line2)
           case type
           when :proportional then (line1.y_min.abs + line2.y_max) * value
@@ -101,8 +109,8 @@ module HexaPDF
           end
         end
 
-        # Returns the gap between the two given LineFragment objects, i.e. the distance between the
-        # y_min of the first line and the y_max of the second line.
+        # Returns the gap between the two given Line objects, i.e. the distance between the y_min of
+        # the first line and the y_max of the second line.
         def gap(line1, line2)
           case type
           when :proportional then (line1.y_min.abs + line2.y_max) * (value - 1)
@@ -113,6 +121,374 @@ module HexaPDF
 
       end
 
+      # A Quad holds four values and allows them to be accessed by the names top, right, bottom and
+      # left. Quads are normally used for holding values pertaining to boxes, like margins, paddings
+      # or borders.
+      class Quad
+
+        # The value for top.
+        attr_accessor :top
+
+        # The value for bottom.
+        attr_accessor :bottom
+
+        # The value for left.
+        attr_accessor :left
+
+        # The value for right.
+        attr_accessor :right
+
+        # :call-seq:
+        #   Quad.new(value)
+        #   Quad.new(array)
+        #   Quad.new(quad)
+        #
+        # Creates a new Quad object.
+        #
+        # * If a single value is provided that is neither a Quad nor an array, it is handled as if
+        #   an array with one value was given.
+        #
+        # * If a Quad is provided, its values are used.
+        #
+        # * If an array is provided, it depends on the number of elemens in it:
+        #
+        #   * One value: All attributes are set to the same value.
+        #   * Two values: Top and bottom are set to the first value, left and right to the second
+        #     value.
+        #   * Three values: Top is set to the first, left and right to the second, and bottom to the
+        #     third value.
+        #   * Four or more values: Top is set to the first, right to the second, bottom to the third
+        #     and left to the fourth value.
+        def initialize(obj)
+          case obj
+          when Quad
+            @top = obj.top
+            @bottom = obj.bottom
+            @left = obj.left
+            @right = obj.right
+          when Array
+            @top = obj[0]
+            @bottom = obj[2] || obj[0]
+            @left = obj[3] || obj[1] || obj[0]
+            @right = obj[1] || obj[0]
+          else
+            @top = @bottom = @left = @right = obj
+          end
+        end
+
+        # Returns +true+ if the quad effectively contains only one value.
+        def simple?
+          @top == @bottom && @top == @left && @top == @right
+        end
+
+      end
+
+      # Represents the border of a rectangular area.
+      class Border
+
+        # The widths of each edge. See Quad.
+        attr_reader :width
+
+        # The colors of each edge. See Quad.
+        attr_reader :color
+
+        # The styles of each edge. See Quad.
+        attr_reader :style
+
+        # Creates a new border style. All arguments can be set to any value that a Quad can process.
+        def initialize(width: 0, color: 0, style: :solid)
+          @width = Quad.new(width)
+          @color = Quad.new(color)
+          @style = Quad.new(style)
+        end
+
+        # Returns +true+ if there is no border.
+        def none?
+          width.simple? && width.top == 0
+        end
+
+        # Draws the border onto the canvas, inside the rectangle (x, y, w, h).
+        def draw(canvas, x, y, w, h)
+          canvas.save_graphics_state do
+            if width.simple? && color.simple? && style.simple?
+              draw_simple_border(canvas, x, y, w, h)
+            else
+              draw_complex_border(canvas, x, y, w, h)
+            end
+          end
+        end
+
+        private
+
+        # Draws the border assuming that only one width, style and color are used.
+        def draw_simple_border(canvas, x, y, w, h)
+          offset = width.top / 2.0
+          canvas.stroke_color(color.top).
+            line_width(width.top).
+            line_join_style(:miter).
+            miter_limit(10).
+            line_cap_style(line_cap_style(:top))
+
+          if style.top == :solid
+            canvas.line_dash_pattern(0).
+              rectangle(x + offset, y + offset, w - 2 * offset, h - 2 * offset).stroke
+          else
+            canvas.rectangle(x, y, w, h).clip_path.end_path
+
+            canvas.line_dash_pattern(line_dash_pattern(:top, w)).
+              line(x, y + h - offset, x + w, y + h - offset).
+              line(x + w, y + offset, x, y + offset).stroke
+            canvas.line_dash_pattern(line_dash_pattern(:right, h)).
+              line(x + w - offset, y + h, x + w - offset, y).
+              line(x + offset, y, x + offset, y + h).stroke
+          end
+        end
+
+        # Draws a complex border, i.e. one where every edge is potentially differently styled.
+        def draw_complex_border(canvas, x, y, w, h)
+          left = x
+          bottom = y
+          right = left + w
+          top = bottom + h
+          inner_left = left + width.left
+          inner_bottom = bottom + width.bottom
+          inner_right = right - width.right
+          inner_top = top - width.top
+
+          if width.top > 0
+            canvas.save_graphics_state do
+              canvas.polyline(left, top, right, top, inner_right, inner_top,
+                              inner_left, inner_top).
+                clip_path.end_path
+              canvas.stroke_color(color.top).
+                line_width(width.top).
+                line_cap_style(line_cap_style(:top)).
+                line_dash_pattern(line_dash_pattern(:top, w)).
+                line(left, top - width.top / 2.0, right, top - width.top / 2.0).stroke
+            end
+          end
+
+          if width.right > 0
+            canvas.save_graphics_state do
+              canvas.polyline(right, top, right, bottom, inner_right, inner_bottom,
+                              inner_right, inner_top).
+                clip_path.end_path
+              canvas.stroke_color(color.right).
+                line_width(width.right).
+                line_cap_style(line_cap_style(:right)).
+                line_dash_pattern(line_dash_pattern(:right, h)).
+                line(right - width.right / 2.0, top, right - width.right / 2.0, bottom).stroke
+            end
+          end
+
+          if width.bottom > 0
+            canvas.save_graphics_state do
+              canvas.polyline(right, bottom, left, bottom, inner_left, inner_bottom,
+                              inner_right, inner_bottom).
+                clip_path.end_path
+              canvas.stroke_color(color.bottom).
+                line_width(width.bottom).
+                line_cap_style(line_cap_style(:bottom)).
+                line_dash_pattern(line_dash_pattern(:bottom, w)).
+                line(right, bottom + width.bottom / 2.0, left, bottom + width.bottom / 2.0).stroke
+            end
+          end
+
+          if width.left > 0
+            canvas.save_graphics_state do
+              canvas.polyline(left, bottom, left, top, inner_left, inner_top,
+                              inner_left, inner_bottom).
+                clip_path.end_path
+              canvas.stroke_color(color.left).
+                line_width(width.left).
+                line_cap_style(line_cap_style(:left)).
+                line_dash_pattern(line_dash_pattern(:left, h)).
+                line(left + width.left / 2.0, bottom, left + width.left / 2.0, top).stroke
+            end
+          end
+        end
+
+        # Returns the line cap style for the given edge name.
+        def line_cap_style(edge)
+          case style.send(edge)
+          when :solid then :butt
+          when :dashed then :projecting_square
+          when :dashed_round, :dotted then :round
+          else
+            raise ArgumentError, "Invalid border style specified: #{style.send(edge)}"
+          end
+        end
+
+        # Returns the line dash pattern for the given edge name. The argument +length+ needs to
+        # contain the length of the edge.
+        def line_dash_pattern(edge, length)
+          case style.send(edge)
+          when :solid
+            0
+          when :dashed, :dashed_round
+            # Due to the used line cap styles, a dash of length w appears with a length of 2w. The
+            # gap between dashes is nominally 3w but adjusted so that full dashes start and end in
+            # the corners.
+            w = width.send(edge)
+            count = [(length.to_f / (w * 3)).floor, 1].max
+            gap = [(length - w * (count + 2)).to_f, 0].max / count
+            HexaPDF::Content::LineDashPattern.new([w, gap], w * 0.5 + gap)
+          when :dotted
+            # Adjust the gap so that full dots appear in the corners.
+            w = width.send(edge)
+            gap = (length - w).to_f / (length.to_f / (w * 2)).ceil
+            HexaPDF::Content::LineDashPattern.new([0, gap], [gap - w * 0.5, 0].max)
+          end
+        end
+
+      end
+
+      # Represents layers that can be drawn under or over a box.
+      #
+      # There are two ways to specify layers via #add:
+      #
+      # * Directly by providing a callable object.
+      #
+      # * By reference to a callable object or class in the 'style.layers_map' configuration option.
+      #   The reference name is looked up in the configuration option using
+      #   HexaPDF::Configuration#constantize. If the resulting object is a callable object, it is
+      #   used; otherwise it is assumed that it is a class and an object is instantiated, passing in
+      #   any options given on #add.
+      #
+      # The object resolved in this way needs to respond to #call(canvas, box) where +canvas+ is the
+      # HexaPDF::Content::Canvas object on which it should be drawn and +box+ is a box-like object
+      # (e.g. Box or TextFragment). The coordinate system is translated so that the origin is at the
+      # lower right corner of the box during the drawing operations.
+      class Layers
+
+        # Creates a new Layers object popuplated with the given +layers+.
+        def initialize(layers = [])
+          @layers = layers
+        end
+
+        # :call-seq:
+        #   layers.add {|canvas, box| block}
+        #   layers.add(name, **options)
+        #
+        # Adds a new layer object.
+        #
+        # The layer object can either be specified as a block or by reference to a configured layer
+        # object in 'style.layers_map'. In this case +name+ is used as the reference and the options
+        # are passed to layer object if it needs initialization.
+        def add(name = nil, **options, &block)
+          if block_given?
+            @layers << block
+          elsif name
+            @layers << [name, options]
+          else
+            raise ArgumentError, "Layer object name or block missing"
+          end
+        end
+
+        # Draws all layer objects onto the canvas at the position [x, y] for the given box.
+        def draw(canvas, x, y, box)
+          return if none?
+
+          canvas.translate(x, y) do
+            each(canvas.context.document.config) do |layer|
+              canvas.save_graphics_state { layer.call(canvas, box) }
+            end
+          end
+        end
+
+        # Yields all layer objects. Objects that have been specified via a reference are first
+        # resolved using the provided configuration object.
+        def each(config) #:yield: layer
+          @layers.each do |obj, options|
+            obj = config.constantize('style.layers_map', obj) unless obj.respond_to?(:call)
+            obj = obj.new(**options) unless obj.respond_to?(:call)
+            yield(obj)
+          end
+        end
+
+        # Returns +true+ if there are no layers defined.
+        def none?
+          @layers.empty?
+        end
+
+      end
+
+      # The LinkLayer class provides support for linking to in-document or remote destinations for
+      # Style objects using link annotations. Typical use cases would be linking to a (named)
+      # destination on a different page or executing a URI action.
+      #
+      # See: PDF1.7 s12.5.6.6, Layers, HexaPDF::Type::Annotations::Link
+      class LinkLayer
+
+        # Creates a new LinkLayer object.
+        #
+        # The following arguments are allowed (note that only *one* of +dest+, +uri+ or +file+ may
+        # be specified):
+        #
+        # +dest+::
+        #   The destination array or a name of a named destination for in-document links.
+        #
+        # +uri+::
+        #   The URI to link to.
+        #
+        # +file+::
+        #   The file that should be opened or, if it refers to an application, the application that
+        #   should be launched. Can either be a string or a Filespec object. Also see:
+        #   HexaPDF::Type::FileSpecification.
+        #
+        # +border+::
+        #   If set to +true+, a standard border is used. Also accepts an array that adheres to the
+        #   rules for annotation borders.
+        #
+        # +border_color+::
+        #   Defines the border color. Can be an array with 0 (transparent), 1 (grayscale), 3 (RGB)
+        #   or 4 (CMYK) values.
+        #
+        # Examples:
+        #   LinkLayer.new(dest: [page, :XYZ, nil, nil, nil], border: true)
+        #   LinkLayer.new(uri: "https://my.example.com/path", border: [5 5 2])
+        def initialize(dest: nil, uri: nil, file: nil, border: false, border_color: nil)
+          if dest && (uri || file) || uri && file
+            raise ArgumentError, "Only one of dest, uri and file is allowed"
+          end
+          @dest = dest
+          @action = if uri
+                      {S: :URI, URI: uri}
+                    elsif file
+                      {S: :Launch, F: file, NewWindow: true}
+                    end
+          @border = case border
+                    when false then [0, 0, 0]
+                    when true then nil
+                    when Array then border
+                    else raise ArgumentError, "Invalid value for border: #{border}"
+                    end
+          @border_color = border_color
+        end
+
+        # Creates the needed link annotation if possible, i.e. if the context of the canvas is a page.
+        def call(canvas, box)
+          return unless canvas.context.type == :Page
+          page = canvas.context
+          matrix = canvas.graphics_state.ctm
+          quad_points = [*matrix.evaluate(0, 0), *matrix.evaluate(box.width, 0),
+                         *matrix.evaluate(box.width, box.height), *matrix.evaluate(0, box.height)]
+          x_minmax = quad_points.values_at(0, 2, 4, 6).minmax
+          y_minmax = quad_points.values_at(1, 3, 5, 7).minmax
+          annot = {
+            Subtype: :Link,
+            Rect: [x_minmax[0], y_minmax[0], x_minmax[1], y_minmax[1]],
+            QuadPoints: quad_points,
+            Dest: @dest,
+            A: @action,
+            Border: @border,
+            C: @border_color && canvas.color_from_specification(@border_color).components,
+          }
+          (page[:Annots] ||= []) << page.document.add(annot)
+        end
+
+      end
+
       UNSET = ::Object.new # :nodoc:
 
       # Creates a new Style object.
@@ -195,6 +571,109 @@ module HexaPDF
       #
       # See: HexaPDF::Layout::TextShaper#shape_text for available features.
 
+      ##
+      # :method: text_rendering_mode
+      # :call-seq:
+      #   text_rendering_mode(mode = nil)
+      #
+      # The text rendering mode, i.e. whether text should be filled, stroked, clipped, invisible or
+      # a combination thereof, defaults to :fill.
+      #
+      # See: HexaPDF::Content::Canvas#text_rendering_mode
+
+      ##
+      # :method: subscript
+      # :call-seq:
+      #   subscript(enable = false)
+      #
+      # Render the text as subscript, i.e. lower and in a smaller font size; defaults to false.
+      #
+      # If superscript is set, it will be deactivated.
+
+      ##
+      # :method: superscript
+      # :call-seq:
+      #   superscript(enable = false)
+      #
+      # Render the text as superscript, i.e. higher and in a smaller font size; defaults to false.
+      #
+      # If subscript is set, it will be deactivated.
+
+      ##
+      # :method: fill_color
+      # :call-seq:
+      #   fill_color(color = nil)
+      #
+      # The color used for filling (e.g. text), defaults to black.
+      #
+      # See: HexaPDF::Content::Canvas#fill_color
+
+      ##
+      # :method: fill_alpha
+      # :call-seq:
+      #   fill_alpha(alpha = nil)
+      #
+      # The alpha value applied to filling operations (e.g. text), defaults to 1 (i.e. 100%
+      # opaque).
+      #
+      # See: HexaPDF::Content::Canvas#opacity
+
+      ##
+      # :method: stroke_color
+      # :call-seq:
+      #   stroke_color(color = nil)
+      #
+      # The color used for stroking (e.g. text outlines), defaults to black.
+      #
+      # See: HexaPDF::Content::Canvas#stroke_color
+
+      ##
+      # :method: stroke_alpha
+      # :call-seq:
+      #   stroke_alpha(alpha = nil)
+      #
+      # The alpha value applied to stroking operations (e.g. text outlines), defaults to 1 (i.e.
+      # 100% opaque).
+      #
+      # See: HexaPDF::Content::Canvas#opacity
+
+      ##
+      # :method: stroke_width
+      # :call-seq:
+      #   stroke_width(width = nil)
+      #
+      # The line width used for stroking operations (e.g. text outlines), defaults to 1.
+      #
+      # See: HexaPDF::Content::Canvas#line_width
+
+      ##
+      # :method: stroke_cap_style
+      # :call-seq:
+      #   stroke_cap_style(style = nil)
+      #
+      # The line cap style used for stroking operations (e.g. text outlines), defaults to :butt.
+      #
+      # See: HexaPDF::Content::Canvas#line_cap_style
+
+      ##
+      # :method: stroke_join_style
+      # :call-seq:
+      #   stroke_join_style(style = nil)
+      #
+      # The line join style used for stroking operations (e.g. text outlines), defaults to :miter.
+      #
+      # See: HexaPDF::Content::Canvas#line_join_style
+
+      ##
+      # :method: stroke_miter_limit
+      # :call-seq:
+      #   stroke_miter_limit(limit = nil)
+      #
+      # The miter limit used for stroking operations (e.g. text outlines) when #stroke_join_style is
+      # :miter, defaults to 10.0.
+      #
+      # See: HexaPDF::Content::Canvas#miter_limit
+
       ##
       # :method: align
       # :call-seq:
@@ -229,6 +708,50 @@ module HexaPDF
       #
       # The indentation to be used for the first line of a sequence of text lines, defaults to 0.
 
+      ##
+      # :method: background_color
+      # :call-seq:
+      #   background_color(color = nil)
+      #
+      # The color used for backgrounds, defaults to +nil+ (i.e. no background).
+
+      ##
+      # :method: padding
+      # :call-seq:
+      #   padding(value = nil)
+      #
+      # The padding between the border and the contents, defaults to 0 for all four sides.
+
+      ##
+      # :method: margin
+      # :call-seq:
+      #   margin(value = nil)
+      #
+      # The margin around a box, defaults to 0 for all four sides.
+
+      ##
+      # :method: border
+      # :call-seq:
+      #   border(value = nil)
+      #
+      # The border around the contents, defaults to no border.
+
+      ##
+      # :method: overlays
+      # :call-seq:
+      #   overlays(layers = nil)
+      #
+      # A Layers object containing all the layers that should be drawn over the box; defaults to no
+      # layers being drawn.
+
+      ##
+      # :method: underlays
+      # :call-seq:
+      #   underlays(layers = nil)
+      #
+      # A Layers object containing all the layers that should be drawn under the box; defaults to no
+      # layers being drawn.
+
       [
         [:font, "raise HexaPDF::Error, 'No font set'"],
         [:font_size, 10],
@@ -237,73 +760,132 @@ module HexaPDF
         [:horizontal_scaling, 100],
         [:text_rise, 0],
         [:font_features, {}],
+        [:text_rendering_mode, :fill],
+        [:subscript, false, "value; superscript(false) if superscript"],
+        [:superscript, false, "value; subscript(false) if subscript"],
+        [:underline, false],
+        [:strikeout, false],
+        [:fill_color, "default_color"],
+        [:fill_alpha, 1],
+        [:stroke_color, "default_color"],
+        [:stroke_alpha, 1],
+        [:stroke_width, 1],
+        [:stroke_cap_style, :butt],
+        [:stroke_join_style, :miter],
+        [:stroke_miter_limit, 10.0],
+        [:stroke_dash_pattern, "Content::LineDashPattern.new",
+         "Content::LineDashPattern.normalize(value, phase)", ", phase = 0"],
         [:align, :left],
         [:valign, :top],
         [:text_indent, 0],
-      ].each do |name, default|
+        [:line_spacing, "LineSpacing.new(:single)",
+         "LineSpacing.new(value, value: extra_arg)", ", extra_arg = nil"],
+        [:background_color, nil],
+        [:padding, "Quad.new(0)", "Quad.new(value)"],
+        [:margin, "Quad.new(0)", "Quad.new(value)"],
+        [:border, "Border.new", "Border.new(value)"],
+        [:overlays, "Layers.new", "Layers.new(value)"],
+        [:underlays, "Layers.new", "Layers.new(value)"],
+      ].each do |name, default, setter = "value", extra_args = ""|
         default = default.inspect unless default.kind_of?(String)
         module_eval(<<-EOF, __FILE__, __LINE__)
-          def #{name}(value = UNSET)
-            value == UNSET ? (@#{name} ||= #{default}) : (@#{name} = value; self)
+          def #{name}(value = UNSET#{extra_args})
+            value == UNSET ? (@#{name} ||= #{default}) : (@#{name} = #{setter}; self)
+          end
+          def #{name}?
+            defined?(@#{name})
           end
         EOF
         alias_method("#{name}=", name)
       end
 
-      # :call-seq:
-      #   line_spacing(type = nil, value = nil)
-      #
-      # The spacing between consecutive lines, defaults to type = :single.
-      #
-      # See: LineSpacing
-      def line_spacing(type = UNSET, value = nil)
-        if type == UNSET
-          @line_spacing ||= LineSpacing.new(:single)
-        else
-          @line_spacing = LineSpacing.new(type, value: value)
-          self
-        end
-      end
-      alias_method(:line_spacing=, :line_spacing)
 
+      ##
+      # :method: text_segmentation_algorithm
       # :call-seq:
       #   text_segmentation_algorithm(algorithm = nil) {|items| block }
       #
       # The algorithm to use for text segmentation purposes, defaults to
-      # TextBox::SimpleTextSegmentation.
+      # TextLayouter::SimpleTextSegmentation.
       #
       # When setting the algorithm, either an object that responds to #call(items) or a block can be
       # used.
-      def text_segmentation_algorithm(algorithm = UNSET, &block)
-        if algorithm == UNSET && !block
-          @text_segmentation_algorithm ||= TextBox::SimpleTextSegmentation
-        else
-          @text_segmentation_algorithm = (algorithm != UNSET ? algorithm : block)
-          self
-        end
-      end
-      alias_method(:text_segmentation_algorithm=, :text_segmentation_algorithm)
 
+      ##
+      # :method: text_line_wrapping_algorithm
       # :call-seq:
-      #   text_line_wrapping_algorithm(algorithm = nil) {|items| block }
+      #   text_line_wrapping_algorithm(algorithm = nil) {|items, width_block| block }
       #
-      # The line wrapping algorithm that should be used, defaults to TextBox::SimpleLineWrapping.
+      # The line wrapping algorithm that should be used, defaults to
+      # TextLayouter::SimpleLineWrapping.
       #
       # When setting the algorithm, either an object that responds to #call or a block can be used.
-      # See TextBox::SimpleLineWrapping#call for the needed method signature.
-      def text_line_wrapping_algorithm(algorithm = UNSET, &block)
-        if algorithm == UNSET && !block
-          @text_line_wrapping_algorithm ||= TextBox::SimpleLineWrapping
+      # See TextLayouter::SimpleLineWrapping#call for the needed method signature.
+
+      [
+        [:text_segmentation_algorithm, 'TextLayouter::SimpleTextSegmentation'],
+        [:text_line_wrapping_algorithm, 'TextLayouter::SimpleLineWrapping'],
+      ].each do |name, default|
+        default = default.inspect unless default.kind_of?(String)
+        module_eval(<<-EOF, __FILE__, __LINE__)
+          def #{name}(value = UNSET, &block)
+            if value == UNSET && !block
+              @#{name} ||= #{default}
+            else
+              @#{name} = (value != UNSET ? value : block)
+              self
+            end
+          end
+          def #{name}?
+            defined?(@#{name})
+          end
+        EOF
+        alias_method("#{name}=", name)
+      end
+
+      # The calculated text rise, taking superscript and subscript into account.
+      def calculated_text_rise
+        if superscript
+          text_rise + font_size * 0.33
+        elsif subscript
+          text_rise - font_size * 0.20
         else
-          @text_line_wrapping_algorithm = (algorithm != UNSET ? algorithm : block)
-          self
+          text_rise
         end
       end
-      alias_method(:text_line_wrapping_algorithm=, :text_line_wrapping_algorithm)
+
+      # The calculated font size, taking superscript and subscript into account.
+      def calculated_font_size
+        (superscript || subscript ? 0.583 : 1) * font_size
+      end
+
+      # Returns the correct offset from the baseline for the underline.
+      def calculated_underline_position
+        calculated_text_rise +
+          calculated_font_size / 1000.0 * font.wrapped_font.underline_position *
+          font.scaling_factor - calculated_underline_thickness / 2.0
+      end
+
+      # Returns the correct thickness for the underline.
+      def calculated_underline_thickness
+        calculated_font_size / 1000.0 * font.wrapped_font.underline_thickness * font.scaling_factor
+      end
+
+      # Returns the correct offset from the baseline for the strikeout line.
+      def calculated_strikeout_position
+        calculated_text_rise +
+          calculated_font_size / 1000.0 * font.wrapped_font.strikeout_position *
+          font.scaling_factor - calculated_strikeout_thickness / 2.0
+      end
+
+      # Returns the correct thickness for the strikeout line.
+      def calculated_strikeout_thickness
+        calculated_font_size / 1000.0 * font.wrapped_font.strikeout_thickness * font.scaling_factor
+      end
 
       # The font size scaled appropriately.
       def scaled_font_size
-        @scaled_font_size ||= font_size / 1000.0 * scaled_horizontal_scaling
+        @scaled_font_size ||= calculated_font_size / 1000.0 * scaled_horizontal_scaling
       end
 
       # The character spacing scaled appropriately.
@@ -359,6 +941,13 @@ module HexaPDF
         @scaled_item_widths.clear
       end
 
+      private
+
+      # Returns the default color for an empty PDF page, i.e. black.
+      def default_color
+        GlobalConfiguration.constantize('color_space.map'.freeze, :DeviceGray).new.default_color
+      end
+
     end
 
   end