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
|
/*
* Copyright (C) 2009 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef WebWidgetClient_h
#define WebWidgetClient_h
#include "WebNavigationPolicy.h"
#include "public/platform/WebCommon.h"
#include "public/platform/WebLayerTreeView.h"
#include "public/platform/WebPoint.h"
#include "public/platform/WebRect.h"
#include "public/platform/WebScreenInfo.h"
#include "public/web/WebMeaningfulLayout.h"
#include "public/web/WebTouchAction.h"
namespace blink {
class WebGestureEvent;
class WebNode;
class WebString;
class WebWidget;
struct WebCursorInfo;
struct WebFloatPoint;
struct WebFloatRect;
struct WebFloatSize;
struct WebSize;
class WebWidgetClient {
public:
// Called when a region of the WebWidget needs to be re-painted.
virtual void didInvalidateRect(const WebRect&) { }
// Called when the Widget has changed size as a result of an auto-resize.
virtual void didAutoResize(const WebSize& newSize) { }
// Attempt to initialize compositing for this widget. If this is successful,
// layerTreeView() will return a valid WebLayerTreeView.
virtual void initializeLayerTreeView() { }
// Return a compositing view used for this widget. This is owned by the
// WebWidgetClient.
virtual WebLayerTreeView* layerTreeView() { return 0; }
// FIXME: Remove all overrides of this and change layerTreeView() above to ASSERT_NOT_REACHED.
virtual bool allowsBrokenNullLayerTreeView() const { return false; }
// Called when a call to WebWidget::animate is required
virtual void scheduleAnimation() { }
// Called immediately following the first compositor-driven (frame-generating) layout that
// happened after an interesting document lifecyle change (see WebMeaningfulLayout for details.)
virtual void didMeaningfulLayout(WebMeaningfulLayout) {}
virtual void didFirstLayoutAfterFinishedParsing() { }
// Called when the widget acquires or loses focus, respectively.
virtual void didFocus() { }
virtual void didBlur() { }
// Called when the cursor for the widget changes.
virtual void didChangeCursor(const WebCursorInfo&) { }
// Called when the widget should be closed. WebWidget::close() should
// be called asynchronously as a result of this notification.
virtual void closeWidgetSoon() { }
// Called to show the widget according to the given policy.
virtual void show(WebNavigationPolicy) { }
// Called to get/set the position of the widget in screen coordinates.
virtual WebRect windowRect() { return WebRect(); }
virtual void setWindowRect(const WebRect&) { }
// Called when a tooltip should be shown at the current cursor position.
virtual void setToolTipText(const WebString&, WebTextDirection hint) { }
// Called to get the position of the resizer rect in window coordinates.
virtual WebRect windowResizerRect() { return WebRect(); }
// Called to get the position of the root window containing the widget
// in screen coordinates.
virtual WebRect rootWindowRect() { return WebRect(); }
// Called to query information about the screen where this widget is
// displayed.
virtual WebScreenInfo screenInfo() { return WebScreenInfo(); }
// When this method gets called, WebWidgetClient implementation should
// reset the input method by cancelling any ongoing composition.
virtual void resetInputMethod() { }
// Requests to lock the mouse cursor. If true is returned, the success
// result will be asynchronously returned via a single call to
// WebWidget::didAcquirePointerLock() or
// WebWidget::didNotAcquirePointerLock().
// If false, the request has been denied synchronously.
virtual bool requestPointerLock() { return false; }
// Cause the pointer lock to be released. This may be called at any time,
// including when a lock is pending but not yet acquired.
// WebWidget::didLosePointerLock() is called when unlock is complete.
virtual void requestPointerUnlock() { }
// Returns true iff the pointer is locked to this widget.
virtual bool isPointerLocked() { return false; }
// Called when a gesture event is handled.
virtual void didHandleGestureEvent(const WebGestureEvent& event, bool eventCancelled) { }
// Called when overscrolled on main thread.
virtual void didOverscroll(const WebFloatSize& unusedDelta, const WebFloatSize& accumulatedRootOverScroll, const WebFloatPoint& position, const WebFloatSize& velocity) { }
// Called to update if touch events should be sent.
virtual void hasTouchEventHandlers(bool) { }
// Called during WebWidget::HandleInputEvent for a TouchStart event to inform the embedder
// of the touch actions that are permitted for this touch.
virtual void setTouchAction(WebTouchAction touchAction) { }
// Called when value of focused text field gets dirty, e.g. value is
// modified by script, not by user input.
virtual void didUpdateTextOfFocusedElementByNonUserInput() { }
// Request the browser to show the IME for current input type.
virtual void showImeIfNeeded() { }
// Request that the browser show a UI for an unhandled tap, if needed.
// Invoked during the handling of a GestureTap input event whenever the
// event is not consumed.
// |tappedPosition| is the point where the mouseDown occurred in client
// coordinates.
// |tappedNode| is the node that the mouseDown event hit, provided so the
// UI can be shown only on certain kinds of nodes in specific locations.
// |pageChanged| is true if and only if the DOM tree or style was
// modified during the dispatch of the mouse*, or click events associated
// with the tap.
// This provides a heuristic to help identify when a page is doing
// something as a result of a tap without explicitly consuming the event.
virtual void showUnhandledTapUIIfNeeded(const WebPoint& tappedPosition,
const WebNode& tappedNode, bool pageChanged) { }
// Called immediately after a mousedown event is dispatched due to a mouse
// press or gesture tap.
// Note: This is called even when the mouse down event is prevent default.
virtual void onMouseDown(const WebNode& mouseDownNode) { }
// Converts the |rect| from Blink's Viewport coordinates to the
// coordinates in the native window used to display the content, in
// DIP. They're identical in tradional world, but will differ when
// use-zoom-for-dsf feature is eanbled, and Viewport coordinates
// becomes DSF times larger than window coordinates.
// TODO(oshima): Update the comment when the migration is completed.
virtual void convertViewportToWindow(WebRect* rect) {}
// Converts the |rect| from the coordinates in native window in
// DIP to Blink's Viewport coordinates. They're identical in
// tradional world, but will differ when use-zoom-for-dsf feature
// is eanbled. TODO(oshima): Update the comment when the
// migration is completed.
virtual void convertWindowToViewport(WebFloatRect* rect) {}
protected:
~WebWidgetClient() { }
};
} // namespace blink
#endif
|
