?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Added IDOMEvent::get_target implementation.
[wine.git] / dlls / mshtml / htmlevent.c
blobc06d062dce87ff9cb0b0fc0c950ac89c1f88c15c
1 /*
2 * Copyright 2008-2009 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20 #include <assert.h>
21
22 #define COBJMACROS
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winuser.h"
27 #include "ole2.h"
28 #include "mshtmdid.h"
29
30 #include "mshtml_private.h"
31 #include "htmlevent.h"
32 #include "htmlscript.h"
33
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
37
38 typedef enum {
39 LISTENER_TYPE_CAPTURE,
40 LISTENER_TYPE_BUBBLE,
41 LISTENER_TYPE_ONEVENT,
42 LISTENER_TYPE_ATTACHED
43 } listener_type_t;
44
45 typedef struct {
46 struct list entry;
47 listener_type_t type;
48 IDispatch *function;
49 } event_listener_t;
50
51 typedef struct {
52 struct wine_rb_entry entry;
53 struct list listeners;
54 WCHAR type[1];
55 } listener_container_t;
56
57 static const WCHAR abortW[] = {'a','b','o','r','t',0};
58 static const WCHAR beforeactivateW[] = {'b','e','f','o','r','e','a','c','t','i','v','a','t','e',0};
59 static const WCHAR beforeunloadW[] = {'b','e','f','o','r','e','u','n','l','o','a','d',0};
60 static const WCHAR blurW[] = {'b','l','u','r',0};
61 static const WCHAR changeW[] = {'c','h','a','n','g','e',0};
62 static const WCHAR clickW[] = {'c','l','i','c','k',0};
63 static const WCHAR contextmenuW[] = {'c','o','n','t','e','x','t','m','e','n','u',0};
64 static const WCHAR dataavailableW[] = {'d','a','t','a','a','v','a','i','l','a','b','l','e',0};
65 static const WCHAR dblclickW[] = {'d','b','l','c','l','i','c','k',0};
66 static const WCHAR dragW[] = {'d','r','a','g',0};
67 static const WCHAR dragstartW[] = {'d','r','a','g','s','t','a','r','t',0};
68 static const WCHAR errorW[] = {'e','r','r','o','r',0};
69 static const WCHAR focusW[] = {'f','o','c','u','s',0};
70 static const WCHAR focusinW[] = {'f','o','c','u','s','i','n',0};
71 static const WCHAR focusoutW[] = {'f','o','c','u','s','o','u','t',0};
72 static const WCHAR helpW[] = {'h','e','l','p',0};
73 static const WCHAR keydownW[] = {'k','e','y','d','o','w','n',0};
74 static const WCHAR keypressW[] = {'k','e','y','p','r','e','s','s',0};
75 static const WCHAR keyupW[] = {'k','e','y','u','p',0};
76 static const WCHAR loadW[] = {'l','o','a','d',0};
77 static const WCHAR messageW[] = {'m','e','s','s','a','g','e',0};
78 static const WCHAR mousedownW[] = {'m','o','u','s','e','d','o','w','n',0};
79 static const WCHAR mousemoveW[] = {'m','o','u','s','e','m','o','v','e',0};
80 static const WCHAR mouseoutW[] = {'m','o','u','s','e','o','u','t',0};
81 static const WCHAR mouseoverW[] = {'m','o','u','s','e','o','v','e','r',0};
82 static const WCHAR mouseupW[] = {'m','o','u','s','e','u','p',0};
83 static const WCHAR mousewheelW[] = {'m','o','u','s','e','w','h','e','e','l',0};
84 static const WCHAR pasteW[] = {'p','a','s','t','e',0};
85 static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
86 static const WCHAR resizeW[] = {'r','e','s','i','z','e',0};
87 static const WCHAR scrollW[] = {'s','c','r','o','l','l',0};
88 static const WCHAR selectstartW[] = {'s','e','l','e','c','t','s','t','a','r','t',0};
89 static const WCHAR selectionchangeW[] = {'s','e','l','e','c','t','i','o','n','c','h','a','n','g','e',0};
90 static const WCHAR submitW[] = {'s','u','b','m','i','t',0};
91 static const WCHAR unloadW[] = {'u','n','l','o','a','d',0};
92 static const WCHAR DOMContentLoadedW[] = {'D','O','M','C','o','n','t','e','n','t','L','o','a','d','e','d',0};
93
94 static const WCHAR EventW[] = {'E','v','e','n','t',0};
95 static const WCHAR UIEventW[] = {'U','I','E','v','e','n','t',0};
96 static const WCHAR KeyboardEventW[] = {'K','e','y','b','o','a','r','d','E','v','e','n','t',0};
97 static const WCHAR MouseEventW[] = {'M','o','u','s','e','E','v','e','n','t',0};
98
99 typedef enum {
100 EVENT_TYPE_EVENT,
101 EVENT_TYPE_UIEVENT,
102 EVENT_TYPE_KEYBOARD,
103 EVENT_TYPE_MOUSE,
104 EVENT_TYPE_FOCUS,
105 EVENT_TYPE_DRAG,
106 EVENT_TYPE_MESSAGE,
107 EVENT_TYPE_CLIPBOARD
108 } event_type_t;
109
110 static const WCHAR *event_types[] = {
111 EventW,
112 UIEventW,
113 KeyboardEventW,
114 MouseEventW,
115 EventW, /* FIXME */
116 EventW, /* FIXME */
117 EventW, /* FIXME */
118 EventW /* FIXME */
119 };
120
121 typedef struct {
122 const WCHAR *name;
123 event_type_t type;
124 DISPID dispid;
125 DWORD flags;
126 } event_info_t;
127
128 #define EVENT_DEFAULTLISTENER 0x0001
129 #define EVENT_BUBBLES 0x0002
130 #define EVENT_BIND_TO_BODY 0x0008
131 #define EVENT_CANCELABLE 0x0010
132 #define EVENT_HASDEFAULTHANDLERS 0x0020
133 #define EVENT_FIXME 0x0040
134
135 static const event_info_t event_info[] = {
136 {abortW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONABORT,
137 EVENT_BIND_TO_BODY},
138 {beforeactivateW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONBEFOREACTIVATE,
139 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
140 {beforeunloadW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONBEFOREUNLOAD,
141 EVENT_DEFAULTLISTENER | EVENT_CANCELABLE },
142 {blurW, EVENT_TYPE_FOCUS, DISPID_EVMETH_ONBLUR,
143 EVENT_DEFAULTLISTENER},
144 {changeW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONCHANGE,
145 EVENT_DEFAULTLISTENER | EVENT_BUBBLES},
146 {clickW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONCLICK,
147 EVENT_DEFAULTLISTENER | EVENT_HASDEFAULTHANDLERS | EVENT_BUBBLES | EVENT_CANCELABLE },
148 {contextmenuW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONCONTEXTMENU,
149 EVENT_BUBBLES | EVENT_CANCELABLE},
150 {dataavailableW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONDATAAVAILABLE,
151 EVENT_FIXME | EVENT_BUBBLES},
152 {dblclickW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONDBLCLICK,
153 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
154 {DOMContentLoadedW, EVENT_TYPE_EVENT, 0,
155 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
156 {dragW, EVENT_TYPE_DRAG, DISPID_EVMETH_ONDRAG,
157 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
158 {dragstartW, EVENT_TYPE_DRAG, DISPID_EVMETH_ONDRAGSTART,
159 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
160 {errorW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONERROR,
161 EVENT_BIND_TO_BODY},
162 {focusW, EVENT_TYPE_FOCUS, DISPID_EVMETH_ONFOCUS,
163 EVENT_DEFAULTLISTENER},
164 {focusinW, EVENT_TYPE_FOCUS, DISPID_EVMETH_ONFOCUSIN,
165 EVENT_BUBBLES},
166 {focusoutW, EVENT_TYPE_FOCUS, DISPID_EVMETH_ONFOCUSOUT,
167 EVENT_BUBBLES},
168 {helpW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONHELP,
169 EVENT_BUBBLES | EVENT_CANCELABLE},
170 {keydownW, EVENT_TYPE_KEYBOARD, DISPID_EVMETH_ONKEYDOWN,
171 EVENT_DEFAULTLISTENER | EVENT_HASDEFAULTHANDLERS | EVENT_BUBBLES | EVENT_CANCELABLE },
172 {keypressW, EVENT_TYPE_KEYBOARD, DISPID_EVMETH_ONKEYPRESS,
173 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
174 {keyupW, EVENT_TYPE_KEYBOARD, DISPID_EVMETH_ONKEYUP,
175 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
176 {loadW, EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONLOAD,
177 EVENT_BIND_TO_BODY},
178 {messageW, EVENT_TYPE_MESSAGE, DISPID_EVMETH_ONMESSAGE,
179 0},
180 {mousedownW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEDOWN,
181 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
182 {mousemoveW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEMOVE,
183 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
184 {mouseoutW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEOUT,
185 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
186 {mouseoverW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEOVER,
187 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
188 {mouseupW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEUP,
189 EVENT_DEFAULTLISTENER | EVENT_BUBBLES | EVENT_CANCELABLE},
190 {mousewheelW, EVENT_TYPE_MOUSE, DISPID_EVMETH_ONMOUSEWHEEL,
191 EVENT_FIXME},
192 {pasteW, EVENT_TYPE_CLIPBOARD, DISPID_EVMETH_ONPASTE,
193 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
194 {readystatechangeW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONREADYSTATECHANGE,
195 0},
196 {resizeW, EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONRESIZE,
197 EVENT_DEFAULTLISTENER},
198 {scrollW, EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONSCROLL,
199 EVENT_DEFAULTLISTENER | EVENT_BUBBLES /* FIXME: not for elements */},
200 {selectionchangeW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONSELECTIONCHANGE,
201 EVENT_FIXME},
202 {selectstartW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONSELECTSTART,
203 EVENT_FIXME | EVENT_BUBBLES | EVENT_CANCELABLE},
204 {submitW, EVENT_TYPE_EVENT, DISPID_EVMETH_ONSUBMIT,
205 EVENT_DEFAULTLISTENER | EVENT_HASDEFAULTHANDLERS | EVENT_BUBBLES | EVENT_CANCELABLE},
206 {unloadW, EVENT_TYPE_UIEVENT, DISPID_EVMETH_ONUNLOAD,
207 EVENT_FIXME}
208 };
209
210 static BOOL use_event_quirks(EventTarget*);
211
212 static eventid_t str_to_eid(const WCHAR *str)
213 {
214 int i;
215
216 for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
217 if(!strcmpW(event_info[i].name, str))
218 return i;
219 }
220
221 ERR("unknown type %s\n", debugstr_w(str));
222 return EVENTID_LAST;
223 }
224
225 static eventid_t attr_to_eid(const WCHAR *str)
226 {
227 int i;
228
229 if((str[0] != 'o' && str[0] != 'O') || (str[1] != 'n' && str[1] != 'N'))
230 return EVENTID_LAST;
231
232 for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
233 if(!strcmpW(event_info[i].name, str+2) && event_info[i].dispid)
234 return i;
235 }
236
237 return EVENTID_LAST;
238 }
239
240 static listener_container_t *get_listener_container(EventTarget *event_target, const WCHAR *type, BOOL alloc)
241 {
242 const event_target_vtbl_t *vtbl;
243 listener_container_t *container;
244 struct wine_rb_entry *entry;
245 size_t type_len;
246 eventid_t eid;
247
248 entry = wine_rb_get(&event_target->handler_map, type);
249 if(entry)
250 return WINE_RB_ENTRY_VALUE(entry, listener_container_t, entry);
251 if(!alloc)
252 return NULL;
253
254 eid = str_to_eid(type);
255 if(eid != EVENTID_LAST && (event_info[eid].flags & EVENT_FIXME))
256 FIXME("unimplemented event %s\n", debugstr_w(event_info[eid].name));
257
258 type_len = strlenW(type);
259 container = heap_alloc(FIELD_OFFSET(listener_container_t, type[type_len+1]));
260 if(!container)
261 return NULL;
262 memcpy(container->type, type, (type_len + 1) * sizeof(WCHAR));
263 list_init(&container->listeners);
264 vtbl = dispex_get_vtbl(&event_target->dispex);
265 if(vtbl->bind_event)
266 vtbl->bind_event(&event_target->dispex, eid);
267 else
268 FIXME("Unsupported event binding on target %p\n", event_target);
269
270 wine_rb_put(&event_target->handler_map, container->type, &container->entry);
271 return container;
272 }
273
274 static void remove_event_listener(EventTarget *event_target, const WCHAR *type_name, listener_type_t type, IDispatch *function)
275 {
276 listener_container_t *container;
277 event_listener_t *listener;
278
279 container = get_listener_container(event_target, type_name, FALSE);
280 if(!container)
281 return;
282
283 LIST_FOR_EACH_ENTRY(listener, &container->listeners, event_listener_t, entry) {
284 if(listener->function == function && listener->type == type) {
285 IDispatch_Release(listener->function);
286 list_remove(&listener->entry);
287 heap_free(listener);
288 break;
289 }
290 }
291 }
292
293 typedef struct {
294 DispatchEx dispex;
295 IHTMLEventObj IHTMLEventObj_iface;
296
297 LONG ref;
298
299 DOMEvent *event;
300 VARIANT return_value;
301 } HTMLEventObj;
302
303 static inline HTMLEventObj *impl_from_IHTMLEventObj(IHTMLEventObj *iface)
304 {
305 return CONTAINING_RECORD(iface, HTMLEventObj, IHTMLEventObj_iface);
306 }
307
308 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
309 {
310 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
311
312 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
313
314 if(IsEqualGUID(&IID_IUnknown, riid)) {
315 *ppv = &This->IHTMLEventObj_iface;
316 }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) {
317 *ppv = &This->IHTMLEventObj_iface;
318 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
319 return *ppv ? S_OK : E_NOINTERFACE;
320 }else {
321 *ppv = NULL;
322 WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
323 return E_NOINTERFACE;
324 }
325
326 IUnknown_AddRef((IUnknown*)*ppv);
327 return S_OK;
328 }
329
330 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
331 {
332 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
333 LONG ref = InterlockedIncrement(&This->ref);
334
335 TRACE("(%p) ref=%d\n", This, ref);
336
337 return ref;
338 }
339
340 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
341 {
342 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
343 LONG ref = InterlockedDecrement(&This->ref);
344
345 TRACE("(%p) ref=%d\n", This, ref);
346
347 if(!ref) {
348 if(This->event)
349 IDOMEvent_Release(&This->event->IDOMEvent_iface);
350 release_dispex(&This->dispex);
351 heap_free(This);
352 }
353
354 return ref;
355 }
356
357 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
358 {
359 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
360 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
361 }
362
363 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
364 LCID lcid, ITypeInfo **ppTInfo)
365 {
366 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
367 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
368 }
369
370 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
371 LPOLESTR *rgszNames, UINT cNames,
372 LCID lcid, DISPID *rgDispId)
373 {
374 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
375 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
376 lcid, rgDispId);
377 }
378
379 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
380 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
381 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
382 {
383 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
384 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
385 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
386 }
387
388 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
389 {
390 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
391
392 TRACE("(%p)->(%p)\n", This, p);
393
394 *p = NULL;
395 if(This->event && This->event->target)
396 IDispatchEx_QueryInterface(&This->event->target->dispex.IDispatchEx_iface, &IID_IHTMLElement, (void**)p);
397 return S_OK;
398 }
399
400 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
401 {
402 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
403 cpp_bool ret = FALSE;
404
405 TRACE("(%p)->(%p)\n", This, p);
406
407 if(This->event) {
408 nsIDOMKeyEvent *key_event;
409 nsresult nsres;
410
411 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
412 if(NS_SUCCEEDED(nsres)) {
413 nsIDOMKeyEvent_GetAltKey(key_event, &ret);
414 nsIDOMKeyEvent_Release(key_event);
415 }else {
416 nsIDOMMouseEvent *mouse_event;
417
418 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
419 if(NS_SUCCEEDED(nsres)) {
420 nsIDOMMouseEvent_GetAltKey(mouse_event, &ret);
421 nsIDOMMouseEvent_Release(mouse_event);
422 }
423 }
424 }
425
426 *p = variant_bool(ret);
427 return S_OK;
428 }
429
430 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
431 {
432 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
433 cpp_bool ret = FALSE;
434
435 TRACE("(%p)->(%p)\n", This, p);
436
437 if(This->event) {
438 nsIDOMKeyEvent *key_event;
439 nsresult nsres;
440
441 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
442 if(NS_SUCCEEDED(nsres)) {
443 nsIDOMKeyEvent_GetCtrlKey(key_event, &ret);
444 nsIDOMKeyEvent_Release(key_event);
445 }else {
446 nsIDOMMouseEvent *mouse_event;
447
448 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
449 if(NS_SUCCEEDED(nsres)) {
450 nsIDOMMouseEvent_GetCtrlKey(mouse_event, &ret);
451 nsIDOMMouseEvent_Release(mouse_event);
452 }
453 }
454 }
455
456 *p = variant_bool(ret);
457 return S_OK;
458 }
459
460 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
461 {
462 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
463 cpp_bool ret = FALSE;
464
465 TRACE("(%p)->(%p)\n", This, p);
466
467 if(This->event) {
468 nsIDOMKeyEvent *key_event;
469 nsresult nsres;
470
471 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
472 if(NS_SUCCEEDED(nsres)) {
473 nsIDOMKeyEvent_GetShiftKey(key_event, &ret);
474 nsIDOMKeyEvent_Release(key_event);
475 }else {
476 nsIDOMMouseEvent *mouse_event;
477
478 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
479 if(NS_SUCCEEDED(nsres)) {
480 nsIDOMMouseEvent_GetShiftKey(mouse_event, &ret);
481 nsIDOMMouseEvent_Release(mouse_event);
482 }
483 }
484 }
485
486 *p = variant_bool(ret);
487 return S_OK;
488 }
489
490 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
491 {
492 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
493
494 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
495
496 if(V_VT(&v) != VT_BOOL) {
497 FIXME("unsupported value %s\n", debugstr_variant(&v));
498 return DISP_E_BADVARTYPE;
499 }
500
501 This->return_value = v;
502 if(!V_BOOL(&v) && This->event)
503 IDOMEvent_preventDefault(&This->event->IDOMEvent_iface);
504 return S_OK;
505 }
506
507 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
508 {
509 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
510
511 TRACE("(%p)->(%p)\n", This, p);
512
513 V_VT(p) = VT_EMPTY;
514 return VariantCopy(p, &This->return_value);
515 }
516
517 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
518 {
519 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
520
521 TRACE("(%p)->(%x)\n", This, v);
522
523 if(This->event)
524 IDOMEvent_stopPropagation(&This->event->IDOMEvent_iface);
525 return S_OK;
526 }
527
528 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
529 {
530 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
531
532 TRACE("(%p)->(%p)\n", This, p);
533
534 *p = variant_bool(This->event && This->event->stop_propagation);
535 return S_OK;
536 }
537
538 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
539 {
540 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
541
542 FIXME("(%p)->(%p)\n", This, p);
543
544 *p = NULL;
545 return S_OK;
546 }
547
548 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
549 {
550 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
551
552 FIXME("(%p)->(%p)\n", This, p);
553
554 *p = NULL;
555 return S_OK;
556 }
557
558 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
559 {
560 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
561 FIXME("(%p)->(%d)\n", This, v);
562 return E_NOTIMPL;
563 }
564
565 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
566 {
567 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
568 UINT32 key_code = 0;
569
570 TRACE("(%p)->(%p)\n", This, p);
571
572 if(This->event) {
573 nsIDOMKeyEvent *key_event;
574 nsresult nsres;
575
576 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
577 if(NS_SUCCEEDED(nsres)) {
578 nsIDOMKeyEvent_GetKeyCode(key_event, &key_code);
579 nsIDOMKeyEvent_Release(key_event);
580 }
581 }
582
583 *p = key_code;
584 return S_OK;
585 }
586
587 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
588 {
589 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
590 INT16 button = 0;
591
592 TRACE("(%p)->(%p)\n", This, p);
593
594 if(This->event) {
595 nsIDOMMouseEvent *mouse_event;
596 nsresult nsres;
597
598 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
599 if(NS_SUCCEEDED(nsres)) {
600 nsIDOMMouseEvent_GetButton(mouse_event, &button);
601 nsIDOMMouseEvent_Release(mouse_event);
602 }
603 }
604
605 *p = button;
606 return S_OK;
607 }
608
609 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
610 {
611 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
612
613 TRACE("(%p)->(%p)\n", This, p);
614
615 if(!This->event) {
616 *p = NULL;
617 return S_OK;
618 }
619
620 return IDOMEvent_get_type(&This->event->IDOMEvent_iface, p);
621 }
622
623 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
624 {
625 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
626
627 FIXME("(%p)->(%p)\n", This, p);
628
629 *p = NULL;
630 return S_OK;
631 }
632
633 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
634 {
635 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
636
637 FIXME("(%p)->(%p)\n", This, p);
638
639 *p = 0;
640 return S_OK;
641 }
642
643 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
644 {
645 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
646 LONG x = 0;
647
648 TRACE("(%p)->(%p)\n", This, p);
649
650 if(This->event) {
651 nsIDOMUIEvent *ui_event;
652 nsresult nsres;
653
654 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMUIEvent, (void**)&ui_event);
655 if(NS_SUCCEEDED(nsres)) {
656 /* NOTE: pageX is not exactly right here. */
657 nsres = nsIDOMUIEvent_GetPageX(ui_event, &x);
658 assert(nsres == NS_OK);
659 nsIDOMUIEvent_Release(ui_event);
660 }
661 }
662
663 *p = x;
664 return S_OK;
665 }
666
667 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
668 {
669 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
670 LONG y = 0;
671
672 TRACE("(%p)->(%p)\n", This, p);
673
674 if(This->event) {
675 nsIDOMUIEvent *ui_event;
676 nsresult nsres;
677
678 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMUIEvent, (void**)&ui_event);
679 if(NS_SUCCEEDED(nsres)) {
680 /* NOTE: pageY is not exactly right here. */
681 nsres = nsIDOMUIEvent_GetPageY(ui_event, &y);
682 assert(nsres == NS_OK);
683 nsIDOMUIEvent_Release(ui_event);
684 }
685 }
686
687 *p = y;
688 return S_OK;
689 }
690
691 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
692 {
693 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
694 LONG x = 0;
695
696 TRACE("(%p)->(%p)\n", This, p);
697
698 if(This->event) {
699 nsIDOMMouseEvent *mouse_event;
700 nsresult nsres;
701
702 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
703 if(NS_SUCCEEDED(nsres)) {
704 nsIDOMMouseEvent_GetClientX(mouse_event, &x);
705 nsIDOMMouseEvent_Release(mouse_event);
706 }
707 }
708
709 *p = x;
710 return S_OK;
711 }
712
713 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
714 {
715 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
716 LONG y = 0;
717
718 TRACE("(%p)->(%p)\n", This, p);
719
720 if(This->event) {
721 nsIDOMMouseEvent *mouse_event;
722 nsresult nsres;
723
724 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
725 if(NS_SUCCEEDED(nsres)) {
726 nsIDOMMouseEvent_GetClientY(mouse_event, &y);
727 nsIDOMMouseEvent_Release(mouse_event);
728 }
729 }
730
731 *p = y;
732 return S_OK;
733 }
734
735 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
736 {
737 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
738
739 FIXME("(%p)->(%p)\n", This, p);
740
741 *p = 0;
742 return S_OK;
743 }
744
745 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p)
746 {
747 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
748
749 FIXME("(%p)->(%p)\n", This, p);
750
751 *p = 0;
752 return S_OK;
753 }
754
755 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p)
756 {
757 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
758 LONG x = 0;
759
760 TRACE("(%p)->(%p)\n", This, p);
761
762 if(This->event) {
763 nsIDOMMouseEvent *mouse_event;
764 nsresult nsres;
765
766 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
767 if(NS_SUCCEEDED(nsres)) {
768 nsIDOMMouseEvent_GetScreenX(mouse_event, &x);
769 nsIDOMMouseEvent_Release(mouse_event);
770 }
771 }
772
773 *p = x;
774 return S_OK;
775 }
776
777 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
778 {
779 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
780 LONG y = 0;
781
782 TRACE("(%p)->(%p)\n", This, p);
783
784 if(This->event) {
785 nsIDOMMouseEvent *mouse_event;
786 nsresult nsres;
787
788 nsres = nsIDOMEvent_QueryInterface(This->event->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
789 if(NS_SUCCEEDED(nsres)) {
790 nsIDOMMouseEvent_GetScreenY(mouse_event, &y);
791 nsIDOMMouseEvent_Release(mouse_event);
792 }
793 }
794
795 *p = y;
796 return S_OK;
797 }
798
799 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
800 {
801 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
802
803 FIXME("(%p)->(%p)\n", This, p);
804
805 *p = NULL;
806 return S_OK;
807 }
808
809 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
810 HTMLEventObj_QueryInterface,
811 HTMLEventObj_AddRef,
812 HTMLEventObj_Release,
813 HTMLEventObj_GetTypeInfoCount,
814 HTMLEventObj_GetTypeInfo,
815 HTMLEventObj_GetIDsOfNames,
816 HTMLEventObj_Invoke,
817 HTMLEventObj_get_srcElement,
818 HTMLEventObj_get_altKey,
819 HTMLEventObj_get_ctrlKey,
820 HTMLEventObj_get_shiftKey,
821 HTMLEventObj_put_returnValue,
822 HTMLEventObj_get_returnValue,
823 HTMLEventObj_put_cancelBubble,
824 HTMLEventObj_get_cancelBubble,
825 HTMLEventObj_get_fromElement,
826 HTMLEventObj_get_toElement,
827 HTMLEventObj_put_keyCode,
828 HTMLEventObj_get_keyCode,
829 HTMLEventObj_get_button,
830 HTMLEventObj_get_type,
831 HTMLEventObj_get_qualifier,
832 HTMLEventObj_get_reason,
833 HTMLEventObj_get_x,
834 HTMLEventObj_get_y,
835 HTMLEventObj_get_clientX,
836 HTMLEventObj_get_clientY,
837 HTMLEventObj_get_offsetX,
838 HTMLEventObj_get_offsetY,
839 HTMLEventObj_get_screenX,
840 HTMLEventObj_get_screenY,
841 HTMLEventObj_get_srcFilter
842 };
843
844 static inline HTMLEventObj *unsafe_impl_from_IHTMLEventObj(IHTMLEventObj *iface)
845 {
846 return iface->lpVtbl == &HTMLEventObjVtbl ? impl_from_IHTMLEventObj(iface) : NULL;
847 }
848
849 static const tid_t HTMLEventObj_iface_tids[] = {
850 IHTMLEventObj_tid,
851 0
852 };
853
854 static dispex_static_data_t HTMLEventObj_dispex = {
855 NULL,
856 DispCEventObj_tid,
857 HTMLEventObj_iface_tids
858 };
859
860 static HTMLEventObj *alloc_event_obj(DOMEvent *event)
861 {
862 HTMLEventObj *event_obj;
863
864 event_obj = heap_alloc_zero(sizeof(*event_obj));
865 if(!event_obj)
866 return NULL;
867
868 event_obj->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl;
869 event_obj->ref = 1;
870 event_obj->event = event;
871 if(event)
872 IDOMEvent_AddRef(&event->IDOMEvent_iface);
873
874 init_dispex(&event_obj->dispex, (IUnknown*)&event_obj->IHTMLEventObj_iface, &HTMLEventObj_dispex);
875 return event_obj;
876 }
877
878 HRESULT create_event_obj(IHTMLEventObj **ret)
879 {
880 HTMLEventObj *event_obj;
881
882 event_obj = alloc_event_obj(NULL);
883 if(!event_obj)
884 return E_OUTOFMEMORY;
885
886 *ret = &event_obj->IHTMLEventObj_iface;
887 return S_OK;
888 }
889
890 static inline DOMEvent *impl_from_IDOMEvent(IDOMEvent *iface)
891 {
892 return CONTAINING_RECORD(iface, DOMEvent, IDOMEvent_iface);
893 }
894
895 static HRESULT WINAPI DOMEvent_QueryInterface(IDOMEvent *iface, REFIID riid, void **ppv)
896 {
897 DOMEvent *This = impl_from_IDOMEvent(iface);
898
899 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
900
901 if(IsEqualGUID(&IID_IUnknown, riid))
902 *ppv = &This->IDOMEvent_iface;
903 else if(IsEqualGUID(&IID_IDOMEvent, riid))
904 *ppv = &This->IDOMEvent_iface;
905 else if(dispex_query_interface(&This->dispex, riid, ppv))
906 return *ppv ? S_OK : E_NOINTERFACE;
907 else {
908 *ppv = NULL;
909 WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
910 return E_NOINTERFACE;
911 }
912
913 IUnknown_AddRef((IUnknown*)*ppv);
914 return S_OK;
915 }
916
917 static ULONG WINAPI DOMEvent_AddRef(IDOMEvent *iface)
918 {
919 DOMEvent *This = impl_from_IDOMEvent(iface);
920 LONG ref = InterlockedIncrement(&This->ref);
921
922 TRACE("(%p) ref=%u\n", This, ref);
923
924 return ref;
925 }
926
927 static ULONG WINAPI DOMEvent_Release(IDOMEvent *iface)
928 {
929 DOMEvent *This = impl_from_IDOMEvent(iface);
930 LONG ref = InterlockedDecrement(&This->ref);
931
932 TRACE("(%p) ref=%u\n", This, ref);
933
934 if(!ref) {
935 if(This->target)
936 IDispatchEx_Release(&This->target->dispex.IDispatchEx_iface);
937 nsIDOMEvent_Release(This->nsevent);
938 release_dispex(&This->dispex);
939 heap_free(This->type);
940 heap_free(This);
941 }
942
943 return ref;
944 }
945
946 static HRESULT WINAPI DOMEvent_GetTypeInfoCount(IDOMEvent *iface, UINT *pctinfo)
947 {
948 DOMEvent *This = impl_from_IDOMEvent(iface);
949 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
950 }
951
952 static HRESULT WINAPI DOMEvent_GetTypeInfo(IDOMEvent *iface, UINT iTInfo,
953 LCID lcid, ITypeInfo **ppTInfo)
954 {
955 DOMEvent *This = impl_from_IDOMEvent(iface);
956 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
957 }
958
959 static HRESULT WINAPI DOMEvent_GetIDsOfNames(IDOMEvent *iface, REFIID riid,
960 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
961 {
962 DOMEvent *This = impl_from_IDOMEvent(iface);
963 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
964 lcid, rgDispId);
965 }
966
967 static HRESULT WINAPI DOMEvent_Invoke(IDOMEvent *iface, DISPID dispIdMember,
968 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
969 EXCEPINFO *pExcepInfo, UINT *puArgErr)
970 {
971 DOMEvent *This = impl_from_IDOMEvent(iface);
972 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
973 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
974 }
975
976 static HRESULT WINAPI DOMEvent_get_bubbles(IDOMEvent *iface, VARIANT_BOOL *p)
977 {
978 DOMEvent *This = impl_from_IDOMEvent(iface);
979
980 TRACE("(%p)->(%p)\n", This, p);
981
982 *p = variant_bool(This->bubbles);
983 return S_OK;
984 }
985
986 static HRESULT WINAPI DOMEvent_get_cancelable(IDOMEvent *iface, VARIANT_BOOL *p)
987 {
988 DOMEvent *This = impl_from_IDOMEvent(iface);
989
990 TRACE("(%p)->(%p)\n", This, p);
991
992 *p = variant_bool(This->cancelable);
993 return S_OK;
994 }
995
996 static HRESULT WINAPI DOMEvent_get_currentTarget(IDOMEvent *iface, IEventTarget **p)
997 {
998 DOMEvent *This = impl_from_IDOMEvent(iface);
999
1000 TRACE("(%p)->(%p)\n", This, p);
1001
1002 if(This->current_target)
1003 IEventTarget_AddRef(*p = &This->current_target->IEventTarget_iface);
1004 else
1005 *p = NULL;
1006 return S_OK;
1007 }
1008
1009 static HRESULT WINAPI DOMEvent_get_defaultPrevented(IDOMEvent *iface, VARIANT_BOOL *p)
1010 {
1011 DOMEvent *This = impl_from_IDOMEvent(iface);
1012
1013 TRACE("(%p)->(%p)\n", This, p);
1014
1015 *p = variant_bool(This->prevent_default);
1016 return S_OK;
1017 }
1018
1019 static HRESULT WINAPI DOMEvent_get_eventPhase(IDOMEvent *iface, USHORT *p)
1020 {
1021 DOMEvent *This = impl_from_IDOMEvent(iface);
1022
1023 TRACE("(%p)->(%p)\n", This, p);
1024
1025 *p = This->phase;
1026 return S_OK;
1027 }
1028
1029 static HRESULT WINAPI DOMEvent_get_target(IDOMEvent *iface, IEventTarget **p)
1030 {
1031 DOMEvent *This = impl_from_IDOMEvent(iface);
1032
1033 TRACE("(%p)->(%p)\n", This, p);
1034
1035 if(This->target)
1036 IEventTarget_AddRef(*p = &This->target->IEventTarget_iface);
1037 else
1038 *p = NULL;
1039 return S_OK;
1040 }
1041
1042 static HRESULT WINAPI DOMEvent_get_timeStamp(IDOMEvent *iface, ULONGLONG *p)
1043 {
1044 DOMEvent *This = impl_from_IDOMEvent(iface);
1045 FIXME("(%p)->(%p)\n", This, p);
1046 return E_NOTIMPL;
1047 }
1048
1049 static HRESULT WINAPI DOMEvent_get_type(IDOMEvent *iface, BSTR *p)
1050 {
1051 DOMEvent *This = impl_from_IDOMEvent(iface);
1052
1053 TRACE("(%p)->(%p)\n", This, p);
1054
1055 if(This->type) {
1056 *p = SysAllocString(This->type);
1057 if(!*p)
1058 return E_OUTOFMEMORY;
1059 }else {
1060 *p = NULL;
1061 }
1062 return S_OK;
1063 }
1064
1065 static HRESULT WINAPI DOMEvent_initEvent(IDOMEvent *iface, BSTR type, VARIANT_BOOL can_bubble, VARIANT_BOOL cancelable)
1066 {
1067 DOMEvent *This = impl_from_IDOMEvent(iface);
1068 FIXME("(%p)->()\n", This);
1069 return E_NOTIMPL;
1070 }
1071
1072 static HRESULT WINAPI DOMEvent_preventDefault(IDOMEvent *iface)
1073 {
1074 DOMEvent *This = impl_from_IDOMEvent(iface);
1075
1076 TRACE("(%p)\n", This);
1077
1078 if(This->current_target && This->cancelable) {
1079 This->prevent_default = TRUE;
1080 nsIDOMEvent_PreventDefault(This->nsevent);
1081 }
1082 return S_OK;
1083 }
1084
1085 static HRESULT WINAPI DOMEvent_stopPropagation(IDOMEvent *iface)
1086 {
1087 DOMEvent *This = impl_from_IDOMEvent(iface);
1088
1089 TRACE("(%p)\n", This);
1090
1091 This->stop_propagation = TRUE;
1092 nsIDOMEvent_StopPropagation(This->nsevent);
1093 IDOMEvent_preventDefault(&This->IDOMEvent_iface);
1094 return S_OK;
1095 }
1096
1097 static HRESULT WINAPI DOMEvent_stopImmediatePropagation(IDOMEvent *iface)
1098 {
1099 DOMEvent *This = impl_from_IDOMEvent(iface);
1100 FIXME("(%p)\n", This);
1101 return E_NOTIMPL;
1102 }
1103
1104 static HRESULT WINAPI DOMEvent_get_isTrusted(IDOMEvent *iface, VARIANT_BOOL *p)
1105 {
1106 DOMEvent *This = impl_from_IDOMEvent(iface);
1107 FIXME("(%p)->(%p)\n", This, p);
1108 return E_NOTIMPL;
1109 }
1110
1111 static HRESULT WINAPI DOMEvent_put_cancelBubble(IDOMEvent *iface, VARIANT_BOOL v)
1112 {
1113 DOMEvent *This = impl_from_IDOMEvent(iface);
1114 FIXME("(%p)->(%x)\n", This, v);
1115 return E_NOTIMPL;
1116 }
1117
1118 static HRESULT WINAPI DOMEvent_get_cancelBubble(IDOMEvent *iface, VARIANT_BOOL *p)
1119 {
1120 DOMEvent *This = impl_from_IDOMEvent(iface);
1121 FIXME("(%p)->(%p)\n", This, p);
1122 return E_NOTIMPL;
1123 }
1124
1125 static HRESULT WINAPI DOMEvent_get_srcElement(IDOMEvent *iface, IHTMLElement **p)
1126 {
1127 DOMEvent *This = impl_from_IDOMEvent(iface);
1128 FIXME("(%p)->(%p)\n", This, p);
1129 return E_NOTIMPL;
1130 }
1131
1132 static const IDOMEventVtbl DOMEventVtbl = {
1133 DOMEvent_QueryInterface,
1134 DOMEvent_AddRef,
1135 DOMEvent_Release,
1136 DOMEvent_GetTypeInfoCount,
1137 DOMEvent_GetTypeInfo,
1138 DOMEvent_GetIDsOfNames,
1139 DOMEvent_Invoke,
1140 DOMEvent_get_bubbles,
1141 DOMEvent_get_cancelable,
1142 DOMEvent_get_currentTarget,
1143 DOMEvent_get_defaultPrevented,
1144 DOMEvent_get_eventPhase,
1145 DOMEvent_get_target,
1146 DOMEvent_get_timeStamp,
1147 DOMEvent_get_type,
1148 DOMEvent_initEvent,
1149 DOMEvent_preventDefault,
1150 DOMEvent_stopPropagation,
1151 DOMEvent_stopImmediatePropagation,
1152 DOMEvent_get_isTrusted,
1153 DOMEvent_put_cancelBubble,
1154 DOMEvent_get_cancelBubble,
1155 DOMEvent_get_srcElement
1156 };
1157
1158 static const tid_t DOMEvent_iface_tids[] = {
1159 IDOMEvent_tid,
1160 0
1161 };
1162
1163 static dispex_static_data_t DOMEvent_dispex = {
1164 NULL,
1165 IDOMEvent_tid,
1166 DOMEvent_iface_tids
1167 };
1168
1169 static DOMEvent *alloc_event(nsIDOMEvent *nsevent, eventid_t event_id)
1170 {
1171 DOMEvent *event;
1172
1173 event = heap_alloc_zero(sizeof(*event));
1174 if(!event)
1175 return NULL;
1176
1177 init_dispex(&event->dispex, (IUnknown*)&event->IDOMEvent_iface, &DOMEvent_dispex);
1178 event->IDOMEvent_iface.lpVtbl = &DOMEventVtbl;
1179 event->ref = 1;
1180 event->event_id = event_id;
1181 if(event_id != EVENTID_LAST) {
1182 event->type = heap_strdupW(event_info[event_id].name);
1183 if(!event->type) {
1184 IDOMEvent_Release(&event->IDOMEvent_iface);
1185 return NULL;
1186 }
1187 event->bubbles = (event_info[event_id].flags & EVENT_BUBBLES) != 0;
1188 event->cancelable = (event_info[event_id].flags & EVENT_CANCELABLE) != 0;
1189 }
1190 nsIDOMEvent_AddRef(event->nsevent = nsevent);
1191 return event;
1192 }
1193
1194 HRESULT create_event_from_nsevent(nsIDOMEvent *nsevent, DOMEvent **ret_event)
1195 {
1196 eventid_t event_id = EVENTID_LAST;
1197 DOMEvent *event;
1198 nsAString nsstr;
1199 nsresult nsres;
1200
1201 nsAString_Init(&nsstr, NULL);
1202 nsres = nsIDOMEvent_GetType(nsevent, &nsstr);
1203 if(NS_SUCCEEDED(nsres)) {
1204 const WCHAR *type;
1205 nsAString_GetData(&nsstr, &type);
1206 event_id = str_to_eid(type);
1207 if(event_id == EVENTID_LAST)
1208 FIXME("unknown event type %s\n", debugstr_w(type));
1209 }else {
1210 ERR("GetType failed: %08x\n", nsres);
1211 }
1212 nsAString_Finish(&nsstr);
1213
1214 event = alloc_event(nsevent, event_id);
1215 if(!event)
1216 return E_OUTOFMEMORY;
1217
1218 *ret_event = event;
1219 return S_OK;
1220 }
1221
1222 HRESULT create_document_event_str(HTMLDocumentNode *doc, const WCHAR *type, IDOMEvent **ret_event)
1223 {
1224 nsIDOMEvent *nsevent;
1225 DOMEvent *event;
1226 nsAString nsstr;
1227 nsresult nsres;
1228
1229 nsAString_InitDepend(&nsstr, type);
1230 nsres = nsIDOMHTMLDocument_CreateEvent(doc->nsdoc, &nsstr, &nsevent);
1231 nsAString_Finish(&nsstr);
1232 if(NS_FAILED(nsres)) {
1233 FIXME("CreateEvent(%s) failed: %08x\n", debugstr_w(type), nsres);
1234 return E_FAIL;
1235 }
1236
1237 event = alloc_event(nsevent, EVENTID_LAST);
1238 nsIDOMEvent_Release(nsevent);
1239 if(!event)
1240 return E_OUTOFMEMORY;
1241
1242 *ret_event = &event->IDOMEvent_iface;
1243 return S_OK;
1244 }
1245
1246 HRESULT create_document_event(HTMLDocumentNode *doc, eventid_t event_id, DOMEvent **ret_event)
1247 {
1248 nsIDOMEvent *nsevent;
1249 DOMEvent *event;
1250 nsAString nsstr;
1251 nsresult nsres;
1252
1253 nsAString_InitDepend(&nsstr, event_types[event_info[event_id].type]);
1254 nsres = nsIDOMHTMLDocument_CreateEvent(doc->nsdoc, &nsstr, &nsevent);
1255 nsAString_Finish(&nsstr);
1256 if(NS_FAILED(nsres)) {
1257 FIXME("CreateEvent(%s) failed: %08x\n", debugstr_w(event_types[event_info[event_id].type]), nsres);
1258 return E_FAIL;
1259 }
1260
1261 event = alloc_event(nsevent, event_id);
1262 if(!event)
1263 return E_OUTOFMEMORY;
1264
1265 event->event_id = event_id;
1266 *ret_event = event;
1267 return S_OK;
1268 }
1269
1270 static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv)
1271 {
1272 IDispatchEx *dispex;
1273 EXCEPINFO ei;
1274 HRESULT hres;
1275
1276 memset(&ei, 0, sizeof(ei));
1277
1278 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1279 if(SUCCEEDED(hres)) {
1280 hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL);
1281 IDispatchEx_Release(dispex);
1282 }else {
1283 TRACE("Could not get IDispatchEx interface: %08x\n", hres);
1284 hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,
1285 dp, retv, &ei, NULL);
1286 }
1287
1288 return hres;
1289 }
1290
1291 static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, IHTMLEventObj *event_obj, VARIANT *retv)
1292 {
1293 DISPPARAMS dp = {NULL,NULL,0,0};
1294 VARIANT event_arg;
1295 ULONG argerr;
1296 EXCEPINFO ei;
1297
1298 if(event_obj) {
1299 V_VT(&event_arg) = VT_DISPATCH;
1300 V_DISPATCH(&event_arg) = (IDispatch*)event_obj;
1301 dp.rgvarg = &event_arg;
1302 dp.cArgs = 1;
1303 }
1304
1305 memset(&ei, 0, sizeof(ei));
1306 return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr);
1307 }
1308
1309 static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid)
1310 {
1311 int min, max, i;
1312 HRESULT hres;
1313
1314 if(!data)
1315 return FALSE;
1316
1317 if(!data->ids) {
1318 hres = get_dispids(data->tid, &data->id_cnt, &data->ids);
1319 if(FAILED(hres))
1320 return FALSE;
1321 }
1322
1323 min = 0;
1324 max = data->id_cnt-1;
1325 while(min <= max) {
1326 i = (min+max)/2;
1327 if(data->ids[i] == dispid)
1328 return TRUE;
1329
1330 if(data->ids[i] < dispid)
1331 min = i+1;
1332 else
1333 max = i-1;
1334 }
1335
1336 return FALSE;
1337 }
1338
1339 static void call_event_handlers(EventTarget *event_target, DOMEvent *event)
1340 {
1341 const listener_container_t *container = get_listener_container(event_target, event->type, FALSE);
1342 const BOOL use_quirks = use_event_quirks(event_target);
1343 event_listener_t *listener, listeners_buf[8], *listeners = listeners_buf;
1344 unsigned listeners_cnt, listeners_size;
1345 ConnectionPointContainer *cp_container = NULL;
1346 const event_target_vtbl_t *vtbl = NULL;
1347 VARIANT v;
1348 HRESULT hres;
1349
1350 assert(!event->current_target);
1351 event->current_target = event_target;
1352
1353 if(use_quirks && container && !list_empty(&container->listeners)
1354 && event->phase != DEP_CAPTURING_PHASE) {
1355 listener = LIST_ENTRY(list_tail(&container->listeners), event_listener_t, entry);
1356 if(listener && listener->function && listener->type == LISTENER_TYPE_ONEVENT) {
1357 DISPID named_arg = DISPID_THIS;
1358 VARIANTARG arg;
1359 DISPPARAMS dp = {&arg, &named_arg, 1, 1};
1360
1361 V_VT(&arg) = VT_DISPATCH;
1362 V_DISPATCH(&arg) = (IDispatch*)&event_target->dispex.IDispatchEx_iface;
1363 V_VT(&v) = VT_EMPTY;
1364
1365 TRACE("%s >>>\n", debugstr_w(event->type));
1366 hres = call_disp_func(listener->function, &dp, &v);
1367 if(hres == S_OK) {
1368 TRACE("%s <<< %s\n", debugstr_w(event->type), debugstr_variant(&v));
1369
1370 if(event->cancelable) {
1371 if(V_VT(&v) == VT_BOOL) {
1372 if(!V_BOOL(&v))
1373 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
1374 }else if(V_VT(&v) != VT_EMPTY) {
1375 FIXME("unhandled result %s\n", debugstr_variant(&v));
1376 }
1377 }
1378 VariantClear(&v);
1379 }else {
1380 WARN("%s <<< %08x\n", debugstr_w(event->type), hres);
1381 }
1382 }
1383 }
1384
1385 listeners_cnt = 0;
1386 listeners_size = sizeof(listeners_buf)/sizeof(*listeners_buf);
1387
1388 if(container) {
1389 LIST_FOR_EACH_ENTRY(listener, &container->listeners, event_listener_t, entry) {
1390 if(!listener->function)
1391 continue;
1392 switch(listener->type) {
1393 case LISTENER_TYPE_ONEVENT:
1394 if(use_quirks || event->phase == DEP_CAPTURING_PHASE)
1395 continue;
1396 break;
1397 case LISTENER_TYPE_CAPTURE:
1398 if(event->phase == DEP_BUBBLING_PHASE || event->in_fire_event)
1399 continue;
1400 break;
1401 case LISTENER_TYPE_BUBBLE:
1402 if(event->in_fire_event)
1403 continue;
1404 /* fallthrough */
1405 case LISTENER_TYPE_ATTACHED:
1406 if(event->phase == DEP_CAPTURING_PHASE)
1407 continue;
1408 break;
1409 }
1410
1411 if(listeners_cnt == listeners_size) {
1412 event_listener_t *new_listeners;
1413 if(listeners == listeners_buf) {
1414 new_listeners = heap_alloc(listeners_size * 2 * sizeof(*new_listeners));
1415 if(!new_listeners)
1416 break;
1417 memcpy(new_listeners, listeners, listeners_cnt * sizeof(*listeners));
1418 }else {
1419 new_listeners = heap_realloc(listeners, listeners_size * 2 * sizeof(*new_listeners));
1420 }
1421 listeners = new_listeners;
1422 listeners_size *= 2;
1423 }
1424
1425 listeners[listeners_cnt].type = listener->type;
1426 IDispatch_AddRef(listeners[listeners_cnt].function = listener->function);
1427 listeners_cnt++;
1428 }
1429 }
1430
1431 for(listener = listeners; listener < listeners + listeners_cnt; listener++) {
1432 if(listener->type != LISTENER_TYPE_ATTACHED) {
1433 DISPID named_arg = DISPID_THIS;
1434 VARIANTARG args[2];
1435 DISPPARAMS dp = {args, &named_arg, 2, 1};
1436
1437 V_VT(args) = VT_DISPATCH;
1438 V_DISPATCH(args) = (IDispatch*)&event_target->dispex.IDispatchEx_iface;
1439 V_VT(args+1) = VT_DISPATCH;
1440 V_DISPATCH(args+1) = event->in_fire_event
1441 ? (IDispatch*)event->event_obj : (IDispatch*)&event->IDOMEvent_iface;
1442 V_VT(&v) = VT_EMPTY;
1443
1444 TRACE("%s >>>\n", debugstr_w(event->type));
1445 hres = call_disp_func(listener->function, &dp, &v);
1446 if(hres == S_OK) {
1447 TRACE("%s <<< %s\n", debugstr_w(event->type),
1448 debugstr_variant(&v));
1449
1450 if(event->cancelable) {
1451 if(V_VT(&v) == VT_BOOL) {
1452 if(!V_BOOL(&v))
1453 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
1454 }else if(V_VT(&v) != VT_EMPTY) {
1455 FIXME("unhandled result %s\n", debugstr_variant(&v));
1456 }
1457 }
1458 VariantClear(&v);
1459 }else {
1460 WARN("%s <<< %08x\n", debugstr_w(event->type), hres);
1461 }
1462 }else {
1463 VARIANTARG arg;
1464 DISPPARAMS dp = {&arg, NULL, 1, 0};
1465
1466 V_VT(&arg) = VT_DISPATCH;
1467 V_DISPATCH(&arg) = (IDispatch*)event->event_obj;
1468 V_VT(&v) = VT_EMPTY;
1469
1470 TRACE("%s attached >>>\n", debugstr_w(event->type));
1471 hres = call_disp_func(listener->function, &dp, &v);
1472 if(hres == S_OK) {
1473 TRACE("%s attached <<<\n", debugstr_w(event->type));
1474
1475 if(event->cancelable) {
1476 if(V_VT(&v) == VT_BOOL) {
1477 if(!V_BOOL(&v))
1478 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
1479 }else if(V_VT(&v) != VT_EMPTY) {
1480 FIXME("unhandled result %s\n", debugstr_variant(&v));
1481 }
1482 }
1483 VariantClear(&v);
1484 }else {
1485 WARN("%s attached <<< %08x\n", debugstr_w(event->type), hres);
1486 }
1487 }
1488 }
1489
1490 for(listener = listeners; listener < listeners + listeners_cnt; listener++)
1491 IDispatch_Release(listener->function);
1492 if(listeners != listeners_buf)
1493 heap_free(listeners);
1494
1495 if(event->phase != DEP_CAPTURING_PHASE && event->event_id != EVENTID_LAST
1496 && event_info[event->event_id].dispid && (vtbl = dispex_get_vtbl(&event_target->dispex))
1497 && vtbl->get_cp_container)
1498 cp_container = vtbl->get_cp_container(&event_target->dispex);
1499 if(cp_container) {
1500 if(cp_container->cps) {
1501 ConnectionPoint *cp;
1502 unsigned i, j;
1503
1504 for(j=0; cp_container->cp_entries[j].riid; j++) {
1505 cp = cp_container->cps + j;
1506 if(!cp->sinks_size || !is_cp_event(cp->data, event_info[event->event_id].dispid))
1507 continue;
1508
1509 for(i=0; i < cp->sinks_size; i++) {
1510 if(!cp->sinks[i].disp)
1511 continue;
1512
1513 V_VT(&v) = VT_EMPTY;
1514
1515 TRACE("cp %s [%u] >>>\n", debugstr_w(event->type), i);
1516 hres = call_cp_func(cp->sinks[i].disp, event_info[event->event_id].dispid,
1517 cp->data->pass_event_arg ? event->event_obj : NULL, &v);
1518 if(hres == S_OK) {
1519 TRACE("cp %s [%u] <<<\n", debugstr_w(event->type), i);
1520
1521 if(event->cancelable) {
1522 if(V_VT(&v) == VT_BOOL) {
1523 if(!V_BOOL(&v))
1524 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
1525 }else if(V_VT(&v) != VT_EMPTY) {
1526 FIXME("unhandled result %s\n", debugstr_variant(&v));
1527 }
1528 }
1529 VariantClear(&v);
1530 }else {
1531 WARN("cp %s [%u] <<< %08x\n", debugstr_w(event->type), i, hres);
1532 }
1533 }
1534 }
1535 }
1536 IConnectionPointContainer_Release(&cp_container->IConnectionPointContainer_iface);
1537 }
1538
1539 event->current_target = NULL;
1540 }
1541
1542 void dispatch_event(EventTarget *event_target, DOMEvent *event)
1543 {
1544 EventTarget *target_chain_buf[8], **target_chain = target_chain_buf;
1545 unsigned chain_cnt, chain_buf_size, i;
1546 const event_target_vtbl_t *vtbl, *target_vtbl;
1547 HTMLEventObj *event_obj_ref = NULL;
1548 IHTMLEventObj *prev_event = NULL;
1549 EventTarget *iter;
1550 HRESULT hres;
1551
1552 TRACE("(%p) %s\n", event_target, debugstr_w(event->type));
1553
1554 if(event->event_id == EVENTID_LAST) {
1555 FIXME("Unsupported on unknown events\n");
1556 return;
1557 }
1558
1559 if(event->current_target) {
1560 FIXME("event is being dispatched.\n");
1561 return;
1562 }
1563
1564 iter = event_target;
1565 IDispatchEx_AddRef(&event_target->dispex.IDispatchEx_iface);
1566
1567 chain_cnt = 0;
1568 chain_buf_size = sizeof(target_chain_buf)/sizeof(*target_chain_buf);
1569
1570 do {
1571 if(chain_cnt == chain_buf_size) {
1572 EventTarget **new_chain;
1573 if(target_chain == target_chain_buf) {
1574 new_chain = heap_alloc(chain_buf_size * 2 * sizeof(*new_chain));
1575 if(!new_chain)
1576 break;
1577 memcpy(new_chain, target_chain, chain_buf_size * sizeof(*new_chain));
1578 }else {
1579 new_chain = heap_realloc(target_chain, chain_buf_size * 2 * sizeof(*new_chain));
1580 if(!new_chain)
1581 break;
1582 }
1583 chain_buf_size *= 2;
1584 target_chain = new_chain;
1585 }
1586
1587 target_chain[chain_cnt++] = iter;
1588
1589 if(!(vtbl = dispex_get_vtbl(&iter->dispex)) || !vtbl->get_parent_event_target)
1590 break;
1591 iter = vtbl->get_parent_event_target(&iter->dispex);
1592 } while(iter);
1593
1594 if(!event->event_obj && !event->no_event_obj) {
1595 event_obj_ref = alloc_event_obj(event);
1596 if(event_obj_ref)
1597 event->event_obj = &event_obj_ref->IHTMLEventObj_iface;
1598 }
1599
1600 target_vtbl = dispex_get_vtbl(&event_target->dispex);
1601 if(target_vtbl && target_vtbl->set_current_event)
1602 prev_event = target_vtbl->set_current_event(&event_target->dispex, event->event_obj);
1603
1604 if(event->target)
1605 IDispatchEx_Release(&event->target->dispex.IDispatchEx_iface);
1606 event->target = event_target;
1607 IDispatchEx_AddRef(&event_target->dispex.IDispatchEx_iface);
1608
1609 event->phase = DEP_CAPTURING_PHASE;
1610 i = chain_cnt-1;
1611 while(!event->stop_propagation && i)
1612 call_event_handlers(target_chain[i--], event);
1613
1614 if(!event->stop_propagation) {
1615 event->phase = DEP_AT_TARGET;
1616 call_event_handlers(target_chain[0], event);
1617 }
1618
1619 if(event->bubbles) {
1620 event->phase = DEP_BUBBLING_PHASE;
1621 for(i = 1; !event->stop_propagation && i < chain_cnt; i++)
1622 call_event_handlers(target_chain[i], event);
1623 }
1624
1625 if(target_vtbl && target_vtbl->set_current_event) {
1626 prev_event = target_vtbl->set_current_event(&event_target->dispex, prev_event);
1627 if(prev_event)
1628 IHTMLEventObj_Release(prev_event);
1629 }
1630
1631 if(event->event_id != EVENTID_LAST && (event_info[event->event_id].flags & EVENT_HASDEFAULTHANDLERS)) {
1632 for(i = 0; !event->prevent_default && i < chain_cnt; i++) {
1633 BOOL prevent_default = FALSE;
1634 vtbl = dispex_get_vtbl(&target_chain[i]->dispex);
1635 if(!vtbl || !vtbl->handle_event_default)
1636 continue;
1637 hres = vtbl->handle_event_default(&event_target->dispex, event->event_id,
1638 event->nsevent, &prevent_default);
1639 if(FAILED(hres) || event->stop_propagation)
1640 break;
1641 if(prevent_default)
1642 IDOMEvent_preventDefault(&event->IDOMEvent_iface);
1643 }
1644 }
1645
1646 if(event_obj_ref) {
1647 event->event_obj = NULL;
1648 IHTMLEventObj_Release(&event_obj_ref->IHTMLEventObj_iface);
1649 }
1650
1651 for(i = 0; i < chain_cnt; i++)
1652 IDispatchEx_Release(&target_chain[i]->dispex.IDispatchEx_iface);
1653 if(target_chain != target_chain_buf)
1654 heap_free(target_chain);
1655 }
1656
1657 HRESULT fire_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_var, VARIANT_BOOL *cancelled)
1658 {
1659 HTMLEventObj *event_obj = NULL;
1660 eventid_t eid;
1661 HRESULT hres = S_OK;
1662
1663 eid = attr_to_eid(event_name);
1664 if(eid == EVENTID_LAST) {
1665 WARN("unknown event %s\n", debugstr_w(event_name));
1666 return E_INVALIDARG;
1667 }
1668
1669 if(event_var && V_VT(event_var) != VT_EMPTY && V_VT(event_var) != VT_ERROR) {
1670 if(V_VT(event_var) != VT_DISPATCH) {
1671 FIXME("event_var %s not supported\n", debugstr_variant(event_var));
1672 return E_NOTIMPL;
1673 }
1674
1675 if(V_DISPATCH(event_var)) {
1676 IHTMLEventObj *event_iface;
1677
1678 hres = IDispatch_QueryInterface(V_DISPATCH(event_var), &IID_IHTMLEventObj, (void**)&event_iface);
1679 if(FAILED(hres)) {
1680 FIXME("No IHTMLEventObj iface\n");
1681 return hres;
1682 }
1683
1684 event_obj = unsafe_impl_from_IHTMLEventObj(event_iface);
1685 if(!event_obj) {
1686 ERR("Not our IHTMLEventObj?\n");
1687 IHTMLEventObj_Release(event_iface);
1688 return E_FAIL;
1689 }
1690 }
1691 }
1692
1693 if(!event_obj) {
1694 event_obj = alloc_event_obj(NULL);
1695 if(!event_obj)
1696 return E_OUTOFMEMORY;
1697 }
1698
1699 if(!event_obj->event)
1700 hres = create_document_event(node->doc, eid, &event_obj->event);
1701
1702 if(SUCCEEDED(hres)) {
1703 event_obj->event->event_obj = &event_obj->IHTMLEventObj_iface;
1704 event_obj->event->in_fire_event++;
1705 dispatch_event(&node->event_target, event_obj->event);
1706 event_obj->event->in_fire_event--;
1707 event_obj->event->event_obj = NULL;
1708 }
1709
1710 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
1711 if(FAILED(hres))
1712 return hres;
1713
1714 *cancelled = VARIANT_TRUE; /* FIXME */
1715 return S_OK;
1716 }
1717
1718 HRESULT ensure_doc_nsevent_handler(HTMLDocumentNode *doc, eventid_t eid)
1719 {
1720 nsIDOMNode *nsnode = NULL;
1721
1722 TRACE("%s\n", debugstr_w(event_info[eid].name));
1723
1724 if(!doc->nsdoc)
1725 return S_OK;
1726
1727 switch(eid) {
1728 case EVENTID_FOCUSIN:
1729 doc->event_vector[eid] = TRUE;
1730 eid = EVENTID_FOCUS;
1731 break;
1732 case EVENTID_FOCUSOUT:
1733 doc->event_vector[eid] = TRUE;
1734 eid = EVENTID_BLUR;
1735 break;
1736 default:
1737 break;
1738 }
1739
1740 if(doc->event_vector[eid] || !(event_info[eid].flags & (EVENT_DEFAULTLISTENER|EVENT_BIND_TO_BODY)))
1741 return S_OK;
1742
1743 if(event_info[eid].flags & EVENT_BIND_TO_BODY) {
1744 nsnode = doc->node.nsnode;
1745 nsIDOMNode_AddRef(nsnode);
1746 }
1747
1748 doc->event_vector[eid] = TRUE;
1749 add_nsevent_listener(doc, nsnode, event_info[eid].name);
1750
1751 if(nsnode)
1752 nsIDOMNode_Release(nsnode);
1753 return S_OK;
1754 }
1755
1756 void detach_events(HTMLDocumentNode *doc)
1757 {
1758 if(doc->event_vector) {
1759 int i;
1760
1761 for(i=0; i < EVENTID_LAST; i++) {
1762 if(doc->event_vector[i]) {
1763 detach_nsevent(doc, event_info[i].name);
1764 doc->event_vector[i] = FALSE;
1765 }
1766 }
1767 }
1768
1769 release_nsevents(doc);
1770 }
1771
1772 static HRESULT get_event_dispex_ref(EventTarget *event_target, eventid_t eid, BOOL alloc, VARIANT **ret)
1773 {
1774 WCHAR buf[64];
1775 buf[0] = 'o';
1776 buf[1] = 'n';
1777 strcpyW(buf+2, event_info[eid].name);
1778 return dispex_get_dprop_ref(&event_target->dispex, buf, alloc, ret);
1779 }
1780
1781 static event_listener_t *get_onevent_listener(EventTarget *event_target, eventid_t eid, BOOL alloc)
1782 {
1783 listener_container_t *container;
1784 event_listener_t *listener;
1785
1786 container = get_listener_container(event_target, event_info[eid].name, alloc);
1787 if(!container)
1788 return NULL;
1789
1790 LIST_FOR_EACH_ENTRY_REV(listener, &container->listeners, event_listener_t, entry) {
1791 if(listener->type == LISTENER_TYPE_ONEVENT)
1792 return listener;
1793 }
1794
1795 if(!alloc)
1796 return NULL;
1797
1798 listener = heap_alloc(sizeof(*listener));
1799 if(!listener)
1800 return NULL;
1801
1802 listener->type = LISTENER_TYPE_ONEVENT;
1803 listener->function = NULL;
1804 list_add_tail(&container->listeners, &listener->entry);
1805 return listener;
1806 }
1807
1808 static void remove_event_handler(EventTarget *event_target, eventid_t eid)
1809 {
1810 event_listener_t *listener;
1811 VARIANT *store;
1812 HRESULT hres;
1813
1814 hres = get_event_dispex_ref(event_target, eid, FALSE, &store);
1815 if(SUCCEEDED(hres))
1816 VariantClear(store);
1817
1818 listener = get_onevent_listener(event_target, eid, FALSE);
1819 if(listener && listener->function) {
1820 IDispatch_Release(listener->function);
1821 listener->function = NULL;
1822 }
1823 }
1824
1825 static HRESULT set_event_handler_disp(EventTarget *event_target, eventid_t eid, IDispatch *disp)
1826 {
1827 event_listener_t *listener;
1828
1829 if(event_info[eid].flags & EVENT_FIXME)
1830 FIXME("unimplemented event %s\n", debugstr_w(event_info[eid].name));
1831
1832 remove_event_handler(event_target, eid);
1833 if(!disp)
1834 return S_OK;
1835
1836 listener = get_onevent_listener(event_target, eid, TRUE);
1837 if(!listener)
1838 return E_OUTOFMEMORY;
1839
1840 if(listener->function)
1841 IDispatch_Release(listener->function);
1842
1843 IDispatch_AddRef(listener->function = disp);
1844 return S_OK;
1845 }
1846
1847 HRESULT set_event_handler(EventTarget *event_target, eventid_t eid, VARIANT *var)
1848 {
1849 switch(V_VT(var)) {
1850 case VT_EMPTY:
1851 if(use_event_quirks(event_target)) {
1852 WARN("attempt to set to VT_EMPTY in quirks mode\n");
1853 return E_NOTIMPL;
1854 }
1855 /* fall through */
1856 case VT_NULL:
1857 remove_event_handler(event_target, eid);
1858 return S_OK;
1859
1860 case VT_DISPATCH:
1861 return set_event_handler_disp(event_target, eid, V_DISPATCH(var));
1862
1863 case VT_BSTR: {
1864 VARIANT *v;
1865 HRESULT hres;
1866
1867 if(!use_event_quirks(event_target))
1868 FIXME("Setting to string %s not supported\n", debugstr_w(V_BSTR(var)));
1869
1870 /*
1871 * Setting event handler to string is a rare case and we don't want to
1872 * complicate nor increase memory of listener_container_t for that. Instead,
1873 * we store the value in DispatchEx, which can already handle custom
1874 * properties.
1875 */
1876 remove_event_handler(event_target, eid);
1877
1878 hres = get_event_dispex_ref(event_target, eid, TRUE, &v);
1879 if(FAILED(hres))
1880 return hres;
1881
1882 V_BSTR(v) = SysAllocString(V_BSTR(var));
1883 if(!V_BSTR(v))
1884 return E_OUTOFMEMORY;
1885 V_VT(v) = VT_BSTR;
1886 return S_OK;
1887 }
1888
1889 default:
1890 FIXME("not handler %s\n", debugstr_variant(var));
1891 return E_NOTIMPL;
1892 }
1893
1894 return S_OK;
1895 }
1896
1897 HRESULT get_event_handler(EventTarget *event_target, eventid_t eid, VARIANT *var)
1898 {
1899 event_listener_t *listener;
1900 VARIANT *v;
1901 HRESULT hres;
1902
1903 hres = get_event_dispex_ref(event_target, eid, FALSE, &v);
1904 if(SUCCEEDED(hres) && V_VT(v) != VT_EMPTY) {
1905 V_VT(var) = VT_EMPTY;
1906 return VariantCopy(var, v);
1907 }
1908
1909 listener = get_onevent_listener(event_target, eid, FALSE);
1910 if(listener && listener->function) {
1911 V_VT(var) = VT_DISPATCH;
1912 V_DISPATCH(var) = listener->function;
1913 IDispatch_AddRef(V_DISPATCH(var));
1914 }else {
1915 V_VT(var) = VT_NULL;
1916 }
1917
1918 return S_OK;
1919 }
1920
1921 HRESULT attach_event(EventTarget *event_target, BSTR name, IDispatch *disp, VARIANT_BOOL *res)
1922 {
1923 listener_container_t *container;
1924 event_listener_t *listener;
1925 eventid_t eid;
1926
1927 eid = attr_to_eid(name);
1928 if(eid == EVENTID_LAST) {
1929 WARN("Unknown event\n");
1930 *res = VARIANT_TRUE;
1931 return S_OK;
1932 }
1933
1934 container = get_listener_container(event_target, event_info[eid].name, TRUE);
1935 if(!container)
1936 return E_OUTOFMEMORY;
1937
1938 listener = heap_alloc(sizeof(*listener));
1939 if(!listener)
1940 return E_OUTOFMEMORY;
1941
1942 listener->type = LISTENER_TYPE_ATTACHED;
1943 IDispatch_AddRef(listener->function = disp);
1944 if(use_event_quirks(event_target))
1945 list_add_head(&container->listeners, &listener->entry);
1946 else
1947 list_add_tail(&container->listeners, &listener->entry);
1948
1949 *res = VARIANT_TRUE;
1950 return S_OK;
1951 }
1952
1953 HRESULT detach_event(EventTarget *event_target, BSTR name, IDispatch *disp)
1954 {
1955 eventid_t eid;
1956
1957 eid = attr_to_eid(name);
1958 if(eid == EVENTID_LAST) {
1959 WARN("Unknown event\n");
1960 return S_OK;
1961 }
1962
1963 remove_event_listener(event_target, event_info[eid].name, LISTENER_TYPE_ATTACHED, disp);
1964 return S_OK;
1965 }
1966
1967 void bind_target_event(HTMLDocumentNode *doc, EventTarget *event_target, const WCHAR *event, IDispatch *disp)
1968 {
1969 eventid_t eid;
1970
1971 TRACE("(%p %p %s %p)\n", doc, event_target, debugstr_w(event), disp);
1972
1973 eid = attr_to_eid(event);
1974 if(eid == EVENTID_LAST) {
1975 WARN("Unsupported event %s\n", debugstr_w(event));
1976 return;
1977 }
1978
1979 set_event_handler_disp(event_target, eid, disp);
1980 }
1981
1982 void update_doc_cp_events(HTMLDocumentNode *doc, cp_static_data_t *cp)
1983 {
1984 int i;
1985
1986 for(i=0; i < EVENTID_LAST; i++) {
1987 if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
1988 ensure_doc_nsevent_handler(doc, i);
1989 }
1990 }
1991
1992 void check_event_attr(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem)
1993 {
1994 nsIDOMMozNamedAttrMap *attr_map;
1995 const PRUnichar *name, *value;
1996 nsAString name_str, value_str;
1997 HTMLDOMNode *node = NULL;
1998 cpp_bool has_attrs;
1999 nsIDOMAttr *attr;
2000 IDispatch *disp;
2001 UINT32 length, i;
2002 eventid_t eid;
2003 nsresult nsres;
2004 HRESULT hres;
2005
2006 nsres = nsIDOMHTMLElement_HasAttributes(nselem, &has_attrs);
2007 if(NS_FAILED(nsres) || !has_attrs)
2008 return;
2009
2010 nsres = nsIDOMHTMLElement_GetAttributes(nselem, &attr_map);
2011 if(NS_FAILED(nsres))
2012 return;
2013
2014 nsres = nsIDOMMozNamedAttrMap_GetLength(attr_map, &length);
2015 assert(nsres == NS_OK);
2016
2017 nsAString_Init(&name_str, NULL);
2018 nsAString_Init(&value_str, NULL);
2019
2020 for(i = 0; i < length; i++) {
2021 nsres = nsIDOMMozNamedAttrMap_Item(attr_map, i, &attr);
2022 if(NS_FAILED(nsres))
2023 continue;
2024
2025 nsres = nsIDOMAttr_GetName(attr, &name_str);
2026 if(NS_FAILED(nsres)) {
2027 nsIDOMAttr_Release(attr);
2028 continue;
2029 }
2030
2031 nsAString_GetData(&name_str, &name);
2032 eid = attr_to_eid(name);
2033 if(eid == EVENTID_LAST) {
2034 nsIDOMAttr_Release(attr);
2035 continue;
2036 }
2037
2038 nsres = nsIDOMAttr_GetValue(attr, &value_str);
2039 nsIDOMAttr_Release(attr);
2040 if(NS_FAILED(nsres))
2041 continue;
2042
2043 nsAString_GetData(&value_str, &value);
2044 if(!*value)
2045 continue;
2046
2047 TRACE("%p.%s = %s\n", nselem, debugstr_w(name), debugstr_w(value));
2048
2049 disp = script_parse_event(doc->window, value);
2050 if(!disp)
2051 continue;
2052
2053 if(!node) {
2054 hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
2055 if(FAILED(hres)) {
2056 IDispatch_Release(disp);
2057 break;
2058 }
2059 }
2060
2061 set_event_handler_disp(get_node_event_prop_target(node, eid), eid, disp);
2062 IDispatch_Release(disp);
2063 }
2064
2065 if(node)
2066 node_release(node);
2067 nsAString_Finish(&name_str);
2068 nsAString_Finish(&value_str);
2069 nsIDOMMozNamedAttrMap_Release(attr_map);
2070 }
2071
2072 HRESULT doc_init_events(HTMLDocumentNode *doc)
2073 {
2074 unsigned i;
2075 HRESULT hres;
2076
2077 doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
2078 if(!doc->event_vector)
2079 return E_OUTOFMEMORY;
2080
2081 init_nsevents(doc);
2082
2083 for(i=0; i < EVENTID_LAST; i++) {
2084 if(event_info[i].flags & EVENT_HASDEFAULTHANDLERS) {
2085 hres = ensure_doc_nsevent_handler(doc, i);
2086 if(FAILED(hres))
2087 return hres;
2088 }
2089 }
2090
2091 return S_OK;
2092 }
2093
2094 static inline EventTarget *impl_from_IEventTarget(IEventTarget *iface)
2095 {
2096 return CONTAINING_RECORD(iface, EventTarget, IEventTarget_iface);
2097 }
2098
2099 static HRESULT WINAPI EventTarget_QueryInterface(IEventTarget *iface, REFIID riid, void **ppv)
2100 {
2101 EventTarget *This = impl_from_IEventTarget(iface);
2102 return IDispatchEx_QueryInterface(&This->dispex.IDispatchEx_iface, riid, ppv);
2103 }
2104
2105 static ULONG WINAPI EventTarget_AddRef(IEventTarget *iface)
2106 {
2107 EventTarget *This = impl_from_IEventTarget(iface);
2108 return IDispatchEx_AddRef(&This->dispex.IDispatchEx_iface);
2109 }
2110
2111 static ULONG WINAPI EventTarget_Release(IEventTarget *iface)
2112 {
2113 EventTarget *This = impl_from_IEventTarget(iface);
2114 return IDispatchEx_Release(&This->dispex.IDispatchEx_iface);
2115 }
2116
2117 static HRESULT WINAPI EventTarget_GetTypeInfoCount(IEventTarget *iface, UINT *pctinfo)
2118 {
2119 EventTarget *This = impl_from_IEventTarget(iface);
2120 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
2121 }
2122
2123 static HRESULT WINAPI EventTarget_GetTypeInfo(IEventTarget *iface, UINT iTInfo,
2124 LCID lcid, ITypeInfo **ppTInfo)
2125 {
2126 EventTarget *This = impl_from_IEventTarget(iface);
2127 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2128 }
2129
2130 static HRESULT WINAPI EventTarget_GetIDsOfNames(IEventTarget *iface, REFIID riid, LPOLESTR *rgszNames,
2131 UINT cNames, LCID lcid, DISPID *rgDispId)
2132 {
2133 EventTarget *This = impl_from_IEventTarget(iface);
2134 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid,
2135 rgszNames, cNames, lcid, rgDispId);
2136 }
2137
2138 static HRESULT WINAPI EventTarget_Invoke(IEventTarget *iface, DISPID dispIdMember,
2139 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2140 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2141 {
2142 EventTarget *This = impl_from_IEventTarget(iface);
2143 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember,
2144 riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2145 }
2146
2147 static HRESULT WINAPI EventTarget_addEventListener(IEventTarget *iface, BSTR type,
2148 IDispatch *function, VARIANT_BOOL capture)
2149 {
2150 EventTarget *This = impl_from_IEventTarget(iface);
2151 listener_type_t listener_type = capture ? LISTENER_TYPE_CAPTURE : LISTENER_TYPE_BUBBLE;
2152 listener_container_t *container;
2153 event_listener_t *listener;
2154
2155 TRACE("(%p)->(%s %p %x)\n", This, debugstr_w(type), function, capture);
2156
2157 container = get_listener_container(This, type, TRUE);
2158 if(!container)
2159 return E_OUTOFMEMORY;
2160
2161 /* check for duplicates */
2162 LIST_FOR_EACH_ENTRY(listener, &container->listeners, event_listener_t, entry) {
2163 if(listener->type == listener_type && listener->function == function)
2164 return S_OK;
2165 }
2166
2167 listener = heap_alloc(sizeof(*listener));
2168 if(!listener)
2169 return E_OUTOFMEMORY;
2170
2171 listener->type = listener_type;
2172 IDispatch_AddRef(listener->function = function);
2173 list_add_tail(&container->listeners, &listener->entry);
2174 return S_OK;
2175 }
2176
2177 static HRESULT WINAPI EventTarget_removeEventListener(IEventTarget *iface, BSTR type,
2178 IDispatch *listener, VARIANT_BOOL capture)
2179 {
2180 EventTarget *This = impl_from_IEventTarget(iface);
2181
2182 TRACE("(%p)->(%s %p %x)\n", This, debugstr_w(type), listener, capture);
2183
2184 remove_event_listener(This, type, capture ? LISTENER_TYPE_CAPTURE : LISTENER_TYPE_BUBBLE, listener);
2185 return S_OK;
2186 }
2187
2188 static HRESULT WINAPI EventTarget_dispatchEvent(IEventTarget *iface, IDOMEvent *event, VARIANT_BOOL *result)
2189 {
2190 EventTarget *This = impl_from_IEventTarget(iface);
2191 FIXME("(%p)->(%p %p)\n", This, event, result);
2192 return E_NOTIMPL;
2193 }
2194
2195 HRESULT IEventTarget_addEventListener_hook(DispatchEx *dispex, LCID lcid, WORD flags,
2196 DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
2197 {
2198 /* If only two arguments were given, implicitly set capture to false */
2199 if((flags & DISPATCH_METHOD) && dp->cArgs == 2 && !dp->cNamedArgs) {
2200 VARIANT args[3];
2201 DISPPARAMS new_dp = {args, NULL, 3, 0};
2202 V_VT(args) = VT_BOOL;
2203 V_BOOL(args) = VARIANT_FALSE;
2204 args[1] = dp->rgvarg[0];
2205 args[2] = dp->rgvarg[1];
2206
2207 TRACE("implicit capture\n");
2208
2209 return IDispatchEx_InvokeEx(&dispex->IDispatchEx_iface, DISPID_IEVENTTARGET_ADDEVENTLISTENER,
2210 lcid, flags, &new_dp, res, ei, caller);
2211 }
2212
2213 return S_FALSE; /* fallback to default */
2214 }
2215
2216 HRESULT IEventTarget_removeEventListener_hook(DispatchEx *dispex, LCID lcid, WORD flags,
2217 DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
2218 {
2219 /* If only two arguments were given, implicitly set capture to false */
2220 if((flags & DISPATCH_METHOD) && dp->cArgs == 2 && !dp->cNamedArgs) {
2221 VARIANT args[3];
2222 DISPPARAMS new_dp = {args, NULL, 3, 0};
2223 V_VT(args) = VT_BOOL;
2224 V_BOOL(args) = VARIANT_FALSE;
2225 args[1] = dp->rgvarg[0];
2226 args[2] = dp->rgvarg[1];
2227
2228 TRACE("implicit capture\n");
2229
2230 return IDispatchEx_InvokeEx(&dispex->IDispatchEx_iface, DISPID_IEVENTTARGET_REMOVEEVENTLISTENER,
2231 lcid, flags, &new_dp, res, ei, caller);
2232 }
2233
2234 return S_FALSE; /* fallback to default */
2235 }
2236
2237 static const IEventTargetVtbl EventTargetVtbl = {
2238 EventTarget_QueryInterface,
2239 EventTarget_AddRef,
2240 EventTarget_Release,
2241 EventTarget_GetTypeInfoCount,
2242 EventTarget_GetTypeInfo,
2243 EventTarget_GetIDsOfNames,
2244 EventTarget_Invoke,
2245 EventTarget_addEventListener,
2246 EventTarget_removeEventListener,
2247 EventTarget_dispatchEvent
2248 };
2249
2250 #define DELAY_INIT_VTBL ((const IEventTargetVtbl*)1)
2251
2252 static BOOL use_event_quirks(EventTarget *event_target)
2253 {
2254 if(event_target->IEventTarget_iface.lpVtbl == DELAY_INIT_VTBL) {
2255 event_target->IEventTarget_iface.lpVtbl =
2256 dispex_compat_mode(&event_target->dispex) >= COMPAT_MODE_IE9
2257 ? &EventTargetVtbl : NULL;
2258 }
2259 return !event_target->IEventTarget_iface.lpVtbl;
2260 }
2261
2262 HRESULT EventTarget_QI(EventTarget *event_target, REFIID riid, void **ppv)
2263 {
2264 if(IsEqualGUID(riid, &IID_IEventTarget)) {
2265 if(use_event_quirks(event_target)) {
2266 WARN("IEventTarget queried, but not supported by in document mode\n");
2267 *ppv = NULL;
2268 return E_NOINTERFACE;
2269 }
2270 IEventTarget_AddRef(&event_target->IEventTarget_iface);
2271 *ppv = &event_target->IEventTarget_iface;
2272 return S_OK;
2273 }
2274
2275 if(dispex_query_interface(&event_target->dispex, riid, ppv))
2276 return *ppv ? S_OK : E_NOINTERFACE;
2277
2278 WARN("(%p)->(%s %p)\n", event_target, debugstr_mshtml_guid(riid), ppv);
2279 *ppv = NULL;
2280 return E_NOINTERFACE;
2281 }
2282
2283 void EventTarget_init_dispex_info(dispex_data_t *dispex_info, compat_mode_t compat_mode)
2284 {
2285 static const dispex_hook_t IEventTarget_hooks[] = {
2286 {DISPID_IEVENTTARGET_ADDEVENTLISTENER, IEventTarget_addEventListener_hook},
2287 {DISPID_IEVENTTARGET_REMOVEEVENTLISTENER, IEventTarget_removeEventListener_hook},
2288 {DISPID_UNKNOWN}
2289 };
2290
2291 if(compat_mode >= COMPAT_MODE_IE9)
2292 dispex_info_add_interface(dispex_info, IEventTarget_tid, IEventTarget_hooks);
2293 }
2294
2295 static int event_id_cmp(const void *key, const struct wine_rb_entry *entry)
2296 {
2297 return strcmpW(key, WINE_RB_ENTRY_VALUE(entry, listener_container_t, entry)->type);
2298 }
2299
2300 void EventTarget_Init(EventTarget *event_target, IUnknown *outer, dispex_static_data_t *dispex_data,
2301 compat_mode_t compat_mode)
2302 {
2303 init_dispex_with_compat_mode(&event_target->dispex, outer, dispex_data, compat_mode);
2304 wine_rb_init(&event_target->handler_map, event_id_cmp);
2305
2306 /*
2307 * IEventTarget is supported by the object or not depending on compatibility mode.
2308 * We use NULL vtbl for objects in compatibility mode not supporting the interface.
2309 * For targets that don't know compatibility mode at creation time, we set vtbl
2310 * to special DELAY_INIT_VTBL value so that vtbl will be set to proper value
2311 * when it's needed.
2312 */
2313 if(compat_mode == COMPAT_MODE_QUIRKS && dispex_data->vtbl && dispex_data->vtbl->get_compat_mode)
2314 event_target->IEventTarget_iface.lpVtbl = DELAY_INIT_VTBL;
2315 else if(compat_mode < COMPAT_MODE_IE9)
2316 event_target->IEventTarget_iface.lpVtbl = NULL;
2317 else
2318 event_target->IEventTarget_iface.lpVtbl = &EventTargetVtbl;
2319 }
2320
2321 void release_event_target(EventTarget *event_target)
2322 {
2323 listener_container_t *iter, *iter2;
2324
2325 WINE_RB_FOR_EACH_ENTRY_DESTRUCTOR(iter, iter2, &event_target->handler_map, listener_container_t, entry) {
2326 while(!list_empty(&iter->listeners)) {
2327 event_listener_t *listener = LIST_ENTRY(list_head(&iter->listeners), event_listener_t, entry);
2328 if(listener->function)
2329 IDispatch_Release(listener->function);
2330 list_remove(&listener->entry);
2331 heap_free(listener);
2332 }
2333 heap_free(iter);
2334 }
2335 }
Windows API implementation