@qooxdoo/framework 7.0.0-beta.5 → 7.0.0-beta.9

package/source/class/qx/event/Emitter.js

@@ -20,19 +20,16 @@
  * Basic implementation for an event emitter. This supplies a basic and
  * minimalistic event mechanism.
  */
-qx.Bootstrap.define("qx.event.Emitter",
-{
-  extend : Object,
-  statics : {
+qx.Bootstrap.define("qx.event.Emitter", {
+  extend: Object,
+  statics: {
     /** Static storage for all event listener */
-    __storage : []
+    __storage: []
   },
 
-  members :
-  {
-    __listener : null,
-    __any : null,
-
+  members: {
+    __listener: null,
+    __any: null,
 
     /**
      * Attach a listener to the event emitter. The given <code>name</code>
@@ -44,14 +41,24 @@ qx.Bootstrap.define("qx.event.Emitter",
      * @param ctx {var?Window} The context of the listener.
      * @return {Integer} An unique <code>id</code> for the attached listener.
      */
-    on : function(name, listener, ctx) {
+    on(name, listener, ctx) {
       var id = qx.event.Emitter.__storage.length;
-      this.__getStorage(name).push({listener: listener, ctx: ctx, id: id, name: name});
-      qx.event.Emitter.__storage.push({name: name, listener: listener, ctx: ctx});
+      this.__getStorage(name).push({
+        listener: listener,
+        ctx: ctx,
+        id: id,
+        name: name
+      });
+
+      qx.event.Emitter.__storage.push({
+        name: name,
+        listener: listener,
+        ctx: ctx
+      });
+
       return id;
     },
 
-
     /**
      * Attach a listener to the event emitter which will be executed only once.
      * The given <code>name</code> will define the type of event. Handing in a
@@ -62,14 +69,24 @@ qx.Bootstrap.define("qx.event.Emitter",
      * @param ctx {var?Window} The context of the listener.
      * @return {Integer} An unique <code>id</code> for the attached listener.
      */
-    once : function(name, listener, ctx) {
+    once(name, listener, ctx) {
       var id = qx.event.Emitter.__storage.length;
-      this.__getStorage(name).push({listener: listener, ctx: ctx, once: true, id: id});
-      qx.event.Emitter.__storage.push({name: name, listener: listener, ctx: ctx});
+      this.__getStorage(name).push({
+        listener: listener,
+        ctx: ctx,
+        once: true,
+        id: id
+      });
+
+      qx.event.Emitter.__storage.push({
+        name: name,
+        listener: listener,
+        ctx: ctx
+      });
+
       return id;
     },
 
-
     /**
      * Remove a listener from the event emitter. The given <code>name</code>
      * will define the type of event.
@@ -80,7 +97,7 @@ qx.Bootstrap.define("qx.event.Emitter",
      * @return {Integer|null} The listener's id if it was removed or
      * <code>null</code> if it wasn't found
      */
-    off : function(name, listener, ctx) {
+    off(name, listener, ctx) {
       var storage = this.__getStorage(name);
       for (var i = storage.length - 1; i >= 0; i--) {
         var entry = storage[i];
@@ -93,7 +110,6 @@ qx.Bootstrap.define("qx.event.Emitter",
       return null;
     },
 
-
     /**
      * Removes the listener identified by the given <code>id</code>. The id
      * will be return on attaching the listener and can be stored for removing.
@@ -102,7 +118,7 @@ qx.Bootstrap.define("qx.event.Emitter",
      * @return {Integer|null} The listener's id if it was removed or
      * <code>null</code> if it wasn't found
      */
-    offById : function(id) {
+    offById(id) {
       var entry = qx.event.Emitter.__storage[id];
       if (entry) {
         this.off(entry.name, entry.listener, entry.ctx);
@@ -110,9 +126,6 @@ qx.Bootstrap.define("qx.event.Emitter",
       return null;
     },
 
-
-
-
     /**
      * Alternative for {@link #on}.
      * @param name {String} The name of the event to listen to.
@@ -120,11 +133,10 @@ qx.Bootstrap.define("qx.event.Emitter",
      * @param ctx {var?Window} The context of the listener.
      * @return {Integer} An unique <code>id</code> for the attached listener.
      */
-    addListener : function(name, listener, ctx) {
+    addListener(name, listener, ctx) {
       return this.on(name, listener, ctx);
     },
 
-
     /**
      * Alternative for {@link #once}.
      * @param name {String} The name of the event to listen to.
@@ -132,40 +144,35 @@ qx.Bootstrap.define("qx.event.Emitter",
      * @param ctx {var?Window} The context of the listener.
      * @return {Integer} An unique <code>id</code> for the attached listener.
      */
-    addListenerOnce : function(name, listener, ctx) {
+    addListenerOnce(name, listener, ctx) {
       return this.once(name, listener, ctx);
     },
 
-
     /**
      * Alternative for {@link #off}.
      * @param name {String} The name of the event to listen to.
      * @param listener {Function} The function execute on {@link #emit}.
      * @param ctx {var?Window} The context of the listener.
      */
-    removeListener : function(name, listener, ctx) {
+    removeListener(name, listener, ctx) {
       this.off(name, listener, ctx);
     },
 
-
     /**
      * Alternative for {@link #offById}.
      * @param id {Integer} The id of the listener.
      */
-    removeListenerById : function(id) {
-     this.offById(id);
+    removeListenerById(id) {
+      this.offById(id);
     },
 
-
-
-
     /**
      * Emits an event with the given name. The data will be passed
      * to the listener.
      * @param name {String} The name of the event to emit.
      * @param data {var?undefined} The data which should be passed to the listener.
      */
-    emit : function(name, data) {
+    emit(name, data) {
       var storage = this.__getStorage(name).concat();
       var toDelete = [];
       for (var i = 0; i < storage.length; i++) {
@@ -178,11 +185,13 @@ qx.Bootstrap.define("qx.event.Emitter",
 
       // listener callbacks could manipulate the storage
       // (e.g. module.Event.once)
-      toDelete.forEach(function(entry) {
-        var origStorage = this.__getStorage(name);
-        var idx = origStorage.indexOf(entry);
-        origStorage.splice(idx, 1);
-      }.bind(this));
+      toDelete.forEach(
+        function (entry) {
+          var origStorage = this.__getStorage(name);
+          var idx = origStorage.indexOf(entry);
+          origStorage.splice(idx, 1);
+        }.bind(this)
+      );
 
       // call on any
       storage = this.__getStorage("*");
@@ -192,19 +201,16 @@ qx.Bootstrap.define("qx.event.Emitter",
       }
     },
 
-
-
     /**
      * Returns the internal attached listener.
      * @internal
      * @return {Map} A map which has the event name as key. The values are
      *   arrays containing a map with 'listener' and 'ctx'.
      */
-    getListeners : function() {
+    getListeners() {
       return this.__listener;
     },
 
-
     /**
      * Returns the data entry for a given event id. If the entry could
      * not be found, undefined will be returned.
@@ -212,11 +218,11 @@ qx.Bootstrap.define("qx.event.Emitter",
      * @param id {Number} The listeners id
      * @return {Map|undefined} The data entry if found
      */
-    getEntryById : function(id) {
+    getEntryById(id) {
       for (var name in this.__listener) {
         var store = this.__listener[name];
 
-        for (var i=0, j=store.length; i<j; i++) {
+        for (var i = 0, j = store.length; i < j; i++) {
           if (store[i].id === id) {
             return store[i];
           }
@@ -224,14 +230,13 @@ qx.Bootstrap.define("qx.event.Emitter",
       }
     },
 
-
     /**
      * Internal helper which will return the storage for the given name.
      * @param name {String} The name of the event.
      * @return {Array} An array which is the storage for the listener and
      *   the given event name.
      */
-    __getStorage : function(name) {
+    __getStorage(name) {
       if (this.__listener == null) {
         this.__listener = {};
       }

package/source/class/qx/event/GlobalError.js

@@ -28,21 +28,19 @@
  *
  * @ignore(qx.core, qx.core.Environment)
  */
-qx.Bootstrap.define("qx.event.GlobalError",
-{
-  statics :
-  {
-    __callback : null,
+qx.Bootstrap.define("qx.event.GlobalError", {
+  statics: {
+    __callback: null,
 
-    __originalOnError : null,
+    __originalOnError: null,
 
-    __context : null,
+    __context: null,
 
     /**
      * Little helper to check if the global error handling is enabled.
      * @return {Boolean} <code>true</code>, if it is enabled.
      */
-    __isGlobalErrorHandlingEnabled : function() {
+    __isGlobalErrorHandlingEnabled() {
       if (qx.core && qx.core.Environment) {
         return qx.core.Environment.get("qx.globalErrorHandling");
       } else {
@@ -50,7 +48,6 @@ qx.Bootstrap.define("qx.event.GlobalError",
       }
     },
 
-
     /**
      * Set the global fallback error handler
      *
@@ -58,13 +55,11 @@ qx.Bootstrap.define("qx.event.GlobalError",
      *    exception, which caused the error
      * @param context {Object?window} The "this" context of the callback function
      */
-    setErrorHandler : function(callback, context)
-    {
+    setErrorHandler(callback, context) {
       this.__callback = callback || null;
       this.__context = context || window;
 
-      if (this.__isGlobalErrorHandlingEnabled())
-      {
+      if (this.__isGlobalErrorHandlingEnabled()) {
         // wrap the original onerror
         if (callback && window.onerror) {
           var wrappedHandler = qx.Bootstrap.bind(this.__onErrorWindow, this);
@@ -72,7 +67,7 @@ qx.Bootstrap.define("qx.event.GlobalError",
             this.__originalOnError = window.onerror;
           }
           var self = this;
-          window.onerror = function(msg, uri, lineNumber) {
+          window.onerror = function (msg, uri, lineNumber) {
             self.__originalOnError(msg, uri, lineNumber);
             wrappedHandler(msg, uri, lineNumber);
           };
@@ -94,7 +89,6 @@ qx.Bootstrap.define("qx.event.GlobalError",
       }
     },
 
-
     /**
      * Catches all errors of the <code>window.onerror</code> handler
      * and passes an {@link qx.core.WindowError} object to the error
@@ -106,15 +100,14 @@ qx.Bootstrap.define("qx.event.GlobalError",
      * @param columnNumber {Integer} column number of error
      * @param exception {Error} orginal error
      */
-    __onErrorWindow : function(msg, uri, lineNumber, columnNumber, exception)
-    {
-      if (this.__callback)
-      {
-        this.handleError(new qx.core.WindowError(msg, uri, lineNumber, columnNumber, exception));
+    __onErrorWindow(msg, uri, lineNumber, columnNumber, exception) {
+      if (this.__callback) {
+        this.handleError(
+          new qx.core.WindowError(msg, uri, lineNumber, columnNumber, exception)
+        );
       }
     },
 
-
     /**
      * Wraps a method with error handling code. Only methods, which are called
      * directly by the browser (e.g. event handler) should be wrapped.
@@ -122,47 +115,38 @@ qx.Bootstrap.define("qx.event.GlobalError",
      * @param method {Function} method to wrap
      * @return {Function} The function wrapped with error handling code
      */
-    observeMethod : function(method)
-    {
-      if (this.__isGlobalErrorHandlingEnabled())
-      {
+    observeMethod(method) {
+      if (this.__isGlobalErrorHandlingEnabled()) {
         var self = this;
-        return function()
-        {
+        return function () {
           if (!self.__callback) {
             return method.apply(this, arguments);
           }
 
           try {
             return method.apply(this, arguments);
-          } catch(ex) {
+          } catch (ex) {
             self.handleError(new qx.core.GlobalError(ex, arguments));
-         }
+          }
         };
-      }
-      else
-      {
+      } else {
         return method;
       }
     },
 
-
     /**
      * Delegates every given exception to the registered error handler
      *
      * @param ex {qx.core.WindowError|Error} Exception to delegate
      */
-    handleError : function(ex)
-    {
+    handleError(ex) {
       if (this.__callback) {
         this.__callback.call(this.__context, ex);
       }
     }
   },
 
-
-  defer : function(statics)
-  {
+  defer(statics) {
     // only use the environment class if already loaded
     if (qx.core && qx.core.Environment) {
       qx.core.Environment.add("qx.globalErrorHandling", true);

package/source/class/qx/event/IEventDispatcher.js

@@ -21,10 +21,8 @@
  * register themselves at the event Manager using
  * {@link qx.event.Registration#addDispatcher}.
  */
-qx.Interface.define("qx.event.IEventDispatcher",
-{
-  members:
-  {
+qx.Interface.define("qx.event.IEventDispatcher", {
+  members: {
     /**
      * Whether the dispatcher is responsible for the this event.
      *
@@ -33,13 +31,11 @@ qx.Interface.define("qx.event.IEventDispatcher",
      * @param type {String} the event type
      * @return {Boolean} Whether the event dispatcher is responsible for the this event
      */
-    canDispatchEvent : function(target, event, type)
-    {
+    canDispatchEvent(target, event, type) {
       this.assertInstance(event, qx.event.type.Event);
       this.assertString(type);
     },
 
-
     /**
      * This function dispatches the event to the event listeners.
      *
@@ -48,8 +44,7 @@ qx.Interface.define("qx.event.IEventDispatcher",
      * @param type {String} the event type
      * @return {qx.Promise?} a promise, if one or more of the event handlers returned a promise
      */
-    dispatchEvent : function(target, event, type)
-    {
+    dispatchEvent(target, event, type) {
       this.assertInstance(event, qx.event.type.Event);
       this.assertString(type);
     }

package/source/class/qx/event/IEventHandler.js

@@ -22,15 +22,13 @@
  * All custom event handler like mouse or keyboard event handler must implement
  * this interface.
  */
-qx.Interface.define("qx.event.IEventHandler",
-{
-  statics :
-  {
+qx.Interface.define("qx.event.IEventHandler", {
+  statics: {
     /** @type {Integer} The event target must be a dom node */
     TARGET_DOMNODE: 1,
 
     /** @type {Integer} The event target must be a window object */
-    TARGET_WINDOW : 2,
+    TARGET_WINDOW: 2,
 
     /** @type {Integer} The event target must be a qooxdoo object */
     TARGET_OBJECT: 4,
@@ -39,9 +37,7 @@ qx.Interface.define("qx.event.IEventHandler",
     TARGET_DOCUMENT: 8
   },
 
-
-  members :
-  {
+  members: {
     /**
      * Whether the event handler can handle events of the given type. If the
      * event handler class has a static variable called <code>IGNORE_CAN_HANDLE</code>
@@ -55,8 +51,7 @@ qx.Interface.define("qx.event.IEventHandler",
      * @return {Boolean} Whether the event handler can handle events of the
      *     given type.
      */
-    canHandleEvent : function(target, type) {},
-
+    canHandleEvent(target, type) {},
 
     /**
      * This method is called each time an event listener, for one of the
@@ -68,8 +63,7 @@ qx.Interface.define("qx.event.IEventHandler",
      * @param capture {Boolean} Whether to attach the event to the
      *         capturing phase or the bubbling phase of the event.
      */
-    registerEvent : function(target, type, capture) {},
-
+    registerEvent(target, type, capture) {},
 
     /**
      * This method is called each time an event listener, for one of the
@@ -82,6 +76,6 @@ qx.Interface.define("qx.event.IEventHandler",
      * @param capture {Boolean} Whether to attach the event to the
      *         capturing phase or the bubbling phase of the event.
      */
-    unregisterEvent : function(target, type, capture) {}
+    unregisterEvent(target, type, capture) {}
   }
 });

package/source/class/qx/event/Idle.js

@@ -16,70 +16,58 @@
 
 ************************************************************************ */
 
-
 /**
  * A generic singleton that fires an "interval" event all 100 milliseconds. It
  * can be used whenever one needs to run code periodically. The main purpose of
  * this class is reduce the number of timers.
- * 
+ *
  * NOTE: Instances of this class must be disposed of after use
  *
  */
 
-qx.Class.define("qx.event.Idle",
-{
-  extend : qx.core.Object,
-  implement : [ qx.core.IDisposable ],
-  type : "singleton",
+qx.Class.define("qx.event.Idle", {
+  extend: qx.core.Object,
+  implement: [qx.core.IDisposable],
+  type: "singleton",
 
-  construct : function()
-  {
-    this.base(arguments);
+  construct() {
+    super();
   },
 
-
   /*
   *****************************************************************************
      EVENTS
   *****************************************************************************
   */
 
-  events :
-  {
+  events: {
     /** This event if fired each time the interval time has elapsed */
-    "interval" : "qx.event.type.Event"
+    interval: "qx.event.type.Event"
   },
 
-
   /*
   *****************************************************************************
      PROPERTIES
   *****************************************************************************
   */
 
-  properties :
-  {
+  properties: {
     /**
      * Interval for the timer, which periodically fires the "interval" event,
      * in milliseconds.
      */
-    timeoutInterval :
-    {
+    timeoutInterval: {
       check: "Number",
-      init : 100,
-      apply : "_applyTimeoutInterval"
+      init: 100,
+      apply: "_applyTimeoutInterval"
     }
   },
 
-
-
-  members :
-  {
-
-    __timer : null,
+  members: {
+    __timer: null,
 
     // property apply
-    _applyTimeoutInterval : function(value) {
+    _applyTimeoutInterval(value) {
       if (this.__timer) {
         this.__timer.setInterval(value);
       }
@@ -88,27 +76,27 @@ qx.Class.define("qx.event.Idle",
     /**
      * Fires an "interval" event
      */
-    _onInterval : function() {
+    _onInterval() {
       this.fireEvent("interval");
     },
 
     /**
      * Starts the timer but only if there are listeners for the "interval" event
      */
-    __startTimer: function() {
+    __startTimer() {
       if (!this.__timer && this.hasListener("interval")) {
-          var timer = new qx.event.Timer(this.getTimeoutInterval());
-          timer.addListener("interval", this._onInterval, this);
-          timer.start();
+        var timer = new qx.event.Timer(this.getTimeoutInterval());
+        timer.addListener("interval", this._onInterval, this);
+        timer.start();
 
-          this.__timer = timer;
+        this.__timer = timer;
       }
     },
 
     /**
      * Stops the timer but only if there are no listeners for the interval event
      */
-    __stopTimer: function() {
+    __stopTimer() {
       if (this.__timer && !this.hasListener("interval")) {
         this.__timer.stop();
         this.__timer.dispose();
@@ -119,8 +107,8 @@ qx.Class.define("qx.event.Idle",
     /*
      * @Override
      */
-    addListener: function(type, listener, self, capture) {
-      var result = this.base(arguments, type, listener, self, capture);
+    addListener(type, listener, self, capture) {
+      var result = super.addListener(type, listener, self, capture);
       this.__startTimer();
       return result;
     },
@@ -128,8 +116,8 @@ qx.Class.define("qx.event.Idle",
     /*
      * @Override
      */
-    addListenerOnce: function(type, listener, self, capture) {
-      var result = this.base(arguments, type, listener, self, capture);
+    addListenerOnce(type, listener, self, capture) {
+      var result = super.addListenerOnce(type, listener, self, capture);
       this.__startTimer();
       return result;
     },
@@ -137,8 +125,8 @@ qx.Class.define("qx.event.Idle",
     /*
      * @Override
      */
-    removeListener: function(type, listener, self, capture) {
-      var result = this.base(arguments, type, listener, self, capture);
+    removeListener(type, listener, self, capture) {
+      var result = super.removeListener(type, listener, self, capture);
       this.__stopTimer();
       return result;
     },
@@ -146,12 +134,11 @@ qx.Class.define("qx.event.Idle",
     /*
      * @Override
      */
-    removeListenerById: function(id) {
-      var result = this.base(arguments, id);
+    removeListenerById(id) {
+      var result = super.removeListenerById(id);
       this.__stopTimer();
       return result;
     }
-
   },
 
   /*
@@ -160,13 +147,11 @@ qx.Class.define("qx.event.Idle",
   *****************************************************************************
   */
 
-  destruct : function()
-  {
+  destruct() {
     if (this.__timer) {
       this.__timer.stop();
     }
 
     this.__timer = null;
   }
-
 });