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