markupmsxml.cpp

最有名的一个VC++外部类,Cmarkup,现在已经出了最新版8.2了,现在网上的都是6.1以下的版,希望这个新版对你们有所帮助,一些相用VC开发VML的朋友千万不要错过

	// Convert integer to string
	_TCHAR szVal[25];
	_stprintf( szVal, _T("%d"), nValue );
	return x_AddElem( szName, szVal, bInsert, bAddChild );
}

BOOL CMarkupMSXML::x_AddElem( LPCTSTR szName, LPCTSTR szData, BOOL bInsert, BOOL bAddChild )
{
	MSXMLNS::IXMLDOMNodePtr pNext, pParent;
	if ( bAddChild )
	{
		if ( ! (bool)m_pMain )
			return FALSE;
		pParent = m_pMain;
		pNext = m_pChild;
	}
	else
	{
		if ( m_pChild )
			m_pChild.Release();
		pParent = m_pParent;
		pNext = m_pMain;
	}
	if ( bInsert )
	{
		if ( ! ((bool)pNext) )
			pNext = pParent->GetfirstChild();
	}
	else
	{
		if ( pNext )
			pNext = pNext->GetnextSibling();
	}

	MSXMLNS::IXMLDOMElementPtr pNew;
	if ( m_strDefaultNamespace.IsEmpty() )
		pNew = m_pDOMDoc->createElement( _bstr_t(szName) );
	else
		pNew = m_pDOMDoc->createNode( _variant_t((short)MSXMLNS::NODE_ELEMENT),
			_bstr_t(szName), _bstr_t(m_strDefaultNamespace) );

	x_Insert( pParent, pNext, pNew );
	if ( szData && szData[0] )
	{
		MSXMLNS::IXMLDOMNodePtr pText = m_pDOMDoc->createTextNode( _bstr_t(szData) );
		pNew->appendChild( pText );
	}

	if ( bAddChild )
		m_pChild = pNew;
	else
		m_pMain = pNew;
	return TRUE;
}

CString CMarkupMSXML::x_GetSubDoc( MSXMLNS::IXMLDOMNodePtr pNode ) const
{
	if ( (bool)pNode )
		return (LPCTSTR)pNode->xml;
	return _T("");
}

BOOL CMarkupMSXML::x_AddSubDoc( LPCTSTR szSubDoc, BOOL bInsert, BOOL bAddChild )
{
	MSXMLNS::IXMLDOMNodePtr pNext, pParent;
	if ( bAddChild )
	{
		// Add a subdocument under main position, before or after child
		if ( ! (bool)m_pMain )
			return FALSE;
		pParent = m_pMain;
		pNext = m_pChild;
	}
	else
	{
		// Add a subdocument under parent position, before or after main
		if ( ! (bool)m_pParent )
			return FALSE;
		pParent = m_pParent;
		pNext = m_pMain;
	}
	if ( bInsert )
	{
		if ( ! ((bool)pNext) )
			pNext = pParent->GetfirstChild();
	}
	else
	{
		if ( pNext )
			pNext = pNext->GetnextSibling();
	}

#if defined(MARKUP_MSXML4)
	MSXMLNS::IXMLDOMDocument2Ptr pSubDoc;
	pSubDoc.CreateInstance( __uuidof(MSXML2::DOMDocument40) );
#elif defined(MARKUP_MSXML3)
	MSXMLNS::IXMLDOMDocument2Ptr pSubDoc;
	pSubDoc.CreateInstance( __uuidof(MSXML2::DOMDocument) );
#else
	MSXMLNS::IXMLDOMDocumentPtr pSubDoc;
	pSubDoc.CreateInstance( _T("Microsoft.XMLDOM") );
#endif
	// pSubDoc->PutpreserveWhiteSpace( TRUE );
#ifndef _UNICODE
#if defined(MARKUP_MSXML3) || defined(MARKUP_MSXML4)
	VARIANT_BOOL bResult = pSubDoc->loadXML( szSubDoc );
#else
	USES_CONVERSION;
	_bstr_t bstrSubDoc(A2BSTR(szSubDoc),false);
	VARIANT_BOOL bResult = pSubDoc->loadXML( bstrSubDoc );
#endif
#else
	_bstr_t bstrSubDoc(szSubDoc);
	VARIANT_BOOL bResult = pSubDoc->loadXML( bstrSubDoc );
#endif
	if ( ! bResult )
		return FALSE;
	MSXMLNS::IXMLDOMElementPtr pNew = pSubDoc->GetdocumentElement();
	x_Insert( pParent, pNext, pNew );

	if ( bAddChild )
	{
		m_pChild = pNew;
	}
	else
	{
		m_pMain = pNew;
		if ( m_pChild )
			m_pChild.Release();
	}
	return TRUE;
}

BOOL CMarkupMSXML::x_SetAttrib( MSXMLNS::IXMLDOMNodePtr pNode, LPCTSTR szAttrib, int nValue )
{
	_TCHAR szVal[25];
	_itot( nValue, szVal, 10 );
	return x_SetAttrib( pNode, szAttrib, szVal );
}

BOOL CMarkupMSXML::x_SetAttrib( MSXMLNS::IXMLDOMNodePtr pNode, LPCTSTR szAttrib, LPCTSTR szValue )
{
	if ( ! ((bool)pNode) )
		return FALSE;

	MSXMLNS::IXMLDOMNamedNodeMapPtr pAttribs = pNode->Getattributes();
	MSXMLNS::IXMLDOMAttributePtr pAttr = m_pDOMDoc->createAttribute( _bstr_t(szAttrib) );
	if ( pAttr )
	{
		_variant_t varVal;
#ifdef _UNICODE
		varVal.vt = VT_BSTR;
		varVal.bstrVal = SysAllocString(szValue);
#else
		varVal.SetString(szValue);
#endif
		pAttr->put_value( varVal );
		pAttribs->setNamedItem( pAttr );
		return TRUE;
	}
	return FALSE;
}


int CMarkupMSXML::x_GetNodeType( MSXMLNS::IXMLDOMNodePtr pNode ) const
{
	// Convert DOM node type to EDOM node type
	if ( ((bool)pNode) )
	{
		switch ( pNode->GetnodeType() )
		{
		case MSXMLNS::NODE_ELEMENT:
			return MNT_ELEMENT;
		case MSXMLNS::NODE_TEXT:
			{
				// Determine if whitespace
				MSXMLNS::IXMLDOMTextPtr pText = pNode;
				CString strTextData = (LPCTSTR) pText->Getdata();
				if ( strTextData.SpanIncluding( _T(" \t\r\n") ).GetLength() == strTextData.GetLength() )
					return MNT_WHITESPACE;
				return MNT_TEXT;
			}
		case MSXMLNS::NODE_CDATA_SECTION:
			return MNT_CDATA_SECTION;
		case MSXMLNS::NODE_PROCESSING_INSTRUCTION:
			return MNT_PROCESSING_INSTRUCTION;
		case MSXMLNS::NODE_COMMENT:
			return MNT_COMMENT;
		case MSXMLNS::NODE_DOCUMENT_TYPE:
			MNT_DOCUMENT_TYPE;
		}
	}
	return 0;
}

BOOL CMarkupMSXML::x_AddNode( int nNodeType, LPCTSTR szText, BOOL bInsert )
{
	// Create
	MSXMLNS::IXMLDOMNodePtr pNew;
	switch ( nNodeType )
	{
	case MNT_ELEMENT:
		{
			MSXMLNS::IXMLDOMElementPtr pElement;
			pElement = m_pDOMDoc->createElement( _bstr_t(szText) );
			pNew = pElement;
		}
		break;
	case MNT_TEXT:
	case MNT_WHITESPACE:
		pNew = m_pDOMDoc->createTextNode( _bstr_t(szText) );
		break;
	case MNT_CDATA_SECTION:
		{
			MSXMLNS::IXMLDOMCDATASectionPtr pCDATASection;
			pCDATASection = m_pDOMDoc->createCDATASection( _bstr_t(szText) );
			pNew = pCDATASection;
		}
		break;
	case MNT_PROCESSING_INSTRUCTION:
		{
			// Extract target
			CString strTarget( szText ), strData;
			int nSpace = strTarget.FindOneOf( _T(" \t\r\n") );
			if ( nSpace != -1 )
			{
				strData = strTarget.Mid( nSpace + 1 );
				strTarget = strTarget.Left( nSpace );
			}
			MSXMLNS::IXMLDOMProcessingInstructionPtr pPI;
			pPI = m_pDOMDoc->createProcessingInstruction( _bstr_t((LPCTSTR)strTarget), _bstr_t((LPCTSTR)strData) );
			pNew = pPI;
		}
		break;
	case MNT_COMMENT:
		pNew = m_pDOMDoc->createComment( _bstr_t(szText) );
		break;
	case MNT_DOCUMENT_TYPE:
		m_strError = "XMLDOM: Document Type is Read-Only";
		return FALSE;
	}

	// Insert
	MSXMLNS::IXMLDOMNodePtr pNext, pParent;
	if ( m_pChild )
		m_pChild.Release();
	pParent = m_pParent;
	pNext = m_pMain;
	if ( bInsert )
	{
		if ( ! ((bool)pNext) )
			pNext = pParent->GetfirstChild();
	}
	else
	{
		if ( pNext )
			pNext = pNext->GetnextSibling();
	}
	x_Insert( pParent, pNext, pNew );

	m_pMain = pNew;
	return TRUE;
}

CString CMarkupMSXML::x_GetData( MSXMLNS::IXMLDOMNodePtr pNode ) const
{
	CString strData;
	if ( ! ((bool)pNode) )
		return strData;

	int nNodeType = x_GetNodeType( pNode );
	if ( nNodeType != MNT_ELEMENT )
	{
		switch ( nNodeType )
		{
		case MNT_PROCESSING_INSTRUCTION:
			{
				MSXMLNS::IXMLDOMProcessingInstructionPtr pPI = pNode;
				CString strTarget = (LPCTSTR) pPI->Gettarget();
				strData.Format( _T("%s %s"), strTarget, (LPCTSTR)pPI->Getdata() );
			}
			break;
		case MNT_COMMENT:
			{
				MSXMLNS::IXMLDOMCommentPtr pComment = pNode;
				strData = (LPCTSTR) pComment->Getdata();
			}
			break;
		case MNT_CDATA_SECTION:
			{
				MSXMLNS::IXMLDOMCDATASectionPtr pCDATASection = pNode;
				strData = (LPCTSTR) pCDATASection->Getdata();
			}
			break;
		case MNT_TEXT:
		case MNT_WHITESPACE:
			{
				MSXMLNS::IXMLDOMTextPtr pText = pNode;
				strData = (LPCTSTR) pText->Getdata();
			}
			break;
		}
		return strData;
	}

	if ( (bool)(pNode->GetfirstChild()) )
		strData = (LPCTSTR) pNode->Gettext();
	return strData;
}

BOOL CMarkupMSXML::x_SetData( MSXMLNS::IXMLDOMNodePtr& pNode, LPCTSTR szData, int nCDATA )
{
	if ( ! ((bool)pNode) )
		return FALSE;

	int nNodeType = x_GetNodeType( pNode );
	if ( nNodeType != MNT_ELEMENT )
	{
		switch ( nNodeType )
		{
		case MNT_PROCESSING_INSTRUCTION:
			{
				MSXMLNS::IXMLDOMProcessingInstructionPtr pPI = pNode;
				CString strExistingTarget = (LPCTSTR) pPI->Gettarget();

				// Extract target from specified target
				CString strTarget( szData ), strData;
				int nSpace = strTarget.FindOneOf( _T(" \t\r\n") );
				if ( nSpace != -1 )
				{
					strData = strTarget.Mid( nSpace + 1 );
					strTarget = strTarget.Left( nSpace );
				}
				if ( strTarget != strExistingTarget )
				{
					m_strError = "Specified Target does not match current node";
					return FALSE;
				}
				pPI->Putdata( _bstr_t((LPCTSTR)strData) );
			}
			break;
		case MNT_COMMENT:
			{
				MSXMLNS::IXMLDOMCommentPtr pComment = pNode;
				pComment->Putdata( _bstr_t(szData) );
			}
			break;
		case MNT_CDATA_SECTION:
			{
				MSXMLNS::IXMLDOMCDATASectionPtr pCDATASection = pNode;
				pCDATASection->Putdata( _bstr_t(szData) );
			}
			break;
		case MNT_TEXT:
		case MNT_WHITESPACE:
			{
				MSXMLNS::IXMLDOMTextPtr pText = pNode;
				pText->Putdata( _bstr_t(szData) );
			}
			break;
		}
		return TRUE;
	}

	if ( ! ((bool)pNode) )
		return FALSE;

	// Return FALSE if child element
	MSXMLNS::IXMLDOMNodePtr pChild = pNode->GetfirstChild();
	MSXMLNS::IXMLDOMNodePtr pChildNext = pChild;
	while ( (bool)pChildNext )
	{
		if ( pChildNext->nodeType == MSXMLNS::NODE_ELEMENT )
			return FALSE;
		pChildNext = pChildNext->GetnextSibling();
	}

	// Remove any child nodes
	pChildNext = pChild;
	while ( (bool)pChildNext )
	{
		MSXMLNS::IXMLDOMNodePtr pChildDel = pChildNext;
		pChildNext = pChildNext->GetnextSibling();
		pNode->removeChild( pChildDel );
	}

	if ( nCDATA != 0 )
	{
		MSXMLNS::IXMLDOMCDATASectionPtr pData;
		LPCTSTR pszNextStart = szData;
		LPCTSTR pszEnd = _tcsstr( szData, _T("]]>") );
		while ( pszEnd )
		{
			CString csSegment( pszNextStart, (int)(pszEnd - pszNextStart) + 2 );
			pData = m_pDOMDoc->createCDATASection( _bstr_t((LPCTSTR)csSegment) );
			pNode->appendChild( pData );
			pszNextStart = pszEnd + 2;
			pszEnd = _tcsstr( pszNextStart, _T("]]>") );
		}
		pData = m_pDOMDoc->createCDATASection( _bstr_t(pszNextStart) );
		pNode->appendChild( pData );
	}
	else
	{
		MSXMLNS::IXMLDOMNodePtr pText = m_pDOMDoc->createTextNode( _bstr_t(szData) );
		pNode->appendChild( pText );
	}

	return TRUE;
}