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