dyi 1.2.1 → 1.3.0

data/examples/pie_chart.rb

@@ -3,25 +3,32 @@
 require 'rubygems'
 require 'dyi'
 
-chart = DYI::Chart::PieChart.new 400,500,
-  :data_label_format => "{?name}\n{?percent}",
-  :data_label_font => {:size => 20, :font_family=>'Serif'},
-  :represent_3d => true,
-  :show_data_label => false,
-  :show_baloon => true,
-  :baloon_opacity => 0.3,
-  :baloon_format => "{?name}\n{?percent}",
-#  :moved_elements => [0.2,nil,nil,0.5],
-#  :chart_colors => ['blue', 'red', 'yellow', 'green'],
-  :_3d_settings => {:dy => 30},
-  :background_image_opacity => 0.1,
-  :legend_format => "{?name}\t{!e}{?value:#,##0}\t{!e}({?percent:0.00%})",
-  :chart_stroke_color => 'white'
+# Nominal GDP of Asian Countries (2010)
+chart_data = [['China', 5878],
+              ['Japan', 5459],
+              ['India', 1538],
+              ['South Koria', 1007],
+              ['Other Countries', 2863]]
+reader = DYI::Chart::ArrayReader.read(chart_data, :schema => [:name, :value])
 
-reader = DYI::Chart::ExcelReader.read('data/currency.xlsx', :schema => [:name, :value])
-chart.load_data reader
+# Creates the Pie Chart
+chart = DYI::Chart::PieChart.new(500,240,
+          :center_point => [130, 130],
+          :legend_point => [250, 80],
+          :chart_radius_x => 100,
+          :show_data_label => false,
+          :represent_3d => true,
+          :_3d_settings => {:dy => 20},
+          :baloon_format => "{?name}\n{?value:#,0}",
+          :legend_format => "{?name}\t{!e}{?value:#,0}\t{!e}({?percent:0.0%})",
+          :chart_stroke_color => 'white',
+          :background_image_file => {:path => 'external_files/asian_map.png', :content_type => 'image/png'},
+          :background_image_opacity => 0.3)
+chart.load_data(reader)
+DYI::Drawing::Pen.black_pen.draw_text(chart.canvas,
+          [250, 40],
+          'Nominal GDP of Asian Countries (2010)',
+          :text_anchor => 'middle',
+          :font => {:font_family => 'sans-serif', :size => '14pt', :weight => 'bold'})
 
-chart.save 'output/pie_chart.svg'
-chart.save 'output/pie_chart.xaml', :xaml
-chart.save 'output/pie_chart.eps', :eps
-chart.save 'output/pie_chart.emf', :emf if defined? IRONRUBY_VERSION
+chart.save('output/pie_chart.svg')

data/examples/rainbow.rb

@@ -0,0 +1,31 @@
+# -*- encoding: UTF-8 -*-
+
+require 'rubygems'
+require 'dyi'
+
+canvas = DYI::Canvas.new(500, 280)
+canvas.title = 'Rainbow'
+canvas.description = 'This image is a sample of DYI which uses a radial gradient.'
+
+logo_container = DYI::Shape::ShapeGroup.draw_on(canvas)
+DYI.logo(:canvas => logo_container,
+         :width => 287,
+         :height => 163,
+         :top => 100,
+         :left => 160)
+
+gradient = DYI::Drawing::ColorEffect::RadialGradient.new([1,1.2], 1.2)
+gradient.add_color_opacity(0.72, 'violet', 0)
+gradient.add_color_opacity(0.74, 'violet', 0.5)
+gradient.add_color_opacity(0.78, 'indigo', 0.5)
+gradient.add_color_opacity(0.82, 'blue', 0.5)
+gradient.add_color_opacity(0.86, 'green', 0.5)
+gradient.add_color_opacity(0.9, 'yellow', 0.5)
+gradient.add_color_opacity(0.94, 'orange', 0.5)
+gradient.add_color_opacity(0.98, 'red', 0.5)
+gradient.add_color_opacity(1, 'red', 0)
+
+pen = DYI::Drawing::Brush.new(:color => gradient)
+pen.draw_rectangle(canvas, [0,0], 500, 280)
+
+canvas.save('output/rainbow.svg')

data/examples/simple_animation.rb

@@ -0,0 +1,28 @@
+# -*- encoding: UTF-8 -*-
+
+require 'rubygems'
+require 'dyi'
+
+canvas = DYI::Canvas.new(400, 300)
+
+rect = DYI::Drawing::Brush.new(:color=>'#51ADE2').draw_rectangle(canvas, [10,10], 300, 200)
+rect.add_painting_animation(:from => {:fill => '#51ADE2'},
+                            :to => {:fill => 'red'},
+                            :duration => 3,
+                            :begin_event => DYI::Event.mouseover(rect),
+                            :end_event => DYI::Event.mouseout(rect),
+                            :fill => 'freeze')
+text = DYI::Drawing::Brush.new.draw_text(canvas,
+                                         [100,250],
+                                         'click me!',
+                                         :show_border => true,
+                                         :border_color=>'#325BA8',
+                                         :padding => 8,
+                                         :border_rx => 10,
+                                         :border_width => 3,
+                                         :background_color=>'#A5C7F8')
+rect.add_painting_animation(:to => {:fill => 'green'},
+                            :begin_event => DYI::Event.click(text),
+                            :fill => 'freeze')
+
+canvas.save('output/simple_animation.svg')

data/examples/thumbnail.rb

@@ -0,0 +1,73 @@
+# -*- encoding: UTF-8 -*-
+
+require 'rubygems'
+require 'dyi'
+
+include DYI::Script::EcmaScript::DomLevel2
+
+canvas = DYI::Canvas.new(500, 280)
+
+base_pen = DYI::Drawing::Pen.new(:font => {:size => '14pt'})
+
+symbols = []
+
+symbol = DYI::Shape::GraphicalTemplate.new(400,170)
+pen = DYI::Drawing::Pen.new(:color => 'blue', :width => 10)
+pen.draw_rectangle(symbol, [50, 40], 300, 90, :rx => 30)
+base_pen.draw_text(symbol, [200, 25], 'Rounded Rectangle', :text_anchor => 'middle')
+base_pen.draw_text(symbol, [200, 160], 'page 1', :text_anchor => 'middle')
+symbols << symbol
+
+symbol = DYI::Shape::GraphicalTemplate.new(400,170)
+pen = DYI::Drawing::Pen.new(:color => 'red', :width => 10)
+pen.draw_ellipse(symbol, [200, 85], 150, 45)
+base_pen.draw_text(symbol, [200, 25], 'Ellipse', :text_anchor => 'middle')
+base_pen.draw_text(symbol, [200, 160], 'page 2', :text_anchor => 'middle')
+symbols << symbol
+
+symbol = DYI::Shape::GraphicalTemplate.new(400,170)
+pen = DYI::Drawing::Pen.new(:color => 'green', :width => 10)
+pen.draw_polygon(symbol, [[200, 40], [150, 60], [150, 110], [200, 130], [250, 110], [250, 60]])
+base_pen.draw_text(symbol, [200, 25], 'Hexagon', :text_anchor => 'middle')
+base_pen.draw_text(symbol, [200, 160], 'page 3', :text_anchor => 'middle')
+symbols << symbol
+
+symbol = DYI::Shape::GraphicalTemplate.new(400,170)
+pen = DYI::Drawing::Pen.new(:color => 'orange', :width => 10)
+pen.draw_path(symbol, [100, 85]){|path|
+  path.quadratic_curve_to([150, 0], [200, 85], [300, 85])
+}
+base_pen.draw_text(symbol, [200, 25], 'Wave', :text_anchor => 'middle')
+base_pen.draw_text(symbol, [200, 160], 'page 4', :text_anchor => 'middle')
+symbols << symbol
+
+symbol = DYI::Shape::GraphicalTemplate.new(400,170)
+brush = DYI::Drawing::Brush.cyan_brush
+brush.draw_circle(symbol, [200, 85], 50).add_transform_animation(:translate,
+      :from => [-100, 0],
+      :relays => [[100,0]],
+      :to => [-100, 0],
+      :relayTimes => [0.5],
+      :duration => 3,
+      :calc_mode => 'spline',
+      :key_splines => [0.6, 0, 0.4, 1, 0.6, 0, 0.4, 1],
+      :repeat_count => 0)
+base_pen.draw_text(symbol, [200, 25], 'Animation Circle', :text_anchor => 'middle')
+base_pen.draw_text(symbol, [200, 160], 'page 5', :text_anchor => 'middle')
+symbols << symbol
+
+current_use = symbols.first.instantiate_on(canvas, [50, 10], :width => 400, :height => 170)
+base_pen.draw_rectangle(canvas, [50, 10], 400, 170)
+
+symbols.each_with_index do |symbol, i|
+  group = DYI::Shape::ShapeGroup.draw_on(canvas)
+  rect = base_pen.draw_rectangle(group, [105  + i * 60, 190], 50, 50)
+  use = symbol.instantiate_on(group, [105  + i * 60, 190], :width => 50, :height => 50)
+  group.skew_y(35, [105 + i * 60, 190])
+  rect.add_event_listener(:click, <<-SCRIPT)
+    var currentUse = #{get_element(current_use)};
+    currentUse.setAttributeNS('http://www.w3.org/1999/xlink', 'href', "##{symbol.id = canvas.publish_shape_id}");
+  SCRIPT
+end
+
+canvas.save('output/thumbnail.svg')

data/examples/xslt.rb

@@ -0,0 +1,9 @@
+# -*- encoding: UTF-8 -*-
+
+require 'rubygems'
+require 'dyi'
+
+canvas = DYI.logo
+canvas.reference_stylesheet_file('../external_files/xslt.xsl', 'text/xsl')
+
+canvas.save('output/xslt.svg')

data/lib/dyi.rb

@@ -24,11 +24,80 @@
 module DYI
 
   # DYI program version
-  VERSION = '1.2.1'
+  VERSION = '1.3.0'
 
   # URL of DYI Project
   # @since 0.0.2
-  URL = 'http://sourceforge.net/projects/dyi/'
+  URL = 'http://open-dyi.org/'
+
+  class << self
+
+    # Draw a DYI's logo.
+    # @option options [Canvas, Shape::ShapeGroup] :canvas a container element
+    #   of the DYI's logo
+    # @option options [Length] :width a width of the logo mark
+    # @option options [Length] :height a height of the logo mark
+    # @option options [Length] :left a x-coordinate of a left edge of the logo
+    #   mark
+    # @option options [Length] :top a y-coordinate of a top edge of the logo
+    #   mark
+    # @return [Canvas, Shape::ShapeGroup] a new Canvas object which logo mark is
+    #   draw on if :canvas option is given, otherwise a new Shape::Group object
+    #   which logo mark is on.
+    # @since 1.3.0
+    def logo(options = {})
+      width = Length.new(options[:width] || 287)
+      height = Length.new(options[:height] || 163)
+      if options[:canvas]
+        canvas = Shape::ShapeGroup.draw_on(options[:canvas])
+        canvas.scale(width / 287, height / 163)
+        canvas.translate(options[:left] || 0, options[:top] || 0)
+      else
+        canvas = Canvas.new(width, height)
+      end
+      Drawing::Brush.new(:color=>'#51ADE2').draw_closed_path(canvas, [287,0]) {|path|
+        path.rline_to([0,162.637], [-39.41,0])
+        path.rcurve_to([0,-5.191], [-1.729,-107.272], [-1.729,-107.272], [-2.594,102.295], [-2.813,107.272])
+        path.rline_to([-3.246,0])
+        path.rcurve_to([0,-4.977], [-1.728,-107.272], [-1.728,-107.272], [-2.595,102.513], [-2.595,107.272])
+        path.rline_to([-3.245, 0])
+        path.rcurve_to([-0.215,-4.54], [-1.729,-107.272], [-1.729,-107.272], [-2.813,102.943], [-2.813,107.272])
+        path.rline_to([-3.46, 0], [0, -162.637])
+      }
+      Drawing::Brush.new(:color=>'#325BA8').draw_closed_path(canvas, [258.471,0]) {|path|
+        path.rline_to([-52.793,97.971], [-0.078,64.666], [-57.073,0], [-0.071,-65.106], [-49.789,-97.531],[92.148,0])
+        path.rcurve_to([-12.327,25.52], [-35.9,74.829], [-35.9,74.829], [27.034,-50.391], [40.013,-74.829])
+        path.rline_to([4.322,0])
+        path.rcurve_to([-11.461,24.221], [-37.414,78.289], [-37.414,78.289], [30.206,-55.798], [41.955,-78.289])
+        path.rline_to([4.111,0])
+        path.rcurve_to([-10.599,21.844], [-39.146,81.75], [-39.146,81.75], [33.306,-62.069], [43.687,-81.75])
+      }
+      Drawing::Brush.new(:color=>'#51ADE2', :rule => 'evenodd').draw_closed_path(canvas, [149.875,78.938]){|path|
+        path.rcurve_to([0,13.193], [-2.379,25.52], [-7.353,36.552], [-11.894,20.114], [-20.112,27.249])
+        path.rline_to([-0.216, 0])
+        path.rcurve_to([-9.517,7.786], [-20.113,12.76], [-31.144,15.787], [-22.276,4.111], [-33.954,4.111], [-22.276,-0.651], [-28.98,-1.514])
+        path.rline_to([-20.113, -2.815])
+        path.rcurve_to([12.327,-1.077], [34.17,-4.322], [54.5,-15.784])
+        path.rcurve_to([14.921,-8.219], [27.034,-21.627], [32.441,-33.524], [6.271,-20.543], [6.487,-20.543])
+        path.rcurve_to([-0.217,0], [-1.08,8.649], [-7.137,20.114], [-18.167,24.654], [-32.873,32.003])
+        path.rcurve_to([-25.953,13.411], [-54.067,13.84], [-61.421,13.84])
+        path.rline_to([0, -3.241])
+        path.rcurve_to([7.137,-0.215], [34.82,-1.729], [58.827,-15.355])
+        path.rcurve_to([29.844,-14.921], [35.9,-49.526], [35.035,-48.661])
+        path.rcurve_to([0.866,-0.866], [-6.487,33.303], [-36.117,46.714])
+        path.rcurve_to([-23.791,12.327], [-50.608,12.976], [-57.745,12.976])
+        path.rline_to([0, -3.246])
+        path.rcurve_to([6.92,-0.211], [33.307,-1.942], [55.15,-14.488])
+        path.rcurve_to([26.168,-13.193], [31.358,-41.955], [31.358,-43.254])
+        path.rcurve_to([0,1.299], [-6.487,29.631], [-32.44,41.311])
+        path.rcurve_to([-21.628,11.242], [-47.148,12.108], [-54.068,12.108])
+        path.rline_to([0,-132.574])
+        path.rline_to([27.25, -4.326])
+        path.rcurve_to([10.381,-1.731], [22.06,-2.378], [34.604,-2.378], [21.194,0.864], [31.36,3.677], [19.464,6.92], [27.25,12.975], [16.868,16.006], [21.843,26.819], [7.568,22.924], [7.568,35.467])
+      }
+      canvas
+    end
+  end
 end
 
 %w(

data/lib/dyi/animation.rb

@@ -32,31 +32,103 @@ module DYI
 
     # Base class for animation classes.
     # @abstract
-    # @attr [Object] from a starting value of the animation
-    # @attr [Object] to a ending value of the animation
-    # @attr [Numeric] duration a simple duration of the animation
-    # @attr [Numeric] begin_offset a offset that determine the animation begin
-    # @attr [Event] begin_event an event that determine the element begin
-    # @attr [Numeric] end_offset a offset that determine the animation end
-    # @attr [Event] end_event an event that determine the element end
-    # @attr [String] fill the effect of animation when the animation is over,
-    #       either 'freeze' or 'remove'
-    # @attr [String] additive a value that means whether or not the animation is
-    #       additive, either 'replace' or 'sum'
-    # @attr [String] restart a value for the restart, either 'always',
-    #       'whenNotActive'or 'never'
     class Base
+
       IMPLEMENT_ATTRIBUTES = [:from, :to, :duration, :begin_offset,
                               :begin_event, :end_offset, :end_event, :fill,
-                              :additive, :restart]
+                              :additive, :restart, :relays, :relay_times,
+                              :calc_mode, :repeat_count, :key_splines]
       VALID_VALUES = {
         :fill => ['freeze','remove'],
         :additive => ['replace', 'sum'],
-        :restart => ['always', 'whenNotActive', 'never']
+        :restart => ['always', 'whenNotActive', 'never'],
+        :calc_mode => ['discrete', 'linear', 'paced', 'spline']
       }
 
+      # @attribute from
+      # Returns a starting value of the animation.
+      # @return [Object] a starting value of the animation
+      #+++
+      # @attribute to
+      # Returns a ending value of the animation.
+      # @return [Object] a ending value of the animation
+      #+++
+      # @attribute duration
+      # Returns a simple duration of the animation.
+      # @return [Numeric] a simple duration of the animation
+      #+++
+      # @attribute begin_offset
+      # Returns a offset that determine the animation begin.
+      # @return [Numeric] a offset that determine the animation begin
+      #+++
+      # @attribute begin_event
+      # Returns an event that determine the element begin.
+      # @return [Event] an event that determine the element begin
+      #+++
+      # @attribute end_offset
+      # Returns a offset that determine the animation end
+      # @return [Numeric] a offset that determine the animation end
+      #+++
+      # @attribute end_event
+      # Returns an event that determine the element end.
+      # @return [Event] an event that determine the element end
+      #+++
+      # @attribute fill
+      # Returns the effect of animation when the animation is over, either
+      # <tt>'freeze'</tt> or <tt>'remove'</tt>
+      # @return [String] the effect of animation
+      #+++
+      # @attribute additive
+      # Returns a value that means whether or not the animation is additive,
+      # either <tt>'replace'</tt> or <tt>'sum'</tt>
+      # @return [String] either <tt>'replace'</tt> or <tt>'sum'</tt>
+      #+++
+      # @attribute restart
+      # Returns a value for the restart, either <tt>'always'</tt>,
+      # <tt>'whenNotActive'</tt> or <tt>'never'</tt>
+      # @return [String] either <tt>'always'</tt>, <tt>'whenNotActive'</tt> or
+      #   <tt>'never'</tt>
+      #+++
+      # @attribute relays
+      # @return [Array]
+      # @since 1.3.0
+      #+++
+      # @attribute relay_times
+      # @return [Array<#to_f>]
+      # @since 1.3.0
+      #+++
+      # @attribute calc_mode
+      # @return [String]
+      # @since 1.3.0
+      #+++
+      # @attribute repeat_count
+      # @return [Numeric]
+      # @since 1.3.0
+      #+++
+      # @attribute key_splines
+      # @return [Array<#to_f>]
+      # @since 1.3.0
       attr_reader *IMPLEMENT_ATTRIBUTES
 
+      # Returns whether the animation is cumulative.
+      # @return [Boolean] true if the animation is cumulative, false otherwise
+      # @since 1.3.0
+      def accumulate?
+        @accumulate ? true : false
+      end
+
+      # @attribute [w] fill
+      # @param [String] value the value of attribute fill
+      #+++
+      # @attribute [w] additive
+      # @param [String] value the value of attribute additive
+      #+++
+      # @attribute [w] restart
+      # @param [String] value the value of attribute restart
+      #+++
+      # @attribute [w] calc_mode
+      # @param [String] value the value of attribute calc_mode
+      # @since 1.3.0
       VALID_VALUES.each do |attr, valid_values|
         define_method("#{attr.to_s}=") {|value|
           if (value = value.to_s).size == 0
@@ -71,11 +143,18 @@ module DYI
       end
 
       def duration=(duration)
-        @duration = duration
+        @duration = duration.to_f
+      end
+
+      # @attribute [w] repeat_count
+      # @param [#to_f] count
+      # @since 1.3.0
+      def repeat_count=(count)
+        @repeat_count = count.to_f
       end
 
       def begin_offset=(offset)
-        @begin_offset = offset
+        @begin_offset = offset.to_f
       end
 
       def begin_event=(event)
@@ -83,13 +162,33 @@ module DYI
       end
 
       def end_offset=(offset)
-        @end_offset = offset
+        @end_offset = offset.to_f
       end
 
       def end_event=(event)
         @end_event = event
       end
 
+      # @attribute [w] relays
+      # @param [Array<#to_f>] times
+      # @since 1.3.0
+      def relay_times=(times)
+        @relay_times = times.map{|time| time.to_f}
+      end
+
+      # @attribute [w] key_splines
+      # @param [Array<#to_f>] keys
+      # @since 1.3.0
+      def key_splines=(keys)
+        @key_splines = keys.map{|time| time.to_f}
+      end
+
+      # @param [Boolean] value
+      # @since 1.3.0
+      def accumulate=(value)
+        @accumulate = value
+      end
+
       # @param [Shape::Base] shape a target element for an animation
       # @param [Hash] options an option for an animation
       def initialize(shape, options)
@@ -100,14 +199,17 @@ module DYI
             __send__("#{attr}=", value)
           end
         end
+        @relays ||= []
+        @relay_times ||= []
       end
     end
 
     # Class representing an animation of a painting
-    # @attr [Painting] from a starting value of the animation
-    # @attr [Painting] to a ending value of the animation
     class PaintingAnimation < Base
 
+      # @attribute [rw] from
+      # Returns a starting value of the animation.
+      # @return [Painting] a starting value of the animation
       def from=(painting)
         @from = painting && DYI::Painting.new(painting)
       end
@@ -116,11 +218,19 @@ module DYI
         @to = DYI::Painting.new(painting)
       end
 
+      # @attribute relays
+      # @return [Array<Painting>]
+      # @since 1.3.0
+      def relays=(paintings)
+        @relays = paintings.map{|painting| DYI::Painting.new(painting)}
+      end
+
       def animation_attributes
         DYI::Painting::IMPLEMENT_ATTRIBUTES.inject({}) do |result, attr|
           from_attr, to_attr = @from && @from.__send__(attr), @to.__send__(attr)
-          if to_attr && from_attr != to_attr
-            result[attr] = [from_attr, to_attr]
+          relay_attrs = @relays.map{|relay| relay.__send__(attr)}
+          if to_attr && (from_attr != to_attr || relay_attrs.any?{|relay_attr| from_attr != relay_attrs || relay_attr != to_attr})
+            result[attr] = [from_attr].push(*relay_attrs).push(to_attr)
           end
           result
         end
@@ -159,69 +269,150 @@ module DYI
       end
 
       def from=(value)
-        case type
-        when :translate
-          case value
-          when Array
-            case value.size
-              when 2 then @from = value.map{|v| v.to_f}
-              else raise ArgumentError, "illegal size of Array: #{value.size}"
+        @from =
+            case type
+            when :translate
+              case value
+              when Array
+                case value.size
+                  when 2 then @from = value.map{|v| v.to_f}
+                  else raise ArgumentError, "illegal size of Array: #{value.size}"
+                end
+              when Numeric, Length
+                [value.to_f, 0]
+              when nil
+                nil
+              else
+                raise TypeError, "illegal argument: #{value}"
+              end
+            when :scale
+              case value
+              when Array
+                case value.size
+                  when 2 then @from = value.map{|v| v.to_f}
+                  else raise ArgumentError, "illegal size of Array: #{value.size}"
+                end
+              when Numeric
+                [value.to_f, value.to_f]
+              when nil
+                nil
+              else
+                raise TypeError, "illegal argument: #{value}"
+              end
+            when :rotate
+              case value
+              when Array
+                case value.size
+                  when 3 then value.map{|v| v.to_f}
+                  else raise ArgumentError, "illegal size of Array: #{value.size}"
+                end
+              when Numeric
+                value.to_f
+              when nil
+                nil
+              else
+                raise TypeError, "illegal argument: #{value}"
+              end
+            when :skewX, :skewY
+              value.nil? ? nil : value.to_f
             end
-          when Numeric, Length
-            @from = [value.to_f, 0]
-          when nil
-            @from = nil
-          else
-            raise TypeError, "illegal argument: #{value}"
-          end
-        when :scale
-          case value
-          when Array
-            case value.size
-              when 2 then @from = value.map{|v| v.to_f}
-              else raise ArgumentError, "illegal size of Array: #{value.size}"
-            end
-          when Numeric
-            @from = [value.to_f, value.to_f]
-          when nil
-            @from = nil
-          else
-            raise TypeError, "illegal argument: #{value}"
-          end
-        when :rotate, :skewX, :skewY
-          @from = value.nil? ? nil : value.to_f
-        end
       end
 
       def to=(value)
-        case type
-        when :translate
-          case value
-          when Array
-            case value.size
-              when 2 then @to = value.map{|v| v.to_f}
-              else raise ArgumentError, "illegal size of Array: #{value.size}"
+        @to =
+            case type
+            when :translate
+              case value
+              when Array
+                case value.size
+                  when 2 then value.map{|v| v.to_f}
+                  else raise ArgumentError, "illegal size of Array: #{value.size}"
+                end
+              when Numeric, Length
+                @to = [value.to_f, 0]
+              else
+                raise TypeError, "illegal argument: #{value}"
+              end
+            when :scale
+              case value
+              when Array
+                case value.size
+                  when 2 then value.map{|v| v.to_f}
+                  else raise ArgumentError, "illegal size of Array: #{value.size}"
+                end
+              when Numeric
+                [value.to_f, value.to_f]
+              else
+                raise TypeError, "illegal argument: #{value}"
+              end
+            when :rotate
+              case value
+              when Array
+                case value.size
+                  when 3 then value.map{|v| v.to_f}
+                  else raise ArgumentError, "illegal size of Array: #{value.size}"
+                end
+              when Numeric
+                value.to_f
+              else
+                raise TypeError, "illegal argument: #{value}"
+              end
+            when :skewX, :skewY
+              value.to_f
             end
-          when Numeric, Length
-            @to = [value.to_f, 0]
-          else
-            raise TypeError, "illegal argument: #{value}"
-          end
-        when :scale
-          case value
-          when Array
-            case value.size
-              when 2 then @to = value.map{|v| v.to_f}
-              else raise ArgumentError, "illegal size of Array: #{value.size}"
+      end
+
+      # @attribute relays
+      # @return [Array]
+      # @since 1.3.0
+      def relays=(values)
+        @relays =
+            case type
+            when :translate
+              values.map do |value|
+                case value
+                when Array
+                  case value.size
+                    when 2 then value.map{|v| v.to_f}
+                    else raise ArgumentError, "illegal size of Array: #{value.size}"
+                  end
+                when Numeric, Length
+                  [value.to_f, 0]
+                else
+                  raise TypeError, "illegal argument: #{value}"
+                end
+              end
+            when :scale
+              values.map do |value|
+                case value
+                when Array
+                  case value.size
+                    when 2 then value.map{|v| v.to_f}
+                    else raise ArgumentError, "illegal size of Array: #{value.size}"
+                  end
+                when Numeric
+                  [value.to_f, value.to_f]
+                else
+                  raise TypeError, "illegal argument: #{value}"
+                end
+              end
+            when :rotate
+              values.map do |value|
+                case value
+                when Array
+                  case value.size
+                    when 3 then value.map{|v| v.to_f}
+                    else raise ArgumentError, "illegal size of Array: #{value.size}"
+                  end
+                when Numeric
+                  value.to_f
+                else
+                  raise TypeError, "illegal argument: #{value}"
+                end
+              end
+            when :skewX, :skewY
+              values.map{|value| value.to_f}
             end
-          when Numeric
-            @to = [value.to_f, value.to_f]
-          else
-            raise TypeError, "illegal argument: #{value}"
-          end
-        when :rotate, :skewX, :skewY
-          @to = value.to_f
-        end
       end
 
       def initialize(shape, type, options)