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

views/controls/menu/menu_controller.h

 // 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.
 
 #ifndef VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_
 #define VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_
 
 #include "build/build_config.h"
 
 #include <list>
 #include <set>
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/timer.h"
 #include "views/controls/menu/menu_delegate.h"
 #include "views/controls/menu/menu_item_view.h"
 
 class OSExchangeData;
 
 namespace views {
 
 class DropTargetEvent;
+class MenuButton;
 class MenuHostRootView;
 class MouseEvent;
 class SubmenuView;
 class View;
 
 // MenuController -------------------------------------------------------------
 
 // MenuController is used internally by the various menu classes to manage
 // showing, selecting and drag/drop for menus. All relevant events are
 // forwarded to the MenuController from SubmenuView and MenuHost.
 class MenuController : public MessageLoopForUI::Dispatcher {
  public:
   friend class MenuHostRootView;
   friend class MenuItemView;
 
   // If a menu is currently active, this returns the controller for it.
   static MenuController* GetActiveInstance();
 
   // Runs the menu at the specified location. If the menu was configured to
   // block, the selected item is returned. If the menu does not block this
   // returns NULL immediately.
   MenuItemView* Run(gfx::NativeWindow parent,
+                    MenuButton* button,
                     MenuItemView* root,
                     const gfx::Rect& bounds,
                     MenuItemView::AnchorPosition position,
                     int* mouse_event_flags);
 
   // Whether or not Run blocks.
   bool IsBlockingRun() const { return blocking_run_; }
 
   // Sets the selection to menu_item, a value of NULL unselects everything.
   // If open_submenu is true and menu_item has a submenu, the submenu is shown.
@@ skipping 118 matching lines @@
   bool OnKeyDown(int key_code, const MSG& msg);
 #else
   bool OnKeyDown(int key_code);
 #endif
 
   // Creates a MenuController. If blocking is true, Run blocks the caller
   explicit MenuController(bool blocking);
 
   ~MenuController();
 
+  void UpdateInitialLocation(const gfx::Rect& bounds,
+                             MenuItemView::AnchorPosition position);
+
   // Invoked when the user accepts the selected item. This is only used
   // when blocking. This schedules the loop to quit.
   void Accept(MenuItemView* item, int mouse_event_flags);
 
+  bool ShowSiblingMenu(SubmenuView* source, const MouseEvent& e);
+
   // Closes all menus, including any menus of nested invocations of Run.
   void CloseAllNestedMenus();
 
   // Gets the enabled menu item at the specified location.
   // If over_any_menu is non-null it is set to indicate whether the location
   // is over any menu. It is possible for this to return NULL, but
   // over_any_menu to be true. For example, the user clicked on a separator.
   MenuItemView* GetMenuItemAt(View* menu, int x, int y);
 
   // If there is an empty menu item at the specified location, it is returned.
@@ skipping 124 matching lines @@
   // opening or closing submenus. This gives a slight delayed effect to
   // submenus as the user moves the mouse around. This is done so that as the
   // user moves the mouse all submenus don't immediately pop.
   State pending_state_;
   State state_;
 
   // If the user accepted the selection, this is the result.
   MenuItemView* result_;
 
   // The mouse event flags when the user clicked on a menu. Is 0 if the
-  // user did not use the mousee to select the menu.
+  // user did not use the mouse to select the menu.
   int result_mouse_event_flags_;
 
   // If not empty, it means we're nested. When Run is invoked from within
   // Run, the current state (state_) is pushed onto menu_stack_. This allows
   // MenuController to restore the state when the nested run returns.
   std::list<State> menu_stack_;
 
   // As the mouse moves around submenus are not opened immediately. Instead
   // they open after this timer fires.
   base::OneShotTimer<MenuController> show_timer_;
@@ skipping 25 matching lines @@
   int drop_y_;
   int last_drop_operation_;
 
   // If true, we're in the middle of invoking ShowAt on a submenu.
   bool showing_submenu_;
 
   // Task for scrolling the menu. If non-null indicates a scroll is currently
   // underway.
   scoped_ptr<MenuScrollTask> scroll_task_;
 
+  MenuButton* menu_button_;
+
   DISALLOW_COPY_AND_ASSIGN(MenuController);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_