chrome/browser/ui/views/extensions/browser_action_overflow_menu_controller.cc

   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 #include "chrome/browser/ui/views/extensions/browser_action_overflow_menu_controller.h"
   6
   7 #include "base/message_loop/message_loop.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/browser/extensions/extension_action.h"
  10 #include "chrome/browser/extensions/extension_action_manager.h"
  11 #include "chrome/browser/extensions/extension_context_menu_model.h"
  12 #include "chrome/browser/profiles/profile.h"
  13 #include "chrome/browser/ui/browser_list.h"
  14 #include "chrome/browser/ui/views/extensions/browser_action_drag_data.h"
  15 #include "chrome/browser/ui/views/toolbar/browser_action_view.h"
  16 #include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
  17 #include "extensions/common/extension.h"
  18 #include "ui/gfx/canvas.h"
  19 #include "ui/views/controls/menu/menu_item_view.h"
  20 #include "ui/views/controls/menu/menu_runner.h"
  21 #include "ui/views/controls/menu/submenu_view.h"
  22 #include "ui/views/widget/widget.h"
  23
  24 // In the browser actions container's chevron menu, a menu item view's icon
  25 // comes from BrowserActionView::GetIconWithBadge() (which comes from the
  26 // browser action button's icon) when the menu item view is created. But, the
  27 // browser action button's icon may not be loaded in time because it is read
  28 // from file system in another thread.
  29 // The IconUpdater will update the menu item view's icon when the browser
  30 // action button's icon has been updated.
  31 class IconUpdater : public BrowserActionButton::IconObserver {
  32  public:
  33   IconUpdater(views::MenuItemView* menu_item_view,
  34               BrowserActionButton* button)
  35       : menu_item_view_(menu_item_view),
  36         button_(button) {
  37     DCHECK(menu_item_view);
  38     DCHECK(button);
  39     button->set_icon_observer(this);
  40   }
  41   virtual ~IconUpdater() {
  42     button_->set_icon_observer(NULL);
  43   }
  44
  45   // Overridden from BrowserActionButton::IconObserver:
  46   virtual void OnIconUpdated(const gfx::ImageSkia& icon) OVERRIDE {
  47     menu_item_view_->SetIcon(icon);
  48   }
  49
  50  private:
  51   // The menu item view whose icon might be updated.
  52   views::MenuItemView* menu_item_view_;
  53
  54   // The button to be observed. When its icon changes, update the corresponding
  55   // menu item view's icon.
  56   BrowserActionButton* button_;
  57
  58   DISALLOW_COPY_AND_ASSIGN(IconUpdater);
  59 };
  60
  61 BrowserActionOverflowMenuController::BrowserActionOverflowMenuController(
  62     BrowserActionsContainer* owner,
  63     Browser* browser,
  64     views::MenuButton* menu_button,
  65     const std::vector<BrowserActionView*>& views,
  66     int start_index)
  67     : owner_(owner),
  68       browser_(browser),
  69       observer_(NULL),
  70       menu_button_(menu_button),
  71       menu_(NULL),
  72       views_(&views),
  73       start_index_(start_index),
  74       for_drop_(false) {
  75   menu_ = new views::MenuItemView(this);
  76   menu_runner_.reset(new views::MenuRunner(menu_));
  77   menu_->set_has_icons(true);
  78
  79   size_t command_id = 1;  // Menu id 0 is reserved, start with 1.
  80   for (size_t i = start_index; i < views_->size(); ++i) {
  81     BrowserActionView* view = (*views_)[i];
  82     views::MenuItemView* menu_item = menu_->AppendMenuItemWithIcon(
  83         command_id,
  84         base::UTF8ToUTF16(view->button()->extension()->name()),
  85         view->GetIconWithBadge());
  86
  87     // Set the tooltip for this item.
  88     base::string16 tooltip = base::UTF8ToUTF16(
  89         extensions::ExtensionActionManager::Get(owner_->profile())->
  90         GetBrowserAction(*view->button()->extension())->
  91         GetTitle(owner_->GetCurrentTabId()));
  92     menu_->SetTooltip(tooltip, command_id);
  93
  94     icon_updaters_.push_back(new IconUpdater(menu_item, view->button()));
  95
  96     ++command_id;
  97   }
  98 }
  99
 100 BrowserActionOverflowMenuController::~BrowserActionOverflowMenuController() {
 101   if (observer_)
 102     observer_->NotifyMenuDeleted(this);
 103 }
 104
 105 bool BrowserActionOverflowMenuController::RunMenu(views::Widget* window,
 106                                                   bool for_drop) {
 107   for_drop_ = for_drop;
 108
 109   gfx::Rect bounds = menu_button_->bounds();
 110   gfx::Point screen_loc;
 111   views::View::ConvertPointToScreen(menu_button_, &screen_loc);
 112   bounds.set_x(screen_loc.x());
 113   bounds.set_y(screen_loc.y());
 114
 115   views::MenuAnchorPosition anchor = views::MENU_ANCHOR_TOPRIGHT;
 116   // As we maintain our own lifetime we can safely ignore the result.
 117   ignore_result(menu_runner_->RunMenuAt(window, menu_button_, bounds, anchor,
 118       ui::MENU_SOURCE_NONE, for_drop_ ? views::MenuRunner::FOR_DROP : 0));
 119   if (!for_drop_) {
 120     // Give the context menu (if any) a chance to execute the user-selected
 121     // command.
 122     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 123   }
 124   return true;
 125 }
 126
 127 void BrowserActionOverflowMenuController::CancelMenu() {
 128   menu_->Cancel();
 129 }
 130
 131 bool BrowserActionOverflowMenuController::IsCommandEnabled(int id) const {
 132   BrowserActionView* view = (*views_)[start_index_ + id - 1];
 133   return view->button()->IsEnabled(owner_->GetCurrentTabId());
 134 }
 135
 136 void BrowserActionOverflowMenuController::ExecuteCommand(int id) {
 137   BrowserActionView* view = (*views_)[start_index_ + id - 1];
 138   owner_->OnBrowserActionExecuted(view->button());
 139 }
 140
 141 bool BrowserActionOverflowMenuController::ShowContextMenu(
 142     views::MenuItemView* source,
 143     int id,
 144     const gfx::Point& p,
 145     ui::MenuSourceType source_type) {
 146   const extensions::Extension* extension =
 147       (*views_)[start_index_ + id - 1]->button()->extension();
 148   if (!extension->ShowConfigureContextMenus())
 149     return false;
 150
 151   scoped_refptr<ExtensionContextMenuModel> context_menu_contents =
 152       new ExtensionContextMenuModel(extension, browser_, owner_);
 153   views::MenuRunner context_menu_runner(context_menu_contents.get());
 154
 155   // We can ignore the result as we delete ourself.
 156   // This blocks until the user choses something or dismisses the menu.
 157   ignore_result(context_menu_runner.RunMenuAt(
 158       menu_button_->GetWidget(),
 159       NULL,
 160       gfx::Rect(p, gfx::Size()),
 161       views::MENU_ANCHOR_TOPLEFT,
 162       source_type,
 163       views::MenuRunner::HAS_MNEMONICS | views::MenuRunner::IS_NESTED |
 164           views::MenuRunner::CONTEXT_MENU));
 165
 166   // The user is done with the context menu, so we can close the underlying
 167   // menu.
 168   menu_->Cancel();
 169
 170   return true;
 171 }
 172
 173 void BrowserActionOverflowMenuController::DropMenuClosed(
 174     views::MenuItemView* menu) {
 175   delete this;
 176 }
 177
 178 bool BrowserActionOverflowMenuController::GetDropFormats(
 179     views::MenuItemView* menu,
 180     int* formats,
 181     std::set<OSExchangeData::CustomFormat>* custom_formats) {
 182   custom_formats->insert(BrowserActionDragData::GetBrowserActionCustomFormat());
 183   return true;
 184 }
 185
 186 bool BrowserActionOverflowMenuController::AreDropTypesRequired(
 187     views::MenuItemView* menu) {
 188   return true;
 189 }
 190
 191 bool BrowserActionOverflowMenuController::CanDrop(
 192     views::MenuItemView* menu, const OSExchangeData& data) {
 193   BrowserActionDragData drop_data;
 194   if (!drop_data.Read(data))
 195     return false;
 196   return drop_data.IsFromProfile(owner_->profile());
 197 }
 198
 199 int BrowserActionOverflowMenuController::GetDropOperation(
 200     views::MenuItemView* item,
 201     const ui::DropTargetEvent& event,
 202     DropPosition* position) {
 203   // Don't allow dropping from the BrowserActionContainer into slot 0 of the
 204   // overflow menu since once the move has taken place the item you are dragging
 205   // falls right out of the menu again once the user releases the button
 206   // (because we don't shrink the BrowserActionContainer when you do this).
 207   if ((item->GetCommand() == 0) && (*position == DROP_BEFORE)) {
 208     BrowserActionDragData drop_data;
 209     if (!drop_data.Read(event.data()))
 210       return ui::DragDropTypes::DRAG_NONE;
 211
 212     if (drop_data.index() < owner_->VisibleBrowserActions())
 213       return ui::DragDropTypes::DRAG_NONE;
 214   }
 215
 216   return ui::DragDropTypes::DRAG_MOVE;
 217 }
 218
 219 int BrowserActionOverflowMenuController::OnPerformDrop(
 220     views::MenuItemView* menu,
 221     DropPosition position,
 222     const ui::DropTargetEvent& event) {
 223   BrowserActionDragData drop_data;
 224   if (!drop_data.Read(event.data()))
 225     return ui::DragDropTypes::DRAG_NONE;
 226
 227   size_t drop_index;
 228   ViewForId(menu->GetCommand(), &drop_index);
 229
 230   // When not dragging within the overflow menu (dragging an icon into the menu)
 231   // subtract one to get the right index.
 232   if (position == DROP_BEFORE &&
 233       drop_data.index() < owner_->VisibleBrowserActions())
 234     --drop_index;
 235
 236   owner_->MoveBrowserAction(drop_data.id(), drop_index);
 237
 238   if (for_drop_)
 239     delete this;
 240   return ui::DragDropTypes::DRAG_MOVE;
 241 }
 242
 243 bool BrowserActionOverflowMenuController::CanDrag(views::MenuItemView* menu) {
 244   return true;
 245 }
 246
 247 void BrowserActionOverflowMenuController::WriteDragData(
 248     views::MenuItemView* sender, OSExchangeData* data) {
 249   size_t drag_index;
 250   BrowserActionView* view = ViewForId(sender->GetCommand(), &drag_index);
 251   std::string id = view->button()->extension()->id();
 252
 253   BrowserActionDragData drag_data(id, drag_index);
 254   drag_data.Write(owner_->profile(), data);
 255 }
 256
 257 int BrowserActionOverflowMenuController::GetDragOperations(
 258     views::MenuItemView* sender) {
 259   return ui::DragDropTypes::DRAG_MOVE;
 260 }
 261
 262 BrowserActionView* BrowserActionOverflowMenuController::ViewForId(
 263     int id, size_t* index) {
 264   // The index of the view being dragged (GetCommand gives a 1-based index into
 265   // the overflow menu).
 266   size_t view_index = owner_->VisibleBrowserActions() + id - 1;
 267   if (index)
 268     *index = view_index;
 269   return owner_->GetBrowserActionViewAt(view_index);
 270 }