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
|
// 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 UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_WIN_H_
#define UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_WIN_H_
#include "ui/aura/client/animation_host.h"
#include "ui/aura/root_window_host.h"
#include "ui/views/views_export.h"
#include "ui/views/widget/desktop_aura/desktop_root_window_host.h"
#include "ui/views/win/hwnd_message_handler_delegate.h"
namespace aura {
namespace client {
class FocusClient;
class ScreenPositionClient;
}
}
namespace views {
class DesktopCursorClient;
class DesktopDispatcherClient;
class DesktopDragDropClientWin;
class HWNDMessageHandler;
namespace corewm {
class CursorManager;
}
class VIEWS_EXPORT DesktopRootWindowHostWin
: public DesktopRootWindowHost,
public aura::client::AnimationHost,
public aura::RootWindowHost,
public HWNDMessageHandlerDelegate {
public:
DesktopRootWindowHostWin(
internal::NativeWidgetDelegate* native_widget_delegate,
DesktopNativeWidgetAura* desktop_native_widget_aura,
const gfx::Rect& initial_bounds);
virtual ~DesktopRootWindowHostWin();
// A way of converting an HWND into a content window.
static aura::Window* GetContentWindowForHWND(HWND hwnd);
protected:
// Overridden from DesktopRootWindowHost:
virtual aura::RootWindow* Init(aura::Window* content_window,
const Widget::InitParams& params) OVERRIDE;
virtual void InitFocus(aura::Window* window) OVERRIDE;
virtual void Close() OVERRIDE;
virtual void CloseNow() OVERRIDE;
virtual aura::RootWindowHost* AsRootWindowHost() OVERRIDE;
virtual void ShowWindowWithState(ui::WindowShowState show_state) OVERRIDE;
virtual void ShowMaximizedWithBounds(
const gfx::Rect& restored_bounds) OVERRIDE;
virtual bool IsVisible() const OVERRIDE;
virtual void SetSize(const gfx::Size& size) OVERRIDE;
virtual void CenterWindow(const gfx::Size& size) OVERRIDE;
virtual void GetWindowPlacement(
gfx::Rect* bounds,
ui::WindowShowState* show_state) const OVERRIDE;
virtual gfx::Rect GetWindowBoundsInScreen() const OVERRIDE;
virtual gfx::Rect GetClientAreaBoundsInScreen() const OVERRIDE;
virtual gfx::Rect GetRestoredBounds() const OVERRIDE;
virtual gfx::Rect GetWorkAreaBoundsInScreen() const OVERRIDE;
virtual void SetShape(gfx::NativeRegion native_region) OVERRIDE;
virtual void Activate() OVERRIDE;
virtual void Deactivate() OVERRIDE;
virtual bool IsActive() const OVERRIDE;
virtual void Maximize() OVERRIDE;
virtual void Minimize() OVERRIDE;
virtual void Restore() OVERRIDE;
virtual bool IsMaximized() const OVERRIDE;
virtual bool IsMinimized() const OVERRIDE;
virtual bool HasCapture() const OVERRIDE;
virtual void SetAlwaysOnTop(bool always_on_top) OVERRIDE;
virtual void SetWindowTitle(const string16& title) OVERRIDE;
virtual void ClearNativeFocus() OVERRIDE;
virtual Widget::MoveLoopResult RunMoveLoop(
const gfx::Vector2d& drag_offset,
Widget::MoveLoopSource source) OVERRIDE;
virtual void EndMoveLoop() OVERRIDE;
virtual void SetVisibilityChangedAnimationsEnabled(bool value) OVERRIDE;
virtual bool ShouldUseNativeFrame() OVERRIDE;
virtual void FrameTypeChanged() OVERRIDE;
virtual NonClientFrameView* CreateNonClientFrameView() OVERRIDE;
virtual void SetFullscreen(bool fullscreen) OVERRIDE;
virtual bool IsFullscreen() const OVERRIDE;
virtual void SetOpacity(unsigned char opacity) OVERRIDE;
virtual void SetWindowIcons(const gfx::ImageSkia& window_icon,
const gfx::ImageSkia& app_icon) OVERRIDE;
virtual void InitModalType(ui::ModalType modal_type) OVERRIDE;
virtual void FlashFrame(bool flash_frame) OVERRIDE;
virtual void OnRootViewLayout() const OVERRIDE;
virtual void OnNativeWidgetFocus() OVERRIDE;
virtual void OnNativeWidgetBlur() OVERRIDE;
// Overridden from aura::RootWindowHost:
virtual void SetDelegate(aura::RootWindowHostDelegate* delegate) OVERRIDE;
virtual aura::RootWindow* GetRootWindow() OVERRIDE;
virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
virtual void Show() OVERRIDE;
virtual void Hide() OVERRIDE;
virtual void ToggleFullScreen() OVERRIDE;
virtual gfx::Rect GetBounds() const OVERRIDE;
virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE;
virtual gfx::Insets GetInsets() const OVERRIDE;
virtual void SetInsets(const gfx::Insets& insets) OVERRIDE;
virtual gfx::Point GetLocationOnNativeScreen() const OVERRIDE;
virtual void SetCapture() OVERRIDE;
virtual void ReleaseCapture() OVERRIDE;
virtual void SetCursor(gfx::NativeCursor cursor) OVERRIDE;
virtual bool QueryMouseLocation(gfx::Point* location_return) OVERRIDE;
virtual bool ConfineCursorToRootWindow() OVERRIDE;
virtual void UnConfineCursor() OVERRIDE;
virtual void OnCursorVisibilityChanged(bool show) OVERRIDE;
virtual void MoveCursorTo(const gfx::Point& location) OVERRIDE;
virtual void SetFocusWhenShown(bool focus_when_shown) OVERRIDE;
virtual void PostNativeEvent(const base::NativeEvent& native_event) OVERRIDE;
virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
virtual void PrepareForShutdown() OVERRIDE;
// Overridden from aura::client::AnimationHost
virtual void SetHostTransitionBounds(const gfx::Rect& bounds) OVERRIDE;
virtual void OnWindowHidingAnimationCompleted() OVERRIDE;
// Overridden from HWNDMessageHandlerDelegate:
virtual bool IsWidgetWindow() const OVERRIDE;
virtual bool IsUsingCustomFrame() const OVERRIDE;
virtual void SchedulePaint() OVERRIDE;
virtual void EnableInactiveRendering() OVERRIDE;
virtual bool IsInactiveRenderingDisabled() OVERRIDE;
virtual bool CanResize() const OVERRIDE;
virtual bool CanMaximize() const OVERRIDE;
virtual bool CanActivate() const OVERRIDE;
virtual bool WidgetSizeIsClientSize() const OVERRIDE;
virtual bool CanSaveFocus() const OVERRIDE;
virtual void SaveFocusOnDeactivate() OVERRIDE;
virtual void RestoreFocusOnActivate() OVERRIDE;
virtual void RestoreFocusOnEnable() OVERRIDE;
virtual bool IsModal() const OVERRIDE;
virtual int GetInitialShowState() const OVERRIDE;
virtual bool WillProcessWorkAreaChange() const OVERRIDE;
virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE;
virtual void GetWindowMask(const gfx::Size& size, gfx::Path* path) OVERRIDE;
virtual bool GetClientAreaInsets(gfx::Insets* insets) const OVERRIDE;
virtual void GetMinMaxSize(gfx::Size* min_size,
gfx::Size* max_size) const OVERRIDE;
virtual gfx::Size GetRootViewSize() const OVERRIDE;
virtual void ResetWindowControls() OVERRIDE;
virtual void PaintLayeredWindow(gfx::Canvas* canvas) OVERRIDE;
virtual gfx::NativeViewAccessible GetNativeViewAccessible() OVERRIDE;
virtual bool ShouldHandleSystemCommands() const OVERRIDE;
virtual InputMethod* GetInputMethod() OVERRIDE;
virtual void HandleAppDeactivated() OVERRIDE;
virtual void HandleActivationChanged(bool active) OVERRIDE;
virtual bool HandleAppCommand(short command) OVERRIDE;
virtual void HandleCancelMode() OVERRIDE;
virtual void HandleCaptureLost() OVERRIDE;
virtual void HandleClose() OVERRIDE;
virtual bool HandleCommand(int command) OVERRIDE;
virtual void HandleAccelerator(const ui::Accelerator& accelerator) OVERRIDE;
virtual void HandleCreate() OVERRIDE;
virtual void HandleDestroying() OVERRIDE;
virtual void HandleDestroyed() OVERRIDE;
virtual bool HandleInitialFocus() OVERRIDE;
virtual void HandleDisplayChange() OVERRIDE;
virtual void HandleBeginWMSizeMove() OVERRIDE;
virtual void HandleEndWMSizeMove() OVERRIDE;
virtual void HandleMove() OVERRIDE;
virtual void HandleWorkAreaChanged() OVERRIDE;
virtual void HandleVisibilityChanging(bool visible) OVERRIDE;
virtual void HandleVisibilityChanged(bool visible) OVERRIDE;
virtual void HandleClientSizeChanged(const gfx::Size& new_size) OVERRIDE;
virtual void HandleFrameChanged() OVERRIDE;
virtual void HandleNativeFocus(HWND last_focused_window) OVERRIDE;
virtual void HandleNativeBlur(HWND focused_window) OVERRIDE;
virtual bool HandleMouseEvent(const ui::MouseEvent& event) OVERRIDE;
virtual bool HandleKeyEvent(const ui::KeyEvent& event) OVERRIDE;
virtual bool HandleUntranslatedKeyEvent(const ui::KeyEvent& event) OVERRIDE;
virtual void HandleTouchEvent(const ui::TouchEvent& event) OVERRIDE;
virtual bool HandleIMEMessage(UINT message,
WPARAM w_param,
LPARAM l_param,
LRESULT* result) OVERRIDE;
virtual void HandleInputLanguageChange(DWORD character_set,
HKL input_language_id) OVERRIDE;
virtual bool HandlePaintAccelerated(const gfx::Rect& invalid_rect) OVERRIDE;
virtual void HandlePaint(gfx::Canvas* canvas) OVERRIDE;
virtual bool HandleTooltipNotify(int w_param,
NMHDR* l_param,
LRESULT* l_result) OVERRIDE;
virtual void HandleTooltipMouseMove(UINT message,
WPARAM w_param,
LPARAM l_param) OVERRIDE;
virtual bool PreHandleMSG(UINT message,
WPARAM w_param,
LPARAM l_param,
LRESULT* result) OVERRIDE;
virtual void PostHandleMSG(UINT message,
WPARAM w_param,
LPARAM l_param) OVERRIDE;
Widget* GetWidget();
const Widget* GetWidget() const;
HWND GetHWND() const;
private:
void SetWindowTransparency();
// We are owned by the RootWindow, but we have to have a back pointer to it.
aura::RootWindow* root_window_;
scoped_ptr<HWNDMessageHandler> message_handler_;
scoped_ptr<DesktopDispatcherClient> dispatcher_client_;
scoped_ptr<aura::client::FocusClient> focus_client_;
// TODO(beng): Consider providing an interface to DesktopNativeWidgetAura
// instead of providing this route back to Widget.
internal::NativeWidgetDelegate* native_widget_delegate_;
DesktopNativeWidgetAura* desktop_native_widget_aura_;
aura::RootWindowHostDelegate* root_window_host_delegate_;
aura::Window* content_window_;
// In some cases, we set a screen position client on |root_window_|. If we
// do, we're responsible for the lifetime.
scoped_ptr<aura::client::ScreenPositionClient> position_client_;
// Controls visibility of the cursor.
scoped_ptr<views::corewm::CursorManager> cursor_client_;
scoped_ptr<DesktopDragDropClientWin> drag_drop_client_;
// Extra size added to the host window. Typically, the window size matches
// the contained content, however, when performing a translating or scaling
// animation the window has to be enlarged so that the content is not
// clipped.
gfx::Rect window_expansion_;
// Whether the window close should be converted to a hide, and then actually
// closed on the completion of the hide animation. This is cached because
// the property is set on the contained window which has a shorter lifetime.
bool should_animate_window_close_;
// When Close()d and animations are being applied to this window, the close
// of the window needs to be deferred to when the close animation is
// completed. This variable indicates that a Close was converted to a Hide,
// so that when the Hide is completed the host window should be closed.
bool pending_close_;
// True if the widget is going to have a non_client_view. We cache this value
// rather than asking the Widget for the non_client_view so that we know at
// Init time, before the Widget has created the NonClientView.
bool has_non_client_view_;
DISALLOW_COPY_AND_ASSIGN(DesktopRootWindowHostWin);
};
} // namespace views
#endif // UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_WIN_H_
|
