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