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