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