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