Home | History | Annotate | Download | only in extensions 
      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 }
    271