| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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/window/custom_frame_view.h" | |
| 6 | |
| 7 #include <vector> | |
| 8 | |
| 9 #include "ui/views/controls/button/image_button.h" | |
| 10 #include "ui/views/test/views_test_base.h" | |
| 11 #include "ui/views/widget/widget.h" | |
| 12 #include "ui/views/widget/widget_delegate.h" | |
| 13 #include "ui/views/window/window_button_order_provider.h" | |
| 14 | |
| 15 namespace views { | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 // Allows for the control of whether or not the widget can minimize/maximize or | |
| 20 // not. This can be set after initial setup in order to allow testing of both | |
| 21 // forms of delegates. By default this can minimize and maximize. | |
| 22 class MinimizeAndMaximizeStateControlDelegate : public WidgetDelegateView { | |
| 23 public: | |
| 24 MinimizeAndMaximizeStateControlDelegate() | |
| 25 : can_maximize_(true), | |
| 26 can_minimize_(true) {} | |
| 27 virtual ~MinimizeAndMaximizeStateControlDelegate() {} | |
| 28 | |
| 29 void set_can_maximize(bool can_maximize) { | |
| 30 can_maximize_ = can_maximize; | |
| 31 } | |
| 32 | |
| 33 void set_can_minimize(bool can_minimize) { | |
| 34 can_minimize_ = can_minimize; | |
| 35 } | |
| 36 | |
| 37 // WidgetDelegate: | |
| 38 virtual bool CanMaximize() const override { return can_maximize_; } | |
| 39 virtual bool CanMinimize() const override { return can_minimize_; } | |
| 40 | |
| 41 private: | |
| 42 bool can_maximize_; | |
| 43 bool can_minimize_; | |
| 44 | |
| 45 DISALLOW_COPY_AND_ASSIGN(MinimizeAndMaximizeStateControlDelegate); | |
| 46 }; | |
| 47 | |
| 48 } // namespace | |
| 49 | |
| 50 class CustomFrameViewTest : public ViewsTestBase { | |
| 51 public: | |
| 52 CustomFrameViewTest() {} | |
| 53 virtual ~CustomFrameViewTest() {} | |
| 54 | |
| 55 CustomFrameView* custom_frame_view() { | |
| 56 return custom_frame_view_; | |
| 57 } | |
| 58 | |
| 59 MinimizeAndMaximizeStateControlDelegate* | |
| 60 minimize_and_maximize_state_control_delegate() { | |
| 61 return minimize_and_maximize_state_control_delegate_; | |
| 62 } | |
| 63 | |
| 64 Widget* widget() { | |
| 65 return widget_; | |
| 66 } | |
| 67 | |
| 68 // ViewsTestBase: | |
| 69 virtual void SetUp() override; | |
| 70 virtual void TearDown() override; | |
| 71 | |
| 72 protected: | |
| 73 const std::vector<views::FrameButton>& leading_buttons() { | |
| 74 return WindowButtonOrderProvider::GetInstance()->leading_buttons(); | |
| 75 } | |
| 76 | |
| 77 const std::vector<views::FrameButton>& trailing_buttons() { | |
| 78 return WindowButtonOrderProvider::GetInstance()->trailing_buttons(); | |
| 79 } | |
| 80 | |
| 81 ImageButton* minimize_button() { | |
| 82 return custom_frame_view_->minimize_button_; | |
| 83 } | |
| 84 | |
| 85 ImageButton* maximize_button() { | |
| 86 return custom_frame_view_->maximize_button_; | |
| 87 } | |
| 88 | |
| 89 ImageButton* restore_button() { | |
| 90 return custom_frame_view_->restore_button_; | |
| 91 } | |
| 92 | |
| 93 ImageButton* close_button() { | |
| 94 return custom_frame_view_->close_button_; | |
| 95 } | |
| 96 | |
| 97 gfx::Rect title_bounds() { | |
| 98 return custom_frame_view_->title_bounds_; | |
| 99 } | |
| 100 | |
| 101 void SetWindowButtonOrder( | |
| 102 const std::vector<views::FrameButton> leading_buttons, | |
| 103 const std::vector<views::FrameButton> trailing_buttons); | |
| 104 | |
| 105 private: | |
| 106 // Parent container for |custom_frame_view_| | |
| 107 Widget* widget_; | |
| 108 | |
| 109 // Owned by |widget_| | |
| 110 CustomFrameView* custom_frame_view_; | |
| 111 | |
| 112 // Delegate of |widget_| which controls minimizing and maximizing | |
| 113 MinimizeAndMaximizeStateControlDelegate* | |
| 114 minimize_and_maximize_state_control_delegate_; | |
| 115 | |
| 116 DISALLOW_COPY_AND_ASSIGN(CustomFrameViewTest); | |
| 117 }; | |
| 118 | |
| 119 void CustomFrameViewTest::SetUp() { | |
| 120 ViewsTestBase::SetUp(); | |
| 121 | |
| 122 minimize_and_maximize_state_control_delegate_ = | |
| 123 new MinimizeAndMaximizeStateControlDelegate; | |
| 124 widget_ = new Widget; | |
| 125 Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_WINDOW); | |
| 126 params.delegate = minimize_and_maximize_state_control_delegate_; | |
| 127 params.remove_standard_frame = true; | |
| 128 widget_->Init(params); | |
| 129 | |
| 130 custom_frame_view_ = new CustomFrameView; | |
| 131 widget_->non_client_view()->SetFrameView(custom_frame_view_); | |
| 132 } | |
| 133 | |
| 134 void CustomFrameViewTest::TearDown() { | |
| 135 widget_->CloseNow(); | |
| 136 | |
| 137 ViewsTestBase::TearDown(); | |
| 138 } | |
| 139 | |
| 140 void CustomFrameViewTest::SetWindowButtonOrder( | |
| 141 const std::vector<views::FrameButton> leading_buttons, | |
| 142 const std::vector<views::FrameButton> trailing_buttons) { | |
| 143 WindowButtonOrderProvider::GetInstance()-> | |
| 144 SetWindowButtonOrder(leading_buttons, trailing_buttons); | |
| 145 } | |
| 146 | |
| 147 // Tests that there is a default button ordering before initialization causes | |
| 148 // a configuration file check. | |
| 149 TEST_F(CustomFrameViewTest, DefaultButtons) { | |
| 150 const std::vector<views::FrameButton>& trailing = trailing_buttons(); | |
| 151 EXPECT_EQ(trailing.size(), 3u); | |
| 152 EXPECT_TRUE(leading_buttons().empty()); | |
| 153 EXPECT_EQ(trailing[0], FRAME_BUTTON_MINIMIZE); | |
| 154 EXPECT_EQ(trailing[1], FRAME_BUTTON_MAXIMIZE); | |
| 155 EXPECT_EQ(trailing[2], FRAME_BUTTON_CLOSE); | |
| 156 } | |
| 157 | |
| 158 // Tests that layout places the buttons in order, that the restore button is | |
| 159 // hidden and the buttons are placed after the title. | |
| 160 TEST_F(CustomFrameViewTest, DefaultButtonLayout) { | |
| 161 Widget* parent = widget(); | |
| 162 CustomFrameView* view = custom_frame_view(); | |
| 163 view->Init(parent); | |
| 164 parent->SetBounds(gfx::Rect(0, 0, 300, 100)); | |
| 165 parent->Show(); | |
| 166 | |
| 167 EXPECT_LT(minimize_button()->x(), maximize_button()->x()); | |
| 168 EXPECT_LT(maximize_button()->x(), close_button()->x()); | |
| 169 EXPECT_FALSE(restore_button()->visible()); | |
| 170 | |
| 171 EXPECT_GT(minimize_button()->x(), | |
| 172 title_bounds().x() + title_bounds().width()); | |
| 173 } | |
| 174 | |
| 175 // Tests that setting the buttons to leading places them before the title. | |
| 176 TEST_F(CustomFrameViewTest, LeadingButtonLayout) { | |
| 177 Widget* parent = widget(); | |
| 178 CustomFrameView* view = custom_frame_view(); | |
| 179 | |
| 180 std::vector<views::FrameButton> leading; | |
| 181 leading.push_back(views::FRAME_BUTTON_CLOSE); | |
| 182 leading.push_back(views::FRAME_BUTTON_MINIMIZE); | |
| 183 leading.push_back(views::FRAME_BUTTON_MAXIMIZE); | |
| 184 | |
| 185 std::vector<views::FrameButton> trailing; | |
| 186 | |
| 187 SetWindowButtonOrder(leading, trailing); | |
| 188 | |
| 189 view->Init(parent); | |
| 190 parent->SetBounds(gfx::Rect(0, 0, 300, 100)); | |
| 191 parent->Show(); | |
| 192 EXPECT_LT(close_button()->x(), minimize_button()->x()); | |
| 193 EXPECT_LT(minimize_button()->x(), maximize_button()->x()); | |
| 194 EXPECT_FALSE(restore_button()->visible()); | |
| 195 EXPECT_LT(maximize_button()->x() + maximize_button()->width(), | |
| 196 title_bounds().x()); | |
| 197 } | |
| 198 | |
| 199 // Tests that layouts occuring while maximized swap the maximize button for the | |
| 200 // restore button | |
| 201 TEST_F(CustomFrameViewTest, MaximizeRevealsRestoreButton) { | |
| 202 Widget* parent = widget(); | |
| 203 CustomFrameView* view = custom_frame_view(); | |
| 204 view->Init(parent); | |
| 205 parent->SetBounds(gfx::Rect(0, 0, 300, 100)); | |
| 206 parent->Show(); | |
| 207 | |
| 208 ASSERT_FALSE(restore_button()->visible()); | |
| 209 ASSERT_TRUE(maximize_button()->visible()); | |
| 210 | |
| 211 parent->Maximize(); | |
| 212 view->Layout(); | |
| 213 | |
| 214 EXPECT_TRUE(restore_button()->visible()); | |
| 215 EXPECT_FALSE(maximize_button()->visible()); | |
| 216 } | |
| 217 | |
| 218 // Tests that when the parent cannot maximize that the maximize button is not | |
| 219 // visible | |
| 220 TEST_F(CustomFrameViewTest, CannotMaximizeHidesButton) { | |
| 221 Widget* parent = widget(); | |
| 222 CustomFrameView* view = custom_frame_view(); | |
| 223 MinimizeAndMaximizeStateControlDelegate* delegate = | |
| 224 minimize_and_maximize_state_control_delegate(); | |
| 225 delegate->set_can_maximize(false); | |
| 226 | |
| 227 view->Init(parent); | |
| 228 parent->SetBounds(gfx::Rect(0, 0, 300, 100)); | |
| 229 parent->Show(); | |
| 230 | |
| 231 EXPECT_FALSE(restore_button()->visible()); | |
| 232 EXPECT_FALSE(maximize_button()->visible()); | |
| 233 } | |
| 234 | |
| 235 // Tests that when the parent cannot minimize that the minimize button is not | |
| 236 // visible | |
| 237 TEST_F(CustomFrameViewTest, CannotMinimizeHidesButton) { | |
| 238 Widget* parent = widget(); | |
| 239 CustomFrameView* view = custom_frame_view(); | |
| 240 MinimizeAndMaximizeStateControlDelegate* delegate = | |
| 241 minimize_and_maximize_state_control_delegate(); | |
| 242 delegate->set_can_minimize(false); | |
| 243 | |
| 244 view->Init(parent); | |
| 245 parent->SetBounds(gfx::Rect(0, 0, 300, 100)); | |
| 246 parent->Show(); | |
| 247 | |
| 248 EXPECT_FALSE(minimize_button()->visible()); | |
| 249 } | |
| 250 | |
| 251 // Tests that when maximized that the edge button has an increased width. | |
| 252 TEST_F(CustomFrameViewTest, LargerEdgeButtonsWhenMaximized) { | |
| 253 Widget* parent = widget(); | |
| 254 CustomFrameView* view = custom_frame_view(); | |
| 255 | |
| 256 // Custom ordering to have a button on each edge. | |
| 257 std::vector<views::FrameButton> leading; | |
| 258 leading.push_back(views::FRAME_BUTTON_CLOSE); | |
| 259 leading.push_back(views::FRAME_BUTTON_MAXIMIZE); | |
| 260 std::vector<views::FrameButton> trailing; | |
| 261 trailing.push_back(views::FRAME_BUTTON_MINIMIZE); | |
| 262 SetWindowButtonOrder(leading, trailing); | |
| 263 | |
| 264 view->Init(parent); | |
| 265 parent->SetBounds(gfx::Rect(0, 0, 300, 100)); | |
| 266 parent->Show(); | |
| 267 | |
| 268 gfx::Rect close_button_initial_bounds = close_button()->bounds(); | |
| 269 gfx::Rect minimize_button_initial_bounds = minimize_button()->bounds(); | |
| 270 | |
| 271 parent->Maximize(); | |
| 272 view->Layout(); | |
| 273 | |
| 274 EXPECT_GT(close_button()->bounds().width(), | |
| 275 close_button_initial_bounds.width()); | |
| 276 EXPECT_GT(minimize_button()->bounds().width(), | |
| 277 minimize_button_initial_bounds.width()); | |
| 278 } | |
| 279 | |
| 280 } // namespace views | |
| OLD | NEW |
|---|
Chromium Code Reviews
