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