From e44a7e37b6c7b5961adaffc62b9042b8d442938e Mon Sep 17 00:00:00 2001 From: mensonge Date: Thu, 13 Nov 2008 09:49:11 +0000 Subject: 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 --- includes/js/dojox/storage/manager.js | 261 +++++++++++++++++++++++++++++++++++ 1 file changed, 261 insertions(+) create mode 100644 includes/js/dojox/storage/manager.js (limited to 'includes/js/dojox/storage/manager.js') diff --git a/includes/js/dojox/storage/manager.js b/includes/js/dojox/storage/manager.js new file mode 100644 index 0000000..0198a6d --- /dev/null +++ b/includes/js/dojox/storage/manager.js @@ -0,0 +1,261 @@ +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; + + // providers: Array + // Array of all the static provider instances, useful if you want to + // loop through and see what providers have been registered. + this.providers = []; + + this._initialized = false; + + 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. + + // keep list of providers as a list so that we can know what order + // storage providers are preferred; also, store the providers hashed + // by name in case someone wants to get a provider that uses + // a particular storage backend + this.providers.push(instance); + this.providers[name] = instance; + }; + + 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 + return; + } + + // a flag to force the storage manager to use a particular + // storage provider type, such as + // djConfig = {forceStorageProvider: "dojox.storage.WhatWGStorageProvider"}; + var forceProvider = dojo.config["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 && 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(!forceProvider && 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. + // Confirm that this is still needed with the newly refactored Dojo + // Flash. Used to be for Internet Explorer. -- Brad Neuberg + 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; + } +}; + +} -- cgit v1.2.3-54-g00ecf