prawn-git 2.0.1

data/lib/prawn/font/afm.rb

@@ -0,0 +1,256 @@
+# encoding: utf-8
+
+# prawn/font/afm.rb : Implements AFM font support for Prawn
+#
+# Copyright May 2008, Gregory Brown / James Healy.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require_relative "../encoding"
+
+module Prawn
+  class Font
+
+    # @private
+
+    class AFM < Font
+      class << self
+        attr_accessor :hide_m17n_warning
+      end
+
+      self.hide_m17n_warning = false
+
+      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 ]
+
+      def unicode?
+        false
+      end
+
+      def self.metrics_path
+        if m = ENV['METRICS']
+          @metrics_path ||= m.split(':')
+        else
+          @metrics_path ||= [
+            ".", "/usr/lib/afm",
+            "/usr/local/lib/afm",
+            "/usr/openwin/lib/fonts/afm",
+             Prawn::DATADIR+'/fonts']
+        end
+      end
+
+      attr_reader :attributes #:nodoc:
+
+      def initialize(document, name, options={}) #:nodoc:
+        unless BUILT_INS.include?(name)
+          raise Prawn::Errors::UnknownFont, "#{name} is not a known font."
+        end
+
+        super
+
+        @@font_data ||= SynchronizedCache.new        # parse each ATM font file once only
+
+        file_name = @name.dup
+        file_name << ".afm" unless file_name =~ /\.afm$/
+        file_name = file_name[0] == ?/ ? file_name : find_font(file_name)
+
+        font_data = @@font_data[file_name] ||= parse_afm(file_name)
+        @glyph_widths    = font_data[:glyph_widths]
+        @glyph_table     = font_data[:glyph_table]
+        @bounding_boxes  = font_data[:bounding_boxes]
+        @kern_pairs      = font_data[:kern_pairs]
+        @kern_pair_table = font_data[:kern_pair_table]
+        @attributes      = font_data[:attributes]
+
+        @ascender  = @attributes["ascender"].to_i
+        @descender = @attributes["descender"].to_i
+        @line_gap  = Float(bbox[3] - bbox[1]) - (@ascender - @descender)
+      end
+
+      # The font bbox, as an array of integers
+      #
+      def bbox
+        @bbox ||= @attributes['fontbbox'].split(/\s+/).map { |e| Integer(e) }
+      end
+
+      # NOTE: String *must* be encoded as WinAnsi
+      def compute_width_of(string, options={}) #:nodoc:
+        scale = (options[:size] || size) / 1000.0
+
+        if options[:kerning]
+          strings, numbers = kern(string).partition { |e| e.is_a?(String) }
+          total_kerning_offset = numbers.inject(0.0) { |s,r| s + r }
+          (unscaled_width_of(strings.join) - total_kerning_offset) * scale
+        else
+          unscaled_width_of(string) * scale
+        end
+      end
+
+      # Returns true if the font has kerning data, false otherwise
+      #
+      def has_kerning_data?
+        @kern_pairs.any?
+      end
+
+      # built-in fonts only work with winansi encoding, so translate the
+      # string. Changes the encoding in-place, so the argument itself
+      # is replaced with a string in WinAnsi encoding.
+      #
+      def normalize_encoding(text)
+        text.encode("windows-1252")
+      rescue ::Encoding::InvalidByteSequenceError,
+             ::Encoding::UndefinedConversionError
+
+        raise Prawn::Errors::IncompatibleStringEncoding,
+          "Your document includes text that's not compatible with the Windows-1252 character set.\n"+
+          "If you need full UTF-8 support, use TTF fonts instead of PDF's built-in fonts\n."
+      end
+
+      def to_utf8(text)
+        text.encode("UTF-8")
+      end
+
+      # Returns the number of characters in +str+ (a WinAnsi-encoded string).
+      #
+      def character_count(str)
+        str.length
+      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 each chunk is an array of two elements.
+      # The first element is the font subset number, and the second
+      # is either a string or an array (for kerned text).
+      #
+      # For Adobe fonts, there is only ever a single subset, so
+      # the first element of the array is "0", and the second is
+      # the string itself (or an array, if kerning is performed).
+      #
+      # The +text+ parameter must be in WinAnsi encoding (cp1252).
+      #
+      def encode_text(text, options={})
+        [[0, options[:kerning] ? kern(text) : text]]
+      end
+
+      def glyph_present?(char)
+        !!normalize_encoding(char)
+      rescue Prawn::Errors::IncompatibleStringEncoding
+        false
+      end
+
+      private
+
+      def register(subset)
+        font_dict = {:Type     => :Font,
+                     :Subtype  => :Type1,
+                     :BaseFont => name.to_sym}
+
+        # Symbolic AFM fonts (Symbol, ZapfDingbats) have their own encodings
+        font_dict.merge!(:Encoding => :WinAnsiEncoding) unless symbolic?
+
+        @document.ref!(font_dict)
+      end
+
+      def symbolic?
+        attributes["characterset"] == "Special"
+      end
+
+      def find_font(file)
+        self.class.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" +
+           self.class.metrics_path.join("\n")
+      end
+
+      def parse_afm(file_name)
+        data    = {:glyph_widths => {}, :bounding_boxes => {}, :kern_pairs => {}, :attributes => {}}
+        section = []
+
+        File.foreach(file_name) do |line|
+          case line
+          when /^Start(\w+)/
+            section.push $1
+            next
+          when /^End(\w+)/
+            section.pop
+            next
+          end
+
+          case section
+          when ["FontMetrics", "CharMetrics"]
+            next unless line =~ /^CH?\s/
+
+            name                        = line[/\bN\s+(\.?\w+)\s*;/, 1]
+            data[:glyph_widths][name]   = line[/\bWX\s+(\d+)\s*;/, 1].to_i
+            data[:bounding_boxes][name] = line[/\bB\s+([^;]+);/, 1].to_s.rstrip
+          when ["FontMetrics", "KernData", "KernPairs"]
+            next unless line =~ /^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/
+            data[:kern_pairs][[$1, $2]] = $3.to_i
+          when ["FontMetrics", "KernData", "TrackKern"],
+            ["FontMetrics", "Composites"]
+            next
+          else
+            parse_generic_afm_attribute(line, data)
+          end
+        end
+
+        # process data parsed from AFM file to build tables which
+        #   will be used when measuring and kerning text
+        data[:glyph_table] = (0..255).map do |i|
+          data[:glyph_widths][Encoding::WinAnsi::CHARACTERS[i]].to_i
+        end
+
+        character_hash = Hash[Encoding::WinAnsi::CHARACTERS.zip((0..Encoding::WinAnsi::CHARACTERS.size).to_a)]
+        data[:kern_pair_table] = data[:kern_pairs].inject({}) do |h,p|
+          h[p[0].map { |n| character_hash[n] }] = p[1]
+          h
+        end
+
+        data.each_value { |hash| hash.freeze }
+        data.freeze
+      end
+
+      def parse_generic_afm_attribute(line, hash)
+        line =~ /(^\w+)\s+(.*)/
+        key, value = $1.to_s.downcase, $2
+
+        hash[:attributes][key] = hash[:attributes][key] ? Array(hash[:attributes][key]) << value : value
+      end
+
+      # converts a string into an array with spacing offsets
+      # bewteen characters that need to be kerned
+      #
+      # String *must* be encoded as WinAnsi
+      #
+      def kern(string)
+        kerned = [[]]
+        last_byte = nil
+
+        string.each_byte do |byte|
+          if k = last_byte && @kern_pair_table[[last_byte, byte]]
+            kerned << -k << [byte]
+          else
+            kerned.last << byte
+          end
+          last_byte = byte
+        end
+
+        kerned.map { |e|
+          e = (Array === e ? e.pack("C*") : e)
+          e.respond_to?(:force_encoding) ? e.force_encoding(::Encoding::Windows_1252) : e
+        }
+      end
+
+      private
+
+      def unscaled_width_of(string)
+        string.bytes.inject(0) do |s,r|
+          s + @glyph_table[r]
+        end
+      end
+    end
+  end
+end

data/lib/prawn/font/dfont.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+#
+# font.rb : The Prawn font class
+#
+# Copyright November 2008, Jamis Buck. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+require_relative 'ttf'
+
+module Prawn
+  class Font
+    # @private
+    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 |f|
+          return f.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 |f|
+          return f.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,355 @@
+# encoding: utf-8
+
+# prawn/font/ttf.rb : Implements AFM font support for Prawn
+#
+# Copyright May 2008, Gregory Brown / James Healy / Jamis Buck
+# All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'ttfunk'
+require 'ttfunk/subset_collection'
+
+module Prawn
+  class Font
+
+    # @private
+    class TTF < Font
+      attr_reader :ttf, :subsets
+
+      def unicode?
+        true
+      end
+
+      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
+
+      # NOTE: +string+ must be UTF8-encoded.
+      def compute_width_of(string, options={}) #:nodoc:
+        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.codepoints.inject(0) do |s,r|
+            s + character_width_by_code(r)
+          end * scale
+        end
+      end
+
+      # The font bbox, as an array of integers
+      #
+      def bbox
+        @bbox ||= @ttf.bbox.map { |i| Integer(i * scale_factor) }
+      end
+
+      # Returns true if the font has kerning data, false otherwise
+      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)
+        begin
+          text.encode(::Encoding::UTF_8)
+        rescue => e
+          puts e
+          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
+      end
+
+      def to_utf8(text)
+        text.encode("UTF-8")
+      end
+
+      def glyph_present?(char)
+        code = char.codepoints.first
+        cmap[code] > 0
+      end
+
+      # Returns the number of characters in +str+ (a UTF-8-encoded string).
+      #
+      def character_count(str)
+        str.length
+      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.each_codepoint 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]
+
+        # Some TTF fonts have nonzero widths for \n (UTF-8 / ASCII code: 10).
+        # Patch around this as we'll never be drawing a newline with a width.
+        return 0.0 if code == 10
+
+        @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.gsub("\0","").to_sym
+        ref = @document.ref!(:Type => :Font, :BaseFont => temp_name)
+
+        # Embed the font metrics in the document after everything has been
+        # drawn, just before the document is emitted.
+        @document.renderer.before_render { |doc| embed(ref, subset) }
+
+        ref
+      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].gsub("\0","")
+
+        raise "Can't detect a postscript name for #{file}" if basename.nil?
+
+        fontfile = @document.ref!(:Length1 => font_content.size)
+        fontfile.stream << font_content
+        fontfile.stream.compress!
+
+        descriptor = @document.ref!(:Type        => :FontDescriptor,
+                                   :FontName    => basename.to_sym,
+                                   :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 = [[]]
+        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.stream.compress!
+
+        reference.data.update(:Subtype => :TrueType,
+                              :BaseFont => basename.to_sym,
+                              :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