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

package/source/class/qx/html/Root.js

@@ -26,11 +26,8 @@
  * this element is always visible. In the easiest case, the root element
  * is identical to the document's body.
  */
-qx.Class.define("qx.html.Root",
-{
-  extend : qx.html.Element,
-
-
+qx.Class.define("qx.html.Root", {
+  extend: qx.html.Element,
 
   /*
   *****************************************************************************
@@ -43,26 +40,21 @@ qx.Class.define("qx.html.Root",
    *
    * @param elem {Element?null} DOM element to use
    */
-  construct : function(elem)
-  {
-    this.base(arguments);
+  construct(elem) {
+    super();
 
     if (elem != null) {
       this.useNode(elem);
     }
   },
 
-
-
-
   /*
   *****************************************************************************
      MEMBERS
   *****************************************************************************
   */
 
-  members :
-  {
+  members: {
     /**
      * Sets the element to an already existing node. It will be
      * assumed that this DOM element is already visible e.g.
@@ -71,10 +63,9 @@ qx.Class.define("qx.html.Root",
      * @param elem {Element} the dom element to set
      * @throws {Error} if the element is assigned again
      */
-    useNode : function(elem)
-    {
+    useNode(elem) {
       // Base call
-      this.base(arguments, elem);
+      super.useNode(elem);
 
       // Mark as root
       this.setRoot(true);

package/source/class/qx/html/Text.js

@@ -30,12 +30,12 @@ qx.Class.define("qx.html.Text", {
 
   /**
    * Creates a new Text
-   * 
+   *
    * @param value
    *          {String?} the value of the text
    */
-  construct: function(text) {
-    this.base(arguments, "#text");
+  construct(text) {
+    super("#text");
     if (text) {
       this.__text = text;
     }
@@ -53,72 +53,72 @@ qx.Class.define("qx.html.Text", {
     /*
      * @Override
      */
-    _createDomElement: function() {
+    _createDomElement() {
       return window.document.createTextNode(this.__text || "");
     },
 
     /*
      * @Override
      */
-    isRoot : function() {
+    isRoot() {
       return false;
     },
-    
+
     /*
      * @Override
      */
-    _copyData: function(fromMarkup, propertiesFromDom) {
-      this.base(arguments, fromMarkup, propertiesFromDom);
+    _copyData(fromMarkup, propertiesFromDom) {
+      super._copyData(fromMarkup, propertiesFromDom);
       var elem = this._domNode;
       elem.nodeValue = this.__text || "";
     },
-    
+
     /*
      * @Override
      */
-    _useNode: function(domNode) {
+    _useNode(domNode) {
       this.setText(domNode.nodeValue);
     },
 
     /*
      * @Override
      */
-    _useNodeImpl: function(domNode) {
+    _useNodeImpl(domNode) {
       this.setText(domNode.nodeValue);
     },
 
     /**
      * @Override
      */
-    _syncData : function() {
-      this.base(arguments);
+    _syncData() {
+      super._syncData();
       var elem = this._domNode;
       elem.nodeValue = this.__text || "";
     },
-    
+
     /*
      * @Override
      */
-    _serializeImpl: function(writer) {
+    _serializeImpl(writer) {
       if (this.__text !== null) {
         writer(this.__text);
       }
     },
-    
+
     /**
      * @Override
      */
-    useMarkup: function(html) {
+    useMarkup(html) {
       throw new Error("Could not overwrite existing text node!");
     },
-    
+
     /**
      * Sets the text value
-     * 
+     *
      * @param value {String?} the text value of for the text node
-     * @param direct {Boolean?} whether to set the DOM node immediately if there is one 
+     * @param direct {Boolean?} whether to set the DOM node immediately if there is one
      */
-    setText: function(value, direct) {
+    setText(value, direct) {
       this.__text = value;
       if (direct && this._domNode) {
         this._domNode.nodeValue = value;
@@ -127,13 +127,13 @@ qx.Class.define("qx.html.Text", {
         qx.html.Element._scheduleFlush("element");
       }
     },
-    
+
     /**
      * Returns the value of the node
-     * 
+     *
      * @return {String} the text node
      */
-    getText: function() {
+    getText() {
       return this.__text;
     }
   },
@@ -144,7 +144,7 @@ qx.Class.define("qx.html.Text", {
    * ****************************************************************************
    */
 
-  defer: function(statics) {
+  defer(statics) {
     statics.__deferredCall = new qx.util.DeferredCall(statics.flush, statics);
   },
 
@@ -154,12 +154,19 @@ qx.Class.define("qx.html.Text", {
    * ****************************************************************************
    */
 
-  destruct: function() {
+  destruct() {
     if (this.toHashCode()) {
       delete qx.html.Element._modified[this.toHashCode()];
       delete qx.html.Element._scroll[this.toHashCode()];
     }
 
-    this.__attribValues = this.__styleValues = this.__eventValues = this.__attribJobs = this.__styleJobs = this.__lazyScrollIntoViewX = this.__lazyScrollIntoViewY = null;
+    this.__attribValues =
+      this.__styleValues =
+      this.__eventValues =
+      this.__attribJobs =
+      this.__styleJobs =
+      this.__lazyScrollIntoViewX =
+      this.__lazyScrollIntoViewY =
+        null;
   }
 });

package/source/class/qx/io/ImageLoader.js

@@ -26,26 +26,22 @@
  *
  * Use {@link #load} to preload your own images.
  */
-qx.Bootstrap.define("qx.io.ImageLoader",
-{
-  statics :
-  {
+qx.Bootstrap.define("qx.io.ImageLoader", {
+  statics: {
     /** @type {Map} Internal data structure to cache image sizes */
-    __data : {},
-
+    __data: {},
 
     /** @type {Map} Default image size */
-    __defaultSize :
-    {
-      width : null,
-      height : null
+    __defaultSize: {
+      width: null,
+      height: null
     },
 
     /** @type {RegExp} Known image types */
-    __knownImageTypesRegExp : /\.(png|gif|jpg|jpeg|bmp)\b/i,
+    __knownImageTypesRegExp: /\.(png|gif|jpg|jpeg|bmp)\b/i,
 
     /** @type {RegExp} Image types of a data URL */
-    __dataUrlRegExp : /^data:image\/(png|gif|jpg|jpeg|bmp)\b/i,
+    __dataUrlRegExp: /^data:image\/(png|gif|jpg|jpeg|bmp)\b/i,
 
     /**
      * Whether the given image has previously been loaded using the
@@ -54,13 +50,11 @@ qx.Bootstrap.define("qx.io.ImageLoader",
      * @param source {String} Image source to query
      * @return {Boolean} <code>true</code> when the image is loaded
      */
-    isLoaded : function(source)
-    {
+    isLoaded(source) {
       var entry = this.__data[source];
       return !!(entry && entry.loaded);
     },
 
-
     /**
      * Whether the given image has previously been requested using the
      * {@link #load} method but failed.
@@ -68,65 +62,56 @@ qx.Bootstrap.define("qx.io.ImageLoader",
      * @param source {String} Image source to query
      * @return {Boolean} <code>true</code> when the image loading failed
      */
-    isFailed : function(source)
-    {
+    isFailed(source) {
       var entry = this.__data[source];
       return !!(entry && entry.failed);
     },
 
-
     /**
      * Whether the given image is currently loading.
      *
      * @param source {String} Image source to query
      * @return {Boolean} <code>true</code> when the image is loading in the moment.
      */
-    isLoading : function(source)
-    {
+    isLoading(source) {
       var entry = this.__data[source];
       return !!(entry && entry.loading);
     },
 
-
     /**
      * Returns the format of a previously loaded image
      *
      * @param source {String} Image source to query
      * @return {String ? null} The format of the image or <code>null</code>
      */
-    getFormat : function(source)
-    {
+    getFormat(source) {
       var entry = this.__data[source];
 
-      if (! entry || ! entry.format)
-      {
+      if (!entry || !entry.format) {
         var result = this.__dataUrlRegExp.exec(source);
-        if (result != null)
-        {
+        if (result != null) {
           // If width and height aren't defined, provide some defaults
           var width =
-            (entry && qx.lang.Type.isNumber(entry.width)
-             ? entry.width
-             : this.__defaultSize.width);
+            entry && qx.lang.Type.isNumber(entry.width)
+              ? entry.width
+              : this.__defaultSize.width;
 
           var height =
-            (entry && qx.lang.Type.isNumber(entry.height)
-             ? entry.height
-             : this.__defaultSize.height);
-
-          entry =
-            {
-              loaded : true,
-              format : result[1],
-              width  : width,
-              height : height
-            };
+            entry && qx.lang.Type.isNumber(entry.height)
+              ? entry.height
+              : this.__defaultSize.height;
+
+          entry = {
+            loaded: true,
+            format: result[1],
+            width: width,
+            height: height
+          };
         }
       }
       return entry ? entry.format : null;
     },
 
-
     /**
      * Returns the size of a previously loaded image
      *
@@ -135,38 +120,35 @@ qx.Bootstrap.define("qx.io.ImageLoader",
      *    <code>height</code> as key). If the image is not yet loaded, the
      *    dimensions are given as <code>null</code> for width and height.
      */
-    getSize : function(source) {
+    getSize(source) {
       var entry = this.__data[source];
-      return entry ? { width: entry.width, height: entry.height } : this.__defaultSize;
+      return entry
+        ? { width: entry.width, height: entry.height }
+        : this.__defaultSize;
     },
 
-
     /**
      * Returns the image width
      *
      * @param source {String} Image source to query
      * @return {Integer} The width or <code>null</code> when the image is not loaded
      */
-    getWidth : function(source)
-    {
+    getWidth(source) {
       var entry = this.__data[source];
       return entry ? entry.width : null;
     },
 
-
     /**
      * Returns the image height
      *
      * @param source {String} Image source to query
      * @return {Integer} The height or <code>null</code> when the image is not loaded
      */
-    getHeight : function(source)
-    {
+    getHeight(source) {
       var entry = this.__data[source];
       return entry ? entry.height : null;
     },
 
-
     /**
      * Loads the given image. Supports a callback which is
      * executed when the image is loaded.
@@ -180,8 +162,7 @@ qx.Bootstrap.define("qx.io.ImageLoader",
      *   information about the image.
      * @param context {Object?} Context in which the given callback should be executed
      */
-    load : function(source, callback, context)
-    {
+    load(source, callback, context) {
       // Shorthand
       var entry = this.__data[source];
 
@@ -195,19 +176,15 @@ qx.Bootstrap.define("qx.io.ImageLoader",
       }
 
       // Already known image source
-      if (entry.loaded || entry.loading || entry.failed)
-      {
-        if (callback)
-        {
+      if (entry.loaded || entry.loading || entry.failed) {
+        if (callback) {
           if (entry.loading) {
             entry.callbacks.push(callback, context);
           } else {
             callback.call(context, source, entry);
           }
         }
-      }
-      else
-      {
+      } else {
         // Updating entry
         entry.loading = true;
         entry.callbacks = [];
@@ -217,9 +194,8 @@ qx.Bootstrap.define("qx.io.ImageLoader",
         }
 
         var ResourceManager = qx.util.ResourceManager.getInstance();
-        if(ResourceManager.isFontUri(source))
-        {
-          var el = document.createElement('div');
+        if (ResourceManager.isFontUri(source)) {
+          var el = document.createElement("div");
           var charCode = ResourceManager.fromFontUriToCharCode(source);
           el.value = String.fromCharCode(charCode);
           entry.element = el;
@@ -227,10 +203,15 @@ qx.Bootstrap.define("qx.io.ImageLoader",
         }
 
         // Create image element
-        var el = document.createElement('img');
+        var el = document.createElement("img");
 
         // Create common callback routine
-        var boundCallback = qx.lang.Function.listener(this.__onload, this, el, source);
+        var boundCallback = qx.lang.Function.listener(
+          this.__onload,
+          this,
+          el,
+          source
+        );
 
         // Assign callback to element
         el.onload = boundCallback;
@@ -244,18 +225,15 @@ qx.Bootstrap.define("qx.io.ImageLoader",
       }
     },
 
-
     /**
      * Abort the loading for the given url.
      *
      * @param source {String} URL of the image to abort its loading.
      */
-    abort : function (source)
-    {
+    abort(source) {
       var entry = this.__data[source];
 
-      if (entry && !entry.loaded)
-      {
+      if (entry && !entry.loaded) {
         entry.aborted = true;
 
         var callbacks = entry.callbacks;
@@ -272,27 +250,26 @@ qx.Bootstrap.define("qx.io.ImageLoader",
         delete entry.element;
         delete entry.loading;
 
-        for (var i=0, l=callbacks.length; i<l; i+=2) {
-          callbacks[i].call(callbacks[i+1], source, entry);
+        for (var i = 0, l = callbacks.length; i < l; i += 2) {
+          callbacks[i].call(callbacks[i + 1], source, entry);
         }
       }
 
       this.__data[source] = null;
     },
 
-
     /**
      * Calls a method based on qx.globalErrorHandling
      */
-    __onload: function () {
+    __onload() {
       var callback = qx.core.Environment.select("qx.globalErrorHandling", {
-        "true": qx.event.GlobalError.observeMethod(this.__onLoadHandler),
-        "false": this.__onLoadHandler
+        true: qx.event.GlobalError.observeMethod(this.__onLoadHandler),
+        false: this.__onLoadHandler
       });
+
       callback.apply(this, arguments);
     },
 
-
     /**
      * Internal event listener for all load/error events.
      *
@@ -302,21 +279,22 @@ qx.Bootstrap.define("qx.io.ImageLoader",
      * @param element {Element} DOM element which represents the image
      * @param source {String} The image source loaded
      */
-    __onLoadHandler: function (event, element, source) {
+    __onLoadHandler(event, element, source) {
       // Shorthand
       var entry = this.__data[source];
 
       // [BUG #9149]: When loading a SVG IE11 won't have
       // the width/height of the element set, unless
       // it is inserted into the DOM.
-      if(qx.bom.client.Engine.getName() == "mshtml" &&
-          parseFloat(qx.bom.client.Engine.getVersion()) === 11)
-      {
+      if (
+        qx.bom.client.Engine.getName() == "mshtml" &&
+        parseFloat(qx.bom.client.Engine.getVersion()) === 11
+      ) {
         document.body.appendChild(element);
       }
 
       var isImageAvailable = function (imgElem) {
-        return (imgElem && imgElem.height !== 0);
+        return imgElem && imgElem.height !== 0;
       };
 
       // [BUG #7497]: IE11 doesn't properly emit an error event
@@ -332,14 +310,14 @@ qx.Bootstrap.define("qx.io.ImageLoader",
         if (result != null) {
           entry.format = result[1];
         }
-      }
-      else {
+      } else {
         entry.failed = true;
       }
 
-      if(qx.bom.client.Engine.getName() == "mshtml" &&
-          parseFloat(qx.bom.client.Engine.getVersion()) === 11)
-      {
+      if (
+        qx.bom.client.Engine.getName() == "mshtml" &&
+        parseFloat(qx.bom.client.Engine.getVersion()) === 11
+      ) {
         document.body.removeChild(element);
       }
 
@@ -360,12 +338,10 @@ qx.Bootstrap.define("qx.io.ImageLoader",
       }
     },
 
-
     /**
      * Dispose stored images.
      */
-    dispose : function()
-    {
+    dispose() {
       this.__data = {};
     }
   }

package/source/class/qx/io/PartLoader.js

@@ -21,21 +21,17 @@
  *
  * It contains functionality to load parts and to retrieve part instances.
  */
-qx.Class.define("qx.io.PartLoader",
-{
-  type : "singleton",
-  extend : qx.core.Object,
+qx.Class.define("qx.io.PartLoader", {
+  type: "singleton",
+  extend: qx.core.Object,
 
+  construct() {
+    super();
 
-  construct : function()
-  {
-    this.base(arguments);
-
-
-    var loader = this._loader = qx.Part.getInstance();
+    var loader = (this._loader = qx.Part.getInstance());
 
     var self = this;
-    loader.onpart = function(part) {
+    loader.onpart = function (part) {
       if (part.getReadyState() == "complete") {
         self.fireDataEvent("partLoaded", part);
       } else {
@@ -44,26 +40,22 @@ qx.Class.define("qx.io.PartLoader",
     };
   },
 
-
-  events :
-  {
+  events: {
     /**
      * Fired if a parts was loaded. The data of the event instance point to the
      * loaded part instance.
      */
-    "partLoaded" : "qx.event.type.Data",
+    partLoaded: "qx.event.type.Data",
 
     /**
      * Fired if a part could not be loaded. The event's
      * {@link qx.event.type.Data#getData} method returns the name of the failed
      * part.
      */
-    "partLoadingError" : "qx.event.type.Data"
+    partLoadingError: "qx.event.type.Data"
   },
 
-
-  statics :
-  {
+  statics: {
     /**
      * Loads one or more parts asynchronously. The callback is called after all
      * parts and their dependencies are fully loaded. If the parts are already
@@ -76,14 +68,12 @@ qx.Class.define("qx.io.PartLoader",
      *   the parts specified in the partNames argument.
      * @param self {Object?window} Context to execute the given function in
      */
-    require : function(partNames, callback, self) {
+    require(partNames, callback, self) {
       this.getInstance().require(partNames, callback, self);
     }
   },
 
-
-  members :
-  {
+  members: {
     /**
      * Loads one or more parts asynchronously. The callback is called after all
      * parts and their dependencies are fully loaded. If the parts are already
@@ -95,11 +85,10 @@ qx.Class.define("qx.io.PartLoader",
      * @param callback {Function} Function to execute on completion
      * @param self {Object?window} Context to execute the given function in
      */
-    require : function(partNames, callback, self) {
+    require(partNames, callback, self) {
       this._loader.require(partNames, callback, self);
     },
 
-
     /**
      * Get the part instance of the part with the given name.
      *
@@ -107,27 +96,25 @@ qx.Class.define("qx.io.PartLoader",
      *    compile time.
      * @return {qx.io.part.Part} The corresponding part instance
      */
-    getPart : function(name) {
+    getPart(name) {
       return this.getParts()[name];
     },
 
-
     /**
      * Checks if a part with the given name is available.
      * @param name {String} Name of the part as defined in the config file at
      *    compile time.
      * @return {Boolean} <code>true</code>, if the part is available
      */
-    hasPart : function(name) {
+    hasPart(name) {
       return this.getPart(name) !== undefined;
     },
 
-
     /**
      * Returns a map of all known parts.
      * @return {Map} Map containing all parts.
      */
-    getParts : function() {
+    getParts() {
       return this._loader.getParts();
     }
   }

package/source/class/qx/io/__init__.js

@@ -1,5 +1,7 @@
 /**
- * This package contains classes for server I/O, e.g. for XHR or RPC
- * communication. Application code will mostly use classes from the {@link remote}
- * name space.
+ * This package contains classes for communication with remote servers,
+ * providing support for low-level transport protocols such as HTTP or
+ * Websockets as well as for high-level query protocols such as REST, JSONPRC,
+ * or GraphQL. For documentation, see {@link
+ * https://github.com/qooxdoo/qooxdoo/blob/master/docs/communication/README.md}
  */