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