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 struct list window_list = LIST_INIT(window_list);
  48
  49 static inline BOOL is_outer_window(HTMLWindow *window)
  50 {
  51     return &window->outer_window->base == window;
  52 }
  53
  54 static void release_children(HTMLOuterWindow *This)
  55 {
  56     HTMLOuterWindow *child;
  57
  58     while(!list_empty(&This->children)) {
  59         child = LIST_ENTRY(list_tail(&This->children), HTMLOuterWindow, sibling_entry);
  60
  61         list_remove(&child->sibling_entry);
  62         child->parent = NULL;
  63         IHTMLWindow2_Release(&child->base.IHTMLWindow2_iface);
  64     }
  65 }
  66
  67 static HRESULT get_location(HTMLInnerWindow *This, HTMLLocation **ret)
  68 {
  69     if(This->location) {
  70         IHTMLLocation_AddRef(&This->location->IHTMLLocation_iface);
  71     }else {
  72         HRESULT hres;
  73
  74         hres = HTMLLocation_Create(This, &This->location);
  75         if(FAILED(hres))
  76             return hres;
  77     }
  78
  79     *ret = This->location;
  80     return S_OK;
  81 }
  82
  83 void get_top_window(HTMLOuterWindow *window, HTMLOuterWindow **ret)
  84 {
  85     HTMLOuterWindow *iter;
  86
  87     for(iter = window; iter->parent; iter = iter->parent);
  88     *ret = iter;
  89 }
  90
  91 static inline HRESULT set_window_event(HTMLWindow *window, eventid_t eid, VARIANT *var)
  92 {
  93     if(!window->inner_window->doc) {
  94         FIXME("No document\n");
  95         return E_FAIL;
  96     }
  97
  98     return set_event_handler(&window->inner_window->doc->body_event_target, NULL, window->inner_window->doc, eid, var);
  99 }
 100
 101 static inline HRESULT get_window_event(HTMLWindow *window, eventid_t eid, VARIANT *var)
 102 {
 103     if(!window->inner_window->doc) {
 104         FIXME("No document\n");
 105         return E_FAIL;
 106     }
 107
 108     return get_event_handler(&window->inner_window->doc->body_event_target, eid, var);
 109 }
 110
 111 static void detach_inner_window(HTMLInnerWindow *window)
 112 {
 113     HTMLOuterWindow *outer_window = window->base.outer_window;
 114
 115     if(outer_window && outer_window->doc_obj && outer_window == outer_window->doc_obj->basedoc.window)
 116         window->doc->basedoc.cp_container.forward_container = NULL;
 117
 118     if(window->doc) {
 119         detach_events(window->doc);
 120         while(!list_empty(&window->doc->plugin_hosts))
 121             detach_plugin_host(LIST_ENTRY(list_head(&window->doc->plugin_hosts), PluginHost, entry));
 122     }
 123
 124     abort_window_bindings(window);
 125     remove_target_tasks(window->task_magic);
 126     release_script_hosts(window);
 127     window->base.outer_window = NULL;
 128
 129     if(outer_window && outer_window->base.inner_window == window) {
 130         outer_window->base.inner_window = NULL;
 131         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
 132     }
 133 }
 134
 135 static inline HTMLWindow *impl_from_IHTMLWindow2(IHTMLWindow2 *iface)
 136 {
 137     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow2_iface);
 138 }
 139
 140 static HRESULT WINAPI HTMLWindow2_QueryInterface(IHTMLWindow2 *iface, REFIID riid, void **ppv)
 141 {
 142     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 143
 144     *ppv = NULL;
 145
 146     if(IsEqualGUID(&IID_IUnknown, riid)) {
 147         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 148         *ppv = &This->IHTMLWindow2_iface;
 149     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 150         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 151         *ppv = &This->IHTMLWindow2_iface;
 152     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 153         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 154         *ppv = &This->IDispatchEx_iface;
 155     }else if(IsEqualGUID(&IID_IHTMLFramesCollection2, riid)) {
 156         TRACE("(%p)->(IID_IHTMLFramesCollection2 %p)\n", This, ppv);
 157         *ppv = &This->IHTMLWindow2_iface;
 158     }else if(IsEqualGUID(&IID_IHTMLWindow2, riid)) {
 159         TRACE("(%p)->(IID_IHTMLWindow2 %p)\n", This, ppv);
 160         *ppv = &This->IHTMLWindow2_iface;
 161     }else if(IsEqualGUID(&IID_IHTMLWindow3, riid)) {
 162         TRACE("(%p)->(IID_IHTMLWindow3 %p)\n", This, ppv);
 163         *ppv = &This->IHTMLWindow3_iface;
 164     }else if(IsEqualGUID(&IID_IHTMLWindow4, riid)) {
 165         TRACE("(%p)->(IID_IHTMLWindow4 %p)\n", This, ppv);
 166         *ppv = &This->IHTMLWindow4_iface;
 167     }else if(IsEqualGUID(&IID_IHTMLWindow5, riid)) {
 168         TRACE("(%p)->(IID_IHTMLWindow5 %p)\n", This, ppv);
 169         *ppv = &This->IHTMLWindow5_iface;
 170     }else if(IsEqualGUID(&IID_IHTMLWindow6, riid)) {
 171         TRACE("(%p)->(IID_IHTMLWindow6 %p)\n", This, ppv);
 172         *ppv = &This->IHTMLWindow6_iface;
 173     }else if(IsEqualGUID(&IID_IHTMLPrivateWindow, riid)) {
 174         TRACE("(%p)->(IID_IHTMLPrivateWindow %p)\n", This, ppv);
 175         *ppv = &This->IHTMLPrivateWindow_iface;
 176     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 177         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 178         *ppv = &This->IServiceProvider_iface;
 179     }else if(IsEqualGUID(&IID_ITravelLogClient, riid)) {
 180         TRACE("(%p)->(IID_ITravelLogClient %p)\n", This, ppv);
 181         *ppv = &This->ITravelLogClient_iface;
 182     }else if(IsEqualGUID(&IID_IObjectIdentity, riid)) {
 183         TRACE("(%p)->(IID_IObjectIdentity %p)\n", This, ppv);
 184         *ppv = &This->IObjectIdentity_iface;
 185     }else if(dispex_query_interface(&This->inner_window->dispex, riid, ppv)) {
 186         assert(!*ppv);
 187         return E_NOINTERFACE;
 188     }
 189
 190     if(*ppv) {
 191         IUnknown_AddRef((IUnknown*)*ppv);
 192         return S_OK;
 193     }
 194
 195     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 196     return E_NOINTERFACE;
 197 }
 198
 199 static ULONG WINAPI HTMLWindow2_AddRef(IHTMLWindow2 *iface)
 200 {
 201     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 202     LONG ref = InterlockedIncrement(&This->ref);
 203
 204     TRACE("(%p) ref=%d\n", This, ref);
 205
 206     return ref;
 207 }
 208
 209 static void release_outer_window(HTMLOuterWindow *This)
 210 {
 211     if(This->pending_window) {
 212         abort_window_bindings(This->pending_window);
 213         This->pending_window->base.outer_window = NULL;
 214         IHTMLWindow2_Release(&This->pending_window->base.IHTMLWindow2_iface);
 215     }
 216
 217     remove_target_tasks(This->task_magic);
 218     set_current_mon(This, NULL, 0);
 219     if(This->base.inner_window)
 220         detach_inner_window(This->base.inner_window);
 221     release_children(This);
 222
 223     if(This->secmgr)
 224         IInternetSecurityManager_Release(This->secmgr);
 225
 226     if(This->frame_element)
 227         This->frame_element->content_window = NULL;
 228
 229     This->window_ref->window = NULL;
 230     windowref_release(This->window_ref);
 231
 232     if(This->nswindow)
 233         nsIDOMWindow_Release(This->nswindow);
 234
 235     list_remove(&This->entry);
 236     heap_free(This);
 237 }
 238
 239 static void release_inner_window(HTMLInnerWindow *This)
 240 {
 241     unsigned i;
 242
 243     TRACE("%p\n", This);
 244
 245     detach_inner_window(This);
 246
 247     if(This->doc) {
 248         This->doc->window = NULL;
 249         htmldoc_release(&This->doc->basedoc);
 250     }
 251
 252     release_dispex(&This->dispex);
 253
 254     for(i=0; i < This->global_prop_cnt; i++)
 255         heap_free(This->global_props[i].name);
 256     heap_free(This->global_props);
 257
 258     if(This->location) {
 259         This->location->window = NULL;
 260         IHTMLLocation_Release(&This->location->IHTMLLocation_iface);
 261     }
 262
 263     if(This->image_factory) {
 264         This->image_factory->window = NULL;
 265         IHTMLImageElementFactory_Release(&This->image_factory->IHTMLImageElementFactory_iface);
 266     }
 267
 268     if(This->option_factory) {
 269         This->option_factory->window = NULL;
 270         IHTMLOptionElementFactory_Release(&This->option_factory->IHTMLOptionElementFactory_iface);
 271     }
 272
 273     if(This->screen)
 274         IHTMLScreen_Release(This->screen);
 275
 276     if(This->history) {
 277         This->history->window = NULL;
 278         IOmHistory_Release(&This->history->IOmHistory_iface);
 279     }
 280
 281     if(This->mon)
 282         IMoniker_Release(This->mon);
 283
 284     heap_free(This);
 285 }
 286
 287 static ULONG WINAPI HTMLWindow2_Release(IHTMLWindow2 *iface)
 288 {
 289     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 290     LONG ref = InterlockedDecrement(&This->ref);
 291
 292     TRACE("(%p) ref=%d\n", This, ref);
 293
 294     if(!ref) {
 295         if(is_outer_window(This))
 296             release_outer_window(This->outer_window);
 297         else
 298             release_inner_window(This->inner_window);
 299     }
 300
 301     return ref;
 302 }
 303
 304 static HRESULT WINAPI HTMLWindow2_GetTypeInfoCount(IHTMLWindow2 *iface, UINT *pctinfo)
 305 {
 306     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 307
 308     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
 309 }
 310
 311 static HRESULT WINAPI HTMLWindow2_GetTypeInfo(IHTMLWindow2 *iface, UINT iTInfo,
 312                                               LCID lcid, ITypeInfo **ppTInfo)
 313 {
 314     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 315
 316     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 317 }
 318
 319 static HRESULT WINAPI HTMLWindow2_GetIDsOfNames(IHTMLWindow2 *iface, REFIID riid,
 320                                                 LPOLESTR *rgszNames, UINT cNames,
 321                                                 LCID lcid, DISPID *rgDispId)
 322 {
 323     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 324
 325     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
 326             rgDispId);
 327 }
 328
 329 static HRESULT WINAPI HTMLWindow2_Invoke(IHTMLWindow2 *iface, DISPID dispIdMember,
 330                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 331                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 332 {
 333     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 334
 335     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 336             pDispParams, pVarResult, pExcepInfo, puArgErr);
 337 }
 338
 339 static HRESULT get_frame_by_index(HTMLOuterWindow *This, UINT32 index, HTMLOuterWindow **ret)
 340 {
 341     nsIDOMWindowCollection *nsframes;
 342     nsIDOMWindow *nswindow;
 343     UINT32 length;
 344     nsresult nsres;
 345
 346     nsres = nsIDOMWindow_GetFrames(This->nswindow, &nsframes);
 347     if(NS_FAILED(nsres)) {
 348         FIXME("nsIDOMWindow_GetFrames failed: 0x%08x\n", nsres);
 349         return E_FAIL;
 350     }
 351
 352     nsres = nsIDOMWindowCollection_GetLength(nsframes, &length);
 353     assert(nsres == NS_OK);
 354
 355     if(index >= length) {
 356         nsIDOMWindowCollection_Release(nsframes);
 357         return DISP_E_MEMBERNOTFOUND;
 358     }
 359
 360     nsres = nsIDOMWindowCollection_Item(nsframes, index, &nswindow);
 361     nsIDOMWindowCollection_Release(nsframes);
 362     if(NS_FAILED(nsres)) {
 363         FIXME("nsIDOMWindowCollection_Item failed: 0x%08x\n", nsres);
 364         return E_FAIL;
 365     }
 366
 367     *ret = nswindow_to_window(nswindow);
 368
 369     nsIDOMWindow_Release(nswindow);
 370     return S_OK;
 371 }
 372
 373 HRESULT get_frame_by_name(HTMLOuterWindow *This, const WCHAR *name, BOOL deep, HTMLOuterWindow **ret)
 374 {
 375     nsIDOMWindowCollection *nsframes;
 376     HTMLOuterWindow *window = NULL;
 377     nsIDOMWindow *nswindow;
 378     nsAString name_str;
 379     UINT32 length, i;
 380     nsresult nsres;
 381     HRESULT hres = S_OK;
 382
 383     nsres = nsIDOMWindow_GetFrames(This->nswindow, &nsframes);
 384     if(NS_FAILED(nsres)) {
 385         FIXME("nsIDOMWindow_GetFrames failed: 0x%08x\n", nsres);
 386         return E_FAIL;
 387     }
 388
 389     nsAString_InitDepend(&name_str, name);
 390     nsres = nsIDOMWindowCollection_NamedItem(nsframes, &name_str, &nswindow);
 391     nsAString_Finish(&name_str);
 392     if(NS_FAILED(nsres)) {
 393         nsIDOMWindowCollection_Release(nsframes);
 394         return E_FAIL;
 395     }
 396
 397     if(nswindow) {
 398         *ret = nswindow_to_window(nswindow);
 399         return S_OK;
 400     }
 401
 402     nsres = nsIDOMWindowCollection_GetLength(nsframes, &length);
 403     assert(nsres == NS_OK);
 404
 405     for(i = 0; i < length && !window; ++i) {
 406         HTMLOuterWindow *window_iter;
 407         BSTR id;
 408
 409         nsres = nsIDOMWindowCollection_Item(nsframes, i, &nswindow);
 410         if(NS_FAILED(nsres)) {
 411             FIXME("nsIDOMWindowCollection_Item failed: 0x%08x\n", nsres);
 412             hres = E_FAIL;
 413             break;
 414         }
 415
 416         window_iter = nswindow_to_window(nswindow);
 417
 418         nsIDOMWindow_Release(nswindow);
 419
 420         hres = IHTMLElement_get_id(&window_iter->frame_element->element.IHTMLElement_iface, &id);
 421         if(FAILED(hres)) {
 422             FIXME("IHTMLElement_get_id failed: 0x%08x\n", hres);
 423             break;
 424         }
 425
 426         if(id && !strcmpiW(id, name))
 427             window = window_iter;
 428
 429         SysFreeString(id);
 430
 431         if(!window && deep)
 432             get_frame_by_name(window_iter, name, TRUE, &window);
 433     }
 434
 435     nsIDOMWindowCollection_Release(nsframes);
 436     if(FAILED(hres))
 437         return hres;
 438
 439     *ret = window;
 440     return NS_OK;
 441 }
 442
 443 static HRESULT WINAPI HTMLWindow2_item(IHTMLWindow2 *iface, VARIANT *pvarIndex, VARIANT *pvarResult)
 444 {
 445     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 446     HTMLOuterWindow *window = NULL;
 447     HRESULT hres;
 448
 449     TRACE("(%p)->(%p %p)\n", This, pvarIndex, pvarResult);
 450
 451     switch(V_VT(pvarIndex)) {
 452     case VT_I4: {
 453         int index = V_I4(pvarIndex);
 454         TRACE("Getting index %d\n", index);
 455         if(index < 0)
 456             return DISP_E_MEMBERNOTFOUND;
 457         hres = get_frame_by_index(This->outer_window, index, &window);
 458         break;
 459     }
 460     case VT_UINT: {
 461         unsigned int index = V_UINT(pvarIndex);
 462         TRACE("Getting index %u\n", index);
 463         hres = get_frame_by_index(This->outer_window, index, &window);
 464         break;
 465     }
 466     case VT_BSTR: {
 467         BSTR str = V_BSTR(pvarIndex);
 468         TRACE("Getting name %s\n", wine_dbgstr_w(str));
 469         hres = get_frame_by_name(This->outer_window, str, FALSE, &window);
 470         break;
 471     }
 472     default:
 473         WARN("Invalid index %s\n", debugstr_variant(pvarIndex));
 474         return E_INVALIDARG;
 475     }
 476
 477     if(FAILED(hres))
 478         return hres;
 479     if(!window)
 480         return DISP_E_MEMBERNOTFOUND;
 481
 482     IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
 483     V_VT(pvarResult) = VT_DISPATCH;
 484     V_DISPATCH(pvarResult) = (IDispatch*)window;
 485     return S_OK;
 486 }
 487
 488 static HRESULT WINAPI HTMLWindow2_get_length(IHTMLWindow2 *iface, LONG *p)
 489 {
 490     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 491     nsIDOMWindowCollection *nscollection;
 492     UINT32 length;
 493     nsresult nsres;
 494
 495     TRACE("(%p)->(%p)\n", This, p);
 496
 497     nsres = nsIDOMWindow_GetFrames(This->outer_window->nswindow, &nscollection);
 498     if(NS_FAILED(nsres)) {
 499         ERR("GetFrames failed: %08x\n", nsres);
 500         return E_FAIL;
 501     }
 502
 503     nsres = nsIDOMWindowCollection_GetLength(nscollection, &length);
 504     nsIDOMWindowCollection_Release(nscollection);
 505     if(NS_FAILED(nsres)) {
 506         ERR("GetLength failed: %08x\n", nsres);
 507         return E_FAIL;
 508     }
 509
 510     *p = length;
 511     return S_OK;
 512 }
 513
 514 static HRESULT WINAPI HTMLWindow2_get_frames(IHTMLWindow2 *iface, IHTMLFramesCollection2 **p)
 515 {
 516     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 517     FIXME("(%p)->(%p): semi-stub\n", This, p);
 518
 519     /* FIXME: Should return a separate Window object */
 520     *p = (IHTMLFramesCollection2*)&This->IHTMLWindow2_iface;
 521     HTMLWindow2_AddRef(iface);
 522     return S_OK;
 523 }
 524
 525 static HRESULT WINAPI HTMLWindow2_put_defaultStatus(IHTMLWindow2 *iface, BSTR v)
 526 {
 527     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 528     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 529     return E_NOTIMPL;
 530 }
 531
 532 static HRESULT WINAPI HTMLWindow2_get_defaultStatus(IHTMLWindow2 *iface, BSTR *p)
 533 {
 534     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 535     FIXME("(%p)->(%p)\n", This, p);
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT WINAPI HTMLWindow2_put_status(IHTMLWindow2 *iface, BSTR v)
 540 {
 541     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 542
 543     WARN("(%p)->(%s)\n", This, debugstr_w(v));
 544
 545     /*
 546      * FIXME: Since IE7, setting status is blocked, but still possible in certain circumstances.
 547      * Ignoring the call should be enough for us.
 548      */
 549     return S_OK;
 550 }
 551
 552 static HRESULT WINAPI HTMLWindow2_get_status(IHTMLWindow2 *iface, BSTR *p)
 553 {
 554     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 555
 556     TRACE("(%p)->(%p)\n", This, p);
 557
 558     /* See put_status */
 559     *p = NULL;
 560     return S_OK;
 561 }
 562
 563 static HRESULT WINAPI HTMLWindow2_setTimeout(IHTMLWindow2 *iface, BSTR expression,
 564         LONG msec, VARIANT *language, LONG *timerID)
 565 {
 566     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 567     VARIANT expr_var;
 568
 569     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_w(expression), msec, language, timerID);
 570
 571     V_VT(&expr_var) = VT_BSTR;
 572     V_BSTR(&expr_var) = expression;
 573
 574     return IHTMLWindow3_setTimeout(&This->IHTMLWindow3_iface, &expr_var, msec, language, timerID);
 575 }
 576
 577 static HRESULT WINAPI HTMLWindow2_clearTimeout(IHTMLWindow2 *iface, LONG timerID)
 578 {
 579     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 580
 581     TRACE("(%p)->(%d)\n", This, timerID);
 582
 583     return clear_task_timer(This->inner_window, FALSE, timerID);
 584 }
 585
 586 #define MAX_MESSAGE_LEN 2000
 587
 588 static HRESULT WINAPI HTMLWindow2_alert(IHTMLWindow2 *iface, BSTR message)
 589 {
 590     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 591     WCHAR title[100], *msg = message;
 592     DWORD len;
 593
 594     TRACE("(%p)->(%s)\n", This, debugstr_w(message));
 595
 596     if(!LoadStringW(get_shdoclc(), IDS_MESSAGE_BOX_TITLE, title,
 597                     sizeof(title)/sizeof(WCHAR))) {
 598         WARN("Could not load message box title: %d\n", GetLastError());
 599         return S_OK;
 600     }
 601
 602     len = SysStringLen(message);
 603     if(len > MAX_MESSAGE_LEN) {
 604         msg = heap_alloc((MAX_MESSAGE_LEN+1)*sizeof(WCHAR));
 605         if(!msg)
 606             return E_OUTOFMEMORY;
 607         memcpy(msg, message, MAX_MESSAGE_LEN*sizeof(WCHAR));
 608         msg[MAX_MESSAGE_LEN] = 0;
 609     }
 610
 611     MessageBoxW(This->outer_window->doc_obj->hwnd, msg, title, MB_ICONWARNING);
 612     if(msg != message)
 613         heap_free(msg);
 614     return S_OK;
 615 }
 616
 617 static HRESULT WINAPI HTMLWindow2_confirm(IHTMLWindow2 *iface, BSTR message,
 618         VARIANT_BOOL *confirmed)
 619 {
 620     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 621     WCHAR wszTitle[100];
 622
 623     TRACE("(%p)->(%s %p)\n", This, debugstr_w(message), confirmed);
 624
 625     if(!confirmed) return E_INVALIDARG;
 626
 627     if(!LoadStringW(get_shdoclc(), IDS_MESSAGE_BOX_TITLE, wszTitle,
 628                 sizeof(wszTitle)/sizeof(WCHAR))) {
 629         WARN("Could not load message box title: %d\n", GetLastError());
 630         *confirmed = VARIANT_TRUE;
 631         return S_OK;
 632     }
 633
 634     if(MessageBoxW(This->outer_window->doc_obj->hwnd, message, wszTitle,
 635                 MB_OKCANCEL|MB_ICONQUESTION)==IDOK)
 636         *confirmed = VARIANT_TRUE;
 637     else *confirmed = VARIANT_FALSE;
 638
 639     return S_OK;
 640 }
 641
 642 typedef struct
 643 {
 644     BSTR message;
 645     BSTR dststr;
 646     VARIANT *textdata;
 647 }prompt_arg;
 648
 649 static INT_PTR CALLBACK prompt_dlgproc(HWND hwnd, UINT msg,
 650         WPARAM wparam, LPARAM lparam)
 651 {
 652     switch(msg)
 653     {
 654         case WM_INITDIALOG:
 655         {
 656             prompt_arg *arg = (prompt_arg*)lparam;
 657             WCHAR wszTitle[100];
 658
 659             if(!LoadStringW(get_shdoclc(), IDS_MESSAGE_BOX_TITLE, wszTitle,
 660                         sizeof(wszTitle)/sizeof(WCHAR))) {
 661                 WARN("Could not load message box title: %d\n", GetLastError());
 662                 EndDialog(hwnd, wparam);
 663                 return FALSE;
 664             }
 665
 666             SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
 667             SetWindowTextW(hwnd, wszTitle);
 668             SetWindowTextW(GetDlgItem(hwnd, ID_PROMPT_PROMPT), arg->message);
 669             SetWindowTextW(GetDlgItem(hwnd, ID_PROMPT_EDIT), arg->dststr);
 670             return FALSE;
 671         }
 672         case WM_COMMAND:
 673             switch(wparam)
 674             {
 675                 case MAKEWPARAM(IDCANCEL, BN_CLICKED):
 676                     EndDialog(hwnd, wparam);
 677                     return TRUE;
 678                 case MAKEWPARAM(IDOK, BN_CLICKED):
 679                 {
 680                     prompt_arg *arg =
 681                         (prompt_arg*)GetWindowLongPtrW(hwnd, DWLP_USER);
 682                     HWND hwndPrompt = GetDlgItem(hwnd, ID_PROMPT_EDIT);
 683                     INT len = GetWindowTextLengthW(hwndPrompt);
 684
 685                     if(!arg->textdata)
 686                     {
 687                         EndDialog(hwnd, wparam);
 688                         return TRUE;
 689                     }
 690
 691                     V_VT(arg->textdata) = VT_BSTR;
 692                     if(!len && !arg->dststr)
 693                         V_BSTR(arg->textdata) = NULL;
 694                     else
 695                     {
 696                         V_BSTR(arg->textdata) = SysAllocStringLen(NULL, len);
 697                         GetWindowTextW(hwndPrompt, V_BSTR(arg->textdata), len+1);
 698                     }
 699                     EndDialog(hwnd, wparam);
 700                     return TRUE;
 701                 }
 702             }
 703             return FALSE;
 704         case WM_CLOSE:
 705             EndDialog(hwnd, IDCANCEL);
 706             return TRUE;
 707         default:
 708             return FALSE;
 709     }
 710 }
 711
 712 static HRESULT WINAPI HTMLWindow2_prompt(IHTMLWindow2 *iface, BSTR message,
 713         BSTR dststr, VARIANT *textdata)
 714 {
 715     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 716     prompt_arg arg;
 717
 718     TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(message), debugstr_w(dststr), textdata);
 719
 720     if(textdata) V_VT(textdata) = VT_NULL;
 721
 722     arg.message = message;
 723     arg.dststr = dststr;
 724     arg.textdata = textdata;
 725
 726     DialogBoxParamW(hInst, MAKEINTRESOURCEW(ID_PROMPT_DIALOG),
 727             This->outer_window->doc_obj->hwnd, prompt_dlgproc, (LPARAM)&arg);
 728     return S_OK;
 729 }
 730
 731 static HRESULT WINAPI HTMLWindow2_get_Image(IHTMLWindow2 *iface, IHTMLImageElementFactory **p)
 732 {
 733     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 734     HTMLInnerWindow *window = This->inner_window;
 735
 736     TRACE("(%p)->(%p)\n", This, p);
 737
 738     if(!window->image_factory) {
 739         HRESULT hres;
 740
 741         hres = HTMLImageElementFactory_Create(window, &window->image_factory);
 742         if(FAILED(hres))
 743             return hres;
 744     }
 745
 746     *p = &window->image_factory->IHTMLImageElementFactory_iface;
 747     IHTMLImageElementFactory_AddRef(*p);
 748
 749     return S_OK;
 750 }
 751
 752 static HRESULT WINAPI HTMLWindow2_get_location(IHTMLWindow2 *iface, IHTMLLocation **p)
 753 {
 754     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 755     HTMLLocation *location;
 756     HRESULT hres;
 757
 758     TRACE("(%p)->(%p)\n", This, p);
 759
 760     hres = get_location(This->inner_window, &location);
 761     if(FAILED(hres))
 762         return hres;
 763
 764     *p = &location->IHTMLLocation_iface;
 765     return S_OK;
 766 }
 767
 768 static HRESULT WINAPI HTMLWindow2_get_history(IHTMLWindow2 *iface, IOmHistory **p)
 769 {
 770     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 771     HTMLInnerWindow *window = This->inner_window;
 772
 773     TRACE("(%p)->(%p)\n", This, p);
 774
 775     if(!window->history) {
 776         HRESULT hres;
 777
 778         hres = create_history(window, &window->history);
 779         if(FAILED(hres))
 780             return hres;
 781     }
 782
 783     IOmHistory_AddRef(&window->history->IOmHistory_iface);
 784     *p = &window->history->IOmHistory_iface;
 785     return S_OK;
 786 }
 787
 788 static BOOL notify_webbrowser_close(HTMLOuterWindow *window, HTMLDocumentObj *doc)
 789 {
 790     IConnectionPointContainer *cp_container;
 791     VARIANT_BOOL cancel = VARIANT_FALSE;
 792     IEnumConnections *enum_conn;
 793     VARIANT args[2];
 794     DISPPARAMS dp = {args, NULL, 2, 0};
 795     CONNECTDATA conn_data;
 796     IConnectionPoint *cp;
 797     IDispatch *disp;
 798     ULONG fetched;
 799     HRESULT hres;
 800
 801     if(!doc->webbrowser)
 802         return TRUE;
 803
 804     hres = IUnknown_QueryInterface(doc->webbrowser, &IID_IConnectionPointContainer, (void**)&cp_container);
 805     if(FAILED(hres))
 806         return TRUE;
 807
 808     hres = IConnectionPointContainer_FindConnectionPoint(cp_container, &DIID_DWebBrowserEvents2, &cp);
 809     IConnectionPointContainer_Release(cp_container);
 810     if(FAILED(hres))
 811         return TRUE;
 812
 813     hres = IConnectionPoint_EnumConnections(cp, &enum_conn);
 814     IConnectionPoint_Release(cp);
 815     if(FAILED(hres))
 816         return TRUE;
 817
 818     while(!cancel) {
 819         conn_data.pUnk = NULL;
 820         conn_data.dwCookie = 0;
 821         fetched = 0;
 822         hres = IEnumConnections_Next(enum_conn, 1, &conn_data, &fetched);
 823         if(hres != S_OK)
 824             break;
 825
 826         hres = IUnknown_QueryInterface(conn_data.pUnk, &IID_IDispatch, (void**)&disp);
 827         IUnknown_Release(conn_data.pUnk);
 828         if(FAILED(hres))
 829             continue;
 830
 831         V_VT(args) = VT_BYREF|VT_BOOL;
 832         V_BOOLREF(args) = &cancel;
 833         V_VT(args+1) = VT_BOOL;
 834         V_BOOL(args+1) = window->parent ? VARIANT_TRUE : VARIANT_FALSE;
 835         hres = IDispatch_Invoke(disp, DISPID_WINDOWCLOSING, &IID_NULL, 0, DISPATCH_METHOD, &dp, NULL, NULL, NULL);
 836         IDispatch_Release(disp);
 837         if(FAILED(hres))
 838             cancel = VARIANT_FALSE;
 839     }
 840
 841     IEnumConnections_Release(enum_conn);
 842     return !cancel;
 843 }
 844
 845 static HRESULT WINAPI HTMLWindow2_close(IHTMLWindow2 *iface)
 846 {
 847     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 848     HTMLOuterWindow *window = This->outer_window;
 849
 850     TRACE("(%p)\n", This);
 851
 852     if(!window->doc_obj) {
 853         FIXME("No document object\n");
 854         return E_FAIL;
 855     }
 856
 857     if(!notify_webbrowser_close(window, window->doc_obj))
 858         return S_OK;
 859
 860     FIXME("default action not implemented\n");
 861     return E_NOTIMPL;
 862 }
 863
 864 static HRESULT WINAPI HTMLWindow2_put_opener(IHTMLWindow2 *iface, VARIANT v)
 865 {
 866     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 867     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 868     return E_NOTIMPL;
 869 }
 870
 871 static HRESULT WINAPI HTMLWindow2_get_opener(IHTMLWindow2 *iface, VARIANT *p)
 872 {
 873     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 874
 875     FIXME("(%p)->(%p) returning empty\n", This, p);
 876
 877     V_VT(p) = VT_EMPTY;
 878     return S_OK;
 879 }
 880
 881 static HRESULT WINAPI HTMLWindow2_get_navigator(IHTMLWindow2 *iface, IOmNavigator **p)
 882 {
 883     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 884
 885     TRACE("(%p)->(%p)\n", This, p);
 886
 887     *p = OmNavigator_Create();
 888     return *p ? S_OK : E_OUTOFMEMORY;
 889 }
 890
 891 static HRESULT WINAPI HTMLWindow2_put_name(IHTMLWindow2 *iface, BSTR v)
 892 {
 893     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 894     nsAString name_str;
 895     nsresult nsres;
 896
 897     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 898
 899     nsAString_InitDepend(&name_str, v);
 900     nsres = nsIDOMWindow_SetName(This->outer_window->nswindow, &name_str);
 901     nsAString_Finish(&name_str);
 902     if(NS_FAILED(nsres))
 903         ERR("SetName failed: %08x\n", nsres);
 904
 905     return S_OK;
 906 }
 907
 908 static HRESULT WINAPI HTMLWindow2_get_name(IHTMLWindow2 *iface, BSTR *p)
 909 {
 910     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 911     nsAString name_str;
 912     nsresult nsres;
 913
 914     TRACE("(%p)->(%p)\n", This, p);
 915
 916     nsAString_Init(&name_str, NULL);
 917     nsres = nsIDOMWindow_GetName(This->outer_window->nswindow, &name_str);
 918     return return_nsstr(nsres, &name_str, p);
 919 }
 920
 921 static HRESULT WINAPI HTMLWindow2_get_parent(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 922 {
 923     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 924     HTMLOuterWindow *window = This->outer_window;
 925
 926     TRACE("(%p)->(%p)\n", This, p);
 927
 928     if(!window->parent)
 929         return IHTMLWindow2_get_self(&This->IHTMLWindow2_iface, p);
 930
 931     *p = &window->parent->base.IHTMLWindow2_iface;
 932     IHTMLWindow2_AddRef(*p);
 933     return S_OK;
 934 }
 935
 936 static HRESULT WINAPI HTMLWindow2_open(IHTMLWindow2 *iface, BSTR url, BSTR name,
 937          BSTR features, VARIANT_BOOL replace, IHTMLWindow2 **pomWindowResult)
 938 {
 939     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 940     HTMLOuterWindow *window = This->outer_window;
 941     INewWindowManager *new_window_mgr;
 942     BSTR uri_str;
 943     IUri *uri;
 944     HRESULT hres;
 945
 946     TRACE("(%p)->(%s %s %s %x %p)\n", This, debugstr_w(url), debugstr_w(name),
 947           debugstr_w(features), replace, pomWindowResult);
 948
 949     if(!window->doc_obj || !window->uri_nofrag)
 950         return E_UNEXPECTED;
 951
 952     if(name && *name == '_') {
 953         FIXME("Unsupported name %s\n", debugstr_w(name));
 954         return E_NOTIMPL;
 955     }
 956
 957     hres = do_query_service((IUnknown*)window->doc_obj->client, &SID_SNewWindowManager, &IID_INewWindowManager,
 958             (void**)&new_window_mgr);
 959     if(FAILED(hres)) {
 960         FIXME("No INewWindowManager\n");
 961         return E_NOTIMPL;
 962     }
 963
 964     hres = IUri_GetDisplayUri(window->uri_nofrag, &uri_str);
 965     if(SUCCEEDED(hres)) {
 966         hres = INewWindowManager_EvaluateNewWindow(new_window_mgr, url, name, uri_str,
 967                 features, !!replace, window->doc_obj->has_popup ? 0 : NWMF_FIRST, 0);
 968         window->doc_obj->has_popup = TRUE;
 969         SysFreeString(uri_str);
 970     }
 971     INewWindowManager_Release(new_window_mgr);
 972     if(FAILED(hres)) {
 973         *pomWindowResult = NULL;
 974         return S_OK;
 975     }
 976
 977     hres = create_relative_uri(window, url, &uri);
 978     if(FAILED(hres))
 979         return hres;
 980
 981     hres = navigate_new_window(window, uri, name, pomWindowResult);
 982     IUri_Release(uri);
 983     return hres;
 984 }
 985
 986 static HRESULT WINAPI HTMLWindow2_get_self(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 987 {
 988     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 989
 990     TRACE("(%p)->(%p)\n", This, p);
 991
 992     /* FIXME: We should return kind of proxy window here. */
 993     IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
 994     *p = &This->IHTMLWindow2_iface;
 995     return S_OK;
 996 }
 997
 998 static HRESULT WINAPI HTMLWindow2_get_top(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 999 {
1000     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1001     HTMLOuterWindow *top;
1002
1003     TRACE("(%p)->(%p)\n", This, p);
1004
1005     get_top_window(This->outer_window, &top);
1006     *p = &top->base.IHTMLWindow2_iface;
1007     IHTMLWindow2_AddRef(*p);
1008
1009     return S_OK;
1010 }
1011
1012 static HRESULT WINAPI HTMLWindow2_get_window(IHTMLWindow2 *iface, IHTMLWindow2 **p)
1013 {
1014     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1015
1016     TRACE("(%p)->(%p)\n", This, p);
1017
1018     /* FIXME: We should return kind of proxy window here. */
1019     IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1020     *p = &This->IHTMLWindow2_iface;
1021     return S_OK;
1022 }
1023
1024 static HRESULT WINAPI HTMLWindow2_navigate(IHTMLWindow2 *iface, BSTR url)
1025 {
1026     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1027     FIXME("(%p)->(%s)\n", This, debugstr_w(url));
1028     return E_NOTIMPL;
1029 }
1030
1031 static HRESULT WINAPI HTMLWindow2_put_onfocus(IHTMLWindow2 *iface, VARIANT v)
1032 {
1033     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1034
1035     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1036
1037     return set_window_event(This, EVENTID_FOCUS, &v);
1038 }
1039
1040 static HRESULT WINAPI HTMLWindow2_get_onfocus(IHTMLWindow2 *iface, VARIANT *p)
1041 {
1042     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1043
1044     TRACE("(%p)->(%p)\n", This, p);
1045
1046     return get_window_event(This, EVENTID_FOCUS, p);
1047 }
1048
1049 static HRESULT WINAPI HTMLWindow2_put_onblur(IHTMLWindow2 *iface, VARIANT v)
1050 {
1051     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1052
1053     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1054
1055     return set_window_event(This, EVENTID_BLUR, &v);
1056 }
1057
1058 static HRESULT WINAPI HTMLWindow2_get_onblur(IHTMLWindow2 *iface, VARIANT *p)
1059 {
1060     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1061
1062     TRACE("(%p)->(%p)\n", This, p);
1063
1064     return get_window_event(This, EVENTID_BLUR, p);
1065 }
1066
1067 static HRESULT WINAPI HTMLWindow2_put_onload(IHTMLWindow2 *iface, VARIANT v)
1068 {
1069     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1070
1071     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1072
1073     return set_window_event(This, EVENTID_LOAD, &v);
1074 }
1075
1076 static HRESULT WINAPI HTMLWindow2_get_onload(IHTMLWindow2 *iface, VARIANT *p)
1077 {
1078     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1079
1080     TRACE("(%p)->(%p)\n", This, p);
1081
1082     return get_window_event(This, EVENTID_LOAD, p);
1083 }
1084
1085 static HRESULT WINAPI HTMLWindow2_put_onbeforeunload(IHTMLWindow2 *iface, VARIANT v)
1086 {
1087     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1088
1089     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1090
1091     return set_window_event(This, EVENTID_BEFOREUNLOAD, &v);
1092 }
1093
1094 static HRESULT WINAPI HTMLWindow2_get_onbeforeunload(IHTMLWindow2 *iface, VARIANT *p)
1095 {
1096     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1097
1098     TRACE("(%p)->(%p)\n", This, p);
1099
1100     return get_window_event(This, EVENTID_BEFOREUNLOAD, p);
1101 }
1102
1103 static HRESULT WINAPI HTMLWindow2_put_onunload(IHTMLWindow2 *iface, VARIANT v)
1104 {
1105     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1106     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1107     return E_NOTIMPL;
1108 }
1109
1110 static HRESULT WINAPI HTMLWindow2_get_onunload(IHTMLWindow2 *iface, VARIANT *p)
1111 {
1112     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1113     FIXME("(%p)->(%p)\n", This, p);
1114     return E_NOTIMPL;
1115 }
1116
1117 static HRESULT WINAPI HTMLWindow2_put_onhelp(IHTMLWindow2 *iface, VARIANT v)
1118 {
1119     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1120
1121     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1122
1123     return set_window_event(This, EVENTID_HELP, &v);
1124 }
1125
1126 static HRESULT WINAPI HTMLWindow2_get_onhelp(IHTMLWindow2 *iface, VARIANT *p)
1127 {
1128     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1129
1130     TRACE("(%p)->(%p)\n", This, p);
1131
1132     return get_window_event(This, EVENTID_HELP, p);
1133 }
1134
1135 static HRESULT WINAPI HTMLWindow2_put_onerror(IHTMLWindow2 *iface, VARIANT v)
1136 {
1137     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1138
1139     FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
1140
1141     return set_window_event(This, EVENTID_ERROR, &v);
1142 }
1143
1144 static HRESULT WINAPI HTMLWindow2_get_onerror(IHTMLWindow2 *iface, VARIANT *p)
1145 {
1146     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1147
1148     TRACE("(%p)->(%p)\n", This, p);
1149
1150     return get_window_event(This, EVENTID_ERROR, p);
1151 }
1152
1153 static HRESULT WINAPI HTMLWindow2_put_onresize(IHTMLWindow2 *iface, VARIANT v)
1154 {
1155     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1156
1157     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1158
1159     return set_window_event(This, EVENTID_RESIZE, &v);
1160 }
1161
1162 static HRESULT WINAPI HTMLWindow2_get_onresize(IHTMLWindow2 *iface, VARIANT *p)
1163 {
1164     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1165
1166     TRACE("(%p)->(%p)\n", This, p);
1167
1168     return get_window_event(This, EVENTID_RESIZE, p);
1169 }
1170
1171 static HRESULT WINAPI HTMLWindow2_put_onscroll(IHTMLWindow2 *iface, VARIANT v)
1172 {
1173     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1174
1175     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1176
1177     return set_window_event(This, EVENTID_SCROLL, &v);
1178 }
1179
1180 static HRESULT WINAPI HTMLWindow2_get_onscroll(IHTMLWindow2 *iface, VARIANT *p)
1181 {
1182     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1183
1184     TRACE("(%p)->(%p)\n", This, p);
1185
1186     return get_window_event(This, EVENTID_SCROLL, p);
1187 }
1188
1189 static HRESULT WINAPI HTMLWindow2_get_document(IHTMLWindow2 *iface, IHTMLDocument2 **p)
1190 {
1191     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1192
1193     TRACE("(%p)->(%p)\n", This, p);
1194
1195     if(This->inner_window->doc) {
1196         /* FIXME: We should return a wrapper object here */
1197         *p = &This->inner_window->doc->basedoc.IHTMLDocument2_iface;
1198         IHTMLDocument2_AddRef(*p);
1199     }else {
1200         *p = NULL;
1201     }
1202
1203     return S_OK;
1204 }
1205
1206 static HRESULT WINAPI HTMLWindow2_get_event(IHTMLWindow2 *iface, IHTMLEventObj **p)
1207 {
1208     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1209     HTMLInnerWindow *window = This->inner_window;
1210
1211     TRACE("(%p)->(%p)\n", This, p);
1212
1213     if(window->event)
1214         IHTMLEventObj_AddRef(window->event);
1215     *p = window->event;
1216     return S_OK;
1217 }
1218
1219 static HRESULT WINAPI HTMLWindow2_get__newEnum(IHTMLWindow2 *iface, IUnknown **p)
1220 {
1221     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1222     FIXME("(%p)->(%p)\n", This, p);
1223     return E_NOTIMPL;
1224 }
1225
1226 static HRESULT WINAPI HTMLWindow2_showModalDialog(IHTMLWindow2 *iface, BSTR dialog,
1227         VARIANT *varArgIn, VARIANT *varOptions, VARIANT *varArgOut)
1228 {
1229     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1230     FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_w(dialog), varArgIn, varOptions, varArgOut);
1231     return E_NOTIMPL;
1232 }
1233
1234 static HRESULT WINAPI HTMLWindow2_showHelp(IHTMLWindow2 *iface, BSTR helpURL, VARIANT helpArg,
1235         BSTR features)
1236 {
1237     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1238     FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(helpURL), debugstr_variant(&helpArg), debugstr_w(features));
1239     return E_NOTIMPL;
1240 }
1241
1242 static HRESULT WINAPI HTMLWindow2_get_screen(IHTMLWindow2 *iface, IHTMLScreen **p)
1243 {
1244     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1245     HTMLInnerWindow *window = This->inner_window;
1246
1247     TRACE("(%p)->(%p)\n", This, p);
1248
1249     if(!window->screen) {
1250         HRESULT hres;
1251
1252         hres = HTMLScreen_Create(&window->screen);
1253         if(FAILED(hres))
1254             return hres;
1255     }
1256
1257     *p = window->screen;
1258     IHTMLScreen_AddRef(window->screen);
1259     return S_OK;
1260 }
1261
1262 static HRESULT WINAPI HTMLWindow2_get_Option(IHTMLWindow2 *iface, IHTMLOptionElementFactory **p)
1263 {
1264     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1265     HTMLInnerWindow *window = This->inner_window;
1266
1267     TRACE("(%p)->(%p)\n", This, p);
1268
1269     if(!window->option_factory) {
1270         HRESULT hres;
1271
1272         hres = HTMLOptionElementFactory_Create(window, &window->option_factory);
1273         if(FAILED(hres))
1274             return hres;
1275     }
1276
1277     *p = &window->option_factory->IHTMLOptionElementFactory_iface;
1278     IHTMLOptionElementFactory_AddRef(*p);
1279
1280     return S_OK;
1281 }
1282
1283 static HRESULT WINAPI HTMLWindow2_focus(IHTMLWindow2 *iface)
1284 {
1285     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1286
1287     TRACE("(%p)->()\n", This);
1288
1289     if(This->outer_window->doc_obj)
1290         SetFocus(This->outer_window->doc_obj->hwnd);
1291     return S_OK;
1292 }
1293
1294 static HRESULT WINAPI HTMLWindow2_get_closed(IHTMLWindow2 *iface, VARIANT_BOOL *p)
1295 {
1296     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1297     FIXME("(%p)->(%p)\n", This, p);
1298     return E_NOTIMPL;
1299 }
1300
1301 static HRESULT WINAPI HTMLWindow2_blur(IHTMLWindow2 *iface)
1302 {
1303     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1304     FIXME("(%p)->()\n", This);
1305     return E_NOTIMPL;
1306 }
1307
1308 static HRESULT WINAPI HTMLWindow2_scroll(IHTMLWindow2 *iface, LONG x, LONG y)
1309 {
1310     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1311     FIXME("(%p)->(%d %d)\n", This, x, y);
1312     return E_NOTIMPL;
1313 }
1314
1315 static HRESULT WINAPI HTMLWindow2_get_clientInformation(IHTMLWindow2 *iface, IOmNavigator **p)
1316 {
1317     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1318     FIXME("(%p)->(%p)\n", This, p);
1319     return E_NOTIMPL;
1320 }
1321
1322 static HRESULT WINAPI HTMLWindow2_setInterval(IHTMLWindow2 *iface, BSTR expression,
1323         LONG msec, VARIANT *language, LONG *timerID)
1324 {
1325     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1326     VARIANT expr;
1327
1328     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_w(expression), msec, language, timerID);
1329
1330     V_VT(&expr) = VT_BSTR;
1331     V_BSTR(&expr) = expression;
1332     return IHTMLWindow3_setInterval(&This->IHTMLWindow3_iface, &expr, msec, language, timerID);
1333 }
1334
1335 static HRESULT WINAPI HTMLWindow2_clearInterval(IHTMLWindow2 *iface, LONG timerID)
1336 {
1337     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1338
1339     TRACE("(%p)->(%d)\n", This, timerID);
1340
1341     return clear_task_timer(This->inner_window, TRUE, timerID);
1342 }
1343
1344 static HRESULT WINAPI HTMLWindow2_put_offscreenBuffering(IHTMLWindow2 *iface, VARIANT v)
1345 {
1346     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1347     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1348     return E_NOTIMPL;
1349 }
1350
1351 static HRESULT WINAPI HTMLWindow2_get_offscreenBuffering(IHTMLWindow2 *iface, VARIANT *p)
1352 {
1353     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1354     FIXME("(%p)->(%p)\n", This, p);
1355     return E_NOTIMPL;
1356 }
1357
1358 static HRESULT WINAPI HTMLWindow2_execScript(IHTMLWindow2 *iface, BSTR scode, BSTR language,
1359         VARIANT *pvarRet)
1360 {
1361     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1362
1363     TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(scode), debugstr_w(language), pvarRet);
1364
1365     return exec_script(This->inner_window, scode, language, pvarRet);
1366 }
1367
1368 static HRESULT WINAPI HTMLWindow2_toString(IHTMLWindow2 *iface, BSTR *String)
1369 {
1370     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1371
1372     static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
1373
1374     TRACE("(%p)->(%p)\n", This, String);
1375
1376     if(!String)
1377         return E_INVALIDARG;
1378
1379     *String = SysAllocString(objectW);
1380     return *String ? S_OK : E_OUTOFMEMORY;
1381 }
1382
1383 static HRESULT WINAPI HTMLWindow2_scrollBy(IHTMLWindow2 *iface, LONG x, LONG y)
1384 {
1385     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1386     nsresult nsres;
1387
1388     TRACE("(%p)->(%d %d)\n", This, x, y);
1389
1390     nsres = nsIDOMWindow_ScrollBy(This->outer_window->nswindow, x, y);
1391     if(NS_FAILED(nsres))
1392         ERR("ScrollBy failed: %08x\n", nsres);
1393
1394     return S_OK;
1395 }
1396
1397 static HRESULT WINAPI HTMLWindow2_scrollTo(IHTMLWindow2 *iface, LONG x, LONG y)
1398 {
1399     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1400     nsresult nsres;
1401
1402     TRACE("(%p)->(%d %d)\n", This, x, y);
1403
1404     nsres = nsIDOMWindow_ScrollTo(This->outer_window->nswindow, x, y);
1405     if(NS_FAILED(nsres))
1406         ERR("ScrollTo failed: %08x\n", nsres);
1407
1408     return S_OK;
1409 }
1410
1411 static HRESULT WINAPI HTMLWindow2_moveTo(IHTMLWindow2 *iface, LONG x, LONG y)
1412 {
1413     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1414     FIXME("(%p)->(%d %d)\n", This, x, y);
1415     return E_NOTIMPL;
1416 }
1417
1418 static HRESULT WINAPI HTMLWindow2_moveBy(IHTMLWindow2 *iface, LONG x, LONG y)
1419 {
1420     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1421     FIXME("(%p)->(%d %d)\n", This, x, y);
1422     return E_NOTIMPL;
1423 }
1424
1425 static HRESULT WINAPI HTMLWindow2_resizeTo(IHTMLWindow2 *iface, LONG x, LONG y)
1426 {
1427     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1428     FIXME("(%p)->(%d %d)\n", This, x, y);
1429     return E_NOTIMPL;
1430 }
1431
1432 static HRESULT WINAPI HTMLWindow2_resizeBy(IHTMLWindow2 *iface, LONG x, LONG y)
1433 {
1434     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1435     FIXME("(%p)->(%d %d)\n", This, x, y);
1436     return E_NOTIMPL;
1437 }
1438
1439 static HRESULT WINAPI HTMLWindow2_get_external(IHTMLWindow2 *iface, IDispatch **p)
1440 {
1441     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1442
1443     TRACE("(%p)->(%p)\n", This, p);
1444
1445     *p = NULL;
1446
1447     if(!This->outer_window->doc_obj->hostui)
1448         return S_OK;
1449
1450     return IDocHostUIHandler_GetExternal(This->outer_window->doc_obj->hostui, p);
1451 }
1452
1453 static const IHTMLWindow2Vtbl HTMLWindow2Vtbl = {
1454     HTMLWindow2_QueryInterface,
1455     HTMLWindow2_AddRef,
1456     HTMLWindow2_Release,
1457     HTMLWindow2_GetTypeInfoCount,
1458     HTMLWindow2_GetTypeInfo,
1459     HTMLWindow2_GetIDsOfNames,
1460     HTMLWindow2_Invoke,
1461     HTMLWindow2_item,
1462     HTMLWindow2_get_length,
1463     HTMLWindow2_get_frames,
1464     HTMLWindow2_put_defaultStatus,
1465     HTMLWindow2_get_defaultStatus,
1466     HTMLWindow2_put_status,
1467     HTMLWindow2_get_status,
1468     HTMLWindow2_setTimeout,
1469     HTMLWindow2_clearTimeout,
1470     HTMLWindow2_alert,
1471     HTMLWindow2_confirm,
1472     HTMLWindow2_prompt,
1473     HTMLWindow2_get_Image,
1474     HTMLWindow2_get_location,
1475     HTMLWindow2_get_history,
1476     HTMLWindow2_close,
1477     HTMLWindow2_put_opener,
1478     HTMLWindow2_get_opener,
1479     HTMLWindow2_get_navigator,
1480     HTMLWindow2_put_name,
1481     HTMLWindow2_get_name,
1482     HTMLWindow2_get_parent,
1483     HTMLWindow2_open,
1484     HTMLWindow2_get_self,
1485     HTMLWindow2_get_top,
1486     HTMLWindow2_get_window,
1487     HTMLWindow2_navigate,
1488     HTMLWindow2_put_onfocus,
1489     HTMLWindow2_get_onfocus,
1490     HTMLWindow2_put_onblur,
1491     HTMLWindow2_get_onblur,
1492     HTMLWindow2_put_onload,
1493     HTMLWindow2_get_onload,
1494     HTMLWindow2_put_onbeforeunload,
1495     HTMLWindow2_get_onbeforeunload,
1496     HTMLWindow2_put_onunload,
1497     HTMLWindow2_get_onunload,
1498     HTMLWindow2_put_onhelp,
1499     HTMLWindow2_get_onhelp,
1500     HTMLWindow2_put_onerror,
1501     HTMLWindow2_get_onerror,
1502     HTMLWindow2_put_onresize,
1503     HTMLWindow2_get_onresize,
1504     HTMLWindow2_put_onscroll,
1505     HTMLWindow2_get_onscroll,
1506     HTMLWindow2_get_document,
1507     HTMLWindow2_get_event,
1508     HTMLWindow2_get__newEnum,
1509     HTMLWindow2_showModalDialog,
1510     HTMLWindow2_showHelp,
1511     HTMLWindow2_get_screen,
1512     HTMLWindow2_get_Option,
1513     HTMLWindow2_focus,
1514     HTMLWindow2_get_closed,
1515     HTMLWindow2_blur,
1516     HTMLWindow2_scroll,
1517     HTMLWindow2_get_clientInformation,
1518     HTMLWindow2_setInterval,
1519     HTMLWindow2_clearInterval,
1520     HTMLWindow2_put_offscreenBuffering,
1521     HTMLWindow2_get_offscreenBuffering,
1522     HTMLWindow2_execScript,
1523     HTMLWindow2_toString,
1524     HTMLWindow2_scrollBy,
1525     HTMLWindow2_scrollTo,
1526     HTMLWindow2_moveTo,
1527     HTMLWindow2_moveBy,
1528     HTMLWindow2_resizeTo,
1529     HTMLWindow2_resizeBy,
1530     HTMLWindow2_get_external
1531 };
1532
1533 static inline HTMLWindow *impl_from_IHTMLWindow3(IHTMLWindow3 *iface)
1534 {
1535     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow3_iface);
1536 }
1537
1538 static HRESULT WINAPI HTMLWindow3_QueryInterface(IHTMLWindow3 *iface, REFIID riid, void **ppv)
1539 {
1540     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1541
1542     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1543 }
1544
1545 static ULONG WINAPI HTMLWindow3_AddRef(IHTMLWindow3 *iface)
1546 {
1547     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1548
1549     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1550 }
1551
1552 static ULONG WINAPI HTMLWindow3_Release(IHTMLWindow3 *iface)
1553 {
1554     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1555
1556     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1557 }
1558
1559 static HRESULT WINAPI HTMLWindow3_GetTypeInfoCount(IHTMLWindow3 *iface, UINT *pctinfo)
1560 {
1561     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1562
1563     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1564 }
1565
1566 static HRESULT WINAPI HTMLWindow3_GetTypeInfo(IHTMLWindow3 *iface, UINT iTInfo,
1567                                               LCID lcid, ITypeInfo **ppTInfo)
1568 {
1569     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1570
1571     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1572 }
1573
1574 static HRESULT WINAPI HTMLWindow3_GetIDsOfNames(IHTMLWindow3 *iface, REFIID riid,
1575                                                 LPOLESTR *rgszNames, UINT cNames,
1576                                                 LCID lcid, DISPID *rgDispId)
1577 {
1578     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1579
1580     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1581             rgDispId);
1582 }
1583
1584 static HRESULT WINAPI HTMLWindow3_Invoke(IHTMLWindow3 *iface, DISPID dispIdMember,
1585                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1586                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1587 {
1588     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1589
1590     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1591             pDispParams, pVarResult, pExcepInfo, puArgErr);
1592 }
1593
1594 static HRESULT WINAPI HTMLWindow3_get_screenLeft(IHTMLWindow3 *iface, LONG *p)
1595 {
1596     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1597     FIXME("(%p)->(%p)\n", This, p);
1598     return E_NOTIMPL;
1599 }
1600
1601 static HRESULT WINAPI HTMLWindow3_get_screenTop(IHTMLWindow3 *iface, LONG *p)
1602 {
1603     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1604     FIXME("(%p)->(%p)\n", This, p);
1605     return E_NOTIMPL;
1606 }
1607
1608 static HRESULT WINAPI HTMLWindow3_attachEvent(IHTMLWindow3 *iface, BSTR event, IDispatch *pDisp, VARIANT_BOOL *pfResult)
1609 {
1610     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1611     HTMLInnerWindow *window = This->inner_window;
1612
1613     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
1614
1615     if(!window->doc) {
1616         FIXME("No document\n");
1617         return E_FAIL;
1618     }
1619
1620     return attach_event(&window->doc->body_event_target, NULL, &window->doc->basedoc, event, pDisp, pfResult);
1621 }
1622
1623 static HRESULT WINAPI HTMLWindow3_detachEvent(IHTMLWindow3 *iface, BSTR event, IDispatch *pDisp)
1624 {
1625     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1626     HTMLInnerWindow *window = This->inner_window;
1627
1628     TRACE("(%p)->()\n", This);
1629
1630     if(!window->doc) {
1631         FIXME("No document\n");
1632         return E_FAIL;
1633     }
1634
1635     return detach_event(window->doc->body_event_target, &window->doc->basedoc, event, pDisp);
1636 }
1637
1638 static HRESULT window_set_timer(HTMLInnerWindow *This, VARIANT *expr, LONG msec, VARIANT *language,
1639         BOOL interval, LONG *timer_id)
1640 {
1641     IDispatch *disp = NULL;
1642     HRESULT hres;
1643
1644     switch(V_VT(expr)) {
1645     case VT_DISPATCH:
1646         disp = V_DISPATCH(expr);
1647         IDispatch_AddRef(disp);
1648         break;
1649
1650     case VT_BSTR:
1651         disp = script_parse_event(This->base.inner_window, V_BSTR(expr));
1652         break;
1653
1654     default:
1655         FIXME("unimplemented expr %s\n", debugstr_variant(expr));
1656         return E_NOTIMPL;
1657     }
1658
1659     if(!disp)
1660         return E_FAIL;
1661
1662     hres = set_task_timer(This, msec, interval, disp, timer_id);
1663     IDispatch_Release(disp);
1664
1665     return hres;
1666 }
1667
1668 static HRESULT WINAPI HTMLWindow3_setTimeout(IHTMLWindow3 *iface, VARIANT *expression, LONG msec,
1669         VARIANT *language, LONG *timerID)
1670 {
1671     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1672
1673     TRACE("(%p)->(%s %d %s %p)\n", This, debugstr_variant(expression), msec, debugstr_variant(language), timerID);
1674
1675     return window_set_timer(This->inner_window, expression, msec, language, FALSE, timerID);
1676 }
1677
1678 static HRESULT WINAPI HTMLWindow3_setInterval(IHTMLWindow3 *iface, VARIANT *expression, LONG msec,
1679         VARIANT *language, LONG *timerID)
1680 {
1681     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1682
1683     TRACE("(%p)->(%p %d %p %p)\n", This, expression, msec, language, timerID);
1684
1685     return window_set_timer(This->inner_window, expression, msec, language, TRUE, timerID);
1686 }
1687
1688 static HRESULT WINAPI HTMLWindow3_print(IHTMLWindow3 *iface)
1689 {
1690     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1691     FIXME("(%p)\n", This);
1692     return E_NOTIMPL;
1693 }
1694
1695 static HRESULT WINAPI HTMLWindow3_put_onbeforeprint(IHTMLWindow3 *iface, VARIANT v)
1696 {
1697     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1698     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1699     return E_NOTIMPL;
1700 }
1701
1702 static HRESULT WINAPI HTMLWindow3_get_onbeforeprint(IHTMLWindow3 *iface, VARIANT *p)
1703 {
1704     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1705     FIXME("(%p)->(%p)\n", This, p);
1706     return E_NOTIMPL;
1707 }
1708
1709 static HRESULT WINAPI HTMLWindow3_put_onafterprint(IHTMLWindow3 *iface, VARIANT v)
1710 {
1711     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1712     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1713     return E_NOTIMPL;
1714 }
1715
1716 static HRESULT WINAPI HTMLWindow3_get_onafterprint(IHTMLWindow3 *iface, VARIANT *p)
1717 {
1718     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1719     FIXME("(%p)->(%p)\n", This, p);
1720     return E_NOTIMPL;
1721 }
1722
1723 static HRESULT WINAPI HTMLWindow3_get_clipboardData(IHTMLWindow3 *iface, IHTMLDataTransfer **p)
1724 {
1725     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1726     FIXME("(%p)->(%p)\n", This, p);
1727     return E_NOTIMPL;
1728 }
1729
1730 static HRESULT WINAPI HTMLWindow3_showModelessDialog(IHTMLWindow3 *iface, BSTR url,
1731         VARIANT *varArgIn, VARIANT *options, IHTMLWindow2 **pDialog)
1732 {
1733     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1734     FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_w(url), varArgIn, options, pDialog);
1735     return E_NOTIMPL;
1736 }
1737
1738 static const IHTMLWindow3Vtbl HTMLWindow3Vtbl = {
1739     HTMLWindow3_QueryInterface,
1740     HTMLWindow3_AddRef,
1741     HTMLWindow3_Release,
1742     HTMLWindow3_GetTypeInfoCount,
1743     HTMLWindow3_GetTypeInfo,
1744     HTMLWindow3_GetIDsOfNames,
1745     HTMLWindow3_Invoke,
1746     HTMLWindow3_get_screenLeft,
1747     HTMLWindow3_get_screenTop,
1748     HTMLWindow3_attachEvent,
1749     HTMLWindow3_detachEvent,
1750     HTMLWindow3_setTimeout,
1751     HTMLWindow3_setInterval,
1752     HTMLWindow3_print,
1753     HTMLWindow3_put_onbeforeprint,
1754     HTMLWindow3_get_onbeforeprint,
1755     HTMLWindow3_put_onafterprint,
1756     HTMLWindow3_get_onafterprint,
1757     HTMLWindow3_get_clipboardData,
1758     HTMLWindow3_showModelessDialog
1759 };
1760
1761 static inline HTMLWindow *impl_from_IHTMLWindow4(IHTMLWindow4 *iface)
1762 {
1763     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow4_iface);
1764 }
1765
1766 static HRESULT WINAPI HTMLWindow4_QueryInterface(IHTMLWindow4 *iface, REFIID riid, void **ppv)
1767 {
1768     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1769
1770     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1771 }
1772
1773 static ULONG WINAPI HTMLWindow4_AddRef(IHTMLWindow4 *iface)
1774 {
1775     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1776
1777     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1778 }
1779
1780 static ULONG WINAPI HTMLWindow4_Release(IHTMLWindow4 *iface)
1781 {
1782     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1783
1784     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1785 }
1786
1787 static HRESULT WINAPI HTMLWindow4_GetTypeInfoCount(IHTMLWindow4 *iface, UINT *pctinfo)
1788 {
1789     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1790
1791     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1792 }
1793
1794 static HRESULT WINAPI HTMLWindow4_GetTypeInfo(IHTMLWindow4 *iface, UINT iTInfo,
1795                                               LCID lcid, ITypeInfo **ppTInfo)
1796 {
1797     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1798
1799     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1800 }
1801
1802 static HRESULT WINAPI HTMLWindow4_GetIDsOfNames(IHTMLWindow4 *iface, REFIID riid,
1803                                                 LPOLESTR *rgszNames, UINT cNames,
1804                                                 LCID lcid, DISPID *rgDispId)
1805 {
1806     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1807
1808     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1809             rgDispId);
1810 }
1811
1812 static HRESULT WINAPI HTMLWindow4_Invoke(IHTMLWindow4 *iface, DISPID dispIdMember,
1813                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1814                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1815 {
1816     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1817
1818     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1819             pDispParams, pVarResult, pExcepInfo, puArgErr);
1820 }
1821
1822 static HRESULT WINAPI HTMLWindow4_createPopup(IHTMLWindow4 *iface, VARIANT *varArgIn,
1823                             IDispatch **ppPopup)
1824 {
1825     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1826     FIXME("(%p)->(%p %p)\n", This, varArgIn, ppPopup);
1827     return E_NOTIMPL;
1828 }
1829
1830 static HRESULT WINAPI HTMLWindow4_get_frameElement(IHTMLWindow4 *iface, IHTMLFrameBase **p)
1831 {
1832     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1833     TRACE("(%p)->(%p)\n", This, p);
1834
1835     if(This->outer_window->frame_element) {
1836         *p = &This->outer_window->frame_element->IHTMLFrameBase_iface;
1837         IHTMLFrameBase_AddRef(*p);
1838     }else
1839         *p = NULL;
1840
1841     return S_OK;
1842 }
1843
1844 static const IHTMLWindow4Vtbl HTMLWindow4Vtbl = {
1845     HTMLWindow4_QueryInterface,
1846     HTMLWindow4_AddRef,
1847     HTMLWindow4_Release,
1848     HTMLWindow4_GetTypeInfoCount,
1849     HTMLWindow4_GetTypeInfo,
1850     HTMLWindow4_GetIDsOfNames,
1851     HTMLWindow4_Invoke,
1852     HTMLWindow4_createPopup,
1853     HTMLWindow4_get_frameElement
1854 };
1855
1856 static inline HTMLWindow *impl_from_IHTMLWindow5(IHTMLWindow5 *iface)
1857 {
1858     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow5_iface);
1859 }
1860
1861 static HRESULT WINAPI HTMLWindow5_QueryInterface(IHTMLWindow5 *iface, REFIID riid, void **ppv)
1862 {
1863     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1864
1865     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1866 }
1867
1868 static ULONG WINAPI HTMLWindow5_AddRef(IHTMLWindow5 *iface)
1869 {
1870     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1871
1872     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1873 }
1874
1875 static ULONG WINAPI HTMLWindow5_Release(IHTMLWindow5 *iface)
1876 {
1877     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1878
1879     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1880 }
1881
1882 static HRESULT WINAPI HTMLWindow5_GetTypeInfoCount(IHTMLWindow5 *iface, UINT *pctinfo)
1883 {
1884     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1885
1886     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1887 }
1888
1889 static HRESULT WINAPI HTMLWindow5_GetTypeInfo(IHTMLWindow5 *iface, UINT iTInfo,
1890         LCID lcid, ITypeInfo **ppTInfo)
1891 {
1892     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1893
1894     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1895 }
1896
1897 static HRESULT WINAPI HTMLWindow5_GetIDsOfNames(IHTMLWindow5 *iface, REFIID riid,
1898         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1899 {
1900     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1901
1902     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1903             rgDispId);
1904 }
1905
1906 static HRESULT WINAPI HTMLWindow5_Invoke(IHTMLWindow5 *iface, DISPID dispIdMember,
1907         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1908         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1909 {
1910     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1911
1912     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1913             pDispParams, pVarResult, pExcepInfo, puArgErr);
1914 }
1915
1916 static HRESULT WINAPI HTMLWindow5_put_XMLHttpRequest(IHTMLWindow5 *iface, VARIANT v)
1917 {
1918     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1919     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1920     return E_NOTIMPL;
1921 }
1922
1923 static HRESULT WINAPI HTMLWindow5_get_XMLHttpRequest(IHTMLWindow5 *iface, VARIANT *p)
1924 {
1925     HTMLWindow *This = impl_from_IHTMLWindow5(iface);
1926     FIXME("(%p)->(%p)\n", This, p);
1927     return E_NOTIMPL;
1928 }
1929
1930 static const IHTMLWindow5Vtbl HTMLWindow5Vtbl = {
1931     HTMLWindow5_QueryInterface,
1932     HTMLWindow5_AddRef,
1933     HTMLWindow5_Release,
1934     HTMLWindow5_GetTypeInfoCount,
1935     HTMLWindow5_GetTypeInfo,
1936     HTMLWindow5_GetIDsOfNames,
1937     HTMLWindow5_Invoke,
1938     HTMLWindow5_put_XMLHttpRequest,
1939     HTMLWindow5_get_XMLHttpRequest
1940 };
1941
1942 static inline HTMLWindow *impl_from_IHTMLWindow6(IHTMLWindow6 *iface)
1943 {
1944     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow6_iface);
1945 }
1946
1947 static HRESULT WINAPI HTMLWindow6_QueryInterface(IHTMLWindow6 *iface, REFIID riid, void **ppv)
1948 {
1949     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1950
1951     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1952 }
1953
1954 static ULONG WINAPI HTMLWindow6_AddRef(IHTMLWindow6 *iface)
1955 {
1956     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1957
1958     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1959 }
1960
1961 static ULONG WINAPI HTMLWindow6_Release(IHTMLWindow6 *iface)
1962 {
1963     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1964
1965     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1966 }
1967
1968 static HRESULT WINAPI HTMLWindow6_GetTypeInfoCount(IHTMLWindow6 *iface, UINT *pctinfo)
1969 {
1970     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1971
1972     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1973 }
1974
1975 static HRESULT WINAPI HTMLWindow6_GetTypeInfo(IHTMLWindow6 *iface, UINT iTInfo,
1976                                               LCID lcid, ITypeInfo **ppTInfo)
1977 {
1978     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1979
1980     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1981 }
1982
1983 static HRESULT WINAPI HTMLWindow6_GetIDsOfNames(IHTMLWindow6 *iface, REFIID riid,
1984                                                 LPOLESTR *rgszNames, UINT cNames,
1985                                                 LCID lcid, DISPID *rgDispId)
1986 {
1987     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1988
1989     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1990             rgDispId);
1991 }
1992
1993 static HRESULT WINAPI HTMLWindow6_Invoke(IHTMLWindow6 *iface, DISPID dispIdMember,
1994                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1995                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1996 {
1997     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1998
1999     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2000             pDispParams, pVarResult, pExcepInfo, puArgErr);
2001 }
2002
2003 static HRESULT WINAPI HTMLWindow6_put_XDomainRequest(IHTMLWindow6 *iface, VARIANT v)
2004 {
2005     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2006     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2007     return E_NOTIMPL;
2008 }
2009
2010 static HRESULT WINAPI HTMLWindow6_get_XDomainRequest(IHTMLWindow6 *iface, VARIANT *p)
2011 {
2012     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2013     FIXME("(%p)->(%p)\n", This, p);
2014     return E_NOTIMPL;
2015 }
2016
2017 static HRESULT WINAPI HTMLWindow6_get_sessionStorage(IHTMLWindow6 *iface, IHTMLStorage **p)
2018 {
2019     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2020
2021     FIXME("(%p)->(%p)\n", This, p);
2022
2023     if(!This->inner_window->session_storage) {
2024         HRESULT hres;
2025
2026         hres = create_storage(&This->inner_window->session_storage);
2027         if(FAILED(hres))
2028             return hres;
2029     }
2030
2031     IHTMLStorage_AddRef(This->inner_window->session_storage);
2032     *p = This->inner_window->session_storage;
2033     return S_OK;
2034 }
2035
2036 static HRESULT WINAPI HTMLWindow6_get_localStorage(IHTMLWindow6 *iface, IHTMLStorage **p)
2037 {
2038     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2039     FIXME("(%p)->(%p)\n", This, p);
2040     return E_NOTIMPL;
2041 }
2042
2043 static HRESULT WINAPI HTMLWindow6_put_onhashchange(IHTMLWindow6 *iface, VARIANT v)
2044 {
2045     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2046     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2047     return E_NOTIMPL;
2048 }
2049
2050 static HRESULT WINAPI HTMLWindow6_get_onhashchange(IHTMLWindow6 *iface, VARIANT *p)
2051 {
2052     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2053     FIXME("(%p)->(%p)\n", This, p);
2054     return E_NOTIMPL;
2055 }
2056
2057 static HRESULT WINAPI HTMLWindow6_get_maxConnectionsPerServer(IHTMLWindow6 *iface, LONG *p)
2058 {
2059     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2060     FIXME("(%p)->(%p)\n", This, p);
2061     return E_NOTIMPL;
2062 }
2063
2064 static HRESULT WINAPI HTMLWindow6_postMessage(IHTMLWindow6 *iface, BSTR msg, VARIANT targetOrigin)
2065 {
2066     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2067     FIXME("(%p)->(%s %s)\n", This, debugstr_w(msg), debugstr_variant(&targetOrigin));
2068     return E_NOTIMPL;
2069 }
2070
2071 static HRESULT WINAPI HTMLWindow6_toStaticHTML(IHTMLWindow6 *iface, BSTR bstrHTML, BSTR *pbstrStaticHTML)
2072 {
2073     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2074     FIXME("(%p)->(%s %p)\n", This, debugstr_w(bstrHTML), pbstrStaticHTML);
2075     return E_NOTIMPL;
2076 }
2077
2078 static HRESULT WINAPI HTMLWindow6_put_onmessage(IHTMLWindow6 *iface, VARIANT v)
2079 {
2080     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2081     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2082     return E_NOTIMPL;
2083 }
2084
2085 static HRESULT WINAPI HTMLWindow6_get_onmessage(IHTMLWindow6 *iface, VARIANT *p)
2086 {
2087     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2088     FIXME("(%p)->(%p)\n", This, p);
2089     return E_NOTIMPL;
2090 }
2091
2092 static HRESULT WINAPI HTMLWindow6_msWriteProfilerMark(IHTMLWindow6 *iface, BSTR bstrProfilerMark)
2093 {
2094     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
2095     FIXME("(%p)->(%s)\n", This, debugstr_w(bstrProfilerMark));
2096     return E_NOTIMPL;
2097 }
2098
2099 static const IHTMLWindow6Vtbl HTMLWindow6Vtbl = {
2100     HTMLWindow6_QueryInterface,
2101     HTMLWindow6_AddRef,
2102     HTMLWindow6_Release,
2103     HTMLWindow6_GetTypeInfoCount,
2104     HTMLWindow6_GetTypeInfo,
2105     HTMLWindow6_GetIDsOfNames,
2106     HTMLWindow6_Invoke,
2107     HTMLWindow6_put_XDomainRequest,
2108     HTMLWindow6_get_XDomainRequest,
2109     HTMLWindow6_get_sessionStorage,
2110     HTMLWindow6_get_localStorage,
2111     HTMLWindow6_put_onhashchange,
2112     HTMLWindow6_get_onhashchange,
2113     HTMLWindow6_get_maxConnectionsPerServer,
2114     HTMLWindow6_postMessage,
2115     HTMLWindow6_toStaticHTML,
2116     HTMLWindow6_put_onmessage,
2117     HTMLWindow6_get_onmessage,
2118     HTMLWindow6_msWriteProfilerMark
2119 };
2120
2121 static inline HTMLWindow *impl_from_IHTMLPrivateWindow(IHTMLPrivateWindow *iface)
2122 {
2123     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLPrivateWindow_iface);
2124 }
2125
2126 static HRESULT WINAPI HTMLPrivateWindow_QueryInterface(IHTMLPrivateWindow *iface, REFIID riid, void **ppv)
2127 {
2128     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2129
2130     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2131 }
2132
2133 static ULONG WINAPI HTMLPrivateWindow_AddRef(IHTMLPrivateWindow *iface)
2134 {
2135     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2136
2137     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2138 }
2139
2140 static ULONG WINAPI HTMLPrivateWindow_Release(IHTMLPrivateWindow *iface)
2141 {
2142     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2143
2144     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2145 }
2146
2147 static HRESULT WINAPI HTMLPrivateWindow_SuperNavigate(IHTMLPrivateWindow *iface, BSTR url, BSTR arg2, BSTR arg3,
2148         BSTR arg4, VARIANT *post_data_var, VARIANT *headers_var, ULONG flags)
2149 {
2150     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2151     HTMLOuterWindow *window = This->outer_window;
2152     OLECHAR *translated_url = NULL;
2153     DWORD post_data_size = 0;
2154     BYTE *post_data = NULL;
2155     WCHAR *headers = NULL;
2156     IUri *uri;
2157     HRESULT hres;
2158
2159     TRACE("(%p)->(%s %s %s %s %s %s %x)\n", This, debugstr_w(url), debugstr_w(arg2), debugstr_w(arg3), debugstr_w(arg4),
2160           debugstr_variant(post_data_var), debugstr_variant(headers_var), flags);
2161
2162     if(window->doc_obj->hostui) {
2163         hres = IDocHostUIHandler_TranslateUrl(window->doc_obj->hostui, 0, url, &translated_url);
2164         if(hres != S_OK)
2165             translated_url = NULL;
2166     }
2167
2168     hres = create_uri(translated_url ? translated_url : url, 0, &uri);
2169     CoTaskMemFree(translated_url);
2170     if(FAILED(hres))
2171         return hres;
2172
2173     if(post_data_var) {
2174         if(V_VT(post_data_var) == (VT_ARRAY|VT_UI1)) {
2175             SafeArrayAccessData(V_ARRAY(post_data_var), (void**)&post_data);
2176             post_data_size = V_ARRAY(post_data_var)->rgsabound[0].cElements;
2177         }
2178     }
2179
2180     if(headers_var && V_VT(headers_var) != VT_EMPTY && V_VT(headers_var) != VT_ERROR) {
2181         if(V_VT(headers_var) != VT_BSTR)
2182             return E_INVALIDARG;
2183
2184         headers = V_BSTR(headers_var);
2185     }
2186
2187     hres = super_navigate(window, uri, BINDING_NAVIGATED, headers, post_data, post_data_size);
2188     IUri_Release(uri);
2189     if(post_data)
2190         SafeArrayUnaccessData(V_ARRAY(post_data_var));
2191
2192     return hres;
2193 }
2194
2195 static HRESULT WINAPI HTMLPrivateWindow_GetPendingUrl(IHTMLPrivateWindow *iface, BSTR *url)
2196 {
2197     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2198     FIXME("(%p)->(%p)\n", This, url);
2199     return E_NOTIMPL;
2200 }
2201
2202 static HRESULT WINAPI HTMLPrivateWindow_SetPICSTarget(IHTMLPrivateWindow *iface, IOleCommandTarget *cmdtrg)
2203 {
2204     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2205     FIXME("(%p)->(%p)\n", This, cmdtrg);
2206     return E_NOTIMPL;
2207 }
2208
2209 static HRESULT WINAPI HTMLPrivateWindow_PICSComplete(IHTMLPrivateWindow *iface, int arg)
2210 {
2211     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2212     FIXME("(%p)->(%x)\n", This, arg);
2213     return E_NOTIMPL;
2214 }
2215
2216 static HRESULT WINAPI HTMLPrivateWindow_FindWindowByName(IHTMLPrivateWindow *iface, LPCWSTR name, IHTMLWindow2 **ret)
2217 {
2218     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2219     FIXME("(%p)->(%s %p)\n", This, debugstr_w(name), ret);
2220     return E_NOTIMPL;
2221 }
2222
2223 static HRESULT WINAPI HTMLPrivateWindow_GetAddressBarUrl(IHTMLPrivateWindow *iface, BSTR *url)
2224 {
2225     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2226     TRACE("(%p)->(%p)\n", This, url);
2227
2228     if(!url)
2229         return E_INVALIDARG;
2230
2231     *url = SysAllocString(This->outer_window->url);
2232     return S_OK;
2233 }
2234
2235 static const IHTMLPrivateWindowVtbl HTMLPrivateWindowVtbl = {
2236     HTMLPrivateWindow_QueryInterface,
2237     HTMLPrivateWindow_AddRef,
2238     HTMLPrivateWindow_Release,
2239     HTMLPrivateWindow_SuperNavigate,
2240     HTMLPrivateWindow_GetPendingUrl,
2241     HTMLPrivateWindow_SetPICSTarget,
2242     HTMLPrivateWindow_PICSComplete,
2243     HTMLPrivateWindow_FindWindowByName,
2244     HTMLPrivateWindow_GetAddressBarUrl
2245 };
2246
2247 static inline HTMLWindow *impl_from_ITravelLogClient(ITravelLogClient *iface)
2248 {
2249     return CONTAINING_RECORD(iface, HTMLWindow, ITravelLogClient_iface);
2250 }
2251
2252 static HRESULT WINAPI TravelLogClient_QueryInterface(ITravelLogClient *iface, REFIID riid, void **ppv)
2253 {
2254     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2255
2256     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2257 }
2258
2259 static ULONG WINAPI TravelLogClient_AddRef(ITravelLogClient *iface)
2260 {
2261     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2262
2263     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2264 }
2265
2266 static ULONG WINAPI TravelLogClient_Release(ITravelLogClient *iface)
2267 {
2268     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2269
2270     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2271 }
2272
2273 static HRESULT WINAPI TravelLogClient_FindWindowByIndex(ITravelLogClient *iface, DWORD dwID, IUnknown **ppunk)
2274 {
2275     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2276
2277     FIXME("(%p)->(%d %p) semi-stub\n", This, dwID, ppunk);
2278
2279     *ppunk = NULL;
2280     return E_FAIL;
2281 }
2282
2283 static HRESULT WINAPI TravelLogClient_GetWindowData(ITravelLogClient *iface, IStream *pStream, LPWINDOWDATA pWinData)
2284 {
2285     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2286     FIXME("(%p)->(%p %p)\n", This, pStream, pWinData);
2287     return E_NOTIMPL;
2288 }
2289
2290 static HRESULT WINAPI TravelLogClient_LoadHistoryPosition(ITravelLogClient *iface, LPWSTR pszUrlLocation, DWORD dwPosition)
2291 {
2292     HTMLWindow *This = impl_from_ITravelLogClient(iface);
2293     FIXME("(%p)->(%s %d)\n", This, debugstr_w(pszUrlLocation), dwPosition);
2294     return E_NOTIMPL;
2295 }
2296
2297 static const ITravelLogClientVtbl TravelLogClientVtbl = {
2298     TravelLogClient_QueryInterface,
2299     TravelLogClient_AddRef,
2300     TravelLogClient_Release,
2301     TravelLogClient_FindWindowByIndex,
2302     TravelLogClient_GetWindowData,
2303     TravelLogClient_LoadHistoryPosition
2304 };
2305
2306 static inline HTMLWindow *impl_from_IObjectIdentity(IObjectIdentity *iface)
2307 {
2308     return CONTAINING_RECORD(iface, HTMLWindow, IObjectIdentity_iface);
2309 }
2310
2311 static HRESULT WINAPI ObjectIdentity_QueryInterface(IObjectIdentity *iface, REFIID riid, void **ppv)
2312 {
2313     HTMLWindow *This = impl_from_IObjectIdentity(iface);
2314
2315     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2316 }
2317
2318 static ULONG WINAPI ObjectIdentity_AddRef(IObjectIdentity *iface)
2319 {
2320     HTMLWindow *This = impl_from_IObjectIdentity(iface);
2321
2322     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2323 }
2324
2325 static ULONG WINAPI ObjectIdentity_Release(IObjectIdentity *iface)
2326 {
2327     HTMLWindow *This = impl_from_IObjectIdentity(iface);
2328
2329     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2330 }
2331
2332 static HRESULT WINAPI ObjectIdentity_IsEqualObject(IObjectIdentity *iface, IUnknown *unk)
2333 {
2334     HTMLWindow *This = impl_from_IObjectIdentity(iface);
2335     IServiceProvider *sp;
2336     HRESULT hres;
2337
2338     TRACE("(%p)->(%p)\n", This, unk);
2339
2340     hres = IUnknown_QueryInterface(unk, &IID_IServiceProvider, (void**)&sp);
2341     if(hres != S_OK)
2342         return hres;
2343
2344     hres = &This->inner_window->base.IServiceProvider_iface==sp ||
2345         &This->outer_window->base.IServiceProvider_iface==sp ? S_OK : S_FALSE;
2346     IServiceProvider_Release(sp);
2347     return hres;
2348 }
2349
2350 static const IObjectIdentityVtbl ObjectIdentityVtbl = {
2351     ObjectIdentity_QueryInterface,
2352     ObjectIdentity_AddRef,
2353     ObjectIdentity_Release,
2354     ObjectIdentity_IsEqualObject
2355 };
2356
2357 static inline HTMLWindow *impl_from_IDispatchEx(IDispatchEx *iface)
2358 {
2359     return CONTAINING_RECORD(iface, HTMLWindow, IDispatchEx_iface);
2360 }
2361
2362 static HRESULT WINAPI WindowDispEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
2363 {
2364     HTMLWindow *This = impl_from_IDispatchEx(iface);
2365
2366     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2367 }
2368
2369 static ULONG WINAPI WindowDispEx_AddRef(IDispatchEx *iface)
2370 {
2371     HTMLWindow *This = impl_from_IDispatchEx(iface);
2372
2373     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2374 }
2375
2376 static ULONG WINAPI WindowDispEx_Release(IDispatchEx *iface)
2377 {
2378     HTMLWindow *This = impl_from_IDispatchEx(iface);
2379
2380     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2381 }
2382
2383 static HRESULT WINAPI WindowDispEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
2384 {
2385     HTMLWindow *This = impl_from_IDispatchEx(iface);
2386
2387     TRACE("(%p)->(%p)\n", This, pctinfo);
2388
2389     return IDispatchEx_GetTypeInfoCount(&This->inner_window->dispex.IDispatchEx_iface, pctinfo);
2390 }
2391
2392 static HRESULT WINAPI WindowDispEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
2393                                                LCID lcid, ITypeInfo **ppTInfo)
2394 {
2395     HTMLWindow *This = impl_from_IDispatchEx(iface);
2396
2397     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2398
2399     return IDispatchEx_GetTypeInfo(&This->inner_window->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2400 }
2401
2402 static HRESULT WINAPI WindowDispEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
2403                                                  LPOLESTR *rgszNames, UINT cNames,
2404                                                  LCID lcid, DISPID *rgDispId)
2405 {
2406     HTMLWindow *This = impl_from_IDispatchEx(iface);
2407     UINT i;
2408     HRESULT hres;
2409
2410     WARN("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2411           lcid, rgDispId);
2412
2413     for(i=0; i < cNames; i++) {
2414         /* We shouldn't use script's IDispatchEx here, so we shouldn't use GetDispID */
2415         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
2416         if(FAILED(hres))
2417             return hres;
2418     }
2419
2420     return S_OK;
2421 }
2422
2423 static HRESULT WINAPI WindowDispEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
2424                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2425                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2426 {
2427     HTMLWindow *This = impl_from_IDispatchEx(iface);
2428
2429     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2430           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2431
2432     /* FIXME: Use script dispatch */
2433
2434     return IDispatchEx_Invoke(&This->inner_window->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2435             pDispParams, pVarResult, pExcepInfo, puArgErr);
2436 }
2437
2438 static global_prop_t *alloc_global_prop(HTMLInnerWindow *This, global_prop_type_t type, BSTR name)
2439 {
2440     if(This->global_prop_cnt == This->global_prop_size) {
2441         global_prop_t *new_props;
2442         DWORD new_size;
2443
2444         if(This->global_props) {
2445             new_size = This->global_prop_size*2;
2446             new_props = heap_realloc(This->global_props, new_size*sizeof(global_prop_t));
2447         }else {
2448             new_size = 16;
2449             new_props = heap_alloc(new_size*sizeof(global_prop_t));
2450         }
2451         if(!new_props)
2452             return NULL;
2453         This->global_props = new_props;
2454         This->global_prop_size = new_size;
2455     }
2456
2457     This->global_props[This->global_prop_cnt].name = heap_strdupW(name);
2458     if(!This->global_props[This->global_prop_cnt].name)
2459         return NULL;
2460
2461     This->global_props[This->global_prop_cnt].type = type;
2462     return This->global_props + This->global_prop_cnt++;
2463 }
2464
2465 static inline DWORD prop_to_dispid(HTMLInnerWindow *This, global_prop_t *prop)
2466 {
2467     return MSHTML_DISPID_CUSTOM_MIN + (prop-This->global_props);
2468 }
2469
2470 HRESULT search_window_props(HTMLInnerWindow *This, BSTR bstrName, DWORD grfdex, DISPID *pid)
2471 {
2472     DWORD i;
2473     ScriptHost *script_host;
2474     DISPID id;
2475
2476     for(i=0; i < This->global_prop_cnt; i++) {
2477         /* FIXME: case sensitivity */
2478         if(!strcmpW(This->global_props[i].name, bstrName)) {
2479             *pid = MSHTML_DISPID_CUSTOM_MIN+i;
2480             return S_OK;
2481         }
2482     }
2483
2484     if(find_global_prop(This->base.inner_window, bstrName, grfdex, &script_host, &id)) {
2485         global_prop_t *prop;
2486
2487         prop = alloc_global_prop(This, GLOBAL_SCRIPTVAR, bstrName);
2488         if(!prop)
2489             return E_OUTOFMEMORY;
2490
2491         prop->script_host = script_host;
2492         prop->id = id;
2493
2494         *pid = prop_to_dispid(This, prop);
2495         return S_OK;
2496     }
2497
2498     return DISP_E_UNKNOWNNAME;
2499 }
2500
2501 static HRESULT WINAPI WindowDispEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
2502 {
2503     HTMLWindow *This = impl_from_IDispatchEx(iface);
2504     HTMLInnerWindow *window = This->inner_window;
2505     HRESULT hres;
2506
2507     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
2508
2509     hres = search_window_props(window, bstrName, grfdex, pid);
2510     if(hres != DISP_E_UNKNOWNNAME)
2511         return hres;
2512
2513     hres = IDispatchEx_GetDispID(&window->base.inner_window->dispex.IDispatchEx_iface, bstrName, grfdex, pid);
2514     if(hres != DISP_E_UNKNOWNNAME)
2515         return hres;
2516
2517     if(This->outer_window) {
2518         HTMLOuterWindow *frame;
2519
2520         hres = get_frame_by_name(This->outer_window, bstrName, FALSE, &frame);
2521         if(SUCCEEDED(hres) && frame) {
2522             global_prop_t *prop;
2523
2524             IHTMLWindow2_Release(&frame->base.IHTMLWindow2_iface);
2525
2526             prop = alloc_global_prop(window, GLOBAL_FRAMEVAR, bstrName);
2527             if(!prop)
2528                 return E_OUTOFMEMORY;
2529
2530             *pid = prop_to_dispid(window, prop);
2531             return S_OK;
2532         }
2533     }
2534
2535     if(window->doc) {
2536         global_prop_t *prop;
2537         IHTMLElement *elem;
2538
2539         hres = IHTMLDocument3_getElementById(&window->base.inner_window->doc->basedoc.IHTMLDocument3_iface,
2540                                              bstrName, &elem);
2541         if(SUCCEEDED(hres) && elem) {
2542             IHTMLElement_Release(elem);
2543
2544             prop = alloc_global_prop(window, GLOBAL_ELEMENTVAR, bstrName);
2545             if(!prop)
2546                 return E_OUTOFMEMORY;
2547
2548             *pid = prop_to_dispid(window, prop);
2549             return S_OK;
2550         }
2551     }
2552
2553     return DISP_E_UNKNOWNNAME;
2554 }
2555
2556 static HRESULT WINAPI WindowDispEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
2557         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
2558 {
2559     HTMLWindow *This = impl_from_IDispatchEx(iface);
2560     HTMLInnerWindow *window = This->inner_window;
2561
2562     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
2563
2564     if(id == DISPID_IHTMLWINDOW2_LOCATION && (wFlags & DISPATCH_PROPERTYPUT)) {
2565         HTMLLocation *location;
2566         HRESULT hres;
2567
2568         TRACE("forwarding to location.href\n");
2569
2570         hres = get_location(window, &location);
2571         if(FAILED(hres))
2572             return hres;
2573
2574         hres = IDispatchEx_InvokeEx(&location->dispex.IDispatchEx_iface, DISPID_VALUE, lcid,
2575                 wFlags, pdp, pvarRes, pei, pspCaller);
2576         IHTMLLocation_Release(&location->IHTMLLocation_iface);
2577         return hres;
2578     }
2579
2580     return IDispatchEx_InvokeEx(&window->dispex.IDispatchEx_iface, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
2581 }
2582
2583 static HRESULT WINAPI WindowDispEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
2584 {
2585     HTMLWindow *This = impl_from_IDispatchEx(iface);
2586
2587     TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
2588
2589     return IDispatchEx_DeleteMemberByName(&This->inner_window->dispex.IDispatchEx_iface, bstrName, grfdex);
2590 }
2591
2592 static HRESULT WINAPI WindowDispEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
2593 {
2594     HTMLWindow *This = impl_from_IDispatchEx(iface);
2595
2596     TRACE("(%p)->(%x)\n", This, id);
2597
2598     return IDispatchEx_DeleteMemberByDispID(&This->inner_window->dispex.IDispatchEx_iface, id);
2599 }
2600
2601 static HRESULT WINAPI WindowDispEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
2602 {
2603     HTMLWindow *This = impl_from_IDispatchEx(iface);
2604
2605     TRACE("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
2606
2607     return IDispatchEx_GetMemberProperties(&This->inner_window->dispex.IDispatchEx_iface, id, grfdexFetch,
2608             pgrfdex);
2609 }
2610
2611 static HRESULT WINAPI WindowDispEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
2612 {
2613     HTMLWindow *This = impl_from_IDispatchEx(iface);
2614
2615     TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
2616
2617     return IDispatchEx_GetMemberName(&This->inner_window->dispex.IDispatchEx_iface, id, pbstrName);
2618 }
2619
2620 static HRESULT WINAPI WindowDispEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
2621 {
2622     HTMLWindow *This = impl_from_IDispatchEx(iface);
2623
2624     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
2625
2626     return IDispatchEx_GetNextDispID(&This->inner_window->dispex.IDispatchEx_iface, grfdex, id, pid);
2627 }
2628
2629 static HRESULT WINAPI WindowDispEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
2630 {
2631     HTMLWindow *This = impl_from_IDispatchEx(iface);
2632
2633     TRACE("(%p)->(%p)\n", This, ppunk);
2634
2635     *ppunk = NULL;
2636     return S_OK;
2637 }
2638
2639 static const IDispatchExVtbl WindowDispExVtbl = {
2640     WindowDispEx_QueryInterface,
2641     WindowDispEx_AddRef,
2642     WindowDispEx_Release,
2643     WindowDispEx_GetTypeInfoCount,
2644     WindowDispEx_GetTypeInfo,
2645     WindowDispEx_GetIDsOfNames,
2646     WindowDispEx_Invoke,
2647     WindowDispEx_GetDispID,
2648     WindowDispEx_InvokeEx,
2649     WindowDispEx_DeleteMemberByName,
2650     WindowDispEx_DeleteMemberByDispID,
2651     WindowDispEx_GetMemberProperties,
2652     WindowDispEx_GetMemberName,
2653     WindowDispEx_GetNextDispID,
2654     WindowDispEx_GetNameSpaceParent
2655 };
2656
2657 static inline HTMLWindow *impl_from_IServiceProvider(IServiceProvider *iface)
2658 {
2659     return CONTAINING_RECORD(iface, HTMLWindow, IServiceProvider_iface);
2660 }
2661
2662 static HRESULT WINAPI HTMLWindowSP_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
2663 {
2664     HTMLWindow *This = impl_from_IServiceProvider(iface);
2665     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2666 }
2667
2668 static ULONG WINAPI HTMLWindowSP_AddRef(IServiceProvider *iface)
2669 {
2670     HTMLWindow *This = impl_from_IServiceProvider(iface);
2671     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2672 }
2673
2674 static ULONG WINAPI HTMLWindowSP_Release(IServiceProvider *iface)
2675 {
2676     HTMLWindow *This = impl_from_IServiceProvider(iface);
2677     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2678 }
2679
2680 static HRESULT WINAPI HTMLWindowSP_QueryService(IServiceProvider *iface, REFGUID guidService, REFIID riid, void **ppv)
2681 {
2682     HTMLWindow *This = impl_from_IServiceProvider(iface);
2683
2684     if(IsEqualGUID(guidService, &IID_IHTMLWindow2)) {
2685         TRACE("IID_IHTMLWindow2\n");
2686         return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2687     }
2688
2689     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
2690
2691     if(!This->outer_window->doc_obj)
2692         return E_NOINTERFACE;
2693
2694     return IServiceProvider_QueryService(&This->outer_window->doc_obj->basedoc.IServiceProvider_iface,
2695             guidService, riid, ppv);
2696 }
2697
2698 static const IServiceProviderVtbl ServiceProviderVtbl = {
2699     HTMLWindowSP_QueryInterface,
2700     HTMLWindowSP_AddRef,
2701     HTMLWindowSP_Release,
2702     HTMLWindowSP_QueryService
2703 };
2704
2705 static inline HTMLInnerWindow *impl_from_DispatchEx(DispatchEx *iface)
2706 {
2707     return CONTAINING_RECORD(iface, HTMLInnerWindow, dispex);
2708 }
2709
2710 static HRESULT HTMLWindow_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
2711         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
2712 {
2713     HTMLInnerWindow *This = impl_from_DispatchEx(dispex);
2714     global_prop_t *prop;
2715     DWORD idx;
2716     HRESULT hres;
2717
2718     idx = id - MSHTML_DISPID_CUSTOM_MIN;
2719     if(idx >= This->global_prop_cnt)
2720         return DISP_E_MEMBERNOTFOUND;
2721
2722     prop = This->global_props+idx;
2723
2724     switch(prop->type) {
2725     case GLOBAL_SCRIPTVAR: {
2726         IDispatchEx *iface;
2727         IDispatch *disp;
2728
2729         disp = get_script_disp(prop->script_host);
2730         if(!disp)
2731             return E_UNEXPECTED;
2732
2733         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&iface);
2734         if(SUCCEEDED(hres)) {
2735             TRACE("%s >>>\n", debugstr_w(prop->name));
2736             hres = IDispatchEx_InvokeEx(iface, prop->id, lcid, flags, params, res, ei, caller);
2737             if(hres == S_OK)
2738                 TRACE("%s <<<\n", debugstr_w(prop->name));
2739             else
2740                 WARN("%s <<< %08x\n", debugstr_w(prop->name), hres);
2741             IDispatchEx_Release(iface);
2742         }else {
2743             FIXME("No IDispatchEx\n");
2744         }
2745         IDispatch_Release(disp);
2746         break;
2747     }
2748     case GLOBAL_ELEMENTVAR:
2749         switch(flags) {
2750         case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
2751         case DISPATCH_PROPERTYGET: {
2752             IHTMLElement *elem;
2753
2754             hres = IHTMLDocument3_getElementById(&This->base.inner_window->doc->basedoc.IHTMLDocument3_iface,
2755                     prop->name, &elem);
2756             if(FAILED(hres))
2757                 return hres;
2758
2759             if(!elem)
2760                 return DISP_E_MEMBERNOTFOUND;
2761
2762             V_VT(res) = VT_DISPATCH;
2763             V_DISPATCH(res) = (IDispatch*)elem;
2764             return S_OK;
2765         }
2766         case DISPATCH_PROPERTYPUT: {
2767             DISPID dispex_id;
2768
2769             hres = dispex_get_dynid(&This->dispex, prop->name, &dispex_id);
2770             if(FAILED(hres))
2771                 return hres;
2772
2773             prop->type = GLOBAL_DISPEXVAR;
2774             prop->id = dispex_id;
2775             return IDispatchEx_InvokeEx(&This->dispex.IDispatchEx_iface, dispex_id, 0, flags, params, res, ei, caller);
2776         }
2777         default:
2778             FIXME("Not supported flags: %x\n", flags);
2779             return E_NOTIMPL;
2780         }
2781     case GLOBAL_FRAMEVAR:
2782         if(!This->base.outer_window)
2783             return E_UNEXPECTED;
2784
2785         switch(flags) {
2786         case DISPATCH_PROPERTYGET: {
2787             HTMLOuterWindow *frame;
2788
2789             hres = get_frame_by_name(This->base.outer_window, prop->name, FALSE, &frame);
2790             if(FAILED(hres))
2791                 return hres;
2792
2793             if(!frame)
2794                 return DISP_E_MEMBERNOTFOUND;
2795
2796             V_VT(res) = VT_DISPATCH;
2797             V_DISPATCH(res) = (IDispatch*)&frame->base.inner_window->base.IHTMLWindow2_iface;
2798             IDispatch_AddRef(V_DISPATCH(res));
2799             return S_OK;
2800         }
2801         default:
2802             FIXME("Not supported flags: %x\n", flags);
2803             return E_NOTIMPL;
2804         }
2805     case GLOBAL_DISPEXVAR:
2806         return IDispatchEx_InvokeEx(&This->dispex.IDispatchEx_iface, prop->id, 0, flags, params, res, ei, caller);
2807     default:
2808         ERR("invalid type %d\n", prop->type);
2809         hres = DISP_E_MEMBERNOTFOUND;
2810     }
2811
2812     return hres;
2813 }
2814
2815
2816 static const dispex_static_data_vtbl_t HTMLWindow_dispex_vtbl = {
2817     NULL,
2818     NULL,
2819     HTMLWindow_invoke,
2820     NULL
2821 };
2822
2823 static const tid_t HTMLWindow_iface_tids[] = {
2824     IHTMLWindow2_tid,
2825     IHTMLWindow3_tid,
2826     IHTMLWindow4_tid,
2827     IHTMLWindow6_tid,
2828     0
2829 };
2830
2831 static dispex_static_data_t HTMLWindow_dispex = {
2832     &HTMLWindow_dispex_vtbl,
2833     DispHTMLWindow2_tid,
2834     NULL,
2835     HTMLWindow_iface_tids
2836 };
2837
2838 static void *alloc_window(size_t size)
2839 {
2840     HTMLWindow *window;
2841
2842     window = heap_alloc_zero(size);
2843     if(!window)
2844         return NULL;
2845
2846     window->IHTMLWindow2_iface.lpVtbl = &HTMLWindow2Vtbl;
2847     window->IHTMLWindow3_iface.lpVtbl = &HTMLWindow3Vtbl;
2848     window->IHTMLWindow4_iface.lpVtbl = &HTMLWindow4Vtbl;
2849     window->IHTMLWindow5_iface.lpVtbl = &HTMLWindow5Vtbl;
2850     window->IHTMLWindow6_iface.lpVtbl = &HTMLWindow6Vtbl;
2851     window->IHTMLPrivateWindow_iface.lpVtbl = &HTMLPrivateWindowVtbl;
2852     window->IDispatchEx_iface.lpVtbl = &WindowDispExVtbl;
2853     window->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
2854     window->ITravelLogClient_iface.lpVtbl = &TravelLogClientVtbl;
2855     window->IObjectIdentity_iface.lpVtbl = &ObjectIdentityVtbl;
2856     window->ref = 1;
2857
2858     return window;
2859 }
2860
2861 static HRESULT create_inner_window(HTMLOuterWindow *outer_window, IMoniker *mon, HTMLInnerWindow **ret)
2862 {
2863     HTMLInnerWindow *window;
2864
2865     window = alloc_window(sizeof(HTMLInnerWindow));
2866     if(!window)
2867         return E_OUTOFMEMORY;
2868
2869     list_init(&window->script_hosts);
2870     list_init(&window->bindings);
2871     list_init(&window->script_queue);
2872
2873     window->base.outer_window = outer_window;
2874     window->base.inner_window = window;
2875
2876     init_dispex(&window->dispex, (IUnknown*)&window->base.IHTMLWindow2_iface, &HTMLWindow_dispex);
2877
2878     window->task_magic = get_task_target_magic();
2879
2880     if(mon) {
2881         IMoniker_AddRef(mon);
2882         window->mon = mon;
2883     }
2884
2885     *ret = window;
2886     return S_OK;
2887 }
2888
2889 HRESULT HTMLOuterWindow_Create(HTMLDocumentObj *doc_obj, nsIDOMWindow *nswindow,
2890         HTMLOuterWindow *parent, HTMLOuterWindow **ret)
2891 {
2892     HTMLOuterWindow *window;
2893     HRESULT hres;
2894
2895     window = alloc_window(sizeof(HTMLOuterWindow));
2896     if(!window)
2897         return E_OUTOFMEMORY;
2898
2899     window->base.outer_window = window;
2900     window->base.inner_window = NULL;
2901
2902     window->window_ref = heap_alloc(sizeof(windowref_t));
2903     if(!window->window_ref) {
2904         heap_free(window);
2905         return E_OUTOFMEMORY;
2906     }
2907
2908     window->doc_obj = doc_obj;
2909
2910     window->window_ref->window = window;
2911     window->window_ref->ref = 1;
2912
2913     if(nswindow) {
2914         nsIDOMWindow_AddRef(nswindow);
2915         window->nswindow = nswindow;
2916     }
2917
2918     window->scriptmode = parent ? parent->scriptmode : SCRIPTMODE_GECKO;
2919     window->readystate = READYSTATE_UNINITIALIZED;
2920
2921     hres = create_pending_window(window, NULL);
2922     if(SUCCEEDED(hres))
2923         hres = update_window_doc(window->pending_window);
2924     if(FAILED(hres)) {
2925         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
2926         return hres;
2927     }
2928
2929     hres = CoInternetCreateSecurityManager(NULL, &window->secmgr, 0);
2930     if(FAILED(hres)) {
2931         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
2932         return hres;
2933     }
2934
2935     window->task_magic = get_task_target_magic();
2936
2937     list_init(&window->children);
2938     list_add_head(&window_list, &window->entry);
2939
2940     if(parent) {
2941         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
2942
2943         window->parent = parent;
2944         list_add_tail(&parent->children, &window->sibling_entry);
2945     }
2946
2947     TRACE("%p inner_window %p\n", window, window->base.inner_window);
2948
2949     *ret = window;
2950     return S_OK;
2951 }
2952
2953 HRESULT create_pending_window(HTMLOuterWindow *outer_window, nsChannelBSC *channelbsc)
2954 {
2955     HTMLInnerWindow *pending_window;
2956     HRESULT hres;
2957
2958     hres = create_inner_window(outer_window, outer_window->mon /* FIXME */, &pending_window);
2959     if(FAILED(hres))
2960         return hres;
2961
2962     if(channelbsc) {
2963         IBindStatusCallback_AddRef(&channelbsc->bsc.IBindStatusCallback_iface);
2964         pending_window->bscallback = channelbsc;
2965     }
2966
2967     if(outer_window->pending_window) {
2968         abort_window_bindings(outer_window->pending_window);
2969         outer_window->pending_window->base.outer_window = NULL;
2970         IHTMLWindow2_Release(&outer_window->pending_window->base.IHTMLWindow2_iface);
2971     }
2972
2973     outer_window->pending_window = pending_window;
2974     return S_OK;
2975 }
2976
2977 HRESULT update_window_doc(HTMLInnerWindow *window)
2978 {
2979     HTMLOuterWindow *outer_window = window->base.outer_window;
2980     nsIDOMHTMLDocument *nshtmldoc;
2981     nsIDOMDocument *nsdoc;
2982     nsresult nsres;
2983     HRESULT hres;
2984
2985     assert(!window->doc);
2986
2987     if(!outer_window) {
2988         ERR("NULL outer window\n");
2989         return E_UNEXPECTED;
2990     }
2991
2992     nsres = nsIDOMWindow_GetDocument(outer_window->nswindow, &nsdoc);
2993     if(NS_FAILED(nsres) || !nsdoc) {
2994         ERR("GetDocument failed: %08x\n", nsres);
2995         return E_FAIL;
2996     }
2997
2998     nsres = nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
2999     nsIDOMDocument_Release(nsdoc);
3000     if(NS_FAILED(nsres)) {
3001         ERR("Could not get nsIDOMHTMLDocument iface: %08x\n", nsres);
3002         return E_FAIL;
3003     }
3004
3005     hres = create_doc_from_nsdoc(nshtmldoc, outer_window->doc_obj, window, &window->doc);
3006     nsIDOMHTMLDocument_Release(nshtmldoc);
3007     if(FAILED(hres))
3008         return hres;
3009
3010     if(outer_window->doc_obj->usermode == EDITMODE) {
3011         nsAString mode_str;
3012         nsresult nsres;
3013
3014         static const PRUnichar onW[] = {'o','n',0};
3015
3016         nsAString_InitDepend(&mode_str, onW);
3017         nsres = nsIDOMHTMLDocument_SetDesignMode(window->doc->nsdoc, &mode_str);
3018         nsAString_Finish(&mode_str);
3019         if(NS_FAILED(nsres))
3020             ERR("SetDesignMode failed: %08x\n", nsres);
3021     }
3022
3023     if(window != outer_window->pending_window) {
3024         ERR("not current pending window\n");
3025         return S_OK;
3026     }
3027
3028     if(outer_window->base.inner_window)
3029         detach_inner_window(outer_window->base.inner_window);
3030     outer_window->base.inner_window = window;
3031     outer_window->pending_window = NULL;
3032
3033     if(outer_window->doc_obj->basedoc.window == outer_window || !outer_window->doc_obj->basedoc.window) {
3034         if(outer_window->doc_obj->basedoc.doc_node)
3035             htmldoc_release(&outer_window->doc_obj->basedoc.doc_node->basedoc);
3036         outer_window->doc_obj->basedoc.doc_node = window->doc;
3037         htmldoc_addref(&window->doc->basedoc);
3038     }
3039
3040     return hres;
3041 }
3042
3043 HTMLOuterWindow *nswindow_to_window(const nsIDOMWindow *nswindow)
3044 {
3045     HTMLOuterWindow *iter;
3046
3047     LIST_FOR_EACH_ENTRY(iter, &window_list, HTMLOuterWindow, entry) {
3048         if(iter->nswindow == nswindow)
3049             return iter;
3050     }
3051
3052     return NULL;
3053 }