// FindAndReplaceDlg.cpp : implementation file
//

#include "stdafx.h"
#include "WGroupCtrl.h"
#include "WGroupDlg.h"
#include "FindAndReplaceDlg.h"
#include "actrans.h"
#include <fstream>
#include <acutil.h>

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

static CFindAndReplaceDlg *pDlg = NULL;
// Zyu delete on 101019,代码封装到CFARInsert类中
//int GetAttribNum(AcDbBlockReference &entInsert)
//{
//	int num=0;
//	AcDbObjectIterator *pIter=entInsert.attributeIterator();
//	for(pIter->start(); !pIter->done(); pIter->step()) {
//		num++;
//	}
//	delete pIter;
//	return num;
//}
//
//BOOL GetAttribText(AcDbBlockReference &entInsert, int idx, TDbText &text, AcDbObjectId &idObjRet)
//{
//	AcDbObjectIterator *pIter=entInsert.attributeIterator();
//	int num=0;
//	BOOL bRet=FALSE;
//	for(pIter->start(); !pIter->done(); pIter->step()) {
//		if(num==idx) {
//			AcDbObjectId idObj=pIter->objectId();
//			OPENOBJ_BEGIN(idObj, AcDb::kForRead, AcDbAttribute, pAttr);
//			if(pAttr && !pAttr->isInvisible()) {
//				if(text.ConvertFrom(pAttr)) {
//					idObjRet=idObj;
//					bRet=TRUE;
//				}
//			}
//			OPENOBJ_END();
//			break;
//		}
//		num++;
//	}
//	delete pIter;
//	return bRet;
//}
// Zyu add on 100927，查找对象文本的几个函数
// Begin
//// 搜索上华对象内的文字
//TTextPosition FindInTDbEnt(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
//{
//	TDbEntity *pText = TDbEntity::cast(pEnt);
//	return pText->FindSubText(sSubText, posStart, pRange);
//}
//
//TTextPosition FindInInsert(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
//{
//	TTextPosition posFind;
//	XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
//	AcDbBlockReference *pInsert=AcDbBlockReference::cast(pEnt);
//	int nLen=GetAttribNum(*pInsert);
//	//int nCode=RTNONE;
//	TTextPosition posNext=posStart;
//	for(int i=posStart.m_nCookies; i<nLen; i++)
//	{
//		TDbText dimText;
//		TTextPosition posRet;
//		posNext.m_nCookies=i;
//		AcDbObjectId idObj;
//		if(GetAttribText(*pInsert, i, dimText, idObj))
//		{
//			posRet=dimText.FindSubText(sSubText, posNext, pRange);
//		}
//		if(!posRet)
//		{
//			posNext.m_nTextPos=0;
//		}
//		else
//		{
//			posStart=posNext;
//			if(!posStart && posStart.m_nCookies<(unsigned int)(nLen-1))
//			{
//				posStart.m_nCookies++;
//				posStart.m_nTextPos=0;
//			}
//			posRet.m_nCookies=i;
//			posFind = posRet;
//			break;
//		}
//	}
//	return posFind;
//}
//
//TTextPosition FindInText(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
//{
//	TTextPosition posFind;
//	XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
//	TDbText text;
//	AcDbText *pText = AcDbText::cast(pEnt);
//	if(text.ConvertFrom(pText))
//	{
//		posFind = text.FindSubText(sSubText, posStart, pRange);
//	}
//	return posFind;
//}
//
//TTextPosition FindInMText(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
//{
//	TTextPosition posFind;
//	XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
//	AcDbVoidPtrArray arEnts;
//	if (Acad::eOk == pEnt->explode(arEnts))
//	{
//		for (int i = posStart.m_nCookies; i < arEnts.length(); i++)
//		{
//			posFind = FindInText((AcDbEntity*)arEnts.at(i), sSubText, posStart, pRange);
//			if (!!posFind)
//			{
//				break;
//			}
//			else
//			{
//				posStart.m_nTextPos = -1;
//			}
//		}
//		ReleaseEntSet(arEnts);
//	}
//	return posFind;
//}
//
//TTextPosition FindInDimension(AcDbEntity *pEnt, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
//{
//	TTextPosition posFind;
//	AcDbDimension *pDim = AcDbDimension::cast(pEnt);
//	if (NULL != pDim)
//	{
//		AcDbVoidPtrArray arEnts;
//		if (Acad::eOk == pDim->explode(arEnts))
//		{
//			for(int i = 0; i < arEnts.length(); i++)
//			{
//				AcDbEntity *pEntity = (AcDbEntity*)arEnts.at(i);
//				AcDbMText *pText = AcDbMText::cast(pEntity);
//				if (NULL != pText)
//				{
//					posFind = FindInMText(pText, sSubText, posStart, pRange);
//				}
//			}
//			ReleaseEntSet(arEnts);
//		}
//	}
//	return posFind;
//}
//// End

// Zyu delete on 101019,代码移植到CFARUtil类中
/*
TTextPosition  FindEntText(Entity ent, const TCHAR *sSubText, TTextPosition &posStart, TTextRange *pRange)
{
	TTextPosition posFind;
	if(!sSubText || !sSubText[0])
		return posFind;

	OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
	if(pEnt->isKindOf(TDbEntity::desc())) {
		TDbEntity *pText=TDbEntity::cast(pEnt);
		posFind=pText->FindSubText(sSubText, posStart, pRange);
	} else if(pEnt->isKindOf(AcDbText::desc())) {
		XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
		TDbText text;
		AcDbText *pText=AcDbText::cast(pEnt);
		if(text.ConvertFrom(pText)) {
			posFind = text.FindSubText(sSubText, posStart, pRange);
		}
	} else if(pEnt->isA()==AcDbBlockReference::desc()) {
		XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
		AcDbBlockReference *pInsert=AcDbBlockReference::cast(pEnt);
        int nLen=GetAttribNum(*pInsert);
		//int nCode=RTNONE;
		TTextPosition posNext=posStart;
		for(int i=posStart.m_nCookies; i<nLen; i++) {
			TDbText dimText;
			TTextPosition posRet;
			posNext.m_nCookies=i;
			AcDbObjectId idObj;
			if(GetAttribText(*pInsert, i, dimText, idObj)) {
				posRet=dimText.FindSubText(sSubText, posNext, pRange);
			}
			if(!posRet) {
				posNext.m_nTextPos=0;
			} else {
				posStart=posNext;
				if(!posStart && posStart.m_nCookies<(unsigned int)(nLen-1)) {
					posStart.m_nCookies++;
					posStart.m_nTextPos=0;
				}
				posRet.m_nCookies=i;
			    posFind = posRet;
				break;
			}
		}
    }
	OPENOBJ_END();

	return posFind;
}


// 返回下次查找的位置
TTextPosition ReplaceEntText(Entity ent, TTextPosition posFind, const TCHAR *szRepText)
{
	TTextPosition posStart;
	OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
	if(pEnt->isKindOf(TDbEntity::desc())) {
		TDbEntity *pText=TDbEntity::cast(pEnt);
		if(pText->upgradeOpen()==Acad::eOk)		{
			posStart = pText->ReplaceSubText(posFind, szRepText);
			pText->downgradeOpen();
		} 		else 		{
			adsout << _T("\n无法修改文字对象!");
		}
	} else if(pEnt->isKindOf(AcDbText::desc())) {
		XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
		TDbText text;
		AcDbText *pText=AcDbText::cast(pEnt);
		if(text.ConvertFrom(pText)) {
			posStart = text.ReplaceSubText(posFind, szRepText);
			if(pText->upgradeOpen()==Acad::eOk) {
				pText->setTextString((const TCHAR *)text.GetText());
				pText->downgradeOpen();
			} 	else 		{
				adsout << _T("\n无法修改文字对象!");
			}
		}
	} else if(pEnt->isA()==AcDbBlockReference::desc()) {
		XPushMemVar<BOOL> vTemp(g_bTextStyleEx, FALSE);
		AcDbBlockReference *pInsert=AcDbBlockReference::cast(pEnt);
		int numAttrib=GetAttribNum(*pInsert);;
		posStart.m_nBufLen=_tcslen(szRepText);
		posStart.m_nCookies=posFind.m_nCookies;
		if(!posFind || posFind.m_nCookies>=(unsigned int)numAttrib) {
			;
		} else {
			TDbText dimText;
			TTextPosition posRet;
			AcDbObjectId idObj;
			if(GetAttribText(*pInsert, posFind.m_nCookies, dimText, idObj)) {
				posRet=dimText.ReplaceSubText(posFind, szRepText);
				OPENOBJ_BEGIN(idObj, AcDb::kForWrite, AcDbAttribute, pText);
				if(pText) {
					pText->setTextString(dimText.GetText());
				}
				OPENOBJ_END();
			}
			if(!posRet) {
				if(posRet.m_nCookies<(unsigned int)(numAttrib-1)) {
					posRet.m_nCookies=posFind.m_nCookies+1;
					posRet.m_nTextPos=0;
				}
			}
			posStart=posRet;
		}
	}
	OPENOBJ_END();
	return posStart;
}
*/

//////////////////////////////////////////////////////////////////////////
// Zyu add on 100925，关联XML和表格的类
CTextTypeFileReader::CTextTypeFileReader()
{
	::CoInitialize(NULL);
	m_pLstCtrl = NULL;
	m_sFilePath = _T("");
	m_pDoc = NULL;
}

CTextTypeFileReader::~CTextTypeFileReader()
{
	::CoUninitialize();
	m_pLstCtrl = NULL;
	m_pDoc = NULL;
}


// 设置xml文件位置
void CTextTypeFileReader::SetFilePath(LPCTSTR pszFilePath)
{
	m_sFilePath = pszFilePath;
}

// 设置xml文件关联的列表控件
void CTextTypeFileReader::SetListCtrl(CListCtrl *pCmbCtrl)
{
	m_pLstCtrl = pCmbCtrl;
}


// 初始化
bool CTextTypeFileReader::Init()
{
	HRESULT hr = m_pDoc.CreateInstance(__uuidof(MSXML2::DOMDocument60));
	return SUCCEEDED(hr);
}

// 保存列表控件内容到xml文件
bool CTextTypeFileReader::SaveToXML()
{
	if (NULL == m_pDoc || NULL == m_pLstCtrl)
	{
		return false;
	}

	// 读取文件
	if(m_pDoc->load((LPCTSTR)m_sFilePath) != VARIANT_TRUE)
	{
		return false;
	}
	// 得到settings一级
	MSXML2::IXMLDOMElementPtr pRoot = m_pDoc->GetdocumentElement();
	if (NULL == pRoot)
	{
		return false;
	}

	MSXML2::IXMLDOMNodeListPtr pNodeList = pRoot->GetchildNodes();
	if (NULL == pNodeList)
	{
		return false;
	}

	pNodeList->reset();
	for (int i = 0; i < pNodeList->Getlength(); i++)
	{
		// 得到content一级
		MSXML2::IXMLDOMNodePtr pNode = pNodeList->nextNode();
		if (NULL != pNode)
		{
			CString sName;
			BOOL bSelected = false;
			// 得到content里的属性
			MSXML2::IXMLDOMNamedNodeMapPtr pNodeMap = pNode->Getattributes();
			if (NULL != pNodeMap)
			{
				MSXML2::IXMLDOMNodePtr pNameAttr = pNodeMap->getNamedItem(_bstr_t(_T("name")));
				if (NULL != pNameAttr)
				{
					_variant_t var = pNameAttr->GetnodeValue();
					sName = (LPCTSTR)_bstr_t(var.bstrVal);
					MSXML2::IXMLDOMNodePtr pSeletedAttr = pNodeMap->getNamedItem(_bstr_t(_T("selected")));
					// 如果名称相同，更新content中的selected值
					if (NULL != pSeletedAttr && sName == m_pLstCtrl->GetItemText(i, 0))
					{
						pSeletedAttr->PutnodeValue((_variant_t)(m_pLstCtrl->GetCheck(i) != FALSE));
					}
				}
			}
		}
	}
	m_pDoc->save((LPCTSTR)m_sFilePath);
	return true;
}

// 读取xml文件内容到列表
bool CTextTypeFileReader::LoadToCmbCtrl()
{
	if (NULL == m_pDoc || NULL == m_pLstCtrl)
	{
		return false;
	}

	// 在表格中添加两列
	m_pLstCtrl->InsertColumn(0, _T(""), LVCFMT_CENTER, 150);
	m_pLstCtrl->InsertColumn(0, _T(""), LVCFMT_CENTER, 150);


	// 读取文件
	m_pDoc->async = VARIANT_FALSE;
	m_pDoc->validateOnParse = VARIANT_FALSE;
	if(m_pDoc->load((LPCTSTR)m_sFilePath) != VARIANT_TRUE)
	{
		return false;
	}

	// 得到settings一级
	MSXML2::IXMLDOMElementPtr pRoot = m_pDoc->GetdocumentElement();
	if (NULL == pRoot)
	{
		return false;
	}

	// 得到content一级
	MSXML2::IXMLDOMNodeListPtr pNodeList = pRoot->GetchildNodes();
	if (NULL == pNodeList)
	{
		return false;
	}

	pNodeList->reset();
	// 遍历每一个content，获得name，selected，DXF码
	for (int i = 0; i < pNodeList->Getlength(); i++)
	{
		MSXML2::IXMLDOMNodePtr pNode = pNodeList->nextNode();
		if (NULL != pNode)
		{
			CString sName;
			BOOL bSelected = false;
			MSXML2::IXMLDOMNamedNodeMapPtr pNodeMap = pNode->Getattributes();
			if (NULL != pNodeMap)
			{
				MSXML2::IXMLDOMNodePtr pNameAttr = pNodeMap->getNamedItem(_bstr_t(_T("name")));
				if (NULL != pNameAttr)
				{
					_variant_t var = pNameAttr->GetnodeValue();
					sName = (LPCTSTR)_bstr_t(var.bstrVal);
				}
				MSXML2::IXMLDOMNodePtr pSeletedAttr = pNodeMap->getNamedItem(_bstr_t(_T("selected")));
				if (NULL != pSeletedAttr)
				{
					_variant_t var = pSeletedAttr->GetnodeValue();
					bSelected = _tcscmp((LPCTSTR)var.bstrVal, _T("0"));
				}
			}

			MSXML2::IXMLDOMNodeListPtr pNodeLst = pNode->GetchildNodes();
			CString sDXFCode;
			if (NULL != pNodeLst)
			{
				for (int j = 0; j < pNodeLst->Getlength(); j++)
				{
					MSXML2::IXMLDOMNodePtr pNodeDxf = pNodeLst->nextNode();
					if (NULL != pNodeDxf)
					{
						_bstr_t var = pNodeDxf->Gettext();
						sDXFCode += (LPCTSTR)var;
					}
				}
			}

			// 信息添加到表格
			int iPos = m_pLstCtrl->GetItemCount();
			m_pLstCtrl->InsertItem(iPos, sName);
			m_pLstCtrl->SetItemText(iPos, 1, sDXFCode);
			m_pLstCtrl->SetCheck(iPos, bSelected);
		}
	}
	return true;
}

//////////////////////////////////////////////////////////////////////////
// CSymDefDlg 对话框
// Zyu add on 100925，通配符定义对话框
IMPLEMENT_DYNAMIC(CSymDefDlg, CDialog)

CSymDefDlg::CSymDefDlg(CWnd* pParent /*=NULL*/)
: CModelessDialog(CSymDefDlg::IDD, pParent)
{
}

CSymDefDlg::~CSymDefDlg()
{
}

BOOL CSymDefDlg::OnInitDialog()
{
	// 填入表格的内容
	CListCtrl *pLstCtrl = (CListCtrl*)GetDlgItem(IDC_LST_DEFINE);
	pLstCtrl->SetExtendedStyle(pLstCtrl->GetExtendedStyle() | LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);
	if (NULL != pLstCtrl)
	{
		pLstCtrl->InsertColumn(0, _T("字符"), LVCFMT_LEFT, 100);
		pLstCtrl->InsertColumn(1, _T("定义"), LVCFMT_LEFT, 400);
		pLstCtrl->InsertItem(0, _T("#（井号）"));
		pLstCtrl->SetItemText(0, 1, _T("匹配任意数字字符"));
		pLstCtrl->InsertItem(1, _T("@(At)"));
		pLstCtrl->SetItemText(1, 1, _T("匹配任意字母字符"));
		pLstCtrl->InsertItem(2, _T(".（句号）"));
		pLstCtrl->SetItemText(2, 1, _T("匹配任意非字母数字字符"));
		pLstCtrl->InsertItem(3, _T("*（星号）"));
		pLstCtrl->SetItemText(3, 1, _T("匹配任意字符串，可以在搜索字符串的任意位置使用"));
		pLstCtrl->InsertItem(4, _T("?（问号）"));
		pLstCtrl->SetItemText(4, 1, _T("匹配任意单个字符，例如，?BC匹配ABC、3BC等等"));
		pLstCtrl->InsertItem(5, _T("~（波浪号）"));
		pLstCtrl->SetItemText(5, 1, _T("匹配不包含自身的任意字符串，例如~*AB*匹配所以有不包含AB的字符串"));
		pLstCtrl->InsertItem(6, _T("[]"));
		pLstCtrl->SetItemText(6, 1, _T("匹配括号中包含的任意一个字符，例如，[AB]C匹配AC和BC"));
		pLstCtrl->InsertItem(7, _T("[~]"));
		pLstCtrl->SetItemText(7, 1, _T("匹配括号中未包含的任意字符，例如，[~AB]C匹配XC而不匹配AC"));
		pLstCtrl->InsertItem(8, _T("[-]"));
		pLstCtrl->SetItemText(8, 1, _T("指定单个字符的范围，例如，[A-G]C匹配AC、BC等，直到GC，但不匹配HC"));
		pLstCtrl->InsertItem(9, _T("'（单引号）"));
		pLstCtrl->SetItemText(9, 1, _T("逐字读取其后的字符；例如，'~AB匹配~AB"));
	}
	return CDialog::OnInitDialog();
}

BEGIN_MESSAGE_MAP(CSymDefDlg, CModelessDialog)
END_MESSAGE_MAP()

//////////////////////////////////////////////////////////////////////////
// Zyu add on 100917，设置选项
BOOL CFindAndReplaceDlg::m_bFind = true;
BOOL CFindAndReplaceDlg::m_bReplace = true;
BOOL CFindAndReplaceDlg::m_bPrefix = true;
BOOL CFindAndReplaceDlg::m_bSuffix = false;
BOOL CFindAndReplaceDlg::m_bIncrement = true;
BOOL CFindAndReplaceDlg::m_bAutoZoom = true;
BOOL CFindAndReplaceDlg::m_bCaseSencitive = true;
BOOL CFindAndReplaceDlg::m_bWordMatch = false;
BOOL CFindAndReplaceDlg::m_bWordMatchOld = false;
BOOL CFindAndReplaceDlg::m_bWildcards = false;
BOOL CFindAndReplaceDlg::m_bWildcardsOld = false;
BOOL CFindAndReplaceDlg::m_bSearchXref = false;
BOOL CFindAndReplaceDlg::m_bSearchBlock = true;
BOOL CFindAndReplaceDlg::m_bNoHidden = true;
BOOL CFindAndReplaceDlg::m_bWidthSensitive = false;
BOOL CFindAndReplaceDlg::m_bGrpSetStatus = false;
int  CFindAndReplaceDlg::m_iReplaceType = 0;


CFindAndReplaceDlg::CFindAndReplaceDlg(CWnd* pParent /*=NULL*/)
	: WGroupDlg(CFindAndReplaceDlg::IDD, pParent), m_ssText(SS_FREE), m_ssTextAll(SS_FREE)
	,m_dwPosFind(0)
	,m_dwPosReplace(0)
	,m_bBlkAttrib(0)
	,m_strDefaultFilter(_T(""))
{
	//{{AFX_DATA_INIT(CFindAndReplaceDlg)
	m_sFindText = _T("");
	m_sReplaceText =_T("");
	m_iFindRange = -1;
	// Zyu delete on 100916，删除无用数据
	//m_bAttdef = FALSE;
	//}}AFX_DATA_INIT
	m_nTextNum = 0;
	m_nTextNumAll = 0;
	m_sOldFindText = _T("");
	m_bIsFindEnd = FALSE;
	m_crPrompt = RGB(0,0,0);
}


void CFindAndReplaceDlg::DoDataExchange(CDataExchange* pDX)
{
	WGroupDlg::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CFindAndReplaceDlg)
	DDX_Control(pDX, IDC_COMBO_FINDTEXTS, m_comboFindText);
	DDX_Control(pDX, IDC_COMBO_REPLACETEXT, m_comboReplaceText);
	DDX_Control(pDX, IDC_CMB_PREFIX, m_cmbPrefix);
	DDX_Control(pDX, IDC_CMB_SUFFIX, m_cmbSuffix);
	DDX_Control(pDX, IDC_CMB_INCREMENT, m_cmbIncrement);
	DDX_CBString(pDX, IDC_COMBO_FINDTEXTS, m_sFindText);
	DDX_CBString(pDX, IDC_COMBO_REPLACETEXT, m_sReplaceText);
	DDX_CBString(pDX, IDC_CMB_PREFIX, m_sPrefixText);
	DDX_CBString(pDX, IDC_CMB_SUFFIX, m_sSuffixText);
	DDX_CBString(pDX, IDC_CMB_INCREMENT, m_sIncrementText);
	DDX_CBIndex(pDX, IDC_COMBO_FINDRANGE, m_iFindRange);
	// Zyu delete on 100916，删除无用控件
	//DDX_Check(pDX, IDC_CHECK_ATTDEF, m_bAttdef);
	DDX_Check(pDX, IDC_CHK_SEARCH, m_bFind);
	DDX_Check(pDX, IDC_CHK_REPLACE, m_bReplace);
	DDX_Check(pDX, IDC_CHK_PREFIX, m_bPrefix);
	DDX_Check(pDX, IDC_CHK_SUFFIX, m_bSuffix);
	DDX_Check(pDX, IDC_CHK_INCREMENT, m_bIncrement);
	DDX_Check(pDX, IDC_CHK_AUTOZOOM, m_bAutoZoom);
	DDX_Check(pDX, IDC_CHK_CASESENSITIVE, m_bCaseSencitive);
	DDX_Check(pDX, IDC_CHK_WORDMATCH, m_bWordMatch);
	DDX_Check(pDX, IDC_CHK_WILDCARDS, m_bWildcards);
	DDX_Check(pDX, IDC_CHK_SEARCHXREF, m_bSearchXref);
	DDX_Check(pDX, IDC_CHK_SEARCHBLOCK, m_bSearchBlock);
	DDX_Check(pDX, IDC_CHK_NOHIDDEN, m_bNoHidden);
	DDX_Check(pDX, IDC_CHK_WIDTHSENSITIVE, m_bWidthSensitive);
	DDX_Control(pDX, IDC_STC_SET, m_grpSet);
	DDX_GroupStatus(pDX,IDC_STC_SET, m_bGrpSetStatus);
	DDX_Control(pDX, IDC_LST_TYPE, m_lstStyle);
	//}}AFX_DATA_MAP
	DDX_Radio(pDX, IDC_RAD_REPLACE, m_iReplaceType);
}


BEGIN_MESSAGE_MAP(CFindAndReplaceDlg, WGroupDlg)
	//{{AFX_MSG_MAP(CFindAndReplaceDlg)
	ON_BN_CLICKED(IDC_BUTTON_FIND, OnButtonFind)
	ON_BN_CLICKED(IDC_BUTTON_REPLACE, OnButtonReplace)
	ON_BN_CLICKED(IDC_BUTTON_REPLACEALL, OnButtonReplaceall)
	ON_BN_CLICKED(IDC_BUTTON_SELECT, OnButtonSelect)
	ON_CBN_SELCHANGE(IDC_COMBO_FINDRANGE, OnSelchangeComboFindrange)
	ON_CBN_EDITCHANGE(IDC_COMBO_FINDTEXTS, OnCbnEditchangeComboFindtexts)
	ON_CBN_KILLFOCUS(IDC_COMBO_REPLACETEXT, OnCbnKillfocusComboReplacetext)
	ON_CBN_KILLFOCUS(IDC_CMB_PREFIX, OnCbnKillfocusCmbPrefix)
	ON_CBN_KILLFOCUS(IDC_CMB_SUFFIX, OnCbnKillfocusCmbSuffix)
	ON_CBN_KILLFOCUS(IDC_CMB_INCREMENT, OnCbnKillfocusCmbIncrement)
	ON_CBN_KILLFOCUS(IDC_COMBO_FINDTEXTS, OnCbnKillfocusComboFindtexts)
	ON_CBN_SELCHANGE(IDC_COMBO_FINDTEXTS, OnCbnSelchangeComboFindtexts)
	ON_WM_DESTROY()
	ON_WM_CTLCOLOR()
	ON_BN_CLICKED(IDC_RAD_REPLACE, OnBnClickedRadReplace)
	ON_BN_CLICKED(IDC_RAD_INFIX, OnBnClickedRadInfix)
	ON_BN_CLICKED(IDC_RAD_INCREMENT, OnBnClickedRadIncrement)
	ON_BN_CLICKED(IDC_CHK_SEARCH, OnBnClickedChkSearch)
	ON_BN_CLICKED(IDC_CHK_REPLACE, OnBnClickedChkReplace)
	ON_BN_CLICKED(IDC_CHK_PREFIX, OnBnClickedChkPrefixOrSuffix)
	ON_BN_CLICKED(IDC_CHK_SUFFIX, OnBnClickedChkPrefixOrSuffix)
	ON_BN_CLICKED(IDC_CHK_INCREMENT, OnBnClickedChkIncrement)
	ON_BN_CLICKED(IDC_CHK_WORDMATCH, OnBnClickedChkWordmatch)
	ON_BN_CLICKED(IDC_CHK_WILDCARDS, OnBnClickedChkWildcards)
	ON_BN_CLICKED(IDC_CHK_SEARCHXREF, OnBnClickedChkSearchxref)
	ON_BN_CLICKED(IDC_CHK_CASESENSITIVE, OnBnClickedChkCasesensitive)
	ON_BN_CLICKED(IDC_CHK_NOHIDDEN, OnBnClickedChkNohidden)
	ON_BN_CLICKED(IDC_CHK_WIDTHSENSITIVE, OnBnClickedChkWidthsensitive)
	ON_BN_CLICKED(IDC_CHK_SEARCHBLOCK, OnBnClickedChkSearchblock)
	ON_BN_CLICKED(IDC_BTN_FIND, OnBnClickedBtnFind)
	ON_BN_CLICKED(IDC_BTN_REPLACE, OnBnClickedBtnReplace)
	ON_BN_CLICKED(IDC_BTN_MARKALL, OnBnClickedBtnMarkall)
	ON_BN_CLICKED(IDC_BTN_UNMARKALL, OnBnClickedBtnUnmarkall)
	ON_BN_CLICKED(IDC_BTN_WILDCARDS, OnBnClickedBtnWildcards)
	ON_NOTIFY(LVN_ITEMCHANGED, IDC_LST_TYPE, OnLvnItemchangedLstType)
	ON_WM_CLOSE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


//查找字符串
void CFindAndReplaceDlg::OnButtonFind() 
{
	UpdateData( TRUE );
	// Zyu modify on 101028，新需求允许不给出查找内容
	//if (m_sFindText.IsEmpty())
	//{
	//	AfxMessageBox(_T("查找不能为空！"));
	//	GetDlgItem(IDC_COMBO_FINDTEXTS)->SetFocus();
	//	return;
	//}

	// Zyu add on 101013,设置查找选项
	SetFindOption();
	// Zyu modify on 100919，使用新的函数，在控件失去焦点时插入字符串
	//InsertFindText();
	//InsertReplaceText();			//add by xlc on 090630 解决了查找时替换字符串改变的问题

	//查找字符串
	if (!FindText())
	{
		return;
	}
	CString str;
	// Zyu add on 101029，提示文字变为黑色
	m_crPrompt = RGB(0, 0, 0);
	str.Format(_T("已找到%d个"),m_nFindCount);
	GetDlgItem(IDC_EDIT_RESULT)->SetWindowText(str);
	//判断是否完成对整个图形或者当前选择图形的查找
	if ( m_nTextNum >= m_nTextNumAll)
	{
		m_bIsFindEnd = TRUE;
		CString str;
		// Zyu modify on 101216，查找完毕后，弹出对话框提示
		//str.Format(_T("共找到%d个\r\n查找完毕"),m_nFindCount);
		//GetDlgItem(IDC_EDIT_RESULT)->SetWindowText(str);
		str.Format(_T("      搜索完毕!       \n\n      共找到%d个\n\n      共替换%d个"), m_nFindCount, m_nCount);
		ResetFind();
		MessageBox(str, _T("查找替换"));
		//m_nFindCount =0;
		//m_nCount++;
		//AfxMessageBox(_T("查找完毕!"));
	}
}

//逐个替换字符串
void CFindAndReplaceDlg::OnButtonReplace()
{
	UpdateData( TRUE );
	// Zyu modify on 101028，新需求允许不给出查找内容
	//if (m_sFindText.IsEmpty())
	//{
	//	AfxMessageBox(_T("查找不能为空！"));
	//	GetDlgItem(IDC_COMBO_FINDTEXTS)->SetFocus();
	//	return;
	//}

	CString sFindText;		// 搜索的字符串
	CString sReplaceText;	// 替换的字符串
	GetFindText(sFindText);
	if (!GetReplaceText(sReplaceText))
	{
		return;
	}
	else
	{
		SetDlgItemText(IDC_EDIT_RESULT, _T(""));
		m_crPrompt = RGB(0, 0, 0);
	}

	// Zyu modify on 100919，使用新的函数，在控件失去焦点时插入字符串
	//InsertFindText();
	//InsertReplaceText();

	//判断查找的字符串是否变换,若变,则使找按钮不能被选择
	//if ( m_sOldFindText != m_sFindText )
	if ( m_sOldFindText != sFindText )
	{
		// Zyu modify on 101029，使用新的函数
		//CWnd* pWnd = GetDlgItem(IDC_BUTTON_REPLACE);
		//pWnd->EnableWindow( FALSE );
		EnableReplace();
		return;
	}
	//m_sOldFindText = m_sFindText;
	m_sOldFindText = sFindText;

	if ( m_nTextNum > m_nTextNumAll)
	{
		AfxMessageBox( _T("查找完毕!") );
		return;
	}
	long nTextNum = m_nTextNum;
	nTextNum = m_nTextNum;
	Entity ent = m_ssText[nTextNum];
	int nLen = m_ssText.Length();
	ASSERT(nLen != 0);

	acDocManager->lockDocument(curDoc(),AcAp::kWrite,NULL,NULL,true);
	// Zyu modify on 101019,使用新的替换函数
	//m_posStart=ReplaceEntText(ent, m_posFind, m_sReplaceText);
	m_posStart = m_farUtil.ReplaceEntText(ent, m_posFind, sReplaceText);
	acDocManager->unlockDocument(curDoc());


	//static int nCount =0;
	// Zyu add on 101029，提示文字变为黑色
	m_crPrompt = RGB(0, 0, 0);
	if (m_posStart.m_nBufLen>0)
	{
		m_nCount++;
		CString str;
		str.Format(_T("已替换%d个"),m_nCount);
		GetDlgItem(IDC_EDIT_RESULT)->SetWindowText(str);
		SHads_command(RTSTR, _T("REGEN"), RTNONE);
	}
	if(!m_posStart)
		m_nTextNum++;
	
	//刷新
//	acedRedraw(NULL,1);
	TPickEntSet ssTemp; // add by lgh.改变刷新方式，只刷新本实体的显示
	ssTemp += ent;
	UpdateGraphic(ssTemp);
	actrTransactionManager->flushGraphics();
	acedUpdateDisplay();

	// 设置查找选项
	SetFindOption();
	FindText();//查找字符串

	if ( m_nTextNum >= m_nTextNumAll)
	{
		m_bIsFindEnd = TRUE;
		// Zyu add on 101215，“全部替换”按钮也变灰
		CString str;
		str.Format(_T("      搜索完毕!       \n\n      共找到%d个\n\n      共替换%d个"), m_nFindCount, m_nCount);
		ResetFind();
		MessageBox(str, _T("查找替换"));

		return;
	}

}

//替换所有与查找字符串相匹配的字符串
void CFindAndReplaceDlg::OnButtonReplaceall()
{
	UpdateData( TRUE );
	// 设置查找选项
	SetFindOption();

	// Zyu modify on 100919，使用新的函数，在控件失去焦点时插入字符串
	//InsertFindText();
	//InsertReplaceText();

	// Zyu modify on 101028，新需求允许不给出查找内容
	//if (m_sFindText.IsEmpty())
	//{
	//	AfxMessageBox(_T("查找不能为空！"));
	//	GetDlgItem(IDC_COMBO_FINDTEXTS)->SetFocus();
	//	return;
	//}

	CString sFindText;		// 搜索的字符串
	CString sReplaceText;	// 替换的字符串
	GetFindText(sFindText);

	//if ( m_sOldFindText != m_sFindText )
	if ( m_sOldFindText != sFindText )
	{
		m_bIsFindEnd = FALSE;
		m_nTextNum = 0;
	}

	// sg modify 110818，从循环中拿出来，主要是解决执行撤销操作的时候，希望一次性全部撤销的情况
	acDocManager->lockDocument(curDoc(),AcAp::kWrite,NULL,NULL,true);

	BOOL bFind = FALSE;
	// Zyu delete on 101104，替换数量包括单个替换的实体
	//int nCount = 0;
	//modify by xlc on 070810
//	for( long i = m_nTextNum; i < m_nTextNumAll; i++)	{
	// Zyu modify on 101216，全部替换从当前位置开始
	//for( long i = 0; i < m_nTextNumAll; i++)	{
	for( long i = m_nTextNum; i < m_nTextNumAll; i++)	{
		Entity ent=m_ssText[i];
		//TTextPosition pos;
		while(1)		{
			TTextRange range;
			// Zyu modify on 101019,使用新的搜索函数
			//TTextPosition posFind = FindEntText(ent, m_sFindText, pos, &range);
			if (!m_posFind)
			{
				m_posFind = m_farUtil.FindEntText(ent, sFindText, m_posStart, &range);

				if(!m_posFind)	
					break;

				m_nFindCount++;
			}

			// Zyu add on 101028，得到要替换的字符串
			if (!GetReplaceText(sReplaceText))
			{
				break;
			}

			bFind=TRUE;
			// Zyu modify on 101019,使用新的替换函数
			//pos = ReplaceEntText(ent, posFind, m_sReplaceText);
			// sg delete 110818，删除了2句话，移到了循环外
			//acDocManager->lockDocument(curDoc(),AcAp::kWrite,NULL,NULL,true);
			m_posStart = m_farUtil.ReplaceEntText(ent, m_posFind, sReplaceText);
			//acDocManager->unlockDocument(curDoc());
			if (m_posStart.m_nBufLen>0)
			{
				// Zyu modify on 101104，替换数量包括单个替换的实体
				//nCount++;
				m_nCount++;
				m_posFind = TTextPosition();
			}
			if(!m_posStart)
				break;
		}

		m_posStart = TTextPosition();
		m_posFind = TTextPosition();
	}

	// sg modify 110818，从循环中拿出来，主要是解决执行撤销操作的时候，希望一次性全部撤销的情况
	acDocManager->unlockDocument(curDoc());

	//刷新
	actrTransactionManager->flushGraphics();
	acedUpdateDisplay();
	acedRedraw(NULL,1);
	SHads_command(RTSTR, _T("REGEN"), RTNONE);

	if (bFind == FALSE)
	{
		CString prompt = _T("没有\"") + m_sFindText + _T("\"!");
		//AfxMessageBox(prompt);
	}
	else
	{
		m_sOldFindText = m_sFindText;
		//AfxMessageBox(_T("替换完毕！"));
	}

	// Zyu add on 101029，提示文字变为黑色
	m_crPrompt = RGB(0, 0, 0);
	// Zyu modify on 101104，不需再提示
	//CString strRes;
	//strRes.Format(_T("共替换了%d个!"),nCount);

	// Zyu modify on 101216，全部替换完毕后，弹出对话框提示
	CString str;
	str.Format(_T("      搜索完毕!       \n\n      共找到%d个\n\n      共替换%d个"), m_nFindCount, m_nCount);
	ResetFind();
	MessageBox(str, _T("查找替换"));
}

//选取对象“选择对象”按钮后，重新构造字符串选择集
void CFindAndReplaceDlg::OnButtonSelect() 
{
	// Zyu modify on 101101，简化代码
	/*
    UpdateData(TRUE);
	HideDialog(TRUE);

	const TCHAR *szPrompt[2]={_T("请选择需要查找和替换的字符串的范围:"), _T("移除物体")};
	RBList TextList(RTDXF0, _T("TCH_*,TEXT,INSERT"), NULL);
	m_ssText.Free();
	if(m_ssText.Get(_T(":$"), szPrompt, NULL, TextList) == RTNORM)
	{
		m_nTextNum = 0;
		m_nTextNumAll = m_ssText.Length();
		m_iFindRange = 0;
		m_posFind=TTextPosition();
		m_posStart=TTextPosition();

	}
	else {
		m_nTextNum = 0;
		m_nTextNumAll = 0;
		m_iFindRange = 0;
		m_posFind=TTextPosition();
		m_posStart=TTextPosition();
	}

	HideDialog(FALSE);
	UpdateData(FALSE);
	*/
	UpdateData(TRUE);
	// 隐藏对话框
	HideDialog(TRUE);
	// 搜索范围修改为用户选择
	m_iFindRange = 2;
	UpdateData(FALSE);

	ResetFind();

	// 用户选择
	const TCHAR *szPrompt[2]={_T("请选择需要查找和替换的字符串的范围:"), _T("移除物体")};
	RBList TextList(RTDXF0, GetFilterString(), NULL);
	m_ssTextAll.Free();
	m_ssText.Free();
	m_ssTextAll.Get(_T(":$"), szPrompt, NULL, TRBList());
	m_ssText += m_ssTextAll;
	m_ssText.BaseFilter(TextList);

	m_nTextNumAll = m_ssText.Length();

	// 显示对话框
	HideDialog(FALSE);
}

BOOL CFindAndReplaceDlg::OnInitDialog() 
{
	WGroupDlg::OnInitDialog();
	m_nCount =0;
	m_nFindCount=0;
	m_sOldFindText = m_sFindText;
	// Zyu modify on 101215，采用新函数
	//CWnd* pWnd = GetDlgItem(IDC_BUTTON_FIND);
	//pWnd->SetWindowText(_T("查找"));
	//pWnd = GetDlgItem(IDC_BUTTON_REPLACE);
	//pWnd->EnableWindow(FALSE);

	// Zyu add on 100925，从XML文件中读取文字样式
	CString sFilePath = g_sAppPath;	//获得Sys目录的路径
#ifdef _WIN64
	sFilePath = sFilePath.Left(sFilePath.GetLength() - 10) + _T("\\sys\\TFindRepFilter.xml");
#else
	sFilePath = sFilePath.Left(sFilePath.GetLength() - 7) + _T("\\sys\\TFindRepFilter.xml");
#endif
	m_lstStyle.SetExtendedStyle(m_lstStyle.GetExtendedStyle() | LVS_EX_CHECKBOXES);
	m_xmlReader.SetFilePath(sFilePath);
	m_xmlReader.SetListCtrl(&m_lstStyle);
	if (m_xmlReader.Init())
	{
		m_xmlReader.LoadToCmbCtrl();
	}
	else
	{
		m_strDefaultFilter = _T("TCH_*,INSERT,TEXT,MTEXT");
	}

	//构造字符串的选择集，如果当前图形已经选择了实体，则对当前选择
	//的图形选择集，否则对整个图形构造
	//RBList TextList(RTDXF0, _T("TCH_*,TEXT,INSERT"), NULL);
	m_ssText.Free();
	m_ssTextAll.Free();
	/*
	if ( m_ssText.Get(_T("I"), NULL, NULL, TextList) == RTNORM )
	{
       m_nTextNumAll = m_ssText.Length();
	}*/
    if(g_ssPickFirst.Length())
		m_ssTextAll += g_ssPickFirst;
	m_ssText += m_ssTextAll;
	RBList TextList(RTDXF0, GetFilterString(), NULL);
	m_ssText.BaseFilter(TextList);

	m_nTextNumAll=m_ssText.Length();
	//判断当前是否有被选中的字符串
	if ( m_nTextNumAll != 0 )	{
		// Zyu modify on 100926，调整组合框内容和顺序
		//m_iFindRange = 0;
		m_iFindRange = 2;
	}	else	{
		// Zyu modify on 101101，拾取实体
		//m_ssText.Free();
		//if( m_ssText.Get(_T("X"), NULL, NULL, TextList ) == RTNORM)		{
		//	m_nTextNumAll = m_ssText.Length();
		//}
		m_iFindRange = 0;
		UpdateData(FALSE);
		PickEntities();
	}

	//加载“选择对象”按钮的位图
	CBitmap  bitmap;
	bitmap.LoadBitmap(IDB_SELECTOBJECT);
	CButton *pButton = (CButton *)GetDlgItem(IDC_BUTTON_SELECT);
	// Zyu add on 100919，加载按钮位图
	CButton *pBtnFind = (CButton *)GetDlgItem(IDC_BTN_FIND);
	CButton *pBtnReplace = (CButton *)GetDlgItem(IDC_BTN_REPLACE);
	pBtnFind->SetBitmap((HBITMAP)bitmap);
	pBtnReplace->SetBitmap((HBITMAP)bitmap);
	pButton->SetBitmap((HBITMAP)bitmap);
	bitmap.Detach();

	// Zyu modify on 100919，添加部分控件的提示
	CButton *pBtnAutoZoom = (CButton *)GetDlgItem(IDC_CHK_AUTOZOOM);
	//if (!m_wndToolTip.Create(pButton))
	if (!m_wndToolTip.Create(pButton)
		&& !m_wndToolTip.Create(pBtnFind)
		&& !m_wndToolTip.Create(pBtnReplace)
		&& !m_wndToolTip.Create(pBtnAutoZoom))
	{
		return FALSE;
	}
    m_wndToolTip.AddTool(pButton, _T("选取对象"));
	m_wndToolTip.AddTool(pBtnFind, _T("屏幕取词"));
	m_wndToolTip.AddTool(pBtnReplace, _T("屏幕取词"));
	m_wndToolTip.AddTool(pBtnAutoZoom, _T("勾选此项后，对于当前查找到的文字内容，程序自动放大到屏幕中心位置显示。"));
	m_wndToolTip.SetMaxTipWidth(230);
	// Zyu modify on 100919，使用统一的读写文件函数
	//初始化“查找"和“替换”字符串
	//LoadFindText();
	//LoadReplaceText();
	LoadText((LPTSTR)_T("findtext.his"), m_comboFindText, m_sFindText);
	LoadText((LPTSTR)_T("replacetext.his"), m_comboReplaceText, m_sReplaceText);
	LoadText((LPTSTR)_T("prefixtext.his"), m_cmbPrefix, m_sPrefixText);
	LoadText((LPTSTR)_T("suffixtext.his"), m_cmbSuffix, m_sSuffixText);
	LoadText((LPTSTR)_T("incrementtext.his"), m_cmbIncrement, m_sIncrementText);

	UpdateData(FALSE);
	// Zyu add on 100919，更新控件状态
	EnableCtrls();
	SetCtrlsVisible();
//	HideDialog(FALSE);
	return TRUE;  
}

//选择了查找范围后，重新构造字符串的选择集
void CFindAndReplaceDlg::OnSelchangeComboFindrange() 
{
	UpdateData(TRUE);
	// Zyu add on 101101，重新选择实体
	ResetFind();
	if (m_iFindRange == 0)
	{
#if ADS<17
			OnButtonSelect();
#endif
	}
	/*
	else
	{
		if(m_iFindRange == 1)
		{
			RBList TextList(RTDXF0, _T("TCH_*,TEXT,INSERT"), NULL);
			m_ssText.Free();
			if(m_ssText.Get(_T("X"), NULL, NULL, TextList ) == RTNORM)
			{
				m_nTextNumAll = m_ssText.Length();
				m_nTextNum=0;
				m_posFind=TTextPosition();
				m_posStart=TTextPosition();
			}
		}
	}
	*/
}

void CFindAndReplaceDlg::OnCbnEditchangeComboFindtexts()
{
	ResetFind();
}

void CFindAndReplaceDlg::OnCbnKillfocusComboFindtexts() 
{
	UpdateData(TRUE);
	CWnd* pWnd = GetDlgItem(IDC_BUTTON_REPLACE);
	
	//modify by xlc on 070810
	/*if ( m_sOldFindText == m_sFindText )
	{
		pWnd->EnableWindow( TRUE );
	}
	else
	{
		m_bIsFindEnd = FALSE;
		pWnd->EnableWindow( FALSE );
	}*/
	if ( m_sOldFindText != m_sFindText )
	{
		m_bIsFindEnd = FALSE;
		pWnd->EnableWindow( FALSE );
		m_nTextNum = 0;
		m_nTextNumAll = m_ssText.Length();
		m_posFind=TTextPosition();
		m_posStart=TTextPosition();

		//modify by xlc on 090720 修改查找内容后计数置0
		m_nFindCount=0;
	}

	InsertText(m_sFindText, m_comboFindText);
}

void CFindAndReplaceDlg::OnCbnKillfocusComboReplacetext()
{
	UpdateData(TRUE);
	InsertText(m_sReplaceText, m_comboReplaceText);
}

void CFindAndReplaceDlg::OnCbnKillfocusCmbPrefix()
{
	UpdateData(TRUE);
	InsertText(m_sPrefixText, m_cmbPrefix);
}

void CFindAndReplaceDlg::OnCbnKillfocusCmbSuffix()
{
	UpdateData(TRUE);
	InsertText(m_sSuffixText, m_cmbSuffix);
}

void CFindAndReplaceDlg::OnCbnKillfocusCmbIncrement()
{
	UpdateData(TRUE);
	InsertText(m_sIncrementText, m_cmbIncrement);
}

void CFindAndReplaceDlg::OnCbnSelchangeComboFindtexts()
{
	ResetFind();	
}

void CFindAndReplaceDlg::OnBnClickedRadReplace()
{
	SetCtrlsVisible();
	EnableCtrls();
	m_bWildcards = m_bWildcardsOld;
	m_bWordMatch = m_bWordMatchOld;
	UpdateData(FALSE);
}

void CFindAndReplaceDlg::OnBnClickedRadInfix()
{
	SetCtrlsVisible();
	EnableCtrls();
	m_bWildcards = m_bWildcardsOld;
	m_bWordMatch = m_bWordMatchOld;
	UpdateData(FALSE);
}

void CFindAndReplaceDlg::OnBnClickedRadIncrement()
{
	SetCtrlsVisible();
	EnableCtrls();
}

void CFindAndReplaceDlg::OnBnClickedChkCasesensitive()
{
	ResetFind();
}

void CFindAndReplaceDlg::OnBnClickedChkWordmatch()
{
	UpdateData(TRUE);
	// 全字匹配与通配符不能同时选中
	if (m_bWordMatch)
	{
		m_bWildcards = false;
	}
	UpdateData(FALSE);
	m_bWordMatchOld = m_bWordMatch;
	ResetFind();
}

void CFindAndReplaceDlg::OnBnClickedChkWildcards()
{
	UpdateData(TRUE);
	// 全字匹配与通配符不能同时选中
	if (m_bWildcards)
	{
		m_bWordMatch = false;
	}
	UpdateData(FALSE);
	m_bWildcardsOld = m_bWildcards;
	ResetFind();
}

void CFindAndReplaceDlg::OnBnClickedBtnFind()
{
	UpdateData(TRUE);
	CString sText;
	// 拾取文字
	if (PickText(sText))
	{
		// 按光标位置替换
		int iStart = LOWORD(m_dwPosFind);
		int iEnd = HIWORD(m_dwPosFind);
		m_sFindText.Delete(iStart, iEnd - iStart);
		m_sFindText.Insert(iStart, sText);

		InsertText(m_sFindText, m_comboFindText);
		UpdateData(FALSE);
	}
	ResetFind();
}

void CFindAndReplaceDlg::OnBnClickedBtnReplace()
{
	UpdateData(TRUE);
	CString sText;
	// 拾取文字
	if (PickText(sText))
	{
		// 按光标位置替换
		int iStart = LOWORD(m_dwPosReplace);
		int iEnd = HIWORD(m_dwPosReplace);
		m_sReplaceText.Delete(iStart, iEnd - iStart);
		m_sReplaceText.Insert(iStart, sText);

		InsertText(m_sReplaceText, m_comboReplaceText);
		UpdateData(FALSE);
	}
}

void CFindAndReplaceDlg::OnBnClickedBtnMarkall()
{
	int iLen = m_lstStyle.GetItemCount();
	// 勾选所有列表中的项目
	for (int i = 0; i < iLen; i++)
	{
		m_lstStyle.SetCheck(i, TRUE);
	}
	ResetFind();
}

void CFindAndReplaceDlg::OnBnClickedBtnUnmarkall()
{
	int iLen = m_lstStyle.GetItemCount();
	// 取消勾选所有列表中的项目
	for (int i = 0; i < iLen; i++)
	{
		m_lstStyle.SetCheck(i, FALSE);
	}
	ResetFind();
}

void CFindAndReplaceDlg::OnBnClickedBtnWildcards()
{
	// 显示通配符定义对话框
	CSymDefDlg dlg;
	dlg.DoModal();
}

void CFindAndReplaceDlg::OnBnClickedChkIncrement()
{
	UpdateData(TRUE);
	if (m_bIncrement)
	{
		m_bWordMatchOld = m_bWordMatch;
		m_bWildcardsOld = m_bWildcards;
	}
	else
	{
		m_bWordMatch = m_bWordMatchOld;
		m_bWildcards = m_bWildcardsOld;
		UpdateData(FALSE);
	}

	EnableCtrls();
}

void CFindAndReplaceDlg::OnBnClickedChkReplace()
{
	EnableCtrls();
}

void CFindAndReplaceDlg::OnBnClickedChkPrefixOrSuffix()
{
	EnableCtrls();
}

void CFindAndReplaceDlg::OnBnClickedChkSearch()
{
	EnableCtrls();
	ResetFind();
}

void CFindAndReplaceDlg::OnLvnItemchangedLstType(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
	BOOL bPrevState = (BOOL)(((pNMLV->uOldState & LVIS_STATEIMAGEMASK) >> 12) - 1);
	BOOL bChecked = (BOOL)(((pNMLV->uNewState & LVIS_STATEIMAGEMASK) >> 12) - 1);

	if (bPrevState != bChecked)
	{
		ResetFind();
	}

	*pResult = 0;
}

HBRUSH CFindAndReplaceDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
	HBRUSH hbr = WGroupDlg::OnCtlColor(pDC, pWnd, nCtlColor);
	// 设置提示编辑框的文字颜色
	if (pWnd->GetDlgCtrlID() == IDC_EDIT_RESULT)
	{
		pDC->SetTextColor(m_crPrompt);
	}
	return hbr;
}

void CFindAndReplaceDlg::OnBnClickedChkSearchxref()
{
	ResetFind();
}

void CFindAndReplaceDlg::OnBnClickedChkSearchblock()
{
	ResetFind();
}

void CFindAndReplaceDlg::OnBnClickedChkNohidden()
{
	ResetFind();
}

void CFindAndReplaceDlg::OnBnClickedChkWidthsensitive()
{
	ResetFind();
}

//隐藏或者显示对话框（查找替换对话框）
void CFindAndReplaceDlg::HideDialog(BOOL bFlag)
{
	if (bFlag) {
//		GetParent()->EnableWindow(TRUE);
		GetParent()->SetFocus();
		GetParent()->SetActiveWindow();
		ShowWindow(SW_HIDE);
//		GetParent()->RedrawWindow();
	}
	else {
//		GetParent()->EnableWindow(FALSE);
//		EnableWindow(TRUE);
		SetActiveWindow();
		ShowWindow(SW_SHOW);
		// Zyu add on 101214，解决提示控件不起作用的问题
//		GetParent()->EnableWindow(TRUE);
	}

// 	if (bFlag) {
// 		GetParent()->EnableWindow(TRUE);
// 		GetParent()->SetFocus();
// 		GetParent()->SetActiveWindow();
// 		ShowWindow(SW_HIDE);
// 		GetParent()->RedrawWindow();
// 	}
// 	else {
// 		GetParent()->EnableWindow(FALSE);
// 		EnableWindow(TRUE);
// 		SetActiveWindow();
// 		ShowWindow(SW_SHOW);
// 		// Zyu add on 101214，解决提示控件不起作用的问题
// 		GetParent()->EnableWindow(TRUE);
// 	}
}

bool CFindAndReplaceDlg::FindText()
{
	// UpdateData(TRUE);

	// Zyu add on 101028，被搜索的字符串
	CString sFindText;
	if (!GetFindText(sFindText))
	{
		return false;
	}

	// 判断查找字符串组合框中的字符串是否变换，若变换
	// 则重新开始从所构造的选择集中查找和替换
	//if (m_sOldFindText != m_sFindText)
	if (m_sOldFindText != sFindText)
	{
		// Zyu modify on 101028，使用统一的搜索还原函数
		//m_bIsFindEnd = FALSE;
		//m_nTextNum = 0;
		ResetFind();
	}

	// 选择此按钮后，重新设置它上面的文本
	CWnd* pWnd = GetDlgItem(IDC_BUTTON_FIND);
	pWnd->SetWindowText(_T("查找下一个"));
	//m_sOldFindText = m_sFindText;
	m_sOldFindText = sFindText;
	acedRedraw(NULL,1);

	// 下面是对字符串的查找，坐标的判断，若所查找的字符串
	// 不可见，则使其能可见，若被对话框挡住，则移动对话框
	// 使字符串能对用户可见
	BOOL bFind = FALSE;
	while (m_nTextNum < m_nTextNumAll)
	{
		int n__len = m_ssText.Length();
		ASSERT(n__len > 0);
		Entity ent = m_ssText[m_nTextNum];
		XScreenDc dc(1,1);
		dc.m_nFlag |= IMG_WCS2UCS;
		XPoint ptMin, ptMax;

		TTextRange range;
		// Zyu modify on 101019,使用新的替换函数
		//m_posFind = FindEntText(ent, m_sFindText, m_posStart, &range);
		m_posFind = m_farUtil.FindEntText(ent, sFindText, m_posStart, &range);
		//if (m_posFind.m_nBufLen>0)
		//{
		//	m_nFindCount++;
		//}
		if (!m_posFind)
		{
			m_nTextNum++;
			m_posStart.m_nTextPos = 0;			
			m_posStart.m_nCookies = 0; // sg add 090115
		}
		else
		{
			bFind = TRUE;
			// Zyu add on 101101，切换到实体所在空间
			TCString sSpaceName;
			TCString sSpaceNameEnt;
			TGGetVar(_T("CTAB"), &sSpaceName);
			if (ent.GetData(410, sSpaceNameEnt) == RTNORM)
			{
				if (sSpaceNameEnt != sSpaceName)
				{
					TGSetVar(_T("CTAB"), sSpaceNameEnt);
				}
			}

			if (range.GetExtend(ptMin, ptMax))
			{
				// Zyu modify on 101101，自动缩放
				// 确保找到的位置范围可见
				//AssureInCurrentView(ptMin, ptMax);
				if (m_bAutoZoom)
				{
					// 方向矢量
					AcGeVector3d vDir;
					vDir = ptMax - ptMin;

					// 比例因子
					double dFactor = (vDir.x > vDir.y) ? vDir.x / vDir.y : vDir.y / vDir.x;
					dFactor = (dFactor > 10) ? 10 : dFactor; 
					
					// 调整zoom的范围
					AcGePoint3d ptMaxTemp = ptMax + vDir * 10 / dFactor;
					AcGePoint3d ptMinTemp = ptMin - vDir * 10 / dFactor;
					
					ArxZoom(ptMinTemp, ptMaxTemp);
				}
				else
				{
					// 确保找到的位置范围可见
					AssureInCurrentView(ptMin, ptMax);
				}

				for (int n=0; n<range.m_lstRanges.Length(); n++)
				{
					dc << (*range.m_lstRanges[n]);
				}
			}
			m_nFindCount++;
		}

		if (bFind == TRUE) // 确保找到的字符不被挡住
		{
			CPoint cptMin, cptMax;
			int cvport;
			VERIFY(xg_getvar(_T("CVPORT"), &cvport)==RTNORM);
			acedCoordFromWorldToPixel(cvport, ptMin, cptMin);
			acedCoordFromWorldToPixel(cvport, ptMax, cptMax);
			CRect dwgViewRect, dlgRect;
			CWnd* pDwgViewWnd = acedGetAcadDwgView();
			pDwgViewWnd->GetWindowRect(dwgViewRect);

			int ptx, pty;
			ptx = dwgViewRect.left;
			pty = dwgViewRect.top;
			cptMin.x += ptx;
			cptMin.y += pty;
			cptMax.x += ptx;
			cptMax.y += pty;
			this->GetWindowRect(dlgRect);
			CRect newRect = dlgRect;
			
			// 若字符串被挡住，则移动对话框
			BOOL bMove = FALSE;
			int width, height;
			width = GetSystemMetrics(SM_CXSCREEN);
			height = GetSystemMetrics(SM_CYSCREEN);
			while (newRect.PtInRect(cptMin)!=0 || newRect.PtInRect(cptMax)!=0)
			{
				bMove = FALSE;
				newRect.OffsetRect(0, 5);
				if (newRect.bottom >= height)
				{
					newRect = dlgRect;
					while (newRect.PtInRect(cptMin)!=0 || newRect.PtInRect(cptMax)!=0)
					{
						bMove = FALSE;
						newRect.OffsetRect(0, -5);
						if (newRect.top <= 0)
						{
							break;
						}
						bMove = TRUE;
					}
					break;
				}
				bMove = TRUE;
			}

			if (bMove == TRUE)
			{
				this->MoveWindow(newRect);
			}
			break;
		}
	}

	// 刷新
	actrTransactionManager->flushGraphics();
	acedUpdateDisplay();

	pWnd = GetDlgItem(IDC_BUTTON_REPLACE);
	if (bFind == TRUE)
	{
		// Zyu modify on 101215，采用新的函数
		//pWnd->EnableWindow(TRUE);
		EnableReplace();
	}
	else
	{
		pWnd->EnableWindow(FALSE);
		// Zyu add on 101215，“全部替换”按钮也变灰
		GetDlgItem(IDC_BUTTON_REPLACEALL)->EnableWindow(FALSE);
		
		// Zyu delete on 101216，此处不重置
		//m_nCount =0;
	}
	return true;
}

// Zyu modify on 100919，统一成读写文件的函数
// Begin
//初始化用作查找的字符串
//void CFindAndReplaceDlg::LoadFindText()
//{
//	TCHAR strTmpPath[100] = _T("");
//	GetTempPath(100, strTmpPath);
//	_tcscat(strTmpPath, _T("findtext.his"));
//
///*	m_lstFindText.RemoveAll();
//	std::ifstream in(strTmpPath);
//	if (!(!in))
//	{
//		TCHAR line[256];
//		in.getline(line, 255);
//		if(!(!in)) 
//		{
//			m_lstFindText.AddTail(strnew(line));
//			while(!(!in))
//			{
//				in.getline(line, 255);
//				if(!in) 
//				{
//					break;
//				}
//				m_lstFindText.AddTail(strnew(line));
//				for(int i = (m_lstFindText.GetCount() - 2); i >= 0; i--)
//				{
//					POSITION site = m_lstFindText.FindIndex(i);
//					if (m_lstFindText.GetAt(site) == m_lstFindText.GetTail())
//					{
//						m_lstFindText.RemoveTail();
//						break;
//					}
//				}
//			}
//		}
//	}
//	CComboBox* pComboFind = (CComboBox*)GetDlgItem(IDC_COMBO_FINDTEXTS);
//	pComboFind->ResetContent();
//	for (int i = 0; i < m_lstFindText.GetCount(); i++) 
//	{
//		POSITION site = m_lstFindText.FindIndex(i);
//		pComboFind->InsertString(i, m_lstFindText.GetAt(site));
//	}
//	pComboFind->GetLBText(0, m_sFindText);*/
//
//	int nNum=0;
//	std::ifstream in(_AS(strTmpPath));
//    while(!(!in)) {
//         char line[256];
//         in.getline(line, 255);
//         if(!in) break;
//		 nNum++;
//		 if(nNum>MAXTEXTNUM) break;
//         m_comboFindText.AddString(TString(line));
//    }
//	if (m_comboFindText.GetCount()>0) {
//		m_comboFindText.GetLBText(0,m_sFindText);
//	}
//}
//
////初始化用作替换的字符串
//void CFindAndReplaceDlg::LoadReplaceText()
//{
//	TCHAR strTmpPath[100] = _T("");
//	GetTempPath(100, strTmpPath);
//	_tcscat(strTmpPath, _T("replacetext.his"));
//
// /* m_lstReplaceText.RemoveAll();
//	std::ifstream in(strTmpPath);
//	if (!(!in))
//	{
//		TCHAR line[256];
//		in.getline(line, 255);
//		if(!(!in)) 
//		{
//			m_lstReplaceText.AddTail(strnew(line));
//			while(!(!in))
//			{
//				TCHAR line[256];
//				in.getline(line, 255);
//				if(!in) 
//				{
//					break;
//				}
//				m_lstReplaceText.AddTail(strnew(line));
//				for(int i = (m_lstReplaceText.GetCount() - 2); i >= 0; i--)
//				{
//					POSITION site = m_lstReplaceText.FindIndex(i);
//					if (m_lstReplaceText.GetAt(site) == m_lstReplaceText.GetTail())
//					{
//						m_lstReplaceText.RemoveTail();
//						break;
//					}
//				}
//			}
//		}
//    }
//	CComboBox* pComboReplace = (CComboBox*)GetDlgItem(IDC_COMBO_REPLACETEXT);
//	pComboReplace->ResetContent();
//	for (int i =0; i < m_lstReplaceText.GetCount(); i++) 
//	{
//		POSITION site = m_lstReplaceText.FindIndex(i);
//		pComboReplace->InsertString(i, m_lstReplaceText.GetAt(site));
//	}
//	pComboReplace->GetLBText(0, m_sReplaceText);*/
//
//	int nNum=0;
//	std::ifstream in(_AS(strTmpPath));
//    while(!(!in)) {
//         char line[256];
//         in.getline(line, 255);
//         if(!in) break;
//		 nNum++;
//		 if(nNum>MAXTEXTNUM) break;
//         m_comboReplaceText.AddString(TString(line));
//    }
//	if (m_comboReplaceText.GetCount()>0) {
//		m_comboReplaceText.GetLBText(0,m_sReplaceText);
//	}
//}
//
//
////保存用作查找的字符串
//void CFindAndReplaceDlg::SaveFindText() 
//{
////	if (m_sFindText.IsEmpty()) return;
//	int len = m_comboFindText.GetCount();
//	if (len <= 0) return;
//	
//	TCHAR strTmpPath[256] = _T("");
//	GetTempPath(255, strTmpPath);	
//	_tcscat(strTmpPath, _T("findtext.his"));
//
///*	std::ofstream out(strTmpPath);
//	out << (const TCHAR*)m_sFindText << _T("\n");
//	int len = m_lstFindText.GetCount();
//	for( int i=0; i < len && i < MAXTEXTNUM; i++) {
//		POSITION site = m_lstFindText.FindIndex(i);
//		if (m_lstFindText.GetAt(site) != m_sFindText &&
//			m_lstFindText.GetAt(site) != _T("")) {
//			out << (const TCHAR*)m_lstFindText.GetAt(site) << _T("\n");
//		}
//	}*/
//
//	std::ofstream out(_AS(strTmpPath));
//	for( int i=0; i < len && i < MAXTEXTNUM-1; i++) {
//		CString sText = _T("");
//		m_comboFindText.GetLBText(i,sText);
//		if (!sText.IsEmpty()) {
//			out << (const char*)(_AS(sText)) << "\n";
//		}
//	}
//}
//
////保存用作替换的字符串
//void CFindAndReplaceDlg::SaveReplaceText() 
//{
////	if (m_sReplaceText.IsEmpty()) return;
//	int len = m_comboReplaceText.GetCount();
//	if (len <= 0) return;
//
//	TCHAR strTmpPath[256] = _T("");
//	GetTempPath(255, strTmpPath);	
//	_tcscat(strTmpPath, _T("replacetext.his"));
//
///*	std::ofstream out(strTmpPath);
//	out << (const TCHAR*)m_sReplaceText << _T("\n");
//	int len = m_lstReplaceText.GetCount();
//	for( int i=0; i < len && i < MAXTEXTNUM; i++) {
//		POSITION site = m_lstReplaceText.FindIndex(i);
//		if (m_lstReplaceText.GetAt(site) != m_sReplaceText &&
//			m_lstReplaceText.GetAt(site) != _T(""))	{
//			out << (const TCHAR*)m_lstReplaceText.GetAt(site) << _T("\n");
//		}
//	}*/
//
//	std::ofstream out(_AS(strTmpPath));
//	for( int i=0; i < len && i < MAXTEXTNUM-1; i++) {
//		CString sText = _T("");
//		m_comboReplaceText.GetLBText(i,sText);
//		if (!sText.IsEmpty()) {
//			out << (const char*)_AS(sText) << "\n";
//		}
//	}
//}

void CFindAndReplaceDlg::LoadText(TCHAR *pFileName, CComboBox &cmbText, CString &sText)
{
	TCHAR strTmpPath[100] = _T("");
	GetTempPath(100, strTmpPath);
	_tcscat(strTmpPath, pFileName);

	int nNum=0;
	std::ifstream in(_AS(strTmpPath));
	while(!(!in))
	{
		char line[256];
		in.getline(line, 255);
		if(!in) break;
		nNum++;
		if(nNum>MAXTEXTNUM) break;
		cmbText.AddString(TString(line));
	}
	if (cmbText.GetCount()>0)
	{
		cmbText.GetLBText(0, sText);
	}
}

void CFindAndReplaceDlg::SaveText(TCHAR *pFileName, CComboBox &cmbText)
{
	int len = cmbText.GetCount();
	if (len <= 0) return;

	TCHAR strTmpPath[256] = _T("");
	GetTempPath(255, strTmpPath);	
	_tcscat(strTmpPath, pFileName);

	std::ofstream out(_AS(strTmpPath));
	for( int i=0; i < len && i < MAXTEXTNUM-1; i++)
	{
		CString sText = _T("");
		cmbText.GetLBText(i,sText);
		if (!sText.IsEmpty())
		{
			out << (const char*)(_AS(sText)) << "\n";
		}
	}
}

// 初始化搜索
void CFindAndReplaceDlg::ResetFind()
{
	UpdateData(TRUE);

	m_bIsFindEnd = FALSE;
	m_nTextNum = 0;
	m_posFind = TTextPosition();
	m_posStart = TTextPosition();
	m_farUtil.ResetFind();
	m_nCount = 0;
	m_nFindCount = 0;

	EnableReplace();

	PickEntities();
	SetDlgItemText(IDC_EDIT_RESULT, _T(""));
	SetDlgItemText(IDC_BUTTON_FIND, _T("查找"));
}

// 从图中选取实体
void CFindAndReplaceDlg::PickEntities()
{
	UpdateData(TRUE);
	m_ssText.Free();

	switch (m_iFindRange)
	{
	// 整个图形
	case 0:
		{
			TRBList TextList(RTDXF0, GetFilterString(), NULL);
			m_ssText.Get(_T("X"), NULL, NULL, TextList);
			m_nTextNumAll = m_ssText.Length();
		}
		break;
	// 当前空间/布局
	case 1:
		{
			TCString sSpaceName;
			TGGetVar(_T("CTAB"), sSpaceName);
			TRBList TextList(RTDXF0, GetFilterString(), 410, sSpaceName, NULL);
			m_ssText.Get(_T("X"), NULL, NULL, TextList);
			m_nTextNumAll = m_ssText.Length();
		}
		break;
	// 当前选择
	case 2:
		{
			m_ssText += m_ssTextAll;
			TRBList TextList(RTDXF0, GetFilterString(), NULL);
			m_ssText.BaseFilter(TextList);
			m_nTextNumAll = m_ssText.Length();
		}
		break;
	default:
		{
		}
	}
}

// 设置查找选项
void CFindAndReplaceDlg::SetFindOption()
{
	UpdateData(TRUE);
	DWORD dwMask = g_FindParser.GetFindOption();
	dwMask = m_bIncrement && (m_iReplaceType == 2) ? (dwMask | FP_INCREMENT) : (dwMask & ~FP_INCREMENT);
	dwMask = m_bCaseSencitive ?	(dwMask | FP_MATCH_CASE) : (dwMask & ~FP_MATCH_CASE);
	dwMask = m_bWordMatch ?		(dwMask | FP_WHOLE_WORD) : (dwMask & ~FP_WHOLE_WORD);
	dwMask = m_bWildcards ?		(dwMask | FP_WILDCARD)	 : (dwMask & ~FP_WILDCARD);
	dwMask = m_bWidthSensitive ?(dwMask | FP_WORD_WIDTH) : (dwMask & ~FP_WORD_WIDTH);
	g_FindParser.SetFindOption(dwMask);
	// 设置对块的搜索方式
	m_farUtil.SetFindOption(m_bBlkAttrib, m_bSearchBlock, m_bSearchXref, m_bNoHidden);
}

// 控制替换按钮是否可用
void CFindAndReplaceDlg::EnableReplace()
{
	UpdateData(TRUE);

	bool bEnable = false;
	switch (m_iReplaceType)
	{
	case 0:
		bEnable = !!m_bReplace;
		break;
	case 1:
		bEnable = m_bPrefix || m_bSuffix;
		break;
	case 2:
		bEnable = !!m_bIncrement;
		break;
	}

	GetDlgItem(IDC_BUTTON_REPLACEALL)->EnableWindow(bEnable);

	bEnable = bEnable && (m_nFindCount != 0) && !m_bIsFindEnd;
	GetDlgItem(IDC_BUTTON_REPLACE)->EnableWindow(bEnable);
}

// 设置控件是否显示
void CFindAndReplaceDlg::SetCtrlsVisible()
{
	UpdateData(TRUE);
	int iCmdShow = (m_iReplaceType == 0) ? SW_SHOW : SW_HIDE;
	GetDlgItem(IDC_CHK_REPLACE)->ShowWindow(iCmdShow);
	GetDlgItem(IDC_COMBO_REPLACETEXT)->ShowWindow(iCmdShow);
	GetDlgItem(IDC_BTN_REPLACE)->ShowWindow(iCmdShow);

	iCmdShow = (m_iReplaceType == 1) ? SW_SHOW : SW_HIDE;
	GetDlgItem(IDC_CHK_PREFIX)->ShowWindow(iCmdShow);
	GetDlgItem(IDC_CMB_PREFIX)->ShowWindow(iCmdShow);
	GetDlgItem(IDC_CHK_SUFFIX)->ShowWindow(iCmdShow);
	GetDlgItem(IDC_CMB_SUFFIX)->ShowWindow(iCmdShow);

	iCmdShow = (m_iReplaceType == 2) ? SW_SHOW : SW_HIDE;
	GetDlgItem(IDC_CHK_INCREMENT)->ShowWindow(iCmdShow);
	GetDlgItem(IDC_CMB_INCREMENT)->ShowWindow(iCmdShow);
}


// 更新控件
void CFindAndReplaceDlg::EnableCtrls()
{
	UpdateData(TRUE);

	GetDlgItem(IDC_COMBO_FINDTEXTS)->EnableWindow(m_bFind);
	GetDlgItem(IDC_BTN_FIND)->EnableWindow(m_bFind);
	GetDlgItem(IDC_COMBO_REPLACETEXT)->EnableWindow(m_bReplace);
	GetDlgItem(IDC_BTN_REPLACE)->EnableWindow(m_bReplace);

	GetDlgItem(IDC_CMB_PREFIX)->EnableWindow(m_bPrefix);
	GetDlgItem(IDC_CMB_SUFFIX)->EnableWindow(m_bSuffix);

	GetDlgItem(IDC_CHK_INCREMENT)->EnableWindow(m_bFind);
	GetDlgItem(IDC_CMB_INCREMENT)->EnableWindow(m_bFind && m_bIncrement);

	GetDlgItem(IDC_CHK_CASESENSITIVE)->EnableWindow(m_bFind);
	GetDlgItem(IDC_CHK_WORDMATCH)->EnableWindow(m_bFind);
	GetDlgItem(IDC_CHK_WILDCARDS)->EnableWindow(m_bFind);
	GetDlgItem(IDC_BTN_WILDCARDS)->EnableWindow(m_bFind);
	GetDlgItem(IDC_CHK_SEARCHXREF)->EnableWindow(m_bFind);
	GetDlgItem(IDC_CHK_SEARCHBLOCK)->EnableWindow(m_bFind);
	GetDlgItem(IDC_CHK_NOHIDDEN)->EnableWindow(m_bFind);
	GetDlgItem(IDC_CHK_WIDTHSENSITIVE)->EnableWindow(m_bFind);

	if (m_bIncrement && GetDlgItem(IDC_CHK_INCREMENT)->IsWindowEnabled() && m_iReplaceType == 2)
	{
		SetDlgItemText(IDC_CHK_SEARCH, _T("起始编号："));
		GetDlgItem(IDC_CHK_WORDMATCH)->EnableWindow(false);
		((CButton*)GetDlgItem(IDC_CHK_WORDMATCH))->SetCheck(BST_CHECKED);
		GetDlgItem(IDC_CHK_WILDCARDS)->EnableWindow(false);
		((CButton*)GetDlgItem(IDC_CHK_WILDCARDS))->SetCheck(BST_UNCHECKED);
		GetDlgItem(IDC_BTN_WILDCARDS)->EnableWindow(false);
	}
	else
	{
		SetDlgItemText(IDC_CHK_SEARCH, _T("查找内容："));
	}

	EnableReplace();
}

bool CFindAndReplaceDlg::PickText(CString &sText)
{
	HideDialog(TRUE);
	Entity ent;
	RBList mask(RTDXF0,_T("TCH_*,TEXT"),NULL);
	XPoint pt;
	if(SelectEntity(_T("\n屏幕拾取文字内容："),ent,pt,mask) != RTNORM)
	{
		HideDialog(FALSE);
		return false;
	}

	PickSet ss(SS_FREE);
	ss+=ent;
	TSubText* pSubText = HitTestOnText(ss,Ucs2Wcs(pt));
	if(pSubText!=NULL)
	{
		sText = pSubText->GetText();
		delete pSubText;
		UpdateData(FALSE);
	}

	HideDialog(FALSE);
	return true;
}

// 获得过滤字符串
CString CFindAndReplaceDlg::GetFilterString()
{
	if (!m_strDefaultFilter.IsEmpty())
		return m_strDefaultFilter;

	UpdateData(TRUE);
	CString sFilter;
	// 查找外部参照
	if (m_bSearchXref)
	{
		sFilter += _T("INSERT,");
	}
	// 查找块
	if (m_bSearchBlock)
	{
		sFilter += _T("INSERT,AEC_BLOCK_INSERT,");
	}

	// 查找xml文件中的设置
	for (int i = 0; i < m_lstStyle.GetItemCount(); i++)
	{
		if (m_lstStyle.GetItemText(i, 0) == _T("块属性值"))
		{
			m_bBlkAttrib = m_lstStyle.GetCheck(i);
		}

		if (m_lstStyle.GetCheck(i))
		{
			sFilter += m_lstStyle.GetItemText(i, 1);
		}
	}
	return sFilter;
}

// 获得搜索字符串
bool CFindAndReplaceDlg::GetFindText(CString &sFind)
{
	UpdateData(TRUE);

	// 如果“查找内容”文本框可用，不允许输入为空
	if (((CButton*)GetDlgItem(IDC_CHK_SEARCH))->GetCheck())
	{
		if (m_sFindText.IsEmpty())
		{
			// 以红色进行提示
			m_crPrompt = RGB(255, 0, 0);
			SetDlgItemText(IDC_EDIT_RESULT, _T("查找内容不能为空!"));
			return false;
		}
		else
		{
			sFind = m_sFindText;
		}
	}
	return true;
}

// 获得替换字符串
bool CFindAndReplaceDlg::GetReplaceText(CString &sReplace)
{
	UpdateData(TRUE);
	switch (m_iReplaceType)
	{
	case 0:
		{
			// 如果“替换为”文本框可用，直接使用用户输入的文字
			if (m_bReplace)
				sReplace = m_sReplaceText;
			else
				return false;
		}
		break;
	case 1:
		{
			// 如果进行增量替换，使用搜索到的文本加前/后缀
			if (m_bPrefix || m_bSuffix)
			{
				// 前后缀为空时不进行操作
				if (m_sSuffixText.IsEmpty()
					&& m_sPrefixText.IsEmpty())
				{
					return false;
				}
				// 程序默认始终在字串的起始端和末尾端添加前后缀
				sReplace = g_FindParser.GetDestString();
				if (m_bPrefix)
				{
					sReplace = m_sPrefixText + sReplace;
				}
				if (m_bSuffix)
				{
					sReplace += m_sSuffixText;
				}
				m_posFind.m_nTextPos = 0;
				m_posFind.m_nBufLen = g_FindParser.GetDestString().GetLength();
			}
			else
				return false;
		}
		break;
	case 2:
		{
			// 如果进行增量替换，使用搜索到的文本加增量
			if (m_bIncrement)
			{
				// 增量输入不是数字，停止操作
				if (!IsNumber(m_sIncrementText))
				{
					m_crPrompt = RGB(255, 0, 0);
					SetDlgItemText(IDC_EDIT_RESULT, _T("请输入数字增量!"));
					return false;
				}
				CString sSymble;
				CString sNumber;
				g_FindParser.DivideString(g_FindParser.GetResult(), sSymble, sNumber);
				CString sSum;
				sSum.Format(_T("%f"), _tstof(sNumber) + _tstof(m_sIncrementText));
				int iMaxAccu = max(GetAccuracy(sNumber), GetAccuracy(m_sIncrementText));
				int iAccu = GetAccuracy(sSum);
				if (iMaxAccu < iAccu)
				{
					sSum = sSum.Mid(0, sSum.GetLength() + iMaxAccu - iAccu);
				}
				sReplace = sSymble + sSum;
			}
			else
				return false;
		}
		break;
	default:
		return false;
	}

	return true;
}

bool CFindAndReplaceDlg::IsNumber(LPCTSTR pszNumber, bool bDot, bool bNeg) const
{
	CString sInput(pszNumber);

	short nLength = sInput.GetLength();

	if (0 >= nLength)
	{
		return false;
	}

	if (sInput.GetAt(0) == _T('.'))
	{
		return false;
	}
	TCHAR chTemp;
	bool bExistDot = false;
	for (short i = 0; i < nLength; i++)
	{
		chTemp = sInput.GetAt(i);
		if (chTemp < _T('0') || chTemp > _T('9'))
		{
			if (bDot && _T('.') == chTemp && !bExistDot)
			{
				bExistDot = true;
			}
			else if (!(bNeg && 0 == i && _T('-') == chTemp))
			{
				return false;
			}
		}
	}
	return true;

}

// 获得一个数字字符串的小数点位数
int CFindAndReplaceDlg::GetAccuracy(const CString& sNumber) const
{
	int iPos = sNumber.ReverseFind(_T('.'));
	if (iPos < 0)
	{
		return 0;
	}
	else
	{
		return sNumber.GetLength() - iPos;
	}
}
// End

BOOL CFindAndReplaceDlg::PreTranslateMessage(MSG* pMsg) 
{
	m_wndToolTip.RelayEvent(pMsg);
	// Zyu add on 101101，保存在查找/替换组合框文本高亮选中的位置
	if (pMsg->message == WM_LBUTTONUP
		|| pMsg->message == WM_KEYUP)
	{
		CWnd* pWnd = this->GetFocus();
		if (NULL != pWnd)
		{
			int iId = pWnd->GetDlgCtrlID();
			if (iId == IDC_COMBO_FINDTEXTS
				|| iId == IDC_COMBO_REPLACETEXT)
			{
				m_dwPosFind = m_comboFindText.GetEditSel();
				m_dwPosReplace = m_comboReplaceText.GetEditSel();
			}
		}
	}
	return WGroupDlg::PreTranslateMessage(pMsg);
}

void CFindAndReplaceDlg::OnDestroy() 
{
	m_wndToolTip.DestroyWindow();
	WGroupDlg::OnDestroy();
	delete this;
	pDlg = NULL;
}

// Zyu modify on 100919，统一成向组合框中插入文本的函数
// Begin
/*
void CFindAndReplaceDlg::InsertFindText()
{
	if (m_sFindText.IsEmpty()) return;
	
	int nPos = m_comboFindText.FindString(-1,m_sFindText);
	int nCount = m_comboFindText.GetCount();
	if (nPos==CB_ERR) {
		if (nCount >= MAXTEXTNUM) {
			m_comboFindText.DeleteString(MAXTEXTNUM-1);
		}
		m_comboFindText.InsertString(0,m_sFindText);
	}
	else {
		if (nPos>=0 && nPos<nCount) {
			m_comboFindText.DeleteString(nPos);
			m_comboFindText.InsertString(0,m_sFindText);
			m_comboFindText.GetLBText(0,m_sFindText);
			UpdateData(FALSE);
		}
	}
}

void CFindAndReplaceDlg::InsertReplaceText()
{
	if (m_sReplaceText.IsEmpty()) return;

	int nPos = m_comboReplaceText.FindString(-1,m_sReplaceText);
	int nCount = m_comboReplaceText.GetCount();
	if (nPos==CB_ERR) {
		if (nCount >= MAXTEXTNUM) {
			m_comboReplaceText.DeleteString(MAXTEXTNUM-1);
		}
		m_comboReplaceText.InsertString(0,m_sReplaceText);
	}
	else {
		if (nPos>=0 && nPos<nCount) {
			m_comboReplaceText.DeleteString(nPos);
			m_comboReplaceText.InsertString(0,m_sReplaceText);
			m_comboReplaceText.GetLBText(0,m_sReplaceText);
			UpdateData(FALSE);
		}
	}
}
*/
void CFindAndReplaceDlg::InsertText(CString &sText, CComboBox &cmbText)
{
	if (sText.IsEmpty()) return;

	int nPos = cmbText.FindStringExact(-1,sText);
	int nCount = cmbText.GetCount();
	if (nPos==CB_ERR)
	{
		if (nCount >= MAXTEXTNUM)
		{
			cmbText.DeleteString(MAXTEXTNUM-1);
		}
		cmbText.InsertString(0, sText);
	}
	else
	{
		if (nPos>=0 && nPos<nCount)
		{
			cmbText.DeleteString(nPos);
			cmbText.InsertString(0,sText);
			cmbText.GetLBText(0,sText);
			UpdateData(FALSE);
		}
	}
}

void CFindAndReplaceDlg::OnCancel() 
{
	UpdateData(TRUE);
	// Zyu modify on 100919，使用统一的读写文件函数
	//SaveFindText();
	//SaveReplaceText();
	SaveText((LPTSTR)_T("findtext.his"), m_comboFindText);
	SaveText((LPTSTR)_T("replacetext.his"), m_comboReplaceText);
	SaveText((LPTSTR)_T("prefixtext.his"), m_cmbPrefix);
	SaveText((LPTSTR)_T("suffixtext.his"), m_cmbSuffix);
	SaveText((LPTSTR)_T("incrementtext.his"), m_cmbIncrement);

	// Zyu add on 100925，保存文字类型的选择状态
	m_xmlReader.SaveToXML();

	CDialog::OnCancel();
	DestroyWindow();
}

void CFindAndReplaceDlg::OnClose()
{
	WGroupDlg::OnClose();
	
	DestroyWindow();
}

//命令函数（查找和替换字符串）
void FindAndReplace()
{
	CTemporaryResourceOverride vTemp;
	CFindAndReplaceDlg dlg;
	if (pDlg == NULL)
	{
		pDlg = new CFindAndReplaceDlg;
		pDlg->Create(CFindAndReplaceDlg::IDD, acedGetAcadFrame());
	}
	pDlg->ShowWindow(SW_SHOW);
// 	dlg.DoModal();
	
//	acedRedraw(NULL,1);
}