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