git.oblomov.eu Git - wine/blob - 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 #include <assert.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28
  29 #include "wine/debug.h"
  30
  31 #include "mshtml_private.h"
  32 #include "htmlevent.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  35
  36 static HTMLDOMNode *get_node_obj(IHTMLDOMNode*);
  37 static HRESULT create_node(HTMLDocumentNode*,nsIDOMNode*,HTMLDOMNode**);
  38
  39 typedef struct {
  40     DispatchEx dispex;
  41     IHTMLDOMChildrenCollection IHTMLDOMChildrenCollection_iface;
  42
  43     LONG ref;
  44
  45     /* FIXME: implement weak reference */
  46     HTMLDocumentNode *doc;
  47
  48     nsIDOMNodeList *nslist;
  49 } HTMLDOMChildrenCollection;
  50
  51 static inline HTMLDOMChildrenCollection *impl_from_IHTMLDOMChildrenCollection(IHTMLDOMChildrenCollection *iface)
  52 {
  53     return CONTAINING_RECORD(iface, HTMLDOMChildrenCollection, IHTMLDOMChildrenCollection_iface);
  54 }
  55
  56 static HRESULT WINAPI HTMLDOMChildrenCollection_QueryInterface(IHTMLDOMChildrenCollection *iface, REFIID riid, void **ppv)
  57 {
  58     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
  59
  60     *ppv = NULL;
  61
  62     if(IsEqualGUID(&IID_IUnknown, riid)) {
  63         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  64         *ppv = &This->IHTMLDOMChildrenCollection_iface;
  65     }else if(IsEqualGUID(&IID_IHTMLDOMChildrenCollection, riid)) {
  66         TRACE("(%p)->(IID_IHTMLDOMChildrenCollection %p)\n", This, ppv);
  67         *ppv = &This->IHTMLDOMChildrenCollection_iface;
  68     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
  69         return *ppv ? S_OK : E_NOINTERFACE;
  70     }
  71
  72     if(*ppv) {
  73         IUnknown_AddRef((IUnknown*)*ppv);
  74         return S_OK;
  75     }
  76
  77     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
  78     return E_NOINTERFACE;
  79 }
  80
  81 static ULONG WINAPI HTMLDOMChildrenCollection_AddRef(IHTMLDOMChildrenCollection *iface)
  82 {
  83     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
  84     LONG ref = InterlockedIncrement(&This->ref);
  85
  86     TRACE("(%p) ref=%d\n", This, ref);
  87
  88     return ref;
  89 }
  90
  91 static ULONG WINAPI HTMLDOMChildrenCollection_Release(IHTMLDOMChildrenCollection *iface)
  92 {
  93     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
  94     LONG ref = InterlockedDecrement(&This->ref);
  95
  96     TRACE("(%p) ref=%d\n", This, ref);
  97
  98     if(!ref) {
  99         htmldoc_release(&This->doc->basedoc);
 100         nsIDOMNodeList_Release(This->nslist);
 101         heap_free(This);
 102     }
 103
 104     return ref;
 105 }
 106
 107 static HRESULT WINAPI HTMLDOMChildrenCollection_GetTypeInfoCount(IHTMLDOMChildrenCollection *iface, UINT *pctinfo)
 108 {
 109     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 110     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 111 }
 112
 113 static HRESULT WINAPI HTMLDOMChildrenCollection_GetTypeInfo(IHTMLDOMChildrenCollection *iface, UINT iTInfo,
 114         LCID lcid, ITypeInfo **ppTInfo)
 115 {
 116     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 117     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 118 }
 119
 120 static HRESULT WINAPI HTMLDOMChildrenCollection_GetIDsOfNames(IHTMLDOMChildrenCollection *iface, REFIID riid,
 121         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 122 {
 123     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 124     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 125             lcid, rgDispId);
 126 }
 127
 128 static HRESULT WINAPI HTMLDOMChildrenCollection_Invoke(IHTMLDOMChildrenCollection *iface, DISPID dispIdMember,
 129         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 130         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 131 {
 132     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 133     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 134             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 135 }
 136
 137 static HRESULT WINAPI HTMLDOMChildrenCollection_get_length(IHTMLDOMChildrenCollection *iface, LONG *p)
 138 {
 139     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 140     PRUint32 length=0;
 141
 142     TRACE("(%p)->(%p)\n", This, p);
 143
 144     nsIDOMNodeList_GetLength(This->nslist, &length);
 145     *p = length;
 146     return S_OK;
 147 }
 148
 149 static HRESULT WINAPI HTMLDOMChildrenCollection__newEnum(IHTMLDOMChildrenCollection *iface, IUnknown **p)
 150 {
 151     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 152     FIXME("(%p)->(%p)\n", This, p);
 153     return E_NOTIMPL;
 154 }
 155
 156 static HRESULT WINAPI HTMLDOMChildrenCollection_item(IHTMLDOMChildrenCollection *iface, LONG index, IDispatch **ppItem)
 157 {
 158     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
 159     nsIDOMNode *nsnode = NULL;
 160     HTMLDOMNode *node;
 161     PRUint32 length=0;
 162     nsresult nsres;
 163     HRESULT hres;
 164
 165     TRACE("(%p)->(%d %p)\n", This, index, ppItem);
 166
 167     if (ppItem)
 168         *ppItem = NULL;
 169     else
 170         return E_POINTER;
 171
 172     nsIDOMNodeList_GetLength(This->nslist, &length);
 173     if(index < 0 || index >= length)
 174         return E_INVALIDARG;
 175
 176     nsres = nsIDOMNodeList_Item(This->nslist, index, &nsnode);
 177     if(NS_FAILED(nsres) || !nsnode) {
 178         ERR("Item failed: %08x\n", nsres);
 179         return E_FAIL;
 180     }
 181
 182     hres = get_node(This->doc, nsnode, TRUE, &node);
 183     if(FAILED(hres))
 184         return hres;
 185
 186     *ppItem = (IDispatch*)&node->IHTMLDOMNode_iface;
 187     return S_OK;
 188 }
 189
 190 static const IHTMLDOMChildrenCollectionVtbl HTMLDOMChildrenCollectionVtbl = {
 191     HTMLDOMChildrenCollection_QueryInterface,
 192     HTMLDOMChildrenCollection_AddRef,
 193     HTMLDOMChildrenCollection_Release,
 194     HTMLDOMChildrenCollection_GetTypeInfoCount,
 195     HTMLDOMChildrenCollection_GetTypeInfo,
 196     HTMLDOMChildrenCollection_GetIDsOfNames,
 197     HTMLDOMChildrenCollection_Invoke,
 198     HTMLDOMChildrenCollection_get_length,
 199     HTMLDOMChildrenCollection__newEnum,
 200     HTMLDOMChildrenCollection_item
 201 };
 202
 203 static inline HTMLDOMChildrenCollection *impl_from_DispatchEx(DispatchEx *iface)
 204 {
 205     return CONTAINING_RECORD(iface, HTMLDOMChildrenCollection, dispex);
 206 }
 207
 208 #define DISPID_CHILDCOL_0 MSHTML_DISPID_CUSTOM_MIN
 209
 210 static HRESULT HTMLDOMChildrenCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
 211 {
 212     HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex);
 213     WCHAR *ptr;
 214     DWORD idx=0;
 215     PRUint32 len = 0;
 216
 217     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
 218         idx = idx*10 + (*ptr-'0');
 219     if(*ptr)
 220         return DISP_E_UNKNOWNNAME;
 221
 222     nsIDOMNodeList_GetLength(This->nslist, &len);
 223     if(idx >= len)
 224         return DISP_E_UNKNOWNNAME;
 225
 226     *dispid = DISPID_CHILDCOL_0 + idx;
 227     TRACE("ret %x\n", *dispid);
 228     return S_OK;
 229 }
 230
 231 static HRESULT HTMLDOMChildrenCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 232         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 233 {
 234     HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex);
 235
 236     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
 237
 238     switch(flags) {
 239     case DISPATCH_PROPERTYGET: {
 240         IDispatch *disp = NULL;
 241         HRESULT hres;
 242
 243         hres = IHTMLDOMChildrenCollection_item(&This->IHTMLDOMChildrenCollection_iface,
 244                 id - DISPID_CHILDCOL_0, &disp);
 245         if(FAILED(hres))
 246             return hres;
 247
 248         V_VT(res) = VT_DISPATCH;
 249         V_DISPATCH(res) = disp;
 250         break;
 251     }
 252
 253     default:
 254         FIXME("unimplemented flags %x\n", flags);
 255         return E_NOTIMPL;
 256     }
 257
 258     return S_OK;
 259 }
 260
 261 static const dispex_static_data_vtbl_t HTMLDOMChildrenCollection_dispex_vtbl = {
 262     NULL,
 263     HTMLDOMChildrenCollection_get_dispid,
 264     HTMLDOMChildrenCollection_invoke,
 265     NULL
 266 };
 267
 268 static const tid_t HTMLDOMChildrenCollection_iface_tids[] = {
 269     IHTMLDOMChildrenCollection_tid,
 270     0
 271 };
 272
 273 static dispex_static_data_t HTMLDOMChildrenCollection_dispex = {
 274     &HTMLDOMChildrenCollection_dispex_vtbl,
 275     DispDOMChildrenCollection_tid,
 276     NULL,
 277     HTMLDOMChildrenCollection_iface_tids
 278 };
 279
 280 static IHTMLDOMChildrenCollection *create_child_collection(HTMLDocumentNode *doc, nsIDOMNodeList *nslist)
 281 {
 282     HTMLDOMChildrenCollection *ret;
 283
 284     ret = heap_alloc_zero(sizeof(*ret));
 285     ret->IHTMLDOMChildrenCollection_iface.lpVtbl = &HTMLDOMChildrenCollectionVtbl;
 286     ret->ref = 1;
 287
 288     nsIDOMNodeList_AddRef(nslist);
 289     ret->nslist = nslist;
 290
 291     htmldoc_addref(&doc->basedoc);
 292     ret->doc = doc;
 293
 294     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLDOMChildrenCollection_iface,
 295             &HTMLDOMChildrenCollection_dispex);
 296
 297     return &ret->IHTMLDOMChildrenCollection_iface;
 298 }
 299
 300 static inline HTMLDOMNode *impl_from_IHTMLDOMNode(IHTMLDOMNode *iface)
 301 {
 302     return CONTAINING_RECORD(iface, HTMLDOMNode, IHTMLDOMNode_iface);
 303 }
 304
 305 static HRESULT WINAPI HTMLDOMNode_QueryInterface(IHTMLDOMNode *iface,
 306                                                  REFIID riid, void **ppv)
 307 {
 308     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 309
 310     return This->vtbl->qi(This, riid, ppv);
 311 }
 312
 313 static ULONG WINAPI HTMLDOMNode_AddRef(IHTMLDOMNode *iface)
 314 {
 315     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 316     LONG ref = ccref_incr(&This->ccref, (nsISupports*)&This->IHTMLDOMNode_iface);
 317
 318     TRACE("(%p) ref=%d\n", This, ref);
 319
 320     return ref;
 321 }
 322
 323 static ULONG WINAPI HTMLDOMNode_Release(IHTMLDOMNode *iface)
 324 {
 325     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 326     LONG ref = ccref_decr(&This->ccref, (nsISupports*)&This->IHTMLDOMNode_iface);
 327
 328     TRACE("(%p) ref=%d\n", This, ref);
 329
 330     if(!ref) {
 331         This->vtbl->destructor(This);
 332         release_dispex(&This->dispex);
 333         heap_free(This);
 334     }
 335
 336     return ref;
 337 }
 338
 339 static HRESULT WINAPI HTMLDOMNode_GetTypeInfoCount(IHTMLDOMNode *iface, UINT *pctinfo)
 340 {
 341     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 342     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 343 }
 344
 345 static HRESULT WINAPI HTMLDOMNode_GetTypeInfo(IHTMLDOMNode *iface, UINT iTInfo,
 346                                               LCID lcid, ITypeInfo **ppTInfo)
 347 {
 348     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 349     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 350 }
 351
 352 static HRESULT WINAPI HTMLDOMNode_GetIDsOfNames(IHTMLDOMNode *iface, REFIID riid,
 353                                                 LPOLESTR *rgszNames, UINT cNames,
 354                                                 LCID lcid, DISPID *rgDispId)
 355 {
 356     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 357     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 358             lcid, rgDispId);
 359 }
 360
 361 static HRESULT WINAPI HTMLDOMNode_Invoke(IHTMLDOMNode *iface, DISPID dispIdMember,
 362                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 363                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 364 {
 365     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 366     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 367             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 368 }
 369
 370 static HRESULT WINAPI HTMLDOMNode_get_nodeType(IHTMLDOMNode *iface, LONG *p)
 371 {
 372     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 373     PRUint16 type = -1;
 374
 375     TRACE("(%p)->(%p)\n", This, p);
 376
 377     nsIDOMNode_GetNodeType(This->nsnode, &type);
 378
 379     switch(type) {
 380     case ELEMENT_NODE:
 381         *p = 1;
 382         break;
 383     case TEXT_NODE:
 384         *p = 3;
 385         break;
 386     case COMMENT_NODE:
 387         *p = 8;
 388         break;
 389     case DOCUMENT_NODE:
 390         *p = 9;
 391         break;
 392     case DOCUMENT_FRAGMENT_NODE:
 393         *p = 11;
 394         break;
 395     default:
 396         /*
 397          * FIXME:
 398          * According to MSDN only ELEMENT_NODE and TEXT_NODE are supported.
 399          * It needs more tests.
 400          */
 401         FIXME("type %u\n", type);
 402         *p = 0;
 403     }
 404
 405     return S_OK;
 406 }
 407
 408 static HRESULT WINAPI HTMLDOMNode_get_parentNode(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 409 {
 410     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 411     HTMLDOMNode *node;
 412     nsIDOMNode *nsnode;
 413     nsresult nsres;
 414     HRESULT hres;
 415
 416     TRACE("(%p)->(%p)\n", This, p);
 417
 418     nsres = nsIDOMNode_GetParentNode(This->nsnode, &nsnode);
 419     if(NS_FAILED(nsres)) {
 420         ERR("GetParentNode failed: %08x\n", nsres);
 421         return E_FAIL;
 422     }
 423
 424     if(!nsnode) {
 425         *p = NULL;
 426         return S_OK;
 427     }
 428
 429     hres = get_node(This->doc, nsnode, TRUE, &node);
 430     nsIDOMNode_Release(nsnode);
 431     if(FAILED(hres))
 432         return hres;
 433
 434     *p = &node->IHTMLDOMNode_iface;
 435     return S_OK;
 436 }
 437
 438 static HRESULT WINAPI HTMLDOMNode_hasChildNodes(IHTMLDOMNode *iface, VARIANT_BOOL *fChildren)
 439 {
 440     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 441     cpp_bool has_child = FALSE;
 442     nsresult nsres;
 443
 444     TRACE("(%p)->(%p)\n", This, fChildren);
 445
 446     nsres = nsIDOMNode_HasChildNodes(This->nsnode, &has_child);
 447     if(NS_FAILED(nsres))
 448         ERR("HasChildNodes failed: %08x\n", nsres);
 449
 450     *fChildren = has_child ? VARIANT_TRUE : VARIANT_FALSE;
 451     return S_OK;
 452 }
 453
 454 static HRESULT WINAPI HTMLDOMNode_get_childNodes(IHTMLDOMNode *iface, IDispatch **p)
 455 {
 456     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 457     nsIDOMNodeList *nslist;
 458     nsresult nsres;
 459
 460     TRACE("(%p)->(%p)\n", This, p);
 461
 462     nsres = nsIDOMNode_GetChildNodes(This->nsnode, &nslist);
 463     if(NS_FAILED(nsres)) {
 464         ERR("GetChildNodes failed: %08x\n", nsres);
 465         return E_FAIL;
 466     }
 467
 468     *p = (IDispatch*)create_child_collection(This->doc, nslist);
 469     nsIDOMNodeList_Release(nslist);
 470
 471     return S_OK;
 472 }
 473
 474 static HRESULT WINAPI HTMLDOMNode_get_attributes(IHTMLDOMNode *iface, IDispatch **p)
 475 {
 476     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 477     HTMLAttributeCollection *col;
 478     HRESULT hres;
 479
 480     TRACE("(%p)->(%p)\n", This, p);
 481
 482     if(This->vtbl->get_attr_col) {
 483         hres = This->vtbl->get_attr_col(This, &col);
 484         if(FAILED(hres))
 485             return hres;
 486
 487         *p = (IDispatch*)&col->IHTMLAttributeCollection_iface;
 488         return S_OK;
 489     }
 490
 491     *p = NULL;
 492     return S_OK;
 493 }
 494
 495 static HRESULT WINAPI HTMLDOMNode_insertBefore(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 496                                                VARIANT refChild, IHTMLDOMNode **node)
 497 {
 498     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 499     HTMLDOMNode *new_child, *node_obj, *ref_node = NULL;
 500     nsIDOMNode *nsnode;
 501     nsresult nsres;
 502     HRESULT hres = S_OK;
 503
 504     TRACE("(%p)->(%p %s %p)\n", This, newChild, debugstr_variant(&refChild), node);
 505
 506     new_child = get_node_obj(newChild);
 507     if(!new_child) {
 508         ERR("invalid newChild\n");
 509         return E_INVALIDARG;
 510     }
 511
 512     switch(V_VT(&refChild)) {
 513     case VT_NULL:
 514         break;
 515     case VT_DISPATCH: {
 516         IHTMLDOMNode *ref_iface;
 517
 518         if(!V_DISPATCH(&refChild))
 519             break;
 520
 521         hres = IDispatch_QueryInterface(V_DISPATCH(&refChild), &IID_IHTMLDOMNode, (void**)&ref_iface);
 522         if(FAILED(hres))
 523             break;
 524
 525         ref_node = get_node_obj(ref_iface);
 526         IHTMLDOMNode_Release(ref_iface);
 527         if(!ref_node) {
 528             ERR("unvalid node\n");
 529             hres = E_FAIL;
 530             break;
 531         }
 532         break;
 533     }
 534     default:
 535         FIXME("unimplemented refChild %s\n", debugstr_variant(&refChild));
 536         hres = E_NOTIMPL;
 537     }
 538
 539     if(SUCCEEDED(hres)) {
 540         nsres = nsIDOMNode_InsertBefore(This->nsnode, new_child->nsnode, ref_node ? ref_node->nsnode : NULL, &nsnode);
 541         if(NS_FAILED(nsres)) {
 542             ERR("InsertBefore failed: %08x\n", nsres);
 543             hres = E_FAIL;
 544         }
 545     }
 546     node_release(new_child);
 547     if(ref_node)
 548         node_release(ref_node);
 549     if(FAILED(hres))
 550         return hres;
 551
 552     hres = get_node(This->doc, nsnode, TRUE, &node_obj);
 553     nsIDOMNode_Release(nsnode);
 554     if(FAILED(hres))
 555         return hres;
 556
 557     *node = &node_obj->IHTMLDOMNode_iface;
 558     return S_OK;
 559 }
 560
 561 static HRESULT WINAPI HTMLDOMNode_removeChild(IHTMLDOMNode *iface, IHTMLDOMNode *oldChild,
 562                                               IHTMLDOMNode **node)
 563 {
 564     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 565     HTMLDOMNode *node_obj;
 566     nsIDOMNode *nsnode;
 567     nsresult nsres;
 568     HRESULT hres;
 569
 570     TRACE("(%p)->(%p %p)\n", This, oldChild, node);
 571
 572     node_obj = get_node_obj(oldChild);
 573     if(!node_obj)
 574         return E_FAIL;
 575
 576     nsres = nsIDOMNode_RemoveChild(This->nsnode, node_obj->nsnode, &nsnode);
 577     node_release(node_obj);
 578     if(NS_FAILED(nsres)) {
 579         ERR("RemoveChild failed: %08x\n", nsres);
 580         return E_FAIL;
 581     }
 582
 583     hres = get_node(This->doc, nsnode, TRUE, &node_obj);
 584     nsIDOMNode_Release(nsnode);
 585     if(FAILED(hres))
 586         return hres;
 587
 588     /* FIXME: Make sure that node != newChild */
 589     *node = &node_obj->IHTMLDOMNode_iface;
 590     return S_OK;
 591 }
 592
 593 static HRESULT WINAPI HTMLDOMNode_replaceChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 594                                                IHTMLDOMNode *oldChild, IHTMLDOMNode **node)
 595 {
 596     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 597     HTMLDOMNode *node_new, *node_old, *ret_node;
 598     nsIDOMNode *nsnode;
 599     nsresult nsres;
 600     HRESULT hres;
 601
 602     TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, node);
 603
 604     node_new = get_node_obj(newChild);
 605     if(!node_new)
 606         return E_FAIL;
 607
 608     node_old = get_node_obj(oldChild);
 609     if(!node_old) {
 610         node_release(node_new);
 611         return E_FAIL;
 612     }
 613
 614     nsres = nsIDOMNode_ReplaceChild(This->nsnode, node_new->nsnode, node_old->nsnode, &nsnode);
 615     node_release(node_new);
 616     node_release(node_old);
 617     if(NS_FAILED(nsres))
 618         return E_FAIL;
 619
 620     hres = get_node(This->doc, nsnode, TRUE, &ret_node);
 621     nsIDOMNode_Release(nsnode);
 622     if(FAILED(hres))
 623         return hres;
 624
 625     *node = &ret_node->IHTMLDOMNode_iface;
 626     return S_OK;
 627 }
 628
 629 static HRESULT WINAPI HTMLDOMNode_cloneNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
 630                                             IHTMLDOMNode **clonedNode)
 631 {
 632     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 633     HTMLDOMNode *new_node;
 634     nsIDOMNode *nsnode;
 635     nsresult nsres;
 636     HRESULT hres;
 637
 638     TRACE("(%p)->(%x %p)\n", This, fDeep, clonedNode);
 639
 640     nsres = nsIDOMNode_CloneNode(This->nsnode, fDeep != VARIANT_FALSE, 1, &nsnode);
 641     if(NS_FAILED(nsres) || !nsnode) {
 642         ERR("CloneNode failed: %08x\n", nsres);
 643         return E_FAIL;
 644     }
 645
 646     hres = This->vtbl->clone(This, nsnode, &new_node);
 647     if(FAILED(hres))
 648         return hres;
 649
 650     *clonedNode = &new_node->IHTMLDOMNode_iface;
 651     return S_OK;
 652 }
 653
 654 static HRESULT WINAPI HTMLDOMNode_removeNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
 655                                              IHTMLDOMNode **removed)
 656 {
 657     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 658     FIXME("(%p)->(%x %p)\n", This, fDeep, removed);
 659     return E_NOTIMPL;
 660 }
 661
 662 static HRESULT WINAPI HTMLDOMNode_swapNode(IHTMLDOMNode *iface, IHTMLDOMNode *otherNode,
 663                                            IHTMLDOMNode **swappedNode)
 664 {
 665     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 666     FIXME("(%p)->(%p %p)\n", This, otherNode, swappedNode);
 667     return E_NOTIMPL;
 668 }
 669
 670 static HRESULT WINAPI HTMLDOMNode_replaceNode(IHTMLDOMNode *iface, IHTMLDOMNode *replacement,
 671                                               IHTMLDOMNode **replaced)
 672 {
 673     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 674     FIXME("(%p)->(%p %p)\n", This, replacement, replaced);
 675     return E_NOTIMPL;
 676 }
 677
 678 static HRESULT WINAPI HTMLDOMNode_appendChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 679                                               IHTMLDOMNode **node)
 680 {
 681     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 682     HTMLDOMNode *node_obj;
 683     nsIDOMNode *nsnode;
 684     nsresult nsres;
 685     HRESULT hres;
 686
 687     TRACE("(%p)->(%p %p)\n", This, newChild, node);
 688
 689     node_obj = get_node_obj(newChild);
 690     if(!node_obj)
 691         return E_FAIL;
 692
 693     nsres = nsIDOMNode_AppendChild(This->nsnode, node_obj->nsnode, &nsnode);
 694     node_release(node_obj);
 695     if(NS_FAILED(nsres)) {
 696         ERR("AppendChild failed: %08x\n", nsres);
 697         return E_FAIL;
 698     }
 699
 700     hres = get_node(This->doc, nsnode, TRUE, &node_obj);
 701     nsIDOMNode_Release(nsnode);
 702     if(FAILED(hres))
 703         return hres;
 704
 705     /* FIXME: Make sure that node != newChild */
 706     *node = &node_obj->IHTMLDOMNode_iface;
 707     return S_OK;
 708 }
 709
 710 static HRESULT WINAPI HTMLDOMNode_get_nodeName(IHTMLDOMNode *iface, BSTR *p)
 711 {
 712     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 713     nsAString name;
 714     nsresult nsres;
 715
 716     TRACE("(%p)->(%p)\n", This, p);
 717
 718     nsAString_Init(&name, NULL);
 719     nsres = nsIDOMNode_GetNodeName(This->nsnode, &name);
 720     return return_nsstr(nsres, &name, p);
 721 }
 722
 723 static HRESULT WINAPI HTMLDOMNode_put_nodeValue(IHTMLDOMNode *iface, VARIANT v)
 724 {
 725     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 726
 727     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 728
 729     switch(V_VT(&v)) {
 730     case VT_BSTR: {
 731         nsAString val_str;
 732
 733         nsAString_InitDepend(&val_str, V_BSTR(&v));
 734         nsIDOMNode_SetNodeValue(This->nsnode, &val_str);
 735         nsAString_Finish(&val_str);
 736
 737         return S_OK;
 738     }
 739
 740     default:
 741         FIXME("unsupported value %s\n", debugstr_variant(&v));
 742     }
 743
 744     return E_NOTIMPL;
 745 }
 746
 747 static HRESULT WINAPI HTMLDOMNode_get_nodeValue(IHTMLDOMNode *iface, VARIANT *p)
 748 {
 749     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 750     const PRUnichar *val;
 751     nsAString val_str;
 752
 753     TRACE("(%p)->(%p)\n", This, p);
 754
 755     nsAString_Init(&val_str, NULL);
 756     nsIDOMNode_GetNodeValue(This->nsnode, &val_str);
 757     nsAString_GetData(&val_str, &val);
 758
 759     if(*val) {
 760         V_VT(p) = VT_BSTR;
 761         V_BSTR(p) = SysAllocString(val);
 762     }else {
 763         V_VT(p) = VT_NULL;
 764     }
 765
 766     nsAString_Finish(&val_str);
 767
 768     return S_OK;
 769 }
 770
 771 static HRESULT WINAPI HTMLDOMNode_get_firstChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 772 {
 773     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 774     nsIDOMNode *nschild = NULL;
 775     HTMLDOMNode *node;
 776     HRESULT hres;
 777
 778     TRACE("(%p)->(%p)\n", This, p);
 779
 780     nsIDOMNode_GetFirstChild(This->nsnode, &nschild);
 781     if(!nschild) {
 782         *p = NULL;
 783         return S_OK;
 784     }
 785
 786     hres = get_node(This->doc, nschild, TRUE, &node);
 787     nsIDOMNode_Release(nschild);
 788     if(FAILED(hres))
 789         return hres;
 790
 791     *p = &node->IHTMLDOMNode_iface;
 792     return S_OK;
 793 }
 794
 795 static HRESULT WINAPI HTMLDOMNode_get_lastChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 796 {
 797     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 798     nsIDOMNode *nschild = NULL;
 799     HTMLDOMNode *node;
 800     HRESULT hres;
 801
 802     TRACE("(%p)->(%p)\n", This, p);
 803
 804     nsIDOMNode_GetLastChild(This->nsnode, &nschild);
 805     if(!nschild) {
 806         *p = NULL;
 807         return S_OK;
 808     }
 809
 810     hres = get_node(This->doc, nschild, TRUE, &node);
 811     nsIDOMNode_Release(nschild);
 812     if(FAILED(hres))
 813         return hres;
 814
 815     *p = &node->IHTMLDOMNode_iface;
 816     return S_OK;
 817 }
 818
 819 static HRESULT WINAPI HTMLDOMNode_get_previousSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 820 {
 821     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 822     nsIDOMNode *nschild = NULL;
 823     HTMLDOMNode *node;
 824     HRESULT hres;
 825
 826     TRACE("(%p)->(%p)\n", This, p);
 827
 828     nsIDOMNode_GetPreviousSibling(This->nsnode, &nschild);
 829     if(!nschild) {
 830         *p = NULL;
 831         return S_OK;
 832     }
 833
 834     hres = get_node(This->doc, nschild, TRUE, &node);
 835     nsIDOMNode_Release(nschild);
 836     if(FAILED(hres))
 837         return hres;
 838
 839     *p = &node->IHTMLDOMNode_iface;
 840     return S_OK;
 841 }
 842
 843 static HRESULT WINAPI HTMLDOMNode_get_nextSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 844 {
 845     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
 846     nsIDOMNode *nssibling = NULL;
 847     HTMLDOMNode *node;
 848     HRESULT hres;
 849
 850     TRACE("(%p)->(%p)\n", This, p);
 851
 852     nsIDOMNode_GetNextSibling(This->nsnode, &nssibling);
 853     if(!nssibling) {
 854         *p = NULL;
 855         return S_OK;
 856     }
 857
 858     hres = get_node(This->doc, nssibling, TRUE, &node);
 859     nsIDOMNode_Release(nssibling);
 860     if(FAILED(hres))
 861         return hres;
 862
 863     *p = &node->IHTMLDOMNode_iface;
 864     return S_OK;
 865 }
 866
 867 static const IHTMLDOMNodeVtbl HTMLDOMNodeVtbl = {
 868     HTMLDOMNode_QueryInterface,
 869     HTMLDOMNode_AddRef,
 870     HTMLDOMNode_Release,
 871     HTMLDOMNode_GetTypeInfoCount,
 872     HTMLDOMNode_GetTypeInfo,
 873     HTMLDOMNode_GetIDsOfNames,
 874     HTMLDOMNode_Invoke,
 875     HTMLDOMNode_get_nodeType,
 876     HTMLDOMNode_get_parentNode,
 877     HTMLDOMNode_hasChildNodes,
 878     HTMLDOMNode_get_childNodes,
 879     HTMLDOMNode_get_attributes,
 880     HTMLDOMNode_insertBefore,
 881     HTMLDOMNode_removeChild,
 882     HTMLDOMNode_replaceChild,
 883     HTMLDOMNode_cloneNode,
 884     HTMLDOMNode_removeNode,
 885     HTMLDOMNode_swapNode,
 886     HTMLDOMNode_replaceNode,
 887     HTMLDOMNode_appendChild,
 888     HTMLDOMNode_get_nodeName,
 889     HTMLDOMNode_put_nodeValue,
 890     HTMLDOMNode_get_nodeValue,
 891     HTMLDOMNode_get_firstChild,
 892     HTMLDOMNode_get_lastChild,
 893     HTMLDOMNode_get_previousSibling,
 894     HTMLDOMNode_get_nextSibling
 895 };
 896
 897 static HTMLDOMNode *get_node_obj(IHTMLDOMNode *iface)
 898 {
 899     HTMLDOMNode *ret;
 900
 901     if(iface->lpVtbl != &HTMLDOMNodeVtbl)
 902         return NULL;
 903
 904     ret = impl_from_IHTMLDOMNode(iface);
 905     node_addref(ret);
 906     return ret;
 907 }
 908
 909 static inline HTMLDOMNode *impl_from_IHTMLDOMNode2(IHTMLDOMNode2 *iface)
 910 {
 911     return CONTAINING_RECORD(iface, HTMLDOMNode, IHTMLDOMNode2_iface);
 912 }
 913
 914 static HRESULT WINAPI HTMLDOMNode2_QueryInterface(IHTMLDOMNode2 *iface,
 915         REFIID riid, void **ppv)
 916 {
 917     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
 918
 919     return IHTMLDOMNode_QueryInterface(&This->IHTMLDOMNode_iface, riid, ppv);
 920 }
 921
 922 static ULONG WINAPI HTMLDOMNode2_AddRef(IHTMLDOMNode2 *iface)
 923 {
 924     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
 925
 926     return IHTMLDOMNode_AddRef(&This->IHTMLDOMNode_iface);
 927 }
 928
 929 static ULONG WINAPI HTMLDOMNode2_Release(IHTMLDOMNode2 *iface)
 930 {
 931     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
 932
 933     return IHTMLDOMNode_Release(&This->IHTMLDOMNode_iface);
 934 }
 935
 936 static HRESULT WINAPI HTMLDOMNode2_GetTypeInfoCount(IHTMLDOMNode2 *iface, UINT *pctinfo)
 937 {
 938     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
 939     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 940 }
 941
 942 static HRESULT WINAPI HTMLDOMNode2_GetTypeInfo(IHTMLDOMNode2 *iface, UINT iTInfo,
 943         LCID lcid, ITypeInfo **ppTInfo)
 944 {
 945     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
 946     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 947 }
 948
 949 static HRESULT WINAPI HTMLDOMNode2_GetIDsOfNames(IHTMLDOMNode2 *iface, REFIID riid,
 950                                                 LPOLESTR *rgszNames, UINT cNames,
 951                                                 LCID lcid, DISPID *rgDispId)
 952 {
 953     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
 954     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 955             lcid, rgDispId);
 956 }
 957
 958 static HRESULT WINAPI HTMLDOMNode2_Invoke(IHTMLDOMNode2 *iface, DISPID dispIdMember,
 959         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 960         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 961 {
 962     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
 963     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 964             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 965 }
 966
 967 static HRESULT WINAPI HTMLDOMNode2_get_ownerDocument(IHTMLDOMNode2 *iface, IDispatch **p)
 968 {
 969     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
 970
 971     TRACE("(%p)->(%p)\n", This, p);
 972
 973     /* FIXME: Better check for document node */
 974     if(This == &This->doc->node) {
 975         *p = NULL;
 976     }else {
 977         *p = (IDispatch*)&This->doc->basedoc.IHTMLDocument2_iface;
 978         IDispatch_AddRef(*p);
 979     }
 980     return S_OK;
 981 }
 982
 983 static const IHTMLDOMNode2Vtbl HTMLDOMNode2Vtbl = {
 984     HTMLDOMNode2_QueryInterface,
 985     HTMLDOMNode2_AddRef,
 986     HTMLDOMNode2_Release,
 987     HTMLDOMNode2_GetTypeInfoCount,
 988     HTMLDOMNode2_GetTypeInfo,
 989     HTMLDOMNode2_GetIDsOfNames,
 990     HTMLDOMNode2_Invoke,
 991     HTMLDOMNode2_get_ownerDocument
 992 };
 993
 994 static nsXPCOMCycleCollectionParticipant node_ccp;
 995
 996 HRESULT HTMLDOMNode_QI(HTMLDOMNode *This, REFIID riid, void **ppv)
 997 {
 998     *ppv = NULL;
 999
1000     if(IsEqualGUID(&IID_IUnknown, riid)) {
1001         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1002         *ppv = &This->IHTMLDOMNode_iface;
1003     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1004         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1005         *ppv = &This->IHTMLDOMNode_iface;
1006     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
1007         if(This->dispex.data) {
1008             TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
1009             *ppv = &This->dispex.IDispatchEx_iface;
1010         }else {
1011             FIXME("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
1012             return E_NOINTERFACE;
1013         }
1014     }else if(IsEqualGUID(&IID_IHTMLDOMNode, riid)) {
1015         TRACE("(%p)->(IID_IHTMLDOMNode %p)\n", This, ppv);
1016         *ppv = &This->IHTMLDOMNode_iface;
1017     }else if(IsEqualGUID(&IID_IHTMLDOMNode2, riid)) {
1018         TRACE("(%p)->(IID_IHTMLDOMNode2 %p)\n", This, ppv);
1019         *ppv = &This->IHTMLDOMNode2_iface;
1020     }else if(IsEqualGUID(&IID_nsXPCOMCycleCollectionParticipant, riid)) {
1021         TRACE("(%p)->(IID_nsXPCOMCycleCollectionParticipant %p)\n", This, ppv);
1022         *ppv = &node_ccp;
1023         return NS_OK;
1024     }else if(IsEqualGUID(&IID_nsCycleCollectionISupports, riid)) {
1025         TRACE("(%p)->(IID_nsCycleCollectionISupports %p)\n", This, ppv);
1026         *ppv = &This->IHTMLDOMNode_iface;
1027         return NS_OK;
1028     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1029         return *ppv ? S_OK : E_NOINTERFACE;
1030     }
1031
1032     if(*ppv) {
1033         IUnknown_AddRef((IUnknown*)*ppv);
1034         return S_OK;
1035     }
1036
1037     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1038     return E_NOINTERFACE;
1039 }
1040
1041 void HTMLDOMNode_destructor(HTMLDOMNode *This)
1042 {
1043     if(This->nsnode)
1044         nsIDOMNode_Release(This->nsnode);
1045     if(This->doc && &This->doc->node != This)
1046         htmldoc_release(&This->doc->basedoc);
1047     if(This->event_target)
1048         release_event_target(This->event_target);
1049 }
1050
1051 static HRESULT HTMLDOMNode_clone(HTMLDOMNode *This, nsIDOMNode *nsnode, HTMLDOMNode **ret)
1052 {
1053     return create_node(This->doc, nsnode, ret);
1054 }
1055
1056 static const NodeImplVtbl HTMLDOMNodeImplVtbl = {
1057     HTMLDOMNode_QI,
1058     HTMLDOMNode_destructor,
1059     HTMLDOMNode_clone
1060 };
1061
1062 void HTMLDOMNode_Init(HTMLDocumentNode *doc, HTMLDOMNode *node, nsIDOMNode *nsnode)
1063 {
1064     nsresult nsres;
1065
1066     node->IHTMLDOMNode_iface.lpVtbl = &HTMLDOMNodeVtbl;
1067     node->IHTMLDOMNode2_iface.lpVtbl = &HTMLDOMNode2Vtbl;
1068
1069     ccref_init(&node->ccref, 1);
1070
1071     if(&doc->node != node)
1072         htmldoc_addref(&doc->basedoc);
1073     node->doc = doc;
1074
1075     if(nsnode)
1076         nsIDOMNode_AddRef(nsnode);
1077     node->nsnode = nsnode;
1078
1079     nsres = nsIDOMNode_SetMshtmlNode(nsnode, (nsISupports*)&node->IHTMLDOMNode_iface);
1080     assert(nsres == NS_OK);
1081 }
1082
1083 static HRESULT create_node(HTMLDocumentNode *doc, nsIDOMNode *nsnode, HTMLDOMNode **ret)
1084 {
1085     PRUint16 node_type;
1086     HRESULT hres;
1087
1088     nsIDOMNode_GetNodeType(nsnode, &node_type);
1089
1090     switch(node_type) {
1091     case ELEMENT_NODE: {
1092         HTMLElement *elem;
1093         hres = HTMLElement_Create(doc, nsnode, FALSE, &elem);
1094         if(FAILED(hres))
1095             return hres;
1096         *ret = &elem->node;
1097         break;
1098     }
1099     case TEXT_NODE:
1100         hres = HTMLDOMTextNode_Create(doc, nsnode, ret);
1101         if(FAILED(hres))
1102             return hres;
1103         break;
1104     case COMMENT_NODE: {
1105         HTMLElement *comment;
1106         hres = HTMLCommentElement_Create(doc, nsnode, &comment);
1107         if(FAILED(hres))
1108             return hres;
1109         *ret = &comment->node;
1110         break;
1111     }
1112     case ATTRIBUTE_NODE:
1113         ERR("Called on attribute node\n");
1114         return E_UNEXPECTED;
1115     default: {
1116         HTMLDOMNode *node;
1117
1118         node = heap_alloc_zero(sizeof(HTMLDOMNode));
1119         if(!node)
1120             return E_OUTOFMEMORY;
1121
1122         node->vtbl = &HTMLDOMNodeImplVtbl;
1123         HTMLDOMNode_Init(doc, node, nsnode);
1124         *ret = node;
1125     }
1126     }
1127
1128     TRACE("type %d ret %p\n", node_type, *ret);
1129     return S_OK;
1130 }
1131
1132 static void NSAPI HTMLDOMNode_unmark_if_purple(void *p)
1133 {
1134     HTMLDOMNode *This = impl_from_IHTMLDOMNode(p);
1135     ccref_unmark_if_purple(&This->ccref);
1136 }
1137
1138 static nsresult NSAPI HTMLDOMNode_traverse(void *ccp, void *p, nsCycleCollectionTraversalCallback *cb)
1139 {
1140     HTMLDOMNode *This = impl_from_IHTMLDOMNode(p);
1141
1142     TRACE("%p\n", This);
1143
1144     describe_cc_node(&This->ccref, sizeof(*This), "HTMLDOMNode", cb);
1145
1146     if(This->nsnode)
1147         note_cc_edge((nsISupports*)This->nsnode, "This->nsnode", cb);
1148     if(This->doc && &This->doc->node != This)
1149         note_cc_edge((nsISupports*)&This->doc->node.IHTMLDOMNode_iface, "This->doc", cb);
1150     dispex_traverse(&This->dispex, cb);
1151
1152     if(This->vtbl->traverse)
1153         This->vtbl->traverse(This, cb);
1154
1155     return NS_OK;
1156 }
1157
1158 static nsresult NSAPI HTMLDOMNode_unlink(void *p)
1159 {
1160     HTMLDOMNode *This = impl_from_IHTMLDOMNode(p);
1161
1162     TRACE("%p\n", This);
1163
1164     if(This->vtbl->unlink)
1165         This->vtbl->unlink(This);
1166
1167     dispex_unlink(&This->dispex);
1168
1169     if(This->nsnode) {
1170         nsIDOMNode *nsnode = This->nsnode;
1171         This->nsnode = NULL;
1172         nsIDOMNode_Release(nsnode);
1173     }
1174
1175     if(This->doc && &This->doc->node != This) {
1176         HTMLDocument *doc = &This->doc->basedoc;
1177         This->doc = NULL;
1178         htmldoc_release(doc);
1179     }else {
1180         This->doc = NULL;
1181     }
1182
1183     return NS_OK;
1184 }
1185
1186 void init_node_cc(void)
1187 {
1188     static const CCObjCallback node_ccp_callback = {
1189         HTMLDOMNode_unmark_if_purple,
1190         HTMLDOMNode_traverse,
1191         HTMLDOMNode_unlink
1192     };
1193
1194     ccp_init(&node_ccp, &node_ccp_callback);
1195 }
1196
1197 HRESULT get_node(HTMLDocumentNode *This, nsIDOMNode *nsnode, BOOL create, HTMLDOMNode **ret)
1198 {
1199     nsISupports *unk = NULL;
1200     nsresult nsres;
1201
1202     nsres = nsIDOMNode_GetMshtmlNode(nsnode, &unk);
1203     assert(nsres == NS_OK);
1204
1205     if(unk) {
1206         *ret = get_node_obj((IHTMLDOMNode*)unk);
1207         return NS_OK;
1208     }
1209
1210     if(!create) {
1211         *ret = NULL;
1212         return S_OK;
1213     }
1214
1215     return create_node(This, nsnode, ret);
1216 }