prawn 0.1.0

data/vendor/font_ttf/ttf/exceptions.rb

@@ -0,0 +1,28 @@
+# TTF/Ruby, a library to read and write TrueType fonts in Ruby.
+# Copyright (C) 2006  Mathieu Blondel
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+module Font
+module TTF
+
+class MalformedFont < Exception
+end
+
+class TableMissing < Exception
+end
+
+end
+end

data/vendor/font_ttf/ttf/file.rb

@@ -0,0 +1,290 @@
+# TTF/Ruby, a library to read and write TrueType fonts in Ruby.
+# Copyright (C) 2006  Mathieu Blondel
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+require 'ttf/datatypes'
+require 'ttf/exceptions'
+require 'ttf/fontchunk'
+require 'ttf/encodings'
+
+require 'ttf/table/cmap'
+require 'ttf/table/cvt'
+require 'ttf/table/fpgm'
+require 'ttf/table/gasp'
+require 'ttf/table/glyf'
+require 'ttf/table/head'
+require 'ttf/table/hhea'
+require 'ttf/table/hmtx'
+require 'ttf/table/kern'
+require 'ttf/table/loca'
+require 'ttf/table/maxp'
+require 'ttf/table/name'
+require 'ttf/table/os2'
+require 'ttf/table/post'
+require 'ttf/table/prep'
+require 'ttf/table/vhea'
+require 'ttf/table/vmtx'
+
+module Font
+module TTF
+# TTF/Ruby is a library to read and write TrueType fonts in Ruby.
+#
+# Author:: Mathieu Blondel
+# Copyright:: Copyright (c) 2006 Mathieu Blondel
+# License:: GPL
+#
+# This Font::TTF::File class is TTF/Ruby's main class and is a subclass
+# of Ruby's File class. Here is some sample code:
+#
+#  require 'ttf'
+#
+#  font = Font::TTF::File.new("copy.ttf")
+#
+#  cmap_tbl = font.get_table(:cmap)
+#  enc_tbl4 = cmap_tbl.encoding_tables.find { |t| t.format == 4 }
+#  m_unicode = "m".unpack("U")[0]
+#  glyph_id = enc_tbl4.charmaps[m_unicode]
+#
+#  loca_tbl = font.get_table(:loca)
+#  glyph_offset = loca_tbl.glyph_offsets[glyph_id]
+#
+#  glyf_tbl = font.get_table(:glyf)
+#  glyph = glyf_tbl.get_glyph_at_offset(glyph_offset)
+#  unless glyph.composite?
+#      glyph.abs_coordinates.each { |x, y| puts x, y }
+#  end
+#
+# Here are the tables and their associated Symbol:
+#
+# * :cmap => Font::TTF::Table::Cmap
+# * :cvt => Font::TTF::Table::Cvt
+# * :fpgm => Font::TTF::Table::Fpgm
+# * :gasp => Font::TTF::Table::Gasp
+# * :glyf => Font::TTF::Table::Glyf
+# * :head => Font::TTF::Table::Head
+# * :hhea => Font::TTF::Table::Hhea
+# * :hmtx => Font::TTF::Table::Hmtx
+# * :kern => Font::TTF::Table::Kern
+# * :loca => Font::TTF::Table::Loca
+# * :maxp => Font::TTF::Table::Maxp
+# * :name => Font::TTF::Table::Name
+# * :"OS/2" => Font::TTF::Table::OS2
+# * :post => Font::TTF::Table::Post
+# * :prep => Font::TTF::Table::Prep
+# * :vhea => Font::TTF::Table::Vhea
+# * :vmtx => Font::TTF::Table::Vmtx
+# 
+# Of course, you may modify attributes and generate a new font file.
+#
+#  require "ttf"
+# 
+#  font = Font::TTF::File.new("file.ttf", "w")
+#  name_tbl = font.get_table(:name)
+#  nr = name_tbl.name_records[0]
+#  nr.utf8_str = "blablabla"
+#  font.write(font.dump) 
+#
+class File < File
+
+    TABLES = {:cmap => Font::TTF::Table::Cmap,
+              :cvt => Font::TTF::Table::Cvt,
+              :fpgm => Font::TTF::Table::Fpgm,
+              :gasp => Font::TTF::Table::Gasp,
+              :glyf => Font::TTF::Table::Glyf,
+              :head => Font::TTF::Table::Head,
+              :hhea => Font::TTF::Table::Hhea,
+              :hmtx => Font::TTF::Table::Hmtx,
+              :kern => Font::TTF::Table::Kern,
+              :loca => Font::TTF::Table::Loca,
+              :maxp => Font::TTF::Table::Maxp,
+              :name => Font::TTF::Table::Name,
+              :"OS/2" => Font::TTF::Table::OS2,
+              :post => Font::TTF::Table::Post,
+              :prep => Font::TTF::Table::Prep,
+              :vhea => Font::TTF::Table::Vhea,
+              :vmtx => Font::TTF::Table::Vmtx}
+
+    DIR_ENTRY_SIZE = 4 * IO::SIZEOF_ULONG
+
+    attr_reader :filename, :version, :search_range, 
+                :entry_selector, :range_shift, :table_list, :tables_infos
+
+    attr_writer :version, :search_range, :entry_selector, :range_shift
+
+    # Font::TTF::File being a subclass of Ruby's File class, you may 
+    # create new objects with the same parameters as Ruby's File class. 
+    #
+    # But you may also create new objects without parameters in case you want
+    # to create a font from scratch and you don't need to write it to a file.
+    def initialize(*args)
+        if args.length == 0
+            @filename = nil
+            @version = 0x00010000 # 1.0
+        else
+            super(*args)
+            @filename = args[0]
+        end
+
+        @table_list = [] # ordered list
+        @tables = {} # Tables are kept in this arr so we don't
+                     # have to create new objects everytime
+        @tables_infos = {} # infos about tables present in file
+
+        if not @filename.nil? and FileTest.exists? @filename    
+            begin
+                at_offset(0) do
+                    @version = read_fixed
+                    table_num = read_ushort
+                    @search_range = read_ushort
+                    @entry_selector = read_ushort
+                    @range_shift = read_ushort                           
+                
+                    table_num.times do
+                        tag = read_ulong_as_text.strip.to_sym
+                        @table_list << tag
+                        @tables_infos[tag] = {:checksum => read_ulong,
+                                              :offset => read_ulong,
+                                              :len => read_ulong}
+                    end
+                end               
+            rescue
+                raise MalformedFont
+            end
+        end
+    end
+
+    # Returns table associated with tag tbl_tag. It may return one of
+    # Font::TTF::Table::* object or a Font::TTF::FontChunk object if the
+    # table is not implemented yet by ttf-ruby.
+    #
+    # The table returned is kept internally so that every future call to
+    # get_table with the same tbl_tag will return the same object.
+    def get_table(tbl_tag)
+        tbli = @tables_infos[tbl_tag]
+
+        if @tables.include? tbl_tag
+            @tables[tbl_tag]
+        elsif tbli.nil?
+            raise TableMissing, "Table #{tbl_tag.to_s} neither exists " + \
+                                "in file nor was defined by user!"              
+ 
+        elsif TABLES.include? tbl_tag
+            @tables[tbl_tag] = \
+                TABLES[tbl_tag].new(self, tbli[:offset], tbli[:len])
+        else
+            Font::TTF::FontChunk.new(self, tbli[:offset], tbli[:len])
+        end
+    end
+
+    # Returns whether table with tag tbl_tag is already in font or not.
+    def tables_include?(tbl_tag)
+        @table_list.include? tbl_tag
+    end
+
+    # Gets a new empty table that then may be set with set_table.
+    # tbl_tag is a Symbol.
+    def get_new_table(tbl_tag)
+        if TABLES.include? tbl_tag
+            TABLES[tbl_tag].new(self)
+        else
+            Font::TTF::FontChunk.new(self)
+        end
+    end
+
+    # Updates some member variables that change everytime a table is added
+    # to the font.
+    def table_list_update!
+        @table_list.sort!
+
+        res = 1
+        power = 0
+        while res <= @table_list.length
+            res *= 2
+            power += 1
+        end
+        @search_range = res * 16
+        @entry_selector = power - 1
+        @range_shift = @table_list.length * 16 - @search_range
+    end
+    private :table_list_update!
+
+    # Adds tbl to font. tbl is a table object 
+    # (e.g. an instance of Font::TTF::Table::Loca).
+    def set_table(tbl)
+        tbl_tag = tbl.tag
+
+        unless tables_include? tbl_tag
+            @table_list << tbl_tag 
+            table_list_update!
+        end
+        @tables[tbl_tag] = tbl
+    end
+    
+    # Removes tbl from font. tbl may be a Symbol (e.g. :loca for the loca table)
+    # or a table object (e.g. an instance of Font::TTF::Table::Loca).
+    def unset_table(tbl)
+        if tbl.kind_of? Symbol
+            tbl_tag = tbl
+        else
+            tbl_tag = tbl.tag
+        end
+
+        @table_list.delete(tbl_tag)
+        @tables.delete(tbl_tag)
+        table_list_update!
+    end
+
+    # Dumps the whole font in binary raw format as found in a font file.
+    def dump
+        raw = ""
+        raw += (@version || 0).to_fixed
+        raw += (@table_list || []).length.to_ushort
+        raw += (@search_range || 0).to_ushort
+        raw += (@entry_selector || 0).to_ushort
+        raw += (@range_shift || 0).to_ushort
+
+        
+        offs = IO::SIZEOF_FIXED + 4 * IO::SIZEOF_USHORT + \
+               @table_list.length * DIR_ENTRY_SIZE
+
+        dumps = []
+        @table_list.each do |tbl_tag|
+            tbl = get_table(tbl_tag)
+            tag = tbl_tag.to_s
+            tag.four_chars!
+            raw += tag
+            # FIXME: FontChunk#checksum method is buggy
+            # For now, I set it to 0
+            raw += 0.to_ulong 
+            raw += offs.to_ulong
+            dump = tbl.dump
+            dumps << dump
+            len = dump.length
+            raw += len.to_ulong
+            offs += len
+        end
+
+        dumps.each do |dump|
+            raw += dump
+        end
+        
+        raw
+    end
+
+end
+
+end
+end

data/vendor/font_ttf/ttf/fontchunk.rb

@@ -0,0 +1,77 @@
+# TTF/Ruby, a library to read and write TrueType fonts in Ruby.
+# Copyright (C) 2006  Mathieu Blondel
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+module Font
+module TTF
+
+# A FontChunk is a portion of font. It starts at an offset and has a given
+# length. It is useful to handle tables that have not been implemented
+# or to quickly get a dump for a table that has not been modified.
+class FontChunk 
+
+    attr_reader :font
+    attr_accessor :offset, :len
+
+    def initialize(font, offset=nil, len=nil)
+        @font = font
+        # When a FontChunk is modified by user,
+        # offset and len are not true anymore
+        @offset = offset
+        @len = len
+    end
+
+    # Returns the end of the class name as a Symbol.
+    # Will be useful for tables, which are subclasses of FontChunk.
+    # For example, calling tag on Font::TTF:Table::Loca object will return
+    # :loca.
+    def tag
+        t = self.class.name.split("::").last.downcase.to_sym
+        t = :"OS/2" if t == :os2
+        t
+    end
+
+    # Basically each table is a FontChunk and tables may be created by hand
+    # (i.e. not exist in file yet). This method returns whether the FontChunk
+    # already exists in file or not.
+    def exists_in_file?
+        not @offset.nil?
+    end
+
+    # Returns raw binary data of the FontChunk.
+    def dump
+        @font.at_offset(@offset) do
+            @font.read(@len)
+        end
+    end
+
+    # Returns a checksum of dump.
+    def self.checksum(dump)
+        # FIXME: this methods seems to be buggy
+        len = ((raw.length + 3) & ~3) / IO::SIZEOF_ULONG
+        sum = 0
+        (len - 1).times do |i|
+            ulong_str = raw.slice(i * IO::SIZEOF_ULONG, IO::SIZEOF_ULONG)
+            ulong = ulong_str.unpack("N")[0]
+            sum += ulong
+        end        
+        sum
+    end
+
+end
+
+end
+end

data/vendor/font_ttf/ttf/table/cmap.rb

@@ -0,0 +1,408 @@
+# TTF/Ruby, a library to read and write TrueType fonts in Ruby.
+# Copyright (C) 2006  Mathieu Blondel
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+module Font
+module TTF
+module Table
+
+# Cmap is the character to glyph index mapping table.
+class Cmap < Font::TTF::FontChunk
+
+    # Base class for encoding table classes. It provides attributes which are
+    # common to those classes such as platform_id and encoding_id.
+    class EncodingTable < Font::TTF::FontChunk
+
+        attr_accessor :table, :platform_id, :encoding_id, :offset_from_table  
+        
+        def initialize(table, offset=nil, len=nil, platform_id=nil,
+                       encoding_id=nil)
+            @table = table
+            @font = table.font
+            
+            if not offset.nil?
+                @offset_from_table = offset
+                @platform_id = platform_id
+                @encoding_id = encoding_id
+                super(@table.font, @table.offset + offset, len)
+            else
+                super(@table.font)
+            end
+        end
+
+        def unicode?
+            @platform_id == Font::TTF::Encodings::Platform::UNICODE or \
+            (@platform_id == Font::TTF::Encodings::Platform::MICROSOFT and \
+            @encoding_id == Font::TTF::Encodings::MicrosoftEncoding::UNICODE)
+        end
+
+        # Returns the format (a Fixnum) of the encoding table.
+        def format
+            if self.class.superclass == EncodingTable
+                self.class.name.split(//).last.to_i
+            else
+                nil # Not implemented table format
+            end
+        end
+
+    end
+
+    # Encoding table in format 0, the Apple standard character to glyph
+    # mapping table.
+    class EncodingTable0 < EncodingTable
+
+        attr_accessor :version
+        # An array of 256 elements with simple one to one mapping of
+        # character codes to glyph indices.
+        #
+        # Char 0 => Index glyph_id_array[0]
+        # Char 1 => Index glyph_id_array[1]
+        # ...
+        attr_accessor :glyph_id_array
+
+        def initialize(*args) 
+            super(*args)          
+            if exists_in_file?
+                # 2 * IO::SIZEOF_USHORT corresponds to format and len
+                # that we want to skip
+                @table.font.at_offset(@offset + 2 * IO::SIZEOF_USHORT) do
+                    @version = @font.read_ushort
+                    @glyph_id_array = @font.read_bytes(256)
+                end
+            else
+                # This is to ensure that it will be an array
+                @glyph_id_array = []
+            end
+        end
+
+        # Dumps the table in binary raw format as may be found in a font
+        # file.
+        def dump
+            raw = (format || 0).to_ushort
+            len = 3 * IO::SIZEOF_USHORT + 256
+            raw += len.to_ushort
+            raw += (@version || 0).to_ushort
+            raw += @glyph_id_array.to_bytes
+        end
+    end
+
+    # Encoding table in format 2. Not implemented.
+    class EncodingTable2 < EncodingTable
+    end
+
+    # Encoding table in format 4. This format is well-suited to map
+    # several contiguous ranges, possibly with holes of characters.
+    class EncodingTable4 < EncodingTable
+
+        attr_accessor :version
+
+        attr_reader :search_range, :entry_selector, :range_shift, 
+                    :end_count_array, :reserved_pad, :start_count_array, 
+                    :id_delta_array, :id_range_offset_array, 
+                    :glyph_index_array, :segments
+
+        def initialize(*args)
+            super(*args)
+
+            if exists_in_file?                
+                # 2 * IO::SIZEOF_USHORT corresponds to format and len
+                # that we want to skip
+                @table.font.at_offset(@offset + 2 * IO::SIZEOF_USHORT) do
+                    @version = @font.read_ushort
+                    @seg_count_x2 = @font.read_ushort
+                    @seg_count = @seg_count_x2 / 2
+                    @search_range = @font.read_ushort
+                    @entry_selector = @font.read_ushort
+                    @range_shift = @font.read_ushort
+                    @end_count_array = @font.read_ushorts(@seg_count)
+                    @reserved_pad = @font.read_ushort
+                    @start_count_array = @font.read_ushorts(@seg_count)
+                    @id_delta_array = @font.read_ushorts(@seg_count)
+                    @id_range_offset_array = @font.read_ushorts(@seg_count)
+
+                    @nb_glyph_indices = len - 8 * IO::SIZEOF_USHORT \
+                                          - 4 * @seg_count * IO::SIZEOF_USHORT
+                    @nb_glyph_indices /= IO::SIZEOF_USHORT;
+
+                    if @nb_glyph_indices > 0
+                        @glyph_index_array = \
+                            @font.read_ushorts(@nb_glyph_indices)
+                    else
+                        @glyph_index_array = []
+                    end 
+                    
+                    # Keep them in memory so we don't need to
+                    # recalculate them every time
+                    @segments = get_segments
+                end # end at_offset
+            else
+                @segments = []
+                @glyph_index_array = []
+            end
+        end # end initialize
+
+        def get_segments
+            segments = []
+
+            # For each segment...
+            @start_count_array.each_with_index do |start, curr_seg|
+                endd = @end_count_array[curr_seg]
+                delta = @id_delta_array[curr_seg]
+                range = @id_range_offset_array[curr_seg]
+    
+                segments[curr_seg] = {}
+
+                start.upto(endd) do |curr_char|
+                    if range == 0
+                        index = (curr_char + delta)                    
+                    else
+                        gindex = range / 2 + (curr_char - start) - \
+                                (@seg_count - curr_seg)
+                        index = @glyph_index_array[gindex]
+                        index = 0 if index.nil?
+                        index += delta if index != 0
+                    end
+                    index = index % 65536
+                    # charcode => glyph index
+                    segments[curr_seg][curr_char] = index
+                end
+            end
+            segments
+        end
+        private :get_segments
+
+        # Returns a Hash. Its keys are characters codes and associated values
+        # are glyph indices.
+        def charmaps
+            hsh = {}
+            segments.each do |seg| 
+                seg.each do |char_code, glyph_index|
+                    hsh[char_code] = glyph_index
+                end
+            end
+            hsh
+        end
+
+        # Sets the charmaps. cmps is a Hash in the same fashion as the one
+        # returned by charmaps.
+        def charmaps=(cmps)
+            # TODO: we would need fewer segments if we ensured that
+            # glyphs with id in ascending order were associated
+            # with char codes in ascending order
+            raise "Charmaps is an empty array" if cmps.length == 0
+
+            # Order is important since we will rebuild segments           
+            char_codes = cmps.keys.sort
+
+            @start_count_array = []
+            @end_count_array = []
+            @id_delta_array = []
+            curr_seg = 0
+            i = 0
+
+            @start_count_array[0] = char_codes.first
+            @id_delta_array[0] = cmps[char_codes.first] - char_codes.first
+
+            last_char = 0
+            char_codes.each do |char_code|
+                glyph_id = cmps[char_code]
+                curr_delta = glyph_id - char_code                 
+                if i > 0 and curr_delta != @id_delta_array.last
+                    # Need to create a new segment
+                    @end_count_array[curr_seg] = last_char
+                    curr_seg += 1
+                    @start_count_array[curr_seg] = char_code
+                    @id_delta_array[curr_seg] = curr_delta
+                end        
+                last_char = char_code
+                i += 1
+            end
+            seg_count = @start_count_array.length
+            @end_count_array[seg_count - 1] = last_char
+            @id_range_offset_array = [0] * seg_count # Range offsets not used
+            @segments = get_segments # Recalculate segments
+
+            # Values below are calculated
+            # to allow faster computation by font rasterizers
+            res = 1
+            power = 0
+            while res <= seg_count
+                res *= 2
+                power += 1
+            end
+            @search_range = res
+            @entry_selector = power - 1
+            @range_shift = 2 * seg_count - @search_range       
+        end
+
+        # Returns index/id of glyph associated with unicode.
+        def get_glyph_id_for_unicode(unicode)
+            id = 0
+            @segments.length.times do |i|
+                if @start_count_array[i] <= unicode and \
+                   unicode <= @end_count_array[i]
+                    @segments[i].each do |char_code, glyph_id|
+                        if char_code == unicode
+                            id = glyph_id
+                            break
+                        end
+                    end
+                end
+            end
+            id
+        end
+
+        # Returns the Font::TTF::Table::Glyf::SimpleGlyph or 
+        # Font::TTF::Table::Glyf::CompositeGlyph associated with unicode.
+        def get_glyph_for_unicode(unicode)
+            id = get_glyph_id_for_unicode(unicode)
+            offs = @font.get_table(:loca).glyph_offsets[id]
+            @font.get_table(:glyf).get_glyph_at_offset(offs)
+        end
+
+        # Returns the unicode of glyph with index id.
+        def get_unicode_for_glyph_id(id)
+            # TODO: this method could be rewritten much more efficiently
+            # by using @start_count_array and @end_count_array
+            unicode = 0
+            charmaps.each do |char_code, glyph_index|                
+                if glyph_index == id
+                    unicode = char_code 
+                    break
+                end
+            end
+            unicode             
+        end
+    
+        # Dumps the table in binary raw format as may be found in a font
+        # file.
+        def dump
+            raw = (format || 0).to_ushort
+            seg_count = @segments.length || 0
+            len = 8 * IO::SIZEOF_USHORT + 4 * seg_count * IO::SIZEOF_USHORT + \
+                  @glyph_index_array.length * IO::SIZEOF_USHORT
+            raw += len.to_ushort
+            raw += (@version || 0).to_ushort
+            raw += (seg_count * 2).to_ushort
+            raw += (@search_range || 0).to_ushort
+            raw += (@entry_selector || 0).to_ushort
+            raw += (@range_shift || 0).to_ushort
+            raw += (@end_count_array || []).to_ushorts
+            raw += (@reserved_pad || 0).to_ushort
+            raw += (@start_count_array || []).to_ushorts
+            raw += (@id_delta_array || []).to_ushorts
+            raw += (@id_range_offset_array || []).to_ushorts
+            raw += (@glyph_index_array || []).to_ushorts
+        end
+    end
+
+    # Encoding table in format 6. Not implemented.
+    class EncodingTable6 < EncodingTable
+    end
+
+    # Encoding table in format 8. Not implemented.
+    class EncodingTable8 < EncodingTable
+    end
+
+    # Encoding table in format 10. Not implemented.
+    class EncodingTable10 < EncodingTable
+    end
+
+    # Encoding table in format 12. Not implemented.
+    class EncodingTable12 < EncodingTable
+    end
+
+    attr_accessor :version
+    # An Array of encoding_tables. You may add or remove encoding tables
+    # from this array.
+    attr_accessor :encoding_tables
+
+    def initialize(*args)
+        super(*args)
+
+        if exists_in_file?
+            @font.at_offset(@offset) do
+                @version = @font.read_ushort
+                @encoding_table_num = @font.read_ushort
+                @encoding_tables = []
+                @encoding_table_num.times do
+                    platform_id = @font.read_ushort
+                    encoding_id = @font.read_ushort
+                    offset = @font.read_ulong
+                
+                    @font.at_offset(@offset + offset) do
+                        format = @font.read_ushort
+                        len = @font.read_ushort
+
+                        if [0, 2, 4, 6, 8, 10, 12].include? format
+                            klass = eval("EncodingTable%d" % format)
+                        else
+                            klass = EncodingTable
+                        end
+
+                        @encoding_tables << klass.new(self, 
+                                                      offset,
+                                                      len,        
+                                                      platform_id,
+                                                      encoding_id)
+                    end
+                end
+                
+            end        
+        else
+            @encoding_tables = []
+        end
+    end
+
+    # Returns a new empty EncodingTable0 object that you may add to the
+    # encoding_tables array.
+    def get_new_encoding_table0
+        EncodingTable0.new(self)
+    end
+
+    # Returns a new empty EncodingTable4 object that you may add to the
+    # encoding_tables array.
+    def get_new_encoding_table4
+        EncodingTable4.new(self)
+    end
+
+    # Dumps the cmap table in binary raw format as may be found in a font
+    # file.
+    def dump
+        raw = (@version || 0).to_ushort
+        raw += (@encoding_tables.length || 0).to_ushort
+        dumps = []
+        offs = 2 * IO::SIZEOF_USHORT + @encoding_tables.length * \
+                (2 * IO::SIZEOF_USHORT + IO::SIZEOF_ULONG)
+        @encoding_tables.each do |enc_tbl|
+            raw += (enc_tbl.platform_id || 3).to_ushort
+            raw += (enc_tbl.encoding_id || 1).to_ushort
+            dump = enc_tbl.dump
+            dumps << dump
+            raw += offs.to_ulong
+            offs += dump.length
+        end
+        dumps.each do |dump|
+            raw += dump
+        end
+        raw
+    end
+
+end
+
+end
+end
+end