1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
|
// 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_DISPLAY_CONTROLLER_H_
#define ASH_DISPLAY_DISPLAY_CONTROLLER_H_
#include <map>
#include <vector>
#include "ash/ash_export.h"
#include "ash/display/display_manager.h"
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/gtest_prod_util.h"
#include "base/memory/scoped_ptr.h"
#include "base/observer_list.h"
#include "base/time/time.h"
#include "ui/aura/window.h"
#include "ui/aura/window_tree_host_observer.h"
#include "ui/gfx/display_observer.h"
#include "ui/gfx/point.h"
namespace aura {
class Display;
class WindowTreeHost;
}
namespace base {
class Value;
template <typename T> class JSONValueConverter;
}
namespace gfx {
class Display;
class Insets;
}
namespace ash {
class AshWindowTreeHost;
struct AshWindowTreeHostInitParams;
class CursorWindowController;
class DisplayInfo;
class DisplayManager;
class FocusActivationStore;
class MirrorWindowController;
class RootWindowController;
class VirtualKeyboardWindowController;
// DisplayController owns and maintains RootWindows for each attached
// display, keeping them in sync with display configuration changes.
class ASH_EXPORT DisplayController : public gfx::DisplayObserver,
public aura::WindowTreeHostObserver,
public DisplayManager::Delegate {
public:
class ASH_EXPORT Observer {
public:
// Invoked only once after all displays are initialized
// after startup.
virtual void OnDisplaysInitialized() {}
// Invoked when the display configuration change is requested,
// but before the change is applied to aura/ash.
virtual void OnDisplayConfigurationChanging() {}
// Invoked when the all display configuration changes
// have been applied.
virtual void OnDisplayConfigurationChanged() {};
protected:
virtual ~Observer() {}
};
DisplayController();
virtual ~DisplayController();
void Start();
void Shutdown();
// Returns primary display's ID.
// TODO(oshima): Move this out from DisplayController;
static int64 GetPrimaryDisplayId();
CursorWindowController* cursor_window_controller() {
return cursor_window_controller_.get();
}
MirrorWindowController* mirror_window_controller() {
return mirror_window_controller_.get();
}
VirtualKeyboardWindowController* virtual_keyboard_window_controller() {
return virtual_keyboard_window_controller_.get();
}
// Create a WindowTreeHost for the primary display. This replaces
// |initial_bounds| in |init_params|.
void CreatePrimaryHost(const AshWindowTreeHostInitParams& init_params);
// Initializes all displays.
void InitDisplays();
// Add/Remove observers.
void AddObserver(Observer* observer);
void RemoveObserver(Observer* observer);
// Returns the root window for primary display.
aura::Window* GetPrimaryRootWindow();
// Returns the root window for |display_id|.
aura::Window* GetRootWindowForDisplayId(int64 id);
// Toggle mirror mode.
void ToggleMirrorMode();
// Swap primary and secondary display.
void SwapPrimaryDisplay();
// Sets the ID of the primary display. If the display is not connected, it
// will switch the primary display when connected.
void SetPrimaryDisplayId(int64 id);
// Sets primary display. This re-assigns the current root
// window to given |display|.
void SetPrimaryDisplay(const gfx::Display& display);
// Closes all child windows in the all root windows.
void CloseChildWindows();
// Returns all root windows. In non extended desktop mode, this
// returns the primary root window only.
aura::Window::Windows GetAllRootWindows();
// Returns all oot window controllers. In non extended desktop
// mode, this return a RootWindowController for the primary root window only.
std::vector<RootWindowController*> GetAllRootWindowControllers();
// Gets/Sets/Clears the overscan insets for the specified |display_id|. See
// display_manager.h for the details.
gfx::Insets GetOverscanInsets(int64 display_id) const;
void SetOverscanInsets(int64 display_id, const gfx::Insets& insets_in_dip);
// Checks if the mouse pointer is on one of displays, and moves to
// the center of the nearest display if it's outside of all displays.
void EnsurePointerInDisplays();
// Sets the work area's |insets| to the display assigned to |window|.
bool UpdateWorkAreaOfDisplayNearestWindow(const aura::Window* window,
const gfx::Insets& insets);
// gfx::DisplayObserver overrides:
virtual void OnDisplayAdded(const gfx::Display& display) OVERRIDE;
virtual void OnDisplayRemoved(const gfx::Display& display) OVERRIDE;
virtual void OnDisplayMetricsChanged(const gfx::Display& display,
uint32_t metrics) OVERRIDE;
// aura::WindowTreeHostObserver overrides:
virtual void OnHostResized(const aura::WindowTreeHost* host) OVERRIDE;
// aura::DisplayManager::Delegate overrides:
virtual void CreateOrUpdateNonDesktopDisplay(const DisplayInfo& info)
OVERRIDE;
virtual void CloseNonDesktopDisplay() OVERRIDE;
virtual void PreDisplayConfigurationChange(bool clear_focus) OVERRIDE;
virtual void PostDisplayConfigurationChange() OVERRIDE;
private:
FRIEND_TEST_ALL_PREFIXES(DisplayControllerTest, BoundsUpdated);
FRIEND_TEST_ALL_PREFIXES(DisplayControllerTest, SecondaryDisplayLayout);
friend class DisplayManager;
friend class MirrorWindowController;
// Creates a WindowTreeHost for |display| and stores it in the
// |window_tree_hosts_| map.
AshWindowTreeHost* AddWindowTreeHostForDisplay(
const gfx::Display& display,
const AshWindowTreeHostInitParams& params);
void OnFadeOutForSwapDisplayFinished();
void UpdateHostWindowNames();
class DisplayChangeLimiter {
public:
DisplayChangeLimiter();
// Sets how long the throttling should last.
void SetThrottleTimeout(int64 throttle_ms);
bool IsThrottled() const;
private:
// The time when the throttling ends.
base::Time throttle_timeout_;
DISALLOW_COPY_AND_ASSIGN(DisplayChangeLimiter);
};
// The limiter to throttle how fast a user can
// change the display configuration.
scoped_ptr<DisplayChangeLimiter> limiter_;
typedef std::map<int64, AshWindowTreeHost*> WindowTreeHostMap;
// The mapping from display ID to its window tree host.
WindowTreeHostMap window_tree_hosts_;
ObserverList<Observer> observers_;
// Store the primary window tree host temporarily while replacing
// display.
AshWindowTreeHost* primary_tree_host_for_replace_;
scoped_ptr<FocusActivationStore> focus_activation_store_;
scoped_ptr<CursorWindowController> cursor_window_controller_;
scoped_ptr<MirrorWindowController> mirror_window_controller_;
scoped_ptr<VirtualKeyboardWindowController>
virtual_keyboard_window_controller_;
// Stores the curent cursor location (in native coordinates) used to
// restore the cursor location when display configuration
// changed.
gfx::Point cursor_location_in_native_coords_for_restore_;
DISALLOW_COPY_AND_ASSIGN(DisplayController);
};
} // namespace ash
#endif // ASH_DISPLAY_DISPLAY_CONTROLLER_H_
|