Subversion Repositories Applications.papyrus

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(djConfig["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());

}