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;
        }
};

}