dlls/mshtml/htmlframebase.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 HRESULT set_frame_doc(HTMLFrameBase *frame, nsIDOMDocument *nsdoc)
  35 {
  36     nsIDOMWindow *nswindow;
  37     HTMLWindow *window;
  38     HRESULT hres = S_OK;
  39
  40     if(frame->content_window)
  41         return S_OK;
  42
  43     nswindow = get_nsdoc_window(nsdoc);
  44     if(!nswindow)
  45         return E_FAIL;
  46
  47     window = nswindow_to_window(nswindow);
  48     if(!window)
  49         hres = HTMLWindow_Create(frame->element.node.doc->basedoc.doc_obj, nswindow,
  50                 frame->element.node.doc->basedoc.window, &window);
  51     nsIDOMWindow_Release(nswindow);
  52     if(FAILED(hres))
  53         return hres;
  54
  55     frame->content_window = window;
  56     window->frame_element = frame;
  57     return S_OK;
  58 }
  59
  60 #define HTMLFRAMEBASE_THIS(iface) DEFINE_THIS(HTMLFrameBase, IHTMLFrameBase, iface)
  61
  62 static HRESULT WINAPI HTMLFrameBase_QueryInterface(IHTMLFrameBase *iface, REFIID riid, void **ppv)
  63 {
  64     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
  65
  66     return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(&This->element.node), riid, ppv);
  67 }
  68
  69 static ULONG WINAPI HTMLFrameBase_AddRef(IHTMLFrameBase *iface)
  70 {
  71     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
  72
  73     return IHTMLDOMNode_AddRef(HTMLDOMNODE(&This->element.node));
  74 }
  75
  76 static ULONG WINAPI HTMLFrameBase_Release(IHTMLFrameBase *iface)
  77 {
  78     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
  79
  80     return IHTMLDOMNode_Release(HTMLDOMNODE(&This->element.node));
  81 }
  82
  83 static HRESULT WINAPI HTMLFrameBase_GetTypeInfoCount(IHTMLFrameBase *iface, UINT *pctinfo)
  84 {
  85     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
  86
  87     return IDispatchEx_GetTypeInfoCount(DISPATCHEX(&This->element.node.dispex), pctinfo);
  88 }
  89
  90 static HRESULT WINAPI HTMLFrameBase_GetTypeInfo(IHTMLFrameBase *iface, UINT iTInfo,
  91         LCID lcid, ITypeInfo **ppTInfo)
  92 {
  93     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
  94
  95     return IDispatchEx_GetTypeInfo(DISPATCHEX(&This->element.node.dispex), iTInfo, lcid, ppTInfo);
  96 }
  97
  98 static HRESULT WINAPI HTMLFrameBase_GetIDsOfNames(IHTMLFrameBase *iface, REFIID riid,
  99         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 100 {
 101     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 102
 103     return IDispatchEx_GetIDsOfNames(DISPATCHEX(&This->element.node.dispex), riid, rgszNames,
 104             cNames, lcid, rgDispId);
 105 }
 106
 107 static HRESULT WINAPI HTMLFrameBase_Invoke(IHTMLFrameBase *iface, DISPID dispIdMember,
 108         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 109         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 110 {
 111     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 112
 113     return IDispatchEx_Invoke(DISPATCHEX(&This->element.node.dispex), dispIdMember, riid, lcid,
 114             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 115 }
 116
 117 static HRESULT WINAPI HTMLFrameBase_put_src(IHTMLFrameBase *iface, BSTR v)
 118 {
 119     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 120
 121     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 122
 123     if(!This->content_window || !This->element.node.doc || !This->element.node.doc->basedoc.window) {
 124         FIXME("detached element\n");
 125         return E_FAIL;
 126     }
 127
 128     return navigate_url(This->content_window, v, This->element.node.doc->basedoc.window->url);
 129 }
 130
 131 static HRESULT WINAPI HTMLFrameBase_get_src(IHTMLFrameBase *iface, BSTR *p)
 132 {
 133     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 134     FIXME("(%p)->(%p)\n", This, p);
 135     return E_NOTIMPL;
 136 }
 137
 138 static HRESULT WINAPI HTMLFrameBase_put_name(IHTMLFrameBase *iface, BSTR v)
 139 {
 140     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 141     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI HTMLFrameBase_get_name(IHTMLFrameBase *iface, BSTR *p)
 146 {
 147     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 148     FIXME("(%p)->(%p)\n", This, p);
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI HTMLFrameBase_put_border(IHTMLFrameBase *iface, VARIANT v)
 153 {
 154     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 155     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI HTMLFrameBase_get_border(IHTMLFrameBase *iface, VARIANT *p)
 160 {
 161     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 162     FIXME("(%p)->(%p)\n", This, p);
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI HTMLFrameBase_put_frameBorder(IHTMLFrameBase *iface, BSTR v)
 167 {
 168     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 169     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT WINAPI HTMLFrameBase_get_frameBorder(IHTMLFrameBase *iface, BSTR *p)
 174 {
 175     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 176     FIXME("(%p)->(%p)\n", This, p);
 177     return E_NOTIMPL;
 178 }
 179
 180 static HRESULT WINAPI HTMLFrameBase_put_frameSpacing(IHTMLFrameBase *iface, VARIANT v)
 181 {
 182     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 183     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI HTMLFrameBase_get_frameSpacing(IHTMLFrameBase *iface, VARIANT *p)
 188 {
 189     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 190     FIXME("(%p)->(%p)\n", This, p);
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI HTMLFrameBase_put_marginWidth(IHTMLFrameBase *iface, VARIANT v)
 195 {
 196     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 197     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 198     return E_NOTIMPL;
 199 }
 200
 201 static HRESULT WINAPI HTMLFrameBase_get_marginWidth(IHTMLFrameBase *iface, VARIANT *p)
 202 {
 203     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 204     FIXME("(%p)->(%p)\n", This, p);
 205     return E_NOTIMPL;
 206 }
 207
 208 static HRESULT WINAPI HTMLFrameBase_put_marginHeight(IHTMLFrameBase *iface, VARIANT v)
 209 {
 210     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 211     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 212     return E_NOTIMPL;
 213 }
 214
 215 static HRESULT WINAPI HTMLFrameBase_get_marginHeight(IHTMLFrameBase *iface, VARIANT *p)
 216 {
 217     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 218     FIXME("(%p)->(%p)\n", This, p);
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI HTMLFrameBase_put_noResize(IHTMLFrameBase *iface, VARIANT_BOOL v)
 223 {
 224     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 225     FIXME("(%p)->(%x)\n", This, v);
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI HTMLFrameBase_get_noResize(IHTMLFrameBase *iface, VARIANT_BOOL *p)
 230 {
 231     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 232     FIXME("(%p)->(%p)\n", This, p);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI HTMLFrameBase_put_scrolling(IHTMLFrameBase *iface, BSTR v)
 237 {
 238     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 239     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 240     return E_NOTIMPL;
 241 }
 242
 243 static HRESULT WINAPI HTMLFrameBase_get_scrolling(IHTMLFrameBase *iface, BSTR *p)
 244 {
 245     HTMLFrameBase *This = HTMLFRAMEBASE_THIS(iface);
 246     FIXME("(%p)->(%p)\n", This, p);
 247     return E_NOTIMPL;
 248 }
 249
 250 static const IHTMLFrameBaseVtbl HTMLFrameBaseVtbl = {
 251     HTMLFrameBase_QueryInterface,
 252     HTMLFrameBase_AddRef,
 253     HTMLFrameBase_Release,
 254     HTMLFrameBase_GetTypeInfoCount,
 255     HTMLFrameBase_GetTypeInfo,
 256     HTMLFrameBase_GetIDsOfNames,
 257     HTMLFrameBase_Invoke,
 258     HTMLFrameBase_put_src,
 259     HTMLFrameBase_get_src,
 260     HTMLFrameBase_put_name,
 261     HTMLFrameBase_get_name,
 262     HTMLFrameBase_put_border,
 263     HTMLFrameBase_get_border,
 264     HTMLFrameBase_put_frameBorder,
 265     HTMLFrameBase_get_frameBorder,
 266     HTMLFrameBase_put_frameSpacing,
 267     HTMLFrameBase_get_frameSpacing,
 268     HTMLFrameBase_put_marginWidth,
 269     HTMLFrameBase_get_marginWidth,
 270     HTMLFrameBase_put_marginHeight,
 271     HTMLFrameBase_get_marginHeight,
 272     HTMLFrameBase_put_noResize,
 273     HTMLFrameBase_get_noResize,
 274     HTMLFrameBase_put_scrolling,
 275     HTMLFrameBase_get_scrolling
 276 };
 277
 278 #define HTMLFRAMEBASE2_THIS(iface) DEFINE_THIS(HTMLFrameBase, IHTMLFrameBase2, iface)
 279
 280 static HRESULT WINAPI HTMLFrameBase2_QueryInterface(IHTMLFrameBase2 *iface, REFIID riid, void **ppv)
 281 {
 282     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 283
 284     return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(&This->element.node), riid, ppv);
 285 }
 286
 287 static ULONG WINAPI HTMLFrameBase2_AddRef(IHTMLFrameBase2 *iface)
 288 {
 289     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 290
 291     return IHTMLDOMNode_AddRef(HTMLDOMNODE(&This->element.node));
 292 }
 293
 294 static ULONG WINAPI HTMLFrameBase2_Release(IHTMLFrameBase2 *iface)
 295 {
 296     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 297
 298     return IHTMLDOMNode_Release(HTMLDOMNODE(&This->element.node));
 299 }
 300
 301 static HRESULT WINAPI HTMLFrameBase2_GetTypeInfoCount(IHTMLFrameBase2 *iface, UINT *pctinfo)
 302 {
 303     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 304     FIXME("(%p)\n", This);
 305     return E_NOTIMPL;
 306 }
 307
 308 static HRESULT WINAPI HTMLFrameBase2_GetTypeInfo(IHTMLFrameBase2 *iface, UINT iTInfo,
 309         LCID lcid, ITypeInfo **ppTInfo)
 310 {
 311     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 312     FIXME("(%p)\n", This);
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI HTMLFrameBase2_GetIDsOfNames(IHTMLFrameBase2 *iface, REFIID riid,
 317         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 318 {
 319     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 320     FIXME("(%p)\n", This);
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI HTMLFrameBase2_Invoke(IHTMLFrameBase2 *iface, DISPID dispIdMember,
 325         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 326         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 327 {
 328     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 329     FIXME("(%p)\n", This);
 330     return E_NOTIMPL;
 331 }
 332
 333 static HRESULT WINAPI HTMLFrameBase2_get_contentWindow(IHTMLFrameBase2 *iface, IHTMLWindow2 **p)
 334 {
 335     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 336
 337     TRACE("(%p)->(%p)\n", This, p);
 338
 339     if(This->content_window) {
 340         IHTMLWindow2_AddRef(HTMLWINDOW2(This->content_window));
 341         *p = HTMLWINDOW2(This->content_window);
 342     }else {
 343         WARN("NULL content window\n");
 344         *p = NULL;
 345     }
 346     return S_OK;
 347 }
 348
 349 static HRESULT WINAPI HTMLFrameBase2_put_onload(IHTMLFrameBase2 *iface, VARIANT v)
 350 {
 351     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 352     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT WINAPI HTMLFrameBase2_get_onload(IHTMLFrameBase2 *iface, VARIANT *p)
 357 {
 358     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 359     FIXME("(%p)->(%p)\n", This, p);
 360     return E_NOTIMPL;
 361 }
 362
 363 static HRESULT WINAPI HTMLFrameBase2_put_onreadystatechange(IHTMLFrameBase2 *iface, VARIANT v)
 364 {
 365     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 366     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT WINAPI HTMLFrameBase2_get_onreadystatechange(IHTMLFrameBase2 *iface, VARIANT *p)
 371 {
 372     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 373     FIXME("(%p)->(%p)\n", This, p);
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT WINAPI HTMLFrameBase2_get_readyState(IHTMLFrameBase2 *iface, BSTR *p)
 378 {
 379     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 380
 381     TRACE("(%p)->(%p)\n", This, p);
 382
 383     if(!This->content_window || !This->content_window->doc) {
 384         FIXME("no document associated\n");
 385         return E_FAIL;
 386     }
 387
 388     return IHTMLDocument2_get_readyState(HTMLDOC(&This->content_window->doc->basedoc), p);
 389 }
 390
 391 static HRESULT WINAPI HTMLFrameBase2_put_allowTransparency(IHTMLFrameBase2 *iface, VARIANT_BOOL v)
 392 {
 393     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 394     FIXME("(%p)->(%x)\n", This, v);
 395     return E_NOTIMPL;
 396 }
 397
 398 static HRESULT WINAPI HTMLFrameBase2_get_allowTransparency(IHTMLFrameBase2 *iface, VARIANT_BOOL *p)
 399 {
 400     HTMLFrameBase *This = HTMLFRAMEBASE2_THIS(iface);
 401     FIXME("(%p)->(%p)\n", This, p);
 402     return E_NOTIMPL;
 403 }
 404
 405 #undef HTMLFRAMEBASE2_THIS
 406
 407 static const IHTMLFrameBase2Vtbl HTMLFrameBase2Vtbl = {
 408     HTMLFrameBase2_QueryInterface,
 409     HTMLFrameBase2_AddRef,
 410     HTMLFrameBase2_Release,
 411     HTMLFrameBase2_GetTypeInfoCount,
 412     HTMLFrameBase2_GetTypeInfo,
 413     HTMLFrameBase2_GetIDsOfNames,
 414     HTMLFrameBase2_Invoke,
 415     HTMLFrameBase2_get_contentWindow,
 416     HTMLFrameBase2_put_onload,
 417     HTMLFrameBase2_get_onload,
 418     HTMLFrameBase2_put_onreadystatechange,
 419     HTMLFrameBase2_get_onreadystatechange,
 420     HTMLFrameBase2_get_readyState,
 421     HTMLFrameBase2_put_allowTransparency,
 422     HTMLFrameBase2_get_allowTransparency
 423 };
 424
 425 HRESULT HTMLFrameBase_QI(HTMLFrameBase *This, REFIID riid, void **ppv)
 426 {
 427     if(IsEqualGUID(&IID_IHTMLFrameBase, riid)) {
 428         TRACE("(%p)->(IID_IHTMLFrameBase %p)\n", This, ppv);
 429         *ppv = HTMLFRAMEBASE(This);
 430     }else if(IsEqualGUID(&IID_IHTMLFrameBase2, riid)) {
 431         TRACE("(%p)->(IID_IHTMLFrameBase2 %p)\n", This, ppv);
 432         *ppv = HTMLFRAMEBASE2(This);
 433     }else {
 434         return HTMLElement_QI(&This->element.node, riid, ppv);
 435     }
 436
 437     IUnknown_AddRef((IUnknown*)*ppv);
 438     return S_OK;
 439 }
 440
 441 void HTMLFrameBase_destructor(HTMLFrameBase *This)
 442 {
 443     if(This->content_window)
 444         This->content_window->frame_element = NULL;
 445
 446     HTMLElement_destructor(&This->element.node);
 447 }
 448
 449 void HTMLFrameBase_Init(HTMLFrameBase *This, HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem,
 450         dispex_static_data_t *dispex_data)
 451 {
 452     This->lpIHTMLFrameBaseVtbl = &HTMLFrameBaseVtbl;
 453     This->lpIHTMLFrameBase2Vtbl = &HTMLFrameBase2Vtbl;
 454
 455     HTMLElement_Init(&This->element, doc, nselem, dispex_data);
 456 }
 457
 458 typedef struct {
 459     HTMLFrameBase framebase;
 460 } HTMLFrameElement;
 461
 462 #define HTMLFRAME_NODE_THIS(iface) DEFINE_THIS2(HTMLFrameElement, framebase.element.node, iface)
 463
 464 static HRESULT HTMLFrameElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
 465 {
 466     HTMLFrameElement *This = HTMLFRAME_NODE_THIS(iface);
 467
 468     return HTMLFrameBase_QI(&This->framebase, riid, ppv);
 469 }
 470
 471 static void HTMLFrameElement_destructor(HTMLDOMNode *iface)
 472 {
 473     HTMLFrameElement *This = HTMLFRAME_NODE_THIS(iface);
 474
 475     HTMLFrameBase_destructor(&This->framebase);
 476 }
 477
 478 static HRESULT HTMLFrameElement_get_document(HTMLDOMNode *iface, IDispatch **p)
 479 {
 480     HTMLFrameElement *This = HTMLFRAME_NODE_THIS(iface);
 481
 482     if(!This->framebase.content_window || !This->framebase.content_window->doc) {
 483         *p = NULL;
 484         return S_OK;
 485     }
 486
 487     *p = (IDispatch*)HTMLDOC(&This->framebase.content_window->doc->basedoc);
 488     IDispatch_AddRef(*p);
 489     return S_OK;
 490 }
 491
 492 static HRESULT HTMLFrameElement_bind_to_tree(HTMLDOMNode *iface)
 493 {
 494     HTMLFrameElement *This = HTMLFRAME_NODE_THIS(iface);
 495     nsIDOMHTMLFrameElement *nsframe;
 496     nsIDOMDocument *nsdoc;
 497     nsresult nsres;
 498     HRESULT hres;
 499
 500     nsres = nsIDOMHTMLElement_QueryInterface(This->framebase.element.nselem, &IID_nsIDOMHTMLFrameElement, (void**)&nsframe);
 501     if(NS_FAILED(nsres))
 502         return E_FAIL;
 503
 504     nsres = nsIDOMHTMLFrameElement_GetContentDocument(nsframe, &nsdoc);
 505     nsIDOMHTMLFrameElement_Release(nsframe);
 506     if(NS_FAILED(nsres) || !nsdoc) {
 507         ERR("GetContentDocument failed: %08x\n", nsres);
 508         return E_FAIL;
 509     }
 510
 511     hres = set_frame_doc(&This->framebase, nsdoc);
 512     nsIDOMDocument_Release(nsdoc);
 513     return hres;
 514 }
 515
 516 #undef HTMLFRAME_NODE_THIS
 517
 518 static const NodeImplVtbl HTMLFrameElementImplVtbl = {
 519     HTMLFrameElement_QI,
 520     HTMLFrameElement_destructor,
 521     NULL,
 522     NULL,
 523     NULL,
 524     NULL,
 525     HTMLFrameElement_get_document,
 526     NULL,
 527     NULL,
 528     NULL,
 529     HTMLFrameElement_bind_to_tree
 530 };
 531
 532 HTMLElement *HTMLFrameElement_Create(HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem)
 533 {
 534     nsIDOMHTMLFrameElement *nsframe;
 535     HTMLFrameElement *ret;
 536     nsresult nsres;
 537
 538     ret = heap_alloc_zero(sizeof(HTMLFrameElement));
 539
 540     ret->framebase.element.node.vtbl = &HTMLFrameElementImplVtbl;
 541
 542     nsres = nsIDOMHTMLElement_QueryInterface(nselem, &IID_nsIDOMHTMLFrameElement, (void**)&nsframe);
 543     if(NS_FAILED(nsres))
 544         ERR("Could not get nsIDOMHTMLFrameElement iface: %08x\n", nsres);
 545
 546     HTMLFrameBase_Init(&ret->framebase, doc, nselem, NULL);
 547
 548     return &ret->framebase.element;
 549 }