      1 /**
      2  * @ignore
      3  */
      4 var Ozone = Ozone ? Ozone : {};
      5
      6 /**
      7  * @ignore
      8  * @namespace
      9  */
     10 Ozone.eventing = Ozone.eventing ? Ozone.eventing : {};
     11
     12 (function (window, document, undefined) {
     13
     14     function rpcCall(widgetId, widgetIdCaller, functionName, var_args) {
     15         gadgets.rpc.call("..", "FUNCTION_CALL", null, widgetId, widgetIdCaller, functionName, var_args);
     16     }
     17
     18     /**
     19      * Creates or updates a proxy - This is a private constructor - Do not call this directly.  The other
     20      * Widget APIs such as Widget Intents may return a proxy.  A proxy may contain dynamic functions that were
     21      * registered by the origin widget.
     22      *
     23      * @param {String} wid Id of the Widget this proxy represents
     24      * @param {Object[]} functions Array of objects representing proxy functions
     25      * @param {String} srcId Id of the source Widget who is using the proxy
     26      * @param {Ozone.eventing.WidgetProxy} [proxy] A existing proxy object to be used, instead of creating a new instance
     27      * @constructor
     28      */
     29     Ozone.eventing.WidgetProxy = function (wid, functions, srcId, proxy) {
     30         var widgetId = wid,
     31             readyList = [],
     32             pub = proxy;
     33
     34         if (pub == null) {
     35             pub = /** @lends Ozone.eventing.WidgetProxy.prototype */ {
     36
     37                 /**
     38                  * Id of the Widget that this proxy represents
     39                  */
     40                 id:wid,
     41                 /**
     42                  * Flag which represents if the Widget this proxy represents
     43                  */
     44                 isReady:false,
     45                 callbacks:{},
     46                 /**
     47                  * Sends a direct message to the Widget this proxy represents
     48                  * @param {Object} dataToSend
     49                  * @example
     50                  * var widgetProxy = OWF.RPC.getWidgetProxy(id);
     51                  * widgetProxy.sendMessage({data:'foo'});
     52                  */
     53                 sendMessage:function (dataToSend) {
     54                     gadgets.rpc.call("..", 'DIRECT_MESSAGE', null, widgetId, dataToSend);
     55                 },
     56
     57                 /**
     58                  * Registers a listener function to be executed when the Widget has called notifyReady
     59                  * @param {function} readyListener function to execute
     60                  * @param {Object} readyListenerScope scope for the function to execute with
     61                  * @example
     62                  * var widgetProxy = OWF.RPC.getWidgetProxy(id);
     63                  * widgetProxy.onReady(function() { console.log("Other widget is ready!"); });
     64                  */
     65                 onReady:function (readyListener, readyListenerScope) {
     66
     67                     if (this.isReady) {
     68                         //just execute because the widget is already ready
     69                         readyListener.call(readyListenerScope);
     70                     }
     71                     else {
     72                         //save ready listeners
     73                         readyList.push({fn:readyListener, scope:readyListenerScope});
     74                     }
     75                 },
     76                 fireReady: function() {
     77                     this.isReady = true;
     78                     for (var i = 0, len = readyList.length; i < len; i++) {
     79                         readyList[i].fn.call(readyList[i].scope);
     80                     }
     81                 }
     82             };
     83         }
     84
     85         if (functions != null) {
     86             for (var ii = 0; ii < functions.length; ii++) {
     87                 var functionName = functions[ii];
     88
     89                 pub[functionName] = function (name) {
     90                     return function () {
     91                         var callback = arguments[arguments.length - 1];
     92                         var callbackExists = typeof callback == 'function';
     93                         var args = Array.prototype.slice.call(arguments, 0, callbackExists ? arguments.length - 1 : arguments.length);
     94                         if (callbackExists) {
     95                             pub.callbacks[name] = callback;
     96                         }
     97                         rpcCall.call(this, widgetId, srcId, name, args);
     98                     }
     99                 }(functionName);
    100
    101             }
    102         }
    103
    104         return pub;
    105     };
    106
    107 }(window, document));