piglop-prawn 0.10.2.1

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

@@ -0,0 +1,79 @@
+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/cmap.rb

@@ -0,0 +1,34 @@
+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/glyf/compound.rb

@@ -0,0 +1,81 @@
+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
+

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

@@ -0,0 +1,37 @@
+require 'ttfunk/reader'
+
+module TTFunk
+  class Table
+    class Glyf
+      class Simple
+        attr_reader :raw
+        attr_reader :number_of_contours
+        attr_reader :x_min, :y_min, :x_max, :y_max
+
+        def initialize(raw, number_of_contours, x_min, y_min, x_max, y_max)
+          @raw = raw
+          @number_of_contours = number_of_contours
+          @x_min, @y_min = x_min, y_min
+          @x_max, @y_max = x_max, y_max
+
+          # Because TTFunk is, at this time, a library for simply pulling
+          # metrics out of font files, or for writing font subsets, we don't
+          # really care what the contours are for simple glyphs. We just
+          # care that we've got an entire glyph's definition. Also, a
+          # bounding box could be nice to know. Since we've got all that
+          # at this point, we don't need to worry about parsing the full
+          # contents of the glyph.
+        end
+
+        def compound?
+          false
+        end
+
+        def recode(mapping)
+          raw
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,64 @@
+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/head.rb

@@ -0,0 +1,44 @@
+require 'ttfunk/table'
+
+module TTFunk  
+  class Table
+    class Head < TTFunk::Table
+      attr_reader :version
+      attr_reader :font_revision
+      attr_reader :checksum_adjustment
+      attr_reader :magic_number
+      attr_reader :flags
+      attr_reader :units_per_em
+      attr_reader :created
+      attr_reader :modified
+      attr_reader :x_min
+      attr_reader :y_min
+      attr_reader :x_max
+      attr_reader :y_max
+      attr_reader :mac_style
+      attr_reader :lowest_rec_ppem
+      attr_reader :font_direction_hint
+      attr_reader :index_to_loc_format
+      attr_reader :glyph_data_format
+
+      def self.encode(head, loca)
+        table = head.raw
+        table[8,4] = "\0\0\0\0" # set checksum adjustment to 0 initially
+        table[-4,2] = [loca[:type]].pack("n") # set index_to_loc_format
+        return table
+      end
+
+      private
+
+        def parse!
+          @version, @font_revision, @check_sum_adjustment, @magic_number,
+            @flags, @units_per_em, @created, @modified = read(36, "N4n2q2")
+      
+          @x_min, @y_min, @x_max, @y_max = read_signed(4)
+      
+          @mac_style, @lowest_rec_ppem, @font_direction_hint,
+            @index_to_loc_format, @glyph_data_format = read(10, "n*")
+        end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'ttfunk/table'
+
+module TTFunk  
+  class Table
+    class Hhea < Table
+      attr_reader :version
+      attr_reader :ascent
+      attr_reader :descent
+      attr_reader :line_gap
+      attr_reader :advance_width_max
+      attr_reader :min_left_side_bearing
+      attr_reader :min_right_side_bearing
+      attr_reader :x_max_extent
+      attr_reader :carot_slope_rise
+      attr_reader :carot_slope_run
+      attr_reader :metric_data_format
+      attr_reader :number_of_metrics
+
+      def self.encode(hhea, hmtx)
+        raw = hhea.raw
+        raw[-2,2] = [hmtx[:number_of_metrics]].pack("n")
+        return raw
+      end
+
+      private
+
+        def parse!
+          @version = read(4, "N").first
+          @ascent, @descent, @line_gap = read_signed(3)
+          @advance_width_max = read(2, "n").first
+
+          @min_left_side_bearing, @min_right_side_bearing, @x_max_extent,
+            @carot_slope_rise, @carot_slope_run, @caret_offset,
+            reserved, reserved, reserved, reserved,
+            @metric_data_format = read_signed(11)
+
+          @number_of_metrics = read(2, "n").first
+        end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'ttfunk/table'
+
+module TTFunk  
+  class Table 
+    class Hmtx < Table
+      attr_reader :metrics
+      attr_reader :left_side_bearings
+      attr_reader :widths
+
+      def self.encode(hmtx, mapping)
+        metrics = mapping.keys.sort.map do |new_id|
+          metric = hmtx.for(mapping[new_id])
+          [metric.advance_width, metric.left_side_bearing]
+        end
+
+        { :number_of_metrics => metrics.length,
+          :table => metrics.flatten.pack("n*") }
+      end
+
+      HorizontalMetric = Struct.new(:advance_width, :left_side_bearing)
+
+      def for(glyph_id)
+        @metrics[glyph_id] ||
+          HorizontalMetric.new(@metrics.last.advance_width,
+            @left_side_bearings[glyph_id - @metrics.length])
+      end
+
+      private
+
+        def parse!
+          @metrics = []
+
+          file.horizontal_header.number_of_metrics.times do
+            advance = read(2, "n").first
+            lsb     = read_signed(1).first
+            @metrics.push HorizontalMetric.new(advance, lsb)
+          end
+
+          lsb_count = file.maximum_profile.num_glyphs - file.horizontal_header.number_of_metrics
+          @left_side_bearings = read_signed(lsb_count)
+
+          @widths = @metrics.map { |metric| metric.advance_width }
+          @widths += [@widths.last] * @left_side_bearings.length
+        end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'ttfunk/reader'
+
+module TTFunk
+  class Table
+    class Kern
+      class Format0
+        include Reader
+
+        attr_reader :attributes
+        attr_reader :pairs
+
+        def initialize(attributes={})
+          @attributes = attributes
+
+          num_pairs, search_range, entry_selector, range_shift, *pairs =
+            attributes.delete(:data).unpack("n*")
+
+          @pairs = {}
+          num_pairs.times do |i|
+            break if i*3+2 > pairs.length # sanity check, in case there's a bad length somewhere
+            left = pairs[i*3]
+            right = pairs[i*3+1]
+            value = to_signed(pairs[i*3+2])
+            @pairs[[left, right]] = value
+          end
+        end
+
+        def vertical?
+          @attributes[:vertical]
+        end
+
+        def horizontal?
+          !vertical?
+        end
+
+        def cross_stream?
+          @attributes[:cross]
+        end
+
+        def recode(mapping)
+          subset = []
+          pairs.each do |(left, right), value|
+            if mapping[left] && mapping[right]
+              subset << [mapping[left], mapping[right], value]
+            end
+          end
+
+          return nil if subset.empty?
+
+          num_pairs = subset.length
+          search_range = 2 * 2 ** (Math.log(num_pairs) / Math.log(2)).to_i
+          entry_selector = (Math.log(search_range / 2) / Math.log(2)).to_i
+          range_shift = (2 * num_pairs) - search_range
+
+          [attributes[:version], num_pairs * 6 + 14, attributes[:coverage],
+            num_pairs, search_range, entry_selector, range_shift, subset].
+            flatten.pack("n*")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'ttfunk/table'
+
+module TTFunk
+  class Table
+    class Kern < Table
+      attr_reader :version
+      attr_reader :tables
+
+      def self.encode(kerning, mapping)
+        return nil unless kerning.exists? && kerning.tables.any?
+        tables = kerning.tables.map { |table| table.recode(mapping) }.compact
+        return nil if tables.empty?
+
+        [0, tables.length, tables.join].pack("nnA*")
+      end
+
+      private
+
+        def parse!
+          @version, num_tables = read(4, "n*")
+          @tables = []
+
+          if @version == 1 # Mac OS X fonts
+            @version = (@version << 16) + num_tables
+            num_tables = read(4, "N").first
+            parse_version_1_tables(num_tables)
+          else
+            parse_version_0_tables(num_tables)
+          end
+        end
+
+        def parse_version_0_tables(num_tables)
+          # It looks like some MS fonts report their kerning subtable lengths
+          # wrong. In one case, the length was reported to be some 19366, and yet
+          # the table also claimed to hold 14148 pairs (each pair consisting of 6 bytes).
+          # You do the math!
+          #
+          # We're going to assume that the microsoft fonts hold only a single kerning
+          # subtable, which occupies the entire length of the kerning table. Worst
+          # case, we lose any other subtables that the font contains, but it's better
+          # than reading a truncated kerning table.
+          #
+          # And what's more, it appears to work. So.
+          version, length, coverage = read(6, "n*")
+          format = coverage >> 8
+
+          add_table format, :version => version, :length => length,
+            :coverage => coverage, :data => raw[10..-1],
+            :vertical => (coverage & 0x1 == 0),
+            :minimum => (coverage & 0x2 != 0),
+            :cross => (coverage & 0x4 != 0),
+            :override => (coverage & 0x8 != 0)
+        end
+
+        def parse_version_1_tables(num_tables)
+          num_tables.times do
+            length, coverage, tuple_index = read(8, "Nnn")
+            format = coverage & 0x0FF
+
+            add_table format, :length => length, :coverage => coverage,
+              :tuple_index => tuple_index, :data => io.read(length-8),
+              :vertical => (coverage & 0x8000 != 0),
+              :cross => (coverage & 0x4000 != 0),
+              :variation => (coverage & 0x2000 != 0)
+          end
+        end
+
+        def add_table(format, attributes={})
+          if format == 0
+            @tables << Kern::Format0.new(attributes)
+          else
+            # silently ignore unsupported kerning tables
+          end
+        end
+    end
+  end
+end
+
+require 'ttfunk/table/kern/format0'

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

@@ -0,0 +1,43 @@
+require 'ttfunk/table'
+
+module TTFunk
+  class Table
+    class Loca < Table
+      attr_reader :offsets
+
+      # Accepts an array of offsets, with each index corresponding to the
+      # glyph id with that index.
+      #
+      # Returns a hash containing:
+      #
+      # * :table - the string representing the table's contents
+      # * :type  - the type of offset (to be encoded in the 'head' table)
+      def self.encode(offsets)
+        if offsets.any? { |ofs| ofs > 0xFFFF }
+          { :type => 1, :table => offsets.pack("N*") }
+        else
+          { :type => 0, :table => offsets.map { |o| o/2 }.pack("n*") }
+        end
+      end
+
+      def index_of(glyph_id)
+        @offsets[glyph_id]
+      end
+
+      def size_of(glyph_id)
+        @offsets[glyph_id+1] - @offsets[glyph_id]
+      end
+
+      private
+
+        def parse!
+          type = file.header.index_to_loc_format == 0 ? "n" : "N"
+          @offsets = read(length, "#{type}*")
+
+          if file.header.index_to_loc_format == 0
+            @offsets.map! { |v| v * 2 }
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'ttfunk/table'
+
+module TTFunk
+  class Table
+    class Maxp < Table
+      attr_reader :version
+      attr_reader :num_glyphs
+      attr_reader :max_points
+      attr_reader :max_contours
+      attr_reader :max_component_points
+      attr_reader :max_component_contours
+      attr_reader :max_zones
+      attr_reader :max_twilight_points
+      attr_reader :max_storage
+      attr_reader :max_function_defs
+      attr_reader :max_instruction_defs
+      attr_reader :max_stack_elements
+      attr_reader :max_size_of_instructions
+      attr_reader :max_component_elements
+      attr_reader :max_component_depth
+
+      def self.encode(maxp, mapping)
+        num_glyphs = mapping.length
+        raw = maxp.raw
+        raw[4,2] = [num_glyphs].pack("n")
+        return raw
+      end
+
+      private
+
+        def parse!
+          @version, @num_glyphs, @max_points, @max_contours, @max_component_points,
+            @max_component_contours, @max_zones, @max_twilight_points, @max_storage,
+            @max_function_defs, @max_instruction_defs, @max_stack_elements,
+            @max_size_of_instructions, @max_component_elements, @max_component_depth =
+              read(length, "Nn*")
+        end
+    end
+  end
+end