glyph_imager 0.0.14 → 0.1.0

data/vendor/ttfunk/lib/ttfunk/encoding/windows_1252.rb

@@ -0,0 +1,69 @@
+module TTFunk
+  module Encoding
+    class Windows1252
+      TO_UNICODE = Hash[*(0..255).zip(0..255).flatten]
+      TO_UNICODE.update(
+        0x80 => 0x20AC, 0x82 => 0x201A, 0x83 => 0x0192, 0x84 => 0x201E, 0x85 => 0x2026,
+        0x86 => 0x2020, 0x87 => 0x2021, 0x88 => 0x02C6, 0x89 => 0x2030, 0x8A => 0x0160,
+        0x8B => 0x2039, 0x8C => 0x0152, 0x8E => 0x017D, 0x91 => 0x2018, 0x92 => 0x2019,
+        0x93 => 0x201C, 0x94 => 0x201D, 0x95 => 0x2022, 0x96 => 0x2013, 0x97 => 0x2014,
+        0x98 => 0x02DC, 0x99 => 0x2122, 0x9A => 0x0161, 0x9B => 0x203A, 0x9C => 0x0152,
+        0x9E => 0x017E, 0x9F => 0x0178
+      )
+
+      FROM_UNICODE = {}
+      (0..255).each { |key| FROM_UNICODE[TO_UNICODE[key]] = key }
+
+      # Maps Windows-1252 codes to their corresponding index in the Postscript glyph
+      # table (see TTFunk::Table::Post::Format10). If any entry in this array is a string,
+      # it is a postscript glyph that is not in the standard list, and which should be
+      # emitted specially in the TTF postscript table ('post', see format 2).
+      POSTSCRIPT_GLYPH_MAPPING = [
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+          3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,
+         19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,
+         35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,
+         51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,
+         67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,
+         83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,   0,
+     "Euro",   0, 196, 166, 197, 171, 130, 194, 216, 198, 228, 190, 176,   0, 230,   0,
+          0, 182, 183, 180, 181, 135, 178, 179, 217, 140, 229, 191, 177,   0, 231, 186,
+          3, 163, 132, 133, 189, 150, 232, 134, 142, 139, 157, 169, 164,  16, 138, 218,
+        131, 147, 242, 243, 141, 151, 136, 195, 222, 241, 158, 170, 245, 244, 246, 162,
+        173, 201, 199, 174,  98,  99, 144, 100, 203, 101, 200, 202, 207, 204, 205, 206,
+        233, 102, 211, 208, 209, 175, 103, 240, 145, 214, 212, 213, 104, 235, 237, 137,
+        106, 105, 107, 109, 108, 110, 160, 111, 113, 112, 114, 115, 117, 116, 118, 119,
+        234, 120, 122, 121, 123, 125, 124, 184, 161, 127, 126, 128, 129, 236, 238, 186
+      ]
+
+      def self.covers?(character)
+        !FROM_UNICODE[character].nil?
+      end
+
+      def self.to_utf8(string)
+        to_unicode_codepoints(string.unpack("C*")).pack("U*")
+      end
+
+      def self.to_unicode(string)
+        to_unicode_codepoints(string.unpack("C*")).pack("n*")
+      end
+
+      def self.from_utf8(string)
+        from_unicode_codepoints(string.unpack("U*")).pack("C*")
+      end
+
+      def self.from_unicode(string)
+        from_unicode_codepoints(string.unpack("n*")).pack("C*")
+      end
+
+      def self.to_unicode_codepoints(array)
+        array.map { |code| TO_UNICODE[code] }
+      end
+
+      def self.from_unicode_codepoints(array)
+        array.map { |code| FROM_UNICODE[code] || 0 }
+      end
+    end
+  end
+end

data/vendor/ttfunk/lib/ttfunk/reader.rb

@@ -0,0 +1,44 @@
+module TTFunk
+  module Reader
+    private
+
+      def io
+        @file.contents
+      end
+
+      def read(bytes, format)
+        io.read(bytes).unpack(format)
+      end
+
+      def read_signed(count)
+        read(count*2, "n*").map { |i| to_signed(i) }
+      end
+
+      def to_signed(n)
+        (n>=0x8000) ? -((n ^ 0xFFFF) + 1) : n
+      end
+
+      def parse_from(position)
+        saved, io.pos = io.pos, position
+        result = yield position
+        io.pos = saved
+        return result
+      end
+
+      # For debugging purposes
+      def hexdump(string)
+        bytes = string.unpack("C*")
+        bytes.each_with_index do |c, i|
+          print "%02X" % c
+          if (i+1) % 16 == 0
+            puts
+          elsif (i+1) % 8 == 0
+            print "  "
+          else
+            print " "
+          end
+        end
+        puts unless bytes.length % 16 == 0
+      end
+  end
+end

data/vendor/ttfunk/lib/ttfunk/resource_file.rb

@@ -0,0 +1,78 @@
+module TTFunk
+  class ResourceFile
+    attr_reader :map
+
+    def self.open(path)
+      ::File.open(path, "rb") do |io|
+        file = new(io)
+        yield file
+      end
+    end
+
+    def initialize(io)
+      @io = io
+
+      data_offset, map_offset, data_length, map_length = @io.read(16).unpack("N*")
+
+      @map = {}
+      @io.pos = map_offset + 24 # skip header copy, next map handle, file reference, and attrs
+      type_list_offset, name_list_offset = @io.read(4).unpack("n*")
+
+      type_list_offset += map_offset
+      name_list_offset += map_offset
+
+      @io.pos = type_list_offset
+      max_index = @io.read(2).unpack("n").first
+      0.upto(max_index) do
+        type, max_type_index, ref_list_offset = @io.read(8).unpack("A4nn")
+        @map[type] = { :list => [], :named => {} }
+
+        parse_from(type_list_offset + ref_list_offset) do
+          0.upto(max_type_index) do
+            id, name_ofs, attr = @io.read(5).unpack("nnC")
+            data_ofs = @io.read(3)
+            data_ofs = data_offset + [0, data_ofs].pack("CA*").unpack("N").first
+            handle = @io.read(4).unpack("N").first
+
+            entry = { :id => id, :attributes => attr, :offset => data_ofs, :handle => handle }
+
+            if name_list_offset + name_ofs < map_offset + map_length
+              parse_from(name_ofs + name_list_offset) do
+                len = @io.read(1).unpack("C").first
+                entry[:name] = @io.read(len)
+              end
+            end
+
+            @map[type][:list] << entry
+            @map[type][:named][entry[:name]] = entry if entry[:name]
+          end
+        end
+      end
+    end
+
+    def [](type, index=0)
+      if @map[type]
+        collection = index.is_a?(Fixnum) ? :list : :named
+        if @map[type][collection][index]
+          parse_from(@map[type][collection][index][:offset]) do
+            length = @io.read(4).unpack("N").first
+            return @io.read(length)
+          end
+        end
+      end
+    end
+
+    def resources_for(type)
+      (@map[type] && @map[type][:named] || {}).keys
+    end
+
+    private
+
+      def parse_from(offset)
+        saved, @io.pos = @io.pos, offset
+        yield
+      ensure
+        @io.pos = saved
+      end
+  end
+end

data/vendor/ttfunk/lib/ttfunk/subset.rb

@@ -0,0 +1,18 @@
+require 'ttfunk/subset/unicode'
+require 'ttfunk/subset/unicode_8bit'
+require 'ttfunk/subset/mac_roman'
+require 'ttfunk/subset/windows_1252'
+
+module TTFunk
+  module Subset
+    def self.for(original, encoding)
+      case encoding.to_sym
+        when :unicode      then Unicode.new(original)
+        when :unicode_8bit then Unicode8Bit.new(original)
+        when :mac_roman    then MacRoman.new(original)
+        when :windows_1252 then Windows1252.new(original)
+        else raise NotImplementedError, "encoding #{encoding} is not supported"
+      end
+    end
+  end
+end

data/vendor/ttfunk/lib/ttfunk/subset/base.rb

@@ -0,0 +1,141 @@
+require 'ttfunk/table/cmap'
+require 'ttfunk/table/glyf'
+require 'ttfunk/table/head'
+require 'ttfunk/table/hhea'
+require 'ttfunk/table/hmtx'
+require 'ttfunk/table/kern'
+require 'ttfunk/table/loca'
+require 'ttfunk/table/maxp'
+require 'ttfunk/table/name'
+require 'ttfunk/table/post'
+require 'ttfunk/table/simple'
+
+module TTFunk
+  module Subset
+    class Base
+      attr_reader :original
+
+      def initialize(original)
+        @original = original
+      end
+
+      def unicode?
+        false
+      end
+
+      def to_unicode_map
+        {}
+      end
+
+      def encode(options={})
+        cmap_table = new_cmap_table(options)
+        glyphs = collect_glyphs(original_glyph_ids)
+
+        old2new_glyph = cmap_table[:charmap].inject({ 0 => 0 }) { |map, (code, ids)| map[ids[:old]] = ids[:new]; map }
+        next_glyph_id = cmap_table[:max_glyph_id]
+
+        glyphs.keys.each do |old_id|
+          unless old2new_glyph.key?(old_id) 
+            old2new_glyph[old_id] = next_glyph_id
+            next_glyph_id += 1
+          end
+        end
+
+        new2old_glyph = old2new_glyph.invert
+
+        # "mandatory" tables. Every font should ("should") have these, including
+        # the cmap table (encoded above).
+        glyf_table = TTFunk::Table::Glyf.encode(glyphs, new2old_glyph, old2new_glyph)
+        loca_table = TTFunk::Table::Loca.encode(glyf_table[:offsets])
+        hmtx_table = TTFunk::Table::Hmtx.encode(original.horizontal_metrics, new2old_glyph)
+        hhea_table = TTFunk::Table::Hhea.encode(original.horizontal_header, hmtx_table)
+        maxp_table = TTFunk::Table::Maxp.encode(original.maximum_profile, old2new_glyph)
+        post_table = TTFunk::Table::Post.encode(original.postscript, new2old_glyph)
+        name_table = TTFunk::Table::Name.encode(original.name)
+        head_table = TTFunk::Table::Head.encode(original.header, loca_table)
+
+        # "optional" tables. Fonts may omit these if they do not need them. Because they
+        # apply globally, we can simply copy them over, without modification, if they
+        # exist.
+        os2_table  = original.os2.raw
+        cvt_table  = TTFunk::Table::Simple.new(original, "cvt ").raw
+        fpgm_table = TTFunk::Table::Simple.new(original, "fpgm").raw
+        prep_table = TTFunk::Table::Simple.new(original, "prep").raw
+
+        # for PDF's, the kerning info is all included in the PDF as the text is
+        # drawn. Thus, the PDF readers do not actually use the kerning info in
+        # embedded fonts. If the library is used for something else, the generated
+        # subfont may need a kerning table... in that case, you need to opt into it.
+        if options[:kerning]
+          kern_table = TTFunk::Table::Kern.encode(original.kerning, old2new_glyph)
+        end
+
+        tables = { 'cmap' => cmap_table[:table],
+                   'glyf' => glyf_table[:table],
+                   'loca' => loca_table[:table],
+                   'kern' => kern_table,
+                   'hmtx' => hmtx_table[:table],
+                   'hhea' => hhea_table,
+                   'maxp' => maxp_table,
+                   'OS/2' => os2_table,
+                   'post' => post_table,
+                   'name' => name_table,
+                   'head' => head_table,
+                   'prep' => prep_table,
+                   'fpgm' => fpgm_table,
+                   'cvt ' => cvt_table }
+
+        tables.delete_if { |tag, table| table.nil? }
+
+        search_range = (Math.log(tables.length) / Math.log(2)).to_i * 16
+        entry_selector = (Math.log(search_range) / Math.log(2)).to_i
+        range_shift = tables.length * 16 - search_range
+
+        newfont = [original.directory.scaler_type, tables.length, search_range, entry_selector, range_shift].pack("Nn*")
+
+        directory_size = tables.length * 16
+        offset = newfont.length + directory_size
+
+        table_data = ""
+        head_offset = nil
+        tables.each do |tag, data|
+          newfont << [tag, checksum(data), offset, data.length].pack("A4N*")
+          table_data << data
+          head_offset = offset if tag == 'head'
+          offset += data.length
+          while offset % 4 != 0
+            offset += 1
+            table_data << "\0"
+          end
+        end
+
+        newfont << table_data
+        sum = checksum(newfont)
+        adjustment = 0xB1B0AFBA - sum
+        newfont[head_offset+8,4] = [adjustment].pack("N")
+
+        return newfont
+      end
+
+      private
+
+        def unicode_cmap
+          @unicode_cmap ||= @original.cmap.unicode.first
+        end
+
+        def checksum(data)
+          data += "\0" * (4 - data.length % 4) unless data.length % 4 == 0
+          data.unpack("N*").inject(0) { |sum, dword| sum + dword } & 0xFFFF_FFFF
+        end
+
+        def collect_glyphs(glyph_ids)
+          glyphs = glyph_ids.inject({}) { |h, id| h[id] = original.glyph_outlines.for(id); h }
+          additional_ids = glyphs.values.select { |g| g && g.compound? }.map { |g| g.glyph_ids }.flatten
+
+          glyphs.update(collect_glyphs(additional_ids)) if additional_ids.any?
+
+          return glyphs
+        end
+    end
+  end
+end

data/vendor/ttfunk/lib/ttfunk/subset/mac_roman.rb

@@ -0,0 +1,50 @@
+require 'set'
+require 'ttfunk/subset/base'
+require 'ttfunk/encoding/mac_roman'
+
+module TTFunk
+  module Subset
+    class MacRoman < Base
+      def initialize(original)
+        super
+        @subset = Array.new(256)
+      end
+
+      def to_unicode_map
+        Encoding::MacRoman::TO_UNICODE
+      end
+
+      def use(character)
+        @subset[Encoding::MacRoman::FROM_UNICODE[character]] = character
+      end
+
+      def covers?(character)
+        Encoding::MacRoman.covers?(character)
+      end
+
+      def includes?(character)
+        code = Encoding::MacRoman::FROM_UNICODE[character]
+        code && @subset[code]
+      end
+
+      def from_unicode(character)
+        Encoding::MacRoman::FROM_UNICODE[character]
+      end
+
+      protected
+
+        def new_cmap_table(options)
+          mapping = {}
+          @subset.each_with_index do |unicode, roman|
+            mapping[roman] = unicode_cmap[unicode] if roman
+          end
+
+          TTFunk::Table::Cmap.encode(mapping, :mac_roman)
+        end
+
+        def original_glyph_ids
+          ([0] + @subset.map { |unicode| unicode && unicode_cmap[unicode] }).compact.uniq.sort
+        end
+    end
+  end
+end

data/vendor/ttfunk/lib/ttfunk/subset/unicode.rb

@@ -0,0 +1,48 @@
+require 'set'
+require 'ttfunk/subset/base'
+
+module TTFunk
+  module Subset
+    class Unicode < Base
+      def initialize(original)
+        super
+        @subset = Set.new
+      end
+
+      def unicode?
+        true
+      end
+
+      def to_unicode_map
+        @subset.inject({}) { |map, code| map[code] = code; map }
+      end
+
+      def use(character)
+        @subset << character
+      end
+
+      def covers?(character)
+        true
+      end
+
+      def includes?(character)
+        @subset.includes(character)
+      end
+
+      def from_unicode(character)
+        character
+      end
+
+      protected
+
+        def new_cmap_table(options)
+          mapping = @subset.inject({}) { |map, code| map[code] = unicode_cmap[code]; map }
+          TTFunk::Table::Cmap.encode(mapping, :unicode)
+        end
+
+        def original_glyph_ids
+          ([0] + @subset.map { |code| unicode_cmap[code] }).uniq.sort
+        end
+    end
+  end
+end