Toolbar layout changes for M6 theme.

chrome/browser/views/toolbar_view.cc

 // 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.
 
 #include "chrome/browser/views/toolbar_view.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser.h"
@@ skipping 15 matching lines @@
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "gfx/skbitmap_operations.h"
 #include "grit/theme_resources.h"
 #include "views/controls/button/button_dropdown.h"
 #include "views/focus/view_storage.h"
 #include "views/widget/tooltip_manager.h"
 #include "views/window/non_client_view.h"
 #include "views/window/window.h"
 
-static const int kControlHorizOffset = 4;
-static const int kControlVertOffset = 6;
-static const int kControlIndent = 3;
+// The space between items is 4 px in general.
+const int ToolbarView::kStandardSpacing = 4;
+// The top of the toolbar has an edge we have to skip over in addition to the 4
+// px of spacing.
+const int ToolbarView::kVertSpacing = kStandardSpacing + 1;
+// The edge graphics have some built-in spacing/shadowing, so we have to adjust
+// our spacing to make it still appear to be 4 px.
+static const int kEdgeSpacing = ToolbarView::kStandardSpacing - 1;
+// The buttons to the left of the omnibox are close together.
+static const int kButtonSpacing = 1;
+
 static const int kStatusBubbleWidth = 480;
 
 // The length of time to run the upgrade notification animation (the time it
 // takes one pulse to run its course and go back to its original brightness).
 static const int kPulseDuration = 2000;
 
 // How long to wait between pulsating the upgrade notifier.
 static const int kPulsateEveryMs = 8000;
 
-// The offset in pixels of the upgrade dot on the app menu.
-static const int kUpgradeDotOffset = 11;
-
-// Separation between the location bar and the menus.
-static const int kMenuButtonOffset = 3;
-
-// Padding to the right of the location bar
-static const int kPaddingRight = 2;
-
 static const int kPopupTopSpacingNonGlass = 3;
 static const int kPopupBottomSpacingNonGlass = 2;
 static const int kPopupBottomSpacingGlass = 1;
 
 static SkBitmap* kPopupBackgroundEdge = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, public:
 
 ToolbarView::ToolbarView(Browser* browser)
@@ skipping 81 matching lines @@
   home_->set_triggerable_event_flags(views::Event::EF_LEFT_BUTTON_DOWN |
                                      views::Event::EF_MIDDLE_BUTTON_DOWN);
   home_->set_tag(IDC_HOME);
   home_->SetTooltipText(l10n_util::GetString(IDS_TOOLTIP_HOME));
   home_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_HOME));
   home_->SetID(VIEW_ID_HOME_BUTTON);
 
   browser_actions_ = new BrowserActionsContainer(browser_, this);
 
   app_menu_ = new views::MenuButton(NULL, std::wstring(), this, false);
+  app_menu_->set_border(NULL);
   app_menu_->EnableCanvasFlippingForRTLUI(true);
   app_menu_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_APP));
   app_menu_->SetTooltipText(l10n_util::GetStringF(IDS_APPMENU_TOOLTIP,
       l10n_util::GetString(IDS_PRODUCT_NAME)));
   app_menu_->SetID(VIEW_ID_APP_MENU);
 
   // Catch the case where the window is created after we detect a new version.
   if (Singleton<UpgradeDetector>::get()->notify_upgrade())
     ShowUpgradeReminder();
 
@@ skipping 106 matching lines @@
   DCHECK(model_->input_in_progress() != in_progress);
 
   model_->set_input_in_progress(in_progress);
   location_bar_->Update(NULL);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, AnimationDelegate implementation:
 
 void ToolbarView::AnimationProgressed(const Animation* animation) {
-  app_menu_->SetIcon(GetAppMenuIcon());
+  app_menu_->SetIcon(GetAppMenuIcon(views::CustomButton::BS_NORMAL));
+  app_menu_->SetHoverIcon(GetAppMenuIcon(views::CustomButton::BS_HOT));
+  app_menu_->SetPushedIcon(GetAppMenuIcon(views::CustomButton::BS_PUSHED));
   SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, CommandUpdater::CommandObserver implementation:
 
 void ToolbarView::EnabledStateChangedForCommand(int id, bool enabled) {
   views::Button* button = NULL;
   switch (id) {
     case IDC_BACK:
@@ skipping 84 matching lines @@
 
 void ToolbarView::ExecuteCommand(int command_id) {
   browser_->ExecuteCommand(command_id);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, views::View overrides:
 
 gfx::Size ToolbarView::GetPreferredSize() {
   if (IsDisplayModeNormal()) {
-    int min_width = kControlIndent + back_->GetPreferredSize().width() +
-        forward_->GetPreferredSize().width() + kControlHorizOffset +
-        reload_->GetPreferredSize().width() + kControlHorizOffset +
+    int min_width = kEdgeSpacing +
+        back_->GetPreferredSize().width() + kButtonSpacing +
+        forward_->GetPreferredSize().width() + kButtonSpacing +
+        reload_->GetPreferredSize().width() + kStandardSpacing +
         (show_home_button_.GetValue() ?
-            (home_->GetPreferredSize().width() + kControlHorizOffset) : 0) +
+            (home_->GetPreferredSize().width() + kButtonSpacing) : 0) +
         browser_actions_->GetPreferredSize().width() +
-        kMenuButtonOffset +
-        app_menu_->GetPreferredSize().width() + kPaddingRight;
+        app_menu_->GetPreferredSize().width() + kEdgeSpacing;
 
     static SkBitmap normal_background;
     if (normal_background.isNull()) {
       ResourceBundle& rb = ResourceBundle::GetSharedInstance();
       normal_background = *rb.GetBitmapNamed(IDR_CONTENT_TOP_CENTER);
     }
 
     return gfx::Size(min_width, normal_background.height());
   }
 
@@ skipping 10 matching lines @@
     return;
 
   if (!IsDisplayModeNormal()) {
     int edge_width = (browser_->window() && browser_->window()->IsMaximized()) ?
         0 : kPopupBackgroundEdge->width();  // See Paint().
     location_bar_->SetBounds(edge_width, PopupTopSpacing(),
         width() - (edge_width * 2), location_bar_->GetPreferredSize().height());
     return;
   }
 
-  int child_y = std::min(kControlVertOffset, height());
+  int child_y = std::min(kVertSpacing, height());
   // We assume all child elements are the same height.
   int child_height =
       std::min(back_->GetPreferredSize().height(), height() - child_y);
 
   // If the window is maximized, we extend the back button to the left so that
   // clicking on the left-most pixel will activate the back button.
   // TODO(abarth):  If the window becomes maximized but is not resized,
   //                then Layout() might not be called and the back button
   //                will be slightly the wrong size.  We should force a
   //                Layout() in this case.
   //                http://crbug.com/5540
   int back_width = back_->GetPreferredSize().width();
   if (browser_->window() && browser_->window()->IsMaximized())
-    back_->SetBounds(0, child_y, back_width + kControlIndent, child_height);
+    back_->SetBounds(0, child_y, back_width + kEdgeSpacing, child_height);
   else
-    back_->SetBounds(kControlIndent, child_y, back_width, child_height);
+    back_->SetBounds(kEdgeSpacing, child_y, back_width, child_height);
 
-  forward_->SetBounds(back_->x() + back_->width(), child_y,
-                      forward_->GetPreferredSize().width(), child_height);
+  forward_->SetBounds(back_->x() + back_->width() + kButtonSpacing,
+      child_y, forward_->GetPreferredSize().width(), child_height);
 
-  reload_->SetBounds(forward_->x() + forward_->width() + kControlHorizOffset,
+  reload_->SetBounds(forward_->x() + forward_->width() + kButtonSpacing,
       child_y, reload_->GetPreferredSize().width(), child_height);
 
   if (show_home_button_.GetValue()) {
     home_->SetVisible(true);
-    home_->SetBounds(reload_->x() + reload_->width() + kControlHorizOffset,
-                     child_y, home_->GetPreferredSize().width(), child_height);
+    home_->SetBounds(reload_->x() + reload_->width() + kButtonSpacing, child_y,
+                     home_->GetPreferredSize().width(), child_height);
   } else {
     home_->SetVisible(false);
     home_->SetBounds(reload_->x() + reload_->width(), child_y, 0, child_height);
   }
 
   int browser_actions_width = browser_actions_->GetPreferredSize().width();
   int app_menu_width = app_menu_->GetPreferredSize().width();
-  int location_x = home_->x() + home_->width() + kControlHorizOffset;
-  int available_width = width() - kPaddingRight - app_menu_width -
-      browser_actions_width - kMenuButtonOffset - location_x;
+  int location_x = home_->x() + home_->width() + kStandardSpacing;
+  int available_width = width() - kEdgeSpacing - app_menu_width -
+      browser_actions_width - location_x;
 
   location_bar_->SetBounds(location_x, child_y, std::max(available_width, 0),
                            child_height);
-  int next_menu_x =
-      location_bar_->x() + location_bar_->width() + kMenuButtonOffset;
 
-  browser_actions_->SetBounds(next_menu_x, 0, browser_actions_width, height());
+  browser_actions_->SetBounds(location_bar_->x() + location_bar_->width(), 0,
+                              browser_actions_width, height());
   // The browser actions need to do a layout explicitly, because when an
   // extension is loaded/unloaded/changed, BrowserActionContainer removes and
   // re-adds everything, regardless of whether it has a page action. For a
   // page action, browser action bounds do not change, as a result of which
   // SetBounds does not do a layout at all.
   // TODO(sidchat): Rework the above behavior so that explicit layout is not
   //                required.
   browser_actions_->Layout();
-  next_menu_x += browser_actions_width;
 
-  app_menu_->SetBounds(next_menu_x, child_y, app_menu_width, child_height);
+  app_menu_->SetBounds(browser_actions_->x() + browser_actions_width, child_y,
+                       app_menu_width, child_height);
 }
 
 void ToolbarView::Paint(gfx::Canvas* canvas) {
   View::Paint(canvas);
 
   if (IsDisplayModeNormal())
     return;
 
   // In maximized mode, we don't draw the endcaps on the location bar, because
   // when they're flush against the edge of the screen they just look glitchy.
@@ skipping 67 matching lines @@
   reload_->SetToggledImage(views::CustomButton::BS_HOT,
       tp->GetBitmapNamed(IDR_STOP_H));
   reload_->SetToggledImage(views::CustomButton::BS_PUSHED,
       tp->GetBitmapNamed(IDR_STOP_P));
 
   home_->SetImage(views::CustomButton::BS_NORMAL, tp->GetBitmapNamed(IDR_HOME));
   home_->SetImage(views::CustomButton::BS_HOT, tp->GetBitmapNamed(IDR_HOME_H));
   home_->SetImage(views::CustomButton::BS_PUSHED,
       tp->GetBitmapNamed(IDR_HOME_P));
 
-  app_menu_->SetIcon(GetAppMenuIcon());
+  app_menu_->SetIcon(GetAppMenuIcon(views::CustomButton::BS_NORMAL));
+  app_menu_->SetHoverIcon(GetAppMenuIcon(views::CustomButton::BS_HOT));
+  app_menu_->SetPushedIcon(GetAppMenuIcon(views::CustomButton::BS_PUSHED));
 }
 
 void ToolbarView::ShowUpgradeReminder() {
   update_reminder_animation_.reset(new SlideAnimation(this));
   update_reminder_animation_->SetSlideDuration(kPulseDuration);
 
   // Then start the recurring timer for pulsating it.
   upgrade_reminder_pulse_timer_.Start(
       base::TimeDelta::FromMilliseconds(kPulsateEveryMs),
       this, &ToolbarView::PulsateUpgradeNotifier);
 }
 
 void ToolbarView::PulsateUpgradeNotifier() {
   // Start the pulsating animation.
   update_reminder_animation_->Reset(0.0);
   update_reminder_animation_->Show();
 }
 
-SkBitmap ToolbarView::GetAppMenuIcon() {
+SkBitmap ToolbarView::GetAppMenuIcon(views::CustomButton::ButtonState state) {
   ThemeProvider* tp = GetThemeProvider();
 
-  SkBitmap icon = *tp->GetBitmapNamed(IDR_TOOLS);
+  int id = 0;
+  switch (state) {
+    case views::CustomButton::BS_NORMAL: id = IDR_TOOLS;   break;
+    case views::CustomButton::BS_HOT:    id = IDR_TOOLS_H; break;
+    case views::CustomButton::BS_PUSHED: id = IDR_TOOLS_P; break;
+    default:                             NOTREACHED();     break;
+  }
+  SkBitmap icon = *tp->GetBitmapNamed(id);
 
   if (!Singleton<UpgradeDetector>::get()->notify_upgrade())
     return icon;
 
   // Draw the chrome app menu icon onto the canvas.
   scoped_ptr<gfx::CanvasSkia> canvas(
       new gfx::CanvasSkia(icon.width(), icon.height(), false));
   canvas->DrawBitmapInt(icon, 0, 0);
 
   SkBitmap badge;
@@ skipping 15 matching lines @@
     double value =
         1.0 - abs(2.0 * update_reminder_animation_->GetCurrentValue() - 1.0);
 
     // Add the badge to it.
     badge = SkBitmapOperations::CreateBlendedBitmap(
         *tp->GetBitmapNamed(IDR_UPGRADE_DOT_INACTIVE),
         *tp->GetBitmapNamed(IDR_UPGRADE_DOT_ACTIVE),
         value);
   }
 
-  canvas->DrawBitmapInt(badge, kUpgradeDotOffset,
-                        icon.height() - badge.height());
+  static const int kBadgeLeftSpacing = 8;
+  static const int kBadgeTopSpacing = 18;
+  canvas->DrawBitmapInt(badge, kBadgeLeftSpacing, kBadgeTopSpacing);
 
   return canvas->ExtractBitmap();
 }