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