reactos/base/shell/ie/mshtml/htmlwindow.c

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