# State.js

    /**
     * @class Ext.state.Provider
     * Abstract base class for state provider implementations. This class provides methods
     * for encoding and decoding <b>typed</b> variables including dates and defines the
     * Provider interface.
     */
    Ext.state.Provider = function(){
        Ext.state.Provider.superclass.constructor.call(this);
        /**
         * @event statechange
         * Fires when a state change occurs.
         * @param {Provider} this This state provider
         * @param {String} key The state key which was changed
         * @param {String} value The encoded value for the state
         */
        this.addEvents({
            "statechange": true
        });
        this.state = {};
        Ext.state.Provider.superclass.constructor.call(this);
    };
    Ext.extend(Ext.state.Provider, Ext.util.Observable, {
        /**
         * Returns the current value for a key
         * @param {String} name The key name
         * @param {Mixed} defaultValue A default value to return if the key's value is not found
         * @return {Mixed} The state data
         */
        get : function(name, defaultValue){
            return typeof this.state[name] == "undefined" ?
                defaultValue : this.state[name];
        },

        /**
         * Clears a value from the state
         * @param {String} name The key name
         */
        clear : function(name){
            delete this.state[name];
            this.fireEvent("statechange", this, name, null);
        },

        /**
         * Sets the value for a key
         * @param {String} name The key name
         * @param {Mixed} value The value to set
         */
        set : function(name, value){
            this.state[name] = value;
            this.fireEvent("statechange", this, name, value);
        },

        /**
         * Decodes a string previously encoded with {@link #encodeValue}.
         * @param {String} value The value to decode
         * @return {Mixed} The decoded value
         */
        decodeValue : function(cookie){
            var re = /^(a|n|d|b|s|o)\:(.*)$/;
            var matches = re.exec(unescape(cookie));
            if(!matches || !matches[1]) return; // non state cookie
            var type = matches[1];
            var v = matches[2];
            switch(type){
                case "n":
                    return parseFloat(v);
                case "d":
                    return new Date(Date.parse(v));
                case "b":
                    return (v == "1");
                case "a":
                    var all = [];
                    var values = v.split("^");
                    for(var i = 0, len = values.length; i < len; i++){
                        all.push(this.decodeValue(values[i]));
                    }
                    return all;
               case "o":
                    var all = {};
                    var values = v.split("^");
                    for(var i = 0, len = values.length; i < len; i++){
                        var kv = values[i].split("=");
                        all[kv[0]] = this.decodeValue(kv[1]);
                    }
                    return all;
               default:
                    return v;
            }
        },

        /**
         * Encodes a value including type information.  Decode with {@link #decodeValue}.
         * @param {Mixed} value The value to encode
         * @return {String} The encoded value
         */
        encodeValue : function(v){
            var enc;
            if(typeof v == "number"){
                enc = "n:" + v;
            }else if(typeof v == "boolean"){
                enc = "b:" + (v ? "1" : "0");
            }else if(v instanceof Date){
                enc = "d:" + v.toGMTString();
            }else if(v instanceof Array){
                var flat = "";
                for(var i = 0, len = v.length; i < len; i++){
                    flat += this.encodeValue(v[i]);
                    if(i != len-1) flat += "^";
                }
                enc = "a:" + flat;
            }else if(typeof v == "object"){
                var flat = "";
                for(var key in v){
                    if(typeof v[key] != "function"){
                        flat += key + "=" + this.encodeValue(v[key]) + "^";
                    }
                }
                enc = "o:" + flat.substring(0, flat.length-1);
            }else{
                enc = "s:" + v;
            }
            return escape(enc);
        }
    });

    /**
     * @class Ext.state.Manager
     * This is the global state manager. By default all components that are "state aware" check this class
     * for state information if you don't pass them a custom state provider. In order for this class
     * to be useful, it must be initialized with a provider when your application initializes.
     <pre><code>
    // in your initialization function
    init : function(){
       Ext.state.Manager.setProvider(new Ext.state.CookieProvider());
       ...
       // supposed you have a {@link Ext.BorderLayout}
       var layout = new Ext.BorderLayout(...);
       layout.restoreState();
       // or a {Ext.BasicDialog}
       var dialog = new Ext.BasicDialog(...);
       dialog.restoreState();
     </code></pre>
     * @singleton
     */
    Ext.state.Manager = function(){
        var provider = new Ext.state.Provider();

        return {
            /**
             * Configures the default state provider for your application
             * @param {Provider} stateProvider The state provider to set
             */
            setProvider : function(stateProvider){
                provider = stateProvider;
            },

            /**
             * Returns the current value for a key
             * @param {String} name The key name
             * @param {Mixed} defaultValue The default value to return if the key lookup does not match
             * @return {Mixed} The state data
             */
            get : function(key, defaultValue){
                return provider.get(key, defaultValue);
            },

            /**
             * Sets the value for a key
             * @param {String} name The key name
             * @param {Mixed} value The state data
             */
             set : function(key, value){
                provider.set(key, value);
            },

            /**
             * Clears a value from the state
             * @param {String} name The key name
             */
            clear : function(key){
                provider.clear(key);
            },

            /**
             * Gets the currently configured state provider
             * @return {Provider} The state provider
             */
            getProvider : function(){
                return provider;
            }
        };
    }();

    /**
     * @class Ext.state.CookieProvider
     * @extends Ext.state.Provider
     * The default Provider implementation which saves state via cookies.
     * <br />Usage:
     <pre><code>
       var cp = new Ext.state.CookieProvider({
           path: "/cgi-bin/",
           expires: new Date(new Date().getTime()+(1000*60*60*24*30)); //30 days
           domain: "extjs.com"
       })
       Ext.state.Manager.setProvider(cp);
     </code></pre>
     * @cfg {String} path The path for which the cookie is active (defaults to root '/' which makes it active for all pages in the site)
     * @cfg {Date} expires The cookie expiration date (defaults to 7 days from now)
     * @cfg {String} domain The domain to save the cookie for.  Note that you cannot specify a different domain than
     * your page is on, but you can specify a sub-domain, or simply the domain itself like 'extjs.com' to include
     * all sub-domains if you need to access cookies across different sub-domains (defaults to null which uses the same
     * domain the page is running on including the 'www' like 'www.extjs.com')
     * @cfg {Boolean} secure True if the site is using SSL (defaults to false)
     * @constructor
     * Create a new CookieProvider
     * @param {Object} config The configuration object
     */
    Ext.state.CookieProvider = function(config){
        Ext.state.CookieProvider.superclass.constructor.call(this);
        this.path = "/";
        this.expires = new Date(new Date().getTime()+(1000*60*60*24*7)); //7 days
        this.domain = null;
        this.secure = false;
        Ext.apply(this, config);
        this.state = this.readCookies();
    };

    Ext.extend(Ext.state.CookieProvider, Ext.state.Provider, {
        // private
        set : function(name, value){
            if(typeof value == "undefined" || value === null){
                this.clear(name);
                return;
            }
            this.setCookie(name, value);
            Ext.state.CookieProvider.superclass.set.call(this, name, value);
        },

        // private
        clear : function(name){
            this.clearCookie(name);
            Ext.state.CookieProvider.superclass.clear.call(this, name);
        },

        // private
        readCookies : function(){
            var cookies = {};
            var c = document.cookie + ";";
            var re = /\s?(.*?)=(.*?);/g;
        	var matches;
        	while((matches = re.exec(c)) != null){
                var name = matches[1];
                var value = matches[2];
                if(name && name.substring(0,3) == "ys-"){
                    cookies[name.substr(3)] = this.decodeValue(value);
                }
            }
            return cookies;
        },

        // private
        setCookie : function(name, value){
            document.cookie = "ys-"+ name + "=" + this.encodeValue(value) +
               ((this.expires == null) ? "" : ("; expires=" + this.expires.toGMTString())) +
               ((this.path == null) ? "" : ("; path=" + this.path)) +
               ((this.domain == null) ? "" : ("; domain=" + this.domain)) +
               ((this.secure == true) ? "; secure" : "");
        },

        // private
        clearCookie : function(name){
            document.cookie = "ys-" + name + "=null; expires=Thu, 01-Jan-70 00:00:01 GMT" +
               ((this.path == null) ? "" : ("; path=" + this.path)) +
               ((this.domain == null) ? "" : ("; domain=" + this.domain)) +
               ((this.secure == true) ? "; secure" : "");
        }
    });

Ext - Copyright © 2006-2007 Ext JS, LLC
All rights reserved.