dlls/mshtml/htmlwindow.c

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