ui/views/controls/scroll_view.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 "ui/views/controls/scroll_view.h"
   6
   7 #include "base/logging.h"
   8 #include "ui/events/event.h"
   9 #include "ui/native_theme/native_theme.h"
  10 #include "ui/views/border.h"
  11 #include "ui/views/controls/scrollbar/native_scroll_bar.h"
  12 #include "ui/views/widget/root_view.h"
  13
  14 namespace views {
  15
  16 const char ScrollView::kViewClassName[] = "ScrollView";
  17
  18 namespace {
  19
  20 // Subclass of ScrollView that resets the border when the theme changes.
  21 class ScrollViewWithBorder : public views::ScrollView {
  22  public:
  23   ScrollViewWithBorder() {}
  24
  25   // View overrides;
  26   virtual void OnNativeThemeChanged(const ui::NativeTheme* theme) OVERRIDE {
  27     SetBorder(Border::CreateSolidBorder(
  28         1,
  29         theme->GetSystemColor(ui::NativeTheme::kColorId_UnfocusedBorderColor)));
  30   }
  31
  32  private:
  33   DISALLOW_COPY_AND_ASSIGN(ScrollViewWithBorder);
  34 };
  35
  36 // Returns the position for the view so that it isn't scrolled off the visible
  37 // region.
  38 int CheckScrollBounds(int viewport_size, int content_size, int current_pos) {
  39   int max = std::max(content_size - viewport_size, 0);
  40   if (current_pos < 0)
  41     return 0;
  42   if (current_pos > max)
  43     return max;
  44   return current_pos;
  45 }
  46
  47 // Make sure the content is not scrolled out of bounds
  48 void CheckScrollBounds(View* viewport, View* view) {
  49   if (!view)
  50     return;
  51
  52   int x = CheckScrollBounds(viewport->width(), view->width(), -view->x());
  53   int y = CheckScrollBounds(viewport->height(), view->height(), -view->y());
  54
  55   // This is no op if bounds are the same
  56   view->SetBounds(-x, -y, view->width(), view->height());
  57 }
  58
  59 // Used by ScrollToPosition() to make sure the new position fits within the
  60 // allowed scroll range.
  61 int AdjustPosition(int current_position,
  62                    int new_position,
  63                    int content_size,
  64                    int viewport_size) {
  65   if (-current_position == new_position)
  66     return new_position;
  67   if (new_position < 0)
  68     return 0;
  69   const int max_position = std::max(0, content_size - viewport_size);
  70   return (new_position > max_position) ? max_position : new_position;
  71 }
  72
  73 }  // namespace
  74
  75 // Viewport contains the contents View of the ScrollView.
  76 class ScrollView::Viewport : public View {
  77  public:
  78   Viewport() {}
  79   virtual ~Viewport() {}
  80
  81   virtual const char* GetClassName() const OVERRIDE {
  82     return "ScrollView::Viewport";
  83   }
  84
  85   virtual void ScrollRectToVisible(const gfx::Rect& rect) OVERRIDE {
  86     if (!has_children() || !parent())
  87       return;
  88
  89     View* contents = child_at(0);
  90     gfx::Rect scroll_rect(rect);
  91     scroll_rect.Offset(-contents->x(), -contents->y());
  92     static_cast<ScrollView*>(parent())->ScrollContentsRegionToBeVisible(
  93         scroll_rect);
  94   }
  95
  96   virtual void ChildPreferredSizeChanged(View* child) OVERRIDE {
  97     if (parent())
  98       parent()->Layout();
  99   }
 100
 101  private:
 102   DISALLOW_COPY_AND_ASSIGN(Viewport);
 103 };
 104
 105 ScrollView::ScrollView()
 106     : contents_(NULL),
 107       contents_viewport_(new Viewport()),
 108       header_(NULL),
 109       header_viewport_(new Viewport()),
 110       horiz_sb_(new NativeScrollBar(true)),
 111       vert_sb_(new NativeScrollBar(false)),
 112       resize_corner_(NULL),
 113       min_height_(-1),
 114       max_height_(-1),
 115       hide_horizontal_scrollbar_(false) {
 116   set_notify_enter_exit_on_child(true);
 117
 118   AddChildView(contents_viewport_);
 119   AddChildView(header_viewport_);
 120
 121   // Don't add the scrollbars as children until we discover we need them
 122   // (ShowOrHideScrollBar).
 123   horiz_sb_->SetVisible(false);
 124   horiz_sb_->set_controller(this);
 125   vert_sb_->SetVisible(false);
 126   vert_sb_->set_controller(this);
 127   if (resize_corner_)
 128     resize_corner_->SetVisible(false);
 129 }
 130
 131 ScrollView::~ScrollView() {
 132   // The scrollbars may not have been added, delete them to ensure they get
 133   // deleted.
 134   delete horiz_sb_;
 135   delete vert_sb_;
 136
 137   if (resize_corner_ && !resize_corner_->parent())
 138     delete resize_corner_;
 139 }
 140
 141 // static
 142 ScrollView* ScrollView::CreateScrollViewWithBorder() {
 143   return new ScrollViewWithBorder();
 144 }
 145
 146 void ScrollView::SetContents(View* a_view) {
 147   SetHeaderOrContents(contents_viewport_, a_view, &contents_);
 148 }
 149
 150 void ScrollView::SetHeader(View* header) {
 151   SetHeaderOrContents(header_viewport_, header, &header_);
 152 }
 153
 154 gfx::Rect ScrollView::GetVisibleRect() const {
 155   if (!contents_)
 156     return gfx::Rect();
 157   return gfx::Rect(-contents_->x(), -contents_->y(),
 158                    contents_viewport_->width(), contents_viewport_->height());
 159 }
 160
 161 void ScrollView::ClipHeightTo(int min_height, int max_height) {
 162   min_height_ = min_height;
 163   max_height_ = max_height;
 164 }
 165
 166 int ScrollView::GetScrollBarWidth() const {
 167   return vert_sb_ ? vert_sb_->GetLayoutSize() : 0;
 168 }
 169
 170 int ScrollView::GetScrollBarHeight() const {
 171   return horiz_sb_ ? horiz_sb_->GetLayoutSize() : 0;
 172 }
 173
 174 void ScrollView::SetHorizontalScrollBar(ScrollBar* horiz_sb) {
 175   DCHECK(horiz_sb);
 176   horiz_sb->SetVisible(horiz_sb_->visible());
 177   delete horiz_sb_;
 178   horiz_sb->set_controller(this);
 179   horiz_sb_ = horiz_sb;
 180 }
 181
 182 void ScrollView::SetVerticalScrollBar(ScrollBar* vert_sb) {
 183   DCHECK(vert_sb);
 184   vert_sb->SetVisible(vert_sb_->visible());
 185   delete vert_sb_;
 186   vert_sb->set_controller(this);
 187   vert_sb_ = vert_sb;
 188 }
 189
 190 gfx::Size ScrollView::GetPreferredSize() const {
 191   if (!is_bounded())
 192     return View::GetPreferredSize();
 193
 194   gfx::Size size = contents()->GetPreferredSize();
 195   size.SetToMax(gfx::Size(size.width(), min_height_));
 196   size.SetToMin(gfx::Size(size.width(), max_height_));
 197   gfx::Insets insets = GetInsets();
 198   size.Enlarge(insets.width(), insets.height());
 199   return size;
 200 }
 201
 202 int ScrollView::GetHeightForWidth(int width) const {
 203   if (!is_bounded())
 204     return View::GetHeightForWidth(width);
 205
 206   gfx::Insets insets = GetInsets();
 207   width = std::max(0, width - insets.width());
 208   int height = contents()->GetHeightForWidth(width) + insets.height();
 209   return std::min(std::max(height, min_height_), max_height_);
 210 }
 211
 212 void ScrollView::Layout() {
 213   if (is_bounded()) {
 214     int content_width = width();
 215     int content_height = contents()->GetHeightForWidth(content_width);
 216     if (content_height > height()) {
 217       content_width = std::max(content_width - GetScrollBarWidth(), 0);
 218       content_height = contents()->GetHeightForWidth(content_width);
 219     }
 220     if (contents()->bounds().size() != gfx::Size(content_width, content_height))
 221       contents()->SetBounds(0, 0, content_width, content_height);
 222   }
 223
 224   // Most views will want to auto-fit the available space. Most of them want to
 225   // use all available width (without overflowing) and only overflow in
 226   // height. Examples are HistoryView, MostVisitedView, DownloadTabView, etc.
 227   // Other views want to fit in both ways. An example is PrintView. To make both
 228   // happy, assume a vertical scrollbar but no horizontal scrollbar. To override
 229   // this default behavior, the inner view has to calculate the available space,
 230   // used ComputeScrollBarsVisibility() to use the same calculation that is done
 231   // here and sets its bound to fit within.
 232   gfx::Rect viewport_bounds = GetContentsBounds();
 233   const int contents_x = viewport_bounds.x();
 234   const int contents_y = viewport_bounds.y();
 235   if (viewport_bounds.IsEmpty()) {
 236     // There's nothing to layout.
 237     return;
 238   }
 239
 240   const int header_height =
 241       std::min(viewport_bounds.height(),
 242                header_ ? header_->GetPreferredSize().height() : 0);
 243   viewport_bounds.set_height(
 244       std::max(0, viewport_bounds.height() - header_height));
 245   viewport_bounds.set_y(viewport_bounds.y() + header_height);
 246   // viewport_size is the total client space available.
 247   gfx::Size viewport_size = viewport_bounds.size();
 248   // Assumes a vertical scrollbar since most of the current views are designed
 249   // for this.
 250   int horiz_sb_height = GetScrollBarHeight();
 251   int vert_sb_width = GetScrollBarWidth();
 252   viewport_bounds.set_width(viewport_bounds.width() - vert_sb_width);
 253   // Update the bounds right now so the inner views can fit in it.
 254   contents_viewport_->SetBoundsRect(viewport_bounds);
 255
 256   // Give |contents_| a chance to update its bounds if it depends on the
 257   // viewport.
 258   if (contents_)
 259     contents_->Layout();
 260
 261   bool should_layout_contents = false;
 262   bool horiz_sb_required = false;
 263   bool vert_sb_required = false;
 264   if (contents_) {
 265     gfx::Size content_size = contents_->size();
 266     ComputeScrollBarsVisibility(viewport_size,
 267                                 content_size,
 268                                 &horiz_sb_required,
 269                                 &vert_sb_required);
 270   }
 271   bool resize_corner_required = resize_corner_ && horiz_sb_required &&
 272                                 vert_sb_required;
 273   // Take action.
 274   SetControlVisibility(horiz_sb_, horiz_sb_required);
 275   SetControlVisibility(vert_sb_, vert_sb_required);
 276   SetControlVisibility(resize_corner_, resize_corner_required);
 277
 278   // Non-default.
 279   if (horiz_sb_required) {
 280     viewport_bounds.set_height(
 281         std::max(0, viewport_bounds.height() - horiz_sb_height));
 282     should_layout_contents = true;
 283   }
 284   // Default.
 285   if (!vert_sb_required) {
 286     viewport_bounds.set_width(viewport_bounds.width() + vert_sb_width);
 287     should_layout_contents = true;
 288   }
 289
 290   if (horiz_sb_required) {
 291     int height_offset = horiz_sb_->GetContentOverlapSize();
 292     horiz_sb_->SetBounds(0,
 293                          viewport_bounds.bottom() - height_offset,
 294                          viewport_bounds.right(),
 295                          horiz_sb_height + height_offset);
 296   }
 297   if (vert_sb_required) {
 298     int width_offset = vert_sb_->GetContentOverlapSize();
 299     vert_sb_->SetBounds(viewport_bounds.right() - width_offset,
 300                         0,
 301                         vert_sb_width + width_offset,
 302                         viewport_bounds.bottom());
 303   }
 304   if (resize_corner_required) {
 305     // Show the resize corner.
 306     resize_corner_->SetBounds(viewport_bounds.right(),
 307                               viewport_bounds.bottom(),
 308                               vert_sb_width,
 309                               horiz_sb_height);
 310   }
 311
 312   // Update to the real client size with the visible scrollbars.
 313   contents_viewport_->SetBoundsRect(viewport_bounds);
 314   if (should_layout_contents && contents_)
 315     contents_->Layout();
 316
 317   header_viewport_->SetBounds(contents_x, contents_y,
 318                               viewport_bounds.width(), header_height);
 319   if (header_)
 320     header_->Layout();
 321
 322   CheckScrollBounds(header_viewport_, header_);
 323   CheckScrollBounds(contents_viewport_, contents_);
 324   SchedulePaint();
 325   UpdateScrollBarPositions();
 326 }
 327
 328 bool ScrollView::OnKeyPressed(const ui::KeyEvent& event) {
 329   bool processed = false;
 330
 331   // Give vertical scrollbar priority
 332   if (vert_sb_->visible())
 333     processed = vert_sb_->OnKeyPressed(event);
 334
 335   if (!processed && horiz_sb_->visible())
 336     processed = horiz_sb_->OnKeyPressed(event);
 337
 338   return processed;
 339 }
 340
 341 bool ScrollView::OnMouseWheel(const ui::MouseWheelEvent& e) {
 342   bool processed = false;
 343   // Give vertical scrollbar priority
 344   if (vert_sb_->visible())
 345     processed = vert_sb_->OnMouseWheel(e);
 346
 347   if (!processed && horiz_sb_->visible())
 348     processed = horiz_sb_->OnMouseWheel(e);
 349
 350   return processed;
 351 }
 352
 353 void ScrollView::OnMouseEntered(const ui::MouseEvent& event) {
 354   if (horiz_sb_)
 355     horiz_sb_->OnMouseEnteredScrollView(event);
 356   if (vert_sb_)
 357     vert_sb_->OnMouseEnteredScrollView(event);
 358 }
 359
 360 void ScrollView::OnMouseExited(const ui::MouseEvent& event) {
 361   if (horiz_sb_)
 362     horiz_sb_->OnMouseExitedScrollView(event);
 363   if (vert_sb_)
 364     vert_sb_->OnMouseExitedScrollView(event);
 365 }
 366
 367 void ScrollView::OnGestureEvent(ui::GestureEvent* event) {
 368   // If the event happened on one of the scrollbars, then those events are
 369   // sent directly to the scrollbars. Otherwise, only scroll events are sent to
 370   // the scrollbars.
 371   bool scroll_event = event->type() == ui::ET_GESTURE_SCROLL_UPDATE ||
 372                       event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
 373                       event->type() == ui::ET_GESTURE_SCROLL_END ||
 374                       event->type() == ui::ET_SCROLL_FLING_START;
 375
 376   if (vert_sb_->visible()) {
 377     if (vert_sb_->bounds().Contains(event->location()) || scroll_event)
 378       vert_sb_->OnGestureEvent(event);
 379   }
 380   if (!event->handled() && horiz_sb_->visible()) {
 381     if (horiz_sb_->bounds().Contains(event->location()) || scroll_event)
 382       horiz_sb_->OnGestureEvent(event);
 383   }
 384 }
 385
 386 const char* ScrollView::GetClassName() const {
 387   return kViewClassName;
 388 }
 389
 390 void ScrollView::ScrollToPosition(ScrollBar* source, int position) {
 391   if (!contents_)
 392     return;
 393
 394   if (source == horiz_sb_ && horiz_sb_->visible()) {
 395     position = AdjustPosition(contents_->x(), position, contents_->width(),
 396                               contents_viewport_->width());
 397     if (-contents_->x() == position)
 398       return;
 399     contents_->SetX(-position);
 400     if (header_) {
 401       header_->SetX(-position);
 402       header_->SchedulePaintInRect(header_->GetVisibleBounds());
 403     }
 404   } else if (source == vert_sb_ && vert_sb_->visible()) {
 405     position = AdjustPosition(contents_->y(), position, contents_->height(),
 406                               contents_viewport_->height());
 407     if (-contents_->y() == position)
 408       return;
 409     contents_->SetY(-position);
 410   }
 411   contents_->SchedulePaintInRect(contents_->GetVisibleBounds());
 412 }
 413
 414 int ScrollView::GetScrollIncrement(ScrollBar* source, bool is_page,
 415                                    bool is_positive) {
 416   bool is_horizontal = source->IsHorizontal();
 417   int amount = 0;
 418   if (contents_) {
 419     if (is_page) {
 420       amount = contents_->GetPageScrollIncrement(
 421           this, is_horizontal, is_positive);
 422     } else {
 423       amount = contents_->GetLineScrollIncrement(
 424           this, is_horizontal, is_positive);
 425     }
 426     if (amount > 0)
 427       return amount;
 428   }
 429   // No view, or the view didn't return a valid amount.
 430   if (is_page) {
 431     return is_horizontal ? contents_viewport_->width() :
 432                            contents_viewport_->height();
 433   }
 434   return is_horizontal ? contents_viewport_->width() / 5 :
 435                          contents_viewport_->height() / 5;
 436 }
 437
 438 void ScrollView::SetHeaderOrContents(View* parent,
 439                                      View* new_view,
 440                                      View** member) {
 441   if (*member == new_view)
 442     return;
 443
 444   delete *member;
 445   *member = new_view;
 446   if (*member)
 447     parent->AddChildView(*member);
 448   Layout();
 449 }
 450
 451 void ScrollView::ScrollContentsRegionToBeVisible(const gfx::Rect& rect) {
 452   if (!contents_ || (!horiz_sb_->visible() && !vert_sb_->visible()))
 453     return;
 454
 455   // Figure out the maximums for this scroll view.
 456   const int contents_max_x =
 457       std::max(contents_viewport_->width(), contents_->width());
 458   const int contents_max_y =
 459       std::max(contents_viewport_->height(), contents_->height());
 460
 461   // Make sure x and y are within the bounds of [0,contents_max_*].
 462   int x = std::max(0, std::min(contents_max_x, rect.x()));
 463   int y = std::max(0, std::min(contents_max_y, rect.y()));
 464
 465   // Figure out how far and down the rectangle will go taking width
 466   // and height into account.  This will be "clipped" by the viewport.
 467   const int max_x = std::min(contents_max_x,
 468       x + std::min(rect.width(), contents_viewport_->width()));
 469   const int max_y = std::min(contents_max_y,
 470       y + std::min(rect.height(), contents_viewport_->height()));
 471
 472   // See if the rect is already visible. Note the width is (max_x - x)
 473   // and the height is (max_y - y) to take into account the clipping of
 474   // either viewport or the content size.
 475   const gfx::Rect vis_rect = GetVisibleRect();
 476   if (vis_rect.Contains(gfx::Rect(x, y, max_x - x, max_y - y)))
 477     return;
 478
 479   // Shift contents_'s X and Y so that the region is visible. If we
 480   // need to shift up or left from where we currently are then we need
 481   // to get it so that the content appears in the upper/left
 482   // corner. This is done by setting the offset to -X or -Y.  For down
 483   // or right shifts we need to make sure it appears in the
 484   // lower/right corner. This is calculated by taking max_x or max_y
 485   // and scaling it back by the size of the viewport.
 486   const int new_x =
 487       (vis_rect.x() > x) ? x : std::max(0, max_x - contents_viewport_->width());
 488   const int new_y =
 489       (vis_rect.y() > y) ? y : std::max(0, max_y -
 490                                         contents_viewport_->height());
 491
 492   contents_->SetX(-new_x);
 493   if (header_)
 494     header_->SetX(-new_x);
 495   contents_->SetY(-new_y);
 496   UpdateScrollBarPositions();
 497 }
 498
 499 void ScrollView::ComputeScrollBarsVisibility(const gfx::Size& vp_size,
 500                                              const gfx::Size& content_size,
 501                                              bool* horiz_is_shown,
 502                                              bool* vert_is_shown) const {
 503   // Try to fit both ways first, then try vertical bar only, then horizontal
 504   // bar only, then defaults to both shown.
 505   if (content_size.width() <= vp_size.width() &&
 506       content_size.height() <= vp_size.height()) {
 507     *horiz_is_shown = false;
 508     *vert_is_shown = false;
 509   } else if (content_size.width() <= vp_size.width() - GetScrollBarWidth()) {
 510     *horiz_is_shown = false;
 511     *vert_is_shown = true;
 512   } else if (content_size.height() <= vp_size.height() - GetScrollBarHeight()) {
 513     *horiz_is_shown = true;
 514     *vert_is_shown = false;
 515   } else {
 516     *horiz_is_shown = true;
 517     *vert_is_shown = true;
 518   }
 519
 520   if (hide_horizontal_scrollbar_)
 521     *horiz_is_shown = false;
 522 }
 523
 524 // Make sure that a single scrollbar is created and visible as needed
 525 void ScrollView::SetControlVisibility(View* control, bool should_show) {
 526   if (!control)
 527     return;
 528   if (should_show) {
 529     if (!control->visible()) {
 530       AddChildView(control);
 531       control->SetVisible(true);
 532     }
 533   } else {
 534     RemoveChildView(control);
 535     control->SetVisible(false);
 536   }
 537 }
 538
 539 void ScrollView::UpdateScrollBarPositions() {
 540   if (!contents_)
 541     return;
 542
 543   if (horiz_sb_->visible()) {
 544     int vw = contents_viewport_->width();
 545     int cw = contents_->width();
 546     int origin = contents_->x();
 547     horiz_sb_->Update(vw, cw, -origin);
 548   }
 549   if (vert_sb_->visible()) {
 550     int vh = contents_viewport_->height();
 551     int ch = contents_->height();
 552     int origin = contents_->y();
 553     vert_sb_->Update(vh, ch, -origin);
 554   }
 555 }
 556
 557 // VariableRowHeightScrollHelper ----------------------------------------------
 558
 559 VariableRowHeightScrollHelper::VariableRowHeightScrollHelper(
 560     Controller* controller) : controller_(controller) {
 561 }
 562
 563 VariableRowHeightScrollHelper::~VariableRowHeightScrollHelper() {
 564 }
 565
 566 int VariableRowHeightScrollHelper::GetPageScrollIncrement(
 567     ScrollView* scroll_view, bool is_horizontal, bool is_positive) {
 568   if (is_horizontal)
 569     return 0;
 570   // y coordinate is most likely negative.
 571   int y = abs(scroll_view->contents()->y());
 572   int vis_height = scroll_view->contents()->parent()->height();
 573   if (is_positive) {
 574     // Align the bottom most row to the top of the view.
 575     int bottom = std::min(scroll_view->contents()->height() - 1,
 576                           y + vis_height);
 577     RowInfo bottom_row_info = GetRowInfo(bottom);
 578     // If 0, ScrollView will provide a default value.
 579     return std::max(0, bottom_row_info.origin - y);
 580   } else {
 581     // Align the row on the previous page to to the top of the view.
 582     int last_page_y = y - vis_height;
 583     RowInfo last_page_info = GetRowInfo(std::max(0, last_page_y));
 584     if (last_page_y != last_page_info.origin)
 585       return std::max(0, y - last_page_info.origin - last_page_info.height);
 586     return std::max(0, y - last_page_info.origin);
 587   }
 588 }
 589
 590 int VariableRowHeightScrollHelper::GetLineScrollIncrement(
 591     ScrollView* scroll_view, bool is_horizontal, bool is_positive) {
 592   if (is_horizontal)
 593     return 0;
 594   // y coordinate is most likely negative.
 595   int y = abs(scroll_view->contents()->y());
 596   RowInfo row = GetRowInfo(y);
 597   if (is_positive) {
 598     return row.height - (y - row.origin);
 599   } else if (y == row.origin) {
 600     row = GetRowInfo(std::max(0, row.origin - 1));
 601     return y - row.origin;
 602   } else {
 603     return y - row.origin;
 604   }
 605 }
 606
 607 VariableRowHeightScrollHelper::RowInfo
 608     VariableRowHeightScrollHelper::GetRowInfo(int y) {
 609   return controller_->GetRowInfo(y);
 610 }
 611
 612 // FixedRowHeightScrollHelper -----------------------------------------------
 613
 614 FixedRowHeightScrollHelper::FixedRowHeightScrollHelper(int top_margin,
 615                                                        int row_height)
 616     : VariableRowHeightScrollHelper(NULL),
 617       top_margin_(top_margin),
 618       row_height_(row_height) {
 619   DCHECK_GT(row_height, 0);
 620 }
 621
 622 VariableRowHeightScrollHelper::RowInfo
 623     FixedRowHeightScrollHelper::GetRowInfo(int y) {
 624   if (y < top_margin_)
 625     return RowInfo(0, top_margin_);
 626   return RowInfo((y - top_margin_) / row_height_ * row_height_ + top_margin_,
 627                  row_height_);
 628 }
 629
 630 }  // namespace views