class DYI::Animation::TransformAnimation

Class representing an animation of transform @attr [Symbol] type a type of transform, either ‘translate’, ‘scale’,

'rotate', 'skewX' or 'skewY'

@attr [Numeric|Array] from a starting value of the animation @attr [Numeric|Array] to a ending value of the animation

Constants

IMPLEMENT_ATTRIBUTES
VALID_VALUES

Public Class Methods

new(shape, type, options) click to toggle source
Calls superclass method DYI::Animation::Base::new
# File lib/dyi/animation.rb, line 417
def initialize(shape, type, options)
  @type = type
  super(shape, options)
end
rotate(shape, options) click to toggle source
# File lib/dyi/animation.rb, line 436
def rotate(shape, options)
  new(shape, :rotate, options)
end
scale(shape, options) click to toggle source
# File lib/dyi/animation.rb, line 432
def scale(shape, options)
  new(shape, :scale, options)
end
skew_x(shape, options) click to toggle source
# File lib/dyi/animation.rb, line 440
def skew_x(shape, options)
  new(shape, :skewX, options)
end
skew_y(shape, options) click to toggle source
# File lib/dyi/animation.rb, line 444
def skew_y(shape, options)
  new(shape, :skewY, options)
end
translate(shape, options) click to toggle source
# File lib/dyi/animation.rb, line 428
def translate(shape, options)
  new(shape, :translate, options)
end

Public Instance Methods

from=(value) click to toggle source
# File lib/dyi/animation.rb, line 270
def from=(value)
  @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
end
relays=(values) click to toggle source

@attribute relays @return [Array] @since 1.3.0

# File lib/dyi/animation.rb, line 367
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
end
to=(value) click to toggle source
# File lib/dyi/animation.rb, line 320
def to=(value)
  @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
end
write_as(formatter, shape, io=$>) click to toggle source
# File lib/dyi/animation.rb, line 422
def write_as(formatter, shape, io=$>)
  formatter.write_transform_animation(self, shape, io,
                                      &(block_given? ? Proc.new : nil))
end