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