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