glyph_imager 0.0.14 → 0.1.0

data/vendor/ttf-ruby-0.1/lib/ttf/font_loader.rb

@@ -1,290 +0,0 @@
-# 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 TTFFont
-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 TTFFont::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 = TTFFont::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 => TTFFont::TTF::Table::Cmap
-# * :cvt => TTFFont::TTF::Table::Cvt
-# * :fpgm => TTFFont::TTF::Table::Fpgm
-# * :gasp => TTFFont::TTF::Table::Gasp
-# * :glyf => TTFFont::TTF::Table::Glyf
-# * :head => TTFFont::TTF::Table::Head
-# * :hhea => TTFFont::TTF::Table::Hhea
-# * :hmtx => TTFFont::TTF::Table::Hmtx
-# * :kern => TTFFont::TTF::Table::Kern
-# * :loca => TTFFont::TTF::Table::Loca
-# * :maxp => TTFFont::TTF::Table::Maxp
-# * :name => TTFFont::TTF::Table::Name
-# * :"OS/2" => TTFFont::TTF::Table::OS2
-# * :post => TTFFont::TTF::Table::Post
-# * :prep => TTFFont::TTF::Table::Prep
-# * :vhea => TTFFont::TTF::Table::Vhea
-# * :vmtx => TTFFont::TTF::Table::Vmtx
-# 
-# Of course, you may modify attributes and generate a new font file.
-#
-#  require "ttf"
-# 
-#  font = TTFFont::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 FontLoader < File
-
-    TABLES = {:cmap => TTFFont::TTF::Table::Cmap,
-              :cvt => TTFFont::TTF::Table::Cvt,
-              :fpgm => TTFFont::TTF::Table::Fpgm,
-              :gasp => TTFFont::TTF::Table::Gasp,
-              :glyf => TTFFont::TTF::Table::Glyf,
-              :head => TTFFont::TTF::Table::Head,
-              :hhea => TTFFont::TTF::Table::Hhea,
-              :hmtx => TTFFont::TTF::Table::Hmtx,
-              :kern => TTFFont::TTF::Table::Kern,
-              :loca => TTFFont::TTF::Table::Loca,
-              :maxp => TTFFont::TTF::Table::Maxp,
-              :name => TTFFont::TTF::Table::Name,
-              :"OS/2" => TTFFont::TTF::Table::OS2,
-              :post => TTFFont::TTF::Table::Post,
-              :prep => TTFFont::TTF::Table::Prep,
-              :vhea => TTFFont::TTF::Table::Vhea,
-              :vmtx => TTFFont::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
-
-    # TTFFont::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
-    # TTFFont::TTF::Table::* object or a TTFFont::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
-            TTFFont::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
-            TTFFont::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 TTFFont::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 TTFFont::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/ttf-ruby-0.1/lib/ttf/fontchunk.rb

@@ -1,77 +0,0 @@
-# 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 TTFFont
-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 TTFFont::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/ttf-ruby-0.1/lib/ttf/table/cmap.rb

@@ -1,408 +0,0 @@
-# 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 TTFFont
-module TTF
-module Table
-
-# Cmap is the character to glyph index mapping table.
-class Cmap < TTFFont::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 < TTFFont::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 == TTFFont::TTF::Encodings::Platform::UNICODE or \
-            (@platform_id == TTFFont::TTF::Encodings::Platform::MICROSOFT and \
-            @encoding_id == TTFFont::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 TTFFont::TTF::Table::Glyf::SimpleGlyph or 
-        # TTFFont::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