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