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

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/views/tabs/stacked_tab_strip_layout.h"
   6
   7 #include <stdio.h>
   8
   9 #include "base/logging.h"
  10 #include "base/strings/string_number_conversions.h"
  11
  12 StackedTabStripLayout::StackedTabStripLayout(const gfx::Size& size,
  13                                              int padding,
  14                                              int stacked_padding,
  15                                              int max_stacked_count,
  16                                              views::ViewModelBase* view_model)
  17     : size_(size),
  18       padding_(padding),
  19       stacked_padding_(stacked_padding),
  20       max_stacked_count_(max_stacked_count),
  21       view_model_(view_model),
  22       x_(0),
  23       width_(0),
  24       mini_tab_count_(0),
  25       mini_tab_to_non_mini_tab_(0),
  26       active_index_(-1),
  27       first_tab_x_(0) {
  28 }
  29
  30 StackedTabStripLayout::~StackedTabStripLayout() {
  31 }
  32
  33 void StackedTabStripLayout::SetXAndMiniCount(int x, int mini_tab_count) {
  34   first_tab_x_ = x;
  35   x_ = x;
  36   mini_tab_count_ = mini_tab_count;
  37   mini_tab_to_non_mini_tab_ = 0;
  38   if (!requires_stacking() || tab_count() == mini_tab_count) {
  39     ResetToIdealState();
  40     return;
  41   }
  42   if (mini_tab_count > 0) {
  43     mini_tab_to_non_mini_tab_ = x - ideal_x(mini_tab_count - 1);
  44     first_tab_x_ = ideal_x(0);
  45   }
  46   SetIdealBoundsAt(active_index(), ConstrainActiveX(ideal_x(active_index())));
  47   LayoutByTabOffsetAfter(active_index());
  48   LayoutByTabOffsetBefore(active_index());
  49 }
  50
  51 void StackedTabStripLayout::SetWidth(int width) {
  52   if (width_ == width)
  53     return;
  54
  55   width_ = width;
  56   if (!requires_stacking()) {
  57     ResetToIdealState();
  58     return;
  59   }
  60   SetActiveBoundsAndLayoutFromActiveTab();
  61 }
  62
  63 void StackedTabStripLayout::SetActiveIndex(int index) {
  64   int old = active_index();
  65   active_index_ = index;
  66   if (old == active_index() || !requires_stacking())
  67     return;
  68   SetIdealBoundsAt(active_index(), ConstrainActiveX(ideal_x(active_index())));
  69   LayoutByTabOffsetBefore(active_index());
  70   LayoutByTabOffsetAfter(active_index());
  71   AdjustStackedTabs();
  72 }
  73
  74 void StackedTabStripLayout::DragActiveTab(int delta) {
  75   if (delta == 0 || !requires_stacking())
  76     return;
  77   int initial_x = ideal_x(active_index());
  78   // If we're at a particular edge and start dragging, expose all the tabs after
  79   // the tab (or before when dragging to the left).
  80   if (delta > 0 && initial_x == GetMinX(active_index())) {
  81     LayoutByTabOffsetAfter(active_index());
  82     AdjustStackedTabs();
  83   } else if (delta < 0 && initial_x == GetMaxX(active_index())) {
  84     LayoutByTabOffsetBefore(active_index());
  85     ResetToIdealState();
  86   }
  87   int x = delta > 0 ?
  88       std::min(initial_x + delta, GetMaxDragX(active_index())) :
  89       std::max(initial_x + delta, GetMinDragX(active_index()));
  90   if (x != initial_x) {
  91     SetIdealBoundsAt(active_index(), x);
  92     if (delta > 0) {
  93       PushTabsAfter(active_index(), (x - initial_x));
  94       LayoutForDragBefore(active_index());
  95     } else {
  96       PushTabsBefore(active_index(), initial_x - x);
  97       LayoutForDragAfter(active_index());
  98     }
  99     delta -= (x - initial_x);
 100   }
 101   if (delta > 0)
 102     ExpandTabsBefore(active_index(), delta);
 103   else if (delta < 0)
 104     ExpandTabsAfter(active_index(), -delta);
 105   AdjustStackedTabs();
 106 }
 107
 108 void StackedTabStripLayout::SizeToFit() {
 109   if (!tab_count())
 110     return;
 111
 112   if (!requires_stacking()) {
 113     ResetToIdealState();
 114     return;
 115   }
 116
 117   if (ideal_x(0) != first_tab_x_) {
 118     // Tabs have been dragged to the right. Pull in the tabs from left to right
 119     // to fill in space.
 120     int delta = ideal_x(0) - first_tab_x_;
 121     int i = 0;
 122     for (; i < mini_tab_count_; ++i) {
 123       gfx::Rect mini_bounds(view_model_->ideal_bounds(i));
 124       mini_bounds.set_x(ideal_x(i) - delta);
 125       view_model_->set_ideal_bounds(i, mini_bounds);
 126     }
 127     for (; delta > 0 && i < tab_count() - 1; ++i) {
 128       const int exposed = tab_offset() - (ideal_x(i + 1) - ideal_x(i));
 129       SetIdealBoundsAt(i, ideal_x(i) - delta);
 130       delta -= exposed;
 131     }
 132     AdjustStackedTabs();
 133     return;
 134   }
 135
 136   const int max_x = width_ - size_.width();
 137   if (ideal_x(tab_count() - 1) == max_x)
 138     return;
 139
 140   // Tabs have been dragged to the left. Pull in tabs from right to left to fill
 141   // in space.
 142   SetIdealBoundsAt(tab_count() - 1, max_x);
 143   for (int i = tab_count() - 2; i > mini_tab_count_ &&
 144            ideal_x(i + 1) - ideal_x(i) > tab_offset(); --i) {
 145     SetIdealBoundsAt(i, ideal_x(i + 1) - tab_offset());
 146   }
 147   AdjustStackedTabs();
 148 }
 149
 150 void StackedTabStripLayout::AddTab(int index, int add_types, int start_x) {
 151   if (add_types & kAddTypeActive)
 152     active_index_ = index;
 153   else if (active_index_ >= index)
 154     active_index_++;
 155   if (add_types & kAddTypeMini)
 156     mini_tab_count_++;
 157   x_ = start_x;
 158   if (!requires_stacking() || normal_tab_count() <= 1) {
 159     ResetToIdealState();
 160     return;
 161   }
 162   int active_x = (index + 1 == tab_count()) ?
 163       width_ - size_.width() : ideal_x(index + 1);
 164   SetIdealBoundsAt(active_index(), ConstrainActiveX(active_x));
 165   LayoutByTabOffsetAfter(active_index());
 166   LayoutByTabOffsetBefore(active_index());
 167   AdjustStackedTabs();
 168
 169   if ((add_types & kAddTypeActive) == 0)
 170     MakeVisible(index);
 171 }
 172
 173 void StackedTabStripLayout::RemoveTab(int index, int start_x, int old_x) {
 174   if (index == active_index_)
 175     active_index_ = std::min(active_index_, tab_count() - 1);
 176   else if (index < active_index_)
 177     active_index_--;
 178   bool removed_mini_tab = index < mini_tab_count_;
 179   if (removed_mini_tab) {
 180     mini_tab_count_--;
 181     DCHECK_GE(mini_tab_count_, 0);
 182   }
 183   int delta = start_x - x_;
 184   x_ = start_x;
 185   if (!requires_stacking()) {
 186     ResetToIdealState();
 187     return;
 188   }
 189   if (removed_mini_tab) {
 190     for (int i = mini_tab_count_; i < tab_count(); ++i)
 191       SetIdealBoundsAt(i, ideal_x(i) + delta);
 192   }
 193   SetActiveBoundsAndLayoutFromActiveTab();
 194   AdjustStackedTabs();
 195 }
 196
 197 void StackedTabStripLayout::MoveTab(int from,
 198                                     int to,
 199                                     int new_active_index,
 200                                     int start_x,
 201                                     int mini_tab_count) {
 202   x_ = start_x;
 203   mini_tab_count_ = mini_tab_count;
 204   active_index_ = new_active_index;
 205   if (!requires_stacking() || tab_count() == mini_tab_count_) {
 206     ResetToIdealState();
 207   } else {
 208     SetIdealBoundsAt(active_index(),
 209                      ConstrainActiveX(ideal_x(active_index())));
 210     LayoutByTabOffsetAfter(active_index());
 211     LayoutByTabOffsetBefore(active_index());
 212     AdjustStackedTabs();
 213   }
 214   mini_tab_to_non_mini_tab_ = mini_tab_count > 0 ?
 215       start_x - ideal_x(mini_tab_count - 1) : 0;
 216   first_tab_x_ = mini_tab_count > 0 ? ideal_x(0) : start_x;
 217 }
 218
 219 bool StackedTabStripLayout::IsStacked(int index) const {
 220   if (index == active_index() || tab_count() == mini_tab_count_ ||
 221       index < mini_tab_count_)
 222     return false;
 223   if (index > active_index())
 224     return ideal_x(index) != ideal_x(index - 1) + tab_offset();
 225   return ideal_x(index + 1) != ideal_x(index) + tab_offset();
 226 }
 227
 228 void StackedTabStripLayout::SetActiveTabLocation(int x) {
 229   if (!requires_stacking())
 230     return;
 231
 232   const int index = active_index();
 233   if (index <= mini_tab_count_)
 234     return;
 235
 236   x = std::min(GetMaxX(index), std::max(x, GetMinX(index)));
 237   if (x == ideal_x(index))
 238     return;
 239
 240   SetIdealBoundsAt(index, x);
 241   LayoutByTabOffsetBefore(index);
 242   LayoutByTabOffsetAfter(index);
 243 }
 244
 245 #if !defined(NDEBUG)
 246 std::string StackedTabStripLayout::BoundsString() const {
 247   std::string result;
 248   for (int i = 0; i < view_model_->view_size(); ++i) {
 249     if (!result.empty())
 250       result += " ";
 251     if (i == active_index())
 252       result += "[";
 253     result += base::IntToString(view_model_->ideal_bounds(i).x());
 254     if (i == active_index())
 255       result += "]";
 256   }
 257   return result;
 258 }
 259 #endif
 260
 261 void StackedTabStripLayout::Reset(int x,
 262                                   int width,
 263                                   int mini_tab_count,
 264                                   int active_index) {
 265   x_ = x;
 266   width_ = width;
 267   mini_tab_count_ = mini_tab_count;
 268   mini_tab_to_non_mini_tab_ = mini_tab_count > 0 ?
 269       x - ideal_x(mini_tab_count - 1) : 0;
 270   first_tab_x_ = mini_tab_count > 0 ? ideal_x(0) : x;
 271   active_index_ = active_index;
 272   ResetToIdealState();
 273 }
 274
 275 void StackedTabStripLayout::ResetToIdealState() {
 276   if (tab_count() == mini_tab_count_)
 277     return;
 278
 279   if (!requires_stacking()) {
 280     SetIdealBoundsAt(mini_tab_count_, x_);
 281     LayoutByTabOffsetAfter(mini_tab_count_);
 282     return;
 283   }
 284
 285   if (normal_tab_count() == 1) {
 286     // TODO: might want to shrink the tab here.
 287     SetIdealBoundsAt(mini_tab_count_, 0);
 288     return;
 289   }
 290
 291   int available_width = width_ - x_;
 292   int leading_count = active_index() - mini_tab_count_;
 293   int trailing_count = tab_count() - active_index();
 294   if (width_for_count(leading_count + 1) + max_stacked_width() <
 295       available_width) {
 296     SetIdealBoundsAt(mini_tab_count_, x_);
 297     LayoutByTabOffsetAfter(mini_tab_count_);
 298   } else if (width_for_count(trailing_count) + max_stacked_width() <
 299              available_width) {
 300     SetIdealBoundsAt(tab_count() - 1, width_ - size_.width());
 301     LayoutByTabOffsetBefore(tab_count() - 1);
 302   } else {
 303     int index = active_index();
 304     do {
 305       int stacked_padding = stacked_padding_for_count(index - mini_tab_count_);
 306       SetIdealBoundsAt(index, x_ + stacked_padding);
 307       LayoutByTabOffsetAfter(index);
 308       LayoutByTabOffsetBefore(index);
 309       index--;
 310     } while (index >= mini_tab_count_ && ideal_x(mini_tab_count_) != x_ &&
 311              ideal_x(tab_count() - 1) != width_ - size_.width());
 312   }
 313   AdjustStackedTabs();
 314 }
 315
 316 void StackedTabStripLayout::MakeVisible(int index) {
 317   // Currently no need to support tabs openning before |index| visible.
 318   if (index <= active_index() || !requires_stacking() || !IsStacked(index))
 319     return;
 320
 321   int ideal_delta = width_for_count(index - active_index()) + padding_;
 322   if (ideal_x(index) - ideal_x(active_index()) == ideal_delta)
 323     return;
 324
 325   // First push active index as far to the left as it'll go.
 326   int active_x = std::max(GetMinX(active_index()),
 327                           std::min(ideal_x(index) - ideal_delta,
 328                                    ideal_x(active_index())));
 329   SetIdealBoundsAt(active_index(), active_x);
 330   LayoutUsingCurrentBefore(active_index());
 331   LayoutUsingCurrentAfter(active_index());
 332   AdjustStackedTabs();
 333   if (ideal_x(index) - ideal_x(active_index()) == ideal_delta)
 334     return;
 335
 336   // If we get here active_index() is left aligned. Push |index| as far to
 337   // the right as possible.
 338   int x = std::min(GetMaxX(index), active_x + ideal_delta);
 339   SetIdealBoundsAt(index, x);
 340   LayoutByTabOffsetAfter(index);
 341   for (int next_x = x, i = index - 1; i > active_index(); --i) {
 342     next_x = std::max(GetMinXCompressed(i), next_x - tab_offset());
 343     SetIdealBoundsAt(i, next_x);
 344   }
 345   LayoutUsingCurrentAfter(active_index());
 346   AdjustStackedTabs();
 347 }
 348
 349 int StackedTabStripLayout::ConstrainActiveX(int x) const {
 350   return std::min(GetMaxX(active_index()),
 351                   std::max(GetMinX(active_index()), x));
 352 }
 353
 354 void StackedTabStripLayout::SetActiveBoundsAndLayoutFromActiveTab() {
 355   int x = ConstrainActiveX(ideal_x(active_index()));
 356   SetIdealBoundsAt(active_index(), x);
 357   LayoutUsingCurrentBefore(active_index());
 358   LayoutUsingCurrentAfter(active_index());
 359   AdjustStackedTabs();
 360 }
 361
 362 void StackedTabStripLayout::LayoutByTabOffsetAfter(int index) {
 363   for (int i = index + 1; i < tab_count(); ++i) {
 364     int max_x = width_ - size_.width() -
 365         stacked_padding_for_count(tab_count() - i - 1);
 366     int x = std::min(max_x,
 367                      view_model_->ideal_bounds(i - 1).x() + tab_offset());
 368     SetIdealBoundsAt(i, x);
 369   }
 370 }
 371
 372 void StackedTabStripLayout::LayoutByTabOffsetBefore(int index) {
 373   for (int i = index - 1; i >= mini_tab_count_; --i) {
 374     int min_x = x_ + stacked_padding_for_count(i - mini_tab_count_);
 375     int x = std::max(min_x, ideal_x(i + 1) - (tab_offset()));
 376     SetIdealBoundsAt(i, x);
 377   }
 378 }
 379
 380 void StackedTabStripLayout::LayoutUsingCurrentAfter(int index) {
 381   for (int i = index + 1; i < tab_count(); ++i) {
 382     int min_x = width_ - width_for_count(tab_count() - i);
 383     int x = std::max(min_x,
 384                      std::min(ideal_x(i), ideal_x(i - 1) + tab_offset()));
 385     x = std::min(GetMaxX(i), x);
 386     SetIdealBoundsAt(i, x);
 387   }
 388 }
 389
 390 void StackedTabStripLayout::LayoutUsingCurrentBefore(int index) {
 391   for (int i = index - 1; i >= mini_tab_count_; --i) {
 392     int max_x = x_ + width_for_count(i - mini_tab_count_);
 393     if (i > mini_tab_count_)
 394       max_x += padding_;
 395     max_x = std::min(max_x, ideal_x(i + 1) - stacked_padding_);
 396     SetIdealBoundsAt(
 397         i, std::min(max_x,
 398                     std::max(ideal_x(i), ideal_x(i + 1) - tab_offset())));
 399   }
 400 }
 401
 402 void StackedTabStripLayout::PushTabsAfter(int index, int delta) {
 403   for (int i = index + 1; i < tab_count(); ++i)
 404     SetIdealBoundsAt(i, std::min(ideal_x(i) + delta, GetMaxDragX(i)));
 405 }
 406
 407 void StackedTabStripLayout::PushTabsBefore(int index, int delta) {
 408   for (int i = index - 1; i > mini_tab_count_; --i)
 409     SetIdealBoundsAt(i, std::max(ideal_x(i) - delta, GetMinDragX(i)));
 410 }
 411
 412 void StackedTabStripLayout::LayoutForDragAfter(int index) {
 413   for (int i = index + 1; i < tab_count(); ++i) {
 414     const int min_x = ideal_x(i - 1) + stacked_padding_;
 415     const int max_x = ideal_x(i - 1) + tab_offset();
 416     SetIdealBoundsAt(
 417         i, std::max(min_x, std::min(ideal_x(i), max_x)));
 418   }
 419 }
 420
 421 void StackedTabStripLayout::LayoutForDragBefore(int index) {
 422   for (int i = index - 1; i >= mini_tab_count_; --i) {
 423     const int max_x = ideal_x(i + 1) - stacked_padding_;
 424     const int min_x = ideal_x(i + 1) - tab_offset();
 425     SetIdealBoundsAt(
 426         i, std::max(min_x, std::min(ideal_x(i), max_x)));
 427   }
 428
 429   if (mini_tab_count_ == 0)
 430     return;
 431
 432   // Pull in the mini-tabs.
 433   const int delta = (mini_tab_count_ > 1) ? ideal_x(1) - ideal_x(0) : 0;
 434   for (int i = mini_tab_count_ - 1; i >= 0; --i) {
 435     gfx::Rect mini_bounds(view_model_->ideal_bounds(i));
 436     if (i == mini_tab_count_ - 1)
 437       mini_bounds.set_x(ideal_x(i + 1) - mini_tab_to_non_mini_tab_);
 438     else
 439       mini_bounds.set_x(ideal_x(i + 1) - delta);
 440     view_model_->set_ideal_bounds(i, mini_bounds);
 441   }
 442 }
 443
 444 void StackedTabStripLayout::ExpandTabsBefore(int index, int delta) {
 445   for (int i = index - 1; i >= mini_tab_count_ && delta > 0; --i) {
 446     const int max_x = ideal_x(active_index()) -
 447         stacked_padding_for_count(active_index() - i);
 448     int to_resize = std::min(delta, max_x - ideal_x(i));
 449
 450     if (to_resize <= 0)
 451       continue;
 452     SetIdealBoundsAt(i, ideal_x(i) + to_resize);
 453     delta -= to_resize;
 454     LayoutForDragBefore(i);
 455   }
 456 }
 457
 458 void StackedTabStripLayout::ExpandTabsAfter(int index, int delta) {
 459   if (index == tab_count() - 1)
 460     return;  // Nothing to expand.
 461
 462   for (int i = index + 1; i < tab_count() && delta > 0; ++i) {
 463     const int min_compressed =
 464         ideal_x(active_index()) + stacked_padding_for_count(i - active_index());
 465     const int to_resize = std::min(ideal_x(i) - min_compressed, delta);
 466     if (to_resize <= 0)
 467       continue;
 468     SetIdealBoundsAt(i, ideal_x(i) - to_resize);
 469     delta -= to_resize;
 470     LayoutForDragAfter(i);
 471   }
 472 }
 473
 474 void StackedTabStripLayout::AdjustStackedTabs() {
 475   if (!requires_stacking() || tab_count() <= mini_tab_count_ + 1)
 476     return;
 477
 478   AdjustLeadingStackedTabs();
 479   AdjustTrailingStackedTabs();
 480 }
 481
 482 void StackedTabStripLayout::AdjustLeadingStackedTabs() {
 483   int index = mini_tab_count_ + 1;
 484   while (index < active_index() &&
 485          ideal_x(index) - ideal_x(index - 1) <= stacked_padding_ &&
 486          ideal_x(index) <= x_ + max_stacked_width()) {
 487     index++;
 488   }
 489   if (ideal_x(index) - ideal_x(index - 1) <= stacked_padding_ &&
 490       ideal_x(index) <= x_ + max_stacked_width()) {
 491     index++;
 492   }
 493   if (index <= mini_tab_count_ + max_stacked_count_ - 1)
 494     return;
 495   int max_stacked = index;
 496   int x = x_;
 497   index = mini_tab_count_;
 498   for (; index < max_stacked - max_stacked_count_ - 1; ++index)
 499     SetIdealBoundsAt(index, x);
 500   for (; index < max_stacked; ++index, x += stacked_padding_)
 501     SetIdealBoundsAt(index, x);
 502 }
 503
 504 void StackedTabStripLayout::AdjustTrailingStackedTabs() {
 505   int index = tab_count() - 1;
 506   int max_stacked_x = width_ - size_.width() - max_stacked_width();
 507   while (index > active_index() &&
 508          ideal_x(index) - ideal_x(index - 1) <= stacked_padding_ &&
 509          ideal_x(index - 1) >= max_stacked_x) {
 510     index--;
 511   }
 512   if (index > active_index() &&
 513       ideal_x(index) - ideal_x(index - 1) <= stacked_padding_ &&
 514       ideal_x(index - 1) >= max_stacked_x) {
 515     index--;
 516   }
 517   if (index >= tab_count() - max_stacked_count_)
 518     return;
 519   int first_stacked = index;
 520   int x = width_ - size_.width() -
 521       std::min(tab_count() - first_stacked, max_stacked_count_) *
 522       stacked_padding_;
 523   for (; index < first_stacked + max_stacked_count_;
 524        ++index, x += stacked_padding_) {
 525     SetIdealBoundsAt(index, x);
 526   }
 527   for (; index < tab_count(); ++index)
 528     SetIdealBoundsAt(index, x);
 529 }
 530
 531 void StackedTabStripLayout::SetIdealBoundsAt(int index, int x) {
 532   view_model_->set_ideal_bounds(index, gfx::Rect(gfx::Point(x, 0), size_));
 533 }
 534
 535 int StackedTabStripLayout::GetMinX(int index) const {
 536   int leading_count = index - mini_tab_count_;
 537   int trailing_count = tab_count() - index;
 538   return std::max(x_ + stacked_padding_for_count(leading_count),
 539                   width_ - width_for_count(trailing_count));
 540 }
 541
 542 int StackedTabStripLayout::GetMaxX(int index) const {
 543   int leading_count = index - mini_tab_count_;
 544   int trailing_count = tab_count() - index - 1;
 545   int trailing_offset = stacked_padding_for_count(trailing_count);
 546   int leading_size = width_for_count(leading_count) + x_;
 547   if (leading_count > 0)
 548     leading_size += padding_;
 549   return std::min(width_ - trailing_offset - size_.width(), leading_size);
 550 }
 551
 552 int StackedTabStripLayout::GetMinDragX(int index) const {
 553   return x_ + stacked_padding_for_count(index - mini_tab_count_);
 554 }
 555
 556 int StackedTabStripLayout::GetMaxDragX(int index) const {
 557   const int trailing_offset =
 558       stacked_padding_for_count(tab_count() - index - 1);
 559   return width_ - trailing_offset - size_.width();
 560 }
 561
 562 int StackedTabStripLayout::GetMinXCompressed(int index) const {
 563   DCHECK_GT(index, active_index());
 564   return std::max(
 565       width_ - width_for_count(tab_count() - index),
 566       ideal_x(active_index()) +
 567           stacked_padding_for_count(index - active_index()));
 568 }