#include <map>
#include "ash/ash_switches.h"
+#include "ash/display/cursor_window_controller.h"
#include "ash/display/display_layout_store.h"
#include "ash/display/display_manager.h"
#include "ash/display/mirror_window_controller.h"
#include "ash/display/root_window_transformers.h"
#include "ash/display/virtual_keyboard_window_controller.h"
-#include "ash/host/root_window_host_factory.h"
+#include "ash/host/ash_window_tree_host.h"
+#include "ash/host/ash_window_tree_host_init_params.h"
+#include "ash/host/root_window_transformer.h"
#include "ash/root_window_controller.h"
#include "ash/root_window_settings.h"
#include "ash/screen_util.h"
#include "ash/wm/coordinate_conversion.h"
#include "base/command_line.h"
#include "base/strings/stringprintf.h"
-#include "ui/aura/client/activation_client.h"
+#include "base/strings/utf_string_conversions.h"
#include "ui/aura/client/capture_client.h"
#include "ui/aura/client/focus_client.h"
#include "ui/aura/client/screen_position_client.h"
-#include "ui/aura/root_window.h"
-#include "ui/aura/root_window_transformer.h"
#include "ui/aura/window.h"
+#include "ui/aura/window_event_dispatcher.h"
#include "ui/aura/window_property.h"
#include "ui/aura/window_tracker.h"
+#include "ui/aura/window_tree_host.h"
#include "ui/compositor/compositor.h"
+#include "ui/compositor/compositor_vsync_manager.h"
#include "ui/gfx/display.h"
#include "ui/gfx/screen.h"
+#include "ui/wm/public/activation_client.h"
#if defined(OS_CHROMEOS)
+#include "ash/display/display_configurator_animation.h"
#include "base/sys_info.h"
#include "base/time/time.h"
+#endif // defined(OS_CHROMEOS)
+
#if defined(USE_X11)
-#include "ash/display/output_configurator_animation.h"
-#include "chromeos/display/output_configurator.h"
#include "ui/base/x/x11_util.h"
#include "ui/gfx/x/x11_types.h"
#include <X11/extensions/Xrandr.h>
#undef RootWindow
#endif // defined(USE_X11)
-#endif // defined(OS_CHROMEOS)
+
namespace ash {
namespace {
// accessed after Shell is deleted. A separate display instance is created
// during the shutdown instead of always keeping two display instances
// (one here and another one in display_manager) in sync, which is error prone.
-int64 primary_display_id = gfx::Display::kInvalidDisplayID;
+// This is initialized in the constructor, and then in CreatePrimaryHost().
+int64 primary_display_id = -1;
// Specifies how long the display change should have been disabled
// after each display change operations.
const int64 kCycleDisplayThrottleTimeoutMs = 4000;
const int64 kSwapDisplayThrottleTimeoutMs = 500;
-internal::DisplayManager* GetDisplayManager() {
+DisplayManager* GetDisplayManager() {
return Shell::GetInstance()->display_manager();
}
-void SetDisplayPropertiesOnHostWindow(aura::RootWindow* root,
- const gfx::Display& display) {
- internal::DisplayInfo info =
- GetDisplayManager()->GetDisplayInfo(display.id());
+void SetDisplayPropertiesOnHost(AshWindowTreeHost* ash_host,
+ const gfx::Display& display) {
+ DisplayInfo info = GetDisplayManager()->GetDisplayInfo(display.id());
+ aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
#if defined(OS_CHROMEOS) && defined(USE_X11)
// Native window property (Atom in X11) that specifies the display's
// rotation, scale factor and if it's internal display. They are
}
int internal = display.IsInternal() ? 1 : 0;
- gfx::AcceleratedWidget xwindow = root->host()->GetAcceleratedWidget();
+ gfx::AcceleratedWidget xwindow = host->GetAcceleratedWidget();
ui::SetIntProperty(xwindow, kInternalProp, kCARDINAL, internal);
ui::SetIntProperty(xwindow, kRotationProp, kCARDINAL, xrandr_rotation);
ui::SetIntProperty(xwindow,
kCARDINAL,
100 * display.device_scale_factor());
#endif
- scoped_ptr<aura::RootWindowTransformer> transformer(
- internal::CreateRootWindowTransformerForDisplay(root->window(), display));
- root->host()->SetRootWindowTransformer(transformer.Pass());
+ scoped_ptr<RootWindowTransformer> transformer(
+ CreateRootWindowTransformerForDisplay(host->window(), display));
+ ash_host->SetRootWindowTransformer(transformer.Pass());
+
+ DisplayMode mode;
+ if (GetDisplayManager()->GetSelectedModeForDisplayId(display.id(), &mode) &&
+ mode.refresh_rate > 0.0f) {
+ host->compositor()->vsync_manager()->SetAuthoritativeVSyncInterval(
+ base::TimeDelta::FromMicroseconds(
+ base::Time::kMicrosecondsPerSecond / mode.refresh_rate));
+ }
}
-} // namespace
+aura::Window* GetWindow(AshWindowTreeHost* ash_host) {
+ CHECK(ash_host->AsWindowTreeHost());
+ return ash_host->AsWindowTreeHost()->window();
+}
-namespace internal {
+} // namespace
// A utility class to store/restore focused/active window
// when the display configuration has changed.
DISALLOW_COPY_AND_ASSIGN(FocusActivationStore);
};
-} // namespace internal
-
////////////////////////////////////////////////////////////////////////////////
// DisplayChangeLimiter
// DisplayController
DisplayController::DisplayController()
- : primary_root_window_for_replace_(NULL),
- focus_activation_store_(new internal::FocusActivationStore()),
- mirror_window_controller_(new internal::MirrorWindowController),
- virtual_keyboard_window_controller_(
- new internal::VirtualKeyboardWindowController) {
+ : primary_tree_host_for_replace_(NULL),
+ focus_activation_store_(new FocusActivationStore()),
+ cursor_window_controller_(new CursorWindowController()),
+ mirror_window_controller_(new MirrorWindowController()),
+ weak_ptr_factory_(this) {
#if defined(OS_CHROMEOS)
- CommandLine* command_line = CommandLine::ForCurrentProcess();
- if (!command_line->HasSwitch(switches::kAshDisableDisplayChangeLimiter) &&
- base::SysInfo::IsRunningOnChromeOS())
+ if (base::SysInfo::IsRunningOnChromeOS())
limiter_.reset(new DisplayChangeLimiter);
#endif
// Reset primary display to make sure that tests don't use
}
void DisplayController::Start() {
+ // Created here so that Shell has finished being created. Adds itself
+ // as a ShellObserver.
+ virtual_keyboard_window_controller_.reset(
+ new VirtualKeyboardWindowController);
Shell::GetScreen()->AddObserver(this);
Shell::GetInstance()->display_manager()->set_delegate(this);
-
- if (Shell::GetInstance()->delegate()->IsFirstRunAfterBoot()) {
- // Update the display pref with the initial power state.
- FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
- FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanged());
- }
}
void DisplayController::Shutdown() {
// DisplayManager outlives DisplayController.
Shell::GetInstance()->display_manager()->set_delegate(NULL);
+ cursor_window_controller_.reset();
mirror_window_controller_.reset();
virtual_keyboard_window_controller_.reset();
Shell::GetScreen()->RemoveObserver(this);
// Delete all root window controllers, which deletes root window
// from the last so that the primary root window gets deleted last.
- for (std::map<int64, aura::Window*>::const_reverse_iterator it =
- root_windows_.rbegin(); it != root_windows_.rend(); ++it) {
- internal::RootWindowController* controller =
- internal::GetRootWindowController(it->second);
+ for (WindowTreeHostMap::const_reverse_iterator it =
+ window_tree_hosts_.rbegin();
+ it != window_tree_hosts_.rend();
+ ++it) {
+ RootWindowController* controller =
+ GetRootWindowController(GetWindow(it->second));
DCHECK(controller);
delete controller;
}
}
-void DisplayController::InitPrimaryDisplay() {
+void DisplayController::CreatePrimaryHost(
+ const AshWindowTreeHostInitParams& init_params) {
const gfx::Display& primary_candidate =
GetDisplayManager()->GetPrimaryDisplayCandidate();
primary_display_id = primary_candidate.id();
- AddRootWindowForDisplay(primary_candidate);
+ CHECK_NE(gfx::Display::kInvalidDisplayID, primary_display_id);
+ AddWindowTreeHostForDisplay(primary_candidate, init_params);
}
-void DisplayController::InitSecondaryDisplays() {
- internal::DisplayManager* display_manager = GetDisplayManager();
+void DisplayController::InitDisplays() {
+ RootWindowController::CreateForPrimaryDisplay(
+ window_tree_hosts_[primary_display_id]);
+
+ DisplayManager* display_manager = GetDisplayManager();
for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
const gfx::Display& display = display_manager->GetDisplayAt(i);
if (primary_display_id != display.id()) {
- aura::RootWindow* root = AddRootWindowForDisplay(display);
- internal::RootWindowController::CreateForSecondaryDisplay(root);
+ AshWindowTreeHost* ash_host = AddWindowTreeHostForDisplay(
+ display, AshWindowTreeHostInitParams());
+ RootWindowController::CreateForSecondaryDisplay(ash_host);
}
}
UpdateHostWindowNames();
+
+ FOR_EACH_OBSERVER(Observer, observers_, OnDisplaysInitialized());
}
void DisplayController::AddObserver(Observer* observer) {
// static
int64 DisplayController::GetPrimaryDisplayId() {
+ CHECK_NE(gfx::Display::kInvalidDisplayID, primary_display_id);
return primary_display_id;
}
aura::Window* DisplayController::GetPrimaryRootWindow() {
- DCHECK(!root_windows_.empty());
- return root_windows_[primary_display_id];
+ return GetRootWindowForDisplayId(primary_display_id);
}
aura::Window* DisplayController::GetRootWindowForDisplayId(int64 id) {
- return root_windows_[id];
+ DCHECK_EQ(1u, window_tree_hosts_.count(id));
+ AshWindowTreeHost* host = window_tree_hosts_[id];
+ CHECK(host);
+ return GetWindow(host);
}
void DisplayController::CloseChildWindows() {
- for (std::map<int64, aura::Window*>::const_iterator it =
- root_windows_.begin(); it != root_windows_.end(); ++it) {
- aura::Window* root_window = it->second;
- internal::RootWindowController* controller =
- internal::GetRootWindowController(root_window);
+ for (WindowTreeHostMap::const_iterator it = window_tree_hosts_.begin();
+ it != window_tree_hosts_.end();
+ ++it) {
+ aura::Window* root_window = GetWindow(it->second);
+ RootWindowController* controller = GetRootWindowController(root_window);
if (controller) {
controller->CloseChildWindows();
} else {
aura::Window::Windows DisplayController::GetAllRootWindows() {
aura::Window::Windows windows;
- for (std::map<int64, aura::Window*>::const_iterator it =
- root_windows_.begin(); it != root_windows_.end(); ++it) {
+ for (WindowTreeHostMap::const_iterator it = window_tree_hosts_.begin();
+ it != window_tree_hosts_.end();
+ ++it) {
DCHECK(it->second);
- if (internal::GetRootWindowController(it->second))
- windows.push_back(it->second);
+ if (GetRootWindowController(GetWindow(it->second)))
+ windows.push_back(GetWindow(it->second));
}
return windows;
}
GetDisplayManager()->SetOverscanInsets(display_id, insets_in_dip);
}
-std::vector<internal::RootWindowController*>
+std::vector<RootWindowController*>
DisplayController::GetAllRootWindowControllers() {
- std::vector<internal::RootWindowController*> controllers;
- for (std::map<int64, aura::Window*>::const_iterator it =
- root_windows_.begin(); it != root_windows_.end(); ++it) {
- internal::RootWindowController* controller =
- internal::GetRootWindowController(it->second);
+ std::vector<RootWindowController*> controllers;
+ for (WindowTreeHostMap::const_iterator it = window_tree_hosts_.begin();
+ it != window_tree_hosts_.end();
+ ++it) {
+ RootWindowController* controller =
+ GetRootWindowController(GetWindow(it->second));
if (controller)
controllers.push_back(controller);
}
}
void DisplayController::ToggleMirrorMode() {
- internal::DisplayManager* display_manager = GetDisplayManager();
+ DisplayManager* display_manager = GetDisplayManager();
if (display_manager->num_connected_displays() <= 1)
return;
return;
limiter_->SetThrottleTimeout(kCycleDisplayThrottleTimeoutMs);
}
-#if defined(OS_CHROMEOS) && defined(USE_X11)
+#if defined(OS_CHROMEOS)
Shell* shell = Shell::GetInstance();
- internal::OutputConfiguratorAnimation* animation =
- shell->output_configurator_animation();
- animation->StartFadeOutAnimation(base::Bind(
- base::IgnoreResult(&internal::DisplayManager::SetMirrorMode),
- base::Unretained(display_manager),
- !display_manager->IsMirrored()));
+ DisplayConfiguratorAnimation* animation =
+ shell->display_configurator_animation();
+ animation->StartFadeOutAnimation(
+ base::Bind(&DisplayController::SetMirrorModeAfterAnimation,
+ weak_ptr_factory_.GetWeakPtr(),
+ !display_manager->IsMirrored()));
#endif
}
}
if (Shell::GetScreen()->GetNumDisplays() > 1) {
-#if defined(OS_CHROMEOS) && defined(USE_X11)
- internal::OutputConfiguratorAnimation* animation =
- Shell::GetInstance()->output_configurator_animation();
+#if defined(OS_CHROMEOS)
+ DisplayConfiguratorAnimation* animation =
+ Shell::GetInstance()->display_configurator_animation();
if (animation) {
animation->StartFadeOutAnimation(base::Bind(
&DisplayController::OnFadeOutForSwapDisplayFinished,
- base::Unretained(this)));
+ weak_ptr_factory_.GetWeakPtr()));
} else {
SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
}
void DisplayController::SetPrimaryDisplay(
const gfx::Display& new_primary_display) {
- internal::DisplayManager* display_manager = GetDisplayManager();
+ DisplayManager* display_manager = GetDisplayManager();
DCHECK(new_primary_display.is_valid());
DCHECK(display_manager->IsActiveDisplay(new_primary_display));
}
if (primary_display_id == new_primary_display.id() ||
- root_windows_.size() < 2) {
+ window_tree_hosts_.size() < 2) {
return;
}
- aura::Window* non_primary_root = root_windows_[new_primary_display.id()];
- LOG_IF(ERROR, !non_primary_root)
+ AshWindowTreeHost* non_primary_host =
+ window_tree_hosts_[new_primary_display.id()];
+ LOG_IF(ERROR, !non_primary_host)
<< "Unknown display is requested in SetPrimaryDisplay: id="
<< new_primary_display.id();
- if (!non_primary_root)
+ if (!non_primary_host)
return;
gfx::Display old_primary_display = Shell::GetScreen()->GetPrimaryDisplay();
// Swap root windows between current and new primary display.
- aura::Window* primary_root = root_windows_[primary_display_id];
- DCHECK(primary_root);
- DCHECK_NE(primary_root, non_primary_root);
+ AshWindowTreeHost* primary_host = window_tree_hosts_[primary_display_id];
+ CHECK(primary_host);
+ CHECK_NE(primary_host, non_primary_host);
- root_windows_[new_primary_display.id()] = primary_root;
- internal::GetRootWindowSettings(primary_root)->display_id =
+ window_tree_hosts_[new_primary_display.id()] = primary_host;
+ GetRootWindowSettings(GetWindow(primary_host))->display_id =
new_primary_display.id();
- root_windows_[old_primary_display.id()] = non_primary_root;
- internal::GetRootWindowSettings(non_primary_root)->display_id =
+ window_tree_hosts_[old_primary_display.id()] = non_primary_host;
+ GetRootWindowSettings(GetWindow(non_primary_host))->display_id =
old_primary_display.id();
primary_display_id = new_primary_display.id();
GetDisplayManager()->layout_store()->UpdatePrimaryDisplayId(
display_manager->GetCurrentDisplayIdPair(), primary_display_id);
- UpdateWorkAreaOfDisplayNearestWindow(
- primary_root, old_primary_display.GetWorkAreaInsets());
- UpdateWorkAreaOfDisplayNearestWindow(
- non_primary_root, new_primary_display.GetWorkAreaInsets());
+ UpdateWorkAreaOfDisplayNearestWindow(GetWindow(primary_host),
+ old_primary_display.GetWorkAreaInsets());
+ UpdateWorkAreaOfDisplayNearestWindow(GetWindow(non_primary_host),
+ new_primary_display.GetWorkAreaInsets());
// Update the dispay manager with new display info.
- std::vector<internal::DisplayInfo> display_info_list;
+ std::vector<DisplayInfo> display_info_list;
display_info_list.push_back(display_manager->GetDisplayInfo(
primary_display_id));
display_info_list.push_back(display_manager->GetDisplayInfo(
gfx::Point point_in_screen = Shell::GetScreen()->GetCursorScreenPoint();
gfx::Point target_location_in_native;
int64 closest_distance_squared = -1;
- internal::DisplayManager* display_manager = GetDisplayManager();
+ DisplayManager* display_manager = GetDisplayManager();
aura::Window* dst_root_window = NULL;
for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
const gfx::Display& display = display_manager->GetDisplayAt(i);
- const internal::DisplayInfo display_info =
+ const DisplayInfo display_info =
display_manager->GetDisplayInfo(display.id());
aura::Window* root_window = GetRootWindowForDisplayId(display.id());
if (display_info.bounds_in_native().Contains(
aura::client::ScreenPositionClient* client =
aura::client::GetScreenPositionClient(root_window);
client->ConvertPointFromScreen(root_window, ¢er);
- root_window->GetDispatcher()->host()->ConvertPointToNativeScreen(¢er);
+ root_window->GetHost()->ConvertPointToNativeScreen(¢er);
dst_root_window = root_window;
target_location_in_native = center;
closest_distance_squared = distance_squared;
}
}
- dst_root_window->GetDispatcher()->host()->ConvertPointFromNativeScreen(
+ dst_root_window->GetHost()->ConvertPointFromNativeScreen(
&target_location_in_native);
dst_root_window->MoveCursorTo(target_location_in_native);
}
const aura::Window* window,
const gfx::Insets& insets) {
const aura::Window* root_window = window->GetRootWindow();
- int64 id = internal::GetRootWindowSettings(root_window)->display_id;
+ int64 id = GetRootWindowSettings(root_window)->display_id;
// if id is |kInvaildDisplayID|, it's being deleted.
DCHECK(id != gfx::Display::kInvalidDisplayID);
return GetDisplayManager()->UpdateWorkAreaOfDisplay(id, insets);
}
-void DisplayController::OnDisplayBoundsChanged(const gfx::Display& display) {
- const internal::DisplayInfo& display_info =
- GetDisplayManager()->GetDisplayInfo(display.id());
- DCHECK(!display_info.bounds_in_native().IsEmpty());
- aura::WindowEventDispatcher* dispatcher =
- root_windows_[display.id()]->GetDispatcher();
- dispatcher->host()->SetBounds(display_info.bounds_in_native());
- SetDisplayPropertiesOnHostWindow(dispatcher, display);
-}
-
void DisplayController::OnDisplayAdded(const gfx::Display& display) {
- if (primary_root_window_for_replace_) {
- DCHECK(root_windows_.empty());
+ if (primary_tree_host_for_replace_) {
+ DCHECK(window_tree_hosts_.empty());
primary_display_id = display.id();
- root_windows_[display.id()] = primary_root_window_for_replace_;
- internal::GetRootWindowSettings(primary_root_window_for_replace_)->
- display_id = display.id();
- primary_root_window_for_replace_ = NULL;
- const internal::DisplayInfo& display_info =
+ window_tree_hosts_[display.id()] = primary_tree_host_for_replace_;
+ GetRootWindowSettings(GetWindow(primary_tree_host_for_replace_))
+ ->display_id = display.id();
+ primary_tree_host_for_replace_ = NULL;
+ const DisplayInfo& display_info =
GetDisplayManager()->GetDisplayInfo(display.id());
- aura::WindowEventDispatcher* dispatcher =
- root_windows_[display.id()]->GetDispatcher();
- dispatcher->host()->SetBounds(display_info.bounds_in_native());
- SetDisplayPropertiesOnHostWindow(dispatcher, display);
+ AshWindowTreeHost* ash_host = window_tree_hosts_[display.id()];
+ ash_host->AsWindowTreeHost()->SetBounds(display_info.bounds_in_native());
+ SetDisplayPropertiesOnHost(ash_host, display);
} else {
if (primary_display_id == gfx::Display::kInvalidDisplayID)
primary_display_id = display.id();
- DCHECK(!root_windows_.empty());
- aura::RootWindow* root = AddRootWindowForDisplay(display);
- internal::RootWindowController::CreateForSecondaryDisplay(root);
+ DCHECK(!window_tree_hosts_.empty());
+ AshWindowTreeHost* ash_host = AddWindowTreeHostForDisplay(
+ display, AshWindowTreeHostInitParams());
+ RootWindowController::CreateForSecondaryDisplay(ash_host);
}
}
void DisplayController::OnDisplayRemoved(const gfx::Display& display) {
- aura::Window* root_to_delete = root_windows_[display.id()];
- DCHECK(root_to_delete) << display.ToString();
+ AshWindowTreeHost* host_to_delete = window_tree_hosts_[display.id()];
+ CHECK(host_to_delete) << display.ToString();
// Display for root window will be deleted when the Primary RootWindow
// is deleted by the Shell.
- root_windows_.erase(display.id());
+ window_tree_hosts_.erase(display.id());
// When the primary root window's display is removed, move the primary
// root to the other display.
if (primary_display_id == display.id()) {
// Temporarily store the primary root window in
// |primary_root_window_for_replace_| when replacing the display.
- if (root_windows_.size() == 0) {
+ if (window_tree_hosts_.size() == 0) {
primary_display_id = gfx::Display::kInvalidDisplayID;
- primary_root_window_for_replace_ = root_to_delete;
+ primary_tree_host_for_replace_ = host_to_delete;
return;
}
- DCHECK_EQ(1U, root_windows_.size());
+ DCHECK_EQ(1U, window_tree_hosts_.size());
primary_display_id = ScreenUtil::GetSecondaryDisplay().id();
- aura::Window* primary_root = root_to_delete;
+ AshWindowTreeHost* primary_host = host_to_delete;
- // Delete the other root instead.
- root_to_delete = root_windows_[primary_display_id];
- internal::GetRootWindowSettings(root_to_delete)->display_id = display.id();
+ // Delete the other host instead.
+ host_to_delete = window_tree_hosts_[primary_display_id];
+ GetRootWindowSettings(GetWindow(host_to_delete))->display_id = display.id();
// Setup primary root.
- root_windows_[primary_display_id] = primary_root;
- internal::GetRootWindowSettings(primary_root)->display_id =
+ window_tree_hosts_[primary_display_id] = primary_host;
+ GetRootWindowSettings(GetWindow(primary_host))->display_id =
primary_display_id;
- OnDisplayBoundsChanged(
- GetDisplayManager()->GetDisplayForId(primary_display_id));
+ OnDisplayMetricsChanged(
+ GetDisplayManager()->GetDisplayForId(primary_display_id),
+ DISPLAY_METRIC_BOUNDS);
}
- internal::RootWindowController* controller =
- internal::GetRootWindowController(root_to_delete);
+ RootWindowController* controller =
+ GetRootWindowController(GetWindow(host_to_delete));
DCHECK(controller);
controller->MoveWindowsTo(GetPrimaryRootWindow());
// Delete most of root window related objects, but don't delete
base::MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
}
-void DisplayController::OnWindowTreeHostResized(const aura::RootWindow* root) {
+void DisplayController::OnDisplayMetricsChanged(const gfx::Display& display,
+ uint32_t metrics) {
+ if (!(metrics & (DISPLAY_METRIC_BOUNDS | DISPLAY_METRIC_ROTATION |
+ DISPLAY_METRIC_DEVICE_SCALE_FACTOR)))
+ return;
+
+ const DisplayInfo& display_info =
+ GetDisplayManager()->GetDisplayInfo(display.id());
+ DCHECK(!display_info.bounds_in_native().IsEmpty());
+ AshWindowTreeHost* ash_host = window_tree_hosts_[display.id()];
+ ash_host->AsWindowTreeHost()->SetBounds(display_info.bounds_in_native());
+ SetDisplayPropertiesOnHost(ash_host, display);
+}
+
+void DisplayController::OnHostResized(const aura::WindowTreeHost* host) {
gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
- const_cast<aura::Window*>(root->window()));
+ const_cast<aura::Window*>(host->window()));
- internal::DisplayManager* display_manager = GetDisplayManager();
- if (display_manager->UpdateDisplayBounds(
- display.id(),
- root->host()->GetBounds())) {
+ DisplayManager* display_manager = GetDisplayManager();
+ if (display_manager->UpdateDisplayBounds(display.id(), host->GetBounds())) {
mirror_window_controller_->UpdateWindow();
+ cursor_window_controller_->UpdateContainer();
}
}
void DisplayController::CreateOrUpdateNonDesktopDisplay(
- const internal::DisplayInfo& info) {
+ const DisplayInfo& info) {
switch (GetDisplayManager()->second_display_mode()) {
- case internal::DisplayManager::MIRRORING:
+ case DisplayManager::MIRRORING:
mirror_window_controller_->UpdateWindow(info);
+ cursor_window_controller_->UpdateContainer();
virtual_keyboard_window_controller_->Close();
break;
- case internal::DisplayManager::VIRTUAL_KEYBOARD:
+ case DisplayManager::VIRTUAL_KEYBOARD:
mirror_window_controller_->Close();
+ cursor_window_controller_->UpdateContainer();
virtual_keyboard_window_controller_->UpdateWindow(info);
break;
- case internal::DisplayManager::EXTENDED:
+ case DisplayManager::EXTENDED:
NOTREACHED();
}
}
void DisplayController::CloseNonDesktopDisplay() {
mirror_window_controller_->Close();
+ cursor_window_controller_->UpdateContainer();
virtual_keyboard_window_controller_->Close();
}
aura::client::ScreenPositionClient* client =
aura::client::GetScreenPositionClient(root_window);
client->ConvertPointFromScreen(root_window, &point_in_screen);
- root_window->GetDispatcher()->host()->ConvertPointToNativeScreen(
- &point_in_screen);
+ root_window->GetHost()->ConvertPointToNativeScreen(&point_in_screen);
cursor_location_in_native_coords_for_restore_ = point_in_screen;
}
focus_activation_store_->Restore();
- internal::DisplayManager* display_manager = GetDisplayManager();
- internal::DisplayLayoutStore* layout_store = display_manager->layout_store();
+ DisplayManager* display_manager = GetDisplayManager();
+ DisplayLayoutStore* layout_store = display_manager->layout_store();
if (display_manager->num_connected_displays() > 1) {
DisplayIdPair pair = display_manager->GetCurrentDisplayIdPair();
layout_store->UpdateMirrorStatus(pair, display_manager->IsMirrored());
EnsurePointerInDisplays();
}
-aura::RootWindow* DisplayController::AddRootWindowForDisplay(
- const gfx::Display& display) {
- static int root_window_count = 0;
- const internal::DisplayInfo& display_info =
+AshWindowTreeHost* DisplayController::AddWindowTreeHostForDisplay(
+ const gfx::Display& display,
+ const AshWindowTreeHostInitParams& init_params) {
+ static int host_count = 0;
+ const DisplayInfo& display_info =
GetDisplayManager()->GetDisplayInfo(display.id());
- const gfx::Rect& bounds_in_native = display_info.bounds_in_native();
- aura::RootWindow::CreateParams params(bounds_in_native);
- params.host = Shell::GetInstance()->root_window_host_factory()->
- CreateWindowTreeHost(bounds_in_native);
- aura::RootWindow* root_window = new aura::RootWindow(params);
- root_window->window()->SetName(
- base::StringPrintf("RootWindow-%d", root_window_count++));
- root_window->host()->compositor()->SetBackgroundColor(SK_ColorBLACK);
- // No need to remove RootWindowObserver because
- // the DisplayController object outlives RootWindow objects.
- root_window->AddRootWindowObserver(this);
- internal::InitRootWindowSettings(root_window->window())->display_id =
- display.id();
- root_window->Init();
-
- root_windows_[display.id()] = root_window->window();
- SetDisplayPropertiesOnHostWindow(root_window, display);
+ AshWindowTreeHostInitParams params_with_bounds(init_params);
+ params_with_bounds.initial_bounds = display_info.bounds_in_native();
+ AshWindowTreeHost* ash_host = AshWindowTreeHost::Create(params_with_bounds);
+ aura::WindowTreeHost* host = ash_host->AsWindowTreeHost();
+
+ host->window()->SetName(base::StringPrintf("RootWindow-%d", host_count++));
+ host->window()->SetTitle(base::UTF8ToUTF16(display_info.name()));
+ host->compositor()->SetBackgroundColor(SK_ColorBLACK);
+ // No need to remove our observer observer because the DisplayController
+ // outlives the host.
+ host->AddObserver(this);
+ InitRootWindowSettings(host->window())->display_id = display.id();
+ host->InitHost();
+
+ window_tree_hosts_[display.id()] = ash_host;
+ SetDisplayPropertiesOnHost(ash_host, display);
#if defined(OS_CHROMEOS)
static bool force_constrain_pointer_to_root =
CommandLine::ForCurrentProcess()->HasSwitch(
switches::kAshConstrainPointerToRoot);
if (base::SysInfo::IsRunningOnChromeOS() || force_constrain_pointer_to_root)
- root_window->host()->ConfineCursorToRootWindow();
+ ash_host->ConfineCursorToRootWindow();
#endif
- return root_window;
+ return ash_host;
}
void DisplayController::OnFadeOutForSwapDisplayFinished() {
-#if defined(OS_CHROMEOS) && defined(USE_X11)
+#if defined(OS_CHROMEOS)
SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
- Shell::GetInstance()->output_configurator_animation()->StartFadeInAnimation();
+ Shell::GetInstance()->display_configurator_animation()
+ ->StartFadeInAnimation();
#endif
}
+void DisplayController::SetMirrorModeAfterAnimation(bool mirror) {
+ GetDisplayManager()->SetMirrorMode(mirror);
+}
+
void DisplayController::UpdateHostWindowNames() {
#if defined(USE_X11)
// crbug.com/120229 - set the window title for the primary dislpay
std::string name =
root_windows[i] == primary ? "aura_root_0" : "aura_root_x";
gfx::AcceleratedWidget xwindow =
- root_windows[i]->GetDispatcher()->host()->GetAcceleratedWidget();
+ root_windows[i]->GetHost()->GetAcceleratedWidget();
XStoreName(gfx::GetXDisplay(), xwindow, name.c_str());
}
#endif
projects / platform / framework / web / crosswalk.git / blobdiff