prawn 0.1.2 → 0.2.0

data/lib/prawn/document/internals.rb

@@ -0,0 +1,107 @@
+module Prawn
+  class Document     
+    
+    # This module exposes a few low-level PDF features for those who want
+    # to extend Prawn's core functionality.  If you are not comfortable with
+    # low level PDF functionality as defined by Adobe's specification, chances
+    # are you won't need anything you find here.  
+    #
+    module Internals    
+      
+      # Creates a new Prawn::Reference and adds it to the Document's object
+      # list.  The +data+ argument is anything that Prawn::PdfObject() can convert.    
+      def ref(data)
+        @objects.push(Prawn::Reference.new(@objects.size + 1, data)).last
+      end                                               
+      
+      # Appends a raw string to the current page content.
+      #                               
+      #  # Raw line drawing example:           
+      #  x1,y1,x2,y2 = 100,500,300,550
+      #  pdf.add_content("%.3f %.3f m" % [ x1, y1 ])  # move 
+      #  pdf.add_content("%.3f %.3f l" % [ x2, y2 ])  # draw path
+      #  pdf.add_content("S") # stroke                    
+      #
+      def add_content(str)
+       @page_content << str << "\n"
+      end  
+
+      # Add a new type to the current pages ProcSet 
+      #
+      def proc_set(*types)
+        @current_page.data[:ProcSet] ||= ref([])
+        @current_page.data[:ProcSet].data |= types
+      end
+             
+      # The Resources dictionary for the current page
+      #
+      def page_resources
+        @current_page.data[:Resources] ||= {}
+      end
+      
+      # The Font dictionary for the current page
+      #
+      def page_fonts
+        page_resources[:Font] ||= {}
+      end
+       
+      # The XObject dictionary for the current page
+      def page_xobjects
+        page_resources[:XObject] ||= {}
+      end  
+      
+      private      
+      
+      def finish_page_content     
+        @header.draw if @header      
+        @footer.draw if @footer
+        add_content "Q"
+        @page_content.compress_stream if compression_enabled?
+        @page_content.data[:Length] = @page_content.stream.size
+      end
+
+      # Write out the PDF Header, as per spec 3.4.1
+      def render_header(output)
+        # pdf version
+        output << "%PDF-1.3\n"
+
+        # 4 binary chars, as recommended by the spec
+        output << "\xFF\xFF\xFF\xFF\n"
+      end
+
+      # Write out the PDF Body, as per spec 3.4.2
+      def render_body(output)
+        @objects.each do |ref|
+          ref.offset = output.size
+          output << ref.object
+        end
+      end
+
+      # Write out the PDF Cross Reference Table, as per spec 3.4.3
+      def render_xref(output)
+        @xref_offset = output.size
+        output << "xref\n"
+        output << "0 #{@objects.size + 1}\n"
+        output << "0000000000 65535 f \n"
+        @objects.each do |ref|
+          output.printf("%010d", ref.offset)
+          output << " 00000 n \n"
+        end
+      end
+
+      # Write out the PDF Body, as per spec 3.4.4
+      def render_trailer(output)
+        trailer_hash = {:Size => @objects.size + 1, 
+                        :Root => @root,
+                        :Info => @info}
+
+        output << "trailer\n"
+        output << Prawn::PdfObject(trailer_hash) << "\n"
+        output << "startxref\n" 
+        output << @xref_offset << "\n"
+        output << "%%EOF"
+      end
+                 
+    end
+  end
+end

data/lib/prawn/document/table.rb

@@ -7,8 +7,8 @@
 # This is free software. Please see the LICENSE and COPYING files for details.
 
 module Prawn
-  class Document
-
+  class Document    
+    
     # Builds and renders a Document::Table object from raw data.
     # For details on the options that can be passed, see
     # Document::Table.new
@@ -37,7 +37,7 @@ module Prawn
     #
     #   end
     #
-    def table(data,options={})
+    def table(data,options={})           
       Prawn::Document::Table.new(data,self,options).draw
     end
 
@@ -53,6 +53,7 @@ module Prawn
     #   * Automated page-breaking as needed
     #   * Column widths can be calculated automatically or defined explictly on a 
     #     column by column basis
+    #   * Text alignment can be set for the whole table or by column
     #
     # The current implementation is a bit barebones, but covers most of the
     # basic needs for PDF table generation.  If you have feature requests,
@@ -61,9 +62,13 @@ module Prawn
     # Tables will be revisited before the end of the Ruby Mendicant project and
     # the most commonly needed functionality will likely be added.
     # 
-    class Table
+    class Table  
+      
+      include Prawn::Configurable
 
-      attr_reader :col_widths # :nodoc:
+      attr_reader :col_widths # :nodoc: 
+      
+      NUMBER_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+(?:[eE][+-]?\d+)?)?$/ #:nodoc: 
 
       # Creates a new Document::Table object. This is generally called 
       # indirectly through Document#table but can also be used explictly.
@@ -79,12 +84,13 @@ module Prawn
       # <tt>:horizontal_padding</tt>:: The horizontal cell padding in PDF points [5]
       # <tt>:vertical_padding</tt>:: The vertical cell padding in PDF points [5]
       # <tt>:padding</tt>:: Horizontal and vertical cell padding (overrides both)
-      # <tt>:border</tt>:: With of border lines in PDF points [1]
+      # <tt>:border_width</tt>:: With of border lines in PDF points [1]
       # <tt>:border_style</tt>:: If set to :grid, fills in all borders.  Otherwise, borders are drawn on columns only, not rows
       # <tt>:position</tt>:: One of <tt>:left</tt>, <tt>:center</tt> or <tt>n</tt>, where <tt>n</tt> is an x-offset from the left edge of the current bounding box
       # <tt>:widths:</tt> A hash of indices and widths in PDF points.  E.g. <tt>{ 0 => 50, 1 => 100 }</tt>
       # <tt>:row_colors</tt>:: An array of row background colors which are used cyclicly.   
-      # <tt>:align</tt>:: Alignment of text in columns [:left]
+      # <tt>:align</tt>:: Alignment of text in columns, for entire table (<tt>:center</tt>) or by column (<tt>{ 0 => :left, 1 => :center}</tt>)
+      # <tt>:align_headers</tt>:: Alignment of header text.
       #
       # Row colors are specified as html encoded values, e.g.
       # ["ffffff","aaaaaa","ccaaff"].  You can also specify 
@@ -94,31 +100,37 @@ module Prawn
       # See Document#table for typical usage, as directly using this class is
       # not recommended unless you know why you want to do it.
       #
-      def initialize(data, document,options={})
-        @data                = data
-        @document            = document
-        @font_size           = options[:font_size] || 12
-        @border_style        = options[:border_style]
-        @border              = options[:border]    || 1
-        @position            = options[:position]  || :left
-        @headers             = options[:headers]
-        @row_colors          = options[:row_colors]   
-        @align               = options[:align]
-
-        @horizontal_padding  = options[:horizontal_padding] || 5
-        @vertical_padding    = options[:vertical_padding]   || 5
-
-        if options[:padding]
-          @horizontal_padding = @vertical_padding = options[:padding]
+      def initialize(data, document,options={})     
+        unless data.all? { |e| Array === e }
+          raise Prawn::Errors::InvalidTableData,
+            "data must be a two dimensional array of Prawn::Cells or strings"
         end
-
         
-        @row_colors = ["ffffff","cccccc"] if @row_colors == :pdf_writer
+        @data     = data        
+        @document = document
+        
+        Prawn.verify_options [:font_size,:border_style, :border_width,
+         :position, :headers, :row_colors, :align, :align_headers, 
+         :horizontal_padding, :vertical_padding, :padding, :widths ], options     
+                                            
+        configuration.update(options)  
 
-        @original_row_colors = @row_colors.dup if @row_colors  
+        if padding = options[:padding]
+          C(:horizontal_padding => padding, :vertical_padding => padding) 
+        end
+         
+        if options[:row_colors] == :pdf_writer 
+          C(:row_colors => ["ffffff","cccccc"])  
+        end
         
+        if options[:row_colors]
+          C(:original_row_colors => C(:row_colors)) 
+        end
+
         calculate_column_widths(options[:widths])
-      end
+      end                                        
+      
+      attr_reader :col_widths #:nodoc:
       
       # Width of the table in PDF points
       #
@@ -128,85 +140,98 @@ module Prawn
       
       # Draws the table onto the PDF document
       #
-      def draw
-        case(@position) 
+      def draw  
+        @parent_bounds = @document.bounds  
+        case C(:position) 
         when :center
           x = (@document.bounds.width - width) / 2.0
-          y = @document.y - @document.bounds.absolute_bottom
-          @document.bounding_box [x, y], :width => width do
+          dy = @document.bounds.absolute_top - @document.y
+          @document.bounding_box [x, @parent_bounds.top], :width => width do 
+            @document.move_down(dy)
             generate_table
           end
         when Numeric     
-          x = @position
-          y = @document.y - @document.bounds.absolute_bottom
-          @document.bounding_box [x,y], :width => width do
-            generate_table
-          end
+          x, y = C(:position), @document.y - @document.bounds.absolute_bottom
+          @document.bounding_box([x,y], :width => width) { generate_table }
         else
           generate_table
         end
       end
 
       private
+      
+      def default_configuration     
+        { :font_size           => 12, 
+          :border_width        => 1, 
+          :position            => :left,
+          :horizontal_padding  => 5,
+          :vertical_padding    => 5 } 
+      end
 
       def calculate_column_widths(manual_widths=nil)
         @col_widths = [0] * @data[0].length    
         renderable_data.each do |row|
           row.each_with_index do |cell,i|
             length = cell.to_s.lines.map { |e| 
-              @document.font_metrics.string_width(e,@font_size) }.max.to_f +
-                2*@horizontal_padding
-            @col_widths[i] = length if length > @col_widths[i]
+              @document.font.metrics.string_width(e,C(:font_size)) }.max.to_f +
+                2*C(:horizontal_padding)
+            @col_widths[i] = length.ceil if length > @col_widths[i]
           end
         end  
         
-        # TODO: Could optimize here
         manual_widths.each { |k,v| @col_widths[k] = v } if manual_widths           
       end
 
       def renderable_data
-        if @headers
-          [@headers] + @data
-        else
-          @data
-        end
+        C(:headers) ? [C(:headers)] + @data : @data
       end
 
-      def generate_table
+      def generate_table    
         page_contents = []
-        y_pos = @document.y
+        y_pos = @document.y 
 
-        @document.font_size(@font_size) do
+        @document.font.size C(:font_size) do
           renderable_data.each_with_index do |row,index|
             c = Prawn::Graphics::CellBlock.new(@document)
-            row.each_with_index do |e,i| 
-              case(e)
+            row.each_with_index do |e,i|     
+              case C(:align)
+              when Hash
+                align            = C(:align)[i]
+              else
+                align            = C(:align)
+              end   
+              
+              
+              align ||= e.to_s =~ NUMBER_PATTERN ? :right : :left 
+              
+              case e
               when Prawn::Graphics::Cell
                 e.document = @document
                 e.width    = @col_widths[i]
-                e.horizontal_padding = @horizontal_padding
-                e.vertical_padding   = @vertical_padding    
-                e.border             = @border
+                e.horizontal_padding = C(:horizontal_padding)
+                e.vertical_padding   = C(:vertical_padding)    
+                e.border_width       = C(:border_width)
                 e.border_style       = :sides
-                e.align              = @align
+                e.align              = align 
                 c << e
               else
                 c << Prawn::Graphics::Cell.new(
                   :document => @document, 
                   :text     => e.to_s, 
                   :width    => @col_widths[i],
-                  :horizontal_padding => @horizontal_padding,
-                  :vertical_padding => @vertical_padding,
-                  :border   => @border,
-                  :border_style => :sides,
-                  :align    => @align ) 
+                  :horizontal_padding => C(:horizontal_padding),
+                  :vertical_padding   => C(:vertical_padding),
+                  :border_width       => C(:border_width),
+                  :border_style       => :sides,
+                  :align              => align ) 
               end   
             end
-
-            if c.height > y_pos - @document.margin_box.absolute_bottom
+                                                
+            bbox = @parent_bounds.stretchy? ? @document.margin_box : @parent_bounds
+            if c.height > y_pos - bbox.absolute_bottom
               draw_page(page_contents)
               @document.start_new_page
-              if @headers
+              if C(:headers)
                 page_contents = [page_contents[0]]
                 y_pos = @document.y - page_contents[0].height
               else
@@ -224,22 +249,26 @@ module Prawn
             end
 
           end
-          @document.y -= @vertical_padding
         end
       end
 
       def draw_page(contents)
         return if contents.empty?
 
-        if @border_style == :grid || contents.length == 1
+        if C(:border_style) == :grid || contents.length == 1
           contents.each { |e| e.border_style = :all }
-        else
-          contents.first.border_style = @headers ? :all : :no_bottom
+        else                            
+          if C(:headers)
+            contents.first.border_style = :all 
+            contents.first.align        = C(:align_headers) || :left
+          else
+            contents.first.border_style  = :no_bottom    
+          end
           contents.last.border_style  = :no_top
         end
 
         contents.each do |x| 
-          x.background_color = next_row_color if @row_colors
+          x.background_color = next_row_color if C(:row_colors)
           x.draw 
         end
 
@@ -247,11 +276,11 @@ module Prawn
       end
 
       def next_row_color
-        @row_colors.unshift(@row_colors.pop).last
+        C(:row_colors).unshift(C(:row_colors).pop).last
       end
 
-      def reset_row_colors
-        @row_colors = @original_row_colors.dup if @row_colors
+      def reset_row_colors    
+        C(:row_colors => C(:original_row_colors).dup) if C(:row_colors)
       end
 
     end

data/lib/prawn/document/text.rb

@@ -10,34 +10,34 @@ require "zlib"
 module Prawn
   class Document
     module Text
-      DEFAULT_FONT_SIZE = 12
-      
-      # The built in fonts specified by the Adobe PDF spec.
-      BUILT_INS = %w[ Courier Courier-Bold Courier-Oblique Courier-BoldOblique
-                      Helvetica Helvetica-Bold Helvetica-Oblique
-                      Helvetica-BoldOblique Times-Roman Times-Bold Times-Italic
-                      Times-BoldItalic Symbol ZapfDingbats ]
-
-      # Draws text on the page. If a point is specified via the <tt>:at</tt>
+      # Draws text on the page. If a point is specified via the +:at+
       # option the text will begin exactly at that point, and the string is
       # assumed to be pre-formatted to properly fit the page.
+      # 
+      #   pdf.text "Hello World", :at => [100,100]
+      #   pdf.text "Goodbye World", :at => [50,50], :size => 16
       #
-      # When <tt>:at</tt> is not specified, Prawn attempts to wrap the text to
-      # fit within your current bounding box (or margin box if no bounding box
+      # When +:at+ is not specified, 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 margin_box. Text wrap in Prawn does not re-flow
+      # 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.  
       #
-      #   pdf.text "Hello World", :at => [100,100]
-      #   pdf.text "Goodbye World", :at => [50,50], :size => 16
       #   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     
+      #
+      #  Wrapping is done by splitting words by spaces by default.  If your text
+      #  does not contain spaces, you can wrap based on characters instead:
+      #
+      #   pdf.text "This will be wrapped by character", :wrap => :character  
       #
       # If your font contains kerning pairs data that Prawn can parse, the 
       # text will be kerned by default.  You can disable this feature by passing
       # <tt>:kerning => false</tt>.
       #
-      # == Encoding
+      # === Character Encoding Details: 
       #
       # Note that strings passed to this function should be encoded as UTF-8.
       # If you get unexpected characters appearing in your rendered document, 
@@ -45,162 +45,82 @@ module Prawn
       #
       # If the current font is a built-in one, although the string must be
       # encoded as UTF-8, only characters that are available in ISO-8859-1
-      # are allowed.
+      # are allowed (transliteration will be attempted).
       #
       # 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.
       #
-      def text(text,options={})
-        # ensure a valid font is selected
-        font "Helvetica" unless fonts[@font]
-
+      def text(text,options={})            
         # we'll be messing with the strings encoding, don't change the users
         # original string
-        text = text.dup
-
-        # check the string is encoded sanely
-        # - UTF-8 for TTF fonts
-        # - ISO-8859-1 for Built-In fonts
-        if using_builtin_font?
-          normalize_builtin_encoding(text)
-        else
-          normalize_ttf_encoding(text)
-        end
-
-        if options.key?(:kerning)
-          options[:kerning] = false unless font_metrics.has_kerning_data?
-        else
-          options[:kerning] = true if font_metrics.has_kerning_data?
-        end
-
-        return wrapped_text(text,options) unless options[:at]
+        text = text.to_s.dup                      
         
-        x,y = translate(options[:at])
-        font_size(options[:size] || current_font_size) do
-          font_name = font_registry[fonts[@font]]          
-          
-          text = @font_metrics.convert_text(text,options)    
+        # we might also mess with the font
+        original_font  = font.name   
+              
+        options = text_options.merge(options)
+        process_text_options(options) 
+         
+        font.normalize_encoding(text) unless @skip_encoding        
+
+        if options[:at]                
+          x,y = translate(options[:at])            
+          font.size(options[:size]) { add_text_content(text,x,y,options) }
+        else
+          wrapped_text(text,options)
+        end         
 
-          add_content %Q{
-            BT
-            /#{font_name} #{current_font_size} Tf
-            #{x} #{y} Td
-          }
-          
-          add_content Prawn::PdfObject(text, true) << 
-            " #{options[:kerning] ? 'TJ' : 'Tj'}\n"
-          
-          add_content %Q{
-            ET
-          }
-        end
-      end
+        font(original_font) 
+      end 
+                          
+      # A hash of configuration options, to be used globally by text().
+      # 
+      #   pdf.text_options.update(:size => 16, :align => :right)   
+      #   pdf.text "Hello World" #=> Size 16 w. right alignment
+      #
+      def text_options
+        @text_options ||= {}
+      end 
                        
-      # Access to low-level font metrics data. This is only necessary for those
-      # who require direct access to font attributes, and can be safely ignored
-      # otherwise.
-      #                 
-      def font_metrics 
-        @font_metrics ||= Prawn::Font::Metrics["Helvetica"]
-      end
-
-      # Sets the current font.
-      #
-      # The single parameter must be a string. It can be one of the 14 built-in
-      # fonts supported by PDF, or the location of a TTF file. The BUILT_INS
-      # array specifies the valid built in font values.
-      #
-      #   pdf.font "Times-Roman"
-      #   pdf.font "Chalkboard.ttf"
-      #
-      # If a ttf font is specified, the full file will be embedded in the 
-      # rendered PDF. This should be your preferred option in most cases. 
-      # It will increase the size of the resulting file, but also make it 
-      # more portable.
-      #
-      def font(name)
-        proc_set :PDF, :Text
-        @font_metrics = Prawn::Font::Metrics[name]
-        case(name)
-        when /\.ttf$/
-          @font = embed_ttf_font(name)
-        else
-          @font = register_builtin_font(name)
-        end
-        set_current_font
-      end
-      
-      # Sets the default font size for use within a block.  Individual overrides
-      # can be used as desired.  The previous font size will be restored after the
-      # block.
-      #
-      #  Prawn::Document.generate("font_size.pdf") do
-      #   font_size!(16) 
-      #   text "At size 16"
-      #
-      #   font_size(10) do
-      #     text "At size 10"
-      #     text "At size 6", :size => 6
-      #     text "At size 10"
-      #   end
-      #
-      #   text "At size 16"
-      #  end   
-      #
-      # When called without an argument, this method returns the current font
-      # size.
-      #
-      def font_size(size=nil)
-        return current_font_size unless size
-        font_size_before_block = @font_size || DEFAULT_FONT_SIZE
-        font_size!(size)
-        yield
-        font_size!(font_size_before_block)
-      end
-      
-      # Sets the default font size. See example in font_size
-      #
-      def font_size!(size)
-        @font_size = size unless size == nil
-      end     
+      private 
       
-      alias_method :font_size=, :font_size!
+      def process_text_options(options)
+        Prawn.verify_options [:style, :kerning, :size, :at, :wrap, 
+                              :spacing, :align ], options                               
+        
+        if options[:style]  
+          raise "Bad font family" unless font.family
+          font(font.family,:style => options[:style])
+        end
 
-      private 
+        unless options.key?(:kerning)
+          options[:kerning] = font.metrics.has_kerning_data?
+        end                     
 
+        options[:size] ||= font.size
+     end
 
-      # The current font_size being used in the document.
-      #
-      def current_font_size
-        @font_size || DEFAULT_FONT_SIZE
+      def move_text_position(dy)   
+         bottom = @bounding_box.stretchy? ? @margin_box.absolute_bottom :
+                                            @bounding_box.absolute_bottom
+         start_new_page if (y - dy) < bottom
+         
+         self.y -= dy       
       end
 
-      def move_text_position(dy)
-         (y - dy) < @margin_box.absolute_bottom ? start_new_page : self.y -= dy       
-      end
-
-      def text_width(text,size)
-        @font_metrics.string_width(text,size)
-      end
-
-      # TODO: Get kerning working with wrapped text
       def wrapped_text(text,options) 
-        options[:align] ||= :left
-        font_size(options[:size] || current_font_size) do
-          font_name = font_registry[fonts[@font]]
+        options[:align] ||= :left      
 
-          text = @font_metrics.naive_wrap(text, bounds.right, current_font_size, 
-            :kerning => options[:kerning]) 
+        font.size(options[:size]) do
+          text = font.metrics.naive_wrap(text, bounds.right, font.size, 
+            :kerning => options[:kerning], :mode => options[:wrap]) 
 
           lines = text.lines
-
-          lines.each do |e|    
-            
-            move_text_position(@font_metrics.font_height(current_font_size) +
-                           @font_metrics.descender / 1000.0 * current_font_size)  
-                               
+                                                       
+          lines.each do |e|                                                   
+            move_text_position( font.height + font.descender )                                 
                            
-            line_width = text_width(e,font_size)
+            line_width = font.width_of(e)
             case(options[:align]) 
             when :left
               x = @bounding_box.absolute_left
@@ -208,173 +128,31 @@ module Prawn
               x = @bounding_box.absolute_left + 
                 (@bounding_box.width - line_width) / 2.0
             when :right
-              x = @bounding_box.absolute_right - line_width
+              x = @bounding_box.absolute_right - line_width 
             end
                                
-            add_content %Q{
-              BT
-              /#{font_name} #{current_font_size} Tf
-              #{x} #{y} Td
-            }    
-             
-           add_content Prawn::PdfObject(@font_metrics.convert_text(e,options), true) << 
-             " #{options[:kerning] ? 'TJ' : 'Tj'}\n"   
-
-            add_content %Q{
-              ET
-            }                
-            
-            ds = -@font_metrics.descender / 1000.0 * current_font_size 
-            move_text_position(options[:spacing] || ds )
-          end
-        end
-      end
-
-      def embed_ttf_font(file) #:nodoc:
-
-        ttf_metrics = Prawn::Font::Metrics::TTF.new(file)
-
-        unless File.file?(file)
-          raise ArgumentError, "file #{file} does not exist"
-        end
-
-        basename = @font_metrics.basename
-
-        raise "Can't detect a postscript name for #{file}" if basename.nil?
-
-        enctables[basename] = @font_metrics.enc_table
-
-        if enctables[basename].nil?
-          raise "#{file} missing the required encoding table" 
-        end
-
-        font_content    = File.open(file,"rb") { |f| f.read }
-        compressed_font = Zlib::Deflate.deflate(font_content)
-
-        fontfile = ref(:Length  => compressed_font.size,
-                       :Length1 => font_content.size,
-                       :Filter => :FlateDecode )
-        fontfile << compressed_font
-
-        # TODO: Not sure what to do about CapHeight, as ttf2afm doesn't
-        #       pick it up. Missing proper StemV and flags
-        #
-        descriptor = ref(:Type        => :FontDescriptor,
-                         :FontName    => basename,
-                         :FontFile2   => fontfile,
-                         :FontBBox    => @font_metrics.bbox,
-                         :Flags       => 32, # FIXME: additional flags
-                         :StemV       => 0,
-                         :ItalicAngle => 0,
-                         :Ascent      => @font_metrics.ascender,
-                         :Descent     => @font_metrics.descender
-                         )
-
-        descendant = ref(:Type           => :Font,
-                         :Subtype        => :CIDFontType2, # CID, TTF
-                         :BaseFont       => basename,
-                         :CIDSystemInfo  => { :Registry   => "Adobe", 
-                                              :Ordering   => "Identity", 
-                                              :Supplement => 0 },
-                         :FontDescriptor => descriptor,
-                         :W              => @font_metrics.glyph_widths,
-                         :CIDToGIDMap    => :Identity
-                        )
-
-        to_unicode_content = @font_metrics.to_unicode_cmap.to_s
-        compressed_to_unicode = Zlib::Deflate.deflate(to_unicode_content)
-        to_unicode = ref(:Length  => compressed_to_unicode.size,
-                         :Length1 => to_unicode_content.size,
-                         :Filter => :FlateDecode )
-        to_unicode << compressed_to_unicode
-
-        # TODO: Needs ToUnicode (at least)
-        fonts[basename] ||= ref(:Type            => :Font,
-                                :Subtype         => :Type0,
-                                :BaseFont        => basename,
-                                :DescendantFonts => [descendant],
-                                :Encoding        => :"Identity-H",
-                                :ToUnicode       => to_unicode)
-        return basename
-      end
-
-      # built-in fonts only work with latin encoding, so translate the string
-      def normalize_builtin_encoding(text)
-        if text.respond_to?(:encode!)
-          text.encode!("ISO-8859-1")
-        else
-          require 'iconv'
-          text.replace Iconv.conv('ISO-8859-1', 'utf-8', text)
-        end
-      rescue
-        raise Prawn::Errors::IncompatibleStringEncoding, "When using a " +
-            "builtin font, only characters that exist in " +
-            "WinAnsi/ISO-8859-1 are allowed."
-      end
-
-      def normalize_ttf_encoding(text)
-        # TODO: if the current font is a built in one, we can't use the utf-8
-        # string provided by the user. We should convert it to WinAnsi or
-        # MacRoman or some such.
-        if text.respond_to?(:encode!)
-          # if we're running under a M17n aware VM, ensure the string provided is
-          # UTF-8 (by converting it if necessary)
-          begin
-            text.encode!("UTF-8")
-          rescue
-            raise Prawn::Errors::IncompatibleStringEncoding, "Encoding " +
-            "#{text.encoding} can not be transparently converted to UTF-8. " +
-            "Please ensure the encoding of the string you are attempting " +
-            "to use is set correctly"
-          end
-        else
-          # on a non M17N aware VM, use unpack as a hackish way to verify the
-          # string is valid utf-8. I thought it was better than loading iconv
-          # though.
-          begin
-            text.unpack("U*")
-          rescue
-            raise Prawn::Errors::IncompatibleStringEncoding, "The string you " +
-            "are attempting to render is not encoded in valid UTF-8."
-          end
-        end
-      end
-
-      def register_builtin_font(name) #:nodoc:
-        unless BUILT_INS.include?(name)
-          raise Prawn::Errors::UnknownFont, "#{name} is not a known font."
+            add_text_content(e,x,y,options)
+            move_text_position(options[:spacing] || -font.descender )     
+          end 
         end
-        fonts[name] ||= ref(:Type => :Font,
-                            :Subtype => :Type1,
-                            :BaseFont => name.to_sym,
-                            :Encoding => :WinAnsiEncoding)
-        return name
-      end
-
-      def set_current_font #:nodoc:
-        return if @font.nil?
-        font_registry[fonts[@font]] ||= :"F#{font_registry.size + 1}"
-
-        page_fonts.merge!(
-          font_registry[fonts[@font]] => fonts[@font]
-        )
-      end
-
-      def enctables #:nodoc
-        @enctables ||= {}
-      end 
+      end  
       
-      def font_registry #:nodoc:
-        @font_registry ||= {}
-      end
-
-      def fonts #:nodoc:
-        @fonts ||= {}
-      end
-
-      def using_builtin_font?
-        fonts[@font].data[:Subtype] == :Type1
-      end
+      def add_text_content(text, x, y, options)
+        text = font.metrics.convert_text(text,options)
+
+        add_content %Q{
+          BT
+          /#{font.identifier} #{font.size} Tf
+          #{x} #{y} Td
+        }  
+
+        add_content Prawn::PdfObject(text, true) <<
+          " #{options[:kerning] ? 'TJ' : 'Tj'}\n"
+
+        add_content %Q{
+          ET
+        }
+      end  
     end
   end
 end