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

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