?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Implement GdipSetPathGradientLinearBlend.
[wine/multimedia.git] / dlls / msxml3 / domdoc.c
blob6805c75f79904d69fcb8c01a61b2ccd3aebbcd96
1 /*
2 * DOM Document implementation
3 *
4 * Copyright 2005 Mike McCormack
5 * Copyright 2010-2011 Adam Martinson for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define COBJMACROS
23 #define NONAMELESSUNION
24
25 #include "config.h"
26
27 #include <stdarg.h>
28 #include <assert.h>
29 #ifdef HAVE_LIBXML2
30 # include <libxml/parser.h>
31 # include <libxml/xmlerror.h>
32 # include <libxml/xpathInternals.h>
33 # include <libxml/xmlsave.h>
34 # include <libxml/SAX2.h>
35 # include <libxml/parserInternals.h>
36 #endif
37
38 #include "windef.h"
39 #include "winbase.h"
40 #include "winuser.h"
41 #include "winnls.h"
42 #include "ole2.h"
43 #include "olectl.h"
44 #include "msxml6.h"
45 #include "wininet.h"
46 #include "winreg.h"
47 #include "shlwapi.h"
48 #include "ocidl.h"
49 #include "objsafe.h"
50
51 #include "wine/debug.h"
52 #include "wine/list.h"
53
54 #include "msxml_private.h"
55
56 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
57
58 #ifdef HAVE_LIBXML2
59
60 /* not defined in older versions */
61 #define XML_SAVE_FORMAT 1
62 #define XML_SAVE_NO_DECL 2
63 #define XML_SAVE_NO_EMPTY 4
64 #define XML_SAVE_NO_XHTML 8
65 #define XML_SAVE_XHTML 16
66 #define XML_SAVE_AS_XML 32
67 #define XML_SAVE_AS_HTML 64
68
69 static const WCHAR PropertySelectionLanguageW[] = {'S','e','l','e','c','t','i','o','n','L','a','n','g','u','a','g','e',0};
70 static const WCHAR PropertySelectionNamespacesW[] = {'S','e','l','e','c','t','i','o','n','N','a','m','e','s','p','a','c','e','s',0};
71 static const WCHAR PropertyProhibitDTDW[] = {'P','r','o','h','i','b','i','t','D','T','D',0};
72 static const WCHAR PropertyNewParserW[] = {'N','e','w','P','a','r','s','e','r',0};
73 static const WCHAR PropValueXPathW[] = {'X','P','a','t','h',0};
74 static const WCHAR PropValueXSLPatternW[] = {'X','S','L','P','a','t','t','e','r','n',0};
75 static const WCHAR PropertyResolveExternalsW[] = {'R','e','s','o','l','v','e','E','x','t','e','r','n','a','l','s',0};
76
77 /* Anything that passes the test_get_ownerDocument()
78 * tests can go here (data shared between all instances).
79 * We need to preserve this when reloading a document,
80 * and also need access to it from the libxml backend. */
81 typedef struct {
82 MSXML_VERSION version;
83 VARIANT_BOOL preserving;
84 IXMLDOMSchemaCollection2* schemaCache;
85 struct list selectNsList;
86 xmlChar const* selectNsStr;
87 LONG selectNsStr_len;
88 BOOL XPath;
89 } domdoc_properties;
90
91 typedef struct ConnectionPoint ConnectionPoint;
92 typedef struct domdoc domdoc;
93
94 struct ConnectionPoint
95 {
96 IConnectionPoint IConnectionPoint_iface;
97 const IID *iid;
98
99 ConnectionPoint *next;
100 IConnectionPointContainer *container;
101 domdoc *doc;
102
103 union
104 {
105 IUnknown *unk;
106 IDispatch *disp;
107 IPropertyNotifySink *propnotif;
108 } *sinks;
109 DWORD sinks_size;
110 };
111
112 typedef enum {
113 EVENTID_READYSTATECHANGE = 0,
114 EVENTID_DATAAVAILABLE,
115 EVENTID_TRANSFORMNODE,
116 EVENTID_LAST
117 } eventid_t;
118
119 struct domdoc
120 {
121 xmlnode node;
122 IXMLDOMDocument3 IXMLDOMDocument3_iface;
123 IPersistStreamInit IPersistStreamInit_iface;
124 IObjectWithSite IObjectWithSite_iface;
125 IObjectSafety IObjectSafety_iface;
126 IConnectionPointContainer IConnectionPointContainer_iface;
127 LONG ref;
128 VARIANT_BOOL async;
129 VARIANT_BOOL validating;
130 VARIANT_BOOL resolving;
131 domdoc_properties* properties;
132 bsc_t *bsc;
133 HRESULT error;
134
135 /* IPersistStream */
136 IStream *stream;
137
138 /* IObjectWithSite*/
139 IUnknown *site;
140
141 /* IObjectSafety */
142 DWORD safeopt;
143
144 /* connection list */
145 ConnectionPoint *cp_list;
146 ConnectionPoint cp_domdocevents;
147 ConnectionPoint cp_propnotif;
148 ConnectionPoint cp_dispatch;
149
150 /* events */
151 IDispatch *events[EVENTID_LAST];
152
153 IXMLDOMSchemaCollection2 *namespaces;
154 };
155
156 static HRESULT set_doc_event(domdoc *doc, eventid_t eid, const VARIANT *v)
157 {
158 IDispatch *disp;
159
160 switch (V_VT(v))
161 {
162 case VT_UNKNOWN:
163 if (V_UNKNOWN(v))
164 IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, (void**)&disp);
165 else
166 disp = NULL;
167 break;
168 case VT_DISPATCH:
169 disp = V_DISPATCH(v);
170 if (disp) IDispatch_AddRef(disp);
171 break;
172 default:
173 return DISP_E_TYPEMISMATCH;
174 }
175
176 if (doc->events[eid]) IDispatch_Release(doc->events[eid]);
177 doc->events[eid] = disp;
178
179 return S_OK;
180 }
181
182 static inline ConnectionPoint *impl_from_IConnectionPoint(IConnectionPoint *iface)
183 {
184 return CONTAINING_RECORD(iface, ConnectionPoint, IConnectionPoint_iface);
185 }
186
187 /*
188 In native windows, the whole lifetime management of XMLDOMNodes is
189 managed automatically using reference counts. Wine emulates that by
190 maintaining a reference count to the document that is increased for
191 each IXMLDOMNode pointer passed out for this document. If all these
192 pointers are gone, the document is unreachable and gets freed, that
193 is, all nodes in the tree of the document get freed.
194
195 You are able to create nodes that are associated to a document (in
196 fact, in msxml's XMLDOM model, all nodes are associated to a document),
197 but not in the tree of that document, for example using the createFoo
198 functions from IXMLDOMDocument. These nodes do not get cleaned up
199 by libxml, so we have to do it ourselves.
200
201 To catch these nodes, a list of "orphan nodes" is introduced.
202 It contains pointers to all roots of node trees that are
203 associated with the document without being part of the document
204 tree. All nodes with parent==NULL (except for the document root nodes)
205 should be in the orphan node list of their document. All orphan nodes
206 get freed together with the document itself.
207 */
208
209 typedef struct _xmldoc_priv {
210 LONG refs;
211 struct list orphans;
212 domdoc_properties* properties;
213 } xmldoc_priv;
214
215 typedef struct _orphan_entry {
216 struct list entry;
217 xmlNode * node;
218 } orphan_entry;
219
220 typedef struct _select_ns_entry {
221 struct list entry;
222 xmlChar const* prefix;
223 xmlChar prefix_end;
224 xmlChar const* href;
225 xmlChar href_end;
226 } select_ns_entry;
227
228 static inline xmldoc_priv * priv_from_xmlDocPtr(const xmlDocPtr doc)
229 {
230 return doc->_private;
231 }
232
233 static inline domdoc_properties * properties_from_xmlDocPtr(xmlDocPtr doc)
234 {
235 return priv_from_xmlDocPtr(doc)->properties;
236 }
237
238 BOOL is_xpathmode(const xmlDocPtr doc)
239 {
240 return properties_from_xmlDocPtr(doc)->XPath;
241 }
242
243 void set_xpathmode(xmlDocPtr doc, BOOL xpath)
244 {
245 properties_from_xmlDocPtr(doc)->XPath = xpath;
246 }
247
248 int registerNamespaces(xmlXPathContextPtr ctxt)
249 {
250 int n = 0;
251 const select_ns_entry* ns = NULL;
252 const struct list* pNsList = &properties_from_xmlDocPtr(ctxt->doc)->selectNsList;
253
254 TRACE("(%p)\n", ctxt);
255
256 LIST_FOR_EACH_ENTRY( ns, pNsList, select_ns_entry, entry )
257 {
258 xmlXPathRegisterNs(ctxt, ns->prefix, ns->href);
259 ++n;
260 }
261
262 return n;
263 }
264
265 static inline void clear_selectNsList(struct list* pNsList)
266 {
267 select_ns_entry *ns, *ns2;
268 LIST_FOR_EACH_ENTRY_SAFE( ns, ns2, pNsList, select_ns_entry, entry )
269 {
270 heap_free( ns );
271 }
272 list_init(pNsList);
273 }
274
275 static xmldoc_priv * create_priv(void)
276 {
277 xmldoc_priv *priv;
278 priv = heap_alloc( sizeof (*priv) );
279
280 if (priv)
281 {
282 priv->refs = 0;
283 list_init( &priv->orphans );
284 priv->properties = NULL;
285 }
286
287 return priv;
288 }
289
290 static domdoc_properties *create_properties(MSXML_VERSION version)
291 {
292 domdoc_properties *properties = heap_alloc(sizeof(domdoc_properties));
293
294 list_init(&properties->selectNsList);
295 properties->preserving = VARIANT_FALSE;
296 properties->schemaCache = NULL;
297 properties->selectNsStr = heap_alloc_zero(sizeof(xmlChar));
298 properties->selectNsStr_len = 0;
299
300 /* properties that are dependent on object versions */
301 properties->version = version;
302 properties->XPath = (version == MSXML4 || version == MSXML6);
303
304 return properties;
305 }
306
307 static domdoc_properties* copy_properties(domdoc_properties const* properties)
308 {
309 domdoc_properties* pcopy = heap_alloc(sizeof(domdoc_properties));
310 select_ns_entry const* ns = NULL;
311 select_ns_entry* new_ns = NULL;
312 int len = (properties->selectNsStr_len+1)*sizeof(xmlChar);
313 ptrdiff_t offset;
314
315 if (pcopy)
316 {
317 pcopy->version = properties->version;
318 pcopy->preserving = properties->preserving;
319 pcopy->schemaCache = properties->schemaCache;
320 if (pcopy->schemaCache)
321 IXMLDOMSchemaCollection2_AddRef(pcopy->schemaCache);
322 pcopy->XPath = properties->XPath;
323 pcopy->selectNsStr_len = properties->selectNsStr_len;
324 list_init( &pcopy->selectNsList );
325 pcopy->selectNsStr = heap_alloc(len);
326 memcpy((xmlChar*)pcopy->selectNsStr, properties->selectNsStr, len);
327 offset = pcopy->selectNsStr - properties->selectNsStr;
328
329 LIST_FOR_EACH_ENTRY( ns, (&properties->selectNsList), select_ns_entry, entry )
330 {
331 new_ns = heap_alloc(sizeof(select_ns_entry));
332 memcpy(new_ns, ns, sizeof(select_ns_entry));
333 new_ns->href += offset;
334 new_ns->prefix += offset;
335 list_add_tail(&pcopy->selectNsList, &new_ns->entry);
336 }
337
338 }
339
340 return pcopy;
341 }
342
343 static void free_properties(domdoc_properties* properties)
344 {
345 if (properties)
346 {
347 if (properties->schemaCache)
348 IXMLDOMSchemaCollection2_Release(properties->schemaCache);
349 clear_selectNsList(&properties->selectNsList);
350 heap_free((xmlChar*)properties->selectNsStr);
351 heap_free(properties);
352 }
353 }
354
355 static void release_namespaces(domdoc *This)
356 {
357 if (This->namespaces)
358 {
359 IXMLDOMSchemaCollection2_Release(This->namespaces);
360 This->namespaces = NULL;
361 }
362 }
363
364 /* links a "<?xml" node as a first child */
365 void xmldoc_link_xmldecl(xmlDocPtr doc, xmlNodePtr node)
366 {
367 assert(doc != NULL);
368 if (doc->standalone != -1) xmlAddPrevSibling( doc->children, node );
369 }
370
371 /* unlinks a first "<?xml" child if it was created */
372 xmlNodePtr xmldoc_unlink_xmldecl(xmlDocPtr doc)
373 {
374 xmlNodePtr node;
375
376 assert(doc != NULL);
377
378 if (doc->standalone != -1)
379 {
380 node = doc->children;
381 xmlUnlinkNode( node );
382 }
383 else
384 node = NULL;
385
386 return node;
387 }
388
389 BOOL is_preserving_whitespace(xmlNodePtr node)
390 {
391 domdoc_properties* properties = NULL;
392 /* during parsing the xmlDoc._private stuff is not there */
393 if (priv_from_xmlDocPtr(node->doc))
394 properties = properties_from_xmlDocPtr(node->doc);
395 return ((properties && properties->preserving == VARIANT_TRUE) ||
396 xmlNodeGetSpacePreserve(node) == 1);
397 }
398
399 static inline BOOL strn_isspace(xmlChar const* str, int len)
400 {
401 for (; str && len > 0 && *str; ++str, --len)
402 if (!isspace(*str))
403 break;
404
405 return len == 0;
406 }
407
408 static void sax_characters(void *ctx, const xmlChar *ch, int len)
409 {
410 xmlParserCtxtPtr ctxt;
411 const domdoc *This;
412
413 ctxt = (xmlParserCtxtPtr) ctx;
414 This = (const domdoc*) ctxt->_private;
415
416 if (ctxt->node)
417 {
418 /* during domdoc_loadXML() the xmlDocPtr->_private data is not available */
419 if (!This->properties->preserving &&
420 !is_preserving_whitespace(ctxt->node) &&
421 strn_isspace(ch, len))
422 return;
423 }
424
425 xmlSAX2Characters(ctxt, ch, len);
426 }
427
428 static void LIBXML2_LOG_CALLBACK sax_error(void* ctx, char const* msg, ...)
429 {
430 va_list ap;
431 va_start(ap, msg);
432 LIBXML2_CALLBACK_ERR(doparse, msg, ap);
433 va_end(ap);
434 }
435
436 static void LIBXML2_LOG_CALLBACK sax_warning(void* ctx, char const* msg, ...)
437 {
438 va_list ap;
439 va_start(ap, msg);
440 LIBXML2_CALLBACK_WARN(doparse, msg, ap);
441 va_end(ap);
442 }
443
444 static void sax_serror(void* ctx, xmlErrorPtr err)
445 {
446 LIBXML2_CALLBACK_SERROR(doparse, err);
447 }
448
449 static xmlDocPtr doparse(domdoc* This, char const* ptr, int len, xmlCharEncoding encoding)
450 {
451 xmlDocPtr doc = NULL;
452 xmlParserCtxtPtr pctx;
453 static xmlSAXHandler sax_handler = {
454 xmlSAX2InternalSubset, /* internalSubset */
455 xmlSAX2IsStandalone, /* isStandalone */
456 xmlSAX2HasInternalSubset, /* hasInternalSubset */
457 xmlSAX2HasExternalSubset, /* hasExternalSubset */
458 xmlSAX2ResolveEntity, /* resolveEntity */
459 xmlSAX2GetEntity, /* getEntity */
460 xmlSAX2EntityDecl, /* entityDecl */
461 xmlSAX2NotationDecl, /* notationDecl */
462 xmlSAX2AttributeDecl, /* attributeDecl */
463 xmlSAX2ElementDecl, /* elementDecl */
464 xmlSAX2UnparsedEntityDecl, /* unparsedEntityDecl */
465 xmlSAX2SetDocumentLocator, /* setDocumentLocator */
466 xmlSAX2StartDocument, /* startDocument */
467 xmlSAX2EndDocument, /* endDocument */
468 xmlSAX2StartElement, /* startElement */
469 xmlSAX2EndElement, /* endElement */
470 xmlSAX2Reference, /* reference */
471 sax_characters, /* characters */
472 sax_characters, /* ignorableWhitespace */
473 xmlSAX2ProcessingInstruction, /* processingInstruction */
474 xmlSAX2Comment, /* comment */
475 sax_warning, /* warning */
476 sax_error, /* error */
477 sax_error, /* fatalError */
478 xmlSAX2GetParameterEntity, /* getParameterEntity */
479 xmlSAX2CDataBlock, /* cdataBlock */
480 xmlSAX2ExternalSubset, /* externalSubset */
481 0, /* initialized */
482 NULL, /* _private */
483 xmlSAX2StartElementNs, /* startElementNs */
484 xmlSAX2EndElementNs, /* endElementNs */
485 sax_serror /* serror */
486 };
487 xmlInitParser();
488
489 pctx = xmlCreateMemoryParserCtxt(ptr, len);
490 if (!pctx)
491 {
492 ERR("Failed to create parser context\n");
493 return NULL;
494 }
495
496 if (pctx->sax) xmlFree(pctx->sax);
497 pctx->sax = &sax_handler;
498 pctx->_private = This;
499 pctx->recovery = 0;
500
501 if (encoding != XML_CHAR_ENCODING_NONE)
502 xmlSwitchEncoding(pctx, encoding);
503
504 xmlParseDocument(pctx);
505
506 if (pctx->wellFormed)
507 {
508 doc = pctx->myDoc;
509 }
510 else
511 {
512 xmlFreeDoc(pctx->myDoc);
513 pctx->myDoc = NULL;
514 }
515 pctx->sax = NULL;
516 xmlFreeParserCtxt(pctx);
517
518 /* TODO: put this in one of the SAX callbacks */
519 /* create first child as a <?xml...?> */
520 if (doc && doc->standalone != -1)
521 {
522 xmlNodePtr node;
523 char buff[30];
524 xmlChar *xmlbuff = (xmlChar*)buff;
525
526 node = xmlNewDocPI( doc, (xmlChar*)"xml", NULL );
527
528 /* version attribute can't be omitted */
529 sprintf(buff, "version=\"%s\"", doc->version ? (char*)doc->version : "1.0");
530 xmlNodeAddContent( node, xmlbuff );
531
532 if (doc->encoding)
533 {
534 sprintf(buff, " encoding=\"%s\"", doc->encoding);
535 xmlNodeAddContent( node, xmlbuff );
536 }
537
538 if (doc->standalone != -2)
539 {
540 sprintf(buff, " standalone=\"%s\"", doc->standalone == 0 ? "no" : "yes");
541 xmlNodeAddContent( node, xmlbuff );
542 }
543
544 xmldoc_link_xmldecl( doc, node );
545 }
546
547 return doc;
548 }
549
550 void xmldoc_init(xmlDocPtr doc, MSXML_VERSION version)
551 {
552 doc->_private = create_priv();
553 priv_from_xmlDocPtr(doc)->properties = create_properties(version);
554 }
555
556 LONG xmldoc_add_ref(xmlDocPtr doc)
557 {
558 LONG ref = InterlockedIncrement(&priv_from_xmlDocPtr(doc)->refs);
559 TRACE("(%p)->(%d)\n", doc, ref);
560 return ref;
561 }
562
563 LONG xmldoc_release(xmlDocPtr doc)
564 {
565 xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
566 LONG ref = InterlockedDecrement(&priv->refs);
567 TRACE("(%p)->(%d)\n", doc, ref);
568 if(ref == 0)
569 {
570 orphan_entry *orphan, *orphan2;
571 TRACE("freeing docptr %p\n", doc);
572
573 LIST_FOR_EACH_ENTRY_SAFE( orphan, orphan2, &priv->orphans, orphan_entry, entry )
574 {
575 xmlFreeNode( orphan->node );
576 heap_free( orphan );
577 }
578 free_properties(priv->properties);
579 heap_free(doc->_private);
580
581 xmlFreeDoc(doc);
582 }
583
584 return ref;
585 }
586
587 HRESULT xmldoc_add_orphan(xmlDocPtr doc, xmlNodePtr node)
588 {
589 xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
590 orphan_entry *entry;
591
592 entry = heap_alloc( sizeof (*entry) );
593 if(!entry)
594 return E_OUTOFMEMORY;
595
596 entry->node = node;
597 list_add_head( &priv->orphans, &entry->entry );
598 return S_OK;
599 }
600
601 HRESULT xmldoc_remove_orphan(xmlDocPtr doc, xmlNodePtr node)
602 {
603 xmldoc_priv *priv = priv_from_xmlDocPtr(doc);
604 orphan_entry *entry, *entry2;
605
606 LIST_FOR_EACH_ENTRY_SAFE( entry, entry2, &priv->orphans, orphan_entry, entry )
607 {
608 if( entry->node == node )
609 {
610 list_remove( &entry->entry );
611 heap_free( entry );
612 return S_OK;
613 }
614 }
615
616 return S_FALSE;
617 }
618
619 static inline xmlDocPtr get_doc( domdoc *This )
620 {
621 return (xmlDocPtr)This->node.node;
622 }
623
624 static HRESULT attach_xmldoc(domdoc *This, xmlDocPtr xml )
625 {
626 release_namespaces(This);
627
628 if(This->node.node)
629 {
630 priv_from_xmlDocPtr(get_doc(This))->properties = NULL;
631 if (xmldoc_release(get_doc(This)) != 0)
632 priv_from_xmlDocPtr(get_doc(This))->properties =
633 copy_properties(This->properties);
634 }
635
636 This->node.node = (xmlNodePtr) xml;
637
638 if(This->node.node)
639 {
640 xmldoc_add_ref(get_doc(This));
641 priv_from_xmlDocPtr(get_doc(This))->properties = This->properties;
642 }
643
644 return S_OK;
645 }
646
647 static inline domdoc *impl_from_IXMLDOMDocument3( IXMLDOMDocument3 *iface )
648 {
649 return CONTAINING_RECORD(iface, domdoc, IXMLDOMDocument3_iface);
650 }
651
652 static inline domdoc *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
653 {
654 return CONTAINING_RECORD(iface, domdoc, IPersistStreamInit_iface);
655 }
656
657 static inline domdoc *impl_from_IObjectWithSite(IObjectWithSite *iface)
658 {
659 return CONTAINING_RECORD(iface, domdoc, IObjectWithSite_iface);
660 }
661
662 static inline domdoc *impl_from_IObjectSafety(IObjectSafety *iface)
663 {
664 return CONTAINING_RECORD(iface, domdoc, IObjectSafety_iface);
665 }
666
667 static inline domdoc *impl_from_IConnectionPointContainer(IConnectionPointContainer *iface)
668 {
669 return CONTAINING_RECORD(iface, domdoc, IConnectionPointContainer_iface);
670 }
671
672 /************************************************************************
673 * domdoc implementation of IPersistStream.
674 */
675 static HRESULT WINAPI PersistStreamInit_QueryInterface(
676 IPersistStreamInit *iface, REFIID riid, void **ppvObj)
677 {
678 domdoc* This = impl_from_IPersistStreamInit(iface);
679 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppvObj);
680 }
681
682 static ULONG WINAPI PersistStreamInit_AddRef(
683 IPersistStreamInit *iface)
684 {
685 domdoc* This = impl_from_IPersistStreamInit(iface);
686 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
687 }
688
689 static ULONG WINAPI PersistStreamInit_Release(
690 IPersistStreamInit *iface)
691 {
692 domdoc* This = impl_from_IPersistStreamInit(iface);
693 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
694 }
695
696 static HRESULT WINAPI PersistStreamInit_GetClassID(
697 IPersistStreamInit *iface, CLSID *classid)
698 {
699 domdoc* This = impl_from_IPersistStreamInit(iface);
700 TRACE("(%p)->(%p)\n", This, classid);
701
702 if(!classid)
703 return E_POINTER;
704
705 *classid = *DOMDocument_version(This->properties->version);
706
707 return S_OK;
708 }
709
710 static HRESULT WINAPI PersistStreamInit_IsDirty(
711 IPersistStreamInit *iface)
712 {
713 domdoc *This = impl_from_IPersistStreamInit(iface);
714 FIXME("(%p): stub!\n", This);
715 return S_FALSE;
716 }
717
718 static HRESULT WINAPI PersistStreamInit_Load(
719 IPersistStreamInit *iface, LPSTREAM pStm)
720 {
721 domdoc *This = impl_from_IPersistStreamInit(iface);
722 HRESULT hr;
723 HGLOBAL hglobal;
724 DWORD read, written, len;
725 BYTE buf[4096];
726 char *ptr;
727 xmlDocPtr xmldoc = NULL;
728
729 TRACE("(%p)->(%p)\n", This, pStm);
730
731 if (!pStm)
732 return E_INVALIDARG;
733
734 hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
735 if (FAILED(hr))
736 return hr;
737
738 do
739 {
740 IStream_Read(pStm, buf, sizeof(buf), &read);
741 hr = IStream_Write(This->stream, buf, read, &written);
742 } while(SUCCEEDED(hr) && written != 0 && read != 0);
743
744 if (FAILED(hr))
745 {
746 ERR("Failed to copy stream\n");
747 return hr;
748 }
749
750 hr = GetHGlobalFromStream(This->stream, &hglobal);
751 if (FAILED(hr))
752 return hr;
753
754 len = GlobalSize(hglobal);
755 ptr = GlobalLock(hglobal);
756 if (len != 0)
757 xmldoc = doparse(This, ptr, len, XML_CHAR_ENCODING_NONE);
758 GlobalUnlock(hglobal);
759
760 if (!xmldoc)
761 {
762 ERR("Failed to parse xml\n");
763 return E_FAIL;
764 }
765
766 xmldoc->_private = create_priv();
767
768 return attach_xmldoc(This, xmldoc);
769 }
770
771 static HRESULT WINAPI PersistStreamInit_Save(
772 IPersistStreamInit *iface, IStream *stream, BOOL clr_dirty)
773 {
774 domdoc *This = impl_from_IPersistStreamInit(iface);
775 BSTR xmlString;
776 HRESULT hr;
777
778 TRACE("(%p)->(%p %d)\n", This, stream, clr_dirty);
779
780 hr = IXMLDOMDocument3_get_xml(&This->IXMLDOMDocument3_iface, &xmlString);
781 if(hr == S_OK)
782 {
783 DWORD len = SysStringLen(xmlString) * sizeof(WCHAR);
784
785 hr = IStream_Write( stream, xmlString, len, NULL );
786 SysFreeString(xmlString);
787 }
788
789 TRACE("ret 0x%08x\n", hr);
790
791 return hr;
792 }
793
794 static HRESULT WINAPI PersistStreamInit_GetSizeMax(
795 IPersistStreamInit *iface, ULARGE_INTEGER *pcbSize)
796 {
797 domdoc *This = impl_from_IPersistStreamInit(iface);
798 TRACE("(%p)->(%p): stub!\n", This, pcbSize);
799 return E_NOTIMPL;
800 }
801
802 static HRESULT WINAPI PersistStreamInit_InitNew(
803 IPersistStreamInit *iface)
804 {
805 domdoc *This = impl_from_IPersistStreamInit(iface);
806 TRACE("(%p)\n", This);
807 return S_OK;
808 }
809
810 static const IPersistStreamInitVtbl xmldoc_IPersistStreamInit_VTable =
811 {
812 PersistStreamInit_QueryInterface,
813 PersistStreamInit_AddRef,
814 PersistStreamInit_Release,
815 PersistStreamInit_GetClassID,
816 PersistStreamInit_IsDirty,
817 PersistStreamInit_Load,
818 PersistStreamInit_Save,
819 PersistStreamInit_GetSizeMax,
820 PersistStreamInit_InitNew
821 };
822
823 /* IXMLDOMDocument3 interface */
824
825 static const tid_t domdoc_se_tids[] = {
826 IXMLDOMNode_tid,
827 IXMLDOMDocument_tid,
828 IXMLDOMDocument2_tid,
829 IXMLDOMDocument3_tid,
830 0
831 };
832
833 static HRESULT WINAPI domdoc_QueryInterface( IXMLDOMDocument3 *iface, REFIID riid, void** ppvObject )
834 {
835 domdoc *This = impl_from_IXMLDOMDocument3( iface );
836
837 TRACE("(%p)->(%s %p)\n", This, debugstr_guid( riid ), ppvObject );
838
839 *ppvObject = NULL;
840
841 if ( IsEqualGUID( riid, &IID_IUnknown ) ||
842 IsEqualGUID( riid, &IID_IDispatch ) ||
843 IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
844 IsEqualGUID( riid, &IID_IXMLDOMDocument ) ||
845 IsEqualGUID( riid, &IID_IXMLDOMDocument2 )||
846 IsEqualGUID( riid, &IID_IXMLDOMDocument3 ))
847 {
848 *ppvObject = iface;
849 }
850 else if (IsEqualGUID(&IID_IPersistStream, riid) ||
851 IsEqualGUID(&IID_IPersistStreamInit, riid))
852 {
853 *ppvObject = &This->IPersistStreamInit_iface;
854 }
855 else if (IsEqualGUID(&IID_IObjectWithSite, riid))
856 {
857 *ppvObject = &This->IObjectWithSite_iface;
858 }
859 else if (IsEqualGUID(&IID_IObjectSafety, riid))
860 {
861 *ppvObject = &This->IObjectSafety_iface;
862 }
863 else if( IsEqualGUID( riid, &IID_ISupportErrorInfo ))
864 {
865 return node_create_supporterrorinfo(domdoc_se_tids, ppvObject);
866 }
867 else if(node_query_interface(&This->node, riid, ppvObject))
868 {
869 return *ppvObject ? S_OK : E_NOINTERFACE;
870 }
871 else if (IsEqualGUID( riid, &IID_IConnectionPointContainer ))
872 {
873 *ppvObject = &This->IConnectionPointContainer_iface;
874 }
875 else
876 {
877 TRACE("interface %s not implemented\n", debugstr_guid(riid));
878 return E_NOINTERFACE;
879 }
880
881 IUnknown_AddRef((IUnknown*)*ppvObject);
882
883 return S_OK;
884 }
885
886 static ULONG WINAPI domdoc_AddRef( IXMLDOMDocument3 *iface )
887 {
888 domdoc *This = impl_from_IXMLDOMDocument3( iface );
889 ULONG ref = InterlockedIncrement( &This->ref );
890 TRACE("(%p)->(%d)\n", This, ref );
891 return ref;
892 }
893
894 static ULONG WINAPI domdoc_Release( IXMLDOMDocument3 *iface )
895 {
896 domdoc *This = impl_from_IXMLDOMDocument3( iface );
897 LONG ref = InterlockedDecrement( &This->ref );
898
899 TRACE("(%p)->(%d)\n", This, ref );
900
901 if ( ref == 0 )
902 {
903 int eid;
904
905 if(This->bsc)
906 detach_bsc(This->bsc);
907
908 if (This->site)
909 IUnknown_Release( This->site );
910 destroy_xmlnode(&This->node);
911 if (This->stream)
912 IStream_Release(This->stream);
913
914 for (eid = 0; eid < EVENTID_LAST; eid++)
915 if (This->events[eid]) IDispatch_Release(This->events[eid]);
916
917 release_namespaces(This);
918 heap_free(This);
919 }
920
921 return ref;
922 }
923
924 static HRESULT WINAPI domdoc_GetTypeInfoCount( IXMLDOMDocument3 *iface, UINT* pctinfo )
925 {
926 domdoc *This = impl_from_IXMLDOMDocument3( iface );
927 return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
928 }
929
930 static HRESULT WINAPI domdoc_GetTypeInfo(
931 IXMLDOMDocument3 *iface,
932 UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
933 {
934 domdoc *This = impl_from_IXMLDOMDocument3( iface );
935 return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
936 }
937
938 static HRESULT WINAPI domdoc_GetIDsOfNames(
939 IXMLDOMDocument3 *iface,
940 REFIID riid,
941 LPOLESTR* rgszNames,
942 UINT cNames,
943 LCID lcid,
944 DISPID* rgDispId)
945 {
946 domdoc *This = impl_from_IXMLDOMDocument3( iface );
947 return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface,
948 riid, rgszNames, cNames, lcid, rgDispId);
949 }
950
951 static HRESULT WINAPI domdoc_Invoke(
952 IXMLDOMDocument3 *iface,
953 DISPID dispIdMember,
954 REFIID riid,
955 LCID lcid,
956 WORD wFlags,
957 DISPPARAMS* pDispParams,
958 VARIANT* pVarResult,
959 EXCEPINFO* pExcepInfo,
960 UINT* puArgErr)
961 {
962 domdoc *This = impl_from_IXMLDOMDocument3( iface );
963 return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface,
964 dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
965 }
966
967 static HRESULT WINAPI domdoc_get_nodeName(
968 IXMLDOMDocument3 *iface,
969 BSTR* name )
970 {
971 domdoc *This = impl_from_IXMLDOMDocument3( iface );
972
973 static const WCHAR documentW[] = {'#','d','o','c','u','m','e','n','t',0};
974
975 TRACE("(%p)->(%p)\n", This, name);
976
977 return return_bstr(documentW, name);
978 }
979
980
981 static HRESULT WINAPI domdoc_get_nodeValue(
982 IXMLDOMDocument3 *iface,
983 VARIANT* value )
984 {
985 domdoc *This = impl_from_IXMLDOMDocument3( iface );
986
987 TRACE("(%p)->(%p)\n", This, value);
988
989 if(!value)
990 return E_INVALIDARG;
991
992 V_VT(value) = VT_NULL;
993 V_BSTR(value) = NULL; /* tests show that we should do this */
994 return S_FALSE;
995 }
996
997
998 static HRESULT WINAPI domdoc_put_nodeValue(
999 IXMLDOMDocument3 *iface,
1000 VARIANT value)
1001 {
1002 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1003 TRACE("(%p)->(%s)\n", This, debugstr_variant(&value));
1004 return E_FAIL;
1005 }
1006
1007
1008 static HRESULT WINAPI domdoc_get_nodeType(
1009 IXMLDOMDocument3 *iface,
1010 DOMNodeType* type )
1011 {
1012 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1013
1014 TRACE("(%p)->(%p)\n", This, type);
1015
1016 *type = NODE_DOCUMENT;
1017 return S_OK;
1018 }
1019
1020
1021 static HRESULT WINAPI domdoc_get_parentNode(
1022 IXMLDOMDocument3 *iface,
1023 IXMLDOMNode** parent )
1024 {
1025 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1026
1027 TRACE("(%p)->(%p)\n", This, parent);
1028
1029 return node_get_parent(&This->node, parent);
1030 }
1031
1032
1033 static HRESULT WINAPI domdoc_get_childNodes(
1034 IXMLDOMDocument3 *iface,
1035 IXMLDOMNodeList** childList )
1036 {
1037 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1038
1039 TRACE("(%p)->(%p)\n", This, childList);
1040
1041 return node_get_child_nodes(&This->node, childList);
1042 }
1043
1044
1045 static HRESULT WINAPI domdoc_get_firstChild(
1046 IXMLDOMDocument3 *iface,
1047 IXMLDOMNode** firstChild )
1048 {
1049 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1050
1051 TRACE("(%p)->(%p)\n", This, firstChild);
1052
1053 return node_get_first_child(&This->node, firstChild);
1054 }
1055
1056
1057 static HRESULT WINAPI domdoc_get_lastChild(
1058 IXMLDOMDocument3 *iface,
1059 IXMLDOMNode** lastChild )
1060 {
1061 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1062
1063 TRACE("(%p)->(%p)\n", This, lastChild);
1064
1065 return node_get_last_child(&This->node, lastChild);
1066 }
1067
1068
1069 static HRESULT WINAPI domdoc_get_previousSibling(
1070 IXMLDOMDocument3 *iface,
1071 IXMLDOMNode** previousSibling )
1072 {
1073 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1074
1075 TRACE("(%p)->(%p)\n", This, previousSibling);
1076
1077 return return_null_node(previousSibling);
1078 }
1079
1080
1081 static HRESULT WINAPI domdoc_get_nextSibling(
1082 IXMLDOMDocument3 *iface,
1083 IXMLDOMNode** nextSibling )
1084 {
1085 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1086
1087 TRACE("(%p)->(%p)\n", This, nextSibling);
1088
1089 return return_null_node(nextSibling);
1090 }
1091
1092
1093 static HRESULT WINAPI domdoc_get_attributes(
1094 IXMLDOMDocument3 *iface,
1095 IXMLDOMNamedNodeMap** attributeMap )
1096 {
1097 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1098
1099 TRACE("(%p)->(%p)\n", This, attributeMap);
1100
1101 return return_null_ptr((void**)attributeMap);
1102 }
1103
1104
1105 static HRESULT WINAPI domdoc_insertBefore(
1106 IXMLDOMDocument3 *iface,
1107 IXMLDOMNode* newChild,
1108 VARIANT refChild,
1109 IXMLDOMNode** outNewChild )
1110 {
1111 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1112
1113 TRACE("(%p)->(%p %s %p)\n", This, newChild, debugstr_variant(&refChild), outNewChild);
1114
1115 return node_insert_before(&This->node, newChild, &refChild, outNewChild);
1116 }
1117
1118
1119 static HRESULT WINAPI domdoc_replaceChild(
1120 IXMLDOMDocument3 *iface,
1121 IXMLDOMNode* newChild,
1122 IXMLDOMNode* oldChild,
1123 IXMLDOMNode** outOldChild)
1124 {
1125 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1126
1127 TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, outOldChild);
1128
1129 return node_replace_child(&This->node, newChild, oldChild, outOldChild);
1130 }
1131
1132
1133 static HRESULT WINAPI domdoc_removeChild(
1134 IXMLDOMDocument3 *iface,
1135 IXMLDOMNode *child,
1136 IXMLDOMNode **oldChild)
1137 {
1138 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1139 TRACE("(%p)->(%p %p)\n", This, child, oldChild);
1140 return node_remove_child(&This->node, child, oldChild);
1141 }
1142
1143
1144 static HRESULT WINAPI domdoc_appendChild(
1145 IXMLDOMDocument3 *iface,
1146 IXMLDOMNode *child,
1147 IXMLDOMNode **outChild)
1148 {
1149 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1150 TRACE("(%p)->(%p %p)\n", This, child, outChild);
1151 return node_append_child(&This->node, child, outChild);
1152 }
1153
1154
1155 static HRESULT WINAPI domdoc_hasChildNodes(
1156 IXMLDOMDocument3 *iface,
1157 VARIANT_BOOL *ret)
1158 {
1159 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1160 TRACE("(%p)->(%p)\n", This, ret);
1161 return node_has_childnodes(&This->node, ret);
1162 }
1163
1164
1165 static HRESULT WINAPI domdoc_get_ownerDocument(
1166 IXMLDOMDocument3 *iface,
1167 IXMLDOMDocument **doc)
1168 {
1169 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1170 TRACE("(%p)->(%p)\n", This, doc);
1171 return node_get_owner_doc(&This->node, doc);
1172 }
1173
1174
1175 static HRESULT WINAPI domdoc_cloneNode(
1176 IXMLDOMDocument3 *iface,
1177 VARIANT_BOOL deep,
1178 IXMLDOMNode** outNode)
1179 {
1180 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1181 TRACE("(%p)->(%d %p)\n", This, deep, outNode);
1182 return node_clone( &This->node, deep, outNode );
1183 }
1184
1185
1186 static HRESULT WINAPI domdoc_get_nodeTypeString(
1187 IXMLDOMDocument3 *iface,
1188 BSTR *p)
1189 {
1190 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1191 static const WCHAR documentW[] = {'d','o','c','u','m','e','n','t',0};
1192
1193 TRACE("(%p)->(%p)\n", This, p);
1194
1195 return return_bstr(documentW, p);
1196 }
1197
1198
1199 static HRESULT WINAPI domdoc_get_text(
1200 IXMLDOMDocument3 *iface,
1201 BSTR *p)
1202 {
1203 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1204 TRACE("(%p)->(%p)\n", This, p);
1205 return node_get_text(&This->node, p);
1206 }
1207
1208
1209 static HRESULT WINAPI domdoc_put_text(
1210 IXMLDOMDocument3 *iface,
1211 BSTR text )
1212 {
1213 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1214 TRACE("(%p)->(%s)\n", This, debugstr_w(text));
1215 return E_FAIL;
1216 }
1217
1218
1219 static HRESULT WINAPI domdoc_get_specified(
1220 IXMLDOMDocument3 *iface,
1221 VARIANT_BOOL* isSpecified )
1222 {
1223 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1224 FIXME("(%p)->(%p) stub!\n", This, isSpecified);
1225 *isSpecified = VARIANT_TRUE;
1226 return S_OK;
1227 }
1228
1229
1230 static HRESULT WINAPI domdoc_get_definition(
1231 IXMLDOMDocument3 *iface,
1232 IXMLDOMNode** definitionNode )
1233 {
1234 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1235 FIXME("(%p)->(%p)\n", This, definitionNode);
1236 return E_NOTIMPL;
1237 }
1238
1239
1240 static HRESULT WINAPI domdoc_get_nodeTypedValue(
1241 IXMLDOMDocument3 *iface,
1242 VARIANT* v )
1243 {
1244 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1245 TRACE("(%p)->(%p)\n", This, v);
1246 return return_null_var(v);
1247 }
1248
1249 static HRESULT WINAPI domdoc_put_nodeTypedValue(
1250 IXMLDOMDocument3 *iface,
1251 VARIANT typedValue )
1252 {
1253 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1254 FIXME("(%p)->(%s)\n", This, debugstr_variant(&typedValue));
1255 return E_NOTIMPL;
1256 }
1257
1258
1259 static HRESULT WINAPI domdoc_get_dataType(
1260 IXMLDOMDocument3 *iface,
1261 VARIANT* typename )
1262 {
1263 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1264 TRACE("(%p)->(%p)\n", This, typename);
1265 return return_null_var( typename );
1266 }
1267
1268
1269 static HRESULT WINAPI domdoc_put_dataType(
1270 IXMLDOMDocument3 *iface,
1271 BSTR dataTypeName )
1272 {
1273 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1274
1275 FIXME("(%p)->(%s)\n", This, debugstr_w(dataTypeName));
1276
1277 if(!dataTypeName)
1278 return E_INVALIDARG;
1279
1280 return E_FAIL;
1281 }
1282
1283 static int XMLCALL domdoc_get_xml_writecallback(void *ctx, const char *data, int len)
1284 {
1285 return xmlBufferAdd((xmlBufferPtr)ctx, (xmlChar*)data, len) == 0 ? len : 0;
1286 }
1287
1288 static HRESULT WINAPI domdoc_get_xml(
1289 IXMLDOMDocument3 *iface,
1290 BSTR* p)
1291 {
1292 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1293 xmlSaveCtxtPtr ctxt;
1294 xmlBufferPtr buf;
1295 int options;
1296 long ret;
1297
1298 TRACE("(%p)->(%p)\n", This, p);
1299
1300 if(!p)
1301 return E_INVALIDARG;
1302
1303 *p = NULL;
1304
1305 buf = xmlBufferCreate();
1306 if(!buf)
1307 return E_OUTOFMEMORY;
1308
1309 options = XML_SAVE_FORMAT | XML_SAVE_NO_DECL;
1310 ctxt = xmlSaveToIO(domdoc_get_xml_writecallback, NULL, buf, "UTF-8", options);
1311
1312 if(!ctxt)
1313 {
1314 xmlBufferFree(buf);
1315 return E_OUTOFMEMORY;
1316 }
1317
1318 ret = xmlSaveDoc(ctxt, get_doc(This));
1319 /* flushes on close */
1320 xmlSaveClose(ctxt);
1321
1322 TRACE("%ld, len=%d\n", ret, xmlBufferLength(buf));
1323 if(ret != -1 && xmlBufferLength(buf) > 0)
1324 {
1325 BSTR content;
1326
1327 content = bstr_from_xmlChar(xmlBufferContent(buf));
1328 content = EnsureCorrectEOL(content);
1329
1330 *p = content;
1331 }
1332 else
1333 {
1334 *p = SysAllocStringLen(NULL, 0);
1335 }
1336
1337 xmlBufferFree(buf);
1338
1339 return *p ? S_OK : E_OUTOFMEMORY;
1340 }
1341
1342
1343 static HRESULT WINAPI domdoc_transformNode(
1344 IXMLDOMDocument3 *iface,
1345 IXMLDOMNode *node,
1346 BSTR *p)
1347 {
1348 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1349 TRACE("(%p)->(%p %p)\n", This, node, p);
1350 return node_transform_node(&This->node, node, p);
1351 }
1352
1353
1354 static HRESULT WINAPI domdoc_selectNodes(
1355 IXMLDOMDocument3 *iface,
1356 BSTR p,
1357 IXMLDOMNodeList **outList)
1358 {
1359 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1360 TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList);
1361 return node_select_nodes(&This->node, p, outList);
1362 }
1363
1364
1365 static HRESULT WINAPI domdoc_selectSingleNode(
1366 IXMLDOMDocument3 *iface,
1367 BSTR p,
1368 IXMLDOMNode **outNode)
1369 {
1370 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1371 TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode);
1372 return node_select_singlenode(&This->node, p, outNode);
1373 }
1374
1375
1376 static HRESULT WINAPI domdoc_get_parsed(
1377 IXMLDOMDocument3 *iface,
1378 VARIANT_BOOL* isParsed )
1379 {
1380 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1381 FIXME("(%p)->(%p) stub!\n", This, isParsed);
1382 *isParsed = VARIANT_TRUE;
1383 return S_OK;
1384 }
1385
1386 static HRESULT WINAPI domdoc_get_namespaceURI(
1387 IXMLDOMDocument3 *iface,
1388 BSTR* namespaceURI )
1389 {
1390 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1391 TRACE("(%p)->(%p)\n", This, namespaceURI);
1392 return return_null_bstr( namespaceURI );
1393 }
1394
1395 static HRESULT WINAPI domdoc_get_prefix(
1396 IXMLDOMDocument3 *iface,
1397 BSTR* prefix )
1398 {
1399 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1400 TRACE("(%p)->(%p)\n", This, prefix);
1401 return return_null_bstr( prefix );
1402 }
1403
1404
1405 static HRESULT WINAPI domdoc_get_baseName(
1406 IXMLDOMDocument3 *iface,
1407 BSTR* name )
1408 {
1409 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1410 TRACE("(%p)->(%p)\n", This, name);
1411 return return_null_bstr( name );
1412 }
1413
1414
1415 static HRESULT WINAPI domdoc_transformNodeToObject(
1416 IXMLDOMDocument3 *iface,
1417 IXMLDOMNode* stylesheet,
1418 VARIANT outputObject)
1419 {
1420 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1421 FIXME("(%p)->(%p %s)\n", This, stylesheet, debugstr_variant(&outputObject));
1422 return E_NOTIMPL;
1423 }
1424
1425
1426 static HRESULT WINAPI domdoc_get_doctype(
1427 IXMLDOMDocument3 *iface,
1428 IXMLDOMDocumentType** doctype )
1429 {
1430 domdoc *This = impl_from_IXMLDOMDocument3(iface);
1431 IXMLDOMNode *node;
1432 xmlDtdPtr dtd;
1433 HRESULT hr;
1434
1435 TRACE("(%p)->(%p)\n", This, doctype);
1436
1437 if (!doctype) return E_INVALIDARG;
1438
1439 *doctype = NULL;
1440
1441 dtd = xmlGetIntSubset(get_doc(This));
1442 if (!dtd) return S_FALSE;
1443
1444 node = create_node((xmlNodePtr)dtd);
1445 if (!node) return S_FALSE;
1446
1447 hr = IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMDocumentType, (void**)doctype);
1448 IXMLDOMNode_Release(node);
1449
1450 return hr;
1451 }
1452
1453
1454 static HRESULT WINAPI domdoc_get_implementation(
1455 IXMLDOMDocument3 *iface,
1456 IXMLDOMImplementation** impl )
1457 {
1458 domdoc *This = impl_from_IXMLDOMDocument3(iface);
1459
1460 TRACE("(%p)->(%p)\n", This, impl);
1461
1462 if(!impl)
1463 return E_INVALIDARG;
1464
1465 *impl = (IXMLDOMImplementation*)create_doc_Implementation();
1466
1467 return S_OK;
1468 }
1469
1470 static HRESULT WINAPI domdoc_get_documentElement(
1471 IXMLDOMDocument3 *iface,
1472 IXMLDOMElement** DOMElement )
1473 {
1474 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1475 IXMLDOMNode *element_node;
1476 xmlNodePtr root;
1477 HRESULT hr;
1478
1479 TRACE("(%p)->(%p)\n", This, DOMElement);
1480
1481 if(!DOMElement)
1482 return E_INVALIDARG;
1483
1484 *DOMElement = NULL;
1485
1486 root = xmlDocGetRootElement( get_doc(This) );
1487 if ( !root )
1488 return S_FALSE;
1489
1490 element_node = create_node( root );
1491 if(!element_node) return S_FALSE;
1492
1493 hr = IXMLDOMNode_QueryInterface(element_node, &IID_IXMLDOMElement, (void**)DOMElement);
1494 IXMLDOMNode_Release(element_node);
1495
1496 return hr;
1497 }
1498
1499
1500 static HRESULT WINAPI domdoc_put_documentElement(
1501 IXMLDOMDocument3 *iface,
1502 IXMLDOMElement* DOMElement )
1503 {
1504 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1505 IXMLDOMNode *elementNode;
1506 xmlNodePtr oldRoot;
1507 xmlnode *xmlNode;
1508 HRESULT hr;
1509
1510 TRACE("(%p)->(%p)\n", This, DOMElement);
1511
1512 hr = IXMLDOMElement_QueryInterface( DOMElement, &IID_IXMLDOMNode, (void**)&elementNode );
1513 if(FAILED(hr))
1514 return hr;
1515
1516 xmlNode = get_node_obj( elementNode );
1517 if(!xmlNode) return E_FAIL;
1518
1519 if(!xmlNode->node->parent)
1520 if(xmldoc_remove_orphan(xmlNode->node->doc, xmlNode->node) != S_OK)
1521 WARN("%p is not an orphan of %p\n", xmlNode->node->doc, xmlNode->node);
1522
1523 oldRoot = xmlDocSetRootElement( get_doc(This), xmlNode->node);
1524 IXMLDOMNode_Release( elementNode );
1525
1526 if(oldRoot)
1527 xmldoc_add_orphan(oldRoot->doc, oldRoot);
1528
1529 return S_OK;
1530 }
1531
1532
1533 static HRESULT WINAPI domdoc_createElement(
1534 IXMLDOMDocument3 *iface,
1535 BSTR tagname,
1536 IXMLDOMElement** element )
1537 {
1538 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1539 IXMLDOMNode *node;
1540 VARIANT type;
1541 HRESULT hr;
1542
1543 TRACE("(%p)->(%s %p)\n", This, debugstr_w(tagname), element);
1544
1545 if (!element || !tagname) return E_INVALIDARG;
1546
1547 V_VT(&type) = VT_I1;
1548 V_I1(&type) = NODE_ELEMENT;
1549
1550 hr = IXMLDOMDocument3_createNode(iface, type, tagname, NULL, &node);
1551 if (hr == S_OK)
1552 {
1553 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMElement, (void**)element);
1554 IXMLDOMNode_Release(node);
1555 }
1556
1557 return hr;
1558 }
1559
1560
1561 static HRESULT WINAPI domdoc_createDocumentFragment(
1562 IXMLDOMDocument3 *iface,
1563 IXMLDOMDocumentFragment** frag )
1564 {
1565 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1566 IXMLDOMNode *node;
1567 VARIANT type;
1568 HRESULT hr;
1569
1570 TRACE("(%p)->(%p)\n", This, frag);
1571
1572 if (!frag) return E_INVALIDARG;
1573
1574 *frag = NULL;
1575
1576 V_VT(&type) = VT_I1;
1577 V_I1(&type) = NODE_DOCUMENT_FRAGMENT;
1578
1579 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1580 if (hr == S_OK)
1581 {
1582 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMDocumentFragment, (void**)frag);
1583 IXMLDOMNode_Release(node);
1584 }
1585
1586 return hr;
1587 }
1588
1589
1590 static HRESULT WINAPI domdoc_createTextNode(
1591 IXMLDOMDocument3 *iface,
1592 BSTR data,
1593 IXMLDOMText** text )
1594 {
1595 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1596 IXMLDOMNode *node;
1597 VARIANT type;
1598 HRESULT hr;
1599
1600 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), text);
1601
1602 if (!text) return E_INVALIDARG;
1603
1604 *text = NULL;
1605
1606 V_VT(&type) = VT_I1;
1607 V_I1(&type) = NODE_TEXT;
1608
1609 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1610 if (hr == S_OK)
1611 {
1612 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMText, (void**)text);
1613 IXMLDOMNode_Release(node);
1614 hr = IXMLDOMText_put_data(*text, data);
1615 }
1616
1617 return hr;
1618 }
1619
1620
1621 static HRESULT WINAPI domdoc_createComment(
1622 IXMLDOMDocument3 *iface,
1623 BSTR data,
1624 IXMLDOMComment** comment )
1625 {
1626 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1627 VARIANT type;
1628 HRESULT hr;
1629 IXMLDOMNode *node;
1630
1631 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), comment);
1632
1633 if (!comment) return E_INVALIDARG;
1634
1635 *comment = NULL;
1636
1637 V_VT(&type) = VT_I1;
1638 V_I1(&type) = NODE_COMMENT;
1639
1640 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1641 if (hr == S_OK)
1642 {
1643 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMComment, (void**)comment);
1644 IXMLDOMNode_Release(node);
1645 hr = IXMLDOMComment_put_data(*comment, data);
1646 }
1647
1648 return hr;
1649 }
1650
1651
1652 static HRESULT WINAPI domdoc_createCDATASection(
1653 IXMLDOMDocument3 *iface,
1654 BSTR data,
1655 IXMLDOMCDATASection** cdata )
1656 {
1657 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1658 IXMLDOMNode *node;
1659 VARIANT type;
1660 HRESULT hr;
1661
1662 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), cdata);
1663
1664 if (!cdata) return E_INVALIDARG;
1665
1666 *cdata = NULL;
1667
1668 V_VT(&type) = VT_I1;
1669 V_I1(&type) = NODE_CDATA_SECTION;
1670
1671 hr = IXMLDOMDocument3_createNode(iface, type, NULL, NULL, &node);
1672 if (hr == S_OK)
1673 {
1674 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMCDATASection, (void**)cdata);
1675 IXMLDOMNode_Release(node);
1676 hr = IXMLDOMCDATASection_put_data(*cdata, data);
1677 }
1678
1679 return hr;
1680 }
1681
1682
1683 static HRESULT WINAPI domdoc_createProcessingInstruction(
1684 IXMLDOMDocument3 *iface,
1685 BSTR target,
1686 BSTR data,
1687 IXMLDOMProcessingInstruction** pi )
1688 {
1689 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1690 IXMLDOMNode *node;
1691 VARIANT type;
1692 HRESULT hr;
1693
1694 TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(target), debugstr_w(data), pi);
1695
1696 if (!pi) return E_INVALIDARG;
1697
1698 *pi = NULL;
1699
1700 V_VT(&type) = VT_I1;
1701 V_I1(&type) = NODE_PROCESSING_INSTRUCTION;
1702
1703 hr = IXMLDOMDocument3_createNode(iface, type, target, NULL, &node);
1704 if (hr == S_OK)
1705 {
1706 xmlnode *node_obj;
1707
1708 /* this is to bypass check in ::put_data() that blocks "<?xml" PIs */
1709 node_obj = get_node_obj(node);
1710 hr = node_set_content(node_obj, data);
1711
1712 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMProcessingInstruction, (void**)pi);
1713 IXMLDOMNode_Release(node);
1714 }
1715
1716 return hr;
1717 }
1718
1719
1720 static HRESULT WINAPI domdoc_createAttribute(
1721 IXMLDOMDocument3 *iface,
1722 BSTR name,
1723 IXMLDOMAttribute** attribute )
1724 {
1725 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1726 IXMLDOMNode *node;
1727 VARIANT type;
1728 HRESULT hr;
1729
1730 TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), attribute);
1731
1732 if (!attribute || !name) return E_INVALIDARG;
1733
1734 V_VT(&type) = VT_I1;
1735 V_I1(&type) = NODE_ATTRIBUTE;
1736
1737 hr = IXMLDOMDocument3_createNode(iface, type, name, NULL, &node);
1738 if (hr == S_OK)
1739 {
1740 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMAttribute, (void**)attribute);
1741 IXMLDOMNode_Release(node);
1742 }
1743
1744 return hr;
1745 }
1746
1747
1748 static HRESULT WINAPI domdoc_createEntityReference(
1749 IXMLDOMDocument3 *iface,
1750 BSTR name,
1751 IXMLDOMEntityReference** entityref )
1752 {
1753 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1754 IXMLDOMNode *node;
1755 VARIANT type;
1756 HRESULT hr;
1757
1758 TRACE("(%p)->(%s %p)\n", This, debugstr_w(name), entityref);
1759
1760 if (!entityref) return E_INVALIDARG;
1761
1762 *entityref = NULL;
1763
1764 V_VT(&type) = VT_I1;
1765 V_I1(&type) = NODE_ENTITY_REFERENCE;
1766
1767 hr = IXMLDOMDocument3_createNode(iface, type, name, NULL, &node);
1768 if (hr == S_OK)
1769 {
1770 IXMLDOMNode_QueryInterface(node, &IID_IXMLDOMEntityReference, (void**)entityref);
1771 IXMLDOMNode_Release(node);
1772 }
1773
1774 return hr;
1775 }
1776
1777 xmlChar* tagName_to_XPath(const BSTR tagName)
1778 {
1779 xmlChar *query, *tmp;
1780 static const xmlChar mod_pre[] = "*[local-name()='";
1781 static const xmlChar mod_post[] = "']";
1782 static const xmlChar prefix[] = "descendant::";
1783 const WCHAR *tokBegin, *tokEnd;
1784 int len;
1785
1786 query = xmlStrdup(prefix);
1787
1788 tokBegin = tagName;
1789 while (tokBegin && *tokBegin)
1790 {
1791 switch (*tokBegin)
1792 {
1793 case '/':
1794 query = xmlStrcat(query, BAD_CAST "/");
1795 ++tokBegin;
1796 break;
1797 case '*':
1798 query = xmlStrcat(query, BAD_CAST "*");
1799 ++tokBegin;
1800 break;
1801 default:
1802 query = xmlStrcat(query, mod_pre);
1803 tokEnd = tokBegin;
1804 while (*tokEnd && *tokEnd != '/')
1805 ++tokEnd;
1806 len = WideCharToMultiByte(CP_UTF8, 0, tokBegin, tokEnd-tokBegin, NULL, 0, NULL, NULL);
1807 tmp = xmlMalloc(len);
1808 WideCharToMultiByte(CP_UTF8, 0, tokBegin, tokEnd-tokBegin, (char*)tmp, len, NULL, NULL);
1809 query = xmlStrncat(query, tmp, len);
1810 xmlFree(tmp);
1811 tokBegin = tokEnd;
1812 query = xmlStrcat(query, mod_post);
1813 }
1814 }
1815
1816 return query;
1817 }
1818
1819 static HRESULT WINAPI domdoc_getElementsByTagName(
1820 IXMLDOMDocument3 *iface,
1821 BSTR tagName,
1822 IXMLDOMNodeList** resultList )
1823 {
1824 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1825 xmlChar *query;
1826 HRESULT hr;
1827 BOOL XPath;
1828
1829 TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
1830
1831 if (!tagName || !resultList) return E_INVALIDARG;
1832
1833 XPath = This->properties->XPath;
1834 This->properties->XPath = TRUE;
1835 query = tagName_to_XPath(tagName);
1836 hr = create_selection((xmlNodePtr)get_doc(This), query, resultList);
1837 xmlFree(query);
1838 This->properties->XPath = XPath;
1839
1840 return hr;
1841 }
1842
1843 static HRESULT get_node_type(VARIANT Type, DOMNodeType * type)
1844 {
1845 VARIANT tmp;
1846 HRESULT hr;
1847
1848 VariantInit(&tmp);
1849 hr = VariantChangeType(&tmp, &Type, 0, VT_I4);
1850 if(FAILED(hr))
1851 return E_INVALIDARG;
1852
1853 *type = V_I4(&tmp);
1854
1855 return S_OK;
1856 }
1857
1858 static HRESULT WINAPI domdoc_createNode(
1859 IXMLDOMDocument3 *iface,
1860 VARIANT Type,
1861 BSTR name,
1862 BSTR namespaceURI,
1863 IXMLDOMNode** node )
1864 {
1865 domdoc *This = impl_from_IXMLDOMDocument3( iface );
1866 DOMNodeType node_type;
1867 xmlNodePtr xmlnode;
1868 xmlChar *xml_name, *href;
1869 HRESULT hr;
1870
1871 TRACE("(%p)->(%s %s %s %p)\n", This, debugstr_variant(&Type), debugstr_w(name), debugstr_w(namespaceURI), node);
1872
1873 if(!node) return E_INVALIDARG;
1874
1875 hr = get_node_type(Type, &node_type);
1876 if(FAILED(hr)) return hr;
1877
1878 if(namespaceURI && namespaceURI[0] && node_type != NODE_ELEMENT)
1879 FIXME("nodes with namespaces currently not supported.\n");
1880
1881 TRACE("node_type %d\n", node_type);
1882
1883 /* exit earlier for types that need name */
1884 switch(node_type)
1885 {
1886 case NODE_ELEMENT:
1887 case NODE_ATTRIBUTE:
1888 case NODE_ENTITY_REFERENCE:
1889 case NODE_PROCESSING_INSTRUCTION:
1890 if (!name || *name == 0) return E_FAIL;
1891 break;
1892 default:
1893 break;
1894 }
1895
1896 xml_name = xmlchar_from_wchar(name);
1897 /* prevent empty href to be allocated */
1898 href = namespaceURI ? xmlchar_from_wchar(namespaceURI) : NULL;
1899
1900 switch(node_type)
1901 {
1902 case NODE_ELEMENT:
1903 {
1904 xmlChar *local, *prefix;
1905
1906 local = xmlSplitQName2(xml_name, &prefix);
1907
1908 xmlnode = xmlNewDocNode(get_doc(This), NULL, local ? local : xml_name, NULL);
1909
1910 /* allow to create default namespace xmlns= */
1911 if (local || (href && *href))
1912 {
1913 xmlNsPtr ns = xmlNewNs(xmlnode, href, prefix);
1914 xmlSetNs(xmlnode, ns);
1915 }
1916
1917 xmlFree(local);
1918 xmlFree(prefix);
1919
1920 break;
1921 }
1922 case NODE_ATTRIBUTE:
1923 xmlnode = (xmlNodePtr)xmlNewDocProp(get_doc(This), xml_name, NULL);
1924 break;
1925 case NODE_TEXT:
1926 xmlnode = (xmlNodePtr)xmlNewDocText(get_doc(This), NULL);
1927 break;
1928 case NODE_CDATA_SECTION:
1929 xmlnode = xmlNewCDataBlock(get_doc(This), NULL, 0);
1930 break;
1931 case NODE_ENTITY_REFERENCE:
1932 xmlnode = xmlNewReference(get_doc(This), xml_name);
1933 break;
1934 case NODE_PROCESSING_INSTRUCTION:
1935 #ifdef HAVE_XMLNEWDOCPI
1936 xmlnode = xmlNewDocPI(get_doc(This), xml_name, NULL);
1937 #else
1938 FIXME("xmlNewDocPI() not supported, use libxml2 2.6.15 or greater\n");
1939 xmlnode = NULL;
1940 #endif
1941 break;
1942 case NODE_COMMENT:
1943 xmlnode = xmlNewDocComment(get_doc(This), NULL);
1944 break;
1945 case NODE_DOCUMENT_FRAGMENT:
1946 xmlnode = xmlNewDocFragment(get_doc(This));
1947 break;
1948 /* unsupported types */
1949 case NODE_DOCUMENT:
1950 case NODE_DOCUMENT_TYPE:
1951 case NODE_ENTITY:
1952 case NODE_NOTATION:
1953 heap_free(xml_name);
1954 return E_INVALIDARG;
1955 default:
1956 FIXME("unhandled node type %d\n", node_type);
1957 xmlnode = NULL;
1958 break;
1959 }
1960
1961 *node = create_node(xmlnode);
1962 heap_free(xml_name);
1963 heap_free(href);
1964
1965 if(*node)
1966 {
1967 TRACE("created node (%d, %p, %p)\n", node_type, *node, xmlnode);
1968 xmldoc_add_orphan(xmlnode->doc, xmlnode);
1969 return S_OK;
1970 }
1971
1972 return E_FAIL;
1973 }
1974
1975 static HRESULT WINAPI domdoc_nodeFromID(
1976 IXMLDOMDocument3 *iface,
1977 BSTR idString,
1978 IXMLDOMNode** node )
1979 {
1980 domdoc *This = impl_from_IXMLDOMDocument3(iface);
1981 FIXME("(%p)->(%s %p)\n", This, debugstr_w(idString), node);
1982 return E_NOTIMPL;
1983 }
1984
1985 static HRESULT domdoc_onDataAvailable(void *obj, char *ptr, DWORD len)
1986 {
1987 domdoc *This = obj;
1988 xmlDocPtr xmldoc;
1989
1990 xmldoc = doparse(This, ptr, len, XML_CHAR_ENCODING_NONE);
1991 if(xmldoc) {
1992 xmldoc->_private = create_priv();
1993 return attach_xmldoc(This, xmldoc);
1994 }
1995
1996 return S_OK;
1997 }
1998
1999 static HRESULT domdoc_load_moniker(domdoc *This, IMoniker *mon)
2000 {
2001 bsc_t *bsc;
2002 HRESULT hr;
2003
2004 hr = bind_url(mon, domdoc_onDataAvailable, This, &bsc);
2005 if(FAILED(hr))
2006 return hr;
2007
2008 if(This->bsc) {
2009 hr = detach_bsc(This->bsc);
2010 if(FAILED(hr))
2011 return hr;
2012 }
2013
2014 This->bsc = bsc;
2015 return S_OK;
2016 }
2017
2018 static HRESULT WINAPI domdoc_load(
2019 IXMLDOMDocument3 *iface,
2020 VARIANT source,
2021 VARIANT_BOOL* isSuccessful )
2022 {
2023 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2024 LPWSTR filename = NULL;
2025 HRESULT hr = S_FALSE;
2026 IXMLDOMDocument3 *pNewDoc = NULL;
2027 IStream *pStream = NULL;
2028 xmlDocPtr xmldoc;
2029
2030 TRACE("(%p)->(%s)\n", This, debugstr_variant(&source));
2031
2032 if (!isSuccessful)
2033 return E_POINTER;
2034 *isSuccessful = VARIANT_FALSE;
2035
2036 assert( &This->node );
2037
2038 switch( V_VT(&source) )
2039 {
2040 case VT_BSTR:
2041 filename = V_BSTR(&source);
2042 break;
2043 case VT_BSTR|VT_BYREF:
2044 if (!V_BSTRREF(&source)) return E_INVALIDARG;
2045 filename = *V_BSTRREF(&source);
2046 break;
2047 case VT_ARRAY|VT_UI1:
2048 {
2049 SAFEARRAY *psa = V_ARRAY(&source);
2050 char *str;
2051 LONG len;
2052 UINT dim = SafeArrayGetDim(psa);
2053
2054 switch (dim)
2055 {
2056 case 0:
2057 ERR("SAFEARRAY == NULL\n");
2058 hr = This->error = E_INVALIDARG;
2059 break;
2060 case 1:
2061 /* Only takes UTF-8 strings.
2062 * NOT NULL-terminated. */
2063 SafeArrayAccessData(psa, (void**)&str);
2064 SafeArrayGetUBound(psa, 1, &len);
2065
2066 if ((xmldoc = doparse(This, str, ++len, XML_CHAR_ENCODING_UTF8)))
2067 {
2068 hr = This->error = S_OK;
2069 *isSuccessful = VARIANT_TRUE;
2070 TRACE("parsed document %p\n", xmldoc);
2071 }
2072 else
2073 {
2074 This->error = E_FAIL;
2075 TRACE("failed to parse document\n");
2076 }
2077
2078 SafeArrayUnaccessData(psa);
2079
2080 if(xmldoc)
2081 {
2082 xmldoc->_private = create_priv();
2083 return attach_xmldoc(This, xmldoc);
2084 }
2085 break;
2086 default:
2087 FIXME("unhandled SAFEARRAY dim: %d\n", dim);
2088 hr = This->error = E_NOTIMPL;
2089 }
2090 }
2091 break;
2092 case VT_UNKNOWN:
2093 hr = IUnknown_QueryInterface(V_UNKNOWN(&source), &IID_IXMLDOMDocument3, (void**)&pNewDoc);
2094 if(hr == S_OK)
2095 {
2096 if(pNewDoc)
2097 {
2098 domdoc *newDoc = impl_from_IXMLDOMDocument3( pNewDoc );
2099
2100 xmldoc = xmlCopyDoc(get_doc(newDoc), 1);
2101 xmldoc->_private = create_priv();
2102 hr = attach_xmldoc(This, xmldoc);
2103
2104 if(SUCCEEDED(hr))
2105 *isSuccessful = VARIANT_TRUE;
2106
2107 return hr;
2108 }
2109 }
2110 hr = IUnknown_QueryInterface(V_UNKNOWN(&source), &IID_IStream, (void**)&pStream);
2111 if(hr == S_OK)
2112 {
2113 IPersistStream *pDocStream;
2114 hr = IUnknown_QueryInterface(iface, &IID_IPersistStream, (void**)&pDocStream);
2115 if(hr == S_OK)
2116 {
2117 hr = IPersistStream_Load(pDocStream, pStream);
2118 IStream_Release(pStream);
2119 if(hr == S_OK)
2120 {
2121 *isSuccessful = VARIANT_TRUE;
2122
2123 TRACE("Using IStream to load Document\n");
2124 return S_OK;
2125 }
2126 else
2127 {
2128 ERR("xmldoc_IPersistStream_Load failed (%d)\n", hr);
2129 }
2130 }
2131 else
2132 {
2133 ERR("QueryInterface IID_IPersistStream failed (%d)\n", hr);
2134 }
2135 }
2136 else
2137 {
2138 /* ISequentialStream */
2139 FIXME("Unknown type not supported (%d) (%p)(%p)\n", hr, pNewDoc, V_UNKNOWN(&source)->lpVtbl);
2140 }
2141 break;
2142 default:
2143 FIXME("VT type not supported (%d)\n", V_VT(&source));
2144 }
2145
2146 if ( filename )
2147 {
2148 IMoniker *mon;
2149
2150 hr = create_moniker_from_url( filename, &mon);
2151 if ( SUCCEEDED(hr) )
2152 {
2153 hr = domdoc_load_moniker( This, mon );
2154 IMoniker_Release(mon);
2155 }
2156
2157 if ( FAILED(hr) )
2158 This->error = E_FAIL;
2159 else
2160 {
2161 hr = This->error = S_OK;
2162 *isSuccessful = VARIANT_TRUE;
2163 }
2164 }
2165
2166 if(!filename || FAILED(hr)) {
2167 xmldoc = xmlNewDoc(NULL);
2168 xmldoc->_private = create_priv();
2169 hr = attach_xmldoc(This, xmldoc);
2170 if(SUCCEEDED(hr))
2171 hr = S_FALSE;
2172 }
2173
2174 TRACE("ret (%d)\n", hr);
2175
2176 return hr;
2177 }
2178
2179
2180 static HRESULT WINAPI domdoc_get_readyState(
2181 IXMLDOMDocument3 *iface,
2182 LONG *value )
2183 {
2184 domdoc *This = impl_from_IXMLDOMDocument3(iface);
2185 FIXME("stub! (%p)->(%p)\n", This, value);
2186
2187 if (!value)
2188 return E_INVALIDARG;
2189
2190 *value = READYSTATE_COMPLETE;
2191 return S_OK;
2192 }
2193
2194
2195 static HRESULT WINAPI domdoc_get_parseError(
2196 IXMLDOMDocument3 *iface,
2197 IXMLDOMParseError** errorObj )
2198 {
2199 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2200 static const WCHAR err[] = {'e','r','r','o','r',0};
2201 BSTR error_string = NULL;
2202
2203 FIXME("(%p)->(%p): creating a dummy parseError\n", iface, errorObj);
2204
2205 if(This->error)
2206 error_string = SysAllocString(err);
2207
2208 *errorObj = create_parseError(This->error, NULL, error_string, NULL, 0, 0, 0);
2209 if(!*errorObj) return E_OUTOFMEMORY;
2210 return S_OK;
2211 }
2212
2213
2214 static HRESULT WINAPI domdoc_get_url(
2215 IXMLDOMDocument3 *iface,
2216 BSTR* urlString )
2217 {
2218 domdoc *This = impl_from_IXMLDOMDocument3(iface);
2219 FIXME("(%p)->(%p)\n", This, urlString);
2220 return E_NOTIMPL;
2221 }
2222
2223
2224 static HRESULT WINAPI domdoc_get_async(
2225 IXMLDOMDocument3 *iface,
2226 VARIANT_BOOL* isAsync )
2227 {
2228 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2229
2230 TRACE("(%p)->(%p: %d)\n", This, isAsync, This->async);
2231 *isAsync = This->async;
2232 return S_OK;
2233 }
2234
2235
2236 static HRESULT WINAPI domdoc_put_async(
2237 IXMLDOMDocument3 *iface,
2238 VARIANT_BOOL isAsync )
2239 {
2240 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2241
2242 TRACE("(%p)->(%d)\n", This, isAsync);
2243 This->async = isAsync;
2244 return S_OK;
2245 }
2246
2247
2248 static HRESULT WINAPI domdoc_abort(
2249 IXMLDOMDocument3 *iface )
2250 {
2251 domdoc *This = impl_from_IXMLDOMDocument3(iface);
2252 FIXME("%p\n", This);
2253 return E_NOTIMPL;
2254 }
2255
2256 /* don't rely on data to be in BSTR format, treat it as WCHAR string */
2257 static HRESULT WINAPI domdoc_loadXML(
2258 IXMLDOMDocument3 *iface,
2259 BSTR data,
2260 VARIANT_BOOL* isSuccessful )
2261 {
2262 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2263 xmlDocPtr xmldoc = NULL;
2264 HRESULT hr = S_FALSE, hr2;
2265
2266 TRACE("(%p)->(%s %p)\n", This, debugstr_w(data), isSuccessful );
2267
2268 assert ( &This->node );
2269
2270 if ( isSuccessful )
2271 {
2272 *isSuccessful = VARIANT_FALSE;
2273
2274 if (data)
2275 {
2276 WCHAR *ptr = data;
2277
2278 /* skip leading spaces if needed */
2279 if (This->properties->version == MSXML_DEFAULT || This->properties->version == MSXML26)
2280 while (*ptr)
2281 if (isspaceW(*ptr)) ptr++; else break;
2282
2283 xmldoc = doparse(This, (char*)ptr, strlenW(ptr)*sizeof(WCHAR), XML_CHAR_ENCODING_UTF16LE);
2284 if ( !xmldoc )
2285 {
2286 This->error = E_FAIL;
2287 TRACE("failed to parse document\n");
2288 }
2289 else
2290 {
2291 hr = This->error = S_OK;
2292 *isSuccessful = VARIANT_TRUE;
2293 TRACE("parsed document %p\n", xmldoc);
2294 }
2295 }
2296 }
2297
2298 if(!xmldoc)
2299 xmldoc = xmlNewDoc(NULL);
2300 xmldoc->_private = create_priv();
2301 hr2 = attach_xmldoc(This, xmldoc);
2302 if( FAILED(hr2) )
2303 hr = hr2;
2304
2305 return hr;
2306 }
2307
2308 static int XMLCALL domdoc_save_writecallback(void *ctx, const char *buffer, int len)
2309 {
2310 DWORD written = -1;
2311
2312 if(!WriteFile(ctx, buffer, len, &written, NULL))
2313 {
2314 WARN("write error\n");
2315 return -1;
2316 }
2317 else
2318 return written;
2319 }
2320
2321 static int XMLCALL domdoc_save_closecallback(void *ctx)
2322 {
2323 return CloseHandle(ctx) ? 0 : -1;
2324 }
2325
2326 static int XMLCALL domdoc_stream_save_writecallback(void *ctx, const char *buffer, int len)
2327 {
2328 ULONG written = 0;
2329 HRESULT hr;
2330
2331 hr = IStream_Write((IStream*)ctx, buffer, len, &written);
2332 if (hr != S_OK)
2333 {
2334 WARN("stream write error: 0x%08x\n", hr);
2335 return -1;
2336 }
2337 else
2338 return written;
2339 }
2340
2341 static int XMLCALL domdoc_stream_save_closecallback(void *ctx)
2342 {
2343 IStream_Release((IStream*)ctx);
2344 return 0;
2345 }
2346
2347 static HRESULT WINAPI domdoc_save(
2348 IXMLDOMDocument3 *iface,
2349 VARIANT destination )
2350 {
2351 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2352 xmlSaveCtxtPtr ctx = NULL;
2353 xmlNodePtr xmldecl;
2354 HRESULT ret = S_OK;
2355
2356 TRACE("(%p)->(%s)\n", This, debugstr_variant(&destination));
2357
2358 switch (V_VT(&destination))
2359 {
2360 case VT_UNKNOWN:
2361 {
2362 IUnknown *pUnk = V_UNKNOWN(&destination);
2363 IXMLDOMDocument3 *document;
2364 IStream *stream;
2365
2366 ret = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMDocument3, (void**)&document);
2367 if(ret == S_OK)
2368 {
2369 VARIANT_BOOL success;
2370 BSTR xml;
2371
2372 ret = IXMLDOMDocument3_get_xml(iface, &xml);
2373 if(ret == S_OK)
2374 {
2375 ret = IXMLDOMDocument3_loadXML(document, xml, &success);
2376 SysFreeString(xml);
2377 }
2378
2379 IXMLDOMDocument3_Release(document);
2380 return ret;
2381 }
2382
2383 ret = IUnknown_QueryInterface(pUnk, &IID_IStream, (void**)&stream);
2384 if(ret == S_OK)
2385 {
2386 ctx = xmlSaveToIO(domdoc_stream_save_writecallback,
2387 domdoc_stream_save_closecallback, stream, NULL, XML_SAVE_NO_DECL);
2388
2389 if(!ctx)
2390 {
2391 IStream_Release(stream);
2392 return E_FAIL;
2393 }
2394 }
2395 }
2396 break;
2397
2398 case VT_BSTR:
2399 case VT_BSTR | VT_BYREF:
2400 {
2401 /* save with file path */
2402 HANDLE handle = CreateFileW( (V_VT(&destination) & VT_BYREF)? *V_BSTRREF(&destination) : V_BSTR(&destination),
2403 GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
2404 if( handle == INVALID_HANDLE_VALUE )
2405 {
2406 WARN("failed to create file\n");
2407 return E_FAIL;
2408 }
2409
2410 /* disable top XML declaration */
2411 ctx = xmlSaveToIO(domdoc_save_writecallback, domdoc_save_closecallback,
2412 handle, NULL, XML_SAVE_NO_DECL);
2413 if (!ctx)
2414 {
2415 CloseHandle(handle);
2416 return E_FAIL;
2417 }
2418 }
2419 break;
2420
2421 default:
2422 FIXME("Unhandled VARIANT: %s\n", debugstr_variant(&destination));
2423 return S_FALSE;
2424 }
2425
2426 xmldecl = xmldoc_unlink_xmldecl(get_doc(This));
2427 if (xmlSaveDoc(ctx, get_doc(This)) == -1) ret = S_FALSE;
2428 xmldoc_link_xmldecl(get_doc(This), xmldecl);
2429
2430 /* will release resources through close callback */
2431 xmlSaveClose(ctx);
2432
2433 return ret;
2434 }
2435
2436 static HRESULT WINAPI domdoc_get_validateOnParse(
2437 IXMLDOMDocument3 *iface,
2438 VARIANT_BOOL* isValidating )
2439 {
2440 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2441 TRACE("(%p)->(%p: %d)\n", This, isValidating, This->validating);
2442 *isValidating = This->validating;
2443 return S_OK;
2444 }
2445
2446
2447 static HRESULT WINAPI domdoc_put_validateOnParse(
2448 IXMLDOMDocument3 *iface,
2449 VARIANT_BOOL isValidating )
2450 {
2451 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2452 TRACE("(%p)->(%d)\n", This, isValidating);
2453 This->validating = isValidating;
2454 return S_OK;
2455 }
2456
2457
2458 static HRESULT WINAPI domdoc_get_resolveExternals(
2459 IXMLDOMDocument3 *iface,
2460 VARIANT_BOOL* isResolving )
2461 {
2462 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2463 TRACE("(%p)->(%p: %d)\n", This, isResolving, This->resolving);
2464 *isResolving = This->resolving;
2465 return S_OK;
2466 }
2467
2468
2469 static HRESULT WINAPI domdoc_put_resolveExternals(
2470 IXMLDOMDocument3 *iface,
2471 VARIANT_BOOL isResolving )
2472 {
2473 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2474 TRACE("(%p)->(%d)\n", This, isResolving);
2475 This->resolving = isResolving;
2476 return S_OK;
2477 }
2478
2479
2480 static HRESULT WINAPI domdoc_get_preserveWhiteSpace(
2481 IXMLDOMDocument3 *iface,
2482 VARIANT_BOOL* isPreserving )
2483 {
2484 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2485 TRACE("(%p)->(%p: %d)\n", This, isPreserving, This->properties->preserving);
2486 *isPreserving = This->properties->preserving;
2487 return S_OK;
2488 }
2489
2490
2491 static HRESULT WINAPI domdoc_put_preserveWhiteSpace(
2492 IXMLDOMDocument3 *iface,
2493 VARIANT_BOOL isPreserving )
2494 {
2495 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2496 TRACE("(%p)->(%d)\n", This, isPreserving);
2497 This->properties->preserving = isPreserving;
2498 return S_OK;
2499 }
2500
2501
2502 static HRESULT WINAPI domdoc_put_onreadystatechange(
2503 IXMLDOMDocument3 *iface,
2504 VARIANT event )
2505 {
2506 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2507
2508 TRACE("(%p)->(%s)\n", This, debugstr_variant(&event));
2509 return set_doc_event(This, EVENTID_READYSTATECHANGE, &event);
2510 }
2511
2512
2513 static HRESULT WINAPI domdoc_put_onDataAvailable(IXMLDOMDocument3 *iface, VARIANT sink)
2514 {
2515 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2516 FIXME("(%p)->(%s): stub\n", This, debugstr_variant(&sink));
2517 return E_NOTIMPL;
2518 }
2519
2520 static HRESULT WINAPI domdoc_put_onTransformNode(IXMLDOMDocument3 *iface, VARIANT sink )
2521 {
2522 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2523 FIXME("(%p)->(%s): stub\n", This, debugstr_variant(&sink));
2524 return E_NOTIMPL;
2525 }
2526
2527 static HRESULT WINAPI domdoc_get_namespaces(
2528 IXMLDOMDocument3* iface,
2529 IXMLDOMSchemaCollection** collection )
2530 {
2531 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2532 HRESULT hr;
2533
2534 FIXME("(%p)->(%p): semi-stub\n", This, collection);
2535
2536 if (!collection) return E_POINTER;
2537
2538 if (!This->namespaces)
2539 {
2540 hr = SchemaCache_create(This->properties->version, NULL, (void**)&This->namespaces);
2541 if (hr != S_OK) return hr;
2542
2543 hr = cache_from_doc_ns(This->namespaces, &This->node);
2544 if (hr != S_OK)
2545 release_namespaces(This);
2546 }
2547
2548 if (This->namespaces)
2549 return IXMLDOMSchemaCollection2_QueryInterface(This->namespaces,
2550 &IID_IXMLDOMSchemaCollection, (void**)collection);
2551
2552 return hr;
2553 }
2554
2555 static HRESULT WINAPI domdoc_get_schemas(
2556 IXMLDOMDocument3* iface,
2557 VARIANT* var1 )
2558 {
2559 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2560 HRESULT hr = S_FALSE;
2561 IXMLDOMSchemaCollection2* cur_schema = This->properties->schemaCache;
2562
2563 TRACE("(%p)->(%p)\n", This, var1);
2564
2565 VariantInit(var1); /* Test shows we don't call VariantClear here */
2566 V_VT(var1) = VT_NULL;
2567
2568 if(cur_schema)
2569 {
2570 hr = IXMLDOMSchemaCollection2_QueryInterface(cur_schema, &IID_IDispatch, (void**)&V_DISPATCH(var1));
2571 if(SUCCEEDED(hr))
2572 V_VT(var1) = VT_DISPATCH;
2573 }
2574 return hr;
2575 }
2576
2577 static HRESULT WINAPI domdoc_putref_schemas(
2578 IXMLDOMDocument3* iface,
2579 VARIANT schema)
2580 {
2581 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2582 HRESULT hr = E_FAIL;
2583 IXMLDOMSchemaCollection2* new_schema = NULL;
2584
2585 FIXME("(%p)->(%s): semi-stub\n", This, debugstr_variant(&schema));
2586 switch(V_VT(&schema))
2587 {
2588 case VT_UNKNOWN:
2589 hr = IUnknown_QueryInterface(V_UNKNOWN(&schema), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
2590 break;
2591
2592 case VT_DISPATCH:
2593 hr = IDispatch_QueryInterface(V_DISPATCH(&schema), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
2594 break;
2595
2596 case VT_NULL:
2597 case VT_EMPTY:
2598 hr = S_OK;
2599 break;
2600
2601 default:
2602 WARN("Can't get schema from vt %x\n", V_VT(&schema));
2603 }
2604
2605 if(SUCCEEDED(hr))
2606 {
2607 IXMLDOMSchemaCollection2* old_schema = InterlockedExchangePointer((void**)&This->properties->schemaCache, new_schema);
2608 if(old_schema) IXMLDOMSchemaCollection2_Release(old_schema);
2609 }
2610
2611 return hr;
2612 }
2613
2614 static inline BOOL is_wellformed(xmlDocPtr doc)
2615 {
2616 #ifdef HAVE_XMLDOC_PROPERTIES
2617 return doc->properties & XML_DOC_WELLFORMED;
2618 #else
2619 /* Not a full check, but catches the worst violations */
2620 xmlNodePtr child;
2621 int root = 0;
2622
2623 for (child = doc->children; child != NULL; child = child->next)
2624 {
2625 switch (child->type)
2626 {
2627 case XML_ELEMENT_NODE:
2628 if (++root > 1)
2629 return FALSE;
2630 break;
2631 case XML_TEXT_NODE:
2632 case XML_CDATA_SECTION_NODE:
2633 return FALSE;
2634 break;
2635 default:
2636 break;
2637 }
2638 }
2639
2640 return root == 1;
2641 #endif
2642 }
2643
2644 static void LIBXML2_LOG_CALLBACK validate_error(void* ctx, char const* msg, ...)
2645 {
2646 va_list ap;
2647 va_start(ap, msg);
2648 LIBXML2_CALLBACK_ERR(domdoc_validateNode, msg, ap);
2649 va_end(ap);
2650 }
2651
2652 static void LIBXML2_LOG_CALLBACK validate_warning(void* ctx, char const* msg, ...)
2653 {
2654 va_list ap;
2655 va_start(ap, msg);
2656 LIBXML2_CALLBACK_WARN(domdoc_validateNode, msg, ap);
2657 va_end(ap);
2658 }
2659
2660 static HRESULT WINAPI domdoc_validateNode(
2661 IXMLDOMDocument3* iface,
2662 IXMLDOMNode* node,
2663 IXMLDOMParseError** err)
2664 {
2665 domdoc* This = impl_from_IXMLDOMDocument3(iface);
2666 LONG state, err_code = 0;
2667 HRESULT hr = S_OK;
2668 int validated = 0;
2669
2670 TRACE("(%p)->(%p, %p)\n", This, node, err);
2671 IXMLDOMDocument3_get_readyState(iface, &state);
2672 if (state != READYSTATE_COMPLETE)
2673 {
2674 if (err)
2675 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2676 return E_PENDING;
2677 }
2678
2679 if (!node)
2680 {
2681 if (err)
2682 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2683 return E_POINTER;
2684 }
2685
2686 if (!get_node_obj(node)->node || get_node_obj(node)->node->doc != get_doc(This))
2687 {
2688 if (err)
2689 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2690 return E_FAIL;
2691 }
2692
2693 if (!is_wellformed(get_doc(This)))
2694 {
2695 ERR("doc not well-formed\n");
2696 if (err)
2697 *err = create_parseError(E_XML_NOTWF, NULL, NULL, NULL, 0, 0, 0);
2698 return S_FALSE;
2699 }
2700
2701 /* DTD validation */
2702 if (get_doc(This)->intSubset || get_doc(This)->extSubset)
2703 {
2704 xmlValidCtxtPtr vctx = xmlNewValidCtxt();
2705 vctx->error = validate_error;
2706 vctx->warning = validate_warning;
2707 ++validated;
2708
2709 if (!((node == (IXMLDOMNode*)iface)?
2710 xmlValidateDocument(vctx, get_doc(This)) :
2711 xmlValidateElement(vctx, get_doc(This), get_node_obj(node)->node)))
2712 {
2713 /* TODO: get a real error code here */
2714 TRACE("DTD validation failed\n");
2715 err_code = E_XML_INVALID;
2716 hr = S_FALSE;
2717 }
2718 xmlFreeValidCtxt(vctx);
2719 }
2720
2721 /* Schema validation */
2722 if (hr == S_OK && This->properties->schemaCache != NULL)
2723 {
2724
2725 hr = SchemaCache_validate_tree(This->properties->schemaCache, get_node_obj(node)->node);
2726 if (SUCCEEDED(hr))
2727 {
2728 ++validated;
2729 /* TODO: get a real error code here */
2730 if (hr == S_OK)
2731 {
2732 TRACE("schema validation succeeded\n");
2733 }
2734 else
2735 {
2736 ERR("schema validation failed\n");
2737 err_code = E_XML_INVALID;
2738 }
2739 }
2740 else
2741 {
2742 /* not really OK, just didn't find a schema for the ns */
2743 hr = S_OK;
2744 }
2745 }
2746
2747 if (!validated)
2748 {
2749 ERR("no DTD or schema found\n");
2750 err_code = E_XML_NODTD;
2751 hr = S_FALSE;
2752 }
2753
2754 if (err)
2755 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2756
2757 return hr;
2758 }
2759
2760 static HRESULT WINAPI domdoc_validate(
2761 IXMLDOMDocument3* iface,
2762 IXMLDOMParseError** err)
2763 {
2764 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2765 TRACE("(%p)->(%p)\n", This, err);
2766 return IXMLDOMDocument3_validateNode(iface, (IXMLDOMNode*)iface, err);
2767 }
2768
2769 static HRESULT WINAPI domdoc_setProperty(
2770 IXMLDOMDocument3* iface,
2771 BSTR p,
2772 VARIANT value)
2773 {
2774 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2775
2776 TRACE("(%p)->(%s %s)\n", This, debugstr_w(p), debugstr_variant(&value));
2777
2778 if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
2779 {
2780 VARIANT varStr;
2781 HRESULT hr;
2782 BSTR bstr;
2783
2784 V_VT(&varStr) = VT_EMPTY;
2785 if (V_VT(&value) != VT_BSTR)
2786 {
2787 if (FAILED(hr = VariantChangeType(&varStr, &value, 0, VT_BSTR)))
2788 return hr;
2789 bstr = V_BSTR(&varStr);
2790 }
2791 else
2792 bstr = V_BSTR(&value);
2793
2794 hr = S_OK;
2795 if (lstrcmpiW(bstr, PropValueXPathW) == 0)
2796 This->properties->XPath = TRUE;
2797 else if (lstrcmpiW(bstr, PropValueXSLPatternW) == 0)
2798 This->properties->XPath = FALSE;
2799 else
2800 hr = E_FAIL;
2801
2802 VariantClear(&varStr);
2803 return hr;
2804 }
2805 else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
2806 {
2807 xmlChar *nsStr = (xmlChar*)This->properties->selectNsStr;
2808 struct list *pNsList;
2809 VARIANT varStr;
2810 HRESULT hr;
2811 BSTR bstr;
2812
2813 V_VT(&varStr) = VT_EMPTY;
2814 if (V_VT(&value) != VT_BSTR)
2815 {
2816 if (FAILED(hr = VariantChangeType(&varStr, &value, 0, VT_BSTR)))
2817 return hr;
2818 bstr = V_BSTR(&varStr);
2819 }
2820 else
2821 bstr = V_BSTR(&value);
2822
2823 hr = S_OK;
2824
2825 pNsList = &(This->properties->selectNsList);
2826 clear_selectNsList(pNsList);
2827 heap_free(nsStr);
2828 nsStr = xmlchar_from_wchar(bstr);
2829
2830 TRACE("property value: \"%s\"\n", debugstr_w(bstr));
2831
2832 This->properties->selectNsStr = nsStr;
2833 This->properties->selectNsStr_len = xmlStrlen(nsStr);
2834 if (bstr && *bstr)
2835 {
2836 xmlChar *pTokBegin, *pTokEnd, *pTokInner;
2837 select_ns_entry* ns_entry = NULL;
2838 xmlXPathContextPtr ctx;
2839
2840 ctx = xmlXPathNewContext(This->node.node->doc);
2841 pTokBegin = nsStr;
2842
2843 /* skip leading spaces */
2844 while (*pTokBegin == ' ' || *pTokBegin == '\n' ||
2845 *pTokBegin == '\t' || *pTokBegin == '\r')
2846 ++pTokBegin;
2847
2848 for (; *pTokBegin; pTokBegin = pTokEnd)
2849 {
2850 if (ns_entry)
2851 memset(ns_entry, 0, sizeof(select_ns_entry));
2852 else
2853 ns_entry = heap_alloc_zero(sizeof(select_ns_entry));
2854
2855 while (*pTokBegin == ' ')
2856 ++pTokBegin;
2857 pTokEnd = pTokBegin;
2858 while (*pTokEnd != ' ' && *pTokEnd != 0)
2859 ++pTokEnd;
2860
2861 if (xmlStrncmp(pTokBegin, (xmlChar const*)"xmlns", 5) != 0)
2862 {
2863 hr = E_FAIL;
2864 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2865 debugstr_w(bstr), debugstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
2866 continue;
2867 }
2868
2869 pTokBegin += 5;
2870 if (*pTokBegin == '=')
2871 {
2872 /*valid for XSLPattern?*/
2873 FIXME("Setting default xmlns not supported - skipping.\n");
2874 continue;
2875 }
2876 else if (*pTokBegin == ':')
2877 {
2878 ns_entry->prefix = ++pTokBegin;
2879 for (pTokInner = pTokBegin; pTokInner != pTokEnd && *pTokInner != '='; ++pTokInner)
2880 ;
2881
2882 if (pTokInner == pTokEnd)
2883 {
2884 hr = E_FAIL;
2885 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2886 debugstr_w(bstr), debugstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
2887 continue;
2888 }
2889
2890 ns_entry->prefix_end = *pTokInner;
2891 *pTokInner = 0;
2892 ++pTokInner;
2893
2894 if (pTokEnd-pTokInner > 1 &&
2895 ((*pTokInner == '\'' && *(pTokEnd-1) == '\'') ||
2896 (*pTokInner == '"' && *(pTokEnd-1) == '"')))
2897 {
2898 ns_entry->href = ++pTokInner;
2899 ns_entry->href_end = *(pTokEnd-1);
2900 *(pTokEnd-1) = 0;
2901 list_add_tail(pNsList, &ns_entry->entry);
2902 /*let libxml figure out if they're valid from here ;)*/
2903 if (xmlXPathRegisterNs(ctx, ns_entry->prefix, ns_entry->href) != 0)
2904 {
2905 hr = E_FAIL;
2906 }
2907 ns_entry = NULL;
2908 continue;
2909 }
2910 else
2911 {
2912 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2913 debugstr_w(bstr), debugstr_an((const char*)pTokInner, pTokEnd-pTokInner));
2914 list_add_tail(pNsList, &ns_entry->entry);
2915
2916 ns_entry = NULL;
2917 hr = E_FAIL;
2918 continue;
2919 }
2920 }
2921 else
2922 {
2923 hr = E_FAIL;
2924 continue;
2925 }
2926 }
2927 heap_free(ns_entry);
2928 xmlXPathFreeContext(ctx);
2929 }
2930
2931 VariantClear(&varStr);
2932 return hr;
2933 }
2934 else if (lstrcmpiW(p, PropertyProhibitDTDW) == 0 ||
2935 lstrcmpiW(p, PropertyNewParserW) == 0 ||
2936 lstrcmpiW(p, PropertyResolveExternalsW) == 0)
2937 {
2938 /* Ignore */
2939 FIXME("Ignoring property %s, value %d\n", debugstr_w(p), V_BOOL(&value));
2940 return S_OK;
2941 }
2942
2943 FIXME("Unknown property %s\n", debugstr_w(p));
2944 return E_FAIL;
2945 }
2946
2947 static HRESULT WINAPI domdoc_getProperty(
2948 IXMLDOMDocument3* iface,
2949 BSTR p,
2950 VARIANT* var)
2951 {
2952 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2953
2954 TRACE("(%p)->(%s)\n", This, debugstr_w(p));
2955
2956 if (!var)
2957 return E_INVALIDARG;
2958
2959 if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
2960 {
2961 V_VT(var) = VT_BSTR;
2962 V_BSTR(var) = This->properties->XPath ?
2963 SysAllocString(PropValueXPathW) :
2964 SysAllocString(PropValueXSLPatternW);
2965 return V_BSTR(var) ? S_OK : E_OUTOFMEMORY;
2966 }
2967 else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
2968 {
2969 int lenA, lenW;
2970 BSTR rebuiltStr, cur;
2971 const xmlChar *nsStr;
2972 struct list *pNsList;
2973 select_ns_entry* pNsEntry;
2974
2975 V_VT(var) = VT_BSTR;
2976 nsStr = This->properties->selectNsStr;
2977 pNsList = &This->properties->selectNsList;
2978 lenA = This->properties->selectNsStr_len;
2979 lenW = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, NULL, 0);
2980 rebuiltStr = heap_alloc(lenW*sizeof(WCHAR));
2981 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, rebuiltStr, lenW);
2982 cur = rebuiltStr;
2983 /* this is fine because all of the chars that end tokens are ASCII*/
2984 LIST_FOR_EACH_ENTRY(pNsEntry, pNsList, select_ns_entry, entry)
2985 {
2986 while (*cur != 0) ++cur;
2987 if (pNsEntry->prefix_end)
2988 {
2989 *cur = pNsEntry->prefix_end;
2990 while (*cur != 0) ++cur;
2991 }
2992
2993 if (pNsEntry->href_end)
2994 {
2995 *cur = pNsEntry->href_end;
2996 }
2997 }
2998 V_BSTR(var) = SysAllocString(rebuiltStr);
2999 heap_free(rebuiltStr);
3000 return S_OK;
3001 }
3002
3003 FIXME("Unknown property %s\n", debugstr_w(p));
3004 return E_FAIL;
3005 }
3006
3007 static HRESULT WINAPI domdoc_importNode(
3008 IXMLDOMDocument3* iface,
3009 IXMLDOMNode* node,
3010 VARIANT_BOOL deep,
3011 IXMLDOMNode** clone)
3012 {
3013 domdoc *This = impl_from_IXMLDOMDocument3( iface );
3014 FIXME("(%p)->(%p %d %p): stub\n", This, node, deep, clone);
3015 return E_NOTIMPL;
3016 }
3017
3018 static const struct IXMLDOMDocument3Vtbl XMLDOMDocument3Vtbl =
3019 {
3020 domdoc_QueryInterface,
3021 domdoc_AddRef,
3022 domdoc_Release,
3023 domdoc_GetTypeInfoCount,
3024 domdoc_GetTypeInfo,
3025 domdoc_GetIDsOfNames,
3026 domdoc_Invoke,
3027 domdoc_get_nodeName,
3028 domdoc_get_nodeValue,
3029 domdoc_put_nodeValue,
3030 domdoc_get_nodeType,
3031 domdoc_get_parentNode,
3032 domdoc_get_childNodes,
3033 domdoc_get_firstChild,
3034 domdoc_get_lastChild,
3035 domdoc_get_previousSibling,
3036 domdoc_get_nextSibling,
3037 domdoc_get_attributes,
3038 domdoc_insertBefore,
3039 domdoc_replaceChild,
3040 domdoc_removeChild,
3041 domdoc_appendChild,
3042 domdoc_hasChildNodes,
3043 domdoc_get_ownerDocument,
3044 domdoc_cloneNode,
3045 domdoc_get_nodeTypeString,
3046 domdoc_get_text,
3047 domdoc_put_text,
3048 domdoc_get_specified,
3049 domdoc_get_definition,
3050 domdoc_get_nodeTypedValue,
3051 domdoc_put_nodeTypedValue,
3052 domdoc_get_dataType,
3053 domdoc_put_dataType,
3054 domdoc_get_xml,
3055 domdoc_transformNode,
3056 domdoc_selectNodes,
3057 domdoc_selectSingleNode,
3058 domdoc_get_parsed,
3059 domdoc_get_namespaceURI,
3060 domdoc_get_prefix,
3061 domdoc_get_baseName,
3062 domdoc_transformNodeToObject,
3063 domdoc_get_doctype,
3064 domdoc_get_implementation,
3065 domdoc_get_documentElement,
3066 domdoc_put_documentElement,
3067 domdoc_createElement,
3068 domdoc_createDocumentFragment,
3069 domdoc_createTextNode,
3070 domdoc_createComment,
3071 domdoc_createCDATASection,
3072 domdoc_createProcessingInstruction,
3073 domdoc_createAttribute,
3074 domdoc_createEntityReference,
3075 domdoc_getElementsByTagName,
3076 domdoc_createNode,
3077 domdoc_nodeFromID,
3078 domdoc_load,
3079 domdoc_get_readyState,
3080 domdoc_get_parseError,
3081 domdoc_get_url,
3082 domdoc_get_async,
3083 domdoc_put_async,
3084 domdoc_abort,
3085 domdoc_loadXML,
3086 domdoc_save,
3087 domdoc_get_validateOnParse,
3088 domdoc_put_validateOnParse,
3089 domdoc_get_resolveExternals,
3090 domdoc_put_resolveExternals,
3091 domdoc_get_preserveWhiteSpace,
3092 domdoc_put_preserveWhiteSpace,
3093 domdoc_put_onreadystatechange,
3094 domdoc_put_onDataAvailable,
3095 domdoc_put_onTransformNode,
3096 domdoc_get_namespaces,
3097 domdoc_get_schemas,
3098 domdoc_putref_schemas,
3099 domdoc_validate,
3100 domdoc_setProperty,
3101 domdoc_getProperty,
3102 domdoc_validateNode,
3103 domdoc_importNode
3104 };
3105
3106 /* IConnectionPointContainer */
3107 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
3108 REFIID riid, void **ppv)
3109 {
3110 domdoc *This = impl_from_IConnectionPointContainer(iface);
3111 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppv);
3112 }
3113
3114 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
3115 {
3116 domdoc *This = impl_from_IConnectionPointContainer(iface);
3117 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
3118 }
3119
3120 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
3121 {
3122 domdoc *This = impl_from_IConnectionPointContainer(iface);
3123 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
3124 }
3125
3126 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
3127 IEnumConnectionPoints **ppEnum)
3128 {
3129 domdoc *This = impl_from_IConnectionPointContainer(iface);
3130 FIXME("(%p)->(%p): stub\n", This, ppEnum);
3131 return E_NOTIMPL;
3132 }
3133
3134 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
3135 REFIID riid, IConnectionPoint **cp)
3136 {
3137 domdoc *This = impl_from_IConnectionPointContainer(iface);
3138 ConnectionPoint *iter;
3139
3140 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), cp);
3141
3142 *cp = NULL;
3143
3144 for(iter = This->cp_list; iter; iter = iter->next)
3145 {
3146 if (IsEqualGUID(iter->iid, riid))
3147 *cp = &iter->IConnectionPoint_iface;
3148 }
3149
3150 if (*cp)
3151 {
3152 IConnectionPoint_AddRef(*cp);
3153 return S_OK;
3154 }
3155
3156 FIXME("unsupported riid %s\n", debugstr_guid(riid));
3157 return CONNECT_E_NOCONNECTION;
3158
3159 }
3160
3161 static const struct IConnectionPointContainerVtbl ConnectionPointContainerVtbl =
3162 {
3163 ConnectionPointContainer_QueryInterface,
3164 ConnectionPointContainer_AddRef,
3165 ConnectionPointContainer_Release,
3166 ConnectionPointContainer_EnumConnectionPoints,
3167 ConnectionPointContainer_FindConnectionPoint
3168 };
3169
3170 /* IConnectionPoint */
3171 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface,
3172 REFIID riid, void **ppv)
3173 {
3174 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3175
3176 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv );
3177
3178 *ppv = NULL;
3179
3180 if (IsEqualGUID(&IID_IUnknown, riid) ||
3181 IsEqualGUID(&IID_IConnectionPoint, riid))
3182 {
3183 *ppv = iface;
3184 }
3185
3186 if (*ppv)
3187 {
3188 IConnectionPoint_AddRef(iface);
3189 return S_OK;
3190 }
3191
3192 WARN("Unsupported interface %s\n", debugstr_guid(riid));
3193 return E_NOINTERFACE;
3194 }
3195
3196 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
3197 {
3198 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3199 return IConnectionPointContainer_AddRef(This->container);
3200 }
3201
3202 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
3203 {
3204 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3205 return IConnectionPointContainer_Release(This->container);
3206 }
3207
3208 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *iid)
3209 {
3210 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3211
3212 TRACE("(%p)->(%p)\n", This, iid);
3213
3214 if (!iid) return E_POINTER;
3215
3216 *iid = *This->iid;
3217 return S_OK;
3218 }
3219
3220 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
3221 IConnectionPointContainer **container)
3222 {
3223 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3224
3225 TRACE("(%p)->(%p)\n", This, container);
3226
3227 if (!container) return E_POINTER;
3228
3229 *container = This->container;
3230 IConnectionPointContainer_AddRef(*container);
3231 return S_OK;
3232 }
3233
3234 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink,
3235 DWORD *pdwCookie)
3236 {
3237 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3238 FIXME("(%p)->(%p %p): stub\n", This, pUnkSink, pdwCookie);
3239 return E_NOTIMPL;
3240 }
3241
3242 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD cookie)
3243 {
3244 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3245
3246 TRACE("(%p)->(%d)\n", This, cookie);
3247
3248 if (cookie == 0 || cookie > This->sinks_size || !This->sinks[cookie-1].unk)
3249 return CONNECT_E_NOCONNECTION;
3250
3251 IUnknown_Release(This->sinks[cookie-1].unk);
3252 This->sinks[cookie-1].unk = NULL;
3253
3254 return S_OK;
3255 }
3256
3257 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
3258 IEnumConnections **ppEnum)
3259 {
3260 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3261 FIXME("(%p)->(%p): stub\n", This, ppEnum);
3262 return E_NOTIMPL;
3263 }
3264
3265 static const IConnectionPointVtbl ConnectionPointVtbl =
3266 {
3267 ConnectionPoint_QueryInterface,
3268 ConnectionPoint_AddRef,
3269 ConnectionPoint_Release,
3270 ConnectionPoint_GetConnectionInterface,
3271 ConnectionPoint_GetConnectionPointContainer,
3272 ConnectionPoint_Advise,
3273 ConnectionPoint_Unadvise,
3274 ConnectionPoint_EnumConnections
3275 };
3276
3277 static void ConnectionPoint_Init(ConnectionPoint *cp, struct domdoc *doc, REFIID riid)
3278 {
3279 cp->IConnectionPoint_iface.lpVtbl = &ConnectionPointVtbl;
3280 cp->doc = doc;
3281 cp->iid = riid;
3282 cp->sinks = NULL;
3283 cp->sinks_size = 0;
3284
3285 cp->next = doc->cp_list;
3286 doc->cp_list = cp;
3287
3288 cp->container = &doc->IConnectionPointContainer_iface;
3289 }
3290
3291 /* domdoc implementation of IObjectWithSite */
3292 static HRESULT WINAPI
3293 domdoc_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
3294 {
3295 domdoc *This = impl_from_IObjectWithSite(iface);
3296 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppvObject);
3297 }
3298
3299 static ULONG WINAPI domdoc_ObjectWithSite_AddRef( IObjectWithSite* iface )
3300 {
3301 domdoc *This = impl_from_IObjectWithSite(iface);
3302 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
3303 }
3304
3305 static ULONG WINAPI domdoc_ObjectWithSite_Release( IObjectWithSite* iface )
3306 {
3307 domdoc *This = impl_from_IObjectWithSite(iface);
3308 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
3309 }
3310
3311 static HRESULT WINAPI domdoc_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite )
3312 {
3313 domdoc *This = impl_from_IObjectWithSite(iface);
3314
3315 TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
3316
3317 if ( !This->site )
3318 return E_FAIL;
3319
3320 return IUnknown_QueryInterface( This->site, iid, ppvSite );
3321 }
3322
3323 static HRESULT WINAPI domdoc_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
3324 {
3325 domdoc *This = impl_from_IObjectWithSite(iface);
3326
3327 TRACE("(%p)->(%p)\n", iface, punk);
3328
3329 if(!punk)
3330 {
3331 if(This->site)
3332 {
3333 IUnknown_Release( This->site );
3334 This->site = NULL;
3335 }
3336
3337 return S_OK;
3338 }
3339
3340 IUnknown_AddRef( punk );
3341
3342 if(This->site)
3343 IUnknown_Release( This->site );
3344
3345 This->site = punk;
3346
3347 return S_OK;
3348 }
3349
3350 static const IObjectWithSiteVtbl domdocObjectSite =
3351 {
3352 domdoc_ObjectWithSite_QueryInterface,
3353 domdoc_ObjectWithSite_AddRef,
3354 domdoc_ObjectWithSite_Release,
3355 domdoc_ObjectWithSite_SetSite,
3356 domdoc_ObjectWithSite_GetSite
3357 };
3358
3359 static HRESULT WINAPI domdoc_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
3360 {
3361 domdoc *This = impl_from_IObjectSafety(iface);
3362 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppv);
3363 }
3364
3365 static ULONG WINAPI domdoc_Safety_AddRef(IObjectSafety *iface)
3366 {
3367 domdoc *This = impl_from_IObjectSafety(iface);
3368 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
3369 }
3370
3371 static ULONG WINAPI domdoc_Safety_Release(IObjectSafety *iface)
3372 {
3373 domdoc *This = impl_from_IObjectSafety(iface);
3374 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
3375 }
3376
3377 #define SAFETY_SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)
3378
3379 static HRESULT WINAPI domdoc_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
3380 DWORD *supported, DWORD *enabled)
3381 {
3382 domdoc *This = impl_from_IObjectSafety(iface);
3383
3384 TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
3385
3386 if(!supported || !enabled) return E_POINTER;
3387
3388 *supported = SAFETY_SUPPORTED_OPTIONS;
3389 *enabled = This->safeopt;
3390
3391 return S_OK;
3392 }
3393
3394 static HRESULT WINAPI domdoc_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
3395 DWORD mask, DWORD enabled)
3396 {
3397 domdoc *This = impl_from_IObjectSafety(iface);
3398 TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), mask, enabled);
3399
3400 if ((mask & ~SAFETY_SUPPORTED_OPTIONS) != 0)
3401 return E_FAIL;
3402
3403 This->safeopt = (This->safeopt & ~mask) | (mask & enabled);
3404
3405 return S_OK;
3406 }
3407
3408 #undef SAFETY_SUPPORTED_OPTIONS
3409
3410 static const IObjectSafetyVtbl domdocObjectSafetyVtbl = {
3411 domdoc_Safety_QueryInterface,
3412 domdoc_Safety_AddRef,
3413 domdoc_Safety_Release,
3414 domdoc_Safety_GetInterfaceSafetyOptions,
3415 domdoc_Safety_SetInterfaceSafetyOptions
3416 };
3417
3418 static const tid_t domdoc_iface_tids[] = {
3419 IXMLDOMDocument3_tid,
3420 0
3421 };
3422
3423 static dispex_static_data_t domdoc_dispex = {
3424 NULL,
3425 IXMLDOMDocument3_tid,
3426 NULL,
3427 domdoc_iface_tids
3428 };
3429
3430 HRESULT get_domdoc_from_xmldoc(xmlDocPtr xmldoc, IXMLDOMDocument3 **document)
3431 {
3432 domdoc *doc;
3433
3434 doc = heap_alloc( sizeof (*doc) );
3435 if( !doc )
3436 return E_OUTOFMEMORY;
3437
3438 doc->IXMLDOMDocument3_iface.lpVtbl = &XMLDOMDocument3Vtbl;
3439 doc->IPersistStreamInit_iface.lpVtbl = &xmldoc_IPersistStreamInit_VTable;
3440 doc->IObjectWithSite_iface.lpVtbl = &domdocObjectSite;
3441 doc->IObjectSafety_iface.lpVtbl = &domdocObjectSafetyVtbl;
3442 doc->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
3443 doc->ref = 1;
3444 doc->async = VARIANT_TRUE;
3445 doc->validating = 0;
3446 doc->resolving = 0;
3447 doc->properties = properties_from_xmlDocPtr(xmldoc);
3448 doc->error = S_OK;
3449 doc->stream = NULL;
3450 doc->site = NULL;
3451 doc->safeopt = 0;
3452 doc->bsc = NULL;
3453 doc->cp_list = NULL;
3454 doc->namespaces = NULL;
3455 memset(doc->events, 0, sizeof(doc->events));
3456
3457 /* events connection points */
3458 ConnectionPoint_Init(&doc->cp_dispatch, doc, &IID_IDispatch);
3459 ConnectionPoint_Init(&doc->cp_propnotif, doc, &IID_IPropertyNotifySink);
3460 ConnectionPoint_Init(&doc->cp_domdocevents, doc, &DIID_XMLDOMDocumentEvents);
3461
3462 init_xmlnode(&doc->node, (xmlNodePtr)xmldoc, (IXMLDOMNode*)&doc->IXMLDOMDocument3_iface,
3463 &domdoc_dispex);
3464
3465 *document = &doc->IXMLDOMDocument3_iface;
3466
3467 TRACE("returning iface %p\n", *document);
3468 return S_OK;
3469 }
3470
3471 HRESULT DOMDocument_create(MSXML_VERSION version, IUnknown *pUnkOuter, void **ppObj)
3472 {
3473 xmlDocPtr xmldoc;
3474 HRESULT hr;
3475
3476 TRACE("(%d, %p, %p)\n", version, pUnkOuter, ppObj);
3477
3478 xmldoc = xmlNewDoc(NULL);
3479 if(!xmldoc)
3480 return E_OUTOFMEMORY;
3481
3482 xmldoc_init(xmldoc, version);
3483
3484 hr = get_domdoc_from_xmldoc(xmldoc, (IXMLDOMDocument3**)ppObj);
3485 if(FAILED(hr))
3486 {
3487 free_properties(properties_from_xmlDocPtr(xmldoc));
3488 heap_free(xmldoc->_private);
3489 xmlFreeDoc(xmldoc);
3490 return hr;
3491 }
3492
3493 return hr;
3494 }
3495
3496 IUnknown* create_domdoc( xmlNodePtr document )
3497 {
3498 void* pObj = NULL;
3499 HRESULT hr;
3500
3501 TRACE("(%p)\n", document);
3502
3503 hr = get_domdoc_from_xmldoc((xmlDocPtr)document, (IXMLDOMDocument3**)&pObj);
3504 if (FAILED(hr))
3505 return NULL;
3506
3507 return pObj;
3508 }
3509
3510 #else
3511
3512 HRESULT DOMDocument_create(MSXML_VERSION version, IUnknown *pUnkOuter, void **ppObj)
3513 {
3514 MESSAGE("This program tried to use a DOMDocument object, but\n"
3515 "libxml2 support was not present at compile time.\n");
3516 return E_NOTIMPL;
3517 }
3518
3519 #endif
Maarten's multimedia branch