diff options
66 files changed, 784 insertions, 303 deletions
diff --git a/ash/accelerators/accelerator_controller.cc b/ash/accelerators/accelerator_controller.cc index 4f85ce3..be49935 100644 --- a/ash/accelerators/accelerator_controller.cc +++ b/ash/accelerators/accelerator_controller.cc @@ -564,7 +564,7 @@ bool AcceleratorController::PerformAction(int action, shell->GetGridSize()); if (wm::IsWindowFullscreen(window) || wm::IsWindowMaximized(window)) { - SetRestoreBounds(window, sizer.GetSnapBounds(window->bounds())); + SetRestoreBoundsInParent(window, sizer.GetSnapBounds(window->bounds())); wm::RestoreWindow(window); } else { window->SetBounds(sizer.GetSnapBounds(window->bounds())); diff --git a/ash/ash.gyp b/ash/ash.gyp index 101740b..6e1fb89 100644 --- a/ash/ash.gyp +++ b/ash/ash.gyp @@ -106,6 +106,8 @@ 'display/mouse_cursor_event_filter.h', 'display/multi_display_manager.cc', 'display/multi_display_manager.h', + 'display/screen_position_controller.cc', + 'display/screen_position_controller.h', 'display/secondary_display_view.cc', 'display/secondary_display_view.h', 'root_window_controller.cc', @@ -398,6 +400,7 @@ 'launcher/launcher_unittest.cc', 'launcher/launcher_view_unittest.cc', 'root_window_controller_unittest.cc', + 'screen_ash_unittest.cc', 'screensaver/screensaver_view_unittest.cc', 'shell_unittest.cc', 'system/tray/system_tray_unittest.cc', diff --git a/ash/display/display_controller.cc b/ash/display/display_controller.cc index f37903e..d2e0ee5 100644 --- a/ash/display/display_controller.cc +++ b/ash/display/display_controller.cc @@ -7,6 +7,7 @@ #include "ash/ash_switches.h" #include "ash/display/multi_display_manager.h" #include "ash/root_window_controller.h" +#include "ash/screen_ash.h" #include "ash/shell.h" #include "ash/wm/window_util.h" #include "base/command_line.h" @@ -139,11 +140,12 @@ bool DisplayController::WarpMouseCursorIfNecessary( gfx::Rect alternate_bounds = alternate_root->bounds(); gfx::Point alternate_point; - gfx::Rect display_area( - gfx::Screen::GetDisplayNearestWindow(current_root).bounds()); - // TODO(oshima): This is temporary code until the virtual screen - // coordinate is implemented. + // coordinate is fully implemented. + gfx::Rect display_area(ScreenAsh::ConvertRectFromScreen( + current_root, + gfx::Screen::GetDisplayNearestWindow(current_root).bounds())); + if (location_in_root.x() <= display_area.x()) { if (location_in_root.y() < alternate_bounds.height() && ((in_primary && secondary_display_layout_ == LEFT) || diff --git a/ash/display/multi_display_manager.cc b/ash/display/multi_display_manager.cc index 1060748..5098e0a 100644 --- a/ash/display/multi_display_manager.cc +++ b/ash/display/multi_display_manager.cc @@ -208,10 +208,10 @@ void MultiDisplayManager::Init() { base::SplitString(size_str, ',', &parts); for (vector<string>::const_iterator iter = parts.begin(); iter != parts.end(); ++iter) { - displays_.push_back(CreateDisplayFromSpec(*iter)); + AddDisplayFromSpec(*iter); } if (displays_.empty()) - displays_.push_back(CreateDisplayFromSpec("" /* default */)); + AddDisplayFromSpec(std::string() /* default */); // Force the 1st display to be the primary display (id == 0). displays_[0].set_id(0); } @@ -273,5 +273,18 @@ gfx::Display& MultiDisplayManager::FindDisplayForRootWindow( return GetInvalidDisplay(); } +void MultiDisplayManager::AddDisplayFromSpec(const std::string& spec) { + gfx::Display display = CreateDisplayFromSpec(spec); + + if (internal::DisplayController::IsVirtualScreenCoordinatesEnabled()) { + const gfx::Insets insets = display.GetWorkAreaInsets(); + const gfx::Rect& native_bounds = display.bounds_in_pixel(); + display.set_bounds( + gfx::Rect(native_bounds.origin(), display.bounds().size())); + display.UpdateWorkAreaFromInsets(insets); + } + displays_.push_back(display); +} + } // namespace internal } // namespace ash diff --git a/ash/display/multi_display_manager.h b/ash/display/multi_display_manager.h index 955b8e7..1c29b02 100644 --- a/ash/display/multi_display_manager.h +++ b/ash/display/multi_display_manager.h @@ -5,6 +5,7 @@ #ifndef ASH_DISPLAY_MULTI_DISPLAY_MANAGER_H_ #define ASH_DISPLAY_MULTI_DISPLAY_MANAGER_H_ +#include <string> #include <vector> #include "ash/ash_export.h" @@ -73,6 +74,10 @@ class ASH_EXPORT MultiDisplayManager : public aura::DisplayManager, void ScaleDisplayImpl(); gfx::Display& FindDisplayForRootWindow(const aura::RootWindow* root); + // Refer to |aura::DisplayManager::CreateDisplayFromSpec| API for + // the format of |spec|. + void AddDisplayFromSpec(const std::string& spec); + Displays displays_; DISALLOW_COPY_AND_ASSIGN(MultiDisplayManager); diff --git a/ash/display/multi_display_manager_unittest.cc b/ash/display/multi_display_manager_unittest.cc index f633237..d53ec01 100644 --- a/ash/display/multi_display_manager_unittest.cc +++ b/ash/display/multi_display_manager_unittest.cc @@ -89,12 +89,23 @@ class MultiDisplayManagerTest : public test::AshTestBase, DISALLOW_COPY_AND_ASSIGN(MultiDisplayManagerTest); }; -TEST_F(MultiDisplayManagerTest, NativeDisplayTest) { +#if defined(OS_CHROMEOS) +// TODO(oshima): This fails with non extended desktop on windows. +// Reenable when extended desktop is enabled by default. +#define MAYBE_NativeDisplayTest NativeDisplayTest +#define MAYBE_EmulatorTest EmulatorTest +#else +#define MAYBE_NativeDisplayTest DISABLED_NativeDisplayTest +#define MAYBE_EmulatorTest DISABLED_EmulatorTest +#endif + +TEST_F(MultiDisplayManagerTest, MAYBE_NativeDisplayTest) { aura::DisplayManager::set_use_fullscreen_host_window(true); EXPECT_EQ(1U, display_manager()->GetNumDisplays()); // Update primary and add seconary. + LOG(ERROR) << "A"; UpdateDisplay("0+0-500x500,0+501-400x400"); EXPECT_EQ(2U, display_manager()->GetNumDisplays()); EXPECT_EQ("1 1 0", GetCountSummary()); @@ -105,6 +116,7 @@ TEST_F(MultiDisplayManagerTest, NativeDisplayTest) { EXPECT_EQ("0,501 400x400", added()[0].bounds_in_pixel().ToString()); reset(); + LOG(ERROR) << "B"; // Delete secondary. UpdateDisplay("0+0-500x500"); EXPECT_EQ("0 0 1", GetCountSummary()); @@ -175,7 +187,7 @@ TEST_F(MultiDisplayManagerTest, NativeDisplayTest) { } // Test in emulation mode (use_fullscreen_host_window=false) -TEST_F(MultiDisplayManagerTest, EmulatorTest) { +TEST_F(MultiDisplayManagerTest, MAYBE_EmulatorTest) { EXPECT_EQ(1U, display_manager()->GetNumDisplays()); internal::MultiDisplayManager::AddRemoveDisplay(); diff --git a/ash/display/screen_position_controller.cc b/ash/display/screen_position_controller.cc new file mode 100644 index 0000000..3c464b4 --- /dev/null +++ b/ash/display/screen_position_controller.cc @@ -0,0 +1,62 @@ +// 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 "ash/display/screen_position_controller.h" + +#include "ash/display/display_controller.h" +#include "ash/shell_window_ids.h" +#include "ash/wm/window_properties.h" +#include "ui/aura/root_window.h" +#include "ui/gfx/display.h" +#include "ui/gfx/screen.h" + +namespace ash { +namespace internal { + +void ScreenPositionController::ConvertPointToScreen( + const aura::Window* window, + gfx::Point* point) { + const aura::RootWindow* root = window->GetRootWindow(); + aura::Window::ConvertPointToWindow(window, root, point); + if (DisplayController::IsVirtualScreenCoordinatesEnabled()) { + const gfx::Point display_origin = + gfx::Screen::GetDisplayNearestWindow( + const_cast<aura::RootWindow*>(root)).bounds().origin(); + point->Offset(display_origin.x(), display_origin.y()); + } +} + +void ScreenPositionController::ConvertPointFromScreen( + const aura::Window* window, + gfx::Point* point) { + const aura::RootWindow* root = window->GetRootWindow(); + if (DisplayController::IsVirtualScreenCoordinatesEnabled()) { + const gfx::Point display_origin = + gfx::Screen::GetDisplayNearestWindow( + const_cast<aura::RootWindow*>(root)).bounds().origin(); + point->Offset(-display_origin.x(), -display_origin.y()); + } + aura::Window::ConvertPointToWindow(root, window, point); +} + +void ScreenPositionController::SetBounds( + aura::Window* window, + const gfx::Rect& bounds) { + if (!DisplayController::IsVirtualScreenCoordinatesEnabled() || + !window->parent()->GetProperty(internal::kUsesScreenCoordinatesKey)) { + window->SetBounds(bounds); + return; + } + // TODO(oshima): Pick the new root window that most closely shares + // the bounds. For a new widget, NativeWidgetAura picks the right + // root window. + gfx::Point origin(bounds.origin()); + const gfx::Point display_origin = + gfx::Screen::GetDisplayNearestWindow(window).bounds().origin(); + origin.Offset(-display_origin.x(), -display_origin.y()); + window->SetBounds(gfx::Rect(origin, bounds.size())); +} + +} // internal +} // ash diff --git a/ash/display/screen_position_controller.h b/ash/display/screen_position_controller.h new file mode 100644 index 0000000..0d39480 --- /dev/null +++ b/ash/display/screen_position_controller.h @@ -0,0 +1,34 @@ +// 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. + +#ifndef ASH_DISPLAY_SCREEN_POSITION_CONTROLLER_H_ +#define ASH_DISPLAY_SCREEN_POSITION_CONTROLLER_H_ + +#include "base/basictypes.h" +#include "ui/aura/client/screen_position_client.h" + +namespace ash { +namespace internal { + +class ScreenPositionController : public aura::client::ScreenPositionClient { + public: + ScreenPositionController() {} + virtual ~ScreenPositionController() {} + + // aura::client::ScreenPositionClient overrides: + virtual void ConvertPointToScreen(const aura::Window* window, + gfx::Point* point) OVERRIDE; + virtual void ConvertPointFromScreen(const aura::Window* window, + gfx::Point* point) OVERRIDE; + virtual void SetBounds(aura::Window* window, + const gfx::Rect& bounds) OVERRIDE; + + private: + DISALLOW_COPY_AND_ASSIGN(ScreenPositionController); +}; + +} // internal +} // ash + +#endif // ASH_DISPLAY_SCREEN_POSITION_CONTROLLER_H_ diff --git a/ash/root_window_controller.cc b/ash/root_window_controller.cc index cb0da8b..5fa2bb4 100644 --- a/ash/root_window_controller.cc +++ b/ash/root_window_controller.cc @@ -4,6 +4,9 @@ #include "ash/root_window_controller.h" +#include <vector> + +#include "ash/display/display_controller.h" #include "ash/shell.h" #include "ash/shell_factory.h" #include "ash/shell_window_ids.h" @@ -15,6 +18,7 @@ #include "ash/wm/system_modal_container_layout_manager.h" #include "ash/wm/toplevel_window_event_filter.h" #include "ash/wm/visibility_controller.h" +#include "ash/wm/window_properties.h" #include "ash/wm/workspace/workspace_manager.h" #include "ash/wm/workspace_controller.h" #include "ui/aura/client/activation_client.h" @@ -26,6 +30,8 @@ #include "ui/aura/window.h" #include "ui/aura/window_observer.h" #include "ui/aura/window_tracker.h" +#include "ui/gfx/display.h" +#include "ui/gfx/screen.h" namespace ash { namespace { @@ -55,6 +61,10 @@ void MoveAllWindows(aura::RootWindow* src, internal::kShellWindowId_SystemModalContainer, internal::kShellWindowId_LockSystemModalContainer, }; + const gfx::Point src_origin = + gfx::Screen::GetDisplayNearestWindow(src).bounds().origin(); + const gfx::Point dst_origin = + gfx::Screen::GetDisplayNearestWindow(src).bounds().origin(); for (size_t i = 0; i < arraysize(kContainerIdsToMove); i++) { int id = kContainerIdsToMove[i]; @@ -70,11 +80,23 @@ void MoveAllWindows(aura::RootWindow* src, window->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_NONE) { continue; } + // Update the restore bounds to make it relative to the display. + gfx::Rect restore_bounds; + if (internal::DisplayController::IsVirtualScreenCoordinatesEnabled()) + restore_bounds = GetRestoreBoundsInParent(window); dst_container->AddChild(window); + if (!restore_bounds.IsEmpty()) + SetRestoreBoundsInParent(window, restore_bounds); } } } +// Mark the container window so that a widget added to this container will +// use the virtual screeen coordinates instead of parent. +void SetUsesScreenCoordinates(aura::Window* container) { + container->SetProperty(internal::kUsesScreenCoordinatesKey, true); +} + // Creates each of the special window containers that holds windows of various // types in the shell UI. void CreateContainersInRootWindow(aura::RootWindow* root_window) { @@ -112,6 +134,7 @@ void CreateContainersInRootWindow(aura::RootWindow* root_window) { default_container->SetEventFilter( new ToplevelWindowEventFilter(default_container)); SetChildWindowVisibilityChangesAnimated(default_container); + SetUsesScreenCoordinates(default_container); aura::Window* always_on_top_container = CreateContainer( internal::kShellWindowId_AlwaysOnTopContainer, @@ -120,14 +143,19 @@ void CreateContainersInRootWindow(aura::RootWindow* root_window) { always_on_top_container->SetEventFilter( new ToplevelWindowEventFilter(always_on_top_container)); SetChildWindowVisibilityChangesAnimated(always_on_top_container); + SetUsesScreenCoordinates(always_on_top_container); - CreateContainer(internal::kShellWindowId_PanelContainer, - "PanelContainer", - non_lock_screen_containers); + aura::Window* panel_container = CreateContainer( + internal::kShellWindowId_PanelContainer, + "PanelContainer", + non_lock_screen_containers); + SetUsesScreenCoordinates(panel_container); - CreateContainer(internal::kShellWindowId_LauncherContainer, - "LauncherContainer", - non_lock_screen_containers); + aura::Window* launcher_container = + CreateContainer(internal::kShellWindowId_LauncherContainer, + "LauncherContainer", + non_lock_screen_containers); + SetUsesScreenCoordinates(launcher_container); CreateContainer(internal::kShellWindowId_AppListContainer, "AppListContainer", @@ -142,10 +170,13 @@ void CreateContainersInRootWindow(aura::RootWindow* root_window) { modal_container->SetLayoutManager( new internal::SystemModalContainerLayoutManager(modal_container)); SetChildWindowVisibilityChangesAnimated(modal_container); + SetUsesScreenCoordinates(modal_container); - CreateContainer(internal::kShellWindowId_InputMethodContainer, - "InputMethodContainer", - non_lock_screen_containers); + aura::Window* input_method_container = CreateContainer( + internal::kShellWindowId_InputMethodContainer, + "InputMethodContainer", + non_lock_screen_containers); + SetUsesScreenCoordinates(input_method_container); // TODO(beng): Figure out if we can make this use // SystemModalContainerEventFilter instead of stops_event_propagation. @@ -155,6 +186,7 @@ void CreateContainersInRootWindow(aura::RootWindow* root_window) { lock_screen_containers); lock_container->SetLayoutManager( new internal::BaseLayoutManager(root_window)); + SetUsesScreenCoordinates(lock_container); // TODO(beng): stopsevents aura::Window* lock_modal_container = CreateContainer( @@ -166,6 +198,7 @@ void CreateContainersInRootWindow(aura::RootWindow* root_window) { lock_modal_container->SetLayoutManager( new internal::SystemModalContainerLayoutManager(lock_modal_container)); SetChildWindowVisibilityChangesAnimated(lock_modal_container); + SetUsesScreenCoordinates(lock_modal_container); CreateContainer(internal::kShellWindowId_StatusContainer, "StatusContainer", @@ -176,22 +209,27 @@ void CreateContainersInRootWindow(aura::RootWindow* root_window) { "SettingBubbleContainer", lock_screen_related_containers); SetChildWindowVisibilityChangesAnimated(settings_bubble_container); + SetUsesScreenCoordinates(settings_bubble_container); aura::Window* menu_container = CreateContainer( internal::kShellWindowId_MenuContainer, "MenuContainer", lock_screen_related_containers); SetChildWindowVisibilityChangesAnimated(menu_container); + SetUsesScreenCoordinates(menu_container); aura::Window* drag_drop_container = CreateContainer( internal::kShellWindowId_DragImageAndTooltipContainer, "DragImageAndTooltipContainer", lock_screen_related_containers); SetChildWindowVisibilityChangesAnimated(drag_drop_container); + SetUsesScreenCoordinates(drag_drop_container); - CreateContainer(internal::kShellWindowId_OverlayContainer, - "OverlayContainer", - lock_screen_related_containers); + aura::Window* overlay_container = CreateContainer( + internal::kShellWindowId_OverlayContainer, + "OverlayContainer", + lock_screen_related_containers); + SetUsesScreenCoordinates(overlay_container); } } // namespace diff --git a/ash/root_window_controller_unittest.cc b/ash/root_window_controller_unittest.cc index 8fd4acc..7524b29 100644 --- a/ash/root_window_controller_unittest.cc +++ b/ash/root_window_controller_unittest.cc @@ -85,51 +85,77 @@ class RootWindowControllerTest : public test::AshTestBase { TEST_F(RootWindowControllerTest, MoveWindows_Basic) { UpdateDisplay("0+0-600x600,600+0-500x500"); Shell::RootWindowList root_windows = Shell::GetAllRootWindows(); - // Emulate virtual screen coordinate system. - root_windows[0]->SetBounds(gfx::Rect(0, 0, 600, 600)); - root_windows[1]->SetBounds(gfx::Rect(600, 0, 500, 500)); views::Widget* normal = CreateTestWidget(gfx::Rect(650, 10, 100, 100)); EXPECT_EQ(root_windows[1], normal->GetNativeView()->GetRootWindow()); - EXPECT_EQ("100x100", normal->GetWindowScreenBounds().size().ToString()); + EXPECT_EQ("650,10 100x100", normal->GetWindowScreenBounds().ToString()); + EXPECT_EQ("50,10 100x100", + normal->GetNativeView()->GetRootWindowBounds().ToString()); views::Widget* maximized = CreateTestWidget(gfx::Rect(700, 10, 100, 100)); maximized->Maximize(); EXPECT_EQ(root_windows[1], maximized->GetNativeView()->GetRootWindow()); #if !defined(OS_WIN) // TODO(oshima): Window reports smaller screen size. Investigate why. - EXPECT_EQ("500x500", maximized->GetWindowScreenBounds().size().ToString()); + EXPECT_EQ("600,0 500x500", maximized->GetWindowScreenBounds().ToString()); + EXPECT_EQ("0,0 500x500", + maximized->GetNativeView()->GetRootWindowBounds().ToString()); #endif views::Widget* minimized = CreateTestWidget(gfx::Rect(800, 10, 100, 100)); minimized->Minimize(); EXPECT_EQ(root_windows[1], minimized->GetNativeView()->GetRootWindow()); - EXPECT_EQ("100x100", minimized->GetWindowScreenBounds().size().ToString()); + EXPECT_EQ("800,10 100x100", + minimized->GetWindowScreenBounds().ToString()); views::Widget* fullscreen = CreateTestWidget(gfx::Rect(900, 10, 100, 100)); fullscreen->SetFullscreen(true); EXPECT_EQ(root_windows[1], fullscreen->GetNativeView()->GetRootWindow()); #if !defined(OS_WIN) // TODO(oshima): Window reports smaller screen size. Investigate why. - EXPECT_EQ("500x500", fullscreen->GetWindowScreenBounds().size().ToString()); + EXPECT_EQ("600,0 500x500", + fullscreen->GetWindowScreenBounds().ToString()); + EXPECT_EQ("0,0 500x500", + fullscreen->GetNativeView()->GetRootWindowBounds().ToString()); #endif UpdateDisplay("0+0-600x600"); EXPECT_EQ(root_windows[0], normal->GetNativeView()->GetRootWindow()); - EXPECT_EQ("100x100", normal->GetWindowScreenBounds().size().ToString()); + EXPECT_EQ("50,10 100x100", normal->GetWindowScreenBounds().ToString()); + EXPECT_EQ("50,10 100x100", + normal->GetNativeView()->GetRootWindowBounds().ToString()); // Maximized area on primary display has 2px (given as // kAutoHideSize in shelf_layout_manager.cc) inset at the bottom. EXPECT_EQ(root_windows[0], maximized->GetNativeView()->GetRootWindow()); - EXPECT_EQ("600x598", maximized->GetWindowScreenBounds().size().ToString()); + EXPECT_EQ("0,0 600x598", + maximized->GetWindowScreenBounds().ToString()); + EXPECT_EQ("0,0 600x598", + maximized->GetNativeView()->GetRootWindowBounds().ToString()); EXPECT_EQ(root_windows[0], minimized->GetNativeView()->GetRootWindow()); - EXPECT_EQ("100x100", minimized->GetWindowScreenBounds().size().ToString()); + EXPECT_EQ("200,10 100x100", + minimized->GetWindowScreenBounds().ToString()); EXPECT_EQ(root_windows[0], fullscreen->GetNativeView()->GetRootWindow()); EXPECT_TRUE(fullscreen->IsFullscreen()); - EXPECT_EQ("600x600", fullscreen->GetWindowScreenBounds().size().ToString()); + EXPECT_EQ("0,0 600x600", + fullscreen->GetWindowScreenBounds().ToString()); + EXPECT_EQ("0,0 600x600", + fullscreen->GetNativeView()->GetRootWindowBounds().ToString()); + + // Test if the restore bounds are correctly updated. + wm::RestoreWindow(maximized->GetNativeView()); + EXPECT_EQ("100,10 100x100", maximized->GetWindowScreenBounds().ToString()); + EXPECT_EQ("100,10 100x100", + maximized->GetNativeView()->GetRootWindowBounds().ToString()); + + fullscreen->SetFullscreen(false); + EXPECT_EQ("300,10 100x100", + fullscreen->GetWindowScreenBounds().ToString()); + EXPECT_EQ("300,10 100x100", + fullscreen->GetNativeView()->GetRootWindowBounds().ToString()); } TEST_F(RootWindowControllerTest, MoveWindows_Modal) { diff --git a/ash/screen_ash.cc b/ash/screen_ash.cc index ccfb97e..a7adb30 100644 --- a/ash/screen_ash.cc +++ b/ash/screen_ash.cc @@ -7,6 +7,7 @@ #include "ash/shell.h" #include "ash/wm/shelf_layout_manager.h" #include "base/logging.h" +#include "ui/aura/client/screen_position_client.h" #include "ui/aura/env.h" #include "ui/aura/display_manager.h" #include "ui/aura/root_window.h" @@ -28,19 +29,51 @@ ScreenAsh::~ScreenAsh() { } // static -gfx::Rect ScreenAsh::GetMaximizedWindowBounds(aura::Window* window) { +gfx::Rect ScreenAsh::GetMaximizedWindowParentBounds(aura::Window* window) { if (window->GetRootWindow() == Shell::GetPrimaryRootWindow()) return Shell::GetInstance()->shelf()->GetMaximizedWindowBounds(window); else - return gfx::Screen::GetDisplayNearestWindow(window).bounds(); + return GetDisplayParentBounds(window); } // static -gfx::Rect ScreenAsh::GetUnmaximizedWorkAreaBounds(aura::Window* window) { +gfx::Rect ScreenAsh::GetUnmaximizedWorkAreaParentBounds(aura::Window* window) { if (window->GetRootWindow() == Shell::GetPrimaryRootWindow()) return Shell::GetInstance()->shelf()->GetUnmaximizedWorkAreaBounds(window); else - return gfx::Screen::GetDisplayNearestWindow(window).work_area(); + return GetDisplayWorkAreaParentBounds(window); +} + +// static +gfx::Rect ScreenAsh::GetDisplayParentBounds(aura::Window* window) { + return ConvertRectFromScreen( + window->parent(), + gfx::Screen::GetDisplayNearestWindow(window).bounds()); +} + +// static +gfx::Rect ScreenAsh::GetDisplayWorkAreaParentBounds(aura::Window* window) { + return ConvertRectFromScreen( + window->parent(), + gfx::Screen::GetDisplayNearestWindow(window).work_area()); +} + +// static +gfx::Rect ScreenAsh::ConvertRectToScreen(aura::Window* window, + const gfx::Rect& rect) { + gfx::Point point = rect.origin(); + aura::client::GetScreenPositionClient(window->GetRootWindow())-> + ConvertPointToScreen(window, &point); + return gfx::Rect(point, rect.size()); +} + +// static +gfx::Rect ScreenAsh::ConvertRectFromScreen(aura::Window* window, + const gfx::Rect& rect) { + gfx::Point point = rect.origin(); + aura::client::GetScreenPositionClient(window->GetRootWindow())-> + ConvertPointFromScreen(window, &point); + return gfx::Rect(point, rect.size()); } gfx::Point ScreenAsh::GetCursorScreenPoint() { @@ -50,7 +83,6 @@ gfx::Point ScreenAsh::GetCursorScreenPoint() { gfx::NativeWindow ScreenAsh::GetWindowAtCursorScreenPoint() { const gfx::Point point = gfx::Screen::GetCursorScreenPoint(); - // TODO(oshima): convert point to relateive to the root window. return Shell::GetRootWindowAt(point)->GetTopWindowContainingPoint(point); } diff --git a/ash/screen_ash.h b/ash/screen_ash.h index dae6da6..94fb54b 100644 --- a/ash/screen_ash.h +++ b/ash/screen_ash.h @@ -20,12 +20,29 @@ class ASH_EXPORT ScreenAsh : public gfx::ScreenImpl { ScreenAsh(); virtual ~ScreenAsh(); - // Returns the bounds for maximized windows. Maximized windows trigger - // auto-hiding the shelf. - static gfx::Rect GetMaximizedWindowBounds(aura::Window* window); + // Returns the bounds for maximized windows in parent coordinates. + // Maximized windows trigger auto-hiding the shelf. + static gfx::Rect GetMaximizedWindowParentBounds(aura::Window* window); - // Returns work area when a maximized window is not present. - static gfx::Rect GetUnmaximizedWorkAreaBounds(aura::Window* window); + // Returns work area when a maximized window is not present in + // parent coordinates. + static gfx::Rect GetUnmaximizedWorkAreaParentBounds(aura::Window* window); + + // Returns the display bounds in parent coordinates. + static gfx::Rect GetDisplayParentBounds(aura::Window* window); + + // Returns the display's work area bounds in parent coordinates. + static gfx::Rect GetDisplayWorkAreaParentBounds(aura::Window* window); + + // Converts |rect| from |window|'s coordinates to the virtual screen + // coordinates. + static gfx::Rect ConvertRectToScreen(aura::Window* window, + const gfx::Rect& rect); + + // Converts |rect| from virtual screen coordinates to the |window|'s + // coordinates. + static gfx::Rect ConvertRectFromScreen(aura::Window* window, + const gfx::Rect& rect); protected: virtual gfx::Point GetCursorScreenPoint() OVERRIDE; diff --git a/ash/screen_ash_unittest.cc b/ash/screen_ash_unittest.cc new file mode 100644 index 0000000..96727c8 --- /dev/null +++ b/ash/screen_ash_unittest.cc @@ -0,0 +1,115 @@ +// 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 "ash/screen_ash.h" + +#include "ash/display/display_controller.h" +#include "ash/shell.h" +#include "ash/test/ash_test_base.h" +#include "ash/wm/window_util.h" +#include "ui/aura/env.h" +#include "ui/aura/root_window.h" +#include "ui/aura/window.h" +#include "ui/views/widget/widget.h" +#include "ui/views/widget/widget_delegate.h" + +namespace ash { +namespace test { +class ScreenAshTest : public test::AshTestBase { + public: + ScreenAshTest() {} + virtual ~ScreenAshTest() {} + + virtual void SetUp() OVERRIDE { + internal::DisplayController::SetExtendedDesktopEnabled(true); + internal::DisplayController::SetVirtualScreenCoordinatesEnabled(true); + AshTestBase::SetUp(); + } + + virtual void TearDown() OVERRIDE { + AshTestBase::TearDown(); + internal::DisplayController::SetExtendedDesktopEnabled(false); + internal::DisplayController::SetVirtualScreenCoordinatesEnabled(false); + } + + private: + DISALLOW_COPY_AND_ASSIGN(ScreenAshTest); +}; + +#if !defined(OS_WIN) +TEST_F(ScreenAshTest, Bounds) { + UpdateDisplay("0+0-600x600,600+0-500x500"); + + views::Widget* primary = + views::Widget::CreateWindowWithBounds(NULL, gfx::Rect(10, 10, 100, 100)); + primary->Show(); + views::Widget* secondary = + views::Widget::CreateWindowWithBounds(NULL, gfx::Rect(610, 10, 100, 100)); + secondary->Show(); + + // Maximized bounds + EXPECT_EQ("0,0 600x598", + ScreenAsh::GetMaximizedWindowParentBounds( + primary->GetNativeView()).ToString()); + EXPECT_EQ("0,0 500x500", + ScreenAsh::GetMaximizedWindowParentBounds( + secondary->GetNativeView()).ToString()); + + // Unmaximized work area bounds + EXPECT_EQ("0,0 600x552", + ScreenAsh::GetUnmaximizedWorkAreaParentBounds( + primary->GetNativeView()).ToString()); + EXPECT_EQ("0,0 500x500", + ScreenAsh::GetUnmaximizedWorkAreaParentBounds( + secondary->GetNativeView()).ToString()); + + // Display bounds + EXPECT_EQ("0,0 600x600", + ScreenAsh::GetDisplayParentBounds( + primary->GetNativeView()).ToString()); + EXPECT_EQ("0,0 500x500", + ScreenAsh::GetDisplayParentBounds( + secondary->GetNativeView()).ToString()); + + // Work area bounds + EXPECT_EQ("0,0 600x552", + ScreenAsh::GetDisplayWorkAreaParentBounds( + primary->GetNativeView()).ToString()); + EXPECT_EQ("0,0 500x500", + ScreenAsh::GetDisplayWorkAreaParentBounds( + secondary->GetNativeView()).ToString()); +} +#endif + +TEST_F(ScreenAshTest, ConvertRect) { + UpdateDisplay("0+0-600x600,600+0-500x500"); + + views::Widget* primary = + views::Widget::CreateWindowWithBounds(NULL, gfx::Rect(10, 10, 100, 100)); + primary->Show(); + views::Widget* secondary = + views::Widget::CreateWindowWithBounds(NULL, gfx::Rect(610, 10, 100, 100)); + secondary->Show(); + + EXPECT_EQ( + "0,0 100x100", + ScreenAsh::ConvertRectFromScreen( + primary->GetNativeView(), gfx::Rect(10, 10, 100, 100)).ToString()); + EXPECT_EQ( + "10,10 100x100", + ScreenAsh::ConvertRectFromScreen( + secondary->GetNativeView(), gfx::Rect(620, 20, 100, 100)).ToString()); + + EXPECT_EQ( + "40,40 100x100", + ScreenAsh::ConvertRectToScreen( + primary->GetNativeView(), gfx::Rect(30, 30, 100, 100)).ToString()); + EXPECT_EQ( + "650,50 100x100", + ScreenAsh::ConvertRectToScreen( + secondary->GetNativeView(), gfx::Rect(40, 40, 100, 100)).ToString()); +} + +} // namespace test +} // namespace ash diff --git a/ash/shell.cc b/ash/shell.cc index b017668..681425c 100644 --- a/ash/shell.cc +++ b/ash/shell.cc @@ -20,6 +20,7 @@ #include "ash/display/display_controller.h" #include "ash/display/mouse_cursor_event_filter.h" #include "ash/display/multi_display_manager.h" +#include "ash/display/screen_position_controller.h" #include "ash/display/secondary_display_view.h" #include "ash/root_window_controller.h" #include "ash/screen_ash.h" @@ -249,6 +250,7 @@ Shell::~Shell() { // This also deletes all RootWindows. display_controller_.reset(); + screen_position_controller_.reset(); // Launcher widget has a InputMethodBridge that references to // input_method_filter_'s input_method_. So explicitly release launcher_ @@ -357,6 +359,8 @@ std::vector<aura::Window*> Shell::GetAllContainers(int container_id) { } void Shell::Init() { + if (internal::DisplayController::IsVirtualScreenCoordinatesEnabled()) + VLOG(1) << "Using virtual screen coordinates"; // Install the custom factory first so that views::FocusManagers for Tray, // Launcher, and WallPaper could be created by the factory. views::FocusManagerFactory::Install(new AshFocusManagerFactory); @@ -372,6 +376,7 @@ void Shell::Init() { activation_controller_.reset( new internal::ActivationController(focus_manager_.get())); + screen_position_controller_.reset(new internal::ScreenPositionController); display_controller_.reset(new internal::DisplayController); display_controller_->InitPrimaryDisplay(); aura::RootWindow* root_window = display_controller_->GetPrimaryRootWindow(); @@ -678,6 +683,8 @@ void Shell::InitRootWindowForSecondaryDisplay(aura::RootWindow* root) { root->layout_manager()->OnWindowResized(); root->ShowRootWindow(); aura::client::SetCaptureClient(root, capture_controller_.get()); + aura::client::SetScreenPositionClient( + root, screen_position_controller_.get()); } } @@ -695,6 +702,8 @@ void Shell::InitRootWindowController( aura::client::SetVisibilityClient(root_window, visibility_controller_.get()); aura::client::SetDragDropClient(root_window, drag_drop_controller_.get()); aura::client::SetCaptureClient(root_window, capture_controller_.get()); + aura::client::SetScreenPositionClient(root_window, + screen_position_controller_.get()); if (nested_dispatcher_controller_.get()) { aura::client::SetDispatcherClient(root_window, diff --git a/ash/shell.h b/ash/shell.h index cb4133f..f2fad34 100644 --- a/ash/shell.h +++ b/ash/shell.h @@ -89,6 +89,7 @@ class PartialScreenshotEventFilter; class ResizeShadowController; class RootWindowController; class RootWindowLayoutManager; +class ScreenPositionController; class ShadowController; class ShelfLayoutManager; class ShellContextMenu; @@ -434,6 +435,7 @@ class ASH_EXPORT Shell : aura::CursorDelegate { scoped_ptr<aura::FocusManager> focus_manager_; scoped_ptr<aura::client::UserActionClient> user_action_client_; scoped_ptr<internal::MouseCursorEventFilter> mouse_cursor_filter_; + scoped_ptr<internal::ScreenPositionController> screen_position_controller_; // An event filter that rewrites or drops an event. scoped_ptr<internal::EventRewriterEventFilter> event_rewriter_filter_; diff --git a/ash/shell/toplevel_window.cc b/ash/shell/toplevel_window.cc index 8ff724b..cb5f301 100644 --- a/ash/shell/toplevel_window.cc +++ b/ash/shell/toplevel_window.cc @@ -22,7 +22,7 @@ ToplevelWindow::CreateParams::CreateParams() // static void ToplevelWindow::CreateToplevelWindow(const CreateParams& params) { static int count = 0; - int x = count == 0 ? 50 : 350; + int x = count == 0 ? 150 : 750; count = (count + 1) % 2; views::Widget* widget = views::Widget::CreateWindowWithBounds(new ToplevelWindow(params), diff --git a/ash/shell_context_menu.cc b/ash/shell_context_menu.cc index 7973ca2..0a7fe2c 100644 --- a/ash/shell_context_menu.cc +++ b/ash/shell_context_menu.cc @@ -5,8 +5,10 @@ #include "ash/shell_context_menu.h" #include "ash/desktop_background/desktop_background_controller.h" +#include "ash/display/display_controller.h" #include "ash/shell.h" #include "grit/ash_strings.h" +#include "ui/aura/client/screen_position_client.h" #include "ui/aura/window.h" #include "ui/base/l10n/l10n_util.h" #include "ui/views/controls/menu/menu_model_adapter.h" @@ -24,19 +26,22 @@ ShellContextMenu::~ShellContextMenu() { void ShellContextMenu::ShowMenu(views::Widget* widget, const gfx::Point& location) { - // TODO(oshima): Figure out the exact semantics of - // just switching the active root window without changing the - // active window. - Shell::GetInstance()->set_active_root_window( - widget->GetNativeView()->GetRootWindow()); + if (!internal::DisplayController::IsVirtualScreenCoordinatesEnabled()) { + Shell::GetInstance()->set_active_root_window( + widget->GetNativeView()->GetRootWindow()); + } ui::SimpleMenuModel menu_model(this); menu_model.AddItem(MENU_CHANGE_WALLPAPER, l10n_util::GetStringUTF16(IDS_AURA_SET_DESKTOP_WALLPAPER)); views::MenuModelAdapter menu_model_adapter(&menu_model); menu_runner_.reset(new views::MenuRunner(menu_model_adapter.CreateMenu())); + aura::Window* window = widget->GetNativeView(); + gfx::Point menu_origin = location; + aura::client::GetScreenPositionClient(window->GetRootWindow())-> + ConvertPointToScreen(window, &menu_origin); if (menu_runner_->RunMenuAt( - widget, NULL, gfx::Rect(location, gfx::Size()), + widget, NULL, gfx::Rect(menu_origin, gfx::Size()), views::MenuItemView::TOPLEFT, views::MenuRunner::HAS_MNEMONICS) == views::MenuRunner::MENU_DELETED) return; diff --git a/ash/system/tray/tray_bubble_view.cc b/ash/system/tray/tray_bubble_view.cc index 1b934d4..4b0fb1a 100644 --- a/ash/system/tray/tray_bubble_view.cc +++ b/ash/system/tray/tray_bubble_view.cc @@ -376,7 +376,7 @@ void TrayBubbleView::Host::ProcessLocatedEvent( const aura::LocatedEvent& event) { if (!widget_) return; - gfx::Rect bounds = widget_->GetNativeWindow()->GetBoundsInRootWindow(); + gfx::Rect bounds = widget_->GetNativeWindow()->GetRootWindowBounds(); if (bounds.Contains(event.root_location())) return; if (tray_view_) { diff --git a/ash/tooltips/tooltip_controller.cc b/ash/tooltips/tooltip_controller.cc index 4798cd33..5db968e 100644 --- a/ash/tooltips/tooltip_controller.cc +++ b/ash/tooltips/tooltip_controller.cc @@ -409,7 +409,7 @@ void TooltipController::UpdateIfRequired() { string16 tooltip_text(tooltip_text_); gfx::Point widget_loc = curr_mouse_loc_; widget_loc = widget_loc.Add( - tooltip_window_->GetBoundsInRootWindow().origin()); + tooltip_window_->GetScreenBounds().origin()); tooltip_->SetText(tooltip_text, widget_loc); tooltip_->Show(); } diff --git a/ash/wm/app_list_controller.cc b/ash/wm/app_list_controller.cc index 1fa0ac5..53290de 100644 --- a/ash/wm/app_list_controller.cc +++ b/ash/wm/app_list_controller.cc @@ -202,7 +202,7 @@ void AppListController::ScheduleAnimation() { void AppListController::ProcessLocatedEvent(const aura::LocatedEvent& event) { if (view_ && is_visible_) { views::Widget* widget = view_->GetWidget(); - if (!widget->GetNativeView()->GetBoundsInRootWindow().Contains( + if (!widget->GetNativeView()->GetRootWindowBounds().Contains( event.root_location())) { SetVisible(false); } diff --git a/ash/wm/base_layout_manager.cc b/ash/wm/base_layout_manager.cc index 29d39a0d..bb08389 100644 --- a/ash/wm/base_layout_manager.cc +++ b/ash/wm/base_layout_manager.cc @@ -33,7 +33,8 @@ gfx::Rect BoundsWithScreenEdgeVisible(aura::Window* window, // If the restore_bounds are more than 1 grid step away from the size the // window would be when maximized, inset it. int grid_size = ash::Shell::GetInstance()->GetGridSize(); - gfx::Rect max_bounds = ash::ScreenAsh::GetMaximizedWindowBounds(window); + gfx::Rect max_bounds = + ash::ScreenAsh::GetMaximizedWindowParentBounds(window); max_bounds.Inset(grid_size, grid_size); if (restore_bounds.Contains(max_bounds)) return max_bounds; @@ -103,9 +104,9 @@ void BaseLayoutManager::SetChildBounds(aura::Window* child, gfx::Rect child_bounds(requested_bounds); // Some windows rely on this to set their initial bounds. if (wm::IsWindowMaximized(child)) - child_bounds = ScreenAsh::GetMaximizedWindowBounds(child); + child_bounds = ScreenAsh::GetMaximizedWindowParentBounds(child); else if (wm::IsWindowFullscreen(child)) - child_bounds = gfx::Screen::GetDisplayNearestWindow(child).bounds(); + child_bounds = ScreenAsh::GetDisplayParentBounds(child); SetChildBoundsDirect(child, child_bounds); } @@ -176,11 +177,14 @@ void BaseLayoutManager::UpdateBoundsFromShowState(aura::Window* window, switch (window->GetProperty(aura::client::kShowStateKey)) { case ui::SHOW_STATE_DEFAULT: case ui::SHOW_STATE_NORMAL: { - const gfx::Rect* restore = GetRestoreBounds(window); + const gfx::Rect* restore = GetRestoreBoundsInScreen(window); if (restore) { + gfx::Rect bounds_in_parent = + ScreenAsh::ConvertRectFromScreen(window->parent(), *restore); MaybeAnimateToBounds(window, animate, - BoundsWithScreenEdgeVisible(window, *restore)); + BoundsWithScreenEdgeVisible(window, + bounds_in_parent)); } window->ClearProperty(aura::client::kRestoreBoundsKey); break; @@ -190,7 +194,7 @@ void BaseLayoutManager::UpdateBoundsFromShowState(aura::Window* window, SetRestoreBoundsIfNotSet(window); MaybeAnimateToBounds(window, animate, - ScreenAsh::GetMaximizedWindowBounds(window)); + ScreenAsh::GetMaximizedWindowParentBounds(window)); break; case ui::SHOW_STATE_FULLSCREEN: @@ -198,7 +202,7 @@ void BaseLayoutManager::UpdateBoundsFromShowState(aura::Window* window, // Don't animate the full-screen window transition. // TODO(jamescook): Use animation here. Be sure the lock screen works. SetChildBoundsDirect( - window, gfx::Screen::GetDisplayNearestWindow(window).bounds()); + window, ScreenAsh::GetDisplayParentBounds(window)); break; default: @@ -232,14 +236,15 @@ void BaseLayoutManager::AdjustWindowSizesForScreenChange() { ++it) { aura::Window* window = *it; if (wm::IsWindowMaximized(window)) { - SetChildBoundsDirect(window, ScreenAsh::GetMaximizedWindowBounds(window)); + SetChildBoundsDirect( + window, ScreenAsh::GetMaximizedWindowParentBounds(window)); } else if (wm::IsWindowFullscreen(window)) { SetChildBoundsDirect( - window, gfx::Screen::GetDisplayNearestWindow(window).bounds()); + window, ScreenAsh::GetDisplayParentBounds(window)); } else { // The work area may be smaller than the full screen. gfx::Rect display_rect = - gfx::Screen::GetDisplayNearestWindow(window).work_area(); + ScreenAsh::GetDisplayWorkAreaParentBounds(window); // Put as much of the window as possible within the display area. window->SetBounds(window->bounds().AdjustToFit(display_rect)); } diff --git a/ash/wm/base_layout_manager_unittest.cc b/ash/wm/base_layout_manager_unittest.cc index 2de08af..5d48392 100644 --- a/ash/wm/base_layout_manager_unittest.cc +++ b/ash/wm/base_layout_manager_unittest.cc @@ -54,8 +54,9 @@ TEST_F(BaseLayoutManagerTest, Maximize) { scoped_ptr<aura::Window> window(CreateTestWindow(bounds)); window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED); // Maximized window fills the work area, not the whole display. - EXPECT_EQ(ScreenAsh::GetMaximizedWindowBounds(window.get()).ToString(), - window->bounds().ToString()); + EXPECT_EQ( + ScreenAsh::GetMaximizedWindowParentBounds(window.get()).ToString(), + window->bounds().ToString()); window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL); EXPECT_EQ(bounds.ToString(), window->bounds().ToString()); } @@ -78,14 +79,15 @@ TEST_F(BaseLayoutManagerTest, MaximizeRootWindowResize) { scoped_ptr<aura::Window> window(CreateTestWindow(bounds)); window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED); gfx::Rect initial_work_area_bounds = - ScreenAsh::GetMaximizedWindowBounds(window.get()); + ScreenAsh::GetMaximizedWindowParentBounds(window.get()); EXPECT_EQ(initial_work_area_bounds.ToString(), window->bounds().ToString()); // Enlarge the root window. We should still match the work area size. Shell::GetPrimaryRootWindow()->SetHostSize(gfx::Size(900, 700)); - EXPECT_EQ(ScreenAsh::GetMaximizedWindowBounds(window.get()).ToString(), - window->bounds().ToString()); + EXPECT_EQ( + ScreenAsh::GetMaximizedWindowParentBounds(window.get()).ToString(), + window->bounds().ToString()); EXPECT_NE(initial_work_area_bounds.ToString(), - ScreenAsh::GetMaximizedWindowBounds(window.get()).ToString()); + ScreenAsh::GetMaximizedWindowParentBounds(window.get()).ToString()); } // Tests normal->fullscreen->normal. @@ -166,7 +168,8 @@ TEST_F(BaseLayoutManagerTest, BoundsWithScreenEdgeVisible) { window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL); // It should have the default maximized window bounds, inset by the grid size. int grid_size = ash::Shell::GetInstance()->GetGridSize(); - gfx::Rect max_bounds = ash::ScreenAsh::GetMaximizedWindowBounds(window.get()); + gfx::Rect max_bounds = + ash::ScreenAsh::GetMaximizedWindowParentBounds(window.get()); max_bounds.Inset(grid_size, grid_size); EXPECT_EQ(max_bounds.ToString(), window->bounds().ToString()); } diff --git a/ash/wm/panel_layout_manager.cc b/ash/wm/panel_layout_manager.cc index 451b1af..84dfdc6 100644 --- a/ash/wm/panel_layout_manager.cc +++ b/ash/wm/panel_layout_manager.cc @@ -128,7 +128,7 @@ void PanelLayoutManager::ToggleMinimize(aura::Window* panel) { panel->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL); gfx::Rect new_bounds(old_bounds); - const gfx::Rect* restore_bounds = GetRestoreBounds(panel); + const gfx::Rect* restore_bounds = GetRestoreBoundsInScreen(panel); if (restore_bounds) { new_bounds.set_height(restore_bounds->height()); new_bounds.set_y(old_bounds.bottom() - restore_bounds->height()); @@ -138,7 +138,7 @@ void PanelLayoutManager::ToggleMinimize(aura::Window* panel) { } else { const gfx::Rect& old_bounds = panel->bounds(); panel->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED); - SetRestoreBounds(panel, old_bounds); + SetRestoreBoundsInParent(panel, old_bounds); SetChildBounds(panel, gfx::Rect(old_bounds.x(), old_bounds.bottom() - kMinimizedHeight, @@ -353,7 +353,7 @@ void PanelLayoutManager::UpdateCallout(aura::Window* active_panel) { void PanelLayoutManager::ShowCalloutHelper(aura::Window* active_panel) { DCHECK(active_panel); - gfx::Rect bounds = active_panel->GetBoundsInRootWindow(); + gfx::Rect bounds = active_panel->GetRootWindowBounds(); gfx::Rect callout_bounds = callout_widget_->GetWindowScreenBounds(); callout_bounds.set_x( bounds.x() + (bounds.width() - callout_bounds.width()) / 2); diff --git a/ash/wm/panel_layout_manager_unittest.cc b/ash/wm/panel_layout_manager_unittest.cc index 3a4fd37..7835575 100644 --- a/ash/wm/panel_layout_manager_unittest.cc +++ b/ash/wm/panel_layout_manager_unittest.cc @@ -80,7 +80,7 @@ class PanelLayoutManagerTest : public ash::test::AshTestBase { gfx::Rect icon_bounds = launcher->GetScreenBoundsOfItemIconForWindow(panel); ASSERT_FALSE(icon_bounds.IsEmpty()); - gfx::Rect window_bounds = panel->GetBoundsInRootWindow(); + gfx::Rect window_bounds = panel->GetRootWindowBounds(); // 1-pixel tolerance--since we center panels over their icons, panels with // odd pixel widths won't be perfectly lined up with even pixel width @@ -98,9 +98,9 @@ class PanelLayoutManagerTest : public ash::test::AshTestBase { views::Widget* widget = NULL; GetCalloutWidget(&widget); EXPECT_TRUE(widget->IsVisible()); - EXPECT_EQ(panel->GetBoundsInRootWindow().bottom(), + EXPECT_EQ(panel->GetRootWindowBounds().bottom(), widget->GetWindowScreenBounds().y()); - EXPECT_NEAR(panel->GetBoundsInRootWindow().CenterPoint().x(), + EXPECT_NEAR(panel->GetRootWindowBounds().CenterPoint().x(), widget->GetWindowScreenBounds().CenterPoint().x(), 1); } diff --git a/ash/wm/property_util.cc b/ash/wm/property_util.cc index a51d298..8453ce3 100644 --- a/ash/wm/property_util.cc +++ b/ash/wm/property_util.cc @@ -5,6 +5,7 @@ #include "ash/wm/property_util.h" #include "ash/ash_export.h" +#include "ash/screen_ash.h" #include "ash/wm/window_properties.h" #include "ash/wm/window_util.h" #include "ui/aura/client/aura_constants.h" @@ -18,19 +19,32 @@ namespace { bool g_default_windows_persist_across_all_workspaces = false; } // namespace -void SetRestoreBounds(aura::Window* window, const gfx::Rect& bounds) { +void SetRestoreBoundsInScreen(aura::Window* window, const gfx::Rect& bounds) { window->SetProperty(aura::client::kRestoreBoundsKey, new gfx::Rect(bounds)); } +void SetRestoreBoundsInParent(aura::Window* window, const gfx::Rect& bounds) { + window->SetProperty( + aura::client::kRestoreBoundsKey, + new gfx::Rect(ScreenAsh::ConvertRectToScreen(window->parent(), bounds))); +} + void SetRestoreBoundsIfNotSet(aura::Window* window) { - if (!GetRestoreBounds(window)) - SetRestoreBounds(window, window->bounds()); + if (!GetRestoreBoundsInScreen(window)) + SetRestoreBoundsInParent(window, window->bounds()); } -const gfx::Rect* GetRestoreBounds(aura::Window* window) { +const gfx::Rect* GetRestoreBoundsInScreen(aura::Window* window) { return window->GetProperty(aura::client::kRestoreBoundsKey); } +gfx::Rect GetRestoreBoundsInParent(aura::Window* window) { + const gfx::Rect* rect = window->GetProperty(aura::client::kRestoreBoundsKey); + if (!rect) + return gfx::Rect(); + return ScreenAsh::ConvertRectFromScreen(window->parent(), *rect); +} + void ClearRestoreBounds(aura::Window* window) { window->ClearProperty(aura::client::kRestoreBoundsKey); } diff --git a/ash/wm/property_util.h b/ash/wm/property_util.h index 029880a..75adf0a 100644 --- a/ash/wm/property_util.h +++ b/ash/wm/property_util.h @@ -21,18 +21,26 @@ namespace internal { class RootWindowController; } -// Sets the restore bounds property on |window|. Deletes existing bounds value -// if exists. -ASH_EXPORT void SetRestoreBounds(aura::Window* window, const gfx::Rect& bounds); +// Sets the restore bounds property on |window| in the virtual screen +// coordinates. Deletes existing bounds value if exists. +ASH_EXPORT void SetRestoreBoundsInScreen(aura::Window* window, + const gfx::Rect& screen_bounds); +// Same as |SetRestoreBoundsInScreen| except that the bounds is in the +// parent's coordinates. +ASH_EXPORT void SetRestoreBoundsInParent(aura::Window* window, + const gfx::Rect& parent_bounds); // Same as SetRestoreBounds(), but does nothing if the restore bounds have // already been set. The bounds used are the bounds of the window. ASH_EXPORT void SetRestoreBoundsIfNotSet(aura::Window* window); -// Returns the restore bounds property on |window|. NULL if the -// restore bounds property does not exist for |window|. |window| -// owns the bounds object. -ASH_EXPORT const gfx::Rect* GetRestoreBounds(aura::Window* window); +// Returns the restore bounds property on |window| in the virtual screen +// coordinates. The bounds can be NULL if the bounds property does not +// exist for |window|. |window| owns the bounds object. +ASH_EXPORT const gfx::Rect* GetRestoreBoundsInScreen(aura::Window* window); +// Same as |GetRestoreBoundsInScreen| except that it returns the +// bounds in the parent's coordinates. +ASH_EXPORT gfx::Rect GetRestoreBoundsInParent(aura::Window* window); // Deletes and clears the restore bounds property on |window|. ASH_EXPORT void ClearRestoreBounds(aura::Window* window); diff --git a/ash/wm/shelf_layout_manager.cc b/ash/wm/shelf_layout_manager.cc index 455986f..2b4031f 100644 --- a/ash/wm/shelf_layout_manager.cc +++ b/ash/wm/shelf_layout_manager.cc @@ -156,35 +156,6 @@ bool ShelfLayoutManager::IsVisible() const { state_.auto_hide_state == AUTO_HIDE_SHOWN)); } -gfx::Rect ShelfLayoutManager::GetMaximizedWindowBounds( - aura::Window* window) { - // TODO: needs to be multi-mon aware. - gfx::Rect bounds(gfx::Screen::GetDisplayNearestWindow(window).bounds()); - if (auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_DEFAULT || - auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS) { - AdjustBoundsBasedOnAlignment(kAutoHideSize, &bounds); - return bounds; - } - // SHELF_AUTO_HIDE_BEHAVIOR_NEVER maximized windows don't get any taller. - return GetUnmaximizedWorkAreaBounds(window); -} - -gfx::Rect ShelfLayoutManager::GetUnmaximizedWorkAreaBounds( - aura::Window* window) { - // TODO: needs to be multi-mon aware. - gfx::Rect bounds(gfx::Screen::GetDisplayNearestWindow(window).bounds()); - int size; - if (auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS) { - size = kAutoHideSize; - } else { - int width, height; - GetShelfSize(&width, &height); - size = std::max(width, height); - } - AdjustBoundsBasedOnAlignment(size, &bounds); - return bounds; -} - void ShelfLayoutManager::SetLauncher(Launcher* launcher) { if (launcher == launcher_) return; @@ -209,10 +180,10 @@ bool ShelfLayoutManager::SetAlignment(ShelfAlignment alignment) { } gfx::Rect ShelfLayoutManager::GetIdealBounds() { - // TODO: this is wrong. Figure out what display shelf is on and everything - // should be based on it. - gfx::Rect bounds( - gfx::Screen::GetDisplayNearestWindow(status_->GetNativeView()).bounds()); + // TODO(oshima): this is wrong. Figure out what display shelf is on + // and everything should be based on it. + gfx::Rect bounds(ScreenAsh::GetDisplayParentBounds( + status_->GetNativeView())); int width = 0, height = 0; GetShelfSize(&width, &height); switch (alignment_) { @@ -350,6 +321,33 @@ void ShelfLayoutManager::OnWindowActivated(aura::Window* active, //////////////////////////////////////////////////////////////////////////////// // ShelfLayoutManager, private: +gfx::Rect ShelfLayoutManager::GetMaximizedWindowBounds( + aura::Window* window) { + gfx::Rect bounds(ScreenAsh::GetDisplayParentBounds(window)); + if (auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_DEFAULT || + auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS) { + AdjustBoundsBasedOnAlignment(kAutoHideSize, &bounds); + return bounds; + } + // SHELF_AUTO_HIDE_BEHAVIOR_NEVER maximized windows don't get any taller. + return GetUnmaximizedWorkAreaBounds(window); +} + +gfx::Rect ShelfLayoutManager::GetUnmaximizedWorkAreaBounds( + aura::Window* window) { + gfx::Rect bounds(ScreenAsh::GetDisplayParentBounds(window)); + int size; + if (auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS) { + size = kAutoHideSize; + } else { + int width, height; + GetShelfSize(&width, &height); + size = std::max(width, height); + } + AdjustBoundsBasedOnAlignment(size, &bounds); + return bounds; +} + void ShelfLayoutManager::SetState(VisibilityState visibility_state) { ShellDelegate* delegate = Shell::GetInstance()->delegate(); State state; diff --git a/ash/wm/shelf_layout_manager.h b/ash/wm/shelf_layout_manager.h index 2a372a8..ff9e439 100644 --- a/ash/wm/shelf_layout_manager.h +++ b/ash/wm/shelf_layout_manager.h @@ -11,6 +11,7 @@ #include "ash/wm/shelf_types.h" #include "base/basictypes.h" #include "base/compiler_specific.h" +#include "base/gtest_prod_util.h" #include "base/observer_list.h" #include "base/timer.h" #include "ui/aura/client/activation_change_observer.h" @@ -27,6 +28,7 @@ class Widget; } namespace ash { +class ScreenAsh; namespace internal { class ShelfLayoutManagerTest; @@ -114,10 +116,7 @@ class ASH_EXPORT ShelfLayoutManager : // on the screen. bool IsVisible() const; - // Returns the bounds the specified window should be when maximized. - gfx::Rect GetMaximizedWindowBounds(aura::Window* window); - gfx::Rect GetUnmaximizedWorkAreaBounds(aura::Window* window); - + public: // The launcher is typically created after the layout manager. void SetLauncher(Launcher* launcher); Launcher* launcher() { return launcher_; } @@ -164,7 +163,9 @@ class ASH_EXPORT ShelfLayoutManager : private: class AutoHideEventFilter; + friend class ash::ScreenAsh; friend class ShelfLayoutManagerTest; + FRIEND_TEST_ALL_PREFIXES(ShelfLayoutManagerTest, SetAutoHideBehavior); struct TargetBounds { TargetBounds() : opacity(0.0f) {} @@ -195,6 +196,10 @@ class ASH_EXPORT ShelfLayoutManager : bool is_screen_locked; }; + // Returns the bounds the specified window should be when maximized. + gfx::Rect GetMaximizedWindowBounds(aura::Window* window); + gfx::Rect GetUnmaximizedWorkAreaBounds(aura::Window* window); + // Sets the visibility of the shelf to |state|. void SetState(VisibilityState visibility_state); diff --git a/ash/wm/shelf_layout_manager_unittest.cc b/ash/wm/shelf_layout_manager_unittest.cc index 898cc2a..31b7e69 100644 --- a/ash/wm/shelf_layout_manager_unittest.cc +++ b/ash/wm/shelf_layout_manager_unittest.cc @@ -350,17 +350,17 @@ TEST_F(ShelfLayoutManagerTest, SetAutoHideBehavior) { widget->Maximize(); EXPECT_EQ(ShelfLayoutManager::VISIBLE, shelf->visibility_state()); EXPECT_EQ(gfx::Screen::GetDisplayNearestWindow(window).work_area().bottom(), - widget->GetWorkAreaBoundsInScreen().bottom()); + widget->GetWorkAreaScreenBounds().bottom()); shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS); EXPECT_EQ(ShelfLayoutManager::AUTO_HIDE, shelf->visibility_state()); EXPECT_EQ(gfx::Screen::GetDisplayNearestWindow(window).work_area().bottom(), - widget->GetWorkAreaBoundsInScreen().bottom()); + widget->GetWorkAreaScreenBounds().bottom()); shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER); EXPECT_EQ(ShelfLayoutManager::VISIBLE, shelf->visibility_state()); EXPECT_EQ(gfx::Screen::GetDisplayNearestWindow(window).work_area().bottom(), - widget->GetWorkAreaBoundsInScreen().bottom()); + widget->GetWorkAreaScreenBounds().bottom()); } // Verifies the shelf is visible when status/launcher is focused. diff --git a/ash/wm/system_gesture_event_filter.cc b/ash/wm/system_gesture_event_filter.cc index b6e83a8..91fa4cd 100644 --- a/ash/wm/system_gesture_event_filter.cc +++ b/ash/wm/system_gesture_event_filter.cc @@ -401,7 +401,8 @@ class SystemPinchHandler { case ui::ET_GESTURE_PINCH_UPDATE: { // The PINCH_UPDATE events contain incremental scaling updates. pinch_factor_ *= event.details().scale(); - gfx::Rect bounds = GetPhantomWindowBounds(target_, event.location()); + gfx::Rect bounds = + GetPhantomWindowScreenBounds(target_, event.location()); if (phantom_state_ != PHANTOM_WINDOW_NORMAL || phantom_.IsShowing()) phantom_.Show(bounds); break; @@ -432,16 +433,18 @@ class SystemPinchHandler { } private: - gfx::Rect GetPhantomWindowBounds(aura::Window* window, - const gfx::Point& point) { + gfx::Rect GetPhantomWindowScreenBounds(aura::Window* window, + const gfx::Point& point) { if (pinch_factor_ > kPinchThresholdForMaximize) { phantom_state_ = PHANTOM_WINDOW_MAXIMIZED; - return ScreenAsh::GetMaximizedWindowBounds(target_); + return ScreenAsh::ConvertRectToScreen( + target_->parent(), + ScreenAsh::GetMaximizedWindowParentBounds(target_)); } if (pinch_factor_ < kPinchThresholdForMinimize) { if (wm::IsWindowMaximized(window) || wm::IsWindowFullscreen(window)) { - const gfx::Rect* restore = GetRestoreBounds(window); + const gfx::Rect* restore = GetRestoreBoundsInScreen(window); if (restore) { phantom_state_ = PHANTOM_WINDOW_MINIMIZED; return *restore; diff --git a/ash/wm/toplevel_window_event_filter_unittest.cc b/ash/wm/toplevel_window_event_filter_unittest.cc index ca9aeeb..7683b3a 100644 --- a/ash/wm/toplevel_window_event_filter_unittest.cc +++ b/ash/wm/toplevel_window_event_filter_unittest.cc @@ -477,7 +477,7 @@ TEST_F(ToplevelWindowEventFilterTest, GestureDrag) { old_bounds = target->bounds(); // Snap left. - end = location = target->GetBoundsInRootWindow().CenterPoint(); + end = location = target->GetRootWindowBounds().CenterPoint(); end.Offset(-100, 0); generator.GestureScrollSequence(location, end, base::TimeDelta::FromMilliseconds(5), @@ -493,7 +493,7 @@ TEST_F(ToplevelWindowEventFilterTest, GestureDrag) { old_bounds = target->bounds(); // Maximize. - end = location = target->GetBoundsInRootWindow().CenterPoint(); + end = location = target->GetRootWindowBounds().CenterPoint(); end.Offset(0, -100); generator.GestureScrollSequence(location, end, base::TimeDelta::FromMilliseconds(5), @@ -506,7 +506,7 @@ TEST_F(ToplevelWindowEventFilterTest, GestureDrag) { target->SetBounds(old_bounds); // Minimize. - end = location = target->GetBoundsInRootWindow().CenterPoint(); + end = location = target->GetRootWindowBounds().CenterPoint(); end.Offset(0, 100); generator.GestureScrollSequence(location, end, base::TimeDelta::FromMilliseconds(5), diff --git a/ash/wm/video_detector.cc b/ash/wm/video_detector.cc index 5b32a53..52a3ded 100644 --- a/ash/wm/video_detector.cc +++ b/ash/wm/video_detector.cc @@ -100,7 +100,7 @@ void VideoDetector::MaybeNotifyObservers(aura::Window* window, return; gfx::Rect root_bounds = window->GetRootWindow()->bounds(); - if (!window->GetBoundsInRootWindow().Intersects(root_bounds)) + if (!window->GetRootWindowBounds().Intersects(root_bounds)) return; FOR_EACH_OBSERVER(VideoDetectorObserver, observers_, OnVideoDetected()); diff --git a/ash/wm/window_properties.cc b/ash/wm/window_properties.cc index a312149..acf749d 100644 --- a/ash/wm/window_properties.cc +++ b/ash/wm/window_properties.cc @@ -27,16 +27,17 @@ DEFINE_WINDOW_PROPERTY_KEY( bool, kChildWindowVisibilityChangesAnimatedKey, false); DEFINE_WINDOW_PROPERTY_KEY( ui::WindowShowState, kRestoreShowStateKey, ui::SHOW_STATE_DEFAULT); +DEFINE_WINDOW_PROPERTY_KEY(RootWindowController*, + kRootWindowControllerKey, NULL); DEFINE_WINDOW_PROPERTY_KEY(ShadowType, kShadowTypeKey, SHADOW_TYPE_NONE); DEFINE_OWNED_WINDOW_PROPERTY_KEY(ui_controls::UIControlsAura, kUIControlsKey, NULL); +DEFINE_WINDOW_PROPERTY_KEY(bool, kUsesScreenCoordinatesKey, false); DEFINE_WINDOW_PROPERTY_KEY(ash::WindowPersistsAcrossAllWorkspacesType, kWindowPersistsAcrossAllWorkspacesKey, WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_DEFAULT); DEFINE_WINDOW_PROPERTY_KEY(bool, kWindowTrackedByWorkspaceKey, true); -DEFINE_WINDOW_PROPERTY_KEY(RootWindowController*, - kRootWindowControllerKey, NULL); } // namespace internal } // namespace ash diff --git a/ash/wm/window_properties.h b/ash/wm/window_properties.h index 041db7e..f70487a 100644 --- a/ash/wm/window_properties.h +++ b/ash/wm/window_properties.h @@ -37,6 +37,9 @@ extern const aura::WindowProperty<bool>* const extern const aura::WindowProperty<ui::WindowShowState>* const kRestoreShowStateKey; +extern const aura::WindowProperty<RootWindowController*>* const + kRootWindowControllerKey; + // A property key describing the drop shadow that should be displayed under the // window. If unset, no shadow is displayed. extern const aura::WindowProperty<ShadowType>* const kShadowTypeKey; @@ -45,6 +48,9 @@ extern const aura::WindowProperty<ShadowType>* const kShadowTypeKey; extern const aura::WindowProperty<ui_controls::UIControlsAura*>* const kUIControlsKey; +// Property to tell if the container uses the screen coordinates. +extern const aura::WindowProperty<bool>* const kUsesScreenCoordinatesKey; + extern const aura::WindowProperty<WindowPersistsAcrossAllWorkspacesType>* const kWindowPersistsAcrossAllWorkspacesKey; @@ -52,9 +58,6 @@ extern const aura::WindowProperty<WindowPersistsAcrossAllWorkspacesType>* const extern const aura::WindowProperty<bool>* const kWindowTrackedByWorkspaceKey; -extern const aura::WindowProperty<RootWindowController*>* const - kRootWindowControllerKey; - // Alphabetical sort. } // namespace internal diff --git a/ash/wm/window_resizer.cc b/ash/wm/window_resizer.cc index df28ec7..7cea2e1 100644 --- a/ash/wm/window_resizer.cc +++ b/ash/wm/window_resizer.cc @@ -4,6 +4,7 @@ #include "ash/wm/window_resizer.h" +#include "ash/screen_ash.h" #include "ash/shell.h" #include "ui/aura/client/aura_constants.h" #include "ui/aura/root_window.h" @@ -202,8 +203,8 @@ gfx::Rect WindowResizer::CalculateBoundsForDrag( if (details.window_component == HTBOTTOM || details.window_component == HTBOTTOMRIGHT || details.window_component == HTBOTTOMLEFT) { - gfx::Rect work_area = gfx::Screen::GetDisplayNearestWindow( - details.window).work_area(); + gfx::Rect work_area = + ScreenAsh::GetDisplayWorkAreaParentBounds(details.window); if (new_bounds.bottom() > work_area.bottom()) new_bounds.Inset(0, 0, 0, new_bounds.bottom() - work_area.bottom()); diff --git a/ash/wm/window_util.cc b/ash/wm/window_util.cc index 17f6034..5e9f37a 100644 --- a/ash/wm/window_util.cc +++ b/ash/wm/window_util.cc @@ -59,6 +59,11 @@ bool CanActivateWindow(aura::Window* window) { return client && client->CanActivateWindow(window); } +internal::RootWindowController* GetRootWindowController( + aura::RootWindow* root_window) { + return root_window->GetProperty(internal::kRootWindowControllerKey); +} + bool IsWindowNormal(aura::Window* window) { return window->GetProperty(aura::client::kShowStateKey) == ui::SHOW_STATE_NORMAL || @@ -99,10 +104,5 @@ void CenterWindow(aura::Window* window) { window->SetBounds(center); } -internal::RootWindowController* GetRootWindowController( - aura::RootWindow* root_window) { - return root_window->GetProperty(internal::kRootWindowControllerKey); -} - } // namespace wm } // namespace ash diff --git a/ash/wm/workspace/frame_maximize_button.cc b/ash/wm/workspace/frame_maximize_button.cc index fe4ccf1..2504e2b 100644 --- a/ash/wm/workspace/frame_maximize_button.cc +++ b/ash/wm/workspace/frame_maximize_button.cc @@ -14,6 +14,7 @@ #include "grit/ui_resources.h" #include "ui/aura/event.h" #include "ui/aura/event_filter.h" +#include "ui/aura/window.h" #include "ui/base/l10n/l10n_util.h" #include "ui/base/resource/resource_bundle.h" #include "ui/gfx/image/image.h" @@ -304,7 +305,9 @@ void FrameMaximizeButton::UpdateSnap(const gfx::Point& location) { if (type == snap_type_) { if (snap_sizer_.get()) { snap_sizer_->Update(LocationForSnapSizer(location)); - phantom_window_->Show(snap_sizer_->target_bounds()); + phantom_window_->Show(ScreenAsh::ConvertRectToScreen( + frame_->GetWidget()->GetNativeView()->parent(), + snap_sizer_->target_bounds())); } return; } @@ -330,7 +333,7 @@ void FrameMaximizeButton::UpdateSnap(const gfx::Point& location) { phantom_window_.reset(new internal::PhantomWindowController( frame_->GetWidget()->GetNativeWindow())); } - phantom_window_->Show(BoundsForType(snap_type_)); + phantom_window_->Show(ScreenBoundsForType(snap_type_)); } FrameMaximizeButton::SnapType FrameMaximizeButton::SnapTypeForLocation( @@ -348,14 +351,18 @@ FrameMaximizeButton::SnapType FrameMaximizeButton::SnapTypeForLocation( return !frame_->GetWidget()->IsMaximized() ? SNAP_MAXIMIZE : SNAP_RESTORE; } -gfx::Rect FrameMaximizeButton::BoundsForType(SnapType type) const { +gfx::Rect FrameMaximizeButton::ScreenBoundsForType(SnapType type) const { aura::Window* window = frame_->GetWidget()->GetNativeWindow(); switch (type) { case SNAP_LEFT: case SNAP_RIGHT: - return snap_sizer_->target_bounds(); + return ScreenAsh::ConvertRectToScreen( + frame_->GetWidget()->GetNativeView()->parent(), + snap_sizer_->target_bounds()); case SNAP_MAXIMIZE: - return ScreenAsh::GetMaximizedWindowBounds(window); + return ScreenAsh::ConvertRectToScreen( + window->parent(), + ScreenAsh::GetMaximizedWindowParentBounds(window)); case SNAP_MINIMIZE: { Launcher* launcher = Shell::GetInstance()->launcher(); gfx::Rect item_rect(launcher->GetScreenBoundsOfItemIconForWindow(window)); @@ -368,7 +375,7 @@ gfx::Rect FrameMaximizeButton::BoundsForType(SnapType type) const { return launcher->widget()->GetWindowScreenBounds(); } case SNAP_RESTORE: { - const gfx::Rect* restore = GetRestoreBounds(window); + const gfx::Rect* restore = GetRestoreBoundsInScreen(window); return restore ? *restore : frame_->GetWidget()->GetWindowScreenBounds(); } case SNAP_NONE: @@ -389,11 +396,11 @@ void FrameMaximizeButton::Snap() { case SNAP_LEFT: case SNAP_RIGHT: if (frame_->GetWidget()->IsMaximized()) { - ash::SetRestoreBounds(frame_->GetWidget()->GetNativeWindow(), - BoundsForType(snap_type_)); + ash::SetRestoreBoundsInScreen(frame_->GetWidget()->GetNativeWindow(), + ScreenBoundsForType(snap_type_)); frame_->GetWidget()->Restore(); } else { - frame_->GetWidget()->SetBounds(BoundsForType(snap_type_)); + frame_->GetWidget()->SetBounds(ScreenBoundsForType(snap_type_)); } break; case SNAP_MAXIMIZE: diff --git a/ash/wm/workspace/frame_maximize_button.h b/ash/wm/workspace/frame_maximize_button.h index 9bca380..7cc7b7b 100644 --- a/ash/wm/workspace/frame_maximize_button.h +++ b/ash/wm/workspace/frame_maximize_button.h @@ -85,7 +85,7 @@ class ASH_EXPORT FrameMaximizeButton : public views::ImageButton { SnapType SnapTypeForLocation(const gfx::Point& location) const; // Returns the bounds of the resulting window for the specified type. - gfx::Rect BoundsForType(SnapType type) const; + gfx::Rect ScreenBoundsForType(SnapType type) const; // Converts location to screen coordinates and returns it. These are the // coordinates used by the SnapSizer. diff --git a/ash/wm/workspace/maximized_workspace.cc b/ash/wm/workspace/maximized_workspace.cc index f7e1b7a..6182b09 100644 --- a/ash/wm/workspace/maximized_workspace.cc +++ b/ash/wm/workspace/maximized_workspace.cc @@ -41,9 +41,10 @@ void MaximizedWorkspace::OnWindowRemoved(aura::Window* window) { void MaximizedWorkspace::ResetWindowBounds(aura::Window* window) { if (wm::IsWindowFullscreen(window)) { SetWindowBounds(window, - gfx::Screen::GetDisplayNearestWindow(window).bounds()); + ScreenAsh::GetDisplayParentBounds(window)); } else { - SetWindowBounds(window, ScreenAsh::GetMaximizedWindowBounds(window)); + SetWindowBounds(window, + ScreenAsh::GetMaximizedWindowParentBounds(window)); } } diff --git a/ash/wm/workspace/phantom_window_controller.cc b/ash/wm/workspace/phantom_window_controller.cc index ec535ec..45d6140 100644 --- a/ash/wm/workspace/phantom_window_controller.cc +++ b/ash/wm/workspace/phantom_window_controller.cc @@ -86,7 +86,7 @@ void PhantomWindowController::Show(const gfx::Rect& bounds) { if (!phantom_widget_.get()) { // Show the phantom at the bounds of the window. We'll animate to the target // bounds. - start_bounds_ = window_->bounds(); + start_bounds_ = window_->GetScreenBounds(); CreatePhantomWidget(start_bounds_); } else { start_bounds_ = phantom_widget_->GetWindowScreenBounds(); @@ -126,7 +126,7 @@ void PhantomWindowController::CreatePhantomWidget(const gfx::Rect& bounds) { // launcher button. Put the phantom in the same window as the launcher so that // the phantom is visible. params.parent = Shell::GetContainer( - Shell::GetActiveRootWindow(), + Shell::GetInstance()->GetRootWindowMatching(bounds), kShellWindowId_LauncherContainer); params.can_activate = false; params.keep_on_top = true; diff --git a/ash/wm/workspace/snap_sizer.cc b/ash/wm/workspace/snap_sizer.cc index c303f1d..997b719 100644 --- a/ash/wm/workspace/snap_sizer.cc +++ b/ash/wm/workspace/snap_sizer.cc @@ -110,7 +110,7 @@ gfx::Rect SnapSizer::GetTargetBounds() const { } gfx::Rect SnapSizer::GetTargetBoundsForPercent(int percent_index) const { - gfx::Rect work_area(ScreenAsh::GetUnmaximizedWorkAreaBounds(window_)); + gfx::Rect work_area(ScreenAsh::GetUnmaximizedWorkAreaParentBounds(window_)); int y = WindowResizer::AlignToGridRoundUp(work_area.y(), grid_size_); // We don't align to the bottom of the grid as the launcher may not // necessarily align to the grid (happens when auto-hidden). @@ -129,8 +129,7 @@ gfx::Rect SnapSizer::GetTargetBoundsForPercent(int percent_index) const { } bool SnapSizer::AlongEdge(int x) const { - // TODO: need to support multi-display. - gfx::Rect area(gfx::Screen::GetDisplayNearestWindow(window_).bounds()); + gfx::Rect area(ScreenAsh::GetDisplayParentBounds(window_)); return (x <= area.x()) || (x >= area.right() - 1); } diff --git a/ash/wm/workspace/snap_sizer.h b/ash/wm/workspace/snap_sizer.h index f597c8b..472c9e1 100644 --- a/ash/wm/workspace/snap_sizer.h +++ b/ash/wm/workspace/snap_sizer.h @@ -19,6 +19,7 @@ namespace internal { // SnapSizer is responsible for determining the resulting bounds of a window // that is being snapped to the left or right side of the screen. +// The bounds used in this class are in the container's coordinates. class ASH_EXPORT SnapSizer { public: enum Edge { diff --git a/ash/wm/workspace/workspace_event_filter.cc b/ash/wm/workspace/workspace_event_filter.cc index 863b418..564e176 100644 --- a/ash/wm/workspace/workspace_event_filter.cc +++ b/ash/wm/workspace/workspace_event_filter.cc @@ -4,6 +4,7 @@ #include "ash/wm/workspace/workspace_event_filter.h" +#include "ash/screen_ash.h" #include "ash/wm/property_util.h" #include "ash/wm/window_frame.h" #include "ash/wm/window_util.h" @@ -17,6 +18,7 @@ #include "ui/compositor/scoped_layer_animation_settings.h" #include "ui/gfx/screen.h" +namespace ash { namespace { // Sends OnWindowHoveredChanged(|hovered|) to the WindowFrame for |window|, @@ -24,28 +26,32 @@ namespace { void WindowHoverChanged(aura::Window* window, bool hovered) { if (!window) return; - ash::WindowFrame* window_frame = window->GetProperty(ash::kWindowFrameKey); + WindowFrame* window_frame = window->GetProperty(kWindowFrameKey); if (!window_frame) return; window_frame->OnWindowHoverChanged(hovered); } void SingleAxisMaximize(aura::Window* window, const gfx::Rect& maximize_rect) { + gfx::Rect bounds_in_screen = + ScreenAsh::ConvertRectToScreen(window->parent(), window->bounds()); + window->ClearProperty(aura::client::kRestoreBoundsKey); window->SetProperty(aura::client::kRestoreBoundsKey, - new gfx::Rect(window->bounds())); + new gfx::Rect(bounds_in_screen)); window->SetBounds(maximize_rect); } void SingleAxisUnmaximize(aura::Window* window, - const gfx::Rect& restore_bounds) { + const gfx::Rect& restore_bounds_in_screen) { + gfx::Rect restore_bounds = ScreenAsh::ConvertRectFromScreen( + window->parent(), restore_bounds_in_screen); window->SetBounds(restore_bounds); window->ClearProperty(aura::client::kRestoreBoundsKey); } } // namespace -namespace ash { namespace internal { WorkspaceEventFilter::WorkspaceEventFilter(aura::Window* owner) diff --git a/ash/wm/workspace/workspace_manager_unittest.cc b/ash/wm/workspace/workspace_manager_unittest.cc index 0377b7d..6b182ca 100644 --- a/ash/wm/workspace/workspace_manager_unittest.cc +++ b/ash/wm/workspace/workspace_manager_unittest.cc @@ -101,11 +101,11 @@ TEST_F(WorkspaceManagerTest, AddNormalWindowWhenEmpty) { ASSERT_TRUE(manager_->IsManagedWindow(w1.get())); EXPECT_FALSE(FindBy(w1.get())); - EXPECT_TRUE(GetRestoreBounds(w1.get()) == NULL); + EXPECT_TRUE(GetRestoreBoundsInScreen(w1.get()) == NULL); w1->Show(); - EXPECT_TRUE(GetRestoreBounds(w1.get()) == NULL); + EXPECT_TRUE(GetRestoreBoundsInScreen(w1.get()) == NULL); ASSERT_TRUE(w1->layer() != NULL); EXPECT_TRUE(w1->layer()->visible()); @@ -143,9 +143,9 @@ TEST_F(WorkspaceManagerTest, SingleMaximizeWindow) { EXPECT_EQ(Workspace::TYPE_MAXIMIZED, workspaces()[1]->type()); ASSERT_EQ(1u, workspaces()[1]->windows().size()); EXPECT_EQ(w1.get(), workspaces()[1]->windows()[0]); - EXPECT_EQ(ScreenAsh::GetMaximizedWindowBounds(w1.get()).width(), + EXPECT_EQ(ScreenAsh::GetMaximizedWindowParentBounds(w1.get()).width(), w1->bounds().width()); - EXPECT_EQ(ScreenAsh::GetMaximizedWindowBounds(w1.get()).height(), + EXPECT_EQ(ScreenAsh::GetMaximizedWindowParentBounds(w1.get()).height(), w1->bounds().height()); // Restore the window. @@ -203,7 +203,8 @@ TEST_F(WorkspaceManagerTest, AddMaximizedWindowWhenEmpty) { ASSERT_TRUE(w1->layer() != NULL); EXPECT_TRUE(w1->layer()->visible()); - gfx::Rect work_area(ScreenAsh::GetMaximizedWindowBounds(w1.get())); + gfx::Rect work_area( + ScreenAsh::GetMaximizedWindowParentBounds(w1.get())); EXPECT_EQ(work_area.width(), w1->bounds().width()); EXPECT_EQ(work_area.height(), w1->bounds().height()); @@ -241,7 +242,7 @@ TEST_F(WorkspaceManagerTest, MaximizeWithNormalWindow) { ASSERT_TRUE(w2->layer() != NULL); EXPECT_TRUE(w2->layer()->visible()); - gfx::Rect work_area(ScreenAsh::GetMaximizedWindowBounds(w1.get())); + gfx::Rect work_area(ScreenAsh::GetMaximizedWindowParentBounds(w1.get())); EXPECT_EQ(work_area.width(), w2->bounds().width()); EXPECT_EQ(work_area.height(), w2->bounds().height()); @@ -351,8 +352,8 @@ TEST_F(WorkspaceManagerTest, SingleFullscreenWindow) { EXPECT_EQ(w1.get(), workspaces()[1]->windows()[0]); EXPECT_EQ(GetFullscreenBounds(w1.get()).width(), w1->bounds().width()); EXPECT_EQ(GetFullscreenBounds(w1.get()).height(), w1->bounds().height()); - ASSERT_TRUE(GetRestoreBounds(w1.get())); - EXPECT_EQ(gfx::Rect(0, 0, 250, 251), *GetRestoreBounds(w1.get())); + ASSERT_TRUE(GetRestoreBoundsInScreen(w1.get())); + EXPECT_EQ(gfx::Rect(0, 0, 250, 251), *GetRestoreBoundsInScreen(w1.get())); } // Makes sure switching workspaces doesn't show transient windows. @@ -511,7 +512,7 @@ TEST_F(WorkspaceManagerTest, ShelfStateUpdated) { w1->Show(); EXPECT_EQ(ShelfLayoutManager::VISIBLE, shelf->visibility_state()); EXPECT_EQ("0,1 101x102", w1->bounds().ToString()); - EXPECT_EQ(ScreenAsh::GetMaximizedWindowBounds(w2.get()).ToString(), + EXPECT_EQ(ScreenAsh::GetMaximizedWindowParentBounds(w2.get()).ToString(), w2->bounds().ToString()); // Switch to w2. @@ -519,7 +520,7 @@ TEST_F(WorkspaceManagerTest, ShelfStateUpdated) { EXPECT_EQ(ShelfLayoutManager::AUTO_HIDE, shelf->visibility_state()); EXPECT_EQ(ShelfLayoutManager::AUTO_HIDE_HIDDEN, shelf->auto_hide_state()); EXPECT_EQ("0,1 101x102", w1->bounds().ToString()); - EXPECT_EQ(ScreenAsh::GetMaximizedWindowBounds(w2.get()).ToString(), + EXPECT_EQ(ScreenAsh::GetMaximizedWindowParentBounds(w2.get()).ToString(), w2->bounds().ToString()); } diff --git a/ash/wm/workspace/workspace_window_resizer.cc b/ash/wm/workspace/workspace_window_resizer.cc index 26d957c..455afdd 100644 --- a/ash/wm/workspace/workspace_window_resizer.cc +++ b/ash/wm/workspace/workspace_window_resizer.cc @@ -7,6 +7,7 @@ #include <algorithm> #include <cmath> +#include "ash/screen_ash.h" #include "ash/shell.h" #include "ash/wm/property_util.h" #include "ash/wm/window_util.h" @@ -85,8 +86,8 @@ void WorkspaceWindowResizer::CompleteDrag(int event_flags) { return; if (snap_type_ == SNAP_LEFT_EDGE || snap_type_ == SNAP_RIGHT_EDGE) { - if (!GetRestoreBounds(details_.window)) - SetRestoreBounds(details_.window, details_.initial_bounds); + if (!GetRestoreBoundsInScreen(details_.window)) + SetRestoreBoundsInParent(details_.window, details_.initial_bounds); details_.window->SetBounds(snap_sizer_->target_bounds()); return; } @@ -280,7 +281,7 @@ void WorkspaceWindowResizer::AdjustBoundsForMainWindow( gfx::Rect* bounds, int grid_size) const { // Always keep kMinOnscreenHeight on the bottom. gfx::Rect work_area( - gfx::Screen::GetDisplayNearestWindow(window()).work_area()); + ScreenAsh::GetDisplayWorkAreaParentBounds(details_.window)); int max_y = AlignToGridRoundUp(work_area.bottom() - kMinOnscreenHeight, grid_size); if (bounds->y() > max_y) @@ -334,7 +335,7 @@ void WorkspaceWindowResizer::SnapToWorkAreaEdges( bool WorkspaceWindowResizer::TouchesBottomOfScreen() const { gfx::Rect work_area( - gfx::Screen::GetDisplayNearestWindow(details_.window).work_area()); + ScreenAsh::GetDisplayWorkAreaParentBounds(details_.window)); return (attached_windows_.empty() && details_.window->bounds().bottom() == work_area.bottom()) || (!attached_windows_.empty() && @@ -383,7 +384,8 @@ void WorkspaceWindowResizer::UpdatePhantomWindow(const gfx::Point& location, phantom_window_controller_.reset( new PhantomWindowController(details_.window)); } - phantom_window_controller_->Show(snap_sizer_->target_bounds()); + phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen( + details_.window->parent(), snap_sizer_->target_bounds())); } void WorkspaceWindowResizer::RestackWindows() { @@ -421,8 +423,7 @@ WorkspaceWindowResizer::SnapType WorkspaceWindowResizer::GetSnapType( const gfx::Point& location) const { // TODO: this likely only wants total display area, not the area of a single // display. - gfx::Rect area( - gfx::Screen::GetDisplayNearestWindow(details_.window).bounds()); + gfx::Rect area(ScreenAsh::GetDisplayParentBounds(details_.window)); if (location.x() <= area.x()) return SNAP_LEFT_EDGE; if (location.x() >= area.right() - 1) diff --git a/ash/wm/workspace/workspace_window_resizer_unittest.cc b/ash/wm/workspace/workspace_window_resizer_unittest.cc index eed78ae..930ba49 100644 --- a/ash/wm/workspace/workspace_window_resizer_unittest.cc +++ b/ash/wm/workspace/workspace_window_resizer_unittest.cc @@ -431,7 +431,7 @@ TEST_F(WorkspaceWindowResizerTest, AttachedResize_BOTTOM_3_Compress) { // Assertions around dragging to the left/right edge of the screen. TEST_F(WorkspaceWindowResizerTest, Edge) { int bottom = - ScreenAsh::GetUnmaximizedWorkAreaBounds(window_.get()).bottom(); + ScreenAsh::GetUnmaximizedWorkAreaParentBounds(window_.get()).bottom(); window_->SetBounds(gfx::Rect(20, 30, 50, 60)); { SetGridSize(0); @@ -442,8 +442,9 @@ TEST_F(WorkspaceWindowResizerTest, Edge) { resizer->CompleteDrag(0); EXPECT_EQ("0,0 400x" + base::IntToString(bottom), window_->bounds().ToString()); - ASSERT_TRUE(GetRestoreBounds(window_.get())); - EXPECT_EQ("20,30 50x60", GetRestoreBounds(window_.get())->ToString()); + ASSERT_TRUE(GetRestoreBoundsInScreen(window_.get())); + EXPECT_EQ("20,30 50x60", + GetRestoreBoundsInScreen(window_.get())->ToString()); } // Try the same with the right side. @@ -455,8 +456,8 @@ TEST_F(WorkspaceWindowResizerTest, Edge) { resizer->CompleteDrag(0); EXPECT_EQ("400,0 400x" + base::IntToString(bottom), window_->bounds().ToString()); - ASSERT_TRUE(GetRestoreBounds(window_.get())); - EXPECT_EQ("20,30 50x60", GetRestoreBounds(window_.get())->ToString()); + ASSERT_TRUE(GetRestoreBoundsInScreen(window_.get())); + EXPECT_EQ("20,30 50x60", GetRestoreBoundsInScreen(window_.get())->ToString()); } // Verifies windows are correctly restacked when reordering multiple windows. diff --git a/chrome/browser/ui/views/hung_renderer_view.cc b/chrome/browser/ui/views/hung_renderer_view.cc index c0129b6..908aa60 100644 --- a/chrome/browser/ui/views/hung_renderer_view.cc +++ b/chrome/browser/ui/views/hung_renderer_view.cc @@ -548,7 +548,7 @@ void HungRendererDialogView::CreateKillButtonView() { gfx::Rect HungRendererDialogView::GetDisplayBounds( WebContents* contents) { #if defined(USE_AURA) - gfx::Rect contents_bounds(contents->GetNativeView()->GetBoundsInRootWindow()); + gfx::Rect contents_bounds(contents->GetNativeView()->GetRootWindowBounds()); #elif defined(OS_WIN) HWND contents_hwnd = contents->GetNativeView(); RECT contents_bounds_rect; diff --git a/chrome/browser/ui/views/tab_contents/chrome_web_contents_view_delegate_views.cc b/chrome/browser/ui/views/tab_contents/chrome_web_contents_view_delegate_views.cc index 5815006..437ee94 100644 --- a/chrome/browser/ui/views/tab_contents/chrome_web_contents_view_delegate_views.cc +++ b/chrome/browser/ui/views/tab_contents/chrome_web_contents_view_delegate_views.cc @@ -139,17 +139,10 @@ void ChromeWebContentsViewDelegateViews::ShowContextMenu( aura::Window* web_contents_window = web_contents_->GetView()->GetNativeView(); aura::RootWindow* root_window = web_contents_window->GetRootWindow(); - aura::Window::ConvertPointToWindow(web_contents_window, root_window, - &screen_point); - - // If we are on the desktop, transform the data from our toplevel window - // coordinates to screen coordinates. - aura::Window* toplevel_window = - web_contents_->GetView()->GetTopLevelNativeWindow(); aura::client::ScreenPositionClient* screen_position_client = - aura::client::GetScreenPositionClient(toplevel_window); - if (screen_position_client) - screen_position_client->ConvertToScreenPoint(&screen_point); + aura::client::GetScreenPositionClient(root_window); + screen_position_client->ConvertPointToScreen(web_contents_window, + &screen_point); #else POINT temp = screen_point.ToPOINT(); ClientToScreen(web_contents_->GetView()->GetNativeView(), &temp); diff --git a/chrome/browser/ui/window_sizer/window_sizer_ash.cc b/chrome/browser/ui/window_sizer/window_sizer_ash.cc index 3089d69..8e5ef96 100644 --- a/chrome/browser/ui/window_sizer/window_sizer_ash.cc +++ b/chrome/browser/ui/window_sizer/window_sizer_ash.cc @@ -84,7 +84,7 @@ bool WindowSizer::GetBoundsIgnoringPreviousStateAsh( if (top_window == NULL) { GetDefaultWindowBounds(bounds); } else { - *bounds = top_window->GetBoundsInRootWindow(); + *bounds = top_window->GetRootWindowBounds(); gfx::Rect work_area = monitor_info_provider_->GetMonitorWorkAreaMatching(*bounds); *bounds = bounds->AdjustToFit(work_area); diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc index fd78b6f..fa120ca 100644 --- a/content/browser/renderer_host/render_widget_host_view_aura.cc +++ b/content/browser/renderer_host/render_widget_host_view_aura.cc @@ -26,6 +26,7 @@ #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h" #include "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h" #include "ui/aura/client/aura_constants.h" +#include "ui/aura/client/screen_position_client.h" #include "ui/aura/client/tooltip_client.h" #include "ui/aura/client/window_types.h" #include "ui/aura/cursor_manager.h" @@ -338,7 +339,7 @@ bool RenderWidgetHostViewAura::IsShowing() { } gfx::Rect RenderWidgetHostViewAura::GetViewBounds() const { - return window_->GetBoundsInRootWindow(); + return window_->GetRootWindowBounds(); } void RenderWidgetHostViewAura::UpdateCursor(const WebCursor& cursor) { @@ -842,12 +843,10 @@ gfx::Rect RenderWidgetHostViewAura::ConvertRectToScreen(const gfx::Rect& rect) { gfx::Point end = gfx::Point(rect.right(), rect.bottom()); aura::RootWindow* root_window = window_->GetRootWindow(); - aura::Window::ConvertPointToWindow(window_, root_window, &origin); - aura::Window::ConvertPointToWindow(window_, root_window, &end); - // TODO(yusukes): Unlike Chrome OS, |root_window| origin might not be the - // same as the system screen origin on Windows and Linux. Probably we should - // (implement and) use something like ConvertPointToScreen(). - + aura::client::ScreenPositionClient* screen_position_client = + aura::client::GetScreenPositionClient(root_window); + screen_position_client->ConvertPointToScreen(window_, &origin); + screen_position_client->ConvertPointToScreen(window_, &end); return gfx::Rect(origin.x(), origin.y(), end.x() - origin.x(), diff --git a/content/browser/web_contents/web_contents_view_aura.cc b/content/browser/web_contents/web_contents_view_aura.cc index 63fe316..21b82af 100644 --- a/content/browser/web_contents/web_contents_view_aura.cc +++ b/content/browser/web_contents/web_contents_view_aura.cc @@ -304,7 +304,7 @@ gfx::NativeWindow WebContentsViewAura::GetTopLevelNativeWindow() const { } void WebContentsViewAura::GetContainerBounds(gfx::Rect *out) const { - *out = window_->GetBoundsInRootWindow(); + *out = window_->GetScreenBounds(); } void WebContentsViewAura::SetPageTitle(const string16& title) { @@ -398,7 +398,7 @@ void WebContentsViewAura::CloseTabAfterEventTracking() { } gfx::Rect WebContentsViewAura::GetViewBounds() const { - return window_->GetBoundsInRootWindow(); + return window_->GetRootWindowBounds(); } //////////////////////////////////////////////////////////////////////////////// diff --git a/ui/aura/client/screen_position_client.cc b/ui/aura/client/screen_position_client.cc index 75175e2..ac13156 100644 --- a/ui/aura/client/screen_position_client.cc +++ b/ui/aura/client/screen_position_client.cc @@ -4,7 +4,7 @@ #include "ui/aura/client/screen_position_client.h" -#include "ui/aura/window.h" +#include "ui/aura/root_window.h" #include "ui/aura/window_property.h" DECLARE_WINDOW_PROPERTY_TYPE(aura::client::ScreenPositionClient*) @@ -16,12 +16,12 @@ DEFINE_LOCAL_WINDOW_PROPERTY_KEY(ScreenPositionClient*, kScreenPositionClientKey, NULL); -void SetScreenPositionClient(Window* window, +void SetScreenPositionClient(RootWindow* window, ScreenPositionClient* client) { window->SetProperty(kScreenPositionClientKey, client); } -ScreenPositionClient* GetScreenPositionClient(Window* window) { +ScreenPositionClient* GetScreenPositionClient(const RootWindow* window) { return window ? window->GetProperty(kScreenPositionClientKey) : NULL; } diff --git a/ui/aura/client/screen_position_client.h b/ui/aura/client/screen_position_client.h index 99f7d86..3384c44 100644 --- a/ui/aura/client/screen_position_client.h +++ b/ui/aura/client/screen_position_client.h @@ -8,9 +8,14 @@ #include "ui/aura/aura_export.h" #include "ui/aura/window.h" +namespace gfx { +class Rect; +} + namespace aura { class Event; +class RootWindow; class Window; namespace client { @@ -19,18 +24,23 @@ namespace client { // RootWindow into system coordinates. class AURA_EXPORT ScreenPositionClient { public: - // Converts the |screen_point| from a given RootWindow's coordinates space + // Converts the |screen_point| from a given |window|'s coordinate space // into screen coordinate space. - virtual void ConvertToScreenPoint(gfx::Point* screen_point) = 0; - + virtual void ConvertPointToScreen(const Window* window, + gfx::Point* point) = 0; + virtual void ConvertPointFromScreen(const Window* window, + gfx::Point* point) = 0; + // Sets the bounds of the window. The implementation is responsible + // for finding out and translating the right coordinates for the |window|. + virtual void SetBounds(Window* window, const gfx::Rect& bounds) = 0; virtual ~ScreenPositionClient() {} }; // Sets/Gets the activation client on the Window. -AURA_EXPORT void SetScreenPositionClient(Window* window, +AURA_EXPORT void SetScreenPositionClient(RootWindow* window, ScreenPositionClient* client); AURA_EXPORT ScreenPositionClient* GetScreenPositionClient( - Window* window); + const RootWindow* window); } // namespace clients } // namespace aura diff --git a/ui/aura/window.cc b/ui/aura/window.cc index 40a70ef..f652c63 100644 --- a/ui/aura/window.cc +++ b/ui/aura/window.cc @@ -16,6 +16,7 @@ #include "base/stringprintf.h" #include "ui/aura/client/capture_client.h" #include "ui/aura/client/event_client.h" +#include "ui/aura/client/screen_position_client.h" #include "ui/aura/client/stacking_client.h" #include "ui/aura/client/visibility_client.h" #include "ui/aura/env.h" @@ -190,6 +191,9 @@ void Window::SetType(client::WindowType type) { // Cannot change type after the window is initialized. DCHECK(!layer()); type_ = type; + if (type_ == client::WINDOW_TYPE_POPUP) { + LOG(ERROR) << "POPUP:"; + } } void Window::SetName(const std::string& name) { @@ -235,7 +239,7 @@ bool Window::IsVisible() const { return visible_ && layer_ && layer_->IsDrawn(); } -gfx::Rect Window::GetBoundsInRootWindow() const { +gfx::Rect Window::GetRootWindowBounds() const { // TODO(beng): There may be a better way to handle this, and the existing code // is likely wrong anyway in a multi-display world, but this will // do for now. @@ -246,6 +250,21 @@ gfx::Rect Window::GetBoundsInRootWindow() const { return gfx::Rect(origin, bounds().size()); } +gfx::Rect Window::GetScreenBounds() const { + gfx::Rect bounds(GetRootWindowBounds()); + const RootWindow* root = GetRootWindow(); + if (root) { + aura::client::ScreenPositionClient* screen_position_client = + aura::client::GetScreenPositionClient(root); + if (screen_position_client) { + gfx::Point origin = bounds.origin(); + screen_position_client->ConvertPointToScreen(root, &origin); + bounds.set_origin(origin); + } + } + return bounds; +} + void Window::SetTransform(const ui::Transform& transform) { RootWindow* root_window = GetRootWindow(); bool contained_mouse = IsVisible() && root_window && @@ -276,6 +295,20 @@ void Window::SetBounds(const gfx::Rect& new_bounds) { SetBoundsInternal(new_bounds); } +void Window::SetScreenBounds(const gfx::Rect& new_bounds_in_screen) { + RootWindow* root = GetRootWindow(); + if (root) { + gfx::Point origin = new_bounds_in_screen.origin(); + aura::client::ScreenPositionClient* screen_position_client = + aura::client::GetScreenPositionClient(root); + screen_position_client->ConvertPointFromScreen( + parent(), &origin); + SetBounds(gfx::Rect(origin, new_bounds_in_screen.size())); + return; + } + SetBounds(new_bounds_in_screen); +} + gfx::Rect Window::GetTargetBounds() const { return layer_->GetTargetBounds(); } diff --git a/ui/aura/window.h b/ui/aura/window.h index c1f98bc..d9bc9b1 100644 --- a/ui/aura/window.h +++ b/ui/aura/window.h @@ -131,12 +131,14 @@ class AURA_EXPORT Window : public ui::LayerDelegate, // whether Show() without a Hide() has been invoked. bool TargetVisibility() const { return visible_; } - // Returns the window's bounds in screen coordinates. In ash, this is - // effectively screen bounds. - // - // TODO(oshima): Fix this to return screen's coordinate for multi-display - // support. - gfx::Rect GetBoundsInRootWindow() const; + // Returns the window's bounds in root window's coordinates. + gfx::Rect GetRootWindowBounds() const; + + // Returns the window's bounds in screen coordinates. + // How the root window's coordinates is mapped to screen's coordinates + // is platform dependent and defined in the implementation of the + // |aura::client::ScreenPositionClient| interface. + gfx::Rect GetScreenBounds() const; virtual void SetTransform(const ui::Transform& transform); @@ -149,6 +151,10 @@ class AURA_EXPORT Window : public ui::LayerDelegate, // LayoutManager may adjust the bounds. void SetBounds(const gfx::Rect& new_bounds); + // Changes the bounds of the window in the screen coordintates. + // If present, the window's parent's LayoutManager may adjust the bounds. + void SetScreenBounds(const gfx::Rect& new_bounds_in_screen_coords); + // Returns the target bounds of the window. If the window's layer is // not animating, it simply returns the current bounds. gfx::Rect GetTargetBounds() const; diff --git a/ui/aura/window_unittest.cc b/ui/aura/window_unittest.cc index d955719..54a2458 100644 --- a/ui/aura/window_unittest.cc +++ b/ui/aura/window_unittest.cc @@ -934,22 +934,22 @@ TEST_F(WindowTest, ReleaseCaptureOnDestroy) { EXPECT_EQ(NULL, aura::client::GetCaptureWindow(root_window())); } -TEST_F(WindowTest, GetBoundsInRootWindow) { +TEST_F(WindowTest, GetRootWindowBounds) { scoped_ptr<Window> viewport(CreateTestWindowWithBounds( gfx::Rect(0, 0, 300, 300), NULL)); scoped_ptr<Window> child(CreateTestWindowWithBounds( gfx::Rect(0, 0, 100, 100), viewport.get())); // Sanity check. - EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString()); + EXPECT_EQ("0,0 100x100", child->GetRootWindowBounds().ToString()); // The |child| window's screen bounds should move along with the |viewport|. viewport->SetBounds(gfx::Rect(-100, -100, 300, 300)); - EXPECT_EQ("-100,-100 100x100", child->GetBoundsInRootWindow().ToString()); + EXPECT_EQ("-100,-100 100x100", child->GetRootWindowBounds().ToString()); // The |child| window is moved to the 0,0 in screen coordinates. - // |GetBoundsInRootWindow()| should return 0,0. + // |GetRootWindowBounds()| should return 0,0. child->SetBounds(gfx::Rect(100, 100, 100, 100)); - EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString()); + EXPECT_EQ("0,0 100x100", child->GetRootWindowBounds().ToString()); } class MouseEnterExitWindowDelegate : public TestWindowDelegate { diff --git a/ui/oak/oak_aura_window_display.cc b/ui/oak/oak_aura_window_display.cc index 68130091..6bffa624 100644 --- a/ui/oak/oak_aura_window_display.cc +++ b/ui/oak/oak_aura_window_display.cc @@ -123,7 +123,7 @@ string16 OakAuraWindowDisplay::GetText(int row, int column_id) { return PropertyWithBounds("Bounds: ", window_->bounds()); case ROW_BOUNDSINROOTWINDOW: return PropertyWithBounds("Bounds in Root Window: ", - window_->GetBoundsInRootWindow()); + window_->GetRootWindowBounds()); case ROW_TRANSFORM: return ASCIIToUTF16("Transform:"); case ROW_PARENT: diff --git a/ui/views/controls/button/menu_button.cc b/ui/views/controls/button/menu_button.cc index 23607f4..a572654 100644 --- a/ui/views/controls/button/menu_button.cc +++ b/ui/views/controls/button/menu_button.cc @@ -266,7 +266,7 @@ int MenuButton::GetMaximumScreenXCoordinate() { return 0; } - gfx::Rect monitor_bounds = GetWidget()->GetWorkAreaBoundsInScreen(); + gfx::Rect monitor_bounds = GetWidget()->GetWorkAreaScreenBounds(); return monitor_bounds.right() - 1; } diff --git a/ui/views/widget/desktop_native_widget_helper_aura.cc b/ui/views/widget/desktop_native_widget_helper_aura.cc index ad68faf..a10cf3e 100644 --- a/ui/views/widget/desktop_native_widget_helper_aura.cc +++ b/ui/views/widget/desktop_native_widget_helper_aura.cc @@ -34,43 +34,54 @@ DEFINE_WINDOW_PROPERTY_KEY( namespace { -// Client that always offsets the passed in point by the RootHost's origin. -class RootWindowScreenPositionClient +// Client that always offsets by the toplevel RootWindow of the passed +// in child NativeWidgetAura. +class DesktopScreenPositionClient : public aura::client::ScreenPositionClient { public: - explicit RootWindowScreenPositionClient(aura::RootWindow* root_window) - : root_window_(root_window) {} - virtual ~RootWindowScreenPositionClient() {} - - // aura::client::ScreenPositionClient: - virtual void ConvertToScreenPoint(gfx::Point* screen_point) OVERRIDE { - gfx::Point origin = root_window_->GetHostOrigin(); - screen_point->Offset(origin.x(), origin.y()); + DesktopScreenPositionClient() {} + virtual ~DesktopScreenPositionClient() {} + + // aura::client::ScreenPositionClient overrides: + virtual void ConvertPointToScreen(const aura::Window* window, + gfx::Point* point) OVERRIDE { + const aura::RootWindow* root_window = window->GetRootWindow(); + aura::Window::ConvertPointToWindow(window, root_window, point); + gfx::Point origin = root_window->GetHostOrigin(); + point->Offset(origin.x(), origin.y()); } - private: - aura::RootWindow* root_window_; -}; + virtual void ConvertPointFromScreen(const aura::Window* window, + gfx::Point* point) OVERRIDE { + const aura::RootWindow* root_window = window->GetRootWindow(); + gfx::Point origin = root_window->GetHostOrigin(); + point->Offset(-origin.x(), -origin.y()); + aura::Window::ConvertPointToWindow(root_window, window, point); + } -// Client that always offsets by the toplevel RootWindow of the passed in child -// NativeWidgetAura. -class EmbeddedWindowScreenPositionClient - : public aura::client::ScreenPositionClient { - public: - explicit EmbeddedWindowScreenPositionClient(NativeWidgetAura* widget) - : widget_(widget) {} - virtual ~EmbeddedWindowScreenPositionClient() {} + virtual void SetBounds(aura::Window* window, + const gfx::Rect& bounds) OVERRIDE { + gfx::Point origin = bounds.origin(); + aura::RootWindow* root = window->GetRootWindow(); + aura::Window::ConvertPointToWindow(window->parent(), root, &origin); - // aura::client::ScreenPositionClient: - virtual void ConvertToScreenPoint(gfx::Point* screen_point) OVERRIDE { - aura::RootWindow* root = - widget_->GetNativeWindow()->GetRootWindow()->GetRootWindow(); - gfx::Point origin = root->GetHostOrigin(); - screen_point->Offset(origin.x(), origin.y()); +#if !defined(OS_WIN) + if (window->type() == aura::client::WINDOW_TYPE_CONTROL) { + window->SetBounds(gfx::Rect(origin, bounds.size())); + return; + } else if (window->type() == aura::client::WINDOW_TYPE_POPUP) { + // The caller expects windows we consider "embedded" to be placed in the + // screen coordinate system. So we need to offset the root window's + // position (which is in screen coordinates) from these bounds. + gfx::Point host_origin = root->GetHostOrigin(); + origin.Offset(-host_origin.x(), -host_origin.y()); + window->SetBounds(gfx::Rect(origin, bounds.size())); + return; + } +#endif // !defined(OS_WIN) + root->SetHostBounds(bounds); + window->SetBounds(gfx::Rect(bounds.size())); } - - private: - NativeWidgetAura* widget_; }; } // namespace @@ -111,8 +122,6 @@ void DesktopNativeWidgetHelperAura::PreInitialize( if (params.type == Widget::InitParams::TYPE_POPUP || params.type == Widget::InitParams::TYPE_BUBBLE) { is_embedded_window_ = true; - position_client_.reset(new EmbeddedWindowScreenPositionClient(widget_)); - aura::client::SetScreenPositionClient(window, position_client_.get()); return; } else if (params.type == Widget::InitParams::TYPE_CONTROL) { return; @@ -170,9 +179,9 @@ void DesktopNativeWidgetHelperAura::PreInitialize( aura::client::SetDispatcherClient(root_window_.get(), new aura::DesktopDispatcherClient); - position_client_.reset( - new RootWindowScreenPositionClient(root_window_.get())); - aura::client::SetScreenPositionClient(window, position_client_.get()); + position_client_.reset(new DesktopScreenPositionClient()); + aura::client::SetScreenPositionClient(root_window_.get(), + position_client_.get()); } void DesktopNativeWidgetHelperAura::PostInitialize() { diff --git a/ui/views/widget/native_widget_aura.cc b/ui/views/widget/native_widget_aura.cc index dc2f441..cf77b2f 100644 --- a/ui/views/widget/native_widget_aura.cc +++ b/ui/views/widget/native_widget_aura.cc @@ -70,24 +70,10 @@ aura::client::WindowType GetAuraWindowTypeForWidgetType( } } -const gfx::Rect* GetRestoreBounds(aura::Window* window) { - return window->GetProperty(aura::client::kRestoreBoundsKey); -} - void SetRestoreBounds(aura::Window* window, const gfx::Rect& bounds) { window->SetProperty(aura::client::kRestoreBoundsKey, new gfx::Rect(bounds)); } -void AdjustScreenBounds(aura::Window* window, gfx::Rect* bounds) { - aura::client::ScreenPositionClient* screen_position_client = - aura::client::GetScreenPositionClient(window); - if (screen_position_client) { - gfx::Point origin = bounds->origin(); - screen_position_client->ConvertToScreenPoint(&origin); - bounds->set_origin(origin); - } -} - } // namespace // Used when SetInactiveRenderingDisabled() is invoked to track when active @@ -362,19 +348,29 @@ InputMethod* NativeWidgetAura::CreateInputMethod() { } void NativeWidgetAura::CenterWindow(const gfx::Size& size) { - gfx::Rect parent_bounds(window_->parent()->GetBoundsInRootWindow()); + gfx::Rect parent_bounds(window_->parent()->GetRootWindowBounds()); // When centering window, we take the intersection of the host and // the parent. We assume the root window represents the visible // rect of a single screen. gfx::Rect work_area = gfx::Screen::GetDisplayNearestWindow(window_).work_area(); + + aura::client::ScreenPositionClient* screen_position_client = + aura::client::GetScreenPositionClient(window_->GetRootWindow()); + if (screen_position_client) { + gfx::Point origin = work_area.origin(); + screen_position_client->ConvertPointFromScreen(window_->parent(), + &origin); + work_area.set_origin(origin); + } + parent_bounds = parent_bounds.Intersect(work_area); // If |window_|'s transient parent's bounds are big enough to fit it, then we // center it with respect to the transient parent. if (window_->transient_parent()) { gfx::Rect transient_parent_rect = window_->transient_parent()-> - GetBoundsInRootWindow().Intersect(work_area); + GetRootWindowBounds().Intersect(work_area); if (transient_parent_rect.height() >= size.height() && transient_parent_rect.width() >= size.width()) parent_bounds = transient_parent_rect; @@ -433,17 +429,13 @@ void NativeWidgetAura::InitModalType(ui::ModalType modal_type) { } gfx::Rect NativeWidgetAura::GetWindowScreenBounds() const { - gfx::Rect bounds = window_->GetBoundsInRootWindow(); - AdjustScreenBounds(window_, &bounds); - return bounds; + return window_->GetScreenBounds(); } gfx::Rect NativeWidgetAura::GetClientAreaScreenBounds() const { // View-to-screen coordinate system transformations depend on this returning // the full window bounds, for example View::ConvertPointToScreen(). - gfx::Rect bounds = window_->GetBoundsInRootWindow(); - AdjustScreenBounds(window_, &bounds); - return bounds; + return window_->GetScreenBounds(); } gfx::Rect NativeWidgetAura::GetRestoredBounds() const { @@ -457,10 +449,16 @@ gfx::Rect NativeWidgetAura::GetRestoredBounds() const { return restore_bounds ? *restore_bounds : window_->bounds(); } -void NativeWidgetAura::SetBounds(const gfx::Rect& in_bounds) { - gfx::Rect bounds = in_bounds; - if (desktop_helper_.get()) - bounds = desktop_helper_->ModifyAndSetBounds(bounds); +void NativeWidgetAura::SetBounds(const gfx::Rect& bounds) { + aura::RootWindow* root = window_->GetRootWindow(); + if (root) { + aura::client::ScreenPositionClient* screen_position_client = + aura::client::GetScreenPositionClient(root); + if (screen_position_client) { + screen_position_client->SetBounds(window_, bounds); + return; + } + } window_->SetBounds(bounds); } @@ -652,7 +650,7 @@ void NativeWidgetAura::FocusNativeView(gfx::NativeView native_view) { window_->GetFocusManager()->SetFocusedWindow(native_view, NULL); } -gfx::Rect NativeWidgetAura::GetWorkAreaBoundsInScreen() const { +gfx::Rect NativeWidgetAura::GetWorkAreaScreenBounds() const { return gfx::Screen::GetDisplayNearestWindow(GetNativeView()).work_area(); } diff --git a/ui/views/widget/native_widget_aura.h b/ui/views/widget/native_widget_aura.h index 240e657..d54c99e 100644 --- a/ui/views/widget/native_widget_aura.h +++ b/ui/views/widget/native_widget_aura.h @@ -117,7 +117,7 @@ class VIEWS_EXPORT NativeWidgetAura : public internal::NativeWidgetPrivate, virtual void SetCursor(gfx::NativeCursor cursor) OVERRIDE; virtual void ClearNativeFocus() OVERRIDE; virtual void FocusNativeView(gfx::NativeView native_view) OVERRIDE; - virtual gfx::Rect GetWorkAreaBoundsInScreen() const OVERRIDE; + virtual gfx::Rect GetWorkAreaScreenBounds() const OVERRIDE; virtual void SetInactiveRenderingDisabled(bool value) OVERRIDE; virtual Widget::MoveLoopResult RunMoveLoop() OVERRIDE; virtual void EndMoveLoop() OVERRIDE; diff --git a/ui/views/widget/native_widget_private.h b/ui/views/widget/native_widget_private.h index 6f25459..1ae8bd6 100644 --- a/ui/views/widget/native_widget_private.h +++ b/ui/views/widget/native_widget_private.h @@ -208,7 +208,7 @@ class VIEWS_EXPORT NativeWidgetPrivate : public NativeWidget, virtual void SetCursor(gfx::NativeCursor cursor) = 0; virtual void ClearNativeFocus() = 0; virtual void FocusNativeView(gfx::NativeView native_view) = 0; - virtual gfx::Rect GetWorkAreaBoundsInScreen() const = 0; + virtual gfx::Rect GetWorkAreaScreenBounds() const = 0; virtual void SetInactiveRenderingDisabled(bool value) = 0; virtual Widget::MoveLoopResult RunMoveLoop() = 0; virtual void EndMoveLoop() = 0; diff --git a/ui/views/widget/native_widget_win.cc b/ui/views/widget/native_widget_win.cc index 6bb6f40..5af20c6 100644 --- a/ui/views/widget/native_widget_win.cc +++ b/ui/views/widget/native_widget_win.cc @@ -1169,7 +1169,7 @@ void NativeWidgetWin::FocusNativeView(gfx::NativeView native_view) { ::SetFocus(native_view); } -gfx::Rect NativeWidgetWin::GetWorkAreaBoundsInScreen() const { +gfx::Rect NativeWidgetWin::GetWorkAreaScreenBounds() const { return gfx::Screen::GetDisplayNearestWindow(GetNativeView()).work_area(); } diff --git a/ui/views/widget/native_widget_win.h b/ui/views/widget/native_widget_win.h index 08ca047..a45d3bb 100644 --- a/ui/views/widget/native_widget_win.h +++ b/ui/views/widget/native_widget_win.h @@ -256,7 +256,7 @@ class VIEWS_EXPORT NativeWidgetWin : public ui::WindowImpl, virtual void SetCursor(gfx::NativeCursor cursor) OVERRIDE; virtual void ClearNativeFocus() OVERRIDE; virtual void FocusNativeView(gfx::NativeView native_view) OVERRIDE; - virtual gfx::Rect GetWorkAreaBoundsInScreen() const OVERRIDE; + virtual gfx::Rect GetWorkAreaScreenBounds() const OVERRIDE; virtual void SetInactiveRenderingDisabled(bool value) OVERRIDE; virtual Widget::MoveLoopResult RunMoveLoop() OVERRIDE; virtual void EndMoveLoop() OVERRIDE; diff --git a/ui/views/widget/widget.cc b/ui/views/widget/widget.cc index 1dfb8256..e8ab01a 100644 --- a/ui/views/widget/widget.cc +++ b/ui/views/widget/widget.cc @@ -891,8 +891,8 @@ View* Widget::GetChildViewParent() { return GetContentsView() ? GetContentsView() : GetRootView(); } -gfx::Rect Widget::GetWorkAreaBoundsInScreen() const { - return native_widget_->GetWorkAreaBoundsInScreen(); +gfx::Rect Widget::GetWorkAreaScreenBounds() const { + return native_widget_->GetWorkAreaScreenBounds(); } void Widget::OnOwnerClosing() { diff --git a/ui/views/widget/widget.h b/ui/views/widget/widget.h index f16ea6b..b993108 100644 --- a/ui/views/widget/widget.h +++ b/ui/views/widget/widget.h @@ -615,8 +615,8 @@ class VIEWS_EXPORT Widget : public internal::NativeWidgetDelegate, // with it. TYPE_CONTROL and TYPE_TOOLTIP is not considered top level. bool is_top_level() const { return is_top_level_; } - // Returns the bounds of work area in the screen that Widget belongs to. - gfx::Rect GetWorkAreaBoundsInScreen() const; + // Returns the work are bounds of the screen the Widget belongs to. + gfx::Rect GetWorkAreaScreenBounds() const; // Notification that our owner is closing. // NOTE: this is not invoked for aura as it's currently not needed there. |