dlls/mshtml/htmlelemcol.c

   1 /*
   2  * Copyright 2006-2008 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 #include <assert.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28
  29 #include "wine/debug.h"
  30
  31 #include "mshtml_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  34
  35 typedef struct {
  36     DispatchEx dispex;
  37     IHTMLElementCollection IHTMLElementCollection_iface;
  38
  39     HTMLElement **elems;
  40     DWORD len;
  41
  42     LONG ref;
  43 } HTMLElementCollection;
  44
  45 typedef struct {
  46     IEnumVARIANT IEnumVARIANT_iface;
  47
  48     LONG ref;
  49
  50     ULONG iter;
  51     HTMLElementCollection *col;
  52 } HTMLElementCollectionEnum;
  53
  54 typedef struct {
  55     HTMLElement **buf;
  56     DWORD len;
  57     DWORD size;
  58 } elem_vector_t;
  59
  60 /* FIXME: Handle it better way */
  61 static inline HTMLElement *elem_from_HTMLDOMNode(HTMLDOMNode *iface)
  62 {
  63     return CONTAINING_RECORD(iface, HTMLElement, node);
  64 }
  65
  66 static IHTMLElementCollection *HTMLElementCollection_Create(HTMLElement **elems, DWORD len);
  67
  68 static void elem_vector_add(elem_vector_t *buf, HTMLElement *elem)
  69 {
  70     if(buf->len == buf->size) {
  71         buf->size <<= 1;
  72         buf->buf = heap_realloc(buf->buf, buf->size*sizeof(HTMLElement*));
  73     }
  74
  75     buf->buf[buf->len++] = elem;
  76 }
  77
  78 static void elem_vector_normalize(elem_vector_t *buf)
  79 {
  80     if(!buf->len) {
  81         heap_free(buf->buf);
  82         buf->buf = NULL;
  83     }else if(buf->size > buf->len) {
  84         buf->buf = heap_realloc(buf->buf, buf->len*sizeof(HTMLElement*));
  85     }
  86
  87     buf->size = buf->len;
  88 }
  89
  90 static inline BOOL is_elem_node(nsIDOMNode *node)
  91 {
  92     UINT16 type=0;
  93
  94     nsIDOMNode_GetNodeType(node, &type);
  95
  96     return type == ELEMENT_NODE || type == COMMENT_NODE;
  97 }
  98
  99 static inline HTMLElementCollectionEnum *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
 100 {
 101     return CONTAINING_RECORD(iface, HTMLElementCollectionEnum, IEnumVARIANT_iface);
 102 }
 103
 104 static HRESULT WINAPI HTMLElementCollectionEnum_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **ppv)
 105 {
 106     HTMLElementCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 107
 108     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 109
 110     if(IsEqualGUID(riid, &IID_IUnknown)) {
 111         *ppv = &This->IEnumVARIANT_iface;
 112     }else if(IsEqualGUID(riid, &IID_IEnumVARIANT)) {
 113         *ppv = &This->IEnumVARIANT_iface;
 114     }else {
 115         FIXME("Unsupported iface %s\n", debugstr_mshtml_guid(riid));
 116         *ppv = NULL;
 117         return E_NOINTERFACE;
 118     }
 119
 120     IUnknown_AddRef((IUnknown*)*ppv);
 121     return S_OK;
 122 }
 123
 124 static ULONG WINAPI HTMLElementCollectionEnum_AddRef(IEnumVARIANT *iface)
 125 {
 126     HTMLElementCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 127     LONG ref = InterlockedIncrement(&This->ref);
 128
 129     TRACE("(%p) ref=%d\n", This, ref);
 130
 131     return ref;
 132 }
 133
 134 static ULONG WINAPI HTMLElementCollectionEnum_Release(IEnumVARIANT *iface)
 135 {
 136     HTMLElementCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 137     LONG ref = InterlockedDecrement(&This->ref);
 138
 139     TRACE("(%p) ref=%d\n", This, ref);
 140
 141     if(!ref) {
 142         IHTMLElementCollection_Release(&This->col->IHTMLElementCollection_iface);
 143         heap_free(This);
 144     }
 145
 146     return ref;
 147 }
 148
 149 static HRESULT WINAPI HTMLElementCollectionEnum_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
 150 {
 151     HTMLElementCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 152     ULONG fetched = 0;
 153
 154     TRACE("(%p)->(%d %p %p)\n", This, celt, rgVar, pCeltFetched);
 155
 156     while(This->iter+fetched < This->col->len && fetched < celt) {
 157         V_VT(rgVar+fetched) = VT_DISPATCH;
 158         V_DISPATCH(rgVar+fetched) = (IDispatch*)&This->col->elems[This->iter+fetched]->IHTMLElement_iface;
 159         IDispatch_AddRef(V_DISPATCH(rgVar+fetched));
 160         fetched++;
 161     }
 162
 163     This->iter += fetched;
 164     if(pCeltFetched)
 165         *pCeltFetched = fetched;
 166     return fetched == celt ? S_OK : S_FALSE;
 167 }
 168
 169 static HRESULT WINAPI HTMLElementCollectionEnum_Skip(IEnumVARIANT *iface, ULONG celt)
 170 {
 171     HTMLElementCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 172
 173     TRACE("(%p)->(%d)\n", This, celt);
 174
 175     if(This->iter + celt > This->col->len) {
 176         This->iter = This->col->len;
 177         return S_FALSE;
 178     }
 179
 180     This->iter += celt;
 181     return S_OK;
 182 }
 183
 184 static HRESULT WINAPI HTMLElementCollectionEnum_Reset(IEnumVARIANT *iface)
 185 {
 186     HTMLElementCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 187
 188     TRACE("(%p)->()\n", This);
 189
 190     This->iter = 0;
 191     return S_OK;
 192 }
 193
 194 static HRESULT WINAPI HTMLElementCollectionEnum_Clone(IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
 195 {
 196     HTMLElementCollectionEnum *This = impl_from_IEnumVARIANT(iface);
 197     FIXME("(%p)->(%p)\n", This, ppEnum);
 198     return E_NOTIMPL;
 199 }
 200
 201 static const IEnumVARIANTVtbl HTMLElementCollectionEnumVtbl = {
 202     HTMLElementCollectionEnum_QueryInterface,
 203     HTMLElementCollectionEnum_AddRef,
 204     HTMLElementCollectionEnum_Release,
 205     HTMLElementCollectionEnum_Next,
 206     HTMLElementCollectionEnum_Skip,
 207     HTMLElementCollectionEnum_Reset,
 208     HTMLElementCollectionEnum_Clone
 209 };
 210
 211 static inline HTMLElementCollection *impl_from_IHTMLElementCollection(IHTMLElementCollection *iface)
 212 {
 213     return CONTAINING_RECORD(iface, HTMLElementCollection, IHTMLElementCollection_iface);
 214 }
 215
 216 static HRESULT WINAPI HTMLElementCollection_QueryInterface(IHTMLElementCollection *iface,
 217                                                            REFIID riid, void **ppv)
 218 {
 219     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 220
 221     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 222
 223     if(IsEqualGUID(&IID_IUnknown, riid)) {
 224         *ppv = &This->IHTMLElementCollection_iface;
 225     }else if(IsEqualGUID(&IID_IHTMLElementCollection, riid)) {
 226         *ppv = &This->IHTMLElementCollection_iface;
 227     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 228         return *ppv ? S_OK : E_NOINTERFACE;
 229     }else {
 230         *ppv = NULL;
 231         FIXME("Unsupported iface %s\n", debugstr_mshtml_guid(riid));
 232         return E_NOINTERFACE;
 233     }
 234
 235     IHTMLElementCollection_AddRef(&This->IHTMLElementCollection_iface);
 236     return S_OK;
 237 }
 238
 239 static ULONG WINAPI HTMLElementCollection_AddRef(IHTMLElementCollection *iface)
 240 {
 241     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 242     LONG ref = InterlockedIncrement(&This->ref);
 243
 244     TRACE("(%p) ref=%d\n", This, ref);
 245
 246     return ref;
 247 }
 248
 249 static ULONG WINAPI HTMLElementCollection_Release(IHTMLElementCollection *iface)
 250 {
 251     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 252     LONG ref = InterlockedDecrement(&This->ref);
 253
 254     TRACE("(%p) ref=%d\n", This, ref);
 255
 256     if(!ref) {
 257         unsigned i;
 258
 259         for(i=0; i < This->len; i++)
 260             node_release(&This->elems[i]->node);
 261         heap_free(This->elems);
 262
 263         release_dispex(&This->dispex);
 264         heap_free(This);
 265     }
 266
 267     return ref;
 268 }
 269
 270 static HRESULT WINAPI HTMLElementCollection_GetTypeInfoCount(IHTMLElementCollection *iface,
 271                                                              UINT *pctinfo)
 272 {
 273     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 274     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 275 }
 276
 277 static HRESULT WINAPI HTMLElementCollection_GetTypeInfo(IHTMLElementCollection *iface,
 278         UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 279 {
 280     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 281     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 282 }
 283
 284 static HRESULT WINAPI HTMLElementCollection_GetIDsOfNames(IHTMLElementCollection *iface,
 285         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 286 {
 287     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 288     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 289             lcid, rgDispId);
 290 }
 291
 292 static HRESULT WINAPI HTMLElementCollection_Invoke(IHTMLElementCollection *iface,
 293         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 294         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 295 {
 296     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 297     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 298             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 299 }
 300
 301 static HRESULT WINAPI HTMLElementCollection_toString(IHTMLElementCollection *iface,
 302                                                      BSTR *String)
 303 {
 304     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 305     FIXME("(%p)->(%p)\n", This, String);
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI HTMLElementCollection_put_length(IHTMLElementCollection *iface,
 310                                                        LONG v)
 311 {
 312     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 313     FIXME("(%p)->(%d)\n", This, v);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI HTMLElementCollection_get_length(IHTMLElementCollection *iface,
 318                                                        LONG *p)
 319 {
 320     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 321
 322     TRACE("(%p)->(%p)\n", This, p);
 323
 324     *p = This->len;
 325     return S_OK;
 326 }
 327
 328 static HRESULT WINAPI HTMLElementCollection_get__newEnum(IHTMLElementCollection *iface,
 329                                                          IUnknown **p)
 330 {
 331     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 332     HTMLElementCollectionEnum *ret;
 333
 334     TRACE("(%p)->(%p)\n", This, p);
 335
 336     ret = heap_alloc(sizeof(*ret));
 337     if(!ret)
 338         return E_OUTOFMEMORY;
 339
 340     ret->IEnumVARIANT_iface.lpVtbl = &HTMLElementCollectionEnumVtbl;
 341     ret->ref = 1;
 342     ret->iter = 0;
 343
 344     IHTMLElementCollection_AddRef(&This->IHTMLElementCollection_iface);
 345     ret->col = This;
 346
 347     *p = (IUnknown*)&ret->IEnumVARIANT_iface;
 348     return S_OK;
 349 }
 350
 351 static BOOL is_elem_id(HTMLElement *elem, LPCWSTR name)
 352 {
 353     BSTR elem_id;
 354     HRESULT hres;
 355
 356     hres = IHTMLElement_get_id(&elem->IHTMLElement_iface, &elem_id);
 357     if(FAILED(hres)){
 358         WARN("IHTMLElement_get_id failed: 0x%08x\n", hres);
 359         return FALSE;
 360     }
 361
 362     if(elem_id && !strcmpW(elem_id, name)) {
 363         SysFreeString(elem_id);
 364         return TRUE;
 365     }
 366
 367     SysFreeString(elem_id);
 368     return FALSE;
 369 }
 370
 371 static BOOL is_elem_name(HTMLElement *elem, LPCWSTR name)
 372 {
 373     const PRUnichar *str;
 374     nsAString nsstr;
 375     BOOL ret = FALSE;
 376     nsresult nsres;
 377
 378     static const PRUnichar nameW[] = {'n','a','m','e',0};
 379
 380     if(!elem->nselem)
 381         return FALSE;
 382
 383     nsAString_Init(&nsstr, NULL);
 384     nsIDOMHTMLElement_GetId(elem->nselem, &nsstr);
 385     nsAString_GetData(&nsstr, &str);
 386     if(!strcmpiW(str, name)) {
 387         nsAString_Finish(&nsstr);
 388         return TRUE;
 389     }
 390
 391     nsres = get_elem_attr_value(elem->nselem, nameW, &nsstr, &str);
 392     if(NS_SUCCEEDED(nsres)) {
 393         ret = !strcmpiW(str, name);
 394         nsAString_Finish(&nsstr);
 395     }
 396
 397     return ret;
 398 }
 399
 400 static HRESULT get_item_idx(HTMLElementCollection *This, UINT idx, IDispatch **ret)
 401 {
 402     if(idx < This->len) {
 403         *ret = (IDispatch*)This->elems[idx];
 404         IDispatch_AddRef(*ret);
 405     }
 406
 407     return S_OK;
 408 }
 409
 410 static HRESULT WINAPI HTMLElementCollection_item(IHTMLElementCollection *iface,
 411         VARIANT name, VARIANT index, IDispatch **pdisp)
 412 {
 413     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 414     HRESULT hres = S_OK;
 415
 416     TRACE("(%p)->(%s %s %p)\n", This, debugstr_variant(&name), debugstr_variant(&index), pdisp);
 417
 418     *pdisp = NULL;
 419
 420     switch(V_VT(&name)) {
 421     case VT_I4:
 422         if(V_I4(&name) < 0)
 423             return E_INVALIDARG;
 424         hres = get_item_idx(This, V_I4(&name), pdisp);
 425         break;
 426
 427     case VT_UINT:
 428         hres = get_item_idx(This, V_UINT(&name), pdisp);
 429         break;
 430
 431     case VT_BSTR: {
 432         DWORD i;
 433
 434         if(V_VT(&index) == VT_I4) {
 435             LONG idx = V_I4(&index);
 436
 437             if(idx < 0)
 438                 return E_INVALIDARG;
 439
 440             for(i=0; i<This->len; i++) {
 441                 if(is_elem_name(This->elems[i], V_BSTR(&name)) && !idx--)
 442                     break;
 443             }
 444
 445             if(i != This->len) {
 446                 *pdisp = (IDispatch*)&This->elems[i]->IHTMLElement_iface;
 447                 IDispatch_AddRef(*pdisp);
 448             }
 449         }else {
 450             elem_vector_t buf = {NULL, 0, 8};
 451
 452             buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 453
 454             for(i=0; i<This->len; i++) {
 455                 if(is_elem_name(This->elems[i], V_BSTR(&name))) {
 456                     node_addref(&This->elems[i]->node);
 457                     elem_vector_add(&buf, This->elems[i]);
 458                 }
 459             }
 460
 461             if(buf.len > 1) {
 462                 elem_vector_normalize(&buf);
 463                 *pdisp = (IDispatch*)HTMLElementCollection_Create(buf.buf, buf.len);
 464             }else {
 465                 if(buf.len == 1) {
 466                     /* Already AddRef-ed */
 467                     *pdisp = (IDispatch*)&buf.buf[0]->IHTMLElement_iface;
 468                 }
 469
 470                 heap_free(buf.buf);
 471             }
 472         }
 473         break;
 474     }
 475
 476     default:
 477         FIXME("Unsupported name %s\n", debugstr_variant(&name));
 478         hres = E_NOTIMPL;
 479     }
 480
 481     if(SUCCEEDED(hres))
 482         TRACE("returning %p\n", *pdisp);
 483     return hres;
 484 }
 485
 486 static HRESULT WINAPI HTMLElementCollection_tags(IHTMLElementCollection *iface,
 487                                                  VARIANT tagName, IDispatch **pdisp)
 488 {
 489     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 490     DWORD i;
 491     nsAString tag_str;
 492     const PRUnichar *tag;
 493     elem_vector_t buf = {NULL, 0, 8};
 494
 495     if(V_VT(&tagName) != VT_BSTR) {
 496         WARN("Invalid arg\n");
 497         return DISP_E_MEMBERNOTFOUND;
 498     }
 499
 500     TRACE("(%p)->(%s %p)\n", This, debugstr_w(V_BSTR(&tagName)), pdisp);
 501
 502     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 503
 504     nsAString_Init(&tag_str, NULL);
 505
 506     for(i=0; i<This->len; i++) {
 507         if(!This->elems[i]->nselem)
 508             continue;
 509
 510         nsIDOMHTMLElement_GetTagName(This->elems[i]->nselem, &tag_str);
 511         nsAString_GetData(&tag_str, &tag);
 512
 513         if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, tag, -1,
 514                           V_BSTR(&tagName), -1) == CSTR_EQUAL) {
 515             node_addref(&This->elems[i]->node);
 516             elem_vector_add(&buf, This->elems[i]);
 517         }
 518     }
 519
 520     nsAString_Finish(&tag_str);
 521     elem_vector_normalize(&buf);
 522
 523     TRACE("fount %d tags\n", buf.len);
 524
 525     *pdisp = (IDispatch*)HTMLElementCollection_Create(buf.buf, buf.len);
 526     return S_OK;
 527 }
 528
 529 static const IHTMLElementCollectionVtbl HTMLElementCollectionVtbl = {
 530     HTMLElementCollection_QueryInterface,
 531     HTMLElementCollection_AddRef,
 532     HTMLElementCollection_Release,
 533     HTMLElementCollection_GetTypeInfoCount,
 534     HTMLElementCollection_GetTypeInfo,
 535     HTMLElementCollection_GetIDsOfNames,
 536     HTMLElementCollection_Invoke,
 537     HTMLElementCollection_toString,
 538     HTMLElementCollection_put_length,
 539     HTMLElementCollection_get_length,
 540     HTMLElementCollection_get__newEnum,
 541     HTMLElementCollection_item,
 542     HTMLElementCollection_tags
 543 };
 544
 545 static inline HTMLElementCollection *impl_from_DispatchEx(DispatchEx *iface)
 546 {
 547     return CONTAINING_RECORD(iface, HTMLElementCollection, dispex);
 548 }
 549
 550 #define DISPID_ELEMCOL_0 MSHTML_DISPID_CUSTOM_MIN
 551
 552 static HRESULT HTMLElementCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
 553 {
 554     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
 555     WCHAR *ptr;
 556     DWORD idx=0;
 557
 558     if(!*name)
 559         return DISP_E_UNKNOWNNAME;
 560
 561     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
 562         idx = idx*10 + (*ptr-'0');
 563
 564     if(*ptr) {
 565         /* the name contains alpha characters, so search by name & id */
 566         for(idx = 0; idx < This->len; ++idx) {
 567             if(is_elem_id(This->elems[idx], name) ||
 568                     is_elem_name(This->elems[idx], name))
 569                 break;
 570         }
 571     }
 572
 573     if(idx >= This->len)
 574         return DISP_E_UNKNOWNNAME;
 575
 576     *dispid = DISPID_ELEMCOL_0 + idx;
 577     TRACE("ret %x\n", *dispid);
 578     return S_OK;
 579 }
 580
 581 static HRESULT HTMLElementCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 582         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 583 {
 584     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
 585     DWORD idx;
 586
 587     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
 588
 589     idx = id - DISPID_ELEMCOL_0;
 590     if(idx >= This->len)
 591         return DISP_E_UNKNOWNNAME;
 592
 593     switch(flags) {
 594     case DISPATCH_PROPERTYGET:
 595         V_VT(res) = VT_DISPATCH;
 596         V_DISPATCH(res) = (IDispatch*)&This->elems[idx]->IHTMLElement_iface;
 597         IHTMLElement_AddRef(&This->elems[idx]->IHTMLElement_iface);
 598         break;
 599     default:
 600         FIXME("unimplemented flags %x\n", flags);
 601         return E_NOTIMPL;
 602     }
 603
 604     return S_OK;
 605 }
 606
 607 static const dispex_static_data_vtbl_t HTMLElementColection_dispex_vtbl = {
 608     NULL,
 609     HTMLElementCollection_get_dispid,
 610     HTMLElementCollection_invoke,
 611     NULL
 612 };
 613
 614 static const tid_t HTMLElementCollection_iface_tids[] = {
 615     IHTMLElementCollection_tid,
 616     0
 617 };
 618
 619 static dispex_static_data_t HTMLElementCollection_dispex = {
 620     &HTMLElementColection_dispex_vtbl,
 621     DispHTMLElementCollection_tid,
 622     NULL,
 623     HTMLElementCollection_iface_tids
 624 };
 625
 626 static void create_all_list(HTMLDocumentNode *doc, HTMLDOMNode *elem, elem_vector_t *buf)
 627 {
 628     nsIDOMNodeList *nsnode_list;
 629     nsIDOMNode *iter;
 630     UINT32 list_len = 0, i;
 631     nsresult nsres;
 632     HRESULT hres;
 633
 634     nsres = nsIDOMNode_GetChildNodes(elem->nsnode, &nsnode_list);
 635     if(NS_FAILED(nsres)) {
 636         ERR("GetChildNodes failed: %08x\n", nsres);
 637         return;
 638     }
 639
 640     nsIDOMNodeList_GetLength(nsnode_list, &list_len);
 641     if(!list_len)
 642         return;
 643
 644     for(i=0; i<list_len; i++) {
 645         nsres = nsIDOMNodeList_Item(nsnode_list, i, &iter);
 646         if(NS_FAILED(nsres)) {
 647             ERR("Item failed: %08x\n", nsres);
 648             continue;
 649         }
 650
 651         if(is_elem_node(iter)) {
 652             HTMLDOMNode *node;
 653
 654             hres = get_node(doc, iter, TRUE, &node);
 655             if(FAILED(hres)) {
 656                 FIXME("get_node failed: %08x\n", hres);
 657                 continue;
 658             }
 659
 660             elem_vector_add(buf, elem_from_HTMLDOMNode(node));
 661             create_all_list(doc, node, buf);
 662         }
 663     }
 664 }
 665
 666 IHTMLElementCollection *create_all_collection(HTMLDOMNode *node, BOOL include_root)
 667 {
 668     elem_vector_t buf = {NULL, 0, 8};
 669
 670     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 671
 672     if(include_root) {
 673         node_addref(node);
 674         elem_vector_add(&buf, elem_from_HTMLDOMNode(node));
 675     }
 676     create_all_list(node->doc, node, &buf);
 677     elem_vector_normalize(&buf);
 678
 679     return HTMLElementCollection_Create(buf.buf, buf.len);
 680 }
 681
 682 IHTMLElementCollection *create_collection_from_nodelist(HTMLDocumentNode *doc, nsIDOMNodeList *nslist)
 683 {
 684     UINT32 length = 0, i;
 685     HTMLDOMNode *node;
 686     elem_vector_t buf;
 687     HRESULT hres;
 688
 689     nsIDOMNodeList_GetLength(nslist, &length);
 690
 691     buf.len = 0;
 692     buf.size = length;
 693     if(length) {
 694         nsIDOMNode *nsnode;
 695
 696         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 697
 698         for(i=0; i<length; i++) {
 699             nsIDOMNodeList_Item(nslist, i, &nsnode);
 700             if(is_elem_node(nsnode)) {
 701                 hres = get_node(doc, nsnode, TRUE, &node);
 702                 if(FAILED(hres))
 703                     continue;
 704                 buf.buf[buf.len++] = elem_from_HTMLDOMNode(node);
 705             }
 706             nsIDOMNode_Release(nsnode);
 707         }
 708
 709         elem_vector_normalize(&buf);
 710     }else {
 711         buf.buf = NULL;
 712     }
 713
 714     return HTMLElementCollection_Create(buf.buf, buf.len);
 715 }
 716
 717 IHTMLElementCollection *create_collection_from_htmlcol(HTMLDocumentNode *doc, nsIDOMHTMLCollection *nscol)
 718 {
 719     UINT32 length = 0, i;
 720     elem_vector_t buf;
 721     HTMLDOMNode *node;
 722     HRESULT hres = S_OK;
 723
 724     nsIDOMHTMLCollection_GetLength(nscol, &length);
 725
 726     buf.len = buf.size = length;
 727     if(buf.len) {
 728         nsIDOMNode *nsnode;
 729
 730         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 731
 732         for(i=0; i<length; i++) {
 733             nsIDOMHTMLCollection_Item(nscol, i, &nsnode);
 734             hres = get_node(doc, nsnode, TRUE, &node);
 735             nsIDOMNode_Release(nsnode);
 736             if(FAILED(hres))
 737                 break;
 738             buf.buf[i] = elem_from_HTMLDOMNode(node);
 739         }
 740     }else {
 741         buf.buf = NULL;
 742     }
 743
 744     if(FAILED(hres)) {
 745         heap_free(buf.buf);
 746         return NULL;
 747     }
 748
 749     return HTMLElementCollection_Create(buf.buf, buf.len);
 750 }
 751
 752 HRESULT get_elem_source_index(HTMLElement *elem, LONG *ret)
 753 {
 754     elem_vector_t buf = {NULL, 0, 8};
 755     nsIDOMNode *parent_node, *iter;
 756     UINT16 parent_type;
 757     HTMLDOMNode *node;
 758     int i;
 759     nsresult nsres;
 760     HRESULT hres;
 761
 762     iter = elem->node.nsnode;
 763     nsIDOMNode_AddRef(iter);
 764
 765     /* Find document or document fragment parent. */
 766     while(1) {
 767         nsres = nsIDOMNode_GetParentNode(iter, &parent_node);
 768         nsIDOMNode_Release(iter);
 769         assert(nsres == NS_OK);
 770         if(!parent_node)
 771             break;
 772
 773         nsres = nsIDOMNode_GetNodeType(parent_node, &parent_type);
 774         assert(nsres == NS_OK);
 775
 776         if(parent_type != ELEMENT_NODE) {
 777             if(parent_type != DOCUMENT_NODE && parent_type != DOCUMENT_FRAGMENT_NODE)
 778                 FIXME("Unexpected parent_type %d\n", parent_type);
 779             break;
 780         }
 781
 782         iter = parent_node;
 783     }
 784
 785     if(!parent_node) {
 786         *ret = -1;
 787         return S_OK;
 788     }
 789
 790     hres = get_node(elem->node.doc, parent_node, TRUE, &node);
 791     nsIDOMNode_Release(parent_node);
 792     if(FAILED(hres))
 793         return hres;
 794
 795
 796     /* Create all children collection and find the element in it.
 797      * This could be optimized if we ever find the reason. */
 798     buf.buf = heap_alloc(buf.size*sizeof(*buf.buf));
 799     if(!buf.buf) {
 800         IHTMLDOMNode_Release(&node->IHTMLDOMNode_iface);
 801         return E_OUTOFMEMORY;
 802     }
 803
 804     create_all_list(elem->node.doc, node, &buf);
 805
 806     for(i=0; i < buf.len; i++) {
 807         if(buf.buf[i] == elem)
 808             break;
 809     }
 810     IHTMLDOMNode_Release(&node->IHTMLDOMNode_iface);
 811     heap_free(buf.buf);
 812     if(i == buf.len) {
 813         FIXME("The element is not in parent's child list?\n");
 814         return E_UNEXPECTED;
 815     }
 816
 817     *ret = i;
 818     return S_OK;
 819 }
 820
 821 static IHTMLElementCollection *HTMLElementCollection_Create(HTMLElement **elems, DWORD len)
 822 {
 823     HTMLElementCollection *ret = heap_alloc_zero(sizeof(HTMLElementCollection));
 824
 825     ret->IHTMLElementCollection_iface.lpVtbl = &HTMLElementCollectionVtbl;
 826     ret->ref = 1;
 827     ret->elems = elems;
 828     ret->len = len;
 829
 830     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLElementCollection_iface,
 831             &HTMLElementCollection_dispex);
 832
 833     TRACE("ret=%p len=%d\n", ret, len);
 834
 835     return &ret->IHTMLElementCollection_iface;
 836 }