Rename WebKitTools to Tools
[WebKit-https.git] / Tools / 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 "config.h"
30 #include "EventSender.h"
31
32 #include "DraggingInfo.h"
33 #include "DumpRenderTree.h"
34
35 #include <WebCore/COMPtr.h>
36 #include <wtf/ASCIICType.h>
37 #include <wtf/Platform.h>
38 #include <JavaScriptCore/JavaScriptCore.h>
39 #include <JavaScriptCore/Assertions.h>
40 #include <WebKit/WebKit.h>
41 #include <windows.h>
42
43 #define WM_DRT_SEND_QUEUED_EVENT (WM_APP+1)
44
45 static bool down;
46 static bool dragMode = true;
47 static bool replayingSavedEvents;
48 static int timeOffset;
49 static POINT lastMousePosition;
50
51 struct DelayedMessage {
52     MSG msg;
53     unsigned delay;
54 };
55
56 static DelayedMessage msgQueue[1024];
57 static unsigned endOfQueue;
58 static unsigned startOfQueue;
59
60 static bool didDragEnter;
61 DraggingInfo* draggingInfo = 0;
62
63 static JSValueRef getDragModeCallback(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
64 {
65     return JSValueMakeBoolean(context, dragMode);
66 }
67
68 static bool setDragModeCallback(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
69 {
70     dragMode = JSValueToBoolean(context, value);
71     return true;
72 }
73
74 static JSValueRef getConstantCallback(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception)
75 {
76     if (JSStringIsEqualToUTF8CString(propertyName, "WM_KEYDOWN"))
77         return JSValueMakeNumber(context, WM_KEYDOWN);
78     if (JSStringIsEqualToUTF8CString(propertyName, "WM_KEYUP"))
79         return JSValueMakeNumber(context, WM_KEYUP);
80     if (JSStringIsEqualToUTF8CString(propertyName, "WM_CHAR"))
81         return JSValueMakeNumber(context, WM_CHAR);
82     if (JSStringIsEqualToUTF8CString(propertyName, "WM_DEADCHAR"))
83         return JSValueMakeNumber(context, WM_DEADCHAR);
84     if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSKEYDOWN"))
85         return JSValueMakeNumber(context, WM_SYSKEYDOWN);
86     if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSKEYUP"))
87         return JSValueMakeNumber(context, WM_SYSKEYUP);
88     if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSCHAR"))
89         return JSValueMakeNumber(context, WM_SYSCHAR);
90     if (JSStringIsEqualToUTF8CString(propertyName, "WM_SYSDEADCHAR"))
91         return JSValueMakeNumber(context, WM_SYSDEADCHAR);
92     ASSERT_NOT_REACHED();
93     return JSValueMakeUndefined(context);
94 }
95
96 static JSValueRef leapForwardCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
97 {
98     if (argumentCount > 0) {
99         msgQueue[endOfQueue].delay = JSValueToNumber(context, arguments[0], exception);
100         ASSERT(!exception || !*exception);
101     }
102
103     return JSValueMakeUndefined(context);
104 }
105
106 static DWORD currentEventTime()
107 {
108     return ::GetTickCount() + timeOffset;
109 }
110
111 static MSG makeMsg(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
112 {
113     MSG result = {0};
114     result.hwnd = hwnd;
115     result.message = message;
116     result.wParam = wParam;
117     result.lParam = lParam;
118     result.time = currentEventTime();
119     result.pt = lastMousePosition;
120
121     return result;
122 }
123
124 static LRESULT dispatchMessage(const MSG* msg)
125 {
126     ASSERT(msg);
127     ::TranslateMessage(msg);
128     return ::DispatchMessage(msg);
129 }
130
131 static JSValueRef contextClickCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
132 {
133     COMPtr<IWebFramePrivate> framePrivate;
134     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
135         framePrivate->layout();
136
137     down = true;
138     MSG msg = makeMsg(webViewWindow, WM_RBUTTONDOWN, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
139     dispatchMessage(&msg);
140     down = false;
141     msg = makeMsg(webViewWindow, WM_RBUTTONUP, 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
142     dispatchMessage(&msg);
143     
144     return JSValueMakeUndefined(context);
145 }
146
147 static WPARAM buildModifierFlags(JSContextRef context, const JSValueRef modifiers)
148 {
149     JSObjectRef modifiersArray = JSValueToObject(context, modifiers, 0);
150     if (!modifiersArray)
151         return 0;
152
153     WPARAM flags = 0;
154     int modifiersCount = JSValueToNumber(context, JSObjectGetProperty(context, modifiersArray, JSStringCreateWithUTF8CString("length"), 0), 0);
155     for (int i = 0; i < modifiersCount; ++i) {
156         JSValueRef value = JSObjectGetPropertyAtIndex(context, modifiersArray, i, 0);
157         JSStringRef string = JSValueToStringCopy(context, value, 0);
158         if (JSStringIsEqualToUTF8CString(string, "ctrlKey")
159             || JSStringIsEqualToUTF8CString(string, "addSelectionKey"))
160             flags |= MK_CONTROL;
161         else if (JSStringIsEqualToUTF8CString(string, "shiftKey")
162                  || JSStringIsEqualToUTF8CString(string, "rangeSelectionKey"))
163             flags |= MK_SHIFT;
164         // No way to specifiy altKey in a MSG.
165
166         JSStringRelease(string);
167     }
168     return flags;
169 }
170
171 static JSValueRef mouseDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
172 {
173     COMPtr<IWebFramePrivate> framePrivate;
174     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
175         framePrivate->layout();
176
177     down = true;
178     int mouseType = WM_LBUTTONDOWN;
179     if (argumentCount >= 1) {
180         int mouseNumber = JSValueToNumber(context, arguments[0], exception);
181         switch (mouseNumber) {
182         case 0:
183             mouseType = WM_LBUTTONDOWN;
184             break;
185         case 1:
186             mouseType = WM_MBUTTONDOWN;
187             break;
188         case 2:
189             mouseType = WM_RBUTTONDOWN;
190             break;
191         case 3:
192             // fast/events/mouse-click-events expects the 4th button has event.button = 1, so send an WM_BUTTONDOWN
193             mouseType = WM_MBUTTONDOWN;
194             break;
195         default:
196             mouseType = WM_LBUTTONDOWN;
197             break;
198         }
199     }
200
201     WPARAM wparam = 0;
202     if (argumentCount >= 2)
203         wparam |= buildModifierFlags(context, arguments[1]);
204         
205     MSG msg = makeMsg(webViewWindow, mouseType, wparam, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
206     if (!msgQueue[endOfQueue].delay)
207         dispatchMessage(&msg);
208     else {
209         // replaySavedEvents has the required logic to make leapForward delays work
210         msgQueue[endOfQueue++].msg = msg;
211         replaySavedEvents();
212     }
213
214     return JSValueMakeUndefined(context);
215 }
216
217 static inline POINTL pointl(const POINT& point)
218 {
219     POINTL result;
220     result.x = point.x;
221     result.y = point.y;
222     return result;
223 }
224
225 static void doMouseUp(MSG msg, HRESULT* oleDragAndDropReturnValue = 0)
226 {
227     COMPtr<IWebFramePrivate> framePrivate;
228     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
229         framePrivate->layout();
230
231     dispatchMessage(&msg);
232     down = false;
233
234     if (draggingInfo) {
235         COMPtr<IWebView> webView;
236         COMPtr<IDropTarget> webViewDropTarget;
237         if (SUCCEEDED(frame->webView(&webView)) && SUCCEEDED(webView->QueryInterface(IID_IDropTarget, (void**)&webViewDropTarget))) {
238             POINT screenPoint = msg.pt;
239             DWORD effect = 0;
240             ::ClientToScreen(webViewWindow, &screenPoint);
241             if (!didDragEnter) {
242                 webViewDropTarget->DragEnter(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);
243                 didDragEnter = true;
244             }
245             HRESULT hr = draggingInfo->dropSource()->QueryContinueDrag(0, 0);
246             if (oleDragAndDropReturnValue)
247                 *oleDragAndDropReturnValue = hr;
248             webViewDropTarget->DragOver(0, pointl(screenPoint), &effect);
249             if (hr == DRAGDROP_S_DROP && effect != DROPEFFECT_NONE) {
250                 DWORD effect = 0;
251                 webViewDropTarget->Drop(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);
252                 draggingInfo->setPerformedDropEffect(effect);
253             } else
254                 webViewDropTarget->DragLeave();
255
256             // Reset didDragEnter so that another drag started within the same frame works properly.
257             didDragEnter = false;
258         }
259     }
260 }
261
262 static JSValueRef mouseUpCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
263 {
264     int mouseType = WM_LBUTTONUP;
265     if (argumentCount >= 1) {
266         int mouseNumber = JSValueToNumber(context, arguments[0], exception);
267         switch (mouseNumber) {
268         case 0:
269             mouseType = WM_LBUTTONUP;
270             break;
271         case 1:
272             mouseType = WM_MBUTTONUP;
273             break;
274         case 2:
275             mouseType = WM_RBUTTONUP;
276             break;
277         case 3:
278             // fast/events/mouse-click-events expects the 4th button has event.button = 1, so send an WM_MBUTTONUP
279             mouseType = WM_MBUTTONUP;
280             break;
281         default:
282             mouseType = WM_LBUTTONUP;
283             break;
284         }
285     }
286
287     WPARAM wparam = 0;
288     if (argumentCount >= 2)
289         wparam |= buildModifierFlags(context, arguments[1]);
290
291     MSG msg = makeMsg(webViewWindow, mouseType, wparam, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
292
293     if ((dragMode && !replayingSavedEvents) || msgQueue[endOfQueue].delay) {
294         msgQueue[endOfQueue++].msg = msg;
295         replaySavedEvents();
296     } else
297         doMouseUp(msg);
298
299     return JSValueMakeUndefined(context);
300 }
301
302 static void doMouseMove(MSG msg)
303 {
304     COMPtr<IWebFramePrivate> framePrivate;
305     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
306         framePrivate->layout();
307
308     dispatchMessage(&msg);
309
310     if (down && draggingInfo) {
311         POINT screenPoint = msg.pt;
312         ::ClientToScreen(webViewWindow, &screenPoint);
313
314         IWebView* webView;
315         COMPtr<IDropTarget> webViewDropTarget;
316         if (SUCCEEDED(frame->webView(&webView)) && SUCCEEDED(webView->QueryInterface(IID_IDropTarget, (void**)&webViewDropTarget))) {
317             DWORD effect = 0;
318             if (didDragEnter)
319                 webViewDropTarget->DragOver(MK_LBUTTON, pointl(screenPoint), &effect);
320             else {
321                 webViewDropTarget->DragEnter(draggingInfo->dataObject(), 0, pointl(screenPoint), &effect);
322                 didDragEnter = true;
323             }
324             draggingInfo->dropSource()->GiveFeedback(effect);
325         }
326     }
327 }
328
329 static JSValueRef mouseMoveToCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
330 {
331     if (argumentCount < 2)
332         return JSValueMakeUndefined(context);
333
334     lastMousePosition.x = (int)JSValueToNumber(context, arguments[0], exception);
335     ASSERT(!exception || !*exception);
336     lastMousePosition.y = (int)JSValueToNumber(context, arguments[1], exception);
337     ASSERT(!exception || !*exception);
338
339     MSG msg = makeMsg(webViewWindow, WM_MOUSEMOVE, down ? MK_LBUTTON : 0, MAKELPARAM(lastMousePosition.x, lastMousePosition.y));
340
341     if (dragMode && down && !replayingSavedEvents) {
342         msgQueue[endOfQueue++].msg = msg;
343         return JSValueMakeUndefined(context);
344     }
345
346     doMouseMove(msg);
347
348     return JSValueMakeUndefined(context);
349 }
350
351 void replaySavedEvents(HRESULT* oleDragAndDropReturnValue)
352 {
353     replayingSavedEvents = true;
354   
355     MSG msg = { 0 };
356
357     while (startOfQueue < endOfQueue && !msgQueue[startOfQueue].delay) {
358         msg = msgQueue[startOfQueue++].msg;
359         switch (msg.message) {
360             case WM_LBUTTONUP:
361             case WM_RBUTTONUP:
362             case WM_MBUTTONUP:
363                 doMouseUp(msg, oleDragAndDropReturnValue);
364                 break;
365             case WM_MOUSEMOVE:
366                 doMouseMove(msg);
367                 break;
368             case WM_LBUTTONDOWN:
369             case WM_RBUTTONDOWN:
370             case WM_MBUTTONDOWN:
371                 dispatchMessage(&msg);
372                 break;
373             default:
374                 // Not reached
375                 break;
376         }
377     }
378
379     int numQueuedMessages = endOfQueue - startOfQueue;
380     if (!numQueuedMessages) {
381         startOfQueue = 0;
382         endOfQueue = 0;
383         replayingSavedEvents = false;
384         ASSERT(!down);
385         return;
386     }
387
388     if (msgQueue[startOfQueue].delay) {
389         ::Sleep(msgQueue[startOfQueue].delay);
390         msgQueue[startOfQueue].delay = 0;
391     }
392
393     ::PostMessage(webViewWindow, WM_DRT_SEND_QUEUED_EVENT, 0, 0);
394     while (::GetMessage(&msg, webViewWindow, 0, 0)) {
395         // FIXME: Why do we get a WM_MOUSELEAVE? it breaks tests
396         if (msg.message == WM_MOUSELEAVE)
397             continue;
398         if (msg.message != WM_DRT_SEND_QUEUED_EVENT) {
399             dispatchMessage(&msg);
400             continue;
401         }
402         msg = msgQueue[startOfQueue++].msg;
403         switch (msg.message) {
404             case WM_LBUTTONUP:
405             case WM_RBUTTONUP:
406             case WM_MBUTTONUP:
407                 doMouseUp(msg, oleDragAndDropReturnValue);
408                 break;
409             case WM_MOUSEMOVE:
410                 doMouseMove(msg);
411                 break;
412             case WM_LBUTTONDOWN:
413             case WM_RBUTTONDOWN:
414             case WM_MBUTTONDOWN:
415                 dispatchMessage(&msg);
416                 break;
417             default:
418                 // Not reached
419                 break;
420         }
421         if (startOfQueue >= endOfQueue)
422             break;
423         ::Sleep(msgQueue[startOfQueue].delay);
424         msgQueue[startOfQueue].delay = 0;
425         ::PostMessage(webViewWindow, WM_DRT_SEND_QUEUED_EVENT, 0, 0);
426     }
427     startOfQueue = 0;
428     endOfQueue = 0;
429
430     replayingSavedEvents = false;
431 }
432
433 static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
434 {
435     if (argumentCount < 1)
436         return JSValueMakeUndefined(context);
437
438     static const JSStringRef lengthProperty = JSStringCreateWithUTF8CString("length");
439
440     COMPtr<IWebFramePrivate> framePrivate;
441     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
442         framePrivate->layout();
443     
444     JSStringRef character = JSValueToStringCopy(context, arguments[0], exception);
445     ASSERT(!*exception);
446     int virtualKeyCode;
447     int charCode = 0;
448     int keyData = 1;
449     bool needsShiftKeyModifier = false;
450     if (JSStringIsEqualToUTF8CString(character, "leftArrow")) {
451         virtualKeyCode = VK_LEFT;
452         keyData += KF_EXTENDED << 16; // In this case, extended means "not keypad".
453     } else if (JSStringIsEqualToUTF8CString(character, "rightArrow")) {
454         virtualKeyCode = VK_RIGHT;
455         keyData += KF_EXTENDED << 16;
456     } else if (JSStringIsEqualToUTF8CString(character, "upArrow")) {
457         virtualKeyCode = VK_UP;
458         keyData += KF_EXTENDED << 16;
459     } else if (JSStringIsEqualToUTF8CString(character, "downArrow")) {
460         virtualKeyCode = VK_DOWN;
461         keyData += KF_EXTENDED << 16;
462     } else if (JSStringIsEqualToUTF8CString(character, "pageUp"))
463         virtualKeyCode = VK_PRIOR;
464     else if (JSStringIsEqualToUTF8CString(character, "pageDown"))
465         virtualKeyCode = VK_NEXT;
466     else if (JSStringIsEqualToUTF8CString(character, "home"))
467         virtualKeyCode = VK_HOME;
468     else if (JSStringIsEqualToUTF8CString(character, "end"))
469         virtualKeyCode = VK_END;
470     else if (JSStringIsEqualToUTF8CString(character, "insert"))
471         virtualKeyCode = VK_INSERT;
472     else if (JSStringIsEqualToUTF8CString(character, "delete"))
473         virtualKeyCode = VK_DELETE;
474     else if (JSStringIsEqualToUTF8CString(character, "printScreen"))
475         virtualKeyCode = VK_SNAPSHOT;
476     else {
477         charCode = JSStringGetCharactersPtr(character)[0];
478         virtualKeyCode = LOBYTE(VkKeyScan(charCode));
479         if (WTF::isASCIIUpper(charCode))
480             needsShiftKeyModifier = true;
481     }
482     JSStringRelease(character);
483
484     BYTE keyState[256];
485     if (argumentCount > 1 || needsShiftKeyModifier) {
486         ::GetKeyboardState(keyState);
487
488         BYTE newKeyState[256];
489         memcpy(newKeyState, keyState, sizeof(keyState));
490
491         if (needsShiftKeyModifier)
492             newKeyState[VK_SHIFT] = 0x80;
493
494         if (argumentCount > 1) {
495             JSObjectRef modifiersArray = JSValueToObject(context, arguments[1], 0);
496             if (modifiersArray) {
497                 int modifiersCount = JSValueToNumber(context, JSObjectGetProperty(context, modifiersArray, lengthProperty, 0), 0);
498                 for (int i = 0; i < modifiersCount; ++i) {
499                     JSValueRef value = JSObjectGetPropertyAtIndex(context, modifiersArray, i, 0);
500                     JSStringRef string = JSValueToStringCopy(context, value, 0);
501                     if (JSStringIsEqualToUTF8CString(string, "ctrlKey") || JSStringIsEqualToUTF8CString(string, "addSelectionKey"))
502                         newKeyState[VK_CONTROL] = 0x80;
503                     else if (JSStringIsEqualToUTF8CString(string, "shiftKey") || JSStringIsEqualToUTF8CString(string, "rangeSelectionKey"))
504                         newKeyState[VK_SHIFT] = 0x80;
505                     else if (JSStringIsEqualToUTF8CString(string, "altKey"))
506                         newKeyState[VK_MENU] = 0x80;
507
508                     JSStringRelease(string);
509                 }
510             }
511         }
512
513         ::SetKeyboardState(newKeyState);
514     }
515
516     MSG msg = makeMsg(webViewWindow, (::GetKeyState(VK_MENU) & 0x8000) ? WM_SYSKEYDOWN : WM_KEYDOWN, virtualKeyCode, keyData);
517     if (virtualKeyCode != 255)
518         dispatchMessage(&msg);
519     else {
520         // For characters that do not exist in the active keyboard layout,
521         // ::Translate will not work, so we post an WM_CHAR event ourselves.
522         ::PostMessage(webViewWindow, WM_CHAR, charCode, 0);
523     }
524
525     // Tests expect that all messages are processed by the time keyDown() returns.
526     if (::PeekMessage(&msg, webViewWindow, WM_CHAR, WM_CHAR, PM_REMOVE) || ::PeekMessage(&msg, webViewWindow, WM_SYSCHAR, WM_SYSCHAR, PM_REMOVE))
527         ::DispatchMessage(&msg);
528
529     MSG msgUp = makeMsg(webViewWindow, (::GetKeyState(VK_MENU) & 0x8000) ? WM_SYSKEYUP : WM_KEYUP, virtualKeyCode, keyData);
530     ::DispatchMessage(&msgUp);
531
532     if (argumentCount > 1 || needsShiftKeyModifier)
533         ::SetKeyboardState(keyState);
534
535     return JSValueMakeUndefined(context);
536 }
537
538 // eventSender.dispatchMessage(message, wParam, lParam, time = currentEventTime(), x = lastMousePosition.x, y = lastMousePosition.y)
539 static JSValueRef dispatchMessageCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
540 {
541     if (argumentCount < 3)
542         return JSValueMakeUndefined(context);
543
544     COMPtr<IWebFramePrivate> framePrivate;
545     if (SUCCEEDED(frame->QueryInterface(&framePrivate)))
546         framePrivate->layout();
547     
548     MSG msg = {};
549     msg.hwnd = webViewWindow;
550     msg.message = JSValueToNumber(context, arguments[0], exception);
551     ASSERT(!*exception);
552     msg.wParam = JSValueToNumber(context, arguments[1], exception);
553     ASSERT(!*exception);
554     msg.lParam = static_cast<ULONG_PTR>(JSValueToNumber(context, arguments[2], exception));
555     ASSERT(!*exception);
556     if (argumentCount >= 4) {
557         msg.time = JSValueToNumber(context, arguments[3], exception);
558         ASSERT(!*exception);
559     }
560     if (!msg.time)
561         msg.time = currentEventTime();
562     if (argumentCount >= 6) {
563         msg.pt.x = JSValueToNumber(context, arguments[4], exception);
564         ASSERT(!*exception);
565         msg.pt.y = JSValueToNumber(context, arguments[5], exception);
566         ASSERT(!*exception);
567     } else
568         msg.pt = lastMousePosition;
569
570     ::DispatchMessage(&msg);
571
572     return JSValueMakeUndefined(context);
573 }
574
575 static JSValueRef textZoomInCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
576 {
577     COMPtr<IWebView> webView;
578     if (FAILED(frame->webView(&webView)))
579         return JSValueMakeUndefined(context);
580
581     COMPtr<IWebIBActions> webIBActions(Query, webView);
582     if (!webIBActions)
583         return JSValueMakeUndefined(context);
584
585     webIBActions->makeTextLarger(0);
586     return JSValueMakeUndefined(context);
587 }
588
589 static JSValueRef textZoomOutCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
590 {
591     COMPtr<IWebView> webView;
592     if (FAILED(frame->webView(&webView)))
593         return JSValueMakeUndefined(context);
594
595     COMPtr<IWebIBActions> webIBActions(Query, webView);
596     if (!webIBActions)
597         return JSValueMakeUndefined(context);
598
599     webIBActions->makeTextSmaller(0);
600     return JSValueMakeUndefined(context);
601 }
602
603 static JSValueRef zoomPageInCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
604 {
605     COMPtr<IWebView> webView;
606     if (FAILED(frame->webView(&webView)))
607         return JSValueMakeUndefined(context);
608
609     COMPtr<IWebIBActions> webIBActions(Query, webView);
610     if (!webIBActions)
611         return JSValueMakeUndefined(context);
612
613     webIBActions->zoomPageIn(0);
614     return JSValueMakeUndefined(context);
615 }
616
617 static JSValueRef zoomPageOutCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
618 {
619     COMPtr<IWebView> webView;
620     if (FAILED(frame->webView(&webView)))
621         return JSValueMakeUndefined(context);
622
623     COMPtr<IWebIBActions> webIBActions(Query, webView);
624     if (!webIBActions)
625         return JSValueMakeUndefined(context);
626
627     webIBActions->zoomPageOut(0);
628     return JSValueMakeUndefined(context);
629 }
630
631 static JSStaticFunction staticFunctions[] = {
632     { "contextClick", contextClickCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
633     { "mouseDown", mouseDownCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
634     { "mouseUp", mouseUpCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
635     { "mouseMoveTo", mouseMoveToCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
636     { "leapForward", leapForwardCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
637     { "keyDown", keyDownCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
638     { "dispatchMessage", dispatchMessageCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
639     { "textZoomIn", textZoomInCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
640     { "textZoomOut", textZoomOutCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
641     { "zoomPageIn", zoomPageInCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
642     { "zoomPageOut", zoomPageOutCallback, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
643     { 0, 0, 0 }
644 };
645
646 static JSStaticValue staticValues[] = {
647     { "dragMode", getDragModeCallback, setDragModeCallback, kJSPropertyAttributeNone },
648     { "WM_KEYDOWN", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
649     { "WM_KEYUP", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
650     { "WM_CHAR", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
651     { "WM_DEADCHAR", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
652     { "WM_SYSKEYDOWN", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
653     { "WM_SYSKEYUP", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
654     { "WM_SYSCHAR", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
655     { "WM_SYSDEADCHAR", getConstantCallback, 0, kJSPropertyAttributeReadOnly | kJSPropertyAttributeNone },
656     { 0, 0, 0, 0 }
657 };
658
659 static JSClassRef getClass(JSContextRef context)
660 {
661     static JSClassRef eventSenderClass = 0;
662
663     if (!eventSenderClass) {
664         JSClassDefinition classDefinition = {0};
665         classDefinition.staticFunctions = staticFunctions;
666         classDefinition.staticValues = staticValues;
667
668         eventSenderClass = JSClassCreate(&classDefinition);
669     }
670
671     return eventSenderClass;
672 }
673
674 JSObjectRef makeEventSender(JSContextRef context, bool isTopFrame)
675 {
676     if (isTopFrame) {
677         down = false;
678         dragMode = true;
679         replayingSavedEvents = false;
680         timeOffset = 0;
681         lastMousePosition.x = 0;
682         lastMousePosition.y = 0;
683
684         endOfQueue = 0;
685         startOfQueue = 0;
686
687         didDragEnter = false;
688         draggingInfo = 0;
689     }
690     return JSObjectMake(context, getClass(context), 0);
691 }