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