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