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 259 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 485 matching lines @@
                                               bool prefer_leading,
                                               bool* is_leading) {
   DCHECK(item);
 
   SubmenuView* submenu = item->GetSubmenu();
   DCHECK(submenu);
 
   gfx::Size pref = submenu->GetScrollViewContainer()->GetPreferredSize();
 
   // 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() -
+                    (2 * MenuConfig::instance().menu_border_offset_horizontal),

[sky, 2012/08/07 03:41:53]

I'm confused by the usage of this. Here menu_border_offset_horizontal means
shrink the border by a certain amount, and below it means offset the initial
position by it. It should only mean one of these things. IF you need to adjust
the preferred size, it shouldn't be here but instead in where the preferred size
is calculated.

Also, this change is going to effect the placement of *all* menus, not just
those from the comobox. The bug seems to indicate this is only for the placement
of the menu from the combobox. If that's the case, the adjustments shouldn't be
here, but where the size and position are calculated in the combobox.

[Harry McCleave, 2012/08/07 20:16:34]

Done.

                             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() +
+          MenuConfig::instance().menu_border_offset_horizontal;
+    y = state_.initial_bounds.bottom() +
+          MenuConfig::instance().menu_border_offset_vertical;
     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.
@@ skipping 44 matching lines @@
         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);
       }
     } else if (item->actual_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);
     }
   } 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
@@ skipping 469 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