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
|
// Copyright (c) 2011 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 VIEWS_WINDOW_WINDOW_H_
#define VIEWS_WINDOW_WINDOW_H_
#pragma once
#include "ui/gfx/native_widget_types.h"
#include "views/widget/widget.h"
#include "views/window/client_view.h"
#include "views/window/native_window_delegate.h"
#include "views/window/non_client_view.h"
namespace gfx {
class Font;
class Rect;
class Size;
} // namespace gfx
namespace views {
class NativeWindow;
class NonClientFrameView;
class Widget;
class WindowDelegate;
////////////////////////////////////////////////////////////////////////////////
// Window class
//
// Encapsulates window-like behavior. See WindowDelegate.
//
class Window : public Widget,
public internal::NativeWindowDelegate {
public:
struct InitParams {
// |window_delegate| cannot be NULL.
explicit InitParams(WindowDelegate* window_delegate);
WindowDelegate* window_delegate;
gfx::NativeWindow parent_window;
NativeWindow* native_window;
Widget::InitParams widget_init_params;
};
enum FrameType {
FRAME_TYPE_DEFAULT, // Use whatever the default would be.
FRAME_TYPE_FORCE_CUSTOM, // Force the custom frame.
FRAME_TYPE_FORCE_NATIVE // Force the native frame.
};
Window();
virtual ~Window();
// Creates an instance of an object implementing this interface.
// TODO(beng): create a version of this function that takes a NativeView, for
// constrained windows.
static Window* CreateChromeWindow(gfx::NativeWindow parent,
const gfx::Rect& bounds,
WindowDelegate* window_delegate);
// Returns the preferred size of the contents view of this window based on
// its localized size data. The width in cols is held in a localized string
// resource identified by |col_resource_id|, the height in the same fashion.
// TODO(beng): This should eventually live somewhere else, probably closer to
// ClientView.
static int GetLocalizedContentsWidth(int col_resource_id);
static int GetLocalizedContentsHeight(int row_resource_id);
static gfx::Size GetLocalizedContentsSize(int col_resource_id,
int row_resource_id);
// Initializes the window. Must be called before any post-configuration
// operations are performed.
void InitWindow(const InitParams& params);
// Retrieves the window's bounds, including its frame.
gfx::Rect GetBounds() const;
// Retrieves the restored bounds for the window.
gfx::Rect GetNormalBounds() const;
// Like Show(), but does not activate the window.
void ShowInactive();
// Prevents the window from being rendered as deactivated the next time it is.
// This state is reset automatically as soon as the window becomes activated
// again. There is no ability to control the state through this API as this
// leads to sync problems.
void DisableInactiveRendering();
// Toggles the enable state for the Close button (and the Close menu item in
// the system menu).
void EnableClose(bool enable);
// Tell the window to update its title from the delegate.
void UpdateWindowTitle();
// Tell the window to update its icon from the delegate.
void UpdateWindowIcon();
// Creates an appropriate NonClientFrameView for this window.
virtual NonClientFrameView* CreateFrameViewForWindow();
// Updates the frame after an event caused it to be changed.
virtual void UpdateFrameAfterFrameChange();
void set_frame_type(FrameType frame_type) { frame_type_ = frame_type; }
FrameType frame_type() const { return frame_type_; }
// Whether we should be using a native frame.
bool ShouldUseNativeFrame() const;
// Forces the frame into the alternate frame type (custom or native) depending
// on its current state.
void DebugToggleFrameType();
// Tell the window that something caused the frame type to change.
void FrameTypeChanged();
// Overridden from Widget:
virtual void Show() OVERRIDE;
virtual void Close() OVERRIDE;
WindowDelegate* window_delegate() {
return const_cast<WindowDelegate*>(
const_cast<const Window*>(this)->window_delegate());
}
const WindowDelegate* window_delegate() const {
return window_delegate_;
}
NonClientView* non_client_view() {
return const_cast<NonClientView*>(
const_cast<const Window*>(this)->non_client_view());
}
const NonClientView* non_client_view() const {
return non_client_view_;
}
ClientView* client_view() {
return const_cast<ClientView*>(
const_cast<const Window*>(this)->client_view());
}
const ClientView* client_view() const {
return non_client_view()->client_view();
}
NativeWindow* native_window() { return native_window_; }
protected:
// Overridden from NativeWindowDelegate:
virtual bool CanActivate() const OVERRIDE;
virtual bool IsInactiveRenderingDisabled() const OVERRIDE;
virtual void EnableInactiveRendering() OVERRIDE;
virtual bool IsModal() const OVERRIDE;
virtual bool IsDialogBox() const OVERRIDE;
virtual gfx::Size GetMinimumSize() const OVERRIDE;
virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE;
virtual bool ExecuteCommand(int command_id) OVERRIDE;
virtual void OnNativeWindowCreated(const gfx::Rect& bounds) OVERRIDE;
virtual void OnNativeWindowActivationChanged(bool active) OVERRIDE;
virtual void OnNativeWindowBeginUserBoundsChange() OVERRIDE;
virtual void OnNativeWindowEndUserBoundsChange() OVERRIDE;
virtual void OnNativeWindowDestroying() OVERRIDE;
virtual void OnNativeWindowDestroyed() OVERRIDE;
virtual void OnNativeWindowBoundsChanged() OVERRIDE;
virtual Window* AsWindow() OVERRIDE;
virtual internal::NativeWidgetDelegate* AsNativeWidgetDelegate() OVERRIDE;
private:
// Sizes and positions the window just after it is created.
void SetInitialBounds(const gfx::Rect& bounds);
// Persists the window's restored position and maximized state using the
// window delegate.
void SaveWindowPosition();
NativeWindow* native_window_;
// Our window delegate (see InitWindow() method for documentation).
WindowDelegate* window_delegate_;
// The View that provides the non-client area of the window (title bar,
// window controls, sizing borders etc). To use an implementation other than
// the default, this class must be sub-classed and this value set to the
// desired implementation before calling |InitWindow()|.
NonClientView* non_client_view_;
// The saved maximized state for this window. See note in SetInitialBounds
// that explains why we save this.
bool saved_maximized_state_;
// The smallest size the window can be.
gfx::Size minimum_size_;
// True when the window should be rendered as active, regardless of whether
// or not it actually is.
bool disable_inactive_rendering_;
// Set to true if the window is in the process of closing .
bool window_closed_;
// The current frame type in use by this window. Defaults to
// FRAME_TYPE_DEFAULT.
FrameType frame_type_;
DISALLOW_COPY_AND_ASSIGN(Window);
};
} // namespace views
#endif // #ifndef VIEWS_WINDOW_WINDOW_H_
|
