开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Java编程 > JavaScript > 查看源码
direct-debug.js
资源名称：ext-3.1.0.zip　[点击查看]
上传用户：dawnssy
上传日期：2022-08-06
资源大小：9345k
文件大小：41k
源码类别：

JavaScript

开发平台：

JavaScript

direct-debug.js：源码内容
  1. /*!  * Ext JS Library 3.1.0  * Copyright(c) 2006-2009 Ext JS, LLC  * licensing@extjs.com  * http://www.extjs.com/license  */ /**
  2.  * @class Ext.data.DirectProxy
  3.  * @extends Ext.data.DataProxy
  4.  */
  5. Ext.data.DirectProxy = function(config){
  6.     Ext.apply(this, config);
  7.     if(typeof this.paramOrder == 'string'){
  8.         this.paramOrder = this.paramOrder.split(/[s,|]/);
  9.     }
  10.     Ext.data.DirectProxy.superclass.constructor.call(this, config);
  11. };
  13. Ext.extend(Ext.data.DirectProxy, Ext.data.DataProxy, {
  14.     /**
  15.      * @cfg {Array/String} paramOrder Defaults to <tt>undefined</tt>. A list of params to be executed
  16.      * server side.  Specify the params in the order in which they must be executed on the server-side
  17.      * as either (1) an Array of String values, or (2) a String of params delimited by either whitespace,
  18.      * comma, or pipe. For example,
  19.      * any of the following would be acceptable:<pre><code>
  20. paramOrder: ['param1','param2','param3']
  21. paramOrder: 'param1 param2 param3'
  22. paramOrder: 'param1,param2,param3'
  23. paramOrder: 'param1|param2|param'
  24.      </code></pre>
  25.      */
  26.     paramOrder: undefined,
  28.     /**
  29.      * @cfg {Boolean} paramsAsHash
  30.      * Send parameters as a collection of named arguments (defaults to <tt>true</tt>). Providing a
  31.      * <tt>{@link #paramOrder}</tt> nullifies this configuration.
  32.      */
  33.     paramsAsHash: true,
  35.     /**
  36.      * @cfg {Function} directFn
  37.      * Function to call when executing a request.  directFn is a simple alternative to defining the api configuration-parameter
  38.      * for Store's which will not implement a full CRUD api.
  39.      */
  40.     directFn : undefined,
  42.     /**
  43.      * DirectProxy implementation of {@link Ext.data.DataProxy#doRequest}
  44.      * @param {String} action The crud action type (create, read, update, destroy)
  45.      * @param {Ext.data.Record/Ext.data.Record[]} rs If action is load, rs will be null
  46.      * @param {Object} params An object containing properties which are to be used as HTTP parameters
  47.      * for the request to the remote server.
  48.      * @param {Ext.data.DataReader} reader The Reader object which converts the data
  49.      * object into a block of Ext.data.Records.
  50.      * @param {Function} callback
  51.      * <div class="sub-desc"><p>A function to be called after the request.
  52.      * The <tt>callback</tt> is passed the following arguments:<ul>
  53.      * <li><tt>r</tt> : Ext.data.Record[] The block of Ext.data.Records.</li>
  54.      * <li><tt>options</tt>: Options object from the action request</li>
  55.      * <li><tt>success</tt>: Boolean success indicator</li></ul></p></div>
  56.      * @param {Object} scope The scope (<code>this</code> reference) in which the callback function is executed. Defaults to the browser window.
  57.      * @param {Object} arg An optional argument which is passed to the callback as its second parameter.
  58.      * @protected
  59.      */
  60.     doRequest : function(action, rs, params, reader, callback, scope, options) {
  61.         var args = [],
  62.             directFn = this.api[action] || this.directFn;
  64.         switch (action) {
  65.             case Ext.data.Api.actions.create:
  66.                 args.push(params.jsonData); // <-- create(Hash)
  67.                 break;
  68.             case Ext.data.Api.actions.read:
  69.                 // If the method has no parameters, ignore the paramOrder/paramsAsHash.
  70.                 if(directFn.directCfg.method.len > 0){
  71.                     if(this.paramOrder){
  72.                         for(var i = 0, len = this.paramOrder.length; i < len; i++){
  73.                             args.push(params[this.paramOrder[i]]);
  74.                         }
  75.                     }else if(this.paramsAsHash){
  76.                         args.push(params);
  77.                     }
  78.                 }
  79.                 break;
  80.             case Ext.data.Api.actions.update:
  81.                 args.push(params.jsonData);        // <-- update(Hash/Hash[])
  82.                 break;
  83.             case Ext.data.Api.actions.destroy:
  84.                 args.push(params.jsonData);        // <-- destroy(Int/Int[])
  85.                 break;
  86.         }
  88.         var trans = {
  89.             params : params || {},
  90.             request: {
  91.                 callback : callback,
  92.                 scope : scope,
  93.                 arg : options
  94.             },
  95.             reader: reader
  96.         };
  98.         args.push(this.createCallback(action, rs, trans), this);
  99.         directFn.apply(window, args);
  100.     },
  102.     // private
  103.     createCallback : function(action, rs, trans) {
  104.         return function(result, res) {
  105.             if (!res.status) {
  106.                 // @deprecated fire loadexception
  107.                 if (action === Ext.data.Api.actions.read) {
  108.                     this.fireEvent("loadexception", this, trans, res, null);
  109.                 }
  110.                 this.fireEvent('exception', this, 'remote', action, trans, res, null);
  111.                 trans.request.callback.call(trans.request.scope, null, trans.request.arg, false);
  112.                 return;
  113.             }
  114.             if (action === Ext.data.Api.actions.read) {
  115.                 this.onRead(action, trans, result, res);
  116.             } else {
  117.                 this.onWrite(action, trans, result, res, rs);
  118.             }
  119.         };
  120.     },
  121.     /**
  122.      * Callback for read actions
  123.      * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
  124.      * @param {Object} trans The request transaction object
  125.      * @param {Object} result Data object picked out of the server-response.
  126.      * @param {Object} res The server response
  127.      * @protected
  128.      */
  129.     onRead : function(action, trans, result, res) {
  130.         var records;
  131.         try {
  132.             records = trans.reader.readRecords(result);
  133.         }
  134.         catch (ex) {
  135.             // @deprecated: Fire old loadexception for backwards-compat.
  136.             this.fireEvent("loadexception", this, trans, res, ex);
  138.             this.fireEvent('exception', this, 'response', action, trans, res, ex);
  139.             trans.request.callback.call(trans.request.scope, null, trans.request.arg, false);
  140.             return;
  141.         }
  142.         this.fireEvent("load", this, res, trans.request.arg);
  143.         trans.request.callback.call(trans.request.scope, records, trans.request.arg, true);
  144.     },
  145.     /**
  146.      * Callback for write actions
  147.      * @param {String} action [{@link Ext.data.Api#actions create|read|update|destroy}]
  148.      * @param {Object} trans The request transaction object
  149.      * @param {Object} result Data object picked out of the server-response.
  150.      * @param {Object} res The server response
  151.      * @param {Ext.data.Record/[Ext.data.Record]} rs The Store resultset associated with the action.
  152.      * @protected
  153.      */
  154.     onWrite : function(action, trans, result, res, rs) {
  155.         var data = trans.reader.extractData(result, false);
  156.         this.fireEvent("write", this, action, data, res, rs, trans.request.arg);
  157.         trans.request.callback.call(trans.request.scope, data, res, true);
  158.     }
  159. });
  161. /**
  162.  * @class Ext.data.DirectStore
  163.  * @extends Ext.data.Store
  164.  * <p>Small helper class to create an {@link Ext.data.Store} configured with an
  165.  * {@link Ext.data.DirectProxy} and {@link Ext.data.JsonReader} to make interacting
  166.  * with an {@link Ext.Direct} Server-side {@link Ext.direct.Provider Provider} easier.
  167.  * To create a different proxy/reader combination create a basic {@link Ext.data.Store}
  168.  * configured as needed.</p>
  169.  *
  170.  * <p><b>*Note:</b> Although they are not listed, this class inherits all of the config options of:</p>
  171.  * <div><ul class="mdetail-params">
  172.  * <li><b>{@link Ext.data.Store Store}</b></li>
  173.  * <div class="sub-desc"><ul class="mdetail-params">
  174.  *
  175.  * </ul></div>
  176.  * <li><b>{@link Ext.data.JsonReader JsonReader}</b></li>
  177.  * <div class="sub-desc"><ul class="mdetail-params">
  178.  * <li><tt><b>{@link Ext.data.JsonReader#root root}</b></tt></li>
  179.  * <li><tt><b>{@link Ext.data.JsonReader#idProperty idProperty}</b></tt></li>
  180.  * <li><tt><b>{@link Ext.data.JsonReader#totalProperty totalProperty}</b></tt></li>
  181.  * </ul></div>
  182.  *
  183.  * <li><b>{@link Ext.data.DirectProxy DirectProxy}</b></li>
  184.  * <div class="sub-desc"><ul class="mdetail-params">
  185.  * <li><tt><b>{@link Ext.data.DirectProxy#directFn directFn}</b></tt></li>
  186.  * <li><tt><b>{@link Ext.data.DirectProxy#paramOrder paramOrder}</b></tt></li>
  187.  * <li><tt><b>{@link Ext.data.DirectProxy#paramsAsHash paramsAsHash}</b></tt></li>
  188.  * </ul></div>
  189.  * </ul></div>
  190.  *
  191.  * @xtype directstore
  192.  *
  193.  * @constructor
  194.  * @param {Object} config
  195.  */
  196. Ext.data.DirectStore = function(c){
  197.     // each transaction upon a singe record will generatie a distinct Direct transaction since Direct queues them into one Ajax request.
  198.     c.batchTransactions = false;
  200.     Ext.data.DirectStore.superclass.constructor.call(this, Ext.apply(c, {
  201.         proxy: (typeof(c.proxy) == 'undefined') ? new Ext.data.DirectProxy(Ext.copyTo({}, c, 'paramOrder,paramsAsHash,directFn,api')) : c.proxy,
  202.         reader: (typeof(c.reader) == 'undefined' && typeof(c.fields) == 'object') ? new Ext.data.JsonReader(Ext.copyTo({}, c, 'totalProperty,root,idProperty'), c.fields) : c.reader
  203.     }));
  204. };
  205. Ext.extend(Ext.data.DirectStore, Ext.data.Store, {});
  206. Ext.reg('directstore', Ext.data.DirectStore); /**
  207.  * @class Ext.Direct
  208.  * @extends Ext.util.Observable
  209.  * <p><b><u>Overview</u></b></p>
  210.  * 
  211.  * <p>Ext.Direct aims to streamline communication between the client and server
  212.  * by providing a single interface that reduces the amount of common code
  213.  * typically required to validate data and handle returned data packets
  214.  * (reading data, error conditions, etc).</p>
  215.  *  
  216.  * <p>The Ext.direct namespace includes several classes for a closer integration
  217.  * with the server-side. The Ext.data namespace also includes classes for working
  218.  * with Ext.data.Stores which are backed by data from an Ext.Direct method.</p>
  219.  * 
  220.  * <p><b><u>Specification</u></b></p>
  221.  * 
  222.  * <p>For additional information consult the 
  223.  * <a href="http://extjs.com/products/extjs/direct.php">Ext.Direct Specification</a>.</p>
  224.  *   
  225.  * <p><b><u>Providers</u></b></p>
  226.  * 
  227.  * <p>Ext.Direct uses a provider architecture, where one or more providers are
  228.  * used to transport data to and from the server. There are several providers
  229.  * that exist in the core at the moment:</p><div class="mdetail-params"><ul>
  230.  * 
  231.  * <li>{@link Ext.direct.JsonProvider JsonProvider} for simple JSON operations</li>
  232.  * <li>{@link Ext.direct.PollingProvider PollingProvider} for repeated requests</li>
  233.  * <li>{@link Ext.direct.RemotingProvider RemotingProvider} exposes server side
  234.  * on the client.</li>
  235.  * </ul></div>
  236.  * 
  237.  * <p>A provider does not need to be invoked directly, providers are added via
  238.  * {@link Ext.Direct}.{@link Ext.Direct#add add}.</p>
  239.  * 
  240.  * <p><b><u>Router</u></b></p>
  241.  * 
  242.  * <p>Ext.Direct utilizes a "router" on the server to direct requests from the client
  243.  * to the appropriate server-side method. Because the Ext.Direct API is completely
  244.  * platform-agnostic, you could completely swap out a Java based server solution
  245.  * and replace it with one that uses C# without changing the client side JavaScript
  246.  * at all.</p>
  247.  * 
  248.  * <p><b><u>Server side events</u></b></p>
  249.  * 
  250.  * <p>Custom events from the server may be handled by the client by adding
  251.  * listeners, for example:</p>
  252.  * <pre><code>
  253. {"type":"event","name":"message","data":"Successfully polled at: 11:19:30 am"}
  255. // add a handler for a 'message' event sent by the server 
  256. Ext.Direct.on('message', function(e){
  257.     out.append(String.format('&lt;p>&lt;i>{0}&lt;/i>&lt;/p>', e.data));
  258.             out.el.scrollTo('t', 100000, true);
  259. });
  260.  * </code></pre>
  261.  * @singleton
  262.  */
  263. Ext.Direct = Ext.extend(Ext.util.Observable, {
  264.     /**
  265.      * Each event type implements a getData() method. The default event types are:
  266.      * <div class="mdetail-params"><ul>
  267.      * <li><b><tt>event</tt></b> : Ext.Direct.Event</li>
  268.      * <li><b><tt>exception</tt></b> : Ext.Direct.ExceptionEvent</li>
  269.      * <li><b><tt>rpc</tt></b> : Ext.Direct.RemotingEvent</li>
  270.      * </ul></div>
  271.      * @property eventTypes
  272.      * @type Object
  273.      */
  275.     /**
  276.      * Four types of possible exceptions which can occur:
  277.      * <div class="mdetail-params"><ul>
  278.      * <li><b><tt>Ext.Direct.exceptions.TRANSPORT</tt></b> : 'xhr'</li>
  279.      * <li><b><tt>Ext.Direct.exceptions.PARSE</tt></b> : 'parse'</li>
  280.      * <li><b><tt>Ext.Direct.exceptions.LOGIN</tt></b> : 'login'</li>
  281.      * <li><b><tt>Ext.Direct.exceptions.SERVER</tt></b> : 'exception'</li>
  282.      * </ul></div>
  283.      * @property exceptions
  284.      * @type Object
  285.      */
  286.     exceptions: {
  287.         TRANSPORT: 'xhr',
  288.         PARSE: 'parse',
  289.         LOGIN: 'login',
  290.         SERVER: 'exception'
  291.     },
  292.     
  293.     // private
  294.     constructor: function(){
  295.         this.addEvents(
  296.             /**
  297.              * @event event
  298.              * Fires after an event.
  299.              * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred.
  300.              * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}.
  301.              */
  302.             'event',
  303.             /**
  304.              * @event exception
  305.              * Fires after an event exception.
  306.              * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred.
  307.              */
  308.             'exception'
  309.         );
  310.         this.transactions = {};
  311.         this.providers = {};
  312.     },
  314.     /**
  315.      * Adds an Ext.Direct Provider and creates the proxy or stub methods to execute server-side methods.
  316.      * If the provider is not already connected, it will auto-connect.
  317.      * <pre><code>
  318. var pollProv = new Ext.direct.PollingProvider({
  319.     url: 'php/poll2.php'
  320. }); 
  322. Ext.Direct.addProvider(
  323.     {
  324.         "type":"remoting",       // create a {@link Ext.direct.RemotingProvider} 
  325.         "url":"php/router.php", // url to connect to the Ext.Direct server-side router.
  326.         "actions":{              // each property within the actions object represents a Class 
  327.             "TestAction":[       // array of methods within each server side Class   
  328.             {
  329.                 "name":"doEcho", // name of method
  330.                 "len":1
  331.             },{
  332.                 "name":"multiply",
  333.                 "len":1
  334.             },{
  335.                 "name":"doForm",
  336.                 "formHandler":true, // handle form on server with Ext.Direct.Transaction 
  337.                 "len":1
  338.             }]
  339.         },
  340.         "namespace":"myApplication",// namespace to create the Remoting Provider in
  341.     },{
  342.         type: 'polling', // create a {@link Ext.direct.PollingProvider} 
  343.         url:  'php/poll.php'
  344.     },
  345.     pollProv // reference to previously created instance
  346. );
  347.      * </code></pre>
  348.      * @param {Object/Array} provider Accepts either an Array of Provider descriptions (an instance
  349.      * or config object for a Provider) or any number of Provider descriptions as arguments.  Each
  350.      * Provider description instructs Ext.Direct how to create client-side stub methods.
  351.      */
  352.     addProvider : function(provider){        
  353.         var a = arguments;
  354.         if(a.length > 1){
  355.             for(var i = 0, len = a.length; i < len; i++){
  356.                 this.addProvider(a[i]);
  357.             }
  358.             return;
  359.         }
  360.         
  361.         // if provider has not already been instantiated
  362.         if(!provider.events){
  363.             provider = new Ext.Direct.PROVIDERS[provider.type](provider);
  364.         }
  365.         provider.id = provider.id || Ext.id();
  366.         this.providers[provider.id] = provider;
  368.         provider.on('data', this.onProviderData, this);
  369.         provider.on('exception', this.onProviderException, this);
  372.         if(!provider.isConnected()){
  373.             provider.connect();
  374.         }
  376.         return provider;
  377.     },
  379.     /**
  380.      * Retrieve a {@link Ext.direct.Provider provider} by the
  381.      * <b><tt>{@link Ext.direct.Provider#id id}</tt></b> specified when the provider is
  382.      * {@link #addProvider added}.
  383.      * @param {String} id Unique identifier assigned to the provider when calling {@link #addProvider} 
  384.      */
  385.     getProvider : function(id){
  386.         return this.providers[id];
  387.     },
  389.     removeProvider : function(id){
  390.         var provider = id.id ? id : this.providers[id.id];
  391.         provider.un('data', this.onProviderData, this);
  392.         provider.un('exception', this.onProviderException, this);
  393.         delete this.providers[provider.id];
  394.         return provider;
  395.     },
  397.     addTransaction: function(t){
  398.         this.transactions[t.tid] = t;
  399.         return t;
  400.     },
  402.     removeTransaction: function(t){
  403.         delete this.transactions[t.tid || t];
  404.         return t;
  405.     },
  407.     getTransaction: function(tid){
  408.         return this.transactions[tid.tid || tid];
  409.     },
  411.     onProviderData : function(provider, e){
  412.         if(Ext.isArray(e)){
  413.             for(var i = 0, len = e.length; i < len; i++){
  414.                 this.onProviderData(provider, e[i]);
  415.             }
  416.             return;
  417.         }
  418.         if(e.name && e.name != 'event' && e.name != 'exception'){
  419.             this.fireEvent(e.name, e);
  420.         }else if(e.type == 'exception'){
  421.             this.fireEvent('exception', e);
  422.         }
  423.         this.fireEvent('event', e, provider);
  424.     },
  426.     createEvent : function(response, extraProps){
  427.         return new Ext.Direct.eventTypes[response.type](Ext.apply(response, extraProps));
  428.     }
  429. });
  430. // overwrite impl. with static instance
  431. Ext.Direct = new Ext.Direct();
  433. Ext.Direct.TID = 1;
  434. Ext.Direct.PROVIDERS = {};/**
  435.  * @class Ext.Direct.Transaction
  436.  * @extends Object
  437.  * <p>Supporting Class for Ext.Direct (not intended to be used directly).</p>
  438.  * @constructor
  439.  * @param {Object} config
  440.  */
  441. Ext.Direct.Transaction = function(config){
  442.     Ext.apply(this, config);
  443.     this.tid = ++Ext.Direct.TID;
  444.     this.retryCount = 0;
  445. };
  446. Ext.Direct.Transaction.prototype = {
  447.     send: function(){
  448.         this.provider.queueTransaction(this);
  449.     },
  451.     retry: function(){
  452.         this.retryCount++;
  453.         this.send();
  454.     },
  456.     getProvider: function(){
  457.         return this.provider;
  458.     }
  459. };Ext.Direct.Event = function(config){
  460.     Ext.apply(this, config);
  461. }
  462. Ext.Direct.Event.prototype = {
  463.     status: true,
  464.     getData: function(){
  465.         return this.data;
  466.     }
  467. };
  469. Ext.Direct.RemotingEvent = Ext.extend(Ext.Direct.Event, {
  470.     type: 'rpc',
  471.     getTransaction: function(){
  472.         return this.transaction || Ext.Direct.getTransaction(this.tid);
  473.     }
  474. });
  476. Ext.Direct.ExceptionEvent = Ext.extend(Ext.Direct.RemotingEvent, {
  477.     status: false,
  478.     type: 'exception'
  479. });
  481. Ext.Direct.eventTypes = {
  482.     'rpc':  Ext.Direct.RemotingEvent,
  483.     'event':  Ext.Direct.Event,
  484.     'exception':  Ext.Direct.ExceptionEvent
  485. };
  487. /**
  488.  * @class Ext.direct.Provider
  489.  * @extends Ext.util.Observable
  490.  * <p>Ext.direct.Provider is an abstract class meant to be extended.</p>
  491.  * 
  492.  * <p>For example ExtJs implements the following subclasses:</p>
  493.  * <pre><code>
  494. Provider
  495. |
  496. +---{@link Ext.direct.JsonProvider JsonProvider} 
  497.     |
  498.     +---{@link Ext.direct.PollingProvider PollingProvider}   
  499.     |
  500.     +---{@link Ext.direct.RemotingProvider RemotingProvider}   
  501.  * </code></pre>
  502.  * @abstract
  503.  */
  504. Ext.direct.Provider = Ext.extend(Ext.util.Observable, {    
  505.     /**
  506.      * @cfg {String} id
  507.      * The unique id of the provider (defaults to an {@link Ext#id auto-assigned id}).
  508.      * You should assign an id if you need to be able to access the provider later and you do
  509.      * not have an object reference available, for example:
  510.      * <pre><code>
  511. Ext.Direct.addProvider(
  512.     {
  513.         type: 'polling',
  514.         url:  'php/poll.php',
  515.         id:   'poll-provider'
  516.     }
  517. );
  518.      
  519. var p = {@link Ext.Direct Ext.Direct}.{@link Ext.Direct#getProvider getProvider}('poll-provider');
  520. p.disconnect();
  521.      * </code></pre>
  522.      */
  523.         
  524.     /**
  525.      * @cfg {Number} priority
  526.      * Priority of the request. Lower is higher priority, <tt>0</tt> means "duplex" (always on).
  527.      * All Providers default to <tt>1</tt> except for PollingProvider which defaults to <tt>3</tt>.
  528.      */    
  529.     priority: 1,
  531.     /**
  532.      * @cfg {String} type
  533.      * <b>Required</b>, <tt>undefined</tt> by default.  The <tt>type</tt> of provider specified
  534.      * to {@link Ext.Direct Ext.Direct}.{@link Ext.Direct#addProvider addProvider} to create a
  535.      * new Provider. Acceptable values by default are:<div class="mdetail-params"><ul>
  536.      * <li><b><tt>polling</tt></b> : {@link Ext.direct.PollingProvider PollingProvider}</li>
  537.      * <li><b><tt>remoting</tt></b> : {@link Ext.direct.RemotingProvider RemotingProvider}</li>
  538.      * </ul></div>
  539.      */    
  540.  
  541.     // private
  542.     constructor : function(config){
  543.         Ext.apply(this, config);
  544.         this.addEvents(
  545.             /**
  546.              * @event connect
  547.              * Fires when the Provider connects to the server-side
  548.              * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}.
  549.              */            
  550.             'connect',
  551.             /**
  552.              * @event disconnect
  553.              * Fires when the Provider disconnects from the server-side
  554.              * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}.
  555.              */            
  556.             'disconnect',
  557.             /**
  558.              * @event data
  559.              * Fires when the Provider receives data from the server-side
  560.              * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}.
  561.              * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred.
  562.              */            
  563.             'data',
  564.             /**
  565.              * @event exception
  566.              * Fires when the Provider receives an exception from the server-side
  567.              */                        
  568.             'exception'
  569.         );
  570.         Ext.direct.Provider.superclass.constructor.call(this, config);
  571.     },
  573.     /**
  574.      * Returns whether or not the server-side is currently connected.
  575.      * Abstract method for subclasses to implement.
  576.      */
  577.     isConnected: function(){
  578.         return false;
  579.     },
  581.     /**
  582.      * Abstract methods for subclasses to implement.
  583.      */
  584.     connect: Ext.emptyFn,
  585.     
  586.     /**
  587.      * Abstract methods for subclasses to implement.
  588.      */
  589.     disconnect: Ext.emptyFn
  590. });
  591. /**
  592.  * @class Ext.direct.JsonProvider
  593.  * @extends Ext.direct.Provider
  594.  */
  595. Ext.direct.JsonProvider = Ext.extend(Ext.direct.Provider, {
  596.     parseResponse: function(xhr){
  597.         if(!Ext.isEmpty(xhr.responseText)){
  598.             if(typeof xhr.responseText == 'object'){
  599.                 return xhr.responseText;
  600.             }
  601.             return Ext.decode(xhr.responseText);
  602.         }
  603.         return null;
  604.     },
  606.     getEvents: function(xhr){
  607.         var data = null;
  608.         try{
  609.             data = this.parseResponse(xhr);
  610.         }catch(e){
  611.             var event = new Ext.Direct.ExceptionEvent({
  612.                 data: e,
  613.                 xhr: xhr,
  614.                 code: Ext.Direct.exceptions.PARSE,
  615.                 message: 'Error parsing json response: nn ' + data
  616.             })
  617.             return [event];
  618.         }
  619.         var events = [];
  620.         if(Ext.isArray(data)){
  621.             for(var i = 0, len = data.length; i < len; i++){
  622.                 events.push(Ext.Direct.createEvent(data[i]));
  623.             }
  624.         }else{
  625.             events.push(Ext.Direct.createEvent(data));
  626.         }
  627.         return events;
  628.     }
  629. });/**
  630.  * @class Ext.direct.PollingProvider
  631.  * @extends Ext.direct.JsonProvider
  632.  *
  633.  * <p>Provides for repetitive polling of the server at distinct {@link #interval intervals}.
  634.  * The initial request for data originates from the client, and then is responded to by the
  635.  * server.</p>
  636.  * 
  637.  * <p>All configurations for the PollingProvider should be generated by the server-side
  638.  * API portion of the Ext.Direct stack.</p>
  639.  *
  640.  * <p>An instance of PollingProvider may be created directly via the new keyword or by simply
  641.  * specifying <tt>type = 'polling'</tt>.  For example:</p>
  642.  * <pre><code>
  643. var pollA = new Ext.direct.PollingProvider({
  644.     type:'polling',
  645.     url: 'php/pollA.php',
  646. });
  647. Ext.Direct.addProvider(pollA);
  648. pollA.disconnect();
  650. Ext.Direct.addProvider(
  651.     {
  652.         type:'polling',
  653.         url: 'php/pollB.php',
  654.         id: 'pollB-provider'
  655.     }
  656. );
  657. var pollB = Ext.Direct.getProvider('pollB-provider');
  658.  * </code></pre>
  659.  */
  660. Ext.direct.PollingProvider = Ext.extend(Ext.direct.JsonProvider, {
  661.     /**
  662.      * @cfg {Number} priority
  663.      * Priority of the request (defaults to <tt>3</tt>). See {@link Ext.direct.Provider#priority}.
  664.      */
  665.     // override default priority
  666.     priority: 3,
  667.     
  668.     /**
  669.      * @cfg {Number} interval
  670.      * How often to poll the server-side in milliseconds (defaults to <tt>3000</tt> - every
  671.      * 3 seconds).
  672.      */
  673.     interval: 3000,
  675.     /**
  676.      * @cfg {Object} baseParams An object containing properties which are to be sent as parameters
  677.      * on every polling request
  678.      */
  679.     
  680.     /**
  681.      * @cfg {String/Function} url
  682.      * The url which the PollingProvider should contact with each request. This can also be
  683.      * an imported Ext.Direct method which will accept the baseParams as its only argument.
  684.      */
  686.     // private
  687.     constructor : function(config){
  688.         Ext.direct.PollingProvider.superclass.constructor.call(this, config);
  689.         this.addEvents(
  690.             /**
  691.              * @event beforepoll
  692.              * Fired immediately before a poll takes place, an event handler can return false
  693.              * in order to cancel the poll.
  694.              * @param {Ext.direct.PollingProvider}
  695.              */
  696.             'beforepoll',            
  697.             /**
  698.              * @event poll
  699.              * This event has not yet been implemented.
  700.              * @param {Ext.direct.PollingProvider}
  701.              */
  702.             'poll'
  703.         );
  704.     },
  706.     // inherited
  707.     isConnected: function(){
  708.         return !!this.pollTask;
  709.     },
  711.     /**
  712.      * Connect to the server-side and begin the polling process. To handle each
  713.      * response subscribe to the data event.
  714.      */
  715.     connect: function(){
  716.         if(this.url && !this.pollTask){
  717.             this.pollTask = Ext.TaskMgr.start({
  718.                 run: function(){
  719.                     if(this.fireEvent('beforepoll', this) !== false){
  720.                         if(typeof this.url == 'function'){
  721.                             this.url(this.baseParams);
  722.                         }else{
  723.                             Ext.Ajax.request({
  724.                                 url: this.url,
  725.                                 callback: this.onData,
  726.                                 scope: this,
  727.                                 params: this.baseParams
  728.                             });
  729.                         }
  730.                     }
  731.                 },
  732.                 interval: this.interval,
  733.                 scope: this
  734.             });
  735.             this.fireEvent('connect', this);
  736.         }else if(!this.url){
  737.             throw 'Error initializing PollingProvider, no url configured.';
  738.         }
  739.     },
  741.     /**
  742.      * Disconnect from the server-side and stop the polling process. The disconnect
  743.      * event will be fired on a successful disconnect.
  744.      */
  745.     disconnect: function(){
  746.         if(this.pollTask){
  747.             Ext.TaskMgr.stop(this.pollTask);
  748.             delete this.pollTask;
  749.             this.fireEvent('disconnect', this);
  750.         }
  751.     },
  753.     // private
  754.     onData: function(opt, success, xhr){
  755.         if(success){
  756.             var events = this.getEvents(xhr);
  757.             for(var i = 0, len = events.length; i < len; i++){
  758.                 var e = events[i];
  759.                 this.fireEvent('data', this, e);
  760.             }
  761.         }else{
  762.             var e = new Ext.Direct.ExceptionEvent({
  763.                 data: e,
  764.                 code: Ext.Direct.exceptions.TRANSPORT,
  765.                 message: 'Unable to connect to the server.',
  766.                 xhr: xhr
  767.             });
  768.             this.fireEvent('data', this, e);
  769.         }
  770.     }
  771. });
  773. Ext.Direct.PROVIDERS['polling'] = Ext.direct.PollingProvider;/**
  774.  * @class Ext.direct.RemotingProvider
  775.  * @extends Ext.direct.JsonProvider
  776.  * 
  777.  * <p>The {@link Ext.direct.RemotingProvider RemotingProvider} exposes access to
  778.  * server side methods on the client (a remote procedure call (RPC) type of
  779.  * connection where the client can initiate a procedure on the server).</p>
  780.  * 
  781.  * <p>This allows for code to be organized in a fashion that is maintainable,
  782.  * while providing a clear path between client and server, something that is
  783.  * not always apparent when using URLs.</p>
  784.  * 
  785.  * <p>To accomplish this the server-side needs to describe what classes and methods
  786.  * are available on the client-side. This configuration will typically be
  787.  * outputted by the server-side Ext.Direct stack when the API description is built.</p>
  788.  */
  789. Ext.direct.RemotingProvider = Ext.extend(Ext.direct.JsonProvider, {       
  790.     /**
  791.      * @cfg {Object} actions
  792.      * Object literal defining the server side actions and methods. For example, if
  793.      * the Provider is configured with:
  794.      * <pre><code>
  795. "actions":{ // each property within the 'actions' object represents a server side Class 
  796.     "TestAction":[ // array of methods within each server side Class to be   
  797.     {              // stubbed out on client
  798.         "name":"doEcho", 
  799.         "len":1            
  800.     },{
  801.         "name":"multiply",// name of method
  802.         "len":2           // The number of parameters that will be used to create an
  803.                           // array of data to send to the server side function.
  804.                           // Ensure the server sends back a Number, not a String. 
  805.     },{
  806.         "name":"doForm",
  807.         "formHandler":true, // direct the client to use specialized form handling method 
  808.         "len":1
  809.     }]
  810. }
  811.      * </code></pre>
  812.      * <p>Note that a Store is not required, a server method can be called at any time.
  813.      * In the following example a <b>client side</b> handler is used to call the
  814.      * server side method "multiply" in the server-side "TestAction" Class:</p>
  815.      * <pre><code>
  816. TestAction.multiply(
  817.     2, 4, // pass two arguments to server, so specify len=2
  818.     // callback function after the server is called
  819.     // result: the result returned by the server
  820.     //      e: Ext.Direct.RemotingEvent object
  821.     function(result, e){
  822.         var t = e.getTransaction();
  823.         var action = t.action; // server side Class called
  824.         var method = t.method; // server side method called
  825.         if(e.status){
  826.             var answer = Ext.encode(result); // 8
  827.     
  828.         }else{
  829.             var msg = e.message; // failure message
  830.         }
  831.     }
  832. );
  833.      * </code></pre>
  834.      * In the example above, the server side "multiply" function will be passed two
  835.      * arguments (2 and 4).  The "multiply" method should return the value 8 which will be
  836.      * available as the <tt>result</tt> in the example above. 
  837.      */
  838.     
  839.     /**
  840.      * @cfg {String/Object} namespace
  841.      * Namespace for the Remoting Provider (defaults to the browser global scope of <i>window</i>).
  842.      * Explicitly specify the namespace Object, or specify a String to have a
  843.      * {@link Ext#namespace namespace created} implicitly.
  844.      */
  845.     
  846.     /**
  847.      * @cfg {String} url
  848.      * <b>Required<b>. The url to connect to the {@link Ext.Direct} server-side router. 
  849.      */
  850.     
  851.     /**
  852.      * @cfg {String} enableUrlEncode
  853.      * Specify which param will hold the arguments for the method.
  854.      * Defaults to <tt>'data'</tt>.
  855.      */
  856.     
  857.     /**
  858.      * @cfg {Number/Boolean} enableBuffer
  859.      * <p><tt>true</tt> or <tt>false</tt> to enable or disable combining of method
  860.      * calls. If a number is specified this is the amount of time in milliseconds
  861.      * to wait before sending a batched request (defaults to <tt>10</tt>).</p>
  862.      * <br><p>Calls which are received within the specified timeframe will be
  863.      * concatenated together and sent in a single request, optimizing the
  864.      * application by reducing the amount of round trips that have to be made
  865.      * to the server.</p>
  866.      */
  867.     enableBuffer: 10,
  868.     
  869.     /**
  870.      * @cfg {Number} maxRetries
  871.      * Number of times to re-attempt delivery on failure of a call. Defaults to <tt>1</tt>.
  872.      */
  873.     maxRetries: 1,
  874.     
  875.     /**
  876.      * @cfg {Number} timeout
  877.      * The timeout to use for each request. Defaults to <tt>undefined</tt>.
  878.      */
  879.     timeout: undefined,
  881.     constructor : function(config){
  882.         Ext.direct.RemotingProvider.superclass.constructor.call(this, config);
  883.         this.addEvents(
  884.             /**
  885.              * @event beforecall
  886.              * Fires immediately before the client-side sends off the RPC call.
  887.              * By returning false from an event handler you can prevent the call from
  888.              * executing.
  889.              * @param {Ext.direct.RemotingProvider} provider
  890.              * @param {Ext.Direct.Transaction} transaction
  891.              */            
  892.             'beforecall',            
  893.             /**
  894.              * @event call
  895.              * Fires immediately after the request to the server-side is sent. This does
  896.              * NOT fire after the response has come back from the call.
  897.              * @param {Ext.direct.RemotingProvider} provider
  898.              * @param {Ext.Direct.Transaction} transaction
  899.              */            
  900.             'call'
  901.         );
  902.         this.namespace = (Ext.isString(this.namespace)) ? Ext.ns(this.namespace) : this.namespace || window;
  903.         this.transactions = {};
  904.         this.callBuffer = [];
  905.     },
  907.     // private
  908.     initAPI : function(){
  909.         var o = this.actions;
  910.         for(var c in o){
  911.             var cls = this.namespace[c] || (this.namespace[c] = {}),
  912.                 ms = o[c];
  913.             for(var i = 0, len = ms.length; i < len; i++){
  914.                 var m = ms[i];
  915.                 cls[m.name] = this.createMethod(c, m);
  916.             }
  917.         }
  918.     },
  920.     // inherited
  921.     isConnected: function(){
  922.         return !!this.connected;
  923.     },
  925.     connect: function(){
  926.         if(this.url){
  927.             this.initAPI();
  928.             this.connected = true;
  929.             this.fireEvent('connect', this);
  930.         }else if(!this.url){
  931.             throw 'Error initializing RemotingProvider, no url configured.';
  932.         }
  933.     },
  935.     disconnect: function(){
  936.         if(this.connected){
  937.             this.connected = false;
  938.             this.fireEvent('disconnect', this);
  939.         }
  940.     },
  942.     onData: function(opt, success, xhr){
  943.         if(success){
  944.             var events = this.getEvents(xhr);
  945.             for(var i = 0, len = events.length; i < len; i++){
  946.                 var e = events[i],
  947.                     t = this.getTransaction(e);
  948.                 this.fireEvent('data', this, e);
  949.                 if(t){
  950.                     this.doCallback(t, e, true);
  951.                     Ext.Direct.removeTransaction(t);
  952.                 }
  953.             }
  954.         }else{
  955.             var ts = [].concat(opt.ts);
  956.             for(var i = 0, len = ts.length; i < len; i++){
  957.                 var t = this.getTransaction(ts[i]);
  958.                 if(t && t.retryCount < this.maxRetries){
  959.                     t.retry();
  960.                 }else{
  961.                     var e = new Ext.Direct.ExceptionEvent({
  962.                         data: e,
  963.                         transaction: t,
  964.                         code: Ext.Direct.exceptions.TRANSPORT,
  965.                         message: 'Unable to connect to the server.',
  966.                         xhr: xhr
  967.                     });
  968.                     this.fireEvent('data', this, e);
  969.                     if(t){
  970.                         this.doCallback(t, e, false);
  971.                         Ext.Direct.removeTransaction(t);
  972.                     }
  973.                 }
  974.             }
  975.         }
  976.     },
  978.     getCallData: function(t){
  979.         return {
  980.             action: t.action,
  981.             method: t.method,
  982.             data: t.data,
  983.             type: 'rpc',
  984.             tid: t.tid
  985.         };
  986.     },
  988.     doSend : function(data){
  989.         var o = {
  990.             url: this.url,
  991.             callback: this.onData,
  992.             scope: this,
  993.             ts: data,
  994.             timeout: this.timeout
  995.         }, callData;
  997.         if(Ext.isArray(data)){
  998.             callData = [];
  999.             for(var i = 0, len = data.length; i < len; i++){
  1000.                 callData.push(this.getCallData(data[i]));
  1001.             }
  1002.         }else{
  1003.             callData = this.getCallData(data);
  1004.         }
  1006.         if(this.enableUrlEncode){
  1007.             var params = {};
  1008.             params[Ext.isString(this.enableUrlEncode) ? this.enableUrlEncode : 'data'] = Ext.encode(callData);
  1009.             o.params = params;
  1010.         }else{
  1011.             o.jsonData = callData;
  1012.         }
  1013.         Ext.Ajax.request(o);
  1014.     },
  1016.     combineAndSend : function(){
  1017.         var len = this.callBuffer.length;
  1018.         if(len > 0){
  1019.             this.doSend(len == 1 ? this.callBuffer[0] : this.callBuffer);
  1020.             this.callBuffer = [];
  1021.         }
  1022.     },
  1024.     queueTransaction: function(t){
  1025.         if(t.form){
  1026.             this.processForm(t);
  1027.             return;
  1028.         }
  1029.         this.callBuffer.push(t);
  1030.         if(this.enableBuffer){
  1031.             if(!this.callTask){
  1032.                 this.callTask = new Ext.util.DelayedTask(this.combineAndSend, this);
  1033.             }
  1034.             this.callTask.delay(Ext.isNumber(this.enableBuffer) ? this.enableBuffer : 10);
  1035.         }else{
  1036.             this.combineAndSend();
  1037.         }
  1038.     },
  1040.     doCall : function(c, m, args){
  1041.         var data = null, hs = args[m.len], scope = args[m.len+1];
  1043.         if(m.len !== 0){
  1044.             data = args.slice(0, m.len);
  1045.         }
  1047.         var t = new Ext.Direct.Transaction({
  1048.             provider: this,
  1049.             args: args,
  1050.             action: c,
  1051.             method: m.name,
  1052.             data: data,
  1053.             cb: scope && Ext.isFunction(hs) ? hs.createDelegate(scope) : hs
  1054.         });
  1056.         if(this.fireEvent('beforecall', this, t) !== false){
  1057.             Ext.Direct.addTransaction(t);
  1058.             this.queueTransaction(t);
  1059.             this.fireEvent('call', this, t);
  1060.         }
  1061.     },
  1063.     doForm : function(c, m, form, callback, scope){
  1064.         var t = new Ext.Direct.Transaction({
  1065.             provider: this,
  1066.             action: c,
  1067.             method: m.name,
  1068.             args:[form, callback, scope],
  1069.             cb: scope && Ext.isFunction(callback) ? callback.createDelegate(scope) : callback,
  1070.             isForm: true
  1071.         });
  1073.         if(this.fireEvent('beforecall', this, t) !== false){
  1074.             Ext.Direct.addTransaction(t);
  1075.             var isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data',
  1076.                 params = {
  1077.                     extTID: t.tid,
  1078.                     extAction: c,
  1079.                     extMethod: m.name,
  1080.                     extType: 'rpc',
  1081.                     extUpload: String(isUpload)
  1082.                 };
  1083.             
  1084.             // change made from typeof callback check to callback.params
  1085.             // to support addl param passing in DirectSubmit EAC 6/2
  1086.             Ext.apply(t, {
  1087.                 form: Ext.getDom(form),
  1088.                 isUpload: isUpload,
  1089.                 params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params
  1090.             });
  1091.             this.fireEvent('call', this, t);
  1092.             this.processForm(t);
  1093.         }
  1094.     },
  1095.     
  1096.     processForm: function(t){
  1097.         Ext.Ajax.request({
  1098.             url: this.url,
  1099.             params: t.params,
  1100.             callback: this.onData,
  1101.             scope: this,
  1102.             form: t.form,
  1103.             isUpload: t.isUpload,
  1104.             ts: t
  1105.         });
  1106.     },
  1108.     createMethod : function(c, m){
  1109.         var f;
  1110.         if(!m.formHandler){
  1111.             f = function(){
  1112.                 this.doCall(c, m, Array.prototype.slice.call(arguments, 0));
  1113.             }.createDelegate(this);
  1114.         }else{
  1115.             f = function(form, callback, scope){
  1116.                 this.doForm(c, m, form, callback, scope);
  1117.             }.createDelegate(this);
  1118.         }
  1119.         f.directCfg = {
  1120.             action: c,
  1121.             method: m
  1122.         };
  1123.         return f;
  1124.     },
  1126.     getTransaction: function(opt){
  1127.         return opt && opt.tid ? Ext.Direct.getTransaction(opt.tid) : null;
  1128.     },
  1130.     doCallback: function(t, e){
  1131.         var fn = e.status ? 'success' : 'failure';
  1132.         if(t && t.cb){
  1133.             var hs = t.cb,
  1134.                 result = Ext.isDefined(e.result) ? e.result : e.data;
  1135.             if(Ext.isFunction(hs)){
  1136.                 hs(result, e);
  1137.             } else{
  1138.                 Ext.callback(hs[fn], hs.scope, [result, e]);
  1139.                 Ext.callback(hs.callback, hs.scope, [result, e]);
  1140.             }
  1141.         }
  1142.     }
  1143. });
  1144. Ext.Direct.PROVIDERS['remoting'] = Ext.direct.RemotingProvider;