1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "ash/display/display_controller.h"
11 #include "ash/ash_switches.h"
12 #include "ash/display/cursor_window_controller.h"
13 #include "ash/display/display_layout_store.h"
14 #include "ash/display/display_manager.h"
15 #include "ash/display/mirror_window_controller.h"
16 #include "ash/display/root_window_transformers.h"
17 #include "ash/host/ash_window_tree_host.h"
18 #include "ash/host/ash_window_tree_host_init_params.h"
19 #include "ash/host/root_window_transformer.h"
20 #include "ash/root_window_controller.h"
21 #include "ash/root_window_settings.h"
22 #include "ash/screen_util.h"
23 #include "ash/shell.h"
24 #include "ash/shell_delegate.h"
25 #include "ash/wm/coordinate_conversion.h"
26 #include "base/command_line.h"
27 #include "base/stl_util.h"
28 #include "base/strings/stringprintf.h"
29 #include "base/strings/utf_string_conversions.h"
30 #include "ui/aura/client/capture_client.h"
31 #include "ui/aura/client/focus_client.h"
32 #include "ui/aura/client/screen_position_client.h"
33 #include "ui/aura/window.h"
34 #include "ui/aura/window_event_dispatcher.h"
35 #include "ui/aura/window_property.h"
36 #include "ui/aura/window_tracker.h"
37 #include "ui/aura/window_tree_host.h"
38 #include "ui/compositor/compositor.h"
39 #include "ui/compositor/compositor_vsync_manager.h"
40 #include "ui/gfx/display.h"
41 #include "ui/gfx/screen.h"
42 #include "ui/wm/public/activation_client.h"
44 #if defined(OS_CHROMEOS)
45 #include "ash/display/display_configurator_animation.h"
46 #include "base/sys_info.h"
47 #include "base/time/time.h"
48 #endif // defined(OS_CHROMEOS)
51 #include "ui/base/x/x11_util.h"
52 #include "ui/gfx/x/x11_types.h"
54 // Including this at the bottom to avoid other
55 // potential conflict with chrome headers.
56 #include <X11/extensions/Xrandr.h>
58 #endif // defined(USE_X11)
64 // Primary display stored in global object as it can be
65 // accessed after Shell is deleted. A separate display instance is created
66 // during the shutdown instead of always keeping two display instances
67 // (one here and another one in display_manager) in sync, which is error prone.
68 // This is initialized in the constructor, and then in CreatePrimaryHost().
69 int64 primary_display_id
= -1;
71 // Specifies how long the display change should have been disabled
72 // after each display change operations.
73 // |kCycleDisplayThrottleTimeoutMs| is set to be longer to avoid
74 // changing the settings while the system is still configurating
75 // displays. It will be overriden by |kAfterDisplayChangeThrottleTimeoutMs|
76 // when the display change happens, so the actual timeout is much shorter.
77 const int64 kAfterDisplayChangeThrottleTimeoutMs
= 500;
78 const int64 kCycleDisplayThrottleTimeoutMs
= 4000;
79 const int64 kSwapDisplayThrottleTimeoutMs
= 500;
81 DisplayManager
* GetDisplayManager() {
82 return Shell::GetInstance()->display_manager();
85 void SetDisplayPropertiesOnHost(AshWindowTreeHost
* ash_host
,
86 const gfx::Display
& display
) {
87 DisplayInfo info
= GetDisplayManager()->GetDisplayInfo(display
.id());
88 aura::WindowTreeHost
* host
= ash_host
->AsWindowTreeHost();
89 #if defined(OS_CHROMEOS) && defined(USE_X11)
90 // Native window property (Atom in X11) that specifies the display's
91 // rotation, scale factor and if it's internal display. They are
92 // read and used by touchpad/mouse driver directly on X (contact
93 // adlr@ for more details on touchpad/mouse driver side). The value
94 // of the rotation is one of 0 (normal), 1 (90 degrees clockwise), 2
95 // (180 degree) or 3 (270 degrees clockwise). The value of the
96 // scale factor is in percent (100, 140, 200 etc).
97 const char kRotationProp
[] = "_CHROME_DISPLAY_ROTATION";
98 const char kScaleFactorProp
[] = "_CHROME_DISPLAY_SCALE_FACTOR";
99 const char kInternalProp
[] = "_CHROME_DISPLAY_INTERNAL";
100 const char kCARDINAL
[] = "CARDINAL";
101 int xrandr_rotation
= RR_Rotate_0
;
102 switch (info
.rotation()) {
103 case gfx::Display::ROTATE_0
:
104 xrandr_rotation
= RR_Rotate_0
;
106 case gfx::Display::ROTATE_90
:
107 xrandr_rotation
= RR_Rotate_90
;
109 case gfx::Display::ROTATE_180
:
110 xrandr_rotation
= RR_Rotate_180
;
112 case gfx::Display::ROTATE_270
:
113 xrandr_rotation
= RR_Rotate_270
;
117 int internal
= display
.IsInternal() ? 1 : 0;
118 gfx::AcceleratedWidget xwindow
= host
->GetAcceleratedWidget();
119 ui::SetIntProperty(xwindow
, kInternalProp
, kCARDINAL
, internal
);
120 ui::SetIntProperty(xwindow
, kRotationProp
, kCARDINAL
, xrandr_rotation
);
121 ui::SetIntProperty(xwindow
,
124 100 * display
.device_scale_factor());
126 scoped_ptr
<RootWindowTransformer
> transformer(
127 CreateRootWindowTransformerForDisplay(host
->window(), display
));
128 ash_host
->SetRootWindowTransformer(transformer
.Pass());
131 GetDisplayManager()->GetActiveModeForDisplayId(display
.id());
132 if (mode
.refresh_rate
> 0.0f
) {
133 host
->compositor()->vsync_manager()->SetAuthoritativeVSyncInterval(
134 base::TimeDelta::FromMicroseconds(
135 base::Time::kMicrosecondsPerSecond
/ mode
.refresh_rate
));
139 aura::Window
* GetWindow(AshWindowTreeHost
* ash_host
) {
140 CHECK(ash_host
->AsWindowTreeHost());
141 return ash_host
->AsWindowTreeHost()->window();
146 // A utility class to store/restore focused/active window
147 // when the display configuration has changed.
148 class FocusActivationStore
{
150 FocusActivationStore()
151 : activation_client_(NULL
),
152 capture_client_(NULL
),
158 void Store(bool clear_focus
) {
159 if (!activation_client_
) {
160 aura::Window
* root
= Shell::GetPrimaryRootWindow();
161 activation_client_
= aura::client::GetActivationClient(root
);
162 capture_client_
= aura::client::GetCaptureClient(root
);
163 focus_client_
= aura::client::GetFocusClient(root
);
165 focused_
= focus_client_
->GetFocusedWindow();
167 tracker_
.Add(focused_
);
168 active_
= activation_client_
->GetActiveWindow();
169 if (active_
&& focused_
!= active_
)
170 tracker_
.Add(active_
);
172 // Deactivate the window to close menu / bubble windows.
174 activation_client_
->DeactivateWindow(active_
);
176 // Release capture if any.
177 capture_client_
->SetCapture(NULL
);
178 // Clear the focused window if any. This is necessary because a
179 // window may be deleted when losing focus (fullscreen flash for
180 // example). If the focused window is still alive after move, it'll
181 // be re-focused below.
183 focus_client_
->FocusWindow(NULL
);
187 // Restore focused or active window if it's still alive.
188 if (focused_
&& tracker_
.Contains(focused_
)) {
189 focus_client_
->FocusWindow(focused_
);
190 } else if (active_
&& tracker_
.Contains(active_
)) {
191 activation_client_
->ActivateWindow(active_
);
194 tracker_
.Remove(focused_
);
196 tracker_
.Remove(active_
);
202 aura::client::ActivationClient
* activation_client_
;
203 aura::client::CaptureClient
* capture_client_
;
204 aura::client::FocusClient
* focus_client_
;
205 aura::WindowTracker tracker_
;
206 aura::Window
* focused_
;
207 aura::Window
* active_
;
209 DISALLOW_COPY_AND_ASSIGN(FocusActivationStore
);
212 ////////////////////////////////////////////////////////////////////////////////
213 // DisplayChangeLimiter
215 DisplayController::DisplayChangeLimiter::DisplayChangeLimiter()
216 : throttle_timeout_(base::Time::Now()) {
219 void DisplayController::DisplayChangeLimiter::SetThrottleTimeout(
222 base::Time::Now() + base::TimeDelta::FromMilliseconds(throttle_ms
);
225 bool DisplayController::DisplayChangeLimiter::IsThrottled() const {
226 return base::Time::Now() < throttle_timeout_
;
229 ////////////////////////////////////////////////////////////////////////////////
232 DisplayController::DisplayController()
233 : primary_tree_host_for_replace_(NULL
),
234 focus_activation_store_(new FocusActivationStore()),
235 cursor_window_controller_(new CursorWindowController()),
236 mirror_window_controller_(new MirrorWindowController()),
237 weak_ptr_factory_(this) {
238 #if defined(OS_CHROMEOS)
239 if (base::SysInfo::IsRunningOnChromeOS())
240 limiter_
.reset(new DisplayChangeLimiter
);
242 // Reset primary display to make sure that tests don't use
243 // stale display info from previous tests.
244 primary_display_id
= gfx::Display::kInvalidDisplayID
;
247 DisplayController::~DisplayController() {
250 void DisplayController::Start() {
251 Shell::GetScreen()->AddObserver(this);
252 Shell::GetInstance()->display_manager()->set_delegate(this);
255 void DisplayController::Shutdown() {
256 // Unset the display manager's delegate here because
257 // DisplayManager outlives DisplayController.
258 Shell::GetInstance()->display_manager()->set_delegate(NULL
);
260 cursor_window_controller_
.reset();
261 mirror_window_controller_
.reset();
263 Shell::GetScreen()->RemoveObserver(this);
265 int64 primary_id
= Shell::GetScreen()->GetPrimaryDisplay().id();
267 // Delete non primary root window controllers first, then
268 // delete the primary root window controller.
269 aura::Window::Windows root_windows
= DisplayController::GetAllRootWindows();
270 std::vector
<RootWindowController
*> to_delete
;
271 RootWindowController
* primary_rwc
= NULL
;
272 for (aura::Window::Windows::iterator iter
= root_windows
.begin();
273 iter
!= root_windows
.end();
275 RootWindowController
* rwc
= GetRootWindowController(*iter
);
276 if (GetRootWindowSettings(*iter
)->display_id
== primary_id
)
279 to_delete
.push_back(rwc
);
283 STLDeleteElements(&to_delete
);
287 void DisplayController::CreatePrimaryHost(
288 const AshWindowTreeHostInitParams
& init_params
) {
289 const gfx::Display
& primary_candidate
=
290 GetDisplayManager()->GetPrimaryDisplayCandidate();
291 primary_display_id
= primary_candidate
.id();
292 CHECK_NE(gfx::Display::kInvalidDisplayID
, primary_display_id
);
293 AddWindowTreeHostForDisplay(primary_candidate
, init_params
);
296 void DisplayController::InitDisplays() {
297 RootWindowController::CreateForPrimaryDisplay(
298 window_tree_hosts_
[primary_display_id
]);
300 DisplayManager
* display_manager
= GetDisplayManager();
301 for (size_t i
= 0; i
< display_manager
->GetNumDisplays(); ++i
) {
302 const gfx::Display
& display
= display_manager
->GetDisplayAt(i
);
303 if (primary_display_id
!= display
.id()) {
304 AshWindowTreeHost
* ash_host
= AddWindowTreeHostForDisplay(
305 display
, AshWindowTreeHostInitParams());
306 RootWindowController::CreateForSecondaryDisplay(ash_host
);
309 UpdateHostWindowNames();
311 FOR_EACH_OBSERVER(Observer
, observers_
, OnDisplaysInitialized());
314 void DisplayController::AddObserver(Observer
* observer
) {
315 observers_
.AddObserver(observer
);
318 void DisplayController::RemoveObserver(Observer
* observer
) {
319 observers_
.RemoveObserver(observer
);
323 int64
DisplayController::GetPrimaryDisplayId() {
324 CHECK_NE(gfx::Display::kInvalidDisplayID
, primary_display_id
);
325 return primary_display_id
;
328 aura::Window
* DisplayController::GetPrimaryRootWindow() {
329 return GetRootWindowForDisplayId(primary_display_id
);
332 aura::Window
* DisplayController::GetRootWindowForDisplayId(int64 id
) {
333 CHECK_EQ(1u, window_tree_hosts_
.count(id
));
334 AshWindowTreeHost
* host
= window_tree_hosts_
[id
];
336 return GetWindow(host
);
339 void DisplayController::CloseChildWindows() {
340 for (WindowTreeHostMap::const_iterator it
= window_tree_hosts_
.begin();
341 it
!= window_tree_hosts_
.end();
343 aura::Window
* root_window
= GetWindow(it
->second
);
344 RootWindowController
* controller
= GetRootWindowController(root_window
);
346 controller
->CloseChildWindows();
348 while (!root_window
->children().empty()) {
349 aura::Window
* child
= root_window
->children()[0];
356 aura::Window::Windows
DisplayController::GetAllRootWindows() {
357 aura::Window::Windows windows
;
358 for (WindowTreeHostMap::const_iterator it
= window_tree_hosts_
.begin();
359 it
!= window_tree_hosts_
.end();
362 if (GetRootWindowController(GetWindow(it
->second
)))
363 windows
.push_back(GetWindow(it
->second
));
368 gfx::Insets
DisplayController::GetOverscanInsets(int64 display_id
) const {
369 return GetDisplayManager()->GetOverscanInsets(display_id
);
372 void DisplayController::SetOverscanInsets(int64 display_id
,
373 const gfx::Insets
& insets_in_dip
) {
374 GetDisplayManager()->SetOverscanInsets(display_id
, insets_in_dip
);
377 std::vector
<RootWindowController
*>
378 DisplayController::GetAllRootWindowControllers() {
379 std::vector
<RootWindowController
*> controllers
;
380 for (WindowTreeHostMap::const_iterator it
= window_tree_hosts_
.begin();
381 it
!= window_tree_hosts_
.end();
383 RootWindowController
* controller
=
384 GetRootWindowController(GetWindow(it
->second
));
386 controllers
.push_back(controller
);
391 void DisplayController::ToggleMirrorMode() {
392 DisplayManager
* display_manager
= GetDisplayManager();
393 if (display_manager
->num_connected_displays() <= 1)
397 if (limiter_
->IsThrottled())
399 limiter_
->SetThrottleTimeout(kCycleDisplayThrottleTimeoutMs
);
401 #if defined(OS_CHROMEOS)
402 Shell
* shell
= Shell::GetInstance();
403 DisplayConfiguratorAnimation
* animation
=
404 shell
->display_configurator_animation();
405 animation
->StartFadeOutAnimation(
406 base::Bind(&DisplayController::SetMirrorModeAfterAnimation
,
407 weak_ptr_factory_
.GetWeakPtr(),
408 !display_manager
->IsMirrored()));
412 void DisplayController::SwapPrimaryDisplay() {
414 if (limiter_
->IsThrottled())
416 limiter_
->SetThrottleTimeout(kSwapDisplayThrottleTimeoutMs
);
419 if (Shell::GetScreen()->GetNumDisplays() > 1) {
420 #if defined(OS_CHROMEOS)
421 DisplayConfiguratorAnimation
* animation
=
422 Shell::GetInstance()->display_configurator_animation();
424 animation
->StartFadeOutAnimation(base::Bind(
425 &DisplayController::OnFadeOutForSwapDisplayFinished
,
426 weak_ptr_factory_
.GetWeakPtr()));
428 SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
431 SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
436 void DisplayController::SetPrimaryDisplayId(int64 id
) {
437 DCHECK_NE(gfx::Display::kInvalidDisplayID
, id
);
438 if (id
== gfx::Display::kInvalidDisplayID
|| primary_display_id
== id
)
441 const gfx::Display
& display
= GetDisplayManager()->GetDisplayForId(id
);
442 if (display
.is_valid())
443 SetPrimaryDisplay(display
);
446 void DisplayController::SetPrimaryDisplay(
447 const gfx::Display
& new_primary_display
) {
448 DisplayManager
* display_manager
= GetDisplayManager();
449 DCHECK(new_primary_display
.is_valid());
450 DCHECK(display_manager
->IsActiveDisplay(new_primary_display
));
452 if (!new_primary_display
.is_valid() ||
453 !display_manager
->IsActiveDisplay(new_primary_display
)) {
454 LOG(ERROR
) << "Invalid or non-existent display is requested:"
455 << new_primary_display
.ToString();
459 if (primary_display_id
== new_primary_display
.id() ||
460 window_tree_hosts_
.size() < 2) {
464 AshWindowTreeHost
* non_primary_host
=
465 window_tree_hosts_
[new_primary_display
.id()];
466 LOG_IF(ERROR
, !non_primary_host
)
467 << "Unknown display is requested in SetPrimaryDisplay: id="
468 << new_primary_display
.id();
469 if (!non_primary_host
)
472 gfx::Display old_primary_display
= Shell::GetScreen()->GetPrimaryDisplay();
474 // Swap root windows between current and new primary display.
475 AshWindowTreeHost
* primary_host
= window_tree_hosts_
[primary_display_id
];
477 CHECK_NE(primary_host
, non_primary_host
);
479 window_tree_hosts_
[new_primary_display
.id()] = primary_host
;
480 GetRootWindowSettings(GetWindow(primary_host
))->display_id
=
481 new_primary_display
.id();
483 window_tree_hosts_
[old_primary_display
.id()] = non_primary_host
;
484 GetRootWindowSettings(GetWindow(non_primary_host
))->display_id
=
485 old_primary_display
.id();
487 primary_display_id
= new_primary_display
.id();
488 GetDisplayManager()->layout_store()->UpdatePrimaryDisplayId(
489 display_manager
->GetCurrentDisplayIdPair(), primary_display_id
);
491 UpdateWorkAreaOfDisplayNearestWindow(GetWindow(primary_host
),
492 old_primary_display
.GetWorkAreaInsets());
493 UpdateWorkAreaOfDisplayNearestWindow(GetWindow(non_primary_host
),
494 new_primary_display
.GetWorkAreaInsets());
496 // Update the dispay manager with new display info.
497 std::vector
<DisplayInfo
> display_info_list
;
498 display_info_list
.push_back(display_manager
->GetDisplayInfo(
499 primary_display_id
));
500 display_info_list
.push_back(display_manager
->GetDisplayInfo(
501 ScreenUtil::GetSecondaryDisplay().id()));
502 GetDisplayManager()->set_force_bounds_changed(true);
503 GetDisplayManager()->UpdateDisplays(display_info_list
);
504 GetDisplayManager()->set_force_bounds_changed(false);
507 void DisplayController::EnsurePointerInDisplays() {
508 // If the mouse is currently on a display in native location,
509 // use the same native location. Otherwise find the display closest
510 // to the current cursor location in screen coordinates.
512 gfx::Point point_in_screen
= Shell::GetScreen()->GetCursorScreenPoint();
513 gfx::Point target_location_in_native
;
514 int64 closest_distance_squared
= -1;
515 DisplayManager
* display_manager
= GetDisplayManager();
517 aura::Window
* dst_root_window
= NULL
;
518 for (size_t i
= 0; i
< display_manager
->GetNumDisplays(); ++i
) {
519 const gfx::Display
& display
= display_manager
->GetDisplayAt(i
);
520 const DisplayInfo display_info
=
521 display_manager
->GetDisplayInfo(display
.id());
522 aura::Window
* root_window
= GetRootWindowForDisplayId(display
.id());
523 if (display_info
.bounds_in_native().Contains(
524 cursor_location_in_native_coords_for_restore_
)) {
525 dst_root_window
= root_window
;
526 target_location_in_native
= cursor_location_in_native_coords_for_restore_
;
529 gfx::Point center
= display
.bounds().CenterPoint();
530 // Use the distance squared from the center of the dislay. This is not
531 // exactly "closest" display, but good enough to pick one
532 // appropriate (and there are at most two displays).
533 // We don't care about actual distance, only relative to other displays, so
534 // using the LengthSquared() is cheaper than Length().
536 int64 distance_squared
= (center
- point_in_screen
).LengthSquared();
537 if (closest_distance_squared
< 0 ||
538 closest_distance_squared
> distance_squared
) {
539 aura::Window
* root_window
= GetRootWindowForDisplayId(display
.id());
540 aura::client::ScreenPositionClient
* client
=
541 aura::client::GetScreenPositionClient(root_window
);
542 client
->ConvertPointFromScreen(root_window
, ¢er
);
543 root_window
->GetHost()->ConvertPointToNativeScreen(¢er
);
544 dst_root_window
= root_window
;
545 target_location_in_native
= center
;
546 closest_distance_squared
= distance_squared
;
549 dst_root_window
->GetHost()->ConvertPointFromNativeScreen(
550 &target_location_in_native
);
551 dst_root_window
->MoveCursorTo(target_location_in_native
);
554 bool DisplayController::UpdateWorkAreaOfDisplayNearestWindow(
555 const aura::Window
* window
,
556 const gfx::Insets
& insets
) {
557 const aura::Window
* root_window
= window
->GetRootWindow();
558 int64 id
= GetRootWindowSettings(root_window
)->display_id
;
559 // if id is |kInvaildDisplayID|, it's being deleted.
560 DCHECK(id
!= gfx::Display::kInvalidDisplayID
);
561 return GetDisplayManager()->UpdateWorkAreaOfDisplay(id
, insets
);
564 void DisplayController::OnDisplayAdded(const gfx::Display
& display
) {
565 if (primary_tree_host_for_replace_
) {
566 DCHECK(window_tree_hosts_
.empty());
567 primary_display_id
= display
.id();
568 window_tree_hosts_
[display
.id()] = primary_tree_host_for_replace_
;
569 GetRootWindowSettings(GetWindow(primary_tree_host_for_replace_
))
570 ->display_id
= display
.id();
571 primary_tree_host_for_replace_
= NULL
;
572 const DisplayInfo
& display_info
=
573 GetDisplayManager()->GetDisplayInfo(display
.id());
574 AshWindowTreeHost
* ash_host
= window_tree_hosts_
[display
.id()];
575 ash_host
->AsWindowTreeHost()->SetBounds(display_info
.bounds_in_native());
576 SetDisplayPropertiesOnHost(ash_host
, display
);
578 if (primary_display_id
== gfx::Display::kInvalidDisplayID
)
579 primary_display_id
= display
.id();
580 DCHECK(!window_tree_hosts_
.empty());
581 AshWindowTreeHost
* ash_host
= AddWindowTreeHostForDisplay(
582 display
, AshWindowTreeHostInitParams());
583 RootWindowController::CreateForSecondaryDisplay(ash_host
);
587 void DisplayController::OnDisplayRemoved(const gfx::Display
& display
) {
588 AshWindowTreeHost
* host_to_delete
= window_tree_hosts_
[display
.id()];
589 CHECK(host_to_delete
) << display
.ToString();
591 // Display for root window will be deleted when the Primary RootWindow
592 // is deleted by the Shell.
593 window_tree_hosts_
.erase(display
.id());
595 // When the primary root window's display is removed, move the primary
596 // root to the other display.
597 if (primary_display_id
== display
.id()) {
598 // Temporarily store the primary root window in
599 // |primary_root_window_for_replace_| when replacing the display.
600 if (window_tree_hosts_
.size() == 0) {
601 primary_display_id
= gfx::Display::kInvalidDisplayID
;
602 primary_tree_host_for_replace_
= host_to_delete
;
605 DCHECK_EQ(1U, window_tree_hosts_
.size());
606 primary_display_id
= ScreenUtil::GetSecondaryDisplay().id();
607 AshWindowTreeHost
* primary_host
= host_to_delete
;
609 // Delete the other host instead.
610 host_to_delete
= window_tree_hosts_
[primary_display_id
];
611 GetRootWindowSettings(GetWindow(host_to_delete
))->display_id
= display
.id();
613 // Setup primary root.
614 window_tree_hosts_
[primary_display_id
] = primary_host
;
615 GetRootWindowSettings(GetWindow(primary_host
))->display_id
=
618 OnDisplayMetricsChanged(
619 GetDisplayManager()->GetDisplayForId(primary_display_id
),
620 DISPLAY_METRIC_BOUNDS
);
622 RootWindowController
* controller
=
623 GetRootWindowController(GetWindow(host_to_delete
));
625 controller
->MoveWindowsTo(GetPrimaryRootWindow());
626 // Delete most of root window related objects, but don't delete
627 // root window itself yet because the stack may be using it.
628 controller
->Shutdown();
629 base::MessageLoop::current()->DeleteSoon(FROM_HERE
, controller
);
632 void DisplayController::OnDisplayMetricsChanged(const gfx::Display
& display
,
634 if (!(metrics
& (DISPLAY_METRIC_BOUNDS
| DISPLAY_METRIC_ROTATION
|
635 DISPLAY_METRIC_DEVICE_SCALE_FACTOR
)))
637 const DisplayInfo
& display_info
=
638 GetDisplayManager()->GetDisplayInfo(display
.id());
639 DCHECK(!display_info
.bounds_in_native().IsEmpty());
640 AshWindowTreeHost
* ash_host
= window_tree_hosts_
[display
.id()];
641 ash_host
->AsWindowTreeHost()->SetBounds(display_info
.bounds_in_native());
642 SetDisplayPropertiesOnHost(ash_host
, display
);
645 void DisplayController::OnHostResized(const aura::WindowTreeHost
* host
) {
646 gfx::Display display
= Shell::GetScreen()->GetDisplayNearestWindow(
647 const_cast<aura::Window
*>(host
->window()));
649 DisplayManager
* display_manager
= GetDisplayManager();
650 if (display_manager
->UpdateDisplayBounds(display
.id(), host
->GetBounds())) {
651 mirror_window_controller_
->UpdateWindow();
652 cursor_window_controller_
->UpdateContainer();
656 void DisplayController::CreateOrUpdateNonDesktopDisplay(
657 const DisplayInfo
& info
) {
658 switch (GetDisplayManager()->second_display_mode()) {
659 case DisplayManager::MIRRORING
:
660 mirror_window_controller_
->UpdateWindow(info
);
661 cursor_window_controller_
->UpdateContainer();
663 case DisplayManager::EXTENDED
:
668 void DisplayController::CloseNonDesktopDisplay() {
669 mirror_window_controller_
->Close();
670 // If cursor_compositing is enabled for large cursor, the cursor window is
671 // always on the desktop display (the visible cursor on the non-desktop
672 // display is drawn through compositor mirroring). Therefore, it's unnecessary
673 // to handle the cursor_window at all. See: http://crbug.com/412910
674 if (!cursor_window_controller_
->is_cursor_compositing_enabled())
675 cursor_window_controller_
->UpdateContainer();
678 void DisplayController::PreDisplayConfigurationChange(bool clear_focus
) {
679 FOR_EACH_OBSERVER(Observer
, observers_
, OnDisplayConfigurationChanging());
680 focus_activation_store_
->Store(clear_focus
);
681 gfx::Screen
* screen
= Shell::GetScreen();
682 gfx::Point point_in_screen
= screen
->GetCursorScreenPoint();
683 gfx::Display display
= screen
->GetDisplayNearestPoint(point_in_screen
);
684 aura::Window
* root_window
= GetRootWindowForDisplayId(display
.id());
686 aura::client::ScreenPositionClient
* client
=
687 aura::client::GetScreenPositionClient(root_window
);
688 client
->ConvertPointFromScreen(root_window
, &point_in_screen
);
689 root_window
->GetHost()->ConvertPointToNativeScreen(&point_in_screen
);
690 cursor_location_in_native_coords_for_restore_
= point_in_screen
;
693 void DisplayController::PostDisplayConfigurationChange() {
695 limiter_
->SetThrottleTimeout(kAfterDisplayChangeThrottleTimeoutMs
);
697 focus_activation_store_
->Restore();
699 DisplayManager
* display_manager
= GetDisplayManager();
700 DisplayLayoutStore
* layout_store
= display_manager
->layout_store();
701 if (display_manager
->num_connected_displays() > 1) {
702 DisplayIdPair pair
= display_manager
->GetCurrentDisplayIdPair();
703 layout_store
->UpdateMirrorStatus(pair
, display_manager
->IsMirrored());
704 DisplayLayout layout
= layout_store
->GetRegisteredDisplayLayout(pair
);
706 if (Shell::GetScreen()->GetNumDisplays() > 1 ) {
707 int64 primary_id
= layout
.primary_id
;
709 primary_id
== gfx::Display::kInvalidDisplayID
?
710 pair
.first
: primary_id
);
711 // Update the primary_id in case the above call is
712 // ignored. Happens when a) default layout's primary id
713 // doesn't exist, or b) the primary_id has already been
714 // set to the same and didn't update it.
715 layout_store
->UpdatePrimaryDisplayId(
716 pair
, Shell::GetScreen()->GetPrimaryDisplay().id());
719 FOR_EACH_OBSERVER(Observer
, observers_
, OnDisplayConfigurationChanged());
720 UpdateHostWindowNames();
721 EnsurePointerInDisplays();
724 AshWindowTreeHost
* DisplayController::AddWindowTreeHostForDisplay(
725 const gfx::Display
& display
,
726 const AshWindowTreeHostInitParams
& init_params
) {
727 static int host_count
= 0;
728 const DisplayInfo
& display_info
=
729 GetDisplayManager()->GetDisplayInfo(display
.id());
730 AshWindowTreeHostInitParams
params_with_bounds(init_params
);
731 params_with_bounds
.initial_bounds
= display_info
.bounds_in_native();
732 AshWindowTreeHost
* ash_host
= AshWindowTreeHost::Create(params_with_bounds
);
733 aura::WindowTreeHost
* host
= ash_host
->AsWindowTreeHost();
735 host
->window()->SetName(base::StringPrintf("RootWindow-%d", host_count
++));
736 host
->window()->SetTitle(base::UTF8ToUTF16(display_info
.name()));
737 host
->compositor()->SetBackgroundColor(SK_ColorBLACK
);
738 // No need to remove our observer observer because the DisplayController
739 // outlives the host.
740 host
->AddObserver(this);
741 InitRootWindowSettings(host
->window())->display_id
= display
.id();
744 window_tree_hosts_
[display
.id()] = ash_host
;
745 SetDisplayPropertiesOnHost(ash_host
, display
);
747 #if defined(OS_CHROMEOS)
748 static bool force_constrain_pointer_to_root
=
749 CommandLine::ForCurrentProcess()->HasSwitch(
750 switches::kAshConstrainPointerToRoot
);
751 if (base::SysInfo::IsRunningOnChromeOS() || force_constrain_pointer_to_root
)
752 ash_host
->ConfineCursorToRootWindow();
757 void DisplayController::OnFadeOutForSwapDisplayFinished() {
758 #if defined(OS_CHROMEOS)
759 SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
760 Shell::GetInstance()->display_configurator_animation()
761 ->StartFadeInAnimation();
765 void DisplayController::SetMirrorModeAfterAnimation(bool mirror
) {
766 GetDisplayManager()->SetMirrorMode(mirror
);
769 void DisplayController::UpdateHostWindowNames() {
771 // crbug.com/120229 - set the window title for the primary dislpay
772 // to "aura_root_0" so gtalk can find the primary root window to broadcast.
773 // TODO(jhorwich) Remove this once Chrome supports window-based broadcasting.
774 aura::Window
* primary
= Shell::GetPrimaryRootWindow();
775 aura::Window::Windows root_windows
= Shell::GetAllRootWindows();
776 for (size_t i
= 0; i
< root_windows
.size(); ++i
) {
778 root_windows
[i
] == primary
? "aura_root_0" : "aura_root_x";
779 gfx::AcceleratedWidget xwindow
=
780 root_windows
[i
]->GetHost()->GetAcceleratedWidget();
781 XStoreName(gfx::GetXDisplay(), xwindow
, name
.c_str());