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     FIXME("(%p)->(%p)\n", This, p);
 383     return E_NOTIMPL;
 384 }
 385
 386 static HRESULT WINAPI HTMLTable_get_caption(IHTMLTable *iface, IHTMLTableCaption **p)
 387 {
 388     HTMLTable *This = impl_from_IHTMLTable(iface);
 389     FIXME("(%p)->(%p)\n", This, p);
 390     return E_NOTIMPL;
 391 }
 392
 393 static HRESULT WINAPI HTMLTable_createTHead(IHTMLTable *iface, IDispatch **head)
 394 {
 395     HTMLTable *This = impl_from_IHTMLTable(iface);
 396     FIXME("(%p)->(%p)\n", This, head);
 397     return E_NOTIMPL;
 398 }
 399
 400 static HRESULT WINAPI HTMLTable_deleteTHead(IHTMLTable *iface)
 401 {
 402     HTMLTable *This = impl_from_IHTMLTable(iface);
 403     FIXME("(%p)\n", This);
 404     return E_NOTIMPL;
 405 }
 406
 407 static HRESULT WINAPI HTMLTable_createTFoot(IHTMLTable *iface, IDispatch **foot)
 408 {
 409     HTMLTable *This = impl_from_IHTMLTable(iface);
 410     FIXME("(%p)->(%p)\n", This, foot);
 411     return E_NOTIMPL;
 412 }
 413
 414 static HRESULT WINAPI HTMLTable_deleteTFoot(IHTMLTable *iface)
 415 {
 416     HTMLTable *This = impl_from_IHTMLTable(iface);
 417     FIXME("(%p)\n", This);
 418     return E_NOTIMPL;
 419 }
 420
 421 static HRESULT WINAPI HTMLTable_createCaption(IHTMLTable *iface, IHTMLTableCaption **caption)
 422 {
 423     HTMLTable *This = impl_from_IHTMLTable(iface);
 424     FIXME("(%p)->(%p)\n", This, caption);
 425     return E_NOTIMPL;
 426 }
 427
 428 static HRESULT WINAPI HTMLTable_deleteCaption(IHTMLTable *iface)
 429 {
 430     HTMLTable *This = impl_from_IHTMLTable(iface);
 431     FIXME("(%p)\n", This);
 432     return E_NOTIMPL;
 433 }
 434
 435 static HRESULT WINAPI HTMLTable_insertRow(IHTMLTable *iface, LONG index, IDispatch **row)
 436 {
 437     HTMLTable *This = impl_from_IHTMLTable(iface);
 438     FIXME("(%p)->(%d %p)\n", This, index, row);
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI HTMLTable_deleteRow(IHTMLTable *iface, LONG index)
 443 {
 444     HTMLTable *This = impl_from_IHTMLTable(iface);
 445     FIXME("(%p)->(%d)\n", This, index);
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI HTMLTable_get_readyState(IHTMLTable *iface, BSTR *p)
 450 {
 451     HTMLTable *This = impl_from_IHTMLTable(iface);
 452     FIXME("(%p)->(%p)\n", This, p);
 453     return E_NOTIMPL;
 454 }
 455
 456 static HRESULT WINAPI HTMLTable_put_onreadystatechange(IHTMLTable *iface, VARIANT v)
 457 {
 458     HTMLTable *This = impl_from_IHTMLTable(iface);
 459     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI HTMLTable_get_onreadystatechange(IHTMLTable *iface, VARIANT *p)
 464 {
 465     HTMLTable *This = impl_from_IHTMLTable(iface);
 466     FIXME("(%p)->(%p)\n", This, p);
 467     return E_NOTIMPL;
 468 }
 469
 470 static const IHTMLTableVtbl HTMLTableVtbl = {
 471     HTMLTable_QueryInterface,
 472     HTMLTable_AddRef,
 473     HTMLTable_Release,
 474     HTMLTable_GetTypeInfoCount,
 475     HTMLTable_GetTypeInfo,
 476     HTMLTable_GetIDsOfNames,
 477     HTMLTable_Invoke,
 478     HTMLTable_put_cols,
 479     HTMLTable_get_cols,
 480     HTMLTable_put_border,
 481     HTMLTable_get_border,
 482     HTMLTable_put_frame,
 483     HTMLTable_get_frame,
 484     HTMLTable_put_rules,
 485     HTMLTable_get_rules,
 486     HTMLTable_put_cellSpacing,
 487     HTMLTable_get_cellSpacing,
 488     HTMLTable_put_cellPadding,
 489     HTMLTable_get_cellPadding,
 490     HTMLTable_put_background,
 491     HTMLTable_get_background,
 492     HTMLTable_put_bgColor,
 493     HTMLTable_get_bgColor,
 494     HTMLTable_put_borderColor,
 495     HTMLTable_get_borderColor,
 496     HTMLTable_put_borderColorLight,
 497     HTMLTable_get_borderColorLight,
 498     HTMLTable_put_borderColorDark,
 499     HTMLTable_get_borderColorDark,
 500     HTMLTable_put_align,
 501     HTMLTable_get_align,
 502     HTMLTable_refresh,
 503     HTMLTable_get_rows,
 504     HTMLTable_put_width,
 505     HTMLTable_get_width,
 506     HTMLTable_put_height,
 507     HTMLTable_get_height,
 508     HTMLTable_put_dataPageSize,
 509     HTMLTable_get_dataPageSize,
 510     HTMLTable_nextPage,
 511     HTMLTable_previousPage,
 512     HTMLTable_get_tHead,
 513     HTMLTable_get_tFoot,
 514     HTMLTable_get_tBodies,
 515     HTMLTable_get_caption,
 516     HTMLTable_createTHead,
 517     HTMLTable_deleteTHead,
 518     HTMLTable_createTFoot,
 519     HTMLTable_deleteTFoot,
 520     HTMLTable_createCaption,
 521     HTMLTable_deleteCaption,
 522     HTMLTable_insertRow,
 523     HTMLTable_deleteRow,
 524     HTMLTable_get_readyState,
 525     HTMLTable_put_onreadystatechange,
 526     HTMLTable_get_onreadystatechange
 527 };
 528
 529 /* IHTMLTable2 */
 530 static HRESULT WINAPI HTMLTable2_QueryInterface(IHTMLTable2 *iface,
 531                                                          REFIID riid, void **ppv)
 532 {
 533     HTMLTable *This = impl_from_IHTMLTable2(iface);
 534
 535     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 536 }
 537
 538 static ULONG WINAPI HTMLTable2_AddRef(IHTMLTable2 *iface)
 539 {
 540     HTMLTable *This = impl_from_IHTMLTable2(iface);
 541
 542     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 543 }
 544
 545 static ULONG WINAPI HTMLTable2_Release(IHTMLTable2 *iface)
 546 {
 547     HTMLTable *This = impl_from_IHTMLTable2(iface);
 548
 549     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 550 }
 551
 552 static HRESULT WINAPI HTMLTable2_GetTypeInfoCount(IHTMLTable2 *iface, UINT *pctinfo)
 553 {
 554     HTMLTable *This = impl_from_IHTMLTable2(iface);
 555     return IDispatchEx_GetTypeInfoCount(&This->element.node.dispex.IDispatchEx_iface, pctinfo);
 556 }
 557
 558 static HRESULT WINAPI HTMLTable2_GetTypeInfo(IHTMLTable2 *iface, UINT iTInfo,
 559                                               LCID lcid, ITypeInfo **ppTInfo)
 560 {
 561     HTMLTable *This = impl_from_IHTMLTable2(iface);
 562     return IDispatchEx_GetTypeInfo(&This->element.node.dispex.IDispatchEx_iface, iTInfo, lcid,
 563             ppTInfo);
 564 }
 565
 566 static HRESULT WINAPI HTMLTable2_GetIDsOfNames(IHTMLTable2 *iface, REFIID riid,
 567                                                 LPOLESTR *rgszNames, UINT cNames,
 568                                                 LCID lcid, DISPID *rgDispId)
 569 {
 570     HTMLTable *This = impl_from_IHTMLTable2(iface);
 571     return IDispatchEx_GetIDsOfNames(&This->element.node.dispex.IDispatchEx_iface, riid, rgszNames,
 572             cNames, lcid, rgDispId);
 573 }
 574
 575 static HRESULT WINAPI HTMLTable2_Invoke(IHTMLTable2 *iface, DISPID dispIdMember,
 576                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 577                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 578 {
 579     HTMLTable *This = impl_from_IHTMLTable2(iface);
 580     return IDispatchEx_Invoke(&This->element.node.dispex.IDispatchEx_iface, dispIdMember, riid,
 581             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 582 }
 583
 584 static HRESULT WINAPI HTMLTable2_firstPage(IHTMLTable2 *iface)
 585 {
 586     HTMLTable *This = impl_from_IHTMLTable2(iface);
 587     FIXME("(%p)->()\n", This);
 588     return E_NOTIMPL;
 589 }
 590
 591 static HRESULT WINAPI HTMLTable2_lastPage(IHTMLTable2 *iface)
 592 {
 593     HTMLTable *This = impl_from_IHTMLTable2(iface);
 594     FIXME("(%p)->()\n", This);
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI HTMLTable2_cells(IHTMLTable2 *iface, IHTMLElementCollection **p)
 599 {
 600     HTMLTable *This = impl_from_IHTMLTable2(iface);
 601     FIXME("(%p)->(%p)\n", This, p);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI HTMLTable2_moveRow(IHTMLTable2 *iface, LONG indexFrom, LONG indexTo, IDispatch **row)
 606 {
 607     HTMLTable *This = impl_from_IHTMLTable2(iface);
 608     FIXME("(%p)->(%d %d %p)\n", This, indexFrom, indexTo, row);
 609     return E_NOTIMPL;
 610 }
 611
 612
 613 static const IHTMLTable2Vtbl HTMLTable2Vtbl = {
 614     HTMLTable2_QueryInterface,
 615     HTMLTable2_AddRef,
 616     HTMLTable2_Release,
 617     HTMLTable2_GetTypeInfoCount,
 618     HTMLTable2_GetTypeInfo,
 619     HTMLTable2_GetIDsOfNames,
 620     HTMLTable2_Invoke,
 621     HTMLTable2_firstPage,
 622     HTMLTable2_lastPage,
 623     HTMLTable2_cells,
 624     HTMLTable2_moveRow
 625 };
 626
 627 /* IHTMLTable3 */
 628 static HRESULT WINAPI HTMLTable3_QueryInterface(IHTMLTable3 *iface,
 629                                                          REFIID riid, void **ppv)
 630 {
 631     HTMLTable *This = impl_from_IHTMLTable3(iface);
 632
 633     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 634 }
 635
 636 static ULONG WINAPI HTMLTable3_AddRef(IHTMLTable3 *iface)
 637 {
 638     HTMLTable *This = impl_from_IHTMLTable3(iface);
 639
 640     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 641 }
 642
 643 static ULONG WINAPI HTMLTable3_Release(IHTMLTable3 *iface)
 644 {
 645     HTMLTable *This = impl_from_IHTMLTable3(iface);
 646
 647     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 648 }
 649
 650 static HRESULT WINAPI HTMLTable3_GetTypeInfoCount(IHTMLTable3 *iface, UINT *pctinfo)
 651 {
 652     HTMLTable *This = impl_from_IHTMLTable3(iface);
 653     return IDispatchEx_GetTypeInfoCount(&This->element.node.dispex.IDispatchEx_iface, pctinfo);
 654 }
 655
 656 static HRESULT WINAPI HTMLTable3_GetTypeInfo(IHTMLTable3 *iface, UINT iTInfo,
 657                                               LCID lcid, ITypeInfo **ppTInfo)
 658 {
 659     HTMLTable *This = impl_from_IHTMLTable3(iface);
 660     return IDispatchEx_GetTypeInfo(&This->element.node.dispex.IDispatchEx_iface, iTInfo, lcid,
 661             ppTInfo);
 662 }
 663
 664 static HRESULT WINAPI HTMLTable3_GetIDsOfNames(IHTMLTable3 *iface, REFIID riid,
 665                                                 LPOLESTR *rgszNames, UINT cNames,
 666                                                 LCID lcid, DISPID *rgDispId)
 667 {
 668     HTMLTable *This = impl_from_IHTMLTable3(iface);
 669     return IDispatchEx_GetIDsOfNames(&This->element.node.dispex.IDispatchEx_iface, riid, rgszNames,
 670             cNames, lcid, rgDispId);
 671 }
 672
 673 static HRESULT WINAPI HTMLTable3_Invoke(IHTMLTable3 *iface, DISPID dispIdMember,
 674                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 675                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 676 {
 677     HTMLTable *This = impl_from_IHTMLTable3(iface);
 678     return IDispatchEx_Invoke(&This->element.node.dispex.IDispatchEx_iface, dispIdMember, riid,
 679             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 680 }
 681
 682 static HRESULT WINAPI HTMLTable3_put_summary(IHTMLTable3 *iface, BSTR v)
 683 {
 684     HTMLTable *This = impl_from_IHTMLTable3(iface);
 685     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 686     return E_NOTIMPL;
 687 }
 688
 689 static HRESULT WINAPI HTMLTable3_get_summary(IHTMLTable3 *iface, BSTR * p)
 690 {
 691     HTMLTable *This = impl_from_IHTMLTable3(iface);
 692     FIXME("(%p)->(%p)\n", This, p);
 693     return E_NOTIMPL;
 694 }
 695
 696 static const IHTMLTable3Vtbl HTMLTable3Vtbl = {
 697     HTMLTable3_QueryInterface,
 698     HTMLTable3_AddRef,
 699     HTMLTable3_Release,
 700     HTMLTable3_GetTypeInfoCount,
 701     HTMLTable3_GetTypeInfo,
 702     HTMLTable3_GetIDsOfNames,
 703     HTMLTable3_Invoke,
 704     HTMLTable3_put_summary,
 705     HTMLTable3_get_summary
 706 };
 707
 708 static inline HTMLTable *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
 709 {
 710     return CONTAINING_RECORD(iface, HTMLTable, element.node);
 711 }
 712
 713 static HRESULT HTMLTable_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 714 {
 715     HTMLTable *This = impl_from_HTMLDOMNode(iface);
 716
 717     *ppv = NULL;
 718
 719     if(IsEqualGUID(&IID_IUnknown, riid)) {
 720         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 721         *ppv = &This->IHTMLTable_iface;
 722     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 723         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 724         *ppv = &This->IHTMLTable_iface;
 725     }else if(IsEqualGUID(&IID_IHTMLTable, riid)) {
 726         TRACE("(%p)->(IID_IHTMLTable %p)\n", This, ppv);
 727         *ppv = &This->IHTMLTable_iface;
 728     }else if(IsEqualGUID(&IID_IHTMLTable2, riid)) {
 729         TRACE("(%p)->(IID_IHTMLTable2 %p)\n", This, ppv);
 730         *ppv = &This->IHTMLTable_iface;
 731     }else if(IsEqualGUID(&IID_IHTMLTable3, riid)) {
 732         TRACE("(%p)->(IID_IHTMLTable3 %p)\n", This, ppv);
 733         *ppv = &This->IHTMLTable_iface;
 734     }
 735
 736     if(*ppv) {
 737         IUnknown_AddRef((IUnknown*)*ppv);
 738         return S_OK;
 739     }
 740
 741     return HTMLElement_QI(&This->element.node, riid, ppv);
 742 }
 743
 744 static const cpc_entry_t HTMLTable_cpc[] = {
 745     {&DIID_HTMLTableEvents},
 746     HTMLELEMENT_CPC,
 747     {NULL}
 748 };
 749
 750 static const NodeImplVtbl HTMLTableImplVtbl = {
 751     HTMLTable_QI,
 752     HTMLElement_destructor,
 753     HTMLTable_cpc,
 754     HTMLElement_clone,
 755     HTMLElement_handle_event,
 756     HTMLElement_get_attr_col
 757 };
 758
 759 static const tid_t HTMLTable_iface_tids[] = {
 760     HTMLELEMENT_TIDS,
 761     IHTMLTable_tid,
 762     0
 763 };
 764
 765 static dispex_static_data_t HTMLTable_dispex = {
 766     NULL,
 767     DispHTMLTable_tid,
 768     NULL,
 769     HTMLTable_iface_tids
 770 };
 771
 772 HRESULT HTMLTable_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
 773 {
 774     HTMLTable *ret;
 775     nsresult nsres;
 776
 777     ret = heap_alloc_zero(sizeof(HTMLTable));
 778     if(!ret)
 779         return E_OUTOFMEMORY;
 780
 781     ret->element.node.vtbl = &HTMLTableImplVtbl;
 782     ret->IHTMLTable_iface.lpVtbl = &HTMLTableVtbl;
 783
 784     HTMLElement_Init(&ret->element, doc, nselem, &HTMLTable_dispex);
 785
 786     nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableElement, (void**)&ret->nstable);
 787
 788     /* Share the reference with nsnode */
 789     assert(nsres == NS_OK && (nsIDOMNode*)ret->nstable == ret->element.node.nsnode);
 790     nsIDOMNode_Release(ret->element.node.nsnode);
 791
 792     *elem = &ret->element;
 793     return S_OK;
 794 }