Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojo._base.fx"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojo._base.fx"] = true;
dojo.provide("dojo._base.fx");
dojo.require("dojo._base.Color");
dojo.require("dojo._base.connect");
dojo.require("dojo._base.declare");
dojo.require("dojo._base.lang");
dojo.require("dojo._base.html");

/*
        Animation losely package based on Dan Pupius' work, contributed under CLA: 
                http://pupius.co.uk/js/Toolkit.Drawing.js
*/

dojo._Line = function(/*int*/ start, /*int*/ end){
        //      summary:
        //              dojo._Line is the object used to generate values from a start value
        //              to an end value
        //      start: int
        //              Beginning value for range
        //      end: int
        //              Ending value for range
        this.start = start;
        this.end = end;
        this.getValue = function(/*float*/ n){
                //      summary: returns the point on the line
                //      n: a floating point number greater than 0 and less than 1
                return ((this.end - this.start) * n) + this.start; // Decimal
        }
}

dojo.declare("dojo._Animation", null, {
        //      summary
        //              A generic animation object that fires callbacks into it's handlers
        //              object at various states
        //
        constructor: function(/*Object*/ args){
                dojo.mixin(this, args);
                if(dojo.isArray(this.curve)){
                        /* curve: Array
                                pId: a */
                        this.curve = new dojo._Line(this.curve[0], this.curve[1]);
                }
        },
        
        // duration: Integer
        //      The time in milliseonds the animation will take to run
        duration: 1000,

/*=====
        // curve: dojo._Line||Array
        //      A two element array of start and end values, or a dojo._Line instance to be
        //      used in the Animation. 
        curve: null,

        // easing: Function
        //      A Function to adjust the acceleration (or deceleration) of the progress 
        //      across a dojo._Line
        easing: null,
=====*/

        // repeat: Integer
        //      The number of times to loop the animation
        repeat: 0,

        // rate: Integer
        //      the time in milliseconds to wait before advancing to next frame 
        //      (used as a fps timer: rate/1000 = fps)
        rate: 10 /* 100 fps */,

/*===== 
        // delay: Integer
        //      The time in milliseconds to wait before starting animation after it has been .play()'ed
        delay: null,

        // events
        //
        // beforeBegin: Event
        //      Synthetic event fired before a dojo._Animation begins playing (synhcronous)
        beforeBegin: null,

        // onBegin: Event
        //      Synthetic event fired as a dojo._Animation begins playing (useful?)
        onBegin: null,

        // onAnimate: Event
        //      Synthetic event fired at each interval of a dojo._Animation
        onAnimate: null,

        // onEnd: Event
        //      Synthetic event fired after the final frame of a dojo._Animation
        onEnd: null,

        // ???
        onPlay: null,

        // onPause: Event
        //      Synthetic event fired when a dojo._Animation is paused
        onPause: null,

        // onStop: Event
        //      Synthetic event fires when a dojo._Animation is stopped
        onStop: null,

=====*/

        _percent: 0,
        _startRepeatCount: 0,

        fire: function(/*Event*/ evt, /*Array?*/ args){
                //      summary:
                //              Convenience function.  Fire event "evt" and pass it the
                //              arguments specified in "args".
                //      evt:
                //              The event to fire.
                //      args:
                //              The arguments to pass to the event.
                if(this[evt]){
                        this[evt].apply(this, args||[]);
                }
                return this; // dojo._Animation
        },

        play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
                // summary:
                //              Start the animation.
                // delay:
                //              How many milliseconds to delay before starting.
                // gotoStart:
                //              If true, starts the animation from the beginning; otherwise,
                //              starts it from its current position.
                var _t = this;
                if(gotoStart){
                        _t._stopTimer();
                        _t._active = _t._paused = false;
                        _t._percent = 0;
                }else if(_t._active && !_t._paused){
                        return _t; // dojo._Animation
                }

                _t.fire("beforeBegin");

                var d = delay||_t.delay;
                var _p = dojo.hitch(_t, "_play", gotoStart);
                if(d > 0){
                        setTimeout(_p, d);
                        return _t; // dojo._Animation
                }
                _p();
                return _t;
        },

        _play: function(gotoStart){
                var _t = this;
                _t._startTime = new Date().valueOf();
                if(_t._paused){
                        _t._startTime -= _t.duration * _t._percent;
                }
                _t._endTime = _t._startTime + _t.duration;

                _t._active = true;
                _t._paused = false;

                var value = _t.curve.getValue(_t._percent);
                if(!_t._percent){
                        if(!_t._startRepeatCount){
                                _t._startRepeatCount = _t.repeat;
                        }
                        _t.fire("onBegin", [value]);
                }

                _t.fire("onPlay", [value]);

                _t._cycle();
                return _t; // dojo._Animation
        },

        pause: function(){
                // summary: Pauses a running animation.
                this._stopTimer();
                if(!this._active){ return this; /*dojo._Animation*/}
                this._paused = true;
                this.fire("onPause", [this.curve.getValue(this._percent)]);
                return this; // dojo._Animation
        },

        gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){
                //      summary:
                //              Sets the progress of the animation.
                //      percent:
                //              A percentage in decimal notation (between and including 0.0 and 1.0).
                //      andPlay:
                //              If true, play the animation after setting the progress.
                this._stopTimer();
                this._active = this._paused = true;
                this._percent = percent;
                if(andPlay){ this.play(); }
                return this; // dojo._Animation
        },

        stop: function(/*boolean?*/ gotoEnd){
                // summary: Stops a running animation.
                // gotoEnd: If true, the animation will end.
                if(!this._timer){ return; }
                this._stopTimer();
                if(gotoEnd){
                        this._percent = 1;
                }
                this.fire("onStop", [this.curve.getValue(this._percent)]);
                this._active = this._paused = false;
                return this; // dojo._Animation
        },

        status: function(){
                // summary: Returns a string token representation of the status of
                //                      the animation, one of: "paused", "playing", "stopped"
                if(this._active){
                        return this._paused ? "paused" : "playing"; // String
                }
                return "stopped"; // String
        },

        _cycle: function(){
                var _t = this;
                if(_t._active){
                        var curr = new Date().valueOf();
                        var step = (curr - _t._startTime) / (_t._endTime - _t._startTime);

                        if(step >= 1){
                                step = 1;
                        }
                        _t._percent = step;

                        // Perform easing
                        if(_t.easing){
                                step = _t.easing(step);
                        }

                        _t.fire("onAnimate", [_t.curve.getValue(step)]);

                        if(step < 1){
                                _t._startTimer();
                        }else{
                                _t._active = false;

                                if(_t.repeat > 0){
                                        _t.repeat--;
                                        _t.play(null, true);
                                }else if(_t.repeat == -1){
                                        _t.play(null, true);
                                }else{
                                        if(_t._startRepeatCount){
                                                _t.repeat = _t._startRepeatCount;
                                                _t._startRepeatCount = 0;
                                        }
                                }
                                _t._percent = 0;
                                _t.fire("onEnd");
                        }
                }
                return _t; // dojo._Animation
        }
});

(function(){
        var d = dojo;
        var ctr = 0;
        var _globalTimerList = [];
        var runner = {
                run: function(){}
        };
        var timer = null;
        dojo._Animation.prototype._startTimer = function(){
                // this._timer = setTimeout(dojo.hitch(this, "_cycle"), this.rate);
                if(!this._timer){
                        this._timer = dojo.connect(runner, "run", this, "_cycle");
                        ctr++;
                }
                if(!timer){
                        timer = setInterval(dojo.hitch(runner, "run"), this.rate);
                }
        };

        dojo._Animation.prototype._stopTimer = function(){
                dojo.disconnect(this._timer);
                this._timer = null;
                ctr--;
                if(!ctr){
                        clearInterval(timer);
                        timer = null;
                }
        };

        var _makeFadeable = (d.isIE) ? function(node){
                // only set the zoom if the "tickle" value would be the same as the
                // default
                var ns = node.style;
                if(!ns.zoom.length && d.style(node, "zoom") == "normal"){
                        // make sure the node "hasLayout"
                        // NOTE: this has been tested with larger and smaller user-set text
                        // sizes and works fine
                        ns.zoom = "1";
                        // node.style.zoom = "normal";
                }
                // don't set the width to auto if it didn't already cascade that way.
                // We don't want to f anyones designs
                if(!ns.width.length && d.style(node, "width") == "auto"){
                        ns.width = "auto";
                }
        } : function(){};

        dojo._fade = function(/*Object*/ args){
                //      summary: 
                //              Returns an animation that will fade the node defined by
                //              args.node from the start to end values passed (args.start
                //              args.end) (end is mandatory, start is optional)

                args.node = d.byId(args.node);
                var fArgs = d.mixin({ properties: {} }, args);
                var props = (fArgs.properties.opacity = {});
                props.start = !("start" in fArgs) ?
                        function(){ return Number(d.style(fArgs.node, "opacity")); } : fArgs.start;
                props.end = fArgs.end;

                var anim = d.animateProperty(fArgs);
                d.connect(anim, "beforeBegin", d.partial(_makeFadeable, fArgs.node));

                return anim; // dojo._Animation
        }

        /*=====
        dojo.__fadeArgs = function(kwArgs){
                //      duration: Integer?
                //              Duration of the animation in milliseconds.
                // easing: Function?
                //              An easing function.
        }
        =====*/

        dojo.fadeIn = function(/*dojo.__fadeArgs*/ args){
                // summary: 
                //              Returns an animation that will fade node defined in 'args' from
                //              its current opacity to fully opaque.
                return d._fade(d.mixin({ end: 1 }, args)); // dojo._Animation
        }

        dojo.fadeOut = function(/*dojo.__fadeArgs*/  args){
                // summary: 
                //              Returns an animation that will fade node defined in 'args'
                //              from its current opacity to fully transparent.
                return d._fade(d.mixin({ end: 0 }, args)); // dojo._Animation
        }

        dojo._defaultEasing = function(/*Decimal?*/ n){
                // summary: The default easing function for dojo._Animation(s)
                return 0.5 + ((Math.sin((n + 1.5) * Math.PI))/2);
        }

        var PropLine = function(properties){
                this._properties = properties;
                for(var p in properties){
                        var prop = properties[p];
                        if(prop.start instanceof d.Color){
                                // create a reusable temp color object to keep intermediate results
                                prop.tempColor = new d.Color();
                        }
                }
                this.getValue = function(r){
                        var ret = {};
                        for(var p in this._properties){
                                var prop = this._properties[p];
                                var start = prop.start;
                                if(start instanceof d.Color){
                                        ret[p] = d.blendColors(start, prop.end, r, prop.tempColor).toCss();
                                }else if(!d.isArray(start)){
                                        ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units||"px" : "");
                                }
                        }
                        return ret;
                }
        }

        dojo.animateProperty = function(/*Object*/ args){
                //      summary: 
                //              Returns an animation that will transition the properties of
                //              node defined in 'args' depending how they are defined in
                //              'args.properties'
                //
                // description:
                //              The foundation of most dojo.fx animations, dojo.AnimateProperty
                //              will take an object of "properties" corresponding to style
                //              properties, and animate them in parallel over a set duration.
                //      
                //              args.node can be a String or a DomNode reference
                //      
                //      example:
                //      |       dojo.animateProperty({ node: node, duration:2000,
                //      |               properties: {
                //      |                       width: { start: '200', end: '400', unit:"px" },
                //      |                       height: { start:'200', end: '400', unit:"px" },
                //      |                       paddingTop: { start:'5', end:'50', unit:"px" } 
                //      |               }
                //      |       }).play();
                //

                args.node = d.byId(args.node);
                if(!args.easing){ args.easing = d._defaultEasing; }

                var anim = new d._Animation(args);
                d.connect(anim, "beforeBegin", anim, function(){
                        var pm = {};
                        for(var p in this.properties){
                                // Make shallow copy of properties into pm because we overwrite some values below.
                                // In particular if start/end are functions we don't want to overwrite them or
                                // the functions won't be called if the animation is reused.
                                var prop = (pm[p] = d.mixin({}, this.properties[p]));

                                if(d.isFunction(prop.start)){
                                        prop.start = prop.start();
                                }
                                if(d.isFunction(prop.end)){
                                        prop.end = prop.end();
                                }

                                var isColor = (p.toLowerCase().indexOf("color") >= 0);
                                function getStyle(node, p){
                                        // dojo.style(node, "height") can return "auto" or "" on IE; this is more reliable:
                                        var v = ({height: node.offsetHeight, width: node.offsetWidth})[p];
                                        if(v !== undefined){ return v; }
                                        v = d.style(node, p);
                                        return (p=="opacity") ? Number(v) : parseFloat(v);
                                }
                                if(!("end" in prop)){
                                        prop.end = getStyle(this.node, p);
                                }else if(!("start" in prop)){
                                        prop.start = getStyle(this.node, p);
                                }

                                if(isColor){
                                        // console.debug("it's a color!");
                                        prop.start = new d.Color(prop.start);
                                        prop.end = new d.Color(prop.end);
                                }else{
                                        prop.start = (p == "opacity") ? Number(prop.start) : parseFloat(prop.start);
                                }
                                // console.debug("start:", prop.start);
                                // console.debug("end:", prop.end);
                        }
                        this.curve = new PropLine(pm);
                });
                d.connect(anim, "onAnimate", anim, function(propValues){
                        // try{
                        for(var s in propValues){
                                // console.debug(s, propValues[s], this.node.style[s]);
                                d.style(this.node, s, propValues[s]);
                                // this.node.style[s] = propValues[s];
                        }
                        // }catch(e){ console.debug(dojo.toJson(e)); }
                });
                return anim; // dojo._Animation
        }
})();

}