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_disp_func(IDispatch *disp, DISPPARAMS *dp)
 790 {
 791     EXCEPINFO ei;
 792     IDispatchEx *dispex;
 793     VARIANT res;
 794     HRESULT hres;
 795
 796     VariantInit(&res);
 797     memset(&ei, 0, sizeof(ei));
 798
 799     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 800     if(SUCCEEDED(hres)) {
 801         hres = IDispatchEx_InvokeEx(dispex, 0, GetUserDefaultLCID(), DISPATCH_METHOD, dp, &res, &ei, NULL);
 802         IDispatchEx_Release(dispex);
 803     }else {
 804         TRACE("Could not get IDispatchEx interface: %08x\n", hres);
 805         hres = IDispatch_Invoke(disp, 0, &IID_NULL, GetUserDefaultLCID(), DISPATCH_METHOD,
 806                 dp, &res, &ei, NULL);
 807     }
 808
 809     VariantClear(&res);
 810     return hres;
 811 }
 812
 813 static HRESULT call_cp_func(IDispatch *disp, DISPID dispid)
 814 {
 815     DISPPARAMS dp = {NULL,NULL,0,0};
 816     ULONG argerr;
 817     EXCEPINFO ei;
 818     VARIANT vres;
 819     HRESULT hres;
 820
 821     V_VT(&vres) = VT_EMPTY;
 822     memset(&ei, 0, sizeof(ei));
 823     hres = IDispatch_Invoke(disp, dispid, &IID_NULL, 0, DISPATCH_METHOD, &dp, &vres, &ei, &argerr);
 824     if(SUCCEEDED(hres) && V_VT(&vres) != VT_EMPTY) {
 825         FIXME("handle result %s\n", debugstr_variant(&vres));
 826         VariantClear(&vres);
 827     }
 828
 829     return hres;
 830 }
 831
 832 static BOOL is_cp_event(cp_static_data_t *data, DISPID dispid)
 833 {
 834     int min, max, i;
 835     HRESULT hres;
 836
 837     if(!data)
 838         return FALSE;
 839
 840     if(!data->ids) {
 841         hres = get_dispids(data->tid, &data->id_cnt, &data->ids);
 842         if(FAILED(hres))
 843             return FALSE;
 844     }
 845
 846     min = 0;
 847     max = data->id_cnt-1;
 848     while(min <= max) {
 849         i = (min+max)/2;
 850         if(data->ids[i] == dispid)
 851             return TRUE;
 852
 853         if(data->ids[i] < dispid)
 854             min = i+1;
 855         else
 856             max = i-1;
 857     }
 858
 859     return FALSE;
 860 }
 861
 862 static void call_event_handlers(HTMLDocumentNode *doc, IHTMLEventObj *event_obj, event_target_t *event_target,
 863         ConnectionPointContainer *cp_container, eventid_t eid, IDispatch *this_obj)
 864 {
 865     handler_vector_t *handler_vector = NULL;
 866     int i;
 867     HRESULT hres;
 868
 869     if(event_target)
 870         handler_vector = event_target->event_table[eid];
 871
 872     if(handler_vector && handler_vector->handler_prop) {
 873         DISPID named_arg = DISPID_THIS;
 874         VARIANTARG arg;
 875         DISPPARAMS dp = {&arg, &named_arg, 1, 1};
 876
 877         V_VT(&arg) = VT_DISPATCH;
 878         V_DISPATCH(&arg) = this_obj;
 879
 880         TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
 881         hres = call_disp_func(handler_vector->handler_prop, &dp);
 882         if(hres == S_OK)
 883             TRACE("%s <<<\n", debugstr_w(event_info[eid].name));
 884         else
 885             WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
 886     }
 887
 888     if(handler_vector && handler_vector->handler_cnt) {
 889         VARIANTARG arg;
 890         DISPPARAMS dp = {&arg, NULL, 1, 0};
 891
 892         V_VT(&arg) = VT_DISPATCH;
 893         V_DISPATCH(&arg) = (IDispatch*)event_obj;
 894
 895         i = handler_vector->handler_cnt;
 896         while(i--) {
 897             if(handler_vector->handlers[i]) {
 898                 TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
 899                 hres = call_disp_func(handler_vector->handlers[i], &dp);
 900                 if(hres == S_OK)
 901                     TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
 902                 else
 903                     WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
 904             }
 905         }
 906     }
 907
 908     if(cp_container) {
 909         ConnectionPoint *cp;
 910
 911         if(cp_container->forward_container)
 912             cp_container = cp_container->forward_container;
 913
 914         for(cp = cp_container->cp_list; cp; cp = cp->next) {
 915             if(cp->sinks_size && is_cp_event(cp->data, event_info[eid].dispid)) {
 916                 for(i=0; i < cp->sinks_size; i++) {
 917                     if(!cp->sinks[i].disp)
 918                         continue;
 919
 920                     TRACE("cp %s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
 921                     hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid);
 922                     if(hres == S_OK)
 923                         TRACE("cp %s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
 924                     else
 925                         WARN("cp %s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
 926                 }
 927             }
 928         }
 929     }
 930 }
 931
 932 void fire_event(HTMLDocumentNode *doc, eventid_t eid, BOOL set_event, nsIDOMNode *target, nsIDOMEvent *nsevent)
 933 {
 934     IHTMLEventObj *prev_event, *event_obj = NULL;
 935     nsIDOMNode *parent, *nsnode;
 936     HTMLDOMNode *node;
 937     PRUint16 node_type;
 938     HRESULT hres;
 939
 940     TRACE("(%p) %s\n", doc, debugstr_w(event_info[eid].name));
 941
 942     prev_event = doc->basedoc.window->event;
 943     if(set_event) {
 944         hres = get_node(doc, target, TRUE, &node);
 945         if(FAILED(hres))
 946             return;
 947
 948         event_obj = create_event(node, eid, nsevent);
 949     }
 950     doc->basedoc.window->event = event_obj;
 951
 952     nsIDOMNode_GetNodeType(target, &node_type);
 953     nsnode = target;
 954     nsIDOMNode_AddRef(nsnode);
 955
 956     switch(node_type) {
 957     case ELEMENT_NODE:
 958         do {
 959             hres = get_node(doc, nsnode, FALSE, &node);
 960             if(SUCCEEDED(hres) && node)
 961                 call_event_handlers(doc, event_obj, *get_node_event_target(node),
 962                         node->cp_container, eid, (IDispatch*)&node->IHTMLDOMNode_iface);
 963
 964             if(!(event_info[eid].flags & EVENT_BUBBLE))
 965                 break;
 966
 967             nsIDOMNode_GetParentNode(nsnode, &parent);
 968             nsIDOMNode_Release(nsnode);
 969             nsnode = parent;
 970             if(!nsnode)
 971                 break;
 972
 973             nsIDOMNode_GetNodeType(nsnode, &node_type);
 974         }while(node_type == ELEMENT_NODE);
 975
 976         if(!(event_info[eid].flags & EVENT_BUBBLE))
 977             break;
 978
 979     case DOCUMENT_NODE:
 980         if(event_info[eid].flags & EVENT_FORWARDBODY) {
 981             nsIDOMHTMLElement *nsbody;
 982             nsresult nsres;
 983
 984             nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
 985             if(NS_SUCCEEDED(nsres) && nsbody) {
 986                 hres = get_node(doc, (nsIDOMNode*)nsbody, FALSE, &node);
 987                 if(SUCCEEDED(hres) && node)
 988                     call_event_handlers(doc, event_obj, *get_node_event_target(node),
 989                             node->cp_container, eid, (IDispatch*)&node->IHTMLDOMNode_iface);
 990                 nsIDOMHTMLElement_Release(nsbody);
 991             }else {
 992                 ERR("Could not get body: %08x\n", nsres);
 993             }
 994         }
 995
 996         call_event_handlers(doc, event_obj, doc->node.event_target, &doc->basedoc.cp_container, eid,
 997                 (IDispatch*)&doc->basedoc.IHTMLDocument2_iface);
 998         break;
 999
1000     default:
1001         FIXME("unimplemented node type %d\n", node_type);
1002     }
1003
1004     if(nsnode)
1005         nsIDOMNode_Release(nsnode);
1006
1007     if(event_obj)
1008         IHTMLEventObj_Release(event_obj);
1009     doc->basedoc.window->event = prev_event;
1010 }
1011
1012 HRESULT dispatch_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_obj, VARIANT_BOOL *cancelled)
1013 {
1014     eventid_t eid;
1015
1016     eid = attr_to_eid(event_name);
1017     if(eid == EVENTID_LAST) {
1018         WARN("unknown event %s\n", debugstr_w(event_name));
1019         return E_INVALIDARG;
1020     }
1021
1022     if(event_obj && V_VT(event_obj) != VT_EMPTY && V_VT(event_obj) != VT_ERROR)
1023         FIXME("event_obj not implemented\n");
1024
1025     if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
1026         FIXME("not EVENT_DEFAULTEVENTHANDLER\n");
1027         return E_NOTIMPL;
1028     }
1029
1030     fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
1031
1032     *cancelled = VARIANT_TRUE; /* FIXME */
1033     return S_OK;
1034 }
1035
1036 HRESULT call_event(HTMLDOMNode *node, eventid_t eid)
1037 {
1038     HRESULT hres;
1039
1040     if(node->vtbl->call_event) {
1041         BOOL handled = FALSE;
1042
1043         hres = node->vtbl->call_event(node, eid, &handled);
1044         if(handled)
1045             return hres;
1046     }
1047
1048     fire_event(node->doc, eid, TRUE, node->nsnode, NULL);
1049     return S_OK;
1050 }
1051
1052 static inline event_target_t *get_event_target(event_target_t **event_target_ptr)
1053 {
1054     if(!*event_target_ptr)
1055         *event_target_ptr = heap_alloc_zero(sizeof(event_target_t));
1056     return *event_target_ptr;
1057 }
1058
1059 static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt)
1060 {
1061     handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid];
1062
1063     if(handler_vector) {
1064         if(cnt <= handler_vector->handler_cnt)
1065             return TRUE;
1066
1067         new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1068     }else {
1069         new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
1070     }
1071
1072     if(!new_vector)
1073         return FALSE;
1074
1075     new_vector->handler_cnt = cnt;
1076     event_target->event_table[eid] = new_vector;
1077     return TRUE;
1078 }
1079
1080 static HRESULT ensure_nsevent_handler(HTMLDocumentNode *doc, event_target_t *event_target, nsIDOMNode *nsnode, eventid_t eid)
1081 {
1082     if(!doc->nsdoc)
1083         return S_OK;
1084
1085     if(event_info[eid].flags & EVENT_NODEHANDLER) {
1086         DWORD mask;
1087
1088         mask = get_node_handler_mask(eid);
1089         if(event_target->node_handlers_mask & mask)
1090             return S_OK;
1091
1092         add_nsevent_listener(doc, nsnode, event_info[eid].name);
1093         event_target->node_handlers_mask |= mask;
1094         return S_OK;
1095     }
1096
1097     if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER))
1098         return S_OK;
1099
1100     if(!doc->event_vector) {
1101         doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
1102         if(!doc->event_vector)
1103             return E_OUTOFMEMORY;
1104     }
1105
1106     if(!doc->event_vector[eid]) {
1107         doc->event_vector[eid] = TRUE;
1108         add_nsevent_listener(doc, NULL, event_info[eid].name);
1109     }
1110
1111     return S_OK;
1112 }
1113
1114 static HRESULT remove_event_handler(event_target_t **event_target, eventid_t eid)
1115 {
1116     if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1117         IDispatch_Release((*event_target)->event_table[eid]->handler_prop);
1118         (*event_target)->event_table[eid]->handler_prop = NULL;
1119     }
1120
1121     return S_OK;
1122 }
1123
1124 static HRESULT set_event_handler_disp(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocumentNode *doc,
1125         eventid_t eid, IDispatch *disp)
1126 {
1127     event_target_t *event_target;
1128
1129     if(!disp)
1130         return remove_event_handler(event_target_ptr, eid);
1131
1132     event_target = get_event_target(event_target_ptr);
1133     if(!event_target)
1134         return E_OUTOFMEMORY;
1135
1136     if(!alloc_handler_vector(event_target, eid, 0))
1137         return E_OUTOFMEMORY;
1138
1139     if(event_target->event_table[eid]->handler_prop)
1140         IDispatch_Release(event_target->event_table[eid]->handler_prop);
1141
1142     event_target->event_table[eid]->handler_prop = disp;
1143     IDispatch_AddRef(disp);
1144
1145     return ensure_nsevent_handler(doc, event_target, nsnode, eid);
1146 }
1147
1148 HRESULT set_event_handler(event_target_t **event_target, nsIDOMNode *nsnode, HTMLDocumentNode *doc, eventid_t eid, VARIANT *var)
1149 {
1150     switch(V_VT(var)) {
1151     case VT_NULL:
1152         return remove_event_handler(event_target, eid);
1153
1154     case VT_DISPATCH:
1155         return set_event_handler_disp(event_target, nsnode, doc, eid, V_DISPATCH(var));
1156
1157     default:
1158         FIXME("not supported vt=%d\n", V_VT(var));
1159     case VT_EMPTY:
1160         return E_NOTIMPL;
1161     }
1162
1163     return S_OK;
1164 }
1165
1166 HRESULT get_event_handler(event_target_t **event_target, eventid_t eid, VARIANT *var)
1167 {
1168     if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
1169         V_VT(var) = VT_DISPATCH;
1170         V_DISPATCH(var) = (*event_target)->event_table[eid]->handler_prop;
1171         IDispatch_AddRef(V_DISPATCH(var));
1172     }else {
1173         V_VT(var) = VT_NULL;
1174     }
1175
1176     return S_OK;
1177 }
1178
1179 HRESULT attach_event(event_target_t **event_target_ptr, nsIDOMNode *nsnode, HTMLDocument *doc, BSTR name,
1180         IDispatch *disp, VARIANT_BOOL *res)
1181 {
1182     event_target_t *event_target;
1183     eventid_t eid;
1184     DWORD i = 0;
1185
1186     eid = attr_to_eid(name);
1187     if(eid == EVENTID_LAST) {
1188         WARN("Unknown event\n");
1189         *res = VARIANT_TRUE;
1190         return S_OK;
1191     }
1192
1193     event_target = get_event_target(event_target_ptr);
1194     if(!event_target)
1195         return E_OUTOFMEMORY;
1196
1197     if(event_target->event_table[eid]) {
1198         while(i < event_target->event_table[eid]->handler_cnt && event_target->event_table[eid]->handlers[i])
1199             i++;
1200         if(i == event_target->event_table[eid]->handler_cnt && !alloc_handler_vector(event_target, eid, i+1))
1201             return E_OUTOFMEMORY;
1202     }else if(!alloc_handler_vector(event_target, eid, i+1)) {
1203         return E_OUTOFMEMORY;
1204     }
1205
1206     IDispatch_AddRef(disp);
1207     event_target->event_table[eid]->handlers[i] = disp;
1208
1209     *res = VARIANT_TRUE;
1210     return ensure_nsevent_handler(doc->doc_node, event_target, nsnode, eid);
1211 }
1212
1213 HRESULT detach_event(event_target_t *event_target, HTMLDocument *doc, BSTR name, IDispatch *disp)
1214 {
1215     eventid_t eid;
1216     DWORD i = 0;
1217
1218     if(!event_target)
1219         return S_OK;
1220
1221     eid = attr_to_eid(name);
1222     if(eid == EVENTID_LAST) {
1223         WARN("Unknown event\n");
1224         return S_OK;
1225     }
1226
1227     if(!event_target->event_table[eid])
1228         return S_OK;
1229
1230     while(i < event_target->event_table[eid]->handler_cnt) {
1231         if(event_target->event_table[eid]->handlers[i] == disp) {
1232             IDispatch_Release(event_target->event_table[eid]->handlers[i]);
1233             event_target->event_table[eid]->handlers[i] = NULL;
1234         }
1235         i++;
1236     }
1237
1238     return S_OK;
1239 }
1240
1241 void update_cp_events(HTMLWindow *window, event_target_t **event_target_ptr, cp_static_data_t *cp, nsIDOMNode *nsnode)
1242 {
1243     event_target_t *event_target;
1244     int i;
1245
1246     event_target = get_event_target(event_target_ptr);
1247     if(!event_target)
1248         return; /* FIXME */
1249
1250     for(i=0; i < EVENTID_LAST; i++) {
1251         if((event_info[i].flags & EVENT_DEFAULTLISTENER) && is_cp_event(cp, event_info[i].dispid))
1252             ensure_nsevent_handler(window->doc, event_target, nsnode, i);
1253     }
1254 }
1255
1256 void check_event_attr(HTMLDocumentNode *doc, nsIDOMElement *nselem)
1257 {
1258     const PRUnichar *attr_value;
1259     nsAString attr_name_str, attr_value_str;
1260     IDispatch *disp;
1261     HTMLDOMNode *node;
1262     int i;
1263     nsresult nsres;
1264     HRESULT hres;
1265
1266     nsAString_Init(&attr_value_str, NULL);
1267     nsAString_Init(&attr_name_str, NULL);
1268
1269     for(i=0; i < EVENTID_LAST; i++) {
1270         nsAString_SetData(&attr_name_str, event_info[i].attr_name);
1271         nsres = nsIDOMElement_GetAttribute(nselem, &attr_name_str, &attr_value_str);
1272         if(NS_SUCCEEDED(nsres)) {
1273             nsAString_GetData(&attr_value_str, &attr_value);
1274             if(!*attr_value)
1275                 continue;
1276
1277             TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
1278
1279             disp = script_parse_event(doc->basedoc.window, attr_value);
1280             if(disp) {
1281                 hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
1282                 if(SUCCEEDED(hres))
1283                     set_event_handler_disp(get_node_event_target(node), node->nsnode, node->doc, i, disp);
1284                 IDispatch_Release(disp);
1285             }
1286         }
1287     }
1288
1289     nsAString_Finish(&attr_value_str);
1290     nsAString_Finish(&attr_name_str);
1291 }
1292
1293 void release_event_target(event_target_t *event_target)
1294 {
1295     int i, j;
1296
1297     for(i=0; i < EVENTID_LAST; i++) {
1298         if(event_target->event_table[i]) {
1299             if(event_target->event_table[i]->handler_prop)
1300                 IDispatch_Release(event_target->event_table[i]->handler_prop);
1301             for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
1302                 IDispatch_Release(event_target->event_table[i]->handlers[j]);
1303         }
1304     }
1305
1306     heap_free(event_target);
1307 }