?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
makefiles: Explicitly create destination dirs when installing symlinks.
[wine/zf.git] / dlls / mshtml / htmldoc.c
blob0fd039bfa606666daced54788d1c991ab02596c3
1 /*
2 * Copyright 2005-2009 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 <stdio.h>
21 #include <assert.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "wininet.h"
29 #include "ole2.h"
30 #include "perhist.h"
31 #include "mshtmdid.h"
32 #include "mshtmcid.h"
33
34 #include "wine/debug.h"
35
36 #include "mshtml_private.h"
37 #include "htmlevent.h"
38 #include "pluginhost.h"
39 #include "binding.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
42
43 static HRESULT create_document_fragment(nsIDOMNode *nsnode, HTMLDocumentNode *doc_node, HTMLDocumentNode **ret);
44
45 HRESULT get_doc_elem_by_id(HTMLDocumentNode *doc, const WCHAR *id, HTMLElement **ret)
46 {
47 nsIDOMNodeList *nsnode_list;
48 nsIDOMElement *nselem;
49 nsIDOMNode *nsnode;
50 nsAString id_str;
51 nsresult nsres;
52 HRESULT hres;
53
54 if(!doc->nsdoc) {
55 WARN("NULL nsdoc\n");
56 return E_UNEXPECTED;
57 }
58
59 nsAString_InitDepend(&id_str, id);
60 /* get element by id attribute */
61 nsres = nsIDOMHTMLDocument_GetElementById(doc->nsdoc, &id_str, &nselem);
62 if(FAILED(nsres)) {
63 ERR("GetElementById failed: %08x\n", nsres);
64 nsAString_Finish(&id_str);
65 return E_FAIL;
66 }
67
68 /* get first element by name attribute */
69 nsres = nsIDOMHTMLDocument_GetElementsByName(doc->nsdoc, &id_str, &nsnode_list);
70 nsAString_Finish(&id_str);
71 if(FAILED(nsres)) {
72 ERR("getElementsByName failed: %08x\n", nsres);
73 if(nselem)
74 nsIDOMElement_Release(nselem);
75 return E_FAIL;
76 }
77
78 nsres = nsIDOMNodeList_Item(nsnode_list, 0, &nsnode);
79 nsIDOMNodeList_Release(nsnode_list);
80 assert(nsres == NS_OK);
81
82 if(nsnode && nselem) {
83 UINT16 pos;
84
85 nsres = nsIDOMNode_CompareDocumentPosition(nsnode, (nsIDOMNode*)nselem, &pos);
86 if(NS_FAILED(nsres)) {
87 FIXME("CompareDocumentPosition failed: 0x%08x\n", nsres);
88 nsIDOMNode_Release(nsnode);
89 nsIDOMElement_Release(nselem);
90 return E_FAIL;
91 }
92
93 TRACE("CompareDocumentPosition gave: 0x%x\n", pos);
94 if(!(pos & (DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS))) {
95 nsIDOMElement_Release(nselem);
96 nselem = NULL;
97 }
98 }
99
100 if(nsnode) {
101 if(!nselem) {
102 nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMElement, (void**)&nselem);
103 assert(nsres == NS_OK);
104 }
105 nsIDOMNode_Release(nsnode);
106 }
107
108 if(!nselem) {
109 *ret = NULL;
110 return S_OK;
111 }
112
113 hres = get_element(nselem, ret);
114 nsIDOMElement_Release(nselem);
115 return hres;
116 }
117
118 UINT get_document_charset(HTMLDocumentNode *doc)
119 {
120 nsAString charset_str;
121 UINT ret = 0;
122 nsresult nsres;
123
124 if(doc->charset)
125 return doc->charset;
126
127 nsAString_Init(&charset_str, NULL);
128 nsres = nsIDOMHTMLDocument_GetCharacterSet(doc->nsdoc, &charset_str);
129 if(NS_SUCCEEDED(nsres)) {
130 const PRUnichar *charset;
131
132 nsAString_GetData(&charset_str, &charset);
133
134 if(*charset) {
135 BSTR str = SysAllocString(charset);
136 ret = cp_from_charset_string(str);
137 SysFreeString(str);
138 }
139 }else {
140 ERR("GetCharset failed: %08x\n", nsres);
141 }
142 nsAString_Finish(&charset_str);
143
144 if(!ret)
145 return CP_UTF8;
146
147 return doc->charset = ret;
148 }
149
150 static inline HTMLDocument *impl_from_IHTMLDocument2(IHTMLDocument2 *iface)
151 {
152 return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument2_iface);
153 }
154
155 static HRESULT WINAPI HTMLDocument_QueryInterface(IHTMLDocument2 *iface, REFIID riid, void **ppv)
156 {
157 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
158
159 return htmldoc_query_interface(This, riid, ppv);
160 }
161
162 static ULONG WINAPI HTMLDocument_AddRef(IHTMLDocument2 *iface)
163 {
164 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
165
166 return htmldoc_addref(This);
167 }
168
169 static ULONG WINAPI HTMLDocument_Release(IHTMLDocument2 *iface)
170 {
171 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
172
173 return htmldoc_release(This);
174 }
175
176 static HRESULT WINAPI HTMLDocument_GetTypeInfoCount(IHTMLDocument2 *iface, UINT *pctinfo)
177 {
178 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
179
180 return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
181 }
182
183 static HRESULT WINAPI HTMLDocument_GetTypeInfo(IHTMLDocument2 *iface, UINT iTInfo,
184 LCID lcid, ITypeInfo **ppTInfo)
185 {
186 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
187
188 return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
189 }
190
191 static HRESULT WINAPI HTMLDocument_GetIDsOfNames(IHTMLDocument2 *iface, REFIID riid,
192 LPOLESTR *rgszNames, UINT cNames,
193 LCID lcid, DISPID *rgDispId)
194 {
195 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
196
197 return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
198 rgDispId);
199 }
200
201 static HRESULT WINAPI HTMLDocument_Invoke(IHTMLDocument2 *iface, DISPID dispIdMember,
202 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
203 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
204 {
205 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
206
207 return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
208 pDispParams, pVarResult, pExcepInfo, puArgErr);
209 }
210
211 static HRESULT WINAPI HTMLDocument_get_Script(IHTMLDocument2 *iface, IDispatch **p)
212 {
213 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
214 HRESULT hres;
215
216 TRACE("(%p)->(%p)\n", This, p);
217
218 hres = IHTMLDocument7_get_parentWindow(&This->IHTMLDocument7_iface, (IHTMLWindow2**)p);
219 return hres == S_OK && !*p ? E_PENDING : hres;
220 }
221
222 static HRESULT WINAPI HTMLDocument_get_all(IHTMLDocument2 *iface, IHTMLElementCollection **p)
223 {
224 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
225 nsIDOMElement *nselem = NULL;
226 HTMLDOMNode *node;
227 nsresult nsres;
228 HRESULT hres;
229
230 TRACE("(%p)->(%p)\n", This, p);
231
232 if(!This->doc_node->nsdoc) {
233 WARN("NULL nsdoc\n");
234 return E_UNEXPECTED;
235 }
236
237 nsres = nsIDOMHTMLDocument_GetDocumentElement(This->doc_node->nsdoc, &nselem);
238 if(NS_FAILED(nsres)) {
239 ERR("GetDocumentElement failed: %08x\n", nsres);
240 return E_FAIL;
241 }
242
243 if(!nselem) {
244 *p = NULL;
245 return S_OK;
246 }
247
248 hres = get_node((nsIDOMNode*)nselem, TRUE, &node);
249 nsIDOMElement_Release(nselem);
250 if(FAILED(hres))
251 return hres;
252
253 *p = create_all_collection(node, TRUE);
254 node_release(node);
255 return hres;
256 }
257
258 static HRESULT WINAPI HTMLDocument_get_body(IHTMLDocument2 *iface, IHTMLElement **p)
259 {
260 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
261 nsIDOMHTMLElement *nsbody = NULL;
262 HTMLElement *element;
263 HRESULT hres;
264
265 TRACE("(%p)->(%p)\n", This, p);
266
267 if(This->doc_node->nsdoc) {
268 nsresult nsres;
269
270 nsres = nsIDOMHTMLDocument_GetBody(This->doc_node->nsdoc, &nsbody);
271 if(NS_FAILED(nsres)) {
272 TRACE("Could not get body: %08x\n", nsres);
273 return E_UNEXPECTED;
274 }
275 }
276
277 if(!nsbody) {
278 *p = NULL;
279 return S_OK;
280 }
281
282 hres = get_element((nsIDOMElement*)nsbody, &element);
283 nsIDOMHTMLElement_Release(nsbody);
284 if(FAILED(hres))
285 return hres;
286
287 *p = &element->IHTMLElement_iface;
288 return S_OK;
289 }
290
291 static HRESULT WINAPI HTMLDocument_get_activeElement(IHTMLDocument2 *iface, IHTMLElement **p)
292 {
293 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
294 nsIDOMElement *nselem;
295 HTMLElement *elem;
296 nsresult nsres;
297 HRESULT hres;
298
299 TRACE("(%p)->(%p)\n", This, p);
300
301 if(!This->doc_node->nsdoc) {
302 *p = NULL;
303 return S_OK;
304 }
305
306 /*
307 * NOTE: Gecko may return an active element even if the document is not visible.
308 * IE returns NULL in this case.
309 */
310 nsres = nsIDOMHTMLDocument_GetActiveElement(This->doc_node->nsdoc, &nselem);
311 if(NS_FAILED(nsres)) {
312 ERR("GetActiveElement failed: %08x\n", nsres);
313 return E_FAIL;
314 }
315
316 if(!nselem) {
317 *p = NULL;
318 return S_OK;
319 }
320
321 hres = get_element(nselem, &elem);
322 nsIDOMElement_Release(nselem);
323 if(FAILED(hres))
324 return hres;
325
326 *p = &elem->IHTMLElement_iface;
327 return S_OK;
328 }
329
330 static HRESULT WINAPI HTMLDocument_get_images(IHTMLDocument2 *iface, IHTMLElementCollection **p)
331 {
332 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
333 nsIDOMHTMLCollection *nscoll = NULL;
334 nsresult nsres;
335
336 TRACE("(%p)->(%p)\n", This, p);
337
338 if(!p)
339 return E_INVALIDARG;
340
341 *p = NULL;
342
343 if(!This->doc_node->nsdoc) {
344 WARN("NULL nsdoc\n");
345 return E_UNEXPECTED;
346 }
347
348 nsres = nsIDOMHTMLDocument_GetImages(This->doc_node->nsdoc, &nscoll);
349 if(NS_FAILED(nsres)) {
350 ERR("GetImages failed: %08x\n", nsres);
351 return E_FAIL;
352 }
353
354 if(nscoll) {
355 *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
356 nsIDOMHTMLCollection_Release(nscoll);
357 }
358
359 return S_OK;
360 }
361
362 static HRESULT WINAPI HTMLDocument_get_applets(IHTMLDocument2 *iface, IHTMLElementCollection **p)
363 {
364 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
365 nsIDOMHTMLCollection *nscoll = NULL;
366 nsresult nsres;
367
368 TRACE("(%p)->(%p)\n", This, p);
369
370 if(!p)
371 return E_INVALIDARG;
372
373 *p = NULL;
374
375 if(!This->doc_node->nsdoc) {
376 WARN("NULL nsdoc\n");
377 return E_UNEXPECTED;
378 }
379
380 nsres = nsIDOMHTMLDocument_GetApplets(This->doc_node->nsdoc, &nscoll);
381 if(NS_FAILED(nsres)) {
382 ERR("GetApplets failed: %08x\n", nsres);
383 return E_FAIL;
384 }
385
386 if(nscoll) {
387 *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
388 nsIDOMHTMLCollection_Release(nscoll);
389 }
390
391 return S_OK;
392 }
393
394 static HRESULT WINAPI HTMLDocument_get_links(IHTMLDocument2 *iface, IHTMLElementCollection **p)
395 {
396 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
397 nsIDOMHTMLCollection *nscoll = NULL;
398 nsresult nsres;
399
400 TRACE("(%p)->(%p)\n", This, p);
401
402 if(!p)
403 return E_INVALIDARG;
404
405 *p = NULL;
406
407 if(!This->doc_node->nsdoc) {
408 WARN("NULL nsdoc\n");
409 return E_UNEXPECTED;
410 }
411
412 nsres = nsIDOMHTMLDocument_GetLinks(This->doc_node->nsdoc, &nscoll);
413 if(NS_FAILED(nsres)) {
414 ERR("GetLinks failed: %08x\n", nsres);
415 return E_FAIL;
416 }
417
418 if(nscoll) {
419 *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
420 nsIDOMHTMLCollection_Release(nscoll);
421 }
422
423 return S_OK;
424 }
425
426 static HRESULT WINAPI HTMLDocument_get_forms(IHTMLDocument2 *iface, IHTMLElementCollection **p)
427 {
428 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
429 nsIDOMHTMLCollection *nscoll = NULL;
430 nsresult nsres;
431
432 TRACE("(%p)->(%p)\n", This, p);
433
434 if(!p)
435 return E_INVALIDARG;
436
437 *p = NULL;
438
439 if(!This->doc_node->nsdoc) {
440 WARN("NULL nsdoc\n");
441 return E_UNEXPECTED;
442 }
443
444 nsres = nsIDOMHTMLDocument_GetForms(This->doc_node->nsdoc, &nscoll);
445 if(NS_FAILED(nsres)) {
446 ERR("GetForms failed: %08x\n", nsres);
447 return E_FAIL;
448 }
449
450 if(nscoll) {
451 *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
452 nsIDOMHTMLCollection_Release(nscoll);
453 }
454
455 return S_OK;
456 }
457
458 static HRESULT WINAPI HTMLDocument_get_anchors(IHTMLDocument2 *iface, IHTMLElementCollection **p)
459 {
460 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
461 nsIDOMHTMLCollection *nscoll = NULL;
462 nsresult nsres;
463
464 TRACE("(%p)->(%p)\n", This, p);
465
466 if(!p)
467 return E_INVALIDARG;
468
469 *p = NULL;
470
471 if(!This->doc_node->nsdoc) {
472 WARN("NULL nsdoc\n");
473 return E_UNEXPECTED;
474 }
475
476 nsres = nsIDOMHTMLDocument_GetAnchors(This->doc_node->nsdoc, &nscoll);
477 if(NS_FAILED(nsres)) {
478 ERR("GetAnchors failed: %08x\n", nsres);
479 return E_FAIL;
480 }
481
482 if(nscoll) {
483 *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
484 nsIDOMHTMLCollection_Release(nscoll);
485 }
486
487 return S_OK;
488 }
489
490 static HRESULT WINAPI HTMLDocument_put_title(IHTMLDocument2 *iface, BSTR v)
491 {
492 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
493 nsAString nsstr;
494 nsresult nsres;
495
496 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
497
498 if(!This->doc_node->nsdoc) {
499 WARN("NULL nsdoc\n");
500 return E_UNEXPECTED;
501 }
502
503 nsAString_InitDepend(&nsstr, v);
504 nsres = nsIDOMHTMLDocument_SetTitle(This->doc_node->nsdoc, &nsstr);
505 nsAString_Finish(&nsstr);
506 if(NS_FAILED(nsres))
507 ERR("SetTitle failed: %08x\n", nsres);
508
509 return S_OK;
510 }
511
512 static HRESULT WINAPI HTMLDocument_get_title(IHTMLDocument2 *iface, BSTR *p)
513 {
514 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
515 const PRUnichar *ret;
516 nsAString nsstr;
517 nsresult nsres;
518
519 TRACE("(%p)->(%p)\n", This, p);
520
521 if(!This->doc_node->nsdoc) {
522 WARN("NULL nsdoc\n");
523 return E_UNEXPECTED;
524 }
525
526
527 nsAString_Init(&nsstr, NULL);
528 nsres = nsIDOMHTMLDocument_GetTitle(This->doc_node->nsdoc, &nsstr);
529 if (NS_SUCCEEDED(nsres)) {
530 nsAString_GetData(&nsstr, &ret);
531 *p = SysAllocString(ret);
532 }
533 nsAString_Finish(&nsstr);
534
535 if(NS_FAILED(nsres)) {
536 ERR("GetTitle failed: %08x\n", nsres);
537 return E_FAIL;
538 }
539
540 return S_OK;
541 }
542
543 static HRESULT WINAPI HTMLDocument_get_scripts(IHTMLDocument2 *iface, IHTMLElementCollection **p)
544 {
545 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
546 nsIDOMHTMLCollection *nscoll = NULL;
547 nsresult nsres;
548
549 TRACE("(%p)->(%p)\n", This, p);
550
551 if(!p)
552 return E_INVALIDARG;
553
554 *p = NULL;
555
556 if(!This->doc_node->nsdoc) {
557 WARN("NULL nsdoc\n");
558 return E_UNEXPECTED;
559 }
560
561 nsres = nsIDOMHTMLDocument_GetScripts(This->doc_node->nsdoc, &nscoll);
562 if(NS_FAILED(nsres)) {
563 ERR("GetImages failed: %08x\n", nsres);
564 return E_FAIL;
565 }
566
567 if(nscoll) {
568 *p = create_collection_from_htmlcol(nscoll, This->doc_node->document_mode);
569 nsIDOMHTMLCollection_Release(nscoll);
570 }
571
572 return S_OK;
573 }
574
575 static HRESULT WINAPI HTMLDocument_put_designMode(IHTMLDocument2 *iface, BSTR v)
576 {
577 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
578 HRESULT hres;
579
580 static const WCHAR onW[] = {'o','n',0};
581
582 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
583
584 if(wcsicmp(v, onW)) {
585 FIXME("Unsupported arg %s\n", debugstr_w(v));
586 return E_NOTIMPL;
587 }
588
589 hres = setup_edit_mode(This->doc_obj);
590 if(FAILED(hres))
591 return hres;
592
593 call_property_onchanged(&This->cp_container, DISPID_IHTMLDOCUMENT2_DESIGNMODE);
594 return S_OK;
595 }
596
597 static HRESULT WINAPI HTMLDocument_get_designMode(IHTMLDocument2 *iface, BSTR *p)
598 {
599 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
600 static const WCHAR szOff[] = {'O','f','f',0};
601 FIXME("(%p)->(%p) always returning Off\n", This, p);
602
603 if(!p)
604 return E_INVALIDARG;
605
606 *p = SysAllocString(szOff);
607
608 return S_OK;
609 }
610
611 static HRESULT WINAPI HTMLDocument_get_selection(IHTMLDocument2 *iface, IHTMLSelectionObject **p)
612 {
613 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
614 nsISelection *nsselection;
615 nsresult nsres;
616
617 TRACE("(%p)->(%p)\n", This, p);
618
619 nsres = nsIDOMWindow_GetSelection(This->window->nswindow, &nsselection);
620 if(NS_FAILED(nsres)) {
621 ERR("GetSelection failed: %08x\n", nsres);
622 return E_FAIL;
623 }
624
625 return HTMLSelectionObject_Create(This->doc_node, nsselection, p);
626 }
627
628 static HRESULT WINAPI HTMLDocument_get_readyState(IHTMLDocument2 *iface, BSTR *p)
629 {
630 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
631
632
633 TRACE("(%p)->(%p)\n", iface, p);
634
635 if(!p)
636 return E_POINTER;
637
638 return get_readystate_string(This->window->readystate, p);
639 }
640
641 static HRESULT WINAPI HTMLDocument_get_frames(IHTMLDocument2 *iface, IHTMLFramesCollection2 **p)
642 {
643 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
644
645 TRACE("(%p)->(%p)\n", This, p);
646
647 return IHTMLWindow2_get_frames(&This->window->base.IHTMLWindow2_iface, p);
648 }
649
650 static HRESULT WINAPI HTMLDocument_get_embeds(IHTMLDocument2 *iface, IHTMLElementCollection **p)
651 {
652 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
653 FIXME("(%p)->(%p)\n", This, p);
654 return E_NOTIMPL;
655 }
656
657 static HRESULT WINAPI HTMLDocument_get_plugins(IHTMLDocument2 *iface, IHTMLElementCollection **p)
658 {
659 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
660 FIXME("(%p)->(%p)\n", This, p);
661 return E_NOTIMPL;
662 }
663
664 static HRESULT WINAPI HTMLDocument_put_alinkColor(IHTMLDocument2 *iface, VARIANT v)
665 {
666 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
667 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
668 return E_NOTIMPL;
669 }
670
671 static HRESULT WINAPI HTMLDocument_get_alinkColor(IHTMLDocument2 *iface, VARIANT *p)
672 {
673 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
674 FIXME("(%p)->(%p)\n", This, p);
675 return E_NOTIMPL;
676 }
677
678 static HRESULT WINAPI HTMLDocument_put_bgColor(IHTMLDocument2 *iface, VARIANT v)
679 {
680 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
681 IHTMLElement *element = NULL;
682 IHTMLBodyElement *body;
683 HRESULT hr;
684
685 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
686
687 hr = IHTMLDocument2_get_body(iface, &element);
688 if (FAILED(hr))
689 {
690 ERR("Failed to get body (0x%08x)\n", hr);
691 return hr;
692 }
693
694 if(!element)
695 {
696 FIXME("Empty body element.\n");
697 return hr;
698 }
699
700 hr = IHTMLElement_QueryInterface(element, &IID_IHTMLBodyElement, (void**)&body);
701 if (SUCCEEDED(hr))
702 {
703 hr = IHTMLBodyElement_put_bgColor(body, v);
704 IHTMLBodyElement_Release(body);
705 }
706 IHTMLElement_Release(element);
707
708 return hr;
709 }
710
711 static HRESULT WINAPI HTMLDocument_get_bgColor(IHTMLDocument2 *iface, VARIANT *p)
712 {
713 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
714 nsAString nsstr;
715 nsresult nsres;
716 HRESULT hres;
717
718 TRACE("(%p)->(%p)\n", This, p);
719
720 if(!This->doc_node->nsdoc) {
721 WARN("NULL nsdoc\n");
722 return E_UNEXPECTED;
723 }
724
725 nsAString_Init(&nsstr, NULL);
726 nsres = nsIDOMHTMLDocument_GetBgColor(This->doc_node->nsdoc, &nsstr);
727 hres = return_nsstr_variant(nsres, &nsstr, NSSTR_COLOR, p);
728 if(hres == S_OK && V_VT(p) == VT_BSTR && !V_BSTR(p)) {
729 TRACE("default #ffffff\n");
730 if(!(V_BSTR(p) = SysAllocString(L"#ffffff")))
731 hres = E_OUTOFMEMORY;
732 }
733 return hres;
734 }
735
736 static HRESULT WINAPI HTMLDocument_put_fgColor(IHTMLDocument2 *iface, VARIANT v)
737 {
738 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
739 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
740 return E_NOTIMPL;
741 }
742
743 static HRESULT WINAPI HTMLDocument_get_fgColor(IHTMLDocument2 *iface, VARIANT *p)
744 {
745 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
746 FIXME("(%p)->(%p)\n", This, p);
747 return E_NOTIMPL;
748 }
749
750 static HRESULT WINAPI HTMLDocument_put_linkColor(IHTMLDocument2 *iface, VARIANT v)
751 {
752 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
753 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
754 return E_NOTIMPL;
755 }
756
757 static HRESULT WINAPI HTMLDocument_get_linkColor(IHTMLDocument2 *iface, VARIANT *p)
758 {
759 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
760 FIXME("(%p)->(%p)\n", This, p);
761 return E_NOTIMPL;
762 }
763
764 static HRESULT WINAPI HTMLDocument_put_vlinkColor(IHTMLDocument2 *iface, VARIANT v)
765 {
766 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
767 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
768 return E_NOTIMPL;
769 }
770
771 static HRESULT WINAPI HTMLDocument_get_vlinkColor(IHTMLDocument2 *iface, VARIANT *p)
772 {
773 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
774 FIXME("(%p)->(%p)\n", This, p);
775 return E_NOTIMPL;
776 }
777
778 static HRESULT WINAPI HTMLDocument_get_referrer(IHTMLDocument2 *iface, BSTR *p)
779 {
780 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
781
782 FIXME("(%p)->(%p)\n", This, p);
783
784 *p = NULL;
785 return S_OK;
786 }
787
788 static HRESULT WINAPI HTMLDocument_get_location(IHTMLDocument2 *iface, IHTMLLocation **p)
789 {
790 HTMLDocumentNode *This = impl_from_IHTMLDocument2(iface)->doc_node;
791
792 TRACE("(%p)->(%p)\n", This, p);
793
794 if(!This->nsdoc || !This->window) {
795 WARN("NULL window\n");
796 return E_UNEXPECTED;
797 }
798
799 return IHTMLWindow2_get_location(&This->window->base.IHTMLWindow2_iface, p);
800 }
801
802 static HRESULT WINAPI HTMLDocument_get_lastModified(IHTMLDocument2 *iface, BSTR *p)
803 {
804 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
805 FIXME("(%p)->(%p)\n", This, p);
806 return E_NOTIMPL;
807 }
808
809 static HRESULT WINAPI HTMLDocument_put_URL(IHTMLDocument2 *iface, BSTR v)
810 {
811 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
812
813 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
814
815 if(!This->window) {
816 FIXME("No window available\n");
817 return E_FAIL;
818 }
819
820 return navigate_url(This->window, v, This->window->uri, BINDING_NAVIGATED);
821 }
822
823 static HRESULT WINAPI HTMLDocument_get_URL(IHTMLDocument2 *iface, BSTR *p)
824 {
825 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
826
827 static const WCHAR about_blank_url[] =
828 {'a','b','o','u','t',':','b','l','a','n','k',0};
829
830 TRACE("(%p)->(%p)\n", iface, p);
831
832 *p = SysAllocString(This->window->url ? This->window->url : about_blank_url);
833 return *p ? S_OK : E_OUTOFMEMORY;
834 }
835
836 static HRESULT WINAPI HTMLDocument_put_domain(IHTMLDocument2 *iface, BSTR v)
837 {
838 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
839 nsAString nsstr;
840 nsresult nsres;
841
842 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
843
844 nsAString_InitDepend(&nsstr, v);
845 nsres = nsIDOMHTMLDocument_SetDomain(This->doc_node->nsdoc, &nsstr);
846 nsAString_Finish(&nsstr);
847 if(NS_FAILED(nsres)) {
848 ERR("SetDomain failed: %08x\n", nsres);
849 return E_INVALIDARG;
850 }
851
852 return S_OK;
853 }
854
855 static HRESULT WINAPI HTMLDocument_get_domain(IHTMLDocument2 *iface, BSTR *p)
856 {
857 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
858 nsAString nsstr;
859 nsresult nsres;
860
861 TRACE("(%p)->(%p)\n", This, p);
862
863 nsAString_Init(&nsstr, NULL);
864 nsres = nsIDOMHTMLDocument_GetDomain(This->doc_node->nsdoc, &nsstr);
865 if(NS_SUCCEEDED(nsres) && This->window && This->window->uri) {
866 const PRUnichar *str;
867 HRESULT hres;
868
869 nsAString_GetData(&nsstr, &str);
870 if(!*str) {
871 TRACE("Gecko returned empty string, fallback to loaded URL.\n");
872 nsAString_Finish(&nsstr);
873 hres = IUri_GetHost(This->window->uri, p);
874 return FAILED(hres) ? hres : S_OK;
875 }
876 }
877
878 return return_nsstr(nsres, &nsstr, p);
879 }
880
881 static HRESULT WINAPI HTMLDocument_put_cookie(IHTMLDocument2 *iface, BSTR v)
882 {
883 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
884 BOOL bret;
885
886 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
887
888 bret = InternetSetCookieExW(This->window->url, NULL, v, 0, 0);
889 if(!bret) {
890 FIXME("InternetSetCookieExW failed: %u\n", GetLastError());
891 return HRESULT_FROM_WIN32(GetLastError());
892 }
893
894 return S_OK;
895 }
896
897 static HRESULT WINAPI HTMLDocument_get_cookie(IHTMLDocument2 *iface, BSTR *p)
898 {
899 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
900 DWORD size;
901 BOOL bret;
902
903 TRACE("(%p)->(%p)\n", This, p);
904
905 size = 0;
906 bret = InternetGetCookieExW(This->window->url, NULL, NULL, &size, 0, NULL);
907 if(!bret && GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
908 WARN("InternetGetCookieExW failed: %u\n", GetLastError());
909 *p = NULL;
910 return S_OK;
911 }
912
913 if(!size) {
914 *p = NULL;
915 return S_OK;
916 }
917
918 *p = SysAllocStringLen(NULL, size/sizeof(WCHAR)-1);
919 if(!*p)
920 return E_OUTOFMEMORY;
921
922 bret = InternetGetCookieExW(This->window->url, NULL, *p, &size, 0, NULL);
923 if(!bret) {
924 ERR("InternetGetCookieExW failed: %u\n", GetLastError());
925 return E_FAIL;
926 }
927
928 return S_OK;
929 }
930
931 static HRESULT WINAPI HTMLDocument_put_expando(IHTMLDocument2 *iface, VARIANT_BOOL v)
932 {
933 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
934 FIXME("(%p)->(%x)\n", This, v);
935 return E_NOTIMPL;
936 }
937
938 static HRESULT WINAPI HTMLDocument_get_expando(IHTMLDocument2 *iface, VARIANT_BOOL *p)
939 {
940 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
941 FIXME("(%p)->(%p)\n", This, p);
942 return E_NOTIMPL;
943 }
944
945 static HRESULT WINAPI HTMLDocument_put_charset(IHTMLDocument2 *iface, BSTR v)
946 {
947 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
948 FIXME("(%p)->(%s) returning S_OK\n", This, debugstr_w(v));
949 return S_OK;
950 }
951
952 static HRESULT WINAPI HTMLDocument_get_charset(IHTMLDocument2 *iface, BSTR *p)
953 {
954 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
955
956 TRACE("(%p)->(%p)\n", This, p);
957
958 return IHTMLDocument7_get_characterSet(&This->IHTMLDocument7_iface, p);
959 }
960
961 static HRESULT WINAPI HTMLDocument_put_defaultCharset(IHTMLDocument2 *iface, BSTR v)
962 {
963 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
964 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
965 return E_NOTIMPL;
966 }
967
968 static HRESULT WINAPI HTMLDocument_get_defaultCharset(IHTMLDocument2 *iface, BSTR *p)
969 {
970 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
971
972 TRACE("(%p)->(%p)\n", This, p);
973
974 *p = charset_string_from_cp(GetACP());
975 return *p ? S_OK : E_OUTOFMEMORY;
976 }
977
978 static HRESULT WINAPI HTMLDocument_get_mimeType(IHTMLDocument2 *iface, BSTR *p)
979 {
980 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
981 FIXME("(%p)->(%p)\n", This, p);
982 return E_NOTIMPL;
983 }
984
985 static HRESULT WINAPI HTMLDocument_get_fileSize(IHTMLDocument2 *iface, BSTR *p)
986 {
987 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
988 FIXME("(%p)->(%p)\n", This, p);
989 return E_NOTIMPL;
990 }
991
992 static HRESULT WINAPI HTMLDocument_get_fileCreatedDate(IHTMLDocument2 *iface, BSTR *p)
993 {
994 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
995 FIXME("(%p)->(%p)\n", This, p);
996 return E_NOTIMPL;
997 }
998
999 static HRESULT WINAPI HTMLDocument_get_fileModifiedDate(IHTMLDocument2 *iface, BSTR *p)
1000 {
1001 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1002 FIXME("(%p)->(%p)\n", This, p);
1003 return E_NOTIMPL;
1004 }
1005
1006 static HRESULT WINAPI HTMLDocument_get_fileUpdatedDate(IHTMLDocument2 *iface, BSTR *p)
1007 {
1008 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1009 FIXME("(%p)->(%p)\n", This, p);
1010 return E_NOTIMPL;
1011 }
1012
1013 static HRESULT WINAPI HTMLDocument_get_security(IHTMLDocument2 *iface, BSTR *p)
1014 {
1015 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1016 FIXME("(%p)->(%p)\n", This, p);
1017 return E_NOTIMPL;
1018 }
1019
1020 static HRESULT WINAPI HTMLDocument_get_protocol(IHTMLDocument2 *iface, BSTR *p)
1021 {
1022 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1023 FIXME("(%p)->(%p)\n", This, p);
1024 return E_NOTIMPL;
1025 }
1026
1027 static HRESULT WINAPI HTMLDocument_get_nameProp(IHTMLDocument2 *iface, BSTR *p)
1028 {
1029 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1030 FIXME("(%p)->(%p)\n", This, p);
1031 return E_NOTIMPL;
1032 }
1033
1034 static HRESULT document_write(HTMLDocument *This, SAFEARRAY *psarray, BOOL ln)
1035 {
1036 VARIANT *var, tmp;
1037 JSContext *jsctx;
1038 nsAString nsstr;
1039 ULONG i, argc;
1040 nsresult nsres;
1041 HRESULT hres;
1042
1043 if(!This->doc_node->nsdoc) {
1044 WARN("NULL nsdoc\n");
1045 return E_UNEXPECTED;
1046 }
1047
1048 if (!psarray)
1049 return S_OK;
1050
1051 if(psarray->cDims != 1) {
1052 FIXME("cDims=%d\n", psarray->cDims);
1053 return E_INVALIDARG;
1054 }
1055
1056 hres = SafeArrayAccessData(psarray, (void**)&var);
1057 if(FAILED(hres)) {
1058 WARN("SafeArrayAccessData failed: %08x\n", hres);
1059 return hres;
1060 }
1061
1062 V_VT(&tmp) = VT_EMPTY;
1063
1064 jsctx = get_context_from_document(This->doc_node->nsdoc);
1065 argc = psarray->rgsabound[0].cElements;
1066 for(i=0; i < argc; i++) {
1067 if(V_VT(var+i) == VT_BSTR) {
1068 nsAString_InitDepend(&nsstr, V_BSTR(var+i));
1069 }else {
1070 hres = VariantChangeTypeEx(&tmp, var+i, MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT), 0, VT_BSTR);
1071 if(FAILED(hres)) {
1072 WARN("Could not convert %s to string\n", debugstr_variant(var+i));
1073 break;
1074 }
1075 nsAString_InitDepend(&nsstr, V_BSTR(&tmp));
1076 }
1077
1078 if(!ln || i != argc-1)
1079 nsres = nsIDOMHTMLDocument_Write(This->doc_node->nsdoc, &nsstr, jsctx);
1080 else
1081 nsres = nsIDOMHTMLDocument_Writeln(This->doc_node->nsdoc, &nsstr, jsctx);
1082 nsAString_Finish(&nsstr);
1083 if(V_VT(var+i) != VT_BSTR)
1084 VariantClear(&tmp);
1085 if(NS_FAILED(nsres)) {
1086 ERR("Write failed: %08x\n", nsres);
1087 hres = E_FAIL;
1088 break;
1089 }
1090 }
1091
1092 SafeArrayUnaccessData(psarray);
1093
1094 return hres;
1095 }
1096
1097 static HRESULT WINAPI HTMLDocument_write(IHTMLDocument2 *iface, SAFEARRAY *psarray)
1098 {
1099 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1100
1101 TRACE("(%p)->(%p)\n", iface, psarray);
1102
1103 return document_write(This, psarray, FALSE);
1104 }
1105
1106 static HRESULT WINAPI HTMLDocument_writeln(IHTMLDocument2 *iface, SAFEARRAY *psarray)
1107 {
1108 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1109
1110 TRACE("(%p)->(%p)\n", This, psarray);
1111
1112 return document_write(This, psarray, TRUE);
1113 }
1114
1115 static HRESULT WINAPI HTMLDocument_open(IHTMLDocument2 *iface, BSTR url, VARIANT name,
1116 VARIANT features, VARIANT replace, IDispatch **pomWindowResult)
1117 {
1118 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1119 nsISupports *tmp;
1120 nsresult nsres;
1121
1122 static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
1123
1124 TRACE("(%p)->(%s %s %s %s %p)\n", This, debugstr_w(url), debugstr_variant(&name),
1125 debugstr_variant(&features), debugstr_variant(&replace), pomWindowResult);
1126
1127 if(!This->doc_node->nsdoc) {
1128 ERR("!nsdoc\n");
1129 return E_NOTIMPL;
1130 }
1131
1132 if(!url || wcscmp(url, text_htmlW) || V_VT(&name) != VT_ERROR
1133 || V_VT(&features) != VT_ERROR || V_VT(&replace) != VT_ERROR)
1134 FIXME("unsupported args\n");
1135
1136 nsres = nsIDOMHTMLDocument_Open(This->doc_node->nsdoc, NULL, NULL, NULL,
1137 get_context_from_document(This->doc_node->nsdoc), 0, &tmp);
1138 if(NS_FAILED(nsres)) {
1139 ERR("Open failed: %08x\n", nsres);
1140 return E_FAIL;
1141 }
1142
1143 if(tmp)
1144 nsISupports_Release(tmp);
1145
1146 *pomWindowResult = (IDispatch*)&This->window->base.IHTMLWindow2_iface;
1147 IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
1148 return S_OK;
1149 }
1150
1151 static HRESULT WINAPI HTMLDocument_close(IHTMLDocument2 *iface)
1152 {
1153 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1154 nsresult nsres;
1155
1156 TRACE("(%p)\n", This);
1157
1158 if(!This->doc_node->nsdoc) {
1159 ERR("!nsdoc\n");
1160 return E_NOTIMPL;
1161 }
1162
1163 nsres = nsIDOMHTMLDocument_Close(This->doc_node->nsdoc);
1164 if(NS_FAILED(nsres)) {
1165 ERR("Close failed: %08x\n", nsres);
1166 return E_FAIL;
1167 }
1168
1169 return S_OK;
1170 }
1171
1172 static HRESULT WINAPI HTMLDocument_clear(IHTMLDocument2 *iface)
1173 {
1174 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1175 nsresult nsres;
1176
1177 TRACE("(%p)\n", This);
1178
1179 nsres = nsIDOMHTMLDocument_Clear(This->doc_node->nsdoc);
1180 if(NS_FAILED(nsres)) {
1181 ERR("Clear failed: %08x\n", nsres);
1182 return E_FAIL;
1183 }
1184
1185 return S_OK;
1186 }
1187
1188 static const WCHAR copyW[] =
1189 {'c','o','p','y',0};
1190 static const WCHAR cutW[] =
1191 {'c','u','t',0};
1192 static const WCHAR fontnameW[] =
1193 {'f','o','n','t','n','a','m','e',0};
1194 static const WCHAR fontsizeW[] =
1195 {'f','o','n','t','s','i','z','e',0};
1196 static const WCHAR indentW[] =
1197 {'i','n','d','e','n','t',0};
1198 static const WCHAR insertorderedlistW[] =
1199 {'i','n','s','e','r','t','o','r','d','e','r','e','d','l','i','s','t',0};
1200 static const WCHAR insertunorderedlistW[] =
1201 {'i','n','s','e','r','t','u','n','o','r','d','e','r','e','d','l','i','s','t',0};
1202 static const WCHAR outdentW[] =
1203 {'o','u','t','d','e','n','t',0};
1204 static const WCHAR pasteW[] =
1205 {'p','a','s','t','e',0};
1206 static const WCHAR respectvisibilityindesignW[] =
1207 {'r','e','s','p','e','c','t','v','i','s','i','b','i','l','i','t','y','i','n','d','e','s','i','g','n',0};
1208
1209 static const struct {
1210 const WCHAR *name;
1211 OLECMDID id;
1212 }command_names[] = {
1213 {copyW, IDM_COPY},
1214 {cutW, IDM_CUT},
1215 {fontnameW, IDM_FONTNAME},
1216 {fontsizeW, IDM_FONTSIZE},
1217 {indentW, IDM_INDENT},
1218 {insertorderedlistW, IDM_ORDERLIST},
1219 {insertunorderedlistW, IDM_UNORDERLIST},
1220 {outdentW, IDM_OUTDENT},
1221 {pasteW, IDM_PASTE},
1222 {respectvisibilityindesignW, IDM_RESPECTVISIBILITY_INDESIGN}
1223 };
1224
1225 static BOOL cmdid_from_string(const WCHAR *str, OLECMDID *cmdid)
1226 {
1227 int i;
1228
1229 for(i = 0; i < ARRAY_SIZE(command_names); i++) {
1230 if(!wcsicmp(command_names[i].name, str)) {
1231 *cmdid = command_names[i].id;
1232 return TRUE;
1233 }
1234 }
1235
1236 FIXME("Unknown command %s\n", debugstr_w(str));
1237 return FALSE;
1238 }
1239
1240 static HRESULT WINAPI HTMLDocument_queryCommandSupported(IHTMLDocument2 *iface, BSTR cmdID,
1241 VARIANT_BOOL *pfRet)
1242 {
1243 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1244 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1245 return E_NOTIMPL;
1246 }
1247
1248 static HRESULT WINAPI HTMLDocument_queryCommandEnabled(IHTMLDocument2 *iface, BSTR cmdID,
1249 VARIANT_BOOL *pfRet)
1250 {
1251 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1252 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1253 return E_NOTIMPL;
1254 }
1255
1256 static HRESULT WINAPI HTMLDocument_queryCommandState(IHTMLDocument2 *iface, BSTR cmdID,
1257 VARIANT_BOOL *pfRet)
1258 {
1259 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1260 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1261 return E_NOTIMPL;
1262 }
1263
1264 static HRESULT WINAPI HTMLDocument_queryCommandIndeterm(IHTMLDocument2 *iface, BSTR cmdID,
1265 VARIANT_BOOL *pfRet)
1266 {
1267 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1268 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1269 return E_NOTIMPL;
1270 }
1271
1272 static HRESULT WINAPI HTMLDocument_queryCommandText(IHTMLDocument2 *iface, BSTR cmdID,
1273 BSTR *pfRet)
1274 {
1275 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1276 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1277 return E_NOTIMPL;
1278 }
1279
1280 static HRESULT WINAPI HTMLDocument_queryCommandValue(IHTMLDocument2 *iface, BSTR cmdID,
1281 VARIANT *pfRet)
1282 {
1283 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1284 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1285 return E_NOTIMPL;
1286 }
1287
1288 static HRESULT WINAPI HTMLDocument_execCommand(IHTMLDocument2 *iface, BSTR cmdID,
1289 VARIANT_BOOL showUI, VARIANT value, VARIANT_BOOL *pfRet)
1290 {
1291 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1292 OLECMDID cmdid;
1293 VARIANT ret;
1294 HRESULT hres;
1295
1296 TRACE("(%p)->(%s %x %s %p)\n", This, debugstr_w(cmdID), showUI, debugstr_variant(&value), pfRet);
1297
1298 if(!cmdid_from_string(cmdID, &cmdid))
1299 return OLECMDERR_E_NOTSUPPORTED;
1300
1301 V_VT(&ret) = VT_EMPTY;
1302 hres = IOleCommandTarget_Exec(&This->IOleCommandTarget_iface, &CGID_MSHTML, cmdid,
1303 showUI ? 0 : OLECMDEXECOPT_DONTPROMPTUSER, &value, &ret);
1304 if(FAILED(hres))
1305 return hres;
1306
1307 if(V_VT(&ret) != VT_EMPTY) {
1308 FIXME("Handle ret %s\n", debugstr_variant(&ret));
1309 VariantClear(&ret);
1310 }
1311
1312 *pfRet = VARIANT_TRUE;
1313 return S_OK;
1314 }
1315
1316 static HRESULT WINAPI HTMLDocument_execCommandShowHelp(IHTMLDocument2 *iface, BSTR cmdID,
1317 VARIANT_BOOL *pfRet)
1318 {
1319 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1320 FIXME("(%p)->(%s %p)\n", This, debugstr_w(cmdID), pfRet);
1321 return E_NOTIMPL;
1322 }
1323
1324 static HRESULT WINAPI HTMLDocument_createElement(IHTMLDocument2 *iface, BSTR eTag,
1325 IHTMLElement **newElem)
1326 {
1327 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1328 HTMLElement *elem;
1329 HRESULT hres;
1330
1331 TRACE("(%p)->(%s %p)\n", This, debugstr_w(eTag), newElem);
1332
1333 hres = create_element(This->doc_node, eTag, &elem);
1334 if(FAILED(hres))
1335 return hres;
1336
1337 *newElem = &elem->IHTMLElement_iface;
1338 return S_OK;
1339 }
1340
1341 static HRESULT WINAPI HTMLDocument_put_onhelp(IHTMLDocument2 *iface, VARIANT v)
1342 {
1343 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1344 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1345 return E_NOTIMPL;
1346 }
1347
1348 static HRESULT WINAPI HTMLDocument_get_onhelp(IHTMLDocument2 *iface, VARIANT *p)
1349 {
1350 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1351 FIXME("(%p)->(%p)\n", This, p);
1352 return E_NOTIMPL;
1353 }
1354
1355 static HRESULT WINAPI HTMLDocument_put_onclick(IHTMLDocument2 *iface, VARIANT v)
1356 {
1357 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1358
1359 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1360
1361 return set_doc_event(This, EVENTID_CLICK, &v);
1362 }
1363
1364 static HRESULT WINAPI HTMLDocument_get_onclick(IHTMLDocument2 *iface, VARIANT *p)
1365 {
1366 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1367
1368 TRACE("(%p)->(%p)\n", This, p);
1369
1370 return get_doc_event(This, EVENTID_CLICK, p);
1371 }
1372
1373 static HRESULT WINAPI HTMLDocument_put_ondblclick(IHTMLDocument2 *iface, VARIANT v)
1374 {
1375 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1376
1377 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1378
1379 return set_doc_event(This, EVENTID_DBLCLICK, &v);
1380 }
1381
1382 static HRESULT WINAPI HTMLDocument_get_ondblclick(IHTMLDocument2 *iface, VARIANT *p)
1383 {
1384 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1385
1386 TRACE("(%p)->(%p)\n", This, p);
1387
1388 return get_doc_event(This, EVENTID_DBLCLICK, p);
1389 }
1390
1391 static HRESULT WINAPI HTMLDocument_put_onkeyup(IHTMLDocument2 *iface, VARIANT v)
1392 {
1393 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1394
1395 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1396
1397 return set_doc_event(This, EVENTID_KEYUP, &v);
1398 }
1399
1400 static HRESULT WINAPI HTMLDocument_get_onkeyup(IHTMLDocument2 *iface, VARIANT *p)
1401 {
1402 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1403
1404 TRACE("(%p)->(%p)\n", This, p);
1405
1406 return get_doc_event(This, EVENTID_KEYUP, p);
1407 }
1408
1409 static HRESULT WINAPI HTMLDocument_put_onkeydown(IHTMLDocument2 *iface, VARIANT v)
1410 {
1411 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1412
1413 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1414
1415 return set_doc_event(This, EVENTID_KEYDOWN, &v);
1416 }
1417
1418 static HRESULT WINAPI HTMLDocument_get_onkeydown(IHTMLDocument2 *iface, VARIANT *p)
1419 {
1420 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1421
1422 TRACE("(%p)->(%p)\n", This, p);
1423
1424 return get_doc_event(This, EVENTID_KEYDOWN, p);
1425 }
1426
1427 static HRESULT WINAPI HTMLDocument_put_onkeypress(IHTMLDocument2 *iface, VARIANT v)
1428 {
1429 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1430
1431 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1432
1433 return set_doc_event(This, EVENTID_KEYPRESS, &v);
1434 }
1435
1436 static HRESULT WINAPI HTMLDocument_get_onkeypress(IHTMLDocument2 *iface, VARIANT *p)
1437 {
1438 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1439
1440 TRACE("(%p)->(%p)\n", This, p);
1441
1442 return get_doc_event(This, EVENTID_KEYPRESS, p);
1443 }
1444
1445 static HRESULT WINAPI HTMLDocument_put_onmouseup(IHTMLDocument2 *iface, VARIANT v)
1446 {
1447 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1448
1449 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1450
1451 return set_doc_event(This, EVENTID_MOUSEUP, &v);
1452 }
1453
1454 static HRESULT WINAPI HTMLDocument_get_onmouseup(IHTMLDocument2 *iface, VARIANT *p)
1455 {
1456 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1457
1458 TRACE("(%p)->(%p)\n", This, p);
1459
1460 return get_doc_event(This, EVENTID_MOUSEUP, p);
1461 }
1462
1463 static HRESULT WINAPI HTMLDocument_put_onmousedown(IHTMLDocument2 *iface, VARIANT v)
1464 {
1465 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1466
1467 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1468
1469 return set_doc_event(This, EVENTID_MOUSEDOWN, &v);
1470 }
1471
1472 static HRESULT WINAPI HTMLDocument_get_onmousedown(IHTMLDocument2 *iface, VARIANT *p)
1473 {
1474 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1475
1476 TRACE("(%p)->(%p)\n", This, p);
1477
1478 return get_doc_event(This, EVENTID_MOUSEDOWN, p);
1479 }
1480
1481 static HRESULT WINAPI HTMLDocument_put_onmousemove(IHTMLDocument2 *iface, VARIANT v)
1482 {
1483 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1484
1485 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1486
1487 return set_doc_event(This, EVENTID_MOUSEMOVE, &v);
1488 }
1489
1490 static HRESULT WINAPI HTMLDocument_get_onmousemove(IHTMLDocument2 *iface, VARIANT *p)
1491 {
1492 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1493
1494 TRACE("(%p)->(%p)\n", This, p);
1495
1496 return get_doc_event(This, EVENTID_MOUSEMOVE, p);
1497 }
1498
1499 static HRESULT WINAPI HTMLDocument_put_onmouseout(IHTMLDocument2 *iface, VARIANT v)
1500 {
1501 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1502
1503 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1504
1505 return set_doc_event(This, EVENTID_MOUSEOUT, &v);
1506 }
1507
1508 static HRESULT WINAPI HTMLDocument_get_onmouseout(IHTMLDocument2 *iface, VARIANT *p)
1509 {
1510 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1511
1512 TRACE("(%p)->(%p)\n", This, p);
1513
1514 return get_doc_event(This, EVENTID_MOUSEOUT, p);
1515 }
1516
1517 static HRESULT WINAPI HTMLDocument_put_onmouseover(IHTMLDocument2 *iface, VARIANT v)
1518 {
1519 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1520
1521 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1522
1523 return set_doc_event(This, EVENTID_MOUSEOVER, &v);
1524 }
1525
1526 static HRESULT WINAPI HTMLDocument_get_onmouseover(IHTMLDocument2 *iface, VARIANT *p)
1527 {
1528 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1529
1530 TRACE("(%p)->(%p)\n", This, p);
1531
1532 return get_doc_event(This, EVENTID_MOUSEOVER, p);
1533 }
1534
1535 static HRESULT WINAPI HTMLDocument_put_onreadystatechange(IHTMLDocument2 *iface, VARIANT v)
1536 {
1537 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1538
1539 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1540
1541 return set_doc_event(This, EVENTID_READYSTATECHANGE, &v);
1542 }
1543
1544 static HRESULT WINAPI HTMLDocument_get_onreadystatechange(IHTMLDocument2 *iface, VARIANT *p)
1545 {
1546 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1547
1548 TRACE("(%p)->(%p)\n", This, p);
1549
1550 return get_doc_event(This, EVENTID_READYSTATECHANGE, p);
1551 }
1552
1553 static HRESULT WINAPI HTMLDocument_put_onafterupdate(IHTMLDocument2 *iface, VARIANT v)
1554 {
1555 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1556 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1557 return E_NOTIMPL;
1558 }
1559
1560 static HRESULT WINAPI HTMLDocument_get_onafterupdate(IHTMLDocument2 *iface, VARIANT *p)
1561 {
1562 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1563 FIXME("(%p)->(%p)\n", This, p);
1564 return E_NOTIMPL;
1565 }
1566
1567 static HRESULT WINAPI HTMLDocument_put_onrowexit(IHTMLDocument2 *iface, VARIANT v)
1568 {
1569 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1570 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1571 return E_NOTIMPL;
1572 }
1573
1574 static HRESULT WINAPI HTMLDocument_get_onrowexit(IHTMLDocument2 *iface, VARIANT *p)
1575 {
1576 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1577 FIXME("(%p)->(%p)\n", This, p);
1578 return E_NOTIMPL;
1579 }
1580
1581 static HRESULT WINAPI HTMLDocument_put_onrowenter(IHTMLDocument2 *iface, VARIANT v)
1582 {
1583 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1584 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1585 return E_NOTIMPL;
1586 }
1587
1588 static HRESULT WINAPI HTMLDocument_get_onrowenter(IHTMLDocument2 *iface, VARIANT *p)
1589 {
1590 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1591 FIXME("(%p)->(%p)\n", This, p);
1592 return E_NOTIMPL;
1593 }
1594
1595 static HRESULT WINAPI HTMLDocument_put_ondragstart(IHTMLDocument2 *iface, VARIANT v)
1596 {
1597 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1598
1599 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1600
1601 return set_doc_event(This, EVENTID_DRAGSTART, &v);
1602 }
1603
1604 static HRESULT WINAPI HTMLDocument_get_ondragstart(IHTMLDocument2 *iface, VARIANT *p)
1605 {
1606 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1607
1608 TRACE("(%p)->(%p)\n", This, p);
1609
1610 return get_doc_event(This, EVENTID_DRAGSTART, p);
1611 }
1612
1613 static HRESULT WINAPI HTMLDocument_put_onselectstart(IHTMLDocument2 *iface, VARIANT v)
1614 {
1615 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1616
1617 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1618
1619 return set_doc_event(This, EVENTID_SELECTSTART, &v);
1620 }
1621
1622 static HRESULT WINAPI HTMLDocument_get_onselectstart(IHTMLDocument2 *iface, VARIANT *p)
1623 {
1624 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1625
1626 TRACE("(%p)->(%p)\n", This, p);
1627
1628 return get_doc_event(This, EVENTID_SELECTSTART, p);
1629 }
1630
1631 static HRESULT WINAPI HTMLDocument_elementFromPoint(IHTMLDocument2 *iface, LONG x, LONG y,
1632 IHTMLElement **elementHit)
1633 {
1634 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1635 nsIDOMElement *nselem;
1636 HTMLElement *element;
1637 nsresult nsres;
1638 HRESULT hres;
1639
1640 TRACE("(%p)->(%d %d %p)\n", This, x, y, elementHit);
1641
1642 nsres = nsIDOMHTMLDocument_ElementFromPoint(This->doc_node->nsdoc, x, y, &nselem);
1643 if(NS_FAILED(nsres)) {
1644 ERR("ElementFromPoint failed: %08x\n", nsres);
1645 return E_FAIL;
1646 }
1647
1648 if(!nselem) {
1649 *elementHit = NULL;
1650 return S_OK;
1651 }
1652
1653 hres = get_element(nselem, &element);
1654 nsIDOMElement_Release(nselem);
1655 if(FAILED(hres))
1656 return hres;
1657
1658 *elementHit = &element->IHTMLElement_iface;
1659 return S_OK;
1660 }
1661
1662 static HRESULT WINAPI HTMLDocument_get_parentWindow(IHTMLDocument2 *iface, IHTMLWindow2 **p)
1663 {
1664 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1665 HRESULT hres;
1666
1667 TRACE("(%p)->(%p)\n", This, p);
1668
1669 hres = IHTMLDocument7_get_defaultView(&This->IHTMLDocument7_iface, p);
1670 return hres == S_OK && !*p ? E_FAIL : hres;
1671 }
1672
1673 static HRESULT WINAPI HTMLDocument_get_styleSheets(IHTMLDocument2 *iface,
1674 IHTMLStyleSheetsCollection **p)
1675 {
1676 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1677 nsIDOMStyleSheetList *nsstylelist;
1678 nsresult nsres;
1679
1680 TRACE("(%p)->(%p)\n", This, p);
1681
1682 *p = NULL;
1683
1684 if(!This->doc_node->nsdoc) {
1685 WARN("NULL nsdoc\n");
1686 return E_UNEXPECTED;
1687 }
1688
1689 nsres = nsIDOMHTMLDocument_GetStyleSheets(This->doc_node->nsdoc, &nsstylelist);
1690 if(NS_FAILED(nsres)) {
1691 ERR("GetStyleSheets failed: %08x\n", nsres);
1692 return E_FAIL;
1693 }
1694
1695 *p = HTMLStyleSheetsCollection_Create(nsstylelist);
1696 nsIDOMStyleSheetList_Release(nsstylelist);
1697
1698 return S_OK;
1699 }
1700
1701 static HRESULT WINAPI HTMLDocument_put_onbeforeupdate(IHTMLDocument2 *iface, VARIANT v)
1702 {
1703 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1704 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1705 return E_NOTIMPL;
1706 }
1707
1708 static HRESULT WINAPI HTMLDocument_get_onbeforeupdate(IHTMLDocument2 *iface, VARIANT *p)
1709 {
1710 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1711 FIXME("(%p)->(%p)\n", This, p);
1712 return E_NOTIMPL;
1713 }
1714
1715 static HRESULT WINAPI HTMLDocument_put_onerrorupdate(IHTMLDocument2 *iface, VARIANT v)
1716 {
1717 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1718 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1719 return E_NOTIMPL;
1720 }
1721
1722 static HRESULT WINAPI HTMLDocument_get_onerrorupdate(IHTMLDocument2 *iface, VARIANT *p)
1723 {
1724 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1725 FIXME("(%p)->(%p)\n", This, p);
1726 return E_NOTIMPL;
1727 }
1728
1729 static HRESULT WINAPI HTMLDocument_toString(IHTMLDocument2 *iface, BSTR *String)
1730 {
1731 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1732
1733 static const WCHAR objectW[] = {'[','o','b','j','e','c','t',']',0};
1734
1735 TRACE("(%p)->(%p)\n", This, String);
1736
1737 if(!String)
1738 return E_INVALIDARG;
1739
1740 *String = SysAllocString(objectW);
1741 return *String ? S_OK : E_OUTOFMEMORY;
1742
1743 }
1744
1745 static HRESULT WINAPI HTMLDocument_createStyleSheet(IHTMLDocument2 *iface, BSTR bstrHref,
1746 LONG lIndex, IHTMLStyleSheet **ppnewStyleSheet)
1747 {
1748 HTMLDocument *This = impl_from_IHTMLDocument2(iface);
1749 nsIDOMHTMLHeadElement *head_elem;
1750 IHTMLStyleElement *style_elem;
1751 HTMLElement *elem;
1752 nsresult nsres;
1753 HRESULT hres;
1754
1755 static const WCHAR styleW[] = {'s','t','y','l','e',0};
1756
1757 TRACE("(%p)->(%s %d %p)\n", This, debugstr_w(bstrHref), lIndex, ppnewStyleSheet);
1758
1759 if(!This->doc_node->nsdoc) {
1760 FIXME("not a real doc object\n");
1761 return E_NOTIMPL;
1762 }
1763
1764 if(lIndex != -1)
1765 FIXME("Unsupported lIndex %d\n", lIndex);
1766
1767 if(bstrHref && *bstrHref) {
1768 FIXME("semi-stub for href %s\n", debugstr_w(bstrHref));
1769 *ppnewStyleSheet = HTMLStyleSheet_Create(NULL);
1770 return S_OK;
1771 }
1772
1773 hres = create_element(This->doc_node, styleW, &elem);
1774 if(FAILED(hres))
1775 return hres;
1776
1777 nsres = nsIDOMHTMLDocument_GetHead(This->doc_node->nsdoc, &head_elem);
1778 if(NS_SUCCEEDED(nsres)) {
1779 nsIDOMNode *head_node, *tmp_node;
1780
1781 nsres = nsIDOMHTMLHeadElement_QueryInterface(head_elem, &IID_nsIDOMNode, (void**)&head_node);
1782 nsIDOMHTMLHeadElement_Release(head_elem);
1783 assert(nsres == NS_OK);
1784
1785 nsres = nsIDOMNode_AppendChild(head_node, elem->node.nsnode, &tmp_node);
1786 nsIDOMNode_Release(head_node);
1787 if(NS_SUCCEEDED(nsres) && tmp_node)
1788 nsIDOMNode_Release(tmp_node);
1789 }
1790 if(NS_FAILED(nsres)) {
1791 IHTMLElement_Release(&elem->IHTMLElement_iface);
1792 return E_FAIL;
1793 }
1794
1795 hres = IHTMLElement_QueryInterface(&elem->IHTMLElement_iface, &IID_IHTMLStyleElement, (void**)&style_elem);
1796 assert(hres == S_OK);
1797 IHTMLElement_Release(&elem->IHTMLElement_iface);
1798
1799 hres = IHTMLStyleElement_get_styleSheet(style_elem, ppnewStyleSheet);
1800 IHTMLStyleElement_Release(style_elem);
1801 return hres;
1802 }
1803
1804 static const IHTMLDocument2Vtbl HTMLDocumentVtbl = {
1805 HTMLDocument_QueryInterface,
1806 HTMLDocument_AddRef,
1807 HTMLDocument_Release,
1808 HTMLDocument_GetTypeInfoCount,
1809 HTMLDocument_GetTypeInfo,
1810 HTMLDocument_GetIDsOfNames,
1811 HTMLDocument_Invoke,
1812 HTMLDocument_get_Script,
1813 HTMLDocument_get_all,
1814 HTMLDocument_get_body,
1815 HTMLDocument_get_activeElement,
1816 HTMLDocument_get_images,
1817 HTMLDocument_get_applets,
1818 HTMLDocument_get_links,
1819 HTMLDocument_get_forms,
1820 HTMLDocument_get_anchors,
1821 HTMLDocument_put_title,
1822 HTMLDocument_get_title,
1823 HTMLDocument_get_scripts,
1824 HTMLDocument_put_designMode,
1825 HTMLDocument_get_designMode,
1826 HTMLDocument_get_selection,
1827 HTMLDocument_get_readyState,
1828 HTMLDocument_get_frames,
1829 HTMLDocument_get_embeds,
1830 HTMLDocument_get_plugins,
1831 HTMLDocument_put_alinkColor,
1832 HTMLDocument_get_alinkColor,
1833 HTMLDocument_put_bgColor,
1834 HTMLDocument_get_bgColor,
1835 HTMLDocument_put_fgColor,
1836 HTMLDocument_get_fgColor,
1837 HTMLDocument_put_linkColor,
1838 HTMLDocument_get_linkColor,
1839 HTMLDocument_put_vlinkColor,
1840 HTMLDocument_get_vlinkColor,
1841 HTMLDocument_get_referrer,
1842 HTMLDocument_get_location,
1843 HTMLDocument_get_lastModified,
1844 HTMLDocument_put_URL,
1845 HTMLDocument_get_URL,
1846 HTMLDocument_put_domain,
1847 HTMLDocument_get_domain,
1848 HTMLDocument_put_cookie,
1849 HTMLDocument_get_cookie,
1850 HTMLDocument_put_expando,
1851 HTMLDocument_get_expando,
1852 HTMLDocument_put_charset,
1853 HTMLDocument_get_charset,
1854 HTMLDocument_put_defaultCharset,
1855 HTMLDocument_get_defaultCharset,
1856 HTMLDocument_get_mimeType,
1857 HTMLDocument_get_fileSize,
1858 HTMLDocument_get_fileCreatedDate,
1859 HTMLDocument_get_fileModifiedDate,
1860 HTMLDocument_get_fileUpdatedDate,
1861 HTMLDocument_get_security,
1862 HTMLDocument_get_protocol,
1863 HTMLDocument_get_nameProp,
1864 HTMLDocument_write,
1865 HTMLDocument_writeln,
1866 HTMLDocument_open,
1867 HTMLDocument_close,
1868 HTMLDocument_clear,
1869 HTMLDocument_queryCommandSupported,
1870 HTMLDocument_queryCommandEnabled,
1871 HTMLDocument_queryCommandState,
1872 HTMLDocument_queryCommandIndeterm,
1873 HTMLDocument_queryCommandText,
1874 HTMLDocument_queryCommandValue,
1875 HTMLDocument_execCommand,
1876 HTMLDocument_execCommandShowHelp,
1877 HTMLDocument_createElement,
1878 HTMLDocument_put_onhelp,
1879 HTMLDocument_get_onhelp,
1880 HTMLDocument_put_onclick,
1881 HTMLDocument_get_onclick,
1882 HTMLDocument_put_ondblclick,
1883 HTMLDocument_get_ondblclick,
1884 HTMLDocument_put_onkeyup,
1885 HTMLDocument_get_onkeyup,
1886 HTMLDocument_put_onkeydown,
1887 HTMLDocument_get_onkeydown,
1888 HTMLDocument_put_onkeypress,
1889 HTMLDocument_get_onkeypress,
1890 HTMLDocument_put_onmouseup,
1891 HTMLDocument_get_onmouseup,
1892 HTMLDocument_put_onmousedown,
1893 HTMLDocument_get_onmousedown,
1894 HTMLDocument_put_onmousemove,
1895 HTMLDocument_get_onmousemove,
1896 HTMLDocument_put_onmouseout,
1897 HTMLDocument_get_onmouseout,
1898 HTMLDocument_put_onmouseover,
1899 HTMLDocument_get_onmouseover,
1900 HTMLDocument_put_onreadystatechange,
1901 HTMLDocument_get_onreadystatechange,
1902 HTMLDocument_put_onafterupdate,
1903 HTMLDocument_get_onafterupdate,
1904 HTMLDocument_put_onrowexit,
1905 HTMLDocument_get_onrowexit,
1906 HTMLDocument_put_onrowenter,
1907 HTMLDocument_get_onrowenter,
1908 HTMLDocument_put_ondragstart,
1909 HTMLDocument_get_ondragstart,
1910 HTMLDocument_put_onselectstart,
1911 HTMLDocument_get_onselectstart,
1912 HTMLDocument_elementFromPoint,
1913 HTMLDocument_get_parentWindow,
1914 HTMLDocument_get_styleSheets,
1915 HTMLDocument_put_onbeforeupdate,
1916 HTMLDocument_get_onbeforeupdate,
1917 HTMLDocument_put_onerrorupdate,
1918 HTMLDocument_get_onerrorupdate,
1919 HTMLDocument_toString,
1920 HTMLDocument_createStyleSheet
1921 };
1922
1923 static inline HTMLDocument *impl_from_IHTMLDocument3(IHTMLDocument3 *iface)
1924 {
1925 return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument3_iface);
1926 }
1927
1928 static HRESULT WINAPI HTMLDocument3_QueryInterface(IHTMLDocument3 *iface,
1929 REFIID riid, void **ppv)
1930 {
1931 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1932 return htmldoc_query_interface(This, riid, ppv);
1933 }
1934
1935 static ULONG WINAPI HTMLDocument3_AddRef(IHTMLDocument3 *iface)
1936 {
1937 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1938 return htmldoc_addref(This);
1939 }
1940
1941 static ULONG WINAPI HTMLDocument3_Release(IHTMLDocument3 *iface)
1942 {
1943 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1944 return htmldoc_release(This);
1945 }
1946
1947 static HRESULT WINAPI HTMLDocument3_GetTypeInfoCount(IHTMLDocument3 *iface, UINT *pctinfo)
1948 {
1949 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1950 return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
1951 }
1952
1953 static HRESULT WINAPI HTMLDocument3_GetTypeInfo(IHTMLDocument3 *iface, UINT iTInfo,
1954 LCID lcid, ITypeInfo **ppTInfo)
1955 {
1956 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1957 return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1958 }
1959
1960 static HRESULT WINAPI HTMLDocument3_GetIDsOfNames(IHTMLDocument3 *iface, REFIID riid,
1961 LPOLESTR *rgszNames, UINT cNames,
1962 LCID lcid, DISPID *rgDispId)
1963 {
1964 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1965 return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
1966 rgDispId);
1967 }
1968
1969 static HRESULT WINAPI HTMLDocument3_Invoke(IHTMLDocument3 *iface, DISPID dispIdMember,
1970 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1971 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1972 {
1973 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1974 return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1975 pDispParams, pVarResult, pExcepInfo, puArgErr);
1976 }
1977
1978 static HRESULT WINAPI HTMLDocument3_releaseCapture(IHTMLDocument3 *iface)
1979 {
1980 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1981 FIXME("(%p)\n", This);
1982 return E_NOTIMPL;
1983 }
1984
1985 static HRESULT WINAPI HTMLDocument3_recalc(IHTMLDocument3 *iface, VARIANT_BOOL fForce)
1986 {
1987 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1988
1989 WARN("(%p)->(%x)\n", This, fForce);
1990
1991 /* Doing nothing here should be fine for us. */
1992 return S_OK;
1993 }
1994
1995 static HRESULT WINAPI HTMLDocument3_createTextNode(IHTMLDocument3 *iface, BSTR text,
1996 IHTMLDOMNode **newTextNode)
1997 {
1998 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
1999 nsIDOMText *nstext;
2000 HTMLDOMNode *node;
2001 nsAString text_str;
2002 nsresult nsres;
2003 HRESULT hres;
2004
2005 TRACE("(%p)->(%s %p)\n", This, debugstr_w(text), newTextNode);
2006
2007 if(!This->doc_node->nsdoc) {
2008 WARN("NULL nsdoc\n");
2009 return E_UNEXPECTED;
2010 }
2011
2012 nsAString_InitDepend(&text_str, text);
2013 nsres = nsIDOMHTMLDocument_CreateTextNode(This->doc_node->nsdoc, &text_str, &nstext);
2014 nsAString_Finish(&text_str);
2015 if(NS_FAILED(nsres)) {
2016 ERR("CreateTextNode failed: %08x\n", nsres);
2017 return E_FAIL;
2018 }
2019
2020 hres = HTMLDOMTextNode_Create(This->doc_node, (nsIDOMNode*)nstext, &node);
2021 nsIDOMText_Release(nstext);
2022 if(FAILED(hres))
2023 return hres;
2024
2025 *newTextNode = &node->IHTMLDOMNode_iface;
2026 return S_OK;
2027 }
2028
2029 static HRESULT WINAPI HTMLDocument3_get_documentElement(IHTMLDocument3 *iface, IHTMLElement **p)
2030 {
2031 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2032 nsIDOMElement *nselem = NULL;
2033 HTMLElement *element;
2034 nsresult nsres;
2035 HRESULT hres;
2036
2037 TRACE("(%p)->(%p)\n", This, p);
2038
2039 if(This->window->readystate == READYSTATE_UNINITIALIZED) {
2040 *p = NULL;
2041 return S_OK;
2042 }
2043
2044 if(!This->doc_node->nsdoc) {
2045 WARN("NULL nsdoc\n");
2046 return E_UNEXPECTED;
2047 }
2048
2049 nsres = nsIDOMHTMLDocument_GetDocumentElement(This->doc_node->nsdoc, &nselem);
2050 if(NS_FAILED(nsres)) {
2051 ERR("GetDocumentElement failed: %08x\n", nsres);
2052 return E_FAIL;
2053 }
2054
2055 if(!nselem) {
2056 *p = NULL;
2057 return S_OK;
2058 }
2059
2060 hres = get_element(nselem, &element);
2061 nsIDOMElement_Release(nselem);
2062 if(FAILED(hres))
2063 return hres;
2064
2065 *p = &element->IHTMLElement_iface;
2066 return hres;
2067 }
2068
2069 static HRESULT WINAPI HTMLDocument3_get_uniqueID(IHTMLDocument3 *iface, BSTR *p)
2070 {
2071 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2072
2073 TRACE("(%p)->(%p)\n", This, p);
2074
2075 return elem_unique_id(++This->doc_node->unique_id, p);
2076 }
2077
2078 static HRESULT WINAPI HTMLDocument3_attachEvent(IHTMLDocument3 *iface, BSTR event,
2079 IDispatch* pDisp, VARIANT_BOOL *pfResult)
2080 {
2081 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2082
2083 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
2084
2085 return attach_event(&This->doc_node->node.event_target, event, pDisp, pfResult);
2086 }
2087
2088 static HRESULT WINAPI HTMLDocument3_detachEvent(IHTMLDocument3 *iface, BSTR event,
2089 IDispatch *pDisp)
2090 {
2091 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2092
2093 TRACE("(%p)->(%s %p)\n", This, debugstr_w(event), pDisp);
2094
2095 return detach_event(&This->doc_node->node.event_target, event, pDisp);
2096 }
2097
2098 static HRESULT WINAPI HTMLDocument3_put_onrowsdelete(IHTMLDocument3 *iface, VARIANT v)
2099 {
2100 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2101 FIXME("(%p)->()\n", This);
2102 return E_NOTIMPL;
2103 }
2104
2105 static HRESULT WINAPI HTMLDocument3_get_onrowsdelete(IHTMLDocument3 *iface, VARIANT *p)
2106 {
2107 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2108 FIXME("(%p)->(%p)\n", This, p);
2109 return E_NOTIMPL;
2110 }
2111
2112 static HRESULT WINAPI HTMLDocument3_put_onrowsinserted(IHTMLDocument3 *iface, VARIANT v)
2113 {
2114 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2115 FIXME("(%p)->()\n", This);
2116 return E_NOTIMPL;
2117 }
2118
2119 static HRESULT WINAPI HTMLDocument3_get_onrowsinserted(IHTMLDocument3 *iface, VARIANT *p)
2120 {
2121 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2122 FIXME("(%p)->(%p)\n", This, p);
2123 return E_NOTIMPL;
2124 }
2125
2126 static HRESULT WINAPI HTMLDocument3_put_oncellchange(IHTMLDocument3 *iface, VARIANT v)
2127 {
2128 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2129 FIXME("(%p)->()\n", This);
2130 return E_NOTIMPL;
2131 }
2132
2133 static HRESULT WINAPI HTMLDocument3_get_oncellchange(IHTMLDocument3 *iface, VARIANT *p)
2134 {
2135 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2136 FIXME("(%p)->(%p)\n", This, p);
2137 return E_NOTIMPL;
2138 }
2139
2140 static HRESULT WINAPI HTMLDocument3_put_ondatasetchanged(IHTMLDocument3 *iface, VARIANT v)
2141 {
2142 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2143 FIXME("(%p)->()\n", This);
2144 return E_NOTIMPL;
2145 }
2146
2147 static HRESULT WINAPI HTMLDocument3_get_ondatasetchanged(IHTMLDocument3 *iface, VARIANT *p)
2148 {
2149 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2150 FIXME("(%p)->(%p)\n", This, p);
2151 return E_NOTIMPL;
2152 }
2153
2154 static HRESULT WINAPI HTMLDocument3_put_ondataavailable(IHTMLDocument3 *iface, VARIANT v)
2155 {
2156 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2157 FIXME("(%p)->()\n", This);
2158 return E_NOTIMPL;
2159 }
2160
2161 static HRESULT WINAPI HTMLDocument3_get_ondataavailable(IHTMLDocument3 *iface, VARIANT *p)
2162 {
2163 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2164 FIXME("(%p)->(%p)\n", This, p);
2165 return E_NOTIMPL;
2166 }
2167
2168 static HRESULT WINAPI HTMLDocument3_put_ondatasetcomplete(IHTMLDocument3 *iface, VARIANT v)
2169 {
2170 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2171 FIXME("(%p)->()\n", This);
2172 return E_NOTIMPL;
2173 }
2174
2175 static HRESULT WINAPI HTMLDocument3_get_ondatasetcomplete(IHTMLDocument3 *iface, VARIANT *p)
2176 {
2177 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2178 FIXME("(%p)->(%p)\n", This, p);
2179 return E_NOTIMPL;
2180 }
2181
2182 static HRESULT WINAPI HTMLDocument3_put_onpropertychange(IHTMLDocument3 *iface, VARIANT v)
2183 {
2184 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2185 FIXME("(%p)->()\n", This);
2186 return E_NOTIMPL;
2187 }
2188
2189 static HRESULT WINAPI HTMLDocument3_get_onpropertychange(IHTMLDocument3 *iface, VARIANT *p)
2190 {
2191 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2192 FIXME("(%p)->(%p)\n", This, p);
2193 return E_NOTIMPL;
2194 }
2195
2196 static HRESULT WINAPI HTMLDocument3_put_dir(IHTMLDocument3 *iface, BSTR v)
2197 {
2198 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2199 nsAString dir_str;
2200 nsresult nsres;
2201
2202 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2203
2204 if(!This->doc_node->nsdoc) {
2205 FIXME("NULL nsdoc\n");
2206 return E_UNEXPECTED;
2207 }
2208
2209 nsAString_InitDepend(&dir_str, v);
2210 nsres = nsIDOMHTMLDocument_SetDir(This->doc_node->nsdoc, &dir_str);
2211 nsAString_Finish(&dir_str);
2212 if(NS_FAILED(nsres)) {
2213 ERR("SetDir failed: %08x\n", nsres);
2214 return E_FAIL;
2215 }
2216
2217 return S_OK;
2218 }
2219
2220 static HRESULT WINAPI HTMLDocument3_get_dir(IHTMLDocument3 *iface, BSTR *p)
2221 {
2222 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2223 nsAString dir_str;
2224 nsresult nsres;
2225
2226 TRACE("(%p)->(%p)\n", This, p);
2227
2228 if(!This->doc_node->nsdoc) {
2229 FIXME("NULL nsdoc\n");
2230 return E_UNEXPECTED;
2231 }
2232
2233 nsAString_Init(&dir_str, NULL);
2234 nsres = nsIDOMHTMLDocument_GetDir(This->doc_node->nsdoc, &dir_str);
2235 return return_nsstr(nsres, &dir_str, p);
2236 }
2237
2238 static HRESULT WINAPI HTMLDocument3_put_oncontextmenu(IHTMLDocument3 *iface, VARIANT v)
2239 {
2240 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2241
2242 TRACE("(%p)->()\n", This);
2243
2244 return set_doc_event(This, EVENTID_CONTEXTMENU, &v);
2245 }
2246
2247 static HRESULT WINAPI HTMLDocument3_get_oncontextmenu(IHTMLDocument3 *iface, VARIANT *p)
2248 {
2249 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2250
2251 TRACE("(%p)->(%p)\n", This, p);
2252
2253 return get_doc_event(This, EVENTID_CONTEXTMENU, p);
2254 }
2255
2256 static HRESULT WINAPI HTMLDocument3_put_onstop(IHTMLDocument3 *iface, VARIANT v)
2257 {
2258 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2259 FIXME("(%p)->()\n", This);
2260 return E_NOTIMPL;
2261 }
2262
2263 static HRESULT WINAPI HTMLDocument3_get_onstop(IHTMLDocument3 *iface, VARIANT *p)
2264 {
2265 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2266 FIXME("(%p)->(%p)\n", This, p);
2267 return E_NOTIMPL;
2268 }
2269
2270 static HRESULT WINAPI HTMLDocument3_createDocumentFragment(IHTMLDocument3 *iface,
2271 IHTMLDocument2 **ppNewDoc)
2272 {
2273 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2274 nsIDOMDocumentFragment *doc_frag;
2275 HTMLDocumentNode *docnode;
2276 nsresult nsres;
2277 HRESULT hres;
2278
2279 TRACE("(%p)->(%p)\n", This, ppNewDoc);
2280
2281 if(!This->doc_node->nsdoc) {
2282 FIXME("NULL nsdoc\n");
2283 return E_NOTIMPL;
2284 }
2285
2286 nsres = nsIDOMHTMLDocument_CreateDocumentFragment(This->doc_node->nsdoc, &doc_frag);
2287 if(NS_FAILED(nsres)) {
2288 ERR("CreateDocumentFragment failed: %08x\n", nsres);
2289 return E_FAIL;
2290 }
2291
2292 hres = create_document_fragment((nsIDOMNode*)doc_frag, This->doc_node, &docnode);
2293 nsIDOMDocumentFragment_Release(doc_frag);
2294 if(FAILED(hres))
2295 return hres;
2296
2297 *ppNewDoc = &docnode->basedoc.IHTMLDocument2_iface;
2298 return S_OK;
2299 }
2300
2301 static HRESULT WINAPI HTMLDocument3_get_parentDocument(IHTMLDocument3 *iface,
2302 IHTMLDocument2 **p)
2303 {
2304 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2305 FIXME("(%p)->(%p)\n", This, p);
2306 return E_NOTIMPL;
2307 }
2308
2309 static HRESULT WINAPI HTMLDocument3_put_enableDownload(IHTMLDocument3 *iface,
2310 VARIANT_BOOL v)
2311 {
2312 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2313 FIXME("(%p)->(%x)\n", This, v);
2314 return E_NOTIMPL;
2315 }
2316
2317 static HRESULT WINAPI HTMLDocument3_get_enableDownload(IHTMLDocument3 *iface,
2318 VARIANT_BOOL *p)
2319 {
2320 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2321 FIXME("(%p)->(%p)\n", This, p);
2322 return E_NOTIMPL;
2323 }
2324
2325 static HRESULT WINAPI HTMLDocument3_put_baseUrl(IHTMLDocument3 *iface, BSTR v)
2326 {
2327 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2328 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2329 return E_NOTIMPL;
2330 }
2331
2332 static HRESULT WINAPI HTMLDocument3_get_baseUrl(IHTMLDocument3 *iface, BSTR *p)
2333 {
2334 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2335 FIXME("(%p)->(%p)\n", This, p);
2336 return E_NOTIMPL;
2337 }
2338
2339 static HRESULT WINAPI HTMLDocument3_get_childNodes(IHTMLDocument3 *iface, IDispatch **p)
2340 {
2341 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2342
2343 TRACE("(%p)->(%p)\n", This, p);
2344
2345 return IHTMLDOMNode_get_childNodes(&This->doc_node->node.IHTMLDOMNode_iface, p);
2346 }
2347
2348 static HRESULT WINAPI HTMLDocument3_put_inheritStyleSheets(IHTMLDocument3 *iface,
2349 VARIANT_BOOL v)
2350 {
2351 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2352 FIXME("(%p)->()\n", This);
2353 return E_NOTIMPL;
2354 }
2355
2356 static HRESULT WINAPI HTMLDocument3_get_inheritStyleSheets(IHTMLDocument3 *iface,
2357 VARIANT_BOOL *p)
2358 {
2359 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2360 FIXME("(%p)->(%p)\n", This, p);
2361 return E_NOTIMPL;
2362 }
2363
2364 static HRESULT WINAPI HTMLDocument3_put_onbeforeeditfocus(IHTMLDocument3 *iface, VARIANT v)
2365 {
2366 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2367 FIXME("(%p)->()\n", This);
2368 return E_NOTIMPL;
2369 }
2370
2371 static HRESULT WINAPI HTMLDocument3_get_onbeforeeditfocus(IHTMLDocument3 *iface, VARIANT *p)
2372 {
2373 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2374 FIXME("(%p)->(%p)\n", This, p);
2375 return E_NOTIMPL;
2376 }
2377
2378 static HRESULT WINAPI HTMLDocument3_getElementsByName(IHTMLDocument3 *iface, BSTR v,
2379 IHTMLElementCollection **ppelColl)
2380 {
2381 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2382 nsIDOMNodeList *node_list;
2383 nsAString selector_str;
2384 WCHAR *selector;
2385 nsresult nsres;
2386
2387 static const WCHAR formatW[] = {'*','[','i','d','=','%','s',']',',','*','[','n','a','m','e','=','%','s',']',0};
2388
2389 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), ppelColl);
2390
2391 if(!This->doc_node || !This->doc_node->nsdoc) {
2392 /* We should probably return an empty collection. */
2393 FIXME("No nsdoc\n");
2394 return E_NOTIMPL;
2395 }
2396
2397 selector = heap_alloc(2*SysStringLen(v)*sizeof(WCHAR) + sizeof(formatW));
2398 if(!selector)
2399 return E_OUTOFMEMORY;
2400 swprintf(selector, 2*SysStringLen(v) + ARRAY_SIZE(formatW), formatW, v, v);
2401
2402 /*
2403 * NOTE: IE getElementsByName implementation differs from Gecko. It searches both name and id attributes.
2404 * That's why we use CSS selector instead. We should also use name only when it applies to given element
2405 * types and search should be case insensitive. Those are currently not supported properly.
2406 */
2407 nsAString_InitDepend(&selector_str, selector);
2408 nsres = nsIDOMHTMLDocument_QuerySelectorAll(This->doc_node->nsdoc, &selector_str, &node_list);
2409 nsAString_Finish(&selector_str);
2410 heap_free(selector);
2411 if(NS_FAILED(nsres)) {
2412 ERR("QuerySelectorAll failed: %08x\n", nsres);
2413 return E_FAIL;
2414 }
2415
2416 *ppelColl = create_collection_from_nodelist(node_list, This->doc_node->document_mode);
2417 nsIDOMNodeList_Release(node_list);
2418 return S_OK;
2419 }
2420
2421
2422 static HRESULT WINAPI HTMLDocument3_getElementById(IHTMLDocument3 *iface, BSTR v,
2423 IHTMLElement **pel)
2424 {
2425 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2426 HTMLElement *elem;
2427 HRESULT hres;
2428
2429 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
2430
2431 hres = get_doc_elem_by_id(This->doc_node, v, &elem);
2432 if(FAILED(hres) || !elem) {
2433 *pel = NULL;
2434 return hres;
2435 }
2436
2437 *pel = &elem->IHTMLElement_iface;
2438 return S_OK;
2439 }
2440
2441
2442 static HRESULT WINAPI HTMLDocument3_getElementsByTagName(IHTMLDocument3 *iface, BSTR v,
2443 IHTMLElementCollection **pelColl)
2444 {
2445 HTMLDocument *This = impl_from_IHTMLDocument3(iface);
2446 nsIDOMNodeList *nslist;
2447 nsAString id_str;
2448 nsresult nsres;
2449
2450 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pelColl);
2451
2452 if(This->doc_node->nsdoc) {
2453 nsAString_InitDepend(&id_str, v);
2454 nsres = nsIDOMHTMLDocument_GetElementsByTagName(This->doc_node->nsdoc, &id_str, &nslist);
2455 nsAString_Finish(&id_str);
2456 if(FAILED(nsres)) {
2457 ERR("GetElementByName failed: %08x\n", nsres);
2458 return E_FAIL;
2459 }
2460 }else {
2461 nsIDOMDocumentFragment *docfrag;
2462 nsAString nsstr;
2463
2464 if(v) {
2465 const WCHAR *ptr;
2466 for(ptr=v; *ptr; ptr++) {
2467 if(!iswalnum(*ptr)) {
2468 FIXME("Unsupported invalid tag %s\n", debugstr_w(v));
2469 return E_NOTIMPL;
2470 }
2471 }
2472 }
2473
2474 nsres = nsIDOMNode_QueryInterface(This->doc_node->node.nsnode, &IID_nsIDOMDocumentFragment, (void**)&docfrag);
2475 if(NS_FAILED(nsres)) {
2476 ERR("Could not get nsIDOMDocumentFragment iface: %08x\n", nsres);
2477 return E_UNEXPECTED;
2478 }
2479
2480 nsAString_InitDepend(&nsstr, v);
2481 nsres = nsIDOMDocumentFragment_QuerySelectorAll(docfrag, &nsstr, &nslist);
2482 nsAString_Finish(&nsstr);
2483 nsIDOMDocumentFragment_Release(docfrag);
2484 if(NS_FAILED(nsres)) {
2485 ERR("QuerySelectorAll failed: %08x\n", nsres);
2486 return E_FAIL;
2487 }
2488 }
2489
2490
2491 *pelColl = create_collection_from_nodelist(nslist, This->doc_node->document_mode);
2492 nsIDOMNodeList_Release(nslist);
2493
2494 return S_OK;
2495 }
2496
2497 static const IHTMLDocument3Vtbl HTMLDocument3Vtbl = {
2498 HTMLDocument3_QueryInterface,
2499 HTMLDocument3_AddRef,
2500 HTMLDocument3_Release,
2501 HTMLDocument3_GetTypeInfoCount,
2502 HTMLDocument3_GetTypeInfo,
2503 HTMLDocument3_GetIDsOfNames,
2504 HTMLDocument3_Invoke,
2505 HTMLDocument3_releaseCapture,
2506 HTMLDocument3_recalc,
2507 HTMLDocument3_createTextNode,
2508 HTMLDocument3_get_documentElement,
2509 HTMLDocument3_get_uniqueID,
2510 HTMLDocument3_attachEvent,
2511 HTMLDocument3_detachEvent,
2512 HTMLDocument3_put_onrowsdelete,
2513 HTMLDocument3_get_onrowsdelete,
2514 HTMLDocument3_put_onrowsinserted,
2515 HTMLDocument3_get_onrowsinserted,
2516 HTMLDocument3_put_oncellchange,
2517 HTMLDocument3_get_oncellchange,
2518 HTMLDocument3_put_ondatasetchanged,
2519 HTMLDocument3_get_ondatasetchanged,
2520 HTMLDocument3_put_ondataavailable,
2521 HTMLDocument3_get_ondataavailable,
2522 HTMLDocument3_put_ondatasetcomplete,
2523 HTMLDocument3_get_ondatasetcomplete,
2524 HTMLDocument3_put_onpropertychange,
2525 HTMLDocument3_get_onpropertychange,
2526 HTMLDocument3_put_dir,
2527 HTMLDocument3_get_dir,
2528 HTMLDocument3_put_oncontextmenu,
2529 HTMLDocument3_get_oncontextmenu,
2530 HTMLDocument3_put_onstop,
2531 HTMLDocument3_get_onstop,
2532 HTMLDocument3_createDocumentFragment,
2533 HTMLDocument3_get_parentDocument,
2534 HTMLDocument3_put_enableDownload,
2535 HTMLDocument3_get_enableDownload,
2536 HTMLDocument3_put_baseUrl,
2537 HTMLDocument3_get_baseUrl,
2538 HTMLDocument3_get_childNodes,
2539 HTMLDocument3_put_inheritStyleSheets,
2540 HTMLDocument3_get_inheritStyleSheets,
2541 HTMLDocument3_put_onbeforeeditfocus,
2542 HTMLDocument3_get_onbeforeeditfocus,
2543 HTMLDocument3_getElementsByName,
2544 HTMLDocument3_getElementById,
2545 HTMLDocument3_getElementsByTagName
2546 };
2547
2548 static inline HTMLDocument *impl_from_IHTMLDocument4(IHTMLDocument4 *iface)
2549 {
2550 return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument4_iface);
2551 }
2552
2553 static HRESULT WINAPI HTMLDocument4_QueryInterface(IHTMLDocument4 *iface,
2554 REFIID riid, void **ppv)
2555 {
2556 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2557 return htmldoc_query_interface(This, riid, ppv);
2558 }
2559
2560 static ULONG WINAPI HTMLDocument4_AddRef(IHTMLDocument4 *iface)
2561 {
2562 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2563 return htmldoc_addref(This);
2564 }
2565
2566 static ULONG WINAPI HTMLDocument4_Release(IHTMLDocument4 *iface)
2567 {
2568 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2569 return htmldoc_release(This);
2570 }
2571
2572 static HRESULT WINAPI HTMLDocument4_GetTypeInfoCount(IHTMLDocument4 *iface, UINT *pctinfo)
2573 {
2574 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2575 return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
2576 }
2577
2578 static HRESULT WINAPI HTMLDocument4_GetTypeInfo(IHTMLDocument4 *iface, UINT iTInfo,
2579 LCID lcid, ITypeInfo **ppTInfo)
2580 {
2581 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2582 return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2583 }
2584
2585 static HRESULT WINAPI HTMLDocument4_GetIDsOfNames(IHTMLDocument4 *iface, REFIID riid,
2586 LPOLESTR *rgszNames, UINT cNames,
2587 LCID lcid, DISPID *rgDispId)
2588 {
2589 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2590 return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
2591 rgDispId);
2592 }
2593
2594 static HRESULT WINAPI HTMLDocument4_Invoke(IHTMLDocument4 *iface, DISPID dispIdMember,
2595 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2596 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2597 {
2598 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2599 return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2600 pDispParams, pVarResult, pExcepInfo, puArgErr);
2601 }
2602
2603 static HRESULT WINAPI HTMLDocument4_focus(IHTMLDocument4 *iface)
2604 {
2605 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2606 nsIDOMHTMLElement *nsbody;
2607 nsresult nsres;
2608
2609 TRACE("(%p)->()\n", This);
2610
2611 nsres = nsIDOMHTMLDocument_GetBody(This->doc_node->nsdoc, &nsbody);
2612 if(NS_FAILED(nsres) || !nsbody) {
2613 ERR("GetBody failed: %08x\n", nsres);
2614 return E_FAIL;
2615 }
2616
2617 nsres = nsIDOMHTMLElement_Focus(nsbody);
2618 nsIDOMHTMLElement_Release(nsbody);
2619 if(NS_FAILED(nsres)) {
2620 ERR("Focus failed: %08x\n", nsres);
2621 return E_FAIL;
2622 }
2623
2624 return S_OK;
2625 }
2626
2627 static HRESULT WINAPI HTMLDocument4_hasFocus(IHTMLDocument4 *iface, VARIANT_BOOL *pfFocus)
2628 {
2629 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2630 cpp_bool has_focus;
2631 nsresult nsres;
2632
2633 TRACE("(%p)->(%p)\n", This, pfFocus);
2634
2635 if(!This->doc_node->nsdoc) {
2636 FIXME("Unimplemented for fragments.\n");
2637 return E_NOTIMPL;
2638 }
2639
2640 nsres = nsIDOMHTMLDocument_HasFocus(This->doc_node->nsdoc, &has_focus);
2641 assert(nsres == NS_OK);
2642
2643 *pfFocus = variant_bool(has_focus);
2644 return S_OK;
2645 }
2646
2647 static HRESULT WINAPI HTMLDocument4_put_onselectionchange(IHTMLDocument4 *iface, VARIANT v)
2648 {
2649 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2650
2651 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2652
2653 return set_doc_event(This, EVENTID_SELECTIONCHANGE, &v);
2654 }
2655
2656 static HRESULT WINAPI HTMLDocument4_get_onselectionchange(IHTMLDocument4 *iface, VARIANT *p)
2657 {
2658 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2659
2660 TRACE("(%p)->(%p)\n", This, p);
2661
2662 return get_doc_event(This, EVENTID_SELECTIONCHANGE, p);
2663 }
2664
2665 static HRESULT WINAPI HTMLDocument4_get_namespaces(IHTMLDocument4 *iface, IDispatch **p)
2666 {
2667 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2668
2669 TRACE("(%p)->(%p)\n", This, p);
2670
2671 if(!This->doc_node->namespaces) {
2672 HRESULT hres;
2673
2674 hres = create_namespace_collection(&This->doc_node->namespaces);
2675 if(FAILED(hres))
2676 return hres;
2677 }
2678
2679 IHTMLNamespaceCollection_AddRef(This->doc_node->namespaces);
2680 *p = (IDispatch*)This->doc_node->namespaces;
2681 return S_OK;
2682 }
2683
2684 static HRESULT WINAPI HTMLDocument4_createDocumentFromUrl(IHTMLDocument4 *iface, BSTR bstrUrl,
2685 BSTR bstrOptions, IHTMLDocument2 **newDoc)
2686 {
2687 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2688 FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(bstrUrl), debugstr_w(bstrOptions), newDoc);
2689 return E_NOTIMPL;
2690 }
2691
2692 static HRESULT WINAPI HTMLDocument4_put_media(IHTMLDocument4 *iface, BSTR v)
2693 {
2694 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2695 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2696 return E_NOTIMPL;
2697 }
2698
2699 static HRESULT WINAPI HTMLDocument4_get_media(IHTMLDocument4 *iface, BSTR *p)
2700 {
2701 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2702 FIXME("(%p)->(%p)\n", This, p);
2703 return E_NOTIMPL;
2704 }
2705
2706 static HRESULT WINAPI HTMLDocument4_createEventObject(IHTMLDocument4 *iface,
2707 VARIANT *pvarEventObject, IHTMLEventObj **ppEventObj)
2708 {
2709 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2710
2711 TRACE("(%p)->(%s %p)\n", This, debugstr_variant(pvarEventObject), ppEventObj);
2712
2713 if(pvarEventObject && V_VT(pvarEventObject) != VT_ERROR && V_VT(pvarEventObject) != VT_EMPTY) {
2714 FIXME("unsupported pvarEventObject %s\n", debugstr_variant(pvarEventObject));
2715 return E_NOTIMPL;
2716 }
2717
2718 return create_event_obj(ppEventObj);
2719 }
2720
2721 static HRESULT WINAPI HTMLDocument4_fireEvent(IHTMLDocument4 *iface, BSTR bstrEventName,
2722 VARIANT *pvarEventObject, VARIANT_BOOL *pfCanceled)
2723 {
2724 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2725
2726 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(bstrEventName), pvarEventObject, pfCanceled);
2727
2728 return fire_event(&This->doc_node->node, bstrEventName, pvarEventObject, pfCanceled);
2729 }
2730
2731 static HRESULT WINAPI HTMLDocument4_createRenderStyle(IHTMLDocument4 *iface, BSTR v,
2732 IHTMLRenderStyle **ppIHTMLRenderStyle)
2733 {
2734 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2735 FIXME("(%p)->(%s %p)\n", This, debugstr_w(v), ppIHTMLRenderStyle);
2736 return E_NOTIMPL;
2737 }
2738
2739 static HRESULT WINAPI HTMLDocument4_put_oncontrolselect(IHTMLDocument4 *iface, VARIANT v)
2740 {
2741 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2742 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2743 return E_NOTIMPL;
2744 }
2745
2746 static HRESULT WINAPI HTMLDocument4_get_oncontrolselect(IHTMLDocument4 *iface, VARIANT *p)
2747 {
2748 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2749 FIXME("(%p)->(%p)\n", This, p);
2750 return E_NOTIMPL;
2751 }
2752
2753 static HRESULT WINAPI HTMLDocument4_get_URLEncoded(IHTMLDocument4 *iface, BSTR *p)
2754 {
2755 HTMLDocument *This = impl_from_IHTMLDocument4(iface);
2756 FIXME("(%p)->(%p)\n", This, p);
2757 return E_NOTIMPL;
2758 }
2759
2760 static const IHTMLDocument4Vtbl HTMLDocument4Vtbl = {
2761 HTMLDocument4_QueryInterface,
2762 HTMLDocument4_AddRef,
2763 HTMLDocument4_Release,
2764 HTMLDocument4_GetTypeInfoCount,
2765 HTMLDocument4_GetTypeInfo,
2766 HTMLDocument4_GetIDsOfNames,
2767 HTMLDocument4_Invoke,
2768 HTMLDocument4_focus,
2769 HTMLDocument4_hasFocus,
2770 HTMLDocument4_put_onselectionchange,
2771 HTMLDocument4_get_onselectionchange,
2772 HTMLDocument4_get_namespaces,
2773 HTMLDocument4_createDocumentFromUrl,
2774 HTMLDocument4_put_media,
2775 HTMLDocument4_get_media,
2776 HTMLDocument4_createEventObject,
2777 HTMLDocument4_fireEvent,
2778 HTMLDocument4_createRenderStyle,
2779 HTMLDocument4_put_oncontrolselect,
2780 HTMLDocument4_get_oncontrolselect,
2781 HTMLDocument4_get_URLEncoded
2782 };
2783
2784 static inline HTMLDocument *impl_from_IHTMLDocument5(IHTMLDocument5 *iface)
2785 {
2786 return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument5_iface);
2787 }
2788
2789 static HRESULT WINAPI HTMLDocument5_QueryInterface(IHTMLDocument5 *iface,
2790 REFIID riid, void **ppv)
2791 {
2792 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2793 return htmldoc_query_interface(This, riid, ppv);
2794 }
2795
2796 static ULONG WINAPI HTMLDocument5_AddRef(IHTMLDocument5 *iface)
2797 {
2798 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2799 return htmldoc_addref(This);
2800 }
2801
2802 static ULONG WINAPI HTMLDocument5_Release(IHTMLDocument5 *iface)
2803 {
2804 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2805 return htmldoc_release(This);
2806 }
2807
2808 static HRESULT WINAPI HTMLDocument5_GetTypeInfoCount(IHTMLDocument5 *iface, UINT *pctinfo)
2809 {
2810 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2811 return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
2812 }
2813
2814 static HRESULT WINAPI HTMLDocument5_GetTypeInfo(IHTMLDocument5 *iface, UINT iTInfo,
2815 LCID lcid, ITypeInfo **ppTInfo)
2816 {
2817 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2818 return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2819 }
2820
2821 static HRESULT WINAPI HTMLDocument5_GetIDsOfNames(IHTMLDocument5 *iface, REFIID riid,
2822 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2823 {
2824 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2825 return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
2826 rgDispId);
2827 }
2828
2829 static HRESULT WINAPI HTMLDocument5_Invoke(IHTMLDocument5 *iface, DISPID dispIdMember,
2830 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2831 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2832 {
2833 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2834 return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2835 pDispParams, pVarResult, pExcepInfo, puArgErr);
2836 }
2837
2838 static HRESULT WINAPI HTMLDocument5_put_onmousewheel(IHTMLDocument5 *iface, VARIANT v)
2839 {
2840 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2841
2842 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2843
2844 return set_doc_event(This, EVENTID_MOUSEWHEEL, &v);
2845 }
2846
2847 static HRESULT WINAPI HTMLDocument5_get_onmousewheel(IHTMLDocument5 *iface, VARIANT *p)
2848 {
2849 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2850
2851 TRACE("(%p)->(%p)\n", This, p);
2852
2853 return get_doc_event(This, EVENTID_MOUSEWHEEL, p);
2854 }
2855
2856 static HRESULT WINAPI HTMLDocument5_get_doctype(IHTMLDocument5 *iface, IHTMLDOMNode **p)
2857 {
2858 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2859 FIXME("(%p)->(%p)\n", This, p);
2860 return E_NOTIMPL;
2861 }
2862
2863 static HRESULT WINAPI HTMLDocument5_get_implementation(IHTMLDocument5 *iface, IHTMLDOMImplementation **p)
2864 {
2865 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2866 HTMLDocumentNode *doc_node = This->doc_node;
2867
2868 TRACE("(%p)->(%p)\n", This, p);
2869
2870 if(!doc_node->dom_implementation) {
2871 HRESULT hres;
2872
2873 hres = create_dom_implementation(doc_node, &doc_node->dom_implementation);
2874 if(FAILED(hres))
2875 return hres;
2876 }
2877
2878 IHTMLDOMImplementation_AddRef(doc_node->dom_implementation);
2879 *p = doc_node->dom_implementation;
2880 return S_OK;
2881 }
2882
2883 static HRESULT WINAPI HTMLDocument5_createAttribute(IHTMLDocument5 *iface, BSTR bstrattrName,
2884 IHTMLDOMAttribute **ppattribute)
2885 {
2886 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2887 HTMLDOMAttribute *attr;
2888 HRESULT hres;
2889
2890 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrattrName), ppattribute);
2891
2892 hres = HTMLDOMAttribute_Create(bstrattrName, NULL, 0, &attr);
2893 if(FAILED(hres))
2894 return hres;
2895
2896 *ppattribute = &attr->IHTMLDOMAttribute_iface;
2897 return S_OK;
2898 }
2899
2900 static HRESULT WINAPI HTMLDocument5_createComment(IHTMLDocument5 *iface, BSTR bstrdata,
2901 IHTMLDOMNode **ppRetNode)
2902 {
2903 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2904 nsIDOMComment *nscomment;
2905 HTMLElement *elem;
2906 nsAString str;
2907 nsresult nsres;
2908 HRESULT hres;
2909
2910 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrdata), ppRetNode);
2911
2912 if(!This->doc_node->nsdoc) {
2913 WARN("NULL nsdoc\n");
2914 return E_UNEXPECTED;
2915 }
2916
2917 nsAString_InitDepend(&str, bstrdata);
2918 nsres = nsIDOMHTMLDocument_CreateComment(This->doc_node->nsdoc, &str, &nscomment);
2919 nsAString_Finish(&str);
2920 if(NS_FAILED(nsres)) {
2921 ERR("CreateTextNode failed: %08x\n", nsres);
2922 return E_FAIL;
2923 }
2924
2925 hres = HTMLCommentElement_Create(This->doc_node, (nsIDOMNode*)nscomment, &elem);
2926 nsIDOMComment_Release(nscomment);
2927 if(FAILED(hres))
2928 return hres;
2929
2930 *ppRetNode = &elem->node.IHTMLDOMNode_iface;
2931 return S_OK;
2932 }
2933
2934 static HRESULT WINAPI HTMLDocument5_put_onfocusin(IHTMLDocument5 *iface, VARIANT v)
2935 {
2936 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2937
2938 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2939
2940 return set_doc_event(This, EVENTID_FOCUSIN, &v);
2941 }
2942
2943 static HRESULT WINAPI HTMLDocument5_get_onfocusin(IHTMLDocument5 *iface, VARIANT *p)
2944 {
2945 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2946
2947 TRACE("(%p)->(%p)\n", This, p);
2948
2949 return get_doc_event(This, EVENTID_FOCUSIN, p);
2950 }
2951
2952 static HRESULT WINAPI HTMLDocument5_put_onfocusout(IHTMLDocument5 *iface, VARIANT v)
2953 {
2954 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2955
2956 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2957
2958 return set_doc_event(This, EVENTID_FOCUSOUT, &v);
2959 }
2960
2961 static HRESULT WINAPI HTMLDocument5_get_onfocusout(IHTMLDocument5 *iface, VARIANT *p)
2962 {
2963 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2964
2965 TRACE("(%p)->(%p)\n", This, p);
2966
2967 return get_doc_event(This, EVENTID_FOCUSOUT, p);
2968 }
2969
2970 static HRESULT WINAPI HTMLDocument5_put_onactivate(IHTMLDocument5 *iface, VARIANT v)
2971 {
2972 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2973 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2974 return E_NOTIMPL;
2975 }
2976
2977 static HRESULT WINAPI HTMLDocument5_get_onactivate(IHTMLDocument5 *iface, VARIANT *p)
2978 {
2979 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2980 FIXME("(%p)->(%p)\n", This, p);
2981 return E_NOTIMPL;
2982 }
2983
2984 static HRESULT WINAPI HTMLDocument5_put_ondeactivate(IHTMLDocument5 *iface, VARIANT v)
2985 {
2986 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2987 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2988 return E_NOTIMPL;
2989 }
2990
2991 static HRESULT WINAPI HTMLDocument5_get_ondeactivate(IHTMLDocument5 *iface, VARIANT *p)
2992 {
2993 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
2994 FIXME("(%p)->(%p)\n", This, p);
2995 return E_NOTIMPL;
2996 }
2997
2998 static HRESULT WINAPI HTMLDocument5_put_onbeforeactivate(IHTMLDocument5 *iface, VARIANT v)
2999 {
3000 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
3001 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3002 return E_NOTIMPL;
3003 }
3004
3005 static HRESULT WINAPI HTMLDocument5_get_onbeforeactivate(IHTMLDocument5 *iface, VARIANT *p)
3006 {
3007 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
3008 FIXME("(%p)->(%p)\n", This, p);
3009 return E_NOTIMPL;
3010 }
3011
3012 static HRESULT WINAPI HTMLDocument5_put_onbeforedeactivate(IHTMLDocument5 *iface, VARIANT v)
3013 {
3014 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
3015 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3016 return E_NOTIMPL;
3017 }
3018
3019 static HRESULT WINAPI HTMLDocument5_get_onbeforedeactivate(IHTMLDocument5 *iface, VARIANT *p)
3020 {
3021 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
3022 FIXME("(%p)->(%p)\n", This, p);
3023 return E_NOTIMPL;
3024 }
3025
3026 static HRESULT WINAPI HTMLDocument5_get_compatMode(IHTMLDocument5 *iface, BSTR *p)
3027 {
3028 HTMLDocument *This = impl_from_IHTMLDocument5(iface);
3029
3030 static const WCHAR BackCompatW[] = {'B','a','c','k','C','o','m','p','a','t',0};
3031 static const WCHAR CSS1CompatW[] = {'C','S','S','1','C','o','m','p','a','t',0};
3032
3033 TRACE("(%p)->(%p)\n", This, p);
3034
3035 *p = SysAllocString(This->doc_node->document_mode <= COMPAT_MODE_IE5 ? BackCompatW : CSS1CompatW);
3036 return *p ? S_OK : E_OUTOFMEMORY;
3037 }
3038
3039 static const IHTMLDocument5Vtbl HTMLDocument5Vtbl = {
3040 HTMLDocument5_QueryInterface,
3041 HTMLDocument5_AddRef,
3042 HTMLDocument5_Release,
3043 HTMLDocument5_GetTypeInfoCount,
3044 HTMLDocument5_GetTypeInfo,
3045 HTMLDocument5_GetIDsOfNames,
3046 HTMLDocument5_Invoke,
3047 HTMLDocument5_put_onmousewheel,
3048 HTMLDocument5_get_onmousewheel,
3049 HTMLDocument5_get_doctype,
3050 HTMLDocument5_get_implementation,
3051 HTMLDocument5_createAttribute,
3052 HTMLDocument5_createComment,
3053 HTMLDocument5_put_onfocusin,
3054 HTMLDocument5_get_onfocusin,
3055 HTMLDocument5_put_onfocusout,
3056 HTMLDocument5_get_onfocusout,
3057 HTMLDocument5_put_onactivate,
3058 HTMLDocument5_get_onactivate,
3059 HTMLDocument5_put_ondeactivate,
3060 HTMLDocument5_get_ondeactivate,
3061 HTMLDocument5_put_onbeforeactivate,
3062 HTMLDocument5_get_onbeforeactivate,
3063 HTMLDocument5_put_onbeforedeactivate,
3064 HTMLDocument5_get_onbeforedeactivate,
3065 HTMLDocument5_get_compatMode
3066 };
3067
3068 static inline HTMLDocument *impl_from_IHTMLDocument6(IHTMLDocument6 *iface)
3069 {
3070 return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument6_iface);
3071 }
3072
3073 static HRESULT WINAPI HTMLDocument6_QueryInterface(IHTMLDocument6 *iface,
3074 REFIID riid, void **ppv)
3075 {
3076 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3077 return htmldoc_query_interface(This, riid, ppv);
3078 }
3079
3080 static ULONG WINAPI HTMLDocument6_AddRef(IHTMLDocument6 *iface)
3081 {
3082 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3083 return htmldoc_addref(This);
3084 }
3085
3086 static ULONG WINAPI HTMLDocument6_Release(IHTMLDocument6 *iface)
3087 {
3088 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3089 return htmldoc_release(This);
3090 }
3091
3092 static HRESULT WINAPI HTMLDocument6_GetTypeInfoCount(IHTMLDocument6 *iface, UINT *pctinfo)
3093 {
3094 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3095 return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
3096 }
3097
3098 static HRESULT WINAPI HTMLDocument6_GetTypeInfo(IHTMLDocument6 *iface, UINT iTInfo,
3099 LCID lcid, ITypeInfo **ppTInfo)
3100 {
3101 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3102 return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3103 }
3104
3105 static HRESULT WINAPI HTMLDocument6_GetIDsOfNames(IHTMLDocument6 *iface, REFIID riid,
3106 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3107 {
3108 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3109 return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
3110 rgDispId);
3111 }
3112
3113 static HRESULT WINAPI HTMLDocument6_Invoke(IHTMLDocument6 *iface, DISPID dispIdMember,
3114 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3115 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3116 {
3117 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3118 return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
3119 pDispParams, pVarResult, pExcepInfo, puArgErr);
3120 }
3121
3122 static HRESULT WINAPI HTMLDocument6_get_compatible(IHTMLDocument6 *iface,
3123 IHTMLDocumentCompatibleInfoCollection **p)
3124 {
3125 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3126 FIXME("(%p)->(%p)\n", This, p);
3127 return E_NOTIMPL;
3128 }
3129
3130 static HRESULT WINAPI HTMLDocument6_get_documentMode(IHTMLDocument6 *iface, VARIANT *p)
3131 {
3132 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3133
3134 TRACE("(%p)->(%p)\n", This, p);
3135
3136 if(!This->doc_node) {
3137 FIXME("NULL doc_node\n");
3138 return E_UNEXPECTED;
3139 }
3140
3141 V_VT(p) = VT_R4;
3142 V_R4(p) = compat_mode_info[This->doc_node->document_mode].document_mode;
3143 return S_OK;
3144 }
3145
3146 static HRESULT WINAPI HTMLDocument6_get_onstorage(IHTMLDocument6 *iface,
3147 VARIANT *p)
3148 {
3149 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3150 FIXME("(%p)->(%p)\n", This, p);
3151 return E_NOTIMPL;
3152 }
3153
3154 static HRESULT WINAPI HTMLDocument6_put_onstorage(IHTMLDocument6 *iface, VARIANT v)
3155 {
3156 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3157 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3158 return E_NOTIMPL;
3159 }
3160
3161 static HRESULT WINAPI HTMLDocument6_get_onstoragecommit(IHTMLDocument6 *iface,
3162 VARIANT *p)
3163 {
3164 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3165 FIXME("(%p)->(%p)\n", This, p);
3166 return E_NOTIMPL;
3167 }
3168
3169 static HRESULT WINAPI HTMLDocument6_put_onstoragecommit(IHTMLDocument6 *iface, VARIANT v)
3170 {
3171 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3172 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3173 return E_NOTIMPL;
3174 }
3175
3176 static HRESULT WINAPI HTMLDocument6_getElementById(IHTMLDocument6 *iface,
3177 BSTR bstrId, IHTMLElement2 **p)
3178 {
3179 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3180 nsIDOMElement *nselem;
3181 HTMLElement *elem;
3182 nsAString nsstr;
3183 nsresult nsres;
3184 HRESULT hres;
3185
3186 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrId), p);
3187
3188 /*
3189 * Unlike IHTMLDocument3 implementation, this is standard compliant and does
3190 * not search for name attributes, so we may simply let Gecko do the right thing.
3191 */
3192
3193 if(!This->doc_node->nsdoc) {
3194 FIXME("Not a document\n");
3195 return E_FAIL;
3196 }
3197
3198 nsAString_InitDepend(&nsstr, bstrId);
3199 nsres = nsIDOMHTMLDocument_GetElementById(This->doc_node->nsdoc, &nsstr, &nselem);
3200 nsAString_Finish(&nsstr);
3201 if(NS_FAILED(nsres)) {
3202 ERR("GetElementById failed: %08x\n", nsres);
3203 return E_FAIL;
3204 }
3205
3206 if(!nselem) {
3207 *p = NULL;
3208 return S_OK;
3209 }
3210
3211 hres = get_element(nselem, &elem);
3212 nsIDOMElement_Release(nselem);
3213 if(FAILED(hres))
3214 return hres;
3215
3216 *p = &elem->IHTMLElement2_iface;
3217 return S_OK;
3218 }
3219
3220 static HRESULT WINAPI HTMLDocument6_updateSettings(IHTMLDocument6 *iface)
3221 {
3222 HTMLDocument *This = impl_from_IHTMLDocument6(iface);
3223 FIXME("(%p)->()\n", This);
3224 return E_NOTIMPL;
3225 }
3226
3227 static const IHTMLDocument6Vtbl HTMLDocument6Vtbl = {
3228 HTMLDocument6_QueryInterface,
3229 HTMLDocument6_AddRef,
3230 HTMLDocument6_Release,
3231 HTMLDocument6_GetTypeInfoCount,
3232 HTMLDocument6_GetTypeInfo,
3233 HTMLDocument6_GetIDsOfNames,
3234 HTMLDocument6_Invoke,
3235 HTMLDocument6_get_compatible,
3236 HTMLDocument6_get_documentMode,
3237 HTMLDocument6_put_onstorage,
3238 HTMLDocument6_get_onstorage,
3239 HTMLDocument6_put_onstoragecommit,
3240 HTMLDocument6_get_onstoragecommit,
3241 HTMLDocument6_getElementById,
3242 HTMLDocument6_updateSettings
3243 };
3244
3245 static inline HTMLDocument *impl_from_IHTMLDocument7(IHTMLDocument7 *iface)
3246 {
3247 return CONTAINING_RECORD(iface, HTMLDocument, IHTMLDocument7_iface);
3248 }
3249
3250 static HRESULT WINAPI HTMLDocument7_QueryInterface(IHTMLDocument7 *iface, REFIID riid, void **ppv)
3251 {
3252 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3253 return htmldoc_query_interface(This, riid, ppv);
3254 }
3255
3256 static ULONG WINAPI HTMLDocument7_AddRef(IHTMLDocument7 *iface)
3257 {
3258 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3259 return htmldoc_addref(This);
3260 }
3261
3262 static ULONG WINAPI HTMLDocument7_Release(IHTMLDocument7 *iface)
3263 {
3264 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3265 return htmldoc_release(This);
3266 }
3267
3268 static HRESULT WINAPI HTMLDocument7_GetTypeInfoCount(IHTMLDocument7 *iface, UINT *pctinfo)
3269 {
3270 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3271 return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
3272 }
3273
3274 static HRESULT WINAPI HTMLDocument7_GetTypeInfo(IHTMLDocument7 *iface, UINT iTInfo,
3275 LCID lcid, ITypeInfo **ppTInfo)
3276 {
3277 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3278 return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3279 }
3280
3281 static HRESULT WINAPI HTMLDocument7_GetIDsOfNames(IHTMLDocument7 *iface, REFIID riid,
3282 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3283 {
3284 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3285 return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
3286 rgDispId);
3287 }
3288
3289 static HRESULT WINAPI HTMLDocument7_Invoke(IHTMLDocument7 *iface, DISPID dispIdMember,
3290 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3291 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3292 {
3293 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3294 return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
3295 pDispParams, pVarResult, pExcepInfo, puArgErr);
3296 }
3297
3298 static HRESULT WINAPI HTMLDocument7_get_defaultView(IHTMLDocument7 *iface, IHTMLWindow2 **p)
3299 {
3300 HTMLDocumentNode *This = impl_from_IHTMLDocument7(iface)->doc_node;
3301
3302 TRACE("(%p)->(%p)\n", This, p);
3303
3304 if(This->window && This->window->base.outer_window) {
3305 *p = &This->window->base.outer_window->base.IHTMLWindow2_iface;
3306 IHTMLWindow2_AddRef(*p);
3307 }else {
3308 *p = NULL;
3309 }
3310 return S_OK;
3311 }
3312
3313 static HRESULT WINAPI HTMLDocument7_createCDATASection(IHTMLDocument7 *iface, BSTR text, IHTMLDOMNode **newCDATASectionNode)
3314 {
3315 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3316 FIXME("(%p)->(%p)\n", This, newCDATASectionNode);
3317 return E_NOTIMPL;
3318 }
3319
3320 static HRESULT WINAPI HTMLDocument7_getSelection(IHTMLDocument7 *iface, IHTMLSelection **ppIHTMLSelection)
3321 {
3322 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3323 FIXME("(%p)->(%p)\n", This, ppIHTMLSelection);
3324 return E_NOTIMPL;
3325 }
3326
3327 static HRESULT WINAPI HTMLDocument7_getElementsByTagNameNS(IHTMLDocument7 *iface, VARIANT *pvarNS,
3328 BSTR bstrLocalName, IHTMLElementCollection **pelColl)
3329 {
3330 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3331 FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(bstrLocalName), pelColl);
3332 return E_NOTIMPL;
3333 }
3334
3335 static HRESULT WINAPI HTMLDocument7_createElementNS(IHTMLDocument7 *iface, VARIANT *pvarNS, BSTR bstrTag, IHTMLElement **newElem)
3336 {
3337 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3338 nsIDOMElement *dom_element;
3339 HTMLElement *element;
3340 nsAString ns, tag;
3341 nsresult nsres;
3342 HRESULT hres;
3343
3344 TRACE("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(bstrTag), newElem);
3345
3346 if(!This->doc_node->nsdoc) {
3347 FIXME("NULL nsdoc\n");
3348 return E_FAIL;
3349 }
3350
3351 if(pvarNS && V_VT(pvarNS) != VT_NULL && V_VT(pvarNS) != VT_BSTR)
3352 FIXME("Unsupported namespace %s\n", debugstr_variant(pvarNS));
3353
3354 nsAString_InitDepend(&ns, pvarNS && V_VT(pvarNS) == VT_BSTR ? V_BSTR(pvarNS) : NULL);
3355 nsAString_InitDepend(&tag, bstrTag);
3356 nsres = nsIDOMHTMLDocument_CreateElementNS(This->doc_node->nsdoc, &ns, &tag, &dom_element);
3357 nsAString_Finish(&ns);
3358 nsAString_Finish(&tag);
3359 if(NS_FAILED(nsres)) {
3360 WARN("CreateElementNS failed: %08x\n", nsres);
3361 return map_nsresult(nsres);
3362 }
3363
3364 hres = HTMLElement_Create(This->doc_node, (nsIDOMNode*)dom_element, FALSE, &element);
3365 nsIDOMElement_Release(dom_element);
3366 if(FAILED(hres))
3367 return hres;
3368
3369 *newElem = &element->IHTMLElement_iface;
3370 return S_OK;
3371 }
3372
3373 static HRESULT WINAPI HTMLDocument7_createAttributeNS(IHTMLDocument7 *iface, VARIANT *pvarNS,
3374 BSTR bstrAttrName, IHTMLDOMAttribute **ppAttribute)
3375 {
3376 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3377 FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(bstrAttrName), ppAttribute);
3378 return E_NOTIMPL;
3379 }
3380
3381 static HRESULT WINAPI HTMLDocument7_put_onmsthumbnailclick(IHTMLDocument7 *iface, VARIANT v)
3382 {
3383 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3384 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3385 return E_NOTIMPL;
3386 }
3387
3388 static HRESULT WINAPI HTMLDocument7_get_onmsthumbnailclick(IHTMLDocument7 *iface, VARIANT *p)
3389 {
3390 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3391
3392 TRACE("(%p)->(%p)\n", This, p);
3393
3394 return get_doc_event(This, EVENTID_MSTHUMBNAILCLICK, p);
3395 }
3396
3397 static HRESULT WINAPI HTMLDocument7_get_characterSet(IHTMLDocument7 *iface, BSTR *p)
3398 {
3399 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3400 nsAString charset_str;
3401 nsresult nsres;
3402
3403 TRACE("(%p)->(%p)\n", This, p);
3404
3405 if(!This->doc_node->nsdoc) {
3406 FIXME("NULL nsdoc\n");
3407 return E_FAIL;
3408 }
3409
3410 nsAString_Init(&charset_str, NULL);
3411 nsres = nsIDOMHTMLDocument_GetCharacterSet(This->doc_node->nsdoc, &charset_str);
3412 return return_nsstr(nsres, &charset_str, p);
3413 }
3414
3415 static HRESULT WINAPI HTMLDocument7_createElement(IHTMLDocument7 *iface, BSTR bstrTag, IHTMLElement **newElem)
3416 {
3417 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3418
3419 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrTag), newElem);
3420
3421 return IHTMLDocument2_createElement(&This->IHTMLDocument2_iface, bstrTag, newElem);
3422 }
3423
3424 static HRESULT WINAPI HTMLDocument7_createAttribute(IHTMLDocument7 *iface, BSTR bstrAttrName, IHTMLDOMAttribute **ppAttribute)
3425 {
3426 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3427
3428 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrAttrName), ppAttribute);
3429
3430 return IHTMLDocument5_createAttribute(&This->IHTMLDocument5_iface, bstrAttrName, ppAttribute);
3431 }
3432
3433 static HRESULT WINAPI HTMLDocument7_getElementsByClassName(IHTMLDocument7 *iface, BSTR v, IHTMLElementCollection **pel)
3434 {
3435 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3436 nsIDOMNodeList *nslist;
3437 nsAString nsstr;
3438 nsresult nsres;
3439
3440 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
3441
3442 if(!This->doc_node->nsdoc) {
3443 FIXME("NULL nsdoc not supported\n");
3444 return E_NOTIMPL;
3445 }
3446
3447 nsAString_InitDepend(&nsstr, v);
3448 nsres = nsIDOMHTMLDocument_GetElementsByClassName(This->doc_node->nsdoc, &nsstr, &nslist);
3449 nsAString_Finish(&nsstr);
3450 if(FAILED(nsres)) {
3451 ERR("GetElementByClassName failed: %08x\n", nsres);
3452 return E_FAIL;
3453 }
3454
3455
3456 *pel = create_collection_from_nodelist(nslist, This->doc_node->document_mode);
3457 nsIDOMNodeList_Release(nslist);
3458 return S_OK;
3459 }
3460
3461 static HRESULT WINAPI HTMLDocument7_createProcessingInstruction(IHTMLDocument7 *iface, BSTR target,
3462 BSTR data, IDOMProcessingInstruction **newProcessingInstruction)
3463 {
3464 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3465 FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(target), debugstr_w(data), newProcessingInstruction);
3466 return E_NOTIMPL;
3467 }
3468
3469 static HRESULT WINAPI HTMLDocument7_adoptNode(IHTMLDocument7 *iface, IHTMLDOMNode *pNodeSource, IHTMLDOMNode3 **ppNodeDest)
3470 {
3471 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3472 FIXME("(%p)->(%p %p)\n", This, pNodeSource, ppNodeDest);
3473 return E_NOTIMPL;
3474 }
3475
3476 static HRESULT WINAPI HTMLDocument7_put_onmssitemodejumplistitemremoved(IHTMLDocument7 *iface, VARIANT v)
3477 {
3478 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3479 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3480 return E_NOTIMPL;
3481 }
3482
3483 static HRESULT WINAPI HTMLDocument7_get_onmssitemodejumplistitemremoved(IHTMLDocument7 *iface, VARIANT *p)
3484 {
3485 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3486 FIXME("(%p)->(%p)\n", This, p);
3487 return E_NOTIMPL;
3488 }
3489
3490 static HRESULT WINAPI HTMLDocument7_get_all(IHTMLDocument7 *iface, IHTMLElementCollection **p)
3491 {
3492 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3493
3494 TRACE("(%p)->(%p)\n", This, p);
3495
3496 return IHTMLDocument2_get_all(&This->IHTMLDocument2_iface, p);
3497 }
3498
3499 static HRESULT WINAPI HTMLDocument7_get_inputEncoding(IHTMLDocument7 *iface, BSTR *p)
3500 {
3501 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3502 FIXME("(%p)->(%p)\n", This, p);
3503 return E_NOTIMPL;
3504 }
3505
3506 static HRESULT WINAPI HTMLDocument7_get_xmlEncoding(IHTMLDocument7 *iface, BSTR *p)
3507 {
3508 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3509 FIXME("(%p)->(%p)\n", This, p);
3510 return E_NOTIMPL;
3511 }
3512
3513 static HRESULT WINAPI HTMLDocument7_put_xmlStandalone(IHTMLDocument7 *iface, VARIANT_BOOL v)
3514 {
3515 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3516 FIXME("(%p)->(%x)\n", This, v);
3517 return E_NOTIMPL;
3518 }
3519
3520 static HRESULT WINAPI HTMLDocument7_get_xmlStandalone(IHTMLDocument7 *iface, VARIANT_BOOL *p)
3521 {
3522 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3523 FIXME("(%p)->(%p)\n", This, p);
3524 return E_NOTIMPL;
3525 }
3526
3527 static HRESULT WINAPI HTMLDocument7_put_xmlVersion(IHTMLDocument7 *iface, BSTR v)
3528 {
3529 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3530 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3531 return E_NOTIMPL;
3532 }
3533
3534 static HRESULT WINAPI HTMLDocument7_get_xmlVersion(IHTMLDocument7 *iface, BSTR *p)
3535 {
3536 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3537 FIXME("(%p)->(%p)\n", This, p);
3538 return E_NOTIMPL;
3539 }
3540
3541 static HRESULT WINAPI HTMLDocument7_hasAttributes(IHTMLDocument7 *iface, VARIANT_BOOL *pfHasAttributes)
3542 {
3543 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3544 FIXME("(%p)->(%p)\n", This, pfHasAttributes);
3545 return E_NOTIMPL;
3546 }
3547
3548 static HRESULT WINAPI HTMLDocument7_put_onabort(IHTMLDocument7 *iface, VARIANT v)
3549 {
3550 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3551
3552 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3553
3554 return set_doc_event(This, EVENTID_ABORT, &v);
3555 }
3556
3557 static HRESULT WINAPI HTMLDocument7_get_onabort(IHTMLDocument7 *iface, VARIANT *p)
3558 {
3559 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3560
3561 TRACE("(%p)->(%p)\n", This, p);
3562
3563 return get_doc_event(This, EVENTID_ABORT, p);
3564 }
3565
3566 static HRESULT WINAPI HTMLDocument7_put_onblur(IHTMLDocument7 *iface, VARIANT v)
3567 {
3568 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3569
3570 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3571
3572 return set_doc_event(This, EVENTID_BLUR, &v);
3573 }
3574
3575 static HRESULT WINAPI HTMLDocument7_get_onblur(IHTMLDocument7 *iface, VARIANT *p)
3576 {
3577 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3578
3579 TRACE("(%p)->(%p)\n", This, p);
3580
3581 return get_doc_event(This, EVENTID_BLUR, p);
3582 }
3583
3584 static HRESULT WINAPI HTMLDocument7_put_oncanplay(IHTMLDocument7 *iface, VARIANT v)
3585 {
3586 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3587 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3588 return E_NOTIMPL;
3589 }
3590
3591 static HRESULT WINAPI HTMLDocument7_get_oncanplay(IHTMLDocument7 *iface, VARIANT *p)
3592 {
3593 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3594 FIXME("(%p)->(%p)\n", This, p);
3595 return E_NOTIMPL;
3596 }
3597
3598 static HRESULT WINAPI HTMLDocument7_put_oncanplaythrough(IHTMLDocument7 *iface, VARIANT v)
3599 {
3600 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3601 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3602 return E_NOTIMPL;
3603 }
3604
3605 static HRESULT WINAPI HTMLDocument7_get_oncanplaythrough(IHTMLDocument7 *iface, VARIANT *p)
3606 {
3607 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3608 FIXME("(%p)->(%p)\n", This, p);
3609 return E_NOTIMPL;
3610 }
3611
3612 static HRESULT WINAPI HTMLDocument7_put_onchange(IHTMLDocument7 *iface, VARIANT v)
3613 {
3614 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3615
3616 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3617
3618 return set_doc_event(This, EVENTID_CHANGE, &v);
3619 }
3620
3621 static HRESULT WINAPI HTMLDocument7_get_onchange(IHTMLDocument7 *iface, VARIANT *p)
3622 {
3623 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3624
3625 TRACE("(%p)->(%p)\n", This, p);
3626
3627 return get_doc_event(This, EVENTID_CHANGE, p);
3628 }
3629
3630 static HRESULT WINAPI HTMLDocument7_put_ondrag(IHTMLDocument7 *iface, VARIANT v)
3631 {
3632 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3633
3634 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3635
3636 return set_doc_event(This, EVENTID_DRAG, &v);
3637 }
3638
3639 static HRESULT WINAPI HTMLDocument7_get_ondrag(IHTMLDocument7 *iface, VARIANT *p)
3640 {
3641 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3642
3643 TRACE("(%p)->(%p)\n", This, p);
3644
3645 return get_doc_event(This, EVENTID_DRAG, p);
3646 }
3647
3648 static HRESULT WINAPI HTMLDocument7_put_ondragend(IHTMLDocument7 *iface, VARIANT v)
3649 {
3650 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3651 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3652 return E_NOTIMPL;
3653 }
3654
3655 static HRESULT WINAPI HTMLDocument7_get_ondragend(IHTMLDocument7 *iface, VARIANT *p)
3656 {
3657 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3658 FIXME("(%p)->(%p)\n", This, p);
3659 return E_NOTIMPL;
3660 }
3661
3662 static HRESULT WINAPI HTMLDocument7_put_ondragenter(IHTMLDocument7 *iface, VARIANT v)
3663 {
3664 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3665 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3666 return E_NOTIMPL;
3667 }
3668
3669 static HRESULT WINAPI HTMLDocument7_get_ondragenter(IHTMLDocument7 *iface, VARIANT *p)
3670 {
3671 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3672 FIXME("(%p)->(%p)\n", This, p);
3673 return E_NOTIMPL;
3674 }
3675
3676 static HRESULT WINAPI HTMLDocument7_put_ondragleave(IHTMLDocument7 *iface, VARIANT v)
3677 {
3678 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3679 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3680 return E_NOTIMPL;
3681 }
3682
3683 static HRESULT WINAPI HTMLDocument7_get_ondragleave(IHTMLDocument7 *iface, VARIANT *p)
3684 {
3685 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3686 FIXME("(%p)->(%p)\n", This, p);
3687 return E_NOTIMPL;
3688 }
3689
3690 static HRESULT WINAPI HTMLDocument7_put_ondragover(IHTMLDocument7 *iface, VARIANT v)
3691 {
3692 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3693 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3694 return E_NOTIMPL;
3695 }
3696
3697 static HRESULT WINAPI HTMLDocument7_get_ondragover(IHTMLDocument7 *iface, VARIANT *p)
3698 {
3699 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3700 FIXME("(%p)->(%p)\n", This, p);
3701 return E_NOTIMPL;
3702 }
3703
3704 static HRESULT WINAPI HTMLDocument7_put_ondrop(IHTMLDocument7 *iface, VARIANT v)
3705 {
3706 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3707 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3708 return E_NOTIMPL;
3709 }
3710
3711 static HRESULT WINAPI HTMLDocument7_get_ondrop(IHTMLDocument7 *iface, VARIANT *p)
3712 {
3713 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3714 FIXME("(%p)->(%p)\n", This, p);
3715 return E_NOTIMPL;
3716 }
3717
3718 static HRESULT WINAPI HTMLDocument7_put_ondurationchange(IHTMLDocument7 *iface, VARIANT v)
3719 {
3720 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3721 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3722 return E_NOTIMPL;
3723 }
3724
3725 static HRESULT WINAPI HTMLDocument7_get_ondurationchange(IHTMLDocument7 *iface, VARIANT *p)
3726 {
3727 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3728 FIXME("(%p)->(%p)\n", This, p);
3729 return E_NOTIMPL;
3730 }
3731
3732 static HRESULT WINAPI HTMLDocument7_put_onemptied(IHTMLDocument7 *iface, VARIANT v)
3733 {
3734 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3735 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3736 return E_NOTIMPL;
3737 }
3738
3739 static HRESULT WINAPI HTMLDocument7_get_onemptied(IHTMLDocument7 *iface, VARIANT *p)
3740 {
3741 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3742 FIXME("(%p)->(%p)\n", This, p);
3743 return E_NOTIMPL;
3744 }
3745
3746 static HRESULT WINAPI HTMLDocument7_put_onended(IHTMLDocument7 *iface, VARIANT v)
3747 {
3748 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3749 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3750 return E_NOTIMPL;
3751 }
3752
3753 static HRESULT WINAPI HTMLDocument7_get_onended(IHTMLDocument7 *iface, VARIANT *p)
3754 {
3755 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3756 FIXME("(%p)->(%p)\n", This, p);
3757 return E_NOTIMPL;
3758 }
3759
3760 static HRESULT WINAPI HTMLDocument7_put_onerror(IHTMLDocument7 *iface, VARIANT v)
3761 {
3762 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3763
3764 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3765
3766 return set_doc_event(This, EVENTID_ERROR, &v);
3767 }
3768
3769 static HRESULT WINAPI HTMLDocument7_get_onerror(IHTMLDocument7 *iface, VARIANT *p)
3770 {
3771 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3772
3773 TRACE("(%p)->(%p)\n", This, p);
3774
3775 return get_doc_event(This, EVENTID_ERROR, p);
3776 }
3777
3778 static HRESULT WINAPI HTMLDocument7_put_onfocus(IHTMLDocument7 *iface, VARIANT v)
3779 {
3780 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3781
3782 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3783
3784 return set_doc_event(This, EVENTID_FOCUS, &v);
3785 }
3786
3787 static HRESULT WINAPI HTMLDocument7_get_onfocus(IHTMLDocument7 *iface, VARIANT *p)
3788 {
3789 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3790
3791 TRACE("(%p)->(%p)\n", This, p);
3792
3793 return get_doc_event(This, EVENTID_FOCUS, p);
3794 }
3795
3796 static HRESULT WINAPI HTMLDocument7_put_oninput(IHTMLDocument7 *iface, VARIANT v)
3797 {
3798 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3799
3800 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3801
3802 return set_doc_event(This, EVENTID_INPUT, &v);
3803 }
3804
3805 static HRESULT WINAPI HTMLDocument7_get_oninput(IHTMLDocument7 *iface, VARIANT *p)
3806 {
3807 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3808
3809 TRACE("(%p)->(%p)\n", This, p);
3810
3811 return get_doc_event(This, EVENTID_INPUT, p);
3812 }
3813
3814 static HRESULT WINAPI HTMLDocument7_put_onload(IHTMLDocument7 *iface, VARIANT v)
3815 {
3816 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3817
3818 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3819
3820 return set_doc_event(This, EVENTID_LOAD, &v);
3821 }
3822
3823 static HRESULT WINAPI HTMLDocument7_get_onload(IHTMLDocument7 *iface, VARIANT *p)
3824 {
3825 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3826
3827 TRACE("(%p)->(%p)\n", This, p);
3828
3829 return get_doc_event(This, EVENTID_LOAD, p);
3830 }
3831
3832 static HRESULT WINAPI HTMLDocument7_put_onloadeddata(IHTMLDocument7 *iface, VARIANT v)
3833 {
3834 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3835 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3836 return E_NOTIMPL;
3837 }
3838
3839 static HRESULT WINAPI HTMLDocument7_get_onloadeddata(IHTMLDocument7 *iface, VARIANT *p)
3840 {
3841 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3842 FIXME("(%p)->(%p)\n", This, p);
3843 return E_NOTIMPL;
3844 }
3845
3846 static HRESULT WINAPI HTMLDocument7_put_onloadedmetadata(IHTMLDocument7 *iface, VARIANT v)
3847 {
3848 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3849 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3850 return E_NOTIMPL;
3851 }
3852
3853 static HRESULT WINAPI HTMLDocument7_get_onloadedmetadata(IHTMLDocument7 *iface, VARIANT *p)
3854 {
3855 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3856 FIXME("(%p)->(%p)\n", This, p);
3857 return E_NOTIMPL;
3858 }
3859
3860 static HRESULT WINAPI HTMLDocument7_put_onloadstart(IHTMLDocument7 *iface, VARIANT v)
3861 {
3862 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3863 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3864 return E_NOTIMPL;
3865 }
3866
3867 static HRESULT WINAPI HTMLDocument7_get_onloadstart(IHTMLDocument7 *iface, VARIANT *p)
3868 {
3869 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3870 FIXME("(%p)->(%p)\n", This, p);
3871 return E_NOTIMPL;
3872 }
3873
3874 static HRESULT WINAPI HTMLDocument7_put_onpause(IHTMLDocument7 *iface, VARIANT v)
3875 {
3876 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3877 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3878 return E_NOTIMPL;
3879 }
3880
3881 static HRESULT WINAPI HTMLDocument7_get_onpause(IHTMLDocument7 *iface, VARIANT *p)
3882 {
3883 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3884 FIXME("(%p)->(%p)\n", This, p);
3885 return E_NOTIMPL;
3886 }
3887
3888 static HRESULT WINAPI HTMLDocument7_put_onplay(IHTMLDocument7 *iface, VARIANT v)
3889 {
3890 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3891 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3892 return E_NOTIMPL;
3893 }
3894
3895 static HRESULT WINAPI HTMLDocument7_get_onplay(IHTMLDocument7 *iface, VARIANT *p)
3896 {
3897 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3898 FIXME("(%p)->(%p)\n", This, p);
3899 return E_NOTIMPL;
3900 }
3901
3902 static HRESULT WINAPI HTMLDocument7_put_onplaying(IHTMLDocument7 *iface, VARIANT v)
3903 {
3904 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3905 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3906 return E_NOTIMPL;
3907 }
3908
3909 static HRESULT WINAPI HTMLDocument7_get_onplaying(IHTMLDocument7 *iface, VARIANT *p)
3910 {
3911 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3912 FIXME("(%p)->(%p)\n", This, p);
3913 return E_NOTIMPL;
3914 }
3915
3916 static HRESULT WINAPI HTMLDocument7_put_onprogress(IHTMLDocument7 *iface, VARIANT v)
3917 {
3918 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3919 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3920 return E_NOTIMPL;
3921 }
3922
3923 static HRESULT WINAPI HTMLDocument7_get_onprogress(IHTMLDocument7 *iface, VARIANT *p)
3924 {
3925 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3926 FIXME("(%p)->(%p)\n", This, p);
3927 return E_NOTIMPL;
3928 }
3929
3930 static HRESULT WINAPI HTMLDocument7_put_onratechange(IHTMLDocument7 *iface, VARIANT v)
3931 {
3932 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3933 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3934 return E_NOTIMPL;
3935 }
3936
3937 static HRESULT WINAPI HTMLDocument7_get_onratechange(IHTMLDocument7 *iface, VARIANT *p)
3938 {
3939 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3940 FIXME("(%p)->(%p)\n", This, p);
3941 return E_NOTIMPL;
3942 }
3943
3944 static HRESULT WINAPI HTMLDocument7_put_onreset(IHTMLDocument7 *iface, VARIANT v)
3945 {
3946 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3947 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3948 return E_NOTIMPL;
3949 }
3950
3951 static HRESULT WINAPI HTMLDocument7_get_onreset(IHTMLDocument7 *iface, VARIANT *p)
3952 {
3953 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3954 FIXME("(%p)->(%p)\n", This, p);
3955 return E_NOTIMPL;
3956 }
3957
3958 static HRESULT WINAPI HTMLDocument7_put_onscroll(IHTMLDocument7 *iface, VARIANT v)
3959 {
3960 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3961
3962 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3963
3964 return set_doc_event(This, EVENTID_SCROLL, &v);
3965 }
3966
3967 static HRESULT WINAPI HTMLDocument7_get_onscroll(IHTMLDocument7 *iface, VARIANT *p)
3968 {
3969 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3970
3971 TRACE("(%p)->(%p)\n", This, p);
3972
3973 return get_doc_event(This, EVENTID_SCROLL, p);
3974 }
3975
3976 static HRESULT WINAPI HTMLDocument7_put_onseekend(IHTMLDocument7 *iface, VARIANT v)
3977 {
3978 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3979 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3980 return E_NOTIMPL;
3981 }
3982
3983 static HRESULT WINAPI HTMLDocument7_get_onseekend(IHTMLDocument7 *iface, VARIANT *p)
3984 {
3985 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3986 FIXME("(%p)->(%p)\n", This, p);
3987 return E_NOTIMPL;
3988 }
3989
3990 static HRESULT WINAPI HTMLDocument7_put_onseeking(IHTMLDocument7 *iface, VARIANT v)
3991 {
3992 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
3993 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3994 return E_NOTIMPL;
3995 }
3996
3997 static HRESULT WINAPI HTMLDocument7_get_onseeking(IHTMLDocument7 *iface, VARIANT *p)
3998 {
3999 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4000 FIXME("(%p)->(%p)\n", This, p);
4001 return E_NOTIMPL;
4002 }
4003
4004 static HRESULT WINAPI HTMLDocument7_put_onselect(IHTMLDocument7 *iface, VARIANT v)
4005 {
4006 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4007 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4008 return E_NOTIMPL;
4009 }
4010
4011 static HRESULT WINAPI HTMLDocument7_get_onselect(IHTMLDocument7 *iface, VARIANT *p)
4012 {
4013 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4014 FIXME("(%p)->(%p)\n", This, p);
4015 return E_NOTIMPL;
4016 }
4017
4018 static HRESULT WINAPI HTMLDocument7_put_onstalled(IHTMLDocument7 *iface, VARIANT v)
4019 {
4020 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4021 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4022 return E_NOTIMPL;
4023 }
4024
4025 static HRESULT WINAPI HTMLDocument7_get_onstalled(IHTMLDocument7 *iface, VARIANT *p)
4026 {
4027 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4028 FIXME("(%p)->(%p)\n", This, p);
4029 return E_NOTIMPL;
4030 }
4031
4032 static HRESULT WINAPI HTMLDocument7_put_onsubmit(IHTMLDocument7 *iface, VARIANT v)
4033 {
4034 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4035
4036 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4037
4038 return set_doc_event(This, EVENTID_SUBMIT, &v);
4039 }
4040
4041 static HRESULT WINAPI HTMLDocument7_get_onsubmit(IHTMLDocument7 *iface, VARIANT *p)
4042 {
4043 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4044
4045 TRACE("(%p)->(%p)\n", This, p);
4046
4047 return get_doc_event(This, EVENTID_SUBMIT, p);
4048 }
4049
4050 static HRESULT WINAPI HTMLDocument7_put_onsuspend(IHTMLDocument7 *iface, VARIANT v)
4051 {
4052 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4053 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4054 return E_NOTIMPL;
4055 }
4056
4057 static HRESULT WINAPI HTMLDocument7_get_onsuspend(IHTMLDocument7 *iface, VARIANT *p)
4058 {
4059 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4060 FIXME("(%p)->(%p)\n", This, p);
4061 return E_NOTIMPL;
4062 }
4063
4064 static HRESULT WINAPI HTMLDocument7_put_ontimeupdate(IHTMLDocument7 *iface, VARIANT v)
4065 {
4066 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4067 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4068 return E_NOTIMPL;
4069 }
4070
4071 static HRESULT WINAPI HTMLDocument7_get_ontimeupdate(IHTMLDocument7 *iface, VARIANT *p)
4072 {
4073 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4074 FIXME("(%p)->(%p)\n", This, p);
4075 return E_NOTIMPL;
4076 }
4077
4078 static HRESULT WINAPI HTMLDocument7_put_onvolumechange(IHTMLDocument7 *iface, VARIANT v)
4079 {
4080 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4081 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4082 return E_NOTIMPL;
4083 }
4084
4085 static HRESULT WINAPI HTMLDocument7_get_onvolumechange(IHTMLDocument7 *iface, VARIANT *p)
4086 {
4087 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4088 FIXME("(%p)->(%p)\n", This, p);
4089 return E_NOTIMPL;
4090 }
4091
4092 static HRESULT WINAPI HTMLDocument7_put_onwaiting(IHTMLDocument7 *iface, VARIANT v)
4093 {
4094 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4095 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4096 return E_NOTIMPL;
4097 }
4098
4099 static HRESULT WINAPI HTMLDocument7_get_onwaiting(IHTMLDocument7 *iface, VARIANT *p)
4100 {
4101 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4102 FIXME("(%p)->(%p)\n", This, p);
4103 return E_NOTIMPL;
4104 }
4105
4106 static HRESULT WINAPI HTMLDocument7_normalize(IHTMLDocument7 *iface)
4107 {
4108 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4109 FIXME("(%p)\n", This);
4110 return E_NOTIMPL;
4111 }
4112
4113 static HRESULT WINAPI HTMLDocument7_importNode(IHTMLDocument7 *iface, IHTMLDOMNode *pNodeSource,
4114 VARIANT_BOOL fDeep, IHTMLDOMNode3 **ppNodeDest)
4115 {
4116 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4117 FIXME("(%p)->(%p %x %p)\n", This, pNodeSource, fDeep, ppNodeDest);
4118 return E_NOTIMPL;
4119 }
4120
4121 static HRESULT WINAPI HTMLDocument7_get_parentWindow(IHTMLDocument7 *iface, IHTMLWindow2 **p)
4122 {
4123 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4124
4125 TRACE("(%p)->(%p)\n", This, p);
4126
4127 return IHTMLDocument7_get_defaultView(&This->IHTMLDocument7_iface, p);
4128 }
4129
4130 static HRESULT WINAPI HTMLDocument7_put_body(IHTMLDocument7 *iface, IHTMLElement *v)
4131 {
4132 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4133 FIXME("(%p)->(%p)\n", This, v);
4134 return E_NOTIMPL;
4135 }
4136
4137 static HRESULT WINAPI HTMLDocument7_get_body(IHTMLDocument7 *iface, IHTMLElement **p)
4138 {
4139 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4140
4141 TRACE("(%p)->(%p)\n", This, p);
4142
4143 return IHTMLDocument2_get_body(&This->IHTMLDocument2_iface, p);
4144 }
4145
4146 static HRESULT WINAPI HTMLDocument7_get_head(IHTMLDocument7 *iface, IHTMLElement **p)
4147 {
4148 HTMLDocument *This = impl_from_IHTMLDocument7(iface);
4149 nsIDOMHTMLHeadElement *nshead;
4150 nsIDOMElement *nselem;
4151 HTMLElement *elem;
4152 nsresult nsres;
4153 HRESULT hres;
4154
4155 TRACE("(%p)->(%p)\n", This, p);
4156
4157 if(!This->doc_node->nsdoc) {
4158 FIXME("No document\n");
4159 return E_FAIL;
4160 }
4161
4162 nsres = nsIDOMHTMLDocument_GetHead(This->doc_node->nsdoc, &nshead);
4163 assert(nsres == NS_OK);
4164
4165 if(!nshead) {
4166 *p = NULL;
4167 return S_OK;
4168 }
4169
4170 nsres = nsIDOMHTMLHeadElement_QueryInterface(nshead, &IID_nsIDOMElement, (void**)&nselem);
4171 nsIDOMHTMLHeadElement_Release(nshead);
4172 assert(nsres == NS_OK);
4173
4174 hres = get_element(nselem, &elem);
4175 nsIDOMElement_Release(nselem);
4176 if(FAILED(hres))
4177 return hres;
4178
4179 *p = &elem->IHTMLElement_iface;
4180 return S_OK;
4181 }
4182
4183 static const IHTMLDocument7Vtbl HTMLDocument7Vtbl = {
4184 HTMLDocument7_QueryInterface,
4185 HTMLDocument7_AddRef,
4186 HTMLDocument7_Release,
4187 HTMLDocument7_GetTypeInfoCount,
4188 HTMLDocument7_GetTypeInfo,
4189 HTMLDocument7_GetIDsOfNames,
4190 HTMLDocument7_Invoke,
4191 HTMLDocument7_get_defaultView,
4192 HTMLDocument7_createCDATASection,
4193 HTMLDocument7_getSelection,
4194 HTMLDocument7_getElementsByTagNameNS,
4195 HTMLDocument7_createElementNS,
4196 HTMLDocument7_createAttributeNS,
4197 HTMLDocument7_put_onmsthumbnailclick,
4198 HTMLDocument7_get_onmsthumbnailclick,
4199 HTMLDocument7_get_characterSet,
4200 HTMLDocument7_createElement,
4201 HTMLDocument7_createAttribute,
4202 HTMLDocument7_getElementsByClassName,
4203 HTMLDocument7_createProcessingInstruction,
4204 HTMLDocument7_adoptNode,
4205 HTMLDocument7_put_onmssitemodejumplistitemremoved,
4206 HTMLDocument7_get_onmssitemodejumplistitemremoved,
4207 HTMLDocument7_get_all,
4208 HTMLDocument7_get_inputEncoding,
4209 HTMLDocument7_get_xmlEncoding,
4210 HTMLDocument7_put_xmlStandalone,
4211 HTMLDocument7_get_xmlStandalone,
4212 HTMLDocument7_put_xmlVersion,
4213 HTMLDocument7_get_xmlVersion,
4214 HTMLDocument7_hasAttributes,
4215 HTMLDocument7_put_onabort,
4216 HTMLDocument7_get_onabort,
4217 HTMLDocument7_put_onblur,
4218 HTMLDocument7_get_onblur,
4219 HTMLDocument7_put_oncanplay,
4220 HTMLDocument7_get_oncanplay,
4221 HTMLDocument7_put_oncanplaythrough,
4222 HTMLDocument7_get_oncanplaythrough,
4223 HTMLDocument7_put_onchange,
4224 HTMLDocument7_get_onchange,
4225 HTMLDocument7_put_ondrag,
4226 HTMLDocument7_get_ondrag,
4227 HTMLDocument7_put_ondragend,
4228 HTMLDocument7_get_ondragend,
4229 HTMLDocument7_put_ondragenter,
4230 HTMLDocument7_get_ondragenter,
4231 HTMLDocument7_put_ondragleave,
4232 HTMLDocument7_get_ondragleave,
4233 HTMLDocument7_put_ondragover,
4234 HTMLDocument7_get_ondragover,
4235 HTMLDocument7_put_ondrop,
4236 HTMLDocument7_get_ondrop,
4237 HTMLDocument7_put_ondurationchange,
4238 HTMLDocument7_get_ondurationchange,
4239 HTMLDocument7_put_onemptied,
4240 HTMLDocument7_get_onemptied,
4241 HTMLDocument7_put_onended,
4242 HTMLDocument7_get_onended,
4243 HTMLDocument7_put_onerror,
4244 HTMLDocument7_get_onerror,
4245 HTMLDocument7_put_onfocus,
4246 HTMLDocument7_get_onfocus,
4247 HTMLDocument7_put_oninput,
4248 HTMLDocument7_get_oninput,
4249 HTMLDocument7_put_onload,
4250 HTMLDocument7_get_onload,
4251 HTMLDocument7_put_onloadeddata,
4252 HTMLDocument7_get_onloadeddata,
4253 HTMLDocument7_put_onloadedmetadata,
4254 HTMLDocument7_get_onloadedmetadata,
4255 HTMLDocument7_put_onloadstart,
4256 HTMLDocument7_get_onloadstart,
4257 HTMLDocument7_put_onpause,
4258 HTMLDocument7_get_onpause,
4259 HTMLDocument7_put_onplay,
4260 HTMLDocument7_get_onplay,
4261 HTMLDocument7_put_onplaying,
4262 HTMLDocument7_get_onplaying,
4263 HTMLDocument7_put_onprogress,
4264 HTMLDocument7_get_onprogress,
4265 HTMLDocument7_put_onratechange,
4266 HTMLDocument7_get_onratechange,
4267 HTMLDocument7_put_onreset,
4268 HTMLDocument7_get_onreset,
4269 HTMLDocument7_put_onscroll,
4270 HTMLDocument7_get_onscroll,
4271 HTMLDocument7_put_onseekend,
4272 HTMLDocument7_get_onseekend,
4273 HTMLDocument7_put_onseeking,
4274 HTMLDocument7_get_onseeking,
4275 HTMLDocument7_put_onselect,
4276 HTMLDocument7_get_onselect,
4277 HTMLDocument7_put_onstalled,
4278 HTMLDocument7_get_onstalled,
4279 HTMLDocument7_put_onsubmit,
4280 HTMLDocument7_get_onsubmit,
4281 HTMLDocument7_put_onsuspend,
4282 HTMLDocument7_get_onsuspend,
4283 HTMLDocument7_put_ontimeupdate,
4284 HTMLDocument7_get_ontimeupdate,
4285 HTMLDocument7_put_onvolumechange,
4286 HTMLDocument7_get_onvolumechange,
4287 HTMLDocument7_put_onwaiting,
4288 HTMLDocument7_get_onwaiting,
4289 HTMLDocument7_normalize,
4290 HTMLDocument7_importNode,
4291 HTMLDocument7_get_parentWindow,
4292 HTMLDocument7_put_body,
4293 HTMLDocument7_get_body,
4294 HTMLDocument7_get_head
4295 };
4296
4297 static inline HTMLDocument *impl_from_IDocumentSelector(IDocumentSelector *iface)
4298 {
4299 return CONTAINING_RECORD(iface, HTMLDocument, IDocumentSelector_iface);
4300 }
4301
4302 static HRESULT WINAPI DocumentSelector_QueryInterface(IDocumentSelector *iface, REFIID riid, void **ppv)
4303 {
4304 HTMLDocument *This = impl_from_IDocumentSelector(iface);
4305 return htmldoc_query_interface(This, riid, ppv);
4306 }
4307
4308 static ULONG WINAPI DocumentSelector_AddRef(IDocumentSelector *iface)
4309 {
4310 HTMLDocument *This = impl_from_IDocumentSelector(iface);
4311 return htmldoc_addref(This);
4312 }
4313
4314 static ULONG WINAPI DocumentSelector_Release(IDocumentSelector *iface)
4315 {
4316 HTMLDocument *This = impl_from_IDocumentSelector(iface);
4317 return htmldoc_release(This);
4318 }
4319
4320 static HRESULT WINAPI DocumentSelector_GetTypeInfoCount(IDocumentSelector *iface, UINT *pctinfo)
4321 {
4322 HTMLDocument *This = impl_from_IDocumentSelector(iface);
4323 return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
4324 }
4325
4326 static HRESULT WINAPI DocumentSelector_GetTypeInfo(IDocumentSelector *iface, UINT iTInfo,
4327 LCID lcid, ITypeInfo **ppTInfo)
4328 {
4329 HTMLDocument *This = impl_from_IDocumentSelector(iface);
4330 return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4331 }
4332
4333 static HRESULT WINAPI DocumentSelector_GetIDsOfNames(IDocumentSelector *iface, REFIID riid,
4334 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4335 {
4336 HTMLDocument *This = impl_from_IDocumentSelector(iface);
4337 return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
4338 rgDispId);
4339 }
4340
4341 static HRESULT WINAPI DocumentSelector_Invoke(IDocumentSelector *iface, DISPID dispIdMember, REFIID riid,
4342 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4343 {
4344 HTMLDocument *This = impl_from_IDocumentSelector(iface);
4345 return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
4346 pDispParams, pVarResult, pExcepInfo, puArgErr);
4347 }
4348
4349 static HRESULT WINAPI DocumentSelector_querySelector(IDocumentSelector *iface, BSTR v, IHTMLElement **pel)
4350 {
4351 HTMLDocument *This = impl_from_IDocumentSelector(iface);
4352 nsIDOMElement *nselem;
4353 HTMLElement *elem;
4354 nsAString nsstr;
4355 nsresult nsres;
4356 HRESULT hres;
4357
4358 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
4359
4360 nsAString_InitDepend(&nsstr, v);
4361 nsres = nsIDOMHTMLDocument_QuerySelector(This->doc_node->nsdoc, &nsstr, &nselem);
4362 nsAString_Finish(&nsstr);
4363 if(NS_FAILED(nsres)) {
4364 ERR("QuerySelector failed: %08x\n", nsres);
4365 return E_FAIL;
4366 }
4367
4368 if(!nselem) {
4369 *pel = NULL;
4370 return S_OK;
4371 }
4372
4373 hres = get_element(nselem, &elem);
4374 nsIDOMElement_Release(nselem);
4375 if(FAILED(hres))
4376 return hres;
4377
4378 *pel = &elem->IHTMLElement_iface;
4379 return S_OK;
4380 }
4381
4382 static HRESULT WINAPI DocumentSelector_querySelectorAll(IDocumentSelector *iface, BSTR v, IHTMLDOMChildrenCollection **pel)
4383 {
4384 HTMLDocument *This = impl_from_IDocumentSelector(iface);
4385 nsIDOMNodeList *node_list;
4386 nsAString nsstr;
4387 nsresult nsres;
4388
4389 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
4390
4391 nsAString_InitDepend(&nsstr, v);
4392 nsres = nsIDOMHTMLDocument_QuerySelectorAll(This->doc_node->nsdoc, &nsstr, &node_list);
4393 nsAString_Finish(&nsstr);
4394 if(NS_FAILED(nsres)) {
4395 ERR("QuerySelectorAll failed: %08x\n", nsres);
4396 return E_FAIL;
4397 }
4398
4399 *pel = create_child_collection(node_list);
4400 nsIDOMNodeList_Release(node_list);
4401 return *pel ? S_OK : E_OUTOFMEMORY;
4402 }
4403
4404 static const IDocumentSelectorVtbl DocumentSelectorVtbl = {
4405 DocumentSelector_QueryInterface,
4406 DocumentSelector_AddRef,
4407 DocumentSelector_Release,
4408 DocumentSelector_GetTypeInfoCount,
4409 DocumentSelector_GetTypeInfo,
4410 DocumentSelector_GetIDsOfNames,
4411 DocumentSelector_Invoke,
4412 DocumentSelector_querySelector,
4413 DocumentSelector_querySelectorAll
4414 };
4415
4416 static inline HTMLDocument *impl_from_IDocumentEvent(IDocumentEvent *iface)
4417 {
4418 return CONTAINING_RECORD(iface, HTMLDocument, IDocumentEvent_iface);
4419 }
4420
4421 static HRESULT WINAPI DocumentEvent_QueryInterface(IDocumentEvent *iface, REFIID riid, void **ppv)
4422 {
4423 HTMLDocument *This = impl_from_IDocumentEvent(iface);
4424 return htmldoc_query_interface(This, riid, ppv);
4425 }
4426
4427 static ULONG WINAPI DocumentEvent_AddRef(IDocumentEvent *iface)
4428 {
4429 HTMLDocument *This = impl_from_IDocumentEvent(iface);
4430 return htmldoc_addref(This);
4431 }
4432
4433 static ULONG WINAPI DocumentEvent_Release(IDocumentEvent *iface)
4434 {
4435 HTMLDocument *This = impl_from_IDocumentEvent(iface);
4436 return htmldoc_release(This);
4437 }
4438
4439 static HRESULT WINAPI DocumentEvent_GetTypeInfoCount(IDocumentEvent *iface, UINT *pctinfo)
4440 {
4441 HTMLDocument *This = impl_from_IDocumentEvent(iface);
4442 return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
4443 }
4444
4445 static HRESULT WINAPI DocumentEvent_GetTypeInfo(IDocumentEvent *iface, UINT iTInfo,
4446 LCID lcid, ITypeInfo **ppTInfo)
4447 {
4448 HTMLDocument *This = impl_from_IDocumentEvent(iface);
4449 return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4450 }
4451
4452 static HRESULT WINAPI DocumentEvent_GetIDsOfNames(IDocumentEvent *iface, REFIID riid,
4453 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4454 {
4455 HTMLDocument *This = impl_from_IDocumentEvent(iface);
4456 return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
4457 rgDispId);
4458 }
4459
4460 static HRESULT WINAPI DocumentEvent_Invoke(IDocumentEvent *iface, DISPID dispIdMember, REFIID riid,
4461 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4462 {
4463 HTMLDocument *This = impl_from_IDocumentEvent(iface);
4464 return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
4465 pDispParams, pVarResult, pExcepInfo, puArgErr);
4466 }
4467
4468 static HRESULT WINAPI DocumentEvent_createEvent(IDocumentEvent *iface, BSTR eventType, IDOMEvent **p)
4469 {
4470 HTMLDocument *This = impl_from_IDocumentEvent(iface);
4471
4472 TRACE("(%p)->(%s %p)\n", This, debugstr_w(eventType), p);
4473
4474 return create_document_event_str(This->doc_node, eventType, p);
4475 }
4476
4477 static const IDocumentEventVtbl DocumentEventVtbl = {
4478 DocumentEvent_QueryInterface,
4479 DocumentEvent_AddRef,
4480 DocumentEvent_Release,
4481 DocumentEvent_GetTypeInfoCount,
4482 DocumentEvent_GetTypeInfo,
4483 DocumentEvent_GetIDsOfNames,
4484 DocumentEvent_Invoke,
4485 DocumentEvent_createEvent
4486 };
4487
4488 static void HTMLDocument_on_advise(IUnknown *iface, cp_static_data_t *cp)
4489 {
4490 HTMLDocument *This = impl_from_IHTMLDocument2((IHTMLDocument2*)iface);
4491
4492 if(This->window)
4493 update_doc_cp_events(This->doc_node, cp);
4494 }
4495
4496 static inline HTMLDocument *impl_from_ISupportErrorInfo(ISupportErrorInfo *iface)
4497 {
4498 return CONTAINING_RECORD(iface, HTMLDocument, ISupportErrorInfo_iface);
4499 }
4500
4501 static HRESULT WINAPI SupportErrorInfo_QueryInterface(ISupportErrorInfo *iface, REFIID riid, void **ppv)
4502 {
4503 HTMLDocument *This = impl_from_ISupportErrorInfo(iface);
4504 return htmldoc_query_interface(This, riid, ppv);
4505 }
4506
4507 static ULONG WINAPI SupportErrorInfo_AddRef(ISupportErrorInfo *iface)
4508 {
4509 HTMLDocument *This = impl_from_ISupportErrorInfo(iface);
4510 return htmldoc_addref(This);
4511 }
4512
4513 static ULONG WINAPI SupportErrorInfo_Release(ISupportErrorInfo *iface)
4514 {
4515 HTMLDocument *This = impl_from_ISupportErrorInfo(iface);
4516 return htmldoc_release(This);
4517 }
4518
4519 static HRESULT WINAPI SupportErrorInfo_InterfaceSupportsErrorInfo(ISupportErrorInfo *iface, REFIID riid)
4520 {
4521 FIXME("(%p)->(%s)\n", iface, debugstr_mshtml_guid(riid));
4522 return S_FALSE;
4523 }
4524
4525 static const ISupportErrorInfoVtbl SupportErrorInfoVtbl = {
4526 SupportErrorInfo_QueryInterface,
4527 SupportErrorInfo_AddRef,
4528 SupportErrorInfo_Release,
4529 SupportErrorInfo_InterfaceSupportsErrorInfo
4530 };
4531
4532 static inline HTMLDocument *impl_from_IDispatchEx(IDispatchEx *iface)
4533 {
4534 return CONTAINING_RECORD(iface, HTMLDocument, IDispatchEx_iface);
4535 }
4536
4537 static HRESULT dispid_from_elem_name(HTMLDocumentNode *This, BSTR name, DISPID *dispid)
4538 {
4539 nsIDOMNodeList *node_list;
4540 nsAString name_str;
4541 UINT32 len;
4542 unsigned i;
4543 nsresult nsres;
4544
4545 if(!This->nsdoc)
4546 return DISP_E_UNKNOWNNAME;
4547
4548 nsAString_InitDepend(&name_str, name);
4549 nsres = nsIDOMHTMLDocument_GetElementsByName(This->nsdoc, &name_str, &node_list);
4550 nsAString_Finish(&name_str);
4551 if(NS_FAILED(nsres))
4552 return E_FAIL;
4553
4554 nsres = nsIDOMNodeList_GetLength(node_list, &len);
4555 nsIDOMNodeList_Release(node_list);
4556 if(NS_FAILED(nsres))
4557 return E_FAIL;
4558
4559 if(!len)
4560 return DISP_E_UNKNOWNNAME;
4561
4562 for(i=0; i < This->elem_vars_cnt; i++) {
4563 if(!wcscmp(name, This->elem_vars[i])) {
4564 *dispid = MSHTML_DISPID_CUSTOM_MIN+i;
4565 return S_OK;
4566 }
4567 }
4568
4569 if(This->elem_vars_cnt == This->elem_vars_size) {
4570 WCHAR **new_vars;
4571
4572 if(This->elem_vars_size) {
4573 new_vars = heap_realloc(This->elem_vars, This->elem_vars_size*2*sizeof(WCHAR*));
4574 if(!new_vars)
4575 return E_OUTOFMEMORY;
4576 This->elem_vars_size *= 2;
4577 }else {
4578 new_vars = heap_alloc(16*sizeof(WCHAR*));
4579 if(!new_vars)
4580 return E_OUTOFMEMORY;
4581 This->elem_vars_size = 16;
4582 }
4583
4584 This->elem_vars = new_vars;
4585 }
4586
4587 This->elem_vars[This->elem_vars_cnt] = heap_strdupW(name);
4588 if(!This->elem_vars[This->elem_vars_cnt])
4589 return E_OUTOFMEMORY;
4590
4591 *dispid = MSHTML_DISPID_CUSTOM_MIN+This->elem_vars_cnt++;
4592 return S_OK;
4593 }
4594
4595 static HRESULT WINAPI DocDispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
4596 {
4597 HTMLDocument *This = impl_from_IDispatchEx(iface);
4598
4599 return htmldoc_query_interface(This, riid, ppv);
4600 }
4601
4602 static ULONG WINAPI DocDispatchEx_AddRef(IDispatchEx *iface)
4603 {
4604 HTMLDocument *This = impl_from_IDispatchEx(iface);
4605
4606 return htmldoc_addref(This);
4607 }
4608
4609 static ULONG WINAPI DocDispatchEx_Release(IDispatchEx *iface)
4610 {
4611 HTMLDocument *This = impl_from_IDispatchEx(iface);
4612
4613 return htmldoc_release(This);
4614 }
4615
4616 static HRESULT WINAPI DocDispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
4617 {
4618 HTMLDocument *This = impl_from_IDispatchEx(iface);
4619
4620 return IDispatchEx_GetTypeInfoCount(This->dispex, pctinfo);
4621 }
4622
4623 static HRESULT WINAPI DocDispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
4624 LCID lcid, ITypeInfo **ppTInfo)
4625 {
4626 HTMLDocument *This = impl_from_IDispatchEx(iface);
4627
4628 return IDispatchEx_GetTypeInfo(This->dispex, iTInfo, lcid, ppTInfo);
4629 }
4630
4631 static HRESULT WINAPI DocDispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
4632 LPOLESTR *rgszNames, UINT cNames,
4633 LCID lcid, DISPID *rgDispId)
4634 {
4635 HTMLDocument *This = impl_from_IDispatchEx(iface);
4636
4637 return IDispatchEx_GetIDsOfNames(This->dispex, riid, rgszNames, cNames, lcid, rgDispId);
4638 }
4639
4640 static HRESULT WINAPI DocDispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
4641 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
4642 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4643 {
4644 HTMLDocument *This = impl_from_IDispatchEx(iface);
4645
4646 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
4647 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4648
4649 switch(dispIdMember) {
4650 case DISPID_READYSTATE:
4651 TRACE("DISPID_READYSTATE\n");
4652
4653 if(!(wFlags & DISPATCH_PROPERTYGET))
4654 return E_INVALIDARG;
4655
4656 V_VT(pVarResult) = VT_I4;
4657 V_I4(pVarResult) = This->window->readystate;
4658 return S_OK;
4659 }
4660
4661 return IDispatchEx_Invoke(This->dispex, dispIdMember, riid, lcid, wFlags, pDispParams,
4662 pVarResult, pExcepInfo, puArgErr);
4663 }
4664
4665 static HRESULT WINAPI DocDispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
4666 {
4667 HTMLDocument *This = impl_from_IDispatchEx(iface);
4668 HRESULT hres;
4669
4670 hres = IDispatchEx_GetDispID(This->dispex, bstrName, grfdex, pid);
4671 if(hres != DISP_E_UNKNOWNNAME)
4672 return hres;
4673
4674 return dispid_from_elem_name(This->doc_node, bstrName, pid);
4675 }
4676
4677 static HRESULT WINAPI DocDispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
4678 VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
4679 {
4680 HTMLDocument *This = impl_from_IDispatchEx(iface);
4681
4682 if(This->window && id == DISPID_IHTMLDOCUMENT2_LOCATION && (wFlags & DISPATCH_PROPERTYPUT))
4683 return IDispatchEx_InvokeEx(&This->window->base.IDispatchEx_iface, DISPID_IHTMLWINDOW2_LOCATION,
4684 lcid, wFlags, pdp, pvarRes, pei, pspCaller);
4685
4686
4687 return IDispatchEx_InvokeEx(This->dispex, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
4688 }
4689
4690 static HRESULT WINAPI DocDispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
4691 {
4692 HTMLDocument *This = impl_from_IDispatchEx(iface);
4693
4694 return IDispatchEx_DeleteMemberByName(This->dispex, bstrName, grfdex);
4695 }
4696
4697 static HRESULT WINAPI DocDispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
4698 {
4699 HTMLDocument *This = impl_from_IDispatchEx(iface);
4700
4701 return IDispatchEx_DeleteMemberByDispID(This->dispex, id);
4702 }
4703
4704 static HRESULT WINAPI DocDispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
4705 {
4706 HTMLDocument *This = impl_from_IDispatchEx(iface);
4707
4708 return IDispatchEx_GetMemberProperties(This->dispex, id, grfdexFetch, pgrfdex);
4709 }
4710
4711 static HRESULT WINAPI DocDispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
4712 {
4713 HTMLDocument *This = impl_from_IDispatchEx(iface);
4714
4715 return IDispatchEx_GetMemberName(This->dispex, id, pbstrName);
4716 }
4717
4718 static HRESULT WINAPI DocDispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
4719 {
4720 HTMLDocument *This = impl_from_IDispatchEx(iface);
4721
4722 return IDispatchEx_GetNextDispID(This->dispex, grfdex, id, pid);
4723 }
4724
4725 static HRESULT WINAPI DocDispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
4726 {
4727 HTMLDocument *This = impl_from_IDispatchEx(iface);
4728
4729 return IDispatchEx_GetNameSpaceParent(This->dispex, ppunk);
4730 }
4731
4732 static const IDispatchExVtbl DocDispatchExVtbl = {
4733 DocDispatchEx_QueryInterface,
4734 DocDispatchEx_AddRef,
4735 DocDispatchEx_Release,
4736 DocDispatchEx_GetTypeInfoCount,
4737 DocDispatchEx_GetTypeInfo,
4738 DocDispatchEx_GetIDsOfNames,
4739 DocDispatchEx_Invoke,
4740 DocDispatchEx_GetDispID,
4741 DocDispatchEx_InvokeEx,
4742 DocDispatchEx_DeleteMemberByName,
4743 DocDispatchEx_DeleteMemberByDispID,
4744 DocDispatchEx_GetMemberProperties,
4745 DocDispatchEx_GetMemberName,
4746 DocDispatchEx_GetNextDispID,
4747 DocDispatchEx_GetNameSpaceParent
4748 };
4749
4750 static inline HTMLDocument *impl_from_IProvideMultipleClassInfo(IProvideMultipleClassInfo *iface)
4751 {
4752 return CONTAINING_RECORD(iface, HTMLDocument, IProvideMultipleClassInfo_iface);
4753 }
4754
4755 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideMultipleClassInfo *iface,
4756 REFIID riid, void **ppv)
4757 {
4758 HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4759 return htmldoc_query_interface(This, riid, ppv);
4760 }
4761
4762 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideMultipleClassInfo *iface)
4763 {
4764 HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4765 return htmldoc_addref(This);
4766 }
4767
4768 static ULONG WINAPI ProvideClassInfo_Release(IProvideMultipleClassInfo *iface)
4769 {
4770 HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4771 return htmldoc_release(This);
4772 }
4773
4774 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideMultipleClassInfo *iface, ITypeInfo **ppTI)
4775 {
4776 HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4777 TRACE("(%p)->(%p)\n", This, ppTI);
4778 return get_class_typeinfo(&CLSID_HTMLDocument, ppTI);
4779 }
4780
4781 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideMultipleClassInfo *iface, DWORD dwGuidKind, GUID *pGUID)
4782 {
4783 HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4784 FIXME("(%p)->(%u %p)\n", This, dwGuidKind, pGUID);
4785 return E_NOTIMPL;
4786 }
4787
4788 static HRESULT WINAPI ProvideMultipleClassInfo_GetMultiTypeInfoCount(IProvideMultipleClassInfo *iface, ULONG *pcti)
4789 {
4790 HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4791 FIXME("(%p)->(%p)\n", This, pcti);
4792 *pcti = 1;
4793 return S_OK;
4794 }
4795
4796 static HRESULT WINAPI ProvideMultipleClassInfo_GetInfoOfIndex(IProvideMultipleClassInfo *iface, ULONG iti,
4797 DWORD dwFlags, ITypeInfo **pptiCoClass, DWORD *pdwTIFlags, ULONG *pcdispidReserved, IID *piidPrimary, IID *piidSource)
4798 {
4799 HTMLDocument *This = impl_from_IProvideMultipleClassInfo(iface);
4800 FIXME("(%p)->(%u %x %p %p %p %p %p)\n", This, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource);
4801 return E_NOTIMPL;
4802 }
4803
4804 static const IProvideMultipleClassInfoVtbl ProvideMultipleClassInfoVtbl = {
4805 ProvideClassInfo_QueryInterface,
4806 ProvideClassInfo_AddRef,
4807 ProvideClassInfo_Release,
4808 ProvideClassInfo_GetClassInfo,
4809 ProvideClassInfo2_GetGUID,
4810 ProvideMultipleClassInfo_GetMultiTypeInfoCount,
4811 ProvideMultipleClassInfo_GetInfoOfIndex
4812 };
4813
4814 /**********************************************************
4815 * IMarkupServices implementation
4816 */
4817 static inline HTMLDocument *impl_from_IMarkupServices(IMarkupServices *iface)
4818 {
4819 return CONTAINING_RECORD(iface, HTMLDocument, IMarkupServices_iface);
4820 }
4821
4822 static HRESULT WINAPI MarkupServices_QueryInterface(IMarkupServices *iface, REFIID riid, void **ppvObject)
4823 {
4824 HTMLDocument *This = impl_from_IMarkupServices(iface);
4825 return htmldoc_query_interface(This, riid, ppvObject);
4826 }
4827
4828 static ULONG WINAPI MarkupServices_AddRef(IMarkupServices *iface)
4829 {
4830 HTMLDocument *This = impl_from_IMarkupServices(iface);
4831 return htmldoc_addref(This);
4832 }
4833
4834 static ULONG WINAPI MarkupServices_Release(IMarkupServices *iface)
4835 {
4836 HTMLDocument *This = impl_from_IMarkupServices(iface);
4837 return htmldoc_release(This);
4838 }
4839
4840 static HRESULT WINAPI MarkupServices_CreateMarkupPointer(IMarkupServices *iface, IMarkupPointer **ppPointer)
4841 {
4842 HTMLDocument *This = impl_from_IMarkupServices(iface);
4843
4844 TRACE("(%p)->(%p)\n", This, ppPointer);
4845
4846 return create_markup_pointer(ppPointer);
4847 }
4848
4849 static HRESULT WINAPI MarkupServices_CreateMarkupContainer(IMarkupServices *iface, IMarkupContainer **ppMarkupContainer)
4850 {
4851 HTMLDocument *This = impl_from_IMarkupServices(iface);
4852 FIXME("(%p)->(%p)\n", This, ppMarkupContainer);
4853 return E_NOTIMPL;
4854 }
4855
4856 static HRESULT WINAPI MarkupServices_CreateElement(IMarkupServices *iface,
4857 ELEMENT_TAG_ID tagID, OLECHAR *pchAttributes, IHTMLElement **ppElement)
4858 {
4859 HTMLDocument *This = impl_from_IMarkupServices(iface);
4860 FIXME("(%p)->(%d,%s,%p)\n", This, tagID, debugstr_w(pchAttributes), ppElement);
4861 return E_NOTIMPL;
4862 }
4863
4864 static HRESULT WINAPI MarkupServices_CloneElement(IMarkupServices *iface,
4865 IHTMLElement *pElemCloneThis, IHTMLElement **ppElementTheClone)
4866 {
4867 HTMLDocument *This = impl_from_IMarkupServices(iface);
4868 FIXME("(%p)->(%p,%p)\n", This, pElemCloneThis, ppElementTheClone);
4869 return E_NOTIMPL;
4870 }
4871
4872 static HRESULT WINAPI MarkupServices_InsertElement(IMarkupServices *iface,
4873 IHTMLElement *pElementInsert, IMarkupPointer *pPointerStart,
4874 IMarkupPointer *pPointerFinish)
4875 {
4876 HTMLDocument *This = impl_from_IMarkupServices(iface);
4877 FIXME("(%p)->(%p,%p,%p)\n", This, pElementInsert, pPointerStart, pPointerFinish);
4878 return E_NOTIMPL;
4879 }
4880
4881 static HRESULT WINAPI MarkupServices_RemoveElement(IMarkupServices *iface, IHTMLElement *pElementRemove)
4882 {
4883 HTMLDocument *This = impl_from_IMarkupServices(iface);
4884 FIXME("(%p)->(%p)\n", This, pElementRemove);
4885 return E_NOTIMPL;
4886 }
4887
4888 static HRESULT WINAPI MarkupServices_Remove(IMarkupServices *iface,
4889 IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish)
4890 {
4891 HTMLDocument *This = impl_from_IMarkupServices(iface);
4892 FIXME("(%p)->(%p,%p)\n", This, pPointerStart, pPointerFinish);
4893 return E_NOTIMPL;
4894 }
4895
4896 static HRESULT WINAPI MarkupServices_Copy(IMarkupServices *iface,
4897 IMarkupPointer *pPointerSourceStart, IMarkupPointer *pPointerSourceFinish,
4898 IMarkupPointer *pPointerTarget)
4899 {
4900 HTMLDocument *This = impl_from_IMarkupServices(iface);
4901 FIXME("(%p)->(%p,%p,%p)\n", This, pPointerSourceStart, pPointerSourceFinish, pPointerTarget);
4902 return E_NOTIMPL;
4903 }
4904
4905 static HRESULT WINAPI MarkupServices_Move(IMarkupServices *iface,
4906 IMarkupPointer *pPointerSourceStart, IMarkupPointer *pPointerSourceFinish,
4907 IMarkupPointer *pPointerTarget)
4908 {
4909 HTMLDocument *This = impl_from_IMarkupServices(iface);
4910 FIXME("(%p)->(%p,%p,%p)\n", This, pPointerSourceStart, pPointerSourceFinish, pPointerTarget);
4911 return E_NOTIMPL;
4912 }
4913
4914 static HRESULT WINAPI MarkupServices_InsertText(IMarkupServices *iface,
4915 OLECHAR *pchText, LONG cch, IMarkupPointer *pPointerTarget)
4916 {
4917 HTMLDocument *This = impl_from_IMarkupServices(iface);
4918 FIXME("(%p)->(%s,%x,%p)\n", This, debugstr_w(pchText), cch, pPointerTarget);
4919 return E_NOTIMPL;
4920 }
4921
4922 static HRESULT WINAPI MarkupServices_ParseString(IMarkupServices *iface,
4923 OLECHAR *pchHTML, DWORD dwFlags, IMarkupContainer **ppContainerResult,
4924 IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish)
4925 {
4926 HTMLDocument *This = impl_from_IMarkupServices(iface);
4927 FIXME("(%p)->(%s,%x,%p,%p,%p)\n", This, debugstr_w(pchHTML), dwFlags, ppContainerResult, pPointerStart, pPointerFinish);
4928 return E_NOTIMPL;
4929 }
4930
4931 static HRESULT WINAPI MarkupServices_ParseGlobal(IMarkupServices *iface,
4932 HGLOBAL hglobalHTML, DWORD dwFlags, IMarkupContainer **ppContainerResult,
4933 IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish)
4934 {
4935 HTMLDocument *This = impl_from_IMarkupServices(iface);
4936 FIXME("(%p)->(%s,%x,%p,%p,%p)\n", This, debugstr_w(hglobalHTML), dwFlags, ppContainerResult, pPointerStart, pPointerFinish);
4937 return E_NOTIMPL;
4938 }
4939
4940 static HRESULT WINAPI MarkupServices_IsScopedElement(IMarkupServices *iface,
4941 IHTMLElement *pElement, BOOL *pfScoped)
4942 {
4943 HTMLDocument *This = impl_from_IMarkupServices(iface);
4944 FIXME("(%p)->(%p,%p)\n", This, pElement, pfScoped);
4945 return E_NOTIMPL;
4946 }
4947
4948 static HRESULT WINAPI MarkupServices_GetElementTagId(IMarkupServices *iface,
4949 IHTMLElement *pElement, ELEMENT_TAG_ID *ptagId)
4950 {
4951 HTMLDocument *This = impl_from_IMarkupServices(iface);
4952 FIXME("(%p)->(%p,%p)\n", This, pElement, ptagId);
4953 return E_NOTIMPL;
4954 }
4955
4956 static HRESULT WINAPI MarkupServices_GetTagIDForName(IMarkupServices *iface,
4957 BSTR bstrName, ELEMENT_TAG_ID *ptagId)
4958 {
4959 HTMLDocument *This = impl_from_IMarkupServices(iface);
4960 FIXME("(%p)->(%s,%p)\n", This, debugstr_w(bstrName), ptagId);
4961 return E_NOTIMPL;
4962 }
4963
4964 static HRESULT WINAPI MarkupServices_GetNameForTagID(IMarkupServices *iface,
4965 ELEMENT_TAG_ID tagId, BSTR *pbstrName)
4966 {
4967 HTMLDocument *This = impl_from_IMarkupServices(iface);
4968 FIXME("(%p)->(%d,%p)\n", This, tagId, pbstrName);
4969 return E_NOTIMPL;
4970 }
4971
4972 static HRESULT WINAPI MarkupServices_MovePointersToRange(IMarkupServices *iface,
4973 IHTMLTxtRange *pIRange, IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish)
4974 {
4975 HTMLDocument *This = impl_from_IMarkupServices(iface);
4976 FIXME("(%p)->(%p,%p,%p)\n", This, pIRange, pPointerStart, pPointerFinish);
4977 return E_NOTIMPL;
4978 }
4979
4980 static HRESULT WINAPI MarkupServices_MoveRangeToPointers(IMarkupServices *iface,
4981 IMarkupPointer *pPointerStart, IMarkupPointer *pPointerFinish, IHTMLTxtRange *pIRange)
4982 {
4983 HTMLDocument *This = impl_from_IMarkupServices(iface);
4984 FIXME("(%p)->(%p,%p,%p)\n", This, pPointerStart, pPointerFinish, pIRange);
4985 return E_NOTIMPL;
4986 }
4987
4988 static HRESULT WINAPI MarkupServices_BeginUndoUnit(IMarkupServices *iface, OLECHAR *pchTitle)
4989 {
4990 HTMLDocument *This = impl_from_IMarkupServices(iface);
4991 FIXME("(%p)->(%s)\n", This, debugstr_w(pchTitle));
4992 return E_NOTIMPL;
4993 }
4994
4995 static HRESULT WINAPI MarkupServices_EndUndoUnit(IMarkupServices *iface)
4996 {
4997 HTMLDocument *This = impl_from_IMarkupServices(iface);
4998 FIXME("(%p)\n", This);
4999 return E_NOTIMPL;
5000 }
5001
5002 static const IMarkupServicesVtbl MarkupServicesVtbl = {
5003 MarkupServices_QueryInterface,
5004 MarkupServices_AddRef,
5005 MarkupServices_Release,
5006 MarkupServices_CreateMarkupPointer,
5007 MarkupServices_CreateMarkupContainer,
5008 MarkupServices_CreateElement,
5009 MarkupServices_CloneElement,
5010 MarkupServices_InsertElement,
5011 MarkupServices_RemoveElement,
5012 MarkupServices_Remove,
5013 MarkupServices_Copy,
5014 MarkupServices_Move,
5015 MarkupServices_InsertText,
5016 MarkupServices_ParseString,
5017 MarkupServices_ParseGlobal,
5018 MarkupServices_IsScopedElement,
5019 MarkupServices_GetElementTagId,
5020 MarkupServices_GetTagIDForName,
5021 MarkupServices_GetNameForTagID,
5022 MarkupServices_MovePointersToRange,
5023 MarkupServices_MoveRangeToPointers,
5024 MarkupServices_BeginUndoUnit,
5025 MarkupServices_EndUndoUnit
5026 };
5027
5028 /**********************************************************
5029 * IMarkupContainer implementation
5030 */
5031 static inline HTMLDocument *impl_from_IMarkupContainer(IMarkupContainer *iface)
5032 {
5033 return CONTAINING_RECORD(iface, HTMLDocument, IMarkupContainer_iface);
5034 }
5035
5036 static HRESULT WINAPI MarkupContainer_QueryInterface(IMarkupContainer *iface, REFIID riid, void **ppvObject)
5037 {
5038 HTMLDocument *This = impl_from_IMarkupContainer(iface);
5039 return htmldoc_query_interface(This, riid, ppvObject);
5040 }
5041
5042 static ULONG WINAPI MarkupContainer_AddRef(IMarkupContainer *iface)
5043 {
5044 HTMLDocument *This = impl_from_IMarkupContainer(iface);
5045 return htmldoc_addref(This);
5046 }
5047
5048 static ULONG WINAPI MarkupContainer_Release(IMarkupContainer *iface)
5049 {
5050 HTMLDocument *This = impl_from_IMarkupContainer(iface);
5051 return htmldoc_release(This);
5052 }
5053
5054 static HRESULT WINAPI MarkupContainer_OwningDoc(IMarkupContainer *iface, IHTMLDocument2 **ppDoc)
5055 {
5056 HTMLDocument *This = impl_from_IMarkupContainer(iface);
5057 FIXME("(%p)->(%p)\n", This, ppDoc);
5058 return E_NOTIMPL;
5059 }
5060
5061 static const IMarkupContainerVtbl MarkupContainerVtbl = {
5062 MarkupContainer_QueryInterface,
5063 MarkupContainer_AddRef,
5064 MarkupContainer_Release,
5065 MarkupContainer_OwningDoc
5066 };
5067
5068 /**********************************************************
5069 * IDisplayServices implementation
5070 */
5071 static inline HTMLDocument *impl_from_IDisplayServices(IDisplayServices *iface)
5072 {
5073 return CONTAINING_RECORD(iface, HTMLDocument, IDisplayServices_iface);
5074 }
5075
5076 static HRESULT WINAPI DisplayServices_QueryInterface(IDisplayServices *iface, REFIID riid, void **ppvObject)
5077 {
5078 HTMLDocument *This = impl_from_IDisplayServices(iface);
5079 return htmldoc_query_interface(This, riid, ppvObject);
5080 }
5081
5082 static ULONG WINAPI DisplayServices_AddRef(IDisplayServices *iface)
5083 {
5084 HTMLDocument *This = impl_from_IDisplayServices(iface);
5085 return htmldoc_addref(This);
5086 }
5087
5088 static ULONG WINAPI DisplayServices_Release(IDisplayServices *iface)
5089 {
5090 HTMLDocument *This = impl_from_IDisplayServices(iface);
5091 return htmldoc_release(This);
5092 }
5093
5094 static HRESULT WINAPI DisplayServices_CreateDisplayPointer(IDisplayServices *iface, IDisplayPointer **ppDispPointer)
5095 {
5096 HTMLDocument *This = impl_from_IDisplayServices(iface);
5097 FIXME("(%p)->(%p)\n", This, ppDispPointer);
5098 return E_NOTIMPL;
5099 }
5100
5101 static HRESULT WINAPI DisplayServices_TransformRect(IDisplayServices *iface,
5102 RECT *pRect, COORD_SYSTEM eSource, COORD_SYSTEM eDestination, IHTMLElement *pIElement)
5103 {
5104 HTMLDocument *This = impl_from_IDisplayServices(iface);
5105 FIXME("(%p)->(%s,%d,%d,%p)\n", This, wine_dbgstr_rect(pRect), eSource, eDestination, pIElement);
5106 return E_NOTIMPL;
5107 }
5108
5109 static HRESULT WINAPI DisplayServices_TransformPoint(IDisplayServices *iface,
5110 POINT *pPoint, COORD_SYSTEM eSource, COORD_SYSTEM eDestination, IHTMLElement *pIElement)
5111 {
5112 HTMLDocument *This = impl_from_IDisplayServices(iface);
5113 FIXME("(%p)->(%s,%d,%d,%p)\n", This, wine_dbgstr_point(pPoint), eSource, eDestination, pIElement);
5114 return E_NOTIMPL;
5115 }
5116
5117 static HRESULT WINAPI DisplayServices_GetCaret(IDisplayServices *iface, IHTMLCaret **ppCaret)
5118 {
5119 HTMLDocument *This = impl_from_IDisplayServices(iface);
5120 FIXME("(%p)->(%p)\n", This, ppCaret);
5121 return E_NOTIMPL;
5122 }
5123
5124 static HRESULT WINAPI DisplayServices_GetComputedStyle(IDisplayServices *iface,
5125 IMarkupPointer *pPointer, IHTMLComputedStyle **ppComputedStyle)
5126 {
5127 HTMLDocument *This = impl_from_IDisplayServices(iface);
5128 FIXME("(%p)->(%p,%p)\n", This, pPointer, ppComputedStyle);
5129 return E_NOTIMPL;
5130 }
5131
5132 static HRESULT WINAPI DisplayServices_ScrollRectIntoView(IDisplayServices *iface,
5133 IHTMLElement *pIElement, RECT rect)
5134 {
5135 HTMLDocument *This = impl_from_IDisplayServices(iface);
5136 FIXME("(%p)->(%p,%s)\n", This, pIElement, wine_dbgstr_rect(&rect));
5137 return E_NOTIMPL;
5138 }
5139
5140 static HRESULT WINAPI DisplayServices_HasFlowLayout(IDisplayServices *iface,
5141 IHTMLElement *pIElement, BOOL *pfHasFlowLayout)
5142 {
5143 HTMLDocument *This = impl_from_IDisplayServices(iface);
5144 FIXME("(%p)->(%p,%p)\n", This, pIElement, pfHasFlowLayout);
5145 return E_NOTIMPL;
5146 }
5147
5148 static const IDisplayServicesVtbl DisplayServicesVtbl = {
5149 DisplayServices_QueryInterface,
5150 DisplayServices_AddRef,
5151 DisplayServices_Release,
5152 DisplayServices_CreateDisplayPointer,
5153 DisplayServices_TransformRect,
5154 DisplayServices_TransformPoint,
5155 DisplayServices_GetCaret,
5156 DisplayServices_GetComputedStyle,
5157 DisplayServices_ScrollRectIntoView,
5158 DisplayServices_HasFlowLayout
5159 };
5160
5161 /**********************************************************
5162 * IDocumentRange implementation
5163 */
5164 static inline HTMLDocument *impl_from_IDocumentRange(IDocumentRange *iface)
5165 {
5166 return CONTAINING_RECORD(iface, HTMLDocument, IDocumentRange_iface);
5167 }
5168
5169 static HRESULT WINAPI DocumentRange_QueryInterface(IDocumentRange *iface, REFIID riid, void **ppv)
5170 {
5171 HTMLDocument *This = impl_from_IDocumentRange(iface);
5172
5173 return htmldoc_query_interface(This, riid, ppv);
5174 }
5175
5176 static ULONG WINAPI DocumentRange_AddRef(IDocumentRange *iface)
5177 {
5178 HTMLDocument *This = impl_from_IDocumentRange(iface);
5179
5180 return htmldoc_addref(This);
5181 }
5182
5183 static ULONG WINAPI DocumentRange_Release(IDocumentRange *iface)
5184 {
5185 HTMLDocument *This = impl_from_IDocumentRange(iface);
5186
5187 return htmldoc_release(This);
5188 }
5189
5190 static HRESULT WINAPI DocumentRange_GetTypeInfoCount(IDocumentRange *iface, UINT *pctinfo)
5191 {
5192 HTMLDocument *This = impl_from_IDocumentRange(iface);
5193
5194 return IDispatchEx_GetTypeInfoCount(&This->IDispatchEx_iface, pctinfo);
5195 }
5196
5197 static HRESULT WINAPI DocumentRange_GetTypeInfo(IDocumentRange *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
5198 {
5199 HTMLDocument *This = impl_from_IDocumentRange(iface);
5200
5201 return IDispatchEx_GetTypeInfo(&This->IDispatchEx_iface, iTInfo, lcid, ppTInfo);
5202 }
5203
5204 static HRESULT WINAPI DocumentRange_GetIDsOfNames(IDocumentRange *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
5205 LCID lcid, DISPID *rgDispId)
5206 {
5207 HTMLDocument *This = impl_from_IDocumentRange(iface);
5208
5209 return IDispatchEx_GetIDsOfNames(&This->IDispatchEx_iface, riid, rgszNames, cNames, lcid,
5210 rgDispId);
5211 }
5212
5213 static HRESULT WINAPI DocumentRange_Invoke(IDocumentRange *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
5214 WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
5215 {
5216 HTMLDocument *This = impl_from_IDocumentRange(iface);
5217
5218 return IDispatchEx_Invoke(&This->IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
5219 pDispParams, pVarResult, pExcepInfo, puArgErr);
5220 }
5221
5222 static HRESULT WINAPI DocumentRange_createRange(IDocumentRange *iface, IHTMLDOMRange **p)
5223 {
5224 HTMLDocument *This = impl_from_IDocumentRange(iface);
5225 nsIDOMRange *nsrange;
5226 HRESULT hres;
5227
5228 TRACE("(%p)->(%p)\n", This, p);
5229
5230 if(!This->doc_node->nsdoc) {
5231 WARN("NULL nsdoc\n");
5232 return E_UNEXPECTED;
5233 }
5234
5235 if(NS_FAILED(nsIDOMHTMLDocument_CreateRange(This->doc_node->nsdoc, &nsrange)))
5236 return E_FAIL;
5237
5238 hres = HTMLDOMRange_Create(nsrange, p);
5239 nsIDOMRange_Release(nsrange);
5240 return hres;
5241 }
5242
5243 static const IDocumentRangeVtbl DocumentRangeVtbl = {
5244 DocumentRange_QueryInterface,
5245 DocumentRange_AddRef,
5246 DocumentRange_Release,
5247 DocumentRange_GetTypeInfoCount,
5248 DocumentRange_GetTypeInfo,
5249 DocumentRange_GetIDsOfNames,
5250 DocumentRange_Invoke,
5251 DocumentRange_createRange,
5252 };
5253
5254 static BOOL htmldoc_qi(HTMLDocument *This, REFIID riid, void **ppv)
5255 {
5256 *ppv = NULL;
5257
5258 if(IsEqualGUID(&IID_IUnknown, riid))
5259 *ppv = &This->IHTMLDocument2_iface;
5260 else if(IsEqualGUID(&IID_IDispatch, riid))
5261 *ppv = &This->IDispatchEx_iface;
5262 else if(IsEqualGUID(&IID_IDispatchEx, riid))
5263 *ppv = &This->IDispatchEx_iface;
5264 else if(IsEqualGUID(&IID_IHTMLDocument, riid))
5265 *ppv = &This->IHTMLDocument2_iface;
5266 else if(IsEqualGUID(&IID_IHTMLDocument2, riid))
5267 *ppv = &This->IHTMLDocument2_iface;
5268 else if(IsEqualGUID(&IID_IHTMLDocument3, riid))
5269 *ppv = &This->IHTMLDocument3_iface;
5270 else if(IsEqualGUID(&IID_IHTMLDocument4, riid))
5271 *ppv = &This->IHTMLDocument4_iface;
5272 else if(IsEqualGUID(&IID_IHTMLDocument5, riid))
5273 *ppv = &This->IHTMLDocument5_iface;
5274 else if(IsEqualGUID(&IID_IHTMLDocument6, riid))
5275 *ppv = &This->IHTMLDocument6_iface;
5276 else if(IsEqualGUID(&IID_IHTMLDocument7, riid))
5277 *ppv = &This->IHTMLDocument7_iface;
5278 else if(IsEqualGUID(&IID_IDocumentSelector, riid))
5279 *ppv = &This->IDocumentSelector_iface;
5280 else if(IsEqualGUID(&IID_IDocumentEvent, riid))
5281 *ppv = &This->IDocumentEvent_iface;
5282 else if(IsEqualGUID(&IID_IPersist, riid))
5283 *ppv = &This->IPersistFile_iface;
5284 else if(IsEqualGUID(&IID_IPersistMoniker, riid))
5285 *ppv = &This->IPersistMoniker_iface;
5286 else if(IsEqualGUID(&IID_IPersistFile, riid))
5287 *ppv = &This->IPersistFile_iface;
5288 else if(IsEqualGUID(&IID_IMonikerProp, riid))
5289 *ppv = &This->IMonikerProp_iface;
5290 else if(IsEqualGUID(&IID_IOleObject, riid))
5291 *ppv = &This->IOleObject_iface;
5292 else if(IsEqualGUID(&IID_IOleDocument, riid))
5293 *ppv = &This->IOleDocument_iface;
5294 else if(IsEqualGUID(&IID_IOleInPlaceActiveObject, riid))
5295 *ppv = &This->IOleInPlaceActiveObject_iface;
5296 else if(IsEqualGUID(&IID_IOleWindow, riid))
5297 *ppv = &This->IOleInPlaceActiveObject_iface;
5298 else if(IsEqualGUID(&IID_IOleInPlaceObject, riid))
5299 *ppv = &This->IOleInPlaceObjectWindowless_iface;
5300 else if(IsEqualGUID(&IID_IOleInPlaceObjectWindowless, riid))
5301 *ppv = &This->IOleInPlaceObjectWindowless_iface;
5302 else if(IsEqualGUID(&IID_IServiceProvider, riid))
5303 *ppv = &This->IServiceProvider_iface;
5304 else if(IsEqualGUID(&IID_IOleCommandTarget, riid))
5305 *ppv = &This->IOleCommandTarget_iface;
5306 else if(IsEqualGUID(&IID_IOleControl, riid))
5307 *ppv = &This->IOleControl_iface;
5308 else if(IsEqualGUID(&IID_IHlinkTarget, riid))
5309 *ppv = &This->IHlinkTarget_iface;
5310 else if(IsEqualGUID(&IID_IConnectionPointContainer, riid))
5311 *ppv = &This->cp_container.IConnectionPointContainer_iface;
5312 else if(IsEqualGUID(&IID_IPersistStreamInit, riid))
5313 *ppv = &This->IPersistStreamInit_iface;
5314 else if(IsEqualGUID(&DIID_DispHTMLDocument, riid))
5315 *ppv = &This->IHTMLDocument2_iface;
5316 else if(IsEqualGUID(&IID_ISupportErrorInfo, riid))
5317 *ppv = &This->ISupportErrorInfo_iface;
5318 else if(IsEqualGUID(&IID_IPersistHistory, riid))
5319 *ppv = &This->IPersistHistory_iface;
5320 else if(IsEqualGUID(&IID_IObjectWithSite, riid))
5321 *ppv = &This->IObjectWithSite_iface;
5322 else if(IsEqualGUID(&IID_IOleContainer, riid))
5323 *ppv = &This->IOleContainer_iface;
5324 else if(IsEqualGUID(&IID_IObjectSafety, riid))
5325 *ppv = &This->IObjectSafety_iface;
5326 else if(IsEqualGUID(&IID_IProvideClassInfo, riid))
5327 *ppv = &This->IProvideMultipleClassInfo_iface;
5328 else if(IsEqualGUID(&IID_IProvideClassInfo2, riid))
5329 *ppv = &This->IProvideMultipleClassInfo_iface;
5330 else if(IsEqualGUID(&IID_IProvideMultipleClassInfo, riid))
5331 *ppv = &This->IProvideMultipleClassInfo_iface;
5332 else if(IsEqualGUID(&IID_IMarkupServices, riid))
5333 *ppv = &This->IMarkupServices_iface;
5334 else if(IsEqualGUID(&IID_IMarkupContainer, riid))
5335 *ppv = &This->IMarkupContainer_iface;
5336 else if(IsEqualGUID(&IID_IDisplayServices, riid))
5337 *ppv = &This->IDisplayServices_iface;
5338 else if(IsEqualGUID(&IID_IDocumentRange, riid))
5339 *ppv = &This->IDocumentRange_iface;
5340 else if(IsEqualGUID(&CLSID_CMarkup, riid)) {
5341 FIXME("(%p)->(CLSID_CMarkup %p)\n", This, ppv);
5342 *ppv = NULL;
5343 }else if(IsEqualGUID(&IID_IRunnableObject, riid)) {
5344 TRACE("(%p)->(IID_IRunnableObject %p) returning NULL\n", This, ppv);
5345 *ppv = NULL;
5346 }else if(IsEqualGUID(&IID_IPersistPropertyBag, riid)) {
5347 TRACE("(%p)->(IID_IPersistPropertyBag %p) returning NULL\n", This, ppv);
5348 *ppv = NULL;
5349 }else if(IsEqualGUID(&IID_IExternalConnection, riid)) {
5350 TRACE("(%p)->(IID_IExternalConnection %p) returning NULL\n", This, ppv);
5351 *ppv = NULL;
5352 }else if(IsEqualGUID(&IID_IStdMarshalInfo, riid)) {
5353 TRACE("(%p)->(IID_IStdMarshalInfo %p) returning NULL\n", This, ppv);
5354 *ppv = NULL;
5355 }else {
5356 return FALSE;
5357 }
5358
5359 if(*ppv)
5360 IUnknown_AddRef((IUnknown*)*ppv);
5361 return TRUE;
5362 }
5363
5364 static cp_static_data_t HTMLDocumentEvents_data = { HTMLDocumentEvents_tid, HTMLDocument_on_advise };
5365 static cp_static_data_t HTMLDocumentEvents2_data = { HTMLDocumentEvents2_tid, HTMLDocument_on_advise, TRUE };
5366
5367 static const cpc_entry_t HTMLDocument_cpc[] = {
5368 {&IID_IDispatch, &HTMLDocumentEvents_data},
5369 {&IID_IPropertyNotifySink},
5370 {&DIID_HTMLDocumentEvents, &HTMLDocumentEvents_data},
5371 {&DIID_HTMLDocumentEvents2, &HTMLDocumentEvents2_data},
5372 {NULL}
5373 };
5374
5375 static void init_doc(HTMLDocument *doc, IUnknown *outer, IDispatchEx *dispex)
5376 {
5377 doc->IHTMLDocument2_iface.lpVtbl = &HTMLDocumentVtbl;
5378 doc->IHTMLDocument3_iface.lpVtbl = &HTMLDocument3Vtbl;
5379 doc->IHTMLDocument4_iface.lpVtbl = &HTMLDocument4Vtbl;
5380 doc->IHTMLDocument5_iface.lpVtbl = &HTMLDocument5Vtbl;
5381 doc->IHTMLDocument6_iface.lpVtbl = &HTMLDocument6Vtbl;
5382 doc->IHTMLDocument7_iface.lpVtbl = &HTMLDocument7Vtbl;
5383 doc->IDispatchEx_iface.lpVtbl = &DocDispatchExVtbl;
5384 doc->IDocumentSelector_iface.lpVtbl = &DocumentSelectorVtbl;
5385 doc->IDocumentEvent_iface.lpVtbl = &DocumentEventVtbl;
5386 doc->ISupportErrorInfo_iface.lpVtbl = &SupportErrorInfoVtbl;
5387 doc->IProvideMultipleClassInfo_iface.lpVtbl = &ProvideMultipleClassInfoVtbl;
5388 doc->IMarkupServices_iface.lpVtbl = &MarkupServicesVtbl;
5389 doc->IMarkupContainer_iface.lpVtbl = &MarkupContainerVtbl;
5390 doc->IDisplayServices_iface.lpVtbl = &DisplayServicesVtbl;
5391 doc->IDocumentRange_iface.lpVtbl = &DocumentRangeVtbl;
5392
5393 doc->outer_unk = outer;
5394 doc->dispex = dispex;
5395
5396 HTMLDocument_Persist_Init(doc);
5397 HTMLDocument_OleCmd_Init(doc);
5398 HTMLDocument_OleObj_Init(doc);
5399 HTMLDocument_Service_Init(doc);
5400
5401 ConnectionPointContainer_Init(&doc->cp_container, (IUnknown*)&doc->IHTMLDocument2_iface, HTMLDocument_cpc);
5402 }
5403
5404 static inline HTMLDocumentNode *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
5405 {
5406 return CONTAINING_RECORD(iface, HTMLDocumentNode, node);
5407 }
5408
5409 static HRESULT HTMLDocumentNode_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
5410 {
5411 HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
5412
5413 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
5414
5415 if(htmldoc_qi(&This->basedoc, riid, ppv))
5416 return *ppv ? S_OK : E_NOINTERFACE;
5417
5418 if(IsEqualGUID(&IID_IInternetHostSecurityManager, riid))
5419 *ppv = &This->IInternetHostSecurityManager_iface;
5420 else
5421 return HTMLDOMNode_QI(&This->node, riid, ppv);
5422
5423 IUnknown_AddRef((IUnknown*)*ppv);
5424 return S_OK;
5425 }
5426
5427 void detach_document_node(HTMLDocumentNode *doc)
5428 {
5429 unsigned i;
5430
5431 while(!list_empty(&doc->plugin_hosts))
5432 detach_plugin_host(LIST_ENTRY(list_head(&doc->plugin_hosts), PluginHost, entry));
5433
5434 if(doc->dom_implementation) {
5435 detach_dom_implementation(doc->dom_implementation);
5436 IHTMLDOMImplementation_Release(doc->dom_implementation);
5437 doc->dom_implementation = NULL;
5438 }
5439
5440 if(doc->namespaces) {
5441 IHTMLNamespaceCollection_Release(doc->namespaces);
5442 doc->namespaces = NULL;
5443 }
5444
5445 detach_events(doc);
5446 detach_selection(doc);
5447 detach_ranges(doc);
5448
5449 for(i=0; i < doc->elem_vars_cnt; i++)
5450 heap_free(doc->elem_vars[i]);
5451 heap_free(doc->elem_vars);
5452 doc->elem_vars_cnt = doc->elem_vars_size = 0;
5453 doc->elem_vars = NULL;
5454
5455 if(doc->catmgr) {
5456 ICatInformation_Release(doc->catmgr);
5457 doc->catmgr = NULL;
5458 }
5459
5460 if(!doc->nsdoc && doc->window) {
5461 /* document fragments own reference to inner window */
5462 IHTMLWindow2_Release(&doc->window->base.IHTMLWindow2_iface);
5463 doc->window = NULL;
5464 }
5465
5466 if(doc->browser) {
5467 list_remove(&doc->browser_entry);
5468 doc->browser = NULL;
5469 }
5470 }
5471
5472 static void HTMLDocumentNode_destructor(HTMLDOMNode *iface)
5473 {
5474 HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
5475
5476 TRACE("(%p)\n", This);
5477
5478 heap_free(This->event_vector);
5479 ConnectionPointContainer_Destroy(&This->basedoc.cp_container);
5480 }
5481
5482 static HRESULT HTMLDocumentNode_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
5483 {
5484 HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
5485 FIXME("%p\n", This);
5486 return E_NOTIMPL;
5487 }
5488
5489 static void HTMLDocumentNode_traverse(HTMLDOMNode *iface, nsCycleCollectionTraversalCallback *cb)
5490 {
5491 HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
5492
5493 if(This->nsdoc)
5494 note_cc_edge((nsISupports*)This->nsdoc, "This->nsdoc", cb);
5495 }
5496
5497 static void HTMLDocumentNode_unlink(HTMLDOMNode *iface)
5498 {
5499 HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
5500
5501 if(This->nsdoc) {
5502 nsIDOMHTMLDocument *nsdoc = This->nsdoc;
5503
5504 release_document_mutation(This);
5505 detach_document_node(This);
5506 This->nsdoc = NULL;
5507 nsIDOMHTMLDocument_Release(nsdoc);
5508 This->window = NULL;
5509 }
5510 }
5511
5512 static const NodeImplVtbl HTMLDocumentNodeImplVtbl = {
5513 &CLSID_HTMLDocument,
5514 HTMLDocumentNode_QI,
5515 HTMLDocumentNode_destructor,
5516 HTMLDocument_cpc,
5517 HTMLDocumentNode_clone,
5518 NULL,
5519 NULL,
5520 NULL,
5521 NULL,
5522 NULL,
5523 NULL,
5524 NULL,
5525 NULL,
5526 NULL,
5527 NULL,
5528 HTMLDocumentNode_traverse,
5529 HTMLDocumentNode_unlink
5530 };
5531
5532 static HRESULT HTMLDocumentFragment_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
5533 {
5534 HTMLDocumentNode *This = impl_from_HTMLDOMNode(iface);
5535 HTMLDocumentNode *new_node;
5536 HRESULT hres;
5537
5538 hres = create_document_fragment(nsnode, This->node.doc, &new_node);
5539 if(FAILED(hres))
5540 return hres;
5541
5542 *ret = &new_node->node;
5543 return S_OK;
5544 }
5545
5546 static inline HTMLDocumentNode *impl_from_DispatchEx(DispatchEx *iface)
5547 {
5548 return CONTAINING_RECORD(iface, HTMLDocumentNode, node.event_target.dispex);
5549 }
5550
5551 static HRESULT HTMLDocumentNode_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
5552 VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
5553 {
5554 HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5555 nsIDOMNodeList *node_list;
5556 nsAString name_str;
5557 nsIDOMNode *nsnode;
5558 HTMLDOMNode *node;
5559 unsigned i;
5560 nsresult nsres;
5561 HRESULT hres;
5562
5563 if(flags != DISPATCH_PROPERTYGET && flags != (DISPATCH_METHOD|DISPATCH_PROPERTYGET)) {
5564 FIXME("unsupported flags %x\n", flags);
5565 return E_NOTIMPL;
5566 }
5567
5568 i = id - MSHTML_DISPID_CUSTOM_MIN;
5569
5570 if(!This->nsdoc || i >= This->elem_vars_cnt)
5571 return DISP_E_UNKNOWNNAME;
5572
5573 nsAString_InitDepend(&name_str, This->elem_vars[i]);
5574 nsres = nsIDOMHTMLDocument_GetElementsByName(This->nsdoc, &name_str, &node_list);
5575 nsAString_Finish(&name_str);
5576 if(NS_FAILED(nsres))
5577 return E_FAIL;
5578
5579 nsres = nsIDOMNodeList_Item(node_list, 0, &nsnode);
5580 nsIDOMNodeList_Release(node_list);
5581 if(NS_FAILED(nsres) || !nsnode)
5582 return DISP_E_UNKNOWNNAME;
5583
5584 hres = get_node(nsnode, TRUE, &node);
5585 if(FAILED(hres))
5586 return hres;
5587
5588 V_VT(res) = VT_DISPATCH;
5589 V_DISPATCH(res) = (IDispatch*)&node->IHTMLDOMNode_iface;
5590 return S_OK;
5591 }
5592
5593 static compat_mode_t HTMLDocumentNode_get_compat_mode(DispatchEx *dispex)
5594 {
5595 HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5596
5597 TRACE("(%p) returning %u\n", This, This->document_mode);
5598
5599 return lock_document_mode(This);
5600 }
5601
5602 static nsISupports *HTMLDocumentNode_get_gecko_target(DispatchEx *dispex)
5603 {
5604 HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5605 return (nsISupports*)This->node.nsnode;
5606 }
5607
5608 static void HTMLDocumentNode_bind_event(DispatchEx *dispex, eventid_t eid)
5609 {
5610 HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5611 ensure_doc_nsevent_handler(This, This->node.nsnode, eid);
5612 }
5613
5614 static EventTarget *HTMLDocumentNode_get_parent_event_target(DispatchEx *dispex)
5615 {
5616 HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5617 if(!This->window)
5618 return NULL;
5619 IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
5620 return &This->window->event_target;
5621 }
5622
5623 static ConnectionPointContainer *HTMLDocumentNode_get_cp_container(DispatchEx *dispex)
5624 {
5625 HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5626 ConnectionPointContainer *container = This->basedoc.doc_obj
5627 ? &This->basedoc.doc_obj->basedoc.cp_container : &This->basedoc.cp_container;
5628 IConnectionPointContainer_AddRef(&container->IConnectionPointContainer_iface);
5629 return container;
5630 }
5631
5632 static IHTMLEventObj *HTMLDocumentNode_set_current_event(DispatchEx *dispex, IHTMLEventObj *event)
5633 {
5634 HTMLDocumentNode *This = impl_from_DispatchEx(dispex);
5635 return default_set_current_event(This->window, event);
5636 }
5637
5638 static const event_target_vtbl_t HTMLDocumentNode_event_target_vtbl = {
5639 {
5640 NULL,
5641 NULL,
5642 HTMLDocumentNode_invoke,
5643 HTMLDocumentNode_get_compat_mode,
5644 NULL
5645 },
5646 HTMLDocumentNode_get_gecko_target,
5647 HTMLDocumentNode_bind_event,
5648 HTMLDocumentNode_get_parent_event_target,
5649 NULL,
5650 HTMLDocumentNode_get_cp_container,
5651 HTMLDocumentNode_set_current_event
5652 };
5653
5654 static const NodeImplVtbl HTMLDocumentFragmentImplVtbl = {
5655 &CLSID_HTMLDocument,
5656 HTMLDocumentNode_QI,
5657 HTMLDocumentNode_destructor,
5658 HTMLDocument_cpc,
5659 HTMLDocumentFragment_clone
5660 };
5661
5662 static const tid_t HTMLDocumentNode_iface_tids[] = {
5663 IHTMLDOMNode_tid,
5664 IHTMLDOMNode2_tid,
5665 IHTMLDocument2_tid,
5666 IHTMLDocument4_tid,
5667 IHTMLDocument5_tid,
5668 IDocumentSelector_tid,
5669 0
5670 };
5671
5672 static void HTMLDocumentNode_init_dispex_info(dispex_data_t *info, compat_mode_t mode)
5673 {
5674 HTMLDOMNode_init_dispex_info(info, mode);
5675
5676 if(mode >= COMPAT_MODE_IE9) {
5677 dispex_info_add_interface(info, IHTMLDocument7_tid, NULL);
5678 dispex_info_add_interface(info, IDocumentEvent_tid, NULL);
5679 }
5680
5681 /* Depending on compatibility version, we add interfaces in different order
5682 * so that the right getElementById implementation is used. */
5683 if(mode < COMPAT_MODE_IE8) {
5684 dispex_info_add_interface(info, IHTMLDocument3_tid, NULL);
5685 dispex_info_add_interface(info, IHTMLDocument6_tid, NULL);
5686 }else {
5687 dispex_info_add_interface(info, IHTMLDocument6_tid, NULL);
5688 dispex_info_add_interface(info, IHTMLDocument3_tid, NULL);
5689 }
5690 }
5691
5692 static dispex_static_data_t HTMLDocumentNode_dispex = {
5693 &HTMLDocumentNode_event_target_vtbl.dispex_vtbl,
5694 DispHTMLDocument_tid,
5695 HTMLDocumentNode_iface_tids,
5696 HTMLDocumentNode_init_dispex_info
5697 };
5698
5699 static HTMLDocumentNode *alloc_doc_node(HTMLDocumentObj *doc_obj, HTMLInnerWindow *window)
5700 {
5701 HTMLDocumentNode *doc;
5702
5703 doc = heap_alloc_zero(sizeof(HTMLDocumentNode));
5704 if(!doc)
5705 return NULL;
5706
5707 doc->ref = 1;
5708 doc->basedoc.doc_node = doc;
5709 doc->basedoc.doc_obj = doc_obj;
5710 doc->basedoc.window = window ? window->base.outer_window : NULL;
5711 doc->window = window;
5712
5713 init_doc(&doc->basedoc, (IUnknown*)&doc->node.IHTMLDOMNode_iface,
5714 &doc->node.event_target.dispex.IDispatchEx_iface);
5715 HTMLDocumentNode_SecMgr_Init(doc);
5716
5717 list_init(&doc->selection_list);
5718 list_init(&doc->range_list);
5719 list_init(&doc->plugin_hosts);
5720
5721 return doc;
5722 }
5723
5724 HRESULT create_document_node(nsIDOMHTMLDocument *nsdoc, GeckoBrowser *browser, HTMLInnerWindow *window,
5725 compat_mode_t parent_mode, HTMLDocumentNode **ret)
5726 {
5727 HTMLDocumentObj *doc_obj = browser->doc;
5728 HTMLDocumentNode *doc;
5729
5730 doc = alloc_doc_node(doc_obj, window);
5731 if(!doc)
5732 return E_OUTOFMEMORY;
5733
5734 if(parent_mode >= COMPAT_MODE_IE9) {
5735 TRACE("using parent mode %u\n", parent_mode);
5736 doc->document_mode = parent_mode;
5737 lock_document_mode(doc);
5738 }
5739
5740 if(!doc_obj->basedoc.window || (window && is_main_content_window(window->base.outer_window)))
5741 doc->basedoc.cp_container.forward_container = &doc_obj->basedoc.cp_container;
5742
5743 HTMLDOMNode_Init(doc, &doc->node, (nsIDOMNode*)nsdoc, &HTMLDocumentNode_dispex);
5744
5745 nsIDOMHTMLDocument_AddRef(nsdoc);
5746 doc->nsdoc = nsdoc;
5747
5748 init_document_mutation(doc);
5749 doc_init_events(doc);
5750
5751 doc->node.vtbl = &HTMLDocumentNodeImplVtbl;
5752
5753 list_add_head(&browser->document_nodes, &doc->browser_entry);
5754 doc->browser = browser;
5755
5756 if(browser->usermode == EDITMODE) {
5757 nsAString mode_str;
5758 nsresult nsres;
5759
5760 static const PRUnichar onW[] = {'o','n',0};
5761
5762 nsAString_InitDepend(&mode_str, onW);
5763 nsres = nsIDOMHTMLDocument_SetDesignMode(doc->nsdoc, &mode_str);
5764 nsAString_Finish(&mode_str);
5765 if(NS_FAILED(nsres))
5766 ERR("SetDesignMode failed: %08x\n", nsres);
5767 }
5768
5769 *ret = doc;
5770 return S_OK;
5771 }
5772
5773 static HRESULT create_document_fragment(nsIDOMNode *nsnode, HTMLDocumentNode *doc_node, HTMLDocumentNode **ret)
5774 {
5775 HTMLDocumentNode *doc_frag;
5776
5777 doc_frag = alloc_doc_node(doc_node->basedoc.doc_obj, doc_node->window);
5778 if(!doc_frag)
5779 return E_OUTOFMEMORY;
5780
5781 IHTMLWindow2_AddRef(&doc_frag->window->base.IHTMLWindow2_iface);
5782
5783 HTMLDOMNode_Init(doc_node, &doc_frag->node, nsnode, &HTMLDocumentNode_dispex);
5784 doc_frag->node.vtbl = &HTMLDocumentFragmentImplVtbl;
5785 doc_frag->document_mode = lock_document_mode(doc_node);
5786
5787 *ret = doc_frag;
5788 return S_OK;
5789 }
5790
5791 HRESULT get_document_node(nsIDOMDocument *dom_document, HTMLDocumentNode **ret)
5792 {
5793 HTMLDOMNode *node;
5794 HRESULT hres;
5795
5796 hres = get_node((nsIDOMNode*)dom_document, FALSE, &node);
5797 if(FAILED(hres))
5798 return hres;
5799
5800 if(!node) {
5801 ERR("document not initialized\n");
5802 return E_FAIL;
5803 }
5804
5805 assert(node->vtbl == &HTMLDocumentNodeImplVtbl);
5806 *ret = impl_from_HTMLDOMNode(node);
5807 return S_OK;
5808 }
5809
5810 static inline HTMLDocumentObj *impl_from_IUnknown(IUnknown *iface)
5811 {
5812 return CONTAINING_RECORD(iface, HTMLDocumentObj, IUnknown_inner);
5813 }
5814
5815 static HRESULT WINAPI HTMLDocumentObj_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
5816 {
5817 HTMLDocumentObj *This = impl_from_IUnknown(iface);
5818
5819 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
5820
5821 if(IsEqualGUID(&IID_IUnknown, riid)) {
5822 *ppv = &This->IUnknown_inner;
5823 }else if(htmldoc_qi(&This->basedoc, riid, ppv)) {
5824 return *ppv ? S_OK : E_NOINTERFACE;
5825 }else if(IsEqualGUID(&IID_ICustomDoc, riid)) {
5826 *ppv = &This->ICustomDoc_iface;
5827 }else if(IsEqualGUID(&IID_IOleDocumentView, riid)) {
5828 *ppv = &This->IOleDocumentView_iface;
5829 }else if(IsEqualGUID(&IID_IViewObject, riid)) {
5830 *ppv = &This->IViewObjectEx_iface;
5831 }else if(IsEqualGUID(&IID_IViewObject2, riid)) {
5832 *ppv = &This->IViewObjectEx_iface;
5833 }else if(IsEqualGUID(&IID_IViewObjectEx, riid)) {
5834 *ppv = &This->IViewObjectEx_iface;
5835 }else if(IsEqualGUID(&IID_ITargetContainer, riid)) {
5836 *ppv = &This->ITargetContainer_iface;
5837 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
5838 return *ppv ? S_OK : E_NOINTERFACE;
5839 }else {
5840 FIXME("Unimplemented interface %s\n", debugstr_mshtml_guid(riid));
5841 *ppv = NULL;
5842 return E_NOINTERFACE;
5843 }
5844
5845 IUnknown_AddRef((IUnknown*)*ppv);
5846 return S_OK;
5847 }
5848
5849 static ULONG WINAPI HTMLDocumentObj_AddRef(IUnknown *iface)
5850 {
5851 HTMLDocumentObj *This = impl_from_IUnknown(iface);
5852 ULONG ref = InterlockedIncrement(&This->ref);
5853
5854 TRACE("(%p) ref = %u\n", This, ref);
5855
5856 return ref;
5857 }
5858
5859 static ULONG WINAPI HTMLDocumentObj_Release(IUnknown *iface)
5860 {
5861 HTMLDocumentObj *This = impl_from_IUnknown(iface);
5862 ULONG ref = InterlockedDecrement(&This->ref);
5863
5864 TRACE("(%p) ref = %u\n", This, ref);
5865
5866 if(!ref) {
5867 if(This->basedoc.doc_node) {
5868 This->basedoc.doc_node->basedoc.doc_obj = NULL;
5869 htmldoc_release(&This->basedoc.doc_node->basedoc);
5870 }
5871 if(This->basedoc.window)
5872 IHTMLWindow2_Release(&This->basedoc.window->base.IHTMLWindow2_iface);
5873 if(This->advise_holder)
5874 IOleAdviseHolder_Release(This->advise_holder);
5875
5876 if(This->view_sink)
5877 IAdviseSink_Release(This->view_sink);
5878 if(This->client)
5879 IOleObject_SetClientSite(&This->basedoc.IOleObject_iface, NULL);
5880 if(This->hostui)
5881 ICustomDoc_SetUIHandler(&This->ICustomDoc_iface, NULL);
5882 if(This->in_place_active)
5883 IOleInPlaceObjectWindowless_InPlaceDeactivate(&This->basedoc.IOleInPlaceObjectWindowless_iface);
5884 if(This->ipsite)
5885 IOleDocumentView_SetInPlaceSite(&This->IOleDocumentView_iface, NULL);
5886 if(This->undomgr)
5887 IOleUndoManager_Release(This->undomgr);
5888 if(This->editsvcs)
5889 IHTMLEditServices_Release(This->editsvcs);
5890 if(This->tooltips_hwnd)
5891 DestroyWindow(This->tooltips_hwnd);
5892
5893 if(This->hwnd)
5894 DestroyWindow(This->hwnd);
5895 heap_free(This->mime);
5896
5897 remove_target_tasks(This->task_magic);
5898 ConnectionPointContainer_Destroy(&This->basedoc.cp_container);
5899 release_dispex(&This->dispex);
5900
5901 if(This->nscontainer)
5902 detach_gecko_browser(This->nscontainer);
5903 heap_free(This);
5904 }
5905
5906 return ref;
5907 }
5908
5909 static const IUnknownVtbl HTMLDocumentObjVtbl = {
5910 HTMLDocumentObj_QueryInterface,
5911 HTMLDocumentObj_AddRef,
5912 HTMLDocumentObj_Release
5913 };
5914
5915 /**********************************************************
5916 * ICustomDoc implementation
5917 */
5918
5919 static inline HTMLDocumentObj *impl_from_ICustomDoc(ICustomDoc *iface)
5920 {
5921 return CONTAINING_RECORD(iface, HTMLDocumentObj, ICustomDoc_iface);
5922 }
5923
5924 static HRESULT WINAPI CustomDoc_QueryInterface(ICustomDoc *iface, REFIID riid, void **ppv)
5925 {
5926 HTMLDocumentObj *This = impl_from_ICustomDoc(iface);
5927
5928 return htmldoc_query_interface(&This->basedoc, riid, ppv);
5929 }
5930
5931 static ULONG WINAPI CustomDoc_AddRef(ICustomDoc *iface)
5932 {
5933 HTMLDocumentObj *This = impl_from_ICustomDoc(iface);
5934
5935 return htmldoc_addref(&This->basedoc);
5936 }
5937
5938 static ULONG WINAPI CustomDoc_Release(ICustomDoc *iface)
5939 {
5940 HTMLDocumentObj *This = impl_from_ICustomDoc(iface);
5941
5942 return htmldoc_release(&This->basedoc);
5943 }
5944
5945 static HRESULT WINAPI CustomDoc_SetUIHandler(ICustomDoc *iface, IDocHostUIHandler *pUIHandler)
5946 {
5947 HTMLDocumentObj *This = impl_from_ICustomDoc(iface);
5948 IOleCommandTarget *cmdtrg;
5949 HRESULT hres;
5950
5951 TRACE("(%p)->(%p)\n", This, pUIHandler);
5952
5953 if(This->custom_hostui && This->hostui == pUIHandler)
5954 return S_OK;
5955
5956 This->custom_hostui = TRUE;
5957
5958 if(This->hostui)
5959 IDocHostUIHandler_Release(This->hostui);
5960 if(pUIHandler)
5961 IDocHostUIHandler_AddRef(pUIHandler);
5962 This->hostui = pUIHandler;
5963 if(!pUIHandler)
5964 return S_OK;
5965
5966 hres = IDocHostUIHandler_QueryInterface(pUIHandler, &IID_IOleCommandTarget, (void**)&cmdtrg);
5967 if(SUCCEEDED(hres)) {
5968 FIXME("custom UI handler supports IOleCommandTarget\n");
5969 IOleCommandTarget_Release(cmdtrg);
5970 }
5971
5972 return S_OK;
5973 }
5974
5975 static const ICustomDocVtbl CustomDocVtbl = {
5976 CustomDoc_QueryInterface,
5977 CustomDoc_AddRef,
5978 CustomDoc_Release,
5979 CustomDoc_SetUIHandler
5980 };
5981
5982 static const tid_t HTMLDocumentObj_iface_tids[] = {
5983 IHTMLDocument2_tid,
5984 IHTMLDocument3_tid,
5985 IHTMLDocument4_tid,
5986 IHTMLDocument5_tid,
5987 0
5988 };
5989 static dispex_static_data_t HTMLDocumentObj_dispex = {
5990 NULL,
5991 DispHTMLDocument_tid,
5992 HTMLDocumentObj_iface_tids
5993 };
5994
5995 static HRESULT create_document_object(BOOL is_mhtml, IUnknown *outer, REFIID riid, void **ppv)
5996 {
5997 HTMLDocumentObj *doc;
5998 HRESULT hres;
5999
6000 if(outer && !IsEqualGUID(&IID_IUnknown, riid)) {
6001 *ppv = NULL;
6002 return E_INVALIDARG;
6003 }
6004
6005 /* ensure that security manager is initialized */
6006 if(!get_security_manager())
6007 return E_OUTOFMEMORY;
6008
6009 doc = heap_alloc_zero(sizeof(HTMLDocumentObj));
6010 if(!doc)
6011 return E_OUTOFMEMORY;
6012
6013 doc->ref = 1;
6014 doc->IUnknown_inner.lpVtbl = &HTMLDocumentObjVtbl;
6015 doc->ICustomDoc_iface.lpVtbl = &CustomDocVtbl;
6016
6017 doc->basedoc.doc_obj = doc;
6018
6019 init_dispex(&doc->dispex, (IUnknown*)&doc->ICustomDoc_iface, &HTMLDocumentObj_dispex);
6020 init_doc(&doc->basedoc, outer ? outer : &doc->IUnknown_inner, &doc->dispex.IDispatchEx_iface);
6021 TargetContainer_Init(doc);
6022 doc->is_mhtml = is_mhtml;
6023
6024 doc->task_magic = get_task_target_magic();
6025
6026 HTMLDocument_View_Init(doc);
6027
6028 hres = create_gecko_browser(doc, &doc->nscontainer);
6029 if(FAILED(hres)) {
6030 ERR("Failed to init Gecko, returning CLASS_E_CLASSNOTAVAILABLE\n");
6031 htmldoc_release(&doc->basedoc);
6032 return hres;
6033 }
6034
6035 if(IsEqualGUID(&IID_IUnknown, riid)) {
6036 *ppv = &doc->IUnknown_inner;
6037 }else {
6038 hres = htmldoc_query_interface(&doc->basedoc, riid, ppv);
6039 htmldoc_release(&doc->basedoc);
6040 if(FAILED(hres))
6041 return hres;
6042 }
6043
6044 doc->basedoc.window = doc->nscontainer->content_window;
6045 IHTMLWindow2_AddRef(&doc->basedoc.window->base.IHTMLWindow2_iface);
6046
6047 if(!doc->basedoc.doc_node && doc->basedoc.window->base.inner_window->doc) {
6048 doc->basedoc.doc_node = doc->basedoc.window->base.inner_window->doc;
6049 htmldoc_addref(&doc->basedoc.doc_node->basedoc);
6050 }
6051
6052 get_thread_hwnd();
6053
6054 return S_OK;
6055 }
6056
6057 HRESULT HTMLDocument_Create(IUnknown *outer, REFIID riid, void **ppv)
6058 {
6059 TRACE("(%p %s %p)\n", outer, debugstr_mshtml_guid(riid), ppv);
6060 return create_document_object(FALSE, outer, riid, ppv);
6061 }
6062
6063 HRESULT MHTMLDocument_Create(IUnknown *outer, REFIID riid, void **ppv)
6064 {
6065 TRACE("(%p %s %p)\n", outer, debugstr_mshtml_guid(riid), ppv);
6066 return create_document_object(TRUE, outer, riid, ppv);
6067 }
Zebediah Figura's local tree