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());

}