7fec10ae6dc908196592bc043672be25d72a671f
[WebKit-https.git] / WebKitTools / DumpRenderTree / win / EventSender.cpp
1 /*
2  * Copyright (C) 2007, 2008 Apple 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
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "DumpRenderTree.h"
30 #include "EventSender.h"
31
32 #include "DraggingInfo.h"
33
34 #include <WebCore/COMPtr.h>
35 #include <wtf/ASCIICType.h>
36 #include <wtf/Platform.h>
37 #include <JavaScriptCore/JavaScriptCore.h>
38 #include <JavaScriptCore/Assertions.h>
39 #include <WebKit/IWebFrame.h>
40 #include <WebKit/IWebFramePrivate.h>
41 #include <windows.h>
42
43 static bool down;
44 static bool dragMode = true;
45 static bool replayingSavedEvents;
46 static int timeOffset;
47 static POINT lastMousePosition;
48
49 static MSG msgQueue[1024];
50 static unsigned endOfQueue;
51 static unsigned startOfQueue;
52
53 static bool didDragEnter;
54 DraggingInfo* draggingInfo = 0;
55
56 static JSValueRef getDragModeCallback(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
57 {
58     return JSValueMakeBoolean(context, dragMode);
59 }
60
61 static bool setDragModeCallback(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
62 {
63     dragMode = JSValueToBoolean(context, value);
64     return true;
65 }
66
67 static JSValueRef getConstantCallback(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
68 {
69     if (JSStringIsEqualToUTF8CString(propertyName, "WM_KEYDOWN"))
70         return JSValueMakeNumber(context, WM_KEYDOWN);
71     if (JSStringIsEqualToUTF8CString(propertyName, "WM_KEYUP"))
72         return JSValueMakeNumber(context, WM_KEYUP);
73     if (JSStringIsEqualToUTF8CString(propertyName, "WM_CHAR"))
74         return JSValueMakeNumber(context, WM_CHAR);
75     if (JSStringIsEqualToUTF8CString(propertyName, "WM_DEADCHAR"))
76         return JSValueMakeNumber(context, WM_DEADCHAR);
77     if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSKEYDOWN"))
78         return JSValueMakeNumber(context, WM_SYSKEYDOWN);
79     if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSKEYUP"))
80         return JSValueMakeNumber(context, WM_SYSKEYUP);
81     if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSCHAR"))
82         return JSValueMakeNumber(context, WM_SYSCHAR);
83     if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSDEADCHAR"))
84         return JSValueMakeNumber(context, WM_SYSDEADCHAR);
85     ASSERT_NOT_REACHED();
86     return JSValueMakeUndefined(context);
87 }
88
89 static JSValueRef leapForwardCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
90 {
91     if (argumentCount > 0) {
92         timeOffset += JSValueToNumber(context, arguments[0], exception);
93         ASSERT(!exception || !*exception);
94     }
95
96     return JSValueMakeUndefined(context);
97 }
98
99 static DWORD currentEventTime()
100 {
101     return ::GetTickCount() + timeOffset;
102 }
103
104 static MSG makeMsg(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
105 {
106     MSG result = {0};
107     result.hwnd = hwnd;
108     result.message = message;
109     result.wParam = wParam;
110     result.lParam = lParam;
111     result.time = currentEventTime();
112     result.pt = lastMousePosition;
113
114     return result;
115 }
116
117 static LRESULT dispatchMessage(const MSG* msg)
118 {
119     ASSERT(msg);
120
121     ::TranslateMessage(msg);
122     return ::DispatchMessage(msg);
123 }
124
125 static JSValueRef contextClickCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
126 {
127     COMPtr<IWebFramePrivate> framePrivate;
128     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
129         framePrivate->layout();
130
131     down = true;
132     MSG msg = makeMsg(webViewWindow, WM_RBUTTONDOWN, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
133     dispatchMessage(&msg);
134     down = false;
135     msg = makeMsg(webViewWindow, WM_RBUTTONUP, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
136     dispatchMessage(&msg);
137     
138     return JSValueMakeUndefined(context);
139 }
140
141 static JSValueRef mouseDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
142 {
143     COMPtr<IWebFramePrivate> framePrivate;
144     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
145         framePrivate->layout();
146
147     down = true;
148     MSG msg = makeMsg(webViewWindow, WM_LBUTTONDOWN, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
149     dispatchMessage(&msg);
150
151     return JSValueMakeUndefined(context);
152 }
153
154 static inline POINTL pointl(const POINT& point)
155 {
156     POINTL result;
157     result.x = point.x;
158     result.y = point.y;
159     return result;
160 }
161
162 static void doMouseUp(MSG msg)
163 {
164     COMPtr<IWebFramePrivate> framePrivate;
165     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
166         framePrivate->layout();
167
168     dispatchMessage(&msg);
169     down = false;
170
171     if (draggingInfo) {
172         COMPtr<IWebView> webView;
173         COMPtr<IDropTarget> webViewDropTarget;
174         if (SUCCEEDED(frame->webView(&webView)) && SUCCEEDED(webView->QueryInterface(IID_IDropTarget, (void**)&webViewDropTarget))) {
175             POINT screenPoint = msg.pt;
176             ::ClientToScreen(webViewWindow, &screenPoint);
177             HRESULT hr = draggingInfo->dropSource()->QueryContinueDrag(0, 0);
178             DWORD effect = 0;
179             webViewDropTarget->DragOver(0, pointl(screenPoint), &effect);
180             if (hr == DRAGDROP_S_DROP && effect != DROPEFFECT_NONE) {
181                 DWORD effect = 0;
182                 webViewDropTarget->Drop(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);
183             } else
184                 webViewDropTarget->DragLeave();
185
186             delete draggingInfo;
187             draggingInfo = 0;
188         }
189     }
190 }
191
192 static JSValueRef mouseUpCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
193 {
194     MSG msg = makeMsg(webViewWindow, WM_LBUTTONUP, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
195
196     if (dragMode && !replayingSavedEvents) {
197         msgQueue[endOfQueue++] = msg;
198         replaySavedEvents();
199     } else
200         doMouseUp(msg);
201
202     return JSValueMakeUndefined(context);
203 }
204
205 static void doMouseMove(MSG msg)
206 {
207     COMPtr<IWebFramePrivate> framePrivate;
208     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
209         framePrivate->layout();
210
211     dispatchMessage(&msg);
212
213     if (down && draggingInfo) {
214         POINT screenPoint = msg.pt;
215         ::ClientToScreen(webViewWindow, &screenPoint);
216
217         IWebView* webView;
218         COMPtr<IDropTarget> webViewDropTarget;
219         if (SUCCEEDED(frame->webView(&webView)) && SUCCEEDED(webView->QueryInterface(IID_IDropTarget, (void**)&webViewDropTarget))) {
220             DWORD effect = 0;
221             if (didDragEnter)
222                 webViewDropTarget->DragOver(MK_LBUTTON, pointl(screenPoint), &effect);
223             else {
224                 webViewDropTarget->DragEnter(draggingInfo->dataObject(), MK_LBUTTON, pointl(screenPoint), &effect);
225                 didDragEnter = true;
226             }
227             draggingInfo->dropSource()->GiveFeedback(effect);
228             replaySavedEvents();
229         }
230     }
231 }
232
233 static JSValueRef mouseMoveToCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
234 {
235     if (argumentCount < 2)
236         return JSValueMakeUndefined(context);
237
238     lastMousePosition.x = (int)JSValueToNumber(context, arguments[0], exception);
239     ASSERT(!exception || !*exception);
240     lastMousePosition.y = (int)JSValueToNumber(context, arguments[1], exception);
241     ASSERT(!exception || !*exception);
242
243     MSG msg = makeMsg(webViewWindow, WM_MOUSEMOVE, down ? MK_LBUTTON : 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
244
245     if (dragMode && down && !replayingSavedEvents) {
246         msgQueue[endOfQueue++] = msg;
247         return JSValueMakeUndefined(context);
248     }
249
250     doMouseMove(msg);
251
252     return JSValueMakeUndefined(context);
253 }
254
255 void replaySavedEvents()
256 {
257     replayingSavedEvents = true;
258
259     MSG emptyMsg = {0};
260     while (startOfQueue < endOfQueue) {
261         MSG msg = msgQueue[startOfQueue++];
262         switch (msg.message) {
263             case WM_LBUTTONUP:
264                 doMouseUp(msg);
265                 break;
266             case WM_MOUSEMOVE:
267                 doMouseMove(msg);
268                 break;
269             default:
270                 // Not reached
271                 break;
272         }
273     }
274     startOfQueue = 0;
275     endOfQueue = 0;
276
277     replayingSavedEvents = false;
278 }
279
280 static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
281 {
282     if (argumentCount < 1)
283         return JSValueMakeUndefined(context);
284
285     static const JSStringRef lengthProperty = JSStringCreateWithUTF8CString("length");
286
287     COMPtr<IWebFramePrivate> framePrivate;
288     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
289         framePrivate->layout();
290     
291     JSStringRef character = JSValueToStringCopy(context, arguments[0], exception);
292     ASSERT(!*exception);
293     int virtualKeyCode;
294     int charCode = 0;
295     int keyData = 1;
296     bool needsShiftKeyModifier = false;
297     if (JSStringIsEqualToUTF8CString(character, "leftArrow")) {
298         virtualKeyCode = VK_LEFT;
299         keyData += KF_EXTENDED << 16; // In this case, extended means "not keypad".
300     } else if (JSStringIsEqualToUTF8CString(character, "rightArrow")) {
301         virtualKeyCode = VK_RIGHT;
302         keyData += KF_EXTENDED << 16;
303     } else if (JSStringIsEqualToUTF8CString(character, "upArrow")) {
304         virtualKeyCode = VK_UP;
305         keyData += KF_EXTENDED << 16;
306     } else if (JSStringIsEqualToUTF8CString(character, "downArrow")) {
307         virtualKeyCode = VK_DOWN;
308         keyData += KF_EXTENDED << 16;
309     } else if (JSStringIsEqualToUTF8CString(character, "pageUp"))
310         virtualKeyCode = VK_PRIOR;
311     else if (JSStringIsEqualToUTF8CString(character, "pageDown"))
312         virtualKeyCode = VK_NEXT;
313     else if (JSStringIsEqualToUTF8CString(character, "delete"))
314         virtualKeyCode = VK_BACK;
315     else {
316         charCode = JSStringGetCharactersPtr(character)[0];
317         virtualKeyCode = LOBYTE(VkKeyScan(charCode));
318         if (WTF::isASCIIUpper(charCode))
319             needsShiftKeyModifier = true;
320     }
321     JSStringRelease(character);
322
323     BYTE keyState[256];
324     if (argumentCount > 1 || needsShiftKeyModifier) {
325         ::GetKeyboardState(keyState);
326
327         BYTE newKeyState[256];
328         memcpy(newKeyState, keyState, sizeof(keyState));
329
330         if (needsShiftKeyModifier)
331             newKeyState[VK_SHIFT] = 0x80;
332
333         if (argumentCount > 1) {
334             JSObjectRef modifiersArray = JSValueToObject(context, arguments[1], exception);
335             if (modifiersArray) {
336                 int modifiersCount = JSValueToNumber(context, JSObjectGetProperty(context, modifiersArray, lengthProperty, 0), 0);
337                 for (int i = 0; i < modifiersCount; ++i) {
338                     JSValueRef value = JSObjectGetPropertyAtIndex(context, modifiersArray, i, 0);
339                     JSStringRef string = JSValueToStringCopy(context, value, 0);
340                     if (JSStringIsEqualToUTF8CString(string, "ctrlKey"))
341                         newKeyState[VK_CONTROL] = 0x80;
342                     else if (JSStringIsEqualToUTF8CString(string, "shiftKey"))
343                         newKeyState[VK_SHIFT] = 0x80;
344                     else if (JSStringIsEqualToUTF8CString(string, "altKey"))
345                         newKeyState[VK_MENU] = 0x80;
346                     else if (JSStringIsEqualToUTF8CString(string, "metaKey"))
347                         newKeyState[VK_MENU] = 0x80;
348
349                     JSStringRelease(string);
350                 }
351             }
352         }
353
354         ::SetKeyboardState(newKeyState);
355     }
356
357     MSG msg = makeMsg(webViewWindow, (::GetKeyState(VK_MENU) & 0x8000) ? WM_SYSKEYDOWN : WM_KEYDOWN, virtualKeyCode, keyData);
358     if (virtualKeyCode != 255)
359         dispatchMessage(&msg);
360     else {
361         // For characters that do not exist in the active keyboard layout,
362         // ::Translate will not work, so we post an WM_CHAR event ourselves.
363         ::PostMessage(webViewWindow, WM_CHAR, charCode, 0);
364     }
365
366     // Tests expect that all messages are processed by the time keyDown() returns.
367     if (::PeekMessage(&msg, webViewWindow, WM_CHAR, WM_CHAR, PM_REMOVE) || ::PeekMessage(&msg, webViewWindow, WM_SYSCHAR, WM_SYSCHAR, PM_REMOVE))
368         ::DispatchMessage(&msg);
369
370     MSG msgUp = makeMsg(webViewWindow, (::GetKeyState(VK_MENU) & 0x8000) ? WM_SYSKEYUP : WM_KEYUP, virtualKeyCode, keyData);
371     ::DispatchMessage(&msgUp);
372
373     if (argumentCount > 1 || needsShiftKeyModifier)
374         ::SetKeyboardState(keyState);
375
376     return JSValueMakeUndefined(context);
377 }
378
379 // eventSender.dispatchMessage(message, wParam, lParam, time = currentEventTime(), x = lastMousePosition.x, y = lastMousePosition.y)
380 static JSValueRef dispatchMessageCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
381 {
382     if (argumentCount < 3)
383         return JSValueMakeUndefined(context);
384
385     COMPtr<IWebFramePrivate> framePrivate;
386     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
387         framePrivate->layout();
388     
389     MSG msg = {};
390     msg.hwnd = webViewWindow;
391     msg.message = JSValueToNumber(context, arguments[0], exception);
392     ASSERT(!*exception);
393     msg.wParam = JSValueToNumber(context, arguments[1], exception);
394     ASSERT(!*exception);
395     msg.lParam = static_cast<ULONG_PTR>(JSValueToNumber(context, arguments[2], exception));
396     ASSERT(!*exception);
397     if (argumentCount >= 4) {
398         msg.time = JSValueToNumber(context, arguments[3], exception);
399         ASSERT(!*exception);
400     }
401     if (!msg.time)
402         msg.time = currentEventTime();
403     if (argumentCount >= 6) {
404         msg.pt.x = JSValueToNumber(context, arguments[4], exception);
405         ASSERT(!*exception);
406         msg.pt.y = JSValueToNumber(context, arguments[5], exception);
407         ASSERT(!*exception);
408     } else
409         msg.pt = lastMousePosition;
410
411     ::DispatchMessage(&msg);
412
413     return JSValueMakeUndefined(context);
414 }
415
416 static JSValueRef textZoomInCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
417 {
418     COMPtr<IWebView> webView;
419     if (FAILED(frame->webView(&webView)))
420         return JSValueMakeUndefined(context);
421
422     COMPtr<IWebIBActions> webIBActions;
423     if (FAILED(webView->QueryInterface(IID_IWebIBActions, (void**)&webIBActions)))
424         return JSValueMakeUndefined(context);
425
426     webIBActions->makeTextLarger(0);
427     return JSValueMakeUndefined(context);
428 }
429
430 static JSValueRef textZoomOutCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
431 {
432     COMPtr<IWebView> webView;
433     if (FAILED(frame->webView(&webView)))
434         return JSValueMakeUndefined(context);
435
436     COMPtr<IWebIBActions> webIBActions;
437     if (FAILED(webView->QueryInterface(IID_IWebIBActions, (void**)&webIBActions)))
438         return JSValueMakeUndefined(context);
439
440     webIBActions->makeTextSmaller(0);
441     return JSValueMakeUndefined(context);
442 }
443
444 static JSStaticFunction staticFunctions[] = {
445     { "contextClick", contextClickCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
446     { "mouseDown", mouseDownCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
447     { "mouseUp", mouseUpCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
448     { "mouseMoveTo", mouseMoveToCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
449     { "leapForward", leapForwardCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
450     { "keyDown", keyDownCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
451     { "dispatchMessage", dispatchMessageCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
452     { "textZoomIn", textZoomInCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
453     { "textZoomOut", textZoomOutCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
454     { 0, 0, 0 }
455 };
456
457 static JSStaticValue staticValues[] = {
458     { "dragMode", getDragModeCallback, setDragModeCallback, kJSPropertyAttributeNone },
459     { "WM_KEYDOWN", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
460     { "WM_KEYUP", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
461     { "WM_CHAR", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
462     { "WM_DEADCHAR", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
463     { "WM_SYSKEYDOWN", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
464     { "WM_SYSKEYUP", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
465     { "WM_SYSCHAR", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
466     { "WM_SYSDEADCHAR", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
467     { 0, 0, 0, 0 }
468 };
469
470 static JSClassRef getClass(JSContextRef context)
471 {
472     static JSClassRef eventSenderClass = 0;
473
474     if (!eventSenderClass) {
475         JSClassDefinition classDefinition = {0};
476         classDefinition.staticFunctions = staticFunctions;
477         classDefinition.staticValues = staticValues;
478
479         eventSenderClass = JSClassCreate(&classDefinition);
480     }
481
482     return eventSenderClass;
483 }
484
485 JSObjectRef makeEventSender(JSContextRef context)
486 {
487     return JSObjectMake(context, getClass(context), 0);
488 }