Run clang-format on ui/webui/resources

ui/webui/resources/js/cr/ui/list.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // require: array_data_model.js
 // require: list_selection_model.js
 // require: list_selection_controller.js
 // require: list_item.js
 
 /**
@@ skipping 10 matching lines @@
    * false if the mouseevent was generated over a border or a scrollbar.
    * @param {!HTMLElement} el The element to test the event with.
    * @param {!Event} e The mouse event.
    * @return {boolean} Whether the mouse event was inside the viewport.
    */
   function inViewport(el, e) {
     var rect = el.getBoundingClientRect();
     var x = e.clientX;
     var y = e.clientY;
     return x >= rect.left + el.clientLeft &&
-           x < rect.left + el.clientLeft + el.clientWidth &&
-           y >= rect.top + el.clientTop &&
-           y < rect.top + el.clientTop + el.clientHeight;
+        x < rect.left + el.clientLeft + el.clientWidth &&
+        y >= rect.top + el.clientTop &&
+        y < rect.top + el.clientTop + el.clientHeight;
   }
 
   function getComputedStyle(el) {
     return el.ownerDocument.defaultView.getComputedStyle(el);
   }
 
   /**
    * Creates a new list element.
    * @param {Object=} opt_propertyBag Optional properties.
    * @constructor
@@ skipping 43 matching lines @@
      * Function used to create grid items.
      * @type {function(new:cr.ui.ListItem, *)}
      * @private
      */
     itemConstructor_: cr.ui.ListItem,
 
     /**
      * Function used to create grid items.
      * @return {function(new:cr.ui.ListItem, *)}
      */
-    get itemConstructor() {
-      return this.itemConstructor_;
-    },
+    get itemConstructor() { return this.itemConstructor_; },
     set itemConstructor(func) {
       if (func != this.itemConstructor_) {
         this.itemConstructor_ = func;
         this.cachedItems_ = {};
         this.redraw();
       }
     },
 
     dataModel_: null,
 
     /**
      * The data model driving the list.
      * @type {ArrayDataModel}
      */
     set dataModel(dataModel) {
       if (this.dataModel_ == dataModel)
         return;
 
       if (!this.boundHandleDataModelPermuted_) {
         this.boundHandleDataModelPermuted_ =
             this.handleDataModelPermuted_.bind(this);
         this.boundHandleDataModelChange_ =
             this.handleDataModelChange_.bind(this);
       }
 
       if (this.dataModel_) {
         this.dataModel_.removeEventListener(
-            'permuted',
-            this.boundHandleDataModelPermuted_);
-        this.dataModel_.removeEventListener('change',
-                                            this.boundHandleDataModelChange_);
+            'permuted', this.boundHandleDataModelPermuted_);
+        this.dataModel_.removeEventListener(
+            'change', this.boundHandleDataModelChange_);
       }
 
       this.dataModel_ = dataModel;
 
       this.cachedItems_ = {};
       this.cachedItemHeights_ = {};
       this.selectionModel.clear();
       if (dataModel)
         this.selectionModel.adjustLength(dataModel.length);
 
       if (this.dataModel_) {
         this.dataModel_.addEventListener(
-            'permuted',
-            this.boundHandleDataModelPermuted_);
-        this.dataModel_.addEventListener('change',
-                                         this.boundHandleDataModelChange_);
+            'permuted', this.boundHandleDataModelPermuted_);
+        this.dataModel_.addEventListener(
+            'change', this.boundHandleDataModelChange_);
       }
 
       this.redraw();
       this.onSetDataModelComplete();
     },
 
-    get dataModel() {
-      return this.dataModel_;
-    },
+    get dataModel() { return this.dataModel_; },
 
     /**
      * Override to be notified when |this.dataModel| is set.
      * @protected
      */
-    onSetDataModelComplete: function() {
-    },
+    onSetDataModelComplete: function() {},
 
     /**
      * Cached item for measuring the default item size by measureItem().
      * @type {cr.ui.ListItem}
      */
     cachedMeasuredItem_: null,
 
     /**
      * The selection model to use.
      * @type {cr.ui.ListSelectionModel}
      */
-    get selectionModel() {
-      return this.selectionModel_;
-    },
+    get selectionModel() { return this.selectionModel_; },
     set selectionModel(sm) {
       var oldSm = this.selectionModel_;
       if (oldSm == sm)
         return;
 
       if (!this.boundHandleOnChange_) {
         this.boundHandleOnChange_ = this.handleOnChange_.bind(this);
         this.boundHandleLeadChange_ = this.handleLeadChange.bind(this);
       }
 
       if (oldSm) {
         oldSm.removeEventListener('change', this.boundHandleOnChange_);
-        oldSm.removeEventListener('leadIndexChange',
-                                  this.boundHandleLeadChange_);
+        oldSm.removeEventListener(
+            'leadIndexChange', this.boundHandleLeadChange_);
       }
 
       this.selectionModel_ = sm;
       this.selectionController_ = this.createSelectionController(sm);
 
       if (sm) {
         sm.addEventListener('change', this.boundHandleOnChange_);
         sm.addEventListener('leadIndexChange', this.boundHandleLeadChange_);
       }
     },
 
     /**
      * Whether or not the list auto-expands.
      * @type {boolean}
      */
-    get autoExpands() {
-      return this.autoExpands_;
-    },
+    get autoExpands() { return this.autoExpands_; },
     set autoExpands(autoExpands) {
       if (this.autoExpands_ == autoExpands)
         return;
       this.autoExpands_ = autoExpands;
       this.redraw();
     },
 
     /**
      * Whether or not the rows on list have various heights.
      * @type {boolean}
      */
-    get fixedHeight() {
-      return this.fixedHeight_;
-    },
+    get fixedHeight() { return this.fixedHeight_; },
     set fixedHeight(fixedHeight) {
       if (this.fixedHeight_ == fixedHeight)
         return;
       this.fixedHeight_ = fixedHeight;
       this.redraw();
     },
 
     /**
      * Convenience alias for selectionModel.selectedItem
      * @type {*}
@@ skipping 16 matching lines @@
     },
 
     /**
      * Convenience alias for selectionModel.selectedItems
      * @type {!Array<*>}
      */
     get selectedItems() {
       var indexes = this.selectionModel.selectedIndexes;
       var dataModel = this.dataModel;
       if (dataModel) {
-        return indexes.map(function(i) {
-          return dataModel.item(i);
-        });
+        return indexes.map(function(i) { return dataModel.item(i); });
       }
       return [];
     },
 
     /**
      * The HTML elements representing the items.
      * @type {HTMLCollection}
      */
     get items() {
-      return Array.prototype.filter.call(this.children,
-                                         this.isItem, this);
+      return Array.prototype.filter.call(this.children, this.isItem, this);
     },
 
     /**
      * Returns true if the child is a list item. Subclasses may override this
      * to filter out certain elements.
      * @param {Node} child Child of the list.
      * @return {boolean} True if a list item.
      */
     isItem: function(child) {
       return child.nodeType == Node.ELEMENT_NODE &&
-             child != this.beforeFiller_ && child != this.afterFiller_;
+          child != this.beforeFiller_ && child != this.afterFiller_;
     },
 
     batchCount_: 0,
 
     /**
      * When making a lot of updates to the list, the code could be wrapped in
      * the startBatchUpdates and finishBatchUpdates to increase performance. Be
      * sure that the code will not return without calling endBatchUpdates or the
      * list will not be correctly updated.
      */
-    startBatchUpdates: function() {
-      this.batchCount_++;
-    },
+    startBatchUpdates: function() { this.batchCount_++; },
 
     /**
      * See startBatchUpdates.
      */
     endBatchUpdates: function() {
       this.batchCount_--;
       if (this.batchCount_ == 0)
         this.redraw();
     },
 
@@ skipping 87 matching lines @@
      *     the first value in the model.
      * @return {{height: number, marginTop: number, marginBottom: number,
      *     width: number, marginLeft: number, marginRight: number}}
      *     The height and width of the item, taking
      *     margins into account, and the top, bottom, left and right margins
      *     themselves.
      */
     measureItem: function(opt_item) {
       var dataModel = this.dataModel;
       if (!dataModel || !dataModel.length) {
-        return {height: 0, marginTop: 0, marginBottom: 0,
-                width: 0, marginLeft: 0, marginRight: 0};
+        return {
+          height: 0,
+          marginTop: 0,
+          marginBottom: 0,
+          width: 0,
+          marginLeft: 0,
+          marginRight: 0
+        };
       }
       var item = opt_item || this.cachedMeasuredItem_ ||
           this.createItem(dataModel.item(0));
       if (!opt_item) {
         this.cachedMeasuredItem_ = item;
         this.appendChild(item);
       }
 
       var rect = item.getBoundingClientRect();
       var cs = getComputedStyle(item);
@@ skipping 21 matching lines @@
       } else if (ml >= 0 && mr >= 0) {
         mh = Math.max(ml, mr);
       } else {
         mh = ml + mr;
       }
       w += mh;
 
       if (!opt_item)
         this.removeChild(item);
       return {
-          height: Math.max(0, h),
-          marginTop: mt, marginBottom: mb,
-          width: Math.max(0, w),
-          marginLeft: ml, marginRight: mr};
+        height: Math.max(0, h),
+        marginTop: mt,
+        marginBottom: mb,
+        width: Math.max(0, w),
+        marginLeft: ml,
+        marginRight: mr
+      };
     },
 
     /**
      * Callback for the double click event.
      * @param {Event} e The mouse event object.
      * @private
      */
     handleDoubleClick_: function(e) {
       if (this.disabled)
         return;
 
-      var target = /** @type {HTMLElement} */(e.target);
+      var target = /** @type {HTMLElement} */ (e.target);
 
       var ancestor = this.getListItemAncestor(target);
       var index = -1;
       if (ancestor) {
         index = this.getIndexOfListItem(ancestor);
         this.activateItemAtIndex(index);
       }
 
       var sm = this.selectionModel;
       var indexSelected = sm.getIndexSelected(index);
       if (!indexSelected)
         this.handlePointerDownUp_(e);
     },
 
     /**
      * Callback for mousedown and mouseup events.
      * @param {Event} e The mouse event object.
      * @private
      */
     handlePointerDownUp_: function(e) {
       if (this.disabled)
         return;
 
-      var target = /** @type {HTMLElement} */(e.target);
+      var target = /** @type {HTMLElement} */ (e.target);
 
       // If the target was this element we need to make sure that the user did
       // not click on a border or a scrollbar.
       if (target == this) {
         if (inViewport(target, e))
           this.selectionController_.handlePointerDownUp(e, -1);
         return;
       }
 
       target = this.getListItemAncestor(target);
@@ skipping 189 matching lines @@
         }
         return top;
       }
     },
 
     /**
      * @param {number} index The index of the item.
      * @return {number} The row of the item. May vary in the case
      *     of multiple columns.
      */
-    getItemRow: function(index) {
-      return index;
-    },
+    getItemRow: function(index) { return index; },
 
     /**
      * @param {number} row The row.
      * @return {number} The index of the first item in the row.
      */
-    getFirstItemInRow: function(row) {
-      return row;
-    },
+    getFirstItemInRow: function(row) { return row; },
 
     /**
      * Ensures that a given index is inside the viewport.
      * @param {number} index The index of the item to scroll into view.
      */
     scrollIndexIntoView: function(index) {
       var dataModel = this.dataModel;
       if (!dataModel || index < 0 || index >= dataModel.length)
         return;
 
       var itemHeight = this.getItemHeightByIndex_(index);
       var scrollTop = this.scrollTop;
       var top = this.getItemTop(index);
       var clientHeight = this.clientHeight;
 
       var cs = getComputedStyle(this);
-      var paddingY = parseInt(cs.paddingTop, 10) +
-                     parseInt(cs.paddingBottom, 10);
+      var paddingY =
+          parseInt(cs.paddingTop, 10) + parseInt(cs.paddingBottom, 10);
       var availableHeight = clientHeight - paddingY;
 
       var self = this;
       // Function to adjust the tops of viewport and row.
-      function scrollToAdjustTop() {
-        self.scrollTop = top;
-      }
+      function scrollToAdjustTop() { self.scrollTop = top; }
       // Function to adjust the bottoms of viewport and row.
       function scrollToAdjustBottom() {
         self.scrollTop = top + itemHeight - availableHeight;
       }
 
       // Check if the entire of given indexed row can be shown in the viewport.
       if (itemHeight <= availableHeight) {
         if (top < scrollTop)
           scrollToAdjustTop();
         else if (scrollTop + availableHeight < top + itemHeight)
@@ skipping 113 matching lines @@
       // If offset exceeds the height of list.
       var lastHeight = 0;
       if (this.dataModel.length) {
         var h = this.getHeightsForIndex_(this.dataModel.length - 1);
         lastHeight = h.top + h.height;
       }
       if (lastHeight < offset)
         return this.dataModel.length;
 
       // Estimates index.
-      var estimatedIndex = Math.min(Math.floor(offset / itemHeight),
-                                    this.dataModel.length - 1);
+      var estimatedIndex =
+          Math.min(Math.floor(offset / itemHeight), this.dataModel.length - 1);
       var isIncrementing = this.getItemTop(estimatedIndex) < offset;
 
       // Searchs the correct index.
       do {
         var heights = this.getHeightsForIndex_(estimatedIndex);
         var top = heights.top;
         var height = heights.height;
 
         if (top <= offset && offset <= (top + height))
           break;
@@ skipping 22 matching lines @@
      * @param {number} scrollTop The scroll top position.
      * @param {number} clientHeight The height of viewport.
      * @return {{first: number, length: number, last: number}} The index of
      *     first item in view port, The number of items, The item past the last.
      */
     getItemsInViewPort: function(scrollTop, clientHeight) {
       if (this.autoExpands_) {
         return {
           first: 0,
           length: this.dataModel.length,
-          last: this.dataModel.length};
+          last: this.dataModel.length
+        };
       } else {
         var firstIndex = this.getIndexForListOffset_(scrollTop);
         var lastIndex = this.getIndexForListOffset_(scrollTop + clientHeight);
 
         return {
           first: firstIndex,
           length: lastIndex - firstIndex + 1,
-          last: lastIndex + 1};
+          last: lastIndex + 1
+        };
       }
     },
 
     /**
      * Merges list items currently existing in the list with items in the range
      * [firstIndex, lastIndex). Removes or adds items if needed.
      * Doesn't delete {@code this.pinnedItem_} if it is present (instead hides
      * it if it is out of the range).
      * @param {number} firstIndex The index of first item, inclusively.
      * @param {number} lastIndex The index of last item, exclusively.
      */
     mergeItems: function(firstIndex, lastIndex) {
       var self = this;
       var dataModel = this.dataModel;
       var currentIndex = firstIndex;
 
       function insert() {
         var dataItem = dataModel.item(currentIndex);
-        var newItem = self.cachedItems_[currentIndex] ||
-            self.createItem(dataItem);
+        var newItem =
+            self.cachedItems_[currentIndex] || self.createItem(dataItem);
         newItem.listIndex = currentIndex;
         self.cachedItems_[currentIndex] = newItem;
         self.insertBefore(newItem, item);
         currentIndex++;
       }
 
       function remove() {
         var next = item.nextSibling;
         if (item != self.pinnedItem_)
           self.removeChild(item);
@@ skipping 128 matching lines @@
       // interleave measuring with mutating dom.
       if (!this.fixedHeight_)
         this.ensureAllItemSizesInCache();
 
       var autoExpands = this.autoExpands_;
 
       var itemsInViewPort = this.getItemsInViewPort(scrollTop, clientHeight);
       // Draws the hidden rows just above/below the viewport to prevent
       // flashing in scroll.
       var firstIndex = Math.max(
-          0,
-          Math.min(dataModel.length - 1, itemsInViewPort.first - 1));
+          0, Math.min(dataModel.length - 1, itemsInViewPort.first - 1));
       var lastIndex = Math.min(itemsInViewPort.last + 1, dataModel.length);
 
       var beforeFillerHeight =
           this.autoExpands ? 0 : this.getItemTop(firstIndex);
       var afterFillerHeight =
           this.autoExpands ? 0 : this.getAfterFillerHeight(lastIndex);
 
       this.beforeFiller_.style.height = beforeFillerHeight + 'px';
 
       var sm = this.selectionModel;
@@ skipping 83 matching lines @@
         delete this.cachedItems_[index];
         this.redraw();
       }
     },
 
     /**
      * Called when a list item is activated, currently only by a double click
      * event.
      * @param {number} index The index of the activated item.
      */
-    activateItemAtIndex: function(index) {
-    },
+    activateItemAtIndex: function(index) {},
 
     /**
      * Returns a ListItem for the leadIndex. If the item isn't present in the
      * list creates it and inserts to the list (may be invisible if it's out of
      * the visible range).
      *
      * Item returned from this method won't be removed until it remains a lead
      * item or till the data model changes (unlike other items that could be
      * removed when they go out of the visible range).
      *
      * @return {cr.ui.ListItem} The lead item for the list.
      */
     ensureLeadItemExists: function() {
       var index = this.selectionModel.leadIndex;
       if (index < 0)
         return null;
       var cachedItems = this.cachedItems_ || {};
 
-      var item = cachedItems[index] ||
-                 this.createItem(this.dataModel.item(index));
+      var item =
+          cachedItems[index] || this.createItem(this.dataModel.item(index));
       if (this.pinnedItem_ != item && this.pinnedItem_ &&
           this.pinnedItem_.hidden) {
         this.removeChild(this.pinnedItem_);
       }
       this.pinnedItem_ = item;
       cachedItems[index] = item;
       item.listIndex = index;
       if (item.parentNode == this)
         return item;
 
@@ skipping 52 matching lines @@
    * that point even though it doesn't actually have the page focus.
    */
   cr.defineProperty(List, 'hasElementFocus', cr.PropertyKind.BOOL_ATTR);
 
   /**
    * Mousedown event handler.
    * @this {cr.ui.List}
    * @param {Event} e The mouse event object.
    */
   function handleMouseDown(e) {
-    e.target = /** @type {!HTMLElement} */(e.target);
+    e.target = /** @type {!HTMLElement} */ (e.target);
     var listItem = this.getListItemAncestor(e.target);
     var wasSelected = listItem && listItem.selected;
     this.handlePointerDownUp_(e);
 
     if (e.defaultPrevented || e.button != 0)
       return;
 
     // The following hack is required only if the listItem gets selected.
     if (!listItem || wasSelected || !listItem.selected)
       return;
@@ skipping 11 matching lines @@
   }
 
   /**
    * Dragstart event handler.
    * If there is an item at starting position of drag operation and the item
    * is not selected, select it.
    * @this {cr.ui.List}
    * @param {Event} e The event object for 'dragstart'.
    */
   function handleDragStart(e) {
-    e = /** @type {MouseEvent} */(e);
+    e = /** @type {MouseEvent} */ (e);
     var element = e.target.ownerDocument.elementFromPoint(e.clientX, e.clientY);
     var listItem = this.getListItemAncestor(element);
     if (!listItem)
       return;
 
     var index = this.getIndexOfListItem(listItem);
     if (index == -1)
       return;
 
     var isAlreadySelected = this.selectionModel_.getIndexSelected(index);
     if (!isAlreadySelected)
       this.selectionModel_.selectedIndex = index;
   }
 
   /**
    * Check if |start| or its ancestor under |root| is focusable.
    * This is a helper for handleMouseDown.
    * @param {!Element} start An element which we start to check.
    * @param {!Element} root An element which we finish to check.
    * @return {boolean} True if we found a focusable element.
    */
   function containsFocusableElement(start, root) {
     for (var element = start; element && element != root;
-        element = element.parentElement) {
+         element = element.parentElement) {
       if (element.tabIndex >= 0 && !element.disabled)
         return true;
     }
     return false;
   }
 
-  return {
-    List: List
-  };
+  return {List: List};
 });