glyph_imager 0.0.3

data/vendor/ttf-ruby-0.1/lib/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/ttf-ruby-0.1/lib/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