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

diff --git a/includes/js/dojox/storage/WhatWGStorageProvider.js b/includes/js/dojox/storage/WhatWGStorageProvider.js
new file mode 100644
index 0000000..4bd4c22
--- /dev/null
+++ b/includes/js/dojox/storage/WhatWGStorageProvider.js
@@ -0,0 +1,278 @@
+if(!dojo._hasResource["dojox.storage.WhatWGStorageProvider"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.storage.WhatWGStorageProvider"] = true;
+dojo.provide("dojox.storage.WhatWGStorageProvider");
+dojo.require("dojox.storage.Provider");
+dojo.require("dojox.storage.manager");
+
+dojo.declare("dojox.storage.WhatWGStorageProvider", [ dojox.storage.Provider ], {
+	// summary:
+	//		Storage provider that uses WHAT Working Group features in Firefox 2 
+	//		to achieve permanent storage.
+	// description: 
+	//		The WHAT WG storage API is documented at 
+	//		http://www.whatwg.org/specs/web-apps/current-work/#scs-client-side
+	//
+	//		You can disable this storage provider with the following djConfig
+	//		variable:
+	//		var djConfig = { disableWhatWGStorage: true };
+	//		
+	//		Authors of this storage provider-	
+	//			JB Boisseau, jb.boisseau@eutech-ssii.com
+	//			Brad Neuberg, bkn3@columbia.edu 
+
+	initialized: false,
+	
+	_domain: null,
+	_available: null,
+	_statusHandler: null,
+	_allNamespaces: null,
+	_storageEventListener: null,
+	
+	initialize: function(){
+		if(dojo.config["disableWhatWGStorage"] == true){
+			return;
+		}
+		
+		// get current domain
+		// see: https://bugzilla.mozilla.org/show_bug.cgi?id=357323
+		this._domain = (location.hostname == "localhost") ? "localhost.localdomain" : location.hostname;
+		// console.debug(this._domain);
+		
+		// indicate that this storage provider is now loaded
+		this.initialized = true;
+		dojox.storage.manager.loaded();	
+	},
+	
+	isAvailable: function(){
+		try{
+			// see: https://bugzilla.mozilla.org/show_bug.cgi?id=357323
+			var myStorage = globalStorage[((location.hostname == "localhost") ? "localhost.localdomain" : location.hostname)];
+		}catch(e){
+			this._available = false;
+			return this._available;
+		}
+		
+		this._available = true;	
+		return this._available;
+	},
+
+	put: function(key, value, resultsHandler, namespace){
+		if(this.isValidKey(key) == false){
+			throw new Error("Invalid key given: " + key);
+		}
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		// get our full key name, which is namespace + key
+		key = this.getFullKey(key, namespace);	
+		
+		this._statusHandler = resultsHandler;
+		
+		// serialize the value;
+		// handle strings differently so they have better performance
+		if(dojo.isString(value)){
+			value = "string:" + value;
+		}else{
+			value = dojo.toJson(value);
+		}
+		
+		// register for successful storage events.
+		var storageListener = dojo.hitch(this, function(evt){
+			// remove any old storage event listener we might have added
+			// to the window on old put() requests; Firefox has a bug
+			// where it can occassionaly go into infinite loops calling
+			// our storage event listener over and over -- this is a 
+			// workaround
+			// FIXME: Simplify this into a test case and submit it
+			// to Firefox
+			window.removeEventListener("storage", storageListener, false);
+			
+			// indicate we succeeded
+			if(resultsHandler){
+				resultsHandler.call(null, this.SUCCESS, key);
+			}
+		});
+		
+		window.addEventListener("storage", storageListener, false);
+		
+		// try to store the value	
+		try{
+			var myStorage = globalStorage[this._domain];
+			myStorage.setItem(key, value);
+		}catch(e){
+			// indicate we failed
+			this._statusHandler.call(null, this.FAILED, key, e.toString());
+		}
+	},
+
+	get: function(key, namespace){
+		if(this.isValidKey(key) == false){
+			throw new Error("Invalid key given: " + key);
+		}
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		// get our full key name, which is namespace + key
+		key = this.getFullKey(key, namespace);
+		
+		// sometimes, even if a key doesn't exist, Firefox
+		// will return a blank string instead of a null --
+		// this _might_ be due to having underscores in the
+		// keyname, but I am not sure.
+		
+		// FIXME: Simplify this bug into a testcase and
+		// submit it to Firefox
+		var myStorage = globalStorage[this._domain];
+		var results = myStorage.getItem(key);
+		
+		if(results == null || results == ""){
+			return null;
+		}
+		
+		results = results.value;
+		
+		// destringify the content back into a 
+		// real JavaScript object;
+		// handle strings differently so they have better performance
+		if(dojo.isString(results) && (/^string:/.test(results))){
+			results = results.substring("string:".length);
+		}else{
+			results = dojo.fromJson(results);
+		}
+		
+		return results;
+	},
+	
+	getNamespaces: function(){
+		var results = [ this.DEFAULT_NAMESPACE ];
+		
+		// simply enumerate through our array and save any string
+		// that starts with __
+		var found = {};
+		var myStorage = globalStorage[this._domain];
+		var tester = /^__([^_]*)_/;
+		for(var i = 0; i < myStorage.length; i++){
+			var currentKey = myStorage.key(i);
+			if(tester.test(currentKey) == true){
+				var currentNS = currentKey.match(tester)[1];
+				// have we seen this namespace before?
+				if(typeof found[currentNS] == "undefined"){
+					found[currentNS] = true;
+					results.push(currentNS);
+				}
+			}
+		}
+		
+		return results;
+	},
+
+	getKeys: function(namespace){
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		if(this.isValidKey(namespace) == false){
+			throw new Error("Invalid namespace given: " + namespace);
+		}
+		
+		// create a regular expression to test the beginning
+		// of our key names to see if they match our namespace;
+		// if it is the default namespace then test for the presence
+		// of no namespace for compatibility with older versions
+		// of dojox.storage
+		var namespaceTester;
+		if(namespace == this.DEFAULT_NAMESPACE){
+			namespaceTester = new RegExp("^([^_]{2}.*)$");	
+		}else{
+			namespaceTester = new RegExp("^__" + namespace + "_(.*)$");
+		}
+		
+		var myStorage = globalStorage[this._domain];
+		var keysArray = [];
+		for(var i = 0; i < myStorage.length; i++){
+			var currentKey = myStorage.key(i);
+			if(namespaceTester.test(currentKey) == true){
+				// strip off the namespace portion
+				currentKey = currentKey.match(namespaceTester)[1];
+				keysArray.push(currentKey);
+			}
+		}
+		
+		return keysArray;
+	},
+
+	clear: function(namespace){
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		if(this.isValidKey(namespace) == false){
+			throw new Error("Invalid namespace given: " + namespace);
+		}
+		
+		// create a regular expression to test the beginning
+		// of our key names to see if they match our namespace;
+		// if it is the default namespace then test for the presence
+		// of no namespace for compatibility with older versions
+		// of dojox.storage
+		var namespaceTester;
+		if(namespace == this.DEFAULT_NAMESPACE){
+			namespaceTester = new RegExp("^[^_]{2}");	
+		}else{
+			namespaceTester = new RegExp("^__" + namespace + "_");
+		}
+		
+		var myStorage = globalStorage[this._domain];
+		var keys = [];
+		for(var i = 0; i < myStorage.length; i++){
+			if(namespaceTester.test(myStorage.key(i)) == true){
+				keys[keys.length] = myStorage.key(i);
+			}
+		}
+		
+		dojo.forEach(keys, dojo.hitch(myStorage, "removeItem"));
+	},
+	
+	remove: function(key, namespace){
+		// get our full key name, which is namespace + key
+		key = this.getFullKey(key, namespace);
+		
+		var myStorage = globalStorage[this._domain];
+		myStorage.removeItem(key);
+	},
+	
+	isPermanent: function(){
+		return true;
+	},
+
+	getMaximumSize: function(){
+		return this.SIZE_NO_LIMIT;
+	},
+
+	hasSettingsUI: function(){
+		return false;
+	},
+	
+	showSettingsUI: function(){
+		throw new Error(this.declaredClass + " does not support a storage settings user-interface");
+	},
+	
+	hideSettingsUI: function(){
+		throw new Error(this.declaredClass + " does not support a storage settings user-interface");
+	},
+	
+	getFullKey: function(key, namespace){
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		if(this.isValidKey(namespace) == false){
+			throw new Error("Invalid namespace given: " + namespace);
+		}
+		
+		// don't append a namespace string for the default namespace,
+		// for compatibility with older versions of dojox.storage
+		if(namespace == this.DEFAULT_NAMESPACE){
+			return key;
+		}else{
+			return "__" + namespace + "_" + key;
+		}
+	}
+});
+
+dojox.storage.manager.register("dojox.storage.WhatWGStorageProvider", 
+								new dojox.storage.WhatWGStorageProvider());
+
+}