prawn 0.1.0

data/vendor/font_ttf/ttf/table/cvt.rb

@@ -0,0 +1,49 @@
+# TTF/Ruby, a library to read and write TrueType fonts in Ruby.
+# Copyright (C) 2006  Mathieu Blondel
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+module Font
+module TTF
+module Table
+
+# Cvt is the Control Value table. It references values that can be
+# referenced by instructions (used for hinting, aka grid-fitting).
+class Cvt < Font::TTF::FontChunk
+
+    attr_accessor :instructions
+
+    def initialize(*args)
+        super(*args)
+
+        if exists_in_file?
+            @font.at_offset(@offset) do
+                n = @len / IO::SIZEOF_FWORD
+                @instructions = @font.read_fwords(n)
+            end
+        end
+    end
+
+    # Dumps the cvt table in binary raw format as may be found in a font
+    # file.
+    def dump
+        (@instructions || []).to_fwords
+    end
+    
+end
+
+end
+end
+end

data/vendor/font_ttf/ttf/table/fpgm.rb

@@ -0,0 +1,48 @@
+# TTF/Ruby, a library to read and write TrueType fonts in Ruby.
+# Copyright (C) 2006  Mathieu Blondel
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+module Font
+module TTF
+module Table
+
+# Fpgm is the Font Program table. It is similar to the Cvt table except
+# it is only run once, when the font is first used.
+class Fpgm < Font::TTF::FontChunk
+
+    attr_accessor :instructions
+
+    def initialize(*args)
+        super(*args)
+
+        if exists_in_file?
+            @font.at_offset(@offset) do
+                @instructions = @font.read_bytes(@len)
+            end
+        end
+    end
+
+    # Dumps the fpgm table in binary raw format as may be found in a font
+    # file.
+    def dump
+        (@instructions || []).to_bytes
+    end
+    
+end
+
+end
+end
+end

data/vendor/font_ttf/ttf/table/gasp.rb

@@ -0,0 +1,88 @@
+# TTF/Ruby, a library to read and write TrueType fonts in Ruby.
+# Copyright (C) 2006  Mathieu Blondel
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+module Font
+module TTF
+module Table
+
+# Gasp is the Grid-fitting and scan conversion procedure table.
+class Gasp < Font::TTF::FontChunk
+
+    class GaspRange < Font::TTF::FontChunk
+
+        SIZEOF_GASP_RANGE = 2 * IO::SIZEOF_USHORT
+
+        attr_accessor :range_max_ppem, :range_gasp_behavior
+
+        def initialize(table, n=nil)
+            if n.nil?
+                # when object is created by hand
+                super(table.font)
+            else
+                offs = table.offset + 2 * IO::SIZEOF_USHORT + \
+                       n * SIZEOF_GASP_RANGE
+                super(table.font, offs, SIZEOF_GASP_RANGE)
+
+                table.font.at_offset(@offset) do
+                    @range_max_ppem = table.font.read_ushort
+                    @range_gasp_behavior = table.font.read_ushort
+                end
+            end
+        end
+
+        def dump
+            raw = (@range_max_ppem || 0).to_ushort
+            raw += (@range_gasp_behavior || 0).to_ushort
+        end
+
+    end
+
+    attr_accessor :version
+    # An Array of GaspRange objects.
+    attr_accessor :gasp_ranges
+
+    def initialize(*args)
+        super(*args)
+
+        if exists_in_file?
+            @font.at_offset(@offset) do
+                @version = @font.read_ushort
+                @num_ranges = @font.read_ushort
+                @gasp_ranges = []
+                @num_ranges.times do |i|
+                    @gasp_ranges << GaspRange.new(self, i)
+                end
+            end
+        end
+    end
+
+    # Dumps the gasp table in binary raw format as may be found in a font
+    # file.
+    def dump
+        raw = (@version || 0).to_ushort
+        raw += (@gasp_ranges || []).length.to_ushort
+        @gasp_ranges.each do |gr|
+            raw += gr.dump
+        end
+        raw
+    end
+    
+end
+
+end
+end
+end

data/vendor/font_ttf/ttf/table/glyf.rb

@@ -0,0 +1,452 @@
+# TTF/Ruby, a library to read and write TrueType fonts in Ruby.
+# Copyright (C) 2006  Mathieu Blondel
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+module Font
+module TTF
+module Table
+
+# Glyf is the Glyph data table.
+class Glyf < Font::TTF::FontChunk
+
+    # Base class for SimpleGlyph and CompositeGlyph.
+    class Glyph < Font::TTF::FontChunk
+
+        attr_accessor :num_contours, :x_min, :y_min, :x_max, :y_max
+
+        def initialize(table, offset=nil)
+            @table = table
+            @offset_from_table = offset
+            super(@table.font, @table.offset + @offset_from_table)
+
+            if exists_in_file?
+                @font.at_offset(@offset) do
+                    @num_contours = @font.read_short
+                    @x_min = @font.read_fword
+                    @y_min = @font.read_fword
+                    @x_max = @font.read_fword
+                    @y_max = @font.read_fword
+                end
+            end
+        end
+
+        def dump
+            raw = (@num_contours || 0).to_short
+            raw += (@x_min || 0).to_fword
+            raw += (@y_min || 0).to_fword
+            raw += (@x_max || 0).to_fword
+            raw += (@y_max || 0).to_fword 
+        end
+
+        # Returns whether the glyph is composite or not.
+        def composite?
+            self.class == CompositeGlyph
+        end
+
+        # Returns whether is simple (i.e. not composite) or not.
+        def simple?
+            self.class == SimpleGlyph
+        end
+
+    end
+
+    # SimpleGlyph class.
+    class SimpleGlyph < Glyph
+
+        Point = Struct.new(:rel_x, :abs_x, :rel_y, :abs_y, 
+                          :end_of_contour, :on_curve)
+
+        # Point is helper class which gives information on a point
+        # such as it absolute (abs_x, abs_y) and relative (rel_x, rel_y)
+        # coordinates
+        class Point
+            # Whether the point is end of contour or not.
+            alias :end_of_contour? :end_of_contour
+            # Whether the point is on curve or not.
+            alias :on_curve? :on_curve
+
+            # Whether the point is off curve or not.
+            def off_curve?
+                not on_curve?
+            end
+        end
+
+        FLAG_ON_CURVE = 0b1
+        FLAG_X_SHORT_VECTOR = 0b10
+        FLAG_Y_SHORT_VECTOR = 0b100
+        FLAG_REPEAT = 0b1000
+        FLAG_X_IS_SAME = 0b10000
+        FLAG_Y_IS_SAME = 0b100000
+
+        attr_accessor :end_pts_of_contours, :instructions, :flags,
+                      :x_coordinates, :y_coordinates
+
+        def initialize(*args)
+            super(*args)
+            
+            if exists_in_file?
+                offs = @offset + IO::SIZEOF_SHORT + 4 * IO::SIZEOF_FWORD
+                @font.at_offset(offs) do
+                    @end_pts_of_contours = @font.read_ushorts(@num_contours)
+                    instruction_len = @font.read_ushort
+                    @instructions = @font.read_bytes(instruction_len)
+                    unless @end_pts_of_contours.empty?
+                        num_points = @end_pts_of_contours.last + 1
+                    else
+                        num_points = 0
+                    end
+                    @flags = []
+                    while @flags.length < num_points
+                        flag = @font.read_byte
+                        @flags << flag
+                        if flag & FLAG_REPEAT != 0
+                            @font.read_byte.times do
+                                @flags << flag
+                            end
+                        end
+                    end
+                    @x_coordinates = []
+                    @y_coordinates = []
+                    [[@x_coordinates, FLAG_X_SHORT_VECTOR, FLAG_X_IS_SAME],
+                     [@y_coordinates, FLAG_Y_SHORT_VECTOR, FLAG_Y_IS_SAME]
+                    ].each do |coordinates, short, same|
+                        num_points.times do |i|
+                            flag = @flags[i]
+                            if flag & short != 0
+                                # if the coordinate is a BYTE
+                                if flag & same != 0
+                                    coordinates << @font.read_byte
+                                else
+                                    coordinates << -@font.read_byte
+                                end
+                            else
+                                # the coordinate is a SHORT
+                                if flag & same != 0
+                                    # same so 0 (relative coordinates)
+                                    coordinates << 0
+                                else
+                                    coordinates << @font.read_short
+                                end
+                            end
+                        end
+                    end
+                    @len = @font.pos - @offset
+                end
+            end
+
+        end
+        
+        # Returns an Array of [x,y] pairs of relative coordinates.
+        def rel_coordinates
+            coords = []
+            @x_coordinates.length.times do |i|
+                coords << [@x_coordinates[i], @y_coordinates[i]]
+            end
+            coords
+        end
+
+        # Returns an Array of [x,y] pairs of absolute coordinates.
+        def abs_coordinates
+            abs_x = 0
+            abs_y = 0
+            coords = []
+            rel_coordinates.each do |rel_x, rel_y|
+                abs_x += rel_x
+                abs_y += rel_y
+                coords << [abs_x, abs_y]
+            end
+            coords
+        end
+
+        # Returns an Array of Point objects.
+        def points
+            x_abs = 0
+            y_abs = 0
+            pnts = []
+            @x_coordinates.length.times do |i|
+                pnt = Point.new
+                pnt.rel_x = @x_coordinates[i]
+                pnt.rel_y = @y_coordinates[i]
+                x_abs += pnt.rel_x
+                y_abs += pnt.rel_y
+                pnt.abs_x = x_abs
+                pnt.abs_y = y_abs
+                pnt.end_of_contour = @end_pts_of_contours.include? i
+                pnt.on_curve = (@flags[i] & FLAG_ON_CURVE != 0)
+                pnts << pnt
+            end
+            pnts
+        end
+
+        def dump
+            raw = super
+            raw += @end_pts_of_contours.to_ushorts
+            raw += @instructions.length.to_ushort
+            raw += @instructions.to_bytes
+
+            tmp = ""
+            [[@x_coordinates, FLAG_X_SHORT_VECTOR, FLAG_X_IS_SAME],
+                [@y_coordinates, FLAG_Y_SHORT_VECTOR, FLAG_Y_IS_SAME]
+            ].each do |coordinates, short, same|
+                coordinates.each_with_index do |coord, i|
+                    if 0 <= coord and coord <= 255
+                        @flags[i] = (@flags[i] | short) | same
+                        tmp += coord.to_byte
+                    elsif -255 <= coord and coord < 0
+                        @flags[i] = (@flags[i] | short) & ~same
+                        tmp += (-coord).to_byte
+                    elsif coord == 0
+                        @flags[i] = (@flags[i] & ~short) | same
+                    else
+                        @flags[i] = (@flags[i] & ~short) & ~same
+                        tmp += coord.to_short
+                    end
+                end
+            end
+
+            # We write all flags rather than using the flag_repeat trick
+            # So we unset the "repeat" bit for all flags
+            # TODO: implement the repeat feature (this saves space)
+            raw += @flags.collect { |f| f & ~FLAG_REPEAT }.to_bytes
+
+            raw += tmp
+        end
+    end
+
+    # CompositeGlyph class.
+    class CompositeGlyph < Glyph
+
+        GlyphComponent = Struct.new(:flags, :index, :args, :scale,
+                                    :xscale, :yscale, :scale01, :scale10)
+
+        ARG_1_AND_2_ARE_WORDS = 0b1
+        ARGS_ARE_XY_VALUES = 0b10
+        ROUND_XY_TO_GRID = 0b100
+        WE_HAVE_A_SCALE = 0b1000
+        RESERVED = 0b10000
+        MORE_COMPONENTS = 0b100000
+        WE_HAVE_AN_X_AND_Y_SCALE = 0b1000000
+        WE_HAVE_A_TWO_BY_TWO = 0b10000000
+        WE_HAVE_INSTRUCTIONS = 0b100000000
+        USE_MY_METRICS = 0b1000000000
+
+        # An Array of GlyphComponent objects
+        attr_accessor :components
+        # An Array of instructions (Fixnums)
+        attr_accessor :instructions
+
+        def initialize(*args)
+            super(*args)
+            
+            if exists_in_file?
+                offs = @offset + IO::SIZEOF_SHORT + 4 * IO::SIZEOF_FWORD
+                @font.at_offset(offs) do
+                    @components = []
+                    continue = true
+                    while continue
+                        gc = GlyphComponent.new
+                        gc.flags = @font.read_ushort
+                        gc.index = @font.read_ushort
+    
+                        gc.args = []
+                        if gc.flags & ARG_1_AND_2_ARE_WORDS != 0
+                            gc.args[0] = @font.read_short
+                            gc.args[1] = @font.read_short
+                        else
+                            gc.args[0] = @font.read_ushort
+                        end
+    
+                        if gc.flags & WE_HAVE_A_SCALE != 0
+                            gc.scale = @font.read_f2dot14
+                        elsif gc.flags & WE_HAVE_AN_X_AND_Y_SCALE != 0
+                            gc.xscale = @font.read_f2dot14
+                            gc.yscale = @font.read_f2dot14
+                        elsif gc.flags & WE_HAVE_A_TWO_BY_TWO != 0
+                            gc.xscale  = @font.read_f2dot14
+                            gc.scale01 = @font.read_f2dot14
+                            gc.scale10 = @font.read_f2dot14
+                            gc.yscale = @font.read_f2dot14
+                        end
+                        @components << gc
+                        continue = (gc.flags & MORE_COMPONENTS != 0)
+                    end
+
+                    if @components.last.flags & \
+                       WE_HAVE_INSTRUCTIONS != 0
+                        inst_len = @font.read_ushort
+                        @instructions = @font.read_bytes(inst_len)
+                    else
+                        @instructions = []
+                    end
+
+                    @len = @font.pos - @offset
+                end
+            end
+        end
+
+        def dump
+            raw = super
+            components_len = @components.length
+            @components.each_with_index do |gc, i|
+                flags = gc.flags
+                tmp = ""
+                if not gc.args.nil? and gc.args.length == 2
+                    flags |= ARG_1_AND_2_ARE_WORDS 
+                    tmp += gc.args[0].to_short
+                    tmp += gc.args[1].to_short
+                else
+                    flags &= ~ARG_1_AND_2_ARE_WORDS
+                    tmp += gc.args[0].to_ushort
+                end
+                if not gc.scale.nil?
+                    flags |= WE_HAVE_A_SCALE
+                    tmp += gc.scale.to_f2dot14
+                elsif not gc.scale01.nil?
+                    flags |= WE_HAVE_A_TWO_BY_TWO
+                    tmp += gc.xscale.to_f2dot14
+                    tmp += gc.scale01.to_f2dot14
+                    tmp += gc.scale10.to_f2dot14
+                    tmp += gc.yscale.to_f2dot14
+                elsif not gc.xscale.nil?
+                    flags |= WE_HAVE_AN_X_AND_Y_SCALE
+                    tmp += gc.xscale.to_f2dot14
+                    tmp += gc.yscale.to_f2dot14
+                end
+
+                if i < components_len - 1
+                    flags |= MORE_COMPONENTS
+                else
+                    flags &= ~MORE_COMPONENTS
+                    if @instructions.length > 0
+                        flags |= WE_HAVE_INSTRUCTIONS
+                    else
+                        flags &= ~WE_HAVE_INSTRUCTIONS
+                    end
+                end
+                raw += flags.to_ushort
+                raw += gc.index.to_ushort
+                raw += tmp
+            end
+            unless @instructions.empty?
+                raw += @instructions.length.to_ushort
+                raw += @instructions.to_bytes
+            end
+            raw
+        end
+    end
+
+    attr_accessor :glyphs
+
+    def initialize(*args)
+        super(*args)
+    end
+
+    # Returns the kind of glyph at offset, i.e. either SimpleGlyph
+    # or CompositeGlyph.
+    def kind_of_glyph_at_offset(offs_from_table)
+        @font.at_offset(@offset + offs_from_table) do
+            num_contours = @font.read_short
+            if num_contours >= 0
+                SimpleGlyph
+            else
+                CompositeGlyph
+            end
+        end
+    end
+
+    def get_glyph_at_offset(offs_from_table)
+        klass = kind_of_glyph_at_offset(offs_from_table)
+        klass.new(self, offs_from_table)
+    end
+
+    def get_glyphs
+        loca = @font.get_table(:loca)
+        glyphs = []
+        loca.glyph_offsets[0...-1].each do |off|
+            glyphs << get_glyph_at_offset(off)
+        end
+        glyphs
+    end
+    private :get_glyphs
+
+    # Returns all Glyph (SimpleGlyph or CompositeGlyph) in an Array.
+    # This method may be real overkill if you just need to access a few glyphs.
+    # In this case, you should use the loca table (Font::TTF::Table::Loca)
+    # to get offsets and get_glyph_at_offset to get glyph associated with them.
+    def glyphs
+        @glyphs ||= get_glyphs
+    end
+
+    # Sets glyphs. new_glyphs is an Array of Glyph objects.
+    def glyphs=(new_glyphs)
+        @glyphs = new_glyphs
+        @font.get_table(:maxp).num_glyphs = @glyphs.length
+        @font.get_table(:post).num_glyphs = @glyphs.length
+    end
+
+    # Iterates over each glyph.
+    # It does not load all glyphs like glyphs.each would do.
+    def each_glyph
+        loca = @font.get_table(:loca)
+        glyphs = []
+        loca.glyph_offsets[0...-1].each do |off|
+            glyph = get_glyph_at_offset(off)
+            yield glyph
+        end
+    end
+
+    # Dumps the glyf table in binary raw format as may be found in a font
+    # file.
+    def dump
+        raw = ""
+        offs = 0
+        glyph_offsets = []
+        glyphs.each do |glyph|            
+            glyph_offsets << offs
+            dump = glyph.dump
+            len = dump.length
+            raw += dump
+            # offsets should be multiples of SIZEOF_ULONG
+            diff = len % IO::SIZEOF_ULONG
+            raw += " " * diff
+            offs += len + diff
+        end
+        # An additional offset is added so that the length of the last
+        # glyph can be calculated: 
+        # len of last glyph = additional offs - last glyph offs
+        glyph_offsets << offs        
+
+        # 2 ** 16 * 2 = 131072 is the maximum size supported
+        # if the short format is used in the loca table
+        # Using shorts saves two bytes per glyph!
+        if offs < 131072
+            @font.get_table(:head).index_to_loc_format = \
+                Font::TTF::Table::Head::SHORT_FORMAT
+        else
+            @font.get_table(:head).index_to_loc_format = \
+                Font::TTF::Table::Head::LONG_FORMAT
+        end
+
+        @font.get_table(:loca).glyph_offsets = glyph_offsets
+
+        raw
+    end
+   
+end
+
+end
+end
+end