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