src/chrome/browser/resources/file_manager/foreground/js/file_selection.js

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 'use strict';
   6
   7 /**
   8  * The current selection object.
   9  *
  10  * @param {FileManager} fileManager FileManager instance.
  11  * @param {Array.<number>} indexes Selected indexes.
  12  * @constructor
  13  */
  14 function FileSelection(fileManager, indexes) {
  15   this.fileManager_ = fileManager;
  16   this.computeBytesSequence_ = 0;
  17   this.indexes = indexes;
  18   this.entries = [];
  19   this.totalCount = 0;
  20   this.fileCount = 0;
  21   this.directoryCount = 0;
  22   this.bytes = 0;
  23   this.showBytes = false;
  24   this.allDriveFilesPresent = false,
  25   this.iconType = null;
  26   this.bytesKnown = false;
  27   this.mustBeHidden_ = false;
  28   this.mimeTypes = null;
  29
  30   // Synchronously compute what we can.
  31   for (var i = 0; i < this.indexes.length; i++) {
  32     var entry = fileManager.getFileList().item(this.indexes[i]);
  33     if (!entry)
  34       continue;
  35
  36     this.entries.push(entry);
  37
  38     if (this.iconType == null) {
  39       this.iconType = FileType.getIcon(entry);
  40     } else if (this.iconType != 'unknown') {
  41       var iconType = FileType.getIcon(entry);
  42       if (this.iconType != iconType)
  43         this.iconType = 'unknown';
  44     }
  45
  46     if (entry.isFile) {
  47       this.fileCount += 1;
  48     } else {
  49       this.directoryCount += 1;
  50     }
  51     this.totalCount++;
  52   }
  53
  54   this.tasks = new FileTasks(this.fileManager_);
  55
  56   Object.seal(this);
  57 }
  58
  59 /**
  60  * Computes data required to get file tasks and requests the tasks.
  61  *
  62  * @param {function} callback The callback.
  63  */
  64 FileSelection.prototype.createTasks = function(callback) {
  65   if (!this.fileManager_.isOnDrive()) {
  66     this.tasks.init(this.entries);
  67     callback();
  68     return;
  69   }
  70
  71   this.fileManager_.metadataCache_.get(this.entries, 'drive', function(props) {
  72     var present = props.filter(function(p) { return p && p.availableOffline });
  73     this.allDriveFilesPresent = present.length == props.length;
  74
  75     // Collect all of the mime types and push that info into the selection.
  76     this.mimeTypes = props.map(function(value) {
  77       return (value && value.contentMimeType) || '';
  78     });
  79
  80     this.tasks.init(this.entries, this.mimeTypes);
  81     callback();
  82   }.bind(this));
  83 };
  84
  85 /**
  86  * Computes the total size of selected files.
  87  *
  88  * @param {function} callback Completion callback. Not called when cancelled,
  89  *     or a new call has been invoked in the meantime.
  90  */
  91 FileSelection.prototype.computeBytes = function(callback) {
  92   if (this.entries.length == 0) {
  93     this.bytesKnown = true;
  94     this.showBytes = false;
  95     this.bytes = 0;
  96     return;
  97   }
  98
  99   var computeBytesSequence = ++this.computeBytesSequence_;
 100   var pendingMetadataCount = 0;
 101
 102   var maybeDone = function() {
 103     if (pendingMetadataCount == 0) {
 104       this.bytesKnown = true;
 105       callback();
 106     }
 107   }.bind(this);
 108
 109   var onProps = function(properties) {
 110     // Ignore if the call got cancelled, or there is another new one fired.
 111     if (computeBytesSequence != this.computeBytesSequence_)
 112       return;
 113
 114     // It may happen that the metadata is not available because a file has been
 115     // deleted in the meantime.
 116     if (properties)
 117       this.bytes += properties.size;
 118     pendingMetadataCount--;
 119     maybeDone();
 120   }.bind(this);
 121
 122   for (var index = 0; index < this.entries.length; index++) {
 123     var entry = this.entries[index];
 124     if (entry.isFile) {
 125       this.showBytes |= !FileType.isHosted(entry);
 126       pendingMetadataCount++;
 127       this.fileManager_.metadataCache_.get(entry, 'filesystem', onProps);
 128     } else if (entry.isDirectory) {
 129       // Don't compute the directory size as it's expensive.
 130       // crbug.com/179073.
 131       this.showBytes = false;
 132       break;
 133     }
 134   }
 135   maybeDone();
 136 };
 137
 138 /**
 139  * Cancels any async computation by increasing the sequence number. Results
 140  * of any previous call to computeBytes() will be discarded.
 141  *
 142  * @private
 143  */
 144 FileSelection.prototype.cancelComputing_ = function() {
 145   this.computeBytesSequence_++;
 146 };
 147
 148 /**
 149  * This object encapsulates everything related to current selection.
 150  *
 151  * @param {FileManager} fileManager File manager instance.
 152  * @extends {cr.EventTarget}
 153  * @constructor
 154  */
 155 function FileSelectionHandler(fileManager) {
 156   this.fileManager_ = fileManager;
 157   // TODO(dgozman): create a shared object with most of UI elements.
 158   this.okButton_ = fileManager.okButton_;
 159   this.filenameInput_ = fileManager.filenameInput_;
 160   this.previewPanel_ = fileManager.previewPanel_;
 161   this.taskItems_ = fileManager.taskItems_;
 162 }
 163
 164 /**
 165  * Create the temporary disabled action menu item.
 166  * @return {Object} Created disabled item.
 167  * @private
 168  */
 169 FileSelectionHandler.createTemporaryDisabledActionMenuItem_ = function() {
 170   if (!FileSelectionHandler.cachedDisabledActionMenuItem_) {
 171     FileSelectionHandler.cachedDisabledActionMenuItem_ = {
 172       label: str('ACTION_OPEN'),
 173       disabled: true
 174     };
 175   }
 176
 177   return FileSelectionHandler.cachedDisabledActionMenuItem_;
 178 };
 179
 180 /**
 181  * Cached the temporary disabled action menu item. Used inside
 182  * FileSelectionHandler.createTemporaryDisabledActionMenuItem_().
 183  * @private
 184  */
 185 FileSelectionHandler.cachedDisabledActionMenuItem_ = null;
 186
 187 /**
 188  * FileSelectionHandler extends cr.EventTarget.
 189  */
 190 FileSelectionHandler.prototype.__proto__ = cr.EventTarget.prototype;
 191
 192 /**
 193  * Maximum amount of thumbnails in the preview pane.
 194  *
 195  * @const
 196  * @type {number}
 197  */
 198 FileSelectionHandler.MAX_PREVIEW_THUMBNAIL_COUNT = 4;
 199
 200 /**
 201  * Maximum width or height of an image what pops up when the mouse hovers
 202  * thumbnail in the bottom panel (in pixels).
 203  *
 204  * @const
 205  * @type {number}
 206  */
 207 FileSelectionHandler.IMAGE_HOVER_PREVIEW_SIZE = 200;
 208
 209 /**
 210  * Update the UI when the selection model changes.
 211  *
 212  * @param {Event} event The change event.
 213  */
 214 FileSelectionHandler.prototype.onFileSelectionChanged = function(event) {
 215   var indexes =
 216       this.fileManager_.getCurrentList().selectionModel.selectedIndexes;
 217   if (this.selection) this.selection.cancelComputing_();
 218   var selection = new FileSelection(this.fileManager_, indexes);
 219   this.selection = selection;
 220
 221   if (this.fileManager_.dialogType == DialogType.SELECT_SAVEAS_FILE) {
 222     // If this is a save-as dialog, copy the selected file into the filename
 223     // input text box.
 224     if (this.selection.totalCount == 1 &&
 225         this.selection.entries[0].isFile &&
 226         this.filenameInput_.value != this.selection.entries[0].name) {
 227       this.filenameInput_.value = this.selection.entries[0].name;
 228     }
 229   }
 230
 231   this.updateOkButton();
 232
 233   if (this.selectionUpdateTimer_) {
 234     clearTimeout(this.selectionUpdateTimer_);
 235     this.selectionUpdateTimer_ = null;
 236   }
 237
 238   // The rest of the selection properties are computed via (sometimes lengthy)
 239   // asynchronous calls. We initiate these calls after a timeout. If the
 240   // selection is changing quickly we only do this once when it slows down.
 241
 242   var updateDelay = 200;
 243   var now = Date.now();
 244   if (now > (this.lastFileSelectionTime_ || 0) + updateDelay) {
 245     // The previous selection change happened a while ago. Update the UI soon.
 246     updateDelay = 0;
 247   }
 248   this.lastFileSelectionTime_ = now;
 249
 250   if (this.fileManager_.dialogType === DialogType.FULL_PAGE &&
 251       selection.directoryCount === 0 && selection.fileCount > 0) {
 252     // Show disabled items for position calculation of the menu. They will be
 253     // overridden in this.updateFileSelectionAsync().
 254     this.fileManager_.updateContextMenuActionItems(
 255         FileSelectionHandler.createTemporaryDisabledActionMenuItem_(), true);
 256   } else {
 257     // Update context menu.
 258     this.fileManager_.updateContextMenuActionItems(null, false);
 259   }
 260
 261   this.selectionUpdateTimer_ = setTimeout(function() {
 262     this.selectionUpdateTimer_ = null;
 263     if (this.selection == selection)
 264       this.updateFileSelectionAsync(selection);
 265   }.bind(this), updateDelay);
 266 };
 267
 268 /**
 269  * Updates the Ok button enabled state.
 270  *
 271  * @return {boolean} Whether button is enabled.
 272  */
 273 FileSelectionHandler.prototype.updateOkButton = function() {
 274   var selectable;
 275   var dialogType = this.fileManager_.dialogType;
 276
 277   if (DialogType.isFolderDialog(dialogType)) {
 278     // In SELECT_FOLDER mode, we allow to select current directory
 279     // when nothing is selected.
 280     selectable = this.selection.directoryCount <= 1 &&
 281         this.selection.fileCount == 0;
 282   } else if (dialogType == DialogType.SELECT_OPEN_FILE) {
 283     selectable = (this.isFileSelectionAvailable() &&
 284                   this.selection.directoryCount == 0 &&
 285                   this.selection.fileCount == 1);
 286   } else if (dialogType == DialogType.SELECT_OPEN_MULTI_FILE) {
 287     selectable = (this.isFileSelectionAvailable() &&
 288                   this.selection.directoryCount == 0 &&
 289                   this.selection.fileCount >= 1);
 290   } else if (dialogType == DialogType.SELECT_SAVEAS_FILE) {
 291     if (this.fileManager_.isOnReadonlyDirectory()) {
 292       selectable = false;
 293     } else {
 294       selectable = !!this.filenameInput_.value;
 295     }
 296   } else if (dialogType == DialogType.FULL_PAGE) {
 297     // No "select" buttons on the full page UI.
 298     selectable = true;
 299   } else {
 300     throw new Error('Unknown dialog type');
 301   }
 302
 303   this.okButton_.disabled = !selectable;
 304   return selectable;
 305 };
 306
 307 /**
 308   * Check if all the files in the current selection are available. The only
 309   * case when files might be not available is when the selection contains
 310   * uncached Drive files and the browser is offline.
 311   *
 312   * @return {boolean} True if all files in the current selection are
 313   *                   available.
 314   */
 315 FileSelectionHandler.prototype.isFileSelectionAvailable = function() {
 316   var isDriveOffline =
 317       this.fileManager_.volumeManager.getDriveConnectionState().type ===
 318           util.DriveConnectionType.OFFLINE;
 319   return !this.fileManager_.isOnDrive() || !isDriveOffline ||
 320       this.selection.allDriveFilesPresent;
 321 };
 322
 323 /**
 324  * Calculates async selection stats and updates secondary UI elements.
 325  *
 326  * @param {FileSelection} selection The selection object.
 327  */
 328 FileSelectionHandler.prototype.updateFileSelectionAsync = function(selection) {
 329   if (this.selection != selection) return;
 330
 331   // Update the file tasks.
 332   if (this.fileManager_.dialogType === DialogType.FULL_PAGE &&
 333       selection.directoryCount === 0 && selection.fileCount > 0) {
 334     selection.createTasks(function() {
 335       if (this.selection != selection)
 336         return;
 337       selection.tasks.display(this.taskItems_);
 338       selection.tasks.updateMenuItem();
 339     }.bind(this));
 340   } else {
 341     this.taskItems_.hidden = true;
 342   }
 343
 344   // Update preview panels.
 345   var wasVisible = this.previewPanel_.visible;
 346   this.previewPanel_.setSelection(selection);
 347
 348   // Scroll to item
 349   if (!wasVisible && this.selection.totalCount == 1) {
 350     var list = this.fileManager_.getCurrentList();
 351     list.scrollIndexIntoView(list.selectionModel.selectedIndex);
 352   }
 353
 354   // Sync the commands availability.
 355   if (this.fileManager_.commandHandler)
 356     this.fileManager_.commandHandler.updateAvailability();
 357
 358   // Inform tests it's OK to click buttons now.
 359   if (selection.totalCount > 0) {
 360     util.testSendMessage('selection-change-complete');
 361   }
 362 };