(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 Uploads
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.
	 * 
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 : Object
The parameter to the request call.
	     * 
success : Boolean
True if the request succeeded.
	     * 
response : Object
The 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 : Object
The XMLHttpRequest object containing the response data.
	     * 
options : Object
The 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 : Object
The XMLHttpRequest object containing the response data.
	     * 
options : Object
The 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);
    }
});