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