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
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
|
// 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_SHELL_H_
#define ASH_SHELL_H_
#pragma once
#include <utility>
#include <vector>
#include "ash/ash_export.h"
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/gtest_prod_util.h"
#include "base/memory/scoped_ptr.h"
#include "ui/gfx/size.h"
class CommandLine;
namespace aura {
class EventFilter;
class RootWindow;
class Window;
}
namespace gfx {
class Point;
class Rect;
}
namespace ui {
class Layer;
}
namespace views {
class NonClientFrameView;
class Widget;
}
namespace ash {
class AcceleratorController;
class Launcher;
class NestedDispatcherController;
class PowerButtonController;
class ShellDelegate;
class VideoDetector;
class WindowCycleController;
namespace internal {
class ActivationController;
class AcceleratorFilter;
class AppList;
class DragDropController;
class FocusCycler;
class InputMethodEventFilter;
class PartialScreenshotEventFilter;
class RootWindowEventFilter;
class RootWindowLayoutManager;
class ShadowController;
class ShelfLayoutManager;
class StackingController;
class TooltipController;
class VisibilityController;
class WindowModalityController;
class WorkspaceController;
}
// Shell is a singleton object that presents the Shell API and implements the
// RootWindow's delegate interface.
//
// Upon creation, the Shell sets itself as the RootWindow's delegate, which
// takes ownership of the Shell.
class ASH_EXPORT Shell {
public:
// In compact window mode we fill the screen with a single maximized window,
// similar to ChromeOS R17 and earlier. In overlapping mode we have draggable
// windows. In managed mode the workspace arranges windows for the user.
enum WindowMode {
MODE_COMPACT,
MODE_MANAGED,
MODE_OVERLAPPING,
};
enum BackgroundMode {
BACKGROUND_IMAGE,
BACKGROUND_SOLID_COLOR
};
enum Direction {
FORWARD,
BACKWARD
};
// A shell must be explicitly created so that it can call |Init()| with the
// delegate set. |delegate| can be NULL (if not required for initialization).
static Shell* CreateInstance(ShellDelegate* delegate);
// Should never be called before |CreateInstance()|.
static Shell* GetInstance();
static void DeleteInstance();
// Get the singleton RootWindow used by the Shell.
static aura::RootWindow* GetRootWindow();
const gfx::Size& compact_status_area_offset() const {
return compact_status_area_offset_;
}
BackgroundMode desktop_background_mode() const {
return desktop_background_mode_;
}
aura::Window* GetContainer(int container_id);
const aura::Window* GetContainer(int container_id) const;
// Adds or removes |filter| from the RootWindowEventFilter.
void AddRootWindowEventFilter(aura::EventFilter* filter);
void RemoveRootWindowEventFilter(aura::EventFilter* filter);
size_t GetRootWindowEventFilterCount() const;
// Shows the background menu over |widget|.
void ShowBackgroundMenu(views::Widget* widget, const gfx::Point& location);
// Toggles app list.
void ToggleAppList();
// Dynamic window mode chooses between MODE_OVERLAPPING and MODE_COMPACT
// based on screen resolution and dynamically changes modes when the screen
// resolution changes (e.g. plugging in a monitor).
void set_dynamic_window_mode(bool value) { dynamic_window_mode_ = value; }
// Changes the current window mode, which will cause all the open windows
// to be laid out in the new mode and layout managers and event filters to be
// installed or removed.
void ChangeWindowMode(WindowMode mode);
// Sets an appropriate window mode for the given screen resolution.
void SetWindowModeForMonitorSize(const gfx::Size& monitor_size);
// Sets the desktop background mode.
void SetDesktopBackgroundMode(BackgroundMode mode);
// Returns true if the screen is locked.
bool IsScreenLocked() const;
// Returns true if a modal dialog window is currently open.
bool IsModalWindowOpen() const;
// See enum WindowMode for details.
bool IsWindowModeCompact() const { return window_mode_ == MODE_COMPACT; }
// Sets the offset between the corner of the status area and the corner of the
// screen when we're using the compact window mode.
void SetCompactStatusAreaOffset(gfx::Size& offset);
// Creates a default views::NonClientFrameView for use by windows in the
// Ash environment.
views::NonClientFrameView* CreateDefaultNonClientFrameView(
views::Widget* widget);
// Rotate focus through containers that can recieve focus.
void RotateFocus(Direction direction);
#if !defined(OS_MACOSX)
AcceleratorController* accelerator_controller() {
return accelerator_controller_.get();
}
#endif // !defined(OS_MACOSX)
internal::RootWindowEventFilter* root_filter() {
return root_filter_;
}
internal::TooltipController* tooltip_controller() {
return tooltip_controller_.get();
}
internal::PartialScreenshotEventFilter* partial_screenshot_filter() {
return partial_screenshot_filter_.get();
}
PowerButtonController* power_button_controller() {
return power_button_controller_.get();
}
VideoDetector* video_detector() {
return video_detector_.get();
}
WindowCycleController* window_cycle_controller() {
return window_cycle_controller_.get();
}
ShellDelegate* delegate() { return delegate_.get(); }
Launcher* launcher() { return launcher_.get(); }
internal::ShelfLayoutManager* shelf() const { return shelf_; }
// Made available for tests.
internal::ShadowController* shadow_controller() {
return shadow_controller_.get();
}
private:
FRIEND_TEST_ALL_PREFIXES(ShellTest, ComputeWindowMode);
FRIEND_TEST_ALL_PREFIXES(ShellTest, ChangeWindowMode);
typedef std::pair<aura::Window*, gfx::Rect> WindowAndBoundsPair;
explicit Shell(ShellDelegate* delegate);
virtual ~Shell();
void Init();
// Returns the appropriate window mode to use based on the primary monitor's
// |monitor_size| and the user's |command_line|.
WindowMode ComputeWindowMode(const gfx::Size& monitor_size,
CommandLine* command_line) const;
// Initializes or re-initializes the layout managers and event filters needed
// to support a given window mode and cleans up the unneeded ones.
void SetupCompactWindowMode();
void SetupNonCompactWindowMode();
// Sets the LayoutManager of the container with the specified id to NULL. This
// has the effect of deleting the current LayoutManager.
void ResetLayoutManager(int container_id);
static Shell* instance_;
internal::RootWindowEventFilter* root_filter_; // not owned
std::vector<WindowAndBoundsPair> to_restore_;
#if !defined(OS_MACOSX)
scoped_ptr<NestedDispatcherController> nested_dispatcher_controller_;
scoped_ptr<AcceleratorController> accelerator_controller_;
#endif // !defined(OS_MACOSX)
scoped_ptr<ShellDelegate> delegate_;
scoped_ptr<Launcher> launcher_;
scoped_ptr<internal::AppList> app_list_;
scoped_ptr<internal::StackingController> stacking_controller_;
scoped_ptr<internal::ActivationController> activation_controller_;
scoped_ptr<internal::WindowModalityController> window_modality_controller_;
scoped_ptr<internal::DragDropController> drag_drop_controller_;
scoped_ptr<internal::WorkspaceController> workspace_controller_;
scoped_ptr<internal::ShadowController> shadow_controller_;
scoped_ptr<internal::TooltipController> tooltip_controller_;
scoped_ptr<internal::VisibilityController> visibility_controller_;
scoped_ptr<PowerButtonController> power_button_controller_;
scoped_ptr<VideoDetector> video_detector_;
scoped_ptr<WindowCycleController> window_cycle_controller_;
scoped_ptr<internal::FocusCycler> focus_cycler_;
// An event filter that pre-handles all key events to send them to an IME.
scoped_ptr<internal::InputMethodEventFilter> input_method_filter_;
// An event filter that pre-handles key events while the partial
// screenshot UI is active.
scoped_ptr<internal::PartialScreenshotEventFilter> partial_screenshot_filter_;
#if !defined(OS_MACOSX)
// An event filter that pre-handles global accelerators.
scoped_ptr<internal::AcceleratorFilter> accelerator_filter_;
#endif
// The shelf for managing the launcher and the status widget in non-compact
// mode. Shell does not own the shelf. Instead, it is owned by container of
// the status area.
internal::ShelfLayoutManager* shelf_;
// Change window mode based on screen resolution.
bool dynamic_window_mode_;
// Can change at runtime.
WindowMode window_mode_;
// Can change at runtime.
BackgroundMode desktop_background_mode_;
// Owned by aura::RootWindow, cached here for type safety.
internal::RootWindowLayoutManager* root_window_layout_;
// Status area with clock, Wi-Fi signal, etc.
views::Widget* status_widget_;
// Offset between the corner of the status area and the corner of the screen
// when in the compact window mode.
gfx::Size compact_status_area_offset_;
DISALLOW_COPY_AND_ASSIGN(Shell);
};
} // namespace ash
#endif // ASH_SHELL_H_
|