ui/views/controls/menu/menu_runner_impl.cc

   1 // Copyright 2014 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 "ui/views/controls/menu/menu_runner_impl.h"
   6
   7 #include "ui/native_theme/native_theme.h"
   8 #include "ui/views/controls/button/menu_button.h"
   9 #include "ui/views/controls/menu/menu_controller.h"
  10 #include "ui/views/controls/menu/menu_delegate.h"
  11 #include "ui/views/controls/menu/menu_item_view.h"
  12 #include "ui/views/controls/menu/menu_runner_impl_adapter.h"
  13 #include "ui/views/widget/widget.h"
  14
  15 #if defined(OS_WIN)
  16 #include "base/win/win_util.h"
  17 #endif
  18
  19 namespace views {
  20 namespace internal {
  21
  22 #if !defined(OS_MACOSX)
  23 MenuRunnerImplInterface* MenuRunnerImplInterface::Create(
  24     ui::MenuModel* menu_model,
  25     int32 run_types) {
  26   return new MenuRunnerImplAdapter(menu_model);
  27 }
  28 #endif
  29
  30 MenuRunnerImpl::MenuRunnerImpl(MenuItemView* menu)
  31     : menu_(menu),
  32       running_(false),
  33       delete_after_run_(false),
  34       for_drop_(false),
  35       controller_(NULL),
  36       owns_controller_(false),
  37       closing_event_time_(base::TimeDelta()),
  38       weak_factory_(this) {
  39 }
  40
  41 bool MenuRunnerImpl::IsRunning() const {
  42   return running_;
  43 }
  44
  45 void MenuRunnerImpl::Release() {
  46   if (running_) {
  47     if (delete_after_run_)
  48       return;  // We already canceled.
  49
  50     // The menu is running a nested message loop, we can't delete it now
  51     // otherwise the stack would be in a really bad state (many frames would
  52     // have deleted objects on them). Instead cancel the menu, when it returns
  53     // Holder will delete itself.
  54     delete_after_run_ = true;
  55
  56     // Swap in a different delegate. That way we know the original MenuDelegate
  57     // won't be notified later on (when it's likely already been deleted).
  58     if (!empty_delegate_.get())
  59       empty_delegate_.reset(new MenuDelegate());
  60     menu_->set_delegate(empty_delegate_.get());
  61
  62     DCHECK(controller_);
  63     // Release is invoked when MenuRunner is destroyed. Assume this is happening
  64     // because the object referencing the menu has been destroyed and the menu
  65     // button is no longer valid.
  66     controller_->Cancel(MenuController::EXIT_DESTROYED);
  67   } else {
  68     delete this;
  69   }
  70 }
  71
  72 MenuRunner::RunResult MenuRunnerImpl::RunMenuAt(Widget* parent,
  73                                                 MenuButton* button,
  74                                                 const gfx::Rect& bounds,
  75                                                 MenuAnchorPosition anchor,
  76                                                 int32 run_types) {
  77   closing_event_time_ = base::TimeDelta();
  78   if (running_) {
  79     // Ignore requests to show the menu while it's already showing. MenuItemView
  80     // doesn't handle this very well (meaning it crashes).
  81     return MenuRunner::NORMAL_EXIT;
  82   }
  83
  84   MenuController* controller = MenuController::GetActiveInstance();
  85   if (controller) {
  86     if ((run_types & MenuRunner::IS_NESTED) != 0) {
  87       if (!controller->IsBlockingRun()) {
  88         controller->CancelAll();
  89         controller = NULL;
  90       }
  91     } else {
  92       // There's some other menu open and we're not nested. Cancel the menu.
  93       controller->CancelAll();
  94       if ((run_types & MenuRunner::FOR_DROP) == 0) {
  95         // We can't open another menu, otherwise the message loop would become
  96         // twice nested. This isn't necessarily a problem, but generally isn't
  97         // expected.
  98         return MenuRunner::NORMAL_EXIT;
  99       }
 100       // Drop menus don't block the message loop, so it's ok to create a new
 101       // MenuController.
 102       controller = NULL;
 103     }
 104   }
 105
 106   running_ = true;
 107   for_drop_ = (run_types & MenuRunner::FOR_DROP) != 0;
 108   bool has_mnemonics = (run_types & MenuRunner::HAS_MNEMONICS) != 0;
 109   owns_controller_ = false;
 110   if (!controller) {
 111     // No menus are showing, show one.
 112     ui::NativeTheme* theme =
 113         parent ? parent->GetNativeTheme() : ui::NativeTheme::instance();
 114     controller = new MenuController(theme, !for_drop_, this);
 115     owns_controller_ = true;
 116   }
 117   controller->set_is_combobox((run_types & MenuRunner::COMBOBOX) != 0);
 118   controller_ = controller;
 119   menu_->set_controller(controller_);
 120   menu_->PrepareForRun(owns_controller_,
 121                        has_mnemonics,
 122                        !for_drop_ && ShouldShowMnemonics(button));
 123
 124   // Run the loop.
 125   int mouse_event_flags = 0;
 126   MenuItemView* result =
 127       controller->Run(parent,
 128                       button,
 129                       menu_,
 130                       bounds,
 131                       anchor,
 132                       (run_types & MenuRunner::CONTEXT_MENU) != 0,
 133                       (run_types & MenuRunner::NESTED_DRAG) != 0,
 134                       &mouse_event_flags);
 135   // Get the time of the event which closed this menu.
 136   closing_event_time_ = controller->closing_event_time();
 137   if (for_drop_) {
 138     // Drop menus return immediately. We finish processing in DropMenuClosed.
 139     return MenuRunner::NORMAL_EXIT;
 140   }
 141   return MenuDone(result, mouse_event_flags);
 142 }
 143
 144 void MenuRunnerImpl::Cancel() {
 145   if (running_)
 146     controller_->Cancel(MenuController::EXIT_ALL);
 147 }
 148
 149 base::TimeDelta MenuRunnerImpl::GetClosingEventTime() const {
 150   return closing_event_time_;
 151 }
 152
 153 void MenuRunnerImpl::DropMenuClosed(NotifyType type, MenuItemView* menu) {
 154   MenuDone(NULL, 0);
 155
 156   if (type == NOTIFY_DELEGATE && menu->GetDelegate()) {
 157     // Delegate is null when invoked from the destructor.
 158     menu->GetDelegate()->DropMenuClosed(menu);
 159   }
 160 }
 161
 162 void MenuRunnerImpl::SiblingMenuCreated(MenuItemView* menu) {
 163   if (menu != menu_ && sibling_menus_.count(menu) == 0)
 164     sibling_menus_.insert(menu);
 165 }
 166
 167 MenuRunnerImpl::~MenuRunnerImpl() {
 168   delete menu_;
 169   for (std::set<MenuItemView*>::iterator i = sibling_menus_.begin();
 170        i != sibling_menus_.end();
 171        ++i)
 172     delete *i;
 173 }
 174
 175 MenuRunner::RunResult MenuRunnerImpl::MenuDone(MenuItemView* result,
 176                                                int mouse_event_flags) {
 177   menu_->RemoveEmptyMenus();
 178   menu_->set_controller(NULL);
 179
 180   if (owns_controller_) {
 181     // We created the controller and need to delete it.
 182     delete controller_;
 183     owns_controller_ = false;
 184   }
 185   controller_ = NULL;
 186   // Make sure all the windows we created to show the menus have been
 187   // destroyed.
 188   menu_->DestroyAllMenuHosts();
 189   if (delete_after_run_) {
 190     delete this;
 191     return MenuRunner::MENU_DELETED;
 192   }
 193   running_ = false;
 194   if (result && menu_->GetDelegate()) {
 195     // Executing the command may also delete this.
 196     base::WeakPtr<MenuRunnerImpl> ref(weak_factory_.GetWeakPtr());
 197     menu_->GetDelegate()->ExecuteCommand(result->GetCommand(),
 198                                          mouse_event_flags);
 199     if (!ref)
 200       return MenuRunner::MENU_DELETED;
 201   }
 202   return MenuRunner::NORMAL_EXIT;
 203 }
 204
 205 bool MenuRunnerImpl::ShouldShowMnemonics(MenuButton* button) {
 206   // Show mnemonics if the button has focus or alt is pressed.
 207   bool show_mnemonics = button ? button->HasFocus() : false;
 208 #if defined(OS_WIN)
 209   // This is only needed on Windows.
 210   if (!show_mnemonics)
 211     show_mnemonics = base::win::IsAltPressed();
 212 #endif
 213   return show_mnemonics;
 214 }
 215
 216 }  // namespace internal
 217 }  // namespace views