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