?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
po: Update Japanese translation.
[wine/multimedia.git] / dlls / msxml3 / domdoc.c
blob5097ff6ca8cb8bbe94aad3de73e74331faabbb81
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 && isspaceW(*ptr)) ptr++;
2281
2282 xmldoc = doparse(This, (char*)ptr, strlenW(ptr)*sizeof(WCHAR), XML_CHAR_ENCODING_UTF16LE);
2283 if ( !xmldoc )
2284 {
2285 This->error = E_FAIL;
2286 TRACE("failed to parse document\n");
2287 }
2288 else
2289 {
2290 hr = This->error = S_OK;
2291 *isSuccessful = VARIANT_TRUE;
2292 TRACE("parsed document %p\n", xmldoc);
2293 }
2294 }
2295 }
2296
2297 if(!xmldoc)
2298 xmldoc = xmlNewDoc(NULL);
2299 xmldoc->_private = create_priv();
2300 hr2 = attach_xmldoc(This, xmldoc);
2301 if( FAILED(hr2) )
2302 hr = hr2;
2303
2304 return hr;
2305 }
2306
2307 static int XMLCALL domdoc_save_writecallback(void *ctx, const char *buffer, int len)
2308 {
2309 DWORD written = -1;
2310
2311 if(!WriteFile(ctx, buffer, len, &written, NULL))
2312 {
2313 WARN("write error\n");
2314 return -1;
2315 }
2316 else
2317 return written;
2318 }
2319
2320 static int XMLCALL domdoc_save_closecallback(void *ctx)
2321 {
2322 return CloseHandle(ctx) ? 0 : -1;
2323 }
2324
2325 static int XMLCALL domdoc_stream_save_writecallback(void *ctx, const char *buffer, int len)
2326 {
2327 ULONG written = 0;
2328 HRESULT hr;
2329
2330 hr = IStream_Write((IStream*)ctx, buffer, len, &written);
2331 if (hr != S_OK)
2332 {
2333 WARN("stream write error: 0x%08x\n", hr);
2334 return -1;
2335 }
2336 else
2337 return written;
2338 }
2339
2340 static int XMLCALL domdoc_stream_save_closecallback(void *ctx)
2341 {
2342 IStream_Release((IStream*)ctx);
2343 return 0;
2344 }
2345
2346 static HRESULT WINAPI domdoc_save(
2347 IXMLDOMDocument3 *iface,
2348 VARIANT destination )
2349 {
2350 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2351 xmlSaveCtxtPtr ctx = NULL;
2352 xmlNodePtr xmldecl;
2353 HRESULT ret = S_OK;
2354
2355 TRACE("(%p)->(%s)\n", This, debugstr_variant(&destination));
2356
2357 switch (V_VT(&destination))
2358 {
2359 case VT_UNKNOWN:
2360 {
2361 IUnknown *pUnk = V_UNKNOWN(&destination);
2362 IXMLDOMDocument3 *document;
2363 IStream *stream;
2364
2365 ret = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMDocument3, (void**)&document);
2366 if(ret == S_OK)
2367 {
2368 VARIANT_BOOL success;
2369 BSTR xml;
2370
2371 ret = IXMLDOMDocument3_get_xml(iface, &xml);
2372 if(ret == S_OK)
2373 {
2374 ret = IXMLDOMDocument3_loadXML(document, xml, &success);
2375 SysFreeString(xml);
2376 }
2377
2378 IXMLDOMDocument3_Release(document);
2379 return ret;
2380 }
2381
2382 ret = IUnknown_QueryInterface(pUnk, &IID_IStream, (void**)&stream);
2383 if(ret == S_OK)
2384 {
2385 ctx = xmlSaveToIO(domdoc_stream_save_writecallback,
2386 domdoc_stream_save_closecallback, stream, NULL, XML_SAVE_NO_DECL);
2387
2388 if(!ctx)
2389 {
2390 IStream_Release(stream);
2391 return E_FAIL;
2392 }
2393 }
2394 }
2395 break;
2396
2397 case VT_BSTR:
2398 case VT_BSTR | VT_BYREF:
2399 {
2400 /* save with file path */
2401 HANDLE handle = CreateFileW( (V_VT(&destination) & VT_BYREF)? *V_BSTRREF(&destination) : V_BSTR(&destination),
2402 GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
2403 if( handle == INVALID_HANDLE_VALUE )
2404 {
2405 WARN("failed to create file\n");
2406 return E_FAIL;
2407 }
2408
2409 /* disable top XML declaration */
2410 ctx = xmlSaveToIO(domdoc_save_writecallback, domdoc_save_closecallback,
2411 handle, NULL, XML_SAVE_NO_DECL);
2412 if (!ctx)
2413 {
2414 CloseHandle(handle);
2415 return E_FAIL;
2416 }
2417 }
2418 break;
2419
2420 default:
2421 FIXME("Unhandled VARIANT: %s\n", debugstr_variant(&destination));
2422 return S_FALSE;
2423 }
2424
2425 xmldecl = xmldoc_unlink_xmldecl(get_doc(This));
2426 if (xmlSaveDoc(ctx, get_doc(This)) == -1) ret = S_FALSE;
2427 xmldoc_link_xmldecl(get_doc(This), xmldecl);
2428
2429 /* will release resources through close callback */
2430 xmlSaveClose(ctx);
2431
2432 return ret;
2433 }
2434
2435 static HRESULT WINAPI domdoc_get_validateOnParse(
2436 IXMLDOMDocument3 *iface,
2437 VARIANT_BOOL* isValidating )
2438 {
2439 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2440 TRACE("(%p)->(%p: %d)\n", This, isValidating, This->validating);
2441 *isValidating = This->validating;
2442 return S_OK;
2443 }
2444
2445
2446 static HRESULT WINAPI domdoc_put_validateOnParse(
2447 IXMLDOMDocument3 *iface,
2448 VARIANT_BOOL isValidating )
2449 {
2450 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2451 TRACE("(%p)->(%d)\n", This, isValidating);
2452 This->validating = isValidating;
2453 return S_OK;
2454 }
2455
2456
2457 static HRESULT WINAPI domdoc_get_resolveExternals(
2458 IXMLDOMDocument3 *iface,
2459 VARIANT_BOOL* isResolving )
2460 {
2461 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2462 TRACE("(%p)->(%p: %d)\n", This, isResolving, This->resolving);
2463 *isResolving = This->resolving;
2464 return S_OK;
2465 }
2466
2467
2468 static HRESULT WINAPI domdoc_put_resolveExternals(
2469 IXMLDOMDocument3 *iface,
2470 VARIANT_BOOL isResolving )
2471 {
2472 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2473 TRACE("(%p)->(%d)\n", This, isResolving);
2474 This->resolving = isResolving;
2475 return S_OK;
2476 }
2477
2478
2479 static HRESULT WINAPI domdoc_get_preserveWhiteSpace(
2480 IXMLDOMDocument3 *iface,
2481 VARIANT_BOOL* isPreserving )
2482 {
2483 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2484 TRACE("(%p)->(%p: %d)\n", This, isPreserving, This->properties->preserving);
2485 *isPreserving = This->properties->preserving;
2486 return S_OK;
2487 }
2488
2489
2490 static HRESULT WINAPI domdoc_put_preserveWhiteSpace(
2491 IXMLDOMDocument3 *iface,
2492 VARIANT_BOOL isPreserving )
2493 {
2494 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2495 TRACE("(%p)->(%d)\n", This, isPreserving);
2496 This->properties->preserving = isPreserving;
2497 return S_OK;
2498 }
2499
2500
2501 static HRESULT WINAPI domdoc_put_onreadystatechange(
2502 IXMLDOMDocument3 *iface,
2503 VARIANT event )
2504 {
2505 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2506
2507 TRACE("(%p)->(%s)\n", This, debugstr_variant(&event));
2508 return set_doc_event(This, EVENTID_READYSTATECHANGE, &event);
2509 }
2510
2511
2512 static HRESULT WINAPI domdoc_put_onDataAvailable(IXMLDOMDocument3 *iface, VARIANT sink)
2513 {
2514 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2515 FIXME("(%p)->(%s): stub\n", This, debugstr_variant(&sink));
2516 return E_NOTIMPL;
2517 }
2518
2519 static HRESULT WINAPI domdoc_put_onTransformNode(IXMLDOMDocument3 *iface, VARIANT sink )
2520 {
2521 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2522 FIXME("(%p)->(%s): stub\n", This, debugstr_variant(&sink));
2523 return E_NOTIMPL;
2524 }
2525
2526 static HRESULT WINAPI domdoc_get_namespaces(
2527 IXMLDOMDocument3* iface,
2528 IXMLDOMSchemaCollection** collection )
2529 {
2530 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2531 HRESULT hr;
2532
2533 FIXME("(%p)->(%p): semi-stub\n", This, collection);
2534
2535 if (!collection) return E_POINTER;
2536
2537 if (!This->namespaces)
2538 {
2539 hr = SchemaCache_create(This->properties->version, NULL, (void**)&This->namespaces);
2540 if (hr != S_OK) return hr;
2541
2542 hr = cache_from_doc_ns(This->namespaces, &This->node);
2543 if (hr != S_OK)
2544 release_namespaces(This);
2545 }
2546
2547 if (This->namespaces)
2548 return IXMLDOMSchemaCollection2_QueryInterface(This->namespaces,
2549 &IID_IXMLDOMSchemaCollection, (void**)collection);
2550
2551 return hr;
2552 }
2553
2554 static HRESULT WINAPI domdoc_get_schemas(
2555 IXMLDOMDocument3* iface,
2556 VARIANT* var1 )
2557 {
2558 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2559 HRESULT hr = S_FALSE;
2560 IXMLDOMSchemaCollection2* cur_schema = This->properties->schemaCache;
2561
2562 TRACE("(%p)->(%p)\n", This, var1);
2563
2564 VariantInit(var1); /* Test shows we don't call VariantClear here */
2565 V_VT(var1) = VT_NULL;
2566
2567 if(cur_schema)
2568 {
2569 hr = IXMLDOMSchemaCollection2_QueryInterface(cur_schema, &IID_IDispatch, (void**)&V_DISPATCH(var1));
2570 if(SUCCEEDED(hr))
2571 V_VT(var1) = VT_DISPATCH;
2572 }
2573 return hr;
2574 }
2575
2576 static HRESULT WINAPI domdoc_putref_schemas(
2577 IXMLDOMDocument3* iface,
2578 VARIANT schema)
2579 {
2580 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2581 HRESULT hr = E_FAIL;
2582 IXMLDOMSchemaCollection2* new_schema = NULL;
2583
2584 FIXME("(%p)->(%s): semi-stub\n", This, debugstr_variant(&schema));
2585 switch(V_VT(&schema))
2586 {
2587 case VT_UNKNOWN:
2588 hr = IUnknown_QueryInterface(V_UNKNOWN(&schema), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
2589 break;
2590
2591 case VT_DISPATCH:
2592 hr = IDispatch_QueryInterface(V_DISPATCH(&schema), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
2593 break;
2594
2595 case VT_NULL:
2596 case VT_EMPTY:
2597 hr = S_OK;
2598 break;
2599
2600 default:
2601 WARN("Can't get schema from vt %x\n", V_VT(&schema));
2602 }
2603
2604 if(SUCCEEDED(hr))
2605 {
2606 IXMLDOMSchemaCollection2* old_schema = InterlockedExchangePointer((void**)&This->properties->schemaCache, new_schema);
2607 if(old_schema) IXMLDOMSchemaCollection2_Release(old_schema);
2608 }
2609
2610 return hr;
2611 }
2612
2613 static inline BOOL is_wellformed(xmlDocPtr doc)
2614 {
2615 #ifdef HAVE_XMLDOC_PROPERTIES
2616 return doc->properties & XML_DOC_WELLFORMED;
2617 #else
2618 /* Not a full check, but catches the worst violations */
2619 xmlNodePtr child;
2620 int root = 0;
2621
2622 for (child = doc->children; child != NULL; child = child->next)
2623 {
2624 switch (child->type)
2625 {
2626 case XML_ELEMENT_NODE:
2627 if (++root > 1)
2628 return FALSE;
2629 break;
2630 case XML_TEXT_NODE:
2631 case XML_CDATA_SECTION_NODE:
2632 return FALSE;
2633 break;
2634 default:
2635 break;
2636 }
2637 }
2638
2639 return root == 1;
2640 #endif
2641 }
2642
2643 static void LIBXML2_LOG_CALLBACK validate_error(void* ctx, char const* msg, ...)
2644 {
2645 va_list ap;
2646 va_start(ap, msg);
2647 LIBXML2_CALLBACK_ERR(domdoc_validateNode, msg, ap);
2648 va_end(ap);
2649 }
2650
2651 static void LIBXML2_LOG_CALLBACK validate_warning(void* ctx, char const* msg, ...)
2652 {
2653 va_list ap;
2654 va_start(ap, msg);
2655 LIBXML2_CALLBACK_WARN(domdoc_validateNode, msg, ap);
2656 va_end(ap);
2657 }
2658
2659 static HRESULT WINAPI domdoc_validateNode(
2660 IXMLDOMDocument3* iface,
2661 IXMLDOMNode* node,
2662 IXMLDOMParseError** err)
2663 {
2664 domdoc* This = impl_from_IXMLDOMDocument3(iface);
2665 LONG state, err_code = 0;
2666 HRESULT hr = S_OK;
2667 int validated = 0;
2668
2669 TRACE("(%p)->(%p, %p)\n", This, node, err);
2670 IXMLDOMDocument3_get_readyState(iface, &state);
2671 if (state != READYSTATE_COMPLETE)
2672 {
2673 if (err)
2674 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2675 return E_PENDING;
2676 }
2677
2678 if (!node)
2679 {
2680 if (err)
2681 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2682 return E_POINTER;
2683 }
2684
2685 if (!get_node_obj(node)->node || get_node_obj(node)->node->doc != get_doc(This))
2686 {
2687 if (err)
2688 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2689 return E_FAIL;
2690 }
2691
2692 if (!is_wellformed(get_doc(This)))
2693 {
2694 ERR("doc not well-formed\n");
2695 if (err)
2696 *err = create_parseError(E_XML_NOTWF, NULL, NULL, NULL, 0, 0, 0);
2697 return S_FALSE;
2698 }
2699
2700 /* DTD validation */
2701 if (get_doc(This)->intSubset || get_doc(This)->extSubset)
2702 {
2703 xmlValidCtxtPtr vctx = xmlNewValidCtxt();
2704 vctx->error = validate_error;
2705 vctx->warning = validate_warning;
2706 ++validated;
2707
2708 if (!((node == (IXMLDOMNode*)iface)?
2709 xmlValidateDocument(vctx, get_doc(This)) :
2710 xmlValidateElement(vctx, get_doc(This), get_node_obj(node)->node)))
2711 {
2712 /* TODO: get a real error code here */
2713 TRACE("DTD validation failed\n");
2714 err_code = E_XML_INVALID;
2715 hr = S_FALSE;
2716 }
2717 xmlFreeValidCtxt(vctx);
2718 }
2719
2720 /* Schema validation */
2721 if (hr == S_OK && This->properties->schemaCache != NULL)
2722 {
2723
2724 hr = SchemaCache_validate_tree(This->properties->schemaCache, get_node_obj(node)->node);
2725 if (SUCCEEDED(hr))
2726 {
2727 ++validated;
2728 /* TODO: get a real error code here */
2729 if (hr == S_OK)
2730 {
2731 TRACE("schema validation succeeded\n");
2732 }
2733 else
2734 {
2735 ERR("schema validation failed\n");
2736 err_code = E_XML_INVALID;
2737 }
2738 }
2739 else
2740 {
2741 /* not really OK, just didn't find a schema for the ns */
2742 hr = S_OK;
2743 }
2744 }
2745
2746 if (!validated)
2747 {
2748 ERR("no DTD or schema found\n");
2749 err_code = E_XML_NODTD;
2750 hr = S_FALSE;
2751 }
2752
2753 if (err)
2754 *err = create_parseError(err_code, NULL, NULL, NULL, 0, 0, 0);
2755
2756 return hr;
2757 }
2758
2759 static HRESULT WINAPI domdoc_validate(
2760 IXMLDOMDocument3* iface,
2761 IXMLDOMParseError** err)
2762 {
2763 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2764 TRACE("(%p)->(%p)\n", This, err);
2765 return IXMLDOMDocument3_validateNode(iface, (IXMLDOMNode*)iface, err);
2766 }
2767
2768 static HRESULT WINAPI domdoc_setProperty(
2769 IXMLDOMDocument3* iface,
2770 BSTR p,
2771 VARIANT value)
2772 {
2773 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2774
2775 TRACE("(%p)->(%s %s)\n", This, debugstr_w(p), debugstr_variant(&value));
2776
2777 if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
2778 {
2779 VARIANT varStr;
2780 HRESULT hr;
2781 BSTR bstr;
2782
2783 V_VT(&varStr) = VT_EMPTY;
2784 if (V_VT(&value) != VT_BSTR)
2785 {
2786 if (FAILED(hr = VariantChangeType(&varStr, &value, 0, VT_BSTR)))
2787 return hr;
2788 bstr = V_BSTR(&varStr);
2789 }
2790 else
2791 bstr = V_BSTR(&value);
2792
2793 hr = S_OK;
2794 if (lstrcmpiW(bstr, PropValueXPathW) == 0)
2795 This->properties->XPath = TRUE;
2796 else if (lstrcmpiW(bstr, PropValueXSLPatternW) == 0)
2797 This->properties->XPath = FALSE;
2798 else
2799 hr = E_FAIL;
2800
2801 VariantClear(&varStr);
2802 return hr;
2803 }
2804 else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
2805 {
2806 xmlChar *nsStr = (xmlChar*)This->properties->selectNsStr;
2807 struct list *pNsList;
2808 VARIANT varStr;
2809 HRESULT hr;
2810 BSTR bstr;
2811
2812 V_VT(&varStr) = VT_EMPTY;
2813 if (V_VT(&value) != VT_BSTR)
2814 {
2815 if (FAILED(hr = VariantChangeType(&varStr, &value, 0, VT_BSTR)))
2816 return hr;
2817 bstr = V_BSTR(&varStr);
2818 }
2819 else
2820 bstr = V_BSTR(&value);
2821
2822 hr = S_OK;
2823
2824 pNsList = &(This->properties->selectNsList);
2825 clear_selectNsList(pNsList);
2826 heap_free(nsStr);
2827 nsStr = xmlchar_from_wchar(bstr);
2828
2829 TRACE("property value: \"%s\"\n", debugstr_w(bstr));
2830
2831 This->properties->selectNsStr = nsStr;
2832 This->properties->selectNsStr_len = xmlStrlen(nsStr);
2833 if (bstr && *bstr)
2834 {
2835 xmlChar *pTokBegin, *pTokEnd, *pTokInner;
2836 select_ns_entry* ns_entry = NULL;
2837 xmlXPathContextPtr ctx;
2838
2839 ctx = xmlXPathNewContext(This->node.node->doc);
2840 pTokBegin = nsStr;
2841
2842 /* skip leading spaces */
2843 while (*pTokBegin == ' ' || *pTokBegin == '\n' ||
2844 *pTokBegin == '\t' || *pTokBegin == '\r')
2845 ++pTokBegin;
2846
2847 for (; *pTokBegin; pTokBegin = pTokEnd)
2848 {
2849 if (ns_entry)
2850 memset(ns_entry, 0, sizeof(select_ns_entry));
2851 else
2852 ns_entry = heap_alloc_zero(sizeof(select_ns_entry));
2853
2854 while (*pTokBegin == ' ')
2855 ++pTokBegin;
2856 pTokEnd = pTokBegin;
2857 while (*pTokEnd != ' ' && *pTokEnd != 0)
2858 ++pTokEnd;
2859
2860 if (xmlStrncmp(pTokBegin, (xmlChar const*)"xmlns", 5) != 0)
2861 {
2862 hr = E_FAIL;
2863 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2864 debugstr_w(bstr), debugstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
2865 continue;
2866 }
2867
2868 pTokBegin += 5;
2869 if (*pTokBegin == '=')
2870 {
2871 /*valid for XSLPattern?*/
2872 FIXME("Setting default xmlns not supported - skipping.\n");
2873 continue;
2874 }
2875 else if (*pTokBegin == ':')
2876 {
2877 ns_entry->prefix = ++pTokBegin;
2878 for (pTokInner = pTokBegin; pTokInner != pTokEnd && *pTokInner != '='; ++pTokInner)
2879 ;
2880
2881 if (pTokInner == pTokEnd)
2882 {
2883 hr = E_FAIL;
2884 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2885 debugstr_w(bstr), debugstr_an((const char*)pTokBegin, pTokEnd-pTokBegin));
2886 continue;
2887 }
2888
2889 ns_entry->prefix_end = *pTokInner;
2890 *pTokInner = 0;
2891 ++pTokInner;
2892
2893 if (pTokEnd-pTokInner > 1 &&
2894 ((*pTokInner == '\'' && *(pTokEnd-1) == '\'') ||
2895 (*pTokInner == '"' && *(pTokEnd-1) == '"')))
2896 {
2897 ns_entry->href = ++pTokInner;
2898 ns_entry->href_end = *(pTokEnd-1);
2899 *(pTokEnd-1) = 0;
2900 list_add_tail(pNsList, &ns_entry->entry);
2901 /*let libxml figure out if they're valid from here ;)*/
2902 if (xmlXPathRegisterNs(ctx, ns_entry->prefix, ns_entry->href) != 0)
2903 {
2904 hr = E_FAIL;
2905 }
2906 ns_entry = NULL;
2907 continue;
2908 }
2909 else
2910 {
2911 WARN("Syntax error in xmlns string: %s\n\tat token: %s\n",
2912 debugstr_w(bstr), debugstr_an((const char*)pTokInner, pTokEnd-pTokInner));
2913 list_add_tail(pNsList, &ns_entry->entry);
2914
2915 ns_entry = NULL;
2916 hr = E_FAIL;
2917 continue;
2918 }
2919 }
2920 else
2921 {
2922 hr = E_FAIL;
2923 continue;
2924 }
2925 }
2926 heap_free(ns_entry);
2927 xmlXPathFreeContext(ctx);
2928 }
2929
2930 VariantClear(&varStr);
2931 return hr;
2932 }
2933 else if (lstrcmpiW(p, PropertyProhibitDTDW) == 0 ||
2934 lstrcmpiW(p, PropertyNewParserW) == 0 ||
2935 lstrcmpiW(p, PropertyResolveExternalsW) == 0)
2936 {
2937 /* Ignore */
2938 FIXME("Ignoring property %s, value %d\n", debugstr_w(p), V_BOOL(&value));
2939 return S_OK;
2940 }
2941
2942 FIXME("Unknown property %s\n", debugstr_w(p));
2943 return E_FAIL;
2944 }
2945
2946 static HRESULT WINAPI domdoc_getProperty(
2947 IXMLDOMDocument3* iface,
2948 BSTR p,
2949 VARIANT* var)
2950 {
2951 domdoc *This = impl_from_IXMLDOMDocument3( iface );
2952
2953 TRACE("(%p)->(%s)\n", This, debugstr_w(p));
2954
2955 if (!var)
2956 return E_INVALIDARG;
2957
2958 if (lstrcmpiW(p, PropertySelectionLanguageW) == 0)
2959 {
2960 V_VT(var) = VT_BSTR;
2961 V_BSTR(var) = This->properties->XPath ?
2962 SysAllocString(PropValueXPathW) :
2963 SysAllocString(PropValueXSLPatternW);
2964 return V_BSTR(var) ? S_OK : E_OUTOFMEMORY;
2965 }
2966 else if (lstrcmpiW(p, PropertySelectionNamespacesW) == 0)
2967 {
2968 int lenA, lenW;
2969 BSTR rebuiltStr, cur;
2970 const xmlChar *nsStr;
2971 struct list *pNsList;
2972 select_ns_entry* pNsEntry;
2973
2974 V_VT(var) = VT_BSTR;
2975 nsStr = This->properties->selectNsStr;
2976 pNsList = &This->properties->selectNsList;
2977 lenA = This->properties->selectNsStr_len;
2978 lenW = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, NULL, 0);
2979 rebuiltStr = heap_alloc(lenW*sizeof(WCHAR));
2980 MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)nsStr, lenA+1, rebuiltStr, lenW);
2981 cur = rebuiltStr;
2982 /* this is fine because all of the chars that end tokens are ASCII*/
2983 LIST_FOR_EACH_ENTRY(pNsEntry, pNsList, select_ns_entry, entry)
2984 {
2985 while (*cur != 0) ++cur;
2986 if (pNsEntry->prefix_end)
2987 {
2988 *cur = pNsEntry->prefix_end;
2989 while (*cur != 0) ++cur;
2990 }
2991
2992 if (pNsEntry->href_end)
2993 {
2994 *cur = pNsEntry->href_end;
2995 }
2996 }
2997 V_BSTR(var) = SysAllocString(rebuiltStr);
2998 heap_free(rebuiltStr);
2999 return S_OK;
3000 }
3001
3002 FIXME("Unknown property %s\n", debugstr_w(p));
3003 return E_FAIL;
3004 }
3005
3006 static HRESULT WINAPI domdoc_importNode(
3007 IXMLDOMDocument3* iface,
3008 IXMLDOMNode* node,
3009 VARIANT_BOOL deep,
3010 IXMLDOMNode** clone)
3011 {
3012 domdoc *This = impl_from_IXMLDOMDocument3( iface );
3013 FIXME("(%p)->(%p %d %p): stub\n", This, node, deep, clone);
3014 return E_NOTIMPL;
3015 }
3016
3017 static const struct IXMLDOMDocument3Vtbl XMLDOMDocument3Vtbl =
3018 {
3019 domdoc_QueryInterface,
3020 domdoc_AddRef,
3021 domdoc_Release,
3022 domdoc_GetTypeInfoCount,
3023 domdoc_GetTypeInfo,
3024 domdoc_GetIDsOfNames,
3025 domdoc_Invoke,
3026 domdoc_get_nodeName,
3027 domdoc_get_nodeValue,
3028 domdoc_put_nodeValue,
3029 domdoc_get_nodeType,
3030 domdoc_get_parentNode,
3031 domdoc_get_childNodes,
3032 domdoc_get_firstChild,
3033 domdoc_get_lastChild,
3034 domdoc_get_previousSibling,
3035 domdoc_get_nextSibling,
3036 domdoc_get_attributes,
3037 domdoc_insertBefore,
3038 domdoc_replaceChild,
3039 domdoc_removeChild,
3040 domdoc_appendChild,
3041 domdoc_hasChildNodes,
3042 domdoc_get_ownerDocument,
3043 domdoc_cloneNode,
3044 domdoc_get_nodeTypeString,
3045 domdoc_get_text,
3046 domdoc_put_text,
3047 domdoc_get_specified,
3048 domdoc_get_definition,
3049 domdoc_get_nodeTypedValue,
3050 domdoc_put_nodeTypedValue,
3051 domdoc_get_dataType,
3052 domdoc_put_dataType,
3053 domdoc_get_xml,
3054 domdoc_transformNode,
3055 domdoc_selectNodes,
3056 domdoc_selectSingleNode,
3057 domdoc_get_parsed,
3058 domdoc_get_namespaceURI,
3059 domdoc_get_prefix,
3060 domdoc_get_baseName,
3061 domdoc_transformNodeToObject,
3062 domdoc_get_doctype,
3063 domdoc_get_implementation,
3064 domdoc_get_documentElement,
3065 domdoc_put_documentElement,
3066 domdoc_createElement,
3067 domdoc_createDocumentFragment,
3068 domdoc_createTextNode,
3069 domdoc_createComment,
3070 domdoc_createCDATASection,
3071 domdoc_createProcessingInstruction,
3072 domdoc_createAttribute,
3073 domdoc_createEntityReference,
3074 domdoc_getElementsByTagName,
3075 domdoc_createNode,
3076 domdoc_nodeFromID,
3077 domdoc_load,
3078 domdoc_get_readyState,
3079 domdoc_get_parseError,
3080 domdoc_get_url,
3081 domdoc_get_async,
3082 domdoc_put_async,
3083 domdoc_abort,
3084 domdoc_loadXML,
3085 domdoc_save,
3086 domdoc_get_validateOnParse,
3087 domdoc_put_validateOnParse,
3088 domdoc_get_resolveExternals,
3089 domdoc_put_resolveExternals,
3090 domdoc_get_preserveWhiteSpace,
3091 domdoc_put_preserveWhiteSpace,
3092 domdoc_put_onreadystatechange,
3093 domdoc_put_onDataAvailable,
3094 domdoc_put_onTransformNode,
3095 domdoc_get_namespaces,
3096 domdoc_get_schemas,
3097 domdoc_putref_schemas,
3098 domdoc_validate,
3099 domdoc_setProperty,
3100 domdoc_getProperty,
3101 domdoc_validateNode,
3102 domdoc_importNode
3103 };
3104
3105 /* IConnectionPointContainer */
3106 static HRESULT WINAPI ConnectionPointContainer_QueryInterface(IConnectionPointContainer *iface,
3107 REFIID riid, void **ppv)
3108 {
3109 domdoc *This = impl_from_IConnectionPointContainer(iface);
3110 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppv);
3111 }
3112
3113 static ULONG WINAPI ConnectionPointContainer_AddRef(IConnectionPointContainer *iface)
3114 {
3115 domdoc *This = impl_from_IConnectionPointContainer(iface);
3116 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
3117 }
3118
3119 static ULONG WINAPI ConnectionPointContainer_Release(IConnectionPointContainer *iface)
3120 {
3121 domdoc *This = impl_from_IConnectionPointContainer(iface);
3122 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
3123 }
3124
3125 static HRESULT WINAPI ConnectionPointContainer_EnumConnectionPoints(IConnectionPointContainer *iface,
3126 IEnumConnectionPoints **ppEnum)
3127 {
3128 domdoc *This = impl_from_IConnectionPointContainer(iface);
3129 FIXME("(%p)->(%p): stub\n", This, ppEnum);
3130 return E_NOTIMPL;
3131 }
3132
3133 static HRESULT WINAPI ConnectionPointContainer_FindConnectionPoint(IConnectionPointContainer *iface,
3134 REFIID riid, IConnectionPoint **cp)
3135 {
3136 domdoc *This = impl_from_IConnectionPointContainer(iface);
3137 ConnectionPoint *iter;
3138
3139 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), cp);
3140
3141 *cp = NULL;
3142
3143 for(iter = This->cp_list; iter; iter = iter->next)
3144 {
3145 if (IsEqualGUID(iter->iid, riid))
3146 *cp = &iter->IConnectionPoint_iface;
3147 }
3148
3149 if (*cp)
3150 {
3151 IConnectionPoint_AddRef(*cp);
3152 return S_OK;
3153 }
3154
3155 FIXME("unsupported riid %s\n", debugstr_guid(riid));
3156 return CONNECT_E_NOCONNECTION;
3157
3158 }
3159
3160 static const struct IConnectionPointContainerVtbl ConnectionPointContainerVtbl =
3161 {
3162 ConnectionPointContainer_QueryInterface,
3163 ConnectionPointContainer_AddRef,
3164 ConnectionPointContainer_Release,
3165 ConnectionPointContainer_EnumConnectionPoints,
3166 ConnectionPointContainer_FindConnectionPoint
3167 };
3168
3169 /* IConnectionPoint */
3170 static HRESULT WINAPI ConnectionPoint_QueryInterface(IConnectionPoint *iface,
3171 REFIID riid, void **ppv)
3172 {
3173 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3174
3175 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv );
3176
3177 *ppv = NULL;
3178
3179 if (IsEqualGUID(&IID_IUnknown, riid) ||
3180 IsEqualGUID(&IID_IConnectionPoint, riid))
3181 {
3182 *ppv = iface;
3183 }
3184
3185 if (*ppv)
3186 {
3187 IConnectionPoint_AddRef(iface);
3188 return S_OK;
3189 }
3190
3191 WARN("Unsupported interface %s\n", debugstr_guid(riid));
3192 return E_NOINTERFACE;
3193 }
3194
3195 static ULONG WINAPI ConnectionPoint_AddRef(IConnectionPoint *iface)
3196 {
3197 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3198 return IConnectionPointContainer_AddRef(This->container);
3199 }
3200
3201 static ULONG WINAPI ConnectionPoint_Release(IConnectionPoint *iface)
3202 {
3203 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3204 return IConnectionPointContainer_Release(This->container);
3205 }
3206
3207 static HRESULT WINAPI ConnectionPoint_GetConnectionInterface(IConnectionPoint *iface, IID *iid)
3208 {
3209 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3210
3211 TRACE("(%p)->(%p)\n", This, iid);
3212
3213 if (!iid) return E_POINTER;
3214
3215 *iid = *This->iid;
3216 return S_OK;
3217 }
3218
3219 static HRESULT WINAPI ConnectionPoint_GetConnectionPointContainer(IConnectionPoint *iface,
3220 IConnectionPointContainer **container)
3221 {
3222 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3223
3224 TRACE("(%p)->(%p)\n", This, container);
3225
3226 if (!container) return E_POINTER;
3227
3228 *container = This->container;
3229 IConnectionPointContainer_AddRef(*container);
3230 return S_OK;
3231 }
3232
3233 static HRESULT WINAPI ConnectionPoint_Advise(IConnectionPoint *iface, IUnknown *pUnkSink,
3234 DWORD *pdwCookie)
3235 {
3236 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3237 FIXME("(%p)->(%p %p): stub\n", This, pUnkSink, pdwCookie);
3238 return E_NOTIMPL;
3239 }
3240
3241 static HRESULT WINAPI ConnectionPoint_Unadvise(IConnectionPoint *iface, DWORD cookie)
3242 {
3243 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3244
3245 TRACE("(%p)->(%d)\n", This, cookie);
3246
3247 if (cookie == 0 || cookie > This->sinks_size || !This->sinks[cookie-1].unk)
3248 return CONNECT_E_NOCONNECTION;
3249
3250 IUnknown_Release(This->sinks[cookie-1].unk);
3251 This->sinks[cookie-1].unk = NULL;
3252
3253 return S_OK;
3254 }
3255
3256 static HRESULT WINAPI ConnectionPoint_EnumConnections(IConnectionPoint *iface,
3257 IEnumConnections **ppEnum)
3258 {
3259 ConnectionPoint *This = impl_from_IConnectionPoint(iface);
3260 FIXME("(%p)->(%p): stub\n", This, ppEnum);
3261 return E_NOTIMPL;
3262 }
3263
3264 static const IConnectionPointVtbl ConnectionPointVtbl =
3265 {
3266 ConnectionPoint_QueryInterface,
3267 ConnectionPoint_AddRef,
3268 ConnectionPoint_Release,
3269 ConnectionPoint_GetConnectionInterface,
3270 ConnectionPoint_GetConnectionPointContainer,
3271 ConnectionPoint_Advise,
3272 ConnectionPoint_Unadvise,
3273 ConnectionPoint_EnumConnections
3274 };
3275
3276 static void ConnectionPoint_Init(ConnectionPoint *cp, struct domdoc *doc, REFIID riid)
3277 {
3278 cp->IConnectionPoint_iface.lpVtbl = &ConnectionPointVtbl;
3279 cp->doc = doc;
3280 cp->iid = riid;
3281 cp->sinks = NULL;
3282 cp->sinks_size = 0;
3283
3284 cp->next = doc->cp_list;
3285 doc->cp_list = cp;
3286
3287 cp->container = &doc->IConnectionPointContainer_iface;
3288 }
3289
3290 /* domdoc implementation of IObjectWithSite */
3291 static HRESULT WINAPI
3292 domdoc_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
3293 {
3294 domdoc *This = impl_from_IObjectWithSite(iface);
3295 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppvObject);
3296 }
3297
3298 static ULONG WINAPI domdoc_ObjectWithSite_AddRef( IObjectWithSite* iface )
3299 {
3300 domdoc *This = impl_from_IObjectWithSite(iface);
3301 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
3302 }
3303
3304 static ULONG WINAPI domdoc_ObjectWithSite_Release( IObjectWithSite* iface )
3305 {
3306 domdoc *This = impl_from_IObjectWithSite(iface);
3307 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
3308 }
3309
3310 static HRESULT WINAPI domdoc_ObjectWithSite_GetSite( IObjectWithSite *iface, REFIID iid, void **ppvSite )
3311 {
3312 domdoc *This = impl_from_IObjectWithSite(iface);
3313
3314 TRACE("(%p)->(%s %p)\n", This, debugstr_guid( iid ), ppvSite );
3315
3316 if ( !This->site )
3317 return E_FAIL;
3318
3319 return IUnknown_QueryInterface( This->site, iid, ppvSite );
3320 }
3321
3322 static HRESULT WINAPI domdoc_ObjectWithSite_SetSite( IObjectWithSite *iface, IUnknown *punk )
3323 {
3324 domdoc *This = impl_from_IObjectWithSite(iface);
3325
3326 TRACE("(%p)->(%p)\n", iface, punk);
3327
3328 if(!punk)
3329 {
3330 if(This->site)
3331 {
3332 IUnknown_Release( This->site );
3333 This->site = NULL;
3334 }
3335
3336 return S_OK;
3337 }
3338
3339 IUnknown_AddRef( punk );
3340
3341 if(This->site)
3342 IUnknown_Release( This->site );
3343
3344 This->site = punk;
3345
3346 return S_OK;
3347 }
3348
3349 static const IObjectWithSiteVtbl domdocObjectSite =
3350 {
3351 domdoc_ObjectWithSite_QueryInterface,
3352 domdoc_ObjectWithSite_AddRef,
3353 domdoc_ObjectWithSite_Release,
3354 domdoc_ObjectWithSite_SetSite,
3355 domdoc_ObjectWithSite_GetSite
3356 };
3357
3358 static HRESULT WINAPI domdoc_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
3359 {
3360 domdoc *This = impl_from_IObjectSafety(iface);
3361 return IXMLDOMDocument3_QueryInterface(&This->IXMLDOMDocument3_iface, riid, ppv);
3362 }
3363
3364 static ULONG WINAPI domdoc_Safety_AddRef(IObjectSafety *iface)
3365 {
3366 domdoc *This = impl_from_IObjectSafety(iface);
3367 return IXMLDOMDocument3_AddRef(&This->IXMLDOMDocument3_iface);
3368 }
3369
3370 static ULONG WINAPI domdoc_Safety_Release(IObjectSafety *iface)
3371 {
3372 domdoc *This = impl_from_IObjectSafety(iface);
3373 return IXMLDOMDocument3_Release(&This->IXMLDOMDocument3_iface);
3374 }
3375
3376 #define SAFETY_SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)
3377
3378 static HRESULT WINAPI domdoc_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
3379 DWORD *supported, DWORD *enabled)
3380 {
3381 domdoc *This = impl_from_IObjectSafety(iface);
3382
3383 TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), supported, enabled);
3384
3385 if(!supported || !enabled) return E_POINTER;
3386
3387 *supported = SAFETY_SUPPORTED_OPTIONS;
3388 *enabled = This->safeopt;
3389
3390 return S_OK;
3391 }
3392
3393 static HRESULT WINAPI domdoc_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
3394 DWORD mask, DWORD enabled)
3395 {
3396 domdoc *This = impl_from_IObjectSafety(iface);
3397 TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), mask, enabled);
3398
3399 if ((mask & ~SAFETY_SUPPORTED_OPTIONS) != 0)
3400 return E_FAIL;
3401
3402 This->safeopt = (This->safeopt & ~mask) | (mask & enabled);
3403
3404 return S_OK;
3405 }
3406
3407 #undef SAFETY_SUPPORTED_OPTIONS
3408
3409 static const IObjectSafetyVtbl domdocObjectSafetyVtbl = {
3410 domdoc_Safety_QueryInterface,
3411 domdoc_Safety_AddRef,
3412 domdoc_Safety_Release,
3413 domdoc_Safety_GetInterfaceSafetyOptions,
3414 domdoc_Safety_SetInterfaceSafetyOptions
3415 };
3416
3417 static const tid_t domdoc_iface_tids[] = {
3418 IXMLDOMDocument3_tid,
3419 0
3420 };
3421
3422 static dispex_static_data_t domdoc_dispex = {
3423 NULL,
3424 IXMLDOMDocument3_tid,
3425 NULL,
3426 domdoc_iface_tids
3427 };
3428
3429 HRESULT get_domdoc_from_xmldoc(xmlDocPtr xmldoc, IXMLDOMDocument3 **document)
3430 {
3431 domdoc *doc;
3432
3433 doc = heap_alloc( sizeof (*doc) );
3434 if( !doc )
3435 return E_OUTOFMEMORY;
3436
3437 doc->IXMLDOMDocument3_iface.lpVtbl = &XMLDOMDocument3Vtbl;
3438 doc->IPersistStreamInit_iface.lpVtbl = &xmldoc_IPersistStreamInit_VTable;
3439 doc->IObjectWithSite_iface.lpVtbl = &domdocObjectSite;
3440 doc->IObjectSafety_iface.lpVtbl = &domdocObjectSafetyVtbl;
3441 doc->IConnectionPointContainer_iface.lpVtbl = &ConnectionPointContainerVtbl;
3442 doc->ref = 1;
3443 doc->async = VARIANT_TRUE;
3444 doc->validating = 0;
3445 doc->resolving = 0;
3446 doc->properties = properties_from_xmlDocPtr(xmldoc);
3447 doc->error = S_OK;
3448 doc->stream = NULL;
3449 doc->site = NULL;
3450 doc->safeopt = 0;
3451 doc->bsc = NULL;
3452 doc->cp_list = NULL;
3453 doc->namespaces = NULL;
3454 memset(doc->events, 0, sizeof(doc->events));
3455
3456 /* events connection points */
3457 ConnectionPoint_Init(&doc->cp_dispatch, doc, &IID_IDispatch);
3458 ConnectionPoint_Init(&doc->cp_propnotif, doc, &IID_IPropertyNotifySink);
3459 ConnectionPoint_Init(&doc->cp_domdocevents, doc, &DIID_XMLDOMDocumentEvents);
3460
3461 init_xmlnode(&doc->node, (xmlNodePtr)xmldoc, (IXMLDOMNode*)&doc->IXMLDOMDocument3_iface,
3462 &domdoc_dispex);
3463
3464 *document = &doc->IXMLDOMDocument3_iface;
3465
3466 TRACE("returning iface %p\n", *document);
3467 return S_OK;
3468 }
3469
3470 HRESULT DOMDocument_create(MSXML_VERSION version, IUnknown *pUnkOuter, void **ppObj)
3471 {
3472 xmlDocPtr xmldoc;
3473 HRESULT hr;
3474
3475 TRACE("(%d, %p, %p)\n", version, pUnkOuter, ppObj);
3476
3477 xmldoc = xmlNewDoc(NULL);
3478 if(!xmldoc)
3479 return E_OUTOFMEMORY;
3480
3481 xmldoc_init(xmldoc, version);
3482
3483 hr = get_domdoc_from_xmldoc(xmldoc, (IXMLDOMDocument3**)ppObj);
3484 if(FAILED(hr))
3485 {
3486 free_properties(properties_from_xmlDocPtr(xmldoc));
3487 heap_free(xmldoc->_private);
3488 xmlFreeDoc(xmldoc);
3489 return hr;
3490 }
3491
3492 return hr;
3493 }
3494
3495 IUnknown* create_domdoc( xmlNodePtr document )
3496 {
3497 void* pObj = NULL;
3498 HRESULT hr;
3499
3500 TRACE("(%p)\n", document);
3501
3502 hr = get_domdoc_from_xmldoc((xmlDocPtr)document, (IXMLDOMDocument3**)&pObj);
3503 if (FAILED(hr))
3504 return NULL;
3505
3506 return pObj;
3507 }
3508
3509 #else
3510
3511 HRESULT DOMDocument_create(MSXML_VERSION version, IUnknown *pUnkOuter, void **ppObj)
3512 {
3513 MESSAGE("This program tried to use a DOMDocument object, but\n"
3514 "libxml2 support was not present at compile time.\n");
3515 return E_NOTIMPL;
3516 }
3517
3518 #endif
Maarten's multimedia branch