# HttpProxy.js

    /**
     * @class Ext.data.HttpProxy
     * An implementation of {@link Ext.data.DataProxy} that reads a data object from an {@link Ext.data.Connection} object
     * configured to reference a certain URL.<br><br>
     * <p>
     * <em>Note that this class cannot be used to retrieve data from a domain other than the domain
     * from which the running page was served.<br><br>
     * <p>
     * For cross-domain access to remote data, use an {@link Ext.data.ScriptTagProxy}.</em><br><br>
     * <p>
     * Be aware that to enable the browser to parse an XML document, the server must set
     * the Content-Type header in the HTTP response to "text/xml".
     * @constructor
     * @param {Object} conn Connection config options to add to each request (e.g. {url: 'foo.php'} or
     * an {@link Ext.data.Connection} object.  If a Connection config is passed, the singleton {@link Ext.Ajax} object
     * will be used to make the request.
     */
    Ext.data.HttpProxy = function(conn){
        Ext.data.HttpProxy.superclass.constructor.call(this);
        // is conn a conn config or a real conn?
        this.conn = conn;
        this.useAjax = !conn || !conn.events;
    };

    Ext.extend(Ext.data.HttpProxy, Ext.data.DataProxy, {
        /**
         * Return the {@link Ext.data.Connection} object being used by this Proxy.
         * @return {Connection} The Connection object. This object may be used to subscribe to events on
         * a finer-grained basis than the DataProxy events.
         */
        getConnection : function(){
            return this.useAjax ? Ext.Ajax : this.conn;
        },

        /**
         * Load data from the configured {@link Ext.data.Connection}, read the data object into
         * a block of Ext.data.Records using the passed {@link Ext.data.DataReader} implementation, and
         * process that block using the passed callback.
         * @param {Object} params An object containing properties which are to be used as HTTP parameters
         * for the request to the remote server.
         * @param {Ext.data.DataReader} reader The Reader object which converts the data
         * object into a block of Ext.data.Records.
         * @param {Function} callback The function into which to pass the block of Ext.data.Records.
         * The function must be passed <ul>
         * <li>The Record block object</li>
         * <li>The "arg" argument from the load function</li>
         * <li>A boolean success indicator</li>
         * </ul>
         * @param {Object} scope The scope in which to call the callback
         * @param {Object} arg An optional argument which is passed to the callback as its second parameter.
         */
        load : function(params, reader, callback, scope, arg){
            if(this.fireEvent("beforeload", this, params) !== false){
                var  o = {
                    params : params || {},
                    request: {
                        callback : callback,
                        scope : scope,
                        arg : arg
                    },
                    reader: reader,
                    callback : this.loadResponse,
                    scope: this
                };
                if(this.useAjax){
                    Ext.applyIf(o, this.conn);
                    if(this.activeRequest){
                        Ext.Ajax.abort(this.activeRequest);
                    }
                    this.activeRequest = Ext.Ajax.request(o);
                }else{
                    this.conn.request(o);
                }
            }else{
                callback.call(scope||this, null, arg, false);
            }
        },

        // private
        loadResponse : function(o, success, response){
            delete this.activeRequest;
            if(!success){
                this.fireEvent("loadexception", this, o, response);
                o.request.callback.call(o.request.scope, null, o.request.arg, false);
                return;
            }
            var result;
            try {
                result = o.reader.read(response);
            }catch(e){
                this.fireEvent("loadexception", this, o, response, e);
                o.request.callback.call(o.request.scope, null, o.request.arg, false);
                return;
            }
            this.fireEvent("load", this, o, o.request.arg);
            o.request.callback.call(o.request.scope, result, o.request.arg, true);
        },

        // private
        update : function(dataSet){

        },

        // private
        updateResponse : function(dataSet){

        }
    });

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