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