src/chrome/browser/ui/views/bookmarks/bookmark_menu_controller_views.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/bookmarks/bookmark_menu_controller_views.h"
   6
   7 #include "base/prefs/pref_service.h"
   8 #include "base/stl_util.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/bookmarks/bookmark_stats.h"
  11 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
  12 #include "chrome/browser/ui/views/bookmarks/bookmark_menu_controller_observer.h"
  13 #include "chrome/browser/ui/views/bookmarks/bookmark_menu_delegate.h"
  14 #include "components/bookmarks/browser/bookmark_model.h"
  15 #include "content/public/browser/page_navigator.h"
  16 #include "content/public/browser/user_metrics.h"
  17 #include "ui/base/dragdrop/os_exchange_data.h"
  18 #include "ui/views/controls/button/menu_button.h"
  19 #include "ui/views/controls/menu/menu_item_view.h"
  20 #include "ui/views/controls/menu/menu_runner.h"
  21 #include "ui/views/widget/widget.h"
  22
  23 using base::UserMetricsAction;
  24 using content::PageNavigator;
  25 using views::MenuItemView;
  26
  27 BookmarkMenuController::BookmarkMenuController(Browser* browser,
  28                                                PageNavigator* page_navigator,
  29                                                views::Widget* parent,
  30                                                const BookmarkNode* node,
  31                                                int start_child_index,
  32                                                bool for_drop)
  33     : menu_delegate_(
  34         new BookmarkMenuDelegate(browser, page_navigator, parent, 1,
  35                                  kint32max)),
  36       node_(node),
  37       observer_(NULL),
  38       for_drop_(for_drop),
  39       bookmark_bar_(NULL) {
  40   menu_delegate_->Init(this, NULL, node, start_child_index,
  41                        BookmarkMenuDelegate::HIDE_PERMANENT_FOLDERS,
  42                        BOOKMARK_LAUNCH_LOCATION_BAR_SUBFOLDER);
  43   menu_runner_.reset(new views::MenuRunner(
  44       menu_delegate_->menu(), for_drop ? views::MenuRunner::FOR_DROP : 0));
  45 }
  46
  47 void BookmarkMenuController::RunMenuAt(BookmarkBarView* bookmark_bar) {
  48   bookmark_bar_ = bookmark_bar;
  49   views::MenuButton* menu_button = bookmark_bar_->GetMenuButtonForNode(node_);
  50   DCHECK(menu_button);
  51   views::MenuAnchorPosition anchor;
  52   bookmark_bar_->GetAnchorPositionForButton(menu_button, &anchor);
  53   gfx::Point screen_loc;
  54   views::View::ConvertPointToScreen(menu_button, &screen_loc);
  55   // Subtract 1 from the height to make the popup flush with the button border.
  56   gfx::Rect bounds(screen_loc.x(), screen_loc.y(), menu_button->width(),
  57                    menu_button->height() - 1);
  58   menu_delegate_->GetBookmarkModel()->AddObserver(this);
  59   // We only delete ourself after the menu completes, so we can safely ignore
  60   // the return value.
  61   ignore_result(menu_runner_->RunMenuAt(menu_delegate_->parent(),
  62                                         menu_button,
  63                                         bounds,
  64                                         anchor,
  65                                         ui::MENU_SOURCE_NONE));
  66   if (!for_drop_)
  67     delete this;
  68 }
  69
  70 void BookmarkMenuController::Cancel() {
  71   menu_delegate_->menu()->Cancel();
  72 }
  73
  74 MenuItemView* BookmarkMenuController::menu() const {
  75   return menu_delegate_->menu();
  76 }
  77
  78 MenuItemView* BookmarkMenuController::context_menu() const {
  79   return menu_delegate_->context_menu();
  80 }
  81
  82 void BookmarkMenuController::SetPageNavigator(PageNavigator* navigator) {
  83   menu_delegate_->SetPageNavigator(navigator);
  84 }
  85
  86 base::string16 BookmarkMenuController::GetTooltipText(int id,
  87                                                 const gfx::Point& p) const {
  88   return menu_delegate_->GetTooltipText(id, p);
  89 }
  90
  91 bool BookmarkMenuController::IsTriggerableEvent(views::MenuItemView* menu,
  92                                                 const ui::Event& e) {
  93   return menu_delegate_->IsTriggerableEvent(menu, e);
  94 }
  95
  96 void BookmarkMenuController::ExecuteCommand(int id, int mouse_event_flags) {
  97   menu_delegate_->ExecuteCommand(id, mouse_event_flags);
  98 }
  99
 100 bool BookmarkMenuController::ShouldExecuteCommandWithoutClosingMenu(
 101       int id, const ui::Event& e) {
 102   return menu_delegate_->ShouldExecuteCommandWithoutClosingMenu(id, e);
 103 }
 104
 105 bool BookmarkMenuController::GetDropFormats(
 106       MenuItemView* menu,
 107       int* formats,
 108       std::set<ui::OSExchangeData::CustomFormat>* custom_formats) {
 109   return menu_delegate_->GetDropFormats(menu, formats, custom_formats);
 110 }
 111
 112 bool BookmarkMenuController::AreDropTypesRequired(MenuItemView* menu) {
 113   return menu_delegate_->AreDropTypesRequired(menu);
 114 }
 115
 116 bool BookmarkMenuController::CanDrop(MenuItemView* menu,
 117                                      const ui::OSExchangeData& data) {
 118   return menu_delegate_->CanDrop(menu, data);
 119 }
 120
 121 int BookmarkMenuController::GetDropOperation(
 122     MenuItemView* item,
 123     const ui::DropTargetEvent& event,
 124     DropPosition* position) {
 125   return menu_delegate_->GetDropOperation(item, event, position);
 126 }
 127
 128 int BookmarkMenuController::OnPerformDrop(MenuItemView* menu,
 129                                           DropPosition position,
 130                                           const ui::DropTargetEvent& event) {
 131   int result = menu_delegate_->OnPerformDrop(menu, position, event);
 132   if (for_drop_)
 133     delete this;
 134   return result;
 135 }
 136
 137 bool BookmarkMenuController::ShowContextMenu(MenuItemView* source,
 138                                              int id,
 139                                              const gfx::Point& p,
 140                                              ui::MenuSourceType source_type) {
 141   return menu_delegate_->ShowContextMenu(source, id, p, source_type);
 142 }
 143
 144 void BookmarkMenuController::DropMenuClosed(MenuItemView* menu) {
 145   delete this;
 146 }
 147
 148 bool BookmarkMenuController::CanDrag(MenuItemView* menu) {
 149   return menu_delegate_->CanDrag(menu);
 150 }
 151
 152 void BookmarkMenuController::WriteDragData(MenuItemView* sender,
 153                                            ui::OSExchangeData* data) {
 154   return menu_delegate_->WriteDragData(sender, data);
 155 }
 156
 157 int BookmarkMenuController::GetDragOperations(MenuItemView* sender) {
 158   return menu_delegate_->GetDragOperations(sender);
 159 }
 160
 161 views::MenuItemView* BookmarkMenuController::GetSiblingMenu(
 162     views::MenuItemView* menu,
 163     const gfx::Point& screen_point,
 164     views::MenuAnchorPosition* anchor,
 165     bool* has_mnemonics,
 166     views::MenuButton** button) {
 167   if (!bookmark_bar_ || for_drop_)
 168     return NULL;
 169   gfx::Point bookmark_bar_loc(screen_point);
 170   views::View::ConvertPointFromScreen(bookmark_bar_, &bookmark_bar_loc);
 171   int start_index;
 172   const BookmarkNode* node = bookmark_bar_->GetNodeForButtonAtModelIndex(
 173       bookmark_bar_loc, &start_index);
 174   if (!node || !node->is_folder())
 175     return NULL;
 176
 177   menu_delegate_->SetActiveMenu(node, start_index);
 178   *button = bookmark_bar_->GetMenuButtonForNode(node);
 179   bookmark_bar_->GetAnchorPositionForButton(*button, anchor);
 180   *has_mnemonics = false;
 181   return this->menu();
 182 }
 183
 184 int BookmarkMenuController::GetMaxWidthForMenu(MenuItemView* view) {
 185   return menu_delegate_->GetMaxWidthForMenu(view);
 186 }
 187
 188 void BookmarkMenuController::BookmarkModelChanged() {
 189   if (!menu_delegate_->is_mutating_model())
 190     menu()->Cancel();
 191 }
 192
 193 BookmarkMenuController::~BookmarkMenuController() {
 194   menu_delegate_->GetBookmarkModel()->RemoveObserver(this);
 195   if (observer_)
 196     observer_->BookmarkMenuControllerDeleted(this);
 197 }