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 var2str(const VARIANT *p, nsAString *nsstr)
  61 {
  62     BSTR str;
  63     BOOL ret;
  64     HRESULT hres;
  65
  66     switch(V_VT(p)) {
  67     case VT_BSTR:
  68         return nsAString_Init(nsstr, V_BSTR(p))?
  69             S_OK : E_OUTOFMEMORY;
  70     case VT_R8:
  71         hres = VarBstrFromR8(V_R8(p), 0, 0, &str);
  72         break;
  73     case VT_R4:
  74         hres = VarBstrFromR4(V_R4(p), 0, 0, &str);
  75         break;
  76     case VT_I4:
  77         hres = VarBstrFromI4(V_I4(p), 0, 0, &str);
  78         break;
  79     default:
  80         FIXME("unsupported arg %s\n", debugstr_variant(p));
  81         return E_NOTIMPL;
  82     }
  83     if (FAILED(hres))
  84         return hres;
  85
  86     ret = nsAString_Init(nsstr, str);
  87     SysFreeString(str);
  88     return ret ? S_OK : E_OUTOFMEMORY;
  89 }
  90
  91 static HRESULT nsstr_to_truncated_bstr(const nsAString *nsstr, BSTR *ret_ptr)
  92 {
  93     const PRUnichar *str, *ptr, *end = NULL;
  94     BSTR ret;
  95
  96     nsAString_GetData(nsstr, &str);
  97
  98     for(ptr = str; isdigitW(*ptr); ptr++);
  99     if(*ptr == '.') {
 100         for(end = ptr++; isdigitW(*ptr); ptr++);
 101         if(*ptr)
 102             end = NULL;
 103     }
 104
 105     ret = end ? SysAllocStringLen(str, end-str) : SysAllocString(str);
 106
 107     *ret_ptr = ret;
 108     return ret ? S_OK : E_OUTOFMEMORY;
 109 }
 110
 111 static HRESULT WINAPI HTMLTable_QueryInterface(IHTMLTable *iface,
 112                                                          REFIID riid, void **ppv)
 113 {
 114     HTMLTable *This = impl_from_IHTMLTable(iface);
 115
 116     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 117 }
 118
 119 static ULONG WINAPI HTMLTable_AddRef(IHTMLTable *iface)
 120 {
 121     HTMLTable *This = impl_from_IHTMLTable(iface);
 122
 123     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 124 }
 125
 126 static ULONG WINAPI HTMLTable_Release(IHTMLTable *iface)
 127 {
 128     HTMLTable *This = impl_from_IHTMLTable(iface);
 129
 130     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 131 }
 132
 133 static HRESULT WINAPI HTMLTable_GetTypeInfoCount(IHTMLTable *iface, UINT *pctinfo)
 134 {
 135     HTMLTable *This = impl_from_IHTMLTable(iface);
 136     return IDispatchEx_GetTypeInfoCount(&This->element.node.dispex.IDispatchEx_iface, pctinfo);
 137 }
 138
 139 static HRESULT WINAPI HTMLTable_GetTypeInfo(IHTMLTable *iface, UINT iTInfo,
 140                                               LCID lcid, ITypeInfo **ppTInfo)
 141 {
 142     HTMLTable *This = impl_from_IHTMLTable(iface);
 143     return IDispatchEx_GetTypeInfo(&This->element.node.dispex.IDispatchEx_iface, iTInfo, lcid,
 144             ppTInfo);
 145 }
 146
 147 static HRESULT WINAPI HTMLTable_GetIDsOfNames(IHTMLTable *iface, REFIID riid,
 148                                                 LPOLESTR *rgszNames, UINT cNames,
 149                                                 LCID lcid, DISPID *rgDispId)
 150 {
 151     HTMLTable *This = impl_from_IHTMLTable(iface);
 152     return IDispatchEx_GetIDsOfNames(&This->element.node.dispex.IDispatchEx_iface, riid, rgszNames,
 153             cNames, lcid, rgDispId);
 154 }
 155
 156 static HRESULT WINAPI HTMLTable_Invoke(IHTMLTable *iface, DISPID dispIdMember,
 157                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 158                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 159 {
 160     HTMLTable *This = impl_from_IHTMLTable(iface);
 161     return IDispatchEx_Invoke(&This->element.node.dispex.IDispatchEx_iface, dispIdMember, riid,
 162             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 163 }
 164
 165 static HRESULT WINAPI HTMLTable_put_cols(IHTMLTable *iface, LONG v)
 166 {
 167     HTMLTable *This = impl_from_IHTMLTable(iface);
 168     FIXME("(%p)->(%d)\n", This, v);
 169     return E_NOTIMPL;
 170 }
 171
 172 static HRESULT WINAPI HTMLTable_get_cols(IHTMLTable *iface, LONG *p)
 173 {
 174     HTMLTable *This = impl_from_IHTMLTable(iface);
 175     FIXME("(%p)->(%p)\n", This, p);
 176     return E_NOTIMPL;
 177 }
 178
 179 static HRESULT WINAPI HTMLTable_put_border(IHTMLTable *iface, VARIANT v)
 180 {
 181     HTMLTable *This = impl_from_IHTMLTable(iface);
 182     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 183     return E_NOTIMPL;
 184 }
 185
 186 static HRESULT WINAPI HTMLTable_get_border(IHTMLTable *iface, VARIANT *p)
 187 {
 188     HTMLTable *This = impl_from_IHTMLTable(iface);
 189     FIXME("(%p)->(%p)\n", This, p);
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI HTMLTable_put_frame(IHTMLTable *iface, BSTR v)
 194 {
 195     HTMLTable *This = impl_from_IHTMLTable(iface);
 196     nsAString str;
 197     nsresult nsres;
 198
 199     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 200
 201     nsAString_InitDepend(&str, v);
 202     nsres = nsIDOMHTMLTableElement_SetFrame(This->nstable, &str);
 203     nsAString_Finish(&str);
 204
 205     if (NS_FAILED(nsres)) {
 206         ERR("SetFrame(%s) failed: %08x\n", debugstr_w(v), nsres);
 207         return E_FAIL;
 208     }
 209     return S_OK;
 210 }
 211
 212 static HRESULT WINAPI HTMLTable_get_frame(IHTMLTable *iface, BSTR *p)
 213 {
 214     HTMLTable *This = impl_from_IHTMLTable(iface);
 215     nsAString str;
 216     nsresult nsres;
 217
 218     TRACE("(%p)->(%p)\n", This, p);
 219
 220     nsAString_Init(&str, NULL);
 221     nsres = nsIDOMHTMLTableElement_GetFrame(This->nstable, &str);
 222
 223     return return_nsstr(nsres, &str, p);
 224 }
 225
 226 static HRESULT WINAPI HTMLTable_put_rules(IHTMLTable *iface, BSTR v)
 227 {
 228     HTMLTable *This = impl_from_IHTMLTable(iface);
 229     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT WINAPI HTMLTable_get_rules(IHTMLTable *iface, BSTR *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_cellSpacing(IHTMLTable *iface, VARIANT v)
 241 {
 242     HTMLTable *This = impl_from_IHTMLTable(iface);
 243     nsAString nsstr;
 244     WCHAR buf[64];
 245     nsresult nsres;
 246
 247     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 248
 249     switch(V_VT(&v)) {
 250     case VT_BSTR:
 251         nsAString_InitDepend(&nsstr, V_BSTR(&v));
 252         break;
 253     case VT_I4: {
 254         static const WCHAR formatW[] = {'%','d',0};
 255         sprintfW(buf, formatW, V_I4(&v));
 256         nsAString_InitDepend(&nsstr, buf);
 257         break;
 258     }
 259     default:
 260         FIXME("unsupported arg %s\n", debugstr_variant(&v));
 261         return E_NOTIMPL;
 262     }
 263
 264     nsres = nsIDOMHTMLTableElement_SetCellSpacing(This->nstable, &nsstr);
 265     nsAString_Finish(&nsstr);
 266     if(NS_FAILED(nsres)) {
 267         ERR("SetCellSpacing failed: %08x\n", nsres);
 268         return E_FAIL;
 269     }
 270
 271     return S_OK;
 272 }
 273
 274 static HRESULT WINAPI HTMLTable_get_cellSpacing(IHTMLTable *iface, VARIANT *p)
 275 {
 276     HTMLTable *This = impl_from_IHTMLTable(iface);
 277     nsAString nsstr;
 278     nsresult nsres;
 279
 280     TRACE("(%p)->(%p)\n", This, p);
 281
 282     nsAString_Init(&nsstr, NULL);
 283     nsres = nsIDOMHTMLTableElement_GetCellSpacing(This->nstable, &nsstr);
 284     V_VT(p) = VT_BSTR;
 285     return return_nsstr(nsres, &nsstr, &V_BSTR(p));
 286 }
 287
 288 static HRESULT WINAPI HTMLTable_put_cellPadding(IHTMLTable *iface, VARIANT v)
 289 {
 290     HTMLTable *This = impl_from_IHTMLTable(iface);
 291     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 292     return E_NOTIMPL;
 293 }
 294
 295 static HRESULT WINAPI HTMLTable_get_cellPadding(IHTMLTable *iface, VARIANT *p)
 296 {
 297     HTMLTable *This = impl_from_IHTMLTable(iface);
 298     FIXME("(%p)->(%p)\n", This, p);
 299     return E_NOTIMPL;
 300 }
 301
 302 static HRESULT WINAPI HTMLTable_put_background(IHTMLTable *iface, BSTR v)
 303 {
 304     HTMLTable *This = impl_from_IHTMLTable(iface);
 305     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI HTMLTable_get_background(IHTMLTable *iface, BSTR *p)
 310 {
 311     HTMLTable *This = impl_from_IHTMLTable(iface);
 312     FIXME("(%p)->(%p)\n", This, p);
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI HTMLTable_put_bgColor(IHTMLTable *iface, VARIANT v)
 317 {
 318     HTMLTable *This = impl_from_IHTMLTable(iface);
 319     nsAString val;
 320     nsresult nsres;
 321
 322     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 323
 324     if(!variant_to_nscolor(&v, &val))
 325         return S_OK;
 326
 327     nsres = nsIDOMHTMLTableElement_SetBgColor(This->nstable, &val);
 328     nsAString_Finish(&val);
 329     if (NS_FAILED(nsres)){
 330         ERR("Set BgColor(%s) failed!\n", debugstr_variant(&v));
 331         return E_FAIL;
 332     }
 333
 334     return S_OK;
 335 }
 336
 337 static HRESULT WINAPI HTMLTable_get_bgColor(IHTMLTable *iface, VARIANT *p)
 338 {
 339     HTMLTable *This = impl_from_IHTMLTable(iface);
 340     nsAString strColor;
 341     nsresult nsres;
 342     HRESULT hres;
 343     const PRUnichar *color;
 344
 345     TRACE("(%p)->(%p)\n", This, p);
 346
 347     nsAString_Init(&strColor, NULL);
 348     nsres = nsIDOMHTMLTableElement_GetBgColor(This->nstable, &strColor);
 349
 350     if(NS_SUCCEEDED(nsres)) {
 351        nsAString_GetData(&strColor, &color);
 352        V_VT(p) = VT_BSTR;
 353        hres = nscolor_to_str(color, &V_BSTR(p));
 354     }else {
 355        ERR("SetBgColor failed: %08x\n", nsres);
 356        hres = E_FAIL;
 357     }
 358
 359     nsAString_Finish(&strColor);
 360     return hres;
 361 }
 362
 363 static HRESULT WINAPI HTMLTable_put_borderColor(IHTMLTable *iface, VARIANT v)
 364 {
 365     HTMLTable *This = impl_from_IHTMLTable(iface);
 366     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT WINAPI HTMLTable_get_borderColor(IHTMLTable *iface, VARIANT *p)
 371 {
 372     HTMLTable *This = impl_from_IHTMLTable(iface);
 373     FIXME("(%p)->(%p)\n", This, p);
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT WINAPI HTMLTable_put_borderColorLight(IHTMLTable *iface, VARIANT v)
 378 {
 379     HTMLTable *This = impl_from_IHTMLTable(iface);
 380     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 381     return E_NOTIMPL;
 382 }
 383
 384 static HRESULT WINAPI HTMLTable_get_borderColorLight(IHTMLTable *iface, VARIANT *p)
 385 {
 386     HTMLTable *This = impl_from_IHTMLTable(iface);
 387     FIXME("(%p)->(%p)\n", This, p);
 388     return E_NOTIMPL;
 389 }
 390
 391 static HRESULT WINAPI HTMLTable_put_borderColorDark(IHTMLTable *iface, VARIANT v)
 392 {
 393     HTMLTable *This = impl_from_IHTMLTable(iface);
 394     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 395     return E_NOTIMPL;
 396 }
 397
 398 static HRESULT WINAPI HTMLTable_get_borderColorDark(IHTMLTable *iface, VARIANT *p)
 399 {
 400     HTMLTable *This = impl_from_IHTMLTable(iface);
 401     FIXME("(%p)->(%p)\n", This, p);
 402     return E_NOTIMPL;
 403 }
 404
 405 static HRESULT WINAPI HTMLTable_put_align(IHTMLTable *iface, BSTR v)
 406 {
 407     HTMLTable *This = impl_from_IHTMLTable(iface);
 408     nsAString val;
 409     nsresult nsres;
 410
 411     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 412
 413     nsAString_InitDepend(&val, v);
 414
 415     nsres = nsIDOMHTMLTableElement_SetAlign(This->nstable, &val);
 416     nsAString_Finish(&val);
 417     if (NS_FAILED(nsres)){
 418         ERR("Set Align(%s) failed!\n", debugstr_w(v));
 419         return E_FAIL;
 420     }
 421     return S_OK;
 422 }
 423
 424 static HRESULT WINAPI HTMLTable_get_align(IHTMLTable *iface, BSTR *p)
 425 {
 426     HTMLTable *This = impl_from_IHTMLTable(iface);
 427     nsAString val;
 428     nsresult nsres;
 429
 430     TRACE("(%p)->(%p)\n", This, p);
 431
 432     nsAString_Init(&val, NULL);
 433     nsres = nsIDOMHTMLTableElement_GetAlign(This->nstable, &val);
 434
 435     return return_nsstr(nsres, &val, p);
 436 }
 437
 438 static HRESULT WINAPI HTMLTable_refresh(IHTMLTable *iface)
 439 {
 440     HTMLTable *This = impl_from_IHTMLTable(iface);
 441     FIXME("(%p)\n", This);
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI HTMLTable_get_rows(IHTMLTable *iface, IHTMLElementCollection **p)
 446 {
 447     HTMLTable *This = impl_from_IHTMLTable(iface);
 448     nsIDOMHTMLCollection *nscol;
 449     nsresult nsres;
 450
 451     TRACE("(%p)->(%p)\n", This, p);
 452
 453     nsres = nsIDOMHTMLTableElement_GetRows(This->nstable, &nscol);
 454     if(NS_FAILED(nsres)) {
 455         ERR("GetRows failed: %08x\n", nsres);
 456         return E_FAIL;
 457     }
 458
 459     *p = create_collection_from_htmlcol(This->element.node.doc, nscol);
 460
 461     nsIDOMHTMLCollection_Release(nscol);
 462     return S_OK;
 463 }
 464
 465 static HRESULT WINAPI HTMLTable_put_width(IHTMLTable *iface, VARIANT v)
 466 {
 467     HTMLTable *This = impl_from_IHTMLTable(iface);
 468     nsAString val;
 469     HRESULT hres;
 470     nsresult nsres;
 471
 472     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 473     hres = var2str(&v, &val);
 474
 475     if (FAILED(hres)){
 476         ERR("Set Width(%s) failed when initializing a nsAString, err = %08x\n",
 477             debugstr_variant(&v), hres);
 478         return hres;
 479     }
 480
 481     nsres = nsIDOMHTMLTableElement_SetWidth(This->nstable, &val);
 482     nsAString_Finish(&val);
 483
 484     if (NS_FAILED(nsres)){
 485         ERR("Set Width(%s) failed, err = %08x\n", debugstr_variant(&v), nsres);
 486         return E_FAIL;
 487     }
 488     return S_OK;
 489 }
 490
 491 static HRESULT WINAPI HTMLTable_get_width(IHTMLTable *iface, VARIANT *p)
 492 {
 493     HTMLTable *This = impl_from_IHTMLTable(iface);
 494     nsAString val;
 495     BSTR bstr;
 496     nsresult nsres;
 497     HRESULT hres;
 498
 499     TRACE("(%p)->(%p)\n", This, p);
 500     nsAString_Init(&val, NULL);
 501     nsres = nsIDOMHTMLTableElement_GetWidth(This->nstable, &val);
 502     if (NS_FAILED(nsres)){
 503         ERR("Get Width failed!\n");
 504         nsAString_Finish(&val);
 505         return E_FAIL;
 506     }
 507
 508     hres = nsstr_to_truncated_bstr(&val, &bstr);
 509     nsAString_Finish(&val);
 510
 511     V_VT(p) = VT_BSTR;
 512     V_BSTR(p) = bstr;
 513     return hres;
 514 }
 515
 516 static HRESULT WINAPI HTMLTable_put_height(IHTMLTable *iface, VARIANT v)
 517 {
 518     HTMLTable *This = impl_from_IHTMLTable(iface);
 519     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 520     return E_NOTIMPL;
 521 }
 522
 523 static HRESULT WINAPI HTMLTable_get_height(IHTMLTable *iface, VARIANT *p)
 524 {
 525     HTMLTable *This = impl_from_IHTMLTable(iface);
 526     FIXME("(%p)->(%p)\n", This, p);
 527     return E_NOTIMPL;
 528 }
 529
 530 static HRESULT WINAPI HTMLTable_put_dataPageSize(IHTMLTable *iface, LONG v)
 531 {
 532     HTMLTable *This = impl_from_IHTMLTable(iface);
 533     FIXME("(%p)->(%d)\n", This, v);
 534     return E_NOTIMPL;
 535 }
 536
 537 static HRESULT WINAPI HTMLTable_get_dataPageSize(IHTMLTable *iface, LONG *p)
 538 {
 539     HTMLTable *This = impl_from_IHTMLTable(iface);
 540     FIXME("(%p)->(%p)\n", This, p);
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI HTMLTable_nextPage(IHTMLTable *iface)
 545 {
 546     HTMLTable *This = impl_from_IHTMLTable(iface);
 547     FIXME("(%p)\n", This);
 548     return E_NOTIMPL;
 549 }
 550
 551 static HRESULT WINAPI HTMLTable_previousPage(IHTMLTable *iface)
 552 {
 553     HTMLTable *This = impl_from_IHTMLTable(iface);
 554     FIXME("(%p)\n", This);
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI HTMLTable_get_tHead(IHTMLTable *iface, IHTMLTableSection **p)
 559 {
 560     HTMLTable *This = impl_from_IHTMLTable(iface);
 561     FIXME("(%p)->(%p)\n", This, p);
 562     return E_NOTIMPL;
 563 }
 564
 565 static HRESULT WINAPI HTMLTable_get_tFoot(IHTMLTable *iface, IHTMLTableSection **p)
 566 {
 567     HTMLTable *This = impl_from_IHTMLTable(iface);
 568     FIXME("(%p)->(%p)\n", This, p);
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI HTMLTable_get_tBodies(IHTMLTable *iface, IHTMLElementCollection **p)
 573 {
 574     HTMLTable *This = impl_from_IHTMLTable(iface);
 575     nsIDOMHTMLCollection *nscol = NULL;
 576     nsresult nsres;
 577
 578     TRACE("(%p)->(%p)\n", This, p);
 579
 580     nsres = nsIDOMHTMLTableElement_GetTBodies(This->nstable, &nscol);
 581     if(NS_FAILED(nsres)) {
 582         ERR("GetTBodies failed: %08x\n", nsres);
 583         return E_FAIL;
 584     }
 585
 586     *p = create_collection_from_htmlcol(This->element.node.doc, nscol);
 587
 588     nsIDOMHTMLCollection_Release(nscol);
 589     return S_OK;
 590 }
 591
 592 static HRESULT WINAPI HTMLTable_get_caption(IHTMLTable *iface, IHTMLTableCaption **p)
 593 {
 594     HTMLTable *This = impl_from_IHTMLTable(iface);
 595     FIXME("(%p)->(%p)\n", This, p);
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI HTMLTable_createTHead(IHTMLTable *iface, IDispatch **head)
 600 {
 601     HTMLTable *This = impl_from_IHTMLTable(iface);
 602     FIXME("(%p)->(%p)\n", This, head);
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI HTMLTable_deleteTHead(IHTMLTable *iface)
 607 {
 608     HTMLTable *This = impl_from_IHTMLTable(iface);
 609     FIXME("(%p)\n", This);
 610     return E_NOTIMPL;
 611 }
 612
 613 static HRESULT WINAPI HTMLTable_createTFoot(IHTMLTable *iface, IDispatch **foot)
 614 {
 615     HTMLTable *This = impl_from_IHTMLTable(iface);
 616     FIXME("(%p)->(%p)\n", This, foot);
 617     return E_NOTIMPL;
 618 }
 619
 620 static HRESULT WINAPI HTMLTable_deleteTFoot(IHTMLTable *iface)
 621 {
 622     HTMLTable *This = impl_from_IHTMLTable(iface);
 623     FIXME("(%p)\n", This);
 624     return E_NOTIMPL;
 625 }
 626
 627 static HRESULT WINAPI HTMLTable_createCaption(IHTMLTable *iface, IHTMLTableCaption **caption)
 628 {
 629     HTMLTable *This = impl_from_IHTMLTable(iface);
 630     FIXME("(%p)->(%p)\n", This, caption);
 631     return E_NOTIMPL;
 632 }
 633
 634 static HRESULT WINAPI HTMLTable_deleteCaption(IHTMLTable *iface)
 635 {
 636     HTMLTable *This = impl_from_IHTMLTable(iface);
 637     FIXME("(%p)\n", This);
 638     return E_NOTIMPL;
 639 }
 640
 641 static HRESULT WINAPI HTMLTable_insertRow(IHTMLTable *iface, LONG index, IDispatch **row)
 642 {
 643     HTMLTable *This = impl_from_IHTMLTable(iface);
 644     nsIDOMHTMLElement *nselem;
 645     HTMLElement *elem;
 646     nsresult nsres;
 647     HRESULT hres;
 648
 649     TRACE("(%p)->(%d %p)\n", This, index, row);
 650     nsres = nsIDOMHTMLTableElement_InsertRow(This->nstable, index, &nselem);
 651     if(NS_FAILED(nsres)) {
 652         ERR("Insert Row at %d failed: %08x\n", index, nsres);
 653         return E_FAIL;
 654     }
 655
 656     hres = HTMLTableRow_Create(This->element.node.doc, nselem, &elem);
 657     nsIDOMHTMLElement_Release(nselem);
 658     if (FAILED(hres)) {
 659         ERR("Create TableRow failed: %08x\n", hres);
 660         return hres;
 661     }
 662
 663     *row = (IDispatch *)&elem->IHTMLElement_iface;
 664     return S_OK;
 665 }
 666
 667 static HRESULT WINAPI HTMLTable_deleteRow(IHTMLTable *iface, LONG index)
 668 {
 669     HTMLTable *This = impl_from_IHTMLTable(iface);
 670     nsresult nsres;
 671
 672     TRACE("(%p)->(%d)\n", This, index);
 673     nsres = nsIDOMHTMLTableElement_DeleteRow(This->nstable, index);
 674     if(NS_FAILED(nsres)) {
 675         ERR("Delete Row failed: %08x\n", nsres);
 676         return E_FAIL;
 677     }
 678     return S_OK;
 679 }
 680
 681 static HRESULT WINAPI HTMLTable_get_readyState(IHTMLTable *iface, BSTR *p)
 682 {
 683     HTMLTable *This = impl_from_IHTMLTable(iface);
 684     FIXME("(%p)->(%p)\n", This, p);
 685     return E_NOTIMPL;
 686 }
 687
 688 static HRESULT WINAPI HTMLTable_put_onreadystatechange(IHTMLTable *iface, VARIANT v)
 689 {
 690     HTMLTable *This = impl_from_IHTMLTable(iface);
 691     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI HTMLTable_get_onreadystatechange(IHTMLTable *iface, VARIANT *p)
 696 {
 697     HTMLTable *This = impl_from_IHTMLTable(iface);
 698     FIXME("(%p)->(%p)\n", This, p);
 699     return E_NOTIMPL;
 700 }
 701
 702 static const IHTMLTableVtbl HTMLTableVtbl = {
 703     HTMLTable_QueryInterface,
 704     HTMLTable_AddRef,
 705     HTMLTable_Release,
 706     HTMLTable_GetTypeInfoCount,
 707     HTMLTable_GetTypeInfo,
 708     HTMLTable_GetIDsOfNames,
 709     HTMLTable_Invoke,
 710     HTMLTable_put_cols,
 711     HTMLTable_get_cols,
 712     HTMLTable_put_border,
 713     HTMLTable_get_border,
 714     HTMLTable_put_frame,
 715     HTMLTable_get_frame,
 716     HTMLTable_put_rules,
 717     HTMLTable_get_rules,
 718     HTMLTable_put_cellSpacing,
 719     HTMLTable_get_cellSpacing,
 720     HTMLTable_put_cellPadding,
 721     HTMLTable_get_cellPadding,
 722     HTMLTable_put_background,
 723     HTMLTable_get_background,
 724     HTMLTable_put_bgColor,
 725     HTMLTable_get_bgColor,
 726     HTMLTable_put_borderColor,
 727     HTMLTable_get_borderColor,
 728     HTMLTable_put_borderColorLight,
 729     HTMLTable_get_borderColorLight,
 730     HTMLTable_put_borderColorDark,
 731     HTMLTable_get_borderColorDark,
 732     HTMLTable_put_align,
 733     HTMLTable_get_align,
 734     HTMLTable_refresh,
 735     HTMLTable_get_rows,
 736     HTMLTable_put_width,
 737     HTMLTable_get_width,
 738     HTMLTable_put_height,
 739     HTMLTable_get_height,
 740     HTMLTable_put_dataPageSize,
 741     HTMLTable_get_dataPageSize,
 742     HTMLTable_nextPage,
 743     HTMLTable_previousPage,
 744     HTMLTable_get_tHead,
 745     HTMLTable_get_tFoot,
 746     HTMLTable_get_tBodies,
 747     HTMLTable_get_caption,
 748     HTMLTable_createTHead,
 749     HTMLTable_deleteTHead,
 750     HTMLTable_createTFoot,
 751     HTMLTable_deleteTFoot,
 752     HTMLTable_createCaption,
 753     HTMLTable_deleteCaption,
 754     HTMLTable_insertRow,
 755     HTMLTable_deleteRow,
 756     HTMLTable_get_readyState,
 757     HTMLTable_put_onreadystatechange,
 758     HTMLTable_get_onreadystatechange
 759 };
 760
 761 /* IHTMLTable2 */
 762 static HRESULT WINAPI HTMLTable2_QueryInterface(IHTMLTable2 *iface,
 763                                                          REFIID riid, void **ppv)
 764 {
 765     HTMLTable *This = impl_from_IHTMLTable2(iface);
 766
 767     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 768 }
 769
 770 static ULONG WINAPI HTMLTable2_AddRef(IHTMLTable2 *iface)
 771 {
 772     HTMLTable *This = impl_from_IHTMLTable2(iface);
 773
 774     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 775 }
 776
 777 static ULONG WINAPI HTMLTable2_Release(IHTMLTable2 *iface)
 778 {
 779     HTMLTable *This = impl_from_IHTMLTable2(iface);
 780
 781     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 782 }
 783
 784 static HRESULT WINAPI HTMLTable2_GetTypeInfoCount(IHTMLTable2 *iface, UINT *pctinfo)
 785 {
 786     HTMLTable *This = impl_from_IHTMLTable2(iface);
 787     return IDispatchEx_GetTypeInfoCount(&This->element.node.dispex.IDispatchEx_iface, pctinfo);
 788 }
 789
 790 static HRESULT WINAPI HTMLTable2_GetTypeInfo(IHTMLTable2 *iface, UINT iTInfo,
 791                                               LCID lcid, ITypeInfo **ppTInfo)
 792 {
 793     HTMLTable *This = impl_from_IHTMLTable2(iface);
 794     return IDispatchEx_GetTypeInfo(&This->element.node.dispex.IDispatchEx_iface, iTInfo, lcid,
 795             ppTInfo);
 796 }
 797
 798 static HRESULT WINAPI HTMLTable2_GetIDsOfNames(IHTMLTable2 *iface, REFIID riid,
 799                                                 LPOLESTR *rgszNames, UINT cNames,
 800                                                 LCID lcid, DISPID *rgDispId)
 801 {
 802     HTMLTable *This = impl_from_IHTMLTable2(iface);
 803     return IDispatchEx_GetIDsOfNames(&This->element.node.dispex.IDispatchEx_iface, riid, rgszNames,
 804             cNames, lcid, rgDispId);
 805 }
 806
 807 static HRESULT WINAPI HTMLTable2_Invoke(IHTMLTable2 *iface, DISPID dispIdMember,
 808                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 809                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 810 {
 811     HTMLTable *This = impl_from_IHTMLTable2(iface);
 812     return IDispatchEx_Invoke(&This->element.node.dispex.IDispatchEx_iface, dispIdMember, riid,
 813             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 814 }
 815
 816 static HRESULT WINAPI HTMLTable2_firstPage(IHTMLTable2 *iface)
 817 {
 818     HTMLTable *This = impl_from_IHTMLTable2(iface);
 819     FIXME("(%p)->()\n", This);
 820     return E_NOTIMPL;
 821 }
 822
 823 static HRESULT WINAPI HTMLTable2_lastPage(IHTMLTable2 *iface)
 824 {
 825     HTMLTable *This = impl_from_IHTMLTable2(iface);
 826     FIXME("(%p)->()\n", This);
 827     return E_NOTIMPL;
 828 }
 829
 830 static HRESULT WINAPI HTMLTable2_cells(IHTMLTable2 *iface, IHTMLElementCollection **p)
 831 {
 832     HTMLTable *This = impl_from_IHTMLTable2(iface);
 833     FIXME("(%p)->(%p)\n", This, p);
 834     return E_NOTIMPL;
 835 }
 836
 837 static HRESULT WINAPI HTMLTable2_moveRow(IHTMLTable2 *iface, LONG indexFrom, LONG indexTo, IDispatch **row)
 838 {
 839     HTMLTable *This = impl_from_IHTMLTable2(iface);
 840     FIXME("(%p)->(%d %d %p)\n", This, indexFrom, indexTo, row);
 841     return E_NOTIMPL;
 842 }
 843
 844
 845 static const IHTMLTable2Vtbl HTMLTable2Vtbl = {
 846     HTMLTable2_QueryInterface,
 847     HTMLTable2_AddRef,
 848     HTMLTable2_Release,
 849     HTMLTable2_GetTypeInfoCount,
 850     HTMLTable2_GetTypeInfo,
 851     HTMLTable2_GetIDsOfNames,
 852     HTMLTable2_Invoke,
 853     HTMLTable2_firstPage,
 854     HTMLTable2_lastPage,
 855     HTMLTable2_cells,
 856     HTMLTable2_moveRow
 857 };
 858
 859 /* IHTMLTable3 */
 860 static HRESULT WINAPI HTMLTable3_QueryInterface(IHTMLTable3 *iface,
 861                                                          REFIID riid, void **ppv)
 862 {
 863     HTMLTable *This = impl_from_IHTMLTable3(iface);
 864
 865     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 866 }
 867
 868 static ULONG WINAPI HTMLTable3_AddRef(IHTMLTable3 *iface)
 869 {
 870     HTMLTable *This = impl_from_IHTMLTable3(iface);
 871
 872     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 873 }
 874
 875 static ULONG WINAPI HTMLTable3_Release(IHTMLTable3 *iface)
 876 {
 877     HTMLTable *This = impl_from_IHTMLTable3(iface);
 878
 879     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 880 }
 881
 882 static HRESULT WINAPI HTMLTable3_GetTypeInfoCount(IHTMLTable3 *iface, UINT *pctinfo)
 883 {
 884     HTMLTable *This = impl_from_IHTMLTable3(iface);
 885     return IDispatchEx_GetTypeInfoCount(&This->element.node.dispex.IDispatchEx_iface, pctinfo);
 886 }
 887
 888 static HRESULT WINAPI HTMLTable3_GetTypeInfo(IHTMLTable3 *iface, UINT iTInfo,
 889                                               LCID lcid, ITypeInfo **ppTInfo)
 890 {
 891     HTMLTable *This = impl_from_IHTMLTable3(iface);
 892     return IDispatchEx_GetTypeInfo(&This->element.node.dispex.IDispatchEx_iface, iTInfo, lcid,
 893             ppTInfo);
 894 }
 895
 896 static HRESULT WINAPI HTMLTable3_GetIDsOfNames(IHTMLTable3 *iface, REFIID riid,
 897                                                 LPOLESTR *rgszNames, UINT cNames,
 898                                                 LCID lcid, DISPID *rgDispId)
 899 {
 900     HTMLTable *This = impl_from_IHTMLTable3(iface);
 901     return IDispatchEx_GetIDsOfNames(&This->element.node.dispex.IDispatchEx_iface, riid, rgszNames,
 902             cNames, lcid, rgDispId);
 903 }
 904
 905 static HRESULT WINAPI HTMLTable3_Invoke(IHTMLTable3 *iface, DISPID dispIdMember,
 906                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 907                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 908 {
 909     HTMLTable *This = impl_from_IHTMLTable3(iface);
 910     return IDispatchEx_Invoke(&This->element.node.dispex.IDispatchEx_iface, dispIdMember, riid,
 911             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 912 }
 913
 914 static HRESULT WINAPI HTMLTable3_put_summary(IHTMLTable3 *iface, BSTR v)
 915 {
 916     HTMLTable *This = impl_from_IHTMLTable3(iface);
 917     nsAString str;
 918     nsresult nsres;
 919
 920     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 921
 922     nsAString_InitDepend(&str, v);
 923
 924     nsres = nsIDOMHTMLTableElement_SetSummary(This->nstable, &str);
 925
 926     nsAString_Finish(&str);
 927     if (NS_FAILED(nsres)) {
 928         ERR("Set summary(%s) failed: %08x\n", debugstr_w(v), nsres);
 929         return E_FAIL;
 930     }
 931     return S_OK;
 932 }
 933
 934 static HRESULT WINAPI HTMLTable3_get_summary(IHTMLTable3 *iface, BSTR * p)
 935 {
 936     HTMLTable *This = impl_from_IHTMLTable3(iface);
 937     nsAString str;
 938     nsresult nsres;
 939
 940     TRACE("(%p)->(%p)\n", This, p);
 941
 942     nsAString_Init(&str, NULL);
 943     nsres = nsIDOMHTMLTableElement_GetSummary(This->nstable, &str);
 944
 945     return return_nsstr(nsres, &str, p);
 946 }
 947
 948 static const IHTMLTable3Vtbl HTMLTable3Vtbl = {
 949     HTMLTable3_QueryInterface,
 950     HTMLTable3_AddRef,
 951     HTMLTable3_Release,
 952     HTMLTable3_GetTypeInfoCount,
 953     HTMLTable3_GetTypeInfo,
 954     HTMLTable3_GetIDsOfNames,
 955     HTMLTable3_Invoke,
 956     HTMLTable3_put_summary,
 957     HTMLTable3_get_summary
 958 };
 959
 960 static inline HTMLTable *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
 961 {
 962     return CONTAINING_RECORD(iface, HTMLTable, element.node);
 963 }
 964
 965 static HRESULT HTMLTable_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 966 {
 967     HTMLTable *This = impl_from_HTMLDOMNode(iface);
 968
 969     *ppv = NULL;
 970
 971     if(IsEqualGUID(&IID_IUnknown, riid)) {
 972         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 973         *ppv = &This->IHTMLTable_iface;
 974     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 975         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 976         *ppv = &This->IHTMLTable_iface;
 977     }else if(IsEqualGUID(&IID_IHTMLTable, riid)) {
 978         TRACE("(%p)->(IID_IHTMLTable %p)\n", This, ppv);
 979         *ppv = &This->IHTMLTable_iface;
 980     }else if(IsEqualGUID(&IID_IHTMLTable2, riid)) {
 981         TRACE("(%p)->(IID_IHTMLTable2 %p)\n", This, ppv);
 982         *ppv = &This->IHTMLTable2_iface;
 983     }else if(IsEqualGUID(&IID_IHTMLTable3, riid)) {
 984         TRACE("(%p)->(IID_IHTMLTable3 %p)\n", This, ppv);
 985         *ppv = &This->IHTMLTable3_iface;
 986     }
 987
 988     if(*ppv) {
 989         IUnknown_AddRef((IUnknown*)*ppv);
 990         return S_OK;
 991     }
 992
 993     return HTMLElement_QI(&This->element.node, riid, ppv);
 994 }
 995
 996 static void HTMLTable_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
 997 {
 998     HTMLTable *This = impl_from_HTMLDOMNode(iface);
 999
1000     if(This->nstable)
1001         note_cc_edge((nsISupports*)This->nstable, "This->nstable", cb);
1002 }
1003
1004 static void HTMLTable_unlink(HTMLDOMNode *iface)
1005 {
1006     HTMLTable *This = impl_from_HTMLDOMNode(iface);
1007
1008     if(This->nstable) {
1009         nsIDOMHTMLTableElement *nstable = This->nstable;
1010
1011         This->nstable = NULL;
1012         nsIDOMHTMLTableElement_Release(nstable);
1013     }
1014 }
1015
1016 static const cpc_entry_t HTMLTable_cpc[] = {
1017     {&DIID_HTMLTableEvents},
1018     HTMLELEMENT_CPC,
1019     {NULL}
1020 };
1021
1022 static const NodeImplVtbl HTMLTableImplVtbl = {
1023     HTMLTable_QI,
1024     HTMLElement_destructor,
1025     HTMLTable_cpc,
1026     HTMLElement_clone,
1027     HTMLElement_handle_event,
1028     HTMLElement_get_attr_col,
1029     NULL,
1030     NULL,
1031     NULL,
1032     NULL,
1033     NULL,
1034     NULL,
1035     NULL,
1036     NULL,
1037     NULL,
1038     HTMLTable_traverse,
1039     HTMLTable_unlink
1040 };
1041
1042 static const tid_t HTMLTable_iface_tids[] = {
1043     HTMLELEMENT_TIDS,
1044     IHTMLTable_tid,
1045     IHTMLTable2_tid,
1046     IHTMLTable3_tid,
1047     0
1048 };
1049
1050 static dispex_static_data_t HTMLTable_dispex = {
1051     NULL,
1052     DispHTMLTable_tid,
1053     NULL,
1054     HTMLTable_iface_tids
1055 };
1056
1057 HRESULT HTMLTable_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, HTMLElement **elem)
1058 {
1059     HTMLTable *ret;
1060     nsresult nsres;
1061
1062     ret = heap_alloc_zero(sizeof(HTMLTable));
1063     if(!ret)
1064         return E_OUTOFMEMORY;
1065
1066     ret->element.node.vtbl = &HTMLTableImplVtbl;
1067     ret->IHTMLTable_iface.lpVtbl = &HTMLTableVtbl;
1068     ret->IHTMLTable2_iface.lpVtbl = &HTMLTable2Vtbl;
1069     ret->IHTMLTable3_iface.lpVtbl = &HTMLTable3Vtbl;
1070
1071     HTMLElement_Init(&ret->element, doc, nselem, &HTMLTable_dispex);
1072
1073     nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLTableElement, (void**)&ret->nstable);
1074     assert(nsres == NS_OK);
1075
1076     *elem = &ret->element;
1077     return S_OK;
1078 }