git.oblomov.eu Git - wine/blob - 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 typedef struct {
1810     task_t header;
1811     HTMLWindow *window;
1812     IUri *uri;
1813 } navigate_javascript_task_t;
1814
1815 static void navigate_javascript_proc(task_t *_task)
1816 {
1817     navigate_javascript_task_t *task = (navigate_javascript_task_t*)_task;
1818     HTMLWindow *window = task->window;
1819     VARIANT v;
1820     BSTR code;
1821     HRESULT hres;
1822
1823     static const WCHAR jscriptW[] = {'j','s','c','r','i','p','t',0};
1824
1825     task->window->readystate = READYSTATE_COMPLETE;
1826
1827     hres = IUri_GetPath(task->uri, &code);
1828     if(FAILED(hres))
1829         return;
1830
1831     set_download_state(window->doc_obj, 1);
1832
1833     V_VT(&v) = VT_EMPTY;
1834     hres = exec_script(window, code, jscriptW, &v);
1835     SysFreeString(code);
1836     if(SUCCEEDED(hres) && V_VT(&v) != VT_EMPTY) {
1837         FIXME("javascirpt URL returned %s\n", debugstr_variant(&v));
1838         VariantClear(&v);
1839     }
1840
1841     if(window->doc_obj->view_sink)
1842         IAdviseSink_OnViewChange(window->doc_obj->view_sink, DVASPECT_CONTENT, -1);
1843
1844     set_download_state(window->doc_obj, 0);
1845 }
1846
1847 static void navigate_javascript_task_destr(task_t *_task)
1848 {
1849     navigate_javascript_task_t *task = (navigate_javascript_task_t*)_task;
1850
1851     IUri_Release(task->uri);
1852     heap_free(task);
1853 }
1854
1855 typedef struct {
1856     task_t header;
1857     HTMLWindow *window;
1858     nsChannelBSC *bscallback;
1859     IMoniker *mon;
1860 } navigate_task_t;
1861
1862 static void navigate_proc(task_t *_task)
1863 {
1864     navigate_task_t *task = (navigate_task_t*)_task;
1865     HRESULT hres;
1866
1867     hres = set_moniker(&task->window->doc_obj->basedoc, task->mon, NULL, task->bscallback, TRUE);
1868     if(SUCCEEDED(hres))
1869         hres = start_binding(task->window, NULL, (BSCallback*)task->bscallback, NULL);
1870
1871 }
1872
1873 static void navigate_task_destr(task_t *_task)
1874 {
1875     navigate_task_t *task = (navigate_task_t*)_task;
1876
1877     IUnknown_Release((IUnknown*)task->bscallback);
1878     IMoniker_Release(task->mon);
1879     heap_free(task);
1880 }
1881
1882 static HRESULT WINAPI HTMLPrivateWindow_SuperNavigate(IHTMLPrivateWindow *iface, BSTR url, BSTR arg2, BSTR arg3,
1883         BSTR arg4, VARIANT *post_data_var, VARIANT *headers_var, ULONG flags)
1884 {
1885     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
1886     DWORD post_data_size = 0;
1887     BYTE *post_data = NULL;
1888     WCHAR *headers = NULL;
1889     nsChannelBSC *bsc;
1890     IMoniker *mon;
1891     DWORD scheme;
1892     BSTR new_url;
1893     IUri *uri;
1894     HRESULT hres;
1895
1896     TRACE("(%p)->(%s %s %s %s %s %s %x)\n", This, debugstr_w(url), debugstr_w(arg2), debugstr_w(arg3), debugstr_w(arg4),
1897           debugstr_variant(post_data_var), debugstr_variant(headers_var), flags);
1898
1899     new_url = url;
1900     if(This->doc_obj->hostui) {
1901         OLECHAR *translated_url = NULL;
1902
1903         hres = IDocHostUIHandler_TranslateUrl(This->doc_obj->hostui, 0, url, &translated_url);
1904         if(hres == S_OK && translated_url) {
1905             new_url = SysAllocString(translated_url);
1906             CoTaskMemFree(translated_url);
1907         }
1908     }
1909
1910     if(This->doc_obj->client) {
1911         IOleCommandTarget *cmdtrg;
1912
1913         hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
1914         if(SUCCEEDED(hres)) {
1915             VARIANT in, out;
1916
1917             V_VT(&in) = VT_BSTR;
1918             V_BSTR(&in) = new_url;
1919             V_VT(&out) = VT_BOOL;
1920             V_BOOL(&out) = VARIANT_TRUE;
1921             hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 67, 0, &in, &out);
1922             IOleCommandTarget_Release(cmdtrg);
1923             if(SUCCEEDED(hres))
1924                 VariantClear(&out);
1925         }
1926     }
1927
1928     hres = CreateUri(new_url, 0, 0, &uri);
1929     if(new_url != url)
1930         SysFreeString(new_url);
1931     if(FAILED(hres))
1932         return hres;
1933
1934     hres = CreateURLMonikerEx2(NULL, uri, &mon, URL_MK_UNIFORM);
1935     if(FAILED(hres))
1936         return hres;
1937
1938     /* FIXME: Why not set_ready_state? */
1939     This->readystate = READYSTATE_UNINITIALIZED;
1940
1941     if(post_data_var) {
1942         if(V_VT(post_data_var) == (VT_ARRAY|VT_UI1)) {
1943             SafeArrayAccessData(V_ARRAY(post_data_var), (void**)&post_data);
1944             post_data_size = V_ARRAY(post_data_var)->rgsabound[0].cElements;
1945         }
1946     }
1947
1948     if(headers_var && V_VT(headers_var) != VT_EMPTY && V_VT(headers_var) != VT_ERROR) {
1949         if(V_VT(headers_var) != VT_BSTR)
1950             return E_INVALIDARG;
1951
1952         headers = V_BSTR(headers_var);
1953     }
1954
1955     hres = create_channelbsc(mon, headers, post_data, post_data_size, &bsc);
1956     if(post_data)
1957         SafeArrayUnaccessData(V_ARRAY(post_data_var));
1958     if(FAILED(hres)) {
1959         IMoniker_Release(mon);
1960         return hres;
1961     }
1962
1963     prepare_for_binding(&This->doc_obj->basedoc, mon, NULL, TRUE);
1964
1965     hres = IUri_GetScheme(uri, &scheme);
1966
1967     if(scheme != URL_SCHEME_JAVASCRIPT) {
1968         navigate_task_t *task;
1969
1970         IUri_Release(uri);
1971
1972         task = heap_alloc(sizeof(*task));
1973         if(!task) {
1974             IUnknown_Release((IUnknown*)bsc);
1975             IMoniker_Release(mon);
1976             return E_OUTOFMEMORY;
1977         }
1978
1979         task->window = This;
1980         task->bscallback = bsc;
1981         task->mon = mon;
1982         push_task(&task->header, navigate_proc, navigate_task_destr, This->task_magic);
1983
1984         /* Silently and repeated when real loading starts? */
1985         This->readystate = READYSTATE_LOADING;
1986     }else {
1987         navigate_javascript_task_t *task;
1988
1989         IUnknown_Release((IUnknown*)bsc);
1990         IMoniker_Release(mon);
1991
1992         task = heap_alloc(sizeof(*task));
1993         if(!task) {
1994             IUri_Release(uri);
1995             return E_OUTOFMEMORY;
1996         }
1997
1998         task->window = This;
1999         task->uri = uri;
2000         push_task(&task->header, navigate_javascript_proc, navigate_javascript_task_destr, This->task_magic);
2001
2002         /* Why silently? */
2003         This->readystate = READYSTATE_COMPLETE;
2004     }
2005
2006     return S_OK;
2007 }
2008
2009 static HRESULT WINAPI HTMLPrivateWindow_GetPendingUrl(IHTMLPrivateWindow *iface, BSTR *url)
2010 {
2011     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2012     FIXME("(%p)->(%p)\n", This, url);
2013     return E_NOTIMPL;
2014 }
2015
2016 static HRESULT WINAPI HTMLPrivateWindow_SetPICSTarget(IHTMLPrivateWindow *iface, IOleCommandTarget *cmdtrg)
2017 {
2018     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2019     FIXME("(%p)->(%p)\n", This, cmdtrg);
2020     return E_NOTIMPL;
2021 }
2022
2023 static HRESULT WINAPI HTMLPrivateWindow_PICSComplete(IHTMLPrivateWindow *iface, int arg)
2024 {
2025     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2026     FIXME("(%p)->(%x)\n", This, arg);
2027     return E_NOTIMPL;
2028 }
2029
2030 static HRESULT WINAPI HTMLPrivateWindow_FindWindowByName(IHTMLPrivateWindow *iface, LPCWSTR name, IHTMLWindow2 **ret)
2031 {
2032     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2033     FIXME("(%p)->(%s %p)\n", This, debugstr_w(name), ret);
2034     return E_NOTIMPL;
2035 }
2036
2037 static HRESULT WINAPI HTMLPrivateWindow_GetAddressBar(IHTMLPrivateWindow *iface, BSTR *url)
2038 {
2039     HTMLWindow *This = impl_from_IHTMLPrivateWindow(iface);
2040     TRACE("(%p)->(%p)\n", This, url);
2041
2042     if(!url)
2043         return E_INVALIDARG;
2044
2045     *url = SysAllocString(This->url);
2046     return S_OK;
2047 }
2048
2049 static const IHTMLPrivateWindowVtbl HTMLPrivateWindowVtbl = {
2050     HTMLPrivateWindow_QueryInterface,
2051     HTMLPrivateWindow_AddRef,
2052     HTMLPrivateWindow_Release,
2053     HTMLPrivateWindow_SuperNavigate,
2054     HTMLPrivateWindow_GetPendingUrl,
2055     HTMLPrivateWindow_SetPICSTarget,
2056     HTMLPrivateWindow_PICSComplete,
2057     HTMLPrivateWindow_FindWindowByName,
2058     HTMLPrivateWindow_GetAddressBar
2059 };
2060
2061 static inline HTMLWindow *impl_from_IDispatchEx(IDispatchEx *iface)
2062 {
2063     return CONTAINING_RECORD(iface, HTMLWindow, IDispatchEx_iface);
2064 }
2065
2066 static HRESULT WINAPI WindowDispEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
2067 {
2068     HTMLWindow *This = impl_from_IDispatchEx(iface);
2069
2070     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2071 }
2072
2073 static ULONG WINAPI WindowDispEx_AddRef(IDispatchEx *iface)
2074 {
2075     HTMLWindow *This = impl_from_IDispatchEx(iface);
2076
2077     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2078 }
2079
2080 static ULONG WINAPI WindowDispEx_Release(IDispatchEx *iface)
2081 {
2082     HTMLWindow *This = impl_from_IDispatchEx(iface);
2083
2084     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2085 }
2086
2087 static HRESULT WINAPI WindowDispEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
2088 {
2089     HTMLWindow *This = impl_from_IDispatchEx(iface);
2090
2091     TRACE("(%p)->(%p)\n", This, pctinfo);
2092
2093     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
2094 }
2095
2096 static HRESULT WINAPI WindowDispEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
2097                                                LCID lcid, ITypeInfo **ppTInfo)
2098 {
2099     HTMLWindow *This = impl_from_IDispatchEx(iface);
2100
2101     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
2102
2103     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2104 }
2105
2106 static HRESULT WINAPI WindowDispEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
2107                                                  LPOLESTR *rgszNames, UINT cNames,
2108                                                  LCID lcid, DISPID *rgDispId)
2109 {
2110     HTMLWindow *This = impl_from_IDispatchEx(iface);
2111     UINT i;
2112     HRESULT hres;
2113
2114     WARN("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
2115           lcid, rgDispId);
2116
2117     for(i=0; i < cNames; i++) {
2118         /* We shouldn't use script's IDispatchEx here, so we shouldn't use GetDispID */
2119         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
2120         if(FAILED(hres))
2121             return hres;
2122     }
2123
2124     return S_OK;
2125 }
2126
2127 static HRESULT WINAPI WindowDispEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
2128                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2129                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2130 {
2131     HTMLWindow *This = impl_from_IDispatchEx(iface);
2132
2133     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
2134           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2135
2136     /* FIXME: Use script dispatch */
2137
2138     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2139             pDispParams, pVarResult, pExcepInfo, puArgErr);
2140 }
2141
2142 static global_prop_t *alloc_global_prop(HTMLWindow *This, global_prop_type_t type, BSTR name)
2143 {
2144     if(This->global_prop_cnt == This->global_prop_size) {
2145         global_prop_t *new_props;
2146         DWORD new_size;
2147
2148         if(This->global_props) {
2149             new_size = This->global_prop_size*2;
2150             new_props = heap_realloc(This->global_props, new_size*sizeof(global_prop_t));
2151         }else {
2152             new_size = 16;
2153             new_props = heap_alloc(new_size*sizeof(global_prop_t));
2154         }
2155         if(!new_props)
2156             return NULL;
2157         This->global_props = new_props;
2158         This->global_prop_size = new_size;
2159     }
2160
2161     This->global_props[This->global_prop_cnt].name = heap_strdupW(name);
2162     if(!This->global_props[This->global_prop_cnt].name)
2163         return NULL;
2164
2165     This->global_props[This->global_prop_cnt].type = type;
2166     return This->global_props + This->global_prop_cnt++;
2167 }
2168
2169 static inline DWORD prop_to_dispid(HTMLWindow *This, global_prop_t *prop)
2170 {
2171     return MSHTML_DISPID_CUSTOM_MIN + (prop-This->global_props);
2172 }
2173
2174 HRESULT search_window_props(HTMLWindow *This, BSTR bstrName, DWORD grfdex, DISPID *pid)
2175 {
2176     DWORD i;
2177     ScriptHost *script_host;
2178     DISPID id;
2179
2180     for(i=0; i < This->global_prop_cnt; i++) {
2181         /* FIXME: case sensitivity */
2182         if(!strcmpW(This->global_props[i].name, bstrName)) {
2183             *pid = MSHTML_DISPID_CUSTOM_MIN+i;
2184             return S_OK;
2185         }
2186     }
2187
2188     if(find_global_prop(This, bstrName, grfdex, &script_host, &id)) {
2189         global_prop_t *prop;
2190
2191         prop = alloc_global_prop(This, GLOBAL_SCRIPTVAR, bstrName);
2192         if(!prop)
2193             return E_OUTOFMEMORY;
2194
2195         prop->script_host = script_host;
2196         prop->id = id;
2197
2198         *pid = prop_to_dispid(This, prop);
2199         return S_OK;
2200     }
2201
2202     return DISP_E_UNKNOWNNAME;
2203 }
2204
2205 static HRESULT WINAPI WindowDispEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
2206 {
2207     HTMLWindow *This = impl_from_IDispatchEx(iface);
2208     HRESULT hres;
2209
2210     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
2211
2212     hres = search_window_props(This, bstrName, grfdex, pid);
2213     if(hres != DISP_E_UNKNOWNNAME)
2214         return hres;
2215
2216     hres = IDispatchEx_GetDispID(&This->dispex.IDispatchEx_iface, bstrName, grfdex, pid);
2217     if(hres != DISP_E_UNKNOWNNAME)
2218         return hres;
2219
2220     if(This->doc) {
2221         global_prop_t *prop;
2222         IHTMLElement *elem;
2223
2224         hres = IHTMLDocument3_getElementById(&This->doc->basedoc.IHTMLDocument3_iface,
2225                                              bstrName, &elem);
2226         if(SUCCEEDED(hres) && elem) {
2227             IHTMLElement_Release(elem);
2228
2229             prop = alloc_global_prop(This, GLOBAL_ELEMENTVAR, bstrName);
2230             if(!prop)
2231                 return E_OUTOFMEMORY;
2232
2233             *pid = prop_to_dispid(This, prop);
2234             return S_OK;
2235         }
2236     }
2237
2238     return DISP_E_UNKNOWNNAME;
2239 }
2240
2241 static HRESULT WINAPI WindowDispEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
2242         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
2243 {
2244     HTMLWindow *This = impl_from_IDispatchEx(iface);
2245
2246     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
2247
2248     if(id == DISPID_IHTMLWINDOW2_LOCATION && (wFlags & DISPATCH_PROPERTYPUT)) {
2249         HTMLLocation *location;
2250         HRESULT hres;
2251
2252         TRACE("forwarding to location.href\n");
2253
2254         hres = get_location(This, &location);
2255         if(FAILED(hres))
2256             return hres;
2257
2258         hres = IDispatchEx_InvokeEx(&location->dispex.IDispatchEx_iface, DISPID_VALUE, lcid,
2259                 wFlags, pdp, pvarRes, pei, pspCaller);
2260         IHTMLLocation_Release(&location->IHTMLLocation_iface);
2261         return hres;
2262     }
2263
2264     return IDispatchEx_InvokeEx(&This->dispex.IDispatchEx_iface, id, lcid, wFlags, pdp, pvarRes,
2265             pei, pspCaller);
2266 }
2267
2268 static HRESULT WINAPI WindowDispEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
2269 {
2270     HTMLWindow *This = impl_from_IDispatchEx(iface);
2271
2272     TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
2273
2274     return IDispatchEx_DeleteMemberByName(&This->dispex.IDispatchEx_iface, bstrName, grfdex);
2275 }
2276
2277 static HRESULT WINAPI WindowDispEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
2278 {
2279     HTMLWindow *This = impl_from_IDispatchEx(iface);
2280
2281     TRACE("(%p)->(%x)\n", This, id);
2282
2283     return IDispatchEx_DeleteMemberByDispID(&This->dispex.IDispatchEx_iface, id);
2284 }
2285
2286 static HRESULT WINAPI WindowDispEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
2287 {
2288     HTMLWindow *This = impl_from_IDispatchEx(iface);
2289
2290     TRACE("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
2291
2292     return IDispatchEx_GetMemberProperties(&This->dispex.IDispatchEx_iface, id, grfdexFetch,
2293             pgrfdex);
2294 }
2295
2296 static HRESULT WINAPI WindowDispEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
2297 {
2298     HTMLWindow *This = impl_from_IDispatchEx(iface);
2299
2300     TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
2301
2302     return IDispatchEx_GetMemberName(&This->dispex.IDispatchEx_iface, id, pbstrName);
2303 }
2304
2305 static HRESULT WINAPI WindowDispEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
2306 {
2307     HTMLWindow *This = impl_from_IDispatchEx(iface);
2308
2309     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
2310
2311     return IDispatchEx_GetNextDispID(&This->dispex.IDispatchEx_iface, grfdex, id, pid);
2312 }
2313
2314 static HRESULT WINAPI WindowDispEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
2315 {
2316     HTMLWindow *This = impl_from_IDispatchEx(iface);
2317
2318     TRACE("(%p)->(%p)\n", This, ppunk);
2319
2320     *ppunk = NULL;
2321     return S_OK;
2322 }
2323
2324 static const IDispatchExVtbl WindowDispExVtbl = {
2325     WindowDispEx_QueryInterface,
2326     WindowDispEx_AddRef,
2327     WindowDispEx_Release,
2328     WindowDispEx_GetTypeInfoCount,
2329     WindowDispEx_GetTypeInfo,
2330     WindowDispEx_GetIDsOfNames,
2331     WindowDispEx_Invoke,
2332     WindowDispEx_GetDispID,
2333     WindowDispEx_InvokeEx,
2334     WindowDispEx_DeleteMemberByName,
2335     WindowDispEx_DeleteMemberByDispID,
2336     WindowDispEx_GetMemberProperties,
2337     WindowDispEx_GetMemberName,
2338     WindowDispEx_GetNextDispID,
2339     WindowDispEx_GetNameSpaceParent
2340 };
2341
2342 static inline HTMLWindow *impl_from_IServiceProvider(IServiceProvider *iface)
2343 {
2344     return CONTAINING_RECORD(iface, HTMLWindow, IServiceProvider_iface);
2345 }
2346
2347 static HRESULT WINAPI HTMLWindowSP_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
2348 {
2349     HTMLWindow *This = impl_from_IServiceProvider(iface);
2350     return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2351 }
2352
2353 static ULONG WINAPI HTMLWindowSP_AddRef(IServiceProvider *iface)
2354 {
2355     HTMLWindow *This = impl_from_IServiceProvider(iface);
2356     return IHTMLWindow2_AddRef(&This->IHTMLWindow2_iface);
2357 }
2358
2359 static ULONG WINAPI HTMLWindowSP_Release(IServiceProvider *iface)
2360 {
2361     HTMLWindow *This = impl_from_IServiceProvider(iface);
2362     return IHTMLWindow2_Release(&This->IHTMLWindow2_iface);
2363 }
2364
2365 static HRESULT WINAPI HTMLWindowSP_QueryService(IServiceProvider *iface, REFGUID guidService, REFIID riid, void **ppv)
2366 {
2367     HTMLWindow *This = impl_from_IServiceProvider(iface);
2368
2369     if(IsEqualGUID(guidService, &IID_IHTMLWindow2)) {
2370         TRACE("IID_IHTMLWindow2\n");
2371         return IHTMLWindow2_QueryInterface(&This->IHTMLWindow2_iface, riid, ppv);
2372     }
2373
2374     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
2375
2376     if(!This->doc_obj)
2377         return E_NOINTERFACE;
2378
2379     return IServiceProvider_QueryService(&This->doc_obj->basedoc.IServiceProvider_iface,
2380             guidService, riid, ppv);
2381 }
2382
2383 static const IServiceProviderVtbl ServiceProviderVtbl = {
2384     HTMLWindowSP_QueryInterface,
2385     HTMLWindowSP_AddRef,
2386     HTMLWindowSP_Release,
2387     HTMLWindowSP_QueryService
2388 };
2389
2390 static inline HTMLWindow *impl_from_DispatchEx(DispatchEx *iface)
2391 {
2392     return CONTAINING_RECORD(iface, HTMLWindow, dispex);
2393 }
2394
2395 static HRESULT HTMLWindow_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
2396         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
2397 {
2398     HTMLWindow *This = impl_from_DispatchEx(dispex);
2399     global_prop_t *prop;
2400     DWORD idx;
2401     HRESULT hres;
2402
2403     idx = id - MSHTML_DISPID_CUSTOM_MIN;
2404     if(idx >= This->global_prop_cnt)
2405         return DISP_E_MEMBERNOTFOUND;
2406
2407     prop = This->global_props+idx;
2408
2409     switch(prop->type) {
2410     case GLOBAL_SCRIPTVAR: {
2411         IDispatchEx *iface;
2412         IDispatch *disp;
2413
2414         disp = get_script_disp(prop->script_host);
2415         if(!disp)
2416             return E_UNEXPECTED;
2417
2418         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&iface);
2419         if(SUCCEEDED(hres)) {
2420             TRACE("%s >>>\n", debugstr_w(prop->name));
2421             hres = IDispatchEx_InvokeEx(iface, prop->id, lcid, flags, params, res, ei, caller);
2422             if(hres == S_OK)
2423                 TRACE("%s <<<\n", debugstr_w(prop->name));
2424             else
2425                 WARN("%s <<< %08x\n", debugstr_w(prop->name), hres);
2426             IDispatchEx_Release(iface);
2427         }else {
2428             FIXME("No IDispatchEx\n");
2429         }
2430         IDispatch_Release(disp);
2431         break;
2432     }
2433     case GLOBAL_ELEMENTVAR: {
2434         IHTMLElement *elem;
2435
2436         hres = IHTMLDocument3_getElementById(&This->doc->basedoc.IHTMLDocument3_iface,
2437                                              prop->name, &elem);
2438         if(FAILED(hres))
2439             return hres;
2440
2441         if(!elem)
2442             return DISP_E_MEMBERNOTFOUND;
2443
2444         V_VT(res) = VT_DISPATCH;
2445         V_DISPATCH(res) = (IDispatch*)elem;
2446         break;
2447     }
2448     default:
2449         ERR("invalid type %d\n", prop->type);
2450         hres = DISP_E_MEMBERNOTFOUND;
2451     }
2452
2453     return hres;
2454 }
2455
2456
2457 static const dispex_static_data_vtbl_t HTMLWindow_dispex_vtbl = {
2458     NULL,
2459     NULL,
2460     HTMLWindow_invoke,
2461     NULL
2462 };
2463
2464 static const tid_t HTMLWindow_iface_tids[] = {
2465     IHTMLWindow2_tid,
2466     IHTMLWindow3_tid,
2467     IHTMLWindow4_tid,
2468     IHTMLWindow6_tid,
2469     0
2470 };
2471
2472 static dispex_static_data_t HTMLWindow_dispex = {
2473     &HTMLWindow_dispex_vtbl,
2474     DispHTMLWindow2_tid,
2475     NULL,
2476     HTMLWindow_iface_tids
2477 };
2478
2479 HRESULT HTMLWindow_Create(HTMLDocumentObj *doc_obj, nsIDOMWindow *nswindow, HTMLWindow *parent, HTMLWindow **ret)
2480 {
2481     HTMLWindow *window;
2482     HRESULT hres;
2483
2484     window = heap_alloc_zero(sizeof(HTMLWindow));
2485     if(!window)
2486         return E_OUTOFMEMORY;
2487
2488     window->window_ref = heap_alloc(sizeof(windowref_t));
2489     if(!window->window_ref) {
2490         heap_free(window);
2491         return E_OUTOFMEMORY;
2492     }
2493
2494     window->IHTMLWindow2_iface.lpVtbl = &HTMLWindow2Vtbl;
2495     window->IHTMLWindow3_iface.lpVtbl = &HTMLWindow3Vtbl;
2496     window->IHTMLWindow4_iface.lpVtbl = &HTMLWindow4Vtbl;
2497     window->IHTMLWindow6_iface.lpVtbl = &HTMLWindow6Vtbl;
2498     window->IHTMLPrivateWindow_iface.lpVtbl = &HTMLPrivateWindowVtbl;
2499     window->IDispatchEx_iface.lpVtbl = &WindowDispExVtbl;
2500     window->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
2501     window->ref = 1;
2502     window->doc_obj = doc_obj;
2503
2504     window->window_ref->window = window;
2505     window->window_ref->ref = 1;
2506
2507     init_dispex(&window->dispex, (IUnknown*)&window->IHTMLWindow2_iface, &HTMLWindow_dispex);
2508
2509     if(nswindow) {
2510         nsIDOMWindow_AddRef(nswindow);
2511         window->nswindow = nswindow;
2512     }
2513
2514     window->scriptmode = parent ? parent->scriptmode : SCRIPTMODE_GECKO;
2515     window->readystate = READYSTATE_UNINITIALIZED;
2516     list_init(&window->script_hosts);
2517
2518     hres = CoInternetCreateSecurityManager(NULL, &window->secmgr, 0);
2519     if(FAILED(hres)) {
2520         IHTMLWindow2_Release(&window->IHTMLWindow2_iface);
2521         return hres;
2522     }
2523
2524     window->task_magic = get_task_target_magic();
2525     update_window_doc(window);
2526
2527     list_init(&window->children);
2528     list_add_head(&window_list, &window->entry);
2529
2530     if(parent) {
2531         IHTMLWindow2_AddRef(&window->IHTMLWindow2_iface);
2532
2533         window->parent = parent;
2534         list_add_tail(&parent->children, &window->sibling_entry);
2535     }
2536
2537     *ret = window;
2538     return S_OK;
2539 }
2540
2541 void update_window_doc(HTMLWindow *window)
2542 {
2543     nsIDOMHTMLDocument *nshtmldoc;
2544     nsIDOMDocument *nsdoc;
2545     nsresult nsres;
2546
2547     nsres = nsIDOMWindow_GetDocument(window->nswindow, &nsdoc);
2548     if(NS_FAILED(nsres) || !nsdoc) {
2549         ERR("GetDocument failed: %08x\n", nsres);
2550         return;
2551     }
2552
2553     nsres = nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
2554     nsIDOMDocument_Release(nsdoc);
2555     if(NS_FAILED(nsres)) {
2556         ERR("Could not get nsIDOMHTMLDocument iface: %08x\n", nsres);
2557         return;
2558     }
2559
2560     if(!window->doc || window->doc->nsdoc != nshtmldoc) {
2561         HTMLDocumentNode *doc;
2562         HRESULT hres;
2563
2564         hres = create_doc_from_nsdoc(nshtmldoc, window->doc_obj, window, &doc);
2565         if(SUCCEEDED(hres)) {
2566             window_set_docnode(window, doc);
2567             htmldoc_release(&doc->basedoc);
2568         }else {
2569             ERR("create_doc_from_nsdoc failed: %08x\n", hres);
2570         }
2571     }
2572
2573     nsIDOMHTMLDocument_Release(nshtmldoc);
2574 }
2575
2576 HTMLWindow *nswindow_to_window(const nsIDOMWindow *nswindow)
2577 {
2578     HTMLWindow *iter;
2579
2580     LIST_FOR_EACH_ENTRY(iter, &window_list, HTMLWindow, entry) {
2581         if(iter->nswindow == nswindow)
2582             return iter;
2583     }
2584
2585     return NULL;
2586 }