kavu-prawn-core 0.4.99

data/lib/prawn/font/dfont.rb

@@ -0,0 +1,31 @@
+require 'prawn/font/ttf'
+
+module Prawn
+  class Font
+    class DFont < TTF
+      # Returns a list of the names of all named fonts in the given dfont file.
+      # Note that fonts are not required to be named in a dfont file, so the
+      # list may be empty even if the file does contain fonts. Also, note that
+      # the list is returned in no particular order, so the first font in the
+      # list is not necessarily the font at index 0 in the file.
+      def self.named_fonts(file)
+        TTFunk::ResourceFile.open(file) do |file|
+          return file.resources_for("sfnt")
+        end
+      end
+
+      # Returns the number of fonts contained in the dfont file.
+      def self.font_count(file)
+        TTFunk::ResourceFile.open(file) do |file|
+          return file.map["sfnt"][:list].length
+        end
+      end
+
+      private 
+
+      def read_ttf_file
+        TTFunk::File.from_dfont(@name, @options[:font] || 0)
+      end
+    end
+  end
+end

data/lib/prawn/font/ttf.rb

@@ -0,0 +1,326 @@
+require 'ttfunk'
+require 'ttfunk/subset_collection'
+
+module Prawn
+  class Font
+    class TTF < Font
+      attr_reader :ttf, :subsets
+      
+      def initialize(document, name, options={})
+        super
+
+        @ttf              = read_ttf_file
+        @subsets          = TTFunk::SubsetCollection.new(@ttf)
+
+        @attributes       = {}
+        @bounding_boxes   = {} 
+        @char_widths      = {}   
+        @has_kerning_data = @ttf.kerning.exists? && @ttf.kerning.tables.any?
+
+        @ascender         = Integer(@ttf.ascent * scale_factor)
+        @descender        = Integer(@ttf.descent * scale_factor)
+        @line_gap         = Integer(@ttf.line_gap * scale_factor)
+      end
+
+      # +string+ must be UTF8-encoded.
+      def compute_width_of(string, options={})
+        scale = (options[:size] || size) / 1000.0
+        if options[:kerning]
+          kern(string).inject(0) do |s,r|
+            if r.is_a?(Numeric)
+              s - r
+            else 
+              r.inject(s) { |s2, u| s2 + character_width_by_code(u) }
+            end
+          end * scale
+        else
+          string.unpack("U*").inject(0) do |s,r|
+            s + character_width_by_code(r)
+          end * scale
+        end
+      end   
+      
+      def bbox
+        @bbox ||= @ttf.bbox.map { |i| Integer(i * scale_factor) }
+      end
+
+      def has_kerning_data?
+        @has_kerning_data 
+      end
+
+      # Perform any changes to the string that need to happen
+      # before it is rendered to the canvas. Returns an array of
+      # subset "chunks", where the even-numbered indices are the
+      # font subset number, and the following entry element is
+      # either a string or an array (for kerned text).
+      #
+      # The +text+ parameter must be UTF8-encoded.
+      def encode_text(text,options={})
+        text = text.chomp
+
+        if options[:kerning]
+          last_subset = nil
+          kern(text).inject([]) do |result, element| 
+            if element.is_a?(Numeric)
+              result.last[1] = [result.last[1]] unless result.last[1].is_a?(Array)
+              result.last[1] << element
+              result
+            else
+              encoded = @subsets.encode(element)
+
+              if encoded.first[0] == last_subset
+                result.last[1] << encoded.first[1]
+                encoded.shift
+              end
+
+              if encoded.any?
+                last_subset = encoded.last[0]
+                result + encoded
+              else
+                result
+              end
+            end
+          end
+        else
+          @subsets.encode(text.unpack("U*"))
+        end
+      end
+      
+      def basename
+        @basename ||= @ttf.name.postscript_name
+      end
+
+      # not sure how to compute this for true-type fonts...
+      def stemV
+        0
+      end
+
+      def italic_angle
+        @italic_angle ||= if @ttf.postscript.exists?
+          raw = @ttf.postscript.italic_angle
+          hi, low = raw >> 16, raw & 0xFF
+          hi = -((hi ^ 0xFFFF) + 1) if hi & 0x8000 != 0
+          "#{hi}.#{low}".to_f
+        else
+          0
+        end
+      end
+
+      def cap_height
+        @cap_height ||= begin
+          height = @ttf.os2.exists? && @ttf.os2.cap_height || 0
+          height == 0 ? ascender : height
+        end
+      end
+
+      def x_height
+        # FIXME: seems like if os2 table doesn't exist, we could
+        # just find the height of the lower-case 'x' glyph?
+        @ttf.os2.exists? && @ttf.os2.x_height || 0
+      end
+
+      def family_class
+        @family_class ||= (@ttf.os2.exists? && @ttf.os2.family_class || 0) >> 8
+      end
+
+      def serif?
+        @serif ||= [1,2,3,4,5,7].include?(family_class)
+      end
+
+      def script?
+        @script ||= family_class == 10
+      end
+
+      def pdf_flags
+        @flags ||= begin
+          flags = 0
+          flags |= 0x0001 if @ttf.postscript.fixed_pitch?
+          flags |= 0x0002 if serif?
+          flags |= 0x0008 if script?
+          flags |= 0x0040 if italic_angle != 0
+          flags |= 0x0004 # assume the font contains at least some non-latin characters
+        end
+      end
+
+      def normalize_encoding(text)
+        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
+
+      private
+
+      def cmap
+        @cmap ||= @ttf.cmap.unicode.first or raise("no unicode cmap for font")
+      end
+      
+      # +string+ must be UTF8-encoded.
+      #
+      # Returns an array. If an element is a numeric, it represents the
+      # kern amount to inject at that position. Otherwise, the element
+      # is an array of UTF-16 characters.
+      def kern(string)
+        a = []
+
+        string.unpack("U*").each do |r|
+          if a.empty?
+            a << [r]
+          elsif (kern = kern_pairs_table[[cmap[a.last.last], cmap[r]]])
+            kern *= scale_factor
+            a << -kern << [r]
+          else
+            a.last << r
+          end
+        end
+
+        a
+      end
+
+      def kern_pairs_table
+        @kerning_data ||= has_kerning_data? ? @ttf.kerning.tables.first.pairs : {}
+      end
+
+      def cid_to_gid_map
+        max = cmap.code_map.keys.max
+        (0..max).map { |cid| cmap[cid] }.pack("n*")
+      end
+
+      def hmtx
+        @hmtx ||= @ttf.horizontal_metrics
+      end
+
+      def character_width_by_code(code)    
+        return 0 unless cmap[code]
+        @char_widths[code] ||= Integer(hmtx.widths[cmap[code]] * scale_factor)
+      end                   
+
+      def scale_factor
+        @scale ||= 1000.0 / @ttf.header.units_per_em
+      end
+
+      def register(subset)
+        temp_name = @ttf.name.postscript_name
+        @document.ref(:Type => :Font, :BaseFont => temp_name) { |ref| embed(ref, subset) }
+      end
+
+      def embed(reference, subset)
+        font_content = @subsets[subset].encode
+
+        # FIXME: we need postscript_name and glyph widths from the font
+        # subset. Perhaps this could be done by querying the subset,
+        # rather than by parsing the font that the subset produces?
+        font = TTFunk::File.new(font_content)
+
+        # empirically, it looks like Adobe Reader will not display fonts
+        # if their font name is more than 33 bytes long. Strange. But true.
+        basename = font.name.postscript_name[0, 33]
+
+        raise "Can't detect a postscript name for #{file}" if basename.nil?
+
+        compressed_font = Zlib::Deflate.deflate(font_content)
+
+        fontfile = @document.ref(:Length => compressed_font.size,
+                                 :Length1 => font_content.size,
+                                 :Filter => :FlateDecode )
+        fontfile << compressed_font
+
+        descriptor = @document.ref(:Type        => :FontDescriptor,
+                                   :FontName    => basename,
+                                   :FontFile2   => fontfile,
+                                   :FontBBox    => bbox,
+                                   :Flags       => pdf_flags,
+                                   :StemV       => stemV,
+                                   :ItalicAngle => italic_angle,
+                                   :Ascent      => ascender,
+                                   :Descent     => descender,
+                                   :CapHeight   => cap_height,
+                                   :XHeight     => x_height)
+
+        hmtx = font.horizontal_metrics
+        widths = font.cmap.tables.first.code_map.map { |gid|
+          Integer(hmtx.widths[gid] * scale_factor) }[32..-1]
+
+        # It would be nice to have Encoding set for the macroman subsets,
+        # and only do a ToUnicode cmap for non-encoded unicode subsets.
+        # However, apparently Adobe Reader won't render MacRoman encoded
+        # subsets if original font contains unicode characters. (It has to
+        # be some flag or something that ttfunk is simply copying over...
+        # but I can't figure out which flag that is.)
+        #
+        # For now, it's simplest to just create a unicode cmap for every font.
+        # It offends my inner purist, but it'll do.
+
+        map = @subsets[subset].to_unicode_map
+
+        ranges = [[]]
+        lines = map.keys.sort.inject("") do |s, code|
+          ranges << [] if ranges.last.length >= 100
+          unicode = map[code]
+          ranges.last << "<%02x><%04x>" % [code, unicode]
+        end
+
+        range_blocks = ranges.inject("") do |s, list|
+          s << "%d beginbfchar\n%s\nendbfchar\n" % [list.length, list.join("\n")]
+        end
+
+        to_unicode_cmap = UNICODE_CMAP_TEMPLATE % range_blocks.strip
+
+        cmap = @document.ref({})
+        cmap << to_unicode_cmap
+        cmap.compress_stream
+
+        reference.data.update(:Subtype => :TrueType,
+                              :BaseFont => basename,
+                              :FontDescriptor => descriptor,
+                              :FirstChar => 32,
+                              :LastChar => 255,
+                              :Widths => @document.ref(widths),
+                              :ToUnicode => cmap)
+      end
+
+      UNICODE_CMAP_TEMPLATE = <<-STR.strip.gsub(/^\s*/, "")
+        /CIDInit /ProcSet findresource begin
+        12 dict begin
+        begincmap
+        /CIDSystemInfo <<
+          /Registry (Adobe)
+          /Ordering (UCS)
+          /Supplement 0
+        >> def
+        /CMapName /Adobe-Identity-UCS def
+        /CMapType 2 def
+        1 begincodespacerange
+        <00><ff>
+        endcodespacerange
+        %s
+        endcmap
+        CMapName currentdict /CMap defineresource pop
+        end
+        end
+      STR
+
+      def read_ttf_file
+        TTFunk::File.open(@name)
+      end
+    end
+  end
+end

data/lib/prawn/font.rb

@@ -0,0 +1,288 @@
+# encoding: utf-8
+#
+# font.rb : The Prawn font class
+#
+# 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/afm"
+require "prawn/font/ttf"
+require "prawn/font/dfont"
+
+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 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 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={})
+      return @font || font("Helvetica") if name.nil?
+
+      raise Errors::NotOnPage unless @current_page
+      new_font = find_font(name, options)
+
+      if block_given?
+        save_font do
+          set_font(new_font, options[:size])
+          yield
+        end
+      else
+        set_font(new_font, options[:size])
+      end
+
+      @font
+    end
+
+    # 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
+
+      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
+
+    # 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
+
+    # 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 Font#normalize_encoding method to make sure strings
+    # are in an encoding appropriate for the current font.
+    #--
+    # For the record, this method used to be a method of Font (and still delegates
+    # to width computations on Font). However, having the primary interface for
+    # calculating string widths exist on Font made it tricky to write extensions
+    # for Prawn in which widths are computed differently (e.g., taking formatting
+    # tags into account, or the like).
+    #
+    # By putting width_of here, on Document itself, extensions may easily override
+    # it and redefine the width calculation behavior.
+    #++
+    def width_of(string, options={})
+      font.compute_width_of(string, options)
+    end
+  end
+
+  # Provides font information and helper functions.
+  #
+  class Font
+
+    # The current font name
+    attr_reader :name
+
+    # The current font family
+    attr_reader :family
+
+    # 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
+
+    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
+      @line_gap / 1000.0 * size
+    end
+
+    def identifier_for(subset)
+      "#{@identifier}.#{subset}"
+    end
+
+    def inspect
+      "#{self.class.name}< #{name}: #{size} >"
+    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 height_at(size)
+      @normalized_height ||= (@ascender - @descender + @line_gap) / 1000.0
+      @normalized_height * size
+    end
+
+    # Gets height of current font in PDF points at current font size
+    #
+    def height
+      height_at(size)
+    end
+
+    # 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
+
+    private
+
+    def size
+      @document.font_size
+    end
+
+  end
+
+end