dlls/mshtml/htmlwindow.c

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