/* * Copyright 2008-2009 Jacek Caban for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include #include #define COBJMACROS #include "windef.h" #include "winbase.h" #include "winuser.h" #include "ole2.h" #include "mshtmdid.h" #include "mshtml_private.h" #include "htmlevent.h" #include "htmlscript.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(mshtml); typedef struct { IDispatch *handler_prop; DWORD handler_cnt; IDispatch *handlers[0]; } handler_vector_t; struct event_target_t { handler_vector_t *event_table[EVENTID_LAST]; }; static const WCHAR abortW[] = {'a','b','o','r','t',0}; static const WCHAR onabortW[] = {'o','n','a','b','o','r','t',0}; static const WCHAR beforeunloadW[] = {'b','e','f','o','r','e','u','n','l','o','a','d',0}; static const WCHAR onbeforeunloadW[] = {'o','n','b','e','f','o','r','e','u','n','l','o','a','d',0}; static const WCHAR blurW[] = {'b','l','u','r',0}; static const WCHAR onblurW[] = {'o','n','b','l','u','r',0}; static const WCHAR changeW[] = {'c','h','a','n','g','e',0}; static const WCHAR onchangeW[] = {'o','n','c','h','a','n','g','e',0}; static const WCHAR clickW[] = {'c','l','i','c','k',0}; static const WCHAR onclickW[] = {'o','n','c','l','i','c','k',0}; static const WCHAR contextmenuW[] = {'c','o','n','t','e','x','t','m','e','n','u',0}; static const WCHAR oncontextmenuW[] = {'o','n','c','o','n','t','e','x','t','m','e','n','u',0}; static const WCHAR dataavailableW[] = {'d','a','t','a','a','v','a','i','l','a','b','l','e',0}; static const WCHAR ondataavailableW[] = {'o','n','d','a','t','a','a','v','a','i','l','a','b','l','e',0}; static const WCHAR dblclickW[] = {'d','b','l','c','l','i','c','k',0}; static const WCHAR ondblclickW[] = {'o','n','d','b','l','c','l','i','c','k',0}; static const WCHAR dragW[] = {'d','r','a','g',0}; static const WCHAR ondragW[] = {'o','n','d','r','a','g',0}; static const WCHAR dragstartW[] = {'d','r','a','g','s','t','a','r','t',0}; static const WCHAR ondragstartW[] = {'o','n','d','r','a','g','s','t','a','r','t',0}; static const WCHAR errorW[] = {'e','r','r','o','r',0}; static const WCHAR onerrorW[] = {'o','n','e','r','r','o','r',0}; static const WCHAR focusW[] = {'f','o','c','u','s',0}; static const WCHAR onfocusW[] = {'o','n','f','o','c','u','s',0}; static const WCHAR helpW[] = {'h','e','l','p',0}; static const WCHAR onhelpW[] = {'o','n','h','e','l','p',0}; static const WCHAR keydownW[] = {'k','e','y','d','o','w','n',0}; static const WCHAR onkeydownW[] = {'o','n','k','e','y','d','o','w','n',0}; static const WCHAR keypressW[] = {'k','e','y','p','r','e','s','s',0}; static const WCHAR onkeypressW[] = {'o','n','k','e','y','p','r','e','s','s',0}; static const WCHAR keyupW[] = {'k','e','y','u','p',0}; static const WCHAR onkeyupW[] = {'o','n','k','e','y','u','p',0}; static const WCHAR loadW[] = {'l','o','a','d',0}; static const WCHAR onloadW[] = {'o','n','l','o','a','d',0}; static const WCHAR mousedownW[] = {'m','o','u','s','e','d','o','w','n',0}; static const WCHAR onmousedownW[] = {'o','n','m','o','u','s','e','d','o','w','n',0}; static const WCHAR mousemoveW[] = {'m','o','u','s','e','m','o','v','e',0}; static const WCHAR onmousemoveW[] = {'o','n','m','o','u','s','e','m','o','v','e',0}; static const WCHAR mouseoutW[] = {'m','o','u','s','e','o','u','t',0}; static const WCHAR onmouseoutW[] = {'o','n','m','o','u','s','e','o','u','t',0}; static const WCHAR mouseoverW[] = {'m','o','u','s','e','o','v','e','r',0}; static const WCHAR onmouseoverW[] = {'o','n','m','o','u','s','e','o','v','e','r',0}; static const WCHAR mouseupW[] = {'m','o','u','s','e','u','p',0}; static const WCHAR onmouseupW[] = {'o','n','m','o','u','s','e','u','p',0}; static const WCHAR pasteW[] = {'p','a','s','t','e',0}; static const WCHAR onpasteW[] = {'o','n','p','a','s','t','e',0}; static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0}; static const WCHAR onreadystatechangeW[] = {'o','n','r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0}; static const WCHAR resizeW[] = {'r','e','s','i','z','e',0}; static const WCHAR onresizeW[] = {'o','n','r','e','s','i','z','e',0}; static const WCHAR scrollW[] = {'s','c','r','o','l','l',0}; static const WCHAR onscrollW[] = {'o','n','s','c','r','o','l','l',0}; static const WCHAR selectstartW[] = {'s','e','l','e','c','t','s','t','a','r','t',0}; static const WCHAR onselectstartW[] = {'o','n','s','e','l','e','c','t','s','t','a','r','t',0}; static const WCHAR submitW[] = {'s','u','b','m','i','t',0}; static const WCHAR onsubmitW[] = {'o','n','s','u','b','m','i','t',0}; static const WCHAR HTMLEventsW[] = {'H','T','M','L','E','v','e','n','t','s',0}; static const WCHAR KeyboardEventW[] = {'K','e','y','b','o','a','r','d','E','v','e','n','t',0}; static const WCHAR MouseEventW[] = {'M','o','u','s','e','E','v','e','n','t',0}; enum { EVENTT_NONE, EVENTT_HTML, EVENTT_KEY, EVENTT_MOUSE }; static const WCHAR *event_types[] = { NULL, HTMLEventsW, KeyboardEventW, MouseEventW }; typedef struct { LPCWSTR name; LPCWSTR attr_name; DWORD type; DISPID dispid; DWORD flags; } event_info_t; #define EVENT_DEFAULTLISTENER 0x0001 #define EVENT_BUBBLE 0x0002 #define EVENT_FORWARDBODY 0x0004 #define EVENT_BIND_TO_BODY 0x0008 #define EVENT_CANCELABLE 0x0010 #define EVENT_HASDEFAULTHANDLERS 0x0020 static const event_info_t event_info[] = { {abortW, onabortW, EVENTT_NONE, DISPID_EVMETH_ONABORT, EVENT_BIND_TO_BODY}, {beforeunloadW, onbeforeunloadW, EVENTT_NONE, DISPID_EVMETH_ONBEFOREUNLOAD, EVENT_DEFAULTLISTENER|EVENT_FORWARDBODY}, {blurW, onblurW, EVENTT_HTML, DISPID_EVMETH_ONBLUR, EVENT_DEFAULTLISTENER}, {changeW, onchangeW, EVENTT_HTML, DISPID_EVMETH_ONCHANGE, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {clickW, onclickW, EVENTT_MOUSE, DISPID_EVMETH_ONCLICK, EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE|EVENT_HASDEFAULTHANDLERS}, {contextmenuW, oncontextmenuW, EVENTT_MOUSE, DISPID_EVMETH_ONCONTEXTMENU, EVENT_BUBBLE|EVENT_CANCELABLE}, {dataavailableW, ondataavailableW, EVENTT_NONE, DISPID_EVMETH_ONDATAAVAILABLE, EVENT_BUBBLE}, {dblclickW, ondblclickW, EVENTT_MOUSE, DISPID_EVMETH_ONDBLCLICK, EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE}, {dragW, ondragW, EVENTT_MOUSE, DISPID_EVMETH_ONDRAG, EVENT_CANCELABLE}, {dragstartW, ondragstartW, EVENTT_MOUSE, DISPID_EVMETH_ONDRAGSTART, EVENT_CANCELABLE}, {errorW, onerrorW, EVENTT_NONE, DISPID_EVMETH_ONERROR, EVENT_BIND_TO_BODY}, {focusW, onfocusW, EVENTT_HTML, DISPID_EVMETH_ONFOCUS, EVENT_DEFAULTLISTENER}, {helpW, onhelpW, EVENTT_KEY, DISPID_EVMETH_ONHELP, EVENT_BUBBLE|EVENT_CANCELABLE}, {keydownW, onkeydownW, EVENTT_KEY, DISPID_EVMETH_ONKEYDOWN, EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_HASDEFAULTHANDLERS}, {keypressW, onkeypressW, EVENTT_KEY, DISPID_EVMETH_ONKEYPRESS, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {keyupW, onkeyupW, EVENTT_KEY, DISPID_EVMETH_ONKEYUP, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {loadW, onloadW, EVENTT_HTML, DISPID_EVMETH_ONLOAD, EVENT_BIND_TO_BODY}, {mousedownW, onmousedownW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEDOWN, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {mousemoveW, onmousemoveW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEMOVE, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {mouseoutW, onmouseoutW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEOUT, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {mouseoverW, onmouseoverW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEOVER, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {mouseupW, onmouseupW, EVENTT_MOUSE, DISPID_EVMETH_ONMOUSEUP, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {pasteW, onpasteW, EVENTT_NONE, DISPID_EVMETH_ONPASTE, EVENT_CANCELABLE}, {readystatechangeW, onreadystatechangeW, EVENTT_NONE, DISPID_EVMETH_ONREADYSTATECHANGE, 0}, {resizeW, onresizeW, EVENTT_NONE, DISPID_EVMETH_ONRESIZE, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {scrollW, onscrollW, EVENTT_HTML, DISPID_EVMETH_ONSCROLL, EVENT_DEFAULTLISTENER|EVENT_BUBBLE}, {selectstartW, onselectstartW, EVENTT_MOUSE, DISPID_EVMETH_ONSELECTSTART, EVENT_CANCELABLE}, {submitW, onsubmitW, EVENTT_HTML, DISPID_EVMETH_ONSUBMIT, EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE|EVENT_HASDEFAULTHANDLERS} }; eventid_t str_to_eid(LPCWSTR str) { int i; for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) { if(!strcmpW(event_info[i].name, str)) return i; } ERR("unknown type %s\n", debugstr_w(str)); return EVENTID_LAST; } static eventid_t attr_to_eid(LPCWSTR str) { int i; for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) { if(!strcmpW(event_info[i].attr_name, str)) return i; } return EVENTID_LAST; } typedef struct { DispatchEx dispex; IHTMLEventObj IHTMLEventObj_iface; LONG ref; HTMLDOMNode *target; const event_info_t *type; nsIDOMEvent *nsevent; BOOL prevent_default; BOOL cancel_bubble; } HTMLEventObj; static inline HTMLEventObj *impl_from_IHTMLEventObj(IHTMLEventObj *iface) { return CONTAINING_RECORD(iface, HTMLEventObj, IHTMLEventObj_iface); } static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv); if(IsEqualGUID(&IID_IUnknown, riid)) { *ppv = &This->IHTMLEventObj_iface; }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) { *ppv = &This->IHTMLEventObj_iface; }else if(dispex_query_interface(&This->dispex, riid, ppv)) { return *ppv ? S_OK : E_NOINTERFACE; }else { *ppv = NULL; WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv); return E_NOINTERFACE; } IUnknown_AddRef((IUnknown*)*ppv); return S_OK; } static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); LONG ref = InterlockedIncrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); return ref; } static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); LONG ref = InterlockedDecrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); if(!ref) { if(This->target) IHTMLDOMNode_Release(&This->target->IHTMLDOMNode_iface); if(This->nsevent) nsIDOMEvent_Release(This->nsevent); release_dispex(&This->dispex); heap_free(This); } return ref; } static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo); } static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo); } static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames, lcid, rgDispId); } static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); } static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); TRACE("(%p)->(%p)\n", This, p); *p = NULL; if(This->target) IHTMLDOMNode_QueryInterface(&This->target->IHTMLDOMNode_iface, &IID_IHTMLElement, (void**)p); return S_OK; } static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); cpp_bool ret = FALSE; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMKeyEvent *key_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event); if(NS_SUCCEEDED(nsres)) { nsIDOMKeyEvent_GetAltKey(key_event, &ret); nsIDOMKeyEvent_Release(key_event); }else { nsIDOMMouseEvent *mouse_event; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event); if(NS_SUCCEEDED(nsres)) { nsIDOMMouseEvent_GetAltKey(mouse_event, &ret); nsIDOMMouseEvent_Release(mouse_event); } } } *p = ret ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); cpp_bool ret = FALSE; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMKeyEvent *key_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event); if(NS_SUCCEEDED(nsres)) { nsIDOMKeyEvent_GetCtrlKey(key_event, &ret); nsIDOMKeyEvent_Release(key_event); }else { nsIDOMMouseEvent *mouse_event; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event); if(NS_SUCCEEDED(nsres)) { nsIDOMMouseEvent_GetCtrlKey(mouse_event, &ret); nsIDOMMouseEvent_Release(mouse_event); } } } *p = ret ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); cpp_bool ret = FALSE; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMKeyEvent *key_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event); if(NS_SUCCEEDED(nsres)) { nsIDOMKeyEvent_GetShiftKey(key_event, &ret); nsIDOMKeyEvent_Release(key_event); }else { nsIDOMMouseEvent *mouse_event; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event); if(NS_SUCCEEDED(nsres)) { nsIDOMMouseEvent_GetShiftKey(mouse_event, &ret); nsIDOMMouseEvent_Release(mouse_event); } } } *p = ret ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; } static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); TRACE("(%p)->(%s)\n", This, debugstr_variant(&v)); if(V_VT(&v) != VT_BOOL) { FIXME("unsupported value %s\n", debugstr_variant(&v)); return DISP_E_BADVARTYPE; } if(!V_BOOL(&v)) This->prevent_default = TRUE; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); FIXME("(%p)->(%p)\n", This, p); V_VT(p) = VT_EMPTY; return S_OK; } static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); TRACE("(%p)->(%x)\n", This, v); This->cancel_bubble = !!v; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); TRACE("(%p)->(%p)\n", This, p); *p = This->cancel_bubble ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); FIXME("(%p)->(%p)\n", This, p); *p = NULL; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); FIXME("(%p)->(%p)\n", This, p); *p = NULL; return S_OK; } static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); FIXME("(%p)->(%d)\n", This, v); return E_NOTIMPL; } static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); UINT32 key_code = 0; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMKeyEvent *key_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event); if(NS_SUCCEEDED(nsres)) { nsIDOMKeyEvent_GetKeyCode(key_event, &key_code); nsIDOMKeyEvent_Release(key_event); } } *p = key_code; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); UINT16 button = 0; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMMouseEvent *mouse_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event); if(NS_SUCCEEDED(nsres)) { nsIDOMMouseEvent_GetButton(mouse_event, &button); nsIDOMMouseEvent_Release(mouse_event); } } *p = button; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); TRACE("(%p)->(%p)\n", This, p); if(!This->type) { *p = NULL; return S_OK; } *p = SysAllocString(This->type->name); return *p ? S_OK : E_OUTOFMEMORY; } static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); FIXME("(%p)->(%p)\n", This, p); *p = NULL; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); FIXME("(%p)->(%p)\n", This, p); *p = 0; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); LONG x = 0; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMUIEvent *ui_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMUIEvent, (void**)&ui_event); if(NS_SUCCEEDED(nsres)) { /* NOTE: pageX is not exactly right here. */ nsres = nsIDOMUIEvent_GetPageX(ui_event, &x); assert(nsres == NS_OK); nsIDOMUIEvent_Release(ui_event); } } *p = x; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); LONG y = 0; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMUIEvent *ui_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMUIEvent, (void**)&ui_event); if(NS_SUCCEEDED(nsres)) { /* NOTE: pageY is not exactly right here. */ nsres = nsIDOMUIEvent_GetPageY(ui_event, &y); assert(nsres == NS_OK); nsIDOMUIEvent_Release(ui_event); } } *p = y; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); LONG x = 0; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMMouseEvent *mouse_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event); if(NS_SUCCEEDED(nsres)) { nsIDOMMouseEvent_GetClientX(mouse_event, &x); nsIDOMMouseEvent_Release(mouse_event); } } *p = x; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); LONG y = 0; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMMouseEvent *mouse_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event); if(NS_SUCCEEDED(nsres)) { nsIDOMMouseEvent_GetClientY(mouse_event, &y); nsIDOMMouseEvent_Release(mouse_event); } } *p = y; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); FIXME("(%p)->(%p)\n", This, p); *p = 0; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); FIXME("(%p)->(%p)\n", This, p); *p = 0; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); LONG x = 0; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMMouseEvent *mouse_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event); if(NS_SUCCEEDED(nsres)) { nsIDOMMouseEvent_GetScreenX(mouse_event, &x); nsIDOMMouseEvent_Release(mouse_event); } } *p = x; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); LONG y = 0; TRACE("(%p)->(%p)\n", This, p); if(This->nsevent) { nsIDOMMouseEvent *mouse_event; nsresult nsres; nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event); if(NS_SUCCEEDED(nsres)) { nsIDOMMouseEvent_GetScreenY(mouse_event, &y); nsIDOMMouseEvent_Release(mouse_event); } } *p = y; return S_OK; } static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p) { HTMLEventObj *This = impl_from_IHTMLEventObj(iface); FIXME("(%p)->(%p)\n", This, p); *p = NULL; return S_OK; } static const IHTMLEventObjVtbl HTMLEventObjVtbl = { HTMLEventObj_QueryInterface, HTMLEventObj_AddRef, HTMLEventObj_Release, HTMLEventObj_GetTypeInfoCount, HTMLEventObj_GetTypeInfo, HTMLEventObj_GetIDsOfNames, HTMLEventObj_Invoke, HTMLEventObj_get_srcElement, HTMLEventObj_get_altKey, HTMLEventObj_get_ctrlKey, HTMLEventObj_get_shiftKey, HTMLEventObj_put_returnValue, HTMLEventObj_get_returnValue, HTMLEventObj_put_cancelBubble, HTMLEventObj_get_cancelBubble, HTMLEventObj_get_fromElement, HTMLEventObj_get_toElement, HTMLEventObj_put_keyCode, HTMLEventObj_get_keyCode, HTMLEventObj_get_button, HTMLEventObj_get_type, HTMLEventObj_get_qualifier, HTMLEventObj_get_reason, HTMLEventObj_get_x, HTMLEventObj_get_y, HTMLEventObj_get_clientX, HTMLEventObj_get_clientY, HTMLEventObj_get_offsetX, HTMLEventObj_get_offsetY, HTMLEventObj_get_screenX, HTMLEventObj_get_screenY, HTMLEventObj_get_srcFilter }; static inline HTMLEventObj *unsafe_impl_from_IHTMLEventObj(IHTMLEventObj *iface) { return iface->lpVtbl == &HTMLEventObjVtbl ? impl_from_IHTMLEventObj(iface) : NULL; } static const tid_t HTMLEventObj_iface_tids[] = { IHTMLEventObj_tid, 0 }; static dispex_static_data_t HTMLEventObj_dispex = { NULL, DispCEventObj_tid, NULL, HTMLEventObj_iface_tids }; static HTMLEventObj *create_event(void) { HTMLEventObj *ret; ret = heap_alloc_zero(sizeof(*ret)); if(!ret) return NULL; ret->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl; ret->ref = 1; init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLEventObj_iface, &HTMLEventObj_dispex); return ret; } static HRESULT set_event_info(HTMLEventObj *event, HTMLDOMNode *target, eventid_t eid, nsIDOMEvent *nsevent) { event->type = event_info+eid; event->nsevent = nsevent; if(nsevent) { nsIDOMEvent_AddRef(nsevent); }else if(event_types[event_info[eid].type]) { nsAString type_str; nsresult nsres; nsAString_InitDepend(&type_str, event_types[event_info[eid].type]); nsres = nsIDOMHTMLDocument_CreateEvent(target->doc->nsdoc, &type_str, &event->nsevent); nsAString_Finish(&type_str); if(NS_FAILED(nsres)) { ERR("Could not create event: %08x\n", nsres); return E_FAIL; } } event->target = target; if(target) IHTMLDOMNode_AddRef(&target->IHTMLDOMNode_iface); return S_OK; } HRESULT create_event_obj(IHTMLEventObj **ret) { HTMLEventObj *event; event = create_event(); if(!event) return E_OUTOFMEMORY; *ret = &event->IHTMLEventObj_iface; return S_OK; } static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv) { IDispatchEx *dispex; EXCEPINFO ei; HRESULT hres; memset(&ei, 0, sizeof(ei)); hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(SUCCEEDED(hres)) { hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL); IDispatchEx_Release(dispex); }else { TRACE("Could not get IDispatchEx interface: %08x\n", hres); hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL); } return hres; } static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, HTMLEventObj *event_obj, VARIANT *retv) { DISPPARAMS dp = {NULL,NULL,0,0}; VARIANT event_arg; ULONG argerr; EXCEPINFO ei; if(event_obj) { V_VT(&event_arg) = VT_DISPATCH; V_DISPATCH(&event_arg) = (IDispatch*)&event_obj->IHTMLEventObj_iface; dp.rgvarg = &event_arg; dp.cArgs = 1; } memset(&ei, 0, sizeof(ei)); return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr); } static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid) { int min, max, i; HRESULT hres; if(!data) return FALSE; if(!data->ids) { hres = get_dispids(data->tid, &data->id_cnt, &data->ids); if(FAILED(hres)) return FALSE; } min = 0; max = data->id_cnt-1; while(min <= max) { i = (min+max)/2; if(data->ids[i] == dispid) return TRUE; if(data->ids[i] < dispid) min = i+1; else max = i-1; } return FALSE; } static void call_event_handlers(HTMLDocumentNode *doc, HTMLEventObj *event_obj, event_target_t *event_target, ConnectionPointContainer *cp_container, eventid_t eid, IDispatch *this_obj) { const BOOL cancelable = event_info[eid].flags & EVENT_CANCELABLE; handler_vector_t *handler_vector = NULL; VARIANT v; HRESULT hres; if(event_target) handler_vector = event_target->event_table[eid]; if(handler_vector && handler_vector->handler_prop) { DISPID named_arg = DISPID_THIS; VARIANTARG arg; DISPPARAMS dp = {&arg, &named_arg, 1, 1}; V_VT(&arg) = VT_DISPATCH; V_DISPATCH(&arg) = this_obj; V_VT(&v) = VT_EMPTY; TRACE("%s >>>\n", debugstr_w(event_info[eid].name)); hres = call_disp_func(handler_vector->handler_prop, &dp, &v); if(hres == S_OK) { TRACE("%s <<< %s\n", debugstr_w(event_info[eid].name), debugstr_variant(&v)); if(cancelable) { if(V_VT(&v) == VT_BOOL) { if(!V_BOOL(&v)) event_obj->prevent_default = TRUE; }else if(V_VT(&v) != VT_EMPTY) { FIXME("unhandled result %s\n", debugstr_variant(&v)); } } VariantClear(&v); }else { WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres); } } if(handler_vector && handler_vector->handler_cnt) { VARIANTARG arg; DISPPARAMS dp = {&arg, NULL, 1, 0}; int i; V_VT(&arg) = VT_DISPATCH; V_DISPATCH(&arg) = (IDispatch*)event_obj; i = handler_vector->handler_cnt; while(i--) { if(handler_vector->handlers[i]) { V_VT(&v) = VT_EMPTY; TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i); hres = call_disp_func(handler_vector->handlers[i], &dp, &v); if(hres == S_OK) { TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i); if(cancelable) { if(V_VT(&v) == VT_BOOL) { if(!V_BOOL(&v)) event_obj->prevent_default = TRUE; }else if(V_VT(&v) != VT_EMPTY) { FIXME("unhandled result %s\n", debugstr_variant(&v)); } } VariantClear(&v); }else { WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres); } } } } /* * NOTE: CP events may require doc_obj reference, which we don't own. We make sure that * it's safe to call event handler by checking nsevent_listener, which is NULL for * detached documents. */ if(cp_container && cp_container->forward_container) cp_container = cp_container->forward_container; if(cp_container && cp_container->cps && doc->nsevent_listener) { ConnectionPoint *cp; unsigned i, j; for(j=0; cp_container->cp_entries[j].riid; j++) { cp = cp_container->cps + j; if(!cp->sinks_size || !is_cp_event(cp->data, event_info[eid].dispid)) continue; for(i=0; doc->nsevent_listener && i < cp->sinks_size; i++) { if(!cp->sinks[i].disp) continue; V_VT(&v) = VT_EMPTY; TRACE("cp %s [%u] >>>\n", debugstr_w(event_info[eid].name), i); hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid, cp->data->pass_event_arg ? event_obj : NULL, &v); if(hres == S_OK) { TRACE("cp %s [%u] <<<\n", debugstr_w(event_info[eid].name), i); if(cancelable) { if(V_VT(&v) == VT_BOOL) { if(!V_BOOL(&v)) event_obj->prevent_default = TRUE; }else if(V_VT(&v) != VT_EMPTY) { FIXME("unhandled result %s\n", debugstr_variant(&v)); } } VariantClear(&v); }else { WARN("cp %s [%u] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres); } } if(!doc->nsevent_listener) break; } } } static void fire_event_obj(HTMLDocumentNode *doc, eventid_t eid, HTMLEventObj *event_obj, nsIDOMNode *target, IDispatch *script_this) { IHTMLEventObj *prev_event; nsIDOMNode *parent, *nsnode; BOOL prevent_default = FALSE; HTMLInnerWindow *window; HTMLDOMNode *node; UINT16 node_type; nsresult nsres; HRESULT hres; TRACE("(%p) %s\n", doc, debugstr_w(event_info[eid].name)); window = doc->window; if(!window) { WARN("NULL window\n"); return; } htmldoc_addref(&doc->basedoc); prev_event = window->event; window->event = event_obj ? &event_obj->IHTMLEventObj_iface : NULL; nsIDOMNode_GetNodeType(target, &node_type); nsnode = target; nsIDOMNode_AddRef(nsnode); switch(node_type) { case ELEMENT_NODE: do { hres = get_node(doc, nsnode, FALSE, &node); if(SUCCEEDED(hres) && node) { call_event_handlers(doc, event_obj, *get_node_event_target(node), node->cp_container, eid, script_this ? script_this : (IDispatch*)&node->IHTMLDOMNode_iface); node_release(node); } if(!(event_info[eid].flags & EVENT_BUBBLE) || (event_obj && event_obj->cancel_bubble)) break; nsIDOMNode_GetParentNode(nsnode, &parent); nsIDOMNode_Release(nsnode); nsnode = parent; if(!nsnode) break; nsIDOMNode_GetNodeType(nsnode, &node_type); }while(node_type == ELEMENT_NODE); if(!(event_info[eid].flags & EVENT_BUBBLE) || (event_obj && event_obj->cancel_bubble)) break; case DOCUMENT_NODE: if(event_info[eid].flags & EVENT_FORWARDBODY) { nsIDOMHTMLElement *nsbody; nsresult nsres; nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody); if(NS_SUCCEEDED(nsres) && nsbody) { hres = get_node(doc, (nsIDOMNode*)nsbody, FALSE, &node); if(SUCCEEDED(hres) && node) { call_event_handlers(doc, event_obj, *get_node_event_target(node), node->cp_container, eid, script_this ? script_this : (IDispatch*)&node->IHTMLDOMNode_iface); node_release(node); } nsIDOMHTMLElement_Release(nsbody); }else { ERR("Could not get body: %08x\n", nsres); } } call_event_handlers(doc, event_obj, doc->node.event_target, &doc->basedoc.cp_container, eid, script_this ? script_this : (IDispatch*)&doc->basedoc.IHTMLDocument2_iface); break; default: FIXME("unimplemented node type %d\n", node_type); } if(nsnode) nsIDOMNode_Release(nsnode); if(event_obj && event_obj->prevent_default) prevent_default = TRUE; window->event = prev_event; if(!prevent_default && (event_info[eid].flags & EVENT_HASDEFAULTHANDLERS)) { nsIDOMNode_AddRef(target); nsnode = target; do { hres = get_node(doc, nsnode, TRUE, &node); if(FAILED(hres)) break; if(node) { if(node->vtbl->handle_event) hres = node->vtbl->handle_event(node, eid, event_obj ? event_obj->nsevent : NULL, &prevent_default); node_release(node); if(FAILED(hres) || prevent_default || (event_obj && event_obj->cancel_bubble)) break; } nsres = nsIDOMNode_GetParentNode(nsnode, &parent); if(NS_FAILED(nsres)) break; nsIDOMNode_Release(nsnode); nsnode = parent; } while(nsnode); if(nsnode) nsIDOMNode_Release(nsnode); } if(prevent_default && event_obj && event_obj->nsevent) { TRACE("calling PreventDefault\n"); nsIDOMEvent_PreventDefault(event_obj->nsevent); } htmldoc_release(&doc->basedoc); } void fire_event(HTMLDocumentNode *doc, eventid_t eid, BOOL set_event, nsIDOMNode *target, nsIDOMEvent *nsevent, IDispatch *script_this) { HTMLEventObj *event_obj = NULL; HTMLDOMNode *node; HRESULT hres; if(set_event) { hres = get_node(doc, target, TRUE, &node); if(FAILED(hres)) return; event_obj = create_event(); node_release(node); if(!event_obj) return; hres = set_event_info(event_obj, node, eid, nsevent); if(FAILED(hres)) { IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface); return; } } fire_event_obj(doc, eid, event_obj, target, script_this); if(event_obj) IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface); } HRESULT dispatch_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_var, VARIANT_BOOL *cancelled) { HTMLEventObj *event_obj = NULL; eventid_t eid; HRESULT hres; eid = attr_to_eid(event_name); if(eid == EVENTID_LAST) { WARN("unknown event %s\n", debugstr_w(event_name)); return E_INVALIDARG; } if(event_var && V_VT(event_var) != VT_EMPTY && V_VT(event_var) != VT_ERROR) { if(V_VT(event_var) != VT_DISPATCH) { FIXME("event_var %s not supported\n", debugstr_variant(event_var)); return E_NOTIMPL; } if(V_DISPATCH(event_var)) { IHTMLEventObj *event_iface; hres = IDispatch_QueryInterface(V_DISPATCH(event_var), &IID_IHTMLEventObj, (void**)&event_iface); if(FAILED(hres)) { FIXME("No IHTMLEventObj iface\n"); return hres; } event_obj = unsafe_impl_from_IHTMLEventObj(event_iface); if(!event_obj) { ERR("Not our IHTMLEventObj?\n"); IHTMLEventObj_Release(event_iface); return E_FAIL; } } } if(event_obj) { hres = set_event_info(event_obj, node, eid, NULL); if(SUCCEEDED(hres)) fire_event_obj(node->doc, eid, event_obj, node->nsnode, NULL); IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface); if(FAILED(hres)) return hres; }else { if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) { FIXME("not EVENT_DEFAULTEVENTHANDLER\n"); return E_NOTIMPL; } fire_event(node->doc, eid, TRUE, node->nsnode, NULL, NULL); } *cancelled = VARIANT_TRUE; /* FIXME */ return S_OK; } HRESULT call_fire_event(HTMLDOMNode *node, eventid_t eid) { HRESULT hres; if(node->vtbl->fire_event) { BOOL handled = FALSE; hres = node->vtbl->fire_event(node, eid, &handled); if(handled) return hres; } fire_event(node->doc, eid, TRUE, node->nsnode, NULL, NULL); return S_OK; } static inline event_target_t *get_event_target(event_target_t **event_target_ptr) { if(!*event_target_ptr) *event_target_ptr = heap_alloc_zero(sizeof(event_target_t)); return *event_target_ptr; } static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt) { handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid]; if(handler_vector) { if(cnt <= handler_vector->handler_cnt) return TRUE; new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt); }else { new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt); } if(!new_vector) return FALSE; new_vector->handler_cnt = cnt; event_target->event_table[eid] = new_vector; return TRUE; } static HRESULT ensure_nsevent_handler(HTMLDocumentNode *doc, event_target_t *event_target, eventid_t eid) { nsIDOMNode *nsnode = NULL; TRACE("%s\n", debugstr_w(event_info[eid].name)); if(!doc->nsdoc || doc->event_vector[eid] || !(event_info[eid].flags & (EVENT_DEFAULTLISTENER|EVENT_BIND_TO_BODY))) return S_OK; if(event_info[eid].flags & EVENT_BIND_TO_BODY) { nsnode = doc->node.nsnode; nsIDOMNode_AddRef(nsnode); } doc->event_vector[eid] = TRUE; add_nsevent_listener(doc, nsnode, event_info[eid].name); if(nsnode) nsIDOMNode_Release(nsnode); return S_OK; } void detach_events(HTMLDocumentNode *doc) { if(doc->event_vector) { int i; for(i=0; i < EVENTID_LAST; i++) { if(doc->event_vector[i]) { detach_nsevent(doc, event_info[i].name); doc->event_vector[i] = FALSE; } } } release_nsevents(doc); } static HRESULT remove_event_handler(event_target_t **event_target, eventid_t eid) { if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) { IDispatch_Release((*event_target)->event_table[eid]->handler_prop); (*event_target)->event_table[eid]->handler_prop = NULL; } return S_OK; } static HRESULT set_event_handler_disp(event_target_t **event_target_ptr, HTMLDocumentNode *doc, eventid_t eid, IDispatch *disp) { event_target_t *event_target; if(!disp) return remove_event_handler(event_target_ptr, eid); event_target = get_event_target(event_target_ptr); if(!event_target) return E_OUTOFMEMORY; if(!alloc_handler_vector(event_target, eid, 0)) return E_OUTOFMEMORY; if(event_target->event_table[eid]->handler_prop) IDispatch_Release(event_target->event_table[eid]->handler_prop); event_target->event_table[eid]->handler_prop = disp; IDispatch_AddRef(disp); return ensure_nsevent_handler(doc, event_target, eid); } HRESULT set_event_handler(event_target_t **event_target, HTMLDocumentNode *doc, eventid_t eid, VARIANT *var) { switch(V_VT(var)) { case VT_NULL: return remove_event_handler(event_target, eid); case VT_DISPATCH: return set_event_handler_disp(event_target, doc, eid, V_DISPATCH(var)); default: FIXME("not handler %s\n", debugstr_variant(var)); /* fall through */ case VT_EMPTY: return E_NOTIMPL; } return S_OK; } HRESULT get_event_handler(event_target_t **event_target, eventid_t eid, VARIANT *var) { if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) { V_VT(var) = VT_DISPATCH; V_DISPATCH(var) = (*event_target)->event_table[eid]->handler_prop; IDispatch_AddRef(V_DISPATCH(var)); }else { V_VT(var) = VT_NULL; } return S_OK; } HRESULT attach_event(event_target_t **event_target_ptr, HTMLDocument *doc, BSTR name, IDispatch *disp, VARIANT_BOOL *res) { event_target_t *event_target; eventid_t eid; DWORD i = 0; eid = attr_to_eid(name); if(eid == EVENTID_LAST) { WARN("Unknown event\n"); *res = VARIANT_TRUE; return S_OK; } event_target = get_event_target(event_target_ptr); if(!event_target) return E_OUTOFMEMORY; if(event_target->event_table[eid]) { while(i < event_target->event_table[eid]->handler_cnt && event_target->event_table[eid]->handlers[i]) i++; if(i == event_target->event_table[eid]->handler_cnt && !alloc_handler_vector(event_target, eid, i+1)) return E_OUTOFMEMORY; }else if(!alloc_handler_vector(event_target, eid, i+1)) { return E_OUTOFMEMORY; } IDispatch_AddRef(disp); event_target->event_table[eid]->handlers[i] = disp; *res = VARIANT_TRUE; return ensure_nsevent_handler(doc->doc_node, event_target, eid); } HRESULT detach_event(event_target_t *event_target, HTMLDocument *doc, BSTR name, IDispatch *disp) { eventid_t eid; DWORD i = 0; if(!event_target) return S_OK; eid = attr_to_eid(name); if(eid == EVENTID_LAST) { WARN("Unknown event\n"); return S_OK; } if(!event_target->event_table[eid]) return S_OK; while(i < event_target->event_table[eid]->handler_cnt) { if(event_target->event_table[eid]->handlers[i] == disp) { IDispatch_Release(event_target->event_table[eid]->handlers[i]); event_target->event_table[eid]->handlers[i] = NULL; } i++; } return S_OK; } void bind_node_event(HTMLDocumentNode *doc, event_target_t **event_target, HTMLDOMNode *node, const WCHAR *event, IDispatch *disp) { eventid_t eid; TRACE("(%p %p %p %s %p)\n", doc, event_target, node, debugstr_w(event), disp); eid = attr_to_eid(event); if(eid == EVENTID_LAST) { WARN("Unsupported event %s\n", debugstr_w(event)); return; } set_event_handler_disp(event_target, doc, eid, disp); } void update_cp_events(HTMLInnerWindow *window, event_target_t **event_target_ptr, cp_static_data_t *cp) { event_target_t *event_target; int i; event_target = get_event_target(event_target_ptr); if(!event_target) return; /* FIXME */ for(i=0; i < EVENTID_LAST; i++) { if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid)) ensure_nsevent_handler(window->doc, event_target, i); } } void check_event_attr(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem) { const PRUnichar *attr_value; nsAString attr_value_str; IDispatch *disp; HTMLDOMNode *node; int i; nsresult nsres; HRESULT hres; for(i=0; i < EVENTID_LAST; i++) { nsres = get_elem_attr_value(nselem, event_info[i].attr_name, &attr_value_str, &attr_value); if(NS_SUCCEEDED(nsres)) { if(!*attr_value) continue; TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value)); disp = script_parse_event(doc->window, attr_value); if(disp) { hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node); if(SUCCEEDED(hres)) { set_event_handler_disp(get_node_event_target(node), node->doc, i, disp); node_release(node); } IDispatch_Release(disp); } nsAString_Finish(&attr_value_str); } } } HRESULT doc_init_events(HTMLDocumentNode *doc) { unsigned i; HRESULT hres; doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL)); if(!doc->event_vector) return E_OUTOFMEMORY; init_nsevents(doc); for(i=0; i < EVENTID_LAST; i++) { if(event_info[i].flags & EVENT_HASDEFAULTHANDLERS) { hres = ensure_nsevent_handler(doc, NULL, i); if(FAILED(hres)) return hres; } } return S_OK; } void release_event_target(event_target_t *event_target) { int i; unsigned int j; for(i=0; i < EVENTID_LAST; i++) { if(event_target->event_table[i]) { if(event_target->event_table[i]->handler_prop) IDispatch_Release(event_target->event_table[i]->handler_prop); for(j=0; j < event_target->event_table[i]->handler_cnt; j++) if(event_target->event_table[i]->handlers[j]) IDispatch_Release(event_target->event_table[i]->handlers[j]); } } heap_free(event_target); }