dlls/mshtml/htmlevent.c

   1 /*
   2  * Copyright 2008 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 struct event_target_t {
  36     IDispatch *event_table[EVENTID_LAST];
  37 };
  38
  39 static const WCHAR changeW[] = {'c','h','a','n','g','e',0};
  40 static const WCHAR onchangeW[] = {'o','n','c','h','a','n','g','e',0};
  41
  42 static const WCHAR clickW[] = {'c','l','i','c','k',0};
  43 static const WCHAR onclickW[] = {'o','n','c','l','i','c','k',0};
  44
  45 static const WCHAR keyupW[] = {'k','e','y','u','p',0};
  46 static const WCHAR onkeyupW[] = {'o','n','k','e','y','u','p',0};
  47
  48 static const WCHAR loadW[] = {'l','o','a','d',0};
  49 static const WCHAR onloadW[] = {'o','n','l','o','a','d',0};
  50
  51 typedef struct {
  52     LPCWSTR name;
  53     LPCWSTR attr_name;
  54     DWORD flags;
  55 } event_info_t;
  56
  57 #define EVENT_DEFAULTLISTENER    0x0001
  58
  59 static const event_info_t event_info[] = {
  60     {changeW,   onchangeW,   EVENT_DEFAULTLISTENER},
  61     {clickW,    onclickW,    EVENT_DEFAULTLISTENER},
  62     {keyupW,    onkeyupW,    EVENT_DEFAULTLISTENER},
  63     {loadW,     onloadW,     0}
  64 };
  65
  66 eventid_t str_to_eid(LPCWSTR str)
  67 {
  68     int i;
  69
  70     for(i=0; i < sizeof(event_info)/sizeof(event_info[0]); i++) {
  71         if(!strcmpW(event_info[i].name, str))
  72             return i;
  73     }
  74
  75     ERR("unknown type %s\n", debugstr_w(str));
  76     return EVENTID_LAST;
  77 }
  78
  79 typedef struct {
  80     DispatchEx dispex;
  81     const IHTMLEventObjVtbl  *lpIHTMLEventObjVtbl;
  82     LONG ref;
  83 } HTMLEventObj;
  84
  85 #define HTMLEVENTOBJ(x) ((IHTMLEventObj*) &(x)->lpIHTMLEventObjVtbl)
  86
  87 #define HTMLEVENTOBJ_THIS(iface) DEFINE_THIS(HTMLEventObj, IHTMLEventObj, iface)
  88
  89 static HRESULT WINAPI HTMLEventObj_QueryInterface(IHTMLEventObj *iface, REFIID riid, void **ppv)
  90 {
  91     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
  92
  93     *ppv = NULL;
  94
  95     if(IsEqualGUID(&IID_IUnknown, riid)) {
  96         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  97         *ppv = HTMLEVENTOBJ(This);
  98     }else if(IsEqualGUID(&IID_IHTMLEventObj, riid)) {
  99         TRACE("(%p)->(IID_IHTMLEventObj %p)\n", This, ppv);
 100         *ppv = HTMLEVENTOBJ(This);
 101     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 102         return *ppv ? S_OK : E_NOINTERFACE;
 103     }
 104
 105     if(*ppv) {
 106         IUnknown_AddRef((IUnknown*)*ppv);
 107         return S_OK;
 108     }
 109
 110     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 111     return E_NOINTERFACE;
 112 }
 113
 114 static ULONG WINAPI HTMLEventObj_AddRef(IHTMLEventObj *iface)
 115 {
 116     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 117     LONG ref = InterlockedIncrement(&This->ref);
 118
 119     TRACE("(%p) ref=%d\n", This, ref);
 120
 121     return ref;
 122 }
 123
 124 static ULONG WINAPI HTMLEventObj_Release(IHTMLEventObj *iface)
 125 {
 126     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 127     LONG ref = InterlockedDecrement(&This->ref);
 128
 129     TRACE("(%p) ref=%d\n", This, ref);
 130
 131     if(!ref)
 132         heap_free(This);
 133
 134     return ref;
 135 }
 136
 137 static HRESULT WINAPI HTMLEventObj_GetTypeInfoCount(IHTMLEventObj *iface, UINT *pctinfo)
 138 {
 139     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 140     FIXME("(%p)->(%p)\n", This, pctinfo);
 141     return E_NOTIMPL;
 142 }
 143
 144 static HRESULT WINAPI HTMLEventObj_GetTypeInfo(IHTMLEventObj *iface, UINT iTInfo,
 145                                               LCID lcid, ITypeInfo **ppTInfo)
 146 {
 147     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 148     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI HTMLEventObj_GetIDsOfNames(IHTMLEventObj *iface, REFIID riid,
 153                                                 LPOLESTR *rgszNames, UINT cNames,
 154                                                 LCID lcid, DISPID *rgDispId)
 155 {
 156     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 157     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 158           lcid, rgDispId);
 159     return E_NOTIMPL;
 160 }
 161
 162 static HRESULT WINAPI HTMLEventObj_Invoke(IHTMLEventObj *iface, DISPID dispIdMember,
 163                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 164                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 165 {
 166     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 167     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 168           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 169     return E_NOTIMPL;
 170 }
 171
 172 static HRESULT WINAPI HTMLEventObj_get_srcElement(IHTMLEventObj *iface, IHTMLElement **p)
 173 {
 174     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 175     FIXME("(%p)->(%p)\n", This, p);
 176     return E_NOTIMPL;
 177 }
 178
 179 static HRESULT WINAPI HTMLEventObj_get_altKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 180 {
 181     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 182     FIXME("(%p)->(%p)\n", This, p);
 183     return E_NOTIMPL;
 184 }
 185
 186 static HRESULT WINAPI HTMLEventObj_get_ctrlKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 187 {
 188     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 189     FIXME("(%p)->(%p)\n", This, p);
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI HTMLEventObj_get_shiftKey(IHTMLEventObj *iface, VARIANT_BOOL *p)
 194 {
 195     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 196     FIXME("(%p)->(%p)\n", This, p);
 197     return E_NOTIMPL;
 198 }
 199
 200 static HRESULT WINAPI HTMLEventObj_put_returnValue(IHTMLEventObj *iface, VARIANT v)
 201 {
 202     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 203     FIXME("(%p)->()\n", This);
 204     return E_NOTIMPL;
 205 }
 206
 207 static HRESULT WINAPI HTMLEventObj_get_returnValue(IHTMLEventObj *iface, VARIANT *p)
 208 {
 209     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 210     FIXME("(%p)->(%p)\n", This, p);
 211     return E_NOTIMPL;
 212 }
 213
 214 static HRESULT WINAPI HTMLEventObj_put_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL v)
 215 {
 216     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 217     FIXME("(%p)->(%x)\n", This, v);
 218     return E_NOTIMPL;
 219 }
 220
 221 static HRESULT WINAPI HTMLEventObj_get_cancelBubble(IHTMLEventObj *iface, VARIANT_BOOL *p)
 222 {
 223     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 224     FIXME("(%p)->(%p)\n", This, p);
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI HTMLEventObj_get_fromElement(IHTMLEventObj *iface, IHTMLElement **p)
 229 {
 230     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 231     FIXME("(%p)->(%p)\n", This, p);
 232     return E_NOTIMPL;
 233 }
 234
 235 static HRESULT WINAPI HTMLEventObj_get_toElement(IHTMLEventObj *iface, IHTMLElement **p)
 236 {
 237     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 238     FIXME("(%p)->(%p)\n", This, p);
 239     return E_NOTIMPL;
 240 }
 241
 242 static HRESULT WINAPI HTMLEventObj_put_keyCode(IHTMLEventObj *iface, long v)
 243 {
 244     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 245     FIXME("(%p)->(%ld)\n", This, v);
 246     return E_NOTIMPL;
 247 }
 248
 249 static HRESULT WINAPI HTMLEventObj_get_keyCode(IHTMLEventObj *iface, long *p)
 250 {
 251     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 252     FIXME("(%p)->(%p)\n", This, p);
 253     return E_NOTIMPL;
 254 }
 255
 256 static HRESULT WINAPI HTMLEventObj_get_button(IHTMLEventObj *iface, long *p)
 257 {
 258     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 259     FIXME("(%p)->(%p)\n", This, p);
 260     return E_NOTIMPL;
 261 }
 262
 263 static HRESULT WINAPI HTMLEventObj_get_type(IHTMLEventObj *iface, BSTR *p)
 264 {
 265     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 266     FIXME("(%p)->(%p)\n", This, p);
 267     return E_NOTIMPL;
 268 }
 269
 270 static HRESULT WINAPI HTMLEventObj_get_qualifier(IHTMLEventObj *iface, BSTR *p)
 271 {
 272     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 273     FIXME("(%p)->(%p)\n", This, p);
 274     return E_NOTIMPL;
 275 }
 276
 277 static HRESULT WINAPI HTMLEventObj_get_reason(IHTMLEventObj *iface, long *p)
 278 {
 279     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 280     FIXME("(%p)->(%p)\n", This, p);
 281     return E_NOTIMPL;
 282 }
 283
 284 static HRESULT WINAPI HTMLEventObj_get_x(IHTMLEventObj *iface, long *p)
 285 {
 286     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 287     FIXME("(%p)->(%p)\n", This, p);
 288     return E_NOTIMPL;
 289 }
 290
 291 static HRESULT WINAPI HTMLEventObj_get_y(IHTMLEventObj *iface, long *p)
 292 {
 293     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 294     FIXME("(%p)->(%p)\n", This, p);
 295     return E_NOTIMPL;
 296 }
 297
 298 static HRESULT WINAPI HTMLEventObj_get_clientX(IHTMLEventObj *iface, long *p)
 299 {
 300     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 301     FIXME("(%p)->(%p)\n", This, p);
 302     return E_NOTIMPL;
 303 }
 304
 305 static HRESULT WINAPI HTMLEventObj_get_clientY(IHTMLEventObj *iface, long *p)
 306 {
 307     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 308     FIXME("(%p)->(%p)\n", This, p);
 309     return E_NOTIMPL;
 310 }
 311
 312 static HRESULT WINAPI HTMLEventObj_get_offsetX(IHTMLEventObj *iface, long *p)
 313 {
 314     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 315     FIXME("(%p)->(%p)\n", This, p);
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI HTMLEventObj_get_offsetY(IHTMLEventObj *iface, long *p)
 320 {
 321     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 322     FIXME("(%p)->(%p)\n", This, p);
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT WINAPI HTMLEventObj_get_screenX(IHTMLEventObj *iface, long *p)
 327 {
 328     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 329     FIXME("(%p)->(%p)\n", This, p);
 330     return E_NOTIMPL;
 331 }
 332
 333 static HRESULT WINAPI HTMLEventObj_get_screenY(IHTMLEventObj *iface, long *p)
 334 {
 335     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 336     FIXME("(%p)->(%p)\n", This, p);
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI HTMLEventObj_get_srcFilter(IHTMLEventObj *iface, IDispatch **p)
 341 {
 342     HTMLEventObj *This = HTMLEVENTOBJ_THIS(iface);
 343     FIXME("(%p)->(%p)\n", This, p);
 344     return E_NOTIMPL;
 345 }
 346
 347 #undef HTMLEVENTOBJ_THIS
 348
 349 static const IHTMLEventObjVtbl HTMLEventObjVtbl = {
 350     HTMLEventObj_QueryInterface,
 351     HTMLEventObj_AddRef,
 352     HTMLEventObj_Release,
 353     HTMLEventObj_GetTypeInfoCount,
 354     HTMLEventObj_GetTypeInfo,
 355     HTMLEventObj_GetIDsOfNames,
 356     HTMLEventObj_Invoke,
 357     HTMLEventObj_get_srcElement,
 358     HTMLEventObj_get_altKey,
 359     HTMLEventObj_get_ctrlKey,
 360     HTMLEventObj_get_shiftKey,
 361     HTMLEventObj_put_returnValue,
 362     HTMLEventObj_get_returnValue,
 363     HTMLEventObj_put_cancelBubble,
 364     HTMLEventObj_get_cancelBubble,
 365     HTMLEventObj_get_fromElement,
 366     HTMLEventObj_get_toElement,
 367     HTMLEventObj_put_keyCode,
 368     HTMLEventObj_get_keyCode,
 369     HTMLEventObj_get_button,
 370     HTMLEventObj_get_type,
 371     HTMLEventObj_get_qualifier,
 372     HTMLEventObj_get_reason,
 373     HTMLEventObj_get_x,
 374     HTMLEventObj_get_y,
 375     HTMLEventObj_get_clientX,
 376     HTMLEventObj_get_clientY,
 377     HTMLEventObj_get_offsetX,
 378     HTMLEventObj_get_offsetY,
 379     HTMLEventObj_get_screenX,
 380     HTMLEventObj_get_screenY,
 381     HTMLEventObj_get_srcFilter
 382 };
 383
 384 static const tid_t HTMLEventObj_iface_tids[] = {
 385     IHTMLEventObj_tid,
 386     0
 387 };
 388
 389 static dispex_static_data_t HTMLEventObj_dispex = {
 390     NULL,
 391     DispCEventObj_tid,
 392     NULL,
 393     HTMLEventObj_iface_tids
 394 };
 395
 396 static IHTMLEventObj *create_event(void)
 397 {
 398     HTMLEventObj *ret;
 399
 400     ret = heap_alloc(sizeof(*ret));
 401     ret->lpIHTMLEventObjVtbl = &HTMLEventObjVtbl;
 402     ret->ref = 1;
 403
 404     init_dispex(&ret->dispex, (IUnknown*)HTMLEVENTOBJ(ret), &HTMLEventObj_dispex);
 405
 406     return HTMLEVENTOBJ(ret);
 407 }
 408
 409 void fire_event(HTMLDocument *doc, eventid_t eid, nsIDOMNode *target)
 410 {
 411     HTMLDOMNode *node;
 412
 413     node = get_node(doc, target, FALSE);
 414     if(!node)
 415         return;
 416
 417     if(node->event_target && node->event_target->event_table[eid]) {
 418         doc->window->event = create_event();
 419
 420         TRACE("%s >>>\n", debugstr_w(event_info[eid].name));
 421         call_disp_func(doc, node->event_target->event_table[eid]);
 422         TRACE("%s <<<\n", debugstr_w(event_info[eid].name));
 423
 424         IHTMLEventObj_Release(doc->window->event);
 425         doc->window->event = NULL;
 426     }
 427 }
 428
 429 static HRESULT set_node_event_disp(HTMLDOMNode *node, eventid_t eid, IDispatch *disp)
 430 {
 431     if(!node->event_target)
 432         node->event_target = heap_alloc_zero(sizeof(event_target_t));
 433     else if(node->event_target->event_table[eid])
 434         IDispatch_Release(node->event_target->event_table[eid]);
 435
 436     IDispatch_AddRef(disp);
 437     node->event_target->event_table[eid] = disp;
 438
 439     if(event_info[eid].flags & EVENT_DEFAULTLISTENER) {
 440         if(!node->doc->nscontainer->event_vector) {
 441             node->doc->nscontainer->event_vector = heap_alloc_zero(EVENTID_LAST*sizeof(BOOL));
 442             if(!node->doc->nscontainer->event_vector)
 443                 return E_OUTOFMEMORY;
 444         }
 445
 446         if(!node->doc->nscontainer->event_vector[eid]) {
 447             node->doc->nscontainer->event_vector[eid] = TRUE;
 448             add_nsevent_listener(node->doc->nscontainer, event_info[eid].name);
 449         }
 450     }
 451
 452     return S_OK;
 453 }
 454
 455 HRESULT set_node_event(HTMLDOMNode *node, eventid_t eid, VARIANT *var)
 456 {
 457     switch(V_VT(var)) {
 458     case VT_DISPATCH:
 459         return set_node_event_disp(node, eid, V_DISPATCH(var));
 460
 461     default:
 462         FIXME("not supported vt=%d\n", V_VT(var));
 463     }
 464
 465     return E_NOTIMPL;
 466 }
 467
 468 void check_event_attr(HTMLDocument *doc, nsIDOMElement *nselem)
 469 {
 470     const PRUnichar *attr_value;
 471     nsAString attr_name_str, attr_value_str;
 472     IDispatch *disp;
 473     HTMLDOMNode *node;
 474     int i;
 475     nsresult nsres;
 476
 477     nsAString_Init(&attr_value_str, NULL);
 478     nsAString_Init(&attr_name_str, NULL);
 479
 480     for(i=0; i < EVENTID_LAST; i++) {
 481         nsAString_SetData(&attr_name_str, event_info[i].attr_name);
 482         nsres = nsIDOMElement_GetAttribute(nselem, &attr_name_str, &attr_value_str);
 483         if(NS_SUCCEEDED(nsres)) {
 484             nsAString_GetData(&attr_value_str, &attr_value);
 485             if(!*attr_value)
 486                 continue;
 487
 488             TRACE("%p.%s = %s\n", nselem, debugstr_w(event_info[i].attr_name), debugstr_w(attr_value));
 489
 490             disp = script_parse_event(doc, attr_value);
 491             if(disp) {
 492                 node = get_node(doc, (nsIDOMNode*)nselem, TRUE);
 493                 set_node_event_disp(node, i, disp);
 494                 IDispatch_Release(disp);
 495             }
 496         }
 497     }
 498
 499     nsAString_Finish(&attr_value_str);
 500     nsAString_Finish(&attr_name_str);
 501 }
 502
 503 void release_event_target(event_target_t *event_target)
 504 {
 505     int i;
 506
 507     for(i=0; i < EVENTID_LAST; i++) {
 508         if(event_target->event_table[i])
 509             IDispatch_Release(event_target->event_table[i]);
 510     }
 511
 512     heap_free(event_target);
 513 }