Home | History | Annotate | Download | only in scrollbar 
      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
    518