Makes it so that when a folder is open on the bookmark bar and the...

views/controls/menu/menu_controller.cc

 // Copyright (c) 2006-2008 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 "views/controls/menu/menu_controller.h"
 
 #include "app/gfx/canvas.h"
 #include "app/l10n_util.h"
 #include "app/os_exchange_data.h"
 #include "base/keyboard_codes.h"
 #include "base/time.h"
+#include "views/controls/button/menu_button.h"
 #include "views/controls/menu/menu_scroll_view_container.h"
 #include "views/controls/menu/submenu_view.h"
 #include "views/drag_utils.h"
 #include "views/screen.h"
 #include "views/view_constants.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget.h"
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 114 matching lines @@
 MenuController* MenuController::GetActiveInstance() {
   return active_instance_;
 }
 
 #ifdef DEBUG_MENU
 static int instance_count = 0;
 static int nested_depth = 0;
 #endif
 
 MenuItemView* MenuController::Run(gfx::NativeWindow parent,
+                                  MenuButton* button,
                                   MenuItemView* root,
                                   const gfx::Rect& bounds,
                                   MenuItemView::AnchorPosition position,
                                   int* result_mouse_event_flags) {
   exit_all_ = false;
   possible_drag_ = false;
 
   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.
     DCHECK(owner_ == parent);
   } else {
     showing_ = true;
   }
 
   // Reset current state.
   pending_state_ = State();
   state_ = State();
-  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);
-  }
-  pending_state_.anchor = position;
+  UpdateInitialLocation(bounds, position);
+
   owner_ = parent;
 
-  // 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 = Screen::GetMonitorAreaNearestPoint(
-      bounds.origin());
-
   // Set the selection, which opens the initial menu.
   SetSelection(root, true, true);
 
   if (!blocking_run_) {
     // Start the timer to hide the menu. This is needed as we get no
     // notification when the drag has finished.
     StartCancelAllTimer();
     return NULL;
+  } else if (button) {
+    menu_button_ = button;
   }
 
 #ifdef DEBUG_MENU
   nested_depth++;
   DLOG(INFO) << " entering nested loop, depth=" << nested_depth;
 #endif
 
   MessageLoopForUI* loop = MessageLoopForUI::current();
   if (MenuItemView::allow_task_nesting_during_run_) {
     bool did_allow_task_nesting = loop->NestableTasksAllowed();
@@ skipping 35 matching lines @@
     // We're nested and about to return a value. The caller might enter another
     // blocking loop. We need to make sure all menus are hidden before that
     // happens otherwise the menus will stay on screen.
     CloseAllNestedMenus();
 
     // Set exit_all_ to true, which makes sure all nested loops exit
     // immediately.
     exit_all_ = true;
   }
 
+  if (menu_button_) {
+    menu_button_->SetState(CustomButton::BS_NORMAL);
+    menu_button_->SchedulePaint();
+  }
+
   return result;
 }
 
 void MenuController::SetSelection(MenuItemView* menu_item,
                                   bool open_submenu,
                                   bool update_immediately) {
   size_t paths_differ_at = 0;
   std::vector<MenuItemView*> current_path;
   std::vector<MenuItemView*> new_path;
   BuildPathsAndCalculateDiff(pending_state_.item, menu_item, &current_path,
@@ skipping 51 matching lines @@
 }
 
 void MenuController::OnMousePressed(SubmenuView* source,
                                     const MouseEvent& event) {
 #ifdef DEBUG_MENU
   DLOG(INFO) << "OnMousePressed source=" << source;
 #endif
   if (!blocking_run_)
     return;
 
-  MenuPart part =
-      GetMenuPartByScreenCoordinate(source, event.x(), event.y());
+  MenuPart part = GetMenuPartByScreenCoordinate(source, event.x(), event.y());
   if (part.is_scroll())
     return;  // Ignore presses on scroll buttons.
 
   if (part.type == MenuPart::NONE ||
       (part.type == MenuPart::MENU_ITEM && part.menu &&
        part.menu->GetRootMenuItem() != state_.item->GetRootMenuItem())) {
     // Mouse wasn't pressed over any menu, or the active menu, cancel.
 
     // We're going to close and we own the mouse capture. We need to repost the
     // mouse down, otherwise the window the user clicked on won't get the
@@ skipping 24 matching lines @@
   // On a press we immediately commit the selection, that way a submenu
   // pops up immediately rather than after a delay.
   SetSelection(part.menu, open_submenu, true);
 }
 
 void MenuController::OnMouseDragged(SubmenuView* source,
                                     const MouseEvent& event) {
 #ifdef DEBUG_MENU
   DLOG(INFO) << "OnMouseDragged source=" << source;
 #endif
-  MenuPart part =
-      GetMenuPartByScreenCoordinate(source, event.x(), event.y());
+  MenuPart part = GetMenuPartByScreenCoordinate(source, event.x(), event.y());
   UpdateScrolling(part);
 
   if (!blocking_run_)
     return;
 
   if (possible_drag_) {
     if (View::ExceededDragThreshold(event.x() - press_x_,
                                     event.y() - press_y_)) {
       MenuItemView* item = state_.item;
       DCHECK(item);
@@ skipping 25 matching lines @@
           Cancel(true);
         }  // else case, drop was on us.
       }  // else case, someone canceled us, don't do anything
     }
     return;
   }
   if (part.type == MenuPart::MENU_ITEM) {
     if (!part.menu)
       part.menu = source->GetMenuItem();
     SetSelection(part.menu ? part.menu : state_.item, true, false);
+  } else if (part.type == MenuPart::NONE) {
+    ShowSiblingMenu(source, event);
   }
 }
 
 void MenuController::OnMouseReleased(SubmenuView* source,
                                      const MouseEvent& event) {
 #ifdef DEBUG_MENU
   DLOG(INFO) << "OnMouseReleased source=" << source;
 #endif
   if (!blocking_run_)
     return;
 
   DCHECK(state_.item);
   possible_drag_ = false;
   DCHECK(blocking_run_);
-  MenuPart part =
-      GetMenuPartByScreenCoordinate(source, event.x(), event.y());
+  MenuPart part = GetMenuPartByScreenCoordinate(source, event.x(), event.y());
   if (event.IsRightMouseButton() && (part.type == MenuPart::MENU_ITEM &&
                                      part.menu)) {
     // Set the selection immediately, making sure the submenu is only open
     // if it already was.
     bool open_submenu = (state_.item == pending_state_.item &&
                          state_.submenu_open);
     SetSelection(pending_state_.item, open_submenu, true);
     gfx::Point loc(event.location());
     View::ConvertPointToScreen(source->GetScrollViewContainer(), &loc);
 
@@ skipping 15 matching lines @@
 }
 
 void MenuController::OnMouseMoved(SubmenuView* source,
                                   const MouseEvent& event) {
 #ifdef DEBUG_MENU
   DLOG(INFO) << "OnMouseMoved source=" << source;
 #endif
   if (showing_submenu_)
     return;
 
-  MenuPart part =
-      GetMenuPartByScreenCoordinate(source, event.x(), event.y());
+  MenuPart part = GetMenuPartByScreenCoordinate(source, event.x(), event.y());
 
   UpdateScrolling(part);
 
   if (!blocking_run_)
     return;
 
+  if (part.type == MenuPart::NONE && ShowSiblingMenu(source, event))
+    return;
+
   if (part.type == MenuPart::MENU_ITEM && part.menu) {
     SetSelection(part.menu, true, false);
   } else if (!part.is_scroll() && pending_state_.item &&
              (!pending_state_.item->HasSubmenu() ||
               !pending_state_.item->GetSubmenu()->IsShowing())) {
     // On exit if the user hasn't selected an item with a submenu, move the
     // selection back to the parent menu item.
     SetSelection(pending_state_.item->GetParentMenuItem(), true, false);
   }
 }
@@ skipping 315 matching lines @@
     : blocking_run_(blocking),
       showing_(false),
       exit_all_(false),
       did_capture_(false),
       result_(NULL),
       result_mouse_event_flags_(0),
       drop_target_(NULL),
       owner_(NULL),
       possible_drag_(false),
       valid_drop_coordinates_(false),
-      showing_submenu_(false) {
+      showing_submenu_(false),
+      menu_button_(NULL) {
 #ifdef DEBUG_MENU
   instance_count++;
   DLOG(INFO) << "created MC, count=" << instance_count;
 #endif
 }
 
 MenuController::~MenuController() {
   DCHECK(!showing_);
   StopShowTimer();
   StopCancelAllTimer();
 #ifdef DEBUG_MENU
   instance_count--;
   DLOG(INFO) << "destroyed MC, count=" << instance_count;
 #endif
 }
 
+void MenuController::UpdateInitialLocation(
+    const gfx::Rect& bounds,
+    MenuItemView::AnchorPosition position) {
+  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);
+  }
+  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 = Screen::GetMonitorAreaNearestPoint(
+      bounds.origin());
+}
+
 void MenuController::Accept(MenuItemView* item, int mouse_event_flags) {
   DCHECK(IsBlockingRun());
   result_ = item;
   exit_all_ = true;
   result_mouse_event_flags_ = mouse_event_flags;
 }
 
+bool MenuController::ShowSiblingMenu(SubmenuView* source, const MouseEvent& e) {
+  if (!menu_stack_.empty() || !menu_button_)
+    return false;
+
+  View* source_view = source->GetScrollViewContainer();
+  if (e.x() >= 0 && e.x() < source_view->width() && e.y() >= 0 &&
+      e.y() < source_view->height()) {
+    // The mouse is over the menu, no need to continue.
+    return false;
+  }
+
+  gfx::NativeWindow window_under_mouse = Screen::GetWindowAtCursorScreenPoint();
+  if (window_under_mouse != owner_)
+    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(e.location());
+  View::ConvertPointToScreen(source_view, &screen_point);
+  MenuItemView::AnchorPosition 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 || alt_menu == state_.item)
+    return false;
+
+  if (!button) {
+    // If the delegate returns a menu, they must also return a button.
+    NOTREACHED();
+    return false;
+  }
+
+  // There is a sibling menu, update the button state, hide the current menu
+  // and show the new one.
+  menu_button_->SetState(CustomButton::BS_NORMAL);
+  menu_button_->SchedulePaint();
+  menu_button_ = button;
+  menu_button_->SetState(CustomButton::BS_PUSHED);
+  menu_button_->SchedulePaint();
+
+  // Need to reset capture when we show the menu again, otherwise we aren't
+  // going to get any events.
+  did_capture_ = false;
+  gfx::Point screen_menu_loc;
+  View::ConvertPointToScreen(button, &screen_menu_loc);
+  // Subtract 1 from the height to make the popup flush with the button border.
+  UpdateInitialLocation(gfx::Rect(screen_menu_loc.x(), screen_menu_loc.y(),
+                                  button->width(), button->height() - 1),
+                        anchor);
+  alt_menu->PrepareForRun(has_mnemonics);
+  alt_menu->controller_ = this;
+  SetSelection(alt_menu, true, true);
+  return true;
+}
+
 void MenuController::CloseAllNestedMenus() {
   for (std::list<State>::iterator i = menu_stack_.begin();
        i != menu_stack_.end(); ++i) {
     MenuItemView* item = i->item;
     MenuItemView* last_item = item;
     while (item) {
       CloseMenu(item);
       last_item = item;
       item = item->GetParentMenuItem();
     }
@@ skipping 564 matching lines @@
   if (!scroll_task_.get())
     scroll_task_.reset(new MenuScrollTask());
   scroll_task_->Update(part);
 }
 
 void MenuController::StopScrolling() {
   scroll_task_.reset(NULL);
 }
 
 }  // namespace views