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