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