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