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