alphasights-prawn 0.10.0

data/lib/prawn/text.rb

@@ -0,0 +1,449 @@
+# encoding: utf-8
+
+# text.rb : Implements PDF text primitives
+#
+# Copyright May 2008, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+require "prawn/core/text"
+require "prawn/core/text/wrap"
+require "prawn/text/box"
+require "prawn/text/formatted"
+require "zlib"
+
+module Prawn
+  module Text
+
+    include Prawn::Core::Text
+    include Prawn::Text::Formatted
+
+    Prawn::Text::NBSP = " "
+
+    # If you want text to flow onto a new page or between columns, this is the
+    # method to use. If, instead, if you want to place bounded text outside of
+    # the flow of a document (for captions, labels, charts, etc.), use Text::Box
+    # or its convenience method text_box.
+    # 
+    # Draws text on the page. Prawn attempts to wrap the text to fit within your
+    # current bounding box (or margin_box if no bounding box is being used).
+    # Text will flow onto the next page when it reaches the bottom of the
+    # bounding box. Text wrap in Prawn does not re-flow linebreaks, so if you
+    # want fully automated text wrapping, be sure to remove newlines before
+    # attempting to draw your string.
+    #
+    # == Examples
+    #
+    #   pdf.text "Will be wrapped when it hits the edge of your bounding box"
+    #   pdf.text "This will be centered", :align => :center
+    #   pdf.text "This will be right aligned", :align => :right
+    #   pdf.text "This <i>includes <b>inline</b></i> <font size='24'>" +
+    #            "formatting</font>", :inline_format => true
+    #
+    # If your font contains kerning pair data that Prawn can parse, the
+    # text will be kerned by default. You can disable kerning by including
+    # a false <tt>:kerning</tt> option. If you want to disable kerning on an
+    # entire document, set default_kerning = false for that document
+    #
+    # === Text Positioning Details
+    # 
+    # The text is positioned at font.ascender below the baseline,
+    # making it easy to use this method within bounding boxes and spans.
+    #
+    # == Encoding
+    #
+    # Note that strings passed to this function should be encoded as UTF-8.
+    # If you get unexpected characters appearing in your rendered document, 
+    # check this.
+    #
+    # If the current font is a built-in one, although the string must be
+    # encoded as UTF-8, only characters that are available in WinAnsi
+    # are allowed.
+    #
+    # If an empty box is rendered to your PDF instead of the character you 
+    # wanted it usually means the current font doesn't include that character.
+    #
+    # == Options (default values marked in [])
+    #
+    # <tt>:inline_format</tt>::
+    #      <tt>boolean</tt>. If true, then the string parameter is interpreted
+    #      as a HTML-esque string that recognizes the following tags:
+    #      <tt>\<b></b></tt>:: bold
+    #      <tt>\<i></i></tt>:: italic
+    #      <tt>\<u></u></tt>:: underline
+    #      <tt>\<strikethrough></strikethrough></tt>:: strikethrough
+    #      <tt>\<sub></sub></tt>:: subscript
+    #      <tt>\<sup></sup></tt>:: superscript
+    #      <tt>\<font></font></tt>::
+    #          with the following attributes (using double or single quotes)
+    #            <tt>size="24"</tt>::
+    #                attribute for setting size
+    #            <tt>character_spacing="2.5"</tt>::
+    #                attribute for setting character spacing
+    #            <tt>name="Helvetica"</tt>::
+    #                attribute for setting the font. The font name must be an
+    #                AFM font with the desired faces or must be a font that is
+    #                already registered using Prawn::Document#font_families
+    #      <tt>\<color></color></tt>::
+    #          with the following attributes
+    #            <tt>rgb="ffffff" or rgb="#ffffff"</tt>::
+    #            <tt>c="100" m="100" y="100" k="100"</tt>::
+    #      <tt>\<link></link></tt>::
+    #          with the following attributes
+    #            <tt>href="http://example.com"</tt>:: an external link
+    #            <tt>anchor="ToC"</tt>::
+    #                where the value of the anchor attribute is the name of a
+    #                destination that has already been or will be registered
+    #                using Prawn::Core::Destinations#add_dest. A clickable link
+    #                will be created to that destination. 
+    #          Note that you must explicitly underline and color using the
+    #          appropriate tags if you which to draw attention to the link
+    #
+    # <tt>:kerning</tt>:: <tt>boolean</tt>. Whether or not to use kerning (if it
+    #                     is available with the current font)
+    #                     [value of default_kerning?]
+    # <tt>:size</tt>:: <tt>number</tt>. The font size to use. [current font
+    #                  size]
+    # <tt>:character_spacing</tt>:: <tt>number</tt>. The amount of space to add
+    #                               to or remove from the default character
+    #                               spacing. [0]
+    # <tt>:style</tt>:: The style to use. The requested style must be part of
+    #                   the current font familly. [current style]
+    # <tt>:indent_paragraphs</tt>:: <tt>number</tt>. The amount to indent the
+    #                               first line of each paragraph. Omit this
+    #                               option if you do not want indenting
+    # <tt>:align</tt>:: <tt>:left</tt>, <tt>:center</tt>, <tt>:right</tt>, or
+    #                   <tt>:justify</tt> Alignment within the bounding box [:left]
+    # <tt>:valign</tt>:: <tt>:top</tt>, <tt>:center</tt>, or <tt>:bottom</tt>.
+    #                    Vertical alignment within the bounding box [:top]
+    # <tt>:leading</tt>:: <tt>number</tt>. Additional space between lines [0]
+    # <tt>:final_gap</tt>:: <tt>boolean</tt>. If true, then the space between
+    #                       each line is included below the last line;
+    #                       otherwise, document.y is placed just below the
+    #                       descender of the last line printed [true]
+    #                        
+    # == Exceptions
+    #
+    # Raises <tt>ArgumentError</tt> if <tt>:at</tt> option included
+    #
+    # Raises <tt>Prawn::Errrors::CannotFit</tt> if not wide enough to print
+    # any text
+    #
+    def text(string, options={})
+      # we modify the options. don't change the user's hash
+      options = options.dup
+
+      if options[:inline_format]
+        options.delete(:inline_format)
+        array = Text::Formatted::Parser.to_array(string)
+        formatted_text(array, options)
+        return
+      end
+
+      inspect_options_for_text(options)
+
+      if @indent_paragraphs
+        string.split("\n").each do |paragraph|
+          options[:skip_encoding] = false
+          remaining_text = draw_indented_line(paragraph, options)
+          options[:skip_encoding] = true
+          if remaining_text == paragraph
+            # we were too close to the bottom of the page to print even one line
+            @bounding_box.move_past_bottom
+            remaining_text = draw_indented_line(paragraph, options)
+          end
+          remaining_text = fill_text_box(remaining_text, options)
+          draw_remaining_text_on_new_pages(remaining_text, options)
+        end
+      else
+        remaining_text = fill_text_box(string, options)
+        options[:skip_encoding] = true
+        draw_remaining_text_on_new_pages(remaining_text, options)
+      end
+    end
+
+
+    # Draws formatted text to the page.
+    # Formatted text is comprised of an array of hashes, where each hash defines
+    # text and format information. See Text::Formatted#formatted_text_box for
+    # more information on the structure of this array
+    #
+    # == Example
+    #
+    #   text([{ :text => "hello" },
+    #         { :text => "world",
+    #           :size => 24,
+    #           :style => [:bold, :italic] }])
+    #
+    # == Options
+    #
+    # Accepts the same options as #text
+    #
+    # == Exceptions
+    #
+    # Same as for #text
+    #
+    def formatted_text(array, options={})
+      # we modify the options. don't change the user's hash
+      options = options.dup
+
+      inspect_options_for_text(options)
+
+      if @indent_paragraphs
+        Text::Formatted::Parser.array_paragraphs(array).each do |paragraph|
+          options[:skip_encoding] = false
+          remaining_text = draw_indented_formatted_line(paragraph, options)
+          options[:skip_encoding] = true
+          if remaining_text == paragraph
+            # we were too close to the bottom of the page to print even one line
+            @bounding_box.move_past_bottom
+            remaining_text = draw_indented_formatted_line(paragraph, options)
+          end
+          remaining_text = fill_formatted_text_box(remaining_text, options)
+          draw_remaining_formatted_text_on_new_pages(remaining_text, options)
+        end
+      else
+        remaining_text = fill_formatted_text_box(array, options)
+        options[:skip_encoding] = true
+        draw_remaining_formatted_text_on_new_pages(remaining_text, options)
+      end
+    end
+
+    # Draws text on the page, beginning at the point specified by the :at option
+    # the string is assumed to be pre-formatted to properly fit the page.
+    # 
+    #   pdf.draw_text "Hello World", :at => [100,100]
+    #   pdf.draw_text "Goodbye World", :at => [50,50], :size => 16
+    #
+    # If your font contains kerning pair data that Prawn can parse, the
+    # text will be kerned by default. You can disable kerning by including
+    # a false <tt>:kerning</tt> option. If you want to disable kerning on an
+    # entire document, set default_kerning = false for that document
+    #
+    # === Text Positioning Details:
+    #
+    # Prawn will position your text by the left-most edge of its baseline, and
+    # flow along a single line.  (This means that :align will not work)
+    #
+    # == Rotation
+    #
+    # Text can be rotated before it is placed on the canvas by specifying the
+    # <tt>:rotate</tt> option with a given angle. Rotation occurs counter-clockwise.
+    #
+    # == Encoding
+    #
+    # Note that strings passed to this function should be encoded as UTF-8.
+    # If you get unexpected characters appearing in your rendered document, 
+    # check this.
+    #
+    # If the current font is a built-in one, although the string must be
+    # encoded as UTF-8, only characters that are available in WinAnsi
+    # are allowed.
+    #
+    # If an empty box is rendered to your PDF instead of the character you 
+    # wanted it usually means the current font doesn't include that character.
+    #
+    # == Options (default values marked in [])
+    #
+    # <tt>:at</tt>:: <tt>[x, y]</tt>(required). The position at which to start the text
+    # <tt>:kerning</tt>:: <tt>boolean</tt>. Whether or not to use kerning (if it
+    #                     is available with the current font)
+    #                     [value of default_kerning?]
+    # <tt>:size</tt>:: <tt>number</tt>. The font size to use. [current font
+    #                  size]
+    # <tt>:style</tt>:: The style to use. The requested style must be part of
+    #                   the current font familly. [current style]
+    #
+    # <tt>:rotate</tt>:: <tt>number</tt>. The angle to which to rotate text
+    #
+    # == Exceptions
+    #
+    # Raises <tt>ArgumentError</tt> if <tt>:at</tt> option omitted
+    #
+    # Raises <tt>ArgumentError</tt> if <tt>:align</tt> option included
+    #
+    def draw_text(text, options)
+      # we modify the options. don't change the user's hash
+      options = options.dup
+      inspect_options_for_draw_text(options)
+      # dup because normalize_encoding changes the string
+      text = text.to_s.dup
+      save_font do
+        process_text_options(options)
+        font.normalize_encoding!(text) unless @skip_encoding
+        font_size(options[:size]) { draw_text!(text, options) }
+      end
+    end
+
+    # Gets height of text in PDF points.
+    # Same options as #text, except as noted.
+    # Not compatible with :indent_paragraphs option
+    #
+    # ==Example
+    #
+    #   height_of("hello\nworld")
+    #
+    # == Exceptions
+    #
+    # Raises <tt>NotImplementedError</tt> if <tt>:indent_paragraphs</tt>
+    # option included
+    #
+    # Raises <tt>Prawn::Errrors::CannotFit</tt> if not wide enough to print
+    # any text
+    #
+    def height_of(string, options={})
+      if options[:indent_paragraphs]
+        raise NotImplementedError, ":indent_paragraphs option not available" +
+          "with height_of"
+      end
+      process_final_gap_option(options)
+      box = Text::Box.new(string,
+                          options.merge(:height   => 100000000,
+                                        :document => self))
+      printed = box.render(:dry_run => true)
+
+      height = box.height - (box.line_height - box.ascender)
+      height += box.line_height + box.leading - box.ascender if @final_gap
+      height
+    end
+
+    # Gets height of formatted text in PDF points.
+    # See documentation for #height_of.
+    #
+    # ==Example
+    #
+    #   height_of_formatted([{ :text => "hello" },
+    #                        { :text => "world",
+    #                          :size => 24,
+    #                          :style => [:bold, :italic] }])
+    #
+    def height_of_formatted(array, options={})
+      if options[:indent_paragraphs]
+        raise NotImplementedError, ":indent_paragraphs option not available" +
+          "with height_of"
+      end
+      process_final_gap_option(options)
+      box = Text::Formatted::Box.new(array,
+                          options.merge(:height   => 100000000,
+                                        :document => self))
+      printed = box.render(:dry_run => true)
+
+      height = box.height - (box.line_height - box.ascender)
+      height += box.line_height + box.leading - box.ascender if @final_gap
+      height
+    end
+
+    private
+
+    def draw_remaining_text_on_new_pages(remaining_text, options)
+      while remaining_text.length > 0
+        @bounding_box.move_past_bottom
+        previous_remaining_text = remaining_text
+        remaining_text = fill_text_box(remaining_text, options)
+        break if remaining_text == previous_remaining_text
+      end
+    end
+
+    def draw_indented_line(string, options)
+      indent(@indent_paragraphs) do
+        fill_text_box(string, options.dup.merge(:single_line => true))
+      end
+    end
+
+    def fill_text_box(text, options)
+      merge_text_box_positioning_options(options)
+
+      box = Text::Box.new(text, options)
+      remaining_text = box.render
+
+      self.y -= box.height - (box.line_height - box.ascender)
+      if @final_gap
+        self.y -= box.line_height + box.leading - box.ascender
+      end
+      remaining_text
+    end
+
+
+
+
+    def draw_remaining_formatted_text_on_new_pages(remaining_text, options)
+      while remaining_text.length > 0
+        @bounding_box.move_past_bottom
+        previous_remaining_text = remaining_text
+        remaining_text = fill_formatted_text_box(remaining_text, options)
+        break if remaining_text == previous_remaining_text
+      end
+    end
+
+    def draw_indented_formatted_line(string, options)
+      indent(@indent_paragraphs) do
+        fill_formatted_text_box(string, options.dup.merge(:single_line => true))
+      end
+    end
+
+    def fill_formatted_text_box(text, options)
+      merge_text_box_positioning_options(options)
+      box = Text::Formatted::Box.new(text, options)
+      remaining_text = box.render
+
+      self.y -= box.height - (box.line_height - box.ascender)
+      if @final_gap
+        self.y -= box.line_height + box.leading - box.ascender
+      end
+      remaining_text
+    end
+
+
+
+    def merge_text_box_positioning_options(options)
+      bottom = @bounding_box.stretchy? ? @margin_box.absolute_bottom :
+                                         @bounding_box.absolute_bottom
+
+      options[:height] = y - bottom
+      options[:width] = bounds.width
+      options[:at] = [@bounding_box.left_side - @bounding_box.absolute_left,
+                      y - @bounding_box.absolute_bottom]
+    end
+
+    def inspect_options_for_draw_text(options)
+      if options[:at].nil?
+        raise ArgumentError, "The :at option is required for draw_text"
+      elsif options[:align]
+        raise ArgumentError, "The :align option does not work with draw_text"
+      end
+      if options[:kerning].nil? then
+        options[:kerning] = default_kerning?
+      end
+      valid_options = Prawn::Core::Text::VALID_OPTIONS + [:at, :rotate]
+      Prawn.verify_options(valid_options, options)
+    end
+
+    def inspect_options_for_text(options)
+      if options[:at]
+        raise ArgumentError, ":at is no longer a valid option with text." +
+                             "use draw_text or text_box instead"
+      end
+      process_final_gap_option(options)
+      process_indent_paragraphs_option(options)
+      options[:document] = self
+    end
+
+    def process_final_gap_option(options)
+      @final_gap = options[:final_gap].nil? || options[:final_gap]
+      options.delete(:final_gap)
+    end
+
+    def process_indent_paragraphs_option(options)
+      @indent_paragraphs = options[:indent_paragraphs]
+      options.delete(:indent_paragraphs)
+    end
+
+    def move_text_position(dy)
+      bottom = @bounding_box.stretchy? ? @margin_box.absolute_bottom :
+                                         @bounding_box.absolute_bottom
+
+      @bounding_box.move_past_bottom if (y - dy) < bottom
+
+      self.y -= dy
+    end
+  end
+end

data/lib/prawn/text/box.rb

@@ -0,0 +1,392 @@
+# encoding: utf-8
+
+# text/rectangle.rb : Implements text boxes
+#
+# Copyright November 2009, Daniel Nelson. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+
+module Prawn
+  module Text
+
+    # Draws the requested text into a box. When the text overflows
+    # the rectangle, you can display ellipses, shrink to fit, or
+    # truncate the text. Text boxes are independent of the document
+    # y position.
+    #
+    # == Encoding
+    #
+    # Note that strings passed to this function should be encoded as UTF-8.
+    # If you get unexpected characters appearing in your rendered document, 
+    # check this.
+    #
+    # If the current font is a built-in one, although the string must be
+    # encoded as UTF-8, only characters that are available in WinAnsi
+    # are allowed.
+    #
+    # If an empty box is rendered to your PDF instead of the character you 
+    # wanted it usually means the current font doesn't include that character.
+    #
+    # == Options (default values marked in [])
+    #
+    # <tt>:kerning</tt>:: <tt>boolean</tt>. Whether or not to use kerning (if it
+    #                     is available with the current font)
+    #                     [value of document.default_kerning?]
+    # <tt>:size</tt>:: <tt>number</tt>. The font size to use. [current font
+    #                  size]
+    # <tt>:character_spacing</tt>:: <tt>number</tt>. The amount of space to add
+    #                               to or remove from the default character
+    #                               spacing. [0]
+    # <tt>:style</tt>:: The style to use. The requested style must be part of
+    #                   the current font familly. [current style]
+    #
+    # <tt>:at</tt>::
+    #     <tt>[x, y]</tt>. The upper left corner of the box
+    #     [@document.bounds.left, @document.bounds.top]
+    # <tt>:width</tt>::
+    #     <tt>number</tt>. The width of the box [@document.bounds.right - @at[0]]
+    # <tt>:height</tt>::
+    #     <tt>number</tt>. The height of the box [@at[1] - @document.bounds.bottom]
+    # <tt>:align</tt>::
+    #     <tt>:left</tt>, <tt>:center</tt>, <tt>:right</tt>, or
+    #     <tt>:justify</tt> Alignment within the bounding box [:left]
+    # <tt>:valign</tt>::
+    #     <tt>:top</tt>, <tt>:center</tt>, or <tt>:bottom</tt>. Vertical
+    #     alignment within the bounding box [:top]
+    #                   
+    # <tt>:rotate</tt>::
+    #     <tt>number</tt>. The angle to rotate the text
+    # <tt>:rotate_around</tt>::
+    #     <tt>:center</tt>, <tt>:upper_left</tt>, <tt>:upper_right</tt>,
+    #     <tt>:lower_right</tt>, or <tt>:lower_left</tt>. The point around which
+    #     to rotate the text [:upper_left]
+    # <tt>:leading</tt>::
+    #     <tt>number</tt>. Additional space between lines [0]
+    # <tt>:single_line</tt>::
+    #     <tt>boolean</tt>. If true, then only the first line will be drawn [false]
+    # <tt>:skip_encoding</tt>::
+    #     <tt>boolean</tt> [false]
+    # <tt>:overflow</tt>::
+    #     <tt>:truncate</tt>, <tt>:shrink_to_fit</tt>, <tt>:expand</tt>, or
+    #     <tt>:ellipses</tt>. This controls the behavior when the amount of text
+    #     exceeds the available space. <tt>:ellipses</tt> [:truncate]
+    # <tt>:min_font_size</tt>::
+    #     <tt>number</tt>. The minimum font size to use when :overflow is set to
+    #     :shrink_to_fit (that is the font size will not be reduced to less than
+    #     this value, even if it means that some text will be cut off). [5]
+    #
+    # == Returns
+    #
+    # Returns any text that did not print under the current settings.
+    #
+    # NOTE: if an AFM font is used, then the returned text is encoded in
+    # WinAnsi. Subsequent calls to text_box that pass this returned text back
+    # into text box must include a :skip_encoding => true option. This is
+    # unnecessary when using TTF fonts because those operate on UTF-8 encoding.
+    #
+    # == Exceptions
+    #
+    # Raises <tt>Prawn::Errrors::CannotFit</tt> if not wide enough to print
+    # any text
+    #
+    def text_box(string, options)
+      Text::Box.new(string, options.merge(:document => self)).render
+    end
+
+    # Generally, one would use the Prawn::Text#text_box convenience
+    # method. However, using Text::Box.new in conjunction with 
+    # #render(:dry_run=> true) enables one to do look-ahead calculations prior
+    # to placing text on the page, or to determine how much vertical space was
+    # consumed by the printed text
+    #
+    class Box
+      include Prawn::Core::Text::Wrap
+
+      def valid_options
+        Prawn::Core::Text::VALID_OPTIONS + [:at, :height, :width,
+                                            :align, :valign,
+                                            :rotate, :rotate_around,
+                                            :overflow, :min_font_size,
+                                            :leading, :character_spacing,
+                                            :single_line,
+                                            :skip_encoding,
+                                            :document]
+      end
+      
+      # The text that was successfully printed (or, if <tt>dry_run</tt> was
+      # used, the test that would have been successfully printed)
+      attr_reader :text
+      # The upper left corner of the text box
+      attr_reader :at
+      # The line height of the last line printed
+      attr_reader :line_height
+      # The height of the ascender of the last line printed
+      attr_reader :ascender
+      # The height of the descender of the last line printed
+      attr_reader :descender
+      # The leading used during printing
+      attr_reader :leading
+
+
+      # Extend Prawn::Text::Box
+      #
+      # Example (see Prawn::Text::Core::Wrap for what is required
+      # of the wrap method if you want to override the default
+      # wrapping algorithm):
+      #
+      #   module MyWrap
+      #
+      #     def wrap
+      #       @text = nil
+      #       @line_height = @document.font.height
+      #       @descender   = @document.font.descender
+      #       @ascender    = @document.font.ascender
+      #       @baseline_y  = -@ascender
+      #       draw_line("all your base are belong to us")
+      #       ""
+      #     end
+      #
+      #   end
+      #
+      #   Prawn::Text::Box.extensions << MyWrap
+      #
+      #   box = Prawn::Text::Box.new('hello world')
+      #   box.render('why can't I print anything other than' +
+      #              '"all your base are belong to us"?')
+      #
+      #
+      def self.extensions
+        @extensions ||= []
+      end
+
+      def self.inherited(base) #:nodoc:
+        extensions.each { |e| base.extensions << e }
+      end
+
+      # See Prawn::Text#text_box for valid options
+      #
+      def initialize(text, options={})
+        @inked             = false
+        Prawn.verify_options(valid_options, options)
+        options            = options.dup
+
+        self.class.extensions.reverse_each { |e| extend e }
+
+        @overflow          = options[:overflow] || :truncate
+
+        self.original_text = text
+        @text              = nil
+        
+        @document          = options[:document]
+        @at                = options[:at] ||
+                             [@document.bounds.left, @document.bounds.top]
+        @width             = options[:width] ||
+                             @document.bounds.right - @at[0]
+        @height            = options[:height] ||
+                             @at[1] - @document.bounds.bottom
+        @align             = options[:align] || :left
+        @vertical_align    = options[:valign] || :top
+        @leading           = options[:leading] || @document.default_leading?
+        @character_spacing = options[:character_spacing] ||
+                             @document.character_spacing
+        @rotate            = options[:rotate] || 0
+        @rotate_around     = options[:rotate_around] || :upper_left
+        @single_line       = options[:single_line]
+        @skip_encoding     = options[:skip_encoding] || @document.skip_encoding
+
+        if @overflow == :expand
+          # if set to expand, then we simply set the bottom
+          # as the bottom of the document bounds, since that
+          # is the maximum we should expand to
+          @height = @at[1] - @document.bounds.bottom
+          @overflow = :truncate
+        end
+        @min_font_size = options[:min_font_size] || 5
+        if options[:kerning].nil? then
+          options[:kerning] = @document.default_kerning?
+        end
+        @options = { :kerning => options[:kerning],
+                     :size    => options[:size],
+                     :style   => options[:style] }
+
+        super(text, options)
+      end
+      
+      # Render text to the document based on the settings defined in initialize.
+      #
+      # In order to facilitate look-ahead calculations, <tt>render</tt> accepts
+      # a <tt>:dry_run => true</tt> option. If provided, then everything is
+      # executed as if rendering, with the exception that nothing is drawn on
+      # the page. Useful for look-ahead computations of height, unprinted text,
+      # etc.
+      #
+      # Returns any text that did not print under the current settings
+      #
+      def render(flags={})
+        unprinted_text = ''
+        @document.save_font do
+          @document.character_spacing(@character_spacing) do
+            process_options
+
+            if @skip_encoding
+              text = original_text
+            else
+              text = normalize_encoding
+            end
+
+            @document.font_size(@font_size) do
+              shrink_to_fit(text) if @overflow == :shrink_to_fit
+              process_vertical_alignment(text)
+              @inked = true unless flags[:dry_run]
+              if @rotate != 0 && @inked
+                unprinted_text = render_rotated(text)
+              else
+                unprinted_text = wrap(text)
+              end
+              @inked = false
+            end
+          end
+        end
+
+        unprinted_text
+      end
+
+      # The height actually used during the previous <tt>render</tt>
+      # 
+      def height
+        return 0 if @baseline_y.nil? || @descender.nil?
+        # baseline is already pushed down one line below the current
+        # line, so we need to subtract line line_height and leading,
+        # but we need to add in the descender since baseline is
+        # above the descender
+        @baseline_y.abs - @ascender - @leading
+      end
+
+      # The width available at this point in the box
+      #
+      def available_width
+        @width
+      end
+
+      def draw_line(line_to_print, line_width=0, word_spacing=0, include_ellipses=false) #:nodoc:
+        insert_ellipses(line_to_print) if include_ellipses
+
+        case(@align)
+        when :left, :justify
+          x = @at[0]
+        when :center
+          x = @at[0] + @width * 0.5 - line_width * 0.5
+        when :right
+          x = @at[0] + @width - line_width
+        end
+        
+        y = @at[1] + @baseline_y
+        
+        if @inked
+          if @align == :justify
+            @document.word_spacing(word_spacing) {
+              @document.character_spacing(@character_spacing) {
+                @document.draw_text!(line_to_print, :at => [x, y],
+                                     :kerning => @kerning)
+              }
+            }
+          else
+            @document.character_spacing(@character_spacing) {
+              @document.draw_text!(line_to_print, :at => [x, y],
+                                   :kerning => @kerning)
+            }
+          end
+        end
+        
+        line_to_print
+      end
+
+      private
+
+      def normalize_encoding
+        @document.font.normalize_encoding(@original_string)
+      end
+
+      def original_text
+        @original_string
+      end
+
+      def original_text=(string)
+        @original_string = string.dup
+      end
+
+      def process_vertical_alignment(text)
+        return if @vertical_align == :top
+        wrap(text)
+        case @vertical_align
+        when :center
+          @at[1] = @at[1] - (@height - height) * 0.5
+        when :bottom
+          @at[1] = @at[1] - (@height - height)
+        end
+        @height = height
+      end
+
+      # Decrease the font size until the text fits or the min font
+      # size is reached
+      def shrink_to_fit(text)
+        while (unprinted_text = wrap(text)).length > 0 &&
+            @font_size > @min_font_size
+          @font_size -= 0.5
+          @document.font_size = @font_size
+        end
+      end
+
+      def process_options
+        # must be performed within a save_font bock because
+        # document.process_text_options sets the font
+        @document.process_text_options(@options)
+        @font_size = @options[:size]
+        @kerning   = @options[:kerning]
+      end
+
+      def render_rotated(text)
+        unprinted_text = ''
+
+        case @rotate_around
+        when :center
+          x = @at[0] + @width * 0.5
+          y = @at[1] - @height * 0.5
+        when :upper_right
+          x = @at[0] + @width
+          y = @at[1]
+        when :lower_right
+          x = @at[0] + @width
+          y = @at[1] - @height
+        when :lower_left
+          x = @at[0]
+          y = @at[1] - @height
+        else
+          x = @at[0]
+          y = @at[1]
+        end
+
+        @document.rotate(@rotate, :origin => [x, y]) do
+          unprinted_text = wrap(text)
+        end
+        unprinted_text
+      end
+      
+      def last_line?
+        @baseline_y.abs + @descender > @height - @line_height
+      end
+
+      def insert_ellipses(line_to_print)
+        if @document.width_of(line_to_print + "...",
+                              :kerning => @kerning) < available_width
+          line_to_print.insert(-1, "...")
+        else
+          line_to_print[-3..-1] = "..." if line_to_print.length > 3
+        end
+      end
+
+    end
+
+  end
+end