Move enum MenuAnchorPosition to reduce deps on menu_item_view.h

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"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 17 matching lines @@
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/vector2d.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/menu/menu_config.h"
 #include "ui/views/controls/menu/menu_controller_delegate.h"
 #include "ui/views/controls/menu/menu_host_root_view.h"
+#include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/controls/menu/menu_scroll_view_container.h"
 #include "ui/views/controls/menu/submenu_view.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/mouse_constants.h"
 #include "ui/views/view.h"
 #include "ui/views/view_constants.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager.h"
@@ skipping 291 matching lines @@
   // currently selected item whose mnemonic matches. This may remain -1 even
   // though there are matches.
   int next_match;
 };
 
 // MenuController:State ------------------------------------------------------
 
 MenuController::State::State()
     : item(NULL),
       submenu_open(false),
-      anchor(MenuItemView::TOPLEFT),
-      context_menu(false) {}
+      anchor(MENU_ANCHOR_TOPLEFT),
+      context_menu(false) {
+}
 
 MenuController::State::~State() {}
 
 // MenuController ------------------------------------------------------------
 
 // static
 MenuController* MenuController::active_instance_ = NULL;
 
 // static
 MenuController* MenuController::GetActiveInstance() {
   return active_instance_;
 }
 
 MenuItemView* MenuController::Run(Widget* parent,
                                   MenuButton* button,
                                   MenuItemView* root,
                                   const gfx::Rect& bounds,
-                                  MenuItemView::AnchorPosition position,
+                                  MenuAnchorPosition position,
                                   bool context_menu,
                                   int* result_event_flags) {
   exit_type_ = EXIT_NONE;
   possible_drag_ = false;
   drag_in_progress_ = false;
   closing_event_time_ = base::TimeDelta();
   menu_start_time_ = base::TimeTicks::Now();
   menu_start_mouse_press_loc_ = gfx::Point();
 
   // If we are shown on mouse press, we will eat the subsequent mouse down and
@@ skipping 846 matching lines @@
     return ACCELERATOR_NOT_PROCESSED;
 
   ui::Accelerator accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   hot_view->AcceleratorPressed(accelerator);
   CustomButton* button = static_cast<CustomButton*>(hot_view);
   button->SetHotTracked(true);
   return (exit_type_ == EXIT_NONE) ?
       ACCELERATOR_PROCESSED : ACCELERATOR_PROCESSED_EXIT;
 }
 
-void MenuController::UpdateInitialLocation(
-    const gfx::Rect& bounds,
-    MenuItemView::AnchorPosition position,
-    bool context_menu) {
+void MenuController::UpdateInitialLocation(const gfx::Rect& bounds,
+                                           MenuAnchorPosition position,
+                                           bool context_menu) {
   pending_state_.context_menu = context_menu;
   pending_state_.initial_bounds = bounds;
   if (bounds.height() > 1) {
     // Inset the bounds slightly, otherwise drag coordinates don't line up
     // nicely and menus close prematurely.
     pending_state_.initial_bounds.Inset(0, 1);
   }
 
   // Reverse anchor position for RTL languages.
   if (base::i18n::IsRTL() &&
-      (position == MenuItemView::TOPRIGHT ||
-       position == MenuItemView::TOPLEFT)) {
-    pending_state_.anchor = position == MenuItemView::TOPRIGHT ?
-        MenuItemView::TOPLEFT : MenuItemView::TOPRIGHT;
+      (position == MENU_ANCHOR_TOPRIGHT || position == MENU_ANCHOR_TOPLEFT)) {
+    pending_state_.anchor = position == MENU_ANCHOR_TOPRIGHT
+                                ? MENU_ANCHOR_TOPLEFT
+                                : MENU_ANCHOR_TOPRIGHT;
   } else {
     pending_state_.anchor = position;
   }
 
   // Calculate the bounds of the monitor we'll show menus on. Do this once to
   // avoid repeated system queries for the info.
   pending_state_.monitor_bounds = GetScreen()->GetDisplayNearestPoint(
       bounds.origin()).work_area();
 #if defined(USE_ASH)
   if (!pending_state_.monitor_bounds.Contains(bounds)) {
@@ skipping 35 matching lines @@
 
   gfx::NativeWindow window_under_mouse = GetScreen()->GetWindowUnderCursor();
   // TODO(oshima): Replace with views only API.
   if (!owner_ || window_under_mouse != owner_->GetNativeWindow())
     return false;
 
   // The user moved the mouse outside the menu and over the owning window. See
   // if there is a sibling menu we should show.
   gfx::Point screen_point(mouse_location);
   View::ConvertPointToScreen(source_view, &screen_point);
-  MenuItemView::AnchorPosition anchor;
+  MenuAnchorPosition anchor;
   bool has_mnemonics;
   MenuButton* button = NULL;
   MenuItemView* alt_menu = source->GetMenuItem()->GetDelegate()->
       GetSiblingMenu(source->GetMenuItem()->GetRootMenuItem(),
                      screen_point, &anchor, &has_mnemonics, &button);
   if (!alt_menu || (state_.item && state_.item->GetRootMenuItem() == alt_menu))
     return false;
 
   delegate_->SiblingMenuCreated(alt_menu);
 
@@ skipping 403 matching lines @@
   if (!item->GetParentMenuItem()) {
     // First item, position relative to initial location.
     x = state_.initial_bounds.x();
 
     // Offsets for context menu prevent menu items being selected by
     // simply opening the menu (bug 142992).
     if (menu_config.offset_context_menus && state_.context_menu)
       x += 1;
 
     y = state_.initial_bounds.bottom();
-    if (state_.anchor == MenuItemView::TOPRIGHT) {
+    if (state_.anchor == MENU_ANCHOR_TOPRIGHT) {
       x = x + state_.initial_bounds.width() - pref.width();
       if (menu_config.offset_context_menus && state_.context_menu)
         x -= 1;
-    } else if (state_.anchor == MenuItemView::BOTTOMCENTER) {
+    } else if (state_.anchor == MENU_ANCHOR_BOTTOMCENTER) {
       x = x - (pref.width() - state_.initial_bounds.width()) / 2;
       if (pref.height() >
           state_.initial_bounds.y() + kCenteredContextMenuYOffset) {
         // Menu does not fit above the anchor. We move it to below.
         y = state_.initial_bounds.y() - kCenteredContextMenuYOffset;
       } else {
         y = std::max(0, state_.initial_bounds.y() - pref.height()) +
             kCenteredContextMenuYOffset;
       }
     }
@@ skipping 28 matching lines @@
           orientation = MenuItemView::POSITION_ABOVE_BOUNDS;
         } else {
           // It is allowed to move the menu a bit around in order to get the
           // best fit and to avoid showing scroll elements.
           y = state_.monitor_bounds.bottom() - pref.height();
         }
         if (orientation == MenuItemView::POSITION_BELOW_BOUNDS) {
           // The menu should never overlap the owning button. So move it.
           // We use the anchor view style to determine the preferred position
           // relative to the owning button.
-          if (state_.anchor == MenuItemView::TOPLEFT) {
+          if (state_.anchor == MENU_ANCHOR_TOPLEFT) {
             // The menu starts with the same x coordinate as the owning button.
             if (x + state_.initial_bounds.width() + pref.width() >
                 state_.monitor_bounds.right())
               x -= pref.width();  // Move the menu to the left of the button.
             else
               x += state_.initial_bounds.width(); // Move the menu right.
           } else {
             // The menu should end with the same x coordinate as the owning
             // button.
             if (state_.monitor_bounds.x() >
@@ skipping 92 matching lines @@
 
   gfx::Size pref = submenu->GetScrollViewContainer()->GetPreferredSize();
   const gfx::Rect& owner_bounds = pending_state_.initial_bounds;
 
   // First the size gets reduced to the possible space.
   if (!state_.monitor_bounds.IsEmpty()) {
     int max_width = state_.monitor_bounds.width();
     int max_height = state_.monitor_bounds.height();
     // In case of bubbles, the maximum width is limited by the space
     // between the display corner and the target area + the tip size.
-    if (state_.anchor == MenuItemView::BUBBLE_LEFT) {
+    if (state_.anchor == MENU_ANCHOR_BUBBLE_LEFT) {
       max_width = owner_bounds.x() - state_.monitor_bounds.x() +
                   kBubbleTipSizeLeftRight;
-    } else if (state_.anchor == MenuItemView::BUBBLE_RIGHT) {
+    } else if (state_.anchor == MENU_ANCHOR_BUBBLE_RIGHT) {
       max_width = state_.monitor_bounds.right() - owner_bounds.right() +
                   kBubbleTipSizeLeftRight;
-    } else if (state_.anchor == MenuItemView::BUBBLE_ABOVE) {
+    } else if (state_.anchor == MENU_ANCHOR_BUBBLE_ABOVE) {
       max_height = owner_bounds.y() - state_.monitor_bounds.y() +
                    kBubbleTipSizeTopBottom;
-    } else if (state_.anchor == MenuItemView::BUBBLE_BELOW) {
+    } else if (state_.anchor == MENU_ANCHOR_BUBBLE_BELOW) {
       max_height = state_.monitor_bounds.bottom() - owner_bounds.bottom() +
                    kBubbleTipSizeTopBottom;
     }
     // The space for the menu to cover should never get empty.
     DCHECK_GE(max_width, kBubbleTipSizeLeftRight);
     DCHECK_GE(max_height, kBubbleTipSizeTopBottom);
     pref.set_width(std::min(pref.width(), max_width));
     pref.set_height(std::min(pref.height(), max_height));
   }
   // Also make sure that the menu does not go too wide.
   pref.set_width(std::min(pref.width(),
                           item->GetDelegate()->GetMaxWidthForMenu(item)));
 
   int x, y;
-  if (state_.anchor == MenuItemView::BUBBLE_ABOVE ||
-      state_.anchor == MenuItemView::BUBBLE_BELOW) {
-    if (state_.anchor == MenuItemView::BUBBLE_ABOVE)
+  if (state_.anchor == MENU_ANCHOR_BUBBLE_ABOVE ||
+      state_.anchor == MENU_ANCHOR_BUBBLE_BELOW) {
+    if (state_.anchor == MENU_ANCHOR_BUBBLE_ABOVE)
       y = owner_bounds.y() - pref.height() + kBubbleTipSizeTopBottom;
     else
       y = owner_bounds.bottom() - kBubbleTipSizeTopBottom;
 
     x = owner_bounds.CenterPoint().x() - pref.width() / 2;
     int x_old = x;
     if (x < state_.monitor_bounds.x()) {
       x = state_.monitor_bounds.x();
     } else if (x + pref.width() > state_.monitor_bounds.right()) {
       x = state_.monitor_bounds.right() - pref.width();
     }
     submenu->GetScrollViewContainer()->SetBubbleArrowOffset(
         pref.width() / 2 - x + x_old);
   } else {
-    if (state_.anchor == MenuItemView::BUBBLE_RIGHT)
+    if (state_.anchor == MENU_ANCHOR_BUBBLE_RIGHT)
       x = owner_bounds.right() - kBubbleTipSizeLeftRight;
     else
       x = owner_bounds.x() - pref.width() + kBubbleTipSizeLeftRight;
 
     y = owner_bounds.CenterPoint().y() - pref.height() / 2;
     int y_old = y;
     if (y < state_.monitor_bounds.y()) {
       y = state_.monitor_bounds.y();
     } else if (y + pref.height() > state_.monitor_bounds.bottom()) {
       y = state_.monitor_bounds.bottom() - pref.height();
@@ skipping 478 matching lines @@
   }
 }
 
 gfx::Screen* MenuController::GetScreen() {
   aura::Window* root = GetOwnerRootWindow(owner_);
   return root ? gfx::Screen::GetScreenFor(root)
               : gfx::Screen::GetNativeScreen();
 }
 
 }  // namespace views