ui/views/controls/button/menu_button.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 "ui/views/controls/button/menu_button.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "grit/ui_resources.h"
   9 #include "grit/ui_strings.h"
  10 #include "ui/accessibility/ax_view_state.h"
  11 #include "ui/base/dragdrop/drag_drop_types.h"
  12 #include "ui/base/l10n/l10n_util.h"
  13 #include "ui/base/resource/resource_bundle.h"
  14 #include "ui/events/event.h"
  15 #include "ui/events/event_constants.h"
  16 #include "ui/gfx/canvas.h"
  17 #include "ui/gfx/image/image.h"
  18 #include "ui/gfx/screen.h"
  19 #include "ui/gfx/text_constants.h"
  20 #include "ui/views/controls/button/button.h"
  21 #include "ui/views/controls/button/menu_button_listener.h"
  22 #include "ui/views/mouse_constants.h"
  23 #include "ui/views/widget/root_view.h"
  24 #include "ui/views/widget/widget.h"
  25
  26 using base::TimeTicks;
  27 using base::TimeDelta;
  28
  29 namespace views {
  30
  31 // Default menu offset.
  32 static const int kDefaultMenuOffsetX = -2;
  33 static const int kDefaultMenuOffsetY = -4;
  34
  35 // static
  36 const char MenuButton::kViewClassName[] = "MenuButton";
  37 const int MenuButton::kMenuMarkerPaddingLeft = 3;
  38 const int MenuButton::kMenuMarkerPaddingRight = -1;
  39
  40 ////////////////////////////////////////////////////////////////////////////////
  41 //
  42 // MenuButton - constructors, destructors, initialization
  43 //
  44 ////////////////////////////////////////////////////////////////////////////////
  45
  46 MenuButton::MenuButton(ButtonListener* listener,
  47                        const base::string16& text,
  48                        MenuButtonListener* menu_button_listener,
  49                        bool show_menu_marker)
  50     : LabelButton(listener, text),
  51       menu_visible_(false),
  52       menu_offset_(kDefaultMenuOffsetX, kDefaultMenuOffsetY),
  53       listener_(menu_button_listener),
  54       show_menu_marker_(show_menu_marker),
  55       menu_marker_(ui::ResourceBundle::GetSharedInstance().GetImageNamed(
  56           IDR_MENU_DROPARROW).ToImageSkia()),
  57       destroyed_flag_(NULL) {
  58   SetHorizontalAlignment(gfx::ALIGN_LEFT);
  59 }
  60
  61 MenuButton::~MenuButton() {
  62   if (destroyed_flag_)
  63     *destroyed_flag_ = true;
  64 }
  65
  66 ////////////////////////////////////////////////////////////////////////////////
  67 //
  68 // MenuButton - Public APIs
  69 //
  70 ////////////////////////////////////////////////////////////////////////////////
  71
  72 bool MenuButton::Activate() {
  73   SetState(STATE_PRESSED);
  74   if (listener_) {
  75     gfx::Rect lb = GetLocalBounds();
  76
  77     // The position of the menu depends on whether or not the locale is
  78     // right-to-left.
  79     gfx::Point menu_position(lb.right(), lb.bottom());
  80     if (base::i18n::IsRTL())
  81       menu_position.set_x(lb.x());
  82
  83     View::ConvertPointToScreen(this, &menu_position);
  84     if (base::i18n::IsRTL())
  85       menu_position.Offset(-menu_offset_.x(), menu_offset_.y());
  86     else
  87       menu_position.Offset(menu_offset_.x(), menu_offset_.y());
  88
  89     int max_x_coordinate = GetMaximumScreenXCoordinate();
  90     if (max_x_coordinate && max_x_coordinate <= menu_position.x())
  91       menu_position.set_x(max_x_coordinate - 1);
  92
  93     // We're about to show the menu from a mouse press. By showing from the
  94     // mouse press event we block RootView in mouse dispatching. This also
  95     // appears to cause RootView to get a mouse pressed BEFORE the mouse
  96     // release is seen, which means RootView sends us another mouse press no
  97     // matter where the user pressed. To force RootView to recalculate the
  98     // mouse target during the mouse press we explicitly set the mouse handler
  99     // to NULL.
 100     static_cast<internal::RootView*>(GetWidget()->GetRootView())->
 101         SetMouseHandler(NULL);
 102
 103     menu_visible_ = true;
 104
 105     bool destroyed = false;
 106     destroyed_flag_ = &destroyed;
 107
 108     listener_->OnMenuButtonClicked(this, menu_position);
 109
 110     if (destroyed) {
 111       // The menu was deleted while showing. Don't attempt any processing.
 112       return false;
 113     }
 114
 115     destroyed_flag_ = NULL;
 116
 117     menu_visible_ = false;
 118     menu_closed_time_ = TimeTicks::Now();
 119
 120     // Now that the menu has closed, we need to manually reset state to
 121     // "normal" since the menu modal loop will have prevented normal
 122     // mouse move messages from getting to this View. We set "normal"
 123     // and not "hot" because the likelihood is that the mouse is now
 124     // somewhere else (user clicked elsewhere on screen to close the menu
 125     // or selected an item) and we will inevitably refresh the hot state
 126     // in the event the mouse _is_ over the view.
 127     SetState(STATE_NORMAL);
 128
 129     // We must return false here so that the RootView does not get stuck
 130     // sending all mouse pressed events to us instead of the appropriate
 131     // target.
 132     return false;
 133   }
 134   return true;
 135 }
 136
 137 void MenuButton::OnPaint(gfx::Canvas* canvas) {
 138   LabelButton::OnPaint(canvas);
 139
 140   if (show_menu_marker_)
 141     PaintMenuMarker(canvas);
 142 }
 143
 144 ////////////////////////////////////////////////////////////////////////////////
 145 //
 146 // MenuButton - Events
 147 //
 148 ////////////////////////////////////////////////////////////////////////////////
 149
 150 gfx::Size MenuButton::GetPreferredSize() const {
 151   gfx::Size prefsize = LabelButton::GetPreferredSize();
 152   if (show_menu_marker_) {
 153     prefsize.Enlarge(menu_marker_->width() + kMenuMarkerPaddingLeft +
 154                          kMenuMarkerPaddingRight,
 155                      0);
 156   }
 157   return prefsize;
 158 }
 159
 160 const char* MenuButton::GetClassName() const {
 161   return kViewClassName;
 162 }
 163
 164 bool MenuButton::OnMousePressed(const ui::MouseEvent& event) {
 165   RequestFocus();
 166   if (state() != STATE_DISABLED) {
 167     // If we're draggable (GetDragOperations returns a non-zero value), then
 168     // don't pop on press, instead wait for release.
 169     if (event.IsOnlyLeftMouseButton() &&
 170         HitTestPoint(event.location()) &&
 171         GetDragOperations(event.location()) == ui::DragDropTypes::DRAG_NONE) {
 172       TimeDelta delta = TimeTicks::Now() - menu_closed_time_;
 173       if (delta.InMilliseconds() > kMinimumMsBetweenButtonClicks)
 174         return Activate();
 175     }
 176   }
 177   return true;
 178 }
 179
 180 void MenuButton::OnMouseReleased(const ui::MouseEvent& event) {
 181   // Explicitly test for left mouse button to show the menu. If we tested for
 182   // !IsTriggerableEvent it could lead to a situation where we end up showing
 183   // the menu and context menu (this would happen if the right button is not
 184   // triggerable and there's a context menu).
 185   if (GetDragOperations(event.location()) != ui::DragDropTypes::DRAG_NONE &&
 186       state() != STATE_DISABLED && !InDrag() && event.IsOnlyLeftMouseButton() &&
 187       HitTestPoint(event.location())) {
 188     Activate();
 189   } else {
 190     LabelButton::OnMouseReleased(event);
 191   }
 192 }
 193
 194 // The reason we override View::OnMouseExited is because we get this event when
 195 // we display the menu. If we don't override this method then
 196 // BaseButton::OnMouseExited will get the event and will set the button's state
 197 // to STATE_NORMAL instead of keeping the state BM_PUSHED. This, in turn, will
 198 // cause the button to appear depressed while the menu is displayed.
 199 void MenuButton::OnMouseExited(const ui::MouseEvent& event) {
 200   if ((state_ != STATE_DISABLED) && (!menu_visible_) && (!InDrag())) {
 201     SetState(STATE_NORMAL);
 202   }
 203 }
 204
 205 void MenuButton::OnGestureEvent(ui::GestureEvent* event) {
 206   if (state() != STATE_DISABLED && event->type() == ui::ET_GESTURE_TAP &&
 207       !Activate()) {
 208     // When |Activate()| returns |false|, it means that a menu is shown and
 209     // has handled the gesture event. So, there is no need to further process
 210     // the gesture event here.
 211     return;
 212   }
 213   LabelButton::OnGestureEvent(event);
 214 }
 215
 216 bool MenuButton::OnKeyPressed(const ui::KeyEvent& event) {
 217   switch (event.key_code()) {
 218     case ui::VKEY_SPACE:
 219       // Alt-space on windows should show the window menu.
 220       if (event.IsAltDown())
 221         break;
 222     case ui::VKEY_RETURN:
 223     case ui::VKEY_UP:
 224     case ui::VKEY_DOWN: {
 225       // WARNING: we may have been deleted by the time Activate returns.
 226       Activate();
 227       // This is to prevent the keyboard event from being dispatched twice.  If
 228       // the keyboard event is not handled, we pass it to the default handler
 229       // which dispatches the event back to us causing the menu to get displayed
 230       // again. Return true to prevent this.
 231       return true;
 232     }
 233     default:
 234       break;
 235   }
 236   return false;
 237 }
 238
 239 bool MenuButton::OnKeyReleased(const ui::KeyEvent& event) {
 240   // Override CustomButton's implementation, which presses the button when
 241   // you press space and clicks it when you release space.  For a MenuButton
 242   // we always activate the menu on key press.
 243   return false;
 244 }
 245
 246 void MenuButton::GetAccessibleState(ui::AXViewState* state) {
 247   CustomButton::GetAccessibleState(state);
 248   state->role = ui::AX_ROLE_POP_UP_BUTTON;
 249   state->default_action = l10n_util::GetStringUTF16(IDS_APP_ACCACTION_PRESS);
 250   state->AddStateFlag(ui::AX_STATE_HASPOPUP);
 251 }
 252
 253 void MenuButton::PaintMenuMarker(gfx::Canvas* canvas) {
 254   gfx::Insets insets = GetInsets();
 255
 256   // We can not use the views' mirroring infrastructure for mirroring a
 257   // MenuButton control (see TextButton::OnPaint() for a detailed explanation
 258   // regarding why we can not flip the canvas). Therefore, we need to
 259   // manually mirror the position of the down arrow.
 260   gfx::Rect arrow_bounds(width() - insets.right() -
 261                          menu_marker_->width() - kMenuMarkerPaddingRight,
 262                          height() / 2 - menu_marker_->height() / 2,
 263                          menu_marker_->width(),
 264                          menu_marker_->height());
 265   arrow_bounds.set_x(GetMirroredXForRect(arrow_bounds));
 266   canvas->DrawImageInt(*menu_marker_, arrow_bounds.x(), arrow_bounds.y());
 267 }
 268
 269 gfx::Rect MenuButton::GetChildAreaBounds() {
 270   gfx::Size s = size();
 271
 272   if (show_menu_marker_) {
 273     s.set_width(s.width() - menu_marker_->width() - kMenuMarkerPaddingLeft -
 274                 kMenuMarkerPaddingRight);
 275   }
 276
 277   return gfx::Rect(s);
 278 }
 279
 280 int MenuButton::GetMaximumScreenXCoordinate() {
 281   if (!GetWidget()) {
 282     NOTREACHED();
 283     return 0;
 284   }
 285
 286   gfx::Rect monitor_bounds = GetWidget()->GetWorkAreaBoundsInScreen();
 287   return monitor_bounds.right() - 1;
 288 }
 289
 290 }  // namespace views