prawn 0.3.0 → 0.4.0

data/lib/prawn/document/text/box.rb

@@ -55,8 +55,7 @@ module Prawn
         private
         
         def fit_text_to_box
-          text = @document.font.metrics.naive_wrap(@text,
-            @width, @document.font.size)
+          text = @document.naive_wrap(@text, @width, @document.font_size)
             
           max_lines = (@height / @document.font.height).floor
 

data/lib/prawn/document/text/wrapping.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+# wrapping.rb : Implementation of naive text wrap
+#
+# Copyright May 2008, Michael Daines. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+module Prawn
+  class Document
+    module Text
+      module Wrapping #:nodoc:                
+        ruby_18 { $KCODE="U" }
+        
+        # Gets height of text in PDF points at current font size.
+        # Text +:line_width+ must be specified in PDF points.
+        #
+        # If using an AFM, string *must* be encoded as WinAnsi
+        # (Use normalize_encoding to convert)
+        #
+        def height_of(string, line_width, size=font_size)
+          string = naive_wrap(string, line_width, size)
+          string.lines.to_a.length * font.height_at(size)
+        end
+
+        # TODO: Replace with TeX optimal algorithm
+        def naive_wrap(string, line_width, font_size, options = {})
+          scan_pattern = options[:mode] == :character ? /./ : /\S+|\s+/                                    
+          
+          output = ""                
+          string.lines.each do |line| 
+            accumulated_width = 0        
+            segments = line.scan(scan_pattern)
+                                          
+            segments.each do |segment|    
+              segment_width = font.width_of(segment, :size => font_size, :kerning => options[:kerning]) 
+        
+              if (accumulated_width + segment_width).round > line_width.round
+                output = "#{output.sub(/[ \t]*\n?(\n*)\z/, "\n\\1")}"
+                
+                if segment =~ /\s/           
+                  accumulated_width = 0
+                else
+                  output << segment
+                  accumulated_width = segment_width
+                end
+              else                           
+                output << segment
+                accumulated_width += segment_width
+              end
+            end    
+          end
+
+          output
+        end
+        
+      end  
+    end
+  end
+end

data/lib/prawn/errors.rb

@@ -36,13 +36,5 @@ module Prawn
      #
      class UnknownOption < StandardError; end
      
-     # This error is raised when table data is malformed
-     #
-     class InvalidTableData < StandardError; end 
-
-     # This error is raised when an empty or nil table is rendered
-     #
-     class EmptyTable < StandardError; end 
-     
   end
 end   

data/lib/prawn/font.rb

@@ -5,358 +5,273 @@
 # Copyright May 2008, Gregory Brown / James Healy. All Rights Reserved.
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
-require "prawn/font/wrapping"       
-require "prawn/font/metrics"
-require "prawn/font/cmap" 
+require "prawn/font/afm"
+require "prawn/font/ttf"
+require "prawn/font/dfont"
 
-module Prawn 
-  
-  class Document 
+module Prawn
+
+  class Document
     # Without arguments, this returns the currently selected font. Otherwise,
     # it 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
+    # fonts supported by PDF, or the location of a TTF file. The Font::AFM::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.
+    # If a ttf font is specified, the glyphs necessary to render your document
+    # 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={}) 
+    def font(name=nil, options={})
       return @font || font("Helvetica") if name.nil?
 
+      new_font = find_font(name, options)
+
       if block_given?
-        original_name = font.name
-        original_size = font.size
-      end
-      
-      @font = find_font(name, options)
-      @font.add_to_current_page
-     
-      @font.size = options[:size] if options[:size]
-      
-      if block_given?
-        yield
-        font(original_name, :size => original_size)
+        save_font do
+          set_font(new_font, options[:size])
+          yield
+        end
       else
-        @font
+        set_font(new_font, options[:size])
       end
+
+      @font
     end
 
-    # Looks up the given font name. Once a font has been found by that name,
-    # it will be cached to subsequent lookups for that font will return the
-    # same object.
+    # When called with no argument, returns the current font size.
+    # When called with a single argument but no block, sets the current font
+    # size.  When a block is used, the font size is applied transactionally and
+    # is rolled back when the block exits.  You may still change the font size
+    # within a transactional block for individual text segments, or nested calls
+    # to font_size.
+    #
+    #   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(points=nil)
+      return @font_size unless points
+      size_before_yield = @font_size
+      @font_size = points
+      block_given? ? yield : return
+      @font_size = size_before_yield
+    end
+
+    # Sets the font directly, given an actual Font object
+    # and size.
+    def set_font(font, size=nil) # :nodoc:
+      @font = font
+      @font_size = size if size
+    end
+
+    # Saves the current font, and then yields. When the block
+    # finishes, the original font is restored.
+    def save_font
+      @font ||= find_font("Helvetica")
+      original_font = @font
+      original_size = @font_size
+
+      yield
+    ensure
+      set_font(original_font, original_size) if original_font
+    end
+
+    # Looks up the given font using the given criteria. Once a font has been
+    # found by that matches the criteria, it will be cached to subsequent lookups
+    # for that font will return the same object.
+    #--
+    # Challenges involved: the name alone is not sufficient to uniquely identify
+    # a font (think dfont suitcases that can hold multiple different fonts in a
+    # single file). Thus, the :name key is included in the cache key.
+    #
+    # It is further complicated, however, since fonts in some formats (like the
+    # dfont suitcases) can be identified either by numeric index, OR by their
+    # name within the suitcase, and both should hash to the same font object
+    # (to avoid the font being embedded multiple times). This is not yet implemented,
+    # which means if someone selects a font both by name, and by index, the
+    # font will be embedded twice. Since we do font subsetting, this double
+    # embedding won't be catastrophic, just annoying.
+    # ++
     #
     def find_font(name, options={}) #:nodoc:
       if font_families.key?(name)
         family, name = name, font_families[name][options[:style] || :normal]
+
+        if name.is_a?(Hash)
+          options = options.merge(name)
+          name = options[:file]
+        end
       end
 
-      font_registry[name] ||= Font.new(name, options.merge(:for => self, :family => family))
-    end      
-       
+      key = "#{name}:#{options[:font] || 0}"
+      font_registry[key] ||= Font.load(self, name, options.merge(:family => family))
+    end
+
     # Hash of Font objects keyed by names
     #
     def font_registry #:nodoc:
       @font_registry ||= {}
-    end     
-     
+    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", 
+    #    "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.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 
+    # 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!(      
+    #
+    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" },       
-           
+                             :normal      => "Courier" },
+
           "Times-Roman" => { :bold         => "Times-Bold",
                              :italic       => "Times-Italic",
                              :bold_italic  => "Times-BoldItalic",
-                             :normal       => "Times-Roman" },        
-           
+                             :normal       => "Times-Roman" },
+
           "Helvetica"   => { :bold         => "Helvetica-Bold",
                              :italic       => "Helvetica-Oblique",
                              :bold_italic  => "Helvetica-BoldOblique",
-                             :normal       => "Helvetica" }        
-        }) 
+                             :normal       => "Helvetica" }
+        })
     end
   end
-  
-  # Provides font information and helper functions.  
-  # 
+
+  # 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
-      
-    # The font metrics object  
-    attr_reader   :metrics
-    
+
     # The current font name
     attr_reader :name
-    
+
     # The current font family
     attr_reader :family
-  
-    attr_reader  :identifier, :reference #:nodoc:
-    
-    # Sets the size of the current font:
-    #
-    #   font.size = 16
-    #
-    attr_writer   :size         
-      
-    def initialize(name,options={}) #:nodoc:
-      @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}"  
-
-      @reference = nil
-    end     
-    
-    def inspect
-      "Prawn::Font< #{name}: #{size} >"
+
+    # The options hash used to initialize the font
+    attr_reader :options
+
+    def self.load(document,name,options={})
+      case name
+      when /\.ttf$/   then TTF.new(document, name, options)
+      when /\.dfont$/ then DFont.new(document, name, options)
+      when /\.afm$/   then AFM.new(document, name, options)
+      else                 AFM.new(document, name, options)
+      end
     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
-    #
-    # If using an AFM, string *must* be encoded as WinAnsi 
-    # (Use normalize_encoding to convert)
-    # 
-    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. 
-    #
-    # If using an AFM, string *must* be encoded as WinAnsi 
-    # (Use normalize_encoding to convert)
-    #
-    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   
-    
-    # The height of the ascender at the current font size in PDF points
-    #
-    def ascender 
-      @metrics.ascender / 1000.0 * @size
-    end  
-    
-    # The height of the descender at the current font size in PDF points
-    #
-    def descender 
-      @metrics.descender / 1000.0 * @size
+
+    def initialize(document,name,options={}) #:nodoc:
+      @document   = document
+      @name       = name
+      @options    = options
+
+      @family     = options[:family]
+
+      @document.proc_set :PDF, :Text
+      @identifier = :"F#{@document.font_registry.size + 1}"
+
+      @references = {}
     end
-    
+
+    def ascender
+      @ascender / 1000.0 * size
+    end
+
+    def descender
+      @descender / 1000.0 * size
+    end
+
     def line_gap
-      @metrics.line_gap / 1000.0 * @size
+      @line_gap / 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 
+
+    def identifier_for(subset)
+      "#{@identifier}.#{subset}"
     end
-                 
-    def add_to_current_page #:nodoc:
-      embed! unless @reference
-      @document.page_fonts.merge!(@identifier => @reference)
-    end              
-    
-    private
 
-    def embed!
-      case(name)
-      when /\.ttf$/i
-        embed_ttf(name)
-      else
-        register_builtin(name)
-      end  
+    def inspect
+      "#{self.class.name}< #{name}: #{size} >"
     end
 
-    # built-in fonts only work with winansi encoding, so translate the string
-    def normalize_builtin_encoding(text)
-      enc = Prawn::Encoding::WinAnsi.new
-      text.replace text.unpack("U*").collect { |i| enc[i] }.pack("C*")
+    # Returns the width of the given string using the given font. If :size is not
+    # specified as one of the options, the string is measured using the current
+    # font size. You can also pass :kerning as an option to indicate whether
+    # kerning should be used when measuring the width (defaults to +false+).
+    #
+    # Note that the string _must_ be encoded properly for the font being used.
+    # For AFM fonts, this is WinAnsi. For TTF, make sure the font is encoded as
+    # UTF-8. You can use the #normalize_encoding method to make sure strings
+    # are in an encoding appropriate for the font.
+    def width_of(string, options={})
+      raise NotImplementedError, "subclasses of Prawn::Font must implement #width_of"
     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
+    # Normalizes the encoding of the string to an encoding supported by the font.
+    # The string is expected to be UTF-8 going in, and will be reencoded in-place
+    # (the argument will be modified directly). The return value is not defined.
+    def normalize_encoding(string)
+      raise NotImplementedError, "subclasses of Prawn::Font must implement #normalize_encoding"
     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
+    def height_at(size)
+      @normalized_height ||= (@ascender - @descender + @line_gap) / 1000.0
+      @normalized_height * size
+    end
 
-      raise "Can't detect a postscript name for #{file}" if basename.nil?
+    # Gets height of current font in PDF points at current font size
+    #
+    def height
+      height_at(size)
+    end
 
-      @encodings = @metrics.cmap
+    # Registers the given subset of the current font with the current PDF
+    # page. This is safe to call multiple times for a given font and subset,
+    # as it will only add the font the first time it is called.
+    #
+    def add_to_current_page(subset)
+      @references[subset] ||= register(subset)
+      @document.page_fonts.merge!(identifier_for(subset) => @references[subset])
+    end
 
-      if @encodings.nil?
-        raise "#{file} missing the required encoding table"
-      end
+    private
 
-      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                              
+    def size
+      @document.font_size
+    end
 
   end
-   
+
 end