Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.timing.Sequence"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.timing.Sequence"] = true;
dojo.provide("dojox.timing.Sequence");
dojo.experimental("dojox.timing.Sequence"); // in case it gets moved/renamed somewhere soon

dojo.declare("dojox.timing.Sequence",null,{
        // summary: 
        //      This class provides functionality to really sequentialize 
        //      function calls. You need to provide a list of functions and 
        //      some parameters for each (like: pauseBefore) and they will
        //      be run one after another. This can be very useful for slideshows
        //      or alike things.
        //
        // description: 
        //      This array will contain the sequence defines resolved, so that
        //      ie. repeat:10 will result in 10 elements in the sequence, so 
        //      the repeat handling is easier and we don't need to handle that
        //      many extra cases. Also the doneFunction, if given is added at the
        //      end of the resolved-sequences.

        // _defsResolved: Array
        //      The resolved sequence, for easier handling.
        _defsResolved: [],

        // This is the time to wait before goOn() calls _go(), which 
        // mostly results from a pauseAfter for a function that returned
        // false and is later continued by the external goOn() call.
        // The time to wait needs to be waited in goOn() where the
        // sequence is continued.

        // _goOnPause: Integer
        //      The pause to wait before really going on.
        _goOnPause: 0,

        _running: false,
        
        go: function(/* Array */defs, /* function|Array? */doneFunction){
                // summary:
                //
                // defs: Array
                //      the sequence of actions
                // doneFunction: Function|Array?
                //      The function to call when done
                this._running = true;
                var self = this;        
                dojo.forEach(defs, function(cur){
                        if(cur.repeat > 1){
                                var repeat = cur.repeat;
                                for(var j=0; j<repeat ;j++){
                                        cur.repeat = 1;
                                        self._defsResolved.push(cur);
                                }
                        }else{
                                self._defsResolved.push(cur);                           
                        }
                });
                var last = defs[defs.length-1];
                if (doneFunction) {
                        self._defsResolved.push({func: doneFunction});
                }
                // stop the sequence, this actually just sets this._running to false
                self._defsResolved.push({func: [this.stop, this]});
                this._curId = 0;
                this._go();
        },

        _go: function(){
                // summary: Execute one task of this._defsResolved.
                //
                // if _running was set to false stop the sequence, this is the
                // case when i.e. stop() was called.
                if(!this._running){
                        return;
                }
                var cur = this._defsResolved[this._curId];
                this._curId += 1;
                // create the function to call, the func property might be an array, which means
                // [function, context, parameter1, parameter2, ...]
                function resolveAndCallFunc(func) {
                        var ret = null;
                        if(dojo.isArray(func)){
                                // Two elements might only be given when the function+context
                                // is given, this is nice for using this, ie: [this.func, this]
                                if(func.length>2){
                                        ret = func[0].apply(func[1], func.slice(2));
                                }else{
                                        ret = func[0].apply(func[1]);
                                }
                        }else{
                                ret = func();
                        }
                        return ret;
                }

                if(this._curId >= this._defsResolved.length){
                        resolveAndCallFunc(cur.func); // call the last function, since it is the doneFunction we dont need to handle pause stuff
                        // don't go on and call this._go() again, we are done
                        return;
                }
                var self = this;
                if(cur.pauseAfter){
                        if(resolveAndCallFunc(cur.func)!==false){
                                window.setTimeout(function() {self._go()}, cur.pauseAfter);
                        }else{
                                this._goOnPause = cur.pauseAfter;
                        }
                }else if(cur.pauseBefore){
                        var x = function(){
                                if(resolveAndCallFunc(cur.func)!==false){
                                        self._go()
                                }
                        };
                        window.setTimeout(x, cur.pauseBefore);
                }else{
                        if(resolveAndCallFunc(cur.func)!==false){
                                this._go();
                        }
                }
        },

        goOn: function(){
                // summary: This method just provides a hook from the outside, so that
                // an interrupted sequence can be continued.
                if(this._goOnPause){
                        var self = this;
                        setTimeout(function(){ self._go() }, this._goOnPause);
                        this._goOnPause = 0; // reset it, so if the next one doesnt set it we dont use the old pause
                }else{ this._go(); }
        },
        
        stop: function(){
                // summary:  Stop the currently running sequence.
                // description: 
                //      This can only interrupt the sequence not the last function that
                //      had been started. If the last function was i.e. a slideshow
                //      that is handled inside a function that you have given as
                //      one sequence item it cant be stopped, since it is not controlled
                //      by this object here. In this case it would be smarter to 
                //      run the slideshow using a sequence object so you can also stop 
                //      it using this method.
                this._running = false;
        }
}); 

}