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