docs/source/Manager2.html

   1 <!DOCTYPE html><html><head><title>Sencha Documentation Project</title><link rel="stylesheet" href="../reset.css" type="text/css"><link rel="stylesheet" href="../prettify.css" type="text/css"><link rel="stylesheet" href="../prettify_sa.css" type="text/css"><script type="text/javascript" src="../prettify.js"></script></head><body onload="prettyPrint()"><pre class="prettyprint"><pre><span id='Ext-direct.Manager'>/**
   2 </span> * @class Ext.direct.Manager
   3  * &lt;p&gt;&lt;b&gt;&lt;u&gt;Overview&lt;/u&gt;&lt;/b&gt;&lt;/p&gt;
   4  *
   5  * &lt;p&gt;Ext.Direct aims to streamline communication between the client and server
   6  * by providing a single interface that reduces the amount of common code
   7  * typically required to validate data and handle returned data packets
   8  * (reading data, error conditions, etc).&lt;/p&gt;
   9  *
  10  * &lt;p&gt;The Ext.direct namespace includes several classes for a closer integration
  11  * with the server-side. The Ext.data namespace also includes classes for working
  12  * with Ext.data.Stores which are backed by data from an Ext.Direct method.&lt;/p&gt;
  13  *
  14  * &lt;p&gt;&lt;b&gt;&lt;u&gt;Specification&lt;/u&gt;&lt;/b&gt;&lt;/p&gt;
  15  *
  16  * &lt;p&gt;For additional information consult the
  17  * &lt;a href=&quot;http://sencha.com/products/extjs/extdirect&quot;&gt;Ext.Direct Specification&lt;/a&gt;.&lt;/p&gt;
  18  *
  19  * &lt;p&gt;&lt;b&gt;&lt;u&gt;Providers&lt;/u&gt;&lt;/b&gt;&lt;/p&gt;
  20  *
  21  * &lt;p&gt;Ext.Direct uses a provider architecture, where one or more providers are
  22  * used to transport data to and from the server. There are several providers
  23  * that exist in the core at the moment:&lt;/p&gt;&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
  24  *
  25  * &lt;li&gt;{@link Ext.direct.JsonProvider JsonProvider} for simple JSON operations&lt;/li&gt;
  26  * &lt;li&gt;{@link Ext.direct.PollingProvider PollingProvider} for repeated requests&lt;/li&gt;
  27  * &lt;li&gt;{@link Ext.direct.RemotingProvider RemotingProvider} exposes server side
  28  * on the client.&lt;/li&gt;
  29  * &lt;/ul&gt;&lt;/div&gt;
  30  *
  31  * &lt;p&gt;A provider does not need to be invoked directly, providers are added via
  32  * {@link Ext.direct.Manager}.{@link Ext.direct.Manager#add add}.&lt;/p&gt;
  33  *
  34  * &lt;p&gt;&lt;b&gt;&lt;u&gt;Router&lt;/u&gt;&lt;/b&gt;&lt;/p&gt;
  35  *
  36  * &lt;p&gt;Ext.Direct utilizes a &quot;router&quot; on the server to direct requests from the client
  37  * to the appropriate server-side method. Because the Ext.Direct API is completely
  38  * platform-agnostic, you could completely swap out a Java based server solution
  39  * and replace it with one that uses C# without changing the client side JavaScript
  40  * at all.&lt;/p&gt;
  41  *
  42  * &lt;p&gt;&lt;b&gt;&lt;u&gt;Server side events&lt;/u&gt;&lt;/b&gt;&lt;/p&gt;
  43  *
  44  * &lt;p&gt;Custom events from the server may be handled by the client by adding
  45  * listeners, for example:&lt;/p&gt;
  46  * &lt;pre&gt;&lt;code&gt;
  47 {&quot;type&quot;:&quot;event&quot;,&quot;name&quot;:&quot;message&quot;,&quot;data&quot;:&quot;Successfully polled at: 11:19:30 am&quot;}
  48
  49 // add a handler for a 'message' event sent by the server
  50 Ext.direct.Manager.on('message', function(e){
  51     out.append(String.format('&amp;lt;p&gt;&amp;lt;i&gt;{0}&amp;lt;/i&gt;&amp;lt;/p&gt;', e.data));
  52             out.el.scrollTo('t', 100000, true);
  53 });
  54  * &lt;/code&gt;&lt;/pre&gt;
  55  * @singleton
  56  */
  57
  58 Ext.define('Ext.direct.Manager', {
  59
  60     /* Begin Definitions */
  61     singleton: true,
  62
  63     mixins: {
  64         observable: 'Ext.util.Observable'
  65     },
  66
  67     requires: ['Ext.util.MixedCollection'],
  68
  69     statics: {
  70         exceptions: {
  71             TRANSPORT: 'xhr',
  72             PARSE: 'parse',
  73             LOGIN: 'login',
  74             SERVER: 'exception'
  75         }
  76     },
  77
  78     /* End Definitions */
  79
  80     constructor: function(){
  81         var me = this;
  82
  83         me.addEvents(
  84 <span id='Ext-direct.Manager-event-event'>            /**
  85 </span>             * @event event
  86              * Fires after an event.
  87              * @param {event} e The Ext.direct.Event type that occurred.
  88              * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}.
  89              */
  90             'event',
  91 <span id='Ext-direct.Manager-event-exception'>            /**
  92 </span>             * @event exception
  93              * Fires after an event exception.
  94              * @param {event} e The Ext.direct.Event type that occurred.
  95              */
  96             'exception'
  97         );
  98         me.transactions = Ext.create('Ext.util.MixedCollection');
  99         me.providers = Ext.create('Ext.util.MixedCollection');
 100
 101         me.mixins.observable.constructor.call(me);
 102     },
 103
 104 <span id='Ext-direct.Manager-method-addProvider'>    /**
 105 </span>     * Adds an Ext.Direct Provider and creates the proxy or stub methods to execute server-side methods.
 106      * If the provider is not already connected, it will auto-connect.
 107      * &lt;pre&gt;&lt;code&gt;
 108 var pollProv = new Ext.direct.PollingProvider({
 109     url: 'php/poll2.php'
 110 });
 111
 112 Ext.direct.Manager.addProvider({
 113     &quot;type&quot;:&quot;remoting&quot;,       // create a {@link Ext.direct.RemotingProvider}
 114     &quot;url&quot;:&quot;php\/router.php&quot;, // url to connect to the Ext.Direct server-side router.
 115     &quot;actions&quot;:{              // each property within the actions object represents a Class
 116         &quot;TestAction&quot;:[       // array of methods within each server side Class
 117         {
 118             &quot;name&quot;:&quot;doEcho&quot;, // name of method
 119             &quot;len&quot;:1
 120         },{
 121             &quot;name&quot;:&quot;multiply&quot;,
 122             &quot;len&quot;:1
 123         },{
 124             &quot;name&quot;:&quot;doForm&quot;,
 125             &quot;formHandler&quot;:true, // handle form on server with Ext.Direct.Transaction
 126             &quot;len&quot;:1
 127         }]
 128     },
 129     &quot;namespace&quot;:&quot;myApplication&quot;,// namespace to create the Remoting Provider in
 130 },{
 131     type: 'polling', // create a {@link Ext.direct.PollingProvider}
 132     url:  'php/poll.php'
 133 }, pollProv); // reference to previously created instance
 134      * &lt;/code&gt;&lt;/pre&gt;
 135      * @param {Object/Array} provider Accepts either an Array of Provider descriptions (an instance
 136      * or config object for a Provider) or any number of Provider descriptions as arguments.  Each
 137      * Provider description instructs Ext.Direct how to create client-side stub methods.
 138      */
 139     addProvider : function(provider){
 140         var me = this,
 141             args = arguments,
 142             i = 0,
 143             len;
 144
 145         if (args.length &gt; 1) {
 146             for (len = args.length; i &lt; len; ++i) {
 147                 me.addProvider(args[i]);
 148             }
 149             return;
 150         }
 151
 152         // if provider has not already been instantiated
 153         if (!provider.isProvider) {
 154             provider = Ext.create('direct.' + provider.type + 'provider', provider);
 155         }
 156         me.providers.add(provider);
 157         provider.on('data', me.onProviderData, me);
 158
 159
 160         if (!provider.isConnected()) {
 161             provider.connect();
 162         }
 163
 164         return provider;
 165     },
 166
 167 <span id='Ext-direct.Manager-method-getProvider'>    /**
 168 </span>     * Retrieve a {@link Ext.direct.Provider provider} by the
 169      * &lt;b&gt;&lt;tt&gt;{@link Ext.direct.Provider#id id}&lt;/tt&gt;&lt;/b&gt; specified when the provider is
 170      * {@link #addProvider added}.
 171      * @param {String/Ext.data.Provider} id The id of the provider, or the provider instance.
 172      */
 173     getProvider : function(id){
 174         return id.isProvider ? id : this.providers.get(id);
 175     },
 176
 177 <span id='Ext-direct.Manager-method-removeProvider'>    /**
 178 </span>     * Removes the provider.
 179      * @param {String/Ext.direct.Provider} provider The provider instance or the id of the provider.
 180      * @return {Ext.direct.Provider} The provider, null if not found.
 181      */
 182     removeProvider : function(provider){
 183         var me = this,
 184             providers = me.providers,
 185             provider = provider.isProvider ? provider : providers.get(provider);
 186
 187         if (provider) {
 188             provider.un('data', me.onProviderData, me);
 189             providers.remove(provider);
 190             return provider;
 191         }
 192         return null;
 193     },
 194
 195 <span id='Ext-direct.Manager-method-addTransaction'>    /**
 196 </span>     * Add a transaction to the manager.
 197      * @private
 198      * @param {Ext.direct.Transaction} transaction The transaction to add
 199      * @return {Ext.direct.Transaction} transaction
 200      */
 201     addTransaction: function(transaction){
 202         this.transactions.add(transaction);
 203         return transaction;
 204     },
 205
 206 <span id='Ext-direct.Manager-method-removeTransaction'>    /**
 207 </span>     * Remove a transaction from the manager.
 208      * @private
 209      * @param {String/Ext.direct.Transaction} transaction The transaction/id of transaction to remove
 210      * @return {Ext.direct.Transaction} transaction
 211      */
 212     removeTransaction: function(transaction){
 213         transaction = this.getTransaction(transaction);
 214         this.transactions.remove(transaction);
 215         return transaction;
 216     },
 217
 218 <span id='Ext-direct.Manager-method-getTransaction'>    /**
 219 </span>     * Gets a transaction
 220      * @private
 221      * @param {String/Ext.direct.Transaction} transaction The transaction/id of transaction to get
 222      * @return {Ext.direct.Transaction}
 223      */
 224     getTransaction: function(transaction){
 225         return transaction.isTransaction ? transaction : this.transactions.get(transaction);
 226     },
 227
 228     onProviderData : function(provider, event){
 229         var me = this,
 230             i = 0,
 231             len;
 232
 233         if (Ext.isArray(event)) {
 234             for (len = event.length; i &lt; len; ++i) {
 235                 me.onProviderData(provider, event[i]);
 236             }
 237             return;
 238         }
 239         if (event.name &amp;&amp; event.name != 'event' &amp;&amp; event.name != 'exception') {
 240             me.fireEvent(event.name, event);
 241         } else if (event.type == 'exception') {
 242             me.fireEvent('exception', event);
 243         }
 244         me.fireEvent('event', event, provider);
 245     }
 246 }, function(){
 247     // Backwards compatibility
 248     Ext.Direct = Ext.direct.Manager;
 249 });
 250 </pre></pre></body></html>