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
 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         event_obj = create_event(get_node(doc, target, TRUE), eid, nsevent);
 914     doc->basedoc.window->event = event_obj;
 915
 916     nsIDOMNode_GetNodeType(target, &node_type);
 917     nsnode = target;
 918     nsIDOMNode_AddRef(nsnode);
 919
 920     switch(node_type) {
 921     case ELEMENT_NODE:
 922         do {
 923             node = get_node(doc, nsnode, FALSE);
 924             if(node)
 925                 call_event_handlers(doc, event_obj, *get_node_event_target(node), node->cp_container, eid,
 926                         (IDispatch*)HTMLDOMNODE(node));
 927
 928             if(!(event_info[eid].flags & EVENT_BUBBLE))
 929                 break;
 930
 931             nsIDOMNode_GetParentNode(nsnode, &parent);
 932             nsIDOMNode_Release(nsnode);
 933             nsnode = parent;
 934             if(!nsnode)
 935                 break;
 936
 937             nsIDOMNode_GetNodeType(nsnode, &node_type);
 938         }while(node_type == ELEMENT_NODE);
 939
 940         if(!(event_info[eid].flags & EVENT_BUBBLE))
 941             break;
 942
 943     case DOCUMENT_NODE:
 944         if(event_info[eid].flags & EVENT_FORWARDBODY) {
 945             nsIDOMHTMLElement *nsbody;
 946             nsresult nsres;
 947
 948             nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
 949             if(NS_SUCCEEDED(nsres) && nsbody) {
 950                 node = get_node(doc, (nsIDOMNode*)nsbody, FALSE);
 951                 if(node)
 952                     call_event_handlers(doc, event_obj, *get_node_event_target(node), node->cp_container,
 953                             eid, (IDispatch*)HTMLDOMNODE(node));
 954                 nsIDOMHTMLElement_Release(nsbody);
 955             }else {
 956                 ERR("Could not get body: %08x\n", nsres);
 957             }
 958         }
 959
 960         call_event_handlers(doc, event_obj, doc->node.event_target, &doc->basedoc.cp_container, eid,
 961                 (IDispatch*)HTMLDOC(&doc->basedoc));
 962         break;
 963
 964     default:
 965         FIXME("unimplemented node type %d\n", node_type);
 966     }
 967
 968     if(nsnode)
 969         nsIDOMNode_Release(nsnode);
 970
 971     if(event_obj)
 972         IHTMLEventObj_Release(event_obj);
 973     doc->basedoc.window->event = prev_event;
 974 }
 975
 976 HRESULT dispatch_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_obj, VARIANT_BOOL *cancelled)
 977 {
 978     eventid_t eid;
 979
 980     eid = attr_to_eid(event_name);
 981     if(eid == EVENTID_LAST) {
 982         WARN("unknown event %s\n", debugstr_w(event_name));
 983         return E_INVALIDARG;
 984     }
 985
 986     if(event_obj && V_VT(event_obj) != VT_EMPTY && V_VT(event_obj) != VT_ERROR)
 987         FIXME("event_obj not implemented\n");
 988
 989     if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
 990         FIXME("not EVENT_DEFAULTEVENTHANDLER\n");
 991         return E_NOTIMPL;
 992     }
 993
 994     fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
 995
 996     *cancelled = VARIANT_TRUE; /* FIXME */
 997     return S_OK;
 998 }
 999
1000 HRESULT call_event(HTMLDOMNode *node, eventid_t eid)
1001 {
1002     HRESULT hres;
1003
1004     if(node->vtbl->call_event) {
1005         BOOL handled = FALSE;
1006
1007         hres = node->vtbl->call_event(node, eid, &handled);
1008         if(handled)
1009             return hres;
1010     }
1011
1012     fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
1013     return S_OK;
1014 }
1015
1016 static inline event_target_t *get_event_target(event_target_t **event_target_ptr)
1017 {
1018     if(!*event_target_ptr)
1019         *event_target_ptr = heap_alloc_zero(sizeof(event_target_t));
1020     return *event_target_ptr;
1021 }
1022
1023 static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt)
1024 {
1025     handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid];
1026
1027     if(handler_vector) {
1028         if(cnt <= handler_vector->handler_cnt)
1029             return TRUE;
1030
1031         new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1032     }else {
1033         new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1034     }
1035
1036     if(!new_vector)
1037         return FALSE;
1038
1039     new_vector->handler_cnt = cnt;
1040     event_target->event_table[eid] = new_vector;
1041     return TRUE;
1042 }
1043
1044 static HRESULT ensure_nsevent_handler(HTMLDocumentNode *doc, event_target_t *event_target, nsIDOMNode *nsnode, eventid_t eid)
1045 {
1046     if(!doc->nsdoc)
1047         return S_OK;
1048
1049     if(event_info[eid].flags & EVENT_NODEHANDLER) {
1050         DWORD mask;
1051
1052         mask = get_node_handler_mask(eid);
1053         if(event_target->node_handlers_mask & mask)
1054             return S_OK;
1055
1056         add_nsevent_listener(doc, nsnode, event_info[eid].name);
1057         event_target->node_handlers_mask |= mask;
1058         return S_OK;
1059     }
1060
1061     if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER))
1062         return S_OK;
1063
1064     if(!doc->event_vector) {
1065         doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
1066         if(!doc->event_vector)
1067             return E_OUTOFMEMORY;
1068     }
1069
1070     if(!doc->event_vector[eid]) {
1071         doc->event_vector[eid] = TRUE;
1072         add_nsevent_listener(doc, NULL, event_info[eid].name);
1073     }
1074
1075     return S_OK;
1076 }
1077
1078 static HRESULT remove_event_handler(event_target_t **event_target, eventid_t eid)
1079 {
1080     if(*event_target && (*event_target)->event_table[eid]->handler_prop) {
1081         IDispatch_Release((*event_target)->event_table[eid]->handler_prop);
1082         (*event_target)->event_table[eid]->handler_prop = NULL;
1083     }
1084
1085     return S_OK;
1086 }
1087
1088 static HRESULT set_event_handler_disp(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocumentNode *doc,
1089         eventid_t eid, IDispatch *disp)
1090 {
1091     event_target_t *event_target;
1092
1093     if(!disp)
1094         return remove_event_handler(event_target_ptr, eid);
1095
1096     event_target = get_event_target(event_target_ptr);
1097     if(!event_target)
1098         return E_OUTOFMEMORY;
1099
1100     if(!alloc_handler_vector(event_target, eid, 0))
1101         return E_OUTOFMEMORY;
1102
1103     if(event_target->event_table[eid]->handler_prop)
1104         IDispatch_Release(event_target->event_table[eid]->handler_prop);
1105
1106     event_target->event_table[eid]->handler_prop = disp;
1107     IDispatch_AddRef(disp);
1108
1109     return ensure_nsevent_handler(doc, event_target, nsnode, eid);
1110 }
1111
1112 HRESULT set_event_handler(event_target_t **event_target, nsIDOMNode *nsnode, HTMLDocumentNode *doc, eventid_t eid, VARIANT *var)
1113 {
1114     switch(V_VT(var)) {
1115     case VT_NULL:
1116         return remove_event_handler(event_target, eid);
1117
1118     case VT_DISPATCH:
1119         return set_event_handler_disp(event_target, nsnode, doc, eid, V_DISPATCH(var));
1120
1121     default:
1122         FIXME("not supported vt=%d\n", V_VT(var));
1123     case VT_EMPTY:
1124         return E_NOTIMPL;
1125     }
1126
1127     return S_OK;
1128 }
1129
1130 HRESULT get_event_handler(event_target_t **event_target, eventid_t eid, VARIANT *var)
1131 {
1132     if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1133         V_VT(var) = VT_DISPATCH;
1134         V_DISPATCH(var) = (*event_target)->event_table[eid]->handler_prop;
1135         IDispatch_AddRef(V_DISPATCH(var));
1136     }else {
1137         V_VT(var) = VT_NULL;
1138     }
1139
1140     return S_OK;
1141 }
1142
1143 HRESULT attach_event(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocument *doc, BSTR name,
1144         IDispatch *disp, VARIANT_BOOL *res)
1145 {
1146     event_target_t *event_target;
1147     eventid_t eid;
1148     DWORD i = 0;
1149
1150     eid = attr_to_eid(name);
1151     if(eid == EVENTID_LAST) {
1152         WARN("Unknown event\n");
1153         *res = VARIANT_TRUE;
1154         return S_OK;
1155     }
1156
1157     event_target = get_event_target(event_target_ptr);
1158     if(!event_target)
1159         return E_OUTOFMEMORY;
1160
1161     if(event_target->event_table[eid]) {
1162         while(i < event_target->event_table[eid]->handler_cnt && event_target->event_table[eid]->handlers[i])
1163             i++;
1164         if(i == event_target->event_table[eid]->handler_cnt && !alloc_handler_vector(event_target, eid, i+1))
1165             return E_OUTOFMEMORY;
1166     }else if(!alloc_handler_vector(event_target, eid, i+1)) {
1167         return E_OUTOFMEMORY;
1168     }
1169
1170     IDispatch_AddRef(disp);
1171     event_target->event_table[eid]->handlers[i] = disp;
1172
1173     *res = VARIANT_TRUE;
1174     return ensure_nsevent_handler(doc->doc_node, event_target, nsnode, eid);
1175 }
1176
1177 HRESULT detach_event(event_target_t *event_target, HTMLDocument *doc, BSTR name, IDispatch *disp)
1178 {
1179     eventid_t eid;
1180     DWORD i = 0;
1181
1182     if(!event_target)
1183         return S_OK;
1184
1185     eid = attr_to_eid(name);
1186     if(eid == EVENTID_LAST) {
1187         WARN("Unknown event\n");
1188         return S_OK;
1189     }
1190
1191     if(!event_target->event_table[eid])
1192         return S_OK;
1193
1194     while(i < event_target->event_table[eid]->handler_cnt) {
1195         if(event_target->event_table[eid]->handlers[i] == disp) {
1196             IDispatch_Release(event_target->event_table[eid]->handlers[i]);
1197             event_target->event_table[eid]->handlers[i] = NULL;
1198         }
1199         i++;
1200     }
1201
1202     return S_OK;
1203 }
1204
1205 void update_cp_events(HTMLWindow *window, event_target_t **event_target_ptr, cp_static_data_t *cp, nsIDOMNode *nsnode)
1206 {
1207     event_target_t *event_target;
1208     int i;
1209
1210     event_target = get_event_target(event_target_ptr);
1211     if(!event_target)
1212         return; /* FIXME */
1213
1214     for(i=0; i < EVENTID_LAST; i++) {
1215         if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
1216             ensure_nsevent_handler(window->doc, event_target, nsnode, i);
1217     }
1218 }
1219
1220 void check_event_attr(HTMLDocumentNode *doc, nsIDOMElement *nselem)
1221 {
1222     const PRUnichar *attr_value;
1223     nsAString attr_name_str, attr_value_str;
1224     IDispatch *disp;
1225     HTMLDOMNode *node;
1226     int i;
1227     nsresult nsres;
1228
1229     nsAString_Init(&attr_value_str, NULL);
1230     nsAString_Init(&attr_name_str, NULL);
1231
1232     for(i=0; i < EVENTID_LAST; i++) {
1233         nsAString_SetData(&attr_name_str, event_info[i].attr_name);
1234         nsres = nsIDOMElement_GetAttribute(nselem, &attr_name_str, &attr_value_str);
1235         if(NS_SUCCEEDED(nsres)) {
1236             nsAString_GetData(&attr_value_str, &attr_value);
1237             if(!*attr_value)
1238                 continue;
1239
1240             TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
1241
1242             disp = script_parse_event(doc->basedoc.window, attr_value);
1243             if(disp) {
1244                 node = get_node(doc, (nsIDOMNode*)nselem, TRUE);
1245                 set_event_handler_disp(get_node_event_target(node), node->nsnode, node->doc, i, disp);
1246                 IDispatch_Release(disp);
1247             }
1248         }
1249     }
1250
1251     nsAString_Finish(&attr_value_str);
1252     nsAString_Finish(&attr_name_str);
1253 }
1254
1255 void release_event_target(event_target_t *event_target)
1256 {
1257     int i, j;
1258
1259     for(i=0; i < EVENTID_LAST; i++) {
1260         if(event_target->event_table[i]) {
1261             if(event_target->event_table[i]->handler_prop)
1262                 IDispatch_Release(event_target->event_table[i]->handler_prop);
1263             for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
1264                 IDispatch_Release(event_target->event_table[i]->handlers[j]);
1265         }
1266     }
1267
1268     heap_free(event_target);
1269 }