Adding drag-drop support in and out of the Browser Action overflow menu....

chrome/browser/views/browser_actions_container.h

 // Copyright (c) 2010 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 CHROME_BROWSER_VIEWS_BROWSER_ACTIONS_CONTAINER_H_
 #define CHROME_BROWSER_VIEWS_BROWSER_ACTIONS_CONTAINER_H_
 
+#include <set>
+#include <string>
 #include <vector>
 
 #include "base/task.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/extensions/image_loading_tracker.h"
 #include "chrome/browser/views/browser_bubble.h"
+#include "chrome/browser/views/extensions/browser_action_overflow_menu_controller.h"
 #include "chrome/browser/views/extensions/extension_action_context_menu.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "views/controls/button/menu_button.h"
 #include "views/controls/menu/view_menu_delegate.h"
 #include "views/controls/resize_gripper.h"
 #include "views/view.h"
 
 class BrowserActionOverflowMenuController;
 class BrowserActionsContainer;
@@ skipping 194 matching lines @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 class BrowserActionsContainer
   : public views::View,
     public NotificationObserver,
     public BrowserBubble::Delegate,
     public views::ViewMenuDelegate,
     public views::DragController,
     public views::ResizeGripper::ResizeGripperDelegate,
     public AnimationDelegate,
-    public ExtensionToolbarModel::Observer {
+    public ExtensionToolbarModel::Observer,
+    public BrowserActionOverflowMenuController::Observer {
+  friend class ShowFolderMenuTask;
  public:
   BrowserActionsContainer(Profile* profile, ToolbarView* toolbar);
   virtual ~BrowserActionsContainer();
 
   static void RegisterUserPrefs(PrefService* prefs);
 
   // Get the number of browser actions being displayed.
   int num_browser_actions() const { return browser_action_views_.size(); }
 
   // Whether we are performing resize animation on the container.
   bool animating() const { return animation_target_size_ > 0; }
 
   // Returns the chevron, if any.
   const views::View* chevron() const { return chevron_; }
 
+  // Returns the profile this container is associated with.
+  Profile* profile() const { return profile_; }
+
   // Returns the current tab's ID, or -1 if there is no current tab.
   int GetCurrentTabId() const;
 
   // Get a particular browser action view.
   BrowserActionView* GetBrowserActionViewAt(int index) {
     return browser_action_views_[index];
   }
 
   // Retrieve the BrowserActionView for |extension|.
   BrowserActionView* GetBrowserActionView(Extension* extension);
 
   // Update the views to reflect the state of the browser action icons.
   void RefreshBrowserActionViews();
 
   // Sets up the browser action view vector.
   void CreateBrowserActionViews();
 
   // Delete all browser action views.
   void DeleteBrowserActionViews();
 
   // Called when a browser action becomes visible/hidden.
   void OnBrowserActionVisibilityChanged();
 
+  // Returns how many browser actions are visible.
+  size_t VisibleBrowserActions() const;
+
   // Called when the user clicks on the browser action icon.
   void OnBrowserActionExecuted(BrowserActionButton* button);
 
   // Overridden from views::View:
   virtual gfx::Size GetPreferredSize();
   virtual void Layout();
   virtual void Paint(gfx::Canvas* canvas);
   virtual void ViewHierarchyChanged(bool is_add,
                                     views::View* parent,
                                     views::View* child);
@@ skipping 33 matching lines @@
                             int x,
                             int y);
 
   // Overridden from ResizeGripper::ResizeGripperDelegate:
   virtual void OnResize(int resize_amount, bool done_resizing);
 
   // Overridden from AnimationDelegate:
   virtual void AnimationProgressed(const Animation* animation);
   virtual void AnimationEnded(const Animation* animation);
 
+  // Overridden from BrowserActionOverflowMenuController::Observer:
+  virtual void NotifyMenuDeleted(
+      BrowserActionOverflowMenuController* controller);
+
+  // Moves a browser action with |id| to |new_index|.
+  void MoveBrowserAction(const std::string& extension_id, size_t new_index);
+
   // Hide the current popup.
   void HidePopup();
 
   // Simulate a click on a browser action button.  This should only be
   // used by unit tests.
   void TestExecuteBrowserAction(int index);
 
   // Retrieve the current popup.  This should only be used by unit tests.
   ExtensionPopup* TestGetPopup() { return popup_; }
 
  private:
   // ExtensionToolbarModel::Observer implementation.
   virtual void BrowserActionAdded(Extension* extension, int index);
   virtual void BrowserActionRemoved(Extension* extension);
   virtual void BrowserActionMoved(Extension* extension, int index);
 
   // Closes the overflow menu if open.
   void CloseOverflowMenu();
 
+  // Cancels the timer for showing the drop down menu.
+  void StopShowFolderDropMenuTimer();
+
+  // Show the drop down folder after a slight delay.
+  void StartShowFolderDropMenuTimer();
+
+  // Show the overflow menu.
+  void ShowDropFolder();
+
+  // Sets the drop indicator position (and schedules paint if the position has
+  // changed).
+  void SetDropIndicator(int x_pos);

[sky, 2010/02/04 20:58:49]

x_pos is mildly confusing here as it isn't the x-coordinate you're passing in,
which x_pos sounds like. I think position would be clearer. But if you disagree,
leave what you have.

+
   // Takes a width in pixels, calculates how many icons fit within that space
   // (up to the maximum number of icons in our vector) and shaves off the
   // excess pixels. |allow_shrink_to_minimum| specifies whether this function
   // clamps the size down further (down to ContainerMinSize()) if there is not
   // room for even one icon. When determining how large the container should be
   // this should be |true|. When determining where to place items, such as the
   // drop indicator, this should be |false|.
   int ClampToNearestIconCount(int pixels, bool allow_shrink_to_minimum) const;
 
   // Calculates the width of the container area NOT used to show the icons (the
   // controls to the left and to the right of the icons).
   int WidthOfNonIconArea() const;
 
   // Given a number of |icons| return the amount of pixels needed to draw it,
   // including the controls (chevron if visible and resize gripper).
   int IconCountToWidth(int icons) const;
 
   // Returns the absolute minimum size you can shrink the container down to and
   // still show it. We account for the chevron and the resize gripper, but not
   // all the padding that we normally show if there are icons.
   int ContainerMinSize() const;
 
-  // Returns how many browser actions are visible.
-  size_t VisibleBrowserActions() const;
-
   // The vector of browser actions (icons/image buttons for each action).
   std::vector<BrowserActionView*> browser_action_views_;
 
   NotificationRegistrar registrar_;
 
   Profile* profile_;
 
   // The toolbar that owns us.
   ToolbarView* toolbar_;
 
   // The current popup and the button it came from.  NULL if no popup.
   ExtensionPopup* popup_;
 
   // The button that triggered the current popup (just a reference to a button
   // from browser_action_views_).
   BrowserActionButton* popup_button_;
 
   // The model that tracks the order of the toolbar icons.
   ExtensionToolbarModel* model_;
 
   // The current size of the container.
   gfx::Size container_size_;
 
   // The resize gripper for the container.
   views::ResizeGripper* resize_gripper_;
 
   // The chevron for accessing the overflow items.
   views::MenuButton* chevron_;
 
-  // The menu to show for the overflow button (chevron).
-  scoped_ptr<BrowserActionOverflowMenuController> overflow_menu_;
+  // The menu to show for the overflow button (chevron). This class manages its
+  // own lifetime so that it can stay alive during drag and drop operations.
+  BrowserActionOverflowMenuController* overflow_menu_;
 
   // The animation that happens when the container snaps to place.
   scoped_ptr<SlideAnimation> resize_animation_;
 
   // Don't show the chevron while animating.
   bool suppress_chevron_;
 
   // This is used while the user is resizing (and when the animations are in
   // progress) to know how wide the delta is between the current state and what
   // we should draw.
   int resize_amount_;
 
   // Keeps track of the absolute pixel width the container should have when we
   // are done animating.
   int animation_target_size_;
 
   // The x position for where to draw the drop indicator. -1 if no indicator.
   int drop_indicator_position_;
 
   ScopedRunnableMethodFactory<BrowserActionsContainer> task_factory_;
 
+  // Handles delayed showing of the overflow menu when hovering.
+  ScopedRunnableMethodFactory<BrowserActionsContainer> show_menu_task_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(BrowserActionsContainer);
 };
 
 #endif  // CHROME_BROWSER_VIEWS_BROWSER_ACTIONS_CONTAINER_H_