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     TRACE("(%p)->(%p)\n", This, p);
 700
 701     if(This->parent) {
 702         *p = HTMLWINDOW2(This->parent);
 703         IHTMLWindow2_AddRef(*p);
 704     }else
 705         *p = NULL;
 706
 707     return S_OK;
 708 }
 709
 710 static HRESULT WINAPI HTMLWindow2_open(IHTMLWindow2 *iface, BSTR url, BSTR name,
 711          BSTR features, VARIANT_BOOL replace, IHTMLWindow2 **pomWindowResult)
 712 {
 713     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 714     FIXME("(%p)->(%s %s %s %x %p)\n", This, debugstr_w(url), debugstr_w(name),
 715           debugstr_w(features), replace, pomWindowResult);
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI HTMLWindow2_get_self(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 720 {
 721     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 722
 723     TRACE("(%p)->(%p)\n", This, p);
 724
 725     /* FIXME: We should return kind of proxy window here. */
 726     IHTMLWindow2_AddRef(HTMLWINDOW2(This));
 727     *p = HTMLWINDOW2(This);
 728     return S_OK;
 729 }
 730
 731 static HRESULT WINAPI HTMLWindow2_get_top(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 732 {
 733     HTMLWindow *This = HTMLWINDOW2_THIS(iface), *curr;
 734     TRACE("(%p)->(%p)\n", This, p);
 735
 736     curr = This;
 737     while(curr->parent)
 738         curr = curr->parent;
 739     *p = HTMLWINDOW2(curr);
 740     IHTMLWindow2_AddRef(*p);
 741
 742     return S_OK;
 743 }
 744
 745 static HRESULT WINAPI HTMLWindow2_get_window(IHTMLWindow2 *iface, IHTMLWindow2 **p)
 746 {
 747     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 748
 749     TRACE("(%p)->(%p)\n", This, p);
 750
 751     /* FIXME: We should return kind of proxy window here. */
 752     IHTMLWindow2_AddRef(HTMLWINDOW2(This));
 753     *p = HTMLWINDOW2(This);
 754     return S_OK;
 755 }
 756
 757 static HRESULT WINAPI HTMLWindow2_navigate(IHTMLWindow2 *iface, BSTR url)
 758 {
 759     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 760     FIXME("(%p)->(%s)\n", This, debugstr_w(url));
 761     return E_NOTIMPL;
 762 }
 763
 764 static HRESULT WINAPI HTMLWindow2_put_onfocus(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_onfocus(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_onblur(IHTMLWindow2 *iface, VARIANT v)
 779 {
 780     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 781     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
 782     return E_NOTIMPL;
 783 }
 784
 785 static HRESULT WINAPI HTMLWindow2_get_onblur(IHTMLWindow2 *iface, VARIANT *p)
 786 {
 787     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 788     FIXME("(%p)->(%p)\n", This, p);
 789     return E_NOTIMPL;
 790 }
 791
 792 static HRESULT WINAPI HTMLWindow2_put_onload(IHTMLWindow2 *iface, VARIANT v)
 793 {
 794     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 795
 796     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 797
 798     return set_window_event(This, EVENTID_LOAD, &v);
 799 }
 800
 801 static HRESULT WINAPI HTMLWindow2_get_onload(IHTMLWindow2 *iface, VARIANT *p)
 802 {
 803     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 804
 805     TRACE("(%p)->(%p)\n", This, p);
 806
 807     return get_window_event(This, EVENTID_LOAD, p);
 808 }
 809
 810 static HRESULT WINAPI HTMLWindow2_put_onbeforeunload(IHTMLWindow2 *iface, VARIANT v)
 811 {
 812     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 813
 814     TRACE("(%p)->(v(%d))\n", This, V_VT(&v));
 815
 816     return set_window_event(This, EVENTID_BEFOREUNLOAD, &v);
 817 }
 818
 819 static HRESULT WINAPI HTMLWindow2_get_onbeforeunload(IHTMLWindow2 *iface, VARIANT *p)
 820 {
 821     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 822
 823     TRACE("(%p)->(%p)\n", This, p);
 824
 825     return get_window_event(This, EVENTID_BEFOREUNLOAD, p);
 826 }
 827
 828 static HRESULT WINAPI HTMLWindow2_put_onunload(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_onunload(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_onhelp(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_onhelp(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_onerror(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_onerror(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_onresize(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_onresize(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_put_onscroll(IHTMLWindow2 *iface, VARIANT v)
 885 {
 886     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 887     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
 888     return E_NOTIMPL;
 889 }
 890
 891 static HRESULT WINAPI HTMLWindow2_get_onscroll(IHTMLWindow2 *iface, VARIANT *p)
 892 {
 893     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 894     FIXME("(%p)->(%p)\n", This, p);
 895     return E_NOTIMPL;
 896 }
 897
 898 static HRESULT WINAPI HTMLWindow2_get_document(IHTMLWindow2 *iface, IHTMLDocument2 **p)
 899 {
 900     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 901
 902     TRACE("(%p)->(%p)\n", This, p);
 903
 904     if(This->doc) {
 905         /* FIXME: We should return a wrapper object here */
 906         *p = HTMLDOC(&This->doc->basedoc);
 907         IHTMLDocument2_AddRef(*p);
 908     }else {
 909         *p = NULL;
 910     }
 911
 912     return S_OK;
 913 }
 914
 915 static HRESULT WINAPI HTMLWindow2_get_event(IHTMLWindow2 *iface, IHTMLEventObj **p)
 916 {
 917     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 918
 919     TRACE("(%p)->(%p)\n", This, p);
 920
 921     if(This->event)
 922         IHTMLEventObj_AddRef(This->event);
 923     *p = This->event;
 924     return S_OK;
 925 }
 926
 927 static HRESULT WINAPI HTMLWindow2_get__newEnum(IHTMLWindow2 *iface, IUnknown **p)
 928 {
 929     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 930     FIXME("(%p)->(%p)\n", This, p);
 931     return E_NOTIMPL;
 932 }
 933
 934 static HRESULT WINAPI HTMLWindow2_showModalDialog(IHTMLWindow2 *iface, BSTR dialog,
 935         VARIANT *varArgIn, VARIANT *varOptions, VARIANT *varArgOut)
 936 {
 937     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 938     FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_w(dialog), varArgIn, varOptions, varArgOut);
 939     return E_NOTIMPL;
 940 }
 941
 942 static HRESULT WINAPI HTMLWindow2_showHelp(IHTMLWindow2 *iface, BSTR helpURL, VARIANT helpArg,
 943         BSTR features)
 944 {
 945     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 946     FIXME("(%p)->(%s v(%d) %s)\n", This, debugstr_w(helpURL), V_VT(&helpArg), debugstr_w(features));
 947     return E_NOTIMPL;
 948 }
 949
 950 static HRESULT WINAPI HTMLWindow2_get_screen(IHTMLWindow2 *iface, IHTMLScreen **p)
 951 {
 952     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 953
 954     TRACE("(%p)->(%p)\n", This, p);
 955
 956     if(!This->screen) {
 957         HRESULT hres;
 958
 959         hres = HTMLScreen_Create(&This->screen);
 960         if(FAILED(hres))
 961             return hres;
 962     }
 963
 964     *p = This->screen;
 965     IHTMLScreen_AddRef(This->screen);
 966     return S_OK;
 967 }
 968
 969 static HRESULT WINAPI HTMLWindow2_get_Option(IHTMLWindow2 *iface, IHTMLOptionElementFactory **p)
 970 {
 971     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 972
 973     TRACE("(%p)->(%p)\n", This, p);
 974
 975     if(!This->option_factory)
 976         This->option_factory = HTMLOptionElementFactory_Create(This);
 977
 978     *p = HTMLOPTFACTORY(This->option_factory);
 979     IHTMLOptionElementFactory_AddRef(*p);
 980
 981     return S_OK;
 982 }
 983
 984 static HRESULT WINAPI HTMLWindow2_focus(IHTMLWindow2 *iface)
 985 {
 986     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 987     FIXME("(%p)->()\n", This);
 988     return E_NOTIMPL;
 989 }
 990
 991 static HRESULT WINAPI HTMLWindow2_get_closed(IHTMLWindow2 *iface, VARIANT_BOOL *p)
 992 {
 993     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
 994     FIXME("(%p)->(%p)\n", This, p);
 995     return E_NOTIMPL;
 996 }
 997
 998 static HRESULT WINAPI HTMLWindow2_blur(IHTMLWindow2 *iface)
 999 {
1000     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1001     FIXME("(%p)->()\n", This);
1002     return E_NOTIMPL;
1003 }
1004
1005 static HRESULT WINAPI HTMLWindow2_scroll(IHTMLWindow2 *iface, LONG x, LONG y)
1006 {
1007     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1008     FIXME("(%p)->(%d %d)\n", This, x, y);
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI HTMLWindow2_get_clientInformation(IHTMLWindow2 *iface, IOmNavigator **p)
1013 {
1014     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1015     FIXME("(%p)->(%p)\n", This, p);
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI HTMLWindow2_setInterval(IHTMLWindow2 *iface, BSTR expression,
1020         LONG msec, VARIANT *language, LONG *timerID)
1021 {
1022     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1023     VARIANT expr;
1024
1025     TRACE("(%p)->(%s %d %p %p)\n", This, debugstr_w(expression), msec, language, timerID);
1026
1027     V_VT(&expr) = VT_BSTR;
1028     V_BSTR(&expr) = expression;
1029     return IHTMLWindow3_setInterval(HTMLWINDOW3(This), &expr, msec, language, timerID);
1030 }
1031
1032 static HRESULT WINAPI HTMLWindow2_clearInterval(IHTMLWindow2 *iface, LONG timerID)
1033 {
1034     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1035
1036     TRACE("(%p)->(%d)\n", This, timerID);
1037
1038     return clear_task_timer(&This->doc->basedoc, TRUE, timerID);
1039 }
1040
1041 static HRESULT WINAPI HTMLWindow2_put_offscreenBuffering(IHTMLWindow2 *iface, VARIANT v)
1042 {
1043     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1044     FIXME("(%p)->(v(%d))\n", This, V_VT(&v));
1045     return E_NOTIMPL;
1046 }
1047
1048 static HRESULT WINAPI HTMLWindow2_get_offscreenBuffering(IHTMLWindow2 *iface, VARIANT *p)
1049 {
1050     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1051     FIXME("(%p)->(%p)\n", This, p);
1052     return E_NOTIMPL;
1053 }
1054
1055 static HRESULT WINAPI HTMLWindow2_execScript(IHTMLWindow2 *iface, BSTR scode, BSTR language,
1056         VARIANT *pvarRet)
1057 {
1058     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1059     FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(scode), debugstr_w(language), pvarRet);
1060     return E_NOTIMPL;
1061 }
1062
1063 static HRESULT WINAPI HTMLWindow2_toString(IHTMLWindow2 *iface, BSTR *String)
1064 {
1065     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1066
1067     static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
1068
1069     TRACE("(%p)->(%p)\n", This, String);
1070
1071     if(!String)
1072         return E_INVALIDARG;
1073
1074     *String = SysAllocString(objectW);
1075     return *String ? S_OK : E_OUTOFMEMORY;
1076 }
1077
1078 static HRESULT WINAPI HTMLWindow2_scrollBy(IHTMLWindow2 *iface, LONG x, LONG y)
1079 {
1080     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1081     nsresult nsres;
1082
1083     TRACE("(%p)->(%d %d)\n", This, x, y);
1084
1085     nsres = nsIDOMWindow_ScrollBy(This->nswindow, x, y);
1086     if(NS_FAILED(nsres))
1087         ERR("ScrollBy failed: %08x\n", nsres);
1088
1089     return S_OK;
1090 }
1091
1092 static HRESULT WINAPI HTMLWindow2_scrollTo(IHTMLWindow2 *iface, LONG x, LONG y)
1093 {
1094     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1095     nsresult nsres;
1096
1097     TRACE("(%p)->(%d %d)\n", This, x, y);
1098
1099     nsres = nsIDOMWindow_ScrollTo(This->nswindow, x, y);
1100     if(NS_FAILED(nsres))
1101         ERR("ScrollTo failed: %08x\n", nsres);
1102
1103     return S_OK;
1104 }
1105
1106 static HRESULT WINAPI HTMLWindow2_moveTo(IHTMLWindow2 *iface, LONG x, LONG y)
1107 {
1108     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1109     FIXME("(%p)->(%d %d)\n", This, x, y);
1110     return E_NOTIMPL;
1111 }
1112
1113 static HRESULT WINAPI HTMLWindow2_moveBy(IHTMLWindow2 *iface, LONG x, LONG y)
1114 {
1115     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1116     FIXME("(%p)->(%d %d)\n", This, x, y);
1117     return E_NOTIMPL;
1118 }
1119
1120 static HRESULT WINAPI HTMLWindow2_resizeTo(IHTMLWindow2 *iface, LONG x, LONG y)
1121 {
1122     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1123     FIXME("(%p)->(%d %d)\n", This, x, y);
1124     return E_NOTIMPL;
1125 }
1126
1127 static HRESULT WINAPI HTMLWindow2_resizeBy(IHTMLWindow2 *iface, LONG x, LONG y)
1128 {
1129     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1130     FIXME("(%p)->(%d %d)\n", This, x, y);
1131     return E_NOTIMPL;
1132 }
1133
1134 static HRESULT WINAPI HTMLWindow2_get_external(IHTMLWindow2 *iface, IDispatch **p)
1135 {
1136     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1137
1138     TRACE("(%p)->(%p)\n", This, p);
1139
1140     *p = NULL;
1141
1142     if(!This->doc_obj->hostui)
1143         return S_OK;
1144
1145     return IDocHostUIHandler_GetExternal(This->doc_obj->hostui, p);
1146 }
1147
1148 static HRESULT HTMLWindow_invoke(IUnknown *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
1149         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
1150 {
1151     HTMLWindow *This = HTMLWINDOW2_THIS(iface);
1152     global_prop_t *prop;
1153     DWORD idx;
1154     HRESULT hres;
1155
1156     idx = id - MSHTML_DISPID_CUSTOM_MIN;
1157     if(idx >= This->global_prop_cnt)
1158         return DISP_E_MEMBERNOTFOUND;
1159
1160     prop = This->global_props+idx;
1161
1162     switch(prop->type) {
1163     case GLOBAL_SCRIPTVAR: {
1164         IDispatchEx *dispex;
1165         IDispatch *disp;
1166
1167         disp = get_script_disp(prop->script_host);
1168         if(!disp)
1169             return E_UNEXPECTED;
1170
1171         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1172         if(SUCCEEDED(hres)) {
1173             TRACE("%s >>>\n", debugstr_w(prop->name));
1174             hres = IDispatchEx_InvokeEx(dispex, prop->id, lcid, flags, params, res, ei, caller);
1175             if(hres == S_OK)
1176                 TRACE("%s <<<\n", debugstr_w(prop->name));
1177             else
1178                 WARN("%s <<< %08x\n", debugstr_w(prop->name), hres);
1179             IDispatchEx_Release(dispex);
1180         }else {
1181             FIXME("No IDispatchEx\n");
1182         }
1183         IDispatch_Release(disp);
1184         break;
1185     }
1186     case GLOBAL_ELEMENTVAR: {
1187         IHTMLElement *elem;
1188
1189         hres = IHTMLDocument3_getElementById(HTMLDOC3(&This->doc->basedoc), prop->name, &elem);
1190         if(FAILED(hres))
1191             return hres;
1192
1193         if(!elem)
1194             return DISP_E_MEMBERNOTFOUND;
1195
1196         V_VT(res) = VT_DISPATCH;
1197         V_DISPATCH(res) = (IDispatch*)elem;
1198         break;
1199     }
1200     default:
1201         ERR("invalid type %d\n", prop->type);
1202         hres = DISP_E_MEMBERNOTFOUND;
1203     }
1204
1205     return hres;
1206 }
1207
1208 #undef HTMLWINDOW2_THIS
1209
1210 static const IHTMLWindow2Vtbl HTMLWindow2Vtbl = {
1211     HTMLWindow2_QueryInterface,
1212     HTMLWindow2_AddRef,
1213     HTMLWindow2_Release,
1214     HTMLWindow2_GetTypeInfoCount,
1215     HTMLWindow2_GetTypeInfo,
1216     HTMLWindow2_GetIDsOfNames,
1217     HTMLWindow2_Invoke,
1218     HTMLWindow2_item,
1219     HTMLWindow2_get_length,
1220     HTMLWindow2_get_frames,
1221     HTMLWindow2_put_defaultStatus,
1222     HTMLWindow2_get_defaultStatus,
1223     HTMLWindow2_put_status,
1224     HTMLWindow2_get_status,
1225     HTMLWindow2_setTimeout,
1226     HTMLWindow2_clearTimeout,
1227     HTMLWindow2_alert,
1228     HTMLWindow2_confirm,
1229     HTMLWindow2_prompt,
1230     HTMLWindow2_get_Image,
1231     HTMLWindow2_get_location,
1232     HTMLWindow2_get_history,
1233     HTMLWindow2_close,
1234     HTMLWindow2_put_opener,
1235     HTMLWindow2_get_opener,
1236     HTMLWindow2_get_navigator,
1237     HTMLWindow2_put_name,
1238     HTMLWindow2_get_name,
1239     HTMLWindow2_get_parent,
1240     HTMLWindow2_open,
1241     HTMLWindow2_get_self,
1242     HTMLWindow2_get_top,
1243     HTMLWindow2_get_window,
1244     HTMLWindow2_navigate,
1245     HTMLWindow2_put_onfocus,
1246     HTMLWindow2_get_onfocus,
1247     HTMLWindow2_put_onblur,
1248     HTMLWindow2_get_onblur,
1249     HTMLWindow2_put_onload,
1250     HTMLWindow2_get_onload,
1251     HTMLWindow2_put_onbeforeunload,
1252     HTMLWindow2_get_onbeforeunload,
1253     HTMLWindow2_put_onunload,
1254     HTMLWindow2_get_onunload,
1255     HTMLWindow2_put_onhelp,
1256     HTMLWindow2_get_onhelp,
1257     HTMLWindow2_put_onerror,
1258     HTMLWindow2_get_onerror,
1259     HTMLWindow2_put_onresize,
1260     HTMLWindow2_get_onresize,
1261     HTMLWindow2_put_onscroll,
1262     HTMLWindow2_get_onscroll,
1263     HTMLWindow2_get_document,
1264     HTMLWindow2_get_event,
1265     HTMLWindow2_get__newEnum,
1266     HTMLWindow2_showModalDialog,
1267     HTMLWindow2_showHelp,
1268     HTMLWindow2_get_screen,
1269     HTMLWindow2_get_Option,
1270     HTMLWindow2_focus,
1271     HTMLWindow2_get_closed,
1272     HTMLWindow2_blur,
1273     HTMLWindow2_scroll,
1274     HTMLWindow2_get_clientInformation,
1275     HTMLWindow2_setInterval,
1276     HTMLWindow2_clearInterval,
1277     HTMLWindow2_put_offscreenBuffering,
1278     HTMLWindow2_get_offscreenBuffering,
1279     HTMLWindow2_execScript,
1280     HTMLWindow2_toString,
1281     HTMLWindow2_scrollBy,
1282     HTMLWindow2_scrollTo,
1283     HTMLWindow2_moveTo,
1284     HTMLWindow2_moveBy,
1285     HTMLWindow2_resizeTo,
1286     HTMLWindow2_resizeBy,
1287     HTMLWindow2_get_external
1288 };
1289
1290 #define HTMLWINDOW3_THIS(iface) DEFINE_THIS(HTMLWindow, HTMLWindow3, iface)
1291
1292 static HRESULT WINAPI HTMLWindow3_QueryInterface(IHTMLWindow3 *iface, REFIID riid, void **ppv)
1293 {
1294     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1295
1296     return IHTMLWindow2_QueryInterface(HTMLWINDOW2(This), riid, ppv);
1297 }
1298
1299 static ULONG WINAPI HTMLWindow3_AddRef(IHTMLWindow3 *iface)
1300 {
1301     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1302
1303     return IHTMLWindow2_AddRef(HTMLWINDOW2(This));
1304 }
1305
1306 static ULONG WINAPI HTMLWindow3_Release(IHTMLWindow3 *iface)
1307 {
1308     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1309
1310     return IHTMLWindow2_Release(HTMLWINDOW2(This));
1311 }
1312
1313 static HRESULT WINAPI HTMLWindow3_GetTypeInfoCount(IHTMLWindow3 *iface, UINT *pctinfo)
1314 {
1315     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1316
1317     return IDispatchEx_GetTypeInfoCount(DISPATCHEX(This), pctinfo);
1318 }
1319
1320 static HRESULT WINAPI HTMLWindow3_GetTypeInfo(IHTMLWindow3 *iface, UINT iTInfo,
1321                                               LCID lcid, ITypeInfo **ppTInfo)
1322 {
1323     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1324
1325     return IDispatchEx_GetTypeInfo(DISPATCHEX(This), iTInfo, lcid, ppTInfo);
1326 }
1327
1328 static HRESULT WINAPI HTMLWindow3_GetIDsOfNames(IHTMLWindow3 *iface, REFIID riid,
1329                                                 LPOLESTR *rgszNames, UINT cNames,
1330                                                 LCID lcid, DISPID *rgDispId)
1331 {
1332     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1333
1334     return IDispatchEx_GetIDsOfNames(DISPATCHEX(This), riid, rgszNames, cNames, lcid, rgDispId);
1335 }
1336
1337 static HRESULT WINAPI HTMLWindow3_Invoke(IHTMLWindow3 *iface, DISPID dispIdMember,
1338                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1339                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1340 {
1341     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1342
1343     return IDispatchEx_Invoke(DISPATCHEX(This), dispIdMember, riid, lcid, wFlags, pDispParams,
1344             pVarResult, pExcepInfo, puArgErr);
1345 }
1346
1347 static HRESULT WINAPI HTMLWindow3_get_screenLeft(IHTMLWindow3 *iface, LONG *p)
1348 {
1349     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1350     FIXME("(%p)->(%p)\n", This, p);
1351     return E_NOTIMPL;
1352 }
1353
1354 static HRESULT WINAPI HTMLWindow3_get_screenTop(IHTMLWindow3 *iface, LONG *p)
1355 {
1356     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1357     FIXME("(%p)->(%p)\n", This, p);
1358     return E_NOTIMPL;
1359 }
1360
1361 static HRESULT WINAPI HTMLWindow3_attachEvent(IHTMLWindow3 *iface, BSTR event, IDispatch *pDisp, VARIANT_BOOL *pfResult)
1362 {
1363     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1364
1365     TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
1366
1367     return attach_event(&This->event_target, &This->doc_obj->basedoc, event, pDisp, pfResult);
1368 }
1369
1370 static HRESULT WINAPI HTMLWindow3_detachEvent(IHTMLWindow3 *iface, BSTR event, IDispatch *pDisp)
1371 {
1372     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1373     FIXME("(%p)->()\n", This);
1374     return E_NOTIMPL;
1375 }
1376
1377 static HRESULT window_set_timer(HTMLWindow *This, VARIANT *expr, LONG msec, VARIANT *language,
1378         BOOL interval, LONG *timer_id)
1379 {
1380     IDispatch *disp = NULL;
1381
1382     switch(V_VT(expr)) {
1383     case VT_DISPATCH:
1384         disp = V_DISPATCH(expr);
1385         IDispatch_AddRef(disp);
1386         break;
1387
1388     case VT_BSTR:
1389         disp = script_parse_event(This, V_BSTR(expr));
1390         break;
1391
1392     default:
1393         FIXME("unimplemented vt=%d\n", V_VT(expr));
1394         return E_NOTIMPL;
1395     }
1396
1397     if(!disp)
1398         return E_FAIL;
1399
1400     *timer_id = set_task_timer(&This->doc->basedoc, msec, interval, disp);
1401     IDispatch_Release(disp);
1402
1403     return S_OK;
1404 }
1405
1406 static HRESULT WINAPI HTMLWindow3_setTimeout(IHTMLWindow3 *iface, VARIANT *expression, LONG msec,
1407         VARIANT *language, LONG *timerID)
1408 {
1409     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1410
1411     TRACE("(%p)->(%p(%d) %d %p %p)\n", This, expression, V_VT(expression), msec, language, timerID);
1412
1413     return window_set_timer(This, expression, msec, language, FALSE, timerID);
1414 }
1415
1416 static HRESULT WINAPI HTMLWindow3_setInterval(IHTMLWindow3 *iface, VARIANT *expression, LONG msec,
1417         VARIANT *language, LONG *timerID)
1418 {
1419     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1420
1421     TRACE("(%p)->(%p %d %p %p)\n", This, expression, msec, language, timerID);
1422
1423     return window_set_timer(This, expression, msec, language, TRUE, timerID);
1424 }
1425
1426 static HRESULT WINAPI HTMLWindow3_print(IHTMLWindow3 *iface)
1427 {
1428     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1429     FIXME("(%p)\n", This);
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT WINAPI HTMLWindow3_put_onbeforeprint(IHTMLWindow3 *iface, VARIANT v)
1434 {
1435     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1436     FIXME("(%p)->()\n", This);
1437     return E_NOTIMPL;
1438 }
1439
1440 static HRESULT WINAPI HTMLWindow3_get_onbeforeprint(IHTMLWindow3 *iface, VARIANT *p)
1441 {
1442     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1443     FIXME("(%p)->(%p)\n", This, p);
1444     return E_NOTIMPL;
1445 }
1446
1447 static HRESULT WINAPI HTMLWindow3_put_onafterprint(IHTMLWindow3 *iface, VARIANT v)
1448 {
1449     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1450     FIXME("(%p)->()\n", This);
1451     return E_NOTIMPL;
1452 }
1453
1454 static HRESULT WINAPI HTMLWindow3_get_onafterprint(IHTMLWindow3 *iface, VARIANT *p)
1455 {
1456     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1457     FIXME("(%p)->(%p)\n", This, p);
1458     return E_NOTIMPL;
1459 }
1460
1461 static HRESULT WINAPI HTMLWindow3_get_clipboardData(IHTMLWindow3 *iface, IHTMLDataTransfer **p)
1462 {
1463     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1464     FIXME("(%p)->(%p)\n", This, p);
1465     return E_NOTIMPL;
1466 }
1467
1468 static HRESULT WINAPI HTMLWindow3_showModelessDialog(IHTMLWindow3 *iface, BSTR url,
1469         VARIANT *varArgIn, VARIANT *options, IHTMLWindow2 **pDialog)
1470 {
1471     HTMLWindow *This = HTMLWINDOW3_THIS(iface);
1472     FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_w(url), varArgIn, options, pDialog);
1473     return E_NOTIMPL;
1474 }
1475
1476 #undef HTMLWINDOW3_THIS
1477
1478 static const IHTMLWindow3Vtbl HTMLWindow3Vtbl = {
1479     HTMLWindow3_QueryInterface,
1480     HTMLWindow3_AddRef,
1481     HTMLWindow3_Release,
1482     HTMLWindow3_GetTypeInfoCount,
1483     HTMLWindow3_GetTypeInfo,
1484     HTMLWindow3_GetIDsOfNames,
1485     HTMLWindow3_Invoke,
1486     HTMLWindow3_get_screenLeft,
1487     HTMLWindow3_get_screenTop,
1488     HTMLWindow3_attachEvent,
1489     HTMLWindow3_detachEvent,
1490     HTMLWindow3_setTimeout,
1491     HTMLWindow3_setInterval,
1492     HTMLWindow3_print,
1493     HTMLWindow3_put_onbeforeprint,
1494     HTMLWindow3_get_onbeforeprint,
1495     HTMLWindow3_put_onafterprint,
1496     HTMLWindow3_get_onafterprint,
1497     HTMLWindow3_get_clipboardData,
1498     HTMLWindow3_showModelessDialog
1499 };
1500
1501 #define HTMLWINDOW4_THIS(iface) DEFINE_THIS(HTMLWindow, HTMLWindow4, iface)
1502
1503 static HRESULT WINAPI HTMLWindow4_QueryInterface(IHTMLWindow4 *iface, REFIID riid, void **ppv)
1504 {
1505     HTMLWindow *This = HTMLWINDOW4_THIS(iface);
1506
1507     return IHTMLWindow2_QueryInterface(HTMLWINDOW2(This), riid, ppv);
1508 }
1509
1510 static ULONG WINAPI HTMLWindow4_AddRef(IHTMLWindow4 *iface)
1511 {
1512     HTMLWindow *This = HTMLWINDOW4_THIS(iface);
1513
1514     return IHTMLWindow2_AddRef(HTMLWINDOW2(This));
1515 }
1516
1517 static ULONG WINAPI HTMLWindow4_Release(IHTMLWindow4 *iface)
1518 {
1519     HTMLWindow *This = HTMLWINDOW4_THIS(iface);
1520
1521     return IHTMLWindow2_Release(HTMLWINDOW2(This));
1522 }
1523
1524 static HRESULT WINAPI HTMLWindow4_GetTypeInfoCount(IHTMLWindow4 *iface, UINT *pctinfo)
1525 {
1526     HTMLWindow *This = HTMLWINDOW4_THIS(iface);
1527
1528     return IDispatchEx_GetTypeInfoCount(DISPATCHEX(This), pctinfo);
1529 }
1530
1531 static HRESULT WINAPI HTMLWindow4_GetTypeInfo(IHTMLWindow4 *iface, UINT iTInfo,
1532                                               LCID lcid, ITypeInfo **ppTInfo)
1533 {
1534     HTMLWindow *This = HTMLWINDOW4_THIS(iface);
1535
1536     return IDispatchEx_GetTypeInfo(DISPATCHEX(This), iTInfo, lcid, ppTInfo);
1537 }
1538
1539 static HRESULT WINAPI HTMLWindow4_GetIDsOfNames(IHTMLWindow4 *iface, REFIID riid,
1540                                                 LPOLESTR *rgszNames, UINT cNames,
1541                                                 LCID lcid, DISPID *rgDispId)
1542 {
1543     HTMLWindow *This = HTMLWINDOW4_THIS(iface);
1544
1545     return IDispatchEx_GetIDsOfNames(DISPATCHEX(This), riid, rgszNames, cNames, lcid, rgDispId);
1546 }
1547
1548 static HRESULT WINAPI HTMLWindow4_Invoke(IHTMLWindow4 *iface, DISPID dispIdMember,
1549                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1550                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1551 {
1552     HTMLWindow *This = HTMLWINDOW4_THIS(iface);
1553
1554     return IDispatchEx_Invoke(DISPATCHEX(This), dispIdMember, riid, lcid, wFlags, pDispParams,
1555             pVarResult, pExcepInfo, puArgErr);
1556 }
1557
1558 static HRESULT WINAPI HTMLWindow4_createPopup(IHTMLWindow4 *iface, VARIANT *varArgIn,
1559                             IDispatch **ppPopup)
1560 {
1561     HTMLWindow *This = HTMLWINDOW4_THIS(iface);
1562     FIXME("(%p)->(%p %p)\n", This, varArgIn, ppPopup);
1563     return E_NOTIMPL;
1564 }
1565
1566 static HRESULT WINAPI HTMLWindow4_get_frameElement(IHTMLWindow4 *iface, IHTMLFrameBase **p)
1567 {
1568     HTMLWindow *This = HTMLWINDOW4_THIS(iface);
1569     TRACE("(%p)->(%p)\n", This, p);
1570
1571     if(This->frame_element) {
1572         *p = HTMLFRAMEBASE(This->frame_element);
1573         IHTMLFrameBase_AddRef(*p);
1574     }else
1575         *p = NULL;
1576
1577     return S_OK;
1578 }
1579
1580 #undef HTMLWINDOW4_THIS
1581
1582 static const IHTMLWindow4Vtbl HTMLWindow4Vtbl = {
1583     HTMLWindow4_QueryInterface,
1584     HTMLWindow4_AddRef,
1585     HTMLWindow4_Release,
1586     HTMLWindow4_GetTypeInfoCount,
1587     HTMLWindow4_GetTypeInfo,
1588     HTMLWindow4_GetIDsOfNames,
1589     HTMLWindow4_Invoke,
1590     HTMLWindow4_createPopup,
1591     HTMLWindow4_get_frameElement
1592 };
1593
1594 #define DISPEX_THIS(iface) DEFINE_THIS(HTMLWindow, IDispatchEx, iface)
1595
1596 static HRESULT WINAPI WindowDispEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
1597 {
1598     HTMLWindow *This = DISPEX_THIS(iface);
1599
1600     return IHTMLWindow2_QueryInterface(HTMLWINDOW2(This), riid, ppv);
1601 }
1602
1603 static ULONG WINAPI WindowDispEx_AddRef(IDispatchEx *iface)
1604 {
1605     HTMLWindow *This = DISPEX_THIS(iface);
1606
1607     return IHTMLWindow2_AddRef(HTMLWINDOW2(This));
1608 }
1609
1610 static ULONG WINAPI WindowDispEx_Release(IDispatchEx *iface)
1611 {
1612     HTMLWindow *This = DISPEX_THIS(iface);
1613
1614     return IHTMLWindow2_Release(HTMLWINDOW2(This));
1615 }
1616
1617 static HRESULT WINAPI WindowDispEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
1618 {
1619     HTMLWindow *This = DISPEX_THIS(iface);
1620
1621     TRACE("(%p)->(%p)\n", This, pctinfo);
1622
1623     return IDispatchEx_GetTypeInfoCount(DISPATCHEX(&This->dispex), pctinfo);
1624 }
1625
1626 static HRESULT WINAPI WindowDispEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
1627                                                LCID lcid, ITypeInfo **ppTInfo)
1628 {
1629     HTMLWindow *This = DISPEX_THIS(iface);
1630
1631     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1632
1633     return IDispatchEx_GetTypeInfo(DISPATCHEX(&This->dispex), iTInfo, lcid, ppTInfo);
1634 }
1635
1636 static HRESULT WINAPI WindowDispEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
1637                                                  LPOLESTR *rgszNames, UINT cNames,
1638                                                  LCID lcid, DISPID *rgDispId)
1639 {
1640     HTMLWindow *This = DISPEX_THIS(iface);
1641
1642     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1643           lcid, rgDispId);
1644
1645     /* FIXME: Use script dispatch */
1646
1647     return IDispatchEx_GetIDsOfNames(DISPATCHEX(&This->dispex), riid, rgszNames, cNames, lcid, rgDispId);
1648 }
1649
1650 static HRESULT WINAPI WindowDispEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
1651                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1652                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1653 {
1654     HTMLWindow *This = DISPEX_THIS(iface);
1655
1656     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1657           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1658
1659     /* FIXME: Use script dispatch */
1660
1661     return IDispatchEx_Invoke(DISPATCHEX(&This->dispex), dispIdMember, riid, lcid, wFlags, pDispParams,
1662                               pVarResult, pExcepInfo, puArgErr);
1663 }
1664
1665 static global_prop_t *alloc_global_prop(HTMLWindow *This, global_prop_type_t type, BSTR name)
1666 {
1667     if(This->global_prop_cnt == This->global_prop_size) {
1668         global_prop_t *new_props;
1669         DWORD new_size;
1670
1671         if(This->global_props) {
1672             new_size = This->global_prop_size*2;
1673             new_props = heap_realloc(This->global_props, new_size*sizeof(global_prop_t));
1674         }else {
1675             new_size = 16;
1676             new_props = heap_alloc(new_size*sizeof(global_prop_t));
1677         }
1678         if(!new_props)
1679             return NULL;
1680         This->global_props = new_props;
1681         This->global_prop_size = new_size;
1682     }
1683
1684     This->global_props[This->global_prop_cnt].name = heap_strdupW(name);
1685     if(!This->global_props[This->global_prop_cnt].name)
1686         return NULL;
1687
1688     This->global_props[This->global_prop_cnt].type = type;
1689     return This->global_props + This->global_prop_cnt++;
1690 }
1691
1692 static inline DWORD prop_to_dispid(HTMLWindow *This, global_prop_t *prop)
1693 {
1694     return MSHTML_DISPID_CUSTOM_MIN + (prop-This->global_props);
1695 }
1696
1697 static HRESULT WINAPI WindowDispEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
1698 {
1699     HTMLWindow *This = DISPEX_THIS(iface);
1700     ScriptHost *script_host;
1701     DISPID id;
1702     DWORD i;
1703     HRESULT hres;
1704
1705     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
1706
1707     for(i=0; i < This->global_prop_cnt; i++) {
1708         /* FIXME: case sensitivity */
1709         if(!strcmpW(This->global_props[i].name, bstrName)) {
1710             *pid = MSHTML_DISPID_CUSTOM_MIN+i;
1711             return S_OK;
1712         }
1713     }
1714
1715     if(find_global_prop(This, bstrName, grfdex, &script_host, &id)) {
1716         global_prop_t *prop;
1717
1718         prop = alloc_global_prop(This, GLOBAL_SCRIPTVAR, bstrName);
1719         if(!prop)
1720             return E_OUTOFMEMORY;
1721
1722         prop->script_host = script_host;
1723         prop->id = id;
1724
1725         *pid = prop_to_dispid(This, prop);
1726         return S_OK;
1727     }
1728
1729     hres = IDispatchEx_GetDispID(DISPATCHEX(&This->dispex), bstrName, grfdex, pid);
1730     if(hres != DISP_E_UNKNOWNNAME)
1731         return hres;
1732
1733     if(This->doc) {
1734         global_prop_t *prop;
1735         IHTMLElement *elem;
1736
1737         hres = IHTMLDocument3_getElementById(HTMLDOC3(&This->doc->basedoc), bstrName, &elem);
1738         if(SUCCEEDED(hres) && elem) {
1739             IHTMLElement_Release(elem);
1740
1741             prop = alloc_global_prop(This, GLOBAL_ELEMENTVAR, bstrName);
1742             if(!prop)
1743                 return E_OUTOFMEMORY;
1744
1745             *pid = prop_to_dispid(This, prop);
1746             return S_OK;
1747         }
1748     }
1749
1750     return DISP_E_UNKNOWNNAME;
1751 }
1752
1753 static HRESULT WINAPI WindowDispEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1754         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1755 {
1756     HTMLWindow *This = DISPEX_THIS(iface);
1757
1758     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
1759
1760     return IDispatchEx_InvokeEx(DISPATCHEX(&This->dispex), id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
1761 }
1762
1763 static HRESULT WINAPI WindowDispEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
1764 {
1765     HTMLWindow *This = DISPEX_THIS(iface);
1766
1767     TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
1768
1769     return IDispatchEx_DeleteMemberByName(DISPATCHEX(&This->dispex), bstrName, grfdex);
1770 }
1771
1772 static HRESULT WINAPI WindowDispEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
1773 {
1774     HTMLWindow *This = DISPEX_THIS(iface);
1775
1776     TRACE("(%p)->(%x)\n", This, id);
1777
1778     return IDispatchEx_DeleteMemberByDispID(DISPATCHEX(&This->dispex), id);
1779 }
1780
1781 static HRESULT WINAPI WindowDispEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
1782 {
1783     HTMLWindow *This = DISPEX_THIS(iface);
1784
1785     TRACE("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
1786
1787     return IDispatchEx_GetMemberProperties(DISPATCHEX(&This->dispex), id, grfdexFetch, pgrfdex);
1788 }
1789
1790 static HRESULT WINAPI WindowDispEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
1791 {
1792     HTMLWindow *This = DISPEX_THIS(iface);
1793
1794     TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
1795
1796     return IDispatchEx_GetMemberName(DISPATCHEX(&This->dispex), id, pbstrName);
1797 }
1798
1799 static HRESULT WINAPI WindowDispEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
1800 {
1801     HTMLWindow *This = DISPEX_THIS(iface);
1802
1803     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
1804
1805     return IDispatchEx_GetNextDispID(DISPATCHEX(&This->dispex), grfdex, id, pid);
1806 }
1807
1808 static HRESULT WINAPI WindowDispEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
1809 {
1810     HTMLWindow *This = DISPEX_THIS(iface);
1811
1812     TRACE("(%p)->(%p)\n", This, ppunk);
1813
1814     *ppunk = NULL;
1815     return S_OK;
1816 }
1817
1818 #undef DISPEX_THIS
1819
1820 static const IDispatchExVtbl WindowDispExVtbl = {
1821     WindowDispEx_QueryInterface,
1822     WindowDispEx_AddRef,
1823     WindowDispEx_Release,
1824     WindowDispEx_GetTypeInfoCount,
1825     WindowDispEx_GetTypeInfo,
1826     WindowDispEx_GetIDsOfNames,
1827     WindowDispEx_Invoke,
1828     WindowDispEx_GetDispID,
1829     WindowDispEx_InvokeEx,
1830     WindowDispEx_DeleteMemberByName,
1831     WindowDispEx_DeleteMemberByDispID,
1832     WindowDispEx_GetMemberProperties,
1833     WindowDispEx_GetMemberName,
1834     WindowDispEx_GetNextDispID,
1835     WindowDispEx_GetNameSpaceParent
1836 };
1837
1838 static const tid_t HTMLWindow_iface_tids[] = {
1839     IHTMLWindow2_tid,
1840     IHTMLWindow3_tid,
1841     IHTMLWindow4_tid,
1842     0
1843 };
1844
1845 static const dispex_static_data_vtbl_t HTMLWindow_dispex_vtbl = {
1846     NULL,
1847     NULL,
1848     HTMLWindow_invoke
1849 };
1850
1851 static dispex_static_data_t HTMLWindow_dispex = {
1852     &HTMLWindow_dispex_vtbl,
1853     DispHTMLWindow2_tid,
1854     NULL,
1855     HTMLWindow_iface_tids
1856 };
1857
1858 HRESULT HTMLWindow_Create(HTMLDocumentObj *doc_obj, nsIDOMWindow *nswindow, HTMLWindow *parent, HTMLWindow **ret)
1859 {
1860     HTMLWindow *window;
1861
1862     window = heap_alloc_zero(sizeof(HTMLWindow));
1863     if(!window)
1864         return E_OUTOFMEMORY;
1865
1866     window->window_ref = heap_alloc(sizeof(windowref_t));
1867     if(!window->window_ref) {
1868         heap_free(window);
1869         return E_OUTOFMEMORY;
1870     }
1871
1872     window->lpHTMLWindow2Vtbl = &HTMLWindow2Vtbl;
1873     window->lpHTMLWindow3Vtbl = &HTMLWindow3Vtbl;
1874     window->lpHTMLWindow4Vtbl = &HTMLWindow4Vtbl;
1875     window->lpIDispatchExVtbl = &WindowDispExVtbl;
1876     window->ref = 1;
1877     window->doc_obj = doc_obj;
1878
1879     window->window_ref->window = window;
1880     window->window_ref->ref = 1;
1881
1882     init_dispex(&window->dispex, (IUnknown*)HTMLWINDOW2(window), &HTMLWindow_dispex);
1883
1884     if(nswindow) {
1885         nsIDOMWindow_AddRef(nswindow);
1886         window->nswindow = nswindow;
1887     }
1888
1889     window->scriptmode = parent ? parent->scriptmode : SCRIPTMODE_GECKO;
1890     window->readystate = READYSTATE_UNINITIALIZED;
1891     list_init(&window->script_hosts);
1892
1893     window->task_magic = get_task_target_magic();
1894     update_window_doc(window);
1895
1896     list_init(&window->children);
1897     list_add_head(&window_list, &window->entry);
1898
1899     if(parent) {
1900         IHTMLWindow2_AddRef(HTMLWINDOW2(window));
1901
1902         window->parent = parent;
1903         list_add_tail(&parent->children, &window->sibling_entry);
1904     }
1905
1906     *ret = window;
1907     return S_OK;
1908 }
1909
1910 void update_window_doc(HTMLWindow *window)
1911 {
1912     nsIDOMHTMLDocument *nshtmldoc;
1913     nsIDOMDocument *nsdoc;
1914     nsresult nsres;
1915
1916     nsres = nsIDOMWindow_GetDocument(window->nswindow, &nsdoc);
1917     if(NS_FAILED(nsres) || !nsdoc) {
1918         ERR("GetDocument failed: %08x\n", nsres);
1919         return;
1920     }
1921
1922     nsres = nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMHTMLDocument, (void**)&nshtmldoc);
1923     nsIDOMDocument_Release(nsdoc);
1924     if(NS_FAILED(nsres)) {
1925         ERR("Could not get nsIDOMHTMLDocument iface: %08x\n", nsres);
1926         return;
1927     }
1928
1929     if(!window->doc || window->doc->nsdoc != nshtmldoc) {
1930         HTMLDocumentNode *doc;
1931         HRESULT hres;
1932
1933         hres = create_doc_from_nsdoc(nshtmldoc, window->doc_obj, window, &doc);
1934         if(SUCCEEDED(hres)) {
1935             window_set_docnode(window, doc);
1936             htmldoc_release(&doc->basedoc);
1937         }else {
1938             ERR("create_doc_from_nsdoc failed: %08x\n", hres);
1939         }
1940     }
1941
1942     nsIDOMHTMLDocument_Release(nshtmldoc);
1943 }
1944
1945 HTMLWindow *nswindow_to_window(const nsIDOMWindow *nswindow)
1946 {
1947     HTMLWindow *iter;
1948
1949     LIST_FOR_EACH_ENTRY(iter, &window_list, HTMLWindow, entry) {
1950         if(iter->nswindow == nswindow)
1951             return iter;
1952     }
1953
1954     return NULL;
1955 }