git.oblomov.eu Git - wine/blob - dlls/mshtml/htmlwindow.c

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