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