?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qcap: Implement a stubbed SmartTee filter.
[wine/multimedia.git] / dlls / mshtml / htmlevent.c
blob254b86427677c8b5ebd07f3c9ee78339eb44c925
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 V_VT(p) = VT_EMPTY;
486 return VariantCopy(p, &This->return_value);
487 }
488
489 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
490 {
491 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
492
493 TRACE("(%p)->(%x)\n", This, v);
494
495 This->cancel_bubble = !!v;
496 return S_OK;
497 }
498
499 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
500 {
501 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
502
503 TRACE("(%p)->(%p)\n", This, p);
504
505 *p = This->cancel_bubble ? VARIANT_TRUE : VARIANT_FALSE;
506 return S_OK;
507 }
508
509 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
510 {
511 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
512
513 FIXME("(%p)->(%p)\n", This, p);
514
515 *p = NULL;
516 return S_OK;
517 }
518
519 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
520 {
521 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
522
523 FIXME("(%p)->(%p)\n", This, p);
524
525 *p = NULL;
526 return S_OK;
527 }
528
529 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
530 {
531 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
532 FIXME("(%p)->(%d)\n", This, v);
533 return E_NOTIMPL;
534 }
535
536 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
537 {
538 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
539 UINT32 key_code = 0;
540
541 TRACE("(%p)->(%p)\n", This, p);
542
543 if(This->nsevent) {
544 nsIDOMKeyEvent *key_event;
545 nsresult nsres;
546
547 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
548 if(NS_SUCCEEDED(nsres)) {
549 nsIDOMKeyEvent_GetKeyCode(key_event, &key_code);
550 nsIDOMKeyEvent_Release(key_event);
551 }
552 }
553
554 *p = key_code;
555 return S_OK;
556 }
557
558 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
559 {
560 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
561 INT16 button = 0;
562
563 TRACE("(%p)->(%p)\n", This, p);
564
565 if(This->nsevent) {
566 nsIDOMMouseEvent *mouse_event;
567 nsresult nsres;
568
569 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
570 if(NS_SUCCEEDED(nsres)) {
571 nsIDOMMouseEvent_GetButton(mouse_event, &button);
572 nsIDOMMouseEvent_Release(mouse_event);
573 }
574 }
575
576 *p = button;
577 return S_OK;
578 }
579
580 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
581 {
582 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
583
584 TRACE("(%p)->(%p)\n", This, p);
585
586 if(!This->type) {
587 *p = NULL;
588 return S_OK;
589 }
590
591 *p = SysAllocString(This->type->name);
592 return *p ? S_OK : E_OUTOFMEMORY;
593 }
594
595 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
596 {
597 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
598
599 FIXME("(%p)->(%p)\n", This, p);
600
601 *p = NULL;
602 return S_OK;
603 }
604
605 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
606 {
607 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
608
609 FIXME("(%p)->(%p)\n", This, p);
610
611 *p = 0;
612 return S_OK;
613 }
614
615 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
616 {
617 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
618 LONG x = 0;
619
620 TRACE("(%p)->(%p)\n", This, p);
621
622 if(This->nsevent) {
623 nsIDOMUIEvent *ui_event;
624 nsresult nsres;
625
626 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMUIEvent, (void**)&ui_event);
627 if(NS_SUCCEEDED(nsres)) {
628 /* NOTE: pageX is not exactly right here. */
629 nsres = nsIDOMUIEvent_GetPageX(ui_event, &x);
630 assert(nsres == NS_OK);
631 nsIDOMUIEvent_Release(ui_event);
632 }
633 }
634
635 *p = x;
636 return S_OK;
637 }
638
639 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
640 {
641 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
642 LONG y = 0;
643
644 TRACE("(%p)->(%p)\n", This, p);
645
646 if(This->nsevent) {
647 nsIDOMUIEvent *ui_event;
648 nsresult nsres;
649
650 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMUIEvent, (void**)&ui_event);
651 if(NS_SUCCEEDED(nsres)) {
652 /* NOTE: pageY is not exactly right here. */
653 nsres = nsIDOMUIEvent_GetPageY(ui_event, &y);
654 assert(nsres == NS_OK);
655 nsIDOMUIEvent_Release(ui_event);
656 }
657 }
658
659 *p = y;
660 return S_OK;
661 }
662
663 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
664 {
665 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
666 LONG x = 0;
667
668 TRACE("(%p)->(%p)\n", This, p);
669
670 if(This->nsevent) {
671 nsIDOMMouseEvent *mouse_event;
672 nsresult nsres;
673
674 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
675 if(NS_SUCCEEDED(nsres)) {
676 nsIDOMMouseEvent_GetClientX(mouse_event, &x);
677 nsIDOMMouseEvent_Release(mouse_event);
678 }
679 }
680
681 *p = x;
682 return S_OK;
683 }
684
685 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
686 {
687 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
688 LONG y = 0;
689
690 TRACE("(%p)->(%p)\n", This, p);
691
692 if(This->nsevent) {
693 nsIDOMMouseEvent *mouse_event;
694 nsresult nsres;
695
696 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
697 if(NS_SUCCEEDED(nsres)) {
698 nsIDOMMouseEvent_GetClientY(mouse_event, &y);
699 nsIDOMMouseEvent_Release(mouse_event);
700 }
701 }
702
703 *p = y;
704 return S_OK;
705 }
706
707 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
708 {
709 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
710
711 FIXME("(%p)->(%p)\n", This, p);
712
713 *p = 0;
714 return S_OK;
715 }
716
717 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p)
718 {
719 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
720
721 FIXME("(%p)->(%p)\n", This, p);
722
723 *p = 0;
724 return S_OK;
725 }
726
727 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p)
728 {
729 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
730 LONG x = 0;
731
732 TRACE("(%p)->(%p)\n", This, p);
733
734 if(This->nsevent) {
735 nsIDOMMouseEvent *mouse_event;
736 nsresult nsres;
737
738 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
739 if(NS_SUCCEEDED(nsres)) {
740 nsIDOMMouseEvent_GetScreenX(mouse_event, &x);
741 nsIDOMMouseEvent_Release(mouse_event);
742 }
743 }
744
745 *p = x;
746 return S_OK;
747 }
748
749 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
750 {
751 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
752 LONG y = 0;
753
754 TRACE("(%p)->(%p)\n", This, p);
755
756 if(This->nsevent) {
757 nsIDOMMouseEvent *mouse_event;
758 nsresult nsres;
759
760 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
761 if(NS_SUCCEEDED(nsres)) {
762 nsIDOMMouseEvent_GetScreenY(mouse_event, &y);
763 nsIDOMMouseEvent_Release(mouse_event);
764 }
765 }
766
767 *p = y;
768 return S_OK;
769 }
770
771 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
772 {
773 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
774
775 FIXME("(%p)->(%p)\n", This, p);
776
777 *p = NULL;
778 return S_OK;
779 }
780
781 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
782 HTMLEventObj_QueryInterface,
783 HTMLEventObj_AddRef,
784 HTMLEventObj_Release,
785 HTMLEventObj_GetTypeInfoCount,
786 HTMLEventObj_GetTypeInfo,
787 HTMLEventObj_GetIDsOfNames,
788 HTMLEventObj_Invoke,
789 HTMLEventObj_get_srcElement,
790 HTMLEventObj_get_altKey,
791 HTMLEventObj_get_ctrlKey,
792 HTMLEventObj_get_shiftKey,
793 HTMLEventObj_put_returnValue,
794 HTMLEventObj_get_returnValue,
795 HTMLEventObj_put_cancelBubble,
796 HTMLEventObj_get_cancelBubble,
797 HTMLEventObj_get_fromElement,
798 HTMLEventObj_get_toElement,
799 HTMLEventObj_put_keyCode,
800 HTMLEventObj_get_keyCode,
801 HTMLEventObj_get_button,
802 HTMLEventObj_get_type,
803 HTMLEventObj_get_qualifier,
804 HTMLEventObj_get_reason,
805 HTMLEventObj_get_x,
806 HTMLEventObj_get_y,
807 HTMLEventObj_get_clientX,
808 HTMLEventObj_get_clientY,
809 HTMLEventObj_get_offsetX,
810 HTMLEventObj_get_offsetY,
811 HTMLEventObj_get_screenX,
812 HTMLEventObj_get_screenY,
813 HTMLEventObj_get_srcFilter
814 };
815
816 static inline HTMLEventObj *unsafe_impl_from_IHTMLEventObj(IHTMLEventObj *iface)
817 {
818 return iface->lpVtbl == &HTMLEventObjVtbl ? impl_from_IHTMLEventObj(iface) : NULL;
819 }
820
821 static const tid_t HTMLEventObj_iface_tids[] = {
822 IHTMLEventObj_tid,
823 0
824 };
825
826 static dispex_static_data_t HTMLEventObj_dispex = {
827 NULL,
828 DispCEventObj_tid,
829 NULL,
830 HTMLEventObj_iface_tids
831 };
832
833 static HTMLEventObj *create_event(void)
834 {
835 HTMLEventObj *ret;
836
837 ret = heap_alloc_zero(sizeof(*ret));
838 if(!ret)
839 return NULL;
840
841 ret->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl;
842 ret->ref = 1;
843
844 init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLEventObj_iface, &HTMLEventObj_dispex);
845
846 return ret;
847 }
848
849 static HRESULT set_event_info(HTMLEventObj *event, HTMLDOMNode *target, eventid_t eid, nsIDOMEvent *nsevent)
850 {
851 event->type = event_info+eid;
852 event->nsevent = nsevent;
853
854 if(nsevent) {
855 nsIDOMEvent_AddRef(nsevent);
856 }else if(event_types[event_info[eid].type]) {
857 nsAString type_str;
858 nsresult nsres;
859
860 nsAString_InitDepend(&type_str, event_types[event_info[eid].type]);
861 nsres = nsIDOMHTMLDocument_CreateEvent(target->doc->nsdoc, &type_str, &event->nsevent);
862 nsAString_Finish(&type_str);
863 if(NS_FAILED(nsres)) {
864 ERR("Could not create event: %08x\n", nsres);
865 return E_FAIL;
866 }
867 }
868
869 event->target = target;
870 if(target)
871 IHTMLDOMNode_AddRef(&target->IHTMLDOMNode_iface);
872 return S_OK;
873 }
874
875 HRESULT create_event_obj(IHTMLEventObj **ret)
876 {
877 HTMLEventObj *event;
878
879 event = create_event();
880 if(!event)
881 return E_OUTOFMEMORY;
882
883 *ret = &event->IHTMLEventObj_iface;
884 return S_OK;
885 }
886
887 static inline event_target_t *get_event_target_data(EventTarget *event_target, BOOL alloc)
888 {
889 event_target_t **ptr;
890
891 ptr = event_target->dispex.data->vtbl && event_target->dispex.data->vtbl->get_event_target_ptr
892 ? event_target->dispex.data->vtbl->get_event_target_ptr(&event_target->dispex)
893 : &event_target->ptr;
894 if(*ptr || !alloc)
895 return *ptr;
896
897 return *ptr = heap_alloc_zero(sizeof(event_target_t));
898 }
899
900 static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv)
901 {
902 IDispatchEx *dispex;
903 EXCEPINFO ei;
904 HRESULT hres;
905
906 memset(&ei, 0, sizeof(ei));
907
908 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
909 if(SUCCEEDED(hres)) {
910 hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL);
911 IDispatchEx_Release(dispex);
912 }else {
913 TRACE("Could not get IDispatchEx interface: %08x\n", hres);
914 hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,
915 dp, retv, &ei, NULL);
916 }
917
918 return hres;
919 }
920
921 static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, HTMLEventObj *event_obj, VARIANT *retv)
922 {
923 DISPPARAMS dp = {NULL,NULL,0,0};
924 VARIANT event_arg;
925 ULONG argerr;
926 EXCEPINFO ei;
927
928 if(event_obj) {
929 V_VT(&event_arg) = VT_DISPATCH;
930 V_DISPATCH(&event_arg) = (IDispatch*)&event_obj->IHTMLEventObj_iface;
931 dp.rgvarg = &event_arg;
932 dp.cArgs = 1;
933 }
934
935 memset(&ei, 0, sizeof(ei));
936 return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr);
937 }
938
939 static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid)
940 {
941 int min, max, i;
942 HRESULT hres;
943
944 if(!data)
945 return FALSE;
946
947 if(!data->ids) {
948 hres = get_dispids(data->tid, &data->id_cnt, &data->ids);
949 if(FAILED(hres))
950 return FALSE;
951 }
952
953 min = 0;
954 max = data->id_cnt-1;
955 while(min <= max) {
956 i = (min+max)/2;
957 if(data->ids[i] == dispid)
958 return TRUE;
959
960 if(data->ids[i] < dispid)
961 min = i+1;
962 else
963 max = i-1;
964 }
965
966 return FALSE;
967 }
968
969 static void call_event_handlers(HTMLDocumentNode *doc, HTMLEventObj *event_obj, EventTarget *event_target,
970 ConnectionPointContainer *cp_container, eventid_t eid, IDispatch *this_obj)
971 {
972 event_target_t *data = get_event_target_data(event_target, FALSE);
973 const BOOL cancelable = event_info[eid].flags & EVENT_CANCELABLE;
974 VARIANT v;
975 HRESULT hres;
976
977 if(data && data->event_table[eid] && data->event_table[eid]->handler_prop) {
978 DISPID named_arg = DISPID_THIS;
979 VARIANTARG arg;
980 DISPPARAMS dp = {&arg, &named_arg, 1, 1};
981
982 V_VT(&arg) = VT_DISPATCH;
983 V_DISPATCH(&arg) = this_obj;
984 V_VT(&v) = VT_EMPTY;
985
986 TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
987 hres = call_disp_func(data->event_table[eid]->handler_prop, &dp, &v);
988 if(hres == S_OK) {
989 TRACE("%s <<< %s\n", debugstr_w(event_info[eid].name), debugstr_variant(&v));
990
991 if(cancelable) {
992 if(V_VT(&v) == VT_BOOL) {
993 if(!V_BOOL(&v))
994 event_obj->prevent_default = TRUE;
995 }else if(V_VT(&v) != VT_EMPTY) {
996 FIXME("unhandled result %s\n", debugstr_variant(&v));
997 }
998 }
999 VariantClear(&v);
1000 }else {
1001 WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
1002 }
1003 }
1004
1005 if(data && data->event_table[eid] && data->event_table[eid]->handler_cnt) {
1006 VARIANTARG arg;
1007 DISPPARAMS dp = {&arg, NULL, 1, 0};
1008 int i;
1009
1010 V_VT(&arg) = VT_DISPATCH;
1011 V_DISPATCH(&arg) = (IDispatch*)event_obj;
1012
1013 i = data->event_table[eid]->handler_cnt;
1014 while(i--) {
1015 if(data->event_table[eid]->handlers[i]) {
1016 V_VT(&v) = VT_EMPTY;
1017
1018 TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
1019 hres = call_disp_func(data->event_table[eid]->handlers[i], &dp, &v);
1020 if(hres == S_OK) {
1021 TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
1022
1023 if(cancelable) {
1024 if(V_VT(&v) == VT_BOOL) {
1025 if(!V_BOOL(&v))
1026 event_obj->prevent_default = TRUE;
1027 }else if(V_VT(&v) != VT_EMPTY) {
1028 FIXME("unhandled result %s\n", debugstr_variant(&v));
1029 }
1030 }
1031 VariantClear(&v);
1032 }else {
1033 WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
1034 }
1035 }
1036 }
1037 }
1038
1039 /*
1040 * NOTE: CP events may require doc_obj reference, which we don't own. We make sure that
1041 * it's safe to call event handler by checking nsevent_listener, which is NULL for
1042 * detached documents.
1043 */
1044 if(cp_container && cp_container->forward_container)
1045 cp_container = cp_container->forward_container;
1046 if(cp_container && cp_container->cps && doc->nsevent_listener) {
1047 ConnectionPoint *cp;
1048 unsigned i, j;
1049
1050 for(j=0; cp_container->cp_entries[j].riid; j++) {
1051 cp = cp_container->cps + j;
1052 if(!cp->sinks_size || !is_cp_event(cp->data, event_info[eid].dispid))
1053 continue;
1054
1055 for(i=0; doc->nsevent_listener && i < cp->sinks_size; i++) {
1056 if(!cp->sinks[i].disp)
1057 continue;
1058
1059 V_VT(&v) = VT_EMPTY;
1060
1061 TRACE("cp %s [%u] >>>\n", debugstr_w(event_info[eid].name), i);
1062 hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid,
1063 cp->data->pass_event_arg ? event_obj : NULL, &v);
1064 if(hres == S_OK) {
1065 TRACE("cp %s [%u] <<<\n", debugstr_w(event_info[eid].name), i);
1066
1067 if(cancelable) {
1068 if(V_VT(&v) == VT_BOOL) {
1069 if(!V_BOOL(&v))
1070 event_obj->prevent_default = TRUE;
1071 }else if(V_VT(&v) != VT_EMPTY) {
1072 FIXME("unhandled result %s\n", debugstr_variant(&v));
1073 }
1074 }
1075 VariantClear(&v);
1076 }else {
1077 WARN("cp %s [%u] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
1078 }
1079 }
1080
1081 if(!doc->nsevent_listener)
1082 break;
1083 }
1084 }
1085 }
1086
1087 static void fire_event_obj(HTMLDocumentNode *doc, eventid_t eid, HTMLEventObj *event_obj,
1088 nsIDOMNode *target, IDispatch *script_this)
1089 {
1090 IHTMLEventObj *prev_event;
1091 nsIDOMNode *parent, *nsnode;
1092 BOOL prevent_default = FALSE;
1093 HTMLInnerWindow *window;
1094 HTMLDOMNode *node;
1095 UINT16 node_type;
1096 nsresult nsres;
1097 HRESULT hres;
1098
1099 TRACE("(%p) %s\n", doc, debugstr_w(event_info[eid].name));
1100
1101 window = doc->window;
1102 if(!window) {
1103 WARN("NULL window\n");
1104 return;
1105 }
1106
1107 htmldoc_addref(&doc->basedoc);
1108
1109 prev_event = window->event;
1110 window->event = event_obj ? &event_obj->IHTMLEventObj_iface : NULL;
1111
1112 nsIDOMNode_GetNodeType(target, &node_type);
1113 nsnode = target;
1114 nsIDOMNode_AddRef(nsnode);
1115
1116 switch(node_type) {
1117 case ELEMENT_NODE:
1118 do {
1119 hres = get_node(doc, nsnode, FALSE, &node);
1120 if(SUCCEEDED(hres) && node) {
1121 call_event_handlers(doc, event_obj, &node->event_target, node->cp_container, eid,
1122 script_this ? script_this : (IDispatch*)&node->IHTMLDOMNode_iface);
1123 node_release(node);
1124 }
1125
1126 if(!(event_info[eid].flags & EVENT_BUBBLE) || (event_obj && event_obj->cancel_bubble))
1127 break;
1128
1129 nsIDOMNode_GetParentNode(nsnode, &parent);
1130 nsIDOMNode_Release(nsnode);
1131 nsnode = parent;
1132 if(!nsnode)
1133 break;
1134
1135 nsIDOMNode_GetNodeType(nsnode, &node_type);
1136 }while(node_type == ELEMENT_NODE);
1137
1138 if(!(event_info[eid].flags & EVENT_BUBBLE) || (event_obj && event_obj->cancel_bubble))
1139 break;
1140
1141 case DOCUMENT_NODE:
1142 if(event_info[eid].flags & EVENT_FORWARDBODY) {
1143 nsIDOMHTMLElement *nsbody;
1144 nsresult nsres;
1145
1146 nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
1147 if(NS_SUCCEEDED(nsres) && nsbody) {
1148 hres = get_node(doc, (nsIDOMNode*)nsbody, FALSE, &node);
1149 if(SUCCEEDED(hres) && node) {
1150 call_event_handlers(doc, event_obj, &node->event_target, node->cp_container, eid,
1151 script_this ? script_this : (IDispatch*)&node->IHTMLDOMNode_iface);
1152 node_release(node);
1153 }
1154 nsIDOMHTMLElement_Release(nsbody);
1155 }else {
1156 ERR("Could not get body: %08x\n", nsres);
1157 }
1158 }
1159
1160 call_event_handlers(doc, event_obj, &doc->node.event_target, &doc->basedoc.cp_container, eid,
1161 script_this ? script_this : (IDispatch*)&doc->basedoc.IHTMLDocument2_iface);
1162 break;
1163
1164 default:
1165 FIXME("unimplemented node type %d\n", node_type);
1166 }
1167
1168 if(nsnode)
1169 nsIDOMNode_Release(nsnode);
1170
1171 if(event_obj && event_obj->prevent_default)
1172 prevent_default = TRUE;
1173 window->event = prev_event;
1174
1175 if(!prevent_default && (event_info[eid].flags & EVENT_HASDEFAULTHANDLERS)) {
1176 nsIDOMNode_AddRef(target);
1177 nsnode = target;
1178
1179 do {
1180 hres = get_node(doc, nsnode, TRUE, &node);
1181 if(FAILED(hres))
1182 break;
1183
1184 if(node) {
1185 if(node->vtbl->handle_event)
1186 hres = node->vtbl->handle_event(node, eid, event_obj ? event_obj->nsevent : NULL, &prevent_default);
1187 node_release(node);
1188 if(FAILED(hres) || prevent_default || (event_obj && event_obj->cancel_bubble))
1189 break;
1190 }
1191
1192 nsres = nsIDOMNode_GetParentNode(nsnode, &parent);
1193 if(NS_FAILED(nsres))
1194 break;
1195
1196 nsIDOMNode_Release(nsnode);
1197 nsnode = parent;
1198 } while(nsnode);
1199
1200 if(nsnode)
1201 nsIDOMNode_Release(nsnode);
1202 }
1203
1204 if(prevent_default && event_obj && event_obj->nsevent) {
1205 TRACE("calling PreventDefault\n");
1206 nsIDOMEvent_PreventDefault(event_obj->nsevent);
1207 }
1208
1209 htmldoc_release(&doc->basedoc);
1210 }
1211
1212 void fire_event(HTMLDocumentNode *doc, eventid_t eid, BOOL set_event, nsIDOMNode *target, nsIDOMEvent *nsevent,
1213 IDispatch *script_this)
1214 {
1215 HTMLEventObj *event_obj = NULL;
1216 HTMLDOMNode *node;
1217 HRESULT hres;
1218
1219 if(set_event) {
1220 hres = get_node(doc, target, TRUE, &node);
1221 if(FAILED(hres))
1222 return;
1223
1224 event_obj = create_event();
1225 node_release(node);
1226 if(!event_obj)
1227 return;
1228
1229 hres = set_event_info(event_obj, node, eid, nsevent);
1230 if(FAILED(hres)) {
1231 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
1232 return;
1233 }
1234 }
1235
1236 fire_event_obj(doc, eid, event_obj, target, script_this);
1237
1238 if(event_obj)
1239 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
1240 }
1241
1242 HRESULT dispatch_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_var, VARIANT_BOOL *cancelled)
1243 {
1244 HTMLEventObj *event_obj = NULL;
1245 eventid_t eid;
1246 HRESULT hres;
1247
1248 eid = attr_to_eid(event_name);
1249 if(eid == EVENTID_LAST) {
1250 WARN("unknown event %s\n", debugstr_w(event_name));
1251 return E_INVALIDARG;
1252 }
1253
1254 if(event_var && V_VT(event_var) != VT_EMPTY && V_VT(event_var) != VT_ERROR) {
1255 if(V_VT(event_var) != VT_DISPATCH) {
1256 FIXME("event_var %s not supported\n", debugstr_variant(event_var));
1257 return E_NOTIMPL;
1258 }
1259
1260 if(V_DISPATCH(event_var)) {
1261 IHTMLEventObj *event_iface;
1262
1263 hres = IDispatch_QueryInterface(V_DISPATCH(event_var), &IID_IHTMLEventObj, (void**)&event_iface);
1264 if(FAILED(hres)) {
1265 FIXME("No IHTMLEventObj iface\n");
1266 return hres;
1267 }
1268
1269 event_obj = unsafe_impl_from_IHTMLEventObj(event_iface);
1270 if(!event_obj) {
1271 ERR("Not our IHTMLEventObj?\n");
1272 IHTMLEventObj_Release(event_iface);
1273 return E_FAIL;
1274 }
1275 }
1276 }
1277
1278 if(event_obj) {
1279 hres = set_event_info(event_obj, node, eid, NULL);
1280 if(SUCCEEDED(hres))
1281 fire_event_obj(node->doc, eid, event_obj, node->nsnode, NULL);
1282
1283 IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
1284 if(FAILED(hres))
1285 return hres;
1286 }else {
1287 if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
1288 FIXME("not EVENT_DEFAULTEVENTHANDLER\n");
1289 return E_NOTIMPL;
1290 }
1291
1292 fire_event(node->doc, eid, TRUE, node->nsnode, NULL, NULL);
1293 }
1294
1295 *cancelled = VARIANT_TRUE; /* FIXME */
1296 return S_OK;
1297 }
1298
1299 HRESULT call_fire_event(HTMLDOMNode *node, eventid_t eid)
1300 {
1301 HRESULT hres;
1302
1303 if(node->vtbl->fire_event) {
1304 BOOL handled = FALSE;
1305
1306 hres = node->vtbl->fire_event(node, eid, &handled);
1307 if(handled)
1308 return hres;
1309 }
1310
1311 fire_event(node->doc, eid, TRUE, node->nsnode, NULL, NULL);
1312 return S_OK;
1313 }
1314
1315 static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt)
1316 {
1317 handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid];
1318
1319 if(handler_vector) {
1320 if(cnt <= handler_vector->handler_cnt)
1321 return TRUE;
1322
1323 new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1324 }else {
1325 new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1326 }
1327
1328 if(!new_vector)
1329 return FALSE;
1330
1331 new_vector->handler_cnt = cnt;
1332 event_target->event_table[eid] = new_vector;
1333 return TRUE;
1334 }
1335
1336 HRESULT ensure_doc_nsevent_handler(HTMLDocumentNode *doc, eventid_t eid)
1337 {
1338 nsIDOMNode *nsnode = NULL;
1339
1340 TRACE("%s\n", debugstr_w(event_info[eid].name));
1341
1342 if(!doc->nsdoc || doc->event_vector[eid] || !(event_info[eid].flags & (EVENT_DEFAULTLISTENER|EVENT_BIND_TO_BODY)))
1343 return S_OK;
1344
1345 if(event_info[eid].flags & EVENT_BIND_TO_BODY) {
1346 nsnode = doc->node.nsnode;
1347 nsIDOMNode_AddRef(nsnode);
1348 }
1349
1350 doc->event_vector[eid] = TRUE;
1351 add_nsevent_listener(doc, nsnode, event_info[eid].name);
1352
1353 if(nsnode)
1354 nsIDOMNode_Release(nsnode);
1355 return S_OK;
1356 }
1357
1358 void detach_events(HTMLDocumentNode *doc)
1359 {
1360 if(doc->event_vector) {
1361 int i;
1362
1363 for(i=0; i < EVENTID_LAST; i++) {
1364 if(doc->event_vector[i]) {
1365 detach_nsevent(doc, event_info[i].name);
1366 doc->event_vector[i] = FALSE;
1367 }
1368 }
1369 }
1370
1371 release_nsevents(doc);
1372 }
1373
1374 static void bind_event(EventTarget *event_target, eventid_t eid)
1375 {
1376 if(event_target->dispex.data->vtbl->bind_event)
1377 event_target->dispex.data->vtbl->bind_event(&event_target->dispex, eid);
1378 else
1379 FIXME("Unsupported event binding on target %p\n", event_target);
1380 }
1381
1382 static void remove_event_handler(EventTarget *event_target, eventid_t eid)
1383 {
1384 event_target_t *data;
1385 VARIANT *store;
1386 HRESULT hres;
1387
1388 hres = dispex_get_dprop_ref(&event_target->dispex, event_info[eid].attr_name, FALSE, &store);
1389 if(SUCCEEDED(hres))
1390 VariantClear(store);
1391
1392 data = get_event_target_data(event_target, FALSE);
1393 if(data && data->event_table[eid] && data->event_table[eid]->handler_prop) {
1394 IDispatch_Release(data->event_table[eid]->handler_prop);
1395 data->event_table[eid]->handler_prop = NULL;
1396 }
1397 }
1398
1399 static HRESULT set_event_handler_disp(EventTarget *event_target, eventid_t eid, IDispatch *disp)
1400 {
1401 event_target_t *data;
1402
1403 remove_event_handler(event_target, eid);
1404 if(!disp)
1405 return S_OK;
1406
1407 data = get_event_target_data(event_target, TRUE);
1408 if(!data)
1409 return E_OUTOFMEMORY;
1410
1411 if(!alloc_handler_vector(data, eid, 0))
1412 return E_OUTOFMEMORY;
1413
1414 data->event_table[eid]->handler_prop = disp;
1415 IDispatch_AddRef(disp);
1416
1417 bind_event(event_target, eid);
1418 return S_OK;
1419 }
1420
1421 HRESULT set_event_handler(EventTarget *event_target, eventid_t eid, VARIANT *var)
1422 {
1423 switch(V_VT(var)) {
1424 case VT_NULL:
1425 remove_event_handler(event_target, eid);
1426 return S_OK;
1427
1428 case VT_DISPATCH:
1429 return set_event_handler_disp(event_target, eid, V_DISPATCH(var));
1430
1431 case VT_BSTR: {
1432 VARIANT *v;
1433 HRESULT hres;
1434
1435 /*
1436 * Setting event handler to string is a rare case and we don't want to
1437 * complicate nor increase memory of event_target_t for that. Instead,
1438 * we store the value in DispatchEx, which can already handle custom
1439 * properties.
1440 */
1441 remove_event_handler(event_target, eid);
1442
1443 hres = dispex_get_dprop_ref(&event_target->dispex, event_info[eid].attr_name, TRUE, &v);
1444 if(FAILED(hres))
1445 return hres;
1446
1447 V_BSTR(v) = SysAllocString(V_BSTR(var));
1448 if(!V_BSTR(v))
1449 return E_OUTOFMEMORY;
1450 V_VT(v) = VT_BSTR;
1451 return S_OK;
1452 }
1453
1454 default:
1455 FIXME("not handler %s\n", debugstr_variant(var));
1456 /* fall through */
1457 case VT_EMPTY:
1458 return E_NOTIMPL;
1459 }
1460
1461 return S_OK;
1462 }
1463
1464 HRESULT get_event_handler(EventTarget *event_target, eventid_t eid, VARIANT *var)
1465 {
1466 event_target_t *data;
1467 VARIANT *v;
1468 HRESULT hres;
1469
1470 hres = dispex_get_dprop_ref(&event_target->dispex, event_info[eid].attr_name, FALSE, &v);
1471 if(SUCCEEDED(hres) && V_VT(v) != VT_EMPTY)
1472 return VariantCopy(var, v);
1473
1474 data = get_event_target_data(event_target, FALSE);
1475 if(data && data->event_table[eid] && data->event_table[eid]->handler_prop) {
1476 V_VT(var) = VT_DISPATCH;
1477 V_DISPATCH(var) = data->event_table[eid]->handler_prop;
1478 IDispatch_AddRef(V_DISPATCH(var));
1479 }else {
1480 V_VT(var) = VT_NULL;
1481 }
1482
1483 return S_OK;
1484 }
1485
1486 HRESULT attach_event(EventTarget *event_target, BSTR name, IDispatch *disp, VARIANT_BOOL *res)
1487 {
1488 event_target_t *data;
1489 eventid_t eid;
1490 DWORD i = 0;
1491
1492 eid = attr_to_eid(name);
1493 if(eid == EVENTID_LAST) {
1494 WARN("Unknown event\n");
1495 *res = VARIANT_TRUE;
1496 return S_OK;
1497 }
1498
1499 data = get_event_target_data(event_target, TRUE);
1500 if(!data)
1501 return E_OUTOFMEMORY;
1502
1503 if(data->event_table[eid]) {
1504 while(i < data->event_table[eid]->handler_cnt && data->event_table[eid]->handlers[i])
1505 i++;
1506 if(i == data->event_table[eid]->handler_cnt && !alloc_handler_vector(data, eid, i+1))
1507 return E_OUTOFMEMORY;
1508 }else if(!alloc_handler_vector(data, eid, i+1)) {
1509 return E_OUTOFMEMORY;
1510 }
1511
1512 IDispatch_AddRef(disp);
1513 data->event_table[eid]->handlers[i] = disp;
1514
1515 bind_event(event_target, eid);
1516
1517 *res = VARIANT_TRUE;
1518 return S_OK;
1519 }
1520
1521 HRESULT detach_event(EventTarget *event_target, 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, eid, disp);
1564 }
1565
1566 void update_doc_cp_events(HTMLDocumentNode *doc, cp_static_data_t *cp)
1567 {
1568 int i;
1569
1570 for(i=0; i < EVENTID_LAST; i++) {
1571 if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
1572 ensure_doc_nsevent_handler(doc, i);
1573 }
1574 }
1575
1576 void check_event_attr(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem)
1577 {
1578 const PRUnichar *attr_value;
1579 nsAString attr_value_str;
1580 IDispatch *disp;
1581 HTMLDOMNode *node;
1582 int i;
1583 nsresult nsres;
1584 HRESULT hres;
1585
1586 for(i=0; i < EVENTID_LAST; i++) {
1587 nsres = get_elem_attr_value(nselem, event_info[i].attr_name, &attr_value_str, &attr_value);
1588 if(NS_SUCCEEDED(nsres)) {
1589 if(!*attr_value)
1590 continue;
1591
1592 TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
1593
1594 disp = script_parse_event(doc->window, attr_value);
1595 if(disp) {
1596 hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
1597 if(SUCCEEDED(hres)) {
1598 set_event_handler_disp(&node->event_target, i, disp);
1599 node_release(node);
1600 }
1601 IDispatch_Release(disp);
1602 }
1603 nsAString_Finish(&attr_value_str);
1604 }
1605 }
1606 }
1607
1608 HRESULT doc_init_events(HTMLDocumentNode *doc)
1609 {
1610 unsigned i;
1611 HRESULT hres;
1612
1613 doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
1614 if(!doc->event_vector)
1615 return E_OUTOFMEMORY;
1616
1617 init_nsevents(doc);
1618
1619 for(i=0; i < EVENTID_LAST; i++) {
1620 if(event_info[i].flags & EVENT_HASDEFAULTHANDLERS) {
1621 hres = ensure_doc_nsevent_handler(doc, i);
1622 if(FAILED(hres))
1623 return hres;
1624 }
1625 }
1626
1627 return S_OK;
1628 }
1629
1630 void release_event_target(event_target_t *event_target)
1631 {
1632 int i;
1633 unsigned int j;
1634
1635 for(i=0; i < EVENTID_LAST; i++) {
1636 if(event_target->event_table[i]) {
1637 if(event_target->event_table[i]->handler_prop)
1638 IDispatch_Release(event_target->event_table[i]->handler_prop);
1639 for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
1640 if(event_target->event_table[i]->handlers[j])
1641 IDispatch_Release(event_target->event_table[i]->handlers[j]);
1642 }
1643 }
1644
1645 heap_free(event_target);
1646 }
Maarten's multimedia branch