git.oblomov.eu Git - wine/blob - dlls/mshtml/htmlwindow.c

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