2 * Copyright 2008-2009 Jacek Caban for CodeWeavers
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.
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.
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
29 #include "mshtml_private.h"
30 #include "htmlevent.h"
32 #include "wine/debug.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
37 IDispatch *handler_prop;
39 IDispatch *handlers[0];
42 struct event_target_t {
43 DWORD node_handlers_mask;
44 handler_vector_t *event_table[EVENTID_LAST];
47 static const WCHAR beforeunloadW[] = {'b','e','f','o','r','e','u','n','l','o','a','d',0};
48 static const WCHAR onbeforeunloadW[] = {'o','n','b','e','f','o','r','e','u','n','l','o','a','d',0};
50 static const WCHAR blurW[] = {'b','l','u','r',0};
51 static const WCHAR onblurW[] = {'o','n','b','l','u','r',0};
53 static const WCHAR changeW[] = {'c','h','a','n','g','e',0};
54 static const WCHAR onchangeW[] = {'o','n','c','h','a','n','g','e',0};
56 static const WCHAR clickW[] = {'c','l','i','c','k',0};
57 static const WCHAR onclickW[] = {'o','n','c','l','i','c','k',0};
59 static const WCHAR contextmenuW[] = {'c','o','n','t','e','x','t','m','e','n','u',0};
60 static const WCHAR oncontextmenuW[] = {'o','n','c','o','n','t','e','x','t','m','e','n','u',0};
62 static const WCHAR dblclickW[] = {'d','b','l','c','l','i','c','k',0};
63 static const WCHAR ondblclickW[] = {'o','n','d','b','l','c','l','i','c','k',0};
65 static const WCHAR dragW[] = {'d','r','a','g',0};
66 static const WCHAR ondragW[] = {'o','n','d','r','a','g',0};
68 static const WCHAR dragstartW[] = {'d','r','a','g','s','t','a','r','t',0};
69 static const WCHAR ondragstartW[] = {'o','n','d','r','a','g','s','t','a','r','t',0};
71 static const WCHAR focusW[] = {'f','o','c','u','s',0};
72 static const WCHAR onfocusW[] = {'o','n','f','o','c','u','s',0};
74 static const WCHAR keydownW[] = {'k','e','y','d','o','w','n',0};
75 static const WCHAR onkeydownW[] = {'o','n','k','e','y','d','o','w','n',0};
77 static const WCHAR keyupW[] = {'k','e','y','u','p',0};
78 static const WCHAR onkeyupW[] = {'o','n','k','e','y','u','p',0};
80 static const WCHAR loadW[] = {'l','o','a','d',0};
81 static const WCHAR onloadW[] = {'o','n','l','o','a','d',0};
83 static const WCHAR mousedownW[] = {'m','o','u','s','e','d','o','w','n',0};
84 static const WCHAR onmousedownW[] = {'o','n','m','o','u','s','e','d','o','w','n',0};
86 static const WCHAR mouseoutW[] = {'m','o','u','s','e','o','u','t',0};
87 static const WCHAR onmouseoutW[] = {'o','n','m','o','u','s','e','o','u','t',0};
89 static const WCHAR mouseoverW[] = {'m','o','u','s','e','o','v','e','r',0};
90 static const WCHAR onmouseoverW[] = {'o','n','m','o','u','s','e','o','v','e','r',0};
92 static const WCHAR mouseupW[] = {'m','o','u','s','e','u','p',0};
93 static const WCHAR onmouseupW[] = {'o','n','m','o','u','s','e','u','p',0};
95 static const WCHAR pasteW[] = {'p','a','s','t','e',0};
96 static const WCHAR onpasteW[] = {'o','n','p','a','s','t','e',0};
98 static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
99 static const WCHAR onreadystatechangeW[] = {'o','n','r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
101 static const WCHAR resizeW[] = {'r','e','s','i','z','e',0};
102 static const WCHAR onresizeW[] = {'o','n','r','e','s','i','z','e',0};
104 static const WCHAR selectstartW[] = {'s','e','l','e','c','t','s','t','a','r','t',0};
105 static const WCHAR onselectstartW[] = {'o','n','s','e','l','e','c','t','s','t','a','r','t',0};
107 static const WCHAR HTMLEventsW[] = {'H','T','M','L','E','v','e','n','t','s',0};
108 static const WCHAR KeyboardEventW[] = {'K','e','y','b','o','a','r','d','E','v','e','n','t',0};
109 static const WCHAR MouseEventW[] = {'M','o','u','s','e','E','v','e','n','t',0};
118 static const WCHAR *event_types[] = {
133 #define EVENT_DEFAULTLISTENER 0x0001
134 #define EVENT_BUBBLE 0x0002
135 #define EVENT_FORWARDBODY 0x0004
136 #define EVENT_NODEHANDLER 0x0008
138 static const event_info_t event_info[] = {
139 {beforeunloadW, onbeforeunloadW, EVENTT_NONE, DISPID_EVMETH_ONBEFOREUNLOAD,
140 EVENT_DEFAULTLISTENER|EVENT_FORWARDBODY},
141 {blurW, onblurW, EVENTT_HTML, DISPID_EVMETH_ONBLUR,
142 EVENT_DEFAULTLISTENER},
143 {changeW, onchangeW, EVENTT_HTML, DISPID_EVMETH_ONCHANGE,
144 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
145 {clickW, onclickW, EVENTT_MOUSE, DISPID_EVMETH_ONCLICK,
146 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
147 {contextmenuW, oncontextmenuW, EVENTT_MOUSE, DISPID_EVMETH_ONCONTEXTMENU,
149 {dblclickW, ondblclickW, EVENTT_MOUSE, DISPID_EVMETH_ONDBLCLICK,
150 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
151 {dragW, ondragW, EVENTT_MOUSE, DISPID_EVMETH_ONDRAG,
153 {dragstartW, ondragstartW, EVENTT_MOUSE, DISPID_EVMETH_ONDRAGSTART,
155 {focusW, onfocusW, EVENTT_HTML, DISPID_EVMETH_ONFOCUS,
156 EVENT_DEFAULTLISTENER},
157 {keydownW, onkeydownW, EVENTT_KEY, DISPID_EVMETH_ONKEYDOWN,
158 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
159 {keyupW, onkeyupW, EVENTT_KEY, DISPID_EVMETH_ONKEYUP,
160 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
161 {loadW, onloadW, EVENTT_HTML, DISPID_EVMETH_ONLOAD,
163 {mousedownW, onmousedownW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEDOWN,
164 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
165 {mouseoutW, onmouseoutW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEOUT,
166 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
167 {mouseoverW, onmouseoverW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEOVER,
168 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
169 {mouseupW, onmouseupW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEUP,
170 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
171 {pasteW, onpasteW, EVENTT_NONE, DISPID_EVMETH_ONPASTE,
173 {readystatechangeW, onreadystatechangeW, EVENTT_NONE, DISPID_EVMETH_ONREADYSTATECHANGE,
175 {resizeW, onresizeW, EVENTT_NONE, DISPID_EVMETH_ONRESIZE,
176 EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
177 {selectstartW, onselectstartW, EVENTT_MOUSE, DISPID_EVMETH_ONSELECTSTART,
181 static const eventid_t node_handled_list[] = { EVENTID_LOAD };
183 eventid_t str_to_eid(LPCWSTR str)
187 for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
188 if(!strcmpW(event_info[i].name, str))
192 ERR("unknown type %s\n", debugstr_w(str));
196 static eventid_t attr_to_eid(LPCWSTR str)
200 for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
201 if(!strcmpW(event_info[i].attr_name, str))
208 static DWORD get_node_handler_mask(eventid_t eid)
212 for(i=0; i<sizeof(node_handled_list)/sizeof(*node_handled_list); i++) {
213 if(node_handled_list[i] == eid)
217 ERR("Invalid eid %d\n", eid);
223 IHTMLEventObj IHTMLEventObj_iface;
228 const event_info_t *type;
229 nsIDOMEvent *nsevent;
232 static inline HTMLEventObj *impl_from_IHTMLEventObj(IHTMLEventObj *iface)
234 return CONTAINING_RECORD(iface, HTMLEventObj, IHTMLEventObj_iface);
237 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
239 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
243 if(IsEqualGUID(&IID_IUnknown, riid)) {
244 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
245 *ppv = &This->IHTMLEventObj_iface;
246 }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) {
247 TRACE("(%p)->(IID_IHTMLEventObj %p)\n", This, ppv);
248 *ppv = &This->IHTMLEventObj_iface;
249 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
250 return *ppv ? S_OK : E_NOINTERFACE;
254 IUnknown_AddRef((IUnknown*)*ppv);
258 WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
259 return E_NOINTERFACE;
262 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
264 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
265 LONG ref = InterlockedIncrement(&This->ref);
267 TRACE("(%p) ref=%d\n", This, ref);
272 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
274 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
275 LONG ref = InterlockedDecrement(&This->ref);
277 TRACE("(%p) ref=%d\n", This, ref);
281 nsIDOMEvent_Release(This->nsevent);
282 release_dispex(&This->dispex);
289 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
291 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
292 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
295 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
296 LCID lcid, ITypeInfo **ppTInfo)
298 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
299 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
302 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
303 LPOLESTR *rgszNames, UINT cNames,
304 LCID lcid, DISPID *rgDispId)
306 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
307 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
311 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
312 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
313 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
315 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
316 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
317 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
320 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
322 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
324 TRACE("(%p)->(%p)\n", This, p);
326 return IHTMLDOMNode_QueryInterface(&This->target->IHTMLDOMNode_iface, &IID_IHTMLElement,
330 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
332 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
335 TRACE("(%p)->(%p)\n", This, p);
338 nsIDOMKeyEvent *key_event;
341 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
342 if(NS_SUCCEEDED(nsres)) {
343 nsIDOMKeyEvent_GetAltKey(key_event, &ret);
344 nsIDOMKeyEvent_Release(key_event);
346 nsIDOMMouseEvent *mouse_event;
348 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
349 if(NS_SUCCEEDED(nsres)) {
350 nsIDOMMouseEvent_GetAltKey(mouse_event, &ret);
351 nsIDOMMouseEvent_Release(mouse_event);
356 *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
360 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
362 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
365 TRACE("(%p)->(%p)\n", This, p);
368 nsIDOMKeyEvent *key_event;
371 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
372 if(NS_SUCCEEDED(nsres)) {
373 nsIDOMKeyEvent_GetCtrlKey(key_event, &ret);
374 nsIDOMKeyEvent_Release(key_event);
376 nsIDOMMouseEvent *mouse_event;
378 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
379 if(NS_SUCCEEDED(nsres)) {
380 nsIDOMMouseEvent_GetCtrlKey(mouse_event, &ret);
381 nsIDOMMouseEvent_Release(mouse_event);
386 *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
390 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
392 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
395 TRACE("(%p)->(%p)\n", This, p);
398 nsIDOMKeyEvent *key_event;
401 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
402 if(NS_SUCCEEDED(nsres)) {
403 nsIDOMKeyEvent_GetShiftKey(key_event, &ret);
404 nsIDOMKeyEvent_Release(key_event);
406 nsIDOMMouseEvent *mouse_event;
408 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
409 if(NS_SUCCEEDED(nsres)) {
410 nsIDOMMouseEvent_GetShiftKey(mouse_event, &ret);
411 nsIDOMMouseEvent_Release(mouse_event);
416 *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
420 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
422 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
423 FIXME("(%p)->()\n", This);
427 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
429 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
431 FIXME("(%p)->(%p)\n", This, p);
437 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
439 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
440 FIXME("(%p)->(%x)\n", This, v);
444 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
446 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
448 FIXME("(%p)->(%p)\n", This, p);
454 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
456 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
458 FIXME("(%p)->(%p)\n", This, p);
464 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
466 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
468 FIXME("(%p)->(%p)\n", This, p);
474 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
476 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
477 FIXME("(%p)->(%d)\n", This, v);
481 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
483 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
484 PRUint32 key_code = 0;
486 TRACE("(%p)->(%p)\n", This, p);
489 nsIDOMKeyEvent *key_event;
492 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
493 if(NS_SUCCEEDED(nsres)) {
494 nsIDOMKeyEvent_GetKeyCode(key_event, &key_code);
495 nsIDOMKeyEvent_Release(key_event);
503 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
505 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
508 TRACE("(%p)->(%p)\n", This, p);
511 nsIDOMMouseEvent *mouse_event;
514 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
515 if(NS_SUCCEEDED(nsres)) {
516 nsIDOMMouseEvent_GetButton(mouse_event, &button);
517 nsIDOMMouseEvent_Release(mouse_event);
525 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
527 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
529 TRACE("(%p)->(%p)\n", This, p);
531 *p = SysAllocString(This->type->name);
532 return *p ? S_OK : E_OUTOFMEMORY;
535 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
537 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
539 FIXME("(%p)->(%p)\n", This, p);
545 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
547 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
549 FIXME("(%p)->(%p)\n", This, p);
555 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
557 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
559 FIXME("(%p)->(%p)\n", This, p);
565 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
567 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
569 FIXME("(%p)->(%p)\n", This, p);
575 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
577 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
580 TRACE("(%p)->(%p)\n", This, p);
583 nsIDOMMouseEvent *mouse_event;
586 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
587 if(NS_SUCCEEDED(nsres)) {
588 nsIDOMMouseEvent_GetClientX(mouse_event, &x);
589 nsIDOMMouseEvent_Release(mouse_event);
597 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
599 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
602 TRACE("(%p)->(%p)\n", This, p);
605 nsIDOMMouseEvent *mouse_event;
608 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
609 if(NS_SUCCEEDED(nsres)) {
610 nsIDOMMouseEvent_GetClientY(mouse_event, &y);
611 nsIDOMMouseEvent_Release(mouse_event);
619 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
621 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
623 FIXME("(%p)->(%p)\n", This, p);
629 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p)
631 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
633 FIXME("(%p)->(%p)\n", This, p);
639 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p)
641 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
644 TRACE("(%p)->(%p)\n", This, p);
647 nsIDOMMouseEvent *mouse_event;
650 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
651 if(NS_SUCCEEDED(nsres)) {
652 nsIDOMMouseEvent_GetScreenX(mouse_event, &x);
653 nsIDOMMouseEvent_Release(mouse_event);
661 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
663 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
666 TRACE("(%p)->(%p)\n", This, p);
669 nsIDOMMouseEvent *mouse_event;
672 nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
673 if(NS_SUCCEEDED(nsres)) {
674 nsIDOMMouseEvent_GetScreenY(mouse_event, &y);
675 nsIDOMMouseEvent_Release(mouse_event);
683 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
685 HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
687 FIXME("(%p)->(%p)\n", This, p);
693 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
694 HTMLEventObj_QueryInterface,
696 HTMLEventObj_Release,
697 HTMLEventObj_GetTypeInfoCount,
698 HTMLEventObj_GetTypeInfo,
699 HTMLEventObj_GetIDsOfNames,
701 HTMLEventObj_get_srcElement,
702 HTMLEventObj_get_altKey,
703 HTMLEventObj_get_ctrlKey,
704 HTMLEventObj_get_shiftKey,
705 HTMLEventObj_put_returnValue,
706 HTMLEventObj_get_returnValue,
707 HTMLEventObj_put_cancelBubble,
708 HTMLEventObj_get_cancelBubble,
709 HTMLEventObj_get_fromElement,
710 HTMLEventObj_get_toElement,
711 HTMLEventObj_put_keyCode,
712 HTMLEventObj_get_keyCode,
713 HTMLEventObj_get_button,
714 HTMLEventObj_get_type,
715 HTMLEventObj_get_qualifier,
716 HTMLEventObj_get_reason,
719 HTMLEventObj_get_clientX,
720 HTMLEventObj_get_clientY,
721 HTMLEventObj_get_offsetX,
722 HTMLEventObj_get_offsetY,
723 HTMLEventObj_get_screenX,
724 HTMLEventObj_get_screenY,
725 HTMLEventObj_get_srcFilter
728 static const tid_t HTMLEventObj_iface_tids[] = {
733 static dispex_static_data_t HTMLEventObj_dispex = {
737 HTMLEventObj_iface_tids
740 static IHTMLEventObj *create_event(HTMLDOMNode *target, eventid_t eid, nsIDOMEvent *nsevent)
744 ret = heap_alloc(sizeof(*ret));
748 ret->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl;
750 ret->type = event_info+eid;
752 ret->nsevent = nsevent;
754 nsIDOMEvent_AddRef(nsevent);
755 }else if(event_types[event_info[eid].type]) {
756 nsIDOMDocumentEvent *doc_event;
759 nsres = nsIDOMHTMLDocument_QueryInterface(target->doc->nsdoc, &IID_nsIDOMDocumentEvent,
761 if(NS_SUCCEEDED(nsres)) {
764 nsAString_InitDepend(&type_str, event_types[event_info[eid].type]);
765 nsres = nsIDOMDocumentEvent_CreateEvent(doc_event, &type_str, &ret->nsevent);
766 nsAString_Finish(&type_str);
767 nsIDOMDocumentEvent_Release(doc_event);
769 if(NS_FAILED(nsres)) {
770 ERR("Could not create event: %08x\n", nsres);
771 IHTMLEventObj_Release(&ret->IHTMLEventObj_iface);
776 ret->target = target;
777 IHTMLDOMNode_AddRef(&target->IHTMLDOMNode_iface);
779 init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLEventObj_iface, &HTMLEventObj_dispex);
781 return &ret->IHTMLEventObj_iface;
784 static HRESULT call_cp_func(IDispatch *disp, DISPID dispid)
786 DISPPARAMS dp = {NULL,NULL,0,0};
792 V_VT(&vres) = VT_EMPTY;
793 memset(&ei, 0, sizeof(ei));
794 hres = IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, &vres, &ei, &argerr);
795 if(SUCCEEDED(hres) && V_VT(&vres) != VT_EMPTY) {
796 FIXME("handle result %s\n", debugstr_variant(&vres));
803 static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid)
812 hres = get_dispids(data->tid, &data->id_cnt, &data->ids);
818 max = data->id_cnt-1;
821 if(data->ids[i] == dispid)
824 if(data->ids[i] < dispid)
833 static void call_event_handlers(HTMLDocumentNode *doc, IHTMLEventObj *event_obj, event_target_t *event_target,
834 ConnectionPointContainer *cp_container, eventid_t eid, IDispatch *this_obj)
836 handler_vector_t *handler_vector = NULL;
841 handler_vector = event_target->event_table[eid];
843 if(handler_vector && handler_vector->handler_prop) {
844 DISPID named_arg = DISPID_THIS;
846 DISPPARAMS dp = {&arg, &named_arg, 1, 1};
848 V_VT(&arg) = VT_DISPATCH;
849 V_DISPATCH(&arg) = this_obj;
851 TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
852 hres = call_disp_func(handler_vector->handler_prop, &dp);
854 TRACE("%s <<<\n", debugstr_w(event_info[eid].name));
856 WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
859 if(handler_vector && handler_vector->handler_cnt) {
861 DISPPARAMS dp = {&arg, NULL, 1, 0};
863 V_VT(&arg) = VT_DISPATCH;
864 V_DISPATCH(&arg) = (IDispatch*)event_obj;
866 i = handler_vector->handler_cnt;
868 if(handler_vector->handlers[i]) {
869 TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
870 hres = call_disp_func(handler_vector->handlers[i], &dp);
872 TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
874 WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
882 if(cp_container->forward_container)
883 cp_container = cp_container->forward_container;
885 for(cp = cp_container->cp_list; cp; cp = cp->next) {
886 if(cp->sinks_size && is_cp_event(cp->data, event_info[eid].dispid)) {
887 for(i=0; i < cp->sinks_size; i++) {
888 if(!cp->sinks[i].disp)
891 TRACE("cp %s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
892 hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid);
894 TRACE("cp %s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
896 WARN("cp %s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
903 void fire_event(HTMLDocumentNode *doc, eventid_t eid, BOOL set_event, nsIDOMNode *target, nsIDOMEvent *nsevent)
905 IHTMLEventObj *prev_event, *event_obj = NULL;
906 nsIDOMNode *parent, *nsnode;
911 TRACE("(%p) %s\n", doc, debugstr_w(event_info[eid].name));
913 prev_event = doc->basedoc.window->event;
915 hres = get_node(doc, target, TRUE, &node);
919 event_obj = create_event(node, eid, nsevent);
921 doc->basedoc.window->event = event_obj;
923 nsIDOMNode_GetNodeType(target, &node_type);
925 nsIDOMNode_AddRef(nsnode);
930 hres = get_node(doc, nsnode, FALSE, &node);
931 if(SUCCEEDED(hres) && node)
932 call_event_handlers(doc, event_obj, *get_node_event_target(node),
933 node->cp_container, eid, (IDispatch*)&node->IHTMLDOMNode_iface);
935 if(!(event_info[eid].flags & EVENT_BUBBLE))
938 nsIDOMNode_GetParentNode(nsnode, &parent);
939 nsIDOMNode_Release(nsnode);
944 nsIDOMNode_GetNodeType(nsnode, &node_type);
945 }while(node_type == ELEMENT_NODE);
947 if(!(event_info[eid].flags & EVENT_BUBBLE))
951 if(event_info[eid].flags & EVENT_FORWARDBODY) {
952 nsIDOMHTMLElement *nsbody;
955 nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
956 if(NS_SUCCEEDED(nsres) && nsbody) {
957 hres = get_node(doc, (nsIDOMNode*)nsbody, FALSE, &node);
958 if(SUCCEEDED(hres) && node)
959 call_event_handlers(doc, event_obj, *get_node_event_target(node),
960 node->cp_container, eid, (IDispatch*)&node->IHTMLDOMNode_iface);
961 nsIDOMHTMLElement_Release(nsbody);
963 ERR("Could not get body: %08x\n", nsres);
967 call_event_handlers(doc, event_obj, doc->node.event_target, &doc->basedoc.cp_container, eid,
968 (IDispatch*)&doc->basedoc.IHTMLDocument2_iface);
972 FIXME("unimplemented node type %d\n", node_type);
976 nsIDOMNode_Release(nsnode);
979 IHTMLEventObj_Release(event_obj);
980 doc->basedoc.window->event = prev_event;
983 HRESULT dispatch_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_obj, VARIANT_BOOL *cancelled)
987 eid = attr_to_eid(event_name);
988 if(eid == EVENTID_LAST) {
989 WARN("unknown event %s\n", debugstr_w(event_name));
993 if(event_obj && V_VT(event_obj) != VT_EMPTY && V_VT(event_obj) != VT_ERROR)
994 FIXME("event_obj not implemented\n");
996 if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
997 FIXME("not EVENT_DEFAULTEVENTHANDLER\n");
1001 fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
1003 *cancelled = VARIANT_TRUE; /* FIXME */
1007 HRESULT call_event(HTMLDOMNode *node, eventid_t eid)
1011 if(node->vtbl->call_event) {
1012 BOOL handled = FALSE;
1014 hres = node->vtbl->call_event(node, eid, &handled);
1019 fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
1023 static inline event_target_t *get_event_target(event_target_t **event_target_ptr)
1025 if(!*event_target_ptr)
1026 *event_target_ptr = heap_alloc_zero(sizeof(event_target_t));
1027 return *event_target_ptr;
1030 static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt)
1032 handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid];
1034 if(handler_vector) {
1035 if(cnt <= handler_vector->handler_cnt)
1038 new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1040 new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1046 new_vector->handler_cnt = cnt;
1047 event_target->event_table[eid] = new_vector;
1051 static HRESULT ensure_nsevent_handler(HTMLDocumentNode *doc, event_target_t *event_target, nsIDOMNode *nsnode, eventid_t eid)
1056 if(event_info[eid].flags & EVENT_NODEHANDLER) {
1059 mask = get_node_handler_mask(eid);
1060 if(event_target->node_handlers_mask & mask)
1063 add_nsevent_listener(doc, nsnode, event_info[eid].name);
1064 event_target->node_handlers_mask |= mask;
1068 if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER))
1071 if(!doc->event_vector) {
1072 doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
1073 if(!doc->event_vector)
1074 return E_OUTOFMEMORY;
1077 if(!doc->event_vector[eid]) {
1078 doc->event_vector[eid] = TRUE;
1079 add_nsevent_listener(doc, NULL, event_info[eid].name);
1085 static HRESULT remove_event_handler(event_target_t **event_target, eventid_t eid)
1087 if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1088 IDispatch_Release((*event_target)->event_table[eid]->handler_prop);
1089 (*event_target)->event_table[eid]->handler_prop = NULL;
1095 static HRESULT set_event_handler_disp(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocumentNode *doc,
1096 eventid_t eid, IDispatch *disp)
1098 event_target_t *event_target;
1101 return remove_event_handler(event_target_ptr, eid);
1103 event_target = get_event_target(event_target_ptr);
1105 return E_OUTOFMEMORY;
1107 if(!alloc_handler_vector(event_target, eid, 0))
1108 return E_OUTOFMEMORY;
1110 if(event_target->event_table[eid]->handler_prop)
1111 IDispatch_Release(event_target->event_table[eid]->handler_prop);
1113 event_target->event_table[eid]->handler_prop = disp;
1114 IDispatch_AddRef(disp);
1116 return ensure_nsevent_handler(doc, event_target, nsnode, eid);
1119 HRESULT set_event_handler(event_target_t **event_target, nsIDOMNode *nsnode, HTMLDocumentNode *doc, eventid_t eid, VARIANT *var)
1123 return remove_event_handler(event_target, eid);
1126 return set_event_handler_disp(event_target, nsnode, doc, eid, V_DISPATCH(var));
1129 FIXME("not supported vt=%d\n", V_VT(var));
1137 HRESULT get_event_handler(event_target_t **event_target, eventid_t eid, VARIANT *var)
1139 if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1140 V_VT(var) = VT_DISPATCH;
1141 V_DISPATCH(var) = (*event_target)->event_table[eid]->handler_prop;
1142 IDispatch_AddRef(V_DISPATCH(var));
1144 V_VT(var) = VT_NULL;
1150 HRESULT attach_event(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocument *doc, BSTR name,
1151 IDispatch *disp, VARIANT_BOOL *res)
1153 event_target_t *event_target;
1157 eid = attr_to_eid(name);
1158 if(eid == EVENTID_LAST) {
1159 WARN("Unknown event\n");
1160 *res = VARIANT_TRUE;
1164 event_target = get_event_target(event_target_ptr);
1166 return E_OUTOFMEMORY;
1168 if(event_target->event_table[eid]) {
1169 while(i < event_target->event_table[eid]->handler_cnt && event_target->event_table[eid]->handlers[i])
1171 if(i == event_target->event_table[eid]->handler_cnt && !alloc_handler_vector(event_target, eid, i+1))
1172 return E_OUTOFMEMORY;
1173 }else if(!alloc_handler_vector(event_target, eid, i+1)) {
1174 return E_OUTOFMEMORY;
1177 IDispatch_AddRef(disp);
1178 event_target->event_table[eid]->handlers[i] = disp;
1180 *res = VARIANT_TRUE;
1181 return ensure_nsevent_handler(doc->doc_node, event_target, nsnode, eid);
1184 HRESULT detach_event(event_target_t *event_target, HTMLDocument *doc, BSTR name, IDispatch *disp)
1192 eid = attr_to_eid(name);
1193 if(eid == EVENTID_LAST) {
1194 WARN("Unknown event\n");
1198 if(!event_target->event_table[eid])
1201 while(i < event_target->event_table[eid]->handler_cnt) {
1202 if(event_target->event_table[eid]->handlers[i] == disp) {
1203 IDispatch_Release(event_target->event_table[eid]->handlers[i]);
1204 event_target->event_table[eid]->handlers[i] = NULL;
1212 void update_cp_events(HTMLWindow *window, event_target_t **event_target_ptr, cp_static_data_t *cp, nsIDOMNode *nsnode)
1214 event_target_t *event_target;
1217 event_target = get_event_target(event_target_ptr);
1221 for(i=0; i < EVENTID_LAST; i++) {
1222 if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
1223 ensure_nsevent_handler(window->doc, event_target, nsnode, i);
1227 void check_event_attr(HTMLDocumentNode *doc, nsIDOMElement *nselem)
1229 const PRUnichar *attr_value;
1230 nsAString attr_name_str, attr_value_str;
1237 nsAString_Init(&attr_value_str, NULL);
1238 nsAString_Init(&attr_name_str, NULL);
1240 for(i=0; i < EVENTID_LAST; i++) {
1241 nsAString_SetData(&attr_name_str, event_info[i].attr_name);
1242 nsres = nsIDOMElement_GetAttribute(nselem, &attr_name_str, &attr_value_str);
1243 if(NS_SUCCEEDED(nsres)) {
1244 nsAString_GetData(&attr_value_str, &attr_value);
1248 TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
1250 disp = script_parse_event(doc->basedoc.window, attr_value);
1252 hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
1254 set_event_handler_disp(get_node_event_target(node), node->nsnode, node->doc, i, disp);
1255 IDispatch_Release(disp);
1260 nsAString_Finish(&attr_value_str);
1261 nsAString_Finish(&attr_name_str);
1264 void release_event_target(event_target_t *event_target)
1268 for(i=0; i < EVENTID_LAST; i++) {
1269 if(event_target->event_table[i]) {
1270 if(event_target->event_table[i]->handler_prop)
1271 IDispatch_Release(event_target->event_table[i]->handler_prop);
1272 for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
1273 IDispatch_Release(event_target->event_table[i]->handlers[j]);
1277 heap_free(event_target);