Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-02 10:45:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

sync msxml3 to wine 1.1.3

Browse source 
svn path=/trunk/; revision=36064
This commit is contained in:
Christoph von Wittich 2008-09-08 16:51:03 +00:00
parent 44e6af9dae
commit 9f5ab44256
23 changed files with 3701 additions and 522 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

67
reactos/dll/win32/msxml3/attribute.c
View file

@ -59,18 +59,18 @@ static HRESULT WINAPI domattr_QueryInterface(
TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
if ( IsEqualGUID( riid, &IID_IXMLDOMAttribute ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IXMLDOMNode ) )
else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) )
{
return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
}
else
{
FIXME("Unsupported inteferace %s\n", debugstr_guid(riid));
FIXME("Unsupported interface %s\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
@ -106,8 +106,13 @@ static HRESULT WINAPI domattr_GetTypeInfoCount(
IXMLDOMAttribute *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
domattr *This = impl_from_IXMLDOMAttribute( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI domattr_GetTypeInfo(
@ -115,8 +120,14 @@ static HRESULT WINAPI domattr_GetTypeInfo(
UINT iTInfo, LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
domattr *This = impl_from_IXMLDOMAttribute( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMAttribute_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI domattr_GetIDsOfNames(
@ -124,8 +135,24 @@ static HRESULT WINAPI domattr_GetIDsOfNames(
REFIID riid, LPOLESTR* rgszNames,
UINT cNames, LCID lcid, DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
domattr *This = impl_from_IXMLDOMAttribute( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMAttribute_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI domattr_Invoke(
@ -134,8 +161,21 @@ static HRESULT WINAPI domattr_Invoke(
WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
EXCEPINFO* pExcepInfo, UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
domattr *This = impl_from_IXMLDOMAttribute( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMAttribute_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI domattr_get_nodeName(
@ -433,8 +473,9 @@ static HRESULT WINAPI domattr_get_name(
IXMLDOMAttribute *iface,
BSTR *p)
{
FIXME("\n");
return E_NOTIMPL;
/* name property returns the same value as nodeName */
domattr *This = impl_from_IXMLDOMAttribute( iface );
return IXMLDOMNode_get_nodeName( This->node, p );
}
static HRESULT WINAPI domattr_get_value(

268
reactos/dll/win32/msxml3/comment.c
View file

@ -59,18 +59,18 @@ static HRESULT WINAPI domcomment_QueryInterface(
TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
if ( IsEqualGUID( riid, &IID_IXMLDOMComment ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IXMLDOMNode ) )
else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) )
{
return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
}
else
{
FIXME("Unsupported inteferace %s\n", debugstr_guid(riid));
FIXME("Unsupported interface %s\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
@ -106,8 +106,13 @@ static HRESULT WINAPI domcomment_GetTypeInfoCount(
IXMLDOMComment *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI domcomment_GetTypeInfo(
@ -115,8 +120,14 @@ static HRESULT WINAPI domcomment_GetTypeInfo(
UINT iTInfo, LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMComment_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI domcomment_GetIDsOfNames(
@ -124,8 +135,24 @@ static HRESULT WINAPI domcomment_GetIDsOfNames(
REFIID riid, LPOLESTR* rgszNames,
UINT cNames, LCID lcid, DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMComment_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI domcomment_Invoke(
@ -134,8 +161,22 @@ static HRESULT WINAPI domcomment_Invoke(
WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
EXCEPINFO* pExcepInfo, UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMComment_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI domcomment_get_nodeName(
@ -433,48 +474,229 @@ static HRESULT WINAPI domcomment_get_data(
IXMLDOMComment *iface,
BSTR *p)
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
HRESULT hr = E_FAIL;
VARIANT vRet;
if(!p)
return E_INVALIDARG;
hr = IXMLDOMNode_get_nodeValue( This->node, &vRet );
if(hr == S_OK)
{
*p = V_BSTR(&vRet);
}
return hr;
}
static HRESULT WINAPI domcomment_put_data(
IXMLDOMComment *iface,
BSTR data)
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
HRESULT hr = E_FAIL;
VARIANT val;
TRACE("%p %s\n", This, debugstr_w(data) );
V_VT(&val) = VT_BSTR;
V_BSTR(&val) = data;
hr = IXMLDOMNode_put_nodeValue( This->node, val );
return hr;
}
static HRESULT WINAPI domcomment_get_length(
IXMLDOMComment *iface,
long *len)
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( This->node );
xmlChar *pContent;
long nLength = 0;
TRACE("%p\n", iface);
if(!len)
return E_INVALIDARG;
pContent = xmlNodeGetContent(pDOMNode->node);
if(pContent)
{
nLength = xmlStrlen(pContent);
xmlFree(pContent);
}
*len = nLength;
return S_OK;
}
static HRESULT WINAPI domcomment_substringData(
IXMLDOMComment *iface,
long offset, long count, BSTR *p)
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( This->node );
xmlChar *pContent;
long nLength = 0;
HRESULT hr = S_FALSE;
TRACE("%p\n", iface);
if(!p)
return E_INVALIDARG;
*p = NULL;
if(offset < 0 || count < 0)
return E_INVALIDARG;
if(count == 0)
return hr;
pContent = xmlNodeGetContent(pDOMNode->node);
if(pContent)
{
nLength = xmlStrlen(pContent);
if( offset < nLength)
{
BSTR sContent = bstr_from_xmlChar(pContent);
if(offset + count > nLength)
*p = SysAllocString(&sContent[offset]);
else
*p = SysAllocStringLen(&sContent[offset], count);
SysFreeString(sContent);
hr = S_OK;
}
xmlFree(pContent);
}
return hr;
}
static HRESULT WINAPI domcomment_appendData(
IXMLDOMComment *iface,
BSTR p)
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( This->node );
xmlChar *pContent;
HRESULT hr = S_FALSE;
TRACE("%p\n", iface);
/* Nothing to do if NULL or an Empty string passed in. */
if(p == NULL || SysStringLen(p) == 0)
return S_OK;
pContent = xmlChar_from_wchar( (WCHAR*)p );
if(pContent)
{
/* Older versions of libxml < 2.6.27 didn't correctly support
xmlTextConcat on Comment nodes. Fallback to setting the
contents directly if xmlTextConcat fails.
NOTE: if xmlTextConcat fails, pContent is destroyed.
*/
if(xmlTextConcat(pDOMNode->node, pContent, SysStringLen(p) ) == 0)
hr = S_OK;
else
{
xmlChar *pNew;
pContent = xmlChar_from_wchar( (WCHAR*)p );
if(pContent)
{
pNew = xmlStrcat(xmlNodeGetContent(pDOMNode->node), pContent);
if(pNew)
{
xmlNodeSetContent(pDOMNode->node, pNew);
hr = S_OK;
}
else
hr = E_FAIL;
}
else
hr = E_FAIL;
}
}
else
hr = E_FAIL;
return hr;
}
static HRESULT WINAPI domcomment_insertData(
IXMLDOMComment *iface,
long offset, BSTR p)
{
FIXME("\n");
return E_NOTIMPL;
domcomment *This = impl_from_IXMLDOMComment( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( This->node );
xmlChar *pXmlContent;
BSTR sNewString;
HRESULT hr = S_FALSE;
long nLength = 0, nLengthP = 0;
xmlChar *str = NULL;
TRACE("%p\n", This);
/* If have a NULL or empty string, don't do anything. */
if(SysStringLen(p) == 0)
return S_OK;
if(offset < 0)
{
return E_INVALIDARG;
}
pXmlContent = xmlNodeGetContent(pDOMNode->node);
if(pXmlContent)
{
BSTR sContent = bstr_from_xmlChar( pXmlContent );
nLength = SysStringLen(sContent);
nLengthP = SysStringLen(p);
if(nLength < offset)
{
SysFreeString(sContent);
xmlFree(pXmlContent);
return E_INVALIDARG;
}
sNewString = SysAllocStringLen(NULL, nLength + nLengthP + 1);
if(sNewString)
{
if(offset > 0)
memcpy(sNewString, sContent, offset * sizeof(WCHAR));
memcpy(&sNewString[offset], p, nLengthP * sizeof(WCHAR));
if(offset+nLengthP < nLength)
memcpy(&sNewString[offset+nLengthP], &sContent[offset], (nLength-offset) * sizeof(WCHAR));
sNewString[nLengthP + nLength] = 0;
str = xmlChar_from_wchar((WCHAR*)sNewString);
if(str)
{
xmlNodeSetContent(pDOMNode->node, str);
hr = S_OK;
}
SysFreeString(sNewString);
}
SysFreeString(sContent);
xmlFree(pXmlContent);
}
return hr;
}
static HRESULT WINAPI domcomment_deleteData(

776
reactos/dll/win32/msxml3/domdoc.c
View file

File diff suppressed because it is too large Load diff

108
reactos/dll/win32/msxml3/element.c
View file

@ -92,8 +92,13 @@ static HRESULT WINAPI domelem_GetTypeInfoCount(
IXMLDOMElement *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
domelem *This = impl_from_IXMLDOMElement( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI domelem_GetTypeInfo(
@ -101,8 +106,14 @@ static HRESULT WINAPI domelem_GetTypeInfo(
UINT iTInfo, LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
domelem *This = impl_from_IXMLDOMElement( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMElement_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI domelem_GetIDsOfNames(
@ -110,8 +121,24 @@ static HRESULT WINAPI domelem_GetIDsOfNames(
REFIID riid, LPOLESTR* rgszNames,
UINT cNames, LCID lcid, DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
domelem *This = impl_from_IXMLDOMElement( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMElement_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI domelem_Invoke(
@ -120,8 +147,22 @@ static HRESULT WINAPI domelem_Invoke(
WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
EXCEPINFO* pExcepInfo, UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
domelem *This = impl_from_IXMLDOMElement( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMElement_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI domelem_get_nodeName(
@ -458,18 +499,28 @@ static HRESULT WINAPI domelem_getAttribute(
{
domelem *This = impl_from_IXMLDOMElement( iface );
xmlNodePtr element;
xmlChar *xml_name, *xml_value;
HRESULT hr = E_FAIL;
xmlChar *xml_name, *xml_value = NULL;
HRESULT hr = S_FALSE;
TRACE("(%p)->(%s,%p)\n", This, debugstr_w(name), value);
if(!value || !name)
return E_INVALIDARG;
element = get_element( This );
if ( !element )
return E_FAIL;
VariantInit(value);
V_BSTR(value) = NULL;
V_VT(value) = VT_NULL;
xml_name = xmlChar_from_wchar( name );
xml_value = xmlGetNsProp(element, xml_name, NULL);
if(!xmlValidateNameValue(xml_name))
hr = E_FAIL;
else
xml_value = xmlGetNsProp(element, xml_name, NULL);
HeapFree(GetProcessHeap(), 0, xml_name);
if(xml_value)
{
@ -531,8 +582,33 @@ static HRESULT WINAPI domelem_getAttributeNode(
IXMLDOMElement *iface,
BSTR p, IXMLDOMAttribute** attributeNode )
{
FIXME("\n");
return E_NOTIMPL;
domelem *This = impl_from_IXMLDOMElement( iface );
xmlChar *xml_name;
xmlNodePtr element;
xmlAttrPtr attr;
IUnknown *unk;
HRESULT hr = E_FAIL;
TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), attributeNode);
element = get_element( This );
if ( !element )
return E_FAIL;
xml_name = xmlChar_from_wchar(p);
attr = xmlHasProp(element, xml_name);
if(attr) {
unk = create_attribute((xmlNodePtr)attr);
hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMAttribute, (void**)attributeNode);
IUnknown_Release(unk);
}else {
*attributeNode = NULL;
}
HeapFree(GetProcessHeap(), 0, xml_name);
return hr;
}
static HRESULT WINAPI domelem_setAttributeNode(
@ -647,12 +723,12 @@ static HRESULT WINAPI Internal_QueryInterface(
TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
if ( IsEqualGUID( riid, &IID_IXMLDOMElement ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = &This->lpVtbl;
}
else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IXMLDOMNode ) )
else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) )
{
return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
}

9
reactos/dll/win32/msxml3/factory.c
View file

@ -133,6 +133,7 @@ static const struct IClassFactoryVtbl xmlcf_vtbl =
static xmlcf domdoccf = { &xmlcf_vtbl, DOMDocument_create };
static xmlcf schemacf = { &xmlcf_vtbl, SchemaCache_create };
static xmlcf xmldoccf = { &xmlcf_vtbl, XMLDocument_create };
static xmlcf saxreadcf = { &xmlcf_vtbl, SAXXMLReader_create };
/******************************************************************
* DllGetClassObject (MSXML3.@)
@ -158,10 +159,16 @@ HRESULT WINAPI DllGetClassObject( REFCLSID rclsid, REFIID iid, LPVOID *ppv )
{
cf = (IClassFactory*) &xmldoccf.lpVtbl;
}
else if( IsEqualCLSID( rclsid, &CLSID_FreeThreadedDOMDocument ) )
else if( IsEqualCLSID( rclsid, &CLSID_DOMFreeThreadedDocument ) || /* Version indep. v 2.x */
IsEqualCLSID( rclsid, &CLSID_FreeThreadedDOMDocument ) )
{
cf = (IClassFactory*) &domdoccf.lpVtbl;
}
else if( IsEqualCLSID( rclsid, &CLSID_SAXXMLReader) ||
IsEqualCLSID( rclsid, &CLSID_SAXXMLReader30 ))
{
cf = (IClassFactory*) &saxreadcf.lpVtbl;
}
if ( !cf )
return CLASS_E_CLASSNOTAVAILABLE;

22
reactos/dll/win32/msxml3/main.c
View file

@ -21,17 +21,24 @@
#include "config.h"
#define COBJMACROS
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "ole2.h"
#include "msxml.h"
#include "msxml2.h"
#include "wine/debug.h"
#include "msxml_private.h"
#ifdef HAVE_LIBXSLT
#include <libxslt/xslt.h>
#endif
WINE_DEFAULT_DEBUG_CHANNEL(msxml);
HRESULT WINAPI DllCanUnloadNow(void)
@ -47,13 +54,28 @@ BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
case DLL_PROCESS_ATTACH:
#ifdef HAVE_LIBXML2
xmlInitParser();
/* Set the default indent character to a single tab. */
xmlThrDefTreeIndentString("\t");
#endif
#ifdef HAVE_XSLTINIT
xsltInit();
#endif
#ifdef HAVE_LIBXML2
/* Set the current ident to the default */
xmlTreeIndentString = "\t";
#endif
DisableThreadLibraryCalls(hInstDLL);
break;
case DLL_PROCESS_DETACH:
#ifdef HAVE_LIBXSLT
xsltCleanupGlobals();
#endif
#ifdef HAVE_LIBXML2
xmlCleanupParser();
#endif
release_typelib();
break;
}
return TRUE;

9
reactos/dll/win32/msxml3/msxml3.rbuild
View file

@ -45,5 +45,14 @@
<file>uuid.c</file>
<file>xmldoc.c</file>
<file>xmlelem.c</file>
<file>saxreader.c</file>
<file>bsc.c</file>
<file>cdata.c</file>
<file>dispex.c</file>
<file>docfrag.c</file>
<file>domimpl.c</file>
<file>entityref.c</file>
<include base="msxml3" root="intermediate">.</include>
<file>msxml3_v1.idl</file>
<file>msxml3.spec</file>
</module>

138
reactos/dll/win32/msxml3/msxml_private.h
View file

@ -21,6 +21,10 @@
#ifndef __MSXML_PRIVATE__
#define __MSXML_PRIVATE__
#include "dispex.h"
#include "wine/unicode.h"
#ifndef __WINE_CONFIG_H
# error You must include config.h to use this header
#endif
@ -32,7 +36,7 @@
#endif
/* constructors */
extern IUnknown *create_domdoc( void );
extern IUnknown *create_domdoc( xmlNodePtr document );
extern IUnknown *create_xmldoc( void );
extern IXMLDOMNode *create_node( xmlNodePtr node );
extern IUnknown *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter );
@ -41,8 +45,12 @@ extern IUnknown *create_attribute( xmlNodePtr attribute );
extern IUnknown *create_text( xmlNodePtr text );
extern IUnknown *create_pi( xmlNodePtr pi );
extern IUnknown *create_comment( xmlNodePtr comment );
extern IUnknown *create_cdata( xmlNodePtr text );
extern IXMLDOMNodeList *create_children_nodelist( xmlNodePtr );
extern IXMLDOMNamedNodeMap *create_nodemap( IXMLDOMNode *node );
extern IUnknown *create_doc_Implementation();
extern IUnknown *create_doc_fragment( xmlNodePtr fragment );
extern IUnknown *create_doc_entity_ref( xmlNodePtr entity );
extern HRESULT queryresult_create( xmlNodePtr, LPWSTR, IXMLDOMNodeList ** );
@ -63,6 +71,23 @@ extern HRESULT XMLElementCollection_create( IUnknown *pUnkOuter, xmlNodePtr node
extern xmlDocPtr parse_xml(char *ptr, int len);
/* IXMLDOMNode Internal Structure */
typedef struct _xmlnode
{
const struct IXMLDOMNodeVtbl *lpVtbl;
const struct IUnknownVtbl *lpInternalUnkVtbl;
IUnknown *pUnkOuter;
LONG ref;
xmlNodePtr node;
} xmlnode;
static inline xmlnode *impl_from_IXMLDOMNode( IXMLDOMNode *iface )
{
return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpVtbl));
}
extern HRESULT DOMDocument_create_from_xmldoc(xmlDocPtr xmldoc, IXMLDOMDocument2 **document);
#endif
extern IXMLDOMParseError *create_parseError( LONG code, BSTR url, BSTR reason, BSTR srcText,
@ -70,5 +95,116 @@ extern IXMLDOMParseError *create_parseError( LONG code, BSTR url, BSTR reason, B
extern HRESULT DOMDocument_create( IUnknown *pUnkOuter, LPVOID *ppObj );
extern HRESULT SchemaCache_create( IUnknown *pUnkOuter, LPVOID *ppObj );
extern HRESULT XMLDocument_create( IUnknown *pUnkOuter, LPVOID *ppObj );
extern HRESULT SAXXMLReader_create(IUnknown *pUnkOuter, LPVOID *ppObj );
typedef struct bsc_t bsc_t;
HRESULT bind_url(LPCWSTR, HRESULT (*onDataAvailable)(void*,char*,DWORD), void*, bsc_t**);
void detach_bsc(bsc_t*);
/* typelibs */
typedef enum tid_t {
IXMLDOMAttribute_tid,
IXMLDOMCDATASection_tid,
IXMLDOMComment_tid,
IXMLDOMDocument2_tid,
IXMLDOMDocumentFragment_tid,
IXMLDOMElement_tid,
IXMLDOMEntityReference_tid,
IXMLDOMImplementation_tid,
IXMLDOMNamedNodeMap_tid,
IXMLDOMNode_tid,
IXMLDOMNodeList_tid,
IXMLDOMParseError_tid,
IXMLDOMProcessingInstruction_tid,
IXMLDOMSchemaCollection_tid,
IXMLDOMText_tid,
IXMLElement_tid,
IXMLDocument_tid,
IVBSAXAttributes_tid,
IVBSAXContentHandler_tid,
IVBSAXDeclHandler_tid,
IVBSAXDTDHandler_tid,
IVBSAXEntityResolver_tid,
IVBSAXErrorHandler_tid,
IVBSAXLexicalHandler_tid,
IVBSAXLocator_tid,
IVBSAXXMLFilter_tid,
IVBSAXXMLReader_tid,
IMXAttributes_tid,
IMXReaderControl_tid,
IMXWriter_tid,
LAST_tid
} tid_t;
extern HRESULT get_typeinfo(tid_t tid, ITypeInfo **typeinfo);
extern void release_typelib(void);
typedef struct dispex_data_t dispex_data_t;
typedef struct dispex_dynamic_data_t dispex_dynamic_data_t;
#define MSXML_DISPID_CUSTOM_MIN 0x60000000
#define MSXML_DISPID_CUSTOM_MAX 0x6fffffff
typedef struct {
HRESULT (*get_dispid)(IUnknown*,BSTR,DWORD,DISPID*);
HRESULT (*invoke)(IUnknown*,DISPID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*);
} dispex_static_data_vtbl_t;
typedef struct {
const dispex_static_data_vtbl_t *vtbl;
const tid_t disp_tid;
dispex_data_t *data;
const tid_t* const iface_tids;
} dispex_static_data_t;
typedef struct {
const IDispatchExVtbl *lpIDispatchExVtbl;
IUnknown *outer;
dispex_static_data_t *data;
dispex_dynamic_data_t *dynamic_data;
} DispatchEx;
void init_dispex(DispatchEx*,IUnknown*,dispex_static_data_t*);
BOOL dispex_query_interface(DispatchEx*,REFIID,void**);
/* memory allocation functions */
static inline void *heap_alloc(size_t len)
{
return HeapAlloc(GetProcessHeap(), 0, len);
}
static inline void *heap_alloc_zero(size_t len)
{
return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
}
static inline void *heap_realloc(void *mem, size_t len)
{
return HeapReAlloc(GetProcessHeap(), 0, mem, len);
}
static inline BOOL heap_free(void *mem)
{
return HeapFree(GetProcessHeap(), 0, mem);
}
static inline LPWSTR heap_strdupW(LPCWSTR str)
{
LPWSTR ret = NULL;
if(str) {
DWORD size;
size = (strlenW(str)+1)*sizeof(WCHAR);
ret = heap_alloc(size);
memcpy(ret, str, size);
}
return ret;
}
#endif /* __MSXML_PRIVATE__ */

689
reactos/dll/win32/msxml3/node.c
View file

@ -33,25 +33,49 @@
#include "msxml_private.h"
#ifdef HAVE_LIBXSLT
# ifdef HAVE_LIBXSLT_PATTERN_H
# include <libxslt/pattern.h>
# endif
# ifdef HAVE_LIBXSLT_TRANSFORM_H
# include <libxslt/transform.h>
# endif
# include <libxslt/xsltutils.h>
# include <libxslt/xsltInternals.h>
#endif
#ifdef HAVE_LIBXML2
# include <libxml/HTMLtree.h>
#endif
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(msxml);
#ifdef HAVE_LIBXML2
typedef struct _xmlnode
{
const struct IXMLDOMNodeVtbl *lpVtbl;
const struct IUnknownVtbl *lpInternalUnkVtbl;
IUnknown *pUnkOuter;
LONG ref;
xmlNodePtr node;
} xmlnode;
static inline xmlnode *impl_from_IXMLDOMNode( IXMLDOMNode *iface )
{
return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpVtbl));
}
static const WCHAR szBinBase64[] = {'b','i','n','.','b','a','s','e','6','4',0};
static const WCHAR szString[] = {'s','t','r','i','n','g',0};
static const WCHAR szNumber[] = {'n','u','m','b','e','r',0};
static const WCHAR szInt[] = {'I','n','t',0};
static const WCHAR szFixed[] = {'F','i','x','e','d','.','1','4','.','4',0};
static const WCHAR szBoolean[] = {'B','o','o','l','e','a','n',0};
static const WCHAR szDateTime[] = {'d','a','t','e','T','i','m','e',0};
static const WCHAR szDateTimeTZ[] = {'d','a','t','e','T','i','m','e','.','t','z',0};
static const WCHAR szDate[] = {'D','a','t','e',0};
static const WCHAR szTime[] = {'T','i','m','e',0};
static const WCHAR szTimeTZ[] = {'T','i','m','e','.','t','z',0};
static const WCHAR szI1[] = {'i','1',0};
static const WCHAR szI2[] = {'i','2',0};
static const WCHAR szI4[] = {'i','4',0};
static const WCHAR szIU1[] = {'u','i','1',0};
static const WCHAR szIU2[] = {'u','i','2',0};
static const WCHAR szIU4[] = {'u','i','4',0};
static const WCHAR szR4[] = {'r','4',0};
static const WCHAR szR8[] = {'r','8',0};
static const WCHAR szFloat[] = {'f','l','o','a','t',0};
static const WCHAR szUUID[] = {'u','u','i','d',0};
static const WCHAR szBinHex[] = {'b','i','n','.','h','e','x',0};
static inline xmlnode *impl_from_InternalUnknown( IUnknown *iface )
{
@ -115,8 +139,13 @@ static HRESULT WINAPI xmlnode_GetTypeInfoCount(
IXMLDOMNode *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI xmlnode_GetTypeInfo(
@ -125,8 +154,14 @@ static HRESULT WINAPI xmlnode_GetTypeInfo(
LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMNode_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI xmlnode_GetIDsOfNames(
@ -137,8 +172,25 @@ static HRESULT WINAPI xmlnode_GetIDsOfNames(
LCID lcid,
DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI xmlnode_Invoke(
@ -152,8 +204,22 @@ static HRESULT WINAPI xmlnode_Invoke(
EXCEPINFO* pExcepInfo,
UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI xmlnode_get_nodeName(
@ -173,13 +239,28 @@ static HRESULT WINAPI xmlnode_get_nodeName(
switch( This->node->type )
{
case XML_TEXT_NODE:
str = (const xmlChar*) "#text";
case XML_CDATA_SECTION_NODE:
str = (const xmlChar*) "#cdata-section";
break;
case XML_COMMENT_NODE:
str = (const xmlChar*) "#comment";
break;
case XML_DOCUMENT_FRAG_NODE:
str = (const xmlChar*) "#document-fragment";
break;
case XML_TEXT_NODE:
str = (const xmlChar*) "#text";
break;
case XML_DOCUMENT_NODE:
str = (const xmlChar*) "#document";
break;
str = (const xmlChar*) "#document";
break;
case XML_ATTRIBUTE_NODE:
case XML_ELEMENT_NODE:
case XML_PI_NODE:
str = This->node->name;
break;
default:
FIXME("nodeName not mapped correctly (%d)\n", This->node->type);
str = This->node->name;
break;
}
@ -219,11 +300,17 @@ static HRESULT WINAPI xmlnode_get_nodeValue(
TRACE("%p %p\n", This, value);
if(!value)
return E_INVALIDARG;
V_BSTR(value) = NULL;
V_VT(value) = VT_NULL;
switch ( This->node->type )
{
case XML_CDATA_SECTION_NODE:
case XML_COMMENT_NODE:
case XML_PI_NODE:
case XML_ATTRIBUTE_NODE:
{
xmlChar *content = xmlNodeGetContent(This->node);
@ -242,7 +329,7 @@ static HRESULT WINAPI xmlnode_get_nodeValue(
case XML_DOCUMENT_NODE:
/* these seem to return NULL */
break;
case XML_PI_NODE:
default:
FIXME("node %p type %d\n", This, This->node->type);
}
@ -256,8 +343,34 @@ static HRESULT WINAPI xmlnode_put_nodeValue(
IXMLDOMNode *iface,
VARIANT value)
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
HRESULT hr = S_FALSE;
xmlChar *str = NULL;
TRACE("%p type(%d)\n", This, This->node->type);
/* Document, Document Fragment, Document Type, Element,
Entity, Entity Reference, Notation aren't supported. */
switch ( This->node->type )
{
case XML_ATTRIBUTE_NODE:
case XML_CDATA_SECTION_NODE:
case XML_COMMENT_NODE:
case XML_PI_NODE:
case XML_TEXT_NODE:
{
str = xmlChar_from_wchar((WCHAR*)V_BSTR(&value));
xmlNodeSetContent(This->node, str);
hr = S_OK;
break;
}
default:
/* Do nothing for unsupported types. */
break;
}
return hr;
}
static HRESULT WINAPI xmlnode_get_nodeType(
@ -331,7 +444,24 @@ static HRESULT WINAPI xmlnode_get_lastChild(
IXMLDOMNode** lastChild)
{
xmlnode *This = impl_from_IXMLDOMNode( iface );
return get_node( This, "lastChild", This->node->last, lastChild );
TRACE("%p\n", This );
if (!lastChild)
return E_INVALIDARG;
switch( This->node->type )
{
/* CDATASection, Comment, PI and Text Nodes do not support lastChild */
case XML_TEXT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_PI_NODE:
case XML_COMMENT_NODE:
*lastChild = NULL;
return S_FALSE;
default:
return get_node( This, "lastChild", This->node->last, lastChild );
}
}
static HRESULT WINAPI xmlnode_get_previousSibling(
@ -339,7 +469,23 @@ static HRESULT WINAPI xmlnode_get_previousSibling(
IXMLDOMNode** previousSibling)
{
xmlnode *This = impl_from_IXMLDOMNode( iface );
return get_node( This, "previous", This->node->prev, previousSibling );
TRACE("%p\n", This );
if (!previousSibling)
return E_INVALIDARG;
switch( This->node->type )
{
/* Attribute, Document and Document Fragment Nodes do not support previousSibling */
case XML_DOCUMENT_NODE:
case XML_DOCUMENT_FRAG_NODE:
case XML_ATTRIBUTE_NODE:
*previousSibling = NULL;
return S_FALSE;
default:
return get_node( This, "previous", This->node->prev, previousSibling );
}
}
static HRESULT WINAPI xmlnode_get_nextSibling(
@ -347,7 +493,23 @@ static HRESULT WINAPI xmlnode_get_nextSibling(
IXMLDOMNode** nextSibling)
{
xmlnode *This = impl_from_IXMLDOMNode( iface );
return get_node( This, "next", This->node->next, nextSibling );
TRACE("%p\n", This );
if (!nextSibling)
return E_INVALIDARG;
switch( This->node->type )
{
/* Attribute, Document and Document Fragment Nodes do not support nextSibling */
case XML_DOCUMENT_NODE:
case XML_DOCUMENT_FRAG_NODE:
case XML_ATTRIBUTE_NODE:
*nextSibling = NULL;
return S_FALSE;
default:
return get_node( This, "next", This->node->next, nextSibling );
}
}
static HRESULT WINAPI xmlnode_get_attributes(
@ -356,8 +518,28 @@ static HRESULT WINAPI xmlnode_get_attributes(
{
xmlnode *This = impl_from_IXMLDOMNode( iface );
TRACE("%p\n", This);
*attributeMap = create_nodemap( iface );
return S_OK;
if (!attributeMap)
return E_INVALIDARG;
switch( This->node->type )
{
/* Attribute, CDataSection, Comment, Documents, Documents Fragments,
Entity and Text Nodes does not support get_attributes */
case XML_ATTRIBUTE_NODE:
case XML_CDATA_SECTION_NODE:
case XML_COMMENT_NODE:
case XML_DOCUMENT_NODE:
case XML_DOCUMENT_FRAG_NODE:
case XML_ENTITY_NODE:
case XML_ENTITY_REF_NODE:
case XML_TEXT_NODE:
*attributeMap = NULL;
return S_FALSE;
default:
*attributeMap = create_nodemap( iface );
return S_OK;
}
}
static HRESULT WINAPI xmlnode_insertBefore(
@ -443,7 +625,8 @@ static HRESULT WINAPI xmlnode_removeChild(
TRACE("%p->(%p, %p)\n", This, childNode, oldChild);
*oldChild = NULL;
if(oldChild)
*oldChild = NULL;
if(!childNode) return E_INVALIDARG;
@ -468,8 +651,13 @@ static HRESULT WINAPI xmlnode_removeChild(
xmlUnlinkNode(child_node_ptr);
IXMLDOMNode_Release(child);
IXMLDOMNode_AddRef(childNode);
*oldChild = childNode;
if(oldChild)
{
IXMLDOMNode_AddRef(childNode);
*oldChild = childNode;
}
return S_OK;
}
@ -479,9 +667,18 @@ static HRESULT WINAPI xmlnode_appendChild(
IXMLDOMNode** outNewChild)
{
xmlnode *This = impl_from_IXMLDOMNode( iface );
DOMNodeType type;
VARIANT var;
HRESULT hr;
TRACE("(%p)->(%p,%p)\n", This, newChild, outNewChild);
hr = IXMLDOMNode_get_nodeType(newChild, &type);
if(FAILED(hr) || type == NODE_ATTRIBUTE) {
if(outNewChild) *outNewChild = NULL;
return E_FAIL;
}
VariantInit(&var);
return IXMLDOMNode_insertBefore(iface, newChild, var, outNewChild);
}
@ -510,8 +707,11 @@ static HRESULT WINAPI xmlnode_get_ownerDocument(
IXMLDOMNode *iface,
IXMLDOMDocument** DOMDocument)
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
TRACE("%p (%p)\n", This, DOMDocument);
return DOMDocument_create_from_xmldoc(This->node->doc, (IXMLDOMDocument2**)DOMDocument);
}
static HRESULT WINAPI xmlnode_cloneNode(
@ -555,8 +755,63 @@ static HRESULT WINAPI xmlnode_get_nodeTypeString(
IXMLDOMNode *iface,
BSTR* xmlnodeType)
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
const xmlChar *str;
TRACE("%p\n", This );
if (!xmlnodeType)
return E_INVALIDARG;
if ( !This->node )
return E_FAIL;
switch( This->node->type )
{
case XML_ATTRIBUTE_NODE:
str = (const xmlChar*) "attribute";
break;
case XML_CDATA_SECTION_NODE:
str = (const xmlChar*) "cdatasection";
break;
case XML_COMMENT_NODE:
str = (const xmlChar*) "comment";
break;
case XML_DOCUMENT_NODE:
str = (const xmlChar*) "document";
break;
case XML_DOCUMENT_FRAG_NODE:
str = (const xmlChar*) "documentfragment";
break;
case XML_ELEMENT_NODE:
str = (const xmlChar*) "element";
break;
case XML_ENTITY_NODE:
str = (const xmlChar*) "entity";
break;
case XML_ENTITY_REF_NODE:
str = (const xmlChar*) "entityreference";
break;
case XML_NOTATION_NODE:
str = (const xmlChar*) "notation";
break;
case XML_PI_NODE:
str = (const xmlChar*) "processinginstruction";
break;
case XML_TEXT_NODE:
str = (const xmlChar*) "text";
break;
default:
FIXME("nodeName not mapped correctly (%d)\n", This->node->type);
str = This->node->name;
break;
}
*xmlnodeType = bstr_from_xmlChar( str );
if (!*xmlnodeType)
return S_FALSE;
return S_OK;
}
static HRESULT WINAPI xmlnode_get_text(
@ -606,8 +861,29 @@ static HRESULT WINAPI xmlnode_put_text(
IXMLDOMNode *iface,
BSTR text)
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
xmlChar *str = NULL;
TRACE("%p\n", This);
switch(This->node->type)
{
case XML_DOCUMENT_NODE:
return E_FAIL;
default:
break;
}
str = xmlChar_from_wchar((WCHAR*)text);
/* Escape the string. */
str = xmlEncodeEntitiesReentrant(This->node->doc, str);
str = xmlEncodeSpecialChars(This->node->doc, str);
xmlNodeSetContent(This->node, str);
xmlFree(str);
return S_OK;
}
static HRESULT WINAPI xmlnode_get_specified(
@ -646,24 +922,217 @@ static HRESULT WINAPI xmlnode_get_dataType(
IXMLDOMNode *iface,
VARIANT* dataTypeName)
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
xmlChar *pVal;
TRACE("iface %p\n", iface);
if(!dataTypeName)
return E_INVALIDARG;
/* Attribute, CDATA Section, Comment, Document, Document Fragment,
Entity, Notation, PI, and Text Node are non-typed. */
V_BSTR(dataTypeName) = NULL;
V_VT(dataTypeName) = VT_NULL;
switch ( This->node->type )
{
case XML_ELEMENT_NODE:
pVal = xmlGetNsProp(This->node, (xmlChar*)"dt",
(xmlChar*)"urn:schemas-microsoft-com:datatypes");
if (pVal)
{
V_VT(dataTypeName) = VT_BSTR;
V_BSTR(dataTypeName) = bstr_from_xmlChar( pVal );
xmlFree(pVal);
}
break;
case XML_ENTITY_REF_NODE:
FIXME("XML_ENTITY_REF_NODE should return a valid value.\n");
break;
default:
TRACE("Type %d returning NULL\n", This->node->type);
}
/* non-typed nodes return S_FALSE */
if(V_VT(dataTypeName) == VT_NULL)
{
return S_FALSE;
}
return S_OK;
}
static HRESULT WINAPI xmlnode_put_dataType(
IXMLDOMNode *iface,
BSTR dataTypeName)
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
HRESULT hr = E_FAIL;
TRACE("iface %p\n", iface);
if(dataTypeName == NULL)
return E_INVALIDARG;
/* An example of this is. The Text in the node needs to be a 0 or 1 for a boolean type.
This applies to changing types (string->bool) or setting a new one
*/
FIXME("Need to Validate the data before allowing a type to be set.\n");
/* Check all supported types. */
if(lstrcmpiW(dataTypeName,szString) == 0 ||
lstrcmpiW(dataTypeName,szNumber) == 0 ||
lstrcmpiW(dataTypeName,szUUID) == 0 ||
lstrcmpiW(dataTypeName,szInt) == 0 ||
lstrcmpiW(dataTypeName,szI4) == 0 ||
lstrcmpiW(dataTypeName,szFixed) == 0 ||
lstrcmpiW(dataTypeName,szBoolean) == 0 ||
lstrcmpiW(dataTypeName,szDateTime) == 0 ||
lstrcmpiW(dataTypeName,szDateTimeTZ) == 0 ||
lstrcmpiW(dataTypeName,szDate) == 0 ||
lstrcmpiW(dataTypeName,szTime) == 0 ||
lstrcmpiW(dataTypeName,szTimeTZ) == 0 ||
lstrcmpiW(dataTypeName,szI1) == 0 ||
lstrcmpiW(dataTypeName,szI2) == 0 ||
lstrcmpiW(dataTypeName,szIU1) == 0 ||
lstrcmpiW(dataTypeName,szIU2) == 0 ||
lstrcmpiW(dataTypeName,szIU4) == 0 ||
lstrcmpiW(dataTypeName,szR4) == 0 ||
lstrcmpiW(dataTypeName,szR8) == 0 ||
lstrcmpiW(dataTypeName,szFloat) == 0 ||
lstrcmpiW(dataTypeName,szBinHex) == 0 ||
lstrcmpiW(dataTypeName,szBinBase64) == 0)
{
xmlNsPtr pNS = NULL;
xmlAttrPtr pAttr = NULL;
xmlChar* str = xmlChar_from_wchar((WCHAR*)dataTypeName);
pAttr = xmlHasNsProp(This->node, (xmlChar*)"dt",
(xmlChar*)"urn:schemas-microsoft-com:datatypes");
if (pAttr)
{
pAttr = xmlSetNsProp(This->node, pAttr->ns, (xmlChar*)"dt", str);
hr = S_OK;
}
else
{
pNS = xmlNewNs(This->node, (xmlChar*)"urn:schemas-microsoft-com:datatypes", (xmlChar*)"dt");
if(pNS)
{
pAttr = xmlNewNsProp(This->node, pNS, (xmlChar*)"dt", str);
if(pAttr)
{
xmlAddChild(This->node, (xmlNodePtr)pAttr);
hr = S_OK;
}
else
ERR("Failed to create Attribute\n");
}
else
ERR("Failed to Create Namepsace\n");
}
}
return hr;
}
static BSTR EnsureCorrectEOL(BSTR sInput)
{
static const WCHAR SZ_RETURN[] = {'\n',0};
static const WCHAR SZ_LINEFEED[] = {'\r',0};
int nNum = 0;
BSTR sNew;
int nLen;
int i;
nLen = lstrlenW(sInput);
/* Count line endings */
for(i=0; i < nLen; i++)
{
if(sInput[i] == SZ_RETURN[0])
nNum++;
}
TRACE("len=%d, num=%d\n", nLen, nNum);
/* Add linefeed as needed */
if(nNum > 0)
{
int nPlace = 0;
sNew = SysAllocStringLen(NULL, nLen + nNum+1);
for(i=0; i < nLen; i++)
{
if(sInput[i] == SZ_RETURN[0])
{
sNew[i+nPlace] = SZ_LINEFEED[0];
nPlace++;
}
sNew[i+nPlace] = sInput[i];
}
SysFreeString(sInput);
}
else
{
sNew = sInput;
}
TRACE("len %d\n", lstrlenW(sNew));
return sNew;
}
/*
* We are trying to replicate the same behaviour as msxml by converting
* line endings to \r\n and using idents as \t. The problem is that msxml
* only formats nodes that have a line ending. Using libxml we cannot
* reproduce behaviour exactly.
*
*/
static HRESULT WINAPI xmlnode_get_xml(
IXMLDOMNode *iface,
BSTR* xmlString)
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
xmlBufferPtr pXmlBuf;
int nSize;
TRACE("iface %p %d\n", iface, This->node->type);
if(!xmlString)
return E_INVALIDARG;
*xmlString = NULL;
pXmlBuf = xmlBufferCreate();
if(pXmlBuf)
{
nSize = xmlNodeDump(pXmlBuf, This->node->doc, This->node, 0, 1);
if(nSize > 0)
{
const xmlChar *pContent;
BSTR bstrContent;
/* Attribute Nodes return a space in front of their name */
pContent = xmlBufferContent(pXmlBuf);
if( ((char*)pContent)[0] == ' ')
bstrContent = bstr_from_xmlChar(pContent+1);
else
bstrContent = bstr_from_xmlChar(pContent);
*xmlString = This->node->type == XML_ELEMENT_NODE ? EnsureCorrectEOL(bstrContent) : bstrContent;
}
xmlBufferFree(pXmlBuf);
}
/* Always returns a string. */
if(*xmlString == NULL) *xmlString = SysAllocStringLen( NULL, 0 );
return S_OK;
}
static HRESULT WINAPI xmlnode_transformNode(
@ -671,8 +1140,79 @@ static HRESULT WINAPI xmlnode_transformNode(
IXMLDOMNode* styleSheet,
BSTR* xmlString)
{
FIXME("\n");
#ifdef HAVE_LIBXSLT
xmlnode *This = impl_from_IXMLDOMNode( iface );
xmlnode *pStyleSheet = NULL;
xsltStylesheetPtr xsltSS = NULL;
xmlDocPtr result = NULL;
IXMLDOMNode *ssNew;
TRACE("%p %p %p\n", This, styleSheet, xmlString);
if(!styleSheet || !xmlString)
return E_INVALIDARG;
*xmlString = NULL;
if(IXMLDOMNode_QueryInterface(styleSheet, &IID_IXMLDOMNode, (LPVOID)&ssNew) == S_OK)
{
pStyleSheet = impl_from_IXMLDOMNode( ssNew );
xsltSS = xsltParseStylesheetDoc( pStyleSheet->node->doc);
if(xsltSS)
{
result = xsltApplyStylesheet(xsltSS, This->node->doc, NULL);
if(result)
{
const xmlChar *pContent;
if(result->type == XML_HTML_DOCUMENT_NODE)
{
xmlOutputBufferPtr pOutput = xmlAllocOutputBuffer(NULL);
if(pOutput)
{
htmlDocContentDumpOutput(pOutput, result->doc, NULL);
if(pOutput)
{
pContent = xmlBufferContent(pOutput->buffer);
*xmlString = bstr_from_xmlChar(pContent);
}
xmlOutputBufferClose(pOutput);
}
}
else
{
xmlBufferPtr pXmlBuf;
int nSize;
pXmlBuf = xmlBufferCreate();
if(pXmlBuf)
{
nSize = xmlNodeDump(pXmlBuf, NULL, (xmlNodePtr)result, 0, 0);
if(nSize > 0)
{
pContent = xmlBufferContent(pXmlBuf);
*xmlString = bstr_from_xmlChar(pContent);
xmlBufferFree(pXmlBuf);
}
}
}
}
}
IXMLDOMNode_Release(ssNew);
}
if(*xmlString == NULL)
*xmlString = SysAllocStringLen(NULL, 0);
return S_OK;
#else
FIXME("libxslt headers were not found at compile time\n");
return E_NOTIMPL;
#endif
}
static HRESULT WINAPI xmlnode_selectNodes(
@ -720,16 +1260,52 @@ static HRESULT WINAPI xmlnode_get_namespaceURI(
IXMLDOMNode *iface,
BSTR* namespaceURI)
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
HRESULT hr = S_FALSE;
xmlNsPtr *pNSList;
TRACE("%p %p\n", This, namespaceURI );
if(!namespaceURI)
return E_INVALIDARG;
*namespaceURI = NULL;
pNSList = xmlGetNsList(This->node->doc, This->node);
if(pNSList)
{
*namespaceURI = bstr_from_xmlChar( pNSList[0]->href );
hr = S_OK;
}
return hr;
}
static HRESULT WINAPI xmlnode_get_prefix(
IXMLDOMNode *iface,
BSTR* prefixString)
{
FIXME("\n");
return E_NOTIMPL;
xmlnode *This = impl_from_IXMLDOMNode( iface );
HRESULT hr = S_FALSE;
xmlNsPtr *pNSList;
TRACE("%p %p\n", This, prefixString );
if(!prefixString)
return E_INVALIDARG;
*prefixString = NULL;
pNSList = xmlGetNsList(This->node->doc, This->node);
if(pNSList)
{
*prefixString = bstr_from_xmlChar( pNSList[0]->prefix );
hr = S_OK;
}
return hr;
}
static HRESULT WINAPI xmlnode_get_baseName(
@ -925,12 +1501,15 @@ IXMLDOMNode *create_node( xmlNodePtr node )
case XML_TEXT_NODE:
pUnk = create_text( node );
break;
case XML_CDATA_SECTION_NODE:
pUnk = create_cdata( node );
break;
case XML_COMMENT_NODE:
pUnk = create_comment( node );
break;
case XML_DOCUMENT_NODE:
ERR("shouldn't be here!\n");
return NULL;
pUnk = create_domdoc( node );
break;
default:
FIXME("only creating basic node for type %d\n", node->type);
pUnk = create_basic_node( node, NULL );

71
reactos/dll/win32/msxml3/nodelist.c
View file

@ -66,6 +66,9 @@ static HRESULT WINAPI xmlnodelist_QueryInterface(
{
TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
if(!ppvObject)
return E_INVALIDARG;
if ( IsEqualGUID( riid, &IID_IUnknown ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IXMLDOMNodeList ) )
@ -111,8 +114,13 @@ static HRESULT WINAPI xmlnodelist_GetTypeInfoCount(
IXMLDOMNodeList *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI xmlnodelist_GetTypeInfo(
@ -121,8 +129,14 @@ static HRESULT WINAPI xmlnodelist_GetTypeInfo(
LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMNodeList_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI xmlnodelist_GetIDsOfNames(
@ -133,8 +147,24 @@ static HRESULT WINAPI xmlnodelist_GetIDsOfNames(
LCID lcid,
DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMNodeList_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI xmlnodelist_Invoke(
@ -148,8 +178,22 @@ static HRESULT WINAPI xmlnodelist_Invoke(
EXCEPINFO* pExcepInfo,
UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
xmlnodelist *This = impl_from_IXMLDOMNodeList( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMNodeList_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI xmlnodelist_get_item(
@ -162,7 +206,10 @@ static HRESULT WINAPI xmlnodelist_get_item(
long nodeIndex = 0;
TRACE("%p %ld\n", This, index);
if(!listItem)
return E_INVALIDARG;
*listItem = NULL;
if (index < 0)
@ -193,6 +240,9 @@ static HRESULT WINAPI xmlnodelist_get_length(
TRACE("%p\n", This);
if(!listLength)
return E_INVALIDARG;
curr = This->parent->children;
while (curr)
{
@ -212,6 +262,9 @@ static HRESULT WINAPI xmlnodelist_nextNode(
TRACE("%p %p\n", This, nextItem );
if(!nextItem)
return E_INVALIDARG;
*nextItem = NULL;
if (!This->current)

99
reactos/dll/win32/msxml3/nodemap.c
View file

@ -112,8 +112,13 @@ static HRESULT WINAPI xmlnodemap_GetTypeInfoCount(
IXMLDOMNamedNodeMap *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI xmlnodemap_GetTypeInfo(
@ -121,8 +126,14 @@ static HRESULT WINAPI xmlnodemap_GetTypeInfo(
UINT iTInfo, LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMNamedNodeMap_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI xmlnodemap_GetIDsOfNames(
@ -130,8 +141,24 @@ static HRESULT WINAPI xmlnodemap_GetIDsOfNames(
REFIID riid, LPOLESTR* rgszNames,
UINT cNames, LCID lcid, DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMNamedNodeMap_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI xmlnodemap_Invoke(
@ -140,8 +167,22 @@ static HRESULT WINAPI xmlnodemap_Invoke(
WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
EXCEPINFO* pExcepInfo, UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMNamedNodeMap_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
xmlChar *xmlChar_from_wchar( LPWSTR str )
@ -195,8 +236,46 @@ static HRESULT WINAPI xmlnodemap_setNamedItem(
IXMLDOMNode* newItem,
IXMLDOMNode** namedItem)
{
FIXME("\n");
return E_NOTIMPL;
xmlnodemap *This = impl_from_IXMLDOMNamedNodeMap( iface );
xmlnode *ThisNew = NULL;
xmlNodePtr nodeNew;
IXMLDOMNode *pAttr = NULL;
xmlNodePtr node;
TRACE("%p %p %p\n", This, newItem, namedItem );
if(!newItem)
return E_INVALIDARG;
if(namedItem) *namedItem = NULL;
node = xmlNodePtr_from_domnode( This->node, 0 );
if ( !node )
return E_FAIL;
/* Must be an Attribute */
IUnknown_QueryInterface(newItem, &IID_IXMLDOMNode, (LPVOID*)&pAttr);
if(pAttr)
{
ThisNew = impl_from_IXMLDOMNode( pAttr );
if(ThisNew->node->type != XML_ATTRIBUTE_NODE)
{
IUnknown_Release(pAttr);
return E_FAIL;
}
nodeNew = xmlAddChild(node, ThisNew->node);
if(namedItem)
*namedItem = create_node( nodeNew );
IUnknown_Release(pAttr);
return S_OK;
}
return E_INVALIDARG;
}
static HRESULT WINAPI xmlnodemap_removeNamedItem(

57
reactos/dll/win32/msxml3/parseerror.c
View file

@ -107,8 +107,13 @@ static HRESULT WINAPI parseError_GetTypeInfoCount(
IXMLDOMParseError *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
parse_error_t *This = impl_from_IXMLDOMParseError( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI parseError_GetTypeInfo(
@ -117,8 +122,14 @@ static HRESULT WINAPI parseError_GetTypeInfo(
LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
parse_error_t *This = impl_from_IXMLDOMParseError( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMParseError_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI parseError_GetIDsOfNames(
@ -129,8 +140,24 @@ static HRESULT WINAPI parseError_GetIDsOfNames(
LCID lcid,
DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
parse_error_t *This = impl_from_IXMLDOMParseError( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMParseError_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI parseError_Invoke(
@ -144,8 +171,22 @@ static HRESULT WINAPI parseError_Invoke(
EXCEPINFO* pExcepInfo,
UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
parse_error_t *This = impl_from_IXMLDOMParseError( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMParseError_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI parseError_get_errorCode(

132
reactos/dll/win32/msxml3/pi.c
View file

@ -59,18 +59,18 @@ static HRESULT WINAPI dom_pi_QueryInterface(
TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
if ( IsEqualGUID( riid, &IID_IXMLDOMProcessingInstruction ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IXMLDOMNode ) )
else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) )
{
return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
}
else
{
FIXME("Unsupported inteferace %s\n", debugstr_guid(riid));
FIXME("Unsupported interface %s\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
@ -106,8 +106,13 @@ static HRESULT WINAPI dom_pi_GetTypeInfoCount(
IXMLDOMProcessingInstruction *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI dom_pi_GetTypeInfo(
@ -115,8 +120,14 @@ static HRESULT WINAPI dom_pi_GetTypeInfo(
UINT iTInfo, LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMProcessingInstruction_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI dom_pi_GetIDsOfNames(
@ -124,8 +135,24 @@ static HRESULT WINAPI dom_pi_GetIDsOfNames(
REFIID riid, LPOLESTR* rgszNames,
UINT cNames, LCID lcid, DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMProcessingInstruction_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI dom_pi_Invoke(
@ -134,8 +161,22 @@ static HRESULT WINAPI dom_pi_Invoke(
WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
EXCEPINFO* pExcepInfo, UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMProcessingInstruction_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI dom_pi_get_nodeName(
@ -159,6 +200,25 @@ static HRESULT WINAPI dom_pi_put_nodeValue(
VARIANT var1 )
{
dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
BSTR sTarget;
static const WCHAR szXML[] = {'x','m','l',0};
HRESULT hr;
TRACE("%p\n", This );
/* Cannot set data to a PI node whose target is 'xml' */
hr = dom_pi_get_nodeName(iface, &sTarget);
if(hr == S_OK)
{
if(lstrcmpW( sTarget, szXML) == 0)
{
SysFreeString(sTarget);
return E_FAIL;
}
SysFreeString(sTarget);
}
return IXMLDOMNode_put_nodeValue( This->node, var1 );
}
@ -433,24 +493,62 @@ static HRESULT WINAPI dom_pi_get_target(
IXMLDOMProcessingInstruction *iface,
BSTR *p)
{
FIXME("\n");
return E_NOTIMPL;
/* target returns the same value as nodeName property */
dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
return IXMLDOMNode_get_nodeName( This->node, p );
}
static HRESULT WINAPI dom_pi_get_data(
IXMLDOMProcessingInstruction *iface,
BSTR *p)
{
FIXME("\n");
return E_NOTIMPL;
dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
HRESULT hr = E_FAIL;
VARIANT vRet;
if(!p)
return E_INVALIDARG;
hr = IXMLDOMNode_get_nodeValue( This->node, &vRet );
if(hr == S_OK)
{
*p = V_BSTR(&vRet);
}
return hr;
}
static HRESULT WINAPI dom_pi_put_data(
IXMLDOMProcessingInstruction *iface,
BSTR data)
{
FIXME("\n");
return E_NOTIMPL;
dom_pi *This = impl_from_IXMLDOMProcessingInstruction( iface );
HRESULT hr = E_FAIL;
VARIANT val;
BSTR sTarget;
static const WCHAR szXML[] = {'x','m','l',0};
TRACE("%p %s\n", This, debugstr_w(data) );
/* Cannot set data to a PI node whose target is 'xml' */
hr = dom_pi_get_nodeName(iface, &sTarget);
if(hr == S_OK)
{
if(lstrcmpW( sTarget, szXML) == 0)
{
SysFreeString(sTarget);
return E_FAIL;
}
SysFreeString(sTarget);
}
V_VT(&val) = VT_BSTR;
V_BSTR(&val) = data;
hr = IXMLDOMNode_put_nodeValue( This->node, val );
return hr;
}
static const struct IXMLDOMProcessingInstructionVtbl dom_pi_vtbl =

189
reactos/dll/win32/msxml3/queryresult.c
View file

@ -50,10 +50,9 @@ WINE_DEFAULT_DEBUG_CHANNEL(msxml);
#include <libxml/xpath.h>
static const struct IXMLDOMNodeListVtbl queryresult_vtbl;
typedef struct _queryresult
{
DispatchEx dispex;
const struct IXMLDOMNodeListVtbl *lpVtbl;
LONG ref;
xmlNodePtr node;
@ -66,64 +65,27 @@ static inline queryresult *impl_from_IXMLDOMNodeList( IXMLDOMNodeList *iface )
return (queryresult *)((char*)iface - FIELD_OFFSET(queryresult, lpVtbl));
}
HRESULT queryresult_create(xmlNodePtr node, LPWSTR szQuery, IXMLDOMNodeList **out)
{
queryresult *This = CoTaskMemAlloc(sizeof(queryresult));
xmlXPathContextPtr ctxt = xmlXPathNewContext(node->doc);
xmlChar *str = xmlChar_from_wchar(szQuery);
HRESULT hr;
TRACE("(%p, %s, %p)\n", node, wine_dbgstr_w(szQuery), out);
*out = NULL;
if (This == NULL || ctxt == NULL || str == NULL)
{
hr = E_OUTOFMEMORY;
goto cleanup;
}
This->lpVtbl = &queryresult_vtbl;
This->ref = 1;
This->resultPos = 0;
This->node = node;
xmldoc_add_ref(This->node->doc);
ctxt->node = node;
This->result = xmlXPathEval(str, ctxt);
if (!This->result || This->result->type != XPATH_NODESET)
{
hr = E_FAIL;
goto cleanup;
}
*out = (IXMLDOMNodeList *)This;
hr = S_OK;
TRACE("found %d matches\n", This->result->nodesetval->nodeNr);
cleanup:
if (This != NULL && FAILED(hr))
IXMLDOMNodeList_Release( (IXMLDOMNodeList*) &This->lpVtbl );
if (ctxt != NULL)
xmlXPathFreeContext(ctxt);
HeapFree(GetProcessHeap(), 0, str);
return hr;
}
static HRESULT WINAPI queryresult_QueryInterface(
IXMLDOMNodeList *iface,
REFIID riid,
void** ppvObject )
{
queryresult *This = impl_from_IXMLDOMNodeList( iface );
TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
if(!ppvObject)
return E_INVALIDARG;
if ( IsEqualGUID( riid, &IID_IUnknown ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IXMLDOMNodeList ) )
{
*ppvObject = iface;
}
else if(dispex_query_interface(&This->dispex, riid, ppvObject))
{
return *ppvObject ? S_OK : E_NOINTERFACE;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
@ -154,7 +116,7 @@ static ULONG WINAPI queryresult_Release(
{
xmlXPathFreeObject(This->result);
xmldoc_release(This->node->doc);
CoTaskMemFree(This);
heap_free(This);
}
return ref;
@ -164,8 +126,13 @@ static HRESULT WINAPI queryresult_GetTypeInfoCount(
IXMLDOMNodeList *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
queryresult *This = impl_from_IXMLDOMNodeList( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI queryresult_GetTypeInfo(
@ -174,8 +141,14 @@ static HRESULT WINAPI queryresult_GetTypeInfo(
LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
queryresult *This = impl_from_IXMLDOMNodeList( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMNodeList_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI queryresult_GetIDsOfNames(
@ -186,8 +159,24 @@ static HRESULT WINAPI queryresult_GetIDsOfNames(
LCID lcid,
DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
queryresult *This = impl_from_IXMLDOMNodeList( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMNodeList_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI queryresult_Invoke(
@ -201,8 +190,22 @@ static HRESULT WINAPI queryresult_Invoke(
EXCEPINFO* pExcepInfo,
UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
queryresult *This = impl_from_IXMLDOMNodeList( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMNodeList_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI queryresult_get_item(
@ -214,9 +217,12 @@ static HRESULT WINAPI queryresult_get_item(
TRACE("%p %ld\n", This, index);
if(!listItem)
return E_INVALIDARG;
*listItem = NULL;
if (index < 0 || index >= This->result->nodesetval->nodeNr)
if (index < 0 || index >= xmlXPathNodeSetGetLength(This->result->nodesetval))
return S_FALSE;
*listItem = create_node(This->result->nodesetval->nodeTab[index]);
@ -233,7 +239,10 @@ static HRESULT WINAPI queryresult_get_length(
TRACE("%p\n", This);
*listLength = This->result->nodesetval->nodeNr;
if(!listLength)
return E_INVALIDARG;
*listLength = xmlXPathNodeSetGetLength(This->result->nodesetval);
return S_OK;
}
@ -245,9 +254,12 @@ static HRESULT WINAPI queryresult_nextNode(
TRACE("%p %p\n", This, nextItem );
if(!nextItem)
return E_INVALIDARG;
*nextItem = NULL;
if (This->resultPos >= This->result->nodesetval->nodeNr)
if (This->resultPos >= xmlXPathNodeSetGetLength(This->result->nodesetval))
return S_FALSE;
*nextItem = create_node(This->result->nodesetval->nodeTab[This->resultPos]);
@ -290,4 +302,61 @@ static const struct IXMLDOMNodeListVtbl queryresult_vtbl =
queryresult__newEnum,
};
static const tid_t queryresult_iface_tids[] = {
IXMLDOMNodeList_tid,
0
};
static dispex_static_data_t queryresult_dispex = {
NULL,
IXMLDOMNodeList_tid,
NULL,
queryresult_iface_tids
};
HRESULT queryresult_create(xmlNodePtr node, LPWSTR szQuery, IXMLDOMNodeList **out)
{
queryresult *This = heap_alloc_zero(sizeof(queryresult));
xmlXPathContextPtr ctxt = xmlXPathNewContext(node->doc);
xmlChar *str = xmlChar_from_wchar(szQuery);
HRESULT hr;
TRACE("(%p, %s, %p)\n", node, wine_dbgstr_w(szQuery), out);
*out = NULL;
if (This == NULL || ctxt == NULL || str == NULL)
{
hr = E_OUTOFMEMORY;
goto cleanup;
}
This->lpVtbl = &queryresult_vtbl;
This->ref = 1;
This->resultPos = 0;
This->node = node;
xmldoc_add_ref(This->node->doc);
ctxt->node = node;
This->result = xmlXPathEval(str, ctxt);
if (!This->result || This->result->type != XPATH_NODESET)
{
hr = E_FAIL;
goto cleanup;
}
init_dispex(&This->dispex, (IUnknown*)&This->lpVtbl, &queryresult_dispex);
*out = (IXMLDOMNodeList *) &This->lpVtbl;
hr = S_OK;
TRACE("found %d matches\n", xmlXPathNodeSetGetLength(This->result->nodesetval));
cleanup:
if (This != NULL && FAILED(hr))
IXMLDOMNodeList_Release( (IXMLDOMNodeList*) &This->lpVtbl );
if (ctxt != NULL)
xmlXPathFreeContext(ctxt);
HeapFree(GetProcessHeap(), 0, str);
return hr;
}
#endif

24
reactos/dll/win32/msxml3/regsvr.c
View file

@ -3,6 +3,7 @@
*
* Copyright (C) 2003 John K. Hohm
* Copyright (C) 2006 Robert Shearman
* Copyright (C) 2008 Alistair Leslie-Hughes
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -24,6 +25,8 @@
#include <stdarg.h>
#include <string.h>
#define COBJMACROS
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
@ -552,6 +555,14 @@ static struct regsvr_coclass const coclass_list[] = {
"Msxml2.XMLSchemaCache",
"3.0"
},
{ &CLSID_SAXXMLReader,
"SAX XML Reader",
NULL,
"msxml3.dll",
"Both",
"Msxml2.SAXXMLReader",
"3.0"
},
{ NULL } /* list terminator */
};
@ -651,6 +662,8 @@ static struct progid const progid_list[] = {
HRESULT WINAPI DllRegisterServer(void)
{
HRESULT hr;
ITypeLib *tl;
static const WCHAR wszMsXml3[] = {'m','s','x','m','l','3','.','d','l','l',0};
TRACE("\n");
@ -659,6 +672,14 @@ HRESULT WINAPI DllRegisterServer(void)
hr = register_interfaces(interface_list);
if (SUCCEEDED(hr))
hr = register_progids(progid_list);
if(SUCCEEDED(hr)) {
hr = LoadTypeLibEx(wszMsXml3, REGKIND_REGISTER, &tl);
if(SUCCEEDED(hr))
ITypeLib_Release(tl);
}
return hr;
}
@ -676,5 +697,8 @@ HRESULT WINAPI DllUnregisterServer(void)
hr = unregister_interfaces(interface_list);
if (SUCCEEDED(hr))
hr = unregister_progids(progid_list);
if (SUCCEEDED(hr))
hr = UnRegisterTypeLib(&LIBID_MSXML2, 3, 0, LOCALE_SYSTEM_DEFAULT, SYS_WIN32);
return hr;
}

57
reactos/dll/win32/msxml3/schema.c
View file

@ -94,15 +94,26 @@ static ULONG WINAPI schema_cache_Release( IXMLDOMSchemaCollection *iface )
static HRESULT WINAPI schema_cache_GetTypeInfoCount( IXMLDOMSchemaCollection *iface, UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
schema_t *This = impl_from_IXMLDOMSchemaCollection( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI schema_cache_GetTypeInfo( IXMLDOMSchemaCollection *iface,
UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
schema_t *This = impl_from_IXMLDOMSchemaCollection( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMSchemaCollection_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI schema_cache_GetIDsOfNames( IXMLDOMSchemaCollection *iface,
@ -112,8 +123,24 @@ static HRESULT WINAPI schema_cache_GetIDsOfNames( IXMLDOMSchemaCollection *iface
LCID lcid,
DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
schema_t *This = impl_from_IXMLDOMSchemaCollection( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMSchemaCollection_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI schema_cache_Invoke( IXMLDOMSchemaCollection *iface,
@ -126,8 +153,22 @@ static HRESULT WINAPI schema_cache_Invoke( IXMLDOMSchemaCollection *iface,
EXCEPINFO* pExcepInfo,
UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
schema_t *This = impl_from_IXMLDOMSchemaCollection( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMSchemaCollection_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI schema_cache_add( IXMLDOMSchemaCollection *iface, BSTR uri, VARIANT var )

248
reactos/dll/win32/msxml3/text.c
View file

@ -2,6 +2,7 @@
* DOM text node implementation
*
* Copyright 2006 Huw Davies
* Copyright 2007-2008 Alistair Leslie-Hughes
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -59,19 +60,20 @@ static HRESULT WINAPI domtext_QueryInterface(
TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
if ( IsEqualGUID( riid, &IID_IXMLDOMText ) ||
IsEqualGUID( riid, &IID_IXMLDOMCharacterData) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
IsEqualGUID( riid, &IID_IXMLDOMElement ) )
{
return IUnknown_QueryInterface(This->element_unk, riid, ppvObject);
}
else
{
FIXME("Unsupported inteferace %s\n", debugstr_guid(riid));
FIXME("Unsupported interface %s\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
@ -107,8 +109,13 @@ static HRESULT WINAPI domtext_GetTypeInfoCount(
IXMLDOMText *iface,
UINT* pctinfo )
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI domtext_GetTypeInfo(
@ -116,8 +123,14 @@ static HRESULT WINAPI domtext_GetTypeInfo(
UINT iTInfo, LCID lcid,
ITypeInfo** ppTInfo )
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDOMText_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI domtext_GetIDsOfNames(
@ -125,8 +138,24 @@ static HRESULT WINAPI domtext_GetIDsOfNames(
REFIID riid, LPOLESTR* rgszNames,
UINT cNames, LCID lcid, DISPID* rgDispId )
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDOMText_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI domtext_Invoke(
@ -135,8 +164,22 @@ static HRESULT WINAPI domtext_Invoke(
WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult,
EXCEPINFO* pExcepInfo, UINT* puArgErr )
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDOMText_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI domtext_get_nodeName(
@ -434,48 +477,207 @@ static HRESULT WINAPI domtext_get_data(
IXMLDOMText *iface,
BSTR *p)
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
HRESULT hr = E_FAIL;
VARIANT vRet;
if(!p)
return E_INVALIDARG;
hr = IXMLDOMNode_get_nodeValue( This->element, &vRet );
if(hr == S_OK)
{
*p = V_BSTR(&vRet);
}
return hr;
}
static HRESULT WINAPI domtext_put_data(
IXMLDOMText *iface,
BSTR data)
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
HRESULT hr = E_FAIL;
VARIANT val;
TRACE("%p %s\n", This, debugstr_w(data) );
V_VT(&val) = VT_BSTR;
V_BSTR(&val) = data;
hr = IXMLDOMNode_put_nodeValue( This->element, val );
return hr;
}
static HRESULT WINAPI domtext_get_length(
IXMLDOMText *iface,
long *len)
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( (IXMLDOMNode*)This->element );
xmlChar *pContent;
long nLength = 0;
TRACE("%p\n", iface);
if(!len)
return E_INVALIDARG;
pContent = xmlNodeGetContent(pDOMNode->node);
if(pContent)
{
nLength = xmlStrlen(pContent);
xmlFree(pContent);
}
*len = nLength;
return S_OK;
}
static HRESULT WINAPI domtext_substringData(
IXMLDOMText *iface,
long offset, long count, BSTR *p)
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( (IXMLDOMNode*)This->element );
xmlChar *pContent;
long nLength = 0;
HRESULT hr = S_FALSE;
TRACE("%p\n", iface);
if(!p)
return E_INVALIDARG;
*p = NULL;
if(offset < 0 || count < 0)
return E_INVALIDARG;
if(count == 0)
return hr;
pContent = xmlNodeGetContent(pDOMNode->node);
if(pContent)
{
nLength = xmlStrlen(pContent);
if( offset < nLength)
{
BSTR sContent = bstr_from_xmlChar(pContent);
if(offset + count > nLength)
*p = SysAllocString(&sContent[offset]);
else
*p = SysAllocStringLen(&sContent[offset], count);
SysFreeString(sContent);
hr = S_OK;
}
xmlFree(pContent);
}
return hr;
}
static HRESULT WINAPI domtext_appendData(
IXMLDOMText *iface,
BSTR p)
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( (IXMLDOMNode*)This->element );
xmlChar *pContent;
HRESULT hr = S_FALSE;
TRACE("%p\n", iface);
/* Nothing to do if NULL or an Empty string passed in. */
if(p == NULL || SysStringLen(p) == 0)
return S_OK;
pContent = xmlChar_from_wchar( (WCHAR*)p );
if(pContent)
{
if(xmlTextConcat(pDOMNode->node, pContent, SysStringLen(p) ) == 0)
hr = S_OK;
else
hr = E_FAIL;
}
else
hr = E_FAIL;
return hr;
}
static HRESULT WINAPI domtext_insertData(
IXMLDOMText *iface,
long offset, BSTR p)
{
FIXME("\n");
return E_NOTIMPL;
domtext *This = impl_from_IXMLDOMText( iface );
xmlnode *pDOMNode = impl_from_IXMLDOMNode( (IXMLDOMNode*)This->element );
xmlChar *pXmlContent;
BSTR sNewString;
HRESULT hr = S_FALSE;
long nLength = 0, nLengthP = 0;
xmlChar *str = NULL;
TRACE("%p\n", This);
/* If have a NULL or empty string, don't do anything. */
if(SysStringLen(p) == 0)
return S_OK;
if(offset < 0)
{
return E_INVALIDARG;
}
pXmlContent = xmlNodeGetContent(pDOMNode->node);
if(pXmlContent)
{
BSTR sContent = bstr_from_xmlChar( pXmlContent );
nLength = SysStringLen(sContent);
nLengthP = SysStringLen(p);
if(nLength < offset)
{
SysFreeString(sContent);
xmlFree(pXmlContent);
return E_INVALIDARG;
}
sNewString = SysAllocStringLen(NULL, nLength + nLengthP + 1);
if(sNewString)
{
if(offset > 0)
memcpy(sNewString, sContent, offset * sizeof(WCHAR));
memcpy(&sNewString[offset], p, nLengthP * sizeof(WCHAR));
if(offset+nLengthP < nLength)
memcpy(&sNewString[offset+nLengthP], &sContent[offset], (nLength-offset) * sizeof(WCHAR));
sNewString[nLengthP + nLength] = 0;
str = xmlChar_from_wchar((WCHAR*)sNewString);
if(str)
{
xmlNodeSetContent(pDOMNode->node, str);
hr = S_OK;
}
SysFreeString(sNewString);
}
SysFreeString(sContent);
xmlFree(pXmlContent);
}
return hr;
}
static HRESULT WINAPI domtext_deleteData(

60
reactos/dll/win32/msxml3/xmldoc.c
View file

@ -126,23 +126,50 @@ static ULONG WINAPI xmldoc_Release(IXMLDocument *iface)
static HRESULT WINAPI xmldoc_GetTypeInfoCount(IXMLDocument *iface, UINT* pctinfo)
{
FIXME("\n");
return E_NOTIMPL;
xmldoc *This = impl_from_IXMLDocument(iface);
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI xmldoc_GetTypeInfo(IXMLDocument *iface, UINT iTInfo,
LCID lcid, ITypeInfo** ppTInfo)
{
FIXME("\n");
return E_NOTIMPL;
xmldoc *This = impl_from_IXMLDocument(iface);
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLDocument_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI xmldoc_GetIDsOfNames(IXMLDocument *iface, REFIID riid,
LPOLESTR* rgszNames, UINT cNames,
LCID lcid, DISPID* rgDispId)
{
FIXME("\n");
return E_NOTIMPL;
xmldoc *This = impl_from_IXMLDocument(iface);
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLDocument_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI xmldoc_Invoke(IXMLDocument *iface, DISPID dispIdMember,
@ -150,8 +177,22 @@ static HRESULT WINAPI xmldoc_Invoke(IXMLDocument *iface, DISPID dispIdMember,
DISPPARAMS* pDispParams, VARIANT* pVarResult,
EXCEPINFO* pExcepInfo, UINT* puArgErr)
{
FIXME("\n");
return E_NOTIMPL;
xmldoc *This = impl_from_IXMLDocument(iface);
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLDocument_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI xmldoc_get_root(IXMLDocument *iface, IXMLElement **p)
@ -453,6 +494,9 @@ static HRESULT WINAPI xmldoc_createElement(IXMLDocument *iface, VARIANT vType,
if (V_VT(&vType) != VT_I4)
return E_INVALIDARG;
if(type_msxml_to_libxml(V_I4(&vType)) == -1)
return E_NOTIMPL;
node = xmlNewNode(NULL, empty);
node->type = type_msxml_to_libxml(V_I4(&vType));

57
reactos/dll/win32/msxml3/xmlelem.c
View file

@ -100,23 +100,50 @@ static ULONG WINAPI xmlelem_Release(IXMLElement *iface)
static HRESULT WINAPI xmlelem_GetTypeInfoCount(IXMLElement *iface, UINT* pctinfo)
{
FIXME("\n");
return E_NOTIMPL;
xmlelem *This = impl_from_IXMLElement(iface);
TRACE("(%p)->(%p)\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI xmlelem_GetTypeInfo(IXMLElement *iface, UINT iTInfo,
LCID lcid, ITypeInfo** ppTInfo)
{
FIXME("\n");
return E_NOTIMPL;
xmlelem *This = impl_from_IXMLElement(iface);
HRESULT hr;
TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
hr = get_typeinfo(IXMLElement_tid, ppTInfo);
return hr;
}
static HRESULT WINAPI xmlelem_GetIDsOfNames(IXMLElement *iface, REFIID riid,
LPOLESTR* rgszNames, UINT cNames,
LCID lcid, DISPID* rgDispId)
{
FIXME("\n");
return E_NOTIMPL;
xmlelem *This = impl_from_IXMLElement(iface);
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
lcid, rgDispId);
if(!rgszNames || cNames == 0 || !rgDispId)
return E_INVALIDARG;
hr = get_typeinfo(IXMLElement_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static HRESULT WINAPI xmlelem_Invoke(IXMLElement *iface, DISPID dispIdMember,
@ -124,8 +151,22 @@ static HRESULT WINAPI xmlelem_Invoke(IXMLElement *iface, DISPID dispIdMember,
DISPPARAMS* pDispParams, VARIANT* pVarResult,
EXCEPINFO* pExcepInfo, UINT* puArgErr)
{
FIXME("\n");
return E_NOTIMPL;
xmlelem *This = impl_from_IXMLElement(iface);
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo(IXMLElement_tid, &typeinfo);
if(SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
pVarResult, pExcepInfo, puArgErr);
ITypeInfo_Release(typeinfo);
}
return hr;
}
static inline BSTR str_dup_upper(BSTR str)

927
reactos/include/psdk/msxml2.idl
View file

@ -1,5 +1,6 @@
/*
* Copyright (C) 2005 Vijay Kiran Kamuju
* Copyright (C) 2008 Alistair Leslie-Hughes
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -23,6 +24,16 @@ import "unknwn.idl";
import "objidl.idl";
import "oaidl.idl";
[
uuid(f5078f18-c551-11d3-89b9-0000f81fe221),
version(3.0),
helpstring("Microsoft XML, v3.0")
]
library MSXML2
{
importlib("stdole2.tlb");
interface IXMLDOMImplementation;
interface IXMLDOMNode;
interface IXMLDOMDocumentFragment;
@ -47,6 +58,34 @@ interface IXTLRuntime;
interface IXSLTemplate;
interface IXSLProcessor;
/* SAX Interfaces */
interface ISAXAttributes;
interface ISAXContentHandler;
interface ISAXDeclHandler;
interface ISAXDTDHandler;
interface ISAXEntityResolver;
interface ISAXErrorHandler;
interface ISAXLexicalHandler;
interface ISAXLocator;
interface ISAXXMLFilter;
interface ISAXXMLReader;
interface IVBSAXAttributes;
interface IVBSAXContentHandler;
interface IVBSAXDeclHandler;
interface IVBSAXDTDHandler;
interface IVBSAXEntityResolver;
interface IVBSAXErrorHandler;
interface IVBSAXLexicalHandler;
interface IVBSAXLocator;
interface IVBSAXXMLFilter;
interface IVBSAXXMLReader;
interface IMXAttributes;
interface IMXReaderControl;
interface IMXWriter;
cpp_quote("#define DOMDocument DOMDocument2")
cpp_quote("#define CLSID_DOMDocument CLSID_DOMDocument2")
@ -1052,3 +1091,891 @@ coclass XSLTemplate30
{
[default] interface IXSLTemplate;
}
/*
* Sax Interfaces
*/
[
object,
local,
uuid(f078abe1-45d2-4832-91ea-4466ce2f25c9)
]
interface ISAXAttributes : IUnknown
{
HRESULT getLength(
[out, retval] int *length);
HRESULT getURI(
[in] int nIndex,
[out] const WCHAR **pUrl,
[out] int *pUriSize);
HRESULT getLocalName(
[in] int nIndex,
[out] const WCHAR **pLocalName,
[out] int *pLocalNameLength);
HRESULT getQName(
[in] int nIndex,
[out] const WCHAR **pQName,
[out] int *pQNameLength);
HRESULT getName(
[in] int nIndex,
[out] const WCHAR **pUri,
[out] int * pUriLength,
[out] const WCHAR ** pLocalName,
[out] int * pLocalNameSize,
[out] const WCHAR ** pQName,
[out] int * pQNameLength);
HRESULT getIndexFromName(
[in] const WCHAR * pUri,
[in] int cUriLength,
[in] const WCHAR * pLocalName,
[in] int cocalNameLength,
[out, retval] int * index);
HRESULT getIndexFromQName(
[in] const WCHAR * pQName,
[in] int nQNameLength,
[out, retval] int * index);
HRESULT getType(
[in] int nIndex,
[out] const WCHAR ** pType,
[out] int * pTypeLength);
HRESULT getTypeFromName(
[in] const WCHAR * pUri,
[in] int nUri,
[in] const WCHAR * pLocalName,
[in] int nLocalName,
[out] const WCHAR ** pType,
[out] int * nType);
HRESULT getTypeFromQName(
[in] const WCHAR * pQName,
[in] int nQName,
[out] const WCHAR ** pType,
[out] int * nType);
HRESULT getValue(
[in] int nIndex,
[out] const WCHAR ** pValue,
[out] int * nValue);
HRESULT getValueFromName(
[in] const WCHAR * pUri,
[in] int nUri,
[in] const WCHAR * pLocalName,
[in] int nLocalName,
[out] const WCHAR ** pValue,
[out] int * nValue);
HRESULT getValueFromQName(
[in] const WCHAR * pQName,
[in] int nQName,
[out] const WCHAR ** pValue,
[out] int * nValue);
};
[
object,
local,
uuid(1545cdfa-9e4e-4497-a8a4-2bf7d0112c44)
]
interface ISAXContentHandler : IUnknown
{
HRESULT putDocumentLocator(
[in] ISAXLocator * pLocator);
HRESULT startDocument();
HRESULT endDocument();
HRESULT startPrefixMapping(
[in] const WCHAR * pPrefix,
[in] int nPrefix,
[in] const WCHAR * pUri,
[in] int nUri);
HRESULT endPrefixMapping(
[in] const WCHAR * pPrefix,
[in] int nPrefix);
HRESULT startElement(
[in] const WCHAR * pNamespaceUri,
[in] int nNamespaceUri,
[in] const WCHAR * pLocalName,
[in] int nLocalName,
[in] const WCHAR * pQName,
[in] int nQName,
[in] ISAXAttributes * pAttr);
HRESULT endElement(
[in] const WCHAR * pNamespaceUri,
[in] int nNamespaceUri,
[in] const WCHAR * pLocalName,
[in] int nLocalName,
[in] const WCHAR * pQName,
[in] int nQName);
HRESULT characters(
[in] const WCHAR * pChars,
[in] int nChars);
HRESULT ignorableWhitespace(
[in] const WCHAR * pChars,
[in] int nChars);
HRESULT processingInstruction(
[in] const WCHAR * pTarget,
[in] int nTarget,
[in] const WCHAR * pData,
[in] int nData);
HRESULT skippedEntity(
[in] const WCHAR * pName,
[in] int nName);
};
[
object,
local,
uuid(862629ac-771a-47b2-8337-4e6843c1be90)
]
interface ISAXDeclHandler : IUnknown
{
HRESULT elementDecl(
[in] const WCHAR * pName,
[in] int nName,
[in] const WCHAR * pModel,
[in] int nModel);
HRESULT attributeDecl(
[in] const WCHAR * pElementName,
[in] int nElementName,
[in] const WCHAR * pAttributeName,
[in] int nAttributeName,
[in] const WCHAR * pType,
[in] int nType,
[in] const WCHAR * pValueDefault,
[in] int nValueDefault,
[in] const WCHAR * pValue,
[in] int nValue);
HRESULT internalEntityDecl(
[in] const WCHAR * pName,
[in] int nName,
[in] const WCHAR * pValue,
[in] int nValue);
HRESULT externalEntityDecl(
[in] const WCHAR * pName,
[in] int nName,
[in] const WCHAR * pPublicId,
[in] int nPublicId,
[in] const WCHAR * pSystemId,
[in] int nSystemId);
};
[
object,
local,
uuid(e15c1baf-afb3-4d60-8c36-19a8c45defed)
]
interface ISAXDTDHandler : IUnknown
{
HRESULT notationDecl(
[in] const WCHAR * pName,
[in] int nName,
[in] const WCHAR * pPublicId,
[in] int nPublicId,
[in] const WCHAR * pSystemId,
[in] int nSystemId);
HRESULT unparsedEntityDecl(
[in] const WCHAR * pName,
[in] int nName,
[in] const WCHAR * pPublicId,
[in] int nPublicId,
[in] const WCHAR * pSystemId,
[in] int nSystemId,
[in] const WCHAR * pNotationName,
[in] int nNotationName);
};
[
object,
local,
uuid(99bca7bd-e8c4-4d5f-a0cf-6d907901ff07),
]
interface ISAXEntityResolver : IUnknown
{
HRESULT resolveEntity(
[in] const WCHAR * pPublicId,
[in] const WCHAR * pSystemId,
[out, retval] VARIANT * ret);
};
[
object,
local,
uuid(a60511c4-ccf5-479e-98a3-dc8dc545b7d0)
]
interface ISAXErrorHandler : IUnknown
{
HRESULT error(
[in] ISAXLocator * pLocator,
[in] const WCHAR * pErrorMessage,
[in] HRESULT hrErrorCode);
HRESULT fatalError(
[in] ISAXLocator * pLocator,
[in] const WCHAR * pErrorMessage,
[in] HRESULT hrErrorCode);
HRESULT ignorableWarning(
[in] ISAXLocator * pLocator,
[in] const WCHAR * pErrorMessage,
[in] HRESULT hrErrorCode);
};
[
object,
local,
uuid(7f85d5f5-47a8-4497-bda5-84ba04819ea6)
]
interface ISAXLexicalHandler : IUnknown
{
HRESULT startDTD(
[in] const WCHAR * pName,
[in] int nName,
[in] const WCHAR * pPublicId,
[in] int nPublicId,
[in] const WCHAR * pSystemId,
[in] int nSystemId);
HRESULT endDTD();
HRESULT startEntity(
[in] const WCHAR * pName,
[in] int nName);
HRESULT endEntity(
[in] const WCHAR * pName,
[in] int nName);
HRESULT startCDATA();
HRESULT endCDATA();
HRESULT comment(
[in] const WCHAR * pChars,
[in] int nChars);
};
[
object,
local,
uuid(9b7e472a-0de4-4640-bff3-84d38a051c31)
]
interface ISAXLocator : IUnknown
{
HRESULT getColumnNumber(
[out, retval] int * nColumn);
HRESULT getLineNumber(
[out, retval] int * nLine);
HRESULT getPublicId(
[out, retval] const WCHAR ** publicId);
HRESULT getSystemId(
[out, retval] const WCHAR ** systemId);
};
[
local,
object,
uuid(70409222-ca09-4475-acb8-40312fe8d145)
]
interface ISAXXMLFilter : ISAXXMLReader
{
HRESULT getParent(
[out, retval] ISAXXMLReader ** pReader);
HRESULT putParent(
[in] ISAXXMLReader * reader);
};
[
local,
object,
uuid (a4f96ed0-f829-476e-81c0-cdc7bd2a0802)
]
interface ISAXXMLReader : IUnknown
{
HRESULT getFeature(
[in] const WCHAR * pFeature,
[out, retval] VARIANT_BOOL * pValue);
HRESULT putFeature(
[in] const WCHAR * pFeature,
[in] VARIANT_BOOL vfValue);
HRESULT getProperty(
[in] const WCHAR * pProp,
[out, retval] VARIANT * pValue);
HRESULT putProperty(
[in] const WCHAR * pProp,
[in] VARIANT value);
HRESULT getEntityResolver(
[out, retval] ISAXEntityResolver ** ppEntityResolver);
HRESULT putEntityResolver(
[in] ISAXEntityResolver * pEntityResolver);
HRESULT getContentHandler(
[out, retval] ISAXContentHandler ** pContentHandler);
HRESULT putContentHandler(
[in] ISAXContentHandler * contentHandler);
HRESULT getDTDHandler(
[out, retval] ISAXDTDHandler ** pDTDHandler);
HRESULT putDTDHandler(
[in] ISAXDTDHandler * pDTDHandler);
HRESULT getErrorHandler(
[out, retval] ISAXErrorHandler ** pErrorHandler);
HRESULT putErrorHandler(
[in] ISAXErrorHandler * errorHandler);
HRESULT getBaseURL(
[out, retval] const WCHAR ** pBaseUrl);
HRESULT putBaseURL(
[in] const WCHAR * pBaseUrl);
HRESULT getSecureBaseURL(
[out, retval] const WCHAR ** pSecureBaseUrl);
HRESULT putSecureBaseURL(
[in] const WCHAR * secureBaseUrl);
HRESULT parse(
[in] VARIANT varInput);
HRESULT parseURL(
[in] const WCHAR * url);
}
[
object,
dual,
uuid(10dc0586-132b-4cac-8bb3-db00ac8b7ee0)
]
interface IVBSAXAttributes : IDispatch
{
[propget, id(DISPID_SAX_ATTRIBUTES_LENGTH)]
HRESULT length( [out, retval] int * nLength);
[id(DISPID_SAX_ATTRIBUTES_GETURI)]
HRESULT getURI( [in] int nIndex, [out, retval] BSTR * uri);
[id(DISPID_SAX_ATTRIBUTES_GETLOCALNAME)]
HRESULT getLocalName( [in] int nIndex, [out, retval] BSTR * localName);
[id(DISPID_SAX_ATTRIBUTES_GETQNAME)]
HRESULT getQName( [in] int nIndex, [out, retval] BSTR * QName);
[id(DISPID_SAX_ATTRIBUTES_GETINDEXFROMNAME)]
HRESULT getIndexFromName( [in] BSTR uri,
[in] BSTR localName, [out, retval] int * nIndex);
[id(DISPID_SAX_ATTRIBUTES_GETINDEXFROMQNAME)]
HRESULT getIndexFromQName( [in] BSTR QName, [out, retval] int * nIndex);
[id(DISPID_SAX_ATTRIBUTES_GETTYPE)]
HRESULT getType( [in] int nIndex, [out, retval] BSTR * type);
[id(DISPID_SAX_ATTRIBUTES_GETTYPEFROMNAME)]
HRESULT getTypeFromName( [in] BSTR uri, [in] BSTR localName,
[out, retval] BSTR * type);
[id(DISPID_SAX_ATTRIBUTES_GETTYPEFROMQNAME)]
HRESULT getTypeFromQName( [in] BSTR QName, [out, retval] BSTR * type);
[id(DISPID_SAX_ATTRIBUTES_GETVALUE)]
HRESULT getValue( [in] int nIndex, [out, retval] BSTR * value);
[id(DISPID_SAX_ATTRIBUTES_GETVALUEFROMNAME)]
HRESULT getValueFromName( [in] BSTR uri,
[in] BSTR localName,
[out, retval] BSTR * value);
[id(DISPID_SAX_ATTRIBUTES_GETVALUEFROMQNAME)]
HRESULT getValueFromQName( [in] BSTR QName, [out, retval] BSTR * value);
};
[
object,
dual,
uuid(2ed7290a-4dd5-4b46-bb26-4e4155e77faa)
]
interface IVBSAXContentHandler : IDispatch
{
[propputref, id(DISPID_SAX_CONTENTHANDLER_DOCUMENTLOCATOR)]
HRESULT documentLocator( [in] IVBSAXLocator * oLocator);
[id(DISPID_SAX_CONTENTHANDLER_STARTDOCUMENT)]
HRESULT startDocument();
[id(DISPID_SAX_CONTENTHANDLER_ENDDOCUMENT)]
HRESULT endDocument();
[id(DISPID_SAX_CONTENTHANDLER_STARTPREFIXMAPPING)]
HRESULT startPrefixMapping( [in, out] BSTR * prefix, [in, out] BSTR * uri);
[id(DISPID_SAX_CONTENTHANDLER_ENDPREFIXMAPPING)]
HRESULT endPrefixMapping( [in, out] BSTR * prefix);
[id(DISPID_SAX_CONTENTHANDLER_STARTELEMENT)]
HRESULT startElement( [in, out] BSTR * namespaceURI,
[in, out] BSTR * localName,
[in, out] BSTR * QName,
[in] IVBSAXAttributes * oAttributes);
[id(DISPID_SAX_CONTENTHANDLER_ENDELEMENT)]
HRESULT endElement( [in, out] BSTR * namespaceURI,
[in, out] BSTR * localName, [in, out] BSTR * strQName);
[id(DISPID_SAX_CONTENTHANDLER_CHARACTERS)]
HRESULT characters( [in, out] BSTR * chars);
[id(DISPID_SAX_CONTENTHANDLER_IGNORABLEWHITESPACE)]
HRESULT ignorableWhitespace( [in, out] BSTR * chars);
[id(DISPID_SAX_CONTENTHANDLER_PROCESSINGINSTRUCTION)]
HRESULT processingInstruction( [in, out] BSTR * target,
[in, out] BSTR * data);
[id(DISPID_SAX_CONTENTHANDLER_SKIPPEDENTITY)]
HRESULT skippedEntity( [in, out] BSTR * name);
};
[
object,
dual,
uuid(e8917260-7579-4be1-b5dd-7afbfa6f077b)
]
interface IVBSAXDeclHandler : IDispatch
{
[id(DISPID_SAX_DECLHANDLER_ELEMENTDECL)]
HRESULT elementDecl(
[in, out] BSTR * name,
[in, out] BSTR * model);
[id(DISPID_SAX_DECLHANDLER_ATTRIBUTEDECL)]
HRESULT attributeDecl(
[in, out] BSTR * elementName,
[in, out] BSTR * attributeName,
[in, out] BSTR * type,
[in, out] BSTR * valueDefault,
[in, out] BSTR * value);
[id(DISPID_SAX_DECLHANDLER_INTERNALENTITYDECL)]
HRESULT internalEntityDecl(
[in, out] BSTR * name,
[in, out] BSTR * value);
[id(DISPID_SAX_DECLHANDLER_EXTERNALENTITYDECL)]
HRESULT externalEntityDecl(
[in, out] BSTR * name,
[in, out] BSTR * publicId,
[in, out] BSTR * systemId);
};
[
object,
dual,
uuid(24fb3297-302d-4620-ba39-3a732d850558)
]
interface IVBSAXDTDHandler : IDispatch
{
[id(DISPID_SAX_DTDHANDLER_NOTATIONDECL)]
HRESULT notationDecl(
[in, out] BSTR * name,
[in, out] BSTR * publicId,
[in, out] BSTR * systemId);
[id(DISPID_SAX_DTDHANDLER_UNPARSEDENTITYDECL)]
HRESULT unparsedEntityDecl(
[in, out] BSTR * name,
[in, out] BSTR * publicId,
[in, out] BSTR * systemId,
[in, out] BSTR * notationName);
};
[
object,
dual,
uuid(0c05d096-f45b-4aca-ad1a-aa0bc25518dc)
]
interface IVBSAXEntityResolver : IDispatch
{
[id(DISPID_SAX_ENTITYRESOLVER_RESOLVEENTITY)]
HRESULT resolveEntity(
[in, out] BSTR * publicId,
[in, out] BSTR * systemId,
[out, retval] VARIANT * ret);
};
[
object,
dual,
uuid(d963d3fe-173c-4862-9095-b92f66995f52)
]
interface IVBSAXErrorHandler : IDispatch
{
[id(DISPID_SAX_ERRORHANDLER_ERROR)]
HRESULT error(
[in] IVBSAXLocator * locator,
[in, out] BSTR * errorMessage,
[in] long errorCode);
[id(DISPID_SAX_ERRORHANDLER_FATALERROR)]
HRESULT fatalError(
[in] IVBSAXLocator * locator,
[in, out] BSTR * errorMessage,
[in] long errorCode);
[id(DISPID_SAX_ERRORHANDLER_IGNORABLEWARNING)]
HRESULT ignorableWarning(
[in] IVBSAXLocator * locator,
[in, out] BSTR * errorMessage,
[in] long errorCode);
};
[
object,
dual,
uuid(032aac35-8c0e-4d9d-979f-e3b702935576)
]
interface IVBSAXLexicalHandler : IDispatch
{
[id(DISPID_SAX_LEXICALHANDLER_STARTDTD)]
HRESULT startDTD(
[in, out] BSTR * name,
[in, out] BSTR * publicId,
[in, out] BSTR * systemId);
[id(DISPID_SAX_LEXICALHANDLER_ENDDTD)]
HRESULT endDTD();
[id(DISPID_SAX_LEXICALHANDLER_STARTENTITY)]
HRESULT startEntity([in, out] BSTR * name);
[id(DISPID_SAX_LEXICALHANDLER_ENDENTITY)]
HRESULT endEntity([in, out] BSTR * name);
[id(DISPID_SAX_LEXICALHANDLER_STARTCDATA)]
HRESULT startCDATA();
[id(DISPID_SAX_LEXICALHANDLER_ENDCDATA)]
HRESULT endCDATA();
[id(DISPID_SAX_LEXICALHANDLER_COMMENT)]
HRESULT comment( [in, out] BSTR * chars);
};
[
object,
uuid(796e7ac5-5aa2-4eff-acad-3faaf01a3288)
]
interface IVBSAXLocator : IDispatch
{
[propget, id(DISPID_SAX_LOCATOR_COLUMNNUMBER)]
HRESULT columnNumber( [out, retval] int * column);
[propget, id(DISPID_SAX_LOCATOR_LINENUMBER)]
HRESULT lineNumber( [out, retval] int * line);
[propget, id(DISPID_SAX_LOCATOR_PUBLICID)]
HRESULT publicId( [out, retval] BSTR * publicId);
[propget, id(DISPID_SAX_LOCATOR_SYSTEMID)]
HRESULT systemId( [out, retval] BSTR * systemId);
};
[
object,
dual,
uuid(1299eb1b-5b88-433e-82de-82ca75ad4e04)
]
interface IVBSAXXMLFilter : IDispatch
{
[propget, id(DISPID_SAX_XMLFILTER_PARENT)]
HRESULT parent( [out, retval] IVBSAXXMLReader ** reader);
[propputref, id(DISPID_SAX_XMLFILTER_PARENT)]
HRESULT parent( [in] IVBSAXXMLReader * reader);
};
[
dual,
object,
uuid (8c033caa-6cd6-4f73-b728-4531af74945f)
]
interface IVBSAXXMLReader : IDispatch
{
[id(DISPID_SAX_XMLREADER_GETFEATURE)]
HRESULT getFeature( [in] const WCHAR * pFeature,
[out, retval] VARIANT_BOOL * pValue);
[id(DISPID_SAX_XMLREADER_PUTFEATURE)]
HRESULT putFeature( [in] const WCHAR * pFeature,
[in] VARIANT_BOOL vfValue);
[id(DISPID_SAX_XMLREADER_GETPROPERTY)]
HRESULT getProperty( [in] const WCHAR * pProp,
[out, retval] VARIANT * pValue);
[id(DISPID_SAX_XMLREADER_PUTPROPERTY)]
HRESULT putProperty( [in] const WCHAR * pProp, [in] VARIANT value);
[propget, id(DISPID_SAX_XMLREADER_ENTITYRESOLVER)]
HRESULT getEntityResolver(
[out, retval] IVBSAXEntityResolver ** ppEntityResolver);
[propputref, id(DISPID_SAX_XMLREADER_ENTITYRESOLVER)]
HRESULT putEntityResolver( [in] IVBSAXEntityResolver * pEntityResolver);
[propget, id(DISPID_SAX_XMLREADER_CONTENTHANDLER)]
HRESULT getContentHandler(
[out, retval] IVBSAXContentHandler ** pContentHandler);
[propputref, id(DISPID_SAX_XMLREADER_CONTENTHANDLER)]
HRESULT putContentHandler([in] IVBSAXContentHandler * contentHandler);
[propget, id(DISPID_SAX_XMLREADER_DTDHANDLER)]
HRESULT getDTDHandler([out, retval] IVBSAXDTDHandler ** pDTDHandler);
[propputref, id(DISPID_SAX_XMLREADER_DTDHANDLER)]
HRESULT putDTDHandler([in] IVBSAXDTDHandler * pDTDHandler);
[propget, id(DISPID_SAX_XMLREADER_ERRORHANDLER)]
HRESULT getErrorHandler([out, retval] IVBSAXErrorHandler ** pErrorHandler);
[propputref, id(DISPID_SAX_XMLREADER_ERRORHANDLER)]
HRESULT putErrorHandler([in] IVBSAXErrorHandler * errorHandler);
[propget, id(DISPID_SAX_XMLREADER_BASEURL)]
HRESULT getBaseURL([out, retval] const WCHAR ** pBaseUrl);
[propput, id(DISPID_SAX_XMLREADER_BASEURL)]
HRESULT putBaseURL([in] const WCHAR * pBaseUrl);
[propget, id(DISPID_SAX_XMLREADER_SECUREBASEURL)]
HRESULT getSecureBaseURL([out, retval] const WCHAR ** pSecureBaseUrl);
[propput, id(DISPID_SAX_XMLREADER_SECUREBASEURL)]
HRESULT putSecureBaseURL([in] const WCHAR * secureBaseUrl);
[propget, id(DISPID_SAX_XMLREADER_PARSE)]
HRESULT parse( [in] VARIANT varInput);
[propput, id(DISPID_SAX_XMLREADER_PARSE)]
HRESULT parseURL([in] const WCHAR * url);
}
[
object,
dual,
uuid(f10d27cc-3ec0-415c-8ed8-77ab1c5e7262)
]
interface IMXAttributes : IDispatch
{
[id(DISPID_MX_ATTRIBUTES_ADDATTRIBUTE)]
HRESULT addAttribute(
[in] BSTR uri,
[in] BSTR localName,
[in] BSTR QName,
[in] BSTR type,
[in] BSTR value);
[id(DISPID_MX_ATTRIBUTES_ADDATTRIBUTEFROMINDEX)]
HRESULT addAttributeFromIndex( [in] VARIANT atts,
[in] int index);
[id(DISPID_MX_ATTRIBUTES_CLEAR)]
HRESULT clear();
[id(DISPID_MX_ATTRIBUTES_REMOVEATTRIBUTE)]
HRESULT removeAttribute( [in] int index);
[id(DISPID_MX_ATTRIBUTES_SETATTRIBUTE)]
HRESULT setAttribute(
[in] int index,
[in] BSTR uri,
[in] BSTR localName,
[in] BSTR QName,
[in] BSTR type,
[in] BSTR value);
[id(DISPID_MX_ATTRIBUTES_SETATTRIBUTES)]
HRESULT setAttributes( [in] VARIANT atts);
[id(DISPID_MX_ATTRIBUTES_SETLOCALNAME)]
HRESULT setLocalName( [in] int index,
[in] BSTR localName);
[id(DISPID_MX_ATTRIBUTES_SETQNAME)]
HRESULT setQName(
[in] int index,
[in] BSTR QName);
[id(DISPID_MX_ATTRIBUTES_SETTYPE)]
HRESULT setType( [in] int index, [in] BSTR type);
[id(DISPID_MX_ATTRIBUTES_SETURI)]
HRESULT setURI( [in] int index, [in] BSTR uri);
[id(DISPID_MX_ATTRIBUTES_SETVALUE)]
HRESULT setValue([in] int index, [in] BSTR value);
};
[
object,
dual,
uuid(808f4e35-8d5a-4fbe-8466-33a41279ed30)
]
interface IMXReaderControl : IDispatch
{
[id(DISPID_MX_READER_CONTROL_ABORT)]
HRESULT abort();
[id(DISPID_MX_READER_CONTROL_RESUME)]
HRESULT resume();
[id(DISPID_MX_READER_CONTROL_SUSPEND)]
HRESULT suspend();
};
[
object,
dual,
uuid(4d7ff4ba-1565-4ea8-94e1-6e724a46f98d)
]
interface IMXWriter : IDispatch
{
[propput, id(DISPID_MX_WRITER_OUTPUT)]
HRESULT output ( [in] VARIANT Destination);
[propget, id(DISPID_MX_WRITER_OUTPUT)]
HRESULT output ( [out, retval] VARIANT * Destination);
[propput, id(DISPID_MX_WRITER_ENCODING)]
HRESULT encoding ([in] BSTR encoding);
[propget, id(DISPID_MX_WRITER_ENCODING)]
HRESULT encoding ([out, retval] BSTR * encoding);
[propput, id(DISPID_MX_WRITER_BYTEORDERMARK)]
HRESULT byteOrderMark ([in] VARIANT_BOOL writeByteOrderMark);
[propget, id(DISPID_MX_WRITER_BYTEORDERMARK)]
HRESULT byteOrderMark ([out, retval] VARIANT_BOOL * writeByteOrderMark);
[propput, id(DISPID_MX_WRITER_INDENT)]
HRESULT indent ([in] VARIANT_BOOL indentMode);
[propget, id(DISPID_MX_WRITER_INDENT)]
HRESULT indent ([out, retval] VARIANT_BOOL * indentMode);
[propput, id(DISPID_MX_WRITER_STANDALONE)]
HRESULT standalone ([in] VARIANT_BOOL value);
[propget, id(DISPID_MX_WRITER_STANDALONE)]
HRESULT standalone ([out, retval] VARIANT_BOOL * value);
[propput, id(DISPID_MX_WRITER_OMITXMLDECLARATION)]
HRESULT omitXMLDeclaration ([in] VARIANT_BOOL value);
[propget, id(DISPID_MX_WRITER_OMITXMLDECLARATION)]
HRESULT omitXMLDeclaration ([out, retval] VARIANT_BOOL * value);
[propput, id(DISPID_MX_WRITER_VERSION)]
HRESULT version ([in] BSTR version);
[propget, id(DISPID_MX_WRITER_VERSION)]
HRESULT version ([out, retval] BSTR * version);
[propput, id(DISPID_MX_WRITER_DISABLEOUTPUTESCAPING)]
HRESULT disableOutputEscaping([in] VARIANT_BOOL value);
[propget, id(DISPID_MX_WRITER_DISABLEOUTPUTESCAPING)]
HRESULT disableOutputEscaping([out, retval] VARIANT_BOOL * value);
[id(DISPID_MX_WRITER_FLUSH)]
HRESULT flush();
};
[
uuid(079aa557-4a18-424a-8eee-e39f0a8d41b9)
]
coclass SAXXMLReader
{
[default] interface IVBSAXXMLReader;
interface ISAXXMLReader;
interface IMXReaderControl;
};
[
uuid(3124c396-fb13-4836-a6ad-1317f1713688)
]
coclass SAXXMLReader30
{
[default] interface IVBSAXXMLReader;
interface ISAXXMLReader;
interface IMXReaderControl;
};
[
uuid(fc220ad8-a72a-4ee8-926e-0b7ad152a020)
]
coclass MXXMLWriter
{
[default] interface IMXWriter;
interface ISAXContentHandler;
interface ISAXErrorHandler;
interface ISAXDTDHandler;
interface ISAXLexicalHandler;
interface ISAXDeclHandler;
interface IVBSAXContentHandler;
interface IVBSAXDeclHandler;
interface IVBSAXDTDHandler;
interface IVBSAXErrorHandler;
interface IVBSAXLexicalHandler;
};
[
uuid(3d813dfe-6c91-4a4e-8f41-04346a841d9c)
]
coclass MXXMLWriter30
{
[default] interface IMXWriter;
interface ISAXContentHandler;
interface ISAXDeclHandler;
interface ISAXDTDHandler;
interface ISAXErrorHandler;
interface ISAXLexicalHandler;
interface IVBSAXContentHandler;
interface IVBSAXDeclHandler;
interface IVBSAXDTDHandler;
interface IVBSAXErrorHandler;
interface IVBSAXLexicalHandler;
};
[
uuid(4dd441ad-526d-4a77-9f1b-9841ed802fb0)
]
coclass SAXAttributes
{
[default] interface IMXAttributes;
interface IVBSAXAttributes;
interface ISAXAttributes;
};
[
uuid(3e784a01-f3ae-4dc0-9354-9526b9370eba)
]
coclass SAXAttributes30
{
[default] interface IMXAttributes;
interface IVBSAXAttributes;
interface ISAXAttributes;
};
} /* Library MSXML */

127
reactos/include/psdk/msxml2did.h
View file

@ -1,5 +1,6 @@
/*
* Copyright (C) 2005 Vijay Kiran Kamuju
* Copyright (C) 2008 Alistair Leslie-Hughes
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@ -268,4 +269,130 @@
#define DISPID_XMLDSO_DOCUMENT 0x10001
#define DISPID_XMLDSO_JAVADSOCOMPATIBLE 0x10002
/* SAX Defines */
#define DISPID_SAX_XMLREADER__MIN 0x00000501
#define DISPID_SAX_XMLREADER__MAX 0x00010000
#define DISPID_SAX_XMLREADER__BASE DISPID_SAX_XMLREADER__MIN
#define DISPID_SAX_XMLREADER 0x00000501
#define DISPID_SAX_XMLREADER_GETFEATURE 0x00000502
#define DISPID_SAX_XMLREADER_PUTFEATURE 0x00000503
#define DISPID_SAX_XMLREADER_GETPROPERTY 0x00000504
#define DISPID_SAX_XMLREADER_PUTPROPERTY 0x00000505
#define DISPID_SAX_XMLREADER_ENTITYRESOLVER 0x00000506
#define DISPID_SAX_XMLREADER_CONTENTHANDLER 0x00000507
#define DISPID_SAX_XMLREADER_DTDHANDLER 0x00000508
#define DISPID_SAX_XMLREADER_ERRORHANDLER 0x00000509
#define DISPID_SAX_XMLREADER_BASEURL 0x0000050A
#define DISPID_SAX_XMLREADER_SECUREBASEURL 0x0000050B
#define DISPID_SAX_XMLREADER_PARSE 0x0000050C
#define DISPID_SAX_XMLREADER_PARSEURL 0x0000050D
#define DISPID_SAX_XMLREADER_PARENT 0x0000050E
#define DISPID_SAX_XMLFILTER 0x00000510
#define DISPID_SAX_XMLFILTER_GETFEATURE 0x00000511
#define DISPID_SAX_XMLFILTER_PUTFEATURE 0x00000512
#define DISPID_SAX_XMLFILTER_GETPROPERTY 0x00000513
#define DISPID_SAX_XMLFILTER_PUTPROPERTY 0x00000514
#define DISPID_SAX_XMLFILTER_ENTITYRESOLVER 0x00000515
#define DISPID_SAX_XMLFILTER_CONTENTHANDLER 0x00000516
#define DISPID_SAX_XMLFILTER_DTDHANDLER 0x00000517
#define DISPID_SAX_XMLFILTER_ERRORHANDLER 0x00000518
#define DISPID_SAX_XMLFILTER_BASEURL 0x00000519
#define DISPID_SAX_XMLFILTER_SECUREBASEURL 0x0000051A
#define DISPID_SAX_XMLFILTER_PARSE 0x0000051B
#define DISPID_SAX_XMLFILTER_PARSEURL 0x0000051C
#define DISPID_SAX_XMLFILTER_PARENT 0x0000051D
#define DISPID_SAX_LOCATOR 0x00000520
#define DISPID_SAX_LOCATOR_COLUMNNUMBER 0x00000521
#define DISPID_SAX_LOCATOR_LINENUMBER 0x00000522
#define DISPID_SAX_LOCATOR_PUBLICID 0x00000523
#define DISPID_SAX_LOCATOR_SYSTEMID 0x00000524
#define DISPID_SAX_ENTITYRESOLVER 0x00000526
#define DISPID_SAX_ENTITYRESOLVER_RESOLVEENTITY 0x00000527
#define DISPID_SAX_CONTENTHANDLER 0x00000529
#define DISPID_SAX_CONTENTHANDLER_DOCUMENTLOCATOR 0x0000052A
#define DISPID_SAX_CONTENTHANDLER_STARTDOCUMENT 0x0000052B
#define DISPID_SAX_CONTENTHANDLER_ENDDOCUMENT 0x0000052C
#define DISPID_SAX_CONTENTHANDLER_STARTPREFIXMAPPING 0x0000052D
#define DISPID_SAX_CONTENTHANDLER_ENDPREFIXMAPPING 0x0000052E
#define DISPID_SAX_CONTENTHANDLER_STARTELEMENT 0x0000052F
#define DISPID_SAX_CONTENTHANDLER_ENDELEMENT 0x00000530
#define DISPID_SAX_CONTENTHANDLER_CHARACTERS 0x00000531
#define DISPID_SAX_CONTENTHANDLER_IGNORABLEWHITESPACE 0x00000532
#define DISPID_SAX_CONTENTHANDLER_PROCESSINGINSTRUCTION 0x00000533
#define DISPID_SAX_CONTENTHANDLER_SKIPPEDENTITY 0x00000534
#define DISPID_SAX_DTDHANDLER 0x00000536
#define DISPID_SAX_DTDHANDLER_NOTATIONDECL 0x00000537
#define DISPID_SAX_DTDHANDLER_UNPARSEDENTITYDECL 0x00000538
#define DISPID_SAX_ERRORHANDLER 0x0000053A
#define DISPID_SAX_ERRORHANDLER_ERROR 0x0000053B
#define DISPID_SAX_ERRORHANDLER_FATALERROR 0x0000053C
#define DISPID_SAX_ERRORHANDLER_IGNORABLEWARNING 0x0000053D
#define DISPID_SAX_ATTRIBUTES 0x0000053F
#define DISPID_SAX_ATTRIBUTES_LENGTH 0x00000540
#define DISPID_SAX_ATTRIBUTES_GETURI 0x00000541
#define DISPID_SAX_ATTRIBUTES_GETLOCALNAME 0x00000542
#define DISPID_SAX_ATTRIBUTES_GETQNAME 0x00000543
#define DISPID_SAX_ATTRIBUTES_GETINDEXFROMNAME 0x00000544
#define DISPID_SAX_ATTRIBUTES_GETINDEXFROMQNAME 0x00000545
#define DISPID_SAX_ATTRIBUTES_GETTYPE 0x00000546
#define DISPID_SAX_ATTRIBUTES_GETTYPEFROMNAME 0x00000547
#define DISPID_SAX_ATTRIBUTES_GETTYPEFROMQNAME 0x00000548
#define DISPID_SAX_ATTRIBUTES_GETVALUE 0x00000549
#define DISPID_SAX_ATTRIBUTES_GETVALUEFROMNAME 0x0000054A
#define DISPID_SAX_ATTRIBUTES_GETVALUEFROMQNAME 0x0000054B
#define DISPID_SAX_LEXICALHANDLER 0x0000054D
#define DISPID_SAX_LEXICALHANDLER_STARTDTD 0x0000054E
#define DISPID_SAX_LEXICALHANDLER_ENDDTD 0x0000054F
#define DISPID_SAX_LEXICALHANDLER_STARTENTITY 0x00000550
#define DISPID_SAX_LEXICALHANDLER_ENDENTITY 0x00000551
#define DISPID_SAX_LEXICALHANDLER_STARTCDATA 0x00000552
#define DISPID_SAX_LEXICALHANDLER_ENDCDATA 0x00000553
#define DISPID_SAX_LEXICALHANDLER_COMMENT 0x00000554
#define DISPID_SAX_DECLHANDLER 0x00000556
#define DISPID_SAX_DECLHANDLER_ELEMENTDECL 0x00000557
#define DISPID_SAX_DECLHANDLER_ATTRIBUTEDECL 0x00000558
#define DISPID_SAX_DECLHANDLER_INTERNALENTITYDECL 0x00000559
#define DISPID_SAX_DECLHANDLER_EXTERNALENTITYDECL 0x0000055A
#define DISPID_MX_ATTRIBUTES_ADDATTRIBUTE 0x0000055D
#define DISPID_MX_ATTRIBUTES_CLEAR 0x0000055E
#define DISPID_MX_ATTRIBUTES_REMOVEATTRIBUTE 0x0000055F
#define DISPID_MX_ATTRIBUTES_SETATTRIBUTE 0x00000560
#define DISPID_MX_ATTRIBUTES_SETATTRIBUTES 0x00000561
#define DISPID_MX_ATTRIBUTES_SETLOCALNAME 0x00000562
#define DISPID_MX_ATTRIBUTES_SETQNAME 0x00000563
#define DISPID_MX_ATTRIBUTES_SETTYPE 0x00000564
#define DISPID_MX_ATTRIBUTES_SETURI 0x00000565
#define DISPID_MX_ATTRIBUTES_SETVALUE 0x00000566
#define DISPID_MX_ATTRIBUTES_ADDATTRIBUTEFROMINDEX 0x00000567
#define DISPID_MX_WRITER 0x00000568
#define DISPID_MX_WRITER_OUTPUT 0x00000569
#define DISPID_MX_WRITER_DESTINATION 0x0000056A
#define DISPID_MX_WRITER_ENCODING 0x0000056B
#define DISPID_MX_WRITER_BYTEORDERMARK 0x0000056C
#define DISPID_MX_WRITER_INDENT 0x0000056D
#define DISPID_MX_WRITER_STANDALONE 0x0000056E
#define DISPID_MX_WRITER_OMITXMLDECLARATION 0x0000056F
#define DISPID_MX_WRITER_VERSION 0x00000570
#define DISPID_MX_WRITER_DISABLEOUTPUTESCAPING 0x00000571
#define DISPID_MX_WRITER_FLUSH 0x00000572
#define DISPID_MX_WRITER_RESET 0x00000573
#define DISPID_MX_READER_CONTROL 0x00000575
#define DISPID_MX_READER_CONTROL_ABORT 0x00000576
#define DISPID_MX_READER_CONTROL_RESUME 0x00000577
#define DISPID_MX_READER_CONTROL_SUSPEND 0x00000578
#endif /* __MSXML2DID_H__ */

74
reactos/include/psdk/xmldom.idl
View file

@ -550,7 +550,7 @@ oleautomation,
uuid(2933bf88-7b36-11d2-b20e-00c04f983e60),
pointer_default(unique)
]
interface IXMLDOMComment : IXMLDOMNode
interface IXMLDOMComment : IXMLDOMCharacterData
{
/* empty */
}
@ -591,6 +591,7 @@ interface IXMLDOMCDATASection : IXMLDOMText
{
/* empty */
}
[
local,
object,
@ -613,6 +614,77 @@ interface IXMLDOMDocumentType : IXMLDOMNode
HRESULT notations( [out,retval] IXMLDOMNamedNodeMap **notationMap );
}
[
local,
object,
odl,
dual,
nonextensible,
oleautomation,
uuid(2933bf8c-7b36-11d2-b20e-00c04f983e60),
pointer_default(unique)
]
interface IXMLDOMNotation : IXMLDOMNode
{
[propget, id(DISPID_DOM_NOTATION_PUBLICID)]
HRESULT publicId([out, retval] VARIANT *publicId);
[propget, id(DISPID_DOM_NOTATION_SYSTEMID)]
HRESULT systemId([out, retval] VARIANT *systemId);
}
[
local,
object,
odl,
dual,
nonextensible,
oleautomation,
uuid(2933bf8d-7b36-11d2-b20e-00c04f983e60),
pointer_default(unique)
]
interface IXMLDOMEntity : IXMLDOMNode
{
[propget, id(DISPID_DOM_ENTITY_PUBLICID)]
HRESULT publicId([out, retval] VARIANT *publicId);
[propget, id(DISPID_DOM_ENTITY_SYSTEMID)]
HRESULT systemId([out, retval] VARIANT *systemId);
[propget, id(DISPID_DOM_ENTITY_NOTATIONNAME)]
HRESULT notationName([out, retval] BSTR *name);
}
[
local,
object,
odl,
dual,
nonextensible,
oleautomation,
uuid(2933bf8e-7b36-11d2-b20e-00c04f983e60),
pointer_default(unique)
]
interface IXMLDOMEntityReference : IXMLDOMNode
{
}
[
local,
object,
odl,
dual,
nonextensible,
oleautomation,
uuid(2933bf8f-7b36-11d2-b20e-00c04f983e60),
pointer_default(unique)
]
interface IXMLDOMImplementation : IDispatch
{
[id(DISPID_DOM_IMPLEMENTATION_HASFEATURE)]
HRESULT hasFeature([in] BSTR feature, [in] BSTR version, [out, retval] VARIANT_BOOL *pbool);
}
[
local,
object,

15
reactos/include/psdk/xmldomdid.h
View file

@ -171,6 +171,21 @@
#define DISPID_DOM_DOCUMENTTYPE_NOTATIONS 131
#define DISPID_DOM_DOCUMENTTYPE__TOP 132
#define DISPID_DOM_NOTATION 133
#define DISPID_DOM_NOTATION_PUBLICID 134
#define DISPID_DOM_NOTATION_SYSTEMID 135
#define DISPID_DOM_NOTATION__TOP 136
#define DISPID_DOM_ENTITY 137
#define DISPID_DOM_ENTITY_PUBLICID 138
#define DISPID_DOM_ENTITY_SYSTEMID 139
#define DISPID_DOM_ENTITY_NOTATIONNAME 140
#define DISPID_DOM_ENTITY__TOP 141
#define DISPID_DOM_IMPLEMENTATION 142
#define DISPID_DOM_IMPLEMENTATION_HASFEATURE 143
#define DISPID_DOM_IMPLEMENTATION__TOP 144
#define DISPID_DOM_ERROR 0x000000b0
#define DISPID_DOM_ERROR_ERRORCODE 0x000000b1