diff options
Diffstat (limited to 'js/dojo-1.6/dojox/timing/Sequence.xd.js')
| -rw-r--r-- | js/dojo-1.6/dojox/timing/Sequence.xd.js | 162 |
1 files changed, 162 insertions, 0 deletions
diff --git a/js/dojo-1.6/dojox/timing/Sequence.xd.js b/js/dojo-1.6/dojox/timing/Sequence.xd.js new file mode 100644 index 0000000..3b270af --- /dev/null +++ b/js/dojo-1.6/dojox/timing/Sequence.xd.js @@ -0,0 +1,162 @@ +/*
+ Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+ Available via Academic Free License >= 2.1 OR the modified BSD license.
+ see: http://dojotoolkit.org/license for details
+*/
+
+
+dojo._xdResourceLoaded(function(dojo, dijit, dojox){
+return {depends: [["provide", "dojox.timing.Sequence"]],
+defineResource: function(dojo, dijit, dojox){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");
+
+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();
+ }
+ }
+ },
+
+ goOn: function(){
+ // summary: This method just provides a hook from the outside, so that
+ // an interrupted sequence can be continued.
+ if(this._goOnPause){
+ setTimeout(dojo.hitch(this, "_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;
+ }
+
+});
+
+}
+
+}};});
|