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