?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
makefiles: Output rules for building generated .rc files.
[wine.git] / dlls / mshtml / htmlevent.c
blobf2c24a41d5c5128cf7a6d69f9834b34b3e427bec
1 /*
2 * Copyright 2008-2009 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20 #include <assert.h>
21
22 #define COBJMACROS
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winuser.h"
27 #include "ole2.h"
28 #include "mshtmdid.h"
29
30 #include "mshtml_private.h"
31 #include "htmlevent.h"
32 #include "htmlscript.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
37
38 typedef enum {
39 LISTENER_TYPE_CAPTURE,
40 LISTENER_TYPE_BUBBLE,
41 LISTENER_TYPE_ONEVENT,
42 LISTENER_TYPE_ATTACHED
43 } listener_type_t;
44
45 typedef struct {
46 struct list entry;
47 listener_type_t type;
48 IDispatch *function;
49 } event_listener_t;
50
51 typedef struct {
52 struct wine_rb_entry entry;
53 struct list listeners;
54 WCHAR type[1];
55 } listener_container_t;
56
57 typedef enum {
58 DISPATCH_BOTH,
59 DISPATCH_STANDARD,
60 DISPATCH_LEGACY
61 } dispatch_mode_t;
62
63 static const WCHAR abortW[] = {'a','b','o','r','t',0};
64 static const WCHAR beforeactivateW[] = {'b','e','f','o','r','e','a','c','t','i','v','a','t','e',0};
65 static const WCHAR beforeunloadW[] = {'b','e','f','o','r','e','u','n','l','o','a','d',0};
66 static const WCHAR blurW[] = {'b','l','u','r',0};
67 static const WCHAR changeW[] = {'c','h','a','n','g','e',0};
68 static const WCHAR clickW[] = {'c','l','i','c','k',0};
69 static const WCHAR contextmenuW[] = {'c','o','n','t','e','x','t','m','e','n','u',0};
70 static const WCHAR dataavailableW[] = {'d','a','t','a','a','v','a','i','l','a','b','l','e',0};
71 static const WCHAR dblclickW[] = {'d','b','l','c','l','i','c','k',0};
72 static const WCHAR dragW[] = {'d','r','a','g',0};
73 static const WCHAR dragstartW[] = {'d','r','a','g','s','t','a','r','t',0};
74 static const WCHAR errorW[] = {'e','r','r','o','r',0};
75 static const WCHAR focusW[] = {'f','o','c','u','s',0};
76 static const WCHAR focusinW[] = {'f','o','c','u','s','i','n',0};
77 static const WCHAR focusoutW[] = {'f','o','c','u','s','o','u','t',0};
78 static const WCHAR helpW[] = {'h','e','l','p',0};
79 static const WCHAR inputW[] = {'i','n','p','u','t',0};
80 static const WCHAR keydownW[] = {'k','e','y','d','o','w','n',0};
81 static const WCHAR keypressW[] = {'k','e','y','p','r','e','s','s',0};
82 static const WCHAR keyupW[] = {'k','e','y','u','p',0};
83 static const WCHAR loadW[] = {'l','o','a','d',0};
84 static const WCHAR messageW[] = {'m','e','s','s','a','g','e',0};
85 static const WCHAR mousedownW[] = {'m','o','u','s','e','d','o','w','n',0};
86 static const WCHAR mousemoveW[] = {'m','o','u','s','e','m','o','v','e',0};
87 static const WCHAR mouseoutW[] = {'m','o','u','s','e','o','u','t',0};
88 static const WCHAR mouseoverW[] = {'m','o','u','s','e','o','v','e','r',0};
89 static const WCHAR mouseupW[] = {'m','o','u','s','e','u','p',0};
90 static const WCHAR mousewheelW[] = {'m','o','u','s','e','w','h','e','e','l',0};
91 static const WCHAR pasteW[] = {'p','a','s','t','e',0};
92 static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
93 static const WCHAR resizeW[] = {'r','e','s','i','z','e',0};
94 static const WCHAR scrollW[] = {'s','c','r','o','l','l',0};
95 static const WCHAR selectstartW[] = {'s','e','l','e','c','t','s','t','a','r','t',0};
96 static const WCHAR selectionchangeW[] = {'s','e','l','e','c','t','i','o','n','c','h','a','n','g','e',0};
97 static const WCHAR submitW[] = {'s','u','b','m','i','t',0};
98 static const WCHAR unloadW[] = {'u','n','l','o','a','d',0};
99 static const WCHAR DOMContentLoadedW[] = {'D','O','M','C','o','n','t','e','n','t','L','o','a','d','e','d',0};
100
101 static const WCHAR EventW[] = {'E','v','e','n','t',0};
102 static const WCHAR UIEventW[] = {'U','I','E','v','e','n','t',0};
103 static const WCHAR KeyboardEventW[] = {'K','e','y','b','o','a','r','d','E','v','e','n','t',0};
104 static const WCHAR MouseEventW[] = {'M','o','u','s','e','E','v','e','n','t',0};
105
106 typedef enum {
107 EVENT_TYPE_EVENT,
108 EVENT_TYPE_UIEVENT,
109 EVENT_TYPE_KEYBOARD,
110 EVENT_TYPE_MOUSE,
111 EVENT_TYPE_FOCUS,
112 EVENT_TYPE_DRAG,
113 EVENT_TYPE_MESSAGE,
114 EVENT_TYPE_CLIPBOARD
115 } event_type_t;
116
117 static const WCHAR *event_types[] = {
118 EventW,
119 UIEventW,
120 KeyboardEventW,
121 MouseEventW,
122 EventW, /* FIXME */
123 EventW, /* FIXME */
124 EventW, /* FIXME */
125 EventW /* FIXME */
126 };
127
128 typedef struct {
129 const WCHAR *name;
130 event_type_t type;
131 DISPID dispid;
132 DWORD flags;
133 } event_info_t;
134
135 /* Use Gecko default listener (it's registered on window object for DOM nodes). */
136 #define EVENT_DEFAULTLISTENER 0x0001
137 /* Register Gecko listener on target itself (unlike EVENT_DEFAULTLISTENER). */
138 #define EVENT_BIND_TO_TARGET 0x0002
139 /* Event bubbles by default (unless explicitly specified otherwise). */
140 #define EVENT_BUBBLES 0x0004
141 /* Event is cancelable by default (unless explicitly specified otherwise). */
142 #define EVENT_CANCELABLE 0x0008
143 /* Event may have default handler (so we always have to register Gecko listener). */
144 #define EVENT_HASDEFAULTHANDLERS 0x0020
145 /* Ecent is not supported properly, print FIXME message when it's used. */
146 #define EVENT_FIXME 0x0040
147
148 /* mouse event flags for fromElement and toElement implementation */
149 #define EVENT_MOUSE_TO_RELATED 0x0100
150 #define EVENT_MOUSE_FROM_RELATED 0x0200
151
152 static const event_info_t event_info[] = {
153 {abortW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONABORT,
154 EVENT_BIND_TO_TARGET},
155 {beforeactivateW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONBEFOREACTIVATE,
156 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
157 {beforeunloadW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONBEFOREUNLOAD,
158 EVENT_DEFAULTLISTENER | EVENT_CANCELABLE },
159 {blurW, EVENT_TYPE_FOCUS, DISPID_EVMETH_ONBLUR,
160 EVENT_DEFAULTLISTENER},
161 {changeW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONCHANGE,
162 EVENT_DEFAULTLISTENER | EVENT_BUBBLES},
163 {clickW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONCLICK,
164 EVENT_DEFAULTLISTENER | EVENT_HASDEFAULTHANDLERS | EVENT_BUBBLES | EVENT_CANCELABLE },
165 {contextmenuW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONCONTEXTMENU,
166 EVENT_BUBBLES | EVENT_CANCELABLE},
167 {dataavailableW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONDATAAVAILABLE,
168 EVENT_FIXME | EVENT_BUBBLES},
169 {dblclickW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONDBLCLICK,
170 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
171 {DOMContentLoadedW, EVENT_TYPE_EVENT, 0,
172 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
173 {dragW, EVENT_TYPE_DRAG, DISPID_EVMETH_ONDRAG,
174 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
175 {dragstartW, EVENT_TYPE_DRAG, DISPID_EVMETH_ONDRAGSTART,
176 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
177 {errorW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONERROR,
178 EVENT_BIND_TO_TARGET},
179 {focusW, EVENT_TYPE_FOCUS, DISPID_EVMETH_ONFOCUS,
180 EVENT_DEFAULTLISTENER},
181 {focusinW, EVENT_TYPE_FOCUS, DISPID_EVMETH_ONFOCUSIN,
182 EVENT_BUBBLES},
183 {focusoutW, EVENT_TYPE_FOCUS, DISPID_EVMETH_ONFOCUSOUT,
184 EVENT_BUBBLES},
185 {helpW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONHELP,
186 EVENT_BUBBLES | EVENT_CANCELABLE},
187 {inputW, EVENT_TYPE_EVENT, DISPID_UNKNOWN,
188 EVENT_DEFAULTLISTENER | EVENT_BUBBLES},
189 {keydownW, EVENT_TYPE_KEYBOARD, DISPID_EVMETH_ONKEYDOWN,
190 EVENT_DEFAULTLISTENER | EVENT_HASDEFAULTHANDLERS | EVENT_BUBBLES | EVENT_CANCELABLE },
191 {keypressW, EVENT_TYPE_KEYBOARD, DISPID_EVMETH_ONKEYPRESS,
192 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
193 {keyupW, EVENT_TYPE_KEYBOARD, DISPID_EVMETH_ONKEYUP,
194 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
195 {loadW, EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONLOAD,
196 EVENT_BIND_TO_TARGET},
197 {messageW, EVENT_TYPE_MESSAGE, DISPID_EVMETH_ONMESSAGE,
198 0},
199 {mousedownW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEDOWN,
200 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
201 {mousemoveW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEMOVE,
202 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE | EVENT_MOUSE_FROM_RELATED},
203 {mouseoutW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEOUT,
204 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE | EVENT_MOUSE_TO_RELATED},
205 {mouseoverW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEOVER,
206 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE | EVENT_MOUSE_FROM_RELATED},
207 {mouseupW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEUP,
208 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
209 {mousewheelW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEWHEEL,
210 EVENT_FIXME},
211 {pasteW, EVENT_TYPE_CLIPBOARD, DISPID_EVMETH_ONPASTE,
212 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
213 {readystatechangeW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONREADYSTATECHANGE,
214 0},
215 {resizeW, EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONRESIZE,
216 EVENT_DEFAULTLISTENER},
217 {scrollW, EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONSCROLL,
218 EVENT_DEFAULTLISTENER | EVENT_BUBBLES /* FIXME: not for elements */},
219 {selectionchangeW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONSELECTIONCHANGE,
220 EVENT_FIXME},
221 {selectstartW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONSELECTSTART,
222 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
223 {submitW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONSUBMIT,
224 EVENT_DEFAULTLISTENER | EVENT_HASDEFAULTHANDLERS | EVENT_BUBBLES | EVENT_CANCELABLE},
225 {unloadW, EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONUNLOAD,
226 EVENT_FIXME}
227 };
228
229 static eventid_t str_to_eid(const WCHAR *str)
230 {
231 int i;
232
233 for(i=0; i < ARRAY_SIZE(event_info); i++) {
234 if(!strcmpW(event_info[i].name, str))
235 return i;
236 }
237
238 return EVENTID_LAST;
239 }
240
241 static eventid_t attr_to_eid(const WCHAR *str)
242 {
243 int i;
244
245 if((str[0] != 'o' && str[0] != 'O') || (str[1] != 'n' && str[1] != 'N'))
246 return EVENTID_LAST;
247
248 for(i=0; i < ARRAY_SIZE(event_info); i++) {
249 if(!strcmpW(event_info[i].name, str+2) && event_info[i].dispid)
250 return i;
251 }
252
253 return EVENTID_LAST;
254 }
255
256 static listener_container_t *get_listener_container(EventTarget *event_target, const WCHAR *type, BOOL alloc)
257 {
258 const event_target_vtbl_t *vtbl;
259 listener_container_t *container;
260 struct wine_rb_entry *entry;
261 size_t type_len;
262 eventid_t eid;
263
264 entry = wine_rb_get(&event_target->handler_map, type);
265 if(entry)
266 return WINE_RB_ENTRY_VALUE(entry, listener_container_t, entry);
267 if(!alloc)
268 return NULL;
269
270 eid = str_to_eid(type);
271 if(eid != EVENTID_LAST && (event_info[eid].flags & EVENT_FIXME))
272 FIXME("unimplemented event %s\n", debugstr_w(event_info[eid].name));
273
274 type_len = strlenW(type);
275 container = heap_alloc(FIELD_OFFSET(listener_container_t, type[type_len+1]));
276 if(!container)
277 return NULL;
278 memcpy(container->type, type, (type_len + 1) * sizeof(WCHAR));
279 list_init(&container->listeners);
280 vtbl = dispex_get_vtbl(&event_target->dispex);
281 if(vtbl->bind_event)
282 vtbl->bind_event(&event_target->dispex, eid);
283 else
284 FIXME("Unsupported event binding on target %p\n", event_target);
285
286 wine_rb_put(&event_target->handler_map, container->type, &container->entry);
287 return container;
288 }
289
290 static void remove_event_listener(EventTarget *event_target, const WCHAR *type_name, listener_type_t type, IDispatch *function)
291 {
292 listener_container_t *container;
293 event_listener_t *listener;
294
295 container = get_listener_container(event_target, type_name, FALSE);
296 if(!container)
297 return;
298
299 LIST_FOR_EACH_ENTRY(listener, &container->listeners, event_listener_t, entry) {
300 if(listener->function == function && listener->type == type) {
301 IDispatch_Release(listener->function);
302 list_remove(&listener->entry);
303 heap_free(listener);
304 break;
305 }
306 }
307 }
308
309 static HRESULT get_gecko_target(IEventTarget*,nsIDOMEventTarget**);
310
311 typedef struct {
312 DispatchEx dispex;
313 IHTMLEventObj IHTMLEventObj_iface;
314
315 LONG ref;
316
317 DOMEvent *event;
318 VARIANT return_value;
319 } HTMLEventObj;
320
321 static inline HTMLEventObj *impl_from_IHTMLEventObj(IHTMLEventObj *iface)
322 {
323 return CONTAINING_RECORD(iface, HTMLEventObj, IHTMLEventObj_iface);
324 }
325
326 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
327 {
328 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
329
330 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
331
332 if(IsEqualGUID(&IID_IUnknown, riid)) {
333 *ppv = &This->IHTMLEventObj_iface;
334 }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) {
335 *ppv = &This->IHTMLEventObj_iface;
336 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
337 return *ppv ? S_OK : E_NOINTERFACE;
338 }else {
339 *ppv = NULL;
340 WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
341 return E_NOINTERFACE;
342 }
343
344 IUnknown_AddRef((IUnknown*)*ppv);
345 return S_OK;
346 }
347
348 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
349 {
350 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
351 LONG ref = InterlockedIncrement(&This->ref);
352
353 TRACE("(%p) ref=%d\n", This, ref);
354
355 return ref;
356 }
357
358 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
359 {
360 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
361 LONG ref = InterlockedDecrement(&This->ref);
362
363 TRACE("(%p) ref=%d\n", This, ref);
364
365 if(!ref) {
366 if(This->event)
367 IDOMEvent_Release(&This->event->IDOMEvent_iface);
368 release_dispex(&This->dispex);
369 heap_free(This);
370 }
371
372 return ref;
373 }
374
375 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
376 {
377 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
378 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
379 }
380
381 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
382 LCID lcid, ITypeInfo **ppTInfo)
383 {
384 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
385 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
386 }
387
388 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
389 LPOLESTR *rgszNames, UINT cNames,
390 LCID lcid, DISPID *rgDispId)
391 {
392 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
393 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
394 lcid, rgDispId);
395 }
396
397 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
398 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
399 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
400 {
401 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
402 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
403 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
404 }
405
406 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
407 {
408 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
409
410 TRACE("(%p)->(%p)\n", This, p);
411
412 if(!This->event) {
413 *p = NULL;
414 return S_OK;
415 }
416
417 return IDOMEvent_get_srcElement(&This->event->IDOMEvent_iface, p);
418 }
419
420 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
421 {
422 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
423 cpp_bool ret = FALSE;
424
425 TRACE("(%p)->(%p)\n", This, p);
426
427 if(This->event && This->event->mouse_event)
428 return IDOMMouseEvent_get_altKey(&This->event->IDOMMouseEvent_iface, p);
429
430 if(This->event && This->event->keyboard_event)
431 return IDOMKeyboardEvent_get_altKey(&This->event->IDOMKeyboardEvent_iface, p);
432
433 *p = variant_bool(ret);
434 return S_OK;
435 }
436
437 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
438 {
439 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
440 cpp_bool ret = FALSE;
441
442 TRACE("(%p)->(%p)\n", This, p);
443
444 if(This->event && This->event->mouse_event)
445 return IDOMMouseEvent_get_ctrlKey(&This->event->IDOMMouseEvent_iface, p);
446
447 if(This->event && This->event->keyboard_event)
448 return IDOMKeyboardEvent_get_ctrlKey(&This->event->IDOMKeyboardEvent_iface, p);
449
450 *p = variant_bool(ret);
451 return S_OK;
452 }
453
454 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
455 {
456 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
457 cpp_bool ret = FALSE;
458
459 TRACE("(%p)->(%p)\n", This, p);
460
461 if(This->event && This->event->mouse_event)
462 return IDOMMouseEvent_get_shiftKey(&This->event->IDOMMouseEvent_iface, p);
463
464 if(This->event && This->event->keyboard_event)
465 return IDOMKeyboardEvent_get_shiftKey(&This->event->IDOMKeyboardEvent_iface, p);
466
467 *p = variant_bool(ret);
468 return S_OK;
469 }
470
471 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
472 {
473 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
474
475 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
476
477 if(V_VT(&v) != VT_BOOL) {
478 FIXME("unsupported value %s\n", debugstr_variant(&v));
479 return DISP_E_BADVARTYPE;
480 }
481
482 This->return_value = v;
483 if(!V_BOOL(&v) && This->event)
484 IDOMEvent_preventDefault(&This->event->IDOMEvent_iface);
485 return S_OK;
486 }
487
488 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
489 {
490 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
491
492 TRACE("(%p)->(%p)\n", This, p);
493
494 V_VT(p) = VT_EMPTY;
495 return VariantCopy(p, &This->return_value);
496 }
497
498 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
499 {
500 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
501
502 TRACE("(%p)->(%x)\n", This, v);
503
504 if(This->event)
505 IDOMEvent_stopPropagation(&This->event->IDOMEvent_iface);
506 return S_OK;
507 }
508
509 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
510 {
511 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
512
513 TRACE("(%p)->(%p)\n", This, p);
514
515 *p = variant_bool(This->event && This->event->stop_propagation);
516 return S_OK;
517 }
518
519 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
520 {
521 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
522
523 TRACE("(%p)->(%p)\n", This, p);
524
525 if(This->event && This->event->mouse_event)
526 return IDOMMouseEvent_get_fromElement(&This->event->IDOMMouseEvent_iface, p);
527
528 *p = NULL;
529 return S_OK;
530 }
531
532 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
533 {
534 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
535
536 TRACE("(%p)->(%p)\n", This, p);
537
538 if(This->event && This->event->mouse_event)
539 return IDOMMouseEvent_get_toElement(&This->event->IDOMMouseEvent_iface, p);
540
541 *p = NULL;
542 return S_OK;
543 }
544
545 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
546 {
547 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
548 FIXME("(%p)->(%d)\n", This, v);
549 return E_NOTIMPL;
550 }
551
552 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
553 {
554 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
555
556 TRACE("(%p)->(%p)\n", This, p);
557
558 if(This->event && This->event->keyboard_event)
559 return IDOMKeyboardEvent_get_keyCode(&This->event->IDOMKeyboardEvent_iface, p);
560
561 *p = 0;
562 return S_OK;
563 }
564
565 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
566 {
567 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
568 USHORT button = 0;
569
570 TRACE("(%p)->(%p)\n", This, p);
571
572 if(This->event && This->event->mouse_event) {
573 HRESULT hres;
574 hres = IDOMMouseEvent_get_button(&This->event->IDOMMouseEvent_iface, &button);
575 if(FAILED(hres))
576 return hres;
577 }
578
579 *p = button;
580 return S_OK;
581 }
582
583 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
584 {
585 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
586
587 TRACE("(%p)->(%p)\n", This, p);
588
589 if(!This->event) {
590 *p = NULL;
591 return S_OK;
592 }
593
594 return IDOMEvent_get_type(&This->event->IDOMEvent_iface, p);
595 }
596
597 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
598 {
599 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
600
601 FIXME("(%p)->(%p)\n", This, p);
602
603 *p = NULL;
604 return S_OK;
605 }
606
607 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
608 {
609 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
610
611 FIXME("(%p)->(%p)\n", This, p);
612
613 *p = 0;
614 return S_OK;
615 }
616
617 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
618 {
619 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
620 LONG x = 0;
621
622 TRACE("(%p)->(%p)\n", This, p);
623
624 if(This->event && This->event->ui_event) {
625 nsresult nsres;
626
627 /* NOTE: pageX is not exactly right here. */
628 nsres = nsIDOMUIEvent_GetPageX(This->event->ui_event, &x);
629 assert(nsres == NS_OK);
630 }
631
632 *p = x;
633 return S_OK;
634 }
635
636 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
637 {
638 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
639 LONG y = 0;
640
641 TRACE("(%p)->(%p)\n", This, p);
642
643 if(This->event && This->event->ui_event) {
644 nsresult nsres;
645
646 /* NOTE: pageY is not exactly right here. */
647 nsres = nsIDOMUIEvent_GetPageY(This->event->ui_event, &y);
648 assert(nsres == NS_OK);
649 }
650
651 *p = y;
652 return S_OK;
653 }
654
655 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
656 {
657 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
658
659 TRACE("(%p)->(%p)\n", This, p);
660
661 if(This->event && This->event->mouse_event)
662 return IDOMMouseEvent_get_clientX(&This->event->IDOMMouseEvent_iface, p);
663
664 *p = 0;
665 return S_OK;
666 }
667
668 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
669 {
670 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
671
672 TRACE("(%p)->(%p)\n", This, p);
673
674 if(This->event && This->event->mouse_event)
675 return IDOMMouseEvent_get_clientY(&This->event->IDOMMouseEvent_iface, p);
676
677 *p = 0;
678 return S_OK;
679 }
680
681 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
682 {
683 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
684
685 TRACE("(%p)->(%p)\n", This, p);
686
687 if(This->event && This->event->mouse_event)
688 return IDOMMouseEvent_get_offsetX(&This->event->IDOMMouseEvent_iface, p);
689
690 *p = 0;
691 return S_OK;
692 }
693
694 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p)
695 {
696 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
697
698 TRACE("(%p)->(%p)\n", This, p);
699
700 if(This->event && This->event->mouse_event)
701 return IDOMMouseEvent_get_offsetY(&This->event->IDOMMouseEvent_iface, p);
702
703 *p = 0;
704 return S_OK;
705 }
706
707 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p)
708 {
709 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
710
711 TRACE("(%p)->(%p)\n", This, p);
712
713 if(This->event && This->event->mouse_event)
714 return IDOMMouseEvent_get_screenX(&This->event->IDOMMouseEvent_iface, p);
715
716 *p = 0;
717 return S_OK;
718 }
719
720 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
721 {
722 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
723
724 TRACE("(%p)->(%p)\n", This, p);
725
726 if(This->event && This->event->mouse_event)
727 return IDOMMouseEvent_get_screenY(&This->event->IDOMMouseEvent_iface, p);
728
729 *p = 0;
730 return S_OK;
731 }
732
733 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
734 {
735 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
736
737 FIXME("(%p)->(%p)\n", This, p);
738
739 *p = NULL;
740 return S_OK;
741 }
742
743 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
744 HTMLEventObj_QueryInterface,
745 HTMLEventObj_AddRef,
746 HTMLEventObj_Release,
747 HTMLEventObj_GetTypeInfoCount,
748 HTMLEventObj_GetTypeInfo,
749 HTMLEventObj_GetIDsOfNames,
750 HTMLEventObj_Invoke,
751 HTMLEventObj_get_srcElement,
752 HTMLEventObj_get_altKey,
753 HTMLEventObj_get_ctrlKey,
754 HTMLEventObj_get_shiftKey,
755 HTMLEventObj_put_returnValue,
756 HTMLEventObj_get_returnValue,
757 HTMLEventObj_put_cancelBubble,
758 HTMLEventObj_get_cancelBubble,
759 HTMLEventObj_get_fromElement,
760 HTMLEventObj_get_toElement,
761 HTMLEventObj_put_keyCode,
762 HTMLEventObj_get_keyCode,
763 HTMLEventObj_get_button,
764 HTMLEventObj_get_type,
765 HTMLEventObj_get_qualifier,
766 HTMLEventObj_get_reason,
767 HTMLEventObj_get_x,
768 HTMLEventObj_get_y,
769 HTMLEventObj_get_clientX,
770 HTMLEventObj_get_clientY,
771 HTMLEventObj_get_offsetX,
772 HTMLEventObj_get_offsetY,
773 HTMLEventObj_get_screenX,
774 HTMLEventObj_get_screenY,
775 HTMLEventObj_get_srcFilter
776 };
777
778 static inline HTMLEventObj *unsafe_impl_from_IHTMLEventObj(IHTMLEventObj *iface)
779 {
780 return iface->lpVtbl == &HTMLEventObjVtbl ? impl_from_IHTMLEventObj(iface) : NULL;
781 }
782
783 static const tid_t HTMLEventObj_iface_tids[] = {
784 IHTMLEventObj_tid,
785 0
786 };
787
788 static dispex_static_data_t HTMLEventObj_dispex = {
789 NULL,
790 DispCEventObj_tid,
791 HTMLEventObj_iface_tids
792 };
793
794 static HTMLEventObj *alloc_event_obj(DOMEvent *event)
795 {
796 HTMLEventObj *event_obj;
797
798 event_obj = heap_alloc_zero(sizeof(*event_obj));
799 if(!event_obj)
800 return NULL;
801
802 event_obj->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl;
803 event_obj->ref = 1;
804 event_obj->event = event;
805 if(event)
806 IDOMEvent_AddRef(&event->IDOMEvent_iface);
807
808 init_dispex(&event_obj->dispex, (IUnknown*)&event_obj->IHTMLEventObj_iface, &HTMLEventObj_dispex);
809 return event_obj;
810 }
811
812 HRESULT create_event_obj(IHTMLEventObj **ret)
813 {
814 HTMLEventObj *event_obj;
815
816 event_obj = alloc_event_obj(NULL);
817 if(!event_obj)
818 return E_OUTOFMEMORY;
819
820 *ret = &event_obj->IHTMLEventObj_iface;
821 return S_OK;
822 }
823
824 static inline DOMEvent *impl_from_IDOMEvent(IDOMEvent *iface)
825 {
826 return CONTAINING_RECORD(iface, DOMEvent, IDOMEvent_iface);
827 }
828
829 static const IDOMEventVtbl DOMEventVtbl;
830
831 static inline DOMEvent *unsafe_impl_from_IDOMEvent(IDOMEvent *iface)
832 {
833 return iface && iface->lpVtbl == &DOMEventVtbl ? impl_from_IDOMEvent(iface) : NULL;
834 }
835
836 static HRESULT WINAPI DOMEvent_QueryInterface(IDOMEvent *iface, REFIID riid, void **ppv)
837 {
838 DOMEvent *This = impl_from_IDOMEvent(iface);
839
840 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
841
842 if(IsEqualGUID(&IID_IUnknown, riid))
843 *ppv = &This->IDOMEvent_iface;
844 else if(IsEqualGUID(&IID_IDOMEvent, riid))
845 *ppv = &This->IDOMEvent_iface;
846 else if(This->ui_event && IsEqualGUID(&IID_IDOMUIEvent, riid))
847 *ppv = &This->IDOMUIEvent_iface;
848 else if(This->mouse_event && IsEqualGUID(&IID_IDOMMouseEvent, riid))
849 *ppv = &This->IDOMMouseEvent_iface;
850 else if(This->keyboard_event && IsEqualGUID(&IID_IDOMKeyboardEvent, riid))
851 *ppv = &This->IDOMKeyboardEvent_iface;
852 else if(dispex_query_interface(&This->dispex, riid, ppv))
853 return *ppv ? S_OK : E_NOINTERFACE;
854 else {
855 *ppv = NULL;
856 WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
857 return E_NOINTERFACE;
858 }
859
860 IUnknown_AddRef((IUnknown*)*ppv);
861 return S_OK;
862 }
863
864 static ULONG WINAPI DOMEvent_AddRef(IDOMEvent *iface)
865 {
866 DOMEvent *This = impl_from_IDOMEvent(iface);
867 LONG ref = InterlockedIncrement(&This->ref);
868
869 TRACE("(%p) ref=%u\n", This, ref);
870
871 return ref;
872 }
873
874 static ULONG WINAPI DOMEvent_Release(IDOMEvent *iface)
875 {
876 DOMEvent *This = impl_from_IDOMEvent(iface);
877 LONG ref = InterlockedDecrement(&This->ref);
878
879 TRACE("(%p) ref=%u\n", This, ref);
880
881 if(!ref) {
882 if(This->ui_event)
883 nsIDOMUIEvent_Release(This->ui_event);
884 if(This->mouse_event)
885 nsIDOMMouseEvent_Release(This->mouse_event);
886 if(This->target)
887 IEventTarget_Release(&This->target->IEventTarget_iface);
888 nsIDOMEvent_Release(This->nsevent);
889 release_dispex(&This->dispex);
890 heap_free(This->type);
891 heap_free(This);
892 }
893
894 return ref;
895 }
896
897 static HRESULT WINAPI DOMEvent_GetTypeInfoCount(IDOMEvent *iface, UINT *pctinfo)
898 {
899 DOMEvent *This = impl_from_IDOMEvent(iface);
900 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
901 }
902
903 static HRESULT WINAPI DOMEvent_GetTypeInfo(IDOMEvent *iface, UINT iTInfo,
904 LCID lcid, ITypeInfo **ppTInfo)
905 {
906 DOMEvent *This = impl_from_IDOMEvent(iface);
907 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
908 }
909
910 static HRESULT WINAPI DOMEvent_GetIDsOfNames(IDOMEvent *iface, REFIID riid,
911 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
912 {
913 DOMEvent *This = impl_from_IDOMEvent(iface);
914 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
915 lcid, rgDispId);
916 }
917
918 static HRESULT WINAPI DOMEvent_Invoke(IDOMEvent *iface, DISPID dispIdMember,
919 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
920 EXCEPINFO *pExcepInfo, UINT *puArgErr)
921 {
922 DOMEvent *This = impl_from_IDOMEvent(iface);
923 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
924 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
925 }
926
927 static HRESULT WINAPI DOMEvent_get_bubbles(IDOMEvent *iface, VARIANT_BOOL *p)
928 {
929 DOMEvent *This = impl_from_IDOMEvent(iface);
930
931 TRACE("(%p)->(%p)\n", This, p);
932
933 *p = variant_bool(This->bubbles);
934 return S_OK;
935 }
936
937 static HRESULT WINAPI DOMEvent_get_cancelable(IDOMEvent *iface, VARIANT_BOOL *p)
938 {
939 DOMEvent *This = impl_from_IDOMEvent(iface);
940
941 TRACE("(%p)->(%p)\n", This, p);
942
943 *p = variant_bool(This->cancelable);
944 return S_OK;
945 }
946
947 static HRESULT WINAPI DOMEvent_get_currentTarget(IDOMEvent *iface, IEventTarget **p)
948 {
949 DOMEvent *This = impl_from_IDOMEvent(iface);
950
951 TRACE("(%p)->(%p)\n", This, p);
952
953 if(This->current_target)
954 IEventTarget_AddRef(*p = &This->current_target->IEventTarget_iface);
955 else
956 *p = NULL;
957 return S_OK;
958 }
959
960 static HRESULT WINAPI DOMEvent_get_defaultPrevented(IDOMEvent *iface, VARIANT_BOOL *p)
961 {
962 DOMEvent *This = impl_from_IDOMEvent(iface);
963
964 TRACE("(%p)->(%p)\n", This, p);
965
966 *p = variant_bool(This->prevent_default);
967 return S_OK;
968 }
969
970 static HRESULT WINAPI DOMEvent_get_eventPhase(IDOMEvent *iface, USHORT *p)
971 {
972 DOMEvent *This = impl_from_IDOMEvent(iface);
973
974 TRACE("(%p)->(%p)\n", This, p);
975
976 *p = This->phase;
977 return S_OK;
978 }
979
980 static HRESULT WINAPI DOMEvent_get_target(IDOMEvent *iface, IEventTarget **p)
981 {
982 DOMEvent *This = impl_from_IDOMEvent(iface);
983
984 TRACE("(%p)->(%p)\n", This, p);
985
986 if(This->target)
987 IEventTarget_AddRef(*p = &This->target->IEventTarget_iface);
988 else
989 *p = NULL;
990 return S_OK;
991 }
992
993 static HRESULT WINAPI DOMEvent_get_timeStamp(IDOMEvent *iface, ULONGLONG *p)
994 {
995 DOMEvent *This = impl_from_IDOMEvent(iface);
996
997 TRACE("(%p)->(%p)\n", This, p);
998
999 *p = This->time_stamp;
1000 return S_OK;
1001 }
1002
1003 static HRESULT WINAPI DOMEvent_get_type(IDOMEvent *iface, BSTR *p)
1004 {
1005 DOMEvent *This = impl_from_IDOMEvent(iface);
1006
1007 TRACE("(%p)->(%p)\n", This, p);
1008
1009 if(This->type) {
1010 *p = SysAllocString(This->type);
1011 if(!*p)
1012 return E_OUTOFMEMORY;
1013 }else {
1014 *p = NULL;
1015 }
1016 return S_OK;
1017 }
1018
1019 #ifdef __i386__
1020 #define nsIDOMEvent_InitEvent(_this,type,bubbles,cancelable) \
1021 ((void (WINAPI*)(void*,nsIDOMEvent*,const nsAString*,cpp_bool,cpp_bool)) \
1022 &call_thiscall_func)((_this)->lpVtbl->InitEvent,_this,type,bubbles,cancelable)
1023
1024 #endif
1025
1026 static HRESULT WINAPI DOMEvent_initEvent(IDOMEvent *iface, BSTR type, VARIANT_BOOL can_bubble, VARIANT_BOOL cancelable)
1027 {
1028 DOMEvent *This = impl_from_IDOMEvent(iface);
1029 nsAString nsstr;
1030
1031 TRACE("(%p)->(%s %x %x)\n", This, debugstr_w(type), can_bubble, cancelable);
1032
1033 if(This->target) {
1034 TRACE("called on already dispatched event\n");
1035 return S_OK;
1036 }
1037
1038 heap_free(This->type);
1039 This->type = heap_strdupW(type);
1040 if(!This->type)
1041 return E_OUTOFMEMORY;
1042 This->event_id = str_to_eid(type);
1043
1044 This->bubbles = !!can_bubble;
1045 This->cancelable = !!cancelable;
1046
1047 nsAString_InitDepend(&nsstr, type);
1048 nsIDOMEvent_InitEvent(This->nsevent, &nsstr, This->bubbles, This->cancelable);
1049 nsAString_Finish(&nsstr);
1050
1051 return S_OK;
1052 }
1053
1054 static HRESULT WINAPI DOMEvent_preventDefault(IDOMEvent *iface)
1055 {
1056 DOMEvent *This = impl_from_IDOMEvent(iface);
1057
1058 TRACE("(%p)\n", This);
1059
1060 if(This->current_target && This->cancelable) {
1061 This->prevent_default = TRUE;
1062 nsIDOMEvent_PreventDefault(This->nsevent);
1063 }
1064 return S_OK;
1065 }
1066
1067 static HRESULT WINAPI DOMEvent_stopPropagation(IDOMEvent *iface)
1068 {
1069 DOMEvent *This = impl_from_IDOMEvent(iface);
1070
1071 TRACE("(%p)\n", This);
1072
1073 This->stop_propagation = TRUE;
1074 nsIDOMEvent_StopPropagation(This->nsevent);
1075 return S_OK;
1076 }
1077
1078 static HRESULT WINAPI DOMEvent_stopImmediatePropagation(IDOMEvent *iface)
1079 {
1080 DOMEvent *This = impl_from_IDOMEvent(iface);
1081
1082 TRACE("(%p)\n", This);
1083
1084 This->stop_immediate_propagation = This->stop_propagation = TRUE;
1085 nsIDOMEvent_StopImmediatePropagation(This->nsevent);
1086 return S_OK;
1087 }
1088
1089 static HRESULT WINAPI DOMEvent_get_isTrusted(IDOMEvent *iface, VARIANT_BOOL *p)
1090 {
1091 DOMEvent *This = impl_from_IDOMEvent(iface);
1092 FIXME("(%p)->(%p)\n", This, p);
1093 return E_NOTIMPL;
1094 }
1095
1096 static HRESULT WINAPI DOMEvent_put_cancelBubble(IDOMEvent *iface, VARIANT_BOOL v)
1097 {
1098 DOMEvent *This = impl_from_IDOMEvent(iface);
1099 FIXME("(%p)->(%x)\n", This, v);
1100 return E_NOTIMPL;
1101 }
1102
1103 static HRESULT WINAPI DOMEvent_get_cancelBubble(IDOMEvent *iface, VARIANT_BOOL *p)
1104 {
1105 DOMEvent *This = impl_from_IDOMEvent(iface);
1106 FIXME("(%p)->(%p)\n", This, p);
1107 return E_NOTIMPL;
1108 }
1109
1110 static HRESULT WINAPI DOMEvent_get_srcElement(IDOMEvent *iface, IHTMLElement **p)
1111 {
1112 DOMEvent *This = impl_from_IDOMEvent(iface);
1113
1114 TRACE("(%p)->(%p)\n", This, p);
1115
1116 if(This->target)
1117 IDispatchEx_QueryInterface(&This->target->dispex.IDispatchEx_iface, &IID_IHTMLElement, (void**)p);
1118 else
1119 *p = NULL;
1120 return S_OK;
1121 }
1122
1123 static const IDOMEventVtbl DOMEventVtbl = {
1124 DOMEvent_QueryInterface,
1125 DOMEvent_AddRef,
1126 DOMEvent_Release,
1127 DOMEvent_GetTypeInfoCount,
1128 DOMEvent_GetTypeInfo,
1129 DOMEvent_GetIDsOfNames,
1130 DOMEvent_Invoke,
1131 DOMEvent_get_bubbles,
1132 DOMEvent_get_cancelable,
1133 DOMEvent_get_currentTarget,
1134 DOMEvent_get_defaultPrevented,
1135 DOMEvent_get_eventPhase,
1136 DOMEvent_get_target,
1137 DOMEvent_get_timeStamp,
1138 DOMEvent_get_type,
1139 DOMEvent_initEvent,
1140 DOMEvent_preventDefault,
1141 DOMEvent_stopPropagation,
1142 DOMEvent_stopImmediatePropagation,
1143 DOMEvent_get_isTrusted,
1144 DOMEvent_put_cancelBubble,
1145 DOMEvent_get_cancelBubble,
1146 DOMEvent_get_srcElement
1147 };
1148
1149 static inline DOMEvent *impl_from_IDOMUIEvent(IDOMUIEvent *iface)
1150 {
1151 return CONTAINING_RECORD(iface, DOMEvent, IDOMUIEvent_iface);
1152 }
1153
1154 static HRESULT WINAPI DOMUIEvent_QueryInterface(IDOMUIEvent *iface, REFIID riid, void **ppv)
1155 {
1156 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1157 return IDOMEvent_QueryInterface(&This->IDOMEvent_iface, riid, ppv);
1158 }
1159
1160 static ULONG WINAPI DOMUIEvent_AddRef(IDOMUIEvent *iface)
1161 {
1162 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1163 return IDOMEvent_AddRef(&This->IDOMEvent_iface);
1164 }
1165
1166 static ULONG WINAPI DOMUIEvent_Release(IDOMUIEvent *iface)
1167 {
1168 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1169 return IDOMEvent_Release(&This->IDOMEvent_iface);
1170 }
1171
1172 static HRESULT WINAPI DOMUIEvent_GetTypeInfoCount(IDOMUIEvent *iface, UINT *pctinfo)
1173 {
1174 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1175 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1176 }
1177
1178 static HRESULT WINAPI DOMUIEvent_GetTypeInfo(IDOMUIEvent *iface, UINT iTInfo,
1179 LCID lcid, ITypeInfo **ppTInfo)
1180 {
1181 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1182 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1183 }
1184
1185 static HRESULT WINAPI DOMUIEvent_GetIDsOfNames(IDOMUIEvent *iface, REFIID riid,
1186 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1187 {
1188 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1189 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1190 lcid, rgDispId);
1191 }
1192
1193 static HRESULT WINAPI DOMUIEvent_Invoke(IDOMUIEvent *iface, DISPID dispIdMember,
1194 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1195 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1196 {
1197 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1198 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1199 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1200 }
1201
1202 static HRESULT WINAPI DOMUIEvent_get_view(IDOMUIEvent *iface, IHTMLWindow2 **p)
1203 {
1204 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1205 mozIDOMWindowProxy *moz_window;
1206 HTMLOuterWindow *view = NULL;
1207 nsresult nsres;
1208
1209 TRACE("(%p)->(%p)\n", This, p);
1210
1211 nsres = nsIDOMUIEvent_GetView(This->ui_event, &moz_window);
1212 if(NS_FAILED(nsres))
1213 return E_FAIL;
1214
1215 if(moz_window) {
1216 view = mozwindow_to_window(moz_window);
1217 mozIDOMWindowProxy_Release(moz_window);
1218 }
1219 if(view)
1220 IHTMLWindow2_AddRef((*p = &view->base.inner_window->base.IHTMLWindow2_iface));
1221 else
1222 *p = NULL;
1223 return S_OK;
1224 }
1225
1226 static HRESULT WINAPI DOMUIEvent_get_detail(IDOMUIEvent *iface, LONG *p)
1227 {
1228 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1229 INT32 detail;
1230 nsresult nsres;
1231
1232 TRACE("(%p)->(%p)\n", This, p);
1233
1234 nsres = nsIDOMUIEvent_GetDetail(This->ui_event, &detail);
1235 if(NS_FAILED(nsres))
1236 return E_FAIL;
1237
1238 *p = detail;
1239 return S_OK;
1240 }
1241
1242 static HRESULT WINAPI DOMUIEvent_initUIEvent(IDOMUIEvent *iface, BSTR type, VARIANT_BOOL can_bubble,
1243 VARIANT_BOOL cancelable, IHTMLWindow2 *view, LONG detail)
1244 {
1245 DOMEvent *This = impl_from_IDOMUIEvent(iface);
1246 nsAString type_str;
1247 nsresult nsres;
1248 HRESULT hres;
1249
1250 TRACE("(%p)->(%s %x %x %p %x)\n", This, debugstr_w(type), can_bubble, cancelable, view, detail);
1251
1252 if(This->target) {
1253 TRACE("called on already dispatched event\n");
1254 return S_OK;
1255 }
1256
1257 if(view)
1258 FIXME("view argument is not supported\n");
1259
1260 hres = IDOMEvent_initEvent(&This->IDOMEvent_iface, type, can_bubble, cancelable);
1261 if(FAILED(hres))
1262 return hres;
1263
1264 nsAString_InitDepend(&type_str, type);
1265 nsres = nsIDOMUIEvent_InitUIEvent(This->ui_event, &type_str, can_bubble, cancelable,
1266 NULL /* FIXME */, detail);
1267 nsAString_Finish(&type_str);
1268 if(NS_FAILED(nsres)) {
1269 FIXME("InitUIEvent failed: %08x\n", nsres);
1270 return E_FAIL;
1271 }
1272
1273 return S_OK;
1274 }
1275
1276 static const IDOMUIEventVtbl DOMUIEventVtbl = {
1277 DOMUIEvent_QueryInterface,
1278 DOMUIEvent_AddRef,
1279 DOMUIEvent_Release,
1280 DOMUIEvent_GetTypeInfoCount,
1281 DOMUIEvent_GetTypeInfo,
1282 DOMUIEvent_GetIDsOfNames,
1283 DOMUIEvent_Invoke,
1284 DOMUIEvent_get_view,
1285 DOMUIEvent_get_detail,
1286 DOMUIEvent_initUIEvent
1287 };
1288
1289 static inline DOMEvent *impl_from_IDOMMouseEvent(IDOMMouseEvent *iface)
1290 {
1291 return CONTAINING_RECORD(iface, DOMEvent, IDOMMouseEvent_iface);
1292 }
1293
1294 static HRESULT WINAPI DOMMouseEvent_QueryInterface(IDOMMouseEvent *iface, REFIID riid, void **ppv)
1295 {
1296 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1297 return IDOMEvent_QueryInterface(&This->IDOMEvent_iface, riid, ppv);
1298 }
1299
1300 static ULONG WINAPI DOMMouseEvent_AddRef(IDOMMouseEvent *iface)
1301 {
1302 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1303 return IDOMEvent_AddRef(&This->IDOMEvent_iface);
1304 }
1305
1306 static ULONG WINAPI DOMMouseEvent_Release(IDOMMouseEvent *iface)
1307 {
1308 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1309 return IDOMEvent_Release(&This->IDOMEvent_iface);
1310 }
1311
1312 static HRESULT WINAPI DOMMouseEvent_GetTypeInfoCount(IDOMMouseEvent *iface, UINT *pctinfo)
1313 {
1314 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1315 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1316 }
1317
1318 static HRESULT WINAPI DOMMouseEvent_GetTypeInfo(IDOMMouseEvent *iface, UINT iTInfo,
1319 LCID lcid, ITypeInfo **ppTInfo)
1320 {
1321 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1322 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1323 }
1324
1325 static HRESULT WINAPI DOMMouseEvent_GetIDsOfNames(IDOMMouseEvent *iface, REFIID riid,
1326 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1327 {
1328 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1329 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1330 lcid, rgDispId);
1331 }
1332
1333 static HRESULT WINAPI DOMMouseEvent_Invoke(IDOMMouseEvent *iface, DISPID dispIdMember,
1334 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1335 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1336 {
1337 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1338 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1339 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1340 }
1341
1342 static HRESULT WINAPI DOMMouseEvent_get_screenX(IDOMMouseEvent *iface, LONG *p)
1343 {
1344 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1345 INT32 screen_x;
1346 nsresult nsres;
1347
1348 TRACE("(%p)->(%p)\n", This, p);
1349
1350 nsres = nsIDOMMouseEvent_GetScreenX(This->mouse_event, &screen_x);
1351 if(NS_FAILED(nsres))
1352 return E_FAIL;
1353
1354 *p = screen_x;
1355 return S_OK;
1356 }
1357
1358 static HRESULT WINAPI DOMMouseEvent_get_screenY(IDOMMouseEvent *iface, LONG *p)
1359 {
1360 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1361 INT32 screen_y;
1362 nsresult nsres;
1363
1364 TRACE("(%p)->(%p)\n", This, p);
1365
1366 nsres = nsIDOMMouseEvent_GetScreenY(This->mouse_event, &screen_y);
1367 if(NS_FAILED(nsres))
1368 return E_FAIL;
1369
1370 *p = screen_y;
1371 return S_OK;
1372 }
1373
1374 static HRESULT WINAPI DOMMouseEvent_get_clientX(IDOMMouseEvent *iface, LONG *p)
1375 {
1376 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1377 INT32 client_x;
1378 nsresult nsres;
1379
1380 TRACE("(%p)->(%p)\n", This, p);
1381
1382 nsres = nsIDOMMouseEvent_GetClientX(This->mouse_event, &client_x);
1383 if(NS_FAILED(nsres))
1384 return E_FAIL;
1385
1386 *p = client_x;
1387 return S_OK;
1388 }
1389
1390 static HRESULT WINAPI DOMMouseEvent_get_clientY(IDOMMouseEvent *iface, LONG *p)
1391 {
1392 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1393 INT32 client_y;
1394 nsresult nsres;
1395
1396 TRACE("(%p)->(%p)\n", This, p);
1397
1398 nsres = nsIDOMMouseEvent_GetClientY(This->mouse_event, &client_y);
1399 if(NS_FAILED(nsres))
1400 return E_FAIL;
1401
1402 *p = client_y;
1403 return S_OK;
1404 }
1405
1406 static HRESULT WINAPI DOMMouseEvent_get_ctrlKey(IDOMMouseEvent *iface, VARIANT_BOOL *p)
1407 {
1408 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1409 cpp_bool r;
1410 nsresult nsres;
1411
1412 TRACE("(%p)->(%p)\n", This, p);
1413
1414 nsres = nsIDOMMouseEvent_GetCtrlKey(This->mouse_event, &r);
1415 if(NS_FAILED(nsres))
1416 return E_FAIL;
1417
1418 *p = variant_bool(r);
1419 return S_OK;
1420 }
1421
1422 static HRESULT WINAPI DOMMouseEvent_get_shiftKey(IDOMMouseEvent *iface, VARIANT_BOOL *p)
1423 {
1424 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1425 cpp_bool r;
1426 nsresult nsres;
1427
1428 TRACE("(%p)->(%p)\n", This, p);
1429
1430 nsres = nsIDOMMouseEvent_GetShiftKey(This->mouse_event, &r);
1431 if(NS_FAILED(nsres))
1432 return E_FAIL;
1433
1434 *p = variant_bool(r);
1435 return S_OK;
1436 }
1437
1438 static HRESULT WINAPI DOMMouseEvent_get_altKey(IDOMMouseEvent *iface, VARIANT_BOOL *p)
1439 {
1440 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1441 cpp_bool r;
1442 nsresult nsres;
1443
1444 TRACE("(%p)->(%p)\n", This, p);
1445
1446 nsres = nsIDOMMouseEvent_GetAltKey(This->mouse_event, &r);
1447 if(NS_FAILED(nsres))
1448 return E_FAIL;
1449
1450 *p = variant_bool(r);
1451 return S_OK;
1452 }
1453
1454 static HRESULT WINAPI DOMMouseEvent_get_metaKey(IDOMMouseEvent *iface, VARIANT_BOOL *p)
1455 {
1456 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1457 cpp_bool r;
1458 nsresult nsres;
1459
1460 TRACE("(%p)->(%p)\n", This, p);
1461
1462 nsres = nsIDOMMouseEvent_GetMetaKey(This->mouse_event, &r);
1463 if(NS_FAILED(nsres))
1464 return E_FAIL;
1465
1466 *p = variant_bool(r);
1467 return S_OK;
1468 }
1469
1470 static HRESULT WINAPI DOMMouseEvent_get_button(IDOMMouseEvent *iface, USHORT *p)
1471 {
1472 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1473 INT16 r;
1474 nsresult nsres;
1475
1476 TRACE("(%p)->(%p)\n", This, p);
1477
1478 nsres = nsIDOMMouseEvent_GetButton(This->mouse_event, &r);
1479 if(NS_FAILED(nsres))
1480 return E_FAIL;
1481
1482 *p = r;
1483 return S_OK;
1484 }
1485
1486 static HRESULT WINAPI DOMMouseEvent_get_relatedTarget(IDOMMouseEvent *iface, IEventTarget **p)
1487 {
1488 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1489 nsIDOMEventTarget *related_target;
1490 nsIDOMNode *target_node;
1491 HTMLDOMNode *node;
1492 HRESULT hres;
1493 nsresult nsres;
1494
1495 TRACE("(%p)->(%p)\n", This, p);
1496
1497 nsres = nsIDOMMouseEvent_GetRelatedTarget(This->mouse_event, &related_target);
1498 if(NS_FAILED(nsres))
1499 return E_FAIL;
1500
1501 if(!related_target) {
1502 *p = NULL;
1503 return S_OK;
1504 }
1505
1506 nsres = nsIDOMEventTarget_QueryInterface(related_target, &IID_nsIDOMNode, (void**)&target_node);
1507 nsIDOMEventTarget_Release(related_target);
1508 if(NS_FAILED(nsres)) {
1509 FIXME("Only node targets supported\n");
1510 return E_NOTIMPL;
1511 }
1512
1513 hres = get_node(target_node, TRUE, &node);
1514 nsIDOMNode_Release(target_node);
1515 if(FAILED(hres))
1516 return hres;
1517
1518 *p = &node->event_target.IEventTarget_iface;
1519 return S_OK;
1520 }
1521
1522 static HRESULT WINAPI DOMMouseEvent_initMouseEvent(IDOMMouseEvent *iface, BSTR type,
1523 VARIANT_BOOL can_bubble, VARIANT_BOOL cancelable, IHTMLWindow2 *view, LONG detail,
1524 LONG screen_x, LONG screen_y, LONG client_x, LONG client_y, VARIANT_BOOL ctrl_key,
1525 VARIANT_BOOL alt_key, VARIANT_BOOL shift_key, VARIANT_BOOL meta_key, USHORT button,
1526 IEventTarget *related_target)
1527 {
1528 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1529 nsIDOMEventTarget *nstarget = NULL;
1530 nsAString type_str;
1531 nsresult nsres;
1532 HRESULT hres;
1533
1534 TRACE("(%p)->(%s %x %x %p %d %d %d %d %d %x %x %x %x %u %p)\n", This, debugstr_w(type),
1535 can_bubble, cancelable, view, detail, screen_x, screen_y, client_x, client_y,
1536 ctrl_key, alt_key, shift_key, meta_key, button, related_target);
1537
1538 if(This->target) {
1539 TRACE("called on already dispatched event\n");
1540 return S_OK;
1541 }
1542
1543 if(view)
1544 FIXME("view argument is not supported\n");
1545
1546 if(related_target) {
1547 hres = get_gecko_target(related_target, &nstarget);
1548 if(FAILED(hres))
1549 return hres;
1550 }
1551
1552 hres = IDOMEvent_initEvent(&This->IDOMEvent_iface, type, can_bubble, cancelable);
1553 if(SUCCEEDED(hres)) {
1554 nsAString_InitDepend(&type_str, type);
1555 nsres = nsIDOMMouseEvent_InitMouseEvent(This->mouse_event, &type_str, can_bubble, cancelable,
1556 NULL /* FIXME */, detail, screen_x, screen_y,
1557 client_x, client_y, ctrl_key, alt_key, shift_key,
1558 meta_key, button, nstarget);
1559 nsAString_Finish(&type_str);
1560 if(NS_FAILED(nsres)) {
1561 FIXME("InitMouseEvent failed: %08x\n", nsres);
1562 return E_FAIL;
1563 }
1564 }
1565
1566 if(nstarget)
1567 nsIDOMEventTarget_Release(nstarget);
1568 return S_OK;
1569 }
1570
1571 static HRESULT WINAPI DOMMouseEvent_getModifierState(IDOMMouseEvent *iface, BSTR key,
1572 VARIANT_BOOL *activated)
1573 {
1574 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1575 FIXME("(%p)->(%s %p)\n", This, debugstr_w(key), activated);
1576 return E_NOTIMPL;
1577 }
1578
1579 static HRESULT WINAPI DOMMouseEvent_get_buttons(IDOMMouseEvent *iface, USHORT *p)
1580 {
1581 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1582 UINT16 r;
1583 nsresult nsres;
1584
1585 TRACE("(%p)->(%p)\n", This, p);
1586
1587 nsres = nsIDOMMouseEvent_GetButtons(This->mouse_event, &r);
1588 if(NS_FAILED(nsres))
1589 return E_FAIL;
1590
1591 *p = r;
1592 return S_OK;
1593 }
1594
1595 static HRESULT WINAPI DOMMouseEvent_get_fromElement(IDOMMouseEvent *iface, IHTMLElement **p)
1596 {
1597 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1598 IEventTarget *related_target = NULL;
1599
1600 TRACE("(%p)->(%p)\n", This, p);
1601
1602 if(This->event_id != EVENTID_LAST) {
1603 HRESULT hres = S_OK;
1604 if(event_info[This->event_id].flags & EVENT_MOUSE_FROM_RELATED)
1605 hres = IDOMMouseEvent_get_relatedTarget(&This->IDOMMouseEvent_iface, &related_target);
1606 else if(event_info[This->event_id].flags & EVENT_MOUSE_TO_RELATED)
1607 hres = IDOMEvent_get_target(&This->IDOMEvent_iface, &related_target);
1608 if(FAILED(hres))
1609 return hres;
1610 }
1611
1612 if(!related_target) {
1613 *p = NULL;
1614 return S_OK;
1615 }
1616
1617 IEventTarget_QueryInterface(related_target, &IID_IHTMLElement, (void**)p);
1618 return S_OK;
1619 }
1620
1621 static HRESULT WINAPI DOMMouseEvent_get_toElement(IDOMMouseEvent *iface, IHTMLElement **p)
1622 {
1623 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1624 IEventTarget *related_target = NULL;
1625
1626 TRACE("(%p)->(%p)\n", This, p);
1627
1628 if(This->event_id != EVENTID_LAST) {
1629 HRESULT hres = S_OK;
1630 if(event_info[This->event_id].flags & EVENT_MOUSE_TO_RELATED)
1631 hres = IDOMMouseEvent_get_relatedTarget(&This->IDOMMouseEvent_iface, &related_target);
1632 else if(event_info[This->event_id].flags & EVENT_MOUSE_FROM_RELATED)
1633 hres = IDOMEvent_get_target(&This->IDOMEvent_iface, &related_target);
1634 if(FAILED(hres))
1635 return hres;
1636 }
1637
1638 if(!related_target) {
1639 *p = NULL;
1640 return S_OK;
1641 }
1642
1643 IEventTarget_QueryInterface(related_target, &IID_IHTMLElement, (void**)p);
1644 return S_OK;
1645 }
1646
1647 static HRESULT WINAPI DOMMouseEvent_get_x(IDOMMouseEvent *iface, LONG *p)
1648 {
1649 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1650 FIXME("(%p)->(%p)\n", This, p);
1651 return E_NOTIMPL;
1652 }
1653
1654 static HRESULT WINAPI DOMMouseEvent_get_y(IDOMMouseEvent *iface, LONG *p)
1655 {
1656 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1657 FIXME("(%p)->(%p)\n", This, p);
1658 return E_NOTIMPL;
1659 }
1660
1661 static HRESULT WINAPI DOMMouseEvent_get_offsetX(IDOMMouseEvent *iface, LONG *p)
1662 {
1663 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1664
1665 FIXME("(%p)->(%p) returning 0\n", This, p);
1666
1667 *p = 0;
1668 return S_OK;
1669 }
1670
1671 static HRESULT WINAPI DOMMouseEvent_get_offsetY(IDOMMouseEvent *iface, LONG *p)
1672 {
1673 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1674
1675 FIXME("(%p)->(%p) returning 0\n", This, p);
1676
1677 *p = 0;
1678 return S_OK;
1679 }
1680
1681 static HRESULT WINAPI DOMMouseEvent_get_pageX(IDOMMouseEvent *iface, LONG *p)
1682 {
1683 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1684 INT32 r;
1685 nsresult nsres;
1686
1687 TRACE("(%p)->(%p)\n", This, p);
1688
1689 nsres = nsIDOMMouseEvent_GetPageX(This->mouse_event, &r);
1690 if(NS_FAILED(nsres))
1691 return E_FAIL;
1692
1693 *p = r;
1694 return S_OK;
1695 }
1696
1697 static HRESULT WINAPI DOMMouseEvent_get_pageY(IDOMMouseEvent *iface, LONG *p)
1698 {
1699 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1700 INT32 r;
1701 nsresult nsres;
1702
1703 TRACE("(%p)->(%p)\n", This, p);
1704
1705 nsres = nsIDOMMouseEvent_GetPageY(This->mouse_event, &r);
1706 if(NS_FAILED(nsres))
1707 return E_FAIL;
1708
1709 *p = r;
1710 return S_OK;
1711 }
1712
1713 static HRESULT WINAPI DOMMouseEvent_get_layerX(IDOMMouseEvent *iface, LONG *p)
1714 {
1715 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1716 FIXME("(%p)->(%p)\n", This, p);
1717 return E_NOTIMPL;
1718 }
1719
1720 static HRESULT WINAPI DOMMouseEvent_get_layerY(IDOMMouseEvent *iface, LONG *p)
1721 {
1722 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1723 FIXME("(%p)->(%p)\n", This, p);
1724 return E_NOTIMPL;
1725 }
1726
1727 static HRESULT WINAPI DOMMouseEvent_get_which(IDOMMouseEvent *iface, USHORT *p)
1728 {
1729 DOMEvent *This = impl_from_IDOMMouseEvent(iface);
1730 UINT32 r;
1731 nsresult nsres;
1732
1733 TRACE("(%p)->(%p)\n", This, p);
1734
1735 nsres = nsIDOMMouseEvent_GetWhich(This->mouse_event, &r);
1736 if(NS_FAILED(nsres))
1737 return E_FAIL;
1738
1739 *p = r;
1740 return S_OK;
1741 }
1742
1743 static const IDOMMouseEventVtbl DOMMouseEventVtbl = {
1744 DOMMouseEvent_QueryInterface,
1745 DOMMouseEvent_AddRef,
1746 DOMMouseEvent_Release,
1747 DOMMouseEvent_GetTypeInfoCount,
1748 DOMMouseEvent_GetTypeInfo,
1749 DOMMouseEvent_GetIDsOfNames,
1750 DOMMouseEvent_Invoke,
1751 DOMMouseEvent_get_screenX,
1752 DOMMouseEvent_get_screenY,
1753 DOMMouseEvent_get_clientX,
1754 DOMMouseEvent_get_clientY,
1755 DOMMouseEvent_get_ctrlKey,
1756 DOMMouseEvent_get_shiftKey,
1757 DOMMouseEvent_get_altKey,
1758 DOMMouseEvent_get_metaKey,
1759 DOMMouseEvent_get_button,
1760 DOMMouseEvent_get_relatedTarget,
1761 DOMMouseEvent_initMouseEvent,
1762 DOMMouseEvent_getModifierState,
1763 DOMMouseEvent_get_buttons,
1764 DOMMouseEvent_get_fromElement,
1765 DOMMouseEvent_get_toElement,
1766 DOMMouseEvent_get_x,
1767 DOMMouseEvent_get_y,
1768 DOMMouseEvent_get_offsetX,
1769 DOMMouseEvent_get_offsetY,
1770 DOMMouseEvent_get_pageX,
1771 DOMMouseEvent_get_pageY,
1772 DOMMouseEvent_get_layerX,
1773 DOMMouseEvent_get_layerY,
1774 DOMMouseEvent_get_which
1775 };
1776
1777 static inline DOMEvent *impl_from_IDOMKeyboardEvent(IDOMKeyboardEvent *iface)
1778 {
1779 return CONTAINING_RECORD(iface, DOMEvent, IDOMKeyboardEvent_iface);
1780 }
1781
1782 static HRESULT WINAPI DOMKeyboardEvent_QueryInterface(IDOMKeyboardEvent *iface, REFIID riid, void **ppv)
1783 {
1784 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1785 return IDOMEvent_QueryInterface(&This->IDOMEvent_iface, riid, ppv);
1786 }
1787
1788 static ULONG WINAPI DOMKeyboardEvent_AddRef(IDOMKeyboardEvent *iface)
1789 {
1790 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1791 return IDOMEvent_AddRef(&This->IDOMEvent_iface);
1792 }
1793
1794 static ULONG WINAPI DOMKeyboardEvent_Release(IDOMKeyboardEvent *iface)
1795 {
1796 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1797 return IDOMEvent_Release(&This->IDOMEvent_iface);
1798 }
1799
1800 static HRESULT WINAPI DOMKeyboardEvent_GetTypeInfoCount(IDOMKeyboardEvent *iface, UINT *pctinfo)
1801 {
1802 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1803 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1804 }
1805
1806 static HRESULT WINAPI DOMKeyboardEvent_GetTypeInfo(IDOMKeyboardEvent *iface, UINT iTInfo,
1807 LCID lcid, ITypeInfo **ppTInfo)
1808 {
1809 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1810 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1811 }
1812
1813 static HRESULT WINAPI DOMKeyboardEvent_GetIDsOfNames(IDOMKeyboardEvent *iface, REFIID riid,
1814 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1815 {
1816 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1817 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1818 lcid, rgDispId);
1819 }
1820
1821 static HRESULT WINAPI DOMKeyboardEvent_Invoke(IDOMKeyboardEvent *iface, DISPID dispIdMember,
1822 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1823 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1824 {
1825 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1826 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1827 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1828 }
1829
1830 static HRESULT WINAPI DOMKeyboardEvent_get_key(IDOMKeyboardEvent *iface, BSTR *p)
1831 {
1832 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1833 nsAString key_str;
1834 nsresult nsres;
1835
1836 TRACE("(%p)->(%p)\n", This, p);
1837
1838
1839 nsAString_Init(&key_str, NULL);
1840 nsres = nsIDOMKeyEvent_GetKey(This->keyboard_event, &key_str);
1841 return return_nsstr(nsres, &key_str, p);
1842 }
1843
1844 static HRESULT WINAPI DOMKeyboardEvent_get_location(IDOMKeyboardEvent *iface, ULONG *p)
1845 {
1846 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1847 UINT32 r;
1848 nsresult nsres;
1849
1850 TRACE("(%p)->(%p)\n", This, p);
1851
1852 nsres = nsIDOMKeyEvent_GetLocation(This->keyboard_event, &r);
1853 if(NS_FAILED(nsres))
1854 return E_FAIL;
1855
1856 *p = r;
1857 return S_OK;
1858 }
1859
1860 static HRESULT WINAPI DOMKeyboardEvent_get_ctrlKey(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
1861 {
1862 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1863 cpp_bool r;
1864 nsresult nsres;
1865
1866 TRACE("(%p)->(%p)\n", This, p);
1867
1868 nsres = nsIDOMKeyEvent_GetCtrlKey(This->keyboard_event, &r);
1869 if(NS_FAILED(nsres))
1870 return E_FAIL;
1871
1872 *p = variant_bool(r);
1873 return S_OK;
1874 }
1875
1876 static HRESULT WINAPI DOMKeyboardEvent_get_shiftKey(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
1877 {
1878 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1879 cpp_bool r;
1880 nsresult nsres;
1881
1882 TRACE("(%p)->(%p)\n", This, p);
1883
1884 nsres = nsIDOMKeyEvent_GetShiftKey(This->keyboard_event, &r);
1885 if(NS_FAILED(nsres))
1886 return E_FAIL;
1887
1888 *p = variant_bool(r);
1889 return S_OK;
1890 }
1891
1892 static HRESULT WINAPI DOMKeyboardEvent_get_altKey(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
1893 {
1894 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1895 cpp_bool r;
1896 nsresult nsres;
1897
1898 TRACE("(%p)->(%p)\n", This, p);
1899
1900 nsres = nsIDOMKeyEvent_GetAltKey(This->keyboard_event, &r);
1901 if(NS_FAILED(nsres))
1902 return E_FAIL;
1903
1904 *p = variant_bool(r);
1905 return S_OK;
1906 }
1907
1908 static HRESULT WINAPI DOMKeyboardEvent_get_metaKey(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
1909 {
1910 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1911 cpp_bool r;
1912 nsresult nsres;
1913
1914 TRACE("(%p)->(%p)\n", This, p);
1915
1916 nsres = nsIDOMKeyEvent_GetMetaKey(This->keyboard_event, &r);
1917 if(NS_FAILED(nsres))
1918 return E_FAIL;
1919
1920 *p = variant_bool(r);
1921 return S_OK;
1922 }
1923
1924 static HRESULT WINAPI DOMKeyboardEvent_get_repeat(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
1925 {
1926 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1927 cpp_bool r;
1928 nsresult nsres;
1929
1930 TRACE("(%p)->(%p)\n", This, p);
1931
1932 nsres = nsIDOMKeyEvent_GetRepeat(This->keyboard_event, &r);
1933 if(NS_FAILED(nsres))
1934 return E_FAIL;
1935
1936 *p = variant_bool(r);
1937 return S_OK;
1938 }
1939
1940 static HRESULT WINAPI DOMKeyboardEvent_getModifierState(IDOMKeyboardEvent *iface, BSTR key,
1941 VARIANT_BOOL *state)
1942 {
1943 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1944 FIXME("(%p)->(%s %p)\n", This, debugstr_w(key), state);
1945 return E_NOTIMPL;
1946 }
1947
1948 static HRESULT WINAPI DOMKeyboardEvent_initKeyboardEvent(IDOMKeyboardEvent *iface, BSTR type,
1949 VARIANT_BOOL can_bubble, VARIANT_BOOL cancelable, IHTMLWindow2 *view, BSTR key,
1950 ULONG location, BSTR modifiers_list, VARIANT_BOOL repeat, BSTR locale)
1951 {
1952 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1953 FIXME("(%p)->(%s %x %x %p %s %u %s %x %s)\n", This, debugstr_w(type), can_bubble,
1954 cancelable, view, debugstr_w(key), location, debugstr_w(modifiers_list),
1955 repeat, debugstr_w(locale));
1956 return E_NOTIMPL;
1957 }
1958
1959 static HRESULT WINAPI DOMKeyboardEvent_get_keyCode(IDOMKeyboardEvent *iface, LONG *p)
1960 {
1961 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1962 UINT32 r;
1963 nsresult nsres;
1964
1965 TRACE("(%p)->(%p)\n", This, p);
1966
1967 nsres = nsIDOMKeyEvent_GetKeyCode(This->keyboard_event, &r);
1968 if(NS_FAILED(nsres))
1969 return E_FAIL;
1970
1971 *p = r;
1972 return S_OK;
1973 }
1974
1975 static HRESULT WINAPI DOMKeyboardEvent_get_charCode(IDOMKeyboardEvent *iface, LONG *p)
1976 {
1977 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1978 UINT32 r;
1979 nsresult nsres;
1980
1981 TRACE("(%p)->(%p)\n", This, p);
1982
1983 nsres = nsIDOMKeyEvent_GetKeyCode(This->keyboard_event, &r);
1984 if(NS_FAILED(nsres))
1985 return E_FAIL;
1986
1987 *p = r;
1988 return S_OK;
1989 }
1990
1991 static HRESULT WINAPI DOMKeyboardEvent_get_which(IDOMKeyboardEvent *iface, LONG *p)
1992 {
1993 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
1994 UINT32 r;
1995 nsresult nsres;
1996
1997 TRACE("(%p)->(%p)\n", This, p);
1998
1999 nsres = nsIDOMKeyEvent_GetWhich(This->keyboard_event, &r);
2000 if(NS_FAILED(nsres))
2001 return E_FAIL;
2002
2003 *p = r;
2004 return S_OK;
2005 }
2006
2007 static HRESULT WINAPI DOMKeyboardEvent_get_char(IDOMKeyboardEvent *iface, VARIANT *p)
2008 {
2009 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
2010 FIXME("(%p)->(%p)\n", This, p);
2011 return E_NOTIMPL;
2012 }
2013
2014 static HRESULT WINAPI DOMKeyboardEvent_get_locale(IDOMKeyboardEvent *iface, BSTR *p)
2015 {
2016 DOMEvent *This = impl_from_IDOMKeyboardEvent(iface);
2017 FIXME("(%p)->(%p)\n", This, p);
2018 return E_NOTIMPL;
2019 }
2020
2021 static const IDOMKeyboardEventVtbl DOMKeyboardEventVtbl = {
2022 DOMKeyboardEvent_QueryInterface,
2023 DOMKeyboardEvent_AddRef,
2024 DOMKeyboardEvent_Release,
2025 DOMKeyboardEvent_GetTypeInfoCount,
2026 DOMKeyboardEvent_GetTypeInfo,
2027 DOMKeyboardEvent_GetIDsOfNames,
2028 DOMKeyboardEvent_Invoke,
2029 DOMKeyboardEvent_get_key,
2030 DOMKeyboardEvent_get_location,
2031 DOMKeyboardEvent_get_ctrlKey,
2032 DOMKeyboardEvent_get_shiftKey,
2033 DOMKeyboardEvent_get_altKey,
2034 DOMKeyboardEvent_get_metaKey,
2035 DOMKeyboardEvent_get_repeat,
2036 DOMKeyboardEvent_getModifierState,
2037 DOMKeyboardEvent_initKeyboardEvent,
2038 DOMKeyboardEvent_get_keyCode,
2039 DOMKeyboardEvent_get_charCode,
2040 DOMKeyboardEvent_get_which,
2041 DOMKeyboardEvent_get_char,
2042 DOMKeyboardEvent_get_locale
2043 };
2044
2045 static const tid_t DOMEvent_iface_tids[] = {
2046 IDOMEvent_tid,
2047 0
2048 };
2049
2050 static dispex_static_data_t DOMEvent_dispex = {
2051 NULL,
2052 DispDOMEvent_tid,
2053 DOMEvent_iface_tids
2054 };
2055
2056 static const tid_t DOMUIEvent_iface_tids[] = {
2057 IDOMEvent_tid,
2058 IDOMUIEvent_tid,
2059 0
2060 };
2061
2062 static dispex_static_data_t DOMUIEvent_dispex = {
2063 NULL,
2064 DispDOMUIEvent_tid,
2065 DOMUIEvent_iface_tids
2066 };
2067
2068 static const tid_t DOMMouseEvent_iface_tids[] = {
2069 IDOMEvent_tid,
2070 IDOMUIEvent_tid,
2071 IDOMMouseEvent_tid,
2072 0
2073 };
2074
2075 static dispex_static_data_t DOMMouseEvent_dispex = {
2076 NULL,
2077 DispDOMMouseEvent_tid,
2078 DOMMouseEvent_iface_tids
2079 };
2080
2081 static const tid_t DOMKeyboardEvent_iface_tids[] = {
2082 IDOMEvent_tid,
2083 IDOMUIEvent_tid,
2084 IDOMKeyboardEvent_tid,
2085 0
2086 };
2087
2088 static dispex_static_data_t DOMKeyboardEvent_dispex = {
2089 NULL,
2090 DispDOMKeyboardEvent_tid,
2091 DOMKeyboardEvent_iface_tids
2092 };
2093
2094 static DOMEvent *alloc_event(nsIDOMEvent *nsevent, eventid_t event_id)
2095 {
2096 dispex_static_data_t *dispex_data = &DOMEvent_dispex;
2097 DOMEvent *event;
2098 FILETIME time;
2099 nsresult nsres;
2100
2101 /* 1601 to 1970 is 369 years plus 89 leap days */
2102 const ULONGLONG time_epoch = (ULONGLONG)(369 * 365 + 89) * 86400 * 1000;
2103
2104 event = heap_alloc_zero(sizeof(*event));
2105 if(!event)
2106 return NULL;
2107
2108 event->IDOMEvent_iface.lpVtbl = &DOMEventVtbl;
2109 event->IDOMUIEvent_iface.lpVtbl = &DOMUIEventVtbl;
2110 event->IDOMMouseEvent_iface.lpVtbl = &DOMMouseEventVtbl;
2111 event->IDOMKeyboardEvent_iface.lpVtbl = &DOMKeyboardEventVtbl;
2112 event->ref = 1;
2113 event->event_id = event_id;
2114 if(event_id != EVENTID_LAST) {
2115 event->type = heap_strdupW(event_info[event_id].name);
2116 if(!event->type) {
2117 heap_free(event);
2118 return NULL;
2119 }
2120 event->bubbles = (event_info[event_id].flags & EVENT_BUBBLES) != 0;
2121 event->cancelable = (event_info[event_id].flags & EVENT_CANCELABLE) != 0;
2122 }
2123 nsIDOMEvent_AddRef(event->nsevent = nsevent);
2124
2125 GetSystemTimeAsFileTime(&time);
2126 event->time_stamp = (((ULONGLONG)time.dwHighDateTime<<32) + time.dwLowDateTime) / 10000
2127 - time_epoch;
2128
2129 nsres = nsIDOMEvent_QueryInterface(nsevent, &IID_nsIDOMUIEvent, (void**)&event->ui_event);
2130 if(NS_SUCCEEDED(nsres))
2131 dispex_data = &DOMUIEvent_dispex;
2132 else
2133 event->ui_event = NULL;
2134
2135 nsres = nsIDOMEvent_QueryInterface(nsevent, &IID_nsIDOMMouseEvent, (void**)&event->mouse_event);
2136 if(NS_SUCCEEDED(nsres))
2137 dispex_data = &DOMMouseEvent_dispex;
2138 else
2139 event->mouse_event = NULL;
2140
2141 nsres = nsIDOMEvent_QueryInterface(nsevent, &IID_nsIDOMKeyEvent, (void**)&event->keyboard_event);
2142 if(NS_SUCCEEDED(nsres))
2143 dispex_data = &DOMKeyboardEvent_dispex;
2144 else
2145 event->keyboard_event = NULL;
2146
2147 init_dispex(&event->dispex, (IUnknown*)&event->IDOMEvent_iface, dispex_data);
2148 return event;
2149 }
2150
2151 HRESULT create_event_from_nsevent(nsIDOMEvent *nsevent, DOMEvent **ret_event)
2152 {
2153 eventid_t event_id = EVENTID_LAST;
2154 DOMEvent *event;
2155 nsAString nsstr;
2156 nsresult nsres;
2157
2158 nsAString_Init(&nsstr, NULL);
2159 nsres = nsIDOMEvent_GetType(nsevent, &nsstr);
2160 if(NS_SUCCEEDED(nsres)) {
2161 const WCHAR *type;
2162 nsAString_GetData(&nsstr, &type);
2163 event_id = str_to_eid(type);
2164 if(event_id == EVENTID_LAST)
2165 FIXME("unknown event type %s\n", debugstr_w(type));
2166 }else {
2167 ERR("GetType failed: %08x\n", nsres);
2168 }
2169 nsAString_Finish(&nsstr);
2170
2171 event = alloc_event(nsevent, event_id);
2172 if(!event)
2173 return E_OUTOFMEMORY;
2174
2175 *ret_event = event;
2176 return S_OK;
2177 }
2178
2179 HRESULT create_document_event_str(HTMLDocumentNode *doc, const WCHAR *type, IDOMEvent **ret_event)
2180 {
2181 nsIDOMEvent *nsevent;
2182 DOMEvent *event;
2183 nsAString nsstr;
2184 nsresult nsres;
2185
2186 nsAString_InitDepend(&nsstr, type);
2187 nsres = nsIDOMHTMLDocument_CreateEvent(doc->nsdoc, &nsstr, &nsevent);
2188 nsAString_Finish(&nsstr);
2189 if(NS_FAILED(nsres)) {
2190 FIXME("CreateEvent(%s) failed: %08x\n", debugstr_w(type), nsres);
2191 return E_FAIL;
2192 }
2193
2194 event = alloc_event(nsevent, EVENTID_LAST);
2195 nsIDOMEvent_Release(nsevent);
2196 if(!event)
2197 return E_OUTOFMEMORY;
2198
2199 *ret_event = &event->IDOMEvent_iface;
2200 return S_OK;
2201 }
2202
2203 HRESULT create_document_event(HTMLDocumentNode *doc, eventid_t event_id, DOMEvent **ret_event)
2204 {
2205 nsIDOMEvent *nsevent;
2206 DOMEvent *event;
2207 nsAString nsstr;
2208 nsresult nsres;
2209
2210 nsAString_InitDepend(&nsstr, event_types[event_info[event_id].type]);
2211 nsres = nsIDOMHTMLDocument_CreateEvent(doc->nsdoc, &nsstr, &nsevent);
2212 nsAString_Finish(&nsstr);
2213 if(NS_FAILED(nsres)) {
2214 FIXME("CreateEvent(%s) failed: %08x\n", debugstr_w(event_types[event_info[event_id].type]), nsres);
2215 return E_FAIL;
2216 }
2217
2218 event = alloc_event(nsevent, event_id);
2219 if(!event)
2220 return E_OUTOFMEMORY;
2221
2222 event->event_id = event_id;
2223 *ret_event = event;
2224 return S_OK;
2225 }
2226
2227 static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv)
2228 {
2229 IDispatchEx *dispex;
2230 EXCEPINFO ei;
2231 HRESULT hres;
2232
2233 memset(&ei, 0, sizeof(ei));
2234
2235 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
2236 if(SUCCEEDED(hres)) {
2237 hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL);
2238 IDispatchEx_Release(dispex);
2239 }else {
2240 TRACE("Could not get IDispatchEx interface: %08x\n", hres);
2241 hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,
2242 dp, retv, &ei, NULL);
2243 }
2244
2245 return hres;
2246 }
2247
2248 static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, IHTMLEventObj *event_obj, VARIANT *retv)
2249 {
2250 DISPPARAMS dp = {NULL,NULL,0,0};
2251 VARIANT event_arg;
2252 ULONG argerr;
2253 EXCEPINFO ei;
2254
2255 if(event_obj) {
2256 V_VT(&event_arg) = VT_DISPATCH;
2257 V_DISPATCH(&event_arg) = (IDispatch*)event_obj;
2258 dp.rgvarg = &event_arg;
2259 dp.cArgs = 1;
2260 }
2261
2262 memset(&ei, 0, sizeof(ei));
2263 return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr);
2264 }
2265
2266 static BOOL use_event_quirks(EventTarget *event_target)
2267 {
2268 return dispex_compat_mode(&event_target->dispex) < COMPAT_MODE_IE9;
2269 }
2270
2271 static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid)
2272 {
2273 int min, max, i;
2274 HRESULT hres;
2275
2276 if(!data || dispid == DISPID_UNKNOWN)
2277 return FALSE;
2278
2279 if(!data->ids) {
2280 hres = get_dispids(data->tid, &data->id_cnt, &data->ids);
2281 if(FAILED(hres))
2282 return FALSE;
2283 }
2284
2285 min = 0;
2286 max = data->id_cnt-1;
2287 while(min <= max) {
2288 i = (min+max)/2;
2289 if(data->ids[i] == dispid)
2290 return TRUE;
2291
2292 if(data->ids[i] < dispid)
2293 min = i+1;
2294 else
2295 max = i-1;
2296 }
2297
2298 return FALSE;
2299 }
2300
2301 static void call_event_handlers(EventTarget *event_target, DOMEvent *event, dispatch_mode_t dispatch_mode)
2302 {
2303 const listener_container_t *container = get_listener_container(event_target, event->type, FALSE);
2304 event_listener_t *listener, listeners_buf[8], *listeners = listeners_buf;
2305 unsigned listeners_cnt, listeners_size;
2306 ConnectionPointContainer *cp_container = NULL;
2307 const event_target_vtbl_t *vtbl = NULL;
2308 BOOL skip_onevent_listener = FALSE;
2309 VARIANT v;
2310 HRESULT hres;
2311
2312 assert(!event->current_target);
2313 event->current_target = event_target;
2314
2315 if(container && !list_empty(&container->listeners) && event->phase != DEP_CAPTURING_PHASE) {
2316 listener = LIST_ENTRY(list_tail(&container->listeners), event_listener_t, entry);
2317 if(listener && listener->function && listener->type == LISTENER_TYPE_ONEVENT
2318 && use_event_quirks(event_target)) {
2319 DISPID named_arg = DISPID_THIS;
2320 VARIANTARG arg;
2321 DISPPARAMS dp = {&arg, &named_arg, 1, 1};
2322
2323 skip_onevent_listener = TRUE;
2324
2325 V_VT(&arg) = VT_DISPATCH;
2326 V_DISPATCH(&arg) = (IDispatch*)&event_target->dispex.IDispatchEx_iface;
2327 V_VT(&v) = VT_EMPTY;
2328
2329 TRACE("%s >>>\n", debugstr_w(event->type));
2330 hres = call_disp_func(listener->function, &dp, &v);
2331 if(hres == S_OK) {
2332 TRACE("%s <<< %s\n", debugstr_w(event->type), debugstr_variant(&v));
2333
2334 if(event->cancelable) {
2335 if(V_VT(&v) == VT_BOOL) {
2336 if(!V_BOOL(&v))
2337 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
2338 }else if(V_VT(&v) != VT_EMPTY) {
2339 FIXME("unhandled result %s\n", debugstr_variant(&v));
2340 }
2341 }
2342 VariantClear(&v);
2343 }else {
2344 WARN("%s <<< %08x\n", debugstr_w(event->type), hres);
2345 }
2346 }
2347 }
2348
2349 listeners_cnt = 0;
2350 listeners_size = ARRAY_SIZE(listeners_buf);
2351
2352 if(container) {
2353 LIST_FOR_EACH_ENTRY(listener, &container->listeners, event_listener_t, entry) {
2354 if(!listener->function)
2355 continue;
2356 switch(listener->type) {
2357 case LISTENER_TYPE_ONEVENT:
2358 if(skip_onevent_listener || event->phase == DEP_CAPTURING_PHASE)
2359 continue;
2360 break;
2361 case LISTENER_TYPE_CAPTURE:
2362 if(event->phase == DEP_BUBBLING_PHASE || dispatch_mode == DISPATCH_LEGACY)
2363 continue;
2364 break;
2365 case LISTENER_TYPE_BUBBLE:
2366 if(event->phase == DEP_CAPTURING_PHASE || dispatch_mode == DISPATCH_LEGACY)
2367 continue;
2368 break;
2369 case LISTENER_TYPE_ATTACHED:
2370 if(event->phase == DEP_CAPTURING_PHASE || dispatch_mode == DISPATCH_STANDARD)
2371 continue;
2372 break;
2373 }
2374
2375 if(listeners_cnt == listeners_size) {
2376 event_listener_t *new_listeners;
2377 if(listeners == listeners_buf) {
2378 new_listeners = heap_alloc(listeners_size * 2 * sizeof(*new_listeners));
2379 if(!new_listeners)
2380 break;
2381 memcpy(new_listeners, listeners, listeners_cnt * sizeof(*listeners));
2382 }else {
2383 new_listeners = heap_realloc(listeners, listeners_size * 2 * sizeof(*new_listeners));
2384 }
2385 listeners = new_listeners;
2386 listeners_size *= 2;
2387 }
2388
2389 listeners[listeners_cnt].type = listener->type;
2390 IDispatch_AddRef(listeners[listeners_cnt].function = listener->function);
2391 listeners_cnt++;
2392 }
2393 }
2394
2395 for(listener = listeners; !event->stop_immediate_propagation
2396 && listener < listeners + listeners_cnt; listener++) {
2397 if(listener->type != LISTENER_TYPE_ATTACHED) {
2398 DISPID named_arg = DISPID_THIS;
2399 VARIANTARG args[2];
2400 DISPPARAMS dp = {args, &named_arg, 2, 1};
2401
2402 V_VT(args) = VT_DISPATCH;
2403 V_DISPATCH(args) = (IDispatch*)&event_target->dispex.IDispatchEx_iface;
2404 V_VT(args+1) = VT_DISPATCH;
2405 V_DISPATCH(args+1) = dispatch_mode == DISPATCH_LEGACY
2406 ? (IDispatch*)event->event_obj : (IDispatch*)&event->IDOMEvent_iface;
2407 V_VT(&v) = VT_EMPTY;
2408
2409 TRACE("%s >>>\n", debugstr_w(event->type));
2410 hres = call_disp_func(listener->function, &dp, &v);
2411 if(hres == S_OK) {
2412 TRACE("%s <<< %s\n", debugstr_w(event->type),
2413 debugstr_variant(&v));
2414
2415 if(event->cancelable) {
2416 if(V_VT(&v) == VT_BOOL) {
2417 if(!V_BOOL(&v))
2418 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
2419 }else if(V_VT(&v) != VT_EMPTY) {
2420 FIXME("unhandled result %s\n", debugstr_variant(&v));
2421 }
2422 }
2423 VariantClear(&v);
2424 }else {
2425 WARN("%s <<< %08x\n", debugstr_w(event->type), hres);
2426 }
2427 }else {
2428 VARIANTARG arg;
2429 DISPPARAMS dp = {&arg, NULL, 1, 0};
2430
2431 V_VT(&arg) = VT_DISPATCH;
2432 V_DISPATCH(&arg) = (IDispatch*)event->event_obj;
2433 V_VT(&v) = VT_EMPTY;
2434
2435 TRACE("%s attached >>>\n", debugstr_w(event->type));
2436 hres = call_disp_func(listener->function, &dp, &v);
2437 if(hres == S_OK) {
2438 TRACE("%s attached <<<\n", debugstr_w(event->type));
2439
2440 if(event->cancelable) {
2441 if(V_VT(&v) == VT_BOOL) {
2442 if(!V_BOOL(&v))
2443 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
2444 }else if(V_VT(&v) != VT_EMPTY) {
2445 FIXME("unhandled result %s\n", debugstr_variant(&v));
2446 }
2447 }
2448 VariantClear(&v);
2449 }else {
2450 WARN("%s attached <<< %08x\n", debugstr_w(event->type), hres);
2451 }
2452 }
2453 }
2454
2455 for(listener = listeners; listener < listeners + listeners_cnt; listener++)
2456 IDispatch_Release(listener->function);
2457 if(listeners != listeners_buf)
2458 heap_free(listeners);
2459
2460 if(event->phase != DEP_CAPTURING_PHASE && event->event_id != EVENTID_LAST
2461 && event_info[event->event_id].dispid && (vtbl = dispex_get_vtbl(&event_target->dispex))
2462 && vtbl->get_cp_container)
2463 cp_container = vtbl->get_cp_container(&event_target->dispex);
2464 if(cp_container) {
2465 if(cp_container->cps) {
2466 ConnectionPoint *cp;
2467 unsigned i, j;
2468
2469 for(j=0; cp_container->cp_entries[j].riid; j++) {
2470 cp = cp_container->cps + j;
2471 if(!cp->sinks_size || !is_cp_event(cp->data, event_info[event->event_id].dispid))
2472 continue;
2473
2474 for(i=0; i < cp->sinks_size; i++) {
2475 if(!cp->sinks[i].disp)
2476 continue;
2477
2478 V_VT(&v) = VT_EMPTY;
2479
2480 TRACE("cp %s [%u] >>>\n", debugstr_w(event->type), i);
2481 hres = call_cp_func(cp->sinks[i].disp, event_info[event->event_id].dispid,
2482 cp->data->pass_event_arg ? event->event_obj : NULL, &v);
2483 if(hres == S_OK) {
2484 TRACE("cp %s [%u] <<<\n", debugstr_w(event->type), i);
2485
2486 if(event->cancelable) {
2487 if(V_VT(&v) == VT_BOOL) {
2488 if(!V_BOOL(&v))
2489 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
2490 }else if(V_VT(&v) != VT_EMPTY) {
2491 FIXME("unhandled result %s\n", debugstr_variant(&v));
2492 }
2493 }
2494 VariantClear(&v);
2495 }else {
2496 WARN("cp %s [%u] <<< %08x\n", debugstr_w(event->type), i, hres);
2497 }
2498 }
2499 }
2500 }
2501 IConnectionPointContainer_Release(&cp_container->IConnectionPointContainer_iface);
2502 }
2503
2504 event->current_target = NULL;
2505 }
2506
2507 static HRESULT dispatch_event_object(EventTarget *event_target, DOMEvent *event,
2508 dispatch_mode_t dispatch_mode, VARIANT_BOOL *r)
2509 {
2510 EventTarget *target_chain_buf[8], **target_chain = target_chain_buf;
2511 unsigned chain_cnt, chain_buf_size, i;
2512 const event_target_vtbl_t *vtbl, *target_vtbl;
2513 HTMLEventObj *event_obj_ref = NULL;
2514 IHTMLEventObj *prev_event = NULL;
2515 EventTarget *iter;
2516 HRESULT hres;
2517
2518 TRACE("(%p) %s\n", event_target, debugstr_w(event->type));
2519
2520 if(!event->type) {
2521 FIXME("Uninitialized event.\n");
2522 return E_FAIL;
2523 }
2524
2525 if(event->current_target) {
2526 FIXME("event is being dispatched.\n");
2527 return E_FAIL;
2528 }
2529
2530 iter = event_target;
2531 IEventTarget_AddRef(&event_target->IEventTarget_iface);
2532
2533 chain_cnt = 0;
2534 chain_buf_size = ARRAY_SIZE(target_chain_buf);
2535
2536 do {
2537 if(chain_cnt == chain_buf_size) {
2538 EventTarget **new_chain;
2539 if(target_chain == target_chain_buf) {
2540 new_chain = heap_alloc(chain_buf_size * 2 * sizeof(*new_chain));
2541 if(!new_chain)
2542 break;
2543 memcpy(new_chain, target_chain, chain_buf_size * sizeof(*new_chain));
2544 }else {
2545 new_chain = heap_realloc(target_chain, chain_buf_size * 2 * sizeof(*new_chain));
2546 if(!new_chain)
2547 break;
2548 }
2549 chain_buf_size *= 2;
2550 target_chain = new_chain;
2551 }
2552
2553 target_chain[chain_cnt++] = iter;
2554
2555 if(!(vtbl = dispex_get_vtbl(&iter->dispex)) || !vtbl->get_parent_event_target)
2556 break;
2557 iter = vtbl->get_parent_event_target(&iter->dispex);
2558 } while(iter);
2559
2560 if(!event->event_obj && !event->no_event_obj) {
2561 event_obj_ref = alloc_event_obj(event);
2562 if(event_obj_ref)
2563 event->event_obj = &event_obj_ref->IHTMLEventObj_iface;
2564 }
2565
2566 target_vtbl = dispex_get_vtbl(&event_target->dispex);
2567 if(target_vtbl && target_vtbl->set_current_event)
2568 prev_event = target_vtbl->set_current_event(&event_target->dispex, event->event_obj);
2569
2570 if(event->target)
2571 IEventTarget_Release(&event->target->IEventTarget_iface);
2572 event->target = event_target;
2573 IEventTarget_AddRef(&event_target->IEventTarget_iface);
2574
2575 event->phase = DEP_CAPTURING_PHASE;
2576 i = chain_cnt-1;
2577 while(!event->stop_propagation && i)
2578 call_event_handlers(target_chain[i--], event, dispatch_mode);
2579
2580 if(!event->stop_propagation) {
2581 event->phase = DEP_AT_TARGET;
2582 call_event_handlers(target_chain[0], event, dispatch_mode);
2583 }
2584
2585 if(event->bubbles) {
2586 event->phase = DEP_BUBBLING_PHASE;
2587 for(i = 1; !event->stop_propagation && i < chain_cnt; i++)
2588 call_event_handlers(target_chain[i], event, dispatch_mode);
2589 }
2590
2591 if(r)
2592 *r = variant_bool(!event->prevent_default);
2593
2594 if(target_vtbl && target_vtbl->set_current_event) {
2595 prev_event = target_vtbl->set_current_event(&event_target->dispex, prev_event);
2596 if(prev_event)
2597 IHTMLEventObj_Release(prev_event);
2598 }
2599
2600 if(event->event_id != EVENTID_LAST && (event_info[event->event_id].flags & EVENT_HASDEFAULTHANDLERS)) {
2601 BOOL prevent_default = event->prevent_default;
2602 for(i = 0; !prevent_default && i < chain_cnt; i++) {
2603 vtbl = dispex_get_vtbl(&target_chain[i]->dispex);
2604 if(!vtbl || !vtbl->handle_event_default)
2605 continue;
2606 hres = vtbl->handle_event_default(&event_target->dispex, event->event_id,
2607 event->nsevent, &prevent_default);
2608 if(FAILED(hres) || event->stop_propagation)
2609 break;
2610 if(prevent_default)
2611 nsIDOMEvent_PreventDefault(event->nsevent);
2612 }
2613 }
2614
2615 event->prevent_default = FALSE;
2616 if(event_obj_ref) {
2617 event->event_obj = NULL;
2618 IHTMLEventObj_Release(&event_obj_ref->IHTMLEventObj_iface);
2619 }
2620
2621 for(i = 0; i < chain_cnt; i++)
2622 IEventTarget_Release(&target_chain[i]->IEventTarget_iface);
2623 if(target_chain != target_chain_buf)
2624 heap_free(target_chain);
2625
2626 return S_OK;
2627 }
2628
2629 void dispatch_event(EventTarget *event_target, DOMEvent *event)
2630 {
2631 dispatch_event_object(event_target, event, DISPATCH_BOTH, NULL);
2632
2633 /*
2634 * We may have registered multiple Gecko listeners for the same event type,
2635 * but we already dispatched event to all relevant targets. Stop event
2636 * propagation here to avoid events being dispatched multiple times.
2637 */
2638 if(event->event_id != EVENTID_LAST && (event_info[event->event_id].flags & EVENT_BIND_TO_TARGET))
2639 nsIDOMEvent_StopPropagation(event->nsevent);
2640 }
2641
2642 HRESULT fire_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_var, VARIANT_BOOL *cancelled)
2643 {
2644 HTMLEventObj *event_obj = NULL;
2645 eventid_t eid;
2646 HRESULT hres = S_OK;
2647
2648 eid = attr_to_eid(event_name);
2649 if(eid == EVENTID_LAST) {
2650 WARN("unknown event %s\n", debugstr_w(event_name));
2651 return E_INVALIDARG;
2652 }
2653
2654 if(event_var && V_VT(event_var) != VT_EMPTY && V_VT(event_var) != VT_ERROR) {
2655 if(V_VT(event_var) != VT_DISPATCH) {
2656 FIXME("event_var %s not supported\n", debugstr_variant(event_var));
2657 return E_NOTIMPL;
2658 }
2659
2660 if(V_DISPATCH(event_var)) {
2661 IHTMLEventObj *event_iface;
2662
2663 hres = IDispatch_QueryInterface(V_DISPATCH(event_var), &IID_IHTMLEventObj, (void**)&event_iface);
2664 if(FAILED(hres)) {
2665 FIXME("No IHTMLEventObj iface\n");
2666 return hres;
2667 }
2668
2669 event_obj = unsafe_impl_from_IHTMLEventObj(event_iface);
2670 if(!event_obj) {
2671 ERR("Not our IHTMLEventObj?\n");
2672 IHTMLEventObj_Release(event_iface);
2673 return E_FAIL;
2674 }
2675 }
2676 }
2677
2678 if(!event_obj) {
2679 event_obj = alloc_event_obj(NULL);
2680 if(!event_obj)
2681 return E_OUTOFMEMORY;
2682 }
2683
2684 if(!event_obj->event)
2685 hres = create_document_event(node->doc, eid, &event_obj->event);
2686
2687 if(SUCCEEDED(hres)) {
2688 event_obj->event->event_obj = &event_obj->IHTMLEventObj_iface;
2689 dispatch_event_object(&node->event_target, event_obj->event, DISPATCH_LEGACY, NULL);
2690 event_obj->event->event_obj = NULL;
2691 }
2692
2693 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
2694 if(FAILED(hres))
2695 return hres;
2696
2697 *cancelled = VARIANT_TRUE; /* FIXME */
2698 return S_OK;
2699 }
2700
2701 HRESULT ensure_doc_nsevent_handler(HTMLDocumentNode *doc, nsIDOMNode *nsnode, eventid_t eid)
2702 {
2703 TRACE("%s\n", debugstr_w(event_info[eid].name));
2704
2705 if(!doc->nsdoc)
2706 return S_OK;
2707
2708 switch(eid) {
2709 case EVENTID_FOCUSIN:
2710 doc->event_vector[eid] = TRUE;
2711 eid = EVENTID_FOCUS;
2712 break;
2713 case EVENTID_FOCUSOUT:
2714 doc->event_vector[eid] = TRUE;
2715 eid = EVENTID_BLUR;
2716 break;
2717 default:
2718 break;
2719 }
2720
2721 if(event_info[eid].flags & EVENT_DEFAULTLISTENER) {
2722 nsnode = NULL;
2723 }else if(event_info[eid].flags & EVENT_BIND_TO_TARGET) {
2724 if(!nsnode)
2725 nsnode = doc->node.nsnode;
2726 }else {
2727 return S_OK;
2728 }
2729
2730 if(!nsnode || nsnode == doc->node.nsnode) {
2731 if(doc->event_vector[eid])
2732 return S_OK;
2733 doc->event_vector[eid] = TRUE;
2734 }
2735
2736 add_nsevent_listener(doc, nsnode, event_info[eid].name);
2737 return S_OK;
2738 }
2739
2740 void detach_events(HTMLDocumentNode *doc)
2741 {
2742 if(doc->event_vector) {
2743 int i;
2744
2745 for(i=0; i < EVENTID_LAST; i++) {
2746 if(doc->event_vector[i]) {
2747 detach_nsevent(doc, event_info[i].name);
2748 doc->event_vector[i] = FALSE;
2749 }
2750 }
2751 }
2752
2753 release_nsevents(doc);
2754 }
2755
2756 static HRESULT get_event_dispex_ref(EventTarget *event_target, eventid_t eid, BOOL alloc, VARIANT **ret)
2757 {
2758 WCHAR buf[64];
2759 buf[0] = 'o';
2760 buf[1] = 'n';
2761 strcpyW(buf+2, event_info[eid].name);
2762 return dispex_get_dprop_ref(&event_target->dispex, buf, alloc, ret);
2763 }
2764
2765 static event_listener_t *get_onevent_listener(EventTarget *event_target, eventid_t eid, BOOL alloc)
2766 {
2767 listener_container_t *container;
2768 event_listener_t *listener;
2769
2770 container = get_listener_container(event_target, event_info[eid].name, alloc);
2771 if(!container)
2772 return NULL;
2773
2774 LIST_FOR_EACH_ENTRY_REV(listener, &container->listeners, event_listener_t, entry) {
2775 if(listener->type == LISTENER_TYPE_ONEVENT)
2776 return listener;
2777 }
2778
2779 if(!alloc)
2780 return NULL;
2781
2782 listener = heap_alloc(sizeof(*listener));
2783 if(!listener)
2784 return NULL;
2785
2786 listener->type = LISTENER_TYPE_ONEVENT;
2787 listener->function = NULL;
2788 list_add_tail(&container->listeners, &listener->entry);
2789 return listener;
2790 }
2791
2792 static void remove_event_handler(EventTarget *event_target, eventid_t eid)
2793 {
2794 event_listener_t *listener;
2795 VARIANT *store;
2796 HRESULT hres;
2797
2798 hres = get_event_dispex_ref(event_target, eid, FALSE, &store);
2799 if(SUCCEEDED(hres))
2800 VariantClear(store);
2801
2802 listener = get_onevent_listener(event_target, eid, FALSE);
2803 if(listener && listener->function) {
2804 IDispatch_Release(listener->function);
2805 listener->function = NULL;
2806 }
2807 }
2808
2809 static HRESULT set_event_handler_disp(EventTarget *event_target, eventid_t eid, IDispatch *disp)
2810 {
2811 event_listener_t *listener;
2812
2813 if(event_info[eid].flags & EVENT_FIXME)
2814 FIXME("unimplemented event %s\n", debugstr_w(event_info[eid].name));
2815
2816 remove_event_handler(event_target, eid);
2817 if(!disp)
2818 return S_OK;
2819
2820 listener = get_onevent_listener(event_target, eid, TRUE);
2821 if(!listener)
2822 return E_OUTOFMEMORY;
2823
2824 if(listener->function)
2825 IDispatch_Release(listener->function);
2826
2827 IDispatch_AddRef(listener->function = disp);
2828 return S_OK;
2829 }
2830
2831 HRESULT set_event_handler(EventTarget *event_target, eventid_t eid, VARIANT *var)
2832 {
2833 switch(V_VT(var)) {
2834 case VT_EMPTY:
2835 if(use_event_quirks(event_target)) {
2836 WARN("attempt to set to VT_EMPTY in quirks mode\n");
2837 return E_NOTIMPL;
2838 }
2839 /* fall through */
2840 case VT_NULL:
2841 remove_event_handler(event_target, eid);
2842 return S_OK;
2843
2844 case VT_DISPATCH:
2845 return set_event_handler_disp(event_target, eid, V_DISPATCH(var));
2846
2847 case VT_BSTR: {
2848 VARIANT *v;
2849 HRESULT hres;
2850
2851 if(!use_event_quirks(event_target))
2852 FIXME("Setting to string %s not supported\n", debugstr_w(V_BSTR(var)));
2853
2854 /*
2855 * Setting event handler to string is a rare case and we don't want to
2856 * complicate nor increase memory of listener_container_t for that. Instead,
2857 * we store the value in DispatchEx, which can already handle custom
2858 * properties.
2859 */
2860 remove_event_handler(event_target, eid);
2861
2862 hres = get_event_dispex_ref(event_target, eid, TRUE, &v);
2863 if(FAILED(hres))
2864 return hres;
2865
2866 V_BSTR(v) = SysAllocString(V_BSTR(var));
2867 if(!V_BSTR(v))
2868 return E_OUTOFMEMORY;
2869 V_VT(v) = VT_BSTR;
2870 return S_OK;
2871 }
2872
2873 default:
2874 FIXME("not handler %s\n", debugstr_variant(var));
2875 return E_NOTIMPL;
2876 }
2877
2878 return S_OK;
2879 }
2880
2881 HRESULT get_event_handler(EventTarget *event_target, eventid_t eid, VARIANT *var)
2882 {
2883 event_listener_t *listener;
2884 VARIANT *v;
2885 HRESULT hres;
2886
2887 hres = get_event_dispex_ref(event_target, eid, FALSE, &v);
2888 if(SUCCEEDED(hres) && V_VT(v) != VT_EMPTY) {
2889 V_VT(var) = VT_EMPTY;
2890 return VariantCopy(var, v);
2891 }
2892
2893 listener = get_onevent_listener(event_target, eid, FALSE);
2894 if(listener && listener->function) {
2895 V_VT(var) = VT_DISPATCH;
2896 V_DISPATCH(var) = listener->function;
2897 IDispatch_AddRef(V_DISPATCH(var));
2898 }else {
2899 V_VT(var) = VT_NULL;
2900 }
2901
2902 return S_OK;
2903 }
2904
2905 HRESULT attach_event(EventTarget *event_target, BSTR name, IDispatch *disp, VARIANT_BOOL *res)
2906 {
2907 listener_container_t *container;
2908 event_listener_t *listener;
2909 eventid_t eid;
2910
2911 eid = attr_to_eid(name);
2912 if(eid == EVENTID_LAST) {
2913 WARN("Unknown event\n");
2914 *res = VARIANT_TRUE;
2915 return S_OK;
2916 }
2917
2918 container = get_listener_container(event_target, event_info[eid].name, TRUE);
2919 if(!container)
2920 return E_OUTOFMEMORY;
2921
2922 listener = heap_alloc(sizeof(*listener));
2923 if(!listener)
2924 return E_OUTOFMEMORY;
2925
2926 listener->type = LISTENER_TYPE_ATTACHED;
2927 IDispatch_AddRef(listener->function = disp);
2928 if(use_event_quirks(event_target))
2929 list_add_head(&container->listeners, &listener->entry);
2930 else
2931 list_add_tail(&container->listeners, &listener->entry);
2932
2933 *res = VARIANT_TRUE;
2934 return S_OK;
2935 }
2936
2937 HRESULT detach_event(EventTarget *event_target, BSTR name, IDispatch *disp)
2938 {
2939 eventid_t eid;
2940
2941 eid = attr_to_eid(name);
2942 if(eid == EVENTID_LAST) {
2943 WARN("Unknown event\n");
2944 return S_OK;
2945 }
2946
2947 remove_event_listener(event_target, event_info[eid].name, LISTENER_TYPE_ATTACHED, disp);
2948 return S_OK;
2949 }
2950
2951 void bind_target_event(HTMLDocumentNode *doc, EventTarget *event_target, const WCHAR *event, IDispatch *disp)
2952 {
2953 eventid_t eid;
2954
2955 TRACE("(%p %p %s %p)\n", doc, event_target, debugstr_w(event), disp);
2956
2957 eid = attr_to_eid(event);
2958 if(eid == EVENTID_LAST) {
2959 WARN("Unsupported event %s\n", debugstr_w(event));
2960 return;
2961 }
2962
2963 set_event_handler_disp(event_target, eid, disp);
2964 }
2965
2966 void update_doc_cp_events(HTMLDocumentNode *doc, cp_static_data_t *cp)
2967 {
2968 int i;
2969
2970 for(i=0; i < EVENTID_LAST; i++) {
2971 if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
2972 ensure_doc_nsevent_handler(doc, NULL, i);
2973 }
2974 }
2975
2976 void check_event_attr(HTMLDocumentNode *doc, nsIDOMElement *nselem)
2977 {
2978 nsIDOMMozNamedAttrMap *attr_map;
2979 const PRUnichar *name, *value;
2980 nsAString name_str, value_str;
2981 HTMLDOMNode *node = NULL;
2982 cpp_bool has_attrs;
2983 nsIDOMAttr *attr;
2984 IDispatch *disp;
2985 UINT32 length, i;
2986 eventid_t eid;
2987 nsresult nsres;
2988 HRESULT hres;
2989
2990 nsres = nsIDOMElement_HasAttributes(nselem, &has_attrs);
2991 if(NS_FAILED(nsres) || !has_attrs)
2992 return;
2993
2994 nsres = nsIDOMElement_GetAttributes(nselem, &attr_map);
2995 if(NS_FAILED(nsres))
2996 return;
2997
2998 nsres = nsIDOMMozNamedAttrMap_GetLength(attr_map, &length);
2999 assert(nsres == NS_OK);
3000
3001 nsAString_Init(&name_str, NULL);
3002 nsAString_Init(&value_str, NULL);
3003
3004 for(i = 0; i < length; i++) {
3005 nsres = nsIDOMMozNamedAttrMap_Item(attr_map, i, &attr);
3006 if(NS_FAILED(nsres))
3007 continue;
3008
3009 nsres = nsIDOMAttr_GetName(attr, &name_str);
3010 if(NS_FAILED(nsres)) {
3011 nsIDOMAttr_Release(attr);
3012 continue;
3013 }
3014
3015 nsAString_GetData(&name_str, &name);
3016 eid = attr_to_eid(name);
3017 if(eid == EVENTID_LAST) {
3018 nsIDOMAttr_Release(attr);
3019 continue;
3020 }
3021
3022 nsres = nsIDOMAttr_GetValue(attr, &value_str);
3023 nsIDOMAttr_Release(attr);
3024 if(NS_FAILED(nsres))
3025 continue;
3026
3027 nsAString_GetData(&value_str, &value);
3028 if(!*value)
3029 continue;
3030
3031 TRACE("%p.%s = %s\n", nselem, debugstr_w(name), debugstr_w(value));
3032
3033 disp = script_parse_event(doc->window, value);
3034 if(!disp)
3035 continue;
3036
3037 if(!node) {
3038 hres = get_node((nsIDOMNode*)nselem, TRUE, &node);
3039 if(FAILED(hres)) {
3040 IDispatch_Release(disp);
3041 break;
3042 }
3043 }
3044
3045 set_event_handler_disp(get_node_event_prop_target(node, eid), eid, disp);
3046 IDispatch_Release(disp);
3047 }
3048
3049 if(node)
3050 node_release(node);
3051 nsAString_Finish(&name_str);
3052 nsAString_Finish(&value_str);
3053 nsIDOMMozNamedAttrMap_Release(attr_map);
3054 }
3055
3056 HRESULT doc_init_events(HTMLDocumentNode *doc)
3057 {
3058 unsigned i;
3059 HRESULT hres;
3060
3061 doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
3062 if(!doc->event_vector)
3063 return E_OUTOFMEMORY;
3064
3065 init_nsevents(doc);
3066
3067 for(i=0; i < EVENTID_LAST; i++) {
3068 if(event_info[i].flags & EVENT_HASDEFAULTHANDLERS) {
3069 hres = ensure_doc_nsevent_handler(doc, NULL, i);
3070 if(FAILED(hres))
3071 return hres;
3072 }
3073 }
3074
3075 return S_OK;
3076 }
3077
3078 static inline EventTarget *impl_from_IEventTarget(IEventTarget *iface)
3079 {
3080 return CONTAINING_RECORD(iface, EventTarget, IEventTarget_iface);
3081 }
3082
3083 static HRESULT WINAPI EventTarget_QueryInterface(IEventTarget *iface, REFIID riid, void **ppv)
3084 {
3085 EventTarget *This = impl_from_IEventTarget(iface);
3086 return IDispatchEx_QueryInterface(&This->dispex.IDispatchEx_iface, riid, ppv);
3087 }
3088
3089 static ULONG WINAPI EventTarget_AddRef(IEventTarget *iface)
3090 {
3091 EventTarget *This = impl_from_IEventTarget(iface);
3092 return IDispatchEx_AddRef(&This->dispex.IDispatchEx_iface);
3093 }
3094
3095 static ULONG WINAPI EventTarget_Release(IEventTarget *iface)
3096 {
3097 EventTarget *This = impl_from_IEventTarget(iface);
3098 return IDispatchEx_Release(&This->dispex.IDispatchEx_iface);
3099 }
3100
3101 static HRESULT WINAPI EventTarget_GetTypeInfoCount(IEventTarget *iface, UINT *pctinfo)
3102 {
3103 EventTarget *This = impl_from_IEventTarget(iface);
3104 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
3105 }
3106
3107 static HRESULT WINAPI EventTarget_GetTypeInfo(IEventTarget *iface, UINT iTInfo,
3108 LCID lcid, ITypeInfo **ppTInfo)
3109 {
3110 EventTarget *This = impl_from_IEventTarget(iface);
3111 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3112 }
3113
3114 static HRESULT WINAPI EventTarget_GetIDsOfNames(IEventTarget *iface, REFIID riid, LPOLESTR *rgszNames,
3115 UINT cNames, LCID lcid, DISPID *rgDispId)
3116 {
3117 EventTarget *This = impl_from_IEventTarget(iface);
3118 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid,
3119 rgszNames, cNames, lcid, rgDispId);
3120 }
3121
3122 static HRESULT WINAPI EventTarget_Invoke(IEventTarget *iface, DISPID dispIdMember,
3123 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3124 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3125 {
3126 EventTarget *This = impl_from_IEventTarget(iface);
3127 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember,
3128 riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3129 }
3130
3131 static HRESULT WINAPI EventTarget_addEventListener(IEventTarget *iface, BSTR type,
3132 IDispatch *function, VARIANT_BOOL capture)
3133 {
3134 EventTarget *This = impl_from_IEventTarget(iface);
3135 listener_type_t listener_type = capture ? LISTENER_TYPE_CAPTURE : LISTENER_TYPE_BUBBLE;
3136 listener_container_t *container;
3137 event_listener_t *listener;
3138
3139 TRACE("(%p)->(%s %p %x)\n", This, debugstr_w(type), function, capture);
3140
3141 container = get_listener_container(This, type, TRUE);
3142 if(!container)
3143 return E_OUTOFMEMORY;
3144
3145 /* check for duplicates */
3146 LIST_FOR_EACH_ENTRY(listener, &container->listeners, event_listener_t, entry) {
3147 if(listener->type == listener_type && listener->function == function)
3148 return S_OK;
3149 }
3150
3151 listener = heap_alloc(sizeof(*listener));
3152 if(!listener)
3153 return E_OUTOFMEMORY;
3154
3155 listener->type = listener_type;
3156 IDispatch_AddRef(listener->function = function);
3157 list_add_tail(&container->listeners, &listener->entry);
3158 return S_OK;
3159 }
3160
3161 static HRESULT WINAPI EventTarget_removeEventListener(IEventTarget *iface, BSTR type,
3162 IDispatch *listener, VARIANT_BOOL capture)
3163 {
3164 EventTarget *This = impl_from_IEventTarget(iface);
3165
3166 TRACE("(%p)->(%s %p %x)\n", This, debugstr_w(type), listener, capture);
3167
3168 remove_event_listener(This, type, capture ? LISTENER_TYPE_CAPTURE : LISTENER_TYPE_BUBBLE, listener);
3169 return S_OK;
3170 }
3171
3172 static HRESULT WINAPI EventTarget_dispatchEvent(IEventTarget *iface, IDOMEvent *event_iface, VARIANT_BOOL *result)
3173 {
3174 EventTarget *This = impl_from_IEventTarget(iface);
3175 DOMEvent *event = unsafe_impl_from_IDOMEvent(event_iface);
3176
3177 TRACE("(%p)->(%p %p)\n", This, event, result);
3178
3179 if(!event) {
3180 WARN("Invalid event\n");
3181 return E_INVALIDARG;
3182 }
3183
3184 return dispatch_event_object(This, event, DISPATCH_STANDARD, result);
3185 }
3186
3187 static HRESULT IEventTarget_addEventListener_hook(DispatchEx *dispex, LCID lcid, WORD flags,
3188 DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
3189 {
3190 /* If only two arguments were given, implicitly set capture to false */
3191 if((flags & DISPATCH_METHOD) && dp->cArgs == 2 && !dp->cNamedArgs) {
3192 VARIANT args[3];
3193 DISPPARAMS new_dp = {args, NULL, 3, 0};
3194 V_VT(args) = VT_BOOL;
3195 V_BOOL(args) = VARIANT_FALSE;
3196 args[1] = dp->rgvarg[0];
3197 args[2] = dp->rgvarg[1];
3198
3199 TRACE("implicit capture\n");
3200
3201 return IDispatchEx_InvokeEx(&dispex->IDispatchEx_iface, DISPID_IEVENTTARGET_ADDEVENTLISTENER,
3202 lcid, flags, &new_dp, res, ei, caller);
3203 }
3204
3205 return S_FALSE; /* fallback to default */
3206 }
3207
3208 static HRESULT IEventTarget_removeEventListener_hook(DispatchEx *dispex, LCID lcid, WORD flags,
3209 DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
3210 {
3211 /* If only two arguments were given, implicitly set capture to false */
3212 if((flags & DISPATCH_METHOD) && dp->cArgs == 2 && !dp->cNamedArgs) {
3213 VARIANT args[3];
3214 DISPPARAMS new_dp = {args, NULL, 3, 0};
3215 V_VT(args) = VT_BOOL;
3216 V_BOOL(args) = VARIANT_FALSE;
3217 args[1] = dp->rgvarg[0];
3218 args[2] = dp->rgvarg[1];
3219
3220 TRACE("implicit capture\n");
3221
3222 return IDispatchEx_InvokeEx(&dispex->IDispatchEx_iface, DISPID_IEVENTTARGET_REMOVEEVENTLISTENER,
3223 lcid, flags, &new_dp, res, ei, caller);
3224 }
3225
3226 return S_FALSE; /* fallback to default */
3227 }
3228
3229 static const IEventTargetVtbl EventTargetVtbl = {
3230 EventTarget_QueryInterface,
3231 EventTarget_AddRef,
3232 EventTarget_Release,
3233 EventTarget_GetTypeInfoCount,
3234 EventTarget_GetTypeInfo,
3235 EventTarget_GetIDsOfNames,
3236 EventTarget_Invoke,
3237 EventTarget_addEventListener,
3238 EventTarget_removeEventListener,
3239 EventTarget_dispatchEvent
3240 };
3241
3242 static EventTarget *unsafe_impl_from_IEventTarget(IEventTarget *iface)
3243 {
3244 return iface && iface->lpVtbl == &EventTargetVtbl ? impl_from_IEventTarget(iface) : NULL;
3245 }
3246
3247 static HRESULT get_gecko_target(IEventTarget *target, nsIDOMEventTarget **ret)
3248 {
3249 EventTarget *event_target = unsafe_impl_from_IEventTarget(target);
3250 const event_target_vtbl_t *vtbl;
3251 nsresult nsres;
3252
3253 if(!event_target) {
3254 WARN("Not our IEventTarget implementation\n");
3255 return E_INVALIDARG;
3256 }
3257
3258 vtbl = (const event_target_vtbl_t*)dispex_get_vtbl(&event_target->dispex);
3259 nsres = nsISupports_QueryInterface(vtbl->get_gecko_target(&event_target->dispex),
3260 &IID_nsIDOMEventTarget, (void**)ret);
3261 assert(nsres == NS_OK);
3262 return S_OK;
3263 }
3264
3265 HRESULT EventTarget_QI(EventTarget *event_target, REFIID riid, void **ppv)
3266 {
3267 if(IsEqualGUID(riid, &IID_IEventTarget)) {
3268 if(use_event_quirks(event_target)) {
3269 WARN("IEventTarget queried, but not supported by in document mode\n");
3270 *ppv = NULL;
3271 return E_NOINTERFACE;
3272 }
3273 IEventTarget_AddRef(&event_target->IEventTarget_iface);
3274 *ppv = &event_target->IEventTarget_iface;
3275 return S_OK;
3276 }
3277
3278 if(dispex_query_interface(&event_target->dispex, riid, ppv))
3279 return *ppv ? S_OK : E_NOINTERFACE;
3280
3281 WARN("(%p)->(%s %p)\n", event_target, debugstr_mshtml_guid(riid), ppv);
3282 *ppv = NULL;
3283 return E_NOINTERFACE;
3284 }
3285
3286 void EventTarget_init_dispex_info(dispex_data_t *dispex_info, compat_mode_t compat_mode)
3287 {
3288 static const dispex_hook_t IEventTarget_hooks[] = {
3289 {DISPID_IEVENTTARGET_ADDEVENTLISTENER, IEventTarget_addEventListener_hook},
3290 {DISPID_IEVENTTARGET_REMOVEEVENTLISTENER, IEventTarget_removeEventListener_hook},
3291 {DISPID_UNKNOWN}
3292 };
3293
3294 if(compat_mode >= COMPAT_MODE_IE9)
3295 dispex_info_add_interface(dispex_info, IEventTarget_tid, IEventTarget_hooks);
3296 }
3297
3298 static int event_id_cmp(const void *key, const struct wine_rb_entry *entry)
3299 {
3300 return strcmpW(key, WINE_RB_ENTRY_VALUE(entry, listener_container_t, entry)->type);
3301 }
3302
3303 void EventTarget_Init(EventTarget *event_target, IUnknown *outer, dispex_static_data_t *dispex_data,
3304 compat_mode_t compat_mode)
3305 {
3306 init_dispex_with_compat_mode(&event_target->dispex, outer, dispex_data, compat_mode);
3307 event_target->IEventTarget_iface.lpVtbl = &EventTargetVtbl;
3308 wine_rb_init(&event_target->handler_map, event_id_cmp);
3309 }
3310
3311 void release_event_target(EventTarget *event_target)
3312 {
3313 listener_container_t *iter, *iter2;
3314
3315 WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR(iter, iter2, &event_target->handler_map, listener_container_t, entry) {
3316 while(!list_empty(&iter->listeners)) {
3317 event_listener_t *listener = LIST_ENTRY(list_head(&iter->listeners), event_listener_t, entry);
3318 if(listener->function)
3319 IDispatch_Release(listener->function);
3320 list_remove(&listener->entry);
3321 heap_free(listener);
3322 }
3323 heap_free(iter);
3324 }
3325 }
Windows API implementation