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