New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit

git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f

1 files changed, 145 insertions, 0 deletions

diff --git a/includes/js/dojox/timing/Sequence.js b/includes/js/dojox/timing/Sequence.js
new file mode 100644
index 0000000..4dc4bdb
--- /dev/null
+++ b/includes/js/dojox/timing/Sequence.js
@@ -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;
+	}
+}); 
+
+}