Rename VolumeList -> NavigationList in Files.app

chrome/browser/resources/file_manager/js/navigation_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.
 
 'use strict';
 
 /**
- * A volume list model. This model combines the 2 lists.
+ * A navigation list model. This model combines the 2 lists.
  * @param {cr.ui.ArrayDataModel} volumesList The first list of the model.
  * @param {cr.ui.ArrayDataModel} pinnedList The second list of the model.
  * @constructor
  * @extends {cr.EventTarget}
  */
-function VolumeListModel(volumesList, pinnedList) {
+function NavigationListModel(volumesList, pinnedList) {
   this.volumesList_ = volumesList;
   this.pinnedList_ = pinnedList;
 
   // Generates a combined 'permuted' event from an event of either list.
   var permutedHandler = function(listNum, e) {
     var permutedEvent = new Event('permuted');
     var newPermutation = [];
     var newLength;
     if (listNum == 1) {
       newLength = e.newLength + this.pinnedList_.length;
@@ skipping 30 matching lines @@
     this.dispatchEvent(changeEvent);
   };
   this.volumesList_.addEventListener('change', changeHandler.bind(this, 1));
   this.pinnedList_.addEventListener('change', changeHandler.bind(this, 2));
 
   // 'splice' and 'sorted' events are not implemented, since they are not used
   // in list.js.
 }
 
 /**
- * VolumeList inherits cr.EventTarget.
+ * NavigationList inherits cr.EventTarget.
  */
-VolumeListModel.prototype = {
+NavigationListModel.prototype = {
   __proto__: cr.EventTarget.prototype,
   get length() { return this.length_(); }
 };
 
 /**
  * Returns the item at the given index.
  * @param {number} index The index of the entry to get.
  * @return {?string} The path at the given index.
  */
-VolumeListModel.prototype.item = function(index) {
+NavigationListModel.prototype.item = function(index) {
   var offset = this.volumesList_.length;
   if (index < offset) {
     var entry = this.volumesList_.item(index);
     return entry ? entry.fullPath : undefined;
   } else {
     return this.pinnedList_.item(index - offset);
   }
 };
 
 /**
- * Type of the item on the volume list.
+ * Type of the item on the navigation list.
  * @enum {number}
  */
-VolumeListModel.ItemType = {
+NavigationListModel.ItemType = {
   ROOT: 1,
   PINNED: 2
 };
 
 /**
  * Returns the type of the item at the given index.
  * @param {number} index The index of the entry to get.
- * @return {VolumeListModel.ItemType} The type of the item.
+ * @return {NavigationListModel.ItemType} The type of the item.
  */
-VolumeListModel.prototype.getItemType = function(index) {
+NavigationListModel.prototype.getItemType = function(index) {
   var offset = this.volumesList_.length;
   return index < offset ?
-      VolumeListModel.ItemType.ROOT : VolumeListModel.ItemType.PINNED;
+      NavigationListModel.ItemType.ROOT : NavigationListModel.ItemType.PINNED;
 };
 
 /**
  * Returns the number of items in the model.
  * @return {number} The length of the model.
  * @private
  */
-VolumeListModel.prototype.length_ = function() {
+NavigationListModel.prototype.length_ = function() {
   return this.volumesList_.length + this.pinnedList_.length;
 };
 
 /**
  * Returns the first matching item.
  * @param {Entry} item The entry to find.
  * @param {number=} opt_fromIndex If provided, then the searching start at
  *     the {@code opt_fromIndex}.
  * @return {number} The index of the first found element or -1 if not found.
  */
-VolumeListModel.prototype.indexOf = function(item, opt_fromIndex) {
+NavigationListModel.prototype.indexOf = function(item, opt_fromIndex) {
   for (var i = opt_fromIndex || 0; i < this.length; i++) {
     if (item === this.item(i))
       return i;
   }
   return -1;
 };
 
 /**
- * A volume item.
+ * A navigation list item.
  * @constructor
  * @extends {HTMLLIElement}
  */
-var VolumeItem = cr.ui.define('li');
+var NavigationListItem = cr.ui.define('li');
 
-VolumeItem.prototype = {
+NavigationListItem.prototype = {
   __proto__: HTMLLIElement.prototype,
 };
 
 /**
  * Decorate the item.
  */
-VolumeItem.prototype.decorate = function() {
+NavigationListItem.prototype.decorate = function() {
   // decorate() may be called twice: from the constructor and from
   // List.createItem(). This check prevents double-decorating.
   if (this.className)
     return;
 
   this.className = 'root-item';
   this.setAttribute('role', 'option');
 
   this.iconDiv_ = cr.doc.createElement('div');
   this.iconDiv_.className = 'volume-icon';
   this.appendChild(this.iconDiv_);
 
   this.label_ = cr.doc.createElement('div');
   this.label_.className = 'root-label';
   this.appendChild(this.label_);
 
   cr.defineProperty(this, 'lead', cr.PropertyKind.BOOL_ATTR);
   cr.defineProperty(this, 'selected', cr.PropertyKind.BOOL_ATTR);
 };
 
 /**
  * Associate a path with this item.
  * @param {string} path Path of this item.
  */
-VolumeItem.prototype.setPath = function(path) {
+NavigationListItem.prototype.setPath = function(path) {
   if (this.path_)
-    console.warn('VolumeItem.setPath should be called only once.');
+    console.warn('NavigationListItem.setPath should be called only once.');
 
   this.path_ = path;
 
   var rootType = PathUtil.getRootType(path);
 
   this.iconDiv_.setAttribute('volume-type-icon', rootType);
   if (rootType === RootType.REMOVABLE) {
     this.iconDiv_.setAttribute('volume-subtype',
         VolumeManager.getInstance().getDeviceType(path));
   }
@@ skipping 15 matching lines @@
     }.bind(this));
 
     this.appendChild(this.eject_);
   }
 };
 
 /**
  * Associate a context menu with this item.
  * @param {cr.ui.Menu} menu Menu this item.
  */
-VolumeItem.prototype.maybeSetContextMenu = function(menu) {
+NavigationListItem.prototype.maybeSetContextMenu = function(menu) {
   if (!this.path_) {
-    console.error(
-        'VolumeItem.maybeSetContextMenu must be called after setPath().');
+    console.error('NavigationListItem.maybeSetContextMenu must be called ' +
+                  'after setPath().');
     return;
   }
 
   var isRoot = PathUtil.isRootPath(this.path_);
   var rootType = PathUtil.getRootType(this.path_);
   // The context menu is shown on the following items:
   // - Removable and Archive volumes
   // - Folder shortcuts
   if (!isRoot ||
       (rootType != RootType.DRIVE && rootType != RootType.DOWNLOADS))
     cr.ui.contextMenuHandler.setContextMenu(this, menu);
 };
 
 /**
- * A volume list.
+ * A navigation list.
  * @constructor
  * @extends {cr.ui.List}
  */
-function VolumeList() {
+function NavigationList() {
 }
 
 /**
- * VolumeList inherits cr.ui.List.
+ * NavigationList inherits cr.ui.List.
  */
-VolumeList.prototype.__proto__ = cr.ui.List.prototype;
+NavigationList.prototype.__proto__ = cr.ui.List.prototype;
 
 /**
  * @param {HTMLElement} el Element to be DirectoryItem.
  * @param {DirectoryModel} directoryModel Current DirectoryModel.
  * @param {cr.ui.ArrayDataModel} pinnedFolderModel Current model of the pinned
  *     folders.
  */
-VolumeList.decorate = function(el, directoryModel, pinnedFolderModel) {
-  el.__proto__ = VolumeList.prototype;
+NavigationList.decorate = function(el, directoryModel, pinnedFolderModel) {
+  el.__proto__ = NavigationList.prototype;
   el.decorate(directoryModel, pinnedFolderModel);
 };
 
 /**
  * @param {DirectoryModel} directoryModel Current DirectoryModel.
  * @param {cr.ui.ArrayDataModel} pinnedFolderModel Current model of the pinned
  *     folders.
  */
-VolumeList.prototype.decorate = function(directoryModel, pinnedFolderModel) {
+NavigationList.prototype.decorate =
+    function(directoryModel, pinnedFolderModel) {
   cr.ui.List.decorate(this);
-  this.__proto__ = VolumeList.prototype;
+  this.__proto__ = NavigationList.prototype;
 
   this.directoryModel_ = directoryModel;
   this.volumeManager_ = VolumeManager.getInstance();
   this.selectionModel = new cr.ui.ListSingleSelectionModel();
 
   this.directoryModel_.addEventListener('directory-changed',
       this.onCurrentDirectoryChanged_.bind(this));
   this.selectionModel.addEventListener(
       'change', this.onSelectionChange_.bind(this));
   this.selectionModel.addEventListener(
       'beforeChange', this.onBeforeSelectionChange_.bind(this));
 
   this.scrollBar_ = new ScrollBar();
   this.scrollBar_.initialize(this.parentNode, this);
 
   // Overriding default role 'list' set by cr.ui.List.decorate() to 'listbox'
   // role for better accessibility on ChromeOS.
   this.setAttribute('role', 'listbox');
 
   var self = this;
   this.itemConstructor = function(path) {
     return self.renderRoot_(path);
   };
 
   this.pinnedItemList_ = pinnedFolderModel;
 
   this.dataModel =
-      new VolumeListModel(this.directoryModel_.getRootsList(),
-                          this.pinnedItemList_);
+      new NavigationListModel(this.directoryModel_.getRootsList(),
+                              this.pinnedItemList_);
 };
 
 /**
- * Creates an element of a volume. This method is called from cr.ui.List
- * internally.
+ * Creates an element of a navigation list. This method is called from
+ * cr.ui.List internally.
  * @param {string} path Path of the directory to be rendered.
- * @return {VolumeItem} Rendered element.
+ * @return {NavigationListItem} Rendered element.
  * @private
  */
-VolumeList.prototype.renderRoot_ = function(path) {
-  var item = new VolumeItem();
+NavigationList.prototype.renderRoot_ = function(path) {
+  var item = new NavigationListItem();
   item.setPath(path);
 
   var handleClick = function() {
     if (item.selected && path !== this.directoryModel_.getCurrentDirPath()) {
       this.directoryModel_.changeDirectory(path);
     }
   }.bind(this);
   item.addEventListener('click', handleClick);
 
   var handleEject = function() {
@@ skipping 19 matching lines @@
   }
   return item;
 };
 
 /**
  * Sets a context menu. Context menu is enabled only on archive and removable
  * volumes as of now.
  *
  * @param {cr.ui.Menu} menu Context menu.
  */
-VolumeList.prototype.setContextMenu = function(menu) {
+NavigationList.prototype.setContextMenu = function(menu) {
   this.contextMenu_ = menu;
 
   for (var i = 0; i < this.dataModel.length; i++) {
     this.getListItemByIndex(i).maybeSetContextMenu(this.contextMenu_);
   }
 };
 
 /**
- * Selects the n-th volume from the list.
- * @param {number} index Volume index.
+ * Selects the n-th item from the list.
+ * @param {number} index Item index.
  * @return {boolean} True for success, otherwise false.
  */
-VolumeList.prototype.selectByIndex = function(index) {
+NavigationList.prototype.selectByIndex = function(index) {
   if (index < 0 || index > this.dataModel.length - 1)
     return false;
 
   var newPath = this.dataModel.item(index);
   if (!newPath)
     return false;
 
   // Prevents double-moving to the current directory.
   if (this.directoryModel_.getCurrentDirEntry().fullPath == newPath)
     return false;
 
   this.directoryModel_.changeDirectory(newPath);
   return true;
 };
 
 /**
  * Handler before root item change.
  * @param {Event} event The event.
  * @private
  */
-VolumeList.prototype.onBeforeSelectionChange_ = function(event) {
+NavigationList.prototype.onBeforeSelectionChange_ = function(event) {
   if (event.changes.length == 1 && !event.changes[0].selected)
     event.preventDefault();
 };
 
 /**
  * Handler for root item being clicked.
  * @param {Event} event The event.
  * @private
  */
-VolumeList.prototype.onSelectionChange_ = function(event) {
-  // This handler is invoked even when the volume list itself changes the
+NavigationList.prototype.onSelectionChange_ = function(event) {
+  // This handler is invoked even when the navigation list itself changes the
   // selection. In such case, we shouldn't handle the event.
   if (this.dontHandleSelectionEvent_)
     return;
 
   this.selectByIndex(this.selectionModel.selectedIndex);
 };
 
 /**
  * Invoked when the current directory is changed.
  * @param {Event} event The event.
  * @private
  */
-VolumeList.prototype.onCurrentDirectoryChanged_ = function(event) {
+NavigationList.prototype.onCurrentDirectoryChanged_ = function(event) {
   var path = event.newDirEntry.fullPath || this.dataModel.getCurrentDirPath();
   var newRootPath = PathUtil.getRootPath(path);
 
-  // Synchronizes the volume list selection with the current directory, after
-  // it is changed outside of the volume list.
+  // Synchronizes the navigation list selection with the current directory,
+  // after it is changed outside of the navigation list.
 
   // (1) Select the nearest parent directory (including the pinned directories).
   var bestMatchIndex = -1;
   var bestMatchSubStringLen = 0;
   for (var i = 0; i < this.dataModel.length; i++) {
     var itemPath = this.dataModel.item(i);
     if (path.indexOf(itemPath) == 0) {
       if (bestMatchSubStringLen < itemPath.length) {
         bestMatchIndex = i;
         bestMatchSubStringLen = itemPath.length;
@@ skipping 13 matching lines @@
     var itemPath = this.dataModel.item(i);
     if (PathUtil.getRootPath(itemPath) == newRootPath) {
       // Not to invoke the handler of this instance, sets the guard.
       this.dontHandleSelectionEvent_ = true;
       this.selectionModel.selectedIndex = i;
       this.dontHandleSelectionEvent_ = false;
       return;
     }
   }
 };