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