prawn 0.11.1.pre → 0.11.1

data/lib/prawn/table/cell/text.rb

@@ -14,9 +14,9 @@ module Prawn
       #
       class Text < Cell
 
-        TextOptions = [:inline_format, :kerning, :size, :style,
-          :align, :valign, :rotate, :rotate_around, :leading, :single_line,
-          :skip_encoding, :overflow, :min_font_size]
+        TextOptions = [:inline_format, :kerning, :size, :align, :valign,
+          :rotate, :rotate_around, :leading, :single_line, :skip_encoding,
+          :overflow, :min_font_size]
 
         TextOptions.each do |option|
           define_method("#{option}=") { |v| @text_options[option] = v }
@@ -28,12 +28,6 @@ module Prawn
         def initialize(pdf, point, options={})
           @text_options = {}
           super
-          
-          # Sets a reasonable minimum width. If the cell has any content, make
-          # sure we have enough width to be at least one character wide. This is
-          # a bit of a hack, but it should work well enough.
-          min_content_width = [natural_content_width, styled_width_of("M")].min
-          @min_width = padding_left + padding_right + min_content_width
         end
 
         # Returns the font that will be used to draw this cell.
@@ -42,6 +36,13 @@ module Prawn
           with_font { @pdf.font }
         end
 
+        # Sets the style of the font in use. Equivalent to the Text::Box
+        # +style+ option, but we already have a style method.
+        #
+        def font_style=(style)
+          @text_options[:style] = style
+        end
+
         # Returns the width of this text with no wrapping. This will be far off
         # from the final width if the text is long.
         #
@@ -56,7 +57,7 @@ module Prawn
           with_font do
             b = text_box(:width => content_width + FPTolerance)
             b.render(:dry_run => true)
-            b.height
+            b.height + b.line_gap
           end
         end
 
@@ -75,6 +76,15 @@ module Prawn
 
         protected
 
+        def set_width_constraints
+          # Sets a reasonable minimum width. If the cell has any content, make
+          # sure we have enough width to be at least one character wide. This is
+          # a bit of a hack, but it should work well enough.
+          min_content_width = [natural_content_width, styled_width_of("M")].min
+          @min_width ||= padding_left + padding_right + min_content_width
+          super
+        end
+
         def with_font
           @pdf.save_font do
             options = {}

data/lib/prawn/table/cells.rb

@@ -54,6 +54,7 @@ module Prawn
       #
       def rows(row_spec)
         index_cells unless @indexed
+        row_spec = transform_spec(row_spec, @row_count)
         Cells.new(@rows[row_spec] ||= select{ |c| row_spec === c.row })
       end
       alias_method :row, :rows
@@ -65,9 +66,10 @@ module Prawn
       #   table.column(0)     # selects first column
       #   table.columns(3..4) # selects columns four and five
       #
-      def columns(row_spec)
+      def columns(col_spec)
         index_cells unless @indexed
-        Cells.new(@columns[row_spec] ||= select{ |c| row_spec === c.column })
+        col_spec = transform_spec(col_spec, @column_count)
+        Cells.new(@columns[col_spec] ||= select{ |c| col_spec === c.column })
       end
       alias_method :column, :columns
 
@@ -104,10 +106,7 @@ module Prawn
       #   table.cells.style { |cell| cell.border_width += 12 }
       #
       def style(options={}, &block)
-        each do |cell| 
-          options.each { |k, v| cell.send("#{k}=", v) }
-          block.call(cell) if block
-        end
+        each { |cell| cell.style(options, &block) }
       end
 
       # Returns the total width of all columns in the selected set.
@@ -182,8 +181,26 @@ module Prawn
           @columns[cell.column] << cell
         end
 
+        @row_count    = @rows.size
+        @column_count = @columns.size
+
         @indexed = true
       end
+
+      # Transforms +spec+, a column / row specification, into an object that
+      # can be compared against a row or column number using ===. Normalizes
+      # negative indices to be positive, given a total size of +total+.
+      #
+      def transform_spec(spec, total)
+        case spec
+        when Range
+          transform_spec(spec.begin, total)..transform_spec(spec.end, total)
+        when Integer
+          spec < 0 ? (total + spec) : spec
+        else # pass through
+          spec
+        end
+      end
     end
   end
 end

data/lib/prawn/text.rb

@@ -6,9 +6,8 @@
 #
 # 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 "prawn/text/box"
 require "zlib"
 
 module Prawn
@@ -17,7 +16,12 @@ module Prawn
     include Prawn::Core::Text
     include Prawn::Text::Formatted
 
+    # No-Break Space
     Prawn::Text::NBSP = " "
+    # Zero Width Space (indicate word boundaries without a space)
+    Prawn::Text::ZWSP = [8203].pack("U")
+    # Soft Hyphen (invisible, except when causing a line break)
+    Prawn::Text::SHY = "­"
 
     # 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
@@ -100,7 +104,7 @@ module Prawn
     #
     # <tt>:kerning</tt>:: <tt>boolean</tt>. Whether or not to use kerning (if it
     #                     is available with the current font)
-    #                     [value of default_kerning?]
+    #                     [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
@@ -111,15 +115,33 @@ module Prawn
     # <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>:direction</tt>::
+    #     <tt>:ltr</tt>, <tt>:rtl</tt>, Direction of the text (left-to-right
+    #     or right-to-left) [value of document.text_direction]
+    # <tt>:fallback_fonts</tt>::
+    #     An array of font names. Each name must be the name of an AFM font or
+    #     the name that was used to register a family of TTF fonts (see
+    #     Prawn::Document#font_families). If present, then each glyph will be
+    #     rendered using the first font that includes the glyph, starting with
+    #     the current font and then moving through :fallback_fonts from
+    #     left to right.
+    # <tt>:align</tt>::
+    #     <tt>:left</tt>, <tt>:center</tt>, <tt>:right</tt>, or
+    #     <tt>:justify</tt> Alignment within the bounding box
+    #     [:left if direction is :ltr, :right if direction is :rtl]
     # <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>:leading</tt>::
+    #     <tt>number</tt>. Additional space between lines [value of
+    #     document.default_leading]
     # <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]
+    # <tt>:mode</tt>:: The text rendering mode to use. Use this to specify if the
+    #                  text should render with the fill color, stroke color or
+    #                  both. See the comments to text_rendering_mode() to see
+    #                  a list of valid options. [0]
     #                        
     # == Exceptions
     #
@@ -135,30 +157,11 @@ module Prawn
       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)
+        array = [{ :text => string }]
       end
+
+      formatted_text(array, options)
     end
 
 
@@ -183,21 +186,24 @@ module Prawn
     # 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)
+      options = inspect_options_for_text(options.dup)
 
       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)
+
+          if @no_text_printed
+            # unless this paragraph was an empty line
+            unless @all_text_printed
+              @bounding_box.move_past_bottom
+              options[:skip_encoding] = false
+              remaining_text = draw_indented_formatted_line(paragraph, options)
+              options[:skip_encoding] = true
+            end
           end
+
           remaining_text = fill_formatted_text_box(remaining_text, options)
           draw_remaining_formatted_text_on_new_pages(remaining_text, options)
         end
@@ -262,9 +268,8 @@ module Prawn
     # 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)
+      options = inspect_options_for_draw_text(options.dup)
+
       # dup because normalize_encoding changes the string
       text = text.to_s.dup
       save_font do
@@ -291,19 +296,7 @@ module Prawn
     # 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
+      height_of_formatted([{ :text => string }], options)
     end
 
     # Gets height of formatted text in PDF points.
@@ -327,44 +320,13 @@ module Prawn
                                         :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 = box.height
+      height += box.line_gap + box.leading 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
@@ -384,16 +346,15 @@ module Prawn
       merge_text_box_positioning_options(options)
       box = Text::Formatted::Box.new(text, options)
       remaining_text = box.render
+      @no_text_printed = box.nothing_printed?
+      @all_text_printed = box.everything_printed?
+
+      self.y -= box.height
+      self.y -= box.line_gap + box.leading if @final_gap
 
-      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
@@ -415,6 +376,7 @@ module Prawn
       end
       valid_options = Prawn::Core::Text::VALID_OPTIONS + [:at, :rotate]
       Prawn.verify_options(valid_options, options)
+      options
     end
 
     def inspect_options_for_text(options)
@@ -425,6 +387,7 @@ module Prawn
       process_final_gap_option(options)
       process_indent_paragraphs_option(options)
       options[:document] = self
+      options
     end
 
     def process_final_gap_option(options)

data/lib/prawn/text/box.rb

@@ -11,9 +11,8 @@ 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.
+    # the rectangle, you shrink to fit, or truncate the text. Text
+    # boxes are independent of the document y position.
     #
     # == Encoding
     #
@@ -38,6 +37,9 @@ module Prawn
     # <tt>:character_spacing</tt>:: <tt>number</tt>. The amount of space to add
     #                               to or remove from the default character
     #                               spacing. [0]
+    # <tt>:mode</tt>:: <tt>symbol</tt>. The text rendering mode. See
+    #                  documentation for Prawn::Document#text_rendering_mode
+    #                  for a list of valid options. [:fill]
     # <tt>:style</tt>:: The style to use. The requested style must be part of
     #                   the current font familly. [current style]
     #
@@ -47,10 +49,21 @@ module Prawn
     # <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>number</tt>. The height of the box [default_height()]
+    # <tt>:direction</tt>::
+    #     <tt>:ltr</tt>, <tt>:rtl</tt>, Direction of the text (left-to-right
+    #     or right-to-left) [value of document.text_direction]
+    # <tt>:fallback_fonts</tt>::
+    #     An array of font names. Each name must be the name of an AFM font or
+    #     the name that was used to register a family of TTF fonts (see
+    #     Prawn::Document#font_families). If present, then each glyph will be
+    #     rendered using the first font that includes the glyph, starting with
+    #     the current font and then moving through :fallback_fonts from
+    #     left to right.
     # <tt>:align</tt>::
     #     <tt>:left</tt>, <tt>:center</tt>, <tt>:right</tt>, or
-    #     <tt>:justify</tt> Alignment within the bounding box [:left]
+    #     <tt>:justify</tt> Alignment within the bounding box
+    #     [:left if direction is :ltr, :right if direction is :rtl]
     # <tt>:valign</tt>::
     #     <tt>:top</tt>, <tt>:center</tt>, or <tt>:bottom</tt>. Vertical
     #     alignment within the bounding box [:top]
@@ -62,15 +75,16 @@ module Prawn
     #     <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>number</tt>. Additional space between lines [value of
+    #     document.default_leading]
     # <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>:truncate</tt>, <tt>:shrink_to_fit</tt>, or <tt>:expand</tt>
+    #     This controls the behavior when the amount of text
+    #     exceeds the available space. [: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
@@ -90,7 +104,7 @@ module Prawn
     # Raises <tt>Prawn::Errrors::CannotFit</tt> if not wide enough to print
     # any text
     #
-    def text_box(string, options)
+    def text_box(string, options={})
       Text::Box.new(string, options.merge(:document => self)).render
     end
 
@@ -100,283 +114,15 @@ module Prawn
     # 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
+    class Box < Prawn::Text::Formatted::Box
 
-      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]
+      def initialize(string, options={})
+        super([{ :text => string }], options)
       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
-          @document.word_spacing(word_spacing) {
-            @document.character_spacing(@character_spacing) {
-              @document.draw_text!(line_to_print, :at => [x, y],
-                                   :kerning => @kerning)
-            }
-          }
-        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
+        leftover = super(flags)
+        leftover.collect { |hash| hash[:text] }.join
       end
 
     end