prawn-git 2.0.1

data/lib/prawn/document/column_box.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+#
+# column_box.rb: Extends BoundingBox to allow for columns of text
+#
+# Author Paul Ostazeski.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require_relative "bounding_box"
+
+module Prawn
+  class Document
+
+    # @group Experimental API
+
+    # A column box is a bounding box with the additional property that when
+    # text flows past the bottom, it will wrap first to another column on the
+    # same page, and only flow to the next page when all the columns are
+    # filled.
+    #
+    # column_box accepts the same parameters as bounding_box, as well as the
+    # number of :columns and a :spacer (in points) between columns. If resetting
+    # the top margin is desired on a new page (e.g. to allow for initial page
+    # wide column titles) the option :reflow_margins => true can be set.
+    #
+    # Defaults are :columns = 3, :spacer = font_size, and
+    # :reflow_margins => false
+    #
+    # Under PDF::Writer, "spacer" was known as "gutter"
+    #
+    def column_box(*args, &block)
+      init_column_box(block) do |parent_box|
+        map_to_absolute!(args[0])
+        @bounding_box = ColumnBox.new(self, parent_box, *args)
+      end
+    end
+
+    private
+
+    def init_column_box(user_block, options={}, &init_block)
+      parent_box = @bounding_box
+
+      init_block.call(parent_box)
+
+      self.y = @bounding_box.absolute_top
+      user_block.call
+      self.y = @bounding_box.absolute_bottom unless options[:hold_position]
+
+      @bounding_box = parent_box
+    end
+
+    # Implements the necessary functionality to allow Document#column_box to
+    # work.
+    #
+    class ColumnBox < BoundingBox
+
+      def initialize(document, parent, point, options={}) #:nodoc:
+        super
+        @columns = options[:columns] || 3
+        @spacer  = options[:spacer]  || @document.font_size
+        @current_column = 0
+        @reflow_margins = options[:reflow_margins]
+      end
+
+      # The column width, not the width of the whole box,
+      # before left and/or right padding
+      def bare_column_width
+        (@width - @spacer * (@columns - 1)) / @columns
+      end
+
+      # The column width after padding.
+      # Used to calculate how long a line of text can be.
+      #
+      def width
+        bare_column_width - (@total_left_padding + @total_right_padding)
+      end
+
+      # Column width including the spacer.
+      #
+      def width_of_column
+        bare_column_width + @spacer
+      end
+
+      # x coordinate of the left edge of the current column
+      #
+      def left_side
+        absolute_left + (width_of_column * @current_column)
+      end
+
+      # Relative position of the left edge of the current column
+      #
+      def left
+        width_of_column * @current_column
+      end
+
+      # x co-orordinate of the right edge of the current column
+      #
+      def right_side
+        columns_from_right = @columns - (1 + @current_column)
+        absolute_right - (width_of_column * columns_from_right)
+      end
+
+      # Relative position of the right edge of the current column.
+      #
+      def right
+        left + width
+      end
+
+      # Moves to the next column or starts a new page if currently positioned at
+      # the rightmost column.
+      def move_past_bottom
+        @current_column = (@current_column + 1) % @columns
+        @document.y = @y
+        if 0 == @current_column
+          if @reflow_margins
+            @y = @parent.absolute_top
+          end
+          @document.start_new_page
+        end
+      end
+
+      # Override the padding functions so as not to split the padding amount
+      # between all columns on the page.
+
+      def add_left_padding(left_padding)
+        @total_left_padding += left_padding
+        @x += left_padding
+      end
+
+      def subtract_left_padding(left_padding)
+        @total_left_padding -= left_padding
+        @x -= left_padding
+      end
+
+      def add_right_padding(right_padding)
+        @total_right_padding += right_padding
+      end
+
+      def subtract_right_padding(right_padding)
+        @total_right_padding -= right_padding
+      end
+    end
+  end
+end

data/lib/prawn/document/internals.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+#
+# internals.rb : Implements document internals for Prawn
+#
+# Copyright August 2008, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require "forwardable"
+
+module Prawn
+  class Document
+
+    # This module exposes a few low-level PDF features for those who want
+    # to extend Prawn's core functionality.  If you are not comfortable with
+    # low level PDF functionality as defined by Adobe's specification, chances
+    # are you won't need anything you find here.
+    #
+    # @private
+    module Internals
+      extend Forwardable
+
+      # These methods are not officially part of Prawn's public API,
+      # but they are used in documentation and possibly in extensions.
+      # Perhaps they will become part of the extension API?
+      # Anyway, for now it's not clear what we should do w. them.
+      delegate [ :graphic_state,
+                 :save_graphics_state,
+                 :restore_graphics_state,
+                 :on_page_create ] => :renderer
+
+      # FIXME: This is a circular reference, because in theory Prawn should
+      # be passing instances of renderer to PDF::Core::Page, but it's
+      # passing Prawn::Document objects instead.
+      #
+      # A proper design would probably not require Prawn to directly instantiate
+      # PDF::Core::Page objects at all!
+      delegate [:compression_enabled?] => :renderer
+
+      # FIXME: More circular references in PDF::Core::Page.
+      delegate [ :ref, :ref!, :deref ] => :renderer
+
+      # FIXME: Another circular reference, because we mix in a module from
+      # PDF::Core to provide destinations, which in theory should not
+      # rely on a Prawn::Document object but is currently wired up that way.
+      delegate [:names] => :renderer
+
+      # FIXME: Circular reference because we mix PDF::Core::Text into
+      # Prawn::Document. PDF::Core::Text should either be split up or
+      # moved in its entirety back up into Prawn.
+      delegate [:add_content] => :renderer
+
+      def renderer
+        @renderer ||= PDF::Core::Renderer.new(state)
+      end
+    end
+  end
+end

data/lib/prawn/document/span.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+# span.rb : Implements text columns
+#
+# Copyright September 2008, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  class Document
+    # @group Stable API
+
+    # A span is a special purpose bounding box that allows a column of
+    # elements to be positioned relative to the margin_box.
+    #
+    # Arguments:
+    # +width+:: The width of the column in PDF points
+    #
+    # Options:
+    # <tt>:position</tt>:: One of :left, :center, :right or an x offset
+    #
+    # This method is typically used for flowing a column of text from one
+    # page to the next.
+    #
+    #  span(350, :position => :center) do
+    #    text "Here's some centered text in a 350 point column. " * 100
+    #  end
+    #
+    def span(width, options={})
+      Prawn.verify_options [:position], options
+      original_position = self.y
+
+      # FIXME: Any way to move this upstream?
+      left_boundary = case(options[:position] || :left)
+      when :left
+        margin_box.absolute_left
+      when :center
+        margin_box.absolute_left + margin_box.width / 2.0 - width / 2.0
+      when :right
+        margin_box.absolute_right - width
+      when Numeric
+        margin_box.absolute_left + options[:position]
+      else
+        raise ArgumentError, "Invalid option for :position"
+      end
+
+      # we need to bust out of whatever nested bounding boxes we're in.
+      canvas do
+        bounding_box([left_boundary,
+                      margin_box.absolute_top], :width => width) do
+          self.y = original_position
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/prawn/encoding.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+#
+# Copyright September 2008, Gregory Brown, James Healy  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Encoding # @private
+    # Map between unicode and WinAnsiEnoding
+    #
+    class WinAnsi #:nodoc:
+      CHARACTERS = %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      quotesingle
+        parenleft     parenright     asterisk       plus
+        comma         hyphen         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
+
+        grave         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
+
+        Euro          .notdef        quotesinglbase florin
+        quotedblbase  ellipsis       dagger         daggerdbl
+        circumflex    perthousand    Scaron         guilsinglleft
+        OE            .notdef        Zcaron         .notdef
+        .notdef       quoteleft      quoteright     quotedblleft
+        quotedblright bullet         endash         emdash
+        tilde         trademark      scaron         guilsinglright
+        oe            .notdef        zcaron         ydieresis
+
+        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
+      ]
+    end
+  end
+end

data/lib/prawn/errors.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+#
+# errors.rb : Implements custom error classes for Prawn
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Errors
+     # Raised when a table is spanned in an impossible way.
+     #
+     InvalidTableSpan = Class.new(StandardError)
+
+     # This error is raised when a method requiring a current page is called
+     # without being on a page.
+     #
+     NotOnPage = Class.new(StandardError)
+
+     # This error is raised when Prawn cannot find a specified font
+     #
+     UnknownFont = Class.new(StandardError)
+
+     # Raised when Prawn is asked to draw something into a too-small box
+     #
+     CannotFit = Class.new(StandardError)
+
+     # Raised if group() is called with a block that is too big to be
+     # rendered in the current context.
+     #
+     CannotGroup = Class.new(StandardError)
+
+     # 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
+     #
+     IncompatibleStringEncoding = Class.new(StandardError)
+
+     # 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.
+     #
+     UnknownOption = Class.new(StandardError)
+
+     # this error is raised when a user attempts to embed an image of an unsupported
+     # type. This can either a completely unsupported format, or a dialect of a
+     # supported format (ie. some types of PNG)
+     UnsupportedImageType = Class.new(StandardError)
+
+    # This error is raised when a named element has alredy been
+    # created. For example, in the stamp module, stamps must have
+    # unique names within a document
+    NameTaken = Class.new(StandardError)
+
+    # This error is raised when a name is not a valid format
+    InvalidName = Class.new(StandardError)
+
+    # This error is raised when an object is attempted to be
+    # referenced by name, but no such name is associated with an object
+    UndefinedObjectName = Class.new(StandardError)
+
+    # This error is raised when a required option has not been set
+    RequiredOption = Class.new(StandardError)
+
+    # This error is raised when a requested outline item with a given title does not exist
+    UnknownOutlineTitle = Class.new(StandardError)
+
+    # This error is raised when a block is required, but not provided
+    BlockRequired = Class.new(StandardError)
+
+    # This error is rased when a graphics method is called with improper arguments
+    InvalidGraphicsPath = Class.new(StandardError)
+
+    # Raised when unrecognized content is provided for a table cell.
+    #
+    UnrecognizedTableContent = Class.new(StandardError)
+
+  end
+end

data/lib/prawn/font.rb

@@ -0,0 +1,413 @@
+# 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_relative "font/afm"
+require_relative "font/ttf"
+require_relative "font/dfont"
+require_relative "font_metric_cache"
+
+module Prawn
+
+  class Document
+    # @group Stable API
+
+    # Without arguments, this returns the currently selected font. Otherwise,
+    # it sets the current font. When a block is used, the font is applied
+    # transactionally and is rolled back when the block exits.
+    #
+    #   Prawn::Document.generate("font.pdf") do
+    #     text "Default font is Helvetica"
+    #
+    #     font "Times-Roman"
+    #     text "Now using Times-Roman"
+    #
+    #     font("DejaVuSans.ttf") do
+    #       text "Using TTF font from file DejaVuSans.ttf"
+    #       font "Courier", :style => :bold
+    #       text "You see this in bold Courier"
+    #     end
+    #
+    #     text "Times-Roman, again"
+    #   end
+    #
+    # The :name 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.
+    #
+    # 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.
+    #
+    # The options parameter is an optional hash providing size and style. To use
+    # the :style option you need to map those font styles to their respective font files.
+    # See font_families for more information.
+    #
+    def font(name=nil, options={})
+      return((defined?(@font) && @font) || font("Helvetica")) if name.nil?
+
+      if state.pages.empty? && !state.page.in_stamp_stream?
+        raise Prawn::Errors::NotOnPage
+      end
+
+      new_font = find_font(name.to_s, 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
+
+    # @method font_size(points=nil)
+    #
+    # 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 size
+    def font_size=(size)
+      font_size(size)
+    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={})
+      if p = options[:inline_format]
+        p = [] unless p.is_a?(Array)
+
+        # Build up an Arranger with the entire string on one line, finalize it,
+        # and find its width.
+        arranger = Prawn::Text::Formatted::Arranger.new(self, options)
+        arranger.consumed = self.text_formatter.format(string, *p)
+        arranger.finalize_line
+
+        arranger.line_width
+      else
+        width_of_string(string, options)
+      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",
+    #                            :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.
+    #
+    # By default the styles :bold, :italic, :bold_italic, and :normal are
+    # defined for fonts "Courier", "Times-Roman" and "Helvetica". When
+    # defining your own font families, you can map any or all of these
+    # styles to whatever font files you'd like.
+    #
+    def font_families
+      @font_families ||= {}.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
+
+    # @group Experimental API
+
+    # 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.
+    # ++
+    #
+    # @private
+    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}"
+
+      if name.is_a? Prawn::Font
+        font_registry[key] = name
+      else
+        font_registry[key] ||= Font.load( self,
+                                          name,
+                                          options.merge(family: family)
+                               )
+      end
+    end
+
+    # Hash of Font objects keyed by names
+    #
+    def font_registry #:nodoc:
+      @font_registry ||= {}
+    end
+
+    private
+
+    def width_of_inline_formatted_string(string, options={})
+      # Build up an Arranger with the entire string on one line, finalize it,
+      # and find its width.
+      arranger = Prawn::Text::Formatted::Arranger.new(self, options)
+      arranger.consumed = Text::Formatted::Parser.format(string)
+      arranger.finalize_line
+
+      arranger.line_width
+    end
+
+    def width_of_string(string, options={})
+      font_metric_cache.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
+
+    # Shortcut interface for constructing a font object.  Filenames of the form
+    # *.ttf will call Font::TTF.new, *.dfont Font::DFont.new, and anything else
+    # will be passed through to Font::AFM.new()
+    def self.load(document, src, options={})
+      case font_format(src, options)
+      when 'ttf'   then TTF.new(document, src, options)
+      when 'dfont' then DFont.new(document, src, options)
+      else AFM.new(document, src, options)
+      end
+    end
+
+    def self.font_format(src, options)
+      return options.fetch(:format, 'ttf') if src.respond_to? :read
+
+      case src.to_s
+      when /\.ttf$/i   then return 'ttf'
+      when /\.dfont$/i then return 'dfont'
+      else return 'afm'
+      end
+    end
+
+    def initialize(document,name,options={}) #:nodoc:
+      @document   = document
+      @name       = name
+      @options    = options
+
+      @family     = options[:family]
+
+      @identifier = generate_unique_id
+
+      @references = {}
+    end
+
+    # The size of the font ascender in PDF points
+    #
+    def ascender
+      @ascender / 1000.0 * size
+    end
+
+    # The size of the font descender in PDF points
+    #
+    def descender
+      -@descender / 1000.0 * size
+    end
+
+    # The size of the recommended gap between lines of text in PDF points
+    #
+    def line_gap
+      @line_gap / 1000.0 * 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. It will be re-encoded
+    # and the new string will be returned. For an in-place (destructive)
+    # version, see normalize_encoding!.
+    def normalize_encoding(string)
+      raise NotImplementedError, "subclasses of Prawn::Font must implement #normalize_encoding"
+    end
+
+    # Destructive version of normalize_encoding; normalizes the encoding of a
+    # string in place.
+    #
+    def normalize_encoding!(str)
+      str.replace(normalize_encoding(str))
+    end
+
+    # Gets height of current font in PDF points at the given font size
+    #
+    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.state.page.fonts.merge!(identifier_for(subset) => @references[subset])
+    end
+
+    def identifier_for(subset) #:nodoc:
+      "#{@identifier}.#{subset}"
+    end
+
+    def inspect #:nodoc:
+      "#{self.class.name}< #{name}: #{size} >"
+    end
+
+    # Return a hash (as in Object#hash) for the font based on the output of
+    # #inspect. This is required since font objects are used as keys in hashes
+    # that cache certain values (See
+    # Prawn::Table::Text#styled_with_of_single_character)
+    #
+    def hash #:nodoc:
+      [ self.class, self.name, self.family, size ].hash
+    end
+
+    # Compliments the #hash implementation above
+    #
+    def eql?( other ) #:nodoc:
+      self.class == other.class && self.name == other.name &&
+        self.family == other.family && size == other.send(:size)
+    end
+
+    private
+
+    # generate a font identifier that hasn't been used on the current page yet
+    #
+    def generate_unique_id
+      :"F#{@document.font_registry.size + 1}"
+    end
+
+    def size
+      @document.font_size
+    end
+
+  end
+
+end