Make the resize gripper invisible....

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 "app/slide_animation.h"
 #include "base/task.h"
 #include "chrome/browser/extensions/extension_context_menu_model.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_popup.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/controls/resize_area.h"
 #include "views/view.h"
 
 class Browser;
 class BrowserActionsContainer;
 class BrowserActionOverflowMenuController;
 class BrowserActionsContainer;
 class Extension;
 class ExtensionAction;
 class ExtensionPopup;
 class PrefService;
@@ skipping 140 matching lines @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // 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:
 //
-//    || _ Icon _ Icon _ Icon _ [chevron] _ | _
+//    r _ Icon _ Icon _ Icon _ [chevron] _ | _
 //    -----------------------------------------
-//     1 2   3  4                   5     6 7 8
+//    1 2   3  4                   5     6 7 8
 //
-// 1) The ResizeGripper view.
+// 1) An invisible resize area.
 // 2) Padding  (kHorizontalPadding).
 // 3) The browser action icon button (BrowserActionView).
 // 4) Padding to visually separate icons from one another
 //    (kBrowserActionButtonPadding). Not included if only one icon visible.
 // 5) The chevron menu (MenuButton), shown when there is not enough room to show
 //    all the icons.
 // 6) Padding  (kDividerHorizontalMargin).
 // 7) A thin vertical divider drawn during Paint to create visual separation for
 //    the container from the Page and Wrench menus.
 // 8) Padding  (kChevronRightMargin).
 //
 // The BrowserActionsContainer follows a few rules, in terms of user experience:
 //
 // 1) The container can never grow beyond the space needed to show all icons
 // (hereby referred to as the max width).
 // 2) The container can never shrink below the space needed to show just the
-// resize gripper and the chevron (ignoring the case where there are no icons to
-// show, in which case the container won't be visible anyway).
+// initial padding and the chevron (ignoring the case where there are no icons
+// to show, in which case the container won't be visible anyway).
 // 3) The container snaps into place (to the pixel count that fits the visible
 // icons) to make sure there is no wasted space at the edges of the container.
 // 4) If the user adds or removes icons (read: installs/uninstalls browser
 // actions) we grow and shrink the container as needed - but ONLY if the
 // container was at max width to begin with.
 // 5) If the container is NOT at max width (has an overflow menu), we respect
 // that size when adding and removing icons and DON'T grow/shrink the container.
 // This means that new icons (which always appear at the far right) will show up
 // in the overflow menu. The install bubble for extensions points to the chevron
 // menu in this case.
 //
 // Resizing the BrowserActionsContainer:
 //
-// The ResizeGripper view sends OnResize messages to the BrowserActionsContainer
-// class as the user drags the gripper. This modifies the value for
-// |resize_amount_|. That indicates to the container that a resize is in
-// progress and is used to calculate the size in GetPreferredSize(), though
-// that function never exceeds the defined minimum and maximum size of the
-// container.
+// The ResizeArea view sends OnResize messages to the BrowserActionsContainer
+// class as the user drags it. This modifies the value for |resize_amount_|.
+// That indicates to the container that a resize is in progress and is used to
+// calculate the size in GetPreferredSize(), though that function never exceeds
+// the defined minimum and maximum size of the container.
 //
 // When the user releases the mouse (ends the resize), we calculate a target
 // size for the container (animation_target_size_), clamp that value to the
 // containers min and max and then animate from the *current* position (that the
 // user has dragged the view to) to the target size.
 //
 // Animating the BrowserActionsContainer:
 //
 // Animations are used when snapping the container to a value that fits all
 // visible icons. This can be triggered when the user finishes resizing the
 // container or when Browser Actions are added/removed.
 //
 // We always animate from the current width (container_size_.width()) to the
 // target size (animation_target_size_), using |resize_amount| to keep track of
 // the animation progress.
 //
 // NOTE: When adding Browser Actions to a maximum width container (no overflow)
 // we make sure to suppress the chevron menu if it wasn't visible. This is
 // 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 views::ViewMenuDelegate,
     public views::DragController,
-    public views::ResizeGripper::ResizeGripperDelegate,
+    public views::ResizeArea::ResizeAreaDelegate,
     public AnimationDelegate,
     public ExtensionToolbarModel::Observer,
     public BrowserActionOverflowMenuController::Observer,
     public ExtensionContextMenuModel::PopupDelegate,
     public ExtensionPopup::Observer {
  public:
   BrowserActionsContainer(Browser* browser, views::View* owner_view);
   virtual ~BrowserActionsContainer();
 
   static void RegisterUserPrefs(PrefService* prefs);
@@ skipping 65 matching lines @@
 
   // Overridden from views::DragController:
   virtual void WriteDragData(View* sender,
                              const gfx::Point& press_pt,
                              OSExchangeData* data);
   virtual int GetDragOperations(View* sender, const gfx::Point& p);
   virtual bool CanStartDrag(View* sender,
                             const gfx::Point& press_pt,
                             const gfx::Point& p);
 
-  // Overridden from ResizeGripper::ResizeGripperDelegate:
+  // Overridden from ResizeArea::ResizeAreaDelegate:
   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);
 
@@ skipping 62 matching lines @@
   // 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).
+  // including the controls (chevron if visible and resize area).
   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;
 
   // Animate to the target value (unless testing, in which case we go straight
   // to the target size).
   void Animate(Tween::Type type, int target_size);
@@ skipping 22 matching lines @@
   // 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 resize area for the container.
+  views::ResizeArea* resize_area_;
 
   // The chevron for accessing the overflow items.
   views::MenuButton* chevron_;
 
   // 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_;
@@ skipping 15 matching lines @@
 
   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_