prawn-svg 0.9.1.8 → 0.9.1.9

data/README

@@ -28,15 +28,18 @@ prawn-svg is in its infancy and does not support the full SVG specifications.  I
   supports moveto, closepath, lineto, horiz lineto, vert lineto, curveto, smooth curveto, quad curveto, smooth quad curveto
   does not support elliptical arc
 
-- text tag
-  attributes: size, text-anchor
-  partially supported attributes: font-family
+- text and tspan tags
+  attributes: size, text-anchor, font-family, font-weight, dx, dy
+  
+- svg, g and symbol tags
+  
+- use tag
   
 - style tag, if css_parser gem is installed on the system [1]
   
 - attributes/styles: fill, stroke, stroke-width, opacity, fill-opacity, stroke-opacity, transform
 
-- transform methods: translate, rotate, scale
+- transform methods: translate, rotate, scale, matrix
 
 - colors: html standard names, #xxx, #xxxxxx, rgb(1, 2, 3), rgb(1%, 2%, 3%)
 
@@ -49,6 +52,6 @@ Mac OS X and Debian Linux users.  You can add to the font path:
 
   Prawn::Svg.font_path << "/my/font/directory"
 
-prawn-svg does NOT support named elements, external references, the tspan tag, gradients/patterns or markers.
+prawn-svg does NOT support external references, gradients/patterns or markers.
 
 [1] If the css_parser gem is installed, it will handle CSS style definitions, but only simple tag, class or id definitions.

data/lib/prawn-svg.rb

@@ -1,7 +1,11 @@
 require 'prawn'
 require 'prawn/svg/extension'
 require 'prawn/svg/interface'
+require 'prawn/svg/font'
+require 'prawn/svg/document'
+require 'prawn/svg/element'
 require 'prawn/svg/parser'
 require 'prawn/svg/parser/path'
+require 'prawn/svg/parser/text'
 
 Prawn::Document.extensions << Prawn::Svg::Extension

data/lib/prawn/svg/document.rb

@@ -0,0 +1,81 @@
+class Prawn::Svg::Document
+  include Prawn::Measurements
+
+  begin
+    require 'css_parser'
+    CSS_PARSER_LOADED = true
+  rescue LoadError
+    CSS_PARSER_LOADED = false
+  end    
+  
+  DEFAULT_WIDTH  = 640
+  DEFAULT_HEIGHT = 480
+  
+  # An +Array+ of warnings that occurred while parsing the SVG data.
+  attr_reader :warnings
+
+  # The scaling factor, as determined by the :width or :height options.
+  attr_accessor :scale
+
+  attr_reader :root,
+    :actual_width, :actual_height, :width, :height, :x_offset, :y_offset,
+    :css_parser
+    
+  def initialize(data, bounds, options)
+    @css_parser = CssParser::Parser.new if CSS_PARSER_LOADED
+
+    @root = REXML::Document.new(data).root
+    @warnings = []
+    @options = options
+    @actual_width, @actual_height = bounds # set this first so % width/heights can be used
+
+    if vb = @root.attributes['viewBox']
+      x1, y1, x2, y2 = vb.strip.split(/\s+/)
+      @x_offset, @y_offset = [x1.to_f, y1.to_f]
+      @actual_width, @actual_height = [x2.to_f - x1.to_f, y2.to_f - y1.to_f]
+    else
+      @x_offset, @y_offset = [0, 0]
+      @actual_width = points(@root.attributes['width'] || DEFAULT_WIDTH, :x)
+      @actual_height = points(@root.attributes['height'] || DEFAULT_HEIGHT, :y)
+    end
+    
+    if @options[:width]
+      @width = @options[:width]      
+      @scale = @options[:width] / @actual_width.to_f
+    elsif @options[:height]
+      @height = @options[:height]
+      @scale = @options[:height] / @actual_height.to_f
+    else
+      @scale = 1
+    end
+
+    @width ||= @actual_width * @scale
+    @height ||= @actual_height * @scale    
+  end
+  
+  def x(value)
+    (points(value, :x) - @x_offset) * scale
+  end
+
+  def y(value)
+    (@actual_height - (points(value, :y) - @y_offset)) * scale
+  end
+
+  def distance(value, axis = nil)
+    value && (points(value, axis) * scale)
+  end
+
+  def points(value, axis = nil)
+    if value.is_a?(String)
+      if match = value.match(/\d(cm|dm|ft|in|m|mm|yd)$/)
+        send("#{match[1]}2pt", value.to_f)
+      elsif value[-1..-1] == "%"
+        value.to_f * (axis == :y ? @actual_height : @actual_width) / 100.0
+      else
+        value.to_f
+      end
+    else
+      value.to_f
+    end
+  end
+end

data/lib/prawn/svg/element.rb

@@ -0,0 +1,220 @@
+class Prawn::Svg::Element
+  attr_reader :document, :element, :parent_calls, :base_calls, :state, :attributes
+  attr_accessor :calls
+  
+  def initialize(document, element, parent_calls, state)
+    @document = document
+    @element = element
+    @parent_calls = parent_calls
+    @state = state
+    @base_calls = @calls = []
+    
+    combine_attributes_and_style_declarations
+    apply_styles
+    
+    if id = @attributes["id"]
+      state[:ids][id] = @base_calls
+    end
+  end
+  
+  def name
+    @name ||= element.name
+  end
+  
+  def each_child_element
+    element.elements.each do |e|
+      yield self.class.new(@document, e, @calls, @state.dup)
+    end
+  end
+  
+  def warnings
+    @document.warnings
+  end
+  
+  def add_call(name, *arguments)
+    @calls << [name.to_s, arguments, []]
+  end
+  
+  def add_call_and_enter(name, *arguments)
+    @calls << [name.to_s, arguments, []]
+    @calls = @calls.last.last
+  end  
+  
+  def append_calls_to_parent
+    @parent_calls.concat(@base_calls)
+  end
+  
+  
+  protected
+  def apply_styles
+    # Transform
+    if transform = @attributes['transform']
+      parse_css_method_calls(transform).each do |name, arguments|
+        case name
+        when 'translate'
+          x, y = arguments
+          x, y = x.split(/\s+/) if y.nil?
+          add_call_and_enter name, @document.distance(x), -@document.distance(y)
+
+        when 'rotate'          
+          add_call_and_enter name, -arguments.first.to_f, :origin => [0, @document.y('0')]
+
+        when 'scale'
+          args = arguments.first.split(/\s+/)
+          x_scale = args[0].to_f
+          y_scale = (args[1] || x_scale).to_f
+          add_call_and_enter "transformation_matrix", x_scale, 0, 0, y_scale, 0, 0
+
+        when 'matrix'
+          args = arguments.first.split(/\s+/)
+          if args.length != 6
+            @document.warnings << "transform 'matrix' must have six arguments"
+          else
+            a, b, c, d, e, f = args.collect {|a| a.to_f}
+            add_call_and_enter "transformation_matrix", a, b, c, d, @document.distance(e), -@document.distance(f)
+          end
+        else
+          @document.warnings << "Unknown transformation '#{name}'; ignoring"
+        end
+      end
+    end    
+        
+    # Opacity:
+    # We can't do nested opacities quite like the SVG requires, but this is close enough.
+    fill_opacity = stroke_opacity = clamp(@attributes['opacity'].to_f, 0, 1) if @attributes['opacity']
+    fill_opacity = clamp(@attributes['fill-opacity'].to_f, 0, 1) if @attributes['fill-opacity']
+    stroke_opacity = clamp(@attributes['stroke-opacity'].to_f, 0, 1) if @attributes['stroke-opacity']
+
+    if fill_opacity || stroke_opacity      
+      state[:fill_opacity] = (state[:fill_opacity] || 1) * (fill_opacity || 1)
+      state[:stroke_opacity] = (state[:stroke_opacity] || 1) * (stroke_opacity || 1)
+
+      add_call_and_enter 'transparent', state[:fill_opacity], state[:stroke_opacity]
+    end
+
+    # Fill and stroke
+    draw_types = []  
+    [:fill, :stroke].each do |type|
+      dec = @attributes[type.to_s]
+      if dec == "none"
+        state[type] = false
+      elsif dec
+        state[type] = true
+        if color = color_to_hex(dec)
+          add_call "#{type}_color", color
+        end
+      end
+
+      draw_types << type.to_s if state[type]
+    end
+    
+    # Stroke width
+    add_call('line_width', @document.distance(@attributes['stroke-width'])) if @attributes['stroke-width']      
+
+    # Fonts        
+    if size = @attributes['font-size']
+      @state[:font_size] = size.to_f * @document.scale
+    end
+    if weight = @attributes['font-weight']
+      font_updated = true
+      @state[:font_style] = weight == 'bold' ? :bold : nil
+    end
+    if (family = @attributes['font-family']) && family.strip != ""
+      font_updated = true
+      @state[:font_family] = family
+    end
+    
+    if @state[:font_family] && font_updated
+      if pdf_font = Prawn::Svg::Font.map_font_family_to_pdf_font(@state[:font_family], @state[:font_style])
+        add_call_and_enter 'font', pdf_font
+      else
+        @document.warnings << "Font family '#{@state[:font_family]}' style '#{@state[:font_style] || 'normal'}' is not a known font."
+      end
+    end    
+    
+    # Call fill, stroke, or both
+    draw_type = draw_types.join("_and_")
+    if draw_type != "" && !Prawn::Svg::Parser::CONTAINER_TAGS.include?(element.name)
+      add_call_and_enter draw_type
+    end            
+  end
+
+  def parse_css_method_calls(string)
+    string.scan(/\s*(\w+)\(([^)]+)\)\s*/).collect do |call|
+      name, argument_string = call
+      arguments = argument_string.split(",").collect {|s| s.strip}
+      [name, arguments]
+    end    
+  end
+
+  # TODO : use http://www.w3.org/TR/SVG11/types.html#ColorKeywords
+  HTML_COLORS = {    
+  	'black' => "000000", 'green' => "008000", 'silver' => "c0c0c0", 'lime' => "00ff00",
+  	'gray' => "808080", 'olive' => "808000", 'white' => "ffffff", 'yellow' => "ffff00",
+  	'maroon' => "800000", 'navy' => "000080", 'red' => "ff0000", 'blue' => "0000ff",
+  	'purple' => "800080", 'teal' => "008080", 'fuchsia' => "ff00ff", 'aqua' => "00ffff"
+  }.freeze
+
+  RGB_VALUE_REGEXP = "\s*(-?[0-9.]+%?)\s*"
+  RGB_REGEXP = /\Argb\(#{RGB_VALUE_REGEXP},#{RGB_VALUE_REGEXP},#{RGB_VALUE_REGEXP}\)\z/i
+
+  def color_to_hex(color_string)
+    color_string.scan(/([^(\s]+(\([^)]*\))?)/).detect do |color, *_|
+      if m = color.match(/\A#([0-9a-f])([0-9a-f])([0-9a-f])\z/i)
+        break "#{m[1] * 2}#{m[2] * 2}#{m[3] * 2}"
+      elsif color.match(/\A#[0-9a-f]{6}\z/i)
+        break color[1..6]
+      elsif hex = HTML_COLORS[color.downcase]
+        break hex
+      elsif m = color.match(RGB_REGEXP)
+        break (1..3).collect do |n|
+          value = m[n].to_f
+          value *= 2.55 if m[n][-1..-1] == '%'
+          "%02x" % clamp(value.round, 0, 255)
+        end.join        
+      end    
+    end
+  end
+
+  def clamp(value, min_value, max_value)
+    [[value, min_value].max, max_value].min
+  end  
+      
+  def combine_attributes_and_style_declarations
+    if @document && @document.css_parser
+      tag_style = @document.css_parser.find_by_selector(element.name)
+      id_style = @document.css_parser.find_by_selector("##{element.attributes["id"]}") if element.attributes["id"]
+  
+      if classes = element.attributes["class"]
+        class_styles = classes.strip.split(/\s+/).collect do |class_name|
+          @document.css_parser.find_by_selector(".#{class_name}")
+        end
+      end
+  
+      element_style = element.attributes['style']
+
+      style = [tag_style, class_styles, id_style, element_style].flatten.collect do |s|
+        s.nil? || s.strip == "" ? "" : "#{s}#{";" unless s.match(/;\s*\z/)}"
+      end.join
+    else
+      style = element.attributes['style'] || ""
+    end
+
+    @attributes = parse_css_declarations(style)
+    element.attributes.each {|n,v| @attributes[n] = v unless @attributes[n]}
+  end    
+
+  def parse_css_declarations(declarations)
+    # copied from css_parser
+    declarations.gsub!(/(^[\s]*)|([\s]*$)/, '')
+
+    output = {}
+    declarations.split(/[\;$]+/m).each do |decs|
+      if matches = decs.match(/\s*(.[^:]*)\s*\:\s*(.[^;]*)\s*(;|\Z)/i)
+        property, value, end_of_declaration = matches.captures
+        output[property] = value
+      end
+    end
+    output
+  end
+end

data/lib/prawn/svg/extension.rb

@@ -17,7 +17,7 @@ module Prawn
       def svg(data, options={})
         svg = Prawn::Svg::Interface.new(data, self, options)
         svg.draw
-        {:warnings => svg.parser_warnings, :width => svg.parser.width, :height => svg.parser.height}
+        {:warnings => svg.document.warnings, :width => svg.document.width, :height => svg.document.height}
       end  
     end
   end

data/lib/prawn/svg/font.rb

@@ -0,0 +1,100 @@
+require 'iconv'
+
+class Prawn::Svg::Font
+  BUILT_IN_FONTS = ["Courier", "Helvetica", "Times-Roman", "Symbol", "ZapfDingbats"]
+
+  GENERIC_CSS_FONT_MAPPING = {
+    "serif"      => "Times-Roman",
+    "sans-serif" => "Helvetica",
+    "cursive"    => "Times-Roman",
+    "fantasy"    => "Times-Roman",
+    "monospace"  => "Courier"}
+    
+  def self.map_font_family_to_pdf_font(font_family, font_style = nil)
+    font_family.split(",").detect do |font|
+      font = font.gsub(/['"]/, '').gsub(/\s{2,}/, ' ').strip.downcase
+
+      built_in_font = BUILT_IN_FONTS.detect {|f| f.downcase == font}
+      break built_in_font if built_in_font
+
+      generic_font = GENERIC_CSS_FONT_MAPPING[font]
+      break generic_font if generic_font
+      
+      break font.downcase if font_installed?(font, font_style)
+    end
+  end
+  
+  def self.font_path(font_family, font_style = nil)
+    font_style = :normal if font_style.nil?
+    if installed_styles = installed_fonts[font_family.downcase]
+      installed_styles[font_style]
+    end
+  end
+  
+  def self.font_installed?(font_family, font_style = nil)
+    !font_path(font_family, font_style).nil?
+  end
+
+  def self.installed_fonts
+    return @installed_fonts if @installed_fonts
+    
+    fonts = {}
+    Prawn::Svg::Interface.font_path.uniq.collect {|path| Dir["#{path}/*"]}.flatten.each do |filename|
+      information = font_information(filename) rescue nil
+      if information && font_name = information[1]
+        font_style = case information[2]
+        when 'Bold' then :bold
+        when 'Italic' then :italic
+        when 'Bold Italic' then :bold_italic
+        else :normal
+        end
+        
+        (fonts[font_name.downcase] ||= {})[font_style] = filename
+      end
+    end
+    
+    @installed_fonts = fonts
+  end
+    
+  def self.font_information(filename)
+    File.open(filename, "r") do |f|
+      x = f.read(12)
+      table_count = x[4] * 256 + x[5]
+      tables = f.read(table_count * 16)
+
+      offset, length = table_count.times do |index|
+        start = index * 16
+        if tables[start..start+3] == 'name'
+          break tables[start+8..start+15].unpack("NN")
+        end
+      end
+      
+      return unless length
+      f.seek(offset)
+      data = f.read(length)
+      
+      format, name_count, string_offset = data[0..5].unpack("nnn")
+      
+      names = {}
+      name_count.times do |index|
+        start = 6 + index * 12
+        platform_id, platform_specific_id, language_id, name_id, length, offset = data[start..start+11].unpack("nnnnnn")        
+        next unless language_id == 0 # English
+        next unless name_id == 1 || name_id == 2
+        
+        offset += string_offset
+        field = data[offset..offset+length-1]        
+        names[name_id] = if platform_id == 0
+          begin
+            Iconv.iconv('UTF-8', 'UTF-16', field)
+          rescue
+            field
+          end
+        else
+          field
+        end
+      end
+      names
+    end
+  end
+end

data/lib/prawn/svg/interface.rb

@@ -1,5 +1,5 @@
 #
-# Prawn::Svg::Interface makes a Prawn::Svg::Parser instance, uses that object to parse the supplied
+# Prawn::Svg::Interface makes a Prawn::Svg::Document instance, uses that object to parse the supplied
 # SVG into Prawn-compatible method calls, and then calls the Prawn methods.
 #
 module Prawn
@@ -12,12 +12,8 @@ module Prawn
   
       class << self; attr_accessor :font_path; end
   
-      attr_reader :data, :prawn, :parser, :options
+      attr_reader :data, :prawn, :document, :options
   
-      # An +Array+ of warnings that occurred while parsing the SVG data.  If this array is non-empty,
-      # it's likely that the SVG failed to render correctly.
-      attr_reader :parser_warnings
-
       #
       # Creates a Prawn::Svg object.
       #
@@ -35,17 +31,18 @@ module Prawn
     
         @options[:at] or raise "options[:at] must be specified"
 
-        @parser = Parser.new(data, [prawn.bounds.width, prawn.bounds.height], options)
-        @parser_warnings = @parser.warnings
+        prawn.font_families.update(Prawn::Svg::Font.installed_fonts)
+
+        @document = Document.new(data, [prawn.bounds.width, prawn.bounds.height], options)        
       end
 
       #
       # Draws the SVG to the Prawn::Document object.
       #
       def draw
-        prawn.bounding_box(@options[:at], :width => @parser.width, :height => @parser.height) do
+        prawn.bounding_box(@options[:at], :width => @document.width, :height => @document.height) do
           prawn.save_graphics_state do
-            proc_creator(prawn, @parser.parse).call
+            proc_creator(prawn, Parser.new(@document).parse).call
           end
         end
       end
@@ -71,15 +68,40 @@ module Prawn
       end
   
       def rewrite_call_arguments(prawn, call, arguments)
+        if call == 'relative_draw_text'
+          call.replace "draw_text"
+          arguments.last[:at][0] = @relative_text_position if @relative_text_position
+        end
+        
         case call
-        when 'text_box'
-          if (anchor = arguments.last.delete(:text_anchor)) && %w(middle end).include?(anchor)
-            width = prawn.width_of(*arguments)
+        when 'text_group'
+          @relative_text_position = nil
+          false
+          
+        when 'draw_text'
+          text, options = arguments
+          
+          width = prawn.width_of(text, options.merge(:kerning => true))
+
+          if (anchor = options.delete(:text_anchor)) && %w(middle end).include?(anchor)
             width /= 2 if anchor == 'middle'
-            arguments.last[:at][0] -= width
+            options[:at][0] -= width
           end
-      
-          arguments.last[:at][1] += prawn.height_of(*arguments) / 3 * 2
+
+          space_width = prawn.width_of("n", options)
+          @relative_text_position = options[:at][0] + width + space_width
+          
+        when 'transformation_matrix'
+          arguments[4] += prawn.bounds.absolute_left * (1 - arguments[0])
+          arguments[5] += prawn.bounds.absolute_top * (1 - arguments[3])
+          
+        when 'save'
+          prawn.save_graphics_state
+          false
+          
+        when 'restore'
+          prawn.restore_graphics_state
+          false
         end
       end
     end

data/lib/prawn/svg/parser.rb

@@ -11,447 +11,205 @@ require 'rexml/document'
 # prawn specifically - this might be useful if you want to take this code and use it to convert
 # SVG to another format.
 #
-module Prawn
-  module Svg
-    class Parser
-      begin
-        require 'css_parser'
-        CSS_PARSER_LOADED = true
-      rescue LoadError
-        CSS_PARSER_LOADED = false
-      end
-  
-      include Prawn::Measurements
-  
-      attr_reader :width, :height
-  
-      # An +Array+ of warnings that occurred while parsing the SVG data.
-      attr_reader :warnings
+class Prawn::Svg::Parser
+  CONTAINER_TAGS = %w(g svg symbol defs)
+  
+  #
+  # Construct a Parser object.  
+  #
+  # The +data+ argument is SVG data.  
+  #
+  # +bounds+ is a tuple [width, height] that specifies the bounds of the drawing space in points.
+  #
+  # +options+ can optionally contain
+  # the key :width or :height.  If both are specified, only :width will be used.
+  #
+  def initialize(document)
+    @document = document
+  end
 
-      # The scaling factor, as determined by the :width or :height options.
-      attr_accessor :scale
-  
-      #
-      # Construct a Parser object.  
-      #
-      # The +data+ argument is SVG data.  
-      #
-      # +bounds+ is a tuple [width, height] that specifies the bounds of the drawing space in points.
-      #
-      # +options+ can optionally contain
-      # the key :width or :height.  If both are specified, only :width will be used.
-      #
-      def initialize(data, bounds, options)
-        @data = data
-        @bounds = bounds
-        @options = options
-        @warnings = []
-        @css_parser = CssParser::Parser.new if CSS_PARSER_LOADED
+  #
+  # Parse the SVG data and return a call tree.  The returned +Array+ is in the format:
+  #
+  #   [
+  #     ['prawn_method_name', ['argument1', 'argument2'], []],
+  #     ['method_that_takes_a_block', ['argument1', 'argument2'], [
+  #       ['method_called_inside_block', ['argument'], []]
+  #     ]
+  #   ]
+  #
+  def parse
+    @document.warnings.clear
     
-        if data
-          parse_document
-          calculate_dimensions
-        end
-      end
+    calls = [['fill_color', '000000', []]]
+    root_element = Prawn::Svg::Element.new(@document, @document.root, calls, :ids => {}, :fill => true)
+    
+    parse_element(root_element)
+    calls
+  end
 
-      #
-      # Parse the SVG data and return a call tree.  The returned +Array+ is in the format:
-      #
-      #   [
-      #     ['prawn_method_name', ['argument1', 'argument2'], []],
-      #     ['method_that_takes_a_block', ['argument1', 'argument2'], [
-      #       ['method_called_inside_block', ['argument'], []]
-      #     ]
-      #   ]
-      #
-      def parse
-        @warnings = []
-        calls = []
-        parse_element(@root, calls, {})
-        calls
-      end
 
+  private  
+  REQUIRED_ATTRIBUTES = {
+    "line"      => %w(x1 y1 x2 y2),
+    "polyline"  => %w(points),
+    "polygon"   => %w(points),
+    "circle"    => %w(r),
+    "ellipse"   => %w(rx ry),
+    "rect"      => %w(width height),
+    "path"      => %w(d)    
+  }
 
-      private  
-      def parse_document
-        @root = REXML::Document.new(@data).root
-        @actual_width, @actual_height = @bounds # set this first so % width/heights can be used
+  def parse_element(element)
+    attrs = element.attributes
 
-        if vb = @root.attributes['viewBox']
-          x1, y1, x2, y2 = vb.strip.split(/\s+/)
-          @x_offset, @y_offset = [x1.to_f, y1.to_f]
-          @actual_width, @actual_height = [x2.to_f - x1.to_f, y2.to_f - y1.to_f]
-        else
-          @x_offset, @y_offset = [0, 0]
-          @actual_width = points(@root.attributes['width'], :x)
-          @actual_height = points(@root.attributes['height'], :y)
-        end
+    if required_attributes = REQUIRED_ATTRIBUTES[element.name]
+      return unless check_attrs_present(element, required_attributes)
+    end
+        
+    case element.name
+    when *CONTAINER_TAGS
+      element.each_child_element do |child|
+        element.add_call "save"
+        parse_element(child)
+        element.add_call "restore"
       end
-    
-      REQUIRED_ATTRIBUTES = {
-        "line"      => %w(x1 y1 x2 y2),
-        "polyline"  => %w(points),
-        "polygon"   => %w(points),
-        "circle"    => %w(r),
-        "ellipse"   => %w(rx ry),
-        "rect"      => %w(x y width height),
-        "path"      => %w(d)    
-      }
-    
-      def parse_element(element, calls, state)
-        attrs = element.attributes
-        calls, style_attrs = apply_styles(element, calls, state)    
-
-        if required_attributes = REQUIRED_ATTRIBUTES[element.name]
-          return unless check_attrs_present(element, required_attributes)
-        end
-    
-        case element.name
-        when 'title', 'desc'
-          # ignore
-      
-        when 'g', 'svg'
-          element.elements.each do |child|
-            parse_element(child, calls, state.dup)
-          end
-    
-        when 'defs'
-          # Pass calls as a blank array so that nothing under this tag can be added to our call tree.
-          element.elements.each do |child|
-            parse_element(child, [], state.dup.merge(:display => false))
-          end
-            
-        when 'style'
-          load_css_styles(element)
-
-        when 'text'
-          # Very primitive support for font-family; it won't work in most cases because
-          # PDF only has a few built-in fonts, and they're not the same as the names
-          # used typically with the web fonts.
-          if font_family = style_attrs["font-family"]
-            if font_family != "" && pdf_font = map_font_family_to_pdf_font(font_family)
-              calls << ['font', [pdf_font], []]
-              calls = calls.last.last
-            else
-              @warnings << "#{font_family} is not a known font."
-            end
-          end
       
-          opts = {:at => [x(attrs['x']), y(attrs['y'])]}
-          if size = style_attrs['font-size']
-            opts[:size] = size.to_f * @scale
-          end
-            
-          # This is not a prawn option but we can't work out how to render it here -
-          # it's handled by Svg#rewrite_call_arguments
-          if anchor = style_attrs['text-anchor']
-            opts[:text_anchor] = anchor        
-          end
+      do_not_append_calls = %w(symbol defs).include?(element.name)
+          
+    when 'style'
+      load_css_styles(element)
+
+    when 'text'
+      @svg_text ||= Text.new
+      @svg_text.parse(element)
+
+    when 'line'
+      element.add_call 'line', x(attrs['x1']), y(attrs['y1']), x(attrs['x2']), y(attrs['y2'])
+
+    when 'polyline'
+      points = attrs['points'].split(/\s+/)
+      return unless base_point = points.shift
+      x, y = base_point.split(",")
+      element.add_call 'move_to', x(x), y(y)
+      element.add_call_and_enter 'stroke'
+      points.each do |point|
+        x, y = point.split(",")
+        element.add_call "line_to", x(x), y(y)
+      end
+
+    when 'polygon'
+      points = attrs['points'].split(/\s+/).collect do |point|
+        x, y = point.split(",")
+        [x(x), y(y)]
+      end
+      element.add_call "polygon", points
+  
+    when 'circle'
+      element.add_call "circle_at", 
+        [x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], :radius => distance(attrs['r'])
+  
+    when 'ellipse'
+      element.add_call "ellipse_at", 
+        [x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], distance(attrs['rx']), distance(attrs['ry'])
+  
+    when 'rect'
+      radius = distance(attrs['rx'] || attrs['ry'])
+      args = [[x(attrs['x'] || '0'), y(attrs['y'] || '0')], distance(attrs['width']), distance(attrs['height'])]
+      if radius
+        # n.b. does not support both rx and ry being specified with different values
+        element.add_call "rounded_rectangle", *(args + [radius])
+      else
+        element.add_call "rectangle", *args
+      end
+  
+    when 'path'
+      parse_path(element)
       
-          calls << ['text_box', [element.text, opts], []]
+    when 'use'
+      parse_use(element)
 
-        when 'line'
-          calls << ['line', [x(attrs['x1']), y(attrs['y1']), x(attrs['x2']), y(attrs['y2'])], []]
-
-        when 'polyline'
-          points = attrs['points'].split(/\s+/)
-          return unless base_point = points.shift
-          x, y = base_point.split(",")
-          calls << ['move_to', [x(x), y(y)], []]
-          calls << ['stroke', [], []]
-          calls = calls.last.last
-          points.each do |point|
-            x, y = point.split(",")
-            calls << ["line_to", [x(x), y(y)], []]
-          end
-    
-        when 'polygon'
-          points = attrs['points'].split(/\s+/).collect do |point|
-            x, y = point.split(",")
-            [x(x), y(y)]
-          end
-          calls << ["polygon", points, []]      
-      
-        when 'circle'
-          calls << ["circle_at", 
-            [[x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], {:radius => distance(attrs['r'])}], 
-            []]
-      
-        when 'ellipse'
-          calls << ["ellipse_at", 
-            [[x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], distance(attrs['rx']), distance(attrs['ry'])],
-            []]
-      
-        when 'rect'
-          radius = distance(attrs['rx'] || attrs['ry'])
-          args = [[x(attrs['x']), y(attrs['y'])], distance(attrs['width']), distance(attrs['height'])]
-          if radius
-            # n.b. does not support both rx and ry being specified with different values
-            calls << ["rounded_rectangle", args + [radius], []]
-          else
-            calls << ["rectangle", args, []]
-          end
+    when 'title', 'desc', 'metadata'
+      # ignore
+      do_not_append_calls = true
       
-        when 'path'
-          @svg_path ||= Path.new
-
-          begin
-            commands = @svg_path.parse(attrs['d'])
-          rescue Prawn::Svg::Parser::Path::InvalidError => e
-            commands = []
-            @warnings << e.message
-          end
-
-          commands.each do |command, args|
-            point_to = [x(args[0]), y(args[1])]
-            if command == 'curve_to'
-              bounds = [[x(args[2]), y(args[3])], [x(args[4]), y(args[5])]]
-              calls << [command, [point_to, {:bounds => bounds}], []]
-            else
-              calls << [command, point_to, []]
-            end
-          end
-
-        else 
-          @warnings << "Unknown tag '#{element.name}'; ignoring"
-        end
-      end
+    when 'font-face'
+      # not supported
+      do_not_append_calls = true
   
-      def load_css_styles(element)
-        if @css_parser
-          data = if element.cdatas.any?
-            element.cdatas.collect {|d| d.to_s}.join
-          else
-            element.text
-          end
+    else 
+      @document.warnings << "Unknown tag '#{element.name}'; ignoring"
+    end
     
-          @css_parser.add_block!(data) 
-        end    
-      end
-  
-      def parse_css_declarations(declarations)
-        # copied from css_parser
-        declarations.gsub!(/(^[\s]*)|([\s]*$)/, '')
-
-        output = {}
-        declarations.split(/[\;$]+/m).each do |decs|
-          if matches = decs.match(/\s*(.[^:]*)\s*\:\s*(.[^;]*)\s*(;|\Z)/i)
-            property, value, end_of_declaration = matches.captures
-            output[property] = value
-          end
-        end
-        output
-      end
-  
-      def determine_style_for(element)
-        if @css_parser
-          tag_style = @css_parser.find_by_selector(element.name)
-          id_style = @css_parser.find_by_selector("##{element.attributes["id"]}") if element.attributes["id"]
-      
-          if classes = element.attributes["class"]
-            class_styles = classes.strip.split(/\s+/).collect do |class_name|
-              @css_parser.find_by_selector(".#{class_name}")
-            end
-          end
-      
-          element_style = element.attributes['style']
-
-          style = [tag_style, class_styles, id_style, element_style].flatten.collect do |s|
-            s.nil? || s.strip == "" ? "" : "#{s}#{";" unless s.match(/;\s*\z/)}"
-          end.join
-        else
-          style = element.attributes['style'] || ""
-        end
+    element.append_calls_to_parent unless do_not_append_calls
+  end
 
-        decs = parse_css_declarations(style)
-        element.attributes.each {|n,v| decs[n] = v unless decs[n]}
-        decs
-      end
   
-      def apply_styles(element, calls, state)
-        decs = determine_style_for(element)    
-        draw_types = []
-    
-        # Transform
-        if transform = decs['transform']
-          parse_css_method_calls(transform).each do |name, arguments|
-            case name
-            when 'translate'
-              x, y = arguments
-              x, y = x.split(/\s+/) if y.nil?
-              calls << [name, [distance(x), -distance(y)], []]
-              calls = calls.last.last
-            when 'rotate'          
-              calls << [name, [-arguments.first.to_f, {:origin => [0, y('0')]}], []]
-              calls = calls.last.last
-            when 'scale'
-              calls << [name, [arguments.first.to_f], []]
-              calls = calls.last.last
-            else
-              @warnings << "Unknown transformation '#{name}'; ignoring"
-            end
-          end
-        end    
-            
-        # Opacity:
-        # We can't do nested opacities quite like the SVG requires, but this is close enough.
-        fill_opacity = stroke_opacity = clamp(decs['opacity'].to_f, 0, 1) if decs['opacity']
-        fill_opacity = clamp(decs['fill-opacity'].to_f, 0, 1) if decs['fill-opacity']
-        stroke_opacity = clamp(decs['stroke-opacity'].to_f, 0, 1) if decs['stroke-opacity']
-    
-        if fill_opacity || stroke_opacity      
-          state[:fill_opacity] = (state[:fill_opacity] || 1) * (fill_opacity || 1)
-          state[:stroke_opacity] = (state[:stroke_opacity] || 1) * (stroke_opacity || 1)
+  def parse_path(element)
+    @svg_path ||= Path.new
 
-          calls << ['transparent', [state[:fill_opacity], state[:stroke_opacity]], []] 
-          calls = calls.last.last
-        end
-
-        # Fill and stroke
-        if decs['fill'] && decs['fill'] != "none"
-          if color = color_to_hex(decs['fill'])
-            calls << ['fill_color', [color], []]
-          end
-          draw_types << 'fill'
-        end
-    
-        if decs['stroke'] && decs['stroke'] != "none"
-          if color = color_to_hex(decs['stroke'])
-            calls << ['stroke_color', [color], []]
-          end
-          draw_types << 'stroke'
-        end
-    
-        calls << ['line_width', [distance(decs['stroke-width'])], []] if decs['stroke-width']  
-    
-        draw_type = draw_types.join("_and_")
-        state[:draw_type] = draw_type if draw_type != ""
-        if state[:draw_type] && !%w(g svg).include?(element.name)
-          calls << [state[:draw_type], [], []]
-          calls = calls.last.last
-        end            
-        
-        [calls, decs]
-      end
-  
-      def parse_css_method_calls(string)
-        string.scan(/\s*(\w+)\(([^)]+)\)\s*/).collect do |call|
-          name, argument_string = call
-          arguments = argument_string.split(",").collect {|s| s.strip}
-          [name, arguments]
-        end    
-      end
-  
-      BUILT_IN_FONTS = ["Courier", "Helvetica", "Times-Roman", "Symbol", "ZapfDingbats"]
-      GENERIC_CSS_FONT_MAPPING = {
-        "serif"      => "Times-Roman",
-        "sans-serif" => "Helvetica",
-        "cursive"    => "Times-Roman",
-        "fantasy"    => "Times-Roman",
-        "monospace"  => "Courier"}
-    
-      def installed_fonts
-        @installed_fonts ||= Prawn::Svg::Interface.font_path.uniq.collect {|path| Dir["#{path}/*"]}.flatten
-      end
-  
-      def map_font_family_to_pdf_font(font_family)
-        font_family.split(",").detect do |font|
-          font = font.gsub(/['"]/, '').gsub(/\s{2,}/, ' ').strip.downcase
-      
-          built_in_font = BUILT_IN_FONTS.detect {|f| f.downcase == font}
-          break built_in_font if built_in_font
-      
-          generic_font = GENERIC_CSS_FONT_MAPPING[font]
-          break generic_font if generic_font
-      
-          installed_font = installed_fonts.detect do |file|
-            (matches = File.basename(file).match(/(.+)\./)) && matches[1].downcase == font
-          end
-          break installed_font if installed_font
-        end
-      end
+    begin
+      commands = @svg_path.parse(element.attributes['d'])
+    rescue Prawn::Svg::Parser::Path::InvalidError => e
+      commands = []
+      @document.warnings << e.message
+    end
 
-      # TODO : use http://www.w3.org/TR/SVG11/types.html#ColorKeywords
-      HTML_COLORS = {    
-      	'black' => "000000", 'green' => "008000", 'silver' => "c0c0c0", 'lime' => "00ff00",
-      	'gray' => "808080", 'olive' => "808000", 'white' => "ffffff", 'yellow' => "ffff00",
-      	'maroon' => "800000", 'navy' => "000080", 'red' => "ff0000", 'blue' => "0000ff",
-      	'purple' => "800080", 'teal' => "008080", 'fuchsia' => "ff00ff", 'aqua' => "00ffff"
-      }.freeze
-  
-      RGB_VALUE_REGEXP = "\s*(-?[0-9.]+%?)\s*"
-      RGB_REGEXP = /\Argb\(#{RGB_VALUE_REGEXP},#{RGB_VALUE_REGEXP},#{RGB_VALUE_REGEXP}\)\z/i
-  
-      def color_to_hex(color_string)
-        color_string.scan(/([^(\s]+(\([^)]*\))?)/).detect do |color, *_|
-          if m = color.match(/\A#([0-9a-f])([0-9a-f])([0-9a-f])\z/i)
-            break "#{m[1] * 2}#{m[2] * 2}#{m[3] * 2}"
-          elsif color.match(/\A#[0-9a-f]{6}\z/i)
-            break color[1..6]
-          elsif hex = HTML_COLORS[color.downcase]
-            break hex
-          elsif m = color.match(RGB_REGEXP)
-            break (1..3).collect do |n|
-              value = m[n].to_f
-              value *= 2.55 if m[n][-1..-1] == '%'
-              "%02x" % clamp(value.round, 0, 255)
-            end.join        
-          end    
-        end
-      end
-  
-      def x(value)
-        (points(value, :x) - @x_offset) * scale
-      end
-  
-      def y(value)
-        (@actual_height - (points(value, :y) - @y_offset)) * scale
-      end
-  
-      def distance(value, axis = nil)
-        value && (points(value, axis) * scale)
-      end
-  
-      def points(value, axis = nil)
-        if value.is_a?(String)
-          if match = value.match(/\d(cm|dm|ft|in|m|mm|yd)$/)
-            send("#{match[1]}2pt", value.to_f)
-          elsif value[-1..-1] == "%"
-            value.to_f * (axis == :y ? @actual_height : @actual_width) / 100.0
-          else
-            value.to_f
-          end
-        else
-          value.to_f
-        end
+    commands.collect do |command, args|
+      point_to = [x(args[0]), y(args[1])]
+      if command == 'curve_to'
+        opts = {:bounds => [[x(args[2]), y(args[3])], [x(args[4]), y(args[5])]]}
       end
+      element.add_call command, point_to, opts
+    end  
+  end
   
-      def calculate_dimensions    
-        if @options[:width]
-          @width = @options[:width]      
-          @scale = @options[:width] / @actual_width.to_f
-        elsif @options[:height]
-          @height = @options[:height]
-          @scale = @options[:height] / @actual_height.to_f
+  def parse_use(element)
+    if href = element.attributes['xlink:href']
+      if href[0..0] == '#'
+        id = href[1..-1]
+        if id_calls = element.state[:ids][id]
+          x = element.attributes['x']
+          y = element.attributes['y']
+          if x || y
+            element.add_call_and_enter "translate", distance(x || 0), -distance(y || 0)
+          end
+          
+          element.calls.concat(id_calls)              
         else
-          @scale = 1
+          @document.warnings << "no tag with ID '#{id}' was found, referenced by use tag"
         end
-    
-        @width ||= @actual_width * @scale
-        @height ||= @actual_height * @scale
+      else
+        @document.warnings << "use tag has an href that is not a reference to an id; this is not supported"
       end
+    else
+      @document.warnings << "no xlink:href specified on use tag"
+    end
+  end    
   
-      def clamp(value, min_value, max_value)
-        [[value, min_value].max, max_value].min
-      end  
-  
-      def check_attrs_present(element, attrs)
-        missing_attrs = attrs - element.attributes.keys
-        if missing_attrs.any?
-          @warnings << "Must have attributes #{missing_attrs.join(", ")} on tag #{element.name}; skipping tag"
-        end
-        missing_attrs.empty?
+  ####################################################################################################################
+
+  def load_css_styles(element)
+    if @document.css_parser
+      data = if element.element.cdatas.any?
+        element.element.cdatas.collect {|d| d.to_s}.join
+      else
+        element.element.text
       end
+
+      @document.css_parser.add_block!(data)       
+    end    
+  end
+
+  def check_attrs_present(element, attrs)
+    missing_attrs = attrs - element.attributes.keys
+    if missing_attrs.any?
+      @document.warnings << "Must have attributes #{missing_attrs.join(", ")} on tag #{element.name}; skipping tag"
     end
+    missing_attrs.empty?
+  end
+  
+  %w(x y distance).each do |method|
+    define_method(method) {|*a| @document.send(method, *a)}
   end
 end

data/lib/prawn/svg/parser/text.rb

@@ -0,0 +1,67 @@
+class Prawn::Svg::Parser::Text
+  def parse(element)
+    element.add_call_and_enter "text_group"
+    internal_parse(element, [element.document.x(0)], [element.document.y(0)], false)
+  end
+    
+  protected
+  def internal_parse(element, x_positions, y_positions, relative)
+    attrs = element.attributes
+    
+    if attrs['x'] || attrs['y']
+      relative = false
+      x_positions = attrs['x'].split(/[\s,]+/).collect {|n| element.document.x(n)} if attrs['x']
+      y_positions = attrs['y'].split(/[\s,]+/).collect {|n| element.document.y(n)} if attrs['y']
+    end
+    
+    if attrs['dx'] || attrs['dy']
+      element.add_call_and_enter "translate", element.document.distance(attrs['dx'] || 0), -element.document.distance(attrs['dy'] || 0)
+    end
+
+    opts = {}
+    if size = element.state[:font_size]
+      opts[:size] = size
+    end
+    if style = element.state[:font_style]
+      opts[:style] = style
+    end
+      
+    # This is not a prawn option but we can't work out how to render it here -
+    # it's handled by Svg#rewrite_call_arguments
+    if anchor = attrs['text-anchor']
+      opts[:text_anchor] = anchor        
+    end
+
+    element.element.children.each do |child|
+      if child.node_type == :text
+        text = child.to_s.strip.gsub(/\s+/, " ")
+
+        while text != "" 
+          opts[:at] = [x_positions.first, y_positions.first]
+
+          if x_positions.length > 1 || y_positions.length > 1
+            element.add_call 'draw_text', text[0..0], opts.dup
+            text = text[1..-1]
+
+            x_positions.shift if x_positions.length > 1
+            y_positions.shift if y_positions.length > 1
+          else
+            element.add_call relative ? 'relative_draw_text' : 'draw_text', text, opts.dup
+            relative = true
+            break
+          end
+        end
+
+      elsif child.name == "tspan"
+        element.add_call 'save'
+        child_element = Prawn::Svg::Element.new(element.document, child, element.calls, element.state.dup)
+        internal_parse(child_element, x_positions, y_positions, relative)
+        child_element.append_calls_to_parent
+        element.add_call 'restore'
+        
+      else
+        element.warnings << "Unknown tag '#{child.name}' inside text tag; ignoring"
+      end
+    end    
+  end
+end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 9
   - 1
-  - 8
-  version: 0.9.1.8
+  - 9
+  version: 0.9.1.9
 platform: ruby
 authors: 
 - Roger Nesbitt
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-09 00:00:00 +12:00
+date: 2010-06-06 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,9 +57,13 @@ extra_rdoc_files: []
 files: 
 - README
 - LICENSE
+- lib/prawn/svg/document.rb
+- lib/prawn/svg/element.rb
 - lib/prawn/svg/extension.rb
+- lib/prawn/svg/font.rb
 - lib/prawn/svg/interface.rb
 - lib/prawn/svg/parser/path.rb
+- lib/prawn/svg/parser/text.rb
 - lib/prawn/svg/parser.rb
 - lib/prawn-svg.rb
 has_rdoc: true