dynamic_images 1.0.0

data/lib/parsers/xml.dtd

@@ -0,0 +1,154 @@
+<?xml version='1.0' encoding='UTF-8'?>
+
+<!--
+    Document type definition of XML document defining dynamic images
+    PUBLIC ID: -//malis//dynamic_images//EN
+    SYSTEM ID: https://raw.github.com/malis/dynamic_images/master/lib/parsers/xml.dtd
+
+-->
+
+<!--
+    An example how to use this DTD from your XML document:
+
+    <?xml version="1.0"?>
+
+    <!DOCTYPE dynamic_images PUBLIC "-//malis//dynamic_images//EN" "https://raw.github.com/malis/dynamic_images/master/lib/parsers/xml.dtd">
+
+    <dynamic_images>
+    ...
+    </dynamic_images>
+-->
+
+<!--- Root element dynamic_images can contain also more than one dynamic_image definition -->
+<!ELEMENT dynamic_images (dynamic_image)*>
+
+<!--- Block element and inherited classes which can contain same elements -->
+<!ENTITY % BlockElements "(block|image|table|text)*">
+<!ELEMENT dynamic_image %BlockElements;>
+<!ELEMENT block %BlockElements;>
+<!ENTITY % common_attrs
+ "height          CDATA                       #IMPLIED
+  h               CDATA                       #IMPLIED
+  margin          CDATA                #IMPLIED
+  margin_top      CDATA                #IMPLIED
+  margin_right    CDATA                #IMPLIED
+  margin_bottom   CDATA                #IMPLIED
+  margin_left     CDATA                #IMPLIED
+  position        (static|relative|absolute)  #IMPLIED
+  width           CDATA                       #IMPLIED
+  w               CDATA                       #IMPLIED
+  x               CDATA                       #IMPLIED
+  y               CDATA                       #IMPLIED
+  z               CDATA                       #IMPLIED"
+>
+<!ENTITY % border_attrs
+ "border          CDATA                #IMPLIED
+  border_top      CDATA                #IMPLIED
+  border_right    CDATA                #IMPLIED
+  border_bottom   CDATA                #IMPLIED
+  border_left     CDATA                #IMPLIED"
+>
+<!ENTITY % block_attrs
+ "%common_attrs;
+  %border_attrs;
+  align           (left|center|right)  #IMPLIED
+  background      CDATA                #IMPLIED
+  color           CDATA                #IMPLIED
+  padding         CDATA                #IMPLIED
+  padding_top     CDATA                #IMPLIED
+  padding_right   CDATA                #IMPLIED
+  padding_bottom  CDATA                #IMPLIED
+  padding_left    CDATA                #IMPLIED
+  vertical_align  CDATA                #IMPLIED
+  valign          CDATA                #IMPLIED"
+>
+<!ATTLIST dynamic_image
+  %block_attrs;
+  from_source   CDATA  #IMPLIED
+  save          CDATA  #IMPLIED
+  save_endless  CDATA  #IMPLIED
+  quality       CDATA  #IMPLIED
+>
+<!ATTLIST block %block_attrs;>
+
+<!--- Image element -->
+<!ELEMENT image (#PCDATA)>
+<!ATTLIST image
+  %common_attrs;
+  alpha           CDATA  #IMPLIED
+  crop            CDATA  #IMPLIED
+>
+
+<!--- Table element -->
+<!ELEMENT table (row|cell)*>
+<!ATTLIST table
+  %common_attrs;
+  background  CDATA  #IMPLIED
+  %border_attrs;
+  cols        CDATA  #IMPLIED
+>
+<!ELEMENT row (cell)*>
+<!ELEMENT cell %BlockElements;>
+<!ATTLIST cell %block_attrs;>
+
+
+<!-- Pango elements to ise in text element -->
+<!ENTITY % PangoElements "(#PCDATA|span|b|big|i|s|sub|sup|small|tt|u)*">
+<!ELEMENT span  %PangoElements;>
+<!ELEMENT b     %PangoElements;>
+<!ELEMENT big   %PangoElements;>
+<!ELEMENT i     %PangoElements;>
+<!ELEMENT s     %PangoElements;>
+<!ELEMENT sub   %PangoElements;>
+<!ELEMENT sup   %PangoElements;>
+<!ELEMENT small %PangoElements;>
+<!ELEMENT tt    %PangoElements;>
+<!ELEMENT u     %PangoElements;>
+<!ATTLIST span
+  font                 CDATA  #IMPLIED
+  font_desc            CDATA  #IMPLIED
+  font_family          CDATA  #IMPLIED
+  face                 CDATA  #IMPLIED
+  font_size            CDATA  #IMPLIED
+  size                 CDATA  #IMPLIED
+  font_style           CDATA  #IMPLIED
+  style                CDATA  #IMPLIED
+  font_weight          CDATA  #IMPLIED
+  weight               CDATA  #IMPLIED
+  font_variant         CDATA  #IMPLIED
+  variant              CDATA  #IMPLIED
+  font_stretch         CDATA  #IMPLIED
+  stretch              CDATA  #IMPLIED
+  foreground           CDATA  #IMPLIED
+  fgcolor              CDATA  #IMPLIED
+  color                CDATA  #IMPLIED
+  background           CDATA  #IMPLIED
+  bgcolor              CDATA  #IMPLIED
+  underline            CDATA  #IMPLIED
+  underline_color      CDATA  #IMPLIED
+  rise                 CDATA  #IMPLIED
+  strikethrough        CDATA  #IMPLIED
+  strikethrough_color  CDATA  #IMPLIED
+  fallback             CDATA  #IMPLIED
+  lang                 CDATA  #IMPLIED
+  leter_spacing        CDATA  #IMPLIED
+  gravity              CDATA  #IMPLIED
+  gravity_hint         CDATA  #IMPLIED
+>
+
+<!--- Text element -->
+<!ELEMENT text %PangoElements;>
+<!ATTLIST text
+  %common_attrs;
+  align        CDATA   #IMPLIED
+  auto_dir     (true)  #IMPLIED
+  color        CDATA   #IMPLIED
+  crop_to      CDATA   #IMPLIED
+  crop_suffix  CDATA   #IMPLIED
+  font         CDATA   #IMPLIED
+  indent       CDATA   #IMPLIED
+  justify      CDATA   #IMPLIED
+  spacng       CDATA   #IMPLIED
+  to_fit       CDATA   #IMPLIED
+>
+

data/lib/parsers/xml_parser.rb

@@ -0,0 +1,135 @@
+require 'rexml/document'
+
+# Module contains parsers of dynamic images from static formats.
+module DynamicImageParsers
+  # XML Parser parses XML documents containing dynamic images. You can give many images into one XML document.
+  #
+  # XML document has to be in same hierarchy as in pure ruby. Save, save_endless and treir quality option is given as dynamic_images's attribute.
+  #
+  # Save_endless images limit is gives as attribute too. It's name is :save_endless_limit.
+  #
+  # Save_endless filename has to be given as string attribute. You can set place of index by <tt>%{index}</tt>. F.e.: <tt>"image-%{index}.png"</tt>.
+  #
+  # Options are taken from element attributes. There is same rules like in pure ruby. See DynamicImage.
+  #
+  # === Example
+  #
+  #  <?xml version="1.0" encoding="UTF-8" ?>
+  #  <!DOCTYPE dynamic_images PUBLIC "-//malis//dynamic_images//EN" "https://raw.github.com/malis/dynamic_images/master/lib/parsers/xml.dtd">
+  #  <dynamic_images>
+  #   <dynamic_image from_source="earth.jpg" align="center" valign="middle" background="red 0.5" save="test_from.jpg" quality="90">
+  #    <text font="Arial bold 15">testing <u>adding</u> some text to image</text>
+  #    <block background="red">
+  #      <image w="50" h="50">kostky.png</image>
+  #    </block>
+  #    <table>
+  #      <row>
+  #        <cell>
+  #          <text><b>Left table header</b></text>
+  #        </cell>
+  #        <cell>
+  #          <text><b>Right table header</b></text>
+  #        </cell>
+  #      </row>
+  #      <row>
+  #        <cell>
+  #          <text>Table value 1</text>
+  #        </cell>
+  #        <cell>
+  #          <text>Table value 2</text>
+  #        </cell>
+  #      </row>
+  #    </table>
+  #   </dynamic_image>
+  #  </dynamic_images>
+  #
+  class XmlParser
+    # Accepts filename or +String+ containing XML document and processes it with dynamic_images library.
+    def initialize(filename_or_xml, render_only_first_to = nil, options = {})
+      @render_only_first_to = render_only_first_to
+      @options = options
+      filename_or_xml = File.read(filename_or_xml) if File.exists? filename_or_xml
+      doc = REXML::Document.new(filename_or_xml)
+      doc.elements.first.each_element do |image|
+        dynamic_image image
+        return if @render_only_first_to
+      end
+    end
+
+    private
+    def dynamic_image(image)
+      options = get_options image
+      DynamicImage.new options do |dimg|
+        image.each_element do |xml_element|
+          in_block_element xml_element, dimg
+        end
+        if @render_only_first_to
+          save_options = @options[:quality] ? {:quality => @options[:quality]} : {}
+          save_options[:format] = @options[:format]
+          dimg.save! @render_only_first_to, save_options
+        else
+          save_options = options[:quality] ? {:quality => options[:quality]} : {}
+          if options[:save]
+            dimg.save! options[:save], save_options
+          elsif options[:save_endless]
+            dimg.save_endless! options[:save_endless_limit].to_i do |index|
+              options[:save_endless].gsub("%{index}", index)
+            end
+          end
+        end
+      end
+    end
+
+    def in_block_element(xml_element, block)
+      options = get_options xml_element
+      case xml_element.name.downcase
+      when "block"
+        block.block options do |block|
+          xml_element.each_element do |e|
+            in_block_element e, block
+          end
+        end
+      when "image"
+        block.image get_raw(xml_element), options
+      when "table"
+        block.table options do |table|
+          xml_element.each_element do |e|
+            in_table_element e, table
+          end
+        end
+      when "text"
+        block.text get_raw(xml_element), options
+      end
+    end
+
+    def in_table_element(xml_element, table)
+      options = get_options xml_element
+      case xml_element.name.downcase
+      when "cell"
+        table.cell options do |block|
+          xml_element.each_element do |e|
+            in_block_element e, block
+          end
+        end
+      when "row"
+        table.row do |row|
+          xml_element.each_element do |e|
+            in_table_element e, row
+          end
+        end
+      end
+    end
+
+    # Basic parsing XML elements methods
+
+    def get_options(e)
+      options = {}
+      e.attributes.each {|k, v| options[k] = v }
+      options
+    end
+
+    def get_raw(e)
+      e.to_s.sub(/\A<[^>]*>/, '').sub(/<[^>]*>\Z/, '')
+    end
+  end
+end

data/lib/render_image.rb

@@ -0,0 +1,60 @@
+# Module used to add methods to ActionController::Base
+module RenderImage
+  # Provides image drawing for Rails app controller. Default format is <tt>action_name.png</tt> in file called <tt>action_name.png.xml.erb</tt>.
+  #
+  # You can use different template name but it has to have extension <tt>.format.xml.erb</tt>. Passing extension <tt>.xml.erb</tt> is optional but file has be called with it.
+  #
+  # You can optionaly pass options (see below) and assigns too. Assigns is +Hash+ of keys and values which will be accessible from view as variables called as keys names.
+  #
+  # === Options
+  # [:quality]
+  #   When saving into JPEG format you can pass :quality into options. Valid values are in 0 - 100.
+  #
+  # === Example
+  # File show.png.xml.erb should looks like this:
+  #
+  #  <?xml version="1.0" encoding="UTF-8" ?>
+  #  <!DOCTYPE dynamic_images PUBLIC "-//malis//dynamic_images//EN" "https://raw.github.com/malis/dynamic_images/master/lib/parsers/xml.dtd">
+  #  <dynamic_images>
+  #    <dynamic_image width="500" align="center" background="blue 0.5">
+  #      <text font="Arial bold 20"><%= @article.title %></text>
+  #      <text indent="30"><%= @article.text %></text>
+  #    </dynamic_image>
+  #  </dynamic_images>
+  #
+  # Attributes save, save_endless and quality will be omitted. You can pass quality in options +Hash+.
+  #
+  def render_image(template = nil, options = {}, assigns = {})
+    template ||= "#{action_name}.png"
+    template += ".xml.erb" if template.class == String && template !~ /\.xml\.erb\Z/i
+    view_path = nil
+    view_paths.each do |v_path|
+      v_path = File.join(v_path, controller_path)
+      view_path = v_path if File.exists? File.join(v_path, template)
+    end
+    raise "There is no template #{template} in paths: #{view_paths.join ' '}" unless view_path
+
+    view = ActionView::Base.new(view_path, assigns)
+    view.extend ApplicationHelper
+    instance_variables.each do |var|
+      next if var.to_s !~ /\A@[a-z]/i
+      view.instance_variable_set var, instance_variable_get(var)
+    end
+    xml = view.render(:file => template)
+
+    file = template.sub(/\.xml\.erb\Z/i, '')
+    if RUBY_VERSION >= "1.9"
+      tempfile = Tempfile.new file, :encoding => 'ascii-8bit'
+    else
+      tempfile = Tempfile.new file
+    end
+    options[:format] = file.scan(/\.([a-z0-9]+)\Z/i).flatten.first
+
+    DynamicImageParsers::XmlParser.new xml, tempfile, options
+
+    tempfile.rewind
+    send_data tempfile.read, :filename => file, :disposition => 'inline', :type => "image/#{options[:format]}"
+    tempfile.close
+    tempfile.unlink
+  end
+end

data/lib/sources/color_source.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/source_factory.rb'
+
+module DynamicImageSources
+  # Source providing solid color to use as source.
+  class ColorSource < SourceFactory
+    # Creates source object from <tt>Cairo::Color::RGB</tt> object and alpha as Float value.
+    def initialize(color, alpha)
+      alpha = nil unless alpha.class == Float
+      @red = color.red
+      @green = color.green
+      @blue = color.blue
+      @alpha = alpha || 1
+    end
+
+    # Gets color component
+    attr_reader :red, :green, :blue, :alpha
+
+    # Gives +Array+ of all known named colors. See http://cairo.rubyforge.org/doc/en/cairo-color.html#label-5
+    def self.named_colors
+      @@named_colors ||= (Cairo::Color.constants.sort - %w{ RGB CMYK HSV X11 Base HEX_RE } - %w{ RGB CMYK HSV X11 Base HEX_RE }.map(&:to_sym)).map(&:to_s)
+    end
+
+    # Returns source object or nil if it can't parse it.
+    #
+    # === Supported syntax
+    # All values can be given as +Array+ or +String+ separated by space chars.
+    #
+    # To make color transparent add number value at the end of +Array+ or +String+.
+    #
+    # For any number value are valid values are 0 - 255 or 0.0 - 1.0
+    #
+    # [Name of color]
+    #   Use one of ColorSource.named_colors.
+    # [RGB]
+    #    Use separated number values for red, green and blue.
+    # [CMYK]
+    #   Use :cmyk key as first value followed by separated number values for cyan, magenta, yellow and black.
+    # [HSV]
+    #   Use :hsv key as first value followed by separated number values for hue, saturation and value.
+    # [HEX]
+    #   Use +String+ starting with <tt>#</tt> char followed by 6 or 3 hex numbers. Hex numbers are doubled if only 3 hex numbers are given. Color <tt>#AABBCC</tt> is same as <tt>#ABC</tt>.
+    #
+    # === Example
+    # * <tt>:red</tt> is same as <tt>"red"</tt> and <tt>[:red]</tt>
+    # * <tt>[255, 0, 0]</tt> and <tt>"#FF0000"</tt> makes red color
+    # * <tt>[255, 0, 0, 64]</tt> and <tt>["#F00", 64]</tt> makes red color with 75% transparency
+    # * <tt>[1.0, 0, 0, 0.25]</tt> and <tt>"#F00 0.25"</tt> makes red color with 75% transparency
+    # * <tt>[:cmyk, 0, 0, 1.0, 0]</tt> makes yellow color
+    # * <tt>[:cmyk, 0, 0, 255, 0, 0.5]</tt> makes yellow color with 50% transparency
+    #
+    def self.parse(source)
+      return source if source.is_a? SourceFactory
+      if source[0].to_s =~ /^#([0-9a-f]{3}|[0-9a-f]{6})$/i
+        hex = ($1.size == 6 ? $1 : $1.unpack('AXAAXAAXA').join).unpack("A2A2A2")
+        source.shift
+        hex.reverse.each {|h| source.unshift h.to_i(16) }
+      end
+      if is_all_nums(source, 0..2)
+        treat_numbers source
+        new Cairo::Color::RGB.new(*source[0..2]), source[3]
+      elsif source[0] == "cmyk" && is_all_nums(source, 1..4)
+        treat_numbers source
+        new Cairo::Color::CMYK.new(*source[1..4]).to_rgb, source[5]
+      elsif source[0] == "hsv" && is_all_nums(source, 1..3)
+        treat_numbers source
+        new Cairo::Color::HSV.new(*source[1..3]).to_rgb, source[4]
+      elsif named_colors.include? source[0].to_s.upcase
+        treat_numbers source
+        new Cairo::Color.parse(source[0].to_s.upcase), source[1]
+      end
+    end
+
+    private
+    def self.is_all_nums(arr, int)
+      int.to_a.each do |index|
+        return false unless arr[index] && arr[index].to_s =~ /^\d+(\.\d+)?$/
+      end
+      return true
+    end
+
+    def self.treat_numbers(source)
+      source.each_with_index do |value, index|
+        if source[index].to_s =~ /^\d+$/
+          source[index] = source[index].to_f/255.0
+        elsif source[index].to_s =~ /^\d+\.\d+$/
+          source[index] = source[index].to_f
+        end
+      end
+    end
+
+    public
+    # Sets color as source to given context
+    def set_source(context, x, y, w, h)
+      context.set_source_rgba @red, @green, @blue, @alpha
+    end
+  end
+end

data/lib/sources/gradient_source.rb

@@ -0,0 +1,200 @@
+require File.dirname(__FILE__) + '/source_factory.rb'
+require File.dirname(__FILE__) + '/color_source.rb'
+
+module DynamicImageSources
+  # Source providing gradient source to drawing.
+  class GradientSource < SourceFactory
+    # Creates gradient source object from type and extend type.
+    #
+    # Valid values for type are :linear and :radial. Default is :linear.
+    #
+    # Valid values for extend type are :pad, :repeat and :reflect. Default is :pad.
+    #
+    def initialize(type, ext, *args)
+      @type = type || :linear
+      @ext = ext || :pad
+      @args = args
+      @stops = []
+    end
+
+    public
+    # Returns source object or nil if it can't parse it.
+    #
+    # === Supported syntax
+    # All values can be given as +Array+ or +String+ separated by space chars.
+    #
+    # Values has to be in this order: <tt>[:gradient_name, *gradient_arguments, stop_value1, stop_value2, ..., stop_valueN]</tt>. All values has to be in one-dimensional array.
+    #
+    # ==== Gradient name
+    # Valid gradient names are:
+    # * Linear:
+    #   * <tt>:gradient</tt> for linear gradient
+    #   * <tt>:gradient_repeat</tt> for linear gradient with repeating
+    #   * <tt>:gradient_reflect</tt> for linear gradient with reflection
+    # * Radial:
+    #   * <tt>:gradient_radial</tt> for radial gradient
+    #   * <tt>:gradient_radial_repeat</tt> for radial gradient with repeating
+    #   * <tt>:gradient_radial_reflect</tt> for radial gradient with reflection
+    #
+    # ==== Gradient arguments
+    # Gradient arguments are different for linear and radial gradients. Adding gradient options is optional.
+    #
+    # ===== Linear
+    # Valid values are <tt>[x0, y0, x1, y1]</tt> or <tt>[angle, size]</tt> where size is optional.
+    #
+    # At first place x0, y0 locates first and x1, y1 second points of gradient vector in pixels.
+    #
+    # At second place angle defines direction of gradient from top left corner. Valid values are 0deg - 360deg ("deg" must be included). Default is 0deg meaning East. Angle is counted in clockwise direction.
+    #
+    # Size is a length of gradinet vector. You can use percentage. F.e.: <tt>"50%"</tt>.
+    #
+    # ===== Radial
+    # Valid values are <tt>[x0, y0, r0, x1, y1, r1]</tt> or <tt>[size, angle0, dif0, angle1, dif1]</tt> where size and pair angle1, dif1 are optional.
+    #
+    # At first place x0, y0 locates first and x1, y1 second centers of circles and r0, r1 theirs radius. All in pixels.
+    #
+    # At second place size is a length of gradinet vector. You can use percentage. F.e.: <tt>"50%"</tt>.
+    #
+    # Angle and dif defines direction and value of circle movement. Valid values for angle are 0deg - 360deg ("deg" must be included). Default is 0deg meaning East. Angle is counted in clockwise direction. You can use percentage for dif. F.e.: <tt>"50%"</tt>.
+    #
+    # ==== Stop values
+    # Stop is described as offset value at first position followed by color. The offset specifies the location in % along the gradient's control vector. For color see ColorSource.parse.
+    #
+    # === Example
+    # * <tt>[:gradient, "0%", :red, "100%", :blue]</tt> will create linear gradient red at left side and blue at right side
+    # * <tt>[:gradient, "0%", 1, 0, 0, "100%", 0, 0, 1]</tt> same as above
+    # * <tt>[:gradient_reflect, "50%", "0%", 1, 0, 0, "100%", 0, 0, 1]</tt> will create gradient red at left side, blue in middle and red at right side
+    # * <tt>[:gradient, "90deg", "0%", :red, "100%", :blue]</tt> will create linear gradient red at top and blue at bottom
+    # * <tt>[:gradient_radial, "0%", :red, "100%", :blue]</tt> will create radial gradient red in center and blue at sides
+    # * <tt>[:gradient_radial, 100, "0%", :red, "100%", :blue]</tt> will create radial gradient red in center and blue 100px from center
+    # * <tt>[:gradient_radial, "225deg", "50%", "0%", :red, "100%", :blue]</tt>will create radial gradient red in left top quadrant and blue at sides
+    #
+    def self.parse(source)
+      if source[0].to_s.downcase =~ /\Agradient_?(radial)?_?(reflect|repeat)?\Z/
+        ext = $2
+        source.shift
+        unless $1 #linear
+          if source[0..3].join(' ') =~ /\A(\d+) (\d+) (\d+) (\d+)\Z/ # x0, y0, x1, y1
+            args = [$1, $2, $3, $4].map(&:to_i)
+            source.shift 4
+          else # angle deg, [size (%)]
+            args = [0, 1.0]
+            if source.first.to_s =~ /\A\d+deg\Z/ #angle
+              args[0] = source.first.to_i
+              source.shift
+            end
+            if source.first.to_s =~ /\A\d+\Z/ #size
+              args[1] = source.first.to_i
+              source.shift
+            end
+            if source[1].to_s =~ /\A\d+%\Z/ && source.first.to_s =~ /\A(\d+)%\Z/ # size
+              args[1] = $1.to_f/100.0
+              source.shift
+            end
+          end
+          object = new :linear, ext, *args
+        else #radial
+          # Args => [size (%),] [angle1 deg, dif1 (%), [angle2 deg, dif2 (%)]]
+          if source[0..5].join(' ') =~ /\A(\d+) (\d+) (\d+) (\d+) (\d+) (\d+)\Z/ # x0, y0, d0, x1, y1, d1
+            args = [$1, $2, $3, $4, $5, $6].map(&:to_i)
+            source.shift 6
+          else
+            args = [1.0, 0, 0, 0, 0]
+            if source.first.to_s =~ /\A\d+\Z/ #size
+              args[0] = source.first.to_i
+              source.shift
+            end
+            if source[1].to_s =~ /\A\d+(%|deg)\Z/ && source.first.to_s =~ /\A(\d+)%\Z/ # size
+              args[0] = $1.to_f/100.0
+              source.shift
+            end
+            if source[0..1].join(' ') =~ /\A(\d+)deg (\d+)(%)?\Z/ # angle1 deg, dif1 (%)
+              args[1] = $1.to_i
+              args[2] = $3 ? $2.to_f/100.0 : $2.to_i
+              source.shift 2
+            end
+            if source[0..1].join(' ') =~ /\A(\d+)deg (\d+)(%)?\Z/ # angle2 deg, dif2 (%)
+              args[3] = $1.to_i
+              args[4] = $3 ? $2.to_f/100.0 : $2.to_i
+              source.shift 2
+            end
+          end
+          object = new :radial, ext, *args
+        end
+        stops = []
+        source.each do |i|
+          if i.to_s =~ /(\d+)%/
+            stops << [$1.to_f/100.0]
+          else
+            stops.last << i if stops.last
+          end
+        end
+        stops.each do |stop|
+          color = ColorSource.parse(stop[1..-1])
+          return nil unless color
+          object.send :add_stop, stop.first, color
+        end
+        object
+      end
+    end
+
+    # Sets color as source to given context
+    def set_source(context, x, y, w, h)
+      case @type.to_sym
+      when :linear
+        if @args.size == 4
+          pattern = Cairo::LinearPattern.new @args[0]+x, @args[1]+y, @args[2]+x, @args[3]+y
+        else
+          if @args[1].class == Float
+            deg = (@args[0]%180+180)%180
+            deg = 180 - deg if deg > 90
+            deg *= Math::PI / 180
+            deg -= Math.atan(h.to_f/w.to_f)
+            dist = Math.sqrt(w**2 + h**2) * Math.cos(deg)
+            dist = dist * @args[1]
+          else
+            dist = @args[1]
+          end
+          pattern = Cairo::LinearPattern.new *[x, y, degree_dist(@args[0], dist, x, y)].flatten
+        end
+      when :radial
+        if @args.size == 6
+          pattern = Cairo::RadialPattern.new @args[0]+x, @args[1]+y, @args[2], @args[3]+x, @args[4]+y, @args[5]
+        else
+          x, y = [x+w/2, y+h/2]
+          radius = @args[0].class == Float ? Math.sqrt(w**2 + h**2)/2 * @args[0] : @args[0]
+          dist1 = @args[2].class == Float ? radius * @args[2] : @args[2]
+          dist2 = @args[4].class == Float ? radius * @args[4] : @args[4]
+          pattern = Cairo::RadialPattern.new *[degree_dist(@args[1], dist1, x, y), 0, degree_dist(@args[3], dist2, x, y), radius].flatten
+        end
+      end
+      pattern.set_extend({
+        :pad => Cairo::EXTEND_NONE,
+        :repeat => Cairo::EXTEND_REPEAT,
+        :reflect => Cairo::EXTEND_REFLECT
+      }[@ext.to_sym]) unless @type.to_sym == :radial && @ext.to_sym == :pad
+      @stops.each do |stop|
+        pattern.add_color_stop_rgba *stop
+      end
+
+      context.set_source pattern
+      context.fill_preserve
+    end
+
+    private
+    def add_stop(offset, color_source)
+      @stops << [offset, color_source.red, color_source.green, color_source.blue, color_source.alpha]
+    end
+
+    def degree_dist(deg, dist, x, y)
+      return [x, y] if dist.zero?
+      deg = (deg%360+360)%360
+      return [x+dist, y] if deg == 0
+      return [x, y+dist] if deg == 90
+      return [x-dist, y] if deg == 180
+      return [x, y-dist] if deg == 270
+      deg *= Math::PI / 180
+      return [x+dist*Math.cos(deg), y+dist*Math.sin(deg)]
+    end
+  end
+end