dlls/mshtml/htmlwindow.c

   1 /*
   2  * Copyright 2006-2010 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
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27 #include "mshtmdid.h"
  28 #include "shlguid.h"
  29
  30 #define NO_SHLWAPI_REG
  31 #include "shlwapi.h"
  32
  33 #include "wine/debug.h"
  34
  35 #include "mshtml_private.h"
  36 #include "htmlevent.h"
  37 #include "binding.h"
  38 #include "resource.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  41
  42 static struct list window_list = LIST_INIT(window_list);
  43
  44 static void window_set_docnode(HTMLWindow *window, HTMLDocumentNode *doc_node)
  45 {
  46     if(window->doc) {
  47         if(window->doc_obj && window == window->doc_obj->basedoc.window)
  48             window->doc->basedoc.cp_container.forward_container = NULL;
  49         abort_document_bindings(window->doc);
  50         window->doc->basedoc.window = NULL;
  51         htmldoc_release(&window->doc->basedoc);
  52     }
  53     window->doc = doc_node;
  54     if(doc_node)
  55         htmldoc_addref(&doc_node->basedoc);
  56
  57     if(window->doc_obj && window->doc_obj->basedoc.window == window) {
  58         if(window->doc_obj->basedoc.doc_node)
  59             htmldoc_release(&window->doc_obj->basedoc.doc_node->basedoc);
  60         window->doc_obj->basedoc.doc_node = doc_node;
  61         if(doc_node)
  62             htmldoc_addref(&doc_node->basedoc);
  63     }
  64
  65     if(doc_node && window->doc_obj && window->doc_obj->usermode == EDITMODE) {
  66         nsAString mode_str;
  67         nsresult nsres;
  68
  69         static const PRUnichar onW[] = {'o','n',0};
  70
  71         nsAString_Init(&mode_str, onW);
  72         nsres = nsIDOMHTMLDocument_SetDesignMode(doc_node->nsdoc, &mode_str);
  73         nsAString_Finish(&mode_str);
  74         if(NS_FAILED(nsres))
  75             ERR("SetDesignMode failed: %08x\n", nsres);
  76     }
  77 }
  78
  79 static void release_children(HTMLWindow *This)
  80 {
  81     HTMLWindow *child;
  82
  83     while(!list_empty(&This->children)) {
  84         child = LIST_ENTRY(list_tail(&This->children), HTMLWindow, sibling_entry);
  85
  86         list_remove(&child->sibling_entry);
  87         child->parent = NULL;
  88         IHTMLWindow2_Release(&child->IHTMLWindow2_iface);
  89     }
  90 }
  91
  92 static HRESULT get_location(HTMLWindow *This, HTMLLocation **ret)
  93 {
  94     if(This->location) {
  95         IHTMLLocation_AddRef(&This->location->IHTMLLocation_iface);
  96     }else {
  97         HRESULT hres;
  98
  99         hres = HTMLLocation_Create(This, &This->location);
 100         if(FAILED(hres))
 101             return hres;
 102     }
 103
 104     *ret = This->location;
 105     return S_OK;
 106 }
 107
 108 static inline HRESULT set_window_event(HTMLWindow *window, eventid_t eid, VARIANT *var)
 109 {
 110     if(!window->doc) {
 111         FIXME("No document\n");
 112         return E_FAIL;
 113     }
 114
 115     return set_event_handler(&window->doc->body_event_target, NULL, window->doc, eid, var);
 116 }
 117
 118 static inline HRESULT get_window_event(HTMLWindow *window, eventid_t eid, VARIANT *var)
 119 {
 120     if(!window->doc) {
 121         FIXME("No document\n");
 122         return E_FAIL;
 123     }
 124
 125     return get_event_handler(&window->doc->body_event_target, eid, var);
 126 }
 127
 128 static inline HTMLWindow *impl_from_IHTMLWindow2(IHTMLWindow2 *iface)
 129 {
 130     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow2_iface);
 131 }
 132
 133 static HRESULT WINAPI HTMLWindow2_QueryInterface(IHTMLWindow2 *iface, REFIID riid, void **ppv)
 134 {
 135     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 136
 137     *ppv = NULL;
 138
 139     if(IsEqualGUID(&IID_IUnknown, riid)) {
 140         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 141         *ppv = &This->IHTMLWindow2_iface;
 142     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 143         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 144         *ppv = &This->IHTMLWindow2_iface;
 145     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 146         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 147         *ppv = &This->IDispatchEx_iface;
 148     }else if(IsEqualGUID(&IID_IHTMLFramesCollection2, riid)) {
 149         TRACE("(%p)->(IID_IHTMLFramesCollection2 %p)\n", This, ppv);
 150         *ppv = &This->IHTMLWindow2_iface;
 151     }else if(IsEqualGUID(&IID_IHTMLWindow2, riid)) {
 152         TRACE("(%p)->(IID_IHTMLWindow2 %p)\n", This, ppv);
 153         *ppv = &This->IHTMLWindow2_iface;
 154     }else if(IsEqualGUID(&IID_IHTMLWindow3, riid)) {
 155         TRACE("(%p)->(IID_IHTMLWindow3 %p)\n", This, ppv);
 156         *ppv = &This->IHTMLWindow3_iface;
 157     }else if(IsEqualGUID(&IID_IHTMLWindow4, riid)) {
 158         TRACE("(%p)->(IID_IHTMLWindow4 %p)\n", This, ppv);
 159         *ppv = &This->IHTMLWindow4_iface;
 160     }else if(IsEqualGUID(&IID_IHTMLWindow6, riid)) {
 161         TRACE("(%p)->(IID_IHTMLWindow6 %p)\n", This, ppv);
 162         *ppv = &This->IHTMLWindow6_iface;
 163     }else if(IsEqualGUID(&IID_IHTMLPrivateWindow, riid)) {
 164         TRACE("(%p)->(IID_IHTMLPrivateWindow %p)\n", This, ppv);
 165         *ppv = &This->IHTMLPrivateWindow_iface;
 166     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 167         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 168         *ppv = &This->IServiceProvider_iface;
 169     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 170         return *ppv ? S_OK : E_NOINTERFACE;
 171     }
 172
 173     if(*ppv) {
 174         IUnknown_AddRef((IUnknown*)*ppv);
 175         return S_OK;
 176     }
 177
 178     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 179     return E_NOINTERFACE;
 180 }
 181
 182 static ULONG WINAPI HTMLWindow2_AddRef(IHTMLWindow2 *iface)
 183 {
 184     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 185     LONG ref = InterlockedIncrement(&This->ref);
 186
 187     TRACE("(%p) ref=%d\n", This, ref);
 188
 189     return ref;
 190 }
 191
 192 static ULONG WINAPI HTMLWindow2_Release(IHTMLWindow2 *iface)
 193 {
 194     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 195     LONG ref = InterlockedDecrement(&This->ref);
 196
 197     TRACE("(%p) ref=%d\n", This, ref);
 198
 199     if(!ref) {
 200         DWORD i;
 201
 202         remove_target_tasks(This->task_magic);
 203         set_window_bscallback(This, NULL);
 204         set_current_mon(This, NULL);
 205         window_set_docnode(This, NULL);
 206         release_children(This);
 207
 208         if(This->secmgr)
 209             IInternetSecurityManager_Release(This->secmgr);
 210
 211         if(This->frame_element)
 212             This->frame_element->content_window = NULL;
 213
 214         if(This->option_factory) {
 215             This->option_factory->window = NULL;
 216             IHTMLOptionElementFactory_Release(&This->option_factory->IHTMLOptionElementFactory_iface);
 217         }
 218
 219         if(This->image_factory) {
 220             This->image_factory->window = NULL;
 221             IHTMLImageElementFactory_Release(&This->image_factory->IHTMLImageElementFactory_iface);
 222         }
 223
 224         if(This->location) {
 225             This->location->window = NULL;
 226             IHTMLLocation_Release(&This->location->IHTMLLocation_iface);
 227         }
 228
 229         if(This->screen)
 230             IHTMLScreen_Release(This->screen);
 231
 232         for(i=0; i < This->global_prop_cnt; i++)
 233             heap_free(This->global_props[i].name);
 234
 235         This->window_ref->window = NULL;
 236         windowref_release(This->window_ref);
 237
 238         heap_free(This->global_props);
 239         release_script_hosts(This);
 240
 241         if(This->nswindow)
 242             nsIDOMWindow_Release(This->nswindow);
 243
 244         list_remove(&This->entry);
 245         release_dispex(&This->dispex);
 246         heap_free(This);
 247     }
 248
 249     return ref;
 250 }
 251
 252 static HRESULT WINAPI HTMLWindow2_GetTypeInfoCount(IHTMLWindow2 *iface, UINT *pctinfo)
 253 {
 254     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 255
 256     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
 257 }
 258
 259 static HRESULT WINAPI HTMLWindow2_GetTypeInfo(IHTMLWindow2 *iface, UINT iTInfo,
 260                                               LCID lcid, ITypeInfo **ppTInfo)
 261 {
 262     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 263
 264     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 265 }
 266
 267 static HRESULT WINAPI HTMLWindow2_GetIDsOfNames(IHTMLWindow2 *iface, REFIID riid,
 268                                                 LPOLESTR *rgszNames, UINT cNames,
 269                                                 LCID lcid, DISPID *rgDispId)
 270 {
 271     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 272
 273     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
 274             rgDispId);
 275 }
 276
 277 static HRESULT WINAPI HTMLWindow2_Invoke(IHTMLWindow2 *iface, DISPID dispIdMember,
 278                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 279                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 280 {
 281     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 282
 283     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 284             pDispParams, pVarResult, pExcepInfo, puArgErr);
 285 }
 286
 287 static HRESULT get_frame_by_index(nsIDOMWindowCollection *nsFrames, PRUint32 index, HTMLWindow **ret)
 288 {
 289     PRUint32 length;
 290     nsIDOMWindow *nsWindow;
 291     nsresult nsres;
 292
 293     nsres = nsIDOMWindowCollection_GetLength(nsFrames, &length);
 294     if(NS_FAILED(nsres)) {
 295         FIXME("nsIDOMWindowCollection_GetLength failed: 0x%08x\n", nsres);
 296         return E_FAIL;
 297     }
 298
 299     if(index >= length)
 300         return DISP_E_MEMBERNOTFOUND;
 301
 302     nsres = nsIDOMWindowCollection_Item(nsFrames, index, &nsWindow);
 303     if(NS_FAILED(nsres)) {
 304         FIXME("nsIDOMWindowCollection_Item failed: 0x%08x\n", nsres);
 305         return E_FAIL;
 306     }
 307
 308     *ret = nswindow_to_window(nsWindow);
 309
 310     nsIDOMWindow_Release(nsWindow);
 311
 312     return S_OK;
 313 }
 314
 315 static HRESULT WINAPI HTMLWindow2_item(IHTMLWindow2 *iface, VARIANT *pvarIndex, VARIANT *pvarResult)
 316 {
 317     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 318     nsIDOMWindowCollection *nsFrames;
 319     HTMLWindow *window = NULL;
 320     HRESULT hres = S_OK;
 321     nsresult nsres;
 322
 323     TRACE("(%p)->(%p %p)\n", This, pvarIndex, pvarResult);
 324
 325     nsres = nsIDOMWindow_GetFrames(This->nswindow, &nsFrames);
 326     if(NS_FAILED(nsres)) {
 327         FIXME("nsIDOMWindow_GetFrames failed: 0x%08x\n", nsres);
 328         return E_FAIL;
 329     }
 330
 331     switch(V_VT(pvarIndex)) {
 332     case VT_I4: {
 333         int index = V_I4(pvarIndex);
 334         TRACE("Getting index %d\n", index);
 335         if(index < 0)
 336             break;
 337         hres = get_frame_by_index(nsFrames, index, &window);
 338         break;
 339     }
 340     case VT_UINT: {
 341         unsigned int index = V_UINT(pvarIndex);
 342         TRACE("Getting index %u\n", index);
 343         hres = get_frame_by_index(nsFrames, index, &window);
 344         break;
 345     }
 346     case VT_BSTR: {
 347         BSTR str = V_BSTR(pvarIndex);
 348         PRUint32 length, i;
 349
 350         TRACE("Getting name %s\n", wine_dbgstr_w(str));
 351
 352         nsIDOMWindowCollection_GetLength(nsFrames, &length);
 353
 354         window = NULL;
 355         for(i = 0; i < length && !window; ++i) {
 356             HTMLWindow *cur_window;
 357             nsIDOMWindow *nsWindow;
 358             BSTR id;
 359
 360             nsres = nsIDOMWindowCollection_Item(nsFrames, i, &nsWindow);
 361             if(NS_FAILED(nsres)) {
 362                 FIXME("nsIDOMWindowCollection_Item failed: 0x%08x\n", nsres);
 363                 hres = E_FAIL;
 364                 break;
 365             }
 366
 367             cur_window = nswindow_to_window(nsWindow);
 368
 369             nsIDOMWindow_Release(nsWindow);
 370
 371             hres = IHTMLElement_get_id(&cur_window->frame_element->element.IHTMLElement_iface, &id);
 372             if(FAILED(hres)) {
 373                 FIXME("IHTMLElement_get_id failed: 0x%08x\n", hres);
 374                 break;
 375             }
 376
 377             if(!strcmpW(id, str))
 378                 window = cur_window;
 379
 380             SysFreeString(id);
 381         }
 382         break;
 383     }
 384     default:
 385         hres = E_INVALIDARG;
 386     }
 387
 388     nsIDOMWindowCollection_Release(nsFrames);
 389     if(FAILED(hres))
 390         return hres;
 391     if(!window)
 392         return DISP_E_MEMBERNOTFOUND;
 393
 394     IHTMLWindow2_AddRef(&window->IHTMLWindow2_iface);
 395     V_VT(pvarResult) = VT_DISPATCH;
 396     V_DISPATCH(pvarResult) = (IDispatch*)window;
 397     return S_OK;
 398 }
 399
 400 static HRESULT WINAPI HTMLWindow2_get_length(IHTMLWindow2 *iface, LONG *p)
 401 {
 402     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 403     nsIDOMWindowCollection *nscollection;
 404     PRUint32 length;
 405     nsresult nsres;
 406
 407     TRACE("(%p)->(%p)\n", This, p);
 408
 409     nsres = nsIDOMWindow_GetFrames(This->nswindow, &nscollection);
 410     if(NS_FAILED(nsres)) {
 411         ERR("GetFrames failed: %08x\n", nsres);
 412         return E_FAIL;
 413     }
 414
 415     nsres = nsIDOMWindowCollection_GetLength(nscollection, &length);
 416     nsIDOMWindowCollection_Release(nscollection);
 417     if(NS_FAILED(nsres)) {
 418         ERR("GetLength failed: %08x\n", nsres);
 419         return E_FAIL;
 420     }
 421
 422     *p = length;
 423     return S_OK;
 424 }
 425
 426 static HRESULT WINAPI HTMLWindow2_get_frames(IHTMLWindow2 *iface, IHTMLFramesCollection2 **p)
 427 {
 428     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 429     FIXME("(%p)->(%p): semi-stub\n", This, p);
 430
 431     /* FIXME: Should return a separate Window object */
 432     *p = (IHTMLFramesCollection2*)&This->IHTMLWindow2_iface;
 433     HTMLWindow2_AddRef(iface);
 434     return S_OK;
 435 }
 436
 437 static HRESULT WINAPI HTMLWindow2_put_defaultStatus(IHTMLWindow2 *iface, BSTR v)
 438 {
 439     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 440     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 441     return E_NOTIMPL;
 442 }
 443
 444 static HRESULT WINAPI HTMLWindow2_get_defaultStatus(IHTMLWindow2 *iface, BSTR *p)
 445 {
 446     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 447     FIXME("(%p)->(%p)\n", This, p);
 448     return E_NOTIMPL;
 449 }
 450
 451 static HRESULT WINAPI HTMLWindow2_put_status(IHTMLWindow2 *iface, BSTR v)
 452 {
 453     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 454
 455     WARN("(%p)->(%s)\n", This, debugstr_w(v));
 456
 457     /*
 458      * FIXME: Since IE7, setting status is blocked, but still possible in certain circumstances.
 459      * Ignoring the call should be enough for us.
 460      */
 461     return S_OK;
 462 }
 463
 464 static HRESULT WINAPI HTMLWindow2_get_status(IHTMLWindow2 *iface, BSTR *p)
 465 {
 466     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 467
 468     TRACE("(%p)->(%p)\n", This, p);
 469
 470     /* See put_status */
 471     *p = NULL;
 472     return S_OK;
 473 }
 474
 475 static HRESULT WINAPI HTMLWindow2_setTimeout(IHTMLWindow2 *iface, BSTR expression,
 476         LONG msec, VARIANT *language, LONG *timerID)
 477 {
 478     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 479     VARIANT expr_var;
 480
 481     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_w(expression), msec, language, timerID);
 482
 483     V_VT(&expr_var) = VT_BSTR;
 484     V_BSTR(&expr_var) = expression;
 485
 486     return IHTMLWindow3_setTimeout(&This->IHTMLWindow3_iface, &expr_var, msec, language, timerID);
 487 }
 488
 489 static HRESULT WINAPI HTMLWindow2_clearTimeout(IHTMLWindow2 *iface, LONG timerID)
 490 {
 491     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 492
 493     TRACE("(%p)->(%d)\n", This, timerID);
 494
 495     return clear_task_timer(&This->doc->basedoc, FALSE, timerID);
 496 }
 497
 498 #define MAX_MESSAGE_LEN 2000
 499
 500 static HRESULT WINAPI HTMLWindow2_alert(IHTMLWindow2 *iface, BSTR message)
 501 {
 502     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 503     WCHAR title[100], *msg = message;
 504     DWORD len;
 505
 506     TRACE("(%p)->(%s)\n", This, debugstr_w(message));
 507
 508     if(!LoadStringW(get_shdoclc(), IDS_MESSAGE_BOX_TITLE, title,
 509                     sizeof(title)/sizeof(WCHAR))) {
 510         WARN("Could not load message box title: %d\n", GetLastError());
 511         return S_OK;
 512     }
 513
 514     len = SysStringLen(message);
 515     if(len > MAX_MESSAGE_LEN) {
 516         msg = heap_alloc((MAX_MESSAGE_LEN+1)*sizeof(WCHAR));
 517         if(!msg)
 518             return E_OUTOFMEMORY;
 519         memcpy(msg, message, MAX_MESSAGE_LEN*sizeof(WCHAR));
 520         msg[MAX_MESSAGE_LEN] = 0;
 521     }
 522
 523     MessageBoxW(This->doc_obj->hwnd, msg, title, MB_ICONWARNING);
 524     if(msg != message)
 525         heap_free(msg);
 526     return S_OK;
 527 }
 528
 529 static HRESULT WINAPI HTMLWindow2_confirm(IHTMLWindow2 *iface, BSTR message,
 530         VARIANT_BOOL *confirmed)
 531 {
 532     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 533     WCHAR wszTitle[100];
 534
 535     TRACE("(%p)->(%s %p)\n", This, debugstr_w(message), confirmed);
 536
 537     if(!confirmed) return E_INVALIDARG;
 538
 539     if(!LoadStringW(get_shdoclc(), IDS_MESSAGE_BOX_TITLE, wszTitle,
 540                 sizeof(wszTitle)/sizeof(WCHAR))) {
 541         WARN("Could not load message box title: %d\n", GetLastError());
 542         *confirmed = VARIANT_TRUE;
 543         return S_OK;
 544     }
 545
 546     if(MessageBoxW(This->doc_obj->hwnd, message, wszTitle,
 547                 MB_OKCANCEL|MB_ICONQUESTION)==IDOK)
 548         *confirmed = VARIANT_TRUE;
 549     else *confirmed = VARIANT_FALSE;
 550
 551     return S_OK;
 552 }
 553
 554 typedef struct
 555 {
 556     BSTR message;
 557     BSTR dststr;
 558     VARIANT *textdata;
 559 }prompt_arg;
 560
 561 static INT_PTR CALLBACK prompt_dlgproc(HWND hwnd, UINT msg,
 562         WPARAM wparam, LPARAM lparam)
 563 {
 564     switch(msg)
 565     {
 566         case WM_INITDIALOG:
 567         {
 568             prompt_arg *arg = (prompt_arg*)lparam;
 569             WCHAR wszTitle[100];
 570
 571             if(!LoadStringW(get_shdoclc(), IDS_MESSAGE_BOX_TITLE, wszTitle,
 572                         sizeof(wszTitle)/sizeof(WCHAR))) {
 573                 WARN("Could not load message box title: %d\n", GetLastError());
 574                 EndDialog(hwnd, wparam);
 575                 return FALSE;
 576             }
 577
 578             SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
 579             SetWindowTextW(hwnd, wszTitle);
 580             SetWindowTextW(GetDlgItem(hwnd, ID_PROMPT_PROMPT), arg->message);
 581             SetWindowTextW(GetDlgItem(hwnd, ID_PROMPT_EDIT), arg->dststr);
 582             return FALSE;
 583         }
 584         case WM_COMMAND:
 585             switch(wparam)
 586             {
 587                 case MAKEWPARAM(IDCANCEL, BN_CLICKED):
 588                     EndDialog(hwnd, wparam);
 589                     return TRUE;
 590                 case MAKEWPARAM(IDOK, BN_CLICKED):
 591                 {
 592                     prompt_arg *arg =
 593                         (prompt_arg*)GetWindowLongPtrW(hwnd, DWLP_USER);
 594                     HWND hwndPrompt = GetDlgItem(hwnd, ID_PROMPT_EDIT);
 595                     INT len = GetWindowTextLengthW(hwndPrompt);
 596
 597                     if(!arg->textdata)
 598                     {
 599                         EndDialog(hwnd, wparam);
 600                         return TRUE;
 601                     }
 602
 603                     V_VT(arg->textdata) = VT_BSTR;
 604                     if(!len && !arg->dststr)
 605                         V_BSTR(arg->textdata) = NULL;
 606                     else
 607                     {
 608                         V_BSTR(arg->textdata) = SysAllocStringLen(NULL, len);
 609                         GetWindowTextW(hwndPrompt, V_BSTR(arg->textdata), len+1);
 610                     }
 611                     EndDialog(hwnd, wparam);
 612                     return TRUE;
 613                 }
 614             }
 615             return FALSE;
 616         case WM_CLOSE:
 617             EndDialog(hwnd, IDCANCEL);
 618             return TRUE;
 619         default:
 620             return FALSE;
 621     }
 622 }
 623
 624 static HRESULT WINAPI HTMLWindow2_prompt(IHTMLWindow2 *iface, BSTR message,
 625         BSTR dststr, VARIANT *textdata)
 626 {
 627     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 628     prompt_arg arg;
 629
 630     TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(message), debugstr_w(dststr), textdata);
 631
 632     if(textdata) V_VT(textdata) = VT_NULL;
 633
 634     arg.message = message;
 635     arg.dststr = dststr;
 636     arg.textdata = textdata;
 637
 638     DialogBoxParamW(hInst, MAKEINTRESOURCEW(ID_PROMPT_DIALOG),
 639             This->doc_obj->hwnd, prompt_dlgproc, (LPARAM)&arg);
 640     return S_OK;
 641 }
 642
 643 static HRESULT WINAPI HTMLWindow2_get_Image(IHTMLWindow2 *iface, IHTMLImageElementFactory **p)
 644 {
 645     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 646
 647     TRACE("(%p)->(%p)\n", This, p);
 648
 649     if(!This->image_factory)
 650         This->image_factory = HTMLImageElementFactory_Create(This);
 651
 652     *p = &This->image_factory->IHTMLImageElementFactory_iface;
 653     IHTMLImageElementFactory_AddRef(*p);
 654
 655     return S_OK;
 656 }
 657
 658 static HRESULT WINAPI HTMLWindow2_get_location(IHTMLWindow2 *iface, IHTMLLocation **p)
 659 {
 660     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 661     HTMLLocation *location;
 662     HRESULT hres;
 663
 664     TRACE("(%p)->(%p)\n", This, p);
 665
 666     hres = get_location(This, &location);
 667     if(FAILED(hres))
 668         return hres;
 669
 670     *p = &location->IHTMLLocation_iface;
 671     return S_OK;
 672 }
 673
 674 static HRESULT WINAPI HTMLWindow2_get_history(IHTMLWindow2 *iface, IOmHistory **p)
 675 {
 676     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 677     FIXME("(%p)->(%p)\n", This, p);
 678     return E_NOTIMPL;
 679 }
 680
 681 static HRESULT WINAPI HTMLWindow2_close(IHTMLWindow2 *iface)
 682 {
 683     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 684     FIXME("(%p)->()\n", This);
 685     return E_NOTIMPL;
 686 }
 687
 688 static HRESULT WINAPI HTMLWindow2_put_opener(IHTMLWindow2 *iface, VARIANT v)
 689 {
 690     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 691     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI HTMLWindow2_get_opener(IHTMLWindow2 *iface, VARIANT *p)
 696 {
 697     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 698     FIXME("(%p)->(%p)\n", This, p);
 699     return E_NOTIMPL;
 700 }
 701
 702 static HRESULT WINAPI HTMLWindow2_get_navigator(IHTMLWindow2 *iface, IOmNavigator **p)
 703 {
 704     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 705
 706     TRACE("(%p)->(%p)\n", This, p);
 707
 708     *p = OmNavigator_Create();
 709     return S_OK;
 710 }
 711
 712 static HRESULT WINAPI HTMLWindow2_put_name(IHTMLWindow2 *iface, BSTR v)
 713 {
 714     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 715     nsAString name_str;
 716     nsresult nsres;
 717
 718     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 719
 720     nsAString_InitDepend(&name_str, v);
 721     nsres = nsIDOMWindow_SetName(This->nswindow, &name_str);
 722     nsAString_Finish(&name_str);
 723     if(NS_FAILED(nsres))
 724         ERR("SetName failed: %08x\n", nsres);
 725
 726     return S_OK;
 727 }
 728
 729 static HRESULT WINAPI HTMLWindow2_get_name(IHTMLWindow2 *iface, BSTR *p)
 730 {
 731     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 732     nsAString name_str;
 733     nsresult nsres;
 734     HRESULT hres;
 735
 736     TRACE("(%p)->(%p)\n", This, p);
 737
 738     nsAString_Init(&name_str, NULL);
 739     nsres = nsIDOMWindow_GetName(This->nswindow, &name_str);
 740     if(NS_SUCCEEDED(nsres)) {
 741         const PRUnichar *name;
 742
 743         nsAString_GetData(&name_str, &name);
 744         if(*name) {
 745             *p = SysAllocString(name);
 746             hres = *p ? S_OK : E_OUTOFMEMORY;
 747         }else {
 748             *p = NULL;
 749             hres = S_OK;
 750         }
 751     }else {
 752         ERR("GetName failed: %08x\n", nsres);
 753         hres = E_FAIL;
 754     }
 755     nsAString_Finish(&name_str);
 756
 757     return hres;
 758 }
 759
 760 static HRESULT WINAPI HTMLWindow2_get_parent(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 761 {
 762     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 763     TRACE("(%p)->(%p)\n", This, p);
 764
 765     if(This->parent) {
 766         *p = &This->parent->IHTMLWindow2_iface;
 767         IHTMLWindow2_AddRef(*p);
 768     }else
 769         *p = NULL;
 770
 771     return S_OK;
 772 }
 773
 774 static HRESULT WINAPI HTMLWindow2_open(IHTMLWindow2 *iface, BSTR url, BSTR name,
 775          BSTR features, VARIANT_BOOL replace, IHTMLWindow2 **pomWindowResult)
 776 {
 777     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 778     FIXME("(%p)->(%s %s %s %x %p)\n", This, debugstr_w(url), debugstr_w(name),
 779           debugstr_w(features), replace, pomWindowResult);
 780     return E_NOTIMPL;
 781 }
 782
 783 static HRESULT WINAPI HTMLWindow2_get_self(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 784 {
 785     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 786
 787     TRACE("(%p)->(%p)\n", This, p);
 788
 789     /* FIXME: We should return kind of proxy window here. */
 790     IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
 791     *p = &This->IHTMLWindow2_iface;
 792     return S_OK;
 793 }
 794
 795 static HRESULT WINAPI HTMLWindow2_get_top(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 796 {
 797     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 798     HTMLWindow *curr;
 799     TRACE("(%p)->(%p)\n", This, p);
 800
 801     curr = This;
 802     while(curr->parent)
 803         curr = curr->parent;
 804     *p = &curr->IHTMLWindow2_iface;
 805     IHTMLWindow2_AddRef(*p);
 806
 807     return S_OK;
 808 }
 809
 810 static HRESULT WINAPI HTMLWindow2_get_window(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 811 {
 812     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 813
 814     TRACE("(%p)->(%p)\n", This, p);
 815
 816     /* FIXME: We should return kind of proxy window here. */
 817     IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
 818     *p = &This->IHTMLWindow2_iface;
 819     return S_OK;
 820 }
 821
 822 static HRESULT WINAPI HTMLWindow2_navigate(IHTMLWindow2 *iface, BSTR url)
 823 {
 824     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 825     FIXME("(%p)->(%s)\n", This, debugstr_w(url));
 826     return E_NOTIMPL;
 827 }
 828
 829 static HRESULT WINAPI HTMLWindow2_put_onfocus(IHTMLWindow2 *iface, VARIANT v)
 830 {
 831     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 832     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
 833     return E_NOTIMPL;
 834 }
 835
 836 static HRESULT WINAPI HTMLWindow2_get_onfocus(IHTMLWindow2 *iface, VARIANT *p)
 837 {
 838     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 839     FIXME("(%p)->(%p)\n", This, p);
 840     return E_NOTIMPL;
 841 }
 842
 843 static HRESULT WINAPI HTMLWindow2_put_onblur(IHTMLWindow2 *iface, VARIANT v)
 844 {
 845     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 846     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
 847     return E_NOTIMPL;
 848 }
 849
 850 static HRESULT WINAPI HTMLWindow2_get_onblur(IHTMLWindow2 *iface, VARIANT *p)
 851 {
 852     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 853     FIXME("(%p)->(%p)\n", This, p);
 854     return E_NOTIMPL;
 855 }
 856
 857 static HRESULT WINAPI HTMLWindow2_put_onload(IHTMLWindow2 *iface, VARIANT v)
 858 {
 859     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 860
 861     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 862
 863     return set_window_event(This, EVENTID_LOAD, &v);
 864 }
 865
 866 static HRESULT WINAPI HTMLWindow2_get_onload(IHTMLWindow2 *iface, VARIANT *p)
 867 {
 868     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 869
 870     TRACE("(%p)->(%p)\n", This, p);
 871
 872     return get_window_event(This, EVENTID_LOAD, p);
 873 }
 874
 875 static HRESULT WINAPI HTMLWindow2_put_onbeforeunload(IHTMLWindow2 *iface, VARIANT v)
 876 {
 877     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 878
 879     TRACE("(%p)->(v(%d))\n", This, V_VT(&v));
 880
 881     return set_window_event(This, EVENTID_BEFOREUNLOAD, &v);
 882 }
 883
 884 static HRESULT WINAPI HTMLWindow2_get_onbeforeunload(IHTMLWindow2 *iface, VARIANT *p)
 885 {
 886     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 887
 888     TRACE("(%p)->(%p)\n", This, p);
 889
 890     return get_window_event(This, EVENTID_BEFOREUNLOAD, p);
 891 }
 892
 893 static HRESULT WINAPI HTMLWindow2_put_onunload(IHTMLWindow2 *iface, VARIANT v)
 894 {
 895     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 896     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
 897     return E_NOTIMPL;
 898 }
 899
 900 static HRESULT WINAPI HTMLWindow2_get_onunload(IHTMLWindow2 *iface, VARIANT *p)
 901 {
 902     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 903     FIXME("(%p)->(%p)\n", This, p);
 904     return E_NOTIMPL;
 905 }
 906
 907 static HRESULT WINAPI HTMLWindow2_put_onhelp(IHTMLWindow2 *iface, VARIANT v)
 908 {
 909     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 910     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
 911     return E_NOTIMPL;
 912 }
 913
 914 static HRESULT WINAPI HTMLWindow2_get_onhelp(IHTMLWindow2 *iface, VARIANT *p)
 915 {
 916     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 917     FIXME("(%p)->(%p)\n", This, p);
 918     return E_NOTIMPL;
 919 }
 920
 921 static HRESULT WINAPI HTMLWindow2_put_onerror(IHTMLWindow2 *iface, VARIANT v)
 922 {
 923     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 924     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
 925     return E_NOTIMPL;
 926 }
 927
 928 static HRESULT WINAPI HTMLWindow2_get_onerror(IHTMLWindow2 *iface, VARIANT *p)
 929 {
 930     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 931     FIXME("(%p)->(%p)\n", This, p);
 932     return E_NOTIMPL;
 933 }
 934
 935 static HRESULT WINAPI HTMLWindow2_put_onresize(IHTMLWindow2 *iface, VARIANT v)
 936 {
 937     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 938
 939     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 940
 941     return set_window_event(This, EVENTID_RESIZE, &v);
 942 }
 943
 944 static HRESULT WINAPI HTMLWindow2_get_onresize(IHTMLWindow2 *iface, VARIANT *p)
 945 {
 946     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 947
 948     TRACE("(%p)->(%p)\n", This, p);
 949
 950     return get_window_event(This, EVENTID_RESIZE, p);
 951 }
 952
 953 static HRESULT WINAPI HTMLWindow2_put_onscroll(IHTMLWindow2 *iface, VARIANT v)
 954 {
 955     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 956     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
 957     return E_NOTIMPL;
 958 }
 959
 960 static HRESULT WINAPI HTMLWindow2_get_onscroll(IHTMLWindow2 *iface, VARIANT *p)
 961 {
 962     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 963     FIXME("(%p)->(%p)\n", This, p);
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI HTMLWindow2_get_document(IHTMLWindow2 *iface, IHTMLDocument2 **p)
 968 {
 969     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 970
 971     TRACE("(%p)->(%p)\n", This, p);
 972
 973     if(This->doc) {
 974         /* FIXME: We should return a wrapper object here */
 975         *p = &This->doc->basedoc.IHTMLDocument2_iface;
 976         IHTMLDocument2_AddRef(*p);
 977     }else {
 978         *p = NULL;
 979     }
 980
 981     return S_OK;
 982 }
 983
 984 static HRESULT WINAPI HTMLWindow2_get_event(IHTMLWindow2 *iface, IHTMLEventObj **p)
 985 {
 986     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 987
 988     TRACE("(%p)->(%p)\n", This, p);
 989
 990     if(This->event)
 991         IHTMLEventObj_AddRef(This->event);
 992     *p = This->event;
 993     return S_OK;
 994 }
 995
 996 static HRESULT WINAPI HTMLWindow2_get__newEnum(IHTMLWindow2 *iface, IUnknown **p)
 997 {
 998     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
 999     FIXME("(%p)->(%p)\n", This, p);
1000     return E_NOTIMPL;
1001 }
1002
1003 static HRESULT WINAPI HTMLWindow2_showModalDialog(IHTMLWindow2 *iface, BSTR dialog,
1004         VARIANT *varArgIn, VARIANT *varOptions, VARIANT *varArgOut)
1005 {
1006     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1007     FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_w(dialog), varArgIn, varOptions, varArgOut);
1008     return E_NOTIMPL;
1009 }
1010
1011 static HRESULT WINAPI HTMLWindow2_showHelp(IHTMLWindow2 *iface, BSTR helpURL, VARIANT helpArg,
1012         BSTR features)
1013 {
1014     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1015     FIXME("(%p)->(%s v(%d) %s)\n", This, debugstr_w(helpURL), V_VT(&helpArg), debugstr_w(features));
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI HTMLWindow2_get_screen(IHTMLWindow2 *iface, IHTMLScreen **p)
1020 {
1021     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1022
1023     TRACE("(%p)->(%p)\n", This, p);
1024
1025     if(!This->screen) {
1026         HRESULT hres;
1027
1028         hres = HTMLScreen_Create(&This->screen);
1029         if(FAILED(hres))
1030             return hres;
1031     }
1032
1033     *p = This->screen;
1034     IHTMLScreen_AddRef(This->screen);
1035     return S_OK;
1036 }
1037
1038 static HRESULT WINAPI HTMLWindow2_get_Option(IHTMLWindow2 *iface, IHTMLOptionElementFactory **p)
1039 {
1040     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1041
1042     TRACE("(%p)->(%p)\n", This, p);
1043
1044     if(!This->option_factory)
1045         This->option_factory = HTMLOptionElementFactory_Create(This);
1046
1047     *p = &This->option_factory->IHTMLOptionElementFactory_iface;
1048     IHTMLOptionElementFactory_AddRef(*p);
1049
1050     return S_OK;
1051 }
1052
1053 static HRESULT WINAPI HTMLWindow2_focus(IHTMLWindow2 *iface)
1054 {
1055     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1056
1057     TRACE("(%p)->()\n", This);
1058
1059     if(This->doc_obj)
1060         SetFocus(This->doc_obj->hwnd);
1061     return S_OK;
1062 }
1063
1064 static HRESULT WINAPI HTMLWindow2_get_closed(IHTMLWindow2 *iface, VARIANT_BOOL *p)
1065 {
1066     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1067     FIXME("(%p)->(%p)\n", This, p);
1068     return E_NOTIMPL;
1069 }
1070
1071 static HRESULT WINAPI HTMLWindow2_blur(IHTMLWindow2 *iface)
1072 {
1073     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1074     FIXME("(%p)->()\n", This);
1075     return E_NOTIMPL;
1076 }
1077
1078 static HRESULT WINAPI HTMLWindow2_scroll(IHTMLWindow2 *iface, LONG x, LONG y)
1079 {
1080     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1081     FIXME("(%p)->(%d %d)\n", This, x, y);
1082     return E_NOTIMPL;
1083 }
1084
1085 static HRESULT WINAPI HTMLWindow2_get_clientInformation(IHTMLWindow2 *iface, IOmNavigator **p)
1086 {
1087     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1088     FIXME("(%p)->(%p)\n", This, p);
1089     return E_NOTIMPL;
1090 }
1091
1092 static HRESULT WINAPI HTMLWindow2_setInterval(IHTMLWindow2 *iface, BSTR expression,
1093         LONG msec, VARIANT *language, LONG *timerID)
1094 {
1095     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1096     VARIANT expr;
1097
1098     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_w(expression), msec, language, timerID);
1099
1100     V_VT(&expr) = VT_BSTR;
1101     V_BSTR(&expr) = expression;
1102     return IHTMLWindow3_setInterval(&This->IHTMLWindow3_iface, &expr, msec, language, timerID);
1103 }
1104
1105 static HRESULT WINAPI HTMLWindow2_clearInterval(IHTMLWindow2 *iface, LONG timerID)
1106 {
1107     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1108
1109     TRACE("(%p)->(%d)\n", This, timerID);
1110
1111     return clear_task_timer(&This->doc->basedoc, TRUE, timerID);
1112 }
1113
1114 static HRESULT WINAPI HTMLWindow2_put_offscreenBuffering(IHTMLWindow2 *iface, VARIANT v)
1115 {
1116     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1117     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
1118     return E_NOTIMPL;
1119 }
1120
1121 static HRESULT WINAPI HTMLWindow2_get_offscreenBuffering(IHTMLWindow2 *iface, VARIANT *p)
1122 {
1123     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1124     FIXME("(%p)->(%p)\n", This, p);
1125     return E_NOTIMPL;
1126 }
1127
1128 static HRESULT WINAPI HTMLWindow2_execScript(IHTMLWindow2 *iface, BSTR scode, BSTR language,
1129         VARIANT *pvarRet)
1130 {
1131     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1132
1133     TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(scode), debugstr_w(language), pvarRet);
1134
1135     return exec_script(This, scode, language, pvarRet);
1136 }
1137
1138 static HRESULT WINAPI HTMLWindow2_toString(IHTMLWindow2 *iface, BSTR *String)
1139 {
1140     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1141
1142     static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
1143
1144     TRACE("(%p)->(%p)\n", This, String);
1145
1146     if(!String)
1147         return E_INVALIDARG;
1148
1149     *String = SysAllocString(objectW);
1150     return *String ? S_OK : E_OUTOFMEMORY;
1151 }
1152
1153 static HRESULT WINAPI HTMLWindow2_scrollBy(IHTMLWindow2 *iface, LONG x, LONG y)
1154 {
1155     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1156     nsresult nsres;
1157
1158     TRACE("(%p)->(%d %d)\n", This, x, y);
1159
1160     nsres = nsIDOMWindow_ScrollBy(This->nswindow, x, y);
1161     if(NS_FAILED(nsres))
1162         ERR("ScrollBy failed: %08x\n", nsres);
1163
1164     return S_OK;
1165 }
1166
1167 static HRESULT WINAPI HTMLWindow2_scrollTo(IHTMLWindow2 *iface, LONG x, LONG y)
1168 {
1169     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1170     nsresult nsres;
1171
1172     TRACE("(%p)->(%d %d)\n", This, x, y);
1173
1174     nsres = nsIDOMWindow_ScrollTo(This->nswindow, x, y);
1175     if(NS_FAILED(nsres))
1176         ERR("ScrollTo failed: %08x\n", nsres);
1177
1178     return S_OK;
1179 }
1180
1181 static HRESULT WINAPI HTMLWindow2_moveTo(IHTMLWindow2 *iface, LONG x, LONG y)
1182 {
1183     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1184     FIXME("(%p)->(%d %d)\n", This, x, y);
1185     return E_NOTIMPL;
1186 }
1187
1188 static HRESULT WINAPI HTMLWindow2_moveBy(IHTMLWindow2 *iface, LONG x, LONG y)
1189 {
1190     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1191     FIXME("(%p)->(%d %d)\n", This, x, y);
1192     return E_NOTIMPL;
1193 }
1194
1195 static HRESULT WINAPI HTMLWindow2_resizeTo(IHTMLWindow2 *iface, LONG x, LONG y)
1196 {
1197     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1198     FIXME("(%p)->(%d %d)\n", This, x, y);
1199     return E_NOTIMPL;
1200 }
1201
1202 static HRESULT WINAPI HTMLWindow2_resizeBy(IHTMLWindow2 *iface, LONG x, LONG y)
1203 {
1204     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1205     FIXME("(%p)->(%d %d)\n", This, x, y);
1206     return E_NOTIMPL;
1207 }
1208
1209 static HRESULT WINAPI HTMLWindow2_get_external(IHTMLWindow2 *iface, IDispatch **p)
1210 {
1211     HTMLWindow *This = impl_from_IHTMLWindow2(iface);
1212
1213     TRACE("(%p)->(%p)\n", This, p);
1214
1215     *p = NULL;
1216
1217     if(!This->doc_obj->hostui)
1218         return S_OK;
1219
1220     return IDocHostUIHandler_GetExternal(This->doc_obj->hostui, p);
1221 }
1222
1223 static const IHTMLWindow2Vtbl HTMLWindow2Vtbl = {
1224     HTMLWindow2_QueryInterface,
1225     HTMLWindow2_AddRef,
1226     HTMLWindow2_Release,
1227     HTMLWindow2_GetTypeInfoCount,
1228     HTMLWindow2_GetTypeInfo,
1229     HTMLWindow2_GetIDsOfNames,
1230     HTMLWindow2_Invoke,
1231     HTMLWindow2_item,
1232     HTMLWindow2_get_length,
1233     HTMLWindow2_get_frames,
1234     HTMLWindow2_put_defaultStatus,
1235     HTMLWindow2_get_defaultStatus,
1236     HTMLWindow2_put_status,
1237     HTMLWindow2_get_status,
1238     HTMLWindow2_setTimeout,
1239     HTMLWindow2_clearTimeout,
1240     HTMLWindow2_alert,
1241     HTMLWindow2_confirm,
1242     HTMLWindow2_prompt,
1243     HTMLWindow2_get_Image,
1244     HTMLWindow2_get_location,
1245     HTMLWindow2_get_history,
1246     HTMLWindow2_close,
1247     HTMLWindow2_put_opener,
1248     HTMLWindow2_get_opener,
1249     HTMLWindow2_get_navigator,
1250     HTMLWindow2_put_name,
1251     HTMLWindow2_get_name,
1252     HTMLWindow2_get_parent,
1253     HTMLWindow2_open,
1254     HTMLWindow2_get_self,
1255     HTMLWindow2_get_top,
1256     HTMLWindow2_get_window,
1257     HTMLWindow2_navigate,
1258     HTMLWindow2_put_onfocus,
1259     HTMLWindow2_get_onfocus,
1260     HTMLWindow2_put_onblur,
1261     HTMLWindow2_get_onblur,
1262     HTMLWindow2_put_onload,
1263     HTMLWindow2_get_onload,
1264     HTMLWindow2_put_onbeforeunload,
1265     HTMLWindow2_get_onbeforeunload,
1266     HTMLWindow2_put_onunload,
1267     HTMLWindow2_get_onunload,
1268     HTMLWindow2_put_onhelp,
1269     HTMLWindow2_get_onhelp,
1270     HTMLWindow2_put_onerror,
1271     HTMLWindow2_get_onerror,
1272     HTMLWindow2_put_onresize,
1273     HTMLWindow2_get_onresize,
1274     HTMLWindow2_put_onscroll,
1275     HTMLWindow2_get_onscroll,
1276     HTMLWindow2_get_document,
1277     HTMLWindow2_get_event,
1278     HTMLWindow2_get__newEnum,
1279     HTMLWindow2_showModalDialog,
1280     HTMLWindow2_showHelp,
1281     HTMLWindow2_get_screen,
1282     HTMLWindow2_get_Option,
1283     HTMLWindow2_focus,
1284     HTMLWindow2_get_closed,
1285     HTMLWindow2_blur,
1286     HTMLWindow2_scroll,
1287     HTMLWindow2_get_clientInformation,
1288     HTMLWindow2_setInterval,
1289     HTMLWindow2_clearInterval,
1290     HTMLWindow2_put_offscreenBuffering,
1291     HTMLWindow2_get_offscreenBuffering,
1292     HTMLWindow2_execScript,
1293     HTMLWindow2_toString,
1294     HTMLWindow2_scrollBy,
1295     HTMLWindow2_scrollTo,
1296     HTMLWindow2_moveTo,
1297     HTMLWindow2_moveBy,
1298     HTMLWindow2_resizeTo,
1299     HTMLWindow2_resizeBy,
1300     HTMLWindow2_get_external
1301 };
1302
1303 static inline HTMLWindow *impl_from_IHTMLWindow3(IHTMLWindow3 *iface)
1304 {
1305     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow3_iface);
1306 }
1307
1308 static HRESULT WINAPI HTMLWindow3_QueryInterface(IHTMLWindow3 *iface, REFIID riid, void **ppv)
1309 {
1310     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1311
1312     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1313 }
1314
1315 static ULONG WINAPI HTMLWindow3_AddRef(IHTMLWindow3 *iface)
1316 {
1317     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1318
1319     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1320 }
1321
1322 static ULONG WINAPI HTMLWindow3_Release(IHTMLWindow3 *iface)
1323 {
1324     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1325
1326     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1327 }
1328
1329 static HRESULT WINAPI HTMLWindow3_GetTypeInfoCount(IHTMLWindow3 *iface, UINT *pctinfo)
1330 {
1331     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1332
1333     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1334 }
1335
1336 static HRESULT WINAPI HTMLWindow3_GetTypeInfo(IHTMLWindow3 *iface, UINT iTInfo,
1337                                               LCID lcid, ITypeInfo **ppTInfo)
1338 {
1339     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1340
1341     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1342 }
1343
1344 static HRESULT WINAPI HTMLWindow3_GetIDsOfNames(IHTMLWindow3 *iface, REFIID riid,
1345                                                 LPOLESTR *rgszNames, UINT cNames,
1346                                                 LCID lcid, DISPID *rgDispId)
1347 {
1348     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1349
1350     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1351             rgDispId);
1352 }
1353
1354 static HRESULT WINAPI HTMLWindow3_Invoke(IHTMLWindow3 *iface, DISPID dispIdMember,
1355                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1356                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1357 {
1358     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1359
1360     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1361             pDispParams, pVarResult, pExcepInfo, puArgErr);
1362 }
1363
1364 static HRESULT WINAPI HTMLWindow3_get_screenLeft(IHTMLWindow3 *iface, LONG *p)
1365 {
1366     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1367     FIXME("(%p)->(%p)\n", This, p);
1368     return E_NOTIMPL;
1369 }
1370
1371 static HRESULT WINAPI HTMLWindow3_get_screenTop(IHTMLWindow3 *iface, LONG *p)
1372 {
1373     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1374     FIXME("(%p)->(%p)\n", This, p);
1375     return E_NOTIMPL;
1376 }
1377
1378 static HRESULT WINAPI HTMLWindow3_attachEvent(IHTMLWindow3 *iface, BSTR event, IDispatch *pDisp, VARIANT_BOOL *pfResult)
1379 {
1380     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1381
1382     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
1383
1384     if(!This->doc) {
1385         FIXME("No document\n");
1386         return E_FAIL;
1387     }
1388
1389     return attach_event(&This->doc->body_event_target, NULL, &This->doc->basedoc, event, pDisp, pfResult);
1390 }
1391
1392 static HRESULT WINAPI HTMLWindow3_detachEvent(IHTMLWindow3 *iface, BSTR event, IDispatch *pDisp)
1393 {
1394     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1395     FIXME("(%p)->()\n", This);
1396     return E_NOTIMPL;
1397 }
1398
1399 static HRESULT window_set_timer(HTMLWindow *This, VARIANT *expr, LONG msec, VARIANT *language,
1400         BOOL interval, LONG *timer_id)
1401 {
1402     IDispatch *disp = NULL;
1403
1404     switch(V_VT(expr)) {
1405     case VT_DISPATCH:
1406         disp = V_DISPATCH(expr);
1407         IDispatch_AddRef(disp);
1408         break;
1409
1410     case VT_BSTR:
1411         disp = script_parse_event(This, V_BSTR(expr));
1412         break;
1413
1414     default:
1415         FIXME("unimplemented vt=%d\n", V_VT(expr));
1416         return E_NOTIMPL;
1417     }
1418
1419     if(!disp)
1420         return E_FAIL;
1421
1422     *timer_id = set_task_timer(&This->doc->basedoc, msec, interval, disp);
1423     IDispatch_Release(disp);
1424
1425     return S_OK;
1426 }
1427
1428 static HRESULT WINAPI HTMLWindow3_setTimeout(IHTMLWindow3 *iface, VARIANT *expression, LONG msec,
1429         VARIANT *language, LONG *timerID)
1430 {
1431     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1432
1433     TRACE("(%p)->(%p(%d) %d %p %p)\n", This, expression, V_VT(expression), msec, language, timerID);
1434
1435     return window_set_timer(This, expression, msec, language, FALSE, timerID);
1436 }
1437
1438 static HRESULT WINAPI HTMLWindow3_setInterval(IHTMLWindow3 *iface, VARIANT *expression, LONG msec,
1439         VARIANT *language, LONG *timerID)
1440 {
1441     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1442
1443     TRACE("(%p)->(%p %d %p %p)\n", This, expression, msec, language, timerID);
1444
1445     return window_set_timer(This, expression, msec, language, TRUE, timerID);
1446 }
1447
1448 static HRESULT WINAPI HTMLWindow3_print(IHTMLWindow3 *iface)
1449 {
1450     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1451     FIXME("(%p)\n", This);
1452     return E_NOTIMPL;
1453 }
1454
1455 static HRESULT WINAPI HTMLWindow3_put_onbeforeprint(IHTMLWindow3 *iface, VARIANT v)
1456 {
1457     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1458     FIXME("(%p)->()\n", This);
1459     return E_NOTIMPL;
1460 }
1461
1462 static HRESULT WINAPI HTMLWindow3_get_onbeforeprint(IHTMLWindow3 *iface, VARIANT *p)
1463 {
1464     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1465     FIXME("(%p)->(%p)\n", This, p);
1466     return E_NOTIMPL;
1467 }
1468
1469 static HRESULT WINAPI HTMLWindow3_put_onafterprint(IHTMLWindow3 *iface, VARIANT v)
1470 {
1471     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1472     FIXME("(%p)->()\n", This);
1473     return E_NOTIMPL;
1474 }
1475
1476 static HRESULT WINAPI HTMLWindow3_get_onafterprint(IHTMLWindow3 *iface, VARIANT *p)
1477 {
1478     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1479     FIXME("(%p)->(%p)\n", This, p);
1480     return E_NOTIMPL;
1481 }
1482
1483 static HRESULT WINAPI HTMLWindow3_get_clipboardData(IHTMLWindow3 *iface, IHTMLDataTransfer **p)
1484 {
1485     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1486     FIXME("(%p)->(%p)\n", This, p);
1487     return E_NOTIMPL;
1488 }
1489
1490 static HRESULT WINAPI HTMLWindow3_showModelessDialog(IHTMLWindow3 *iface, BSTR url,
1491         VARIANT *varArgIn, VARIANT *options, IHTMLWindow2 **pDialog)
1492 {
1493     HTMLWindow *This = impl_from_IHTMLWindow3(iface);
1494     FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_w(url), varArgIn, options, pDialog);
1495     return E_NOTIMPL;
1496 }
1497
1498 static const IHTMLWindow3Vtbl HTMLWindow3Vtbl = {
1499     HTMLWindow3_QueryInterface,
1500     HTMLWindow3_AddRef,
1501     HTMLWindow3_Release,
1502     HTMLWindow3_GetTypeInfoCount,
1503     HTMLWindow3_GetTypeInfo,
1504     HTMLWindow3_GetIDsOfNames,
1505     HTMLWindow3_Invoke,
1506     HTMLWindow3_get_screenLeft,
1507     HTMLWindow3_get_screenTop,
1508     HTMLWindow3_attachEvent,
1509     HTMLWindow3_detachEvent,
1510     HTMLWindow3_setTimeout,
1511     HTMLWindow3_setInterval,
1512     HTMLWindow3_print,
1513     HTMLWindow3_put_onbeforeprint,
1514     HTMLWindow3_get_onbeforeprint,
1515     HTMLWindow3_put_onafterprint,
1516     HTMLWindow3_get_onafterprint,
1517     HTMLWindow3_get_clipboardData,
1518     HTMLWindow3_showModelessDialog
1519 };
1520
1521 static inline HTMLWindow *impl_from_IHTMLWindow4(IHTMLWindow4 *iface)
1522 {
1523     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow4_iface);
1524 }
1525
1526 static HRESULT WINAPI HTMLWindow4_QueryInterface(IHTMLWindow4 *iface, REFIID riid, void **ppv)
1527 {
1528     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1529
1530     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1531 }
1532
1533 static ULONG WINAPI HTMLWindow4_AddRef(IHTMLWindow4 *iface)
1534 {
1535     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1536
1537     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1538 }
1539
1540 static ULONG WINAPI HTMLWindow4_Release(IHTMLWindow4 *iface)
1541 {
1542     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1543
1544     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1545 }
1546
1547 static HRESULT WINAPI HTMLWindow4_GetTypeInfoCount(IHTMLWindow4 *iface, UINT *pctinfo)
1548 {
1549     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1550
1551     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1552 }
1553
1554 static HRESULT WINAPI HTMLWindow4_GetTypeInfo(IHTMLWindow4 *iface, UINT iTInfo,
1555                                               LCID lcid, ITypeInfo **ppTInfo)
1556 {
1557     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1558
1559     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1560 }
1561
1562 static HRESULT WINAPI HTMLWindow4_GetIDsOfNames(IHTMLWindow4 *iface, REFIID riid,
1563                                                 LPOLESTR *rgszNames, UINT cNames,
1564                                                 LCID lcid, DISPID *rgDispId)
1565 {
1566     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1567
1568     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1569             rgDispId);
1570 }
1571
1572 static HRESULT WINAPI HTMLWindow4_Invoke(IHTMLWindow4 *iface, DISPID dispIdMember,
1573                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1574                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1575 {
1576     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1577
1578     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1579             pDispParams, pVarResult, pExcepInfo, puArgErr);
1580 }
1581
1582 static HRESULT WINAPI HTMLWindow4_createPopup(IHTMLWindow4 *iface, VARIANT *varArgIn,
1583                             IDispatch **ppPopup)
1584 {
1585     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1586     FIXME("(%p)->(%p %p)\n", This, varArgIn, ppPopup);
1587     return E_NOTIMPL;
1588 }
1589
1590 static HRESULT WINAPI HTMLWindow4_get_frameElement(IHTMLWindow4 *iface, IHTMLFrameBase **p)
1591 {
1592     HTMLWindow *This = impl_from_IHTMLWindow4(iface);
1593     TRACE("(%p)->(%p)\n", This, p);
1594
1595     if(This->frame_element) {
1596         *p = &This->frame_element->IHTMLFrameBase_iface;
1597         IHTMLFrameBase_AddRef(*p);
1598     }else
1599         *p = NULL;
1600
1601     return S_OK;
1602 }
1603
1604 static const IHTMLWindow4Vtbl HTMLWindow4Vtbl = {
1605     HTMLWindow4_QueryInterface,
1606     HTMLWindow4_AddRef,
1607     HTMLWindow4_Release,
1608     HTMLWindow4_GetTypeInfoCount,
1609     HTMLWindow4_GetTypeInfo,
1610     HTMLWindow4_GetIDsOfNames,
1611     HTMLWindow4_Invoke,
1612     HTMLWindow4_createPopup,
1613     HTMLWindow4_get_frameElement
1614 };
1615
1616 static inline HTMLWindow *impl_from_IHTMLWindow6(IHTMLWindow6 *iface)
1617 {
1618     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLWindow6_iface);
1619 }
1620
1621 static HRESULT WINAPI HTMLWindow6_QueryInterface(IHTMLWindow6 *iface, REFIID riid, void **ppv)
1622 {
1623     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1624
1625     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1626 }
1627
1628 static ULONG WINAPI HTMLWindow6_AddRef(IHTMLWindow6 *iface)
1629 {
1630     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1631
1632     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1633 }
1634
1635 static ULONG WINAPI HTMLWindow6_Release(IHTMLWindow6 *iface)
1636 {
1637     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1638
1639     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1640 }
1641
1642 static HRESULT WINAPI HTMLWindow6_GetTypeInfoCount(IHTMLWindow6 *iface, UINT *pctinfo)
1643 {
1644     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1645
1646     return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1647 }
1648
1649 static HRESULT WINAPI HTMLWindow6_GetTypeInfo(IHTMLWindow6 *iface, UINT iTInfo,
1650                                               LCID lcid, ITypeInfo **ppTInfo)
1651 {
1652     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1653
1654     return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1655 }
1656
1657 static HRESULT WINAPI HTMLWindow6_GetIDsOfNames(IHTMLWindow6 *iface, REFIID riid,
1658                                                 LPOLESTR *rgszNames, UINT cNames,
1659                                                 LCID lcid, DISPID *rgDispId)
1660 {
1661     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1662
1663     return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1664             rgDispId);
1665 }
1666
1667 static HRESULT WINAPI HTMLWindow6_Invoke(IHTMLWindow6 *iface, DISPID dispIdMember,
1668                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1669                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1670 {
1671     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1672
1673     return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1674             pDispParams, pVarResult, pExcepInfo, puArgErr);
1675 }
1676
1677 static HRESULT WINAPI HTMLWindow6_put_XDomainRequest(IHTMLWindow6 *iface, VARIANT v)
1678 {
1679     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1680     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1681     return E_NOTIMPL;
1682 }
1683
1684 static HRESULT WINAPI HTMLWindow6_get_XDomainRequest(IHTMLWindow6 *iface, VARIANT *p)
1685 {
1686     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1687     FIXME("(%p)->(%p)\n", This, p);
1688     return E_NOTIMPL;
1689 }
1690
1691 static HRESULT WINAPI HTMLWindow6_get_sessionStorage(IHTMLWindow6 *iface, IHTMLStorage **p)
1692 {
1693     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1694     FIXME("(%p)->(%p)\n", This, p);
1695     return E_NOTIMPL;
1696 }
1697
1698 static HRESULT WINAPI HTMLWindow6_get_localStorage(IHTMLWindow6 *iface, IHTMLStorage **p)
1699 {
1700     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1701     FIXME("(%p)->(%p)\n", This, p);
1702     return E_NOTIMPL;
1703 }
1704
1705 static HRESULT WINAPI HTMLWindow6_put_onhashchange(IHTMLWindow6 *iface, VARIANT v)
1706 {
1707     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1708     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1709     return E_NOTIMPL;
1710 }
1711
1712 static HRESULT WINAPI HTMLWindow6_get_onhashchange(IHTMLWindow6 *iface, VARIANT *p)
1713 {
1714     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1715     FIXME("(%p)->(%p)\n", This, p);
1716     return E_NOTIMPL;
1717 }
1718
1719 static HRESULT WINAPI HTMLWindow6_get_maxConnectionsPerServer(IHTMLWindow6 *iface, LONG *p)
1720 {
1721     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1722     FIXME("(%p)->(%p)\n", This, p);
1723     return E_NOTIMPL;
1724 }
1725
1726 static HRESULT WINAPI HTMLWindow6_postMessage(IHTMLWindow6 *iface, BSTR msg, VARIANT targetOrigin)
1727 {
1728     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1729     FIXME("(%p)->(%s %s)\n", This, debugstr_w(msg), debugstr_variant(&targetOrigin));
1730     return E_NOTIMPL;
1731 }
1732
1733 static HRESULT WINAPI HTMLWindow6_toStaticHTML(IHTMLWindow6 *iface, BSTR bstrHTML, BSTR *pbstrStaticHTML)
1734 {
1735     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1736     FIXME("(%p)->(%s %p)\n", This, debugstr_w(bstrHTML), pbstrStaticHTML);
1737     return E_NOTIMPL;
1738 }
1739
1740 static HRESULT WINAPI HTMLWindow6_put_onmessage(IHTMLWindow6 *iface, VARIANT v)
1741 {
1742     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1743     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1744     return E_NOTIMPL;
1745 }
1746
1747 static HRESULT WINAPI HTMLWindow6_get_onmessage(IHTMLWindow6 *iface, VARIANT *p)
1748 {
1749     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1750     FIXME("(%p)->(%p)\n", This, p);
1751     return E_NOTIMPL;
1752 }
1753
1754 static HRESULT WINAPI HTMLWindow6_msWriteProfilerMark(IHTMLWindow6 *iface, BSTR bstrProfilerMark)
1755 {
1756     HTMLWindow *This = impl_from_IHTMLWindow6(iface);
1757     FIXME("(%p)->(%s)\n", This, debugstr_w(bstrProfilerMark));
1758     return E_NOTIMPL;
1759 }
1760
1761 static const IHTMLWindow6Vtbl HTMLWindow6Vtbl = {
1762     HTMLWindow6_QueryInterface,
1763     HTMLWindow6_AddRef,
1764     HTMLWindow6_Release,
1765     HTMLWindow6_GetTypeInfoCount,
1766     HTMLWindow6_GetTypeInfo,
1767     HTMLWindow6_GetIDsOfNames,
1768     HTMLWindow6_Invoke,
1769     HTMLWindow6_put_XDomainRequest,
1770     HTMLWindow6_get_XDomainRequest,
1771     HTMLWindow6_get_sessionStorage,
1772     HTMLWindow6_get_localStorage,
1773     HTMLWindow6_put_onhashchange,
1774     HTMLWindow6_get_onhashchange,
1775     HTMLWindow6_get_maxConnectionsPerServer,
1776     HTMLWindow6_postMessage,
1777     HTMLWindow6_toStaticHTML,
1778     HTMLWindow6_put_onmessage,
1779     HTMLWindow6_get_onmessage,
1780     HTMLWindow6_msWriteProfilerMark
1781 };
1782
1783 static inline HTMLWindow *impl_from_IHTMLPrivateWindow(IHTMLPrivateWindow *iface)
1784 {
1785     return CONTAINING_RECORD(iface, HTMLWindow, IHTMLPrivateWindow_iface);
1786 }
1787
1788 static HRESULT WINAPI HTMLPrivateWindow_QueryInterface(IHTMLPrivateWindow *iface, REFIID riid, void **ppv)
1789 {
1790     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1791
1792     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1793 }
1794
1795 static ULONG WINAPI HTMLPrivateWindow_AddRef(IHTMLPrivateWindow *iface)
1796 {
1797     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1798
1799     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1800 }
1801
1802 static ULONG WINAPI HTMLPrivateWindow_Release(IHTMLPrivateWindow *iface)
1803 {
1804     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1805
1806     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1807 }
1808
1809 static HRESULT WINAPI HTMLPrivateWindow_SuperNavigate(IHTMLPrivateWindow *iface, BSTR url, BSTR arg2, BSTR arg3,
1810         BSTR arg4, VARIANT *post_data_var, VARIANT *headers_var, ULONG flags)
1811 {
1812     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1813     OLECHAR *translated_url = NULL;
1814     DWORD post_data_size = 0;
1815     BYTE *post_data = NULL;
1816     WCHAR *headers = NULL;
1817     IUri *uri;
1818     HRESULT hres;
1819
1820     TRACE("(%p)->(%s %s %s %s %s %s %x)\n", This, debugstr_w(url), debugstr_w(arg2), debugstr_w(arg3), debugstr_w(arg4),
1821           debugstr_variant(post_data_var), debugstr_variant(headers_var), flags);
1822
1823     if(This->doc_obj->hostui) {
1824         hres = IDocHostUIHandler_TranslateUrl(This->doc_obj->hostui, 0, url, &translated_url);
1825         if(hres != S_OK)
1826             translated_url = NULL;
1827     }
1828
1829     hres = CreateUri(translated_url ? translated_url : url, 0, 0, &uri);
1830     CoTaskMemFree(translated_url);
1831     if(FAILED(hres))
1832         return hres;
1833
1834     if(post_data_var) {
1835         if(V_VT(post_data_var) == (VT_ARRAY|VT_UI1)) {
1836             SafeArrayAccessData(V_ARRAY(post_data_var), (void**)&post_data);
1837             post_data_size = V_ARRAY(post_data_var)->rgsabound[0].cElements;
1838         }
1839     }
1840
1841     if(headers_var && V_VT(headers_var) != VT_EMPTY && V_VT(headers_var) != VT_ERROR) {
1842         if(V_VT(headers_var) != VT_BSTR)
1843             return E_INVALIDARG;
1844
1845         headers = V_BSTR(headers_var);
1846     }
1847
1848     hres = super_navigate(This, uri, headers, post_data, post_data_size);
1849     IUri_Release(uri);
1850     if(post_data)
1851         SafeArrayUnaccessData(V_ARRAY(post_data_var));
1852
1853     return hres;
1854 }
1855
1856 static HRESULT WINAPI HTMLPrivateWindow_GetPendingUrl(IHTMLPrivateWindow *iface, BSTR *url)
1857 {
1858     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1859     FIXME("(%p)->(%p)\n", This, url);
1860     return E_NOTIMPL;
1861 }
1862
1863 static HRESULT WINAPI HTMLPrivateWindow_SetPICSTarget(IHTMLPrivateWindow *iface, IOleCommandTarget *cmdtrg)
1864 {
1865     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1866     FIXME("(%p)->(%p)\n", This, cmdtrg);
1867     return E_NOTIMPL;
1868 }
1869
1870 static HRESULT WINAPI HTMLPrivateWindow_PICSComplete(IHTMLPrivateWindow *iface, int arg)
1871 {
1872     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1873     FIXME("(%p)->(%x)\n", This, arg);
1874     return E_NOTIMPL;
1875 }
1876
1877 static HRESULT WINAPI HTMLPrivateWindow_FindWindowByName(IHTMLPrivateWindow *iface, LPCWSTR name, IHTMLWindow2 **ret)
1878 {
1879     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1880     FIXME("(%p)->(%s %p)\n", This, debugstr_w(name), ret);
1881     return E_NOTIMPL;
1882 }
1883
1884 static HRESULT WINAPI HTMLPrivateWindow_GetAddressBarUrl(IHTMLPrivateWindow *iface, BSTR *url)
1885 {
1886     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1887     TRACE("(%p)->(%p)\n", This, url);
1888
1889     if(!url)
1890         return E_INVALIDARG;
1891
1892     *url = SysAllocString(This->url);
1893     return S_OK;
1894 }
1895
1896 static const IHTMLPrivateWindowVtbl HTMLPrivateWindowVtbl = {
1897     HTMLPrivateWindow_QueryInterface,
1898     HTMLPrivateWindow_AddRef,
1899     HTMLPrivateWindow_Release,
1900     HTMLPrivateWindow_SuperNavigate,
1901     HTMLPrivateWindow_GetPendingUrl,
1902     HTMLPrivateWindow_SetPICSTarget,
1903     HTMLPrivateWindow_PICSComplete,
1904     HTMLPrivateWindow_FindWindowByName,
1905     HTMLPrivateWindow_GetAddressBarUrl
1906 };
1907
1908 static inline HTMLWindow *impl_from_IDispatchEx(IDispatchEx *iface)
1909 {
1910     return CONTAINING_RECORD(iface, HTMLWindow, IDispatchEx_iface);
1911 }
1912
1913 static HRESULT WINAPI WindowDispEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
1914 {
1915     HTMLWindow *This = impl_from_IDispatchEx(iface);
1916
1917     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
1918 }
1919
1920 static ULONG WINAPI WindowDispEx_AddRef(IDispatchEx *iface)
1921 {
1922     HTMLWindow *This = impl_from_IDispatchEx(iface);
1923
1924     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
1925 }
1926
1927 static ULONG WINAPI WindowDispEx_Release(IDispatchEx *iface)
1928 {
1929     HTMLWindow *This = impl_from_IDispatchEx(iface);
1930
1931     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
1932 }
1933
1934 static HRESULT WINAPI WindowDispEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
1935 {
1936     HTMLWindow *This = impl_from_IDispatchEx(iface);
1937
1938     TRACE("(%p)->(%p)\n", This, pctinfo);
1939
1940     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1941 }
1942
1943 static HRESULT WINAPI WindowDispEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
1944                                                LCID lcid, ITypeInfo **ppTInfo)
1945 {
1946     HTMLWindow *This = impl_from_IDispatchEx(iface);
1947
1948     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1949
1950     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1951 }
1952
1953 static HRESULT WINAPI WindowDispEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
1954                                                  LPOLESTR *rgszNames, UINT cNames,
1955                                                  LCID lcid, DISPID *rgDispId)
1956 {
1957     HTMLWindow *This = impl_from_IDispatchEx(iface);
1958     UINT i;
1959     HRESULT hres;
1960
1961     WARN("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1962           lcid, rgDispId);
1963
1964     for(i=0; i < cNames; i++) {
1965         /* We shouldn't use script's IDispatchEx here, so we shouldn't use GetDispID */
1966         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
1967         if(FAILED(hres))
1968             return hres;
1969     }
1970
1971     return S_OK;
1972 }
1973
1974 static HRESULT WINAPI WindowDispEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
1975                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1976                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1977 {
1978     HTMLWindow *This = impl_from_IDispatchEx(iface);
1979
1980     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1981           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1982
1983     /* FIXME: Use script dispatch */
1984
1985     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1986             pDispParams, pVarResult, pExcepInfo, puArgErr);
1987 }
1988
1989 static global_prop_t *alloc_global_prop(HTMLWindow *This, global_prop_type_t type, BSTR name)
1990 {
1991     if(This->global_prop_cnt == This->global_prop_size) {
1992         global_prop_t *new_props;
1993         DWORD new_size;
1994
1995         if(This->global_props) {
1996             new_size = This->global_prop_size*2;
1997             new_props = heap_realloc(This->global_props, new_size*sizeof(global_prop_t));
1998         }else {
1999             new_size = 16;
2000             new_props = heap_alloc(new_size*sizeof(global_prop_t));
2001         }
2002         if(!new_props)
2003             return NULL;
2004         This->global_props = new_props;
2005         This->global_prop_size = new_size;
2006     }
2007
2008     This->global_props[This->global_prop_cnt].name = heap_strdupW(name);
2009     if(!This->global_props[This->global_prop_cnt].name)
2010         return NULL;
2011
2012     This->global_props[This->global_prop_cnt].type = type;
2013     return This->global_props + This->global_prop_cnt++;
2014 }
2015
2016 static inline DWORD prop_to_dispid(HTMLWindow *This, global_prop_t *prop)
2017 {
2018     return MSHTML_DISPID_CUSTOM_MIN + (prop-This->global_props);
2019 }
2020
2021 HRESULT search_window_props(HTMLWindow *This, BSTR bstrName, DWORD grfdex, DISPID *pid)
2022 {
2023     DWORD i;
2024     ScriptHost *script_host;
2025     DISPID id;
2026
2027     for(i=0; i < This->global_prop_cnt; i++) {
2028         /* FIXME: case sensitivity */
2029         if(!strcmpW(This->global_props[i].name, bstrName)) {
2030             *pid = MSHTML_DISPID_CUSTOM_MIN+i;
2031             return S_OK;
2032         }
2033     }
2034
2035     if(find_global_prop(This, bstrName, grfdex, &script_host, &id)) {
2036         global_prop_t *prop;
2037
2038         prop = alloc_global_prop(This, GLOBAL_SCRIPTVAR, bstrName);
2039         if(!prop)
2040             return E_OUTOFMEMORY;
2041
2042         prop->script_host = script_host;
2043         prop->id = id;
2044
2045         *pid = prop_to_dispid(This, prop);
2046         return S_OK;
2047     }
2048
2049     return DISP_E_UNKNOWNNAME;
2050 }
2051
2052 static HRESULT WINAPI WindowDispEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
2053 {
2054     HTMLWindow *This = impl_from_IDispatchEx(iface);
2055     HRESULT hres;
2056
2057     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
2058
2059     hres = search_window_props(This, bstrName, grfdex, pid);
2060     if(hres != DISP_E_UNKNOWNNAME)
2061         return hres;
2062
2063     hres = IDispatchEx_GetDispID(&This->dispex.IDispatchEx_iface, bstrName, grfdex, pid);
2064     if(hres != DISP_E_UNKNOWNNAME)
2065         return hres;
2066
2067     if(This->doc) {
2068         global_prop_t *prop;
2069         IHTMLElement *elem;
2070
2071         hres = IHTMLDocument3_getElementById(&This->doc->basedoc.IHTMLDocument3_iface,
2072                                              bstrName, &elem);
2073         if(SUCCEEDED(hres) && elem) {
2074             IHTMLElement_Release(elem);
2075
2076             prop = alloc_global_prop(This, GLOBAL_ELEMENTVAR, bstrName);
2077             if(!prop)
2078                 return E_OUTOFMEMORY;
2079
2080             *pid = prop_to_dispid(This, prop);
2081             return S_OK;
2082         }
2083     }
2084
2085     return DISP_E_UNKNOWNNAME;
2086 }
2087
2088 static HRESULT WINAPI WindowDispEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
2089         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
2090 {
2091     HTMLWindow *This = impl_from_IDispatchEx(iface);
2092
2093     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
2094
2095     if(id == DISPID_IHTMLWINDOW2_LOCATION && (wFlags & DISPATCH_PROPERTYPUT)) {
2096         HTMLLocation *location;
2097         HRESULT hres;
2098
2099         TRACE("forwarding to location.href\n");
2100
2101         hres = get_location(This, &location);
2102         if(FAILED(hres))
2103             return hres;
2104
2105         hres = IDispatchEx_InvokeEx(&location->dispex.IDispatchEx_iface, DISPID_VALUE, lcid,
2106                 wFlags, pdp, pvarRes, pei, pspCaller);
2107         IHTMLLocation_Release(&location->IHTMLLocation_iface);
2108         return hres;
2109     }
2110
2111     return IDispatchEx_InvokeEx(&This->dispex.IDispatchEx_iface, id, lcid, wFlags, pdp, pvarRes,
2112             pei, pspCaller);
2113 }
2114
2115 static HRESULT WINAPI WindowDispEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
2116 {
2117     HTMLWindow *This = impl_from_IDispatchEx(iface);
2118
2119     TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
2120
2121     return IDispatchEx_DeleteMemberByName(&This->dispex.IDispatchEx_iface, bstrName, grfdex);
2122 }
2123
2124 static HRESULT WINAPI WindowDispEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
2125 {
2126     HTMLWindow *This = impl_from_IDispatchEx(iface);
2127
2128     TRACE("(%p)->(%x)\n", This, id);
2129
2130     return IDispatchEx_DeleteMemberByDispID(&This->dispex.IDispatchEx_iface, id);
2131 }
2132
2133 static HRESULT WINAPI WindowDispEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
2134 {
2135     HTMLWindow *This = impl_from_IDispatchEx(iface);
2136
2137     TRACE("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
2138
2139     return IDispatchEx_GetMemberProperties(&This->dispex.IDispatchEx_iface, id, grfdexFetch,
2140             pgrfdex);
2141 }
2142
2143 static HRESULT WINAPI WindowDispEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
2144 {
2145     HTMLWindow *This = impl_from_IDispatchEx(iface);
2146
2147     TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
2148
2149     return IDispatchEx_GetMemberName(&This->dispex.IDispatchEx_iface, id, pbstrName);
2150 }
2151
2152 static HRESULT WINAPI WindowDispEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
2153 {
2154     HTMLWindow *This = impl_from_IDispatchEx(iface);
2155
2156     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
2157
2158     return IDispatchEx_GetNextDispID(&This->dispex.IDispatchEx_iface, grfdex, id, pid);
2159 }
2160
2161 static HRESULT WINAPI WindowDispEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
2162 {
2163     HTMLWindow *This = impl_from_IDispatchEx(iface);
2164
2165     TRACE("(%p)->(%p)\n", This, ppunk);
2166
2167     *ppunk = NULL;
2168     return S_OK;
2169 }
2170
2171 static const IDispatchExVtbl WindowDispExVtbl = {
2172     WindowDispEx_QueryInterface,
2173     WindowDispEx_AddRef,
2174     WindowDispEx_Release,
2175     WindowDispEx_GetTypeInfoCount,
2176     WindowDispEx_GetTypeInfo,
2177     WindowDispEx_GetIDsOfNames,
2178     WindowDispEx_Invoke,
2179     WindowDispEx_GetDispID,
2180     WindowDispEx_InvokeEx,
2181     WindowDispEx_DeleteMemberByName,
2182     WindowDispEx_DeleteMemberByDispID,
2183     WindowDispEx_GetMemberProperties,
2184     WindowDispEx_GetMemberName,
2185     WindowDispEx_GetNextDispID,
2186     WindowDispEx_GetNameSpaceParent
2187 };
2188
2189 static inline HTMLWindow *impl_from_IServiceProvider(IServiceProvider *iface)
2190 {
2191     return CONTAINING_RECORD(iface, HTMLWindow, IServiceProvider_iface);
2192 }
2193
2194 static HRESULT WINAPI HTMLWindowSP_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
2195 {
2196     HTMLWindow *This = impl_from_IServiceProvider(iface);
2197     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2198 }
2199
2200 static ULONG WINAPI HTMLWindowSP_AddRef(IServiceProvider *iface)
2201 {
2202     HTMLWindow *This = impl_from_IServiceProvider(iface);
2203     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2204 }
2205
2206 static ULONG WINAPI HTMLWindowSP_Release(IServiceProvider *iface)
2207 {
2208     HTMLWindow *This = impl_from_IServiceProvider(iface);
2209     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2210 }
2211
2212 static HRESULT WINAPI HTMLWindowSP_QueryService(IServiceProvider *iface, REFGUID guidService, REFIID riid, void **ppv)
2213 {
2214     HTMLWindow *This = impl_from_IServiceProvider(iface);
2215
2216     if(IsEqualGUID(guidService, &IID_IHTMLWindow2)) {
2217         TRACE("IID_IHTMLWindow2\n");
2218         return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2219     }
2220
2221     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
2222
2223     if(!This->doc_obj)
2224         return E_NOINTERFACE;
2225
2226     return IServiceProvider_QueryService(&This->doc_obj->basedoc.IServiceProvider_iface,
2227             guidService, riid, ppv);
2228 }
2229
2230 static const IServiceProviderVtbl ServiceProviderVtbl = {
2231     HTMLWindowSP_QueryInterface,
2232     HTMLWindowSP_AddRef,
2233     HTMLWindowSP_Release,
2234     HTMLWindowSP_QueryService
2235 };
2236
2237 static inline HTMLWindow *impl_from_DispatchEx(DispatchEx *iface)
2238 {
2239     return CONTAINING_RECORD(iface, HTMLWindow, dispex);
2240 }
2241
2242 static HRESULT HTMLWindow_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
2243         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
2244 {
2245     HTMLWindow *This = impl_from_DispatchEx(dispex);
2246     global_prop_t *prop;
2247     DWORD idx;
2248     HRESULT hres;
2249
2250     idx = id - MSHTML_DISPID_CUSTOM_MIN;
2251     if(idx >= This->global_prop_cnt)
2252         return DISP_E_MEMBERNOTFOUND;
2253
2254     prop = This->global_props+idx;
2255
2256     switch(prop->type) {
2257     case GLOBAL_SCRIPTVAR: {
2258         IDispatchEx *iface;
2259         IDispatch *disp;
2260
2261         disp = get_script_disp(prop->script_host);
2262         if(!disp)
2263             return E_UNEXPECTED;
2264
2265         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&iface);
2266         if(SUCCEEDED(hres)) {
2267             TRACE("%s >>>\n", debugstr_w(prop->name));
2268             hres = IDispatchEx_InvokeEx(iface, prop->id, lcid, flags, params, res, ei, caller);
2269             if(hres == S_OK)
2270                 TRACE("%s <<<\n", debugstr_w(prop->name));
2271             else
2272                 WARN("%s <<< %08x\n", debugstr_w(prop->name), hres);
2273             IDispatchEx_Release(iface);
2274         }else {
2275             FIXME("No IDispatchEx\n");
2276         }
2277         IDispatch_Release(disp);
2278         break;
2279     }
2280     case GLOBAL_ELEMENTVAR: {
2281         IHTMLElement *elem;
2282
2283         hres = IHTMLDocument3_getElementById(&This->doc->basedoc.IHTMLDocument3_iface,
2284                                              prop->name, &elem);
2285         if(FAILED(hres))
2286             return hres;
2287
2288         if(!elem)
2289             return DISP_E_MEMBERNOTFOUND;
2290
2291         V_VT(res) = VT_DISPATCH;
2292         V_DISPATCH(res) = (IDispatch*)elem;
2293         break;
2294     }
2295     default:
2296         ERR("invalid type %d\n", prop->type);
2297         hres = DISP_E_MEMBERNOTFOUND;
2298     }
2299
2300     return hres;
2301 }
2302
2303
2304 static const dispex_static_data_vtbl_t HTMLWindow_dispex_vtbl = {
2305     NULL,
2306     NULL,
2307     HTMLWindow_invoke,
2308     NULL
2309 };
2310
2311 static const tid_t HTMLWindow_iface_tids[] = {
2312     IHTMLWindow2_tid,
2313     IHTMLWindow3_tid,
2314     IHTMLWindow4_tid,
2315     IHTMLWindow6_tid,
2316     0
2317 };
2318
2319 static dispex_static_data_t HTMLWindow_dispex = {
2320     &HTMLWindow_dispex_vtbl,
2321     DispHTMLWindow2_tid,
2322     NULL,
2323     HTMLWindow_iface_tids
2324 };
2325
2326 HRESULT HTMLWindow_Create(HTMLDocumentObj *doc_obj, nsIDOMWindow *nswindow, HTMLWindow *parent, HTMLWindow **ret)
2327 {
2328     HTMLWindow *window;
2329     HRESULT hres;
2330
2331     window = heap_alloc_zero(sizeof(HTMLWindow));
2332     if(!window)
2333         return E_OUTOFMEMORY;
2334
2335     window->window_ref = heap_alloc(sizeof(windowref_t));
2336     if(!window->window_ref) {
2337         heap_free(window);
2338         return E_OUTOFMEMORY;
2339     }
2340
2341     window->IHTMLWindow2_iface.lpVtbl = &HTMLWindow2Vtbl;
2342     window->IHTMLWindow3_iface.lpVtbl = &HTMLWindow3Vtbl;
2343     window->IHTMLWindow4_iface.lpVtbl = &HTMLWindow4Vtbl;
2344     window->IHTMLWindow6_iface.lpVtbl = &HTMLWindow6Vtbl;
2345     window->IHTMLPrivateWindow_iface.lpVtbl = &HTMLPrivateWindowVtbl;
2346     window->IDispatchEx_iface.lpVtbl = &WindowDispExVtbl;
2347     window->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
2348     window->ref = 1;
2349     window->doc_obj = doc_obj;
2350
2351     window->window_ref->window = window;
2352     window->window_ref->ref = 1;
2353
2354     init_dispex(&window->dispex, (IUnknown*)&window->IHTMLWindow2_iface, &HTMLWindow_dispex);
2355
2356     if(nswindow) {
2357         nsIDOMWindow_AddRef(nswindow);
2358         window->nswindow = nswindow;
2359     }
2360
2361     window->scriptmode = parent ? parent->scriptmode : SCRIPTMODE_GECKO;
2362     window->readystate = READYSTATE_UNINITIALIZED;
2363     list_init(&window->script_hosts);
2364
2365     hres = CoInternetCreateSecurityManager(NULL, &window->secmgr, 0);
2366     if(FAILED(hres)) {
2367         IHTMLWindow2_Release(&window->IHTMLWindow2_iface);
2368         return hres;
2369     }
2370
2371     window->task_magic = get_task_target_magic();
2372     update_window_doc(window);
2373
2374     list_init(&window->children);
2375     list_add_head(&window_list, &window->entry);
2376
2377     if(parent) {
2378         IHTMLWindow2_AddRef(&window->IHTMLWindow2_iface);
2379
2380         window->parent = parent;
2381         list_add_tail(&parent->children, &window->sibling_entry);
2382     }
2383
2384     *ret = window;
2385     return S_OK;
2386 }
2387
2388 void update_window_doc(HTMLWindow *window)
2389 {
2390     nsIDOMHTMLDocument *nshtmldoc;
2391     nsIDOMDocument *nsdoc;
2392     nsresult nsres;
2393
2394     nsres = nsIDOMWindow_GetDocument(window->nswindow, &nsdoc);
2395     if(NS_FAILED(nsres) || !nsdoc) {
2396         ERR("GetDocument failed: %08x\n", nsres);
2397         return;
2398     }
2399
2400     nsres = nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
2401     nsIDOMDocument_Release(nsdoc);
2402     if(NS_FAILED(nsres)) {
2403         ERR("Could not get nsIDOMHTMLDocument iface: %08x\n", nsres);
2404         return;
2405     }
2406
2407     if(!window->doc || window->doc->nsdoc != nshtmldoc) {
2408         HTMLDocumentNode *doc;
2409         HRESULT hres;
2410
2411         hres = create_doc_from_nsdoc(nshtmldoc, window->doc_obj, window, &doc);
2412         if(SUCCEEDED(hres)) {
2413             window_set_docnode(window, doc);
2414             htmldoc_release(&doc->basedoc);
2415         }else {
2416             ERR("create_doc_from_nsdoc failed: %08x\n", hres);
2417         }
2418     }
2419
2420     nsIDOMHTMLDocument_Release(nshtmldoc);
2421 }
2422
2423 HTMLWindow *nswindow_to_window(const nsIDOMWindow *nswindow)
2424 {
2425     HTMLWindow *iter;
2426
2427     LIST_FOR_EACH_ENTRY(iter, &window_list, HTMLWindow, entry) {
2428         if(iter->nswindow == nswindow)
2429             return iter;
2430     }
2431
2432     return NULL;
2433 }