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