| New file |
|---|
| 0,0 → 1,145 |
|---|
| 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; |
| } |
| }); |
| |
| } |