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
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  33
  34 struct HTMLTable {
  35     HTMLElement element;
  36
  37     IHTMLTable  IHTMLTable_iface;
  38     IHTMLTable2 IHTMLTable2_iface;
  39     IHTMLTable3 IHTMLTable3_iface;
  40
  41     ConnectionPoint cp;
  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, (IUnknown*)&This->IHTMLTable_iface,
 304             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 void HTMLTable_destructor(HTMLDOMNode *iface)
 746 {
 747     HTMLTable *This = impl_from_HTMLDOMNode(iface);
 748
 749     if(This->nstable)
 750         nsIDOMHTMLTableElement_Release(This->nstable);
 751
 752     HTMLElement_destructor(&This->element.node);
 753 }
 754
 755 static const NodeImplVtbl HTMLTableImplVtbl = {
 756     HTMLTable_QI,
 757     HTMLTable_destructor,
 758     HTMLElement_clone,
 759     HTMLElement_get_attr_col
 760 };
 761
 762 static const tid_t HTMLTable_iface_tids[] = {
 763     HTMLELEMENT_TIDS,
 764     IHTMLTable_tid,
 765     0
 766 };
 767
 768 static dispex_static_data_t HTMLTable_dispex = {
 769     NULL,
 770     DispHTMLTable_tid,
 771     NULL,
 772     HTMLTable_iface_tids
 773 };
 774
 775 HRESULT HTMLTable_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
 776 {
 777     HTMLTable *ret;
 778     nsresult nsres;
 779
 780     ret = heap_alloc_zero(sizeof(HTMLTable));
 781     if(!ret)
 782         return E_OUTOFMEMORY;
 783
 784     ret->element.node.vtbl = &HTMLTableImplVtbl;
 785     ret->IHTMLTable_iface.lpVtbl = &HTMLTableVtbl;
 786
 787     nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableElement, (void**)&ret->nstable);
 788     if(NS_FAILED(nsres)) {
 789         ERR("Could not get nsIDOMHTMLTableElement iface: %08x\n", nsres);
 790         heap_free(ret);
 791         return E_FAIL;
 792     }
 793
 794     HTMLElement_Init(&ret->element, doc, nselem, &HTMLTable_dispex);
 795     ConnectionPoint_Init(&ret->cp, &ret->element.cp_container, &DIID_HTMLTableEvents, NULL);
 796
 797     *elem = &ret->element;
 798     return S_OK;
 799 }