###

    (function(){
    	var BEFOREREQUEST = "beforerequest",
    		REQUESTCOMPLETE = "requestcomplete",
    		REQUESTEXCEPTION = "requestexception",
    		LOAD = 'load',
    		POST = 'POST',
    		GET = 'GET',
    		WINDOW = window;

    	/**
    	 * @class Ext.data.Connection
    	 * @extends Ext.util.Observable
    	 * The class encapsulates a connection to the page's originating domain, allowing requests to be made
    	 * either to a configured URL, or to a URL specified at request time.
    	 * Requests made by this class are asynchronous, and will return immediately. No data from
    	 * the server will be available to the statement immediately following the {@link #request} call.
    	 * To process returned data, use a
    	 * success callback
    	 * in the request options object,
    	 * or an {@link #requestcomplete event listener}.
    	 * File UploadsFile uploads are not performed using normal "Ajax" techniques, that
    	 * is they are not performed using XMLHttpRequests. Instead the form is submitted in the standard
    	 * manner with the DOM <form> element temporarily modified to have its
    	 * target set to refer
    	 * to a dynamically generated, hidden <iframe> which is inserted into the document
    	 * but removed after the return data has been gathered.
    	 * The server response is parsed by the browser to create the document for the IFRAME. If the
    	 * server is using JSON to send the return object, then the
    	 * Content-Type header
    	 * must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body.
    	 * Characters which are significant to an HTML parser must be sent as HTML entities, so encode
    	 * "<" as "&lt;", "&" as "&amp;" etc.
    	 * The response text is retrieved from the document, and a fake XMLHttpRequest object
    	 * is created containing a responseText property in order to conform to the
    	 * requirements of event handlers and callbacks.
    	 * Be aware that file upload packets are sent with the content type multipart/form
    	 * and some server technologies (notably JEE) may require some custom processing in order to
    	 * retrieve parameter names and parameter values from the packet content.
    	 * @constructor
    	 * @param {Object} config a configuration object.
    	 */
    	Ext.data.Connection = function(config){
    	    Ext.apply(this, config);
    	    this.addEvents(
    	        /**
    	         * @event beforerequest
    	         * Fires before a network request is made to retrieve a data object.
    	         * @param {Connection} conn This Connection object.
    	         * @param {Object} options The options config object passed to the {@link #request} method.
    	         */
    	        BEFOREREQUEST,
    	        /**
    	         * @event requestcomplete
    	         * Fires if the request was successfully completed.
    	         * @param {Connection} conn This Connection object.
    	         * @param {Object} response The XHR object containing the response data.
    	         * See The XMLHttpRequest Object
    	         * for details.
    	         * @param {Object} options The options config object passed to the {@link #request} method.
    	         */
    	        REQUESTCOMPLETE,
    	        /**
    	         * @event requestexception
    	         * Fires if an error HTTP status was returned from the server.
    	         * See HTTP Status Code Definitions
    	         * for details of HTTP status codes.
    	         * @param {Connection} conn This Connection object.
    	         * @param {Object} response The XHR object containing the response data.
    	         * See The XMLHttpRequest Object
    	         * for details.
    	         * @param {Object} options The options config object passed to the {@link #request} method.
    	         */
    	        REQUESTEXCEPTION
    	    );
    	    Ext.data.Connection.superclass.constructor.call(this);
    	};

    	// private
        function handleResponse(response){
            this.transId = false;
            var options = response.argument.options;
            response.argument = options ? options.argument : null;
            this.fireEvent(REQUESTCOMPLETE, this, response, options);
            if(options.success) options.success.call(options.scope, response, options);
            if(options.callback) options.callback.call(options.scope, options, true, response);
        }

        // private
        function handleFailure(response, e){
            this.transId = false;
            var options = response.argument.options;
            response.argument = options ? options.argument : null;
            this.fireEvent(REQUESTEXCEPTION, this, response, options, e);
            if(options.failure) options.failure.call(options.scope, response, options);
            if(options.callback) options.callback.call(options.scope, options, false, response);
        }

    	Ext.extend(Ext.data.Connection, Ext.util.Observable, {
    	    /**
    	     * @cfg {String} url (Optional) The default URL to be used for requests to the server. (defaults to undefined)
    	     */
    	    /**
    	     * @cfg {Object} extraParams (Optional) An object containing properties which are used as
    	     * extra parameters to each request made by this object. (defaults to undefined)
    	     */
    	    /**
    	     * @cfg {Object} defaultHeaders (Optional) An object containing request headers which are added
    	     *  to each request made by this object. (defaults to undefined)
    	     */
    	    /**
    	     * @cfg {String} method (Optional) The default HTTP method to be used for requests.
    	     * (defaults to undefined; if not set, but {@link #request} params are present, POST will be used;
    	     * otherwise, GET will be used.)
    	     */
    	    /**
    	     * @cfg {Number} timeout (Optional) The timeout in milliseconds to be used for requests. (defaults to 30000)
    	     */
    	    timeout : 30000,
    	    /**
    	     * @cfg {Boolean} autoAbort (Optional) Whether this request should abort any pending requests. (defaults to false)
    	     * @type Boolean
    	     */
    	    autoAbort:false,

    	    /**
    	     * @cfg {Boolean} disableCaching (Optional) True to add a unique cache-buster param to GET requests. (defaults to true)
    	     * @type Boolean
    	     */
    	    disableCaching: true,

    	    /**
    	     * @cfg {String} disableCachingParam (Optional) Change the parameter which is sent went disabling caching
    	     * through a cache buster. Defaults to '_dc'
    	     * @type String
    	     */
    	    disableCachingParam: '_dc',

    	    /**
    	     * Sends an HTTP request to a remote server.
    	     * Important: Ajax server requests are asynchronous, and this call will
    	     * return before the response has been received. Process any returned data
    	     * in a callback function.
    	     * To execute a callback function in the correct scope, use the scope option.
    	     * @param {Object} options An object which may contain the following properties:
    	     * url : String/Function (Optional)The URL to
    	     * which to send the request, or a function to call which returns a URL string. The scope of the
    	     * function is specified by the scope option. Defaults to configured URL.
    	     * params : Object/String/Function (Optional)
    	     * An object containing properties which are used as parameters to the
    	     * request, a url encoded string or a function to call to get either. The scope of the function
    	     * is specified by the scope option.
    	     * method : String (Optional)The HTTP method to use
    	     * for the request. Defaults to the configured method, or if no method was configured,
    	     * "GET" if no parameters are being sent, and "POST" if parameters are being sent.  Note that
    	     * the method name is case-sensitive and should be all caps.
    	     * callback : Function (Optional)The
    	     * function to be called upon receipt of the HTTP response. The callback is
    	     * called regardless of success or failure and is passed the following
    	     * parameters:
    	     * options : ObjectThe parameter to the request call.
    	     * success : BooleanTrue if the request succeeded.
    	     * response : ObjectThe XMLHttpRequest object containing the response data.
    	     * See http://www.w3.org/TR/XMLHttpRequest/ for details about
    	     * accessing elements of the response.
    	     *
    	     * success : Function (Optional)The function
    	     * to be called upon success of the request. The callback is passed the following
    	     * parameters:
    	     * response : ObjectThe XMLHttpRequest object containing the response data.
    	     * options : ObjectThe parameter to the request call.
    	     *
    	     * failure : Function (Optional)The function
    	     * to be called upon failure of the request. The callback is passed the
    	     * following parameters:
    	     * response : ObjectThe XMLHttpRequest object containing the response data.
    	     * options : ObjectThe parameter to the request call.
    	     *
    	     * scope : Object (Optional)The scope in
    	     * which to execute the callbacks: The "this" object for the callback function. If the url, or params options were
    	     * specified as functions from which to draw values, then this also serves as the scope for those function calls.
    	     * Defaults to the browser window.
    	     * form : Element/HTMLElement/String (Optional)The <form>
    	     * Element or the id of the <form> to pull parameters from.
    	     * isUpload : Boolean (Optional)Only meaningful when used
    	     * with the form option.
    	     * True if the form object is a file upload (will be set automatically if the form was
    	     * configured with enctype "multipart/form-data").
    	     * File uploads are not performed using normal "Ajax" techniques, that is they are not
    	     * performed using XMLHttpRequests. Instead the form is submitted in the standard manner with the
    	     * DOM <form> element temporarily modified to have its
    	     * target set to refer
    	     * to a dynamically generated, hidden <iframe> which is inserted into the document
    	     * but removed after the return data has been gathered.
    	     * The server response is parsed by the browser to create the document for the IFRAME. If the
    	     * server is using JSON to send the return object, then the
    	     * Content-Type header
    	     * must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body.
    	     * The response text is retrieved from the document, and a fake XMLHttpRequest object
    	     * is created containing a responseText property in order to conform to the
    	     * requirements of event handlers and callbacks.
    	     * Be aware that file upload packets are sent with the content type multipart/form
    	     * and some server technologies (notably JEE) may require some custom processing in order to
    	     * retrieve parameter names and parameter values from the packet content.
    	     *
    	     * headers : Object (Optional)Request
    	     * headers to set for the request.
    	     * xmlData : Object (Optional)XML document
    	     * to use for the post. Note: This will be used instead of params for the post
    	     * data. Any params will be appended to the URL.
    	     * jsonData : Object/String (Optional)JSON
    	     * data to use as the post. Note: This will be used instead of params for the post
    	     * data. Any params will be appended to the URL.
    	     * disableCaching : Boolean (Optional)True
    	     * to add a unique cache-buster param to GET requests.
    	     *
    	     * The options object may also contain any other property which might be needed to perform
    	     * postprocessing in a callback because it is passed to callback functions.
    	     * @return {Number} transactionId The id of the server transaction. This may be used
    	     * to cancel the request.
    	     */
    	    request : function(o){
    		    var me = this;
    	        if(me.fireEvent(BEFOREREQUEST, me, o)){
                    if (o.el) {
                        if(!Ext.isEmpty(o.indicatorText)){
                            me.indicatorText = ''+o.indicatorText+"";
                        }
                        if(me.indicatorText) {
                            Ext.getDom(o.el).innerHTML = me.indicatorText;
                        }
                        o.success = (Ext.isFunction(o.success) ? o.success : function(){}).createInterceptor(function(response) {
                            Ext.getDom(o.el).innerHTML = response.responseText;
                        });
                    }

    	            var p = o.params,
    	            	url = o.url || me.url,
    	            	method,
    	            	cb = {success: handleResponse,
    		                  failure: handleFailure,
    		                  scope: me,
    		                  argument: {options: o},
    		                  timeout : o.timeout || me.timeout
    		            },
    		            form,
    		            serForm;

    	            if (Ext.isFunction(p)) {
    	                p = p.call(o.scope||WINDOW, o);
    	            }

    	            p = Ext.urlEncode(me.extraParams, typeof p == 'object' ? Ext.urlEncode(p) : p);

    	            if (Ext.isFunction(url)) {
    	                url = url.call(o.scope || WINDOW, o);
    	            }

    	            if(form = Ext.getDom(o.form)){
    	                url = url || form.action;

    // this is not supported in Ext Core
    // 	                if(o.isUpload || /multipart\/form-data/i.test(form.getAttribute("enctype"))) {
    // 	                    return doFormUpload.call(me, o, p, url);
    // 	                }
    	                serForm = Ext.lib.Ajax.serializeForm(form);
    	                p = p ? (p + '&' + serForm) : serForm;
    	            }

    	            method = o.method || me.method || ((p || o.xmlData || o.jsonData) ? POST : GET);

    	            if(method == GET && (me.disableCaching || o.disableCaching !== false)) {// || o.disableCaching === true){
    	                var dcp = o.disableCachingParam || me.disableCachingParam;
    	                url += (url.indexOf('?') != -1 ? '&' : '?') + dcp + '=' + (new Date().getTime());
    	            }

    	            o.headers = Ext.apply(o.headers || {}, me.defaultHeaders || {});

    				if(o.autoAbort === true || me.autoAbort) {
    					me.abort();
    				}

    	            if((method == GET || o.xmlData || o.jsonData) && p){
    	                url += (/\?/.test(url) ? '&' : '?') + p;
    	                p = '';
    	            }

    	            return me.transId = Ext.lib.Ajax.request(method, url, cb, p, o);
    	        }else{
    	            return o.callback ? o.callback.apply(o.scope, [o,,]) : null;
    	        }
    	    },

    	    /**
    	     * Determine whether this object has a request outstanding.
    	     * @param {Number} transactionId (Optional) defaults to the last transaction
    	     * @return {Boolean} True if there is an outstanding request.
    	     */
    	    isLoading : function(transId){
    		    return transId ? Ext.lib.Ajax.isCallInProgress(transId) : !! this.transId;
    	    },

    	    /**
    	     * Aborts any outstanding request.
    	     * @param {Number} transactionId (Optional) defaults to the last transaction
    	     */
    	    abort : function(transId){
    	        if(transId || this.isLoading()){
    	            Ext.lib.Ajax.abort(transId || this.transId);
    	        }
    	    }
    	});
    })();

    /**
     * @class Ext.Ajax
     * @extends Ext.data.Connection
     * Global Ajax request class.  Provides a simple way to make Ajax requests with maximum flexibility.  Example usage:
     *
    // Basic request
    Ext.Ajax.request({
       url: 'foo.php',
       success: someFn,
       failure: otherFn,
       headers: {
           'my-header': 'foo'
       },
       params: { foo: 'bar' }
    });

    // Simple ajax form submission
    Ext.Ajax.request({
        form: 'some-form',
        params: 'foo=bar'
    });

    // Default headers to pass in every request
    Ext.Ajax.defaultHeaders = {
        'Powered-By': 'Ext'
    };

    // Global Ajax events can be handled on every request!
    Ext.Ajax.on('beforerequest', this.showSpinner, this);

     * @singleton
     */
    Ext.Ajax = new Ext.data.Connection({
        /**
         * @cfg {String} url @hide
         */
        /**
         * @cfg {Object} extraParams @hide
         */
        /**
         * @cfg {Object} defaultHeaders @hide
         */
        /**
         * @cfg {String} method (Optional) @hide
         */
        /**
         * @cfg {Number} timeout (Optional) @hide
         */
        /**
         * @cfg {Boolean} autoAbort (Optional) @hide
         */

        /**
         * @cfg {Boolean} disableCaching (Optional) @hide
         */

        /**
         * @property  disableCaching
         * True to add a unique cache-buster param to GET requests. (defaults to true)
         * @type Boolean
         */
        /**
         * @property  url
         * The default URL to be used for requests to the server. (defaults to undefined)
         * @type String
         */
        /**
         * @property  extraParams
         * An object containing properties which are used as
         * extra parameters to each request made by this object. (defaults to undefined)
         * @type Object
         */
        /**
         * @property  defaultHeaders
         * An object containing request headers which are added to each request made by this object. (defaults to undefined)
         * @type Object
         */
        /**
         * @property  method
         * The default HTTP method to be used for requests. Note that this is case-sensitive and should be all caps (defaults
         * to undefined; if not set but parms are present will use "POST," otherwise "GET.")
         * @type String
         */
        /**
         * @property  timeout
         * The timeout in milliseconds to be used for requests. (defaults to 30000)
         * @type Number
         */

        /**
         * @property  autoAbort
         * Whether a new request should abort any pending requests. (defaults to false)
         * @type Boolean
         */
        autoAbort : false,

        /**
         * Serialize the passed form into a url encoded string
         * @param {String/HTMLElement} form
         * @return {String}
         */
        serializeForm : function(form){
            return Ext.lib.Ajax.serializeForm(form);
        }
    });