Bookmark manager: make Organized menu commands to work.

chrome/browser/resources/bookmark_manager/js/main.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.
 
 /** @const */ var BookmarkList = bmm.BookmarkList;
 /** @const */ var BookmarkTree = bmm.BookmarkTree;
 /** @const */ var Command = cr.ui.Command;
 /** @const */ var CommandBinding = cr.ui.CommandBinding;
 /** @const */ var LinkKind = cr.LinkKind;
 /** @const */ var ListItem = cr.ui.ListItem;
@@ skipping 883 matching lines @@
  * @param {!cr.ui.CanExecuteEvent} e The event fired by the command system.
  * @param {!cr.ui.Command} command The command we are currently processing.
  */
 function updateOpenCommands(e, command) {
   var selectedItem = e.target.selectedItem;
   var selectionCount;
   if (e.target == tree) {
     selectionCount = selectedItem ? 1 : 0;
     selectedItem = selectedItem.bookmarkNode;
   } else {
-    selectionCount = e.target.selectedItems.length;
+    selectionCount = list.selectedItems.length;
   }
 
   var isFolder = selectionCount == 1 &&
                  selectedItem &&
                  bmm.isFolder(selectedItem);
   var multiple = selectionCount != 1 || isFolder;
 
   function hasBookmarks(node) {
     for (var i = 0; i < node.children.length; i++) {
       if (!bmm.isFolder(node.children[i]))
@@ skipping 57 matching lines @@
 document.addEventListener('canExecute', function(e) {
   var command = e.command;
   switch (command.id) {
     case 'import-menu-command':
       e.canExecute = canEdit;
       break;
     case 'export-menu-command':
       // We can always execute the export-menu command.
       e.canExecute = true;
       break;
-
-    case 'undo-command':
-      // The global undo command has no visible UI, so always enable it, and
-      // just make it a no-op if undo is not possible.
-      e.canExecute = true;
+    case 'sort-command':
+      e.canExecute = !list.isRecent() && !list.isSearch() &&
+          list.dataModel.length > 1;
       break;
-
-    case 'add-new-bookmark-command':
-    case 'new-folder-command':
-      // When active element is other than list/tree view, add-new-bookmark and
-      // new-folder commands are avaiable as if list view is active.
-      canExecuteShared(e, list.isRecent() || list.isSearch());
+    default:
+      canExecuteForList(e);
       break;
   }
 });
 
 /**
  * Helper function for handling canExecute for the list and the tree.
  * @param {!Event} e Can execute event object.
  * @param {boolean} isRecentOrSearch Whether the user is trying to do a command
  *     on recent or search.
  */
 function canExecuteShared(e, isRecentOrSearch) {
   var command = e.command;
   var commandId = command.id;
   switch (commandId) {
     case 'paste-command':
       updatePasteCommand();
       break;
 
-    case 'sort-command':
-      if (isRecentOrSearch) {
-        e.canExecute = false;
-      } else {
-        e.canExecute = list.dataModel.length > 0 && canEdit;
-
-        // The list might be loading so listen to the load event.
-        if (canEdit) {
-          var f = function() {
-            list.removeEventListener('load', f);
-            command.disabled = list.dataModel.length == 0 || !canEdit;
-          };
-          list.addEventListener('load', f);
-        }
-      }
-      break;
-
     case 'add-new-bookmark-command':
     case 'new-folder-command':
       e.canExecute = !isRecentOrSearch && canEdit;
       break;
 
     case 'open-in-new-tab-command':
     case 'open-in-background-tab-command':
     case 'open-in-new-window-command':
     case 'open-incognito-window-command':
       updateOpenCommands(e, command);
       break;
 
     case 'undo-delete-command':
       e.canExecute = !!lastDeletedNodes;
       break;
   }
 }
 
-// Update canExecute for the commands when the list is the active element.
-list.addEventListener('canExecute', function(e) {
-  if (e.target != list) return;
-
+/**
+ * Helper function for handling canExecute for the list and document.
+ * @param {!Event} e Can execute event object.
+ */
+function canExecuteForList(e) {
   var command = e.command;
   var commandId = command.id;
 
   function hasSelected() {
-    return !!e.target.selectedItem;
+    return !!list.selectedItem;
   }
 
   function hasSingleSelected() {
-    return e.target.selectedItems.length == 1;
+    return list.selectedItems.length == 1;
   }
 
   function isRecentOrSearch() {
     return list.isRecent() || list.isSearch();
   }
 
   switch (commandId) {
     case 'rename-folder-command':
       // Show rename if a single folder is selected.
-      var items = e.target.selectedItems;
+      var items = list.selectedItems;
       if (items.length != 1) {
         e.canExecute = false;
         command.hidden = true;
       } else {
         var isFolder = bmm.isFolder(items[0]);
         e.canExecute = isFolder && canEdit;
         command.hidden = !isFolder;
       }
       break;
 
     case 'edit-command':
       // Show the edit command if not a folder.
-      var items = e.target.selectedItems;
+      var items = list.selectedItems;
       if (items.length != 1) {
         e.canExecute = false;
         command.hidden = false;
       } else {
         var isFolder = bmm.isFolder(items[0]);
         e.canExecute = !isFolder && canEdit;
         command.hidden = isFolder;
       }
       break;
 
@@ skipping 10 matching lines @@
       e.canExecute = hasSelected();
       break;
 
     case 'open-in-same-window-command':
       e.canExecute = hasSelected();
       break;
 
     default:
       canExecuteShared(e, isRecentOrSearch());
   }
+}
+
+// Update canExecute for the commands when the list is the active element.
+list.addEventListener('canExecute', function(e) {
+  if (e.target != list) return;
+  canExecuteForList(e);
 });
 
 // Update canExecute for the commands when the tree is the active element.
 tree.addEventListener('canExecute', function(e) {
   if (e.target != tree) return;
 
   var command = e.command;
   var commandId = command.id;
 
   function hasSelected() {
@@ skipping 71 matching lines @@
       });
     }
   });
 }
 
 var organizeButton = document.querySelector('.summary > button');
 organizeButton.addEventListener('click', function(e) {
   updateEditingCommands();
   $('add-new-bookmark-command').canExecuteChange();
   $('new-folder-command').canExecuteChange();
+  $('sort-command').canExecuteChange();
 });
 list.addEventListener('contextmenu', updateEditingCommands);
 tree.addEventListener('contextmenu', updateEditingCommands);
 
-// Handle global commands.
-document.addEventListener('command', function(e) {
-  var command = e.command;
-  switch (command.id) {
-    case 'import-menu-command':
-      chrome.bookmarks.import();
-      break;
-    case 'export-menu-command':
-      chrome.bookmarks.export();
-      break;
-    case 'undo-command':
-      if (performGlobalUndo)
-        performGlobalUndo();
-      break;
-    case 'add-new-bookmark-command':
-    case 'new-folder-command':
-      if (e.target != list && e.target != tree)
-        handleCommand(e);
-      break;
-  }
-});
-
 function handleRename(e) {
   var item = e.target;
   var bookmarkNode = item.bookmarkNode;
   chrome.bookmarks.update(bookmarkNode.id, {title: item.label});
   performGlobalUndo = null;  // This can't be undone, so disable global undo.
 }
 
 tree.addEventListener('rename', handleRename);
 list.addEventListener('rename', handleRename);
 
@@ skipping 79 matching lines @@
   return linkController ||
       (linkController = new cr.LinkController(loadTimeData));
 }
 
 /**
  * Returns the selected bookmark nodes of the active element. Only call this
  * if the list or the tree is focused.
  * @return {!Array} Array of bookmark nodes.
  */
 function getSelectedBookmarkNodes() {
-  if (document.activeElement == list) {
-    return list.selectedItems;
-  } else if (document.activeElement == tree) {
-    return [tree.selectedItem.bookmarkNode];
-  } else {
-    throw Error('getSelectedBookmarkNodes called when wrong element focused.');
-  }
+  return document.activeElement == tree ? [tree.selectedItem.bookmarkNode] :
+                                          list.selectedItems;
 }
 
 /**
  * @return {!Array.<string>} An array of the selected bookmark IDs.
  */
 function getSelectedBookmarkIds() {
   return getSelectedBookmarkNodes().map(function(node) {
     return node.id;
   });
 }
@@ skipping 264 matching lines @@
   }
 
   list.startBatchUpdates();
 
   chrome.bookmarks.onCreated.addListener(handle);
   chrome.bookmarks.onMoved.addListener(handle);
   timer = setTimeout(handleTimeout, 300);
 }
 
 /**
- * Handler for the command event. This is used both for the tree and the list.
+ * Handler for the command event. This is used for context menu of list/tree
+ * and organized menu.
  * @param {!Event} e The event object.
  */
 function handleCommand(e) {
   var command = e.command;
   var commandId = command.id;
   switch (commandId) {
+    case 'import-menu-command':
+      chrome.bookmarks.import();
+      break;
+    case 'export-menu-command':
+      chrome.bookmarks.export();
+      break;
+    case 'undo-command':
+      if (performGlobalUndo)
+        performGlobalUndo();
+      break;
     case 'show-in-folder-command':
       showInFolder();
       break;
     case 'open-in-new-tab-command':
     case 'open-in-background-tab-command':
       openBookmarks(LinkKind.BACKGROUND_TAB);
       break;
     case 'open-in-new-window-command':
       openBookmarks(LinkKind.WINDOW);
       break;
@@ skipping 14 matching lines @@
     case 'paste-command':
       selectItemsAfterUserAction(list);
       chrome.bookmarkManagerPrivate.paste(list.parentId,
                                           getSelectedBookmarkIds());
       break;
     case 'sort-command':
       chrome.bookmarkManagerPrivate.sortChildren(list.parentId);
       break;
     case 'rename-folder-command':
     case 'edit-command':
-      if (document.activeElement == list) {
+      if (document.activeElement == tree)
+        tree.selectedItem.editing = true;
+      else {
         var li = list.getListItem(list.selectedItem);
         if (li)
           li.editing = true;
-      } else {
-        document.activeElement.selectedItem.editing = true;
       }
       break;
     case 'new-folder-command':
       newFolder();
       break;
     case 'add-new-bookmark-command':
       addPage();
       break;
     case 'open-in-same-window-command':
       openItem();
@@ skipping 16 matching lines @@
 
 $('open-in-new-window-command').shortcut = 'Shift-Enter';
 $('open-in-background-tab-command').shortcut = cr.isMac ? 'Meta-Enter' :
                                                           'Ctrl-Enter';
 $('open-in-new-tab-command').shortcut = cr.isMac ? 'Shift-Meta-Enter' :
                                                    'Shift-Ctrl-Enter';
 
 $('rename-folder-command').shortcut = $('edit-command').shortcut =
     cr.isMac ? 'Enter' : 'F2';
 
-list.addEventListener('command', handleCommand);
-tree.addEventListener('command', handleCommand);
+document.addEventListener('command', handleCommand);
 
 // Execute the copy, cut and paste commands when those events are dispatched by
 // the browser. This allows us to rely on the browser to handle the keyboard
 // shortcuts for these commands.
 (function() {
   function handle(id) {
     return function(e) {
       var command = $(id);
       if (!command.disabled) {
         command.execute();
         if (e) e.preventDefault();  // Prevent the system beep.
       }
     };
   }
 
   // Listen to copy, cut and paste events and execute the associated commands.
   document.addEventListener('copy', handle('copy-command'));
   document.addEventListener('cut', handle('cut-command'));
 
   var pasteHandler = handle('paste-command');
   document.addEventListener('paste', function(e) {
     // Paste is a bit special since we need to do an async call to see if we can
     // paste because the paste command might not be up to date.
     updatePasteCommand(pasteHandler);
   });
 })();