| /* | |
| * DOM Document implementation | |
| * | |
| * Copyright 2005 Mike McCormack | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| */ | |
| #define COBJMACROS | |
| #include "config.h" | |
| #include <stdarg.h> | |
| #ifdef HAVE_LIBXML2 | |
| # include <libxml/parser.h> | |
| # include <libxml/xmlerror.h> | |
| #endif | |
| #include "windef.h" | |
| #include "winbase.h" | |
| #include "winuser.h" | |
| #include "winnls.h" | |
| #include "ole2.h" | |
| #include "msxml6.h" | |
| #include "msxml_private.h" | |
| #include "wine/debug.h" | |
| #ifdef HAVE_LIBXML2 | |
| WINE_DEFAULT_DEBUG_CHANNEL(msxml); | |
| static const xmlChar DT_prefix[] = "dt"; | |
| static const xmlChar DT_nsURI[] = "urn:schemas-microsoft-com:datatypes"; | |
| typedef struct _domelem | |
| { | |
| xmlnode node; | |
| IXMLDOMElement IXMLDOMElement_iface; | |
| LONG ref; | |
| } domelem; | |
| static const struct nodemap_funcs domelem_attr_map; | |
| static const tid_t domelem_se_tids[] = { | |
| IXMLDOMNode_tid, | |
| IXMLDOMElement_tid, | |
| NULL_tid | |
| }; | |
| static inline domelem *impl_from_IXMLDOMElement( IXMLDOMElement *iface ) | |
| { | |
| return CONTAINING_RECORD(iface, domelem, IXMLDOMElement_iface); | |
| } | |
| static inline xmlNodePtr get_element( const domelem *This ) | |
| { | |
| return This->node.node; | |
| } | |
| static HRESULT WINAPI domelem_QueryInterface( | |
| IXMLDOMElement *iface, | |
| REFIID riid, | |
| void** ppvObject ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject); | |
| if ( IsEqualGUID( riid, &IID_IXMLDOMElement ) || | |
| IsEqualGUID( riid, &IID_IXMLDOMNode ) || | |
| IsEqualGUID( riid, &IID_IDispatch ) || | |
| IsEqualGUID( riid, &IID_IUnknown ) ) | |
| { | |
| *ppvObject = &This->IXMLDOMElement_iface; | |
| } | |
| else if(node_query_interface(&This->node, riid, ppvObject)) | |
| { | |
| return *ppvObject ? S_OK : E_NOINTERFACE; | |
| } | |
| else if(IsEqualGUID( riid, &IID_ISupportErrorInfo )) | |
| { | |
| return node_create_supporterrorinfo(domelem_se_tids, ppvObject); | |
| } | |
| else | |
| { | |
| TRACE("interface %s not implemented\n", debugstr_guid(riid)); | |
| *ppvObject = NULL; | |
| return E_NOINTERFACE; | |
| } | |
| IUnknown_AddRef( (IUnknown*)*ppvObject ); | |
| return S_OK; | |
| } | |
| static ULONG WINAPI domelem_AddRef( | |
| IXMLDOMElement *iface ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| LONG ref = InterlockedIncrement(&This->ref); | |
| TRACE("(%p)->(%d)\n", This, ref); | |
| return ref; | |
| } | |
| static ULONG WINAPI domelem_Release( | |
| IXMLDOMElement *iface ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| ULONG ref = InterlockedDecrement(&This->ref); | |
| TRACE("(%p)->(%d)\n", This, ref); | |
| if(!ref) { | |
| destroy_xmlnode(&This->node); | |
| heap_free(This); | |
| } | |
| return ref; | |
| } | |
| static HRESULT WINAPI domelem_GetTypeInfoCount( | |
| IXMLDOMElement *iface, | |
| UINT* pctinfo ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo); | |
| } | |
| static HRESULT WINAPI domelem_GetTypeInfo( | |
| IXMLDOMElement *iface, | |
| UINT iTInfo, LCID lcid, | |
| ITypeInfo** ppTInfo ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, | |
| iTInfo, lcid, ppTInfo); | |
| } | |
| static HRESULT WINAPI domelem_GetIDsOfNames( | |
| IXMLDOMElement *iface, | |
| REFIID riid, LPOLESTR* rgszNames, | |
| UINT cNames, LCID lcid, DISPID* rgDispId ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, | |
| riid, rgszNames, cNames, lcid, rgDispId); | |
| } | |
| static HRESULT WINAPI domelem_Invoke( | |
| IXMLDOMElement *iface, | |
| DISPID dispIdMember, REFIID riid, LCID lcid, | |
| WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, | |
| EXCEPINFO* pExcepInfo, UINT* puArgErr ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, | |
| dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); | |
| } | |
| static HRESULT WINAPI domelem_get_nodeName( | |
| IXMLDOMElement *iface, | |
| BSTR* p ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, p); | |
| return node_get_nodeName(&This->node, p); | |
| } | |
| static HRESULT WINAPI domelem_get_nodeValue( | |
| IXMLDOMElement *iface, | |
| VARIANT* value) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, value); | |
| if(!value) | |
| return E_INVALIDARG; | |
| V_VT(value) = VT_NULL; | |
| V_BSTR(value) = NULL; /* tests show that we should do this */ | |
| return S_FALSE; | |
| } | |
| static HRESULT WINAPI domelem_put_nodeValue( | |
| IXMLDOMElement *iface, | |
| VARIANT value) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%s)\n", This, debugstr_variant(&value)); | |
| return E_FAIL; | |
| } | |
| static HRESULT WINAPI domelem_get_nodeType( | |
| IXMLDOMElement *iface, | |
| DOMNodeType* domNodeType ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, domNodeType); | |
| *domNodeType = NODE_ELEMENT; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI domelem_get_parentNode( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode** parent ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, parent); | |
| return node_get_parent(&This->node, parent); | |
| } | |
| static HRESULT WINAPI domelem_get_childNodes( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNodeList** outList) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, outList); | |
| return node_get_child_nodes(&This->node, outList); | |
| } | |
| static HRESULT WINAPI domelem_get_firstChild( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode** domNode) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, domNode); | |
| return node_get_first_child(&This->node, domNode); | |
| } | |
| static HRESULT WINAPI domelem_get_lastChild( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode** domNode) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, domNode); | |
| return node_get_last_child(&This->node, domNode); | |
| } | |
| static HRESULT WINAPI domelem_get_previousSibling( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode** domNode) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, domNode); | |
| return node_get_previous_sibling(&This->node, domNode); | |
| } | |
| static HRESULT WINAPI domelem_get_nextSibling( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode** domNode) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, domNode); | |
| return node_get_next_sibling(&This->node, domNode); | |
| } | |
| static HRESULT WINAPI domelem_get_attributes( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNamedNodeMap** map) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, map); | |
| *map = create_nodemap(This->node.node, &domelem_attr_map); | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI domelem_insertBefore( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode* newNode, VARIANT refChild, | |
| IXMLDOMNode** old_node) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| DOMNodeType type; | |
| HRESULT hr; | |
| TRACE("(%p)->(%p %s %p)\n", This, newNode, debugstr_variant(&refChild), old_node); | |
| hr = IXMLDOMNode_get_nodeType(newNode, &type); | |
| if (hr != S_OK) return hr; | |
| TRACE("new node type %d\n", type); | |
| switch (type) | |
| { | |
| case NODE_DOCUMENT: | |
| case NODE_DOCUMENT_TYPE: | |
| case NODE_ENTITY: | |
| case NODE_NOTATION: | |
| if (old_node) *old_node = NULL; | |
| return E_FAIL; | |
| default: | |
| return node_insert_before(&This->node, newNode, &refChild, old_node); | |
| } | |
| } | |
| static HRESULT WINAPI domelem_replaceChild( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode* newNode, | |
| IXMLDOMNode* oldNode, | |
| IXMLDOMNode** outOldNode) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p %p %p)\n", This, newNode, oldNode, outOldNode); | |
| return node_replace_child(&This->node, newNode, oldNode, outOldNode); | |
| } | |
| static HRESULT WINAPI domelem_removeChild( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode *child, IXMLDOMNode **oldChild) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p %p)\n", This, child, oldChild); | |
| return node_remove_child(&This->node, child, oldChild); | |
| } | |
| static HRESULT WINAPI domelem_appendChild( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode *child, IXMLDOMNode **outChild) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p %p)\n", This, child, outChild); | |
| return node_append_child(&This->node, child, outChild); | |
| } | |
| static HRESULT WINAPI domelem_hasChildNodes( | |
| IXMLDOMElement *iface, | |
| VARIANT_BOOL *ret) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, ret); | |
| return node_has_childnodes(&This->node, ret); | |
| } | |
| static HRESULT WINAPI domelem_get_ownerDocument( | |
| IXMLDOMElement *iface, | |
| IXMLDOMDocument **doc) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, doc); | |
| return node_get_owner_doc(&This->node, doc); | |
| } | |
| static HRESULT WINAPI domelem_cloneNode( | |
| IXMLDOMElement *iface, | |
| VARIANT_BOOL deep, IXMLDOMNode** outNode) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%d %p)\n", This, deep, outNode); | |
| return node_clone( &This->node, deep, outNode ); | |
| } | |
| static HRESULT WINAPI domelem_get_nodeTypeString( | |
| IXMLDOMElement *iface, | |
| BSTR* p) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| static const WCHAR elementW[] = {'e','l','e','m','e','n','t',0}; | |
| TRACE("(%p)->(%p)\n", This, p); | |
| return return_bstr(elementW, p); | |
| } | |
| static HRESULT WINAPI domelem_get_text( | |
| IXMLDOMElement *iface, | |
| BSTR* p) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, p); | |
| return node_get_text(&This->node, p); | |
| } | |
| static HRESULT WINAPI domelem_put_text( | |
| IXMLDOMElement *iface, | |
| BSTR p) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%s)\n", This, debugstr_w(p)); | |
| return node_put_text( &This->node, p ); | |
| } | |
| static HRESULT WINAPI domelem_get_specified( | |
| IXMLDOMElement *iface, | |
| VARIANT_BOOL* isSpecified) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| FIXME("(%p)->(%p) stub!\n", This, isSpecified); | |
| *isSpecified = VARIANT_TRUE; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI domelem_get_definition( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode** definitionNode) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| FIXME("(%p)->(%p)\n", This, definitionNode); | |
| return E_NOTIMPL; | |
| } | |
| static inline BYTE hex_to_byte(xmlChar c) | |
| { | |
| if(c <= '9') return c-'0'; | |
| if(c <= 'F') return c-'A'+10; | |
| return c-'a'+10; | |
| } | |
| static inline BYTE base64_to_byte(xmlChar c) | |
| { | |
| if(c == '+') return 62; | |
| if(c == '/') return 63; | |
| if(c <= '9') return c-'0'+52; | |
| if(c <= 'Z') return c-'A'; | |
| return c-'a'+26; | |
| } | |
| static inline HRESULT variant_from_dt(XDR_DT dt, xmlChar* str, VARIANT* v) | |
| { | |
| VARIANT src; | |
| HRESULT hr = S_OK; | |
| BOOL handled = FALSE; | |
| VariantInit(&src); | |
| switch (dt) | |
| { | |
| case DT_INVALID: | |
| case DT_STRING: | |
| case DT_NMTOKEN: | |
| case DT_NMTOKENS: | |
| case DT_NUMBER: | |
| case DT_URI: | |
| case DT_UUID: | |
| { | |
| V_VT(v) = VT_BSTR; | |
| V_BSTR(v) = bstr_from_xmlChar(str); | |
| if(!V_BSTR(v)) | |
| return E_OUTOFMEMORY; | |
| handled = TRUE; | |
| } | |
| break; | |
| case DT_DATE: | |
| case DT_DATE_TZ: | |
| case DT_DATETIME: | |
| case DT_DATETIME_TZ: | |
| case DT_TIME: | |
| case DT_TIME_TZ: | |
| { | |
| WCHAR *p, *e; | |
| SYSTEMTIME st; | |
| DOUBLE date = 0.0; | |
| st.wYear = 1899; | |
| st.wMonth = 12; | |
| st.wDay = 30; | |
| st.wDayOfWeek = st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0; | |
| V_VT(&src) = VT_BSTR; | |
| V_BSTR(&src) = bstr_from_xmlChar(str); | |
| if(!V_BSTR(&src)) | |
| return E_OUTOFMEMORY; | |
| p = V_BSTR(&src); | |
| e = p + SysStringLen(V_BSTR(&src)); | |
| if(p+4<e && *(p+4)=='-') /* parse date (yyyy-mm-dd) */ | |
| { | |
| st.wYear = atoiW(p); | |
| st.wMonth = atoiW(p+5); | |
| st.wDay = atoiW(p+8); | |
| p += 10; | |
| if(*p == 'T') p++; | |
| } | |
| if(p+2<e && *(p+2)==':') /* parse time (hh:mm:ss.?) */ | |
| { | |
| st.wHour = atoiW(p); | |
| st.wMinute = atoiW(p+3); | |
| st.wSecond = atoiW(p+6); | |
| p += 8; | |
| if(*p == '.') | |
| { | |
| p++; | |
| while(isdigitW(*p)) p++; | |
| } | |
| } | |
| SystemTimeToVariantTime(&st, &date); | |
| V_VT(v) = VT_DATE; | |
| V_DATE(v) = date; | |
| if(*p == '+') /* parse timezone offset (+hh:mm) */ | |
| V_DATE(v) += (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440; | |
| else if(*p == '-') /* parse timezone offset (-hh:mm) */ | |
| V_DATE(v) -= (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440; | |
| VariantClear(&src); | |
| handled = TRUE; | |
| } | |
| break; | |
| case DT_BIN_HEX: | |
| { | |
| SAFEARRAYBOUND sab; | |
| int i, len; | |
| len = xmlStrlen(str)/2; | |
| sab.lLbound = 0; | |
| sab.cElements = len; | |
| V_VT(v) = (VT_ARRAY|VT_UI1); | |
| V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab); | |
| if(!V_ARRAY(v)) | |
| return E_OUTOFMEMORY; | |
| for(i=0; i<len; i++) | |
| ((BYTE*)V_ARRAY(v)->pvData)[i] = (hex_to_byte(str[2*i])<<4) | |
| + hex_to_byte(str[2*i+1]); | |
| handled = TRUE; | |
| } | |
| break; | |
| case DT_BIN_BASE64: | |
| { | |
| SAFEARRAYBOUND sab; | |
| xmlChar *c1, *c2; | |
| int i, len; | |
| /* remove all formatting chars */ | |
| c1 = c2 = str; | |
| len = 0; | |
| while (*c2) | |
| { | |
| if ( *c2 == ' ' || *c2 == '\t' || | |
| *c2 == '\n' || *c2 == '\r' ) | |
| { | |
| c2++; | |
| continue; | |
| } | |
| *c1++ = *c2++; | |
| len++; | |
| } | |
| /* skip padding */ | |
| if(str[len-2] == '=') i = 2; | |
| else if(str[len-1] == '=') i = 1; | |
| else i = 0; | |
| sab.lLbound = 0; | |
| sab.cElements = len/4*3-i; | |
| V_VT(v) = (VT_ARRAY|VT_UI1); | |
| V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab); | |
| if(!V_ARRAY(v)) | |
| return E_OUTOFMEMORY; | |
| for(i=0; i<len/4; i++) | |
| { | |
| ((BYTE*)V_ARRAY(v)->pvData)[3*i] = (base64_to_byte(str[4*i])<<2) | |
| + (base64_to_byte(str[4*i+1])>>4); | |
| if(3*i+1 < sab.cElements) | |
| ((BYTE*)V_ARRAY(v)->pvData)[3*i+1] = (base64_to_byte(str[4*i+1])<<4) | |
| + (base64_to_byte(str[4*i+2])>>2); | |
| if(3*i+2 < sab.cElements) | |
| ((BYTE*)V_ARRAY(v)->pvData)[3*i+2] = (base64_to_byte(str[4*i+2])<<6) | |
| + base64_to_byte(str[4*i+3]); | |
| } | |
| handled = TRUE; | |
| } | |
| break; | |
| case DT_BOOLEAN: | |
| V_VT(v) = VT_BOOL; | |
| break; | |
| case DT_FIXED_14_4: | |
| V_VT(v) = VT_CY; | |
| break; | |
| case DT_I1: | |
| V_VT(v) = VT_I1; | |
| break; | |
| case DT_I2: | |
| V_VT(v) = VT_I2; | |
| break; | |
| case DT_I4: | |
| case DT_INT: | |
| V_VT(v) = VT_I4; | |
| break; | |
| case DT_I8: | |
| V_VT(v) = VT_I8; | |
| break; | |
| case DT_R4: | |
| V_VT(v) = VT_R4; | |
| break; | |
| case DT_FLOAT: | |
| case DT_R8: | |
| V_VT(v) = VT_R8; | |
| break; | |
| case DT_UI1: | |
| V_VT(v) = VT_UI1; | |
| break; | |
| case DT_UI2: | |
| V_VT(v) = VT_UI2; | |
| break; | |
| case DT_UI4: | |
| V_VT(v) = VT_UI4; | |
| break; | |
| case DT_UI8: | |
| V_VT(v) = VT_UI8; | |
| break; | |
| case DT_CHAR: | |
| case DT_ENTITY: | |
| case DT_ENTITIES: | |
| case DT_ENUMERATION: | |
| case DT_ID: | |
| case DT_IDREF: | |
| case DT_IDREFS: | |
| case DT_NOTATION: | |
| FIXME("need to handle dt:%s\n", debugstr_dt(dt)); | |
| V_VT(v) = VT_BSTR; | |
| V_BSTR(v) = bstr_from_xmlChar(str); | |
| if (!V_BSTR(v)) | |
| return E_OUTOFMEMORY; | |
| handled = TRUE; | |
| break; | |
| default: | |
| WARN("unknown type %d\n", dt); | |
| } | |
| if (!handled) | |
| { | |
| V_VT(&src) = VT_BSTR; | |
| V_BSTR(&src) = bstr_from_xmlChar(str); | |
| if(!V_BSTR(&src)) | |
| return E_OUTOFMEMORY; | |
| hr = VariantChangeTypeEx(v, &src, | |
| MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT),0, V_VT(v)); | |
| VariantClear(&src); | |
| } | |
| return hr; | |
| } | |
| static XDR_DT element_get_dt(xmlNodePtr node) | |
| { | |
| XDR_DT dt = DT_INVALID; | |
| TRACE("(%p)\n", node); | |
| if(node->type != XML_ELEMENT_NODE) | |
| { | |
| FIXME("invalid element node\n"); | |
| return dt; | |
| } | |
| if (node->ns && xmlStrEqual(node->ns->href, DT_nsURI)) | |
| { | |
| dt = str_to_dt(node->name, -1); | |
| } | |
| else | |
| { | |
| xmlChar* pVal = xmlGetNsProp(node, BAD_CAST "dt", DT_nsURI); | |
| if (pVal) | |
| { | |
| dt = str_to_dt(pVal, -1); | |
| xmlFree(pVal); | |
| } | |
| else if (node->doc) | |
| { | |
| IXMLDOMDocument3* doc = (IXMLDOMDocument3*)create_domdoc((xmlNodePtr)node->doc); | |
| if (doc) | |
| { | |
| VARIANT v; | |
| VariantInit(&v); | |
| if (IXMLDOMDocument3_get_schemas(doc, &v) == S_OK && | |
| V_VT(&v) == VT_DISPATCH) | |
| { | |
| dt = SchemaCache_get_node_dt((IXMLDOMSchemaCollection2*)V_DISPATCH(&v), node); | |
| } | |
| VariantClear(&v); | |
| IXMLDOMDocument3_Release(doc); | |
| } | |
| } | |
| } | |
| TRACE("=> dt:%s\n", debugstr_dt(dt)); | |
| return dt; | |
| } | |
| static HRESULT WINAPI domelem_get_nodeTypedValue( | |
| IXMLDOMElement *iface, | |
| VARIANT* v) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| XDR_DT dt; | |
| xmlChar* content; | |
| HRESULT hr; | |
| TRACE("(%p)->(%p)\n", This, v); | |
| if(!v) return E_INVALIDARG; | |
| V_VT(v) = VT_NULL; | |
| dt = element_get_dt(get_element(This)); | |
| content = xmlNodeGetContent(get_element(This)); | |
| hr = variant_from_dt(dt, content, v); | |
| xmlFree(content); | |
| return hr; | |
| } | |
| static HRESULT encode_base64(const BYTE *buf, int len, BSTR *ret) | |
| { | |
| static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; | |
| const BYTE *d = buf; | |
| int bytes, pad_bytes, div; | |
| DWORD needed; | |
| WCHAR *ptr; | |
| bytes = (len*8 + 5)/6; | |
| pad_bytes = (bytes % 4) ? 4 - (bytes % 4) : 0; | |
| TRACE("%d, bytes is %d, pad bytes is %d\n", len, bytes, pad_bytes); | |
| needed = bytes + pad_bytes + 1; | |
| *ret = SysAllocStringLen(NULL, needed); | |
| if (!*ret) return E_OUTOFMEMORY; | |
| /* Three bytes of input give 4 chars of output */ | |
| div = len / 3; | |
| ptr = *ret; | |
| while (div > 0) | |
| { | |
| /* first char is the first 6 bits of the first byte*/ | |
| *ptr++ = b64[ ( d[0] >> 2) & 0x3f ]; | |
| /* second char is the last 2 bits of the first byte and the first 4 | |
| * bits of the second byte */ | |
| *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)]; | |
| /* third char is the last 4 bits of the second byte and the first 2 | |
| * bits of the third byte */ | |
| *ptr++ = b64[ ((d[1] << 2) & 0x3c) | (d[2] >> 6 & 0x03)]; | |
| /* fourth char is the remaining 6 bits of the third byte */ | |
| *ptr++ = b64[ d[2] & 0x3f]; | |
| d += 3; | |
| div--; | |
| } | |
| switch (pad_bytes) | |
| { | |
| case 1: | |
| /* first char is the first 6 bits of the first byte*/ | |
| *ptr++ = b64[ ( d[0] >> 2) & 0x3f ]; | |
| /* second char is the last 2 bits of the first byte and the first 4 | |
| * bits of the second byte */ | |
| *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)]; | |
| /* third char is the last 4 bits of the second byte padded with | |
| * two zeroes */ | |
| *ptr++ = b64[ ((d[1] << 2) & 0x3c) ]; | |
| /* fourth char is a = to indicate one byte of padding */ | |
| *ptr++ = '='; | |
| break; | |
| case 2: | |
| /* first char is the first 6 bits of the first byte*/ | |
| *ptr++ = b64[ ( d[0] >> 2) & 0x3f ]; | |
| /* second char is the last 2 bits of the first byte padded with | |
| * four zeroes*/ | |
| *ptr++ = b64[ ((d[0] << 4) & 0x30)]; | |
| /* third char is = to indicate padding */ | |
| *ptr++ = '='; | |
| /* fourth char is = to indicate padding */ | |
| *ptr++ = '='; | |
| break; | |
| } | |
| return S_OK; | |
| } | |
| static HRESULT encode_binhex(const BYTE *buf, int len, BSTR *ret) | |
| { | |
| static const char byte_to_hex[16] = "0123456789abcdef"; | |
| int i; | |
| *ret = SysAllocStringLen(NULL, len*2); | |
| if (!*ret) return E_OUTOFMEMORY; | |
| for (i = 0; i < len; i++) | |
| { | |
| (*ret)[2*i] = byte_to_hex[buf[i] >> 4]; | |
| (*ret)[2*i+1] = byte_to_hex[0x0f & buf[i]]; | |
| } | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI domelem_put_nodeTypedValue( | |
| IXMLDOMElement *iface, | |
| VARIANT value) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| XDR_DT dt; | |
| HRESULT hr; | |
| TRACE("(%p)->(%s)\n", This, debugstr_variant(&value)); | |
| dt = element_get_dt(get_element(This)); | |
| switch (dt) | |
| { | |
| /* for untyped node coerce to BSTR and set */ | |
| case DT_INVALID: | |
| if (V_VT(&value) != VT_BSTR) | |
| { | |
| VARIANT content; | |
| VariantInit(&content); | |
| hr = VariantChangeType(&content, &value, 0, VT_BSTR); | |
| if (hr == S_OK) | |
| { | |
| hr = node_set_content(&This->node, V_BSTR(&content)); | |
| VariantClear(&content); | |
| } | |
| } | |
| else | |
| hr = node_set_content(&This->node, V_BSTR(&value)); | |
| break; | |
| case DT_BIN_BASE64: | |
| if (V_VT(&value) == VT_BSTR) | |
| hr = node_set_content(&This->node, V_BSTR(&value)); | |
| else if (V_VT(&value) == (VT_UI1|VT_ARRAY)) | |
| { | |
| UINT dim = SafeArrayGetDim(V_ARRAY(&value)); | |
| LONG lbound, ubound; | |
| BSTR encoded; | |
| BYTE *ptr; | |
| int len; | |
| if (dim > 1) | |
| FIXME("unexpected array dimension count %u\n", dim); | |
| SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound); | |
| SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound); | |
| len = (ubound - lbound + 1)*SafeArrayGetElemsize(V_ARRAY(&value)); | |
| hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr); | |
| if (FAILED(hr)) return hr; | |
| hr = encode_base64(ptr, len, &encoded); | |
| SafeArrayUnaccessData(V_ARRAY(&value)); | |
| if (FAILED(hr)) return hr; | |
| hr = node_set_content(&This->node, encoded); | |
| SysFreeString(encoded); | |
| } | |
| else | |
| { | |
| FIXME("unhandled variant type %d for dt:%s\n", V_VT(&value), debugstr_dt(dt)); | |
| return E_NOTIMPL; | |
| } | |
| break; | |
| case DT_BIN_HEX: | |
| if (V_VT(&value) == (VT_UI1|VT_ARRAY)) | |
| { | |
| UINT dim = SafeArrayGetDim(V_ARRAY(&value)); | |
| LONG lbound, ubound; | |
| BSTR encoded; | |
| BYTE *ptr; | |
| int len; | |
| if (dim > 1) | |
| FIXME("unexpected array dimension count %u\n", dim); | |
| SafeArrayGetUBound(V_ARRAY(&value), 1, &ubound); | |
| SafeArrayGetLBound(V_ARRAY(&value), 1, &lbound); | |
| len = (ubound - lbound + 1)*SafeArrayGetElemsize(V_ARRAY(&value)); | |
| hr = SafeArrayAccessData(V_ARRAY(&value), (void*)&ptr); | |
| if (FAILED(hr)) return hr; | |
| hr = encode_binhex(ptr, len, &encoded); | |
| SafeArrayUnaccessData(V_ARRAY(&value)); | |
| if (FAILED(hr)) return hr; | |
| hr = node_set_content(&This->node, encoded); | |
| SysFreeString(encoded); | |
| } | |
| else | |
| { | |
| FIXME("unhandled variant type %d for dt:%s\n", V_VT(&value), debugstr_dt(dt)); | |
| return E_NOTIMPL; | |
| } | |
| break; | |
| default: | |
| FIXME("not implemented for dt:%s\n", debugstr_dt(dt)); | |
| return E_NOTIMPL; | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI domelem_get_dataType( | |
| IXMLDOMElement *iface, | |
| VARIANT* typename) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| XDR_DT dt; | |
| TRACE("(%p)->(%p)\n", This, typename); | |
| if (!typename) | |
| return E_INVALIDARG; | |
| dt = element_get_dt(get_element(This)); | |
| switch (dt) | |
| { | |
| case DT_BIN_BASE64: | |
| case DT_BIN_HEX: | |
| case DT_BOOLEAN: | |
| case DT_CHAR: | |
| case DT_DATE: | |
| case DT_DATE_TZ: | |
| case DT_DATETIME: | |
| case DT_DATETIME_TZ: | |
| case DT_FIXED_14_4: | |
| case DT_FLOAT: | |
| case DT_I1: | |
| case DT_I2: | |
| case DT_I4: | |
| case DT_I8: | |
| case DT_INT: | |
| case DT_NUMBER: | |
| case DT_R4: | |
| case DT_R8: | |
| case DT_TIME: | |
| case DT_TIME_TZ: | |
| case DT_UI1: | |
| case DT_UI2: | |
| case DT_UI4: | |
| case DT_UI8: | |
| case DT_URI: | |
| case DT_UUID: | |
| V_VT(typename) = VT_BSTR; | |
| V_BSTR(typename) = SysAllocString(dt_to_bstr(dt)); | |
| if (!V_BSTR(typename)) | |
| return E_OUTOFMEMORY; | |
| break; | |
| default: | |
| /* Other types (DTD equivalents) do not return anything here, | |
| * but the pointer part of the VARIANT is set to NULL */ | |
| V_VT(typename) = VT_NULL; | |
| V_BSTR(typename) = NULL; | |
| break; | |
| } | |
| return (V_VT(typename) != VT_NULL) ? S_OK : S_FALSE; | |
| } | |
| static HRESULT WINAPI domelem_put_dataType( | |
| IXMLDOMElement *iface, | |
| BSTR dtName) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| HRESULT hr = E_FAIL; | |
| xmlChar *str; | |
| XDR_DT dt; | |
| TRACE("(%p)->(%s)\n", This, debugstr_w(dtName)); | |
| if(dtName == NULL) | |
| return E_INVALIDARG; | |
| dt = bstr_to_dt(dtName, -1); | |
| /* 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 | |
| */ | |
| str = xmlNodeGetContent(get_element(This)); | |
| hr = dt_validate(dt, str); | |
| xmlFree(str); | |
| /* Check all supported types. */ | |
| if (hr == S_OK) | |
| { | |
| switch (dt) | |
| { | |
| case DT_BIN_BASE64: | |
| case DT_BIN_HEX: | |
| case DT_BOOLEAN: | |
| case DT_CHAR: | |
| case DT_DATE: | |
| case DT_DATE_TZ: | |
| case DT_DATETIME: | |
| case DT_DATETIME_TZ: | |
| case DT_FIXED_14_4: | |
| case DT_FLOAT: | |
| case DT_I1: | |
| case DT_I2: | |
| case DT_I4: | |
| case DT_I8: | |
| case DT_INT: | |
| case DT_NMTOKEN: | |
| case DT_NMTOKENS: | |
| case DT_NUMBER: | |
| case DT_R4: | |
| case DT_R8: | |
| case DT_STRING: | |
| case DT_TIME: | |
| case DT_TIME_TZ: | |
| case DT_UI1: | |
| case DT_UI2: | |
| case DT_UI4: | |
| case DT_UI8: | |
| case DT_URI: | |
| case DT_UUID: | |
| { | |
| xmlAttrPtr attr = xmlHasNsProp(get_element(This), DT_prefix, DT_nsURI); | |
| if (attr) | |
| { | |
| attr = xmlSetNsProp(get_element(This), attr->ns, DT_prefix, dt_to_str(dt)); | |
| hr = S_OK; | |
| } | |
| else | |
| { | |
| xmlNsPtr ns = xmlNewNs(get_element(This), DT_nsURI, DT_prefix); | |
| if (ns) | |
| { | |
| attr = xmlNewNsProp(get_element(This), ns, DT_prefix, dt_to_str(dt)); | |
| if (attr) | |
| { | |
| xmlAddChild(get_element(This), (xmlNodePtr)attr); | |
| hr = S_OK; | |
| } | |
| else | |
| ERR("Failed to create Attribute\n"); | |
| } | |
| else | |
| ERR("Failed to create Namespace\n"); | |
| } | |
| } | |
| break; | |
| default: | |
| FIXME("need to handle dt:%s\n", debugstr_dt(dt)); | |
| break; | |
| } | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI domelem_get_xml( | |
| IXMLDOMElement *iface, | |
| BSTR* p) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, p); | |
| return node_get_xml(&This->node, TRUE, p); | |
| } | |
| static HRESULT WINAPI domelem_transformNode( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode *node, BSTR *p) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p %p)\n", This, node, p); | |
| return node_transform_node(&This->node, node, p); | |
| } | |
| static HRESULT WINAPI domelem_selectNodes( | |
| IXMLDOMElement *iface, | |
| BSTR p, IXMLDOMNodeList** outList) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outList); | |
| return node_select_nodes(&This->node, p, outList); | |
| } | |
| static HRESULT WINAPI domelem_selectSingleNode( | |
| IXMLDOMElement *iface, | |
| BSTR p, IXMLDOMNode** outNode) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), outNode); | |
| return node_select_singlenode(&This->node, p, outNode); | |
| } | |
| static HRESULT WINAPI domelem_get_parsed( | |
| IXMLDOMElement *iface, | |
| VARIANT_BOOL* isParsed) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| FIXME("(%p)->(%p) stub!\n", This, isParsed); | |
| *isParsed = VARIANT_TRUE; | |
| return S_OK; | |
| } | |
| static HRESULT WINAPI domelem_get_namespaceURI( | |
| IXMLDOMElement *iface, | |
| BSTR* p) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, p); | |
| return node_get_namespaceURI(&This->node, p); | |
| } | |
| static HRESULT WINAPI domelem_get_prefix( | |
| IXMLDOMElement *iface, | |
| BSTR* prefix) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, prefix); | |
| return node_get_prefix( &This->node, prefix ); | |
| } | |
| static HRESULT WINAPI domelem_get_baseName( | |
| IXMLDOMElement *iface, | |
| BSTR* name) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| TRACE("(%p)->(%p)\n", This, name); | |
| return node_get_base_name( &This->node, name ); | |
| } | |
| static HRESULT WINAPI domelem_transformNodeToObject( | |
| IXMLDOMElement *iface, | |
| IXMLDOMNode* domNode, VARIANT var1) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1)); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI domelem_get_tagName( | |
| IXMLDOMElement *iface, | |
| BSTR* p) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| xmlNodePtr element; | |
| const xmlChar *prefix; | |
| xmlChar *qname; | |
| TRACE("(%p)->(%p)\n", This, p ); | |
| if (!p) return E_INVALIDARG; | |
| element = get_element( This ); | |
| if ( !element ) | |
| return E_FAIL; | |
| prefix = element->ns ? element->ns->prefix : NULL; | |
| qname = xmlBuildQName(element->name, prefix, NULL, 0); | |
| *p = bstr_from_xmlChar(qname); | |
| if (qname != element->name) xmlFree(qname); | |
| return *p ? S_OK : E_OUTOFMEMORY; | |
| } | |
| static HRESULT WINAPI domelem_getAttribute( | |
| IXMLDOMElement *iface, | |
| BSTR name, VARIANT* value) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| xmlNodePtr element; | |
| xmlChar *xml_name, *xml_value = NULL; | |
| xmlChar *local, *prefix; | |
| HRESULT hr = S_FALSE; | |
| xmlNsPtr ns; | |
| 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; | |
| V_BSTR(value) = NULL; | |
| V_VT(value) = VT_NULL; | |
| xml_name = xmlchar_from_wchar( name ); | |
| if(!xmlValidateNameValue(xml_name)) | |
| hr = E_FAIL; | |
| else | |
| { | |
| if ((local = xmlSplitQName2(xml_name, &prefix))) | |
| { | |
| if (xmlStrEqual(prefix, BAD_CAST "xmlns")) | |
| { | |
| ns = xmlSearchNs(element->doc, element, local); | |
| if (ns) | |
| xml_value = xmlStrdup(ns->href); | |
| } | |
| else | |
| { | |
| ns = xmlSearchNs(element->doc, element, prefix); | |
| if (ns) | |
| xml_value = xmlGetNsProp(element, local, ns->href); | |
| } | |
| xmlFree(prefix); | |
| xmlFree(local); | |
| } | |
| else | |
| xml_value = xmlGetNsProp(element, xml_name, NULL); | |
| } | |
| heap_free(xml_name); | |
| if(xml_value) | |
| { | |
| V_VT(value) = VT_BSTR; | |
| V_BSTR(value) = bstr_from_xmlChar( xml_value ); | |
| xmlFree(xml_value); | |
| hr = S_OK; | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI domelem_setAttribute( | |
| IXMLDOMElement *iface, | |
| BSTR name, VARIANT value) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| xmlChar *xml_name, *xml_value, *local, *prefix; | |
| xmlNodePtr element; | |
| HRESULT hr = S_OK; | |
| TRACE("(%p)->(%s %s)\n", This, debugstr_w(name), debugstr_variant(&value)); | |
| element = get_element( This ); | |
| if ( !element ) | |
| return E_FAIL; | |
| if (V_VT(&value) != VT_BSTR) | |
| { | |
| VARIANT var; | |
| VariantInit(&var); | |
| hr = VariantChangeType(&var, &value, 0, VT_BSTR); | |
| if (hr != S_OK) | |
| { | |
| FIXME("VariantChangeType failed\n"); | |
| return hr; | |
| } | |
| xml_value = xmlchar_from_wchar(V_BSTR(&var)); | |
| VariantClear(&var); | |
| } | |
| else | |
| xml_value = xmlchar_from_wchar(V_BSTR(&value)); | |
| xml_name = xmlchar_from_wchar( name ); | |
| if ((local = xmlSplitQName2(xml_name, &prefix))) | |
| { | |
| static const xmlChar* xmlnsA = (const xmlChar*)"xmlns"; | |
| xmlNsPtr ns = NULL; | |
| /* it's not allowed to modify existing namespace definition */ | |
| if (xmlStrEqual(prefix, xmlnsA)) | |
| ns = xmlSearchNs(element->doc, element, local); | |
| xmlFree(prefix); | |
| xmlFree(local); | |
| if (ns) | |
| { | |
| int cmp = xmlStrEqual(ns->href, xml_value); | |
| heap_free(xml_value); | |
| heap_free(xml_name); | |
| return cmp ? S_OK : E_INVALIDARG; | |
| } | |
| } | |
| if (!xmlSetNsProp(element, NULL, xml_name, xml_value)) | |
| hr = E_FAIL; | |
| heap_free(xml_value); | |
| heap_free(xml_name); | |
| return hr; | |
| } | |
| static HRESULT WINAPI domelem_removeAttribute( | |
| IXMLDOMElement *iface, | |
| BSTR p) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| IXMLDOMNamedNodeMap *attr; | |
| HRESULT hr; | |
| TRACE("(%p)->(%s)\n", This, debugstr_w(p)); | |
| hr = IXMLDOMElement_get_attributes(iface, &attr); | |
| if (hr != S_OK) return hr; | |
| hr = IXMLDOMNamedNodeMap_removeNamedItem(attr, p, NULL); | |
| IXMLDOMNamedNodeMap_Release(attr); | |
| return hr; | |
| } | |
| static HRESULT WINAPI domelem_getAttributeNode( | |
| IXMLDOMElement *iface, | |
| BSTR p, IXMLDOMAttribute** attributeNode ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| xmlChar *local, *prefix, *nameA; | |
| HRESULT hr = S_FALSE; | |
| xmlNodePtr element; | |
| xmlAttrPtr attr; | |
| TRACE("(%p)->(%s %p)\n", This, debugstr_w(p), attributeNode); | |
| element = get_element( This ); | |
| if (!element) return E_FAIL; | |
| if (attributeNode) *attributeNode = NULL; | |
| nameA = xmlchar_from_wchar(p); | |
| if (!xmlValidateNameValue(nameA)) | |
| { | |
| heap_free(nameA); | |
| return E_FAIL; | |
| } | |
| if (!attributeNode) | |
| { | |
| heap_free(nameA); | |
| return S_FALSE; | |
| } | |
| *attributeNode = NULL; | |
| local = xmlSplitQName2(nameA, &prefix); | |
| if (local) | |
| { | |
| /* try to get namespace for supplied qualified name */ | |
| xmlNsPtr ns = xmlSearchNs(element->doc, element, prefix); | |
| xmlFree(prefix); | |
| attr = xmlHasNsProp(element, local, ns ? ns->href : NULL); | |
| xmlFree(local); | |
| } | |
| else | |
| { | |
| attr = xmlHasProp(element, nameA); | |
| /* attribute has attached namespace and we requested non-qualified | |
| name - it's a failure case */ | |
| if (attr && attr->ns) attr = NULL; | |
| } | |
| heap_free(nameA); | |
| if (attr) | |
| { | |
| IUnknown *unk = create_attribute((xmlNodePtr)attr); | |
| hr = IUnknown_QueryInterface(unk, &IID_IXMLDOMAttribute, (void**)attributeNode); | |
| IUnknown_Release(unk); | |
| } | |
| return hr; | |
| } | |
| static HRESULT WINAPI domelem_setAttributeNode( | |
| IXMLDOMElement *iface, | |
| IXMLDOMAttribute* attribute, | |
| IXMLDOMAttribute** old) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| static const WCHAR xmlnsW[] = {'x','m','l','n','s',0}; | |
| xmlChar *name, *value; | |
| BSTR nameW, prefix; | |
| xmlnode *attr_node; | |
| xmlAttrPtr attr; | |
| VARIANT valueW; | |
| HRESULT hr; | |
| FIXME("(%p)->(%p %p): semi-stub\n", This, attribute, old); | |
| if (!attribute) return E_INVALIDARG; | |
| attr_node = get_node_obj((IXMLDOMNode*)attribute); | |
| if (!attr_node) return E_FAIL; | |
| if (attr_node->parent) | |
| { | |
| WARN("attempt to add already used attribute\n"); | |
| return E_FAIL; | |
| } | |
| hr = IXMLDOMAttribute_get_nodeName(attribute, &nameW); | |
| if (hr != S_OK) return hr; | |
| /* adding xmlns attribute doesn't change a tree or existing namespace definition */ | |
| if (!strcmpW(nameW, xmlnsW)) | |
| { | |
| SysFreeString(nameW); | |
| return DISP_E_UNKNOWNNAME; | |
| } | |
| hr = IXMLDOMAttribute_get_nodeValue(attribute, &valueW); | |
| if (hr != S_OK) | |
| { | |
| SysFreeString(nameW); | |
| return hr; | |
| } | |
| if (old) *old = NULL; | |
| TRACE("attribute: %s=%s\n", debugstr_w(nameW), debugstr_w(V_BSTR(&valueW))); | |
| hr = IXMLDOMAttribute_get_prefix(attribute, &prefix); | |
| if (hr == S_OK) | |
| { | |
| FIXME("namespaces not supported: %s\n", debugstr_w(prefix)); | |
| SysFreeString(prefix); | |
| } | |
| name = xmlchar_from_wchar(nameW); | |
| value = xmlchar_from_wchar(V_BSTR(&valueW)); | |
| if (!name || !value) | |
| { | |
| SysFreeString(nameW); | |
| VariantClear(&valueW); | |
| heap_free(name); | |
| heap_free(value); | |
| return E_OUTOFMEMORY; | |
| } | |
| attr = xmlSetNsProp(get_element(This), NULL, name, value); | |
| if (attr) | |
| attr_node->parent = (IXMLDOMNode*)iface; | |
| SysFreeString(nameW); | |
| VariantClear(&valueW); | |
| heap_free(name); | |
| heap_free(value); | |
| return attr ? S_OK : E_FAIL; | |
| } | |
| static HRESULT WINAPI domelem_removeAttributeNode( | |
| IXMLDOMElement *iface, | |
| IXMLDOMAttribute* domAttribute, | |
| IXMLDOMAttribute** attributeNode) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| FIXME("(%p)->(%p %p)\n", This, domAttribute, attributeNode); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT WINAPI domelem_getElementsByTagName( | |
| IXMLDOMElement *iface, | |
| BSTR tagName, IXMLDOMNodeList** resultList) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| xmlChar *query; | |
| HRESULT hr; | |
| BOOL XPath; | |
| TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList); | |
| if (!tagName || !resultList) return E_INVALIDARG; | |
| XPath = is_xpathmode(get_element(This)->doc); | |
| set_xpathmode(get_element(This)->doc, TRUE); | |
| query = tagName_to_XPath(tagName); | |
| hr = create_selection(get_element(This), query, resultList); | |
| xmlFree(query); | |
| set_xpathmode(get_element(This)->doc, XPath); | |
| return hr; | |
| } | |
| static HRESULT WINAPI domelem_normalize( | |
| IXMLDOMElement *iface ) | |
| { | |
| domelem *This = impl_from_IXMLDOMElement( iface ); | |
| FIXME("%p\n", This); | |
| return E_NOTIMPL; | |
| } | |
| static const struct IXMLDOMElementVtbl domelem_vtbl = | |
| { | |
| domelem_QueryInterface, | |
| domelem_AddRef, | |
| domelem_Release, | |
| domelem_GetTypeInfoCount, | |
| domelem_GetTypeInfo, | |
| domelem_GetIDsOfNames, | |
| domelem_Invoke, | |
| domelem_get_nodeName, | |
| domelem_get_nodeValue, | |
| domelem_put_nodeValue, | |
| domelem_get_nodeType, | |
| domelem_get_parentNode, | |
| domelem_get_childNodes, | |
| domelem_get_firstChild, | |
| domelem_get_lastChild, | |
| domelem_get_previousSibling, | |
| domelem_get_nextSibling, | |
| domelem_get_attributes, | |
| domelem_insertBefore, | |
| domelem_replaceChild, | |
| domelem_removeChild, | |
| domelem_appendChild, | |
| domelem_hasChildNodes, | |
| domelem_get_ownerDocument, | |
| domelem_cloneNode, | |
| domelem_get_nodeTypeString, | |
| domelem_get_text, | |
| domelem_put_text, | |
| domelem_get_specified, | |
| domelem_get_definition, | |
| domelem_get_nodeTypedValue, | |
| domelem_put_nodeTypedValue, | |
| domelem_get_dataType, | |
| domelem_put_dataType, | |
| domelem_get_xml, | |
| domelem_transformNode, | |
| domelem_selectNodes, | |
| domelem_selectSingleNode, | |
| domelem_get_parsed, | |
| domelem_get_namespaceURI, | |
| domelem_get_prefix, | |
| domelem_get_baseName, | |
| domelem_transformNodeToObject, | |
| domelem_get_tagName, | |
| domelem_getAttribute, | |
| domelem_setAttribute, | |
| domelem_removeAttribute, | |
| domelem_getAttributeNode, | |
| domelem_setAttributeNode, | |
| domelem_removeAttributeNode, | |
| domelem_getElementsByTagName, | |
| domelem_normalize, | |
| }; | |
| static HRESULT domelem_get_qualified_item(const xmlNodePtr node, BSTR name, BSTR uri, | |
| IXMLDOMNode **item) | |
| { | |
| xmlAttrPtr attr; | |
| xmlChar *nameA; | |
| xmlChar *href; | |
| TRACE("(%p)->(%s %s %p)\n", node, debugstr_w(name), debugstr_w(uri), item); | |
| if (!name || !item) return E_INVALIDARG; | |
| if (uri && *uri) | |
| { | |
| href = xmlchar_from_wchar(uri); | |
| if (!href) return E_OUTOFMEMORY; | |
| } | |
| else | |
| href = NULL; | |
| nameA = xmlchar_from_wchar(name); | |
| if (!nameA) | |
| { | |
| heap_free(href); | |
| return E_OUTOFMEMORY; | |
| } | |
| attr = xmlHasNsProp(node, nameA, href); | |
| heap_free(nameA); | |
| heap_free(href); | |
| if (!attr) | |
| { | |
| *item = NULL; | |
| return S_FALSE; | |
| } | |
| *item = create_node((xmlNodePtr)attr); | |
| return S_OK; | |
| } | |
| static HRESULT domelem_get_named_item(const xmlNodePtr node, BSTR name, IXMLDOMNode **item) | |
| { | |
| xmlChar *nameA, *local, *prefix; | |
| BSTR uriW, localW; | |
| xmlNsPtr ns; | |
| HRESULT hr; | |
| TRACE("(%p)->(%s %p)\n", node, debugstr_w(name), item ); | |
| nameA = xmlchar_from_wchar(name); | |
| local = xmlSplitQName2(nameA, &prefix); | |
| heap_free(nameA); | |
| if (!local) | |
| return domelem_get_qualified_item(node, name, NULL, item); | |
| /* try to get namespace uri for supplied qualified name */ | |
| ns = xmlSearchNs(node->doc, node, prefix); | |
| xmlFree(prefix); | |
| if (!ns) | |
| { | |
| xmlFree(local); | |
| if (item) *item = NULL; | |
| return item ? S_FALSE : E_INVALIDARG; | |
| } | |
| uriW = bstr_from_xmlChar(ns->href); | |
| localW = bstr_from_xmlChar(local); | |
| xmlFree(local); | |
| TRACE("got qualified node %s, uri=%s\n", debugstr_w(localW), debugstr_w(uriW)); | |
| hr = domelem_get_qualified_item(node, localW, uriW, item); | |
| SysFreeString(localW); | |
| SysFreeString(uriW); | |
| return hr; | |
| } | |
| static HRESULT domelem_set_named_item(xmlNodePtr node, IXMLDOMNode *newItem, IXMLDOMNode **namedItem) | |
| { | |
| xmlNodePtr nodeNew; | |
| xmlnode *ThisNew; | |
| TRACE("(%p)->(%p %p)\n", node, newItem, namedItem ); | |
| if(!newItem) | |
| return E_INVALIDARG; | |
| if(namedItem) *namedItem = NULL; | |
| /* Must be an Attribute */ | |
| ThisNew = get_node_obj( newItem ); | |
| if(!ThisNew) return E_FAIL; | |
| if(ThisNew->node->type != XML_ATTRIBUTE_NODE) | |
| return E_FAIL; | |
| if(!ThisNew->node->parent) | |
| if(xmldoc_remove_orphan(ThisNew->node->doc, ThisNew->node) != S_OK) | |
| WARN("%p is not an orphan of %p\n", ThisNew->node, ThisNew->node->doc); | |
| nodeNew = xmlAddChild(node, ThisNew->node); | |
| if(namedItem) | |
| *namedItem = create_node( nodeNew ); | |
| return S_OK; | |
| } | |
| static HRESULT domelem_remove_qualified_item(xmlNodePtr node, BSTR name, BSTR uri, IXMLDOMNode **item) | |
| { | |
| xmlChar *nameA, *href; | |
| xmlAttrPtr attr; | |
| TRACE("(%p)->(%s %s %p)\n", node, debugstr_w(name), debugstr_w(uri), item); | |
| if (!name) return E_INVALIDARG; | |
| if (uri && *uri) | |
| { | |
| href = xmlchar_from_wchar(uri); | |
| if (!href) return E_OUTOFMEMORY; | |
| } | |
| else | |
| href = NULL; | |
| nameA = xmlchar_from_wchar(name); | |
| if (!nameA) | |
| { | |
| heap_free(href); | |
| return E_OUTOFMEMORY; | |
| } | |
| attr = xmlHasNsProp(node, nameA, href); | |
| heap_free(nameA); | |
| heap_free(href); | |
| if (!attr) | |
| { | |
| if (item) *item = NULL; | |
| return S_FALSE; | |
| } | |
| if (item) | |
| { | |
| xmlUnlinkNode( (xmlNodePtr) attr ); | |
| xmldoc_add_orphan( attr->doc, (xmlNodePtr) attr ); | |
| *item = create_node( (xmlNodePtr) attr ); | |
| } | |
| else | |
| { | |
| if (xmlRemoveProp(attr) == -1) | |
| ERR("xmlRemoveProp failed\n"); | |
| } | |
| return S_OK; | |
| } | |
| static HRESULT domelem_remove_named_item(xmlNodePtr node, BSTR name, IXMLDOMNode **item) | |
| { | |
| TRACE("(%p)->(%s %p)\n", node, debugstr_w(name), item); | |
| return domelem_remove_qualified_item(node, name, NULL, item); | |
| } | |
| static HRESULT domelem_get_item(const xmlNodePtr node, LONG index, IXMLDOMNode **item) | |
| { | |
| xmlAttrPtr curr; | |
| LONG attrIndex; | |
| TRACE("(%p)->(%d %p)\n", node, index, item); | |
| *item = NULL; | |
| if (index < 0) | |
| return S_FALSE; | |
| curr = node->properties; | |
| for (attrIndex = 0; attrIndex < index; attrIndex++) { | |
| if (curr->next == NULL) | |
| return S_FALSE; | |
| else | |
| curr = curr->next; | |
| } | |
| *item = create_node( (xmlNodePtr) curr ); | |
| return S_OK; | |
| } | |
| static HRESULT domelem_get_length(const xmlNodePtr node, LONG *length) | |
| { | |
| xmlAttrPtr first; | |
| xmlAttrPtr curr; | |
| LONG attrCount; | |
| TRACE("(%p)->(%p)\n", node, length); | |
| if( !length ) | |
| return E_INVALIDARG; | |
| first = node->properties; | |
| if (first == NULL) { | |
| *length = 0; | |
| return S_OK; | |
| } | |
| curr = first; | |
| attrCount = 1; | |
| while (curr->next) { | |
| attrCount++; | |
| curr = curr->next; | |
| } | |
| *length = attrCount; | |
| return S_OK; | |
| } | |
| static HRESULT domelem_next_node(const xmlNodePtr node, LONG *iter, IXMLDOMNode **nextNode) | |
| { | |
| xmlAttrPtr curr; | |
| LONG i; | |
| TRACE("(%p)->(%d: %p)\n", node, *iter, nextNode); | |
| *nextNode = NULL; | |
| curr = node->properties; | |
| for (i = 0; i < *iter; i++) { | |
| if (curr->next == NULL) | |
| return S_FALSE; | |
| else | |
| curr = curr->next; | |
| } | |
| (*iter)++; | |
| *nextNode = create_node((xmlNodePtr)curr); | |
| return S_OK; | |
| } | |
| static const struct nodemap_funcs domelem_attr_map = { | |
| domelem_get_named_item, | |
| domelem_set_named_item, | |
| domelem_remove_named_item, | |
| domelem_get_item, | |
| domelem_get_length, | |
| domelem_get_qualified_item, | |
| domelem_remove_qualified_item, | |
| domelem_next_node | |
| }; | |
| static const tid_t domelem_iface_tids[] = { | |
| IXMLDOMElement_tid, | |
| 0 | |
| }; | |
| static dispex_static_data_t domelem_dispex = { | |
| NULL, | |
| IXMLDOMElement_tid, | |
| NULL, | |
| domelem_iface_tids | |
| }; | |
| IUnknown* create_element( xmlNodePtr element ) | |
| { | |
| domelem *This; | |
| This = heap_alloc( sizeof *This ); | |
| if ( !This ) | |
| return NULL; | |
| This->IXMLDOMElement_iface.lpVtbl = &domelem_vtbl; | |
| This->ref = 1; | |
| init_xmlnode(&This->node, element, (IXMLDOMNode*)&This->IXMLDOMElement_iface, &domelem_dispex); | |
| return (IUnknown*)&This->IXMLDOMElement_iface; | |
| } | |
| #endif |