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