?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
imagehlp: Use the IMAGE_FIRST_SECTION helper macro.
[wine.git] / dlls / mshtml / htmlevent.c
blob87039167281b72da37aef2b73ef847de42c1e97b
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
21 #define COBJMACROS
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "ole2.h"
27 #include "mshtmdid.h"
28
29 #include "mshtml_private.h"
30 #include "htmlevent.h"
31 #include "htmlscript.h"
32
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
36
37 typedef enum {
38 LISTENER_TYPE_CAPTURE,
39 LISTENER_TYPE_BUBBLE,
40 LISTENER_TYPE_ONEVENT,
41 LISTENER_TYPE_ATTACHED
42 } listener_type_t;
43
44 typedef struct {
45 struct list entry;
46 listener_type_t type;
47 IDispatch *function;
48 } event_listener_t;
49
50 typedef struct {
51 struct wine_rb_entry entry;
52 struct list listeners;
53 WCHAR type[1];
54 } listener_container_t;
55
56 typedef enum {
57 DISPATCH_BOTH,
58 DISPATCH_STANDARD,
59 DISPATCH_LEGACY
60 } dispatch_mode_t;
61
62 /* Keep inherited event types after the inheritor (e.g. DragEvent->MouseEvent->UIEvent) */
63 typedef enum {
64 EVENT_TYPE_EVENT,
65 EVENT_TYPE_CUSTOM,
66 EVENT_TYPE_DRAG,
67 EVENT_TYPE_KEYBOARD,
68 EVENT_TYPE_MOUSE,
69 EVENT_TYPE_FOCUS,
70 EVENT_TYPE_UIEVENT,
71 EVENT_TYPE_PAGETRANSITION,
72 EVENT_TYPE_MESSAGE,
73 EVENT_TYPE_PROGRESS,
74 EVENT_TYPE_STORAGE,
75 EVENT_TYPE_CLIPBOARD
76 } event_type_t;
77
78 static const WCHAR *event_types[] = {
79 L"Event",
80 L"CustomEvent",
81 L"Event", /* FIXME */
82 L"KeyboardEvent",
83 L"MouseEvent",
84 L"Event", /* FIXME */
85 L"UIEvent",
86 L"PageTransitionEvent",
87 L"MessageEvent",
88 L"ProgressEvent",
89 L"StorageEvent",
90 L"Event" /* FIXME */
91 };
92
93 typedef struct {
94 const WCHAR *name;
95 event_type_t type;
96 DISPID dispid;
97 DWORD flags;
98 } event_info_t;
99
100 /* Use Gecko default listener (it's registered on window object for DOM nodes). */
101 #define EVENT_DEFAULTLISTENER 0x0001
102 /* Register Gecko listener on target itself (unlike EVENT_DEFAULTLISTENER). */
103 #define EVENT_BIND_TO_TARGET 0x0002
104 /* Event bubbles by default (unless explicitly specified otherwise). */
105 #define EVENT_BUBBLES 0x0004
106 /* Event is cancelable by default (unless explicitly specified otherwise). */
107 #define EVENT_CANCELABLE 0x0008
108 /* Event may have default handler (so we always have to register Gecko listener). */
109 #define EVENT_HASDEFAULTHANDLERS 0x0020
110 /* Ecent is not supported properly, print FIXME message when it's used. */
111 #define EVENT_FIXME 0x0040
112
113 /* mouse event flags for fromElement and toElement implementation */
114 #define EVENT_MOUSE_TO_RELATED 0x0100
115 #define EVENT_MOUSE_FROM_RELATED 0x0200
116
117 /* Keep these sorted case sensitively */
118 static const event_info_t event_info[] = {
119 {L"DOMContentLoaded", EVENT_TYPE_EVENT, 0,
120 EVENT_BUBBLES | EVENT_CANCELABLE},
121 {L"abort", EVENT_TYPE_EVENT, DISPID_EVMETH_ONABORT,
122 EVENT_BIND_TO_TARGET},
123 {L"afterprint", EVENT_TYPE_EVENT, DISPID_EVMETH_ONAFTERPRINT,
124 EVENT_DEFAULTLISTENER},
125 {L"animationend", EVENT_TYPE_EVENT, DISPID_EVPROP_ONANIMATIONEND,
126 EVENT_DEFAULTLISTENER | EVENT_BUBBLES},
127 {L"animationstart", EVENT_TYPE_EVENT, DISPID_EVPROP_ONANIMATIONSTART,
128 EVENT_DEFAULTLISTENER | EVENT_BUBBLES},
129 {L"beforeactivate", EVENT_TYPE_EVENT, DISPID_EVMETH_ONBEFOREACTIVATE,
130 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
131 {L"beforeprint", EVENT_TYPE_EVENT, DISPID_EVMETH_ONBEFOREPRINT,
132 EVENT_DEFAULTLISTENER},
133 {L"beforeunload", EVENT_TYPE_EVENT, DISPID_EVMETH_ONBEFOREUNLOAD,
134 EVENT_DEFAULTLISTENER | EVENT_CANCELABLE },
135 {L"blur", EVENT_TYPE_FOCUS, DISPID_EVMETH_ONBLUR,
136 EVENT_DEFAULTLISTENER},
137 {L"change", EVENT_TYPE_EVENT, DISPID_EVMETH_ONCHANGE,
138 EVENT_DEFAULTLISTENER | EVENT_BUBBLES},
139 {L"click", EVENT_TYPE_MOUSE, DISPID_EVMETH_ONCLICK,
140 EVENT_DEFAULTLISTENER | EVENT_HASDEFAULTHANDLERS | EVENT_BUBBLES | EVENT_CANCELABLE },
141 {L"contextmenu", EVENT_TYPE_MOUSE, DISPID_EVMETH_ONCONTEXTMENU,
142 EVENT_BUBBLES | EVENT_CANCELABLE},
143 {L"dataavailable", EVENT_TYPE_EVENT, DISPID_EVMETH_ONDATAAVAILABLE,
144 EVENT_FIXME | EVENT_BUBBLES},
145 {L"dblclick", EVENT_TYPE_MOUSE, DISPID_EVMETH_ONDBLCLICK,
146 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
147 {L"drag", EVENT_TYPE_DRAG, DISPID_EVMETH_ONDRAG,
148 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
149 {L"dragstart", EVENT_TYPE_DRAG, DISPID_EVMETH_ONDRAGSTART,
150 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
151 {L"error", EVENT_TYPE_EVENT, DISPID_EVMETH_ONERROR,
152 EVENT_BIND_TO_TARGET},
153 {L"focus", EVENT_TYPE_FOCUS, DISPID_EVMETH_ONFOCUS,
154 EVENT_DEFAULTLISTENER},
155 {L"focusin", EVENT_TYPE_FOCUS, DISPID_EVMETH_ONFOCUSIN,
156 EVENT_BUBBLES},
157 {L"focusout", EVENT_TYPE_FOCUS, DISPID_EVMETH_ONFOCUSOUT,
158 EVENT_BUBBLES},
159 {L"help", EVENT_TYPE_EVENT, DISPID_EVMETH_ONHELP,
160 EVENT_BUBBLES | EVENT_CANCELABLE},
161 {L"input", EVENT_TYPE_EVENT, DISPID_UNKNOWN,
162 EVENT_DEFAULTLISTENER | EVENT_BUBBLES},
163 {L"keydown", EVENT_TYPE_KEYBOARD, DISPID_EVMETH_ONKEYDOWN,
164 EVENT_DEFAULTLISTENER | EVENT_HASDEFAULTHANDLERS | EVENT_BUBBLES | EVENT_CANCELABLE },
165 {L"keypress", EVENT_TYPE_KEYBOARD, DISPID_EVMETH_ONKEYPRESS,
166 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
167 {L"keyup", EVENT_TYPE_KEYBOARD, DISPID_EVMETH_ONKEYUP,
168 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
169 {L"load", EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONLOAD,
170 EVENT_BIND_TO_TARGET},
171 {L"loadend", EVENT_TYPE_PROGRESS, DISPID_EVPROP_LOADEND,
172 EVENT_BIND_TO_TARGET},
173 {L"loadstart", EVENT_TYPE_PROGRESS, DISPID_EVPROP_LOADSTART,
174 EVENT_BIND_TO_TARGET},
175 {L"message", EVENT_TYPE_MESSAGE, DISPID_EVMETH_ONMESSAGE,
176 0},
177 {L"mousedown", EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEDOWN,
178 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
179 {L"mousemove", EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEMOVE,
180 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE | EVENT_MOUSE_FROM_RELATED},
181 {L"mouseout", EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEOUT,
182 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE | EVENT_MOUSE_TO_RELATED},
183 {L"mouseover", EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEOVER,
184 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE | EVENT_MOUSE_FROM_RELATED},
185 {L"mouseup", EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEUP,
186 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
187 {L"mousewheel", EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEWHEEL,
188 EVENT_FIXME},
189 {L"msthumbnailclick", EVENT_TYPE_MOUSE, DISPID_EVPROP_ONMSTHUMBNAILCLICK,
190 EVENT_FIXME},
191 {L"pagehide", EVENT_TYPE_PAGETRANSITION, DISPID_EVPROP_ONPAGEHIDE,
192 0},
193 {L"pageshow", EVENT_TYPE_PAGETRANSITION, DISPID_EVPROP_ONPAGESHOW,
194 0},
195 {L"paste", EVENT_TYPE_CLIPBOARD, DISPID_EVMETH_ONPASTE,
196 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
197 {L"progress", EVENT_TYPE_PROGRESS, DISPID_EVPROP_PROGRESS,
198 EVENT_BIND_TO_TARGET},
199 {L"readystatechange", EVENT_TYPE_EVENT, DISPID_EVMETH_ONREADYSTATECHANGE,
200 0},
201 {L"resize", EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONRESIZE,
202 EVENT_DEFAULTLISTENER},
203 {L"scroll", EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONSCROLL,
204 EVENT_DEFAULTLISTENER | EVENT_BUBBLES /* FIXME: not for elements */},
205 {L"selectionchange", EVENT_TYPE_EVENT, DISPID_EVMETH_ONSELECTIONCHANGE,
206 EVENT_FIXME},
207 {L"selectstart", EVENT_TYPE_EVENT, DISPID_EVMETH_ONSELECTSTART,
208 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
209 {L"storage", EVENT_TYPE_STORAGE, DISPID_EVMETH_ONSTORAGE,
210 0},
211 {L"storagecommit", EVENT_TYPE_STORAGE, DISPID_EVMETH_ONSTORAGECOMMIT,
212 0},
213 {L"submit", EVENT_TYPE_EVENT, DISPID_EVMETH_ONSUBMIT,
214 EVENT_DEFAULTLISTENER | EVENT_HASDEFAULTHANDLERS | EVENT_BUBBLES | EVENT_CANCELABLE},
215 {L"timeout", EVENT_TYPE_PROGRESS, DISPID_EVPROP_TIMEOUT,
216 EVENT_BIND_TO_TARGET},
217 {L"unload", EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONUNLOAD,
218 EVENT_BIND_TO_TARGET},
219 {L"visibilitychange", EVENT_TYPE_EVENT, DISPID_EVPROP_VISIBILITYCHANGE,
220 EVENT_FIXME | EVENT_BUBBLES},
221
222 /* EVENTID_LAST special entry */
223 {NULL, EVENT_TYPE_EVENT, 0, 0}
224 };
225
226 C_ASSERT(ARRAY_SIZE(event_info) - 1 == EVENTID_LAST);
227
228 static eventid_t str_to_eid(const WCHAR *str)
229 {
230 unsigned i, a = 0, b = ARRAY_SIZE(event_info) - 1;
231 int c;
232
233 while(a < b) {
234 i = (a + b) / 2;
235 if(!(c = wcscmp(event_info[i].name, str)))
236 return i;
237 if(c > 0) b = i;
238 else a = i + 1;
239 }
240
241 return EVENTID_LAST;
242 }
243
244 static eventid_t attr_to_eid(const WCHAR *str)
245 {
246 unsigned i, a = 0, b = ARRAY_SIZE(event_info) - 1;
247 int c;
248
249 if((str[0] != 'o' && str[0] != 'O') || (str[1] != 'n' && str[1] != 'N'))
250 return EVENTID_LAST;
251
252 while(a < b) {
253 i = (a + b) / 2;
254 if(!(c = wcscmp(event_info[i].name, str+2)))
255 return event_info[i].dispid ? i : EVENTID_LAST;
256 if(c > 0) b = i;
257 else a = i + 1;
258 }
259
260 return EVENTID_LAST;
261 }
262
263 const WCHAR *get_event_name(eventid_t eid)
264 {
265 return event_info[eid].name;
266 }
267
268 static listener_container_t *get_listener_container(EventTarget *event_target, const WCHAR *type, BOOL alloc)
269 {
270 const event_target_vtbl_t *vtbl;
271 listener_container_t *container;
272 struct wine_rb_entry *entry;
273 size_t type_len;
274 eventid_t eid;
275
276 entry = wine_rb_get(&event_target->handler_map, type);
277 if(entry)
278 return WINE_RB_ENTRY_VALUE(entry, listener_container_t, entry);
279 if(!alloc)
280 return NULL;
281
282 eid = str_to_eid(type);
283 if(event_info[eid].flags & EVENT_FIXME)
284 FIXME("unimplemented event %s\n", debugstr_w(event_info[eid].name));
285
286 type_len = lstrlenW(type);
287 container = malloc(FIELD_OFFSET(listener_container_t, type[type_len+1]));
288 if(!container)
289 return NULL;
290 memcpy(container->type, type, (type_len + 1) * sizeof(WCHAR));
291 list_init(&container->listeners);
292 vtbl = dispex_get_vtbl(&event_target->dispex);
293 if (!vtbl->bind_event)
294 FIXME("Unsupported event binding on target %p\n", event_target);
295 else if(eid != EVENTID_LAST)
296 vtbl->bind_event(&event_target->dispex, eid);
297
298 wine_rb_put(&event_target->handler_map, container->type, &container->entry);
299 return container;
300 }
301
302 static void remove_event_listener(EventTarget *event_target, const WCHAR *type_name, listener_type_t type, IDispatch *function)
303 {
304 listener_container_t *container;
305 event_listener_t *listener;
306
307 container = get_listener_container(event_target, type_name, FALSE);
308 if(!container)
309 return;
310
311 LIST_FOR_EACH_ENTRY(listener, &container->listeners, event_listener_t, entry) {
312 if(listener->function == function && listener->type == type) {
313 IDispatch_Release(listener->function);
314 list_remove(&listener->entry);
315 free(listener);
316 break;
317 }
318 }
319 }
320
321 static IEventTarget *get_event_target_iface(EventTarget *event_target)
322 {
323 const event_target_vtbl_t *vtbl = dispex_get_vtbl(&event_target->dispex);
324 IEventTarget *ret;
325
326 if(vtbl->get_dispatch_this) {
327 IDispatch *disp = vtbl->get_dispatch_this(&event_target->dispex);
328 IDispatch_QueryInterface(disp, &IID_IEventTarget, (void**)&ret);
329 }else {
330 ret = &event_target->IEventTarget_iface;
331 IEventTarget_AddRef(ret);
332 }
333 return ret;
334 }
335
336 static HRESULT get_gecko_target(IEventTarget*,nsIDOMEventTarget**);
337
338 typedef struct {
339 DOMEvent event;
340 IDOMUIEvent IDOMUIEvent_iface;
341 nsIDOMUIEvent *nsevent;
342 } DOMUIEvent;
343
344 static DOMUIEvent *DOMUIEvent_from_DOMEvent(DOMEvent *event)
345 {
346 return CONTAINING_RECORD(event, DOMUIEvent, event);
347 }
348
349 typedef struct {
350 DispatchEx dispex;
351 IHTMLEventObj IHTMLEventObj_iface;
352
353 DOMEvent *event;
354 VARIANT return_value;
355 } HTMLEventObj;
356
357 static inline HTMLEventObj *impl_from_IHTMLEventObj(IHTMLEventObj *iface)
358 {
359 return CONTAINING_RECORD(iface, HTMLEventObj, IHTMLEventObj_iface);
360 }
361
362 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
363 {
364 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
365 return IDispatchEx_QueryInterface(&This->dispex.IDispatchEx_iface, riid, ppv);
366 }
367
368 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
369 {
370 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
371 return IDispatchEx_AddRef(&This->dispex.IDispatchEx_iface);
372 }
373
374 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
375 {
376 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
377 return IDispatchEx_Release(&This->dispex.IDispatchEx_iface);
378 }
379
380 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
381 {
382 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
383 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
384 }
385
386 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
387 LCID lcid, ITypeInfo **ppTInfo)
388 {
389 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
390 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
391 }
392
393 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
394 LPOLESTR *rgszNames, UINT cNames,
395 LCID lcid, DISPID *rgDispId)
396 {
397 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
398 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
399 lcid, rgDispId);
400 }
401
402 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
403 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
404 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
405 {
406 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
407 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
408 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
409 }
410
411 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
412 {
413 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
414
415 TRACE("(%p)->(%p)\n", This, p);
416
417 if(!This->event) {
418 *p = NULL;
419 return S_OK;
420 }
421
422 return IDOMEvent_get_srcElement(&This->event->IDOMEvent_iface, p);
423 }
424
425 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
426 {
427 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
428 IDOMKeyboardEvent *keyboard_event;
429 IDOMMouseEvent *mouse_event;
430 cpp_bool ret = FALSE;
431
432 TRACE("(%p)->(%p)\n", This, p);
433
434 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
435 HRESULT hres = IDOMMouseEvent_get_altKey(mouse_event, p);
436 IDOMMouseEvent_Release(mouse_event);
437 return hres;
438 }
439
440 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMKeyboardEvent, (void**)&keyboard_event))) {
441 HRESULT hres = IDOMKeyboardEvent_get_altKey(keyboard_event, p);
442 IDOMKeyboardEvent_Release(keyboard_event);
443 return hres;
444 }
445
446 *p = variant_bool(ret);
447 return S_OK;
448 }
449
450 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
451 {
452 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
453 IDOMKeyboardEvent *keyboard_event;
454 IDOMMouseEvent *mouse_event;
455 cpp_bool ret = FALSE;
456
457 TRACE("(%p)->(%p)\n", This, p);
458
459 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
460 HRESULT hres = IDOMMouseEvent_get_ctrlKey(mouse_event, p);
461 IDOMMouseEvent_Release(mouse_event);
462 return hres;
463 }
464
465 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMKeyboardEvent, (void**)&keyboard_event))) {
466 HRESULT hres = IDOMKeyboardEvent_get_ctrlKey(keyboard_event, p);
467 IDOMKeyboardEvent_Release(keyboard_event);
468 return hres;
469 }
470
471 *p = variant_bool(ret);
472 return S_OK;
473 }
474
475 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
476 {
477 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
478 IDOMKeyboardEvent *keyboard_event;
479 IDOMMouseEvent *mouse_event;
480 cpp_bool ret = FALSE;
481
482 TRACE("(%p)->(%p)\n", This, p);
483
484 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
485 HRESULT hres = IDOMMouseEvent_get_shiftKey(mouse_event, p);
486 IDOMMouseEvent_Release(mouse_event);
487 return hres;
488 }
489
490 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMKeyboardEvent, (void**)&keyboard_event))) {
491 HRESULT hres = IDOMKeyboardEvent_get_shiftKey(keyboard_event, p);
492 IDOMKeyboardEvent_Release(keyboard_event);
493 return hres;
494 }
495
496 *p = variant_bool(ret);
497 return S_OK;
498 }
499
500 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
501 {
502 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
503
504 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
505
506 if(V_VT(&v) != VT_BOOL) {
507 FIXME("unsupported value %s\n", debugstr_variant(&v));
508 return DISP_E_BADVARTYPE;
509 }
510
511 This->return_value = v;
512 if(!V_BOOL(&v) && This->event)
513 IDOMEvent_preventDefault(&This->event->IDOMEvent_iface);
514 return S_OK;
515 }
516
517 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
518 {
519 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
520
521 TRACE("(%p)->(%p)\n", This, p);
522
523 V_VT(p) = VT_EMPTY;
524 return VariantCopy(p, &This->return_value);
525 }
526
527 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
528 {
529 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
530
531 TRACE("(%p)->(%x)\n", This, v);
532
533 if(This->event)
534 IDOMEvent_stopPropagation(&This->event->IDOMEvent_iface);
535 return S_OK;
536 }
537
538 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
539 {
540 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
541
542 TRACE("(%p)->(%p)\n", This, p);
543
544 *p = variant_bool(This->event && This->event->stop_propagation);
545 return S_OK;
546 }
547
548 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
549 {
550 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
551 IDOMMouseEvent *mouse_event;
552
553 TRACE("(%p)->(%p)\n", This, p);
554
555 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
556 HRESULT hres = IDOMMouseEvent_get_fromElement(mouse_event, p);
557 IDOMMouseEvent_Release(mouse_event);
558 return hres;
559 }
560
561 *p = NULL;
562 return S_OK;
563 }
564
565 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
566 {
567 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
568 IDOMMouseEvent *mouse_event;
569
570 TRACE("(%p)->(%p)\n", This, p);
571
572 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
573 HRESULT hres = IDOMMouseEvent_get_toElement(mouse_event, p);
574 IDOMMouseEvent_Release(mouse_event);
575 return hres;
576 }
577
578 *p = NULL;
579 return S_OK;
580 }
581
582 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
583 {
584 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
585 FIXME("(%p)->(%ld)\n", This, v);
586 return E_NOTIMPL;
587 }
588
589 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
590 {
591 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
592 IDOMKeyboardEvent *keyboard_event;
593
594 TRACE("(%p)->(%p)\n", This, p);
595
596 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMKeyboardEvent, (void**)&keyboard_event))) {
597 HRESULT hres = IDOMKeyboardEvent_get_keyCode(keyboard_event, p);
598 IDOMKeyboardEvent_Release(keyboard_event);
599 return hres;
600 }
601
602 *p = 0;
603 return S_OK;
604 }
605
606 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
607 {
608 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
609 IDOMMouseEvent *mouse_event;
610 USHORT button = 0;
611
612 TRACE("(%p)->(%p)\n", This, p);
613
614 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
615 HRESULT hres = IDOMMouseEvent_get_button(mouse_event, &button);
616 IDOMMouseEvent_Release(mouse_event);
617 if(FAILED(hres))
618 return hres;
619 }
620
621 *p = button;
622 return S_OK;
623 }
624
625 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
626 {
627 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
628
629 TRACE("(%p)->(%p)\n", This, p);
630
631 if(!This->event) {
632 *p = NULL;
633 return S_OK;
634 }
635
636 return IDOMEvent_get_type(&This->event->IDOMEvent_iface, p);
637 }
638
639 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
640 {
641 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
642
643 FIXME("(%p)->(%p)\n", This, p);
644
645 *p = NULL;
646 return S_OK;
647 }
648
649 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
650 {
651 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
652
653 FIXME("(%p)->(%p)\n", This, p);
654
655 *p = 0;
656 return S_OK;
657 }
658
659 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
660 {
661 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
662 LONG x = 0;
663
664 TRACE("(%p)->(%p)\n", This, p);
665
666 if(This->event) {
667 nsIDOMUIEvent *ui_event;
668 nsresult nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMUIEvent, (void**)&ui_event);
669
670 if(NS_SUCCEEDED(nsres)) {
671 /* NOTE: pageX is not exactly right here. */
672 nsres = nsIDOMUIEvent_GetPageX(ui_event, &x);
673 assert(nsres == NS_OK);
674 nsIDOMUIEvent_Release(ui_event);
675 }
676 }
677
678 *p = x;
679 return S_OK;
680 }
681
682 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
683 {
684 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
685 LONG y = 0;
686
687 TRACE("(%p)->(%p)\n", This, p);
688
689 if(This->event) {
690 nsIDOMUIEvent *ui_event;
691 nsresult nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMUIEvent, (void**)&ui_event);
692
693 if(NS_SUCCEEDED(nsres)) {
694 /* NOTE: pageY is not exactly right here. */
695 nsres = nsIDOMUIEvent_GetPageY(ui_event, &y);
696 assert(nsres == NS_OK);
697 nsIDOMUIEvent_Release(ui_event);
698 }
699 }
700
701 *p = y;
702 return S_OK;
703 }
704
705 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
706 {
707 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
708 IDOMMouseEvent *mouse_event;
709
710 TRACE("(%p)->(%p)\n", This, p);
711
712 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
713 HRESULT hres = IDOMMouseEvent_get_clientX(mouse_event, p);
714 IDOMMouseEvent_Release(mouse_event);
715 return hres;
716 }
717
718 *p = 0;
719 return S_OK;
720 }
721
722 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
723 {
724 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
725 IDOMMouseEvent *mouse_event;
726
727 TRACE("(%p)->(%p)\n", This, p);
728
729 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
730 HRESULT hres = IDOMMouseEvent_get_clientY(mouse_event, p);
731 IDOMMouseEvent_Release(mouse_event);
732 return hres;
733 }
734
735 *p = 0;
736 return S_OK;
737 }
738
739 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
740 {
741 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
742 IDOMMouseEvent *mouse_event;
743
744 TRACE("(%p)->(%p)\n", This, p);
745
746 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
747 HRESULT hres = IDOMMouseEvent_get_offsetX(mouse_event, p);
748 IDOMMouseEvent_Release(mouse_event);
749 return hres;
750 }
751
752 *p = 0;
753 return S_OK;
754 }
755
756 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p)
757 {
758 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
759 IDOMMouseEvent *mouse_event;
760
761 TRACE("(%p)->(%p)\n", This, p);
762
763 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
764 HRESULT hres = IDOMMouseEvent_get_offsetY(mouse_event, p);
765 IDOMMouseEvent_Release(mouse_event);
766 return hres;
767 }
768
769 *p = 0;
770 return S_OK;
771 }
772
773 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p)
774 {
775 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
776 IDOMMouseEvent *mouse_event;
777
778 TRACE("(%p)->(%p)\n", This, p);
779
780 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
781 HRESULT hres = IDOMMouseEvent_get_screenX(mouse_event, p);
782 IDOMMouseEvent_Release(mouse_event);
783 return hres;
784 }
785
786 *p = 0;
787 return S_OK;
788 }
789
790 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
791 {
792 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
793 IDOMMouseEvent *mouse_event;
794
795 TRACE("(%p)->(%p)\n", This, p);
796
797 if(This->event && SUCCEEDED(IDOMEvent_QueryInterface(&This->event->IDOMEvent_iface, &IID_IDOMMouseEvent, (void**)&mouse_event))) {
798 HRESULT hres = IDOMMouseEvent_get_screenY(mouse_event, p);
799 IDOMMouseEvent_Release(mouse_event);
800 return hres;
801 }
802
803 *p = 0;
804 return S_OK;
805 }
806
807 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
808 {
809 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
810
811 FIXME("(%p)->(%p)\n", This, p);
812
813 *p = NULL;
814 return S_OK;
815 }
816
817 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
818 HTMLEventObj_QueryInterface,
819 HTMLEventObj_AddRef,
820 HTMLEventObj_Release,
821 HTMLEventObj_GetTypeInfoCount,
822 HTMLEventObj_GetTypeInfo,
823 HTMLEventObj_GetIDsOfNames,
824 HTMLEventObj_Invoke,
825 HTMLEventObj_get_srcElement,
826 HTMLEventObj_get_altKey,
827 HTMLEventObj_get_ctrlKey,
828 HTMLEventObj_get_shiftKey,
829 HTMLEventObj_put_returnValue,
830 HTMLEventObj_get_returnValue,
831 HTMLEventObj_put_cancelBubble,
832 HTMLEventObj_get_cancelBubble,
833 HTMLEventObj_get_fromElement,
834 HTMLEventObj_get_toElement,
835 HTMLEventObj_put_keyCode,
836 HTMLEventObj_get_keyCode,
837 HTMLEventObj_get_button,
838 HTMLEventObj_get_type,
839 HTMLEventObj_get_qualifier,
840 HTMLEventObj_get_reason,
841 HTMLEventObj_get_x,
842 HTMLEventObj_get_y,
843 HTMLEventObj_get_clientX,
844 HTMLEventObj_get_clientY,
845 HTMLEventObj_get_offsetX,
846 HTMLEventObj_get_offsetY,
847 HTMLEventObj_get_screenX,
848 HTMLEventObj_get_screenY,
849 HTMLEventObj_get_srcFilter
850 };
851
852 static inline HTMLEventObj *unsafe_impl_from_IHTMLEventObj(IHTMLEventObj *iface)
853 {
854 return iface->lpVtbl == &HTMLEventObjVtbl ? impl_from_IHTMLEventObj(iface) : NULL;
855 }
856
857 static inline HTMLEventObj *HTMLEventObj_from_DispatchEx(DispatchEx *iface)
858 {
859 return CONTAINING_RECORD(iface, HTMLEventObj, dispex);
860 }
861
862 static void *HTMLEventObj_query_interface(DispatchEx *dispex, REFIID riid)
863 {
864 HTMLEventObj *This = HTMLEventObj_from_DispatchEx(dispex);
865
866 if(IsEqualGUID(&IID_IHTMLEventObj, riid))
867 return &This->IHTMLEventObj_iface;
868
869 return NULL;
870 }
871
872 static void HTMLEventObj_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
873 {
874 HTMLEventObj *This = HTMLEventObj_from_DispatchEx(dispex);
875 if(This->event)
876 note_cc_edge((nsISupports*)&This->event->IDOMEvent_iface, "event", cb);
877 }
878
879 static void HTMLEventObj_unlink(DispatchEx *dispex)
880 {
881 HTMLEventObj *This = HTMLEventObj_from_DispatchEx(dispex);
882 if(This->event) {
883 DOMEvent *event = This->event;
884 This->event = NULL;
885 IDOMEvent_Release(&event->IDOMEvent_iface);
886 }
887 }
888
889 static void HTMLEventObj_destructor(DispatchEx *dispex)
890 {
891 HTMLEventObj *This = HTMLEventObj_from_DispatchEx(dispex);
892 free(This);
893 }
894
895 static const dispex_static_data_vtbl_t HTMLEventObj_dispex_vtbl = {
896 .query_interface = HTMLEventObj_query_interface,
897 .destructor = HTMLEventObj_destructor,
898 .traverse = HTMLEventObj_traverse,
899 .unlink = HTMLEventObj_unlink
900 };
901
902 static const tid_t HTMLEventObj_iface_tids[] = {
903 IHTMLEventObj_tid,
904 0
905 };
906
907 static dispex_static_data_t HTMLEventObj_dispex = {
908 "MSEventObj",
909 &HTMLEventObj_dispex_vtbl,
910 DispCEventObj_tid,
911 HTMLEventObj_iface_tids
912 };
913
914 static HTMLEventObj *alloc_event_obj(DOMEvent *event, compat_mode_t compat_mode)
915 {
916 HTMLEventObj *event_obj;
917
918 event_obj = calloc(1, sizeof(*event_obj));
919 if(!event_obj)
920 return NULL;
921
922 event_obj->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl;
923 event_obj->event = event;
924 if(event)
925 IDOMEvent_AddRef(&event->IDOMEvent_iface);
926
927 init_dispatch(&event_obj->dispex, &HTMLEventObj_dispex, compat_mode);
928 return event_obj;
929 }
930
931 HRESULT create_event_obj(compat_mode_t compat_mode, IHTMLEventObj **ret)
932 {
933 HTMLEventObj *event_obj;
934
935 event_obj = alloc_event_obj(NULL, compat_mode);
936 if(!event_obj)
937 return E_OUTOFMEMORY;
938
939 *ret = &event_obj->IHTMLEventObj_iface;
940 return S_OK;
941 }
942
943 static inline DOMEvent *impl_from_IDOMEvent(IDOMEvent *iface)
944 {
945 return CONTAINING_RECORD(iface, DOMEvent, IDOMEvent_iface);
946 }
947
948 static const IDOMEventVtbl DOMEventVtbl;
949
950 static inline DOMEvent *unsafe_impl_from_IDOMEvent(IDOMEvent *iface)
951 {
952 return iface && iface->lpVtbl == &DOMEventVtbl ? impl_from_IDOMEvent(iface) : NULL;
953 }
954
955 static HRESULT WINAPI DOMEvent_QueryInterface(IDOMEvent *iface, REFIID riid, void **ppv)
956 {
957 DOMEvent *This = impl_from_IDOMEvent(iface);
958 return IDispatchEx_QueryInterface(&This->dispex.IDispatchEx_iface, riid, ppv);
959 }
960
961 static ULONG WINAPI DOMEvent_AddRef(IDOMEvent *iface)
962 {
963 DOMEvent *This = impl_from_IDOMEvent(iface);
964 return IDispatchEx_AddRef(&This->dispex.IDispatchEx_iface);
965 }
966
967 static ULONG WINAPI DOMEvent_Release(IDOMEvent *iface)
968 {
969 DOMEvent *This = impl_from_IDOMEvent(iface);
970 return IDispatchEx_Release(&This->dispex.IDispatchEx_iface);
971 }
972
973 static HRESULT WINAPI DOMEvent_GetTypeInfoCount(IDOMEvent *iface, UINT *pctinfo)
974 {
975 DOMEvent *This = impl_from_IDOMEvent(iface);
976 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
977 }
978
979 static HRESULT WINAPI DOMEvent_GetTypeInfo(IDOMEvent *iface, UINT iTInfo,
980 LCID lcid, ITypeInfo **ppTInfo)
981 {
982 DOMEvent *This = impl_from_IDOMEvent(iface);
983 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
984 }
985
986 static HRESULT WINAPI DOMEvent_GetIDsOfNames(IDOMEvent *iface, REFIID riid,
987 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
988 {
989 DOMEvent *This = impl_from_IDOMEvent(iface);
990 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
991 lcid, rgDispId);
992 }
993
994 static HRESULT WINAPI DOMEvent_Invoke(IDOMEvent *iface, DISPID dispIdMember,
995 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
996 EXCEPINFO *pExcepInfo, UINT *puArgErr)
997 {
998 DOMEvent *This = impl_from_IDOMEvent(iface);
999 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1000 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1001 }
1002
1003 static HRESULT WINAPI DOMEvent_get_bubbles(IDOMEvent *iface, VARIANT_BOOL *p)
1004 {
1005 DOMEvent *This = impl_from_IDOMEvent(iface);
1006
1007 TRACE("(%p)->(%p)\n", This, p);
1008
1009 *p = variant_bool(This->bubbles);
1010 return S_OK;
1011 }
1012
1013 static HRESULT WINAPI DOMEvent_get_cancelable(IDOMEvent *iface, VARIANT_BOOL *p)
1014 {
1015 DOMEvent *This = impl_from_IDOMEvent(iface);
1016
1017 TRACE("(%p)->(%p)\n", This, p);
1018
1019 *p = variant_bool(This->cancelable);
1020 return S_OK;
1021 }
1022
1023 static HRESULT WINAPI DOMEvent_get_currentTarget(IDOMEvent *iface, IEventTarget **p)
1024 {
1025 DOMEvent *This = impl_from_IDOMEvent(iface);
1026
1027 TRACE("(%p)->(%p)\n", This, p);
1028
1029 if(This->current_target)
1030 *p = get_event_target_iface(This->current_target);
1031 else
1032 *p = NULL;
1033 return S_OK;
1034 }
1035
1036 static HRESULT WINAPI DOMEvent_get_defaultPrevented(IDOMEvent *iface, VARIANT_BOOL *p)
1037 {
1038 DOMEvent *This = impl_from_IDOMEvent(iface);
1039
1040 TRACE("(%p)->(%p)\n", This, p);
1041
1042 *p = variant_bool(This->prevent_default);
1043 return S_OK;
1044 }
1045
1046 static HRESULT WINAPI DOMEvent_get_eventPhase(IDOMEvent *iface, USHORT *p)
1047 {
1048 DOMEvent *This = impl_from_IDOMEvent(iface);
1049
1050 TRACE("(%p)->(%p)\n", This, p);
1051
1052 *p = This->phase;
1053 return S_OK;
1054 }
1055
1056 static HRESULT WINAPI DOMEvent_get_target(IDOMEvent *iface, IEventTarget **p)
1057 {
1058 DOMEvent *This = impl_from_IDOMEvent(iface);
1059
1060 TRACE("(%p)->(%p)\n", This, p);
1061
1062 if(This->target)
1063 *p = get_event_target_iface(This->target);
1064 else
1065 *p = NULL;
1066 return S_OK;
1067 }
1068
1069 static HRESULT WINAPI DOMEvent_get_timeStamp(IDOMEvent *iface, ULONGLONG *p)
1070 {
1071 DOMEvent *This = impl_from_IDOMEvent(iface);
1072
1073 TRACE("(%p)->(%p)\n", This, p);
1074
1075 *p = This->time_stamp;
1076 return S_OK;
1077 }
1078
1079 static HRESULT WINAPI DOMEvent_get_type(IDOMEvent *iface, BSTR *p)
1080 {
1081 DOMEvent *This = impl_from_IDOMEvent(iface);
1082
1083 TRACE("(%p)->(%p)\n", This, p);
1084
1085 if(This->type) {
1086 *p = SysAllocString(This->type);
1087 if(!*p)
1088 return E_OUTOFMEMORY;
1089 }else {
1090 *p = NULL;
1091 }
1092 return S_OK;
1093 }
1094
1095 #ifdef __i386__
1096 #define nsIDOMEvent_InitEvent(_this,type,bubbles,cancelable) \
1097 ((void (WINAPI*)(void*,nsIDOMEvent*,const nsAString*,cpp_bool,cpp_bool)) \
1098 &call_thiscall_func)((_this)->lpVtbl->InitEvent,_this,type,bubbles,cancelable)
1099
1100 #endif
1101
1102 static HRESULT WINAPI DOMEvent_initEvent(IDOMEvent *iface, BSTR type, VARIANT_BOOL can_bubble, VARIANT_BOOL cancelable)
1103 {
1104 DOMEvent *This = impl_from_IDOMEvent(iface);
1105 nsAString nsstr;
1106
1107 TRACE("(%p)->(%s %x %x)\n", This, debugstr_w(type), can_bubble, cancelable);
1108
1109 if(This->target) {
1110 TRACE("called on already dispatched event\n");
1111 return S_OK;
1112 }
1113
1114 free(This->type);
1115 This->type = wcsdup(type);
1116 if(!This->type)
1117 return E_OUTOFMEMORY;
1118 This->event_id = str_to_eid(type);
1119
1120 This->bubbles = !!can_bubble;
1121 This->cancelable = !!cancelable;
1122
1123 nsAString_InitDepend(&nsstr, type);
1124 nsIDOMEvent_InitEvent(This->nsevent, &nsstr, This->bubbles, This->cancelable);
1125 nsAString_Finish(&nsstr);
1126
1127 return S_OK;
1128 }
1129
1130 static HRESULT WINAPI DOMEvent_preventDefault(IDOMEvent *iface)
1131 {
1132 DOMEvent *This = impl_from_IDOMEvent(iface);
1133
1134 TRACE("(%p)\n", This);
1135
1136 if(This->current_target && This->cancelable) {
1137 This->prevent_default = TRUE;
1138 nsIDOMEvent_PreventDefault(This->nsevent);
1139 }
1140 return S_OK;
1141 }
1142
1143 static HRESULT WINAPI DOMEvent_stopPropagation(IDOMEvent *iface)
1144 {
1145 DOMEvent *This = impl_from_IDOMEvent(iface);
1146
1147 TRACE("(%p)\n", This);
1148
1149 This->stop_propagation = TRUE;
1150 nsIDOMEvent_StopPropagation(This->nsevent);
1151 return S_OK;
1152 }
1153
1154 static HRESULT WINAPI DOMEvent_stopImmediatePropagation(IDOMEvent *iface)
1155 {
1156 DOMEvent *This = impl_from_IDOMEvent(iface);
1157
1158 TRACE("(%p)\n", This);
1159
1160 This->stop_immediate_propagation = This->stop_propagation = TRUE;
1161 nsIDOMEvent_StopImmediatePropagation(This->nsevent);
1162 return S_OK;
1163 }
1164
1165 static HRESULT WINAPI DOMEvent_get_isTrusted(IDOMEvent *iface, VARIANT_BOOL *p)
1166 {
1167 DOMEvent *This = impl_from_IDOMEvent(iface);
1168
1169 TRACE("(%p)->(%p)\n", This, p);
1170
1171 *p = variant_bool(This->trusted);
1172 return S_OK;
1173 }
1174
1175 static HRESULT WINAPI DOMEvent_put_cancelBubble(IDOMEvent *iface, VARIANT_BOOL v)
1176 {
1177 DOMEvent *This = impl_from_IDOMEvent(iface);
1178 FIXME("(%p)->(%x)\n", This, v);
1179 return E_NOTIMPL;
1180 }
1181
1182 static HRESULT WINAPI DOMEvent_get_cancelBubble(IDOMEvent *iface, VARIANT_BOOL *p)
1183 {
1184 DOMEvent *This = impl_from_IDOMEvent(iface);
1185 FIXME("(%p)->(%p)\n", This, p);
1186 return E_NOTIMPL;
1187 }
1188
1189 static HRESULT WINAPI DOMEvent_get_srcElement(IDOMEvent *iface, IHTMLElement **p)
1190 {
1191 DOMEvent *This = impl_from_IDOMEvent(iface);
1192
1193 TRACE("(%p)->(%p)\n", This, p);
1194
1195 if(This->target)
1196 IDispatchEx_QueryInterface(&This->target->dispex.IDispatchEx_iface, &IID_IHTMLElement, (void**)p);
1197 else
1198 *p = NULL;
1199 return S_OK;
1200 }
1201
1202 static const IDOMEventVtbl DOMEventVtbl = {
1203 DOMEvent_QueryInterface,
1204 DOMEvent_AddRef,
1205 DOMEvent_Release,
1206 DOMEvent_GetTypeInfoCount,
1207 DOMEvent_GetTypeInfo,
1208 DOMEvent_GetIDsOfNames,
1209 DOMEvent_Invoke,
1210 DOMEvent_get_bubbles,
1211 DOMEvent_get_cancelable,
1212 DOMEvent_get_currentTarget,
1213 DOMEvent_get_defaultPrevented,
1214 DOMEvent_get_eventPhase,
1215 DOMEvent_get_target,
1216 DOMEvent_get_timeStamp,
1217 DOMEvent_get_type,
1218 DOMEvent_initEvent,
1219 DOMEvent_preventDefault,
1220 DOMEvent_stopPropagation,
1221 DOMEvent_stopImmediatePropagation,
1222 DOMEvent_get_isTrusted,
1223 DOMEvent_put_cancelBubble,
1224 DOMEvent_get_cancelBubble,
1225 DOMEvent_get_srcElement
1226 };
1227
1228 static inline DOMEvent *DOMEvent_from_DispatchEx(DispatchEx *iface)
1229 {
1230 return CONTAINING_RECORD(iface, DOMEvent, dispex);
1231 }
1232
1233 static void *DOMEvent_query_interface(DispatchEx *dispex, REFIID riid)
1234 {
1235 DOMEvent *This = DOMEvent_from_DispatchEx(dispex);
1236
1237 if(IsEqualGUID(&IID_IDOMEvent, riid))
1238 return &This->IDOMEvent_iface;
1239
1240 return NULL;
1241 }
1242
1243 static void DOMEvent_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
1244 {
1245 DOMEvent *This = DOMEvent_from_DispatchEx(dispex);
1246 if(This->target)
1247 note_cc_edge((nsISupports*)&This->target->IEventTarget_iface, "target", cb);
1248 if(This->nsevent)
1249 note_cc_edge((nsISupports*)This->nsevent, "nsevent", cb);
1250 }
1251
1252 static void DOMEvent_unlink(DispatchEx *dispex)
1253 {
1254 DOMEvent *This = DOMEvent_from_DispatchEx(dispex);
1255 if(This->target) {
1256 EventTarget *target = This->target;
1257 This->target = NULL;
1258 IEventTarget_Release(&target->IEventTarget_iface);
1259 }
1260 unlink_ref(&This->nsevent);
1261 }
1262
1263 static void DOMEvent_destructor(DispatchEx *dispex)
1264 {
1265 DOMEvent *This = DOMEvent_from_DispatchEx(dispex);
1266 free(This->type);
1267 free(This);
1268 }
1269
1270 static inline DOMUIEvent *impl_from_IDOMUIEvent(IDOMUIEvent *iface)
1271 {
1272 return CONTAINING_RECORD(iface, DOMUIEvent, IDOMUIEvent_iface);
1273 }
1274
1275 static HRESULT WINAPI DOMUIEvent_QueryInterface(IDOMUIEvent *iface, REFIID riid, void **ppv)
1276 {
1277 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1278 return IDOMEvent_QueryInterface(&This->event.IDOMEvent_iface, riid, ppv);
1279 }
1280
1281 static ULONG WINAPI DOMUIEvent_AddRef(IDOMUIEvent *iface)
1282 {
1283 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1284 return IDOMEvent_AddRef(&This->event.IDOMEvent_iface);
1285 }
1286
1287 static ULONG WINAPI DOMUIEvent_Release(IDOMUIEvent *iface)
1288 {
1289 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1290 return IDOMEvent_Release(&This->event.IDOMEvent_iface);
1291 }
1292
1293 static HRESULT WINAPI DOMUIEvent_GetTypeInfoCount(IDOMUIEvent *iface, UINT *pctinfo)
1294 {
1295 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1296 return IDispatchEx_GetTypeInfoCount(&This->event.dispex.IDispatchEx_iface, pctinfo);
1297 }
1298
1299 static HRESULT WINAPI DOMUIEvent_GetTypeInfo(IDOMUIEvent *iface, UINT iTInfo,
1300 LCID lcid, ITypeInfo **ppTInfo)
1301 {
1302 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1303 return IDispatchEx_GetTypeInfo(&This->event.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1304 }
1305
1306 static HRESULT WINAPI DOMUIEvent_GetIDsOfNames(IDOMUIEvent *iface, REFIID riid,
1307 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1308 {
1309 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1310 return IDispatchEx_GetIDsOfNames(&This->event.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1311 lcid, rgDispId);
1312 }
1313
1314 static HRESULT WINAPI DOMUIEvent_Invoke(IDOMUIEvent *iface, DISPID dispIdMember,
1315 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1316 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1317 {
1318 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1319 return IDispatchEx_Invoke(&This->event.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1320 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1321 }
1322
1323 static HRESULT WINAPI DOMUIEvent_get_view(IDOMUIEvent *iface, IHTMLWindow2 **p)
1324 {
1325 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1326 mozIDOMWindowProxy *moz_window;
1327 HTMLOuterWindow *view = NULL;
1328 nsresult nsres;
1329
1330 TRACE("(%p)->(%p)\n", This, p);
1331
1332 nsres = nsIDOMUIEvent_GetView(This->nsevent, &moz_window);
1333 if(NS_FAILED(nsres))
1334 return E_FAIL;
1335
1336 if(moz_window) {
1337 view = mozwindow_to_window(moz_window);
1338 mozIDOMWindowProxy_Release(moz_window);
1339 }
1340 if(view)
1341 IHTMLWindow2_AddRef((*p = &view->base.inner_window->base.IHTMLWindow2_iface));
1342 else
1343 *p = NULL;
1344 return S_OK;
1345 }
1346
1347 static HRESULT WINAPI DOMUIEvent_get_detail(IDOMUIEvent *iface, LONG *p)
1348 {
1349 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1350 LONG detail;
1351 nsresult nsres;
1352
1353 TRACE("(%p)->(%p)\n", This, p);
1354
1355 nsres = nsIDOMUIEvent_GetDetail(This->nsevent, &detail);
1356 if(NS_FAILED(nsres))
1357 return E_FAIL;
1358
1359 *p = detail;
1360 return S_OK;
1361 }
1362
1363 static HRESULT WINAPI DOMUIEvent_initUIEvent(IDOMUIEvent *iface, BSTR type, VARIANT_BOOL can_bubble,
1364 VARIANT_BOOL cancelable, IHTMLWindow2 *view, LONG detail)
1365 {
1366 DOMUIEvent *This = impl_from_IDOMUIEvent(iface);
1367 nsAString type_str;
1368 nsresult nsres;
1369 HRESULT hres;
1370
1371 TRACE("(%p)->(%s %x %x %p %lx)\n", This, debugstr_w(type), can_bubble, cancelable, view, detail);
1372
1373 if(This->event.target) {
1374 TRACE("called on already dispatched event\n");
1375 return S_OK;
1376 }
1377
1378 if(view)
1379 FIXME("view argument is not supported\n");
1380
1381 hres = IDOMEvent_initEvent(&This->event.IDOMEvent_iface, type, can_bubble, cancelable);
1382 if(FAILED(hres))
1383 return hres;
1384
1385 nsAString_InitDepend(&type_str, type);
1386 nsres = nsIDOMUIEvent_InitUIEvent(This->nsevent, &type_str, !!can_bubble, !!cancelable,
1387 NULL /* FIXME */, detail);
1388 nsAString_Finish(&type_str);
1389 if(NS_FAILED(nsres)) {
1390 FIXME("InitUIEvent failed: %08lx\n", nsres);
1391 return E_FAIL;
1392 }
1393
1394 return S_OK;
1395 }
1396
1397 static const IDOMUIEventVtbl DOMUIEventVtbl = {
1398 DOMUIEvent_QueryInterface,
1399 DOMUIEvent_AddRef,
1400 DOMUIEvent_Release,
1401 DOMUIEvent_GetTypeInfoCount,
1402 DOMUIEvent_GetTypeInfo,
1403 DOMUIEvent_GetIDsOfNames,
1404 DOMUIEvent_Invoke,
1405 DOMUIEvent_get_view,
1406 DOMUIEvent_get_detail,
1407 DOMUIEvent_initUIEvent
1408 };
1409
1410 static void *DOMUIEvent_query_interface(DispatchEx *dispex, REFIID riid)
1411 {
1412 DOMUIEvent *This = DOMUIEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
1413
1414 if(IsEqualGUID(&IID_IDOMUIEvent, riid))
1415 return &This->IDOMUIEvent_iface;
1416 return DOMEvent_query_interface(&This->event.dispex, riid);
1417 }
1418
1419 static void DOMUIEvent_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
1420 {
1421 DOMUIEvent *This = DOMUIEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
1422 DOMEvent_traverse(&This->event.dispex, cb);
1423 if(This->nsevent)
1424 note_cc_edge((nsISupports*)This->nsevent, "UIEvent.nsevent", cb);
1425 }
1426
1427 static void DOMUIEvent_unlink(DispatchEx *dispex)
1428 {
1429 DOMUIEvent *This = DOMUIEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
1430 DOMEvent_unlink(&This->event.dispex);
1431 unlink_ref(&This->nsevent);
1432 }
1433
1434 typedef struct {
1435 DOMUIEvent ui_event;
1436 IDOMMouseEvent IDOMMouseEvent_iface;
1437 nsIDOMMouseEvent *nsevent;
1438 } DOMMouseEvent;
1439
1440 static inline DOMMouseEvent *impl_from_IDOMMouseEvent(IDOMMouseEvent *iface)
1441 {
1442 return CONTAINING_RECORD(iface, DOMMouseEvent, IDOMMouseEvent_iface);
1443 }
1444
1445 static HRESULT WINAPI DOMMouseEvent_QueryInterface(IDOMMouseEvent *iface, REFIID riid, void **ppv)
1446 {
1447 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1448 return IDOMEvent_QueryInterface(&This->ui_event.event.IDOMEvent_iface, riid, ppv);
1449 }
1450
1451 static ULONG WINAPI DOMMouseEvent_AddRef(IDOMMouseEvent *iface)
1452 {
1453 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1454 return IDOMEvent_AddRef(&This->ui_event.event.IDOMEvent_iface);
1455 }
1456
1457 static ULONG WINAPI DOMMouseEvent_Release(IDOMMouseEvent *iface)
1458 {
1459 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1460 return IDOMEvent_Release(&This->ui_event.event.IDOMEvent_iface);
1461 }
1462
1463 static HRESULT WINAPI DOMMouseEvent_GetTypeInfoCount(IDOMMouseEvent *iface, UINT *pctinfo)
1464 {
1465 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1466 return IDispatchEx_GetTypeInfoCount(&This->ui_event.event.dispex.IDispatchEx_iface, pctinfo);
1467 }
1468
1469 static HRESULT WINAPI DOMMouseEvent_GetTypeInfo(IDOMMouseEvent *iface, UINT iTInfo,
1470 LCID lcid, ITypeInfo **ppTInfo)
1471 {
1472 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1473 return IDispatchEx_GetTypeInfo(&This->ui_event.event.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1474 }
1475
1476 static HRESULT WINAPI DOMMouseEvent_GetIDsOfNames(IDOMMouseEvent *iface, REFIID riid,
1477 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1478 {
1479 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1480 return IDispatchEx_GetIDsOfNames(&This->ui_event.event.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1481 lcid, rgDispId);
1482 }
1483
1484 static HRESULT WINAPI DOMMouseEvent_Invoke(IDOMMouseEvent *iface, DISPID dispIdMember,
1485 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1486 EXCEPINFO *pExcepInfo, UINT *puArgErr)
1487 {
1488 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1489 return IDispatchEx_Invoke(&This->ui_event.event.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1490 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1491 }
1492
1493 static HRESULT WINAPI DOMMouseEvent_get_screenX(IDOMMouseEvent *iface, LONG *p)
1494 {
1495 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1496 LONG screen_x;
1497 nsresult nsres;
1498
1499 TRACE("(%p)->(%p)\n", This, p);
1500
1501 nsres = nsIDOMMouseEvent_GetScreenX(This->nsevent, &screen_x);
1502 if(NS_FAILED(nsres))
1503 return E_FAIL;
1504
1505 *p = screen_x;
1506 return S_OK;
1507 }
1508
1509 static HRESULT WINAPI DOMMouseEvent_get_screenY(IDOMMouseEvent *iface, LONG *p)
1510 {
1511 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1512 LONG screen_y;
1513 nsresult nsres;
1514
1515 TRACE("(%p)->(%p)\n", This, p);
1516
1517 nsres = nsIDOMMouseEvent_GetScreenY(This->nsevent, &screen_y);
1518 if(NS_FAILED(nsres))
1519 return E_FAIL;
1520
1521 *p = screen_y;
1522 return S_OK;
1523 }
1524
1525 static HRESULT WINAPI DOMMouseEvent_get_clientX(IDOMMouseEvent *iface, LONG *p)
1526 {
1527 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1528 LONG client_x;
1529 nsresult nsres;
1530
1531 TRACE("(%p)->(%p)\n", This, p);
1532
1533 nsres = nsIDOMMouseEvent_GetClientX(This->nsevent, &client_x);
1534 if(NS_FAILED(nsres))
1535 return E_FAIL;
1536
1537 *p = client_x;
1538 return S_OK;
1539 }
1540
1541 static HRESULT WINAPI DOMMouseEvent_get_clientY(IDOMMouseEvent *iface, LONG *p)
1542 {
1543 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1544 LONG client_y;
1545 nsresult nsres;
1546
1547 TRACE("(%p)->(%p)\n", This, p);
1548
1549 nsres = nsIDOMMouseEvent_GetClientY(This->nsevent, &client_y);
1550 if(NS_FAILED(nsres))
1551 return E_FAIL;
1552
1553 *p = client_y;
1554 return S_OK;
1555 }
1556
1557 static HRESULT WINAPI DOMMouseEvent_get_ctrlKey(IDOMMouseEvent *iface, VARIANT_BOOL *p)
1558 {
1559 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1560 cpp_bool r;
1561 nsresult nsres;
1562
1563 TRACE("(%p)->(%p)\n", This, p);
1564
1565 nsres = nsIDOMMouseEvent_GetCtrlKey(This->nsevent, &r);
1566 if(NS_FAILED(nsres))
1567 return E_FAIL;
1568
1569 *p = variant_bool(r);
1570 return S_OK;
1571 }
1572
1573 static HRESULT WINAPI DOMMouseEvent_get_shiftKey(IDOMMouseEvent *iface, VARIANT_BOOL *p)
1574 {
1575 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1576 cpp_bool r;
1577 nsresult nsres;
1578
1579 TRACE("(%p)->(%p)\n", This, p);
1580
1581 nsres = nsIDOMMouseEvent_GetShiftKey(This->nsevent, &r);
1582 if(NS_FAILED(nsres))
1583 return E_FAIL;
1584
1585 *p = variant_bool(r);
1586 return S_OK;
1587 }
1588
1589 static HRESULT WINAPI DOMMouseEvent_get_altKey(IDOMMouseEvent *iface, VARIANT_BOOL *p)
1590 {
1591 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1592 cpp_bool r;
1593 nsresult nsres;
1594
1595 TRACE("(%p)->(%p)\n", This, p);
1596
1597 nsres = nsIDOMMouseEvent_GetAltKey(This->nsevent, &r);
1598 if(NS_FAILED(nsres))
1599 return E_FAIL;
1600
1601 *p = variant_bool(r);
1602 return S_OK;
1603 }
1604
1605 static HRESULT WINAPI DOMMouseEvent_get_metaKey(IDOMMouseEvent *iface, VARIANT_BOOL *p)
1606 {
1607 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1608 cpp_bool r;
1609 nsresult nsres;
1610
1611 TRACE("(%p)->(%p)\n", This, p);
1612
1613 nsres = nsIDOMMouseEvent_GetMetaKey(This->nsevent, &r);
1614 if(NS_FAILED(nsres))
1615 return E_FAIL;
1616
1617 *p = variant_bool(r);
1618 return S_OK;
1619 }
1620
1621 static HRESULT WINAPI DOMMouseEvent_get_button(IDOMMouseEvent *iface, USHORT *p)
1622 {
1623 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1624 INT16 r;
1625 nsresult nsres;
1626
1627 TRACE("(%p)->(%p)\n", This, p);
1628
1629 nsres = nsIDOMMouseEvent_GetButton(This->nsevent, &r);
1630 if(NS_FAILED(nsres))
1631 return E_FAIL;
1632
1633 *p = r;
1634 return S_OK;
1635 }
1636
1637 static HRESULT WINAPI DOMMouseEvent_get_relatedTarget(IDOMMouseEvent *iface, IEventTarget **p)
1638 {
1639 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1640 nsIDOMEventTarget *related_target;
1641 nsIDOMNode *target_node;
1642 HTMLDOMNode *node;
1643 HRESULT hres;
1644 nsresult nsres;
1645
1646 TRACE("(%p)->(%p)\n", This, p);
1647
1648 nsres = nsIDOMMouseEvent_GetRelatedTarget(This->nsevent, &related_target);
1649 if(NS_FAILED(nsres))
1650 return E_FAIL;
1651
1652 if(!related_target) {
1653 *p = NULL;
1654 return S_OK;
1655 }
1656
1657 nsres = nsIDOMEventTarget_QueryInterface(related_target, &IID_nsIDOMNode, (void**)&target_node);
1658 nsIDOMEventTarget_Release(related_target);
1659 if(NS_FAILED(nsres)) {
1660 FIXME("Only node targets supported\n");
1661 return E_NOTIMPL;
1662 }
1663
1664 hres = get_node(target_node, TRUE, &node);
1665 nsIDOMNode_Release(target_node);
1666 if(FAILED(hres))
1667 return hres;
1668
1669 *p = &node->event_target.IEventTarget_iface;
1670 return S_OK;
1671 }
1672
1673 static HRESULT WINAPI DOMMouseEvent_initMouseEvent(IDOMMouseEvent *iface, BSTR type,
1674 VARIANT_BOOL can_bubble, VARIANT_BOOL cancelable, IHTMLWindow2 *view, LONG detail,
1675 LONG screen_x, LONG screen_y, LONG client_x, LONG client_y, VARIANT_BOOL ctrl_key,
1676 VARIANT_BOOL alt_key, VARIANT_BOOL shift_key, VARIANT_BOOL meta_key, USHORT button,
1677 IEventTarget *related_target)
1678 {
1679 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1680 nsIDOMEventTarget *nstarget = NULL;
1681 nsAString type_str;
1682 nsresult nsres;
1683 HRESULT hres;
1684
1685 TRACE("(%p)->(%s %x %x %p %ld %ld %ld %ld %ld %x %x %x %x %u %p)\n", This, debugstr_w(type),
1686 can_bubble, cancelable, view, detail, screen_x, screen_y, client_x, client_y,
1687 ctrl_key, alt_key, shift_key, meta_key, button, related_target);
1688
1689 if(This->ui_event.event.target) {
1690 TRACE("called on already dispatched event\n");
1691 return S_OK;
1692 }
1693
1694 if(view)
1695 FIXME("view argument is not supported\n");
1696
1697 if(related_target) {
1698 hres = get_gecko_target(related_target, &nstarget);
1699 if(FAILED(hres))
1700 return hres;
1701 }
1702
1703 hres = IDOMEvent_initEvent(&This->ui_event.event.IDOMEvent_iface, type, can_bubble, cancelable);
1704 if(SUCCEEDED(hres)) {
1705 nsAString_InitDepend(&type_str, type);
1706 nsres = nsIDOMMouseEvent_InitMouseEvent(This->nsevent, &type_str, can_bubble, cancelable,
1707 NULL /* FIXME */, detail, screen_x, screen_y,
1708 client_x, client_y, !!ctrl_key, !!alt_key, !!shift_key,
1709 !!meta_key, button, nstarget);
1710 nsAString_Finish(&type_str);
1711 if(NS_FAILED(nsres)) {
1712 FIXME("InitMouseEvent failed: %08lx\n", nsres);
1713 return E_FAIL;
1714 }
1715 }
1716
1717 if(nstarget)
1718 nsIDOMEventTarget_Release(nstarget);
1719 return S_OK;
1720 }
1721
1722 static HRESULT WINAPI DOMMouseEvent_getModifierState(IDOMMouseEvent *iface, BSTR key,
1723 VARIANT_BOOL *activated)
1724 {
1725 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1726 FIXME("(%p)->(%s %p)\n", This, debugstr_w(key), activated);
1727 return E_NOTIMPL;
1728 }
1729
1730 static HRESULT WINAPI DOMMouseEvent_get_buttons(IDOMMouseEvent *iface, USHORT *p)
1731 {
1732 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1733 UINT16 r;
1734 nsresult nsres;
1735
1736 TRACE("(%p)->(%p)\n", This, p);
1737
1738 nsres = nsIDOMMouseEvent_GetButtons(This->nsevent, &r);
1739 if(NS_FAILED(nsres))
1740 return E_FAIL;
1741
1742 *p = r;
1743 return S_OK;
1744 }
1745
1746 static HRESULT WINAPI DOMMouseEvent_get_fromElement(IDOMMouseEvent *iface, IHTMLElement **p)
1747 {
1748 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1749 eventid_t event_id = This->ui_event.event.event_id;
1750 IEventTarget *related_target = NULL;
1751 HRESULT hres = S_OK;
1752
1753 TRACE("(%p)->(%p)\n", This, p);
1754
1755 if(event_info[event_id].flags & EVENT_MOUSE_FROM_RELATED)
1756 hres = IDOMMouseEvent_get_relatedTarget(&This->IDOMMouseEvent_iface, &related_target);
1757 else if(event_info[event_id].flags & EVENT_MOUSE_TO_RELATED)
1758 hres = IDOMEvent_get_target(&This->ui_event.event.IDOMEvent_iface, &related_target);
1759 if(FAILED(hres))
1760 return hres;
1761
1762 if(!related_target) {
1763 *p = NULL;
1764 return S_OK;
1765 }
1766
1767 IEventTarget_QueryInterface(related_target, &IID_IHTMLElement, (void**)p);
1768 return S_OK;
1769 }
1770
1771 static HRESULT WINAPI DOMMouseEvent_get_toElement(IDOMMouseEvent *iface, IHTMLElement **p)
1772 {
1773 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1774 eventid_t event_id = This->ui_event.event.event_id;
1775 IEventTarget *related_target = NULL;
1776 HRESULT hres = S_OK;
1777
1778 TRACE("(%p)->(%p)\n", This, p);
1779
1780 if(event_info[event_id].flags & EVENT_MOUSE_TO_RELATED)
1781 hres = IDOMMouseEvent_get_relatedTarget(&This->IDOMMouseEvent_iface, &related_target);
1782 else if(event_info[event_id].flags & EVENT_MOUSE_FROM_RELATED)
1783 hres = IDOMEvent_get_target(&This->ui_event.event.IDOMEvent_iface, &related_target);
1784 if(FAILED(hres))
1785 return hres;
1786
1787 if(!related_target) {
1788 *p = NULL;
1789 return S_OK;
1790 }
1791
1792 IEventTarget_QueryInterface(related_target, &IID_IHTMLElement, (void**)p);
1793 return S_OK;
1794 }
1795
1796 static HRESULT WINAPI DOMMouseEvent_get_x(IDOMMouseEvent *iface, LONG *p)
1797 {
1798 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1799 FIXME("(%p)->(%p)\n", This, p);
1800 return E_NOTIMPL;
1801 }
1802
1803 static HRESULT WINAPI DOMMouseEvent_get_y(IDOMMouseEvent *iface, LONG *p)
1804 {
1805 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1806 FIXME("(%p)->(%p)\n", This, p);
1807 return E_NOTIMPL;
1808 }
1809
1810 static HRESULT WINAPI DOMMouseEvent_get_offsetX(IDOMMouseEvent *iface, LONG *p)
1811 {
1812 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1813
1814 FIXME("(%p)->(%p) returning 0\n", This, p);
1815
1816 *p = 0;
1817 return S_OK;
1818 }
1819
1820 static HRESULT WINAPI DOMMouseEvent_get_offsetY(IDOMMouseEvent *iface, LONG *p)
1821 {
1822 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1823
1824 FIXME("(%p)->(%p) returning 0\n", This, p);
1825
1826 *p = 0;
1827 return S_OK;
1828 }
1829
1830 static HRESULT WINAPI DOMMouseEvent_get_pageX(IDOMMouseEvent *iface, LONG *p)
1831 {
1832 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1833 LONG r;
1834 nsresult nsres;
1835
1836 TRACE("(%p)->(%p)\n", This, p);
1837
1838 nsres = nsIDOMMouseEvent_GetPageX(This->nsevent, &r);
1839 if(NS_FAILED(nsres))
1840 return E_FAIL;
1841
1842 *p = r;
1843 return S_OK;
1844 }
1845
1846 static HRESULT WINAPI DOMMouseEvent_get_pageY(IDOMMouseEvent *iface, LONG *p)
1847 {
1848 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1849 LONG r;
1850 nsresult nsres;
1851
1852 TRACE("(%p)->(%p)\n", This, p);
1853
1854 nsres = nsIDOMMouseEvent_GetPageY(This->nsevent, &r);
1855 if(NS_FAILED(nsres))
1856 return E_FAIL;
1857
1858 *p = r;
1859 return S_OK;
1860 }
1861
1862 static HRESULT WINAPI DOMMouseEvent_get_layerX(IDOMMouseEvent *iface, LONG *p)
1863 {
1864 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1865 nsresult nsres;
1866 LONG r;
1867
1868 TRACE("(%p)->(%p)\n", This, p);
1869
1870 nsres = nsIDOMMouseEvent_GetLayerX(This->nsevent, &r);
1871 if(NS_FAILED(nsres))
1872 return E_FAIL;
1873
1874 *p = r;
1875 return S_OK;
1876 }
1877
1878 static HRESULT WINAPI DOMMouseEvent_get_layerY(IDOMMouseEvent *iface, LONG *p)
1879 {
1880 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1881 nsresult nsres;
1882 LONG r;
1883
1884 TRACE("(%p)->(%p)\n", This, p);
1885
1886 nsres = nsIDOMMouseEvent_GetLayerY(This->nsevent, &r);
1887 if(NS_FAILED(nsres))
1888 return E_FAIL;
1889
1890 *p = r;
1891 return S_OK;
1892 }
1893
1894 static HRESULT WINAPI DOMMouseEvent_get_which(IDOMMouseEvent *iface, USHORT *p)
1895 {
1896 DOMMouseEvent *This = impl_from_IDOMMouseEvent(iface);
1897 UINT32 r;
1898 nsresult nsres;
1899
1900 TRACE("(%p)->(%p)\n", This, p);
1901
1902 nsres = nsIDOMMouseEvent_GetWhich(This->nsevent, &r);
1903 if(NS_FAILED(nsres))
1904 return E_FAIL;
1905
1906 *p = r;
1907 return S_OK;
1908 }
1909
1910 static const IDOMMouseEventVtbl DOMMouseEventVtbl = {
1911 DOMMouseEvent_QueryInterface,
1912 DOMMouseEvent_AddRef,
1913 DOMMouseEvent_Release,
1914 DOMMouseEvent_GetTypeInfoCount,
1915 DOMMouseEvent_GetTypeInfo,
1916 DOMMouseEvent_GetIDsOfNames,
1917 DOMMouseEvent_Invoke,
1918 DOMMouseEvent_get_screenX,
1919 DOMMouseEvent_get_screenY,
1920 DOMMouseEvent_get_clientX,
1921 DOMMouseEvent_get_clientY,
1922 DOMMouseEvent_get_ctrlKey,
1923 DOMMouseEvent_get_shiftKey,
1924 DOMMouseEvent_get_altKey,
1925 DOMMouseEvent_get_metaKey,
1926 DOMMouseEvent_get_button,
1927 DOMMouseEvent_get_relatedTarget,
1928 DOMMouseEvent_initMouseEvent,
1929 DOMMouseEvent_getModifierState,
1930 DOMMouseEvent_get_buttons,
1931 DOMMouseEvent_get_fromElement,
1932 DOMMouseEvent_get_toElement,
1933 DOMMouseEvent_get_x,
1934 DOMMouseEvent_get_y,
1935 DOMMouseEvent_get_offsetX,
1936 DOMMouseEvent_get_offsetY,
1937 DOMMouseEvent_get_pageX,
1938 DOMMouseEvent_get_pageY,
1939 DOMMouseEvent_get_layerX,
1940 DOMMouseEvent_get_layerY,
1941 DOMMouseEvent_get_which
1942 };
1943
1944 static DOMMouseEvent *DOMMouseEvent_from_DOMEvent(DOMEvent *event)
1945 {
1946 return CONTAINING_RECORD(event, DOMMouseEvent, ui_event.event);
1947 }
1948
1949 static void *DOMMouseEvent_query_interface(DispatchEx *dispex, REFIID riid)
1950 {
1951 DOMMouseEvent *This = DOMMouseEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
1952
1953 if(IsEqualGUID(&IID_IDOMMouseEvent, riid))
1954 return &This->IDOMMouseEvent_iface;
1955 if(IsEqualGUID(&IID_IDOMUIEvent, riid))
1956 return &This->ui_event.IDOMUIEvent_iface;
1957 return DOMEvent_query_interface(&This->ui_event.event.dispex, riid);
1958 }
1959
1960 static void DOMMouseEvent_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
1961 {
1962 DOMMouseEvent *This = DOMMouseEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
1963 DOMUIEvent_traverse(&This->ui_event.event.dispex, cb);
1964 if(This->nsevent)
1965 note_cc_edge((nsISupports*)This->nsevent, "MouseEvent.nsevent", cb);
1966 }
1967
1968 static void DOMMouseEvent_unlink(DispatchEx *dispex)
1969 {
1970 DOMMouseEvent *This = DOMMouseEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
1971 DOMUIEvent_unlink(&This->ui_event.event.dispex);
1972 unlink_ref(&This->nsevent);
1973 }
1974
1975 typedef struct {
1976 DOMUIEvent ui_event;
1977 IDOMKeyboardEvent IDOMKeyboardEvent_iface;
1978 nsIDOMKeyEvent *nsevent;
1979 } DOMKeyboardEvent;
1980
1981 static inline DOMKeyboardEvent *impl_from_IDOMKeyboardEvent(IDOMKeyboardEvent *iface)
1982 {
1983 return CONTAINING_RECORD(iface, DOMKeyboardEvent, IDOMKeyboardEvent_iface);
1984 }
1985
1986 static HRESULT WINAPI DOMKeyboardEvent_QueryInterface(IDOMKeyboardEvent *iface, REFIID riid, void **ppv)
1987 {
1988 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
1989 return IDOMEvent_QueryInterface(&This->ui_event.event.IDOMEvent_iface, riid, ppv);
1990 }
1991
1992 static ULONG WINAPI DOMKeyboardEvent_AddRef(IDOMKeyboardEvent *iface)
1993 {
1994 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
1995 return IDOMEvent_AddRef(&This->ui_event.event.IDOMEvent_iface);
1996 }
1997
1998 static ULONG WINAPI DOMKeyboardEvent_Release(IDOMKeyboardEvent *iface)
1999 {
2000 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2001 return IDOMEvent_Release(&This->ui_event.event.IDOMEvent_iface);
2002 }
2003
2004 static HRESULT WINAPI DOMKeyboardEvent_GetTypeInfoCount(IDOMKeyboardEvent *iface, UINT *pctinfo)
2005 {
2006 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2007 return IDispatchEx_GetTypeInfoCount(&This->ui_event.event.dispex.IDispatchEx_iface, pctinfo);
2008 }
2009
2010 static HRESULT WINAPI DOMKeyboardEvent_GetTypeInfo(IDOMKeyboardEvent *iface, UINT iTInfo,
2011 LCID lcid, ITypeInfo **ppTInfo)
2012 {
2013 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2014 return IDispatchEx_GetTypeInfo(&This->ui_event.event.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2015 }
2016
2017 static HRESULT WINAPI DOMKeyboardEvent_GetIDsOfNames(IDOMKeyboardEvent *iface, REFIID riid,
2018 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2019 {
2020 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2021 return IDispatchEx_GetIDsOfNames(&This->ui_event.event.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2022 lcid, rgDispId);
2023 }
2024
2025 static HRESULT WINAPI DOMKeyboardEvent_Invoke(IDOMKeyboardEvent *iface, DISPID dispIdMember,
2026 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
2027 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2028 {
2029 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2030 return IDispatchEx_Invoke(&This->ui_event.event.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2031 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2032 }
2033
2034 static HRESULT WINAPI DOMKeyboardEvent_get_key(IDOMKeyboardEvent *iface, BSTR *p)
2035 {
2036 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2037 nsAString key_str;
2038 nsresult nsres;
2039
2040 TRACE("(%p)->(%p)\n", This, p);
2041
2042
2043 nsAString_Init(&key_str, NULL);
2044 nsres = nsIDOMKeyEvent_GetKey(This->nsevent, &key_str);
2045 return return_nsstr(nsres, &key_str, p);
2046 }
2047
2048 static HRESULT WINAPI DOMKeyboardEvent_get_location(IDOMKeyboardEvent *iface, ULONG *p)
2049 {
2050 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2051 UINT32 r;
2052 nsresult nsres;
2053
2054 TRACE("(%p)->(%p)\n", This, p);
2055
2056 nsres = nsIDOMKeyEvent_GetLocation(This->nsevent, &r);
2057 if(NS_FAILED(nsres))
2058 return E_FAIL;
2059
2060 *p = r;
2061 return S_OK;
2062 }
2063
2064 static HRESULT WINAPI DOMKeyboardEvent_get_ctrlKey(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
2065 {
2066 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2067 cpp_bool r;
2068 nsresult nsres;
2069
2070 TRACE("(%p)->(%p)\n", This, p);
2071
2072 nsres = nsIDOMKeyEvent_GetCtrlKey(This->nsevent, &r);
2073 if(NS_FAILED(nsres))
2074 return E_FAIL;
2075
2076 *p = variant_bool(r);
2077 return S_OK;
2078 }
2079
2080 static HRESULT WINAPI DOMKeyboardEvent_get_shiftKey(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
2081 {
2082 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2083 cpp_bool r;
2084 nsresult nsres;
2085
2086 TRACE("(%p)->(%p)\n", This, p);
2087
2088 nsres = nsIDOMKeyEvent_GetShiftKey(This->nsevent, &r);
2089 if(NS_FAILED(nsres))
2090 return E_FAIL;
2091
2092 *p = variant_bool(r);
2093 return S_OK;
2094 }
2095
2096 static HRESULT WINAPI DOMKeyboardEvent_get_altKey(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
2097 {
2098 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2099 cpp_bool r;
2100 nsresult nsres;
2101
2102 TRACE("(%p)->(%p)\n", This, p);
2103
2104 nsres = nsIDOMKeyEvent_GetAltKey(This->nsevent, &r);
2105 if(NS_FAILED(nsres))
2106 return E_FAIL;
2107
2108 *p = variant_bool(r);
2109 return S_OK;
2110 }
2111
2112 static HRESULT WINAPI DOMKeyboardEvent_get_metaKey(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
2113 {
2114 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2115 cpp_bool r;
2116 nsresult nsres;
2117
2118 TRACE("(%p)->(%p)\n", This, p);
2119
2120 nsres = nsIDOMKeyEvent_GetMetaKey(This->nsevent, &r);
2121 if(NS_FAILED(nsres))
2122 return E_FAIL;
2123
2124 *p = variant_bool(r);
2125 return S_OK;
2126 }
2127
2128 static HRESULT WINAPI DOMKeyboardEvent_get_repeat(IDOMKeyboardEvent *iface, VARIANT_BOOL *p)
2129 {
2130 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2131 cpp_bool r;
2132 nsresult nsres;
2133
2134 TRACE("(%p)->(%p)\n", This, p);
2135
2136 nsres = nsIDOMKeyEvent_GetRepeat(This->nsevent, &r);
2137 if(NS_FAILED(nsres))
2138 return E_FAIL;
2139
2140 *p = variant_bool(r);
2141 return S_OK;
2142 }
2143
2144 static HRESULT WINAPI DOMKeyboardEvent_getModifierState(IDOMKeyboardEvent *iface, BSTR key,
2145 VARIANT_BOOL *state)
2146 {
2147 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2148 FIXME("(%p)->(%s %p)\n", This, debugstr_w(key), state);
2149 return E_NOTIMPL;
2150 }
2151
2152 static HRESULT WINAPI DOMKeyboardEvent_initKeyboardEvent(IDOMKeyboardEvent *iface, BSTR type,
2153 VARIANT_BOOL can_bubble, VARIANT_BOOL cancelable, IHTMLWindow2 *view, BSTR key,
2154 ULONG location, BSTR modifiers_list, VARIANT_BOOL repeat, BSTR locale)
2155 {
2156 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2157 FIXME("(%p)->(%s %x %x %p %s %lu %s %x %s)\n", This, debugstr_w(type), can_bubble,
2158 cancelable, view, debugstr_w(key), location, debugstr_w(modifiers_list),
2159 repeat, debugstr_w(locale));
2160 return E_NOTIMPL;
2161 }
2162
2163 static HRESULT WINAPI DOMKeyboardEvent_get_keyCode(IDOMKeyboardEvent *iface, LONG *p)
2164 {
2165 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2166 UINT32 r;
2167 nsresult nsres;
2168
2169 TRACE("(%p)->(%p)\n", This, p);
2170
2171 nsres = nsIDOMKeyEvent_GetKeyCode(This->nsevent, &r);
2172 if(NS_FAILED(nsres))
2173 return E_FAIL;
2174
2175 *p = r;
2176 return S_OK;
2177 }
2178
2179 static HRESULT WINAPI DOMKeyboardEvent_get_charCode(IDOMKeyboardEvent *iface, LONG *p)
2180 {
2181 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2182 UINT32 r;
2183 nsresult nsres;
2184
2185 TRACE("(%p)->(%p)\n", This, p);
2186
2187 nsres = nsIDOMKeyEvent_GetKeyCode(This->nsevent, &r);
2188 if(NS_FAILED(nsres))
2189 return E_FAIL;
2190
2191 *p = r;
2192 return S_OK;
2193 }
2194
2195 static HRESULT WINAPI DOMKeyboardEvent_get_which(IDOMKeyboardEvent *iface, LONG *p)
2196 {
2197 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2198 UINT32 r;
2199 nsresult nsres;
2200
2201 TRACE("(%p)->(%p)\n", This, p);
2202
2203 nsres = nsIDOMKeyEvent_GetWhich(This->nsevent, &r);
2204 if(NS_FAILED(nsres))
2205 return E_FAIL;
2206
2207 *p = r;
2208 return S_OK;
2209 }
2210
2211 static HRESULT WINAPI DOMKeyboardEvent_get_char(IDOMKeyboardEvent *iface, VARIANT *p)
2212 {
2213 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2214 FIXME("(%p)->(%p)\n", This, p);
2215 return E_NOTIMPL;
2216 }
2217
2218 static HRESULT WINAPI DOMKeyboardEvent_get_locale(IDOMKeyboardEvent *iface, BSTR *p)
2219 {
2220 DOMKeyboardEvent *This = impl_from_IDOMKeyboardEvent(iface);
2221
2222 FIXME("(%p)->(%p) semi-stub\n", This, p);
2223
2224 *p = SysAllocString(L"");
2225 return *p ? S_OK : E_OUTOFMEMORY;
2226 }
2227
2228 static const IDOMKeyboardEventVtbl DOMKeyboardEventVtbl = {
2229 DOMKeyboardEvent_QueryInterface,
2230 DOMKeyboardEvent_AddRef,
2231 DOMKeyboardEvent_Release,
2232 DOMKeyboardEvent_GetTypeInfoCount,
2233 DOMKeyboardEvent_GetTypeInfo,
2234 DOMKeyboardEvent_GetIDsOfNames,
2235 DOMKeyboardEvent_Invoke,
2236 DOMKeyboardEvent_get_key,
2237 DOMKeyboardEvent_get_location,
2238 DOMKeyboardEvent_get_ctrlKey,
2239 DOMKeyboardEvent_get_shiftKey,
2240 DOMKeyboardEvent_get_altKey,
2241 DOMKeyboardEvent_get_metaKey,
2242 DOMKeyboardEvent_get_repeat,
2243 DOMKeyboardEvent_getModifierState,
2244 DOMKeyboardEvent_initKeyboardEvent,
2245 DOMKeyboardEvent_get_keyCode,
2246 DOMKeyboardEvent_get_charCode,
2247 DOMKeyboardEvent_get_which,
2248 DOMKeyboardEvent_get_char,
2249 DOMKeyboardEvent_get_locale
2250 };
2251
2252 static DOMKeyboardEvent *DOMKeyboardEvent_from_DOMEvent(DOMEvent *event)
2253 {
2254 return CONTAINING_RECORD(event, DOMKeyboardEvent, ui_event.event);
2255 }
2256
2257 static void *DOMKeyboardEvent_query_interface(DispatchEx *dispex, REFIID riid)
2258 {
2259 DOMKeyboardEvent *This = DOMKeyboardEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2260
2261 if(IsEqualGUID(&IID_IDOMKeyboardEvent, riid))
2262 return &This->IDOMKeyboardEvent_iface;
2263 if(IsEqualGUID(&IID_IDOMUIEvent, riid))
2264 return &This->ui_event.IDOMUIEvent_iface;
2265 return DOMEvent_query_interface(&This->ui_event.event.dispex, riid);
2266 }
2267
2268 static void DOMKeyboardEvent_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
2269 {
2270 DOMKeyboardEvent *This = DOMKeyboardEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2271 DOMUIEvent_traverse(&This->ui_event.event.dispex, cb);
2272 if(This->nsevent)
2273 note_cc_edge((nsISupports*)This->nsevent, "KeyboardEvent.nsevent", cb);
2274 }
2275
2276 static void DOMKeyboardEvent_unlink(DispatchEx *dispex)
2277 {
2278 DOMKeyboardEvent *This = DOMKeyboardEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2279 DOMUIEvent_unlink(&This->ui_event.event.dispex);
2280 unlink_ref(&This->nsevent);
2281 }
2282
2283 typedef struct {
2284 DOMEvent event;
2285 IWinePageTransitionEvent IWinePageTransitionEvent_iface;
2286 } DOMPageTransitionEvent;
2287
2288 static inline DOMPageTransitionEvent *impl_from_IWinePageTransitionEvent(IWinePageTransitionEvent *iface)
2289 {
2290 return CONTAINING_RECORD(iface, DOMPageTransitionEvent, IWinePageTransitionEvent_iface);
2291 }
2292
2293 static HRESULT WINAPI DOMPageTransitionEvent_QueryInterface(IWinePageTransitionEvent *iface, REFIID riid, void **ppv)
2294 {
2295 DOMPageTransitionEvent *This = impl_from_IWinePageTransitionEvent(iface);
2296 return IDOMEvent_QueryInterface(&This->event.IDOMEvent_iface, riid, ppv);
2297 }
2298
2299 static ULONG WINAPI DOMPageTransitionEvent_AddRef(IWinePageTransitionEvent *iface)
2300 {
2301 DOMPageTransitionEvent *This = impl_from_IWinePageTransitionEvent(iface);
2302 return IDOMEvent_AddRef(&This->event.IDOMEvent_iface);
2303 }
2304
2305 static ULONG WINAPI DOMPageTransitionEvent_Release(IWinePageTransitionEvent *iface)
2306 {
2307 DOMPageTransitionEvent *This = impl_from_IWinePageTransitionEvent(iface);
2308 return IDOMEvent_Release(&This->event.IDOMEvent_iface);
2309 }
2310
2311 static HRESULT WINAPI DOMPageTransitionEvent_GetTypeInfoCount(IWinePageTransitionEvent *iface, UINT *pctinfo)
2312 {
2313 DOMPageTransitionEvent *This = impl_from_IWinePageTransitionEvent(iface);
2314 return IDispatchEx_GetTypeInfoCount(&This->event.dispex.IDispatchEx_iface, pctinfo);
2315 }
2316
2317 static HRESULT WINAPI DOMPageTransitionEvent_GetTypeInfo(IWinePageTransitionEvent *iface, UINT iTInfo,
2318 LCID lcid, ITypeInfo **ppTInfo)
2319 {
2320 DOMPageTransitionEvent *This = impl_from_IWinePageTransitionEvent(iface);
2321 return IDispatchEx_GetTypeInfo(&This->event.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2322 }
2323
2324 static HRESULT WINAPI DOMPageTransitionEvent_GetIDsOfNames(IWinePageTransitionEvent *iface, REFIID riid,
2325 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2326 {
2327 DOMPageTransitionEvent *This = impl_from_IWinePageTransitionEvent(iface);
2328 return IDispatchEx_GetIDsOfNames(&This->event.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2329 lcid, rgDispId);
2330 }
2331
2332 static HRESULT WINAPI DOMPageTransitionEvent_Invoke(IWinePageTransitionEvent *iface, DISPID dispIdMember,
2333 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
2334 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2335 {
2336 DOMPageTransitionEvent *This = impl_from_IWinePageTransitionEvent(iface);
2337 return IDispatchEx_Invoke(&This->event.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2338 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2339 }
2340
2341 static HRESULT WINAPI DOMPageTransitionEvent_get_persisted(IWinePageTransitionEvent *iface, VARIANT_BOOL *p)
2342 {
2343 DOMPageTransitionEvent *This = impl_from_IWinePageTransitionEvent(iface);
2344
2345 FIXME("(%p)->(%p): always returning FALSE\n", This, p);
2346
2347 *p = VARIANT_FALSE;
2348 return S_OK;
2349 }
2350
2351 static const IWinePageTransitionEventVtbl DOMPageTransitionEventVtbl = {
2352 DOMPageTransitionEvent_QueryInterface,
2353 DOMPageTransitionEvent_AddRef,
2354 DOMPageTransitionEvent_Release,
2355 DOMPageTransitionEvent_GetTypeInfoCount,
2356 DOMPageTransitionEvent_GetTypeInfo,
2357 DOMPageTransitionEvent_GetIDsOfNames,
2358 DOMPageTransitionEvent_Invoke,
2359 DOMPageTransitionEvent_get_persisted
2360 };
2361
2362 static DOMPageTransitionEvent *DOMPageTransitionEvent_from_DOMEvent(DOMEvent *event)
2363 {
2364 return CONTAINING_RECORD(event, DOMPageTransitionEvent, event);
2365 }
2366
2367 static void *DOMPageTransitionEvent_query_interface(DispatchEx *dispex, REFIID riid)
2368 {
2369 DOMPageTransitionEvent *page_transition_event = DOMPageTransitionEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2370
2371 if(IsEqualGUID(&IID_IWinePageTransitionEvent, riid))
2372 return &page_transition_event->IWinePageTransitionEvent_iface;
2373 return DOMEvent_query_interface(&page_transition_event->event.dispex, riid);
2374 }
2375
2376 typedef struct {
2377 DOMEvent event;
2378 IDOMCustomEvent IDOMCustomEvent_iface;
2379 VARIANT detail;
2380 } DOMCustomEvent;
2381
2382 static inline DOMCustomEvent *impl_from_IDOMCustomEvent(IDOMCustomEvent *iface)
2383 {
2384 return CONTAINING_RECORD(iface, DOMCustomEvent, IDOMCustomEvent_iface);
2385 }
2386
2387 static HRESULT WINAPI DOMCustomEvent_QueryInterface(IDOMCustomEvent *iface, REFIID riid, void **ppv)
2388 {
2389 DOMCustomEvent *This = impl_from_IDOMCustomEvent(iface);
2390 return IDOMEvent_QueryInterface(&This->event.IDOMEvent_iface, riid, ppv);
2391 }
2392
2393 static ULONG WINAPI DOMCustomEvent_AddRef(IDOMCustomEvent *iface)
2394 {
2395 DOMCustomEvent *This = impl_from_IDOMCustomEvent(iface);
2396 return IDOMEvent_AddRef(&This->event.IDOMEvent_iface);
2397 }
2398
2399 static ULONG WINAPI DOMCustomEvent_Release(IDOMCustomEvent *iface)
2400 {
2401 DOMCustomEvent *This = impl_from_IDOMCustomEvent(iface);
2402 return IDOMEvent_Release(&This->event.IDOMEvent_iface);
2403 }
2404
2405 static HRESULT WINAPI DOMCustomEvent_GetTypeInfoCount(IDOMCustomEvent *iface, UINT *pctinfo)
2406 {
2407 DOMCustomEvent *This = impl_from_IDOMCustomEvent(iface);
2408 return IDispatchEx_GetTypeInfoCount(&This->event.dispex.IDispatchEx_iface, pctinfo);
2409 }
2410
2411 static HRESULT WINAPI DOMCustomEvent_GetTypeInfo(IDOMCustomEvent *iface, UINT iTInfo,
2412 LCID lcid, ITypeInfo **ppTInfo)
2413 {
2414 DOMCustomEvent *This = impl_from_IDOMCustomEvent(iface);
2415 return IDispatchEx_GetTypeInfo(&This->event.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2416 }
2417
2418 static HRESULT WINAPI DOMCustomEvent_GetIDsOfNames(IDOMCustomEvent *iface, REFIID riid,
2419 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2420 {
2421 DOMCustomEvent *This = impl_from_IDOMCustomEvent(iface);
2422 return IDispatchEx_GetIDsOfNames(&This->event.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2423 lcid, rgDispId);
2424 }
2425
2426 static HRESULT WINAPI DOMCustomEvent_Invoke(IDOMCustomEvent *iface, DISPID dispIdMember,
2427 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
2428 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2429 {
2430 DOMCustomEvent *This = impl_from_IDOMCustomEvent(iface);
2431 return IDispatchEx_Invoke(&This->event.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2432 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2433 }
2434
2435 static HRESULT WINAPI DOMCustomEvent_get_detail(IDOMCustomEvent *iface, VARIANT *p)
2436 {
2437 DOMCustomEvent *This = impl_from_IDOMCustomEvent(iface);
2438
2439 TRACE("(%p)->(%p)\n", This, p);
2440
2441 V_VT(p) = VT_EMPTY;
2442 return VariantCopy(p, &This->detail);
2443 }
2444
2445 static HRESULT WINAPI DOMCustomEvent_initCustomEvent(IDOMCustomEvent *iface, BSTR type, VARIANT_BOOL can_bubble,
2446 VARIANT_BOOL cancelable, VARIANT *detail)
2447 {
2448 DOMCustomEvent *This = impl_from_IDOMCustomEvent(iface);
2449 HRESULT hres;
2450
2451 TRACE("(%p)->(%s %x %x %s)\n", This, debugstr_w(type), can_bubble, cancelable, debugstr_variant(detail));
2452
2453 hres = IDOMEvent_initEvent(&This->event.IDOMEvent_iface, type, can_bubble, cancelable);
2454 if(FAILED(hres))
2455 return hres;
2456
2457 return VariantCopy(&This->detail, detail);
2458 }
2459
2460 static const IDOMCustomEventVtbl DOMCustomEventVtbl = {
2461 DOMCustomEvent_QueryInterface,
2462 DOMCustomEvent_AddRef,
2463 DOMCustomEvent_Release,
2464 DOMCustomEvent_GetTypeInfoCount,
2465 DOMCustomEvent_GetTypeInfo,
2466 DOMCustomEvent_GetIDsOfNames,
2467 DOMCustomEvent_Invoke,
2468 DOMCustomEvent_get_detail,
2469 DOMCustomEvent_initCustomEvent
2470 };
2471
2472 static DOMCustomEvent *DOMCustomEvent_from_DOMEvent(DOMEvent *event)
2473 {
2474 return CONTAINING_RECORD(event, DOMCustomEvent, event);
2475 }
2476
2477 static void *DOMCustomEvent_query_interface(DispatchEx *dispex, REFIID riid)
2478 {
2479 DOMCustomEvent *custom_event = DOMCustomEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2480
2481 if(IsEqualGUID(&IID_IDOMCustomEvent, riid))
2482 return &custom_event->IDOMCustomEvent_iface;
2483 return DOMEvent_query_interface(&custom_event->event.dispex, riid);
2484 }
2485
2486 static void DOMCustomEvent_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
2487 {
2488 DOMCustomEvent *custom_event = DOMCustomEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2489 DOMEvent_traverse(&custom_event->event.dispex, cb);
2490 traverse_variant(&custom_event->detail, "detail", cb);
2491 }
2492
2493 static void DOMCustomEvent_unlink(DispatchEx *dispex)
2494 {
2495 DOMCustomEvent *custom_event = DOMCustomEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2496 DOMEvent_unlink(&custom_event->event.dispex);
2497 unlink_variant(&custom_event->detail);
2498 }
2499
2500 static void DOMCustomEvent_destructor(DispatchEx *dispex)
2501 {
2502 DOMCustomEvent *custom_event = DOMCustomEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2503 VariantClear(&custom_event->detail);
2504 DOMEvent_destructor(dispex);
2505 }
2506
2507 typedef struct {
2508 DOMEvent event;
2509 IDOMMessageEvent IDOMMessageEvent_iface;
2510 VARIANT data;
2511 } DOMMessageEvent;
2512
2513 static inline DOMMessageEvent *impl_from_IDOMMessageEvent(IDOMMessageEvent *iface)
2514 {
2515 return CONTAINING_RECORD(iface, DOMMessageEvent, IDOMMessageEvent_iface);
2516 }
2517
2518 static HRESULT WINAPI DOMMessageEvent_QueryInterface(IDOMMessageEvent *iface, REFIID riid, void **ppv)
2519 {
2520 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2521 return IDOMEvent_QueryInterface(&This->event.IDOMEvent_iface, riid, ppv);
2522 }
2523
2524 static ULONG WINAPI DOMMessageEvent_AddRef(IDOMMessageEvent *iface)
2525 {
2526 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2527 return IDOMEvent_AddRef(&This->event.IDOMEvent_iface);
2528 }
2529
2530 static ULONG WINAPI DOMMessageEvent_Release(IDOMMessageEvent *iface)
2531 {
2532 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2533 return IDOMEvent_Release(&This->event.IDOMEvent_iface);
2534 }
2535
2536 static HRESULT WINAPI DOMMessageEvent_GetTypeInfoCount(IDOMMessageEvent *iface, UINT *pctinfo)
2537 {
2538 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2539 return IDispatchEx_GetTypeInfoCount(&This->event.dispex.IDispatchEx_iface, pctinfo);
2540 }
2541
2542 static HRESULT WINAPI DOMMessageEvent_GetTypeInfo(IDOMMessageEvent *iface, UINT iTInfo,
2543 LCID lcid, ITypeInfo **ppTInfo)
2544 {
2545 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2546 return IDispatchEx_GetTypeInfo(&This->event.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2547 }
2548
2549 static HRESULT WINAPI DOMMessageEvent_GetIDsOfNames(IDOMMessageEvent *iface, REFIID riid,
2550 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2551 {
2552 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2553 return IDispatchEx_GetIDsOfNames(&This->event.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2554 lcid, rgDispId);
2555 }
2556
2557 static HRESULT WINAPI DOMMessageEvent_Invoke(IDOMMessageEvent *iface, DISPID dispIdMember,
2558 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
2559 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2560 {
2561 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2562 return IDispatchEx_Invoke(&This->event.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2563 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2564 }
2565
2566 static HRESULT WINAPI DOMMessageEvent_get_data(IDOMMessageEvent *iface, BSTR *p)
2567 {
2568 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2569
2570 TRACE("(%p)->(%p)\n", This, p);
2571
2572 if(V_VT(&This->data) != VT_BSTR) {
2573 FIXME("non-string data\n");
2574 return E_NOTIMPL;
2575 }
2576
2577 return (*p = SysAllocString(V_BSTR(&This->data))) ? S_OK : E_OUTOFMEMORY;
2578 }
2579
2580 static HRESULT DOMMessageEvent_get_data_hook(DispatchEx *dispex, WORD flags, DISPPARAMS *dp, VARIANT *res,
2581 EXCEPINFO *ei, IServiceProvider *caller)
2582 {
2583 DOMMessageEvent *This = CONTAINING_RECORD(dispex, DOMMessageEvent, event.dispex);
2584
2585 if(!(flags & DISPATCH_PROPERTYGET) || !res)
2586 return S_FALSE;
2587
2588 TRACE("(%p)->(%p)\n", This, res);
2589
2590 V_VT(res) = VT_EMPTY;
2591 return VariantCopy(res, &This->data);
2592 }
2593
2594 static HRESULT WINAPI DOMMessageEvent_get_origin(IDOMMessageEvent *iface, BSTR *p)
2595 {
2596 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2597 FIXME("(%p)->(%p)\n", This, p);
2598 return E_NOTIMPL;
2599 }
2600
2601 static HRESULT WINAPI DOMMessageEvent_get_source(IDOMMessageEvent *iface, IHTMLWindow2 **p)
2602 {
2603 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2604 FIXME("(%p)->(%p)\n", This, p);
2605 return E_NOTIMPL;
2606 }
2607
2608 static HRESULT WINAPI DOMMessageEvent_initMessageEvent(IDOMMessageEvent *iface, BSTR type, VARIANT_BOOL can_bubble,
2609 VARIANT_BOOL cancelable, BSTR data, BSTR origin,
2610 BSTR last_event_id, IHTMLWindow2 *source)
2611 {
2612 DOMMessageEvent *This = impl_from_IDOMMessageEvent(iface);
2613 FIXME("(%p)->(%s %x %x %s %s %s %p)\n", This, debugstr_w(type), can_bubble, cancelable,
2614 debugstr_w(data), debugstr_w(origin), debugstr_w(last_event_id), source);
2615 return E_NOTIMPL;
2616 }
2617
2618 static const IDOMMessageEventVtbl DOMMessageEventVtbl = {
2619 DOMMessageEvent_QueryInterface,
2620 DOMMessageEvent_AddRef,
2621 DOMMessageEvent_Release,
2622 DOMMessageEvent_GetTypeInfoCount,
2623 DOMMessageEvent_GetTypeInfo,
2624 DOMMessageEvent_GetIDsOfNames,
2625 DOMMessageEvent_Invoke,
2626 DOMMessageEvent_get_data,
2627 DOMMessageEvent_get_origin,
2628 DOMMessageEvent_get_source,
2629 DOMMessageEvent_initMessageEvent
2630 };
2631
2632 static DOMMessageEvent *DOMMessageEvent_from_DOMEvent(DOMEvent *event)
2633 {
2634 return CONTAINING_RECORD(event, DOMMessageEvent, event);
2635 }
2636
2637 static void *DOMMessageEvent_query_interface(DispatchEx *dispex, REFIID riid)
2638 {
2639 DOMMessageEvent *message_event = DOMMessageEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2640
2641 if(IsEqualGUID(&IID_IDOMMessageEvent, riid))
2642 return &message_event->IDOMMessageEvent_iface;
2643 return DOMEvent_query_interface(&message_event->event.dispex, riid);
2644 }
2645
2646 static void DOMMessageEvent_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
2647 {
2648 DOMMessageEvent *message_event = DOMMessageEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2649 DOMEvent_traverse(&message_event->event.dispex, cb);
2650 traverse_variant(&message_event->data, "data", cb);
2651 }
2652
2653 static void DOMMessageEvent_unlink(DispatchEx *dispex)
2654 {
2655 DOMMessageEvent *message_event = DOMMessageEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2656 DOMEvent_unlink(&message_event->event.dispex);
2657 unlink_variant(&message_event->data);
2658 }
2659
2660 static void DOMMessageEvent_destructor(DispatchEx *dispex)
2661 {
2662 DOMMessageEvent *message_event = DOMMessageEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2663 VariantClear(&message_event->data);
2664 DOMEvent_destructor(dispex);
2665 }
2666
2667 static void DOMMessageEvent_init_dispex_info(dispex_data_t *info, compat_mode_t compat_mode)
2668 {
2669 static const dispex_hook_t hooks[] = {
2670 {DISPID_IDOMMESSAGEEVENT_DATA, DOMMessageEvent_get_data_hook},
2671 {DISPID_UNKNOWN}
2672 };
2673 dispex_info_add_interface(info, IDOMMessageEvent_tid, compat_mode >= COMPAT_MODE_IE10 ? hooks : NULL);
2674 }
2675
2676 typedef struct {
2677 DOMEvent event;
2678 IDOMProgressEvent IDOMProgressEvent_iface;
2679 nsIDOMProgressEvent *nsevent;
2680 BOOL manual_init;
2681 } DOMProgressEvent;
2682
2683 static inline DOMProgressEvent *impl_from_IDOMProgressEvent(IDOMProgressEvent *iface)
2684 {
2685 return CONTAINING_RECORD(iface, DOMProgressEvent, IDOMProgressEvent_iface);
2686 }
2687
2688 static HRESULT WINAPI DOMProgressEvent_QueryInterface(IDOMProgressEvent *iface, REFIID riid, void **ppv)
2689 {
2690 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2691 return IDOMEvent_QueryInterface(&This->event.IDOMEvent_iface, riid, ppv);
2692 }
2693
2694 static ULONG WINAPI DOMProgressEvent_AddRef(IDOMProgressEvent *iface)
2695 {
2696 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2697 return IDOMEvent_AddRef(&This->event.IDOMEvent_iface);
2698 }
2699
2700 static ULONG WINAPI DOMProgressEvent_Release(IDOMProgressEvent *iface)
2701 {
2702 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2703 return IDOMEvent_Release(&This->event.IDOMEvent_iface);
2704 }
2705
2706 static HRESULT WINAPI DOMProgressEvent_GetTypeInfoCount(IDOMProgressEvent *iface, UINT *pctinfo)
2707 {
2708 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2709 return IDispatchEx_GetTypeInfoCount(&This->event.dispex.IDispatchEx_iface, pctinfo);
2710 }
2711
2712 static HRESULT WINAPI DOMProgressEvent_GetTypeInfo(IDOMProgressEvent *iface, UINT iTInfo,
2713 LCID lcid, ITypeInfo **ppTInfo)
2714 {
2715 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2716 return IDispatchEx_GetTypeInfo(&This->event.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2717 }
2718
2719 static HRESULT WINAPI DOMProgressEvent_GetIDsOfNames(IDOMProgressEvent *iface, REFIID riid,
2720 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2721 {
2722 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2723 return IDispatchEx_GetIDsOfNames(&This->event.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2724 lcid, rgDispId);
2725 }
2726
2727 static HRESULT WINAPI DOMProgressEvent_Invoke(IDOMProgressEvent *iface, DISPID dispIdMember,
2728 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
2729 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2730 {
2731 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2732 return IDispatchEx_Invoke(&This->event.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2733 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2734 }
2735
2736 static HRESULT WINAPI DOMProgressEvent_get_lengthComputable(IDOMProgressEvent *iface, VARIANT_BOOL *p)
2737 {
2738 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2739 nsresult nsres;
2740 cpp_bool b;
2741
2742 TRACE("(%p)->(%p)\n", This, p);
2743
2744 nsres = nsIDOMProgressEvent_GetLengthComputable(This->nsevent, &b);
2745 if(NS_FAILED(nsres))
2746 return map_nsresult(nsres);
2747
2748 *p = b ? VARIANT_TRUE : VARIANT_FALSE;
2749 return S_OK;
2750 }
2751
2752 static HRESULT WINAPI DOMProgressEvent_get_loaded(IDOMProgressEvent *iface, ULONGLONG *p)
2753 {
2754 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2755
2756 TRACE("(%p)->(%p)\n", This, p);
2757
2758 return map_nsresult(nsIDOMProgressEvent_GetLoaded(This->nsevent, p));
2759 }
2760
2761 static HRESULT WINAPI DOMProgressEvent_get_total(IDOMProgressEvent *iface, ULONGLONG *p)
2762 {
2763 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2764 cpp_bool b;
2765
2766 TRACE("(%p)->(%p)\n", This, p);
2767
2768 if(!This->manual_init && (NS_FAILED(nsIDOMProgressEvent_GetLengthComputable(This->nsevent, &b)) || !b)) {
2769 *p = ~0;
2770 return S_OK;
2771 }
2772
2773 return map_nsresult(nsIDOMProgressEvent_GetTotal(This->nsevent, p));
2774 }
2775
2776 static HRESULT WINAPI DOMProgressEvent_initProgressEvent(IDOMProgressEvent *iface, BSTR type, VARIANT_BOOL can_bubble,
2777 VARIANT_BOOL cancelable, VARIANT_BOOL lengthComputable,
2778 ULONGLONG loaded, ULONGLONG total)
2779 {
2780 DOMProgressEvent *This = impl_from_IDOMProgressEvent(iface);
2781 nsAString type_str;
2782 nsresult nsres;
2783 HRESULT hres;
2784
2785 TRACE("(%p)->(%s %x %x %x %s %s)\n", This, debugstr_w(type), can_bubble, cancelable, lengthComputable,
2786 wine_dbgstr_longlong(loaded), wine_dbgstr_longlong(total));
2787
2788 if(This->event.target) {
2789 TRACE("called on already dispatched event\n");
2790 return S_OK;
2791 }
2792
2793 hres = IDOMEvent_initEvent(&This->event.IDOMEvent_iface, type, can_bubble, cancelable);
2794 if(SUCCEEDED(hres)) {
2795 nsAString_InitDepend(&type_str, type);
2796 nsres = nsIDOMProgressEvent_InitProgressEvent(This->nsevent, &type_str, !!can_bubble, !!cancelable,
2797 !!lengthComputable, loaded, total);
2798 nsAString_Finish(&type_str);
2799 if(NS_FAILED(nsres))
2800 return map_nsresult(nsres);
2801 This->manual_init = TRUE;
2802 }
2803
2804 return hres;
2805 }
2806
2807 static const IDOMProgressEventVtbl DOMProgressEventVtbl = {
2808 DOMProgressEvent_QueryInterface,
2809 DOMProgressEvent_AddRef,
2810 DOMProgressEvent_Release,
2811 DOMProgressEvent_GetTypeInfoCount,
2812 DOMProgressEvent_GetTypeInfo,
2813 DOMProgressEvent_GetIDsOfNames,
2814 DOMProgressEvent_Invoke,
2815 DOMProgressEvent_get_lengthComputable,
2816 DOMProgressEvent_get_loaded,
2817 DOMProgressEvent_get_total,
2818 DOMProgressEvent_initProgressEvent
2819 };
2820
2821 static DOMProgressEvent *DOMProgressEvent_from_DOMEvent(DOMEvent *event)
2822 {
2823 return CONTAINING_RECORD(event, DOMProgressEvent, event);
2824 }
2825
2826 static void *DOMProgressEvent_query_interface(DispatchEx *dispex, REFIID riid)
2827 {
2828 DOMProgressEvent *This = DOMProgressEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2829
2830 if(IsEqualGUID(&IID_IDOMProgressEvent, riid))
2831 return &This->IDOMProgressEvent_iface;
2832 return DOMEvent_query_interface(&This->event.dispex, riid);
2833 }
2834
2835 static void DOMProgressEvent_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
2836 {
2837 DOMProgressEvent *This = DOMProgressEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2838 DOMEvent_traverse(&This->event.dispex, cb);
2839 if(This->nsevent)
2840 note_cc_edge((nsISupports*)This->nsevent, "ProgressEvent.nsevent", cb);
2841 }
2842
2843 static void DOMProgressEvent_unlink(DispatchEx *dispex)
2844 {
2845 DOMProgressEvent *This = DOMProgressEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
2846 DOMEvent_unlink(&This->event.dispex);
2847 unlink_ref(&This->nsevent);
2848 }
2849
2850 typedef struct {
2851 DOMEvent event;
2852 IDOMStorageEvent IDOMStorageEvent_iface;
2853 BSTR key;
2854 BSTR old_value;
2855 BSTR new_value;
2856 BSTR url;
2857 } DOMStorageEvent;
2858
2859 static inline DOMStorageEvent *impl_from_IDOMStorageEvent(IDOMStorageEvent *iface)
2860 {
2861 return CONTAINING_RECORD(iface, DOMStorageEvent, IDOMStorageEvent_iface);
2862 }
2863
2864 static HRESULT WINAPI DOMStorageEvent_QueryInterface(IDOMStorageEvent *iface, REFIID riid, void **ppv)
2865 {
2866 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2867 return IDOMEvent_QueryInterface(&This->event.IDOMEvent_iface, riid, ppv);
2868 }
2869
2870 static ULONG WINAPI DOMStorageEvent_AddRef(IDOMStorageEvent *iface)
2871 {
2872 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2873 return IDOMEvent_AddRef(&This->event.IDOMEvent_iface);
2874 }
2875
2876 static ULONG WINAPI DOMStorageEvent_Release(IDOMStorageEvent *iface)
2877 {
2878 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2879 return IDOMEvent_Release(&This->event.IDOMEvent_iface);
2880 }
2881
2882 static HRESULT WINAPI DOMStorageEvent_GetTypeInfoCount(IDOMStorageEvent *iface, UINT *pctinfo)
2883 {
2884 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2885 return IDispatchEx_GetTypeInfoCount(&This->event.dispex.IDispatchEx_iface, pctinfo);
2886 }
2887
2888 static HRESULT WINAPI DOMStorageEvent_GetTypeInfo(IDOMStorageEvent *iface, UINT iTInfo,
2889 LCID lcid, ITypeInfo **ppTInfo)
2890 {
2891 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2892 return IDispatchEx_GetTypeInfo(&This->event.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2893 }
2894
2895 static HRESULT WINAPI DOMStorageEvent_GetIDsOfNames(IDOMStorageEvent *iface, REFIID riid,
2896 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2897 {
2898 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2899 return IDispatchEx_GetIDsOfNames(&This->event.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2900 lcid, rgDispId);
2901 }
2902
2903 static HRESULT WINAPI DOMStorageEvent_Invoke(IDOMStorageEvent *iface, DISPID dispIdMember,
2904 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
2905 EXCEPINFO *pExcepInfo, UINT *puArgErr)
2906 {
2907 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2908 return IDispatchEx_Invoke(&This->event.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2909 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2910 }
2911
2912 static HRESULT WINAPI DOMStorageEvent_get_key(IDOMStorageEvent *iface, BSTR *p)
2913 {
2914 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2915
2916 TRACE("(%p)->(%p)\n", This, p);
2917
2918 if(This->key)
2919 return (*p = SysAllocStringLen(This->key, SysStringLen(This->key))) ? S_OK : E_OUTOFMEMORY;
2920 *p = NULL;
2921 return S_OK;
2922 }
2923
2924 static HRESULT WINAPI DOMStorageEvent_get_oldValue(IDOMStorageEvent *iface, BSTR *p)
2925 {
2926 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2927
2928 TRACE("(%p)->(%p)\n", This, p);
2929
2930 if(This->old_value)
2931 return (*p = SysAllocStringLen(This->old_value, SysStringLen(This->old_value))) ? S_OK : E_OUTOFMEMORY;
2932 *p = NULL;
2933 return S_OK;
2934 }
2935
2936 static HRESULT WINAPI DOMStorageEvent_get_newValue(IDOMStorageEvent *iface, BSTR *p)
2937 {
2938 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2939
2940 TRACE("(%p)->(%p)\n", This, p);
2941
2942 if(This->new_value)
2943 return (*p = SysAllocStringLen(This->new_value, SysStringLen(This->new_value))) ? S_OK : E_OUTOFMEMORY;
2944 *p = NULL;
2945 return S_OK;
2946 }
2947
2948 static HRESULT WINAPI DOMStorageEvent_get_url(IDOMStorageEvent *iface, BSTR *p)
2949 {
2950 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2951
2952 TRACE("(%p)->(%p)\n", This, p);
2953
2954 if(This->url)
2955 return (*p = SysAllocStringLen(This->url, SysStringLen(This->url))) ? S_OK : E_OUTOFMEMORY;
2956 *p = NULL;
2957 return S_OK;
2958 }
2959
2960 static HRESULT WINAPI DOMStorageEvent_get_storageArea(IDOMStorageEvent *iface, IHTMLStorage **p)
2961 {
2962 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2963 FIXME("(%p)->(%p)\n", This, p);
2964 return E_NOTIMPL;
2965 }
2966
2967 static HRESULT WINAPI DOMStorageEvent_initStorageEvent(IDOMStorageEvent *iface, BSTR type, VARIANT_BOOL can_bubble,
2968 VARIANT_BOOL cancelable, BSTR keyArg, BSTR oldValueArg,
2969 BSTR newValueArg, BSTR urlArg, IHTMLStorage *storageAreaArg)
2970 {
2971 DOMStorageEvent *This = impl_from_IDOMStorageEvent(iface);
2972 FIXME("(%p)->(%s %x %x %s %s %s %s %p)\n", This, debugstr_w(type), can_bubble, cancelable,
2973 debugstr_w(keyArg), debugstr_w(oldValueArg), debugstr_w(newValueArg), debugstr_w(urlArg), storageAreaArg);
2974 return E_NOTIMPL;
2975 }
2976
2977 static const IDOMStorageEventVtbl DOMStorageEventVtbl = {
2978 DOMStorageEvent_QueryInterface,
2979 DOMStorageEvent_AddRef,
2980 DOMStorageEvent_Release,
2981 DOMStorageEvent_GetTypeInfoCount,
2982 DOMStorageEvent_GetTypeInfo,
2983 DOMStorageEvent_GetIDsOfNames,
2984 DOMStorageEvent_Invoke,
2985 DOMStorageEvent_get_key,
2986 DOMStorageEvent_get_oldValue,
2987 DOMStorageEvent_get_newValue,
2988 DOMStorageEvent_get_url,
2989 DOMStorageEvent_get_storageArea,
2990 DOMStorageEvent_initStorageEvent
2991 };
2992
2993 static DOMStorageEvent *DOMStorageEvent_from_DOMEvent(DOMEvent *event)
2994 {
2995 return CONTAINING_RECORD(event, DOMStorageEvent, event);
2996 }
2997
2998 static void *DOMStorageEvent_query_interface(DispatchEx *dispex, REFIID riid)
2999 {
3000 DOMStorageEvent *storage_event = DOMStorageEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
3001
3002 if(IsEqualGUID(&IID_IDOMStorageEvent, riid))
3003 return &storage_event->IDOMStorageEvent_iface;
3004 return DOMEvent_query_interface(&storage_event->event.dispex, riid);
3005 }
3006
3007 static void DOMStorageEvent_destructor(DispatchEx *dispex)
3008 {
3009 DOMStorageEvent *storage_event = DOMStorageEvent_from_DOMEvent(DOMEvent_from_DispatchEx(dispex));
3010 SysFreeString(storage_event->key);
3011 SysFreeString(storage_event->old_value);
3012 SysFreeString(storage_event->new_value);
3013 SysFreeString(storage_event->url);
3014 DOMEvent_destructor(dispex);
3015 }
3016
3017 static const dispex_static_data_vtbl_t DOMEvent_dispex_vtbl = {
3018 .query_interface = DOMEvent_query_interface,
3019 .destructor = DOMEvent_destructor,
3020 .traverse = DOMEvent_traverse,
3021 .unlink = DOMEvent_unlink
3022 };
3023
3024 static const tid_t DOMEvent_iface_tids[] = {
3025 IDOMEvent_tid,
3026 0
3027 };
3028
3029 static dispex_static_data_t DOMEvent_dispex = {
3030 "Event",
3031 &DOMEvent_dispex_vtbl,
3032 DispDOMEvent_tid,
3033 DOMEvent_iface_tids
3034 };
3035
3036 static const dispex_static_data_vtbl_t DOMUIEvent_dispex_vtbl = {
3037 .query_interface = DOMUIEvent_query_interface,
3038 .destructor = DOMEvent_destructor,
3039 .traverse = DOMUIEvent_traverse,
3040 .unlink = DOMUIEvent_unlink
3041 };
3042
3043 static const tid_t DOMUIEvent_iface_tids[] = {
3044 IDOMEvent_tid,
3045 IDOMUIEvent_tid,
3046 0
3047 };
3048
3049 static dispex_static_data_t DOMUIEvent_dispex = {
3050 "UIEvent",
3051 &DOMUIEvent_dispex_vtbl,
3052 DispDOMUIEvent_tid,
3053 DOMUIEvent_iface_tids
3054 };
3055
3056 static const dispex_static_data_vtbl_t DOMMouseEvent_dispex_vtbl = {
3057 .query_interface = DOMMouseEvent_query_interface,
3058 .destructor = DOMEvent_destructor,
3059 .traverse = DOMMouseEvent_traverse,
3060 .unlink = DOMMouseEvent_unlink
3061 };
3062
3063 static const tid_t DOMMouseEvent_iface_tids[] = {
3064 IDOMEvent_tid,
3065 IDOMUIEvent_tid,
3066 IDOMMouseEvent_tid,
3067 0
3068 };
3069
3070 static dispex_static_data_t DOMMouseEvent_dispex = {
3071 "MouseEvent",
3072 &DOMMouseEvent_dispex_vtbl,
3073 DispDOMMouseEvent_tid,
3074 DOMMouseEvent_iface_tids
3075 };
3076
3077 static const dispex_static_data_vtbl_t DOMKeyboardEvent_dispex_vtbl = {
3078 .query_interface = DOMKeyboardEvent_query_interface,
3079 .destructor = DOMEvent_destructor,
3080 .traverse = DOMKeyboardEvent_traverse,
3081 .unlink = DOMKeyboardEvent_unlink
3082 };
3083
3084 static const tid_t DOMKeyboardEvent_iface_tids[] = {
3085 IDOMEvent_tid,
3086 IDOMUIEvent_tid,
3087 IDOMKeyboardEvent_tid,
3088 0
3089 };
3090
3091 static dispex_static_data_t DOMKeyboardEvent_dispex = {
3092 "KeyboardEvent",
3093 &DOMKeyboardEvent_dispex_vtbl,
3094 DispDOMKeyboardEvent_tid,
3095 DOMKeyboardEvent_iface_tids
3096 };
3097
3098 static void DOMPageTransitionEvent_init_dispex_info(dispex_data_t *info, compat_mode_t mode)
3099 {
3100 if(mode >= COMPAT_MODE_IE11)
3101 dispex_info_add_interface(info, IWinePageTransitionEvent_tid, NULL);
3102 }
3103
3104 static const dispex_static_data_vtbl_t DOMPageTransitionEvent_dispex_vtbl = {
3105 .query_interface = DOMPageTransitionEvent_query_interface,
3106 .destructor = DOMEvent_destructor,
3107 .traverse = DOMEvent_traverse,
3108 .unlink = DOMEvent_unlink
3109 };
3110
3111 static dispex_static_data_t DOMPageTransitionEvent_dispex = {
3112 "PageTransitionEvent",
3113 &DOMPageTransitionEvent_dispex_vtbl,
3114 DispDOMEvent_tid,
3115 DOMEvent_iface_tids,
3116 DOMPageTransitionEvent_init_dispex_info
3117 };
3118
3119 static const dispex_static_data_vtbl_t DOMCustomEvent_dispex_vtbl = {
3120 .query_interface = DOMCustomEvent_query_interface,
3121 .destructor = DOMCustomEvent_destructor,
3122 .traverse = DOMCustomEvent_traverse,
3123 .unlink = DOMCustomEvent_unlink
3124 };
3125
3126 static const tid_t DOMCustomEvent_iface_tids[] = {
3127 IDOMEvent_tid,
3128 IDOMCustomEvent_tid,
3129 0
3130 };
3131
3132 static dispex_static_data_t DOMCustomEvent_dispex = {
3133 "CustomEvent",
3134 &DOMCustomEvent_dispex_vtbl,
3135 DispDOMCustomEvent_tid,
3136 DOMCustomEvent_iface_tids
3137 };
3138
3139 static const dispex_static_data_vtbl_t DOMMessageEvent_dispex_vtbl = {
3140 .query_interface = DOMMessageEvent_query_interface,
3141 .destructor = DOMMessageEvent_destructor,
3142 .traverse = DOMMessageEvent_traverse,
3143 .unlink = DOMMessageEvent_unlink
3144 };
3145
3146 static const tid_t DOMMessageEvent_iface_tids[] = {
3147 IDOMEvent_tid,
3148 0
3149 };
3150
3151 static dispex_static_data_t DOMMessageEvent_dispex = {
3152 "MessageEvent",
3153 &DOMMessageEvent_dispex_vtbl,
3154 DispDOMMessageEvent_tid,
3155 DOMMessageEvent_iface_tids,
3156 DOMMessageEvent_init_dispex_info
3157 };
3158
3159 static const dispex_static_data_vtbl_t DOMProgressEvent_dispex_vtbl = {
3160 .query_interface = DOMProgressEvent_query_interface,
3161 .destructor = DOMEvent_destructor,
3162 .traverse = DOMProgressEvent_traverse,
3163 .unlink = DOMProgressEvent_unlink
3164 };
3165
3166 static const tid_t DOMProgressEvent_iface_tids[] = {
3167 IDOMEvent_tid,
3168 IDOMProgressEvent_tid,
3169 0
3170 };
3171
3172 static dispex_static_data_t DOMProgressEvent_dispex = {
3173 "ProgressEvent",
3174 &DOMProgressEvent_dispex_vtbl,
3175 DispDOMProgressEvent_tid,
3176 DOMProgressEvent_iface_tids
3177 };
3178
3179 static const dispex_static_data_vtbl_t DOMStorageEvent_dispex_vtbl = {
3180 .query_interface = DOMStorageEvent_query_interface,
3181 .destructor = DOMStorageEvent_destructor,
3182 .traverse = DOMEvent_traverse,
3183 .unlink = DOMEvent_unlink
3184 };
3185
3186 static const tid_t DOMStorageEvent_iface_tids[] = {
3187 IDOMEvent_tid,
3188 IDOMStorageEvent_tid,
3189 0
3190 };
3191
3192 static dispex_static_data_t DOMStorageEvent_dispex = {
3193 "StorageEvent",
3194 &DOMStorageEvent_dispex_vtbl,
3195 DispDOMStorageEvent_tid,
3196 DOMStorageEvent_iface_tids
3197 };
3198
3199 static void *event_ctor(unsigned size, dispex_static_data_t *dispex_data, nsIDOMEvent *nsevent, eventid_t event_id,
3200 compat_mode_t compat_mode)
3201 {
3202 DOMEvent *event = calloc(1, size);
3203
3204 if(!event)
3205 return NULL;
3206 event->IDOMEvent_iface.lpVtbl = &DOMEventVtbl;
3207 event->event_id = event_id;
3208 if(event_id != EVENTID_LAST) {
3209 event->type = wcsdup(event_info[event_id].name);
3210 if(!event->type) {
3211 free(event);
3212 return NULL;
3213 }
3214 event->bubbles = (event_info[event_id].flags & EVENT_BUBBLES) != 0;
3215 event->cancelable = (event_info[event_id].flags & EVENT_CANCELABLE) != 0;
3216 }
3217 nsIDOMEvent_AddRef(event->nsevent = nsevent);
3218
3219 event->time_stamp = get_time_stamp();
3220
3221 init_dispatch(&event->dispex, dispex_data, compat_mode);
3222 return event;
3223 }
3224
3225 static void fill_parent_ui_event(nsIDOMEvent *nsevent, DOMUIEvent *ui_event)
3226 {
3227 ui_event->IDOMUIEvent_iface.lpVtbl = &DOMUIEventVtbl;
3228 nsIDOMEvent_QueryInterface(nsevent, &IID_nsIDOMUIEvent, (void**)&ui_event->nsevent);
3229 }
3230
3231 static DOMEvent *generic_event_ctor(void *iface, nsIDOMEvent *nsevent, eventid_t event_id, compat_mode_t compat_mode)
3232 {
3233 return event_ctor(sizeof(DOMEvent), &DOMEvent_dispex, nsevent, event_id, compat_mode);
3234 }
3235
3236 static DOMEvent *ui_event_ctor(void *iface, nsIDOMEvent *nsevent, eventid_t event_id, compat_mode_t compat_mode)
3237 {
3238 DOMUIEvent *ui_event = event_ctor(sizeof(DOMUIEvent), &DOMUIEvent_dispex, nsevent, event_id, compat_mode);
3239 if(!ui_event) return NULL;
3240 ui_event->IDOMUIEvent_iface.lpVtbl = &DOMUIEventVtbl;
3241 ui_event->nsevent = iface;
3242 return &ui_event->event;
3243 }
3244
3245 static DOMEvent *mouse_event_ctor(void *iface, nsIDOMEvent *nsevent, eventid_t event_id, compat_mode_t compat_mode)
3246 {
3247 DOMMouseEvent *mouse_event = event_ctor(sizeof(DOMMouseEvent), &DOMMouseEvent_dispex, nsevent, event_id, compat_mode);
3248 if(!mouse_event) return NULL;
3249 mouse_event->IDOMMouseEvent_iface.lpVtbl = &DOMMouseEventVtbl;
3250 mouse_event->nsevent = iface;
3251 fill_parent_ui_event(nsevent, &mouse_event->ui_event);
3252 return &mouse_event->ui_event.event;
3253 }
3254
3255 static DOMEvent *keyboard_event_ctor(void *iface, nsIDOMEvent *nsevent, eventid_t event_id, compat_mode_t compat_mode)
3256 {
3257 DOMKeyboardEvent *keyboard_event = event_ctor(sizeof(DOMKeyboardEvent), &DOMKeyboardEvent_dispex, nsevent, event_id, compat_mode);
3258 if(!keyboard_event) return NULL;
3259 keyboard_event->IDOMKeyboardEvent_iface.lpVtbl = &DOMKeyboardEventVtbl;
3260 keyboard_event->nsevent = iface;
3261 fill_parent_ui_event(nsevent, &keyboard_event->ui_event);
3262 return &keyboard_event->ui_event.event;
3263 }
3264
3265 static DOMEvent *page_transition_event_ctor(void *iface, nsIDOMEvent *nsevent, eventid_t event_id, compat_mode_t compat_mode)
3266 {
3267 DOMPageTransitionEvent *page_transition_event = event_ctor(sizeof(DOMCustomEvent), &DOMPageTransitionEvent_dispex, nsevent, event_id, compat_mode);
3268 if(!page_transition_event) return NULL;
3269 page_transition_event->IWinePageTransitionEvent_iface.lpVtbl = &DOMPageTransitionEventVtbl;
3270 return &page_transition_event->event;
3271 }
3272
3273 static DOMEvent *custom_event_ctor(void *iface, nsIDOMEvent *nsevent, eventid_t event_id, compat_mode_t compat_mode)
3274 {
3275 DOMCustomEvent *custom_event = event_ctor(sizeof(DOMCustomEvent), &DOMCustomEvent_dispex, nsevent, event_id, compat_mode);
3276 if(!custom_event) return NULL;
3277 custom_event->IDOMCustomEvent_iface.lpVtbl = &DOMCustomEventVtbl;
3278 nsIDOMCustomEvent_Release(iface);
3279 return &custom_event->event;
3280 }
3281
3282 static DOMEvent *progress_event_ctor(void *iface, nsIDOMEvent *nsevent, eventid_t event_id, compat_mode_t compat_mode)
3283 {
3284 DOMProgressEvent *progress_event;
3285
3286 if(!(progress_event = event_ctor(sizeof(DOMProgressEvent), &DOMProgressEvent_dispex, nsevent, event_id, compat_mode)))
3287 return NULL;
3288 progress_event->IDOMProgressEvent_iface.lpVtbl = &DOMProgressEventVtbl;
3289 progress_event->nsevent = iface;
3290 return &progress_event->event;
3291 }
3292
3293 static DOMEvent *message_event_ctor(void *iface, nsIDOMEvent *nsevent, eventid_t event_id, compat_mode_t compat_mode)
3294 {
3295 DOMMessageEvent *message_event = event_ctor(sizeof(DOMMessageEvent), &DOMMessageEvent_dispex, nsevent, event_id, compat_mode);
3296 if(!message_event) return NULL;
3297 message_event->IDOMMessageEvent_iface.lpVtbl = &DOMMessageEventVtbl;
3298 return &message_event->event;
3299 }
3300
3301 static DOMEvent *storage_event_ctor(void *iface, nsIDOMEvent *nsevent, eventid_t event_id, compat_mode_t compat_mode)
3302 {
3303 DOMStorageEvent *storage_event = event_ctor(sizeof(DOMStorageEvent), &DOMStorageEvent_dispex, nsevent, event_id, compat_mode);
3304 if(!storage_event) return NULL;
3305 storage_event->IDOMStorageEvent_iface.lpVtbl = &DOMStorageEventVtbl;
3306 return &storage_event->event;
3307 }
3308
3309 static const struct {
3310 REFIID iid;
3311 DOMEvent *(*ctor)(void *iface, nsIDOMEvent *nsevent, eventid_t, compat_mode_t);
3312 compat_mode_t min_compat_mode;
3313 } event_types_ctor_table[] = {
3314 [EVENT_TYPE_EVENT] = { NULL, generic_event_ctor },
3315 [EVENT_TYPE_UIEVENT] = { &IID_nsIDOMUIEvent, ui_event_ctor },
3316 [EVENT_TYPE_MOUSE] = { &IID_nsIDOMMouseEvent, mouse_event_ctor },
3317 [EVENT_TYPE_KEYBOARD] = { &IID_nsIDOMKeyEvent, keyboard_event_ctor },
3318 [EVENT_TYPE_CLIPBOARD] = { NULL, generic_event_ctor },
3319 [EVENT_TYPE_FOCUS] = { NULL, generic_event_ctor },
3320 [EVENT_TYPE_DRAG] = { NULL, generic_event_ctor },
3321 [EVENT_TYPE_PAGETRANSITION] = { NULL, page_transition_event_ctor },
3322 [EVENT_TYPE_CUSTOM] = { &IID_nsIDOMCustomEvent, custom_event_ctor },
3323 [EVENT_TYPE_PROGRESS] = { &IID_nsIDOMProgressEvent, progress_event_ctor, COMPAT_MODE_IE10 },
3324 [EVENT_TYPE_MESSAGE] = { NULL, message_event_ctor },
3325 [EVENT_TYPE_STORAGE] = { NULL, storage_event_ctor },
3326 };
3327
3328 static DOMEvent *alloc_event(nsIDOMEvent *nsevent, compat_mode_t compat_mode, event_type_t event_type,
3329 eventid_t event_id)
3330 {
3331 void *iface = NULL;
3332 DOMEvent *event;
3333
3334 if(compat_mode < event_types_ctor_table[event_type].min_compat_mode)
3335 event_type = EVENT_TYPE_EVENT;
3336
3337 if(event_types_ctor_table[event_type].iid)
3338 nsIDOMEvent_QueryInterface(nsevent, event_types_ctor_table[event_type].iid, &iface);
3339
3340 /* Transfer the iface ownership to the ctor on success */
3341 if(!(event = event_types_ctor_table[event_type].ctor(iface, nsevent, event_id, compat_mode)) && iface)
3342 nsISupports_Release(iface);
3343 return event;
3344 }
3345
3346 HRESULT create_event_from_nsevent(nsIDOMEvent *nsevent, compat_mode_t compat_mode, DOMEvent **ret_event)
3347 {
3348 event_type_t event_type = EVENT_TYPE_EVENT;
3349 eventid_t event_id = EVENTID_LAST;
3350 DOMEvent *event;
3351 nsAString nsstr;
3352 nsresult nsres;
3353 unsigned i;
3354
3355 nsAString_Init(&nsstr, NULL);
3356 nsres = nsIDOMEvent_GetType(nsevent, &nsstr);
3357 if(NS_SUCCEEDED(nsres)) {
3358 const WCHAR *type;
3359 nsAString_GetData(&nsstr, &type);
3360 event_id = str_to_eid(type);
3361 if(event_id == EVENTID_LAST)
3362 FIXME("unknown event type %s\n", debugstr_w(type));
3363 }else {
3364 ERR("GetType failed: %08lx\n", nsres);
3365 }
3366 nsAString_Finish(&nsstr);
3367
3368 for(i = 0; i < ARRAY_SIZE(event_types_ctor_table); i++) {
3369 void *iface;
3370 if(event_types_ctor_table[i].iid &&
3371 nsIDOMEvent_QueryInterface(nsevent, event_types_ctor_table[i].iid, &iface) == NS_OK) {
3372 nsISupports_Release(iface);
3373 event_type = i;
3374 break;
3375 }
3376 }
3377
3378 event = alloc_event(nsevent, compat_mode, event_type, event_id);
3379 if(!event)
3380 return E_OUTOFMEMORY;
3381
3382 event->trusted = TRUE;
3383 *ret_event = event;
3384 return S_OK;
3385 }
3386
3387 HRESULT create_document_event_str(HTMLDocumentNode *doc, const WCHAR *type, IDOMEvent **ret_event)
3388 {
3389 event_type_t event_type = EVENT_TYPE_EVENT;
3390 nsIDOMEvent *nsevent;
3391 DOMEvent *event;
3392 nsAString nsstr;
3393 nsresult nsres;
3394 unsigned i;
3395
3396 nsAString_InitDepend(&nsstr, type);
3397 nsres = nsIDOMDocument_CreateEvent(doc->dom_document, &nsstr, &nsevent);
3398 nsAString_Finish(&nsstr);
3399 if(NS_FAILED(nsres)) {
3400 FIXME("CreateEvent(%s) failed: %08lx\n", debugstr_w(type), nsres);
3401 return E_FAIL;
3402 }
3403
3404 for(i = 0; i < ARRAY_SIZE(event_types); i++) {
3405 if(!wcsicmp(type, event_types[i])) {
3406 event_type = i;
3407 break;
3408 }
3409 }
3410
3411 event = alloc_event(nsevent, dispex_compat_mode(&doc->node.event_target.dispex),
3412 event_type, EVENTID_LAST);
3413 nsIDOMEvent_Release(nsevent);
3414 if(!event)
3415 return E_OUTOFMEMORY;
3416
3417 *ret_event = &event->IDOMEvent_iface;
3418 return S_OK;
3419 }
3420
3421 HRESULT create_document_event(HTMLDocumentNode *doc, eventid_t event_id, DOMEvent **ret_event)
3422 {
3423 nsIDOMEvent *nsevent;
3424 DOMEvent *event;
3425 nsAString nsstr;
3426 nsresult nsres;
3427
3428 nsAString_InitDepend(&nsstr, event_types[event_info[event_id].type]);
3429 nsres = nsIDOMDocument_CreateEvent(doc->dom_document, &nsstr, &nsevent);
3430 nsAString_Finish(&nsstr);
3431 if(NS_FAILED(nsres)) {
3432 FIXME("CreateEvent(%s) failed: %08lx\n", debugstr_w(event_types[event_info[event_id].type]), nsres);
3433 return E_FAIL;
3434 }
3435
3436 event = alloc_event(nsevent, doc->document_mode, event_info[event_id].type, event_id);
3437 nsIDOMEvent_Release(nsevent);
3438 if(!event)
3439 return E_OUTOFMEMORY;
3440
3441 event->event_id = event_id;
3442 event->trusted = TRUE;
3443 *ret_event = event;
3444 return S_OK;
3445 }
3446
3447 HRESULT create_message_event(HTMLDocumentNode *doc, VARIANT *data, DOMEvent **ret)
3448 {
3449 DOMMessageEvent *message_event;
3450 DOMEvent *event;
3451 HRESULT hres;
3452
3453 hres = create_document_event(doc, EVENTID_MESSAGE, &event);
3454 if(FAILED(hres))
3455 return hres;
3456 message_event = DOMMessageEvent_from_DOMEvent(event);
3457
3458 V_VT(&message_event->data) = VT_EMPTY;
3459 hres = VariantCopy(&message_event->data, data);
3460 if(FAILED(hres)) {
3461 IDOMEvent_Release(&event->IDOMEvent_iface);
3462 return hres;
3463 }
3464
3465 *ret = event;
3466 return S_OK;
3467 }
3468
3469 HRESULT create_storage_event(HTMLDocumentNode *doc, BSTR key, BSTR old_value, BSTR new_value,
3470 const WCHAR *url, BOOL commit, DOMEvent **ret)
3471 {
3472 DOMStorageEvent *storage_event;
3473 DOMEvent *event;
3474 HRESULT hres;
3475
3476 hres = create_document_event(doc, commit ? EVENTID_STORAGECOMMIT : EVENTID_STORAGE, &event);
3477 if(FAILED(hres))
3478 return hres;
3479 storage_event = DOMStorageEvent_from_DOMEvent(event);
3480
3481 if(!commit) {
3482 if((key && !(storage_event->key = SysAllocString(key))) ||
3483 (old_value && !(storage_event->old_value = SysAllocString(old_value))) ||
3484 (new_value && !(storage_event->new_value = SysAllocString(new_value)))) {
3485 IDOMEvent_Release(&event->IDOMEvent_iface);
3486 return E_OUTOFMEMORY;
3487 }
3488 }
3489
3490 if(url && !(storage_event->url = SysAllocString(url))) {
3491 IDOMEvent_Release(&event->IDOMEvent_iface);
3492 return E_OUTOFMEMORY;
3493 }
3494
3495 *ret = event;
3496 return S_OK;
3497 }
3498
3499 HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv)
3500 {
3501 IDispatchEx *dispex;
3502 EXCEPINFO ei;
3503 HRESULT hres;
3504
3505 memset(&ei, 0, sizeof(ei));
3506
3507 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
3508 if(SUCCEEDED(hres)) {
3509 hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL);
3510 IDispatchEx_Release(dispex);
3511 }else {
3512 TRACE("Could not get IDispatchEx interface: %08lx\n", hres);
3513 hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,
3514 dp, retv, &ei, NULL);
3515 }
3516
3517 return hres;
3518 }
3519
3520 static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, IHTMLEventObj *event_obj, VARIANT *retv)
3521 {
3522 DISPPARAMS dp = {NULL,NULL,0,0};
3523 VARIANT event_arg;
3524 UINT argerr;
3525 EXCEPINFO ei;
3526
3527 TRACE("%p,%ld,%p,%p\n", disp, dispid, event_obj, retv);
3528
3529 if(event_obj) {
3530 V_VT(&event_arg) = VT_DISPATCH;
3531 V_DISPATCH(&event_arg) = (IDispatch*)event_obj;
3532 dp.rgvarg = &event_arg;
3533 dp.cArgs = 1;
3534 }
3535
3536 memset(&ei, 0, sizeof(ei));
3537 return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr);
3538 }
3539
3540 static BOOL use_event_quirks(EventTarget *event_target)
3541 {
3542 return dispex_compat_mode(&event_target->dispex) < COMPAT_MODE_IE9;
3543 }
3544
3545 static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid)
3546 {
3547 int min, max, i;
3548 HRESULT hres;
3549
3550 if(!data || dispid == DISPID_UNKNOWN)
3551 return FALSE;
3552
3553 if(!data->ids) {
3554 hres = get_dispids(data->tid, &data->id_cnt, &data->ids);
3555 if(FAILED(hres))
3556 return FALSE;
3557 }
3558
3559 min = 0;
3560 max = data->id_cnt-1;
3561 while(min <= max) {
3562 i = (min+max)/2;
3563 if(data->ids[i] == dispid)
3564 return TRUE;
3565
3566 if(data->ids[i] < dispid)
3567 min = i+1;
3568 else
3569 max = i-1;
3570 }
3571
3572 return FALSE;
3573 }
3574
3575 static void call_event_handlers(EventTarget *event_target, DOMEvent *event, dispatch_mode_t dispatch_mode)
3576 {
3577 const listener_container_t *container = get_listener_container(event_target, event->type, FALSE);
3578 const event_target_vtbl_t *vtbl = dispex_get_vtbl(&event_target->dispex);
3579 event_listener_t *listener, listeners_buf[8], *listeners = listeners_buf;
3580 unsigned listeners_cnt, listeners_size;
3581 ConnectionPointContainer *cp_container = NULL;
3582 BOOL skip_onevent_listener = FALSE;
3583 VARIANT v;
3584 HRESULT hres;
3585
3586 assert(!event->current_target);
3587 event->current_target = event_target;
3588
3589 if(container && !list_empty(&container->listeners) && event->phase != DEP_CAPTURING_PHASE) {
3590 listener = LIST_ENTRY(list_tail(&container->listeners), event_listener_t, entry);
3591 if(listener && listener->function && listener->type == LISTENER_TYPE_ONEVENT
3592 && use_event_quirks(event_target)) {
3593 DISPID named_arg = DISPID_THIS;
3594 VARIANTARG arg;
3595 DISPPARAMS dp = {&arg, &named_arg, 1, 1};
3596
3597 skip_onevent_listener = TRUE;
3598
3599 V_VT(&arg) = VT_DISPATCH;
3600 V_DISPATCH(&arg) = (IDispatch*)&event_target->dispex.IDispatchEx_iface;
3601 V_VT(&v) = VT_EMPTY;
3602 if(vtbl->get_dispatch_this)
3603 V_DISPATCH(&arg) = vtbl->get_dispatch_this(&event_target->dispex);
3604 IDispatch_AddRef(V_DISPATCH(&arg));
3605
3606 TRACE("%p %s >>>\n", event_target, debugstr_w(event->type));
3607 hres = call_disp_func(listener->function, &dp, &v);
3608 IDispatch_Release(V_DISPATCH(&arg));
3609
3610 if(hres == S_OK) {
3611 TRACE("%p %s <<< %s\n", event_target, debugstr_w(event->type), debugstr_variant(&v));
3612
3613 if(event->cancelable) {
3614 if(V_VT(&v) == VT_BOOL) {
3615 if(!V_BOOL(&v))
3616 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
3617 }else if(V_VT(&v) != VT_EMPTY) {
3618 FIXME("unhandled result %s\n", debugstr_variant(&v));
3619 }
3620 }
3621 VariantClear(&v);
3622 }else {
3623 WARN("%p %s <<< %08lx\n", event_target, debugstr_w(event->type), hres);
3624 }
3625 }
3626 }
3627
3628 listeners_cnt = 0;
3629 listeners_size = ARRAY_SIZE(listeners_buf);
3630
3631 if(container) {
3632 LIST_FOR_EACH_ENTRY(listener, &container->listeners, event_listener_t, entry) {
3633 if(!listener->function)
3634 continue;
3635 switch(listener->type) {
3636 case LISTENER_TYPE_ONEVENT:
3637 if(skip_onevent_listener || event->phase == DEP_CAPTURING_PHASE)
3638 continue;
3639 break;
3640 case LISTENER_TYPE_CAPTURE:
3641 if(event->phase == DEP_BUBBLING_PHASE || dispatch_mode == DISPATCH_LEGACY)
3642 continue;
3643 break;
3644 case LISTENER_TYPE_BUBBLE:
3645 if(event->phase == DEP_CAPTURING_PHASE || dispatch_mode == DISPATCH_LEGACY)
3646 continue;
3647 break;
3648 case LISTENER_TYPE_ATTACHED:
3649 if(event->phase == DEP_CAPTURING_PHASE || dispatch_mode == DISPATCH_STANDARD)
3650 continue;
3651 break;
3652 }
3653
3654 if(listeners_cnt == listeners_size) {
3655 event_listener_t *new_listeners;
3656 if(listeners == listeners_buf) {
3657 new_listeners = malloc(listeners_size * 2 * sizeof(*new_listeners));
3658 if(!new_listeners)
3659 break;
3660 memcpy(new_listeners, listeners, listeners_cnt * sizeof(*listeners));
3661 }else {
3662 new_listeners = realloc(listeners, listeners_size * 2 * sizeof(*new_listeners));
3663 }
3664 listeners = new_listeners;
3665 listeners_size *= 2;
3666 }
3667
3668 listeners[listeners_cnt].type = listener->type;
3669 IDispatch_AddRef(listeners[listeners_cnt].function = listener->function);
3670 listeners_cnt++;
3671 }
3672 }
3673
3674 for(listener = listeners; !event->stop_immediate_propagation
3675 && listener < listeners + listeners_cnt; listener++) {
3676 if(listener->type != LISTENER_TYPE_ATTACHED) {
3677 DISPID named_arg = DISPID_THIS;
3678 VARIANTARG args[2];
3679 DISPPARAMS dp = {args, &named_arg, 2, 1};
3680
3681 V_VT(args) = VT_DISPATCH;
3682 V_DISPATCH(args) = (IDispatch*)&event_target->dispex.IDispatchEx_iface;
3683 if(vtbl->get_dispatch_this)
3684 V_DISPATCH(args) = vtbl->get_dispatch_this(&event_target->dispex);
3685 IDispatch_AddRef(V_DISPATCH(args));
3686
3687 V_VT(args+1) = VT_DISPATCH;
3688 V_DISPATCH(args+1) = dispatch_mode == DISPATCH_LEGACY
3689 ? (IDispatch*)event->event_obj : (IDispatch*)&event->IDOMEvent_iface;
3690 V_VT(&v) = VT_EMPTY;
3691
3692 TRACE("%p %s >>>\n", event_target, debugstr_w(event->type));
3693 hres = call_disp_func(listener->function, &dp, &v);
3694 IDispatch_Release(V_DISPATCH(args));
3695
3696 if(hres == S_OK) {
3697 TRACE("%p %s <<< %s\n", event_target, debugstr_w(event->type),
3698 debugstr_variant(&v));
3699
3700 if(event->cancelable) {
3701 if(V_VT(&v) == VT_BOOL) {
3702 if(!V_BOOL(&v))
3703 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
3704 }else if(V_VT(&v) != VT_EMPTY) {
3705 FIXME("unhandled result %s\n", debugstr_variant(&v));
3706 }
3707 }
3708 VariantClear(&v);
3709 }else {
3710 WARN("%p %s <<< %08lx\n", event_target, debugstr_w(event->type), hres);
3711 }
3712 }else {
3713 VARIANTARG arg;
3714 DISPPARAMS dp = {&arg, NULL, 1, 0};
3715
3716 V_VT(&arg) = VT_DISPATCH;
3717 V_DISPATCH(&arg) = (IDispatch*)event->event_obj;
3718 V_VT(&v) = VT_EMPTY;
3719
3720 TRACE("%p %s attached >>>\n", event_target, debugstr_w(event->type));
3721 hres = call_disp_func(listener->function, &dp, &v);
3722 if(hres == S_OK) {
3723 TRACE("%p %s attached <<<\n", event_target, debugstr_w(event->type));
3724
3725 if(event->cancelable) {
3726 if(V_VT(&v) == VT_BOOL) {
3727 if(!V_BOOL(&v))
3728 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
3729 }else if(V_VT(&v) != VT_EMPTY) {
3730 FIXME("unhandled result %s\n", debugstr_variant(&v));
3731 }
3732 }
3733 VariantClear(&v);
3734 }else {
3735 WARN("%p %s attached <<< %08lx\n", event_target, debugstr_w(event->type), hres);
3736 }
3737 }
3738 }
3739
3740 for(listener = listeners; listener < listeners + listeners_cnt; listener++)
3741 IDispatch_Release(listener->function);
3742 if(listeners != listeners_buf)
3743 free(listeners);
3744
3745 if(event->phase != DEP_CAPTURING_PHASE && event_info[event->event_id].dispid && vtbl->get_cp_container)
3746 cp_container = vtbl->get_cp_container(&event_target->dispex);
3747 if(cp_container) {
3748 if(cp_container->cps) {
3749 ConnectionPoint *cp;
3750 unsigned i, j;
3751
3752 for(j=0; cp_container->cp_entries[j].riid; j++) {
3753 cp = cp_container->cps + j;
3754 if(!cp->sinks_size || !is_cp_event(cp->data, event_info[event->event_id].dispid))
3755 continue;
3756
3757 for(i=0; i < cp->sinks_size; i++) {
3758 if(!cp->sinks[i].disp)
3759 continue;
3760
3761 V_VT(&v) = VT_EMPTY;
3762
3763 TRACE("%p cp %s [%u] >>>\n", event_target, debugstr_w(event->type), i);
3764 hres = call_cp_func(cp->sinks[i].disp, event_info[event->event_id].dispid,
3765 cp->data->pass_event_arg ? event->event_obj : NULL, &v);
3766 if(hres == S_OK) {
3767 TRACE("%p cp %s [%u] <<<\n", event_target, debugstr_w(event->type), i);
3768
3769 if(event->cancelable) {
3770 if(V_VT(&v) == VT_BOOL) {
3771 if(!V_BOOL(&v))
3772 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
3773 }else if(V_VT(&v) != VT_EMPTY) {
3774 FIXME("unhandled result %s\n", debugstr_variant(&v));
3775 }
3776 }
3777 VariantClear(&v);
3778 }else {
3779 WARN("%p cp %s [%u] <<< %08lx\n", event_target, debugstr_w(event->type), i, hres);
3780 }
3781 }
3782 }
3783 }
3784 IConnectionPointContainer_Release(&cp_container->IConnectionPointContainer_iface);
3785 }
3786
3787 event->current_target = NULL;
3788 }
3789
3790 static HRESULT dispatch_event_object(EventTarget *event_target, DOMEvent *event,
3791 dispatch_mode_t dispatch_mode, VARIANT_BOOL *r)
3792 {
3793 EventTarget *target_chain_buf[8], **target_chain = target_chain_buf;
3794 unsigned chain_cnt, chain_buf_size, i;
3795 const event_target_vtbl_t *vtbl, *target_vtbl;
3796 HTMLEventObj *event_obj_ref = NULL;
3797 IHTMLEventObj *prev_event = NULL;
3798 EventTarget *iter;
3799 HRESULT hres;
3800
3801 TRACE("(%p) %s\n", event_target, debugstr_w(event->type));
3802
3803 if(!event->type) {
3804 FIXME("Uninitialized event.\n");
3805 return E_FAIL;
3806 }
3807
3808 if(event->current_target) {
3809 FIXME("event is being dispatched.\n");
3810 return E_FAIL;
3811 }
3812
3813 iter = event_target;
3814 IEventTarget_AddRef(&event_target->IEventTarget_iface);
3815
3816 chain_cnt = 0;
3817 chain_buf_size = ARRAY_SIZE(target_chain_buf);
3818
3819 do {
3820 if(chain_cnt == chain_buf_size) {
3821 EventTarget **new_chain;
3822 if(target_chain == target_chain_buf) {
3823 new_chain = malloc(chain_buf_size * 2 * sizeof(*new_chain));
3824 if(!new_chain)
3825 break;
3826 memcpy(new_chain, target_chain, chain_buf_size * sizeof(*new_chain));
3827 }else {
3828 new_chain = realloc(target_chain, chain_buf_size * 2 * sizeof(*new_chain));
3829 if(!new_chain)
3830 break;
3831 }
3832 chain_buf_size *= 2;
3833 target_chain = new_chain;
3834 }
3835
3836 target_chain[chain_cnt++] = iter;
3837
3838 if(!(vtbl = dispex_get_vtbl(&iter->dispex))->get_parent_event_target)
3839 break;
3840 iter = vtbl->get_parent_event_target(&iter->dispex);
3841 } while(iter);
3842
3843 if(!event->event_obj && !event->no_event_obj) {
3844 event_obj_ref = alloc_event_obj(event, dispex_compat_mode(&event->dispex));
3845 if(event_obj_ref)
3846 event->event_obj = &event_obj_ref->IHTMLEventObj_iface;
3847 }
3848
3849 target_vtbl = dispex_get_vtbl(&event_target->dispex);
3850 if(target_vtbl->set_current_event)
3851 prev_event = target_vtbl->set_current_event(&event_target->dispex, event->event_obj);
3852
3853 if(event->target)
3854 IEventTarget_Release(&event->target->IEventTarget_iface);
3855 event->target = event_target;
3856 IEventTarget_AddRef(&event_target->IEventTarget_iface);
3857
3858 event->phase = DEP_CAPTURING_PHASE;
3859 i = chain_cnt-1;
3860 while(!event->stop_propagation && i)
3861 call_event_handlers(target_chain[i--], event, dispatch_mode);
3862
3863 if(!event->stop_propagation) {
3864 event->phase = DEP_AT_TARGET;
3865 call_event_handlers(target_chain[0], event, dispatch_mode);
3866 }
3867
3868 if(event->bubbles) {
3869 event->phase = DEP_BUBBLING_PHASE;
3870 for(i = 1; !event->stop_propagation && i < chain_cnt; i++)
3871 call_event_handlers(target_chain[i], event, dispatch_mode);
3872 }
3873
3874 if(r)
3875 *r = variant_bool(!event->prevent_default);
3876
3877 if(target_vtbl->set_current_event) {
3878 IHTMLEventObj *prev = target_vtbl->set_current_event(&event_target->dispex, prev_event);
3879 if(prev)
3880 IHTMLEventObj_Release(prev);
3881 }
3882
3883 if(prev_event)
3884 IHTMLEventObj_Release(prev_event);
3885
3886 if(event_info[event->event_id].flags & EVENT_HASDEFAULTHANDLERS) {
3887 BOOL prevent_default = event->prevent_default;
3888 for(i = 0; !prevent_default && i < chain_cnt; i++) {
3889 vtbl = dispex_get_vtbl(&target_chain[i]->dispex);
3890 if(!vtbl->handle_event)
3891 continue;
3892 hres = vtbl->handle_event(&event_target->dispex, event->event_id, event->nsevent, &prevent_default);
3893 if(FAILED(hres) || event->stop_propagation)
3894 break;
3895 if(prevent_default)
3896 nsIDOMEvent_PreventDefault(event->nsevent);
3897 }
3898 }
3899
3900 event->prevent_default = FALSE;
3901 if(event_obj_ref) {
3902 event->event_obj = NULL;
3903 IHTMLEventObj_Release(&event_obj_ref->IHTMLEventObj_iface);
3904 }
3905
3906 for(i = 0; i < chain_cnt; i++)
3907 IEventTarget_Release(&target_chain[i]->IEventTarget_iface);
3908 if(target_chain != target_chain_buf)
3909 free(target_chain);
3910
3911 return S_OK;
3912 }
3913
3914 void dispatch_event(EventTarget *event_target, DOMEvent *event)
3915 {
3916 dispatch_event_object(event_target, event, DISPATCH_BOTH, NULL);
3917
3918 /*
3919 * We may have registered multiple Gecko listeners for the same event type,
3920 * but we already dispatched event to all relevant targets. Stop event
3921 * propagation here to avoid events being dispatched multiple times.
3922 */
3923 if(event_info[event->event_id].flags & EVENT_BIND_TO_TARGET)
3924 nsIDOMEvent_StopPropagation(event->nsevent);
3925 }
3926
3927 HRESULT fire_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_var, VARIANT_BOOL *cancelled)
3928 {
3929 HTMLEventObj *event_obj = NULL;
3930 eventid_t eid;
3931 HRESULT hres = S_OK;
3932
3933 eid = attr_to_eid(event_name);
3934 if(eid == EVENTID_LAST) {
3935 WARN("unknown event %s\n", debugstr_w(event_name));
3936 return E_INVALIDARG;
3937 }
3938
3939 if(event_var && V_VT(event_var) != VT_EMPTY && V_VT(event_var) != VT_ERROR) {
3940 if(V_VT(event_var) != VT_DISPATCH) {
3941 FIXME("event_var %s not supported\n", debugstr_variant(event_var));
3942 return E_NOTIMPL;
3943 }
3944
3945 if(V_DISPATCH(event_var)) {
3946 IHTMLEventObj *event_iface;
3947
3948 hres = IDispatch_QueryInterface(V_DISPATCH(event_var), &IID_IHTMLEventObj, (void**)&event_iface);
3949 if(FAILED(hres)) {
3950 FIXME("No IHTMLEventObj iface\n");
3951 return hres;
3952 }
3953
3954 event_obj = unsafe_impl_from_IHTMLEventObj(event_iface);
3955 if(!event_obj) {
3956 ERR("Not our IHTMLEventObj?\n");
3957 IHTMLEventObj_Release(event_iface);
3958 return E_FAIL;
3959 }
3960 }
3961 }
3962
3963 if(!event_obj) {
3964 event_obj = alloc_event_obj(NULL, dispex_compat_mode(&node->event_target.dispex));
3965 if(!event_obj)
3966 return E_OUTOFMEMORY;
3967 }
3968
3969 if(!event_obj->event)
3970 hres = create_document_event(node->doc, eid, &event_obj->event);
3971
3972 if(SUCCEEDED(hres)) {
3973 event_obj->event->event_obj = &event_obj->IHTMLEventObj_iface;
3974 dispatch_event_object(&node->event_target, event_obj->event, DISPATCH_LEGACY, NULL);
3975 event_obj->event->event_obj = NULL;
3976 }
3977
3978 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
3979 if(FAILED(hres))
3980 return hres;
3981
3982 *cancelled = VARIANT_TRUE; /* FIXME */
3983 return S_OK;
3984 }
3985
3986 HRESULT ensure_doc_nsevent_handler(HTMLDocumentNode *doc, nsIDOMNode *nsnode, eventid_t eid)
3987 {
3988 TRACE("%s\n", debugstr_w(event_info[eid].name));
3989
3990 if(!doc->dom_document)
3991 return S_OK;
3992
3993 switch(eid) {
3994 case EVENTID_FOCUSIN:
3995 doc->event_vector[eid] = TRUE;
3996 eid = EVENTID_FOCUS;
3997 break;
3998 case EVENTID_FOCUSOUT:
3999 doc->event_vector[eid] = TRUE;
4000 eid = EVENTID_BLUR;
4001 break;
4002 default:
4003 break;
4004 }
4005
4006 if(event_info[eid].flags & EVENT_DEFAULTLISTENER) {
4007 nsnode = NULL;
4008 }else if(!(event_info[eid].flags & EVENT_BIND_TO_TARGET)) {
4009 return S_OK;
4010 }
4011
4012 if(!nsnode || nsnode == doc->node.nsnode) {
4013 if(doc->event_vector[eid])
4014 return S_OK;
4015 doc->event_vector[eid] = TRUE;
4016 }
4017
4018 add_nsevent_listener(doc, nsnode, event_info[eid].name);
4019 return S_OK;
4020 }
4021
4022 void detach_events(HTMLDocumentNode *doc)
4023 {
4024 if(doc->event_vector) {
4025 int i;
4026
4027 for(i=0; i < EVENTID_LAST; i++) {
4028 if(doc->event_vector[i]) {
4029 detach_nsevent(doc, event_info[i].name);
4030 doc->event_vector[i] = FALSE;
4031 }
4032 }
4033 }
4034
4035 release_nsevents(doc);
4036 }
4037
4038 static HRESULT get_event_dispex_ref(EventTarget *event_target, eventid_t eid, BOOL alloc, VARIANT **ret)
4039 {
4040 WCHAR buf[64];
4041 buf[0] = 'o';
4042 buf[1] = 'n';
4043 lstrcpyW(buf+2, event_info[eid].name);
4044 return dispex_get_dprop_ref(&event_target->dispex, buf, alloc, ret);
4045 }
4046
4047 static event_listener_t *get_onevent_listener(EventTarget *event_target, eventid_t eid, BOOL alloc)
4048 {
4049 listener_container_t *container;
4050 event_listener_t *listener;
4051
4052 container = get_listener_container(event_target, event_info[eid].name, alloc);
4053 if(!container)
4054 return NULL;
4055
4056 LIST_FOR_EACH_ENTRY_REV(listener, &container->listeners, event_listener_t, entry) {
4057 if(listener->type == LISTENER_TYPE_ONEVENT)
4058 return listener;
4059 }
4060
4061 if(!alloc)
4062 return NULL;
4063
4064 listener = malloc(sizeof(*listener));
4065 if(!listener)
4066 return NULL;
4067
4068 listener->type = LISTENER_TYPE_ONEVENT;
4069 listener->function = NULL;
4070 list_add_tail(&container->listeners, &listener->entry);
4071 return listener;
4072 }
4073
4074 static void remove_event_handler(EventTarget *event_target, eventid_t eid)
4075 {
4076 event_listener_t *listener;
4077 VARIANT *store;
4078 HRESULT hres;
4079
4080 hres = get_event_dispex_ref(event_target, eid, FALSE, &store);
4081 if(SUCCEEDED(hres))
4082 VariantClear(store);
4083
4084 listener = get_onevent_listener(event_target, eid, FALSE);
4085 if(listener && listener->function) {
4086 IDispatch_Release(listener->function);
4087 listener->function = NULL;
4088 }
4089 }
4090
4091 static HRESULT set_event_handler_disp(EventTarget *event_target, eventid_t eid, IDispatch *disp)
4092 {
4093 event_listener_t *listener;
4094
4095 if(event_info[eid].flags & EVENT_FIXME)
4096 FIXME("unimplemented event %s\n", debugstr_w(event_info[eid].name));
4097
4098 remove_event_handler(event_target, eid);
4099 if(!disp)
4100 return S_OK;
4101
4102 listener = get_onevent_listener(event_target, eid, TRUE);
4103 if(!listener)
4104 return E_OUTOFMEMORY;
4105
4106 if(listener->function)
4107 IDispatch_Release(listener->function);
4108
4109 IDispatch_AddRef(listener->function = disp);
4110 return S_OK;
4111 }
4112
4113 HRESULT set_event_handler(EventTarget *event_target, eventid_t eid, VARIANT *var)
4114 {
4115 switch(V_VT(var)) {
4116 case VT_EMPTY:
4117 if(use_event_quirks(event_target)) {
4118 WARN("attempt to set to VT_EMPTY in quirks mode\n");
4119 return E_NOTIMPL;
4120 }
4121 /* fall through */
4122 case VT_NULL:
4123 remove_event_handler(event_target, eid);
4124 return S_OK;
4125
4126 case VT_DISPATCH:
4127 return set_event_handler_disp(event_target, eid, V_DISPATCH(var));
4128
4129 case VT_BSTR: {
4130 VARIANT *v;
4131 HRESULT hres;
4132
4133 if(!use_event_quirks(event_target))
4134 FIXME("Setting to string %s not supported\n", debugstr_w(V_BSTR(var)));
4135
4136 /*
4137 * Setting event handler to string is a rare case and we don't want to
4138 * complicate nor increase memory of listener_container_t for that. Instead,
4139 * we store the value in DispatchEx, which can already handle custom
4140 * properties.
4141 */
4142 remove_event_handler(event_target, eid);
4143
4144 hres = get_event_dispex_ref(event_target, eid, TRUE, &v);
4145 if(FAILED(hres))
4146 return hres;
4147
4148 V_BSTR(v) = SysAllocString(V_BSTR(var));
4149 if(!V_BSTR(v))
4150 return E_OUTOFMEMORY;
4151 V_VT(v) = VT_BSTR;
4152 return S_OK;
4153 }
4154
4155 default:
4156 FIXME("not handler %s\n", debugstr_variant(var));
4157 return E_NOTIMPL;
4158 }
4159
4160 return S_OK;
4161 }
4162
4163 HRESULT get_event_handler(EventTarget *event_target, eventid_t eid, VARIANT *var)
4164 {
4165 event_listener_t *listener;
4166 VARIANT *v;
4167 HRESULT hres;
4168
4169 hres = get_event_dispex_ref(event_target, eid, FALSE, &v);
4170 if(SUCCEEDED(hres) && V_VT(v) != VT_EMPTY) {
4171 V_VT(var) = VT_EMPTY;
4172 return VariantCopy(var, v);
4173 }
4174
4175 listener = get_onevent_listener(event_target, eid, FALSE);
4176 if(listener && listener->function) {
4177 V_VT(var) = VT_DISPATCH;
4178 V_DISPATCH(var) = listener->function;
4179 IDispatch_AddRef(V_DISPATCH(var));
4180 }else {
4181 V_VT(var) = VT_NULL;
4182 }
4183
4184 return S_OK;
4185 }
4186
4187 HRESULT attach_event(EventTarget *event_target, BSTR name, IDispatch *disp, VARIANT_BOOL *res)
4188 {
4189 listener_container_t *container;
4190 event_listener_t *listener;
4191 eventid_t eid;
4192
4193 if(!disp) {
4194 *res = VARIANT_FALSE;
4195 return S_OK;
4196 }
4197
4198 eid = attr_to_eid(name);
4199 if(eid == EVENTID_LAST) {
4200 WARN("Unknown event\n");
4201 *res = VARIANT_TRUE;
4202 return S_OK;
4203 }
4204
4205 container = get_listener_container(event_target, event_info[eid].name, TRUE);
4206 if(!container)
4207 return E_OUTOFMEMORY;
4208
4209 listener = malloc(sizeof(*listener));
4210 if(!listener)
4211 return E_OUTOFMEMORY;
4212
4213 listener->type = LISTENER_TYPE_ATTACHED;
4214 IDispatch_AddRef(listener->function = disp);
4215 if(use_event_quirks(event_target))
4216 list_add_head(&container->listeners, &listener->entry);
4217 else
4218 list_add_tail(&container->listeners, &listener->entry);
4219
4220 *res = VARIANT_TRUE;
4221 return S_OK;
4222 }
4223
4224 HRESULT detach_event(EventTarget *event_target, BSTR name, IDispatch *disp)
4225 {
4226 eventid_t eid;
4227
4228 eid = attr_to_eid(name);
4229 if(eid == EVENTID_LAST) {
4230 WARN("Unknown event\n");
4231 return S_OK;
4232 }
4233
4234 remove_event_listener(event_target, event_info[eid].name, LISTENER_TYPE_ATTACHED, disp);
4235 return S_OK;
4236 }
4237
4238 void bind_target_event(HTMLDocumentNode *doc, EventTarget *event_target, const WCHAR *event, IDispatch *disp)
4239 {
4240 eventid_t eid;
4241
4242 TRACE("(%p %p %s %p)\n", doc, event_target, debugstr_w(event), disp);
4243
4244 eid = attr_to_eid(event);
4245 if(eid == EVENTID_LAST) {
4246 WARN("Unsupported event %s\n", debugstr_w(event));
4247 return;
4248 }
4249
4250 set_event_handler_disp(event_target, eid, disp);
4251 }
4252
4253 void update_doc_cp_events(HTMLDocumentNode *doc, cp_static_data_t *cp)
4254 {
4255 int i;
4256
4257 for(i=0; i < EVENTID_LAST; i++) {
4258 if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
4259 ensure_doc_nsevent_handler(doc, NULL, i);
4260 }
4261 }
4262
4263 void check_event_attr(HTMLDocumentNode *doc, nsIDOMElement *nselem)
4264 {
4265 nsIDOMMozNamedAttrMap *attr_map;
4266 const PRUnichar *name, *value;
4267 nsAString name_str, value_str;
4268 HTMLDOMNode *node = NULL;
4269 cpp_bool has_attrs;
4270 nsIDOMAttr *attr;
4271 IDispatch *disp;
4272 UINT32 length, i;
4273 eventid_t eid;
4274 nsresult nsres;
4275 HRESULT hres;
4276
4277 nsres = nsIDOMElement_HasAttributes(nselem, &has_attrs);
4278 if(NS_FAILED(nsres) || !has_attrs)
4279 return;
4280
4281 nsres = nsIDOMElement_GetAttributes(nselem, &attr_map);
4282 if(NS_FAILED(nsres))
4283 return;
4284
4285 nsres = nsIDOMMozNamedAttrMap_GetLength(attr_map, &length);
4286 assert(nsres == NS_OK);
4287
4288 nsAString_Init(&name_str, NULL);
4289 nsAString_Init(&value_str, NULL);
4290
4291 for(i = 0; i < length; i++) {
4292 nsres = nsIDOMMozNamedAttrMap_Item(attr_map, i, &attr);
4293 if(NS_FAILED(nsres))
4294 continue;
4295
4296 nsres = nsIDOMAttr_GetName(attr, &name_str);
4297 if(NS_FAILED(nsres)) {
4298 nsIDOMAttr_Release(attr);
4299 continue;
4300 }
4301
4302 nsAString_GetData(&name_str, &name);
4303 eid = attr_to_eid(name);
4304 if(eid == EVENTID_LAST) {
4305 nsIDOMAttr_Release(attr);
4306 continue;
4307 }
4308
4309 nsres = nsIDOMAttr_GetValue(attr, &value_str);
4310 nsIDOMAttr_Release(attr);
4311 if(NS_FAILED(nsres))
4312 continue;
4313
4314 nsAString_GetData(&value_str, &value);
4315 if(!*value)
4316 continue;
4317
4318 TRACE("%p.%s = %s\n", nselem, debugstr_w(name), debugstr_w(value));
4319
4320 disp = script_parse_event(doc->window, value);
4321 if(!disp)
4322 continue;
4323
4324 if(!node) {
4325 hres = get_node((nsIDOMNode*)nselem, TRUE, &node);
4326 if(FAILED(hres)) {
4327 IDispatch_Release(disp);
4328 break;
4329 }
4330 }
4331
4332 set_event_handler_disp(get_node_event_prop_target(node, eid), eid, disp);
4333 IDispatch_Release(disp);
4334 }
4335
4336 if(node)
4337 node_release(node);
4338 nsAString_Finish(&name_str);
4339 nsAString_Finish(&value_str);
4340 nsIDOMMozNamedAttrMap_Release(attr_map);
4341 }
4342
4343 HRESULT doc_init_events(HTMLDocumentNode *doc)
4344 {
4345 unsigned i;
4346 HRESULT hres;
4347
4348 doc->event_vector = calloc(EVENTID_LAST, sizeof(BOOL));
4349 if(!doc->event_vector)
4350 return E_OUTOFMEMORY;
4351
4352 init_nsevents(doc);
4353
4354 for(i=0; i < EVENTID_LAST; i++) {
4355 if(event_info[i].flags & EVENT_HASDEFAULTHANDLERS) {
4356 hres = ensure_doc_nsevent_handler(doc, NULL, i);
4357 if(FAILED(hres))
4358 return hres;
4359 }
4360 }
4361
4362 return S_OK;
4363 }
4364
4365 static inline EventTarget *impl_from_IEventTarget(IEventTarget *iface)
4366 {
4367 return CONTAINING_RECORD(iface, EventTarget, IEventTarget_iface);
4368 }
4369
4370 static HRESULT WINAPI EventTarget_QueryInterface(IEventTarget *iface, REFIID riid, void **ppv)
4371 {
4372 EventTarget *This = impl_from_IEventTarget(iface);
4373 return IDispatchEx_QueryInterface(&This->dispex.IDispatchEx_iface, riid, ppv);
4374 }
4375
4376 static ULONG WINAPI EventTarget_AddRef(IEventTarget *iface)
4377 {
4378 EventTarget *This = impl_from_IEventTarget(iface);
4379 return IDispatchEx_AddRef(&This->dispex.IDispatchEx_iface);
4380 }
4381
4382 static ULONG WINAPI EventTarget_Release(IEventTarget *iface)
4383 {
4384 EventTarget *This = impl_from_IEventTarget(iface);
4385 return IDispatchEx_Release(&This->dispex.IDispatchEx_iface);
4386 }
4387
4388 static HRESULT WINAPI EventTarget_GetTypeInfoCount(IEventTarget *iface, UINT *pctinfo)
4389 {
4390 EventTarget *This = impl_from_IEventTarget(iface);
4391 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
4392 }
4393
4394 static HRESULT WINAPI EventTarget_GetTypeInfo(IEventTarget *iface, UINT iTInfo,
4395 LCID lcid, ITypeInfo **ppTInfo)
4396 {
4397 EventTarget *This = impl_from_IEventTarget(iface);
4398 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4399 }
4400
4401 static HRESULT WINAPI EventTarget_GetIDsOfNames(IEventTarget *iface, REFIID riid, LPOLESTR *rgszNames,
4402 UINT cNames, LCID lcid, DISPID *rgDispId)
4403 {
4404 EventTarget *This = impl_from_IEventTarget(iface);
4405 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid,
4406 rgszNames, cNames, lcid, rgDispId);
4407 }
4408
4409 static HRESULT WINAPI EventTarget_Invoke(IEventTarget *iface, DISPID dispIdMember,
4410 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
4411 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4412 {
4413 EventTarget *This = impl_from_IEventTarget(iface);
4414 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember,
4415 riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4416 }
4417
4418 static HRESULT WINAPI EventTarget_addEventListener(IEventTarget *iface, BSTR type,
4419 IDispatch *function, VARIANT_BOOL capture)
4420 {
4421 EventTarget *This = impl_from_IEventTarget(iface);
4422 listener_type_t listener_type = capture ? LISTENER_TYPE_CAPTURE : LISTENER_TYPE_BUBBLE;
4423 listener_container_t *container;
4424 event_listener_t *listener;
4425
4426 TRACE("(%p)->(%s %p %x)\n", This, debugstr_w(type), function, capture);
4427
4428 if(!function)
4429 return S_OK;
4430
4431 container = get_listener_container(This, type, TRUE);
4432 if(!container)
4433 return E_OUTOFMEMORY;
4434
4435 /* check for duplicates */
4436 LIST_FOR_EACH_ENTRY(listener, &container->listeners, event_listener_t, entry) {
4437 if(listener->type == listener_type && listener->function == function)
4438 return S_OK;
4439 }
4440
4441 listener = malloc(sizeof(*listener));
4442 if(!listener)
4443 return E_OUTOFMEMORY;
4444
4445 listener->type = listener_type;
4446 IDispatch_AddRef(listener->function = function);
4447 list_add_tail(&container->listeners, &listener->entry);
4448 return S_OK;
4449 }
4450
4451 static HRESULT WINAPI EventTarget_removeEventListener(IEventTarget *iface, BSTR type,
4452 IDispatch *listener, VARIANT_BOOL capture)
4453 {
4454 EventTarget *This = impl_from_IEventTarget(iface);
4455
4456 TRACE("(%p)->(%s %p %x)\n", This, debugstr_w(type), listener, capture);
4457
4458 remove_event_listener(This, type, capture ? LISTENER_TYPE_CAPTURE : LISTENER_TYPE_BUBBLE, listener);
4459 return S_OK;
4460 }
4461
4462 static HRESULT WINAPI EventTarget_dispatchEvent(IEventTarget *iface, IDOMEvent *event_iface, VARIANT_BOOL *result)
4463 {
4464 EventTarget *This = impl_from_IEventTarget(iface);
4465 DOMEvent *event = unsafe_impl_from_IDOMEvent(event_iface);
4466
4467 TRACE("(%p)->(%p %p)\n", This, event, result);
4468
4469 if(!event) {
4470 WARN("Invalid event\n");
4471 return E_INVALIDARG;
4472 }
4473
4474 return dispatch_event_object(This, event, DISPATCH_STANDARD, result);
4475 }
4476
4477 static HRESULT IEventTarget_addEventListener_hook(DispatchEx *dispex, WORD flags,
4478 DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
4479 {
4480 /* If only two arguments were given, implicitly set capture to false */
4481 if((flags & DISPATCH_METHOD) && dp->cArgs == 2 && !dp->cNamedArgs) {
4482 VARIANT args[3];
4483 DISPPARAMS new_dp = {args, NULL, 3, 0};
4484 V_VT(args) = VT_BOOL;
4485 V_BOOL(args) = VARIANT_FALSE;
4486 args[1] = dp->rgvarg[0];
4487 args[2] = dp->rgvarg[1];
4488
4489 TRACE("implicit capture\n");
4490
4491 return dispex_call_builtin(dispex, DISPID_IEVENTTARGET_ADDEVENTLISTENER, &new_dp, res, ei, caller);
4492 }
4493
4494 return S_FALSE; /* fallback to default */
4495 }
4496
4497 static HRESULT IEventTarget_removeEventListener_hook(DispatchEx *dispex, WORD flags,
4498 DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
4499 {
4500 /* If only two arguments were given, implicitly set capture to false */
4501 if((flags & DISPATCH_METHOD) && dp->cArgs == 2 && !dp->cNamedArgs) {
4502 VARIANT args[3];
4503 DISPPARAMS new_dp = {args, NULL, 3, 0};
4504 V_VT(args) = VT_BOOL;
4505 V_BOOL(args) = VARIANT_FALSE;
4506 args[1] = dp->rgvarg[0];
4507 args[2] = dp->rgvarg[1];
4508
4509 TRACE("implicit capture\n");
4510
4511 return dispex_call_builtin(dispex, DISPID_IEVENTTARGET_REMOVEEVENTLISTENER, &new_dp, res, ei, caller);
4512 }
4513
4514 return S_FALSE; /* fallback to default */
4515 }
4516
4517 static const IEventTargetVtbl EventTargetVtbl = {
4518 EventTarget_QueryInterface,
4519 EventTarget_AddRef,
4520 EventTarget_Release,
4521 EventTarget_GetTypeInfoCount,
4522 EventTarget_GetTypeInfo,
4523 EventTarget_GetIDsOfNames,
4524 EventTarget_Invoke,
4525 EventTarget_addEventListener,
4526 EventTarget_removeEventListener,
4527 EventTarget_dispatchEvent
4528 };
4529
4530 static EventTarget *unsafe_impl_from_IEventTarget(IEventTarget *iface)
4531 {
4532 return iface && iface->lpVtbl == &EventTargetVtbl ? impl_from_IEventTarget(iface) : NULL;
4533 }
4534
4535 static HRESULT get_gecko_target(IEventTarget *target, nsIDOMEventTarget **ret)
4536 {
4537 EventTarget *event_target = unsafe_impl_from_IEventTarget(target);
4538 const event_target_vtbl_t *vtbl;
4539 nsresult nsres;
4540
4541 if(!event_target) {
4542 WARN("Not our IEventTarget implementation\n");
4543 return E_INVALIDARG;
4544 }
4545
4546 vtbl = (const event_target_vtbl_t*)dispex_get_vtbl(&event_target->dispex);
4547 nsres = nsISupports_QueryInterface(vtbl->get_gecko_target(&event_target->dispex),
4548 &IID_nsIDOMEventTarget, (void**)ret);
4549 assert(nsres == NS_OK);
4550 return S_OK;
4551 }
4552
4553 void *EventTarget_query_interface(EventTarget *event_target, REFIID riid)
4554 {
4555 if(IsEqualGUID(riid, &IID_IEventTarget)) {
4556 if(use_event_quirks(event_target)) {
4557 WARN("IEventTarget queried, but not supported by in document mode\n");
4558 return NULL;
4559 }
4560 return &event_target->IEventTarget_iface;
4561 }
4562
4563 return NULL;
4564 }
4565
4566 void EventTarget_init_dispex_info(dispex_data_t *dispex_info, compat_mode_t compat_mode)
4567 {
4568 static const dispex_hook_t IEventTarget_hooks[] = {
4569 {DISPID_IEVENTTARGET_ADDEVENTLISTENER, IEventTarget_addEventListener_hook},
4570 {DISPID_IEVENTTARGET_REMOVEEVENTLISTENER, IEventTarget_removeEventListener_hook},
4571 {DISPID_UNKNOWN}
4572 };
4573
4574 if(compat_mode >= COMPAT_MODE_IE9)
4575 dispex_info_add_interface(dispex_info, IEventTarget_tid, IEventTarget_hooks);
4576 }
4577
4578 static int event_id_cmp(const void *key, const struct wine_rb_entry *entry)
4579 {
4580 return wcscmp(key, WINE_RB_ENTRY_VALUE(entry, listener_container_t, entry)->type);
4581 }
4582
4583 void EventTarget_Init(EventTarget *event_target, dispex_static_data_t *dispex_data, compat_mode_t compat_mode)
4584 {
4585 init_dispatch(&event_target->dispex, dispex_data, compat_mode);
4586 event_target->IEventTarget_iface.lpVtbl = &EventTargetVtbl;
4587 wine_rb_init(&event_target->handler_map, event_id_cmp);
4588 }
4589
4590 void release_event_target(EventTarget *event_target)
4591 {
4592 listener_container_t *iter, *iter2;
4593
4594 WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR(iter, iter2, &event_target->handler_map, listener_container_t, entry) {
4595 while(!list_empty(&iter->listeners)) {
4596 event_listener_t *listener = LIST_ENTRY(list_head(&iter->listeners), event_listener_t, entry);
4597 list_remove(&listener->entry);
4598 if(listener->function)
4599 IDispatch_Release(listener->function);
4600 free(listener);
4601 }
4602 free(iter);
4603 }
4604 rb_destroy(&event_target->handler_map, NULL, NULL);
4605 }
Windows API implementation