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