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