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