dlls/mshtml/htmlnode.c

   1 /*
   2  * Copyright 2006 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 "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31 #include "htmlevent.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  34
  35 static HTMLDOMNode *get_node_obj(IHTMLDOMNode*);
  36 static HRESULT create_node(HTMLDocumentNode*,nsIDOMNode*,HTMLDOMNode**);
  37
  38 static ExternalCycleCollectionParticipant node_ccp;
  39
  40 typedef struct {
  41     DispatchEx dispex;
  42     IHTMLDOMChildrenCollection IHTMLDOMChildrenCollection_iface;
  43
  44     LONG ref;
  45
  46     nsIDOMNodeList *nslist;
  47 } HTMLDOMChildrenCollection;
  48
  49 typedef struct {
  50     IEnumVARIANT IEnumVARIANT_iface;
  51
  52     LONG ref;
  53
  54     ULONG iter;
  55     HTMLDOMChildrenCollection *col;
  56 } HTMLDOMChildrenCollectionEnum;
  57
  58 static inline HTMLDOMChildrenCollectionEnum *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
  59 {
  60     return CONTAINING_RECORD(iface, HTMLDOMChildrenCollectionEnum, IEnumVARIANT_iface);
  61 }
  62
  63 static HRESULT WINAPI HTMLDOMChildrenCollectionEnum_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **ppv)
  64 {
  65     HTMLDOMChildrenCollectionEnum *This = impl_from_IEnumVARIANT(iface);
  66
  67     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
  68
  69     if(IsEqualGUID(riid, &IID_IUnknown)) {
  70         *ppv = &This->IEnumVARIANT_iface;
  71     }else if(IsEqualGUID(riid, &IID_IEnumVARIANT)) {
  72         *ppv = &This->IEnumVARIANT_iface;
  73     }else {
  74         FIXME("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
  75         *ppv = NULL;
  76         return E_NOINTERFACE;
  77     }
  78
  79     IUnknown_AddRef((IUnknown*)*ppv);
  80     return S_OK;
  81 }
  82
  83 static ULONG WINAPI HTMLDOMChildrenCollectionEnum_AddRef(IEnumVARIANT *iface)
  84 {
  85     HTMLDOMChildrenCollectionEnum *This = impl_from_IEnumVARIANT(iface);
  86     LONG ref = InterlockedIncrement(&This->ref);
  87
  88     TRACE("(%p) ref=%ld\n", This, ref);
  89
  90     return ref;
  91 }
  92
  93 static ULONG WINAPI HTMLDOMChildrenCollectionEnum_Release(IEnumVARIANT *iface)
  94 {
  95     HTMLDOMChildrenCollectionEnum *This = impl_from_IEnumVARIANT(iface);
  96     LONG ref = InterlockedDecrement(&This->ref);
  97
  98     TRACE("(%p) ref=%ld\n", This, ref);
  99
 100     if(!ref) {
 101         IHTMLDOMChildrenCollection_Release(&This->col->IHTMLDOMChildrenCollection_iface);
 102         free(This);
 103     }
 104
 105     return ref;
 106 }
 107
 108 static ULONG get_enum_len(HTMLDOMChildrenCollectionEnum *This)
 109 {
 110     UINT32 len;
 111     nsresult nsres;
 112
 113     nsres = nsIDOMNodeList_GetLength(This->col->nslist, &len);
 114     assert(nsres == NS_OK);
 115     return len;
 116 }
 117
 118 static HRESULT WINAPI HTMLDOMChildrenCollectionEnum_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
 119 {
 120     HTMLDOMChildrenCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 121     ULONG fetched = 0, len;
 122     nsIDOMNode *nsnode;
 123     HTMLDOMNode *node;
 124     nsresult nsres;
 125     HRESULT hres;
 126
 127     TRACE("(%p)->(%ld %p %p)\n", This, celt, rgVar, pCeltFetched);
 128
 129     len = get_enum_len(This);
 130
 131     while(This->iter+fetched < len && fetched < celt) {
 132         nsres = nsIDOMNodeList_Item(This->col->nslist, This->iter+fetched, &nsnode);
 133         assert(nsres == NS_OK);
 134
 135         hres = get_node(nsnode, TRUE, &node);
 136         nsIDOMNode_Release(nsnode);
 137         if(FAILED(hres)) {
 138             while(fetched--)
 139                 VariantClear(rgVar+fetched);
 140             return hres;
 141         }
 142
 143         V_VT(rgVar+fetched) = VT_DISPATCH;
 144         V_DISPATCH(rgVar+fetched) = (IDispatch*)&node->IHTMLDOMNode_iface;
 145         fetched++;
 146     }
 147
 148     This->iter += fetched;
 149     if(pCeltFetched)
 150         *pCeltFetched = fetched;
 151     return fetched == celt ? S_OK : S_FALSE;
 152 }
 153
 154 static HRESULT WINAPI HTMLDOMChildrenCollectionEnum_Skip(IEnumVARIANT *iface, ULONG celt)
 155 {
 156     HTMLDOMChildrenCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 157     ULONG len;
 158
 159     TRACE("(%p)->(%ld)\n", This, celt);
 160
 161     len = get_enum_len(This);
 162     if(This->iter + celt > len) {
 163         This->iter = len;
 164         return S_FALSE;
 165     }
 166
 167     This->iter += celt;
 168     return S_OK;
 169 }
 170
 171 static HRESULT WINAPI HTMLDOMChildrenCollectionEnum_Reset(IEnumVARIANT *iface)
 172 {
 173     HTMLDOMChildrenCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 174
 175     TRACE("(%p)->()\n", This);
 176
 177     This->iter = 0;
 178     return S_OK;
 179 }
 180
 181 static HRESULT WINAPI HTMLDOMChildrenCollectionEnum_Clone(IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
 182 {
 183     HTMLDOMChildrenCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 184     FIXME("(%p)->(%p)\n", This, ppEnum);
 185     return E_NOTIMPL;
 186 }
 187
 188 static const IEnumVARIANTVtbl HTMLDOMChildrenCollectionEnumVtbl = {
 189     HTMLDOMChildrenCollectionEnum_QueryInterface,
 190     HTMLDOMChildrenCollectionEnum_AddRef,
 191     HTMLDOMChildrenCollectionEnum_Release,
 192     HTMLDOMChildrenCollectionEnum_Next,
 193     HTMLDOMChildrenCollectionEnum_Skip,
 194     HTMLDOMChildrenCollectionEnum_Reset,
 195     HTMLDOMChildrenCollectionEnum_Clone
 196 };
 197
 198 static inline HTMLDOMChildrenCollection *impl_from_IHTMLDOMChildrenCollection(IHTMLDOMChildrenCollection *iface)
 199 {
 200     return CONTAINING_RECORD(iface, HTMLDOMChildrenCollection, IHTMLDOMChildrenCollection_iface);
 201 }
 202
 203 static HRESULT WINAPI HTMLDOMChildrenCollection_QueryInterface(IHTMLDOMChildrenCollection *iface, REFIID riid, void **ppv)
 204 {
 205     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 206
 207     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 208
 209     if(IsEqualGUID(&IID_IUnknown, riid)) {
 210         *ppv = &This->IHTMLDOMChildrenCollection_iface;
 211     }else if(IsEqualGUID(&IID_IHTMLDOMChildrenCollection, riid)) {
 212         *ppv = &This->IHTMLDOMChildrenCollection_iface;
 213     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 214         return *ppv ? S_OK : E_NOINTERFACE;
 215     }else {
 216         *ppv = NULL;
 217         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 218         return E_NOINTERFACE;
 219     }
 220
 221     IUnknown_AddRef((IUnknown*)*ppv);
 222     return S_OK;
 223 }
 224
 225 static ULONG WINAPI HTMLDOMChildrenCollection_AddRef(IHTMLDOMChildrenCollection *iface)
 226 {
 227     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 228     LONG ref = InterlockedIncrement(&This->ref);
 229
 230     TRACE("(%p) ref=%ld\n", This, ref);
 231
 232     return ref;
 233 }
 234
 235 static ULONG WINAPI HTMLDOMChildrenCollection_Release(IHTMLDOMChildrenCollection *iface)
 236 {
 237     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 238     LONG ref = InterlockedDecrement(&This->ref);
 239
 240     TRACE("(%p) ref=%ld\n", This, ref);
 241
 242     if(!ref)
 243         release_dispex(&This->dispex);
 244
 245     return ref;
 246 }
 247
 248 static HRESULT WINAPI HTMLDOMChildrenCollection_GetTypeInfoCount(IHTMLDOMChildrenCollection *iface, UINT *pctinfo)
 249 {
 250     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 251     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 252 }
 253
 254 static HRESULT WINAPI HTMLDOMChildrenCollection_GetTypeInfo(IHTMLDOMChildrenCollection *iface, UINT iTInfo,
 255         LCID lcid, ITypeInfo **ppTInfo)
 256 {
 257     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 258     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 259 }
 260
 261 static HRESULT WINAPI HTMLDOMChildrenCollection_GetIDsOfNames(IHTMLDOMChildrenCollection *iface, REFIID riid,
 262         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 263 {
 264     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 265     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 266             lcid, rgDispId);
 267 }
 268
 269 static HRESULT WINAPI HTMLDOMChildrenCollection_Invoke(IHTMLDOMChildrenCollection *iface, DISPID dispIdMember,
 270         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 271         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 272 {
 273     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 274     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 275             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 276 }
 277
 278 static HRESULT WINAPI HTMLDOMChildrenCollection_get_length(IHTMLDOMChildrenCollection *iface, LONG *p)
 279 {
 280     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 281     UINT32 length=0;
 282
 283     TRACE("(%p)->(%p)\n", This, p);
 284
 285     nsIDOMNodeList_GetLength(This->nslist, &length);
 286     *p = length;
 287     return S_OK;
 288 }
 289
 290 static HRESULT WINAPI HTMLDOMChildrenCollection_get__newEnum(IHTMLDOMChildrenCollection *iface, IUnknown **p)
 291 {
 292     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 293     HTMLDOMChildrenCollectionEnum *ret;
 294
 295     TRACE("(%p)->(%p)\n", This, p);
 296
 297     ret = malloc(sizeof(*ret));
 298     if(!ret)
 299         return E_OUTOFMEMORY;
 300
 301     ret->IEnumVARIANT_iface.lpVtbl = &HTMLDOMChildrenCollectionEnumVtbl;
 302     ret->ref = 1;
 303     ret->iter = 0;
 304
 305     IHTMLDOMChildrenCollection_AddRef(&This->IHTMLDOMChildrenCollection_iface);
 306     ret->col = This;
 307
 308     *p = (IUnknown*)&ret->IEnumVARIANT_iface;
 309     return S_OK;
 310 }
 311
 312 static HRESULT WINAPI HTMLDOMChildrenCollection_item(IHTMLDOMChildrenCollection *iface, LONG index, IDispatch **ppItem)
 313 {
 314     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 315     nsIDOMNode *nsnode = NULL;
 316     HTMLDOMNode *node;
 317     UINT32 length=0;
 318     nsresult nsres;
 319     HRESULT hres;
 320
 321     TRACE("(%p)->(%ld %p)\n", This, index, ppItem);
 322
 323     if (ppItem)
 324         *ppItem = NULL;
 325     else
 326         return E_POINTER;
 327
 328     nsIDOMNodeList_GetLength(This->nslist, &length);
 329     if(index < 0 || index >= length)
 330         return E_INVALIDARG;
 331
 332     nsres = nsIDOMNodeList_Item(This->nslist, index, &nsnode);
 333     if(NS_FAILED(nsres) || !nsnode) {
 334         ERR("Item failed: %08lx\n", nsres);
 335         return E_FAIL;
 336     }
 337
 338     hres = get_node(nsnode, TRUE, &node);
 339     nsIDOMNode_Release(nsnode);
 340     if(FAILED(hres))
 341         return hres;
 342
 343     *ppItem = (IDispatch*)&node->IHTMLDOMNode_iface;
 344     return S_OK;
 345 }
 346
 347 static const IHTMLDOMChildrenCollectionVtbl HTMLDOMChildrenCollectionVtbl = {
 348     HTMLDOMChildrenCollection_QueryInterface,
 349     HTMLDOMChildrenCollection_AddRef,
 350     HTMLDOMChildrenCollection_Release,
 351     HTMLDOMChildrenCollection_GetTypeInfoCount,
 352     HTMLDOMChildrenCollection_GetTypeInfo,
 353     HTMLDOMChildrenCollection_GetIDsOfNames,
 354     HTMLDOMChildrenCollection_Invoke,
 355     HTMLDOMChildrenCollection_get_length,
 356     HTMLDOMChildrenCollection_get__newEnum,
 357     HTMLDOMChildrenCollection_item
 358 };
 359
 360 static inline HTMLDOMChildrenCollection *impl_from_DispatchEx(DispatchEx *iface)
 361 {
 362     return CONTAINING_RECORD(iface, HTMLDOMChildrenCollection, dispex);
 363 }
 364
 365 static void HTMLDOMChildrenCollection_unlink(DispatchEx *dispex)
 366 {
 367     HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex);
 368     unlink_ref(&This->nslist);
 369 }
 370
 371 static void HTMLDOMChildrenCollection_destructor(DispatchEx *dispex)
 372 {
 373     HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex);
 374     free(This);
 375 }
 376
 377 #define DISPID_CHILDCOL_0 MSHTML_DISPID_CUSTOM_MIN
 378
 379 static HRESULT HTMLDOMChildrenCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
 380 {
 381     HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex);
 382     WCHAR *ptr;
 383     DWORD idx=0;
 384     UINT32 len = 0;
 385
 386     for(ptr = name; *ptr && is_digit(*ptr); ptr++)
 387         idx = idx*10 + (*ptr-'0');
 388     if(*ptr)
 389         return DISP_E_UNKNOWNNAME;
 390
 391     nsIDOMNodeList_GetLength(This->nslist, &len);
 392     if(idx >= len)
 393         return DISP_E_UNKNOWNNAME;
 394
 395     *dispid = DISPID_CHILDCOL_0 + idx;
 396     TRACE("ret %lx\n", *dispid);
 397     return S_OK;
 398 }
 399
 400 static HRESULT HTMLDOMChildrenCollection_get_name(DispatchEx *dispex, DISPID id, BSTR *name)
 401 {
 402     HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex);
 403     DWORD idx = id - DISPID_CHILDCOL_0;
 404     UINT32 len = 0;
 405     WCHAR buf[11];
 406
 407     nsIDOMNodeList_GetLength(This->nslist, &len);
 408     if(idx >= len)
 409         return DISP_E_MEMBERNOTFOUND;
 410
 411     len = swprintf(buf, ARRAY_SIZE(buf), L"%u", idx);
 412     return (*name = SysAllocStringLen(buf, len)) ? S_OK : E_OUTOFMEMORY;
 413 }
 414
 415 static HRESULT HTMLDOMChildrenCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 416         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 417 {
 418     HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex);
 419
 420     TRACE("(%p)->(%lx %lx %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
 421
 422     switch(flags) {
 423     case DISPATCH_PROPERTYGET: {
 424         IDispatch *disp = NULL;
 425         HRESULT hres;
 426
 427         hres = IHTMLDOMChildrenCollection_item(&This->IHTMLDOMChildrenCollection_iface,
 428                 id - DISPID_CHILDCOL_0, &disp);
 429         if(FAILED(hres))
 430             return hres;
 431
 432         V_VT(res) = VT_DISPATCH;
 433         V_DISPATCH(res) = disp;
 434         break;
 435     }
 436
 437     default:
 438         FIXME("unimplemented flags %x\n", flags);
 439         return E_NOTIMPL;
 440     }
 441
 442     return S_OK;
 443 }
 444
 445 static const dispex_static_data_vtbl_t HTMLDOMChildrenCollection_dispex_vtbl = {
 446     .destructor       = HTMLDOMChildrenCollection_destructor,
 447     .unlink           = HTMLDOMChildrenCollection_unlink,
 448     .get_dispid       = HTMLDOMChildrenCollection_get_dispid,
 449     .get_name         = HTMLDOMChildrenCollection_get_name,
 450     .invoke           = HTMLDOMChildrenCollection_invoke,
 451 };
 452
 453 static const tid_t HTMLDOMChildrenCollection_iface_tids[] = {
 454     IHTMLDOMChildrenCollection_tid,
 455     0
 456 };
 457
 458 static dispex_static_data_t HTMLDOMChildrenCollection_dispex = {
 459     "NodeList",
 460     &HTMLDOMChildrenCollection_dispex_vtbl,
 461     DispDOMChildrenCollection_tid,
 462     HTMLDOMChildrenCollection_iface_tids,
 463     HTMLDOMNode_init_dispex_info
 464 };
 465
 466 HRESULT create_child_collection(nsIDOMNodeList *nslist, compat_mode_t compat_mode, IHTMLDOMChildrenCollection **ret)
 467 {
 468     HTMLDOMChildrenCollection *collection;
 469
 470     if(!(collection = calloc(1, sizeof(*collection))))
 471         return E_OUTOFMEMORY;
 472
 473     collection->IHTMLDOMChildrenCollection_iface.lpVtbl = &HTMLDOMChildrenCollectionVtbl;
 474     collection->ref = 1;
 475
 476     nsIDOMNodeList_AddRef(nslist);
 477     collection->nslist = nslist;
 478
 479     init_dispatch(&collection->dispex, (IUnknown*)&collection->IHTMLDOMChildrenCollection_iface,
 480                   &HTMLDOMChildrenCollection_dispex, compat_mode);
 481
 482     *ret = &collection->IHTMLDOMChildrenCollection_iface;
 483     return S_OK;
 484 }
 485
 486 static inline HTMLDOMNode *impl_from_IHTMLDOMNode(IHTMLDOMNode *iface)
 487 {
 488     return CONTAINING_RECORD(iface, HTMLDOMNode, IHTMLDOMNode_iface);
 489 }
 490
 491 static HRESULT WINAPI HTMLDOMNode_QueryInterface(IHTMLDOMNode *iface,
 492                                                  REFIID riid, void **ppv)
 493 {
 494     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 495
 496     return This->vtbl->qi(This, riid, ppv);
 497 }
 498
 499 static ULONG WINAPI HTMLDOMNode_AddRef(IHTMLDOMNode *iface)
 500 {
 501     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 502     LONG ref;
 503
 504     ref = ccref_incr(&This->ccref, (nsISupports*)&This->IHTMLDOMNode_iface);
 505
 506     TRACE("(%p) ref=%ld\n", This, ref);
 507
 508     return ref;
 509 }
 510
 511 static ULONG WINAPI HTMLDOMNode_Release(IHTMLDOMNode *iface)
 512 {
 513     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 514     LONG ref = ccref_decr(&This->ccref, (nsISupports*)&This->IHTMLDOMNode_iface, &node_ccp);
 515
 516     TRACE("(%p) ref=%ld\n", This, ref);
 517
 518     return ref;
 519 }
 520
 521 static HRESULT WINAPI HTMLDOMNode_GetTypeInfoCount(IHTMLDOMNode *iface, UINT *pctinfo)
 522 {
 523     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 524     return IDispatchEx_GetTypeInfoCount(&This->event_target.dispex.IDispatchEx_iface, pctinfo);
 525 }
 526
 527 static HRESULT WINAPI HTMLDOMNode_GetTypeInfo(IHTMLDOMNode *iface, UINT iTInfo,
 528                                               LCID lcid, ITypeInfo **ppTInfo)
 529 {
 530     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 531     return IDispatchEx_GetTypeInfo(&This->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 532 }
 533
 534 static HRESULT WINAPI HTMLDOMNode_GetIDsOfNames(IHTMLDOMNode *iface, REFIID riid,
 535                                                 LPOLESTR *rgszNames, UINT cNames,
 536                                                 LCID lcid, DISPID *rgDispId)
 537 {
 538     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 539     return IDispatchEx_GetIDsOfNames(&This->event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 540             lcid, rgDispId);
 541 }
 542
 543 static HRESULT WINAPI HTMLDOMNode_Invoke(IHTMLDOMNode *iface, DISPID dispIdMember,
 544                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 545                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 546 {
 547     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 548     return IDispatchEx_Invoke(&This->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 549             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 550 }
 551
 552 static HRESULT WINAPI HTMLDOMNode_get_nodeType(IHTMLDOMNode *iface, LONG *p)
 553 {
 554     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 555     UINT16 type = -1;
 556
 557     TRACE("(%p)->(%p)\n", This, p);
 558
 559     nsIDOMNode_GetNodeType(This->nsnode, &type);
 560
 561     switch(type) {
 562     case ELEMENT_NODE:
 563         *p = 1;
 564         break;
 565     case TEXT_NODE:
 566         *p = 3;
 567         break;
 568     case COMMENT_NODE:
 569     case DOCUMENT_TYPE_NODE:
 570         *p = 8;
 571         break;
 572     case DOCUMENT_NODE:
 573         *p = 9;
 574         break;
 575     case DOCUMENT_FRAGMENT_NODE:
 576         *p = 11;
 577         break;
 578     default:
 579         /*
 580          * FIXME:
 581          * According to MSDN only ELEMENT_NODE and TEXT_NODE are supported.
 582          * It needs more tests.
 583          */
 584         FIXME("type %u\n", type);
 585         *p = 0;
 586     }
 587
 588     return S_OK;
 589 }
 590
 591 static HRESULT WINAPI HTMLDOMNode_get_parentNode(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 592 {
 593     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 594     HTMLDOMNode *node;
 595     nsIDOMNode *nsnode;
 596     nsresult nsres;
 597     HRESULT hres;
 598
 599     TRACE("(%p)->(%p)\n", This, p);
 600
 601     nsres = nsIDOMNode_GetParentNode(This->nsnode, &nsnode);
 602     if(NS_FAILED(nsres)) {
 603         ERR("GetParentNode failed: %08lx\n", nsres);
 604         return E_FAIL;
 605     }
 606
 607     if(!nsnode) {
 608         *p = NULL;
 609         return S_OK;
 610     }
 611
 612     hres = get_node(nsnode, TRUE, &node);
 613     nsIDOMNode_Release(nsnode);
 614     if(FAILED(hres))
 615         return hres;
 616
 617     *p = &node->IHTMLDOMNode_iface;
 618     return S_OK;
 619 }
 620
 621 static HRESULT WINAPI HTMLDOMNode_hasChildNodes(IHTMLDOMNode *iface, VARIANT_BOOL *fChildren)
 622 {
 623     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 624     cpp_bool has_child = FALSE;
 625     nsresult nsres;
 626
 627     TRACE("(%p)->(%p)\n", This, fChildren);
 628
 629     nsres = nsIDOMNode_HasChildNodes(This->nsnode, &has_child);
 630     if(NS_FAILED(nsres))
 631         ERR("HasChildNodes failed: %08lx\n", nsres);
 632
 633     *fChildren = variant_bool(has_child);
 634     return S_OK;
 635 }
 636
 637 static HRESULT WINAPI HTMLDOMNode_get_childNodes(IHTMLDOMNode *iface, IDispatch **p)
 638 {
 639     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 640     nsIDOMNodeList *nslist;
 641     HRESULT hres;
 642
 643     TRACE("(%p)->(%p)\n", This, p);
 644
 645     hres = map_nsresult(nsIDOMNode_GetChildNodes(This->nsnode, &nslist));
 646     if(FAILED(hres)) {
 647         ERR("GetChildNodes failed: %08lx\n", hres);
 648         return hres;
 649     }
 650
 651     hres = create_child_collection(nslist, dispex_compat_mode(&This->event_target.dispex),
 652                                    (IHTMLDOMChildrenCollection**)p);
 653     nsIDOMNodeList_Release(nslist);
 654     return hres;
 655 }
 656
 657 static HRESULT WINAPI HTMLDOMNode_get_attributes(IHTMLDOMNode *iface, IDispatch **p)
 658 {
 659     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 660     HTMLAttributeCollection *col;
 661     HRESULT hres;
 662
 663     TRACE("(%p)->(%p)\n", This, p);
 664
 665     if(This->vtbl->get_attr_col) {
 666         hres = This->vtbl->get_attr_col(This, &col);
 667         if(FAILED(hres))
 668             return hres;
 669
 670         *p = (IDispatch*)&col->IHTMLAttributeCollection_iface;
 671         return S_OK;
 672     }
 673
 674     *p = NULL;
 675     return S_OK;
 676 }
 677
 678 static HRESULT WINAPI HTMLDOMNode_insertBefore(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 679                                                VARIANT refChild, IHTMLDOMNode **node)
 680 {
 681     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 682     HTMLDOMNode *new_child, *node_obj, *ref_node = NULL;
 683     nsIDOMNode *nsnode;
 684     nsresult nsres;
 685     HRESULT hres = S_OK;
 686
 687     TRACE("(%p)->(%p %s %p)\n", This, newChild, debugstr_variant(&refChild), node);
 688
 689     new_child = get_node_obj(newChild);
 690     if(!new_child) {
 691         ERR("invalid newChild\n");
 692         return E_INVALIDARG;
 693     }
 694
 695     switch(V_VT(&refChild)) {
 696     case VT_NULL:
 697         break;
 698     case VT_DISPATCH: {
 699         IHTMLDOMNode *ref_iface;
 700
 701         if(!V_DISPATCH(&refChild))
 702             break;
 703
 704         hres = IDispatch_QueryInterface(V_DISPATCH(&refChild), &IID_IHTMLDOMNode, (void**)&ref_iface);
 705         if(FAILED(hres))
 706             break;
 707
 708         ref_node = get_node_obj(ref_iface);
 709         IHTMLDOMNode_Release(ref_iface);
 710         if(!ref_node) {
 711             ERR("unvalid node\n");
 712             hres = E_FAIL;
 713             break;
 714         }
 715         break;
 716     }
 717     default:
 718         FIXME("unimplemented refChild %s\n", debugstr_variant(&refChild));
 719         hres = E_NOTIMPL;
 720     }
 721
 722     if(SUCCEEDED(hres)) {
 723         nsres = nsIDOMNode_InsertBefore(This->nsnode, new_child->nsnode, ref_node ? ref_node->nsnode : NULL, &nsnode);
 724         if(NS_FAILED(nsres)) {
 725             ERR("InsertBefore failed: %08lx\n", nsres);
 726             hres = E_FAIL;
 727         }
 728     }
 729     node_release(new_child);
 730     if(ref_node)
 731         node_release(ref_node);
 732     if(FAILED(hres))
 733         return hres;
 734
 735     hres = get_node(nsnode, TRUE, &node_obj);
 736     nsIDOMNode_Release(nsnode);
 737     if(FAILED(hres))
 738         return hres;
 739
 740     *node = &node_obj->IHTMLDOMNode_iface;
 741     return S_OK;
 742 }
 743
 744 static HRESULT WINAPI HTMLDOMNode_removeChild(IHTMLDOMNode *iface, IHTMLDOMNode *oldChild,
 745                                               IHTMLDOMNode **node)
 746 {
 747     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 748     HTMLDOMNode *node_obj;
 749     nsIDOMNode *nsnode;
 750     nsresult nsres;
 751     HRESULT hres;
 752
 753     TRACE("(%p)->(%p %p)\n", This, oldChild, node);
 754
 755     node_obj = get_node_obj(oldChild);
 756     if(!node_obj)
 757         return E_FAIL;
 758
 759     nsres = nsIDOMNode_RemoveChild(This->nsnode, node_obj->nsnode, &nsnode);
 760     node_release(node_obj);
 761     if(NS_FAILED(nsres)) {
 762         ERR("RemoveChild failed: %08lx\n", nsres);
 763         return E_FAIL;
 764     }
 765
 766     hres = get_node(nsnode, TRUE, &node_obj);
 767     nsIDOMNode_Release(nsnode);
 768     if(FAILED(hres))
 769         return hres;
 770
 771     /* FIXME: Make sure that node != newChild */
 772     *node = &node_obj->IHTMLDOMNode_iface;
 773     return S_OK;
 774 }
 775
 776 static HRESULT WINAPI HTMLDOMNode_replaceChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 777                                                IHTMLDOMNode *oldChild, IHTMLDOMNode **node)
 778 {
 779     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 780     HTMLDOMNode *node_new, *node_old, *ret_node;
 781     nsIDOMNode *nsnode;
 782     nsresult nsres;
 783     HRESULT hres;
 784
 785     TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, node);
 786
 787     node_new = get_node_obj(newChild);
 788     if(!node_new)
 789         return E_FAIL;
 790
 791     node_old = get_node_obj(oldChild);
 792     if(!node_old) {
 793         node_release(node_new);
 794         return E_FAIL;
 795     }
 796
 797     nsres = nsIDOMNode_ReplaceChild(This->nsnode, node_new->nsnode, node_old->nsnode, &nsnode);
 798     node_release(node_new);
 799     node_release(node_old);
 800     if(NS_FAILED(nsres))
 801         return E_FAIL;
 802
 803     hres = get_node(nsnode, TRUE, &ret_node);
 804     nsIDOMNode_Release(nsnode);
 805     if(FAILED(hres))
 806         return hres;
 807
 808     *node = &ret_node->IHTMLDOMNode_iface;
 809     return S_OK;
 810 }
 811
 812 static HRESULT WINAPI HTMLDOMNode_cloneNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
 813                                             IHTMLDOMNode **clonedNode)
 814 {
 815     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 816     HTMLDOMNode *new_node;
 817     nsIDOMNode *nsnode;
 818     nsresult nsres;
 819     HRESULT hres;
 820
 821     TRACE("(%p)->(%x %p)\n", This, fDeep, clonedNode);
 822
 823     nsres = nsIDOMNode_CloneNode(This->nsnode, fDeep != VARIANT_FALSE, 1, &nsnode);
 824     if(NS_FAILED(nsres) || !nsnode) {
 825         ERR("CloneNode failed: %08lx\n", nsres);
 826         return E_FAIL;
 827     }
 828
 829     hres = This->vtbl->clone(This, nsnode, &new_node);
 830     nsIDOMNode_Release(nsnode);
 831     if(FAILED(hres))
 832         return hres;
 833
 834     *clonedNode = &new_node->IHTMLDOMNode_iface;
 835     return S_OK;
 836 }
 837
 838 static HRESULT WINAPI HTMLDOMNode_removeNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
 839                                              IHTMLDOMNode **removed)
 840 {
 841     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 842     FIXME("(%p)->(%x %p)\n", This, fDeep, removed);
 843     return E_NOTIMPL;
 844 }
 845
 846 static HRESULT WINAPI HTMLDOMNode_swapNode(IHTMLDOMNode *iface, IHTMLDOMNode *otherNode,
 847                                            IHTMLDOMNode **swappedNode)
 848 {
 849     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 850     FIXME("(%p)->(%p %p)\n", This, otherNode, swappedNode);
 851     return E_NOTIMPL;
 852 }
 853
 854 static HRESULT WINAPI HTMLDOMNode_replaceNode(IHTMLDOMNode *iface, IHTMLDOMNode *replacement,
 855                                               IHTMLDOMNode **replaced)
 856 {
 857     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 858     FIXME("(%p)->(%p %p)\n", This, replacement, replaced);
 859     return E_NOTIMPL;
 860 }
 861
 862 static HRESULT WINAPI HTMLDOMNode_appendChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 863                                               IHTMLDOMNode **node)
 864 {
 865     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 866     HTMLDOMNode *node_obj;
 867     nsIDOMNode *nsnode;
 868     nsresult nsres;
 869     HRESULT hres;
 870
 871     TRACE("(%p)->(%p %p)\n", This, newChild, node);
 872
 873     node_obj = get_node_obj(newChild);
 874     if(!node_obj)
 875         return E_FAIL;
 876
 877     nsres = nsIDOMNode_AppendChild(This->nsnode, node_obj->nsnode, &nsnode);
 878     node_release(node_obj);
 879     if(NS_FAILED(nsres)) {
 880         ERR("AppendChild failed: %08lx\n", nsres);
 881         return E_FAIL;
 882     }
 883
 884     hres = get_node(nsnode, TRUE, &node_obj);
 885     nsIDOMNode_Release(nsnode);
 886     if(FAILED(hres))
 887         return hres;
 888
 889     /* FIXME: Make sure that node != newChild */
 890     *node = &node_obj->IHTMLDOMNode_iface;
 891     return S_OK;
 892 }
 893
 894 static HRESULT WINAPI HTMLDOMNode_get_nodeName(IHTMLDOMNode *iface, BSTR *p)
 895 {
 896     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 897     nsAString name;
 898     nsresult nsres;
 899
 900     TRACE("(%p)->(%p)\n", This, p);
 901
 902     nsAString_Init(&name, NULL);
 903     nsres = nsIDOMNode_GetNodeName(This->nsnode, &name);
 904     return return_nsstr(nsres, &name, p);
 905 }
 906
 907 static HRESULT WINAPI HTMLDOMNode_put_nodeValue(IHTMLDOMNode *iface, VARIANT v)
 908 {
 909     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 910
 911     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 912
 913     switch(V_VT(&v)) {
 914     case VT_BSTR: {
 915         nsAString val_str;
 916
 917         nsAString_InitDepend(&val_str, V_BSTR(&v));
 918         nsIDOMNode_SetNodeValue(This->nsnode, &val_str);
 919         nsAString_Finish(&val_str);
 920
 921         return S_OK;
 922     }
 923
 924     default:
 925         FIXME("unsupported value %s\n", debugstr_variant(&v));
 926     }
 927
 928     return E_NOTIMPL;
 929 }
 930
 931 static HRESULT WINAPI HTMLDOMNode_get_nodeValue(IHTMLDOMNode *iface, VARIANT *p)
 932 {
 933     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 934     const PRUnichar *val;
 935     nsAString val_str;
 936
 937     TRACE("(%p)->(%p)\n", This, p);
 938
 939     nsAString_Init(&val_str, NULL);
 940     nsIDOMNode_GetNodeValue(This->nsnode, &val_str);
 941     nsAString_GetData(&val_str, &val);
 942
 943     if(*val) {
 944         V_VT(p) = VT_BSTR;
 945         V_BSTR(p) = SysAllocString(val);
 946     }else {
 947         V_VT(p) = VT_NULL;
 948     }
 949
 950     nsAString_Finish(&val_str);
 951
 952     return S_OK;
 953 }
 954
 955 static HRESULT WINAPI HTMLDOMNode_get_firstChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 956 {
 957     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 958     nsIDOMNode *nschild = NULL;
 959     HTMLDOMNode *node;
 960     HRESULT hres;
 961
 962     TRACE("(%p)->(%p)\n", This, p);
 963
 964     nsIDOMNode_GetFirstChild(This->nsnode, &nschild);
 965     if(!nschild) {
 966         *p = NULL;
 967         return S_OK;
 968     }
 969
 970     hres = get_node(nschild, TRUE, &node);
 971     nsIDOMNode_Release(nschild);
 972     if(FAILED(hres))
 973         return hres;
 974
 975     *p = &node->IHTMLDOMNode_iface;
 976     return S_OK;
 977 }
 978
 979 static HRESULT WINAPI HTMLDOMNode_get_lastChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 980 {
 981     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 982     nsIDOMNode *nschild = NULL;
 983     HTMLDOMNode *node;
 984     HRESULT hres;
 985
 986     TRACE("(%p)->(%p)\n", This, p);
 987
 988     nsIDOMNode_GetLastChild(This->nsnode, &nschild);
 989     if(!nschild) {
 990         *p = NULL;
 991         return S_OK;
 992     }
 993
 994     hres = get_node(nschild, TRUE, &node);
 995     nsIDOMNode_Release(nschild);
 996     if(FAILED(hres))
 997         return hres;
 998
 999     *p = &node->IHTMLDOMNode_iface;
1000     return S_OK;
1001 }
1002
1003 static HRESULT WINAPI HTMLDOMNode_get_previousSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
1004 {
1005     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
1006     nsIDOMNode *nschild = NULL;
1007     HTMLDOMNode *node;
1008     HRESULT hres;
1009
1010     TRACE("(%p)->(%p)\n", This, p);
1011
1012     nsIDOMNode_GetPreviousSibling(This->nsnode, &nschild);
1013     if(!nschild) {
1014         *p = NULL;
1015         return S_OK;
1016     }
1017
1018     hres = get_node(nschild, TRUE, &node);
1019     nsIDOMNode_Release(nschild);
1020     if(FAILED(hres))
1021         return hres;
1022
1023     *p = &node->IHTMLDOMNode_iface;
1024     return S_OK;
1025 }
1026
1027 static HRESULT WINAPI HTMLDOMNode_get_nextSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
1028 {
1029     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
1030     nsIDOMNode *nssibling = NULL;
1031     HTMLDOMNode *node;
1032     HRESULT hres;
1033
1034     TRACE("(%p)->(%p)\n", This, p);
1035
1036     nsIDOMNode_GetNextSibling(This->nsnode, &nssibling);
1037     if(!nssibling) {
1038         *p = NULL;
1039         return S_OK;
1040     }
1041
1042     hres = get_node(nssibling, TRUE, &node);
1043     nsIDOMNode_Release(nssibling);
1044     if(FAILED(hres))
1045         return hres;
1046
1047     *p = &node->IHTMLDOMNode_iface;
1048     return S_OK;
1049 }
1050
1051 static const IHTMLDOMNodeVtbl HTMLDOMNodeVtbl = {
1052     HTMLDOMNode_QueryInterface,
1053     HTMLDOMNode_AddRef,
1054     HTMLDOMNode_Release,
1055     HTMLDOMNode_GetTypeInfoCount,
1056     HTMLDOMNode_GetTypeInfo,
1057     HTMLDOMNode_GetIDsOfNames,
1058     HTMLDOMNode_Invoke,
1059     HTMLDOMNode_get_nodeType,
1060     HTMLDOMNode_get_parentNode,
1061     HTMLDOMNode_hasChildNodes,
1062     HTMLDOMNode_get_childNodes,
1063     HTMLDOMNode_get_attributes,
1064     HTMLDOMNode_insertBefore,
1065     HTMLDOMNode_removeChild,
1066     HTMLDOMNode_replaceChild,
1067     HTMLDOMNode_cloneNode,
1068     HTMLDOMNode_removeNode,
1069     HTMLDOMNode_swapNode,
1070     HTMLDOMNode_replaceNode,
1071     HTMLDOMNode_appendChild,
1072     HTMLDOMNode_get_nodeName,
1073     HTMLDOMNode_put_nodeValue,
1074     HTMLDOMNode_get_nodeValue,
1075     HTMLDOMNode_get_firstChild,
1076     HTMLDOMNode_get_lastChild,
1077     HTMLDOMNode_get_previousSibling,
1078     HTMLDOMNode_get_nextSibling
1079 };
1080
1081 HTMLDOMNode *unsafe_impl_from_IHTMLDOMNode(IHTMLDOMNode *iface)
1082 {
1083     return iface->lpVtbl == &HTMLDOMNodeVtbl ? impl_from_IHTMLDOMNode(iface) : NULL;
1084 }
1085
1086 static HTMLDOMNode *get_node_obj(IHTMLDOMNode *iface)
1087 {
1088     HTMLDOMNode *ret;
1089
1090     if(iface->lpVtbl != &HTMLDOMNodeVtbl)
1091         return NULL;
1092
1093     ret = impl_from_IHTMLDOMNode(iface);
1094     node_addref(ret);
1095     return ret;
1096 }
1097
1098 static inline HTMLDOMNode *impl_from_IHTMLDOMNode2(IHTMLDOMNode2 *iface)
1099 {
1100     return CONTAINING_RECORD(iface, HTMLDOMNode, IHTMLDOMNode2_iface);
1101 }
1102
1103 static HRESULT WINAPI HTMLDOMNode2_QueryInterface(IHTMLDOMNode2 *iface,
1104         REFIID riid, void **ppv)
1105 {
1106     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
1107
1108     return IHTMLDOMNode_QueryInterface(&This->IHTMLDOMNode_iface, riid, ppv);
1109 }
1110
1111 static ULONG WINAPI HTMLDOMNode2_AddRef(IHTMLDOMNode2 *iface)
1112 {
1113     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
1114
1115     return IHTMLDOMNode_AddRef(&This->IHTMLDOMNode_iface);
1116 }
1117
1118 static ULONG WINAPI HTMLDOMNode2_Release(IHTMLDOMNode2 *iface)
1119 {
1120     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
1121
1122     return IHTMLDOMNode_Release(&This->IHTMLDOMNode_iface);
1123 }
1124
1125 static HRESULT WINAPI HTMLDOMNode2_GetTypeInfoCount(IHTMLDOMNode2 *iface, UINT *pctinfo)
1126 {
1127     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
1128     return IDispatchEx_GetTypeInfoCount(&This->event_target.dispex.IDispatchEx_iface, pctinfo);
1129 }
1130
1131 static HRESULT WINAPI HTMLDOMNode2_GetTypeInfo(IHTMLDOMNode2 *iface, UINT iTInfo,
1132         LCID lcid, ITypeInfo **ppTInfo)
1133 {
1134     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
1135     return IDispatchEx_GetTypeInfo(&This->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1136 }
1137
1138 static HRESULT WINAPI HTMLDOMNode2_GetIDsOfNames(IHTMLDOMNode2 *iface, REFIID riid,
1139                                                 LPOLESTR *rgszNames, UINT cNames,
1140                                                 LCID lcid, DISPID *rgDispId)
1141 {
1142     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
1143     return IDispatchEx_GetIDsOfNames(&This->event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1144             lcid, rgDispId);
1145 }
1146
1147 static HRESULT WINAPI HTMLDOMNode2_Invoke(IHTMLDOMNode2 *iface, DISPID dispIdMember,
1148         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1149         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1150 {
1151     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
1152     return IDispatchEx_Invoke(&This->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1153             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1154 }
1155
1156 static HRESULT WINAPI HTMLDOMNode2_get_ownerDocument(IHTMLDOMNode2 *iface, IDispatch **p)
1157 {
1158     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
1159
1160     TRACE("(%p)->(%p)\n", This, p);
1161
1162     /* FIXME: Better check for document node */
1163     if(This == &This->doc->node) {
1164         *p = NULL;
1165     }else {
1166         *p = (IDispatch*)&This->doc->IHTMLDocument2_iface;
1167         IDispatch_AddRef(*p);
1168     }
1169     return S_OK;
1170 }
1171
1172 static const IHTMLDOMNode2Vtbl HTMLDOMNode2Vtbl = {
1173     HTMLDOMNode2_QueryInterface,
1174     HTMLDOMNode2_AddRef,
1175     HTMLDOMNode2_Release,
1176     HTMLDOMNode2_GetTypeInfoCount,
1177     HTMLDOMNode2_GetTypeInfo,
1178     HTMLDOMNode2_GetIDsOfNames,
1179     HTMLDOMNode2_Invoke,
1180     HTMLDOMNode2_get_ownerDocument
1181 };
1182
1183 static inline HTMLDOMNode *impl_from_IHTMLDOMNode3(IHTMLDOMNode3 *iface)
1184 {
1185     return CONTAINING_RECORD(iface, HTMLDOMNode, IHTMLDOMNode3_iface);
1186 }
1187
1188 static HRESULT WINAPI HTMLDOMNode3_QueryInterface(IHTMLDOMNode3 *iface, REFIID riid, void **ppv)
1189 {
1190     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1191     return IHTMLDOMNode_QueryInterface(&This->IHTMLDOMNode_iface, riid, ppv);
1192 }
1193
1194 static ULONG WINAPI HTMLDOMNode3_AddRef(IHTMLDOMNode3 *iface)
1195 {
1196     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1197
1198     return IHTMLDOMNode_AddRef(&This->IHTMLDOMNode_iface);
1199 }
1200
1201 static ULONG WINAPI HTMLDOMNode3_Release(IHTMLDOMNode3 *iface)
1202 {
1203     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1204
1205     return IHTMLDOMNode_Release(&This->IHTMLDOMNode_iface);
1206 }
1207
1208 static HRESULT WINAPI HTMLDOMNode3_GetTypeInfoCount(IHTMLDOMNode3 *iface, UINT *pctinfo)
1209 {
1210     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1211     return IDispatchEx_GetTypeInfoCount(&This->event_target.dispex.IDispatchEx_iface, pctinfo);
1212 }
1213
1214 static HRESULT WINAPI HTMLDOMNode3_GetTypeInfo(IHTMLDOMNode3 *iface, UINT iTInfo,
1215         LCID lcid, ITypeInfo **ppTInfo)
1216 {
1217     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1218     return IDispatchEx_GetTypeInfo(&This->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1219 }
1220
1221 static HRESULT WINAPI HTMLDOMNode3_GetIDsOfNames(IHTMLDOMNode3 *iface, REFIID riid,
1222                                                 LPOLESTR *rgszNames, UINT cNames,
1223                                                 LCID lcid, DISPID *rgDispId)
1224 {
1225     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1226     return IDispatchEx_GetIDsOfNames(&This->event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1227             lcid, rgDispId);
1228 }
1229
1230 static HRESULT WINAPI HTMLDOMNode3_Invoke(IHTMLDOMNode3 *iface, DISPID dispIdMember,
1231         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1232         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1233 {
1234     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1235     return IDispatchEx_Invoke(&This->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1236             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1237 }
1238
1239 static HRESULT WINAPI HTMLDOMNode3_put_prefix(IHTMLDOMNode3 *iface, VARIANT v)
1240 {
1241     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1242     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1243     return E_NOTIMPL;
1244 }
1245
1246 static HRESULT WINAPI HTMLDOMNode3_get_prefix(IHTMLDOMNode3 *iface, VARIANT *p)
1247 {
1248     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1249     FIXME("(%p)->(%p)\n", This, p);
1250     return E_NOTIMPL;
1251 }
1252
1253 static HRESULT WINAPI HTMLDOMNode3_get_localName(IHTMLDOMNode3 *iface, VARIANT *p)
1254 {
1255     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1256     FIXME("(%p)->(%p)\n", This, p);
1257     return E_NOTIMPL;
1258 }
1259
1260 static HRESULT WINAPI HTMLDOMNode3_get_namespaceURI(IHTMLDOMNode3 *iface, VARIANT *p)
1261 {
1262     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1263     nsAString nsstr;
1264     nsresult nsres;
1265
1266     TRACE("(%p)->(%p)\n", This, p);
1267
1268     nsAString_InitDepend(&nsstr, NULL);
1269     nsres = nsIDOMNode_GetNamespaceURI(This->nsnode, &nsstr);
1270     return return_nsstr_variant(nsres, &nsstr, 0, p);
1271 }
1272
1273 static HRESULT WINAPI HTMLDOMNode3_put_textContent(IHTMLDOMNode3 *iface, VARIANT v)
1274 {
1275     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1276     nsAString nsstr;
1277     nsresult nsres;
1278
1279     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1280
1281     variant_to_nsstr(&v, FALSE, &nsstr);
1282     nsres = nsIDOMNode_SetTextContent(This->nsnode, &nsstr);
1283     nsAString_Finish(&nsstr);
1284     if(NS_FAILED(nsres)) {
1285         ERR("SetTextContent failed: %08lx\n", nsres);
1286         return E_FAIL;
1287     }
1288
1289     return S_OK;
1290 }
1291
1292 static HRESULT WINAPI HTMLDOMNode3_get_textContent(IHTMLDOMNode3 *iface, VARIANT *p)
1293 {
1294     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1295     nsAString nsstr;
1296     nsresult nsres;
1297
1298     TRACE("(%p)->(%p)\n", This, p);
1299
1300     nsAString_Init(&nsstr, NULL);
1301     nsres = nsIDOMNode_GetTextContent(This->nsnode, &nsstr);
1302     return return_nsstr_variant(nsres, &nsstr, 0, p);
1303 }
1304
1305 static HRESULT WINAPI HTMLDOMNode3_isEqualNode(IHTMLDOMNode3 *iface, IHTMLDOMNode3 *otherNode, VARIANT_BOOL *isEqual)
1306 {
1307     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1308     FIXME("(%p)->()\n", This);
1309     return E_NOTIMPL;
1310 }
1311
1312 static HRESULT WINAPI HTMLDOMNode3_lookupNamespaceURI(IHTMLDOMNode3 *iface, VARIANT *prefix, VARIANT *namespaceURI)
1313 {
1314     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1315     FIXME("(%p)->(%s %p)\n", This, debugstr_variant(prefix), namespaceURI);
1316     return E_NOTIMPL;
1317 }
1318
1319 static HRESULT WINAPI HTMLDOMNode3_lookupPrefix(IHTMLDOMNode3 *iface, VARIANT *namespaceURI, VARIANT *prefix)
1320 {
1321     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1322     FIXME("(%p)->(%s %p)\n", This, debugstr_variant(namespaceURI), prefix);
1323     return E_NOTIMPL;
1324 }
1325
1326 static HRESULT WINAPI HTMLDOMNode3_isDefaultNamespace(IHTMLDOMNode3 *iface, VARIANT *namespace, VARIANT_BOOL *pfDefaultNamespace)
1327 {
1328     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1329     FIXME("(%p)->()\n", This);
1330     return E_NOTIMPL;
1331 }
1332
1333 static HRESULT WINAPI HTMLDOMNode3_appendChild(IHTMLDOMNode3 *iface, IHTMLDOMNode *newChild, IHTMLDOMNode **node)
1334 {
1335     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1336     TRACE("(%p)->()\n", This);
1337     return IHTMLDOMNode_appendChild(&This->IHTMLDOMNode_iface, newChild, node);
1338 }
1339
1340 static HRESULT WINAPI HTMLDOMNode3_insertBefore(IHTMLDOMNode3 *iface, IHTMLDOMNode *newChild, VARIANT refChild, IHTMLDOMNode **node)
1341 {
1342     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1343     TRACE("(%p)->(%p %s %p)\n", This, newChild, debugstr_variant(&refChild), node);
1344     return IHTMLDOMNode_insertBefore(&This->IHTMLDOMNode_iface, newChild, refChild, node);
1345 }
1346
1347 static HRESULT WINAPI HTMLDOMNode3_removeChild(IHTMLDOMNode3 *iface, IHTMLDOMNode *oldChild, IHTMLDOMNode **node)
1348 {
1349     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1350     TRACE("(%p)->(%p %p)\n", This, oldChild, node);
1351     return IHTMLDOMNode_removeChild(&This->IHTMLDOMNode_iface, oldChild, node);
1352 }
1353
1354 static HRESULT WINAPI HTMLDOMNode3_replaceChild(IHTMLDOMNode3 *iface, IHTMLDOMNode *newChild, IHTMLDOMNode *oldChild, IHTMLDOMNode **node)
1355 {
1356     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1357     TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, node);
1358     return IHTMLDOMNode_replaceChild(&This->IHTMLDOMNode_iface, newChild, oldChild, node);
1359 }
1360
1361 static HRESULT WINAPI HTMLDOMNode3_isSameNode(IHTMLDOMNode3 *iface, IHTMLDOMNode3 *otherNode, VARIANT_BOOL *isSame)
1362 {
1363     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1364     FIXME("(%p)->()\n", This);
1365     return E_NOTIMPL;
1366 }
1367
1368 static HRESULT WINAPI HTMLDOMNode3_compareDocumentPosition(IHTMLDOMNode3 *iface, IHTMLDOMNode *otherNode, USHORT *flags)
1369 {
1370     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1371     HTMLDOMNode *other;
1372     UINT16 position;
1373     nsresult nsres;
1374
1375     TRACE("(%p)->()\n", This);
1376
1377     other = get_node_obj(otherNode);
1378     if(!other)
1379         return E_INVALIDARG;
1380
1381     nsres = nsIDOMNode_CompareDocumentPosition(This->nsnode, other->nsnode, &position);
1382     IHTMLDOMNode_Release(&other->IHTMLDOMNode_iface);
1383     if(NS_FAILED(nsres)) {
1384         ERR("failed: %08lx\n", nsres);
1385         return E_FAIL;
1386     }
1387
1388     *flags = position;
1389     return S_OK;
1390 }
1391
1392 static HRESULT WINAPI HTMLDOMNode3_isSupported(IHTMLDOMNode3 *iface, BSTR feature, VARIANT version, VARIANT_BOOL *pfisSupported)
1393 {
1394     HTMLDOMNode *This = impl_from_IHTMLDOMNode3(iface);
1395     FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(feature), debugstr_variant(&version), pfisSupported);
1396     return E_NOTIMPL;
1397 }
1398
1399 static const IHTMLDOMNode3Vtbl HTMLDOMNode3Vtbl = {
1400     HTMLDOMNode3_QueryInterface,
1401     HTMLDOMNode3_AddRef,
1402     HTMLDOMNode3_Release,
1403     HTMLDOMNode3_GetTypeInfoCount,
1404     HTMLDOMNode3_GetTypeInfo,
1405     HTMLDOMNode3_GetIDsOfNames,
1406     HTMLDOMNode3_Invoke,
1407     HTMLDOMNode3_put_prefix,
1408     HTMLDOMNode3_get_prefix,
1409     HTMLDOMNode3_get_localName,
1410     HTMLDOMNode3_get_namespaceURI,
1411     HTMLDOMNode3_put_textContent,
1412     HTMLDOMNode3_get_textContent,
1413     HTMLDOMNode3_isEqualNode,
1414     HTMLDOMNode3_lookupNamespaceURI,
1415     HTMLDOMNode3_lookupPrefix,
1416     HTMLDOMNode3_isDefaultNamespace,
1417     HTMLDOMNode3_appendChild,
1418     HTMLDOMNode3_insertBefore,
1419     HTMLDOMNode3_removeChild,
1420     HTMLDOMNode3_replaceChild,
1421     HTMLDOMNode3_isSameNode,
1422     HTMLDOMNode3_compareDocumentPosition,
1423     HTMLDOMNode3_isSupported
1424 };
1425
1426 HRESULT HTMLDOMNode_QI(HTMLDOMNode *This, REFIID riid, void **ppv)
1427 {
1428     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1429
1430     if(IsEqualGUID(&IID_IUnknown, riid)) {
1431         *ppv = &This->IHTMLDOMNode_iface;
1432     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1433         *ppv = &This->IHTMLDOMNode_iface;
1434     }else if(IsEqualGUID(&IID_IHTMLDOMNode, riid)) {
1435         *ppv = &This->IHTMLDOMNode_iface;
1436     }else if(IsEqualGUID(&IID_IHTMLDOMNode2, riid)) {
1437         *ppv = &This->IHTMLDOMNode2_iface;
1438     }else if(IsEqualGUID(&IID_IHTMLDOMNode3, riid)) {
1439         *ppv = &This->IHTMLDOMNode3_iface;
1440     }else if(IsEqualGUID(&IID_nsXPCOMCycleCollectionParticipant, riid)) {
1441         *ppv = &node_ccp;
1442         return S_OK;
1443     }else if(IsEqualGUID(&IID_nsCycleCollectionISupports, riid)) {
1444         *ppv = &This->IHTMLDOMNode_iface;
1445         return S_OK;
1446     }else {
1447         return EventTarget_QI(&This->event_target, riid, ppv);
1448     }
1449
1450     IUnknown_AddRef((IUnknown*)*ppv);
1451     return S_OK;
1452 }
1453
1454 void HTMLDOMNode_destructor(HTMLDOMNode *This)
1455 {
1456     release_event_target(&This->event_target);
1457     if(This->nsnode)
1458         nsIDOMNode_Release(This->nsnode);
1459     if(This->doc && &This->doc->node != This)
1460         IHTMLDOMNode_Release(&This->doc->node.IHTMLDOMNode_iface);
1461 }
1462
1463 static HRESULT HTMLDOMNode_clone(HTMLDOMNode *This, nsIDOMNode *nsnode, HTMLDOMNode **ret)
1464 {
1465     return create_node(This->doc, nsnode, ret);
1466 }
1467
1468 void HTMLDOMNode_init_dispex_info(dispex_data_t *info, compat_mode_t mode)
1469 {
1470     if(mode >= COMPAT_MODE_IE9)
1471         dispex_info_add_interface(info, IHTMLDOMNode3_tid, NULL);
1472
1473     EventTarget_init_dispex_info(info, mode);
1474 }
1475
1476 static const cpc_entry_t HTMLDOMNode_cpc[] = {{NULL}};
1477
1478 static const NodeImplVtbl HTMLDOMNodeImplVtbl = {
1479     .qi                    = HTMLDOMNode_QI,
1480     .destructor            = HTMLDOMNode_destructor,
1481     .cpc_entries           = HTMLDOMNode_cpc,
1482     .clone                 = HTMLDOMNode_clone
1483 };
1484
1485 void HTMLDOMNode_Init(HTMLDocumentNode *doc, HTMLDOMNode *node, nsIDOMNode *nsnode, dispex_static_data_t *dispex_data)
1486 {
1487     nsresult nsres;
1488
1489     node->IHTMLDOMNode_iface.lpVtbl = &HTMLDOMNodeVtbl;
1490     node->IHTMLDOMNode2_iface.lpVtbl = &HTMLDOMNode2Vtbl;
1491     node->IHTMLDOMNode3_iface.lpVtbl = &HTMLDOMNode3Vtbl;
1492
1493     ccref_init(&node->ccref, 1);
1494     EventTarget_Init(&node->event_target, (IUnknown*)&node->IHTMLDOMNode_iface, dispex_data, doc->document_mode);
1495
1496     if(&doc->node != node)
1497         IHTMLDOMNode_AddRef(&doc->node.IHTMLDOMNode_iface);
1498     node->doc = doc;
1499
1500     nsIDOMNode_AddRef(nsnode);
1501     node->nsnode = nsnode;
1502
1503     nsres = nsIDOMNode_SetMshtmlNode(nsnode, (nsISupports*)&node->IHTMLDOMNode_iface);
1504     assert(nsres == NS_OK);
1505 }
1506
1507 static const tid_t HTMLDOMNode_iface_tids[] = {
1508     IHTMLDOMNode_tid,
1509     0
1510 };
1511 static dispex_static_data_t HTMLDOMNode_dispex = {
1512     "Node",
1513     NULL,
1514     IHTMLDOMNode_tid,
1515     HTMLDOMNode_iface_tids,
1516     HTMLDOMNode_init_dispex_info
1517 };
1518
1519 static HRESULT create_node(HTMLDocumentNode *doc, nsIDOMNode *nsnode, HTMLDOMNode **ret)
1520 {
1521     UINT16 node_type;
1522     HRESULT hres;
1523
1524     nsIDOMNode_GetNodeType(nsnode, &node_type);
1525
1526     switch(node_type) {
1527     case ELEMENT_NODE: {
1528         HTMLElement *elem;
1529         hres = HTMLElement_Create(doc, nsnode, FALSE, &elem);
1530         if(FAILED(hres))
1531             return hres;
1532         *ret = &elem->node;
1533         break;
1534     }
1535     case TEXT_NODE:
1536         hres = HTMLDOMTextNode_Create(doc, nsnode, ret);
1537         if(FAILED(hres))
1538             return hres;
1539         break;
1540     case DOCUMENT_TYPE_NODE:
1541         if(dispex_compat_mode(&doc->node.event_target.dispex) >= COMPAT_MODE_IE9) {
1542             hres = create_doctype_node(doc, nsnode, ret);
1543             if(FAILED(hres))
1544                 return hres;
1545             break;
1546         }
1547         /* doctype nodes are represented as comment nodes in quirks mode */
1548         /* fall through */
1549     case COMMENT_NODE: {
1550         HTMLElement *comment;
1551         hres = HTMLCommentElement_Create(doc, nsnode, &comment);
1552         if(FAILED(hres))
1553             return hres;
1554         *ret = &comment->node;
1555         break;
1556     }
1557     case ATTRIBUTE_NODE:
1558         ERR("Called on attribute node\n");
1559         return E_UNEXPECTED;
1560     default: {
1561         HTMLDOMNode *node;
1562
1563         FIXME("unimplemented node type %u\n", node_type);
1564
1565         node = calloc(1, sizeof(HTMLDOMNode));
1566         if(!node)
1567             return E_OUTOFMEMORY;
1568
1569         node->vtbl = &HTMLDOMNodeImplVtbl;
1570         HTMLDOMNode_Init(doc, node, nsnode, &HTMLDOMNode_dispex);
1571         *ret = node;
1572     }
1573     }
1574
1575     TRACE("type %d ret %p\n", node_type, *ret);
1576     return S_OK;
1577 }
1578
1579 static nsresult NSAPI HTMLDOMNode_traverse(void *ccp, void *p, nsCycleCollectionTraversalCallback *cb)
1580 {
1581     HTMLDOMNode *This = impl_from_IHTMLDOMNode(p);
1582
1583     TRACE("%p\n", This);
1584
1585     describe_cc_node(&This->ccref, "HTMLDOMNode", cb);
1586
1587     if(This->nsnode)
1588         note_cc_edge((nsISupports*)This->nsnode, "This->nsnode", cb);
1589     if(This->doc && &This->doc->node != This)
1590         note_cc_edge((nsISupports*)&This->doc->node.IHTMLDOMNode_iface, "This->doc", cb);
1591     dispex_traverse(&This->event_target.dispex, cb);
1592
1593     if(This->vtbl->traverse)
1594         This->vtbl->traverse(This, cb);
1595
1596     return NS_OK;
1597 }
1598
1599 static nsresult NSAPI HTMLDOMNode_unlink(void *p)
1600 {
1601     HTMLDOMNode *This = impl_from_IHTMLDOMNode(p);
1602
1603     TRACE("%p\n", This);
1604
1605     if(This->vtbl->unlink)
1606         This->vtbl->unlink(This);
1607
1608     dispex_unlink(&This->event_target.dispex);
1609     unlink_ref(&This->nsnode);
1610
1611     if(This->doc && &This->doc->node != This) {
1612         HTMLDocumentNode *doc = This->doc;
1613         This->doc = NULL;
1614         IHTMLDOMNode_Release(&doc->node.IHTMLDOMNode_iface);
1615     }else {
1616         This->doc = NULL;
1617     }
1618
1619     return NS_OK;
1620 }
1621
1622 static void NSAPI HTMLDOMNode_delete_cycle_collectable(void *p)
1623 {
1624     HTMLDOMNode *This = impl_from_IHTMLDOMNode(p);
1625
1626     TRACE("(%p)\n", This);
1627
1628     if(This->vtbl->unlink)
1629         This->vtbl->unlink(This);
1630     This->vtbl->destructor(This);
1631     release_dispex(&This->event_target.dispex);
1632     free(This);
1633 }
1634
1635 void init_node_cc(void)
1636 {
1637     static const CCObjCallback node_ccp_callback = {
1638         HTMLDOMNode_traverse,
1639         HTMLDOMNode_unlink,
1640         HTMLDOMNode_delete_cycle_collectable
1641     };
1642
1643     ccp_init(&node_ccp, &node_ccp_callback);
1644 }
1645
1646 HRESULT get_node(nsIDOMNode *nsnode, BOOL create, HTMLDOMNode **ret)
1647 {
1648     nsIDOMDocument *dom_document;
1649     HTMLDocumentNode *document;
1650     nsISupports *unk = NULL;
1651     nsresult nsres;
1652     HRESULT hres;
1653
1654     nsres = nsIDOMNode_GetMshtmlNode(nsnode, &unk);
1655     assert(nsres == NS_OK);
1656
1657     if(unk) {
1658         *ret = get_node_obj((IHTMLDOMNode*)unk);
1659         nsISupports_Release(unk);
1660         return NS_OK;
1661     }
1662
1663     if(!create) {
1664         *ret = NULL;
1665         return S_OK;
1666     }
1667
1668     nsres = nsIDOMNode_GetOwnerDocument(nsnode, &dom_document);
1669     if(NS_FAILED(nsres) || !dom_document) {
1670         ERR("GetOwnerDocument failed: %08lx\n", nsres);
1671         return E_FAIL;
1672     }
1673
1674     hres = get_document_node(dom_document, &document);
1675     nsIDOMDocument_Release(dom_document);
1676     if(!document)
1677         return E_FAIL;
1678
1679     hres = create_node(document, nsnode, ret);
1680     IHTMLDOMNode_Release(&document->node.IHTMLDOMNode_iface);
1681     return hres;
1682 }