prawn 0.1.2 → 0.2.0

data/lib/prawn/errors.rb

@@ -23,11 +23,22 @@ module Prawn
      #
      class UnknownFont < StandardError; end   
 
-     # This error is raised when prawn is being used on a M17N aware VM,
+     # 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   
+     class IncompatibleStringEncoding < StandardError; end     
+     
+     # This error is raised when Prawn encounters an unknown key in functions
+     # that accept an options hash.  This usually means there is a typo in your
+     # code or that the option you are trying to use has a different name than
+     # what you have specified. 
+     #
+     class UnknownOption < StandardError; end
+     
+     # This error is raised when table data is malformed
+     #
+     class InvalidTableData < StandardError; end 
      
   end
 end   

data/lib/prawn/font.rb

@@ -2,4 +2,315 @@
 
 require "prawn/font/wrapping"       
 require "prawn/font/metrics"
-require "prawn/font/cmap"
+require "prawn/font/cmap" 
+
+module Prawn 
+  
+  class Document 
+    # 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=nil, options={}) 
+      if name     
+        if font_families.key?(name)
+          ff = name                                                      
+          name = font_families[name][options[:style] || :normal]
+        end 
+        Prawn::Font.register(name,:for => self, :family => ff) unless font_registry[name]      
+        font_registry[name].add_to_current_page
+        @font_name = name   
+      elsif @font_name.nil?                                              
+        Prawn::Font.register("Helvetica", :for => self, :family => "Helvetica") 
+        @font_name = "Helvetica"             
+      end  
+      font_registry[@font_name] 
+    end      
+       
+    # Hash of Font objects keyed by names
+    #
+    def font_registry
+      @font_registry ||= {}
+    end     
+     
+    # Hash that maps font family names to their styled individual font names
+    #  
+    # To add support for another font family, append to this hash, e.g:
+    #
+    #   pdf.font_families.update(
+    #    "MyTrueTypeFamily" => { :bold        => "foo-bold.ttf", 
+    #                            :italic      => "foo-italic.ttf",
+    #                            :bold_italic => "foo-bold-italic.ttf",
+    #                            :normal      => "foo.ttf" })
+    #
+    # This will then allow you to use the fonts like so:
+    #
+    #   pdf.font("MyTrueTypeFamily", :style => :bold)   
+    #   pdf.text "Some bold text"
+    #   pdf.font("MyTrueTypeFamily")
+    #   pdf.text "Some normal text"
+    #
+    # This assumes that you have appropriate TTF fonts for each style you 
+    # wish to support.
+    #                                                  
+    def font_families 
+      @font_families ||= Hash.new { |h,k| h[k] = {} }.merge!(      
+        { "Courier"     => { :bold        => "Courier-Bold",
+                             :italic      => "Courier-Oblique",
+                             :bold_italic => "Courier-BoldOblique",
+                             :normal      => "Courier" },       
+           
+          "Times-Roman" => { :bold         => "Times-Bold",
+                             :italic       => "Times-Italic",
+                             :bold_italic  => "Times-BoldItalic",
+                             :normal       => "Times-Roman" },        
+           
+          "Helvetica"   => { :bold         => "Helvetica-Bold",
+                             :italic       => "Helvetica-Oblique",
+                             :bold_italic  => "Helvetica-BoldOblique",
+                             :normal       => "Helvetica" }        
+        }) 
+    end
+  end
+  
+  # Provides font information and helper functions.  
+  # 
+  class Font
+    
+    BUILT_INS = %w[ Courier Helvetica Times-Roman Symbol ZapfDingbats 
+                    Courier-Bold Courier-Oblique Courier-BoldOblique
+                    Times-Bold Times-Italic Times-BoldItalic
+                    Helvetica-Bold Helvetica-Oblique Helvetica-BoldOblique ] 
+                        
+    DEFAULT_SIZE = 12
+      
+    def self.register(name,options={})         
+       options[:for].font_registry[name] = Font.new(name,options)
+    end      
+      
+    attr_reader   :metrics, :identifier, :reference, :name, :family
+    attr_writer   :size         
+      
+    def initialize(name,options={}) 
+      @name       = name   
+      @family     = options[:family]      
+              
+      @metrics    = Prawn::Font::Metrics[name] 
+      @document   = options[:for]  
+      
+      @document.proc_set :PDF, :Text  
+      @size       = DEFAULT_SIZE
+      @identifier = :"F#{@document.font_registry.size + 1}"  
+      
+      case(name)
+      when /\.ttf$/
+        embed_ttf(name)
+      else
+        register_builtin(name)
+      end  
+      
+      add_to_current_page    
+    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 size(points=nil)      
+      return @size unless points
+      size_before_yield = @size
+      @size = points
+      yield
+      @size = size_before_yield
+    end    
+        
+    # Gets width of string in PDF points at current font size
+    #
+    def width_of(string)
+      @metrics.string_width(string,@size)
+    end     
+     
+    # Gets height of text in PDF points at current font size.
+    # Text +:line_width+ must be specified in PDF points. 
+    #
+    def height_of(text,options={}) 
+      @metrics.string_height( text, :font_size  => @size, 
+                                    :line_width => options[:line_width] ) 
+    end                     
+     
+    # Gets height of current font in PDF points at current font size
+    #
+    def height
+      @metrics.font_height(@size)       
+    end   
+    
+    def ascender # :nodoc:
+      @metrics.ascender / 1000.0 * @size
+    end  
+    
+    def descender # :nodoc:
+      @metrics.descender / 1000.0 * @size
+    end
+                           
+    def normalize_encoding(text) # :nodoc:
+      # check the string is encoded sanely
+      # - UTF-8 for TTF fonts
+      # - ISO-8859-1 for Built-In fonts
+      if @metrics.type0?
+        normalize_ttf_encoding(text) 
+      else
+        normalize_builtin_encoding(text) 
+      end 
+    end
+                 
+    def add_to_current_page #:nodoc:
+      @document.page_fonts.merge!(@identifier => @reference)
+    end              
+    
+    private
+    
+    # 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//TRANSLIT', '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(name) 
+      unless BUILT_INS.include?(name)
+        raise Prawn::Errors::UnknownFont, "#{name} is not a known font."
+      end      
+      
+      @reference = @document.ref( :Type     => :Font,
+                                  :Subtype  => :Type1,
+                                  :BaseFont => name.to_sym,
+                                  :Encoding => :WinAnsiEncoding)                                                   
+    end    
+    
+    def embed_ttf(file)
+      unless File.file?(file)
+        raise ArgumentError, "file #{file} does not exist"
+      end
+
+      basename = @metrics.basename
+
+      raise "Can't detect a postscript name for #{file}" if basename.nil?
+
+      @encodings = @metrics.enc_table
+
+      if @encodings.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 = @document.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 = @document.ref(:Type        => :FontDescriptor,
+                                 :FontName    => basename,
+                                 :FontFile2   => fontfile,
+                                 :FontBBox    => @metrics.bbox,
+                                 :Flags       => 32, # FIXME: additional flags
+                                 :StemV       => 0,
+                                 :ItalicAngle => 0,
+                                 :Ascent      => @metrics.ascender,
+                                 :Descent     => @metrics.descender )    
+
+      descendant = @document.ref(:Type           => :Font,
+                                 :Subtype        => :CIDFontType2, # CID, TTF
+                                 :BaseFont       => basename,
+                                 :CIDSystemInfo  => { :Registry   => "Adobe",
+                                                      :Ordering   => "Identity",
+                                                      :Supplement => 0 },
+                                 :FontDescriptor => descriptor,
+                                 :W              => @metrics.glyph_widths,
+                                 :CIDToGIDMap    => :Identity ) 
+
+      to_unicode_content = @metrics.to_unicode_cmap.to_s
+      compressed_to_unicode = Zlib::Deflate.deflate(to_unicode_content)   
+      
+      to_unicode = @document.ref(:Length  => compressed_to_unicode.size,
+                                 :Length1 => to_unicode_content.size,
+                                 :Filter  => :FlateDecode )
+      to_unicode << compressed_to_unicode
+
+      @reference = @document.ref(:Type            => :Font,
+                                 :Subtype         => :Type0,
+                                 :BaseFont        => basename,
+                                 :DescendantFonts => [descendant],
+                                 :Encoding        => :"Identity-H",
+                                 :ToUnicode       => to_unicode)
+
+    end                              
+
+  end
+   
+end

data/lib/prawn/font/cmap.rb

@@ -7,7 +7,7 @@
 # This is free software. Please see the LICENSE and COPYING files for details.
 
 module Prawn
-  module Font #:nodoc:
+  class Font #:nodoc:
     class CMap #:nodoc:
 
       def initialize

data/lib/prawn/font/metrics.rb

@@ -10,27 +10,26 @@
 # This is free software. Please see the LICENSE and COPYING files for details.
 
 module Prawn
-  module Font #:nodoc:
+  class 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
+        data[font] ||= (font.match(/\.ttf$/) ? TTF : Adobe).new(font)
       end 
 
       def self.data
         @data ||= {}
       end   
 
-      def string_height(string,options={})
+      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   
+      
+      def font_height(size)
+        (ascender - descender + line_gap) * size / 1000.0
       end
 
       class Adobe < Metrics #:nodoc:     
@@ -85,13 +84,9 @@ module Prawn
           fontbbox.split(/\s+/).map { |e| Integer(e) }
         end   
 
-        def font_height(font_size)
-          Float(bbox[3] - bbox[1]) * font_size / 1000.0
-        end        
-      
         # calculates the width of the supplied string.
         # String *must* be encoded as iso-8859-1
-        def string_width(string, font_size, options = {})   
+        def string_width(string, font_size, options = {}) 
           scale = font_size / 1000.0
           
           if options[:kerning]
@@ -116,8 +111,8 @@ module Prawn
         def kern(string) 
           kerned = string.unpack("C*").inject([]) do |a,r|
             if a.last.is_a? Array
-              if kern = latin_kern_pairs_table[[a.last.last, r]]
-                a << kern << [r]
+              if k = latin_kern_pairs_table[[a.last.last, r]]
+                a << k << [r]
               else
                 a.last << r
               end
@@ -134,7 +129,7 @@ module Prawn
           }                        
         end
         
-        def latin_kern_pairs_table
+        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
@@ -153,16 +148,16 @@ module Prawn
 
         def descender
           @attributes["descender"].to_i 
+        end  
+        
+        def line_gap    
+          Float(bbox[3] - bbox[1]) - (ascender - descender)
         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
+          @attributes.include?(name) ? @attributes[name] : super
         end  
       
         def metrics_path
@@ -170,10 +165,10 @@ module Prawn
             @metrics_path ||= m.split(':')
           else 
             @metrics_path ||= [
-              "/usr/lib/afm",
+              ".", "/usr/lib/afm",
               "/usr/local/lib/afm",
               "/usr/openwin/lib/fonts/afm/", 
-               Prawn::BASEDIR+'/data/fonts/','.'] 
+               Prawn::BASEDIR+'/data/fonts/'] 
           end
         end 
 
@@ -188,7 +183,8 @@ module Prawn
         # perform any changes to the string that need to happen
         # before it is rendered to the canvas
         #
-        # String *must* be encoded as iso-8859-1
+        # String *must* be encoded as iso-8859-1         
+        #
         def convert_text(text, options={})
           options[:kerning] ? kern(text) : text
         end
@@ -243,13 +239,17 @@ module Prawn
         end               
       end
 
-      class TTF < Metrics #:nodoc:
+      class TTF < Metrics #:nodoc:  
+        
+        attr_accessor :ttf
         
         def initialize(font)
           @ttf = ::Font::TTF::File.open(font,"rb")
-          @attributes     = {}
-          @glyph_widths   = {}
-          @bounding_boxes = {}
+          @attributes       = {}
+          @glyph_widths     = {}
+          @bounding_boxes   = {} 
+          @char_widths      = {}   
+          @has_kerning_data = !kern_pairs_table.empty?    
         end
 
         def cmap
@@ -275,7 +275,9 @@ module Prawn
         
         # TODO: NASTY. 
         def kern(string,options={})   
-          string.unpack("U*").inject([]) do |a,r|
+          a = []
+          
+          string.unpack("U*").each do |r|
             if a.last.is_a? Array
               if kern = kern_pairs_table[[cmap[a.last.last], cmap[r]]] 
                 kern *= scale_factor
@@ -287,7 +289,9 @@ module Prawn
               a << [r]
             end
             a
-          end.map { |r| 
+          end
+          
+          a.map { |r| 
             if options[:skip_conversion]
               r.is_a?(Array) ? r.pack("U*") : r
             else
@@ -335,10 +339,10 @@ module Prawn
 
         def descender
           Integer(@ttf.get_table(:hhea).descender * scale_factor)
-        end
-
-        def font_height(size)
-          (ascender - descender) * size / 1000.0
+        end      
+        
+        def line_gap
+          Integer(@ttf.get_table(:hhea).line_gap * scale_factor)   
         end
 
         def basename
@@ -377,19 +381,18 @@ module Prawn
             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
+            @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               
+        rescue ::Font::TTF::TableMissing
+          @kern_pairs_table = {}
         end
 
         def has_kerning_data?
-          !kern_pairs_table.empty? 
-        rescue ::Font::TTF::TableMissing
-          false
+          @has_kerning_data 
         end
 
         def type0?
@@ -398,9 +401,9 @@ module Prawn
 
         def convert_text(text,options)
           text = text.chomp
-          if options[:kerning]
-            kern(text)
-          else
+          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)
@@ -413,15 +416,15 @@ module Prawn
 
         def hmtx
           @hmtx ||= @ttf.get_table(:hmtx).metrics
-        end
-
-        def character_width_by_code(code)
+        end         
+        
+        def character_width_by_code(code)    
           return 0 unless cmap[code]
-          Integer(hmtx[cmap[code]][0] * scale_factor)           
+          @char_widths[code] ||= Integer(hmtx[cmap[code]][0] * scale_factor)           
         end                   
 
         def scale_factor
-          @scale ||= 1 / Float(@ttf.get_table(:head).units_per_em / 1000.0)
+          @scale ||= 1000 * Float(@ttf.get_table(:head).units_per_em)**-1
         end
 
       end