@qooxdoo/framework 7.0.0-beta.1 → 7.0.0-beta.10

package/source/class/qx/ui/table/selection/Model.js

@@ -20,12 +20,8 @@
 /**
  * A selection model.
  */
-qx.Class.define("qx.ui.table.selection.Model",
-{
-  extend : qx.core.Object,
-
-
-
+qx.Class.define("qx.ui.table.selection.Model", {
+  extend: qx.core.Object,
 
   /*
   *****************************************************************************
@@ -33,9 +29,8 @@ qx.Class.define("qx.ui.table.selection.Model",
   *****************************************************************************
   */
 
-  construct : function()
-  {
-    this.base(arguments);
+  construct() {
+    super();
 
     this.__selectedRangeArr = [];
     this.__anchorSelectionIndex = -1;
@@ -44,8 +39,6 @@ qx.Class.define("qx.ui.table.selection.Model",
     this.__hadChangeEventInBatchMode = false;
   },
 
-
-
   /*
   *****************************************************************************
      EVENTS
@@ -54,40 +47,33 @@ qx.Class.define("qx.ui.table.selection.Model",
 
   events: {
     /** Fired when the selection has changed. */
-    "changeSelection" : "qx.event.type.Event"
+    changeSelection: "qx.event.type.Event"
   },
 
-
-
   /*
   *****************************************************************************
      STATICS
   *****************************************************************************
   */
 
-  statics :
-  {
-
+  statics: {
     /** @type {int} The selection mode "none". Nothing can ever be selected. */
-    NO_SELECTION                : 1,
+    NO_SELECTION: 1,
 
     /** @type {int} The selection mode "single". This mode only allows one selected item. */
-    SINGLE_SELECTION            : 2,
-
+    SINGLE_SELECTION: 2,
 
     /**
      * @type {int} The selection mode "single interval". This mode only allows one
      * continuous interval of selected items.
      */
-    SINGLE_INTERVAL_SELECTION   : 3,
-
+    SINGLE_INTERVAL_SELECTION: 3,
 
     /**
      * @type {int} The selection mode "multiple interval". This mode only allows any
      * selection.
      */
-    MULTIPLE_INTERVAL_SELECTION : 4,
-
+    MULTIPLE_INTERVAL_SELECTION: 4,
 
     /**
      * @type {int} The selection mode "multiple interval". This mode only allows any
@@ -96,57 +82,47 @@ qx.Class.define("qx.ui.table.selection.Model",
      * On the other hand, MULTIPLE_INTERVAL_SELECTION does this behavior only
      * when Ctrl-tapping an item.
      */
-    MULTIPLE_INTERVAL_SELECTION_TOGGLE : 5
+    MULTIPLE_INTERVAL_SELECTION_TOGGLE: 5
   },
 
-
-
   /*
   *****************************************************************************
      PROPERTIES
   *****************************************************************************
   */
 
-  properties :
-  {
+  properties: {
     /**
      * Set the selection mode. Valid values are {@link #NO_SELECTION},
      * {@link #SINGLE_SELECTION}, {@link #SINGLE_INTERVAL_SELECTION},
      * {@link #MULTIPLE_INTERVAL_SELECTION} and
      * {@link #MULTIPLE_INTERVAL_SELECTION_TOGGLE}.
      */
-    selectionMode :
-    {
-      init : 2, //SINGLE_SELECTION,
-      check : [1,2,3,4,5],
+    selectionMode: {
+      init: 2, //SINGLE_SELECTION,
+      check: [1, 2, 3, 4, 5],
       //[ NO_SELECTION, SINGLE_SELECTION, SINGLE_INTERVAL_SELECTION, MULTIPLE_INTERVAL_SELECTION, MULTIPLE_INTERVAL_SELECTION_TOGGLE ],
-      apply : "_applySelectionMode"
+      apply: "_applySelectionMode"
     }
   },
 
-
-
-
   /*
   *****************************************************************************
      MEMBERS
   *****************************************************************************
   */
 
-  members :
-  {
-    __hadChangeEventInBatchMode : null,
-    __anchorSelectionIndex : null,
-    __leadSelectionIndex : null,
-    __selectedRangeArr : null,
-
+  members: {
+    __hadChangeEventInBatchMode: null,
+    __anchorSelectionIndex: null,
+    __leadSelectionIndex: null,
+    __selectedRangeArr: null,
 
     // selectionMode property modifier
-    _applySelectionMode : function(selectionMode) {
+    _applySelectionMode(selectionMode) {
       this.resetSelection();
     },
 
-
     /**
      *
      * Activates / Deactivates batch mode. In batch mode, no change events will be thrown but
@@ -161,21 +137,19 @@ qx.Class.define("qx.ui.table.selection.Model",
      * @return {Boolean} true if batch mode is active, false otherwise
      * @throws {Error} if batch mode is turned off once more than it has been turned on
      */
-    setBatchMode : function(batchMode)
-    {
+    setBatchMode(batchMode) {
       if (batchMode) {
         this.hasBatchModeRefCount += 1;
-      }
-      else
-      {
+      } else {
         if (this.hasBatchModeRefCount == 0) {
-          throw new Error("Try to turn off batch mode althoug it was not turned on.");
+          throw new Error(
+            "Try to turn off batch mode althoug it was not turned on."
+          );
         }
 
         this.hasBatchModeRefCount -= 1;
 
-        if (this.__hadChangeEventInBatchMode)
-        {
+        if (this.__hadChangeEventInBatchMode) {
           this.__hadChangeEventInBatchMode = false;
           this._fireChangeSelection();
         }
@@ -184,62 +158,56 @@ qx.Class.define("qx.ui.table.selection.Model",
       return this.hasBatchMode();
     },
 
-
     /**
      *
      * Returns whether batch mode is active. See setter for a description of batch mode.
      *
      * @return {Boolean} true if batch mode is active, false otherwise
      */
-    hasBatchMode : function() {
+    hasBatchMode() {
       return this.hasBatchModeRefCount > 0;
     },
 
-
     /**
      * Returns the first argument of the last call to {@link #setSelectionInterval()},
      * {@link #addSelectionInterval()} or {@link #removeSelectionInterval()}.
      *
      * @return {Integer} the anchor selection index.
      */
-    getAnchorSelectionIndex : function() {
+    getAnchorSelectionIndex() {
       return this.__anchorSelectionIndex;
     },
 
-
     /**
      * Sets the anchor selection index. Only use this function, if you want manipulate
      * the selection manually.
      *
      * @param index {Integer} the index to set.
      */
-    _setAnchorSelectionIndex : function(index) {
+    _setAnchorSelectionIndex(index) {
       this.__anchorSelectionIndex = index;
     },
 
-
     /**
      * Returns the second argument of the last call to {@link #setSelectionInterval()},
      * {@link #addSelectionInterval()} or {@link #removeSelectionInterval()}.
      *
      * @return {Integer} the lead selection index.
      */
-    getLeadSelectionIndex : function() {
+    getLeadSelectionIndex() {
       return this.__leadSelectionIndex;
     },
 
-
     /**
      * Sets the lead selection index. Only use this function, if you want manipulate
      * the selection manually.
      *
      * @param index {Integer} the index to set.
      */
-    _setLeadSelectionIndex : function(index) {
+    _setLeadSelectionIndex(index) {
       this.__leadSelectionIndex = index;
     },
 
-
     /**
      * Returns an array that holds all the selected ranges of the table. Each
      * entry is a map holding information about the "minIndex" and "maxIndex" of the
@@ -247,45 +215,38 @@ qx.Class.define("qx.ui.table.selection.Model",
      *
      * @return {Map[]} array with all the selected ranges.
      */
-    _getSelectedRangeArr : function() {
+    _getSelectedRangeArr() {
       return this.__selectedRangeArr;
     },
 
-
     /**
      * Resets (clears) the selection.
      */
-    resetSelection : function()
-    {
-      if (!this.isSelectionEmpty())
-      {
+    resetSelection() {
+      if (!this.isSelectionEmpty()) {
         this._resetSelection();
         this._fireChangeSelection();
       }
     },
 
-
     /**
      * Returns whether the selection is empty.
      *
      * @return {Boolean} whether the selection is empty.
      */
-    isSelectionEmpty : function() {
+    isSelectionEmpty() {
       return this.__selectedRangeArr.length == 0;
     },
 
-
     /**
      * Returns the number of selected items.
      *
      * @return {Integer} the number of selected items.
      */
-    getSelectedCount : function()
-    {
+    getSelectedCount() {
       var selectedCount = 0;
 
-      for (var i=0; i<this.__selectedRangeArr.length; i++)
-      {
+      for (var i = 0; i < this.__selectedRangeArr.length; i++) {
         var range = this.__selectedRangeArr[i];
         selectedCount += range.maxIndex - range.minIndex + 1;
       }
@@ -293,17 +254,14 @@ qx.Class.define("qx.ui.table.selection.Model",
       return selectedCount;
     },
 
-
     /**
      * Returns whether an index is selected.
      *
      * @param index {Integer} the index to check.
      * @return {Boolean} whether the index is selected.
      */
-    isSelectedIndex : function(index)
-    {
-      for (var i=0; i<this.__selectedRangeArr.length; i++)
-      {
+    isSelectedIndex(index) {
+      for (var i = 0; i < this.__selectedRangeArr.length; i++) {
         var range = this.__selectedRangeArr[i];
 
         if (index >= range.minIndex && index <= range.maxIndex) {
@@ -314,32 +272,27 @@ qx.Class.define("qx.ui.table.selection.Model",
       return false;
     },
 
-
     /**
      * Returns the selected ranges as an array. Each array element has a
      * <code>minIndex</code> and a <code>maxIndex</code> property.
      *
      * @return {Map[]} the selected ranges.
      */
-    getSelectedRanges : function()
-    {
+    getSelectedRanges() {
       // clone the selection array and the individual elements - this prevents the
       // caller from messing with the internal model
       var retVal = [];
 
-      for (var i=0; i<this.__selectedRangeArr.length; i++)
-      {
-        retVal.push(
-        {
-          minIndex : this.__selectedRangeArr[i].minIndex,
-          maxIndex : this.__selectedRangeArr[i].maxIndex
+      for (var i = 0; i < this.__selectedRangeArr.length; i++) {
+        retVal.push({
+          minIndex: this.__selectedRangeArr[i].minIndex,
+          maxIndex: this.__selectedRangeArr[i].maxIndex
         });
       }
 
       return retVal;
     },
 
-
     /**
      * Calls an iterator function for each selected index.
      *
@@ -356,29 +309,28 @@ qx.Class.define("qx.ui.table.selection.Model",
      * @param object {var ? null} the object to use when calling the handler.
      *          (this object will be available via "this" in the iterator)
      */
-    iterateSelection : function(iterator, object)
-    {
-      for (var i=0; i<this.__selectedRangeArr.length; i++)
-      {
-        for (var j=this.__selectedRangeArr[i].minIndex; j<=this.__selectedRangeArr[i].maxIndex; j++) {
+    iterateSelection(iterator, object) {
+      for (var i = 0; i < this.__selectedRangeArr.length; i++) {
+        for (
+          var j = this.__selectedRangeArr[i].minIndex;
+          j <= this.__selectedRangeArr[i].maxIndex;
+          j++
+        ) {
           iterator.call(object, j);
         }
       }
     },
 
-
     /**
      * Sets the selected interval. This will clear the former selection.
      *
      * @param fromIndex {Integer} the first index of the selection (including).
      * @param toIndex {Integer} the last index of the selection (including).
      */
-    setSelectionInterval : function(fromIndex, toIndex)
-    {
+    setSelectionInterval(fromIndex, toIndex) {
       var me = this.self(arguments);
 
-      switch(this.getSelectionMode())
-      {
+      switch (this.getSelectionMode()) {
         case me.NO_SELECTION:
           return;
 
@@ -393,24 +345,17 @@ qx.Class.define("qx.ui.table.selection.Model",
 
         case me.MULTIPLE_INTERVAL_SELECTION_TOGGLE:
           this.setBatchMode(true);
-          try
-          {
-            for (var i = fromIndex; i <= toIndex; i++)
-            {
-              if (!this.isSelectedIndex(i))
-              {
+          try {
+            for (var i = fromIndex; i <= toIndex; i++) {
+              if (!this.isSelectedIndex(i)) {
                 this._addSelectionInterval(i, i);
-              }
-              else
-              {
+              } else {
                 this.removeSelectionInterval(i, i);
               }
             }
-          }
-          catch (e) {
+          } catch (e) {
             throw e;
-          }
-          finally {
+          } finally {
             this.setBatchMode(false);
           }
           this._fireChangeSelection();
@@ -423,19 +368,16 @@ qx.Class.define("qx.ui.table.selection.Model",
       this._fireChangeSelection();
     },
 
-
     /**
      * Adds a selection interval to the current selection.
      *
      * @param fromIndex {Integer} the first index of the selection (including).
      * @param toIndex {Integer} the last index of the selection (including).
      */
-    addSelectionInterval : function(fromIndex, toIndex)
-    {
+    addSelectionInterval(fromIndex, toIndex) {
       var SelectionModel = qx.ui.table.selection.Model;
 
-      switch(this.getSelectionMode())
-      {
+      switch (this.getSelectionMode()) {
         case SelectionModel.NO_SELECTION:
           return;
 
@@ -451,7 +393,6 @@ qx.Class.define("qx.ui.table.selection.Model",
       }
     },
 
-
     /**
      * Removes an interval from the current selection.
      *
@@ -460,8 +401,7 @@ qx.Class.define("qx.ui.table.selection.Model",
      * @param rowsRemoved {Boolean?} rows were removed that caused this selection to change.
      *   If rows were removed, move the selections over so the same rows are selected as before.
      */
-    removeSelectionInterval : function(fromIndex, toIndex, rowsRemoved)
-    {
+    removeSelectionInterval(fromIndex, toIndex, rowsRemoved) {
       this.__anchorSelectionIndex = fromIndex;
       this.__leadSelectionIndex = toIndex;
 
@@ -472,31 +412,25 @@ qx.Class.define("qx.ui.table.selection.Model",
       // Crop the affected ranges
       var newRanges = [];
       var extraRange = null;
-      for (var i=0; i<this.__selectedRangeArr.length; i++)
-      {
+      for (var i = 0; i < this.__selectedRangeArr.length; i++) {
         var range = this.__selectedRangeArr[i];
 
-        if (range.minIndex > maxIndex)
-        {
+        if (range.minIndex > maxIndex) {
           if (rowsRemoved) {
             // Move whole selection up.
             range.minIndex -= removeCount;
             range.maxIndex -= removeCount;
           }
-        }
-        else if (range.maxIndex >= minIndex)
-        {
+        } else if (range.maxIndex >= minIndex) {
           // This range is affected
-          var minIsIn = (range.minIndex >= minIndex);
-          var maxIsIn = (range.maxIndex >= minIndex) && (range.maxIndex <= maxIndex);
+          var minIsIn = range.minIndex >= minIndex;
+          var maxIsIn =
+            range.maxIndex >= minIndex && range.maxIndex <= maxIndex;
 
-          if (minIsIn && maxIsIn)
-          {
+          if (minIsIn && maxIsIn) {
             // This range is removed completely
             range = null;
-          }
-          else if (minIsIn)
-          {
+          } else if (minIsIn) {
             if (rowsRemoved) {
               range.minIndex = minIndex;
               range.maxIndex -= removeCount;
@@ -504,14 +438,10 @@ qx.Class.define("qx.ui.table.selection.Model",
               // The range is cropped from the left
               range.minIndex = maxIndex + 1;
             }
-          }
-          else if (maxIsIn)
-          {
+          } else if (maxIsIn) {
             // The range is cropped from the right
             range.maxIndex = minIndex - 1;
-          }
-          else
-          {
+          } else {
             if (rowsRemoved) {
               range.maxIndex -= removeCount;
             } else {
@@ -541,18 +471,15 @@ qx.Class.define("qx.ui.table.selection.Model",
       this._fireChangeSelection();
     },
 
-
     /**
      * Resets (clears) the selection, but doesn't inform the listeners.
      */
-    _resetSelection : function()
-    {
+    _resetSelection() {
       this.__selectedRangeArr = [];
       this.__anchorSelectionIndex = -1;
       this.__leadSelectionIndex = -1;
     },
 
-
     /**
      * Adds a selection interval to the current selection, but doesn't inform
      * the listeners.
@@ -560,8 +487,7 @@ qx.Class.define("qx.ui.table.selection.Model",
      * @param fromIndex {Integer} the first index of the selection (including).
      * @param toIndex {Integer} the last index of the selection (including).
      */
-    _addSelectionInterval : function(fromIndex, toIndex)
-    {
+    _addSelectionInterval(fromIndex, toIndex) {
       this.__anchorSelectionIndex = fromIndex;
       this.__leadSelectionIndex = toIndex;
 
@@ -571,8 +497,7 @@ qx.Class.define("qx.ui.table.selection.Model",
       // Find the index where the new range should be inserted
       var newRangeIndex = 0;
 
-      for (;newRangeIndex<this.__selectedRangeArr.length; newRangeIndex++)
-      {
+      for (; newRangeIndex < this.__selectedRangeArr.length; newRangeIndex++) {
         var range = this.__selectedRangeArr[newRangeIndex];
 
         if (range.minIndex > minIndex) {
@@ -581,21 +506,18 @@ qx.Class.define("qx.ui.table.selection.Model",
       }
 
       // Add the new range
-      this.__selectedRangeArr.splice(newRangeIndex, 0,
-      {
-        minIndex : minIndex,
-        maxIndex : maxIndex
+      this.__selectedRangeArr.splice(newRangeIndex, 0, {
+        minIndex: minIndex,
+        maxIndex: maxIndex
       });
 
       // Merge overlapping ranges
       var lastRange = this.__selectedRangeArr[0];
 
-      for (var i=1; i<this.__selectedRangeArr.length; i++)
-      {
+      for (var i = 1; i < this.__selectedRangeArr.length; i++) {
         var range = this.__selectedRangeArr[i];
 
-        if (lastRange.maxIndex + 1 >= range.minIndex)
-        {
+        if (lastRange.maxIndex + 1 >= range.minIndex) {
           // The ranges are overlapping -> merge them
           lastRange.maxIndex = Math.max(lastRange.maxIndex, range.maxIndex);
 
@@ -604,9 +526,7 @@ qx.Class.define("qx.ui.table.selection.Model",
 
           // Check this index another time
           i--;
-        }
-        else
-        {
+        } else {
           lastRange = range;
         }
       }
@@ -617,12 +537,10 @@ qx.Class.define("qx.ui.table.selection.Model",
      * Logs the current ranges for debug purposes.
      *
      */
-    _dumpRanges : function()
-    {
+    _dumpRanges() {
       var text = "Ranges:";
 
-      for (var i=0; i<this.__selectedRangeArr.length; i++)
-      {
+      for (var i = 0; i < this.__selectedRangeArr.length; i++) {
         var range = this.__selectedRangeArr[i];
         text += " [" + range.minIndex + ".." + range.maxIndex + "]";
       }
@@ -630,37 +548,29 @@ qx.Class.define("qx.ui.table.selection.Model",
       this.debug(text);
     },
 
-
     /**
      * Fires the "changeSelection" event to all registered listeners. If the selection model
      * currently is in batch mode, only one event will be thrown when batch mode is ended.
      *
      */
-    _fireChangeSelection : function()
-    {
-      if (this.hasBatchMode())
-      {
+    _fireChangeSelection() {
+      if (this.hasBatchMode()) {
         // In batch mode, remember event but do not throw (yet)
         this.__hadChangeEventInBatchMode = true;
-      }
-      else
-      {
+      } else {
         // If not in batch mode, throw event
         this.fireEvent("changeSelection");
       }
     }
   },
 
-
-
-
   /*
   *****************************************************************************
      DESTRUCTOR
   *****************************************************************************
   */
 
-  destruct : function() {
+  destruct() {
     this.__selectedRangeArr = null;
   }
 });