markupmsxml.cpp

MarkUP ,用于VC环境下

{
	if ( pNext )
	{
		VARIANT varRef;
		VariantInit( &varRef );
		varRef.vt = VT_DISPATCH;
		varRef.pdispVal = pNext.GetInterfacePtr();
		pParent->insertBefore( pNew, varRef );
	}
	else
		pParent->appendChild( pNew );
}

BOOL CMarkupMSXML::x_AddElem( LPCTSTR szName, int nValue, BOOL bInsert, BOOL bAddChild )
{
	// 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( ToBSTR(szName) );
	else
		pNew = m_pDOMDoc->createNode( _variant_t((short)MSXMLNS::NODE_ELEMENT),
			ToBSTR(szName), ToBSTR(m_strDefaultNamespace) );

	x_Insert( pParent, pNext, pNew );
	if ( szData && szData[0] )
	{
		MSXMLNS::IXMLDOMNodePtr pText = m_pDOMDoc->createTextNode( ToBSTR(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 FromBSTR(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 );
#if ! defined(_UNICODE) && (defined(MARKUP_MSXML3) || defined(MARKUP_MSXML4))
	VARIANT_BOOL bResult = pSubDoc->loadXML( szSubDoc );
#else
	VARIANT_BOOL bResult = pSubDoc->loadXML( ToBSTR(szSubDoc) );
#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( ToBSTR(szAttrib) );
	if ( pAttr )
	{
		pAttr->put_value( ToVARIANT(szValue) );
		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 = FromBSTR(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( ToBSTR(szText) );
			pNew = pElement;
		}
		break;
	case MNT_TEXT:
	case MNT_WHITESPACE:
		pNew = m_pDOMDoc->createTextNode( ToBSTR(szText) );
		break;
	case MNT_CDATA_SECTION:
		{
			MSXMLNS::IXMLDOMCDATASectionPtr pCDATASection;
			pCDATASection = m_pDOMDoc->createCDATASection( ToBSTR(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( ToBSTR(strTarget), ToBSTR(strData) );
			pNew = pPI;
		}
		break;
	case MNT_COMMENT:
		pNew = m_pDOMDoc->createComment( ToBSTR(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 = FromBSTR(pPI->Gettarget());
				strData.Format( _T("%s %s"), strTarget, FromBSTR(pPI->Getdata()) );
			}
			break;
		case MNT_COMMENT:
			{
				MSXMLNS::IXMLDOMCommentPtr pComment = pNode;
				strData = FromBSTR(pComment->Getdata());
			}
			break;
		case MNT_CDATA_SECTION:
			{
				MSXMLNS::IXMLDOMCDATASectionPtr pCDATASection = pNode;
				strData = FromBSTR(pCDATASection->Getdata());
			}
			break;
		case MNT_TEXT:
		case MNT_WHITESPACE:
			{
				MSXMLNS::IXMLDOMTextPtr pText = pNode;
				strData = FromBSTR(pText->Getdata());
			}
			break;
		}
		return strData;
	}

	if ( (bool)(pNode->GetfirstChild()) )
		strData = FromBSTR(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 = FromBSTR(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( ToBSTR(strData) );
			}
			break;
		case MNT_COMMENT:
			{
				MSXMLNS::IXMLDOMCommentPtr pComment = pNode;
				pComment->Putdata( ToBSTR(szData) );
			}
			break;
		case MNT_CDATA_SECTION:
			{
				MSXMLNS::IXMLDOMCDATASectionPtr pCDATASection = pNode;
				pCDATASection->Putdata( ToBSTR(szData) );
			}
			break;
		case MNT_TEXT:
		case MNT_WHITESPACE:
			{
				MSXMLNS::IXMLDOMTextPtr pText = pNode;
				pText->Putdata( ToBSTR(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( ToBSTR(csSegment) );
			pNode->appendChild( pData );
			pszNextStart = pszEnd + 2;
			pszEnd = _tcsstr( pszNextStart, _T("]]>") );
		}
		pData = m_pDOMDoc->createCDATASection( ToBSTR(pszNextStart) );
		pNode->appendChild( pData );
	}
	else
	{
		MSXMLNS::IXMLDOMNodePtr pText = m_pDOMDoc->createTextNode( ToBSTR(szData) );
		pNode->appendChild( pText );
	}

	return TRUE;
}