diff --git a/reactos/dll/win32/msxml3/attribute.c b/reactos/dll/win32/msxml3/attribute.c index 689829996f1..2681a76fab0 100644 --- a/reactos/dll/win32/msxml3/attribute.c +++ b/reactos/dll/win32/msxml3/attribute.c @@ -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( diff --git a/reactos/dll/win32/msxml3/comment.c b/reactos/dll/win32/msxml3/comment.c index f9fc927923d..9a45be601e9 100644 --- a/reactos/dll/win32/msxml3/comment.c +++ b/reactos/dll/win32/msxml3/comment.c @@ -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( diff --git a/reactos/dll/win32/msxml3/domdoc.c b/reactos/dll/win32/msxml3/domdoc.c index af5097cfe5d..61f01f1fdb7 100644 --- a/reactos/dll/win32/msxml3/domdoc.c +++ b/reactos/dll/win32/msxml3/domdoc.c @@ -19,6 +19,7 @@ */ #define COBJMACROS +#define NONAMELESSUNION #include "config.h" @@ -31,9 +32,10 @@ #include "ole2.h" #include "msxml2.h" #include "wininet.h" -#include "urlmon.h" #include "winreg.h" #include "shlwapi.h" +#include "ocidl.h" +#include "objsafe.h" #include "wine/debug.h" @@ -47,128 +49,12 @@ static const WCHAR SZ_PROPERTY_SELECTION_LANGUAGE[] = {'S','e','l','e','c','t',' static const WCHAR SZ_VALUE_XPATH[] = {'X','P','a','t','h',0}; static const WCHAR SZ_VALUE_XSLPATTERN[] = {'X','S','L','P','a','t','t','e','r','n',0}; -typedef struct { - const struct IBindStatusCallbackVtbl *lpVtbl; -} bsc; - -static HRESULT WINAPI bsc_QueryInterface( - IBindStatusCallback *iface, - REFIID riid, - LPVOID *ppobj ) -{ - if (IsEqualGUID(riid, &IID_IUnknown) || - IsEqualGUID(riid, &IID_IBindStatusCallback)) - { - IBindStatusCallback_AddRef( iface ); - *ppobj = iface; - return S_OK; - } - - FIXME("interface %s not implemented\n", debugstr_guid(riid)); - return E_NOINTERFACE; -} - -static ULONG WINAPI bsc_AddRef( - IBindStatusCallback *iface ) -{ - return 2; -} - -static ULONG WINAPI bsc_Release( - IBindStatusCallback *iface ) -{ - return 1; -} - -static HRESULT WINAPI bsc_OnStartBinding( - IBindStatusCallback* iface, - DWORD dwReserved, - IBinding* pib) -{ - return S_OK; -} - -static HRESULT WINAPI bsc_GetPriority( - IBindStatusCallback* iface, - LONG* pnPriority) -{ - return S_OK; -} - -static HRESULT WINAPI bsc_OnLowResource( - IBindStatusCallback* iface, - DWORD reserved) -{ - return S_OK; -} - -static HRESULT WINAPI bsc_OnProgress( - IBindStatusCallback* iface, - ULONG ulProgress, - ULONG ulProgressMax, - ULONG ulStatusCode, - LPCWSTR szStatusText) -{ - return S_OK; -} - -static HRESULT WINAPI bsc_OnStopBinding( - IBindStatusCallback* iface, - HRESULT hresult, - LPCWSTR szError) -{ - return S_OK; -} - -static HRESULT WINAPI bsc_GetBindInfo( - IBindStatusCallback* iface, - DWORD* grfBINDF, - BINDINFO* pbindinfo) -{ - *grfBINDF = BINDF_RESYNCHRONIZE; - - return S_OK; -} - -static HRESULT WINAPI bsc_OnDataAvailable( - IBindStatusCallback* iface, - DWORD grfBSCF, - DWORD dwSize, - FORMATETC* pformatetc, - STGMEDIUM* pstgmed) -{ - return S_OK; -} - -static HRESULT WINAPI bsc_OnObjectAvailable( - IBindStatusCallback* iface, - REFIID riid, - IUnknown* punk) -{ - return S_OK; -} - -static const struct IBindStatusCallbackVtbl bsc_vtbl = -{ - bsc_QueryInterface, - bsc_AddRef, - bsc_Release, - bsc_OnStartBinding, - bsc_GetPriority, - bsc_OnLowResource, - bsc_OnProgress, - bsc_OnStopBinding, - bsc_GetBindInfo, - bsc_OnDataAvailable, - bsc_OnObjectAvailable -}; - -static bsc domdoc_bsc = { &bsc_vtbl }; - typedef struct _domdoc { const struct IXMLDOMDocument2Vtbl *lpVtbl; const struct IPersistStreamVtbl *lpvtblIPersistStream; + const struct IObjectWithSiteVtbl *lpvtblIObjectWithSite; + const struct IObjectSafetyVtbl *lpvtblIObjectSafety; LONG ref; VARIANT_BOOL async; VARIANT_BOOL validating; @@ -178,12 +64,33 @@ typedef struct _domdoc IUnknown *node_unk; IXMLDOMNode *node; IXMLDOMSchemaCollection *schema; + bsc_t *bsc; HRESULT error; - /* IPersistStream */ - IStream *stream; + /* IPersistStream */ + IStream *stream; + + /* IObjectWithSite*/ + IUnknown *site; + + /* IObjectSafety */ + DWORD safeopt; } domdoc; +static xmlDocPtr doparse( char *ptr, int len ) +{ +#ifdef HAVE_XMLREADMEMORY + /* + * use xmlReadMemory if possible so we can suppress + * writing errors to stderr + */ + return xmlReadMemory( ptr, len, NULL, NULL, + XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS ); +#else + return xmlParseMemory( ptr, len ); +#endif +} + LONG xmldoc_add_ref(xmlDocPtr doc) { LONG ref = InterlockedIncrement((LONG*)&doc->_private); @@ -219,6 +126,17 @@ static inline domdoc *impl_from_IPersistStream(IPersistStream *iface) return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblIPersistStream)); } +static inline domdoc *impl_from_IObjectWithSite(IObjectWithSite *iface) +{ + return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblIObjectWithSite)); +} + +static inline domdoc *impl_from_IObjectSafety(IObjectSafety *iface) +{ + return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblIObjectSafety)); +} + + /************************************************************************ * xmldoc implementation of IPersistStream. */ @@ -246,8 +164,14 @@ static ULONG WINAPI xmldoc_IPersistStream_Release( static HRESULT WINAPI xmldoc_IPersistStream_GetClassID( IPersistStream *iface, CLSID *classid) { - FIXME("(%p,%p): stub!\n", iface, classid); - return E_NOTIMPL; + TRACE("(%p,%p): stub!\n", iface, classid); + + if(!classid) + return E_POINTER; + + *classid = CLSID_DOMDocument2; + + return S_OK; } static HRESULT WINAPI xmldoc_IPersistStream_IsDirty( @@ -345,14 +269,16 @@ static HRESULT WINAPI domdoc_QueryInterface( IXMLDOMDocument2 *iface, REFIID rii TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject ); + *ppvObject = NULL; + if ( IsEqualGUID( riid, &IID_IUnknown ) || + IsEqualGUID( riid, &IID_IDispatch ) || IsEqualGUID( riid, &IID_IXMLDOMDocument ) || IsEqualGUID( riid, &IID_IXMLDOMDocument2 ) ) { *ppvObject = iface; } - else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) || - IsEqualGUID( riid, &IID_IDispatch ) ) + else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) ) { return IUnknown_QueryInterface(This->node_unk, riid, ppvObject); } @@ -360,6 +286,15 @@ static HRESULT WINAPI domdoc_QueryInterface( IXMLDOMDocument2 *iface, REFIID rii { *ppvObject = (IPersistStream*)&(This->lpvtblIPersistStream); } + else if (IsEqualGUID(&IID_IObjectWithSite, riid)) + { + *ppvObject = (IObjectWithSite*)&(This->lpvtblIObjectWithSite); + } + else if(IsEqualGUID(&IID_IRunnableObject, riid)) + { + TRACE("IID_IRunnableObject not supported returning NULL\n"); + return E_NOINTERFACE; + } else { FIXME("interface %s not implemented\n", debugstr_guid(riid)); @@ -392,6 +327,11 @@ static ULONG WINAPI domdoc_Release( ref = InterlockedDecrement( &This->ref ); if ( ref == 0 ) { + if(This->bsc) + detach_bsc(This->bsc); + + if (This->site) + IUnknown_Release( This->site ); IUnknown_Release( This->node_unk ); if(This->schema) IXMLDOMSchemaCollection_Release( This->schema ); if (This->stream) IStream_Release(This->stream); @@ -403,16 +343,27 @@ static ULONG WINAPI domdoc_Release( static HRESULT WINAPI domdoc_GetTypeInfoCount( IXMLDOMDocument2 *iface, UINT* pctinfo ) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( iface ); + + TRACE("(%p)->(%p)\n", This, pctinfo); + + *pctinfo = 1; + + return S_OK; } static HRESULT WINAPI domdoc_GetTypeInfo( IXMLDOMDocument2 *iface, UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo ) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( iface ); + HRESULT hr; + + TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo); + + hr = get_typeinfo(IXMLDOMDocument2_tid, ppTInfo); + + return hr; } static HRESULT WINAPI domdoc_GetIDsOfNames( @@ -423,8 +374,24 @@ static HRESULT WINAPI domdoc_GetIDsOfNames( LCID lcid, DISPID* rgDispId) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( 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(IXMLDOMDocument2_tid, &typeinfo); + if(SUCCEEDED(hr)) + { + hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId); + ITypeInfo_Release(typeinfo); + } + + return hr; } @@ -439,8 +406,22 @@ static HRESULT WINAPI domdoc_Invoke( EXCEPINFO* pExcepInfo, UINT* puArgErr) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( 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(IXMLDOMDocument2_tid, &typeinfo); + if(SUCCEEDED(hr)) + { + hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams, + pVarResult, pExcepInfo, puArgErr); + ITypeInfo_Release(typeinfo); + } + + return hr; } @@ -791,8 +772,12 @@ static HRESULT WINAPI domdoc_get_implementation( IXMLDOMDocument2 *iface, IXMLDOMImplementation** impl ) { - FIXME("\n"); - return E_NOTIMPL; + if(!impl) + return E_INVALIDARG; + + *impl = (IXMLDOMImplementation*)create_doc_Implementation(); + + return S_OK; } static HRESULT WINAPI domdoc_get_documentElement( @@ -828,12 +813,26 @@ static HRESULT WINAPI domdoc_get_documentElement( } -static HRESULT WINAPI domdoc_documentElement( +static HRESULT WINAPI domdoc_put_documentElement( IXMLDOMDocument2 *iface, IXMLDOMElement* DOMElement ) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( iface ); + IXMLDOMNode *elementNode; + xmlnode *xmlNode; + HRESULT hr; + + TRACE("(%p)->(%p)\n", This, DOMElement); + + hr = IXMLDOMElement_QueryInterface( DOMElement, &IID_IXMLDOMNode, (void**)&elementNode ); + if(FAILED(hr)) + return hr; + + xmlNode = impl_from_IXMLDOMNode( elementNode ); + xmlDocSetRootElement( get_doc(This), xmlNode->node); + IXMLDOMNode_Release( elementNode ); + + return S_OK; } @@ -868,8 +867,26 @@ static HRESULT WINAPI domdoc_createDocumentFragment( IXMLDOMDocument2 *iface, IXMLDOMDocumentFragment** docFrag ) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( iface ); + xmlNodePtr xmlnode; + + TRACE("%p\n", iface); + + if(!docFrag) + return E_INVALIDARG; + + *docFrag = NULL; + + xmlnode = xmlNewDocFragment(get_doc( This ) ); + + if(!xmlnode) + return E_FAIL; + + xmlnode->doc = get_doc( This ); + + *docFrag = (IXMLDOMDocumentFragment*)create_doc_fragment(xmlnode); + + return S_OK; } @@ -909,8 +926,29 @@ static HRESULT WINAPI domdoc_createComment( BSTR data, IXMLDOMComment** comment ) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( iface ); + xmlNodePtr xmlnode; + xmlChar *xml_content; + + TRACE("%p->(%s %p)\n", iface, debugstr_w(data), comment); + + if(!comment) + return E_INVALIDARG; + + *comment = NULL; + + xml_content = xmlChar_from_wchar((WCHAR*)data); + xmlnode = xmlNewComment(xml_content); + HeapFree(GetProcessHeap(), 0, xml_content); + + if(!xmlnode) + return E_FAIL; + + xmlnode->doc = get_doc( This ); + + *comment = (IXMLDOMComment*)create_comment(xmlnode); + + return S_OK; } @@ -919,8 +957,29 @@ static HRESULT WINAPI domdoc_createCDATASection( BSTR data, IXMLDOMCDATASection** cdata ) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( iface ); + xmlNodePtr xmlnode; + xmlChar *xml_content; + + TRACE("%p->(%s %p)\n", iface, debugstr_w(data), cdata); + + if(!cdata) + return E_INVALIDARG; + + *cdata = NULL; + + xml_content = xmlChar_from_wchar((WCHAR*)data); + xmlnode = xmlNewCDataBlock(get_doc( This ), xml_content, strlen( (char*)xml_content) ); + HeapFree(GetProcessHeap(), 0, xml_content); + + if(!xmlnode) + return E_FAIL; + + xmlnode->doc = get_doc( This ); + + *cdata = (IXMLDOMCDATASection*)create_cdata(xmlnode); + + return S_OK; } @@ -937,6 +996,12 @@ static HRESULT WINAPI domdoc_createProcessingInstruction( TRACE("%p->(%s %s %p)\n", iface, debugstr_w(target), debugstr_w(data), pi); + if(!pi) + return E_INVALIDARG; + + if(!target || lstrlenW(target) == 0) + return E_FAIL; + xml_target = xmlChar_from_wchar((WCHAR*)target); xml_content = xmlChar_from_wchar((WCHAR*)data); @@ -960,8 +1025,29 @@ static HRESULT WINAPI domdoc_createAttribute( BSTR name, IXMLDOMAttribute** attribute ) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( iface ); + xmlNodePtr xmlnode; + xmlChar *xml_name; + + TRACE("%p->(%s %p)\n", iface, debugstr_w(name), attribute); + + if(!attribute) + return E_INVALIDARG; + + *attribute = NULL; + + xml_name = xmlChar_from_wchar((WCHAR*)name); + xmlnode = (xmlNode *)xmlNewProp(NULL, xml_name, NULL); + HeapFree(GetProcessHeap(), 0, xml_name); + + if(!xmlnode) + return E_FAIL; + + xmlnode->doc = get_doc( This ); + + *attribute = (IXMLDOMAttribute*)create_attribute(xmlnode); + + return S_OK; } @@ -970,8 +1056,29 @@ static HRESULT WINAPI domdoc_createEntityReference( BSTR name, IXMLDOMEntityReference** entityRef ) { - FIXME("\n"); - return E_NOTIMPL; + domdoc *This = impl_from_IXMLDOMDocument2( iface ); + xmlNodePtr xmlnode; + xmlChar *xml_name; + + TRACE("%p\n", iface); + + if(!entityRef) + return E_INVALIDARG; + + *entityRef = NULL; + + xml_name = xmlChar_from_wchar((WCHAR*)name); + xmlnode = xmlNewReference(get_doc( This ), xml_name ); + HeapFree(GetProcessHeap(), 0, xml_name); + + if(!xmlnode) + return E_FAIL; + + xmlnode->doc = get_doc( This ); + + *entityRef = (IXMLDOMEntityReference*)create_doc_entity_ref(xmlnode); + + return S_OK; } @@ -1030,6 +1137,17 @@ static HRESULT WINAPI domdoc_createNode( *node = create_node(xmlnode); TRACE("created %p\n", xmlnode); break; + case NODE_ATTRIBUTE: + xmlnode = (xmlNode *)xmlNewProp(NULL, xml_name, NULL); + if(xmlnode) + { + xmlnode->doc = get_doc( This ); + + *node = (IXMLDOMNode*)create_attribute(xmlnode); + } + + TRACE("created %p\n", xmlnode); + break; default: FIXME("unhandled node type %d\n", node_type); @@ -1053,99 +1171,34 @@ static HRESULT WINAPI domdoc_nodeFromID( return E_NOTIMPL; } -static xmlDocPtr doparse( char *ptr, int len ) +static HRESULT domdoc_onDataAvailable(void *obj, char *ptr, DWORD len) { -#ifdef HAVE_XMLREADMEMORY - /* - * use xmlReadMemory if possible so we can suppress - * writing errors to stderr - */ - return xmlReadMemory( ptr, len, NULL, NULL, - XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS ); -#else - return xmlParseMemory( ptr, len ); -#endif + domdoc *This = obj; + xmlDocPtr xmldoc; + + xmldoc = doparse( ptr, len ); + if(xmldoc) { + xmldoc->_private = 0; + attach_xmlnode(This->node, (xmlNodePtr) xmldoc); + } + + return S_OK; } -static xmlDocPtr doread( LPWSTR filename ) +static HRESULT doread( domdoc *This, LPWSTR filename ) { - xmlDocPtr xmldoc = NULL; + bsc_t *bsc; HRESULT hr; - IBindCtx *pbc; - IStream *stream, *memstream; - WCHAR url[INTERNET_MAX_URL_LENGTH]; - BYTE buf[4096]; - DWORD read, written; - TRACE("%s\n", debugstr_w( filename )); - - if(!PathIsURLW(filename)) - { - WCHAR fullpath[MAX_PATH]; - DWORD needed = sizeof(url)/sizeof(WCHAR); - - if(!PathSearchAndQualifyW(filename, fullpath, sizeof(fullpath)/sizeof(WCHAR))) - { - WARN("can't find path\n"); - return NULL; - } - - if(FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0))) - { - ERR("can't create url from path\n"); - return NULL; - } - filename = url; - } - - hr = CreateBindCtx(0, &pbc); - if(SUCCEEDED(hr)) - { - hr = RegisterBindStatusCallback(pbc, (IBindStatusCallback*)&domdoc_bsc.lpVtbl, NULL, 0); - if(SUCCEEDED(hr)) - { - IMoniker *moniker; - hr = CreateURLMoniker(NULL, filename, &moniker); - if(SUCCEEDED(hr)) - { - hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (LPVOID*)&stream); - IMoniker_Release(moniker); - } - } - IBindCtx_Release(pbc); - } + hr = bind_url(filename, domdoc_onDataAvailable, This, &bsc); if(FAILED(hr)) - return NULL; + return hr; - hr = CreateStreamOnHGlobal(NULL, TRUE, &memstream); - if(FAILED(hr)) - { - IStream_Release(stream); - return NULL; - } + if(This->bsc) + detach_bsc(This->bsc); - do - { - IStream_Read(stream, buf, sizeof(buf), &read); - hr = IStream_Write(memstream, buf, read, &written); - } while(SUCCEEDED(hr) && written != 0 && read != 0); - - if(SUCCEEDED(hr)) - { - HGLOBAL hglobal; - hr = GetHGlobalFromStream(memstream, &hglobal); - if(SUCCEEDED(hr)) - { - DWORD len = GlobalSize(hglobal); - char *ptr = GlobalLock(hglobal); - if(len != 0) - xmldoc = doparse( ptr, len ); - GlobalUnlock(hglobal); - } - } - IStream_Release(memstream); - IStream_Release(stream); - return xmldoc; + This->bsc = bsc; + return S_OK; } static HRESULT WINAPI domdoc_load( @@ -1155,10 +1208,10 @@ static HRESULT WINAPI domdoc_load( { domdoc *This = impl_from_IXMLDOMDocument2( iface ); LPWSTR filename = NULL; - xmlDocPtr xmldoc = NULL; HRESULT hr = S_FALSE; IXMLDOMDocument2 *pNewDoc = NULL; IStream *pStream = NULL; + xmlDocPtr xmldoc; TRACE("type %d\n", V_VT(&xmlSource) ); @@ -1228,9 +1281,9 @@ static HRESULT WINAPI domdoc_load( if ( filename ) { - xmldoc = doread( filename ); + hr = doread( This, filename ); - if ( !xmldoc ) + if ( FAILED(hr) ) This->error = E_FAIL; else { @@ -1239,11 +1292,12 @@ static HRESULT WINAPI domdoc_load( } } - if(!xmldoc) + if(!filename || FAILED(hr)) { xmldoc = xmlNewDoc(NULL); - - xmldoc->_private = 0; - attach_xmlnode(This->node, (xmlNodePtr) xmldoc); + xmldoc->_private = 0; + attach_xmlnode(This->node, (xmlNodePtr) xmldoc); + hr = S_FALSE; + } TRACE("ret (%d)\n", hr); @@ -1385,20 +1439,47 @@ static HRESULT WINAPI domdoc_save( { domdoc *This = impl_from_IXMLDOMDocument2( iface ); HANDLE handle; - xmlChar *mem; + xmlChar *mem, *p; int size; HRESULT ret = S_OK; DWORD written; - TRACE("(%p)->(var(vt %x, %s))\n", This, V_VT(&destination), + TRACE("(%p)->(var(vt %d, %s))\n", This, V_VT(&destination), V_VT(&destination) == VT_BSTR ? debugstr_w(V_BSTR(&destination)) : NULL); - if(V_VT(&destination) != VT_BSTR) + if(V_VT(&destination) != VT_BSTR && V_VT(&destination) != VT_UNKNOWN) { - FIXME("Unhandled vt %x\n", V_VT(&destination)); + FIXME("Unhandled vt %d\n", V_VT(&destination)); return S_FALSE; } + if(V_VT(&destination) == VT_UNKNOWN) + { + IUnknown *pUnk = V_UNKNOWN(&destination); + IXMLDOMDocument *pDocument; + + ret = IXMLDOMDocument_QueryInterface(pUnk, &IID_IXMLDOMDocument2, (void**)&pDocument); + if(ret == S_OK) + { + BSTR bXML; + VARIANT_BOOL bSuccessful; + + ret = IXMLDOMDocument_get_xml(iface, &bXML); + if(ret == S_OK) + { + ret = IXMLDOMDocument_loadXML(pDocument, bXML, &bSuccessful); + + SysFreeString(bXML); + } + + IXMLDOMDocument_Release(pDocument); + } + + TRACE("ret %d", ret); + + return ret; + } + handle = CreateFileW( V_BSTR(&destination), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); if( handle == INVALID_HANDLE_VALUE ) @@ -1408,7 +1489,23 @@ static HRESULT WINAPI domdoc_save( } xmlDocDumpMemory(get_doc(This), &mem, &size); - if(!WriteFile(handle, mem, (DWORD)size, &written, NULL) || written != (DWORD)size) + + /* + * libxml2 always adds XML declaration on top of the file and one for each processing instruction node in DOM tree. + * MSXML adds XML declaration only for processing instruction nodes. + * We skip the first XML declaration generated by libxml2 to get exactly what we need. + */ + p = mem; + if(size > 2 && p[0] == '<' && p[1] == '?') { + while(p < mem+size && (p[0] != '?' || p[1] != '>')) + p++; + p += 2; + while(p < mem+size && isspace(*p)) + p++; + size -= p-mem; + } + + if(!WriteFile(handle, p, (DWORD)size, &written, NULL) || written != (DWORD)size) { WARN("write error\n"); ret = S_FALSE; @@ -1701,7 +1798,7 @@ static const struct IXMLDOMDocument2Vtbl domdoc_vtbl = domdoc_get_doctype, domdoc_get_implementation, domdoc_get_documentElement, - domdoc_documentElement, + domdoc_put_documentElement, domdoc_createElement, domdoc_createDocumentFragment, domdoc_createTextNode, @@ -1739,13 +1836,141 @@ static const struct IXMLDOMDocument2Vtbl domdoc_vtbl = domdoc_getProperty }; -HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj) +/* xmldoc implementation of IObjectWithSite */ +static HRESULT WINAPI +xmldoc_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject ) +{ + domdoc *This = impl_from_IObjectWithSite(iface); + return IXMLDocument_QueryInterface( (IXMLDocument *)This, riid, ppvObject ); +} + +static ULONG WINAPI +xmldoc_ObjectWithSite_AddRef( IObjectWithSite* iface ) +{ + domdoc *This = impl_from_IObjectWithSite(iface); + return IXMLDocument_AddRef((IXMLDocument *)This); +} + +static ULONG WINAPI +xmldoc_ObjectWithSite_Release( IObjectWithSite* iface ) +{ + domdoc *This = impl_from_IObjectWithSite(iface); + return IXMLDocument_Release((IXMLDocument *)This); +} + +static HRESULT WINAPI +xmldoc_GetSite( IObjectWithSite *iface, REFIID iid, void ** ppvSite ) +{ + domdoc *This = impl_from_IObjectWithSite(iface); + + TRACE("%p %s %p\n", This, debugstr_guid( iid ), ppvSite ); + + if ( !This->site ) + return E_FAIL; + + return IUnknown_QueryInterface( This->site, iid, ppvSite ); +} + +static HRESULT WINAPI +xmldoc_SetSite( IObjectWithSite *iface, IUnknown *punk ) +{ + domdoc *This = impl_from_IObjectWithSite(iface); + + TRACE("%p %p\n", iface, punk); + + if(!punk) + { + if(This->site) + { + IUnknown_Release( This->site ); + This->site = NULL; + } + + return S_OK; + } + + if ( punk ) + IUnknown_AddRef( punk ); + + if(This->site) + IUnknown_Release( This->site ); + + This->site = punk; + + return S_OK; +} + +static const IObjectWithSiteVtbl domdocObjectSite = +{ + xmldoc_ObjectWithSite_QueryInterface, + xmldoc_ObjectWithSite_AddRef, + xmldoc_ObjectWithSite_Release, + xmldoc_SetSite, + xmldoc_GetSite, +}; + +static HRESULT WINAPI xmldoc_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv) +{ + domdoc *This = impl_from_IObjectSafety(iface); + return IXMLDocument_QueryInterface( (IXMLDocument *)This, riid, ppv ); +} + +static ULONG WINAPI xmldoc_Safety_AddRef(IObjectSafety *iface) +{ + domdoc *This = impl_from_IObjectSafety(iface); + return IXMLDocument_AddRef((IXMLDocument *)This); +} + +static ULONG WINAPI xmldoc_Safety_Release(IObjectSafety *iface) +{ + domdoc *This = impl_from_IObjectSafety(iface); + return IXMLDocument_Release((IXMLDocument *)This); +} + +#define SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER) + +static HRESULT WINAPI xmldoc_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid, + DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions) +{ + domdoc *This = impl_from_IObjectSafety(iface); + + TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), pdwSupportedOptions, pdwEnabledOptions); + + if(!pdwSupportedOptions || !pdwEnabledOptions) + return E_POINTER; + + *pdwSupportedOptions = SUPPORTED_OPTIONS; + *pdwEnabledOptions = This->safeopt; + + return S_OK; +} + +static HRESULT WINAPI xmldoc_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid, + DWORD dwOptionSetMask, DWORD dwEnabledOptions) +{ + domdoc *This = impl_from_IObjectSafety(iface); + + TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), dwOptionSetMask, dwEnabledOptions); + + if(dwOptionSetMask & ~SUPPORTED_OPTIONS) + return E_FAIL; + + This->safeopt = dwEnabledOptions & dwEnabledOptions; + return S_OK; +} + +static const IObjectSafetyVtbl domdocObjectSafetyVtbl = { + xmldoc_Safety_QueryInterface, + xmldoc_Safety_AddRef, + xmldoc_Safety_Release, + xmldoc_Safety_GetInterfaceSafetyOptions, + xmldoc_Safety_SetInterfaceSafetyOptions +}; + +HRESULT DOMDocument_create_from_xmldoc(xmlDocPtr xmldoc, IXMLDOMDocument2 **document) { domdoc *doc; HRESULT hr; - xmlDocPtr xmldoc; - - TRACE("(%p,%p)\n", pUnkOuter, ppObj); doc = HeapAlloc( GetProcessHeap(), 0, sizeof (*doc) ); if( !doc ) @@ -1753,6 +1978,8 @@ HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj) doc->lpVtbl = &domdoc_vtbl; doc->lpvtblIPersistStream = &xmldoc_IPersistStream_VTable; + doc->lpvtblIObjectWithSite = &domdocObjectSite; + doc->lpvtblIObjectSafety = &domdocObjectSafetyVtbl; doc->ref = 1; doc->async = 0; doc->validating = 0; @@ -1762,20 +1989,13 @@ HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj) doc->error = S_OK; doc->schema = NULL; doc->stream = NULL; - - xmldoc = xmlNewDoc(NULL); - if(!xmldoc) - { - HeapFree(GetProcessHeap(), 0, doc); - return E_OUTOFMEMORY; - } - - xmldoc->_private = 0; + doc->site = NULL; + doc->safeopt = 0; + doc->bsc = NULL; doc->node_unk = create_basic_node( (xmlNodePtr)xmldoc, (IUnknown*)&doc->lpVtbl ); if(!doc->node_unk) { - xmlFreeDoc(xmldoc); HeapFree(GetProcessHeap(), 0, doc); return E_FAIL; } @@ -1790,12 +2010,46 @@ HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj) /* The ref on doc->node is actually looped back into this object, so release it */ IXMLDOMNode_Release(doc->node); - *ppObj = &doc->lpVtbl; + *document = (IXMLDOMDocument2*)&doc->lpVtbl; - TRACE("returning iface %p\n", *ppObj); + TRACE("returning iface %p\n", *document); return S_OK; } +HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj) +{ + xmlDocPtr xmldoc; + HRESULT hr; + + TRACE("(%p,%p)\n", pUnkOuter, ppObj); + + xmldoc = xmlNewDoc(NULL); + if(!xmldoc) + return E_OUTOFMEMORY; + + xmldoc->_private = 0; + + hr = DOMDocument_create_from_xmldoc(xmldoc, (IXMLDOMDocument2**)ppObj); + if(FAILED(hr)) + xmlFreeDoc(xmldoc); + + return hr; +} + +IUnknown* create_domdoc( xmlNodePtr document ) +{ + HRESULT hr; + LPVOID pObj = NULL; + + TRACE("(%p)\n", document); + + hr = DOMDocument_create_from_xmldoc((xmlDocPtr)document, (IXMLDOMDocument2**)&pObj); + if (FAILED(hr)) + return NULL; + + return (IUnknown*)pObj; +} + #else HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj) diff --git a/reactos/dll/win32/msxml3/element.c b/reactos/dll/win32/msxml3/element.c index e7f03d676e8..4b9bf6cae04 100644 --- a/reactos/dll/win32/msxml3/element.c +++ b/reactos/dll/win32/msxml3/element.c @@ -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); } diff --git a/reactos/dll/win32/msxml3/factory.c b/reactos/dll/win32/msxml3/factory.c index a973b04c96d..beb5bbcf8b2 100644 --- a/reactos/dll/win32/msxml3/factory.c +++ b/reactos/dll/win32/msxml3/factory.c @@ -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; diff --git a/reactos/dll/win32/msxml3/main.c b/reactos/dll/win32/msxml3/main.c index 62bf2b51430..b301ab75239 100644 --- a/reactos/dll/win32/msxml3/main.c +++ b/reactos/dll/win32/msxml3/main.c @@ -21,17 +21,24 @@ #include "config.h" +#define COBJMACROS + #include #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 +#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; diff --git a/reactos/dll/win32/msxml3/msxml3.rbuild b/reactos/dll/win32/msxml3/msxml3.rbuild index bad16c86556..790125f9f99 100644 --- a/reactos/dll/win32/msxml3/msxml3.rbuild +++ b/reactos/dll/win32/msxml3/msxml3.rbuild @@ -45,5 +45,14 @@ uuid.c xmldoc.c xmlelem.c + saxreader.c + bsc.c + cdata.c + dispex.c + docfrag.c + domimpl.c + entityref.c + . + msxml3_v1.idl msxml3.spec diff --git a/reactos/dll/win32/msxml3/msxml_private.h b/reactos/dll/win32/msxml3/msxml_private.h index 4914a58ee38..ae3a4e6cbd2 100644 --- a/reactos/dll/win32/msxml3/msxml_private.h +++ b/reactos/dll/win32/msxml3/msxml_private.h @@ -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__ */ diff --git a/reactos/dll/win32/msxml3/node.c b/reactos/dll/win32/msxml3/node.c index 63f3ad53a09..68bf8818a45 100644 --- a/reactos/dll/win32/msxml3/node.c +++ b/reactos/dll/win32/msxml3/node.c @@ -33,25 +33,49 @@ #include "msxml_private.h" +#ifdef HAVE_LIBXSLT +# ifdef HAVE_LIBXSLT_PATTERN_H +# include +# endif +# ifdef HAVE_LIBXSLT_TRANSFORM_H +# include +# endif +# include +# include +#endif + +#ifdef HAVE_LIBXML2 +# include +#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 ); diff --git a/reactos/dll/win32/msxml3/nodelist.c b/reactos/dll/win32/msxml3/nodelist.c index 9b1aa904833..c4427751d35 100644 --- a/reactos/dll/win32/msxml3/nodelist.c +++ b/reactos/dll/win32/msxml3/nodelist.c @@ -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) diff --git a/reactos/dll/win32/msxml3/nodemap.c b/reactos/dll/win32/msxml3/nodemap.c index 94b3f627fd6..f41df2f7d08 100644 --- a/reactos/dll/win32/msxml3/nodemap.c +++ b/reactos/dll/win32/msxml3/nodemap.c @@ -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( diff --git a/reactos/dll/win32/msxml3/parseerror.c b/reactos/dll/win32/msxml3/parseerror.c index f70ed5278e1..4db078b690e 100644 --- a/reactos/dll/win32/msxml3/parseerror.c +++ b/reactos/dll/win32/msxml3/parseerror.c @@ -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( diff --git a/reactos/dll/win32/msxml3/pi.c b/reactos/dll/win32/msxml3/pi.c index 3f997e2280b..a38f355ce04 100644 --- a/reactos/dll/win32/msxml3/pi.c +++ b/reactos/dll/win32/msxml3/pi.c @@ -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 = diff --git a/reactos/dll/win32/msxml3/queryresult.c b/reactos/dll/win32/msxml3/queryresult.c index 85d7acaf6e5..8b7836279a3 100644 --- a/reactos/dll/win32/msxml3/queryresult.c +++ b/reactos/dll/win32/msxml3/queryresult.c @@ -50,10 +50,9 @@ WINE_DEFAULT_DEBUG_CHANNEL(msxml); #include -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 diff --git a/reactos/dll/win32/msxml3/regsvr.c b/reactos/dll/win32/msxml3/regsvr.c index 3a0c6bd55f3..320d51e280d 100644 --- a/reactos/dll/win32/msxml3/regsvr.c +++ b/reactos/dll/win32/msxml3/regsvr.c @@ -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 #include +#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; } diff --git a/reactos/dll/win32/msxml3/schema.c b/reactos/dll/win32/msxml3/schema.c index 0eec06ccf81..08f4933a348 100644 --- a/reactos/dll/win32/msxml3/schema.c +++ b/reactos/dll/win32/msxml3/schema.c @@ -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 ) diff --git a/reactos/dll/win32/msxml3/text.c b/reactos/dll/win32/msxml3/text.c index a1e7d49677d..4b32ac9ce1e 100644 --- a/reactos/dll/win32/msxml3/text.c +++ b/reactos/dll/win32/msxml3/text.c @@ -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( diff --git a/reactos/dll/win32/msxml3/xmldoc.c b/reactos/dll/win32/msxml3/xmldoc.c index a4c0850b095..fb653adf780 100644 --- a/reactos/dll/win32/msxml3/xmldoc.c +++ b/reactos/dll/win32/msxml3/xmldoc.c @@ -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)); diff --git a/reactos/dll/win32/msxml3/xmlelem.c b/reactos/dll/win32/msxml3/xmlelem.c index 5af43a77c91..8166e6ac5bb 100644 --- a/reactos/dll/win32/msxml3/xmlelem.c +++ b/reactos/dll/win32/msxml3/xmlelem.c @@ -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) diff --git a/reactos/include/psdk/msxml2.idl b/reactos/include/psdk/msxml2.idl index fe7794046d6..112a5c4b3b6 100644 --- a/reactos/include/psdk/msxml2.idl +++ b/reactos/include/psdk/msxml2.idl @@ -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 */ diff --git a/reactos/include/psdk/msxml2did.h b/reactos/include/psdk/msxml2did.h index 1a718de4151..f2adaaff427 100644 --- a/reactos/include/psdk/msxml2did.h +++ b/reactos/include/psdk/msxml2did.h @@ -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__ */ diff --git a/reactos/include/psdk/xmldom.idl b/reactos/include/psdk/xmldom.idl index 746113144bb..bf85acfb7f0 100644 --- a/reactos/include/psdk/xmldom.idl +++ b/reactos/include/psdk/xmldom.idl @@ -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, diff --git a/reactos/include/psdk/xmldomdid.h b/reactos/include/psdk/xmldomdid.h index 4e8dc855722..a299157c3ac 100644 --- a/reactos/include/psdk/xmldomdid.h +++ b/reactos/include/psdk/xmldomdid.h @@ -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