git.oblomov.eu Git - wine/blob - dlls/mshtml/htmliframe.c

   1 /*
   2  * Copyright 2008 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
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  33
  34 typedef struct {
  35     HTMLElement element;
  36     const IHTMLFrameBaseVtbl   *lpIHTMLFrameBaseVtbl;
  37     const IHTMLFrameBase2Vtbl  *lpIHTMLFrameBase2Vtbl;
  38
  39     LONG ref;
  40
  41     nsIDOMHTMLIFrameElement *nsiframe;
  42     HTMLWindow *content_window;
  43 } HTMLIFrame;
  44
  45 #define HTMLFRAMEBASE(x)   (&(x)->lpIHTMLFrameBaseVtbl)
  46 #define HTMLFRAMEBASE2(x)  (&(x)->lpIHTMLFrameBase2Vtbl)
  47
  48 static HRESULT create_content_window(HTMLIFrame *This, nsIDOMHTMLDocument *nsdoc, HTMLWindow **ret)
  49 {
  50     nsIDOMDocumentView *nsdocview;
  51     nsIDOMAbstractView *nsview;
  52     nsIDOMWindow *nswindow;
  53     nsresult nsres;
  54     HRESULT hres;
  55
  56     nsres = nsIDOMHTMLDocument_QueryInterface(nsdoc, &IID_nsIDOMDocumentView, (void**)&nsdocview);
  57     if(NS_FAILED(nsres)) {
  58         ERR("Could not get nsIDOMDocumentView: %08x\n", nsres);
  59         return E_FAIL;
  60     }
  61
  62     nsres = nsIDOMDocumentView_GetDefaultView(nsdocview, &nsview);
  63     nsIDOMDocumentView_Release(nsdocview);
  64     if(NS_FAILED(nsres)) {
  65         ERR("GetDefaultView failed: %08x\n", nsres);
  66         return E_FAIL;
  67     }
  68
  69     nsres = nsIDOMAbstractView_QueryInterface(nsview, &IID_nsIDOMWindow, (void**)&nswindow);
  70     nsIDOMAbstractView_Release(nsview);
  71     if(NS_FAILED(nsres)) {
  72         ERR("Coult not get nsIDOMWindow iface: %08x\n", nsres);
  73         return E_FAIL;
  74     }
  75
  76     hres = HTMLWindow_Create(This->element.node.doc->basedoc.doc_obj, nswindow, ret);
  77
  78     nsIDOMWindow_Release(nswindow);
  79     return hres;
  80 }
  81
  82 #define HTMLFRAMEBASE_THIS(iface) DEFINE_THIS(HTMLIFrame, IHTMLFrameBase, iface)
  83
  84 static HRESULT WINAPI HTMLIFrameBase_QueryInterface(IHTMLFrameBase *iface, REFIID riid, void **ppv)
  85 {
  86     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
  87
  88     return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(&This->element.node), riid, ppv);
  89 }
  90
  91 static ULONG WINAPI HTMLIFrameBase_AddRef(IHTMLFrameBase *iface)
  92 {
  93     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
  94
  95     return IHTMLDOMNode_AddRef(HTMLDOMNODE(&This->element.node));
  96 }
  97
  98 static ULONG WINAPI HTMLIFrameBase_Release(IHTMLFrameBase *iface)
  99 {
 100     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 101
 102     return IHTMLDOMNode_Release(HTMLDOMNODE(&This->element.node));
 103 }
 104
 105 static HRESULT WINAPI HTMLIFrameBase_GetTypeInfoCount(IHTMLFrameBase *iface, UINT *pctinfo)
 106 {
 107     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 108
 109     return IDispatchEx_GetTypeInfoCount(DISPATCHEX(&This->element.node.dispex), pctinfo);
 110 }
 111
 112 static HRESULT WINAPI HTMLIFrameBase_GetTypeInfo(IHTMLFrameBase *iface, UINT iTInfo,
 113         LCID lcid, ITypeInfo **ppTInfo)
 114 {
 115     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 116
 117     return IDispatchEx_GetTypeInfo(DISPATCHEX(&This->element.node.dispex), iTInfo, lcid, ppTInfo);
 118 }
 119
 120 static HRESULT WINAPI HTMLIFrameBase_GetIDsOfNames(IHTMLFrameBase *iface, REFIID riid,
 121         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 122 {
 123     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 124
 125     return IDispatchEx_GetIDsOfNames(DISPATCHEX(&This->element.node.dispex), riid, rgszNames,
 126             cNames, lcid, rgDispId);
 127 }
 128
 129 static HRESULT WINAPI HTMLIFrameBase_Invoke(IHTMLFrameBase *iface, DISPID dispIdMember,
 130         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 131         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 132 {
 133     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 134
 135     return IDispatchEx_Invoke(DISPATCHEX(&This->element.node.dispex), dispIdMember, riid, lcid,
 136             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 137 }
 138
 139 static HRESULT WINAPI HTMLIFrameBase_put_src(IHTMLFrameBase *iface, BSTR v)
 140 {
 141     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 142     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI HTMLIFrameBase_get_src(IHTMLFrameBase *iface, BSTR *p)
 147 {
 148     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 149     FIXME("(%p)->(%p)\n", This, p);
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI HTMLIFrameBase_put_name(IHTMLFrameBase *iface, BSTR v)
 154 {
 155     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 156     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI HTMLIFrameBase_get_name(IHTMLFrameBase *iface, BSTR *p)
 161 {
 162     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 163     FIXME("(%p)->(%p)\n", This, p);
 164     return E_NOTIMPL;
 165 }
 166
 167 static HRESULT WINAPI HTMLIFrameBase_put_border(IHTMLFrameBase *iface, VARIANT v)
 168 {
 169     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 170     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT WINAPI HTMLIFrameBase_get_border(IHTMLFrameBase *iface, VARIANT *p)
 175 {
 176     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 177     FIXME("(%p)->(%p)\n", This, p);
 178     return E_NOTIMPL;
 179 }
 180
 181 static HRESULT WINAPI HTMLIFrameBase_put_frameBorder(IHTMLFrameBase *iface, BSTR v)
 182 {
 183     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 184     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 185     return E_NOTIMPL;
 186 }
 187
 188 static HRESULT WINAPI HTMLIFrameBase_get_frameBorder(IHTMLFrameBase *iface, BSTR *p)
 189 {
 190     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 191     FIXME("(%p)->(%p)\n", This, p);
 192     return E_NOTIMPL;
 193 }
 194
 195 static HRESULT WINAPI HTMLIFrameBase_put_frameSpacing(IHTMLFrameBase *iface, VARIANT v)
 196 {
 197     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 198     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT WINAPI HTMLIFrameBase_get_frameSpacing(IHTMLFrameBase *iface, VARIANT *p)
 203 {
 204     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 205     FIXME("(%p)->(%p)\n", This, p);
 206     return E_NOTIMPL;
 207 }
 208
 209 static HRESULT WINAPI HTMLIFrameBase_put_marginWidth(IHTMLFrameBase *iface, VARIANT v)
 210 {
 211     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 212     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT WINAPI HTMLIFrameBase_get_marginWidth(IHTMLFrameBase *iface, VARIANT *p)
 217 {
 218     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 219     FIXME("(%p)->(%p)\n", This, p);
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI HTMLIFrameBase_put_marginHeight(IHTMLFrameBase *iface, VARIANT v)
 224 {
 225     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 226     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI HTMLIFrameBase_get_marginHeight(IHTMLFrameBase *iface, VARIANT *p)
 231 {
 232     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 233     FIXME("(%p)->(%p)\n", This, p);
 234     return E_NOTIMPL;
 235 }
 236
 237 static HRESULT WINAPI HTMLIFrameBase_put_noResize(IHTMLFrameBase *iface, VARIANT_BOOL v)
 238 {
 239     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 240     FIXME("(%p)->(%x)\n", This, v);
 241     return E_NOTIMPL;
 242 }
 243
 244 static HRESULT WINAPI HTMLIFrameBase_get_noResize(IHTMLFrameBase *iface, VARIANT_BOOL *p)
 245 {
 246     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 247     FIXME("(%p)->(%p)\n", This, p);
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI HTMLIFrameBase_put_scrolling(IHTMLFrameBase *iface, BSTR v)
 252 {
 253     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 254     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 255     return E_NOTIMPL;
 256 }
 257
 258 static HRESULT WINAPI HTMLIFrameBase_get_scrolling(IHTMLFrameBase *iface, BSTR *p)
 259 {
 260     HTMLIFrame *This = HTMLFRAMEBASE_THIS(iface);
 261     FIXME("(%p)->(%p)\n", This, p);
 262     return E_NOTIMPL;
 263 }
 264
 265 static const IHTMLFrameBaseVtbl HTMLIFrameBaseVtbl = {
 266     HTMLIFrameBase_QueryInterface,
 267     HTMLIFrameBase_AddRef,
 268     HTMLIFrameBase_Release,
 269     HTMLIFrameBase_GetTypeInfoCount,
 270     HTMLIFrameBase_GetTypeInfo,
 271     HTMLIFrameBase_GetIDsOfNames,
 272     HTMLIFrameBase_Invoke,
 273     HTMLIFrameBase_put_src,
 274     HTMLIFrameBase_get_src,
 275     HTMLIFrameBase_put_name,
 276     HTMLIFrameBase_get_name,
 277     HTMLIFrameBase_put_border,
 278     HTMLIFrameBase_get_border,
 279     HTMLIFrameBase_put_frameBorder,
 280     HTMLIFrameBase_get_frameBorder,
 281     HTMLIFrameBase_put_frameSpacing,
 282     HTMLIFrameBase_get_frameSpacing,
 283     HTMLIFrameBase_put_marginWidth,
 284     HTMLIFrameBase_get_marginWidth,
 285     HTMLIFrameBase_put_marginHeight,
 286     HTMLIFrameBase_get_marginHeight,
 287     HTMLIFrameBase_put_noResize,
 288     HTMLIFrameBase_get_noResize,
 289     HTMLIFrameBase_put_scrolling,
 290     HTMLIFrameBase_get_scrolling
 291 };
 292
 293 #define HTMLFRAMEBASE2_THIS(iface) DEFINE_THIS(HTMLIFrame, IHTMLFrameBase2, iface)
 294
 295 static HRESULT WINAPI HTMLIFrameBase2_QueryInterface(IHTMLFrameBase2 *iface, REFIID riid, void **ppv)
 296 {
 297     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 298
 299     return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(&This->element.node), riid, ppv);
 300 }
 301
 302 static ULONG WINAPI HTMLIFrameBase2_AddRef(IHTMLFrameBase2 *iface)
 303 {
 304     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 305
 306     return IHTMLDOMNode_AddRef(HTMLDOMNODE(&This->element.node));
 307 }
 308
 309 static ULONG WINAPI HTMLIFrameBase2_Release(IHTMLFrameBase2 *iface)
 310 {
 311     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 312
 313     return IHTMLDOMNode_Release(HTMLDOMNODE(&This->element.node));
 314 }
 315
 316 static HRESULT WINAPI HTMLIFrameBase2_GetTypeInfoCount(IHTMLFrameBase2 *iface, UINT *pctinfo)
 317 {
 318     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 319     FIXME("(%p)\n", This);
 320     return E_NOTIMPL;
 321 }
 322
 323 static HRESULT WINAPI HTMLIFrameBase2_GetTypeInfo(IHTMLFrameBase2 *iface, UINT iTInfo,
 324         LCID lcid, ITypeInfo **ppTInfo)
 325 {
 326     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 327     FIXME("(%p)\n", This);
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI HTMLIFrameBase2_GetIDsOfNames(IHTMLFrameBase2 *iface, REFIID riid,
 332         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 333 {
 334     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 335     FIXME("(%p)\n", This);
 336     return E_NOTIMPL;
 337 }
 338
 339 static HRESULT WINAPI HTMLIFrameBase2_Invoke(IHTMLFrameBase2 *iface, DISPID dispIdMember,
 340         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 341         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 342 {
 343     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 344     FIXME("(%p)\n", This);
 345     return E_NOTIMPL;
 346 }
 347
 348 static HRESULT WINAPI HTMLIFrameBase2_get_contentWindow(IHTMLFrameBase2 *iface, IHTMLWindow2 **p)
 349 {
 350     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 351
 352     TRACE("(%p)->(%p)\n", This, p);
 353
 354     if(!This->content_window) {
 355         nsIDOMHTMLDocument *nshtmldoc;
 356         HTMLDocumentNode *content_doc;
 357         nsIDOMDocument *nsdoc;
 358         HTMLWindow *window;
 359         nsresult nsres;
 360         HRESULT hres;
 361
 362         nsres = nsIDOMHTMLIFrameElement_GetContentDocument(This->nsiframe, &nsdoc);
 363         if(NS_FAILED(nsres)) {
 364             ERR("GetContentDocument failed: %08x\n", nsres);
 365             return E_FAIL;
 366         }
 367
 368         if(!nsdoc) {
 369             FIXME("NULL contentDocument\n");
 370             return E_FAIL;
 371         }
 372
 373         nsres = nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
 374         nsIDOMDocument_Release(nsdoc);
 375         if(NS_FAILED(nsres)) {
 376             ERR("Could not get nsIDOMHTMLDocument iface: %08x\n", nsres);
 377             return E_FAIL;
 378         }
 379
 380         hres = create_content_window(This, nshtmldoc, &window);
 381         if(FAILED(hres)) {
 382             nsIDOMHTMLDocument_Release(nshtmldoc);
 383             return E_FAIL;
 384         }
 385
 386         hres = create_doc_from_nsdoc(nshtmldoc, This->element.node.doc->basedoc.doc_obj, window, &content_doc);
 387         nsIDOMHTMLDocument_Release(nshtmldoc);
 388         if(SUCCEEDED(hres))
 389             window_set_docnode(window, content_doc);
 390         else
 391             IHTMLWindow2_Release(HTMLWINDOW2(window));
 392         htmldoc_release(&content_doc->basedoc);
 393         if(FAILED(hres))
 394             return hres;
 395
 396         This->content_window = window;
 397     }
 398
 399     IHTMLWindow2_AddRef(HTMLWINDOW2(This->content_window));
 400     *p = HTMLWINDOW2(This->content_window);
 401     return S_OK;
 402 }
 403
 404 static HRESULT WINAPI HTMLIFrameBase2_put_onload(IHTMLFrameBase2 *iface, VARIANT v)
 405 {
 406     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 407     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 408     return E_NOTIMPL;
 409 }
 410
 411 static HRESULT WINAPI HTMLIFrameBase2_get_onload(IHTMLFrameBase2 *iface, VARIANT *p)
 412 {
 413     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 414     FIXME("(%p)->(%p)\n", This, p);
 415     return E_NOTIMPL;
 416 }
 417
 418 static HRESULT WINAPI HTMLIFrameBase2_put_onreadystatechange(IHTMLFrameBase2 *iface, VARIANT v)
 419 {
 420     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 421     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 422     return E_NOTIMPL;
 423 }
 424
 425 static HRESULT WINAPI HTMLIFrameBase2_get_onreadystatechange(IHTMLFrameBase2 *iface, VARIANT *p)
 426 {
 427     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 428     FIXME("(%p)->(%p)\n", This, p);
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI HTMLIFrameBase2_get_readyState(IHTMLFrameBase2 *iface, BSTR *p)
 433 {
 434     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 435     FIXME("(%p)->(%p)\n", This, p);
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI HTMLIFrameBase2_put_allowTransparency(IHTMLFrameBase2 *iface, VARIANT_BOOL v)
 440 {
 441     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 442     FIXME("(%p)->(%x)\n", This, v);
 443     return E_NOTIMPL;
 444 }
 445
 446 static HRESULT WINAPI HTMLIFrameBase2_get_allowTransparency(IHTMLFrameBase2 *iface, VARIANT_BOOL *p)
 447 {
 448     HTMLIFrame *This = HTMLFRAMEBASE2_THIS(iface);
 449     FIXME("(%p)->(%p)\n", This, p);
 450     return E_NOTIMPL;
 451 }
 452
 453 #undef HTMLFRAMEBASE2_THIS
 454
 455 static const IHTMLFrameBase2Vtbl HTMLIFrameBase2Vtbl = {
 456     HTMLIFrameBase2_QueryInterface,
 457     HTMLIFrameBase2_AddRef,
 458     HTMLIFrameBase2_Release,
 459     HTMLIFrameBase2_GetTypeInfoCount,
 460     HTMLIFrameBase2_GetTypeInfo,
 461     HTMLIFrameBase2_GetIDsOfNames,
 462     HTMLIFrameBase2_Invoke,
 463     HTMLIFrameBase2_get_contentWindow,
 464     HTMLIFrameBase2_put_onload,
 465     HTMLIFrameBase2_get_onload,
 466     HTMLIFrameBase2_put_onreadystatechange,
 467     HTMLIFrameBase2_get_onreadystatechange,
 468     HTMLIFrameBase2_get_readyState,
 469     HTMLIFrameBase2_put_allowTransparency,
 470     HTMLIFrameBase2_get_allowTransparency
 471 };
 472
 473 #define HTMLIFRAME_NODE_THIS(iface) DEFINE_THIS2(HTMLIFrame, element.node, iface)
 474
 475 static HRESULT HTMLIFrame_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 476 {
 477     HTMLIFrame *This = HTMLIFRAME_NODE_THIS(iface);
 478
 479     *ppv = NULL;
 480
 481     if(IsEqualGUID(&IID_IHTMLFrameBase, riid)) {
 482         TRACE("(%p)->(IID_IHTMLFrameBase %p)\n", This, ppv);
 483         *ppv = HTMLFRAMEBASE(This);
 484     }else if(IsEqualGUID(&IID_IHTMLFrameBase2, riid)) {
 485         TRACE("(%p)->(IID_IHTMLFrameBase2 %p)\n", This, ppv);
 486         *ppv = HTMLFRAMEBASE2(This);
 487     }else {
 488         return HTMLElement_QI(&This->element.node, riid, ppv);
 489     }
 490
 491     IUnknown_AddRef((IUnknown*)*ppv);
 492     return S_OK;
 493 }
 494
 495 static void HTMLIFrame_destructor(HTMLDOMNode *iface)
 496 {
 497     HTMLIFrame *This = HTMLIFRAME_NODE_THIS(iface);
 498
 499     if(This->content_window)
 500         IHTMLWindow2_Release(HTMLWINDOW2(This->content_window));
 501     if(This->nsiframe)
 502         nsIDOMHTMLIFrameElement_Release(This->nsiframe);
 503
 504     HTMLElement_destructor(&This->element.node);
 505 }
 506
 507 #undef HTMLIFRAME_NODE_THIS
 508
 509 static const NodeImplVtbl HTMLIFrameImplVtbl = {
 510     HTMLIFrame_QI,
 511     HTMLIFrame_destructor
 512 };
 513
 514 static const tid_t HTMLIFrame_iface_tids[] = {
 515     IHTMLDOMNode_tid,
 516     IHTMLDOMNode2_tid,
 517     IHTMLElement_tid,
 518     IHTMLElement2_tid,
 519     IHTMLElement3_tid,
 520     IHTMLFrameBase_tid,
 521     IHTMLFrameBase2_tid,
 522     0
 523 };
 524
 525 static dispex_static_data_t HTMLIFrame_dispex = {
 526     NULL,
 527     DispHTMLIFrame_tid,
 528     NULL,
 529     HTMLIFrame_iface_tids
 530 };
 531
 532 HTMLElement *HTMLIFrame_Create(nsIDOMHTMLElement *nselem)
 533 {
 534     HTMLIFrame *ret;
 535     nsresult nsres;
 536
 537     ret = heap_alloc_zero(sizeof(HTMLIFrame));
 538
 539     ret->lpIHTMLFrameBaseVtbl = &HTMLIFrameBaseVtbl;
 540     ret->lpIHTMLFrameBase2Vtbl = &HTMLIFrameBase2Vtbl;
 541     ret->element.node.vtbl = &HTMLIFrameImplVtbl;
 542
 543     HTMLElement_Init(&ret->element, &HTMLIFrame_dispex);
 544
 545     nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLIFrameElement, (void**)&ret->nsiframe);
 546     if(NS_FAILED(nsres))
 547         ERR("Could not get nsIDOMHTMLIFrameElement iface: %08x\n", nsres);
 548
 549     return &ret->element;
 550 }