Page MenuHomeCode
Files F948742

Sequence.js
No OneTemporary
Actions

Sequence.js
View Options

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;
}
});
}

File Metadata

Mime Type
text/plain
Expires
Sat, Apr 26, 18:55 (1 d, 11 h ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
26318
Default Alt Text
Sequence.js (4 KB)

Event Timeline