dll/win32/mshtml/htmltable.c

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