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
  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 blurW[] = {'b','l','u','r',0};
  46 static const WCHAR onblurW[] = {'o','n','b','l','u','r',0};
  47
  48 static const WCHAR changeW[] = {'c','h','a','n','g','e',0};
  49 static const WCHAR onchangeW[] = {'o','n','c','h','a','n','g','e',0};
  50
  51 static const WCHAR clickW[] = {'c','l','i','c','k',0};
  52 static const WCHAR onclickW[] = {'o','n','c','l','i','c','k',0};
  53
  54 static const WCHAR dragW[] = {'d','r','a','g',0};
  55 static const WCHAR ondragW[] = {'o','n','d','r','a','g',0};
  56
  57 static const WCHAR dragstartW[] = {'d','r','a','g','s','t','a','r','t',0};
  58 static const WCHAR ondragstartW[] = {'o','n','d','r','a','g','s','t','a','r','t',0};
  59
  60 static const WCHAR focusW[] = {'f','o','c','u','s',0};
  61 static const WCHAR onfocusW[] = {'o','n','f','o','c','u','s',0};
  62
  63 static const WCHAR keydownW[] = {'k','e','y','d','o','w','n',0};
  64 static const WCHAR onkeydownW[] = {'o','n','k','e','y','d','o','w','n',0};
  65
  66 static const WCHAR keyupW[] = {'k','e','y','u','p',0};
  67 static const WCHAR onkeyupW[] = {'o','n','k','e','y','u','p',0};
  68
  69 static const WCHAR loadW[] = {'l','o','a','d',0};
  70 static const WCHAR onloadW[] = {'o','n','l','o','a','d',0};
  71
  72 static const WCHAR mousedownW[] = {'m','o','u','s','e','d','o','w','n',0};
  73 static const WCHAR onmousedownW[] = {'o','n','m','o','u','s','e','d','o','w','n',0};
  74
  75 static const WCHAR mouseoutW[] = {'m','o','u','s','e','o','u','t',0};
  76 static const WCHAR onmouseoutW[] = {'o','n','m','o','u','s','e','o','u','t',0};
  77
  78 static const WCHAR mouseoverW[] = {'m','o','u','s','e','o','v','e','r',0};
  79 static const WCHAR onmouseoverW[] = {'o','n','m','o','u','s','e','o','v','e','r',0};
  80
  81 static const WCHAR mouseupW[] = {'m','o','u','s','e','u','p',0};
  82 static const WCHAR onmouseupW[] = {'o','n','m','o','u','s','e','u','p',0};
  83
  84 static const WCHAR pasteW[] = {'p','a','s','t','e',0};
  85 static const WCHAR onpasteW[] = {'o','n','p','a','s','t','e',0};
  86
  87 static const WCHAR selectstartW[] = {'s','e','l','e','c','t','s','t','a','r','t',0};
  88 static const WCHAR onselectstartW[] = {'o','n','s','e','l','e','c','t','s','t','a','r','t',0};
  89
  90 typedef struct {
  91     LPCWSTR name;
  92     LPCWSTR attr_name;
  93     DWORD flags;
  94 } event_info_t;
  95
  96 #define EVENT_DEFAULTLISTENER    0x0001
  97 #define EVENT_BUBBLE             0x0002
  98
  99 static const event_info_t event_info[] = {
 100     {blurW,         onblurW,         EVENT_DEFAULTLISTENER},
 101     {changeW,       onchangeW,       EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 102     {clickW,        onclickW,        EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 103     {dragW,         ondragW,         0},
 104     {dragstartW,    ondragstartW,    0},
 105     {focusW,        onfocusW,        EVENT_DEFAULTLISTENER},
 106     {keydownW,      onkeydownW,      EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 107     {keyupW,        onkeyupW,        EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 108     {loadW,         onloadW,         0},
 109     {mousedownW,    onmousedownW,    EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 110     {mouseoutW,     onmouseoutW,     EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 111     {mouseoverW,    onmouseoverW,    EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 112     {mouseupW,      onmouseupW,      EVENT_DEFAULTLISTENER|EVENT_BUBBLE},
 113     {pasteW,        onpasteW,        0},
 114     {selectstartW,  onselectstartW,  0}
 115 };
 116
 117 eventid_t str_to_eid(LPCWSTR str)
 118 {
 119     int i;
 120
 121     for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
 122         if(!strcmpW(event_info[i].name, str))
 123             return i;
 124     }
 125
 126     ERR("unknown type %s\n", debugstr_w(str));
 127     return EVENTID_LAST;
 128 }
 129
 130 static eventid_t attr_to_eid(LPCWSTR str)
 131 {
 132     int i;
 133
 134     for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
 135         if(!strcmpW(event_info[i].attr_name, str))
 136             return i;
 137     }
 138
 139     return EVENTID_LAST;
 140 }
 141
 142 typedef struct {
 143     DispatchEx dispex;
 144     const IHTMLEventObjVtbl  *lpIHTMLEventObjVtbl;
 145
 146     LONG ref;
 147
 148     HTMLDOMNode *target;
 149     const event_info_t *type;
 150     nsIDOMEvent *nsevent;
 151 } HTMLEventObj;
 152
 153 #define HTMLEVENTOBJ(x) ((IHTMLEventObj*) &(x)->lpIHTMLEventObjVtbl)
 154
 155 #define HTMLEVENTOBJ_THIS(iface) DEFINE_THIS(HTMLEventObj, IHTMLEventObj, iface)
 156
 157 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
 158 {
 159     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 160
 161     *ppv = NULL;
 162
 163     if(IsEqualGUID(&IID_IUnknown, riid)) {
 164         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 165         *ppv = HTMLEVENTOBJ(This);
 166     }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) {
 167         TRACE("(%p)->(IID_IHTMLEventObj %p)\n", This, ppv);
 168         *ppv = HTMLEVENTOBJ(This);
 169     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 170         return *ppv ? S_OK : E_NOINTERFACE;
 171     }
 172
 173     if(*ppv) {
 174         IUnknown_AddRef((IUnknown*)*ppv);
 175         return S_OK;
 176     }
 177
 178     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 179     return E_NOINTERFACE;
 180 }
 181
 182 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
 183 {
 184     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 185     LONG ref = InterlockedIncrement(&This->ref);
 186
 187     TRACE("(%p) ref=%d\n", This, ref);
 188
 189     return ref;
 190 }
 191
 192 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
 193 {
 194     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 195     LONG ref = InterlockedDecrement(&This->ref);
 196
 197     TRACE("(%p) ref=%d\n", This, ref);
 198
 199     if(!ref) {
 200         if(This->nsevent)
 201             nsIDOMEvent_Release(This->nsevent);
 202         release_dispex(&This->dispex);
 203         heap_free(This);
 204     }
 205
 206     return ref;
 207 }
 208
 209 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
 210 {
 211     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 212     FIXME("(%p)->(%p)\n", This, pctinfo);
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
 217                                               LCID lcid, ITypeInfo **ppTInfo)
 218 {
 219     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 220     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 221     return E_NOTIMPL;
 222 }
 223
 224 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
 225                                                 LPOLESTR *rgszNames, UINT cNames,
 226                                                 LCID lcid, DISPID *rgDispId)
 227 {
 228     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 229     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 230           lcid, rgDispId);
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
 235                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 236                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 237 {
 238     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 239     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 240           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 241     return E_NOTIMPL;
 242 }
 243
 244 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
 245 {
 246     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 247
 248     TRACE("(%p)->(%p)\n", This, p);
 249
 250     return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(This->target), &IID_IHTMLElement, (void**)p);
 251 }
 252
 253 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 254 {
 255     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 256     PRBool ret = FALSE;
 257
 258     TRACE("(%p)->(%p)\n", This, p);
 259
 260     if(This->nsevent) {
 261         nsIDOMKeyEvent *key_event;
 262         nsresult nsres;
 263
 264         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 265         if(NS_SUCCEEDED(nsres)) {
 266             nsIDOMKeyEvent_GetAltKey(key_event, &ret);
 267             nsIDOMKeyEvent_Release(key_event);
 268         }else {
 269             nsIDOMMouseEvent *mouse_event;
 270
 271             nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 272             if(NS_SUCCEEDED(nsres)) {
 273                 nsIDOMMouseEvent_GetAltKey(mouse_event, &ret);
 274                 nsIDOMMouseEvent_Release(mouse_event);
 275             }
 276         }
 277     }
 278
 279     *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
 280     return S_OK;
 281 }
 282
 283 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 284 {
 285     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 286     PRBool ret = FALSE;
 287
 288     TRACE("(%p)->(%p)\n", This, p);
 289
 290     if(This->nsevent) {
 291         nsIDOMKeyEvent *key_event;
 292         nsresult nsres;
 293
 294         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 295         if(NS_SUCCEEDED(nsres)) {
 296             nsIDOMKeyEvent_GetCtrlKey(key_event, &ret);
 297             nsIDOMKeyEvent_Release(key_event);
 298         }else {
 299             nsIDOMMouseEvent *mouse_event;
 300
 301             nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 302             if(NS_SUCCEEDED(nsres)) {
 303                 nsIDOMMouseEvent_GetCtrlKey(mouse_event, &ret);
 304                 nsIDOMMouseEvent_Release(mouse_event);
 305             }
 306         }
 307     }
 308
 309     *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 314 {
 315     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 316     PRBool ret = FALSE;
 317
 318     TRACE("(%p)->(%p)\n", This, p);
 319
 320     if(This->nsevent) {
 321         nsIDOMKeyEvent *key_event;
 322         nsresult nsres;
 323
 324         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMKeyEvent, (void**)&key_event);
 325         if(NS_SUCCEEDED(nsres)) {
 326             nsIDOMKeyEvent_GetShiftKey(key_event, &ret);
 327             nsIDOMKeyEvent_Release(key_event);
 328         }else {
 329             nsIDOMMouseEvent *mouse_event;
 330
 331             nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 332             if(NS_SUCCEEDED(nsres)) {
 333                 nsIDOMMouseEvent_GetShiftKey(mouse_event, &ret);
 334                 nsIDOMMouseEvent_Release(mouse_event);
 335             }
 336         }
 337     }
 338
 339     *p = ret ? VARIANT_TRUE : VARIANT_FALSE;
 340     return S_OK;
 341 }
 342
 343 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
 344 {
 345     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 346     FIXME("(%p)->()\n", This);
 347     return E_NOTIMPL;
 348 }
 349
 350 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
 351 {
 352     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 353
 354     FIXME("(%p)->(%p)\n", This, p);
 355
 356     V_VT(p) = VT_EMPTY;
 357     return S_OK;
 358 }
 359
 360 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
 361 {
 362     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 363     FIXME("(%p)->(%x)\n", This, v);
 364     return E_NOTIMPL;
 365 }
 366
 367 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
 368 {
 369     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 370
 371     FIXME("(%p)->(%p)\n", This, p);
 372
 373     *p = VARIANT_FALSE;
 374     return S_OK;
 375 }
 376
 377 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
 378 {
 379     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 380
 381     FIXME("(%p)->(%p)\n", This, p);
 382
 383     *p = NULL;
 384     return S_OK;
 385 }
 386
 387 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
 388 {
 389     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 390
 391     FIXME("(%p)->(%p)\n", This, p);
 392
 393     *p = NULL;
 394     return S_OK;
 395 }
 396
 397 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, LONG v)
 398 {
 399     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 400     FIXME("(%p)->(%d)\n", This, v);
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, LONG *p)
 405 {
 406     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 407     PRUint32 key_code = 0;
 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_GetKeyCode(key_event, &key_code);
 418             nsIDOMKeyEvent_Release(key_event);
 419         }
 420     }
 421
 422     *p = key_code;
 423     return S_OK;
 424 }
 425
 426 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, LONG *p)
 427 {
 428     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 429     PRUint16 button = 0;
 430
 431     TRACE("(%p)->(%p)\n", This, p);
 432
 433     if(This->nsevent) {
 434         nsIDOMMouseEvent *mouse_event;
 435         nsresult nsres;
 436
 437         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 438         if(NS_SUCCEEDED(nsres)) {
 439             nsIDOMMouseEvent_GetButton(mouse_event, &button);
 440             nsIDOMMouseEvent_Release(mouse_event);
 441         }
 442     }
 443
 444     *p = button;
 445     return S_OK;
 446 }
 447
 448 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
 449 {
 450     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 451
 452     TRACE("(%p)->(%p)\n", This, p);
 453
 454     *p = SysAllocString(This->type->name);
 455     return *p ? S_OK : E_OUTOFMEMORY;
 456 }
 457
 458 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
 459 {
 460     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 461
 462     FIXME("(%p)->(%p)\n", This, p);
 463
 464     *p = NULL;
 465     return S_OK;
 466 }
 467
 468 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, LONG *p)
 469 {
 470     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 471
 472     FIXME("(%p)->(%p)\n", This, p);
 473
 474     *p = 0;
 475     return S_OK;
 476 }
 477
 478 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, LONG *p)
 479 {
 480     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 481
 482     FIXME("(%p)->(%p)\n", This, p);
 483
 484     *p = -1;
 485     return S_OK;
 486 }
 487
 488 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, LONG *p)
 489 {
 490     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 491
 492     FIXME("(%p)->(%p)\n", This, p);
 493
 494     *p = -1;
 495     return S_OK;
 496 }
 497
 498 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, LONG *p)
 499 {
 500     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 501     PRInt32 x = 0;
 502
 503     TRACE("(%p)->(%p)\n", This, p);
 504
 505     if(This->nsevent) {
 506         nsIDOMMouseEvent *mouse_event;
 507         nsresult nsres;
 508
 509         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 510         if(NS_SUCCEEDED(nsres)) {
 511             nsIDOMMouseEvent_GetClientX(mouse_event, &x);
 512             nsIDOMMouseEvent_Release(mouse_event);
 513         }
 514     }
 515
 516     *p = x;
 517     return S_OK;
 518 }
 519
 520 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, LONG *p)
 521 {
 522     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 523     PRInt32 y = 0;
 524
 525     TRACE("(%p)->(%p)\n", This, p);
 526
 527     if(This->nsevent) {
 528         nsIDOMMouseEvent *mouse_event;
 529         nsresult nsres;
 530
 531         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 532         if(NS_SUCCEEDED(nsres)) {
 533             nsIDOMMouseEvent_GetClientY(mouse_event, &y);
 534             nsIDOMMouseEvent_Release(mouse_event);
 535         }
 536     }
 537
 538     *p = y;
 539     return S_OK;
 540 }
 541
 542 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, LONG *p)
 543 {
 544     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 545
 546     FIXME("(%p)->(%p)\n", This, p);
 547
 548     *p = 0;
 549     return S_OK;
 550 }
 551
 552 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, LONG *p)
 553 {
 554     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 555
 556     FIXME("(%p)->(%p)\n", This, p);
 557
 558     *p = 0;
 559     return S_OK;
 560 }
 561
 562 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, LONG *p)
 563 {
 564     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 565     PRInt32 x = 0;
 566
 567     TRACE("(%p)->(%p)\n", This, p);
 568
 569     if(This->nsevent) {
 570         nsIDOMMouseEvent *mouse_event;
 571         nsresult nsres;
 572
 573         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 574         if(NS_SUCCEEDED(nsres)) {
 575             nsIDOMMouseEvent_GetScreenX(mouse_event, &x);
 576             nsIDOMMouseEvent_Release(mouse_event);
 577         }
 578     }
 579
 580     *p = x;
 581     return S_OK;
 582 }
 583
 584 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, LONG *p)
 585 {
 586     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 587     PRInt32 y = 0;
 588
 589     TRACE("(%p)->(%p)\n", This, p);
 590
 591     if(This->nsevent) {
 592         nsIDOMMouseEvent *mouse_event;
 593         nsresult nsres;
 594
 595         nsres = nsIDOMEvent_QueryInterface(This->nsevent, &IID_nsIDOMMouseEvent, (void**)&mouse_event);
 596         if(NS_SUCCEEDED(nsres)) {
 597             nsIDOMMouseEvent_GetScreenY(mouse_event, &y);
 598             nsIDOMMouseEvent_Release(mouse_event);
 599         }
 600     }
 601
 602     *p = y;
 603     return S_OK;
 604 }
 605
 606 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
 607 {
 608     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 609
 610     FIXME("(%p)->(%p)\n", This, p);
 611
 612     *p = NULL;
 613     return S_OK;
 614 }
 615
 616 #undef HTMLEVENTOBJ_THIS
 617
 618 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
 619     HTMLEventObj_QueryInterface,
 620     HTMLEventObj_AddRef,
 621     HTMLEventObj_Release,
 622     HTMLEventObj_GetTypeInfoCount,
 623     HTMLEventObj_GetTypeInfo,
 624     HTMLEventObj_GetIDsOfNames,
 625     HTMLEventObj_Invoke,
 626     HTMLEventObj_get_srcElement,
 627     HTMLEventObj_get_altKey,
 628     HTMLEventObj_get_ctrlKey,
 629     HTMLEventObj_get_shiftKey,
 630     HTMLEventObj_put_returnValue,
 631     HTMLEventObj_get_returnValue,
 632     HTMLEventObj_put_cancelBubble,
 633     HTMLEventObj_get_cancelBubble,
 634     HTMLEventObj_get_fromElement,
 635     HTMLEventObj_get_toElement,
 636     HTMLEventObj_put_keyCode,
 637     HTMLEventObj_get_keyCode,
 638     HTMLEventObj_get_button,
 639     HTMLEventObj_get_type,
 640     HTMLEventObj_get_qualifier,
 641     HTMLEventObj_get_reason,
 642     HTMLEventObj_get_x,
 643     HTMLEventObj_get_y,
 644     HTMLEventObj_get_clientX,
 645     HTMLEventObj_get_clientY,
 646     HTMLEventObj_get_offsetX,
 647     HTMLEventObj_get_offsetY,
 648     HTMLEventObj_get_screenX,
 649     HTMLEventObj_get_screenY,
 650     HTMLEventObj_get_srcFilter
 651 };
 652
 653 static const tid_t HTMLEventObj_iface_tids[] = {
 654     IHTMLEventObj_tid,
 655     0
 656 };
 657
 658 static dispex_static_data_t HTMLEventObj_dispex = {
 659     NULL,
 660     DispCEventObj_tid,
 661     NULL,
 662     HTMLEventObj_iface_tids
 663 };
 664
 665 static IHTMLEventObj *create_event(HTMLDOMNode *target, eventid_t eid, nsIDOMEvent *nsevent)
 666 {
 667     HTMLEventObj *ret;
 668
 669     ret = heap_alloc(sizeof(*ret));
 670     ret->lpIHTMLEventObjVtbl = &HTMLEventObjVtbl;
 671     ret->ref = 1;
 672     ret->type = event_info+eid;
 673     ret->target = target;
 674     IHTMLDOMNode_AddRef(HTMLDOMNODE(target));
 675
 676     ret->nsevent = nsevent;
 677     if(nsevent)
 678         nsIDOMEvent_AddRef(nsevent);
 679
 680     init_dispex(&ret->dispex, (IUnknown*)HTMLEVENTOBJ(ret), &HTMLEventObj_dispex);
 681
 682     return HTMLEVENTOBJ(ret);
 683 }
 684
 685 static void call_event_handlers(HTMLDocument *doc, IHTMLEventObj *event_obj, event_target_t *event_target,
 686         eventid_t eid, IDispatch *this_obj)
 687 {
 688     handler_vector_t *handler_vector;
 689     DWORD i;
 690     HRESULT hres;
 691
 692     if(!event_target || !(handler_vector = event_target->event_table[eid]))
 693         return;
 694
 695     if(handler_vector->handler_prop) {
 696         DISPID named_arg = DISPID_THIS;
 697         VARIANTARG arg;
 698         DISPPARAMS dp = {&arg, &named_arg, 1, 1};
 699
 700         V_VT(&arg) = VT_DISPATCH;
 701         V_DISPATCH(&arg) = this_obj;
 702
 703         TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
 704         hres = call_disp_func(handler_vector->handler_prop, &dp);
 705         if(hres == S_OK)
 706             TRACE("%s <<<\n", debugstr_w(event_info[eid].name));
 707         else
 708             WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres);
 709     }
 710
 711     if(handler_vector->handler_cnt) {
 712         VARIANTARG arg;
 713         DISPPARAMS dp = {&arg, NULL, 1, 0};
 714
 715         V_VT(&arg) = VT_DISPATCH;
 716         V_DISPATCH(&arg) = (IDispatch*)event_obj;
 717
 718         for(i=0; i < handler_vector->handler_cnt; i++) {
 719             if(handler_vector->handlers[i]) {
 720                 TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i);
 721                 hres = call_disp_func(handler_vector->handlers[i], &dp);
 722                 if(hres == S_OK)
 723                     TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i);
 724                 else
 725                     WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres);
 726             }
 727         }
 728     }
 729 }
 730
 731 void fire_event(HTMLDocument *doc, eventid_t eid, nsIDOMNode *target, nsIDOMEvent *nsevent)
 732 {
 733     IHTMLEventObj *prev_event, *event_obj = NULL;
 734     nsIDOMNode *parent, *nsnode;
 735     HTMLDOMNode *node;
 736     PRUint16 node_type;
 737
 738     nsIDOMNode_GetNodeType(target, &node_type);
 739     if(node_type != ELEMENT_NODE) {
 740         FIXME("node type %d node supported\n", node_type);
 741         return;
 742     }
 743
 744     prev_event = doc->window->event;
 745     event_obj = doc->window->event = create_event(get_node(doc, target, TRUE), eid, nsevent);
 746     nsnode = target;
 747     nsIDOMNode_AddRef(nsnode);
 748
 749     while(1) {
 750         node = get_node(doc, nsnode, FALSE);
 751
 752         if(node)
 753             call_event_handlers(doc, event_obj, node->event_target, eid, (IDispatch*)HTMLDOMNODE(node));
 754
 755         if(!(event_info[eid].flags & EVENT_BUBBLE))
 756             break;
 757
 758         nsIDOMNode_GetParentNode(nsnode, &parent);
 759         nsIDOMNode_Release(nsnode);
 760         nsnode = parent;
 761         if(!nsnode)
 762             break;
 763
 764         nsIDOMNode_GetNodeType(nsnode, &node_type);
 765         if(node_type != ELEMENT_NODE)
 766             break;
 767     }
 768
 769     if(nsnode)
 770         nsIDOMNode_Release(nsnode);
 771
 772     if(event_info[eid].flags & EVENT_BUBBLE)
 773         call_event_handlers(doc, event_obj, doc->event_target, eid, (IDispatch*)HTMLDOC(doc));
 774
 775     IHTMLEventObj_Release(event_obj);
 776     doc->window->event = prev_event;
 777 }
 778
 779 static inline event_target_t *get_event_target(event_target_t **event_target_ptr)
 780 {
 781     if(!*event_target_ptr)
 782         *event_target_ptr = heap_alloc_zero(sizeof(event_target_t));
 783     return *event_target_ptr;
 784 }
 785
 786 static BOOL alloc_handler_vector(event_target_t *event_target, eventid_t eid, int cnt)
 787 {
 788     handler_vector_t *new_vector, *handler_vector = event_target->event_table[eid];
 789
 790     if(handler_vector) {
 791         if(cnt <= handler_vector->handler_cnt)
 792             return TRUE;
 793
 794         new_vector = heap_realloc_zero(handler_vector, sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
 795     }else {
 796         new_vector = heap_alloc_zero(sizeof(handler_vector_t) + sizeof(IDispatch*)*cnt);
 797     }
 798
 799     if(!new_vector)
 800         return FALSE;
 801
 802     new_vector->handler_cnt = cnt;
 803     event_target->event_table[eid] = new_vector;
 804     return TRUE;
 805 }
 806
 807 static HRESULT set_event_handler_disp(event_target_t **event_target_ptr, HTMLDocument *doc, eventid_t eid, IDispatch *disp)
 808 {
 809     event_target_t *event_target;
 810
 811     event_target = get_event_target(event_target_ptr);
 812     if(!event_target)
 813         return E_OUTOFMEMORY;
 814
 815     if(!alloc_handler_vector(event_target, eid, 0))
 816         return E_OUTOFMEMORY;
 817
 818     if(event_target->event_table[eid]->handler_prop)
 819         IDispatch_Release(event_target->event_table[eid]->handler_prop);
 820
 821     event_target->event_table[eid]->handler_prop = disp;
 822     if(!disp)
 823         return S_OK;
 824     IDispatch_AddRef(disp);
 825
 826     if(doc->nscontainer && (event_info[eid].flags & EVENT_DEFAULTLISTENER)) {
 827         if(!doc->nscontainer->event_vector) {
 828             doc->nscontainer->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
 829             if(!doc->nscontainer->event_vector)
 830                 return E_OUTOFMEMORY;
 831         }
 832
 833         if(!doc->nscontainer->event_vector[eid]) {
 834             doc->nscontainer->event_vector[eid] = TRUE;
 835             add_nsevent_listener(doc->nscontainer, event_info[eid].name);
 836         }
 837     }
 838
 839     return S_OK;
 840 }
 841
 842 HRESULT set_event_handler(event_target_t **event_target, HTMLDocument *doc, eventid_t eid, VARIANT *var)
 843 {
 844     switch(V_VT(var)) {
 845     case VT_NULL:
 846         if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
 847             IDispatch_Release((*event_target)->event_table[eid]->handler_prop);
 848             (*event_target)->event_table[eid]->handler_prop = NULL;
 849         }
 850         break;
 851
 852     case VT_DISPATCH:
 853         return set_event_handler_disp(event_target, doc, eid, V_DISPATCH(var));
 854
 855     default:
 856         FIXME("not supported vt=%d\n", V_VT(var));
 857         return E_NOTIMPL;
 858     }
 859
 860     return S_OK;
 861 }
 862
 863 HRESULT get_event_handler(event_target_t **event_target, eventid_t eid, VARIANT *var)
 864 {
 865     if(*event_target && (*event_target)->event_table[eid] && (*event_target)->event_table[eid]->handler_prop) {
 866         V_VT(var) = VT_DISPATCH;
 867         V_DISPATCH(var) = (*event_target)->event_table[eid]->handler_prop;
 868         IDispatch_AddRef(V_DISPATCH(var));
 869     }else {
 870         V_VT(var) = VT_NULL;
 871     }
 872
 873     return S_OK;
 874 }
 875
 876 HRESULT attach_event(event_target_t **event_target_ptr, HTMLDocument *doc, BSTR name, IDispatch *disp, VARIANT_BOOL *res)
 877 {
 878     event_target_t *event_target;
 879     eventid_t eid;
 880     DWORD i = 0;
 881
 882     eid = attr_to_eid(name);
 883     if(eid == EVENTID_LAST) {
 884         WARN("Unknown event\n");
 885         *res = VARIANT_TRUE;
 886         return S_OK;
 887     }
 888
 889     event_target = get_event_target(event_target_ptr);
 890     if(!event_target)
 891         return E_OUTOFMEMORY;
 892
 893     if(event_target->event_table[eid]) {
 894         while(i < event_target->event_table[eid]->handler_cnt && event_target->event_table[eid]->handlers[i])
 895             i++;
 896         if(i == event_target->event_table[eid]->handler_cnt && !alloc_handler_vector(event_target, eid, i+1))
 897             return E_OUTOFMEMORY;
 898     }else if(!alloc_handler_vector(event_target, eid, i+1)) {
 899         return E_OUTOFMEMORY;
 900     }
 901
 902     IDispatch_AddRef(disp);
 903     event_target->event_table[eid]->handlers[i] = disp;
 904
 905     *res = VARIANT_TRUE;
 906     return S_OK;
 907 }
 908
 909 void check_event_attr(HTMLDocument *doc, nsIDOMElement *nselem)
 910 {
 911     const PRUnichar *attr_value;
 912     nsAString attr_name_str, attr_value_str;
 913     IDispatch *disp;
 914     HTMLDOMNode *node;
 915     int i;
 916     nsresult nsres;
 917
 918     nsAString_Init(&attr_value_str, NULL);
 919     nsAString_Init(&attr_name_str, NULL);
 920
 921     for(i=0; i < EVENTID_LAST; i++) {
 922         nsAString_SetData(&attr_name_str, event_info[i].attr_name);
 923         nsres = nsIDOMElement_GetAttribute(nselem, &attr_name_str, &attr_value_str);
 924         if(NS_SUCCEEDED(nsres)) {
 925             nsAString_GetData(&attr_value_str, &attr_value);
 926             if(!*attr_value)
 927                 continue;
 928
 929             TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
 930
 931             disp = script_parse_event(doc, attr_value);
 932             if(disp) {
 933                 node = get_node(doc, (nsIDOMNode*)nselem, TRUE);
 934                 set_event_handler_disp(&node->event_target, node->doc, i, disp);
 935                 IDispatch_Release(disp);
 936             }
 937         }
 938     }
 939
 940     nsAString_Finish(&attr_value_str);
 941     nsAString_Finish(&attr_name_str);
 942 }
 943
 944 void release_event_target(event_target_t *event_target)
 945 {
 946     int i, j;
 947
 948     for(i=0; i < EVENTID_LAST; i++) {
 949         if(event_target->event_table[i]) {
 950             if(event_target->event_table[i]->handler_prop)
 951                 IDispatch_Release(event_target->event_table[i]->handler_prop);
 952             for(j=0; j < event_target->event_table[i]->handler_cnt; j++)
 953                 IDispatch_Release(event_target->event_table[i]->handlers[j]);
 954         }
 955     }
 956
 957     heap_free(event_target);
 958 }