git.oblomov.eu Git - wine/blob - dlls/mshtml/htmlevent.c

   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
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27 #include "mshtmdid.h"
  28
  29 #include "mshtml_private.h"
  30 #include "htmlevent.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  35
  36 typedef struct {
  37     IDispatch *handler_prop;
  38     DWORD handler_cnt;
  39     IDispatch *handlers[0];
  40 } handler_vector_t;
  41
  42 struct event_target_t {
  43     DWORD node_handlers_mask;
  44     handler_vector_t *event_table[EVENTID_LAST];
  45 };
  46
  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};
  49
  50 static const WCHAR blurW[] = {'b','l','u','r',0};
  51 static const WCHAR onblurW[] = {'o','n','b','l','u','r',0};
  52
  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};
  55
  56 static const WCHAR clickW[] = {'c','l','i','c','k',0};
  57 static const WCHAR onclickW[] = {'o','n','c','l','i','c','k',0};
  58
  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};
  61
  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};
  64
  65 static const WCHAR dragW[] = {'d','r','a','g',0};
  66 static const WCHAR ondragW[] = {'o','n','d','r','a','g',0};
  67
  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};
  70
  71 static const WCHAR focusW[] = {'f','o','c','u','s',0};
  72 static const WCHAR onfocusW[] = {'o','n','f','o','c','u','s',0};
  73
  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};
  76
  77 static const WCHAR keyupW[] = {'k','e','y','u','p',0};
  78 static const WCHAR onkeyupW[] = {'o','n','k','e','y','u','p',0};
  79
  80 static const WCHAR loadW[] = {'l','o','a','d',0};
  81 static const WCHAR onloadW[] = {'o','n','l','o','a','d',0};
  82
  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};
  85
  86 static const WCHAR mousemoveW[] = {'m','o','u','s','e','m','o','v','e',0};
  87 static const WCHAR onmousemoveW[] = {'o','n','m','o','u','s','e','m','o','v','e',0};
  88
  89 static const WCHAR mouseoutW[] = {'m','o','u','s','e','o','u','t',0};
  90 static const WCHAR onmouseoutW[] = {'o','n','m','o','u','s','e','o','u','t',0};
  91
  92 static const WCHAR mouseoverW[] = {'m','o','u','s','e','o','v','e','r',0};
  93 static const WCHAR onmouseoverW[] = {'o','n','m','o','u','s','e','o','v','e','r',0};
  94
  95 static const WCHAR mouseupW[] = {'m','o','u','s','e','u','p',0};
  96 static const WCHAR onmouseupW[] = {'o','n','m','o','u','s','e','u','p',0};
  97
  98 static const WCHAR pasteW[] = {'p','a','s','t','e',0};
  99 static const WCHAR onpasteW[] = {'o','n','p','a','s','t','e',0};
 100
 101 static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
 102 static const WCHAR onreadystatechangeW[] = {'o','n','r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
 103
 104 static const WCHAR resizeW[] = {'r','e','s','i','z','e',0};
 105 static const WCHAR onresizeW[] = {'o','n','r','e','s','i','z','e',0};
 106
 107 static const WCHAR selectstartW[] = {'s','e','l','e','c','t','s','t','a','r','t',0};
 108 static const WCHAR onselectstartW[] = {'o','n','s','e','l','e','c','t','s','t','a','r','t',0};
 109
 110 static const WCHAR submitW[] = {'s','u','b','m','i','t',0};
 111 static const WCHAR onsubmitW[] = {'o','n','s','u','b','m','i','t',0};
 112
 113 static const WCHAR HTMLEventsW[] = {'H','T','M','L','E','v','e','n','t','s',0};
 114 static const WCHAR KeyboardEventW[] = {'K','e','y','b','o','a','r','d','E','v','e','n','t',0};
 115 static const WCHAR MouseEventW[] = {'M','o','u','s','e','E','v','e','n','t',0};
 116
 117 enum {
 118     EVENTT_NONE,
 119     EVENTT_HTML,
 120     EVENTT_KEY,
 121     EVENTT_MOUSE
 122 };
 123
 124 static const WCHAR *event_types[] = {
 125     NULL,
 126     HTMLEventsW,
 127     KeyboardEventW,
 128     MouseEventW
 129 };
 130
 131 typedef struct {
 132     LPCWSTR name;
 133     LPCWSTR attr_name;
 134     DWORD type;
 135     DISPID dispid;
 136     DWORD flags;
 137 } event_info_t;
 138
 139 #define EVENT_DEFAULTLISTENER    0x0001
 140 #define EVENT_BUBBLE             0x0002
 141 #define EVENT_FORWARDBODY        0x0004
 142 #define EVENT_NODEHANDLER        0x0008
 143 #define EVENT_CANCELABLE         0x0010
 144 #define EVENT_HASDEFAULTHANDLERS 0x0020
 145
 146 static const event_info_t event_info[] = {
 147     {beforeunloadW,      onbeforeunloadW,      EVENTT_NONE,   DISPID_EVMETH_ONBEFOREUNLOAD,
 148         EVENT_DEFAULTLISTENER|EVENT_FORWARDBODY},
 149     {blurW,              onblurW,              EVENTT_HTML,   DISPID_EVMETH_ONBLUR,
 150         EVENT_DEFAULTLISTENER},
 151     {changeW,            onchangeW,            EVENTT_HTML,   DISPID_EVMETH_ONCHANGE,
 152         EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 153     {clickW,             onclickW,             EVENTT_MOUSE,  DISPID_EVMETH_ONCLICK,
 154         EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE|EVENT_HASDEFAULTHANDLERS},
 155     {contextmenuW,       oncontextmenuW,       EVENTT_MOUSE,  DISPID_EVMETH_ONCONTEXTMENU,
 156         EVENT_BUBBLE|EVENT_CANCELABLE},
 157     {dblclickW,          ondblclickW,          EVENTT_MOUSE,  DISPID_EVMETH_ONDBLCLICK,
 158         EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE},
 159     {dragW,              ondragW,              EVENTT_MOUSE,  DISPID_EVMETH_ONDRAG,
 160         EVENT_CANCELABLE},
 161     {dragstartW,         ondragstartW,         EVENTT_MOUSE,  DISPID_EVMETH_ONDRAGSTART,
 162         EVENT_CANCELABLE},
 163     {focusW,             onfocusW,             EVENTT_HTML,   DISPID_EVMETH_ONFOCUS,
 164         EVENT_DEFAULTLISTENER},
 165     {keydownW,           onkeydownW,           EVENTT_KEY,    DISPID_EVMETH_ONKEYDOWN,
 166         EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 167     {keyupW,             onkeyupW,             EVENTT_KEY,    DISPID_EVMETH_ONKEYUP,
 168         EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 169     {loadW,              onloadW,              EVENTT_HTML,   DISPID_EVMETH_ONLOAD,
 170         EVENT_NODEHANDLER},
 171     {mousedownW,         onmousedownW,         EVENTT_MOUSE,  DISPID_EVMETH_ONMOUSEDOWN,
 172         EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 173     {mousemoveW,         onmousemoveW,         EVENTT_MOUSE,  DISPID_EVMETH_ONMOUSEMOVE,
 174         EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 175     {mouseoutW,          onmouseoutW,          EVENTT_MOUSE,  DISPID_EVMETH_ONMOUSEOUT,
 176         EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 177     {mouseoverW,         onmouseoverW,         EVENTT_MOUSE,  DISPID_EVMETH_ONMOUSEOVER,
 178         EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 179     {mouseupW,           onmouseupW,           EVENTT_MOUSE,  DISPID_EVMETH_ONMOUSEUP,
 180         EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 181     {pasteW,             onpasteW,             EVENTT_NONE,   DISPID_EVMETH_ONPASTE,
 182         EVENT_CANCELABLE},
 183     {readystatechangeW,  onreadystatechangeW,  EVENTT_NONE,   DISPID_EVMETH_ONREADYSTATECHANGE,
 184         0},
 185     {resizeW,            onresizeW,            EVENTT_NONE,   DISPID_EVMETH_ONRESIZE,
 186         EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 187     {selectstartW,       onselectstartW,       EVENTT_MOUSE,  DISPID_EVMETH_ONSELECTSTART,
 188         EVENT_CANCELABLE},
 189     {submitW,            onsubmitW,            EVENTT_HTML,   DISPID_EVMETH_ONSUBMIT,
 190         EVENT_DEFAULTLISTENER|EVENT_BUBBLE|EVENT_CANCELABLE}
 191 };
 192
 193 static const eventid_t node_handled_list[] = { EVENTID_LOAD };
 194
 195 eventid_t str_to_eid(LPCWSTR str)
 196 {
 197     int i;
 198
 199     for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
 200         if(!strcmpW(event_info[i].name, str))
 201             return i;
 202     }
 203
 204     ERR("unknown type %s\n", debugstr_w(str));
 205     return EVENTID_LAST;
 206 }
 207
 208 static eventid_t attr_to_eid(LPCWSTR str)
 209 {
 210     int i;
 211
 212     for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
 213         if(!strcmpW(event_info[i].attr_name, str))
 214             return i;
 215     }
 216
 217     return EVENTID_LAST;
 218 }
 219
 220 static DWORD get_node_handler_mask(eventid_t eid)
 221 {
 222     DWORD i;
 223
 224     for(i=0; i<sizeof(node_handled_list)/sizeof(*node_handled_list); i++) {
 225         if(node_handled_list[i] == eid)
 226             return 1 << i;
 227     }
 228
 229     ERR("Invalid eid %d\n", eid);
 230     return ~0;
 231 }
 232
 233 typedef struct {
 234     DispatchEx dispex;
 235     IHTMLEventObj IHTMLEventObj_iface;
 236
 237     LONG ref;
 238
 239     HTMLDOMNode *target;
 240     const event_info_t *type;
 241     nsIDOMEvent *nsevent;
 242     BOOL prevent_default;
 243 } HTMLEventObj;
 244
 245 static inline HTMLEventObj *impl_from_IHTMLEventObj(IHTMLEventObj *iface)
 246 {
 247     return CONTAINING_RECORD(iface, HTMLEventObj, IHTMLEventObj_iface);
 248 }
 249
 250 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
 251 {
 252     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 253
 254     *ppv = NULL;
 255
 256     if(IsEqualGUID(&IID_IUnknown, riid)) {
 257         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 258         *ppv = &This->IHTMLEventObj_iface;
 259     }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) {
 260         TRACE("(%p)->(IID_IHTMLEventObj %p)\n", This, ppv);
 261         *ppv = &This->IHTMLEventObj_iface;
 262     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 263         return *ppv ? S_OK : E_NOINTERFACE;
 264     }
 265
 266     if(*ppv) {
 267         IUnknown_AddRef((IUnknown*)*ppv);
 268         return S_OK;
 269     }
 270
 271     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 272     return E_NOINTERFACE;
 273 }
 274
 275 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
 276 {
 277     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 278     LONG ref = InterlockedIncrement(&This->ref);
 279
 280     TRACE("(%p) ref=%d\n", This, ref);
 281
 282     return ref;
 283 }
 284
 285 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
 286 {
 287     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 288     LONG ref = InterlockedDecrement(&This->ref);
 289
 290     TRACE("(%p) ref=%d\n", This, ref);
 291
 292     if(!ref) {
 293         if(This->target)
 294             IHTMLDOMNode_Release(&This->target->IHTMLDOMNode_iface);
 295         if(This->nsevent)
 296             nsIDOMEvent_Release(This->nsevent);
 297         release_dispex(&This->dispex);
 298         heap_free(This);
 299     }
 300
 301     return ref;
 302 }
 303
 304 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
 305 {
 306     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 307     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 308 }
 309
 310 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
 311                                               LCID lcid, ITypeInfo **ppTInfo)
 312 {
 313     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 314     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 315 }
 316
 317 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
 318                                                 LPOLESTR *rgszNames, UINT cNames,
 319                                                 LCID lcid, DISPID *rgDispId)
 320 {
 321     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 322     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 323             lcid, rgDispId);
 324 }
 325
 326 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
 327                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 328                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 329 {
 330     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 331     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 332             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 333 }
 334
 335 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
 336 {
 337     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 338
 339     TRACE("(%p)->(%p)\n", This, p);
 340
 341     return IHTMLDOMNode_QueryInterface(&This->target->IHTMLDOMNode_iface, &IID_IHTMLElement,
 342             (void**)p);
 343 }
 344
 345 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 346 {
 347     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 348     PRBool ret = FALSE;
 349
 350     TRACE("(%p)->(%p)\n", This, p);
 351
 352     if(This->nsevent) {
 353         nsIDOMKeyEvent *key_event;
 354         nsresult nsres;
 355
 356         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 357         if(NS_SUCCEEDED(nsres)) {
 358             nsIDOMKeyEvent_GetAltKey(key_event, &ret);
 359             nsIDOMKeyEvent_Release(key_event);
 360         }else {
 361             nsIDOMMouseEvent *mouse_event;
 362
 363             nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 364             if(NS_SUCCEEDED(nsres)) {
 365                 nsIDOMMouseEvent_GetAltKey(mouse_event, &ret);
 366                 nsIDOMMouseEvent_Release(mouse_event);
 367             }
 368         }
 369     }
 370
 371     *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
 372     return S_OK;
 373 }
 374
 375 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 376 {
 377     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 378     PRBool ret = FALSE;
 379
 380     TRACE("(%p)->(%p)\n", This, p);
 381
 382     if(This->nsevent) {
 383         nsIDOMKeyEvent *key_event;
 384         nsresult nsres;
 385
 386         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 387         if(NS_SUCCEEDED(nsres)) {
 388             nsIDOMKeyEvent_GetCtrlKey(key_event, &ret);
 389             nsIDOMKeyEvent_Release(key_event);
 390         }else {
 391             nsIDOMMouseEvent *mouse_event;
 392
 393             nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 394             if(NS_SUCCEEDED(nsres)) {
 395                 nsIDOMMouseEvent_GetCtrlKey(mouse_event, &ret);
 396                 nsIDOMMouseEvent_Release(mouse_event);
 397             }
 398         }
 399     }
 400
 401     *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
 402     return S_OK;
 403 }
 404
 405 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 406 {
 407     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 408     PRBool ret = FALSE;
 409
 410     TRACE("(%p)->(%p)\n", This, p);
 411
 412     if(This->nsevent) {
 413         nsIDOMKeyEvent *key_event;
 414         nsresult nsres;
 415
 416         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 417         if(NS_SUCCEEDED(nsres)) {
 418             nsIDOMKeyEvent_GetShiftKey(key_event, &ret);
 419             nsIDOMKeyEvent_Release(key_event);
 420         }else {
 421             nsIDOMMouseEvent *mouse_event;
 422
 423             nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 424             if(NS_SUCCEEDED(nsres)) {
 425                 nsIDOMMouseEvent_GetShiftKey(mouse_event, &ret);
 426                 nsIDOMMouseEvent_Release(mouse_event);
 427             }
 428         }
 429     }
 430
 431     *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
 432     return S_OK;
 433 }
 434
 435 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
 436 {
 437     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 438
 439     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 440
 441     if(V_VT(&v) != VT_BOOL) {
 442         FIXME("unsupported vt %d\n", V_VT(&v));
 443         return DISP_E_BADVARTYPE;
 444     }
 445
 446     if(!V_BOOL(&v))
 447         This->prevent_default = TRUE;
 448     return S_OK;
 449 }
 450
 451 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
 452 {
 453     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 454
 455     FIXME("(%p)->(%p)\n", This, p);
 456
 457     V_VT(p) = VT_EMPTY;
 458     return S_OK;
 459 }
 460
 461 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
 462 {
 463     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 464     FIXME("(%p)->(%x)\n", This, v);
 465     return E_NOTIMPL;
 466 }
 467
 468 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
 469 {
 470     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 471
 472     FIXME("(%p)->(%p)\n", This, p);
 473
 474     *p = VARIANT_FALSE;
 475     return S_OK;
 476 }
 477
 478 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
 479 {
 480     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 481
 482     FIXME("(%p)->(%p)\n", This, p);
 483
 484     *p = NULL;
 485     return S_OK;
 486 }
 487
 488 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
 489 {
 490     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 491
 492     FIXME("(%p)->(%p)\n", This, p);
 493
 494     *p = NULL;
 495     return S_OK;
 496 }
 497
 498 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
 499 {
 500     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 501     FIXME("(%p)->(%d)\n", This, v);
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
 506 {
 507     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 508     PRUint32 key_code = 0;
 509
 510     TRACE("(%p)->(%p)\n", This, p);
 511
 512     if(This->nsevent) {
 513         nsIDOMKeyEvent *key_event;
 514         nsresult nsres;
 515
 516         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 517         if(NS_SUCCEEDED(nsres)) {
 518             nsIDOMKeyEvent_GetKeyCode(key_event, &key_code);
 519             nsIDOMKeyEvent_Release(key_event);
 520         }
 521     }
 522
 523     *p = key_code;
 524     return S_OK;
 525 }
 526
 527 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
 528 {
 529     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 530     PRUint16 button = 0;
 531
 532     TRACE("(%p)->(%p)\n", This, p);
 533
 534     if(This->nsevent) {
 535         nsIDOMMouseEvent *mouse_event;
 536         nsresult nsres;
 537
 538         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 539         if(NS_SUCCEEDED(nsres)) {
 540             nsIDOMMouseEvent_GetButton(mouse_event, &button);
 541             nsIDOMMouseEvent_Release(mouse_event);
 542         }
 543     }
 544
 545     *p = button;
 546     return S_OK;
 547 }
 548
 549 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
 550 {
 551     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 552
 553     TRACE("(%p)->(%p)\n", This, p);
 554
 555     *p = SysAllocString(This->type->name);
 556     return *p ? S_OK : E_OUTOFMEMORY;
 557 }
 558
 559 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
 560 {
 561     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 562
 563     FIXME("(%p)->(%p)\n", This, p);
 564
 565     *p = NULL;
 566     return S_OK;
 567 }
 568
 569 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
 570 {
 571     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 572
 573     FIXME("(%p)->(%p)\n", This, p);
 574
 575     *p = 0;
 576     return S_OK;
 577 }
 578
 579 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
 580 {
 581     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 582
 583     FIXME("(%p)->(%p)\n", This, p);
 584
 585     *p = -1;
 586     return S_OK;
 587 }
 588
 589 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
 590 {
 591     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 592
 593     FIXME("(%p)->(%p)\n", This, p);
 594
 595     *p = -1;
 596     return S_OK;
 597 }
 598
 599 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
 600 {
 601     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 602     PRInt32 x = 0;
 603
 604     TRACE("(%p)->(%p)\n", This, p);
 605
 606     if(This->nsevent) {
 607         nsIDOMMouseEvent *mouse_event;
 608         nsresult nsres;
 609
 610         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 611         if(NS_SUCCEEDED(nsres)) {
 612             nsIDOMMouseEvent_GetClientX(mouse_event, &x);
 613             nsIDOMMouseEvent_Release(mouse_event);
 614         }
 615     }
 616
 617     *p = x;
 618     return S_OK;
 619 }
 620
 621 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
 622 {
 623     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 624     PRInt32 y = 0;
 625
 626     TRACE("(%p)->(%p)\n", This, p);
 627
 628     if(This->nsevent) {
 629         nsIDOMMouseEvent *mouse_event;
 630         nsresult nsres;
 631
 632         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 633         if(NS_SUCCEEDED(nsres)) {
 634             nsIDOMMouseEvent_GetClientY(mouse_event, &y);
 635             nsIDOMMouseEvent_Release(mouse_event);
 636         }
 637     }
 638
 639     *p = y;
 640     return S_OK;
 641 }
 642
 643 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
 644 {
 645     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 646
 647     FIXME("(%p)->(%p)\n", This, p);
 648
 649     *p = 0;
 650     return S_OK;
 651 }
 652
 653 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p)
 654 {
 655     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 656
 657     FIXME("(%p)->(%p)\n", This, p);
 658
 659     *p = 0;
 660     return S_OK;
 661 }
 662
 663 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p)
 664 {
 665     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 666     PRInt32 x = 0;
 667
 668     TRACE("(%p)->(%p)\n", This, p);
 669
 670     if(This->nsevent) {
 671         nsIDOMMouseEvent *mouse_event;
 672         nsresult nsres;
 673
 674         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 675         if(NS_SUCCEEDED(nsres)) {
 676             nsIDOMMouseEvent_GetScreenX(mouse_event, &x);
 677             nsIDOMMouseEvent_Release(mouse_event);
 678         }
 679     }
 680
 681     *p = x;
 682     return S_OK;
 683 }
 684
 685 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
 686 {
 687     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 688     PRInt32 y = 0;
 689
 690     TRACE("(%p)->(%p)\n", This, p);
 691
 692     if(This->nsevent) {
 693         nsIDOMMouseEvent *mouse_event;
 694         nsresult nsres;
 695
 696         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 697         if(NS_SUCCEEDED(nsres)) {
 698             nsIDOMMouseEvent_GetScreenY(mouse_event, &y);
 699             nsIDOMMouseEvent_Release(mouse_event);
 700         }
 701     }
 702
 703     *p = y;
 704     return S_OK;
 705 }
 706
 707 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
 708 {
 709     HTMLEventObj *This = impl_from_IHTMLEventObj(iface);
 710
 711     FIXME("(%p)->(%p)\n", This, p);
 712
 713     *p = NULL;
 714     return S_OK;
 715 }
 716
 717 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
 718     HTMLEventObj_QueryInterface,
 719     HTMLEventObj_AddRef,
 720     HTMLEventObj_Release,
 721     HTMLEventObj_GetTypeInfoCount,
 722     HTMLEventObj_GetTypeInfo,
 723     HTMLEventObj_GetIDsOfNames,
 724     HTMLEventObj_Invoke,
 725     HTMLEventObj_get_srcElement,
 726     HTMLEventObj_get_altKey,
 727     HTMLEventObj_get_ctrlKey,
 728     HTMLEventObj_get_shiftKey,
 729     HTMLEventObj_put_returnValue,
 730     HTMLEventObj_get_returnValue,
 731     HTMLEventObj_put_cancelBubble,
 732     HTMLEventObj_get_cancelBubble,
 733     HTMLEventObj_get_fromElement,
 734     HTMLEventObj_get_toElement,
 735     HTMLEventObj_put_keyCode,
 736     HTMLEventObj_get_keyCode,
 737     HTMLEventObj_get_button,
 738     HTMLEventObj_get_type,
 739     HTMLEventObj_get_qualifier,
 740     HTMLEventObj_get_reason,
 741     HTMLEventObj_get_x,
 742     HTMLEventObj_get_y,
 743     HTMLEventObj_get_clientX,
 744     HTMLEventObj_get_clientY,
 745     HTMLEventObj_get_offsetX,
 746     HTMLEventObj_get_offsetY,
 747     HTMLEventObj_get_screenX,
 748     HTMLEventObj_get_screenY,
 749     HTMLEventObj_get_srcFilter
 750 };
 751
 752 static const tid_t HTMLEventObj_iface_tids[] = {
 753     IHTMLEventObj_tid,
 754     0
 755 };
 756
 757 static dispex_static_data_t HTMLEventObj_dispex = {
 758     NULL,
 759     DispCEventObj_tid,
 760     NULL,
 761     HTMLEventObj_iface_tids
 762 };
 763
 764 static HTMLEventObj *create_event(HTMLDOMNode *target, eventid_t eid, nsIDOMEvent *nsevent)
 765 {
 766     HTMLEventObj *ret;
 767
 768     ret = heap_alloc_zero(sizeof(*ret));
 769     if(!ret)
 770         return NULL;
 771
 772     ret->IHTMLEventObj_iface.lpVtbl = &HTMLEventObjVtbl;
 773     ret->ref = 1;
 774     ret->type = event_info+eid;
 775
 776     ret->nsevent = nsevent;
 777     if(nsevent) {
 778         nsIDOMEvent_AddRef(nsevent);
 779     }else if(event_types[event_info[eid].type]) {
 780         nsIDOMDocumentEvent *doc_event;
 781         nsresult nsres;
 782
 783         nsres = nsIDOMHTMLDocument_QueryInterface(target->doc->nsdoc, &IID_nsIDOMDocumentEvent,
 784                  (void**)&doc_event);
 785         if(NS_SUCCEEDED(nsres)) {
 786             nsAString type_str;
 787
 788             nsAString_InitDepend(&type_str, event_types[event_info[eid].type]);
 789             nsres = nsIDOMDocumentEvent_CreateEvent(doc_event, &type_str, &ret->nsevent);
 790             nsAString_Finish(&type_str);
 791             nsIDOMDocumentEvent_Release(doc_event);
 792         }
 793         if(NS_FAILED(nsres)) {
 794             ERR("Could not create event: %08x\n", nsres);
 795             IHTMLEventObj_Release(&ret->IHTMLEventObj_iface);
 796             return NULL;
 797         }
 798     }
 799
 800     ret->target = target;
 801     IHTMLDOMNode_AddRef(&target->IHTMLDOMNode_iface);
 802
 803     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLEventObj_iface, &HTMLEventObj_dispex);
 804
 805     return ret;
 806 }
 807
 808 static HRESULT call_disp_func(IDispatch *disp, DISPPARAMS *dp, VARIANT *retv)
 809 {
 810     IDispatchEx *dispex;
 811     EXCEPINFO ei;
 812     HRESULT hres;
 813
 814     memset(&ei, 0, sizeof(ei));
 815
 816     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 817     if(SUCCEEDED(hres)) {
 818         hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, retv, &ei, NULL);
 819         IDispatchEx_Release(dispex);
 820     }else {
 821         TRACE("Could not get IDispatchEx interface: %08x\n", hres);
 822         hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,
 823                 dp, retv, &ei, NULL);
 824     }
 825
 826     return hres;
 827 }
 828
 829 static HRESULT call_cp_func(IDispatch *disp, DISPID dispid, VARIANT *retv)
 830 {
 831     DISPPARAMS dp = {NULL,NULL,0,0};
 832     ULONG argerr;
 833     EXCEPINFO ei;
 834
 835     memset(&ei, 0, sizeof(ei));
 836     return IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, retv, &ei, &argerr);
 837 }
 838
 839 static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid)
 840 {
 841     int min, max, i;
 842     HRESULT hres;
 843
 844     if(!data)
 845         return FALSE;
 846
 847     if(!data->ids) {
 848         hres = get_dispids(data->tid, &data->id_cnt, &data->ids);
 849         if(FAILED(hres))
 850             return FALSE;
 851     }
 852
 853     min = 0;
 854     max = data->id_cnt-1;
 855     while(min <= max) {
 856         i = (min+max)/2;
 857         if(data->ids[i] == dispid)
 858             return TRUE;
 859
 860         if(data->ids[i] < dispid)
 861             min = i+1;
 862         else
 863             max = i-1;
 864     }
 865
 866     return FALSE;
 867 }
 868
 869 static void call_event_handlers(HTMLDocumentNode *doc, HTMLEventObj *event_obj, event_target_t *event_target,
 870         ConnectionPointContainer *cp_container, eventid_t eid, IDispatch *this_obj)
 871 {
 872     const BOOL cancelable = event_info[eid].flags & EVENT_CANCELABLE;
 873     handler_vector_t *handler_vector = NULL;
 874     VARIANT v;
 875     int i;
 876     HRESULT hres;
 877
 878     if(event_target)
 879         handler_vector = event_target->event_table[eid];
 880
 881     if(handler_vector && handler_vector->handler_prop) {
 882         DISPID named_arg = DISPID_THIS;
 883         VARIANTARG arg;
 884         DISPPARAMS dp = {&arg, &named_arg, 1, 1};
 885
 886         V_VT(&arg) = VT_DISPATCH;
 887         V_DISPATCH(&arg) = this_obj;
 888         V_VT(&v) = VT_EMPTY;
 889
 890         TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
 891         hres = call_disp_func(handler_vector->handler_prop, &dp, &v);
 892         if(hres == S_OK) {
 893             TRACE("%s <<< %s\n", debugstr_w(event_info[eid].name), debugstr_variant(&v));
 894
 895             if(cancelable) {
 896                 if(V_VT(&v) == VT_BOOL) {
 897                     if(!V_BOOL(&v))
 898                         event_obj->prevent_default = TRUE;
 899                 }else if(V_VT(&v) != VT_EMPTY) {
 900                     FIXME("unhandled result %s\n", debugstr_variant(&v));
 901                 }
 902             }
 903             VariantClear(&v);
 904         }else {
 905             WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
 906         }
 907     }
 908
 909     if(handler_vector && handler_vector->handler_cnt) {
 910         VARIANTARG arg;
 911         DISPPARAMS dp = {&arg, NULL, 1, 0};
 912
 913         V_VT(&arg) = VT_DISPATCH;
 914         V_DISPATCH(&arg) = (IDispatch*)event_obj;
 915
 916         i = handler_vector->handler_cnt;
 917         while(i--) {
 918             if(handler_vector->handlers[i]) {
 919                 V_VT(&v) = VT_EMPTY;
 920
 921                 TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
 922                 hres = call_disp_func(handler_vector->handlers[i], &dp, &v);
 923                 if(hres == S_OK) {
 924                     TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
 925
 926                     if(cancelable) {
 927                         if(V_VT(&v) == VT_BOOL) {
 928                             if(!V_BOOL(&v))
 929                                 event_obj->prevent_default = TRUE;
 930                         }else if(V_VT(&v) != VT_EMPTY) {
 931                             FIXME("unhandled result %s\n", debugstr_variant(&v));
 932                         }
 933                     }
 934                     VariantClear(&v);
 935                 }else {
 936                     WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
 937                 }
 938             }
 939         }
 940     }
 941
 942     if(cp_container) {
 943         ConnectionPoint *cp;
 944
 945         if(cp_container->forward_container)
 946             cp_container = cp_container->forward_container;
 947
 948         for(cp = cp_container->cp_list; cp; cp = cp->next) {
 949             if(cp->sinks_size && is_cp_event(cp->data, event_info[eid].dispid)) {
 950                 for(i=0; i < cp->sinks_size; i++) {
 951                     if(!cp->sinks[i].disp)
 952                         continue;
 953
 954                     V_VT(&v) = VT_EMPTY;
 955
 956                     TRACE("cp %s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
 957                     hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid, &v);
 958                     if(hres == S_OK) {
 959                         TRACE("cp %s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
 960
 961                         if(cancelable) {
 962                             if(V_VT(&v) == VT_BOOL) {
 963                                 if(!V_BOOL(&v))
 964                                     event_obj->prevent_default = TRUE;
 965                             }else if(V_VT(&v) != VT_EMPTY) {
 966                                 FIXME("unhandled result %s\n", debugstr_variant(&v));
 967                             }
 968                         }
 969                         VariantClear(&v);
 970                     }else {
 971                         WARN("cp %s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
 972                     }
 973                 }
 974             }
 975         }
 976     }
 977 }
 978
 979 void fire_event(HTMLDocumentNode *doc, eventid_t eid, BOOL set_event, nsIDOMNode *target, nsIDOMEvent *nsevent)
 980 {
 981     HTMLEventObj *event_obj = NULL;
 982     IHTMLEventObj *prev_event;
 983     nsIDOMNode *parent, *nsnode;
 984     BOOL prevent_default = FALSE;
 985     HTMLDOMNode *node;
 986     PRUint16 node_type;
 987     nsresult nsres;
 988     HRESULT hres;
 989
 990     TRACE("(%p) %s\n", doc, debugstr_w(event_info[eid].name));
 991
 992     prev_event = doc->basedoc.window->event;
 993     if(set_event) {
 994         hres = get_node(doc, target, TRUE, &node);
 995         if(FAILED(hres))
 996             return;
 997
 998         event_obj = create_event(node, eid, nsevent);
 999         doc->basedoc.window->event = &event_obj->IHTMLEventObj_iface;
1000     }else {
1001         doc->basedoc.window->event = NULL;
1002     }
1003
1004     nsIDOMNode_GetNodeType(target, &node_type);
1005     nsnode = target;
1006     nsIDOMNode_AddRef(nsnode);
1007
1008     switch(node_type) {
1009     case ELEMENT_NODE:
1010         do {
1011             hres = get_node(doc, nsnode, FALSE, &node);
1012             if(SUCCEEDED(hres) && node)
1013                 call_event_handlers(doc, event_obj, *get_node_event_target(node),
1014                         node->cp_container, eid, (IDispatch*)&node->IHTMLDOMNode_iface);
1015
1016             if(!(event_info[eid].flags & EVENT_BUBBLE))
1017                 break;
1018
1019             nsIDOMNode_GetParentNode(nsnode, &parent);
1020             nsIDOMNode_Release(nsnode);
1021             nsnode = parent;
1022             if(!nsnode)
1023                 break;
1024
1025             nsIDOMNode_GetNodeType(nsnode, &node_type);
1026         }while(node_type == ELEMENT_NODE);
1027
1028         if(!(event_info[eid].flags & EVENT_BUBBLE))
1029             break;
1030
1031     case DOCUMENT_NODE:
1032         if(event_info[eid].flags & EVENT_FORWARDBODY) {
1033             nsIDOMHTMLElement *nsbody;
1034             nsresult nsres;
1035
1036             nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
1037             if(NS_SUCCEEDED(nsres) && nsbody) {
1038                 hres = get_node(doc, (nsIDOMNode*)nsbody, FALSE, &node);
1039                 if(SUCCEEDED(hres) && node)
1040                     call_event_handlers(doc, event_obj, *get_node_event_target(node),
1041                             node->cp_container, eid, (IDispatch*)&node->IHTMLDOMNode_iface);
1042                 nsIDOMHTMLElement_Release(nsbody);
1043             }else {
1044                 ERR("Could not get body: %08x\n", nsres);
1045             }
1046         }
1047
1048         call_event_handlers(doc, event_obj, doc->node.event_target, &doc->basedoc.cp_container, eid,
1049                 (IDispatch*)&doc->basedoc.IHTMLDocument2_iface);
1050         break;
1051
1052     default:
1053         FIXME("unimplemented node type %d\n", node_type);
1054     }
1055
1056     if(nsnode)
1057         nsIDOMNode_Release(nsnode);
1058
1059     if(event_obj && event_obj->prevent_default)
1060         prevent_default = TRUE;
1061     doc->basedoc.window->event = prev_event;
1062     if(event_obj)
1063         IHTMLEventObj_Release(&event_obj->IHTMLEventObj_iface);
1064
1065     if(!prevent_default && (event_info[eid].flags & EVENT_HASDEFAULTHANDLERS)) {
1066         nsIDOMNode_AddRef(target);
1067         nsnode = target;
1068
1069         do {
1070             hres = get_node(doc, nsnode, TRUE, &node);
1071             if(FAILED(hres))
1072                 break;
1073
1074             if(node && node->vtbl->handle_event) {
1075                 hres = node->vtbl->handle_event(node, eid, &prevent_default);
1076                 if(FAILED(hres) || prevent_default)
1077                     break;
1078             }
1079
1080             nsres = nsIDOMNode_GetParentNode(nsnode, &parent);
1081             if(NS_FAILED(nsres))
1082                 break;
1083
1084             nsIDOMNode_Release(nsnode);
1085             nsnode = parent;
1086         } while(nsnode);
1087
1088         if(nsnode)
1089             nsIDOMNode_Release(nsnode);
1090     }
1091
1092     if(prevent_default && nsevent) {
1093         TRACE("calling PreventDefault\n");
1094         nsIDOMEvent_PreventDefault(nsevent);
1095     }
1096 }
1097
1098 HRESULT dispatch_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_obj, VARIANT_BOOL *cancelled)
1099 {
1100     eventid_t eid;
1101
1102     eid = attr_to_eid(event_name);
1103     if(eid == EVENTID_LAST) {
1104         WARN("unknown event %s\n", debugstr_w(event_name));
1105         return E_INVALIDARG;
1106     }
1107
1108     if(event_obj && V_VT(event_obj) != VT_EMPTY && V_VT(event_obj) != VT_ERROR)
1109         FIXME("event_obj not implemented\n");
1110
1111     if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
1112         FIXME("not EVENT_DEFAULTEVENTHANDLER\n");
1113         return E_NOTIMPL;
1114     }
1115
1116     fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
1117
1118     *cancelled = VARIANT_TRUE; /* FIXME */
1119     return S_OK;
1120 }
1121
1122 HRESULT call_fire_event(HTMLDOMNode *node, eventid_t eid)
1123 {
1124     HRESULT hres;
1125
1126     if(node->vtbl->fire_event) {
1127         BOOL handled = FALSE;
1128
1129         hres = node->vtbl->fire_event(node, eid, &handled);
1130         if(handled)
1131             return hres;
1132     }
1133
1134     fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
1135     return S_OK;
1136 }
1137
1138 static inline event_target_t *get_event_target(event_target_t **event_target_ptr)
1139 {
1140     if(!*event_target_ptr)
1141         *event_target_ptr = heap_alloc_zero(sizeof(event_target_t));
1142     return *event_target_ptr;
1143 }
1144
1145 static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt)
1146 {
1147     handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid];
1148
1149     if(handler_vector) {
1150         if(cnt <= handler_vector->handler_cnt)
1151             return TRUE;
1152
1153         new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1154     }else {
1155         new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1156     }
1157
1158     if(!new_vector)
1159         return FALSE;
1160
1161     new_vector->handler_cnt = cnt;
1162     event_target->event_table[eid] = new_vector;
1163     return TRUE;
1164 }
1165
1166 static HRESULT ensure_nsevent_handler(HTMLDocumentNode *doc, event_target_t *event_target, nsIDOMNode *nsnode, eventid_t eid)
1167 {
1168     if(!doc->nsdoc)
1169         return S_OK;
1170
1171     if(event_info[eid].flags & EVENT_NODEHANDLER) {
1172         DWORD mask;
1173
1174         mask = get_node_handler_mask(eid);
1175         if(event_target->node_handlers_mask & mask)
1176             return S_OK;
1177
1178         add_nsevent_listener(doc, nsnode, event_info[eid].name);
1179         event_target->node_handlers_mask |= mask;
1180         return S_OK;
1181     }
1182
1183     if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER))
1184         return S_OK;
1185
1186     if(!doc->event_vector[eid]) {
1187         doc->event_vector[eid] = TRUE;
1188         add_nsevent_listener(doc, NULL, event_info[eid].name);
1189     }
1190
1191     return S_OK;
1192 }
1193
1194 static HRESULT remove_event_handler(event_target_t **event_target, eventid_t eid)
1195 {
1196     if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1197         IDispatch_Release((*event_target)->event_table[eid]->handler_prop);
1198         (*event_target)->event_table[eid]->handler_prop = NULL;
1199     }
1200
1201     return S_OK;
1202 }
1203
1204 static HRESULT set_event_handler_disp(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocumentNode *doc,
1205         eventid_t eid, IDispatch *disp)
1206 {
1207     event_target_t *event_target;
1208
1209     if(!disp)
1210         return remove_event_handler(event_target_ptr, eid);
1211
1212     event_target = get_event_target(event_target_ptr);
1213     if(!event_target)
1214         return E_OUTOFMEMORY;
1215
1216     if(!alloc_handler_vector(event_target, eid, 0))
1217         return E_OUTOFMEMORY;
1218
1219     if(event_target->event_table[eid]->handler_prop)
1220         IDispatch_Release(event_target->event_table[eid]->handler_prop);
1221
1222     event_target->event_table[eid]->handler_prop = disp;
1223     IDispatch_AddRef(disp);
1224
1225     return ensure_nsevent_handler(doc, event_target, nsnode, eid);
1226 }
1227
1228 HRESULT set_event_handler(event_target_t **event_target, nsIDOMNode *nsnode, HTMLDocumentNode *doc, eventid_t eid, VARIANT *var)
1229 {
1230     switch(V_VT(var)) {
1231     case VT_NULL:
1232         return remove_event_handler(event_target, eid);
1233
1234     case VT_DISPATCH:
1235         return set_event_handler_disp(event_target, nsnode, doc, eid, V_DISPATCH(var));
1236
1237     default:
1238         FIXME("not supported vt=%d\n", V_VT(var));
1239     case VT_EMPTY:
1240         return E_NOTIMPL;
1241     }
1242
1243     return S_OK;
1244 }
1245
1246 HRESULT get_event_handler(event_target_t **event_target, eventid_t eid, VARIANT *var)
1247 {
1248     if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1249         V_VT(var) = VT_DISPATCH;
1250         V_DISPATCH(var) = (*event_target)->event_table[eid]->handler_prop;
1251         IDispatch_AddRef(V_DISPATCH(var));
1252     }else {
1253         V_VT(var) = VT_NULL;
1254     }
1255
1256     return S_OK;
1257 }
1258
1259 HRESULT attach_event(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocument *doc, BSTR name,
1260         IDispatch *disp, VARIANT_BOOL *res)
1261 {
1262     event_target_t *event_target;
1263     eventid_t eid;
1264     DWORD i = 0;
1265
1266     eid = attr_to_eid(name);
1267     if(eid == EVENTID_LAST) {
1268         WARN("Unknown event\n");
1269         *res = VARIANT_TRUE;
1270         return S_OK;
1271     }
1272
1273     event_target = get_event_target(event_target_ptr);
1274     if(!event_target)
1275         return E_OUTOFMEMORY;
1276
1277     if(event_target->event_table[eid]) {
1278         while(i < event_target->event_table[eid]->handler_cnt && event_target->event_table[eid]->handlers[i])
1279             i++;
1280         if(i == event_target->event_table[eid]->handler_cnt && !alloc_handler_vector(event_target, eid, i+1))
1281             return E_OUTOFMEMORY;
1282     }else if(!alloc_handler_vector(event_target, eid, i+1)) {
1283         return E_OUTOFMEMORY;
1284     }
1285
1286     IDispatch_AddRef(disp);
1287     event_target->event_table[eid]->handlers[i] = disp;
1288
1289     *res = VARIANT_TRUE;
1290     return ensure_nsevent_handler(doc->doc_node, event_target, nsnode, eid);
1291 }
1292
1293 HRESULT detach_event(event_target_t *event_target, HTMLDocument *doc, BSTR name, IDispatch *disp)
1294 {
1295     eventid_t eid;
1296     DWORD i = 0;
1297
1298     if(!event_target)
1299         return S_OK;
1300
1301     eid = attr_to_eid(name);
1302     if(eid == EVENTID_LAST) {
1303         WARN("Unknown event\n");
1304         return S_OK;
1305     }
1306
1307     if(!event_target->event_table[eid])
1308         return S_OK;
1309
1310     while(i < event_target->event_table[eid]->handler_cnt) {
1311         if(event_target->event_table[eid]->handlers[i] == disp) {
1312             IDispatch_Release(event_target->event_table[eid]->handlers[i]);
1313             event_target->event_table[eid]->handlers[i] = NULL;
1314         }
1315         i++;
1316     }
1317
1318     return S_OK;
1319 }
1320
1321 void update_cp_events(HTMLWindow *window, event_target_t **event_target_ptr, cp_static_data_t *cp, nsIDOMNode *nsnode)
1322 {
1323     event_target_t *event_target;
1324     int i;
1325
1326     event_target = get_event_target(event_target_ptr);
1327     if(!event_target)
1328         return; /* FIXME */
1329
1330     for(i=0; i < EVENTID_LAST; i++) {
1331         if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
1332             ensure_nsevent_handler(window->doc, event_target, nsnode, i);
1333     }
1334 }
1335
1336 void check_event_attr(HTMLDocumentNode *doc, nsIDOMElement *nselem)
1337 {
1338     const PRUnichar *attr_value;
1339     nsAString attr_name_str, attr_value_str;
1340     IDispatch *disp;
1341     HTMLDOMNode *node;
1342     int i;
1343     nsresult nsres;
1344     HRESULT hres;
1345
1346     nsAString_Init(&attr_value_str, NULL);
1347     nsAString_Init(&attr_name_str, NULL);
1348
1349     for(i=0; i < EVENTID_LAST; i++) {
1350         nsAString_SetData(&attr_name_str, event_info[i].attr_name);
1351         nsres = nsIDOMElement_GetAttribute(nselem, &attr_name_str, &attr_value_str);
1352         if(NS_SUCCEEDED(nsres)) {
1353             nsAString_GetData(&attr_value_str, &attr_value);
1354             if(!*attr_value)
1355                 continue;
1356
1357             TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
1358
1359             disp = script_parse_event(doc->basedoc.window, attr_value);
1360             if(disp) {
1361                 hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
1362                 if(SUCCEEDED(hres))
1363                     set_event_handler_disp(get_node_event_target(node), node->nsnode, node->doc, i, disp);
1364                 IDispatch_Release(disp);
1365             }
1366         }
1367     }
1368
1369     nsAString_Finish(&attr_value_str);
1370     nsAString_Finish(&attr_name_str);
1371 }
1372
1373 HRESULT doc_init_events(HTMLDocumentNode *doc)
1374 {
1375     unsigned i;
1376     HRESULT hres;
1377
1378     doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
1379     if(!doc->event_vector)
1380         return E_OUTOFMEMORY;
1381
1382     init_nsevents(doc);
1383
1384     for(i=0; i < EVENTID_LAST; i++) {
1385         if(event_info[i].flags & EVENT_HASDEFAULTHANDLERS) {
1386             hres = ensure_nsevent_handler(doc, NULL, NULL, i);
1387             if(FAILED(hres))
1388                 return hres;
1389         }
1390     }
1391
1392     return S_OK;
1393 }
1394
1395 void release_event_target(event_target_t *event_target)
1396 {
1397     int i, j;
1398
1399     for(i=0; i < EVENTID_LAST; i++) {
1400         if(event_target->event_table[i]) {
1401             if(event_target->event_table[i]->handler_prop)
1402                 IDispatch_Release(event_target->event_table[i]->handler_prop);
1403             for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
1404                 if(event_target->event_table[i]->handlers[j])
1405                     IDispatch_Release(event_target->event_table[i]->handlers[j]);
1406         }
1407     }
1408
1409     heap_free(event_target);
1410 }