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