Minor fix: Remove DOJO library (60Mo) replaced by link to Google CDN (online DOJO library)

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

1 files changed, 0 insertions, 145 deletions

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