git.oblomov.eu Git - wine/blob - 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     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI HTMLTable_get_cellSpacing(IHTMLTable *iface, VARIANT *p)
 178 {
 179     HTMLTable *This = impl_from_IHTMLTable(iface);
 180     FIXME("(%p)->(%p)\n", This, p);
 181     return E_NOTIMPL;
 182 }
 183
 184 static HRESULT WINAPI HTMLTable_put_cellPadding(IHTMLTable *iface, VARIANT v)
 185 {
 186     HTMLTable *This = impl_from_IHTMLTable(iface);
 187     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI HTMLTable_get_cellPadding(IHTMLTable *iface, VARIANT *p)
 192 {
 193     HTMLTable *This = impl_from_IHTMLTable(iface);
 194     FIXME("(%p)->(%p)\n", This, p);
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI HTMLTable_put_background(IHTMLTable *iface, BSTR v)
 199 {
 200     HTMLTable *This = impl_from_IHTMLTable(iface);
 201     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 202     return E_NOTIMPL;
 203 }
 204
 205 static HRESULT WINAPI HTMLTable_get_background(IHTMLTable *iface, BSTR *p)
 206 {
 207     HTMLTable *This = impl_from_IHTMLTable(iface);
 208     FIXME("(%p)->(%p)\n", This, p);
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI HTMLTable_put_bgColor(IHTMLTable *iface, VARIANT v)
 213 {
 214     HTMLTable *This = impl_from_IHTMLTable(iface);
 215     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 216     return E_NOTIMPL;
 217 }
 218
 219 static HRESULT WINAPI HTMLTable_get_bgColor(IHTMLTable *iface, VARIANT *p)
 220 {
 221     HTMLTable *This = impl_from_IHTMLTable(iface);
 222     FIXME("(%p)->(%p)\n", This, p);
 223     return E_NOTIMPL;
 224 }
 225
 226 static HRESULT WINAPI HTMLTable_put_borderColor(IHTMLTable *iface, VARIANT v)
 227 {
 228     HTMLTable *This = impl_from_IHTMLTable(iface);
 229     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT WINAPI HTMLTable_get_borderColor(IHTMLTable *iface, VARIANT *p)
 234 {
 235     HTMLTable *This = impl_from_IHTMLTable(iface);
 236     FIXME("(%p)->(%p)\n", This, p);
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI HTMLTable_put_borderColorLight(IHTMLTable *iface, VARIANT v)
 241 {
 242     HTMLTable *This = impl_from_IHTMLTable(iface);
 243     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 244     return E_NOTIMPL;
 245 }
 246
 247 static HRESULT WINAPI HTMLTable_get_borderColorLight(IHTMLTable *iface, VARIANT *p)
 248 {
 249     HTMLTable *This = impl_from_IHTMLTable(iface);
 250     FIXME("(%p)->(%p)\n", This, p);
 251     return E_NOTIMPL;
 252 }
 253
 254 static HRESULT WINAPI HTMLTable_put_borderColorDark(IHTMLTable *iface, VARIANT v)
 255 {
 256     HTMLTable *This = impl_from_IHTMLTable(iface);
 257     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 258     return E_NOTIMPL;
 259 }
 260
 261 static HRESULT WINAPI HTMLTable_get_borderColorDark(IHTMLTable *iface, VARIANT *p)
 262 {
 263     HTMLTable *This = impl_from_IHTMLTable(iface);
 264     FIXME("(%p)->(%p)\n", This, p);
 265     return E_NOTIMPL;
 266 }
 267
 268 static HRESULT WINAPI HTMLTable_put_align(IHTMLTable *iface, BSTR v)
 269 {
 270     HTMLTable *This = impl_from_IHTMLTable(iface);
 271     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 272     return E_NOTIMPL;
 273 }
 274
 275 static HRESULT WINAPI HTMLTable_get_align(IHTMLTable *iface, BSTR *p)
 276 {
 277     HTMLTable *This = impl_from_IHTMLTable(iface);
 278     FIXME("(%p)->(%p)\n", This, p);
 279     return E_NOTIMPL;
 280 }
 281
 282 static HRESULT WINAPI HTMLTable_refresh(IHTMLTable *iface)
 283 {
 284     HTMLTable *This = impl_from_IHTMLTable(iface);
 285     FIXME("(%p)\n", This);
 286     return E_NOTIMPL;
 287 }
 288
 289 static HRESULT WINAPI HTMLTable_get_rows(IHTMLTable *iface, IHTMLElementCollection **p)
 290 {
 291     HTMLTable *This = impl_from_IHTMLTable(iface);
 292     nsIDOMHTMLCollection *nscol;
 293     nsresult nsres;
 294
 295     TRACE("(%p)->(%p)\n", This, p);
 296
 297     nsres = nsIDOMHTMLTableElement_GetRows(This->nstable, &nscol);
 298     if(NS_FAILED(nsres)) {
 299         ERR("GetRows failed: %08x\n", nsres);
 300         return E_FAIL;
 301     }
 302
 303     *p = create_collection_from_htmlcol(This->element.node.doc, nscol);
 304
 305     nsIDOMHTMLCollection_Release(nscol);
 306     return S_OK;
 307 }
 308
 309 static HRESULT WINAPI HTMLTable_put_width(IHTMLTable *iface, VARIANT v)
 310 {
 311     HTMLTable *This = impl_from_IHTMLTable(iface);
 312     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI HTMLTable_get_width(IHTMLTable *iface, VARIANT *p)
 317 {
 318     HTMLTable *This = impl_from_IHTMLTable(iface);
 319     FIXME("(%p)->(%p)\n", This, p);
 320     return E_NOTIMPL;
 321 }
 322
 323 static HRESULT WINAPI HTMLTable_put_height(IHTMLTable *iface, VARIANT v)
 324 {
 325     HTMLTable *This = impl_from_IHTMLTable(iface);
 326     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 327     return E_NOTIMPL;
 328 }
 329
 330 static HRESULT WINAPI HTMLTable_get_height(IHTMLTable *iface, VARIANT *p)
 331 {
 332     HTMLTable *This = impl_from_IHTMLTable(iface);
 333     FIXME("(%p)->(%p)\n", This, p);
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI HTMLTable_put_dataPageSize(IHTMLTable *iface, LONG v)
 338 {
 339     HTMLTable *This = impl_from_IHTMLTable(iface);
 340     FIXME("(%p)->(%d)\n", This, v);
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI HTMLTable_get_dataPageSize(IHTMLTable *iface, LONG *p)
 345 {
 346     HTMLTable *This = impl_from_IHTMLTable(iface);
 347     FIXME("(%p)->(%p)\n", This, p);
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI HTMLTable_nextPage(IHTMLTable *iface)
 352 {
 353     HTMLTable *This = impl_from_IHTMLTable(iface);
 354     FIXME("(%p)\n", This);
 355     return E_NOTIMPL;
 356 }
 357
 358 static HRESULT WINAPI HTMLTable_previousPage(IHTMLTable *iface)
 359 {
 360     HTMLTable *This = impl_from_IHTMLTable(iface);
 361     FIXME("(%p)\n", This);
 362     return E_NOTIMPL;
 363 }
 364
 365 static HRESULT WINAPI HTMLTable_get_tHead(IHTMLTable *iface, IHTMLTableSection **p)
 366 {
 367     HTMLTable *This = impl_from_IHTMLTable(iface);
 368     FIXME("(%p)->(%p)\n", This, p);
 369     return E_NOTIMPL;
 370 }
 371
 372 static HRESULT WINAPI HTMLTable_get_tFoot(IHTMLTable *iface, IHTMLTableSection **p)
 373 {
 374     HTMLTable *This = impl_from_IHTMLTable(iface);
 375     FIXME("(%p)->(%p)\n", This, p);
 376     return E_NOTIMPL;
 377 }
 378
 379 static HRESULT WINAPI HTMLTable_get_tBodies(IHTMLTable *iface, IHTMLElementCollection **p)
 380 {
 381     HTMLTable *This = impl_from_IHTMLTable(iface);
 382     nsIDOMHTMLCollection *nscol = NULL;
 383     nsresult nsres;
 384
 385     TRACE("(%p)->(%p)\n", This, p);
 386
 387     nsres = nsIDOMHTMLTableElement_GetTBodies(This->nstable, &nscol);
 388     if(NS_FAILED(nsres)) {
 389         ERR("GetTBodies failed: %08x\n", nsres);
 390         return E_FAIL;
 391     }
 392
 393     *p = create_collection_from_htmlcol(This->element.node.doc, nscol);
 394
 395     nsIDOMHTMLCollection_Release(nscol);
 396     return S_OK;
 397 }
 398
 399 static HRESULT WINAPI HTMLTable_get_caption(IHTMLTable *iface, IHTMLTableCaption **p)
 400 {
 401     HTMLTable *This = impl_from_IHTMLTable(iface);
 402     FIXME("(%p)->(%p)\n", This, p);
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI HTMLTable_createTHead(IHTMLTable *iface, IDispatch **head)
 407 {
 408     HTMLTable *This = impl_from_IHTMLTable(iface);
 409     FIXME("(%p)->(%p)\n", This, head);
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI HTMLTable_deleteTHead(IHTMLTable *iface)
 414 {
 415     HTMLTable *This = impl_from_IHTMLTable(iface);
 416     FIXME("(%p)\n", This);
 417     return E_NOTIMPL;
 418 }
 419
 420 static HRESULT WINAPI HTMLTable_createTFoot(IHTMLTable *iface, IDispatch **foot)
 421 {
 422     HTMLTable *This = impl_from_IHTMLTable(iface);
 423     FIXME("(%p)->(%p)\n", This, foot);
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI HTMLTable_deleteTFoot(IHTMLTable *iface)
 428 {
 429     HTMLTable *This = impl_from_IHTMLTable(iface);
 430     FIXME("(%p)\n", This);
 431     return E_NOTIMPL;
 432 }
 433
 434 static HRESULT WINAPI HTMLTable_createCaption(IHTMLTable *iface, IHTMLTableCaption **caption)
 435 {
 436     HTMLTable *This = impl_from_IHTMLTable(iface);
 437     FIXME("(%p)->(%p)\n", This, caption);
 438     return E_NOTIMPL;
 439 }
 440
 441 static HRESULT WINAPI HTMLTable_deleteCaption(IHTMLTable *iface)
 442 {
 443     HTMLTable *This = impl_from_IHTMLTable(iface);
 444     FIXME("(%p)\n", This);
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI HTMLTable_insertRow(IHTMLTable *iface, LONG index, IDispatch **row)
 449 {
 450     HTMLTable *This = impl_from_IHTMLTable(iface);
 451     FIXME("(%p)->(%d %p)\n", This, index, row);
 452     return E_NOTIMPL;
 453 }
 454
 455 static HRESULT WINAPI HTMLTable_deleteRow(IHTMLTable *iface, LONG index)
 456 {
 457     HTMLTable *This = impl_from_IHTMLTable(iface);
 458     FIXME("(%p)->(%d)\n", This, index);
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT WINAPI HTMLTable_get_readyState(IHTMLTable *iface, BSTR *p)
 463 {
 464     HTMLTable *This = impl_from_IHTMLTable(iface);
 465     FIXME("(%p)->(%p)\n", This, p);
 466     return E_NOTIMPL;
 467 }
 468
 469 static HRESULT WINAPI HTMLTable_put_onreadystatechange(IHTMLTable *iface, VARIANT v)
 470 {
 471     HTMLTable *This = impl_from_IHTMLTable(iface);
 472     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI HTMLTable_get_onreadystatechange(IHTMLTable *iface, VARIANT *p)
 477 {
 478     HTMLTable *This = impl_from_IHTMLTable(iface);
 479     FIXME("(%p)->(%p)\n", This, p);
 480     return E_NOTIMPL;
 481 }
 482
 483 static const IHTMLTableVtbl HTMLTableVtbl = {
 484     HTMLTable_QueryInterface,
 485     HTMLTable_AddRef,
 486     HTMLTable_Release,
 487     HTMLTable_GetTypeInfoCount,
 488     HTMLTable_GetTypeInfo,
 489     HTMLTable_GetIDsOfNames,
 490     HTMLTable_Invoke,
 491     HTMLTable_put_cols,
 492     HTMLTable_get_cols,
 493     HTMLTable_put_border,
 494     HTMLTable_get_border,
 495     HTMLTable_put_frame,
 496     HTMLTable_get_frame,
 497     HTMLTable_put_rules,
 498     HTMLTable_get_rules,
 499     HTMLTable_put_cellSpacing,
 500     HTMLTable_get_cellSpacing,
 501     HTMLTable_put_cellPadding,
 502     HTMLTable_get_cellPadding,
 503     HTMLTable_put_background,
 504     HTMLTable_get_background,
 505     HTMLTable_put_bgColor,
 506     HTMLTable_get_bgColor,
 507     HTMLTable_put_borderColor,
 508     HTMLTable_get_borderColor,
 509     HTMLTable_put_borderColorLight,
 510     HTMLTable_get_borderColorLight,
 511     HTMLTable_put_borderColorDark,
 512     HTMLTable_get_borderColorDark,
 513     HTMLTable_put_align,
 514     HTMLTable_get_align,
 515     HTMLTable_refresh,
 516     HTMLTable_get_rows,
 517     HTMLTable_put_width,
 518     HTMLTable_get_width,
 519     HTMLTable_put_height,
 520     HTMLTable_get_height,
 521     HTMLTable_put_dataPageSize,
 522     HTMLTable_get_dataPageSize,
 523     HTMLTable_nextPage,
 524     HTMLTable_previousPage,
 525     HTMLTable_get_tHead,
 526     HTMLTable_get_tFoot,
 527     HTMLTable_get_tBodies,
 528     HTMLTable_get_caption,
 529     HTMLTable_createTHead,
 530     HTMLTable_deleteTHead,
 531     HTMLTable_createTFoot,
 532     HTMLTable_deleteTFoot,
 533     HTMLTable_createCaption,
 534     HTMLTable_deleteCaption,
 535     HTMLTable_insertRow,
 536     HTMLTable_deleteRow,
 537     HTMLTable_get_readyState,
 538     HTMLTable_put_onreadystatechange,
 539     HTMLTable_get_onreadystatechange
 540 };
 541
 542 /* IHTMLTable2 */
 543 static HRESULT WINAPI HTMLTable2_QueryInterface(IHTMLTable2 *iface,
 544                                                          REFIID riid, void **ppv)
 545 {
 546     HTMLTable *This = impl_from_IHTMLTable2(iface);
 547
 548     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 549 }
 550
 551 static ULONG WINAPI HTMLTable2_AddRef(IHTMLTable2 *iface)
 552 {
 553     HTMLTable *This = impl_from_IHTMLTable2(iface);
 554
 555     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 556 }
 557
 558 static ULONG WINAPI HTMLTable2_Release(IHTMLTable2 *iface)
 559 {
 560     HTMLTable *This = impl_from_IHTMLTable2(iface);
 561
 562     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 563 }
 564
 565 static HRESULT WINAPI HTMLTable2_GetTypeInfoCount(IHTMLTable2 *iface, UINT *pctinfo)
 566 {
 567     HTMLTable *This = impl_from_IHTMLTable2(iface);
 568     return IDispatchEx_GetTypeInfoCount(&This->element.node.dispex.IDispatchEx_iface, pctinfo);
 569 }
 570
 571 static HRESULT WINAPI HTMLTable2_GetTypeInfo(IHTMLTable2 *iface, UINT iTInfo,
 572                                               LCID lcid, ITypeInfo **ppTInfo)
 573 {
 574     HTMLTable *This = impl_from_IHTMLTable2(iface);
 575     return IDispatchEx_GetTypeInfo(&This->element.node.dispex.IDispatchEx_iface, iTInfo, lcid,
 576             ppTInfo);
 577 }
 578
 579 static HRESULT WINAPI HTMLTable2_GetIDsOfNames(IHTMLTable2 *iface, REFIID riid,
 580                                                 LPOLESTR *rgszNames, UINT cNames,
 581                                                 LCID lcid, DISPID *rgDispId)
 582 {
 583     HTMLTable *This = impl_from_IHTMLTable2(iface);
 584     return IDispatchEx_GetIDsOfNames(&This->element.node.dispex.IDispatchEx_iface, riid, rgszNames,
 585             cNames, lcid, rgDispId);
 586 }
 587
 588 static HRESULT WINAPI HTMLTable2_Invoke(IHTMLTable2 *iface, DISPID dispIdMember,
 589                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 590                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 591 {
 592     HTMLTable *This = impl_from_IHTMLTable2(iface);
 593     return IDispatchEx_Invoke(&This->element.node.dispex.IDispatchEx_iface, dispIdMember, riid,
 594             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 595 }
 596
 597 static HRESULT WINAPI HTMLTable2_firstPage(IHTMLTable2 *iface)
 598 {
 599     HTMLTable *This = impl_from_IHTMLTable2(iface);
 600     FIXME("(%p)->()\n", This);
 601     return E_NOTIMPL;
 602 }
 603
 604 static HRESULT WINAPI HTMLTable2_lastPage(IHTMLTable2 *iface)
 605 {
 606     HTMLTable *This = impl_from_IHTMLTable2(iface);
 607     FIXME("(%p)->()\n", This);
 608     return E_NOTIMPL;
 609 }
 610
 611 static HRESULT WINAPI HTMLTable2_cells(IHTMLTable2 *iface, IHTMLElementCollection **p)
 612 {
 613     HTMLTable *This = impl_from_IHTMLTable2(iface);
 614     FIXME("(%p)->(%p)\n", This, p);
 615     return E_NOTIMPL;
 616 }
 617
 618 static HRESULT WINAPI HTMLTable2_moveRow(IHTMLTable2 *iface, LONG indexFrom, LONG indexTo, IDispatch **row)
 619 {
 620     HTMLTable *This = impl_from_IHTMLTable2(iface);
 621     FIXME("(%p)->(%d %d %p)\n", This, indexFrom, indexTo, row);
 622     return E_NOTIMPL;
 623 }
 624
 625
 626 static const IHTMLTable2Vtbl HTMLTable2Vtbl = {
 627     HTMLTable2_QueryInterface,
 628     HTMLTable2_AddRef,
 629     HTMLTable2_Release,
 630     HTMLTable2_GetTypeInfoCount,
 631     HTMLTable2_GetTypeInfo,
 632     HTMLTable2_GetIDsOfNames,
 633     HTMLTable2_Invoke,
 634     HTMLTable2_firstPage,
 635     HTMLTable2_lastPage,
 636     HTMLTable2_cells,
 637     HTMLTable2_moveRow
 638 };
 639
 640 /* IHTMLTable3 */
 641 static HRESULT WINAPI HTMLTable3_QueryInterface(IHTMLTable3 *iface,
 642                                                          REFIID riid, void **ppv)
 643 {
 644     HTMLTable *This = impl_from_IHTMLTable3(iface);
 645
 646     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 647 }
 648
 649 static ULONG WINAPI HTMLTable3_AddRef(IHTMLTable3 *iface)
 650 {
 651     HTMLTable *This = impl_from_IHTMLTable3(iface);
 652
 653     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 654 }
 655
 656 static ULONG WINAPI HTMLTable3_Release(IHTMLTable3 *iface)
 657 {
 658     HTMLTable *This = impl_from_IHTMLTable3(iface);
 659
 660     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 661 }
 662
 663 static HRESULT WINAPI HTMLTable3_GetTypeInfoCount(IHTMLTable3 *iface, UINT *pctinfo)
 664 {
 665     HTMLTable *This = impl_from_IHTMLTable3(iface);
 666     return IDispatchEx_GetTypeInfoCount(&This->element.node.dispex.IDispatchEx_iface, pctinfo);
 667 }
 668
 669 static HRESULT WINAPI HTMLTable3_GetTypeInfo(IHTMLTable3 *iface, UINT iTInfo,
 670                                               LCID lcid, ITypeInfo **ppTInfo)
 671 {
 672     HTMLTable *This = impl_from_IHTMLTable3(iface);
 673     return IDispatchEx_GetTypeInfo(&This->element.node.dispex.IDispatchEx_iface, iTInfo, lcid,
 674             ppTInfo);
 675 }
 676
 677 static HRESULT WINAPI HTMLTable3_GetIDsOfNames(IHTMLTable3 *iface, REFIID riid,
 678                                                 LPOLESTR *rgszNames, UINT cNames,
 679                                                 LCID lcid, DISPID *rgDispId)
 680 {
 681     HTMLTable *This = impl_from_IHTMLTable3(iface);
 682     return IDispatchEx_GetIDsOfNames(&This->element.node.dispex.IDispatchEx_iface, riid, rgszNames,
 683             cNames, lcid, rgDispId);
 684 }
 685
 686 static HRESULT WINAPI HTMLTable3_Invoke(IHTMLTable3 *iface, DISPID dispIdMember,
 687                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 688                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 689 {
 690     HTMLTable *This = impl_from_IHTMLTable3(iface);
 691     return IDispatchEx_Invoke(&This->element.node.dispex.IDispatchEx_iface, dispIdMember, riid,
 692             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 693 }
 694
 695 static HRESULT WINAPI HTMLTable3_put_summary(IHTMLTable3 *iface, BSTR v)
 696 {
 697     HTMLTable *This = impl_from_IHTMLTable3(iface);
 698     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 699     return E_NOTIMPL;
 700 }
 701
 702 static HRESULT WINAPI HTMLTable3_get_summary(IHTMLTable3 *iface, BSTR * p)
 703 {
 704     HTMLTable *This = impl_from_IHTMLTable3(iface);
 705     FIXME("(%p)->(%p)\n", This, p);
 706     return E_NOTIMPL;
 707 }
 708
 709 static const IHTMLTable3Vtbl HTMLTable3Vtbl = {
 710     HTMLTable3_QueryInterface,
 711     HTMLTable3_AddRef,
 712     HTMLTable3_Release,
 713     HTMLTable3_GetTypeInfoCount,
 714     HTMLTable3_GetTypeInfo,
 715     HTMLTable3_GetIDsOfNames,
 716     HTMLTable3_Invoke,
 717     HTMLTable3_put_summary,
 718     HTMLTable3_get_summary
 719 };
 720
 721 static inline HTMLTable *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
 722 {
 723     return CONTAINING_RECORD(iface, HTMLTable, element.node);
 724 }
 725
 726 static HRESULT HTMLTable_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 727 {
 728     HTMLTable *This = impl_from_HTMLDOMNode(iface);
 729
 730     *ppv = NULL;
 731
 732     if(IsEqualGUID(&IID_IUnknown, riid)) {
 733         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 734         *ppv = &This->IHTMLTable_iface;
 735     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 736         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 737         *ppv = &This->IHTMLTable_iface;
 738     }else if(IsEqualGUID(&IID_IHTMLTable, riid)) {
 739         TRACE("(%p)->(IID_IHTMLTable %p)\n", This, ppv);
 740         *ppv = &This->IHTMLTable_iface;
 741     }else if(IsEqualGUID(&IID_IHTMLTable2, riid)) {
 742         TRACE("(%p)->(IID_IHTMLTable2 %p)\n", This, ppv);
 743         *ppv = &This->IHTMLTable_iface;
 744     }else if(IsEqualGUID(&IID_IHTMLTable3, riid)) {
 745         TRACE("(%p)->(IID_IHTMLTable3 %p)\n", This, ppv);
 746         *ppv = &This->IHTMLTable_iface;
 747     }
 748
 749     if(*ppv) {
 750         IUnknown_AddRef((IUnknown*)*ppv);
 751         return S_OK;
 752     }
 753
 754     return HTMLElement_QI(&This->element.node, riid, ppv);
 755 }
 756
 757 static const cpc_entry_t HTMLTable_cpc[] = {
 758     {&DIID_HTMLTableEvents},
 759     HTMLELEMENT_CPC,
 760     {NULL}
 761 };
 762
 763 static const NodeImplVtbl HTMLTableImplVtbl = {
 764     HTMLTable_QI,
 765     HTMLElement_destructor,
 766     HTMLTable_cpc,
 767     HTMLElement_clone,
 768     HTMLElement_handle_event,
 769     HTMLElement_get_attr_col
 770 };
 771
 772 static const tid_t HTMLTable_iface_tids[] = {
 773     HTMLELEMENT_TIDS,
 774     IHTMLTable_tid,
 775     0
 776 };
 777
 778 static dispex_static_data_t HTMLTable_dispex = {
 779     NULL,
 780     DispHTMLTable_tid,
 781     NULL,
 782     HTMLTable_iface_tids
 783 };
 784
 785 HRESULT HTMLTable_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
 786 {
 787     HTMLTable *ret;
 788     nsresult nsres;
 789
 790     ret = heap_alloc_zero(sizeof(HTMLTable));
 791     if(!ret)
 792         return E_OUTOFMEMORY;
 793
 794     ret->element.node.vtbl = &HTMLTableImplVtbl;
 795     ret->IHTMLTable_iface.lpVtbl = &HTMLTableVtbl;
 796
 797     HTMLElement_Init(&ret->element, doc, nselem, &HTMLTable_dispex);
 798
 799     nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableElement, (void**)&ret->nstable);
 800
 801     /* Share the reference with nsnode */
 802     assert(nsres == NS_OK && (nsIDOMNode*)ret->nstable == ret->element.node.nsnode);
 803     nsIDOMNode_Release(ret->element.node.nsnode);
 804
 805     *elem = &ret->element;
 806     return S_OK;
 807 }