Support reordering of Browser Actions within the container. Currently does no...

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 <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/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;
-class BrowserActionOverflowMenuController;
 class Extension;
 class ExtensionAction;
 class ExtensionPopup;
 class PrefService;
 class Profile;
 class SlideAnimation;
 class ToolbarView;
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserActionButton
 
 // The BrowserActionButton is a specialization of the MenuButton class.
 // It acts on a ExtensionAction, in this case a BrowserAction and handles
 // loading the image for the button asynchronously on the file thread.
 class BrowserActionButton : public views::MenuButton,
                             public views::ButtonListener,
                             public ImageLoadingTracker::Observer,
                             public NotificationObserver {
  public:
   BrowserActionButton(Extension* extension, BrowserActionsContainer* panel);
   ~BrowserActionButton();
 
   ExtensionAction* browser_action() const { return browser_action_; }
   Extension* extension() { return extension_; }
 
   // Called to update the display to match the browser action's state.
   void UpdateState();
 
+  // Returns the default icon, if any.
+  const SkBitmap& default_icon() const { return default_icon_; }
+
   // Overridden from views::View. Return a 0-inset so the icon can draw all the
   // way to the edge of the view if it wants.
   virtual gfx::Insets GetInsets() const;
 
   // Overridden from views::ButtonListener:
   virtual void ButtonPressed(views::Button* sender, const views::Event& event);
 
   // Overridden from ImageLoadingTracker.
   virtual void OnImageLoaded(SkBitmap* image, size_t index);
 
@@ skipping 68 matching lines @@
   virtual void Layout();
 
   // Override PaintChildren so that we can paint the badge on top of children.
   virtual void PaintChildren(gfx::Canvas* canvas);
 
   // The container for this view.
   BrowserActionsContainer* panel_;
 
   // The button this view contains.
   BrowserActionButton* button_;
+
+  DISALLOW_COPY_AND_ASSIGN(BrowserActionView);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // The BrowserActionsContainer is a container view, responsible for drawing the
 // browser action icons (extensions that add icons to the toolbar).
 //
 // The BrowserActionsContainer (when it contains one or more icons) consists of
 // the following elements, numbered as seen below the line:
 //
@@ skipping 60 matching lines @@
 // because we won't have enough space to show the new Browser Action until the
 // animation ends and we don't want the chevron to flash into view while we are
 // growing the container.
 //
 ////////////////////////////////////////////////////////////////////////////////
 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:
   BrowserActionsContainer(Profile* profile, ToolbarView* toolbar);
   virtual ~BrowserActionsContainer();
 
   static void RegisterUserPrefs(PrefService* prefs);
 
   // Get the number of browser actions being displayed.
@@ skipping 12 matching lines @@
   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();
 
   // 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);
+  virtual bool GetDropFormats(
+      int* formats, std::set<OSExchangeData::CustomFormat>* custom_formats);
+  virtual bool AreDropTypesRequired();
+  virtual bool CanDrop(const OSExchangeData& data);
+  virtual void OnDragEntered(const views::DropTargetEvent& event);
+  virtual int OnDragUpdated(const views::DropTargetEvent& event);
+  virtual void OnDragExited();
+  virtual int OnPerformDrop(const views::DropTargetEvent& event);
 
   // Overridden from NotificationObserver:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // BrowserBubble::Delegate methods.
   virtual void BubbleBrowserWindowMoved(BrowserBubble* bubble);
   virtual void BubbleBrowserWindowClosing(BrowserBubble* bubble);
   virtual void BubbleGotFocus(BrowserBubble* bubble);
   virtual void BubbleLostFocus(BrowserBubble* bubble,
                                gfx::NativeView focused_view);
 
   // Overridden from views::ViewMenuDelegate:
   virtual void RunMenu(View* source, const gfx::Point& pt);
 
+  // Overridden from views::DragController:
+  virtual void WriteDragData(View* sender,
+                             int press_x,
+                             int press_y,
+                             OSExchangeData* data);
+  virtual int GetDragOperations(View* sender, int x, int y);
+  virtual bool CanStartDrag(View* sender,
+                            int press_x,
+                            int press_y,
+                            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);
 
   // 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();
 
   // 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.
-  int ClampToNearestIconCount(int pixels) const;
+  // 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
@@ skipping 44 matching lines @@
 
   // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserActionsContainer);
 };
 
 #endif  // CHROME_BROWSER_VIEWS_BROWSER_ACTIONS_CONTAINER_H_