3bec50d15979d3273d34d5e519de6c8cc11d84ca
[WebKit-https.git] / WebKit / chromium / src / WebViewImpl.h
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef WebViewImpl_h
32 #define WebViewImpl_h
33
34 // FIXME: Remove these relative paths once consumers from glue are removed.
35 #include "../public/WebNavigationPolicy.h"
36 #include "../public/WebPoint.h"
37 #include "../public/WebSize.h"
38 #include "../public/WebString.h"
39 #include "../public/WebView.h"
40
41 #include "BackForwardListClientImpl.h"
42 #include "ChromeClientImpl.h"
43 #include "ContextMenuClientImpl.h"
44 #include "DragClientImpl.h"
45 #include "EditorClientImpl.h"
46 #include "InspectorClientImpl.h"
47 #include "NotificationPresenterImpl.h"
48
49 #include <wtf/OwnPtr.h>
50 #include <wtf/RefCounted.h>
51
52 namespace WebCore {
53 class ChromiumDataObject;
54 class Frame;
55 class HistoryItem;
56 class HitTestResult;
57 class KeyboardEvent;
58 class Page;
59 class PlatformKeyboardEvent;
60 class PopupContainer;
61 class Range;
62 class RenderTheme;
63 class Widget;
64 }
65
66 namespace WebKit {
67 class AutocompletePopupMenuClient;
68 class ContextMenuClientImpl;
69 class WebAccessibilityObject;
70 class WebDevToolsAgentPrivate;
71 class WebFrameImpl;
72 class WebKeyboardEvent;
73 class WebMouseEvent;
74 class WebMouseWheelEvent;
75 class WebSettingsImpl;
76
77 class WebViewImpl : public WebView, public RefCounted<WebViewImpl> {
78 public:
79     // WebWidget methods:
80     virtual void close();
81     virtual WebSize size() { return m_size; }
82     virtual void resize(const WebSize&);
83     virtual void layout();
84     virtual void paint(WebCanvas*, const WebRect&);
85     virtual bool handleInputEvent(const WebInputEvent&);
86     virtual void mouseCaptureLost();
87     virtual void setFocus(bool enable);
88     virtual bool handleCompositionEvent(WebCompositionCommand command,
89                                         int cursorPosition,
90                                         int targetStart,
91                                         int targetEnd,
92                                         const WebString& text);
93     virtual bool queryCompositionStatus(bool* enabled,
94                                         WebRect* caretRect);
95     virtual void setTextDirection(WebTextDirection direction);
96
97     // WebView methods:
98     virtual void initializeMainFrame(WebFrameClient*);
99     virtual WebSettings* settings();
100     virtual WebString pageEncoding() const;
101     virtual void setPageEncoding(const WebString& encoding);
102     virtual bool isTransparent() const;
103     virtual void setIsTransparent(bool value);
104     virtual bool tabsToLinks() const;
105     virtual void setTabsToLinks(bool value);
106     virtual bool tabKeyCyclesThroughElements() const;
107     virtual void setTabKeyCyclesThroughElements(bool value);
108     virtual bool isActive() const;
109     virtual void setIsActive(bool value);
110     virtual bool dispatchBeforeUnloadEvent();
111     virtual void dispatchUnloadEvent();
112     virtual WebFrame* mainFrame();
113     virtual WebFrame* findFrameByName(
114         const WebString& name, WebFrame* relativeToFrame);
115     virtual WebFrame* focusedFrame();
116     virtual void setFocusedFrame(WebFrame* frame);
117     virtual void setInitialFocus(bool reverse);
118     virtual void clearFocusedNode();
119     virtual int zoomLevel();
120     virtual int setZoomLevel(bool textOnly, int zoomLevel);
121     virtual void performMediaPlayerAction(
122         const WebMediaPlayerAction& action,
123         const WebPoint& location);
124     virtual void copyImageAt(const WebPoint& point);
125     virtual void dragSourceEndedAt(
126         const WebPoint& clientPoint,
127         const WebPoint& screenPoint,
128         WebDragOperation operation);
129     virtual void dragSourceSystemDragEnded();
130     virtual WebDragOperation dragTargetDragEnter(
131         const WebDragData& dragData, int identity,
132         const WebPoint& clientPoint,
133         const WebPoint& screenPoint,
134         WebDragOperationsMask operationsAllowed);
135     virtual WebDragOperation dragTargetDragOver(
136         const WebPoint& clientPoint,
137         const WebPoint& screenPoint,
138         WebDragOperationsMask operationsAllowed);
139     virtual void dragTargetDragLeave();
140     virtual void dragTargetDrop(
141         const WebPoint& clientPoint,
142         const WebPoint& screenPoint);
143     virtual int dragIdentity();
144     virtual bool setDropEffect(bool accept);
145     virtual unsigned long createUniqueIdentifierForRequest();
146     virtual void inspectElementAt(const WebPoint& point);
147     virtual WebString inspectorSettings() const;
148     virtual void setInspectorSettings(const WebString& settings);
149     virtual WebDevToolsAgent* devToolsAgent();
150     virtual void setDevToolsAgent(WebDevToolsAgent*);
151     virtual WebAccessibilityObject accessibilityObject();
152     virtual void applyAutofillSuggestions(
153         const WebNode&,
154         const WebVector<WebString>& suggestions,
155         int defaultSuggestionIndex);
156     virtual void hideAutofillPopup();
157     virtual void setScrollbarColors(unsigned inactiveColor,
158                                     unsigned activeColor,
159                                     unsigned trackColor);
160
161     // WebViewImpl
162
163     void setIgnoreInputEvents(bool newValue);
164     WebDevToolsAgentPrivate* devToolsAgentPrivate() { return m_devToolsAgent.get(); }
165
166     const WebPoint& lastMouseDownPoint() const
167     {
168         return m_lastMouseDownPoint;
169     }
170
171     WebCore::Frame* focusedWebCoreFrame();
172
173     // Returns the currently focused Node or null if no node has focus.
174     WebCore::Node* focusedWebCoreNode();
175
176     static WebViewImpl* fromPage(WebCore::Page*);
177
178     WebViewClient* client()
179     {
180         return m_client;
181     }
182
183     // Returns the page object associated with this view.  This may be null when
184     // the page is shutting down, but will be valid at all other times.
185     WebCore::Page* page() const
186     {
187         return m_page.get();
188     }
189
190     WebCore::RenderTheme* theme() const;
191
192     // Returns the main frame associated with this view.  This may be null when
193     // the page is shutting down, but will be valid at all other times.
194     WebFrameImpl* mainFrameImpl();
195
196     // History related methods:
197     void setCurrentHistoryItem(WebCore::HistoryItem*);
198     WebCore::HistoryItem* previousHistoryItem();
199     void observeNewNavigation();
200
201     // Event related methods:
202     void mouseMove(const WebMouseEvent&);
203     void mouseLeave(const WebMouseEvent&);
204     void mouseDown(const WebMouseEvent&);
205     void mouseUp(const WebMouseEvent&);
206     void mouseContextMenu(const WebMouseEvent&);
207     void mouseDoubleClick(const WebMouseEvent&);
208     void mouseWheel(const WebMouseWheelEvent&);
209     bool keyEvent(const WebKeyboardEvent&);
210     bool charEvent(const WebKeyboardEvent&);
211
212     // Handles context menu events orignated via the the keyboard. These
213     // include the VK_APPS virtual key and the Shift+F10 combine.  Code is
214     // based on the Webkit function bool WebView::handleContextMenuEvent(WPARAM
215     // wParam, LPARAM lParam) in webkit\webkit\win\WebView.cpp. The only
216     // significant change in this function is the code to convert from a
217     // Keyboard event to the Right Mouse button down event.
218     bool sendContextMenuEvent(const WebKeyboardEvent&);
219
220     // Notifies the WebView that a load has been committed.  isNewNavigation
221     // will be true if a new session history item should be created for that
222     // load.
223     void didCommitLoad(bool* isNewNavigation);
224
225     bool contextMenuAllowed() const
226     {
227         return m_contextMenuAllowed;
228     }
229
230     // Set the disposition for how this webview is to be initially shown.
231     void setInitialNavigationPolicy(WebNavigationPolicy policy)
232     {
233         m_initialNavigationPolicy = policy;
234     }
235     WebNavigationPolicy initialNavigationPolicy() const
236     {
237         return m_initialNavigationPolicy;
238     }
239
240     // Determines whether a page should e.g. be opened in a background tab.
241     // Returns false if it has no opinion, in which case it doesn't set *policy.
242     static bool navigationPolicyFromMouseEvent(
243         unsigned short button,
244         bool ctrl,
245         bool shift,
246         bool alt,
247         bool meta,
248         WebNavigationPolicy*);
249
250     // Start a system drag and drop operation.
251     void startDragging(
252         const WebPoint& eventPos,
253         const WebDragData& dragData,
254         WebDragOperationsMask dragSourceOperationMask);
255
256     // Hides the autocomplete popup if it is showing.
257     void hideAutoCompletePopup();
258     void autoCompletePopupDidHide();
259
260 #if ENABLE(NOTIFICATIONS)
261     // Returns the provider of desktop notifications.
262     NotificationPresenterImpl* notificationPresenterImpl();
263 #endif
264
265     // Tries to scroll a frame or any parent of a frame. Returns true if the view
266     // was scrolled.
267     bool propagateScroll(WebCore::ScrollDirection, WebCore::ScrollGranularity);
268
269     // HACK: currentInputEvent() is for ChromeClientImpl::show(), until we can
270     // fix WebKit to pass enough information up into ChromeClient::show() so we
271     // can decide if the window.open event was caused by a middle-mouse click
272     static const WebInputEvent* currentInputEvent()
273     {
274         return m_currentInputEvent;
275     }
276
277 private:
278     friend class WebView;  // So WebView::Create can call our constructor
279     friend class WTF::RefCounted<WebViewImpl>;
280
281     WebViewImpl(WebViewClient* client);
282     ~WebViewImpl();
283
284     // Returns true if the event was actually processed.
285     bool keyEventDefault(const WebKeyboardEvent&);
286
287     // Returns true if the autocomple has consumed the event.
288     bool autocompleteHandleKeyEvent(const WebKeyboardEvent&);
289
290     // Repaints the autofill popup.  Should be called when the suggestions have
291     // changed.  Note that this should only be called when the autofill popup is
292     // showing.
293     void refreshAutofillPopup();
294
295     // Returns true if the view was scrolled.
296     bool scrollViewWithKeyboard(int keyCode, int modifiers);
297
298     // Converts |pos| from window coordinates to contents coordinates and gets
299     // the HitTestResult for it.
300     WebCore::HitTestResult hitTestResultForWindowPos(const WebCore::IntPoint&);
301
302     WebViewClient* m_client;
303
304     BackForwardListClientImpl m_backForwardListClientImpl;
305     ChromeClientImpl m_chromeClientImpl;
306     ContextMenuClientImpl m_contextMenuClientImpl;
307     DragClientImpl m_dragClientImpl;
308     EditorClientImpl m_editorClientImpl;
309     InspectorClientImpl m_inspectorClientImpl;
310
311     WebSize m_size;
312
313     WebPoint m_lastMousePosition;
314     OwnPtr<WebCore::Page> m_page;
315
316     // This flag is set when a new navigation is detected.  It is used to satisfy
317     // the corresponding argument to WebFrameClient::didCommitProvisionalLoad.
318     bool m_observedNewNavigation;
319 #ifndef NDEBUG
320     // Used to assert that the new navigation we observed is the same navigation
321     // when we make use of m_observedNewNavigation.
322     const WebCore::DocumentLoader* m_newNavigationLoader;
323 #endif
324
325     // An object that can be used to manipulate m_page->settings() without linking
326     // against WebCore.  This is lazily allocated the first time GetWebSettings()
327     // is called.
328     OwnPtr<WebSettingsImpl> m_webSettings;
329
330     // A copy of the web drop data object we received from the browser.
331     RefPtr<WebCore::ChromiumDataObject> m_currentDragData;
332
333     // The point relative to the client area where the mouse was last pressed
334     // down. This is used by the drag client to determine what was under the
335     // mouse when the drag was initiated. We need to track this here in
336     // WebViewImpl since DragClient::startDrag does not pass the position the
337     // mouse was at when the drag was initiated, only the current point, which
338     // can be misleading as it is usually not over the element the user actually
339     // dragged by the time a drag is initiated.
340     WebPoint m_lastMouseDownPoint;
341
342     // Keeps track of the current zoom level.  0 means no zoom, positive numbers
343     // mean zoom in, negative numbers mean zoom out.
344     int m_zoomLevel;
345
346     bool m_contextMenuAllowed;
347
348     bool m_doingDragAndDrop;
349
350     bool m_ignoreInputEvents;
351
352     // Webkit expects keyPress events to be suppressed if the associated keyDown
353     // event was handled. Safari implements this behavior by peeking out the
354     // associated WM_CHAR event if the keydown was handled. We emulate
355     // this behavior by setting this flag if the keyDown was handled.
356     bool m_suppressNextKeypressEvent;
357
358     // The policy for how this webview is to be initially shown.
359     WebNavigationPolicy m_initialNavigationPolicy;
360
361     // Represents whether or not this object should process incoming IME events.
362     bool m_imeAcceptEvents;
363
364     // True while dispatching system drag and drop events to drag/drop targets
365     // within this WebView.
366     bool m_dragTargetDispatch;
367
368     // Valid when m_dragTargetDispatch is true; the identity of the drag data
369     // copied from the WebDropData object sent from the browser process.
370     int m_dragIdentity;
371
372     // Valid when m_dragTargetDispatch is true.  Used to override the default
373     // browser drop effect with the effects "none" or "copy".
374     enum DragTargetDropEffect {
375         DropEffectDefault = -1,
376         DropEffectNone,
377         DropEffectCopy
378     } m_dropEffect;
379
380     // The available drag operations (copy, move link...) allowed by the source.
381     WebDragOperation m_operationsAllowed;
382
383     // The current drag operation as negotiated by the source and destination.
384     // When not equal to DragOperationNone, the drag data can be dropped onto the
385     // current drop target in this WebView (the drop target can accept the drop).
386     WebDragOperation m_dragOperation;
387
388     // The autocomplete popup.  Kept around and reused every-time new suggestions
389     // should be shown.
390     RefPtr<WebCore::PopupContainer> m_autocompletePopup;
391
392     // Whether the autocomplete popup is currently showing.
393     bool m_autocompletePopupShowing;
394
395     // The autocomplete client.
396     OwnPtr<AutocompletePopupMenuClient> m_autocompletePopupClient;
397
398     OwnPtr<WebDevToolsAgentPrivate> m_devToolsAgent;
399
400     // Whether the webview is rendering transparently.
401     bool m_isTransparent;
402
403     // Whether the user can press tab to focus links.
404     bool m_tabsToLinks;
405
406     // Inspector settings.
407     WebString m_inspectorSettings;
408
409 #if ENABLE(NOTIFICATIONS)
410     // The provider of desktop notifications;
411     NotificationPresenterImpl m_notificationPresenter;
412 #endif
413
414     static const WebInputEvent* m_currentInputEvent;
415 };
416
417 } // namespace WebKit
418
419 #endif