| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/message_loop/message_loop.h" |
| #include "chrome/browser/chrome_notification_types.h" |
| #include "chrome/browser/ui/panels/base_panel_browser_test.h" |
| #include "chrome/browser/ui/panels/detached_panel_collection.h" |
| #include "chrome/browser/ui/panels/docked_panel_collection.h" |
| #include "chrome/browser/ui/panels/native_panel.h" |
| #include "chrome/browser/ui/panels/panel.h" |
| #include "chrome/browser/ui/panels/panel_drag_controller.h" |
| #include "chrome/browser/ui/panels/panel_manager.h" |
| #include "chrome/browser/ui/panels/stacked_panel_collection.h" |
| #include "chrome/browser/ui/panels/test_panel_collection_squeeze_observer.h" |
| #include "content/public/browser/notification_service.h" |
| #include "content/public/test/test_utils.h" |
| |
| class PanelDragBrowserTest : public BasePanelBrowserTest { |
| public: |
| PanelDragBrowserTest() : BasePanelBrowserTest() { |
| } |
| |
| virtual ~PanelDragBrowserTest() { |
| } |
| |
| virtual void SetUpOnMainThread() OVERRIDE { |
| BasePanelBrowserTest::SetUpOnMainThread(); |
| |
| // All the tests here assume using mocked 800x600 display area for the |
| // primary monitor. Do the check now. |
| gfx::Rect primary_display_area = PanelManager::GetInstance()-> |
| display_settings_provider()->GetPrimaryDisplayArea(); |
| DCHECK(primary_display_area.width() == 800); |
| DCHECK(primary_display_area.height() == 600); |
| } |
| |
| // Drag |panel| from its origin by the offset |delta|. |
| void DragPanelByDelta(Panel* panel, const gfx::Vector2d& delta) { |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| gfx::Point mouse_location(panel->GetBounds().origin()); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| panel_testing->DragTitlebar(mouse_location + delta); |
| panel_testing->FinishDragTitlebar(); |
| } |
| |
| // Drag |panel| from its origin to |new_mouse_location|. |
| void DragPanelToMouseLocation(Panel* panel, |
| const gfx::Point& new_mouse_location) { |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| gfx::Point mouse_location(panel->GetBounds().origin()); |
| panel_testing->PressLeftMouseButtonTitlebar(panel->GetBounds().origin()); |
| panel_testing->DragTitlebar(new_mouse_location); |
| panel_testing->FinishDragTitlebar(); |
| } |
| |
| // Return the bounds of a panel given its initial bounds and the bounds of the |
| // panel above it. |
| static gfx::Rect GetStackedAtBottomPanelBounds( |
| const gfx::Rect& initial_bounds, |
| const gfx::Rect& above_bounds) { |
| return gfx::Rect(above_bounds.x(), |
| above_bounds.bottom(), |
| above_bounds.width(), |
| initial_bounds.height()); |
| } |
| |
| // Return the bounds of a panel given its initial bounds and the bounds of the |
| // panel below it. |
| static gfx::Rect GetStackedAtTopPanelBounds( |
| const gfx::Rect& initial_bounds, |
| const gfx::Rect& below_bounds) { |
| return gfx::Rect(below_bounds.x(), |
| below_bounds.y() - initial_bounds.height(), |
| initial_bounds.width(), |
| initial_bounds.height()); |
| } |
| |
| static gfx::Vector2d GetDragDeltaToRemainDocked() { |
| return gfx::Vector2d( |
| -5, |
| -(PanelDragController::GetDetachDockedPanelThresholdForTesting() / 2)); |
| } |
| |
| static gfx::Vector2d GetDragDeltaToDetach() { |
| return gfx::Vector2d( |
| -20, |
| -(PanelDragController::GetDetachDockedPanelThresholdForTesting() + 20)); |
| } |
| |
| static gfx::Vector2d GetDragDeltaToRemainDetached(Panel* panel) { |
| int distance = |
| panel->manager()->docked_collection()->work_area().bottom() - |
| panel->GetBounds().bottom(); |
| return gfx::Vector2d( |
| -5, |
| distance - |
| PanelDragController::GetDockDetachedPanelThresholdForTesting() * 2); |
| } |
| |
| static gfx::Vector2d GetDragDeltaToAttach(Panel* panel) { |
| int distance = |
| panel->manager()->docked_collection()->work_area().bottom() - |
| panel->GetBounds().bottom(); |
| return gfx::Vector2d( |
| -20, |
| distance - |
| PanelDragController::GetDockDetachedPanelThresholdForTesting() / 2); |
| } |
| |
| // Return the delta needed to drag |panel1| to stack to the bottom of |
| // |panel2|. |
| static gfx::Vector2d GetDragDeltaToStackToBottom(Panel* panel1, |
| Panel* panel2) { |
| gfx::Rect bounds1 = panel1->GetBounds(); |
| gfx::Rect bounds2 = panel2->GetBounds(); |
| return gfx::Vector2d( |
| bounds2.x() - bounds1.x(), |
| bounds2.bottom() - bounds1.y() + |
| PanelDragController::GetGluePanelDistanceThresholdForTesting() / 2); |
| } |
| |
| // Return the delta needed to drag |panel1| to unstack from the bottom of |
| // |panel2|. |
| static gfx::Vector2d GetDragDeltaToUnstackFromBottom(Panel* panel1, |
| Panel* panel2) { |
| gfx::Rect bounds1 = panel1->GetBounds(); |
| gfx::Rect bounds2 = panel2->GetBounds(); |
| return gfx::Vector2d( |
| 0, PanelDragController::GetGluePanelDistanceThresholdForTesting() * 2); |
| } |
| |
| // Return the delta needed to drag |panel1| to stack to the top of |panel2|. |
| static gfx::Vector2d GetDragDeltaToStackToTop(Panel* panel1, Panel* panel2) { |
| gfx::Rect bounds1 = panel1->GetBounds(); |
| gfx::Rect bounds2 = panel2->GetBounds(); |
| StackedPanelCollection* stack1 = panel1->stack(); |
| int bottom = stack1 ? stack1->bottom_panel()->GetBounds().bottom() |
| : bounds1.bottom(); |
| return gfx::Vector2d( |
| bounds2.x() - bounds1.x(), |
| bounds2.y() - bottom - |
| PanelDragController::GetGluePanelDistanceThresholdForTesting() / 2); |
| } |
| |
| // Return the delta needed to drag |panel1| to unstack from the top of |
| // |panel2|. |
| static gfx::Vector2d GetDragDeltaToUnstackFromTop(Panel* panel1, |
| Panel* panel2) { |
| gfx::Rect bounds1 = panel1->GetBounds(); |
| gfx::Rect bounds2 = panel2->GetBounds(); |
| return gfx::Vector2d( |
| 0, -PanelDragController::GetGluePanelDistanceThresholdForTesting() * 2); |
| } |
| |
| // Return the delta needed to drag |panel1| to snap to the left of |panel2|. |
| static gfx::Vector2d GetDragDeltaToSnapToLeft(Panel* panel1, |
| Panel* panel2) { |
| gfx::Rect bounds1 = panel1->GetBounds(); |
| gfx::Rect bounds2 = panel2->GetBounds(); |
| return gfx::Vector2d( |
| bounds2.x() - bounds1.width() - bounds1.x() - |
| PanelDragController::GetGluePanelDistanceThresholdForTesting() / 2, |
| bounds2.y() - bounds1.y() + |
| PanelDragController::GetGluePanelDistanceThresholdForTesting() * 2); |
| } |
| |
| // Return the delta needed to drag |panel1| to snap to the right of |panel2|. |
| static gfx::Vector2d GetDragDeltaToSnapToRight(Panel* panel1, |
| Panel* panel2) { |
| gfx::Rect bounds1 = panel1->GetBounds(); |
| gfx::Rect bounds2 = panel2->GetBounds(); |
| return gfx::Vector2d( |
| bounds2.right() - bounds1.x() + |
| PanelDragController::GetGluePanelDistanceThresholdForTesting() / 2, |
| bounds2.y() - bounds1.y() + |
| PanelDragController::GetGluePanelDistanceThresholdForTesting() * 2); |
| } |
| |
| // Return the delta needed to drag |panel| to unsnap from its current |
| // position. |
| static gfx::Vector2d GetDragDeltaToUnsnap(Panel* panel) { |
| return gfx::Vector2d( |
| PanelDragController::GetGluePanelDistanceThresholdForTesting() * 2, 0); |
| } |
| }; |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DragOneDockedPanel) { |
| static const int big_delta_x = 70; |
| static const int big_delta_y = 30; // Do not exceed the threshold to detach. |
| |
| Panel* panel = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| gfx::Rect panel_old_bounds = panel->GetBounds(); |
| |
| // Drag left. |
| gfx::Point mouse_location = panel_old_bounds.origin(); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| mouse_location.Offset(-big_delta_x, 0); |
| panel_testing->DragTitlebar(mouse_location); |
| gfx::Rect panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(-big_delta_x, 0); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| panel_testing->FinishDragTitlebar(); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| // Drag left and cancel. |
| mouse_location = panel_old_bounds.origin(); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| mouse_location.Offset(-big_delta_x, 0); |
| panel_testing->DragTitlebar(mouse_location); |
| panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(-big_delta_x, 0); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| panel_testing->CancelDragTitlebar(); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| // Drag right. |
| mouse_location = panel_old_bounds.origin(); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| mouse_location.Offset(big_delta_x, 0); |
| panel_testing->DragTitlebar(mouse_location); |
| panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(big_delta_x, 0); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| panel_testing->FinishDragTitlebar(); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| // Drag right and up. Expect no vertical movement. |
| mouse_location = panel_old_bounds.origin(); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| mouse_location.Offset(big_delta_x, big_delta_y); |
| panel_testing->DragTitlebar(mouse_location); |
| panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(big_delta_x, 0); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| panel_testing->FinishDragTitlebar(); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| // Drag up. Expect no movement on drag. |
| mouse_location = panel_old_bounds.origin(); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| mouse_location.Offset(0, -big_delta_y); |
| panel_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| panel_testing->FinishDragTitlebar(); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| // Drag down. Expect no movement on drag. |
| mouse_location = panel_old_bounds.origin(); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| mouse_location.Offset(0, big_delta_y); |
| panel_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| panel_testing->FinishDragTitlebar(); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| PanelManager::GetInstance()->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DragTwoDockedPanels) { |
| static const gfx::Vector2d small_delta(10, 0); |
| |
| Panel* panel1 = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); |
| Panel* panel2 = CreateDockedPanel("2", gfx::Rect(0, 0, 100, 100)); |
| scoped_ptr<NativePanelTesting> panel1_testing( |
| CreateNativePanelTesting(panel1)); |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| gfx::Point position1 = panel1->GetBounds().origin(); |
| gfx::Point position2 = panel2->GetBounds().origin(); |
| |
| // Drag right panel towards left with small delta. |
| // Expect no shuffle: P1 P2 |
| gfx::Point mouse_location = position1; |
| panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| |
| mouse_location = mouse_location - small_delta; |
| panel1_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| |
| panel1_testing->FinishDragTitlebar(); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| |
| // Drag right panel towards left with big delta. |
| // Expect shuffle: P2 P1 |
| mouse_location = position1; |
| panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| |
| mouse_location = position2 + gfx::Vector2d(1, 0); |
| panel1_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| |
| panel1_testing->FinishDragTitlebar(); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| |
| // Drag left panel towards right with small delta. |
| // Expect no shuffle: P2 P1 |
| mouse_location = position2; |
| panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| |
| mouse_location = mouse_location + small_delta; |
| panel1_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| |
| panel1_testing->FinishDragTitlebar(); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| |
| // Drag left panel towards right with big delta. |
| // Expect shuffle: P1 P2 |
| mouse_location = position2; |
| panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| |
| mouse_location = position1 + gfx::Vector2d(1, 0); |
| panel1_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| |
| panel1_testing->FinishDragTitlebar(); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| |
| // Drag right panel towards left with big delta and then cancel the drag. |
| // Expect shuffle after drag: P2 P1 |
| // Expect shuffle after cancel: P1 P2 |
| mouse_location = position1; |
| panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| |
| mouse_location = position2 + gfx::Vector2d(1, 0); |
| panel1_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(mouse_location, panel1->GetBounds().origin()); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| |
| panel1_testing->CancelDragTitlebar(); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| |
| PanelManager::GetInstance()->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DragThreeDockedPanels) { |
| Panel* panel1 = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); |
| Panel* panel2 = CreateDockedPanel("2", gfx::Rect(0, 0, 100, 100)); |
| Panel* panel3 = CreateDockedPanel("3", gfx::Rect(0, 0, 100, 100)); |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| scoped_ptr<NativePanelTesting> panel3_testing( |
| CreateNativePanelTesting(panel3)); |
| gfx::Point position1 = panel1->GetBounds().origin(); |
| gfx::Point position2 = panel2->GetBounds().origin(); |
| gfx::Point position3 = panel3->GetBounds().origin(); |
| |
| // Drag leftmost panel to become the rightmost in 2 drags. Each drag will |
| // shuffle one panel. |
| // Expect shuffle after 1st drag: P1 P3 P2 |
| // Expect shuffle after 2nd drag: P3 P1 P2 |
| gfx::Point mouse_location = position3; |
| panel3_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| EXPECT_EQ(position3, panel3->GetBounds().origin()); |
| |
| mouse_location = position2 + gfx::Vector2d(1, 0); |
| panel3_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); |
| |
| mouse_location = position1 + gfx::Vector2d(1, 0); |
| panel3_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); |
| |
| panel3_testing->FinishDragTitlebar(); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| |
| // Drag rightmost panel to become the leftmost in 2 drags and then cancel the |
| // drag. Each drag will shuffle one panel and the cancellation will restore |
| // all panels. |
| // Expect shuffle after 1st drag: P1 P3 P2 |
| // Expect shuffle after 2nd drag: P1 P2 P3 |
| // Expect shuffle after cancel: P3 P1 P2 |
| mouse_location = position1; |
| panel3_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| |
| mouse_location = position2 + gfx::Vector2d(1, 0); |
| panel3_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); |
| |
| mouse_location = position3 + gfx::Vector2d(1, 0); |
| panel3_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); |
| |
| panel3_testing->CancelDragTitlebar(); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| |
| // Drag leftmost panel to become the rightmost in a single drag. The drag will |
| // shuffle 2 panels at a time. |
| // Expect shuffle: P2 P3 P1 |
| mouse_location = position3; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| |
| mouse_location = position1 + gfx::Vector2d(1, 0); |
| panel2_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(position3, panel1->GetBounds().origin()); |
| EXPECT_EQ(mouse_location, panel2->GetBounds().origin()); |
| EXPECT_EQ(position2, panel3->GetBounds().origin()); |
| |
| panel2_testing->FinishDragTitlebar(); |
| EXPECT_EQ(position3, panel1->GetBounds().origin()); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| EXPECT_EQ(position2, panel3->GetBounds().origin()); |
| |
| // Drag rightmost panel to become the leftmost in a single drag. The drag will |
| // shuffle 2 panels at a time. |
| // Expect shuffle: P3 P1 P2 |
| mouse_location = position1; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position3, panel1->GetBounds().origin()); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| EXPECT_EQ(position2, panel3->GetBounds().origin()); |
| |
| mouse_location = position3 + gfx::Vector2d(1, 0); |
| panel2_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(mouse_location, panel2->GetBounds().origin()); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| |
| panel2_testing->FinishDragTitlebar(); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| |
| // Drag rightmost panel to become the leftmost in a single drag and then |
| // cancel the drag. The drag will shuffle 2 panels and the cancellation will |
| // restore all panels. |
| // Expect shuffle after drag: P1 P2 P3 |
| // Expect shuffle after cancel: P3 P1 P2 |
| mouse_location = position1; |
| panel3_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| |
| mouse_location = position3 + gfx::Vector2d(1, 0); |
| panel3_testing->DragTitlebar(mouse_location); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel2->GetBounds().origin()); |
| EXPECT_EQ(mouse_location, panel3->GetBounds().origin()); |
| |
| panel3_testing->CancelDragTitlebar(); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| EXPECT_EQ(position3, panel2->GetBounds().origin()); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| |
| PanelManager::GetInstance()->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DragMinimizedPanel) { |
| Panel* panel = CreatePanel("panel1"); |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| |
| panel->Minimize(); |
| EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); |
| |
| // Hover over minimized panel to bring up titlebar. |
| gfx::Point hover_point(panel->GetBounds().origin()); |
| MoveMouseAndWaitForExpansionStateChange(panel, hover_point); |
| EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); |
| |
| // Verify we can drag a minimized panel. |
| gfx::Rect panel_old_bounds = panel->GetBounds(); |
| gfx::Point mouse_location = panel_old_bounds.origin(); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); |
| |
| mouse_location.Offset(-70, 0); |
| panel_testing->DragTitlebar(mouse_location); |
| gfx::Rect panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(-70, 0); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); |
| |
| // Verify panel returns to fully minimized state after dragging ends once |
| // mouse moves away from panel. |
| panel_testing->FinishDragTitlebar(); |
| EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); |
| |
| MoveMouseAndWaitForExpansionStateChange(panel, mouse_location); |
| EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); |
| |
| panel->Close(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, |
| DragMinimizedPanelWhileDrawingAttention) { |
| Panel* panel = CreatePanel("panel1"); |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| CreatePanel("panel2"); |
| |
| panel->Minimize(); |
| EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); |
| |
| panel->FlashFrame(true); |
| EXPECT_TRUE(panel->IsDrawingAttention()); |
| EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); |
| |
| // Drag the panel. Verify panel stays in title-only state after attention is |
| // cleared because it is being dragged. |
| gfx::Rect panel_old_bounds = panel->GetBounds(); |
| gfx::Point mouse_location = panel_old_bounds.origin(); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); |
| |
| mouse_location.Offset(-70, 0); |
| panel_testing->DragTitlebar(mouse_location); |
| gfx::Rect panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(-70, 0); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| panel->FlashFrame(false); |
| EXPECT_FALSE(panel->IsDrawingAttention()); |
| EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); |
| |
| // Typical user scenario will detect the mouse in the panel |
| // after attention is cleared, causing titles to pop up, so |
| // we simulate that here. |
| MoveMouse(mouse_location); |
| |
| // Verify panel returns to fully minimized state after dragging ends once |
| // mouse moves away from the panel. |
| panel_testing->FinishDragTitlebar(); |
| EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state()); |
| |
| mouse_location.Offset(0, -50); |
| MoveMouseAndWaitForExpansionStateChange(panel, mouse_location); |
| EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state()); |
| |
| PanelManager::GetInstance()->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, CloseDockedPanelOnDrag) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| PanelDragController* drag_controller = panel_manager->drag_controller(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| |
| // Create 4 docked panels. |
| // We have: P4 P3 P2 P1 |
| Panel* panel1 = CreatePanelWithBounds("Panel1", gfx::Rect(0, 0, 100, 100)); |
| Panel* panel2 = CreatePanelWithBounds("Panel2", gfx::Rect(0, 0, 100, 100)); |
| Panel* panel3 = CreatePanelWithBounds("Panel3", gfx::Rect(0, 0, 100, 100)); |
| Panel* panel4 = CreatePanelWithBounds("Panel4", gfx::Rect(0, 0, 100, 100)); |
| ASSERT_EQ(4, docked_collection->num_panels()); |
| |
| scoped_ptr<NativePanelTesting> panel1_testing( |
| CreateNativePanelTesting(panel1)); |
| gfx::Point position1 = panel1->GetBounds().origin(); |
| gfx::Point position2 = panel2->GetBounds().origin(); |
| gfx::Point position3 = panel3->GetBounds().origin(); |
| gfx::Point position4 = panel4->GetBounds().origin(); |
| |
| // Test the scenario: drag a panel, close another panel, cancel the drag. |
| { |
| std::vector<Panel*> panels; |
| gfx::Point panel1_new_position = position1; |
| panel1_new_position.Offset(-500, 0); |
| |
| // Start dragging a panel. |
| // We have: P1* P4 P3 P2 |
| gfx::Point mouse_location = panel1->GetBounds().origin(); |
| panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| mouse_location.Offset(-500, -5); |
| panel1_testing->DragTitlebar(mouse_location); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| |
| ASSERT_EQ(4, docked_collection->num_panels()); |
| panels = PanelManager::GetInstance()->panels(); |
| EXPECT_EQ(panel2, panels[0]); |
| EXPECT_EQ(panel3, panels[1]); |
| EXPECT_EQ(panel4, panels[2]); |
| EXPECT_EQ(panel1, panels[3]); |
| EXPECT_EQ(position1, panel2->GetBounds().origin()); |
| EXPECT_EQ(position2, panel3->GetBounds().origin()); |
| EXPECT_EQ(position3, panel4->GetBounds().origin()); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| // Closing another panel while dragging in progress will keep the dragging |
| // panel intact. |
| // We have: P1* P4 P3 |
| CloseWindowAndWait(panel2); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| |
| ASSERT_EQ(3, docked_collection->num_panels()); |
| panels = PanelManager::GetInstance()->panels(); |
| EXPECT_EQ(panel3, panels[0]); |
| EXPECT_EQ(panel4, panels[1]); |
| EXPECT_EQ(panel1, panels[2]); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| EXPECT_EQ(position2, panel4->GetBounds().origin()); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| // Cancel the drag. |
| // We have: P4 P3 P1 |
| panel1_testing->CancelDragTitlebar(); |
| EXPECT_FALSE(drag_controller->is_dragging()); |
| |
| ASSERT_EQ(3, docked_collection->num_panels()); |
| panels = PanelManager::GetInstance()->panels(); |
| EXPECT_EQ(panel1, panels[0]); |
| EXPECT_EQ(panel3, panels[1]); |
| EXPECT_EQ(panel4, panels[2]); |
| EXPECT_EQ(position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(position2, panel3->GetBounds().origin()); |
| EXPECT_EQ(position3, panel4->GetBounds().origin()); |
| } |
| |
| // Test the scenario: drag a panel, close another panel, end the drag. |
| { |
| std::vector<Panel*> panels; |
| gfx::Point panel1_new_position = position1; |
| panel1_new_position.Offset(-500, 0); |
| |
| // Start dragging a panel. |
| // We have: P1* P4 P3 |
| gfx::Point mouse_location = panel1->GetBounds().origin(); |
| panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| mouse_location.Offset(-500, -5); |
| panel1_testing->DragTitlebar(mouse_location); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| |
| ASSERT_EQ(3, docked_collection->num_panels()); |
| panels = PanelManager::GetInstance()->panels(); |
| EXPECT_EQ(panel3, panels[0]); |
| EXPECT_EQ(panel4, panels[1]); |
| EXPECT_EQ(panel1, panels[2]); |
| EXPECT_EQ(position1, panel3->GetBounds().origin()); |
| EXPECT_EQ(position2, panel4->GetBounds().origin()); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| // Closing another panel while dragging in progress will keep the dragging |
| // panel intact. |
| // We have: P1* P4 |
| CloseWindowAndWait(panel3); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| |
| ASSERT_EQ(2, docked_collection->num_panels()); |
| panels = PanelManager::GetInstance()->panels(); |
| EXPECT_EQ(panel4, panels[0]); |
| EXPECT_EQ(panel1, panels[1]); |
| EXPECT_EQ(position1, panel4->GetBounds().origin()); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| // Finish the drag. |
| // We have: P1 P4 |
| panel1_testing->FinishDragTitlebar(); |
| EXPECT_FALSE(drag_controller->is_dragging()); |
| |
| ASSERT_EQ(2, docked_collection->num_panels()); |
| panels = PanelManager::GetInstance()->panels(); |
| EXPECT_EQ(panel4, panels[0]); |
| EXPECT_EQ(panel1, panels[1]); |
| EXPECT_EQ(position1, panel4->GetBounds().origin()); |
| EXPECT_EQ(position2, panel1->GetBounds().origin()); |
| } |
| |
| // Test the scenario: drag a panel and close the dragging panel. |
| { |
| std::vector<Panel*> panels; |
| gfx::Point panel1_new_position = position2; |
| panel1_new_position.Offset(-500, 0); |
| |
| // Start dragging a panel again. |
| // We have: P1* P4 |
| gfx::Point mouse_location = panel1->GetBounds().origin(); |
| panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| mouse_location.Offset(-500, -5); |
| panel1_testing->DragTitlebar(mouse_location); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| ASSERT_EQ(2, docked_collection->num_panels()); |
| panels = PanelManager::GetInstance()->panels(); |
| EXPECT_EQ(panel4, panels[0]); |
| EXPECT_EQ(panel1, panels[1]); |
| EXPECT_EQ(position1, panel4->GetBounds().origin()); |
| |
| // Closing the dragging panel should make the drag controller abort. |
| // We have: P4 |
| content::WindowedNotificationObserver signal( |
| chrome::NOTIFICATION_PANEL_CLOSED, content::Source<Panel>(panel1)); |
| panel1->Close(); |
| EXPECT_FALSE(drag_controller->is_dragging()); |
| |
| // Continue the drag to ensure the drag controller does not crash. |
| panel1_new_position.Offset(20, 30); |
| panel1_testing->DragTitlebar(panel1_new_position); |
| panel1_testing->FinishDragTitlebar(); |
| |
| // Wait till the panel is fully closed. |
| signal.Wait(); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| panels = PanelManager::GetInstance()->panels(); |
| EXPECT_EQ(panel4, panels[0]); |
| EXPECT_EQ(position1, panel4->GetBounds().origin()); |
| } |
| |
| panel_manager->CloseAll(); |
| } |
| |
| // http://crbug.com/175760; several panel tests failing regularly on mac. |
| #if defined(OS_MACOSX) |
| #define MAYBE_DragOneDetachedPanel DISABLED_DragOneDetachedPanel |
| #else |
| #define MAYBE_DragOneDetachedPanel DragOneDetachedPanel |
| #endif |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, MAYBE_DragOneDetachedPanel) { |
| Panel* panel = CreateDetachedPanel("1", gfx::Rect(300, 200, 250, 200)); |
| |
| // Test that the detached panel can be dragged almost anywhere except getting |
| // close to the bottom of the docked area to trigger the attach. |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| gfx::Point origin = panel->GetBounds().origin(); |
| |
| panel_testing->PressLeftMouseButtonTitlebar(origin); |
| EXPECT_EQ(origin, panel->GetBounds().origin()); |
| |
| origin.Offset(-51, -102); |
| panel_testing->DragTitlebar(origin); |
| EXPECT_EQ(origin, panel->GetBounds().origin()); |
| |
| origin.Offset(37, 45); |
| panel_testing->DragTitlebar(origin); |
| EXPECT_EQ(origin, panel->GetBounds().origin()); |
| |
| panel_testing->FinishDragTitlebar(); |
| EXPECT_EQ(origin, panel->GetBounds().origin()); |
| |
| // Test that cancelling the drag will return the panel the the original |
| // position. |
| gfx::Point original_position = panel->GetBounds().origin(); |
| origin = original_position; |
| |
| panel_testing->PressLeftMouseButtonTitlebar(origin); |
| EXPECT_EQ(origin, panel->GetBounds().origin()); |
| |
| origin.Offset(-51, -102); |
| panel_testing->DragTitlebar(origin); |
| EXPECT_EQ(origin, panel->GetBounds().origin()); |
| |
| origin.Offset(37, 45); |
| panel_testing->DragTitlebar(origin); |
| EXPECT_EQ(origin, panel->GetBounds().origin()); |
| |
| panel_testing->CancelDragTitlebar(); |
| WaitForBoundsAnimationFinished(panel); |
| EXPECT_EQ(original_position, panel->GetBounds().origin()); |
| |
| PanelManager::GetInstance()->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, CloseDetachedPanelOnDrag) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| PanelDragController* drag_controller = panel_manager->drag_controller(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 1 detached panel. |
| Panel* panel1 = CreateDetachedPanel("1", gfx::Rect(100, 200, 100, 100)); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| |
| scoped_ptr<NativePanelTesting> panel1_testing( |
| CreateNativePanelTesting(panel1)); |
| gfx::Point panel1_old_position = panel1->GetBounds().origin(); |
| |
| // Test the scenario: drag a panel, close another panel, cancel the drag. |
| { |
| // Create a panel to be closed. |
| Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(300, 210, 110, 110)); |
| |
| // Start dragging a panel. |
| panel1_testing->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin()); |
| gfx::Point panel1_new_position = panel1_old_position; |
| panel1_new_position.Offset(-51, -102); |
| panel1_testing->DragTitlebar(panel1_new_position); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_TRUE(detached_collection->HasPanel(panel1)); |
| EXPECT_TRUE(detached_collection->HasPanel(panel2)); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| // Closing another panel while dragging in progress will keep the dragging |
| // panel intact. |
| CloseWindowAndWait(panel2); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_TRUE(detached_collection->HasPanel(panel1)); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| // Cancel the drag. |
| panel1_testing->CancelDragTitlebar(); |
| WaitForBoundsAnimationFinished(panel1); |
| EXPECT_FALSE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1_old_position, panel1->GetBounds().origin()); |
| } |
| |
| // Test the scenario: drag a panel, close another panel, end the drag. |
| { |
| // Create a panel to be closed. |
| Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(300, 210, 110, 110)); |
| |
| // Start dragging a panel. |
| panel1_testing->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin()); |
| gfx::Point panel1_new_position = panel1_old_position; |
| panel1_new_position.Offset(-51, -102); |
| panel1_testing->DragTitlebar(panel1_new_position); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_TRUE(detached_collection->HasPanel(panel1)); |
| EXPECT_TRUE(detached_collection->HasPanel(panel2)); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| // Closing another panel while dragging in progress will keep the dragging |
| // panel intact. |
| CloseWindowAndWait(panel2); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_TRUE(detached_collection->HasPanel(panel1)); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| // Finish the drag. |
| panel1_testing->FinishDragTitlebar(); |
| EXPECT_FALSE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| } |
| |
| // Test the scenario: drag a panel and close the dragging panel. |
| { |
| // Start dragging a panel again. |
| panel1_testing->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin()); |
| gfx::Point panel1_new_position = panel1->GetBounds().origin(); |
| panel1_new_position.Offset(45, 67); |
| panel1_testing->DragTitlebar(panel1_new_position); |
| EXPECT_TRUE(drag_controller->is_dragging()); |
| EXPECT_EQ(panel1, drag_controller->dragging_panel()); |
| |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_TRUE(detached_collection->HasPanel(panel1)); |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| |
| // Closing the dragging panel should make the drag controller abort. |
| content::WindowedNotificationObserver signal( |
| chrome::NOTIFICATION_PANEL_CLOSED, content::Source<Panel>(panel1)); |
| panel1->Close(); |
| EXPECT_FALSE(drag_controller->is_dragging()); |
| |
| // Continue the drag to ensure the drag controller does not crash. |
| panel1_new_position.Offset(20, 30); |
| panel1_testing->DragTitlebar(panel1_new_position); |
| panel1_testing->FinishDragTitlebar(); |
| |
| // Wait till the panel is fully closed. |
| signal.Wait(); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, Detach) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create one docked panel. |
| Panel* panel = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| |
| gfx::Rect panel_old_bounds = panel->GetBounds(); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| gfx::Point mouse_location(panel->GetBounds().origin()); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag up the panel in a small offset that does not trigger the detach. |
| // Expect that the panel is still docked and only x coordinate of its position |
| // is changed. |
| gfx::Vector2d drag_delta_to_remain_docked = GetDragDeltaToRemainDocked(); |
| mouse_location = mouse_location + drag_delta_to_remain_docked; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel->collection()->type()); |
| gfx::Rect panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(drag_delta_to_remain_docked.x(), 0); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Continue dragging up the panel in big offset that triggers the detach. |
| // Expect that the panel is previewed as detached. |
| gfx::Vector2d drag_delta_to_detach = GetDragDeltaToDetach(); |
| mouse_location = mouse_location + drag_delta_to_detach; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| panel_new_bounds.Offset( |
| drag_delta_to_detach.x(), |
| drag_delta_to_detach.y() + drag_delta_to_remain_docked.y()); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Finish the drag. |
| // Expect that the panel stays as detached. |
| panel_testing->FinishDragTitlebar(); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| // http://crbug.com/175760; several panel tests failing regularly on mac. |
| #if defined(OS_MACOSX) |
| #define MAYBE_DetachAndCancel DISABLED_DetachAndCancel |
| #else |
| #define MAYBE_DetachAndCancel DetachAndCancel |
| #endif |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, MAYBE_DetachAndCancel) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create one docked panel. |
| Panel* panel = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| |
| gfx::Rect panel_old_bounds = panel->GetBounds(); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| gfx::Point mouse_location(panel->GetBounds().origin()); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag up the panel in a small offset that does not trigger the detach. |
| // Expect that the panel is still docked and only x coordinate of its position |
| // is changed. |
| gfx::Vector2d drag_delta_to_remain_docked = GetDragDeltaToRemainDocked(); |
| mouse_location = mouse_location + drag_delta_to_remain_docked; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel->collection()->type()); |
| gfx::Rect panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(drag_delta_to_remain_docked.x(), 0); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Continue dragging up the panel in big offset that triggers the detach. |
| // Expect that the panel is previewed as detached. |
| gfx::Vector2d drag_delta_to_detach = GetDragDeltaToDetach(); |
| mouse_location = mouse_location + drag_delta_to_detach; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| panel_new_bounds.Offset( |
| drag_delta_to_detach.x(), |
| drag_delta_to_detach.y() + drag_delta_to_remain_docked.y()); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Cancel the drag. |
| // Expect that the panel is back as docked. |
| panel_testing->CancelDragTitlebar(); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel->collection()->type()); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| // http://crbug.com/175760; several panel tests failing regularly on mac. |
| #if defined(OS_MACOSX) |
| #define MAYBE_Attach DISABLED_Attach |
| #else |
| #define MAYBE_Attach Attach |
| #endif |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, MAYBE_Attach) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create one detached panel. |
| Panel* panel = CreateDetachedPanel("1", gfx::Rect(400, 300, 100, 100)); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| |
| gfx::Rect panel_old_bounds = panel->GetBounds(); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| gfx::Point mouse_location(panel->GetBounds().origin()); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag down the panel but not close enough to the bottom of work area. |
| // Expect that the panel is still detached. |
| gfx::Vector2d drag_delta_to_remain_detached = |
| GetDragDeltaToRemainDetached(panel); |
| mouse_location = mouse_location + drag_delta_to_remain_detached; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| gfx::Rect panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(drag_delta_to_remain_detached); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Continue dragging down the panel to make it close enough to the bottom of |
| // work area. |
| // Expect that the panel is previewed as docked. |
| gfx::Vector2d drag_delta_to_attach = GetDragDeltaToAttach(panel); |
| mouse_location = mouse_location + drag_delta_to_attach; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel->collection()->type()); |
| panel_new_bounds.Offset(drag_delta_to_attach); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Finish the drag. |
| // Expect that the panel stays as docked and moves to the final position. |
| panel_testing->FinishDragTitlebar(); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel->collection()->type()); |
| panel_new_bounds.set_x( |
| docked_collection->StartingRightPosition() - panel_new_bounds.width()); |
| panel_new_bounds.set_y( |
| docked_collection->work_area().bottom() - panel_new_bounds.height()); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| // http://crbug.com/175760; several panel tests failing regularly on mac. |
| #if defined(OS_MACOSX) |
| #define MAYBE_AttachAndCancel DISABLED_AttachAndCancel |
| #else |
| #define MAYBE_AttachAndCancel AttachAndCancel |
| #endif |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, MAYBE_AttachAndCancel) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create one detached panel. |
| Panel* panel = CreateDetachedPanel("1", gfx::Rect(400, 300, 100, 100)); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| |
| gfx::Rect panel_old_bounds = panel->GetBounds(); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| gfx::Point mouse_location(panel->GetBounds().origin()); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag down the panel but not close enough to the bottom of work area. |
| // Expect that the panel is still detached. |
| gfx::Vector2d drag_delta_to_remain_detached = |
| GetDragDeltaToRemainDetached(panel); |
| mouse_location = mouse_location + drag_delta_to_remain_detached; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| gfx::Rect panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(drag_delta_to_remain_detached); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Continue dragging down the panel to make it close enough to the bottom of |
| // work area. |
| // Expect that the panel is previewed as docked. |
| gfx::Vector2d drag_delta_to_attach = GetDragDeltaToAttach(panel); |
| mouse_location = mouse_location + drag_delta_to_attach; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel->collection()->type()); |
| panel_new_bounds.Offset(drag_delta_to_attach); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Cancel the drag. |
| // Expect that the panel is back as detached. |
| panel_testing->CancelDragTitlebar(); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DetachAttachAndCancel) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create one docked panel. |
| Panel* panel = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100)); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| |
| gfx::Rect panel_old_bounds = panel->GetBounds(); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel_testing( |
| CreateNativePanelTesting(panel)); |
| gfx::Point mouse_location(panel->GetBounds().origin()); |
| panel_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag up the panel to trigger the detach. |
| // Expect that the panel is previewed as detached. |
| gfx::Vector2d drag_delta_to_detach = GetDragDeltaToDetach(); |
| mouse_location = mouse_location + drag_delta_to_detach; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| gfx::Rect panel_new_bounds = panel_old_bounds; |
| panel_new_bounds.Offset(drag_delta_to_detach); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Continue dragging down the panel to trigger the re-attach. |
| gfx::Vector2d drag_delta_to_reattach = GetDragDeltaToAttach(panel); |
| mouse_location = mouse_location + drag_delta_to_reattach; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel->collection()->type()); |
| panel_new_bounds.Offset(drag_delta_to_reattach); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Continue dragging up the panel to trigger the detach again. |
| gfx::Vector2d drag_delta_to_detach_again = GetDragDeltaToDetach(); |
| mouse_location = mouse_location + drag_delta_to_detach_again; |
| panel_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| panel_new_bounds.Offset(drag_delta_to_detach_again); |
| EXPECT_EQ(panel_new_bounds, panel->GetBounds()); |
| |
| // Cancel the drag. |
| // Expect that the panel stays as docked. |
| panel_testing->CancelDragTitlebar(); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel->collection()->type()); |
| EXPECT_EQ(panel_old_bounds, panel->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DetachWithSqueeze) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create some docked panels. |
| // docked: P1 P2 P3 P4 P5 |
| Panel* panel1 = CreateDockedPanel("1", gfx::Rect(0, 0, 200, 100)); |
| Panel* panel2 = CreateDockedPanel("2", gfx::Rect(0, 0, 200, 100)); |
| Panel* panel3 = CreateDockedPanel("3", gfx::Rect(0, 0, 200, 100)); |
| Panel* panel4 = CreateDockedPanel("4", gfx::Rect(0, 0, 200, 100)); |
| Panel* panel5 = CreateDockedPanel("5", gfx::Rect(0, 0, 200, 100)); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(5, docked_collection->num_panels()); |
| |
| // Drag to detach the middle docked panel. |
| // Expect to have: |
| // detached: P2 |
| // docked: P1 P3 P4 P5 |
| gfx::Point panel2_docked_position = panel2->GetBounds().origin(); |
| gfx::Vector2d drag_delta_to_detach_panel2(-20, -100); |
| DragPanelByDelta(panel2, drag_delta_to_detach_panel2); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(4, docked_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel3->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel4->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel5->collection()->type()); |
| gfx::Point panel2_new_position = |
| panel2_docked_position + drag_delta_to_detach_panel2; |
| EXPECT_EQ(panel2_new_position, panel2->GetBounds().origin()); |
| |
| // Drag to detach the left-most docked panel. |
| // Expect to have: |
| // detached: P2 P4 |
| // docked: P1 P3 P5 |
| gfx::Point panel4_docked_position = panel4->GetBounds().origin(); |
| gfx::Vector2d drag_delta_to_detach_panel4(-40, -250); |
| DragPanelByDelta(panel4, drag_delta_to_detach_panel4); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_EQ(3, docked_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel3->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel4->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel5->collection()->type()); |
| EXPECT_EQ(panel2_new_position, panel2->GetBounds().origin()); |
| gfx::Point panel4_new_position = |
| panel4_docked_position + drag_delta_to_detach_panel4; |
| EXPECT_EQ(panel4_new_position, panel4->GetBounds().origin()); |
| |
| // Drag to detach the right-most docked panel. |
| // Expect to have: |
| // detached: P1 P2 P4 |
| // docked: P3 P5 |
| gfx::Point docked_position1 = panel1->GetBounds().origin(); |
| gfx::Point docked_position2 = panel3->GetBounds().origin(); |
| gfx::Vector2d drag_delta_to_detach_panel1(-60, -400); |
| DragPanelByDelta(panel1, drag_delta_to_detach_panel1); |
| ASSERT_EQ(3, detached_collection->num_panels()); |
| ASSERT_EQ(2, docked_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel3->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel4->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel5->collection()->type()); |
| gfx::Point panel1_new_position = |
| docked_position1 + drag_delta_to_detach_panel1; |
| EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin()); |
| EXPECT_EQ(panel2_new_position, panel2->GetBounds().origin()); |
| EXPECT_EQ(panel4_new_position, panel4->GetBounds().origin()); |
| |
| // No more squeeze, docked panels should stay put. |
| EXPECT_EQ(docked_position1, panel3->GetBounds().origin()); |
| EXPECT_EQ(panel1->GetBounds().width(), panel1->GetRestoredBounds().width()); |
| EXPECT_EQ(docked_position2, panel5->GetBounds().origin()); |
| EXPECT_EQ(panel2->GetBounds().width(), panel2->GetRestoredBounds().width()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, AttachWithSqueeze) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create some detached, docked panels. |
| // detached: P1 P2 P3 |
| // docked: P4 P5 P6 P7 |
| Panel* panel1 = CreateInactiveDetachedPanel( |
| "1", gfx::Rect(100, 300, 200, 100)); |
| Panel* panel2 = CreateInactiveDetachedPanel( |
| "2", gfx::Rect(200, 300, 200, 100)); |
| Panel* panel3 = CreateInactiveDetachedPanel( |
| "3", gfx::Rect(400, 300, 200, 100)); |
| Panel* panel4 = CreateInactiveDockedPanel("4", gfx::Rect(0, 0, 200, 100)); |
| Panel* panel5 = CreateInactiveDockedPanel("5", gfx::Rect(0, 0, 200, 100)); |
| Panel* panel6 = CreateInactiveDockedPanel("6", gfx::Rect(0, 0, 200, 100)); |
| Panel* panel7 = CreateDockedPanel("7", gfx::Rect(0, 0, 200, 100)); |
| ASSERT_EQ(3, detached_collection->num_panels()); |
| ASSERT_EQ(4, docked_collection->num_panels()); |
| |
| // Wait for active states to settle. |
| PanelCollectionSqueezeObserver panel7_settled(docked_collection, panel7); |
| panel7_settled.Wait(); |
| |
| gfx::Point detached_position1 = panel1->GetBounds().origin(); |
| gfx::Point detached_position2 = panel2->GetBounds().origin(); |
| gfx::Point detached_position3 = panel3->GetBounds().origin(); |
| gfx::Point docked_position4 = panel4->GetBounds().origin(); |
| gfx::Point docked_position5 = panel5->GetBounds().origin(); |
| gfx::Point docked_position6 = panel6->GetBounds().origin(); |
| gfx::Point docked_position7 = panel7->GetBounds().origin(); |
| |
| // Drag to attach a detached panel between 2 docked panels. |
| // Expect to have: |
| // detached: P1 P2 |
| // docked: P4 P3 P5 P6 P7 |
| gfx::Point drag_to_location(panel5->GetBounds().x() + 10, |
| panel5->GetBounds().y()); |
| DragPanelToMouseLocation(panel3, drag_to_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_EQ(5, docked_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel3->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel4->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel5->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel6->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel7->collection()->type()); |
| EXPECT_EQ(detached_position1, panel1->GetBounds().origin()); |
| EXPECT_EQ(detached_position2, panel2->GetBounds().origin()); |
| |
| // Wait for active states to settle. |
| base::MessageLoopForUI::current()->RunUntilIdle(); |
| |
| // Panel positions should have shifted because of the "squeeze" mode. |
| EXPECT_NE(docked_position4, panel4->GetBounds().origin()); |
| EXPECT_LT(panel4->GetBounds().width(), panel4->GetRestoredBounds().width()); |
| EXPECT_NE(docked_position5, panel5->GetBounds().origin()); |
| EXPECT_LT(panel5->GetBounds().width(), panel5->GetRestoredBounds().width()); |
| |
| #if defined(OS_WIN) |
| // The panel we dragged becomes the active one. |
| EXPECT_EQ(true, panel3->IsActive()); |
| EXPECT_EQ(panel3->GetBounds().width(), panel3->GetRestoredBounds().width()); |
| |
| EXPECT_NE(docked_position6, panel6->GetBounds().origin()); |
| #else |
| // The last panel is active so these positions do not change. |
| // TODO (ABurago) this is wrong behavior, a panel should activate |
| // when it is dragged (it does in real usage, but not when drag is |
| // simulated in a test). Change this test when the behavior is fixed. |
| EXPECT_EQ(true, panel7->IsActive()); |
| EXPECT_EQ(panel7->GetBounds().width(), panel7->GetRestoredBounds().width()); |
| |
| EXPECT_EQ(docked_position6, panel6->GetBounds().origin()); |
| #endif |
| EXPECT_EQ(docked_position7, panel7->GetBounds().origin()); |
| |
| // Drag to attach a detached panel to most-right. |
| // Expect to have: |
| // detached: P1 |
| // docked: P2 P4 P3 P5 P6 P7 |
| gfx::Point drag_to_location2(panel4->GetBounds().right() + 10, |
| panel4->GetBounds().y()); |
| DragPanelToMouseLocation(panel2, drag_to_location2); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(6, docked_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel2->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel3->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel4->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel5->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel6->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel7->collection()->type()); |
| EXPECT_EQ(detached_position1, panel1->GetBounds().origin()); |
| |
| // Drag to attach a detached panel to most-left. |
| // Expect to have: |
| // docked: P2 P4 P1 P3 P5 P6 P7 |
| gfx::Point drag_to_location3(panel3->GetBounds().x() - 10, |
| panel3->GetBounds().y()); |
| DragPanelToMouseLocation(panel1, drag_to_location3); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(7, docked_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel2->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel3->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel4->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel5->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel6->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel7->collection()->type()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| // http://crbug.com/175760; several panel tests failing regularly on mac. |
| #if defined(OS_MACOSX) |
| #define MAYBE_DragDetachedPanelToTop DISABLED_DragDetachedPanelToTop |
| #else |
| #define MAYBE_DragDetachedPanelToTop DragDetachedPanelToTop |
| #endif |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, MAYBE_DragDetachedPanelToTop) { |
| // Setup the test areas to have top-aligned bar excluded from work area. |
| const gfx::Rect primary_display_area(0, 0, 800, 600); |
| const gfx::Rect primary_work_area(0, 10, 800, 590); |
| mock_display_settings_provider()->SetPrimaryDisplay( |
| primary_display_area, primary_work_area); |
| |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| Panel* panel = CreateDetachedPanel("1", gfx::Rect(300, 200, 250, 200)); |
| |
| // Drag up the panel. Expect that the panel should not go outside the top of |
| // the work area. |
| gfx::Point drag_to_location(250, 0); |
| DragPanelToMouseLocation(panel, drag_to_location); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| EXPECT_EQ(drag_to_location.x(), panel->GetBounds().origin().x()); |
| EXPECT_EQ(primary_work_area.y(), panel->GetBounds().origin().y()); |
| |
| // Drag down the panel. Expect that the panel can be dragged without |
| // constraint. |
| drag_to_location = gfx::Point(280, 150); |
| DragPanelToMouseLocation(panel, drag_to_location); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| EXPECT_EQ(drag_to_location, panel->GetBounds().origin()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, |
| DragDockedPanelToSecondaryDisplay) { |
| // Setup 2 displays with secondary display on the right side of primary |
| // display. |
| mock_display_settings_provider()->SetPrimaryDisplay( |
| gfx::Rect(0, 0, 400, 600), gfx::Rect(0, 0, 400, 560)); |
| gfx::Rect secondary_display_area(400, 100, 400, 500); |
| mock_display_settings_provider()->SetSecondaryDisplay( |
| secondary_display_area, secondary_display_area); |
| |
| // Create a docked panel. |
| gfx::Size panel_size(100, 100); |
| Panel* panel = CreateDockedPanel("1", gfx::Rect(gfx::Point(), panel_size)); |
| EXPECT_EQ(PanelCollection::DOCKED, panel->collection()->type()); |
| |
| // Drag the panel to the secondary display horizontally. |
| // Expected that the panel should become detached. |
| gfx::Point drag_to_location(secondary_display_area.x() + 100, |
| panel->GetBounds().y()); |
| DragPanelToMouseLocation(panel, drag_to_location); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| gfx::Rect expected_bounds(drag_to_location, panel_size); |
| EXPECT_EQ(expected_bounds, panel->GetBounds()); |
| |
| PanelManager::GetInstance()->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, |
| DragDetachedPanelToSecondaryDisplay) { |
| // Setup 2 displays with secondary display at the bottom of primary display. |
| mock_display_settings_provider()->SetPrimaryDisplay( |
| gfx::Rect(0, 0, 800, 300), gfx::Rect(0, 0, 800, 260)); |
| gfx::Rect secondary_display_area(100, 300, 700, 250); |
| mock_display_settings_provider()->SetSecondaryDisplay( |
| secondary_display_area, secondary_display_area); |
| |
| // Create a detached panel on the primary display. |
| gfx::Rect initial_panel_bounds(300, 50, 100, 100); |
| Panel* panel = CreateDetachedPanel("1", initial_panel_bounds); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| EXPECT_EQ(initial_panel_bounds, panel->GetBounds()); |
| |
| // Drag down the panel to the secondary display vertically. |
| // Expected that the panel should remain detached. |
| gfx::Point drag_to_location(initial_panel_bounds.x(), |
| secondary_display_area.y() + 100); |
| DragPanelToMouseLocation(panel, drag_to_location); |
| EXPECT_EQ(PanelCollection::DETACHED, panel->collection()->type()); |
| gfx::Rect expected_bounds(drag_to_location, initial_panel_bounds.size()); |
| EXPECT_EQ(expected_bounds, panel->GetBounds()); |
| |
| PanelManager::GetInstance()->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, GroupPanelAndPanelFromBottom) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create two detached panels. |
| Panel* panel1 = CreateDetachedPanel("1", gfx::Rect(300, 200, 200, 100)); |
| Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(100, 100, 150, 150)); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_EQ(0, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| |
| gfx::Rect panel1_old_bounds = panel1->GetBounds(); |
| gfx::Rect panel2_old_bounds = panel2->GetBounds(); |
| |
| // Press on title-bar of P2. |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| gfx::Point mouse_location(panel2->GetBounds().origin()); |
| gfx::Point original_mouse_location = mouse_location; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag P2 close to the bottom of P1 to trigger the stacking. Expect: |
| // 1) P1 and P2 form a stack. |
| // 2) P2 jumps vertcially to align to the bottom edge of P1. |
| // 3) P2 moves horizontally by the dragging delta. |
| // 4) The width of P2 remains unchanged. |
| gfx::Vector2d drag_delta_to_stack = |
| GetDragDeltaToStackToBottom(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_stack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_new_bounds(panel2_old_bounds.x() + drag_delta_to_stack.x(), |
| panel1_old_bounds.bottom(), |
| panel2_old_bounds.width(), |
| panel2_old_bounds.height()); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| // Drag P2 somewhat away from the bottom of P1 to trigger the unstacking. |
| // Expect P1 and P2 become detached. |
| gfx::Vector2d drag_delta_to_unstack = |
| GetDragDeltaToUnstackFromBottom(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_unstack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_EQ(0, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| panel2_new_bounds.set_origin(panel2_old_bounds.origin()); |
| panel2_new_bounds.Offset(mouse_location - original_mouse_location); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| // Drag P2 close to the bottom of P1 to trigger the stacking again. Expect: |
| // 1) P1 and P2 form a stack. |
| // 2) P2 jumps vertcially to align to the bottom edge of P1. |
| // 3) P2 moves horizontally by the dragging delta. |
| // 4) The width of P2 remains unchanged. |
| drag_delta_to_stack = GetDragDeltaToStackToBottom(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_stack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| panel2_new_bounds.set_x(panel2_new_bounds.x() + drag_delta_to_stack.x()); |
| panel2_new_bounds.set_y(panel1_old_bounds.bottom()); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| // Move the mouse a little bit. Expect P2 only moves horizontally. P2 should |
| // not move vertically since its top edge already glues to the bottom edge |
| // of P1. |
| gfx::Vector2d small_delta(1, -1); |
| mouse_location = mouse_location + small_delta; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| panel2_new_bounds.set_x(panel2_new_bounds.x() + small_delta.x()); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| // Finish the drag. Expect: |
| // 1) P1 and P2 remain stacked. |
| // 2) P2 moves horizontally to align with P1. |
| // 3) The width of P2 is adjusted to be same as the one of P1. |
| panel2_testing->FinishDragTitlebar(); |
| WaitForBoundsAnimationFinished(panel2); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| panel2_new_bounds.set_x(panel1_old_bounds.x()); |
| panel2_new_bounds.set_width(panel1_old_bounds.width()); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, GroupPanelAndPanelFromTop) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create two detached panels. |
| Panel* panel1 = CreateDetachedPanel("1", gfx::Rect(300, 300, 200, 100)); |
| Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(100, 200, 150, 150)); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_EQ(0, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| |
| gfx::Rect panel1_old_bounds = panel1->GetBounds(); |
| gfx::Rect panel2_old_bounds = panel2->GetBounds(); |
| |
| // Press on title-bar of P2. |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| gfx::Point mouse_location(panel2->GetBounds().origin()); |
| gfx::Point original_mouse_location = mouse_location; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag P2 close to the top of P1 to trigger the stacking. Expect: |
| // 1) P2 and P1 form a stack. |
| // 2) P2 jumps vertcially to align to the top edge of P1. |
| // 3) P2 moves horizontally by the dragging delta. |
| // 4) The width of both P1 and P2 remains unchanged. |
| gfx::Vector2d drag_delta_to_stack = GetDragDeltaToStackToTop(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_stack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_new_bounds( |
| panel2_old_bounds.x() + drag_delta_to_stack.x(), |
| panel1_old_bounds.y() - panel2_old_bounds.height(), |
| panel2_old_bounds.width(), |
| panel2_old_bounds.height()); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| // Drag P2 somewhat away from the top of P1 to trigger the unstacking. |
| // Expect P1 and P2 become detached. |
| gfx::Vector2d drag_delta_to_unstack = |
| GetDragDeltaToUnstackFromTop(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_unstack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_EQ(0, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| panel2_new_bounds.set_origin(panel2_old_bounds.origin()); |
| panel2_new_bounds.Offset(mouse_location - original_mouse_location); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| // Drag P2 close to the top of P1 to trigger the stacking again. Expect: |
| // 1) P2 and P1 form a stack. |
| // 2) P2 jumps vertcially to align to the top edge of P1. |
| // 3) P2 moves horizontally by the dragging delta. |
| // 4) The width of both P1 and P2 remains unchanged. |
| drag_delta_to_stack = GetDragDeltaToStackToTop(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_stack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| panel2_new_bounds.set_x(panel2_new_bounds.x() + drag_delta_to_stack.x()); |
| panel2_new_bounds.set_y(panel1_old_bounds.y() - panel2_old_bounds.height()); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| // Move the mouse a little bit. Expect only P2 moves horizontally. P2 should |
| // not move vertically because its bottom edge already glues to the top edge |
| // of P1. |
| gfx::Vector2d small_delta(1, -1); |
| mouse_location = mouse_location + small_delta; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| panel2_new_bounds.set_x(panel2_new_bounds.x() + small_delta.x()); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| // Finish the drag. Expect: |
| // 1) P2 and P1 remain stacked. |
| // 2) P2 moves horizontally to align with P1. |
| // 3) The width of P1 is adjusted to be same as the one of P2. |
| panel2_testing->FinishDragTitlebar(); |
| WaitForBoundsAnimationFinished(panel1); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| gfx::Rect panel1_new_bounds = panel1_old_bounds; |
| panel1_new_bounds.set_width(panel2_new_bounds.width()); |
| EXPECT_EQ(panel1_new_bounds, panel1->GetBounds()); |
| panel2_new_bounds.set_x(panel1_new_bounds.x()); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, GroupAndCancel) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create two detached panels. |
| Panel* panel1 = CreateDetachedPanel("1", gfx::Rect(300, 200, 200, 100)); |
| Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(100, 100, 150, 150)); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_EQ(0, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| |
| gfx::Rect panel1_old_bounds = panel1->GetBounds(); |
| gfx::Rect panel2_old_bounds = panel2->GetBounds(); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| gfx::Point mouse_location(panel2->GetBounds().origin()); |
| gfx::Point original_mouse_location = mouse_location; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag P2 close to the bottom of P1 to trigger the stacking. |
| // Expect that P2 stacks to P1 and P2's width remains unchanged. |
| gfx::Vector2d drag_delta_to_stack = |
| GetDragDeltaToStackToBottom(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_stack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_new_bounds(panel1_old_bounds.x(), |
| panel1_old_bounds.bottom(), |
| panel2_old_bounds.width(), |
| panel2_old_bounds.height()); |
| EXPECT_EQ(panel2_new_bounds, panel2->GetBounds()); |
| |
| // Cancel the drag. |
| // Expect that the P1 and P2 become detached. |
| panel2_testing->CancelDragTitlebar(); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_EQ(0, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_old_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_old_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, GroupPanelAndStackFromBottom) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 100, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Create 1 detached panel. |
| gfx::Rect panel3_initial_bounds = gfx::Rect(300, 200, 100, 100); |
| Panel* panel3 = CreateDetachedPanel("3", panel3_initial_bounds); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| gfx::Rect panel3_expected_bounds(panel3_initial_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag P3 close to the bottom edge of P1 that is not the bottom panel. |
| // Expect no stacking. |
| gfx::Vector2d drag_delta_to_stack = |
| GetDragDeltaToStackToBottom(panel3, panel1); |
| DragPanelByDelta(panel3, drag_delta_to_stack); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(2, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| |
| // Drag P3 close to the bottom edge of P2 that is the bottom panel. |
| // Expect that P3 becomes the bottom panel of the stack. |
| drag_delta_to_stack = GetDragDeltaToStackToBottom(panel3, panel2); |
| DragPanelByDelta(panel3, drag_delta_to_stack); |
| WaitForBoundsAnimationFinished(panel3); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(3, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| EXPECT_EQ(stack, panel3->collection()); |
| EXPECT_EQ(panel3, stack->bottom_panel()); |
| |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel3_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel3_initial_bounds, panel2_expected_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, GroupPanelAndStackFromTop) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 300, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Create 1 detached panel. |
| gfx::Rect panel3_initial_bounds = gfx::Rect(300, 200, 100, 100); |
| Panel* panel3 = CreateDetachedPanel("3", panel3_initial_bounds); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| gfx::Rect panel3_expected_bounds(panel3_initial_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag P3 close to the top edge of P2 that is not the top panel. |
| // Expect no stacking. |
| gfx::Vector2d drag_delta_to_stack = GetDragDeltaToStackToTop(panel3, panel2); |
| DragPanelByDelta(panel3, drag_delta_to_stack); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(2, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| |
| // Drag P3 close to the top edge of P1 that is the top panel. |
| // Expect that P3 becomes the top panel of the stack. |
| drag_delta_to_stack = GetDragDeltaToStackToTop(panel3, panel1); |
| DragPanelByDelta(panel3, drag_delta_to_stack); |
| WaitForBoundsAnimationFinished(panel1); |
| WaitForBoundsAnimationFinished(panel2); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(3, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| EXPECT_EQ(stack, panel3->collection()); |
| EXPECT_EQ(panel3, stack->top_panel()); |
| |
| panel3_expected_bounds = GetStackedAtTopPanelBounds( |
| panel3_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| panel1_expected_bounds.set_width(panel3_expected_bounds.width()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.set_width(panel3_expected_bounds.width()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, GroupStackAndPanelFromBottom) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 100, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Create 1 detached panel. |
| gfx::Rect panel3_initial_bounds = gfx::Rect(300, 200, 100, 100); |
| Panel* panel3 = CreateDetachedPanel("3", panel3_initial_bounds); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| gfx::Rect panel3_expected_bounds(panel3_initial_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag P1 (together with P2) to stack to the bottom of P3. |
| // Expect that P1 and P2 append to the bottom of P3 and all 3 panels are in |
| // one stack. |
| gfx::Vector2d drag_delta_to_stack = |
| GetDragDeltaToStackToBottom(panel1, panel3); |
| DragPanelByDelta(panel1, drag_delta_to_stack); |
| WaitForBoundsAnimationFinished(panel1); |
| WaitForBoundsAnimationFinished(panel2); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| StackedPanelCollection* final_stack = panel_manager->stacks().front(); |
| ASSERT_EQ(3, final_stack->num_panels()); |
| EXPECT_EQ(final_stack, panel1->stack()); |
| EXPECT_EQ(final_stack, panel2->stack()); |
| EXPECT_EQ(final_stack, panel3->stack()); |
| |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| panel1_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel1_initial_bounds, panel3_expected_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, GroupStackAndPanelFromTop) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 100, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Create 1 detached panel. |
| gfx::Rect panel3_initial_bounds = gfx::Rect(300, 450, 100, 100); |
| Panel* panel3 = CreateDetachedPanel("3", panel3_initial_bounds); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| gfx::Rect panel3_expected_bounds(panel3_initial_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag P1 (together with P2) to stack to the top of P3. |
| // Expect that P1 and P2 add to the top of P3 and all 3 panels are in |
| // one stack. P1 and P2 should align to top of P3 while P3 should update its |
| // width to be same as the width of P1 and P2. |
| gfx::Vector2d drag_delta_to_stack = GetDragDeltaToStackToTop(panel1, panel3); |
| DragPanelByDelta(panel1, drag_delta_to_stack); |
| WaitForBoundsAnimationFinished(panel3); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| StackedPanelCollection* final_stack = panel_manager->stacks().front(); |
| ASSERT_EQ(3, final_stack->num_panels()); |
| EXPECT_EQ(final_stack, panel1->stack()); |
| EXPECT_EQ(final_stack, panel2->stack()); |
| EXPECT_EQ(final_stack, panel3->stack()); |
| |
| panel3_expected_bounds.set_width(panel1_expected_bounds.width()); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| panel2_expected_bounds = GetStackedAtTopPanelBounds( |
| panel2_expected_bounds, panel3_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel1_expected_bounds = GetStackedAtTopPanelBounds( |
| panel1_expected_bounds, panel2_expected_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, GroupStackAndStackFromBottom) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack1 = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack1); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack1); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack1->num_panels()); |
| EXPECT_EQ(stack1, panel1->stack()); |
| EXPECT_EQ(stack1, panel2->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Create 2 more stacked panels in another stack. |
| StackedPanelCollection* stack2 = panel_manager->CreateStack(); |
| gfx::Rect panel3_initial_bounds = gfx::Rect(300, 100, 220, 120); |
| Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack2); |
| gfx::Rect panel4_initial_bounds = gfx::Rect(0, 0, 180, 140); |
| Panel* panel4 = CreateStackedPanel("4", panel4_initial_bounds, stack2); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(2, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack2->num_panels()); |
| EXPECT_EQ(stack2, panel3->stack()); |
| EXPECT_EQ(stack2, panel4->stack()); |
| |
| gfx::Rect panel3_expected_bounds(panel3_initial_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| gfx::Rect panel4_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel4_initial_bounds, panel3_expected_bounds); |
| EXPECT_EQ(panel4_expected_bounds, panel4->GetBounds()); |
| |
| // Drag P3 (together with P4) to stack to the bottom of the stack consisting |
| // P1 and P2. |
| // Expect that P3 and P4 append to the bottom of P2 and all 4 panels are in |
| // one stack. |
| gfx::Vector2d drag_delta_to_stack = |
| GetDragDeltaToStackToBottom(panel3, panel2); |
| DragPanelByDelta(panel3, drag_delta_to_stack); |
| WaitForBoundsAnimationFinished(panel3); |
| WaitForBoundsAnimationFinished(panel4); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| StackedPanelCollection* final_stack = panel_manager->stacks().front(); |
| ASSERT_EQ(4, final_stack->num_panels()); |
| EXPECT_EQ(final_stack, panel1->stack()); |
| EXPECT_EQ(final_stack, panel2->stack()); |
| EXPECT_EQ(final_stack, panel3->stack()); |
| EXPECT_EQ(final_stack, panel4->stack()); |
| |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel3_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel3_initial_bounds, panel2_expected_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| panel4_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel4_initial_bounds, panel3_expected_bounds); |
| EXPECT_EQ(panel4_expected_bounds, panel4->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, GroupStackAndStackFromTop) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack1 = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack1); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack1); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack1->num_panels()); |
| EXPECT_EQ(stack1, panel1->stack()); |
| EXPECT_EQ(stack1, panel2->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Create 2 more stacked panels in another stack. |
| StackedPanelCollection* stack2 = panel_manager->CreateStack(); |
| gfx::Rect panel3_initial_bounds = gfx::Rect(300, 350, 220, 110); |
| Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack2); |
| gfx::Rect panel4_initial_bounds = gfx::Rect(0, 0, 180, 100); |
| Panel* panel4 = CreateStackedPanel("4", panel4_initial_bounds, stack2); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(2, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack2->num_panels()); |
| EXPECT_EQ(stack2, panel3->stack()); |
| EXPECT_EQ(stack2, panel4->stack()); |
| |
| gfx::Rect panel3_expected_bounds(panel3_initial_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| gfx::Rect panel4_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel4_initial_bounds, panel3_expected_bounds); |
| EXPECT_EQ(panel4_expected_bounds, panel4->GetBounds()); |
| |
| // Drag P1 (together with P2) to stack to the top of the stack consisting |
| // P3 and P4. |
| // Expect that P1 and P2 add to the top of P3 and all 4 panels are in |
| // one stack. P1 and P2 should align to top of P3 while P3 and P4 should |
| // update their width to be same as the width of P1 and P2. |
| gfx::Vector2d drag_delta_to_stack = GetDragDeltaToStackToTop(panel1, panel3); |
| DragPanelByDelta(panel1, drag_delta_to_stack); |
| WaitForBoundsAnimationFinished(panel3); |
| WaitForBoundsAnimationFinished(panel4); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| StackedPanelCollection* final_stack = panel_manager->stacks().front(); |
| ASSERT_EQ(4, final_stack->num_panels()); |
| EXPECT_EQ(final_stack, panel1->stack()); |
| EXPECT_EQ(final_stack, panel2->stack()); |
| EXPECT_EQ(final_stack, panel3->stack()); |
| EXPECT_EQ(final_stack, panel4->stack()); |
| |
| panel4_expected_bounds.set_width(panel1_expected_bounds.width()); |
| EXPECT_EQ(panel4_expected_bounds, panel4->GetBounds()); |
| panel3_expected_bounds.set_width(panel1_expected_bounds.width()); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| panel2_expected_bounds = GetStackedAtTopPanelBounds( |
| panel2_expected_bounds, panel3_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel1_expected_bounds = GetStackedAtTopPanelBounds( |
| panel1_expected_bounds, panel2_expected_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, UngroupTwoPanelStack) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(2, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| gfx::Rect panel2_old_bounds = panel2_expected_bounds; |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| gfx::Point mouse_location(panel2->GetBounds().origin()); |
| gfx::Point original_mouse_location = mouse_location; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag P2 away from the bottom of P1 to trigger the unstacking. |
| // Expect that P1 and P2 get detached. |
| gfx::Vector2d drag_delta_to_unstack = |
| GetDragDeltaToUnstackFromBottom(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_unstack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_TRUE(stack->num_panels() == 0); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.Offset(drag_delta_to_unstack); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag P2 a bit closer to the bottom of P1 to trigger the stacking. |
| // Expect P1 and P2 get stacked together. |
| gfx::Vector2d drag_delta_to_stack = |
| GetDragDeltaToStackToBottom(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_stack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| // Note that the empty stack might still exist until the drag ends. |
| ASSERT_GE(panel_manager->num_stacks(), 1); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(panel1->stack(), panel2->stack()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag P2 away from the bottom of P1 to trigger the unstacking again. |
| // Expect that P1 and P2 get detached. |
| drag_delta_to_unstack = GetDragDeltaToUnstackFromBottom(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_unstack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_TRUE(stack->num_panels() == 0); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds = panel2_old_bounds; |
| panel2_expected_bounds.Offset(mouse_location - original_mouse_location); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Finish the drag. |
| // Expect that the P1 and P2 stay detached. |
| panel2_testing->FinishDragTitlebar(); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_EQ(0, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, UngroupAndCancel) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(2, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| gfx::Rect panel2_old_bounds = panel2->GetBounds(); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| gfx::Point mouse_location(panel2->GetBounds().origin()); |
| gfx::Point original_mouse_location = mouse_location; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag P2 away from the bottom of P1 to trigger the unstacking. |
| // Expect that P1 and P2 get detached. |
| gfx::Vector2d drag_delta_to_unstack = |
| GetDragDeltaToUnstackFromBottom(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_unstack; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| ASSERT_TRUE(stack->num_panels() == 0); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.Offset(drag_delta_to_unstack); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Cancel the drag. |
| // Expect that the P1 and P2 put back to the same stack. |
| panel2_testing->CancelDragTitlebar(); |
| WaitForBoundsAnimationFinished(panel2); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_old_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, |
| UngroupBottomPanelInThreePanelStack) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 3 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 120, 120); |
| Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(3, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| EXPECT_EQ(stack, panel3->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| gfx::Rect panel3_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel3_initial_bounds, panel2_expected_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag P3 away to unstack from P2 and P1. |
| // Expect that P1 and P2 are still in the stack while P3 gets detached. |
| gfx::Vector2d drag_delta_to_unstack = |
| GetDragDeltaToUnstackFromBottom(panel3, panel2); |
| DragPanelByDelta(panel3, drag_delta_to_unstack); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel3->collection()->type()); |
| |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel3_expected_bounds.Offset(drag_delta_to_unstack); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, |
| UngroupMiddlePanelInThreePanelStack) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 3 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 120, 120); |
| Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(3, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| EXPECT_EQ(stack, panel3->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| gfx::Rect panel3_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel3_initial_bounds, panel2_expected_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag P2 (together with P3) away to unstack from P1. |
| // Expect that P2 and P3 are still in a stack while P1 gets detached. |
| gfx::Vector2d drag_delta_to_unstack = |
| GetDragDeltaToUnstackFromBottom(panel2, panel1); |
| DragPanelByDelta(panel2, drag_delta_to_unstack); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| StackedPanelCollection* final_stack = panel_manager->stacks().front(); |
| ASSERT_EQ(2, final_stack->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(final_stack, panel2->stack()); |
| EXPECT_EQ(final_stack, panel3->stack()); |
| |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.Offset(drag_delta_to_unstack); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel3_expected_bounds.Offset(drag_delta_to_unstack); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, |
| UngroupThirdPanelInFourPanelStack) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 4 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 120, 200, 100); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 120, 120); |
| Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack); |
| gfx::Rect panel4_initial_bounds = gfx::Rect(0, 0, 120, 110); |
| Panel* panel4 = CreateStackedPanel("4", panel4_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(4, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| EXPECT_EQ(stack, panel3->stack()); |
| EXPECT_EQ(stack, panel4->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| gfx::Rect panel3_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel3_initial_bounds, panel2_expected_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| gfx::Rect panel4_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel4_initial_bounds, panel3_expected_bounds); |
| EXPECT_EQ(panel4_expected_bounds, panel4->GetBounds()); |
| |
| // Drag P3 (together with P4) away to unstack from P2. |
| // Expect that P1 and P2 are in one stack while P3 and P4 are in different |
| // stack. |
| gfx::Vector2d drag_delta_to_unstack = |
| GetDragDeltaToUnstackFromBottom(panel3, panel2); |
| DragPanelByDelta(panel3, drag_delta_to_unstack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(2, panel_manager->num_stacks()); |
| StackedPanelCollection* final_stack1 = panel_manager->stacks().front(); |
| ASSERT_EQ(2, final_stack1->num_panels()); |
| StackedPanelCollection* final_stack2 = panel_manager->stacks().back(); |
| ASSERT_EQ(2, final_stack2->num_panels()); |
| EXPECT_EQ(panel1->stack(), panel2->stack()); |
| EXPECT_EQ(panel3->stack(), panel4->stack()); |
| |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel3_expected_bounds.Offset(drag_delta_to_unstack); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| panel4_expected_bounds.Offset(drag_delta_to_unstack); |
| EXPECT_EQ(panel4_expected_bounds, panel4->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, UngroupAndGroup) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(2, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Create 1 detached panel. |
| gfx::Rect panel3_initial_bounds = gfx::Rect(300, 200, 100, 100); |
| Panel* panel3 = CreateDetachedPanel("3", panel3_initial_bounds); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| gfx::Rect panel3_expected_bounds(panel3_initial_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag P2 to the bottom edge of P3 to trigger both unstacking and stacking. |
| // Expect that P3 and P2 are stacked together while P1 gets detached. |
| gfx::Vector2d drag_delta_to_unstack_and_stack = |
| GetDragDeltaToStackToBottom(panel2, panel3); |
| DragPanelByDelta(panel2, drag_delta_to_unstack_and_stack); |
| WaitForBoundsAnimationFinished(panel2); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| StackedPanelCollection* final_stack = panel_manager->stacks().front(); |
| ASSERT_EQ(2, final_stack->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(final_stack, panel2->stack()); |
| EXPECT_EQ(final_stack, panel3->stack()); |
| |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel3_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, UngroupAndAttach) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(2, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(stack, panel1->stack()); |
| EXPECT_EQ(stack, panel2->stack()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag P2 close to the bottom of the work area to trigger both unstacking and |
| // docking for P2. |
| // Expect that P2 gets docked while P2 gets detached. |
| gfx::Vector2d drag_delta_to_unstack_and_attach = GetDragDeltaToAttach(panel2); |
| DragPanelByDelta(panel2, drag_delta_to_unstack_and_attach); |
| WaitForBoundsAnimationFinished(panel2); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(0, panel_manager->num_stacks()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel2->collection()->type()); |
| |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.set_x(docked_collection->StartingRightPosition() - |
| panel2_expected_bounds.width()); |
| panel2_expected_bounds.set_y(docked_collection->work_area().bottom() - |
| panel2_expected_bounds.height()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, SnapPanelToPanelLeft) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 detached panels. |
| gfx::Rect panel1_initial_bounds = gfx::Rect(300, 200, 300, 200); |
| Panel* panel1 = CreateDetachedPanel("1", panel1_initial_bounds); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(100, 100, 100, 250); |
| Panel* panel2 = CreateDetachedPanel("2", panel2_initial_bounds); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds(panel2_initial_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| gfx::Point mouse_location(panel2->GetBounds().origin()); |
| gfx::Point original_mouse_location = mouse_location; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag P2 close to the left of P1 to trigger the snapping. |
| gfx::Vector2d drag_delta_to_snap = GetDragDeltaToSnapToLeft(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_snap; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.Offset(drag_delta_to_snap); |
| panel2_expected_bounds.set_x( |
| panel1_expected_bounds.x() - panel2_expected_bounds.width()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag P2 a bit away from the left of P1 to trigger the unsnapping. |
| gfx::Vector2d drag_delta_to_unsnap = GetDragDeltaToUnsnap(panel1); |
| mouse_location = mouse_location + drag_delta_to_unsnap; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds = panel2_initial_bounds; |
| panel2_expected_bounds.Offset(mouse_location - original_mouse_location); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag P2 close to the left of P1 to trigger the snapping again. |
| drag_delta_to_snap = GetDragDeltaToSnapToLeft(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_snap; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.Offset(drag_delta_to_snap); |
| panel2_expected_bounds.set_x( |
| panel1_expected_bounds.x() - panel2_expected_bounds.width()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag P2 vertically with a little bit of horizontal movement should still |
| // keep the snapping. |
| gfx::Vector2d drag_delta_almost_vertically(2, 20); |
| mouse_location = mouse_location + drag_delta_almost_vertically; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.set_y( |
| panel2_expected_bounds.y() + drag_delta_almost_vertically.y()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Finish the drag. |
| panel2_testing->FinishDragTitlebar(); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, SnapPanelToPanelRight) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 detached panels. |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 200, 100, 200); |
| Panel* panel1 = CreateDetachedPanel("1", panel1_initial_bounds); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(300, 100, 200, 250); |
| Panel* panel2 = CreateDetachedPanel("2", panel2_initial_bounds); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds(panel2_initial_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| gfx::Point mouse_location(panel2->GetBounds().origin()); |
| gfx::Point original_mouse_location = mouse_location; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag P1 close to the right of P2 to trigger the snapping. |
| gfx::Vector2d drag_delta_to_snap = GetDragDeltaToSnapToRight(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_snap; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.Offset(drag_delta_to_snap); |
| panel2_expected_bounds.set_x(panel1_expected_bounds.right()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag P2 a bit away from the right of P1 to trigger the unsnapping. |
| gfx::Vector2d drag_delta_to_unsnap = GetDragDeltaToUnsnap(panel1); |
| mouse_location = mouse_location + drag_delta_to_unsnap; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds = panel2_initial_bounds; |
| panel2_expected_bounds.Offset(mouse_location - original_mouse_location); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag P2 close to the right of P1 to trigger the snapping again. |
| drag_delta_to_snap = GetDragDeltaToSnapToRight(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_snap; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.Offset(drag_delta_to_snap); |
| panel2_expected_bounds.set_x(panel1_expected_bounds.right()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag P2 vertically with a little bit of horizontal movement should still |
| // keep the snapping. |
| gfx::Vector2d drag_delta_almost_vertically(2, -20); |
| mouse_location = mouse_location + drag_delta_almost_vertically; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.set_y( |
| panel2_expected_bounds.y() + drag_delta_almost_vertically.y()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Finish the drag. |
| panel2_testing->FinishDragTitlebar(); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, SnapAndCancel) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 detached panels. |
| gfx::Rect panel1_initial_bounds = gfx::Rect(300, 200, 300, 200); |
| Panel* panel1 = CreateDetachedPanel("1", panel1_initial_bounds); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(100, 100, 100, 250); |
| Panel* panel2 = CreateDetachedPanel("2", panel2_initial_bounds); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds(panel2_initial_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Press on title-bar. |
| scoped_ptr<NativePanelTesting> panel2_testing( |
| CreateNativePanelTesting(panel2)); |
| gfx::Point mouse_location(panel2->GetBounds().origin()); |
| gfx::Point original_mouse_location = mouse_location; |
| panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); |
| |
| // Drag P2 close to the left of P1 to trigger the snapping. |
| gfx::Vector2d drag_delta_to_snap = GetDragDeltaToSnapToLeft(panel2, panel1); |
| mouse_location = mouse_location + drag_delta_to_snap; |
| panel2_testing->DragTitlebar(mouse_location); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.Offset(drag_delta_to_snap); |
| panel2_expected_bounds.set_x( |
| panel1_expected_bounds.x() - panel2_expected_bounds.width()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Cancel the drag. |
| panel2_testing->CancelDragTitlebar(); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(panel1_initial_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_initial_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, SnapPanelToStackLeft) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(300, 100, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Create 1 detached panel. |
| gfx::Rect panel3_initial_bounds = gfx::Rect(100, 200, 100, 100); |
| Panel* panel3 = CreateDetachedPanel("3", panel3_initial_bounds); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel3->collection()->type()); |
| gfx::Rect panel3_expected_bounds(panel3_initial_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag P3 close to the left of the stack of P1 and P2 to trigger the |
| // snapping. |
| gfx::Vector2d drag_delta_to_snap = GetDragDeltaToSnapToLeft(panel3, panel1); |
| DragPanelByDelta(panel3, drag_delta_to_snap); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel3->collection()->type()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel3_expected_bounds.Offset(drag_delta_to_snap); |
| panel3_expected_bounds.set_x( |
| panel1_expected_bounds.x() - panel3_expected_bounds.width()); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, SnapPanelToStackRight) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 2 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(100, 100, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| ASSERT_EQ(0, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Create 1 detached panel. |
| gfx::Rect panel3_initial_bounds = gfx::Rect(300, 200, 100, 100); |
| Panel* panel3 = CreateDetachedPanel("3", panel3_initial_bounds); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel3->collection()->type()); |
| gfx::Rect panel3_expected_bounds(panel3_initial_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag P3 close to the right of the stack of P1 and P2 to trigger the |
| // snapping. |
| gfx::Vector2d drag_delta_to_snap = GetDragDeltaToSnapToRight(panel3, panel1); |
| DragPanelByDelta(panel3, drag_delta_to_snap); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| ASSERT_EQ(2, stack->num_panels()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel3->collection()->type()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel3_expected_bounds.Offset(drag_delta_to_snap); |
| panel3_expected_bounds.set_x(panel1_expected_bounds.right()); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DetachAndSnap) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| DockedPanelCollection* docked_collection = panel_manager->docked_collection(); |
| DetachedPanelCollection* detached_collection = |
| panel_manager->detached_collection(); |
| |
| // Create 1 detached panel. |
| Panel* panel1 = CreateDetachedPanel("1", gfx::Rect(300, 200, 100, 100)); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| gfx::Rect panel1_bounds = panel1->GetBounds(); |
| |
| // Create 1 docked panel. |
| Panel* panel2 = CreateDockedPanel("2", gfx::Rect(0, 0, 150, 150)); |
| ASSERT_EQ(1, docked_collection->num_panels()); |
| ASSERT_EQ(1, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DOCKED, panel2->collection()->type()); |
| gfx::Rect panel2_bounds = panel2->GetBounds(); |
| |
| // Drag P2 close to the right of P1 to trigger both detaching and snapping. |
| gfx::Vector2d drag_delta_to_detach_and_snap = |
| GetDragDeltaToSnapToRight(panel2, panel1); |
| DragPanelByDelta(panel2, drag_delta_to_detach_and_snap); |
| ASSERT_EQ(0, docked_collection->num_panels()); |
| ASSERT_EQ(2, detached_collection->num_panels()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); |
| EXPECT_EQ(PanelCollection::DETACHED, panel2->collection()->type()); |
| EXPECT_EQ(panel1_bounds, panel1->GetBounds()); |
| panel2_bounds.Offset(drag_delta_to_detach_and_snap); |
| panel2_bounds.set_x(panel1_bounds.right()); |
| EXPECT_EQ(panel2_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DragTopStackedPanel) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| |
| // Create 3 stacked panels. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(300, 100, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 150, 200); |
| Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack); |
| ASSERT_EQ(3, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| EXPECT_EQ(stack, panel3->collection()); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| gfx::Rect panel3_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel3_initial_bounds, panel2_expected_bounds); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| // Drag the top panel by a delta. |
| // Expect all panels are still in the same stack and they are all moved by the |
| // same delta. |
| gfx::Vector2d drag_delta(-50, -20); |
| DragPanelByDelta(panel1, drag_delta); |
| ASSERT_EQ(3, stack->num_panels()); |
| ASSERT_EQ(1, panel_manager->num_stacks()); |
| EXPECT_EQ(stack, panel1->collection()); |
| EXPECT_EQ(stack, panel2->collection()); |
| EXPECT_EQ(stack, panel3->collection()); |
| |
| panel1_expected_bounds.Offset(drag_delta); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.Offset(drag_delta); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| panel3_expected_bounds.Offset(drag_delta); |
| EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, SnapDetachedPanelToScreenEdge) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| int small_distance = |
| PanelDragController::GetSnapPanelToScreenEdgeThresholdForTesting() / 2; |
| |
| // Setup 2 displays with secondary display on the right side of primary |
| // display. |
| gfx::Rect primary_display_area(0, 0, 400, 600); |
| gfx::Rect primary_work_area(0, 0, 400, 560); |
| mock_display_settings_provider()->SetPrimaryDisplay( |
| primary_display_area, primary_work_area); |
| gfx::Rect secondary_display_area(400, 100, 400, 500); |
| gfx::Rect secondary_work_area(400, 140, 400, 460); |
| mock_display_settings_provider()->SetSecondaryDisplay( |
| secondary_display_area, secondary_work_area); |
| |
| // Create one detached panel on the primary display. |
| gfx::Rect initial_bounds = gfx::Rect(100, 100, 200, 150); |
| Panel* panel = CreateDetachedPanel("1", initial_bounds); |
| gfx::Rect expected_bounds(initial_bounds); |
| EXPECT_EQ(expected_bounds, panel->GetBounds()); |
| |
| // Drag the panel close to the right edge of the primary display. |
| // Expect that the panel should snap to the right edge. |
| gfx::Point drag_to_location( |
| primary_work_area.right() - small_distance - panel->GetBounds().width(), |
| panel->GetBounds().y()); |
| DragPanelToMouseLocation(panel, drag_to_location); |
| expected_bounds.set_x(primary_work_area.right() - panel->GetBounds().width()); |
| EXPECT_EQ(expected_bounds, panel->GetBounds()); |
| |
| // Drag the panel close to the top-left corner of the primary display. |
| // Expect that the panel should snap to the top-left corner. |
| drag_to_location = gfx::Point( |
| primary_work_area.x() + small_distance, |
| primary_work_area.y() - small_distance); |
| DragPanelToMouseLocation(panel, drag_to_location); |
| expected_bounds.set_origin(primary_work_area.origin()); |
| EXPECT_EQ(expected_bounds, panel->GetBounds()); |
| |
| // Drag the panel close to the top-right corner of the secondary display. |
| // Expect that the panel should snap to the top-right corner. |
| drag_to_location = gfx::Point( |
| secondary_work_area.right() - small_distance - panel->GetBounds().width(), |
| secondary_work_area.y() + small_distance); |
| DragPanelToMouseLocation(panel, drag_to_location); |
| expected_bounds.set_x( |
| secondary_work_area.right() - panel->GetBounds().width()); |
| expected_bounds.set_y(secondary_work_area.y()); |
| EXPECT_EQ(expected_bounds, panel->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, SnapStackedPanelToScreenEdge) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| int small_distance = |
| PanelDragController::GetSnapPanelToScreenEdgeThresholdForTesting() / 2; |
| |
| // Setup 2 displays with secondary display on the right side of primary |
| // display. |
| gfx::Rect primary_display_area(0, 0, 400, 600); |
| gfx::Rect primary_work_area(0, 0, 400, 560); |
| mock_display_settings_provider()->SetPrimaryDisplay( |
| primary_display_area, primary_work_area); |
| gfx::Rect secondary_display_area(400, 100, 400, 500); |
| gfx::Rect secondary_work_area(400, 140, 400, 460); |
| mock_display_settings_provider()->SetSecondaryDisplay( |
| secondary_display_area, secondary_work_area); |
| |
| // Create 2 stacked panels on the primary display. |
| StackedPanelCollection* stack = panel_manager->CreateStack(); |
| gfx::Rect panel1_initial_bounds = gfx::Rect(300, 100, 200, 150); |
| Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); |
| gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); |
| Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); |
| |
| gfx::Rect panel1_expected_bounds(panel1_initial_bounds); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| gfx::Rect panel2_expected_bounds = GetStackedAtBottomPanelBounds( |
| panel2_initial_bounds, panel1_expected_bounds); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag the stack close to the left edge of the primary display. |
| // Expect that the stack should snap to the left edge. |
| gfx::Point drag_to_location( |
| primary_work_area.x() + small_distance, panel1->GetBounds().y()); |
| DragPanelToMouseLocation(panel1, drag_to_location); |
| |
| panel1_expected_bounds.set_x(primary_work_area.x()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.set_x(primary_work_area.x()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag the stack close to the bottom-right corner of the primary display. |
| // Expect that the stack should snap to the bottom-right corner. |
| drag_to_location = gfx::Point( |
| primary_work_area.right() + small_distance - panel1->GetBounds().width(), |
| primary_work_area.bottom() - small_distance - |
| panel1->GetBounds().height() - panel2->GetBounds().height()); |
| DragPanelToMouseLocation(panel1, drag_to_location); |
| |
| int expected_x = primary_work_area.right() - panel1->GetBounds().width(); |
| panel1_expected_bounds.set_x(expected_x); |
| panel1_expected_bounds.set_y(primary_work_area.bottom() - |
| panel1->GetBounds().height() - panel2->GetBounds().height()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.set_x(expected_x); |
| panel2_expected_bounds.set_y(primary_work_area.bottom() - |
| panel2->GetBounds().height()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| // Drag the stack close to the top-left corner of the secondary display. |
| // Expect that the stack should snap to the top-left corner. |
| drag_to_location = gfx::Point( |
| secondary_work_area.x() + small_distance, |
| secondary_work_area.y() + small_distance); |
| DragPanelToMouseLocation(panel1, drag_to_location); |
| |
| expected_x = secondary_work_area.x(); |
| panel1_expected_bounds.set_x(expected_x); |
| panel1_expected_bounds.set_y(secondary_work_area.y()); |
| EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); |
| panel2_expected_bounds.set_x(expected_x); |
| panel2_expected_bounds.set_y(panel1_expected_bounds.bottom()); |
| EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); |
| |
| panel_manager->CloseAll(); |
| } |