+<!DOCTYPE html>
<html>
<head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>The source code</title>
- <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
- <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
+ <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
+ <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
+ <style type="text/css">
+ .highlight { display: block; background-color: #ddd; }
+ </style>
+ <script type="text/javascript">
+ function highlight() {
+ document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
+ }
+ </script>
</head>
-<body onload="prettyPrint();">
- <pre class="prettyprint lang-js">/*!
- * Ext JS Library 3.2.2
- * Copyright(c) 2006-2010 Ext JS, Inc.
- * licensing@extjs.com
- * http://www.extjs.com/license
- */
-<div id="cls-Ext.direct.RemotingProvider"></div>/**
- * @class Ext.direct.RemotingProvider
+<body onload="prettyPrint(); highlight();">
+ <pre class="prettyprint lang-js"><span id='Ext-direct-RemotingProvider'>/**
+</span> * @class Ext.direct.RemotingProvider
* @extends Ext.direct.JsonProvider
*
- * <p>The {@link Ext.direct.RemotingProvider RemotingProvider} exposes access to
+ * <p>The {@link Ext.direct.RemotingProvider RemotingProvider} exposes access to
* server side methods on the client (a remote procedure call (RPC) type of
- * connection where the client can initiate a procedure on the server).</p>
+ * connection where the client can initiate a procedure on the server).</p>
*
- * <p>This allows for code to be organized in a fashion that is maintainable,
+ * <p>This allows for code to be organized in a fashion that is maintainable,
* while providing a clear path between client and server, something that is
- * not always apparent when using URLs.</p>
+ * not always apparent when using URLs.</p>
*
- * <p>To accomplish this the server-side needs to describe what classes and methods
+ * <p>To accomplish this the server-side needs to describe what classes and methods
* are available on the client-side. This configuration will typically be
- * outputted by the server-side Ext.Direct stack when the API description is built.</p>
+ * outputted by the server-side Ext.Direct stack when the API description is built.</p>
*/
-Ext.direct.RemotingProvider = Ext.extend(Ext.direct.JsonProvider, {
- <div id="cfg-Ext.direct.RemotingProvider-actions"></div>/**
- * @cfg {Object} actions
+Ext.define('Ext.direct.RemotingProvider', {
+
+ /* Begin Definitions */
+
+ alias: 'direct.remotingprovider',
+
+ extend: 'Ext.direct.JsonProvider',
+
+ requires: [
+ 'Ext.util.MixedCollection',
+ 'Ext.util.DelayedTask',
+ 'Ext.direct.Transaction',
+ 'Ext.direct.RemotingMethod'
+ ],
+
+ /* End Definitions */
+
+<span id='Ext-direct-RemotingProvider-cfg-actions'> /**
+</span> * @cfg {Object} actions
* Object literal defining the server side actions and methods. For example, if
* the Provider is configured with:
- * <pre><code>
-"actions":{ // each property within the 'actions' object represents a server side Class
- "TestAction":[ // array of methods within each server side Class to be
+ * <pre><code>
+"actions":{ // each property within the 'actions' object represents a server side Class
+ "TestAction":[ // array of methods within each server side Class to be
{ // stubbed out on client
- "name":"doEcho",
- "len":1
+ "name":"doEcho",
+ "len":1
},{
- "name":"multiply",// name of method
- "len":2 // The number of parameters that will be used to create an
+ "name":"multiply",// name of method
+ "len":2 // The number of parameters that will be used to create an
// array of data to send to the server side function.
// Ensure the server sends back a Number, not a String.
},{
- "name":"doForm",
- "formHandler":true, // direct the client to use specialized form handling method
- "len":1
+ "name":"doForm",
+ "formHandler":true, // direct the client to use specialized form handling method
+ "len":1
}]
}
- * </code></pre>
- * <p>Note that a Store is not required, a server method can be called at any time.
- * In the following example a <b>client side</b> handler is used to call the
- * server side method "multiply" in the server-side "TestAction" Class:</p>
- * <pre><code>
+ * </code></pre>
+ * <p>Note that a Store is not required, a server method can be called at any time.
+ * In the following example a <b>client side</b> handler is used to call the
+ * server side method "multiply" in the server-side "TestAction" Class:</p>
+ * <pre><code>
TestAction.multiply(
2, 4, // pass two arguments to server, so specify len=2
// callback function after the server is called
// result: the result returned by the server
- // e: Ext.Direct.RemotingEvent object
+ // e: Ext.direct.RemotingEvent object
function(result, e){
var t = e.getTransaction();
var action = t.action; // server side Class called
}
}
);
- * </code></pre>
- * In the example above, the server side "multiply" function will be passed two
- * arguments (2 and 4). The "multiply" method should return the value 8 which will be
- * available as the <tt>result</tt> in the example above.
+ * </code></pre>
+ * In the example above, the server side "multiply" function will be passed two
+ * arguments (2 and 4). The "multiply" method should return the value 8 which will be
+ * available as the <tt>result</tt> in the example above.
*/
- <div id="cfg-Ext.direct.RemotingProvider-namespace"></div>/**
- * @cfg {String/Object} namespace
- * Namespace for the Remoting Provider (defaults to the browser global scope of <i>window</i>).
+<span id='Ext-direct-RemotingProvider-cfg-namespace'> /**
+</span> * @cfg {String/Object} namespace
+ * Namespace for the Remoting Provider (defaults to the browser global scope of <i>window</i>).
* Explicitly specify the namespace Object, or specify a String to have a
* {@link Ext#namespace namespace created} implicitly.
*/
- <div id="cfg-Ext.direct.RemotingProvider-url"></div>/**
- * @cfg {String} url
- * <b>Required<b>. The url to connect to the {@link Ext.Direct} server-side router.
+<span id='Ext-direct-RemotingProvider-cfg-url'> /**
+</span> * @cfg {String} url
+ * <b>Required</b>. The url to connect to the {@link Ext.direct.Manager} server-side router.
*/
- <div id="cfg-Ext.direct.RemotingProvider-enableUrlEncode"></div>/**
- * @cfg {String} enableUrlEncode
+<span id='Ext-direct-RemotingProvider-cfg-enableUrlEncode'> /**
+</span> * @cfg {String} enableUrlEncode
* Specify which param will hold the arguments for the method.
- * Defaults to <tt>'data'</tt>.
+ * Defaults to <tt>'data'</tt>.
*/
- <div id="cfg-Ext.direct.RemotingProvider-enableBuffer"></div>/**
- * @cfg {Number/Boolean} enableBuffer
- * <p><tt>true</tt> or <tt>false</tt> to enable or disable combining of method
+<span id='Ext-direct-RemotingProvider-cfg-enableBuffer'> /**
+</span> * @cfg {Number/Boolean} enableBuffer
+ * <p><tt>true</tt> or <tt>false</tt> to enable or disable combining of method
* calls. If a number is specified this is the amount of time in milliseconds
- * to wait before sending a batched request (defaults to <tt>10</tt>).</p>
- * <br><p>Calls which are received within the specified timeframe will be
+ * to wait before sending a batched request.</p>
+ * <br><p>Calls which are received within the specified timeframe will be
* concatenated together and sent in a single request, optimizing the
* application by reducing the amount of round trips that have to be made
- * to the server.</p>
+ * to the server.</p>
*/
enableBuffer: 10,
- <div id="cfg-Ext.direct.RemotingProvider-maxRetries"></div>/**
- * @cfg {Number} maxRetries
- * Number of times to re-attempt delivery on failure of a call. Defaults to <tt>1</tt>.
+<span id='Ext-direct-RemotingProvider-cfg-maxRetries'> /**
+</span> * @cfg {Number} maxRetries
+ * Number of times to re-attempt delivery on failure of a call.
*/
maxRetries: 1,
- <div id="cfg-Ext.direct.RemotingProvider-timeout"></div>/**
- * @cfg {Number} timeout
- * The timeout to use for each request. Defaults to <tt>undefined</tt>.
+<span id='Ext-direct-RemotingProvider-cfg-timeout'> /**
+</span> * @cfg {Number} timeout
+ * The timeout to use for each request.
*/
timeout: undefined,
-
+
constructor : function(config){
- Ext.direct.RemotingProvider.superclass.constructor.call(this, config);
- this.addEvents(
- <div id="event-Ext.direct.RemotingProvider-beforecall"></div>/**
- * @event beforecall
+ var me = this;
+ me.callParent(arguments);
+ me.addEvents(
+<span id='Ext-direct-RemotingProvider-event-beforecall'> /**
+</span> * @event beforecall
* Fires immediately before the client-side sends off the RPC call.
* By returning false from an event handler you can prevent the call from
* executing.
* @param {Ext.direct.RemotingProvider} provider
- * @param {Ext.Direct.Transaction} transaction
+ * @param {Ext.direct.Transaction} transaction
* @param {Object} meta The meta data
*/
'beforecall',
- <div id="event-Ext.direct.RemotingProvider-call"></div>/**
- * @event call
+<span id='Ext-direct-RemotingProvider-event-call'> /**
+</span> * @event call
* Fires immediately after the request to the server-side is sent. This does
* NOT fire after the response has come back from the call.
* @param {Ext.direct.RemotingProvider} provider
- * @param {Ext.Direct.Transaction} transaction
+ * @param {Ext.direct.Transaction} transaction
* @param {Object} meta The meta data
*/
'call'
);
- this.namespace = (Ext.isString(this.namespace)) ? Ext.ns(this.namespace) : this.namespace || window;
- this.transactions = {};
- this.callBuffer = [];
+ me.namespace = (Ext.isString(me.namespace)) ? Ext.ns(me.namespace) : me.namespace || window;
+ me.transactions = Ext.create('Ext.util.MixedCollection');
+ me.callBuffer = [];
},
-
- // private
+
+<span id='Ext-direct-RemotingProvider-method-initAPI'> /**
+</span> * Initialize the API
+ * @private
+ */
initAPI : function(){
- var o = this.actions;
- for(var c in o){
- var cls = this.namespace[c] || (this.namespace[c] = {}),
- ms = o[c];
- for(var i = 0, len = ms.length; i < len; i++){
- var m = ms[i];
- cls[m.name] = this.createMethod(c, m);
+ var actions = this.actions,
+ namespace = this.namespace,
+ action,
+ cls,
+ methods,
+ i,
+ len,
+ method;
+
+ for (action in actions) {
+ cls = namespace[action];
+ if (!cls) {
+ cls = namespace[action] = {};
+ }
+ methods = actions[action];
+
+ for (i = 0, len = methods.length; i < len; ++i) {
+ method = Ext.create('Ext.direct.RemotingMethod', methods[i]);
+ cls[method.name] = this.createHandler(action, method);
}
}
},
-
- // inherited
+
+<span id='Ext-direct-RemotingProvider-method-createHandler'> /**
+</span> * Create a handler function for a direct call.
+ * @private
+ * @param {String} action The action the call is for
+ * @param {Object} method The details of the method
+ * @return {Function} A JS function that will kick off the call
+ */
+ createHandler : function(action, method){
+ var me = this,
+ handler;
+
+ if (!method.formHandler) {
+ handler = function(){
+ me.configureRequest(action, method, Array.prototype.slice.call(arguments, 0));
+ };
+ } else {
+ handler = function(form, callback, scope){
+ me.configureFormRequest(action, method, form, callback, scope);
+ };
+ }
+ handler.directCfg = {
+ action: action,
+ method: method
+ };
+ return handler;
+ },
+
+ // inherit docs
isConnected: function(){
return !!this.connected;
},
+ // inherit docs
connect: function(){
- if(this.url){
- this.initAPI();
- this.connected = true;
- this.fireEvent('connect', this);
- }else if(!this.url){
- throw 'Error initializing RemotingProvider, no url configured.';
+ var me = this;
+
+ if (me.url) {
+ me.initAPI();
+ me.connected = true;
+ me.fireEvent('connect', me);
+ } else if(!me.url) {
+ //<debug>
+ Ext.Error.raise('Error initializing RemotingProvider, no url configured.');
+ //</debug>
}
},
+ // inherit docs
disconnect: function(){
- if(this.connected){
- this.connected = false;
- this.fireEvent('disconnect', this);
+ var me = this;
+
+ if (me.connected) {
+ me.connected = false;
+ me.fireEvent('disconnect', me);
}
},
-
- onData: function(opt, success, xhr){
- if(success){
- var events = this.getEvents(xhr);
- for(var i = 0, len = events.length; i < len; i++){
- var e = events[i],
- t = this.getTransaction(e);
- this.fireEvent('data', this, e);
- if(t){
- this.doCallback(t, e, true);
- Ext.Direct.removeTransaction(t);
+
+<span id='Ext-direct-RemotingProvider-method-runCallback'> /**
+</span> * Run any callbacks related to the transaction.
+ * @private
+ * @param {Ext.direct.Transaction} transaction The transaction
+ * @param {Ext.direct.Event} event The event
+ */
+ runCallback: function(transaction, event){
+ var funcName = event.status ? 'success' : 'failure',
+ callback,
+ result;
+
+ if (transaction && transaction.callback) {
+ callback = transaction.callback;
+ result = Ext.isDefined(event.result) ? event.result : event.data;
+
+ if (Ext.isFunction(callback)) {
+ callback(result, event);
+ } else {
+ Ext.callback(callback[funcName], callback.scope, [result, event]);
+ Ext.callback(callback.callback, callback.scope, [result, event]);
+ }
+ }
+ },
+
+<span id='Ext-direct-RemotingProvider-method-onData'> /**
+</span> * React to the ajax request being completed
+ * @private
+ */
+ onData: function(options, success, response){
+ var me = this,
+ i = 0,
+ len,
+ events,
+ event,
+ transaction,
+ transactions;
+
+ if (success) {
+ events = me.createEvents(response);
+ for (len = events.length; i < len; ++i) {
+ event = events[i];
+ transaction = me.getTransaction(event);
+ me.fireEvent('data', me, event);
+ if (transaction) {
+ me.runCallback(transaction, event, true);
+ Ext.direct.Manager.removeTransaction(transaction);
}
}
- }else{
- var ts = [].concat(opt.ts);
- for(var i = 0, len = ts.length; i < len; i++){
- var t = this.getTransaction(ts[i]);
- if(t && t.retryCount < this.maxRetries){
- t.retry();
- }else{
- var e = new Ext.Direct.ExceptionEvent({
- data: e,
- transaction: t,
- code: Ext.Direct.exceptions.TRANSPORT,
+ } else {
+ transactions = [].concat(options.transaction);
+ for (len = transactions.length; i < len; ++i) {
+ transaction = me.getTransaction(transactions[i]);
+ if (transaction && transaction.retryCount < me.maxRetries) {
+ transaction.retry();
+ } else {
+ event = Ext.create('Ext.direct.ExceptionEvent', {
+ data: null,
+ transaction: transaction,
+ code: Ext.direct.Manager.self.exceptions.TRANSPORT,
message: 'Unable to connect to the server.',
- xhr: xhr
+ xhr: response
});
- this.fireEvent('data', this, e);
- if(t){
- this.doCallback(t, e, false);
- Ext.Direct.removeTransaction(t);
+ me.fireEvent('data', me, event);
+ if (transaction) {
+ me.runCallback(transaction, event, false);
+ Ext.direct.Manager.removeTransaction(transaction);
}
}
}
}
},
+
+<span id='Ext-direct-RemotingProvider-method-getTransaction'> /**
+</span> * Get transaction from XHR options
+ * @private
+ * @param {Object} options The options sent to the Ajax request
+ * @return {Ext.direct.Transaction} The transaction, null if not found
+ */
+ getTransaction: function(options){
+ return options && options.tid ? Ext.direct.Manager.getTransaction(options.tid) : null;
+ },
+
+<span id='Ext-direct-RemotingProvider-method-configureRequest'> /**
+</span> * Configure a direct request
+ * @private
+ * @param {String} action The action being executed
+ * @param {Object} method The being executed
+ */
+ configureRequest: function(action, method, args){
+ var me = this,
+ callData = method.getCallData(args),
+ data = callData.data,
+ callback = callData.callback,
+ scope = callData.scope,
+ transaction;
- getCallData: function(t){
+ transaction = Ext.create('Ext.direct.Transaction', {
+ provider: me,
+ args: args,
+ action: action,
+ method: method.name,
+ data: data,
+ callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback
+ });
+
+ if (me.fireEvent('beforecall', me, transaction, method) !== false) {
+ Ext.direct.Manager.addTransaction(transaction);
+ me.queueTransaction(transaction);
+ me.fireEvent('call', me, transaction, method);
+ }
+ },
+
+<span id='Ext-direct-RemotingProvider-method-getCallData'> /**
+</span> * Gets the Ajax call info for a transaction
+ * @private
+ * @param {Ext.direct.Transaction} transaction The transaction
+ * @return {Object} The call params
+ */
+ getCallData: function(transaction){
return {
- action: t.action,
- method: t.method,
- data: t.data,
+ action: transaction.action,
+ method: transaction.method,
+ data: transaction.data,
type: 'rpc',
- tid: t.tid
+ tid: transaction.id
};
},
+
+<span id='Ext-direct-RemotingProvider-method-sendRequest'> /**
+</span> * Sends a request to the server
+ * @private
+ * @param {Object/Array} data The data to send
+ */
+ sendRequest : function(data){
+ var me = this,
+ request = {
+ url: me.url,
+ callback: me.onData,
+ scope: me,
+ transaction: data,
+ timeout: me.timeout
+ }, callData,
+ enableUrlEncode = me.enableUrlEncode,
+ i = 0,
+ len,
+ params;
+
- doSend : function(data){
- var o = {
- url: this.url,
- callback: this.onData,
- scope: this,
- ts: data,
- timeout: this.timeout
- }, callData;
-
- if(Ext.isArray(data)){
+ if (Ext.isArray(data)) {
callData = [];
- for(var i = 0, len = data.length; i < len; i++){
- callData.push(this.getCallData(data[i]));
+ for (len = data.length; i < len; ++i) {
+ callData.push(me.getCallData(data[i]));
}
- }else{
- callData = this.getCallData(data);
- }
-
- if(this.enableUrlEncode){
- var params = {};
- params[Ext.isString(this.enableUrlEncode) ? this.enableUrlEncode : 'data'] = Ext.encode(callData);
- o.params = params;
- }else{
- o.jsonData = callData;
+ } else {
+ callData = me.getCallData(data);
}
- Ext.Ajax.request(o);
- },
- combineAndSend : function(){
- var len = this.callBuffer.length;
- if(len > 0){
- this.doSend(len == 1 ? this.callBuffer[0] : this.callBuffer);
- this.callBuffer = [];
+ if (enableUrlEncode) {
+ params = {};
+ params[Ext.isString(enableUrlEncode) ? enableUrlEncode : 'data'] = Ext.encode(callData);
+ request.params = params;
+ } else {
+ request.jsonData = callData;
}
+ Ext.Ajax.request(request);
},
-
- queueTransaction: function(t){
- if(t.form){
- this.processForm(t);
+
+<span id='Ext-direct-RemotingProvider-method-queueTransaction'> /**
+</span> * Add a new transaction to the queue
+ * @private
+ * @param {Ext.direct.Transaction} transaction The transaction
+ */
+ queueTransaction: function(transaction){
+ var me = this,
+ enableBuffer = me.enableBuffer;
+
+ if (transaction.form) {
+ me.sendFormRequest(transaction);
return;
}
- this.callBuffer.push(t);
- if(this.enableBuffer){
- if(!this.callTask){
- this.callTask = new Ext.util.DelayedTask(this.combineAndSend, this);
+
+ me.callBuffer.push(transaction);
+ if (enableBuffer) {
+ if (!me.callTask) {
+ me.callTask = Ext.create('Ext.util.DelayedTask', me.combineAndSend, me);
}
- this.callTask.delay(Ext.isNumber(this.enableBuffer) ? this.enableBuffer : 10);
- }else{
- this.combineAndSend();
+ me.callTask.delay(Ext.isNumber(enableBuffer) ? enableBuffer : 10);
+ } else {
+ me.combineAndSend();
}
},
-
- doCall : function(c, m, args){
- var data = null, hs = args[m.len], scope = args[m.len+1];
-
- if(m.len !== 0){
- data = args.slice(0, m.len);
- }
-
- var t = new Ext.Direct.Transaction({
- provider: this,
- args: args,
- action: c,
- method: m.name,
- data: data,
- cb: scope && Ext.isFunction(hs) ? hs.createDelegate(scope) : hs
- });
-
- if(this.fireEvent('beforecall', this, t, m) !== false){
- Ext.Direct.addTransaction(t);
- this.queueTransaction(t);
- this.fireEvent('call', this, t, m);
+
+<span id='Ext-direct-RemotingProvider-method-combineAndSend'> /**
+</span> * Combine any buffered requests and send them off
+ * @private
+ */
+ combineAndSend : function(){
+ var buffer = this.callBuffer,
+ len = buffer.length;
+
+ if (len > 0) {
+ this.sendRequest(len == 1 ? buffer[0] : buffer);
+ this.callBuffer = [];
}
},
+
+<span id='Ext-direct-RemotingProvider-method-configureFormRequest'> /**
+</span> * Configure a form submission request
+ * @private
+ * @param {String} action The action being executed
+ * @param {Object} method The method being executed
+ * @param {HTMLElement} form The form being submitted
+ * @param {Function} callback (optional) A callback to run after the form submits
+ * @param {Object} scope (optional) A scope to execute the callback in
+ */
+ configureFormRequest : function(action, method, form, callback, scope){
+ var me = this,
+ transaction = Ext.create('Ext.direct.Transaction', {
+ provider: me,
+ action: action,
+ method: method.name,
+ args: [form, callback, scope],
+ callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback,
+ isForm: true
+ }),
+ isUpload,
+ params;
- doForm : function(c, m, form, callback, scope){
- var t = new Ext.Direct.Transaction({
- provider: this,
- action: c,
- method: m.name,
- args:[form, callback, scope],
- cb: scope && Ext.isFunction(callback) ? callback.createDelegate(scope) : callback,
- isForm: true
- });
-
- if(this.fireEvent('beforecall', this, t, m) !== false){
- Ext.Direct.addTransaction(t);
- var isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data',
- params = {
- extTID: t.tid,
- extAction: c,
- extMethod: m.name,
- extType: 'rpc',
- extUpload: String(isUpload)
- };
+ if (me.fireEvent('beforecall', me, transaction, method) !== false) {
+ Ext.direct.Manager.addTransaction(transaction);
+ isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data';
+
+ params = {
+ extTID: transaction.id,
+ extAction: action,
+ extMethod: method.name,
+ extType: 'rpc',
+ extUpload: String(isUpload)
+ };
// change made from typeof callback check to callback.params
// to support addl param passing in DirectSubmit EAC 6/2
- Ext.apply(t, {
+ Ext.apply(transaction, {
form: Ext.getDom(form),
isUpload: isUpload,
- params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params
+ params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params
});
- this.fireEvent('call', this, t, m);
- this.processForm(t);
+ me.fireEvent('call', me, transaction, method);
+ me.sendFormRequest(transaction);
}
},
- processForm: function(t){
+<span id='Ext-direct-RemotingProvider-method-sendFormRequest'> /**
+</span> * Sends a form request
+ * @private
+ * @param {Ext.direct.Transaction} transaction The transaction to send
+ */
+ sendFormRequest: function(transaction){
Ext.Ajax.request({
url: this.url,
- params: t.params,
+ params: transaction.params,
callback: this.onData,
scope: this,
- form: t.form,
- isUpload: t.isUpload,
- ts: t
+ form: transaction.form,
+ isUpload: transaction.isUpload,
+ transaction: transaction
});
- },
-
- createMethod : function(c, m){
- var f;
- if(!m.formHandler){
- f = function(){
- this.doCall(c, m, Array.prototype.slice.call(arguments, 0));
- }.createDelegate(this);
- }else{
- f = function(form, callback, scope){
- this.doForm(c, m, form, callback, scope);
- }.createDelegate(this);
- }
- f.directCfg = {
- action: c,
- method: m
- };
- return f;
- },
-
- getTransaction: function(opt){
- return opt && opt.tid ? Ext.Direct.getTransaction(opt.tid) : null;
- },
-
- doCallback: function(t, e){
- var fn = e.status ? 'success' : 'failure';
- if(t && t.cb){
- var hs = t.cb,
- result = Ext.isDefined(e.result) ? e.result : e.data;
- if(Ext.isFunction(hs)){
- hs(result, e);
- } else{
- Ext.callback(hs[fn], hs.scope, [result, e]);
- Ext.callback(hs.callback, hs.scope, [result, e]);
- }
- }
}
+
});
-Ext.Direct.PROVIDERS['remoting'] = Ext.direct.RemotingProvider;</pre>
+</pre>
</body>
-</html>
\ No newline at end of file
+</html>
git.ithinksw.org / extjs.git / blobdiff