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