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
|
// 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_VIEWS_DELEGATE_H_
#define UI_VIEWS_VIEWS_DELEGATE_H_
#include <string>
#if defined(OS_WIN)
#include <windows.h>
#endif
#include "base/callback.h"
#include "base/location.h"
#include "base/macros.h"
#include "base/strings/string16.h"
#include "build/build_config.h"
#include "ui/accessibility/ax_enums.h"
#include "ui/base/ui_base_types.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/views/views_export.h"
#include "ui/views/widget/widget.h"
namespace base {
class TaskRunner;
class TimeDelta;
}
namespace content {
class WebContents;
class BrowserContext;
class SiteInstance;
}
namespace gfx {
class ImageSkia;
class Rect;
}
namespace ui {
class ContextFactory;
}
namespace views {
class NativeWidget;
class NonClientFrameView;
class ViewsTouchEditingControllerFactory;
class View;
class Widget;
#if defined(USE_AURA)
class TouchSelectionMenuRunnerViews;
#endif
namespace internal {
class NativeWidgetDelegate;
}
// ViewsDelegate is an interface implemented by an object using the views
// framework. It is used to obtain various high level application utilities
// and perform some actions such as window placement saving.
//
// The embedding app must set the ViewsDelegate instance by instantiating an
// implementation of ViewsDelegate (the constructor will set the instance).
class VIEWS_EXPORT ViewsDelegate {
public:
using NativeWidgetFactory =
base::Callback<NativeWidget*(const Widget::InitParams&,
internal::NativeWidgetDelegate*)>;
#if defined(OS_WIN)
enum AppbarAutohideEdge {
EDGE_TOP = 1 << 0,
EDGE_LEFT = 1 << 1,
EDGE_BOTTOM = 1 << 2,
EDGE_RIGHT = 1 << 3,
};
#endif
enum class ProcessMenuAcceleratorResult {
// The accelerator was handled while the menu was showing. No further action
// is needed and the menu should be kept open.
LEAVE_MENU_OPEN,
// The accelerator was not handled. Menu should be closed and the
// accelerator will be reposted to be handled after the menu closes.
CLOSE_MENU
};
virtual ~ViewsDelegate();
// Returns the ViewsDelegate instance if there is one, or nullptr otherwise.
static ViewsDelegate* GetInstance();
// Call this method to set a factory callback that will be used to construct
// NativeWidget implementations overriding the platform defaults.
void set_native_widget_factory(NativeWidgetFactory factory) {
native_widget_factory_ = factory;
}
const NativeWidgetFactory& native_widget_factory() {
return native_widget_factory_;
}
// Saves the position, size and "show" state for the window with the
// specified name.
virtual void SaveWindowPlacement(const Widget* widget,
const std::string& window_name,
const gfx::Rect& bounds,
ui::WindowShowState show_state);
// Retrieves the saved position and size and "show" state for the window with
// the specified name.
virtual bool GetSavedWindowPlacement(const Widget* widget,
const std::string& window_name,
gfx::Rect* bounds,
ui::WindowShowState* show_state) const;
virtual void NotifyAccessibilityEvent(View* view, ui::AXEvent event_type);
// For accessibility, notify the delegate that a menu item was focused
// so that alternate feedback (speech / magnified text) can be provided.
virtual void NotifyMenuItemFocused(const base::string16& menu_name,
const base::string16& menu_item_name,
int item_index,
int item_count,
bool has_submenu);
// If |accelerator| can be processed while a menu is showing, it will be
// processed now and LEAVE_MENU_OPEN is returned. Otherwise, |accelerator|
// will be reposted for processing later after the menu closes and CLOSE_MENU
// will be returned.
virtual ProcessMenuAcceleratorResult ProcessAcceleratorWhileMenuShowing(
const ui::Accelerator& accelerator);
#if defined(OS_WIN)
// Retrieves the default window icon to use for windows if none is specified.
virtual HICON GetDefaultWindowIcon() const;
// Retrieves the small window icon to use for windows if none is specified.
virtual HICON GetSmallWindowIcon() const = 0;
// Returns true if the window passed in is in the Windows 8 metro
// environment.
virtual bool IsWindowInMetro(gfx::NativeWindow window) const;
#elif defined(OS_LINUX) && !defined(OS_CHROMEOS)
virtual gfx::ImageSkia* GetDefaultWindowIcon() const;
#endif
// Creates a default NonClientFrameView to be used for windows that don't
// specify their own. If this function returns NULL, the
// views::CustomFrameView type will be used.
virtual NonClientFrameView* CreateDefaultNonClientFrameView(Widget* widget);
// AddRef/ReleaseRef are invoked while a menu is visible. They are used to
// ensure we don't attempt to exit while a menu is showing.
virtual void AddRef();
virtual void ReleaseRef();
// Creates a web contents. This will return NULL unless overriden.
virtual content::WebContents* CreateWebContents(
content::BrowserContext* browser_context,
content::SiteInstance* site_instance);
// Gives the platform a chance to modify the properties of a Widget.
virtual void OnBeforeWidgetInit(Widget::InitParams* params,
internal::NativeWidgetDelegate* delegate) = 0;
// Returns the default obscured text reveal duration.
virtual base::TimeDelta GetDefaultTextfieldObscuredRevealDuration();
// Returns true if the operating system's window manager will always provide a
// title bar with caption buttons (ignoring the setting to
// |remove_standard_frame| in InitParams). If |maximized|, this applies to
// maximized windows; otherwise to restored windows.
virtual bool WindowManagerProvidesTitleBar(bool maximized);
// Returns the context factory for new windows.
virtual ui::ContextFactory* GetContextFactory();
// Returns the user-visible name of the application.
virtual std::string GetApplicationName();
#if defined(OS_WIN)
// Starts a query for the appbar autohide edges of the specified monitor and
// returns the current value. If the query finds the edges have changed from
// the current value, |callback| is subsequently invoked. If the edges have
// not changed, |callback| is never run.
//
// The return value is a bitmask of AppbarAutohideEdge.
virtual int GetAppbarAutohideEdges(HMONITOR monitor,
const base::Closure& callback);
#endif
// Returns a blocking pool task runner given a TaskRunnerType.
virtual scoped_refptr<base::TaskRunner> GetBlockingPoolTaskRunner();
protected:
ViewsDelegate();
private:
scoped_ptr<ViewsTouchEditingControllerFactory> views_tsc_factory_;
#if defined(USE_AURA)
scoped_ptr<TouchSelectionMenuRunnerViews> touch_selection_menu_runner_;
#endif
NativeWidgetFactory native_widget_factory_;
DISALLOW_COPY_AND_ASSIGN(ViewsDelegate);
};
} // namespace views
#endif // UI_VIEWS_VIEWS_DELEGATE_H_
|
