git.oblomov.eu Git - wine/blob - 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
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  33
  34 typedef struct {
  35     DispatchEx dispex;
  36     const IHTMLElementCollectionVtbl *lpHTMLElementCollectionVtbl;
  37
  38     IUnknown *ref_unk;
  39     HTMLElement **elems;
  40     DWORD len;
  41
  42     LONG ref;
  43 } HTMLElementCollection;
  44
  45 #define HTMLELEMCOL(x)  ((IHTMLElementCollection*) &(x)->lpHTMLElementCollectionVtbl)
  46
  47 typedef struct {
  48     HTMLElement **buf;
  49     DWORD len;
  50     DWORD size;
  51 } elem_vector_t;
  52
  53 /* FIXME: Handle it better way */
  54 static inline HTMLElement *elem_from_HTMLDOMNode(HTMLDOMNode *iface)
  55 {
  56     return CONTAINING_RECORD(iface, HTMLElement, node);
  57 }
  58
  59 static IHTMLElementCollection *HTMLElementCollection_Create(IUnknown *ref_unk,
  60                                                             HTMLElement **elems, DWORD len);
  61
  62 static void elem_vector_add(elem_vector_t *buf, HTMLElement *elem)
  63 {
  64     if(buf->len == buf->size) {
  65         buf->size <<= 1;
  66         buf->buf = heap_realloc(buf->buf, buf->size*sizeof(HTMLElement**));
  67     }
  68
  69     buf->buf[buf->len++] = elem;
  70 }
  71
  72 static void elem_vector_normalize(elem_vector_t *buf)
  73 {
  74     if(!buf->len) {
  75         heap_free(buf->buf);
  76         buf->buf = NULL;
  77     }else if(buf->size > buf->len) {
  78         buf->buf = heap_realloc(buf->buf, buf->len*sizeof(HTMLElement**));
  79     }
  80
  81     buf->size = buf->len;
  82 }
  83
  84 static inline BOOL is_elem_node(nsIDOMNode *node)
  85 {
  86     PRUint16 type=0;
  87
  88     nsIDOMNode_GetNodeType(node, &type);
  89
  90     return type == ELEMENT_NODE || type == COMMENT_NODE;
  91 }
  92
  93 #define ELEMCOL_THIS(iface) DEFINE_THIS(HTMLElementCollection, HTMLElementCollection, iface)
  94
  95 static HRESULT WINAPI HTMLElementCollection_QueryInterface(IHTMLElementCollection *iface,
  96                                                            REFIID riid, void **ppv)
  97 {
  98     HTMLElementCollection *This = ELEMCOL_THIS(iface);
  99
 100     *ppv = NULL;
 101
 102     if(IsEqualGUID(&IID_IUnknown, riid)) {
 103         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 104         *ppv = HTMLELEMCOL(This);
 105     }else if(IsEqualGUID(&IID_IHTMLElementCollection, riid)) {
 106         TRACE("(%p)->(IID_IHTMLElementCollection %p)\n", This, ppv);
 107         *ppv = HTMLELEMCOL(This);
 108     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 109         return *ppv ? S_OK : E_NOINTERFACE;
 110     }
 111
 112     if(*ppv) {
 113         IHTMLElementCollection_AddRef(HTMLELEMCOL(This));
 114         return S_OK;
 115     }
 116
 117     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 118     return E_NOINTERFACE;
 119 }
 120
 121 static ULONG WINAPI HTMLElementCollection_AddRef(IHTMLElementCollection *iface)
 122 {
 123     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 124     LONG ref = InterlockedIncrement(&This->ref);
 125
 126     TRACE("(%p) ref=%d\n", This, ref);
 127
 128     return ref;
 129 }
 130
 131 static ULONG WINAPI HTMLElementCollection_Release(IHTMLElementCollection *iface)
 132 {
 133     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 134     LONG ref = InterlockedDecrement(&This->ref);
 135
 136     TRACE("(%p) ref=%d\n", This, ref);
 137
 138     if(!ref) {
 139         IUnknown_Release(This->ref_unk);
 140         release_dispex(&This->dispex);
 141         heap_free(This->elems);
 142         heap_free(This);
 143     }
 144
 145     return ref;
 146 }
 147
 148 static HRESULT WINAPI HTMLElementCollection_GetTypeInfoCount(IHTMLElementCollection *iface,
 149                                                              UINT *pctinfo)
 150 {
 151     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 152     return IDispatchEx_GetTypeInfoCount(DISPATCHEX(&This->dispex), pctinfo);
 153 }
 154
 155 static HRESULT WINAPI HTMLElementCollection_GetTypeInfo(IHTMLElementCollection *iface,
 156         UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 157 {
 158     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 159     return IDispatchEx_GetTypeInfo(DISPATCHEX(&This->dispex), iTInfo, lcid, ppTInfo);
 160 }
 161
 162 static HRESULT WINAPI HTMLElementCollection_GetIDsOfNames(IHTMLElementCollection *iface,
 163         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 164 {
 165     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 166     return IDispatchEx_GetIDsOfNames(DISPATCHEX(&This->dispex), riid, rgszNames, cNames, lcid, rgDispId);
 167 }
 168
 169 static HRESULT WINAPI HTMLElementCollection_Invoke(IHTMLElementCollection *iface,
 170         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 171         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 172 {
 173     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 174     return IDispatchEx_Invoke(DISPATCHEX(&This->dispex), dispIdMember, riid, lcid,
 175             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 176 }
 177
 178 static HRESULT WINAPI HTMLElementCollection_toString(IHTMLElementCollection *iface,
 179                                                      BSTR *String)
 180 {
 181     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 182     FIXME("(%p)->(%p)\n", This, String);
 183     return E_NOTIMPL;
 184 }
 185
 186 static HRESULT WINAPI HTMLElementCollection_put_length(IHTMLElementCollection *iface,
 187                                                        LONG v)
 188 {
 189     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 190     FIXME("(%p)->(%d)\n", This, v);
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI HTMLElementCollection_get_length(IHTMLElementCollection *iface,
 195                                                        LONG *p)
 196 {
 197     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 198
 199     TRACE("(%p)->(%p)\n", This, p);
 200
 201     *p = This->len;
 202     return S_OK;
 203 }
 204
 205 static HRESULT WINAPI HTMLElementCollection_get__newEnum(IHTMLElementCollection *iface,
 206                                                          IUnknown **p)
 207 {
 208     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 209     FIXME("(%p)->(%p)\n", This, p);
 210     return E_NOTIMPL;
 211 }
 212
 213 static BOOL is_elem_id(HTMLElement *elem, LPCWSTR name)
 214 {
 215     BSTR elem_id;
 216     HRESULT hres;
 217
 218     hres = IHTMLElement_get_id(HTMLELEM(elem), &elem_id);
 219     if(FAILED(hres)){
 220         WARN("IHTMLElement_get_id failed: 0x%08x\n", hres);
 221         return FALSE;
 222     }
 223
 224     if(elem_id && !strcmpW(elem_id, name)) {
 225         SysFreeString(elem_id);
 226         return TRUE;
 227     }
 228
 229     SysFreeString(elem_id);
 230     return FALSE;
 231 }
 232
 233 static BOOL is_elem_name(HTMLElement *elem, LPCWSTR name)
 234 {
 235     const PRUnichar *str;
 236     nsAString nsstr, nsname;
 237     BOOL ret = FALSE;
 238     nsresult nsres;
 239
 240     static const PRUnichar nameW[] = {'n','a','m','e',0};
 241
 242     if(!elem->nselem)
 243         return FALSE;
 244
 245     nsAString_Init(&nsstr, NULL);
 246     nsIDOMHTMLElement_GetId(elem->nselem, &nsstr);
 247     nsAString_GetData(&nsstr, &str);
 248     if(!strcmpiW(str, name)) {
 249         nsAString_Finish(&nsstr);
 250         return TRUE;
 251     }
 252
 253     nsAString_InitDepend(&nsname, nameW);
 254     nsres =  nsIDOMHTMLElement_GetAttribute(elem->nselem, &nsname, &nsstr);
 255     nsAString_Finish(&nsname);
 256     if(NS_SUCCEEDED(nsres)) {
 257         nsAString_GetData(&nsstr, &str);
 258         ret = !strcmpiW(str, name);
 259     }
 260
 261     nsAString_Finish(&nsstr);
 262     return ret;
 263 }
 264
 265 static HRESULT get_item_idx(HTMLElementCollection *This, UINT idx, IDispatch **ret)
 266 {
 267     if(idx < This->len) {
 268         *ret = (IDispatch*)This->elems[idx];
 269         IDispatch_AddRef(*ret);
 270     }
 271
 272     return S_OK;
 273 }
 274
 275 static HRESULT WINAPI HTMLElementCollection_item(IHTMLElementCollection *iface,
 276         VARIANT name, VARIANT index, IDispatch **pdisp)
 277 {
 278     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 279     HRESULT hres = S_OK;
 280
 281     TRACE("(%p)->(%s %s %p)\n", This, debugstr_variant(&name), debugstr_variant(&index), pdisp);
 282
 283     *pdisp = NULL;
 284
 285     switch(V_VT(&name)) {
 286     case VT_I4:
 287         if(V_I4(&name) < 0)
 288             return E_INVALIDARG;
 289         hres = get_item_idx(This, V_I4(&name), pdisp);
 290         break;
 291
 292     case VT_UINT:
 293         hres = get_item_idx(This, V_UINT(&name), pdisp);
 294         break;
 295
 296     case VT_BSTR: {
 297         DWORD i;
 298
 299         if(V_VT(&index) == VT_I4) {
 300             LONG idx = V_I4(&index);
 301
 302             if(idx < 0)
 303                 return E_INVALIDARG;
 304
 305             for(i=0; i<This->len; i++) {
 306                 if(is_elem_name(This->elems[i], V_BSTR(&name)) && !idx--)
 307                     break;
 308             }
 309
 310             if(i != This->len) {
 311                 *pdisp = (IDispatch*)HTMLELEM(This->elems[i]);
 312                 IDispatch_AddRef(*pdisp);
 313             }
 314         }else {
 315             elem_vector_t buf = {NULL, 0, 8};
 316
 317             buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 318
 319             for(i=0; i<This->len; i++) {
 320                 if(is_elem_name(This->elems[i], V_BSTR(&name)))
 321                     elem_vector_add(&buf, This->elems[i]);
 322             }
 323
 324             if(buf.len > 1) {
 325                 elem_vector_normalize(&buf);
 326                 *pdisp = (IDispatch*)HTMLElementCollection_Create(This->ref_unk, buf.buf, buf.len);
 327             }else {
 328                 if(buf.len == 1) {
 329                     *pdisp = (IDispatch*)HTMLELEM(buf.buf[0]);
 330                     IDispatch_AddRef(*pdisp);
 331                 }
 332
 333                 heap_free(buf.buf);
 334             }
 335         }
 336         break;
 337     }
 338
 339     default:
 340         FIXME("Unsupported name %s\n", debugstr_variant(&name));
 341         hres = E_NOTIMPL;
 342     }
 343
 344     if(SUCCEEDED(hres))
 345         TRACE("returning %p\n", *pdisp);
 346     return hres;
 347 }
 348
 349 static HRESULT WINAPI HTMLElementCollection_tags(IHTMLElementCollection *iface,
 350                                                  VARIANT tagName, IDispatch **pdisp)
 351 {
 352     HTMLElementCollection *This = ELEMCOL_THIS(iface);
 353     DWORD i;
 354     nsAString tag_str;
 355     const PRUnichar *tag;
 356     elem_vector_t buf = {NULL, 0, 8};
 357
 358     if(V_VT(&tagName) != VT_BSTR) {
 359         WARN("Invalid arg\n");
 360         return DISP_E_MEMBERNOTFOUND;
 361     }
 362
 363     TRACE("(%p)->(%s %p)\n", This, debugstr_w(V_BSTR(&tagName)), pdisp);
 364
 365     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 366
 367     nsAString_Init(&tag_str, NULL);
 368
 369     for(i=0; i<This->len; i++) {
 370         if(!This->elems[i]->nselem)
 371             continue;
 372
 373         nsIDOMElement_GetTagName(This->elems[i]->nselem, &tag_str);
 374         nsAString_GetData(&tag_str, &tag);
 375
 376         if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, tag, -1,
 377                           V_BSTR(&tagName), -1) == CSTR_EQUAL)
 378             elem_vector_add(&buf, This->elems[i]);
 379     }
 380
 381     nsAString_Finish(&tag_str);
 382     elem_vector_normalize(&buf);
 383
 384     TRACE("fount %d tags\n", buf.len);
 385
 386     *pdisp = (IDispatch*)HTMLElementCollection_Create(This->ref_unk, buf.buf, buf.len);
 387     return S_OK;
 388 }
 389
 390 #undef ELEMCOL_THIS
 391
 392 static const IHTMLElementCollectionVtbl HTMLElementCollectionVtbl = {
 393     HTMLElementCollection_QueryInterface,
 394     HTMLElementCollection_AddRef,
 395     HTMLElementCollection_Release,
 396     HTMLElementCollection_GetTypeInfoCount,
 397     HTMLElementCollection_GetTypeInfo,
 398     HTMLElementCollection_GetIDsOfNames,
 399     HTMLElementCollection_Invoke,
 400     HTMLElementCollection_toString,
 401     HTMLElementCollection_put_length,
 402     HTMLElementCollection_get_length,
 403     HTMLElementCollection_get__newEnum,
 404     HTMLElementCollection_item,
 405     HTMLElementCollection_tags
 406 };
 407
 408 static inline HTMLElementCollection *impl_from_DispatchEx(DispatchEx *iface)
 409 {
 410     return CONTAINING_RECORD(iface, HTMLElementCollection, dispex);
 411 }
 412
 413 #define DISPID_ELEMCOL_0 MSHTML_DISPID_CUSTOM_MIN
 414
 415 static HRESULT HTMLElementCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
 416 {
 417     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
 418     WCHAR *ptr;
 419     DWORD idx=0;
 420
 421     if(!*name)
 422         return DISP_E_UNKNOWNNAME;
 423
 424     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
 425         idx = idx*10 + (*ptr-'0');
 426
 427     if(*ptr) {
 428         /* the name contains alpha characters, so search by name & id */
 429         for(idx = 0; idx < This->len; ++idx) {
 430             if(is_elem_id(This->elems[idx], name) ||
 431                     is_elem_name(This->elems[idx], name))
 432                 break;
 433         }
 434     }
 435
 436     if(idx >= This->len)
 437         return DISP_E_UNKNOWNNAME;
 438
 439     *dispid = DISPID_ELEMCOL_0 + idx;
 440     TRACE("ret %x\n", *dispid);
 441     return S_OK;
 442 }
 443
 444 static HRESULT HTMLElementCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 445         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 446 {
 447     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
 448     DWORD idx;
 449
 450     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
 451
 452     idx = id - DISPID_ELEMCOL_0;
 453     if(idx >= This->len)
 454         return DISP_E_UNKNOWNNAME;
 455
 456     switch(flags) {
 457     case DISPATCH_PROPERTYGET:
 458         V_VT(res) = VT_DISPATCH;
 459         V_DISPATCH(res) = (IDispatch*)HTMLELEM(This->elems[idx]);
 460         IHTMLElement_AddRef(HTMLELEM(This->elems[idx]));
 461         break;
 462     default:
 463         FIXME("unimplemented flags %x\n", flags);
 464         return E_NOTIMPL;
 465     }
 466
 467     return S_OK;
 468 }
 469
 470 static const dispex_static_data_vtbl_t HTMLElementColection_dispex_vtbl = {
 471     NULL,
 472     HTMLElementCollection_get_dispid,
 473     HTMLElementCollection_invoke
 474 };
 475
 476 static const tid_t HTMLElementCollection_iface_tids[] = {
 477     IHTMLElementCollection_tid,
 478     0
 479 };
 480
 481 static dispex_static_data_t HTMLElementCollection_dispex = {
 482     &HTMLElementColection_dispex_vtbl,
 483     DispHTMLElementCollection_tid,
 484     NULL,
 485     HTMLElementCollection_iface_tids
 486 };
 487
 488 static void create_all_list(HTMLDocumentNode *doc, HTMLDOMNode *elem, elem_vector_t *buf)
 489 {
 490     nsIDOMNodeList *nsnode_list;
 491     nsIDOMNode *iter;
 492     PRUint32 list_len = 0, i;
 493     nsresult nsres;
 494     HRESULT hres;
 495
 496     nsres = nsIDOMNode_GetChildNodes(elem->nsnode, &nsnode_list);
 497     if(NS_FAILED(nsres)) {
 498         ERR("GetChildNodes failed: %08x\n", nsres);
 499         return;
 500     }
 501
 502     nsIDOMNodeList_GetLength(nsnode_list, &list_len);
 503     if(!list_len)
 504         return;
 505
 506     for(i=0; i<list_len; i++) {
 507         nsres = nsIDOMNodeList_Item(nsnode_list, i, &iter);
 508         if(NS_FAILED(nsres)) {
 509             ERR("Item failed: %08x\n", nsres);
 510             continue;
 511         }
 512
 513         if(is_elem_node(iter)) {
 514             HTMLDOMNode *node;
 515
 516             hres = get_node(doc, iter, TRUE, &node);
 517             if(FAILED(hres)) {
 518                 FIXME("get_node failed: %08x\n", hres);
 519                 continue;
 520             }
 521
 522             elem_vector_add(buf, elem_from_HTMLDOMNode(node));
 523             create_all_list(doc, node, buf);
 524         }
 525     }
 526 }
 527
 528 IHTMLElementCollection *create_all_collection(HTMLDOMNode *node, BOOL include_root)
 529 {
 530     elem_vector_t buf = {NULL, 0, 8};
 531
 532     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement**));
 533
 534     if(include_root)
 535         elem_vector_add(&buf, elem_from_HTMLDOMNode(node));
 536     create_all_list(node->doc, node, &buf);
 537     elem_vector_normalize(&buf);
 538
 539     return HTMLElementCollection_Create((IUnknown*)HTMLDOMNODE(node), buf.buf, buf.len);
 540 }
 541
 542 IHTMLElementCollection *create_collection_from_nodelist(HTMLDocumentNode *doc, IUnknown *unk, nsIDOMNodeList *nslist)
 543 {
 544     PRUint32 length = 0, i;
 545     HTMLDOMNode *node;
 546     elem_vector_t buf;
 547     HRESULT hres;
 548
 549     nsIDOMNodeList_GetLength(nslist, &length);
 550
 551     buf.len = 0;
 552     buf.size = length;
 553     if(length) {
 554         nsIDOMNode *nsnode;
 555
 556         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 557
 558         for(i=0; i<length; i++) {
 559             nsIDOMNodeList_Item(nslist, i, &nsnode);
 560             if(is_elem_node(nsnode)) {
 561                 hres = get_node(doc, nsnode, TRUE, &node);
 562                 if(FAILED(hres))
 563                     continue;
 564                 buf.buf[buf.len++] = elem_from_HTMLDOMNode(node);
 565             }
 566             nsIDOMNode_Release(nsnode);
 567         }
 568
 569         elem_vector_normalize(&buf);
 570     }else {
 571         buf.buf = NULL;
 572     }
 573
 574     return HTMLElementCollection_Create(unk, buf.buf, buf.len);
 575 }
 576
 577 IHTMLElementCollection *create_collection_from_htmlcol(HTMLDocumentNode *doc, IUnknown *unk, nsIDOMHTMLCollection *nscol)
 578 {
 579     PRUint32 length = 0, i;
 580     elem_vector_t buf;
 581     HTMLDOMNode *node;
 582     HRESULT hres = S_OK;
 583
 584     nsIDOMHTMLCollection_GetLength(nscol, &length);
 585
 586     buf.len = buf.size = length;
 587     if(buf.len) {
 588         nsIDOMNode *nsnode;
 589
 590         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 591
 592         for(i=0; i<length; i++) {
 593             nsIDOMHTMLCollection_Item(nscol, i, &nsnode);
 594             hres = get_node(doc, nsnode, TRUE, &node);
 595             nsIDOMNode_Release(nsnode);
 596             if(FAILED(hres))
 597                 break;
 598             buf.buf[i] = elem_from_HTMLDOMNode(node);
 599         }
 600     }else {
 601         buf.buf = NULL;
 602     }
 603
 604     if(FAILED(hres)) {
 605         heap_free(buf.buf);
 606         return NULL;
 607     }
 608
 609     return HTMLElementCollection_Create(unk, buf.buf, buf.len);
 610 }
 611
 612 static IHTMLElementCollection *HTMLElementCollection_Create(IUnknown *ref_unk,
 613             HTMLElement **elems, DWORD len)
 614 {
 615     HTMLElementCollection *ret = heap_alloc_zero(sizeof(HTMLElementCollection));
 616
 617     ret->lpHTMLElementCollectionVtbl = &HTMLElementCollectionVtbl;
 618     ret->ref = 1;
 619     ret->elems = elems;
 620     ret->len = len;
 621
 622     init_dispex(&ret->dispex, (IUnknown*)HTMLELEMCOL(ret), &HTMLElementCollection_dispex);
 623
 624     IUnknown_AddRef(ref_unk);
 625     ret->ref_unk = ref_unk;
 626
 627     TRACE("ret=%p len=%d\n", ret, len);
 628
 629     return HTMLELEMCOL(ret);
 630 }