Browser actions container layout changes for M6 theme.

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_
 #pragma once
 
 #include <set>
 #include <string>
@@ skipping 158 matching lines @@
   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:
-//
-//    r _ Icon _ Icon _ Icon _ [chevron] _ | _
-//    -----------------------------------------
-//    1 2   3  4                   5     6 7 8
-//
-// 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 container is placed flush against the omnibox and wrench menu, and its
+// layout looks like:
+//   rI_I_IcCs
+// Where the letters are as follows:
+//   r: An invisible resize area.  This is ToolbarView::kStandardSpacing pixels
+//      wide and directly adjacent to the omnibox.
+//   I: An icon.  This is as wide as the IDR_BROWSER_ACTION image.
+//   _: kItemSpacing pixels of empty space.
+//   c: kChevronSpacing pixels of empty space.  Only present if C is present.
+//   C: An optional chevron, visible for overflow.  As wide as the
+//      IDR_BROWSER_ACTIONS_OVERFLOW image.
+//   s: ToolbarView::kStandardSpacing pixels of empty space (before the wrench
+//      menu).
+// The reason the container contains the trailing space "s", rather than having
+// it be handled by the parent view, is so that when the chevron is invisible
+// and the user starts dragging an icon around, we have the space to draw the
+// ultimate drop indicator.  (Otherwise, we'd be trying to draw it into the
+// padding beyond our right edge, and it wouldn't appear.)
 //
 // 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
 // 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.
@@ skipping 45 matching lines @@
       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);
 
+  void Init();
+
   // 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.
@@ skipping 40 matching lines @@
                                     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);
+  virtual void OnThemeChanged();
   virtual bool GetAccessibleRole(AccessibilityTypes::Role* role);
 
   // Overridden from views::ViewMenuDelegate:
   virtual void RunMenu(View* source, const gfx::Point& pt);
 
   // 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);
@@ skipping 34 matching lines @@
   // Set how many icons the container should show. This should only be used by
   // unit tests.
   void TestSetIconVisibilityCount(size_t icons);
 
   // During testing we can disable animations by setting this flag to true,
   // so that the bar resizes instantly, instead of having to poll it while it
   // animates to open/closed status.
   static bool disable_animations_during_testing_;
 
  private:
+  friend class BrowserActionView;  // So it can access IconHeight().
   friend class ShowFolderMenuTask;
 
   typedef std::vector<BrowserActionView*> BrowserActionViews;
 
+  // Returns the width of an icon, optionally with its padding.
+  static int IconWidth(bool include_padding);
+
+  // Returns the height of an icon.
+  static int IconHeight();
+
   // ExtensionToolbarModel::Observer implementation.
   virtual void BrowserActionAdded(Extension* extension, int index);
   virtual void BrowserActionRemoved(Extension* extension);
   virtual void BrowserActionMoved(Extension* extension, int index);
   virtual void ModelLoaded();
 
+  void LoadImages();
+
   // Sets the initial container width.
   void SetContainerWidth();
 
   // 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);
 
-  // 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;
+  // Given a number of |icons| and whether to |display_chevron|, returns the
+  // amount of pixels needed to draw the entire container.  For convenience,
+  // callers can set |icons| to -1 to mean "all icons".
+  int IconCountToWidth(int icons, bool display_chevron) 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 area).
-  int IconCountToWidth(int icons) const;
+  // Given a pixel width, returns the number of icons that fit, assuming we need
+  // to show a chevron.
+  int WidthToIconCount(int pixels) 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.
+  // still show it.  This assumes a visible chevron because the only way we
+  // would not have a chevron when shrinking down this far is if there were no
+  // icons, in which case the container wouldn't be shown at all.
   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);
 
   // Returns true if this extension should be shown in this toolbar. This can
   // return false if we are in an incognito window and the extension is disabled
   // for incognito.
   bool ShouldDisplayBrowserAction(Extension* extension);
@@ skipping 54 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_