module Magick::RVG::Transformable

Transformations are operations on the coordinate system. All the transformations defined within a container (an RVG object or a group) are applied before drawing any shapes or text. All transformations are applied in the order they were defined. Note: This means that

g.translate(10,20).scale(2)

is not the same as

g.scale(2).translate(10,20)

Public Class Methods

new(*args, &block) click to toggle source
Calls superclass method
# File lib/rvg/transformable.rb, line 34
def initialize(*args, &block)
    super()
    @transforms = Transforms.new
end

Public Instance Methods

matrix(sx, rx, ry, sy, tx, ty) { |self| ... } click to toggle source

Applies the transformation matrix [sx, rx, ry, sy, tx, ty]

# File lib/rvg/transformable.rb, line 42
def matrix(sx, rx, ry, sy, tx, ty)
    begin
        @transforms << [:affine, [Float(sx), Float(rx), Float(ry), Float(sy), Float(tx), Float(ty)]]
    rescue ArgumentError
        raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{rx.class}, #{ry.class}, #{sy.class}, #{sx.class}, #{sx.class}, #{tx.class}, #{ty.class})"
    end
    yield(self) if block_given?
    self
end
rotate(angle, *args) { |self| ... } click to toggle source

This method can take either of two argument lists:

rotate(angle)

rotate by angle degrees

rotate(angle, cx, cy)

rotate by angle degrees about the point [cx, cy].

# File lib/rvg/transformable.rb, line 83
def rotate(angle, *args)
    begin
        case args.length
            when 0
                @transforms << [:rotate, [Float(angle)]]
            when 2
                cx, cy = Float(args[0]), Float(args[1])
                @transforms << [:translate, [cx, cy]]
                @transforms << [:rotate, [angle]]
                @transforms << [:translate, [-cx, -cy]]
            else
                fail ArgumentError, "wrong number of arguments (#{args.length} for 1 or 3)"
        end
    rescue ArgumentError
        raise ArgumentError, "arguments must be convertable to float (got #{[angle, *args].collect {|a| a.class}.join(', ')})"
    end
    yield(self) if block_given?
    self
end
scale(sx, sy=nil) { |self| ... } click to toggle source

Multiply the x-coordinates by sx and the y-coordinates by sy. If sy is omitted it defaults to sx.

# File lib/rvg/transformable.rb, line 68
def scale(sx, sy=nil)
    sy ||= sx
    begin
        @transforms << [:scale, [Float(sx), Float(sy)]]
    rescue ArgumentError
        raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{sy.class})"
    end
    yield(self) if block_given?
    self
end
skewX(angle) { |self| ... } click to toggle source

Skew the X-axis by angle degrees.

# File lib/rvg/transformable.rb, line 104
def skewX(angle)
    begin
        @transforms << [:skewx, [Float(angle)]]
    rescue ArgumentError
        raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
    end
    yield(self) if block_given?
    self
end
skewY(angle) { |self| ... } click to toggle source

Skew the Y-axis by angle degrees.

# File lib/rvg/transformable.rb, line 115
def skewY(angle)
    begin
        @transforms << [:skewy, [Float(angle)]]
    rescue ArgumentError
        raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
    end
    yield(self) if block_given?
    self
end
translate(tx, ty=nil) { |self| ... } click to toggle source

Add tx to all x-coordinates and ty to all y-coordinates. If ty is omitted it defaults to tx.

# File lib/rvg/transformable.rb, line 55
def translate(tx, ty=nil)
    ty ||= tx
    begin
        @transforms << [:translate, [Float(tx), Float(ty)]]
    rescue ArgumentError
        raise ArgumentError, "arguments must be convertable to float (got #{tx.class}, #{ty.class})"
    end
    yield(self) if block_given?
    self
end

Private Instance Methods

add_transform_primitives(gc) click to toggle source

Apply transforms in the same order they were specified!

# File lib/rvg/transformable.rb, line 30
def add_transform_primitives(gc)
    @transforms.each { |transform| gc.__send__(transform[0], *transform[1]) }
end