Home | History | Annotate | Download | only in controls 
      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 "testing/gtest/include/gtest/gtest.h"
      8 #include "ui/views/controls/scrollbar/overlay_scroll_bar.h"
      9 #include "ui/views/test/test_views.h"
     10 
     11 namespace views {
     12 
     13 namespace {
     14 
     15 const int kWidth = 100;
     16 const int kMinHeight = 50;
     17 const int kMaxHeight = 100;
     18 
     19 // View implementation that allows setting the preferred size.
     20 class CustomView : public View {
     21  public:
     22   CustomView() {}
     23 
     24   void SetPreferredSize(const gfx::Size& size) {
     25     preferred_size_ = size;
     26     PreferredSizeChanged();
     27   }
     28 
     29   virtual gfx::Size GetPreferredSize() const OVERRIDE {
     30     return preferred_size_;
     31   }
     32 
     33   virtual void Layout() OVERRIDE {
     34     gfx::Size pref = GetPreferredSize();
     35     int width = pref.width();
     36     int height = pref.height();
     37     if (parent()) {
     38       width = std::max(parent()->width(), width);
     39       height = std::max(parent()->height(), height);
     40     }
     41     SetBounds(x(), y(), width, height);
     42   }
     43 
     44  private:
     45   gfx::Size preferred_size_;
     46 
     47   DISALLOW_COPY_AND_ASSIGN(CustomView);
     48 };
     49 
     50 }  // namespace
     51 
     52 // Verifies the viewport is sized to fit the available space.
     53 TEST(ScrollViewTest, ViewportSizedToFit) {
     54   ScrollView scroll_view;
     55   View* contents = new View;
     56   scroll_view.SetContents(contents);
     57   scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
     58   scroll_view.Layout();
     59   EXPECT_EQ("0,0 100x100", contents->parent()->bounds().ToString());
     60 }
     61 
     62 // Verifies the scrollbars are added as necessary.
     63 TEST(ScrollViewTest, ScrollBars) {
     64   ScrollView scroll_view;
     65   View* contents = new View;
     66   scroll_view.SetContents(contents);
     67   scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
     68 
     69   // Size the contents such that vertical scrollbar is needed.
     70   contents->SetBounds(0, 0, 50, 400);
     71   scroll_view.Layout();
     72   EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), contents->parent()->width());
     73   EXPECT_EQ(100, contents->parent()->height());
     74   EXPECT_TRUE(!scroll_view.horizontal_scroll_bar() ||
     75               !scroll_view.horizontal_scroll_bar()->visible());
     76   ASSERT_TRUE(scroll_view.vertical_scroll_bar() != NULL);
     77   EXPECT_TRUE(scroll_view.vertical_scroll_bar()->visible());
     78 
     79   // Size the contents such that horizontal scrollbar is needed.
     80   contents->SetBounds(0, 0, 400, 50);
     81   scroll_view.Layout();
     82   EXPECT_EQ(100, contents->parent()->width());
     83   EXPECT_EQ(100 - scroll_view.GetScrollBarHeight(),
     84             contents->parent()->height());
     85   ASSERT_TRUE(scroll_view.horizontal_scroll_bar() != NULL);
     86   EXPECT_TRUE(scroll_view.horizontal_scroll_bar()->visible());
     87   EXPECT_TRUE(!scroll_view.vertical_scroll_bar() ||
     88               !scroll_view.vertical_scroll_bar()->visible());
     89 
     90   // Both horizontal and vertical.
     91   contents->SetBounds(0, 0, 300, 400);
     92   scroll_view.Layout();
     93   EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), contents->parent()->width());
     94   EXPECT_EQ(100 - scroll_view.GetScrollBarHeight(),
     95             contents->parent()->height());
     96   ASSERT_TRUE(scroll_view.horizontal_scroll_bar() != NULL);
     97   EXPECT_TRUE(scroll_view.horizontal_scroll_bar()->visible());
     98   ASSERT_TRUE(scroll_view.vertical_scroll_bar() != NULL);
     99   EXPECT_TRUE(scroll_view.vertical_scroll_bar()->visible());
    100 }
    101 
    102 // Assertions around adding a header.
    103 TEST(ScrollViewTest, Header) {
    104   ScrollView scroll_view;
    105   View* contents = new View;
    106   CustomView* header = new CustomView;
    107   scroll_view.SetHeader(header);
    108   View* header_parent = header->parent();
    109   scroll_view.SetContents(contents);
    110   scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
    111   scroll_view.Layout();
    112   // |header|s preferred size is empty, which should result in all space going
    113   // to contents.
    114   EXPECT_EQ("0,0 100x0", header->parent()->bounds().ToString());
    115   EXPECT_EQ("0,0 100x100", contents->parent()->bounds().ToString());
    116 
    117   // Get the header a height of 20.
    118   header->SetPreferredSize(gfx::Size(10, 20));
    119   EXPECT_EQ("0,0 100x20", header->parent()->bounds().ToString());
    120   EXPECT_EQ("0,20 100x80", contents->parent()->bounds().ToString());
    121 
    122   // Remove the header.
    123   scroll_view.SetHeader(NULL);
    124   // SetHeader(NULL) deletes header.
    125   header = NULL;
    126   EXPECT_EQ("0,0 100x0", header_parent->bounds().ToString());
    127   EXPECT_EQ("0,0 100x100", contents->parent()->bounds().ToString());
    128 }
    129 
    130 // Verifies the scrollbars are added as necessary when a header is present.
    131 TEST(ScrollViewTest, ScrollBarsWithHeader) {
    132   ScrollView scroll_view;
    133   View* contents = new View;
    134   scroll_view.SetContents(contents);
    135   CustomView* header = new CustomView;
    136   scroll_view.SetHeader(header);
    137   scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
    138 
    139   header->SetPreferredSize(gfx::Size(10, 20));
    140 
    141   // Size the contents such that vertical scrollbar is needed.
    142   contents->SetBounds(0, 0, 50, 400);
    143   scroll_view.Layout();
    144   EXPECT_EQ(0, contents->parent()->x());
    145   EXPECT_EQ(20, contents->parent()->y());
    146   EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), contents->parent()->width());
    147   EXPECT_EQ(80, contents->parent()->height());
    148   EXPECT_EQ(0, header->parent()->x());
    149   EXPECT_EQ(0, header->parent()->y());
    150   EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), header->parent()->width());
    151   EXPECT_EQ(20, header->parent()->height());
    152   EXPECT_TRUE(!scroll_view.horizontal_scroll_bar() ||
    153               !scroll_view.horizontal_scroll_bar()->visible());
    154   ASSERT_TRUE(scroll_view.vertical_scroll_bar() != NULL);
    155   EXPECT_TRUE(scroll_view.vertical_scroll_bar()->visible());
    156 
    157   // Size the contents such that horizontal scrollbar is needed.
    158   contents->SetBounds(0, 0, 400, 50);
    159   scroll_view.Layout();
    160   EXPECT_EQ(0, contents->parent()->x());
    161   EXPECT_EQ(20, contents->parent()->y());
    162   EXPECT_EQ(100, contents->parent()->width());
    163   EXPECT_EQ(100 - scroll_view.GetScrollBarHeight() - 20,
    164             contents->parent()->height());
    165   EXPECT_EQ(0, header->parent()->x());
    166   EXPECT_EQ(0, header->parent()->y());
    167   EXPECT_EQ(100, header->parent()->width());
    168   EXPECT_EQ(20, header->parent()->height());
    169   ASSERT_TRUE(scroll_view.horizontal_scroll_bar() != NULL);
    170   EXPECT_TRUE(scroll_view.horizontal_scroll_bar()->visible());
    171   EXPECT_TRUE(!scroll_view.vertical_scroll_bar() ||
    172               !scroll_view.vertical_scroll_bar()->visible());
    173 
    174   // Both horizontal and vertical.
    175   contents->SetBounds(0, 0, 300, 400);
    176   scroll_view.Layout();
    177   EXPECT_EQ(0, contents->parent()->x());
    178   EXPECT_EQ(20, contents->parent()->y());
    179   EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), contents->parent()->width());
    180   EXPECT_EQ(100 - scroll_view.GetScrollBarHeight() - 20,
    181             contents->parent()->height());
    182   EXPECT_EQ(0, header->parent()->x());
    183   EXPECT_EQ(0, header->parent()->y());
    184   EXPECT_EQ(100 - scroll_view.GetScrollBarWidth(), header->parent()->width());
    185   EXPECT_EQ(20, header->parent()->height());
    186   ASSERT_TRUE(scroll_view.horizontal_scroll_bar() != NULL);
    187   EXPECT_TRUE(scroll_view.horizontal_scroll_bar()->visible());
    188   ASSERT_TRUE(scroll_view.vertical_scroll_bar() != NULL);
    189   EXPECT_TRUE(scroll_view.vertical_scroll_bar()->visible());
    190 }
    191 
    192 // Verifies the header scrolls horizontally with the content.
    193 TEST(ScrollViewTest, HeaderScrollsWithContent) {
    194   ScrollView scroll_view;
    195   CustomView* contents = new CustomView;
    196   scroll_view.SetContents(contents);
    197   contents->SetPreferredSize(gfx::Size(500, 500));
    198 
    199   CustomView* header = new CustomView;
    200   scroll_view.SetHeader(header);
    201   header->SetPreferredSize(gfx::Size(500, 20));
    202 
    203   scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
    204   EXPECT_EQ("0,0", contents->bounds().origin().ToString());
    205   EXPECT_EQ("0,0", header->bounds().origin().ToString());
    206 
    207   // Scroll the horizontal scrollbar.
    208   ASSERT_TRUE(scroll_view.horizontal_scroll_bar());
    209   scroll_view.ScrollToPosition(
    210       const_cast<ScrollBar*>(scroll_view.horizontal_scroll_bar()), 1);
    211   EXPECT_EQ("-1,0", contents->bounds().origin().ToString());
    212   EXPECT_EQ("-1,0", header->bounds().origin().ToString());
    213 
    214   // Scrolling the vertical scrollbar shouldn't effect the header.
    215   ASSERT_TRUE(scroll_view.vertical_scroll_bar());
    216   scroll_view.ScrollToPosition(
    217       const_cast<ScrollBar*>(scroll_view.vertical_scroll_bar()), 1);
    218   EXPECT_EQ("-1,-1", contents->bounds().origin().ToString());
    219   EXPECT_EQ("-1,0", header->bounds().origin().ToString());
    220 }
    221 
    222 // Verifies ScrollRectToVisible() on the child works.
    223 TEST(ScrollViewTest, ScrollRectToVisible) {
    224   ScrollView scroll_view;
    225   CustomView* contents = new CustomView;
    226   scroll_view.SetContents(contents);
    227   contents->SetPreferredSize(gfx::Size(500, 1000));
    228 
    229   scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
    230   scroll_view.Layout();
    231   EXPECT_EQ("0,0", contents->bounds().origin().ToString());
    232 
    233   // Scroll to y=405 height=10, this should make the y position of the content
    234   // at (405 + 10) - viewport_height (scroll region bottom aligned).
    235   contents->ScrollRectToVisible(gfx::Rect(0, 405, 10, 10));
    236   const int viewport_height = contents->parent()->height();
    237   EXPECT_EQ(-(415 - viewport_height), contents->y());
    238 
    239   // Scroll to the current y-location and 10x10; should do nothing.
    240   contents->ScrollRectToVisible(gfx::Rect(0, -contents->y(), 10, 10));
    241   EXPECT_EQ(-(415 - viewport_height), contents->y());
    242 }
    243 
    244 // Verifies ClipHeightTo() uses the height of the content when it is between the
    245 // minimum and maximum height values.
    246 TEST(ScrollViewTest, ClipHeightToNormalContentHeight) {
    247   ScrollView scroll_view;
    248 
    249   scroll_view.ClipHeightTo(kMinHeight, kMaxHeight);
    250 
    251   const int kNormalContentHeight = 75;
    252   scroll_view.SetContents(
    253       new views::StaticSizedView(gfx::Size(kWidth, kNormalContentHeight)));
    254 
    255   EXPECT_EQ(gfx::Size(kWidth, kNormalContentHeight),
    256             scroll_view.GetPreferredSize());
    257 
    258   scroll_view.SizeToPreferredSize();
    259   scroll_view.Layout();
    260 
    261   EXPECT_EQ(gfx::Size(kWidth, kNormalContentHeight),
    262             scroll_view.contents()->size());
    263   EXPECT_EQ(gfx::Size(kWidth, kNormalContentHeight), scroll_view.size());
    264 }
    265 
    266 // Verifies ClipHeightTo() uses the minimum height when the content is shorter
    267 // thamn the minimum height value.
    268 TEST(ScrollViewTest, ClipHeightToShortContentHeight) {
    269   ScrollView scroll_view;
    270 
    271   scroll_view.ClipHeightTo(kMinHeight, kMaxHeight);
    272 
    273   const int kShortContentHeight = 10;
    274   scroll_view.SetContents(
    275       new views::StaticSizedView(gfx::Size(kWidth, kShortContentHeight)));
    276 
    277   EXPECT_EQ(gfx::Size(kWidth, kMinHeight), scroll_view.GetPreferredSize());
    278 
    279   scroll_view.SizeToPreferredSize();
    280   scroll_view.Layout();
    281 
    282   EXPECT_EQ(gfx::Size(kWidth, kShortContentHeight),
    283             scroll_view.contents()->size());
    284   EXPECT_EQ(gfx::Size(kWidth, kMinHeight), scroll_view.size());
    285 }
    286 
    287 // Verifies ClipHeightTo() uses the maximum height when the content is longer
    288 // thamn the maximum height value.
    289 TEST(ScrollViewTest, ClipHeightToTallContentHeight) {
    290   ScrollView scroll_view;
    291 
    292   // Use a scrollbar that is disabled by default, so the width of the content is
    293   // not affected.
    294   scroll_view.SetVerticalScrollBar(new views::OverlayScrollBar(false));
    295 
    296   scroll_view.ClipHeightTo(kMinHeight, kMaxHeight);
    297 
    298   const int kTallContentHeight = 1000;
    299   scroll_view.SetContents(
    300       new views::StaticSizedView(gfx::Size(kWidth, kTallContentHeight)));
    301 
    302   EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view.GetPreferredSize());
    303 
    304   scroll_view.SizeToPreferredSize();
    305   scroll_view.Layout();
    306 
    307   EXPECT_EQ(gfx::Size(kWidth, kTallContentHeight),
    308             scroll_view.contents()->size());
    309   EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view.size());
    310 }
    311 
    312 // Verifies that when ClipHeightTo() produces a scrollbar, it reduces the width
    313 // of the inner content of the ScrollView.
    314 TEST(ScrollViewTest, ClipHeightToScrollbarUsesWidth) {
    315   ScrollView scroll_view;
    316 
    317   scroll_view.ClipHeightTo(kMinHeight, kMaxHeight);
    318 
    319   // Create a view that will be much taller than it is wide.
    320   scroll_view.SetContents(new views::ProportionallySizedView(1000));
    321 
    322   // Without any width, it will default to 0,0 but be overridden by min height.
    323   scroll_view.SizeToPreferredSize();
    324   EXPECT_EQ(gfx::Size(0, kMinHeight), scroll_view.GetPreferredSize());
    325 
    326   gfx::Size new_size(kWidth, scroll_view.GetHeightForWidth(kWidth));
    327   scroll_view.SetSize(new_size);
    328   scroll_view.Layout();
    329 
    330   int scroll_bar_width = scroll_view.GetScrollBarWidth();
    331   int expected_width = kWidth - scroll_bar_width;
    332   EXPECT_EQ(scroll_view.contents()->size().width(), expected_width);
    333   EXPECT_EQ(scroll_view.contents()->size().height(), 1000 * expected_width);
    334   EXPECT_EQ(gfx::Size(kWidth, kMaxHeight), scroll_view.size());
    335 }
    336 
    337 TEST(ScrollViewTest, CornerViewVisibility) {
    338   ScrollView scroll_view;
    339   View* contents = new View;
    340   scroll_view.SetContents(contents);
    341   scroll_view.SetBoundsRect(gfx::Rect(0, 0, 100, 100));
    342   View* corner_view = scroll_view.corner_view_;
    343 
    344   // Corner view should be visible when both scrollbars are visible.
    345   contents->SetBounds(0, 0, 200, 200);
    346   scroll_view.Layout();
    347   EXPECT_EQ(&scroll_view, corner_view->parent());
    348   EXPECT_TRUE(corner_view->visible());
    349 
    350   // Corner view should be aligned to the scrollbars.
    351   EXPECT_EQ(scroll_view.vertical_scroll_bar()->x(), corner_view->x());
    352   EXPECT_EQ(scroll_view.horizontal_scroll_bar()->y(), corner_view->y());
    353   EXPECT_EQ(scroll_view.GetScrollBarWidth(), corner_view->width());
    354   EXPECT_EQ(scroll_view.GetScrollBarHeight(), corner_view->height());
    355 
    356   // Corner view should be removed when only the vertical scrollbar is visible.
    357   contents->SetBounds(0, 0, 50, 200);
    358   scroll_view.Layout();
    359   EXPECT_FALSE(corner_view->parent());
    360 
    361   // ... or when only the horizontal scrollbar is visible.
    362   contents->SetBounds(0, 0, 200, 50);
    363   scroll_view.Layout();
    364   EXPECT_FALSE(corner_view->parent());
    365 
    366   // ... or when no scrollbar is visible.
    367   contents->SetBounds(0, 0, 50, 50);
    368   scroll_view.Layout();
    369   EXPECT_FALSE(corner_view->parent());
    370 
    371   // Corner view should reappear when both scrollbars reappear.
    372   contents->SetBounds(0, 0, 200, 200);
    373   scroll_view.Layout();
    374   EXPECT_EQ(&scroll_view, corner_view->parent());
    375   EXPECT_TRUE(corner_view->visible());
    376 }
    377 
    378 }  // namespace views
    379