Subversion Repositories Applications.papyrus

dojo.require("dojox.storage");

var TestStorage = {

	currentProvider: "default",

	currentNamespace: dojox.storage.DEFAULT_NAMESPACE,

	initialize: function(){

		//console.debug("test_storage.initialize()");

		// do we even have a storage provider?

		if(dojox.storage.manager.available == false){

			alert("No storage provider is available on this browser");

			return;

		}

		// clear out old values and enable input forms

		dojo.byId("storageNamespace").value = this.currentNamespace;

		dojo.byId("storageNamespace").disabled = false;

		dojo.byId("storageKey").value = "";

		dojo.byId("storageKey").disabled = false;

		dojo.byId("storageValue").value = "";

		dojo.byId("storageValue").disabled = false;

		// write out our available namespaces

		this._printAvailableNamespaces();

		// write out our available keys

		this._printAvailableKeys();

		// initialize our event handlers

		var namespaceDirectory = dojo.byId("namespaceDirectory");

		dojo.connect(namespaceDirectory, "onchange", this, this.namespaceChange);

		var directory = dojo.byId("directory");

		dojo.connect(directory, "onchange", this, this.directoryChange);

		var storageValueElem = dojo.byId("storageValue");

		dojo.connect(storageValueElem, "onkeyup", this, this.printValueSize);

		// make the directory be unselected if the key name field gets focus

		var keyNameField = dojo.byId("storageKey");

		dojo.connect(keyNameField, "onfocus", function(evt){

			directory.selectedIndex = -1;

		});

		// add onclick listeners to all of our buttons

		var buttonContainer = dojo.byId("buttonContainer");

		var currentChild = buttonContainer.firstChild;

		while(currentChild.nextSibling != null){

			if(currentChild.nodeType == 1){

				var buttonName = currentChild.id;

				var functionName = buttonName.match(/^(.*)Button$/)[1];

				dojo.connect(currentChild, "onclick", this, this[functionName]);

				currentChild.disabled = false;

			}

			currentChild = currentChild.nextSibling;

		}

		// print out metadata

		this._printProviderMetadata();

		// disable the configuration button if none is supported for this provider

		if(dojox.storage.hasSettingsUI() == false){

			dojo.byId("configureButton").disabled = true;

		}

	},

	namespaceChange: function(evt){

		var ns = evt.target.value;

		this.currentNamespace = ns;

		// update our available keys

		this._printAvailableKeys();

		// clear out our key and values

		dojo.byId("storageNamespace").value = this.currentNamespace;

		dojo.byId("storageKey").value = "";

		dojo.byId("storageValue").value = "";

	},

	directoryChange: function(evt){

		var key = evt.target.value;

		// add this value into the form

		var keyNameField = dojo.byId("storageKey");

		keyNameField.value = key;

		this._handleLoad(key);

	},

	load: function(evt){

		// cancel the button's default behavior

		evt.preventDefault();

		evt.stopPropagation();

		// get the key to load

		var key = dojo.byId("storageKey").value;

		if(key == null || typeof key == "undefined" || key == ""){

			alert("Please enter a key name");

			return;

		}

		this._handleLoad(key);

	},

	save: function(evt){

		// cancel the button's default behavior

		evt.preventDefault();

		evt.stopPropagation();

		// get the new values

		var key = dojo.byId("storageKey").value;

		var value = dojo.byId("storageValue").value;

		var namespace = dojo.byId("storageNamespace").value;

		if(key == null || typeof key == "undefined" || key == ""){

			alert("Please enter a key name");

			return;

		}

		if(value == null || typeof value == "undefined" || value == ""){

			alert("Please enter a key value");

			return;

		}

		// print out the size of the value

		this.printValueSize();

		// do the save

		this._save(key, value, namespace);

	},

	clearNamespace: function(evt){

		// cancel the button's default behavior

		evt.preventDefault();

		evt.stopPropagation();

		dojox.storage.clear(this.currentNamespace);

		this._printAvailableNamespaces();

		this._printAvailableKeys();

	},

	configure: function(evt){

		// cancel the button's default behavior

		evt.preventDefault();

		evt.stopPropagation();

		if(dojox.storage.hasSettingsUI()){

			// redraw our keys after the dialog is closed, in

			// case they have all been erased

			var self = this;

			dojox.storage.onHideSettingsUI = function(){

				self._printAvailableKeys();

			}

			// show the dialog

			dojox.storage.showSettingsUI();

		}

	},

	remove: function(evt){

		// cancel the button's default behavior

		evt.preventDefault();

		evt.stopPropagation();

		// determine what key to delete; if the directory has a selected value,

		// use that; otherwise, use the key name field

		var directory = dojo.byId("directory");

		var keyNameField = dojo.byId("storageKey");

		var keyValueField = dojo.byId("storageValue");

		var key;

		if(directory.selectedIndex != -1){

			key = directory.value;

			// delete this option

			var options = directory.childNodes;

			for(var i = 0; i < options.length; i++){

				if(options[i].nodeType == 1 &&

					 options[i].value == key){

					directory.removeChild(options[i]);

					break;

				}

			}

		}else{

			key = keyNameField.value;

		}

		keyNameField.value = "";

		keyValueField.value = "";

		// now delete the value

		this._printStatus("Removing '" + key + "'...");

		if(this.currentNamespace == dojox.storage.DEFAULT_NAMESPACE){

			dojox.storage.remove(key);

		}else{

			dojox.storage.remove(key, this.currentNamespace);

		}

		// update our UI

		this._printAvailableNamespaces();

		this._printStatus("Removed '" + key);

	},

	printValueSize: function(){

		var storageValue = dojo.byId("storageValue").value;

		var size = 0;

		if(storageValue != null && typeof storageValue != "undefined"){

			size = storageValue.length;

		}

		// determine the units we are dealing with

		var units;

		if(size < 1024)

			units = " bytes";

		else{

			units = " K";

			size = size / 1024;

			size = Math.round(size);

		}

		size = size + units;

		var valueSize = dojo.byId("valueSize");

		valueSize.innerHTML = size;

	},

	saveBook: function(evt){

		this._printStatus("Loading book...");

		var d = dojo.xhrGet({

			url: "resources/testBook.txt",

			handleAs: "text"

		});

		d.addCallback(dojo.hitch(this, function(results){

			this._printStatus("Book loaded");

			this._save("testBook", results);

		}));

		d.addErrback(dojo.hitch(this, function(error){

			alert("Unable to load testBook.txt: " + error);

		}));

		if(!typeof evt != "undefined" && evt != null){

			evt.preventDefault();

			evt.stopPropagation();

		}

		return false;

	},

	saveXML: function(evt){

		this._printStatus("Loading XML...");

		var d = dojo.xhrGet({

			url: "resources/testXML.xml",

			handleAs: "text"

		});

		d.addCallback(dojo.hitch(this, function(results){

			this._printStatus("XML loaded");

			this._save("testXML", results);

		}));

		d.addErrback(dojo.hitch(this, function(error){

			alert("Unable to load testXML.xml: " + error);

		}));

		if(!typeof evt != "undefined" && evt != null){

			evt.preventDefault();

			evt.stopPropagation();

		}

		return false;

	},

	_save: function(key, value, namespace){

		this._printStatus("Saving '" + key + "'...");

		var self = this;

		var saveHandler = function(status, keyName){

			if(status == dojox.storage.FAILED){

				alert("You do not have permission to store data for this web site. "

			        + "Press the Configure button to grant permission.");

			}else if(status == dojox.storage.SUCCESS){

				// clear out the old value

				dojo.byId("storageKey").value = "";

				dojo.byId("storageValue").value = "";

				self._printStatus("Saved '" + key + "'");

				if(typeof namespace != "undefined"

					&& namespace != null){

					self.currentNamespace = namespace;

				}

				// update the list of available keys and namespaces

				// put this on a slight timeout, because saveHandler is called back

				// from Flash, which can cause problems in Flash 8 communication

				// which affects Safari

				// FIXME: Find out what is going on in the Flash 8 layer and fix it

				// there

				window.setTimeout(function(){

					self._printAvailableKeys();

					self._printAvailableNamespaces();

				}, 1);

			}

		};

		try{

			if(namespace == dojox.storage.DEFAULT_NAMESPACE){

				dojox.storage.put(key, value, saveHandler);

			}else{

				dojox.storage.put(key, value, saveHandler, namespace);

			}

		}catch(exp){

			alert(exp);

		}

	},

	_printAvailableKeys: function(){

		var directory = dojo.byId("directory");

		// clear out any old keys

		directory.innerHTML = "";

		// add new ones

		var availableKeys;

		if(this.currentNamespace == dojox.storage.DEFAULT_NAMESPACE){

			availableKeys = dojox.storage.getKeys();

		}else{

			availableKeys = dojox.storage.getKeys(this.currentNamespace);

		}

		for (var i = 0; i < availableKeys.length; i++){

			var optionNode = document.createElement("option");

			optionNode.appendChild(document.createTextNode(availableKeys[i]));

			optionNode.value = availableKeys[i];

			directory.appendChild(optionNode);

		}

	},

	_printAvailableNamespaces: function(){

		var namespacesDir = dojo.byId("namespaceDirectory");

		// clear out any old namespaces

		namespacesDir.innerHTML = "";

		// add new ones

		var availableNamespaces = dojox.storage.getNamespaces();

		for (var i = 0; i < availableNamespaces.length; i++){

			var optionNode = document.createElement("option");

			optionNode.appendChild(document.createTextNode(availableNamespaces[i]));

			optionNode.value = availableNamespaces[i];

			namespacesDir.appendChild(optionNode);

		}

	},

	_handleLoad: function(key){

		this._printStatus("Loading '" + key + "'...");

		// get the value

		var results;

		if(this.currentNamespace == dojox.storage.DEFAULT_NAMESPACE){

			results = dojox.storage.get(key);

		}else{

			results = dojox.storage.get(key, this.currentNamespace);

		}

		// jsonify it if it is a JavaScript object

		if(typeof results != "string"){

			results = dojo.toJson(results);

		}

		// print out its value

		this._printStatus("Loaded '" + key + "'");

		dojo.byId("storageValue").value = results;

		// print out the size of the value

		this.printValueSize();

	},

	_printProviderMetadata: function(){

		var storageType = dojox.storage.manager.currentProvider.declaredClass;

		var isSupported = dojox.storage.isAvailable();

		var maximumSize = dojox.storage.getMaximumSize();

		var permanent = dojox.storage.isPermanent();

		var uiConfig = dojox.storage.hasSettingsUI();

		var moreInfo = "";

		if(dojox.storage.manager.currentProvider.declaredClass

				== "dojox.storage.FlashStorageProvider"){

			moreInfo = "Flash Comm Version " + dojo.flash.info.commVersion;

		}

		dojo.byId("currentStorageProvider").innerHTML = storageType;

		dojo.byId("isSupported").innerHTML = isSupported;

		dojo.byId("isPersistent").innerHTML = permanent;

		dojo.byId("hasUIConfig").innerHTML = uiConfig;

		dojo.byId("maximumSize").innerHTML = maximumSize;

		dojo.byId("moreInfo").innerHTML = moreInfo;

	},

	_printStatus: function(message){

		// remove the old status

		var top = dojo.byId("top");

		for (var i = 0; i < top.childNodes.length; i++){

			var currentNode = top.childNodes[i];

			if (currentNode.nodeType == 1 &&

					currentNode.className == "status"){

				top.removeChild(currentNode);

			}

		}

		var status = document.createElement("span");

		status.className = "status";

		status.innerHTML = message;

		top.appendChild(status);

		dojo.fadeOut({node: status, duration: 2000}).play();

	}

};

// wait until the storage system is finished loading

if(dojox.storage.manager.isInitialized() == false){ // storage might already be loaded when we get here

	dojo.connect(dojox.storage.manager, "loaded", TestStorage, TestStorage.initialize);

}else{

	dojo.connect(dojo, "loaded", TestStorage, TestStorage.initialize);

}