prawn 0.4.1 → 0.5.0.1

data/vendor/ttfunk/lib/ttfunk/table.rb

@@ -1,46 +0,0 @@
-require 'ttfunk/reader'
-
-module TTFunk
-  class Table
-    include Reader
-
-    attr_reader :file
-    attr_reader :offset
-    attr_reader :length
-
-    def initialize(file)
-      @file = file
-
-      info = file.directory_info(tag)
-
-      if info
-        @offset = info[:offset]
-        @length = info[:length]
-
-        parse_from(@offset) { parse! }
-      end
-    end
-
-    def exists?
-      !@offset.nil?
-    end
-
-    def raw
-      if exists?
-        parse_from(offset) { io.read(length) }
-      else
-        nil
-      end
-    end
-
-    def tag
-      self.class.name.split(/::/).last.downcase
-    end
-
-    private
-
-      def parse!
-        # do nothing, by default
-      end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/table/cmap.rb

@@ -1,34 +0,0 @@
-module TTFunk  
-  class Table
-    class Cmap < Table
-      attr_reader :version
-      attr_reader :tables
-
-      def self.encode(charmap, encoding)
-        result = Cmap::Subtable.encode(charmap, encoding)
-
-        # pack 'version' and 'table-count'
-        result[:table] = [0, 1, result.delete(:subtable)].pack("nnA*")
-        return result
-      end
-
-      def unicode
-        @unicode ||= @tables.select { |table| table.unicode? }
-      end
-
-      private
-
-        def parse!
-          @version, table_count = read(4, "nn")
-          @tables = []
-
-          table_count.times do
-            @tables << Cmap::Subtable.new(file, offset)
-          end
-        end
-    end
-    
-  end
-end
-
-require 'ttfunk/table/cmap/subtable'

data/vendor/ttfunk/lib/ttfunk/table/cmap/format00.rb

@@ -1,54 +0,0 @@
-require 'ttfunk/encoding/mac_roman'
-require 'ttfunk/encoding/windows_1252'
-
-module TTFunk
-  class Table
-    class Cmap
-
-      module Format00
-        attr_reader :language
-        attr_reader :code_map
-
-        # Expects a hash mapping character codes to glyph ids (where the
-        # glyph ids are from the original font). Returns a hash including
-        # a new map (:charmap) that maps the characters in charmap to a
-        # another hash containing both the old (:old) and new (:new) glyph
-        # ids. The returned hash also includes a :subtable key, which contains
-        # the encoded subtable for the given charmap.
-        def self.encode(charmap)
-          next_id = 0 
-          glyph_indexes = Array.new(256, 0)
-          glyph_map = { 0 => 0 }
-
-          new_map = charmap.keys.sort.inject({}) do |map, code|
-            glyph_map[charmap[code]] ||= next_id += 1
-            map[code] = { :old => charmap[code], :new => glyph_map[charmap[code]] }
-            glyph_indexes[code] = glyph_map[charmap[code]]
-            map
-          end
-
-          # format, length, language, indices
-          subtable = [0, 262, 0, *glyph_indexes].pack("nnnC*")
-
-          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
-        end
-
-        def [](code)
-          @code_map[code] || 0
-        end
-
-        def supported?
-          true
-        end
-
-        private
-
-          def parse_cmap!
-            length, @language = read(4, "nn")
-            @code_map = read(256, "C*")
-          end
-      end
-
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/table/cmap/format04.rb

@@ -1,126 +0,0 @@
-module TTFunk
-  class Table
-    class Cmap
-
-      module Format04
-        attr_reader :language
-        attr_reader :code_map
-
-        # Expects a hash mapping character codes to glyph ids (where the
-        # glyph ids are from the original font). Returns a hash including
-        # a new map (:charmap) that maps the characters in charmap to a
-        # another hash containing both the old (:old) and new (:new) glyph
-        # ids. The returned hash also includes a :subtable key, which contains
-        # the encoded subtable for the given charmap.
-        def self.encode(charmap)
-          end_codes = []
-          start_codes = []
-          next_id = 0
-          last = difference = nil
-
-          glyph_map = { 0 => 0 }
-          new_map = charmap.keys.sort.inject({}) do |map, code|
-            old = charmap[code]
-            glyph_map[old] ||= next_id += 1
-            map[code] = { :old => old, :new => glyph_map[old] }
-
-            delta = glyph_map[old] - code
-            if last.nil? || delta != difference
-              end_codes << last if last
-              start_codes << code
-              difference = delta
-            end
-            last = code
-
-            map
-          end
-
-          end_codes << last if last
-          end_codes << 0xFFFF
-          start_codes << 0xFFFF
-          segcount = start_codes.length
-
-          # build the conversion tables
-          deltas = []
-          range_offsets = []
-          glyph_indices = []
-
-          offset = 0
-          start_codes.zip(end_codes).each_with_index do |(a, b), segment|
-            if a == 0xFFFF
-              deltas << 0
-              range_offsets << 0
-              break
-            end
-
-            start_glyph_id = new_map[a][:new]
-            if a - start_glyph_id >= 0x8000
-              deltas << 0
-              range_offsets << 2 * (glyph_indices.length + segcount - segment)
-              a.upto(b) { |code| glyph_indices << new_map[code][:new] }
-            else
-              deltas << -a + start_glyph_id
-              range_offsets << 0
-            end
-            offset += 2
-          end
-
-          # format, length, language
-          subtable = [4, 16 + 8 * segcount + 2 * glyph_indices.length, 0].pack("nnn")
-
-          search_range = 2 * 2 ** (Math.log(segcount) / Math.log(2)).to_i
-          entry_selector = (Math.log(search_range / 2) / Math.log(2)).to_i
-          range_shift = (2 * segcount) - search_range
-          subtable << [segcount * 2, search_range, entry_selector, range_shift].pack("nnnn")
-
-          subtable << end_codes.pack("n*") << "\0\0" << start_codes.pack("n*")
-          subtable << deltas.pack("n*") << range_offsets.pack("n*") << glyph_indices.pack("n*")
-
-          { :charmap => new_map, :subtable => subtable, :max_glyph_id => next_id+1 }
-        end
-
-        def [](code)
-          @code_map[code] || 0
-        end
-
-        def supported?
-          true
-        end
-
-        private
-
-          def parse_cmap!
-            length, @language, segcount_x2 = read(6, "nnn")
-            segcount = segcount_x2 / 2
-
-            io.read(6) # skip searching hints
-
-            end_code = read(segcount_x2, "n*")
-            io.read(2) # skip reserved value
-            start_code = read(segcount_x2, "n*")
-            id_delta = read_signed(segcount)
-            id_range_offset = read(segcount_x2, "n*")
-
-            glyph_ids = read(length - io.pos + @offset, "n*")
-
-            @code_map = {}
-
-            end_code.each_with_index do |tail, i|
-              start_code[i].upto(tail) do |code|
-                if id_range_offset[i].zero?
-                  glyph_id = code + id_delta[i]
-                else
-                  index = id_range_offset[i] / 2 + (code - start_code[i]) - (segcount - i)
-                  glyph_id = glyph_ids[index] || 0 # because some TTF fonts are broken
-                  glyph_id += id_delta[i] if glyph_id != 0
-                end
-
-                @code_map[code] = glyph_id & 0xFFFF
-              end
-            end
-          end
-      end
-
-    end
-  end
-end

data/vendor/ttfunk/lib/ttfunk/table/cmap/subtable.rb

@@ -1,79 +0,0 @@
-require 'ttfunk/reader'
-
-module TTFunk
-  class Table
-    class Cmap
-      class Subtable
-        include Reader
-
-        attr_reader :platform_id
-        attr_reader :encoding_id
-        attr_reader :format
-
-        ENCODING_MAPPINGS = {
-          :mac_roman    => { :platform_id => 1, :encoding_id => 0 },
-          # use microsoft unicode, instead of generic unicode, for optimal windows support
-          :unicode      => { :platform_id => 3, :encoding_id => 1 }
-        }
-
-        def self.encode(charmap, encoding)
-          case encoding
-          when :mac_roman
-            result = Format00.encode(charmap)
-          when :unicode
-            result = Format04.encode(charmap)
-          else
-            raise NotImplementedError, "encoding #{encoding.inspect} is not supported"
-          end
-
-          mapping = ENCODING_MAPPINGS[encoding]
-
-          # platform-id, encoding-id, offset
-          result[:subtable] = [mapping[:platform_id], mapping[:encoding_id],
-            12, result[:subtable]].pack("nnNA*")
-
-          return result
-        end
-
-        def initialize(file, table_start)
-          @file = file
-          @platform_id, @encoding_id, @offset = read(8, "nnN")
-          @offset += table_start
-
-          parse_from(@offset) do
-            @format = read(2, "n").first
-
-            case @format
-              when 0 then extend(TTFunk::Table::Cmap::Format00)
-              when 4 then extend(TTFunk::Table::Cmap::Format04)
-            end
-
-            parse_cmap!
-          end
-        end
-
-        def unicode?
-          platform_id == 3 && encoding_id == 1 && format == 4 ||
-          platform_id == 0 && format == 4
-        end
-
-        def supported?
-          false
-        end
-
-        def [](code)
-          raise NotImplementedError, "cmap format #{@format} is not supported"
-        end
-
-        private
-
-          def parse_cmap!
-            # do nothing...
-          end
-      end
-    end
-  end
-end
-
-require 'ttfunk/table/cmap/format00'
-require 'ttfunk/table/cmap/format04'

data/vendor/ttfunk/lib/ttfunk/table/glyf.rb

@@ -1,64 +0,0 @@
-require 'ttfunk/table'
-
-module TTFunk
-  class Table
-    class Glyf < Table
-      # Accepts a hash mapping (old) glyph-ids to glyph objects, and a hash
-      # mapping old glyph-ids to new glyph-ids.
-      #
-      # Returns a hash containing:
-      # 
-      # * :table - a string representing the encoded 'glyf' table containing
-      #   the given glyphs.
-      # * :offsets - an array of offsets for each glyph
-      def self.encode(glyphs, new2old, old2new)
-        result = { :table => "", :offsets => [] }
-
-        new2old.keys.sort.each do |new_id|
-          glyph = glyphs[new2old[new_id]]
-          result[:offsets] << result[:table].length
-          result[:table] << glyph.recode(old2new) if glyph
-        end
-
-        # include an offset at the end of the table, for use in computing the
-        # size of the last glyph
-        result[:offsets] << result[:table].length
-        return result
-      end
-
-      def for(glyph_id)
-        return @cache[glyph_id] if @cache.key?(glyph_id)
-
-        index = file.glyph_locations.index_of(glyph_id)
-        size  = file.glyph_locations.size_of(glyph_id)
-
-        if size.zero? # blank glyph, e.g. space character
-          @cache[glyph_id] = nil
-          return nil
-        end
-
-        parse_from(offset + index) do
-          raw = io.read(size)
-          number_of_contours, x_min, y_min, x_max, y_max = raw.unpack("n5").map { |i| to_signed(i) }
-
-          @cache[glyph_id] = if number_of_contours == -1
-              Compound.new(raw, x_min, y_min, x_max, y_max)
-            else
-              Simple.new(raw, number_of_contours, x_min, y_min, x_max, y_max)
-            end
-        end
-      end
-
-      private
-
-        def parse!
-          # because the glyf table is rather complex to parse, we defer
-          # the parse until we need a specific glyf, and then cache it.
-          @cache = {}
-        end
-    end
-  end
-end
-
-require 'ttfunk/table/glyf/compound'
-require 'ttfunk/table/glyf/simple'

data/vendor/ttfunk/lib/ttfunk/table/glyf/compound.rb

@@ -1,81 +0,0 @@
-require 'ttfunk/reader'
-
-module TTFunk
-  class Table
-    class Glyf
-      class Compound
-        include Reader
-
-        ARG_1_AND_2_ARE_WORDS    = 0x0001
-        WE_HAVE_A_SCALE          = 0x0008
-        MORE_COMPONENTS          = 0x0020
-        WE_HAVE_AN_X_AND_Y_SCALE = 0x0040
-        WE_HAVE_A_TWO_BY_TWO     = 0x0080
-        WE_HAVE_INSTRUCTIONS     = 0x0100
-
-        attr_reader :raw
-        attr_reader :x_min, :y_min, :x_max, :y_max
-        attr_reader :glyph_ids
-
-        Component = Struct.new(:flags, :glyph_index, :arg1, :arg2, :transform)
-
-        def initialize(raw, x_min, y_min, x_max, y_max)
-          @raw = raw
-          @x_min, @y_min, @x_max, @y_max = x_min, y_min, x_max, y_max
-
-          # Because TTFunk only cares about glyphs insofar as they (1) provide
-          # a bounding box for each glyph, and (2) can be rewritten into a
-          # font subset, we don't really care about the rest of the glyph data
-          # except as a whole. Thus, we don't actually decompose the glyph
-          # into it's parts--all we really care about are the locations within
-          # the raw string where the component glyph ids are stored, so that
-          # when we rewrite this glyph into a subset we can rewrite the
-          # component glyph-ids so they are correct for the subset.
-
-          @glyph_ids = []
-          @glyph_id_offsets = []
-          offset = 10 # 2 bytes for each of num-contours, min x/y, max x/y
-
-          loop do
-            flags, glyph_id = @raw[offset, 4].unpack("n*")
-            @glyph_ids << glyph_id
-            @glyph_id_offsets << offset + 2
-
-            break unless flags & MORE_COMPONENTS != 0
-            offset += 4
-
-            if flags & ARG_1_AND_2_ARE_WORDS != 0
-              offset += 4
-            else
-              offset += 2
-            end
-
-            if flags & WE_HAVE_A_TWO_BY_TWO != 0
-              offset += 8
-            elsif flags & WE_HAVE_AN_X_AND_Y_SCALE != 0
-              offset += 4
-            elsif flags & WE_HAVE_A_SCALE != 0
-              offset += 2
-            end
-          end
-        end
-
-        def compound?
-          true
-        end
-
-        def recode(mapping)
-          result = @raw.dup
-          new_ids = glyph_ids.map { |id| mapping[id] }
-
-          new_ids.zip(@glyph_id_offsets).each do |new_id, offset|
-            result[offset, 2] = [new_id].pack("n")
-          end
-
-          return result
-        end
-      end
-    end
-  end
-end
-