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