/**
                             * Adds support for the <code>transform</code> attribute of <code>Graphic</code>
                             * <code>Shape</code> instances.
                             * @module anim
                             * @submodule anim-shape-transform
                             * @deprecated Use anim-shape instead.
                             */
                            /**
                             * Adds support for the <code>transform</code> and <code>fill</code> attributes of <code>Graphic</code>
                             * and <code>Shape</code> instances. The <code>anim-shape</code> submodule can be used for all animations
                             * involving <code>Graphic</code> <code>Shape</code> attributes.
                             *
                             * @module anim
                             * @submodule anim-shape
                             */
                                var NUM = Number,
                                TO,
                                TOSTRING,
                                COLOR = "color",
                                STOPS = "stops",
                                TYPE = "type",
                                GETUPDATEDSTOPS = function(anim, from, to, elapsed, duration, fn)
                                {
                                    var i = 0,
                                        getUpdatedColorValue = Y.Anim.getUpdatedColorValue,
                                        toStop,
                                        fromStop,
                                        prop,
                                        len = to.length,
                                        stops = [],
                                        stop;
                                    for(; i < len; i = i + 1)
                                    {
                                        toStop = to[i];
                                        fromStop = from[i];
                                        stop = {};
                                        for(prop in toStop)
                                        {
                                            if(toStop.hasOwnProperty(prop))
                                            {
                                                if(prop === COLOR)
                                                {
                                                    stop[prop] = Y.Color.toHex(getUpdatedColorValue(
                                                        Y.Color.toHex(fromStop[prop]),
                                                        Y.Color.toHex(toStop[prop]),
                                                        elapsed,
                                                        duration,
                                                        fn
                                                    ));
                                                }
                                                else
                                                {
                                                    stop[prop] = fn(elapsed, NUM(fromStop[prop]), NUM(toStop[prop]) - NUM(fromStop[prop]), duration);
                                                }
                                            }
                                        }
                                        stops.push(stop);
                                    }
                                    return stops;
                                },
                                FILLANDSTROKEBEHAVIOR = {
                                    set: function(anim, att, from, to, elapsed, duration, fn) {
                                        var i,
                                        updated = {},
                                        getUpdatedColorValue = Y.Anim.getUpdatedColorValue,
                                        getUpdatedStops = GETUPDATEDSTOPS;
                                        for(i in to)
                                        {
                                            if(to.hasOwnProperty(i) && i !== TYPE)
                                            {
                                                switch(i)
                                                {
                                                    case COLOR :
                                                        updated[i] = getUpdatedColorValue(from[i], to[i], elapsed, duration, fn);
                                                    break;
                                                    case STOPS :
                                                        updated[i] = getUpdatedStops(anim, from[i], to[i], elapsed, duration, fn);
                                                    break;
                                                    default :
                                                        updated[i] = fn(elapsed, NUM(from[i]), NUM(to[i]) - NUM(from[i]), duration);
                                                    break;
                                                }
                                            }
                                        }
                                        anim._node.set(att, updated);
                                    }
                                };
                                Y.Anim.behaviors.fill = FILLANDSTROKEBEHAVIOR;
                                Y.Anim.behaviors.stroke = FILLANDSTROKEBEHAVIOR;
                            
                                Y.Anim.behaviors.transform = {
                                    set: function(anim, att, from, to, elapsed, duration, fn) {
                                        var node = anim._node,
                                            transform = "",
                                            transformTo,
                                            transformFrom,
                                            toArgs,
                                            fromArgs,
                                            i = 0,
                                            j,
                                            argLen,
                                            len;
                                        to = TO;
                                        len = TO.length;
                                        for(; i < len; ++i)
                                        {
                                            toArgs = to[i].concat();
                                            fromArgs = from[i].concat();
                                            transformTo = toArgs.shift();
                                            transformFrom = fromArgs.shift();
                                            argLen = toArgs.length;
                                            transform += transformTo + "(";
                                            for(j = 0; j < argLen; ++j)
                                            {
                                                transform += fn(elapsed, NUM(fromArgs[j]), NUM(toArgs[j]) - NUM(fromArgs[j]), duration);
                                                if(j < argLen - 1)
                                                {
                                                    transform += ", ";
                                                }
                                            }
                                            transform += ");";
                                        }
                                        if(transform)
                                        {
                                            node.set('transform', transform);
                                        }
                                        node._transform = TOSTRING;
                                    },
                            
                                    get: function(anim) {
                                        var node = anim._node,
                                            fromMatrix = node.matrix,
                                            toString = anim.get("to").transform,
                                            fromString = node.get("transform"),
                                            toArray = Y.MatrixUtil.getTransformArray(toString),
                                            fromArray = fromString ? Y.MatrixUtil.getTransformArray(fromString) : null,
                                            toMatrix,
                                            i,
                                            len,
                                            transformFunction,
                                            from;
                                        if(toArray)
                                        {
                                            if(!fromArray || fromArray.length < 1)
                                            {
                                                fromArray = [];
                                                len = toArray.length;
                                                for(i = 0; i < len; ++i)
                                                {
                                                    transformFunction = toArray[i][0];
                                                    fromArray[i] = Y.MatrixUtil.getTransformFunctionArray(transformFunction);
                                                }
                                                TO = toArray;
                                                from = fromArray;
                                            }
                                            else if(Y.MatrixUtil.compareTransformSequence(toArray, fromArray))
                                            {
                                                TO = toArray;
                                                from = fromArray;
                                            }
                                            else
                                            {
                                                toMatrix = new Y.Matrix();
                                                len = toArray.length;
                                                for(i = 0; i < len; ++i)
                                                {
                                                    transformFunction = toArray[i].shift();
                                                    transformFunction = transformFunction === "matrix" ? "multiply" : transformFunction;
                                                    toMatrix[transformFunction].apply(toMatrix, toArray[i]);
                                                }
                            
                                                TO = toMatrix.decompose();
                                                from = fromMatrix.decompose();
                                            }
                                        }
                                        TOSTRING = toString;
                                        return from;
                                    }
                                };