dll/win32/mshtml/htmltable.c

   1 /*
   2  * Copyright 2007 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 "mshtml_private.h"
  20
  21 struct HTMLTable {
  22     HTMLElement element;
  23
  24     IHTMLTable  IHTMLTable_iface;
  25     IHTMLTable2 IHTMLTable2_iface;
  26     IHTMLTable3 IHTMLTable3_iface;
  27
  28     nsIDOMHTMLTableElement *nstable;
  29 };
  30
  31 static inline HTMLTable *impl_from_IHTMLTable(IHTMLTable *iface)
  32 {
  33     return CONTAINING_RECORD(iface, HTMLTable, IHTMLTable_iface);
  34 }
  35
  36 static inline HTMLTable *impl_from_IHTMLTable2(IHTMLTable2 *iface)
  37 {
  38     return CONTAINING_RECORD(iface, HTMLTable, IHTMLTable2_iface);
  39 }
  40
  41 static inline HTMLTable *impl_from_IHTMLTable3(IHTMLTable3 *iface)
  42 {
  43     return CONTAINING_RECORD(iface, HTMLTable, IHTMLTable3_iface);
  44 }
  45
  46 static HRESULT var2str(const VARIANT *p, nsAString *nsstr)
  47 {
  48     BSTR str;
  49     BOOL ret;
  50     HRESULT hres;
  51
  52     switch(V_VT(p)) {
  53     case VT_BSTR:
  54         return nsAString_Init(nsstr, V_BSTR(p))?
  55             S_OK : E_OUTOFMEMORY;
  56     case VT_R8:
  57         hres = VarBstrFromR8(V_R8(p), 0, 0, &str);
  58         break;
  59     case VT_R4:
  60         hres = VarBstrFromR4(V_R4(p), 0, 0, &str);
  61         break;
  62     case VT_I4:
  63         hres = VarBstrFromI4(V_I4(p), 0, 0, &str);
  64         break;
  65     default:
  66         FIXME("unsupported arg %s\n", debugstr_variant(p));
  67         return E_NOTIMPL;
  68     }
  69     if (FAILED(hres))
  70         return hres;
  71
  72     ret = nsAString_Init(nsstr, str);
  73     SysFreeString(str);
  74     return ret ? S_OK : E_OUTOFMEMORY;
  75 }
  76
  77 static HRESULT nsstr_to_truncated_bstr(const nsAString *nsstr, BSTR *ret_ptr)
  78 {
  79     const PRUnichar *str, *ptr, *end = NULL;
  80     BSTR ret;
  81
  82     nsAString_GetData(nsstr, &str);
  83
  84     for(ptr = str; isdigitW(*ptr); ptr++);
  85     if(*ptr == '.') {
  86         for(end = ptr++; isdigitW(*ptr); ptr++);
  87         if(*ptr)
  88             end = NULL;
  89     }
  90
  91     ret = end ? SysAllocStringLen(str, end-str) : SysAllocString(str);
  92
  93     *ret_ptr = ret;
  94     return ret ? S_OK : E_OUTOFMEMORY;
  95 }
  96
  97 static HRESULT WINAPI HTMLTable_QueryInterface(IHTMLTable *iface,
  98                                                          REFIID riid, void **ppv)
  99 {
 100     HTMLTable *This = impl_from_IHTMLTable(iface);
 101
 102     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 103 }
 104
 105 static ULONG WINAPI HTMLTable_AddRef(IHTMLTable *iface)
 106 {
 107     HTMLTable *This = impl_from_IHTMLTable(iface);
 108
 109     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 110 }
 111
 112 static ULONG WINAPI HTMLTable_Release(IHTMLTable *iface)
 113 {
 114     HTMLTable *This = impl_from_IHTMLTable(iface);
 115
 116     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 117 }
 118
 119 static HRESULT WINAPI HTMLTable_GetTypeInfoCount(IHTMLTable *iface, UINT *pctinfo)
 120 {
 121     HTMLTable *This = impl_from_IHTMLTable(iface);
 122     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
 123 }
 124
 125 static HRESULT WINAPI HTMLTable_GetTypeInfo(IHTMLTable *iface, UINT iTInfo,
 126                                               LCID lcid, ITypeInfo **ppTInfo)
 127 {
 128     HTMLTable *This = impl_from_IHTMLTable(iface);
 129     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
 130             ppTInfo);
 131 }
 132
 133 static HRESULT WINAPI HTMLTable_GetIDsOfNames(IHTMLTable *iface, REFIID riid,
 134                                                 LPOLESTR *rgszNames, UINT cNames,
 135                                                 LCID lcid, DISPID *rgDispId)
 136 {
 137     HTMLTable *This = impl_from_IHTMLTable(iface);
 138     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 139             cNames, lcid, rgDispId);
 140 }
 141
 142 static HRESULT WINAPI HTMLTable_Invoke(IHTMLTable *iface, DISPID dispIdMember,
 143                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 144                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 145 {
 146     HTMLTable *This = impl_from_IHTMLTable(iface);
 147     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 148             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 149 }
 150
 151 static HRESULT WINAPI HTMLTable_put_cols(IHTMLTable *iface, LONG v)
 152 {
 153     HTMLTable *This = impl_from_IHTMLTable(iface);
 154     FIXME("(%p)->(%d)\n", This, v);
 155     return E_NOTIMPL;
 156 }
 157
 158 static HRESULT WINAPI HTMLTable_get_cols(IHTMLTable *iface, LONG *p)
 159 {
 160     HTMLTable *This = impl_from_IHTMLTable(iface);
 161     FIXME("(%p)->(%p)\n", This, p);
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI HTMLTable_put_border(IHTMLTable *iface, VARIANT v)
 166 {
 167     HTMLTable *This = impl_from_IHTMLTable(iface);
 168     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 169     return E_NOTIMPL;
 170 }
 171
 172 static HRESULT WINAPI HTMLTable_get_border(IHTMLTable *iface, VARIANT *p)
 173 {
 174     HTMLTable *This = impl_from_IHTMLTable(iface);
 175     FIXME("(%p)->(%p)\n", This, p);
 176     return E_NOTIMPL;
 177 }
 178
 179 static HRESULT WINAPI HTMLTable_put_frame(IHTMLTable *iface, BSTR v)
 180 {
 181     HTMLTable *This = impl_from_IHTMLTable(iface);
 182     nsAString str;
 183     nsresult nsres;
 184
 185     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 186
 187     nsAString_InitDepend(&str, v);
 188     nsres = nsIDOMHTMLTableElement_SetFrame(This->nstable, &str);
 189     nsAString_Finish(&str);
 190
 191     if (NS_FAILED(nsres)) {
 192         ERR("SetFrame(%s) failed: %08x\n", debugstr_w(v), nsres);
 193         return E_FAIL;
 194     }
 195     return S_OK;
 196 }
 197
 198 static HRESULT WINAPI HTMLTable_get_frame(IHTMLTable *iface, BSTR *p)
 199 {
 200     HTMLTable *This = impl_from_IHTMLTable(iface);
 201     nsAString str;
 202     nsresult nsres;
 203
 204     TRACE("(%p)->(%p)\n", This, p);
 205
 206     nsAString_Init(&str, NULL);
 207     nsres = nsIDOMHTMLTableElement_GetFrame(This->nstable, &str);
 208
 209     return return_nsstr(nsres, &str, p);
 210 }
 211
 212 static HRESULT WINAPI HTMLTable_put_rules(IHTMLTable *iface, BSTR v)
 213 {
 214     HTMLTable *This = impl_from_IHTMLTable(iface);
 215     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 216     return E_NOTIMPL;
 217 }
 218
 219 static HRESULT WINAPI HTMLTable_get_rules(IHTMLTable *iface, BSTR *p)
 220 {
 221     HTMLTable *This = impl_from_IHTMLTable(iface);
 222     FIXME("(%p)->(%p)\n", This, p);
 223     return E_NOTIMPL;
 224 }
 225
 226 static HRESULT WINAPI HTMLTable_put_cellSpacing(IHTMLTable *iface, VARIANT v)
 227 {
 228     HTMLTable *This = impl_from_IHTMLTable(iface);
 229     nsAString nsstr;
 230     WCHAR buf[64];
 231     nsresult nsres;
 232
 233     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 234
 235     switch(V_VT(&v)) {
 236     case VT_BSTR:
 237         nsAString_InitDepend(&nsstr, V_BSTR(&v));
 238         break;
 239     case VT_I4: {
 240         static const WCHAR formatW[] = {'%','d',0};
 241         sprintfW(buf, formatW, V_I4(&v));
 242         nsAString_InitDepend(&nsstr, buf);
 243         break;
 244     }
 245     default:
 246         FIXME("unsupported arg %s\n", debugstr_variant(&v));
 247         return E_NOTIMPL;
 248     }
 249
 250     nsres = nsIDOMHTMLTableElement_SetCellSpacing(This->nstable, &nsstr);
 251     nsAString_Finish(&nsstr);
 252     if(NS_FAILED(nsres)) {
 253         ERR("SetCellSpacing failed: %08x\n", nsres);
 254         return E_FAIL;
 255     }
 256
 257     return S_OK;
 258 }
 259
 260 static HRESULT WINAPI HTMLTable_get_cellSpacing(IHTMLTable *iface, VARIANT *p)
 261 {
 262     HTMLTable *This = impl_from_IHTMLTable(iface);
 263     nsAString nsstr;
 264     nsresult nsres;
 265
 266     TRACE("(%p)->(%p)\n", This, p);
 267
 268     nsAString_Init(&nsstr, NULL);
 269     nsres = nsIDOMHTMLTableElement_GetCellSpacing(This->nstable, &nsstr);
 270     V_VT(p) = VT_BSTR;
 271     return return_nsstr(nsres, &nsstr, &V_BSTR(p));
 272 }
 273
 274 static HRESULT WINAPI HTMLTable_put_cellPadding(IHTMLTable *iface, VARIANT v)
 275 {
 276     HTMLTable *This = impl_from_IHTMLTable(iface);
 277     nsAString val;
 278     HRESULT hres;
 279     nsresult nsres;
 280
 281     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 282
 283     hres = var2str(&v, &val);
 284     if(FAILED(hres))
 285         return hres;
 286
 287     nsres = nsIDOMHTMLTableElement_SetCellPadding(This->nstable, &val);
 288     nsAString_Finish(&val);
 289     if(NS_FAILED(nsres)) {
 290         ERR("Set Width(%s) failed, err = %08x\n", debugstr_variant(&v), nsres);
 291         return E_FAIL;
 292     }
 293
 294     return S_OK;
 295 }
 296
 297 static HRESULT WINAPI HTMLTable_get_cellPadding(IHTMLTable *iface, VARIANT *p)
 298 {
 299     HTMLTable *This = impl_from_IHTMLTable(iface);
 300     nsAString val;
 301     nsresult nsres;
 302
 303     TRACE("(%p)->(%p)\n", This, p);
 304
 305     nsAString_Init(&val, NULL);
 306     nsres = nsIDOMHTMLTableElement_GetCellPadding(This->nstable, &val);
 307     return return_nsstr_variant(nsres, &val, p);
 308 }
 309
 310 static HRESULT WINAPI HTMLTable_put_background(IHTMLTable *iface, BSTR v)
 311 {
 312     HTMLTable *This = impl_from_IHTMLTable(iface);
 313     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI HTMLTable_get_background(IHTMLTable *iface, BSTR *p)
 318 {
 319     HTMLTable *This = impl_from_IHTMLTable(iface);
 320     FIXME("(%p)->(%p)\n", This, p);
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI HTMLTable_put_bgColor(IHTMLTable *iface, VARIANT v)
 325 {
 326     HTMLTable *This = impl_from_IHTMLTable(iface);
 327     nsAString val;
 328     nsresult nsres;
 329
 330     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 331
 332     if(!variant_to_nscolor(&v, &val))
 333         return S_OK;
 334
 335     nsres = nsIDOMHTMLTableElement_SetBgColor(This->nstable, &val);
 336     nsAString_Finish(&val);
 337     if (NS_FAILED(nsres)){
 338         ERR("Set BgColor(%s) failed!\n", debugstr_variant(&v));
 339         return E_FAIL;
 340     }
 341
 342     return S_OK;
 343 }
 344
 345 static HRESULT WINAPI HTMLTable_get_bgColor(IHTMLTable *iface, VARIANT *p)
 346 {
 347     HTMLTable *This = impl_from_IHTMLTable(iface);
 348     nsAString strColor;
 349     nsresult nsres;
 350     HRESULT hres;
 351     const PRUnichar *color;
 352
 353     TRACE("(%p)->(%p)\n", This, p);
 354
 355     nsAString_Init(&strColor, NULL);
 356     nsres = nsIDOMHTMLTableElement_GetBgColor(This->nstable, &strColor);
 357
 358     if(NS_SUCCEEDED(nsres)) {
 359        nsAString_GetData(&strColor, &color);
 360        V_VT(p) = VT_BSTR;
 361        hres = nscolor_to_str(color, &V_BSTR(p));
 362     }else {
 363        ERR("SetBgColor failed: %08x\n", nsres);
 364        hres = E_FAIL;
 365     }
 366
 367     nsAString_Finish(&strColor);
 368     return hres;
 369 }
 370
 371 static HRESULT WINAPI HTMLTable_put_borderColor(IHTMLTable *iface, VARIANT v)
 372 {
 373     HTMLTable *This = impl_from_IHTMLTable(iface);
 374     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 375     return E_NOTIMPL;
 376 }
 377
 378 static HRESULT WINAPI HTMLTable_get_borderColor(IHTMLTable *iface, VARIANT *p)
 379 {
 380     HTMLTable *This = impl_from_IHTMLTable(iface);
 381     FIXME("(%p)->(%p)\n", This, p);
 382     return E_NOTIMPL;
 383 }
 384
 385 static HRESULT WINAPI HTMLTable_put_borderColorLight(IHTMLTable *iface, VARIANT v)
 386 {
 387     HTMLTable *This = impl_from_IHTMLTable(iface);
 388     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI HTMLTable_get_borderColorLight(IHTMLTable *iface, VARIANT *p)
 393 {
 394     HTMLTable *This = impl_from_IHTMLTable(iface);
 395     FIXME("(%p)->(%p)\n", This, p);
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT WINAPI HTMLTable_put_borderColorDark(IHTMLTable *iface, VARIANT v)
 400 {
 401     HTMLTable *This = impl_from_IHTMLTable(iface);
 402     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI HTMLTable_get_borderColorDark(IHTMLTable *iface, VARIANT *p)
 407 {
 408     HTMLTable *This = impl_from_IHTMLTable(iface);
 409     FIXME("(%p)->(%p)\n", This, p);
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI HTMLTable_put_align(IHTMLTable *iface, BSTR v)
 414 {
 415     HTMLTable *This = impl_from_IHTMLTable(iface);
 416     nsAString val;
 417     nsresult nsres;
 418
 419     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 420
 421     nsAString_InitDepend(&val, v);
 422
 423     nsres = nsIDOMHTMLTableElement_SetAlign(This->nstable, &val);
 424     nsAString_Finish(&val);
 425     if (NS_FAILED(nsres)){
 426         ERR("Set Align(%s) failed!\n", debugstr_w(v));
 427         return E_FAIL;
 428     }
 429     return S_OK;
 430 }
 431
 432 static HRESULT WINAPI HTMLTable_get_align(IHTMLTable *iface, BSTR *p)
 433 {
 434     HTMLTable *This = impl_from_IHTMLTable(iface);
 435     nsAString val;
 436     nsresult nsres;
 437
 438     TRACE("(%p)->(%p)\n", This, p);
 439
 440     nsAString_Init(&val, NULL);
 441     nsres = nsIDOMHTMLTableElement_GetAlign(This->nstable, &val);
 442
 443     return return_nsstr(nsres, &val, p);
 444 }
 445
 446 static HRESULT WINAPI HTMLTable_refresh(IHTMLTable *iface)
 447 {
 448     HTMLTable *This = impl_from_IHTMLTable(iface);
 449     FIXME("(%p)\n", This);
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI HTMLTable_get_rows(IHTMLTable *iface, IHTMLElementCollection **p)
 454 {
 455     HTMLTable *This = impl_from_IHTMLTable(iface);
 456     nsIDOMHTMLCollection *nscol;
 457     nsresult nsres;
 458
 459     TRACE("(%p)->(%p)\n", This, p);
 460
 461     nsres = nsIDOMHTMLTableElement_GetRows(This->nstable, &nscol);
 462     if(NS_FAILED(nsres)) {
 463         ERR("GetRows failed: %08x\n", nsres);
 464         return E_FAIL;
 465     }
 466
 467     *p = create_collection_from_htmlcol(This->element.node.doc, nscol);
 468
 469     nsIDOMHTMLCollection_Release(nscol);
 470     return S_OK;
 471 }
 472
 473 static HRESULT WINAPI HTMLTable_put_width(IHTMLTable *iface, VARIANT v)
 474 {
 475     HTMLTable *This = impl_from_IHTMLTable(iface);
 476     nsAString val;
 477     HRESULT hres;
 478     nsresult nsres;
 479
 480     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 481     hres = var2str(&v, &val);
 482
 483     if (FAILED(hres)){
 484         ERR("Set Width(%s) failed when initializing a nsAString, err = %08x\n",
 485             debugstr_variant(&v), hres);
 486         return hres;
 487     }
 488
 489     nsres = nsIDOMHTMLTableElement_SetWidth(This->nstable, &val);
 490     nsAString_Finish(&val);
 491
 492     if (NS_FAILED(nsres)){
 493         ERR("Set Width(%s) failed, err = %08x\n", debugstr_variant(&v), nsres);
 494         return E_FAIL;
 495     }
 496     return S_OK;
 497 }
 498
 499 static HRESULT WINAPI HTMLTable_get_width(IHTMLTable *iface, VARIANT *p)
 500 {
 501     HTMLTable *This = impl_from_IHTMLTable(iface);
 502     nsAString val;
 503     BSTR bstr;
 504     nsresult nsres;
 505     HRESULT hres;
 506
 507     TRACE("(%p)->(%p)\n", This, p);
 508     nsAString_Init(&val, NULL);
 509     nsres = nsIDOMHTMLTableElement_GetWidth(This->nstable, &val);
 510     if (NS_FAILED(nsres)){
 511         ERR("Get Width failed!\n");
 512         nsAString_Finish(&val);
 513         return E_FAIL;
 514     }
 515
 516     hres = nsstr_to_truncated_bstr(&val, &bstr);
 517     nsAString_Finish(&val);
 518
 519     V_VT(p) = VT_BSTR;
 520     V_BSTR(p) = bstr;
 521     return hres;
 522 }
 523
 524 static HRESULT WINAPI HTMLTable_put_height(IHTMLTable *iface, VARIANT v)
 525 {
 526     HTMLTable *This = impl_from_IHTMLTable(iface);
 527     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 528     return E_NOTIMPL;
 529 }
 530
 531 static HRESULT WINAPI HTMLTable_get_height(IHTMLTable *iface, VARIANT *p)
 532 {
 533     HTMLTable *This = impl_from_IHTMLTable(iface);
 534     FIXME("(%p)->(%p)\n", This, p);
 535     return E_NOTIMPL;
 536 }
 537
 538 static HRESULT WINAPI HTMLTable_put_dataPageSize(IHTMLTable *iface, LONG v)
 539 {
 540     HTMLTable *This = impl_from_IHTMLTable(iface);
 541     FIXME("(%p)->(%d)\n", This, v);
 542     return E_NOTIMPL;
 543 }
 544
 545 static HRESULT WINAPI HTMLTable_get_dataPageSize(IHTMLTable *iface, LONG *p)
 546 {
 547     HTMLTable *This = impl_from_IHTMLTable(iface);
 548     FIXME("(%p)->(%p)\n", This, p);
 549     return E_NOTIMPL;
 550 }
 551
 552 static HRESULT WINAPI HTMLTable_nextPage(IHTMLTable *iface)
 553 {
 554     HTMLTable *This = impl_from_IHTMLTable(iface);
 555     FIXME("(%p)\n", This);
 556     return E_NOTIMPL;
 557 }
 558
 559 static HRESULT WINAPI HTMLTable_previousPage(IHTMLTable *iface)
 560 {
 561     HTMLTable *This = impl_from_IHTMLTable(iface);
 562     FIXME("(%p)\n", This);
 563     return E_NOTIMPL;
 564 }
 565
 566 static HRESULT WINAPI HTMLTable_get_tHead(IHTMLTable *iface, IHTMLTableSection **p)
 567 {
 568     HTMLTable *This = impl_from_IHTMLTable(iface);
 569     FIXME("(%p)->(%p)\n", This, p);
 570     return E_NOTIMPL;
 571 }
 572
 573 static HRESULT WINAPI HTMLTable_get_tFoot(IHTMLTable *iface, IHTMLTableSection **p)
 574 {
 575     HTMLTable *This = impl_from_IHTMLTable(iface);
 576     FIXME("(%p)->(%p)\n", This, p);
 577     return E_NOTIMPL;
 578 }
 579
 580 static HRESULT WINAPI HTMLTable_get_tBodies(IHTMLTable *iface, IHTMLElementCollection **p)
 581 {
 582     HTMLTable *This = impl_from_IHTMLTable(iface);
 583     nsIDOMHTMLCollection *nscol = NULL;
 584     nsresult nsres;
 585
 586     TRACE("(%p)->(%p)\n", This, p);
 587
 588     nsres = nsIDOMHTMLTableElement_GetTBodies(This->nstable, &nscol);
 589     if(NS_FAILED(nsres)) {
 590         ERR("GetTBodies failed: %08x\n", nsres);
 591         return E_FAIL;
 592     }
 593
 594     *p = create_collection_from_htmlcol(This->element.node.doc, nscol);
 595
 596     nsIDOMHTMLCollection_Release(nscol);
 597     return S_OK;
 598 }
 599
 600 static HRESULT WINAPI HTMLTable_get_caption(IHTMLTable *iface, IHTMLTableCaption **p)
 601 {
 602     HTMLTable *This = impl_from_IHTMLTable(iface);
 603     FIXME("(%p)->(%p)\n", This, p);
 604     return E_NOTIMPL;
 605 }
 606
 607 static HRESULT WINAPI HTMLTable_createTHead(IHTMLTable *iface, IDispatch **head)
 608 {
 609     HTMLTable *This = impl_from_IHTMLTable(iface);
 610     FIXME("(%p)->(%p)\n", This, head);
 611     return E_NOTIMPL;
 612 }
 613
 614 static HRESULT WINAPI HTMLTable_deleteTHead(IHTMLTable *iface)
 615 {
 616     HTMLTable *This = impl_from_IHTMLTable(iface);
 617     FIXME("(%p)\n", This);
 618     return E_NOTIMPL;
 619 }
 620
 621 static HRESULT WINAPI HTMLTable_createTFoot(IHTMLTable *iface, IDispatch **foot)
 622 {
 623     HTMLTable *This = impl_from_IHTMLTable(iface);
 624     FIXME("(%p)->(%p)\n", This, foot);
 625     return E_NOTIMPL;
 626 }
 627
 628 static HRESULT WINAPI HTMLTable_deleteTFoot(IHTMLTable *iface)
 629 {
 630     HTMLTable *This = impl_from_IHTMLTable(iface);
 631     FIXME("(%p)\n", This);
 632     return E_NOTIMPL;
 633 }
 634
 635 static HRESULT WINAPI HTMLTable_createCaption(IHTMLTable *iface, IHTMLTableCaption **caption)
 636 {
 637     HTMLTable *This = impl_from_IHTMLTable(iface);
 638     FIXME("(%p)->(%p)\n", This, caption);
 639     return E_NOTIMPL;
 640 }
 641
 642 static HRESULT WINAPI HTMLTable_deleteCaption(IHTMLTable *iface)
 643 {
 644     HTMLTable *This = impl_from_IHTMLTable(iface);
 645     FIXME("(%p)\n", This);
 646     return E_NOTIMPL;
 647 }
 648
 649 static HRESULT WINAPI HTMLTable_insertRow(IHTMLTable *iface, LONG index, IDispatch **row)
 650 {
 651     HTMLTable *This = impl_from_IHTMLTable(iface);
 652     nsIDOMHTMLElement *nselem;
 653     HTMLElement *elem;
 654     nsresult nsres;
 655     HRESULT hres;
 656
 657     TRACE("(%p)->(%d %p)\n", This, index, row);
 658     nsres = nsIDOMHTMLTableElement_InsertRow(This->nstable, index, &nselem);
 659     if(NS_FAILED(nsres)) {
 660         ERR("Insert Row at %d failed: %08x\n", index, nsres);
 661         return E_FAIL;
 662     }
 663
 664     hres = HTMLTableRow_Create(This->element.node.doc, nselem, &elem);
 665     nsIDOMHTMLElement_Release(nselem);
 666     if (FAILED(hres)) {
 667         ERR("Create TableRow failed: %08x\n", hres);
 668         return hres;
 669     }
 670
 671     *row = (IDispatch *)&elem->IHTMLElement_iface;
 672     return S_OK;
 673 }
 674
 675 static HRESULT WINAPI HTMLTable_deleteRow(IHTMLTable *iface, LONG index)
 676 {
 677     HTMLTable *This = impl_from_IHTMLTable(iface);
 678     nsresult nsres;
 679
 680     TRACE("(%p)->(%d)\n", This, index);
 681     nsres = nsIDOMHTMLTableElement_DeleteRow(This->nstable, index);
 682     if(NS_FAILED(nsres)) {
 683         ERR("Delete Row failed: %08x\n", nsres);
 684         return E_FAIL;
 685     }
 686     return S_OK;
 687 }
 688
 689 static HRESULT WINAPI HTMLTable_get_readyState(IHTMLTable *iface, BSTR *p)
 690 {
 691     HTMLTable *This = impl_from_IHTMLTable(iface);
 692     FIXME("(%p)->(%p)\n", This, p);
 693     return E_NOTIMPL;
 694 }
 695
 696 static HRESULT WINAPI HTMLTable_put_onreadystatechange(IHTMLTable *iface, VARIANT v)
 697 {
 698     HTMLTable *This = impl_from_IHTMLTable(iface);
 699     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 700     return E_NOTIMPL;
 701 }
 702
 703 static HRESULT WINAPI HTMLTable_get_onreadystatechange(IHTMLTable *iface, VARIANT *p)
 704 {
 705     HTMLTable *This = impl_from_IHTMLTable(iface);
 706     FIXME("(%p)->(%p)\n", This, p);
 707     return E_NOTIMPL;
 708 }
 709
 710 static const IHTMLTableVtbl HTMLTableVtbl = {
 711     HTMLTable_QueryInterface,
 712     HTMLTable_AddRef,
 713     HTMLTable_Release,
 714     HTMLTable_GetTypeInfoCount,
 715     HTMLTable_GetTypeInfo,
 716     HTMLTable_GetIDsOfNames,
 717     HTMLTable_Invoke,
 718     HTMLTable_put_cols,
 719     HTMLTable_get_cols,
 720     HTMLTable_put_border,
 721     HTMLTable_get_border,
 722     HTMLTable_put_frame,
 723     HTMLTable_get_frame,
 724     HTMLTable_put_rules,
 725     HTMLTable_get_rules,
 726     HTMLTable_put_cellSpacing,
 727     HTMLTable_get_cellSpacing,
 728     HTMLTable_put_cellPadding,
 729     HTMLTable_get_cellPadding,
 730     HTMLTable_put_background,
 731     HTMLTable_get_background,
 732     HTMLTable_put_bgColor,
 733     HTMLTable_get_bgColor,
 734     HTMLTable_put_borderColor,
 735     HTMLTable_get_borderColor,
 736     HTMLTable_put_borderColorLight,
 737     HTMLTable_get_borderColorLight,
 738     HTMLTable_put_borderColorDark,
 739     HTMLTable_get_borderColorDark,
 740     HTMLTable_put_align,
 741     HTMLTable_get_align,
 742     HTMLTable_refresh,
 743     HTMLTable_get_rows,
 744     HTMLTable_put_width,
 745     HTMLTable_get_width,
 746     HTMLTable_put_height,
 747     HTMLTable_get_height,
 748     HTMLTable_put_dataPageSize,
 749     HTMLTable_get_dataPageSize,
 750     HTMLTable_nextPage,
 751     HTMLTable_previousPage,
 752     HTMLTable_get_tHead,
 753     HTMLTable_get_tFoot,
 754     HTMLTable_get_tBodies,
 755     HTMLTable_get_caption,
 756     HTMLTable_createTHead,
 757     HTMLTable_deleteTHead,
 758     HTMLTable_createTFoot,
 759     HTMLTable_deleteTFoot,
 760     HTMLTable_createCaption,
 761     HTMLTable_deleteCaption,
 762     HTMLTable_insertRow,
 763     HTMLTable_deleteRow,
 764     HTMLTable_get_readyState,
 765     HTMLTable_put_onreadystatechange,
 766     HTMLTable_get_onreadystatechange
 767 };
 768
 769 /* IHTMLTable2 */
 770 static HRESULT WINAPI HTMLTable2_QueryInterface(IHTMLTable2 *iface,
 771                                                          REFIID riid, void **ppv)
 772 {
 773     HTMLTable *This = impl_from_IHTMLTable2(iface);
 774
 775     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 776 }
 777
 778 static ULONG WINAPI HTMLTable2_AddRef(IHTMLTable2 *iface)
 779 {
 780     HTMLTable *This = impl_from_IHTMLTable2(iface);
 781
 782     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 783 }
 784
 785 static ULONG WINAPI HTMLTable2_Release(IHTMLTable2 *iface)
 786 {
 787     HTMLTable *This = impl_from_IHTMLTable2(iface);
 788
 789     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 790 }
 791
 792 static HRESULT WINAPI HTMLTable2_GetTypeInfoCount(IHTMLTable2 *iface, UINT *pctinfo)
 793 {
 794     HTMLTable *This = impl_from_IHTMLTable2(iface);
 795     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
 796 }
 797
 798 static HRESULT WINAPI HTMLTable2_GetTypeInfo(IHTMLTable2 *iface, UINT iTInfo,
 799                                               LCID lcid, ITypeInfo **ppTInfo)
 800 {
 801     HTMLTable *This = impl_from_IHTMLTable2(iface);
 802     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
 803             ppTInfo);
 804 }
 805
 806 static HRESULT WINAPI HTMLTable2_GetIDsOfNames(IHTMLTable2 *iface, REFIID riid,
 807                                                 LPOLESTR *rgszNames, UINT cNames,
 808                                                 LCID lcid, DISPID *rgDispId)
 809 {
 810     HTMLTable *This = impl_from_IHTMLTable2(iface);
 811     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 812             cNames, lcid, rgDispId);
 813 }
 814
 815 static HRESULT WINAPI HTMLTable2_Invoke(IHTMLTable2 *iface, DISPID dispIdMember,
 816                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 817                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 818 {
 819     HTMLTable *This = impl_from_IHTMLTable2(iface);
 820     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 821             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 822 }
 823
 824 static HRESULT WINAPI HTMLTable2_firstPage(IHTMLTable2 *iface)
 825 {
 826     HTMLTable *This = impl_from_IHTMLTable2(iface);
 827     FIXME("(%p)->()\n", This);
 828     return E_NOTIMPL;
 829 }
 830
 831 static HRESULT WINAPI HTMLTable2_lastPage(IHTMLTable2 *iface)
 832 {
 833     HTMLTable *This = impl_from_IHTMLTable2(iface);
 834     FIXME("(%p)->()\n", This);
 835     return E_NOTIMPL;
 836 }
 837
 838 static HRESULT WINAPI HTMLTable2_cells(IHTMLTable2 *iface, IHTMLElementCollection **p)
 839 {
 840     HTMLTable *This = impl_from_IHTMLTable2(iface);
 841     FIXME("(%p)->(%p)\n", This, p);
 842     return E_NOTIMPL;
 843 }
 844
 845 static HRESULT WINAPI HTMLTable2_moveRow(IHTMLTable2 *iface, LONG indexFrom, LONG indexTo, IDispatch **row)
 846 {
 847     HTMLTable *This = impl_from_IHTMLTable2(iface);
 848     FIXME("(%p)->(%d %d %p)\n", This, indexFrom, indexTo, row);
 849     return E_NOTIMPL;
 850 }
 851
 852
 853 static const IHTMLTable2Vtbl HTMLTable2Vtbl = {
 854     HTMLTable2_QueryInterface,
 855     HTMLTable2_AddRef,
 856     HTMLTable2_Release,
 857     HTMLTable2_GetTypeInfoCount,
 858     HTMLTable2_GetTypeInfo,
 859     HTMLTable2_GetIDsOfNames,
 860     HTMLTable2_Invoke,
 861     HTMLTable2_firstPage,
 862     HTMLTable2_lastPage,
 863     HTMLTable2_cells,
 864     HTMLTable2_moveRow
 865 };
 866
 867 /* IHTMLTable3 */
 868 static HRESULT WINAPI HTMLTable3_QueryInterface(IHTMLTable3 *iface,
 869                                                          REFIID riid, void **ppv)
 870 {
 871     HTMLTable *This = impl_from_IHTMLTable3(iface);
 872
 873     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 874 }
 875
 876 static ULONG WINAPI HTMLTable3_AddRef(IHTMLTable3 *iface)
 877 {
 878     HTMLTable *This = impl_from_IHTMLTable3(iface);
 879
 880     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 881 }
 882
 883 static ULONG WINAPI HTMLTable3_Release(IHTMLTable3 *iface)
 884 {
 885     HTMLTable *This = impl_from_IHTMLTable3(iface);
 886
 887     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 888 }
 889
 890 static HRESULT WINAPI HTMLTable3_GetTypeInfoCount(IHTMLTable3 *iface, UINT *pctinfo)
 891 {
 892     HTMLTable *This = impl_from_IHTMLTable3(iface);
 893     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
 894 }
 895
 896 static HRESULT WINAPI HTMLTable3_GetTypeInfo(IHTMLTable3 *iface, UINT iTInfo,
 897                                               LCID lcid, ITypeInfo **ppTInfo)
 898 {
 899     HTMLTable *This = impl_from_IHTMLTable3(iface);
 900     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
 901             ppTInfo);
 902 }
 903
 904 static HRESULT WINAPI HTMLTable3_GetIDsOfNames(IHTMLTable3 *iface, REFIID riid,
 905                                                 LPOLESTR *rgszNames, UINT cNames,
 906                                                 LCID lcid, DISPID *rgDispId)
 907 {
 908     HTMLTable *This = impl_from_IHTMLTable3(iface);
 909     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 910             cNames, lcid, rgDispId);
 911 }
 912
 913 static HRESULT WINAPI HTMLTable3_Invoke(IHTMLTable3 *iface, DISPID dispIdMember,
 914                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 915                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 916 {
 917     HTMLTable *This = impl_from_IHTMLTable3(iface);
 918     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 919             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 920 }
 921
 922 static HRESULT WINAPI HTMLTable3_put_summary(IHTMLTable3 *iface, BSTR v)
 923 {
 924     HTMLTable *This = impl_from_IHTMLTable3(iface);
 925     nsAString str;
 926     nsresult nsres;
 927
 928     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 929
 930     nsAString_InitDepend(&str, v);
 931
 932     nsres = nsIDOMHTMLTableElement_SetSummary(This->nstable, &str);
 933
 934     nsAString_Finish(&str);
 935     if (NS_FAILED(nsres)) {
 936         ERR("Set summary(%s) failed: %08x\n", debugstr_w(v), nsres);
 937         return E_FAIL;
 938     }
 939     return S_OK;
 940 }
 941
 942 static HRESULT WINAPI HTMLTable3_get_summary(IHTMLTable3 *iface, BSTR * p)
 943 {
 944     HTMLTable *This = impl_from_IHTMLTable3(iface);
 945     nsAString str;
 946     nsresult nsres;
 947
 948     TRACE("(%p)->(%p)\n", This, p);
 949
 950     nsAString_Init(&str, NULL);
 951     nsres = nsIDOMHTMLTableElement_GetSummary(This->nstable, &str);
 952
 953     return return_nsstr(nsres, &str, p);
 954 }
 955
 956 static const IHTMLTable3Vtbl HTMLTable3Vtbl = {
 957     HTMLTable3_QueryInterface,
 958     HTMLTable3_AddRef,
 959     HTMLTable3_Release,
 960     HTMLTable3_GetTypeInfoCount,
 961     HTMLTable3_GetTypeInfo,
 962     HTMLTable3_GetIDsOfNames,
 963     HTMLTable3_Invoke,
 964     HTMLTable3_put_summary,
 965     HTMLTable3_get_summary
 966 };
 967
 968 static inline HTMLTable *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
 969 {
 970     return CONTAINING_RECORD(iface, HTMLTable, element.node);
 971 }
 972
 973 static HRESULT HTMLTable_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 974 {
 975     HTMLTable *This = impl_from_HTMLDOMNode(iface);
 976
 977     *ppv = NULL;
 978
 979     if(IsEqualGUID(&IID_IUnknown, riid)) {
 980         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 981         *ppv = &This->IHTMLTable_iface;
 982     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 983         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 984         *ppv = &This->IHTMLTable_iface;
 985     }else if(IsEqualGUID(&IID_IHTMLTable, riid)) {
 986         TRACE("(%p)->(IID_IHTMLTable %p)\n", This, ppv);
 987         *ppv = &This->IHTMLTable_iface;
 988     }else if(IsEqualGUID(&IID_IHTMLTable2, riid)) {
 989         TRACE("(%p)->(IID_IHTMLTable2 %p)\n", This, ppv);
 990         *ppv = &This->IHTMLTable2_iface;
 991     }else if(IsEqualGUID(&IID_IHTMLTable3, riid)) {
 992         TRACE("(%p)->(IID_IHTMLTable3 %p)\n", This, ppv);
 993         *ppv = &This->IHTMLTable3_iface;
 994     }
 995
 996     if(*ppv) {
 997         IUnknown_AddRef((IUnknown*)*ppv);
 998         return S_OK;
 999     }
1000
1001     return HTMLElement_QI(&This->element.node, riid, ppv);
1002 }
1003
1004 static void HTMLTable_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
1005 {
1006     HTMLTable *This = impl_from_HTMLDOMNode(iface);
1007
1008     if(This->nstable)
1009         note_cc_edge((nsISupports*)This->nstable, "This->nstable", cb);
1010 }
1011
1012 static void HTMLTable_unlink(HTMLDOMNode *iface)
1013 {
1014     HTMLTable *This = impl_from_HTMLDOMNode(iface);
1015
1016     if(This->nstable) {
1017         nsIDOMHTMLTableElement *nstable = This->nstable;
1018
1019         This->nstable = NULL;
1020         nsIDOMHTMLTableElement_Release(nstable);
1021     }
1022 }
1023
1024 static const cpc_entry_t HTMLTable_cpc[] = {
1025     {&DIID_HTMLTableEvents},
1026     HTMLELEMENT_CPC,
1027     {NULL}
1028 };
1029
1030 static const NodeImplVtbl HTMLTableImplVtbl = {
1031     HTMLTable_QI,
1032     HTMLElement_destructor,
1033     HTMLTable_cpc,
1034     HTMLElement_clone,
1035     HTMLElement_handle_event,
1036     HTMLElement_get_attr_col,
1037     NULL,
1038     NULL,
1039     NULL,
1040     NULL,
1041     NULL,
1042     NULL,
1043     NULL,
1044     NULL,
1045     NULL,
1046     HTMLTable_traverse,
1047     HTMLTable_unlink
1048 };
1049
1050 static const tid_t HTMLTable_iface_tids[] = {
1051     HTMLELEMENT_TIDS,
1052     IHTMLTable_tid,
1053     IHTMLTable2_tid,
1054     IHTMLTable3_tid,
1055     0
1056 };
1057
1058 static dispex_static_data_t HTMLTable_dispex = {
1059     NULL,
1060     DispHTMLTable_tid,
1061     NULL,
1062     HTMLTable_iface_tids
1063 };
1064
1065 HRESULT HTMLTable_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
1066 {
1067     HTMLTable *ret;
1068     nsresult nsres;
1069
1070     ret = heap_alloc_zero(sizeof(HTMLTable));
1071     if(!ret)
1072         return E_OUTOFMEMORY;
1073
1074     ret->element.node.vtbl = &HTMLTableImplVtbl;
1075     ret->IHTMLTable_iface.lpVtbl = &HTMLTableVtbl;
1076     ret->IHTMLTable2_iface.lpVtbl = &HTMLTable2Vtbl;
1077     ret->IHTMLTable3_iface.lpVtbl = &HTMLTable3Vtbl;
1078
1079     HTMLElement_Init(&ret->element, doc, nselem, &HTMLTable_dispex);
1080
1081     nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableElement, (void**)&ret->nstable);
1082     assert(nsres == NS_OK);
1083
1084     *elem = &ret->element;
1085     return S_OK;
1086 }