Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.storage.manager"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojox.storage.manager"] = true;

dojo.provide("dojox.storage.manager");

//dojo.require("dojo.AdapterRegistry");

// FIXME: refactor this to use an AdapterRegistry

dojox.storage.manager = new function(){

	// summary: A singleton class in charge of the dojox.storage system

	// description:

	//		Initializes the storage systems and figures out the best available

	//		storage options on this platform.

	// currentProvider: Object

	//	The storage provider that was automagically chosen to do storage

	//	on this platform, such as dojox.storage.FlashStorageProvider.

	this.currentProvider = null;

	// available: Boolean

	//	Whether storage of some kind is available.

	this.available = false;

	this._initialized = false;

	this._providers = [];

	this._onLoadListeners = [];

	this.initialize = function(){

		// summary:

		//		Initializes the storage system and autodetects the best storage

		//		provider we can provide on this platform

		this.autodetect();

	};

	this.register = function(/*string*/ name, /*Object*/ instance){

		// summary:

		//		Registers the existence of a new storage provider; used by

		//		subclasses to inform the manager of their existence. The

		//		storage manager will select storage providers based on

		//		their ordering, so the order in which you call this method

		//		matters.

		// name:

		//		The full class name of this provider, such as

		//		"dojox.storage.FlashStorageProvider".

		// instance:

		//		An instance of this provider, which we will use to call

		//		isAvailable() on.

		this._providers[this._providers.length] = instance; //FIXME: push?

		this._providers[name] = instance; // FIXME: this._providers is an array, not a hash

	};

	this.setProvider = function(storageClass){

		// summary:

		//		Instructs the storageManager to use the given storage class for

		//		all storage requests.

		// description:

		//		Example-

		//			dojox.storage.setProvider(

		//				dojox.storage.IEStorageProvider)

	};

	this.autodetect = function(){

		// summary:

		//		Autodetects the best possible persistent storage provider

		//		available on this platform.

		//console.debug("dojox.storage.manager.autodetect");

		if(this._initialized){ // already finished

			//console.debug("dojox.storage.manager already initialized; returning");

			return;

		}

		// a flag to force the storage manager to use a particular

		// storage provider type, such as

		// djConfig = {forceStorageProvider: "dojox.storage.WhatWGStorageProvider"};

		var forceProvider = djConfig["forceStorageProvider"]||false;

		// go through each provider, seeing if it can be used

		var providerToUse;

		//FIXME: use dojo.some

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

			providerToUse = this._providers[i];

			if(forceProvider == providerToUse.declaredClass){

				// still call isAvailable for this provider, since this helps some

				// providers internally figure out if they are available

				// FIXME: This should be refactored since it is non-intuitive

				// that isAvailable() would initialize some state

				providerToUse.isAvailable();

				break;

			}else if(providerToUse.isAvailable()){

				break;

			}

		}

		if(!providerToUse){ // no provider available

			this._initialized = true;

			this.available = false;

			this.currentProvider = null;

			console.warn("No storage provider found for this platform");

			this.loaded();

			return;

		}

		// create this provider and mix in it's properties

		// so that developers can do dojox.storage.put rather

		// than dojox.storage.currentProvider.put, for example

		this.currentProvider = providerToUse;

		dojo.mixin(dojox.storage, this.currentProvider);

		// have the provider initialize itself

		dojox.storage.initialize();

		this._initialized = true;

		this.available = true;

	};

	this.isAvailable = function(){ /*Boolean*/

		// summary: Returns whether any storage options are available.

		return this.available;

	};

	this.addOnLoad = function(func){ /* void */

		// summary:

		//		Adds an onload listener to know when Dojo Offline can be used.

		// description:

		//		Adds a listener to know when Dojo Offline can be used. This

		//		ensures that the Dojo Offline framework is loaded and that the

		//		local dojox.storage system is ready to be used. This method is

		//		useful if you don't want to have a dependency on Dojo Events

		//		when using dojox.storage.

		// func: Function

		//		A function to call when Dojo Offline is ready to go

		this._onLoadListeners.push(func);

		if(this.isInitialized()){

			this._fireLoaded();

		}

	};

	this.removeOnLoad = function(func){ /* void */

		// summary: Removes the given onLoad listener

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

			if(func == this._onLoadListeners[i]){

				this._onLoadListeners = this._onLoadListeners.splice(i, 1);

				break;

			}

		}

	};

	this.isInitialized = function(){ /*Boolean*/

	 	// summary:

		//		Returns whether the storage system is initialized and ready to

		//		be used.

		// FIXME: This should REALLY not be in here, but it fixes a tricky

		// Flash timing bug

		if(this.currentProvider != null

			&& this.currentProvider.declaredClass == "dojox.storage.FlashStorageProvider"

			&& dojox.flash.ready == false){

			return false;

		}else{

			return this._initialized;

		}

	};

	this.supportsProvider = function(/*string*/ storageClass){ /* Boolean */

		// summary: Determines if this platform supports the given storage provider.

		// description:

		//		Example-

		//			dojox.storage.manager.supportsProvider(

		//				"dojox.storage.InternetExplorerStorageProvider");

		// construct this class dynamically

		try{

			// dynamically call the given providers class level isAvailable()

			// method

			var provider = eval("new " + storageClass + "()");

			var results = provider.isAvailable();

			if(!results){ return false; }

			return results;

		}catch(e){

			return false;

		}

	};

	this.getProvider = function(){ /* Object */

		// summary: Gets the current provider

		return this.currentProvider;

	};

	this.loaded = function(){

		// summary:

		//		The storage provider should call this method when it is loaded

		//		and ready to be used. Clients who will use the provider will

		//		connect to this method to know when they can use the storage

		//		system. You can either use dojo.connect to connect to this

		//		function, or can use dojox.storage.manager.addOnLoad() to add

		//		a listener that does not depend on the dojo.event package.

		// description:

		//		Example 1-

		//			if(dojox.storage.manager.isInitialized() == false){

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

		//			}else{

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

		//			}

		//		Example 2-

		//			dojox.storage.manager.addOnLoad(someFunction);

		// FIXME: we should just provide a Deferred for this. That way you

		// don't care when this happens or has happened. Deferreds are in Base

		this._fireLoaded();

	};

	this._fireLoaded = function(){

		//console.debug("dojox.storage.manager._fireLoaded");

		dojo.forEach(this._onLoadListeners, function(i){

			try{

				i();

			}catch(e){ console.debug(e); }

		});

	};

	this.getResourceList = function(){

		// summary:

		//		Returns a list of whatever resources are necessary for storage

		//		providers to work.

		// description:

		//		This will return all files needed by all storage providers for

		//		this particular environment type. For example, if we are in the

		//		browser environment, then this will return the hidden SWF files

		//		needed by the FlashStorageProvider, even if we don't need them

		//		for the particular browser we are working within. This is meant

		//		to faciliate Dojo Offline, which must retrieve all resources we

		//		need offline into the offline cache -- we retrieve everything

		//		needed, in case another browser that requires different storage

		//		mechanisms hits the local offline cache. For example, if we

		//		were to sync against Dojo Offline on Firefox 2, then we would

		//		not grab the FlashStorageProvider resources needed for Safari.

		var results = [];

		dojo.forEach(dojox.storage.manager._providers, function(currentProvider){

			results = results.concat(currentProvider.getResourceList());

		});

		return results;

	}

};

}