Set toolbar padding to something appropriate for Metro icons.

chrome/browser/ui/views/tabs/tab_strip.cc

 // Copyright (c) 2012 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/ui/views/tabs/tab_strip.h"
 
 #include <algorithm>
 #include <iterator>
 #include <vector>
 
@@ skipping 14 matching lines @@
 #include "chrome/browser/ui/views/tabs/tab_strip_controller.h"
 #include "chrome/browser/ui/views/tabs/touch_tab_strip_layout.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/animation/animation_container.h"
 #include "ui/base/animation/throb_animation.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/touch/touch_mode_support.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/mouse_watcher_view_host.h"
 #include "ui/views/view_model_utils.h"
 #include "ui/views/widget/default_theme_provider.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/non_client_view.h"
 
 #if defined(OS_WIN)
 #include "ui/base/win/hwnd_util.h"
 #include "ui/views/widget/monitor_win.h"
 #endif
 
 using views::DropTargetEvent;
 
-// Offset for the new tab button to bring it closer to the rightmost tab.
-#if defined(USE_ASH)
-static const int kNewTabButtonHOffset = -11;
-static const int kNewTabButtonVOffset = 7;
-#else
-static const int kNewTabButtonHOffset = -5;
-static const int kNewTabButtonVOffset = 5;
-#endif
-// Amount the left edge of a tab is offset from the rectangle of the tab's
-// favicon/title/close box.  Related to the width of IDR_TAB_ACTIVE_LEFT.
-#if defined(USE_ASH)
-static const int kTabHOffset = -27;
-#else
-static const int kTabHOffset = -16;
-#endif
+namespace {
+
 static const int kTabStripAnimationVSlop = 40;
 // Inactive tabs in a native frame are slightly transparent.
 static const int kNativeFrameInactiveTabAlpha = 200;
 // If there are multiple tabs selected then make non-selected inactive tabs
 // even more transparent.
 static const int kNativeFrameInactiveTabAlphaMultiSelection = 150;
 
 // Inverse ratio of the width of a tab edge to the width of the tab. When
 // hovering over the left or right edge of a tab, the drop indicator will
 // point between tabs.
 static const int kTabEdgeRatioInverse = 4;
 
 // Size of the drop indicator.
 static int drop_indicator_width;
 static int drop_indicator_height;
 
 static inline int Round(double x) {
   // Why oh why is this not in a standard header?
   return static_cast<int>(floor(x + 0.5));
 }
 
 // Max number of stacked tabs.
 static const int kMaxStackedCount = 4;
 
 // Padding between stacked tabs.
 static const int kStackedPadding = 6;
 
-namespace {
+// Horizontal offset for the new tab button to bring it closer to the
+// rightmost tab.
+const int GetNewTabButtonHOffset() {
+  static int value = -1;
+  if (value == -1) {
+    switch (ui::GetDisplayLayout()) {
+      case ui::LAYOUT_ASH:
+        value = -11;
+        break;
+      case ui::LAYOUT_TOUCH:
+        value = -6;
+        break;
+      default:
+        value = -5;
+    }
+  }
+  return value;
+}
+
+// Vertical offset for the new tab button to bring it closer to the
+// rightmost tab.
+const int GetNewTabButtonVOffset() {
+  static int value = -1;
+  if (value == -1) {
+    switch (ui::GetDisplayLayout()) {
+      case ui::LAYOUT_ASH:
+        value = 7;
+        break;
+      case ui::LAYOUT_TOUCH:
+        value = 10;
+        break;
+      default:
+        value = 5;
+    }
+  }
+  return value;
+}
+
+// Amount the left edge of a tab is offset from the rectangle of the tab's
+// favicon/title/close box.  Related to the width of IDR_TAB_ACTIVE_LEFT.
+const int GetTabHOffset() {
+  static int value = -1;
+  if (value == -1) {
+    switch (ui::GetDisplayLayout()) {
+      case ui::LAYOUT_ASH:
+        value = -27;
+        break;
+      case ui::LAYOUT_TOUCH:
+        value = -16;
+        break;
+      default:
+        value = -16;
+    }
+  }
+  return value;
+}
 
 // Animation delegate used when a dragged tab is released. When done sets the
 // dragging state to false.
 class ResetDraggingStateDelegate
     : public views::BoundsAnimator::OwnedAnimationDelegate {
  public:
   explicit ResetDraggingStateDelegate(BaseTab* tab) : tab_(tab) {
   }
 
   virtual void AnimationEnded(const ui::Animation* animation) {
@@ skipping 139 matching lines @@
   int height = mask->height();
   int width = mask->width();
   gfx::Canvas canvas(gfx::Size(width, height), false);
 
   // For custom images the background starts at the top of the tab strip.
   // Otherwise the background starts at the top of the frame.
   SkBitmap* background = GetThemeProvider()->GetBitmapNamed(background_id);
   int offset_y = GetThemeProvider()->HasCustomImage(background_id) ?
       0 : background_offset_.y();
   canvas.TileImageInt(*background, GetMirroredX() + background_offset_.x(),
-                      kNewTabButtonVOffset + offset_y, 0, 0, width, height);
+                      GetNewTabButtonVOffset() + offset_y, 0, 0, width, height);
 
   if (alpha != 255) {
     SkPaint paint;
     paint.setColor(SkColorSetARGB(alpha, 255, 255, 255));
     paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
     paint.setStyle(SkPaint::kFill_Style);
     canvas.DrawRect(gfx::Rect(0, 0, width, height), paint);
   }
 
   // White highlight on hover.
@@ skipping 255 matching lines @@
 
   int model_count = GetModelCount();
   if (model_index + 1 != model_count && model_count > 1) {
     // The user is about to close a tab other than the last tab. Set
     // available_width_for_tabs_ so that if we do a layout we don't position a
     // tab past the end of the second to last tab. We do this so that as the
     // user closes tabs with the mouse a tab continues to fall under the mouse.
     Tab* last_tab = tab_at(model_count - 1);
     Tab* tab_being_removed = tab_at(model_index);
     available_width_for_tabs_ = last_tab->x() + last_tab->width() -
-        tab_being_removed->width() - kTabHOffset;
+        tab_being_removed->width() - GetTabHOffset();
     if (model_index == 0 && tab_being_removed->data().mini &&
         !tab_at(1)->data().mini) {
       available_width_for_tabs_ -= kMiniToNonMiniGap;
     }
   }
 
   in_tab_close_ = true;
   AddMessageLoopObserver();
 }
 
@@ skipping 408 matching lines @@
 
 std::string TabStrip::GetClassName() const {
   return kViewClassName;
 }
 
 gfx::Size TabStrip::GetPreferredSize() {
   // Report the minimum width as the size required for a single selected tab
   // plus the new tab button. Don't base it on the actual number of tabs because
   // it's undesirable to have the minimum window size change when a new tab is
   // opened.
-  int needed_width = Tab::GetMinimumSelectedSize().width() - kTabHOffset +
-      new_tab_button_width();
+  int needed_width = Tab::GetMinimumSelectedSize().width() -
+      GetTabHOffset() + new_tab_button_width();
   return gfx::Size(needed_width, Tab::GetMinimumUnselectedSize().height());
 }
 
 void TabStrip::OnDragEntered(const DropTargetEvent& event) {
   // Force animations to stop, otherwise it makes the index calculation tricky.
   StopAnimating(true);
 
   UpdateDropIndex(event);
 }
 
@@ skipping 135 matching lines @@
   AddChildView(newtab_button_);
   if (drop_indicator_width == 0) {
     // Direction doesn't matter, both images are the same size.
     SkBitmap* drop_image = GetDropArrowImage(true);
     drop_indicator_width = drop_image->width();
     drop_indicator_height = drop_image->height();
   }
   if (TouchModeSupport::IsTouchOptimized()) {
     touch_layout_.reset(new TouchTabStripLayout(
                             Tab::GetStandardSize(),
-                            kTabHOffset,
+                            GetTabHOffset(),
                             kStackedPadding,
                             kMaxStackedCount,
                             &tabs_));
   }
 }
 
 BaseTab* TabStrip::CreateTab() {
   Tab* tab = new Tab(this);
   tab->set_animation_container(animation_container_.get());
   return tab;
 }
 
 void TabStrip::StartInsertTabAnimation(int model_index) {
   PrepareForAnimation();
 
   // The TabStrip can now use its entire width to lay out Tabs.
   in_tab_close_ = false;
   available_width_for_tabs_ = -1;
 
   GenerateIdealBounds();
 
   BaseTab* tab = tab_at(model_index);
   if (model_index == 0) {
     tab->SetBounds(0, ideal_bounds(model_index).y(), 0,
                    ideal_bounds(model_index).height());
   } else {
     BaseTab* last_tab = tab_at(model_index - 1);
-    tab->SetBounds(last_tab->bounds().right() + kTabHOffset,
+    tab->SetBounds(last_tab->bounds().right() + GetTabHOffset(),
                    ideal_bounds(model_index).y(), 0,
                    ideal_bounds(model_index).height());
   }
 
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMoveTabAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
@@ skipping 69 matching lines @@
     touch_layout_->SetWidth(size().width() - new_tab_button_width());
 
   GenerateIdealBounds();
 
   views::ViewModelUtils::SetViewBoundsToIdealBounds(tabs_);
 
   SchedulePaint();
 
   if (SizeTabButtonToTopOfTabStrip()) {
     newtab_button_bounds_.set_height(
-        kNewTabButtonHeight + kNewTabButtonVOffset);
+        kNewTabButtonHeight + GetNewTabButtonVOffset());
     newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                       views::ImageButton::ALIGN_BOTTOM);
   } else {
     newtab_button_bounds_.set_height(kNewTabButtonHeight);
     newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                       views::ImageButton::ALIGN_TOP);
   }
   newtab_button_->SetBoundsRect(newtab_button_bounds_);
 }
 
@@ skipping 37 matching lines @@
 void TabStrip::CalculateBoundsForDraggedTabs(const std::vector<BaseTab*>& tabs,
                                              std::vector<gfx::Rect>* bounds) {
   int x = 0;
   for (size_t i = 0; i < tabs.size(); ++i) {
     BaseTab* tab = tabs[i];
     if (i > 0 && tab->data().mini != tabs[i - 1]->data().mini)
       x += kMiniToNonMiniGap;
     gfx::Rect new_bounds = tab->bounds();
     new_bounds.set_origin(gfx::Point(x, 0));
     bounds->push_back(new_bounds);
-    x += tab->width() + kTabHOffset;
+    x += tab->width() + GetTabHOffset();
   }
 }
 
 int TabStrip::GetSizeNeededForTabs(const std::vector<BaseTab*>& tabs) {
   int width = 0;
   for (size_t i = 0; i < tabs.size(); ++i) {
     BaseTab* tab = tabs[i];
     width += tab->width();
     if (i > 0 && tab->data().mini != tabs[i - 1]->data().mini)
       width += kMiniToNonMiniGap;
   }
   if (tabs.size() > 0)
-    width += kTabHOffset * static_cast<int>(tabs.size() - 1);
+    width += GetTabHOffset() * static_cast<int>(tabs.size() - 1);
   return width;
 }
 
 void TabStrip::RemoveTabFromViewModel(int index) {
   // We still need to paint the tab until we actually remove it. Put it
   // in tabs_closing_map_ so we can find it.
   tabs_closing_map_[index].push_back(tab_at(index));
   UpdateTabsClosingMap(index + 1, -1);
   tabs_.Remove(index);
 }
@@ skipping 139 matching lines @@
     // width here; the first preserves the consistent "leave the last tab under
     // the user's mouse so they can close many tabs" behavior at the cost of
     // prolonging the glitchy appearance of the overflow state, while the second
     // gets us out of overflow as soon as possible but forces the user to move
     // their mouse for a few tabs' worth of closing.  We choose visual
     // imperfection over behavioral imperfection and select the first option.
     available_width = available_width_for_tabs_;
   }
 
   if (mini_tab_count > 0) {
-    available_width -= mini_tab_count * (Tab::GetMiniWidth() + kTabHOffset);
+    available_width -= mini_tab_count * (Tab::GetMiniWidth() + GetTabHOffset());
     tab_count -= mini_tab_count;
     if (tab_count == 0) {
       *selected_width = *unselected_width = Tab::GetStandardSize().width();
       return;
     }
     // Account for gap between the last mini-tab and first non-mini-tab.
     available_width -= kMiniToNonMiniGap;
   }
 
   // Calculate the desired tab widths by dividing the available space into equal
   // portions.  Don't let tabs get larger than the "standard width" or smaller
   // than the minimum width for each type, respectively.
-  const int total_offset = kTabHOffset * (tab_count - 1);
+  const int total_offset = GetTabHOffset() * (tab_count - 1);
   const double desired_tab_width = std::min((static_cast<double>(
       available_width - total_offset) / static_cast<double>(tab_count)),
       static_cast<double>(Tab::GetStandardSize().width()));
   *unselected_width = std::max(desired_tab_width, min_unselected_width);
   *selected_width = std::max(desired_tab_width, min_selected_width);
 
   // When there are multiple tabs, we'll have one selected and some unselected
   // tabs.  If the desired width was between the minimum sizes of these types,
   // try to shrink the tabs with the smaller minimum.  For example, if we have
   // a strip of width 10 with 4 tabs, the desired width per tab will be 2.5.  If
@@ skipping 72 matching lines @@
 }
 
 gfx::Rect TabStrip::GetDropBounds(int drop_index,
                                   bool drop_before,
                                   bool* is_beneath) {
   DCHECK_NE(drop_index, -1);
   int center_x;
   if (drop_index < tab_count()) {
     Tab* tab = tab_at(drop_index);
     if (drop_before)
-      center_x = tab->x() - (kTabHOffset / 2);
+      center_x = tab->x() - (GetTabHOffset() / 2);
     else
       center_x = tab->x() + (tab->width() / 2);
   } else {
     Tab* last_tab = tab_at(drop_index - 1);
-    center_x = last_tab->x() + last_tab->width() + (kTabHOffset / 2);
+    center_x = last_tab->x() + last_tab->width() + (GetTabHOffset() / 2);
   }
 
   // Mirror the center point if necessary.
   center_x = GetMirroredXInView(center_x);
 
   // Determine the screen bounds.
   gfx::Point drop_loc(center_x - drop_indicator_width / 2,
                       -drop_indicator_height);
   ConvertPointToScreen(this, &drop_loc);
   gfx::Rect drop_bounds(drop_loc.x(), drop_loc.y(), drop_indicator_width,
@@ skipping 123 matching lines @@
 }
 
 void TabStrip::PrepareForAnimation() {
   if (!IsDragSessionActive() && !TabDragController::IsAttachedTo(this)) {
     for (int i = 0; i < tab_count(); ++i)
       tab_at(i)->set_dragging(false);
   }
 }
 
 void TabStrip::GenerateIdealBounds() {
-  int new_tab_y = SizeTabButtonToTopOfTabStrip() ? 0 : kNewTabButtonVOffset;
+  int new_tab_y =
+      SizeTabButtonToTopOfTabStrip() ? 0 : GetNewTabButtonVOffset();
 
   if (touch_layout_.get()) {
     if (tabs_.view_size() == 0)
       return;
 
     int new_tab_x = tabs_.ideal_bounds(tabs_.view_size() - 1).right() +
-        kNewTabButtonHOffset;
+        GetNewTabButtonHOffset();
     newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
     return;
   }
 
   double unselected, selected;
   GetDesiredTabWidths(tab_count(), GetMiniTabCount(), &unselected, &selected);
   current_unselected_width_ = unselected;
   current_selected_width_ = selected;
 
   // NOTE: This currently assumes a tab's height doesn't differ based on
   // selected state or the number of tabs in the strip!
   int tab_height = Tab::GetStandardSize().height();
   int first_non_mini_index = 0;
   double tab_x = GenerateIdealBoundsForMiniTabs(&first_non_mini_index);
   for (int i = first_non_mini_index; i < tab_count(); ++i) {
     Tab* tab = tab_at(i);
     DCHECK(!tab->data().mini);
     double tab_width = tab->IsActive() ? selected : unselected;
     double end_of_tab = tab_x + tab_width;
     int rounded_tab_x = Round(tab_x);
     set_ideal_bounds(
         i,
         gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                   tab_height));
-    tab_x = end_of_tab + kTabHOffset;
+    tab_x = end_of_tab + GetTabHOffset();
   }
 
   // Update bounds of new tab button.
   int new_tab_x;
   if (abs(Round(unselected) - Tab::GetStandardSize().width()) > 1 &&
       !in_tab_close_) {
     // We're shrinking tabs, so we need to anchor the New Tab button to the
     // right edge of the TabStrip's bounds, rather than the right edge of the
     // right-most Tab, otherwise it'll bounce when animating.
     new_tab_x = width() - newtab_button_bounds_.width();
   } else {
-    new_tab_x = Round(tab_x - kTabHOffset) + kNewTabButtonHOffset;
+    new_tab_x = Round(tab_x - GetTabHOffset()) + GetNewTabButtonHOffset();
   }
   newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
 }
 
 int TabStrip::GenerateIdealBoundsForMiniTabs(int* first_non_mini_index) {
   int next_x = 0;
   int mini_width = Tab::GetMiniWidth();
   int tab_height = Tab::GetStandardSize().height();
   int index = 0;
   for (; index < tab_count() && tab_at(index)->data().mini; ++index) {
     set_ideal_bounds(index,
                      gfx::Rect(next_x, 0, mini_width, tab_height));
-    next_x += mini_width + kTabHOffset;
+    next_x += mini_width + GetTabHOffset();
   }
   if (index > 0 && index < tab_count())
     next_x += kMiniToNonMiniGap;
   if (first_non_mini_index)
     *first_non_mini_index = index;
   return next_x;
 }
 
 int TabStrip::new_tab_button_width() const {
-  return kNewTabButtonWidth + kNewTabButtonHOffset;
+  return kNewTabButtonWidth + GetNewTabButtonHOffset();
 }
 
 void TabStrip::StartResizeLayoutAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMiniTabAnimation() {
   in_tab_close_ = false;
   available_width_for_tabs_ = -1;
 
   PrepareForAnimation();
 
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMouseInitiatedRemoveTabAnimation(int model_index) {
   // The user initiated the close. We want to persist the bounds of all the
   // existing tabs, so we manually shift ideal_bounds then animate.
   BaseTab* tab_closing = tab_at(model_index);
-  int delta = tab_closing->width() + kTabHOffset;
+  int delta = tab_closing->width() + GetTabHOffset();
   // If the tab being closed is a mini-tab next to a non-mini-tab, be sure to
   // add the extra padding.
   DCHECK_NE(model_index + 1, tab_count());
   if (tab_closing->data().mini && model_index + 1 < tab_count() &&
       !tab_at(model_index + 1)->data().mini) {
     delta += kMiniToNonMiniGap;
   }
 
   for (int i = model_index + 1; i < tab_count(); ++i) {
     gfx::Rect bounds = ideal_bounds(i);
@@ skipping 29 matching lines @@
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToView(this, tab, &point_in_tab_coords);
   return tab->HitTest(point_in_tab_coords);
 }
 
 int TabStrip::GetStartXForNormalTabs() const {
   int mini_tab_count = GetMiniTabCount();
   if (mini_tab_count == 0)
     return 0;
-  return mini_tab_count * (Tab::GetMiniWidth() + kTabHOffset) +
+  return mini_tab_count * (Tab::GetMiniWidth() + GetTabHOffset()) +
       kMiniToNonMiniGap;
 }
 
 Tab* TabStrip::FindTabForEvent(const gfx::Point& point, int start, int delta) {
   for (int i = start; i >= 0 && i < tab_count(); i += delta) {
     if (IsPointInTab(tab_at(i), point))
       return tab_at(i);
   }
   return NULL;
 }