dlls/msxml3/xmlelem.c

   1 /*
   2  * XML Element implementation
   3  *
   4  * Copyright 2007 James Hawkins
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "ole2.h"
  30 #include "msxml2.h"
  31 #include "ocidl.h"
  32
  33 #include "wine/debug.h"
  34
  35 #include "msxml_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  38
  39 #ifdef HAVE_LIBXML2
  40
  41 /**********************************************************************
  42  * IXMLElement
  43  */
  44 typedef struct _xmlelem
  45 {
  46     const IXMLElementVtbl *lpVtbl;
  47     LONG ref;
  48     xmlNodePtr node;
  49 } xmlelem;
  50
  51 static inline xmlelem *impl_from_IXMLElement(IXMLElement *iface)
  52 {
  53     return (xmlelem *)((char*)iface - FIELD_OFFSET(xmlelem, lpVtbl));
  54 }
  55
  56 static HRESULT WINAPI xmlelem_QueryInterface(IXMLElement *iface, REFIID riid, void** ppvObject)
  57 {
  58     xmlelem *This = impl_from_IXMLElement(iface);
  59
  60     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
  61
  62     if (IsEqualGUID(riid, &IID_IUnknown) ||
  63         IsEqualGUID(riid, &IID_IXMLElement))
  64     {
  65         *ppvObject = iface;
  66     }
  67     else
  68     {
  69         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  70         return E_NOINTERFACE;
  71     }
  72
  73     IXMLElement_AddRef(iface);
  74
  75     return S_OK;
  76 }
  77
  78 static ULONG WINAPI xmlelem_AddRef(IXMLElement *iface)
  79 {
  80     xmlelem *This = impl_from_IXMLElement(iface);
  81     TRACE("%p\n", This);
  82     return InterlockedIncrement(&This->ref);
  83 }
  84
  85 static ULONG WINAPI xmlelem_Release(IXMLElement *iface)
  86 {
  87     xmlelem *This = impl_from_IXMLElement(iface);
  88     LONG ref;
  89
  90     TRACE("%p\n", This);
  91
  92     ref = InterlockedDecrement(&This->ref);
  93     if (ref == 0)
  94     {
  95         HeapFree(GetProcessHeap(), 0, This);
  96     }
  97
  98     return ref;
  99 }
 100
 101 static HRESULT WINAPI xmlelem_GetTypeInfoCount(IXMLElement *iface, UINT* pctinfo)
 102 {
 103     FIXME("\n");
 104     return E_NOTIMPL;
 105 }
 106
 107 static HRESULT WINAPI xmlelem_GetTypeInfo(IXMLElement *iface, UINT iTInfo,
 108                                           LCID lcid, ITypeInfo** ppTInfo)
 109 {
 110     FIXME("\n");
 111     return E_NOTIMPL;
 112 }
 113
 114 static HRESULT WINAPI xmlelem_GetIDsOfNames(IXMLElement *iface, REFIID riid,
 115                                             LPOLESTR* rgszNames, UINT cNames,
 116                                             LCID lcid, DISPID* rgDispId)
 117 {
 118     FIXME("\n");
 119     return E_NOTIMPL;
 120 }
 121
 122 static HRESULT WINAPI xmlelem_Invoke(IXMLElement *iface, DISPID dispIdMember,
 123                                      REFIID riid, LCID lcid, WORD wFlags,
 124                                      DISPPARAMS* pDispParams, VARIANT* pVarResult,
 125                                      EXCEPINFO* pExcepInfo, UINT* puArgErr)
 126 {
 127     FIXME("\n");
 128     return E_NOTIMPL;
 129 }
 130
 131 static inline BSTR str_dup_upper(BSTR str)
 132 {
 133     INT len = (lstrlenW(str) + 1) * sizeof(WCHAR);
 134     BSTR p = SysAllocStringLen(NULL, len);
 135     if (p)
 136     {
 137         memcpy(p, str, len);
 138         CharUpperW(p);
 139     }
 140     return p;
 141 }
 142
 143 static HRESULT WINAPI xmlelem_get_tagName(IXMLElement *iface, BSTR *p)
 144 {
 145     xmlelem *This = impl_from_IXMLElement(iface);
 146     BSTR temp;
 147
 148     TRACE("(%p, %p)\n", iface, p);
 149
 150     if (!p)
 151         return E_INVALIDARG;
 152
 153     temp = bstr_from_xmlChar(This->node->name);
 154     *p = str_dup_upper(temp);
 155     SysFreeString(temp);
 156
 157     TRACE("returning %s\n", debugstr_w(*p));
 158
 159     return S_OK;
 160 }
 161
 162 static HRESULT WINAPI xmlelem_put_tagName(IXMLElement *iface, BSTR p)
 163 {
 164     FIXME("(%p, %p): stub\n", iface, p);
 165
 166     if (!p)
 167         return E_INVALIDARG;
 168
 169     return E_NOTIMPL;
 170 }
 171
 172 static HRESULT WINAPI xmlelem_get_parent(IXMLElement *iface, IXMLElement **parent)
 173 {
 174     xmlelem *This = impl_from_IXMLElement(iface);
 175
 176     TRACE("(%p, %p)\n", iface, parent);
 177
 178     if (!parent)
 179         return E_INVALIDARG;
 180
 181     *parent = NULL;
 182
 183     if (!This->node->parent)
 184         return S_FALSE;
 185
 186     return XMLElement_create((IUnknown *)iface, This->node->parent, (LPVOID *)parent);
 187 }
 188
 189 static HRESULT WINAPI xmlelem_setAttribute(IXMLElement *iface, BSTR strPropertyName,
 190                                             VARIANT PropertyValue)
 191 {
 192     xmlelem *This = impl_from_IXMLElement(iface);
 193     xmlChar *name, *value;
 194     xmlAttrPtr attr;
 195
 196     TRACE("(%p, %s)\n", iface, debugstr_w(strPropertyName));
 197
 198     if (!strPropertyName || V_VT(&PropertyValue) != VT_BSTR)
 199         return E_INVALIDARG;
 200
 201     name = xmlChar_from_wchar(strPropertyName);
 202     value = xmlChar_from_wchar(V_BSTR(&PropertyValue));
 203     attr = xmlSetProp(This->node, name, value);
 204
 205     HeapFree(GetProcessHeap(), 0, name);
 206     HeapFree(GetProcessHeap(), 0, value);
 207     return (attr) ? S_OK : S_FALSE;
 208 }
 209
 210 static HRESULT WINAPI xmlelem_getAttribute(IXMLElement *iface, BSTR strPropertyName,
 211                                            VARIANT *PropertyValue)
 212 {
 213     xmlelem *This = impl_from_IXMLElement(iface);
 214     xmlChar *val = NULL, *name;
 215     xmlAttrPtr ptr;
 216
 217     TRACE("(%p, %s, %p)\n", iface, debugstr_w(strPropertyName), PropertyValue);
 218
 219     if (!PropertyValue)
 220         return E_INVALIDARG;
 221
 222     VariantInit(PropertyValue);
 223     V_BSTR(PropertyValue) = NULL;
 224
 225     if (!strPropertyName)
 226         return E_INVALIDARG;
 227
 228     name = xmlChar_from_wchar(strPropertyName);
 229     ptr = This->node->properties;
 230     while (ptr)
 231     {
 232         if (!lstrcmpiA((LPSTR)name, (LPCSTR)ptr->name))
 233         {
 234             val = xmlNodeListGetString(ptr->doc, ptr->children, 1);
 235             break;
 236         }
 237
 238         ptr = ptr->next;
 239     }
 240
 241     if (val)
 242     {
 243         V_VT(PropertyValue) = VT_BSTR;
 244         V_BSTR(PropertyValue) = bstr_from_xmlChar(val);
 245     }
 246
 247     HeapFree(GetProcessHeap(), 0, name);
 248     xmlFree(val);
 249     TRACE("returning %s\n", debugstr_w(V_BSTR(PropertyValue)));
 250     return (val) ? S_OK : S_FALSE;
 251 }
 252
 253 static HRESULT WINAPI xmlelem_removeAttribute(IXMLElement *iface, BSTR strPropertyName)
 254 {
 255     xmlelem *This = impl_from_IXMLElement(iface);
 256     xmlChar *name;
 257     xmlAttrPtr attr;
 258     int res;
 259     HRESULT hr = S_FALSE;
 260
 261     TRACE("(%p, %s)\n", iface, debugstr_w(strPropertyName));
 262
 263     if (!strPropertyName)
 264         return E_INVALIDARG;
 265
 266     name = xmlChar_from_wchar(strPropertyName);
 267     attr = xmlHasProp(This->node, name);
 268     if (!attr)
 269         goto done;
 270
 271     res = xmlRemoveProp(attr);
 272
 273     if (res == 0)
 274         hr = S_OK;
 275
 276 done:
 277     HeapFree(GetProcessHeap(), 0, name);
 278     return hr;
 279 }
 280
 281 static HRESULT WINAPI xmlelem_get_children(IXMLElement *iface, IXMLElementCollection **p)
 282 {
 283     xmlelem *This = impl_from_IXMLElement(iface);
 284
 285     TRACE("(%p, %p)\n", iface, p);
 286
 287     if (!p)
 288         return E_INVALIDARG;
 289
 290     return XMLElementCollection_create((IUnknown *)iface, This->node->children, (LPVOID *)p);
 291 }
 292
 293 static long type_libxml_to_msxml(xmlElementType type)
 294 {
 295     switch (type)
 296     {
 297         case XML_ELEMENT_NODE:
 298             return XMLELEMTYPE_ELEMENT;
 299         case XML_TEXT_NODE:
 300             return XMLELEMTYPE_TEXT;
 301         case XML_COMMENT_NODE:
 302             return XMLELEMTYPE_COMMENT;
 303         case XML_DOCUMENT_NODE:
 304             return XMLELEMTYPE_DOCUMENT;
 305         case XML_DTD_NODE:
 306             return XMLELEMTYPE_DTD;
 307         case XML_PI_NODE:
 308             return XMLELEMTYPE_PI;
 309         default:
 310             break;
 311     }
 312
 313     return XMLELEMTYPE_OTHER;
 314 }
 315
 316 static HRESULT WINAPI xmlelem_get_type(IXMLElement *iface, long *p)
 317 {
 318     xmlelem *This = impl_from_IXMLElement(iface);
 319
 320     TRACE("(%p, %p)\n", This, p);
 321
 322     if (!p)
 323         return E_INVALIDARG;
 324
 325     *p = type_libxml_to_msxml(This->node->type);
 326     TRACE("returning %ld\n", *p);
 327     return S_OK;
 328 }
 329
 330 static HRESULT WINAPI xmlelem_get_text(IXMLElement *iface, BSTR *p)
 331 {
 332     xmlelem *This = impl_from_IXMLElement(iface);
 333     xmlChar *content;
 334
 335     TRACE("(%p, %p)\n", iface, p);
 336
 337     if (!p)
 338         return E_INVALIDARG;
 339
 340     content = xmlNodeGetContent(This->node);
 341     *p = bstr_from_xmlChar(content);
 342     TRACE("returning %s\n", debugstr_w(*p));
 343     return S_OK;
 344 }
 345
 346 static HRESULT WINAPI xmlelem_put_text(IXMLElement *iface, BSTR p)
 347 {
 348     xmlelem *This = impl_from_IXMLElement(iface);
 349     xmlChar *content;
 350
 351     TRACE("(%p, %s)\n", iface, debugstr_w(p));
 352
 353     /* FIXME: test which types can be used */
 354     if (This->node->type == XML_ELEMENT_NODE)
 355         return E_NOTIMPL;
 356
 357     content = xmlChar_from_wchar(p);
 358     xmlNodeSetContent(This->node, content);
 359
 360     HeapFree( GetProcessHeap(), 0, content);
 361
 362     return S_OK;
 363 }
 364
 365 static HRESULT WINAPI xmlelem_addChild(IXMLElement *iface, IXMLElement *pChildElem,
 366                                         long lIndex, long lreserved)
 367 {
 368     xmlelem *This = impl_from_IXMLElement(iface);
 369     xmlelem *childElem = impl_from_IXMLElement(pChildElem);
 370     xmlNodePtr child;
 371
 372     TRACE("(%p, %p, %ld, %ld)\n", iface, pChildElem, lIndex, lreserved);
 373
 374     if (lIndex == 0)
 375         child = xmlAddChild(This->node, childElem->node);
 376     else
 377         child = xmlAddNextSibling(This->node, childElem->node->last);
 378
 379     return (child) ? S_OK : S_FALSE;
 380 }
 381
 382 static HRESULT WINAPI xmlelem_removeChild(IXMLElement *iface, IXMLElement *pChildElem)
 383 {
 384     FIXME("(%p, %p): stub\n", iface, pChildElem);
 385     return E_NOTIMPL;
 386 }
 387
 388 static const struct IXMLElementVtbl xmlelem_vtbl =
 389 {
 390     xmlelem_QueryInterface,
 391     xmlelem_AddRef,
 392     xmlelem_Release,
 393     xmlelem_GetTypeInfoCount,
 394     xmlelem_GetTypeInfo,
 395     xmlelem_GetIDsOfNames,
 396     xmlelem_Invoke,
 397     xmlelem_get_tagName,
 398     xmlelem_put_tagName,
 399     xmlelem_get_parent,
 400     xmlelem_setAttribute,
 401     xmlelem_getAttribute,
 402     xmlelem_removeAttribute,
 403     xmlelem_get_children,
 404     xmlelem_get_type,
 405     xmlelem_get_text,
 406     xmlelem_put_text,
 407     xmlelem_addChild,
 408     xmlelem_removeChild
 409 };
 410
 411 HRESULT XMLElement_create(IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj)
 412 {
 413     xmlelem *elem;
 414
 415     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 416
 417     if (!ppObj)
 418         return E_INVALIDARG;
 419
 420     *ppObj = NULL;
 421
 422     elem = HeapAlloc(GetProcessHeap(), 0, sizeof (*elem));
 423     if(!elem)
 424         return E_OUTOFMEMORY;
 425
 426     elem->lpVtbl = &xmlelem_vtbl;
 427     elem->ref = 1;
 428     elem->node = node;
 429
 430     *ppObj = &elem->lpVtbl;
 431
 432     TRACE("returning iface %p\n", *ppObj);
 433     return S_OK;
 434 }
 435
 436 /************************************************************************
 437  * IXMLElementCollection
 438  */
 439 typedef struct _xmlelem_collection
 440 {
 441     const IXMLElementCollectionVtbl *lpVtbl;
 442     const IEnumVARIANTVtbl          *lpvtblIEnumVARIANT;
 443     LONG ref;
 444     LONG length;
 445     xmlNodePtr node;
 446
 447     /* IEnumVARIANT members */
 448     xmlNodePtr current;
 449 } xmlelem_collection;
 450
 451 static inline xmlelem_collection *impl_from_IXMLElementCollection(IXMLElementCollection *iface)
 452 {
 453     return (xmlelem_collection *)((char*)iface - FIELD_OFFSET(xmlelem_collection, lpVtbl));
 454 }
 455
 456 static inline xmlelem_collection *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
 457 {
 458     return (xmlelem_collection *)((char*)iface - FIELD_OFFSET(xmlelem_collection, lpvtblIEnumVARIANT));
 459 }
 460
 461 static HRESULT WINAPI xmlelem_collection_QueryInterface(IXMLElementCollection *iface, REFIID riid, void** ppvObject)
 462 {
 463     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 464
 465     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 466
 467     if (IsEqualGUID(riid, &IID_IUnknown) ||
 468         IsEqualGUID(riid, &IID_IXMLElementCollection))
 469     {
 470         *ppvObject = iface;
 471     }
 472     else if (IsEqualGUID(riid, &IID_IEnumVARIANT))
 473     {
 474         *ppvObject = (IEnumVARIANT *)&(This->lpvtblIEnumVARIANT);
 475     }
 476     else
 477     {
 478         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 479         return E_NOINTERFACE;
 480     }
 481
 482     IXMLElementCollection_AddRef(iface);
 483
 484     return S_OK;
 485 }
 486
 487 static ULONG WINAPI xmlelem_collection_AddRef(IXMLElementCollection *iface)
 488 {
 489     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 490     TRACE("%p\n", This);
 491     return InterlockedIncrement(&This->ref);
 492 }
 493
 494 static ULONG WINAPI xmlelem_collection_Release(IXMLElementCollection *iface)
 495 {
 496     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 497     LONG ref;
 498
 499     TRACE("%p\n", This);
 500
 501     ref = InterlockedDecrement(&This->ref);
 502     if (ref == 0)
 503     {
 504         HeapFree(GetProcessHeap(), 0, This);
 505     }
 506
 507     return ref;
 508 }
 509
 510 static HRESULT WINAPI xmlelem_collection_GetTypeInfoCount(IXMLElementCollection *iface, UINT* pctinfo)
 511 {
 512     FIXME("\n");
 513     return E_NOTIMPL;
 514 }
 515
 516 static HRESULT WINAPI xmlelem_collection_GetTypeInfo(IXMLElementCollection *iface, UINT iTInfo,
 517                                                      LCID lcid, ITypeInfo** ppTInfo)
 518 {
 519     FIXME("\n");
 520     return E_NOTIMPL;
 521 }
 522
 523 static HRESULT WINAPI xmlelem_collection_GetIDsOfNames(IXMLElementCollection *iface, REFIID riid,
 524                                                        LPOLESTR* rgszNames, UINT cNames,
 525                                                        LCID lcid, DISPID* rgDispId)
 526 {
 527     FIXME("\n");
 528     return E_NOTIMPL;
 529 }
 530
 531 static HRESULT WINAPI xmlelem_collection_Invoke(IXMLElementCollection *iface, DISPID dispIdMember,
 532                                                 REFIID riid, LCID lcid, WORD wFlags,
 533                                                 DISPPARAMS* pDispParams, VARIANT* pVarResult,
 534                                                 EXCEPINFO* pExcepInfo, UINT* puArgErr)
 535 {
 536     FIXME("\n");
 537     return E_NOTIMPL;
 538 }
 539
 540 static HRESULT WINAPI xmlelem_collection_put_length(IXMLElementCollection *iface, long v)
 541 {
 542     TRACE("(%p, %ld)\n", iface, v);
 543     return E_FAIL;
 544 }
 545
 546 static HRESULT WINAPI xmlelem_collection_get_length(IXMLElementCollection *iface, long *p)
 547 {
 548     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 549
 550     TRACE("(%p, %p)\n", iface, p);
 551
 552     if (!p)
 553         return E_INVALIDARG;
 554
 555     *p = This->length;
 556     return S_OK;
 557 }
 558
 559 static HRESULT WINAPI xmlelem_collection_get__newEnum(IXMLElementCollection *iface, IUnknown **ppUnk)
 560 {
 561     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 562
 563     TRACE("(%p, %p)\n", iface, ppUnk);
 564
 565     if (!ppUnk)
 566         return E_INVALIDARG;
 567
 568     *ppUnk = (IUnknown *)This;
 569     IUnknown_AddRef(*ppUnk);
 570     return S_OK;
 571 }
 572
 573 static HRESULT WINAPI xmlelem_collection_item(IXMLElementCollection *iface, VARIANT var1,
 574                                               VARIANT var2, IDispatch **ppDisp)
 575 {
 576     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 577     xmlNodePtr ptr = This->node;
 578     int index, i;
 579
 580     TRACE("(%p, %p)\n", iface, ppDisp);
 581
 582     if (!ppDisp)
 583         return E_INVALIDARG;
 584
 585     *ppDisp = NULL;
 586
 587     index = V_I4(&var1);
 588     if (index < 0)
 589         return E_INVALIDARG;
 590     if (index >= This->length)
 591         return E_FAIL;
 592
 593     for (i = 0; i < index; i++)
 594         ptr = ptr->next;
 595
 596     return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)ppDisp);
 597 }
 598
 599 static const struct IXMLElementCollectionVtbl xmlelem_collection_vtbl =
 600 {
 601     xmlelem_collection_QueryInterface,
 602     xmlelem_collection_AddRef,
 603     xmlelem_collection_Release,
 604     xmlelem_collection_GetTypeInfoCount,
 605     xmlelem_collection_GetTypeInfo,
 606     xmlelem_collection_GetIDsOfNames,
 607     xmlelem_collection_Invoke,
 608     xmlelem_collection_put_length,
 609     xmlelem_collection_get_length,
 610     xmlelem_collection_get__newEnum,
 611     xmlelem_collection_item
 612 };
 613
 614 /************************************************************************
 615  * xmlelem_collection implementation of IEnumVARIANT.
 616  */
 617 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_QueryInterface(
 618     IEnumVARIANT *iface, REFIID riid, LPVOID *ppvObj)
 619 {
 620     xmlelem_collection *this = impl_from_IEnumVARIANT(iface);
 621     return IXMLDocument_QueryInterface((IXMLDocument *)this, riid, ppvObj);
 622 }
 623
 624 static ULONG WINAPI xmlelem_collection_IEnumVARIANT_AddRef(
 625     IEnumVARIANT *iface)
 626 {
 627     xmlelem_collection *this = impl_from_IEnumVARIANT(iface);
 628     return IXMLDocument_AddRef((IXMLDocument *)this);
 629 }
 630
 631 static ULONG WINAPI xmlelem_collection_IEnumVARIANT_Release(
 632     IEnumVARIANT *iface)
 633 {
 634     xmlelem_collection *this = impl_from_IEnumVARIANT(iface);
 635     return IXMLDocument_Release((IXMLDocument *)this);
 636 }
 637
 638 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Next(
 639     IEnumVARIANT *iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
 640 {
 641     xmlelem_collection *This = impl_from_IEnumVARIANT(iface);
 642     xmlNodePtr ptr = This->current;
 643
 644     TRACE("(%p, %d, %p, %p)\n", iface, celt, rgVar, pCeltFetched);
 645
 646     if (!rgVar)
 647         return E_INVALIDARG;
 648
 649     /* FIXME: handle celt */
 650     if (pCeltFetched)
 651         *pCeltFetched = 1;
 652
 653     This->current = This->current->next;
 654
 655     V_VT(rgVar) = VT_DISPATCH;
 656     return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)&V_DISPATCH(rgVar));
 657 }
 658
 659 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Skip(
 660     IEnumVARIANT *iface, ULONG celt)
 661 {
 662     FIXME("(%p, %d): stub\n", iface, celt);
 663     return E_NOTIMPL;
 664 }
 665
 666 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Reset(
 667     IEnumVARIANT *iface)
 668 {
 669     xmlelem_collection *This = impl_from_IEnumVARIANT(iface);
 670     This->current = This->node;
 671     return S_OK;
 672 }
 673
 674 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Clone(
 675     IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
 676 {
 677     FIXME("(%p, %p): stub\n", iface, ppEnum);
 678     return E_NOTIMPL;
 679 }
 680
 681 static const struct IEnumVARIANTVtbl xmlelem_collection_IEnumVARIANTvtbl =
 682 {
 683     xmlelem_collection_IEnumVARIANT_QueryInterface,
 684     xmlelem_collection_IEnumVARIANT_AddRef,
 685     xmlelem_collection_IEnumVARIANT_Release,
 686     xmlelem_collection_IEnumVARIANT_Next,
 687     xmlelem_collection_IEnumVARIANT_Skip,
 688     xmlelem_collection_IEnumVARIANT_Reset,
 689     xmlelem_collection_IEnumVARIANT_Clone
 690 };
 691
 692 HRESULT XMLElementCollection_create(IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj)
 693 {
 694     xmlelem_collection *collection;
 695     xmlNodePtr ptr;
 696
 697     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 698
 699     *ppObj = NULL;
 700
 701     if (!node)
 702         return S_FALSE;
 703
 704     collection = HeapAlloc(GetProcessHeap(), 0, sizeof (*collection));
 705     if(!collection)
 706         return E_OUTOFMEMORY;
 707
 708     collection->lpVtbl = &xmlelem_collection_vtbl;
 709     collection->lpvtblIEnumVARIANT = &xmlelem_collection_IEnumVARIANTvtbl;
 710     collection->ref = 1;
 711     collection->length = 0;
 712     collection->node = node;
 713     collection->current = node;
 714
 715     ptr = node;
 716     while (ptr)
 717     {
 718         collection->length++;
 719         ptr = ptr->next;
 720     }
 721
 722     *ppObj = &collection->lpVtbl;
 723
 724     TRACE("returning iface %p\n", *ppObj);
 725     return S_OK;
 726 }
 727
 728 #endif