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