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**,DWORD,compat_mode_t);
  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 && !wcscmp(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     if(!elem->dom_element)
 379         return FALSE;
 380
 381     nsAString_Init(&nsstr, NULL);
 382     nsIDOMElement_GetId(elem->dom_element, &nsstr);
 383     nsAString_GetData(&nsstr, &str);
 384     if(!wcsicmp(str, name)) {
 385         nsAString_Finish(&nsstr);
 386         return TRUE;
 387     }
 388
 389     nsres = get_elem_attr_value(elem->dom_element, L"name", &nsstr, &str);
 390     if(NS_SUCCEEDED(nsres)) {
 391         ret = !wcsicmp(str, name);
 392         nsAString_Finish(&nsstr);
 393     }
 394
 395     return ret;
 396 }
 397
 398 static HRESULT get_item_idx(HTMLElementCollection *This, UINT idx, IDispatch **ret)
 399 {
 400     if(idx < This->len) {
 401         *ret = (IDispatch*)&This->elems[idx]->node.event_target.dispex.IDispatchEx_iface;
 402         IDispatch_AddRef(*ret);
 403     }
 404
 405     return S_OK;
 406 }
 407
 408 static HRESULT WINAPI HTMLElementCollection_item(IHTMLElementCollection *iface,
 409         VARIANT name, VARIANT index, IDispatch **pdisp)
 410 {
 411     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 412     HRESULT hres = S_OK;
 413
 414     TRACE("(%p)->(%s %s %p)\n", This, debugstr_variant(&name), debugstr_variant(&index), pdisp);
 415
 416     *pdisp = NULL;
 417
 418     switch(V_VT(&name)) {
 419     case VT_I4:
 420     case VT_INT:
 421         if(V_I4(&name) < 0)
 422             return dispex_compat_mode(&This->dispex) < COMPAT_MODE_IE9 ? E_INVALIDARG : S_OK;
 423         hres = get_item_idx(This, V_I4(&name), pdisp);
 424         break;
 425
 426     case VT_UI4:
 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                                                                   dispex_compat_mode(&This->dispex));
 465             }else {
 466                 if(buf.len == 1) {
 467                     /* Already AddRef-ed */
 468                     *pdisp = (IDispatch*)&buf.buf[0]->IHTMLElement_iface;
 469                 }
 470
 471                 heap_free(buf.buf);
 472             }
 473         }
 474         break;
 475     }
 476
 477     default:
 478         FIXME("Unsupported name %s\n", debugstr_variant(&name));
 479         hres = E_NOTIMPL;
 480     }
 481
 482     if(SUCCEEDED(hres))
 483         TRACE("returning %p\n", *pdisp);
 484     return hres;
 485 }
 486
 487 static HRESULT WINAPI HTMLElementCollection_tags(IHTMLElementCollection *iface,
 488                                                  VARIANT tagName, IDispatch **pdisp)
 489 {
 490     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 491     DWORD i;
 492     nsAString tag_str;
 493     const PRUnichar *tag;
 494     elem_vector_t buf = {NULL, 0, 8};
 495
 496     if(V_VT(&tagName) != VT_BSTR) {
 497         WARN("Invalid arg\n");
 498         return DISP_E_MEMBERNOTFOUND;
 499     }
 500
 501     TRACE("(%p)->(%s %p)\n", This, debugstr_w(V_BSTR(&tagName)), pdisp);
 502
 503     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 504
 505     nsAString_Init(&tag_str, NULL);
 506
 507     for(i=0; i<This->len; i++) {
 508         if(!This->elems[i]->dom_element)
 509             continue;
 510
 511         nsIDOMElement_GetTagName(This->elems[i]->dom_element, &tag_str);
 512         nsAString_GetData(&tag_str, &tag);
 513
 514         if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, tag, -1,
 515                           V_BSTR(&tagName), -1) == CSTR_EQUAL) {
 516             node_addref(&This->elems[i]->node);
 517             elem_vector_add(&buf, This->elems[i]);
 518         }
 519     }
 520
 521     nsAString_Finish(&tag_str);
 522     elem_vector_normalize(&buf);
 523
 524     TRACE("found %d tags\n", buf.len);
 525
 526     *pdisp = (IDispatch*)HTMLElementCollection_Create(buf.buf, buf.len,
 527                                                       dispex_compat_mode(&This->dispex));
 528     return S_OK;
 529 }
 530
 531 static const IHTMLElementCollectionVtbl HTMLElementCollectionVtbl = {
 532     HTMLElementCollection_QueryInterface,
 533     HTMLElementCollection_AddRef,
 534     HTMLElementCollection_Release,
 535     HTMLElementCollection_GetTypeInfoCount,
 536     HTMLElementCollection_GetTypeInfo,
 537     HTMLElementCollection_GetIDsOfNames,
 538     HTMLElementCollection_Invoke,
 539     HTMLElementCollection_toString,
 540     HTMLElementCollection_put_length,
 541     HTMLElementCollection_get_length,
 542     HTMLElementCollection_get__newEnum,
 543     HTMLElementCollection_item,
 544     HTMLElementCollection_tags
 545 };
 546
 547 static inline HTMLElementCollection *impl_from_DispatchEx(DispatchEx *iface)
 548 {
 549     return CONTAINING_RECORD(iface, HTMLElementCollection, dispex);
 550 }
 551
 552 #define DISPID_ELEMCOL_0 MSHTML_DISPID_CUSTOM_MIN
 553
 554 static HRESULT HTMLElementCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
 555 {
 556     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
 557     WCHAR *ptr;
 558     DWORD idx=0;
 559
 560     if(!*name)
 561         return DISP_E_UNKNOWNNAME;
 562
 563     for(ptr = name; *ptr && is_digit(*ptr); ptr++)
 564         idx = idx*10 + (*ptr-'0');
 565
 566     if(*ptr) {
 567         /* the name contains alpha characters, so search by name & id */
 568         for(idx = 0; idx < This->len; ++idx) {
 569             if(is_elem_id(This->elems[idx], name) ||
 570                     is_elem_name(This->elems[idx], name))
 571                 break;
 572         }
 573     }
 574
 575     if(idx >= This->len)
 576         return DISP_E_UNKNOWNNAME;
 577
 578     *dispid = DISPID_ELEMCOL_0 + idx;
 579     TRACE("ret %x\n", *dispid);
 580     return S_OK;
 581 }
 582
 583 static HRESULT HTMLElementCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 584         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 585 {
 586     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
 587     DWORD idx;
 588
 589     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
 590
 591     idx = id - DISPID_ELEMCOL_0;
 592     if(idx >= This->len)
 593         return DISP_E_UNKNOWNNAME;
 594
 595     switch(flags) {
 596     case DISPATCH_PROPERTYGET:
 597         V_VT(res) = VT_DISPATCH;
 598         V_DISPATCH(res) = (IDispatch*)&This->elems[idx]->IHTMLElement_iface;
 599         IHTMLElement_AddRef(&This->elems[idx]->IHTMLElement_iface);
 600         break;
 601     default:
 602         FIXME("unimplemented flags %x\n", flags);
 603         return E_NOTIMPL;
 604     }
 605
 606     return S_OK;
 607 }
 608
 609 static const dispex_static_data_vtbl_t HTMLElementColection_dispex_vtbl = {
 610     NULL,
 611     HTMLElementCollection_get_dispid,
 612     HTMLElementCollection_invoke,
 613     NULL
 614 };
 615
 616 static const tid_t HTMLElementCollection_iface_tids[] = {
 617     IHTMLElementCollection_tid,
 618     0
 619 };
 620
 621 static dispex_static_data_t HTMLElementCollection_dispex = {
 622     &HTMLElementColection_dispex_vtbl,
 623     DispHTMLElementCollection_tid,
 624     HTMLElementCollection_iface_tids
 625 };
 626
 627 static void create_all_list(HTMLDOMNode *elem, elem_vector_t *buf)
 628 {
 629     nsIDOMNodeList *nsnode_list;
 630     nsIDOMNode *iter;
 631     UINT32 list_len = 0, i;
 632     nsresult nsres;
 633     HRESULT hres;
 634
 635     nsres = nsIDOMNode_GetChildNodes(elem->nsnode, &nsnode_list);
 636     if(NS_FAILED(nsres)) {
 637         ERR("GetChildNodes failed: %08x\n", nsres);
 638         return;
 639     }
 640
 641     nsIDOMNodeList_GetLength(nsnode_list, &list_len);
 642     if(!list_len)
 643         return;
 644
 645     for(i=0; i<list_len; i++) {
 646         nsres = nsIDOMNodeList_Item(nsnode_list, i, &iter);
 647         if(NS_FAILED(nsres)) {
 648             ERR("Item failed: %08x\n", nsres);
 649             continue;
 650         }
 651
 652         if(is_elem_node(iter)) {
 653             HTMLDOMNode *node;
 654
 655             hres = get_node(iter, TRUE, &node);
 656             if(FAILED(hres)) {
 657                 FIXME("get_node failed: %08x\n", hres);
 658                 continue;
 659             }
 660
 661             elem_vector_add(buf, elem_from_HTMLDOMNode(node));
 662             create_all_list(node, buf);
 663         }
 664     }
 665 }
 666
 667 IHTMLElementCollection *create_all_collection(HTMLDOMNode *node, BOOL include_root)
 668 {
 669     elem_vector_t buf = {NULL, 0, 8};
 670
 671     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 672
 673     if(include_root) {
 674         node_addref(node);
 675         elem_vector_add(&buf, elem_from_HTMLDOMNode(node));
 676     }
 677     create_all_list(node, &buf);
 678     elem_vector_normalize(&buf);
 679
 680     return HTMLElementCollection_Create(buf.buf, buf.len,
 681                                         dispex_compat_mode(&node->event_target.dispex));
 682 }
 683
 684 IHTMLElementCollection *create_collection_from_nodelist(nsIDOMNodeList *nslist, compat_mode_t compat_mode)
 685 {
 686     UINT32 length = 0, i;
 687     HTMLDOMNode *node;
 688     elem_vector_t buf;
 689     HRESULT hres;
 690
 691     nsIDOMNodeList_GetLength(nslist, &length);
 692
 693     buf.len = 0;
 694     buf.size = length;
 695     if(length) {
 696         nsIDOMNode *nsnode;
 697
 698         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 699
 700         for(i=0; i<length; i++) {
 701             nsIDOMNodeList_Item(nslist, i, &nsnode);
 702             if(is_elem_node(nsnode)) {
 703                 hres = get_node(nsnode, TRUE, &node);
 704                 if(FAILED(hres))
 705                     continue;
 706                 buf.buf[buf.len++] = elem_from_HTMLDOMNode(node);
 707             }
 708             nsIDOMNode_Release(nsnode);
 709         }
 710
 711         elem_vector_normalize(&buf);
 712     }else {
 713         buf.buf = NULL;
 714     }
 715
 716     return HTMLElementCollection_Create(buf.buf, buf.len, compat_mode);
 717 }
 718
 719 IHTMLElementCollection *create_collection_from_htmlcol(nsIDOMHTMLCollection *nscol, compat_mode_t compat_mode)
 720 {
 721     UINT32 length = 0, i;
 722     elem_vector_t buf;
 723     HTMLDOMNode *node;
 724     HRESULT hres = S_OK;
 725
 726     if(nscol)
 727         nsIDOMHTMLCollection_GetLength(nscol, &length);
 728
 729     buf.len = buf.size = length;
 730     if(buf.len) {
 731         nsIDOMNode *nsnode;
 732
 733         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 734
 735         for(i=0; i<length; i++) {
 736             nsIDOMHTMLCollection_Item(nscol, i, &nsnode);
 737             hres = get_node(nsnode, TRUE, &node);
 738             nsIDOMNode_Release(nsnode);
 739             if(FAILED(hres))
 740                 break;
 741             buf.buf[i] = elem_from_HTMLDOMNode(node);
 742         }
 743     }else {
 744         buf.buf = NULL;
 745     }
 746
 747     if(FAILED(hres)) {
 748         heap_free(buf.buf);
 749         return NULL;
 750     }
 751
 752     return HTMLElementCollection_Create(buf.buf, buf.len, compat_mode);
 753 }
 754
 755 HRESULT get_elem_source_index(HTMLElement *elem, LONG *ret)
 756 {
 757     elem_vector_t buf = {NULL, 0, 8};
 758     nsIDOMNode *parent_node, *iter;
 759     UINT16 parent_type;
 760     HTMLDOMNode *node;
 761     int i;
 762     nsresult nsres;
 763     HRESULT hres;
 764
 765     iter = elem->node.nsnode;
 766     nsIDOMNode_AddRef(iter);
 767
 768     /* Find document or document fragment parent. */
 769     while(1) {
 770         nsres = nsIDOMNode_GetParentNode(iter, &parent_node);
 771         nsIDOMNode_Release(iter);
 772         assert(nsres == NS_OK);
 773         if(!parent_node)
 774             break;
 775
 776         nsres = nsIDOMNode_GetNodeType(parent_node, &parent_type);
 777         assert(nsres == NS_OK);
 778
 779         if(parent_type != ELEMENT_NODE) {
 780             if(parent_type != DOCUMENT_NODE && parent_type != DOCUMENT_FRAGMENT_NODE)
 781                 FIXME("Unexpected parent_type %d\n", parent_type);
 782             break;
 783         }
 784
 785         iter = parent_node;
 786     }
 787
 788     if(!parent_node) {
 789         *ret = -1;
 790         return S_OK;
 791     }
 792
 793     hres = get_node(parent_node, TRUE, &node);
 794     nsIDOMNode_Release(parent_node);
 795     if(FAILED(hres))
 796         return hres;
 797
 798     /* Create all children collection and find the element in it.
 799      * This could be optimized if we ever find the reason. */
 800     buf.buf = heap_alloc(buf.size*sizeof(*buf.buf));
 801     if(!buf.buf) {
 802         IHTMLDOMNode_Release(&node->IHTMLDOMNode_iface);
 803         return E_OUTOFMEMORY;
 804     }
 805
 806     create_all_list(node, &buf);
 807
 808     for(i=0; i < buf.len; i++) {
 809         if(buf.buf[i] == elem)
 810             break;
 811     }
 812     IHTMLDOMNode_Release(&node->IHTMLDOMNode_iface);
 813     heap_free(buf.buf);
 814     if(i == buf.len) {
 815         FIXME("The element is not in parent's child list?\n");
 816         return E_UNEXPECTED;
 817     }
 818
 819     *ret = i;
 820     return S_OK;
 821 }
 822
 823 static IHTMLElementCollection *HTMLElementCollection_Create(HTMLElement **elems, DWORD len,
 824                                                             compat_mode_t compat_mode)
 825 {
 826     HTMLElementCollection *ret = heap_alloc_zero(sizeof(HTMLElementCollection));
 827
 828     if (!ret)
 829         return NULL;
 830
 831     ret->IHTMLElementCollection_iface.lpVtbl = &HTMLElementCollectionVtbl;
 832     ret->ref = 1;
 833     ret->elems = elems;
 834     ret->len = len;
 835
 836     init_dispatch(&ret->dispex, (IUnknown*)&ret->IHTMLElementCollection_iface,
 837                   &HTMLElementCollection_dispex, compat_mode);
 838
 839     TRACE("ret=%p len=%d\n", ret, len);
 840
 841     return &ret->IHTMLElementCollection_iface;
 842 }