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 13 matching lines @@
 #include "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 #include "chrome/browser/ui/views/tabs/tab_strip_controller.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 width reserved for stacked tabs along a particular edge.
 static const double kMaxEdgeStackWidth = 24;
 
-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_METRO:
+        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_METRO:
+        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_METRO:
+        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 223 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 404 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();
-  needed_width += kNewTabButtonHOffset - kTabHOffset;
+  needed_width += GetNewTabButtonHOffset() - GetTabHOffset();
   needed_width += newtab_button_bounds_.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 156 matching lines @@
   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 64 matching lines @@
   GenerateIdealBounds();
 
   views::ViewModelUtils::SetViewBoundsToIdealBounds(tabs_);
 
   SchedulePaint();
 
   // It is possible we don't have a new tab button yet.
   if (newtab_button_) {
     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 44 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 118 matching lines @@
   for (int i = index1; i < index2; ++i) {
     if (!tab_at(i)->closing())
       count++;
   }
   return count;
 }
 
 void TabStrip::UpdateNumVisibleTabs(int non_closing_tab_count,
                                     int width,
                                     double tab_size) {
-  num_visible_tabs_ = (width + kTabHOffset) / (tab_size + kTabHOffset);
+  num_visible_tabs_ = (width + GetTabHOffset()) / (tab_size + GetTabHOffset());
   num_visible_tabs_ = std::max(1, num_visible_tabs_);
   // Make sure the first_visible_tab_index_ is valid.
   // TODO: this isn't quite right, it doesn't take into account closing tabs.
   first_visible_tab_index_ =
       std::min(first_visible_tab_index_, non_closing_tab_count -
                num_visible_tabs_);
   first_visible_tab_index_ = std::max(0, first_visible_tab_index_);
 }
 
 void TabStrip::EnsureModelIndexIsVisible(int model_index) {
@@ skipping 27 matching lines @@
 
   if (tab_count == 0) {
     // Return immediately to avoid divide-by-zero below.
     return;
   }
 
   // Determine how much space we can actually allocate to tabs.
   int available_width;
   if (available_width_for_tabs_ < 0) {
     available_width = width();
-    available_width -= (kNewTabButtonHOffset + newtab_button_bounds_.width());
+    available_width -=
+        (GetNewTabButtonHOffset() + newtab_button_bounds_.width());
   } else {
     // Interesting corner case: if |available_width_for_tabs_| > the result
     // of the calculation in the conditional arm above, the strip is in
     // overflow.  We can either use the specified width or the true available
     // 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 165 matching lines @@
           tab_x += kMiniToNonMiniGap;
         }
         if (tab->IsActive())
           tab_width = selected;
       }
       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();
       last_was_mini = tab->data().mini;
     }
   }
 
   // If we're in stacking mode, update the positions now that we have
   // appropriate widths.
-  if (stacking_ && tab_x - kTabHOffset >
+  if (stacking_ && tab_x - GetTabHOffset() >
       width() - newtab_button_bounds_.width()) {
     tab_x = GenerateIdealBoundsWithStacking(
         mini_tab_count, non_closing_tab_count, tab_x, selected);
   }
 
   // Update bounds of new tab button.
   int new_tab_x;
-  int new_tab_y = SizeTabButtonToTopOfTabStrip() ? 0 : kNewTabButtonVOffset;
+  int new_tab_y = SizeTabButtonToTopOfTabStrip() ? 0 : GetNewTabButtonVOffset();
   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));
 }
 
 double TabStrip::GenerateIdealBoundsWithStacking(int mini_tab_count,
                                                  int non_closing_tab_count,
                                                  double new_tab_x,
                                                  double selected_size) {
   if (non_closing_tab_count == mini_tab_count)
     return new_tab_x;
 
   // Pinned tabs always have their desired size, and don't stack. We rely on
   // GenerateIdealBounds to have positioned pinned tabs already, so don't move
   // them.
   int tab_index = 0;
   double next_x = 0;
   for (; tab_index < tab_count(); ++tab_index) {
     BaseTab* tab = tab_at(tab_index);
     if (!tab->closing() && !tab->data().mini) {
       next_x = ideal_bounds(tab_index).x();
       break;
     }
   }
   if (tab_index == tab_count())
     return new_tab_x;
 
   // Always reserve kMaxEdgeStackWidth on each side for stacking. We don't
   // later try to adjust as it can lead to tabs bouncing around.
   int available_width = width() -
-      (kNewTabButtonHOffset + newtab_button_bounds_.width()) - next_x -
+      (GetNewTabButtonHOffset() + newtab_button_bounds_.width()) - next_x -
       2 * kMaxEdgeStackWidth;
   if (available_width <= 0)
     return new_tab_x;
   UpdateNumVisibleTabs(non_closing_tab_count, available_width, selected_size);
   int stacked_leading_index = tab_index;
   int stacked_trailing_index = first_visible_tab_index_;
   for (int visible_count = 0;
        stacked_trailing_index < tab_count() &&
            visible_count < num_visible_tabs_; ++stacked_trailing_index) {
     if (!tab_at(stacked_trailing_index)->closing())
@@ skipping 18 matching lines @@
     }
   } else {
     tab_index = first_visible_tab_index_;
   }
 
   if (stacked_leading_count > 0 && stacked_trailing_count == 0) {
     // If there are no stacked tabs on the right and there is extra space, give
     // it to the last stacked tab on the left.
     next_x += available_width + kMaxEdgeStackWidth -
         (num_visible_tabs_ * selected_size +
-         std::max(num_visible_tabs_ - 1, 0) * kTabHOffset);
+         std::max(num_visible_tabs_ - 1, 0) * GetTabHOffset());
   }
 
   // Totally visible tabs.
   for (int visible_count = 0;
        tab_index < tab_count() && visible_count < num_visible_tabs_;
        tab_index++) {
     if (tab_at(tab_index)->closing())
       continue;
     gfx::Rect bounds = ideal_bounds(tab_index);
     bounds.set_x(next_x);
-    next_x = bounds.right() + kTabHOffset;
+    next_x = bounds.right() + GetTabHOffset();
     set_ideal_bounds(tab_index, bounds);
     visible_count++;
   }
 
   // Stacked tabs to the right.
   if (stacked_trailing_count == 0)
     return next_x;
 
   double stacked_offset =
       kMaxEdgeStackWidth / static_cast<double>(stacked_trailing_count);
-  next_x = width() - (kNewTabButtonHOffset + newtab_button_bounds_.width()) -
+  next_x = width() -
+      (GetNewTabButtonHOffset() + newtab_button_bounds_.width()) -
       (stacked_trailing_count - 1) * stacked_offset - selected_size;
   for (; tab_index < tab_count(); ++tab_index) {
     if (tab_at(tab_index)->closing())
       continue;
     gfx::Rect bounds = ideal_bounds(tab_index);
     bounds.set_x(next_x);
     set_ideal_bounds(tab_index, bounds);
     next_x += stacked_offset;
   }
 
-  return next_x + kTabHOffset;
+  return next_x + GetTabHOffset();
 }
 
 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 24 matching lines @@
       new RemoveTabDelegate(this, tab_closing),
       true);
 }
 
 bool TabStrip::IsPointInTab(Tab* tab,
                             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);
 }