source: [view]
dojo.provide("dojox.timing.Sequence");
dojo.experimental("dojox.timing.Sequence");
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,
constructor: function(){
this._defsResolved = [];
},
go: function(/* Array */defs, /* Function|Array? */doneFunction){
// summary: Run the passed sequence definition
//
// defs: Array
// The sequence of actions
// doneFunction: Function|Array?
// The function to call when done
this._running = true;
dojo.forEach(defs, function(cur){
if(cur.repeat > 1){
var repeat = cur.repeat;
for(var j = 0; j < repeat; j++){
cur.repeat = 1;
this._defsResolved.push(cur);
}
}else{
this._defsResolved.push(cur);
}
}, this);
var last = defs[defs.length - 1];
if(doneFunction){
this._defsResolved.push({ func: doneFunction });
}
// stop the sequence, this actually just sets this._running to false
this._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;
}
if(cur.pauseAfter){
if(resolveAndCallFunc(cur.func) !== false){
setTimeout(dojo.hitch(this, "_go"), cur.pauseAfter);
}else{
this._goOnPause = cur.pauseAfter;
}
}else if(cur.pauseBefore){
var x = dojo.hitch(this,function(){
if(resolveAndCallFunc(cur.func) !== false){
this._go()
}
});
setTimeout(x, cur.pauseBefore);
}else{
if(resolveAndCallFunc(cur.func) !== false){
this._go();
}
}