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