reactos/dll/win32/mshtml/htmlevent.c

   1 /*
   2  * Copyright 2008-2009 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "mshtml_private.h"
  29 #include "htmlevent.h"
  30
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  34
  35 typedef struct {
  36     IDispatch *handler_prop;
  37     DWORD handler_cnt;
  38     IDispatch *handlers[0];
  39 } handler_vector_t;
  40
  41 struct event_target_t {
  42     handler_vector_t *event_table[EVENTID_LAST];
  43 };
  44
  45 static const WCHAR beforeunloadW[] = {'b','e','f','o','r','e','u','n','l','o','a','d',0};
  46 static const WCHAR onbeforeunloadW[] = {'o','n','b','e','f','o','r','e','u','n','l','o','a','d',0};
  47
  48 static const WCHAR blurW[] = {'b','l','u','r',0};
  49 static const WCHAR onblurW[] = {'o','n','b','l','u','r',0};
  50
  51 static const WCHAR changeW[] = {'c','h','a','n','g','e',0};
  52 static const WCHAR onchangeW[] = {'o','n','c','h','a','n','g','e',0};
  53
  54 static const WCHAR clickW[] = {'c','l','i','c','k',0};
  55 static const WCHAR onclickW[] = {'o','n','c','l','i','c','k',0};
  56
  57 static const WCHAR dblclickW[] = {'d','b','l','c','l','i','c','k',0};
  58 static const WCHAR ondblclickW[] = {'o','n','d','b','l','c','l','i','c','k',0};
  59
  60 static const WCHAR dragW[] = {'d','r','a','g',0};
  61 static const WCHAR ondragW[] = {'o','n','d','r','a','g',0};
  62
  63 static const WCHAR dragstartW[] = {'d','r','a','g','s','t','a','r','t',0};
  64 static const WCHAR ondragstartW[] = {'o','n','d','r','a','g','s','t','a','r','t',0};
  65
  66 static const WCHAR focusW[] = {'f','o','c','u','s',0};
  67 static const WCHAR onfocusW[] = {'o','n','f','o','c','u','s',0};
  68
  69 static const WCHAR keydownW[] = {'k','e','y','d','o','w','n',0};
  70 static const WCHAR onkeydownW[] = {'o','n','k','e','y','d','o','w','n',0};
  71
  72 static const WCHAR keyupW[] = {'k','e','y','u','p',0};
  73 static const WCHAR onkeyupW[] = {'o','n','k','e','y','u','p',0};
  74
  75 static const WCHAR loadW[] = {'l','o','a','d',0};
  76 static const WCHAR onloadW[] = {'o','n','l','o','a','d',0};
  77
  78 static const WCHAR mousedownW[] = {'m','o','u','s','e','d','o','w','n',0};
  79 static const WCHAR onmousedownW[] = {'o','n','m','o','u','s','e','d','o','w','n',0};
  80
  81 static const WCHAR mouseoutW[] = {'m','o','u','s','e','o','u','t',0};
  82 static const WCHAR onmouseoutW[] = {'o','n','m','o','u','s','e','o','u','t',0};
  83
  84 static const WCHAR mouseoverW[] = {'m','o','u','s','e','o','v','e','r',0};
  85 static const WCHAR onmouseoverW[] = {'o','n','m','o','u','s','e','o','v','e','r',0};
  86
  87 static const WCHAR mouseupW[] = {'m','o','u','s','e','u','p',0};
  88 static const WCHAR onmouseupW[] = {'o','n','m','o','u','s','e','u','p',0};
  89
  90 static const WCHAR pasteW[] = {'p','a','s','t','e',0};
  91 static const WCHAR onpasteW[] = {'o','n','p','a','s','t','e',0};
  92
  93 static const WCHAR readystatechangeW[] = {'r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
  94 static const WCHAR onreadystatechangeW[] = {'o','n','r','e','a','d','y','s','t','a','t','e','c','h','a','n','g','e',0};
  95
  96 static const WCHAR selectstartW[] = {'s','e','l','e','c','t','s','t','a','r','t',0};
  97 static const WCHAR onselectstartW[] = {'o','n','s','e','l','e','c','t','s','t','a','r','t',0};
  98
  99 static const WCHAR HTMLEventsW[] = {'H','T','M','L','E','v','e','n','t','s',0};
 100 static const WCHAR KeyboardEventW[] = {'K','e','y','b','o','a','r','d','E','v','e','n','t',0};
 101 static const WCHAR MouseEventW[] = {'M','o','u','s','e','E','v','e','n','t',0};
 102
 103 enum {
 104     EVENTT_NONE,
 105     EVENTT_HTML,
 106     EVENTT_KEY,
 107     EVENTT_MOUSE
 108 };
 109
 110 static const WCHAR *event_types[] = {
 111     NULL,
 112     HTMLEventsW,
 113     KeyboardEventW,
 114     MouseEventW
 115 };
 116
 117 typedef struct {
 118     LPCWSTR name;
 119     LPCWSTR attr_name;
 120     DWORD type;
 121     DWORD flags;
 122 } event_info_t;
 123
 124 #define EVENT_DEFAULTLISTENER    0x0001
 125 #define EVENT_BUBBLE             0x0002
 126 #define EVENT_FORWARDBODY        0x0004
 127
 128 static const event_info_t event_info[] = {
 129     {beforeunloadW,      onbeforeunloadW,      EVENTT_NONE,  EVENT_DEFAULTLISTENER|EVENT_FORWARDBODY},
 130     {blurW,              onblurW,              EVENTT_HTML,  EVENT_DEFAULTLISTENER},
 131     {changeW,            onchangeW,            EVENTT_HTML,  EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 132     {clickW,             onclickW,             EVENTT_MOUSE, EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 133     {dblclickW,          ondblclickW,          EVENTT_MOUSE, EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 134     {dragW,              ondragW,              EVENTT_MOUSE, 0},
 135     {dragstartW,         ondragstartW,         EVENTT_MOUSE, 0},
 136     {focusW,             onfocusW,             EVENTT_HTML,  EVENT_DEFAULTLISTENER},
 137     {keydownW,           onkeydownW,           EVENTT_KEY,   EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 138     {keyupW,             onkeyupW,             EVENTT_KEY,   EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 139     {loadW,              onloadW,              EVENTT_HTML,  0},
 140     {mousedownW,         onmousedownW,         EVENTT_MOUSE, EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 141     {mouseoutW,          onmouseoutW,          EVENTT_MOUSE, EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 142     {mouseoverW,         onmouseoverW,         EVENTT_MOUSE, EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 143     {mouseupW,           onmouseupW,           EVENTT_MOUSE, EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 144     {pasteW,             onpasteW,             EVENTT_NONE,  0},
 145     {readystatechangeW,  onreadystatechangeW,  EVENTT_NONE,  0},
 146     {selectstartW,       onselectstartW,       EVENTT_MOUSE, 0}
 147 };
 148
 149 eventid_t str_to_eid(LPCWSTR str)
 150 {
 151     int i;
 152
 153     for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
 154         if(!strcmpW(event_info[i].name, str))
 155             return i;
 156     }
 157
 158     ERR("unknown type %s\n", debugstr_w(str));
 159     return EVENTID_LAST;
 160 }
 161
 162 static eventid_t attr_to_eid(LPCWSTR str)
 163 {
 164     int i;
 165
 166     for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
 167         if(!strcmpW(event_info[i].attr_name, str))
 168             return i;
 169     }
 170
 171     return EVENTID_LAST;
 172 }
 173
 174 typedef struct {
 175     DispatchEx dispex;
 176     const IHTMLEventObjVtbl  *lpIHTMLEventObjVtbl;
 177
 178     LONG ref;
 179
 180     HTMLDOMNode *target;
 181     const event_info_t *type;
 182     nsIDOMEvent *nsevent;
 183 } HTMLEventObj;
 184
 185 #define HTMLEVENTOBJ(x) ((IHTMLEventObj*) &(x)->lpIHTMLEventObjVtbl)
 186
 187 #define HTMLEVENTOBJ_THIS(iface) DEFINE_THIS(HTMLEventObj, IHTMLEventObj, iface)
 188
 189 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
 190 {
 191     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 192
 193     *ppv = NULL;
 194
 195     if(IsEqualGUID(&IID_IUnknown, riid)) {
 196         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 197         *ppv = HTMLEVENTOBJ(This);
 198     }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) {
 199         TRACE("(%p)->(IID_IHTMLEventObj %p)\n", This, ppv);
 200         *ppv = HTMLEVENTOBJ(This);
 201     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 202         return *ppv ? S_OK : E_NOINTERFACE;
 203     }
 204
 205     if(*ppv) {
 206         IUnknown_AddRef((IUnknown*)*ppv);
 207         return S_OK;
 208     }
 209
 210     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 211     return E_NOINTERFACE;
 212 }
 213
 214 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
 215 {
 216     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 217     LONG ref = InterlockedIncrement(&This->ref);
 218
 219     TRACE("(%p) ref=%d\n", This, ref);
 220
 221     return ref;
 222 }
 223
 224 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
 225 {
 226     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 227     LONG ref = InterlockedDecrement(&This->ref);
 228
 229     TRACE("(%p) ref=%d\n", This, ref);
 230
 231     if(!ref) {
 232         if(This->nsevent)
 233             nsIDOMEvent_Release(This->nsevent);
 234         release_dispex(&This->dispex);
 235         heap_free(This);
 236     }
 237
 238     return ref;
 239 }
 240
 241 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
 242 {
 243     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 244     FIXME("(%p)->(%p)\n", This, pctinfo);
 245     return E_NOTIMPL;
 246 }
 247
 248 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
 249                                               LCID lcid, ITypeInfo **ppTInfo)
 250 {
 251     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 252     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 253     return E_NOTIMPL;
 254 }
 255
 256 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
 257                                                 LPOLESTR *rgszNames, UINT cNames,
 258                                                 LCID lcid, DISPID *rgDispId)
 259 {
 260     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 261     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 262           lcid, rgDispId);
 263     return E_NOTIMPL;
 264 }
 265
 266 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
 267                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 268                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 269 {
 270     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 271     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 272           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 273     return E_NOTIMPL;
 274 }
 275
 276 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
 277 {
 278     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 279
 280     TRACE("(%p)->(%p)\n", This, p);
 281
 282     return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(This->target), &IID_IHTMLElement, (void**)p);
 283 }
 284
 285 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 286 {
 287     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 288     PRBool ret = FALSE;
 289
 290     TRACE("(%p)->(%p)\n", This, p);
 291
 292     if(This->nsevent) {
 293         nsIDOMKeyEvent *key_event;
 294         nsresult nsres;
 295
 296         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 297         if(NS_SUCCEEDED(nsres)) {
 298             nsIDOMKeyEvent_GetAltKey(key_event, &ret);
 299             nsIDOMKeyEvent_Release(key_event);
 300         }else {
 301             nsIDOMMouseEvent *mouse_event;
 302
 303             nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 304             if(NS_SUCCEEDED(nsres)) {
 305                 nsIDOMMouseEvent_GetAltKey(mouse_event, &ret);
 306                 nsIDOMMouseEvent_Release(mouse_event);
 307             }
 308         }
 309     }
 310
 311     *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
 312     return S_OK;
 313 }
 314
 315 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 316 {
 317     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 318     PRBool ret = FALSE;
 319
 320     TRACE("(%p)->(%p)\n", This, p);
 321
 322     if(This->nsevent) {
 323         nsIDOMKeyEvent *key_event;
 324         nsresult nsres;
 325
 326         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 327         if(NS_SUCCEEDED(nsres)) {
 328             nsIDOMKeyEvent_GetCtrlKey(key_event, &ret);
 329             nsIDOMKeyEvent_Release(key_event);
 330         }else {
 331             nsIDOMMouseEvent *mouse_event;
 332
 333             nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 334             if(NS_SUCCEEDED(nsres)) {
 335                 nsIDOMMouseEvent_GetCtrlKey(mouse_event, &ret);
 336                 nsIDOMMouseEvent_Release(mouse_event);
 337             }
 338         }
 339     }
 340
 341     *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
 342     return S_OK;
 343 }
 344
 345 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 346 {
 347     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 348     PRBool ret = FALSE;
 349
 350     TRACE("(%p)->(%p)\n", This, p);
 351
 352     if(This->nsevent) {
 353         nsIDOMKeyEvent *key_event;
 354         nsresult nsres;
 355
 356         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 357         if(NS_SUCCEEDED(nsres)) {
 358             nsIDOMKeyEvent_GetShiftKey(key_event, &ret);
 359             nsIDOMKeyEvent_Release(key_event);
 360         }else {
 361             nsIDOMMouseEvent *mouse_event;
 362
 363             nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 364             if(NS_SUCCEEDED(nsres)) {
 365                 nsIDOMMouseEvent_GetShiftKey(mouse_event, &ret);
 366                 nsIDOMMouseEvent_Release(mouse_event);
 367             }
 368         }
 369     }
 370
 371     *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
 372     return S_OK;
 373 }
 374
 375 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
 376 {
 377     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 378     FIXME("(%p)->()\n", This);
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
 383 {
 384     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 385
 386     FIXME("(%p)->(%p)\n", This, p);
 387
 388     V_VT(p) = VT_EMPTY;
 389     return S_OK;
 390 }
 391
 392 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
 393 {
 394     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 395     FIXME("(%p)->(%x)\n", This, v);
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
 400 {
 401     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 402
 403     FIXME("(%p)->(%p)\n", This, p);
 404
 405     *p = VARIANT_FALSE;
 406     return S_OK;
 407 }
 408
 409 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
 410 {
 411     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 412
 413     FIXME("(%p)->(%p)\n", This, p);
 414
 415     *p = NULL;
 416     return S_OK;
 417 }
 418
 419 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
 420 {
 421     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 422
 423     FIXME("(%p)->(%p)\n", This, p);
 424
 425     *p = NULL;
 426     return S_OK;
 427 }
 428
 429 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
 430 {
 431     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 432     FIXME("(%p)->(%d)\n", This, v);
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
 437 {
 438     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 439     PRUint32 key_code = 0;
 440
 441     TRACE("(%p)->(%p)\n", This, p);
 442
 443     if(This->nsevent) {
 444         nsIDOMKeyEvent *key_event;
 445         nsresult nsres;
 446
 447         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 448         if(NS_SUCCEEDED(nsres)) {
 449             nsIDOMKeyEvent_GetKeyCode(key_event, &key_code);
 450             nsIDOMKeyEvent_Release(key_event);
 451         }
 452     }
 453
 454     *p = key_code;
 455     return S_OK;
 456 }
 457
 458 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
 459 {
 460     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 461     PRUint16 button = 0;
 462
 463     TRACE("(%p)->(%p)\n", This, p);
 464
 465     if(This->nsevent) {
 466         nsIDOMMouseEvent *mouse_event;
 467         nsresult nsres;
 468
 469         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 470         if(NS_SUCCEEDED(nsres)) {
 471             nsIDOMMouseEvent_GetButton(mouse_event, &button);
 472             nsIDOMMouseEvent_Release(mouse_event);
 473         }
 474     }
 475
 476     *p = button;
 477     return S_OK;
 478 }
 479
 480 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
 481 {
 482     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 483
 484     TRACE("(%p)->(%p)\n", This, p);
 485
 486     *p = SysAllocString(This->type->name);
 487     return *p ? S_OK : E_OUTOFMEMORY;
 488 }
 489
 490 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
 491 {
 492     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 493
 494     FIXME("(%p)->(%p)\n", This, p);
 495
 496     *p = NULL;
 497     return S_OK;
 498 }
 499
 500 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
 501 {
 502     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 503
 504     FIXME("(%p)->(%p)\n", This, p);
 505
 506     *p = 0;
 507     return S_OK;
 508 }
 509
 510 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
 511 {
 512     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 513
 514     FIXME("(%p)->(%p)\n", This, p);
 515
 516     *p = -1;
 517     return S_OK;
 518 }
 519
 520 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
 521 {
 522     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 523
 524     FIXME("(%p)->(%p)\n", This, p);
 525
 526     *p = -1;
 527     return S_OK;
 528 }
 529
 530 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
 531 {
 532     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 533     PRInt32 x = 0;
 534
 535     TRACE("(%p)->(%p)\n", This, p);
 536
 537     if(This->nsevent) {
 538         nsIDOMMouseEvent *mouse_event;
 539         nsresult nsres;
 540
 541         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 542         if(NS_SUCCEEDED(nsres)) {
 543             nsIDOMMouseEvent_GetClientX(mouse_event, &x);
 544             nsIDOMMouseEvent_Release(mouse_event);
 545         }
 546     }
 547
 548     *p = x;
 549     return S_OK;
 550 }
 551
 552 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
 553 {
 554     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 555     PRInt32 y = 0;
 556
 557     TRACE("(%p)->(%p)\n", This, p);
 558
 559     if(This->nsevent) {
 560         nsIDOMMouseEvent *mouse_event;
 561         nsresult nsres;
 562
 563         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 564         if(NS_SUCCEEDED(nsres)) {
 565             nsIDOMMouseEvent_GetClientY(mouse_event, &y);
 566             nsIDOMMouseEvent_Release(mouse_event);
 567         }
 568     }
 569
 570     *p = y;
 571     return S_OK;
 572 }
 573
 574 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
 575 {
 576     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 577
 578     FIXME("(%p)->(%p)\n", This, p);
 579
 580     *p = 0;
 581     return S_OK;
 582 }
 583
 584 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p)
 585 {
 586     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 587
 588     FIXME("(%p)->(%p)\n", This, p);
 589
 590     *p = 0;
 591     return S_OK;
 592 }
 593
 594 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p)
 595 {
 596     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 597     PRInt32 x = 0;
 598
 599     TRACE("(%p)->(%p)\n", This, p);
 600
 601     if(This->nsevent) {
 602         nsIDOMMouseEvent *mouse_event;
 603         nsresult nsres;
 604
 605         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 606         if(NS_SUCCEEDED(nsres)) {
 607             nsIDOMMouseEvent_GetScreenX(mouse_event, &x);
 608             nsIDOMMouseEvent_Release(mouse_event);
 609         }
 610     }
 611
 612     *p = x;
 613     return S_OK;
 614 }
 615
 616 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
 617 {
 618     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 619     PRInt32 y = 0;
 620
 621     TRACE("(%p)->(%p)\n", This, p);
 622
 623     if(This->nsevent) {
 624         nsIDOMMouseEvent *mouse_event;
 625         nsresult nsres;
 626
 627         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 628         if(NS_SUCCEEDED(nsres)) {
 629             nsIDOMMouseEvent_GetScreenY(mouse_event, &y);
 630             nsIDOMMouseEvent_Release(mouse_event);
 631         }
 632     }
 633
 634     *p = y;
 635     return S_OK;
 636 }
 637
 638 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
 639 {
 640     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 641
 642     FIXME("(%p)->(%p)\n", This, p);
 643
 644     *p = NULL;
 645     return S_OK;
 646 }
 647
 648 #undef HTMLEVENTOBJ_THIS
 649
 650 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
 651     HTMLEventObj_QueryInterface,
 652     HTMLEventObj_AddRef,
 653     HTMLEventObj_Release,
 654     HTMLEventObj_GetTypeInfoCount,
 655     HTMLEventObj_GetTypeInfo,
 656     HTMLEventObj_GetIDsOfNames,
 657     HTMLEventObj_Invoke,
 658     HTMLEventObj_get_srcElement,
 659     HTMLEventObj_get_altKey,
 660     HTMLEventObj_get_ctrlKey,
 661     HTMLEventObj_get_shiftKey,
 662     HTMLEventObj_put_returnValue,
 663     HTMLEventObj_get_returnValue,
 664     HTMLEventObj_put_cancelBubble,
 665     HTMLEventObj_get_cancelBubble,
 666     HTMLEventObj_get_fromElement,
 667     HTMLEventObj_get_toElement,
 668     HTMLEventObj_put_keyCode,
 669     HTMLEventObj_get_keyCode,
 670     HTMLEventObj_get_button,
 671     HTMLEventObj_get_type,
 672     HTMLEventObj_get_qualifier,
 673     HTMLEventObj_get_reason,
 674     HTMLEventObj_get_x,
 675     HTMLEventObj_get_y,
 676     HTMLEventObj_get_clientX,
 677     HTMLEventObj_get_clientY,
 678     HTMLEventObj_get_offsetX,
 679     HTMLEventObj_get_offsetY,
 680     HTMLEventObj_get_screenX,
 681     HTMLEventObj_get_screenY,
 682     HTMLEventObj_get_srcFilter
 683 };
 684
 685 static const tid_t HTMLEventObj_iface_tids[] = {
 686     IHTMLEventObj_tid,
 687     0
 688 };
 689
 690 static dispex_static_data_t HTMLEventObj_dispex = {
 691     NULL,
 692     DispCEventObj_tid,
 693     NULL,
 694     HTMLEventObj_iface_tids
 695 };
 696
 697 static IHTMLEventObj *create_event(HTMLDOMNode *target, eventid_t eid, nsIDOMEvent *nsevent)
 698 {
 699     HTMLEventObj *ret;
 700
 701     ret = heap_alloc(sizeof(*ret));
 702     if(!ret)
 703         return NULL;
 704
 705     ret->lpIHTMLEventObjVtbl = &HTMLEventObjVtbl;
 706     ret->ref = 1;
 707     ret->type = event_info+eid;
 708
 709     ret->nsevent = nsevent;
 710     if(nsevent) {
 711         nsIDOMEvent_AddRef(nsevent);
 712     }else if(event_types[event_info[eid].type]) {
 713         nsIDOMDocumentEvent *doc_event;
 714         nsresult nsres;
 715
 716         nsres = nsIDOMHTMLDocument_QueryInterface(target->doc->nsdoc, &IID_nsIDOMDocumentEvent,
 717                  (void**)&doc_event);
 718         if(NS_SUCCEEDED(nsres)) {
 719             nsAString type_str;
 720
 721             nsAString_Init(&type_str, event_types[event_info[eid].type]);
 722             nsres = nsIDOMDocumentEvent_CreateEvent(doc_event, &type_str, &ret->nsevent);
 723             nsAString_Finish(&type_str);
 724             nsIDOMDocumentEvent_Release(doc_event);
 725         }
 726         if(NS_FAILED(nsres)) {
 727             ERR("Could not create event: %08x\n", nsres);
 728             IHTMLEventObj_Release(HTMLEVENTOBJ(ret));
 729             return NULL;
 730         }
 731     }
 732
 733     ret->target = target;
 734     IHTMLDOMNode_AddRef(HTMLDOMNODE(target));
 735
 736     init_dispex(&ret->dispex, (IUnknown*)HTMLEVENTOBJ(ret), &HTMLEventObj_dispex);
 737
 738     return HTMLEVENTOBJ(ret);
 739 }
 740
 741 static void call_event_handlers(HTMLDocumentNode *doc, IHTMLEventObj *event_obj, event_target_t *event_target,
 742         eventid_t eid, IDispatch *this_obj)
 743 {
 744     handler_vector_t *handler_vector;
 745     DWORD i;
 746     HRESULT hres;
 747
 748     if(!event_target || !(handler_vector = event_target->event_table[eid]))
 749         return;
 750
 751     if(handler_vector->handler_prop) {
 752         DISPID named_arg = DISPID_THIS;
 753         VARIANTARG arg;
 754         DISPPARAMS dp = {&arg, &named_arg, 1, 1};
 755
 756         V_VT(&arg) = VT_DISPATCH;
 757         V_DISPATCH(&arg) = this_obj;
 758
 759         TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
 760         hres = call_disp_func(handler_vector->handler_prop, &dp);
 761         if(hres == S_OK)
 762             TRACE("%s <<<\n", debugstr_w(event_info[eid].name));
 763         else
 764             WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
 765     }
 766
 767     if(handler_vector->handler_cnt) {
 768         VARIANTARG arg;
 769         DISPPARAMS dp = {&arg, NULL, 1, 0};
 770
 771         V_VT(&arg) = VT_DISPATCH;
 772         V_DISPATCH(&arg) = (IDispatch*)event_obj;
 773
 774         for(i=0; i < handler_vector->handler_cnt; i++) {
 775             if(handler_vector->handlers[i]) {
 776                 TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
 777                 hres = call_disp_func(handler_vector->handlers[i], &dp);
 778                 if(hres == S_OK)
 779                     TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
 780                 else
 781                     WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
 782             }
 783         }
 784     }
 785 }
 786
 787 void fire_event(HTMLDocumentNode *doc, eventid_t eid, nsIDOMNode *target, nsIDOMEvent *nsevent)
 788 {
 789     IHTMLEventObj *prev_event, *event_obj = NULL;
 790     nsIDOMNode *parent, *nsnode;
 791     HTMLDOMNode *node;
 792     PRUint16 node_type;
 793
 794     TRACE("(%p) %s\n", doc, debugstr_w(event_info[eid].name));
 795
 796     prev_event = doc->basedoc.window->event;
 797     event_obj = doc->basedoc.window->event = create_event(get_node(doc, target, TRUE), eid, nsevent);
 798
 799     nsIDOMNode_GetNodeType(target, &node_type);
 800     nsnode = target;
 801     nsIDOMNode_AddRef(nsnode);
 802
 803     switch(node_type) {
 804     case ELEMENT_NODE:
 805         do {
 806             node = get_node(doc, nsnode, FALSE);
 807             if(node)
 808                 call_event_handlers(doc, event_obj, *get_node_event_target(node), eid, (IDispatch*)HTMLDOMNODE(node));
 809
 810             if(!(event_info[eid].flags & EVENT_BUBBLE))
 811                 break;
 812
 813             nsIDOMNode_GetParentNode(nsnode, &parent);
 814             nsIDOMNode_Release(nsnode);
 815             nsnode = parent;
 816             if(!nsnode)
 817                 break;
 818
 819             nsIDOMNode_GetNodeType(nsnode, &node_type);
 820         }while(node_type == ELEMENT_NODE);
 821
 822         if(!(event_info[eid].flags & EVENT_BUBBLE))
 823             break;
 824
 825     case DOCUMENT_NODE:
 826         if(event_info[eid].flags & EVENT_FORWARDBODY) {
 827             nsIDOMHTMLElement *nsbody;
 828             nsresult nsres;
 829
 830             nsres = nsIDOMHTMLDocument_GetBody(doc->nsdoc, &nsbody);
 831             if(NS_SUCCEEDED(nsres) && nsbody) {
 832                 node = get_node(doc, (nsIDOMNode*)nsbody, FALSE);
 833                 if(node)
 834                     call_event_handlers(doc, event_obj, *get_node_event_target(node), eid, (IDispatch*)HTMLDOMNODE(node));
 835                 nsIDOMHTMLElement_Release(nsbody);
 836             }else {
 837                 ERR("Could not get body: %08x\n", nsres);
 838             }
 839         }
 840
 841         call_event_handlers(doc, event_obj, doc->basedoc.doc_node->node.event_target, eid,
 842                 (IDispatch*)HTMLDOC(&doc->basedoc));
 843         break;
 844
 845     default:
 846         FIXME("unimplemented node type %d\n", node_type);
 847     }
 848
 849     if(nsnode)
 850         nsIDOMNode_Release(nsnode);
 851
 852     IHTMLEventObj_Release(event_obj);
 853     doc->basedoc.window->event = prev_event;
 854 }
 855
 856 HRESULT dispatch_event(HTMLDOMNode *node, const WCHAR *event_name, VARIANT *event_obj, VARIANT_BOOL *cancelled)
 857 {
 858     eventid_t eid;
 859
 860     eid = attr_to_eid(event_name);
 861     if(eid == EVENTID_LAST) {
 862         WARN("unknown event %s\n", debugstr_w(event_name));
 863         return E_INVALIDARG;
 864     }
 865
 866     if(event_obj && V_VT(event_obj) != VT_EMPTY && V_VT(event_obj) != VT_ERROR)
 867         FIXME("event_obj not implemented\n");
 868
 869     if(!(event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
 870         FIXME("not EVENT_DEFAULTEVENTHANDLER\n");
 871         return E_NOTIMPL;
 872     }
 873
 874     fire_event(node->doc, eid, node->nsnode, NULL);
 875
 876     *cancelled = VARIANT_TRUE; /* FIXME */
 877     return S_OK;
 878 }
 879
 880 HRESULT call_event(HTMLDOMNode *node, eventid_t eid)
 881 {
 882     HRESULT hres;
 883
 884     if(node->vtbl->call_event) {
 885         BOOL handled = FALSE;
 886
 887         hres = node->vtbl->call_event(node, eid, &handled);
 888         if(handled)
 889             return hres;
 890     }
 891
 892     fire_event(node->doc, eid, node->nsnode, NULL);
 893     return S_OK;
 894 }
 895
 896 static inline event_target_t *get_event_target(event_target_t **event_target_ptr)
 897 {
 898     if(!*event_target_ptr)
 899         *event_target_ptr = heap_alloc_zero(sizeof(event_target_t));
 900     return *event_target_ptr;
 901 }
 902
 903 static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt)
 904 {
 905     handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid];
 906
 907     if(handler_vector) {
 908         if(cnt <= handler_vector->handler_cnt)
 909             return TRUE;
 910
 911         new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
 912     }else {
 913         new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
 914     }
 915
 916     if(!new_vector)
 917         return FALSE;
 918
 919     new_vector->handler_cnt = cnt;
 920     event_target->event_table[eid] = new_vector;
 921     return TRUE;
 922 }
 923
 924 static HRESULT set_event_handler_disp(event_target_t **event_target_ptr, HTMLDocumentNode *doc,
 925         eventid_t eid, IDispatch *disp)
 926 {
 927     event_target_t *event_target;
 928
 929     event_target = get_event_target(event_target_ptr);
 930     if(!event_target)
 931         return E_OUTOFMEMORY;
 932
 933     if(!alloc_handler_vector(event_target, eid, 0))
 934         return E_OUTOFMEMORY;
 935
 936     if(event_target->event_table[eid]->handler_prop)
 937         IDispatch_Release(event_target->event_table[eid]->handler_prop);
 938
 939     event_target->event_table[eid]->handler_prop = disp;
 940     if(!disp)
 941         return S_OK;
 942     IDispatch_AddRef(disp);
 943
 944     if(doc->nsdoc && (event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
 945         if(!doc->event_vector) {
 946             doc->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
 947             if(!doc->event_vector)
 948                 return E_OUTOFMEMORY;
 949         }
 950
 951         if(!doc->event_vector[eid]) {
 952             doc->event_vector[eid] = TRUE;
 953             add_nsevent_listener(doc, event_info[eid].name);
 954         }
 955     }
 956
 957     return S_OK;
 958 }
 959
 960 HRESULT set_event_handler(event_target_t **event_target, HTMLDocumentNode *doc, eventid_t eid, VARIANT *var)
 961 {
 962     switch(V_VT(var)) {
 963     case VT_NULL:
 964         if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
 965             IDispatch_Release((*event_target)->event_table[eid]->handler_prop);
 966             (*event_target)->event_table[eid]->handler_prop = NULL;
 967         }
 968         break;
 969
 970     case VT_DISPATCH:
 971         return set_event_handler_disp(event_target, doc, eid, V_DISPATCH(var));
 972
 973     default:
 974         FIXME("not supported vt=%d\n", V_VT(var));
 975         return E_NOTIMPL;
 976     }
 977
 978     return S_OK;
 979 }
 980
 981 HRESULT get_event_handler(event_target_t **event_target, eventid_t eid, VARIANT *var)
 982 {
 983     if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
 984         V_VT(var) = VT_DISPATCH;
 985         V_DISPATCH(var) = (*event_target)->event_table[eid]->handler_prop;
 986         IDispatch_AddRef(V_DISPATCH(var));
 987     }else {
 988         V_VT(var) = VT_NULL;
 989     }
 990
 991     return S_OK;
 992 }
 993
 994 HRESULT attach_event(event_target_t **event_target_ptr, HTMLDocument *doc, BSTR name, IDispatch *disp, VARIANT_BOOL *res)
 995 {
 996     event_target_t *event_target;
 997     eventid_t eid;
 998     DWORD i = 0;
 999
1000     eid = attr_to_eid(name);
1001     if(eid == EVENTID_LAST) {
1002         WARN("Unknown event\n");
1003         *res = VARIANT_TRUE;
1004         return S_OK;
1005     }
1006
1007     event_target = get_event_target(event_target_ptr);
1008     if(!event_target)
1009         return E_OUTOFMEMORY;
1010
1011     if(event_target->event_table[eid]) {
1012         while(i < event_target->event_table[eid]->handler_cnt && event_target->event_table[eid]->handlers[i])
1013             i++;
1014         if(i == event_target->event_table[eid]->handler_cnt && !alloc_handler_vector(event_target, eid, i+1))
1015             return E_OUTOFMEMORY;
1016     }else if(!alloc_handler_vector(event_target, eid, i+1)) {
1017         return E_OUTOFMEMORY;
1018     }
1019
1020     IDispatch_AddRef(disp);
1021     event_target->event_table[eid]->handlers[i] = disp;
1022
1023     *res = VARIANT_TRUE;
1024     return S_OK;
1025 }
1026
1027 void check_event_attr(HTMLDocumentNode *doc, nsIDOMElement *nselem)
1028 {
1029     const PRUnichar *attr_value;
1030     nsAString attr_name_str, attr_value_str;
1031     IDispatch *disp;
1032     HTMLDOMNode *node;
1033     int i;
1034     nsresult nsres;
1035
1036     nsAString_Init(&attr_value_str, NULL);
1037     nsAString_Init(&attr_name_str, NULL);
1038
1039     for(i=0; i < EVENTID_LAST; i++) {
1040         nsAString_SetData(&attr_name_str, event_info[i].attr_name);
1041         nsres = nsIDOMElement_GetAttribute(nselem, &attr_name_str, &attr_value_str);
1042         if(NS_SUCCEEDED(nsres)) {
1043             nsAString_GetData(&attr_value_str, &attr_value);
1044             if(!*attr_value)
1045                 continue;
1046
1047             TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
1048
1049             disp = script_parse_event(doc->basedoc.window, attr_value);
1050             if(disp) {
1051                 node = get_node(doc, (nsIDOMNode*)nselem, TRUE);
1052                 set_event_handler_disp(get_node_event_target(node), node->doc, i, disp);
1053                 IDispatch_Release(disp);
1054             }
1055         }
1056     }
1057
1058     nsAString_Finish(&attr_value_str);
1059     nsAString_Finish(&attr_name_str);
1060 }
1061
1062 void release_event_target(event_target_t *event_target)
1063 {
1064     int i, j;
1065
1066     for(i=0; i < EVENTID_LAST; i++) {
1067         if(event_target->event_table[i]) {
1068             if(event_target->event_table[i]->handler_prop)
1069                 IDispatch_Release(event_target->event_table[i]->handler_prop);
1070             for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
1071                 IDispatch_Release(event_target->event_table[i]->handlers[j]);
1072         }
1073     }
1074
1075     heap_free(event_target);
1076 }