?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Added IHTMLButtonElement::name tests.
[wine.git] / dlls / mshtml / htmlevent.c
blob9ea17082062195393af573845dcab78a06d1985e
1 /*
2 * Copyright 2008-2009 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20
21 #define COBJMACROS
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "ole2.h"
27 #include "mshtmdid.h"
28
29 #include "mshtml_private.h"
30 #include "htmlevent.h"
31 #include "htmlscript.h"
32
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
36
37 typedef struct {
38 IDispatch *handler_prop;
39 DWORD handler_cnt;
40 IDispatch *handlers[0];
41 } handler_vector_t;
42
43 struct event_target_t {
44 DWORD node_handlers_mask;
45 handler_vector_t *event_table[EVENTID_LAST];
46 };
47
48 static const WCHAR abortW[] = {'a','b','o','r','t',0};
49 static const WCHAR onabortW[] = {'o','n','a','b','o','r','t',0};
50
51 static const WCHAR beforeunloadW[] = {'b','e','f','o','r','e','u','n','l','o','a','d',0};
52 static const WCHAR onbeforeunloadW[] = {'o','n','b','e','f','o','r','e','u','n','l','o','a','d',0};
53
54 static const WCHAR blurW[] = {'b','l','u','r',0};
55 static const WCHAR onblurW[] = {'o','n','b','l','u','r',0};
56
57 static const WCHAR changeW[] = {'c','h','a','n','g','e',0};
58 static const WCHAR onchangeW[] = {'o','n','c','h','a','n','g','e',0};
59
60 static const WCHAR clickW[] = {'c','l','i','c','k',0};
61 static const WCHAR onclickW[] = {'o','n','c','l','i','c','k',0};
62
63 static const WCHAR contextmenuW[] = {'c','o','n','t','e','x','t','m','e','n','u',0};
64 static const WCHAR oncontextmenuW[] = {'o','n','c','o','n','t','e','x','t','m','e','n','u',0};
65
66 static const WCHAR dataavailableW[] = {'d','a','t','a','a','v','a','i','l','a','b','l','e',0};
67 static const WCHAR ondataavailableW[] = {'o','n','d','a','t','a','a','v','a','i','l','a','b','l','e',0};
68
69 static const WCHAR dblclickW[] = {'d','b','l','c','l','i','c','k',0};
70 static const WCHAR ondblclickW[] = {'o','n','d','b','l','c','l','i','c','k',0};
71
72 static const WCHAR dragW[] = {'d','r','a','g',0};
73 static const WCHAR ondragW[] = {'o','n','d','r','a','g',0};
74
75 static const WCHAR dragstartW[] = {'d','r','a','g','s','t','a','r','t',0};
76 static const WCHAR ondragstartW[] = {'o','n','d','r','a','g','s','t','a','r','t',0};
77
78 static const WCHAR errorW[] = {'e','r','r','o','r',0};
79 static const WCHAR onerrorW[] = {'o','n','e','r','r','o','r',0};
80
81 static const WCHAR focusW[] = {'f','o','c','u','s',0};
82 static const WCHAR onfocusW[] = {'o','n','f','o','c','u','s',0};
83
84 static const WCHAR helpW[] = {'h','e','l','p',0};
85 static const WCHAR onhelpW[] = {'o','n','h','e','l','p',0};
86
87 static const WCHAR keydownW[] = {'k','e','y','d','o','w','n',0};
88 static const WCHAR onkeydownW[] = {'o','n','k','e','y','d','o','w','n',0};
89
90 static const WCHAR keypressW[] = {'k','e','y','p','r','e','s','s',0};
91 static const WCHAR onkeypressW[] = {'o','n','k','e','y','p','r','e','s','s',0};
92
93 static const WCHAR keyupW[] = {'k','e','y','u','p',0};
94 static const WCHAR onkeyupW[] = {'o','n','k','e','y','u','p',0};
95
96 static const WCHAR loadW[] = {'l','o','a','d',0};
97 static const WCHAR onloadW[] = {'o','n','l','o','a','d',0};
98
99 static const WCHAR mousedownW[] = {'m','o','u','s','e','d','o','w','n',0};
100 static const WCHAR onmousedownW[] = {'o','n','m','o','u','s','e','d','o','w','n',0};
101
102 static const WCHAR mousemoveW[] = {'m','o','u','s','e','m','o','v','e',0};
103 static const WCHAR onmousemoveW[] = {'o','n','m','o','u','s','e','m','o','v','e',0};
104
105 static const WCHAR mouseoutW[] = {'m','o','u','s','e','o','u','t',0};
106 static const WCHAR onmouseoutW[] = {'o','n','m','o','u','s','e','o','u','t',0};
107
108 static const WCHAR mouseoverW[] = {'m','o','u','s','e','o','v','e','r',0};
109 static const WCHAR onmouseoverW[] = {'o','n','m','o','u','s','e','o','v','e','r',0};
110
111 static const WCHAR mouseupW[] = {'m','o','u','s','e','u','p',0};
112 static const WCHAR onmouseupW[] = {'o','n','m','o','u','s','e','u','p',0};
113
114 static const WCHAR pasteW[] = {'p','a','s','t','e',0};
115 static const WCHAR onpasteW[] = {'o','n','p','a','s','t','e',0};
116
117 static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
118 static const WCHAR onreadystatechangeW[] = {'o','n','r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
119
120 static const WCHAR resizeW[] = {'r','e','s','i','z','e',0};
121 static const WCHAR onresizeW[] = {'o','n','r','e','s','i','z','e',0};
122
123 static const WCHAR scrollW[] = {'s','c','r','o','l','l',0};
124 static const WCHAR onscrollW[] = {'o','n','s','c','r','o','l','l',0};
125
126 static const WCHAR selectstartW[] = {'s','e','l','e','c','t','s','t','a','r','t',0};
127 static const WCHAR onselectstartW[] = {'o','n','s','e','l','e','c','t','s','t','a','r','t',0};
128
129 static const WCHAR submitW[] = {'s','u','b','m','i','t',0};
130 static const WCHAR onsubmitW[] = {'o','n','s','u','b','m','i','t',0};
131
132 static const WCHAR HTMLEventsW[] = {'H','T','M','L','E','v','e','n','t','s',0};
133 static const WCHAR KeyboardEventW[] = {'K','e','y','b','o','a','r','d','E','v','e','n','t',0};
134 static const WCHAR MouseEventW[] = {'M','o','u','s','e','E','v','e','n','t',0};
135
136 enum {
137 EVENTT_NONE,
138 EVENTT_HTML,
139 EVENTT_KEY,
140 EVENTT_MOUSE
141 };
142
143 static const WCHAR *event_types[] = {
144 NULL,
145 HTMLEventsW,
146 KeyboardEventW,
147 MouseEventW
148 };
149
150 typedef struct {
151 LPCWSTR name;
152 LPCWSTR attr_name;
153 DWORD type;
154 DISPID dispid;
155 DWORD flags;
156 } event_info_t;
157
158 #define EVENT_DEFAULTLISTENER 0x0001
159 #define EVENT_BUBBLE 0x0002
160 #define EVENT_FORWARDBODY 0x0004
161 #define EVENT_NODEHANDLER 0x0008
162 #define EVENT_CANCELABLE 0x0010
163 #define EVENT_HASDEFAULTHANDLERS 0x0020
164
165 static const event_info_t event_info[] = {
166 {abortW, onabortW, EVENTT_NONE, DISPID_EVMETH_ONABORT,
167 EVENT_NODEHANDLER},
168 {beforeunloadW, onbeforeunloadW, EVENTT_NONE, DISPID_EVMETH_ONBEFOREUNLOAD,
169 EVENT_DEFAULTLISTENER|EVENT_FORWARDBODY},
170 {blurW, onblurW, EVENTT_HTML, DISPID_EVMETH_ONBLUR,
171 EVENT_DEFAULTLISTENER},
172 {changeW, onchangeW, EVENTT_HTML, DISPID_EVMETH_ONCHANGE,
173 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
174 {clickW, onclickW, EVENTT_MOUSE, DISPID_EVMETH_ONCLICK,
175 EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE|EVENT_HASDEFAULTHANDLERS},
176 {contextmenuW, oncontextmenuW, EVENTT_MOUSE, DISPID_EVMETH_ONCONTEXTMENU,
177 EVENT_BUBBLE|EVENT_CANCELABLE},
178 {dataavailableW, ondataavailableW, EVENTT_NONE, DISPID_EVMETH_ONDATAAVAILABLE,
179 EVENT_BUBBLE},
180 {dblclickW, ondblclickW, EVENTT_MOUSE, DISPID_EVMETH_ONDBLCLICK,
181 EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE},
182 {dragW, ondragW, EVENTT_MOUSE, DISPID_EVMETH_ONDRAG,
183 EVENT_CANCELABLE},
184 {dragstartW, ondragstartW, EVENTT_MOUSE, DISPID_EVMETH_ONDRAGSTART,
185 EVENT_CANCELABLE},
186 {errorW, onerrorW, EVENTT_NONE, DISPID_EVMETH_ONERROR,
187 EVENT_NODEHANDLER},
188 {focusW, onfocusW, EVENTT_HTML, DISPID_EVMETH_ONFOCUS,
189 EVENT_DEFAULTLISTENER},
190 {helpW, onhelpW, EVENTT_KEY, DISPID_EVMETH_ONHELP,
191 EVENT_BUBBLE|EVENT_CANCELABLE},
192 {keydownW, onkeydownW, EVENTT_KEY, DISPID_EVMETH_ONKEYDOWN,
193 EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_HASDEFAULTHANDLERS},
194 {keypressW, onkeypressW, EVENTT_KEY, DISPID_EVMETH_ONKEYPRESS,
195 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
196 {keyupW, onkeyupW, EVENTT_KEY, DISPID_EVMETH_ONKEYUP,
197 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
198 {loadW, onloadW, EVENTT_HTML, DISPID_EVMETH_ONLOAD,
199 EVENT_NODEHANDLER},
200 {mousedownW, onmousedownW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEDOWN,
201 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
202 {mousemoveW, onmousemoveW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEMOVE,
203 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
204 {mouseoutW, onmouseoutW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEOUT,
205 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
206 {mouseoverW, onmouseoverW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEOVER,
207 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
208 {mouseupW, onmouseupW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEUP,
209 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
210 {pasteW, onpasteW, EVENTT_NONE, DISPID_EVMETH_ONPASTE,
211 EVENT_CANCELABLE},
212 {readystatechangeW, onreadystatechangeW, EVENTT_NONE, DISPID_EVMETH_ONREADYSTATECHANGE,
213 0},
214 {resizeW, onresizeW, EVENTT_NONE, DISPID_EVMETH_ONRESIZE,
215 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
216 {scrollW, onscrollW, EVENTT_HTML, DISPID_EVMETH_ONSCROLL,
217 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
218 {selectstartW, onselectstartW, EVENTT_MOUSE, DISPID_EVMETH_ONSELECTSTART,
219 EVENT_CANCELABLE},
220 {submitW, onsubmitW, EVENTT_HTML, DISPID_EVMETH_ONSUBMIT,
221 EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE}
222 };
223
224 static const eventid_t node_handled_list[] = { EVENTID_ABORT, EVENTID_ERROR, EVENTID_LOAD };
225
226 eventid_t str_to_eid(LPCWSTR str)
227 {
228 int i;
229
230 for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
231 if(!strcmpW(event_info[i].name, str))
232 return i;
233 }
234
235 ERR("unknown type %s\n", debugstr_w(str));
236 return EVENTID_LAST;
237 }
238
239 static eventid_t attr_to_eid(LPCWSTR str)
240 {
241 int i;
242
243 for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
244 if(!strcmpW(event_info[i].attr_name, str))
245 return i;
246 }
247
248 return EVENTID_LAST;
249 }
250
251 static DWORD get_node_handler_mask(eventid_t eid)
252 {
253 DWORD i;
254
255 for(i=0; i<sizeof(node_handled_list)/sizeof(*node_handled_list); i++) {
256 if(node_handled_list[i] == eid)
257 return 1 << i;
258 }
259
260 ERR("Invalid eid %d\n", eid);
261 return ~0;
262 }
263
264 typedef struct {
265 DispatchEx dispex;
266 IHTMLEventObj IHTMLEventObj_iface;
267
268 LONG ref;
269
270 HTMLDOMNode *target;
271 const event_info_t *type;
272 nsIDOMEvent *nsevent;
273 BOOL prevent_default;
274 BOOL cancel_bubble;
275 } HTMLEventObj;
276
277 static inline HTMLEventObj *impl_from_IHTMLEventObj(IHTMLEventObj *iface)
278 {
279 return CONTAINING_RECORD(iface, HTMLEventObj, IHTMLEventObj_iface);
280 }
281
282 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
283 {
284 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
285
286 *ppv = NULL;
287
288 if(IsEqualGUID(&IID_IUnknown, riid)) {
289 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
290 *ppv = &This->IHTMLEventObj_iface;
291 }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) {
292 TRACE("(%p)->(IID_IHTMLEventObj %p)\n", This, ppv);
293 *ppv = &This->IHTMLEventObj_iface;
294 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
295 return *ppv ? S_OK : E_NOINTERFACE;
296 }
297
298 if(*ppv) {
299 IUnknown_AddRef((IUnknown*)*ppv);
300 return S_OK;
301 }
302
303 WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
304 return E_NOINTERFACE;
305 }
306
307 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
308 {
309 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
310 LONG ref = InterlockedIncrement(&This->ref);
311
312 TRACE("(%p) ref=%d\n", This, ref);
313
314 return ref;
315 }
316
317 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
318 {
319 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
320 LONG ref = InterlockedDecrement(&This->ref);
321
322 TRACE("(%p) ref=%d\n", This, ref);
323
324 if(!ref) {
325 if(This->target)
326 IHTMLDOMNode_Release(&This->target->IHTMLDOMNode_iface);
327 if(This->nsevent)
328 nsIDOMEvent_Release(This->nsevent);
329 release_dispex(&This->dispex);
330 heap_free(This);
331 }
332
333 return ref;
334 }
335
336 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
337 {
338 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
339 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
340 }
341
342 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
343 LCID lcid, ITypeInfo **ppTInfo)
344 {
345 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
346 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
347 }
348
349 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
350 LPOLESTR *rgszNames, UINT cNames,
351 LCID lcid, DISPID *rgDispId)
352 {
353 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
354 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
355 lcid, rgDispId);
356 }
357
358 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
359 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
360 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
361 {
362 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
363 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
364 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
365 }
366
367 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
368 {
369 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
370
371 TRACE("(%p)->(%p)\n", This, p);
372
373 *p = NULL;
374 if(This->target)
375 IHTMLDOMNode_QueryInterface(&This->target->IHTMLDOMNode_iface, &IID_IHTMLElement, (void**)p);
376 return S_OK;
377 }
378
379 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
380 {
381 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
382 cpp_bool ret = FALSE;
383
384 TRACE("(%p)->(%p)\n", This, p);
385
386 if(This->nsevent) {
387 nsIDOMKeyEvent *key_event;
388 nsresult nsres;
389
390 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
391 if(NS_SUCCEEDED(nsres)) {
392 nsIDOMKeyEvent_GetAltKey(key_event, &ret);
393 nsIDOMKeyEvent_Release(key_event);
394 }else {
395 nsIDOMMouseEvent *mouse_event;
396
397 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
398 if(NS_SUCCEEDED(nsres)) {
399 nsIDOMMouseEvent_GetAltKey(mouse_event, &ret);
400 nsIDOMMouseEvent_Release(mouse_event);
401 }
402 }
403 }
404
405 *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
406 return S_OK;
407 }
408
409 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
410 {
411 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
412 cpp_bool ret = FALSE;
413
414 TRACE("(%p)->(%p)\n", This, p);
415
416 if(This->nsevent) {
417 nsIDOMKeyEvent *key_event;
418 nsresult nsres;
419
420 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
421 if(NS_SUCCEEDED(nsres)) {
422 nsIDOMKeyEvent_GetCtrlKey(key_event, &ret);
423 nsIDOMKeyEvent_Release(key_event);
424 }else {
425 nsIDOMMouseEvent *mouse_event;
426
427 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
428 if(NS_SUCCEEDED(nsres)) {
429 nsIDOMMouseEvent_GetCtrlKey(mouse_event, &ret);
430 nsIDOMMouseEvent_Release(mouse_event);
431 }
432 }
433 }
434
435 *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
436 return S_OK;
437 }
438
439 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
440 {
441 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
442 cpp_bool ret = FALSE;
443
444 TRACE("(%p)->(%p)\n", This, p);
445
446 if(This->nsevent) {
447 nsIDOMKeyEvent *key_event;
448 nsresult nsres;
449
450 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
451 if(NS_SUCCEEDED(nsres)) {
452 nsIDOMKeyEvent_GetShiftKey(key_event, &ret);
453 nsIDOMKeyEvent_Release(key_event);
454 }else {
455 nsIDOMMouseEvent *mouse_event;
456
457 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
458 if(NS_SUCCEEDED(nsres)) {
459 nsIDOMMouseEvent_GetShiftKey(mouse_event, &ret);
460 nsIDOMMouseEvent_Release(mouse_event);
461 }
462 }
463 }
464
465 *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
466 return S_OK;
467 }
468
469 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
470 {
471 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
472
473 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
474
475 if(V_VT(&v) != VT_BOOL) {
476 FIXME("unsupported value %s\n", debugstr_variant(&v));
477 return DISP_E_BADVARTYPE;
478 }
479
480 if(!V_BOOL(&v))
481 This->prevent_default = TRUE;
482 return S_OK;
483 }
484
485 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
486 {
487 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
488
489 FIXME("(%p)->(%p)\n", This, p);
490
491 V_VT(p) = VT_EMPTY;
492 return S_OK;
493 }
494
495 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
496 {
497 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
498
499 TRACE("(%p)->(%x)\n", This, v);
500
501 This->cancel_bubble = !!v;
502 return S_OK;
503 }
504
505 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
506 {
507 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
508
509 TRACE("(%p)->(%p)\n", This, p);
510
511 *p = This->cancel_bubble ? VARIANT_TRUE : VARIANT_FALSE;
512 return S_OK;
513 }
514
515 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
516 {
517 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
518
519 FIXME("(%p)->(%p)\n", This, p);
520
521 *p = NULL;
522 return S_OK;
523 }
524
525 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
526 {
527 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
528
529 FIXME("(%p)->(%p)\n", This, p);
530
531 *p = NULL;
532 return S_OK;
533 }
534
535 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
536 {
537 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
538 FIXME("(%p)->(%d)\n", This, v);
539 return E_NOTIMPL;
540 }
541
542 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
543 {
544 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
545 UINT32 key_code = 0;
546
547 TRACE("(%p)->(%p)\n", This, p);
548
549 if(This->nsevent) {
550 nsIDOMKeyEvent *key_event;
551 nsresult nsres;
552
553 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
554 if(NS_SUCCEEDED(nsres)) {
555 nsIDOMKeyEvent_GetKeyCode(key_event, &key_code);
556 nsIDOMKeyEvent_Release(key_event);
557 }
558 }
559
560 *p = key_code;
561 return S_OK;
562 }
563
564 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
565 {
566 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
567 UINT16 button = 0;
568
569 TRACE("(%p)->(%p)\n", This, p);
570
571 if(This->nsevent) {
572 nsIDOMMouseEvent *mouse_event;
573 nsresult nsres;
574
575 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
576 if(NS_SUCCEEDED(nsres)) {
577 nsIDOMMouseEvent_GetButton(mouse_event, &button);
578 nsIDOMMouseEvent_Release(mouse_event);
579 }
580 }
581
582 *p = button;
583 return S_OK;
584 }
585
586 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
587 {
588 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
589
590 TRACE("(%p)->(%p)\n", This, p);
591
592 if(!This->type) {
593 *p = NULL;
594 return S_OK;
595 }
596
597 *p = SysAllocString(This->type->name);
598 return *p ? S_OK : E_OUTOFMEMORY;
599 }
600
601 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
602 {
603 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
604
605 FIXME("(%p)->(%p)\n", This, p);
606
607 *p = NULL;
608 return S_OK;
609 }
610
611 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
612 {
613 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
614
615 FIXME("(%p)->(%p)\n", This, p);
616
617 *p = 0;
618 return S_OK;
619 }
620
621 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
622 {
623 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
624
625 FIXME("(%p)->(%p)\n", This, p);
626
627 *p = -1;
628 return S_OK;
629 }
630
631 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
632 {
633 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
634
635 FIXME("(%p)->(%p)\n", This, p);
636
637 *p = -1;
638 return S_OK;
639 }
640
641 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
642 {
643 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
644 LONG x = 0;
645
646 TRACE("(%p)->(%p)\n", This, p);
647
648 if(This->nsevent) {
649 nsIDOMMouseEvent *mouse_event;
650 nsresult nsres;
651
652 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
653 if(NS_SUCCEEDED(nsres)) {
654 nsIDOMMouseEvent_GetClientX(mouse_event, &x);
655 nsIDOMMouseEvent_Release(mouse_event);
656 }
657 }
658
659 *p = x;
660 return S_OK;
661 }
662
663 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
664 {
665 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
666 LONG y = 0;
667
668 TRACE("(%p)->(%p)\n", This, p);
669
670 if(This->nsevent) {
671 nsIDOMMouseEvent *mouse_event;
672 nsresult nsres;
673
674 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
675 if(NS_SUCCEEDED(nsres)) {
676 nsIDOMMouseEvent_GetClientY(mouse_event, &y);
677 nsIDOMMouseEvent_Release(mouse_event);
678 }
679 }
680
681 *p = y;
682 return S_OK;
683 }
684
685 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
686 {
687 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
688
689 FIXME("(%p)->(%p)\n", This, p);
690
691 *p = 0;
692 return S_OK;
693 }
694
695 static HRESULT WINAPI HTMLEventObj_get_offsetY(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_screenX(IHTMLEventObj *iface, LONG *p)
706 {
707 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
708 LONG x = 0;
709
710 TRACE("(%p)->(%p)\n", This, p);
711
712 if(This->nsevent) {
713 nsIDOMMouseEvent *mouse_event;
714 nsresult nsres;
715
716 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
717 if(NS_SUCCEEDED(nsres)) {
718 nsIDOMMouseEvent_GetScreenX(mouse_event, &x);
719 nsIDOMMouseEvent_Release(mouse_event);
720 }
721 }
722
723 *p = x;
724 return S_OK;
725 }
726
727 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
728 {
729 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
730 LONG y = 0;
731
732 TRACE("(%p)->(%p)\n", This, p);
733
734 if(This->nsevent) {
735 nsIDOMMouseEvent *mouse_event;
736 nsresult nsres;
737
738 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
739 if(NS_SUCCEEDED(nsres)) {
740 nsIDOMMouseEvent_GetScreenY(mouse_event, &y);
741 nsIDOMMouseEvent_Release(mouse_event);
742 }
743 }
744
745 *p = y;
746 return S_OK;
747 }
748
749 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
750 {
751 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
752
753 FIXME("(%p)->(%p)\n", This, p);
754
755 *p = NULL;
756 return S_OK;
757 }
758
759 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
760 HTMLEventObj_QueryInterface,
761 HTMLEventObj_AddRef,
762 HTMLEventObj_Release,
763 HTMLEventObj_GetTypeInfoCount,
764 HTMLEventObj_GetTypeInfo,
765 HTMLEventObj_GetIDsOfNames,
766 HTMLEventObj_Invoke,
767 HTMLEventObj_get_srcElement,
768 HTMLEventObj_get_altKey,
769 HTMLEventObj_get_ctrlKey,
770 HTMLEventObj_get_shiftKey,
771 HTMLEventObj_put_returnValue,
772 HTMLEventObj_get_returnValue,
773 HTMLEventObj_put_cancelBubble,
774 HTMLEventObj_get_cancelBubble,
775 HTMLEventObj_get_fromElement,
776 HTMLEventObj_get_toElement,
777 HTMLEventObj_put_keyCode,
778 HTMLEventObj_get_keyCode,
779 HTMLEventObj_get_button,
780 HTMLEventObj_get_type,
781 HTMLEventObj_get_qualifier,
782 HTMLEventObj_get_reason,
783 HTMLEventObj_get_x,
784 HTMLEventObj_get_y,
785 HTMLEventObj_get_clientX,
786 HTMLEventObj_get_clientY,
787 HTMLEventObj_get_offsetX,
788 HTMLEventObj_get_offsetY,
789 HTMLEventObj_get_screenX,
790 HTMLEventObj_get_screenY,
791 HTMLEventObj_get_srcFilter
792 };
793
794 static inline HTMLEventObj *unsafe_impl_from_IHTMLEventObj(IHTMLEventObj *iface)
795 {
796 return iface->lpVtbl == &HTMLEventObjVtbl ? impl_from_IHTMLEventObj(iface) : NULL;
797 }
798
799 static const tid_t HTMLEventObj_iface_tids[] = {
800 IHTMLEventObj_tid,
801 0
802 };
803
804 static dispex_static_data_t HTMLEventObj_dispex = {
805 NULL,
806 DispCEventObj_tid,
807 NULL,
808 HTMLEventObj_iface_tids
809 };
810
811 static HTMLEventObj *create_event(void)
812 {
813 HTMLEventObj *ret;
814
815 ret = heap_alloc_zero(sizeof(*ret));
816 if(!ret)
817 return NULL;
818
819 ret->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl;
820 ret->ref = 1;
821
822 init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLEventObj_iface, &HTMLEventObj_dispex);
823
824 return ret;
825 }
826
827 static HRESULT set_event_info(HTMLEventObj *event, HTMLDOMNode *target, eventid_t eid, nsIDOMEvent *nsevent)
828 {
829 event->type = event_info+eid;
830 event->nsevent = nsevent;
831
832 if(nsevent) {
833 nsIDOMEvent_AddRef(nsevent);
834 }else if(event_types[event_info[eid].type]) {
835 nsAString type_str;
836 nsresult nsres;
837
838 nsAString_InitDepend(&type_str, event_types[event_info[eid].type]);
839 nsres = nsIDOMHTMLDocument_CreateEvent(target->doc->nsdoc, &type_str, &event->nsevent);
840 nsAString_Finish(&type_str);
841 if(NS_FAILED(nsres)) {
842 ERR("Could not create event: %08x\n", nsres);
843 return E_FAIL;
844 }
845 }
846
847 event->target = target;
848 if(target)
849 IHTMLDOMNode_AddRef(&target->IHTMLDOMNode_iface);
850 return S_OK;
851 }
852
853 HRESULT create_event_obj(IHTMLEventObj **ret)
854 {
855 HTMLEventObj *event;
856
857 event = create_event();
858 if(!event)
859 return E_OUTOFMEMORY;
860
861 *ret = &event->IHTMLEventObj_iface;
862 return S_OK;
863 }
864
865 static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv)
866 {
867 IDispatchEx *dispex;
868 EXCEPINFO ei;
869 HRESULT hres;
870
871 memset(&ei, 0, sizeof(ei));
872
873 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
874 if(SUCCEEDED(hres)) {
875 hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL);
876 IDispatchEx_Release(dispex);
877 }else {
878 TRACE("Could not get IDispatchEx interface: %08x\n", hres);
879 hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,
880 dp, retv, &ei, NULL);
881 }
882
883 return hres;
884 }
885
886 static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, HTMLEventObj *event_obj, VARIANT *retv)
887 {
888 DISPPARAMS dp = {NULL,NULL,0,0};
889 VARIANT event_arg;
890 ULONG argerr;
891 EXCEPINFO ei;
892
893 if(event_obj) {
894 V_VT(&event_arg) = VT_DISPATCH;
895 V_DISPATCH(&event_arg) = (IDispatch*)&event_obj->IHTMLEventObj_iface;
896 dp.rgvarg = &event_arg;
897 dp.cArgs = 1;
898 }
899
900 memset(&ei, 0, sizeof(ei));
901 return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr);
902 }
903
904 static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid)
905 {
906 int min, max, i;
907 HRESULT hres;
908
909 if(!data)
910 return FALSE;
911
912 if(!data->ids) {
913 hres = get_dispids(data->tid, &data->id_cnt, &data->ids);
914 if(FAILED(hres))
915 return FALSE;
916 }
917
918 min = 0;
919 max = data->id_cnt-1;
920 while(min <= max) {
921 i = (min+max)/2;
922 if(data->ids[i] == dispid)
923 return TRUE;
924
925 if(data->ids[i] < dispid)
926 min = i+1;
927 else
928 max = i-1;
929 }
930
931 return FALSE;
932 }
933
934 static void call_event_handlers(HTMLDocumentNode *doc, HTMLEventObj *event_obj, event_target_t *event_target,
935 ConnectionPointContainer *cp_container, eventid_t eid, IDispatch *this_obj)
936 {
937 const BOOL cancelable = event_info[eid].flags & EVENT_CANCELABLE;
938 handler_vector_t *handler_vector = NULL;
939 VARIANT v;
940 HRESULT hres;
941
942 if(event_target)
943 handler_vector = event_target->event_table[eid];
944
945 if(handler_vector && handler_vector->handler_prop) {
946 DISPID named_arg = DISPID_THIS;
947 VARIANTARG arg;
948 DISPPARAMS dp = {&arg, &named_arg, 1, 1};
949
950 V_VT(&arg) = VT_DISPATCH;
951 V_DISPATCH(&arg) = this_obj;
952 V_VT(&v) = VT_EMPTY;
953
954 TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
955 hres = call_disp_func(handler_vector->handler_prop, &dp, &v);
956 if(hres == S_OK) {
957 TRACE("%s <<< %s\n", debugstr_w(event_info[eid].name), debugstr_variant(&v));
958
959 if(cancelable) {
960 if(V_VT(&v) == VT_BOOL) {
961 if(!V_BOOL(&v))
962 event_obj->prevent_default = TRUE;
963 }else if(V_VT(&v) != VT_EMPTY) {
964 FIXME("unhandled result %s\n", debugstr_variant(&v));
965 }
966 }
967 VariantClear(&v);
968 }else {
969 WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
970 }
971 }
972
973 if(handler_vector && handler_vector->handler_cnt) {
974 VARIANTARG arg;
975 DISPPARAMS dp = {&arg, NULL, 1, 0};
976 int i;
977
978 V_VT(&arg) = VT_DISPATCH;
979 V_DISPATCH(&arg) = (IDispatch*)event_obj;
980
981 i = handler_vector->handler_cnt;
982 while(i--) {
983 if(handler_vector->handlers[i]) {
984 V_VT(&v) = VT_EMPTY;
985
986 TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
987 hres = call_disp_func(handler_vector->handlers[i], &dp, &v);
988 if(hres == S_OK) {
989 TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
990
991 if(cancelable) {
992 if(V_VT(&v) == VT_BOOL) {
993 if(!V_BOOL(&v))
994 event_obj->prevent_default = TRUE;
995 }else if(V_VT(&v) != VT_EMPTY) {
996 FIXME("unhandled result %s\n", debugstr_variant(&v));
997 }
998 }
999 VariantClear(&v);
1000 }else {
1001 WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
1002 }
1003 }
1004 }
1005 }
1006
1007 /*
1008 * NOTE: CP events may require doc_obj reference, which we don't own. We make sure that
1009 * it's safe to call event handler by checking nsevent_listener, which is NULL for
1010 * detached documents.
1011 */
1012 if(cp_container && cp_container->forward_container)
1013 cp_container = cp_container->forward_container;
1014 if(cp_container && cp_container->cps && doc->nsevent_listener) {
1015 ConnectionPoint *cp;
1016 unsigned i, j;
1017
1018 for(j=0; cp_container->cp_entries[j].riid; j++) {
1019 cp = cp_container->cps + j;
1020 if(!cp->sinks_size || !is_cp_event(cp->data, event_info[eid].dispid))
1021 continue;
1022
1023 for(i=0; doc->nsevent_listener && i < cp->sinks_size; i++) {
1024 if(!cp->sinks[i].disp)
1025 continue;
1026
1027 V_VT(&v) = VT_EMPTY;
1028
1029 TRACE("cp %s [%u] >>>\n", debugstr_w(event_info[eid].name), i);
1030 hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid,
1031 cp->data->pass_event_arg ? event_obj : NULL, &v);
1032 if(hres == S_OK) {
1033 TRACE("cp %s [%u] <<<\n", debugstr_w(event_info[eid].name), i);
1034
1035 if(cancelable) {
1036 if(V_VT(&v) == VT_BOOL) {
1037 if(!V_BOOL(&v))
1038 event_obj->prevent_default = TRUE;
1039 }else if(V_VT(&v) != VT_EMPTY) {
1040 FIXME("unhandled result %s\n", debugstr_variant(&v));
1041 }
1042 }
1043 VariantClear(&v);
1044 }else {
1045 WARN("cp %s [%u] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
1046 }
1047 }
1048
1049 if(!doc->nsevent_listener)
1050 break;
1051 }
1052 }
1053 }
1054
1055 static void fire_event_obj(HTMLDocumentNode *doc, eventid_t eid, HTMLEventObj *event_obj,
1056 nsIDOMNode *target, IDispatch *script_this)
1057 {
1058 IHTMLEventObj *prev_event;
1059 nsIDOMNode *parent, *nsnode;
1060 BOOL prevent_default = FALSE;
1061 HTMLInnerWindow *window;
1062 HTMLDOMNode *node;
1063 UINT16 node_type;
1064 nsresult nsres;
1065 HRESULT hres;
1066
1067 TRACE("(%p) %s\n", doc, debugstr_w(event_info[eid].name));
1068
1069 window = doc->window;
1070 if(!window) {
1071 WARN("NULL window\n");
1072 return;
1073 }
1074
1075 htmldoc_addref(&doc->basedoc);
1076
1077 prev_event = window->event;
1078 window->event = event_obj ? &event_obj->IHTMLEventObj_iface : NULL;
1079
1080 nsIDOMNode_GetNodeType(target, &node_type);
1081 nsnode = target;
1082 nsIDOMNode_AddRef(nsnode);
1083
1084 switch(node_type) {
1085 case ELEMENT_NODE:
1086 do {
1087 hres = get_node(doc, nsnode, FALSE, &node);
1088 if(SUCCEEDED(hres) && node) {
1089 call_event_handlers(doc, event_obj, *get_node_event_target(node),
1090 node->cp_container, eid, script_this ? script_this : (IDispatch*)&node->IHTMLDOMNode_iface);
1091 node_release(node);
1092 }
1093
1094 if(!(event_info[eid].flags & EVENT_BUBBLE) || (event_obj && event_obj->cancel_bubble))
1095 break;
1096
1097 nsIDOMNode_GetParentNode(nsnode, &parent);
1098 nsIDOMNode_Release(nsnode);
1099 nsnode = parent;
1100 if(!nsnode)
1101 break;
1102
1103 nsIDOMNode_GetNodeType(nsnode, &node_type);
1104 }while(node_type == ELEMENT_NODE);
1105
1106 if(!(event_info[eid].flags & EVENT_BUBBLE) || (event_obj && event_obj->cancel_bubble))
1107 break;
1108
1109 case DOCUMENT_NODE:
1110 if(event_info[eid].flags & EVENT_FORWARDBODY) {
1111 nsIDOMHTMLElement *nsbody;
1112 nsresult nsres;
1113
1114 nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
1115 if(NS_SUCCEEDED(nsres) && nsbody) {
1116 hres = get_node(doc, (nsIDOMNode*)nsbody, FALSE, &node);
1117 if(SUCCEEDED(hres) && node) {
1118 call_event_handlers(doc, event_obj, *get_node_event_target(node),
1119 node->cp_container, eid, script_this ? script_this : (IDispatch*)&node->IHTMLDOMNode_iface);
1120 node_release(node);
1121 }
1122 nsIDOMHTMLElement_Release(nsbody);
1123 }else {
1124 ERR("Could not get body: %08x\n", nsres);
1125 }
1126 }
1127
1128 call_event_handlers(doc, event_obj, doc->node.event_target, &doc->basedoc.cp_container, eid,
1129 script_this ? script_this : (IDispatch*)&doc->basedoc.IHTMLDocument2_iface);
1130 break;
1131
1132 default:
1133 FIXME("unimplemented node type %d\n", node_type);
1134 }
1135
1136 if(nsnode)
1137 nsIDOMNode_Release(nsnode);
1138
1139 if(event_obj && event_obj->prevent_default)
1140 prevent_default = TRUE;
1141 window->event = prev_event;
1142
1143 if(!prevent_default && (event_info[eid].flags & EVENT_HASDEFAULTHANDLERS)) {
1144 nsIDOMNode_AddRef(target);
1145 nsnode = target;
1146
1147 do {
1148 hres = get_node(doc, nsnode, TRUE, &node);
1149 if(FAILED(hres))
1150 break;
1151
1152 if(node) {
1153 if(node->vtbl->handle_event)
1154 hres = node->vtbl->handle_event(node, eid, event_obj ? event_obj->nsevent : NULL, &prevent_default);
1155 node_release(node);
1156 if(FAILED(hres) || prevent_default || (event_obj && event_obj->cancel_bubble))
1157 break;
1158 }
1159
1160 nsres = nsIDOMNode_GetParentNode(nsnode, &parent);
1161 if(NS_FAILED(nsres))
1162 break;
1163
1164 nsIDOMNode_Release(nsnode);
1165 nsnode = parent;
1166 } while(nsnode);
1167
1168 if(nsnode)
1169 nsIDOMNode_Release(nsnode);
1170 }
1171
1172 if(prevent_default && event_obj && event_obj->nsevent) {
1173 TRACE("calling PreventDefault\n");
1174 nsIDOMEvent_PreventDefault(event_obj->nsevent);
1175 }
1176
1177 htmldoc_release(&doc->basedoc);
1178 }
1179
1180 void fire_event(HTMLDocumentNode *doc, eventid_t eid, BOOL set_event, nsIDOMNode *target, nsIDOMEvent *nsevent,
1181 IDispatch *script_this)
1182 {
1183 HTMLEventObj *event_obj = NULL;
1184 HTMLDOMNode *node;
1185 HRESULT hres;
1186
1187 if(set_event) {
1188 hres = get_node(doc, target, TRUE, &node);
1189 if(FAILED(hres))
1190 return;
1191
1192 event_obj = create_event();
1193 node_release(node);
1194 if(!event_obj)
1195 return;
1196
1197 hres = set_event_info(event_obj, node, eid, nsevent);
1198 if(FAILED(hres)) {
1199 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
1200 return;
1201 }
1202 }
1203
1204 fire_event_obj(doc, eid, event_obj, target, script_this);
1205
1206 if(event_obj)
1207 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
1208 }
1209
1210 HRESULT dispatch_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_var, VARIANT_BOOL *cancelled)
1211 {
1212 HTMLEventObj *event_obj = NULL;
1213 eventid_t eid;
1214 HRESULT hres;
1215
1216 eid = attr_to_eid(event_name);
1217 if(eid == EVENTID_LAST) {
1218 WARN("unknown event %s\n", debugstr_w(event_name));
1219 return E_INVALIDARG;
1220 }
1221
1222 if(event_var && V_VT(event_var) != VT_EMPTY && V_VT(event_var) != VT_ERROR) {
1223 if(V_VT(event_var) != VT_DISPATCH) {
1224 FIXME("event_var %s not supported\n", debugstr_variant(event_var));
1225 return E_NOTIMPL;
1226 }
1227
1228 if(V_DISPATCH(event_var)) {
1229 IHTMLEventObj *event_iface;
1230
1231 hres = IDispatch_QueryInterface(V_DISPATCH(event_var), &IID_IHTMLEventObj, (void**)&event_iface);
1232 if(FAILED(hres)) {
1233 FIXME("No IHTMLEventObj iface\n");
1234 return hres;
1235 }
1236
1237 event_obj = unsafe_impl_from_IHTMLEventObj(event_iface);
1238 if(!event_obj) {
1239 ERR("Not our IHTMLEventObj?\n");
1240 IHTMLEventObj_Release(event_iface);
1241 return E_FAIL;
1242 }
1243 }
1244 }
1245
1246 if(event_obj) {
1247 hres = set_event_info(event_obj, node, eid, NULL);
1248 if(SUCCEEDED(hres))
1249 fire_event_obj(node->doc, eid, event_obj, node->nsnode, NULL);
1250
1251 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
1252 if(FAILED(hres))
1253 return hres;
1254 }else {
1255 if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
1256 FIXME("not EVENT_DEFAULTEVENTHANDLER\n");
1257 return E_NOTIMPL;
1258 }
1259
1260 fire_event(node->doc, eid, TRUE, node->nsnode, NULL, NULL);
1261 }
1262
1263 *cancelled = VARIANT_TRUE; /* FIXME */
1264 return S_OK;
1265 }
1266
1267 HRESULT call_fire_event(HTMLDOMNode *node, eventid_t eid)
1268 {
1269 HRESULT hres;
1270
1271 if(node->vtbl->fire_event) {
1272 BOOL handled = FALSE;
1273
1274 hres = node->vtbl->fire_event(node, eid, &handled);
1275 if(handled)
1276 return hres;
1277 }
1278
1279 fire_event(node->doc, eid, TRUE, node->nsnode, NULL, NULL);
1280 return S_OK;
1281 }
1282
1283 static inline event_target_t *get_event_target(event_target_t **event_target_ptr)
1284 {
1285 if(!*event_target_ptr)
1286 *event_target_ptr = heap_alloc_zero(sizeof(event_target_t));
1287 return *event_target_ptr;
1288 }
1289
1290 static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt)
1291 {
1292 handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid];
1293
1294 if(handler_vector) {
1295 if(cnt <= handler_vector->handler_cnt)
1296 return TRUE;
1297
1298 new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1299 }else {
1300 new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1301 }
1302
1303 if(!new_vector)
1304 return FALSE;
1305
1306 new_vector->handler_cnt = cnt;
1307 event_target->event_table[eid] = new_vector;
1308 return TRUE;
1309 }
1310
1311 static HRESULT ensure_nsevent_handler(HTMLDocumentNode *doc, event_target_t *event_target, nsIDOMNode *nsnode, eventid_t eid)
1312 {
1313 if(!doc->nsdoc)
1314 return S_OK;
1315
1316 if(event_info[eid].flags & EVENT_NODEHANDLER) {
1317 DWORD mask;
1318
1319 mask = get_node_handler_mask(eid);
1320 if(event_target->node_handlers_mask & mask)
1321 return S_OK;
1322
1323 add_nsevent_listener(doc, nsnode, event_info[eid].name);
1324 event_target->node_handlers_mask |= mask;
1325 return S_OK;
1326 }
1327
1328 if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER))
1329 return S_OK;
1330
1331 if(!doc->event_vector[eid]) {
1332 doc->event_vector[eid] = TRUE;
1333 add_nsevent_listener(doc, NULL, event_info[eid].name);
1334 }
1335
1336 return S_OK;
1337 }
1338
1339 void detach_events(HTMLDocumentNode *doc)
1340 {
1341 if(doc->event_vector) {
1342 int i;
1343
1344 for(i=0; i < EVENTID_LAST; i++) {
1345 if(doc->event_vector[i]) {
1346 detach_nsevent(doc, event_info[i].name);
1347 doc->event_vector[i] = FALSE;
1348 }
1349 }
1350 }
1351
1352 release_nsevents(doc);
1353 }
1354
1355
1356 static HRESULT remove_event_handler(event_target_t **event_target, eventid_t eid)
1357 {
1358 if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1359 IDispatch_Release((*event_target)->event_table[eid]->handler_prop);
1360 (*event_target)->event_table[eid]->handler_prop = NULL;
1361 }
1362
1363 return S_OK;
1364 }
1365
1366 static HRESULT set_event_handler_disp(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocumentNode *doc,
1367 eventid_t eid, IDispatch *disp)
1368 {
1369 event_target_t *event_target;
1370
1371 if(!disp)
1372 return remove_event_handler(event_target_ptr, eid);
1373
1374 event_target = get_event_target(event_target_ptr);
1375 if(!event_target)
1376 return E_OUTOFMEMORY;
1377
1378 if(!alloc_handler_vector(event_target, eid, 0))
1379 return E_OUTOFMEMORY;
1380
1381 if(event_target->event_table[eid]->handler_prop)
1382 IDispatch_Release(event_target->event_table[eid]->handler_prop);
1383
1384 event_target->event_table[eid]->handler_prop = disp;
1385 IDispatch_AddRef(disp);
1386
1387 return ensure_nsevent_handler(doc, event_target, nsnode, eid);
1388 }
1389
1390 HRESULT set_event_handler(event_target_t **event_target, nsIDOMNode *nsnode, HTMLDocumentNode *doc, eventid_t eid, VARIANT *var)
1391 {
1392 switch(V_VT(var)) {
1393 case VT_NULL:
1394 return remove_event_handler(event_target, eid);
1395
1396 case VT_DISPATCH:
1397 return set_event_handler_disp(event_target, nsnode, doc, eid, V_DISPATCH(var));
1398
1399 default:
1400 FIXME("not handler %s\n", debugstr_variant(var));
1401 /* fall through */
1402 case VT_EMPTY:
1403 return E_NOTIMPL;
1404 }
1405
1406 return S_OK;
1407 }
1408
1409 HRESULT get_event_handler(event_target_t **event_target, eventid_t eid, VARIANT *var)
1410 {
1411 if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1412 V_VT(var) = VT_DISPATCH;
1413 V_DISPATCH(var) = (*event_target)->event_table[eid]->handler_prop;
1414 IDispatch_AddRef(V_DISPATCH(var));
1415 }else {
1416 V_VT(var) = VT_NULL;
1417 }
1418
1419 return S_OK;
1420 }
1421
1422 HRESULT attach_event(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocument *doc, BSTR name,
1423 IDispatch *disp, VARIANT_BOOL *res)
1424 {
1425 event_target_t *event_target;
1426 eventid_t eid;
1427 DWORD i = 0;
1428
1429 eid = attr_to_eid(name);
1430 if(eid == EVENTID_LAST) {
1431 WARN("Unknown event\n");
1432 *res = VARIANT_TRUE;
1433 return S_OK;
1434 }
1435
1436 event_target = get_event_target(event_target_ptr);
1437 if(!event_target)
1438 return E_OUTOFMEMORY;
1439
1440 if(event_target->event_table[eid]) {
1441 while(i < event_target->event_table[eid]->handler_cnt && event_target->event_table[eid]->handlers[i])
1442 i++;
1443 if(i == event_target->event_table[eid]->handler_cnt && !alloc_handler_vector(event_target, eid, i+1))
1444 return E_OUTOFMEMORY;
1445 }else if(!alloc_handler_vector(event_target, eid, i+1)) {
1446 return E_OUTOFMEMORY;
1447 }
1448
1449 IDispatch_AddRef(disp);
1450 event_target->event_table[eid]->handlers[i] = disp;
1451
1452 *res = VARIANT_TRUE;
1453 return ensure_nsevent_handler(doc->doc_node, event_target, nsnode, eid);
1454 }
1455
1456 HRESULT detach_event(event_target_t *event_target, HTMLDocument *doc, BSTR name, IDispatch *disp)
1457 {
1458 eventid_t eid;
1459 DWORD i = 0;
1460
1461 if(!event_target)
1462 return S_OK;
1463
1464 eid = attr_to_eid(name);
1465 if(eid == EVENTID_LAST) {
1466 WARN("Unknown event\n");
1467 return S_OK;
1468 }
1469
1470 if(!event_target->event_table[eid])
1471 return S_OK;
1472
1473 while(i < event_target->event_table[eid]->handler_cnt) {
1474 if(event_target->event_table[eid]->handlers[i] == disp) {
1475 IDispatch_Release(event_target->event_table[eid]->handlers[i]);
1476 event_target->event_table[eid]->handlers[i] = NULL;
1477 }
1478 i++;
1479 }
1480
1481 return S_OK;
1482 }
1483
1484 void bind_elem_event(HTMLDocumentNode *doc, HTMLElement *elem, const WCHAR *event, IDispatch *disp)
1485 {
1486 eventid_t eid;
1487
1488 TRACE("(%p %p %s %p)\n", doc, elem, debugstr_w(event), disp);
1489
1490 eid = attr_to_eid(event);
1491 if(eid == EVENTID_LAST) {
1492 WARN("Unsupported event %s\n", debugstr_w(event));
1493 return;
1494 }
1495
1496 set_event_handler_disp(&elem->node.event_target, elem->node.nsnode, doc, eid, disp);
1497 }
1498
1499 void update_cp_events(HTMLInnerWindow *window, event_target_t **event_target_ptr, cp_static_data_t *cp, nsIDOMNode *nsnode)
1500 {
1501 event_target_t *event_target;
1502 int i;
1503
1504 event_target = get_event_target(event_target_ptr);
1505 if(!event_target)
1506 return; /* FIXME */
1507
1508 for(i=0; i < EVENTID_LAST; i++) {
1509 if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
1510 ensure_nsevent_handler(window->doc, event_target, nsnode, i);
1511 }
1512 }
1513
1514 void check_event_attr(HTMLDocumentNode *doc, nsIDOMElement *nselem)
1515 {
1516 const PRUnichar *attr_value;
1517 nsAString attr_name_str, attr_value_str;
1518 IDispatch *disp;
1519 HTMLDOMNode *node;
1520 int i;
1521 nsresult nsres;
1522 HRESULT hres;
1523
1524 nsAString_Init(&attr_value_str, NULL);
1525 nsAString_Init(&attr_name_str, NULL);
1526
1527 for(i=0; i < EVENTID_LAST; i++) {
1528 nsAString_SetData(&attr_name_str, event_info[i].attr_name);
1529 nsres = nsIDOMElement_GetAttribute(nselem, &attr_name_str, &attr_value_str);
1530 if(NS_SUCCEEDED(nsres)) {
1531 nsAString_GetData(&attr_value_str, &attr_value);
1532 if(!*attr_value)
1533 continue;
1534
1535 TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
1536
1537 disp = script_parse_event(doc->window, attr_value);
1538 if(disp) {
1539 hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
1540 if(SUCCEEDED(hres)) {
1541 set_event_handler_disp(get_node_event_target(node), node->nsnode, node->doc, i, disp);
1542 node_release(node);
1543 }
1544 IDispatch_Release(disp);
1545 }
1546 }
1547 }
1548
1549 nsAString_Finish(&attr_value_str);
1550 nsAString_Finish(&attr_name_str);
1551 }
1552
1553 HRESULT doc_init_events(HTMLDocumentNode *doc)
1554 {
1555 unsigned i;
1556 HRESULT hres;
1557
1558 doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
1559 if(!doc->event_vector)
1560 return E_OUTOFMEMORY;
1561
1562 init_nsevents(doc);
1563
1564 for(i=0; i < EVENTID_LAST; i++) {
1565 if(event_info[i].flags & EVENT_HASDEFAULTHANDLERS) {
1566 hres = ensure_nsevent_handler(doc, NULL, NULL, i);
1567 if(FAILED(hres))
1568 return hres;
1569 }
1570 }
1571
1572 return S_OK;
1573 }
1574
1575 void release_event_target(event_target_t *event_target)
1576 {
1577 int i;
1578 unsigned int j;
1579
1580 for(i=0; i < EVENTID_LAST; i++) {
1581 if(event_target->event_table[i]) {
1582 if(event_target->event_table[i]->handler_prop)
1583 IDispatch_Release(event_target->event_table[i]->handler_prop);
1584 for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
1585 if(event_target->event_table[i]->handlers[j])
1586 IDispatch_Release(event_target->event_table[i]->handlers[j]);
1587 }
1588 }
1589
1590 heap_free(event_target);
1591 }
Windows API implementation