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