ui/views/controls/scrollbar/base_scroll_bar.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/scrollbar/base_scroll_bar.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/strings/string16.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "build/build_config.h"
  15 #include "ui/base/l10n/l10n_util.h"
  16 #include "ui/events/event.h"
  17 #include "ui/events/keycodes/keyboard_codes.h"
  18 #include "ui/gfx/canvas.h"
  19 #include "ui/gfx/geometry/safe_integer_conversions.h"
  20 #include "ui/strings/grit/ui_strings.h"
  21 #include "ui/views/controls/menu/menu_item_view.h"
  22 #include "ui/views/controls/menu/menu_runner.h"
  23 #include "ui/views/controls/scroll_view.h"
  24 #include "ui/views/controls/scrollbar/base_scroll_bar_thumb.h"
  25 #include "ui/views/widget/widget.h"
  26
  27 #if defined(OS_LINUX)
  28 #include "ui/gfx/screen.h"
  29 #endif
  30
  31 #undef min
  32 #undef max
  33
  34 namespace views {
  35
  36 ///////////////////////////////////////////////////////////////////////////////
  37 // BaseScrollBar, public:
  38
  39 BaseScrollBar::BaseScrollBar(bool horizontal, BaseScrollBarThumb* thumb)
  40     : ScrollBar(horizontal),
  41       thumb_(thumb),
  42       contents_size_(0),
  43       contents_scroll_offset_(0),
  44       viewport_size_(0),
  45       thumb_track_state_(CustomButton::STATE_NORMAL),
  46       last_scroll_amount_(SCROLL_NONE),
  47       repeater_(base::Bind(&BaseScrollBar::TrackClicked,
  48                            base::Unretained(this))),
  49       context_menu_mouse_position_(0) {
  50   AddChildView(thumb_);
  51
  52   set_context_menu_controller(this);
  53   thumb_->set_context_menu_controller(this);
  54 }
  55
  56 void BaseScrollBar::ScrollByAmount(ScrollAmount amount) {
  57   int offset = contents_scroll_offset_;
  58   switch (amount) {
  59     case SCROLL_START:
  60       offset = GetMinPosition();
  61       break;
  62     case SCROLL_END:
  63       offset = GetMaxPosition();
  64       break;
  65     case SCROLL_PREV_LINE:
  66       offset -= GetScrollIncrement(false, false);
  67       offset = std::max(GetMinPosition(), offset);
  68       break;
  69     case SCROLL_NEXT_LINE:
  70       offset += GetScrollIncrement(false, true);
  71       offset = std::min(GetMaxPosition(), offset);
  72       break;
  73     case SCROLL_PREV_PAGE:
  74       offset -= GetScrollIncrement(true, false);
  75       offset = std::max(GetMinPosition(), offset);
  76       break;
  77     case SCROLL_NEXT_PAGE:
  78       offset += GetScrollIncrement(true, true);
  79       offset = std::min(GetMaxPosition(), offset);
  80       break;
  81     default:
  82       break;
  83   }
  84   contents_scroll_offset_ = offset;
  85   ScrollContentsToOffset();
  86 }
  87
  88 BaseScrollBar::~BaseScrollBar() {
  89 }
  90
  91 void BaseScrollBar::ScrollToThumbPosition(int thumb_position,
  92                                           bool scroll_to_middle) {
  93   contents_scroll_offset_ =
  94       CalculateContentsOffset(thumb_position, scroll_to_middle);
  95   if (contents_scroll_offset_ < GetMinPosition()) {
  96     contents_scroll_offset_ = GetMinPosition();
  97   } else if (contents_scroll_offset_ > GetMaxPosition()) {
  98     contents_scroll_offset_ = GetMaxPosition();
  99   }
 100   ScrollContentsToOffset();
 101   SchedulePaint();
 102 }
 103
 104 bool BaseScrollBar::ScrollByContentsOffset(int contents_offset) {
 105   int old_offset = contents_scroll_offset_;
 106   contents_scroll_offset_ -= contents_offset;
 107   if (contents_scroll_offset_ < GetMinPosition()) {
 108     contents_scroll_offset_ = GetMinPosition();
 109   } else if (contents_scroll_offset_ > GetMaxPosition()) {
 110     contents_scroll_offset_ = GetMaxPosition();
 111   }
 112   if (old_offset == contents_scroll_offset_)
 113     return false;
 114
 115   ScrollContentsToOffset();
 116   return true;
 117 }
 118
 119 void BaseScrollBar::OnThumbStateChanged(CustomButton::ButtonState old_state,
 120                                         CustomButton::ButtonState new_state) {
 121   if (old_state == CustomButton::STATE_PRESSED &&
 122       new_state == CustomButton::STATE_NORMAL &&
 123       GetThumbTrackState() == CustomButton::STATE_HOVERED) {
 124     SetThumbTrackState(CustomButton::STATE_NORMAL);
 125   }
 126 }
 127
 128 ///////////////////////////////////////////////////////////////////////////////
 129 // BaseScrollBar, View implementation:
 130
 131 bool BaseScrollBar::OnMousePressed(const ui::MouseEvent& event) {
 132   if (event.IsOnlyLeftMouseButton())
 133     ProcessPressEvent(event);
 134   return true;
 135 }
 136
 137 void BaseScrollBar::OnMouseReleased(const ui::MouseEvent& event) {
 138   SetState(HitTestPoint(event.location()) ?
 139            CustomButton::STATE_HOVERED : CustomButton::STATE_NORMAL);
 140 }
 141
 142 void BaseScrollBar::OnMouseCaptureLost() {
 143   SetState(CustomButton::STATE_NORMAL);
 144 }
 145
 146 void BaseScrollBar::OnMouseEntered(const ui::MouseEvent& event) {
 147   SetThumbTrackState(CustomButton::STATE_HOVERED);
 148 }
 149
 150 void BaseScrollBar::OnMouseExited(const ui::MouseEvent& event) {
 151   if (GetThumbTrackState() == CustomButton::STATE_HOVERED)
 152     SetState(CustomButton::STATE_NORMAL);
 153 }
 154
 155 bool BaseScrollBar::OnKeyPressed(const ui::KeyEvent& event) {
 156   ScrollAmount amount = SCROLL_NONE;
 157   switch (event.key_code()) {
 158     case ui::VKEY_UP:
 159       if (!IsHorizontal())
 160         amount = SCROLL_PREV_LINE;
 161       break;
 162     case ui::VKEY_DOWN:
 163       if (!IsHorizontal())
 164         amount = SCROLL_NEXT_LINE;
 165       break;
 166     case ui::VKEY_LEFT:
 167       if (IsHorizontal())
 168         amount = SCROLL_PREV_LINE;
 169       break;
 170     case ui::VKEY_RIGHT:
 171       if (IsHorizontal())
 172         amount = SCROLL_NEXT_LINE;
 173       break;
 174     case ui::VKEY_PRIOR:
 175       amount = SCROLL_PREV_PAGE;
 176       break;
 177     case ui::VKEY_NEXT:
 178       amount = SCROLL_NEXT_PAGE;
 179       break;
 180     case ui::VKEY_HOME:
 181       amount = SCROLL_START;
 182       break;
 183     case ui::VKEY_END:
 184       amount = SCROLL_END;
 185       break;
 186     default:
 187       break;
 188   }
 189   if (amount != SCROLL_NONE) {
 190     ScrollByAmount(amount);
 191     return true;
 192   }
 193   return false;
 194 }
 195
 196 bool BaseScrollBar::OnMouseWheel(const ui::MouseWheelEvent& event) {
 197   OnScroll(event.x_offset(), event.y_offset());
 198   return true;
 199 }
 200
 201 void BaseScrollBar::OnGestureEvent(ui::GestureEvent* event) {
 202   // If a fling is in progress, then stop the fling for any incoming gesture
 203   // event (except for the GESTURE_END event that is generated at the end of the
 204   // fling).
 205   if (scroll_animator_.get() && scroll_animator_->is_scrolling() &&
 206       (event->type() != ui::ET_GESTURE_END ||
 207        event->details().touch_points() > 1)) {
 208     scroll_animator_->Stop();
 209   }
 210
 211   if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
 212     ProcessPressEvent(*event);
 213     event->SetHandled();
 214     return;
 215   }
 216
 217   if (event->type() == ui::ET_GESTURE_LONG_PRESS) {
 218     // For a long-press, the repeater started in tap-down should continue. So
 219     // return early.
 220     return;
 221   }
 222
 223   SetState(CustomButton::STATE_NORMAL);
 224
 225   if (event->type() == ui::ET_GESTURE_TAP) {
 226     // TAP_DOWN would have already scrolled some amount. So scrolling again on
 227     // TAP is not necessary.
 228     event->SetHandled();
 229     return;
 230   }
 231
 232   if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
 233       event->type() == ui::ET_GESTURE_SCROLL_END) {
 234     event->SetHandled();
 235     return;
 236   }
 237
 238   if (event->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
 239     float scroll_amount_f;
 240     int scroll_amount;
 241     if (IsHorizontal()) {
 242       scroll_amount_f = event->details().scroll_x() - roundoff_error_.x();
 243       scroll_amount = gfx::ToRoundedInt(scroll_amount_f);
 244       roundoff_error_.set_x(scroll_amount - scroll_amount_f);
 245     } else {
 246       scroll_amount_f = event->details().scroll_y() - roundoff_error_.y();
 247       scroll_amount = gfx::ToRoundedInt(scroll_amount_f);
 248       roundoff_error_.set_y(scroll_amount - scroll_amount_f);
 249     }
 250     if (ScrollByContentsOffset(scroll_amount))
 251       event->SetHandled();
 252     return;
 253   }
 254
 255   if (event->type() == ui::ET_SCROLL_FLING_START) {
 256     if (!scroll_animator_.get())
 257       scroll_animator_.reset(new ScrollAnimator(this));
 258     scroll_animator_->Start(
 259         IsHorizontal() ?  event->details().velocity_x() : 0.f,
 260         IsHorizontal() ? 0.f : event->details().velocity_y());
 261     event->SetHandled();
 262   }
 263 }
 264
 265 ///////////////////////////////////////////////////////////////////////////////
 266 // BaseScrollBar, ScrollDelegate implementation:
 267
 268 bool BaseScrollBar::OnScroll(float dx, float dy) {
 269   return IsHorizontal() ? ScrollByContentsOffset(dx) :
 270                           ScrollByContentsOffset(dy);
 271 }
 272
 273 ///////////////////////////////////////////////////////////////////////////////
 274 // BaseScrollBar, ContextMenuController implementation:
 275
 276 enum ScrollBarContextMenuCommands {
 277   ScrollBarContextMenuCommand_ScrollHere = 1,
 278   ScrollBarContextMenuCommand_ScrollStart,
 279   ScrollBarContextMenuCommand_ScrollEnd,
 280   ScrollBarContextMenuCommand_ScrollPageUp,
 281   ScrollBarContextMenuCommand_ScrollPageDown,
 282   ScrollBarContextMenuCommand_ScrollPrev,
 283   ScrollBarContextMenuCommand_ScrollNext
 284 };
 285
 286 void BaseScrollBar::ShowContextMenuForView(View* source,
 287                                            const gfx::Point& p,
 288                                            ui::MenuSourceType source_type) {
 289   Widget* widget = GetWidget();
 290   gfx::Rect widget_bounds = widget->GetWindowBoundsInScreen();
 291   gfx::Point temp_pt(p.x() - widget_bounds.x(), p.y() - widget_bounds.y());
 292   View::ConvertPointFromWidget(this, &temp_pt);
 293   context_menu_mouse_position_ = IsHorizontal() ? temp_pt.x() : temp_pt.y();
 294
 295   views::MenuItemView* menu = new views::MenuItemView(this);
 296   // MenuRunner takes ownership of |menu|.
 297   menu_runner_.reset(new MenuRunner(
 298       menu, MenuRunner::HAS_MNEMONICS | views::MenuRunner::CONTEXT_MENU));
 299   menu->AppendDelegateMenuItem(ScrollBarContextMenuCommand_ScrollHere);
 300   menu->AppendSeparator();
 301   menu->AppendDelegateMenuItem(ScrollBarContextMenuCommand_ScrollStart);
 302   menu->AppendDelegateMenuItem(ScrollBarContextMenuCommand_ScrollEnd);
 303   menu->AppendSeparator();
 304   menu->AppendDelegateMenuItem(ScrollBarContextMenuCommand_ScrollPageUp);
 305   menu->AppendDelegateMenuItem(ScrollBarContextMenuCommand_ScrollPageDown);
 306   menu->AppendSeparator();
 307   menu->AppendDelegateMenuItem(ScrollBarContextMenuCommand_ScrollPrev);
 308   menu->AppendDelegateMenuItem(ScrollBarContextMenuCommand_ScrollNext);
 309   if (menu_runner_->RunMenuAt(GetWidget(),
 310                               NULL,
 311                               gfx::Rect(p, gfx::Size()),
 312                               MENU_ANCHOR_TOPLEFT,
 313                               source_type) == MenuRunner::MENU_DELETED) {
 314     return;
 315   }
 316 }
 317
 318 ///////////////////////////////////////////////////////////////////////////////
 319 // BaseScrollBar, Menu::Delegate implementation:
 320
 321 base::string16 BaseScrollBar::GetLabel(int id) const {
 322   int ids_value = 0;
 323   switch (id) {
 324     case ScrollBarContextMenuCommand_ScrollHere:
 325       ids_value = IDS_APP_SCROLLBAR_CXMENU_SCROLLHERE;
 326       break;
 327     case ScrollBarContextMenuCommand_ScrollStart:
 328       ids_value = IsHorizontal() ? IDS_APP_SCROLLBAR_CXMENU_SCROLLLEFTEDGE
 329                                  : IDS_APP_SCROLLBAR_CXMENU_SCROLLHOME;
 330       break;
 331     case ScrollBarContextMenuCommand_ScrollEnd:
 332       ids_value = IsHorizontal() ? IDS_APP_SCROLLBAR_CXMENU_SCROLLRIGHTEDGE
 333                                  : IDS_APP_SCROLLBAR_CXMENU_SCROLLEND;
 334       break;
 335     case ScrollBarContextMenuCommand_ScrollPageUp:
 336       ids_value = IDS_APP_SCROLLBAR_CXMENU_SCROLLPAGEUP;
 337       break;
 338     case ScrollBarContextMenuCommand_ScrollPageDown:
 339       ids_value = IDS_APP_SCROLLBAR_CXMENU_SCROLLPAGEDOWN;
 340       break;
 341     case ScrollBarContextMenuCommand_ScrollPrev:
 342       ids_value = IsHorizontal() ? IDS_APP_SCROLLBAR_CXMENU_SCROLLLEFT
 343                                  : IDS_APP_SCROLLBAR_CXMENU_SCROLLUP;
 344       break;
 345     case ScrollBarContextMenuCommand_ScrollNext:
 346       ids_value = IsHorizontal() ? IDS_APP_SCROLLBAR_CXMENU_SCROLLRIGHT
 347                                  : IDS_APP_SCROLLBAR_CXMENU_SCROLLDOWN;
 348       break;
 349     default:
 350       NOTREACHED() << "Invalid BaseScrollBar Context Menu command!";
 351   }
 352
 353   return ids_value ? l10n_util::GetStringUTF16(ids_value) : base::string16();
 354 }
 355
 356 bool BaseScrollBar::IsCommandEnabled(int id) const {
 357   switch (id) {
 358     case ScrollBarContextMenuCommand_ScrollPageUp:
 359     case ScrollBarContextMenuCommand_ScrollPageDown:
 360       return !IsHorizontal();
 361   }
 362   return true;
 363 }
 364
 365 void BaseScrollBar::ExecuteCommand(int id) {
 366   switch (id) {
 367     case ScrollBarContextMenuCommand_ScrollHere:
 368       ScrollToThumbPosition(context_menu_mouse_position_, true);
 369       break;
 370     case ScrollBarContextMenuCommand_ScrollStart:
 371       ScrollByAmount(SCROLL_START);
 372       break;
 373     case ScrollBarContextMenuCommand_ScrollEnd:
 374       ScrollByAmount(SCROLL_END);
 375       break;
 376     case ScrollBarContextMenuCommand_ScrollPageUp:
 377       ScrollByAmount(SCROLL_PREV_PAGE);
 378       break;
 379     case ScrollBarContextMenuCommand_ScrollPageDown:
 380       ScrollByAmount(SCROLL_NEXT_PAGE);
 381       break;
 382     case ScrollBarContextMenuCommand_ScrollPrev:
 383       ScrollByAmount(SCROLL_PREV_LINE);
 384       break;
 385     case ScrollBarContextMenuCommand_ScrollNext:
 386       ScrollByAmount(SCROLL_NEXT_LINE);
 387       break;
 388   }
 389 }
 390
 391 ///////////////////////////////////////////////////////////////////////////////
 392 // BaseScrollBar, ScrollBar implementation:
 393
 394 void BaseScrollBar::Update(int viewport_size,
 395                            int content_size,
 396                            int contents_scroll_offset) {
 397   ScrollBar::Update(viewport_size, content_size, contents_scroll_offset);
 398
 399   // Make sure contents_size is always > 0 to avoid divide by zero errors in
 400   // calculations throughout this code.
 401   contents_size_ = std::max(1, content_size);
 402
 403   viewport_size_ = std::max(1, viewport_size);
 404
 405   if (content_size < 0)
 406     content_size = 0;
 407   if (contents_scroll_offset < 0)
 408     contents_scroll_offset = 0;
 409   if (contents_scroll_offset > content_size)
 410     contents_scroll_offset = content_size;
 411   contents_scroll_offset_ = contents_scroll_offset;
 412
 413   // Thumb Height and Thumb Pos.
 414   // The height of the thumb is the ratio of the Viewport height to the
 415   // content size multiplied by the height of the thumb track.
 416   double ratio = static_cast<double>(viewport_size) / contents_size_;
 417   int thumb_size = static_cast<int>(ratio * GetTrackSize());
 418   thumb_->SetSize(thumb_size);
 419
 420   int thumb_position = CalculateThumbPosition(contents_scroll_offset);
 421   thumb_->SetPosition(thumb_position);
 422 }
 423
 424 int BaseScrollBar::GetPosition() const {
 425   return thumb_->GetPosition();
 426 }
 427
 428 ///////////////////////////////////////////////////////////////////////////////
 429 // BaseScrollBar, protected:
 430
 431 BaseScrollBarThumb* BaseScrollBar::GetThumb() const {
 432   return thumb_;
 433 }
 434
 435 CustomButton::ButtonState BaseScrollBar::GetThumbTrackState() const {
 436   return thumb_track_state_;
 437 }
 438
 439 void BaseScrollBar::ScrollToPosition(int position) {
 440   controller()->ScrollToPosition(this, position);
 441 }
 442
 443 int BaseScrollBar::GetScrollIncrement(bool is_page, bool is_positive) {
 444   return controller()->GetScrollIncrement(this, is_page, is_positive);
 445 }
 446
 447 ///////////////////////////////////////////////////////////////////////////////
 448 // BaseScrollBar, private:
 449
 450 int BaseScrollBar::GetThumbSizeForTest() {
 451   return thumb_->GetSize();
 452 }
 453
 454 void BaseScrollBar::ProcessPressEvent(const ui::LocatedEvent& event) {
 455   SetThumbTrackState(CustomButton::STATE_PRESSED);
 456   gfx::Rect thumb_bounds = thumb_->bounds();
 457   if (IsHorizontal()) {
 458     if (GetMirroredXInView(event.x()) < thumb_bounds.x()) {
 459       last_scroll_amount_ = SCROLL_PREV_PAGE;
 460     } else if (GetMirroredXInView(event.x()) > thumb_bounds.right()) {
 461       last_scroll_amount_ = SCROLL_NEXT_PAGE;
 462     }
 463   } else {
 464     if (event.y() < thumb_bounds.y()) {
 465       last_scroll_amount_ = SCROLL_PREV_PAGE;
 466     } else if (event.y() > thumb_bounds.bottom()) {
 467       last_scroll_amount_ = SCROLL_NEXT_PAGE;
 468     }
 469   }
 470   TrackClicked();
 471   repeater_.Start();
 472 }
 473
 474 void BaseScrollBar::SetState(CustomButton::ButtonState state) {
 475   SetThumbTrackState(state);
 476   repeater_.Stop();
 477 }
 478
 479 void BaseScrollBar::TrackClicked() {
 480   if (last_scroll_amount_ != SCROLL_NONE)
 481     ScrollByAmount(last_scroll_amount_);
 482 }
 483
 484 void BaseScrollBar::ScrollContentsToOffset() {
 485   ScrollToPosition(contents_scroll_offset_);
 486   thumb_->SetPosition(CalculateThumbPosition(contents_scroll_offset_));
 487 }
 488
 489 int BaseScrollBar::GetTrackSize() const {
 490   gfx::Rect track_bounds = GetTrackBounds();
 491   return IsHorizontal() ? track_bounds.width() : track_bounds.height();
 492 }
 493
 494 int BaseScrollBar::CalculateThumbPosition(int contents_scroll_offset) const {
 495   // In some combination of viewport_size and contents_size_, the result of
 496   // simple division can be rounded and there could be 1 pixel gap even when the
 497   // contents scroll down to the bottom. See crbug.com/244671
 498   if (contents_scroll_offset + viewport_size_ == contents_size_) {
 499     int track_size = GetTrackSize();
 500     return track_size - (viewport_size_ * GetTrackSize() / contents_size_);
 501   }
 502   return (contents_scroll_offset * GetTrackSize()) / contents_size_;
 503 }
 504
 505 int BaseScrollBar::CalculateContentsOffset(int thumb_position,
 506                                            bool scroll_to_middle) const {
 507   if (scroll_to_middle)
 508     thumb_position = thumb_position - (thumb_->GetSize() / 2);
 509   return (thumb_position * contents_size_) / GetTrackSize();
 510 }
 511
 512 void BaseScrollBar::SetThumbTrackState(CustomButton::ButtonState state) {
 513   thumb_track_state_ = state;
 514   SchedulePaint();
 515 }
 516
 517 }  // namespace views