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