xmlnodewrapper.cpp

管理项目进度工具的原代码

			bPath = m_xmldoc->Geturl();
		
		m_xmldoc->put_preserveWhiteSpace(bPreserveWhiteSpace ? VARIANT_TRUE : VARIANT_FALSE);
		
		return (VARIANT_TRUE == m_xmldoc->save(bPath));
	}
	catch(...)
	{
		return FALSE;
	}
}

CString CXmlDocumentWrapper::Transform(LPCTSTR pathXSL) const
{
	CXmlDocumentWrapper xsl;
	
    try
    {
        if (xsl.Load(pathXSL))
            return (LPSTR)m_xmldoc->transformNode(xsl.AsNode());
    }
    catch( const _com_error & err)
    {
        AfxMessageBox(err.ErrorMessage(), MB_OK | MB_ICONERROR);
    }

    // else
    return "";
}

MSXML2::IXMLDOMNode* CXmlDocumentWrapper::AsNode()
{
	if (!IsValid())
		return NULL;

	return m_xmldoc->GetdocumentElement().Detach();
}

CString CXmlDocumentWrapper::GetXML(BOOL bPreserveWhiteSpace) const
{
	CString sXml;
	
	if (IsValid())
	{
		m_xmldoc->put_preserveWhiteSpace(bPreserveWhiteSpace ? VARIANT_TRUE : VARIANT_FALSE);
		sXml = (LPCSTR)m_xmldoc->Getxml();
		
      // Getxml doesn't return entire header so we need to fix it up here
      CString sHeader = GetHeader(TRUE);
      int nStart = sXml.Find("?xml");
		
      if (nStart > 0)
      {
         // find start brace
         while (sXml[nStart] != '<')
            nStart--;

         // find end brace
         int nEnd = sXml.Find(">") + 1; // closing brace

         sXml = sXml.Left(nStart) + sHeader + sXml.Mid(nEnd);
      }
      else // just add header
         sXml = sHeader + sXml;
	}
	
	return sXml;
}

CString CXmlDocumentWrapper::GetUrl() const
{
	return (LPSTR)m_xmldoc->Geturl();
}

BOOL CXmlDocumentWrapper::IsVersion3orGreater()
{
	if (s_bVer3orGreater == -1)
	{
		try
		{
			// try to load some dummy xml
			CXmlDocumentWrapper doc;
			CString sXml;

			sXml.Format("<?xml %s ?><NodeList/>", DEFAULT_HEADER);
			s_bVer3orGreater = doc.LoadXML(sXml);
		}
		catch (CException* /*e*/)
		{
			s_bVer3orGreater = FALSE;
		}
	}

	return s_bVer3orGreater;
}

//////////////////////////////////////////////////////////////////////////

//------------------------//
// Convert char * to BSTR //
//------------------------//
BSTR CXmlNodeWrapper::ConvertStringToBSTR(const char* pSrc)
{
	if(!pSrc) return NULL;
	
	BSTR wsOut(NULL);
	DWORD cwch = ::MultiByteToWideChar(CP_ACP, 0, pSrc, -1, NULL, 0);//get size minus NULL terminator

	if (cwch)
	{
		cwch--;
		wsOut = ::SysAllocStringLen(NULL, cwch);
		
		if(wsOut)
		{
			if(!::MultiByteToWideChar(CP_ACP, 0, pSrc, -1, wsOut, cwch))
			{
				if(ERROR_INSUFFICIENT_BUFFER == ::GetLastError())
					return wsOut;
				::SysFreeString(wsOut);//must clean up
				wsOut = NULL;
			}
		}
		
	};
	
	return wsOut;
};

//////////////////////////////////////////////////////////////////////////////

MSXML2::IXMLDOMDocument* CXmlNodeWrapper::ParentDocument()
{
	return m_xmlnode->GetownerDocument().Detach();
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::Interface()
{
	if (IsValid())
		return m_xmlnode;
	return NULL;
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertBefore(MSXML2::IXMLDOMNode *refNode, LPCTSTR nodeName)
{
	MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
	if (xmlDocument)
	{
		MSXML2::IXMLDOMNodePtr newNode = xmlDocument->createNode(_variant_t((short)MSXML2::NODE_ELEMENT),nodeName,"");
		MSXML2::IXMLDOMNode* pNode = m_xmlnode->insertBefore(newNode.Detach(),(IUnknown*)refNode);
		
		return pNode;
	}
	return NULL;
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertAfter(MSXML2::IXMLDOMNode *refNode, LPCTSTR nodeName)
{
	MSXML2::IXMLDOMDocumentPtr xmlDocument = m_xmlnode->GetownerDocument();
	if (xmlDocument)
	{
		MSXML2::IXMLDOMNodePtr newNode = xmlDocument->createNode(_variant_t((short)MSXML2::NODE_ELEMENT),nodeName,"");
		MSXML2::IXMLDOMNodePtr nextNode = refNode->GetnextSibling();
		MSXML2::IXMLDOMNode* pNode = NULL;
		
		if (nextNode.GetInterfacePtr() != NULL)
			pNode = m_xmlnode->insertBefore(newNode.Detach(),(IUnknown*)nextNode);
		else
			pNode = m_xmlnode->appendChild(newNode.Detach());
		
		return pNode;
	}
	return NULL;
}

void CXmlNodeWrapper::RemoveNodes(LPCTSTR searchStr)
{
	if (!IsValid())
		return;

	MSXML2::IXMLDOMNodeListPtr nodeList = m_xmlnode->selectNodes(searchStr);
	for (int i = 0; i < nodeList->Getlength(); i++)
	{
		try
		{
			MSXML2::IXMLDOMNode* pNode = nodeList->Getitem(i).Detach();
			pNode->GetparentNode()->removeChild(pNode);
		}
		catch (_com_error er)
		{
			AfxMessageBox(er.ErrorMessage());
		}
	}
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::Parent()
{
	if (IsValid())
		return m_xmlnode->GetparentNode().Detach();

	return NULL;
}

CXmlNodeListWrapper::CXmlNodeListWrapper()
{
}
CXmlNodeListWrapper::CXmlNodeListWrapper(MSXML2::IXMLDOMNodeListPtr pList)
{
	m_xmlnodelist = pList;
}

void CXmlNodeListWrapper::operator=(MSXML2::IXMLDOMNodeListPtr pList)
{
	if (IsValid())
		m_xmlnodelist.Release();
	
	m_xmlnodelist = pList;
}

CXmlNodeListWrapper::~CXmlNodeListWrapper()
{
	
}

int CXmlNodeListWrapper::Count()
{
	if (IsValid())
		return m_xmlnodelist->Getlength();
	else
		return 0;
	
}

BOOL CXmlNodeListWrapper::IsValid()
{
	if (m_xmlnodelist == NULL)
		return FALSE;

	if (m_xmlnodelist.GetInterfacePtr() == NULL)

		return FALSE;
	return TRUE;
}

MSXML2::IXMLDOMNode* CXmlNodeListWrapper::Next()
{
	if (IsValid())
		return m_xmlnodelist->nextNode().Detach();
	else
		return NULL;
}

void CXmlNodeListWrapper::Start()
{
	if (IsValid())
		m_xmlnodelist->reset();
}

MSXML2::IXMLDOMNode* CXmlNodeListWrapper::Node(int index)
{
	if (IsValid())
		return m_xmlnodelist->Getitem(index).Detach();
	else
		return NULL;
}

MSXML2::IXMLDOMDocument* CXmlNodeListWrapper::AsDocument()
{
	if (IsValid())
	{
		CXmlDocumentWrapper doc;
		doc.LoadXML("<NodeList></NodeList>");
		
		CXmlNodeWrapper root(doc.AsNode());
		
		for (int i = 0; i < m_xmlnodelist->Getlength(); i++)
		{
			root.InsertNode(root.NumNodes(),m_xmlnodelist->Getitem(i)->cloneNode(VARIANT_TRUE));
		}
		return doc.Detach();
	}
	else 
		return NULL;
}

MSXML2::IXMLDOMNodeList* CXmlNodeWrapper::FindNodes(LPCTSTR searchStr)
{
	if(IsValid())
	{
		try
		{
			return m_xmlnode->selectNodes(searchStr).Detach();
		}
		catch (_com_error e)
		{
			CString err = e.ErrorMessage();
			return NULL;
		}
	}
	else
		return NULL;
}

CString CXmlNodeWrapper::Name()
{
	if (IsValid())
		return (LPCSTR)m_xmlnode->GetbaseName();
	return "";
}

MSXML2::IXMLDOMNode* CXmlNodeWrapper::InsertAfter(MSXML2::IXMLDOMNode *refNode, MSXML2::IXMLDOMNode *pNode)
{
	MSXML2::IXMLDOMNodePtr nextNode = refNode->GetnextSibling();
	MSXML2::IXMLDOMNodePtr newNode;
	// Valik - Change IXMLDOMNode* to IXMLDOMNodePtr to prevent an ambiguous symbol error (C2872) in VC 7.1
	MSXML2::IXMLDOMNodePtr pNewNode = NULL;

	if (nextNode.GetInterfacePtr() != NULL)
		pNewNode = m_xmlnode->insertBefore(pNode,(IUnknown*)nextNode);
	else
		pNewNode = m_xmlnode->appendChild(pNode);

	return pNewNode;
}

void CXmlNodeWrapper::SetText(LPCTSTR text)
{
	if (IsValid())
	{
		_bstr_t bstr(ConvertStringToBSTR(text), FALSE);
		m_xmlnode->Puttext(bstr);
	}
}

CString CXmlNodeWrapper::GetText()
{
	if (IsValid())
		return (LPCSTR)m_xmlnode->Gettext();
	else
		return "";
}

void CXmlNodeWrapper::ReplaceNode(MSXML2::IXMLDOMNode *pOldNode, MSXML2::IXMLDOMNode *pNewNode)
{
	if (IsValid())
	{
		m_xmlnode->replaceChild(pNewNode,pOldNode);
	}
}

int CXmlNodeWrapper::NumAttributes()
{
	if (IsValid())
	{
		MSXML2::IXMLDOMNamedNodeMapPtr attribs = m_xmlnode->Getattributes();
		
		if (attribs)
			return attribs->Getlength();
	}
	
	return 0;
}

CString CXmlNodeWrapper::GetAttribName(int index)
{
	CString sName;
	
	if (IsValid())
	{
		MSXML2::IXMLDOMNamedNodeMapPtr attribs = m_xmlnode->Getattributes();

		if (attribs)
		{
			MSXML2::IXMLDOMAttributePtr attrib = attribs->Getitem(index);

			if (attrib)
			{
				sName = (LPCSTR)attrib->Getname();
				attrib.Release();
			}
			
			attribs.Release();
		}
	}
	
	return sName;
}

CString CXmlNodeWrapper::GetAttribVal(int index)
{
	CString sVal;
	
	if (IsValid())
	{
		MSXML2::IXMLDOMNamedNodeMapPtr attribs = m_xmlnode->Getattributes();

		if (attribs)
		{
			MSXML2::IXMLDOMAttributePtr attrib = attribs->Getitem(index);

			if (attrib)
			{
				sVal = (LPCSTR)attrib->Gettext();
				attrib.Release();
			}
			
			attribs.Release();
		}
	}
	
	
	return sVal;
}

CString CXmlNodeWrapper::NodeType()
{
	if (IsValid())
		return (LPCSTR)m_xmlnode->GetnodeTypeString();

	return "";
}

int CXmlNodeWrapper::NodeTypeVal()
{
	if (IsValid())
		return (int)m_xmlnode->GetnodeType();

	// Valik - Fully qualify the name of NODE_INVALID to prevent an ambiguous symbol error (C2872) in VC 7.1
	return MSXML2::NODE_INVALID;
}