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