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