dlls/mshtml/htmlwindow.c

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