https://bugs.webkit.org/show_bug.cgi?id=66133
[WebKit-https.git] / Source / WebKit / chromium / src / WebInputEventConversion.cpp
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 #include "config.h"
32 #include "WebInputEventConversion.h"
33
34 #include "EventNames.h"
35 #include "KeyboardCodes.h"
36 #include "KeyboardEvent.h"
37 #include "MouseEvent.h"
38 #include "PlatformKeyboardEvent.h"
39 #include "PlatformMouseEvent.h"
40 #include "PlatformWheelEvent.h"
41 #include "ScrollView.h"
42 #include "WebInputEvent.h"
43 #include "WheelEvent.h"
44 #include "Widget.h"
45
46 using namespace WebCore;
47
48 namespace WebKit {
49
50 // MakePlatformMouseEvent -----------------------------------------------------
51
52 PlatformMouseEventBuilder::PlatformMouseEventBuilder(Widget* widget, const WebMouseEvent& e)
53 {
54     // FIXME: widget is always toplevel, unless it's a popup.  We may be able
55     // to get rid of this once we abstract popups into a WebKit API.
56     m_position = widget->convertFromContainingWindow(IntPoint(e.x, e.y));
57     m_globalPosition = IntPoint(e.globalX, e.globalY);
58     m_button = static_cast<MouseButton>(e.button);
59     m_shiftKey = (e.modifiers & WebInputEvent::ShiftKey);
60     m_ctrlKey = (e.modifiers & WebInputEvent::ControlKey);
61     m_altKey = (e.modifiers & WebInputEvent::AltKey);
62     m_metaKey = (e.modifiers & WebInputEvent::MetaKey);
63     m_modifierFlags = e.modifiers;
64     m_timestamp = e.timeStampSeconds;
65     m_clickCount = e.clickCount;
66
67     switch (e.type) {
68     case WebInputEvent::MouseMove:
69     case WebInputEvent::MouseLeave:  // synthesize a move event
70         m_eventType = MouseEventMoved;
71         break;
72
73     case WebInputEvent::MouseDown:
74         m_eventType = MouseEventPressed;
75         break;
76
77     case WebInputEvent::MouseUp:
78         m_eventType = MouseEventReleased;
79         break;
80
81     default:
82         ASSERT_NOT_REACHED();
83     }
84 }
85
86 // PlatformWheelEventBuilder --------------------------------------------------
87
88 PlatformWheelEventBuilder::PlatformWheelEventBuilder(Widget* widget, const WebMouseWheelEvent& e)
89 {
90     m_position = widget->convertFromContainingWindow(IntPoint(e.x, e.y));
91     m_globalPosition = IntPoint(e.globalX, e.globalY);
92     m_deltaX = e.deltaX;
93     m_deltaY = e.deltaY;
94     m_wheelTicksX = e.wheelTicksX;
95     m_wheelTicksY = e.wheelTicksY;
96     m_isAccepted = false;
97     m_granularity = e.scrollByPage ?
98         ScrollByPageWheelEvent : ScrollByPixelWheelEvent;
99     m_shiftKey = (e.modifiers & WebInputEvent::ShiftKey);
100     m_ctrlKey = (e.modifiers & WebInputEvent::ControlKey);
101     m_altKey = (e.modifiers & WebInputEvent::AltKey);
102     m_metaKey = (e.modifiers & WebInputEvent::MetaKey);
103 #if OS(DARWIN)
104     m_hasPreciseScrollingDeltas = e.hasPreciseScrollingDeltas;
105     m_phase = static_cast<WebCore::PlatformWheelEventPhase>(e.phase);
106     m_momentumPhase = static_cast<WebCore::PlatformWheelEventPhase>(e.momentumPhase);
107     m_timestamp = e.timeStampSeconds;
108 #endif
109 }
110
111 // PlatformGestureEventBuilder --------------------------------------------------
112
113 #if ENABLE(GESTURE_EVENTS)
114 PlatformGestureEventBuilder::PlatformGestureEventBuilder(Widget* widget, const WebGestureEvent& e)
115 {
116     switch (e.type) {
117     case WebInputEvent::GestureScrollBegin:
118         m_type = PlatformGestureEvent::ScrollBeginType;
119         break;
120     case WebInputEvent::GestureScrollEnd:
121         m_type = PlatformGestureEvent::ScrollEndType;
122         break;
123     default:
124         ASSERT_NOT_REACHED();
125     }
126     m_position = widget->convertFromContainingWindow(IntPoint(e.x, e.y));
127     m_globalPosition = IntPoint(e.globalX, e.globalY);
128     m_timestamp = e.timeStampSeconds;
129     m_shiftKey = (e.modifiers & WebInputEvent::ShiftKey);
130     m_ctrlKey = (e.modifiers & WebInputEvent::ControlKey);
131     m_altKey = (e.modifiers & WebInputEvent::AltKey);
132     m_metaKey = (e.modifiers & WebInputEvent::MetaKey);
133 }
134 #endif
135
136 // MakePlatformKeyboardEvent --------------------------------------------------
137
138 static inline PlatformKeyboardEvent::Type toPlatformKeyboardEventType(WebInputEvent::Type type)
139 {
140     switch (type) {
141     case WebInputEvent::KeyUp:
142         return PlatformKeyboardEvent::KeyUp;
143     case WebInputEvent::KeyDown:
144         return PlatformKeyboardEvent::KeyDown;
145     case WebInputEvent::RawKeyDown:
146         return PlatformKeyboardEvent::RawKeyDown;
147     case WebInputEvent::Char:
148         return PlatformKeyboardEvent::Char;
149     default:
150         ASSERT_NOT_REACHED();
151     }
152     return PlatformKeyboardEvent::KeyDown;
153 }
154
155 PlatformKeyboardEventBuilder::PlatformKeyboardEventBuilder(const WebKeyboardEvent& e)
156 {
157     m_type = toPlatformKeyboardEventType(e.type);
158     m_text = String(e.text);
159     m_unmodifiedText = String(e.unmodifiedText);
160     m_keyIdentifier = String(e.keyIdentifier);
161     m_autoRepeat = (e.modifiers & WebInputEvent::IsAutoRepeat);
162     m_windowsVirtualKeyCode = e.windowsKeyCode;
163     m_nativeVirtualKeyCode = e.nativeKeyCode;
164     m_isKeypad = (e.modifiers & WebInputEvent::IsKeyPad);
165     m_shiftKey = (e.modifiers & WebInputEvent::ShiftKey);
166     m_ctrlKey = (e.modifiers & WebInputEvent::ControlKey);
167     m_altKey = (e.modifiers & WebInputEvent::AltKey);
168     m_metaKey = (e.modifiers & WebInputEvent::MetaKey);
169     m_isSystemKey = e.isSystemKey;
170 }
171
172 void PlatformKeyboardEventBuilder::setKeyType(Type type)
173 {
174     // According to the behavior of Webkit in Windows platform,
175     // we need to convert KeyDown to RawKeydown and Char events
176     // See WebKit/WebKit/Win/WebView.cpp
177     ASSERT(m_type == KeyDown);
178     ASSERT(type == RawKeyDown || type == Char);
179     m_type = type;
180
181     if (type == RawKeyDown) {
182         m_text = String();
183         m_unmodifiedText = String();
184     } else {
185         m_keyIdentifier = String();
186         m_windowsVirtualKeyCode = 0;
187     }
188 }
189
190 // Please refer to bug http://b/issue?id=961192, which talks about Webkit
191 // keyboard event handling changes. It also mentions the list of keys
192 // which don't have associated character events.
193 bool PlatformKeyboardEventBuilder::isCharacterKey() const
194 {
195     switch (windowsVirtualKeyCode()) {
196     case VKEY_BACK:
197     case VKEY_ESCAPE:
198         return false;
199     }
200     return true;
201 }
202
203 #if ENABLE(TOUCH_EVENTS)
204 static inline TouchEventType toPlatformTouchEventType(const WebInputEvent::Type type)
205 {
206     switch (type) {
207     case WebInputEvent::TouchStart:
208         return TouchStart;
209     case WebInputEvent::TouchMove:
210         return TouchMove;
211     case WebInputEvent::TouchEnd:
212         return TouchEnd;
213     case WebInputEvent::TouchCancel:
214         return TouchCancel;
215     default:
216         ASSERT_NOT_REACHED();
217     }
218     return TouchStart;
219 }
220
221 static inline PlatformTouchPoint::State toPlatformTouchPointState(const WebTouchPoint::State state)
222 {
223     switch (state) {
224     case WebTouchPoint::StateReleased:
225         return PlatformTouchPoint::TouchReleased;
226     case WebTouchPoint::StatePressed:
227         return PlatformTouchPoint::TouchPressed;
228     case WebTouchPoint::StateMoved:
229         return PlatformTouchPoint::TouchMoved;
230     case WebTouchPoint::StateStationary:
231         return PlatformTouchPoint::TouchStationary;
232     case WebTouchPoint::StateCancelled:
233         return PlatformTouchPoint::TouchCancelled;
234     case WebTouchPoint::StateUndefined:
235         ASSERT_NOT_REACHED();
236     }
237     return PlatformTouchPoint::TouchReleased;
238 }
239
240 PlatformTouchPointBuilder::PlatformTouchPointBuilder(Widget* widget, const WebTouchPoint& point)
241 {
242     m_id = point.id;
243     m_state = toPlatformTouchPointState(point.state);
244     m_pos = widget->convertFromContainingWindow(point.position);
245     m_screenPos = point.screenPosition;
246     m_radiusY = point.radiusY;
247     m_radiusX = point.radiusX;
248     m_rotationAngle = point.rotationAngle;
249     m_force = point.force;
250 }
251
252 PlatformTouchEventBuilder::PlatformTouchEventBuilder(Widget* widget, const WebTouchEvent& event)
253 {
254     m_type = toPlatformTouchEventType(event.type);
255     m_ctrlKey = event.modifiers & WebInputEvent::ControlKey;
256     m_altKey = event.modifiers & WebInputEvent::AltKey;
257     m_shiftKey = event.modifiers & WebInputEvent::ShiftKey;
258     m_metaKey = event.modifiers & WebInputEvent::MetaKey;
259     m_timestamp = event.timeStampSeconds;
260
261     for (int i = 0; i < event.touchPointsLength; ++i)
262         m_touchPoints.append(PlatformTouchPointBuilder(widget, event.touchPoints[i]));
263 }
264 #endif
265
266 static int getWebInputModifiers(const UIEventWithKeyState& event)
267 {
268     int modifiers = 0;
269     if (event.ctrlKey())
270         modifiers |= WebInputEvent::ControlKey;
271     if (event.shiftKey())
272         modifiers |= WebInputEvent::ShiftKey;
273     if (event.altKey())
274         modifiers |= WebInputEvent::AltKey;
275     if (event.metaKey())
276         modifiers |= WebInputEvent::MetaKey;
277     return modifiers;
278 }
279
280 WebMouseEventBuilder::WebMouseEventBuilder(const Widget* widget, const MouseEvent& event)
281 {
282     if (event.type() == eventNames().mousemoveEvent)
283         type = WebInputEvent::MouseMove;
284     else if (event.type() == eventNames().mouseoutEvent)
285         type = WebInputEvent::MouseLeave;
286     else if (event.type() == eventNames().mouseoverEvent)
287         type = WebInputEvent::MouseEnter;
288     else if (event.type() == eventNames().mousedownEvent)
289         type = WebInputEvent::MouseDown;
290     else if (event.type() == eventNames().mouseupEvent)
291         type = WebInputEvent::MouseUp;
292     else if (event.type() == eventNames().contextmenuEvent)
293         type = WebInputEvent::ContextMenu;
294     else
295         return; // Skip all other mouse events.
296     timeStampSeconds = event.timeStamp() * 1.0e-3;
297     switch (event.button()) {
298     case LeftButton:
299         button = WebMouseEvent::ButtonLeft;
300         break;
301     case MiddleButton:
302         button = WebMouseEvent::ButtonMiddle;
303         break;
304     case RightButton:
305         button = WebMouseEvent::ButtonRight;
306         break;
307     }
308     modifiers = getWebInputModifiers(event);
309     if (event.buttonDown()) {
310         switch (event.button()) {
311         case LeftButton:
312             modifiers |= WebInputEvent::LeftButtonDown;
313             break;
314         case MiddleButton:
315             modifiers |= WebInputEvent::MiddleButtonDown;
316             break;
317         case RightButton:
318             modifiers |= WebInputEvent::RightButtonDown;
319             break;
320         }
321     }
322     ScrollView* view = widget->parent();
323     IntPoint p = view->contentsToWindow(
324         IntPoint(event.absoluteLocation().x(), event.absoluteLocation().y()));
325     globalX = event.screenX();
326     globalY = event.screenY();
327     windowX = p.x();
328     windowY = p.y();
329     x = event.absoluteLocation().x() - widget->location().x();
330     y = event.absoluteLocation().y() - widget->location().y();
331     clickCount = event.detail();
332 }
333
334 WebMouseWheelEventBuilder::WebMouseWheelEventBuilder(const Widget* widget, const WheelEvent& event)
335 {
336     if (event.type() != eventNames().mousewheelEvent)
337         return;
338     type = WebInputEvent::MouseWheel;
339     timeStampSeconds = event.timeStamp() * 1.0e-3;
340     modifiers = getWebInputModifiers(event);
341     ScrollView* view = widget->parent();
342     IntPoint p = view->contentsToWindow(
343         IntPoint(event.absoluteLocation().x(), event.absoluteLocation().y()));
344     globalX = event.screenX();
345     globalY = event.screenY();
346     windowX = p.x();
347     windowY = p.y();
348     x = event.absoluteLocation().x() - widget->location().x();
349     y = event.absoluteLocation().y() - widget->location().y();
350     deltaX = static_cast<float>(event.rawDeltaX());
351     deltaY = static_cast<float>(event.rawDeltaY());
352     // The 120 is from WheelEvent::initWheelEvent().
353     wheelTicksX = static_cast<float>(event.wheelDeltaX()) / 120;
354     wheelTicksY = static_cast<float>(event.wheelDeltaY()) / 120;
355     scrollByPage = event.granularity() == WheelEvent::Page;
356 }
357
358 WebKeyboardEventBuilder::WebKeyboardEventBuilder(const KeyboardEvent& event)
359 {
360     if (event.type() == eventNames().keydownEvent)
361         type = KeyDown;
362     else if (event.type() == eventNames().keyupEvent)
363         type = WebInputEvent::KeyUp;
364     else if (event.type() == eventNames().keypressEvent)
365         type = WebInputEvent::Char;
366     else
367         return; // Skip all other keyboard events.
368     modifiers = getWebInputModifiers(event);
369     timeStampSeconds = event.timeStamp() * 1.0e-3;
370     windowsKeyCode = event.keyCode();
371
372     // The platform keyevent does not exist if the event was created using
373     // initKeyboardEvent.
374     if (!event.keyEvent())
375         return;
376     nativeKeyCode = event.keyEvent()->nativeVirtualKeyCode();
377     unsigned int numChars = std::min(event.keyEvent()->text().length(),
378         static_cast<unsigned int>(WebKeyboardEvent::textLengthCap));
379     for (unsigned int i = 0; i < numChars; i++) {
380         text[i] = event.keyEvent()->text()[i];
381         unmodifiedText[i] = event.keyEvent()->unmodifiedText()[i];
382     }
383 }
384
385 } // namespace WebKit