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, 454 insertions, 0 deletions

diff --git a/includes/js/dojox/off/files.js b/includes/js/dojox/off/files.js
new file mode 100644
index 0000000..6c19ea0
--- /dev/null
+++ b/includes/js/dojox/off/files.js
@@ -0,0 +1,454 @@
+if(!dojo._hasResource["dojox.off.files"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.off.files"] = true;
+dojo.provide("dojox.off.files");
+
+// Author: Brad Neuberg, bkn3@columbia.edu, http://codinginparadise.org
+
+// summary:
+//	Helps maintain resources that should be
+//	available offline, such as CSS files.
+// description:
+//	dojox.off.files makes it easy to indicate
+//	what resources should be available offline,
+//	such as CSS files, JavaScript, HTML, etc.
+dojox.off.files = {
+	// versionURL: String
+	//	An optional file, that if present, records the version
+	//	of our bundle of files to make available offline. If this
+	//	file is present, and we are not currently debugging,
+	//	then we only refresh our offline files if the version has
+	//	changed. 
+	versionURL: "version.js",
+	
+	// listOfURLs: Array
+	//	For advanced usage; most developers can ignore this.
+	//	Our list of URLs that will be cached and made available
+	//	offline.
+	listOfURLs: [],
+	
+	// refreshing: boolean
+	//	For advanced usage; most developers can ignore this.
+	//	Whether we are currently in the middle
+	//	of refreshing our list of offline files.
+	refreshing: false,
+
+	_cancelID: null,
+	
+	_error: false,
+	_errorMessages: [],
+	_currentFileIndex: 0,
+	_store: null,
+	_doSlurp: false,
+	
+	slurp: function(){
+		// summary:
+		//	Autoscans the page to find all resources to
+		//	cache. This includes scripts, images, CSS, and hyperlinks
+		//	to pages that are in the same scheme/port/host as this
+		//	page. We also scan the embedded CSS of any stylesheets
+		//	to find @import statements and url()'s.
+		//  You should call this method from the top-level, outside of
+		//	any functions and before the page loads:
+		//
+		//	<script>
+		//		dojo.require("dojox.sql");
+		//		dojo.require("dojox.off");
+		//		dojo.require("dojox.off.ui");
+		//		dojo.require("dojox.off.sync");
+		//
+		//		// configure how we should work offline
+		//
+		//		// set our application name
+		//		dojox.off.ui.appName = "Moxie";
+		//
+		//		// automatically "slurp" the page and
+		//		// capture the resources we need offline
+		//		dojox.off.files.slurp();
+		//
+		// 		// tell Dojo Offline we are ready for it to initialize itself now
+		//		// that we have finished configuring it for our application
+		//		dojox.off.initialize();
+		//	</script>
+		//
+		//	Note that inline styles on elements are not handled (i.e.
+		//	if you somehow have an inline style that uses a URL);
+		//	object and embed tags are not scanned since their format
+		//	differs based on type; and elements created by JavaScript
+		//	after page load are not found. For these you must manually
+		//	add them with a dojox.off.files.cache() method call.
+		
+		// just schedule the slurp once the page is loaded and
+		// Dojo Offline is ready to slurp; dojox.off will call
+		// our _slurp() method before indicating it is finished
+		// loading
+		this._doSlurp = true;
+	},
+	
+	cache: function(urlOrList){ /* void */
+		// summary:
+		//		Caches a file or list of files to be available offline. This
+		//		can either be a full URL, such as http://foobar.com/index.html,
+		//		or a relative URL, such as ../index.html. This URL is not
+		//		actually cached until dojox.off.sync.synchronize() is called.
+		// urlOrList: String or Array[]
+		//		A URL of a file to cache or an Array of Strings of files to
+		//		cache
+		
+		//console.debug("dojox.off.files.cache, urlOrList="+urlOrList);
+		
+		if(dojo.isString(urlOrList)){
+			var url = this._trimAnchor(urlOrList+"");
+			if(!this.isAvailable(url)){ 
+				this.listOfURLs.push(url); 
+			}
+		}else if(urlOrList instanceof dojo._Url){
+			var url = this._trimAnchor(urlOrList.uri);
+			if(!this.isAvailable(url)){ 
+				this.listOfURLs.push(url); 
+			}
+		}else{
+			dojo.forEach(urlOrList, function(url){
+				url = this._trimAnchor(url);
+				if(!this.isAvailable(url)){ 
+					this.listOfURLs.push(url); 
+				}
+			}, this);
+		}
+	},
+	
+	printURLs: function(){
+		// summary:
+		//	A helper function that will dump and print out
+		//	all of the URLs that are cached for offline
+		//	availability. This can help with debugging if you
+		//	are trying to make sure that all of your URLs are
+		//	available offline
+		console.debug("The following URLs are cached for offline use:");
+		dojo.forEach(this.listOfURLs, function(i){
+			console.debug(i);
+		});	
+	},
+	
+	remove: function(url){ /* void */
+		// summary:
+		//		Removes a URL from the list of files to cache.
+		// description:
+		//		Removes a URL from the list of URLs to cache. Note that this
+		//		does not actually remove the file from the offline cache;
+		//		instead, it just prevents us from refreshing this file at a
+		//		later time, so that it will naturally time out and be removed
+		//		from the offline cache
+		// url: String
+		//		The URL to remove
+		for(var i = 0; i < this.listOfURLs.length; i++){
+			if(this.listOfURLs[i] == url){
+				this.listOfURLs = this.listOfURLs.splice(i, 1);
+				break;
+			}
+		}
+	},
+	
+	isAvailable: function(url){ /* boolean */
+		// summary:
+		//		Determines whether the given resource is available offline.
+		// url: String
+		//	The URL to check
+		for(var i = 0; i < this.listOfURLs.length; i++){
+			if(this.listOfURLs[i] == url){
+				return true;
+			}
+		}
+		
+		return false;
+	},
+	
+	refresh: function(callback){ /* void */
+		//console.debug("dojox.off.files.refresh");
+		// summary:
+		//	For advanced usage; most developers can ignore this.
+		//	Refreshes our list of offline resources,
+		//	making them available offline.
+		// callback: Function
+		//	A callback that receives two arguments: whether an error
+		//	occurred, which is a boolean; and an array of error message strings
+		//	with details on errors encountered. If no error occured then message is
+		//	empty array with length 0.
+		try{
+			if(dojo.config.isDebug){
+				this.printURLs();
+			}
+			
+			this.refreshing = true;
+			
+			if(this.versionURL){
+				this._getVersionInfo(function(oldVersion, newVersion, justDebugged){
+					//console.warn("getVersionInfo, oldVersion="+oldVersion+", newVersion="+newVersion
+					//				+ ", justDebugged="+justDebugged+", isDebug="+dojo.config.isDebug);
+					if(dojo.config.isDebug || !newVersion || justDebugged 
+							|| !oldVersion || oldVersion != newVersion){
+						console.warn("Refreshing offline file list");
+						this._doRefresh(callback, newVersion);
+					}else{
+						console.warn("No need to refresh offline file list");
+						callback(false, []);
+					}
+				});
+			}else{
+				console.warn("Refreshing offline file list");
+				this._doRefresh(callback);
+			}
+		}catch(e){
+			this.refreshing = false;
+                       
+			// can't refresh files -- core operation --
+			// fail fast
+			dojox.off.coreOpFailed = true;
+			dojox.off.enabled = false;
+			dojox.off.onFrameworkEvent("coreOperationFailed");
+		}
+	},
+	
+	abortRefresh: function(){
+		// summary:
+		//	For advanced usage; most developers can ignore this.
+		//	Aborts and cancels a refresh.
+		if(!this.refreshing){
+			return;
+		}
+		
+		this._store.abortCapture(this._cancelID);
+		this.refreshing = false;
+	},
+	
+	_slurp: function(){
+		if(!this._doSlurp){
+			return;
+		}
+		
+		var handleUrl = dojo.hitch(this, function(url){
+			if(this._sameLocation(url)){
+				this.cache(url);
+			}
+		});
+		
+		handleUrl(window.location.href);
+		
+		dojo.query("script").forEach(function(i){
+			try{
+				handleUrl(i.getAttribute("src"));
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp 'script' error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		dojo.query("link").forEach(function(i){
+			try{
+				if(!i.getAttribute("rel")
+					|| i.getAttribute("rel").toLowerCase() != "stylesheet"){
+					return;
+				}
+			
+				handleUrl(i.getAttribute("href"));
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp 'link' error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		dojo.query("img").forEach(function(i){
+			try{
+				handleUrl(i.getAttribute("src"));
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp 'img' error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		dojo.query("a").forEach(function(i){
+			try{
+				handleUrl(i.getAttribute("href"));
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp 'a' error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		// FIXME: handle 'object' and 'embed' tag
+		
+		// parse our style sheets for inline URLs and imports
+		dojo.forEach(document.styleSheets, function(sheet){
+			try{
+				if(sheet.cssRules){ // Firefox
+					dojo.forEach(sheet.cssRules, function(rule){
+						var text = rule.cssText;
+						if(text){
+							var matches = text.match(/url\(\s*([^\) ]*)\s*\)/i);
+							if(!matches){
+								return;
+							}
+							
+							for(var i = 1; i < matches.length; i++){
+								handleUrl(matches[i])
+							}
+						}
+					});
+				}else if(sheet.cssText){ // IE
+					var matches;
+					var text = sheet.cssText.toString();
+					// unfortunately, using RegExp.exec seems to be flakey
+					// for looping across multiple lines on IE using the
+					// global flag, so we have to simulate it
+					var lines = text.split(/\f|\r|\n/);
+					for(var i = 0; i < lines.length; i++){
+						matches = lines[i].match(/url\(\s*([^\) ]*)\s*\)/i);
+						if(matches && matches.length){
+							handleUrl(matches[1]);
+						}
+					}
+				}
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp stylesheet parse error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		//this.printURLs();
+	},
+	
+	_sameLocation: function(url){
+		if(!url){ return false; }
+		
+		// filter out anchors
+		if(url.length && url.charAt(0) == "#"){
+			return false;
+		}
+		
+		// FIXME: dojo._Url should be made public;
+		// it's functionality is very useful for
+		// parsing URLs correctly, which is hard to
+		// do right
+		url = new dojo._Url(url);
+		
+		// totally relative -- ../../someFile.html
+		if(!url.scheme && !url.port && !url.host){ 
+			return true;
+		}
+		
+		// scheme relative with port specified -- brad.com:8080
+		if(!url.scheme && url.host && url.port
+				&& window.location.hostname == url.host
+				&& window.location.port == url.port){
+			return true;
+		}
+		
+		// scheme relative with no-port specified -- brad.com
+		if(!url.scheme && url.host && !url.port
+			&& window.location.hostname == url.host
+			&& window.location.port == 80){
+			return true;
+		}
+		
+		// else we have everything
+		return  window.location.protocol == (url.scheme + ":")
+				&& window.location.hostname == url.host
+				&& (window.location.port == url.port || !window.location.port && !url.port);
+	},
+	
+	_trimAnchor: function(url){
+		return url.replace(/\#.*$/, "");
+	},
+	
+	_doRefresh: function(callback, newVersion){
+		// get our local server
+		var localServer;
+		try{
+			localServer = google.gears.factory.create("beta.localserver", "1.0");
+		}catch(exp){
+			dojo.setObject("google.gears.denied", true);
+			dojox.off.onFrameworkEvent("coreOperationFailed");
+			throw "Google Gears must be allowed to run";
+		}
+		
+		var storeName = "dot_store_" 
+							+ window.location.href.replace(/[^0-9A-Za-z_]/g, "_");
+							
+		// clip at 64 characters, the max length of a resource store name
+		if(storeName.length >= 64){
+		  storeName = storeName.substring(0, 63);
+		}
+			
+		// refresh everything by simply removing
+		// any older stores
+		localServer.removeStore(storeName);
+		
+		// open/create the resource store
+		localServer.openStore(storeName);
+		var store = localServer.createStore(storeName);
+		this._store = store;
+
+		// add our list of files to capture
+		var self = this;
+		this._currentFileIndex = 0;
+		this._cancelID = store.capture(this.listOfURLs, function(url, success, captureId){
+			//console.debug("store.capture, url="+url+", success="+success);
+			if(!success && self.refreshing){
+				self._cancelID = null;
+				self.refreshing = false;
+				var errorMsgs = [];
+				errorMsgs.push("Unable to capture: " + url);
+				callback(true, errorMsgs);
+				return;
+			}else if(success){
+				self._currentFileIndex++;
+			}
+			
+			if(success && self._currentFileIndex >= self.listOfURLs.length){
+				self._cancelID = null;
+				self.refreshing = false;
+				if(newVersion){
+					dojox.storage.put("oldVersion", newVersion, null,
+									dojox.off.STORAGE_NAMESPACE);
+				}
+				dojox.storage.put("justDebugged", dojo.config.isDebug, null,
+									dojox.off.STORAGE_NAMESPACE);
+				callback(false, []);
+			}
+		});
+	},
+	
+	_getVersionInfo: function(callback){
+		var justDebugged = dojox.storage.get("justDebugged", 
+									dojox.off.STORAGE_NAMESPACE);
+		var oldVersion = dojox.storage.get("oldVersion",
+									dojox.off.STORAGE_NAMESPACE);
+		var newVersion = null;
+		
+		callback = dojo.hitch(this, callback);
+		
+		dojo.xhrGet({
+				url: this.versionURL + "?browserbust=" + new Date().getTime(),
+				timeout: 5 * 1000,
+				handleAs: "javascript",
+				error: function(err){
+					//console.warn("dojox.off.files._getVersionInfo, err=",err);
+					dojox.storage.remove("oldVersion", dojox.off.STORAGE_NAMESPACE);
+					dojox.storage.remove("justDebugged", dojox.off.STORAGE_NAMESPACE);
+					callback(oldVersion, newVersion, justDebugged);
+				},
+				load: function(data){
+					//console.warn("dojox.off.files._getVersionInfo, load=",data);
+					
+					// some servers incorrectly return 404's
+					// as a real page
+					if(data){
+						newVersion = data;
+					}
+					
+					callback(oldVersion, newVersion, justDebugged);
+				}
+		});
+	}
+}
+
+}