prawn 0.3.0 → 0.4.0

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,46 @@
+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 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

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

@@ -0,0 +1,63 @@
+require 'set'
+require 'ttfunk/subset/base'
+
+module TTFunk
+  module Subset
+    class Unicode8Bit < Base
+      def initialize(original)
+        super
+        @subset = { 0x20 => 0x20 }
+        @unicodes = { 0x20 => 0x20 }
+        @next = 0x21 # apparently, PDF's don't like to use chars between 0-31
+      end
+
+      def unicode?
+        true
+      end
+
+      def to_unicode_map
+        @subset.dup
+      end
+
+      def use(character)
+        if !@unicodes.key?(character)
+          @subset[@next] = character
+          @unicodes[character] = @next
+          @next += 1
+        end
+      end
+
+      def covers?(character)
+        @unicodes.key?(character) || @next < 256
+      end
+
+      def includes?(character)
+        @unicodes.key?(character)
+      end
+
+      def from_unicode(character)
+        @unicodes[character]
+      end
+
+      protected
+
+        def new_cmap_table(options)
+          mapping = @subset.inject({}) do |map, (code,unicode)|
+            map[code] = unicode_cmap[unicode]
+            map
+          end
+
+          # since we're mapping a subset of the unicode glyphs into an
+          # arbitrary 256-character space, the actual encoding we're
+          # using is irrelevant. We choose MacRoman because it's a 256-character
+          # encoding that happens to be well-supported in both TTF and
+          # PDF formats.
+          TTFunk::Table::Cmap.encode(mapping, :mac_roman)
+        end
+
+        def original_glyph_ids
+          ([0] + @unicodes.keys.map { |unicode| unicode_cmap[unicode] }).uniq.sort
+        end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'set'
+require 'ttfunk/subset/base'
+require 'ttfunk/encoding/windows_1252'
+
+module TTFunk
+  module Subset
+    class Windows1252 < Base
+      def initialize(original)
+        super
+        @subset = Array.new(256)
+      end
+
+      def use(character)
+        @subset[Encoding::Windows1252::FROM_UNICODE[character]] = character
+      end
+
+      def covers?(character)
+        Encoding::Windows1252.covers?(character)
+      end
+
+      def includes?(character)
+        code = Encoding::Windows1252::FROM_UNICODE[character]
+        code && @subset[code]
+      end
+
+      def from_unicode(character)
+        Encoding::Windows1252::FROM_UNICODE[character]
+      end
+
+      protected
+
+        def new_cmap_table(options)
+          mapping = {}
+          @subset.each_with_index do |unicode, cp1252|
+            mapping[cp1252] = unicode_cmap[unicode] if cp1252
+          end
+
+          # yes, I really mean "mac roman". TTF has no cp1252 encoding, and the
+          # alternative would be to encode it using a format 4 unicode table, which
+          # is overkill. for our purposes, mac-roman suffices. (If we were building
+          # a _real_ font, instead of a PDF-embeddable subset, things would probably
+          # be different.)
+          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_collection.rb

@@ -0,0 +1,72 @@
+require 'ttfunk/subset'
+
+module TTFunk
+  class SubsetCollection
+    def initialize(original)
+      @original = original
+      @subsets = [Subset.for(@original, :mac_roman)]
+    end
+
+    def [](subset)
+      @subsets[subset]
+    end
+
+    # +characters+ should be an array of UTF-16 characters
+    def use(characters)
+      characters.each do |char|
+        covered = false
+        @subsets.each_with_index do |subset, i|
+          if subset.covers?(char)
+            subset.use(char)
+            covered = true
+            break
+          end
+        end
+
+        if !covered
+          @subsets << Subset.for(@original, :unicode_8bit)
+          @subsets.last.use(char)
+        end
+      end
+    end
+
+    # +characters+ should be an array of UTF-16 characters. Returns
+    # an array of subset chunks, where each chunk is another array of
+    # two elements. The first element is the subset number, and the
+    # second element is the string of characters to render with that
+    # font subset. The strings will be encoded for their subset font,
+    # and so may not look (in the raw) like what was passed in, but
+    # they will render correctly with the indicated subset font.
+    def encode(characters)
+      return [] if characters.empty?
+
+      # TODO: probably would be more optimal to nix the #use method,
+      # and merge it into this one, so it can be done in a single
+      # pass instead of two passes.
+      use(characters)
+
+      parts = []
+      current_subset = 0
+      current_char = 0
+      char = characters[current_char]
+
+      loop do
+        while @subsets[current_subset].includes?(char)
+          char = @subsets[current_subset].from_unicode(char)
+
+          if parts.empty? || parts.last[0] != current_subset
+            parts << [current_subset, char.chr]
+          else
+            parts.last[1] << char
+          end
+
+          current_char += 1
+          return parts if current_char >= characters.length
+          char = characters[current_char]
+        end
+
+        current_subset = (current_subset + 1) % @subsets.length
+      end
+    end
+  end
+end