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