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