Update drop down menu look & feel

ui/views/controls/menu/menu_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/controls/menu/menu_controller.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/run_loop.h"
 #include "base/time.h"
@@ skipping 32 matching lines @@
 // Period of the scroll timer (in milliseconds).
 static const int kScrollTimerMS = 30;
 
 // Delay, in ms, between when menus are selected are moused over and the menu
 // appears.
 static const int kShowDelay = 400;
 
 // Amount of time from when the drop exits the menu and the menu is hidden.
 static const int kCloseOnExitTime = 1200;
 
+// Border width of the menu shadow (used to align drop down position/bounds)
+static const int kMenuBorderOffsetY = 2;

[sky, 2012/08/07 00:31:57]

This should be moved into menu_config and you'll want to leave the default at 0.

[Harry McCleave, 2012/08/07 01:26:36]

Done.

+static const int kMenuBorderOffsetX = 1;
+
 namespace views {
 
 namespace {
 
 // Returns true if the mnemonic of |menu| matches key.
 bool MatchesMnemonic(MenuItemView* menu, char16 key) {
   return menu->GetMnemonic() == key;
 }
 
 // Returns true if |menu| doesn't have a mnemonic and first character of the its
@@ skipping 207 matching lines @@
 MenuItemView* MenuController::Run(Widget* parent,
                                   MenuButton* button,
                                   MenuItemView* root,
                                   const gfx::Rect& bounds,
                                   MenuItemView::AnchorPosition position,
                                   int* result_mouse_event_flags) {
   exit_type_ = EXIT_NONE;
   possible_drag_ = false;
   drag_in_progress_ = false;
 
-  // We need to drop the first mouse release event when the menu has been
-  // layed out over the bounds.
-  drop_first_release_event_ =
-      root->GetRequestedMenuPosition() == MenuItemView::POSITION_OVER_BOUNDS;
-
   bool nested_menu = showing_;
   if (showing_) {
     // Only support nesting of blocking_run menus, nesting of
     // blocking/non-blocking shouldn't be needed.
     DCHECK(blocking_run_);
 
     // We're already showing, push the current state.
     menu_stack_.push_back(state_);
 
     // The context menu should be owned by the same parent.
@@ skipping 171 matching lines @@
     ShowSiblingMenu(source, event.location());
   }
   UpdateActiveMouseView(source, event, mouse_menu);
 }
 
 void MenuController::OnMouseReleased(SubmenuView* source,
                                      const MouseEvent& event) {
   if (!blocking_run_)
     return;
 
-  // We must ignore the first release event when it occured within the original
-  // bounds.
-  if (drop_first_release_event_ && (event.flags() & ui::EF_LEFT_MOUSE_BUTTON)) {
-    drop_first_release_event_ = false;
-    gfx::Point loc(event.location());
-    View::ConvertPointToScreen(source->GetScrollViewContainer(), &loc);
-    DCHECK(!state_.initial_bounds.IsEmpty());
-    if (state_.initial_bounds.Contains(loc))
-      return;
-  }
-  drop_first_release_event_ = false;
-
   DCHECK(state_.item);
   possible_drag_ = false;
   DCHECK(blocking_run_);
   MenuPart part = GetMenuPart(source, event.location());
   if (event.IsRightMouseButton() && (part.type == MenuPart::MENU_ITEM &&
                                      part.menu)) {
     if (ShowContextMenu(part.menu, source, event))
       return;
   }
 
@@ skipping 287 matching lines @@
        menu_item->GetType() != MenuItemView::SUBMENU)) {
     menu_item->GetWidget()->NotifyAccessibilityEvent(
         menu_item, ui::AccessibilityTypes::EVENT_FOCUS, true);
   }
 }
 
 void MenuController::SetSelectionOnPointerDown(SubmenuView* source,
                                                const LocatedEvent& event) {
   if (!blocking_run_)
     return;
-  drop_first_release_event_ = false;
 
   DCHECK(!active_mouse_view_);
 
   MenuPart part = GetMenuPart(source, event.location());
   if (part.is_scroll())
     return;  // Ignore presses on scroll buttons.
 
   // When this menu is opened through a touch event, a simulated right-click
   // is sent before the menu appears.  Ignore it.
   if ((event.flags() & ui::EF_RIGHT_MOUSE_BUTTON) &&
@@ skipping 236 matching lines @@
     default:
       break;
   }
   return true;
 }
 
 MenuController::MenuController(bool blocking,
                                internal::MenuControllerDelegate* delegate)
     : blocking_run_(blocking),
       showing_(false),
-      drop_first_release_event_(false),
       exit_type_(EXIT_NONE),
       did_capture_(false),
       result_(NULL),
       result_mouse_event_flags_(0),
       drop_target_(NULL),
       drop_position_(MenuDelegate::DROP_UNKNOWN),
       owner_(NULL),
 #if defined(USE_AURA)
       root_window_(NULL),
 #endif
@@ skipping 484 matching lines @@
 gfx::Rect MenuController::CalculateMenuBounds(MenuItemView* item,
                                               bool prefer_leading,
                                               bool* is_leading) {
   DCHECK(item);
 
   SubmenuView* submenu = item->GetSubmenu();
   DCHECK(submenu);
 
   gfx::Size pref = submenu->GetScrollViewContainer()->GetPreferredSize();
 
+  pref.set_width(pref.width() - (2 * kMenuBorderOffsetX));

[sky, 2012/08/07 00:31:57]

Move this into 1545.

[Harry McCleave, 2012/08/07 01:26:36]

Done.

+
   // Don't let the menu go too wide.
-  if (item->actual_menu_position() != MenuItemView::POSITION_OVER_BOUNDS)
-    pref.set_width(std::min(pref.width(),
+  pref.set_width(std::min(pref.width(),
                             item->GetDelegate()->GetMaxWidthForMenu(item)));
   if (!state_.monitor_bounds.IsEmpty())
     pref.set_width(std::min(pref.width(), state_.monitor_bounds.width()));
 
   // Assume we can honor prefer_leading.
   *is_leading = prefer_leading;
 
   int x, y;
 
   if (!item->GetParentMenuItem()) {
     // First item, position relative to initial location.
-    x = state_.initial_bounds.x();
-    if (item->actual_menu_position() == MenuItemView::POSITION_OVER_BOUNDS)
-      y = state_.initial_bounds.y();
-    else
-      y = state_.initial_bounds.bottom();
+    x = state_.initial_bounds.x() + kMenuBorderOffsetX;
+    y = state_.initial_bounds.bottom() + kMenuBorderOffsetY;
     if (state_.anchor == MenuItemView::TOPRIGHT)
       x = x + state_.initial_bounds.width() - pref.width();
 
     if (!state_.monitor_bounds.IsEmpty() &&
-        pref.height() > state_.monitor_bounds.height() &&
-        item->actual_menu_position() == MenuItemView::POSITION_OVER_BOUNDS) {
-      // Handle very tall menus.
-      pref.set_height(state_.monitor_bounds.height());
-      y = state_.monitor_bounds.y();
-    } else if (!state_.monitor_bounds.IsEmpty() &&
-        y + pref.height() > state_.monitor_bounds.bottom() &&
-        item->actual_menu_position() != MenuItemView::POSITION_OVER_BOUNDS) {
+        y + pref.height() > state_.monitor_bounds.bottom()) {
       // The menu doesn't fit fully below the button on the screen. The menu
       // position with respect to the bounds will be preserved if it has
       // already been drawn. When the requested positioning is below the bounds
       // it will shrink the menu to make it fit below.
       // If the requested positioning is best fit, it will first try to fit the
       // menu below. If that does not fit it will try to place it above. If
       // that will not fit it will place it at the bottom of the work area and
       // moving it off the initial_bounds region to avoid overlap.
       // In all other requested position styles it will be flipped above and
       // the height will be shrunken to the usable height.
-      if (item->actual_menu_position() == MenuItemView::POSITION_BELOW_BOUNDS) {
+      if (item->menu_position() == MenuItemView::POSITION_BELOW_BOUNDS) {
         pref.set_height(std::min(pref.height(),
                                  state_.monitor_bounds.bottom() - y));
-      } else if (item->actual_menu_position() ==
+      } else if (item->menu_position() ==
                  MenuItemView::POSITION_BEST_FIT) {
         MenuItemView::MenuPosition orientation =
             MenuItemView::POSITION_BELOW_BOUNDS;
         if (state_.monitor_bounds.height() < pref.height()) {
           // Handle very tall menus.
           pref.set_height(state_.monitor_bounds.height());
           y = state_.monitor_bounds.y();
         } else if (state_.monitor_bounds.y() + pref.height() <
             state_.initial_bounds.y()) {
           // Flipping upwards if there is enough space.
@@ skipping 18 matching lines @@
           } else {
             // The menu should end with the same x coordinate as the owning
             // button.
             if (state_.monitor_bounds.x() >
                 state_.initial_bounds.x() - pref.width())
               x = state_.initial_bounds.right();  // Move right of the button.
             else
               x = state_.initial_bounds.x() - pref.width(); // Move left.
           }
         }
-        item->set_actual_menu_position(orientation);
+        item->set_menu_position(orientation);
       } else {
         pref.set_height(std::min(pref.height(),
             state_.initial_bounds.y() - state_.monitor_bounds.y()));
         y = state_.initial_bounds.y() - pref.height();
-        item->set_actual_menu_position(MenuItemView::POSITION_ABOVE_BOUNDS);
+        item->set_menu_position(MenuItemView::POSITION_ABOVE_BOUNDS);
       }
-    } else if (item->actual_menu_position() ==
+    } else if (item->menu_position() ==
                MenuItemView::POSITION_ABOVE_BOUNDS) {
       pref.set_height(std::min(pref.height(),
           state_.initial_bounds.y() - state_.monitor_bounds.y()));
       y = state_.initial_bounds.y() - pref.height();
-    } else if (item->actual_menu_position() ==
-               MenuItemView::POSITION_OVER_BOUNDS) {
-      // Center vertically assuming all items have the same height.
-      int middle = state_.initial_bounds.y() - pref.height() / 2;
-      if (submenu->GetMenuItemCount() > 0)
-        middle += submenu->GetMenuItemAt(0)->GetPreferredSize().height() / 2;
-      y = std::max(state_.monitor_bounds.y(), middle);
-      if (y + pref.height() > state_.monitor_bounds.bottom())
-        y = state_.monitor_bounds.bottom() - pref.height();
     } else {
-      item->set_actual_menu_position(MenuItemView::POSITION_BELOW_BOUNDS);
+      item->set_menu_position(MenuItemView::POSITION_BELOW_BOUNDS);
     }
   } else {
     // Not the first menu; position it relative to the bounds of the menu
     // item.
     gfx::Point item_loc;
     View::ConvertPointToScreen(item, &item_loc);
 
     // We must make sure we take into account the UI layout. If the layout is
     // RTL, then a 'leading' menu is positioned to the left of the parent menu
     // item and not to the right.
@@ skipping 467 matching lines @@
 
 #if defined(USE_AURA)
 void MenuController::OnWindowActivated(aura::Window* active,
                                        aura::Window* old_active) {
   if (!drag_in_progress_)
     Cancel(EXIT_ALL);
 }
 #endif
 
 }  // namespace views