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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 中间件编程 > 查看源码
direct-debug.js
资源名称：ext-3.0.0.zip　[点击查看]
上传用户：shuoshiled
上传日期：2018-01-28
资源大小：10124k
文件大小：39k
源码类别：

中间件编程

开发平台：

JavaScript

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