git.oblomov.eu Git - wine/blob - dlls/mshtml/htmlevent.c

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