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