// InsTextDlg.cpp : implementation file
//
#include "stdafx.h"

#include "InsTextDlg.h"
#include "xtext.h"
#include "TgAs.h"

#define IDC_TEMP	1000
#define IDR_NEW		1001
#define IDR_INS		1002
#define IDR_DEL		1003
#define IDR_MOD		1004
#define VK_N		0x4e
const TCHAR *c_szLate = {_T("最近使用的词")};
const TCHAR *c_szAll = {_T("全部词汇")};
const TCHAR *c_szName = _T("name");
const TCHAR *c_szCatalog = _T("目录");
const TCHAR *c_szLemma = _T("词条");
const TCHAR *c_szTDWord = _T("上华词库");
static CString m_szType = c_szLate;
static CString m_szName = _T("");
static CXMLNodeInfo g_xmlListLastInfo;
static CXMLNodeInfo g_xmlTreeLastInfo;
static BOOL g_bSort = FALSE;
////////////////////////////////
#define ID_INS_DRAWING		1
#define ID_DEL_DRAWING		2
#define ID_OPEN_DRAWING		3

#define ID_ADD_DRAWING		4
#define ID_NEW_COLLECT		5
#define ID_DEL_COLLECT		6
#define ID_REN_COLLECT		7
#define ID_EXPAND_COLLECT	8
#define ID_COLLAPSE_COLLECT	9

#define ID_ADD_CHILD_COLLECT 10
#define ID_ADD_CHILD_LEMMA   11
#define ID_EXPAND_WORKS		 12
#define ID_COLLAPSE_WORKS	 13

#define IDC_PROJECT_COMBO	14
#define ID_CUR_PROJECT		15
#define ID_NEW_PROJECT		16
#define ID_OPEN_PROJECT		17
#define ID_SET_PROJECT		18 
#define ID_RECENT_PROJECT	19
#define ID_IMPORT_FLOOR     20
#define ID_EXPORT_FLOOR     21
#define ID_SAVE_PROJECT     22
#define ID_RECENT1			23
#define ID_RECENT2			24
#define ID_RECENT3			25
#define ID_RECENT4			26
#define ID_RECENT5			27
#define ID_RECENT6			28
#define ID_RECENT7			29
#define ID_RECENT8			30

#define RECENT_MAX_NUM 8

// add by xly On 101213 设置文字对象的图层切换属性
extern TARCH_IMPEXP BOOL g_bTextDefaultLayer;

Adesk::Boolean acedPostCommand(const TCHAR * );
////////////////////////////////////////////////////
// CEditForListBox
CEditForListBox::CEditForListBox()
{
	m_pItemData = NULL;
}

CEditForListBox::~CEditForListBox()
{
}

void CEditForListBox::PostNcDestroy()
{
	delete this;
}

BOOL CEditForListBox::PreTranslateMessage(MSG *pMsg)
{
	BOOL bRet=CEdit::PreTranslateMessage(pMsg);
	if(pMsg->message == WM_KEYDOWN)
	{
		if(pMsg->wParam == VK_RETURN)
		{
			GetParent()->SetFocus();
			return TRUE;
		}
	}
	return bRet;
}

BEGIN_MESSAGE_MAP(CEditForListBox, CEdit)
	ON_WM_KILLFOCUS()
END_MESSAGE_MAP()

void CEditForListBox::OnKillFocus(CWnd* pNewWnd)
{
	CEdit::OnKillFocus(pNewWnd);

	CString szOld, szNew;
	GetWindowText(szNew);
	
	CExtendListBox *pListBox = (CExtendListBox *)GetParent();
	int iCurSel = pListBox->GetCurSel();
	pListBox->GetText(iCurSel, szOld);
	void *dataPtr = pListBox->GetItemDataPtr(iCurSel);
	int iRet = pListBox->FindStringExact(-1, szNew);
	if(iRet == LB_ERR)//新名称未用
	{
		if(szNew==_T(""))//不发生变化
			MessageBox(_T("名称不能为空!"));
		else if(UString(szNew).Length()>25)
			MessageBox(_T("名称最长为25个字符！"));
		else
		{
			int iPos;
			if(m_pItemData!=NULL)
			{
				iPos = m_pItemData->lstNames.FindData(CNameString(szOld));
				CString& szNameString=m_pItemData->lstNames(iPos);
				szNameString=szNew;
			}
			pListBox->DeleteString(iCurSel);
			pListBox->InsertString(iCurSel, szNew);
			pListBox->SetItemDataPtr(iCurSel, dataPtr);
			iCurSel = pListBox->FindStringExact(-1, szNew);
			if(iCurSel>=0&&iCurSel<pListBox->GetCount())
				pListBox->SetCurSel(iCurSel);
		}
	}
	else//新名称被占用
	{
		if(iRet!=iCurSel)//不发生变化
			MessageBox(CString(_T("<"))+szNew+_T(">项已经存在!"));;
	}
	DestroyWindow();
}

void CEditForListBox::SetExtentData(CListBoxItemData *&pItemData)
{
	m_pItemData = pItemData;
}

//////////////////////////////////////////////////////////////////
// CExtendListBox
IMPLEMENT_DYNAMIC(CExtendListBox, CDragListBox)
CExtendListBox::CExtendListBox(int iFlag)
{
	m_iFlag = iFlag;
	m_bModified = TRUE;
	m_pItemData = NULL;
}

CExtendListBox::~CExtendListBox()
{
}
CString CExtendListBox::CreateNewName()
{
	CString sName=_T("新名称");
	long count=1;
	for(long i=0;i<GetCount();i++)
	{
		CString temp;
		GetText(i,temp);
		if(temp.Find(sName)>=0)
		{
			sName.Format(_T("新名称%d"),count++);
			i=-1;
		}
	}
	return sName;
}
BEGIN_MESSAGE_MAP(CExtendListBox, CDragListBox)
	ON_WM_KEYDOWN()
	ON_WM_RBUTTONDOWN()
	ON_WM_LBUTTONDOWN()
	ON_COMMAND_RANGE(IDR_NEW, IDR_MOD, OnMenuCommand)
END_MESSAGE_MAP()

void CExtendListBox::OnLButtonDown(UINT nFlags,CPoint point)
{
	CDragListBox::OnLButtonDown(nFlags,point);
}
// CExtendListBox 消息处理程序
void CExtendListBox::OnRButtonDown(UINT nFlags, CPoint point)
{
	if(point.x<1||point.y<=1)
		return;

	SetFocus();
	CDragListBox::OnRButtonDown(nFlags, point);
	if(!m_bModified)
		return;
	BOOL bOutSide;
	int iHit = ItemFromPoint(point, bOutSide);
	if(!bOutSide)
		SetCurSel(iHit);
	int iCurSel = GetCurSel();

	CMenu popup;
	popup.CreatePopupMenu();
	if(m_iFlag == 0)
	{
		popup.AppendMenu(MF_STRING, IDR_NEW, _T("新建类别(N)"));
		CString szText;
		GetText(iCurSel, szText);
		if(iHit != -1 && _tcscmp(szText, c_szAll) != 0 && _tcscmp(szText, c_szLate) != 0)
		{
			popup.AppendMenu(MF_STRING, IDR_INS, _T("插入类别(Ins)"));
			popup.AppendMenu(MF_STRING, IDR_DEL, _T("删除类别(Del)"));
			popup.AppendMenu(MF_STRING, IDR_MOD, _T("重命名(F2)"));
		}
	}
	else
	{
		popup.AppendMenu(MF_STRING, IDR_NEW, _T("新建行(N)"));
		if(iCurSel != -1)
		{
			popup.AppendMenu(MF_STRING, IDR_INS, _T("插入行(Ins)"));
			popup.AppendMenu(MF_STRING, IDR_DEL, _T("删除行(Del)"));
			popup.AppendMenu(MF_STRING, IDR_MOD, _T("重命名(F2)"));
		}
	}
	ClientToScreen(&point);
	popup.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this);
}

void CExtendListBox::OnMenuCommand(UINT id)
{
	switch(id)
	{
	case IDR_INS:
		DoInsertItem();
		break;
	case IDR_NEW:
		DoAppendItem();
		break;
	case IDR_DEL:
		DoDeleteItem();
		break;
	case IDR_MOD:
		DoModifyItem();
		break;
	}
}

void CExtendListBox::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	CDragListBox::OnKeyDown(nChar, nRepCnt, nFlags);
	if(!m_bModified)
		return;

	BOOL bPop = FALSE;
	int iCurSel = GetCurSel();
	if(iCurSel == -1)
		bPop = TRUE;
	else
	{
		if(m_iFlag == 0)
		{
			CString szText;
			GetText(iCurSel, szText);
			if(_tcscmp(szText, c_szAll) == 0 || _tcscmp(szText, c_szLate) == 0)
				bPop = TRUE;
		}
	}

	if(bPop)
	{
		if(nChar == VK_N)
			DoAppendItem();
	}
	else
	{
		if(nChar == VK_DELETE)
			DoDeleteItem();
		else if(nChar == VK_INSERT)
			DoInsertItem();
		else if(nChar == VK_N)
			DoAppendItem();
		else if(nChar == VK_F2)
			DoModifyItem();
	}
}

void CExtendListBox::CreateEdit()
{
	int iCurSel = GetCurSel();
	CRect rect;
	GetItemRect(iCurSel, rect);
	rect.bottom += 2;
	rect.top -= 2;
	int iStyle = WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | ES_WANTRETURN;

 	CTemporaryResourceOverride vTmp;
	CEditForListBox *pEdit = new CEditForListBox;
	if(!pEdit->Create(iStyle, rect, this, IDC_TEMP))
		return;

	CString szOld;
	GetText(iCurSel, szOld);
	pEdit->SetFont(GetFont());
	pEdit->SetWindowText(szOld);
	pEdit->SetFocus();
	pEdit->SetSel(0, -1);
	if(m_iFlag != 0)
		pEdit->SetExtentData(m_pItemData);
}

void CExtendListBox::DoDeleteItem()
{
	int iCurSel = GetCurSel();
	if(m_iFlag == 0)
	{
		if(MessageBox(_T("这将删除该类别下所有文字，是否删除？"), _T("提示"), MB_OKCANCEL|MB_ICONQUESTION) != IDOK) 
			return;
		CListBoxItemData *pItemData = (CListBoxItemData *)GetItemDataPtr(iCurSel);
		if(pItemData==0)
			delete pItemData;
	}
	else
	{
		if(m_pItemData != NULL)
		{
			CString szText;
			GetText(iCurSel, szText);
			m_pItemData->lstNames.FindDataAndDel(CNameString(szText));
		}
	}
	DeleteString(iCurSel);
	int iCount = GetCount();
	if(iCurSel >= iCount)
		iCurSel = iCount - 1;
	SetCurSel(iCurSel);
}

void CExtendListBox::DoInsertItem()
{
	int iCurSel = GetCurSel();
	CString sNewName= CreateNewName();
	if(m_iFlag == 0)
	{
		InsertString(iCurSel,sNewName);
		CListBoxItemData *pItemData = new CListBoxItemData;
		SetItemDataPtr(iCurSel, pItemData);
	}
	else
	{
		if(m_pItemData!= NULL)
		{
			CString szText;
			GetText(iCurSel, szText);
			int iPos = m_pItemData->lstNames.FindData(CNameString(szText));
			m_pItemData->lstNames.Insert(iPos, new CNameString(sNewName));
			InsertString(iCurSel, sNewName);
		}
	}
	int iCount = GetCount();
	if(iCurSel >= iCount)
		iCurSel = iCount - 1;
	SetCurSel(iCurSel);
	CreateEdit();
}

void CExtendListBox::DoAppendItem()
{
	int iCurSel = GetCount();
	CString sNewName= CreateNewName();
	InsertString(iCurSel,sNewName);
	if(m_iFlag == 0)
	{
		CListBoxItemData *pItemData = new CListBoxItemData;
		SetItemDataPtr(iCurSel, pItemData);
	}
	else
	{
		if(m_pItemData!=NULL)
			m_pItemData->lstNames.Insert(iCurSel, new CNameString(sNewName));
	}
	SetCurSel(iCurSel);
	CreateEdit();
}

void CExtendListBox::DoModifyItem()
{
	CreateEdit();
}

void CExtendListBox::SetModify(BOOL bModified)
{
	m_bModified = bModified;
}

BOOL CExtendListBox::GetModify()
{
	return m_bModified;
}

void CExtendListBox::SetExtendData(CListBoxItemData *&pItemData)
{
	if(m_iFlag != 0)
		m_pItemData = pItemData;
}

int CExtendListBox::SetCurSel(int nSelect)
{
	int nRet = CDragListBox::SetCurSel(nSelect);
	if(m_iFlag == 0)
		((CInsTextDlg*)GetParent())->OnLbnSelchangeDragType();
	else
		((CInsTextDlg*)GetParent())->OnLbnSelchangeName();
	return nRet;
}

void CExtendListBox::PreSubclassWindow()
{
	if(m_iFlag!=2)
		CDragListBox::PreSubclassWindow();
	else
		CListBox::PreSubclassWindow();
}

BOOL CExtendListBox::OnChildNotify(UINT nMessage, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	if(m_iFlag != 2 && m_bModified)
		return CDragListBox::OnChildNotify(nMessage, wParam, lParam, pResult);
	else
		return CListBox::OnChildNotify(nMessage, wParam, lParam, pResult);
}
//add by whl
CNameString* CExtendListBox::FindNameString(CString szName)
{
	if(m_pItemData==NULL)
		return NULL;
	long iPos=m_pItemData->lstNames.FindData(CNameString(szName));
	return iPos==NOT_FOUND?NULL:m_pItemData->lstNames[iPos];
}
void CExtendListBox::Dropped(int nSrcIndex,CPoint pt)
{
	CDragListBox::Dropped(nSrcIndex,pt);
	if(nSrcIndex!=-1&&m_pItemData!=NULL)
	{
		int nDestIndex = ItemFromPt(pt);
		if (nDestIndex != -1)
			m_pItemData->lstNames.Move(nSrcIndex,nDestIndex);
	}
}
///////////////////////////////////////////////////////////////////
// CInsTextDlg 对话框
IMPLEMENT_DYNAMIC(CInsTextDlg, CModelessDialog)
CInsTextDlg::CInsTextDlg(CWnd* pParent /*=NULL*/)
	: CModelessDialog(CInsTextDlg::IDD, pParent)
	, m_dragNames(1)
	, m_sortNames(2),m_bSingleLineText(FALSE)
{
	m_bEditChanged = FALSE;
}

CInsTextDlg::CInsTextDlg(UINT IDD, CWnd* pParent /*=NULL*/)
	: CModelessDialog(IDD, pParent)
	, m_dragNames(1)
	, m_sortNames(2),m_bSingleLineText(FALSE)
{
	m_bEditChanged = FALSE;
}

CInsTextDlg::~CInsTextDlg()
{
	//对话框销毁时对文档进行保存关闭
	if (m_pXMlDoc)
	{
		m_pXMlDoc->Save();
		delete m_pXMlDoc;
	}
}

void CInsTextDlg::DoDataExchange(CDataExchange* pDX)
{
	CModelessDialog::DoDataExchange(pDX);
	//	DDX_Control(pDX, IDC_DRAG_TYPE, m_dragTypes);
	DDX_Control(pDX, IDC_DRAG_NAME, m_dragNames);
	DDX_Control(pDX, IDC_SORT_NAME, m_sortNames);
	DDX_Control(pDX, IDC_EDIT_SEARCH, m_editSearch);
	DDX_Control(pDX, IDC_ADDTOLIB, m_buttonAdd);
	DDX_Control(pDX,IDC_INPUTTOLIB,m_buttonInput);
	DDX_Control(pDX, IDC_TREE, m_treeNames);
}

BEGIN_MESSAGE_MAP(CInsTextDlg, CModelessDialog)
//	ON_LBN_SELCHANGE(IDC_DRAG_TYPE, OnLbnSelchangeDragType)
	ON_LBN_SELCHANGE(IDC_DRAG_NAME, OnLbnSelchangeName)
	ON_LBN_SELCHANGE(IDC_SORT_NAME, OnLbnSelchangeName)
	ON_EN_CHANGE(IDC_EDIT_SEARCH, OnEnChangeEditSearch)
	ON_LBN_DBLCLK(IDC_DRAG_NAME, OnLbnDblclkListName)
	ON_LBN_DBLCLK(IDC_SORT_NAME, OnLbnDblclkListName)
	ON_COMMAND_RANGE(ID_BUTTON_A, ID_BUTTON_Z, OnSelectLetter)
	ON_BN_CLICKED(IDC_ADDTOLIB, OnBnClickedAddtolib)
	ON_BN_CLICKED(IDC_INPUTTOLIB, OnBnClickedInputtolib)
	ON_WM_DESTROY()
	ON_WM_CLOSE()
	ON_WM_SIZE()
	ON_WM_NCHITTEST()
	ON_NOTIFY(TVN_SELCHANGED, IDC_TREE, OnTvnSelchangedTree)
	ON_MESSAGE(TARCH_TEXTLIB_MSG_NEW,OnNewLine)
	ON_MESSAGE(TARCH_TEXTLIB_MSG_INSERT,OnInSertLine)
	ON_MESSAGE(TARCH_TEXTLIB_MSG_RENAME,OnReNameLine)
	ON_MESSAGE(TARCH_TEXTLIB_MSG_DELETE,OnDeleteLine)
	ON_BN_CLICKED(IDC_BTN_INLIB, OnBnClickedBtnInlib)
END_MESSAGE_MAP()
#if ADS<17
UINT CInsTextDlg::OnNcHitTest(CPoint point)
#else
LRESULT CInsTextDlg::OnNcHitTest(CPoint point)
#endif
{
	// Zyu modify on 100726，去掉编译警告
	//UINT id = CModelessDialog::OnNcHitTest(point);
	UINT id = (UINT)CModelessDialog::OnNcHitTest(point);
	if(id==HTLEFT||id==HTRIGHT)
		return HTCLIENT;
	if(id==HTTOPLEFT||id==HTTOPRIGHT)
		return HTTOP;
	else if(id==HTBOTTOMLEFT||id==HTBOTTOMRIGHT)
		return HTBOTTOM;
	else
		return id;
}
void CInsTextDlg::OnClose()
{
	CModelessDialog::OnClose();
}
void CInsTextDlg::DoDeleteItem()
{	
	CArchTextLibListBox &listBox = m_bSort ? m_sortNames : m_dragNames;
	int iCurSel = listBox.GetCurSel();
	if (iCurSel<0)
	{
		return;
	}
	CXMLNodeInfo *pData = (CXMLNodeInfo*)(listBox.GetItemData(iCurSel));
	if (pData)
	{
		if (pData->m_strNodeXPath!=_T(""))
		{
			if (m_pXMlDoc)
			{
				CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
				pXMLDOMNodePtr->DeleteNode();
			}
		}
	}
	listBox.DeleteStringEx(iCurSel);
	iCurSel = iCurSel -1;
	if (iCurSel<0)
	{
		iCurSel = 0;
	}
	listBox.SetCurSel(iCurSel);
}

void CInsTextDlg::OnBnClickedInputtolib()
{
	m_editSearch.GetWindowText(m_szName);
	if(m_szName == _T(""))
	{
		return;
	}
	CString strName;
	if(m_szName.Find(_T("\n"))>=0||m_szName.Find(_T("\r"))>=0)// 多行文字
	{
		if (m_szName.Find(_T("\n"))>=0)
		{
			strName = m_szName.Mid(0,m_szName.Find(_T("\n")));
			if (strName.GetLength()>20)
			{
				strName = strName.Mid(0,20);
			}
		}
		else
		{
			if (m_szName.Find(_T("\r"))>=0)
			{
				strName = m_szName.Mid(0,m_szName.Find(_T("\n")));
				if (strName.GetLength()>20)
				{
					strName = strName.Mid(0,20);
				}
			}
		}
	}
	else
	{
		if (m_szName.GetLength()>20)
		{
			strName = m_szName.Mid(0,20);
		}
		else
		{
			strName = m_szName;
		}
	}
	CArchTextLibListBox &listBox = m_bSort ? m_sortNames : m_dragNames;
	int iCurSel = listBox.GetCurSel();
	if (iCurSel>0||iCurSel==0)
	{
		CXMLNodeInfo *pData = (CXMLNodeInfo*)(listBox.GetItemData(iCurSel));
		CString szName;
		int nCount = 1;
		if (pData&&pData->m_strNodeXPath!=_T(""))
		{
			if (m_pXMlDoc)
			{
				CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
				CXMLDOMNodePtr pFather = pXMLDOMNodePtr->GetParentNode();
				if (!m_szName.CompareNoCase(pData->m_strNodeValue))
				{
					if (pData->m_strNodeValue.GetLength()>20)
					{
						szName = pData->m_strNodeValue.Mid(0,20);
					}
					else
					{
						szName = pData->m_strNodeValue;
					} 	
				}
				else
				{
					if (pData->m_strNodeValue.GetLength()>20)
					{
						szName = pData->m_strNodeAttributeValue.Mid(0,20);
					}
					else
					{
						szName = pData->m_strNodeAttributeValue;
					}
				} 
				if (!strName.CompareNoCase(szName))
				{
					while (1)
					{
						BOOL bFlag = FALSE;
						szName.Format(_T("(%d)"), nCount);
						szName = strName+szName;
						if (pFather->HasChildNodes())
						{
							CString strNodeName = pFather->GetNodeName();
							CXMLDOMNodesPtr pXMLDOMNodeList = pFather->GetChildrenNodes(strNodeName);
							int nNum = pXMLDOMNodeList->GetCount();
							int i = 0;
							for (i = 0;i < nNum;i++)
							{
								CXMLDOMNodePtr pTem = pXMLDOMNodeList->GetItem(i);
								CString strAttriName = pTem->GetAttributeName();
								CString strAttriValue = pTem->GetAttributeValue(strAttriName);
								if (szName == strAttriValue)
								{
									bFlag = TRUE;
									nCount++;
									break;
								}
							}
						}
						if (!bFlag)
						{
							break;
						}
					}
				}
				else
				{
					szName = strName;
				}
				CXMLNodeInfo TempInfo;
				TempInfo.m_bLeafNode = TRUE;
				TempInfo.m_strNodeName = c_szLemma/*_T("词条")*/;
				TempInfo.m_strNodeAttributeName =c_szName/* _T("name")*/;
				TempInfo.m_strNodeAttributeValue = szName;
				TempInfo.m_strNodeValue = m_szName;
				CXMLDOMNodePtr pInsert = pFather->AppendNode(TempInfo.m_strNodeName,_T(""),TempInfo.m_strNodeAttributeName,
					TempInfo.m_strNodeAttributeValue);
				pInsert->SetNodeValue(m_szName);
				CXMLDOMNodePtr PClone(new CXMLDOMNode(NULL ));
				CXMLDOMNodePtr PTemptr(new CXMLDOMNode(NULL ));
				pInsert->CloneNode(PClone);
				pXMLDOMNodePtr->InsertAfter(PClone,PTemptr);
				pInsert->DeleteNode();
				m_pXMlDoc->GetCurNodeXPath(PTemptr,TempInfo.m_strNodeXPath);
				listBox.InsertStringEx(iCurSel,&TempInfo);
				int iCount = listBox.GetCount();
				if(iCurSel >= iCount)
					iCurSel = iCount - 1;
				listBox.SetCurSel(iCurSel);
				listBox.CreateEdit();
			}
		}
	}
	else
	{
		if (m_pXMlDoc)
		{
			CXMLNodeInfo xmlDocInfo;
			CXMLDOMNodePtr pInsert(new CXMLDOMNode(NULL));
			HTREEITEM hItem = m_treeNames.GetSelectedItem();
			if (hItem!=NULL)
			{
				CXMLNodeInfo *pData = (CXMLNodeInfo*)m_treeNames.GetItemData(hItem);
				if (pData&&pData->m_strNodeXPath!=_T(""))
				{
					CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
					xmlDocInfo.m_strNodeName = c_szLemma/*_T("词条")*/;
					xmlDocInfo.m_strNodeAttributeName = c_szName/*_T("name")*/;
					xmlDocInfo.m_strNodeAttributeValue = strName;
					xmlDocInfo.m_bLeafNode = TRUE;
					xmlDocInfo.m_strNodeValue = m_szName;
					pInsert=pXMLDOMNodePtr->AppendNode(xmlDocInfo.m_strNodeName,_T(""),xmlDocInfo.m_strNodeAttributeName
						,xmlDocInfo.m_strNodeAttributeValue);
					pInsert->SetNodeValue(m_szName);
					m_pXMlDoc->GetCurNodeXPath(pInsert,xmlDocInfo.m_strNodeXPath);
					//listBox.InsertStringEx(iCurSel,&xmlDocInfo);
					listBox.AddStringEx(xmlDocInfo.m_strNodeAttributeValue,&xmlDocInfo);
					int iCount = listBox.GetCount();
					iCurSel = iCount - 1;
					listBox.SetCurSel(iCurSel);
					listBox.CreateEdit();
				}
			}
		}
	}
}

void CInsTextDlg::DoInsertItem()
{
	CArchTextLibListBox &listBox = m_bSort ? m_sortNames : m_dragNames;
	int iCurSel = listBox.GetCurSel();
	if (iCurSel>0||iCurSel==0)
	{
		CXMLNodeInfo *pData = (CXMLNodeInfo*)(listBox.GetItemData(iCurSel));
		CString szName;
		int nCount = 1;
		if (pData&&pData->m_strNodeXPath!=_T(""))
		{
			if (m_pXMlDoc)
			{
				CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
				CXMLDOMNodePtr pFather = pXMLDOMNodePtr->GetParentNode();
				while (1)
				{
					BOOL bFlag = FALSE;
					szName.Format(_T("新建词条(%d)"), nCount);
					if (pFather->HasChildNodes())
					{
						CString strNodeName = pFather->GetNodeName();
						CXMLDOMNodesPtr pXMLDOMNodeList = pFather->GetChildrenNodes(strNodeName);
						int nNum = pXMLDOMNodeList->GetCount();
						int i = 0;
						for (i = 0;i < nNum;i++)
						{
							CXMLDOMNodePtr pTem = pXMLDOMNodeList->GetItem(i);
							CString strAttriName = pTem->GetAttributeName();
							CString strAttriValue = pTem->GetAttributeValue(strAttriName);
							if (szName == strAttriValue)
							{
								bFlag = TRUE;
								nCount++;
								break;
							}
						}
					}
					if (!bFlag)
					{
						break;
					}
				}
				CXMLNodeInfo TempInfo;
				TempInfo.m_bLeafNode = TRUE;
				TempInfo.m_strNodeName = c_szLemma/*_T("词条")*/;
				TempInfo.m_strNodeAttributeName =c_szName/* _T("name")*/;
				TempInfo.m_strNodeAttributeValue = szName;
				CXMLDOMNodePtr pInsert = pFather->AppendNode(TempInfo.m_strNodeName,_T(""),TempInfo.m_strNodeAttributeName,
					TempInfo.m_strNodeAttributeValue);
				CXMLDOMNodePtr PClone(new CXMLDOMNode(NULL ));
				CXMLDOMNodePtr PTemptr(new CXMLDOMNode(NULL ));
				pInsert->CloneNode(PClone);
				pXMLDOMNodePtr->InsertAfter(PClone,PTemptr);
				pInsert->DeleteNode();
				m_pXMlDoc->GetCurNodeXPath(PTemptr,TempInfo.m_strNodeXPath);
				listBox.InsertStringEx(iCurSel,&TempInfo);
				int iCount = listBox.GetCount();
				if(iCurSel >= iCount)
					iCurSel = iCount - 1;
				listBox.SetCurSel(iCurSel);
				listBox.CreateEdit();
			}
		}
	}
	else
	{
		if (m_pXMlDoc)
		{
			CXMLNodeInfo xmlDocInfo;
			CXMLDOMNodePtr pInsert(new CXMLDOMNode(NULL));
			HTREEITEM hItem = m_treeNames.GetSelectedItem();
			if (hItem!=NULL)
			{
				CString szName;
				int nCount = 1;
				CXMLNodeInfo *pData = (CXMLNodeInfo*)m_treeNames.GetItemData(hItem);
				if (pData&&pData->m_strNodeXPath!=_T(""))
				{
					CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
					while (1)
					{
						BOOL bFlag = FALSE;
						szName.Format(_T("新建词条(%d)"), nCount);
						if (pXMLDOMNodePtr->HasChildNodes())
						{
							CString strNodeName = pXMLDOMNodePtr->GetNodeName();
							CXMLDOMNodesPtr pXMLDOMNodeList = pXMLDOMNodePtr->GetChildrenNodes(strNodeName);
							int nNum = pXMLDOMNodeList->GetCount();
							int i = 0;
							for (i = 0;i < nNum;i++)
							{
								CXMLDOMNodePtr pTem = pXMLDOMNodeList->GetItem(i);
								CString strAttriName = pTem->GetAttributeName();
								CString strAttriValue = pTem->GetAttributeValue(strAttriName);
								if (szName == strAttriValue)
								{
									bFlag = TRUE;
									nCount++;
									break;
								}
							}
						}
						if (!bFlag)
						{
							break;
						}
					}
					xmlDocInfo.m_strNodeName = c_szLemma/*_T("词条")*/;
					xmlDocInfo.m_strNodeAttributeName = c_szName/*_T("name")*/;
					xmlDocInfo.m_strNodeAttributeValue = szName;
					xmlDocInfo.m_bLeafNode = TRUE;
					pInsert=pXMLDOMNodePtr->AppendNode(xmlDocInfo.m_strNodeName,_T(""),xmlDocInfo.m_strNodeAttributeName
						,xmlDocInfo.m_strNodeAttributeValue);
					m_pXMlDoc->GetCurNodeXPath(pInsert,xmlDocInfo.m_strNodeXPath);
					//listBox.InsertStringEx(iCurSel,&xmlDocInfo);
					listBox.AddStringEx(xmlDocInfo.m_strNodeAttributeValue,&xmlDocInfo);
					int iCount = listBox.GetCount();
					iCurSel = iCount - 1;
					listBox.SetCurSel(iCurSel);
					listBox.CreateEdit();
				}
			}
		}
	}
}

void CInsTextDlg::DoAppendItem()
{
	DoInsertItem();		
}

void CInsTextDlg::DoModifyItem()
{
	if (m_bSort)
	{
		m_sortNames.CreateEdit();
	}
	else
	{
		m_dragNames.CreateEdit();
	}
}
CString CInsTextDlg::DelStrReturn(const CString &strText)
{
	CString strTem = strText;
	int nPos = strTem.Find(_T('\n'),0);
	while (nPos>-1)
	{
		strTem.Delete(nPos);
		nPos = strTem.Find(_T('\n'),0);
	}
	nPos = strTem.Find(_T('\r'),0);
	while (nPos>-1)
	{
		strTem.Delete(nPos);
		nPos = strTem.Find(_T('\r'),0);
	}
	return strTem;
}
CString CInsTextDlg::SetStrReturn(const CString &strText)
{
	CString strTem = strText;
	int nLen = strTem.GetLength();
	int nNum = 0;
	int i=0;
	for (i=0;i<nLen;i++)
	{
		TCHAR ch = strTem.GetAt(i);
		if (ch == 31)
		{
			strTem.Delete(i);
			i--;
			nNum ++;
		}
		else
		{
			break;
		}
	}
	if (nNum>0)
	{
		int i = 0;
		for (;i<nNum;i++)
		{
			strTem.Insert(0,32);
		}
	}
	int nR = 0;
	if (strTem.Find(_T('\r'),nR)!=-1)
	{
		return strTem;
	}
	int nPos = -1;
	nPos = strTem.FindOneOf(_T("\n"));
	while (nPos!=-1)
	{
		strTem.Insert(nPos,_T('\r'));
		int nPos1 = nPos+2;
		nPos = strTem.Find(_T('\n'),nPos1);
	}
	int nLen1 = strTem.GetLength();
	return strTem;
}
//是否有子节点
BOOL CInsTextDlg::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;
}
//得到xml节点值(仅对叶子节点)
/*CString  CInsTextDlg::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 CInsTextDlg::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[MAX_PATH];
	memset( szGetAttributeValue, 0, sizeof( szGetAttributeValue ) );
	_tcscpy( szGetAttributeValue, ( TCHAR* )(_bstr_t)varTextValue );
	CString strAttributeValue;
	strAttributeValue = szGetAttributeValue;
	if( NULL != pIXMLDOMNode )
	{
		pIXMLDOMNode.Release();
		pIXMLDOMNode = NULL;
	}
	if( NULL != pIXMLDOMNamedNodeMap )
	{
		pIXMLDOMNamedNodeMap.Release();
		pIXMLDOMNamedNodeMap = NULL;
	}
	return strAttributeValue;
}
CString CInsTextDlg::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 CInsTextDlg::GetXMLNodeAttributeName(const MSXML2::IXMLDOMNodePtr &pIXMLDOMNodePtr)
{
	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;
}*/
void CInsTextDlg::BreadGetXmlNodesValve(CArchTextLibListBox &listBox,const  CXMLDOMNodePtr &pXmlNode)
{
	MSXML2::DOMNodeType			NodeType;
	MSXML2::IXMLDOMNodePtr pXMLDOMNodePtr = pXmlNode->GetNodePtr();
	std::deque<MSXML2::IXMLDOMNodePtr> quene;
	quene.push_back(pXMLDOMNodePtr);
	BOOL bFirst = TRUE;
	BOOL bDelete = FALSE;
	while(quene.size()!=0)
	{
		MSXML2::IXMLDOMNodePtr pCurXMLDOMNodePtr = quene.front();
		quene.pop_front();
		
		MSXML2::IXMLDOMNodeListPtr pXMLDOMNodeList = NULL;
		pCurXMLDOMNodePtr->get_childNodes( &pXMLDOMNodeList);
		if(pXMLDOMNodeList->Getlength()==0)
		{
			CString strNodeName = GetXMLNodeName(pCurXMLDOMNodePtr);
			if (strNodeName == c_szLemma)
			{
				CXMLNodeInfo nodeInfo;
				CXMLDOMNode *pTem = new CXMLDOMNode(pCurXMLDOMNodePtr);
				CXMLDOMNodePtr pTemPtr(pTem);
				nodeInfo = GetNodeInfoEx(pTemPtr,m_pXMlDoc);
				listBox.AddStringEx(nodeInfo.m_strNodeAttributeValue,&nodeInfo);
			}
			continue;
		}
		for(long i=0;i<pXMLDOMNodeList->Getlength();i++)
		{
			MSXML2::IXMLDOMNodePtr pXMLDOMNode = pXMLDOMNodeList->Getitem(i);
			int n = pXMLDOMNodeList->Getlength();
			pXMLDOMNode->get_nodeType( &NodeType );
			if(NodeType!=MSXML2::NODE_ELEMENT)
			{
				CString strNodeName = GetXMLNodeName(pCurXMLDOMNodePtr);
				if (strNodeName == c_szLemma)
				{
					CXMLNodeInfo nodeInfo;
					CXMLDOMNode *pTem = new CXMLDOMNode(pCurXMLDOMNodePtr);
					CXMLDOMNodePtr pTemPtr(pTem);
					nodeInfo = GetNodeInfoEx(pTemPtr,m_pXMlDoc);
					listBox.AddStringEx(nodeInfo.m_strNodeAttributeValue,&nodeInfo);
				}
			}
			else
				quene.push_back(pXMLDOMNode);
		}
		
	}	
}

/*void CInsTextDlg::DeepGetXmlNodesValve(CArchTextLibListBox &listBox,const  CXMLDOMNodePtr &pXmlNode)
{
	// root item node
	MSXML2::IXMLDOMNodePtr pXMLDOMNodePtr = pXmlNode->GetNodePtr();
	if(IsHasChildNodes(pXMLDOMNodePtr))
	{
		MSXML2::IXMLDOMNodeListPtr pXMLDOMNodeList = NULL;
		pXMLDOMNodePtr->get_childNodes(&pXMLDOMNodeList);
		AnalyseXmlTree(pXMLDOMNodeList,listBox);
		if (pXMLDOMNodeList!=NULL)
		{
			pXMLDOMNodeList.Release();
			pXMLDOMNodeList = NULL;
		}
	}
	else  // get current node info & insert into list
	{
		CString strNodeName = GetXMLNodeName(pXMLDOMNodePtr);
		int nUm = 0;
		if (strNodeName == c_szLemma)
		{
			//TCHAR szURL[MAX_PATH];
			CXMLNodeInfo nodeInfo;
			CXMLDOMNode *pTem = new CXMLDOMNode(pXMLDOMNodePtr);
			CXMLDOMNodePtr pTemPtr(pTem);
			nodeInfo = GetNodeInfoEx(pTemPtr,m_pXMlDoc);
			listBox.AddStringEx(nodeInfo.m_strNodeAttributeValue,&nodeInfo);
		}
	}
}*/

/*void CInsTextDlg::AnalyseXmlTree(const MSXML2::IXMLDOMNodeListPtr& pXMLDOMNodeList, CArchTextLibListBox &listBox)
{
	int nLen = pXMLDOMNodeList->Getlength();
	for (int i = 0; i < nLen; i++)
	{
		MSXML2::IXMLDOMNodePtr pXMLDOMNode = pXMLDOMNodeList->Getitem(i);
		CString strAttriName = GetXMLNodeAttributeName(pXMLDOMNode);
		CString strAttriValue = GetXMLNodeAttributeValue(pXMLDOMNode,strAttriName);
		CString strLast = c_szLate;
		if (strAttriValue == strLast) continue;
		if(IsHasChildNodes(pXMLDOMNode))
		{
			// 去掉pXMLDOMNodeList当前分析节点
			MSXML2::IXMLDOMNodeListPtr pXMLDOMNodeTemList = NULL;
			pXMLDOMNode->get_childNodes(&pXMLDOMNodeTemList);
			if (pXMLDOMNode!=NULL)
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
			AnalyseXmlTree(pXMLDOMNodeTemList,listBox);
			if (pXMLDOMNodeTemList!=NULL)
			{
				pXMLDOMNodeTemList.Release();
				pXMLDOMNodeTemList = NULL;
			}
		}
		else // insert into list
		{
			InsertIntoLst(pXMLDOMNode,listBox);
			if (pXMLDOMNode!=NULL)
			{
				pXMLDOMNode.Release();
				pXMLDOMNode = NULL;
			}
		}
	}
}*/

/*void CInsTextDlg::InsertIntoLst(const MSXML2::IXMLDOMNodePtr &pXmlNode,CArchTextLibListBox &listBox)
{
	CXMLNodeInfo nodeInfo;
	CXMLDOMNode *pTem = new CXMLDOMNode(pXmlNode);
	CXMLDOMNodePtr pTemPtr(pTem);
	nodeInfo = GetNodeInfoEx(pTemPtr,m_pXMlDoc);
	listBox.AddStringEx(nodeInfo.m_strNodeAttributeValue,&nodeInfo);
}*/
void CInsTextDlg::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();
		}
		//Treequeue.pop_front();
	    //VARIANT_BOOL vrb = pCurXMLDOMNodePtr->hasChildNodes();
		if (IsHasChildNodes(pCurXMLDOMNodePtr)/*vrb == VARIANT_TRUE*/)
		{
			if (bFirst)
			{
				CXMLNodeInfo Noedata;
				Noedata = GetNodeInfoEx(pXmlNode,m_pXMlDoc);
				//Noedata.m_strNodeAttributeValue = c_szTDWord;
			    hParent = m_treeNames.InsertItemEx(&Noedata,TVI_ROOT,TVI_LAST);
				m_hLastItem = hParent;
				hPar = hParent;
				//Treequeue.push_back(hParent);
				bFirst = FALSE;
			}
			else
			{
				bDelete = TRUE;
			}
			
			MSXML2::IXMLDOMNodeListPtr pXMLDOMNodeList = NULL;
			pCurXMLDOMNodePtr->get_childNodes( &pXMLDOMNodeList);
			int i = 0;
			for (i=0;i<pXMLDOMNodeList->Getlength();i++)
			{
				MSXML2::IXMLDOMNodePtr pXMLDOMNode = pXMLDOMNodeList->Getitem(i);
				CString strNodeName;
				strNodeName = GetXMLNodeName(pXMLDOMNode);
				if (strNodeName == c_szCatalog)
				{
					quene.push_back(pXMLDOMNode);
					CXMLNodeInfo xmlInfo;
					xmlInfo.m_strNodeName = c_szCatalog;
					xmlInfo.m_strNodeAttributeName = c_szName;
					CString strXPath,strAttriValue;
					strAttriValue = GetXMLNodeAttributeValue(pXMLDOMNode,c_szName);
					xmlInfo.m_strNodeAttributeValue = strAttriValue;
					CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hPar));
					if (pData)
					{
						strXPath = pData->m_strNodeXPath;
					}
					strXPath += _T("/")+xmlInfo.m_strNodeName+_T("[@")
						+xmlInfo.m_strNodeAttributeName+_T("=")+_T("'")+strAttriValue+_T("']");
					xmlInfo.m_strNodeXPath = strXPath;
					HTREEITEM hItem = m_treeNames.InsertItemEx(&xmlInfo,hPar,TVI_LAST);
					if (g_xmlTreeLastInfo.m_strNodeAttributeValue == xmlInfo.m_strNodeAttributeValue)
					{
						m_hLastItem = hItem;
					}
					Treequeue.push_back(hItem);
					
				}
				
			}
			if (pXMLDOMNodeList!=NULL)
			{
				pXMLDOMNodeList.Release();
				pXMLDOMNodeList = NULL;
			}
		}
		if (bDelete)
		{
			if (pCurXMLDOMNodePtr !=NULL)
			{
				pCurXMLDOMNodePtr.Release();
				pCurXMLDOMNodePtr = NULL;
			}
		}
	}
}
LRESULT CInsTextDlg::OnNewLine(WPARAM w,LPARAM l)
{
	DoAppendItem();
	return 0;
}

LRESULT CInsTextDlg::OnInSertLine(WPARAM w,LPARAM l)
{
	DoInsertItem();
	return 0;
}

LRESULT CInsTextDlg::OnReNameLine(WPARAM w,LPARAM l)
{
	DoModifyItem();
	return 0;
}

LRESULT CInsTextDlg::OnDeleteLine(WPARAM w,LPARAM l)
{
	DoDeleteItem();
	return 0;
}
void CInsTextDlg::OnSize(UINT nType,int cx,int cy)
{
	CModelessDialog::OnSize(nType,cx,cy);
	if(!IsShowNormal())
		return;
	HWND hwnd;
	CEdit *pEdit = (CEdit*)GetDlgItem(IDC_EDIT_SEARCH);
	if (pEdit)
	{
		hwnd = pEdit->GetSafeHwnd();
		if (hwnd)
		{
			pEdit->SetMargins(0,cx-30);
			CRect rect,rect1;
			pEdit->GetWindowRect(rect);
			ScreenToClient(rect);
			rect.SetRect(rect.TopLeft(),CPoint(rect.right,cy-10));
			pEdit->MoveWindow(rect);
		}
	}
}
// CInsTextDlg 消息处理程序
BOOL CInsTextDlg::OnInitDialog()
{
	CModelessDialog::OnInitDialog();
	m_pXMlDoc = new CXMLDOMFile;
	TCHAR *strParth = new TCHAR[MAX_PATH] ;
	if(!FindFile(_T("dict.xml"), strParth)) 
	{
		delete []strParth;
	}
	if (m_pXMlDoc->IsFileExist(strParth))
	{
		if (!m_pXMlDoc->Open(strParth))
		{
			// Zyu modify on 100726，支持64位
#ifndef _WIN64
			MessageBox(_T("打开XML文档失败！请安装MSXML4.0SP2组件"));
#else
			MessageBox(_T("打开XML文档失败！请安装MSXML6.0组件"));
#endif
			return FALSE;
		}
	}
	else
	{
		MessageBox(_T("文件不存在"));
		return FALSE;
	}
	m_treeNames.SetXMLDoc(m_pXMlDoc);
	m_dragNames.SetXMLDoc(m_pXMlDoc);
	m_sortNames.SetXMLDoc(m_pXMlDoc);
	delete []strParth;
	InitToolBar();
	InitList();
	UpdateButton();
	m_bSort = FALSE;
	//m_bEdit = TRUE;
	SetEditText(m_szName);
	return TRUE;
}
void CInsTextDlg::OnTvnSelchangedTree(NMHDR *pNMHDR, LRESULT *pResult)
{
	//MessageBox(_T("A"));
	LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);
	// TODO: 在此添加控件通知处理程序代码
	HTREEITEM hItem = m_treeNames.GetSelectedItem();
	HTREEITEM hRoot = m_treeNames.GetRootItem();
	if (hRoot == hItem)
	{
		m_szType = c_szAll;
		m_bEdit = FALSE;
	}
	if (hItem == NULL)
	{
		hItem = hRoot;
	}
		CXMLNodeInfo *pNodeInfo = (CXMLNodeInfo*)(m_treeNames.GetItemData(hItem));
		if (pNodeInfo->m_strNodeName==_T(""))
		{
			return;
		}
		g_xmlTreeLastInfo = *pNodeInfo;
		if (pNodeInfo)
		{
			m_szType = pNodeInfo->m_strNodeAttributeValue;
			SetNamesModify();
			ChangeListBox(FALSE);
		}
		CString strLate = c_szLate;
		if (pNodeInfo->m_strNodeAttributeValue == strLate)
		{
			m_bEdit = FALSE;
		}
		else
		{
			m_bEdit = TRUE;
		}
	//}
	int n = m_dragNames.GetCount();
	if (n != 0)
	{
		if(m_dragNames.SelectString(-1, m_szName) == LB_ERR)
			m_dragNames.SetCurSel(-1);
	}
	UpdateButton();
	*pResult = 0;
}
void CInsTextDlg::InitToolBar()
{
	CTemporaryResourceOverride vTmp;
	m_toolBar.Create(this);
	m_toolBar.LoadToolBar(IDR_TOOLBAR_LETTER);
	m_toolBar.ShowWindow(SW_SHOW);
	m_toolBar.SetBarStyle(CBRS_ALIGN_TOP | CBRS_TOOLTIPS | CBRS_FLYBY);
	RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, 0);
}
void CInsTextDlg::OnBnClickedBtnInlib()
{
	//OnBnClickedAddtolib();
	OnBnClickedInputtolib();
}
void CInsTextDlg::DeleteTree()
{
	m_treeNames.DeleteAllItemData();
	m_treeNames.DeleteAllItems();
}
void CInsTextDlg::InitTree()
{
	CXMLDOMNodePtr pRootNode,pGuardNode;
	pRootNode = m_pXMlDoc->GetRoot();
	BreadthXmlNodeToTreeNode(pRootNode);
	HTREEITEM hParent = m_treeNames.GetRootItem();
	HTREEITEM hChild = m_treeNames.GetChildItem(hParent);
	m_treeNames.SelectItem(hChild);
	m_treeNames.Expand(hParent, TVE_EXPAND);
	m_szType = c_szLate;
	m_bEdit = FALSE;
	UpdateData(FALSE);
}
void CInsTextDlg::InitList()
{
	CXMLDOMNodePtr pRootNode,pGuardNode;
	pRootNode = m_pXMlDoc->GetRoot();
	HICON hIcon[4];
	m_imageList.Create(16,16,ILC_COLOR8,1,1); 
	m_imageList.SetBkColor(RGB(255,255,255));
	hIcon[0]=AfxGetApp()->LoadIcon(IDI_WORDLIBCLOSE);
	hIcon[1]=AfxGetApp()->LoadIcon(IDI_WORDLIBOPEN);
	hIcon[2]=AfxGetApp()->LoadIcon(IDI_BOOKCLOSE);
	hIcon[3]=AfxGetApp()->LoadIcon(IDI_BOOKOPEN);
	int i=0;
	for(i=0;i<4;i++) 
	{ 
		m_imageList.Add (hIcon[i]); 
	} 
	m_treeNames.SetImageList(&m_imageList,TVSIL_NORMAL);
	pGuardNode = m_pXMlDoc->GetRoot();
	BreadthXmlNodeToTreeNode(pGuardNode);
	HTREEITEM hParent = m_treeNames.GetRootItem();
	HTREEITEM hChild = m_treeNames.GetChildItem(hParent);
	CString strType,strPath;
	if (m_hLastItem == hParent)
	{
		m_treeNames.SelectItem(hChild);
		CXMLNodeInfo*pData = (CXMLNodeInfo*)m_treeNames.GetItemData(hChild);
		if (pData)
		{
			strType = pData->m_strNodeAttributeValue;
			strPath = pData->m_strNodeXPath;
		}
		m_treeNames.Expand(hParent, TVE_EXPAND);
	}
	else
	{
		m_treeNames.SelectItem(m_hLastItem);
		CXMLNodeInfo*pData = (CXMLNodeInfo*)m_treeNames.GetItemData(m_hLastItem);
		if (pData)
		{
			strType = pData->m_strNodeAttributeValue;
			strPath = pData->m_strNodeXPath;
		}
		m_treeNames.Expand(hParent, TVE_EXPAND);
	}
	CArchTextLibListBox &listBox = m_bSort ? m_sortNames : m_dragNames;
	int nNum = listBox.GetCount();
	//int i=0;
	for (i=0;i<nNum;i++)
	{
		CXMLNodeInfo*pData = (CXMLNodeInfo*)listBox.GetItemData(i);
		if (pData)
		{
			if (pData->m_strNodeValue == m_szName)
			{
				listBox.SetCurSel(i);
				break;
			}
		}
	}
	m_szType = strType;
	m_bEdit = FALSE;
	//m_editSearch.EnableWindow(m_bEdit);
}
void CInsTextDlg::SetNamesModify()
{
	if(_tcscmp(m_szType, c_szAll) == 0 || _tcscmp(m_szType, c_szLate) == 0)
	{
		m_dragNames.SetModify(FALSE);
		m_sortNames.SetModify(FALSE);
	}
	else
	{
		m_dragNames.SetModify(TRUE);
		m_sortNames.SetModify(TRUE);
	}
}

void CInsTextDlg::AddNamesByType(CArchTextLibListBox &listBox)
{
	listBox.ReSetContentEx();
	HTREEITEM hRoot = m_treeNames.GetRootItem();
	HTREEITEM hItem = m_treeNames.GetSelectedItem();
	if (hItem == hRoot)
	{
		CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->GetRoot();
		//GetXmlNodesValue(listBox,pXMLDOMNodePtr,TRUE,FALSE);
		//clock()
		BreadGetXmlNodesValve(listBox,pXMLDOMNodePtr);
		//DeepGetXmlNodesValve(listBox,pXMLDOMNodePtr);
		//Test(pXMLDOMNodePtr,listBox);
		listBox.SetModify(FALSE);
	}
	else
	{
		CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hItem));
		if (pData)
		{
			BOOL bEdit = TRUE;
			/*CString str = pData->m_strNodeAttributeValue;
			if (str == c_szLate)
			{
				bEdit = FALSE;
			}*/
			CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
			//GetXmlNodesValue(listBox,pXMLDOMNodePtr,FALSE,FALSE);
			BreadGetXmlNodesValve(listBox,pXMLDOMNodePtr);
			//DeepGetXmlNodesValve(listBox,pXMLDOMNodePtr);
			//Test(pXMLDOMNodePtr,listBox);
			listBox.SetModify(bEdit);
		}
	}
	if (listBox.GetCount()!=0)
	{
		if (g_xmlListLastInfo.m_strNodeAttributeValue !="")
		{
		}
		else
		{
			if(m_szName != _T(""))
			{
				if(listBox.SelectString(-1, m_szName) == LB_ERR)
					listBox.SetCurSel(-1);
			}
				/*listBox.GetText(0, m_szName);
			listBox.SelectString(-1, m_szName);*/
		}
		
	}
	
}

void CInsTextDlg::ChangeListBox(BOOL bIsSort)
{
	m_bSort = bIsSort; 
	HTREEITEM hItem = m_treeNames.GetSelectedItem();
	CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hItem));
	if (pData)
	{
		CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
		if(bIsSort)
		{
			m_dragNames.ShowWindow(SW_HIDE);
			m_sortNames.ShowWindow(SW_SHOW);
			AddNamesByType(m_sortNames);
		}
		else
		{
			m_sortNames.ShowWindow(SW_HIDE);
			m_dragNames.ShowWindow(SW_SHOW);
			AddNamesByType(m_dragNames);
		}
	}
	g_bSort = bIsSort;
}   

void CInsTextDlg::SetPreText(CString &szText)
{
	if(szText != _T(""))
		m_szName = szText;
}

void CInsTextDlg::SetEditText(CString &szText)
{
	if(szText != _T(""))
	{
		CString strTem = SetStrReturn(szText);
		m_editSearch.SetWindowText(strTem);
		m_szName=strTem;//add by whl on 051229
	}
}

CString CInsTextDlg::GetEditText() 
{
	if (!m_bSingleLineText)
	{
		//CArtchTextLibEdit *pWnd = (CArtchTextLibEdit*)GetDlgItem(IDC_EDIT_SEARCH);
		//m_szName = pWnd->GetDlgItemText()
		return m_szName;
	}
	else
	{
		return DelStrReturn(m_szName);
	}
}

void CInsTextDlg::OnLbnSelchangeDragType()
{
	/*int iCurType = m_dragTypes.GetCurSel();
	m_dragTypes.GetText(iCurType, m_szType);
	SetNamesModify();
	ChangeListBox(FALSE);
	UpdateButton();*/
}
//遗留问题：在全部词汇目录中有同名项时只能显示第一个
void CInsTextDlg::OnLbnSelchangeName()
{
	int kk=0;
	//if(!m_bEdit)
	//return;
	if (m_bSort)
	{
		int nCur = m_sortNames.GetCurSel();
		if (nCur == -1)
		{
			return;
		}
		//HTREEITEM hFather = m_treeNames.GetSelectedItem();
		//CXMLNodeInfo *pFatherData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hFather));
		//CXMLDOMNodesPtr pFather = m_pXMlDoc->SelectSingleNode(pFatherData->m_strNodeXPath);
		CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_sortNames.GetItemData(nCur));
		if (pData->m_strNodeXPath==_T(""))
		{
			return;
		}
		CXMLNodeInfo data;
		CXMLDOMNodePtr pNodePter = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
		data =GetNodeInfo(pNodePter,m_pXMlDoc);
		//*pData = data;
		pData->m_strNodeAttributeValue = data.m_strNodeAttributeValue;
		pData->m_strNodeValue = data.m_strNodeValue;
		g_xmlListLastInfo = *pData;
		if (pData)
		{
			if (pData->m_strNodeValue!=_T(""))
			{
				SetEditText(pData->m_strNodeValue);
			}
			else
			{
				SetEditText(pData->m_strNodeAttributeValue);
			}
		}
	}
	else
	{
		int nCur = m_dragNames.GetCurSel();
		if (nCur == -1)
		{
			return;
		}
		CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_dragNames.GetItemData(nCur));
		CXMLNodeInfo data;
		if (pData->m_strNodeXPath==_T(""))
		{
			return;
		}
		CXMLDOMNodePtr pNodePter = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
		data =GetNodeInfo(pNodePter,m_pXMlDoc);
		pData->m_strNodeAttributeValue = data.m_strNodeAttributeValue;
		pData->m_strNodeValue = data.m_strNodeValue;
		g_xmlListLastInfo = *pData;
		if (pData)
		{
			CString str = pData->m_strNodeValue;
			int n = -1;
			n = str.FindOneOf(_T("\n"));
			if (pData->m_strNodeValue!=_T(""))
			{
				SetEditText(pData->m_strNodeValue);
			}
			else
			{
				SetEditText(pData->m_strNodeAttributeValue);
			}
		}
	}
	if (m_bSort!=FALSE)
	{
		m_bEdit = FALSE;
		SetEditText(m_szName);
		m_bEdit = TRUE;
	}
	else
	{
		SetEditText(m_szName);
	}
}

void CInsTextDlg::OnEnChangeEditSearch()
{
	//if(!m_bEdit)
	//	return;
	m_editSearch.GetWindowText(m_szName);
	m_bEditChanged = TRUE;
	CString strOld;
	if(!m_bSort)
	{
		int nIndex = m_dragNames.GetCurSel();
		if (nIndex>-1)
		{
			m_dragNames.GetText(nIndex,strOld);
			ChangeListBox(TRUE);
		}
		
	}
	else
	{
		int nIndex = m_sortNames.GetCurSel();
		if (nIndex>-1)
		{
			m_sortNames.GetText(nIndex,strOld);
		}
	}
	m_bEdit = FALSE;
	if(m_bSort)
	{
		if(m_sortNames.SelectString(-1, strOld) == LB_ERR)
			m_sortNames.SetCurSel(-1);
	}
	else
	{
		if(m_dragNames.SelectString(-1, strOld) == LB_ERR)
			m_dragNames.SetCurSel(-1);
	}
	m_bEdit = TRUE;
}
CNameString* CInsTextDlg::CreateNameString()
{
	if(m_szName==_T(""))
		return NULL;
	CNameString* pString=NULL;
	UString temp(m_szName);
	if(temp.Length()<=25)
		pString=new CNameString(m_szName);
	else
	{
		pString=new CNameString(TString(temp.Left(25)));
		pString->m_sContent=m_szName;
	}
	return pString;
}

void CInsTextDlg::OnBnClickedAddtolib()
{
		m_editSearch.GetWindowText(m_szName);
		//m_szName = _T('\t\t')+m_szName;
		if(m_szName == _T(""))
		{
			return;
		}
		CString strName;
		if (m_szName.GetLength()>20)
		{
			strName = m_szName.Mid(0,20);
		}
		else
		{
			strName = m_szName;
		}
		if (m_bSort)
		{
			int nIndex = m_sortNames.GetCurSel();
			if (nIndex> -1)
			{
				CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_sortNames.GetItemData(nIndex));
				if (pData&&pData->m_strNodeXPath!=_T(""))
				{
					CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
					pXMLDOMNodePtr->SetNodeValue(m_szName);
				}
			}
			else
			{
				CXMLNodeInfo xmlDocInfo;
				CXMLDOMNodePtr pInsert(new CXMLDOMNode(NULL));
				HTREEITEM hItem = m_treeNames.GetSelectedItem();
				CXMLNodeInfo *pData = (CXMLNodeInfo*)m_treeNames.GetItemData(hItem);
				if (pData&&pData->m_strNodeXPath!=_T(""))
				{
					
					CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
					xmlDocInfo.m_strNodeName = c_szLemma/*_T("词条")*/;
					xmlDocInfo.m_strNodeAttributeName = c_szName/*_T("name")*/;
					xmlDocInfo.m_strNodeAttributeValue = strName;
					xmlDocInfo.m_bLeafNode = TRUE;
					pInsert=pXMLDOMNodePtr->AppendNode(xmlDocInfo.m_strNodeName,_T(""),xmlDocInfo.m_strNodeAttributeName
						,xmlDocInfo.m_strNodeAttributeValue);
					m_pXMlDoc->GetCurNodeXPath(pInsert,xmlDocInfo.m_strNodeXPath);
					m_sortNames.AddStringEx(xmlDocInfo.m_strNodeAttributeValue,&xmlDocInfo);
					if (m_sortNames.SelectString(-1,xmlDocInfo.m_strNodeAttributeValue)== LB_ERR)
					{
						m_sortNames.SetCurSel(-1);
					}
				}
			}
			
		}
		else
		{
			int nIndex = m_dragNames.GetCurSel();
			if (nIndex>-1)
			{
				CString strAttri;
				m_dragNames.GetText(nIndex,strAttri);
				CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_dragNames.GetItemData(nIndex));
				if (pData&&pData->m_strNodeXPath!=_T(""))
				{
					CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
					pXMLDOMNodePtr->SetNodeValue(m_szName);
				}
			}
			else
			{
				CXMLNodeInfo xmlDocInfo;
				CXMLDOMNodePtr pInsert(new CXMLDOMNode(NULL));
				HTREEITEM hItem = m_treeNames.GetSelectedItem();
				CXMLNodeInfo *pData = (CXMLNodeInfo*)m_treeNames.GetItemData(hItem);
				if (pData&&pData->m_strNodeXPath!=_T(""))
				{

					CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
					xmlDocInfo.m_strNodeName = c_szLemma/*_T("词条")*/;
					xmlDocInfo.m_strNodeAttributeName = c_szName/*_T("name")*/;
					xmlDocInfo.m_strNodeAttributeValue = strName;
					xmlDocInfo.m_bLeafNode = TRUE;
					pInsert=pXMLDOMNodePtr->AppendNode(xmlDocInfo.m_strNodeName,_T(""),xmlDocInfo.m_strNodeAttributeName
						,xmlDocInfo.m_strNodeAttributeValue);
					m_pXMlDoc->GetCurNodeXPath(pInsert,xmlDocInfo.m_strNodeXPath);
					m_dragNames.AddStringEx(xmlDocInfo.m_strNodeAttributeValue,&xmlDocInfo);
					if (m_dragNames.SelectString(-1,xmlDocInfo.m_strNodeAttributeValue)== LB_ERR)
					{
						m_sortNames.SetCurSel(-1);
					}
				}
			}
		}
		//m_pXMlDoc->Save();
}

void CInsTextDlg::OnSelectLetter(UINT nID)
{
	int i = 0;
	if(!m_bSort)
		ChangeListBox(TRUE);
	const TCHAR *szHead[] = {_T("吖"), _T("八"), _T("擦"), _T("达"), _T("鹅")
						, _T("发"), _T("旮"), _T("妎"), _T("丌"), _T("咔")
						, _T("垃"), _T("嘸"), _T("拿"), _T("噢"), _T("趴")
						, _T("七"), _T("亽"), _T("仨"), _T("他"), _T("屲")
						, _T("夕"), _T("丫"), _T("帀")};

	int iPick;
	switch(nID)
	{
	case ID_BUTTON_A:
		iPick = 0;
		break;
	case ID_BUTTON_B:
		iPick = 1;
		break;
	case ID_BUTTON_C:
		iPick = 2;
		break;
	case ID_BUTTON_D:
		iPick = 3;
		break;
	case ID_BUTTON_E:
		iPick = 4;
		break;
	case ID_BUTTON_F:
		iPick = 5;
		break;
	case ID_BUTTON_G:
		iPick = 6;
		break;
	case ID_BUTTON_H:
		iPick = 7;
		break;
	case ID_BUTTON_J:
		iPick = 8;
		break;
	case ID_BUTTON_K:
		iPick = 9;
		break;
	case ID_BUTTON_L:
		iPick = 10;
		break;
	case ID_BUTTON_M:
		iPick = 11;
		break;
	case ID_BUTTON_N:
		iPick = 12;
		break;
	case ID_BUTTON_O:
		iPick = 13;
		break;
	case ID_BUTTON_P:
		iPick = 14;
		break;
	case ID_BUTTON_Q:
		iPick = 15;
		break;
	case ID_BUTTON_R:
		iPick = 16;
		break;
	case ID_BUTTON_S:
		iPick = 17;
		break;
	case ID_BUTTON_T:
		iPick = 18;
		break;
	case ID_BUTTON_W:
		iPick = 19;
		break;
	case ID_BUTTON_X:
		iPick = 20;
		break;
	case ID_BUTTON_Y:
		iPick = 21;
		break;
	case ID_BUTTON_Z:
		iPick = 22;
		break;
	default:
		iPick = 0;
		break;
	}

	CString szText;
	int iCount = m_dragNames.GetCount();
	if(iPick < 22)
	{
		for(int i=0; i<iCount; i++)
		{
			m_sortNames.GetText(i, szText);
			if(szText.CollateNoCase(szHead[iPick]) >= 0 
				&& szText.CollateNoCase(szHead[iPick+1]) <= 0)
			{
				m_sortNames.SetCurSel(i);
				return;
			}
		}
	}
	else
	{
		for(int i=0; i<iCount; i++)
		{
			m_sortNames.GetText(i, szText);
			if(szText.CollateNoCase(szHead[iPick]) >= 0)
			{
				m_sortNames.SetCurSel(i);
				return;
			}
		}
	}
}

void CInsTextDlg::OnLbnDblclkListName()
{
	AddToLast();
	CInsTextDlg::OnOK();
}

void CInsTextDlg::OnDestroy()
{
	DeleteTree();
	m_dragNames.ReSetContentEx();
	m_sortNames.ReSetContentEx();
	CModelessDialog::OnDestroy();
}

void CInsTextDlg::AddToLast()
{
	HTREEITEM hItem = m_treeNames.GetRootItem();
	HTREEITEM hChild = m_treeNames.GetChildItem(hItem);
	CString strText;
	BOOL bFind = FALSE;
	while(hChild)
	{
		strText = m_treeNames.GetItemText(hChild);
		if (strText == c_szLate)
		{
			bFind = TRUE;
			break;
		}
		hChild = m_treeNames.GetNextSiblingItem(hChild);
	}
	if (bFind)
	{
		CXMLNodeInfo*pData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hChild));
		if (pData)
		{
			CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
			int nIndex = m_dragNames.GetCurSel();
			int nCount = m_dragNames.GetCount();
			if (nCount<=0)
			{
				return;
			}
			if (nIndex == -1)
			{
				nIndex =0;
			}
			CXMLNodeInfo *pData1 = (CXMLNodeInfo*)(m_dragNames.GetItemData(nIndex));
			if (pData1)
			{
				if (!pXMLDOMNodePtr->IsChildNodeExist(pData1->m_strNodeName,pData1->m_strNodeAttributeName,
					pData1->m_strNodeAttributeValue
					))
				{
					CXMLDOMNodePtr pTemNodeptr = pXMLDOMNodePtr->AppendNode(pData1->m_strNodeName,pData1->m_strNodeValue,pData1->m_strNodeAttributeName,
						pData1->m_strNodeAttributeValue);
					if (pTemNodeptr.get()!=NULL)
					{
						CXMLDOMNodePtr pCloneNode( new CXMLDOMNode(NULL));
						if (pTemNodeptr->CloneNode(pCloneNode))
						{
							CXMLDOMNodePtr pFirstBrotherNode = pXMLDOMNodePtr->GetFirstChildNode();
							if (pFirstBrotherNode.get()!=NULL)
							{
								pFirstBrotherNode->InsertBefore(pCloneNode);
								pTemNodeptr->DeleteNode();
							}
						}
						
					}
					//m_pXMlDoc->Save();
				}
			}
		}
	}

}

void CInsTextDlg::UpdateButton()
{
	if(_tcscmp(m_szType, c_szLate) == 0)
	{
		m_buttonAdd.EnableWindow(FALSE);
		m_buttonFile.EnableWindow(FALSE);
		m_buttonInput.EnableWindow(FALSE);
	}
	else
	{
		m_buttonAdd.EnableWindow(TRUE);
		m_buttonFile.EnableWindow(TRUE);
		m_buttonInput.EnableWindow(TRUE);
	}
}
void CInsTextDlg::GetXmlNodesValue(CArchTextLibListBox &listBox,const CXMLDOMNodePtr &pXmlNode,BOOL bAll,BOOL bSort)
{

	CXMLDOMNodesPtr pXMLNodeList = pXmlNode->GetChildrenNodes(pXmlNode->GetNodeName());
	int count = pXMLNodeList->GetCount();
	CString strNodeName = pXmlNode->GetNodeName();
	if(count==0&&strNodeName == c_szLemma) 
	{
		CXMLNodeInfo xmlNodeInfo = GetNodeInfoEx(pXmlNode,m_pXMlDoc);
		HTREEITEM hParent = m_treeNames.GetSelectedItem();
		CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hParent));
		if (pData)
		{
			listBox.AddStringEx(xmlNodeInfo.m_strNodeAttributeValue,&xmlNodeInfo);
		}
		return;
	}
	int i=0;
	for(i=0; i<count; i++)
	{
		CXMLDOMNodePtr pChildNode = pXMLNodeList->GetItem(i);
		if (bAll)
		{
			CString strAttriName = pChildNode->GetAttributeName();
			CString strAttriValve;
			//if (pChildNode->IsAttributeExist(strAttriName))
			//{
				strAttriValve = pChildNode->GetAttributeValue(strAttriName);
			//}
			if (strAttriValve == c_szLate)
			{
				continue;
			}
		}
		if (i==15)
		{
			int k = 19;
		}
		GetXmlNodesValue(listBox,pChildNode,bAll,bSort);//递归子节点
	}
}
//------------------------------------------------------
// 递归将一个节点下所有子节点加入到树
//------------------------------------------------------
void  CInsTextDlg::XmlNodeToTreeNode(HTREEITEM hParentItem, const CXMLDOMNodePtr &pXmlNode)
{
	CXMLDOMNodesPtr pXMLNodeList = pXmlNode->GetChildrenNodes(pXmlNode->GetNodeName());
	int count = pXMLNodeList->GetCount();
	if(count==0) 
	{
		return;
	}
	int i=0;
	for(i=0; i<count; i++)
	{
		CXMLDOMNodePtr pChildNode = pXMLNodeList->GetItem(i);
		HTREEITEM hSubItem;
		CString strName,strNodeName;
		strNodeName = pChildNode->GetNodeName();
		strName = pChildNode->GetAttributeName();
		if (strNodeName == c_szLemma)
		{
			continue;
		}
		CString str = pChildNode->GetAttributeValue(strName);
		CXMLNodeInfo nodeInfo = GetNodeInfo(pChildNode,m_pXMlDoc);
		CXMLNodeInfo*pData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hParentItem));
		if (pData)
		{
			nodeInfo.m_strNodeXPath = pData->m_strNodeXPath+_T("/")+strNodeName+_T("[@")
				+strName+_T("=")+_T("'")+str+_T("']");
			hSubItem = m_treeNames.InsertItemEx(&nodeInfo,hParentItem,TVI_LAST);
			XmlNodeToTreeNode(hSubItem,pChildNode);//递归子节点
		}
	}
}

BOOL CInsTextDlg::ReadStoreData()
{
	//XString fullFile;
 //   if(!FindFile(_T("dict.dbf"), fullFile)) 
	//{
	//	MessageBox(_T("对不起，没有发现dict.dbf文件！"));
	//	return FALSE;
	//}

 //   CodeBase db;
//	XDbfTable *pTable = db.Open(fullFile);
	//if(!pTable) 
	//{
	//	MessageBox(_T("打开dict.dbf文件出错！"));
	//	return FALSE;
	//}

	//m_dragTypes.ResetContent();
	//CString szType, szName ,szContent0,szContent1,szContent2,szContent3;
	//CListBoxItemData *pItemData = NULL;
	//pTable->MoveFirst();
	//while(!pTable->IsEOF())	
	//{
	//	GET_FIELD(pTable, _T("type"), szType);
	//	GET_FIELD(pTable, _T("name"), szName);

	//	//add by whl
	//	GET_FIELD(pTable, _T("content0"),szContent0);
	//	GET_FIELD(pTable, _T("content1"),szContent1);
	//	GET_FIELD(pTable, _T("content2"),szContent2);
	//	GET_FIELD(pTable, _T("content3"),szContent3);

	//	int iRet = m_dragTypes.FindStringExact(-1, szType);
	//	if(iRet != LB_ERR)
	//		pItemData = (CListBoxItemData *)m_dragTypes.GetItemDataPtr(iRet);
	//	else
	//	{
	//		int iType = m_dragTypes.AddString(szType);
	//		pItemData = new CListBoxItemData;
	//		m_dragTypes.SetItemDataPtr(iType, pItemData);
	//	}
	//	if(szName == _T(""))
	//		pTable->Delete();
	//	else
	//	{
	//		if(pItemData > NULL)
	//		{
	//			long oldLen=pItemData->lstNames.GetLength();
	//			pItemData->lstNames.FindDataOrAddTail(CNameString(szName));
	//			
	//			//add by whl
	//			if(pItemData->lstNames.GetLength()>oldLen)//确实新建了条目
	//			{
	//				CNameString*pString=pItemData->lstNames.GetCurData();//最后一个
	//				pString->m_sContent=szContent0+szContent1+szContent2+szContent3;
	//			}
	//		}
	//	}
	//	pTable->MoveNext();
	//}
	return TRUE;
}

BOOL CInsTextDlg::WriteStoreData()
{
	//XString fullFile;
 //   if(!FindFile(_T("dict.dbf"), fullFile)) 
	//{
	//	MessageBox(_T("对不起，没有发现dict.dbf文件！"));
	//	return FALSE;
	//}

 //   CodeBase db;
	//XDbfTable *pTable = db.Open(fullFile);
	//if(!pTable) 
	//{
	//	MessageBox(_T("打开dict.dbf文件出错！"));
	//	return FALSE;
	//}

	//CString szType;
	//pTable->MoveFirst();
	//for(long i=0; i<m_dragTypes.GetCount(); i++)
	//{
	//	m_dragTypes.GetText(i, szType);
	//	if(_tcscmp(szType, c_szAll) == 0)
	//		continue;

	//	CListBoxItemData *pItemData = (CListBoxItemData *)m_dragTypes.GetItemDataPtr(i);
	//	if(pItemData <= NULL)
	//		continue;

	//	for(pItemData->lstNames.MoveToFirst(); !pItemData->lstNames.IsOut(); pItemData->lstNames.MoveToNext())
	//	{
	//		CString szName,szContent0,szContent1,szContent2,szContent3;
	//		pItemData->lstNames.GetCurData()->Split(szName,szContent0,szContent1,szContent2,szContent3);
	//		if(!pTable->IsEOF())
	//		{
	//			SET_FIELD(pTable, _T("type"), (const TCHAR*)szType);
	//			SET_FIELD(pTable, _T("name"), (const TCHAR*)szName);

	//			//add by whl
	//			SET_FIELD(pTable, _T("content0"),(const TCHAR*)szContent0);
	//			SET_FIELD(pTable, _T("content1"),(const TCHAR*)szContent1);
	//			SET_FIELD(pTable, _T("content2"),(const TCHAR*)szContent2);
	//			SET_FIELD(pTable, _T("content3"),(const TCHAR*)szContent3);
	//		}
	//		else
	//		{
	//			pTable->AppendBegin();
	//			SET_FIELD(pTable, _T("type"), (const TCHAR*)szType);
	//			SET_FIELD(pTable, _T("name"), (const TCHAR*)szName);

	//			//add by whl
	//			SET_FIELD(pTable, _T("content0"),(const TCHAR*)szContent0);
	//			SET_FIELD(pTable, _T("content1"),(const TCHAR*)szContent1);
	//			SET_FIELD(pTable, _T("content2"),(const TCHAR*)szContent2);
	//			SET_FIELD(pTable, _T("content3"),(const TCHAR*)szContent3);

	//			pTable->AppendEnd();
	//		}
	//		pTable->MoveNext();
	//	}
	//}

	//while(!pTable->IsEOF())
	//{
	//	pTable->Delete();
	//	pTable->MoveNext();
	//}
	//pTable->Pack();
	return TRUE;
}

///////////////////////////////////////////////////////////////////
// CArchTextLibDlg 对话框
double	g_nDimHeight = 3.5, g_nScaleDim = 0.8;
CString g_csDimStyle = _T("STANDARD");

// add by xly on 101014 初始化静态数据
CString CArchTextLibDlg::m_csTextStyle = g_csDimStyle;

// add by xly on 101222 初始化字高的静态变量
CString CArchTextLibDlg::m_csHeight = _T("3.5");

IMPLEMENT_DYNAMIC(CArchTextLibDlg, CInsTextDlg)
CArchTextLibDlg::CArchTextLibDlg(CWnd* pParent /*=NULL*/)
	: CInsTextDlg(CArchTextLibDlg::IDD, pParent)
{
	m_iAlign = 6;
	// delete by xly on 101222 修改为静态变量
	//m_csHeight = _T("");

	// delete by xly on 101014 记录文字样式
	//m_csTextStyle = g_csDimStyle;
	m_iRunMode = 0;
}

CArchTextLibDlg::~CArchTextLibDlg()
{
}

void CArchTextLibDlg::DoDataExchange(CDataExchange* pDX)
{
	CInsTextDlg::DoDataExchange(pDX);
	DDX_CBIndex(pDX, IDC_COMBO_ALIGN, m_iAlign);
	DDX_CBString(pDX, IDC_COMBO_TEXTHEIGHT, m_csHeight);
	DDX_CBString(pDX, IDC_COMBO_TEXTSTYLE, m_csTextStyle);
	DDX_Control(pDX, IDC_COMBO_TEXTSTYLE, m_comboStyle);
	DDX_Control(pDX, IDC_BUTTON_FILE, m_buttonFile);
}


BEGIN_MESSAGE_MAP(CArchTextLibDlg, CInsTextDlg)
	ON_LBN_DBLCLK(IDC_DRAG_NAME, OnLbnDblclkDragName)
	ON_BN_CLICKED(IDC_BUTTON_FILE, OnBnClickedButtonFile)
	ON_BN_CLICKED(IDC_EXPORT, OnExport)
	ON_BN_CLICKED(IDC_BUTTON_REPLACE, OnButtonReplace)
	ON_BN_CLICKED(IDC_BUTTON_PICK, OnButtonPick)
	ON_WM_CLOSE()
	ON_WM_TIMER()
//	ON_BN_CLICKED(IDC_ADDTOLIB, &CArchTextLibDlg::OnBnClickedAddtolib)
END_MESSAGE_MAP()

// add by xly 0n 101015 获得图中所有文字样式
void LoadTextStyle(XStringList &lstStyle)
{
	AcDbDatabase *pCurDwg=acdbCurDwg();
	AcDbTextStyleTable* pTT;
	VERIFY(pCurDwg->getSymbolTable(pTT, AcDb::kForRead)==Acad::eOk);

	AcDbTextStyleTableIterator* pIter = NULL;
	VERIFY(pTT->newIterator(pIter)==Acad::eOk);
	pTT->close();
	for (pIter->start(); !pIter->done(); pIter->step())
	{
		AcDbTextStyleTableRecord* pTTR;
		if (pIter->getRecord(pTTR, AcDb::kForRead) != Acad::eOk)
			continue;
		const TCHAR* pName = NULL;
		if (pTTR->getName(pName) == Acad::eOk && pName != NULL)
		{
			if(lstStyle.Index(pName) < 0 )		// 如果没有重复  
				lstStyle.Append(tstrnew(pName));   // 读字体风格
		}
		pTTR->close();
	}
	delete pIter; 
}
// CArchTextLibDlg 消息处理程序
BOOL CArchTextLibDlg::OnInitDialog()
{
	CInsTextDlg::OnInitDialog();
	// delete by xly on 101222 修改为静态变量
	// 字高
	//m_csHeight.Format(_T("%.1f"), g_nDimHeight);
	((CComboBox*)GetDlgItem(IDC_COMBO_TEXTHEIGHT))->SelectString(-1, m_csHeight);
	
	// modify by xly 0n 101015 获得图中所有文字样式,文字样式不用全部大写
	// 字体样式
    /*XSymbolList lstStyle(_T("STYLE"));
	for (int i =0; i<lstStyle.Length(); i++)
		m_comboStyle.AddString(lstStyle[i]);*/
	XStringList lstStyle;
	LoadTextStyle(lstStyle);


	// add by xly on 110310保存文字样式到图纸中
	m_csTextStyle = DocGetTgSingleTextStyle();

	// add by xly on 110106 如果使用新创建的文字样式，图纸切换时产生bug
	bool bIsHas(false);// 标记文字样式中，是否有当前样式
	for (int m =0; m < lstStyle.Length(); m++) 
	{
		m_comboStyle.AddString(lstStyle[m]);
		
		// 标记文字样式中有当前样式
		if (lstStyle[m] == m_csTextStyle)
		{
			bIsHas = true;
		}
	}
	// 没有当前样式，设置默认样式Stantard
	if (!bIsHas)
	{
		TCHAR sStyle[256]=_T("");
		xg_getvar(_T("TEXTSTYLE"), sStyle);
		m_csTextStyle = sStyle;
	}

	// add by xly on 110429 文字样式不存在
	if (m_csTextStyle.IsEmpty())
	{
		TCHAR sStyle[256]=_T("");
		xg_getvar(_T("TEXTSTYLE"), sStyle);
		m_csTextStyle = sStyle;
	}

	m_comboStyle.SelectString(-1, m_csTextStyle);

	// add by xly on 110311 保存文字样式到图纸中，更新空间显示
	m_comboStyle.SetCurSel(m_comboStyle.FindStringExact(0, m_csTextStyle));
	//SetTimer(1, 200, NULL);removed by whl
	return TRUE;
}

void CArchTextLibDlg::OnLbnDblclkDragName()
{
	return;
}

// Zyu modify on 100726，支持64位
//void CArchTextLibDlg::OnTimer(UINT nIDEvent)
void CArchTextLibDlg::OnTimer(UINT_PTR nIDEvent)
{
	CPoint point;
	GetCursorPos(&point);
	CRect rect;
	GetWindowRect(&rect);
	if(rect.PtInRect(point))
	{
		if(!m_bInDialog)
		{
			this->SetFocus();
			m_bInDialog = TRUE;
		}
	}
	else
	{
		if(m_bInDialog)
		{
			acedGetAcadDwgView()->SetFocus();
			m_bInDialog = FALSE;
		}
	}

	CInsTextDlg::OnTimer(nIDEvent);
}
void CArchTextLibDlg::OnExport()
{
	SetFileApisToOEM();
	CFileDialog dlg(FALSE, _T("xml"), _T("词库"), OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT
		, _T("xml文档(*.xml)|*.xml|文本文挡(*.txt)|*.txt||"));

	if(dlg.DoModal() != IDOK)
		return;
	
	CStdioFile file;
	if(!file.Open(dlg.GetFileName(), CFile::modeCreate|CFile::modeWrite))
	{
		MessageBox(CString(_T("打开"))+dlg.GetFileName()+_T("失败!"));
		return;
	}
	CString strTem = dlg.GetFileName();
	int i=0;
	for (i=0;i<strTem.GetLength();i++)
	{
		TCHAR ch = strTem.GetAt(i);
		if (ch == '.')
		{
			break;
		}
	}
	strTem.Delete(0,i+1);
	if (m_pXMlDoc==NULL)
	{
		return;
	}
	HTREEITEM hItem = m_treeNames.GetSelectedItem();
	HTREEITEM hRoot = m_treeNames.GetRootItem();
	CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hItem));
	if (!strTem.CompareNoCase(_T("txt")))
	{
		if (hRoot == hItem)
		{
			CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->GetRoot();
			ExportTxt(file,pXMLDOMNodePtr);
		}
		else
		{
			if (pData)
			{
				CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
				ExportTxt(file,pXMLDOMNodePtr);
			}
		}
		file.Close();
	}
	else
	{
		file.Close();
		CString strVersion = m_pXMlDoc->GetVersion();
		CString ss = dlg.GetPathName();
		if (BuildDynamicXMLwithProcessingInstruction(ss))
		{
			int i =0;
		}	
	}
}
BOOL CArchTextLibDlg::BuildDynamicXMLwithProcessingInstruction(CString&strPath)
{

	int nLen = strPath.GetLength();
	TCHAR *szPath = new TCHAR[nLen+1];
	assert( NULL!= szPath );
	if( NULL == szPath )
	{
		return FALSE;
	}
	_tcscpy( szPath,strPath.GetBuffer(nLen));
	BOOL bResult = FALSE;
	strPath.ReleaseBuffer();
	MSXML2::IXMLDOMDocument2Ptr pXMLDOMDocument=NULL;
	MSXML2::IXMLDOMProcessingInstructionPtr pIXMLDOMProcessingInstruction=NULL;
	MSXML2::IXMLDOMNodePtr pIXMLDOMNode = NULL;
	HRESULT hr ;
//	BSTR bstrValue ;
	try
	{
		/*hr=CoCreateInstance(CLSID_DOMDocument26, NULL,CLSCTX_ALL , 
			IID_IXMLDOMDocument2, (LPVOID*)(&pXMLDOMDocument));*/
		// Zyu modify on 100727，支持64位
		hr =pXMLDOMDocument.CreateInstance( __uuidof( MSXML2::DOMDocument60 ) );
		SUCCEEDED(hr) ? 0 : throw hr;
		if(pXMLDOMDocument)
		{
			pIXMLDOMProcessingInstruction = pXMLDOMDocument->createProcessingInstruction(_T("xml"),
				_T("version='1.0' encoding='utf-8'"));
			if(pIXMLDOMProcessingInstruction)
			{
				_variant_t   vNullVal;   
				vNullVal.vt   =   VT_NULL;   
				pXMLDOMDocument->insertBefore(pIXMLDOMProcessingInstruction,vNullVal);
				_variant_t   varNodeType((short)MSXML2::NODE_ELEMENT);
				HTREEITEM hParent = m_treeNames.GetRootItem();
				CXMLNodeInfo *pParentData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hParent));
				pIXMLDOMNode=pXMLDOMDocument->createNode(varNodeType,c_szTDWord,_T(""));
				if (pParentData->m_strNodeName!=_T(""))
				{
					if (pIXMLDOMNode)
					{
						MSXML2::IXMLDOMElementPtr pXMLDOMElement = NULL;
						pXMLDOMElement = static_cast< MSXML2::IXMLDOMElementPtr >(pIXMLDOMNode);
						if (pXMLDOMElement)
						{
							if (pParentData->m_strNodeAttributeName!=_T("")
								&&pParentData->m_strNodeAttributeValue!=_T(""))
							{
								pXMLDOMElement->setAttribute( _bstr_t(pParentData->m_strNodeAttributeName), _variant_t((TCHAR*)(pParentData->m_strNodeAttributeValue.GetBuffer(0))));
							}
						}
					}
				}
				if (pIXMLDOMNode!=NULL)
				{
					pXMLDOMDocument->appendChild(pIXMLDOMNode);
					pIXMLDOMNode->appendChild(pXMLDOMDocument->createTextNode("\n"));
				}
				if(SUCCEEDED(hr))
				{
					bResult=TRUE;
				}
				if (pIXMLDOMNode)
				{
					HTREEITEM hItem = m_treeNames.GetSelectedItem();
					HTREEITEM hRoot = m_treeNames.GetRootItem();
 					if (hItem == hRoot)
 					{
 						CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->GetRoot();
 						CString strNodeName = pXMLDOMNodePtr->GetNodeName();
 						CXMLDOMNodesPtr pNodes = pXMLDOMNodePtr->GetChildrenNodes(strNodeName);
 						int nCount = pNodes->GetCount();
 						int i =0;
 						for (;i<nCount;i++)
 						{
 							VARIANT_BOOL vb = VARIANT_TRUE;
 							MSXML2::IXMLDOMNodePtr pTemIXMLDOMNodePtr = NULL;
 							CXMLDOMNodePtr pTemXMLDOMNodePtr = pNodes->GetItem(i);
 							pTemIXMLDOMNodePtr = pTemXMLDOMNodePtr->GetNodePtr();
 							MSXML2::IXMLDOMNodePtr pChild = NULL;
 							pChild = pTemIXMLDOMNodePtr->cloneNode(vb);
 							pIXMLDOMNode->appendChild(pChild);
							if (pChild!=NULL)
 							{
 								pChild.Release();
 							}
 						}
 					}
					else
					{
						CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hItem));
						if (pData)
						{
							CString strXPath = pData->m_strNodeXPath;
							HTREEITEM hFather = m_treeNames.GetParentItem(hItem);;
							//if (hItem==hRoot)
							//{
							//	hFather = hRoot;
							//}
							XMLNodeInfoArray aryNodeInfo;
							while(hFather !=hRoot)
							{
								CXMLNodeInfo *pParentData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hFather));
								CXMLNodeInfo InfoTem(*pParentData);
								if (InfoTem.m_strNodeName!=c_szTDWord)
								{
									aryNodeInfo.AddTail(InfoTem);
								}
								hFather = m_treeNames.GetParentItem(hFather);
							}
							aryNodeInfo.Reverse();
							int nNum = aryNodeInfo.GetLength();
							MSXML2::IXMLDOMNodePtr pTemFatherIXMLDOMNodePtr = pIXMLDOMNode;
							int i=0;
							for (;i<nNum;i++)
							{
								VARIANT_BOOL vb = VARIANT_FALSE;
								CXMLNodeInfo InfoTem = aryNodeInfo.GetAt(i);
								CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(InfoTem.m_strNodeXPath);
								MSXML2::IXMLDOMNodePtr pTemIXMLDOMNodePtr = NULL;
								MSXML2::IXMLDOMNodePtr pClone = NULL;
								pTemIXMLDOMNodePtr = pXMLDOMNodePtr->GetNodePtr();
								pClone = pTemIXMLDOMNodePtr->cloneNode(vb);
								pTemFatherIXMLDOMNodePtr = pTemFatherIXMLDOMNodePtr->appendChild(pClone);
								if (pClone!=NULL)
								{
									pClone.Release();
								}
							}
							CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
							MSXML2::IXMLDOMNodePtr pTemIXMLDOMNodePtr = NULL;
							pTemIXMLDOMNodePtr = pXMLDOMNodePtr->GetNodePtr();
							VARIANT_BOOL vb = VARIANT_TRUE;
							MSXML2::IXMLDOMNodePtr pClone = NULL;
							pClone = pTemIXMLDOMNodePtr->cloneNode(vb);
							pTemFatherIXMLDOMNodePtr->appendChild(pClone);
							if (pClone!=NULL)
							{
								pClone.Release();
							}
							if (pTemFatherIXMLDOMNodePtr != pIXMLDOMNode)
							{
								if (pTemFatherIXMLDOMNodePtr!=NULL)
								{
									pTemFatherIXMLDOMNodePtr.Release();
								}
							}
						}
					}
					//xsl样式单 
					CString strMyStyle = _T("<?xml version=\"1.0\"?>\n<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">\n<xsl:output method = \"xml\"  omit-xml-declaration = \"yes\" indent = \"yes\"/>\n<xsl:template match=\"/ | @* | node()\">\n<xsl:copy>\n<xsl:apply-templates select=\"@* | node()\"/>\n</xsl:copy>\n</xsl:template>\n</xsl:stylesheet>");
					IXMLDOMDocument2Ptr pStyle=NULL;
					// Zyu modify on 100727，支持64位
					hr = pStyle.CreateInstance(__uuidof( MSXML2::DOMDocument60 ));
					CString strStyle(strMyStyle);
					pStyle->loadXML(strStyle.AllocSysString());
					CString strTest((BSTR)(pXMLDOMDocument->xml));
					IXMLDOMDocument2Ptr pNew=NULL;
					// Zyu modify on 100727，支持64位
					hr = pNew.CreateInstance(__uuidof(MSXML2::DOMDocument60));
					pNew->loadXML(pXMLDOMDocument->transformNode(pStyle));
					CString strNew((BSTR)(pNew->xml));
					strNew=CString("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")+strNew;
					pNew.Release();
					// Zyu modify on 100727，支持64位
					pNew.CreateInstance(__uuidof(MSXML2::DOMDocument60));
					pNew->loadXML(strNew.AllocSysString());
					if( NULL != pXMLDOMDocument )
					{
						pXMLDOMDocument.Release();
					}
					pXMLDOMDocument =  NULL;
					hr = pNew->save(_variant_t((TCHAR*)szPath));
					SUCCEEDED(hr) ? 0 : throw hr;
					pIXMLDOMNode.Release();
					pNew.Release();
					pNew = NULL;
				}
				if (pIXMLDOMProcessingInstruction)
				{
					pIXMLDOMProcessingInstruction.Release();
				}
			}
			
			if (pXMLDOMDocument!=NULL)
			{
				pXMLDOMDocument.Release();
			}
		}
	}
	catch(...)
	{
		if (pIXMLDOMNode)
		{
			pIXMLDOMNode.Release();
		}
		if (pIXMLDOMProcessingInstruction)
		{
			pIXMLDOMProcessingInstruction.Release();
		}
		if (pXMLDOMDocument)
		{
			pXMLDOMDocument.Release();
		}
	}
	return bResult;
}
void CArchTextLibDlg::ExportTxt(CStdioFile &file,const CXMLDOMNodePtr &pXmlNode)
{
	CXMLDOMNodesPtr pXMLNodeList = pXmlNode->GetChildrenNodes(pXmlNode->GetNodeName());
	int count = pXMLNodeList->GetCount();
	CString strNodeName = pXmlNode->GetNodeName();
	if(count==0&&strNodeName == c_szLemma) 
	{
		CXMLNodeInfo xmlNodeInfo = GetNodeInfoEx(pXmlNode,m_pXMlDoc);
		xmlNodeInfo.m_strNodeValue.TrimLeft();
		xmlNodeInfo.m_strNodeValue.TrimRight();
		if (xmlNodeInfo.m_strNodeValue==_T(""))
		{
			file.WriteString(xmlNodeInfo.m_strNodeAttributeValue);
		}
		else
		{
			file.WriteString(xmlNodeInfo.m_strNodeValue);
		}
		file.WriteString(_T("\n"));
		return;
	}
	int i=0;
	for(i=0; i<count; i++)
	{
		CXMLDOMNodePtr pChildNode = pXMLNodeList->GetItem(i);
		CString strAttriName = pChildNode->GetAttributeName();
		CString strAttriValve = pChildNode->GetAttributeValue(strAttriName);
		if (strAttriValve == c_szLate)
		{
			continue;
		}
//		HTREEITEM hSubItem;
		ExportTxt(file,pChildNode);//递归子节点
	}
}
void CArchTextLibDlg::ReadTxt(HTREEITEM hItem,const CString &strPath,CXMLDOMNodePtr&pXMLDOMNodePtr)
{
	CStdioFile file;
	if(!file.Open(strPath, CFile::modeRead))
	{
		MessageBox(CString(_T("打开"))+strPath+_T("失败!"));
		return;
	}
	while(file.ReadString(m_szName))
	{
		CNameString *pString=CreateNameString();
		if(pString==NULL)
			continue;
		if (m_bSort)
		{
			if(m_sortNames.FindStringExact(-1,*pString)>=0)
			{
				MessageBox(CString(_T("<"))+*pString+_T(">项已经存在!"));
				delete pString;
				continue;
			}
		} 
		else
		{
			if(m_dragNames.FindStringExact(-1,*pString)>=0)
			{
				MessageBox(CString(_T("<"))+*pString+_T(">项已经存在!"));
				delete pString;
				continue;
			}
		}
		CXMLNodeInfo xmlInfo;
		xmlInfo.m_bLeafNode = TRUE;
		xmlInfo.m_strNodeName = c_szLemma;
		xmlInfo.m_strNodeValue = m_szName;
		xmlInfo.m_strNodeAttributeName = c_szName;
		xmlInfo.m_strNodeAttributeValue = *pString;
		CXMLDOMNodePtr pTem =pXMLDOMNodePtr->AppendNode(xmlInfo.m_strNodeName,xmlInfo.m_strNodeValue,
			xmlInfo.m_strNodeAttributeName,xmlInfo.m_strNodeAttributeValue);
		m_pXMlDoc->GetCurNodeXPath(pTem,xmlInfo.m_strNodeXPath);
		//m_pXMlDoc->Save();
		m_dragNames.AddStringEx(*pString,&xmlInfo);
	}
	file.Close();
}
void CArchTextLibDlg::ReadXml(HTREEITEM hItem,const CString &strPath,CXMLDOMNodePtr&pXMLDOMNodePtr)
{
	int nLen = strPath.GetLength();
	const TCHAR* strFileName = strPath;
	MSXML2::IXMLDOMDocument2Ptr pXMLDOMDocument=NULL;
	HRESULT hr ;
//	BSTR bstrValue ;
	// Zyu modify on 100727，支持64位
	hr =pXMLDOMDocument.CreateInstance( __uuidof( MSXML2::DOMDocument60 ) );
	SUCCEEDED(hr) ? 0 : throw hr;
	pXMLDOMDocument->async = VARIANT_TRUE;
	if (pXMLDOMDocument->load(strFileName) == VARIANT_TRUE)
	{
		MSXML2::IXMLDOMElementPtr pRoot =NULL;
		pXMLDOMDocument->get_documentElement(&pRoot);
		CXMLDOMNodePtr pRootNode( new CXMLDOMNode( pRoot ) );
		CString strNodeName = pRootNode->GetNodeName();
		CXMLDOMNodesPtr pNodesList=pRootNode->GetChildrenNodes(strNodeName);
		int nCount = pNodesList->GetCount();
		if (strNodeName == _T("上华词库"))
		{
			int i=0;
			while(pNodesList->GetCount()>0)//for (i=0;i<pNodesList->GetCount();i++)
			{
				CXMLDOMNodePtr pTemNode = pNodesList->GetItem(0);
				//i--;
				if (pTemNode->GetNodePtr() !=NULL)
				{
					CString strNodeName = pTemNode->GetNodeName();
					CString strAttriName = pTemNode->GetAttributeName();
					CString strAttriValue = pTemNode->GetAttributeValue(strAttriName);
					CXMLDOMNodePtr pRetNode( new CXMLDOMNode( NULL ) );
					BOOL bDelete = TRUE;
					if (pXMLDOMNodePtr->IsChildNodeExist(strNodeName,strAttriName,strAttriValue,pRetNode))
					{
						CString str = _T("发现相同目录\"")+strAttriValue+_T("\"，是否用新目录内容替换？");
						if (MessageBox(str,NULL,MB_OKCANCEL) ==IDOK )
						{
							pRetNode->InsertBefore(pTemNode);
							pRetNode->DeleteNode();
						}
					}
					else
					{
						pXMLDOMNodePtr->AppendNode(pTemNode);
						bDelete = FALSE;
					}
				}
			}
		} 
		else
		{
			MessageBox(_T("请选择词库文件！"));
		}
		if (pRoot!=NULL)
		{
			pRoot.Release();
			pRoot = NULL;
		}
	}
	if (pXMLDOMDocument!=NULL)
	{
		pXMLDOMDocument.Release();
		pXMLDOMDocument = NULL;
	}
	return;
}
void CArchTextLibDlg::ReadDbf(HTREEITEM hItem,const CString &strPath,CXMLDOMNodePtr&pXMLDOMNodePtr)
{
	CodeBase db;
	XString fullFile;
	//if(!FindFile(_T("dict.dbf"), fullFile)) 
	//{
	//	MessageBox(_T("对不起，没有发现dict.dbf文件！"));
	//	return ;
	//}
	CString strFileName = strPath;
	strFileName.MakeReverse();
	int nPos = strFileName.Find(_T("\\"),0);
	strFileName = strFileName.Mid(0,nPos);
	strFileName.MakeReverse();
	nPos = strFileName.Find(_T("."),0);
	strFileName = strFileName.Mid(0,nPos);
	if (strFileName.CompareNoCase(_T("dict")))
	{
		MessageBox(_T("此文件不是词库文件!"));
		return;
	}
	XDbfTable *pTable = db.Open(strPath);
	if(!pTable) 
	{
		MessageBox(_T("打开dict.dbf文件出错!"));
		return;
	}
	CString szType, szName ,szContent0,szContent1,szContent2,szContent3;
	TARCHWORDLIBDBFMAP wordlibmap;
	pTable->MoveFirst();
	while(!pTable->IsEOF())	
	{
		GET_FIELD(pTable, _T("type"), szType);
		GET_FIELD(pTable, _T("name"), szName);
		//add by whl
		GET_FIELD(pTable, _T("content0"),szContent0);
		GET_FIELD(pTable, _T("content1"),szContent1);
		GET_FIELD(pTable, _T("content2"),szContent2);
		GET_FIELD(pTable, _T("content3"),szContent3);
		CString strValue = szContent0+szContent1+szContent2+szContent3;
		int n0  = 0;
		szContent0.Find('\r',n0);
		int n1 = 0;
		szContent1.Find('\r',n1);
		TARCHWORDLIBDBFMAP::iterator iter;
		iter = wordlibmap.find(szType);
		WordLibDbfInfo dbInfo;
		dbInfo.m_strAttrivalue = szName;
		dbInfo.m_strvalue = strValue;
		if (iter!=wordlibmap.end())
		{
			wordlibmap[szType].AddTail(dbInfo);
		}
		else
		{
			DBFArray ary;
			ary.AddTail(dbInfo);
			wordlibmap.insert(TARCHWORDLIBDBFMAP::value_type(szType,ary));
		}
		pTable->MoveNext();
	}
	CXMLDOMNodePtr pRoot = m_pXMlDoc->GetRoot();
	CString strName = pRoot->GetNodeName();
	CXMLDOMNodesPtr pList = pRoot->GetChildrenNodes(strName);
	int nCount = pList->GetCount();
	int i =0;
	BOOL bHas = FALSE;
	for (i=0;i<nCount;i++)
	{
		CXMLDOMNodePtr pChild = pList->GetItem(i);
		CString strChildName = pChild->GetAttributeName();
		CString strChildValue = pChild->GetAttributeValue(strChildName);
		TARCHWORDLIBDBFMAP::iterator iter;
		iter = wordlibmap.find(strChildValue);
		if (iter!=wordlibmap.end())
		{
			CString strNodeName = pChild->GetNodeName();
			if (pChild->HasChildNodes())
			{
				DBFArray aryDbf = iter->second;
				int k =0,nLen =0;
				nLen = aryDbf.GetLength();
				for (k=0;k<nLen;k++)
				{
					WordLibDbfInfo dbfInfo = aryDbf.GetAt(k);
					if (!pChild->IsChildNodeExist(c_szLemma,c_szName,dbfInfo.m_strAttrivalue))
					{
						pChild->AppendNode(c_szLemma,dbfInfo.m_strvalue,c_szName,
							dbfInfo.m_strAttrivalue);
					}
				}
			}
			else
			{
				DBFArray aryDbf = iter->second;
				int k =0,nLen =0;
				nLen = aryDbf.GetLength();
				for (k=0;k<nLen;k++)
				{
					WordLibDbfInfo dbfInfo = aryDbf.GetAt(k);
					pChild->AppendNode(c_szLemma,dbfInfo.m_strvalue,c_szName,
										dbfInfo.m_strAttrivalue);
				}
			}
			wordlibmap.erase(iter);
		}
		
	}
	TARCHWORDLIBDBFMAP::iterator iter = wordlibmap.begin();
	for (;iter!=wordlibmap.end();iter++)
	{
		DBFArray aryDbf = iter->second;
		CXMLDOMNodePtr pChild = pRoot->AppendNode(c_szCatalog,_T(""),c_szName,iter->first);
		int k =0,nLen =0;
		nLen = aryDbf.GetLength();
		for (k=0;k<nLen;k++)
		{
			WordLibDbfInfo dbfInfo = aryDbf.GetAt(k);
			pChild->AppendNode(c_szLemma,dbfInfo.m_strvalue,c_szName,
				dbfInfo.m_strAttrivalue);
		}
	}
	//m_pXMlDoc->Save();

}
void CArchTextLibDlg::OnBnClickedButtonFile()
{
	CFileDialog dlg(TRUE, _T("xml"), _T("*.xml"), OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT
		, _T("xml文档(*.xml)|*.xml|dbf文档(*.dbf)|*.dbf|文本文挡(*.txt)|*.txt||"));
	if(dlg.DoModal() != IDOK)
		return;
	CString strPath = dlg.GetPathName();
	CString strTem = dlg.GetFileName();
	int i=0;
	for (i=0;i<strTem.GetLength();i++)
	{
		TCHAR ch = strTem.GetAt(i);
		if (ch == '.')
		{
			break;
		}
	}
	strTem.Delete(0,i+1);
	HTREEITEM hItem = m_treeNames.GetSelectedItem();
	HTREEITEM hRoot = m_treeNames.GetRootItem();
	if (hRoot==hItem)
	{
		if (m_pXMlDoc!=NULL)
		{
			CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->GetRoot();
			if (!strTem.CompareNoCase(_T("txt")))
			{
				ReadTxt(hItem,strPath,pXMLDOMNodePtr);
			}
			else if (!strTem.CompareNoCase(_T("xml")))
			{
				ReadXml(hItem,strPath,pXMLDOMNodePtr);
			}
			else
			{
				ReadDbf(hItem,strPath,pXMLDOMNodePtr);
			}
		}
	}
	else
	{
		if (m_pXMlDoc!=NULL)
		{
			CXMLNodeInfo *pData = (CXMLNodeInfo*)(m_treeNames.GetItemData(hItem));
			CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMlDoc->SelectSingleNode(pData->m_strNodeXPath);
			if (!strTem.CompareNoCase(_T("txt")))
			{
				ReadTxt(hItem,strPath,pXMLDOMNodePtr);
			}
			else if (!strTem.CompareNoCase(_T("xml")))
			{
				ReadXml(hItem,strPath,pXMLDOMNodePtr);
			}
			else
			{
				ReadDbf(hItem,strPath,pXMLDOMNodePtr);
			}
		}
	}
	DeleteTree();
	InitTree();
}

void CArchTextLibDlg::OnButtonReplace() 
{
	m_iRunMode = 1;
	acedGetAcadDwgView()->SetFocus();
	PostCommand(_T("` "), false);
}

void CArchTextLibDlg::OnButtonPick() 
{
	m_iRunMode = 2;
	acedGetAcadDwgView()->SetFocus();
	PostCommand(_T("` "), false);
}

void CArchTextLibDlg::OnClose()
{
	CInsTextDlg::OnClose();
	acedPostCommand(_T("\33\33"));	
}

void CArchTextLibDlg::SetTextStyle(const TCHAR* szStyle)
{
    CString csStyle = szStyle;
    int len = m_comboStyle.GetCount();
    for(int i=0;i<len;i++){
        CString csTmp;
        m_comboStyle.GetLBText(i, csTmp);
        if(csTmp == csStyle){
            m_csTextStyle = szStyle;
            m_comboStyle.SetCurSel(i);
            return;
        }
    }
}


//*******************************************************************************
//                              TTextEdJig
//*******************************************************************************
XExplodeDraw::TextAlignment	TTextEdJig::m_AlignList[] = {   XExplodeDraw::kTopLeft, XExplodeDraw::kTopCenter , 
						  XExplodeDraw::kTopRight, XExplodeDraw::kMiddleLeft ,
						  XExplodeDraw::kMiddleCenter, XExplodeDraw::kMiddleRight ,
						  XExplodeDraw::kBottomLeft, XExplodeDraw::kBottomCenter ,
						  XExplodeDraw::kBottomRight,};

TTextEdJig::TTextEdJig(BOOL bIsTg, XPoint pt, double nHeight, const TCHAR*szText, AcDbObjectId idStyle, double nRotation)
{
	m_pDlg = NULL;
	m_pText = NULL;
	m_pAcadText = NULL;
	m_bIsTgText = bIsTg;
	if(m_bIsTgText){
		m_pText = new TDbText();
		m_pText->SetStyleId(idStyle);
		m_pText->SetRotation(nRotation);
		m_pText->SetHeight(nHeight);
		m_pText->SetText(szText);
		m_pText->SetLocation(pt);
	}
	else{
		m_pAcadText = new AcDbText();
		m_pAcadText->setRotation(nRotation);
		m_pAcadText->setHeight(nHeight);
		m_pAcadText->setTextString(szText);
		m_pAcadText->setTextStyle(idStyle);
		m_pAcadText->setPosition(pt);
		m_pAcadText->setAlignmentPoint(pt);
	}
}

TTextEdJig::TTextEdJig(CArchTextLibDlg *dlg, XPoint pt)
{
	m_pDlg = dlg;
	m_pAcadText = NULL;
	dlg->UpdateData(TRUE);
	AcDbObjectId idTextStyle = GetTextStyleId(dlg->m_csTextStyle);

	m_pText = new TDbText();
	m_pText->SetStyleId(idTextStyle);
	m_pText->SetHeight(_tstof(dlg->m_csHeight));
	m_pText->SetText(dlg->GetEditText());
	m_pText->SetLocation(pt);
	m_pText->SetAlignment(m_AlignList[dlg->m_iAlign]);
}

TTextEdJig::~TTextEdJig()
{
	if(m_pText)
		delete m_pText;


	if(m_pAcadText)
		delete m_pAcadText;
}


AcEdJig::DragStatus 
TTextEdJig::GetPoint(XPoint &pt)
{
	if(!m_ptRef)
		return acquirePoint(pt);
	else
		return acquirePoint(pt, m_ptRef);
}

 
int TTextEdJig::DoIt(int *keyIndex)
{
    int nRet = TSymbEdJig::DoIt(keyIndex);
    return nRet;
}

// 更新实体数据
Adesk::Boolean TTextEdJig::update()
{
    Adesk::Boolean bRet=Adesk::kTrue;
	if(m_pDlg){
		m_pDlg->UpdateData(TRUE);
		AcDbObjectId idTextStyle = GetTextStyleId(m_pDlg->m_csTextStyle);
		m_pText->SetStyleId(idTextStyle);
		m_pText->SetHeight(_tstof(m_pDlg->m_csHeight));
		m_pText->SetText(m_pDlg->GetEditText());
		m_pText->SetLocation(m_ptResult);
        m_pText->SetRotation(Ucs2Wcs(0.0));//支持UCS

		CString sTemp(m_pDlg->GetEditText());
		if(sTemp.Find(_T("\n"))>=0||sTemp.Find(_T("\r"))>=0)//多行文字
			m_pText->SetAlignment(XExplodeDraw::kTopLeft);
		else
			m_pText->SetAlignment(m_AlignList[m_pDlg->m_iAlign]);
	}
	else{
		if(m_pText)
			m_pText->SetLocation(m_ptResult);
		if(m_pAcadText){
			m_pAcadText->setAlignmentPoint(m_ptResult);
			XPoint ptInsert = m_ptResult;
			ptInsert.TransformBy(m_AcadTextMat);
			m_pAcadText->setPosition(ptInsert);
		}
	}
	return bRet;
}

AcDbEntity* TTextEdJig::entity() const
{
	if(m_pDlg){
		return (AcDbEntity *)m_pText;
	}
	else{
		if(m_bIsTgText)
			return (AcDbEntity *)m_pText;
		else
			return (AcDbEntity *)m_pAcadText;
	}
	return NULL;
}

 
void TTextEdJig::SetAlign(AcDb::TextVertMode vertMode, AcDb::TextHorzMode horzMode, AcGeMatrix3d mat)
{
	if(m_pAcadText){
		m_pAcadText->setVerticalMode(vertMode);
		m_pAcadText->setHorizontalMode(horzMode);
		m_AcadTextMat = mat;
	}
}

void TTextEdJig::SetAlign(XExplodeDraw::TextAlignment Align)
{
	if(m_pText)
		m_pText->SetAlignment(Align);
}

void TTextEdJig::SetWHScale(double nWHScale)
{
	if(m_pAcadText)
		m_pAcadText->setWidthFactor(nWHScale);
}
//////////////////////////////////////////////////////////////////////
//*******************************************************************************
//                              TMTextEdJig
//*******************************************************************************
XExplodeDraw::TextAlignment	TMTextEdJig::m_AlignList[] = {   XExplodeDraw::kTopLeft, XExplodeDraw::kTopCenter , 
XExplodeDraw::kTopRight, XExplodeDraw::kMiddleLeft ,
XExplodeDraw::kMiddleCenter, XExplodeDraw::kMiddleRight ,
XExplodeDraw::kBottomLeft, XExplodeDraw::kBottomCenter ,
XExplodeDraw::kBottomRight,};

TMTextEdJig::TMTextEdJig(BOOL bIsTg, XPoint pt, double nHeight, const TCHAR*szText, AcDbObjectId idStyle, double nRotation)
{
	m_pDlg = NULL;
	m_pMText = NULL;
	m_pAcadMText = NULL;
	m_bIsTgText = bIsTg;
	m_bSet = FALSE;
	m_dWidth = 0;
	CString str = szText;
	m_strLast = szText;
	if(m_bIsTgText)
	{
		m_pMText = new TDbMText();
		m_pMText->SetStyleId(idStyle);
		m_pMText->SetRotation(nRotation);
		m_pMText->SetHeight(nHeight);
		m_pMText->SetText(szText);
		m_pMText->SetLocation(pt);
		if (str.Find(_T("\n"))>=0||str.Find(_T("\r"))>=0)
		{
			m_pMText->SetLineSpace(1);
			XPoint ptMin,ptMax;
			if(m_pMText->GetExtents2d(ptMin,ptMax)==Acad::eOk)
			{
				ptMin = Wcs2Ucs(ptMin);
				ptMax = Wcs2Ucs(ptMax);
				double width=ptMax.x-ptMin.x+100;
				m_pMText->SetPageWidth(width,FALSE);
			}
		}
	}
	else
	{
		m_pAcadMText = new AcDbMText();
		m_pAcadMText->setRotation(nRotation);
		m_pAcadMText->setTextHeight(nHeight);
		m_pAcadMText->setContents(szText);
		m_pAcadMText->setTextStyle(idStyle);
		m_pAcadMText->setLocation(pt);
	}
	
}

TMTextEdJig::TMTextEdJig(CArchTextLibDlg *dlg, XPoint pt)
{
	m_bSet = FALSE;
	m_pDlg = dlg;
	m_dWidth = 0;
	CString str = dlg->GetEditText();
	m_strLast = str;
	dlg->UpdateData(TRUE);
	AcDbObjectId idTextStyle = GetTextStyleId(dlg->m_csTextStyle);
	m_pAcadMText = NULL;
	m_pMText = new TDbMText();
	m_pMText->SetStyleId(idTextStyle);
	m_pMText->SetHeight(_tstof(dlg->m_csHeight));
	str.TrimLeft();
	str.TrimRight();
	m_pMText->SetText(str);
	m_pMText->SetLocation(pt);
	if (str.Find(_T("\n"))>=0||str.Find(_T("\r"))>=0)
	{
		m_pMText->SetAlignment(XExplodeDraw::kLeft/*m_AlignList[dlg->m_iAlign]*/);
		m_pMText->SetLineSpace(1);
		m_pMText->SetPageWidth(0,FALSE);
		XPoint ptMin,ptMax;
		//ptMin = m_pMText->GetExtents();
		if(m_pMText->GetExtents2d(ptMin,ptMax)==Acad::eOk)
		{
			ptMin = Wcs2Ucs(ptMin);
			ptMax = Wcs2Ucs(ptMax);
			double width=ptMax.x-ptMin.x+Wcs2Ucs(100);
			//width = Ucs2Wcs(width);
			m_pMText->SetPageWidth(width,FALSE);
		}
	}
	else
	{
		m_pMText->SetAlignment(m_AlignList[dlg->m_iAlign]);
	}
}

TMTextEdJig::~TMTextEdJig()
{
	if(m_pMText)
		delete m_pMText;
	if(m_pAcadMText)
		delete m_pAcadMText;
}


AcEdJig::DragStatus TMTextEdJig::GetPoint(XPoint &pt)
{
	AcEdJig::DragStatus st;
	if(!m_ptRef)
	{
		st = acquirePoint(pt);
	}
	else
	{
		st = acquirePoint(pt, m_ptRef);
	}
	return st;
}

int TMTextEdJig::DoIt(int *keyIndex)
{
	//AfxTrace(_T("\nDoit1"));
	//ads_printf(_T("\nDoit1"));
	int nRet = TSymbEdJig::DoIt(keyIndex);
	//ads_printf(_T("\nDoit2"));
	//AfxTrace(_T("\nDoit2"));
	return nRet;
}

// 更新实体数据
Adesk::Boolean TMTextEdJig::update()
{
//	Sleep(20);
	Adesk::Boolean bRet=Adesk::kTrue;
	if(m_pDlg)
	{
		m_pDlg->UpdateData(TRUE);
		CString str = m_pDlg->GetEditText();
		AcDbObjectId idTextStyle = GetTextStyleId(m_pDlg->m_csTextStyle);
		if (m_pMText)
		{
			m_pMText->SetStyleId(idTextStyle);
			m_pMText->SetHeight((_tstof(m_pDlg->m_csHeight)));
			m_pMText->SetText(m_pDlg->GetEditText());
			m_pMText->SetLocation(m_ptResult);
			m_pMText->SetRotation(Ucs2Wcs(0.0));//支持UCS
			if (str.Find(_T("\n"))>=0||str.Find(_T("\r"))>=0)
			{
				m_pMText->SetLineSpace(1);
				m_pMText->SetAlignment(XExplodeDraw::kLeft);
				m_pMText->SetPageWidth(0,FALSE);//必须加 否则出错
				XPoint ptMin,ptMax,ptTem;
				//double dlen = Wcs2Ucs(100);
				XPoint pt,ptucs;
				pt.x = 100;
				pt.y=0;
				ptucs = Wcs2Ucs(pt);
				if (m_pMText->GetExtents2d(ptMin, ptMax)==Acad::eOk)
				{
					//ptMin = Wcs2Ucs(ptMin);
					//ptMax = Wcs2Ucs(ptMax);
 					if (m_strLast == m_pDlg->GetEditText())
 					{
 						if (!m_bSet)
 						{
							m_dWidth = ptMax.x-ptMin.x+ptucs.x;
 							m_bSet = TRUE;
 						}
 					}
 					else
 					{
						m_dWidth = ptMax.x-ptMin.x+ptucs.x;
 						m_bSet = TRUE;
 						m_strLast = m_pDlg->GetEditText();
 					}
					m_pMText->SetPageWidth(m_dWidth,FALSE);
				}
			}
			m_pMText->SetAlignment(m_AlignList[m_pDlg->m_iAlign]);
		}
	}
	else
	{
		if(m_pMText)
		{
			m_pMText->SetLocation(m_ptResult);
			m_pMText->SetLineSpace(1);
			m_pMText->SetAlignment(XExplodeDraw::kLeft);
			XPoint ptMin,ptMax;
			if(m_pMText->GetExtents2d(ptMin,ptMax)==Acad::eOk)
			{
				double width=ptMax.x-ptMin.x+100;
				m_pMText->SetPageWidth(width,FALSE);
			}
		}
		if(m_pAcadMText)
		{
			XPoint ptInsert = m_ptResult;
			ptInsert.TransformBy(m_AcadTextMat);
			m_pAcadMText->setLocation(ptInsert);
		}
	}
	return bRet;
}

AcDbEntity* TMTextEdJig::entity() const
{
	if(m_pDlg)
	{
		if (m_pMText)
		{
			return (AcDbEntity *)m_pMText;	
		}
		else
		{
			return NULL;
		}
	}
	else
	{
		if(m_bIsTgText)
		{
			if (m_pMText)
			{
				return (AcDbEntity *)m_pMText;
			}
			else
			{
				return NULL;
			}
		}
		else
		{
			if (m_pAcadMText)
			{
				return (AcDbEntity *)m_pAcadMText;
			}
			else
			{
				return NULL;
			}
			
		}
	}
	return NULL;
}


void TMTextEdJig::SetAlign(AcDb::TextVertMode vertMode, AcDb::TextHorzMode horzMode, AcGeMatrix3d mat)
{
	if(m_pAcadMText)
	{
		m_AcadTextMat = mat;
	}
}

void TMTextEdJig::SetAlign(XExplodeDraw::TextAlignment Align)
{
	if(m_pMText)
		m_pMText->SetAlignment(XExplodeDraw::kLeft);
}

void TMTextEdJig::SetWHScale(double nWHScale)
{

}
///////////////////////////////////////////////////
void WordLib()
{
	XString fullFile;
	if(!FindFile(_T("dict.xml"), fullFile)) 
	{
		ads_printf(_T("对不起，没有发现dict.xml文件！"));
		return;
	}
	CString strPath = fullFile.cs();
	CXMLDOMFile *pXMLDoc = new CXMLDOMFile;
	if (pXMLDoc->IsFileExist(strPath))
	{
		if (!pXMLDoc->Open(strPath))
		{
			delete pXMLDoc;
			pXMLDoc = NULL;
			// Zyu modify on 100726，支持64位
#ifndef _WIN64
			ads_printf(_T("打开XML文档失败！请安装MSXML4.0SP2组件"));
#else
			ads_printf(_T("打开XML文档失败！请安装MSXML6.0组件"));
#endif
			return;
		}
	}
	delete pXMLDoc;
	pXMLDoc = NULL;
	CArchTextLibDlg dlg(acedGetAcadFrame());  
    {
    CTemporaryResourceOverride vTemp;
	dlg.Create(dlg.IDD, acedGetAcadFrame());
    }
	dlg.ShowWindow(SW_SHOW);
	acedGetAcadDwgView()->SetFocus();
	XPoint ptText;
	
	int nOsMode=0;
    xg_getvar(_T("OSMODE"), &nOsMode);
    nOsMode &= ~0x4000;
    nOsMode |= OS_INT|OS_NEA;
    XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);
	XPoint ptOld;

	XExplodeDraw::TextAlignment 
	AlignList[] = {   XExplodeDraw::kTopLeft, XExplodeDraw::kTopCenter , 
					  XExplodeDraw::kTopRight, XExplodeDraw::kMiddleLeft ,
					  XExplodeDraw::kMiddleCenter, XExplodeDraw::kMiddleRight ,
					  XExplodeDraw::kBottomLeft, XExplodeDraw::kBottomCenter ,
					  XExplodeDraw::kBottomRight,};
	while(1)
	{
        HWND hwnd = dlg.GetSafeHwnd();
      	if(!dlg.IsWindowVisible()) 
		{//在替换或选取的时候关闭对话框
            break;
        }                
		XPoint ptIns;
		xg_getvar(_T("VIEWCTR"), ptIns);
		ptIns = Ucs2Wcs(ptIns);
		dlg.UpdateData(TRUE);
		if(dlg.m_iRunMode == 1)
		{//替换文字
// 			if (dlg.GetEditText() == _T(""))
// 			{
// 				//字符串为空时候 回到初始状态
// 				acedGetAcadDwgView()->SetFocus();
// 				int nOsMode=0;
// 				xg_getvar(_T("OSMODE"), &nOsMode);
// 				nOsMode &= ~0x4000;
// 				nOsMode |= OS_INT|OS_NEA;
// 				XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);;
// 				continue;
// 			}
			Entity entSel;
			int ret;
			INITGET_BEG(0, _T("`"));
			ret = acedEntSel(_T("\n请选择要替换的文字图元<文字插入>:"), entSel, XPoint());
			//ads_printf(_T("\n插入1"));
			INITGET_END();
			if(ret == RTCAN)
				break;
			else if(ret == RTKWORD)
				continue;
			else if(ret == RTNORM)
			{
				//ads_printf(_T("\n插入2"));
				if(!entSel.Is(_T("TEXT"))&&!entSel.Is(_T("ATS_TEXT"))&&
					!entSel.Is(_T("MTEXT"))&&!entSel.Is(_T("ATS_MTEXT")))
				{
					acutPrintf(_T("\n已滤除1个。"));
					continue;
				}
				AcDbEntity *pent = NULL;
				AcDbObjectId id;
				Acad::ErrorStatus  es;
				es = acdbGetObjectId(id,entSel);
				if (es == Acad::eOk&&dlg.GetEditText()!=_T(""))
				{
					es = acdbOpenAcDbEntity(pent,id,AcDb::kForWrite);
					if (es == Acad::eOk)
					{
						if (pent->isKindOf(TDbText::desc()))
						{
							TDbText *pText = TDbText::cast(pent);
							if (pText)
							{
								pText->SetText(dlg.GetEditText());
							}
						}
						if (pent->isKindOf(TDbMText::desc()))
						{
							TDbMText *pText = TDbMText::cast(pent);
							if (pText)
							{
								pText->SetText(dlg.GetEditText());
							}
						}
						if (pent->isKindOf(AcDbText::desc()))
						{
							AcDbText *pText = AcDbText::cast(pent);
							if (pText)
							{
								pText->setTextString(dlg.GetEditText());
							}
						}
						if (pent->isKindOf(AcDbMText::desc()))
						{
							AcDbMText *pText = AcDbMText::cast(pent);
							if (pText)
							{
								pText->setContents(dlg.GetEditText());
							}
						}
						pent->close();
					}
				}
				//ads_printf(_T("\n插入3"));
				//entSel.SetData(1, dlg.GetEditText());
				//entSel.Modify();
				//ads_printf(_T("\n插入4"));
			}
			else
			{
				dlg.m_iRunMode = 0;
				continue;
			}
		}
		else if(dlg.m_iRunMode == 2)
		{//拾取文字
			Entity entSel;
 			int ret;
			INITGET_BEG(0, _T("`"));
			ret = acedEntSel(_T("\n请选择要拾取的文字图元<文字插入>:"), entSel, XPoint());
			INITGET_END();
			if(ret == RTCAN)
				break;
			else if(ret == RTKWORD)
				continue;
			else if(ret == RTNORM)
			{
				if(!entSel.Is(_T("TEXT"))&&!entSel.Is(_T("ATS_TEXT"))&&
					!entSel.Is(_T("MTEXT"))&&!entSel.Is(_T("ATS_MTEXT")))
				{
					acutPrintf(_T("\n已滤除1个。"));
					continue;
				}
			}
			else
			{
				dlg.m_iRunMode = 0;
				continue;
			}
			XText text(entSel);
			ptOld = text.m_ptInsert;
			dlg.m_csHeight.Format(_T("%.1f"), text.m_nHeight);
			CString csStyle = (const TCHAR*)GetSymbolName(text.m_idStyle);
			dlg.SetEditText(text.m_csText);
			dlg.m_iRunMode = 0;
			dlg.SetTextStyle(csStyle);	

		}
        else
		{ 
			CString str = dlg.GetEditText();
// 			if (dlg.GetEditText() == _T(""))
// 			{
// 				acedGetAcadDwgView()->SetFocus();
// 				int nOsMode=0;
// 				xg_getvar(_T("OSMODE"), &nOsMode);
// 				nOsMode &= ~0x4000;
// 				nOsMode |= OS_INT|OS_NEA;
// 				XPushVar<int> vOsMode(_T("OSMODE"), nOsMode);;
// 				continue;;
// 			}
			TMTextEdJig jig(&dlg, ptIns);
			jig.SetKeyword(_T("`"));
			jig.SetPrompt(_T("\n请指定文字的插入点<退出>:"));
			int nKeyIdx;
			if(!!ptOld)
				jig.m_ptRef = ptOld;
			int ret = jig.DoIt(&nKeyIdx);
			if(ret == RTKWORD){
				if(nKeyIdx == 0)
					continue;
			}
			else if(ret != RTNORM){
				dlg.DestroyWindow();
				return;
			}
			ptIns = jig.GetPickPoint();

			ptOld = ptIns;
			double nTextHeight2 = _tstof(dlg.m_csHeight)*DocGetPScale();
			if (dlg.GetEditText()!=_T(""))
			{
				// modify by xly on 101213l 支持图层切换,获得数据库中的当前的图层名
				//XText text(dlg.GetEditText(), ptIns, nTextHeight2, g_nScaleDim, dlg.m_csTextStyle, LAY_TEXT);
				XString csLayerMode;
				xg_getvar(_T("CLAYER"), &csLayerMode);
				if(g_bTextDefaultLayer)
				{
					csLayerMode = LAY_TEXT;
				}
				XText text(dlg.GetEditText(), ptIns, nTextHeight2, g_nScaleDim, dlg.m_csTextStyle, (CString)csLayerMode);
				text.SetRotate(Ucs2Wcs(0.0));//支持UCS
				//text.SetLayoutRotation(Ucs2Wcs(0.0));
				text.TgDraw(AlignList[dlg.m_iAlign]);
			}
		}
		dlg.AddToLast();
		// add by xly on 110310 保存文字样式到图纸中
		DocSetTgSingleTextStyle(dlg.m_csTextStyle);
	}
	dlg.DestroyWindow();
	return;
}
bool GetWordFromLib(CWnd*pParent,CString &res)
{
	CTemporaryResourceOverride vTemp;
	CInsTextDlg dlg(pParent);
	dlg.SetSingleText();
	dlg.SetPreText(res);
	if(dlg.DoModal()!=IDOK||dlg.GetEditText()==_T(""))
		return false;

	res=dlg.GetEditText();
	return true;
}
/////////////////////////////////////////////////
///////////////////////////////////////
////////////////////////////////////////////////////
// CArtchTextLibEdit
CArtchTextLibEdit::CArtchTextLibEdit()
{
	m_pItemData = NULL;
	m_pXMLDoc = NULL;
}
CArtchTextLibEdit::CArtchTextLibEdit(CXMLDOMFile* pXMLDoc)
{
	m_pXMLDoc = pXMLDoc;
}
CArtchTextLibEdit::~CArtchTextLibEdit()
{
}

void CArtchTextLibEdit::PostNcDestroy()
{
	delete this;
}

BOOL CArtchTextLibEdit::PreTranslateMessage(MSG *pMsg)
{
	BOOL bRet=CEdit::PreTranslateMessage(pMsg);
	if(pMsg->message == WM_KEYDOWN)
	{
		if(pMsg->wParam == VK_RETURN)
		{
			GetParent()->SetFocus();
			return TRUE;
		}
	}
	return bRet;
}

BEGIN_MESSAGE_MAP(CArtchTextLibEdit, CEdit)
	ON_WM_KILLFOCUS()
	//ON_WM_CHAR()
	ON_NOTIFY_REFLECT(EN_CHANGE, OnEnChange)
END_MESSAGE_MAP()
//CRichEditCtrl
void CArtchTextLibEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	static CString str;
	TCHAR ch = nChar;
	str +=ch;
	CString szOld, szNew;
	szNew = str;
	//GetWindowText(szNew);
	CArchTextLibListBox *pListBox = (CArchTextLibListBox*)GetParent();
	int iCurSel = pListBox->GetCurSel();
	pListBox->GetText(iCurSel, szOld);
	//void *dataPtr = pListBox->GetItemDataPtr(iCurSel);
	CXMLNodeInfo *pData = (CXMLNodeInfo*)(pListBox->GetItemData(iCurSel));
	int iRet = pListBox->FindStringExact(-1, szNew);
	if (iRet == LB_ERR)
	{
		if(szNew==_T(""))//不发生变化
			MessageBox(_T("名称不能为空!"));
		else if(UString(szNew).Length()>25)
			MessageBox(_T("名称最长为25个字符！"));
		else
		{
			CXMLNodeInfo xmlData(*pData);
			xmlData.m_strNodeAttributeValue = szNew;
			CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMLDoc->SelectSingleNode(pData->m_strNodeXPath);
			pXMLDOMNodePtr->SetAttributeValue(pData->m_strNodeAttributeName,szNew);
			m_pXMLDoc->GetCurNodeXPath(pXMLDOMNodePtr,xmlData.m_strNodeXPath);
			//m_pXMLDoc->Save();
			pListBox->DeleteStringEx(iCurSel);
			pListBox->InsertStringEx(iCurSel,&xmlData);
		}
	}
	else
	{
		if(iRet!=iCurSel)//不发生变化
			MessageBox(CString(_T("<"))+szNew+_T(">项已经存在!"));
	}
}
void CArtchTextLibEdit::OnEnChange(NMHDR* p, LRESULT* l)
{
	CString szOld, szNew;
	GetWindowText(szNew);
	CArchTextLibListBox *pListBox = (CArchTextLibListBox*)GetParent();
	int iCurSel = pListBox->GetCurSel();
	pListBox->GetText(iCurSel, szOld);
	//void *dataPtr = pListBox->GetItemDataPtr(iCurSel);
	CXMLNodeInfo *pData = (CXMLNodeInfo*)(pListBox->GetItemData(iCurSel));
	int iRet = pListBox->FindStringExact(-1, szNew);
	if (iRet == LB_ERR)
	{
		if(szNew==_T(""))//不发生变化
			MessageBox(_T("名称不能为空!"));
		else if(UString(szNew).Length()>25)
			MessageBox(_T("名称最长为25个字符！"));
		else
		{
			CXMLNodeInfo xmlData(*pData);
			xmlData.m_strNodeAttributeValue = szNew;
			CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMLDoc->SelectSingleNode(pData->m_strNodeXPath);
			pXMLDOMNodePtr->SetAttributeValue(pData->m_strNodeAttributeName,szNew);
			m_pXMLDoc->GetCurNodeXPath(pXMLDOMNodePtr,xmlData.m_strNodeXPath);
			//m_pXMLDoc->Save();
			pListBox->DeleteStringEx(iCurSel);
			pListBox->InsertStringEx(iCurSel,&xmlData);
		}
	}
	else
	{
		if(iRet!=iCurSel)//不发生变化
			MessageBox(CString(_T("<"))+szNew+_T(">项已经存在!"));
	}
}
void CArtchTextLibEdit::SetXMLDoc(CXMLDOMFile*pXMLDoc)
{
	m_pXMLDoc = pXMLDoc;
}
void CArtchTextLibEdit::OnKillFocus(CWnd* pNewWnd)
{
	CEdit::OnKillFocus(pNewWnd);

	CString szOld, szNew;
	GetWindowText(szNew);
	CArchTextLibListBox *pListBox = (CArchTextLibListBox*)GetParent();
	int iCurSel = pListBox->GetCurSel();
	pListBox->GetText(iCurSel, szOld);
	//void *dataPtr = pListBox->GetItemDataPtr(iCurSel);
	CXMLNodeInfo *pData = (CXMLNodeInfo*)(pListBox->GetItemData(iCurSel));
	int iRet = pListBox->FindStringExact(-1, szNew);
	if (iRet == LB_ERR)
	{
		if(szNew==_T(""))//不发生变化
			MessageBox(_T("名称不能为空!"));
		else if(UString(szNew).Length()>25)
			MessageBox(_T("名称最长为25个字符！"));
		else
		{
			CXMLNodeInfo xmlData(*pData);
			xmlData.m_strNodeAttributeValue = szNew;
			CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMLDoc->SelectSingleNode(pData->m_strNodeXPath);
			pXMLDOMNodePtr->SetAttributeValue(pData->m_strNodeAttributeName,szNew);
			CString strPath;
			m_pXMLDoc->GetCurNodeXPath(pXMLDOMNodePtr,strPath);
			xmlData.m_strNodeXPath = strPath;
			//m_pXMLDoc->Save();
			pListBox->DeleteStringEx(iCurSel);
			pListBox->InsertStringEx(iCurSel,&xmlData);
		}
	}
	else
	{
		if(iRet!=iCurSel)//不发生变化
			MessageBox(CString(_T("<"))+szNew+_T(">项已经存在!"));
	}
	//if(iRet == LB_ERR)//新名称未用
	//{
	//	if(szNew==_T(""))//不发生变化
	//		MessageBox(_T("名称不能为空!"));
	//	else if(UString(szNew).Length()>25)
	//		MessageBox(_T("名称最长为25个字符！"));
	//	else
	//	{
	//		int iPos;
	//		if(m_pItemData!=NULL)
	//		{
	//			iPos = m_pItemData->lstNames.FindData(CNameString(szOld));
	//			CString& szNameString=m_pItemData->lstNames(iPos);
	//			szNameString=szNew;
	//		}
	//		pListBox->DeleteString(iCurSel);
	//		pListBox->InsertString(iCurSel, szNew);
	//		pListBox->SetItemDataPtr(iCurSel, dataPtr);
	//		iCurSel = pListBox->FindStringExact(-1, szNew);
	//		if(iCurSel>=0&&iCurSel<pListBox->GetCount())
	//			pListBox->SetCurSel(iCurSel);
	//	}
	//}
	//else//新名称被占用
	//{
	//	if(iRet!=iCurSel)//不发生变化
	//		MessageBox(CString(_T("<"))+szNew+_T(">项已经存在!"));;
	//}
	DestroyWindow();
}

void CArtchTextLibEdit::SetExtentData(CXMLNodeInfo *&pItemData)
{
	m_pItemData = pItemData;
}
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
// CExtendListBox
IMPLEMENT_DYNAMIC(CArchTextLibListBox, CDragListBox)
CArchTextLibListBox::CArchTextLibListBox(int iFlag)
{
	m_iFlag = iFlag;
	m_bModified = TRUE;
	//	m_pItemData = NULL;
}
CArchTextLibListBox::~CArchTextLibListBox()
{
	ReSetContentEx();
}
CString CArchTextLibListBox::CreateNewName()
{
	CString sName=_T("新名称");
	long count=1;
	for(long i=0;i<GetCount();i++)
	{
		CString temp;
		GetText(i,temp);
		if(temp.Find(sName)>=0)
		{
			sName.Format(_T("新名称%d"),count++);
			i=-1;
		}
	}
	return sName;
}
BEGIN_MESSAGE_MAP(CArchTextLibListBox, CDragListBox)
	ON_WM_KEYDOWN()
	ON_WM_RBUTTONDOWN()
	ON_WM_LBUTTONDOWN()
	ON_COMMAND_RANGE(IDR_NEW, IDR_MOD, OnMenuCommand)
END_MESSAGE_MAP()

void CArchTextLibListBox::OnLButtonDown(UINT nFlags,CPoint point)
{
//	BOOL bOutSide;
//	int iHit = ItemFromPoint(point, bOutSide);
//	if(!bOutSide)
//		SetCurSel(iHit);
//	int iCurSel = GetCurSel();
	CDragListBox::OnLButtonDown(nFlags,point);
}
// CExtendListBox 消息处理程序
void CArchTextLibListBox::OnRButtonDown(UINT nFlags, CPoint point)
{
	if(point.x<1||point.y<=1)
		return;
	SetFocus();
	CDragListBox::OnRButtonDown(nFlags, point);
	if(!m_bModified)
		return;
	BOOL bOutSide;
	int iHit = ItemFromPoint(point, bOutSide);
	if(!bOutSide)
		SetCurSel(iHit);
	int iCurSel = GetCurSel();
	CMenu popup;
	popup.CreatePopupMenu();
	popup.AppendMenu(MF_STRING, IDR_NEW, _T("新建行(N)"));
	if(iCurSel != -1)
	{
		popup.AppendMenu(MF_STRING, IDR_INS, _T("插入行(Ins)"));
		popup.AppendMenu(MF_STRING, IDR_DEL, _T("删除行(Del)"));
		popup.AppendMenu(MF_STRING, IDR_MOD, _T("重命名(F2)"));
	}
	ClientToScreen(&point);
	popup.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this);
}

void CArchTextLibListBox::OnMenuCommand(UINT id)
{
	switch(id)
	{
	case IDR_INS:
		DoInsertItem();
		break;
	case IDR_NEW:
		DoAppendItem();
		break;
	case IDR_DEL:
		DoDeleteItem();
		break;
	case IDR_MOD:
		DoModifyItem();
		break;
	}
}

void CArchTextLibListBox::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	CDragListBox::OnKeyDown(nChar, nRepCnt, nFlags);
	if(!m_bModified)
		return;

	BOOL bPop = FALSE;
	int iCurSel = GetCurSel();
	if(iCurSel == -1)
		bPop = TRUE;
	else
	{
		if(m_iFlag == 0)
		{
			CString szText;
			GetText(iCurSel, szText);
			if(_tcscmp(szText, c_szAll) == 0 || _tcscmp(szText, c_szLate) == 0)
				bPop = TRUE;
		}
	}

	if(bPop)
	{
		if(nChar == VK_N)
			DoAppendItem();
	}
	else
	{
		if(nChar == VK_DELETE)
			DoDeleteItem();
		else if(nChar == VK_INSERT)
			DoInsertItem();
		else if(nChar == VK_N)
			DoAppendItem();
		else if(nChar == VK_F2)
			DoModifyItem();
	}
}

void CArchTextLibListBox::CreateEdit()
{
	int iCurSel = GetCurSel();
	CRect rect;
	GetItemRect(iCurSel, rect);
	rect.bottom += 2;
	rect.top -= 2;
	int iStyle = WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | ES_WANTRETURN;
	CTemporaryResourceOverride vTmp;
	CArtchTextLibEdit *pEdit = new CArtchTextLibEdit(m_pXMLDoc);
	if(!pEdit->Create(iStyle, rect, this, IDC_TEMP))
		return;
	CString szOld;
	GetText(iCurSel, szOld);
	pEdit->SetFont(GetFont());
	pEdit->SetWindowText(szOld);
	pEdit->SetFocus();
	pEdit->SetSel(0, -1);
}

void CArchTextLibListBox::DoDeleteItem()
{
	GetParent()->SendMessage(TARCH_TEXTLIB_MSG_DELETE);
}

void CArchTextLibListBox::DoInsertItem()
{
	GetParent()->SendMessage(TARCH_TEXTLIB_MSG_INSERT);
}

void CArchTextLibListBox::DoAppendItem()
{
	GetParent()->SendMessage(TARCH_TEXTLIB_MSG_NEW,0,0);
}

void CArchTextLibListBox::DoModifyItem()
{
	CreateEdit();
	GetParent()->SendMessage(TARCH_TEXTLIB_MSG_RENAME);
}

void CArchTextLibListBox::SetModify(BOOL bModified)
{
	m_bModified = bModified;
}

BOOL CArchTextLibListBox::GetModify()
{
	return m_bModified;
}

void CArchTextLibListBox::SetExtendData(CListBoxItemData *&pItemData)
{
}

int CArchTextLibListBox::SetCurSel(int nSelect)
{
	int nRet = CDragListBox::SetCurSel(nSelect);
	((CInsTextDlg*)GetParent())->OnLbnSelchangeName();
	return nRet;
}
void CArchTextLibListBox::SetXMLDoc(CXMLDOMFile*pXMLDoc)
{
	m_pXMLDoc = pXMLDoc;
}
void CArchTextLibListBox::PreSubclassWindow()
{
	if(m_iFlag!=2)
		CDragListBox::PreSubclassWindow();
	else
		CListBox::PreSubclassWindow();
}

BOOL CArchTextLibListBox::OnChildNotify(UINT nMessage, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	if(m_iFlag != 2 && m_bModified)
		return CDragListBox::OnChildNotify(nMessage, wParam, lParam, pResult);
	else
		return CListBox::OnChildNotify(nMessage, wParam, lParam, pResult);
}
int CArchTextLibListBox::AddStringEx(LPCTSTR lpszItem,CXMLNodeInfo *pData)
{
	int nIndex = 0;
	nIndex = AddString(lpszItem);
	CXMLNodeInfo *pNewData = new CXMLNodeInfo(*pData);
	// Zyu modify on 100726，支持64位
	//SetItemData(nIndex,(DWORD)pNewData);
	SetItemData(nIndex,(DWORD_PTR)pNewData);
	return nIndex;
}
int CArchTextLibListBox::InsertStringEx(int nIndex,CXMLNodeInfo *pData)
{
	int n = InsertString(nIndex,pData->m_strNodeAttributeValue);
	CXMLNodeInfo *pNewData = new CXMLNodeInfo(*pData);
	// Zyu modify on 100726，支持64位
	//SetItemData(n,(DWORD)pNewData);
	SetItemData(n,(DWORD_PTR)pNewData);
	return n;
}
int CArchTextLibListBox::DeleteStringEx(UINT nIndex)
{
	CXMLNodeInfo *pData = (CXMLNodeInfo*)GetItemData(nIndex);
	if (pData)
	{
		delete pData;
	}
	int n = DeleteString(nIndex);
	return n;
}
//////////////////////////////////////////
/////////////词库树类////////////////////
CArchTextLibTreeCtrl::CArchTextLibTreeCtrl()
{
	m_bEdit = FALSE;
	m_bDragging = FALSE;
	m_bRub = FALSE;
	m_pXMLDoc = NULL;
}
CArchTextLibTreeCtrl::CArchTextLibTreeCtrl(CXMLDOMFile*pXMLDoc)
{
	m_bEdit = FALSE;
	m_bDragging = FALSE;
	m_bRub = FALSE;
	m_pXMLDoc = pXMLDoc;
}
BEGIN_MESSAGE_MAP(CArchTextLibTreeCtrl, CTreeCtrl)
	ON_COMMAND_RANGE(ID_INS_DRAWING, ID_COLLAPSE_WORKS, OnMenuCommand)
	ON_WM_RBUTTONDOWN()
	ON_NOTIFY_REFLECT(TVN_ENDLABELEDIT, OnTvnEndlabeledit)
	ON_NOTIFY_REFLECT(TVN_BEGINLABELEDIT, OnTvnBeginlabeledit)
	ON_NOTIFY_REFLECT(TVN_BEGINDRAG, OnTvnBegindrag)
	ON_WM_TIMER()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_DESTROY()
END_MESSAGE_MAP()
void CArchTextLibTreeCtrl::OnLButtonDown(UINT nFlags, CPoint point)
{
	m_dwDragStart = GetTickCount();
	CTreeCtrl::OnLButtonDown(nFlags, point);
}
void  CArchTextLibTreeCtrl::XmlNodeToTreeNode(HTREEITEM hParentItem, const CXMLDOMNodePtr &pXmlNode)
{
	CXMLDOMNodesPtr pXMLNodeList = pXmlNode->GetChildrenNodes(pXmlNode->GetNodeName());
	int count = pXMLNodeList->GetCount();
	if(count==0) 
	{
		return;
	}
	int i=0;
	for(i=0; i<count; i++)
	{
		CXMLDOMNodePtr pChildNode = pXMLNodeList->GetItem(i);
		HTREEITEM hSubItem;
		CString strName,strNodeName;
		strNodeName = pChildNode->GetNodeName();
		strName = pChildNode->GetAttributeName();
		if (strNodeName == c_szLemma)
		{
			continue;
		}
		CString str;
		//if (pChildNode->IsAttributeExist(strName))
		//{
			str= pChildNode->GetAttributeValue(strName);
		//}
		CXMLNodeInfo nodeInfo = GetNodeInfo(pChildNode,m_pXMLDoc);
		CXMLNodeInfo*pData = (CXMLNodeInfo*)(GetItemData(hParentItem));
		if (pData)
		{
			nodeInfo.m_strNodeXPath = pData->m_strNodeXPath+_T("/")+strNodeName+_T("[@")
				+strName+_T("=")+_T("'")+str+_T("']");
			hSubItem = InsertItemEx(&nodeInfo,hParentItem,TVI_LAST);
			XmlNodeToTreeNode(hSubItem,pChildNode);//递归子节点
		}
		//hSubItem = InsertItemEx(&nodeInfo,hParentItem,TVI_LAST);
		//XmlNodeToTreeNode(hSubItem,pChildNode);//递归子节点
	}
}
void CArchTextLibTreeCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
	CTreeCtrl::OnLButtonUp(nFlags, point);
	if( m_bDragging )
	{
		if(m_bRub)
		{
			m_bRub = FALSE;
			DrawTempLine(m_ptSta, m_ptEnd);
		}
		m_bDragging = FALSE;
		CImageList::DragLeave( this );
		CImageList::EndDrag();
		ReleaseCapture();
		delete m_pDragImage;
		SelectDropTarget( NULL );
		if( m_hItemDragS == m_hItemDragD || m_hItemDragD == NULL)
		{
			KillTimer( m_nScrollTimerID );
			Invalidate();
			return;
		}
		CXMLNodeInfo *pData = (CXMLNodeInfo *)GetItemData(m_hItemDragD);
		if(pData == NULL)
		{
			KillTimer( m_nScrollTimerID );
			Invalidate();
			return;
		}
		HTREEITEM pParent=GetParentItem(m_hItemDragD);
		if(GetParentItem(m_hItemDragS) != pParent)
		{
			CString szText = GetItemText(m_hItemDragS);
			HTREEITEM hChild = GetChildItem(pParent);
			while( hChild != NULL )
			{
				if(GetItemText(hChild) == szText)
				{
					KillTimer(m_nScrollTimerID);
					Invalidate();
					return;
				}
				hChild =GetNextSiblingItem(hChild);
			}
		}
		Expand( m_hItemDragD,TVE_EXPAND );
		HTREEITEM  htiParent = m_hItemDragD;
		while( (htiParent = GetParentItem(htiParent)) != NULL )
		{
			if( htiParent == m_hItemDragS )
			{
				KillTimer( m_nScrollTimerID );
				Invalidate();
				return;
			}
		}
		HTREEITEM  htiNew;
		if(m_nShowFlag == -1)
		{
			HTREEITEM hPre = GetPrevSiblingItem(m_hItemDragD);
			if(hPre != NULL)
			{
				htiNew = CopyItem(m_hItemDragS, GetParentItem(m_hItemDragD),hPre);
			}
			else
			{
				htiNew = CopyItem(m_hItemDragS, GetParentItem(m_hItemDragD),TVI_FIRST);
			}
		}
		else if(m_nShowFlag == 0)
		{
			htiNew = CopyItem(m_hItemDragS,m_hItemDragD,TVI_LAST);
		}
		else if(m_nShowFlag == 1)
		{
			htiNew = CopyItem(m_hItemDragS,GetParentItem(m_hItemDragD),m_hItemDragD);
		}
		if (htiNew!=NULL)
		{
			DeleteItemEx( m_hItemDragS );
			SelectItem( htiNew );
		}
		KillTimer( m_nScrollTimerID );
	}
}
void CArchTextLibTreeCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
	HTREEITEM  hItem;
	UINT       flags;

	if( m_nHoverTimerID )
	{
		KillTimer( m_nHoverTimerID );
		m_nHoverTimerID = 0;
	}
	m_nHoverTimerID = SetTimer( 1,800,NULL );
	m_HoverPoint = point;

	if( m_bDragging )
	{
		CPoint  pt = point;
		CImageList::DragMove( pt );

		if( (hItem = HitTest(point,&flags)) != NULL && hItem != TVI_ROOT)
		{
			CImageList::DragShowNolock( false );
			m_nShowFlag = GetShowFlag( hItem, pt );
			if(m_nShowFlag != -2)
				m_hItemDragD = hItem;

			CImageList::DragShowNolock( true );
		}

		CRect  rect;
		GetClientRect( &rect );
		if( point.x < rect.left + 20  )
			m_hItemDragD = NULL;
	}
	CTreeCtrl::OnMouseMove(nFlags, point);
}
int CArchTextLibTreeCtrl::GetShowFlag( HTREEITEM hItem, CPoint pt )
{
	if(m_bRub)
	{
		m_bRub = FALSE;
		DrawTempLine(m_ptSta, m_ptEnd);
	}

	int nFlag = -2;
	CXMLNodeInfo *pData = (CXMLNodeInfo *)GetItemData(hItem);
	if(pData == NULL)
		return nFlag;

	CRect rect, rDc;
	GetItemRect(hItem, &rect, FALSE);
	GetItemRect(hItem, &rDc, TRUE);

	long lDis = rect.bottom - rect.top;
	CRect rUp(rect), rMid(rect), rDown(rect);
	rUp.bottom = rUp.top + lDis / 4;
	rDown.top = rDown.bottom - lDis / 4;
	rMid.top = rMid.top + lDis / 4;
	rMid.bottom = rMid.bottom - lDis / 4;
	if(rUp.PtInRect(pt))
	{
		nFlag = -1;
		SelectDropTarget( NULL );
		SelectItem(m_hItemDragS);
		m_ptSta = CPoint(rDc.left, rDc.top);
		m_ptEnd = CPoint(rect.right - 5, rDc.top);
		DrawTempLine(m_ptSta, m_ptEnd);
		m_bRub = TRUE;
	}
	else if(rDown.PtInRect(pt))
	{
		nFlag = 1;
		SelectDropTarget( NULL );
		SelectItem(m_hItemDragS);
		m_ptSta = CPoint(rDc.left, rDc.bottom);
		m_ptEnd = CPoint(rect.right - 5, rDc.bottom);
		DrawTempLine(m_ptSta, m_ptEnd);
		m_bRub = TRUE;
	}
	else if(rMid.PtInRect(pt))
	{
		nFlag = 0;
		SelectDropTarget( hItem );
	}

	return nFlag;
}

void CArchTextLibTreeCtrl::DrawTempLine(CPoint ptSta, CPoint ptEnd)
{
	CClientDC dc(this);
	CPen pen(PS_SOLID, 2, RGB(125,125,125)),*pOldPen;
	pOldPen = dc.SelectObject(&pen);
	dc.SetROP2(R2_XORPEN);

	dc.MoveTo(ptSta);
	dc.LineTo(ptSta.x-2, ptSta.y+2);
	dc.MoveTo(ptSta);
	dc.LineTo(ptSta.x-2, ptSta.y-2);
	dc.MoveTo(ptSta.x-2, ptSta.y);
	dc.LineTo(ptEnd.x+2, ptEnd.y);
	dc.MoveTo(ptEnd);
	dc.LineTo(ptEnd.x+2, ptEnd.y+2);
	dc.MoveTo(ptEnd);
	dc.LineTo(ptEnd.x+2, ptEnd.y-2);
	dc.MoveTo(ptEnd);
	dc.SelectObject(pOldPen);
}
// Zyu modify on 100726，支持64位
//void CArchTextLibTreeCtrl::OnTimer(UINT nIDEvent)
void CArchTextLibTreeCtrl::OnTimer(UINT_PTR nIDEvent)
{
	if( nIDEvent == m_nHoverTimerID )
	{
		KillTimer( m_nHoverTimerID );
		m_nHoverTimerID = 0;
		HTREEITEM  trItem = 0;
		UINT  uFlag = 0;
		trItem = HitTest( m_HoverPoint,&uFlag );
		if( trItem && m_bDragging )
		{
			SelectItem( trItem );
			Expand( trItem,TVE_EXPAND );
		}
	}
	else if( nIDEvent == m_nScrollTimerID )
	{
		m_TimerTicks++;
		CPoint  pt;
		GetCursorPos( &pt );
		CRect  rect;
		GetClientRect( &rect );
		ClientToScreen( &rect );

		HTREEITEM  hItem = GetFirstVisibleItem();

		if( pt.y < rect.top +10 )
		{
			int  slowscroll = 6 - (rect.top + 10 - pt.y )/20;
			if( 0 == (m_TimerTicks % ((slowscroll > 0) ? slowscroll : 1)) )
			{
				CImageList::DragShowNolock ( false );
				SendMessage( WM_VSCROLL,SB_LINEUP );
				SelectDropTarget( hItem );
				m_hItemDragD = hItem;
				CImageList::DragShowNolock ( true );
			}
		}
		else if( pt.y > rect.bottom - 10 )
		{
			int  slowscroll = 6 - (pt.y - rect.bottom + 10)/20;
			if( 0 == (m_TimerTicks % ((slowscroll > 0) ? slowscroll : 1)) )
			{
				CImageList::DragShowNolock ( false );
				SendMessage( WM_VSCROLL,SB_LINEDOWN );
				int  nCount = GetVisibleCount();
				for( int i=0 ; i<nCount-1 ; i++ )
					hItem = GetNextVisibleItem( hItem );
				if( hItem )
					SelectDropTarget( hItem );
				m_hItemDragD = hItem;
				CImageList::DragShowNolock ( true );
			}
		}
	}
	else
		CTreeCtrl::OnTimer(nIDEvent);
}
void CArchTextLibTreeCtrl::OnTvnBegindrag(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMTREEVIEW pNMTreeView = reinterpret_cast<LPNMTREEVIEW>(pNMHDR);

	if( (GetTickCount() - m_dwDragStart) < 60 )
		return;
	m_hItemDragS = pNMTreeView->itemNew.hItem;
	m_hItemDragD = NULL;
	CXMLNodeInfo *pData = (CXMLNodeInfo*)GetItemData(m_hItemDragS);
	if(pData == NULL)
		return;
	m_pDragImage = CreateDragImage( m_hItemDragS );
	if( !m_pDragImage )
		return;
	m_bDragging = true;
	m_pDragImage->BeginDrag ( 0,CPoint(8,8) );
	CPoint  pt = pNMTreeView->ptDrag;
	ClientToScreen( &pt );
	m_pDragImage->DragEnter ( this,pt );
	SetCapture();
	m_nScrollTimerID = SetTimer( 2,40,NULL );
	*pResult = 0;
}
void CArchTextLibTreeCtrl::OnMenuCommand(UINT id)
{
	switch(id)
	{
	case ID_ADD_CHILD_LEMMA:
		DoAddLemma();
		break;
	case ID_ADD_CHILD_COLLECT:
		DoAddChildCollect();
		break;
	case ID_REN_COLLECT:
		DoReNameNode();
		break;
	case ID_DEL_COLLECT:
		DoDeLeteItem();
		break;
	case ID_EXPAND_COLLECT:
		DoExpandCollect();
		break;
	case ID_COLLAPSE_COLLECT:
		DoCollapseCollect();
		break;
	case ID_EXPAND_WORKS:
		DoExpandWorks();
		break;
	case ID_COLLAPSE_WORKS:
		DoCollapseWorks();
		break;
	default:
		break;
	}
}
void CArchTextLibTreeCtrl::ExpandAll()
{
	HTREEITEM hOldItem = GetSelectedItem();
	HTREEITEM hItem = GetRootItem();
	SelectItem(hItem);
	SendMessage(WM_KEYDOWN, VK_MULTIPLY);
	EnsureVisible(hItem);
	SelectItem(hOldItem);
}

void CArchTextLibTreeCtrl::CollapseAll()
{
	HTREEITEM hItem = GetRootItem();
	SelectItem(hItem);
	SendMessage(WM_KEYDOWN, VK_SUBTRACT);
	EnsureVisible(hItem);
	SelectItem(hItem);
}
BOOL CArchTextLibTreeCtrl::PreTranslateMessage(MSG* pMsg)
{
	if(pMsg->message == WM_KEYDOWN)
	{
		// Zyu modify on 100726，支持64位
		//int nVk = pMsg->wParam;
		UINT_PTR nVk = pMsg->wParam;
		if(nVk == VK_DELETE&&pMsg->hwnd==GetSafeHwnd())
		{
			HTREEITEM hItem = GetSelectedItem();
			if(hItem == NULL)
				return CTreeCtrl::PreTranslateMessage(pMsg);

			CXMLNodeInfo *pData = (CXMLNodeInfo *)GetItemData(hItem);
			if(pData == NULL)
				return CTreeCtrl::PreTranslateMessage(pMsg);
			DoDeLeteItem();
			return TRUE;
		}
		else if(nVk == VK_F2)
		{
			HTREEITEM hItem = GetSelectedItem();
			if(hItem == NULL)
				return CTreeCtrl::PreTranslateMessage(pMsg);

			CXMLNodeInfo *pData = (CXMLNodeInfo *)GetItemData(hItem);
			if(pData == NULL)
				return CTreeCtrl::PreTranslateMessage(pMsg);
			DoReNameNode();
			return TRUE;
		}
	}
	return CTreeCtrl::PreTranslateMessage(pMsg);
}
void CArchTextLibTreeCtrl::OnTvnBeginlabeledit(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMTVDISPINFO pTVDispInfo = reinterpret_cast<LPNMTVDISPINFO>(pNMHDR);
	if(m_bEdit)
	{
		m_bEdit = FALSE;
		*pResult = 0;
	}
	else
		*pResult = 1;
}
void CArchTextLibTreeCtrl::OnTvnEndlabeledit(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMTVDISPINFO pTVDispInfo = reinterpret_cast<LPNMTVDISPINFO>(pNMHDR);

	HTREEITEM hItem = pTVDispInfo->item.hItem;
	Expand(hItem, TVE_COLLAPSE);
	CXMLNodeInfo *pData = (CXMLNodeInfo*)GetItemData(hItem);
	if(pData == NULL || pData->m_strNodeXPath==_T(""))
	{
		*pResult = 0;
		return;
	}
	CString szName = pTVDispInfo->item.pszText;
	if (m_pXMLDoc)
	{
		CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMLDoc->SelectSingleNode(pData->m_strNodeXPath);
		CXMLDOMNodePtr pParent = pXMLDOMNodePtr->GetParentNode();
		CString strNodeName = pParent->GetNodeName();
		CXMLDOMNodesPtr pXMLDOMNodesList = pParent->GetChildrenNodes(strNodeName);
		int nNum = pXMLDOMNodesList->GetCount();
		int i =0;
		for (i = 0;i <nNum;i++)
		{
			CXMLDOMNodePtr pTem = pXMLDOMNodesList->GetItem(i);
			CString strAttriName = pTem->GetAttributeName();
			CString strAttriValue;
			//if (pTem->IsAttributeExist(strAttriName))
			//{
			strAttriValue = pTem->GetAttributeValue(strAttriName);
			//}
			if (strAttriValue == szName)
			{
				*pResult = 0;
				return;
			}
		}
		if(szName != _T(""))
		{
			CString strAttName;
			if (pXMLDOMNodePtr->GetAttributeNum()>0)
			{
				strAttName = pXMLDOMNodePtr->GetAttributeName();
				if (strAttName==_T(""))
				{
					strAttName = _T("name");
				}
			}
			else
			{
				strAttName = _T("name");
			}
			pXMLDOMNodePtr->SetAttributeValue(strAttName,szName);
			CString strXPath;
			m_pXMLDoc->GetCurNodeXPath(pXMLDOMNodePtr,strXPath);
			//m_pXMLDoc->Save();
			pData->m_strNodeAttributeValue = szName;
			pData->m_strNodeXPath = strXPath;
			DeleteChildItemEx(hItem);//因为父节点的名字改变导致子节点的路径名字不对删掉重新生成
			XmlNodeToTreeNode(hItem,pXMLDOMNodePtr);
		}
	}
	HTREEITEM hParent = GetParentItem(hItem);
	if (hParent!=NULL)
	{
		SelectItem(hParent);
	}
	SelectItem(hItem);
	*pResult = 1;
}
void CArchTextLibTreeCtrl::DoDeLeteItem()
{
	HTREEITEM hParent = GetSelectedItem();
	HTREEITEM hRoot = GetRootItem();
	if (hParent == NULL|| hParent == TVI_ROOT||hParent == hRoot)
	{
		return;
	}
	CXMLNodeInfo *pData = (CXMLNodeInfo*)GetItemData(hParent);
	if (pData->m_strNodeAttributeValue  == c_szTDWord||pData->m_strNodeAttributeValue == c_szLate)
	{
		return;
	}
	if(pData == NULL || (pData->m_strNodeAttributeName==_T("")&&pData->m_strNodeName==_T("")))
		return;
	CString strXPath = pData->m_strNodeXPath;
	if (m_pXMLDoc)
	{
		CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMLDoc->SelectSingleNode(strXPath);
		pXMLDOMNodePtr->DeleteNode();
		//m_pXMLDoc->Save();
	}
	DeleteItemEx(hParent);
}
void CArchTextLibTreeCtrl::DoReNameNode()
{
	m_bEdit = TRUE;
	HTREEITEM hItem = GetSelectedItem();
	CEdit *pEdit = EditLabel(hItem);
}
void CArchTextLibTreeCtrl::DoAddLemma()
{
	HTREEITEM hParent = GetSelectedItem();
	if(hParent == NULL || hParent == TVI_ROOT)
		return;

	CXMLNodeInfo *pData = (CXMLNodeInfo*)GetItemData(hParent);
	if(pData == NULL || (pData->m_strNodeAttributeName==_T("")&&pData->m_strNodeName==_T("")))
		return;
	CString szName;
	//CXMLDOMFile xmlDoc;
	int nCount = 1;
	if (m_pXMLDoc)
	{
		CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMLDoc->SelectSingleNode(pData->m_strNodeXPath);
		while (1)
		{
			BOOL bFlag = FALSE;
			szName.Format(_T("新建词条(%d)"), nCount);
			if (pXMLDOMNodePtr->HasChildNodes())
			{
				CString strNodeName = pXMLDOMNodePtr->GetNodeName();
				CXMLDOMNodesPtr pXMLDOMNodeList = pXMLDOMNodePtr->GetChildrenNodes(strNodeName);
				int nNum = pXMLDOMNodeList->GetCount();
				int i = 0;
				for (i = 0;i < nNum;i++)
				{
					CXMLDOMNodePtr pTem = pXMLDOMNodeList->GetItem(i);
					CString strAttriName = pTem->GetAttributeName();
					CString strAttriValue = pTem->GetAttributeValue(strAttriName);
					if (szName == strAttriValue)
					{
						bFlag = TRUE;
						nCount++;
						break;
					}
				}
			}
			if (!bFlag)
			{
				break;
			}
		}
		CXMLNodeInfo *pNodeInfo = new CXMLNodeInfo;
		pNodeInfo->m_strNodeName = c_szLemma;
		pNodeInfo->m_strNodeAttributeName = c_szName;
		pNodeInfo->m_bLeafNode = TRUE;
		pNodeInfo->m_strNodeAttributeValue = szName;
		pNodeInfo->m_strNodeValue = szName;
		pXMLDOMNodePtr->AppendNode(pNodeInfo->m_strNodeName,pNodeInfo->m_strNodeValue,
			pNodeInfo->m_strNodeAttributeName,pNodeInfo->m_strNodeAttributeValue);
		//m_pXMLDoc->Save();
	}
	HTREEITEM Hes = GetParentItem(hParent);
	SelectItem(Hes);
	Expand(hParent, TVE_EXPAND);
	SelectItem(hParent);
}
void CArchTextLibTreeCtrl::DoCollapseCollect()
{
	HTREEITEM hItem = GetSelectedItem();
	Expand(hItem, TVE_COLLAPSE);
}
void CArchTextLibTreeCtrl::DoExpandCollect()
{
	HTREEITEM hItem = GetSelectedItem();
	Expand(hItem, TVE_EXPAND);
}
void CArchTextLibTreeCtrl::DoExpandWorks()
{
	ExpandAll();
}

void CArchTextLibTreeCtrl::DoCollapseWorks()
{
	CollapseAll();
}
void CArchTextLibTreeCtrl::DoAddChildCollect()
{
	HTREEITEM hParent = GetSelectedItem();
	if(hParent == NULL || hParent == TVI_ROOT)
		return;

	CXMLNodeInfo *pData = (CXMLNodeInfo*)GetItemData(hParent);
	if(pData == NULL || (pData->m_strNodeAttributeName==_T("")&&pData->m_strNodeName==_T("")))
		return;
	CString szName;
//	CXMLDOMFile xmlDoc;
	BOOL bFlag = FALSE;
	int nCount = 1;
	if (m_pXMLDoc)
	{
		while(1)
		{
			BOOL bFlag = FALSE;
			szName.Format(_T("新建目录(%d)"), nCount);
			if(ItemHasChildren(hParent))
			{
				HTREEITEM hChild = GetChildItem(hParent);
				while(hChild != NULL)
				{
					CString szItem = GetItemText(hChild);
					if(szItem == szName)
					{
						bFlag = TRUE;
						nCount++;
						break;
					}
					hChild = GetNextSiblingItem(hChild);
				}
			}
			if(!bFlag)
				break;
		}
		CXMLNodeInfo *pNodeInfo = new CXMLNodeInfo;
		pNodeInfo->m_strNodeName = c_szCatalog;
		pNodeInfo->m_strNodeAttributeName = c_szName;
		pNodeInfo->m_bLeafNode = FALSE;
		pNodeInfo->m_strNodeAttributeValue = szName;
		pNodeInfo->m_strNodeXPath = pData->m_strNodeXPath + _T("/")+pNodeInfo->m_strNodeName+_T("[@")
			+pNodeInfo->m_strNodeAttributeName+_T("=")+_T("'")+pNodeInfo->m_strNodeAttributeValue+_T("']");
		HTREEITEM hRes = InsertItemEx(pNodeInfo, hParent);
		CXMLDOMNodePtr pXMLDOMNodePtr = m_pXMLDoc->SelectSingleNode(pData->m_strNodeXPath);
		pXMLDOMNodePtr->AppendNode(pNodeInfo->m_strNodeName,TEXT(""),
			pNodeInfo->m_strNodeAttributeName,
			pNodeInfo->m_strNodeAttributeValue);
		//m_pXMLDoc->Save();
		//记住一定要在selectitem之前往xml里写文档 因为调用select函数 会引发selchange消息函数
		//导致在另外一个函数中打开xml 此时会出错
		Expand(hParent, TVE_EXPAND);
		SelectItem(hRes);
		DoReNameNode();
	}
}

HTREEITEM CArchTextLibTreeCtrl::InsertItemEx(CXMLNodeInfo *pNodeInfo, HTREEITEM hParent, HTREEITEM hInsertAfter)
{
	CString strName;
	if (pNodeInfo->m_strNodeAttributeName==_T("")
		&&pNodeInfo->m_strNodeAttributeValue==_T("")
		&&pNodeInfo->m_strNodeName==_T("")
		&&pNodeInfo->m_strNodeValue==_T(""))
	{
		return NULL;
	}
	if (pNodeInfo->m_strNodeAttributeValue!=_T(""))
	{
		strName = pNodeInfo->m_strNodeAttributeValue;
	}
	else
	{
		if (pNodeInfo->m_strNodeName!=_T(""))
		{
			strName =pNodeInfo->m_strNodeName;
		}
	}
	int nImage = 0,nSelectImage = 0;
	if (hParent == TVI_ROOT)
	{
		nImage =0;
		nSelectImage = 1;
	}
	else
	{
		CString strLate = c_szLate;
		nImage = 2;
		nSelectImage = 3;
	}
	HTREEITEM hItem = InsertItem(strName,nImage,1,hParent,hInsertAfter);
	CXMLNodeInfo *pNodeData = new CXMLNodeInfo(*pNodeInfo);
	// Zyu modify on 100726，支持64位
	//SetItemData(hItem,(DWORD)pNodeData);
	SetItemData(hItem,(DWORD_PTR)pNodeData);
	return hItem;
}

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

void CArchTextLibTreeCtrl::DeleteChildItemEx(HTREEITEM hItem)
{
	if (hItem==NULL||hItem ==TVI_ROOT)
	{
		return;
	}
	HTREEITEM hChild = GetChildItem(hItem);
	while(hChild != NULL)
	{
		HTREEITEM hTem = GetNextSiblingItem(hChild);
		DeleteItemEx(hChild);
		hChild = hTem;
	}
}
void CArchTextLibTreeCtrl::DeleteAllItemData(HTREEITEM hItem)
{
	hItem = GetChildItem(hItem);
	while(hItem != NULL)
	{
		CXMLNodeInfo *pData = (CXMLNodeInfo*)GetItemData(hItem);
		delete pData;
		DeleteAllItemData(hItem);
		hItem = GetNextSiblingItem(hItem);
	}
}
HTREEITEM CArchTextLibTreeCtrl::CopyItem(HTREEITEM hItem, HTREEITEM htiNewParent, HTREEITEM htiAfter)
{
	if(hItem == NULL || htiNewParent == NULL)
		return NULL;
	if (m_pXMLDoc)
	{
		CXMLNodeInfo *pData = (CXMLNodeInfo *)GetItemData(hItem);
		if(pData == NULL)
		{
			return NULL;
		}
		CXMLDOMNodePtr pOldXMLDOMNodePtr = m_pXMLDoc->SelectSingleNode(pData->m_strNodeXPath);
		CXMLDOMNodePtr pCloneXMLDOMNodePtr(new CXMLDOMNode(NULL));
		pOldXMLDOMNodePtr->CloneNode(pCloneXMLDOMNodePtr);
		CXMLNodeInfo *pParentData = (CXMLNodeInfo *)GetItemData(htiNewParent);
		CXMLNodeInfo *pPreData = NULL;
		HTREEITEM htest = TVI_ROOT;
		HTREEITEM hfirst = TVI_FIRST;
		if (htiAfter!=TVI_LAST&&htiAfter!=TVI_FIRST)
		{
			pPreData=(CXMLNodeInfo*)GetItemData(htiAfter);
		}
		
		CXMLDOMNodePtr pTemPtr(new CXMLDOMNode(NULL));
		if (pPreData!=NULL)
		{
			if (pPreData->m_strNodeXPath!=_T(""))
			{
				CXMLDOMNodePtr pInSert = m_pXMLDoc->SelectSingleNode(pPreData->m_strNodeXPath);
				if(pInSert.get()->GetNodePtr()!=NULL)
				pInSert->InsertAfter(pCloneXMLDOMNodePtr,pTemPtr);
			}
			else
			{
				if(pParentData != NULL)
				{
					CXMLDOMNodePtr pInSert = m_pXMLDoc->SelectSingleNode(pParentData->m_strNodeXPath);
					if(pInSert.get()->GetNodePtr()!=NULL)
					pInSert->AppendNode(pCloneXMLDOMNodePtr,pTemPtr);
				}
			}
		}
		else
		{
			if(pParentData != NULL)
			{
				CXMLDOMNodePtr pInSert = m_pXMLDoc->SelectSingleNode(pParentData->m_strNodeXPath);
				if(pInSert.get()->GetNodePtr()!=NULL)
				pInSert->AppendNode(pCloneXMLDOMNodePtr,pTemPtr);
			}
		}
		CString strXpath;
		if (pTemPtr.get()->GetNodePtr()==NULL)
		{
			return NULL;
		}
		pOldXMLDOMNodePtr->DeleteNode();
		m_pXMLDoc->GetCurNodeXPath(pTemPtr,strXpath);
		pData->m_strNodeXPath = strXpath;
		hItem = InsertItemEx((CXMLNodeInfo *)pData,htiNewParent,htiAfter);
		//m_pXMLDoc->Save();//切忌 此函数一定放在domfile指针操作 最后
		XmlNodeToTreeNode(hItem, pTemPtr);
	}
	return hItem;
}

void CArchTextLibTreeCtrl::OnRButtonDown(UINT nFlags, CPoint point)
{
	HTREEITEM hItem = HitTest(point);
	if(hItem != NULL)
	{
		SetFocus();
		SelectItem(hItem);
	}
	CMenu popup;
	popup.CreatePopupMenu();
	if(hItem == NULL)
	{
		popup.AppendMenu(MF_STRING, ID_EXPAND_WORKS, _T("全部展开"));
		popup.AppendMenu(MF_STRING, ID_COLLAPSE_WORKS, _T("全部收拢"));
	}
	else
	{
		CXMLNodeInfo *pData = (CXMLNodeInfo *)GetItemData(hItem);
		if(pData == NULL)
			return;
		CString strType;
		if (pData->m_strNodeAttributeValue!=_T(""))
		{
			strType = pData->m_strNodeAttributeValue;
		}
		else
		{
			strType = pData->m_strNodeName;
		}
		//if(strType != _T("最近使用的词")||strType != _T("上华词库"))
		//{
		if(ItemHasChildren(hItem) && (GetItemState(hItem, TVIS_EXPANDED) & TVIS_EXPANDED) == TVIS_EXPANDED)
		{
			popup.AppendMenu(MF_STRING, ID_COLLAPSE_COLLECT, _T("收拢"));
		}
		else
		{
			popup.AppendMenu(MF_STRING, ID_EXPAND_COLLECT, _T("展开"));
			if(!ItemHasChildren(hItem))
				popup.EnableMenuItem(ID_EXPAND_COLLECT, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		}
		popup.AppendMenu(MF_STRING, ID_ADD_CHILD_COLLECT, _T("添加子目录"));
		HTREEITEM hRoot = GetRootItem();
		popup.AppendMenu(MF_STRING,ID_ADD_CHILD_LEMMA,_T("添加新词条"));
		if (hRoot==hItem)
		{
			popup.EnableMenuItem(ID_ADD_CHILD_LEMMA, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		}
		if (hRoot==hItem|| pData->m_strNodeAttributeValue ==c_szLate)
		{
			popup.AppendMenu(MF_STRING,ID_DEL_COLLECT,_T("删除目录"));
			popup.EnableMenuItem(ID_DEL_COLLECT, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		}
		else
		{
			popup.AppendMenu(MF_STRING,ID_DEL_COLLECT,_T("删除目录"));
		}
//		popup.AppendMenu(MF_STRING,ID_REN_COLLECT,_T("重命名"));
		popup.AppendMenu(MF_STRING,ID_REN_COLLECT,_T("重命名"));
		//if (hRoot==hItem)
		//{
		//	popup.EnableMenuItem(ID_REN_COLLECT, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		//}
		
		//}
	}
	ClientToScreen(&point);
	popup.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this);
}
void CArchTextLibTreeCtrl::SetXMLDoc(CXMLDOMFile*pXMLDoc)
{
	m_pXMLDoc = pXMLDoc;
}
/////////////////////////////////////////////
CXMLNodeInfo GetNodeInfo(const CXMLDOMNodePtr& pXmlNode,CXMLDOMFile *pXMLDoc)
{
	CXMLNodeInfo TemInfo;
	CXMLDOMNodePtr pRoot = pXMLDoc->GetRoot();
	if (!pXmlNode->HasChildNodes())
	{
		if (*pXmlNode.get()!=*pRoot.get())
		{
			TemInfo.m_bLeafNode = TRUE;
			TemInfo.m_strNodeName = pXmlNode->GetNodeName();
			TemInfo.m_strNodeValue = pXmlNode->GetNodeValue();
			TemInfo.m_strNodeAttributeName = pXmlNode->GetAttributeName();
			TemInfo.m_strNodeAttributeValue = pXmlNode->GetAttributeValue(TemInfo.m_strNodeAttributeName);
		}
		else
		{
			TemInfo.m_bLeafNode = FALSE;
			TemInfo.m_strNodeName = c_szAll;
		}
	}
	else
	{
		if (*pXmlNode.get()!=*pRoot.get())
		{
			TemInfo.m_bLeafNode = FALSE;
			TemInfo.m_strNodeName = pXmlNode->GetNodeName();
			TemInfo.m_strNodeAttributeName = pXmlNode->GetAttributeName();
			TemInfo.m_strNodeAttributeValue = pXmlNode->GetAttributeValue(TemInfo.m_strNodeAttributeName);
		}
		else
		{
			TemInfo.m_bLeafNode = FALSE;
			TemInfo.m_strNodeName = c_szAll;
		}
	}
	//CString strTem;
	//pXMLDoc->GetCurNodeXPath(pXmlNode,strTem);
	//TemInfo.m_strNodeXPath = strTem;
	return TemInfo;
}

CXMLNodeInfo GetNodeInfoEx(const CXMLDOMNodePtr& pXmlNode,CXMLDOMFile *pXMLDoc)
{
	CXMLNodeInfo TemInfo;
	CXMLDOMNodePtr pRoot = pXMLDoc->GetRoot();
	if (!pXmlNode->HasChildNodes())
	{
		if (*pXmlNode.get()!=*pRoot.get())
		{
			TemInfo.m_bLeafNode = TRUE;
			TemInfo.m_strNodeName = pXmlNode->GetNodeName();
			TemInfo.m_strNodeValue = pXmlNode->GetNodeValue();
			TemInfo.m_strNodeAttributeName = pXmlNode->GetAttributeName();
			TemInfo.m_strNodeAttributeValue = pXmlNode->GetAttributeValue(TemInfo.m_strNodeAttributeName);
		}
		else
		{
			TemInfo.m_bLeafNode = FALSE;
			TemInfo.m_strNodeName = c_szAll;
		}
	}
	else
	{
		//if (*pXmlNode.get()!=*pRoot.get())
		//{
			TemInfo.m_bLeafNode = FALSE;
			TemInfo.m_strNodeName = pXmlNode->GetNodeName();
			if (*pXmlNode.get()==*pRoot.get())
			{
				CString str = pXmlNode->GetAttributeName();;
				if (str!=_T(""))
				{
					TemInfo.m_strNodeAttributeName = pXmlNode->GetAttributeName();
					TemInfo.m_strNodeAttributeValue = pXmlNode->GetAttributeValue(TemInfo.m_strNodeAttributeName);
				}
			}
			else
			{
				TemInfo.m_strNodeAttributeName = pXmlNode->GetAttributeName();
				TemInfo.m_strNodeAttributeValue = pXmlNode->GetAttributeValue(TemInfo.m_strNodeAttributeName);
			}
	}
	CString strTem;
	pXMLDoc->GetCurNodeXPath(pXmlNode,strTem);
	TemInfo.m_strNodeXPath = strTem;
	return TemInfo;
}
BOOL OPenXmlDoc(CXMLDOMFile&xmlDoc)
{
	TCHAR *strParth = new TCHAR[MAX_PATH] ;
	if(!FindFile(_T("dict.xml"), strParth)) 
	{
		delete []strParth;
		return FALSE;
	}
	if (xmlDoc.IsFileExist(strParth))
	{

		if (xmlDoc.Open(strParth))
		{
			delete []strParth;
			return TRUE;
		}
		else
		{
			delete []strParth;
			return FALSE;
		}
	}
	delete []strParth;
	return FALSE;
}
/////////////////////////////////////////////
void CChineseCode::UTF_8ToUnicode(wchar_t* pOut,char *pText) 
{ 
	char* uchar = (char *)pOut; 

	uchar[1] = ((pText[0] & 0x0F) << 4) + ((pText[1] >> 2) & 0x0F); 
	uchar[0] = ((pText[1] & 0x03) << 6) + (pText[2] & 0x3F); 

	return; 
} 

void CChineseCode::UnicodeToUTF_8(char* pOut,wchar_t* pText) 
{ 
	// 注意 WCHAR高低字的顺序,低字节在前，高字节在后 
	char* pchar = (char *)pText; 

	pOut[0] = (0xE0 | ((pchar[1] & 0xF0) >> 4)); 
	pOut[1] = (0x80 | ((pchar[1] & 0x0F) << 2)) + ((pchar[0] & 0xC0) >> 6); 
	pOut[2] = (0x80 | (pchar[0] & 0x3F)); 

	return; 
} 

void CChineseCode::UnicodeToGB2312(char* pOut,wchar_t uData) 
{ 
	WideCharToMultiByte(CP_ACP,NULL,&uData,1,pOut,sizeof(wchar_t),NULL,NULL); 
	return; 
}      

void CChineseCode::Gb2312ToUnicode(wchar_t* pOut,char *gbBuffer) 
{ 
	::MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,gbBuffer,2,pOut,1); 
	return ; 
} 

void CChineseCode::GB2312ToUTF_8(CString& pOut,char *pText, int pLen) 
{ 
	char buf[4]; 
	int nLength = pLen* 3; 
	char* rst = new char[nLength]; 

	memset(buf,0,4); 
	memset(rst,0,nLength); 

	int i = 0; 
	int j = 0;       
	while(i < pLen) 
	{ 
		//如果是英文直接复制就可以 
		if( *(pText + i) >= 0) 
		{ 
			rst[j++] = pText[i++]; 
		} 
		else 
		{ 
			wchar_t pbuffer; 
			Gb2312ToUnicode(&pbuffer,pText+i); 

			UnicodeToUTF_8(buf,&pbuffer); 

			unsigned short int tmp = 0; 
			tmp = rst[j] = buf[0]; 
			tmp = rst[j+1] = buf[1]; 
			tmp = rst[j+2] = buf[2];     

			j += 3; 
			i += 2; 
		} 
	} 
	rst[j] = '\0'; 

	//返回结果 
	pOut = rst;              
	delete []rst;    

	return; 
} 

void CChineseCode::UTF_8ToGB2312(CString &pOut, char *pText, int pLen) 
{ 
	char * newBuf = new char[pLen]; 
	char Ctemp[4]; 
	memset(Ctemp,0,4); 
	int i =0; 
	int j = 0; 
	while(i < pLen) 
	{ 
		if(pText[i] > 0) 
		{ 
			newBuf[j++] = pText[i++];                        
		} 
		else                  
		{ 
			WCHAR Wtemp; 
			UTF_8ToUnicode(&Wtemp,pText + i); 

			UnicodeToGB2312(Ctemp,Wtemp); 

			newBuf[j] = Ctemp[0]; 
			newBuf[j + 1] = Ctemp[1]; 

			i += 3;     
			j += 2;    
		} 
	} 
	newBuf[j] = '\0';  
	pOut = newBuf; 
	delete []newBuf; 
	return;  
}