dlls/mshtml/htmlframe.c

   1 /*
   2  * Copyright 2008,2010 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 "mshtml_private.h"
  29 #include "binding.h"
  30 #include "htmlevent.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  35
  36 static HRESULT set_frame_doc(HTMLFrameBase *frame, nsIDOMDocument *nsdoc)
  37 {
  38     mozIDOMWindowProxy *mozwindow;
  39     HTMLOuterWindow *window;
  40     nsresult nsres;
  41     HRESULT hres = S_OK;
  42
  43     if(frame->content_window)
  44         return S_OK;
  45
  46     nsres = nsIDOMDocument_GetDefaultView(nsdoc, &mozwindow);
  47     if(NS_FAILED(nsres) || !mozwindow)
  48         return E_FAIL;
  49
  50     window = mozwindow_to_window(mozwindow);
  51     if(!window && frame->element.node.doc->browser)
  52         hres = create_outer_window(frame->element.node.doc->browser, mozwindow,
  53                 frame->element.node.doc->basedoc.window, &window);
  54     mozIDOMWindowProxy_Release(mozwindow);
  55     if(FAILED(hres))
  56         return hres;
  57
  58     frame->content_window = window;
  59     window->frame_element = frame;
  60     return S_OK;
  61 }
  62
  63 static inline HTMLFrameBase *impl_from_IHTMLFrameBase(IHTMLFrameBase *iface)
  64 {
  65     return CONTAINING_RECORD(iface, HTMLFrameBase, IHTMLFrameBase_iface);
  66 }
  67
  68 static HRESULT WINAPI HTMLFrameBase_QueryInterface(IHTMLFrameBase *iface, REFIID riid, void **ppv)
  69 {
  70     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
  71
  72     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
  73 }
  74
  75 static ULONG WINAPI HTMLFrameBase_AddRef(IHTMLFrameBase *iface)
  76 {
  77     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
  78
  79     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
  80 }
  81
  82 static ULONG WINAPI HTMLFrameBase_Release(IHTMLFrameBase *iface)
  83 {
  84     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
  85
  86     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
  87 }
  88
  89 static HRESULT WINAPI HTMLFrameBase_GetTypeInfoCount(IHTMLFrameBase *iface, UINT *pctinfo)
  90 {
  91     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
  92
  93     return IDispatchEx_GetTypeInfoCount(&This->element.node.event_target.dispex.IDispatchEx_iface, pctinfo);
  94 }
  95
  96 static HRESULT WINAPI HTMLFrameBase_GetTypeInfo(IHTMLFrameBase *iface, UINT iTInfo,
  97         LCID lcid, ITypeInfo **ppTInfo)
  98 {
  99     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 100
 101     return IDispatchEx_GetTypeInfo(&This->element.node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid,
 102             ppTInfo);
 103 }
 104
 105 static HRESULT WINAPI HTMLFrameBase_GetIDsOfNames(IHTMLFrameBase *iface, REFIID riid,
 106         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 107 {
 108     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 109
 110     return IDispatchEx_GetIDsOfNames(&This->element.node.event_target.dispex.IDispatchEx_iface, riid, rgszNames,
 111             cNames, lcid, rgDispId);
 112 }
 113
 114 static HRESULT WINAPI HTMLFrameBase_Invoke(IHTMLFrameBase *iface, DISPID dispIdMember,
 115         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 116         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 117 {
 118     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 119
 120     return IDispatchEx_Invoke(&This->element.node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid,
 121             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 122 }
 123
 124 static HRESULT WINAPI HTMLFrameBase_put_src(IHTMLFrameBase *iface, BSTR v)
 125 {
 126     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 127
 128     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 129
 130     if(!This->content_window || !This->element.node.doc || !This->element.node.doc->basedoc.window) {
 131         nsAString nsstr;
 132         nsresult nsres;
 133
 134         nsAString_InitDepend(&nsstr, v);
 135         if(This->nsframe)
 136             nsres = nsIDOMHTMLFrameElement_SetSrc(This->nsframe, &nsstr);
 137         else
 138             nsres = nsIDOMHTMLIFrameElement_SetSrc(This->nsiframe, &nsstr);
 139         nsAString_Finish(&nsstr);
 140         if(NS_FAILED(nsres)) {
 141             ERR("SetSrc failed: %08x\n", nsres);
 142             return E_FAIL;
 143         }
 144
 145         return S_OK;
 146     }
 147
 148     return navigate_url(This->content_window, v, This->element.node.doc->basedoc.window->uri, BINDING_NAVIGATED);
 149 }
 150
 151 static HRESULT WINAPI HTMLFrameBase_get_src(IHTMLFrameBase *iface, BSTR *p)
 152 {
 153     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 154     nsAString nsstr;
 155     nsresult nsres;
 156
 157     TRACE("(%p)->(%p)\n", This, p);
 158
 159     if(!This->nsframe && !This->nsiframe) {
 160         ERR("No attached frame object\n");
 161         return E_UNEXPECTED;
 162     }
 163
 164     nsAString_Init(&nsstr, NULL);
 165     if(This->nsframe)
 166         nsres = nsIDOMHTMLFrameElement_GetSrc(This->nsframe, &nsstr);
 167     else
 168         nsres = nsIDOMHTMLIFrameElement_GetSrc(This->nsiframe, &nsstr);
 169     return return_nsstr(nsres, &nsstr, p);
 170 }
 171
 172 static HRESULT WINAPI HTMLFrameBase_put_name(IHTMLFrameBase *iface, BSTR v)
 173 {
 174     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 175     nsAString name_str;
 176     nsresult nsres;
 177
 178     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 179
 180     if(!This->nsframe && !This->nsiframe) {
 181         ERR("No attached ns frame object\n");
 182         return E_UNEXPECTED;
 183     }
 184
 185     nsAString_InitDepend(&name_str, v);
 186     if(This->nsframe)
 187         nsres = nsIDOMHTMLFrameElement_SetName(This->nsframe, &name_str);
 188     else
 189         nsres = nsIDOMHTMLIFrameElement_SetName(This->nsiframe, &name_str);
 190     nsAString_Finish(&name_str);
 191     if(NS_FAILED(nsres)) {
 192         ERR("SetName failed: %08x\n", nsres);
 193         return E_FAIL;
 194     }
 195
 196     return S_OK;
 197 }
 198
 199 static HRESULT WINAPI HTMLFrameBase_get_name(IHTMLFrameBase *iface, BSTR *p)
 200 {
 201     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 202     nsAString nsstr;
 203     nsresult nsres;
 204
 205     TRACE("(%p)->(%p)\n", This, p);
 206
 207     if(!This->nsframe && !This->nsiframe) {
 208         ERR("No attached ns frame object\n");
 209         return E_UNEXPECTED;
 210     }
 211
 212     nsAString_Init(&nsstr, NULL);
 213     if(This->nsframe)
 214         nsres = nsIDOMHTMLFrameElement_GetName(This->nsframe, &nsstr);
 215     else
 216         nsres = nsIDOMHTMLIFrameElement_GetName(This->nsiframe, &nsstr);
 217     return return_nsstr(nsres, &nsstr, p);
 218 }
 219
 220 static HRESULT WINAPI HTMLFrameBase_put_border(IHTMLFrameBase *iface, VARIANT v)
 221 {
 222     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 223     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI HTMLFrameBase_get_border(IHTMLFrameBase *iface, VARIANT *p)
 228 {
 229     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 230     FIXME("(%p)->(%p)\n", This, p);
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT WINAPI HTMLFrameBase_put_frameBorder(IHTMLFrameBase *iface, BSTR v)
 235 {
 236     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 237     nsAString nsstr;
 238     nsresult nsres;
 239
 240     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 241
 242     if(!This->nsframe && !This->nsiframe) {
 243         ERR("No attached ns frame object\n");
 244         return E_UNEXPECTED;
 245     }
 246
 247     nsAString_InitDepend(&nsstr, v);
 248     if(This->nsframe)
 249         nsres = nsIDOMHTMLFrameElement_SetFrameBorder(This->nsframe, &nsstr);
 250     else
 251         nsres = nsIDOMHTMLIFrameElement_SetFrameBorder(This->nsiframe, &nsstr);
 252     nsAString_Finish(&nsstr);
 253     if(NS_FAILED(nsres)) {
 254         ERR("SetFrameBorder failed: %08x\n", nsres);
 255         return E_FAIL;
 256     }
 257
 258     return S_OK;
 259 }
 260
 261 static HRESULT WINAPI HTMLFrameBase_get_frameBorder(IHTMLFrameBase *iface, BSTR *p)
 262 {
 263     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 264     nsAString nsstr;
 265     nsresult nsres;
 266
 267     TRACE("(%p)->(%p)\n", This, p);
 268
 269     if(!This->nsframe && !This->nsiframe) {
 270         ERR("No attached ns frame object\n");
 271         return E_UNEXPECTED;
 272     }
 273
 274     nsAString_Init(&nsstr, NULL);
 275     if(This->nsframe)
 276         nsres = nsIDOMHTMLFrameElement_GetFrameBorder(This->nsframe, &nsstr);
 277     else
 278         nsres = nsIDOMHTMLIFrameElement_GetFrameBorder(This->nsiframe, &nsstr);
 279     return return_nsstr(nsres, &nsstr, p);
 280 }
 281
 282 static HRESULT WINAPI HTMLFrameBase_put_frameSpacing(IHTMLFrameBase *iface, VARIANT v)
 283 {
 284     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 285     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 286     return E_NOTIMPL;
 287 }
 288
 289 static HRESULT WINAPI HTMLFrameBase_get_frameSpacing(IHTMLFrameBase *iface, VARIANT *p)
 290 {
 291     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 292     FIXME("(%p)->(%p)\n", This, p);
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI HTMLFrameBase_put_marginWidth(IHTMLFrameBase *iface, VARIANT v)
 297 {
 298     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 299     nsAString nsstr;
 300     nsresult nsres;
 301
 302     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 303
 304     if(V_VT(&v) != VT_BSTR) {
 305         FIXME("unsupported %s\n", debugstr_variant(&v));
 306         return E_NOTIMPL;
 307     }
 308
 309     nsAString_InitDepend(&nsstr, V_BSTR(&v));
 310     if(This->nsframe)
 311         nsres = nsIDOMHTMLFrameElement_SetMarginWidth(This->nsframe, &nsstr);
 312     else
 313         nsres = nsIDOMHTMLIFrameElement_SetMarginWidth(This->nsiframe, &nsstr);
 314     nsAString_Finish(&nsstr);
 315     return NS_SUCCEEDED(nsres) ? S_OK : E_FAIL;
 316 }
 317
 318 static HRESULT WINAPI HTMLFrameBase_get_marginWidth(IHTMLFrameBase *iface, VARIANT *p)
 319 {
 320     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 321     nsAString nsstr;
 322     nsresult nsres;
 323     HRESULT hres = S_OK;
 324
 325     TRACE("(%p)->(%p)\n", This, p);
 326
 327     nsAString_Init(&nsstr, NULL);
 328     if(This->nsframe)
 329         nsres = nsIDOMHTMLFrameElement_GetMarginWidth(This->nsframe, &nsstr);
 330     else
 331         nsres = nsIDOMHTMLIFrameElement_GetMarginWidth(This->nsiframe, &nsstr);
 332     if(NS_SUCCEEDED(nsres)) {
 333         const PRUnichar *str, *end;
 334
 335         nsAString_GetData(&nsstr, &str);
 336
 337         if(*str) {
 338             BSTR ret;
 339
 340             end = wcsstr(str, L"px");
 341             if(!end)
 342                 end = str+lstrlenW(str);
 343             ret = SysAllocStringLen(str, end-str);
 344             if(ret) {
 345                 V_VT(p) = VT_BSTR;
 346                 V_BSTR(p) = ret;
 347             }else {
 348                 hres = E_OUTOFMEMORY;
 349             }
 350         }else {
 351             V_VT(p) = VT_BSTR;
 352             V_BSTR(p) = NULL;
 353         }
 354     }else {
 355         ERR("GetMarginWidth failed: %08x\n", nsres);
 356         hres = E_FAIL;
 357     }
 358
 359     nsAString_Finish(&nsstr);
 360     return hres;
 361 }
 362
 363 static HRESULT WINAPI HTMLFrameBase_put_marginHeight(IHTMLFrameBase *iface, VARIANT v)
 364 {
 365     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 366     nsAString nsstr;
 367     nsresult nsres;
 368
 369     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 370
 371     if(V_VT(&v) != VT_BSTR) {
 372         FIXME("unsupported %s\n", debugstr_variant(&v));
 373         return E_NOTIMPL;
 374     }
 375
 376     nsAString_InitDepend(&nsstr, V_BSTR(&v));
 377     if(This->nsframe)
 378         nsres = nsIDOMHTMLFrameElement_SetMarginHeight(This->nsframe, &nsstr);
 379     else
 380         nsres = nsIDOMHTMLIFrameElement_SetMarginHeight(This->nsiframe, &nsstr);
 381     nsAString_Finish(&nsstr);
 382     return NS_SUCCEEDED(nsres) ? S_OK : E_FAIL;
 383 }
 384
 385 static HRESULT WINAPI HTMLFrameBase_get_marginHeight(IHTMLFrameBase *iface, VARIANT *p)
 386 {
 387     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 388     nsAString nsstr;
 389     nsresult nsres;
 390     HRESULT hres = S_OK;
 391
 392     TRACE("(%p)->(%p)\n", This, p);
 393
 394     nsAString_Init(&nsstr, NULL);
 395     if(This->nsframe)
 396         nsres = nsIDOMHTMLFrameElement_GetMarginHeight(This->nsframe, &nsstr);
 397     else
 398         nsres = nsIDOMHTMLIFrameElement_GetMarginHeight(This->nsiframe, &nsstr);
 399     if(NS_SUCCEEDED(nsres)) {
 400         const PRUnichar *str, *end;
 401
 402         nsAString_GetData(&nsstr, &str);
 403
 404         if(*str) {
 405             BSTR ret;
 406
 407             end = wcsstr(str, L"px");
 408             if(!end)
 409                 end = str+lstrlenW(str);
 410             ret = SysAllocStringLen(str, end-str);
 411             if(ret) {
 412                 V_VT(p) = VT_BSTR;
 413                 V_BSTR(p) = ret;
 414             }else {
 415                 hres = E_OUTOFMEMORY;
 416             }
 417         }else {
 418             V_VT(p) = VT_BSTR;
 419             V_BSTR(p) = NULL;
 420         }
 421     }else {
 422         ERR("SetMarginHeight failed: %08x\n", nsres);
 423         hres = E_FAIL;
 424     }
 425
 426     nsAString_Finish(&nsstr);
 427     return hres;
 428 }
 429
 430 static HRESULT WINAPI HTMLFrameBase_put_noResize(IHTMLFrameBase *iface, VARIANT_BOOL v)
 431 {
 432     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 433     FIXME("(%p)->(%x)\n", This, v);
 434     return E_NOTIMPL;
 435 }
 436
 437 static HRESULT WINAPI HTMLFrameBase_get_noResize(IHTMLFrameBase *iface, VARIANT_BOOL *p)
 438 {
 439     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 440     FIXME("(%p)->(%p)\n", This, p);
 441     return E_NOTIMPL;
 442 }
 443
 444 static HRESULT WINAPI HTMLFrameBase_put_scrolling(IHTMLFrameBase *iface, BSTR v)
 445 {
 446     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 447     nsAString nsstr;
 448     nsresult nsres;
 449
 450     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 451
 452     if(!(!wcsicmp(v, L"yes") || !wcsicmp(v, L"no") || !wcsicmp(v, L"auto")))
 453         return E_INVALIDARG;
 454
 455     if(This->nsframe) {
 456         nsAString_InitDepend(&nsstr, v);
 457         nsres = nsIDOMHTMLFrameElement_SetScrolling(This->nsframe, &nsstr);
 458     }else if(This->nsiframe) {
 459         nsAString_InitDepend(&nsstr, v);
 460         nsres = nsIDOMHTMLIFrameElement_SetScrolling(This->nsiframe, &nsstr);
 461     }else {
 462         ERR("No attached ns frame object\n");
 463         return E_UNEXPECTED;
 464     }
 465     nsAString_Finish(&nsstr);
 466
 467     if(NS_FAILED(nsres)) {
 468         ERR("SetScrolling failed: 0x%08x\n", nsres);
 469         return E_FAIL;
 470     }
 471
 472     return S_OK;
 473 }
 474
 475 static HRESULT WINAPI HTMLFrameBase_get_scrolling(IHTMLFrameBase *iface, BSTR *p)
 476 {
 477     HTMLFrameBase *This = impl_from_IHTMLFrameBase(iface);
 478     nsAString nsstr;
 479     const PRUnichar *strdata;
 480     nsresult nsres;
 481
 482     TRACE("(%p)->(%p)\n", This, p);
 483
 484     if(This->nsframe) {
 485         nsAString_Init(&nsstr, NULL);
 486         nsres = nsIDOMHTMLFrameElement_GetScrolling(This->nsframe, &nsstr);
 487     }else if(This->nsiframe) {
 488         nsAString_Init(&nsstr, NULL);
 489         nsres = nsIDOMHTMLIFrameElement_GetScrolling(This->nsiframe, &nsstr);
 490     }else {
 491         ERR("No attached ns frame object\n");
 492         return E_UNEXPECTED;
 493     }
 494
 495     if(NS_FAILED(nsres)) {
 496         ERR("GetScrolling failed: 0x%08x\n", nsres);
 497         nsAString_Finish(&nsstr);
 498         return E_FAIL;
 499     }
 500
 501     nsAString_GetData(&nsstr, &strdata);
 502
 503     if(*strdata)
 504         *p = SysAllocString(strdata);
 505     else
 506         *p = SysAllocString(L"auto");
 507
 508     nsAString_Finish(&nsstr);
 509
 510     return *p ? S_OK : E_OUTOFMEMORY;
 511 }
 512
 513 static const IHTMLFrameBaseVtbl HTMLFrameBaseVtbl = {
 514     HTMLFrameBase_QueryInterface,
 515     HTMLFrameBase_AddRef,
 516     HTMLFrameBase_Release,
 517     HTMLFrameBase_GetTypeInfoCount,
 518     HTMLFrameBase_GetTypeInfo,
 519     HTMLFrameBase_GetIDsOfNames,
 520     HTMLFrameBase_Invoke,
 521     HTMLFrameBase_put_src,
 522     HTMLFrameBase_get_src,
 523     HTMLFrameBase_put_name,
 524     HTMLFrameBase_get_name,
 525     HTMLFrameBase_put_border,
 526     HTMLFrameBase_get_border,
 527     HTMLFrameBase_put_frameBorder,
 528     HTMLFrameBase_get_frameBorder,
 529     HTMLFrameBase_put_frameSpacing,
 530     HTMLFrameBase_get_frameSpacing,
 531     HTMLFrameBase_put_marginWidth,
 532     HTMLFrameBase_get_marginWidth,
 533     HTMLFrameBase_put_marginHeight,
 534     HTMLFrameBase_get_marginHeight,
 535     HTMLFrameBase_put_noResize,
 536     HTMLFrameBase_get_noResize,
 537     HTMLFrameBase_put_scrolling,
 538     HTMLFrameBase_get_scrolling
 539 };
 540
 541 static inline HTMLFrameBase *impl_from_IHTMLFrameBase2(IHTMLFrameBase2 *iface)
 542 {
 543     return CONTAINING_RECORD(iface, HTMLFrameBase, IHTMLFrameBase2_iface);
 544 }
 545
 546 static HRESULT WINAPI HTMLFrameBase2_QueryInterface(IHTMLFrameBase2 *iface, REFIID riid, void **ppv)
 547 {
 548     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 549
 550     return IHTMLDOMNode_QueryInterface(&This->element.node.IHTMLDOMNode_iface, riid, ppv);
 551 }
 552
 553 static ULONG WINAPI HTMLFrameBase2_AddRef(IHTMLFrameBase2 *iface)
 554 {
 555     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 556
 557     return IHTMLDOMNode_AddRef(&This->element.node.IHTMLDOMNode_iface);
 558 }
 559
 560 static ULONG WINAPI HTMLFrameBase2_Release(IHTMLFrameBase2 *iface)
 561 {
 562     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 563
 564     return IHTMLDOMNode_Release(&This->element.node.IHTMLDOMNode_iface);
 565 }
 566
 567 static HRESULT WINAPI HTMLFrameBase2_GetTypeInfoCount(IHTMLFrameBase2 *iface, UINT *pctinfo)
 568 {
 569     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 570     FIXME("(%p)\n", This);
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI HTMLFrameBase2_GetTypeInfo(IHTMLFrameBase2 *iface, UINT iTInfo,
 575         LCID lcid, ITypeInfo **ppTInfo)
 576 {
 577     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 578     FIXME("(%p)\n", This);
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI HTMLFrameBase2_GetIDsOfNames(IHTMLFrameBase2 *iface, REFIID riid,
 583         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 584 {
 585     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 586     FIXME("(%p)\n", This);
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI HTMLFrameBase2_Invoke(IHTMLFrameBase2 *iface, DISPID dispIdMember,
 591         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 592         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 593 {
 594     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 595     FIXME("(%p)\n", This);
 596     return E_NOTIMPL;
 597 }
 598
 599 static HRESULT WINAPI HTMLFrameBase2_get_contentWindow(IHTMLFrameBase2 *iface, IHTMLWindow2 **p)
 600 {
 601     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 602
 603     TRACE("(%p)->(%p)\n", This, p);
 604
 605     if(This->content_window) {
 606         IHTMLWindow2_AddRef(&This->content_window->base.IHTMLWindow2_iface);
 607         *p = &This->content_window->base.IHTMLWindow2_iface;
 608     }else {
 609         WARN("NULL content window\n");
 610         *p = NULL;
 611     }
 612     return S_OK;
 613 }
 614
 615 static HRESULT WINAPI HTMLFrameBase2_put_onload(IHTMLFrameBase2 *iface, VARIANT v)
 616 {
 617     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 618
 619     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 620
 621     return set_node_event(&This->element.node, EVENTID_LOAD, &v);
 622 }
 623
 624 static HRESULT WINAPI HTMLFrameBase2_get_onload(IHTMLFrameBase2 *iface, VARIANT *p)
 625 {
 626     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 627
 628     TRACE("(%p)->(%p)\n", This, p);
 629
 630     return get_node_event(&This->element.node, EVENTID_LOAD, p);
 631 }
 632
 633 static HRESULT WINAPI HTMLFrameBase2_put_onreadystatechange(IHTMLFrameBase2 *iface, VARIANT v)
 634 {
 635     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 636     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI HTMLFrameBase2_get_onreadystatechange(IHTMLFrameBase2 *iface, VARIANT *p)
 641 {
 642     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 643     FIXME("(%p)->(%p)\n", This, p);
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI HTMLFrameBase2_get_readyState(IHTMLFrameBase2 *iface, BSTR *p)
 648 {
 649     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 650
 651     TRACE("(%p)->(%p)\n", This, p);
 652
 653     if(!This->content_window || !This->content_window->base.inner_window->doc) {
 654         FIXME("no document associated\n");
 655         return E_FAIL;
 656     }
 657
 658     return IHTMLDocument2_get_readyState(&This->content_window->base.inner_window->doc->basedoc.IHTMLDocument2_iface, p);
 659 }
 660
 661 static HRESULT WINAPI HTMLFrameBase2_put_allowTransparency(IHTMLFrameBase2 *iface, VARIANT_BOOL v)
 662 {
 663     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 664
 665     FIXME("(%p)->(%x) semi-stub\n", This, v);
 666
 667     return S_OK;
 668 }
 669
 670 static HRESULT WINAPI HTMLFrameBase2_get_allowTransparency(IHTMLFrameBase2 *iface, VARIANT_BOOL *p)
 671 {
 672     HTMLFrameBase *This = impl_from_IHTMLFrameBase2(iface);
 673
 674     FIXME("(%p)->(%p) semi-stub\n", This, p);
 675
 676     *p = VARIANT_TRUE;
 677     return S_OK;
 678 }
 679
 680 static const IHTMLFrameBase2Vtbl HTMLFrameBase2Vtbl = {
 681     HTMLFrameBase2_QueryInterface,
 682     HTMLFrameBase2_AddRef,
 683     HTMLFrameBase2_Release,
 684     HTMLFrameBase2_GetTypeInfoCount,
 685     HTMLFrameBase2_GetTypeInfo,
 686     HTMLFrameBase2_GetIDsOfNames,
 687     HTMLFrameBase2_Invoke,
 688     HTMLFrameBase2_get_contentWindow,
 689     HTMLFrameBase2_put_onload,
 690     HTMLFrameBase2_get_onload,
 691     HTMLFrameBase2_put_onreadystatechange,
 692     HTMLFrameBase2_get_onreadystatechange,
 693     HTMLFrameBase2_get_readyState,
 694     HTMLFrameBase2_put_allowTransparency,
 695     HTMLFrameBase2_get_allowTransparency
 696 };
 697
 698 static HRESULT HTMLFrameBase_QI(HTMLFrameBase *This, REFIID riid, void **ppv)
 699 {
 700     if(IsEqualGUID(&IID_IHTMLFrameBase, riid)) {
 701         TRACE("(%p)->(IID_IHTMLFrameBase %p)\n", This, ppv);
 702         *ppv = &This->IHTMLFrameBase_iface;
 703     }else if(IsEqualGUID(&IID_IHTMLFrameBase2, riid)) {
 704         TRACE("(%p)->(IID_IHTMLFrameBase2 %p)\n", This, ppv);
 705         *ppv = &This->IHTMLFrameBase2_iface;
 706     }else {
 707         return HTMLElement_QI(&This->element.node, riid, ppv);
 708     }
 709
 710     IUnknown_AddRef((IUnknown*)*ppv);
 711     return S_OK;
 712 }
 713
 714 static void HTMLFrameBase_destructor(HTMLFrameBase *This)
 715 {
 716     if(This->content_window)
 717         This->content_window->frame_element = NULL;
 718
 719     HTMLElement_destructor(&This->element.node);
 720 }
 721
 722 static void HTMLFrameBase_Init(HTMLFrameBase *This, HTMLDocumentNode *doc, nsIDOMElement *nselem,
 723         dispex_static_data_t *dispex_data)
 724 {
 725     nsresult nsres;
 726
 727     This->IHTMLFrameBase_iface.lpVtbl = &HTMLFrameBaseVtbl;
 728     This->IHTMLFrameBase2_iface.lpVtbl = &HTMLFrameBase2Vtbl;
 729
 730     HTMLElement_Init(&This->element, doc, nselem, dispex_data);
 731
 732     nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLFrameElement, (void**)&This->nsframe);
 733     if(NS_FAILED(nsres)) {
 734         This->nsframe = NULL;
 735         nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLIFrameElement, (void**)&This->nsiframe);
 736         assert(nsres == NS_OK);
 737     }else {
 738         This->nsiframe = NULL;
 739     }
 740 }
 741
 742 struct HTMLFrameElement {
 743     HTMLFrameBase framebase;
 744     IHTMLFrameElement3 IHTMLFrameElement3_iface;
 745 };
 746
 747 static inline HTMLFrameElement *impl_from_IHTMLFrameElement3(IHTMLFrameElement3 *iface)
 748 {
 749     return CONTAINING_RECORD(iface, HTMLFrameElement, IHTMLFrameElement3_iface);
 750 }
 751
 752 static HRESULT WINAPI HTMLFrameElement3_QueryInterface(IHTMLFrameElement3 *iface,
 753         REFIID riid, void **ppv)
 754 {
 755     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 756
 757     return IHTMLDOMNode_QueryInterface(&This->framebase.element.node.IHTMLDOMNode_iface, riid, ppv);
 758 }
 759
 760 static ULONG WINAPI HTMLFrameElement3_AddRef(IHTMLFrameElement3 *iface)
 761 {
 762     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 763
 764     return IHTMLDOMNode_AddRef(&This->framebase.element.node.IHTMLDOMNode_iface);
 765 }
 766
 767 static ULONG WINAPI HTMLFrameElement3_Release(IHTMLFrameElement3 *iface)
 768 {
 769     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 770
 771     return IHTMLDOMNode_Release(&This->framebase.element.node.IHTMLDOMNode_iface);
 772 }
 773
 774 static HRESULT WINAPI HTMLFrameElement3_GetTypeInfoCount(IHTMLFrameElement3 *iface, UINT *pctinfo)
 775 {
 776     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 777     return IDispatchEx_GetTypeInfoCount(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface,
 778             pctinfo);
 779 }
 780
 781 static HRESULT WINAPI HTMLFrameElement3_GetTypeInfo(IHTMLFrameElement3 *iface, UINT iTInfo,
 782         LCID lcid, ITypeInfo **ppTInfo)
 783 {
 784     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 785     return IDispatchEx_GetTypeInfo(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, iTInfo,
 786             lcid, ppTInfo);
 787 }
 788
 789 static HRESULT WINAPI HTMLFrameElement3_GetIDsOfNames(IHTMLFrameElement3 *iface, REFIID riid,
 790         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 791 {
 792     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 793     return IDispatchEx_GetIDsOfNames(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, riid,
 794             rgszNames, cNames, lcid, rgDispId);
 795 }
 796
 797 static HRESULT WINAPI HTMLFrameElement3_Invoke(IHTMLFrameElement3 *iface, DISPID dispIdMember,
 798         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 799         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 800 {
 801     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 802     return IDispatchEx_Invoke(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, dispIdMember,
 803             riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 804 }
 805
 806 static HRESULT WINAPI HTMLFrameElement3_get_contentDocument(IHTMLFrameElement3 *iface, IDispatch **p)
 807 {
 808     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 809     IHTMLDocument2 *doc;
 810     HRESULT hres;
 811
 812     TRACE("(%p)->(%p)\n", This, p);
 813
 814     if(!This->framebase.content_window) {
 815         FIXME("NULL window\n");
 816         return E_FAIL;
 817     }
 818
 819     hres = IHTMLWindow2_get_document(&This->framebase.content_window->base.IHTMLWindow2_iface, &doc);
 820     if(FAILED(hres))
 821         return hres;
 822
 823     *p = doc ? (IDispatch*)doc : NULL;
 824     return S_OK;
 825 }
 826
 827 static HRESULT WINAPI HTMLFrameElement3_put_src(IHTMLFrameElement3 *iface, BSTR v)
 828 {
 829     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 830     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 831     return E_NOTIMPL;
 832 }
 833
 834 static HRESULT WINAPI HTMLFrameElement3_get_src(IHTMLFrameElement3 *iface, BSTR *p)
 835 {
 836     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 837     FIXME("(%p)->(%p)\n", This, p);
 838     return E_NOTIMPL;
 839 }
 840
 841 static HRESULT WINAPI HTMLFrameElement3_put_longDesc(IHTMLFrameElement3 *iface, BSTR v)
 842 {
 843     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 844     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 845     return E_NOTIMPL;
 846 }
 847
 848 static HRESULT WINAPI HTMLFrameElement3_get_longDesc(IHTMLFrameElement3 *iface, BSTR *p)
 849 {
 850     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 851     FIXME("(%p)->(%p)\n", This, p);
 852     return E_NOTIMPL;
 853 }
 854
 855 static HRESULT WINAPI HTMLFrameElement3_put_frameBorder(IHTMLFrameElement3 *iface, BSTR v)
 856 {
 857     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 858     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 859     return E_NOTIMPL;
 860 }
 861
 862 static HRESULT WINAPI HTMLFrameElement3_get_frameBorder(IHTMLFrameElement3 *iface, BSTR *p)
 863 {
 864     HTMLFrameElement *This = impl_from_IHTMLFrameElement3(iface);
 865     FIXME("(%p)->(%p)\n", This, p);
 866     return E_NOTIMPL;
 867 }
 868
 869 static const IHTMLFrameElement3Vtbl HTMLFrameElement3Vtbl = {
 870     HTMLFrameElement3_QueryInterface,
 871     HTMLFrameElement3_AddRef,
 872     HTMLFrameElement3_Release,
 873     HTMLFrameElement3_GetTypeInfoCount,
 874     HTMLFrameElement3_GetTypeInfo,
 875     HTMLFrameElement3_GetIDsOfNames,
 876     HTMLFrameElement3_Invoke,
 877     HTMLFrameElement3_get_contentDocument,
 878     HTMLFrameElement3_put_src,
 879     HTMLFrameElement3_get_src,
 880     HTMLFrameElement3_put_longDesc,
 881     HTMLFrameElement3_get_longDesc,
 882     HTMLFrameElement3_put_frameBorder,
 883     HTMLFrameElement3_get_frameBorder
 884 };
 885
 886 static inline HTMLFrameElement *frame_from_HTMLDOMNode(HTMLDOMNode *iface)
 887 {
 888     return CONTAINING_RECORD(iface, HTMLFrameElement, framebase.element.node);
 889 }
 890
 891 static HRESULT HTMLFrameElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 892 {
 893     HTMLFrameElement *This = frame_from_HTMLDOMNode(iface);
 894
 895     if(IsEqualGUID(&IID_IHTMLFrameElement3, riid)) {
 896         TRACE("(%p)->(IID_IHTMLFrameElement3 %p)\n", This, ppv);
 897         *ppv = &This->IHTMLFrameElement3_iface;
 898     }else {
 899         return HTMLFrameBase_QI(&This->framebase, riid, ppv);
 900     }
 901
 902     IUnknown_AddRef((IUnknown*)*ppv);
 903     return S_OK;
 904 }
 905
 906 static void HTMLFrameElement_destructor(HTMLDOMNode *iface)
 907 {
 908     HTMLFrameElement *This = frame_from_HTMLDOMNode(iface);
 909
 910     HTMLFrameBase_destructor(&This->framebase);
 911 }
 912
 913 static HRESULT HTMLFrameElement_get_document(HTMLDOMNode *iface, IDispatch **p)
 914 {
 915     HTMLFrameElement *This = frame_from_HTMLDOMNode(iface);
 916
 917     if(!This->framebase.content_window || !This->framebase.content_window->base.inner_window->doc) {
 918         *p = NULL;
 919         return S_OK;
 920     }
 921
 922     *p = (IDispatch*)&This->framebase.content_window->base.inner_window->doc->basedoc.IHTMLDocument2_iface;
 923     IDispatch_AddRef(*p);
 924     return S_OK;
 925 }
 926
 927 static HRESULT HTMLFrameElement_get_readystate(HTMLDOMNode *iface, BSTR *p)
 928 {
 929     HTMLFrameElement *This = frame_from_HTMLDOMNode(iface);
 930
 931     return IHTMLFrameBase2_get_readyState(&This->framebase.IHTMLFrameBase2_iface, p);
 932 }
 933
 934 static HRESULT HTMLFrameElement_get_dispid(HTMLDOMNode *iface, BSTR name,
 935         DWORD grfdex, DISPID *pid)
 936 {
 937     HTMLFrameElement *This = frame_from_HTMLDOMNode(iface);
 938
 939     if(!This->framebase.content_window)
 940         return DISP_E_UNKNOWNNAME;
 941
 942     return search_window_props(This->framebase.content_window->base.inner_window, name, grfdex, pid);
 943 }
 944
 945 static HRESULT HTMLFrameElement_invoke(HTMLDOMNode *iface, DISPID id, LCID lcid,
 946         WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 947 {
 948     HTMLFrameElement *This = frame_from_HTMLDOMNode(iface);
 949
 950     if(!This->framebase.content_window) {
 951         ERR("no content window to invoke on\n");
 952         return E_FAIL;
 953     }
 954
 955     return IDispatchEx_InvokeEx(&This->framebase.content_window->base.IDispatchEx_iface, id, lcid,
 956             flags, params, res, ei, caller);
 957 }
 958
 959 static HRESULT HTMLFrameElement_bind_to_tree(HTMLDOMNode *iface)
 960 {
 961     HTMLFrameElement *This = frame_from_HTMLDOMNode(iface);
 962     nsIDOMDocument *nsdoc;
 963     nsresult nsres;
 964     HRESULT hres;
 965
 966     nsres = nsIDOMHTMLFrameElement_GetContentDocument(This->framebase.nsframe, &nsdoc);
 967     if(NS_FAILED(nsres) || !nsdoc) {
 968         ERR("GetContentDocument failed: %08x\n", nsres);
 969         return E_FAIL;
 970     }
 971
 972     hres = set_frame_doc(&This->framebase, nsdoc);
 973     nsIDOMDocument_Release(nsdoc);
 974     return hres;
 975 }
 976
 977 static void HTMLFrameElement_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
 978 {
 979     HTMLFrameElement *This = frame_from_HTMLDOMNode(iface);
 980
 981     if(This->framebase.nsframe)
 982         note_cc_edge((nsISupports*)This->framebase.nsframe, "This->nsframe", cb);
 983 }
 984
 985 static void HTMLFrameElement_unlink(HTMLDOMNode *iface)
 986 {
 987     HTMLFrameElement *This = frame_from_HTMLDOMNode(iface);
 988
 989     if(This->framebase.nsframe) {
 990         nsIDOMHTMLFrameElement *nsframe = This->framebase.nsframe;
 991
 992         This->framebase.nsframe = NULL;
 993         nsIDOMHTMLFrameElement_Release(nsframe);
 994     }
 995 }
 996
 997 static const NodeImplVtbl HTMLFrameElementImplVtbl = {
 998     &CLSID_HTMLFrameElement,
 999     HTMLFrameElement_QI,
1000     HTMLFrameElement_destructor,
1001     HTMLElement_cpc,
1002     HTMLElement_clone,
1003     HTMLElement_handle_event,
1004     HTMLElement_get_attr_col,
1005     NULL,
1006     NULL,
1007     NULL,
1008     HTMLFrameElement_get_document,
1009     HTMLFrameElement_get_readystate,
1010     HTMLFrameElement_get_dispid,
1011     HTMLFrameElement_invoke,
1012     HTMLFrameElement_bind_to_tree,
1013     HTMLFrameElement_traverse,
1014     HTMLFrameElement_unlink
1015 };
1016
1017 static const tid_t HTMLFrameElement_iface_tids[] = {
1018     HTMLELEMENT_TIDS,
1019     IHTMLFrameBase_tid,
1020     IHTMLFrameBase2_tid,
1021     IHTMLFrameElement3_tid,
1022     0
1023 };
1024
1025 static dispex_static_data_t HTMLFrameElement_dispex = {
1026     NULL,
1027     DispHTMLFrameElement_tid,
1028     HTMLFrameElement_iface_tids,
1029     HTMLElement_init_dispex_info
1030 };
1031
1032 HRESULT HTMLFrameElement_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
1033 {
1034     HTMLFrameElement *ret;
1035
1036     ret = heap_alloc_zero(sizeof(HTMLFrameElement));
1037     if(!ret)
1038         return E_OUTOFMEMORY;
1039
1040     ret->framebase.element.node.vtbl = &HTMLFrameElementImplVtbl;
1041     ret->IHTMLFrameElement3_iface.lpVtbl = &HTMLFrameElement3Vtbl;
1042
1043     HTMLFrameBase_Init(&ret->framebase, doc, nselem, &HTMLFrameElement_dispex);
1044
1045     *elem = &ret->framebase.element;
1046     return S_OK;
1047 }
1048
1049 struct HTMLIFrame {
1050     HTMLFrameBase framebase;
1051     IHTMLIFrameElement IHTMLIFrameElement_iface;
1052     IHTMLIFrameElement2 IHTMLIFrameElement2_iface;
1053     IHTMLIFrameElement3 IHTMLIFrameElement3_iface;
1054 };
1055
1056 static inline HTMLIFrame *impl_from_IHTMLIFrameElement(IHTMLIFrameElement *iface)
1057 {
1058     return CONTAINING_RECORD(iface, HTMLIFrame, IHTMLIFrameElement_iface);
1059 }
1060
1061 static HRESULT WINAPI HTMLIFrameElement_QueryInterface(IHTMLIFrameElement *iface,
1062         REFIID riid, void **ppv)
1063 {
1064     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1065
1066     return IHTMLDOMNode_QueryInterface(&This->framebase.element.node.IHTMLDOMNode_iface, riid, ppv);
1067 }
1068
1069 static ULONG WINAPI HTMLIFrameElement_AddRef(IHTMLIFrameElement *iface)
1070 {
1071     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1072
1073     return IHTMLDOMNode_AddRef(&This->framebase.element.node.IHTMLDOMNode_iface);
1074 }
1075
1076 static ULONG WINAPI HTMLIFrameElement_Release(IHTMLIFrameElement *iface)
1077 {
1078     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1079
1080     return IHTMLDOMNode_Release(&This->framebase.element.node.IHTMLDOMNode_iface);
1081 }
1082
1083 static HRESULT WINAPI HTMLIFrameElement_GetTypeInfoCount(IHTMLIFrameElement *iface, UINT *pctinfo)
1084 {
1085     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1086     return IDispatchEx_GetTypeInfoCount(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface,
1087             pctinfo);
1088 }
1089
1090 static HRESULT WINAPI HTMLIFrameElement_GetTypeInfo(IHTMLIFrameElement *iface, UINT iTInfo,
1091         LCID lcid, ITypeInfo **ppTInfo)
1092 {
1093     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1094     return IDispatchEx_GetTypeInfo(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, iTInfo,
1095             lcid, ppTInfo);
1096 }
1097
1098 static HRESULT WINAPI HTMLIFrameElement_GetIDsOfNames(IHTMLIFrameElement *iface, REFIID riid,
1099         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1100 {
1101     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1102     return IDispatchEx_GetIDsOfNames(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, riid,
1103             rgszNames, cNames, lcid, rgDispId);
1104 }
1105
1106 static HRESULT WINAPI HTMLIFrameElement_Invoke(IHTMLIFrameElement *iface, DISPID dispIdMember,
1107         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1108         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1109 {
1110     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1111     return IDispatchEx_Invoke(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, dispIdMember,
1112             riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1113 }
1114
1115 static HRESULT WINAPI HTMLIFrameElement_put_vspace(IHTMLIFrameElement *iface, LONG v)
1116 {
1117     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1118     FIXME("(%p)->(%d)\n", This, v);
1119     return E_NOTIMPL;
1120 }
1121
1122 static HRESULT WINAPI HTMLIFrameElement_get_vspace(IHTMLIFrameElement *iface, LONG *p)
1123 {
1124     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1125     FIXME("(%p)->(%p)\n", This, p);
1126     return E_NOTIMPL;
1127 }
1128
1129 static HRESULT WINAPI HTMLIFrameElement_put_hspace(IHTMLIFrameElement *iface, LONG v)
1130 {
1131     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1132     FIXME("(%p)->(%d)\n", This, v);
1133     return E_NOTIMPL;
1134 }
1135
1136 static HRESULT WINAPI HTMLIFrameElement_get_hspace(IHTMLIFrameElement *iface, LONG *p)
1137 {
1138     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1139     FIXME("(%p)->(%p)\n", This, p);
1140     return E_NOTIMPL;
1141 }
1142
1143 static HRESULT WINAPI HTMLIFrameElement_put_align(IHTMLIFrameElement *iface, BSTR v)
1144 {
1145     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1146     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1147     return E_NOTIMPL;
1148 }
1149
1150 static HRESULT WINAPI HTMLIFrameElement_get_align(IHTMLIFrameElement *iface, BSTR *p)
1151 {
1152     HTMLIFrame *This = impl_from_IHTMLIFrameElement(iface);
1153     FIXME("(%p)->(%p)\n", This, p);
1154     return E_NOTIMPL;
1155 }
1156
1157 static const IHTMLIFrameElementVtbl HTMLIFrameElementVtbl = {
1158     HTMLIFrameElement_QueryInterface,
1159     HTMLIFrameElement_AddRef,
1160     HTMLIFrameElement_Release,
1161     HTMLIFrameElement_GetTypeInfoCount,
1162     HTMLIFrameElement_GetTypeInfo,
1163     HTMLIFrameElement_GetIDsOfNames,
1164     HTMLIFrameElement_Invoke,
1165     HTMLIFrameElement_put_vspace,
1166     HTMLIFrameElement_get_vspace,
1167     HTMLIFrameElement_put_hspace,
1168     HTMLIFrameElement_get_hspace,
1169     HTMLIFrameElement_put_align,
1170     HTMLIFrameElement_get_align
1171 };
1172
1173 static inline HTMLIFrame *impl_from_IHTMLIFrameElement2(IHTMLIFrameElement2 *iface)
1174 {
1175     return CONTAINING_RECORD(iface, HTMLIFrame, IHTMLIFrameElement2_iface);
1176 }
1177
1178 static HRESULT WINAPI HTMLIFrameElement2_QueryInterface(IHTMLIFrameElement2 *iface,
1179         REFIID riid, void **ppv)
1180 {
1181     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1182
1183     return IHTMLDOMNode_QueryInterface(&This->framebase.element.node.IHTMLDOMNode_iface, riid, ppv);
1184 }
1185
1186 static ULONG WINAPI HTMLIFrameElement2_AddRef(IHTMLIFrameElement2 *iface)
1187 {
1188     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1189
1190     return IHTMLDOMNode_AddRef(&This->framebase.element.node.IHTMLDOMNode_iface);
1191 }
1192
1193 static ULONG WINAPI HTMLIFrameElement2_Release(IHTMLIFrameElement2 *iface)
1194 {
1195     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1196
1197     return IHTMLDOMNode_Release(&This->framebase.element.node.IHTMLDOMNode_iface);
1198 }
1199
1200 static HRESULT WINAPI HTMLIFrameElement2_GetTypeInfoCount(IHTMLIFrameElement2 *iface, UINT *pctinfo)
1201 {
1202     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1203     return IDispatchEx_GetTypeInfoCount(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface,
1204             pctinfo);
1205 }
1206
1207 static HRESULT WINAPI HTMLIFrameElement2_GetTypeInfo(IHTMLIFrameElement2 *iface, UINT iTInfo,
1208         LCID lcid, ITypeInfo **ppTInfo)
1209 {
1210     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1211     return IDispatchEx_GetTypeInfo(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, iTInfo,
1212             lcid, ppTInfo);
1213 }
1214
1215 static HRESULT WINAPI HTMLIFrameElement2_GetIDsOfNames(IHTMLIFrameElement2 *iface, REFIID riid,
1216         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1217 {
1218     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1219     return IDispatchEx_GetIDsOfNames(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, riid,
1220             rgszNames, cNames, lcid, rgDispId);
1221 }
1222
1223 static HRESULT WINAPI HTMLIFrameElement2_Invoke(IHTMLIFrameElement2 *iface, DISPID dispIdMember,
1224         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1225         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1226 {
1227     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1228     return IDispatchEx_Invoke(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, dispIdMember,
1229             riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1230 }
1231
1232 static HRESULT WINAPI HTMLIFrameElement2_put_height(IHTMLIFrameElement2 *iface, VARIANT v)
1233 {
1234     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1235     nsAString nsstr;
1236     nsresult nsres;
1237     HRESULT hres;
1238
1239     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1240
1241     hres = variant_to_nsstr(&v, FALSE, &nsstr);
1242     if(FAILED(hres))
1243         return hres;
1244
1245     nsres = nsIDOMHTMLIFrameElement_SetHeight(This->framebase.nsiframe, &nsstr);
1246     nsAString_Finish(&nsstr);
1247     if(NS_FAILED(nsres)) {
1248         ERR("SetHeight failed: %08x\n", nsres);
1249         return E_FAIL;
1250     }
1251
1252     return S_OK;
1253 }
1254
1255 static HRESULT WINAPI HTMLIFrameElement2_get_height(IHTMLIFrameElement2 *iface, VARIANT *p)
1256 {
1257     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1258     nsAString nsstr;
1259     nsresult nsres;
1260
1261     TRACE("(%p)->(%p)\n", This, p);
1262
1263     nsAString_Init(&nsstr, NULL);
1264     nsres = nsIDOMHTMLIFrameElement_GetHeight(This->framebase.nsiframe, &nsstr);
1265
1266     V_VT(p) = VT_BSTR;
1267     return return_nsstr(nsres, &nsstr, &V_BSTR(p));
1268 }
1269
1270 static HRESULT WINAPI HTMLIFrameElement2_put_width(IHTMLIFrameElement2 *iface, VARIANT v)
1271 {
1272     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1273     nsAString nsstr;
1274     nsresult nsres;
1275     HRESULT hres;
1276
1277     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1278
1279     hres = variant_to_nsstr(&v, FALSE, &nsstr);
1280     if(FAILED(hres))
1281         return hres;
1282
1283     nsres = nsIDOMHTMLIFrameElement_SetWidth(This->framebase.nsiframe, &nsstr);
1284     nsAString_Finish(&nsstr);
1285     if(NS_FAILED(nsres)) {
1286         ERR("SetWidth failed: %08x\n", nsres);
1287         return E_FAIL;
1288     }
1289
1290     return S_OK;
1291 }
1292
1293 static HRESULT WINAPI HTMLIFrameElement2_get_width(IHTMLIFrameElement2 *iface, VARIANT *p)
1294 {
1295     HTMLIFrame *This = impl_from_IHTMLIFrameElement2(iface);
1296     nsAString nsstr;
1297     nsresult nsres;
1298
1299     TRACE("(%p)->(%p)\n", This, p);
1300
1301     nsAString_Init(&nsstr, NULL);
1302     nsres = nsIDOMHTMLIFrameElement_GetWidth(This->framebase.nsiframe, &nsstr);
1303
1304     V_VT(p) = VT_BSTR;
1305     return return_nsstr(nsres, &nsstr, &V_BSTR(p));
1306 }
1307
1308 static const IHTMLIFrameElement2Vtbl HTMLIFrameElement2Vtbl = {
1309     HTMLIFrameElement2_QueryInterface,
1310     HTMLIFrameElement2_AddRef,
1311     HTMLIFrameElement2_Release,
1312     HTMLIFrameElement2_GetTypeInfoCount,
1313     HTMLIFrameElement2_GetTypeInfo,
1314     HTMLIFrameElement2_GetIDsOfNames,
1315     HTMLIFrameElement2_Invoke,
1316     HTMLIFrameElement2_put_height,
1317     HTMLIFrameElement2_get_height,
1318     HTMLIFrameElement2_put_width,
1319     HTMLIFrameElement2_get_width
1320 };
1321
1322 static inline HTMLIFrame *impl_from_IHTMLIFrameElement3(IHTMLIFrameElement3 *iface)
1323 {
1324     return CONTAINING_RECORD(iface, HTMLIFrame, IHTMLIFrameElement3_iface);
1325 }
1326
1327 static HRESULT WINAPI HTMLIFrameElement3_QueryInterface(IHTMLIFrameElement3 *iface,
1328         REFIID riid, void **ppv)
1329 {
1330     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1331
1332     return IHTMLDOMNode_QueryInterface(&This->framebase.element.node.IHTMLDOMNode_iface, riid, ppv);
1333 }
1334
1335 static ULONG WINAPI HTMLIFrameElement3_AddRef(IHTMLIFrameElement3 *iface)
1336 {
1337     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1338
1339     return IHTMLDOMNode_AddRef(&This->framebase.element.node.IHTMLDOMNode_iface);
1340 }
1341
1342 static ULONG WINAPI HTMLIFrameElement3_Release(IHTMLIFrameElement3 *iface)
1343 {
1344     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1345
1346     return IHTMLDOMNode_Release(&This->framebase.element.node.IHTMLDOMNode_iface);
1347 }
1348
1349 static HRESULT WINAPI HTMLIFrameElement3_GetTypeInfoCount(IHTMLIFrameElement3 *iface, UINT *pctinfo)
1350 {
1351     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1352     return IDispatchEx_GetTypeInfoCount(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface,
1353             pctinfo);
1354 }
1355
1356 static HRESULT WINAPI HTMLIFrameElement3_GetTypeInfo(IHTMLIFrameElement3 *iface, UINT iTInfo,
1357         LCID lcid, ITypeInfo **ppTInfo)
1358 {
1359     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1360     return IDispatchEx_GetTypeInfo(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, iTInfo,
1361             lcid, ppTInfo);
1362 }
1363
1364 static HRESULT WINAPI HTMLIFrameElement3_GetIDsOfNames(IHTMLIFrameElement3 *iface, REFIID riid,
1365         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1366 {
1367     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1368     return IDispatchEx_GetIDsOfNames(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, riid,
1369             rgszNames, cNames, lcid, rgDispId);
1370 }
1371
1372 static HRESULT WINAPI HTMLIFrameElement3_Invoke(IHTMLIFrameElement3 *iface, DISPID dispIdMember,
1373         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1374         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1375 {
1376     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1377     return IDispatchEx_Invoke(&This->framebase.element.node.event_target.dispex.IDispatchEx_iface, dispIdMember,
1378             riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1379 }
1380
1381 static HRESULT WINAPI HTMLIFrameElement3_get_contentDocument(IHTMLIFrameElement3 *iface, IDispatch **p)
1382 {
1383     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1384     IHTMLDocument2 *doc;
1385     HRESULT hres;
1386
1387     TRACE("(%p)->(%p)\n", This, p);
1388
1389     if(!This->framebase.content_window) {
1390         *p = NULL;
1391         return S_OK;
1392     }
1393
1394     hres = IHTMLWindow2_get_document(&This->framebase.content_window->base.IHTMLWindow2_iface, &doc);
1395     *p = (IDispatch*)doc;
1396     return hres;
1397 }
1398
1399 static HRESULT WINAPI HTMLIFrameElement3_put_src(IHTMLIFrameElement3 *iface, BSTR v)
1400 {
1401     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1402     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1403     return E_NOTIMPL;
1404 }
1405
1406 static HRESULT WINAPI HTMLIFrameElement3_get_src(IHTMLIFrameElement3 *iface, BSTR *p)
1407 {
1408     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1409     FIXME("(%p)->(%p)\n", This, p);
1410     return E_NOTIMPL;
1411 }
1412
1413 static HRESULT WINAPI HTMLIFrameElement3_put_longDesc(IHTMLIFrameElement3 *iface, BSTR v)
1414 {
1415     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1416     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1417     return E_NOTIMPL;
1418 }
1419
1420 static HRESULT WINAPI HTMLIFrameElement3_get_longDesc(IHTMLIFrameElement3 *iface, BSTR *p)
1421 {
1422     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1423     FIXME("(%p)->(%p)\n", This, p);
1424     return E_NOTIMPL;
1425 }
1426
1427 static HRESULT WINAPI HTMLIFrameElement3_put_frameBorder(IHTMLIFrameElement3 *iface, BSTR v)
1428 {
1429     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1430     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1431     return E_NOTIMPL;
1432 }
1433
1434 static HRESULT WINAPI HTMLIFrameElement3_get_frameBorder(IHTMLIFrameElement3 *iface, BSTR *p)
1435 {
1436     HTMLIFrame *This = impl_from_IHTMLIFrameElement3(iface);
1437     FIXME("(%p)->(%p)\n", This, p);
1438     return E_NOTIMPL;
1439 }
1440
1441 static const IHTMLIFrameElement3Vtbl HTMLIFrameElement3Vtbl = {
1442     HTMLIFrameElement3_QueryInterface,
1443     HTMLIFrameElement3_AddRef,
1444     HTMLIFrameElement3_Release,
1445     HTMLIFrameElement3_GetTypeInfoCount,
1446     HTMLIFrameElement3_GetTypeInfo,
1447     HTMLIFrameElement3_GetIDsOfNames,
1448     HTMLIFrameElement3_Invoke,
1449     HTMLIFrameElement3_get_contentDocument,
1450     HTMLIFrameElement3_put_src,
1451     HTMLIFrameElement3_get_src,
1452     HTMLIFrameElement3_put_longDesc,
1453     HTMLIFrameElement3_get_longDesc,
1454     HTMLIFrameElement3_put_frameBorder,
1455     HTMLIFrameElement3_get_frameBorder
1456 };
1457
1458 static inline HTMLIFrame *iframe_from_HTMLDOMNode(HTMLDOMNode *iface)
1459 {
1460     return CONTAINING_RECORD(iface, HTMLIFrame, framebase.element.node);
1461 }
1462
1463 static HRESULT HTMLIFrame_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
1464 {
1465     HTMLIFrame *This = iframe_from_HTMLDOMNode(iface);
1466
1467     if(IsEqualGUID(&IID_IHTMLIFrameElement, riid)) {
1468         TRACE("(%p)->(IID_IHTMLIFrameElement %p)\n", This, ppv);
1469         *ppv = &This->IHTMLIFrameElement_iface;
1470     }else if(IsEqualGUID(&IID_IHTMLIFrameElement2, riid)) {
1471         TRACE("(%p)->(IID_IHTMLIFrameElement2 %p)\n", This, ppv);
1472         *ppv = &This->IHTMLIFrameElement2_iface;
1473     }else if(IsEqualGUID(&IID_IHTMLIFrameElement3, riid)) {
1474         TRACE("(%p)->(IID_IHTMLIFrameElement3 %p)\n", This, ppv);
1475         *ppv = &This->IHTMLIFrameElement3_iface;
1476     }else {
1477         return HTMLFrameBase_QI(&This->framebase, riid, ppv);
1478     }
1479
1480     IUnknown_AddRef((IUnknown*)*ppv);
1481     return S_OK;
1482 }
1483
1484 static void HTMLIFrame_destructor(HTMLDOMNode *iface)
1485 {
1486     HTMLIFrame *This = iframe_from_HTMLDOMNode(iface);
1487
1488     HTMLFrameBase_destructor(&This->framebase);
1489 }
1490
1491 static HRESULT HTMLIFrame_get_document(HTMLDOMNode *iface, IDispatch **p)
1492 {
1493     HTMLIFrame *This = iframe_from_HTMLDOMNode(iface);
1494
1495     if(!This->framebase.content_window || !This->framebase.content_window->base.inner_window->doc) {
1496         *p = NULL;
1497         return S_OK;
1498     }
1499
1500     *p = (IDispatch*)&This->framebase.content_window->base.inner_window->doc->basedoc.IHTMLDocument2_iface;
1501     IDispatch_AddRef(*p);
1502     return S_OK;
1503 }
1504
1505 static HRESULT HTMLIFrame_get_dispid(HTMLDOMNode *iface, BSTR name,
1506         DWORD grfdex, DISPID *pid)
1507 {
1508     HTMLIFrame *This = iframe_from_HTMLDOMNode(iface);
1509
1510     if(!This->framebase.content_window)
1511         return DISP_E_UNKNOWNNAME;
1512
1513     return search_window_props(This->framebase.content_window->base.inner_window, name, grfdex, pid);
1514 }
1515
1516 static HRESULT HTMLIFrame_invoke(HTMLDOMNode *iface, DISPID id, LCID lcid,
1517         WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
1518 {
1519     HTMLIFrame *This = iframe_from_HTMLDOMNode(iface);
1520
1521     if(!This->framebase.content_window) {
1522         ERR("no content window to invoke on\n");
1523         return E_FAIL;
1524     }
1525
1526     return IDispatchEx_InvokeEx(&This->framebase.content_window->base.IDispatchEx_iface, id, lcid,
1527             flags, params, res, ei, caller);
1528 }
1529
1530 static HRESULT HTMLIFrame_get_readystate(HTMLDOMNode *iface, BSTR *p)
1531 {
1532     HTMLIFrame *This = iframe_from_HTMLDOMNode(iface);
1533
1534     return IHTMLFrameBase2_get_readyState(&This->framebase.IHTMLFrameBase2_iface, p);
1535 }
1536
1537 static HRESULT HTMLIFrame_bind_to_tree(HTMLDOMNode *iface)
1538 {
1539     HTMLIFrame *This = iframe_from_HTMLDOMNode(iface);
1540     nsIDOMDocument *nsdoc;
1541     nsresult nsres;
1542     HRESULT hres;
1543
1544     nsres = nsIDOMHTMLIFrameElement_GetContentDocument(This->framebase.nsiframe, &nsdoc);
1545     if(NS_FAILED(nsres) || !nsdoc) {
1546         ERR("GetContentDocument failed: %08x\n", nsres);
1547         return E_FAIL;
1548     }
1549
1550     hres = set_frame_doc(&This->framebase, nsdoc);
1551     nsIDOMDocument_Release(nsdoc);
1552     return hres;
1553 }
1554
1555 static void HTMLIFrame_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
1556 {
1557     HTMLIFrame *This = iframe_from_HTMLDOMNode(iface);
1558
1559     if(This->framebase.nsiframe)
1560         note_cc_edge((nsISupports*)This->framebase.nsiframe, "This->nsiframe", cb);
1561 }
1562
1563 static void HTMLIFrame_unlink(HTMLDOMNode *iface)
1564 {
1565     HTMLIFrame *This = iframe_from_HTMLDOMNode(iface);
1566
1567     if(This->framebase.nsiframe) {
1568         nsIDOMHTMLIFrameElement *nsiframe = This->framebase.nsiframe;
1569
1570         This->framebase.nsiframe = NULL;
1571         nsIDOMHTMLIFrameElement_Release(nsiframe);
1572     }
1573 }
1574
1575 static const NodeImplVtbl HTMLIFrameImplVtbl = {
1576     &CLSID_HTMLIFrame,
1577     HTMLIFrame_QI,
1578     HTMLIFrame_destructor,
1579     HTMLElement_cpc,
1580     HTMLElement_clone,
1581     HTMLElement_handle_event,
1582     HTMLElement_get_attr_col,
1583     NULL,
1584     NULL,
1585     NULL,
1586     HTMLIFrame_get_document,
1587     HTMLIFrame_get_readystate,
1588     HTMLIFrame_get_dispid,
1589     HTMLIFrame_invoke,
1590     HTMLIFrame_bind_to_tree,
1591     HTMLIFrame_traverse,
1592     HTMLIFrame_unlink
1593 };
1594
1595 static const tid_t HTMLIFrame_iface_tids[] = {
1596     HTMLELEMENT_TIDS,
1597     IHTMLFrameBase_tid,
1598     IHTMLFrameBase2_tid,
1599     IHTMLIFrameElement_tid,
1600     IHTMLIFrameElement2_tid,
1601     IHTMLIFrameElement3_tid,
1602     0
1603 };
1604
1605 static dispex_static_data_t HTMLIFrame_dispex = {
1606     NULL,
1607     DispHTMLIFrame_tid,
1608     HTMLIFrame_iface_tids,
1609     HTMLElement_init_dispex_info
1610 };
1611
1612 HRESULT HTMLIFrame_Create(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **elem)
1613 {
1614     HTMLIFrame *ret;
1615
1616     ret = heap_alloc_zero(sizeof(HTMLIFrame));
1617     if(!ret)
1618         return E_OUTOFMEMORY;
1619
1620     ret->IHTMLIFrameElement_iface.lpVtbl = &HTMLIFrameElementVtbl;
1621     ret->IHTMLIFrameElement2_iface.lpVtbl = &HTMLIFrameElement2Vtbl;
1622     ret->IHTMLIFrameElement3_iface.lpVtbl = &HTMLIFrameElement3Vtbl;
1623     ret->framebase.element.node.vtbl = &HTMLIFrameImplVtbl;
1624
1625     HTMLFrameBase_Init(&ret->framebase, doc, nselem, &HTMLIFrame_dispex);
1626
1627     *elem = &ret->framebase.element;
1628     return S_OK;
1629 }