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(HTMLDocument*,IUnknown*);
  36
  37 typedef struct {
  38     DispatchEx dispex;
  39     const IHTMLDOMChildrenCollectionVtbl  *lpIHTMLDOMChildrenCollectionVtbl;
  40
  41     LONG ref;
  42
  43     /* FIXME: implement weak reference */
  44     HTMLDocument *doc;
  45
  46     nsIDOMNodeList *nslist;
  47 } HTMLDOMChildrenCollection;
  48
  49 #define HTMLCHILDCOL(x)  ((IHTMLDOMChildrenCollection*)  &(x)->lpIHTMLDOMChildrenCollectionVtbl)
  50
  51 #define HTMLCHILDCOL_THIS(iface) DEFINE_THIS(HTMLDOMChildrenCollection, IHTMLDOMChildrenCollection, iface)
  52
  53 static HRESULT WINAPI HTMLDOMChildrenCollection_QueryInterface(IHTMLDOMChildrenCollection *iface, REFIID riid, void **ppv)
  54 {
  55     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
  56
  57     *ppv = NULL;
  58
  59     if(IsEqualGUID(&IID_IUnknown, riid)) {
  60         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  61         *ppv = HTMLCHILDCOL(This);
  62     }else if(IsEqualGUID(&IID_IHTMLDOMChildrenCollection, riid)) {
  63         TRACE("(%p)->(IID_IHTMLDOMChildrenCollection %p)\n", This, ppv);
  64         *ppv = HTMLCHILDCOL(This);
  65     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
  66         return *ppv ? S_OK : E_NOINTERFACE;
  67     }
  68
  69     if(*ppv) {
  70         IUnknown_AddRef((IUnknown*)*ppv);
  71         return S_OK;
  72     }
  73
  74     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
  75     return E_NOINTERFACE;
  76 }
  77
  78 static ULONG WINAPI HTMLDOMChildrenCollection_AddRef(IHTMLDOMChildrenCollection *iface)
  79 {
  80     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
  81     LONG ref = InterlockedIncrement(&This->ref);
  82
  83     TRACE("(%p) ref=%d\n", This, ref);
  84
  85     return ref;
  86 }
  87
  88 static ULONG WINAPI HTMLDOMChildrenCollection_Release(IHTMLDOMChildrenCollection *iface)
  89 {
  90     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
  91     LONG ref = InterlockedDecrement(&This->ref);
  92
  93     TRACE("(%p) ref=%d\n", This, ref);
  94
  95     if(!ref) {
  96         nsIDOMNodeList_Release(This->nslist);
  97         heap_free(This);
  98     }
  99
 100     return ref;
 101 }
 102
 103 static HRESULT WINAPI HTMLDOMChildrenCollection_GetTypeInfoCount(IHTMLDOMChildrenCollection *iface, UINT *pctinfo)
 104 {
 105     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
 106     return IDispatchEx_GetTypeInfoCount(DISPATCHEX(&This->dispex), pctinfo);
 107 }
 108
 109 static HRESULT WINAPI HTMLDOMChildrenCollection_GetTypeInfo(IHTMLDOMChildrenCollection *iface, UINT iTInfo,
 110         LCID lcid, ITypeInfo **ppTInfo)
 111 {
 112     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
 113     return IDispatchEx_GetTypeInfo(DISPATCHEX(&This->dispex), iTInfo, lcid, ppTInfo);
 114 }
 115
 116 static HRESULT WINAPI HTMLDOMChildrenCollection_GetIDsOfNames(IHTMLDOMChildrenCollection *iface, REFIID riid,
 117         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 118 {
 119     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
 120     return IDispatchEx_GetIDsOfNames(DISPATCHEX(&This->dispex), riid, rgszNames, cNames, lcid, rgDispId);
 121 }
 122
 123 static HRESULT WINAPI HTMLDOMChildrenCollection_Invoke(IHTMLDOMChildrenCollection *iface, DISPID dispIdMember,
 124         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 125         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 126 {
 127     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
 128     return IDispatchEx_Invoke(DISPATCHEX(&This->dispex), dispIdMember, riid, lcid,
 129             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 130 }
 131
 132 static HRESULT WINAPI HTMLDOMChildrenCollection_get_length(IHTMLDOMChildrenCollection *iface, LONG *p)
 133 {
 134     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
 135     PRUint32 length=0;
 136
 137     TRACE("(%p)->(%p)\n", This, p);
 138
 139     nsIDOMNodeList_GetLength(This->nslist, &length);
 140     *p = length;
 141     return S_OK;
 142 }
 143
 144 static HRESULT WINAPI HTMLDOMChildrenCollection__newEnum(IHTMLDOMChildrenCollection *iface, IUnknown **p)
 145 {
 146     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
 147     FIXME("(%p)->(%p)\n", This, p);
 148     return E_NOTIMPL;
 149 }
 150
 151 static HRESULT WINAPI HTMLDOMChildrenCollection_item(IHTMLDOMChildrenCollection *iface, LONG index, IDispatch **ppItem)
 152 {
 153     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
 154     nsIDOMNode *nsnode = NULL;
 155     PRUint32 length=0;
 156     nsresult nsres;
 157
 158     TRACE("(%p)->(%d %p)\n", This, index, ppItem);
 159
 160     nsIDOMNodeList_GetLength(This->nslist, &length);
 161     if(index < 0 || index >= length)
 162         return E_INVALIDARG;
 163
 164     nsres = nsIDOMNodeList_Item(This->nslist, index, &nsnode);
 165     if(NS_FAILED(nsres) || !nsnode) {
 166         ERR("Item failed: %08x\n", nsres);
 167         return E_FAIL;
 168     }
 169
 170     *ppItem = (IDispatch*)get_node(This->doc, nsnode, TRUE);
 171     IDispatch_AddRef(*ppItem);
 172     return S_OK;
 173 }
 174
 175 #define DISPID_CHILDCOL_0 MSHTML_DISPID_CUSTOM_MIN
 176
 177 static HRESULT HTMLDOMChildrenCollection_get_dispid(IUnknown *iface, BSTR name, DWORD flags, DISPID *dispid)
 178 {
 179     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
 180     WCHAR *ptr;
 181     DWORD idx=0;
 182     PRUint32 len = 0;
 183
 184     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
 185         idx = idx*10 + (*ptr-'0');
 186     if(*ptr)
 187         return DISP_E_UNKNOWNNAME;
 188
 189     nsIDOMNodeList_GetLength(This->nslist, &len);
 190     if(idx >= len)
 191         return DISP_E_UNKNOWNNAME;
 192
 193     *dispid = DISPID_CHILDCOL_0 + idx;
 194     TRACE("ret %x\n", *dispid);
 195     return S_OK;
 196 }
 197
 198 static HRESULT HTMLDOMChildrenCollection_invoke(IUnknown *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 199         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 200 {
 201     HTMLDOMChildrenCollection *This = HTMLCHILDCOL_THIS(iface);
 202
 203     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
 204
 205     switch(flags) {
 206     case INVOKE_PROPERTYGET: {
 207         IDispatch *disp = NULL;
 208         HRESULT hres;
 209
 210         hres = IHTMLDOMChildrenCollection_item(HTMLCHILDCOL(This), id - DISPID_CHILDCOL_0, &disp);
 211         if(0&&FAILED(hres))
 212             return hres;
 213
 214         V_VT(res) = VT_DISPATCH;
 215         V_DISPATCH(res) = disp;
 216         break;
 217     }
 218
 219     default:
 220         FIXME("unimplemented flags %x\n", flags);
 221         return E_NOTIMPL;
 222     }
 223
 224     return S_OK;
 225 }
 226
 227 #undef HTMLCHILDCOL_THIS
 228
 229 static const IHTMLDOMChildrenCollectionVtbl HTMLDOMChildrenCollectionVtbl = {
 230     HTMLDOMChildrenCollection_QueryInterface,
 231     HTMLDOMChildrenCollection_AddRef,
 232     HTMLDOMChildrenCollection_Release,
 233     HTMLDOMChildrenCollection_GetTypeInfoCount,
 234     HTMLDOMChildrenCollection_GetTypeInfo,
 235     HTMLDOMChildrenCollection_GetIDsOfNames,
 236     HTMLDOMChildrenCollection_Invoke,
 237     HTMLDOMChildrenCollection_get_length,
 238     HTMLDOMChildrenCollection__newEnum,
 239     HTMLDOMChildrenCollection_item
 240 };
 241
 242 static const tid_t HTMLDOMChildrenCollection_iface_tids[] = {
 243     IHTMLDOMChildrenCollection_tid,
 244     0
 245 };
 246
 247 static const dispex_static_data_vtbl_t HTMLDOMChildrenCollection_dispex_vtbl = {
 248     HTMLDOMChildrenCollection_get_dispid,
 249     HTMLDOMChildrenCollection_invoke
 250 };
 251
 252 static dispex_static_data_t HTMLDOMChildrenCollection_dispex = {
 253     &HTMLDOMChildrenCollection_dispex_vtbl,
 254     DispDOMChildrenCollection_tid,
 255     NULL,
 256     HTMLDOMChildrenCollection_iface_tids
 257 };
 258
 259 static IHTMLDOMChildrenCollection *create_child_collection(HTMLDocument *doc, nsIDOMNodeList *nslist)
 260 {
 261     HTMLDOMChildrenCollection *ret;
 262
 263     ret = heap_alloc_zero(sizeof(*ret));
 264     ret->lpIHTMLDOMChildrenCollectionVtbl = &HTMLDOMChildrenCollectionVtbl;
 265     ret->ref = 1;
 266
 267     nsIDOMNodeList_AddRef(nslist);
 268     ret->nslist = nslist;
 269     ret->doc = doc;
 270
 271     init_dispex(&ret->dispex, (IUnknown*)HTMLCHILDCOL(ret), &HTMLDOMChildrenCollection_dispex);
 272
 273     return HTMLCHILDCOL(ret);
 274 }
 275
 276 #define HTMLDOMNODE_THIS(iface) DEFINE_THIS(HTMLDOMNode, HTMLDOMNode, iface)
 277
 278 static HRESULT WINAPI HTMLDOMNode_QueryInterface(IHTMLDOMNode *iface,
 279                                                  REFIID riid, void **ppv)
 280 {
 281     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 282
 283     return This->vtbl->qi(This, riid, ppv);
 284 }
 285
 286 static ULONG WINAPI HTMLDOMNode_AddRef(IHTMLDOMNode *iface)
 287 {
 288     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 289     LONG ref = InterlockedIncrement(&This->ref);
 290
 291     TRACE("(%p) ref=%d\n", This, ref);
 292
 293     return ref;
 294 }
 295
 296 static ULONG WINAPI HTMLDOMNode_Release(IHTMLDOMNode *iface)
 297 {
 298     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 299     LONG ref = InterlockedDecrement(&This->ref);
 300
 301     TRACE("(%p) ref=%d\n", This, ref);
 302
 303     if(!ref) {
 304         This->vtbl->destructor(This);
 305         heap_free(This);
 306     }
 307
 308     return ref;
 309 }
 310
 311 static HRESULT WINAPI HTMLDOMNode_GetTypeInfoCount(IHTMLDOMNode *iface, UINT *pctinfo)
 312 {
 313     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 314     return IDispatchEx_GetTypeInfoCount(DISPATCHEX(&This->dispex), pctinfo);
 315 }
 316
 317 static HRESULT WINAPI HTMLDOMNode_GetTypeInfo(IHTMLDOMNode *iface, UINT iTInfo,
 318                                               LCID lcid, ITypeInfo **ppTInfo)
 319 {
 320     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 321     return IDispatchEx_GetTypeInfo(DISPATCHEX(&This->dispex), iTInfo, lcid, ppTInfo);
 322 }
 323
 324 static HRESULT WINAPI HTMLDOMNode_GetIDsOfNames(IHTMLDOMNode *iface, REFIID riid,
 325                                                 LPOLESTR *rgszNames, UINT cNames,
 326                                                 LCID lcid, DISPID *rgDispId)
 327 {
 328     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 329     return IDispatchEx_GetIDsOfNames(DISPATCHEX(&This->dispex), riid, rgszNames, cNames, lcid, rgDispId);
 330 }
 331
 332 static HRESULT WINAPI HTMLDOMNode_Invoke(IHTMLDOMNode *iface, DISPID dispIdMember,
 333                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 334                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 335 {
 336     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 337     return IDispatchEx_Invoke(DISPATCHEX(&This->dispex), dispIdMember, riid, lcid,
 338             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 339 }
 340
 341 static HRESULT WINAPI HTMLDOMNode_get_nodeType(IHTMLDOMNode *iface, LONG *p)
 342 {
 343     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 344     PRUint16 type = -1;
 345
 346     TRACE("(%p)->(%p)\n", This, p);
 347
 348     nsIDOMNode_GetNodeType(This->nsnode, &type);
 349
 350     switch(type) {
 351     case ELEMENT_NODE:
 352         *p = 1;
 353         break;
 354     case TEXT_NODE:
 355         *p = 3;
 356         break;
 357     case COMMENT_NODE:
 358         *p = 8;
 359         break;
 360     case DOCUMENT_NODE:
 361         *p = 9;
 362         break;
 363     default:
 364         /*
 365          * FIXME:
 366          * According to MSDN only ELEMENT_NODE and TEXT_NODE are supported.
 367          * It needs more tests.
 368          */
 369         FIXME("type %u\n", type);
 370         *p = 0;
 371     }
 372
 373     return S_OK;
 374 }
 375
 376 static HRESULT WINAPI HTMLDOMNode_get_parentNode(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 377 {
 378     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 379     HTMLDOMNode *node;
 380     nsIDOMNode *nsnode;
 381     nsresult nsres;
 382
 383     TRACE("(%p)->(%p)\n", This, p);
 384
 385     nsres = nsIDOMNode_GetParentNode(This->nsnode, &nsnode);
 386     if(NS_FAILED(nsres)) {
 387         ERR("GetParentNode failed: %08x\n", nsres);
 388         return E_FAIL;
 389     }
 390
 391     if(!nsnode) {
 392         *p = NULL;
 393         return S_OK;
 394     }
 395
 396     node = get_node(This->doc, nsnode, TRUE);
 397     *p = HTMLDOMNODE(node);
 398     IHTMLDOMNode_AddRef(*p);
 399     return S_OK;
 400 }
 401
 402 static HRESULT WINAPI HTMLDOMNode_hasChildNodes(IHTMLDOMNode *iface, VARIANT_BOOL *fChildren)
 403 {
 404     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 405     PRBool has_child = FALSE;
 406     nsresult nsres;
 407
 408     TRACE("(%p)->(%p)\n", This, fChildren);
 409
 410     nsres = nsIDOMNode_HasChildNodes(This->nsnode, &has_child);
 411     if(NS_FAILED(nsres))
 412         ERR("HasChildNodes failed: %08x\n", nsres);
 413
 414     *fChildren = has_child ? VARIANT_TRUE : VARIANT_FALSE;
 415     return S_OK;
 416 }
 417
 418 static HRESULT WINAPI HTMLDOMNode_get_childNodes(IHTMLDOMNode *iface, IDispatch **p)
 419 {
 420     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 421     nsIDOMNodeList *nslist;
 422     nsresult nsres;
 423
 424     TRACE("(%p)->(%p)\n", This, p);
 425
 426     nsres = nsIDOMNode_GetChildNodes(This->nsnode, &nslist);
 427     if(NS_FAILED(nsres)) {
 428         ERR("GetChildNodes failed: %08x\n", nsres);
 429         return E_FAIL;
 430     }
 431
 432     *p = (IDispatch*)create_child_collection(This->doc, nslist);
 433     nsIDOMNodeList_Release(nslist);
 434
 435     return S_OK;
 436 }
 437
 438 static HRESULT WINAPI HTMLDOMNode_get_attributes(IHTMLDOMNode *iface, IDispatch **p)
 439 {
 440     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 441     FIXME("(%p)->(%p)\n", This, p);
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI HTMLDOMNode_insertBefore(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 446                                                VARIANT refChild, IHTMLDOMNode **node)
 447 {
 448     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 449     nsIDOMNode *nsnode, *nsref = NULL;
 450     HTMLDOMNode *new_child;
 451     nsresult nsres;
 452
 453     TRACE("(%p)->(%p %s %p)\n", This, newChild, debugstr_variant(&refChild), node);
 454
 455     new_child = get_node_obj(This->doc, (IUnknown*)newChild);
 456     if(!new_child) {
 457         ERR("invalid newChild\n");
 458         return E_INVALIDARG;
 459     }
 460
 461     switch(V_VT(&refChild)) {
 462     case VT_NULL:
 463         break;
 464     case VT_DISPATCH: {
 465         HTMLDOMNode *ref_node;
 466
 467         ref_node = get_node_obj(This->doc, (IUnknown*)V_DISPATCH(&refChild));
 468         if(!ref_node) {
 469             ERR("unvalid node\n");
 470             return E_FAIL;
 471         }
 472
 473         nsref = ref_node->nsnode;
 474         break;
 475     }
 476     default:
 477         FIXME("unimplemented vt %d\n", V_VT(&refChild));
 478         return E_NOTIMPL;
 479     }
 480
 481     nsres = nsIDOMNode_InsertBefore(This->nsnode, new_child->nsnode, nsref, &nsnode);
 482     if(NS_FAILED(nsres)) {
 483         ERR("InsertBefore failed: %08x\n", nsres);
 484         return E_FAIL;
 485     }
 486
 487     *node = HTMLDOMNODE(get_node(This->doc, nsnode, TRUE));
 488     nsIDOMNode_Release(nsnode);
 489     IHTMLDOMNode_AddRef(*node);
 490     return S_OK;
 491 }
 492
 493 static HRESULT WINAPI HTMLDOMNode_removeChild(IHTMLDOMNode *iface, IHTMLDOMNode *oldChild,
 494                                               IHTMLDOMNode **node)
 495 {
 496     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 497     HTMLDOMNode *node_obj;
 498     nsIDOMNode *nsnode;
 499     nsresult nsres;
 500
 501     TRACE("(%p)->(%p %p)\n", This, oldChild, node);
 502
 503     node_obj = get_node_obj(This->doc, (IUnknown*)oldChild);
 504     if(!node_obj)
 505         return E_FAIL;
 506
 507     nsres = nsIDOMNode_RemoveChild(This->nsnode, node_obj->nsnode, &nsnode);
 508     if(NS_FAILED(nsres)) {
 509         ERR("RemoveChild failed: %08x\n", nsres);
 510         return E_FAIL;
 511     }
 512
 513     /* FIXME: Make sure that node != newChild */
 514     *node = HTMLDOMNODE(get_node(This->doc, nsnode, TRUE));
 515     nsIDOMNode_Release(nsnode);
 516     IHTMLDOMNode_AddRef(*node);
 517     return S_OK;
 518 }
 519
 520 static HRESULT WINAPI HTMLDOMNode_replaceChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 521                                                IHTMLDOMNode *oldChild, IHTMLDOMNode **node)
 522 {
 523     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 524     FIXME("(%p)->(%p %p %p)\n", This, newChild, oldChild, node);
 525     return E_NOTIMPL;
 526 }
 527
 528 static HRESULT WINAPI HTMLDOMNode_cloneNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
 529                                             IHTMLDOMNode **clonedNode)
 530 {
 531     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 532     FIXME("(%p)->(%x %p)\n", This, fDeep, clonedNode);
 533     return E_NOTIMPL;
 534 }
 535
 536 static HRESULT WINAPI HTMLDOMNode_removeNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
 537                                              IHTMLDOMNode **removed)
 538 {
 539     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 540     FIXME("(%p)->(%x %p)\n", This, fDeep, removed);
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI HTMLDOMNode_swapNode(IHTMLDOMNode *iface, IHTMLDOMNode *otherNode,
 545                                            IHTMLDOMNode **swappedNode)
 546 {
 547     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 548     FIXME("(%p)->(%p %p)\n", This, otherNode, swappedNode);
 549     return E_NOTIMPL;
 550 }
 551
 552 static HRESULT WINAPI HTMLDOMNode_replaceNode(IHTMLDOMNode *iface, IHTMLDOMNode *replacement,
 553                                               IHTMLDOMNode **replaced)
 554 {
 555     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 556     FIXME("(%p)->(%p %p)\n", This, replacement, replaced);
 557     return E_NOTIMPL;
 558 }
 559
 560 static HRESULT WINAPI HTMLDOMNode_appendChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
 561                                               IHTMLDOMNode **node)
 562 {
 563     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 564     HTMLDOMNode *node_obj;
 565     nsIDOMNode *nsnode;
 566     nsresult nsres;
 567
 568     TRACE("(%p)->(%p %p)\n", This, newChild, node);
 569
 570     node_obj = get_node_obj(This->doc, (IUnknown*)newChild);
 571     if(!node_obj)
 572         return E_FAIL;
 573
 574     nsres = nsIDOMNode_AppendChild(This->nsnode, node_obj->nsnode, &nsnode);
 575     if(NS_FAILED(nsres)) {
 576         WARN("AppendChild failed: %08x\n", nsres);
 577         nsnode = node_obj->nsnode;
 578     }
 579
 580     /* FIXME: Make sure that node != newChild */
 581     *node = HTMLDOMNODE(get_node(This->doc, nsnode, TRUE));
 582     IHTMLDOMNode_AddRef(*node);
 583     return S_OK;
 584 }
 585
 586 static HRESULT WINAPI HTMLDOMNode_get_nodeName(IHTMLDOMNode *iface, BSTR *p)
 587 {
 588     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 589
 590     TRACE("(%p)->(%p)\n", This, p);
 591
 592     *p = NULL;
 593
 594     if(This->nsnode) {
 595         nsAString name_str;
 596         const PRUnichar *name;
 597         nsresult nsres;
 598
 599         nsAString_Init(&name_str, NULL);
 600         nsres = nsIDOMNode_GetNodeName(This->nsnode, &name_str);
 601
 602         if(NS_SUCCEEDED(nsres)) {
 603             nsAString_GetData(&name_str, &name);
 604             *p = SysAllocString(name);
 605         }else {
 606             ERR("GetNodeName failed: %08x\n", nsres);
 607         }
 608
 609         nsAString_Finish(&name_str);
 610     }
 611
 612     return S_OK;
 613 }
 614
 615 static HRESULT WINAPI HTMLDOMNode_put_nodeValue(IHTMLDOMNode *iface, VARIANT v)
 616 {
 617     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 618
 619     TRACE("(%p)->()\n", This);
 620
 621     switch(V_VT(&v)) {
 622     case VT_BSTR: {
 623         nsAString val_str;
 624
 625         TRACE("bstr %s\n", debugstr_w(V_BSTR(&v)));
 626
 627         nsAString_Init(&val_str, V_BSTR(&v));
 628         nsIDOMNode_SetNodeValue(This->nsnode, &val_str);
 629         nsAString_Finish(&val_str);
 630
 631         return S_OK;
 632     }
 633
 634     default:
 635         FIXME("unsupported vt %d\n", V_VT(&v));
 636     }
 637
 638     return E_NOTIMPL;
 639 }
 640
 641 static HRESULT WINAPI HTMLDOMNode_get_nodeValue(IHTMLDOMNode *iface, VARIANT *p)
 642 {
 643     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 644     const PRUnichar *val;
 645     nsAString val_str;
 646
 647     TRACE("(%p)->(%p)\n", This, p);
 648
 649     nsAString_Init(&val_str, NULL);
 650     nsIDOMNode_GetNodeValue(This->nsnode, &val_str);
 651     nsAString_GetData(&val_str, &val);
 652
 653     if(*val) {
 654         V_VT(p) = VT_BSTR;
 655         V_BSTR(p) = SysAllocString(val);
 656     }else {
 657         V_VT(p) = VT_NULL;
 658     }
 659
 660     nsAString_Finish(&val_str);
 661
 662     return S_OK;
 663 }
 664
 665 static HRESULT WINAPI HTMLDOMNode_get_firstChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 666 {
 667     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 668     nsIDOMNode *nschild = NULL;
 669
 670     TRACE("(%p)->(%p)\n", This, p);
 671
 672     nsIDOMNode_GetFirstChild(This->nsnode, &nschild);
 673     if(nschild) {
 674         *p = HTMLDOMNODE(get_node(This->doc, nschild, TRUE));
 675         IHTMLDOMNode_AddRef(*p);
 676     }else {
 677         *p = NULL;
 678     }
 679
 680     return S_OK;
 681 }
 682
 683 static HRESULT WINAPI HTMLDOMNode_get_lastChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 684 {
 685     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 686     nsIDOMNode *nschild = NULL;
 687
 688     TRACE("(%p)->(%p)\n", This, p);
 689
 690     nsIDOMNode_GetLastChild(This->nsnode, &nschild);
 691     if(nschild) {
 692         *p = HTMLDOMNODE(get_node(This->doc, nschild, TRUE));
 693         IHTMLDOMNode_AddRef(*p);
 694     }else {
 695         *p = NULL;
 696     }
 697
 698     return S_OK;
 699 }
 700
 701 static HRESULT WINAPI HTMLDOMNode_get_previousSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 702 {
 703     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 704     FIXME("(%p)->(%p)\n", This, p);
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI HTMLDOMNode_get_nextSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
 709 {
 710     HTMLDOMNode *This = HTMLDOMNODE_THIS(iface);
 711     FIXME("(%p)->(%p)\n", This, p);
 712     return E_NOTIMPL;
 713 }
 714
 715 #undef HTMLDOMNODE_THIS
 716
 717 static const IHTMLDOMNodeVtbl HTMLDOMNodeVtbl = {
 718     HTMLDOMNode_QueryInterface,
 719     HTMLDOMNode_AddRef,
 720     HTMLDOMNode_Release,
 721     HTMLDOMNode_GetTypeInfoCount,
 722     HTMLDOMNode_GetTypeInfo,
 723     HTMLDOMNode_GetIDsOfNames,
 724     HTMLDOMNode_Invoke,
 725     HTMLDOMNode_get_nodeType,
 726     HTMLDOMNode_get_parentNode,
 727     HTMLDOMNode_hasChildNodes,
 728     HTMLDOMNode_get_childNodes,
 729     HTMLDOMNode_get_attributes,
 730     HTMLDOMNode_insertBefore,
 731     HTMLDOMNode_removeChild,
 732     HTMLDOMNode_replaceChild,
 733     HTMLDOMNode_cloneNode,
 734     HTMLDOMNode_removeNode,
 735     HTMLDOMNode_swapNode,
 736     HTMLDOMNode_replaceNode,
 737     HTMLDOMNode_appendChild,
 738     HTMLDOMNode_get_nodeName,
 739     HTMLDOMNode_put_nodeValue,
 740     HTMLDOMNode_get_nodeValue,
 741     HTMLDOMNode_get_firstChild,
 742     HTMLDOMNode_get_lastChild,
 743     HTMLDOMNode_get_previousSibling,
 744     HTMLDOMNode_get_nextSibling
 745 };
 746
 747 #define HTMLDOMNODE2_THIS(iface) DEFINE_THIS(HTMLDOMNode, HTMLDOMNode2, iface)
 748
 749 static HRESULT WINAPI HTMLDOMNode2_QueryInterface(IHTMLDOMNode2 *iface,
 750         REFIID riid, void **ppv)
 751 {
 752     HTMLDOMNode *This = HTMLDOMNODE2_THIS(iface);
 753
 754     return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(This), riid, ppv);
 755 }
 756
 757 static ULONG WINAPI HTMLDOMNode2_AddRef(IHTMLDOMNode2 *iface)
 758 {
 759     HTMLDOMNode *This = HTMLDOMNODE2_THIS(iface);
 760
 761     return IHTMLDOMNode_AddRef(HTMLDOMNODE(This));
 762 }
 763
 764 static ULONG WINAPI HTMLDOMNode2_Release(IHTMLDOMNode2 *iface)
 765 {
 766     HTMLDOMNode *This = HTMLDOMNODE2_THIS(iface);
 767
 768     return IHTMLDOMNode_Release(HTMLDOMNODE(This));
 769 }
 770
 771 static HRESULT WINAPI HTMLDOMNode2_GetTypeInfoCount(IHTMLDOMNode2 *iface, UINT *pctinfo)
 772 {
 773     HTMLDOMNode *This = HTMLDOMNODE2_THIS(iface);
 774     return IDispatchEx_GetTypeInfoCount(DISPATCHEX(&This->dispex), pctinfo);
 775 }
 776
 777 static HRESULT WINAPI HTMLDOMNode2_GetTypeInfo(IHTMLDOMNode2 *iface, UINT iTInfo,
 778         LCID lcid, ITypeInfo **ppTInfo)
 779 {
 780     HTMLDOMNode *This = HTMLDOMNODE2_THIS(iface);
 781     return IDispatchEx_GetTypeInfo(DISPATCHEX(&This->dispex), iTInfo, lcid, ppTInfo);
 782 }
 783
 784 static HRESULT WINAPI HTMLDOMNode2_GetIDsOfNames(IHTMLDOMNode2 *iface, REFIID riid,
 785                                                 LPOLESTR *rgszNames, UINT cNames,
 786                                                 LCID lcid, DISPID *rgDispId)
 787 {
 788     HTMLDOMNode *This = HTMLDOMNODE2_THIS(iface);
 789     return IDispatchEx_GetIDsOfNames(DISPATCHEX(&This->dispex), riid, rgszNames, cNames, lcid, rgDispId);
 790 }
 791
 792 static HRESULT WINAPI HTMLDOMNode2_Invoke(IHTMLDOMNode2 *iface, DISPID dispIdMember,
 793         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 794         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 795 {
 796     HTMLDOMNode *This = HTMLDOMNODE2_THIS(iface);
 797     return IDispatchEx_Invoke(DISPATCHEX(&This->dispex), dispIdMember, riid, lcid,
 798             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 799 }
 800
 801 static HRESULT WINAPI HTMLDOMNode2_get_ownerDocument(IHTMLDOMNode2 *iface, IDispatch **p)
 802 {
 803     HTMLDOMNode *This = HTMLDOMNODE2_THIS(iface);
 804     FIXME("(%p)->(%p)\n", This, p);
 805     return E_NOTIMPL;
 806 }
 807
 808 #undef HTMLDOMNODE2_THIS
 809
 810 static const IHTMLDOMNode2Vtbl HTMLDOMNode2Vtbl = {
 811     HTMLDOMNode2_QueryInterface,
 812     HTMLDOMNode2_AddRef,
 813     HTMLDOMNode2_Release,
 814     HTMLDOMNode2_GetTypeInfoCount,
 815     HTMLDOMNode2_GetTypeInfo,
 816     HTMLDOMNode2_GetIDsOfNames,
 817     HTMLDOMNode2_Invoke,
 818     HTMLDOMNode2_get_ownerDocument
 819 };
 820
 821 HRESULT HTMLDOMNode_QI(HTMLDOMNode *This, REFIID riid, void **ppv)
 822 {
 823     *ppv = NULL;
 824
 825     if(IsEqualGUID(&IID_IUnknown, riid)) {
 826         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 827         *ppv = HTMLDOMNODE(This);
 828     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 829         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 830         *ppv = HTMLDOMNODE(This);
 831     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 832         if(This->dispex.data) {
 833             TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 834             *ppv = DISPATCHEX(&This->dispex);
 835         }else {
 836             FIXME("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 837             return E_NOINTERFACE;
 838         }
 839     }else if(IsEqualGUID(&IID_IHTMLDOMNode, riid)) {
 840         TRACE("(%p)->(IID_IHTMLDOMNode %p)\n", This, ppv);
 841         *ppv = HTMLDOMNODE(This);
 842     }else if(IsEqualGUID(&IID_IHTMLDOMNode2, riid)) {
 843         TRACE("(%p)->(IID_IHTMLDOMNode2 %p)\n", This, ppv);
 844         *ppv = HTMLDOMNODE2(This);
 845     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 846         return *ppv ? S_OK : E_NOINTERFACE;
 847     }
 848
 849     if(*ppv) {
 850         IUnknown_AddRef((IUnknown*)*ppv);
 851         return S_OK;
 852     }
 853
 854     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 855     return E_NOINTERFACE;
 856 }
 857
 858 void HTMLDOMNode_destructor(HTMLDOMNode *This)
 859 {
 860     if(This->nsnode)
 861         nsIDOMNode_Release(This->nsnode);
 862     if(This->event_target)
 863         release_event_target(This->event_target);
 864 }
 865
 866 static const NodeImplVtbl HTMLDOMNodeImplVtbl = {
 867     HTMLDOMNode_QI,
 868     HTMLDOMNode_destructor
 869 };
 870
 871 void HTMLDOMNode_Init(HTMLDocument *doc, HTMLDOMNode *node, nsIDOMNode *nsnode)
 872 {
 873     node->lpHTMLDOMNodeVtbl = &HTMLDOMNodeVtbl;
 874     node->lpHTMLDOMNode2Vtbl = &HTMLDOMNode2Vtbl;
 875     node->ref = 1;
 876     node->doc = doc;
 877
 878     nsIDOMNode_AddRef(nsnode);
 879     node->nsnode = nsnode;
 880
 881     node->next = doc->nodes;
 882     doc->nodes = node;
 883 }
 884
 885 static HTMLDOMNode *create_node(HTMLDocument *doc, nsIDOMNode *nsnode)
 886 {
 887     HTMLDOMNode *ret;
 888     PRUint16 node_type;
 889
 890     nsIDOMNode_GetNodeType(nsnode, &node_type);
 891
 892     switch(node_type) {
 893     case ELEMENT_NODE:
 894         ret = &HTMLElement_Create(doc, nsnode, FALSE)->node;
 895         break;
 896     case TEXT_NODE:
 897         ret = HTMLDOMTextNode_Create(doc, nsnode);
 898         break;
 899     case COMMENT_NODE:
 900         ret = &HTMLCommentElement_Create(doc, nsnode)->node;
 901         break;
 902     default:
 903         ret = heap_alloc_zero(sizeof(HTMLDOMNode));
 904         ret->vtbl = &HTMLDOMNodeImplVtbl;
 905         HTMLDOMNode_Init(doc, ret, nsnode);
 906     }
 907
 908     TRACE("type %d ret %p\n", node_type, ret);
 909
 910     return ret;
 911 }
 912
 913 /*
 914  * FIXME
 915  * List looks really ugly here. We should use a better data structure or
 916  * (better) find a way to store HTMLDOMelement pointer in nsIDOMNode.
 917  */
 918
 919 HTMLDOMNode *get_node(HTMLDocument *This, nsIDOMNode *nsnode, BOOL create)
 920 {
 921     HTMLDOMNode *iter = This->nodes;
 922
 923     while(iter) {
 924         if(iter->nsnode == nsnode)
 925             break;
 926         iter = iter->next;
 927     }
 928
 929     if(iter || !create)
 930         return iter;
 931
 932     return create_node(This, nsnode);
 933 }
 934
 935 /*
 936  * FIXME
 937  * We should use better way for getting node object (like private interface)
 938  * or avoid it at all.
 939  */
 940 static HTMLDOMNode *get_node_obj(HTMLDocument *This, IUnknown *iface)
 941 {
 942     HTMLDOMNode *iter = This->nodes;
 943     IHTMLDOMNode *node;
 944
 945     IUnknown_QueryInterface(iface, &IID_IHTMLDOMNode, (void**)&node);
 946     IHTMLDOMNode_Release(node);
 947
 948     while(iter) {
 949         if(HTMLDOMNODE(iter) == node)
 950             return iter;
 951         iter = iter->next;
 952     }
 953
 954     FIXME("Not found %p\n", iface);
 955     return NULL;
 956 }
 957
 958 void release_nodes(HTMLDocument *This)
 959 {
 960     HTMLDOMNode *iter, *next;
 961
 962     if(!This->nodes)
 963         return;
 964
 965     for(iter = This->nodes; iter; iter = next) {
 966         next = iter->next;
 967         iter->doc = NULL;
 968         IHTMLDOMNode_Release(HTMLDOMNODE(iter));
 969     }
 970 }