prawn 0.2.3 → 0.3.0

data/lib/prawn/font/metrics.rb

@@ -9,6 +9,8 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
+require 'prawn/encoding'
+
 module Prawn
   class Font 
     class Metrics #:nodoc:
@@ -33,37 +35,6 @@ module Prawn
       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)            
@@ -85,7 +56,9 @@ module Prawn
         end   
 
         # calculates the width of the supplied string.
-        # String *must* be encoded as iso-8859-1
+        #
+        # String *must* be encoded as WinAnsi 
+        #
         def string_width(string, font_size, options = {}) 
           scale = font_size / 1000.0
           
@@ -107,7 +80,8 @@ module Prawn
         # converts a string into an array with spacing offsets
         # bewteen characters that need to be kerned
         #
-        # String *must* be encoded as iso-8859-1
+        # String *must* be encoded as WinAnsi
+        #
         def kern(string) 
           kerned = string.unpack("C*").inject([]) do |a,r|
             if a.last.is_a? Array
@@ -131,14 +105,14 @@ module Prawn
         
         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[p[0].map { |n| Encoding::WinAnsi::CHARACTERS.index(n) }] = p[1]
             h
           end
         end
  
         def latin_glyphs_table
           @glyphs_table ||= (0..255).map do |i|
-            @glyph_widths[ISOLatin1Encoding[i]].to_i
+            @glyph_widths[Encoding::WinAnsi::CHARACTERS[i]].to_i
           end 
         end
 
@@ -183,7 +157,7 @@ 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 WinAnsi       
         #
         def convert_text(text, options={})
           options[:kerning] ? kern(text) : text
@@ -199,44 +173,45 @@ module Prawn
              @metrics_path.join("\n")
         end  
       
-        def parse_afm(file) 
+        def parse_afm(file_name) 
           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
+
+          File.foreach(file_name) do |line|        
+            case line
+            when /^Start(\w+)/
+              section.push $1
+              next
+            when /^End(\w+)/
+              section.pop
+              next
             end
-          end
-        end               
+
+            case section
+            when ["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
+            when ["FontMetrics", "KernData", "KernPairs"]
+              next unless line =~ /^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/
+              @kern_pairs[[$1, $2]] = $3.to_i
+            when ["FontMetrics", "KernData", "TrackKern"], 
+              ["FontMetrics", "Composites"]
+              next
+            else
+              parse_generic_afm_attribute(line)
+            end
+          end 
+        end
+
+        def parse_generic_afm_attribute(line)
+          line =~ /(^\w+)\s+(.*)/
+          key, value = $1.to_s.downcase, $2      
+
+          @attributes[key] =  @attributes[key] ? 
+          Array(@attributes[key]) << value : value
+        end     
       end
 
       class TTF < Metrics #:nodoc:  
@@ -244,18 +219,18 @@ module Prawn
         attr_accessor :ttf
         
         def initialize(font)
-          @ttf = ::Font::TTF::File.open(font,"rb")
+          @ttf = TTFunk::File.new(font)
           @attributes       = {}
           @glyph_widths     = {}
           @bounding_boxes   = {} 
           @char_widths      = {}   
-          @has_kerning_data = !kern_pairs_table.empty?    
+          @has_kerning_data = !! @ttf.kern? && @ttf.kern.sub_tables[0]
         end
 
         def cmap
-          @cmap ||= enc_table.charmaps
+          @cmap ||= @ttf.cmap.formats[4]
         end
-
+        
         def string_width(string, font_size, options = {})
           scale = font_size / 1000.0
           if options[:kerning]
@@ -298,9 +273,7 @@ module Prawn
               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 = unicode_codepoints.map { |u| cmap[u] }
                 glyph_codes.pack("n*")
               else
                 i
@@ -313,7 +286,7 @@ module Prawn
         def glyph_widths
           glyphs = cmap.values.uniq.sort
           first_glyph = glyphs.shift
-          widths = [first_glyph, [Integer(hmtx[first_glyph][0] * scale_factor)]]
+          widths = [first_glyph, [Integer(hmtx[first_glyph][0] * scale_factor)]] 
           prev_glyph = first_glyph
           glyphs.each do |glyph|
             unless glyph == prev_glyph + 1
@@ -327,38 +300,25 @@ module Prawn
         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
+            Integer(@ttf.head.send(atr)) * scale_factor
           end
         end
 
         def ascender
-          Integer(@ttf.get_table(:hhea).ascender * scale_factor)
+          Integer(@ttf.hhea.ascent * scale_factor)
         end
 
         def descender
-          Integer(@ttf.get_table(:hhea).descender * scale_factor)
+          Integer(@ttf.hhea.descent * scale_factor)
         end      
         
         def line_gap
-          Integer(@ttf.get_table(:hhea).line_gap * scale_factor)   
+          Integer(@ttf.hhea.line_gap * scale_factor)   
         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
+          @basename ||= @ttf.name.postscript_name
         end
 
         # TODO: instead of creating a map that contains every glyph in the font,
@@ -375,20 +335,7 @@ module Prawn
         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               
-        rescue ::Font::TTF::TableMissing
-          @kern_pairs_table = {}
+          @kerning_data ||= has_kerning_data? ? @ttf.kern.sub_tables[0] : {}
         end
 
         def has_kerning_data?
@@ -404,18 +351,16 @@ module Prawn
           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)
-            }
+            unicode_codepoints = text.unpack("U*")
+            glyph_codes = unicode_codepoints.map { |u| cmap[u] }
             text = glyph_codes.pack("n*")
           end
         end
-
+        
         private
 
         def hmtx
-          @hmtx ||= @ttf.get_table(:hmtx).metrics
+          @hmtx ||= @ttf.hmtx.values
         end         
         
         def character_width_by_code(code)    
@@ -424,7 +369,7 @@ module Prawn
         end                   
 
         def scale_factor
-          @scale ||= 1000 * Float(@ttf.get_table(:head).units_per_em)**-1
+          @scale ||= 1000 * Float(@ttf.head.units_per_em)**-1
         end
 
       end

data/lib/prawn/graphics.rb

@@ -7,25 +7,25 @@
 # This is free software. Please see the LICENSE and COPYING files for details.
 
 require "enumerator"
-require "prawn/graphics/cell"   
+require "prawn/graphics/cell"
 require "prawn/graphics/color"
 
 module Prawn
 
-  # Implements the drawing facilities for Prawn::Document.  
+  # Implements the drawing facilities for Prawn::Document.
   # Use this to draw the most beautiful imaginable things.
-  # 
+  #
   # This file lifts and modifies several of PDF::Writer's graphics functions
   # ruby-pdf.rubyforge.org
   #
-  module Graphics  
-    
+  module Graphics
+
     include Color
-           
+
     #######################################################################
     # Low level drawing operations must translate to absolute coords!     #
     #######################################################################
-       
+
     # Moves the drawing position to a given point.  The point can be
     # specified as a tuple or a flattened argument list
     #
@@ -33,50 +33,50 @@ module Prawn
     #   pdf.move_to(100,50)
     #
     def move_to(*point)
-      x,y = translate(point)           
+      x,y = translate(point)
       add_content("%.3f %.3f m" % [ x, y ])
     end
-    
+
     # Draws a line from the current drawing position to the specified point.
-    # The destination may be described as a tuple or a flattened list:    
+    # The destination may be described as a tuple or a flattened list:
     #
-    #   pdf.line_to [50,50] 
-    #   pdf.line_to(50,50)    
+    #   pdf.line_to [50,50]
+    #   pdf.line_to(50,50)
     #
-    def line_to(*point)      
+    def line_to(*point)
       x,y = translate(point)
-      add_content("%.3f %.3f l" % [ x, y ]) 
-    end    
-    
-    # Draws a Bezier curve from the current drawing position to the 
+      add_content("%.3f %.3f l" % [ x, y ])
+    end
+
+    # Draws a Bezier curve from the current drawing position to the
     # specified point, bounded by two additional points.
-    #  
-    #   pdf.curve_to [100,100], :bounds => [[90,90],[75,75]]   
     #
-    def curve_to(dest,options={})                           
-       options[:bounds] or raise Prawn::Errors::InvalidGraphicsPath, 
+    #   pdf.curve_to [100,100], :bounds => [[90,90],[75,75]]
+    #
+    def curve_to(dest,options={})
+       options[:bounds] or raise Prawn::Errors::InvalidGraphicsPath,
          "Bounding points for bezier curve must be specified "+
-         "as :bounds => [[x1,y1],[x2,y2]]"       
+         "as :bounds => [[x1,y1],[x2,y2]]"
 
        curve_points = (options[:bounds] << dest).map { |e| translate(e) }
-       add_content("%.3f %.3f %.3f %.3f %.3f %.3f c" % 
-                     curve_points.flatten )    
-    end   
-    
-    # Draws a rectangle given <tt>point</tt>, <tt>width</tt> and 
+       add_content("%.3f %.3f %.3f %.3f %.3f %.3f c" %
+                     curve_points.flatten )
+    end
+
+    # Draws a rectangle given <tt>point</tt>, <tt>width</tt> and
     # <tt>height</tt>.  The rectangle is bounded by its upper-left corner.
     #
     #    pdf.rectangle [300,300], 100, 200
-    # 
+    #
     def rectangle(point,width,height)
       x,y = translate(point)
-      add_content("%.3f %.3f %.3f %.3f re" % [ x, y - height, width, height ])      
+      add_content("%.3f %.3f %.3f %.3f re" % [ x, y - height, width, height ])
     end
-       
+
     ###########################################################
-    #  Higher level functions: May use relative coords        #   
-    ########################################################### 
-      
+    #  Higher level functions: May use relative coords        #
+    ###########################################################
+
     # Sets line thickness to the <tt>width</tt> specified.
     #
     def line_width=(width)
@@ -93,24 +93,33 @@ module Prawn
         @line_width || 1
       end
     end
-       
-    # Draws a line from one point to another. Points may be specified as 
+
+    # Draws a line from one point to another. Points may be specified as
     # tuples or flattened argument list:
     #
-    #   pdf.line [100,100], [200,250] 
+    #   pdf.line [100,100], [200,250]
     #   pdf.line(100,100,200,250)
     #
     def line(*points)
       x0,y0,x1,y1 = points.flatten
       move_to(x0, y0)
       line_to(x1, y1)
-    end   
+    end
 
     # Draws a horizontal line from <tt>x1</tt> to <tt>x2</tt> at the
-    # current <tt>y</tt> position.
+    # current <tt>y</tt> position, or the position specified by the :at option.
     #
-    def horizontal_line(x1,x2)
-      line(x1,y-bounds.absolute_bottom,x2,y-bounds.absolute_bottom)
+    #  # draw a line from [25, 75] to [100, 75]
+    #  horizontal_line 25, 100, :at => 75  
+    #
+    def horizontal_line(x1,x2,options={})
+      if options[:at]
+        y1 = options[:at]
+      else
+        y1 = y - bounds.absolute_bottom
+      end
+      
+      line(x1,y1,x2,y1)
     end
 
     # Draws a horizontal line from the left border to the right border of the
@@ -120,115 +129,124 @@ module Prawn
       horizontal_line(bounds.left, bounds.right)
     end
 
-    # Draws a vertical line at the given x position from y1 to y2.
-    # 
-    def vertical_line_at(x,y1,y2)
-      line(x,y1,x,y2)
+    # Draws a vertical line at the x cooordinate given by :at from y1 to y2.
+    #
+    #   # draw a line from [25, 100] to [25, 300]
+    #   vertical_line 100, 300, :at => 25
+    #
+    def vertical_line(y1,y2,params)
+      line(params[:at],y1,params[:at],y2)
     end
-               
+
     # Draws a Bezier curve between two points, bounded by two additional
     # points
     #
-    #    pdf.curve [50,100], [100,100], :bounds => [[90,90],[75,75]]  
+    #    pdf.curve [50,100], [100,100], :bounds => [[90,90],[75,75]]
     #
     def curve(origin,dest, options={})
-      move_to *origin    
+      move_to(*origin)
       curve_to(dest,options)
     end
 
     # This constant is used to approximate a symmetrical arc using a cubic
-    # Bezier curve.   
+    # Bezier curve.
     #
     KAPPA = 4.0 * ((Math.sqrt(2) - 1.0) / 3.0)
-                                                                  
+
     # Draws a circle of radius <tt>:radius</tt> with the centre-point at <tt>point</tt>
     # as a complete subpath. The drawing point will be moved to the
-    # centre-point upon completion of the drawing the circle.     
-    #                                           
-    #    pdf.circle_at [100,100], :radius => 25  
+    # centre-point upon completion of the drawing the circle.
+    #
+    #    pdf.circle_at [100,100], :radius => 25
     #
-    def circle_at(point, options)  
+    def circle_at(point, options)
       x,y = point
-      ellipse_at [x, y], options[:radius]     
-    end 
-      
+      ellipse_at [x, y], options[:radius]
+    end
+
     # Draws an ellipse of +x+ radius <tt>r1</tt> and +y+ radius <tt>r2</tt>
     # with the centre-point at <tt>point</tt> as a complete subpath. The
     # drawing point will be moved to the centre-point upon completion of the
-    # drawing the ellipse.   
-    #                                    
+    # drawing the ellipse.
+    #
     #    # draws an ellipse with x-radius 25 and y-radius 50
-    #    pdf.ellipse_at [100,100], 25, 50   
+    #    pdf.ellipse_at [100,100], 25, 50
     #
-    def ellipse_at(point, r1, r2 = r1)  
+    def ellipse_at(point, r1, r2 = r1)
       x, y = point
       l1 = r1 * KAPPA
-      l2 = r2 * KAPPA            
-      
+      l2 = r2 * KAPPA
+
       move_to(x + r1, y)
-      
+
       # Upper right hand corner
-      curve_to [x,  y + r2], 
+      curve_to [x,  y + r2],
         :bounds => [[x + r1, y + l1], [x + l2, y + r2]]
 
-      # Upper left hand corner                          
-      curve_to [x - r1, y],  
-        :bounds => [[x - l2, y + r2], [x - r1, y + l1]] 
- 
+      # Upper left hand corner
+      curve_to [x - r1, y],
+        :bounds => [[x - l2, y + r2], [x - r1, y + l1]]
+
       # Lower left hand corner
-      curve_to [x, y - r2],  
-        :bounds => [[x - r1, y - l1], [x - l2, y - r2]]  
+      curve_to [x, y - r2],
+        :bounds => [[x - r1, y - l1], [x - l2, y - r2]]
 
       # Lower right hand corner
       curve_to [x + r1, y],
-        :bounds => [[x + l2, y - r2], [x + r1, y - l1]]    
-   
+        :bounds => [[x + l2, y - r2], [x + r1, y - l1]]
+
       move_to(x, y)
     end
-     
+
     # Draws a polygon from the specified points.
-    #                                              
+    #
     #    # draws a snazzy triangle
-    #    pdf.polygon [100,100], [100,200], [200,200]  
+    #    pdf.polygon [100,100], [100,200], [200,200]
     #
-    def polygon(*points) 
+    def polygon(*points)
       move_to points[0]
       (points << points[0]).each_cons(2) do |p1,p2|
         line_to(*p2)
       end
     end
-    
+
     # Strokes and closes the current path. See Graphic::Color for color details
     #
     def stroke
       yield if block_given?
       add_content "S"
     end
+    
+    # Draws and strokes a rectangle represented by the current bounding box
+    #
+    def stroke_bounds
+      stroke_rectangle bounds.top_left, bounds.width, bounds.height
+    end
 
     # Fills and closes the current path. See Graphic::Color for color details
     #
-    def fill               
+    def fill
       yield if block_given?
       add_content "f"
     end
 
     # Fills, strokes, and closes the current path. See Graphic::Color for color details
     #
-    def fill_and_stroke  
+    def fill_and_stroke
       yield if block_given?
-      add_content "b" 
-    end                                                       
-    
-    private       
-    
+      add_content "b"
+    end
+
+    private
+
     def translate(*point)
       x,y = point.flatten
       [@bounding_box.absolute_left + x, @bounding_box.absolute_bottom + y]
-    end    
-    
+    end
+
     def translate!(point)
       point.replace(translate(point))
-    end                                                                        
+    end
 
   end
 end