dlls/mshtml/htmlwindow.c

   1 /*
   2  * Copyright 2006-2012 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 #include <assert.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28 #include "mshtmdid.h"
  29 #include "shlguid.h"
  30 #include "shobjidl.h"
  31 #include "exdispid.h"
  32
  33 #define NO_SHLWAPI_REG
  34 #include "shlwapi.h"
  35
  36 #include "wine/debug.h"
  37
  38 #include "mshtml_private.h"
  39 #include "htmlevent.h"
  40 #include "htmlscript.h"
  41 #include "pluginhost.h"
  42 #include "binding.h"
  43 #include "resource.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  46
  47 static int window_map_compare(const void *key, const struct wine_rb_entry *entry)
  48 {
  49     HTMLOuterWindow *window = WINE_RB_ENTRY_VALUE(entry, HTMLOuterWindow, entry);
  50
  51     if(window->window_proxy == key)
  52         return 0;
  53     return (void*)window->window_proxy > key ? -1 : 1;
  54 }
  55
  56 static struct wine_rb_tree window_map = { window_map_compare };
  57
  58 HTMLOuterWindow *mozwindow_to_window(const mozIDOMWindowProxy *mozwindow)
  59 {
  60     struct wine_rb_entry *entry = wine_rb_get(&window_map, mozwindow);
  61     return entry ? WINE_RB_ENTRY_VALUE(entry, HTMLOuterWindow, entry) : NULL;
  62 }
  63
  64 static inline BOOL is_outer_window(HTMLWindow *window)
  65 {
  66     return &window->outer_window->base == window;
  67 }
  68
  69 static void release_children(HTMLOuterWindow *This)
  70 {
  71     HTMLOuterWindow *child;
  72
  73     while(!list_empty(&This->children)) {
  74         child = LIST_ENTRY(list_tail(&This->children), HTMLOuterWindow, sibling_entry);
  75
  76         list_remove(&child->sibling_entry);
  77         child->parent = NULL;
  78         IHTMLWindow2_Release(&child->base.IHTMLWindow2_iface);
  79     }
  80 }
  81
  82 static HRESULT get_location(HTMLInnerWindow *This, HTMLLocation **ret)
  83 {
  84     if(This->location) {
  85         IHTMLLocation_AddRef(&This->location->IHTMLLocation_iface);
  86     }else {
  87         HRESULT hres;
  88
  89         hres = HTMLLocation_Create(This, &This->location);
  90         if(FAILED(hres))
  91             return hres;
  92     }
  93
  94     *ret = This->location;
  95     return S_OK;
  96 }
  97
  98 void get_top_window(HTMLOuterWindow *window, HTMLOuterWindow **ret)
  99 {
 100     HTMLOuterWindow *iter;
 101
 102     for(iter = window; iter->parent; iter = iter->parent);
 103     *ret = iter;
 104 }
 105
 106 static inline HRESULT set_window_event(HTMLWindow *window, eventid_t eid, VARIANT *var)
 107 {
 108     if(!window->inner_window->doc) {
 109         FIXME("No document\n");
 110         return E_FAIL;
 111     }
 112
 113     return set_event_handler(&window->inner_window->event_target, eid, var);
 114 }
 115
 116 static inline HRESULT get_window_event(HTMLWindow *window, eventid_t eid, VARIANT *var)
 117 {
 118     if(!window->inner_window->doc) {
 119         FIXME("No document\n");
 120         return E_FAIL;
 121     }
 122
 123     return get_event_handler(&window->inner_window->event_target, eid, var);
 124 }
 125
 126 static void detach_inner_window(HTMLInnerWindow *window)
 127 {
 128     HTMLOuterWindow *outer_window = window->base.outer_window;
 129
 130     if(outer_window && outer_window->doc_obj && outer_window == outer_window->doc_obj->basedoc.window)
 131         window->doc->basedoc.cp_container.forward_container = NULL;
 132
 133     if(window->doc) {
 134         detach_events(window->doc);
 135         while(!list_empty(&window->doc->plugin_hosts))
 136             detach_plugin_host(LIST_ENTRY(list_head(&window->doc->plugin_hosts), PluginHost, entry));
 137     }
 138
 139     abort_window_bindings(window);
 140     remove_target_tasks(window->task_magic);
 141     release_script_hosts(window);
 142     window->base.outer_window = NULL;
 143
 144     if(outer_window && outer_window->base.inner_window == window) {
 145         outer_window->base.inner_window = NULL;
 146         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
 147     }
 148 }
 149
 150 static inline HTMLWindow *impl_from_IHTMLWindow2(IHTMLWindow2 *iface)
 151 {
 152     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow2_iface);
 153 }
 154
 155 static HRESULT WINAPI HTMLWindow2_QueryInterface(IHTMLWindow2 *iface, REFIID riid, void **ppv)
 156 {
 157     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 158
 159     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 160
 161     if(IsEqualGUID(&IID_IUnknown, riid)) {
 162         *ppv = &This->IHTMLWindow2_iface;
 163     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 164         *ppv = &This->IHTMLWindow2_iface;
 165     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 166         *ppv = &This->IDispatchEx_iface;
 167     }else if(IsEqualGUID(&IID_IHTMLFramesCollection2, riid)) {
 168         *ppv = &This->IHTMLWindow2_iface;
 169     }else if(IsEqualGUID(&IID_IHTMLWindow2, riid)) {
 170         *ppv = &This->IHTMLWindow2_iface;
 171     }else if(IsEqualGUID(&IID_IHTMLWindow3, riid)) {
 172         *ppv = &This->IHTMLWindow3_iface;
 173     }else if(IsEqualGUID(&IID_IHTMLWindow4, riid)) {
 174         *ppv = &This->IHTMLWindow4_iface;
 175     }else if(IsEqualGUID(&IID_IHTMLWindow5, riid)) {
 176         *ppv = &This->IHTMLWindow5_iface;
 177     }else if(IsEqualGUID(&IID_IHTMLWindow6, riid)) {
 178         *ppv = &This->IHTMLWindow6_iface;
 179     }else if(IsEqualGUID(&IID_IHTMLWindow7, riid)) {
 180         *ppv = &This->IHTMLWindow7_iface;
 181     }else if(IsEqualGUID(&IID_IHTMLPrivateWindow, riid)) {
 182         *ppv = &This->IHTMLPrivateWindow_iface;
 183     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 184         *ppv = &This->IServiceProvider_iface;
 185     }else if(IsEqualGUID(&IID_ITravelLogClient, riid)) {
 186         *ppv = &This->ITravelLogClient_iface;
 187     }else if(IsEqualGUID(&IID_IObjectIdentity, riid)) {
 188         *ppv = &This->IObjectIdentity_iface;
 189     }else if(IsEqualGUID(&IID_IProvideClassInfo, riid)) {
 190         *ppv = &This->IProvideMultipleClassInfo_iface;
 191     }else if(IsEqualGUID(&IID_IProvideClassInfo2, riid)) {
 192         *ppv = &This->IProvideMultipleClassInfo_iface;
 193     }else if(IsEqualGUID(&IID_IProvideMultipleClassInfo, riid)) {
 194         *ppv = &This->IProvideMultipleClassInfo_iface;
 195     }else if(IsEqualGUID(&IID_IMarshal, riid)) {
 196         *ppv = NULL;
 197         FIXME("(%p)->(IID_IMarshal %p)\n", This, ppv);
 198         return E_NOINTERFACE;
 199     }else if(dispex_query_interface(&This->inner_window->event_target.dispex, riid, ppv)) {
 200         assert(!*ppv);
 201         return E_NOINTERFACE;
 202     }else {
 203         return EventTarget_QI(&This->inner_window->event_target, riid, ppv);
 204     }
 205
 206     IUnknown_AddRef((IUnknown*)*ppv);
 207     return S_OK;
 208 }
 209
 210 static ULONG WINAPI HTMLWindow2_AddRef(IHTMLWindow2 *iface)
 211 {
 212     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 213     LONG ref = InterlockedIncrement(&This->ref);
 214
 215     TRACE("(%p) ref=%d\n", This, ref);
 216
 217     return ref;
 218 }
 219
 220 static void release_outer_window(HTMLOuterWindow *This)
 221 {
 222     if(This->pending_window) {
 223         abort_window_bindings(This->pending_window);
 224         This->pending_window->base.outer_window = NULL;
 225         IHTMLWindow2_Release(&This->pending_window->base.IHTMLWindow2_iface);
 226     }
 227
 228     remove_target_tasks(This->task_magic);
 229     set_current_mon(This, NULL, 0);
 230     set_current_uri(This, NULL);
 231     if(This->base.inner_window)
 232         detach_inner_window(This->base.inner_window);
 233     release_children(This);
 234
 235     if(This->secmgr)
 236         IInternetSecurityManager_Release(This->secmgr);
 237
 238     if(This->frame_element)
 239         This->frame_element->content_window = NULL;
 240
 241     This->window_ref->window = NULL;
 242     windowref_release(This->window_ref);
 243
 244     if(This->nswindow)
 245         nsIDOMWindow_Release(This->nswindow);
 246     if(This->window_proxy)
 247         mozIDOMWindowProxy_Release(This->window_proxy);
 248
 249     wine_rb_remove(&window_map, &This->entry);
 250     heap_free(This);
 251 }
 252
 253 static void release_inner_window(HTMLInnerWindow *This)
 254 {
 255     unsigned i;
 256
 257     TRACE("%p\n", This);
 258
 259     detach_inner_window(This);
 260
 261     if(This->doc) {
 262         This->doc->window = NULL;
 263         htmldoc_release(&This->doc->basedoc);
 264     }
 265
 266     release_event_target(&This->event_target);
 267     release_dispex(&This->event_target.dispex);
 268
 269     for(i=0; i < This->global_prop_cnt; i++)
 270         heap_free(This->global_props[i].name);
 271     heap_free(This->global_props);
 272
 273     if(This->location) {
 274         This->location->window = NULL;
 275         IHTMLLocation_Release(&This->location->IHTMLLocation_iface);
 276     }
 277
 278     if(This->image_factory) {
 279         This->image_factory->window = NULL;
 280         IHTMLImageElementFactory_Release(&This->image_factory->IHTMLImageElementFactory_iface);
 281     }
 282
 283     if(This->option_factory) {
 284         This->option_factory->window = NULL;
 285         IHTMLOptionElementFactory_Release(&This->option_factory->IHTMLOptionElementFactory_iface);
 286     }
 287
 288     if(This->xhr_factory) {
 289         This->xhr_factory->window = NULL;
 290         IHTMLXMLHttpRequestFactory_Release(&This->xhr_factory->IHTMLXMLHttpRequestFactory_iface);
 291     }
 292
 293     if(This->screen)
 294         IHTMLScreen_Release(This->screen);
 295
 296     if(This->history) {
 297         This->history->window = NULL;
 298         IOmHistory_Release(&This->history->IOmHistory_iface);
 299     }
 300
 301     if(This->session_storage)
 302         IHTMLStorage_Release(This->session_storage);
 303
 304     if(This->mon)
 305         IMoniker_Release(This->mon);
 306
 307     heap_free(This);
 308 }
 309
 310 static ULONG WINAPI HTMLWindow2_Release(IHTMLWindow2 *iface)
 311 {
 312     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 313     LONG ref = InterlockedDecrement(&This->ref);
 314
 315     TRACE("(%p) ref=%d\n", This, ref);
 316
 317     if(!ref) {
 318         if(is_outer_window(This))
 319             release_outer_window(This->outer_window);
 320         else
 321             release_inner_window(This->inner_window);
 322     }
 323
 324     return ref;
 325 }
 326
 327 static HRESULT WINAPI HTMLWindow2_GetTypeInfoCount(IHTMLWindow2 *iface, UINT *pctinfo)
 328 {
 329     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 330
 331     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
 332 }
 333
 334 static HRESULT WINAPI HTMLWindow2_GetTypeInfo(IHTMLWindow2 *iface, UINT iTInfo,
 335                                               LCID lcid, ITypeInfo **ppTInfo)
 336 {
 337     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 338
 339     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 340 }
 341
 342 static HRESULT WINAPI HTMLWindow2_GetIDsOfNames(IHTMLWindow2 *iface, REFIID riid,
 343                                                 LPOLESTR *rgszNames, UINT cNames,
 344                                                 LCID lcid, DISPID *rgDispId)
 345 {
 346     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 347
 348     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
 349             rgDispId);
 350 }
 351
 352 static HRESULT WINAPI HTMLWindow2_Invoke(IHTMLWindow2 *iface, DISPID dispIdMember,
 353                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 354                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 355 {
 356     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 357
 358     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 359             pDispParams, pVarResult, pExcepInfo, puArgErr);
 360 }
 361
 362 static HRESULT get_frame_by_index(HTMLOuterWindow *This, UINT32 index, HTMLOuterWindow **ret)
 363 {
 364     nsIDOMWindowCollection *nsframes;
 365     mozIDOMWindowProxy *mozwindow;
 366     UINT32 length;
 367     nsresult nsres;
 368
 369     nsres = nsIDOMWindow_GetFrames(This->nswindow, &nsframes);
 370     if(NS_FAILED(nsres)) {
 371         FIXME("nsIDOMWindow_GetFrames failed: 0x%08x\n", nsres);
 372         return E_FAIL;
 373     }
 374
 375     nsres = nsIDOMWindowCollection_GetLength(nsframes, &length);
 376     assert(nsres == NS_OK);
 377
 378     if(index >= length) {
 379         nsIDOMWindowCollection_Release(nsframes);
 380         return DISP_E_MEMBERNOTFOUND;
 381     }
 382
 383     nsres = nsIDOMWindowCollection_Item(nsframes, index, &mozwindow);
 384     nsIDOMWindowCollection_Release(nsframes);
 385     if(NS_FAILED(nsres)) {
 386         FIXME("nsIDOMWindowCollection_Item failed: 0x%08x\n", nsres);
 387         return E_FAIL;
 388     }
 389
 390     *ret = mozwindow_to_window(mozwindow);
 391
 392     mozIDOMWindowProxy_Release(mozwindow);
 393     return S_OK;
 394 }
 395
 396 HRESULT get_frame_by_name(HTMLOuterWindow *This, const WCHAR *name, BOOL deep, HTMLOuterWindow **ret)
 397 {
 398     nsIDOMWindowCollection *nsframes;
 399     HTMLOuterWindow *window = NULL;
 400     mozIDOMWindowProxy *mozwindow;
 401     nsAString name_str;
 402     UINT32 length, i;
 403     nsresult nsres;
 404     HRESULT hres = S_OK;
 405
 406     nsres = nsIDOMWindow_GetFrames(This->nswindow, &nsframes);
 407     if(NS_FAILED(nsres)) {
 408         FIXME("nsIDOMWindow_GetFrames failed: 0x%08x\n", nsres);
 409         return E_FAIL;
 410     }
 411
 412     if(!nsframes) {
 413         WARN("nsIDOMWindow_GetFrames returned NULL nsframes: %p\n", This->nswindow);
 414         return DISP_E_MEMBERNOTFOUND;
 415     }
 416
 417     nsAString_InitDepend(&name_str, name);
 418     nsres = nsIDOMWindowCollection_NamedItem(nsframes, &name_str, &mozwindow);
 419     nsAString_Finish(&name_str);
 420     if(NS_FAILED(nsres)) {
 421         nsIDOMWindowCollection_Release(nsframes);
 422         return E_FAIL;
 423     }
 424
 425     if(mozwindow) {
 426         *ret = mozwindow_to_window(mozwindow);
 427         return S_OK;
 428     }
 429
 430     nsres = nsIDOMWindowCollection_GetLength(nsframes, &length);
 431     assert(nsres == NS_OK);
 432
 433     for(i = 0; i < length && !window; ++i) {
 434         HTMLOuterWindow *window_iter;
 435         BSTR id;
 436
 437         nsres = nsIDOMWindowCollection_Item(nsframes, i, &mozwindow);
 438         if(NS_FAILED(nsres)) {
 439             FIXME("nsIDOMWindowCollection_Item failed: 0x%08x\n", nsres);
 440             hres = E_FAIL;
 441             break;
 442         }
 443
 444         window_iter = mozwindow_to_window(mozwindow);
 445
 446         mozIDOMWindowProxy_Release(mozwindow);
 447
 448         if(!window_iter) {
 449             WARN("nsIDOMWindow without HTMLOuterWindow: %p\n", mozwindow);
 450             continue;
 451         }
 452
 453         hres = IHTMLElement_get_id(&window_iter->frame_element->element.IHTMLElement_iface, &id);
 454         if(FAILED(hres)) {
 455             FIXME("IHTMLElement_get_id failed: 0x%08x\n", hres);
 456             break;
 457         }
 458
 459         if(id && !strcmpiW(id, name))
 460             window = window_iter;
 461
 462         SysFreeString(id);
 463
 464         if(!window && deep)
 465             get_frame_by_name(window_iter, name, TRUE, &window);
 466     }
 467
 468     nsIDOMWindowCollection_Release(nsframes);
 469     if(FAILED(hres))
 470         return hres;
 471
 472     *ret = window;
 473     return S_OK;
 474 }
 475
 476 static HRESULT WINAPI HTMLWindow2_item(IHTMLWindow2 *iface, VARIANT *pvarIndex, VARIANT *pvarResult)
 477 {
 478     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 479     HTMLOuterWindow *window = NULL;
 480     HRESULT hres;
 481
 482     TRACE("(%p)->(%p %p)\n", This, pvarIndex, pvarResult);
 483
 484     switch(V_VT(pvarIndex)) {
 485     case VT_I4: {
 486         int index = V_I4(pvarIndex);
 487         TRACE("Getting index %d\n", index);
 488         if(index < 0)
 489             return DISP_E_MEMBERNOTFOUND;
 490         hres = get_frame_by_index(This->outer_window, index, &window);
 491         break;
 492     }
 493     case VT_UINT: {
 494         unsigned int index = V_UINT(pvarIndex);
 495         TRACE("Getting index %u\n", index);
 496         hres = get_frame_by_index(This->outer_window, index, &window);
 497         break;
 498     }
 499     case VT_BSTR: {
 500         BSTR str = V_BSTR(pvarIndex);
 501         TRACE("Getting name %s\n", wine_dbgstr_w(str));
 502         hres = get_frame_by_name(This->outer_window, str, FALSE, &window);
 503         break;
 504     }
 505     default:
 506         WARN("Invalid index %s\n", debugstr_variant(pvarIndex));
 507         return E_INVALIDARG;
 508     }
 509
 510     if(FAILED(hres))
 511         return hres;
 512     if(!window)
 513         return DISP_E_MEMBERNOTFOUND;
 514
 515     IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
 516     V_VT(pvarResult) = VT_DISPATCH;
 517     V_DISPATCH(pvarResult) = (IDispatch*)window;
 518     return S_OK;
 519 }
 520
 521 static HRESULT WINAPI HTMLWindow2_get_length(IHTMLWindow2 *iface, LONG *p)
 522 {
 523     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 524     nsIDOMWindowCollection *nscollection;
 525     UINT32 length;
 526     nsresult nsres;
 527
 528     TRACE("(%p)->(%p)\n", This, p);
 529
 530     nsres = nsIDOMWindow_GetFrames(This->outer_window->nswindow, &nscollection);
 531     if(NS_FAILED(nsres)) {
 532         ERR("GetFrames failed: %08x\n", nsres);
 533         return E_FAIL;
 534     }
 535
 536     nsres = nsIDOMWindowCollection_GetLength(nscollection, &length);
 537     nsIDOMWindowCollection_Release(nscollection);
 538     if(NS_FAILED(nsres)) {
 539         ERR("GetLength failed: %08x\n", nsres);
 540         return E_FAIL;
 541     }
 542
 543     *p = length;
 544     return S_OK;
 545 }
 546
 547 static HRESULT WINAPI HTMLWindow2_get_frames(IHTMLWindow2 *iface, IHTMLFramesCollection2 **p)
 548 {
 549     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 550     FIXME("(%p)->(%p): semi-stub\n", This, p);
 551
 552     /* FIXME: Should return a separate Window object */
 553     *p = (IHTMLFramesCollection2*)&This->IHTMLWindow2_iface;
 554     IHTMLWindow2_AddRef(iface);
 555     return S_OK;
 556 }
 557
 558 static HRESULT WINAPI HTMLWindow2_put_defaultStatus(IHTMLWindow2 *iface, BSTR v)
 559 {
 560     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 561     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 562     return E_NOTIMPL;
 563 }
 564
 565 static HRESULT WINAPI HTMLWindow2_get_defaultStatus(IHTMLWindow2 *iface, BSTR *p)
 566 {
 567     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 568     FIXME("(%p)->(%p)\n", This, p);
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI HTMLWindow2_put_status(IHTMLWindow2 *iface, BSTR v)
 573 {
 574     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 575
 576     WARN("(%p)->(%s)\n", This, debugstr_w(v));
 577
 578     /*
 579      * FIXME: Since IE7, setting status is blocked, but still possible in certain circumstances.
 580      * Ignoring the call should be enough for us.
 581      */
 582     return S_OK;
 583 }
 584
 585 static HRESULT WINAPI HTMLWindow2_get_status(IHTMLWindow2 *iface, BSTR *p)
 586 {
 587     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 588
 589     TRACE("(%p)->(%p)\n", This, p);
 590
 591     /* See put_status */
 592     *p = NULL;
 593     return S_OK;
 594 }
 595
 596 static HRESULT WINAPI HTMLWindow2_setTimeout(IHTMLWindow2 *iface, BSTR expression,
 597         LONG msec, VARIANT *language, LONG *timerID)
 598 {
 599     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 600     VARIANT expr_var;
 601
 602     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_w(expression), msec, language, timerID);
 603
 604     V_VT(&expr_var) = VT_BSTR;
 605     V_BSTR(&expr_var) = expression;
 606
 607     return IHTMLWindow3_setTimeout(&This->IHTMLWindow3_iface, &expr_var, msec, language, timerID);
 608 }
 609
 610 static HRESULT WINAPI HTMLWindow2_clearTimeout(IHTMLWindow2 *iface, LONG timerID)
 611 {
 612     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 613
 614     TRACE("(%p)->(%d)\n", This, timerID);
 615
 616     return clear_task_timer(This->inner_window, timerID);
 617 }
 618
 619 #define MAX_MESSAGE_LEN 2000
 620
 621 static HRESULT WINAPI HTMLWindow2_alert(IHTMLWindow2 *iface, BSTR message)
 622 {
 623     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 624     WCHAR title[100], *msg = message;
 625     DWORD len;
 626
 627     TRACE("(%p)->(%s)\n", This, debugstr_w(message));
 628
 629     if(!LoadStringW(get_shdoclc(), IDS_MESSAGE_BOX_TITLE, title,
 630                     sizeof(title)/sizeof(WCHAR))) {
 631         WARN("Could not load message box title: %d\n", GetLastError());
 632         return S_OK;
 633     }
 634
 635     len = SysStringLen(message);
 636     if(len > MAX_MESSAGE_LEN) {
 637         msg = heap_alloc((MAX_MESSAGE_LEN+1)*sizeof(WCHAR));
 638         if(!msg)
 639             return E_OUTOFMEMORY;
 640         memcpy(msg, message, MAX_MESSAGE_LEN*sizeof(WCHAR));
 641         msg[MAX_MESSAGE_LEN] = 0;
 642     }
 643
 644     MessageBoxW(This->outer_window->doc_obj->hwnd, msg, title, MB_ICONWARNING);
 645     if(msg != message)
 646         heap_free(msg);
 647     return S_OK;
 648 }
 649
 650 static HRESULT WINAPI HTMLWindow2_confirm(IHTMLWindow2 *iface, BSTR message,
 651         VARIANT_BOOL *confirmed)
 652 {
 653     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 654     WCHAR wszTitle[100];
 655
 656     TRACE("(%p)->(%s %p)\n", This, debugstr_w(message), confirmed);
 657
 658     if(!confirmed) return E_INVALIDARG;
 659
 660     if(!LoadStringW(get_shdoclc(), IDS_MESSAGE_BOX_TITLE, wszTitle,
 661                 sizeof(wszTitle)/sizeof(WCHAR))) {
 662         WARN("Could not load message box title: %d\n", GetLastError());
 663         *confirmed = VARIANT_TRUE;
 664         return S_OK;
 665     }
 666
 667     if(MessageBoxW(This->outer_window->doc_obj->hwnd, message, wszTitle,
 668                 MB_OKCANCEL|MB_ICONQUESTION)==IDOK)
 669         *confirmed = VARIANT_TRUE;
 670     else *confirmed = VARIANT_FALSE;
 671
 672     return S_OK;
 673 }
 674
 675 typedef struct
 676 {
 677     BSTR message;
 678     BSTR dststr;
 679     VARIANT *textdata;
 680 }prompt_arg;
 681
 682 static INT_PTR CALLBACK prompt_dlgproc(HWND hwnd, UINT msg,
 683         WPARAM wparam, LPARAM lparam)
 684 {
 685     switch(msg)
 686     {
 687         case WM_INITDIALOG:
 688         {
 689             prompt_arg *arg = (prompt_arg*)lparam;
 690             WCHAR wszTitle[100];
 691
 692             if(!LoadStringW(get_shdoclc(), IDS_MESSAGE_BOX_TITLE, wszTitle,
 693                         sizeof(wszTitle)/sizeof(WCHAR))) {
 694                 WARN("Could not load message box title: %d\n", GetLastError());
 695                 EndDialog(hwnd, wparam);
 696                 return FALSE;
 697             }
 698
 699             SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
 700             SetWindowTextW(hwnd, wszTitle);
 701             SetWindowTextW(GetDlgItem(hwnd, ID_PROMPT_PROMPT), arg->message);
 702             SetWindowTextW(GetDlgItem(hwnd, ID_PROMPT_EDIT), arg->dststr);
 703             return FALSE;
 704         }
 705         case WM_COMMAND:
 706             switch(wparam)
 707             {
 708                 case MAKEWPARAM(IDCANCEL, BN_CLICKED):
 709                     EndDialog(hwnd, wparam);
 710                     return TRUE;
 711                 case MAKEWPARAM(IDOK, BN_CLICKED):
 712                 {
 713                     prompt_arg *arg =
 714                         (prompt_arg*)GetWindowLongPtrW(hwnd, DWLP_USER);
 715                     HWND hwndPrompt = GetDlgItem(hwnd, ID_PROMPT_EDIT);
 716                     INT len = GetWindowTextLengthW(hwndPrompt);
 717
 718                     if(!arg->textdata)
 719                     {
 720                         EndDialog(hwnd, wparam);
 721                         return TRUE;
 722                     }
 723
 724                     V_VT(arg->textdata) = VT_BSTR;
 725                     if(!len && !arg->dststr)
 726                         V_BSTR(arg->textdata) = NULL;
 727                     else
 728                     {
 729                         V_BSTR(arg->textdata) = SysAllocStringLen(NULL, len);
 730                         GetWindowTextW(hwndPrompt, V_BSTR(arg->textdata), len+1);
 731                     }
 732                     EndDialog(hwnd, wparam);
 733                     return TRUE;
 734                 }
 735             }
 736             return FALSE;
 737         case WM_CLOSE:
 738             EndDialog(hwnd, IDCANCEL);
 739             return TRUE;
 740         default:
 741             return FALSE;
 742     }
 743 }
 744
 745 static HRESULT WINAPI HTMLWindow2_prompt(IHTMLWindow2 *iface, BSTR message,
 746         BSTR dststr, VARIANT *textdata)
 747 {
 748     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 749     prompt_arg arg;
 750
 751     TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(message), debugstr_w(dststr), textdata);
 752
 753     if(textdata) V_VT(textdata) = VT_NULL;
 754
 755     arg.message = message;
 756     arg.dststr = dststr;
 757     arg.textdata = textdata;
 758
 759     DialogBoxParamW(hInst, MAKEINTRESOURCEW(ID_PROMPT_DIALOG),
 760             This->outer_window->doc_obj->hwnd, prompt_dlgproc, (LPARAM)&arg);
 761     return S_OK;
 762 }
 763
 764 static HRESULT WINAPI HTMLWindow2_get_Image(IHTMLWindow2 *iface, IHTMLImageElementFactory **p)
 765 {
 766     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 767     HTMLInnerWindow *window = This->inner_window;
 768
 769     TRACE("(%p)->(%p)\n", This, p);
 770
 771     if(!window->image_factory) {
 772         HRESULT hres;
 773
 774         hres = HTMLImageElementFactory_Create(window, &window->image_factory);
 775         if(FAILED(hres))
 776             return hres;
 777     }
 778
 779     *p = &window->image_factory->IHTMLImageElementFactory_iface;
 780     IHTMLImageElementFactory_AddRef(*p);
 781
 782     return S_OK;
 783 }
 784
 785 static HRESULT WINAPI HTMLWindow2_get_location(IHTMLWindow2 *iface, IHTMLLocation **p)
 786 {
 787     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 788     HTMLLocation *location;
 789     HRESULT hres;
 790
 791     TRACE("(%p)->(%p)\n", This, p);
 792
 793     hres = get_location(This->inner_window, &location);
 794     if(FAILED(hres))
 795         return hres;
 796
 797     *p = &location->IHTMLLocation_iface;
 798     return S_OK;
 799 }
 800
 801 static HRESULT WINAPI HTMLWindow2_get_history(IHTMLWindow2 *iface, IOmHistory **p)
 802 {
 803     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 804     HTMLInnerWindow *window = This->inner_window;
 805
 806     TRACE("(%p)->(%p)\n", This, p);
 807
 808     if(!window->history) {
 809         HRESULT hres;
 810
 811         hres = create_history(window, &window->history);
 812         if(FAILED(hres))
 813             return hres;
 814     }
 815
 816     IOmHistory_AddRef(&window->history->IOmHistory_iface);
 817     *p = &window->history->IOmHistory_iface;
 818     return S_OK;
 819 }
 820
 821 static BOOL notify_webbrowser_close(HTMLOuterWindow *window, HTMLDocumentObj *doc)
 822 {
 823     IConnectionPointContainer *cp_container;
 824     VARIANT_BOOL cancel = VARIANT_FALSE;
 825     IEnumConnections *enum_conn;
 826     VARIANT args[2];
 827     DISPPARAMS dp = {args, NULL, 2, 0};
 828     CONNECTDATA conn_data;
 829     IConnectionPoint *cp;
 830     IDispatch *disp;
 831     ULONG fetched;
 832     HRESULT hres;
 833
 834     if(!doc->webbrowser)
 835         return TRUE;
 836
 837     hres = IUnknown_QueryInterface(doc->webbrowser, &IID_IConnectionPointContainer, (void**)&cp_container);
 838     if(FAILED(hres))
 839         return TRUE;
 840
 841     hres = IConnectionPointContainer_FindConnectionPoint(cp_container, &DIID_DWebBrowserEvents2, &cp);
 842     IConnectionPointContainer_Release(cp_container);
 843     if(FAILED(hres))
 844         return TRUE;
 845
 846     hres = IConnectionPoint_EnumConnections(cp, &enum_conn);
 847     IConnectionPoint_Release(cp);
 848     if(FAILED(hres))
 849         return TRUE;
 850
 851     while(!cancel) {
 852         conn_data.pUnk = NULL;
 853         conn_data.dwCookie = 0;
 854         fetched = 0;
 855         hres = IEnumConnections_Next(enum_conn, 1, &conn_data, &fetched);
 856         if(hres != S_OK)
 857             break;
 858
 859         hres = IUnknown_QueryInterface(conn_data.pUnk, &IID_IDispatch, (void**)&disp);
 860         IUnknown_Release(conn_data.pUnk);
 861         if(FAILED(hres))
 862             continue;
 863
 864         V_VT(args) = VT_BYREF|VT_BOOL;
 865         V_BOOLREF(args) = &cancel;
 866         V_VT(args+1) = VT_BOOL;
 867         V_BOOL(args+1) = variant_bool(window->parent != NULL);
 868         hres = IDispatch_Invoke(disp, DISPID_WINDOWCLOSING, &IID_NULL, 0, DISPATCH_METHOD, &dp, NULL, NULL, NULL);
 869         IDispatch_Release(disp);
 870         if(FAILED(hres))
 871             cancel = VARIANT_FALSE;
 872     }
 873
 874     IEnumConnections_Release(enum_conn);
 875     return !cancel;
 876 }
 877
 878 static HRESULT WINAPI HTMLWindow2_close(IHTMLWindow2 *iface)
 879 {
 880     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 881     HTMLOuterWindow *window = This->outer_window;
 882
 883     TRACE("(%p)\n", This);
 884
 885     if(!window->doc_obj) {
 886         FIXME("No document object\n");
 887         return E_FAIL;
 888     }
 889
 890     if(!notify_webbrowser_close(window, window->doc_obj))
 891         return S_OK;
 892
 893     FIXME("default action not implemented\n");
 894     return E_NOTIMPL;
 895 }
 896
 897 static HRESULT WINAPI HTMLWindow2_put_opener(IHTMLWindow2 *iface, VARIANT v)
 898 {
 899     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 900     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 901     return E_NOTIMPL;
 902 }
 903
 904 static HRESULT WINAPI HTMLWindow2_get_opener(IHTMLWindow2 *iface, VARIANT *p)
 905 {
 906     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 907
 908     FIXME("(%p)->(%p) returning empty\n", This, p);
 909
 910     V_VT(p) = VT_EMPTY;
 911     return S_OK;
 912 }
 913
 914 static HRESULT WINAPI HTMLWindow2_get_navigator(IHTMLWindow2 *iface, IOmNavigator **p)
 915 {
 916     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 917
 918     TRACE("(%p)->(%p)\n", This, p);
 919
 920     *p = OmNavigator_Create();
 921     return *p ? S_OK : E_OUTOFMEMORY;
 922 }
 923
 924 static HRESULT WINAPI HTMLWindow2_put_name(IHTMLWindow2 *iface, BSTR v)
 925 {
 926     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 927     nsAString name_str;
 928     nsresult nsres;
 929
 930     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 931
 932     nsAString_InitDepend(&name_str, v);
 933     nsres = nsIDOMWindow_SetName(This->outer_window->nswindow, &name_str);
 934     nsAString_Finish(&name_str);
 935     if(NS_FAILED(nsres))
 936         ERR("SetName failed: %08x\n", nsres);
 937
 938     return S_OK;
 939 }
 940
 941 static HRESULT WINAPI HTMLWindow2_get_name(IHTMLWindow2 *iface, BSTR *p)
 942 {
 943     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 944     nsAString name_str;
 945     nsresult nsres;
 946
 947     TRACE("(%p)->(%p)\n", This, p);
 948
 949     nsAString_Init(&name_str, NULL);
 950     nsres = nsIDOMWindow_GetName(This->outer_window->nswindow, &name_str);
 951     return return_nsstr(nsres, &name_str, p);
 952 }
 953
 954 static HRESULT WINAPI HTMLWindow2_get_parent(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 955 {
 956     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 957     HTMLOuterWindow *window = This->outer_window;
 958
 959     TRACE("(%p)->(%p)\n", This, p);
 960
 961     if(!window->parent)
 962         return IHTMLWindow2_get_self(&This->IHTMLWindow2_iface, p);
 963
 964     *p = &window->parent->base.IHTMLWindow2_iface;
 965     IHTMLWindow2_AddRef(*p);
 966     return S_OK;
 967 }
 968
 969 static HRESULT WINAPI HTMLWindow2_open(IHTMLWindow2 *iface, BSTR url, BSTR name,
 970          BSTR features, VARIANT_BOOL replace, IHTMLWindow2 **pomWindowResult)
 971 {
 972     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 973     HTMLOuterWindow *window = This->outer_window;
 974     IUri *uri;
 975     HRESULT hres;
 976
 977     static const WCHAR _selfW[] = {'_','s','e','l','f',0};
 978
 979     TRACE("(%p)->(%s %s %s %x %p)\n", This, debugstr_w(url), debugstr_w(name),
 980           debugstr_w(features), replace, pomWindowResult);
 981     if(features)
 982         FIXME("unsupported features argument %s\n", debugstr_w(features));
 983     if(replace)
 984         FIXME("unsupported relace argument\n");
 985
 986     if(!window->doc_obj || !window->uri_nofrag)
 987         return E_UNEXPECTED;
 988
 989     if(name && *name == '_') {
 990         if(!strcmpW(name, _selfW)) {
 991             if((features && *features) || replace)
 992                 FIXME("Unsupported arguments for _self target\n");
 993
 994             hres = IHTMLWindow2_navigate(&This->IHTMLWindow2_iface, url);
 995             if(FAILED(hres))
 996                 return hres;
 997
 998             if(pomWindowResult) {
 999                 FIXME("Returning this window for _self target\n");
1000                 *pomWindowResult = &This->IHTMLWindow2_iface;
1001                 IHTMLWindow2_AddRef(*pomWindowResult);
1002             }
1003
1004             return S_OK;
1005         }
1006
1007         FIXME("Unsupported name %s\n", debugstr_w(name));
1008         return E_NOTIMPL;
1009     }
1010
1011     hres = create_relative_uri(window, url, &uri);
1012     if(FAILED(hres))
1013         return hres;
1014
1015     hres = navigate_new_window(window, uri, name, NULL, pomWindowResult);
1016     IUri_Release(uri);
1017     return hres;
1018 }
1019
1020 static HRESULT WINAPI HTMLWindow2_get_self(IHTMLWindow2 *iface, IHTMLWindow2 **p)
1021 {
1022     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1023
1024     TRACE("(%p)->(%p)\n", This, p);
1025
1026     /* FIXME: We should return kind of proxy window here. */
1027     IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1028     *p = &This->IHTMLWindow2_iface;
1029     return S_OK;
1030 }
1031
1032 static HRESULT WINAPI HTMLWindow2_get_top(IHTMLWindow2 *iface, IHTMLWindow2 **p)
1033 {
1034     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1035     HTMLOuterWindow *top;
1036
1037     TRACE("(%p)->(%p)\n", This, p);
1038
1039     get_top_window(This->outer_window, &top);
1040     *p = &top->base.IHTMLWindow2_iface;
1041     IHTMLWindow2_AddRef(*p);
1042
1043     return S_OK;
1044 }
1045
1046 static HRESULT WINAPI HTMLWindow2_get_window(IHTMLWindow2 *iface, IHTMLWindow2 **p)
1047 {
1048     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1049
1050     TRACE("(%p)->(%p)\n", This, p);
1051
1052     /* FIXME: We should return kind of proxy window here. */
1053     IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1054     *p = &This->IHTMLWindow2_iface;
1055     return S_OK;
1056 }
1057
1058 static HRESULT WINAPI HTMLWindow2_navigate(IHTMLWindow2 *iface, BSTR url)
1059 {
1060     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1061
1062     TRACE("(%p)->(%s)\n", This, debugstr_w(url));
1063
1064     return navigate_url(This->outer_window, url, This->outer_window->uri, BINDING_NAVIGATED);
1065 }
1066
1067 static HRESULT WINAPI HTMLWindow2_put_onfocus(IHTMLWindow2 *iface, VARIANT v)
1068 {
1069     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1070
1071     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1072
1073     return set_window_event(This, EVENTID_FOCUS, &v);
1074 }
1075
1076 static HRESULT WINAPI HTMLWindow2_get_onfocus(IHTMLWindow2 *iface, VARIANT *p)
1077 {
1078     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1079
1080     TRACE("(%p)->(%p)\n", This, p);
1081
1082     return get_window_event(This, EVENTID_FOCUS, p);
1083 }
1084
1085 static HRESULT WINAPI HTMLWindow2_put_onblur(IHTMLWindow2 *iface, VARIANT v)
1086 {
1087     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1088
1089     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1090
1091     return set_window_event(This, EVENTID_BLUR, &v);
1092 }
1093
1094 static HRESULT WINAPI HTMLWindow2_get_onblur(IHTMLWindow2 *iface, VARIANT *p)
1095 {
1096     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1097
1098     TRACE("(%p)->(%p)\n", This, p);
1099
1100     return get_window_event(This, EVENTID_BLUR, p);
1101 }
1102
1103 static HRESULT WINAPI HTMLWindow2_put_onload(IHTMLWindow2 *iface, VARIANT v)
1104 {
1105     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1106
1107     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1108
1109     return set_window_event(This, EVENTID_LOAD, &v);
1110 }
1111
1112 static HRESULT WINAPI HTMLWindow2_get_onload(IHTMLWindow2 *iface, VARIANT *p)
1113 {
1114     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1115
1116     TRACE("(%p)->(%p)\n", This, p);
1117
1118     return get_window_event(This, EVENTID_LOAD, p);
1119 }
1120
1121 static HRESULT WINAPI HTMLWindow2_put_onbeforeunload(IHTMLWindow2 *iface, VARIANT v)
1122 {
1123     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1124
1125     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1126
1127     return set_window_event(This, EVENTID_BEFOREUNLOAD, &v);
1128 }
1129
1130 static HRESULT WINAPI HTMLWindow2_get_onbeforeunload(IHTMLWindow2 *iface, VARIANT *p)
1131 {
1132     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1133
1134     TRACE("(%p)->(%p)\n", This, p);
1135
1136     return get_window_event(This, EVENTID_BEFOREUNLOAD, p);
1137 }
1138
1139 static HRESULT WINAPI HTMLWindow2_put_onunload(IHTMLWindow2 *iface, VARIANT v)
1140 {
1141     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1142
1143     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1144
1145     return set_window_event(This, EVENTID_UNLOAD, &v);
1146 }
1147
1148 static HRESULT WINAPI HTMLWindow2_get_onunload(IHTMLWindow2 *iface, VARIANT *p)
1149 {
1150     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1151
1152     TRACE("(%p)->(%p)\n", This, p);
1153
1154     return get_window_event(This, EVENTID_UNLOAD, p);
1155 }
1156
1157 static HRESULT WINAPI HTMLWindow2_put_onhelp(IHTMLWindow2 *iface, VARIANT v)
1158 {
1159     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1160
1161     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1162
1163     return set_window_event(This, EVENTID_HELP, &v);
1164 }
1165
1166 static HRESULT WINAPI HTMLWindow2_get_onhelp(IHTMLWindow2 *iface, VARIANT *p)
1167 {
1168     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1169
1170     TRACE("(%p)->(%p)\n", This, p);
1171
1172     return get_window_event(This, EVENTID_HELP, p);
1173 }
1174
1175 static HRESULT WINAPI HTMLWindow2_put_onerror(IHTMLWindow2 *iface, VARIANT v)
1176 {
1177     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1178
1179     FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
1180
1181     return set_window_event(This, EVENTID_ERROR, &v);
1182 }
1183
1184 static HRESULT WINAPI HTMLWindow2_get_onerror(IHTMLWindow2 *iface, VARIANT *p)
1185 {
1186     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1187
1188     TRACE("(%p)->(%p)\n", This, p);
1189
1190     return get_window_event(This, EVENTID_ERROR, p);
1191 }
1192
1193 static HRESULT WINAPI HTMLWindow2_put_onresize(IHTMLWindow2 *iface, VARIANT v)
1194 {
1195     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1196
1197     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1198
1199     return set_window_event(This, EVENTID_RESIZE, &v);
1200 }
1201
1202 static HRESULT WINAPI HTMLWindow2_get_onresize(IHTMLWindow2 *iface, VARIANT *p)
1203 {
1204     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1205
1206     TRACE("(%p)->(%p)\n", This, p);
1207
1208     return get_window_event(This, EVENTID_RESIZE, p);
1209 }
1210
1211 static HRESULT WINAPI HTMLWindow2_put_onscroll(IHTMLWindow2 *iface, VARIANT v)
1212 {
1213     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1214
1215     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1216
1217     return set_window_event(This, EVENTID_SCROLL, &v);
1218 }
1219
1220 static HRESULT WINAPI HTMLWindow2_get_onscroll(IHTMLWindow2 *iface, VARIANT *p)
1221 {
1222     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1223
1224     TRACE("(%p)->(%p)\n", This, p);
1225
1226     return get_window_event(This, EVENTID_SCROLL, p);
1227 }
1228
1229 static HRESULT WINAPI HTMLWindow2_get_document(IHTMLWindow2 *iface, IHTMLDocument2 **p)
1230 {
1231     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1232
1233     TRACE("(%p)->(%p)\n", This, p);
1234
1235     if(This->inner_window->doc) {
1236         /* FIXME: We should return a wrapper object here */
1237         *p = &This->inner_window->doc->basedoc.IHTMLDocument2_iface;
1238         IHTMLDocument2_AddRef(*p);
1239     }else {
1240         *p = NULL;
1241     }
1242
1243     return S_OK;
1244 }
1245
1246 IHTMLEventObj *default_set_current_event(HTMLInnerWindow *window, IHTMLEventObj *event_obj)
1247 {
1248     IHTMLEventObj *prev_event = NULL;
1249
1250     if(window) {
1251         if(event_obj)
1252             IHTMLEventObj_AddRef(event_obj);
1253         prev_event = window->event;
1254         window->event = event_obj;
1255     }
1256
1257     return prev_event;
1258 }
1259
1260 static HRESULT WINAPI HTMLWindow2_get_event(IHTMLWindow2 *iface, IHTMLEventObj **p)
1261 {
1262     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1263     HTMLInnerWindow *window = This->inner_window;
1264
1265     TRACE("(%p)->(%p)\n", This, p);
1266
1267     if(window->event)
1268         IHTMLEventObj_AddRef(window->event);
1269     *p = window->event;
1270     return S_OK;
1271 }
1272
1273 static HRESULT WINAPI HTMLWindow2_get__newEnum(IHTMLWindow2 *iface, IUnknown **p)
1274 {
1275     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1276     FIXME("(%p)->(%p)\n", This, p);
1277     return E_NOTIMPL;
1278 }
1279
1280 static HRESULT WINAPI HTMLWindow2_showModalDialog(IHTMLWindow2 *iface, BSTR dialog,
1281         VARIANT *varArgIn, VARIANT *varOptions, VARIANT *varArgOut)
1282 {
1283     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1284     FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_w(dialog), varArgIn, varOptions, varArgOut);
1285     return E_NOTIMPL;
1286 }
1287
1288 static HRESULT WINAPI HTMLWindow2_showHelp(IHTMLWindow2 *iface, BSTR helpURL, VARIANT helpArg,
1289         BSTR features)
1290 {
1291     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1292     FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(helpURL), debugstr_variant(&helpArg), debugstr_w(features));
1293     return E_NOTIMPL;
1294 }
1295
1296 static HRESULT WINAPI HTMLWindow2_get_screen(IHTMLWindow2 *iface, IHTMLScreen **p)
1297 {
1298     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1299     HTMLInnerWindow *window = This->inner_window;
1300
1301     TRACE("(%p)->(%p)\n", This, p);
1302
1303     if(!window->screen) {
1304         HRESULT hres;
1305
1306         hres = HTMLScreen_Create(&window->screen);
1307         if(FAILED(hres))
1308             return hres;
1309     }
1310
1311     *p = window->screen;
1312     IHTMLScreen_AddRef(window->screen);
1313     return S_OK;
1314 }
1315
1316 static HRESULT WINAPI HTMLWindow2_get_Option(IHTMLWindow2 *iface, IHTMLOptionElementFactory **p)
1317 {
1318     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1319     HTMLInnerWindow *window = This->inner_window;
1320
1321     TRACE("(%p)->(%p)\n", This, p);
1322
1323     if(!window->option_factory) {
1324         HRESULT hres;
1325
1326         hres = HTMLOptionElementFactory_Create(window, &window->option_factory);
1327         if(FAILED(hres))
1328             return hres;
1329     }
1330
1331     *p = &window->option_factory->IHTMLOptionElementFactory_iface;
1332     IHTMLOptionElementFactory_AddRef(*p);
1333
1334     return S_OK;
1335 }
1336
1337 static HRESULT WINAPI HTMLWindow2_focus(IHTMLWindow2 *iface)
1338 {
1339     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1340
1341     TRACE("(%p)->()\n", This);
1342
1343     if(This->outer_window->doc_obj)
1344         SetFocus(This->outer_window->doc_obj->hwnd);
1345     return S_OK;
1346 }
1347
1348 static HRESULT WINAPI HTMLWindow2_get_closed(IHTMLWindow2 *iface, VARIANT_BOOL *p)
1349 {
1350     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1351     FIXME("(%p)->(%p)\n", This, p);
1352     return E_NOTIMPL;
1353 }
1354
1355 static HRESULT WINAPI HTMLWindow2_blur(IHTMLWindow2 *iface)
1356 {
1357     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1358     FIXME("(%p)->()\n", This);
1359     return E_NOTIMPL;
1360 }
1361
1362 static HRESULT WINAPI HTMLWindow2_scroll(IHTMLWindow2 *iface, LONG x, LONG y)
1363 {
1364     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1365     nsresult nsres;
1366
1367     TRACE("(%p)->(%d %d)\n", This, x, y);
1368
1369     nsres = nsIDOMWindow_Scroll(This->outer_window->nswindow, x, y);
1370     if(NS_FAILED(nsres)) {
1371         ERR("ScrollBy failed: %08x\n", nsres);
1372         return E_FAIL;
1373     }
1374
1375     return S_OK;
1376 }
1377
1378 static HRESULT WINAPI HTMLWindow2_get_clientInformation(IHTMLWindow2 *iface, IOmNavigator **p)
1379 {
1380     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1381
1382     TRACE("(%p)->(%p)\n", This, p);
1383
1384     return IHTMLWindow2_get_navigator(&This->IHTMLWindow2_iface, p);
1385 }
1386
1387 static HRESULT WINAPI HTMLWindow2_setInterval(IHTMLWindow2 *iface, BSTR expression,
1388         LONG msec, VARIANT *language, LONG *timerID)
1389 {
1390     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1391     VARIANT expr;
1392
1393     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_w(expression), msec, language, timerID);
1394
1395     V_VT(&expr) = VT_BSTR;
1396     V_BSTR(&expr) = expression;
1397     return IHTMLWindow3_setInterval(&This->IHTMLWindow3_iface, &expr, msec, language, timerID);
1398 }
1399
1400 static HRESULT WINAPI HTMLWindow2_clearInterval(IHTMLWindow2 *iface, LONG timerID)
1401 {
1402     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1403
1404     TRACE("(%p)->(%d)\n", This, timerID);
1405
1406     return clear_task_timer(This->inner_window, timerID);
1407 }
1408
1409 static HRESULT WINAPI HTMLWindow2_put_offscreenBuffering(IHTMLWindow2 *iface, VARIANT v)
1410 {
1411     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1412     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1413     return E_NOTIMPL;
1414 }
1415
1416 static HRESULT WINAPI HTMLWindow2_get_offscreenBuffering(IHTMLWindow2 *iface, VARIANT *p)
1417 {
1418     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1419     FIXME("(%p)->(%p)\n", This, p);
1420     return E_NOTIMPL;
1421 }
1422
1423 static HRESULT WINAPI HTMLWindow2_execScript(IHTMLWindow2 *iface, BSTR scode, BSTR language,
1424         VARIANT *pvarRet)
1425 {
1426     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1427
1428     TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(scode), debugstr_w(language), pvarRet);
1429
1430     return exec_script(This->inner_window, scode, language, pvarRet);
1431 }
1432
1433 static HRESULT WINAPI HTMLWindow2_toString(IHTMLWindow2 *iface, BSTR *String)
1434 {
1435     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1436
1437     static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
1438
1439     TRACE("(%p)->(%p)\n", This, String);
1440
1441     if(!String)
1442         return E_INVALIDARG;
1443
1444     *String = SysAllocString(objectW);
1445     return *String ? S_OK : E_OUTOFMEMORY;
1446 }
1447
1448 static HRESULT WINAPI HTMLWindow2_scrollBy(IHTMLWindow2 *iface, LONG x, LONG y)
1449 {
1450     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1451     nsresult nsres;
1452
1453     TRACE("(%p)->(%d %d)\n", This, x, y);
1454
1455     nsres = nsIDOMWindow_ScrollBy(This->outer_window->nswindow, x, y);
1456     if(NS_FAILED(nsres))
1457         ERR("ScrollBy failed: %08x\n", nsres);
1458
1459     return S_OK;
1460 }
1461
1462 static HRESULT WINAPI HTMLWindow2_scrollTo(IHTMLWindow2 *iface, LONG x, LONG y)
1463 {
1464     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1465     nsresult nsres;
1466
1467     TRACE("(%p)->(%d %d)\n", This, x, y);
1468
1469     nsres = nsIDOMWindow_ScrollTo(This->outer_window->nswindow, x, y);
1470     if(NS_FAILED(nsres))
1471         ERR("ScrollTo failed: %08x\n", nsres);
1472
1473     return S_OK;
1474 }
1475
1476 static HRESULT WINAPI HTMLWindow2_moveTo(IHTMLWindow2 *iface, LONG x, LONG y)
1477 {
1478     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1479     FIXME("(%p)->(%d %d)\n", This, x, y);
1480     return E_NOTIMPL;
1481 }
1482
1483 static HRESULT WINAPI HTMLWindow2_moveBy(IHTMLWindow2 *iface, LONG x, LONG y)
1484 {
1485     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1486     FIXME("(%p)->(%d %d)\n", This, x, y);
1487     return S_FALSE;
1488 }
1489
1490 static HRESULT WINAPI HTMLWindow2_resizeTo(IHTMLWindow2 *iface, LONG x, LONG y)
1491 {
1492     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1493     FIXME("(%p)->(%d %d)\n", This, x, y);
1494     return E_NOTIMPL;
1495 }
1496
1497 static HRESULT WINAPI HTMLWindow2_resizeBy(IHTMLWindow2 *iface, LONG x, LONG y)
1498 {
1499     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1500     FIXME("(%p)->(%d %d)\n", This, x, y);
1501     return S_FALSE;
1502 }
1503
1504 static HRESULT WINAPI HTMLWindow2_get_external(IHTMLWindow2 *iface, IDispatch **p)
1505 {
1506     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1507
1508     TRACE("(%p)->(%p)\n", This, p);
1509
1510     *p = NULL;
1511
1512     if(!This->outer_window->doc_obj->hostui)
1513         return S_OK;
1514
1515     return IDocHostUIHandler_GetExternal(This->outer_window->doc_obj->hostui, p);
1516 }
1517
1518 static const IHTMLWindow2Vtbl HTMLWindow2Vtbl = {
1519     HTMLWindow2_QueryInterface,
1520     HTMLWindow2_AddRef,
1521     HTMLWindow2_Release,
1522     HTMLWindow2_GetTypeInfoCount,
1523     HTMLWindow2_GetTypeInfo,
1524     HTMLWindow2_GetIDsOfNames,
1525     HTMLWindow2_Invoke,
1526     HTMLWindow2_item,
1527     HTMLWindow2_get_length,
1528     HTMLWindow2_get_frames,
1529     HTMLWindow2_put_defaultStatus,
1530     HTMLWindow2_get_defaultStatus,
1531     HTMLWindow2_put_status,
1532     HTMLWindow2_get_status,
1533     HTMLWindow2_setTimeout,
1534     HTMLWindow2_clearTimeout,
1535     HTMLWindow2_alert,
1536     HTMLWindow2_confirm,
1537     HTMLWindow2_prompt,
1538     HTMLWindow2_get_Image,
1539     HTMLWindow2_get_location,
1540     HTMLWindow2_get_history,
1541     HTMLWindow2_close,
1542     HTMLWindow2_put_opener,
1543     HTMLWindow2_get_opener,
1544     HTMLWindow2_get_navigator,
1545     HTMLWindow2_put_name,
1546     HTMLWindow2_get_name,
1547     HTMLWindow2_get_parent,
1548     HTMLWindow2_open,
1549     HTMLWindow2_get_self,
1550     HTMLWindow2_get_top,
1551     HTMLWindow2_get_window,
1552     HTMLWindow2_navigate,
1553     HTMLWindow2_put_onfocus,
1554     HTMLWindow2_get_onfocus,
1555     HTMLWindow2_put_onblur,
1556     HTMLWindow2_get_onblur,
1557     HTMLWindow2_put_onload,
1558     HTMLWindow2_get_onload,
1559     HTMLWindow2_put_onbeforeunload,
1560     HTMLWindow2_get_onbeforeunload,
1561     HTMLWindow2_put_onunload,
1562     HTMLWindow2_get_onunload,
1563     HTMLWindow2_put_onhelp,
1564     HTMLWindow2_get_onhelp,
1565     HTMLWindow2_put_onerror,
1566     HTMLWindow2_get_onerror,
1567     HTMLWindow2_put_onresize,
1568     HTMLWindow2_get_onresize,
1569     HTMLWindow2_put_onscroll,
1570     HTMLWindow2_get_onscroll,
1571     HTMLWindow2_get_document,
1572     HTMLWindow2_get_event,
1573     HTMLWindow2_get__newEnum,
1574     HTMLWindow2_showModalDialog,
1575     HTMLWindow2_showHelp,
1576     HTMLWindow2_get_screen,
1577     HTMLWindow2_get_Option,
1578     HTMLWindow2_focus,
1579     HTMLWindow2_get_closed,
1580     HTMLWindow2_blur,
1581     HTMLWindow2_scroll,
1582     HTMLWindow2_get_clientInformation,
1583     HTMLWindow2_setInterval,
1584     HTMLWindow2_clearInterval,
1585     HTMLWindow2_put_offscreenBuffering,
1586     HTMLWindow2_get_offscreenBuffering,
1587     HTMLWindow2_execScript,
1588     HTMLWindow2_toString,
1589     HTMLWindow2_scrollBy,
1590     HTMLWindow2_scrollTo,
1591     HTMLWindow2_moveTo,
1592     HTMLWindow2_moveBy,
1593     HTMLWindow2_resizeTo,
1594     HTMLWindow2_resizeBy,
1595     HTMLWindow2_get_external
1596 };
1597
1598 static inline HTMLWindow *impl_from_IHTMLWindow3(IHTMLWindow3 *iface)
1599 {
1600     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow3_iface);
1601 }
1602
1603 static HRESULT WINAPI HTMLWindow3_QueryInterface(IHTMLWindow3 *iface, REFIID riid, void **ppv)
1604 {
1605     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1606
1607     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1608 }
1609
1610 static ULONG WINAPI HTMLWindow3_AddRef(IHTMLWindow3 *iface)
1611 {
1612     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1613
1614     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1615 }
1616
1617 static ULONG WINAPI HTMLWindow3_Release(IHTMLWindow3 *iface)
1618 {
1619     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1620
1621     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1622 }
1623
1624 static HRESULT WINAPI HTMLWindow3_GetTypeInfoCount(IHTMLWindow3 *iface, UINT *pctinfo)
1625 {
1626     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1627
1628     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1629 }
1630
1631 static HRESULT WINAPI HTMLWindow3_GetTypeInfo(IHTMLWindow3 *iface, UINT iTInfo,
1632                                               LCID lcid, ITypeInfo **ppTInfo)
1633 {
1634     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1635
1636     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1637 }
1638
1639 static HRESULT WINAPI HTMLWindow3_GetIDsOfNames(IHTMLWindow3 *iface, REFIID riid,
1640                                                 LPOLESTR *rgszNames, UINT cNames,
1641                                                 LCID lcid, DISPID *rgDispId)
1642 {
1643     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1644
1645     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1646             rgDispId);
1647 }
1648
1649 static HRESULT WINAPI HTMLWindow3_Invoke(IHTMLWindow3 *iface, DISPID dispIdMember,
1650                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1651                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1652 {
1653     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1654
1655     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1656             pDispParams, pVarResult, pExcepInfo, puArgErr);
1657 }
1658
1659 static HRESULT WINAPI HTMLWindow3_get_screenLeft(IHTMLWindow3 *iface, LONG *p)
1660 {
1661     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1662     nsresult nsres;
1663
1664     TRACE("(%p)->(%p)\n", This, p);
1665
1666     nsres = nsIDOMWindow_GetScreenX(This->outer_window->nswindow, p);
1667     if(NS_FAILED(nsres)) {
1668         ERR("GetScreenX failed: %08x\n", nsres);
1669         return E_FAIL;
1670     }
1671
1672     return S_OK;
1673 }
1674
1675 static HRESULT WINAPI HTMLWindow3_get_screenTop(IHTMLWindow3 *iface, LONG *p)
1676 {
1677     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1678     nsresult nsres;
1679
1680     TRACE("(%p)->(%p)\n", This, p);
1681
1682     nsres = nsIDOMWindow_GetScreenY(This->outer_window->nswindow, p);
1683     if(NS_FAILED(nsres)) {
1684         ERR("GetScreenY failed: %08x\n", nsres);
1685         return E_FAIL;
1686     }
1687
1688     return S_OK;
1689 }
1690
1691 static HRESULT WINAPI HTMLWindow3_attachEvent(IHTMLWindow3 *iface, BSTR event, IDispatch *pDisp, VARIANT_BOOL *pfResult)
1692 {
1693     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1694     HTMLInnerWindow *window = This->inner_window;
1695
1696     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
1697
1698     if(!window->doc) {
1699         FIXME("No document\n");
1700         return E_FAIL;
1701     }
1702
1703     return attach_event(&window->event_target, event, pDisp, pfResult);
1704 }
1705
1706 static HRESULT WINAPI HTMLWindow3_detachEvent(IHTMLWindow3 *iface, BSTR event, IDispatch *pDisp)
1707 {
1708     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1709     HTMLInnerWindow *window = This->inner_window;
1710
1711     TRACE("(%p)->()\n", This);
1712
1713     if(!window->doc) {
1714         FIXME("No document\n");
1715         return E_FAIL;
1716     }
1717
1718     return detach_event(&window->event_target, event, pDisp);
1719 }
1720
1721 static HRESULT window_set_timer(HTMLInnerWindow *This, VARIANT *expr, LONG msec, VARIANT *language,
1722         BOOL interval, LONG *timer_id)
1723 {
1724     IDispatch *disp = NULL;
1725     HRESULT hres;
1726
1727     switch(V_VT(expr)) {
1728     case VT_DISPATCH:
1729         disp = V_DISPATCH(expr);
1730         IDispatch_AddRef(disp);
1731         break;
1732
1733     case VT_BSTR:
1734         disp = script_parse_event(This->base.inner_window, V_BSTR(expr));
1735         break;
1736
1737     default:
1738         FIXME("unimplemented expr %s\n", debugstr_variant(expr));
1739         return E_NOTIMPL;
1740     }
1741
1742     if(!disp)
1743         return E_FAIL;
1744
1745     hres = set_task_timer(This, msec, interval, disp, timer_id);
1746     IDispatch_Release(disp);
1747
1748     return hres;
1749 }
1750
1751 static HRESULT WINAPI HTMLWindow3_setTimeout(IHTMLWindow3 *iface, VARIANT *expression, LONG msec,
1752         VARIANT *language, LONG *timerID)
1753 {
1754     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1755
1756     TRACE("(%p)->(%s %d %s %p)\n", This, debugstr_variant(expression), msec, debugstr_variant(language), timerID);
1757
1758     return window_set_timer(This->inner_window, expression, msec, language, FALSE, timerID);
1759 }
1760
1761 static HRESULT WINAPI HTMLWindow3_setInterval(IHTMLWindow3 *iface, VARIANT *expression, LONG msec,
1762         VARIANT *language, LONG *timerID)
1763 {
1764     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1765
1766     TRACE("(%p)->(%p %d %p %p)\n", This, expression, msec, language, timerID);
1767
1768     return window_set_timer(This->inner_window, expression, msec, language, TRUE, timerID);
1769 }
1770
1771 static HRESULT WINAPI HTMLWindow3_print(IHTMLWindow3 *iface)
1772 {
1773     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1774     FIXME("(%p)\n", This);
1775     return E_NOTIMPL;
1776 }
1777
1778 static HRESULT WINAPI HTMLWindow3_put_onbeforeprint(IHTMLWindow3 *iface, VARIANT v)
1779 {
1780     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1781     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1782     return E_NOTIMPL;
1783 }
1784
1785 static HRESULT WINAPI HTMLWindow3_get_onbeforeprint(IHTMLWindow3 *iface, VARIANT *p)
1786 {
1787     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1788     FIXME("(%p)->(%p)\n", This, p);
1789     return E_NOTIMPL;
1790 }
1791
1792 static HRESULT WINAPI HTMLWindow3_put_onafterprint(IHTMLWindow3 *iface, VARIANT v)
1793 {
1794     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1795     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1796     return E_NOTIMPL;
1797 }
1798
1799 static HRESULT WINAPI HTMLWindow3_get_onafterprint(IHTMLWindow3 *iface, VARIANT *p)
1800 {
1801     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1802     FIXME("(%p)->(%p)\n", This, p);
1803     return E_NOTIMPL;
1804 }
1805
1806 static HRESULT WINAPI HTMLWindow3_get_clipboardData(IHTMLWindow3 *iface, IHTMLDataTransfer **p)
1807 {
1808     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1809     FIXME("(%p)->(%p)\n", This, p);
1810     return E_NOTIMPL;
1811 }
1812
1813 static HRESULT WINAPI HTMLWindow3_showModelessDialog(IHTMLWindow3 *iface, BSTR url,
1814         VARIANT *varArgIn, VARIANT *options, IHTMLWindow2 **pDialog)
1815 {
1816     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1817     FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_w(url), varArgIn, options, pDialog);
1818     return E_NOTIMPL;
1819 }
1820
1821 static const IHTMLWindow3Vtbl HTMLWindow3Vtbl = {
1822     HTMLWindow3_QueryInterface,
1823     HTMLWindow3_AddRef,
1824     HTMLWindow3_Release,
1825     HTMLWindow3_GetTypeInfoCount,
1826     HTMLWindow3_GetTypeInfo,
1827     HTMLWindow3_GetIDsOfNames,
1828     HTMLWindow3_Invoke,
1829     HTMLWindow3_get_screenLeft,
1830     HTMLWindow3_get_screenTop,
1831     HTMLWindow3_attachEvent,
1832     HTMLWindow3_detachEvent,
1833     HTMLWindow3_setTimeout,
1834     HTMLWindow3_setInterval,
1835     HTMLWindow3_print,
1836     HTMLWindow3_put_onbeforeprint,
1837     HTMLWindow3_get_onbeforeprint,
1838     HTMLWindow3_put_onafterprint,
1839     HTMLWindow3_get_onafterprint,
1840     HTMLWindow3_get_clipboardData,
1841     HTMLWindow3_showModelessDialog
1842 };
1843
1844 static inline HTMLWindow *impl_from_IHTMLWindow4(IHTMLWindow4 *iface)
1845 {
1846     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow4_iface);
1847 }
1848
1849 static HRESULT WINAPI HTMLWindow4_QueryInterface(IHTMLWindow4 *iface, REFIID riid, void **ppv)
1850 {
1851     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1852
1853     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1854 }
1855
1856 static ULONG WINAPI HTMLWindow4_AddRef(IHTMLWindow4 *iface)
1857 {
1858     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1859
1860     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1861 }
1862
1863 static ULONG WINAPI HTMLWindow4_Release(IHTMLWindow4 *iface)
1864 {
1865     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1866
1867     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1868 }
1869
1870 static HRESULT WINAPI HTMLWindow4_GetTypeInfoCount(IHTMLWindow4 *iface, UINT *pctinfo)
1871 {
1872     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1873
1874     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1875 }
1876
1877 static HRESULT WINAPI HTMLWindow4_GetTypeInfo(IHTMLWindow4 *iface, UINT iTInfo,
1878                                               LCID lcid, ITypeInfo **ppTInfo)
1879 {
1880     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1881
1882     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1883 }
1884
1885 static HRESULT WINAPI HTMLWindow4_GetIDsOfNames(IHTMLWindow4 *iface, REFIID riid,
1886                                                 LPOLESTR *rgszNames, UINT cNames,
1887                                                 LCID lcid, DISPID *rgDispId)
1888 {
1889     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1890
1891     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1892             rgDispId);
1893 }
1894
1895 static HRESULT WINAPI HTMLWindow4_Invoke(IHTMLWindow4 *iface, DISPID dispIdMember,
1896                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1897                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1898 {
1899     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1900
1901     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1902             pDispParams, pVarResult, pExcepInfo, puArgErr);
1903 }
1904
1905 static HRESULT WINAPI HTMLWindow4_createPopup(IHTMLWindow4 *iface, VARIANT *varArgIn,
1906                             IDispatch **ppPopup)
1907 {
1908     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1909     FIXME("(%p)->(%p %p)\n", This, varArgIn, ppPopup);
1910     return E_NOTIMPL;
1911 }
1912
1913 static HRESULT WINAPI HTMLWindow4_get_frameElement(IHTMLWindow4 *iface, IHTMLFrameBase **p)
1914 {
1915     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1916     TRACE("(%p)->(%p)\n", This, p);
1917
1918     if(This->outer_window->frame_element) {
1919         *p = &This->outer_window->frame_element->IHTMLFrameBase_iface;
1920         IHTMLFrameBase_AddRef(*p);
1921     }else
1922         *p = NULL;
1923
1924     return S_OK;
1925 }
1926
1927 static const IHTMLWindow4Vtbl HTMLWindow4Vtbl = {
1928     HTMLWindow4_QueryInterface,
1929     HTMLWindow4_AddRef,
1930     HTMLWindow4_Release,
1931     HTMLWindow4_GetTypeInfoCount,
1932     HTMLWindow4_GetTypeInfo,
1933     HTMLWindow4_GetIDsOfNames,
1934     HTMLWindow4_Invoke,
1935     HTMLWindow4_createPopup,
1936     HTMLWindow4_get_frameElement
1937 };
1938
1939 static inline HTMLWindow *impl_from_IHTMLWindow5(IHTMLWindow5 *iface)
1940 {
1941     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow5_iface);
1942 }
1943
1944 static HRESULT WINAPI HTMLWindow5_QueryInterface(IHTMLWindow5 *iface, REFIID riid, void **ppv)
1945 {
1946     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1947
1948     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1949 }
1950
1951 static ULONG WINAPI HTMLWindow5_AddRef(IHTMLWindow5 *iface)
1952 {
1953     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1954
1955     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1956 }
1957
1958 static ULONG WINAPI HTMLWindow5_Release(IHTMLWindow5 *iface)
1959 {
1960     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1961
1962     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1963 }
1964
1965 static HRESULT WINAPI HTMLWindow5_GetTypeInfoCount(IHTMLWindow5 *iface, UINT *pctinfo)
1966 {
1967     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1968
1969     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1970 }
1971
1972 static HRESULT WINAPI HTMLWindow5_GetTypeInfo(IHTMLWindow5 *iface, UINT iTInfo,
1973         LCID lcid, ITypeInfo **ppTInfo)
1974 {
1975     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1976
1977     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1978 }
1979
1980 static HRESULT WINAPI HTMLWindow5_GetIDsOfNames(IHTMLWindow5 *iface, REFIID riid,
1981         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1982 {
1983     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1984
1985     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1986             rgDispId);
1987 }
1988
1989 static HRESULT WINAPI HTMLWindow5_Invoke(IHTMLWindow5 *iface, DISPID dispIdMember,
1990         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1991         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1992 {
1993     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1994
1995     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1996             pDispParams, pVarResult, pExcepInfo, puArgErr);
1997 }
1998
1999 static HRESULT WINAPI HTMLWindow5_put_XMLHttpRequest(IHTMLWindow5 *iface, VARIANT v)
2000 {
2001     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
2002     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2003     return E_NOTIMPL;
2004 }
2005
2006 static HRESULT WINAPI HTMLWindow5_get_XMLHttpRequest(IHTMLWindow5 *iface, VARIANT *p)
2007 {
2008     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
2009     HTMLInnerWindow *window = This->inner_window;
2010
2011     TRACE("(%p)->(%p)\n", This, p);
2012
2013     if(!window->xhr_factory) {
2014         HRESULT hres;
2015
2016         hres = HTMLXMLHttpRequestFactory_Create(window, &window->xhr_factory);
2017         if(FAILED(hres)) {
2018             return hres;
2019         }
2020     }
2021
2022     V_VT(p) = VT_DISPATCH;
2023     V_DISPATCH(p) = (IDispatch*)&window->xhr_factory->IHTMLXMLHttpRequestFactory_iface;
2024     IDispatch_AddRef(V_DISPATCH(p));
2025
2026     return S_OK;
2027 }
2028
2029 static const IHTMLWindow5Vtbl HTMLWindow5Vtbl = {
2030     HTMLWindow5_QueryInterface,
2031     HTMLWindow5_AddRef,
2032     HTMLWindow5_Release,
2033     HTMLWindow5_GetTypeInfoCount,
2034     HTMLWindow5_GetTypeInfo,
2035     HTMLWindow5_GetIDsOfNames,
2036     HTMLWindow5_Invoke,
2037     HTMLWindow5_put_XMLHttpRequest,
2038     HTMLWindow5_get_XMLHttpRequest
2039 };
2040
2041 static inline HTMLWindow *impl_from_IHTMLWindow6(IHTMLWindow6 *iface)
2042 {
2043     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow6_iface);
2044 }
2045
2046 static HRESULT WINAPI HTMLWindow6_QueryInterface(IHTMLWindow6 *iface, REFIID riid, void **ppv)
2047 {
2048     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2049
2050     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2051 }
2052
2053 static ULONG WINAPI HTMLWindow6_AddRef(IHTMLWindow6 *iface)
2054 {
2055     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2056
2057     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2058 }
2059
2060 static ULONG WINAPI HTMLWindow6_Release(IHTMLWindow6 *iface)
2061 {
2062     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2063
2064     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2065 }
2066
2067 static HRESULT WINAPI HTMLWindow6_GetTypeInfoCount(IHTMLWindow6 *iface, UINT *pctinfo)
2068 {
2069     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2070
2071     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
2072 }
2073
2074 static HRESULT WINAPI HTMLWindow6_GetTypeInfo(IHTMLWindow6 *iface, UINT iTInfo,
2075                                               LCID lcid, ITypeInfo **ppTInfo)
2076 {
2077     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2078
2079     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2080 }
2081
2082 static HRESULT WINAPI HTMLWindow6_GetIDsOfNames(IHTMLWindow6 *iface, REFIID riid,
2083                                                 LPOLESTR *rgszNames, UINT cNames,
2084                                                 LCID lcid, DISPID *rgDispId)
2085 {
2086     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2087
2088     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
2089             rgDispId);
2090 }
2091
2092 static HRESULT WINAPI HTMLWindow6_Invoke(IHTMLWindow6 *iface, DISPID dispIdMember,
2093                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2094                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2095 {
2096     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2097
2098     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2099             pDispParams, pVarResult, pExcepInfo, puArgErr);
2100 }
2101
2102 static HRESULT WINAPI HTMLWindow6_put_XDomainRequest(IHTMLWindow6 *iface, VARIANT v)
2103 {
2104     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2105     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2106     return E_NOTIMPL;
2107 }
2108
2109 static HRESULT WINAPI HTMLWindow6_get_XDomainRequest(IHTMLWindow6 *iface, VARIANT *p)
2110 {
2111     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2112     FIXME("(%p)->(%p)\n", This, p);
2113     return E_NOTIMPL;
2114 }
2115
2116 static HRESULT WINAPI HTMLWindow6_get_sessionStorage(IHTMLWindow6 *iface, IHTMLStorage **p)
2117 {
2118     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2119
2120     FIXME("(%p)->(%p)\n", This, p);
2121
2122     if(!This->inner_window->session_storage) {
2123         HRESULT hres;
2124
2125         hres = create_storage(&This->inner_window->session_storage);
2126         if(FAILED(hres))
2127             return hres;
2128     }
2129
2130     IHTMLStorage_AddRef(This->inner_window->session_storage);
2131     *p = This->inner_window->session_storage;
2132     return S_OK;
2133 }
2134
2135 static HRESULT WINAPI HTMLWindow6_get_localStorage(IHTMLWindow6 *iface, IHTMLStorage **p)
2136 {
2137     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2138     FIXME("(%p)->(%p)\n", This, p);
2139     return E_NOTIMPL;
2140 }
2141
2142 static HRESULT WINAPI HTMLWindow6_put_onhashchange(IHTMLWindow6 *iface, VARIANT v)
2143 {
2144     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2145     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2146     return E_NOTIMPL;
2147 }
2148
2149 static HRESULT WINAPI HTMLWindow6_get_onhashchange(IHTMLWindow6 *iface, VARIANT *p)
2150 {
2151     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2152     FIXME("(%p)->(%p)\n", This, p);
2153     return E_NOTIMPL;
2154 }
2155
2156 static HRESULT WINAPI HTMLWindow6_get_maxConnectionsPerServer(IHTMLWindow6 *iface, LONG *p)
2157 {
2158     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2159     FIXME("(%p)->(%p)\n", This, p);
2160     return E_NOTIMPL;
2161 }
2162
2163 static HRESULT WINAPI HTMLWindow6_postMessage(IHTMLWindow6 *iface, BSTR msg, VARIANT targetOrigin)
2164 {
2165     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2166     DOMEvent *event;
2167     HRESULT hres;
2168
2169     FIXME("(%p)->(%s %s) semi-stub\n", This, debugstr_w(msg), debugstr_variant(&targetOrigin));
2170
2171     if(!This->inner_window->doc) {
2172         FIXME("No document\n");
2173         return E_FAIL;
2174     }
2175
2176     hres = create_document_event(This->inner_window->doc, EVENTID_MESSAGE, &event);
2177     if(FAILED(hres))
2178         return hres;
2179
2180     dispatch_event(&This->inner_window->event_target, event);
2181     IDOMEvent_Release(&event->IDOMEvent_iface);
2182     return S_OK;
2183 }
2184
2185 static HRESULT WINAPI HTMLWindow6_toStaticHTML(IHTMLWindow6 *iface, BSTR bstrHTML, BSTR *pbstrStaticHTML)
2186 {
2187     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2188     FIXME("(%p)->(%s %p)\n", This, debugstr_w(bstrHTML), pbstrStaticHTML);
2189     return E_NOTIMPL;
2190 }
2191
2192 static HRESULT WINAPI HTMLWindow6_put_onmessage(IHTMLWindow6 *iface, VARIANT v)
2193 {
2194     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2195
2196     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2197
2198     return set_window_event(This, EVENTID_MESSAGE, &v);
2199 }
2200
2201 static HRESULT WINAPI HTMLWindow6_get_onmessage(IHTMLWindow6 *iface, VARIANT *p)
2202 {
2203     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2204
2205     TRACE("(%p)->(%p)\n", This, p);
2206
2207     return get_window_event(This, EVENTID_MESSAGE, p);
2208 }
2209
2210 static HRESULT WINAPI HTMLWindow6_msWriteProfilerMark(IHTMLWindow6 *iface, BSTR bstrProfilerMark)
2211 {
2212     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2213     FIXME("(%p)->(%s)\n", This, debugstr_w(bstrProfilerMark));
2214     return E_NOTIMPL;
2215 }
2216
2217 static const IHTMLWindow6Vtbl HTMLWindow6Vtbl = {
2218     HTMLWindow6_QueryInterface,
2219     HTMLWindow6_AddRef,
2220     HTMLWindow6_Release,
2221     HTMLWindow6_GetTypeInfoCount,
2222     HTMLWindow6_GetTypeInfo,
2223     HTMLWindow6_GetIDsOfNames,
2224     HTMLWindow6_Invoke,
2225     HTMLWindow6_put_XDomainRequest,
2226     HTMLWindow6_get_XDomainRequest,
2227     HTMLWindow6_get_sessionStorage,
2228     HTMLWindow6_get_localStorage,
2229     HTMLWindow6_put_onhashchange,
2230     HTMLWindow6_get_onhashchange,
2231     HTMLWindow6_get_maxConnectionsPerServer,
2232     HTMLWindow6_postMessage,
2233     HTMLWindow6_toStaticHTML,
2234     HTMLWindow6_put_onmessage,
2235     HTMLWindow6_get_onmessage,
2236     HTMLWindow6_msWriteProfilerMark
2237 };
2238
2239 static inline HTMLWindow *impl_from_IHTMLWindow7(IHTMLWindow7 *iface)
2240 {
2241     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow7_iface);
2242 }
2243
2244 static HRESULT WINAPI HTMLWindow7_QueryInterface(IHTMLWindow7 *iface, REFIID riid, void **ppv)
2245 {
2246     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2247
2248     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2249 }
2250
2251 static ULONG WINAPI HTMLWindow7_AddRef(IHTMLWindow7 *iface)
2252 {
2253     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2254     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2255 }
2256
2257 static ULONG WINAPI HTMLWindow7_Release(IHTMLWindow7 *iface)
2258 {
2259     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2260     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2261 }
2262
2263 static HRESULT WINAPI HTMLWindow7_GetTypeInfoCount(IHTMLWindow7 *iface, UINT *pctinfo)
2264 {
2265     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2266     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
2267 }
2268
2269 static HRESULT WINAPI HTMLWindow7_GetTypeInfo(IHTMLWindow7 *iface, UINT iTInfo,
2270                                               LCID lcid, ITypeInfo **ppTInfo)
2271 {
2272     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2273     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2274 }
2275
2276 static HRESULT WINAPI HTMLWindow7_GetIDsOfNames(IHTMLWindow7 *iface, REFIID riid,
2277                                                 LPOLESTR *rgszNames, UINT cNames,
2278                                                 LCID lcid, DISPID *rgDispId)
2279 {
2280     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2281     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
2282             rgDispId);
2283 }
2284
2285 static HRESULT WINAPI HTMLWindow7_Invoke(IHTMLWindow7 *iface, DISPID dispIdMember,
2286                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2287                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2288 {
2289     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2290     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2291             pDispParams, pVarResult, pExcepInfo, puArgErr);
2292 }
2293
2294 static HRESULT WINAPI HTMLWindow7_getSelection(IHTMLWindow7 *iface, IHTMLSelection **p)
2295 {
2296     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2297     FIXME("(%p)->(%p)\n", This, p);
2298     return E_NOTIMPL;
2299 }
2300
2301 static HRESULT WINAPI HTMLWindow7_getComputedStyle(IHTMLWindow7 *iface, IHTMLDOMNode *node,
2302                                                    BSTR pseudo_elt, IHTMLCSSStyleDeclaration **p)
2303 {
2304     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2305     FIXME("(%p)->(%p %s %p)\n", This, node, debugstr_w(pseudo_elt), p);
2306     return E_NOTIMPL;
2307 }
2308
2309 static HRESULT WINAPI HTMLWindow7_get_styleMedia(IHTMLWindow7 *iface, IHTMLStyleMedia **p)
2310 {
2311     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2312     FIXME("(%p)->(%p)\n", This, p);
2313     return E_NOTIMPL;
2314 }
2315
2316 static HRESULT WINAPI HTMLWindow7_put_performance(IHTMLWindow7 *iface, VARIANT v)
2317 {
2318     HTMLInnerWindow *This = impl_from_IHTMLWindow7(iface)->inner_window;
2319
2320     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2321
2322     if(!This->performance_initialized) {
2323         V_VT(&This->performance) = VT_EMPTY;
2324         This->performance_initialized = TRUE;
2325     }
2326
2327     return VariantCopy(&This->performance, &v);
2328 }
2329
2330 static HRESULT WINAPI HTMLWindow7_get_performance(IHTMLWindow7 *iface, VARIANT *p)
2331 {
2332     HTMLInnerWindow *This = impl_from_IHTMLWindow7(iface)->inner_window;
2333     HRESULT hres;
2334
2335     TRACE("(%p)->(%p)\n", This, p);
2336
2337     if(!This->performance_initialized) {
2338         IHTMLPerformance *performance;
2339
2340         hres = create_performance(&performance);
2341         if(FAILED(hres))
2342             return hres;
2343
2344         V_VT(&This->performance) = VT_DISPATCH;
2345         V_DISPATCH(&This->performance) = (IDispatch*)performance;
2346         This->performance_initialized = TRUE;
2347     }
2348
2349     V_VT(p) = VT_NULL;
2350     return VariantCopy(p, &This->performance);
2351 }
2352
2353 static HRESULT WINAPI HTMLWindow7_get_innerWidth(IHTMLWindow7 *iface, LONG *p)
2354 {
2355     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2356     INT32 ret;
2357     nsresult nsres;
2358
2359     TRACE("(%p)->(%p)\n", This, p);
2360
2361     nsres = nsIDOMWindow_GetInnerWidth(This->outer_window->nswindow, &ret);
2362     if(NS_FAILED(nsres)) {
2363         ERR("GetInnerWidth failed: %08x\n", nsres);
2364         return E_FAIL;
2365     }
2366
2367     *p = ret;
2368     return S_OK;
2369 }
2370
2371 static HRESULT WINAPI HTMLWindow7_get_innerHeight(IHTMLWindow7 *iface, LONG *p)
2372 {
2373     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2374     INT32 ret;
2375     nsresult nsres;
2376
2377     TRACE("(%p)->(%p)\n", This, p);
2378
2379     nsres = nsIDOMWindow_GetInnerHeight(This->outer_window->nswindow, &ret);
2380     if(NS_FAILED(nsres)) {
2381         ERR("GetInnerWidth failed: %08x\n", nsres);
2382         return E_FAIL;
2383     }
2384
2385     *p = ret;
2386     return S_OK;
2387 }
2388
2389 static HRESULT WINAPI HTMLWindow7_get_pageXOffset(IHTMLWindow7 *iface, LONG *p)
2390 {
2391     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2392     FIXME("(%p)->(%p)\n", This, p);
2393     return E_NOTIMPL;
2394 }
2395
2396 static HRESULT WINAPI HTMLWindow7_get_pageYOffset(IHTMLWindow7 *iface, LONG *p)
2397 {
2398     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2399     FIXME("(%p)->(%p)\n", This, p);
2400     return E_NOTIMPL;
2401 }
2402
2403 static HRESULT WINAPI HTMLWindow7_get_screenX(IHTMLWindow7 *iface, LONG *p)
2404 {
2405     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2406     FIXME("(%p)->(%p)\n", This, p);
2407     return E_NOTIMPL;
2408 }
2409
2410 static HRESULT WINAPI HTMLWindow7_get_screenY(IHTMLWindow7 *iface, LONG *p)
2411 {
2412     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2413     FIXME("(%p)->(%p)\n", This, p);
2414     return E_NOTIMPL;
2415 }
2416
2417 static HRESULT WINAPI HTMLWindow7_get_outerWidth(IHTMLWindow7 *iface, LONG *p)
2418 {
2419     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2420     FIXME("(%p)->(%p)\n", This, p);
2421     return E_NOTIMPL;
2422 }
2423
2424 static HRESULT WINAPI HTMLWindow7_get_outerHeight(IHTMLWindow7 *iface, LONG *p)
2425 {
2426     HTMLWindow *This = impl_from_IHTMLWindow7(iface);
2427     FIXME("(%p)->(%p)\n", This, p);
2428     return E_NOTIMPL;
2429 }
2430
2431 #define HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(name, event_id) \
2432     static HRESULT WINAPI HTMLWindow7_put_on##name(IHTMLWindow7 *iface, VARIANT v) \
2433     { \
2434         HTMLWindow *This = impl_from_IHTMLWindow7(iface); \
2435         TRACE("(%p)->(%s)\n", This, debugstr_variant(&v)); \
2436         return set_window_event(This, event_id, &v); \
2437     } \
2438     static HRESULT WINAPI HTMLWindow7_get_on##name(IHTMLWindow7 *iface, VARIANT *p) \
2439     { \
2440         HTMLWindow *This = impl_from_IHTMLWindow7(iface); \
2441         TRACE("(%p)->(%p)\n", This, p); \
2442         return get_window_event(This, event_id, p); \
2443     }
2444
2445 #define HTMLWINDOW7_ONEVENT_PROPERTY_STUB(name)                         \
2446     static HRESULT WINAPI HTMLWindow7_put_on##name(IHTMLWindow7 *iface, VARIANT v) \
2447     { \
2448         HTMLWindow *This = impl_from_IHTMLWindow7(iface); \
2449         FIXME("(%p)->(%s)\n", This, debugstr_variant(&v)); \
2450         return E_NOTIMPL; \
2451     } \
2452     static HRESULT WINAPI HTMLWindow7_get_on##name(IHTMLWindow7 *iface, VARIANT *p) \
2453     { \
2454         HTMLWindow *This = impl_from_IHTMLWindow7(iface); \
2455         FIXME("(%p)->(%p)\n", This, p); \
2456         return E_NOTIMPL; \
2457     }
2458
2459 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(abort,            EVENTID_ABORT)
2460 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(canplay)
2461 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(canplaythrough)
2462 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(change)
2463 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(click)
2464 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(contextmenu,      EVENTID_CONTEXTMENU)
2465 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(dblclick,         EVENTID_DBLCLICK)
2466 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(drag,             EVENTID_DRAG)
2467 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(dragend)
2468 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(dragenter)
2469 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(dragleave)
2470 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(dragover)
2471 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(dragstart,        EVENTID_DRAGSTART)
2472 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(drop)
2473 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(durationchange)
2474 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(focusin,          EVENTID_FOCUSIN)
2475 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(focusout,         EVENTID_FOCUSOUT)
2476 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(input,            EVENTID_INPUT)
2477 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(emptied)
2478 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(ended)
2479 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(keydown,          EVENTID_KEYDOWN)
2480 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(keypress,         EVENTID_KEYPRESS)
2481 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(keyup)
2482 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(loadeddata)
2483 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(loadedmetadata)
2484 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(loadstart)
2485 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(mousedown,        EVENTID_MOUSEDOWN)
2486 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(mouseenter)
2487 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(mouseleave)
2488 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(mousemove,        EVENTID_MOUSEMOVE)
2489 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(mouseout,         EVENTID_MOUSEOUT)
2490 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(mouseover,        EVENTID_MOUSEOVER)
2491 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(mouseup,          EVENTID_MOUSEUP)
2492 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(mousewheel,       EVENTID_MOUSEWHEEL)
2493 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(offline)
2494 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(online)
2495 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(progress)
2496 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(ratechange)
2497 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(readystatechange, EVENTID_READYSTATECHANGE)
2498 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(reset)
2499 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(seeked)
2500 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(seeking)
2501 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(select)
2502 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(stalled)
2503 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(storage)
2504 HTMLWINDOW7_ONEVENT_PROPERTY_IMPL(submit,           EVENTID_SUBMIT)
2505 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(suspend)
2506 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(timeupdate)
2507 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(pause)
2508 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(play)
2509 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(playing)
2510 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(volumechange)
2511 HTMLWINDOW7_ONEVENT_PROPERTY_STUB(waiting)
2512
2513 static const IHTMLWindow7Vtbl HTMLWindow7Vtbl = {
2514     HTMLWindow7_QueryInterface,
2515     HTMLWindow7_AddRef,
2516     HTMLWindow7_Release,
2517     HTMLWindow7_GetTypeInfoCount,
2518     HTMLWindow7_GetTypeInfo,
2519     HTMLWindow7_GetIDsOfNames,
2520     HTMLWindow7_Invoke,
2521     HTMLWindow7_getSelection,
2522     HTMLWindow7_getComputedStyle,
2523     HTMLWindow7_get_styleMedia,
2524     HTMLWindow7_put_performance,
2525     HTMLWindow7_get_performance,
2526     HTMLWindow7_get_innerWidth,
2527     HTMLWindow7_get_innerHeight,
2528     HTMLWindow7_get_pageXOffset,
2529     HTMLWindow7_get_pageYOffset,
2530     HTMLWindow7_get_screenX,
2531     HTMLWindow7_get_screenY,
2532     HTMLWindow7_get_outerWidth,
2533     HTMLWindow7_get_outerHeight,
2534     HTMLWindow7_put_onabort,
2535     HTMLWindow7_get_onabort,
2536     HTMLWindow7_put_oncanplay,
2537     HTMLWindow7_get_oncanplay,
2538     HTMLWindow7_put_oncanplaythrough,
2539     HTMLWindow7_get_oncanplaythrough,
2540     HTMLWindow7_put_onchange,
2541     HTMLWindow7_get_onchange,
2542     HTMLWindow7_put_onclick,
2543     HTMLWindow7_get_onclick,
2544     HTMLWindow7_put_oncontextmenu,
2545     HTMLWindow7_get_oncontextmenu,
2546     HTMLWindow7_put_ondblclick,
2547     HTMLWindow7_get_ondblclick,
2548     HTMLWindow7_put_ondrag,
2549     HTMLWindow7_get_ondrag,
2550     HTMLWindow7_put_ondragend,
2551     HTMLWindow7_get_ondragend,
2552     HTMLWindow7_put_ondragenter,
2553     HTMLWindow7_get_ondragenter,
2554     HTMLWindow7_put_ondragleave,
2555     HTMLWindow7_get_ondragleave,
2556     HTMLWindow7_put_ondragover,
2557     HTMLWindow7_get_ondragover,
2558     HTMLWindow7_put_ondragstart,
2559     HTMLWindow7_get_ondragstart,
2560     HTMLWindow7_put_ondrop,
2561     HTMLWindow7_get_ondrop,
2562     HTMLWindow7_put_ondurationchange,
2563     HTMLWindow7_get_ondurationchange,
2564     HTMLWindow7_put_onfocusin,
2565     HTMLWindow7_get_onfocusin,
2566     HTMLWindow7_put_onfocusout,
2567     HTMLWindow7_get_onfocusout,
2568     HTMLWindow7_put_oninput,
2569     HTMLWindow7_get_oninput,
2570     HTMLWindow7_put_onemptied,
2571     HTMLWindow7_get_onemptied,
2572     HTMLWindow7_put_onended,
2573     HTMLWindow7_get_onended,
2574     HTMLWindow7_put_onkeydown,
2575     HTMLWindow7_get_onkeydown,
2576     HTMLWindow7_put_onkeypress,
2577     HTMLWindow7_get_onkeypress,
2578     HTMLWindow7_put_onkeyup,
2579     HTMLWindow7_get_onkeyup,
2580     HTMLWindow7_put_onloadeddata,
2581     HTMLWindow7_get_onloadeddata,
2582     HTMLWindow7_put_onloadedmetadata,
2583     HTMLWindow7_get_onloadedmetadata,
2584     HTMLWindow7_put_onloadstart,
2585     HTMLWindow7_get_onloadstart,
2586     HTMLWindow7_put_onmousedown,
2587     HTMLWindow7_get_onmousedown,
2588     HTMLWindow7_put_onmouseenter,
2589     HTMLWindow7_get_onmouseenter,
2590     HTMLWindow7_put_onmouseleave,
2591     HTMLWindow7_get_onmouseleave,
2592     HTMLWindow7_put_onmousemove,
2593     HTMLWindow7_get_onmousemove,
2594     HTMLWindow7_put_onmouseout,
2595     HTMLWindow7_get_onmouseout,
2596     HTMLWindow7_put_onmouseover,
2597     HTMLWindow7_get_onmouseover,
2598     HTMLWindow7_put_onmouseup,
2599     HTMLWindow7_get_onmouseup,
2600     HTMLWindow7_put_onmousewheel,
2601     HTMLWindow7_get_onmousewheel,
2602     HTMLWindow7_put_onoffline,
2603     HTMLWindow7_get_onoffline,
2604     HTMLWindow7_put_ononline,
2605     HTMLWindow7_get_ononline,
2606     HTMLWindow7_put_onprogress,
2607     HTMLWindow7_get_onprogress,
2608     HTMLWindow7_put_onratechange,
2609     HTMLWindow7_get_onratechange,
2610     HTMLWindow7_put_onreadystatechange,
2611     HTMLWindow7_get_onreadystatechange,
2612     HTMLWindow7_put_onreset,
2613     HTMLWindow7_get_onreset,
2614     HTMLWindow7_put_onseeked,
2615     HTMLWindow7_get_onseeked,
2616     HTMLWindow7_put_onseeking,
2617     HTMLWindow7_get_onseeking,
2618     HTMLWindow7_put_onselect,
2619     HTMLWindow7_get_onselect,
2620     HTMLWindow7_put_onstalled,
2621     HTMLWindow7_get_onstalled,
2622     HTMLWindow7_put_onstorage,
2623     HTMLWindow7_get_onstorage,
2624     HTMLWindow7_put_onsubmit,
2625     HTMLWindow7_get_onsubmit,
2626     HTMLWindow7_put_onsuspend,
2627     HTMLWindow7_get_onsuspend,
2628     HTMLWindow7_put_ontimeupdate,
2629     HTMLWindow7_get_ontimeupdate,
2630     HTMLWindow7_put_onpause,
2631     HTMLWindow7_get_onpause,
2632     HTMLWindow7_put_onplay,
2633     HTMLWindow7_get_onplay,
2634     HTMLWindow7_put_onplaying,
2635     HTMLWindow7_get_onplaying,
2636     HTMLWindow7_put_onvolumechange,
2637     HTMLWindow7_get_onvolumechange,
2638     HTMLWindow7_put_onwaiting,
2639     HTMLWindow7_get_onwaiting
2640 };
2641
2642 static inline HTMLWindow *impl_from_IHTMLPrivateWindow(IHTMLPrivateWindow *iface)
2643 {
2644     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLPrivateWindow_iface);
2645 }
2646
2647 static HRESULT WINAPI HTMLPrivateWindow_QueryInterface(IHTMLPrivateWindow *iface, REFIID riid, void **ppv)
2648 {
2649     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2650
2651     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2652 }
2653
2654 static ULONG WINAPI HTMLPrivateWindow_AddRef(IHTMLPrivateWindow *iface)
2655 {
2656     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2657
2658     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2659 }
2660
2661 static ULONG WINAPI HTMLPrivateWindow_Release(IHTMLPrivateWindow *iface)
2662 {
2663     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2664
2665     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2666 }
2667
2668 static HRESULT WINAPI HTMLPrivateWindow_SuperNavigate(IHTMLPrivateWindow *iface, BSTR url, BSTR arg2, BSTR arg3,
2669         BSTR arg4, VARIANT *post_data_var, VARIANT *headers_var, ULONG flags)
2670 {
2671     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2672     HTMLOuterWindow *window = This->outer_window;
2673     OLECHAR *translated_url = NULL;
2674     DWORD post_data_size = 0;
2675     BYTE *post_data = NULL;
2676     WCHAR *headers = NULL;
2677     IUri *uri;
2678     HRESULT hres;
2679
2680     TRACE("(%p)->(%s %s %s %s %s %s %x)\n", This, debugstr_w(url), debugstr_w(arg2), debugstr_w(arg3), debugstr_w(arg4),
2681           debugstr_variant(post_data_var), debugstr_variant(headers_var), flags);
2682
2683     if(window->doc_obj->hostui) {
2684         hres = IDocHostUIHandler_TranslateUrl(window->doc_obj->hostui, 0, url, &translated_url);
2685         if(hres != S_OK)
2686             translated_url = NULL;
2687     }
2688
2689     hres = create_uri(translated_url ? translated_url : url, 0, &uri);
2690     CoTaskMemFree(translated_url);
2691     if(FAILED(hres))
2692         return hres;
2693
2694     if(post_data_var) {
2695         if(V_VT(post_data_var) == (VT_ARRAY|VT_UI1)) {
2696             SafeArrayAccessData(V_ARRAY(post_data_var), (void**)&post_data);
2697             post_data_size = V_ARRAY(post_data_var)->rgsabound[0].cElements;
2698         }
2699     }
2700
2701     if(headers_var && V_VT(headers_var) != VT_EMPTY && V_VT(headers_var) != VT_ERROR) {
2702         if(V_VT(headers_var) != VT_BSTR)
2703             return E_INVALIDARG;
2704
2705         headers = V_BSTR(headers_var);
2706     }
2707
2708     hres = super_navigate(window, uri, BINDING_NAVIGATED|BINDING_NOFRAG, headers, post_data, post_data_size);
2709     IUri_Release(uri);
2710     if(post_data)
2711         SafeArrayUnaccessData(V_ARRAY(post_data_var));
2712
2713     return hres;
2714 }
2715
2716 static HRESULT WINAPI HTMLPrivateWindow_GetPendingUrl(IHTMLPrivateWindow *iface, BSTR *url)
2717 {
2718     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2719     FIXME("(%p)->(%p)\n", This, url);
2720     return E_NOTIMPL;
2721 }
2722
2723 static HRESULT WINAPI HTMLPrivateWindow_SetPICSTarget(IHTMLPrivateWindow *iface, IOleCommandTarget *cmdtrg)
2724 {
2725     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2726     FIXME("(%p)->(%p)\n", This, cmdtrg);
2727     return E_NOTIMPL;
2728 }
2729
2730 static HRESULT WINAPI HTMLPrivateWindow_PICSComplete(IHTMLPrivateWindow *iface, int arg)
2731 {
2732     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2733     FIXME("(%p)->(%x)\n", This, arg);
2734     return E_NOTIMPL;
2735 }
2736
2737 static HRESULT WINAPI HTMLPrivateWindow_FindWindowByName(IHTMLPrivateWindow *iface, LPCWSTR name, IHTMLWindow2 **ret)
2738 {
2739     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2740     FIXME("(%p)->(%s %p)\n", This, debugstr_w(name), ret);
2741     return E_NOTIMPL;
2742 }
2743
2744 static HRESULT WINAPI HTMLPrivateWindow_GetAddressBarUrl(IHTMLPrivateWindow *iface, BSTR *url)
2745 {
2746     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2747     TRACE("(%p)->(%p)\n", This, url);
2748
2749     if(!url)
2750         return E_INVALIDARG;
2751
2752     *url = SysAllocString(This->outer_window->url);
2753     return S_OK;
2754 }
2755
2756 static const IHTMLPrivateWindowVtbl HTMLPrivateWindowVtbl = {
2757     HTMLPrivateWindow_QueryInterface,
2758     HTMLPrivateWindow_AddRef,
2759     HTMLPrivateWindow_Release,
2760     HTMLPrivateWindow_SuperNavigate,
2761     HTMLPrivateWindow_GetPendingUrl,
2762     HTMLPrivateWindow_SetPICSTarget,
2763     HTMLPrivateWindow_PICSComplete,
2764     HTMLPrivateWindow_FindWindowByName,
2765     HTMLPrivateWindow_GetAddressBarUrl
2766 };
2767
2768 static inline HTMLWindow *impl_from_ITravelLogClient(ITravelLogClient *iface)
2769 {
2770     return CONTAINING_RECORD(iface, HTMLWindow, ITravelLogClient_iface);
2771 }
2772
2773 static HRESULT WINAPI TravelLogClient_QueryInterface(ITravelLogClient *iface, REFIID riid, void **ppv)
2774 {
2775     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2776
2777     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2778 }
2779
2780 static ULONG WINAPI TravelLogClient_AddRef(ITravelLogClient *iface)
2781 {
2782     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2783
2784     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2785 }
2786
2787 static ULONG WINAPI TravelLogClient_Release(ITravelLogClient *iface)
2788 {
2789     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2790
2791     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2792 }
2793
2794 static HRESULT WINAPI TravelLogClient_FindWindowByIndex(ITravelLogClient *iface, DWORD dwID, IUnknown **ppunk)
2795 {
2796     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2797
2798     FIXME("(%p)->(%d %p) semi-stub\n", This, dwID, ppunk);
2799
2800     *ppunk = NULL;
2801     return E_FAIL;
2802 }
2803
2804 static HRESULT WINAPI TravelLogClient_GetWindowData(ITravelLogClient *iface, IStream *pStream, LPWINDOWDATA pWinData)
2805 {
2806     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2807     FIXME("(%p)->(%p %p)\n", This, pStream, pWinData);
2808     return E_NOTIMPL;
2809 }
2810
2811 static HRESULT WINAPI TravelLogClient_LoadHistoryPosition(ITravelLogClient *iface, LPWSTR pszUrlLocation, DWORD dwPosition)
2812 {
2813     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2814     FIXME("(%p)->(%s %d)\n", This, debugstr_w(pszUrlLocation), dwPosition);
2815     return E_NOTIMPL;
2816 }
2817
2818 static const ITravelLogClientVtbl TravelLogClientVtbl = {
2819     TravelLogClient_QueryInterface,
2820     TravelLogClient_AddRef,
2821     TravelLogClient_Release,
2822     TravelLogClient_FindWindowByIndex,
2823     TravelLogClient_GetWindowData,
2824     TravelLogClient_LoadHistoryPosition
2825 };
2826
2827 static inline HTMLWindow *impl_from_IObjectIdentity(IObjectIdentity *iface)
2828 {
2829     return CONTAINING_RECORD(iface, HTMLWindow, IObjectIdentity_iface);
2830 }
2831
2832 static HRESULT WINAPI ObjectIdentity_QueryInterface(IObjectIdentity *iface, REFIID riid, void **ppv)
2833 {
2834     HTMLWindow *This = impl_from_IObjectIdentity(iface);
2835
2836     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2837 }
2838
2839 static ULONG WINAPI ObjectIdentity_AddRef(IObjectIdentity *iface)
2840 {
2841     HTMLWindow *This = impl_from_IObjectIdentity(iface);
2842
2843     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2844 }
2845
2846 static ULONG WINAPI ObjectIdentity_Release(IObjectIdentity *iface)
2847 {
2848     HTMLWindow *This = impl_from_IObjectIdentity(iface);
2849
2850     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2851 }
2852
2853 static HRESULT WINAPI ObjectIdentity_IsEqualObject(IObjectIdentity *iface, IUnknown *unk)
2854 {
2855     HTMLWindow *This = impl_from_IObjectIdentity(iface);
2856     IServiceProvider *sp;
2857     HRESULT hres;
2858
2859     TRACE("(%p)->(%p)\n", This, unk);
2860
2861     hres = IUnknown_QueryInterface(unk, &IID_IServiceProvider, (void**)&sp);
2862     if(hres != S_OK)
2863         return hres;
2864
2865     hres = &This->inner_window->base.IServiceProvider_iface==sp ||
2866         &This->outer_window->base.IServiceProvider_iface==sp ? S_OK : S_FALSE;
2867     IServiceProvider_Release(sp);
2868     return hres;
2869 }
2870
2871 static const IObjectIdentityVtbl ObjectIdentityVtbl = {
2872     ObjectIdentity_QueryInterface,
2873     ObjectIdentity_AddRef,
2874     ObjectIdentity_Release,
2875     ObjectIdentity_IsEqualObject
2876 };
2877
2878 static inline HTMLWindow *impl_from_IProvideMultipleClassInfo(IProvideMultipleClassInfo *iface)
2879 {
2880     return CONTAINING_RECORD(iface, HTMLWindow, IProvideMultipleClassInfo_iface);
2881 }
2882
2883 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideMultipleClassInfo *iface,
2884         REFIID riid, void **ppv)
2885 {
2886     HTMLWindow *This = impl_from_IProvideMultipleClassInfo(iface);
2887     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2888 }
2889
2890 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideMultipleClassInfo *iface)
2891 {
2892     HTMLWindow *This = impl_from_IProvideMultipleClassInfo(iface);
2893     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2894 }
2895
2896 static ULONG WINAPI ProvideClassInfo_Release(IProvideMultipleClassInfo *iface)
2897 {
2898     HTMLWindow *This = impl_from_IProvideMultipleClassInfo(iface);
2899     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2900 }
2901
2902 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideMultipleClassInfo *iface, ITypeInfo **ppTI)
2903 {
2904     HTMLWindow *This = impl_from_IProvideMultipleClassInfo(iface);
2905     TRACE("(%p)->(%p)\n", This, ppTI);
2906     return get_class_typeinfo(&CLSID_HTMLWindow2, ppTI);
2907 }
2908
2909 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideMultipleClassInfo *iface, DWORD dwGuidKind, GUID *pGUID)
2910 {
2911     HTMLWindow *This = impl_from_IProvideMultipleClassInfo(iface);
2912     FIXME("(%p)->(%u %p)\n", This, dwGuidKind, pGUID);
2913     return E_NOTIMPL;
2914 }
2915
2916 static HRESULT WINAPI ProvideMultipleClassInfo_GetMultiTypeInfoCount(IProvideMultipleClassInfo *iface, ULONG *pcti)
2917 {
2918     HTMLWindow *This = impl_from_IProvideMultipleClassInfo(iface);
2919     FIXME("(%p)->(%p)\n", This, pcti);
2920     *pcti = 1;
2921     return S_OK;
2922 }
2923
2924 static HRESULT WINAPI ProvideMultipleClassInfo_GetInfoOfIndex(IProvideMultipleClassInfo *iface, ULONG iti,
2925         DWORD dwFlags, ITypeInfo **pptiCoClass, DWORD *pdwTIFlags, ULONG *pcdispidReserved, IID *piidPrimary, IID *piidSource)
2926 {
2927     HTMLWindow *This = impl_from_IProvideMultipleClassInfo(iface);
2928     FIXME("(%p)->(%u %x %p %p %p %p %p)\n", This, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource);
2929     return E_NOTIMPL;
2930 }
2931
2932 static const IProvideMultipleClassInfoVtbl ProvideMultipleClassInfoVtbl = {
2933     ProvideClassInfo_QueryInterface,
2934     ProvideClassInfo_AddRef,
2935     ProvideClassInfo_Release,
2936     ProvideClassInfo_GetClassInfo,
2937     ProvideClassInfo2_GetGUID,
2938     ProvideMultipleClassInfo_GetMultiTypeInfoCount,
2939     ProvideMultipleClassInfo_GetInfoOfIndex
2940 };
2941
2942 static inline HTMLWindow *impl_from_IDispatchEx(IDispatchEx *iface)
2943 {
2944     return CONTAINING_RECORD(iface, HTMLWindow, IDispatchEx_iface);
2945 }
2946
2947 static HRESULT WINAPI WindowDispEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
2948 {
2949     HTMLWindow *This = impl_from_IDispatchEx(iface);
2950
2951     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2952 }
2953
2954 static ULONG WINAPI WindowDispEx_AddRef(IDispatchEx *iface)
2955 {
2956     HTMLWindow *This = impl_from_IDispatchEx(iface);
2957
2958     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2959 }
2960
2961 static ULONG WINAPI WindowDispEx_Release(IDispatchEx *iface)
2962 {
2963     HTMLWindow *This = impl_from_IDispatchEx(iface);
2964
2965     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2966 }
2967
2968 static HRESULT WINAPI WindowDispEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
2969 {
2970     HTMLWindow *This = impl_from_IDispatchEx(iface);
2971
2972     TRACE("(%p)->(%p)\n", This, pctinfo);
2973
2974     return IDispatchEx_GetTypeInfoCount(&This->inner_window->event_target.dispex.IDispatchEx_iface, pctinfo);
2975 }
2976
2977 static HRESULT WINAPI WindowDispEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
2978                                                LCID lcid, ITypeInfo **ppTInfo)
2979 {
2980     HTMLWindow *This = impl_from_IDispatchEx(iface);
2981
2982     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2983
2984     return IDispatchEx_GetTypeInfo(&This->inner_window->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2985 }
2986
2987 static HRESULT WINAPI WindowDispEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
2988                                                  LPOLESTR *rgszNames, UINT cNames,
2989                                                  LCID lcid, DISPID *rgDispId)
2990 {
2991     HTMLWindow *This = impl_from_IDispatchEx(iface);
2992     UINT i;
2993     HRESULT hres;
2994
2995     WARN("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
2996
2997     for(i=0; i < cNames; i++) {
2998         /* We shouldn't use script's IDispatchEx here, so we shouldn't use GetDispID */
2999         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
3000         if(FAILED(hres))
3001             return hres;
3002     }
3003
3004     return S_OK;
3005 }
3006
3007 static HRESULT WINAPI WindowDispEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
3008                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3009                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3010 {
3011     HTMLWindow *This = impl_from_IDispatchEx(iface);
3012
3013     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
3014           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3015
3016     /* FIXME: Use script dispatch */
3017
3018     return IDispatchEx_Invoke(&This->inner_window->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
3019             pDispParams, pVarResult, pExcepInfo, puArgErr);
3020 }
3021
3022 static global_prop_t *alloc_global_prop(HTMLInnerWindow *This, global_prop_type_t type, BSTR name)
3023 {
3024     if(This->global_prop_cnt == This->global_prop_size) {
3025         global_prop_t *new_props;
3026         DWORD new_size;
3027
3028         if(This->global_props) {
3029             new_size = This->global_prop_size*2;
3030             new_props = heap_realloc(This->global_props, new_size*sizeof(global_prop_t));
3031         }else {
3032             new_size = 16;
3033             new_props = heap_alloc(new_size*sizeof(global_prop_t));
3034         }
3035         if(!new_props)
3036             return NULL;
3037         This->global_props = new_props;
3038         This->global_prop_size = new_size;
3039     }
3040
3041     This->global_props[This->global_prop_cnt].name = heap_strdupW(name);
3042     if(!This->global_props[This->global_prop_cnt].name)
3043         return NULL;
3044
3045     This->global_props[This->global_prop_cnt].type = type;
3046     return This->global_props + This->global_prop_cnt++;
3047 }
3048
3049 static inline DWORD prop_to_dispid(HTMLInnerWindow *This, global_prop_t *prop)
3050 {
3051     return MSHTML_DISPID_CUSTOM_MIN + (prop-This->global_props);
3052 }
3053
3054 HRESULT search_window_props(HTMLInnerWindow *This, BSTR bstrName, DWORD grfdex, DISPID *pid)
3055 {
3056     DWORD i;
3057     ScriptHost *script_host;
3058     DISPID id;
3059
3060     for(i=0; i < This->global_prop_cnt; i++) {
3061         /* FIXME: case sensitivity */
3062         if(!strcmpW(This->global_props[i].name, bstrName)) {
3063             *pid = MSHTML_DISPID_CUSTOM_MIN+i;
3064             return S_OK;
3065         }
3066     }
3067
3068     if(find_global_prop(This->base.inner_window, bstrName, grfdex, &script_host, &id)) {
3069         global_prop_t *prop;
3070
3071         prop = alloc_global_prop(This, GLOBAL_SCRIPTVAR, bstrName);
3072         if(!prop)
3073             return E_OUTOFMEMORY;
3074
3075         prop->script_host = script_host;
3076         prop->id = id;
3077
3078         *pid = prop_to_dispid(This, prop);
3079         return S_OK;
3080     }
3081
3082     return DISP_E_UNKNOWNNAME;
3083 }
3084
3085 static HRESULT WINAPI WindowDispEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
3086 {
3087     HTMLWindow *This = impl_from_IDispatchEx(iface);
3088     HTMLInnerWindow *window = This->inner_window;
3089     HRESULT hres;
3090
3091     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
3092
3093     hres = search_window_props(window, bstrName, grfdex, pid);
3094     if(hres != DISP_E_UNKNOWNNAME)
3095         return hres;
3096
3097     hres = IDispatchEx_GetDispID(&window->base.inner_window->event_target.dispex.IDispatchEx_iface, bstrName, grfdex, pid);
3098     if(hres != DISP_E_UNKNOWNNAME)
3099         return hres;
3100
3101     if(This->outer_window) {
3102         HTMLOuterWindow *frame;
3103
3104         hres = get_frame_by_name(This->outer_window, bstrName, FALSE, &frame);
3105         if(SUCCEEDED(hres) && frame) {
3106             global_prop_t *prop;
3107
3108             IHTMLWindow2_Release(&frame->base.IHTMLWindow2_iface);
3109
3110             prop = alloc_global_prop(window, GLOBAL_FRAMEVAR, bstrName);
3111             if(!prop)
3112                 return E_OUTOFMEMORY;
3113
3114             *pid = prop_to_dispid(window, prop);
3115             return S_OK;
3116         }
3117     }
3118
3119     if(window->doc) {
3120         global_prop_t *prop;
3121         IHTMLElement *elem;
3122
3123         hres = IHTMLDocument3_getElementById(&window->base.inner_window->doc->basedoc.IHTMLDocument3_iface,
3124                                              bstrName, &elem);
3125         if(SUCCEEDED(hres) && elem) {
3126             IHTMLElement_Release(elem);
3127
3128             prop = alloc_global_prop(window, GLOBAL_ELEMENTVAR, bstrName);
3129             if(!prop)
3130                 return E_OUTOFMEMORY;
3131
3132             *pid = prop_to_dispid(window, prop);
3133             return S_OK;
3134         }
3135     }
3136
3137     return DISP_E_UNKNOWNNAME;
3138 }
3139
3140 static HRESULT WINAPI WindowDispEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
3141         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
3142 {
3143     HTMLWindow *This = impl_from_IDispatchEx(iface);
3144     HTMLInnerWindow *window = This->inner_window;
3145
3146     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
3147
3148     switch(id) {
3149     case DISPID_IHTMLWINDOW2_LOCATION: {
3150         HTMLLocation *location;
3151         HRESULT hres;
3152
3153         if(!(wFlags & DISPATCH_PROPERTYPUT))
3154             break;
3155
3156         TRACE("forwarding to location.href\n");
3157
3158         hres = get_location(window, &location);
3159         if(FAILED(hres))
3160             return hres;
3161
3162         hres = IDispatchEx_InvokeEx(&location->dispex.IDispatchEx_iface, DISPID_VALUE, lcid,
3163                 wFlags, pdp, pvarRes, pei, pspCaller);
3164         IHTMLLocation_Release(&location->IHTMLLocation_iface);
3165         return hres;
3166     }
3167     case DISPID_IHTMLWINDOW2_SETTIMEOUT:
3168     case DISPID_IHTMLWINDOW3_SETTIMEOUT: {
3169         VARIANT args[2];
3170         DISPPARAMS dp = {args, NULL, 2, 0};
3171
3172         /*
3173          * setTimeout calls should use default value 0 for the second argument if only one is provided,
3174          * but IDL file does not reflect that. We fixup arguments here instead.
3175          */
3176         if(!(wFlags & DISPATCH_METHOD) || pdp->cArgs != 1 || pdp->cNamedArgs)
3177             break;
3178
3179         TRACE("Fixing args\n");
3180
3181         V_VT(args) = VT_I4;
3182         V_I4(args) = 0;
3183         args[1] = *pdp->rgvarg;
3184         return IDispatchEx_InvokeEx(&window->event_target.dispex.IDispatchEx_iface, id, lcid,
3185                 wFlags, &dp, pvarRes, pei, pspCaller);
3186     }
3187     }
3188
3189     return IDispatchEx_InvokeEx(&window->event_target.dispex.IDispatchEx_iface, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
3190 }
3191
3192 static HRESULT WINAPI WindowDispEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
3193 {
3194     HTMLWindow *This = impl_from_IDispatchEx(iface);
3195
3196     TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
3197
3198     return IDispatchEx_DeleteMemberByName(&This->inner_window->event_target.dispex.IDispatchEx_iface, bstrName, grfdex);
3199 }
3200
3201 static HRESULT WINAPI WindowDispEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
3202 {
3203     HTMLWindow *This = impl_from_IDispatchEx(iface);
3204
3205     TRACE("(%p)->(%x)\n", This, id);
3206
3207     return IDispatchEx_DeleteMemberByDispID(&This->inner_window->event_target.dispex.IDispatchEx_iface, id);
3208 }
3209
3210 static HRESULT WINAPI WindowDispEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
3211 {
3212     HTMLWindow *This = impl_from_IDispatchEx(iface);
3213
3214     TRACE("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
3215
3216     return IDispatchEx_GetMemberProperties(&This->inner_window->event_target.dispex.IDispatchEx_iface, id, grfdexFetch,
3217             pgrfdex);
3218 }
3219
3220 static HRESULT WINAPI WindowDispEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
3221 {
3222     HTMLWindow *This = impl_from_IDispatchEx(iface);
3223
3224     TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
3225
3226     return IDispatchEx_GetMemberName(&This->inner_window->event_target.dispex.IDispatchEx_iface, id, pbstrName);
3227 }
3228
3229 static HRESULT WINAPI WindowDispEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
3230 {
3231     HTMLWindow *This = impl_from_IDispatchEx(iface);
3232
3233     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
3234
3235     return IDispatchEx_GetNextDispID(&This->inner_window->event_target.dispex.IDispatchEx_iface, grfdex, id, pid);
3236 }
3237
3238 static HRESULT WINAPI WindowDispEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
3239 {
3240     HTMLWindow *This = impl_from_IDispatchEx(iface);
3241
3242     TRACE("(%p)->(%p)\n", This, ppunk);
3243
3244     *ppunk = NULL;
3245     return S_OK;
3246 }
3247
3248 static const IDispatchExVtbl WindowDispExVtbl = {
3249     WindowDispEx_QueryInterface,
3250     WindowDispEx_AddRef,
3251     WindowDispEx_Release,
3252     WindowDispEx_GetTypeInfoCount,
3253     WindowDispEx_GetTypeInfo,
3254     WindowDispEx_GetIDsOfNames,
3255     WindowDispEx_Invoke,
3256     WindowDispEx_GetDispID,
3257     WindowDispEx_InvokeEx,
3258     WindowDispEx_DeleteMemberByName,
3259     WindowDispEx_DeleteMemberByDispID,
3260     WindowDispEx_GetMemberProperties,
3261     WindowDispEx_GetMemberName,
3262     WindowDispEx_GetNextDispID,
3263     WindowDispEx_GetNameSpaceParent
3264 };
3265
3266 static inline HTMLWindow *impl_from_IServiceProvider(IServiceProvider *iface)
3267 {
3268     return CONTAINING_RECORD(iface, HTMLWindow, IServiceProvider_iface);
3269 }
3270
3271 static HRESULT WINAPI HTMLWindowSP_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
3272 {
3273     HTMLWindow *This = impl_from_IServiceProvider(iface);
3274     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
3275 }
3276
3277 static ULONG WINAPI HTMLWindowSP_AddRef(IServiceProvider *iface)
3278 {
3279     HTMLWindow *This = impl_from_IServiceProvider(iface);
3280     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
3281 }
3282
3283 static ULONG WINAPI HTMLWindowSP_Release(IServiceProvider *iface)
3284 {
3285     HTMLWindow *This = impl_from_IServiceProvider(iface);
3286     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
3287 }
3288
3289 static HRESULT WINAPI HTMLWindowSP_QueryService(IServiceProvider *iface, REFGUID guidService, REFIID riid, void **ppv)
3290 {
3291     HTMLWindow *This = impl_from_IServiceProvider(iface);
3292
3293     if(IsEqualGUID(guidService, &IID_IHTMLWindow2)) {
3294         TRACE("IID_IHTMLWindow2\n");
3295         return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
3296     }
3297
3298     TRACE("(%p)->(%s %s %p)\n", This, debugstr_mshtml_guid(guidService), debugstr_mshtml_guid(riid), ppv);
3299
3300     if(!This->outer_window->doc_obj)
3301         return E_NOINTERFACE;
3302
3303     return IServiceProvider_QueryService(&This->outer_window->doc_obj->basedoc.IServiceProvider_iface,
3304             guidService, riid, ppv);
3305 }
3306
3307 static const IServiceProviderVtbl ServiceProviderVtbl = {
3308     HTMLWindowSP_QueryInterface,
3309     HTMLWindowSP_AddRef,
3310     HTMLWindowSP_Release,
3311     HTMLWindowSP_QueryService
3312 };
3313
3314 static inline HTMLInnerWindow *impl_from_DispatchEx(DispatchEx *iface)
3315 {
3316     return CONTAINING_RECORD(iface, HTMLInnerWindow, event_target.dispex);
3317 }
3318
3319 static HRESULT HTMLWindow_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
3320         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
3321 {
3322     HTMLInnerWindow *This = impl_from_DispatchEx(dispex);
3323     global_prop_t *prop;
3324     DWORD idx;
3325     HRESULT hres;
3326
3327     idx = id - MSHTML_DISPID_CUSTOM_MIN;
3328     if(idx >= This->global_prop_cnt)
3329         return DISP_E_MEMBERNOTFOUND;
3330
3331     prop = This->global_props+idx;
3332
3333     switch(prop->type) {
3334     case GLOBAL_SCRIPTVAR: {
3335         IDispatchEx *iface;
3336         IDispatch *disp;
3337
3338         disp = get_script_disp(prop->script_host);
3339         if(!disp)
3340             return E_UNEXPECTED;
3341
3342         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&iface);
3343         if(SUCCEEDED(hres)) {
3344             TRACE("%s >>>\n", debugstr_w(prop->name));
3345             hres = IDispatchEx_InvokeEx(iface, prop->id, lcid, flags, params, res, ei, caller);
3346             if(hres == S_OK)
3347                 TRACE("%s <<<\n", debugstr_w(prop->name));
3348             else
3349                 WARN("%s <<< %08x\n", debugstr_w(prop->name), hres);
3350             IDispatchEx_Release(iface);
3351         }else {
3352             FIXME("No IDispatchEx\n");
3353         }
3354         IDispatch_Release(disp);
3355         break;
3356     }
3357     case GLOBAL_ELEMENTVAR:
3358         switch(flags) {
3359         case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
3360         case DISPATCH_PROPERTYGET: {
3361             IHTMLElement *elem;
3362
3363             hres = IHTMLDocument3_getElementById(&This->base.inner_window->doc->basedoc.IHTMLDocument3_iface,
3364                     prop->name, &elem);
3365             if(FAILED(hres))
3366                 return hres;
3367
3368             if(!elem)
3369                 return DISP_E_MEMBERNOTFOUND;
3370
3371             V_VT(res) = VT_DISPATCH;
3372             V_DISPATCH(res) = (IDispatch*)elem;
3373             return S_OK;
3374         }
3375         case DISPATCH_PROPERTYPUT: {
3376             DISPID dispex_id;
3377
3378             hres = dispex_get_dynid(&This->event_target.dispex, prop->name, &dispex_id);
3379             if(FAILED(hres))
3380                 return hres;
3381
3382             prop->type = GLOBAL_DISPEXVAR;
3383             prop->id = dispex_id;
3384             return IDispatchEx_InvokeEx(&This->event_target.dispex.IDispatchEx_iface, dispex_id, 0, flags, params, res, ei, caller);
3385         }
3386         default:
3387             FIXME("Not supported flags: %x\n", flags);
3388             return E_NOTIMPL;
3389         }
3390     case GLOBAL_FRAMEVAR:
3391         if(!This->base.outer_window)
3392             return E_UNEXPECTED;
3393
3394         switch(flags) {
3395         case DISPATCH_PROPERTYGET: {
3396             HTMLOuterWindow *frame;
3397
3398             hres = get_frame_by_name(This->base.outer_window, prop->name, FALSE, &frame);
3399             if(FAILED(hres))
3400                 return hres;
3401
3402             if(!frame)
3403                 return DISP_E_MEMBERNOTFOUND;
3404
3405             V_VT(res) = VT_DISPATCH;
3406             V_DISPATCH(res) = (IDispatch*)&frame->base.inner_window->base.IHTMLWindow2_iface;
3407             IDispatch_AddRef(V_DISPATCH(res));
3408             return S_OK;
3409         }
3410         default:
3411             FIXME("Not supported flags: %x\n", flags);
3412             return E_NOTIMPL;
3413         }
3414     case GLOBAL_DISPEXVAR:
3415         return IDispatchEx_InvokeEx(&This->event_target.dispex.IDispatchEx_iface, prop->id, 0, flags, params, res, ei, caller);
3416     default:
3417         ERR("invalid type %d\n", prop->type);
3418         hres = DISP_E_MEMBERNOTFOUND;
3419     }
3420
3421     return hres;
3422 }
3423
3424 static compat_mode_t HTMLWindow_get_compat_mode(DispatchEx *dispex)
3425 {
3426     HTMLInnerWindow *This = impl_from_DispatchEx(dispex);
3427     return lock_document_mode(This->doc);
3428 }
3429
3430 static nsISupports *HTMLWindow_get_gecko_target(DispatchEx *dispex)
3431 {
3432     HTMLInnerWindow *This = impl_from_DispatchEx(dispex);
3433     return (nsISupports*)This->base.outer_window->nswindow;
3434 }
3435
3436 static void HTMLWindow_bind_event(DispatchEx *dispex, eventid_t eid)
3437 {
3438     HTMLInnerWindow *This = impl_from_DispatchEx(dispex);
3439     ensure_doc_nsevent_handler(This->doc, NULL, eid);
3440 }
3441
3442 static void HTMLWindow_init_dispex_info(dispex_data_t *info, compat_mode_t compat_mode)
3443 {
3444     /* FIXME: Expose getComputedStyle once it's implemented.
3445      * Stubs break existing web sites. */
3446     static const dispex_hook_t window7_hooks[] = {
3447         {DISPID_IHTMLWINDOW7_GETCOMPUTEDSTYLE, NULL},
3448         {DISPID_UNKNOWN}
3449     };
3450     if(compat_mode >= COMPAT_MODE_IE9)
3451         dispex_info_add_interface(info, IHTMLWindow7_tid, window7_hooks);
3452     dispex_info_add_interface(info, IHTMLWindow5_tid, NULL);
3453     EventTarget_init_dispex_info(info, compat_mode);
3454 }
3455
3456 static IHTMLEventObj *HTMLWindow_set_current_event(DispatchEx *dispex, IHTMLEventObj *event)
3457 {
3458     HTMLInnerWindow *This = impl_from_DispatchEx(dispex);
3459     return default_set_current_event(This, event);
3460 }
3461
3462 static const event_target_vtbl_t HTMLWindow_event_target_vtbl = {
3463     {
3464         NULL,
3465         NULL,
3466         HTMLWindow_invoke,
3467         HTMLWindow_get_compat_mode,
3468         NULL
3469     },
3470     HTMLWindow_get_gecko_target,
3471     HTMLWindow_bind_event,
3472     NULL,
3473     NULL,
3474     NULL,
3475     HTMLWindow_set_current_event
3476 };
3477
3478 static const tid_t HTMLWindow_iface_tids[] = {
3479     IHTMLWindow2_tid,
3480     IHTMLWindow3_tid,
3481     IHTMLWindow4_tid,
3482     IHTMLWindow6_tid,
3483     0
3484 };
3485
3486 static dispex_static_data_t HTMLWindow_dispex = {
3487     &HTMLWindow_event_target_vtbl.dispex_vtbl,
3488     DispHTMLWindow2_tid,
3489     HTMLWindow_iface_tids,
3490     HTMLWindow_init_dispex_info
3491 };
3492
3493 static void *alloc_window(size_t size)
3494 {
3495     HTMLWindow *window;
3496
3497     window = heap_alloc_zero(size);
3498     if(!window)
3499         return NULL;
3500
3501     window->IHTMLWindow2_iface.lpVtbl = &HTMLWindow2Vtbl;
3502     window->IHTMLWindow3_iface.lpVtbl = &HTMLWindow3Vtbl;
3503     window->IHTMLWindow4_iface.lpVtbl = &HTMLWindow4Vtbl;
3504     window->IHTMLWindow5_iface.lpVtbl = &HTMLWindow5Vtbl;
3505     window->IHTMLWindow6_iface.lpVtbl = &HTMLWindow6Vtbl;
3506     window->IHTMLWindow7_iface.lpVtbl = &HTMLWindow7Vtbl;
3507     window->IHTMLPrivateWindow_iface.lpVtbl = &HTMLPrivateWindowVtbl;
3508     window->IDispatchEx_iface.lpVtbl = &WindowDispExVtbl;
3509     window->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
3510     window->ITravelLogClient_iface.lpVtbl = &TravelLogClientVtbl;
3511     window->IObjectIdentity_iface.lpVtbl = &ObjectIdentityVtbl;
3512     window->IProvideMultipleClassInfo_iface.lpVtbl = &ProvideMultipleClassInfoVtbl;
3513     window->ref = 1;
3514
3515     return window;
3516 }
3517
3518 static HRESULT create_inner_window(HTMLOuterWindow *outer_window, IMoniker *mon, HTMLInnerWindow **ret)
3519 {
3520     HTMLInnerWindow *window;
3521
3522     window = alloc_window(sizeof(HTMLInnerWindow));
3523     if(!window)
3524         return E_OUTOFMEMORY;
3525
3526     list_init(&window->script_hosts);
3527     list_init(&window->bindings);
3528     list_init(&window->script_queue);
3529
3530     window->base.outer_window = outer_window;
3531     window->base.inner_window = window;
3532
3533     EventTarget_Init(&window->event_target, (IUnknown*)&window->base.IHTMLWindow2_iface,
3534                      &HTMLWindow_dispex, COMPAT_MODE_NONE);
3535
3536     window->task_magic = get_task_target_magic();
3537
3538     if(mon) {
3539         IMoniker_AddRef(mon);
3540         window->mon = mon;
3541     }
3542
3543     *ret = window;
3544     return S_OK;
3545 }
3546
3547 HRESULT HTMLOuterWindow_Create(HTMLDocumentObj *doc_obj, nsIDOMWindow *nswindow,
3548         HTMLOuterWindow *parent, HTMLOuterWindow **ret)
3549 {
3550     HTMLOuterWindow *window;
3551     HRESULT hres;
3552
3553     window = alloc_window(sizeof(HTMLOuterWindow));
3554     if(!window)
3555         return E_OUTOFMEMORY;
3556
3557     window->base.outer_window = window;
3558     window->base.inner_window = NULL;
3559
3560     window->window_ref = heap_alloc(sizeof(windowref_t));
3561     if(!window->window_ref) {
3562         heap_free(window);
3563         return E_OUTOFMEMORY;
3564     }
3565
3566     window->doc_obj = doc_obj;
3567
3568     window->window_ref->window = window;
3569     window->window_ref->ref = 1;
3570
3571     if(nswindow) {
3572         nsresult nsres;
3573
3574         nsIDOMWindow_AddRef(nswindow);
3575         window->nswindow = nswindow;
3576
3577         nsres = nsIDOMWindow_QueryInterface(nswindow, &IID_mozIDOMWindowProxy, (void**)&window->window_proxy);
3578         assert(nsres == NS_OK);
3579     }
3580
3581     window->scriptmode = parent ? parent->scriptmode : SCRIPTMODE_GECKO;
3582     window->readystate = READYSTATE_UNINITIALIZED;
3583     window->task_magic = get_task_target_magic();
3584
3585     list_init(&window->children);
3586     wine_rb_put(&window_map, window->window_proxy, &window->entry);
3587
3588     hres = create_pending_window(window, NULL);
3589     if(SUCCEEDED(hres))
3590         hres = update_window_doc(window->pending_window);
3591     if(FAILED(hres)) {
3592         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
3593         return hres;
3594     }
3595
3596     hres = CoInternetCreateSecurityManager(NULL, &window->secmgr, 0);
3597     if(FAILED(hres)) {
3598         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
3599         return hres;
3600     }
3601
3602     if(parent) {
3603         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
3604
3605         window->parent = parent;
3606         list_add_tail(&parent->children, &window->sibling_entry);
3607     }
3608
3609     TRACE("%p inner_window %p\n", window, window->base.inner_window);
3610
3611     *ret = window;
3612     return S_OK;
3613 }
3614
3615 HRESULT create_pending_window(HTMLOuterWindow *outer_window, nsChannelBSC *channelbsc)
3616 {
3617     HTMLInnerWindow *pending_window;
3618     HRESULT hres;
3619
3620     hres = create_inner_window(outer_window, outer_window->mon /* FIXME */, &pending_window);
3621     if(FAILED(hres))
3622         return hres;
3623
3624     if(channelbsc) {
3625         IBindStatusCallback_AddRef(&channelbsc->bsc.IBindStatusCallback_iface);
3626         pending_window->bscallback = channelbsc;
3627     }
3628
3629     if(outer_window->pending_window) {
3630         abort_window_bindings(outer_window->pending_window);
3631         outer_window->pending_window->base.outer_window = NULL;
3632         IHTMLWindow2_Release(&outer_window->pending_window->base.IHTMLWindow2_iface);
3633     }
3634
3635     outer_window->pending_window = pending_window;
3636     return S_OK;
3637 }
3638
3639 HRESULT update_window_doc(HTMLInnerWindow *window)
3640 {
3641     HTMLOuterWindow *outer_window = window->base.outer_window;
3642     nsIDOMHTMLDocument *nshtmldoc;
3643     nsIDOMDocument *nsdoc;
3644     nsresult nsres;
3645     HRESULT hres;
3646
3647     assert(!window->doc);
3648
3649     if(!outer_window) {
3650         ERR("NULL outer window\n");
3651         return E_UNEXPECTED;
3652     }
3653
3654     nsres = nsIDOMWindow_GetDocument(outer_window->nswindow, &nsdoc);
3655     if(NS_FAILED(nsres) || !nsdoc) {
3656         ERR("GetDocument failed: %08x\n", nsres);
3657         return E_FAIL;
3658     }
3659
3660     nsres = nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
3661     nsIDOMDocument_Release(nsdoc);
3662     if(NS_FAILED(nsres)) {
3663         ERR("Could not get nsIDOMHTMLDocument iface: %08x\n", nsres);
3664         return E_FAIL;
3665     }
3666
3667     hres = create_doc_from_nsdoc(nshtmldoc, outer_window->doc_obj, window, &window->doc);
3668     nsIDOMHTMLDocument_Release(nshtmldoc);
3669     if(FAILED(hres))
3670         return hres;
3671
3672     if(outer_window->doc_obj->usermode == EDITMODE) {
3673         nsAString mode_str;
3674         nsresult nsres;
3675
3676         static const PRUnichar onW[] = {'o','n',0};
3677
3678         nsAString_InitDepend(&mode_str, onW);
3679         nsres = nsIDOMHTMLDocument_SetDesignMode(window->doc->nsdoc, &mode_str);
3680         nsAString_Finish(&mode_str);
3681         if(NS_FAILED(nsres))
3682             ERR("SetDesignMode failed: %08x\n", nsres);
3683     }
3684
3685     if(window != outer_window->pending_window) {
3686         ERR("not current pending window\n");
3687         return S_OK;
3688     }
3689
3690     if(outer_window->base.inner_window)
3691         detach_inner_window(outer_window->base.inner_window);
3692     outer_window->base.inner_window = window;
3693     outer_window->pending_window = NULL;
3694
3695     if(outer_window->doc_obj->basedoc.window == outer_window || !outer_window->doc_obj->basedoc.window) {
3696         if(outer_window->doc_obj->basedoc.doc_node)
3697             htmldoc_release(&outer_window->doc_obj->basedoc.doc_node->basedoc);
3698         outer_window->doc_obj->basedoc.doc_node = window->doc;
3699         htmldoc_addref(&window->doc->basedoc);
3700     }
3701
3702     return hres;
3703 }