dlls/mshtml/htmltable.c

   1 /*
   2  * Copyright 2007,2008,2012 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 struct HTMLTableCell {
  35     HTMLElement element;
  36
  37     IHTMLTableCell IHTMLTableCell_iface;
  38
  39     nsIDOMHTMLTableCellElement *nscell;
  40 };
  41
  42 static inline HTMLTableCell *impl_from_IHTMLTableCell(IHTMLTableCell *iface)
  43 {
  44     return CONTAINING_RECORD(iface, HTMLTableCell, IHTMLTableCell_iface);
  45 }
  46
  47 static HRESULT WINAPI HTMLTableCell_QueryInterface(IHTMLTableCell *iface, REFIID riid, void **ppv)
  48 {
  49     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
  50
  51     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
  52 }
  53
  54 static ULONG WINAPI HTMLTableCell_AddRef(IHTMLTableCell *iface)
  55 {
  56     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
  57
  58     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
  59 }
  60
  61 static ULONG WINAPI HTMLTableCell_Release(IHTMLTableCell *iface)
  62 {
  63     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
  64
  65     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
  66 }
  67
  68 static HRESULT WINAPI HTMLTableCell_GetTypeInfoCount(IHTMLTableCell *iface, UINT *pctinfo)
  69 {
  70     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
  71     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
  72 }
  73
  74 static HRESULT WINAPI HTMLTableCell_GetTypeInfo(IHTMLTableCell *iface, UINT iTInfo,
  75                                               LCID lcid, ITypeInfo **ppTInfo)
  76 {
  77     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
  78     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
  79             ppTInfo);
  80 }
  81
  82 static HRESULT WINAPI HTMLTableCell_GetIDsOfNames(IHTMLTableCell *iface, REFIID riid,
  83         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
  84 {
  85     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
  86     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
  87             cNames, lcid, rgDispId);
  88 }
  89
  90 static HRESULT WINAPI HTMLTableCell_Invoke(IHTMLTableCell *iface, DISPID dispIdMember, REFIID riid,
  91         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
  92         UINT *puArgErr)
  93 {
  94     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
  95     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
  96             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
  97 }
  98
  99 static HRESULT WINAPI HTMLTableCell_put_rowSpan(IHTMLTableCell *iface, LONG v)
 100 {
 101     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 102     nsresult nsres;
 103
 104     TRACE("(%p)->(%ld)\n", This, v);
 105
 106     if(v <= 0)
 107         return E_INVALIDARG;
 108
 109     nsres = nsIDOMHTMLTableCellElement_SetRowSpan(This->nscell, v);
 110     if(NS_FAILED(nsres)) {
 111         ERR("SetRowSpan failed: %08lx\n", nsres);
 112         return E_FAIL;
 113     }
 114
 115     return S_OK;
 116 }
 117
 118 static HRESULT WINAPI HTMLTableCell_get_rowSpan(IHTMLTableCell *iface, LONG *p)
 119 {
 120     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 121     nsresult nsres;
 122
 123     TRACE("(%p)->(%p)\n", This, p);
 124
 125     nsres = nsIDOMHTMLTableCellElement_GetRowSpan(This->nscell, p);
 126     if(NS_FAILED(nsres)) {
 127         ERR("GetRowSpan failed: %08lx\n", nsres);
 128         return E_FAIL;
 129     }
 130
 131     return S_OK;
 132 }
 133
 134 static HRESULT WINAPI HTMLTableCell_put_colSpan(IHTMLTableCell *iface, LONG v)
 135 {
 136     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 137     nsresult nsres;
 138
 139     TRACE("(%p)->(%ld)\n", This, v);
 140
 141     if(v <= 0)
 142         return E_INVALIDARG;
 143
 144     nsres = nsIDOMHTMLTableCellElement_SetColSpan(This->nscell, v);
 145     if(NS_FAILED(nsres)) {
 146         ERR("SetColSpan failed: %08lx\n", nsres);
 147         return E_FAIL;
 148     }
 149
 150     return S_OK;
 151 }
 152
 153 static HRESULT WINAPI HTMLTableCell_get_colSpan(IHTMLTableCell *iface, LONG *p)
 154 {
 155     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 156     nsresult nsres;
 157
 158     TRACE("(%p)->(%p)\n", This, p);
 159
 160     nsres = nsIDOMHTMLTableCellElement_GetColSpan(This->nscell, p);
 161     if(NS_FAILED(nsres)) {
 162         ERR("GetColSpan failed: %08lx\n", nsres);
 163         return E_FAIL;
 164     }
 165
 166     return S_OK;
 167 }
 168
 169 static HRESULT WINAPI HTMLTableCell_put_align(IHTMLTableCell *iface, BSTR v)
 170 {
 171     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 172     nsAString str;
 173     nsresult nsres;
 174
 175     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 176
 177     nsAString_InitDepend(&str, v);
 178     nsres = nsIDOMHTMLTableCellElement_SetAlign(This->nscell, &str);
 179     nsAString_Finish(&str);
 180     if (NS_FAILED(nsres)) {
 181         ERR("Set Align failed: %08lx\n", nsres);
 182         return E_FAIL;
 183     }
 184     return S_OK;
 185 }
 186
 187 static HRESULT WINAPI HTMLTableCell_get_align(IHTMLTableCell *iface, BSTR *p)
 188 {
 189     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 190     nsAString str;
 191     nsresult nsres;
 192
 193     TRACE("(%p)->(%p)\n", This, p);
 194
 195     nsAString_Init(&str, NULL);
 196     nsres = nsIDOMHTMLTableCellElement_GetAlign(This->nscell, &str);
 197
 198     return return_nsstr(nsres, &str, p);
 199 }
 200
 201 static HRESULT WINAPI HTMLTableCell_put_vAlign(IHTMLTableCell *iface, BSTR v)
 202 {
 203     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 204     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 205     return E_NOTIMPL;
 206 }
 207
 208 static HRESULT WINAPI HTMLTableCell_get_vAlign(IHTMLTableCell *iface, BSTR *p)
 209 {
 210     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 211     FIXME("(%p)->(%p)\n", This, p);
 212     return E_NOTIMPL;
 213 }
 214
 215 static HRESULT WINAPI HTMLTableCell_put_bgColor(IHTMLTableCell *iface, VARIANT v)
 216 {
 217     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 218     nsAString strColor;
 219     nsresult nsres;
 220
 221     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 222
 223     if(!variant_to_nscolor(&v, &strColor))
 224         return S_OK;
 225
 226     nsres = nsIDOMHTMLTableCellElement_SetBgColor(This->nscell, &strColor);
 227     nsAString_Finish(&strColor);
 228     if(NS_FAILED(nsres)) {
 229         ERR("SetBgColor(%s) failed: %08lx\n", debugstr_variant(&v), nsres);
 230         return E_FAIL;
 231     }
 232
 233     return S_OK;
 234 }
 235
 236 static HRESULT WINAPI HTMLTableCell_get_bgColor(IHTMLTableCell *iface, VARIANT *p)
 237 {
 238     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 239     nsAString strColor;
 240     nsresult nsres;
 241     HRESULT hres;
 242
 243     TRACE("(%p)->(%p)\n", This, p);
 244
 245     nsAString_Init(&strColor, NULL);
 246     nsres = nsIDOMHTMLTableCellElement_GetBgColor(This->nscell, &strColor);
 247
 248     if(NS_SUCCEEDED(nsres)) {
 249         const PRUnichar *color;
 250         nsAString_GetData(&strColor, &color);
 251         V_VT(p) = VT_BSTR;
 252         hres = nscolor_to_str(color, &V_BSTR(p));
 253     }else {
 254         ERR("GetBgColor failed: %08lx\n", nsres);
 255         hres = E_FAIL;
 256     }
 257     nsAString_Finish(&strColor);
 258     return hres;
 259 }
 260
 261 static HRESULT WINAPI HTMLTableCell_put_noWrap(IHTMLTableCell *iface, VARIANT_BOOL v)
 262 {
 263     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 264     FIXME("(%p)->(%x)\n", This, v);
 265     return E_NOTIMPL;
 266 }
 267
 268 static HRESULT WINAPI HTMLTableCell_get_noWrap(IHTMLTableCell *iface, VARIANT_BOOL *p)
 269 {
 270     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 271     FIXME("(%p)->(%p)\n", This, p);
 272     return E_NOTIMPL;
 273 }
 274
 275 static HRESULT WINAPI HTMLTableCell_put_background(IHTMLTableCell *iface, BSTR v)
 276 {
 277     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 278     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 279     return E_NOTIMPL;
 280 }
 281
 282 static HRESULT WINAPI HTMLTableCell_get_background(IHTMLTableCell *iface, BSTR *p)
 283 {
 284     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 285     FIXME("(%p)->(%p)\n", This, p);
 286     return E_NOTIMPL;
 287 }
 288
 289 static HRESULT WINAPI HTMLTableCell_put_borderColor(IHTMLTableCell *iface, VARIANT v)
 290 {
 291     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 292     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI HTMLTableCell_get_borderColor(IHTMLTableCell *iface, VARIANT *p)
 297 {
 298     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 299     FIXME("(%p)->(%p)\n", This, p);
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI HTMLTableCell_put_borderColorLight(IHTMLTableCell *iface, VARIANT v)
 304 {
 305     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 306     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI HTMLTableCell_get_borderColorLight(IHTMLTableCell *iface, VARIANT *p)
 311 {
 312     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 313     FIXME("(%p)->(%p)\n", This, p);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI HTMLTableCell_put_borderColorDark(IHTMLTableCell *iface, VARIANT v)
 318 {
 319     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 320     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI HTMLTableCell_get_borderColorDark(IHTMLTableCell *iface, VARIANT *p)
 325 {
 326     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 327     FIXME("(%p)->(%p)\n", This, p);
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI HTMLTableCell_put_width(IHTMLTableCell *iface, VARIANT v)
 332 {
 333     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 334     nsAString nsstr;
 335     nsresult nsres;
 336     HRESULT hres;
 337
 338     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 339
 340     hres = variant_to_nsstr(&v, FALSE, &nsstr);
 341     if(FAILED(hres))
 342         return hres;
 343
 344     nsres = nsIDOMHTMLTableCellElement_SetWidth(This->nscell, &nsstr);
 345     nsAString_Finish(&nsstr);
 346     return map_nsresult(nsres);
 347 }
 348
 349 static HRESULT WINAPI HTMLTableCell_get_width(IHTMLTableCell *iface, VARIANT *p)
 350 {
 351     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 352     nsAString nsstr;
 353     nsresult nsres;
 354
 355     TRACE("(%p)->(%p)\n", This, p);
 356
 357     nsAString_Init(&nsstr, NULL);
 358     nsres = nsIDOMHTMLTableCellElement_GetWidth(This->nscell, &nsstr);
 359     return return_nsstr_variant(nsres, &nsstr, NSSTR_IMPLICIT_PX, p);
 360 }
 361
 362 static HRESULT WINAPI HTMLTableCell_put_height(IHTMLTableCell *iface, VARIANT v)
 363 {
 364     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 365     nsAString nsstr;
 366     nsresult nsres;
 367     HRESULT hres;
 368
 369     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 370
 371     hres = variant_to_nsstr(&v, FALSE, &nsstr);
 372     if(FAILED(hres))
 373         return hres;
 374
 375     nsres = nsIDOMHTMLTableCellElement_SetHeight(This->nscell, &nsstr);
 376     nsAString_Finish(&nsstr);
 377     return map_nsresult(nsres);
 378 }
 379
 380 static HRESULT WINAPI HTMLTableCell_get_height(IHTMLTableCell *iface, VARIANT *p)
 381 {
 382     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 383     nsAString nsstr;
 384     nsresult nsres;
 385
 386     TRACE("(%p)->(%p)\n", This, p);
 387
 388     nsAString_Init(&nsstr, NULL);
 389     nsres = nsIDOMHTMLTableCellElement_GetHeight(This->nscell, &nsstr);
 390     return return_nsstr_variant(nsres, &nsstr, NSSTR_IMPLICIT_PX, p);
 391 }
 392
 393 static HRESULT WINAPI HTMLTableCell_get_cellIndex(IHTMLTableCell *iface, LONG *p)
 394 {
 395     HTMLTableCell *This = impl_from_IHTMLTableCell(iface);
 396     nsresult nsres;
 397
 398     TRACE("(%p)->(%p)\n", This, p);
 399     nsres = nsIDOMHTMLTableCellElement_GetCellIndex(This->nscell, p);
 400     if (NS_FAILED(nsres)) {
 401         ERR("Get CellIndex failed: %08lx\n", nsres);
 402         return E_FAIL;
 403     }
 404
 405     return S_OK;
 406 }
 407
 408 static const IHTMLTableCellVtbl HTMLTableCellVtbl = {
 409     HTMLTableCell_QueryInterface,
 410     HTMLTableCell_AddRef,
 411     HTMLTableCell_Release,
 412     HTMLTableCell_GetTypeInfoCount,
 413     HTMLTableCell_GetTypeInfo,
 414     HTMLTableCell_GetIDsOfNames,
 415     HTMLTableCell_Invoke,
 416     HTMLTableCell_put_rowSpan,
 417     HTMLTableCell_get_rowSpan,
 418     HTMLTableCell_put_colSpan,
 419     HTMLTableCell_get_colSpan,
 420     HTMLTableCell_put_align,
 421     HTMLTableCell_get_align,
 422     HTMLTableCell_put_vAlign,
 423     HTMLTableCell_get_vAlign,
 424     HTMLTableCell_put_bgColor,
 425     HTMLTableCell_get_bgColor,
 426     HTMLTableCell_put_noWrap,
 427     HTMLTableCell_get_noWrap,
 428     HTMLTableCell_put_background,
 429     HTMLTableCell_get_background,
 430     HTMLTableCell_put_borderColor,
 431     HTMLTableCell_get_borderColor,
 432     HTMLTableCell_put_borderColorLight,
 433     HTMLTableCell_get_borderColorLight,
 434     HTMLTableCell_put_borderColorDark,
 435     HTMLTableCell_get_borderColorDark,
 436     HTMLTableCell_put_width,
 437     HTMLTableCell_get_width,
 438     HTMLTableCell_put_height,
 439     HTMLTableCell_get_height,
 440     HTMLTableCell_get_cellIndex
 441 };
 442
 443 static inline HTMLTableCell *HTMLTableCell_from_HTMLDOMNode(HTMLDOMNode *iface)
 444 {
 445     return CONTAINING_RECORD(iface, HTMLTableCell, element.node);
 446 }
 447
 448 static HRESULT HTMLTableCell_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 449 {
 450     HTMLTableCell *This = HTMLTableCell_from_HTMLDOMNode(iface);
 451
 452     if(IsEqualGUID(&IID_IUnknown, riid)) {
 453         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 454         *ppv = &This->IHTMLTableCell_iface;
 455     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 456         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 457         *ppv = &This->IHTMLTableCell_iface;
 458     }else if(IsEqualGUID(&IID_IHTMLTableCell, riid)) {
 459         TRACE("(%p)->(IID_IHTMLTableCell %p)\n", This, ppv);
 460         *ppv = &This->IHTMLTableCell_iface;
 461     }else {
 462         return HTMLElement_QI(&This->element.node, riid, ppv);
 463     }
 464
 465     IUnknown_AddRef((IUnknown*)*ppv);
 466     return S_OK;
 467 }
 468
 469 static void HTMLTableCell_destructor(HTMLDOMNode *iface)
 470 {
 471     HTMLTableCell *This = HTMLTableCell_from_HTMLDOMNode(iface);
 472
 473     HTMLElement_destructor(&This->element.node);
 474 }
 475
 476 static void HTMLTableCell_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
 477 {
 478     HTMLTableCell *This = HTMLTableCell_from_HTMLDOMNode(iface);
 479
 480     if(This->nscell)
 481         note_cc_edge((nsISupports*)This->nscell, "This->nstablecell", cb);
 482 }
 483
 484 static void HTMLTableCell_unlink(HTMLDOMNode *iface)
 485 {
 486     HTMLTableCell *This = HTMLTableCell_from_HTMLDOMNode(iface);
 487
 488     if(This->nscell) {
 489         nsIDOMHTMLTableCellElement *nscell = This->nscell;
 490
 491         This->nscell = NULL;
 492         nsIDOMHTMLTableCellElement_Release(nscell);
 493     }
 494 }
 495
 496 static const NodeImplVtbl HTMLTableCellImplVtbl = {
 497     &CLSID_HTMLTableCell,
 498     HTMLTableCell_QI,
 499     HTMLTableCell_destructor,
 500     HTMLElement_cpc,
 501     HTMLElement_clone,
 502     HTMLElement_dispatch_nsevent_hook,
 503     HTMLElement_handle_event,
 504     HTMLElement_get_attr_col,
 505     NULL,
 506     NULL,
 507     NULL,
 508     NULL,
 509     NULL,
 510     NULL,
 511     NULL,
 512     NULL,
 513     NULL,
 514     HTMLTableCell_traverse,
 515     HTMLTableCell_unlink
 516 };
 517
 518 static const tid_t HTMLTableCell_iface_tids[] = {
 519     HTMLELEMENT_TIDS,
 520     IHTMLTableCell_tid,
 521     0
 522 };
 523
 524 static dispex_static_data_t HTMLTableCell_dispex = {
 525     L"HTMLTableDataCellElement",
 526     NULL,
 527     DispHTMLTableCell_tid,
 528     HTMLTableCell_iface_tids,
 529     HTMLElement_init_dispex_info
 530 };
 531
 532 HRESULT HTMLTableCell_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
 533 {
 534     HTMLTableCell *ret;
 535     nsresult nsres;
 536
 537     ret = calloc(1, sizeof(*ret));
 538     if(!ret)
 539         return E_OUTOFMEMORY;
 540
 541     ret->IHTMLTableCell_iface.lpVtbl = &HTMLTableCellVtbl;
 542     ret->element.node.vtbl = &HTMLTableCellImplVtbl;
 543
 544     HTMLElement_Init(&ret->element, doc, nselem, &HTMLTableCell_dispex);
 545
 546     nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableCellElement, (void**)&ret->nscell);
 547     assert(nsres == NS_OK);
 548
 549     *elem = &ret->element;
 550     return S_OK;
 551 }
 552
 553 struct HTMLTableRow {
 554     HTMLElement element;
 555
 556     IHTMLTableRow IHTMLTableRow_iface;
 557
 558     nsIDOMHTMLTableRowElement *nsrow;
 559 };
 560
 561 static inline HTMLTableRow *impl_from_IHTMLTableRow(IHTMLTableRow *iface)
 562 {
 563     return CONTAINING_RECORD(iface, HTMLTableRow, IHTMLTableRow_iface);
 564 }
 565
 566 static HRESULT WINAPI HTMLTableRow_QueryInterface(IHTMLTableRow *iface,
 567         REFIID riid, void **ppv)
 568 {
 569     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 570
 571     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 572 }
 573
 574 static ULONG WINAPI HTMLTableRow_AddRef(IHTMLTableRow *iface)
 575 {
 576     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 577
 578     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 579 }
 580
 581 static ULONG WINAPI HTMLTableRow_Release(IHTMLTableRow *iface)
 582 {
 583     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 584
 585     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 586 }
 587
 588 static HRESULT WINAPI HTMLTableRow_GetTypeInfoCount(IHTMLTableRow *iface, UINT *pctinfo)
 589 {
 590     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 591     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
 592 }
 593
 594 static HRESULT WINAPI HTMLTableRow_GetTypeInfo(IHTMLTableRow *iface, UINT iTInfo,
 595                                               LCID lcid, ITypeInfo **ppTInfo)
 596 {
 597     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 598     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
 599             ppTInfo);
 600 }
 601
 602 static HRESULT WINAPI HTMLTableRow_GetIDsOfNames(IHTMLTableRow *iface, REFIID riid,
 603                                                 LPOLESTR *rgszNames, UINT cNames,
 604                                                 LCID lcid, DISPID *rgDispId)
 605 {
 606     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 607     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 608             cNames, lcid, rgDispId);
 609 }
 610
 611 static HRESULT WINAPI HTMLTableRow_Invoke(IHTMLTableRow *iface, DISPID dispIdMember,
 612                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 613                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 614 {
 615     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 616     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 617             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 618 }
 619
 620 static HRESULT WINAPI HTMLTableRow_put_align(IHTMLTableRow *iface, BSTR v)
 621 {
 622     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 623     nsAString val;
 624     nsresult nsres;
 625
 626     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 627
 628     nsAString_InitDepend(&val, v);
 629
 630     nsres = nsIDOMHTMLTableRowElement_SetAlign(This->nsrow, &val);
 631     nsAString_Finish(&val);
 632     if (NS_FAILED(nsres)){
 633         ERR("Set Align(%s) failed!\n", debugstr_w(v));
 634         return E_FAIL;
 635     }
 636     return S_OK;
 637 }
 638
 639 static HRESULT WINAPI HTMLTableRow_get_align(IHTMLTableRow *iface, BSTR *p)
 640 {
 641     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 642     nsAString val;
 643     nsresult nsres;
 644
 645     TRACE("(%p)->(%p)\n", This, p);
 646
 647     nsAString_Init(&val, NULL);
 648     nsres = nsIDOMHTMLTableRowElement_GetAlign(This->nsrow, &val);
 649
 650     return return_nsstr(nsres, &val, p);
 651 }
 652
 653 static HRESULT WINAPI HTMLTableRow_put_vAlign(IHTMLTableRow *iface, BSTR v)
 654 {
 655     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 656     nsAString val;
 657     nsresult nsres;
 658
 659     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 660
 661     nsAString_InitDepend(&val, v);
 662
 663     nsres = nsIDOMHTMLTableRowElement_SetVAlign(This->nsrow, &val);
 664     nsAString_Finish(&val);
 665
 666     if (NS_FAILED(nsres)){
 667         ERR("Set VAlign(%s) failed!\n", debugstr_w(v));
 668         return E_FAIL;
 669     }
 670
 671     return S_OK;
 672 }
 673
 674 static HRESULT WINAPI HTMLTableRow_get_vAlign(IHTMLTableRow *iface, BSTR *p)
 675 {
 676     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 677     nsAString val;
 678     nsresult nsres;
 679
 680     TRACE("(%p)->(%p)\n", This, p);
 681
 682     nsAString_Init(&val, NULL);
 683     nsres = nsIDOMHTMLTableRowElement_GetVAlign(This->nsrow, &val);
 684
 685     return return_nsstr(nsres, &val, p);
 686 }
 687
 688 static HRESULT WINAPI HTMLTableRow_put_bgColor(IHTMLTableRow *iface, VARIANT v)
 689 {
 690     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 691     nsAString val;
 692     nsresult nsres;
 693
 694     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 695
 696     if (!variant_to_nscolor(&v, &val))
 697         return S_OK;
 698
 699     nsres = nsIDOMHTMLTableRowElement_SetBgColor(This->nsrow, &val);
 700     nsAString_Finish(&val);
 701
 702     if (NS_FAILED(nsres)){
 703         ERR("Set BgColor(%s) failed!\n", debugstr_variant(&v));
 704         return E_FAIL;
 705     }
 706
 707     return S_OK;
 708 }
 709
 710 static HRESULT WINAPI HTMLTableRow_get_bgColor(IHTMLTableRow *iface, VARIANT *p)
 711 {
 712     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 713     nsAString strColor;
 714     nsresult nsres;
 715     HRESULT hres;
 716     const PRUnichar *color;
 717
 718     TRACE("(%p)->(%p)\n", This, p);
 719
 720     nsAString_Init(&strColor, NULL);
 721     nsres = nsIDOMHTMLTableRowElement_GetBgColor(This->nsrow, &strColor);
 722
 723     if(NS_SUCCEEDED(nsres)) {
 724        nsAString_GetData(&strColor, &color);
 725        V_VT(p) = VT_BSTR;
 726        hres = nscolor_to_str(color, &V_BSTR(p));
 727     }else {
 728        ERR("SetBgColor failed: %08lx\n", nsres);
 729        hres = E_FAIL;
 730     }
 731
 732     nsAString_Finish(&strColor);
 733     return hres;
 734 }
 735
 736 static HRESULT WINAPI HTMLTableRow_put_borderColor(IHTMLTableRow *iface, VARIANT v)
 737 {
 738     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 739     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI HTMLTableRow_get_borderColor(IHTMLTableRow *iface, VARIANT *p)
 744 {
 745     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 746     FIXME("(%p)->(%p)\n", This, p);
 747     return E_NOTIMPL;
 748 }
 749
 750 static HRESULT WINAPI HTMLTableRow_put_borderColorLight(IHTMLTableRow *iface, VARIANT v)
 751 {
 752     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 753     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT WINAPI HTMLTableRow_get_borderColorLight(IHTMLTableRow *iface, VARIANT *p)
 758 {
 759     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 760     FIXME("(%p)->(%p)\n", This, p);
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT WINAPI HTMLTableRow_put_borderColorDark(IHTMLTableRow *iface, VARIANT v)
 765 {
 766     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 767     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 768     return E_NOTIMPL;
 769 }
 770
 771 static HRESULT WINAPI HTMLTableRow_get_borderColorDark(IHTMLTableRow *iface, VARIANT *p)
 772 {
 773     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 774     FIXME("(%p)->(%p)\n", This, p);
 775     return E_NOTIMPL;
 776 }
 777
 778 static HRESULT WINAPI HTMLTableRow_get_rowIndex(IHTMLTableRow *iface, LONG *p)
 779 {
 780     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 781     nsresult nsres;
 782
 783     TRACE("(%p)->(%p)\n", This, p);
 784     nsres = nsIDOMHTMLTableRowElement_GetRowIndex(This->nsrow, p);
 785     if(NS_FAILED(nsres)) {
 786         ERR("Get rowIndex failed: %08lx\n", nsres);
 787         return E_FAIL;
 788     }
 789     return S_OK;
 790 }
 791
 792 static HRESULT WINAPI HTMLTableRow_get_sectionRowIndex(IHTMLTableRow *iface, LONG *p)
 793 {
 794     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 795     nsresult nsres;
 796
 797     TRACE("(%p)->(%p)\n", This, p);
 798     nsres = nsIDOMHTMLTableRowElement_GetSectionRowIndex(This->nsrow, p);
 799     if(NS_FAILED(nsres)) {
 800         ERR("Get selectionRowIndex failed: %08lx\n", nsres);
 801         return E_FAIL;
 802     }
 803     return S_OK;
 804 }
 805
 806 static HRESULT WINAPI HTMLTableRow_get_cells(IHTMLTableRow *iface, IHTMLElementCollection **p)
 807 {
 808     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 809     nsIDOMHTMLCollection *nscol;
 810     nsresult nsres;
 811
 812     TRACE("(%p)->(%p)\n", This, p);
 813
 814     nsres = nsIDOMHTMLTableRowElement_GetCells(This->nsrow, &nscol);
 815     if(NS_FAILED(nsres)) {
 816         ERR("GetCells failed: %08lx\n", nsres);
 817         return E_FAIL;
 818     }
 819
 820     *p = create_collection_from_htmlcol(nscol, dispex_compat_mode(&This->element.node.event_target.dispex));
 821
 822     nsIDOMHTMLCollection_Release(nscol);
 823     return S_OK;
 824 }
 825
 826 static HRESULT WINAPI HTMLTableRow_insertCell(IHTMLTableRow *iface, LONG index, IDispatch **row)
 827 {
 828     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 829     nsIDOMHTMLElement *nselem;
 830     HTMLElement *elem;
 831     nsresult nsres;
 832     HRESULT hres;
 833
 834     TRACE("(%p)->(%ld %p)\n", This, index, row);
 835     nsres = nsIDOMHTMLTableRowElement_InsertCell(This->nsrow, index, &nselem);
 836     if(NS_FAILED(nsres)) {
 837         ERR("Insert Cell at %ld failed: %08lx\n", index, nsres);
 838         return E_FAIL;
 839     }
 840
 841     hres = HTMLTableCell_Create(This->element.node.doc, (nsIDOMElement*)nselem, &elem);
 842     nsIDOMHTMLElement_Release(nselem);
 843     if (FAILED(hres)) {
 844         ERR("Create TableCell failed: %08lx\n", hres);
 845         return hres;
 846     }
 847
 848     *row = (IDispatch *)&elem->IHTMLElement_iface;
 849     return S_OK;
 850 }
 851
 852 static HRESULT WINAPI HTMLTableRow_deleteCell(IHTMLTableRow *iface, LONG index)
 853 {
 854     HTMLTableRow *This = impl_from_IHTMLTableRow(iface);
 855     nsresult nsres;
 856
 857     TRACE("(%p)->(%ld)\n", This, index);
 858     nsres = nsIDOMHTMLTableRowElement_DeleteCell(This->nsrow, index);
 859     if(NS_FAILED(nsres)) {
 860         ERR("Delete Cell failed: %08lx\n", nsres);
 861         return E_FAIL;
 862     }
 863     return S_OK;
 864 }
 865
 866 static const IHTMLTableRowVtbl HTMLTableRowVtbl = {
 867     HTMLTableRow_QueryInterface,
 868     HTMLTableRow_AddRef,
 869     HTMLTableRow_Release,
 870     HTMLTableRow_GetTypeInfoCount,
 871     HTMLTableRow_GetTypeInfo,
 872     HTMLTableRow_GetIDsOfNames,
 873     HTMLTableRow_Invoke,
 874     HTMLTableRow_put_align,
 875     HTMLTableRow_get_align,
 876     HTMLTableRow_put_vAlign,
 877     HTMLTableRow_get_vAlign,
 878     HTMLTableRow_put_bgColor,
 879     HTMLTableRow_get_bgColor,
 880     HTMLTableRow_put_borderColor,
 881     HTMLTableRow_get_borderColor,
 882     HTMLTableRow_put_borderColorLight,
 883     HTMLTableRow_get_borderColorLight,
 884     HTMLTableRow_put_borderColorDark,
 885     HTMLTableRow_get_borderColorDark,
 886     HTMLTableRow_get_rowIndex,
 887     HTMLTableRow_get_sectionRowIndex,
 888     HTMLTableRow_get_cells,
 889     HTMLTableRow_insertCell,
 890     HTMLTableRow_deleteCell
 891 };
 892
 893 static inline HTMLTableRow *HTMLTableRow_from_HTMLDOMNode(HTMLDOMNode *iface)
 894 {
 895     return CONTAINING_RECORD(iface, HTMLTableRow, element.node);
 896 }
 897
 898 static HRESULT HTMLTableRow_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 899 {
 900     HTMLTableRow *This = HTMLTableRow_from_HTMLDOMNode(iface);
 901
 902     *ppv = NULL;
 903
 904     if(IsEqualGUID(&IID_IUnknown, riid)) {
 905         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 906         *ppv = &This->IHTMLTableRow_iface;
 907     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 908         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 909         *ppv = &This->IHTMLTableRow_iface;
 910     }else if(IsEqualGUID(&IID_IHTMLTableRow, riid)) {
 911         TRACE("(%p)->(IID_IHTMLTableRow %p)\n", This, ppv);
 912         *ppv = &This->IHTMLTableRow_iface;
 913     }
 914
 915     if(*ppv) {
 916         IUnknown_AddRef((IUnknown*)*ppv);
 917         return S_OK;
 918     }
 919
 920     return HTMLElement_QI(&This->element.node, riid, ppv);
 921 }
 922
 923 static void HTMLTableRow_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
 924 {
 925     HTMLTableRow *This = HTMLTableRow_from_HTMLDOMNode(iface);
 926
 927     if(This->nsrow)
 928         note_cc_edge((nsISupports*)This->nsrow, "This->nstablerow", cb);
 929 }
 930
 931 static void HTMLTableRow_unlink(HTMLDOMNode *iface)
 932 {
 933     HTMLTableRow *This = HTMLTableRow_from_HTMLDOMNode(iface);
 934
 935     if(This->nsrow) {
 936         nsIDOMHTMLTableRowElement *nsrow = This->nsrow;
 937
 938         This->nsrow = NULL;
 939         nsIDOMHTMLTableRowElement_Release(nsrow);
 940     }
 941 }
 942
 943 static const NodeImplVtbl HTMLTableRowImplVtbl = {
 944     &CLSID_HTMLTableRow,
 945     HTMLTableRow_QI,
 946     HTMLElement_destructor,
 947     HTMLElement_cpc,
 948     HTMLElement_clone,
 949     HTMLElement_dispatch_nsevent_hook,
 950     HTMLElement_handle_event,
 951     HTMLElement_get_attr_col,
 952     NULL,
 953     NULL,
 954     NULL,
 955     NULL,
 956     NULL,
 957     NULL,
 958     NULL,
 959     NULL,
 960     NULL,
 961     HTMLTableRow_traverse,
 962     HTMLTableRow_unlink
 963 };
 964
 965 static const tid_t HTMLTableRow_iface_tids[] = {
 966     HTMLELEMENT_TIDS,
 967     IHTMLTableRow_tid,
 968     0
 969 };
 970
 971 static dispex_static_data_t HTMLTableRow_dispex = {
 972     L"HTMLTableRowElement",
 973     NULL,
 974     DispHTMLTableRow_tid,
 975     HTMLTableRow_iface_tids,
 976     HTMLElement_init_dispex_info
 977 };
 978
 979 HRESULT HTMLTableRow_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
 980 {
 981     HTMLTableRow *ret;
 982     nsresult nsres;
 983
 984     ret = calloc(1, sizeof(HTMLTableRow));
 985     if(!ret)
 986         return E_OUTOFMEMORY;
 987
 988     ret->IHTMLTableRow_iface.lpVtbl = &HTMLTableRowVtbl;
 989     ret->element.node.vtbl = &HTMLTableRowImplVtbl;
 990
 991     HTMLElement_Init(&ret->element, doc, nselem, &HTMLTableRow_dispex);
 992
 993     nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableRowElement, (void**)&ret->nsrow);
 994     assert(nsres == NS_OK);
 995
 996     *elem = &ret->element;
 997     return S_OK;
 998 }
 999
1000 struct HTMLTable {
1001     HTMLElement element;
1002
1003     IHTMLTable  IHTMLTable_iface;
1004     IHTMLTable2 IHTMLTable2_iface;
1005     IHTMLTable3 IHTMLTable3_iface;
1006
1007     nsIDOMHTMLTableElement *nstable;
1008 };
1009
1010 static inline HTMLTable *impl_from_IHTMLTable(IHTMLTable *iface)
1011 {
1012     return CONTAINING_RECORD(iface, HTMLTable, IHTMLTable_iface);
1013 }
1014
1015 static inline HTMLTable *impl_from_IHTMLTable2(IHTMLTable2 *iface)
1016 {
1017     return CONTAINING_RECORD(iface, HTMLTable, IHTMLTable2_iface);
1018 }
1019
1020 static inline HTMLTable *impl_from_IHTMLTable3(IHTMLTable3 *iface)
1021 {
1022     return CONTAINING_RECORD(iface, HTMLTable, IHTMLTable3_iface);
1023 }
1024
1025 static HRESULT var2str(const VARIANT *p, nsAString *nsstr)
1026 {
1027     BSTR str;
1028     BOOL ret;
1029     HRESULT hres;
1030
1031     switch(V_VT(p)) {
1032     case VT_BSTR:
1033         return nsAString_Init(nsstr, V_BSTR(p))?
1034             S_OK : E_OUTOFMEMORY;
1035     case VT_R8:
1036         hres = VarBstrFromR8(V_R8(p), MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT), 0, &str);
1037         break;
1038     case VT_R4:
1039         hres = VarBstrFromR4(V_R4(p), MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT), 0, &str);
1040         break;
1041     case VT_I4:
1042         hres = VarBstrFromI4(V_I4(p), MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT), 0, &str);
1043         break;
1044     default:
1045         FIXME("unsupported arg %s\n", debugstr_variant(p));
1046         return E_NOTIMPL;
1047     }
1048     if (FAILED(hres))
1049         return hres;
1050
1051     ret = nsAString_Init(nsstr, str);
1052     SysFreeString(str);
1053     return ret ? S_OK : E_OUTOFMEMORY;
1054 }
1055
1056 static HRESULT WINAPI HTMLTable_QueryInterface(IHTMLTable *iface,
1057                                                          REFIID riid, void **ppv)
1058 {
1059     HTMLTable *This = impl_from_IHTMLTable(iface);
1060
1061     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
1062 }
1063
1064 static ULONG WINAPI HTMLTable_AddRef(IHTMLTable *iface)
1065 {
1066     HTMLTable *This = impl_from_IHTMLTable(iface);
1067
1068     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
1069 }
1070
1071 static ULONG WINAPI HTMLTable_Release(IHTMLTable *iface)
1072 {
1073     HTMLTable *This = impl_from_IHTMLTable(iface);
1074
1075     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
1076 }
1077
1078 static HRESULT WINAPI HTMLTable_GetTypeInfoCount(IHTMLTable *iface, UINT *pctinfo)
1079 {
1080     HTMLTable *This = impl_from_IHTMLTable(iface);
1081     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
1082 }
1083
1084 static HRESULT WINAPI HTMLTable_GetTypeInfo(IHTMLTable *iface, UINT iTInfo,
1085                                               LCID lcid, ITypeInfo **ppTInfo)
1086 {
1087     HTMLTable *This = impl_from_IHTMLTable(iface);
1088     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
1089             ppTInfo);
1090 }
1091
1092 static HRESULT WINAPI HTMLTable_GetIDsOfNames(IHTMLTable *iface, REFIID riid,
1093                                                 LPOLESTR *rgszNames, UINT cNames,
1094                                                 LCID lcid, DISPID *rgDispId)
1095 {
1096     HTMLTable *This = impl_from_IHTMLTable(iface);
1097     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
1098             cNames, lcid, rgDispId);
1099 }
1100
1101 static HRESULT WINAPI HTMLTable_Invoke(IHTMLTable *iface, DISPID dispIdMember,
1102                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1103                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1104 {
1105     HTMLTable *This = impl_from_IHTMLTable(iface);
1106     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
1107             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1108 }
1109
1110 static HRESULT WINAPI HTMLTable_put_cols(IHTMLTable *iface, LONG v)
1111 {
1112     HTMLTable *This = impl_from_IHTMLTable(iface);
1113     FIXME("(%p)->(%ld)\n", This, v);
1114     return E_NOTIMPL;
1115 }
1116
1117 static HRESULT WINAPI HTMLTable_get_cols(IHTMLTable *iface, LONG *p)
1118 {
1119     HTMLTable *This = impl_from_IHTMLTable(iface);
1120     FIXME("(%p)->(%p)\n", This, p);
1121     return E_NOTIMPL;
1122 }
1123
1124 static HRESULT WINAPI HTMLTable_put_border(IHTMLTable *iface, VARIANT v)
1125 {
1126     HTMLTable *This = impl_from_IHTMLTable(iface);
1127     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1128     return E_NOTIMPL;
1129 }
1130
1131 static HRESULT WINAPI HTMLTable_get_border(IHTMLTable *iface, VARIANT *p)
1132 {
1133     HTMLTable *This = impl_from_IHTMLTable(iface);
1134     FIXME("(%p)->(%p)\n", This, p);
1135     return E_NOTIMPL;
1136 }
1137
1138 static HRESULT WINAPI HTMLTable_put_frame(IHTMLTable *iface, BSTR v)
1139 {
1140     HTMLTable *This = impl_from_IHTMLTable(iface);
1141     nsAString str;
1142     nsresult nsres;
1143
1144     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1145
1146     nsAString_InitDepend(&str, v);
1147     nsres = nsIDOMHTMLTableElement_SetFrame(This->nstable, &str);
1148     nsAString_Finish(&str);
1149
1150     if (NS_FAILED(nsres)) {
1151         ERR("SetFrame(%s) failed: %08lx\n", debugstr_w(v), nsres);
1152         return E_FAIL;
1153     }
1154     return S_OK;
1155 }
1156
1157 static HRESULT WINAPI HTMLTable_get_frame(IHTMLTable *iface, BSTR *p)
1158 {
1159     HTMLTable *This = impl_from_IHTMLTable(iface);
1160     nsAString str;
1161     nsresult nsres;
1162
1163     TRACE("(%p)->(%p)\n", This, p);
1164
1165     nsAString_Init(&str, NULL);
1166     nsres = nsIDOMHTMLTableElement_GetFrame(This->nstable, &str);
1167
1168     return return_nsstr(nsres, &str, p);
1169 }
1170
1171 static HRESULT WINAPI HTMLTable_put_rules(IHTMLTable *iface, BSTR v)
1172 {
1173     HTMLTable *This = impl_from_IHTMLTable(iface);
1174     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1175     return E_NOTIMPL;
1176 }
1177
1178 static HRESULT WINAPI HTMLTable_get_rules(IHTMLTable *iface, BSTR *p)
1179 {
1180     HTMLTable *This = impl_from_IHTMLTable(iface);
1181     FIXME("(%p)->(%p)\n", This, p);
1182     return E_NOTIMPL;
1183 }
1184
1185 static HRESULT WINAPI HTMLTable_put_cellSpacing(IHTMLTable *iface, VARIANT v)
1186 {
1187     HTMLTable *This = impl_from_IHTMLTable(iface);
1188     nsAString nsstr;
1189     WCHAR buf[64];
1190     nsresult nsres;
1191
1192     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1193
1194     switch(V_VT(&v)) {
1195     case VT_BSTR:
1196         nsAString_InitDepend(&nsstr, V_BSTR(&v));
1197         break;
1198     case VT_I4: {
1199         swprintf(buf, ARRAY_SIZE(buf), L"%d", V_I4(&v));
1200         nsAString_InitDepend(&nsstr, buf);
1201         break;
1202     }
1203     default:
1204         FIXME("unsupported arg %s\n", debugstr_variant(&v));
1205         return E_NOTIMPL;
1206     }
1207
1208     nsres = nsIDOMHTMLTableElement_SetCellSpacing(This->nstable, &nsstr);
1209     nsAString_Finish(&nsstr);
1210     if(NS_FAILED(nsres)) {
1211         ERR("SetCellSpacing failed: %08lx\n", nsres);
1212         return E_FAIL;
1213     }
1214
1215     return S_OK;
1216 }
1217
1218 static HRESULT WINAPI HTMLTable_get_cellSpacing(IHTMLTable *iface, VARIANT *p)
1219 {
1220     HTMLTable *This = impl_from_IHTMLTable(iface);
1221     nsAString nsstr;
1222     nsresult nsres;
1223
1224     TRACE("(%p)->(%p)\n", This, p);
1225
1226     nsAString_Init(&nsstr, NULL);
1227     nsres = nsIDOMHTMLTableElement_GetCellSpacing(This->nstable, &nsstr);
1228     V_VT(p) = VT_BSTR;
1229     return return_nsstr(nsres, &nsstr, &V_BSTR(p));
1230 }
1231
1232 static HRESULT WINAPI HTMLTable_put_cellPadding(IHTMLTable *iface, VARIANT v)
1233 {
1234     HTMLTable *This = impl_from_IHTMLTable(iface);
1235     nsAString val;
1236     HRESULT hres;
1237     nsresult nsres;
1238
1239     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1240
1241     hres = var2str(&v, &val);
1242     if(FAILED(hres))
1243         return hres;
1244
1245     nsres = nsIDOMHTMLTableElement_SetCellPadding(This->nstable, &val);
1246     nsAString_Finish(&val);
1247     if(NS_FAILED(nsres)) {
1248         ERR("Set Width(%s) failed, err = %08lx\n", debugstr_variant(&v), nsres);
1249         return E_FAIL;
1250     }
1251
1252     return S_OK;
1253 }
1254
1255 static HRESULT WINAPI HTMLTable_get_cellPadding(IHTMLTable *iface, VARIANT *p)
1256 {
1257     HTMLTable *This = impl_from_IHTMLTable(iface);
1258     nsAString val;
1259     nsresult nsres;
1260
1261     TRACE("(%p)->(%p)\n", This, p);
1262
1263     nsAString_Init(&val, NULL);
1264     nsres = nsIDOMHTMLTableElement_GetCellPadding(This->nstable, &val);
1265     return return_nsstr_variant(nsres, &val, 0, p);
1266 }
1267
1268 static HRESULT WINAPI HTMLTable_put_background(IHTMLTable *iface, BSTR v)
1269 {
1270     HTMLTable *This = impl_from_IHTMLTable(iface);
1271     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1272     return E_NOTIMPL;
1273 }
1274
1275 static HRESULT WINAPI HTMLTable_get_background(IHTMLTable *iface, BSTR *p)
1276 {
1277     HTMLTable *This = impl_from_IHTMLTable(iface);
1278     FIXME("(%p)->(%p)\n", This, p);
1279     return E_NOTIMPL;
1280 }
1281
1282 static HRESULT WINAPI HTMLTable_put_bgColor(IHTMLTable *iface, VARIANT v)
1283 {
1284     HTMLTable *This = impl_from_IHTMLTable(iface);
1285     nsAString val;
1286     nsresult nsres;
1287
1288     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1289
1290     if(!variant_to_nscolor(&v, &val))
1291         return S_OK;
1292
1293     nsres = nsIDOMHTMLTableElement_SetBgColor(This->nstable, &val);
1294     nsAString_Finish(&val);
1295     if (NS_FAILED(nsres)){
1296         ERR("Set BgColor(%s) failed!\n", debugstr_variant(&v));
1297         return E_FAIL;
1298     }
1299
1300     return S_OK;
1301 }
1302
1303 static HRESULT WINAPI HTMLTable_get_bgColor(IHTMLTable *iface, VARIANT *p)
1304 {
1305     HTMLTable *This = impl_from_IHTMLTable(iface);
1306     nsAString strColor;
1307     nsresult nsres;
1308     HRESULT hres;
1309     const PRUnichar *color;
1310
1311     TRACE("(%p)->(%p)\n", This, p);
1312
1313     nsAString_Init(&strColor, NULL);
1314     nsres = nsIDOMHTMLTableElement_GetBgColor(This->nstable, &strColor);
1315
1316     if(NS_SUCCEEDED(nsres)) {
1317        nsAString_GetData(&strColor, &color);
1318        V_VT(p) = VT_BSTR;
1319        hres = nscolor_to_str(color, &V_BSTR(p));
1320     }else {
1321        ERR("SetBgColor failed: %08lx\n", nsres);
1322        hres = E_FAIL;
1323     }
1324
1325     nsAString_Finish(&strColor);
1326     return hres;
1327 }
1328
1329 static HRESULT WINAPI HTMLTable_put_borderColor(IHTMLTable *iface, VARIANT v)
1330 {
1331     HTMLTable *This = impl_from_IHTMLTable(iface);
1332     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1333     return E_NOTIMPL;
1334 }
1335
1336 static HRESULT WINAPI HTMLTable_get_borderColor(IHTMLTable *iface, VARIANT *p)
1337 {
1338     HTMLTable *This = impl_from_IHTMLTable(iface);
1339     FIXME("(%p)->(%p)\n", This, p);
1340     return E_NOTIMPL;
1341 }
1342
1343 static HRESULT WINAPI HTMLTable_put_borderColorLight(IHTMLTable *iface, VARIANT v)
1344 {
1345     HTMLTable *This = impl_from_IHTMLTable(iface);
1346     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1347     return E_NOTIMPL;
1348 }
1349
1350 static HRESULT WINAPI HTMLTable_get_borderColorLight(IHTMLTable *iface, VARIANT *p)
1351 {
1352     HTMLTable *This = impl_from_IHTMLTable(iface);
1353     FIXME("(%p)->(%p)\n", This, p);
1354     return E_NOTIMPL;
1355 }
1356
1357 static HRESULT WINAPI HTMLTable_put_borderColorDark(IHTMLTable *iface, VARIANT v)
1358 {
1359     HTMLTable *This = impl_from_IHTMLTable(iface);
1360     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1361     return E_NOTIMPL;
1362 }
1363
1364 static HRESULT WINAPI HTMLTable_get_borderColorDark(IHTMLTable *iface, VARIANT *p)
1365 {
1366     HTMLTable *This = impl_from_IHTMLTable(iface);
1367     FIXME("(%p)->(%p)\n", This, p);
1368     return E_NOTIMPL;
1369 }
1370
1371 static HRESULT WINAPI HTMLTable_put_align(IHTMLTable *iface, BSTR v)
1372 {
1373     HTMLTable *This = impl_from_IHTMLTable(iface);
1374     nsAString val;
1375     nsresult nsres;
1376
1377     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1378
1379     nsAString_InitDepend(&val, v);
1380
1381     nsres = nsIDOMHTMLTableElement_SetAlign(This->nstable, &val);
1382     nsAString_Finish(&val);
1383     if (NS_FAILED(nsres)){
1384         ERR("Set Align(%s) failed!\n", debugstr_w(v));
1385         return E_FAIL;
1386     }
1387     return S_OK;
1388 }
1389
1390 static HRESULT WINAPI HTMLTable_get_align(IHTMLTable *iface, BSTR *p)
1391 {
1392     HTMLTable *This = impl_from_IHTMLTable(iface);
1393     nsAString val;
1394     nsresult nsres;
1395
1396     TRACE("(%p)->(%p)\n", This, p);
1397
1398     nsAString_Init(&val, NULL);
1399     nsres = nsIDOMHTMLTableElement_GetAlign(This->nstable, &val);
1400
1401     return return_nsstr(nsres, &val, p);
1402 }
1403
1404 static HRESULT WINAPI HTMLTable_refresh(IHTMLTable *iface)
1405 {
1406     HTMLTable *This = impl_from_IHTMLTable(iface);
1407     FIXME("(%p)\n", This);
1408     return E_NOTIMPL;
1409 }
1410
1411 static HRESULT WINAPI HTMLTable_get_rows(IHTMLTable *iface, IHTMLElementCollection **p)
1412 {
1413     HTMLTable *This = impl_from_IHTMLTable(iface);
1414     nsIDOMHTMLCollection *nscol;
1415     nsresult nsres;
1416
1417     TRACE("(%p)->(%p)\n", This, p);
1418
1419     nsres = nsIDOMHTMLTableElement_GetRows(This->nstable, &nscol);
1420     if(NS_FAILED(nsres)) {
1421         ERR("GetRows failed: %08lx\n", nsres);
1422         return E_FAIL;
1423     }
1424
1425     *p = create_collection_from_htmlcol(nscol, dispex_compat_mode(&This->element.node.event_target.dispex));
1426
1427     nsIDOMHTMLCollection_Release(nscol);
1428     return S_OK;
1429 }
1430
1431 static HRESULT WINAPI HTMLTable_put_width(IHTMLTable *iface, VARIANT v)
1432 {
1433     HTMLTable *This = impl_from_IHTMLTable(iface);
1434     nsAString val;
1435     HRESULT hres;
1436     nsresult nsres;
1437
1438     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1439     hres = var2str(&v, &val);
1440
1441     if (FAILED(hres)){
1442         ERR("Set Width(%s) failed when initializing a nsAString, err = %08lx\n",
1443             debugstr_variant(&v), hres);
1444         return hres;
1445     }
1446
1447     nsres = nsIDOMHTMLTableElement_SetWidth(This->nstable, &val);
1448     nsAString_Finish(&val);
1449
1450     if (NS_FAILED(nsres)){
1451         ERR("Set Width(%s) failed, err = %08lx\n", debugstr_variant(&v), nsres);
1452         return E_FAIL;
1453     }
1454     return S_OK;
1455 }
1456
1457 static HRESULT WINAPI HTMLTable_get_width(IHTMLTable *iface, VARIANT *p)
1458 {
1459     HTMLTable *This = impl_from_IHTMLTable(iface);
1460     nsAString val;
1461     nsresult nsres;
1462
1463     TRACE("(%p)->(%p)\n", This, p);
1464
1465     nsAString_Init(&val, NULL);
1466     nsres = nsIDOMHTMLTableElement_GetWidth(This->nstable, &val);
1467     return return_nsstr_variant(nsres, &val, NSSTR_IMPLICIT_PX, p);
1468 }
1469
1470 static HRESULT WINAPI HTMLTable_put_height(IHTMLTable *iface, VARIANT v)
1471 {
1472     HTMLTable *This = impl_from_IHTMLTable(iface);
1473     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1474     return E_NOTIMPL;
1475 }
1476
1477 static HRESULT WINAPI HTMLTable_get_height(IHTMLTable *iface, VARIANT *p)
1478 {
1479     HTMLTable *This = impl_from_IHTMLTable(iface);
1480     FIXME("(%p)->(%p)\n", This, p);
1481     return E_NOTIMPL;
1482 }
1483
1484 static HRESULT WINAPI HTMLTable_put_dataPageSize(IHTMLTable *iface, LONG v)
1485 {
1486     HTMLTable *This = impl_from_IHTMLTable(iface);
1487     FIXME("(%p)->(%ld)\n", This, v);
1488     return E_NOTIMPL;
1489 }
1490
1491 static HRESULT WINAPI HTMLTable_get_dataPageSize(IHTMLTable *iface, LONG *p)
1492 {
1493     HTMLTable *This = impl_from_IHTMLTable(iface);
1494     FIXME("(%p)->(%p)\n", This, p);
1495     return E_NOTIMPL;
1496 }
1497
1498 static HRESULT WINAPI HTMLTable_nextPage(IHTMLTable *iface)
1499 {
1500     HTMLTable *This = impl_from_IHTMLTable(iface);
1501     FIXME("(%p)\n", This);
1502     return E_NOTIMPL;
1503 }
1504
1505 static HRESULT WINAPI HTMLTable_previousPage(IHTMLTable *iface)
1506 {
1507     HTMLTable *This = impl_from_IHTMLTable(iface);
1508     FIXME("(%p)\n", This);
1509     return E_NOTIMPL;
1510 }
1511
1512 static HRESULT WINAPI HTMLTable_get_tHead(IHTMLTable *iface, IHTMLTableSection **p)
1513 {
1514     HTMLTable *This = impl_from_IHTMLTable(iface);
1515     FIXME("(%p)->(%p)\n", This, p);
1516     return E_NOTIMPL;
1517 }
1518
1519 static HRESULT WINAPI HTMLTable_get_tFoot(IHTMLTable *iface, IHTMLTableSection **p)
1520 {
1521     HTMLTable *This = impl_from_IHTMLTable(iface);
1522     FIXME("(%p)->(%p)\n", This, p);
1523     return E_NOTIMPL;
1524 }
1525
1526 static HRESULT WINAPI HTMLTable_get_tBodies(IHTMLTable *iface, IHTMLElementCollection **p)
1527 {
1528     HTMLTable *This = impl_from_IHTMLTable(iface);
1529     nsIDOMHTMLCollection *nscol = NULL;
1530     nsresult nsres;
1531
1532     TRACE("(%p)->(%p)\n", This, p);
1533
1534     nsres = nsIDOMHTMLTableElement_GetTBodies(This->nstable, &nscol);
1535     if(NS_FAILED(nsres)) {
1536         ERR("GetTBodies failed: %08lx\n", nsres);
1537         return E_FAIL;
1538     }
1539
1540     *p = create_collection_from_htmlcol(nscol, dispex_compat_mode(&This->element.node.event_target.dispex));
1541
1542     nsIDOMHTMLCollection_Release(nscol);
1543     return S_OK;
1544 }
1545
1546 static HRESULT WINAPI HTMLTable_get_caption(IHTMLTable *iface, IHTMLTableCaption **p)
1547 {
1548     HTMLTable *This = impl_from_IHTMLTable(iface);
1549     FIXME("(%p)->(%p)\n", This, p);
1550     return E_NOTIMPL;
1551 }
1552
1553 static HRESULT WINAPI HTMLTable_createTHead(IHTMLTable *iface, IDispatch **head)
1554 {
1555     HTMLTable *This = impl_from_IHTMLTable(iface);
1556     FIXME("(%p)->(%p)\n", This, head);
1557     return E_NOTIMPL;
1558 }
1559
1560 static HRESULT WINAPI HTMLTable_deleteTHead(IHTMLTable *iface)
1561 {
1562     HTMLTable *This = impl_from_IHTMLTable(iface);
1563     FIXME("(%p)\n", This);
1564     return E_NOTIMPL;
1565 }
1566
1567 static HRESULT WINAPI HTMLTable_createTFoot(IHTMLTable *iface, IDispatch **foot)
1568 {
1569     HTMLTable *This = impl_from_IHTMLTable(iface);
1570     FIXME("(%p)->(%p)\n", This, foot);
1571     return E_NOTIMPL;
1572 }
1573
1574 static HRESULT WINAPI HTMLTable_deleteTFoot(IHTMLTable *iface)
1575 {
1576     HTMLTable *This = impl_from_IHTMLTable(iface);
1577     FIXME("(%p)\n", This);
1578     return E_NOTIMPL;
1579 }
1580
1581 static HRESULT WINAPI HTMLTable_createCaption(IHTMLTable *iface, IHTMLTableCaption **caption)
1582 {
1583     HTMLTable *This = impl_from_IHTMLTable(iface);
1584     FIXME("(%p)->(%p)\n", This, caption);
1585     return E_NOTIMPL;
1586 }
1587
1588 static HRESULT WINAPI HTMLTable_deleteCaption(IHTMLTable *iface)
1589 {
1590     HTMLTable *This = impl_from_IHTMLTable(iface);
1591     FIXME("(%p)\n", This);
1592     return E_NOTIMPL;
1593 }
1594
1595 static HRESULT WINAPI HTMLTable_insertRow(IHTMLTable *iface, LONG index, IDispatch **row)
1596 {
1597     HTMLTable *This = impl_from_IHTMLTable(iface);
1598     nsIDOMHTMLElement *nselem;
1599     HTMLElement *elem;
1600     nsresult nsres;
1601     HRESULT hres;
1602
1603     TRACE("(%p)->(%ld %p)\n", This, index, row);
1604     nsres = nsIDOMHTMLTableElement_InsertRow(This->nstable, index, &nselem);
1605     if(NS_FAILED(nsres)) {
1606         ERR("Insert Row at %ld failed: %08lx\n", index, nsres);
1607         return E_FAIL;
1608     }
1609
1610     hres = HTMLTableRow_Create(This->element.node.doc, (nsIDOMElement*)nselem, &elem);
1611     nsIDOMHTMLElement_Release(nselem);
1612     if (FAILED(hres)) {
1613         ERR("Create TableRow failed: %08lx\n", hres);
1614         return hres;
1615     }
1616
1617     *row = (IDispatch *)&elem->IHTMLElement_iface;
1618     return S_OK;
1619 }
1620
1621 static HRESULT WINAPI HTMLTable_deleteRow(IHTMLTable *iface, LONG index)
1622 {
1623     HTMLTable *This = impl_from_IHTMLTable(iface);
1624     nsresult nsres;
1625
1626     TRACE("(%p)->(%ld)\n", This, index);
1627     nsres = nsIDOMHTMLTableElement_DeleteRow(This->nstable, index);
1628     if(NS_FAILED(nsres)) {
1629         ERR("Delete Row failed: %08lx\n", nsres);
1630         return E_FAIL;
1631     }
1632     return S_OK;
1633 }
1634
1635 static HRESULT WINAPI HTMLTable_get_readyState(IHTMLTable *iface, BSTR *p)
1636 {
1637     HTMLTable *This = impl_from_IHTMLTable(iface);
1638     FIXME("(%p)->(%p)\n", This, p);
1639     return E_NOTIMPL;
1640 }
1641
1642 static HRESULT WINAPI HTMLTable_put_onreadystatechange(IHTMLTable *iface, VARIANT v)
1643 {
1644     HTMLTable *This = impl_from_IHTMLTable(iface);
1645     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1646     return E_NOTIMPL;
1647 }
1648
1649 static HRESULT WINAPI HTMLTable_get_onreadystatechange(IHTMLTable *iface, VARIANT *p)
1650 {
1651     HTMLTable *This = impl_from_IHTMLTable(iface);
1652     FIXME("(%p)->(%p)\n", This, p);
1653     return E_NOTIMPL;
1654 }
1655
1656 static const IHTMLTableVtbl HTMLTableVtbl = {
1657     HTMLTable_QueryInterface,
1658     HTMLTable_AddRef,
1659     HTMLTable_Release,
1660     HTMLTable_GetTypeInfoCount,
1661     HTMLTable_GetTypeInfo,
1662     HTMLTable_GetIDsOfNames,
1663     HTMLTable_Invoke,
1664     HTMLTable_put_cols,
1665     HTMLTable_get_cols,
1666     HTMLTable_put_border,
1667     HTMLTable_get_border,
1668     HTMLTable_put_frame,
1669     HTMLTable_get_frame,
1670     HTMLTable_put_rules,
1671     HTMLTable_get_rules,
1672     HTMLTable_put_cellSpacing,
1673     HTMLTable_get_cellSpacing,
1674     HTMLTable_put_cellPadding,
1675     HTMLTable_get_cellPadding,
1676     HTMLTable_put_background,
1677     HTMLTable_get_background,
1678     HTMLTable_put_bgColor,
1679     HTMLTable_get_bgColor,
1680     HTMLTable_put_borderColor,
1681     HTMLTable_get_borderColor,
1682     HTMLTable_put_borderColorLight,
1683     HTMLTable_get_borderColorLight,
1684     HTMLTable_put_borderColorDark,
1685     HTMLTable_get_borderColorDark,
1686     HTMLTable_put_align,
1687     HTMLTable_get_align,
1688     HTMLTable_refresh,
1689     HTMLTable_get_rows,
1690     HTMLTable_put_width,
1691     HTMLTable_get_width,
1692     HTMLTable_put_height,
1693     HTMLTable_get_height,
1694     HTMLTable_put_dataPageSize,
1695     HTMLTable_get_dataPageSize,
1696     HTMLTable_nextPage,
1697     HTMLTable_previousPage,
1698     HTMLTable_get_tHead,
1699     HTMLTable_get_tFoot,
1700     HTMLTable_get_tBodies,
1701     HTMLTable_get_caption,
1702     HTMLTable_createTHead,
1703     HTMLTable_deleteTHead,
1704     HTMLTable_createTFoot,
1705     HTMLTable_deleteTFoot,
1706     HTMLTable_createCaption,
1707     HTMLTable_deleteCaption,
1708     HTMLTable_insertRow,
1709     HTMLTable_deleteRow,
1710     HTMLTable_get_readyState,
1711     HTMLTable_put_onreadystatechange,
1712     HTMLTable_get_onreadystatechange
1713 };
1714
1715 /* IHTMLTable2 */
1716 static HRESULT WINAPI HTMLTable2_QueryInterface(IHTMLTable2 *iface,
1717                                                          REFIID riid, void **ppv)
1718 {
1719     HTMLTable *This = impl_from_IHTMLTable2(iface);
1720
1721     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
1722 }
1723
1724 static ULONG WINAPI HTMLTable2_AddRef(IHTMLTable2 *iface)
1725 {
1726     HTMLTable *This = impl_from_IHTMLTable2(iface);
1727
1728     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
1729 }
1730
1731 static ULONG WINAPI HTMLTable2_Release(IHTMLTable2 *iface)
1732 {
1733     HTMLTable *This = impl_from_IHTMLTable2(iface);
1734
1735     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
1736 }
1737
1738 static HRESULT WINAPI HTMLTable2_GetTypeInfoCount(IHTMLTable2 *iface, UINT *pctinfo)
1739 {
1740     HTMLTable *This = impl_from_IHTMLTable2(iface);
1741     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
1742 }
1743
1744 static HRESULT WINAPI HTMLTable2_GetTypeInfo(IHTMLTable2 *iface, UINT iTInfo,
1745                                               LCID lcid, ITypeInfo **ppTInfo)
1746 {
1747     HTMLTable *This = impl_from_IHTMLTable2(iface);
1748     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
1749             ppTInfo);
1750 }
1751
1752 static HRESULT WINAPI HTMLTable2_GetIDsOfNames(IHTMLTable2 *iface, REFIID riid,
1753                                                 LPOLESTR *rgszNames, UINT cNames,
1754                                                 LCID lcid, DISPID *rgDispId)
1755 {
1756     HTMLTable *This = impl_from_IHTMLTable2(iface);
1757     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
1758             cNames, lcid, rgDispId);
1759 }
1760
1761 static HRESULT WINAPI HTMLTable2_Invoke(IHTMLTable2 *iface, DISPID dispIdMember,
1762                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1763                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1764 {
1765     HTMLTable *This = impl_from_IHTMLTable2(iface);
1766     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
1767             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1768 }
1769
1770 static HRESULT WINAPI HTMLTable2_firstPage(IHTMLTable2 *iface)
1771 {
1772     HTMLTable *This = impl_from_IHTMLTable2(iface);
1773     FIXME("(%p)->()\n", This);
1774     return E_NOTIMPL;
1775 }
1776
1777 static HRESULT WINAPI HTMLTable2_lastPage(IHTMLTable2 *iface)
1778 {
1779     HTMLTable *This = impl_from_IHTMLTable2(iface);
1780     FIXME("(%p)->()\n", This);
1781     return E_NOTIMPL;
1782 }
1783
1784 static HRESULT WINAPI HTMLTable2_cells(IHTMLTable2 *iface, IHTMLElementCollection **p)
1785 {
1786     HTMLTable *This = impl_from_IHTMLTable2(iface);
1787     FIXME("(%p)->(%p)\n", This, p);
1788     return E_NOTIMPL;
1789 }
1790
1791 static HRESULT WINAPI HTMLTable2_moveRow(IHTMLTable2 *iface, LONG indexFrom, LONG indexTo, IDispatch **row)
1792 {
1793     HTMLTable *This = impl_from_IHTMLTable2(iface);
1794     FIXME("(%p)->(%ld %ld %p)\n", This, indexFrom, indexTo, row);
1795     return E_NOTIMPL;
1796 }
1797
1798
1799 static const IHTMLTable2Vtbl HTMLTable2Vtbl = {
1800     HTMLTable2_QueryInterface,
1801     HTMLTable2_AddRef,
1802     HTMLTable2_Release,
1803     HTMLTable2_GetTypeInfoCount,
1804     HTMLTable2_GetTypeInfo,
1805     HTMLTable2_GetIDsOfNames,
1806     HTMLTable2_Invoke,
1807     HTMLTable2_firstPage,
1808     HTMLTable2_lastPage,
1809     HTMLTable2_cells,
1810     HTMLTable2_moveRow
1811 };
1812
1813 /* IHTMLTable3 */
1814 static HRESULT WINAPI HTMLTable3_QueryInterface(IHTMLTable3 *iface,
1815                                                          REFIID riid, void **ppv)
1816 {
1817     HTMLTable *This = impl_from_IHTMLTable3(iface);
1818
1819     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
1820 }
1821
1822 static ULONG WINAPI HTMLTable3_AddRef(IHTMLTable3 *iface)
1823 {
1824     HTMLTable *This = impl_from_IHTMLTable3(iface);
1825
1826     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
1827 }
1828
1829 static ULONG WINAPI HTMLTable3_Release(IHTMLTable3 *iface)
1830 {
1831     HTMLTable *This = impl_from_IHTMLTable3(iface);
1832
1833     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
1834 }
1835
1836 static HRESULT WINAPI HTMLTable3_GetTypeInfoCount(IHTMLTable3 *iface, UINT *pctinfo)
1837 {
1838     HTMLTable *This = impl_from_IHTMLTable3(iface);
1839     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
1840 }
1841
1842 static HRESULT WINAPI HTMLTable3_GetTypeInfo(IHTMLTable3 *iface, UINT iTInfo,
1843                                               LCID lcid, ITypeInfo **ppTInfo)
1844 {
1845     HTMLTable *This = impl_from_IHTMLTable3(iface);
1846     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
1847             ppTInfo);
1848 }
1849
1850 static HRESULT WINAPI HTMLTable3_GetIDsOfNames(IHTMLTable3 *iface, REFIID riid,
1851                                                 LPOLESTR *rgszNames, UINT cNames,
1852                                                 LCID lcid, DISPID *rgDispId)
1853 {
1854     HTMLTable *This = impl_from_IHTMLTable3(iface);
1855     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
1856             cNames, lcid, rgDispId);
1857 }
1858
1859 static HRESULT WINAPI HTMLTable3_Invoke(IHTMLTable3 *iface, DISPID dispIdMember,
1860                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1861                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1862 {
1863     HTMLTable *This = impl_from_IHTMLTable3(iface);
1864     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
1865             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1866 }
1867
1868 static HRESULT WINAPI HTMLTable3_put_summary(IHTMLTable3 *iface, BSTR v)
1869 {
1870     HTMLTable *This = impl_from_IHTMLTable3(iface);
1871     nsAString str;
1872     nsresult nsres;
1873
1874     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1875
1876     nsAString_InitDepend(&str, v);
1877
1878     nsres = nsIDOMHTMLTableElement_SetSummary(This->nstable, &str);
1879
1880     nsAString_Finish(&str);
1881     if (NS_FAILED(nsres)) {
1882         ERR("Set summary(%s) failed: %08lx\n", debugstr_w(v), nsres);
1883         return E_FAIL;
1884     }
1885     return S_OK;
1886 }
1887
1888 static HRESULT WINAPI HTMLTable3_get_summary(IHTMLTable3 *iface, BSTR * p)
1889 {
1890     HTMLTable *This = impl_from_IHTMLTable3(iface);
1891     nsAString str;
1892     nsresult nsres;
1893
1894     TRACE("(%p)->(%p)\n", This, p);
1895
1896     nsAString_Init(&str, NULL);
1897     nsres = nsIDOMHTMLTableElement_GetSummary(This->nstable, &str);
1898
1899     return return_nsstr(nsres, &str, p);
1900 }
1901
1902 static const IHTMLTable3Vtbl HTMLTable3Vtbl = {
1903     HTMLTable3_QueryInterface,
1904     HTMLTable3_AddRef,
1905     HTMLTable3_Release,
1906     HTMLTable3_GetTypeInfoCount,
1907     HTMLTable3_GetTypeInfo,
1908     HTMLTable3_GetIDsOfNames,
1909     HTMLTable3_Invoke,
1910     HTMLTable3_put_summary,
1911     HTMLTable3_get_summary
1912 };
1913
1914 static inline HTMLTable *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
1915 {
1916     return CONTAINING_RECORD(iface, HTMLTable, element.node);
1917 }
1918
1919 static HRESULT HTMLTable_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
1920 {
1921     HTMLTable *This = impl_from_HTMLDOMNode(iface);
1922
1923     *ppv = NULL;
1924
1925     if(IsEqualGUID(&IID_IUnknown, riid)) {
1926         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1927         *ppv = &This->IHTMLTable_iface;
1928     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1929         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1930         *ppv = &This->IHTMLTable_iface;
1931     }else if(IsEqualGUID(&IID_IHTMLTable, riid)) {
1932         TRACE("(%p)->(IID_IHTMLTable %p)\n", This, ppv);
1933         *ppv = &This->IHTMLTable_iface;
1934     }else if(IsEqualGUID(&IID_IHTMLTable2, riid)) {
1935         TRACE("(%p)->(IID_IHTMLTable2 %p)\n", This, ppv);
1936         *ppv = &This->IHTMLTable2_iface;
1937     }else if(IsEqualGUID(&IID_IHTMLTable3, riid)) {
1938         TRACE("(%p)->(IID_IHTMLTable3 %p)\n", This, ppv);
1939         *ppv = &This->IHTMLTable3_iface;
1940     }
1941
1942     if(*ppv) {
1943         IUnknown_AddRef((IUnknown*)*ppv);
1944         return S_OK;
1945     }
1946
1947     return HTMLElement_QI(&This->element.node, riid, ppv);
1948 }
1949
1950 static void HTMLTable_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
1951 {
1952     HTMLTable *This = impl_from_HTMLDOMNode(iface);
1953
1954     if(This->nstable)
1955         note_cc_edge((nsISupports*)This->nstable, "This->nstable", cb);
1956 }
1957
1958 static void HTMLTable_unlink(HTMLDOMNode *iface)
1959 {
1960     HTMLTable *This = impl_from_HTMLDOMNode(iface);
1961
1962     if(This->nstable) {
1963         nsIDOMHTMLTableElement *nstable = This->nstable;
1964
1965         This->nstable = NULL;
1966         nsIDOMHTMLTableElement_Release(nstable);
1967     }
1968 }
1969
1970 static const cpc_entry_t HTMLTable_cpc[] = {
1971     {&DIID_HTMLTableEvents},
1972     HTMLELEMENT_CPC,
1973     {NULL}
1974 };
1975
1976 static const NodeImplVtbl HTMLTableImplVtbl = {
1977     &CLSID_HTMLTable,
1978     HTMLTable_QI,
1979     HTMLElement_destructor,
1980     HTMLTable_cpc,
1981     HTMLElement_clone,
1982     HTMLElement_dispatch_nsevent_hook,
1983     HTMLElement_handle_event,
1984     HTMLElement_get_attr_col,
1985     NULL,
1986     NULL,
1987     NULL,
1988     NULL,
1989     NULL,
1990     NULL,
1991     NULL,
1992     NULL,
1993     NULL,
1994     HTMLTable_traverse,
1995     HTMLTable_unlink
1996 };
1997
1998 static const tid_t HTMLTable_iface_tids[] = {
1999     HTMLELEMENT_TIDS,
2000     IHTMLTable_tid,
2001     IHTMLTable2_tid,
2002     IHTMLTable3_tid,
2003     0
2004 };
2005
2006 static dispex_static_data_t HTMLTable_dispex = {
2007     L"HTMLTableElement",
2008     NULL,
2009     DispHTMLTable_tid,
2010     HTMLTable_iface_tids,
2011     HTMLElement_init_dispex_info
2012 };
2013
2014 HRESULT HTMLTable_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
2015 {
2016     HTMLTable *ret;
2017     nsresult nsres;
2018
2019     ret = calloc(1, sizeof(HTMLTable));
2020     if(!ret)
2021         return E_OUTOFMEMORY;
2022
2023     ret->element.node.vtbl = &HTMLTableImplVtbl;
2024     ret->IHTMLTable_iface.lpVtbl = &HTMLTableVtbl;
2025     ret->IHTMLTable2_iface.lpVtbl = &HTMLTable2Vtbl;
2026     ret->IHTMLTable3_iface.lpVtbl = &HTMLTable3Vtbl;
2027
2028     HTMLElement_Init(&ret->element, doc, nselem, &HTMLTable_dispex);
2029
2030     nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableElement, (void**)&ret->nstable);
2031     assert(nsres == NS_OK);
2032
2033     *elem = &ret->element;
2034     return S_OK;
2035 }