// ImportXMLDocDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "ImportXMLDocDlg.h"


// CImportXMLDocDlg 对话框

IMPLEMENT_DYNAMIC(CImportXMLDocDlg, CModelessDialog)

CImportXMLDocDlg::CImportXMLDocDlg(CWnd* pParent /*=NULL*/)
	: CModelessDialog(CImportXMLDocDlg::IDD, pParent)
{
	m_strFilePath = _T("");
	m_pXMLDoc = NULL;
	m_strPageName = _T("");
	m_nFlag = 0;
	//CString = 0;
}
CImportXMLDocDlg::CImportXMLDocDlg(CXMLDOMFile *pXMLDoc,CString strPageName,int nFlag,CWnd* pParent)
: CModelessDialog(CImportXMLDocDlg::IDD, pParent)
{
	m_pXMLDoc = pXMLDoc;
	m_strPageName = strPageName;
	m_nFlag = nFlag;
	//m_nIndex = nIndex;
}

CImportXMLDocDlg::~CImportXMLDocDlg()
{
	/*if (m_pXMLDoc)
	{
		delete m_pXMLDoc;
	}*/
	//m_treeXmlDoc.DeleteAllItemData();
}

void CImportXMLDocDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_IMPORTXMLDOCTREE, m_treeXmlDoc);
	//DDX_Control(pDX, IDC_IMPORTLIST, m_listProperty);
}


BEGIN_MESSAGE_MAP(CImportXMLDocDlg, CModelessDialog)
	ON_NOTIFY(TVN_SELCHANGED, IDC_IMPORTXMLDOCTREE, CImportXMLDocDlg::OnTvnSelchangedImportxmldoctree)
END_MESSAGE_MAP()

// CImportXMLDocDlg 消息处理程序
BOOL CImportXMLDocDlg::OnInitDialog() 
{
	if (m_nFlag == 0)
	{
		SetWindowText(_T("导入设置"));
	}
	else
	{
		SetWindowText(_T("导入默认设置"));
	}
	CModelessDialog::OnInitDialog();
	InitTree();
	UpdateData(FALSE);
	return TRUE;  // return TRUE unless you set the focus to a control
	// EXCEPTION: OCX Property Pages should return FALSE
}

void CImportXMLDocDlg::InitTree()
{
	m_treeXmlDoc.SetXMLDoc(m_pXMLDoc);//设置xml模型指针
	m_treeXmlDoc.SetCurPageName(m_strPageName);//设置当前页面名字
	m_treeXmlDoc.InitTree();
}

void CImportXMLDocDlg::OnTvnSelchangedImportxmldoctree(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
	// TODO: 在此添加控件通知处理程序代码
	if (pNMTreeView->itemNew.hItem ==NULL)
	{
		return;
	}
	CXMLNodeInfoEx *pData = (CXMLNodeInfoEx*)(m_treeXmlDoc.GetItemData(pNMTreeView->itemNew.hItem));
	if (pData!=NULL)
	{
		NodeAttriButeAry nodeInfoAry = pData->m_aryNodeAttribute;//节点属性数组
		CString strValue = pData->m_strNodeValue;
		int nLen = nodeInfoAry.GetLength();
		CString strWindowsText;
		int i =0;
		if (nLen!=0)
		{
//			m_listProperty.ResetContent();
			for (;i<nLen;i++)
			{
				NodeAttriBute nodeInfo = nodeInfoAry.GetAt(i);
				CString strNodeName = nodeInfo.first;
				CString strNodeValue = nodeInfo.second;
				if (nLen==1&&strNodeName==_T("name"))
				{
					CString strTem = _T("目录");
					strWindowsText += strTem+_T(":")+strNodeValue+_T("\n\r"); 
			//		m_listProperty.AddString(strTem+_T(":")+strNodeValue);
				}
				else
				{
					if (strNodeName!=_T("name"))
					{
						CString strTem = _T("目录");
						if (strNodeName == _T("comment"))
						{
							strTem = _T("功能");
							strWindowsText += strTem+_T(":")+strNodeValue+_T("\n\r");
				//			m_listProperty.AddString(strTem+_T(":")+strNodeValue);
						}
						else if (strNodeName == _T("options"))
						{
							strTem = _T("选项");
							strWindowsText += strTem+_T(":")+strNodeValue+_T("\n\r");
				//			m_listProperty.AddString(strTem+_T(":")+strNodeValue);
						}
						else if (strNodeName == _T("cmdname"))
						{
							strTem = _T("命令名");
							strWindowsText += strTem+_T(":")+strNodeValue+_T("\n\r");
				//			m_listProperty.AddString(strTem+_T(":")+strNodeValue);
						}
					}
				}
			}
		}
		if (pData->m_strNodeName == _T("选项"))
		{
			CString strTem = _T("值");
			strWindowsText += _T("\n\r")+strTem+_T(":")+strValue+_T("\n\r");
		//	m_listProperty.AddString(strTem+_T(":")+strValue);
		}
		CEdit *pText = (CEdit*)GetDlgItem(IDC_EDIT_TEXT);
		pText->SetWindowText(strWindowsText);
	}
	*pResult = 0;
}
/////////////////////////////CImportXMLTreeCtrl/////////////////////
CImportXMLTreeCtrl::CImportXMLTreeCtrl()
{
	m_pXMLDoc = NULL;
	m_uFlags = 0;
}
CImportXMLTreeCtrl::CImportXMLTreeCtrl(CXMLDOMFile*pXMLDoc)
{
	m_pXMLDoc = pXMLDoc;
	m_uFlags = 0;
}
BEGIN_MESSAGE_MAP(CImportXMLTreeCtrl, CTreeCtrl)
	ON_WM_DESTROY()
	ON_NOTIFY_REFLECT(NM_CLICK, OnStateIconClick)
	ON_WM_LBUTTONDOWN()
	ON_WM_KEYDOWN()
END_MESSAGE_MAP()
void CImportXMLTreeCtrl::InitTree()
{
	HICON hIcon[4];
	m_imageList.Create(14,14,ILC_COLOR8,1,1); 
	m_imageList.SetBkColor(RGB(255,255,255));
	hIcon[0]=AfxGetApp()->LoadIcon(IDI_ICON8);
	hIcon[1]=AfxGetApp()->LoadIcon(IDI_ICON6);
	for(int i=0;i<2;i++) 
	{ 
		m_imageList.Add (hIcon[i]); 
	}
	m_imageState.Create(IDB_BITMAP_SETCHECK,13, 1, RGB(255,255,255));
	SetImageList(&m_imageList,TVSIL_NORMAL);
	SetImageList(&m_imageState,TVSIL_STATE);
	CXMLDOMNodePtr pRootNode;
	pRootNode = m_pXMLDoc->GetRoot();
	BreadthXmlNodeToTreeNode(pRootNode);

	//设置当前页面节点状态
	UINT nState = GetItemState( m_hItem, TVIS_STATEIMAGEMASK ) >> 12;
	nState=(nState==3)?1:3;
	SetItemState(m_hItem,INDEXTOSTATEIMAGEMASK(nState),TVIS_STATEIMAGEMASK);
	HTREEITEM hRoot = GetRootItem();//展开指定节点
	HTREEITEM hItem = m_hItem; 
	while (hItem !=hRoot)
	{
		//展开指定节点的父节点
		hItem = GetParentItem(hItem);
		Expand(hItem, TVE_EXPAND);
	}
	//展开根节点
	Expand(hRoot, TVE_EXPAND);
	//展开指定节点下的所有节点
	SelectItem(m_hItem);
	SendMessage(WM_KEYDOWN, VK_MULTIPLY);
	EnsureVisible(m_hItem);
	SelectItem(m_hItem);
	
	
}
//void CImportXMLTreeCtrl::ExpandItem(HTREEITEM hItem)
//{
//	if (ItemHasChildren(hItem))
//	{
//		Expand(hItem,TVE_EXPAND);
//
//	}
//}
//是否有子节点
BOOL CImportXMLTreeCtrl::IsHasChildNodes(const MSXML2::IXMLDOMNodePtr &pIXMLDOMNodePtr)
{
	assert( NULL != pIXMLDOMNodePtr );
	if ( NULL == pIXMLDOMNodePtr )
	{
		return FALSE;
	}
	MSXML2::IXMLDOMNodePtr		pXMLDOMNode = NULL;
	MSXML2::DOMNodeType			NodeType;
	MSXML2::IXMLDOMNodeListPtr	pXMLDOMNodeList = NULL;
	BOOL bHasChildNodes = FALSE;
	HRESULT hr; 
	try
	{
		hr = pIXMLDOMNodePtr->get_childNodes( &pXMLDOMNodeList );
		assert( SUCCEEDED(hr) );
		if ( FAILED( hr ) )
		{
			pXMLDOMNodeList = NULL;
			return FALSE;
		}
		for( int i = 0; i < pXMLDOMNodeList->length; i++ )
		{
			pXMLDOMNode = pXMLDOMNodeList->item[i];
			hr = pXMLDOMNode->get_nodeType( &NodeType );
			assert( SUCCEEDED( hr ) );
			if ( NULL != pXMLDOMNode )
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
			if ( NodeType == MSXML2::NODE_ELEMENT )
			{
				bHasChildNodes = TRUE;
				break;
			}
		}
	}
	catch ( ... )
	{
		if ( NULL != pXMLDOMNode )
		{
			pXMLDOMNode.Release();
			pXMLDOMNode = NULL;
		}
		if ( NULL != pXMLDOMNodeList )
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}
		assert( false );
		return FALSE;
	}
	if ( NULL != pXMLDOMNode )
	{
		pXMLDOMNode.Release();
		pXMLDOMNode = NULL;
	}
	if ( NULL != pXMLDOMNodeList )
	{
		pXMLDOMNodeList.Release();
		pXMLDOMNodeList = NULL;
	}
	return bHasChildNodes;
}
void CImportXMLTreeCtrl::BreadthXmlNodeToTreeNode(const  CXMLDOMNodePtr &pXmlNode)
{
	MSXML2::IXMLDOMNodePtr pXMLDOMNodePtr = pXmlNode->GetNodePtr();
	std::deque<MSXML2::IXMLDOMNodePtr> quene;
	std::deque<HTREEITEM> Treequeue;
	quene.push_back(pXMLDOMNodePtr);
	HTREEITEM hParent;
	BOOL bFirst = TRUE;
	BOOL bDelete = FALSE;
	while(quene.size()!=0)
	{
		MSXML2::IXMLDOMNodePtr pCurXMLDOMNodePtr = quene.front();
		quene.pop_front();
		HTREEITEM hPar;// = Treequeue.front();
		if (Treequeue.size()!=0)
		{
			hPar = Treequeue.front();
			Treequeue.pop_front();
		}
		if (IsHasChildNodes(pCurXMLDOMNodePtr))
		{
			if (bFirst)
			{
				CXMLNodeInfoEx nodeData;
				nodeData = GetNodeInfoEx(pCurXMLDOMNodePtr);
				nodeData.m_strNodeXPath = _T("/")+nodeData.m_aryNodeAttribute[0].second;
				hParent = InsertItemEx(&nodeData,TVI_ROOT,TVI_LAST);
				hPar = hParent;
				bFirst = FALSE;
			}
			else
			{
				bDelete = TRUE;
			}

			MSXML2::IXMLDOMNodeListPtr pXMLDOMNodeList = NULL;
			pCurXMLDOMNodePtr->get_childNodes( &pXMLDOMNodeList);
			CXMLNodeInfoEx*pData = (CXMLNodeInfoEx*)GetItemData(hPar);
			CString strPath = _T("");
			if (pData)
			{
				strPath=pData->m_strNodeXPath;
			}
			/*if (strPath == _T("/上华选项/自定义/快捷键/普通快捷键"))
			{
				int i=0;
			}*/
			int i = 0;
			for (i=0;i<pXMLDOMNodeList->Getlength();i++)
			{
				MSXML2::IXMLDOMNodePtr pXMLDOMNode = pXMLDOMNodeList->Getitem(i);
				CString strNodeName;
				CXMLNodeInfoEx xmlInfo;
				xmlInfo = GetNodeInfoEx(pXMLDOMNode);
				CString strTemName = xmlInfo.m_aryNodeAttribute[0].second;
#if ADS>16
if ((!strTemName.CompareNoCase(_T("启用选择预览")))
	||(!strTemName.CompareNoCase(_T("虚拟漫游距离步长")))
	||(!strTemName.CompareNoCase(_T("角度步长"))))
{
	continue;
}
#endif
				// add by lgh 20101105
				// 不读该项数据，但是XML保留该项纪录。
				if (strTemName.CompareNoCase(_T("阳台按一半面积计算")) == 0)
				{ 
					continue;
				}
				quene.push_back(pXMLDOMNode);
				xmlInfo.m_strNodeXPath = strPath+_T("/")+xmlInfo.m_aryNodeAttribute[0].second;
				HTREEITEM hItem =InsertItemEx(&xmlInfo,hPar,TVI_LAST);
				if (xmlInfo.m_aryNodeAttribute[0].second==m_strPageName)
				{
					m_hItem = hItem;
				}
				Treequeue.push_back(hItem);
			}
			if (pXMLDOMNodeList!=NULL)
			{
				pXMLDOMNodeList.Release();
				pXMLDOMNodeList = NULL;
			}
		}
		if (bDelete)
		{
			if (pCurXMLDOMNodePtr !=NULL)
			{
				pCurXMLDOMNodePtr.Release();
				pCurXMLDOMNodePtr = NULL;
			}
		}
	}
}
HTREEITEM CImportXMLTreeCtrl::InsertItemEx(CXMLNodeInfoEx *pNodeInfo, HTREEITEM hParent, HTREEITEM hInsertAfter)
{
	if (pNodeInfo->m_aryNodeAttribute.GetLength()==0)return 0;
	CString strName = pNodeInfo->m_aryNodeAttribute[0].second;
	HTREEITEM hItem;
	if (pNodeInfo->m_strNodeName == _T("目录"))
	{
		hItem = InsertItem(strName,0,0,hParent,hInsertAfter);
	}
	else
	{
		hItem = InsertItem(strName,1,1,hParent,hInsertAfter);
	}
	CXMLNodeInfoEx *pNodeData = new CXMLNodeInfoEx(*pNodeInfo);
	// Zyu modify on 100722，支持64位
	//SetItemData(hItem,(DWORD)pNodeData);
	SetItemData(hItem,(DWORD_PTR)pNodeData);
	return hItem;
}

void CImportXMLTreeCtrl::DeleteItemEx(HTREEITEM hItem)
{
	if (hItem==NULL||hItem ==TVI_ROOT)
	{
		return;
	}
	HTREEITEM hChild = GetChildItem(hItem);
	while(hChild != NULL)
	{
		DeleteItemEx(hChild);
		hChild = GetNextSiblingItem(hChild);
	}
	CXMLNodeInfo *pNodeData = (CXMLNodeInfo*)GetItemData(hItem);
	if (pNodeData!=NULL)
	{
		delete pNodeData;
	}
	DeleteItem(hItem);
}
void CImportXMLTreeCtrl::DeleteAllItemData(HTREEITEM hItem)
{
	hItem = GetChildItem(hItem);
	while(hItem != NULL)
	{
		CXMLNodeInfoEx *pData = (CXMLNodeInfoEx*)GetItemData(hItem);
		delete pData;
		DeleteAllItemData(hItem);
		hItem = GetNextSiblingItem(hItem);
	}
}

void CImportXMLTreeCtrl::SetXMLDoc(CXMLDOMFile*pXMLDoc)
{
	m_pXMLDoc = pXMLDoc;
}

void CImportXMLTreeCtrl::SetCurPageName(const CString& strName)
{
	m_strPageName = strName;
}

BOOL CImportXMLTreeCtrl::SetItemState(HTREEITEM hItem, UINT nState,
								 UINT nStateMask, BOOL bSearch)
{
	BOOL bReturn=CTreeCtrl::SetItemState( hItem, nState, nStateMask );
	UINT iState = nState >> 12;
	if (iState!=0)
	{
		if (bSearch) TravelChild(hItem, iState);
			TravelSiblingAndParent(hItem,iState);
	}
	return bReturn;
}

void CImportXMLTreeCtrl::OnLButtonDown(UINT nFlags, CPoint point)
{
	HTREEITEM hItem =HitTest(point, &m_uFlags);
	if ((m_uFlags&TVHT_ONITEMSTATEICON))
	{
		//nState: 0->无选择钮 1->没有选择 2->部分选择 3->全部选择
		UINT nState = GetItemState( hItem, TVIS_STATEIMAGEMASK ) >> 12;
		nState=(nState==3)?1:3;
		SetItemState(hItem,INDEXTOSTATEIMAGEMASK(nState),TVIS_STATEIMAGEMASK);
	}
	CTreeCtrl::OnLButtonDown(nFlags, point);
}

void CImportXMLTreeCtrl::OnStateIconClick(NMHDR* pNMHDR, LRESULT* pResult)
{
	if (m_uFlags&TVHT_ONITEMSTATEICON) *pResult=1;
	else *pResult = 0;
	if (*pResult==0)
	{
		LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
		if (pNMTreeView->itemNew.hItem!=NULL)
		{
			SelectItem(pNMTreeView->itemNew.hItem);
		}
	}
}

void CImportXMLTreeCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	//处理空格键
	if (nChar==0x20)
	{
		HTREEITEM hItem =GetSelectedItem();
		UINT nState = GetItemState( hItem, TVIS_STATEIMAGEMASK ) >> 12;
		if (nState!=0)
		{
			nState=(nState==3)?1:3;
			SetItemState( hItem, INDEXTOSTATEIMAGEMASK(nState),
						TVIS_STATEIMAGEMASK );
		}
	 }
	 else CTreeCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
}

void CImportXMLTreeCtrl::TravelChild(HTREEITEM hItem, int nState)
{
	HTREEITEM hChildItem,hBrotherItem;
	//查找子节点，没有就结束
	hChildItem=GetChildItem(hItem);
	if (hChildItem!=NULL)
	{
		//设置子节点的状态与当前节点的状态一致
		CTreeCtrl::SetItemState(hChildItem,INDEXTOSTATEIMAGEMASK(nState),TVIS_STATEIMAGEMASK );
		//再递归处理子节点的子节点和兄弟节点
		TravelChild(hChildItem, nState);
		//处理子节点的兄弟节点和其子节点
		hBrotherItem=GetNextSiblingItem(hChildItem);
		while (hBrotherItem)
		{
			//设置子节点的兄弟节点状态与当前节点的状态一致
			int nState1 = GetItemState( hBrotherItem, TVIS_STATEIMAGEMASK ) >> 12;
			if (nState1!=0)
			{
				CTreeCtrl::SetItemState( hBrotherItem,
					INDEXTOSTATEIMAGEMASK(nState),TVIS_STATEIMAGEMASK );
			}
			//再递归处理子节点的兄弟节点的子节点和兄弟节点
			TravelChild(hBrotherItem, nState);
			hBrotherItem=GetNextSiblingItem(hBrotherItem);
		}
	}
}
void CImportXMLTreeCtrl::TravelSiblingAndParent(HTREEITEM hItem, int nState)
{
	HTREEITEM hNextSiblingItem,hPrevSiblingItem,hParentItem;
	//查找父节点，没有就结束
	hParentItem=GetParentItem(hItem);
	if (hParentItem!=NULL)
	{
		int nState1=nState;//设初始值，防止没有兄弟节点时出错
		//查找当前节点下面的兄弟节点的状态
		hNextSiblingItem=GetNextSiblingItem(hItem);
		while(hNextSiblingItem!=NULL)
		{
			nState1 = GetItemState( hNextSiblingItem, TVIS_STATEIMAGEMASK ) >> 12;
			if (nState1!=nState && nState1!=0) break;
			else hNextSiblingItem=GetNextSiblingItem(hNextSiblingItem);
		}
		if (nState1==nState)
		{
			//查找当前节点上面的兄弟节点的状态
			hPrevSiblingItem=GetPrevSiblingItem(hItem);
			while(hPrevSiblingItem!=NULL)
			{
				nState1 = GetItemState(hPrevSiblingItem,TVIS_STATEIMAGEMASK)>> 12;
				if (nState1!=nState && nState1!=0) break;
				else hPrevSiblingItem=GetPrevSiblingItem(hPrevSiblingItem);
			}
		}
		if (nState1==nState || nState1==0)
		{
			nState1 = GetItemState( hParentItem, TVIS_STATEIMAGEMASK ) >> 12;
			if (nState1!=0)
			{
				//如果状态一致，则父节点的状态与当前节点的状态一致
				CTreeCtrl::SetItemState( hParentItem,
					INDEXTOSTATEIMAGEMASK(nState), TVIS_STATEIMAGEMASK );
			}
			//再递归处理父节点的兄弟节点和其父节点
			TravelSiblingAndParent(hParentItem,nState);
		}
		else
		{
			//状态不一致，则当前节点的父节点、父节点的父节点……状态均为第三态
			hParentItem=GetParentItem(hItem);
			while(hParentItem!=NULL)
			{
				nState1 = GetItemState( hParentItem, TVIS_STATEIMAGEMASK ) >> 12;
				if (nState1!=0)
				{
					CTreeCtrl::SetItemState( hParentItem,INDEXTOSTATEIMAGEMASK(2), TVIS_STATEIMAGEMASK );
				}
				hParentItem=GetParentItem(hParentItem);
			}
		}
	}
}
CXMLNodeInfoEx CImportXMLTreeCtrl::GetNodeInfoEx(const MSXML2::IXMLDOMNodePtr &pIXMLDOMNodePtr)
{
	CXMLNodeInfoEx TemInfo;
	TemInfo.m_bLeafNode = IsHasChildNodes(pIXMLDOMNodePtr);
	TemInfo.m_strNodeName = GetXMLNodeName(pIXMLDOMNodePtr);
	TemInfo.m_strNodeValue = GetXMLNodeValue(pIXMLDOMNodePtr);
	long nLen =GetXMLNodeAttriNum(pIXMLDOMNodePtr);
	if (nLen>0)
	{
		int i =0;
		for (;i<nLen;i++)
		{
			CString strAttriName = GetXMLNodeAttributeName(pIXMLDOMNodePtr,i);
			CString strAttri = GetXMLNodeAttributeValue(pIXMLDOMNodePtr,strAttriName);
			NodeAttriBute nodeAttri;
			nodeAttri.first = strAttriName;
			nodeAttri.second = strAttri;
			TemInfo.m_aryNodeAttribute.AddTail(nodeAttri);
		}
	}
	return TemInfo;
}
//得到xml节点值(仅对叶子节点)
CString  CImportXMLTreeCtrl::GetXMLNodeValue(const MSXML2::IXMLDOMNodePtr &pIXMLDOMNodePtr)
{
	assert( NULL != pIXMLDOMNodePtr );
	if ( NULL == pIXMLDOMNodePtr )
	{
		return _T("");
	}
	if (IsHasChildNodes(pIXMLDOMNodePtr))
	{
		return _T("");
	}
	BSTR bstr = NULL;
	HRESULT hr ;
	try
	{
		hr = pIXMLDOMNodePtr->get_text( &bstr );
		assert( SUCCEEDED(hr) );
		if ( FAILED ( hr ) )
		{
			return _T("");
		}	
	}
	catch( ... )
	{
		if ( NULL != bstr )
		{
			SysFreeString( bstr );
			bstr = NULL;
		}

		assert( false );
		return _T("");
	}

	TCHAR szGetValue[4096];
	memset( szGetValue, 0, sizeof( szGetValue ) );
	_tcscpy( szGetValue, ( TCHAR* )_bstr_t( bstr, true ) );
	CString strNodeValue;
	strNodeValue = szGetValue;
	if ( NULL != bstr )
	{
		SysFreeString( bstr );
		bstr = NULL;
	}
	return strNodeValue;
}
//得到xml节点属性值
CString CImportXMLTreeCtrl::GetXMLNodeAttributeValue(const MSXML2::IXMLDOMNodePtr &pIXMLDOMNodePtr,const CString strNodeAttriName)
{
	assert( NULL != pIXMLDOMNodePtr );
	if ( NULL == pIXMLDOMNodePtr )
	{
		return _T("");
	}

	MSXML2::IXMLDOMNamedNodeMapPtr pIXMLDOMNamedNodeMap = NULL;
	MSXML2::IXMLDOMNodePtr pIXMLDOMNode = NULL;
	VARIANT varTextValue;
	HRESULT hr;
	try
	{
		hr = pIXMLDOMNodePtr->get_attributes( &pIXMLDOMNamedNodeMap );
		assert( SUCCEEDED(hr) );
		if ( FAILED( hr ) )
		{
			return  _T("");
		}
		pIXMLDOMNode = pIXMLDOMNamedNodeMap->getNamedItem( _bstr_t(strNodeAttriName));
		hr = pIXMLDOMNode->get_nodeValue( &varTextValue );
		assert( SUCCEEDED( hr ) );
		if ( FAILED( hr ) )
		{
			return  _T("");
		}
	}
	catch ( ... )
	{
		if ( NULL != pIXMLDOMNode )
		{
			pIXMLDOMNode.Release();
			pIXMLDOMNode = NULL;
		}
		if ( NULL != pIXMLDOMNamedNodeMap )
		{
			pIXMLDOMNamedNodeMap.Release();
			pIXMLDOMNamedNodeMap = NULL;
		}
		assert( false );
		return  _T("");
	}
	//TCHAR szGetAttributeValue[1024];
	//memset( szGetAttributeValue, 0, sizeof( szGetAttributeValue ) );
	//_tcscpy( szGetAttributeValue, ( TCHAR* )(_bstr_t)varTextValue );
	CString strAttributeValue;
	strAttributeValue = (TCHAR*)(_bstr_t)varTextValue;
	if ( NULL != pIXMLDOMNode )
	{
		pIXMLDOMNode.Release();
		pIXMLDOMNode = NULL;
	}
	if ( NULL != pIXMLDOMNamedNodeMap )
	{
		pIXMLDOMNamedNodeMap.Release();
		pIXMLDOMNamedNodeMap = NULL;
	}
	return strAttributeValue;
}
CString CImportXMLTreeCtrl::GetXMLNodeName(const MSXML2::IXMLDOMNodePtr &pIXMLDOMNodePtr)
{
	BSTR bstr = NULL;
	pIXMLDOMNodePtr->get_nodeName( &bstr );
	TCHAR szGetName[MAX_PATH];
	memset( szGetName, 0, sizeof( szGetName ) );
	_tcscpy( szGetName, (TCHAR*)(_bstr_t)( bstr ) );
	CString strNodeName = szGetName;
	return strNodeName;
}
//得到xml节点属性名字
CString CImportXMLTreeCtrl::GetXMLNodeAttributeName(const MSXML2::IXMLDOMNodePtr &pIXMLDOMNodePtr,int nIndex)
{
	//int nIndex =0;
	assert( NULL != pIXMLDOMNodePtr );
	if ( NULL == pIXMLDOMNodePtr )
	{
		return _T("");
	}

	TCHAR szGetAttrName[MAX_PATH];
	memset( szGetAttrName, 0, sizeof( szGetAttrName ) );
	MSXML2::IXMLDOMNamedNodeMapPtr	pXMLDOMNamedNodeMap = NULL;
	MSXML2::IXMLDOMAttributePtr		pXMLDOMAttribute = NULL;
	try
	{
		pXMLDOMNamedNodeMap = pIXMLDOMNodePtr->Getattributes();
		assert( NULL != pXMLDOMNamedNodeMap );
		if ( NULL == pXMLDOMNamedNodeMap ){ return _T(""); }
		assert( nIndex < pXMLDOMNamedNodeMap->length );
		if ( nIndex >= pXMLDOMNamedNodeMap->length ){ return _T(""); }
		pXMLDOMAttribute = pXMLDOMNamedNodeMap->item[ nIndex ];
		ASSERT( NULL != pXMLDOMAttribute );
	}
	catch ( ... )
	{
		if ( NULL != pXMLDOMNamedNodeMap )
		{
			pXMLDOMNamedNodeMap.Release();
			pXMLDOMNamedNodeMap = NULL;
		}
		if ( NULL != pXMLDOMAttribute )
		{
			pXMLDOMAttribute.Release();
			pXMLDOMAttribute = NULL;
		}
		assert( false );
		return _T("");
	}

	_tcscpy( szGetAttrName, ( TCHAR * )( _bstr_t )pXMLDOMAttribute->Getname() );
	if ( NULL != pXMLDOMNamedNodeMap )
	{
		pXMLDOMNamedNodeMap.Release();
		pXMLDOMNamedNodeMap = NULL;
	}
	if ( NULL != pXMLDOMAttribute )
	{
		pXMLDOMAttribute.Release();
		pXMLDOMAttribute = NULL;
	}
	CString strAttriname = szGetAttrName;
	return strAttriname;
}

long CImportXMLTreeCtrl::GetXMLNodeAttriNum(const MSXML2::IXMLDOMNodePtr &pIXMLDOMNodePtr)
{
	long nNum = 0;
	assert( NULL != pIXMLDOMNodePtr );
	if ( NULL == pIXMLDOMNodePtr )
	{
		return 0;
	}
	MSXML2::IXMLDOMNamedNodeMapPtr	pXMLDOMNamedNodeMap = NULL;
	MSXML2::IXMLDOMAttributePtr		pXMLDOMAttribute = NULL;
	try
	{
		pXMLDOMNamedNodeMap = pIXMLDOMNodePtr->Getattributes();
		assert( NULL != pXMLDOMNamedNodeMap );
		if ( NULL == pXMLDOMNamedNodeMap ){ return 0; }
		nNum = pXMLDOMNamedNodeMap->length;
	}
	catch ( ... )
	{
		if ( NULL != pXMLDOMNamedNodeMap )
		{
			pXMLDOMNamedNodeMap.Release();
			pXMLDOMNamedNodeMap = NULL;
		}
		if ( NULL != pXMLDOMAttribute )
		{
			pXMLDOMAttribute.Release();
			pXMLDOMAttribute = NULL;
		}
		return 0;
	}
	if ( NULL != pXMLDOMNamedNodeMap )
	{
		pXMLDOMNamedNodeMap.Release();
		pXMLDOMNamedNodeMap = NULL;
	}
	if ( NULL != pXMLDOMAttribute )
	{
		pXMLDOMAttribute.Release();
		pXMLDOMAttribute = NULL;
	}
	return nNum;
}
void CImportXMLTreeCtrl::GetListCtrlIndex(const CXMLNodeInfoEx &data,CStringArray &arystr)
{
	CString strPath = data.m_strNodeXPath;
	CString strTem;
	int nPos = strPath.Find(_T("/"),1);
	int nStart = 1;
	while (nPos!=-1)
	{
		int nNum = nPos-nStart;
		strTem = strPath.Mid(nStart,nNum);
		arystr.Add(strTem);
		nStart = nPos+1;
		nPos = strPath.Find(_T("/"),nPos+1);
	}
	int nSize = strPath.GetLength();
	if (nStart-1<nSize-1)
	{
		strTem = strPath.Mid(nStart,nSize-nStart);
		arystr.Add(strTem);
	}
}
//深度遍历一棵树
void CImportXMLTreeCtrl::GetCheckedItemData(HTREEITEM hItem)
{
	CXMLNodeInfoEx *pData = (CXMLNodeInfoEx*)GetItemData(hItem);
	if (GetCheck(hItem))//为设置值并且被选中时加入map中
	{
		if (pData->m_strNodeName ==_T("选项"))
		{
			CStringArray arystr;
			GetListCtrlIndex(*pData,arystr);//区分要导入的选项属于哪个对话框
			if (arystr.GetSize()>=2)
			{
				CString strName = arystr.GetAt(1);
				if (strName == _T("图形设置"))//图形设置包含两个界面
				{
					if (arystr.GetSize()>=3)
					{
						CString strSubName = arystr.GetAt(2);
						std::map<CString,NodeInfoAry>::iterator iter;
						iter = m_mapData.find(strSubName);
						if (iter!=m_mapData.end())
						{
							m_mapData[strSubName].AddTail(*pData);
						}
						else
						{
							NodeInfoAry nodeInfoAry;
							nodeInfoAry.AddTail(*pData);
							m_mapData.insert(std::map<CString,NodeInfoAry>::value_type(strSubName,nodeInfoAry));
						}
					}
				}
				else if (strName == _T("自定义"))//自定义对话框包含四个二级sheet页面
				{
					if (arystr.GetSize()>=3)
					{
						CString strSubName = arystr.GetAt(2);
						std::map<CString,NodeInfoAry>::iterator iter;
						iter = m_mapData.find(strSubName);
						if (iter!=m_mapData.end())
						{
							m_mapData[strSubName].AddTail(*pData);
						}
						else
						{
							NodeInfoAry nodeInfoAry;
							nodeInfoAry.AddTail(*pData);
							m_mapData.insert(std::map<CString,NodeInfoAry>::value_type(strSubName,nodeInfoAry));
						}
					}
				}
				else if (strName == _T("高级选项"))//高级选项界面
				{
					std::map<CString,NodeInfoAry>::iterator iter;
					iter = m_mapData.find(strName);
					if (iter!=m_mapData.end())
					{
						m_mapData[strName].AddTail(*pData);
					}
					else
					{
						NodeInfoAry nodeInfoAry;
						nodeInfoAry.AddTail(*pData);
						m_mapData.insert(std::map<CString,NodeInfoAry>::value_type(strName,nodeInfoAry));
					}
				}
			}
		}
	}
	HTREEITEM hSiblingItem = GetNextSiblingItem(hItem);// 得到当前节点兄弟节点
	if (ItemHasChildren(hItem))
	{
		hSiblingItem=GetChildItem(hItem);    
		GetCheckedItemData(hSiblingItem);
	}
	if (GetNextSiblingItem(hItem))
	{
		hSiblingItem=GetNextSiblingItem(hItem);
		GetCheckedItemData(hSiblingItem);
	}

}