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