markupmsxml.cpp

MarkUP ,用于VC环境下

// MarkupMSXML.cpp: implementation of the CMarkupMSXML class.
//
// Markup Release 9.0
// Copyright (C) 1999-2007 First Objective Software, Inc. All rights reserved
// Go to www.firstobject.com for the latest CMarkup and EDOM documentation
// Use in commercial applications requires written permission
// This software is provided "as is", with no warranty.

#include "stdafx.h"
#include "afxconv.h"
#include "MarkupMSXML.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


CMarkupMSXML::CMarkupMSXML()
{
	CoInitialize(NULL);
	x_CreateInstance();
}

CMarkupMSXML::CMarkupMSXML( LPCTSTR szDoc )
{
	CoInitialize(NULL);
	if ( SUCCEEDED(x_CreateInstance()) )
		SetDoc( szDoc );
}

_bstr_t CMarkupMSXML::ToBSTR( LPCTSTR pszText )
{
#ifdef _UNICODE
	_bstr_t bstrText( pszText );
#else
	USES_CONVERSION;
	_bstr_t bstrText( A2BSTR(pszText), false );
#endif
	return bstrText;
}

CString CMarkupMSXML::FromBSTR( const _bstr_t& bstrText )
{
#ifdef _UNICODE
	CString csText( (LPCWSTR)bstrText );
#else
	USES_CONVERSION;
	CString csText( W2A(bstrText) );
#endif
	return csText;
}

_variant_t CMarkupMSXML::ToVARIANT( LPCTSTR pszText )
{
	_variant_t varText;
#ifdef _UNICODE
	varText.vt = VT_BSTR;
	varText.bstrVal = SysAllocString(pszText);
#else
	varText.SetString(pszText);
#endif
	return varText;
}

CString CMarkupMSXML::FromVARIANT( const _variant_t& varText )
{
	CString csText;
	if ( varText.vt == VT_BSTR )
		csText = FromBSTR( varText.bstrVal );
	return csText;
}


CMarkupMSXML::~CMarkupMSXML()
{
	// Release COM interfaces, in case CoUninitialize is being called the last time
	if ( m_pChild )
		m_pChild.Release();
	if ( m_pMain )
		m_pMain.Release();
	if ( m_pParent )
		m_pParent.Release();
	if ( m_pDOMDoc )
		m_pDOMDoc.Release();
	CoUninitialize();
}

HRESULT CMarkupMSXML::x_CreateInstance()
{
	// Release any reference to a previous instance
	if ( m_pParent )
		m_pParent.Release();
	if ( m_pDOMDoc )
		m_pDOMDoc.Release();

	// Create new instance
#if defined( MARKUP_MSXML4 )
	HRESULT hr = m_pDOMDoc.CreateInstance( __uuidof(MSXML2::DOMDocument40) );
#elif defined( MARKUP_MSXML3 )
	HRESULT hr = m_pDOMDoc.CreateInstance( __uuidof(MSXML2::DOMDocument) );
#else
	HRESULT hr = m_pDOMDoc.CreateInstance( "Microsoft.XMLDOM" );
#endif
	if ( FAILED(hr) )
	{
		if ( hr == REGDB_E_CLASSNOTREG )
			AfxMessageBox( _T("MSXML not registered") );
		else
			AfxMessageBox( _T("Unable to create MSXML instance") );
	}
	// m_pDOMDoc->PutpreserveWhiteSpace( TRUE );
	m_pParent = m_pDOMDoc;
	return hr;
}

BOOL CMarkupMSXML::x_ParseError()
{
	MSXMLNS::IXMLDOMParseErrorPtr pDOMParseError;
	m_pDOMDoc->get_parseError( &pDOMParseError );
	m_strError = FromBSTR(pDOMParseError->Getreason());
	m_strError.TrimRight( _T("\r\n") );
	return FALSE;
}

BOOL CMarkupMSXML::SetDoc( LPCTSTR szDoc )
{
	ResetPos();

	// If szDoc is empty, clear it
	if ( ! szDoc || ! szDoc[0] )
		return SUCCEEDED( x_CreateInstance() );

	VARIANT_BOOL bResult = m_pDOMDoc->loadXML( ToBSTR(szDoc) );
	if ( ! bResult )
		return x_ParseError();
	return TRUE;
};

BOOL CMarkupMSXML::Load( LPCTSTR szFileName )
{
	VARIANT_BOOL bResult = m_pDOMDoc->load( ToVARIANT(szFileName) );
	ResetPos();
	if ( ! bResult )
		return x_ParseError();
	return TRUE;
}

BOOL CMarkupMSXML::Save( LPCTSTR szFileName )
{
	HRESULT hr = m_pDOMDoc->save( ToVARIANT(szFileName) );
	if ( hr )
		return FALSE;
	return TRUE;
}

CString CMarkupMSXML::GetDoc() const
{
	return FromBSTR( m_pDOMDoc->xml );
};

BOOL CMarkupMSXML::FindElem( LPCTSTR szName )
{
	// Change current position only if found
	//
	MSXMLNS::IXMLDOMNodePtr pNode;
	pNode = x_FindElem( m_pParent, m_pMain, szName );
	if ( pNode )
	{
		m_pMain = pNode;
		m_pParent = m_pMain->GetparentNode();
		if ( m_pChild )
			m_pChild.Release();
		return TRUE;
	}
	return FALSE;
}

BOOL CMarkupMSXML::SetMainPosPtr( MSXMLNS::IXMLDOMNodePtr pMain )
{
	if ( m_pChild )
		m_pChild.Release();
	if ( pMain )
	{
		m_pMain = pMain;
		m_pParent = m_pMain->GetparentNode();
		return TRUE;
	}
	m_pMain.Release();
	return FALSE;
}

BOOL CMarkupMSXML::FindChildElem( LPCTSTR szName )
{
	// Change current child position only if found
	//
	// Shorthand: call this with no current main position
	// means find child under root element
	if ( ! ((bool)(m_pParent->GetparentNode())) && ! ((bool)m_pMain) )
		FindElem();
	if ( ! ((bool)m_pMain) )
		return FALSE;

	MSXMLNS::IXMLDOMNodePtr pNode;
	pNode = x_FindElem( m_pMain, m_pChild, szName );
	if ( pNode )
	{
		m_pChild = pNode;
		m_pMain = m_pChild->GetparentNode();
		m_pParent = m_pMain->GetparentNode();
		return TRUE;
	}

	return FALSE;
}

BOOL CMarkupMSXML::IntoElem()
{
	if ( m_pMain )
	{
		m_pParent = m_pMain;
		if ( m_pChild )
		{
			m_pMain = m_pChild;
			m_pChild.Release();
		}
		else
			m_pMain.Release();
		return TRUE;
	}
	return FALSE;
}

BOOL CMarkupMSXML::OutOfElem()
{
	if ( (bool)(m_pParent->GetparentNode()) )
	{
		m_pChild = m_pMain;
		m_pMain = m_pParent;
		m_pParent = m_pMain->GetparentNode();
		return TRUE;
	}
	return FALSE;
}

CString CMarkupMSXML::GetAttribName( int n ) const
{
	CString strAttribName;
	if ( ! (bool)m_pMain )
		return strAttribName;

	// Is it within range?
	if ( n >= 0 && n < m_pMain->Getattributes()->Getlength() )
	{
		MSXMLNS::IXMLDOMNodePtr pAttrib = m_pMain->Getattributes()->item[n];
		strAttribName = FromBSTR( pAttrib->GetnodeName() );
	}
	return strAttribName;
}

BOOL CMarkupMSXML::RemoveElem()
{
	if ( m_pMain )
	{
		MSXMLNS::IXMLDOMNodePtr pParent = m_pMain->GetparentNode();
		if ( pParent )
		{
			if ( m_pChild )
				m_pChild.Release();
			MSXMLNS::IXMLDOMNodePtr pPrev = m_pMain->GetpreviousSibling();
			pParent->removeChild( m_pMain );
			m_pMain = pPrev;
			return TRUE;
		}
	}
	return FALSE;
}

BOOL CMarkupMSXML::RemoveChildElem()
{
	if ( m_pChild )
	{
		MSXMLNS::IXMLDOMNodePtr pPrev = m_pChild->GetpreviousSibling();
		m_pMain->removeChild( m_pChild );
		m_pChild.Release();
		m_pChild = pPrev;
		return TRUE;
	}
	return FALSE;
}


int CMarkupMSXML::FindNode( int nType )
{
	MSXMLNS::IXMLDOMNodePtr pNext;
	if ( m_pMain )
		pNext = m_pMain->GetnextSibling();
	else
		pNext = m_pParent->GetfirstChild();
	while ( pNext )
	{
		int nTypeFound = x_GetNodeType( pNext );
		if ( (nType==0 && nTypeFound!=0) || (nTypeFound & nType) )
		{
			m_pMain = pNext;
			if ( m_pChild )
				m_pChild.Release();
			return nTypeFound;
		}
		pNext = pNext->GetnextSibling();
	}
	return 0;
}

BOOL CMarkupMSXML::RemoveNode()
{
	if ( m_pMain )
	{
		MSXMLNS::IXMLDOMNodePtr pParent = m_pMain->GetparentNode();
		if ( pParent )
		{
			if ( m_pChild )
				m_pChild.Release();
			MSXMLNS::IXMLDOMNodePtr pPrev = m_pMain->GetpreviousSibling();
			pParent->removeChild( m_pMain );
			m_pMain = pPrev;
			return TRUE;
		}
	}
	return FALSE;
}


//////////////////////////////////////////////////////////////////////
// Private Methods
//////////////////////////////////////////////////////////////////////


MSXMLNS::IXMLDOMNodePtr CMarkupMSXML::x_FindElem( MSXMLNS::IXMLDOMNodePtr pParent, MSXMLNS::IXMLDOMNodePtr pNode, LPCTSTR szPath )
{
	// If szPath is NULL or empty, go to next sibling element
	// Otherwise go to next sibling element with matching path
	//
	if ( pNode )
		pNode = pNode->GetnextSibling();
	else
		pNode = pParent->GetfirstChild();

	while ( pNode )
	{
		if ( pNode->nodeType == MSXMLNS::NODE_ELEMENT )
		{
			// Compare tag name unless szPath is not specified
			if ( szPath == NULL || !szPath[0] || x_GetTagName(pNode) == szPath )
				break;
		}
		pNode = pNode->GetnextSibling();
	}
	return pNode;

}

CString CMarkupMSXML::x_GetPath( MSXMLNS::IXMLDOMNodePtr pNode ) const
{
	CString strPath;
	while ( ((bool)pNode) && pNode->GetnodeType() != MSXMLNS::NODE_DOCUMENT )
	{
		CString strTagName = x_GetTagName( pNode );
		MSXMLNS::IXMLDOMNodePtr pPrevNode = pNode->GetpreviousSibling();
		int nCount = 1;
		while ( pPrevNode )
		{
			if ( x_GetTagName( pPrevNode ) == strTagName )
				++nCount;
			pPrevNode = pPrevNode->GetpreviousSibling();
		}
		if ( nCount > 1 )
		{
			_TCHAR szPred[25];
			_stprintf( szPred, _T("[%d]"), nCount );
			strPath = _T("/") + strTagName + szPred + strPath;
		}
		else
			strPath = _T("/") + strTagName + strPath;

		pNode = pNode->GetparentNode();
	}
	return strPath;
}

CString CMarkupMSXML::x_GetTagName( MSXMLNS::IXMLDOMNodePtr pNode ) const
{
	CString strTagName;
	if ( pNode )
		strTagName = FromBSTR( pNode->GetnodeName() );
	return strTagName;
}

CString CMarkupMSXML::x_GetAttrib( MSXMLNS::IXMLDOMNodePtr pNode, LPCTSTR szAttrib ) const
{
	CString strAttrib;
	if ( pNode )
	{
		MSXMLNS::IXMLDOMNodePtr pAttrib;
		HRESULT hr = pNode->Getattributes()->raw_getNamedItem( ToBSTR(szAttrib), &pAttrib );
		if ( SUCCEEDED(hr) && ((bool)pAttrib) )
			strAttrib = FromVARIANT(pAttrib->GetnodeValue());
	}
	return strAttrib;
}

void CMarkupMSXML::x_Insert( MSXMLNS::IXMLDOMNodePtr pParent, MSXMLNS::IXMLDOMNodePtr pNext, MSXMLNS::IXMLDOMNodePtr pNew )