prawn 0.4.1 → 0.5.0.1

data/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/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/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/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/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'

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

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

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

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

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

@@ -1,119 +0,0 @@
-require 'ttfunk/table'
-
-module TTFunk
-  class Table
-    class Name < Table
-      class String < ::String
-        attr_reader :platform_id
-        attr_reader :encoding_id
-        attr_reader :language_id
-
-        def initialize(text, platform_id, encoding_id, language_id)
-          super(text)
-          @platform_id = platform_id
-          @encoding_id = encoding_id
-          @language_id = language_id
-        end
-      end
-
-      attr_reader :strings
-
-      attr_reader :copyright
-      attr_reader :font_family
-      attr_reader :font_subfamily
-      attr_reader :unique_subfamily
-      attr_reader :font_name
-      attr_reader :version
-      attr_reader :trademark
-      attr_reader :manufacturer
-      attr_reader :designer
-      attr_reader :description
-      attr_reader :vendor_url
-      attr_reader :designer_url
-      attr_reader :license
-      attr_reader :license_url
-      attr_reader :preferred_family
-      attr_reader :preferred_subfamily
-      attr_reader :compatible_full
-      attr_reader :sample_text
-
-      @@subset_tag = "AAAAAA"
-
-      def self.encode(names)
-        tag = @@subset_tag.dup
-        @@subset_tag.succ!
-
-        postscript_name = Name::String.new("#{tag}+#{names.postscript_name}", 1, 0, 0)
-
-        strings = names.strings.dup
-        strings[6] = [postscript_name]
-        str_count = strings.inject(0) { |sum, (id, list)| sum + list.length }
-
-        table = [0, str_count, 6 + 12 * str_count].pack("n*")
-        strtable = ""
-
-        strings.each do |id, list|
-          list.each do |string|
-            table << [string.platform_id, string.encoding_id, string.language_id, id, string.length, strtable.length].pack("n*")
-            strtable << string
-          end
-        end
-
-        table << strtable
-      end
-
-      def postscript_name
-        return @postscript_name if @postscript_name
-        font_family.first || "unnamed"
-      end
-
-      private
-
-        def parse!
-          format, count, string_offset = read(6, "n*")
-
-          entries = []
-          count.times do
-            platform, encoding, language, id, length, start_offset = read(12, "n*")
-            entries << {
-              :platform_id => platform,
-              :encoding_id => encoding,
-              :language_id => language,
-              :name_id => id,
-              :length => length,
-              :offset => offset + string_offset + start_offset
-            }
-          end
-
-          @strings = Hash.new { |h,k| h[k] = [] }
-
-          count.times do |i|
-            io.pos = entries[i][:offset]
-            text = io.read(entries[i][:length])
-            @strings[entries[i][:name_id]] << Name::String.new(text,
-              entries[i][:platform_id], entries[i][:encoding_id], entries[i][:language_id])
-          end
-
-          @copyright = @strings[0]
-          @font_family = @strings[1]
-          @font_subfamily = @strings[2]
-          @unique_subfamily = @strings[3]
-          @font_name = @strings[4]
-          @version = @strings[5]
-          @postscript_name = @strings[6].first # should only be ONE postscript name
-          @trademark = @strings[7]
-          @manufacturer = @strings[8]
-          @designer = @strings[9]
-          @description = @strings[10]
-          @vendor_url = @strings[11]
-          @designer_url = @strings[12]
-          @license = @strings[13]
-          @license_url = @strings[14]
-          @preferred_family = @strings[15]
-          @preferred_subfamily = @strings[17]
-          @compatible_full = @strings[18]
-          @sample_text = @strings[19]
-        end
-    end
-  end
-end