prawn 0.1.0

data/lib/prawn/document/text.rb

@@ -0,0 +1,346 @@
+# 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 "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>
+      # option the text will begin exactly at that point, and the string is
+      # assumed to be pre-formatted to properly fit the page.
+      #
+      # 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
+      # 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
+      # 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"
+      #
+      # 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>.
+      #
+      # 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 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={})
+        # check the string is encoded sanely
+        normalize_encoding(text)
+
+        if options.key?(:kerning)
+          options[:kerning] = false unless font_metrics.has_kerning_data?
+        else
+          options[:kerning] = true if font_metrics.has_kerning_data?
+        end
+
+        # ensure a valid font is selected
+        font "Helvetica" unless fonts[@font]
+
+        return wrapped_text(text,options) unless options[:at]
+        
+        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)    
+
+          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
+                       
+      # 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     
+      
+      alias_method :font_size=, :font_size!
+
+      private 
+      
+      # The current font_size being used in the document.
+      #
+      def current_font_size
+        @font_size || DEFAULT_FONT_SIZE
+      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]]
+
+          text = @font_metrics.naive_wrap(text, bounds.right, current_font_size, 
+            :kerning => options[:kerning]) 
+
+          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)  
+                               
+                           
+            line_width = text_width(e,font_size)
+            case(options[:align]) 
+            when :left
+              x = @bounding_box.absolute_left
+            when :center
+              x = @bounding_box.absolute_left + 
+                (@bounding_box.width - line_width) / 2.0
+            when :right
+              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
+
+      def normalize_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."
+        end
+        fonts[name] ||= ref(:Type => :Font,
+                            :Subtype => :Type1,
+                            :BaseFont => name.to_sym,
+                            :Encoding => :MacRomanEncoding)
+        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 
+      
+      def font_registry #:nodoc:
+        @font_registry ||= {}
+      end
+
+      def fonts #:nodoc:
+        @fonts ||= {}
+      end
+
+    end
+  end
+end

data/lib/prawn/errors.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+# errors.rb : Implements custom error classes for Prawn
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  module Errors
+     
+     # This error is raised when Prawn::PdfObject() encounters a Ruby object it
+     # cannot convert to PDF
+     #
+     class FailedObjectConversion < StandardError; end
+     
+     # This error is raised when Document#page_layout is set to anything
+     # other than :portrait or :landscape            
+     #
+     class InvalidPageLayout < StandardError; end        
+     
+     # This error is raised when Prawn cannot find a specified font   
+     #
+     class UnknownFont < StandardError; end   
+
+     # This error is raised when prawn is being used on a M17N aware VM,
+     # and the user attempts to add text that isn't compatible with UTF-8
+     # to their document
+     #
+     class IncompatibleStringEncoding < StandardError; end   
+     
+  end
+end   

data/lib/prawn/font.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+require "prawn/font/wrapping"       
+require "prawn/font/metrics"
+require "prawn/font/cmap"

data/lib/prawn/font/cmap.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+# cmap.rb : class for building ToUnicode CMaps for Type0 fonts
+#
+# Copyright May 2008, Gregory Brown / James Healy. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  module Font #:nodoc:
+    class CMap #:nodoc:
+
+      def initialize
+        @codes = {}
+      end
+
+      def [](c)
+        @codes[c]
+      end
+
+      def []=(c, v)
+        @codes[c] = v
+      end
+
+      def to_s
+        # TODO: learn what all this means. I just copied the basic structure
+        #       from an existing PDF
+        # TODO: make this more efficient. The mapping can be specified in
+        #       ranges instead of one -> one
+        res =  "12 dict begin\n"
+        res << "begincmap\n"
+        res << "/CIDSystemInfo\n"
+        res << "<< /Registry (Adobe)\n"
+        res << "/Ordering (UCS)\n"
+        res << "/Supplement 0\n"
+        res << ">> def\n"
+        res << "/CMapName /Adobe-Identity-UCS def\n"
+        res << "/CMapType 2 def\n"
+        res << "begincodespacerange\n"
+        res << "<0000> <ffff>\n"
+        res << "endcodespacerange\n"
+        res << "9 beginbfchar\n"
+        @codes.keys.sort.each do |key|
+          val = @codes[key]
+          ccode = val.to_s(16)
+          ccode = ("0" * (4 - ccode.size)) + ccode
+          unicode = key.to_s(16)
+          unicode = ("0" * (4 - unicode.size)) + unicode
+          res << "<#{ccode}> <#{unicode}>\n"
+        end
+        res << "endbfchar\n"
+        res << "endcmap\n"
+        res << "CMapName currentdict /CMap defineresource pop\n"
+        res << "end\n"
+        res << "end\n"
+      end
+    end
+  end
+end

data/lib/prawn/font/metrics.rb

@@ -0,0 +1,414 @@
+# encoding: utf-8
+
+# metrics.rb : Font metrics parsers for AFM and TTF.
+#
+# Font::Metrics::Adobe is mainly a port of CPAN's Font::AFM 
+# http://search.cpan.org/~gaas/Font-AFM-1.19/AFM.pm
+#
+# Copyright May 2008, Gregory Brown / James Edward Gray II. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  module Font #:nodoc:
+    class Metrics #:nodoc:
+
+      include Prawn::Font::Wrapping
+
+      def self.[](font)
+        data[font] ||= case(font)
+          when /\.ttf$/
+            TTF.new(font)
+          else
+            Adobe.new(font)
+        end
+      end 
+
+      def self.data
+        @data ||= {}
+      end   
+
+      def string_height(string,options={})
+        string = naive_wrap(string, options[:line_width], options[:font_size])
+        string.lines.to_a.length * font_height(options[:font_size])
+      end
+
+      class Adobe < Metrics #:nodoc:     
+         
+        ISOLatin1Encoding = %w[
+         .notdef .notdef .notdef .notdef .notdef .notdef .notdef .notdef
+         .notdef .notdef .notdef .notdef .notdef .notdef .notdef .notdef
+         .notdef .notdef .notdef .notdef .notdef .notdef .notdef .notdef
+         .notdef .notdef .notdef .notdef .notdef .notdef .notdef .notdef space
+         exclam quotedbl numbersign dollar percent ampersand quoteright
+         parenleft parenright asterisk plus comma minus period slash zero one
+         two three four five six seven eight nine colon semicolon less equal
+         greater question at A B C D E F G H I J K L M N O P Q R S
+         T U V W X Y Z bracketleft backslash bracketright asciicircum
+         underscore quoteleft a b c d e f g h i j k l m n o p q r s
+         t u v w x y z braceleft bar braceright asciitilde .notdef .notdef
+         .notdef .notdef .notdef .notdef .notdef .notdef .notdef .notdef
+         .notdef .notdef .notdef .notdef .notdef .notdef .notdef dotlessi grave
+         acute circumflex tilde macron breve dotaccent dieresis .notdef ring
+         cedilla .notdef hungarumlaut ogonek caron space exclamdown cent
+         sterling currency yen brokenbar section dieresis copyright ordfeminine
+         guillemotleft logicalnot hyphen registered macron degree plusminus
+         twosuperior threesuperior acute mu paragraph periodcentered cedilla
+         onesuperior ordmasculine guillemotright onequarter onehalf threequarters
+         questiondown Agrave Aacute Acircumflex Atilde Adieresis Aring AE
+         Ccedilla Egrave Eacute Ecircumflex Edieresis Igrave Iacute Icircumflex
+         Idieresis Eth Ntilde Ograve Oacute Ocircumflex Otilde Odieresis
+         multiply Oslash Ugrave Uacute Ucircumflex Udieresis Yacute Thorn
+         germandbls agrave aacute acircumflex atilde adieresis aring ae
+         ccedilla egrave eacute ecircumflex edieresis igrave iacute icircumflex
+         idieresis eth ntilde ograve oacute ocircumflex otilde odieresis divide
+         oslash ugrave uacute ucircumflex udieresis yacute thorn ydieresis
+        ]    
+      
+        attr_reader :attributes
+                                  
+        def initialize(font_name)            
+          @attributes     = {}   
+          @glyph_widths   = {}
+          @bounding_boxes = {}
+          @kern_pairs     = {}
+          
+          file = font_name.sub(/\.afm$/,'') + '.afm'
+          unless file[0..0] == "/"
+             file = find_font(file)
+          end    
+                           
+          parse_afm(file)
+        end
+        
+        def bbox
+          fontbbox.split(/\s+/).map { |e| Integer(e) }
+        end   
+
+        def font_height(font_size)
+          Float(bbox[3] - bbox[1]) * font_size / 1000.0
+        end        
+      
+        def string_width(string, font_size, options = {})   
+          scale = font_size / 1000.0
+          
+          if options[:kerning]
+            kern(string).inject(0) do |s,r|   
+              if r.is_a? String
+                s + string_width(r, font_size, :kerning => false)
+              else 
+                s - (r * scale)
+              end
+            end
+          else
+            string.unpack("U*").inject(0) do |s,r|
+              s + latin_glyphs_table[r]
+            end * scale
+          end
+        end
+        
+        def kern(string) 
+          kerned = string.unpack("U*").inject([]) do |a,r|
+            if a.last.is_a? Array
+              if kern = latin_kern_pairs_table[[a.last.last, r]]
+                a << kern << [r]
+              else
+                a.last << r
+              end
+            else
+              a << [r]
+            end
+            a
+          end            
+          
+          kerned.map { |r| 
+            i = r.is_a?(Array) ? r.pack("U*") : r 
+            i.is_a?(Numeric) ? -i : i
+          }                        
+        end
+        
+        def latin_kern_pairs_table
+          @kern_pairs_table ||= @kern_pairs.inject({}) do |h,p|
+            h[p[0].map { |n| ISOLatin1Encoding.index(n) }] = p[1]
+            h
+          end
+        end
+ 
+        def latin_glyphs_table
+          @glyphs_table ||= (0..255).map do |i|
+            @glyph_widths[ISOLatin1Encoding[i]].to_i
+          end 
+        end
+
+        def ascender
+          @attributes["ascender"].to_i
+        end
+
+        def descender
+          @attributes["descender"].to_i 
+        end
+
+        # Hackish, but does the trick for now.
+        def method_missing(method, *args, &block)
+          name = method.to_s.delete("_")
+          if @attributes.include? name
+            @attributes[name]
+          else
+            super  
+          end
+        end  
+      
+        def metrics_path
+          @metrics_path ||= (ENV['METRICS'] || 
+            "/usr/lib/afm:/usr/local/lib/afm:"+
+            "/usr/openwin/lib/fonts/afm/:"+
+            "#{Prawn::BASEDIR+'/data/fonts/'}:.").split(':')
+        end 
+
+        def has_kerning_data?
+          true
+        end
+
+        def type0?
+          false
+        end
+
+        def convert_text(text, options={})
+          options[:kerning] ? kern(text) : text
+        end
+
+        private
+      
+        def find_font(file)
+          metrics_path.find { |f| File.exist? "#{f}/#{file}" } + "/#{file}"    
+        rescue NoMethodError
+          raise Prawn::Errors::UnknownFont, 
+            "Couldn't find the font: #{file} in any of:\n" + 
+             @metrics_path.join("\n")
+        end  
+      
+        def parse_afm(file) 
+          section = []
+          
+          File.open(file,"rb") do |file|
+            
+            file.each do |line| 
+              if line =~ /^Start(\w+)/
+                section.push $1
+                next
+              elsif line =~ /^End(\w+)/
+                section.pop
+                next
+              end
+              
+              if section == ["FontMetrics", "CharMetrics"]
+                next unless line =~ /^CH?\s/  
+          
+                name                  = line[/\bN\s+(\.?\w+)\s*;/, 1]
+                @glyph_widths[name]   = line[/\bWX\s+(\d+)\s*;/, 1].to_i
+                @bounding_boxes[name] = line[/\bB\s+([^;]+);/, 1].to_s.rstrip
+              elsif section == ["FontMetrics", "KernData", "KernPairs"]
+                next unless line =~ /^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/
+                @kern_pairs[[$1, $2]] = $3.to_i
+              elsif section == ["FontMetrics", "KernData", "TrackKern"]
+                next
+              elsif section == ["FontMetrics", "Composites"]
+                next
+              elsif line =~ /(^\w+)\s+(.*)/
+                key, value = $1.to_s.downcase, $2      
+              
+                @attributes[key] =  @attributes[key] ? 
+                  Array(@attributes[key]) << value : value
+              else
+                warn "Can't parse:  #{line}"
+              end
+            end
+          end
+        end               
+      end
+
+      class TTF < Metrics #:nodoc:
+        
+        def initialize(font)
+          @ttf = ::Font::TTF::File.open(font,"rb")
+          @attributes     = {}
+          @glyph_widths   = {}
+          @bounding_boxes = {}
+        end
+
+        def cmap
+          @cmap ||= enc_table.charmaps
+        end
+
+        def string_width(string, font_size, options = {})
+          scale = font_size / 1000.0
+          if options[:kerning]
+            kern(string,:skip_conversion => true).inject(0) do |s,r|
+              if r.is_a? String  
+                s + string_width(r, font_size, :kerning => false)
+              else 
+                s + r * scale
+              end
+            end
+          else
+            string.unpack("U*").inject(0) do |s,r|
+              s + character_width_by_code(r)
+            end * scale
+          end
+        end   
+        
+        # TODO: NASTY. 
+        def kern(string,options={})   
+          string.unpack("U*").inject([]) do |a,r|
+            if a.last.is_a? Array
+              if kern = kern_pairs_table[[cmap[a.last.last], cmap[r]]] 
+                kern *= scale_factor
+                a << kern << [r]
+              else
+                a.last << r
+              end
+            else
+              a << [r]
+            end
+            a
+          end.map { |r| 
+            if options[:skip_conversion]
+              r.is_a?(Array) ? r.pack("U*") : r
+            else
+              i = r.is_a?(Array) ? r.pack("U*") : r 
+              x = if i.is_a?(String)
+                unicode_codepoints = i.unpack("U*")
+                glyph_codes = unicode_codepoints.map { |u| 
+                  enc_table.get_glyph_id_for_unicode(u)
+                }
+                glyph_codes.pack("n*")
+              else
+                i
+              end
+              x.is_a?(Numeric) ? -x : x 
+            end
+          }
+        end
+
+        def glyph_widths
+          glyphs = cmap.values.uniq.sort
+          first_glyph = glyphs.shift
+          widths = [first_glyph, [Integer(hmtx[first_glyph][0] * scale_factor)]]
+          prev_glyph = first_glyph
+          glyphs.each do |glyph|
+            unless glyph == prev_glyph + 1
+              widths << glyph
+              widths << []
+            end
+            widths.last << Integer(hmtx[glyph][0] * scale_factor )
+            prev_glyph = glyph
+          end
+          widths
+        end
+
+        def bbox
+          head = @ttf.get_table(:head)
+          [:x_min, :y_min, :x_max, :y_max].map do |atr| 
+            Integer(head.send(atr)) * scale_factor
+          end
+        end
+
+        def ascender
+          Integer(@ttf.get_table(:hhea).ascender * scale_factor)
+        end
+
+        def descender
+          Integer(@ttf.get_table(:hhea).descender * scale_factor)
+        end
+
+        def font_height(size)
+          (ascender - descender) * size / 1000.0
+        end
+
+        def basename
+          return @basename if @basename
+          ps_name = ::Font::TTF::Table::Name::NameRecord::POSTSCRIPT_NAME
+
+          @ttf.get_table(:name).name_records.each do |rec|
+            @basename = rec.utf8_str.to_sym if rec.name_id == ps_name            
+          end
+          @basename
+        end
+
+        def enc_table
+          @enc_table ||= @ttf.get_table(:cmap).encoding_tables.find do |t|
+            t.class == ::Font::TTF::Table::Cmap::EncodingTable4
+          end
+        end
+
+        # TODO: instead of creating a map that contains every glyph in the font,
+        #       only include the glyphs that were used
+        def to_unicode_cmap
+          return @to_unicode if @to_unicode
+          @to_unicode = Prawn::Font::CMap.new
+          unicode_for_glyph = cmap.invert
+          glyphs = unicode_for_glyph.keys.uniq.sort
+          glyphs.each do |glyph|
+            @to_unicode[unicode_for_glyph[glyph]] = glyph
+          end
+          @to_unicode
+        end
+        
+        def kern_pairs_table
+          return @kern_pairs_table if @kern_pairs_table
+          
+          table = @ttf.get_table(:kern).subtables.find { |s| 
+            s.is_a? ::Font::TTF::Table::Kern::KerningSubtable0 }
+          
+          if table
+            @kern_pairs_table ||= table.kerning_pairs.inject({}) do |h,p|
+              h[[p.left, p.right]] = p.value
+              h
+            end
+          else
+            @kern_pairs_table = {}
+          end
+        end
+
+        def has_kerning_data?
+          !kern_pairs_table.empty? 
+        rescue ::Font::TTF::TableMissing
+          false
+        end
+
+        def type0?
+          true
+        end
+
+        def convert_text(text,options)
+          text = text.chomp
+          if options[:kerning]
+            kern(text)
+          else
+           unicode_codepoints = text.unpack("U*")
+            glyph_codes = unicode_codepoints.map { |u| 
+              enc_table.get_glyph_id_for_unicode(u)
+            }
+            text = glyph_codes.pack("n*")
+          end
+        end
+
+        private
+
+        def hmtx
+          @hmtx ||= @ttf.get_table(:hmtx).metrics
+        end
+
+        def character_width_by_code(code)
+          return 0 unless cmap[code]
+          Integer(hmtx[cmap[code]][0] * scale_factor)           
+        end                   
+
+        def scale_factor
+          @scale ||= 1 / Float(@ttf.get_table(:head).units_per_em / 1000.0)
+        end
+
+      end
+    end
+  end   
+end