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 static HRESULT XMLElementCollection_create( IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj );
  42
  43 /**********************************************************************
  44  * IXMLElement
  45  */
  46 typedef struct _xmlelem
  47 {
  48     const IXMLElementVtbl *lpVtbl;
  49     LONG ref;
  50     xmlNodePtr node;
  51     BOOL own;
  52 } xmlelem;
  53
  54 static inline xmlelem *impl_from_IXMLElement(IXMLElement *iface)
  55 {
  56     return (xmlelem *)((char*)iface - FIELD_OFFSET(xmlelem, lpVtbl));
  57 }
  58
  59 static HRESULT WINAPI xmlelem_QueryInterface(IXMLElement *iface, REFIID riid, void** ppvObject)
  60 {
  61     xmlelem *This = impl_from_IXMLElement(iface);
  62
  63     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
  64
  65     if (IsEqualGUID(riid, &IID_IUnknown) ||
  66         IsEqualGUID(riid, &IID_IXMLElement))
  67     {
  68         *ppvObject = iface;
  69     }
  70     else
  71     {
  72         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  73         return E_NOINTERFACE;
  74     }
  75
  76     IXMLElement_AddRef(iface);
  77
  78     return S_OK;
  79 }
  80
  81 static ULONG WINAPI xmlelem_AddRef(IXMLElement *iface)
  82 {
  83     xmlelem *This = impl_from_IXMLElement(iface);
  84     TRACE("%p\n", This);
  85     return InterlockedIncrement(&This->ref);
  86 }
  87
  88 static ULONG WINAPI xmlelem_Release(IXMLElement *iface)
  89 {
  90     xmlelem *This = impl_from_IXMLElement(iface);
  91     LONG ref;
  92
  93     TRACE("%p\n", This);
  94
  95     ref = InterlockedDecrement(&This->ref);
  96     if (ref == 0)
  97     {
  98         if (This->own) xmlFreeNode(This->node);
  99         heap_free(This);
 100     }
 101
 102     return ref;
 103 }
 104
 105 static HRESULT WINAPI xmlelem_GetTypeInfoCount(IXMLElement *iface, UINT* pctinfo)
 106 {
 107     xmlelem *This = impl_from_IXMLElement(iface);
 108
 109     TRACE("(%p)->(%p)\n", This, pctinfo);
 110
 111     *pctinfo = 1;
 112
 113     return S_OK;
 114 }
 115
 116 static HRESULT WINAPI xmlelem_GetTypeInfo(IXMLElement *iface, UINT iTInfo,
 117                                           LCID lcid, ITypeInfo** ppTInfo)
 118 {
 119     xmlelem *This = impl_from_IXMLElement(iface);
 120     HRESULT hr;
 121
 122     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 123
 124     hr = get_typeinfo(IXMLElement_tid, ppTInfo);
 125
 126     return hr;
 127 }
 128
 129 static HRESULT WINAPI xmlelem_GetIDsOfNames(IXMLElement *iface, REFIID riid,
 130                                             LPOLESTR* rgszNames, UINT cNames,
 131                                             LCID lcid, DISPID* rgDispId)
 132 {
 133     xmlelem *This = impl_from_IXMLElement(iface);
 134     ITypeInfo *typeinfo;
 135     HRESULT hr;
 136
 137     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 138           lcid, rgDispId);
 139
 140     if(!rgszNames || cNames == 0 || !rgDispId)
 141         return E_INVALIDARG;
 142
 143     hr = get_typeinfo(IXMLElement_tid, &typeinfo);
 144     if(SUCCEEDED(hr))
 145     {
 146         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 147         ITypeInfo_Release(typeinfo);
 148     }
 149
 150     return hr;
 151 }
 152
 153 static HRESULT WINAPI xmlelem_Invoke(IXMLElement *iface, DISPID dispIdMember,
 154                                      REFIID riid, LCID lcid, WORD wFlags,
 155                                      DISPPARAMS* pDispParams, VARIANT* pVarResult,
 156                                      EXCEPINFO* pExcepInfo, UINT* puArgErr)
 157 {
 158     xmlelem *This = impl_from_IXMLElement(iface);
 159     ITypeInfo *typeinfo;
 160     HRESULT hr;
 161
 162     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 163           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 164
 165     hr = get_typeinfo(IXMLElement_tid, &typeinfo);
 166     if(SUCCEEDED(hr))
 167     {
 168         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
 169                 pVarResult, pExcepInfo, puArgErr);
 170         ITypeInfo_Release(typeinfo);
 171     }
 172
 173     return hr;
 174 }
 175
 176 static HRESULT WINAPI xmlelem_get_tagName(IXMLElement *iface, BSTR *p)
 177 {
 178     xmlelem *This = impl_from_IXMLElement(iface);
 179
 180     TRACE("(%p, %p)\n", iface, p);
 181
 182     if (!p)
 183         return E_INVALIDARG;
 184
 185     *p = bstr_from_xmlChar(This->node->name);
 186     CharUpperBuffW(*p, SysStringLen(*p));
 187
 188     TRACE("returning %s\n", debugstr_w(*p));
 189
 190     return S_OK;
 191 }
 192
 193 static HRESULT WINAPI xmlelem_put_tagName(IXMLElement *iface, BSTR p)
 194 {
 195     FIXME("(%p, %p): stub\n", iface, p);
 196
 197     if (!p)
 198         return E_INVALIDARG;
 199
 200     return E_NOTIMPL;
 201 }
 202
 203 static HRESULT WINAPI xmlelem_get_parent(IXMLElement *iface, IXMLElement **parent)
 204 {
 205     xmlelem *This = impl_from_IXMLElement(iface);
 206
 207     TRACE("(%p, %p)\n", iface, parent);
 208
 209     if (!parent)
 210         return E_INVALIDARG;
 211
 212     *parent = NULL;
 213
 214     if (!This->node->parent)
 215         return S_FALSE;
 216
 217     return XMLElement_create((IUnknown *)iface, This->node->parent, (LPVOID *)parent, FALSE);
 218 }
 219
 220 static HRESULT WINAPI xmlelem_setAttribute(IXMLElement *iface, BSTR strPropertyName,
 221                                             VARIANT PropertyValue)
 222 {
 223     xmlelem *This = impl_from_IXMLElement(iface);
 224     xmlChar *name, *value;
 225     xmlAttrPtr attr;
 226
 227     TRACE("(%p, %s)\n", iface, debugstr_w(strPropertyName));
 228
 229     if (!strPropertyName || V_VT(&PropertyValue) != VT_BSTR)
 230         return E_INVALIDARG;
 231
 232     name = xmlChar_from_wchar(strPropertyName);
 233     value = xmlChar_from_wchar(V_BSTR(&PropertyValue));
 234     attr = xmlSetProp(This->node, name, value);
 235
 236     heap_free(name);
 237     heap_free(value);
 238     return (attr) ? S_OK : S_FALSE;
 239 }
 240
 241 static HRESULT WINAPI xmlelem_getAttribute(IXMLElement *iface, BSTR name,
 242     VARIANT *value)
 243 {
 244     static const WCHAR xmllangW[] = { 'x','m','l',':','l','a','n','g',0 };
 245     xmlelem *This = impl_from_IXMLElement(iface);
 246     xmlChar *val = NULL;
 247
 248     TRACE("(%p, %s, %p)\n", iface, debugstr_w(name), value);
 249
 250     if (!value)
 251         return E_INVALIDARG;
 252
 253     VariantInit(value);
 254     V_BSTR(value) = NULL;
 255
 256     if (!name)
 257         return E_INVALIDARG;
 258
 259     /* case for xml:lang attribute */
 260     if (!lstrcmpiW(name, xmllangW))
 261     {
 262         xmlNsPtr ns;
 263         ns = xmlSearchNs(This->node->doc, This->node, (xmlChar*)"xml");
 264         val = xmlGetNsProp(This->node, (xmlChar*)"lang", ns->href);
 265         xmlFree(ns);
 266     }
 267     else
 268     {
 269         xmlAttrPtr attr;
 270         xmlChar *xml_name;
 271
 272         xml_name = xmlChar_from_wchar(name);
 273         attr = This->node->properties;
 274         while (attr)
 275         {
 276             BSTR attr_name;
 277
 278             attr_name = bstr_from_xmlChar(attr->name);
 279             if (!lstrcmpiW(name, attr_name))
 280             {
 281                 val = xmlNodeListGetString(attr->doc, attr->children, 1);
 282                 SysFreeString(attr_name);
 283                 break;
 284             }
 285
 286             attr = attr->next;
 287             SysFreeString(attr_name);
 288         }
 289
 290         heap_free(xml_name);
 291     }
 292
 293     if (val)
 294     {
 295         V_VT(value) = VT_BSTR;
 296         V_BSTR(value) = bstr_from_xmlChar(val);
 297     }
 298
 299     xmlFree(val);
 300     TRACE("returning %s\n", debugstr_w(V_BSTR(value)));
 301     return (val) ? S_OK : S_FALSE;
 302 }
 303
 304 static HRESULT WINAPI xmlelem_removeAttribute(IXMLElement *iface, BSTR strPropertyName)
 305 {
 306     xmlelem *This = impl_from_IXMLElement(iface);
 307     xmlChar *name;
 308     xmlAttrPtr attr;
 309     int res;
 310     HRESULT hr = S_FALSE;
 311
 312     TRACE("(%p, %s)\n", iface, debugstr_w(strPropertyName));
 313
 314     if (!strPropertyName)
 315         return E_INVALIDARG;
 316
 317     name = xmlChar_from_wchar(strPropertyName);
 318     attr = xmlHasProp(This->node, name);
 319     if (!attr)
 320         goto done;
 321
 322     res = xmlRemoveProp(attr);
 323
 324     if (res == 0)
 325         hr = S_OK;
 326
 327 done:
 328     heap_free(name);
 329     return hr;
 330 }
 331
 332 static HRESULT WINAPI xmlelem_get_children(IXMLElement *iface, IXMLElementCollection **p)
 333 {
 334     xmlelem *This = impl_from_IXMLElement(iface);
 335
 336     TRACE("(%p, %p)\n", iface, p);
 337
 338     if (!p)
 339         return E_INVALIDARG;
 340
 341     return XMLElementCollection_create((IUnknown *)iface, This->node, (LPVOID *)p);
 342 }
 343
 344 static LONG type_libxml_to_msxml(xmlElementType type)
 345 {
 346     switch (type)
 347     {
 348         case XML_ELEMENT_NODE:
 349             return XMLELEMTYPE_ELEMENT;
 350         case XML_TEXT_NODE:
 351             return XMLELEMTYPE_TEXT;
 352         case XML_COMMENT_NODE:
 353             return XMLELEMTYPE_COMMENT;
 354         case XML_DOCUMENT_NODE:
 355             return XMLELEMTYPE_DOCUMENT;
 356         case XML_DTD_NODE:
 357             return XMLELEMTYPE_DTD;
 358         case XML_PI_NODE:
 359             return XMLELEMTYPE_PI;
 360         default:
 361             break;
 362     }
 363
 364     return XMLELEMTYPE_OTHER;
 365 }
 366
 367 static HRESULT WINAPI xmlelem_get_type(IXMLElement *iface, LONG *p)
 368 {
 369     xmlelem *This = impl_from_IXMLElement(iface);
 370
 371     TRACE("(%p, %p)\n", This, p);
 372
 373     if (!p)
 374         return E_INVALIDARG;
 375
 376     *p = type_libxml_to_msxml(This->node->type);
 377     TRACE("returning %d\n", *p);
 378     return S_OK;
 379 }
 380
 381 static HRESULT WINAPI xmlelem_get_text(IXMLElement *iface, BSTR *p)
 382 {
 383     xmlelem *This = impl_from_IXMLElement(iface);
 384     xmlChar *content;
 385
 386     TRACE("(%p, %p)\n", iface, p);
 387
 388     if (!p)
 389         return E_INVALIDARG;
 390
 391     content = xmlNodeGetContent(This->node);
 392     *p = bstr_from_xmlChar(content);
 393     TRACE("returning %s\n", debugstr_w(*p));
 394
 395     xmlFree(content);
 396     return S_OK;
 397 }
 398
 399 static HRESULT WINAPI xmlelem_put_text(IXMLElement *iface, BSTR p)
 400 {
 401     xmlelem *This = impl_from_IXMLElement(iface);
 402     xmlChar *content;
 403
 404     TRACE("(%p, %s)\n", iface, debugstr_w(p));
 405
 406     /* FIXME: test which types can be used */
 407     if (This->node->type == XML_ELEMENT_NODE)
 408         return E_NOTIMPL;
 409
 410     content = xmlChar_from_wchar(p);
 411     xmlNodeSetContent(This->node, content);
 412
 413     heap_free(content);
 414
 415     return S_OK;
 416 }
 417
 418 static HRESULT WINAPI xmlelem_addChild(IXMLElement *iface, IXMLElement *pChildElem,
 419                                        LONG lIndex, LONG lreserved)
 420 {
 421     xmlelem *This = impl_from_IXMLElement(iface);
 422     xmlelem *childElem = impl_from_IXMLElement(pChildElem);
 423     xmlNodePtr child;
 424
 425     TRACE("(%p, %p, %d, %d)\n", iface, pChildElem, lIndex, lreserved);
 426
 427     if (lIndex == 0)
 428         child = xmlAddChild(This->node, childElem->node);
 429     else
 430         child = xmlAddNextSibling(This->node, childElem->node->last);
 431
 432     /* parent is responsible for child data */
 433     if (child) childElem->own = FALSE;
 434
 435     return (child) ? S_OK : S_FALSE;
 436 }
 437
 438 static HRESULT WINAPI xmlelem_removeChild(IXMLElement *iface, IXMLElement *pChildElem)
 439 {
 440     xmlelem *This = impl_from_IXMLElement(iface);
 441     xmlelem *childElem = impl_from_IXMLElement(pChildElem);
 442
 443     TRACE("(%p, %p)\n", This, childElem);
 444
 445     if (!pChildElem)
 446         return E_INVALIDARG;
 447
 448     /* only supported for This is childElem parent case */
 449     if (This->node != childElem->node->parent)
 450         return E_INVALIDARG;
 451
 452     xmlUnlinkNode(childElem->node);
 453     /* standalone element now */
 454     childElem->own = TRUE;
 455
 456     return S_OK;
 457 }
 458
 459 static const struct IXMLElementVtbl xmlelem_vtbl =
 460 {
 461     xmlelem_QueryInterface,
 462     xmlelem_AddRef,
 463     xmlelem_Release,
 464     xmlelem_GetTypeInfoCount,
 465     xmlelem_GetTypeInfo,
 466     xmlelem_GetIDsOfNames,
 467     xmlelem_Invoke,
 468     xmlelem_get_tagName,
 469     xmlelem_put_tagName,
 470     xmlelem_get_parent,
 471     xmlelem_setAttribute,
 472     xmlelem_getAttribute,
 473     xmlelem_removeAttribute,
 474     xmlelem_get_children,
 475     xmlelem_get_type,
 476     xmlelem_get_text,
 477     xmlelem_put_text,
 478     xmlelem_addChild,
 479     xmlelem_removeChild
 480 };
 481
 482 HRESULT XMLElement_create(IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj, BOOL own)
 483 {
 484     xmlelem *elem;
 485
 486     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 487
 488     if (!ppObj)
 489         return E_INVALIDARG;
 490
 491     *ppObj = NULL;
 492
 493     elem = heap_alloc(sizeof (*elem));
 494     if(!elem)
 495         return E_OUTOFMEMORY;
 496
 497     elem->lpVtbl = &xmlelem_vtbl;
 498     elem->ref = 1;
 499     elem->node = node;
 500     elem->own  = own;
 501
 502     *ppObj = &elem->lpVtbl;
 503
 504     TRACE("returning iface %p\n", *ppObj);
 505     return S_OK;
 506 }
 507
 508 /************************************************************************
 509  * IXMLElementCollection
 510  */
 511 typedef struct _xmlelem_collection
 512 {
 513     const IXMLElementCollectionVtbl *lpVtbl;
 514     const IEnumVARIANTVtbl          *lpvtblIEnumVARIANT;
 515     LONG ref;
 516     LONG length;
 517     xmlNodePtr node;
 518
 519     /* IEnumVARIANT members */
 520     xmlNodePtr current;
 521 } xmlelem_collection;
 522
 523 static inline LONG xmlelem_collection_updatelength(xmlelem_collection *collection)
 524 {
 525     xmlNodePtr ptr = collection->node->children;
 526
 527     collection->length = 0;
 528     while (ptr)
 529     {
 530         collection->length++;
 531         ptr = ptr->next;
 532     }
 533     return collection->length;
 534 }
 535
 536 static inline xmlelem_collection *impl_from_IXMLElementCollection(IXMLElementCollection *iface)
 537 {
 538     return (xmlelem_collection *)((char*)iface - FIELD_OFFSET(xmlelem_collection, lpVtbl));
 539 }
 540
 541 static inline xmlelem_collection *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
 542 {
 543     return (xmlelem_collection *)((char*)iface - FIELD_OFFSET(xmlelem_collection, lpvtblIEnumVARIANT));
 544 }
 545
 546 static HRESULT WINAPI xmlelem_collection_QueryInterface(IXMLElementCollection *iface, REFIID riid, void** ppvObject)
 547 {
 548     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 549
 550     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
 551
 552     if (IsEqualGUID(riid, &IID_IUnknown) ||
 553         IsEqualGUID(riid, &IID_IXMLElementCollection))
 554     {
 555         *ppvObject = iface;
 556     }
 557     else if (IsEqualGUID(riid, &IID_IEnumVARIANT))
 558     {
 559         *ppvObject = &(This->lpvtblIEnumVARIANT);
 560     }
 561     else
 562     {
 563         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 564         return E_NOINTERFACE;
 565     }
 566
 567     IXMLElementCollection_AddRef(iface);
 568
 569     return S_OK;
 570 }
 571
 572 static ULONG WINAPI xmlelem_collection_AddRef(IXMLElementCollection *iface)
 573 {
 574     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 575     TRACE("%p\n", This);
 576     return InterlockedIncrement(&This->ref);
 577 }
 578
 579 static ULONG WINAPI xmlelem_collection_Release(IXMLElementCollection *iface)
 580 {
 581     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 582     LONG ref;
 583
 584     TRACE("%p\n", This);
 585
 586     ref = InterlockedDecrement(&This->ref);
 587     if (ref == 0)
 588     {
 589         heap_free(This);
 590     }
 591
 592     return ref;
 593 }
 594
 595 static HRESULT WINAPI xmlelem_collection_GetTypeInfoCount(IXMLElementCollection *iface, UINT* pctinfo)
 596 {
 597     FIXME("\n");
 598     return E_NOTIMPL;
 599 }
 600
 601 static HRESULT WINAPI xmlelem_collection_GetTypeInfo(IXMLElementCollection *iface, UINT iTInfo,
 602                                                      LCID lcid, ITypeInfo** ppTInfo)
 603 {
 604     FIXME("\n");
 605     return E_NOTIMPL;
 606 }
 607
 608 static HRESULT WINAPI xmlelem_collection_GetIDsOfNames(IXMLElementCollection *iface, REFIID riid,
 609                                                        LPOLESTR* rgszNames, UINT cNames,
 610                                                        LCID lcid, DISPID* rgDispId)
 611 {
 612     FIXME("\n");
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI xmlelem_collection_Invoke(IXMLElementCollection *iface, DISPID dispIdMember,
 617                                                 REFIID riid, LCID lcid, WORD wFlags,
 618                                                 DISPPARAMS* pDispParams, VARIANT* pVarResult,
 619                                                 EXCEPINFO* pExcepInfo, UINT* puArgErr)
 620 {
 621     FIXME("\n");
 622     return E_NOTIMPL;
 623 }
 624
 625 static HRESULT WINAPI xmlelem_collection_put_length(IXMLElementCollection *iface, LONG v)
 626 {
 627     TRACE("(%p, %d)\n", iface, v);
 628     return E_FAIL;
 629 }
 630
 631 static HRESULT WINAPI xmlelem_collection_get_length(IXMLElementCollection *iface, LONG *p)
 632 {
 633     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 634
 635     TRACE("(%p, %p)\n", iface, p);
 636
 637     if (!p)
 638         return E_INVALIDARG;
 639
 640     *p = xmlelem_collection_updatelength(This);
 641     return S_OK;
 642 }
 643
 644 static HRESULT WINAPI xmlelem_collection_get__newEnum(IXMLElementCollection *iface, IUnknown **ppUnk)
 645 {
 646     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 647
 648     TRACE("(%p, %p)\n", iface, ppUnk);
 649
 650     if (!ppUnk)
 651         return E_INVALIDARG;
 652
 653     *ppUnk = (IUnknown *)This;
 654     IUnknown_AddRef(*ppUnk);
 655     return S_OK;
 656 }
 657
 658 static HRESULT WINAPI xmlelem_collection_item(IXMLElementCollection *iface, VARIANT var1,
 659                                               VARIANT var2, IDispatch **ppDisp)
 660 {
 661     xmlelem_collection *This = impl_from_IXMLElementCollection(iface);
 662     xmlNodePtr ptr = This->node->children;
 663     int index, i;
 664
 665     TRACE("(%p, %p)\n", iface, ppDisp);
 666
 667     if (!ppDisp)
 668         return E_INVALIDARG;
 669
 670     *ppDisp = NULL;
 671
 672     index = V_I4(&var1);
 673     if (index < 0)
 674         return E_INVALIDARG;
 675
 676     xmlelem_collection_updatelength(This);
 677     if (index >= This->length)
 678         return E_FAIL;
 679
 680     for (i = 0; i < index; i++)
 681         ptr = ptr->next;
 682
 683     return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)ppDisp, FALSE);
 684 }
 685
 686 static const struct IXMLElementCollectionVtbl xmlelem_collection_vtbl =
 687 {
 688     xmlelem_collection_QueryInterface,
 689     xmlelem_collection_AddRef,
 690     xmlelem_collection_Release,
 691     xmlelem_collection_GetTypeInfoCount,
 692     xmlelem_collection_GetTypeInfo,
 693     xmlelem_collection_GetIDsOfNames,
 694     xmlelem_collection_Invoke,
 695     xmlelem_collection_put_length,
 696     xmlelem_collection_get_length,
 697     xmlelem_collection_get__newEnum,
 698     xmlelem_collection_item
 699 };
 700
 701 /************************************************************************
 702  * xmlelem_collection implementation of IEnumVARIANT.
 703  */
 704 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_QueryInterface(
 705     IEnumVARIANT *iface, REFIID riid, LPVOID *ppvObj)
 706 {
 707     xmlelem_collection *this = impl_from_IEnumVARIANT(iface);
 708     return IXMLDocument_QueryInterface((IXMLDocument *)this, riid, ppvObj);
 709 }
 710
 711 static ULONG WINAPI xmlelem_collection_IEnumVARIANT_AddRef(
 712     IEnumVARIANT *iface)
 713 {
 714     xmlelem_collection *this = impl_from_IEnumVARIANT(iface);
 715     return IXMLDocument_AddRef((IXMLDocument *)this);
 716 }
 717
 718 static ULONG WINAPI xmlelem_collection_IEnumVARIANT_Release(
 719     IEnumVARIANT *iface)
 720 {
 721     xmlelem_collection *this = impl_from_IEnumVARIANT(iface);
 722     return IXMLDocument_Release((IXMLDocument *)this);
 723 }
 724
 725 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Next(
 726     IEnumVARIANT *iface, ULONG celt, VARIANT *rgVar, ULONG *fetched)
 727 {
 728     xmlelem_collection *This = impl_from_IEnumVARIANT(iface);
 729     xmlNodePtr ptr = This->current;
 730
 731     TRACE("(%p, %d, %p, %p)\n", iface, celt, rgVar, fetched);
 732
 733     if (!rgVar)
 734         return E_INVALIDARG;
 735
 736     /* FIXME: handle celt */
 737     if (fetched)
 738         *fetched = 1;
 739
 740     if (This->current)
 741         This->current = This->current->next;
 742     else
 743     {
 744         V_VT(rgVar) = VT_EMPTY;
 745         if (fetched) *fetched = 0;
 746         return S_FALSE;
 747     }
 748
 749     V_VT(rgVar) = VT_DISPATCH;
 750     return XMLElement_create((IUnknown *)iface, ptr, (LPVOID *)&V_DISPATCH(rgVar), FALSE);
 751 }
 752
 753 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Skip(
 754     IEnumVARIANT *iface, ULONG celt)
 755 {
 756     FIXME("(%p, %d): stub\n", iface, celt);
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Reset(
 761     IEnumVARIANT *iface)
 762 {
 763     xmlelem_collection *This = impl_from_IEnumVARIANT(iface);
 764     This->current = This->node->children;
 765     return S_OK;
 766 }
 767
 768 static HRESULT WINAPI xmlelem_collection_IEnumVARIANT_Clone(
 769     IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
 770 {
 771     FIXME("(%p, %p): stub\n", iface, ppEnum);
 772     return E_NOTIMPL;
 773 }
 774
 775 static const struct IEnumVARIANTVtbl xmlelem_collection_IEnumVARIANTvtbl =
 776 {
 777     xmlelem_collection_IEnumVARIANT_QueryInterface,
 778     xmlelem_collection_IEnumVARIANT_AddRef,
 779     xmlelem_collection_IEnumVARIANT_Release,
 780     xmlelem_collection_IEnumVARIANT_Next,
 781     xmlelem_collection_IEnumVARIANT_Skip,
 782     xmlelem_collection_IEnumVARIANT_Reset,
 783     xmlelem_collection_IEnumVARIANT_Clone
 784 };
 785
 786 static HRESULT XMLElementCollection_create(IUnknown *pUnkOuter, xmlNodePtr node, LPVOID *ppObj)
 787 {
 788     xmlelem_collection *collection;
 789
 790     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 791
 792     *ppObj = NULL;
 793
 794     if (!node->children)
 795         return S_FALSE;
 796
 797     collection = heap_alloc(sizeof (*collection));
 798     if(!collection)
 799         return E_OUTOFMEMORY;
 800
 801     collection->lpVtbl = &xmlelem_collection_vtbl;
 802     collection->lpvtblIEnumVARIANT = &xmlelem_collection_IEnumVARIANTvtbl;
 803     collection->ref = 1;
 804     collection->length = 0;
 805     collection->node = node;
 806     collection->current = node->children;
 807     xmlelem_collection_updatelength(collection);
 808
 809     *ppObj = &collection->lpVtbl;
 810
 811     TRACE("returning iface %p\n", *ppObj);
 812     return S_OK;
 813 }
 814
 815 #endif