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