prawn-graph 0.0.2 → 0.0.3

data/vendor/prawn-core/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/prawn-core/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/prawn-core/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
-

data/vendor/prawn-core/vendor/ttfunk/lib/ttfunk/table/glyf/simple.rb

@@ -1,37 +0,0 @@
-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/prawn-core/vendor/ttfunk/lib/ttfunk/table/head.rb

@@ -1,44 +0,0 @@
-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/prawn-core/vendor/ttfunk/lib/ttfunk/table/hhea.rb

@@ -1,41 +0,0 @@
-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/prawn-core/vendor/ttfunk/lib/ttfunk/table/hmtx.rb

@@ -1,47 +0,0 @@
-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/prawn-core/vendor/ttfunk/lib/ttfunk/table/kern.rb

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