boss-data/src/ControlTarget.cpp

// ************************************************************************** //
// ControlTarget.cpp : implementation of the CControlTarget class
// Copyright(c)2012 Naiky Company. All rights reserved.
//
// Abstract:
//   ���ļ�ʵ��CControlTarget�ࡣ
// ********************************************* ---- ¬ΰ 2012-01-07 ***** //
#include "StdAfx.h"
#include "ControlTarget.h"
#include "CycMachiningTarget.h"

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

CS_T s_csBreakPointResume = _DEFCS(_CSV(18028),
	_CHINESE("�ϵ����")
	_ENGLISH("BreakPointResume"));
CS_T s_csGoForward = _DEFCS(_CSV(18029),
	_CHINESE("ǰ��")
	_ENGLISH("GoForward"));
CS_T s_csGoBackward = _DEFCS(_CSV(18030),
	_CHINESE("����")
	_ENGLISH("GoBackward"));
CS_T s_csBACKREFPROMPT = _DEFCS(_CSV(18031),
	_CHINESE("�������лػ�еԭ�����\n�Ƿ�ȷ�ϣ�")
	_ENGLISH("It's going to go back to Reference Point\nConform or Not?"));
CS_T s_csFORBIDORIGINBACK = _DEFCS(_CSV(18032),
	_CHINESE("��ǰ�㲻����ִ���Զ�����")
	_ENGLISH("It's forbid to AutoBack at the current point"));
CS_T s_csFORBIDORIGINFORWARD = _DEFCS(_CSV(18033),
	_CHINESE("��ǰ�㲻����ִ���Զ�����")
	_ENGLISH("It's forbid to AutoForward at the current point"));
CS_T s_csNoObjInFileForAction = _DEFCS(_CSV(18034),
	_CHINESE("|E|�ļ���ͼ�Σ�%s������!")
	_ENGLISH("|E|No figure in the file, unable to %s!"));
CS_T s_csFORBIDRESUME = _DEFCS(_CSV(18035),
	_CHINESE("|E|��ǰ�㲻����ִ�жϵ����")
	_ENGLISH("|E|It's forbid to Resume at the current point"));
CS_T s_csCANNOTSIMUCUT_NOOBJ = _DEFCS(_CSV(18036),
	_CHINESE("�ļ���ͼ�Σ��޷��߱߿�")
	_ENGLISH("No figure in the file,can not SimuCut!"));
CS_T s_csCANNOTSIMUCUT_JUST1DOT = _DEFCS(_CSV(18037),
	_CHINESE("�ļ�ֻ��һ���㣬�޷��߱߿�")
	_ENGLISH("Just 1 Dot in the file,can not SimuCut!"));
CS_T s_csFileChanged = _DEFCS(_CSV(18038),
	_CHINESE("�ļ����޸ģ�����󷽿�ִ�л����ӹ�������\n�Ƿ񱣴棿")
	_ENGLISH("File changed, can not mach untill saved!\nSave or not?"));
CS_T s_cs2YDetectConfigError = _DEFCS(_CSV(18039),
	_CHINESE("|F|˫Yԭ����������������!")
	_ENGLISH("|F|Config for 2YErrorDetecting is wrong, please check!"));
CS_T s_csOperateDangerous = _DEFCS(_CSV(18040),
	_CHINESE("��ǰ��������Σ��: ������̧���и�ͷ��\n�Ƿ����...")
	_ENGLISH("Operation dangerous: It's better to raise cutter first.\nContinue or not..."));
CS_T s_csNHOURSLEFTFORCECLOSE = _DEFCS(_CSV(18041),
	_CHINESE("|F|ע����ڣ�ϵͳ����%dСʱ���Զ��ر�!")
	_ENGLISH("|F|The system is expired.\nNcEditor Will Be Closed In %d Hours Without Registered Again!"));
CS_T s_csNoNearPoint = _DEFCS(_CSV(18042),
	_CHINESE("|E|û���ҵ��ڽ��㣡")
	_ENGLISH("|E|No near point be found!"));
CS_T s_csFORBIDNEARSTART = _DEFCS(_CSV(18043),
	_CHINESE("|E|��ǰ�㲻����ִ���ڽ���ӹ���")
	_ENGLISH("|E|It's forbid to near start at the current point!"));
CS_T s_csEXCEEDWORKTABLE = _DEFCS(_CSV(18526),
	_CHINESE("|E|�ӹ��ļ���������̨��Χ��")
	_ENGLISH("|E|Exceed the worktable travel limit!"));
CS_T s_szNOAVALIBLEOBJECTTOMACH = _DEFCS(_CSV(18619),
	_CHINESE("��ǰ�˶���ִ�У���ȷ���Ƿ���ڼӹ�ͼ�Σ�����ѡ��ӹ�ģʽ��δѡ���κ�ͼ�Ρ�")
	_ENGLISH("Current motion cannot be executed. Please make sure graphic to be machined exists or it has been selected."));
CS_T s_szCONFIG_TUBE_NOK = _DEFCS(_CSV(18619),
	_CHINESE("ϵͳ���ò�֧�ּӹ��ܲ��ļ���")
	_ENGLISH("Tube file is not supported under current System Config."));
CS_T s_szFORSEHOMEBEFORBEGIN = _DEFCS(_CSV(18619),
	_CHINESE("�ӹ�ǰ�������Ȼػ�еԭ�㣡")
	_ENGLISH("Before machining, all axes must go home!"));

static bool _FindObjectByID(IN nce::CCadObject* pCadObj_, IN int nID_, OUT nce::CCadObject** ppResult_);
typedef std::vector<UINT> vectorUINT;
void _GetCadIDList(IN nce::CadObjectList* pListCads_, OUT vectorUINT& setIDs_);
void _GetCamGroupByCadID(IN nce::CCamGroup* pCCamGroup_, IN vectorUINT setIDs_, OUT nce::CCamGroup* pOutCCamGroup_);

const CHAR c_szScanType[] = "ScanType";
//���׷�ʽ
const char c_szPerforateType[] = "PerforateType";
//��������
const char c_szPerBlowType[] = "PerBlowType";
//�����
const char c_szCutBlowType[] = "CutBlowType";
//��ȴ��
const char c_szCoolBlowType[] = "CoolBlowType";
//ͼ�㲻�ӹ�
const char c_szOutput[] = "Output";
//һ������
const char c_szFirstSegBlowType[] = "FirstSegBlowType";
//��������
const char c_szSecondSegBlowType[] = "SecondSegBlowType";
//��������
const char c_szThirdSegBlowType[] = "ThirdSegBlowType";
//һ������flag
const char c_szFirstSegPunch[] = "FirstSegPunch";
//��������flag
const char c_szSecondSegPunch[] = "SecondSegPunch";
//��������flag
const char c_szThirdSegPunch[] = "ThirdSegPunch";

using namespace mach;
using namespace ncmath;
using namespace nce;

CControlTarget* CControlTarget::ms_pControlTarget = NULL;
CControlTarget* GetControlTarget()
{
	return CControlTarget::ms_pControlTarget;
}

///////////////////////////////////////////////////////////////////////////////
// CControlTarget
// 
IMPLEMENT_DYNAMIC(CControlTarget, CNceTarget)
BEGIN_MESSAGE_MAP(CControlTarget, CNceTarget)
	ON_COMMAND(IDCMD_CONTROLTARGET_SHOWCONTROLDLG, OnShowControlDlg)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_SHOWCONTROLDLG, OnUpdateShowControlDlg)

	// ��������ɫ��Ӧ��Ӧд��OnCommand��ǰ��������� ---- ��� 2012-05-25
	ON_COMMAND(IDCMD_CONTROLTARGET_DETECT2YERROR, OnDetect2YError)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_DETECT2YERROR, OnUpdateDetect2YError)
	ON_COMMAND(IDCMD_CONTROLTARGET_CLEARW, OnClearW)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_CLEARW, OnUpdateClearW)
	ON_COMMAND(IDCMD_CONTROLTARGET_CLEARWZ, OnClearWZ)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_CLEARWZ, OnUpdateClearWZ)
	ON_COMMAND(IDCMD_CONTROLTARGET_STOP, OnStop)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_STOP, OnUpdateStop)
	ON_COMMAND(IDCMD_CONTROLTARGET_DIRECTSET, OnDirectSet)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_DIRECTSET, OnUpdateDirectSet)
	ON_COMMAND(IDCMD_CONTROLTARGET_BACKRDLG, OnBackRDlg)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_BACKRDLG, OnUpdateBackRDlg)
	ON_COMMAND(IDCMD_CONTROLTARGET_MACHSELECTED, OnIsMachSelected)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_MACHSELECTED, OnUpdateIsMachSelected)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_STARTSELECTION, OnUpdateStartSelectNotMove)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_ZBACKR, OnUpdateZBackOrg)
	ON_UPDATE_COMMAND_UI(IDCMD_CONTROLTARGET_FOLLOWCONTROL, OnUpdateFollowCtrl)
	ON_TARGET_NOTIFY(TN_NAMEDCOMMAND, OnNamedCommand)
	ON_COMMAND_RANGE(IDCMD_CONTROLTARGET_BACKR, IDCMD_CONTROLTARGET_BACKWARDEND, OnCommand)
	ON_UPDATE_COMMAND_UI_RANGE(IDCMD_CONTROLTARGET_BACKR, IDCMD_CONTROLTARGET_BACKWARDEND, OnUpdateCommandUI)
	ON_TARGET_NOTIFY(TN_TIMER_EVERY40MILLISECOND, OnEvery40Millisecond)
	ON_TARGET_NOTIFY(TN_POST_INITINSTANCE, OnPostInitInstance)
END_MESSAGE_MAP()

CControlTarget::CControlTarget()
: c_nMinGFOBDistance(0.01)
, m_bShowControlDlg(true)
, m_nGFOBDistance(10.0)
, m_nGFOBMode(0x00)
, m_bShowBkrefDlgWhenStart(TRUE)
, m_nGFOBKeyState(0)
, m_bEnableKeyMsg(true)
{
	ASSERT(ms_pControlTarget == NULL);
	ms_pControlTarget = this;

	// ����� ---- ��� 2012-04-13
	typedef CControlTarget ThisClass;
	static const CommandItem _s_CommandItems[] =
	{
		// nID									strName				strCommand			strCEParameter	pGetEParameter
		// MFC�����							��������			C#����				CanExecute����	Execute����
		{ IDCMD_CONTROLTARGET_BACKR,			"BackR",			"BackR",			NULL,			NULL, },
		{ IDCMD_CONTROLTARGET_XBACKR,			"BackR",			"BackR",			NULL,			&ThisClass::_GetParamForXBackR, },
		{ IDCMD_CONTROLTARGET_YBACKR,			"BackR",			"BackR",			NULL,			&ThisClass::_GetParamForYBackR, },
		{ IDCMD_CONTROLTARGET_ZBACKR,			"BackRZ",			"BackRZ",			NULL,			&ThisClass::_GetParamForZBackR, },
		{ IDCMD_CONTROLTARGET_DIRECTSET,		"DirectSet",		"DirectSet",		NULL,			NULL, },
		{ IDCMD_CONTROLTARGET_MOVETOFIXPOS,		"BackFP",			"BackFixPos",		NULL,			NULL, },
		{ IDCMD_CONTROLTARGET_BACKW,			"BackW",			"BackW",			NULL,			NULL, },
		{ IDCMD_CONTROLTARGET_CLEARW,			"ClearW",			"ClearW",			NULL,			NULL, },
		{ IDCMD_CONTROLTARGET_BACKWZ,			"BackWZ",			"BackWZ",			NULL,			NULL, },
		{ IDCMD_CONTROLTARGET_CLEARWZ,			"ClearWZ",			"ClearWZ",			NULL,			NULL, },
		{ IDCMD_CONTROLTARGET_SIMUCUT,			"WalkBoundRect",	"RunGCode",			"G00 X0 Y0",	&ThisClass::_GetParamForCommand_SimuCut, },
		{ IDCMD_CONTROLTARGET_START,			"Start",			"Start",			"0,1",			NULL, },
		{ IDCMD_CONTROLTARGET_PAUSE,			"Pause",			"Pause",			NULL,			NULL, },
		{ IDCMD_CONTROLTARGET_STOP,				"Stop",				"Stop",				NULL,			NULL, },
		{ IDCMD_CONTROLTARGET_STARTSELECTION,	"StartSelection",	"StartSelection",	"0,1",			&ThisClass::_GetParamForCommand_MachSelect, },
		{ IDCMD_CONTROLTARGET_BREAKPOINTRESUME,	"BPResume",			"BPResume",			"0,1",			&ThisClass::_GetParamForCommand_BreakPointResume, },
		{ IDCMD_CONTROLTARGET_STARTNEARPOINT,	"NearStart",		"NearStart",		"0,1",				&ThisClass::_GetParamForCommand_StartNearPoint, },
		{ IDCMD_CONTROLTARGET_SIMULATE,			"Simulate",			"Simulate",			"0,1",			NULL, },
		{ IDCMD_CONTROLTARGET_DIRRUN,			"DirRun",			"DirRun",			"0,1",			NULL, },
		{ IDCMD_CONTROLTARGET_FOLLOWCONTROL,	"FollowCtrl",		"FollowCtrl",		NULL,			NULL, },

		{ IDCMD_CONTROLTARGET_JOGFORWARD,		"JogForward",		"DirRunSelection",	"0,1",			&ThisClass::_GetParamForCommand_GoForward, },
		{ IDCMD_CONTROLTARGET_INCFORWARD,		"IncForward",		"DirRunSelection",	"0,1",			&ThisClass::_GetParamForCommand_IncForward, },
		{ IDCMD_CONTROLTARGET_JOGBACKWARD,		"JogBackward",		"DirRunSelection",	"0,1",			&ThisClass::_GetParamForCommand_GoBackward, },
		{ IDCMD_CONTROLTARGET_INCBACKWARD,		"IncBackward",		"DirRunSelection",	"0,1",			&ThisClass::_GetParamForCommand_IncBackward, },
		{ IDCMD_CONTROLTARGET_FORWARDBEGIN,		"ForwardBegin",		"DirRunSelection",	"0,1",			&ThisClass::_GetParamForCommand_ForwardBegin, },
		{ IDCMD_CONTROLTARGET_BACKWARDBEGIN,	"BackwardBegin",	"DirRunSelection",	"0,1",			&ThisClass::_GetParamForCommand_BackwardBegin, },
		{ IDCMD_CONTROLTARGET_FORWARDEND,		"ForwardEnd",		"DirRunSelection",	"0,1",			&ThisClass::_GetParamForCommand_ForwardEnd, },
		{ IDCMD_CONTROLTARGET_BACKWARDEND,		"BackwardEnd",		"DirRunSelection",	"0,1",			&ThisClass::_GetParamForCommand_BackwardEnd, },

//		{ IDCMD_CONTROLTARGET_STARTEDGEFIND,	"StartAutoEdgeFind",		"StartAutoEdgeFind",		NULL,			NULL },
	};
	m_vectorCommandItems.clear();
	m_vectorCommandItems = CommandItemVector(_s_CommandItems + 0, _s_CommandItems + _countof(_s_CommandItems));

	memset(m_KeyStates, 0, sizeof(KeyState) * _countof(m_KeyStates));

	static WSItem _s_WSItems[] =
	{
		{ "DirRun", "DirRunSelection2", },
		{ "Simulate", "SimulateSelection", },
		{ "Start", "StartSelection", },
	};
	m_vectorWSItems.clear();
	m_vectorWSItems = WSItemsVector(_s_WSItems + 0, _s_WSItems + _countof(_s_WSItems));

	// ���ӳ�ʼ�����õ�֧�� ---- ��� 2015-06-12
	CString _strCT = NceGetPrivateProfileString(_T("ControlTarget"), NULL);
	CString _strSBD = NceGetPrivateProfileString(_T("ControlTarget"), _T("ShowBkrefDlg"));
	if (_strCT == "" || _strSBD == "0" || _strSBD == "false" || _strSBD == "False" || _strSBD == "FALSE")
	{
		m_bShowBkrefDlgWhenStart = FALSE;
	}
	m_bAutoZBkrefWhenStart = FALSE;

	CString _strEnableMotionAccel = NceGetPrivateProfileString(_T("ControlTarget"), _T("EnableMotionAccel"), _T("1"));
	if (_strEnableMotionAccel == _T("0"))
	{
		m_bEnableKeyMsg = false;
	}

	m_pwndControlDlg = NULL;
	m_bIsMinSize = false;

	LOAD_PARAM(this, CControlTarget);
}

CControlTarget::~CControlTarget()
{
	ASSERT(ms_pControlTarget == this);
	ms_pControlTarget = NULL;

	SAVE_PARAM(this, CControlTarget);
}

void CControlTarget::Initialize()
{
	// ���û��CommandManager����Ĭ�ϲ���ʾ���������� ---- ��� 2012-06-22
	ASSERT(m_bShowControlDlg == true);
	if (!mach::GetCommandManager())
	{
		m_bShowControlDlg = true;
	}
}

bool CControlTarget::CanExecuteCommand(LPCSTR pszCommand_, LPCSTR pszParameter_)
{
	ASSERT(pszCommand_ && pszCommand_[0]);

	bool _bCanExecute = false;
	CCommandManager* _pCommandManager = mach::GetCommandManager();
	if (!_pCommandManager
		|| pszParameter_ && pszParameter_[0] && !_pCommandManager->CanExecute(pszCommand_, pszParameter_, "LPCSTR", &_bCanExecute)
		|| (!pszParameter_ || !pszParameter_[0]) && !_pCommandManager->CanExecute(pszCommand_, &_bCanExecute))
	{
		return false;
	}

	return _bCanExecute;
}

bool CControlTarget::ExecuteCommand(LPCSTR pszCommand_, LPCSTR pszParameter_)
{
	ASSERT(pszCommand_ && pszCommand_[0]);

	CCommandManager* _pCommandManager = mach::GetCommandManager();
	if (!_pCommandManager)
	{
		return false;
	}

	if (pszParameter_ && pszParameter_[0] && !_pCommandManager->Execute(pszCommand_, pszParameter_, "LPCSTR")
		|| (!pszParameter_ || !pszParameter_[0]) && !_pCommandManager->Execute(pszCommand_))
	{
		return false;
	}

	return true;
}

void CControlTarget::OnNamedCommand(WPARAM wParam_, LPARAM lParam_)
{
	const CStringA _c_strTargetName = "CControlTarget";
	if (_c_strTargetName != (PCSTR)wParam_)
	{
		return;
	}

	// ������� ---- ��� 2012-04-13
	for (size_t _i = 0; _i < m_vectorCommandItems.size(); _i++)
	{
		const CommandItem& _item = m_vectorCommandItems[_i];
		if (_item.strName != (PCSTR)lParam_)
		{
			ASSERT(_i != m_vectorCommandItems.size() - 1);
			continue;
		}

		// ����֮���Բ���ֱ�ӵ��õ�����������ӳ��һ�飬ּ�ھ�ȷ�����������Ķ�
		// �壺���������Ǹ�ID�͵�������һ��String�͵����֣��������ַ�������ʽ��
		// ��ID�͵����                                ---- ��� 2012-04-14
		OnCmdMsg(_item.nID, 0, NULL, NULL);
		break;
	}
}

void CControlTarget::OnShowControlDlg()
{
	m_bShowControlDlg = !m_bShowControlDlg;
	UpdateAllVisions();
}

void CControlTarget::OnMinControlDlg()
{
	((CMachineControlDlg_Left*)m_pwndControlDlg)->OnMinSize();
}

void CControlTarget::OnMaxControlDlg()
{
	((CMachineControlDlg_Left*)m_pwndControlDlg)->OnMaxSize();
}

void CControlTarget::OnUpdateShowControlDlg(CCmdUI* pCmdUI_)
{
	ASSERT(pCmdUI_);

	// ��ǰ��ʾʱ��Enalbe�˵�ʹ���Բ���ʾ����ǰ����ʾʱ��Ҫ��CommandManagerʱ��
	// Enable�˵����Ա�����ʾ��                          ---- ��� 2012-06-22
	bool _bEnable = m_bShowControlDlg || mach::GetCommandManager() != NULL;
	pCmdUI_->Enable(_bEnable ? TRUE : FALSE);

	bool _bCheck = m_bShowControlDlg;
	pCmdUI_->SetCheck(_bCheck ? 1 : 0);
}

void CControlTarget::OnCommand(UINT nID_)
{
	//����ӹ�ʱ���жϵ�ǰ�ӹ�ͼ��������ѹ�Ƿ����
	if (nID_ == IDCMD_CONTROLTARGET_START)
	{
		_SendGasPressureInfo();
	}
	//���ϰ��LT�汾,��������λʱ,�޷�����ģ�⹦�� ---20170623  ����
	if ((nID_ == IDCMD_CONTROLTARGET_SIMULATE) || (nID_ == IDCMD_CONTROLTARGET_BACKR))
	{
		CString _flag = NceGetPrivateProfileString(_T("ZPLimit"), _T("ZPLimitCheck"), _T("0"));
		CString _Portflag = NceGetPrivateProfileString(_T("ZPLimit"), _T("StopperPort"), _T("0"));
		if ("1" == _flag)
		{
			mach::CPortsManager* _pPortsManager = mach::GetPortsManager();
			BitPort _Port;
			ASSERT(_pPortsManager);
			if (_pPortsManager)
			{
				_pPortsManager->GetBitPort((LPCSTR)_Portflag, &_Port);
				if(_Port.bValue)
				{
					return;
				}
			}
		}
	}
	if ((nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_DIRRUN
		|| nID_ == IDCMD_CONTROLTARGET_SIMULATE))
	{
		CTubeTarget* _pTubeTarget = GetTubeTarget();
		ASSERT(_pTubeTarget);
		// �ܲ��ļ���֧���ڷǹܲ������·���/�ӹ� ---- yangxiaobin 2017-01-09
		if (_pTubeTarget->IsTubeFile() && !_pTubeTarget->IsEnable())
		{
			NceShowMessage(_GETCS(s_szCONFIG_TUBE_NOK));
			return;
		}
	}

	//����ڵ���ʱʱ���ڣ������ʼ�Ϳ����а�ť����ȡ��ѭ������ķ�����ֹͣѭ���ӹ� ----liangyan 2013-9-22
	if (nID_ == IDCMD_CONTROLTARGET_START || nID_ == IDCMD_CONTROLTARGET_DIRRUN)
	{
		int m_nTimeRemain = 0;
		CCycMachiningTarget* _pCycMachiningTarget = GetCycMachiningTarget();
		if (_pCycMachiningTarget->GetCountDownRemain(&m_nTimeRemain) && m_nTimeRemain > 0)
		{
			_pCycMachiningTarget->SetEnable(FALSE);
			return;
		}
	}

	if (nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_DIRRUN
		|| nID_ == IDCMD_CONTROLTARGET_SIMUCUT)
	{
		mach::CParamManager* _pParamManager = mach::GetParamManager();
		ASSERT(_pParamManager);
		mach::ParameterValue _PV;
		memset(&_PV, 0, sizeof(mach::ParameterValue));
		_pParamManager->GetParameterValue("ForceHome", &_PV);
		ASSERT(_PV.nType = mach::ParameterValue::VT_BOOL);
		bool _bForceHome = _PV.bValue;

		memset(&_PV, 0, sizeof(mach::ParameterValue));
		_pParamManager->GetParameterValue("ChannelIsRefered", &_PV);
		ASSERT(_PV.nType = mach::ParameterValue::VT_BOOL);
		if (!_PV.bValue && _bForceHome)
		{
			AfxMessageBox(_GETCS(s_szFORSEHOMEBEFORBEGIN));
			return;
		}
	}

	// ���� ---- ��� 2012-04-13
	size_t _nCmdIndex = m_vectorCommandItems.size();
	for (size_t _i = 0; _i < m_vectorCommandItems.size(); _i++)
	{
		const CommandItem& _item = m_vectorCommandItems[_i];
		if (nID_ != _item.nID)
		{
			continue;
		}

		_nCmdIndex = _i;
		break;
	}
	if (_nCmdIndex < 0 || m_vectorCommandItems.size() <= _nCmdIndex)
	{
		ASSERT(FALSE);
		return;
	}

	// ����Ԥ��Ϣ ---- ��� 2016-09-07
	if (!m_vectorCommandItems[_nCmdIndex].strCommand.IsEmpty())
	{
		CStringA _strCommand = m_vectorCommandItems[_nCmdIndex].strCommand;
		CStringA _strParameter = m_vectorCommandItems[_nCmdIndex].pGetEParameter ? (this->*m_vectorCommandItems[_nCmdIndex].pGetEParameter)() : "";
		if (SendTargetMessage(ID_TARGET_BROADCAST, TM_COMMAND_PREEXECUTE, (WPARAM)(PCSTR)_strCommand, (LPARAM)(PCSTR)_strParameter) != 0L)
		{
			return;
		}
	}

	// Ϊ���ؼƣ��ػ�еԭ��ǰҪ��ʾ ---- ��� 2012-04-14
	if (nID_ == IDCMD_CONTROLTARGET_BACKR
		|| nID_ == IDCMD_CONTROLTARGET_XBACKR
		|| nID_ == IDCMD_CONTROLTARGET_YBACKR
		|| nID_ == IDCMD_CONTROLTARGET_ZBACKR)
	{
		if (AfxMessageBox(_GETCS(s_csBACKREFPROMPT), MB_OKCANCEL) != IDOK)
			return;
	}

	// �����²����߱߿� ---- ��η 2017-01-11
	if (nID_ == IDCMD_CONTROLTARGET_SIMUCUT)
	{
		CTubeTarget* _pTubeTarget = GetTubeTarget();
		if (_pTubeTarget && _pTubeTarget->IsEnable())
		{
			return;
		}
	}
	


	// �ж���������ͼ�Σ�����ͼ��Ϊһ�㣬�����߱߿� ---- ����׿�� 2012-02-23
	if (nID_ == IDCMD_CONTROLTARGET_SIMUCUT)
	{
		CFileTarget* _pFileTarget = GetFileTarget();
		ASSERT(_pFileTarget);
		nce::CCadGroup* _pCurrentCadGroup = _pFileTarget->GetCurrentCadGroup();
		ASSERT(_pCurrentCadGroup);
		CStateManager* _pStateManager = GetStateManager();
		ASSERT(_pStateManager);
		DRECT _rcBound;
		if (_pStateManager->IsSelectedMach())
		{
			CSelectTarget* _pSelectTarget = GetSelectTarget();
			ASSERT(_pSelectTarget);
			const CadObjectList* _plistSelectObjs = _pSelectTarget->GetSelectedCadObjects();
			_rcBound = _plistSelectObjs && _plistSelectObjs->size() > 0 ? _pSelectTarget->GetSelObjsBoundRect() : DRECT(0.0, 0.0, 0.0, 0.0);
		}
		else
		{
			_rcBound = _pCurrentCadGroup->GetBoundRect();
		}

		if (_rcBound.width <= 0.0 && _rcBound.height <= 0.0)
		{
			NceShowMessage(_GETCS(s_szNOAVALIBLEOBJECTTOMACH));
			return;
		}
	}

	// �����ѭ���ӹ�ֹͣ���ٿ�ʼ��ʾ�Ƿ����ѭ���ӹ����������������ѭ���������ӹ��굱ǰ������
	// ���ӹ��ˡ� ---- �ƺ��� 2016-03-16
	if (nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_DIRRUN)
	{
		CCycMachiningTarget* _pCycMachiningTarget = GetCycMachiningTarget();
		if (_pCycMachiningTarget
			&& _pCycMachiningTarget->GetEnable()
			&& _pCycMachiningTarget->GetCycTimes() - 1 > _pCycMachiningTarget->GetCycDones()
			&& (_pCycMachiningTarget->IsInterrupt()
			|| _pCycMachiningTarget->GetCycDones() == 0)
			&& NceGetPrivateProfileString(_T("ControlTarget"), _T("CycStartPrompt")) == _T("1"))
		{
			CContineCyclicalMachDlg* _pwndDlg = GetContineCyclicalMachDlg();
			ASSERT(_pwndDlg);
			if (_pwndDlg->DoModal() == IDCANCEL)
				return;
		}
	}

	// ��ʼ�ӹ�ʱ�Զ��Ե�ǰ��Ϊͣ���� ---- ��� 2014-04-28
	// ������ʼ�ӹ�ʱ���Զ�ִ����������
	// ��ʼ�ӹ����߱߿򡢿ն��ж����� ---- DingQiang 2015-06-09
	static DWORD _s_nLastTime = ::GetTickCount();
	mach::CStateManager::State _nState = mach::CStateManager::Invalid;
	if ((nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_DIRRUN
		|| nID_ == IDCMD_CONTROLTARGET_SIMUCUT)
		&& mach::GetStateManager()->GetState(&_nState)
		&& _nState == mach::CStateManager::Idle
		&& NceGetPrivateProfileString(_T("ControlTarget"), _T("AutoClearW")) == _T("1"))
	{
		// ���ν���ʱ����������300ms�Ļ��Ͳ������ˣ�Ϊ�˽�����ֱ����������ָ����Ի�������⡣
		// ͨ�������ʽ������Ǻܺã���ʱ����������ʵ����PLC�д����ֱ���Ϣ���ٵ�PLC�д�����
		// ---- �ƺ��� 2015-10-10
		CStringA _strCommand = m_vectorCommandItems[_nCmdIndex].strCommand;
		CStringA _strParameter = m_vectorCommandItems[_nCmdIndex].pGetEParameter ? (this->*m_vectorCommandItems[_nCmdIndex].pGetEParameter)() : "";
		DWORD _nCurTime = ::GetTickCount();
		DWORD _nSpaceTime = _nCurTime - _s_nLastTime;
		bool _bSmallInterval = false;
		if (_nSpaceTime < 300 && _s_nLastTime != _nCurTime)
		{
			_bSmallInterval = true;
		}
		_s_nLastTime = _nCurTime;
		if (CanExecuteCommand(_strCommand, _strParameter) && !_bSmallInterval)
			OnCmdMsg(IDCMD_CONTROLTARGET_CLEARW, 0, NULL, NULL);
	}

	// ��ʼ�ӹ������桢�����С�ѡ��ӹ���֮ǰ����ʾ�����ļ� ---- ��� 2012-04-14
	if (nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_SIMULATE
		|| nID_ == IDCMD_CONTROLTARGET_DIRRUN
		|| nID_ == IDCMD_CONTROLTARGET_STARTSELECTION
		|| nID_ == IDCMD_CONTROLTARGET_BREAKPOINTRESUME
		|| nID_ == IDCMD_CONTROLTARGET_JOGFORWARD
		|| nID_ == IDCMD_CONTROLTARGET_INCFORWARD
		|| nID_ == IDCMD_CONTROLTARGET_JOGBACKWARD
		|| nID_ == IDCMD_CONTROLTARGET_INCBACKWARD
		|| nID_ == IDCMD_CONTROLTARGET_FORWARDBEGIN
		|| nID_ == IDCMD_CONTROLTARGET_BACKWARDBEGIN
		|| nID_ == IDCMD_CONTROLTARGET_FORWARDEND
		|| nID_ == IDCMD_CONTROLTARGET_BACKWARDEND
		|| nID_ == IDCMD_CONTROLTARGET_STARTNEARPOINT
		|| nID_ == IDCMD_CONTROLTARGET_SIMUCUT)
	{
		if (!_CheckFileSaved())
			return;
	}

	// û�мӹ��ļ���ʱ�򣬶ϵ������ǰ�������˲����� ---- �ž��� 2012-05-25
	ASSERT(GetFileTarget());
	if (GetFileTarget()->GetCurrentCadGroup()->GetNumOfChild() <= 0)
	{
		#define _PromptEmpty(Id, Action)											\
			if (nID_ == Id)															\
			{																		\
				CString _strPrompt;													\
				_strPrompt.Format(_GETCS(s_csNoObjInFileForAction), Action);		\
				NceShowMessage(_strPrompt);											\
				return;																\
			}
		_PromptEmpty(IDCMD_CONTROLTARGET_BREAKPOINTRESUME, _GETCS(s_csBreakPointResume));
		_PromptEmpty(IDCMD_CONTROLTARGET_JOGFORWARD, _GETCS(s_csGoForward));
		_PromptEmpty(IDCMD_CONTROLTARGET_INCFORWARD, _GETCS(s_csGoForward));
		_PromptEmpty(IDCMD_CONTROLTARGET_FORWARDBEGIN, _GETCS(s_csGoForward));
		_PromptEmpty(IDCMD_CONTROLTARGET_FORWARDEND, _GETCS(s_csGoForward));
		_PromptEmpty(IDCMD_CONTROLTARGET_JOGBACKWARD, _GETCS(s_csGoBackward));
		_PromptEmpty(IDCMD_CONTROLTARGET_INCBACKWARD, _GETCS(s_csGoBackward));
		_PromptEmpty(IDCMD_CONTROLTARGET_BACKWARDBEGIN, _GETCS(s_csGoBackward));
		_PromptEmpty(IDCMD_CONTROLTARGET_BACKWARDEND, _GETCS(s_csGoBackward));
		#undef _PromptEmpty
	}

	// ���ӹ������Ƿ񳬹�����λ�� ---- �ƺ��� 2015-09-29
	ASSERT(m_vectorCommandItems[_nCmdIndex].nID == nID_);
	CStringA _strCommand = m_vectorCommandItems[_nCmdIndex].strCommand;
	CStringA _strParameter = m_vectorCommandItems[_nCmdIndex].pGetEParameter ? (this->*m_vectorCommandItems[_nCmdIndex].pGetEParameter)() : "";

	if (nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_DIRRUN
		|| nID_ == IDCMD_CONTROLTARGET_STARTSELECTION
		|| nID_ == IDCMD_CONTROLTARGET_BREAKPOINTRESUME
		|| nID_ == IDCMD_CONTROLTARGET_STARTNEARPOINT
		|| nID_ == IDCMD_CONTROLTARGET_SIMUCUT)
	{
		if (_IsOutsideTheSotfLimit(_strParameter))
		{
			NceShowMessage(_GETCS(s_csEXCEEDWORKTABLE));
			return;
		}
	}
	//�����з���ʱ��ֻ���д�����ʾ�������ǻ�����ӹ�-----20170714 ����
	if (nID_ == IDCMD_CONTROLTARGET_SIMULATE)
	{
		bool _bSimOutRange = false;
		if (_IsOutsideTheSotfLimit(_strParameter))
		{
			_bSimOutRange = true;
		}
		CString _strSimOutRange("SimOutRange");
		SendTargetMessage(ID_TARGET_PARAMMANAGER, TM_SET_PARAMVALUE, WPARAM(_strSimOutRange.GetBuffer()), (LPARAM)&_bSimOutRange);
	}
	// �߱߿��ܾ�����ε�����֧��ͼ�ι����Լ��ӹ�ѡ�й��ܣ���ӹ�����λ�ж������Ѿ����һ�����ʱ���ע�ͣ����жϺ���������ͳһ��  ----��˼ 2017-06-14
	// �߱߿����ڲ��Ǽӹ�ȫ��ͼ�Σ�Ҳ���Ǽӹ�ѡ��ͼ�Σ���Ҫ�����������λ
	//if(nID_ == IDCMD_CONTROLTARGET_SIMUCUT)
	//{
	//	if (_IsRectOutsideTheSotfLimit(_strParameter))
	//	{
	//		NceShowMessage(_GETCS(s_csEXCEEDWORKTABLE));
	//		return;
	//	}
	//}

	// ��ʼ�ӹ�ǰ֪ͨ����ģ������׼��������е�ǰ��ͼ�ȡ� ----�ƺ��� 2015-05-27
	CString _strAutoAdjust = NceGetPrivateProfileString(_T("ControlTarget"), _T("AutoAdjustView"));
	if ((nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_DIRRUN
		|| nID_ == IDCMD_CONTROLTARGET_SIMUCUT
		|| nID_ == IDCMD_CONTROLTARGET_BREAKPOINTRESUME)
		&& _strAutoAdjust == _T("1"))
	{
		SendTargetMessage(ID_TARGET_VIEWPORTADJUST, TN_TASKSTART);
		SendTargetMessage(ID_TARGET_TUBE, TN_TASKSTART);
	}

	// ���ڹܲ����ã������������ʼ�ӹ�����ͼ���ֲ�ͬ ---- ��η 2016-12-30
	if (nID_ == IDCMD_CONTROLTARGET_SIMULATE && _strAutoAdjust == _T("1"))
	{
		SendTargetMessage(ID_TARGET_VIEWPORTADJUST, TN_TASKSTART);
		SendTargetMessage(ID_TARGET_TUBE, TN_TASKSTART_SIMULATE);
	}

	// �統ǰΪѡ��ӹ����������Ӧѡ��ӹ�ָ� ---- �ƺ��� 2016-09-27
	if (nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_SIMULATE
		|| nID_ == IDCMD_CONTROLTARGET_DIRRUN)
	{
		// ��ͣʱ���ÿ�ʼָ�������ѡ��ӹ��� ---- �ƺ��� 2016-09-06
		CStateManager* _pStateManager = GetStateManager();
		ASSERT(_pStateManager);
		mach::CStateManager::State _nState = CStateManager::Idle;
		if(_pStateManager->GetState(&_nState)
			&& _nState != CStateManager::Pausing
			&& _pStateManager->IsSelectedMach())
		{
			ASSERT(_strParameter.IsEmpty());
			_strParameter = _GetParamForCommand_MachSelect();
			if (_strParameter.IsEmpty())
			{
				NceShowMessage(_GETCS(s_szNOAVALIBLEOBJECTTOMACH));
				return;
			}

			for (int _i = 0; _i < (int)m_vectorWSItems.size(); _i++)
			{
				if (_strCommand != m_vectorWSItems[_i].strWholeMachCommand)
					continue;
				_strCommand = m_vectorWSItems[_i].strSelectMachCommand;
				break;
			}
		}
	}

	if (nID_ == IDCMD_CONTROLTARGET_BREAKPOINTRESUME)
	{
		for (int _i = 0; _i < (int)m_vectorWSItems.size(); _i++)
		{
			// �����һ�ξ���ѡ��ӹ�����ֱ�ӵ�����һ��ָ� ---- �ƺ��� 2016-09-03
			if (m_vectorWSItems[_i].strSelectMachCommand == m_strLastTaskCommand)
			{
				_strCommand = m_strLastTaskCommand;
				break;
			}

			// �����һ���������ӹ������������ѡ��ӹ�ָ��ʵ�֡� ---- �ƺ��� 2016-09-03
			if (m_vectorWSItems[_i].strWholeMachCommand == m_strLastTaskCommand)
			{
				_strCommand = m_vectorWSItems[_i].strSelectMachCommand;
				break;
			}
		}
	}

	// ��ʵ�ӹ��Ϳ����в�֧�ֶϵ������ ---- �ƺ��� 2016-09-03
	if (nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_DIRRUN
		|| nID_ == IDCMD_CONTROLTARGET_STARTSELECTION
		|| nID_ == IDCMD_CONTROLTARGET_STARTNEARPOINT)
	{
		m_strLastTaskCommand = _strCommand;
		m_strLastTaskCommandParam = _strParameter;
	}

	// ����ǰ�ȼ������ʾԤ��ʱ�� ---- ��� 2016-10-11
	if (nID_ == IDCMD_CONTROLTARGET_START
		|| nID_ == IDCMD_CONTROLTARGET_SIMULATE)
	{
		CalculateOneHoleTime();
		CTubeTarget* _pTubeTarget = GetTubeTarget();
		ASSERT(_pTubeTarget);
		if (!_pTubeTarget->IsEnable())
		{
			// �ܲ����ò���ʾ
			AfxGetMainWnd()->SendMessage(WM_COMMAND, IDCMD_RUNREPORTTARGET_SHOWESTIMATION);
		   // Fix TFS work item #2739 to enable shortcut keys
		   AfxGetMainWnd()->SetFocus();
		}
	}

	// ��¼һ�¶ϵ��λ�á�
	if ((nID_ != IDCMD_CONTROLTARGET_BREAKPOINTRESUME && _strCommand == _T("StartSelection")) ||
		(nID_ == IDCMD_CONTROLTARGET_STARTNEARPOINT && _strCommand == _T("NearStart")))

	{
		NceFilePos _nPos = _SelectionFirst(_strParameter);
		CStateManager* _pStateManager = GetStateManager();
		_pStateManager->SetSelectedMachFilePos(_nPos);
	}

	// ���� ---- ��� 2012-04-14
	ExecuteCommand(_strCommand, _strParameter);
}

void CControlTarget::OnUpdateCommandUI(CCmdUI* pCmdUI_)
{
	// ���� ---- ��� 2012-04-13
	size_t _nCmdIndex = m_vectorCommandItems.size();
	for (size_t _i = 0; _i < m_vectorCommandItems.size(); _i++)
	{
		const CommandItem& _item = m_vectorCommandItems[_i];
		if (pCmdUI_->m_nID != _item.nID)
		{
			continue;
		}

		_nCmdIndex = _i;
		break;
	}
	if (_nCmdIndex < 0 || m_vectorCommandItems.size() <= _nCmdIndex)
	{
		// ˭���ֽ�������������� ---- ��� 2012-08-06
		ASSERT(FALSE);
		return;
	}

	// ���� ---- ��� 2012-04-14
	bool _bEnable = false;
	ASSERT(m_vectorCommandItems[_nCmdIndex].nID == pCmdUI_->m_nID);
	CStringA _strCommand = m_vectorCommandItems[_nCmdIndex].strCommand;
	CStringA _strParameter = m_vectorCommandItems[_nCmdIndex].strCEParameter;
	_bEnable = CanExecuteCommand(_strCommand, _strParameter);
	static const struct RunningStateItem
	{
		UINT nID;
		DWORD nMask;
	} _s_cItem[] = 
	{
		{IDCMD_CONTROLTARGET_START,			0x00000001},
		{IDCMD_CONTROLTARGET_SIMULATE,		0x00000002},
		{IDCMD_CONTROLTARGET_DIRRUN,		0x00000004},
		{IDCMD_CONTROLTARGET_SIMUCUT,		0x00000008},
		{IDCMD_CONTROLTARGET_BACKR,			0x00000010},
		{IDCMD_CONTROLTARGET_BACKW,			0x00000020},
		{IDCMD_CONTROLTARGET_MOVETOFIXPOS,	0x00000040},
		{IDCMD_CONTROLTARGET_PAUSE, 0},
	};

	for (int _i = 0; _i < _countof(_s_cItem); _i++)
	{
		if (pCmdUI_->m_nID == _s_cItem[_i].nID)
		{
			CStateManager* _pStateManager = GetStateManager();
			if (!_pStateManager)
			{
				break;
			}

			BOOL _bCheck = FALSE;
			if (pCmdUI_->m_nID == IDCMD_CONTROLTARGET_PAUSE)
			{
				// ��ͣ
				mach::CStateManager::State _nState = CStateManager::Idle;
				if(_pStateManager->GetState(&_nState) && _nState == CStateManager::Pausing)
				{
					_bCheck = TRUE;
				}
			}
			else
			{
				DWORD _nRunningState = 0;
				_pStateManager->GetRunningState(&_nRunningState);
				_bCheck = _nRunningState & _s_cItem[_i].nMask;
			}

			// �������߱߿򲻿��� ---- ��η 2017-01-11
			if (pCmdUI_->m_nID == IDCMD_CONTROLTARGET_SIMUCUT)
			{
				CTubeTarget* _pTubeTarget = GetTubeTarget();
				if (_pTubeTarget && _pTubeTarget->IsEnable())
				{
					_bEnable = FALSE;
				}
			}

			if (_bEnable)
			{
				pCmdUI_->SetCheck(FALSE);
				pCmdUI_->Enable();
				return;
			}

			if (_bCheck)
			{
				pCmdUI_->SetCheck();
			}
			else
			{
				pCmdUI_->SetCheck(FALSE);
				pCmdUI_->Enable(_bEnable);
			}

			return;
		}
	}

	pCmdUI_->Enable(_bEnable ? TRUE : FALSE);
}

// ���ð취��
// [Detect2YError]
// Enable="1"
// Subprogram="BKREF-2YERROR-DETECT"
// ���У�Enable�ڱ�ʾ�Ƿ����� ˫Yƫ���⣬SubprogramΪ˫Yƫ������ӳ���
//                                                        ---- ��� 2012-06-21
void CControlTarget::OnDetect2YError()
{
	CString _strEnable = NceGetPrivateProfileString(_T("Detect2YError"), _T("Enable"), _T("0"));
	_strEnable.Trim();
	if (_strEnable == _T("0"))
	{
		ASSERT(FALSE);
		return;
	}

	// ȡ�ӳ���RunGCode ---- ��� 2012-06-21
	CStringA _strSubprogram = NceGetPrivateProfileString(_T("Detect2YError"), _T("Subprogram"));
	if (_strSubprogram.IsEmpty())
	{
		ASSERT(FALSE);
		return;
	}

	// ��ʾȷ�� ---- ��� 2012-06-21
	if (AfxMessageBox(_GETCS(s_csOperateDangerous), MB_YESNO) != IDYES)
	{
		return;
	}

	// ִ�м�� ---- ��� 2012-06-21
	CStringA _strGCode;
	_strGCode.Format("G65 P\"%s\" L1\n", _strSubprogram);
	ExecuteCommand("RunGCode", _strGCode);
}

// ���ð취��
// [Detect2YError]
// Enable="1"
// Subprogram="BKREF-2YERROR-DETECT"
// ���У�Enable�ڱ�ʾ�Ƿ����� ˫Yƫ���⣬�������������ʾ�˵���Ĭ��Ϊ�����á�
//                                                        ---- ��� 2012-06-21
void CControlTarget::OnUpdateDetect2YError(CCmdUI* pCmdUI_)
{
	ASSERT(pCmdUI_);

	if (pCmdUI_->m_pMenu)
	{
		CString _strEnable = NceGetPrivateProfileString(_T("Detect2YError"), _T("Enable"), _T("0"));
		_strEnable.Trim();
		if (_strEnable == _T("0"))
		{
			pCmdUI_->m_pMenu->DeleteMenu(pCmdUI_->m_nID, MF_BYCOMMAND);
			return;
		}
	}

	// ȡ�ӳ����ж��Ƿ��RunGCode ---- ��� 2012-06-21
	CStringA _strSubprogram = NceGetPrivateProfileString(_T("Detect2YError"), _T("Subprogram"));
	if (_strSubprogram.IsEmpty())
	{
		pCmdUI_->Enable(FALSE);
		return;
	}

	CStringA _strGCode;
	_strGCode.Format("G65 P\"%s\" L1\n", _strSubprogram);
	if (!CanExecuteCommand("RunGCode", _strGCode))
	{
		pCmdUI_->Enable(FALSE);
		return;
	}

	pCmdUI_->Enable(TRUE);
}

void CControlTarget::OnClearW()
{
	// ͨ��Action��ɣ��Ա�ɳ��� ---- ��� 2012-03-30
	SendTargetMessage(ID_TARGET_SETORIGIN, TN_SETORIGIN, 0, 0);
	CClearWorkcoorAction::Do(TRUE); // �ɳ���
}

void CControlTarget::OnUpdateClearW(CCmdUI* pCmdUI_)
{
	bool _bCanExecute = CanExecuteCommand("ClearW", NULL);
	pCmdUI_->Enable(_bCanExecute ? TRUE : FALSE);
}

void CControlTarget::OnClearWZ()
{
	CClearWorkcoorActionZ::Do(TRUE);
}

void CControlTarget::OnUpdateClearWZ(CCmdUI* pCmdUI_)
{
	// �ӹ�ʱҲ�����ֶ�����Z�Ĺ���ԭ�㡣 ---- �ƺ��� 2014-12-23
	CStateManager* _pStateManager = GetStateManager();
	CStateManager::State _nState = CStateManager::Idle;
	bool _bCanExecute = _pStateManager
						&& _pStateManager->GetState(&_nState)
						&& (_nState == CStateManager::Idle
						|| _nState == CStateManager::Estop
						|| _nState == CStateManager::Invalid)
						&& CanExecuteCommand("ClearWZ", NULL);
	pCmdUI_->Enable(_bCanExecute ? TRUE : FALSE);
}

void CControlTarget::OnStop()
{
	ASSERT(!CanExecuteCommand("Stop", NULL) || !CanExecuteCommand("StopSimulate", NULL));

	if (CanExecuteCommand("Stop", NULL))
	{
		ExecuteCommand("Stop", NULL);
	}

	if (CanExecuteCommand("StopSimulate", NULL))
	{
		ExecuteCommand("StopSimulate", NULL);
	}
}

void CControlTarget::OnUpdateStop(CCmdUI* pCmdUI_)
{
	ASSERT(!CanExecuteCommand("Stop", NULL) || !CanExecuteCommand("StopSimulate", NULL));
	bool _bCanExecute = CanExecuteCommand("Stop", NULL) || CanExecuteCommand("StopSimulate", NULL);
	bool _bBoardSupport = NceGetPrivateProfileString(_T("ControlTarget"), _T("BoardSupport")) == _T("1");
	// ���϶˿ڴ�ʱ��ͷ���һ����������״̬�����Ի�ʹstop��stopsimulateͬʱΪtrue��
	// Ϊ�˶��϶˿ڴ򿪵�ʱ���ֹֹͣ��������ʱ��һ���жϽ�����⣬����Ӧ���Ľ������----2017.06.27 ��˼
	if (_bBoardSupport)
	{
		mach::CPortsManager* _pPortsManager = mach::GetPortsManager();
		mach::BitPort _BitPort;
		_pPortsManager->GetBitPort("10038", &_BitPort);
		if (_BitPort.bValue)
		{
			_bCanExecute = false;
		}
	}
	pCmdUI_->Enable(_bCanExecute ? TRUE : FALSE);
}

void CControlTarget::OnBackRDlg()
{
	CBkrefDlg _dlg;
	_dlg.m_bShowBkrefDlgWhenStart = m_bShowBkrefDlgWhenStart;
	_dlg.m_bAutoZBkrefWhenStart = m_bAutoZBkrefWhenStart;
	_dlg.DoModal();
	m_bShowBkrefDlgWhenStart = _dlg.m_bShowBkrefDlgWhenStart;
	m_bAutoZBkrefWhenStart = _dlg.m_bAutoZBkrefWhenStart;
}

void CControlTarget::OnUpdateBackRDlg(CCmdUI* pCmdUI_)
{
}

void CControlTarget::OnUpdateZBackOrg(CCmdUI* pCmdUI_)
{
	bool _bShow = NceGetPrivateProfileString(_T("ControlTarget"), _T("EnableZ"), " ") == "1";
	if (pCmdUI_->m_pMenu && !_bShow)
	{
		pCmdUI_->m_pMenu->DeleteMenu(pCmdUI_->m_nID, MF_BYCOMMAND);
	}
	pCmdUI_->Enable(CanExecuteCommand("BackRZ", "Z"));
}

void CControlTarget::OnUpdateFollowCtrl(CCmdUI* pCmdUI_)
{
	bool _bEnable = CanExecuteCommand("FollowCtrl", NULL);
	pCmdUI_->Enable(_bEnable ? TRUE : FALSE);
	if (pCmdUI_->m_pMenu && !_bEnable)
	{
		pCmdUI_->m_pMenu->DeleteMenu(pCmdUI_->m_nID, MF_BYCOMMAND);
	}
}

void CControlTarget::OnIsMachSelected()
{
	CStateManager* _pStateManager = GetStateManager();
	ASSERT(_pStateManager);
	BOOL _bMachSelected = _pStateManager->IsSelectedMach();
	_bMachSelected = !_bMachSelected;
	_pStateManager->SetSelectedMach(_bMachSelected);
        //���üӹ�ѡ��ͼ���Ƿ�ѡ��flag��CMachineControlDlg��������������ͬ��----20170712  ����
	((CMachineControlDlg*)m_pwndControlDlg)->SetSelectMach(_bMachSelected);
}

void CControlTarget::OnUpdateIsMachSelected(CCmdUI* pCmd_)
{
	CStateManager* _pStateManager = GetStateManager();
	CStateManager::State _nState = CStateManager::Idle;
	bool _bEnable = _pStateManager 
					&& _pStateManager->GetState(&_nState)
					&& _nState == CStateManager::Idle;
	pCmd_->SetCheck(_pStateManager && _pStateManager->IsSelectedMach());
	pCmd_->Enable(_bEnable);
}

void CControlTarget::OnUpdateStartSelectNotMove(CCmdUI* pCmd_)
{
	CStateManager* _pStateManager = GetStateManager();
	CStateManager::State _nState = CStateManager::Idle;
	bool _bEnable = _pStateManager 
		&& _pStateManager->GetState(&_nState)
		&& _nState == CStateManager::Idle
		&& CanExecuteCommand("StartSelection", "0,1");
	pCmd_->Enable(_bEnable);
}

// ��ʱ������Vision ---- ��� 2012-04-17
void CControlTarget::OnEvery40Millisecond(WPARAM wParam_, LPARAM lParam_)
{
	_DoTraceKeyState();

	// Every 160 Millisecond ---- ��� 2012-04-17
	static int _s_nTimerCount = rand();
	_s_nTimerCount = (_s_nTimerCount + 1) % 4;
	if (_s_nTimerCount == 0)
	{
		UpdateVisions();
	}
}

void CControlTarget::OnPostInitInstance(WPARAM wParam_, LPARAM lParam_)
{
	if (m_bShowBkrefDlgWhenStart)
	{
		CWnd* _pMainWnd = AfxGetMainWnd();
		ASSERT(_pMainWnd);
		_pMainWnd->SendMessage(WM_COMMAND, IDCMD_CONTROLTARGET_BACKRDLG, 0L);
	}

	if (m_bAutoZBkrefWhenStart)
	{
		// ֱ�ӵ�������ִ�У��������CMD��Ϣ��ִ�л��ᵯ��һ��ȷ�϶Ի��� ---- DingQiang 2016-09-18
		ExecuteCommand("BackRZ", NULL);
	}

	bool _bCheckWPosition = (NceGetPrivateProfileString(_T("ExchangeWorkbench"), _T("Enable"), _T("0")) == "1");
	if (_bCheckWPosition)
	{
		CWnd* _pMainWnd = AfxGetMainWnd();
		ASSERT(_pMainWnd);
		_pMainWnd->SendMessage(WM_COMMAND, IDCMD_EXCHANGEWORKBENCHTARGET_CHECKWPOSITION, 0L);
	}
}

void CControlTarget::OnDirectSet()
{
	// ����XY����ͨ����еԭ���־�� ---- �ƺ��� 2015-01-04
	if (CanExecuteCommand("DirectSet", NULL))
	{
		ExecuteCommand("DirectSet", NULL);
	}

	// ����Z����ͨ����еԭ���־�� ---- �ƺ��� 2015-01-04
	if (CanExecuteCommand("DirectSetZ", NULL))
	{
		ExecuteCommand("DirectSetZ", NULL);
	}
}

void CControlTarget::OnUpdateDirectSet(CCmdUI* pCmdUI_)
{
	bool _bCanExecute = CanExecuteCommand("DirectSet", NULL) || CanExecuteCommand("DirectSetZ", NULL);
	pCmdUI_->Enable(_bCanExecute);
}

bool CControlTarget::_CheckFileSaved()
{
	CFileTarget* _pFileTarget = GetFileTarget();
	ASSERT(_pFileTarget);
	if (!_pFileTarget->IsModified()) // �ѱ���
	{
		return true;
	}

	bool _bNeedPrompt;
	// ��ȡini�ļ��IJ���---- DingQiang 2012-05-07
	CString _strTranslateType = NceGetPrivateProfileString(_T("ControlTarget"), _T("NeedPromptSave"));
	int _nTranslateType = atoi(_strTranslateType);
	switch (_nTranslateType)
	{
	case 0: _bNeedPrompt = false; break;
	case 1: _bNeedPrompt = true; break;
	default: ASSERT(FALSE); _bNeedPrompt = true;
	}

	if (!_bNeedPrompt)
	{
		AfxGetMainWnd()->SendMessage(WM_COMMAND, IDCMD_FILETARGET_SAVE_WITHOUTDIALOG);
		if (!_pFileTarget->IsModified())
		{
			return true;
		}
		else
			return false;
	}
	else
	{
		if (AfxMessageBox(_GETCS(s_csFileChanged), MB_YESNO) == IDYES) // ��ʾ����
		{
			AfxGetMainWnd()->SendMessage(WM_COMMAND, IDCMD_FILETARGET_SAVE);
			if (!_pFileTarget->IsModified())
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		else // ��ʾ�ˣ���������
		{
			ASSERT(_pFileTarget->IsModified());
			return false;
		}
	}
}

bool CControlTarget::_CheckWorktable()
{
	// ��ǰcam����Ӿ��� ---- DingQiang 2015-09-30
	CFileTarget* _pFileTarget = GetFileTarget();
	ASSERT(_pFileTarget);
	static CSimuCutHelper _s_SimuCutHelper;
	DRECT _rcBound = _s_SimuCutHelper.GetBoundRect(_pFileTarget->GetCurrentCamGroup());

	// ����̨���� ---- DingQiang 2015-09-30
	double _pWorktable[4];
	DRECT _rcWorktable;
	SendTargetMessage(ID_TARGET_WORKTABLE, TM_GET_WORKTABLE,(WPARAM)_pWorktable);
	_rcWorktable.x = _pWorktable[0];
	_rcWorktable.y = _pWorktable[1];
	_rcWorktable.width = _pWorktable[2];
	_rcWorktable.height = _pWorktable[3];

	return _rcWorktable.Contains(_rcBound);
}

// �߱߿�Gָ�� ---- ��� 2012-04-14
CStringA CControlTarget::_GetParamForCommand_SimuCut()
{
	// ��ǰͼ�ε���Ӿ��� ---- ��� 2012-04-14
	CStateManager* _pStateManager = GetStateManager();
	ASSERT(_pStateManager);
	DRECT _rcBound;
	DRECT _rcBoundLast;
	if (_pStateManager->IsSelectedMach())
	{
		CFileTarget* _pFileTarget = GetFileTarget();
		ASSERT(_pFileTarget);
		CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
		CCadGroup* _pCadGroup = _pFileTarget->GetCurrentCadGroup();
		if (NULL == _pCamGroup || NULL == _pCadGroup)
		{
			return "";
		}

		if (_pCamGroup->GetNumOfChild() <= 0 || _pCadGroup->GetNumOfChild() <= 0)
		{
			return "";
		}

		// ѡ�мӹ���ֱ����������ѡ��CAM����� ---- ��η 2017-06-08
		bool _bFirstRect = true;
		CamObjectList* _plistCamObjs = _pCamGroup->GetObjectsList();
		for (CamObjectList::const_iterator _it = _plistCamObjs->begin(); _it != _plistCamObjs->end(); _it++)
		{
			// ����Ҫ�����غϵ�CAM
			CCamObject* _pCam = *_it;
			CCadObject* _pCad = NULL;

			// ����Cam�е�CadID�����ҵ���Ӧ��Cad
			bool _bFound = _FindObjectByID(_pCadGroup, (int)_pCam->GetKey_DBL("CadID"), &_pCad);
			ASSERT(_bFound);

			// TFS#4040 - ѡ�мӹ�ͼ���߱߿��ɾ��ijͼ�Σ������߱߿򽫷���false ---- yangxiaobin
			if (!_bFound)
				continue;
			if (_pCad!=NULL && _pCad->IsSelected())
			{
				static CSimuCutHelper _s_SimuCutHelper;
				_rcBoundLast = _s_SimuCutHelper._GetBoundRect_Object(_pCam);
				if (_bFirstRect)
				{
					_rcBound = _rcBoundLast;
					_bFirstRect = false;
				}
				else
				{
					DRECT::Union(_rcBound, _rcBound, _rcBoundLast);
				}
			}
		}
	}
	else
	{
		CFileTarget* _pFileTarget = GetFileTarget();
		ASSERT(_pFileTarget);
		static CSimuCutHelper _s_SimuCutHelper;
		_rcBound = _s_SimuCutHelper.GetBoundRect(_pFileTarget->GetCurrentCamGroup());
	}

	if (_rcBound.width < 0.0 || _rcBound.height < 0.0)
	{
		return "";
	}

	// ��ʱ���߱߿�
	DPOINT2 _ptCor[] = // Corner
	{
		DPOINT2(_rcBound.GetLeft(), _rcBound.GetBottom()),
		DPOINT2(_rcBound.GetRight(), _rcBound.GetBottom()),
		DPOINT2(_rcBound.GetRight(), _rcBound.GetTop()),
		DPOINT2(_rcBound.GetLeft(), _rcBound.GetTop()),
	};

	// ��������Ѳ�߶�λ����Ӿ��ο������ ---- ����׿�� 2012.11.14
	CWCSAdjustTarget* _pWCSAdjustTarget = GetWCSAdjustTarget();
	if (_pWCSAdjustTarget)
	{
		for (int _i = 0; _i < _countof(_ptCor); _i++)
		{
			_ptCor[_i] = _pWCSAdjustTarget->DoWCSAdjust(_ptCor[_i]);
		}
	}

	// �����ᵱǰλ��������ʼ���� ---- ��� 2012-04-14
	size_t _nBSI = 0; // BestStartIndex
	if (CParamManager* _pParamManager = GetParamManager())
	{
		DPOINT2 _ptCurrentPos;
		ParameterValue _ParameterValueAxis0;
		ParameterValue _ParameterValueAxis1;
		_pParamManager->GetParameterValue("State_Axis0_WorkcoorPos", &_ParameterValueAxis0);
		_pParamManager->GetParameterValue("State_Axis1_WorkcoorPos", &_ParameterValueAxis1);
		if ((_ParameterValueAxis0.nType == ParameterValue::VT_DOUBLE)
			&&(_ParameterValueAxis1.nType == ParameterValue::VT_DOUBLE))
		{
			_ptCurrentPos.x = _ParameterValueAxis0.dValue;
			_ptCurrentPos.y = _ParameterValueAxis1.dValue;

			double _nBestDistance = DBL_MAX;
			for (size_t _i = 0; _i < _countof(_ptCor); _i++)
			{
				double _nDistance = (_ptCor[_i] - _ptCurrentPos).GetLength();
				if (_nDistance < _nBestDistance)
				{
					_nBSI = _i;
					_nBestDistance = _nDistance;
				}
			}
		}
	}

	// �ñ������ڱ���Ҫ�߱߿�ͼ�ε���Ӿ������ɵ�G���� ---- ����׿�� 2012-02-24
	CStringA _strGCode = "";

	// �Ա�RunCodeʱ����֪������ʲô�����
	_strGCode.Append("'Command=SimuCut\n");

	// дʱ�����ʹÿ�����ɵ�Code�Dz�һ����
	SYSTEMTIME _t;
	GetLocalTime(&_t);
	_strGCode.AppendFormat("'Time=%d-%02d-%02d %02d:%02d:%02d\n", _t.wYear, _t.wMonth, _t.wDay, _t.wHour, _t.wMinute, _t.wSecond);

	// ִ���߱߿�ǰһЩ���������涯�򿪹ر��涯�ȡ� ---- �ƺ��� 2015-10-11
	CStringA _strPreSubPro = NceGetPrivateProfileString(_T("ControlTarget"), _T("PreSimuCutActions"));
	if (!_strPreSubPro.IsEmpty())
	{
		CStringA _strPreActions;
		_strPreActions.Format("G65 P\"%s\" L1\n", _strPreSubPro);
		_strGCode.AppendFormat(_strPreActions);
	}

	// �߱߿��ٶ�
	CStringA _strG = "G00";
	CStringA _strF = "";
	CString _strSimuCutSpeed = NceGetPrivateProfileString(_T("ControlTarget"), _T("SimuCutSpeed"));
	if (!_strSimuCutSpeed.IsEmpty())
	{
		_strG = "G905 G00";
		_strF.Format("F=%s", CStringA(_strSimuCutSpeed));
	}

	C_ASSERT(_countof(_ptCor) == 4);
	_strGCode.AppendFormat("%s X%.4f Y%.4f %s\r\n", _strG, _ptCor[(_nBSI + 0) % 4].x, _ptCor[(_nBSI + 0) % 4].y, _strF);
	_strGCode.AppendFormat("%s X%.4f Y%.4f %s\r\n", _strG, _ptCor[(_nBSI + 1) % 4].x, _ptCor[(_nBSI + 1) % 4].y, _strF);
	_strGCode.AppendFormat("%s X%.4f Y%.4f %s\r\n", _strG, _ptCor[(_nBSI + 2) % 4].x, _ptCor[(_nBSI + 2) % 4].y, _strF);
	_strGCode.AppendFormat("%s X%.4f Y%.4f %s\r\n", _strG, _ptCor[(_nBSI + 3) % 4].x, _ptCor[(_nBSI + 3) % 4].y, _strF);
	_strGCode.AppendFormat("%s X%.4f Y%.4f %s\r\n", _strG, _ptCor[(_nBSI + 4) % 4].x, _ptCor[(_nBSI + 4) % 4].y, _strF);
	if(NceGetPrivateProfileString(_T("ControlTarget"), _T("AutoClearW")) == _T("1"))
	{
		// ��ʼǰ�����˵�ǰ��Ϊԭ�㣬�������Ҫ��ԭ�� ---- DingQiang 2015-06-09
		_strGCode.AppendFormat("G65 P\"TOORG\" L1\n");
	}
	return _strGCode;
}

// �ϵ�������� ---- DingQiang 2015-06-30 
CStringA CControlTarget::_GetParamForCommand_BreakPointResume()
{
	//ִ�жϵ����ǰ���ж��µ�ǰ����������ѹ�Ƿ��
	_SendGasPressureInfo();

	// ��ȡ��ǰ���õĶϵ�λ������һ��:
	// 0����û�������ʾ����Ĭ�ϵ��ļ�λ�ã�������ֹͣ�󲻶�ʱ���ļ�λ�á�
	// 1��ʾֹͣ��Ϣ����ʱ��λ�ã���ʱһ������ں�ִ��ֹͣǰ�ع⣬������ļ�λ
	// �õ�Ŀ�ľ���Ϊ���ܽ��Ϲع��λ��              ---- DingQiang 2015-06-30
	CString _strBPPT = NceGetPrivateProfileString(_T("ControlTarget"), _T("BreakPointPosType"));
	int _nBPPT = _strBPPT.IsEmpty() ? 0 : atoi(_strBPPT);

	CStateManager* _pStateManager = GetStateManager();
	ASSERT(_pStateManager);
	ASSERT(_nBPPT == 0 || _nBPPT == 1);
	NceFilePos _StartPos;
	if (_nBPPT == 0)
	{
		_StartPos = CFilePositionHelper::GetCurrentMachFilePosition();
	}
	else
	{
		ParameterValue _ParameterValue;
		memset(&_ParameterValue, 0, sizeof(ParameterValue));
		CParamManager* _pParamManager = GetParamManager();
		ASSERT(_pParamManager);
		_pParamManager->GetParameterValue("PreStopFilePos", &_ParameterValue);
		ASSERT(_ParameterValue.nType == ParameterValue::VT_INT64);
		// 1. Get start position
		_StartPos = _ParameterValue.i64Value;
	}

	CString _strBackDistance = NceGetPrivateProfileString(_T("BreakPointFallback"), _T("BreakPointFallbackDistance"));
	double _nBackDistance = atof(_strBackDistance);
	ASSERT(_nBackDistance >= 0.0);
	CFileTarget* _pFileTarget = GetFileTarget();
	ASSERT(_pFileTarget);
	CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
	ASSERT(_pCamGroup);
	const CCamObject* _pStartCamObject = CFilePositionHelper::FindCamObjectByID(_pCamGroup, _StartPos.nID);

	// �����˺��λ����Ϊ�ϵ��������ʼλ�� ---- �߿�ϼ 2016-10-10
	if (_pStartCamObject && DOUBLE_GREAT(_nBackDistance, 0.0))
	{
		// ��ǰ�ӹ��ļ��������յ㲻���л��� ---- �߿�ϼ 2016-11-02
		NceFilePos _CurrentCamEndPos;
		_CurrentCamEndPos =  CFilePositionHelper::ScanEndPos(_pStartCamObject);
		bool _bStartPos = DOUBLE_EQU(_StartPos.nOffset, 0.0) && DOUBLE_EQU(_StartPos.nRate, 0.0);
		bool _bEndPos = _StartPos == _CurrentCamEndPos;

		if (!_bStartPos && !_bEndPos)
		{
			int _nBackOffset = _StartPos.nOffset;
			double _nBackRate = _StartPos.nRate;
			double _nActualTravelLength = 0.0;
			bool _bSucceed = CFilePositionHelper::TravelBackward(dynamic_cast<const CCamPath*>(_pStartCamObject),
				_StartPos.nOffset, _StartPos.nRate, _nBackDistance, &_nBackOffset, &_nBackRate, &_nActualTravelLength);
			ASSERT(0.0 <= _nActualTravelLength && _nActualTravelLength <= _nBackDistance);

			_StartPos.nOffset = _nBackOffset;
			_StartPos.nRate = _nBackRate;
		}
	}

	if (_StartPos <= EOF)
	{
		_StartPos = 0;
	}

	_pStateManager->SetSelectedMachFilePos(_StartPos);

	if (!_pStateManager->IsSelectedMach())
	{
		NceFilePos _nEndPos;
		_nEndPos = CFilePositionHelper::ScanEndPos(_pCamGroup);
		if (_pStartCamObject && _pStartCamObject->GetType() == campath)
		{
			int _nEndOffset = _StartPos.nOffset;
			double _nEndRate = _StartPos.nRate;
			double _nActualTravelLength = 0.0;
			bool _bSucceed = CFilePositionHelper::TravelForward(dynamic_cast<const CCamPath*>(_pStartCamObject),
				_StartPos.nOffset, _StartPos.nRate, 1.0e-1,
				&_nEndOffset, &_nEndRate, &_nActualTravelLength);
			ASSERT(_bSucceed);
			if (_nActualTravelLength <= 1.0e-2)
			{
				// �ϵ�����·��ʣ�º��٣��޶���·��ĩ��ʼ ---- ��� 2012-04-14
				_StartPos.nOffset = _nEndOffset;
				_StartPos.nRate = _nEndRate;
			}
		}

		if (!_pStartCamObject
			|| _pStartCamObject->GetType() != camhole && _pStartCamObject->GetType() != campath
			|| (__int64)_StartPos == (__int64)_nEndPos)
		{
			NceShowMessage(_GETCS(s_csFORBIDRESUME));
			return "";
		}

		CStringA _strParameter;
		_strParameter.Format("%lld,%lld", (__int64)_StartPos, (__int64)_nEndPos);
		return _strParameter;
	}

	ASSERT(m_strLastTaskCommand == _T("StartSelection")
		|| m_strLastTaskCommand == _T("NearStart")
		|| m_strLastTaskCommand == _T("DirRunSelection2"));

	ASSERT(!m_strLastTaskCommandParam.IsEmpty());
	CStringA _strParameter = _Mid(m_strLastTaskCommandParam, _StartPos);
	if (_strParameter.IsEmpty())
	{
		NceShowMessage(_GETCS(s_csFORBIDRESUME));
	}

	return _strParameter;
}

CStringA CControlTarget::_GetParamForCommand_GoForward()
{
	// 1. Get start position
	NceFilePos _StartPos = CFilePositionHelper::GetCurrentMachFilePosition();
	if (_StartPos <= EOF)
	{
		_StartPos = 0;
	}

	// 2. Get end position
	CFileTarget* _pFileTarget = GetFileTarget();
	ASSERT(_pFileTarget);
	CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
	ASSERT(_pCamGroup);
	NceFilePos _nEndPos = CFilePositionHelper::ScanEndPos(_pCamGroup);

	// 3. Working
	const CCamObject* _pStartCamObject = CFilePositionHelper::FindCamObjectByID(_pCamGroup, _StartPos.nID);
	if (_pStartCamObject && _pStartCamObject->GetType() == campath)
	{
		int _nEndOffset = _StartPos.nOffset;
		double _nEndRate = _StartPos.nRate;
		double _nActualTravelLength = 0.0;
		bool _bSucceed = CFilePositionHelper::TravelForward(dynamic_cast<const CCamPath*>(_pStartCamObject),
			_StartPos.nOffset, _StartPos.nRate, 1.0e-1,
			&_nEndOffset, &_nEndRate, &_nActualTravelLength);
		ASSERT(_bSucceed);
		if (_nActualTravelLength <= 1.0e-2)
		{
			// �ϵ�����·��ʣ�º��٣��޶���·��ĩ��ʼ ---- ��� 2012-04-14
			_StartPos.nOffset = _nEndOffset;
			_StartPos.nRate = _nEndRate;
		}
	}

	if (!_pStartCamObject
		|| _pStartCamObject->GetType() != camhole && _pStartCamObject->GetType() != campath
		|| (__int64)_StartPos == (__int64)_nEndPos)
	{
		NceShowMessage(_GETCS(s_csFORBIDRESUME));
		return "";
	}

	CStringA _strParameter;
	_strParameter.Format("%lld,%lld", (__int64)_StartPos, (__int64)_nEndPos);
	return _strParameter;
}

CStringA CControlTarget::_GetParamForCommand_StartNearPoint()
{
	//ִ���ٽ���ӹ�ǰ���ж��µ�ǰ����������ѹ�Ƿ��
	_SendGasPressureInfo();

	//�ҵ���ǰ��������λ�� ---- DingQiang 2013-06-28
	DPOINT2 _ptCur;
	CParamManager* _pParamManager = GetParamManager();
	ASSERT(_pParamManager);
	ParameterValue _ParameterValue;
	memset(&_ParameterValue, 0, sizeof(ParameterValue));
	_pParamManager->GetParameterValue("State_Axis0_WorkcoorPos", &_ParameterValue);
	ASSERT(_ParameterValue.nType == ParameterValue::VT_DOUBLE);
	_ptCur.x = _ParameterValue.dValue;
	_pParamManager->GetParameterValue("State_Axis1_WorkcoorPos", &_ParameterValue);
	ASSERT(_ParameterValue.nType == ParameterValue::VT_DOUBLE);
	_ptCur.y = _ParameterValue.dValue;

	// ���ڽ���뾶 ---- DingQiang 2013-06-26
	CString _strNearRadius = NceGetPrivateProfileString(_T("ControlTarget"), _T("NearPointRadius"));
	double _nNearRadius = _tstof(_strNearRadius);

	// �ҵ�����Ҫ�󼯺ϵ�Cadͼ�ε�ID���� ---- DingQiang 2013-06-26
	CFileTarget* _pFileTarget = GetFileTarget();
	const CCadGroup* _pCurrentCadGroup = _pFileTarget->GetCurrentCadGroup();
	setUINT _setIDs;
	CStateManager* _pStateManager = GetStateManager();
	ASSERT(_pStateManager);
	if (_pStateManager->IsSelectedMach())
	{
		// ����ǹ�ѡ��<�ӹ�ѡ��ͼ��>�����Ǵ�ѡ��ͼ������ȡ�ڽ�ͼ�� ---- ��� 2016-09-13
		CSelectTarget* _pSelectTarget = GetSelectTarget();
		ASSERT(_pSelectTarget);
		const CadObjectList* _plistSelectedCads = _pSelectTarget->GetSelectedCadObjects();
		ASSERT(_plistSelectedCads);
		CCadGroup _group;
		*(_group.GetObjectsList()) = *_plistSelectedCads;
		GetCadIDByCircle(&_group, _ptCur, _nNearRadius, _setIDs);
		_group.PickOffAll();
	}
	else
	{
	GetCadIDByCircle(_pCurrentCadGroup, _ptCur, _nNearRadius, _setIDs);
	}

	if (_setIDs.size() == 0)
	{
		NceShowMessage(_GETCS(s_csNoNearPoint));
		return "";
	}

	// ��cam�������ҵ���ЩID���ϵ�cam���ݣ������Ŀ��㵽ÿ��cam�ľ��룬������
	// ��cam����                                       ---- DingQiang 2013-06-26
	CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
	CamObjectList _listCam;
	GetCamListByCadID(_pCamGroup, _setIDs, &_listCam);
	if (_listCam.size() == 0)
	{
		NceShowMessage(_GETCS(s_csNoNearPoint));
		return "";
	}

	// ������ĵ���ļ�λ�� ---- DingQiang 2013-06-27
	__int64 _StartPos = 0;
	double _nMinDis = GetCamMinDistance(&_listCam, _ptCur, &_StartPos);
	ASSERT(_nMinDis < DBL_MAX);

	CStringA _strParameter;
	if (_pStateManager->IsSelectedMach())
	{
		// ����ǹ�ѡ��<�ӹ�ѡ��ͼ��>�����Ǵ�ѡ��ͼ�εļӹ���Χ��ѡȡ ---- ��� 2016-09-13
		_strParameter = _Mid(_GetParamForCommand_MachSelect(), _StartPos);
	}
	else
	{
		NceFilePos _nEndPos = CFilePositionHelper::ScanEndPos(_pCamGroup);
		if((__int64)_StartPos != (__int64)_nEndPos)
			_strParameter.Format("%lld,%lld", (__int64)_StartPos, (__int64)_nEndPos);
	}

	// ��ʼ�ͽ��ٵ���ͬһ��λ��ʱ���ӹ� ---- DingQiang 2013-06-28
	if (_strParameter.IsEmpty())
	{
		NceShowMessage(_GETCS(s_csFORBIDNEARSTART));
	}

	return _strParameter;
}

CStringA CControlTarget::_GetParamForCommand_MachSelect()
{
//	MAKE_NCEPOS()
	CFileTarget* _pFileTarget = GetFileTarget();
	ASSERT(_pFileTarget);
	CCadGroup* _pCadGroup = _pFileTarget->GetCurrentCadGroup();
	ASSERT(_pCadGroup);
	setUINT _selectCadId;
	GetCadSelectID(_pCadGroup, _selectCadId);
	if (_selectCadId.size() == 0)
	{
		return "";
	}

	CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
	ASSERT(_pCamGroup);
	listCamInfo _selectCamInfo;
	GetCamSelectID(_pCamGroup, _selectCadId, _selectCamInfo);
	if (_selectCamInfo.size() == 0)
	{
		return "";
	}

	CStringA _str;
	for (listCamInfo::const_iterator _it = _selectCamInfo.begin(); _it != _selectCamInfo.end(); ++_it)
	{
		_str.AppendFormat("%lld,%lld;", _it->nStartPos, _it->nEndPos);
	}

	if (!_str.IsEmpty())
	{
		_str = _str.Left(_str.GetLength() - 1);
	}
	return _str;
}

CStringA CControlTarget::_GetParamForCommand_GoBackward()
{
	// 1. Get start position
	NceFilePos _StartPos = CFilePositionHelper::GetCurrentMachFilePosition();
	if (_StartPos <= EOF)
	{
		_StartPos = 0;
	}

	// 2. Get end position
	CFileTarget* _pFileTarget = GetFileTarget();
	ASSERT(_pFileTarget);
	CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
	ASSERT(_pCamGroup);
	NceFilePos _nEndPos = CFilePositionHelper::ScanStartPos(_pCamGroup);

	// 3. Working
	const CCamObject* _pStartCamObject = CFilePositionHelper::FindCamObjectByID(_pCamGroup, _StartPos.nID);
	if (_pStartCamObject && _pStartCamObject->GetType() == campath)
	{
		int _nEndOffset = _StartPos.nOffset;
		double _nEndRate = _StartPos.nRate;
		double _nActualTravelLength = 0.0;
		bool _bSucceed = CFilePositionHelper::TravelBackward(dynamic_cast<const CCamPath*>(_pStartCamObject),
			_StartPos.nOffset, _StartPos.nRate, 1.0e-1,
			&_nEndOffset, &_nEndRate, &_nActualTravelLength);
		ASSERT(_bSucceed);
		if (_nActualTravelLength <= 1.0e-2)
		{
			// �ϵ�����·��ʣ�º��٣��޶���·��ͷ��ʼ ---- ��� 2012-04-14
			_StartPos.nOffset = _nEndOffset;
			_StartPos.nRate = _nEndRate;
		}
	}

	if (!_pStartCamObject
		|| _pStartCamObject->GetType() != camhole && _pStartCamObject->GetType() != campath
		|| (__int64)_StartPos == (__int64)_nEndPos)
	{
		NceShowMessage(_GETCS(s_csFORBIDRESUME));
		return "";
	}

	CStringA _strParameter;
	_strParameter.Format("%lld,%lld", (__int64)_StartPos, (__int64)_nEndPos);
	return _strParameter;
}

CStringA CControlTarget::_GetParamForCommand_IncForward()
{
	// 1. Get start position
	NceFilePos _StartPos = CFilePositionHelper::GetCurrentMachFilePosition();
	if (_StartPos <= EOF)
	{
		_StartPos = 0;
	}

	// 2. Get end position
	CFileTarget* _pFileTarget = GetFileTarget();
	ASSERT(_pFileTarget);
	CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
	ASSERT(_pCamGroup);
	ASSERT(m_nGFOBDistance > 0.0);
	NceFilePos _nEndPos = _StartPos;
	double _nActualTravelLength = 0.0;
	bool _bSucceed = CFilePositionHelper::TravelForward(_pCamGroup,
		_StartPos, m_nGFOBDistance, &_nEndPos, &_nActualTravelLength);
	ASSERT(0.0 <= _nActualTravelLength && _nActualTravelLength <= m_nGFOBDistance);

	// 3. Working
	const CCamObject* _pStartCamObject = CFilePositionHelper::FindCamObjectByID(_pCamGroup, _StartPos.nID);
	if (_pStartCamObject && _pStartCamObject->GetType() == campath)
	{
		int _nEndOffset = _StartPos.nOffset;
		double _nEndRate = _StartPos.nRate;
		double _nActualTravelLength = 0.0;
		bool _bSucceed = CFilePositionHelper::TravelForward(dynamic_cast<const CCamPath*>(_pStartCamObject),
			_StartPos.nOffset, _StartPos.nRate, 1.0e-1,
			&_nEndOffset, &_nEndRate, &_nActualTravelLength);
		ASSERT(_bSucceed);
		if (_nActualTravelLength <= 1.0e-2)
		{
			// �ϵ�����·��ʣ�º��٣��޶���·��ͷ��ʼ ---- ��� 2012-04-14
			_StartPos.nOffset = _nEndOffset;
			_StartPos.nRate = _nEndRate;
		}
	}

	if (!_pStartCamObject
		|| _pStartCamObject->GetType() != camhole && _pStartCamObject->GetType() != campath
		|| (__int64)_StartPos == (__int64)_nEndPos)
	{
		NceShowMessage(_GETCS(s_csFORBIDRESUME));
		return "";
	}

	CStringA _strParameter;
	_strParameter.Format("%lld,%lld", (__int64)_StartPos, (__int64)_nEndPos);
	return _strParameter;
}

CStringA CControlTarget::_GetParamForCommand_IncBackward()
{
	// 1. Get start position
	NceFilePos _StartPos = CFilePositionHelper::GetCurrentMachFilePosition();
	if (_StartPos <= EOF)
	{
		_StartPos = 0;
	}

	// 2. Get end position
	CFileTarget* _pFileTarget = GetFileTarget();
	ASSERT(_pFileTarget);
	CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
	ASSERT(_pCamGroup);
	ASSERT(m_nGFOBDistance > 0.0);
	NceFilePos _nEndPos = _StartPos;
	double _nActualTravelLength = 0.0;
	bool _bSucceed = CFilePositionHelper::TravelBackward(_pCamGroup,
		_StartPos, m_nGFOBDistance, &_nEndPos, &_nActualTravelLength);
	ASSERT(0.0 <= _nActualTravelLength && _nActualTravelLength <= m_nGFOBDistance);

	// 3. Working
	const CCamObject* _pStartCamObject = CFilePositionHelper::FindCamObjectByID(_pCamGroup, _StartPos.nID);
	if (_pStartCamObject && _pStartCamObject->GetType() == campath)
	{
		int _nEndOffset = _StartPos.nOffset;
		double _nEndRate = _StartPos.nRate;
		double _nActualTravelLength = 0.0;
		bool _bSucceed = CFilePositionHelper::TravelBackward(dynamic_cast<const CCamPath*>(_pStartCamObject),
			_StartPos.nOffset, _StartPos.nRate, 1.0e-1,
			&_nEndOffset, &_nEndRate, &_nActualTravelLength);
		ASSERT(_bSucceed);
		if (_nActualTravelLength <= 1.0e-2)
		{
			// �ϵ�����·��ʣ�º��٣��޶���·��ͷ��ʼ ---- ��� 2012-04-14
			_StartPos.nOffset = _nEndOffset;
			_StartPos.nRate = _nEndRate;
		}
	}

	if (!_pStartCamObject
		|| _pStartCamObject->GetType() != camhole && _pStartCamObject->GetType() != campath
		|| (__int64)_StartPos == (__int64)_nEndPos)
	{
		NceShowMessage(_GETCS(s_csFORBIDRESUME));
		return "";
	}

	CStringA _strParameter;
	_strParameter.Format("%lld,%lld", (__int64)_StartPos, (__int64)_nEndPos);
	return _strParameter;
}

CStringA CControlTarget::_GetParamForCommand_ForwardBegin()
{
	CStringA _strRet;
	if (GetGFOBMode() == 0x00)
	{
		_strRet = _GetParamForCommand_GoForward();
	}

	return _strRet;
}

CStringA CControlTarget::_GetParamForCommand_BackwardBegin()
{
	CStringA _strRet;
	if (GetGFOBMode() == 0x00)
	{
		_strRet = _GetParamForCommand_GoBackward();
	}

	return _strRet;
}

CStringA CControlTarget::_GetParamForCommand_ForwardEnd()
{
	CStringA _strRet;
	if (GetGFOBMode() == 0x00)
	{
		AfxGetMainWnd()->SendMessage(WM_COMMAND, IDCMD_CONTROLTARGET_STOP, 0);
		return _strRet;
	}

	ASSERT(GetGFOBMode() == 0x01);
	_strRet = _GetParamForCommand_IncForward();
	return _strRet;
}

CStringA CControlTarget::_GetParamForCommand_BackwardEnd()
{
	CStringA _strRet;
	if (GetGFOBMode() == 0x00)
	{
		AfxGetMainWnd()->SendMessage(WM_COMMAND, IDCMD_CONTROLTARGET_STOP, 0);
		return _strRet;
	}

	ASSERT(GetGFOBMode() == 0x01);
	_strRet = _GetParamForCommand_IncBackward();
	return _strRet;
}

CStringA CControlTarget::_GetParamForXBackR()
{
	return "X";
}

CStringA CControlTarget::_GetParamForYBackR()
{
	return "Y";
}

CStringA CControlTarget::_GetParamForZBackR()
{
	return "Z";
}

CStringA CControlTarget::_GetParamForCommand_BackWZ()
{
	return "G65 P\"TOZORG\" L1\n";
}

void CControlTarget::_ToTraceKeyState(UINT nChar_, bool bEnable_)
{
	// ���ٸ��٣��������� ---- ��� 2013-09-06
	if (!bEnable_)
	{
		for(int _i = 0; _i < _countof(m_KeyStates); _i++)
		{
			KeyState& _ks = m_KeyStates[_i];
			if (_ks.nChar == nChar_)
			{
				_ks.nChar = 0;
				_ks.nState = 0;
			}
		}
		return;
	}

	// ��ʼ���٣���¼��ֵ ---- ��� 2013-09-06
	BOOL _nInitState = ::GetKeyState(nChar_) < 0 ? 1 : 0;

	for(int _i = 0; _i < _countof(m_KeyStates); _i++)
	{
		KeyState& _ks = m_KeyStates[_i];
		if (_ks.nChar == nChar_)
		{
			_ks.nState = _nInitState;
			return;
		}
	}

	for(int _i = 0; _i < _countof(m_KeyStates); _i++)
	{
		KeyState& _ks = m_KeyStates[_i];
		if (_ks.nChar == 0)
		{
			_ks.nChar = nChar_;
			_ks.nState = _nInitState;
			return;
		}
	}

	// No slot to trace any more ---- ��� 2013-09-06
	ASSERT(FALSE);
}

void CControlTarget::_DoTraceKeyState()
{
	for(int _i = 0; _i < _countof(m_KeyStates); _i++)
	{
		KeyState& _ks = m_KeyStates[_i];
		if (_ks.nChar == 0)
		{
			continue;
		}

		BOOL _nState = ::GetKeyState(_ks.nChar) < 0 ? 1 : 0;
		if (_nState != _ks.nState)
		{
			_ks.nState = _nState;

			// �����ٵ��İ���״̬���ģ��Ϊ������Ϣ ---- ��� 2013-09-06
			MSG _msg = { NULL, _nState == 0 ? WM_KEYUP : WM_KEYDOWN, WPARAM(_ks.nChar), LPARAM(1) };
			OnKeyMessage(&_msg);
		}
	}
}

void CControlTarget::GetCadSelectID(IN const CCadGroup* pCadGroup_, OUT setUINT& setIDs_)
{
	ASSERT(pCadGroup_);
	int _nNumOfChild = pCadGroup_->GetNumOfChild();
	const CCadObject* _pCadObject = NULL;
	typedef std::pair<setUINT::iterator, bool> pairRet;
	for (int _i = 0; _i != _nNumOfChild; ++_i)
	{
		_pCadObject = pCadGroup_->GetAt(_i);
		if (_pCadObject->IsSelected())
		{
			pairRet _Ret = setIDs_.insert(_pCadObject->GetID());
			ASSERT(_Ret.second);
		}
		if (_pCadObject->GetType() == cadgroup)
		{
			GetCadSelectID((CCadGroup*)_pCadObject, setIDs_);
		}

		// ��ѡ��ͼ��Ϊ����ʱҲҪ�ݹ���ID ---- DingQiang 2012-11-30
		if (_pCadObject->GetType() == cadtext)
		{
			CCadText* _pCadText = (CCadText*)_pCadObject;
			GetCadSelectID(_pCadText->GetTextGroup(), setIDs_);
		}
	}
}

void CControlTarget::GetCamSelectID(IN const nce::CCamGroup* pCamGroup_, IN const setUINT& setIDs_, OUT listCamInfo& setCamInfo_)
{
	ASSERT(pCamGroup_);
	ASSERT(setIDs_.size());
	int _nNumOfChild = pCamGroup_->GetNumOfChild();
	for (int _i = 0; _i != _nNumOfChild; ++_i)
	{
		const CCamObject* _pCamObject = pCamGroup_->GetAt(_i);
		cam_t _elet = _pCamObject->GetType();
		if (_elet == camgroup)
		{
			GetCamSelectID((CCamGroup*)_pCamObject, setIDs_, setCamInfo_);
		}
		else
		{
			ASSERT(_elet == camhole || _elet == campath);
			UINT _nID = (UINT)_pCamObject->GetKey_DBL("CadID");
			if (setIDs_.find(_nID) != setIDs_.end())
			{
				// ʹ��CFilePositionHelper�������ļ�λ�õ���ؼ��� ---- ��� 2015-08-30
				CamInfo _caminfo = {
					_pCamObject->GetID(),
					CFilePositionHelper::ScanStartPos(_pCamObject),
					CFilePositionHelper::ScanEndPos(_pCamObject)};
				setCamInfo_.push_back(_caminfo);
			}
		}
	}
}

void CControlTarget::GetCadIDByCircle(IN const nce::CCadGroup* pCCadGroup_, DPOINT2 ptCenter_, double nRadius_, OUT setUINT& setIDs_)
{
	ASSERT(pCCadGroup_);
	int _nNumOfChild = pCCadGroup_->GetNumOfChild();
	const CCadObject* _pCadObject = NULL;
	for (int _it = 0; _it < _nNumOfChild; _it++)
	{
		_pCadObject = pCCadGroup_->GetAt(_it);
		if (_pCadObject->GetType() == cadgroup)
		{
			GetCadIDByCircle((CCadGroup*)_pCadObject, ptCenter_, nRadius_, setIDs_);
			continue;
		}

		if (_pCadObject->GetType() == cadtext)
		{
			GetCadIDByCircle(((CCadText*)_pCadObject)->GetTextGroup(), ptCenter_, nRadius_, setIDs_);
			continue;
		}

		double _nMinDis = GetMinDistance(_pCadObject, ptCenter_);
		if (_nMinDis <= nRadius_)
		{
			setIDs_.insert(_pCadObject->GetID());
		}
	}
}

void CControlTarget::GetCamListByCadID(IN nce::CCamGroup* pCCamGroup_, IN setUINT setIDs_, OUT CamObjectList* plistCamObject)
{
	ASSERT(pCCamGroup_);
	ASSERT(plistCamObject->size() == 0);
	CCamObject* _pCamObject = NULL;
	for (int _it = 0; _it < pCCamGroup_->GetNumOfChild(); _it++)
	{
		_pCamObject = pCCamGroup_->GetAt(_it);
		if (_pCamObject->GetType() == camgroup)
		{
			GetCamListByCadID((CCamGroup*)_pCamObject, setIDs_, plistCamObject);
			continue;
		}

		UINT _CadID = (UINT)_pCamObject->GetKey_DBL("CadID");
		if (setIDs_.find(_CadID) != setIDs_.end())
		{
			plistCamObject->push_back(_pCamObject);
		}
	}
}

// ���ҵ�һ����CadID��Ӧ��Cam���� ---- �ƺ��� 2017-05-21
void CControlTarget::GetFirstCamObjByCadID(IN nce::CCamGroup* pCCamGroup_, IN UINT nCadID_, OUT CCamObject** ppCamObject_)
{
	ASSERT(pCCamGroup_ && ppCamObject_);
	CamObjectList* _plistCamObjs = pCCamGroup_->GetObjectsList();
	for (CamObjectList::iterator _it = _plistCamObjs->begin();
		_it != _plistCamObjs->end(); _it++)
	{
		// �ų�Ԥ���ײ����ĵ㡣 ---- �ƺ��� 2017-05-21
		if ((*_it)->GetKey_DBL("CadID") == nCadID_
			&& (*_it)->GetType() == campath)
		{
			*ppCamObject_ = *_it;
			return;
		}
	}
}

double CControlTarget::GetCamMinDistance(IN const nce::CCamObject* pCamObject_, IN DPOINT2 pt_, OUT __int64* pnPos_ /* = NULL */)
{
	ASSERT(pCamObject_);

	double _nMinDis = DBL_MAX;
	cam_t _type = pCamObject_->GetType();
	switch (_type)
	{
	case camhole:
		{
			CCamHole* _pCamHole = (CCamHole*)pCamObject_;
			_nMinDis = GetCamMinDistance(_pCamHole, pt_, pnPos_);
		}
		break;
	case campath:
		{
			CCamPath* _pCamPath = (CCamPath*)pCamObject_;
			_nMinDis = GetCamMinDistance(_pCamPath, pt_, pnPos_);
		}
		break;
	case camgroup:
		{
			CCamGroup* _pCamGroup = (CCamGroup*)pCamObject_;
			_nMinDis = GetCamMinDistance(_pCamGroup->GetObjectsList(), pt_, pnPos_);
		}
		break;
	default:
		ASSERT(FALSE);
		break;
	}

	return _nMinDis;
}

double CControlTarget::GetCamMinDistance(IN const nce::CCamHole* pCamHole_, IN DPOINT2 pt_, OUT __int64* pnPos_ /*= NULL*/)
{
	ASSERT(pCamHole_);
	DPOINT2 _ptTemp(pCamHole_->GetStart().x, pCamHole_->GetStart().y);

	if (pnPos_)
	{
		NceFilePos _pos;
		_pos.SetID(pCamHole_->GetID());
		_pos.SetOffset(0);
		_pos.SetRate(0);

		*pnPos_ = (__int64)_pos;
	}

	return (pt_ - _ptTemp).GetLength();
}

double CControlTarget::GetCamMinDistance(IN const nce::CCamPath* pCamPath_, IN DPOINT2 pt_, OUT __int64* pnPos_ /*= NULL*/)
{
	ASSERT(pCamPath_ != NULL);
	double _nMinDis = DBL_MAX;
	__int64 _nPos = 0;

	// �����Path��NURBS����·���������NURBS�������ģ�������̾��뼰���Ӧ���ļ�λ�� ---- duquan 2016-07-28
	CCamSplineWrapper _CamSplineWrapper(pCamPath_);
	if (_CamSplineWrapper.IsSpline())
	{
		NceFilePos _pos;
		_pos.SetID(pCamPath_->GetID());
		_pos.SetOffset(0);
		_pos.SetRate(0.);

		_nMinDis = _CamSplineWrapper.GetMinDistFromAimPos(pt_, &_pos);
		_nPos = (__int64)_pos;
		if (pnPos_ != NULL)
			*pnPos_ = _nPos;

		return _nMinDis;
	}

	UINT _nNodeCount = pCamPath_->GetNodeCount();
	for (UINT _it = 0; _it < _nNodeCount; _it++)
	{
		double _nDistance = DBL_MAX;
		double _nRate = 0;

		CCamPath::NODE _nNode = pCamPath_->GetNode(_it);
		CCamPath::NODE_T _typeNode = _nNode.nType;
		if (_typeNode == CCamPath::nt_line_xy
			|| _typeNode == CCamPath::nt_line_x
			|| _typeNode == CCamPath::nt_line_y)
		{
			DPOINT2 _ptStart(_nNode.ptStart.x, _nNode.ptStart.y);
			DPOINT2 _ptEnd(_nNode.ptEnd.x, _nNode.ptEnd.y);
			DPOINT2 _vecTemp = pt_ - _ptStart;
			DPOINT2 _vecLine = _ptEnd - _ptStart;
			double _nTemp = _vecTemp * _vecLine;
			double _nValue = _vecLine * _vecLine;
			ASSERT(_nValue >= 0.0);

			DPOINT2 _point;
			if (_nTemp < 0.0)
			{
				_point = _ptStart;
				_nRate = 0;
			}
			else if (_nTemp > _nValue)
			{
				_point = _ptEnd;
				_nRate = 1;
			}
			else
			{
				LineD2D _line(_ptStart, _ptEnd);
				D2GetProjectionPoint(pt_, _line, &_point);
				_nRate = (_point - _ptStart).GetLength() / (_ptEnd - _ptStart).GetLength();
			}

			_nDistance = (pt_ - _point).GetLength();
		}
		else if (_typeNode == CCamPath::nt_arc_xy)
		{
			DPOINT2 _ptStart(_nNode.ptStart.x, _nNode.ptStart.y);
			DPOINT2 _ptEnd(_nNode.ptEnd.x, _nNode.ptEnd.y);
			DPOINT2 _ptCenter;
			double _nStartAngle;
			double _nRadius;
			double _nSweptAngle;
			SEGMENT::SolveArc(_ptStart, _ptEnd, _nNode.nBulge, &_ptCenter, &_nRadius, &_nStartAngle, &_nSweptAngle);

			DPOINT2 _vector = pt_ - _ptCenter;
			double _nAngle = D2GetNormalAngle(_vector);
			double _nMin = _nSweptAngle > 0 ? _nStartAngle : _nStartAngle + _nSweptAngle;
			double _nMax = _nSweptAngle > 0 ? _nStartAngle + _nSweptAngle : _nStartAngle;
			bool _bInRange = IsInRange(_nAngle, _nMin, _nMax);
			if (_bInRange)
			{
				_nDistance = abs((pt_ - _ptCenter).GetLength() - _nRadius);
				_nRate = (_nAngle - _nStartAngle) / _nSweptAngle;
			}
			else
			{
				double _nDis1 = (pt_ - _ptStart).GetLength();
				double _nDis2 = (pt_ - _ptEnd).GetLength();
				if (_nDis1 < _nDis2)
				{
					_nDistance = _nDis1;
					_nRate = 0;
				}
				else
				{
					_nDistance = _nDis2;
					_nRate = 1;
				}
			}
		}
		else if (_typeNode == CCamPath::nt_circle_xy_cw
				|| _typeNode == CCamPath::nt_circle_xy_ccw)
		{
			DPOINT2 _ptCenter(_nNode.ptCenter.x, _nNode.ptCenter.y);
			DPOINT2 _vector = pt_ - _ptCenter;
			double _nRadius = _nNode.nRadius;
			double _nAngle = D2GetNormalAngle(_vector);
			double _nLength = (pt_ - _ptCenter).GetLength();
			if (_typeNode == CCamPath::nt_circle_xy_cw)
			{
				_nRate = (2 * c_nPIE - _nAngle) / (2 * c_nPIE);
			}
			else
			{
				_nRate = _nAngle / (2 * c_nPIE);
			}

			_nDistance = abs(_nLength - _nRadius);
		}
		else
		{
			ASSERT(FALSE);
			continue;
		}

		if (_nDistance < _nMinDis)
		{
			_nMinDis = _nDistance;
			NceFilePos _pos;
			_pos.SetID(pCamPath_->GetID());

			// ���������յ㣬�����ҵ��ĵ����������Сʱ���޶���ͼ����� ---- DingQiang 2013-07-08
			if (pCamPath_->GetStartPoint() == pCamPath_->GetEndPoint()
				&& _it == _nNodeCount -1
				&& abs(_nRate - 1) < 1.0e-2)
			{
				_pos.SetOffset(0);
				_pos.SetRate(0);
			}
			else
			{
				_pos.SetOffset(_it);
				_pos.SetRate(_nRate);
			}

			_nPos = (__int64)_pos;
		}
	}

	if (pnPos_)
	{
		*pnPos_ = _nPos;
	}

	return _nMinDis;
}

double CControlTarget::GetCamMinDistance(IN const nce::CamObjectList* plistCamObject_, IN DPOINT2 pt_, OUT __int64* pnPos_ /*= NULL*/)
{
	ASSERT(plistCamObject_ && plistCamObject_->size() > 0);
	double _nMinDis = DBL_MAX;
	__int64 _nPos = 0;
	const CCamObject* _pCamObject = NULL;
	for (CamObjectList::const_iterator _it = plistCamObject_->begin(); _it != plistCamObject_->end(); _it++)
	{
		const CCamObject* _pCam = *_it;
		__int64 _nPosTemp =0;
		double _nDistance = GetCamMinDistance(_pCam, pt_, &_nPosTemp);
		if (_nDistance < _nMinDis)
		{
			_nMinDis = _nDistance;
			_nPos = _nPosTemp;
			_pCamObject = _pCam;
		}
	}

	if (pnPos_ && _pCamObject)
	{
		*pnPos_ = _nPos;
	}

	return _nMinDis;
}

bool operator<(const CamInfo& caminfo1_, const CamInfo& caminfo2_)
{
	return caminfo1_.nID < caminfo2_.nID;
};

BOOL CControlTarget::OnKeyMessage(const MSG* pMsg_)
{
	ASSERT(pMsg_);

	CCommandManager* _pCommandManager = GetCommandManager();
	if (!_pCommandManager)
	{
		return FALSE;
	}

	//������㴰���DZ༭���򲻽����ֶ����� ---- ��� 2012-04-13
	HWND _hwndFocus = ::GetFocus();
	if (::IsWindow(_hwndFocus))
	{
		TCHAR _szWndClassName[64];
		memset(_szWndClassName, 0, _countof(_szWndClassName) * sizeof(TCHAR));
		::GetClassName(_hwndFocus, _szWndClassName, _countof(_szWndClassName));
		if (!_tcsicmp(_szWndClassName, _T("Edit")))
		{
			return FALSE;
		}
	}

	BOOL _bSucceed = FALSE;
	static const struct GFOBMsgItem
	{
		UINT nGFOBMessage;		// WM_KEYDOWN or WM_KEYUP
		UINT nGFOBChar;
		UINT nGFOBRepCnt;
		DWORD nGFOBMode;	// 0x00-�㶯, 0x01-ǰ��/����ָ���ľ���
		UINT nGFOBCmdID;
		DWORD nMask;
	} _s_GFOBMsgItems[] = 
	{
		{ WM_KEYDOWN, VK_F3, 1, 0x00, IDCMD_CONTROLTARGET_JOGBACKWARD,	0x00000001},
		{ WM_KEYDOWN, VK_F4, 1, 0x00, IDCMD_CONTROLTARGET_JOGFORWARD,	0x00000002},
		{ WM_KEYUP,   VK_F3, 1, 0x00, IDCMD_CONTROLTARGET_STOP,			0x00000001},
		{ WM_KEYUP,   VK_F4, 1, 0x00, IDCMD_CONTROLTARGET_STOP,			0x00000002},

		{ WM_KEYUP,   VK_F3, 1, 0x01, IDCMD_CONTROLTARGET_INCBACKWARD,	0x00000001},
		{ WM_KEYUP,   VK_F4, 1, 0x01, IDCMD_CONTROLTARGET_INCFORWARD,	0x00000002},
	};
	for (size_t _i = 0; _i < _countof(_s_GFOBMsgItems); _i++)
	{
		const GFOBMsgItem& _item = _s_GFOBMsgItems[_i];
		if (pMsg_->message != _item.nGFOBMessage
			|| static_cast<UINT>(pMsg_->wParam) != _item.nGFOBChar
			|| LOWORD(pMsg_->lParam) != _item.nGFOBRepCnt
			|| GetGFOBMode() != _item.nGFOBMode)
		{
			continue;
		}

		// ����/�رհ���״̬���� ---- ��� 2013-09-04
		_ToTraceKeyState(UINT(pMsg_->wParam), pMsg_->message == WM_KEYDOWN ? true : false);

		_bSucceed = OnCmdMsg(_item.nGFOBCmdID, 0, NULL, NULL);

		if (_item.nGFOBMessage == WM_KEYDOWN)
		{
			m_nGFOBKeyState |= _item.nMask;
		}
		else
		{
			m_nGFOBKeyState &= !_item.nMask;
		}
	}

	return _bSucceed ? TRUE : FALSE;
}

void CControlTarget::SetGFOBMode(DWORD nGFOBMode_)
{
	m_nGFOBMode = nGFOBMode_;
	CParamManager* _pParamManager = GetParamManager();
	if (_pParamManager)
	{
		mach::ParameterValue _Parameter;
		memset(&_Parameter, 0, sizeof(mach::ParameterValue));
		_Parameter.nType = mach::ParameterValue::VT_INT;
		_Parameter.iValue = m_nGFOBMode == 1 ? 1 : 0;
		_pParamManager->SetParameterValue("GoBackMode", &_Parameter);
	}
}

DWORD CControlTarget::GetGFOBMode()
{
	CParamManager* _pParamManager = GetParamManager();
	if (_pParamManager)
	{
		mach::ParameterValue _Parameter;
		memset(&_Parameter, 0, sizeof(mach::ParameterValue));
		if (_pParamManager->GetParameterValue("GoBackMode", &_Parameter))
		{
			ASSERT(_Parameter.nType == mach::ParameterValue::VT_INT);
			m_nGFOBMode = _Parameter.iValue;
		}
	}

	return m_nGFOBMode;
}

bool CControlTarget::_IsOutsideTheSotfLimit(const CStringA strFilePosition_)
{
	CParamManager* _pParamManager = GetParamManager();
	if (!_pParamManager)
	{
		ASSERT(FALSE);
		return false;
	}
	mach::ParameterValue _IsCheckLimitX;
	mach::ParameterValue _IsCheckLimitY;
	bool _bSuccess = _pParamManager->GetParameterValue("IsCheckLimitX", &_IsCheckLimitX);
	_bSuccess &= _pParamManager->GetParameterValue("IsCheckLimitY", &_IsCheckLimitY);
	ASSERT(_IsCheckLimitX.nType == ParameterValue::VT_BOOL && _IsCheckLimitY.nType == ParameterValue::VT_BOOL);
	if (!_IsCheckLimitX.bValue && !_IsCheckLimitY.bValue)
		return false;

	mach::ParameterValue _IsReferedX;
	mach::ParameterValue _IsReferedY;
	_bSuccess &= _pParamManager->GetParameterValue("IsReferedX", &_IsReferedX);
	_bSuccess &= _pParamManager->GetParameterValue("IsReferedY", &_IsReferedY);
	ASSERT(_IsReferedX.nType == ParameterValue::VT_BOOL && _IsReferedY.nType == ParameterValue::VT_BOOL);
	if (!_bSuccess)
	{
		ASSERT(FALSE);
		return false;
	}
	// û�лػ�еԭ�㲻�������λ��
	if (!_IsReferedX.bValue && !_IsReferedY.bValue)
	{
		return false;
	}

	CFileTarget* _pFileTarget = GetFileTarget();
	if (!_pFileTarget)
	{
		ASSERT(FALSE);
		return false;
	}

	// û�õ�ͼ�ξͲ��������ж��ˡ� ---- �ƺ��� 2015-12-12
	CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
	if (_pFileTarget->GetFilePath().IsEmpty()
		|| !_pCamGroup->GetObjectsList()
		|| _pCamGroup->GetObjectsList()->size() == 0)
	{
		return false;
	}

	double _pWorktable[4];
	DRECT _rcWorktable;
	SendTargetMessage(ID_TARGET_WORKTABLE, TM_GET_WORKTABLE,(WPARAM)_pWorktable);
	_rcWorktable.x = _pWorktable[0];
	_rcWorktable.y = _pWorktable[1];
	_rcWorktable.width = _pWorktable[2];
	_rcWorktable.height = _pWorktable[3];
	DRECT _rectBound;
	static CSimuCutHelper _s_SimuCutHelper;
	CStateManager* _pStateManager = GetStateManager();

	// �ӹ�����ͼ�Ρ�
	if (!_pStateManager->IsSelectedMach())
	{
		_rectBound = _s_SimuCutHelper.GetBoundRect(_pFileTarget->GetCurrentCamGroup());
	}

	// ѡ��ӹ���
	else
	{
		DRECT _rectBoundLast;
		CFileTarget* _pFileTarget = GetFileTarget();
		ASSERT(_pFileTarget);
		CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
		CCadGroup* _pCadGroup = _pFileTarget->GetCurrentCadGroup();

		CSelectTarget* _pSelectTarget = GetSelectTarget();
		ASSERT(_pSelectTarget);
		const CadObjectList* _plistSelectObjs = _pSelectTarget->GetSelectedCadObjects();

		vectorUINT _setCadID;
		CCamGroup* _pSelcetCamGroup = new CCamGroup;
		_GetCadIDList((CadObjectList*)_plistSelectObjs,_setCadID);
		if (_setCadID.size() > 0)
		{
			_GetCamGroupByCadID(_pCamGroup, _setCadID, _pSelcetCamGroup);
			_rectBound = _s_SimuCutHelper.GetBoundRect(_pSelcetCamGroup);
		}
		_pSelcetCamGroup->GetObjectsList()->clear();
		delete _pSelcetCamGroup;
	}

	_DoWCSAdjust(_rectBound);
	if (_IsCheckLimitX.bValue && _IsReferedX.bValue
		&& (_rectBound.GetLeft() < _rcWorktable.GetLeft() || _rectBound.GetRight() > _rcWorktable.GetRight()))
		return true;

	if (_IsCheckLimitY.bValue && _IsReferedY.bValue
		&& (_rectBound.GetBottom() < _rcWorktable.GetBottom() || _rectBound.GetTop() > _rcWorktable.GetTop()))
		return true;

	return false;
}

bool CControlTarget::_IsRectOutsideTheSotfLimit(const CStringA strFilePosition_)
{
	CParamManager* _pParamManager = GetParamManager();
	if (!_pParamManager)
	{
		ASSERT(FALSE);
		return false;
	}
	mach::ParameterValue _IsCheckLimitX;
	mach::ParameterValue _IsCheckLimitY;
	bool _bSuccess = _pParamManager->GetParameterValue("IsCheckLimitX", &_IsCheckLimitX);
	_bSuccess &= _pParamManager->GetParameterValue("IsCheckLimitY", &_IsCheckLimitY);
	ASSERT(_IsCheckLimitX.nType == ParameterValue::VT_BOOL && _IsCheckLimitY.nType == ParameterValue::VT_BOOL);
	if (!_IsCheckLimitX.bValue && !_IsCheckLimitY.bValue)
		return false;

	mach::ParameterValue _IsReferedX;
	mach::ParameterValue _IsReferedY;
	_bSuccess &= _pParamManager->GetParameterValue("IsReferedX", &_IsReferedX);
	_bSuccess &= _pParamManager->GetParameterValue("IsReferedY", &_IsReferedY);
	ASSERT(_IsReferedX.nType == ParameterValue::VT_BOOL && _IsReferedY.nType == ParameterValue::VT_BOOL);
	if (!_bSuccess)
	{
		ASSERT(FALSE);
		return false;
	}
	// û�лػ�еԭ�㲻�������λ��
	if (!_IsReferedX.bValue && !_IsReferedY.bValue)
	{
		return false;
	}

	CFileTarget* _pFileTarget = GetFileTarget();
	if (!_pFileTarget)
	{
		ASSERT(FALSE);
		return false;
	}

	// û�õ�ͼ�ξͲ��������ж��ˡ� ---- �ƺ��� 2015-12-12
	CCamGroup* _pCamGroup = _pFileTarget->GetCurrentCamGroup();
	if (_pFileTarget->GetFilePath().IsEmpty()
		|| !_pCamGroup->GetObjectsList()
		|| _pCamGroup->GetObjectsList()->size() == 0)
	{
		return false;
	}

	double _pWorktable[4];
	DRECT _rcWorktable;
	SendTargetMessage(ID_TARGET_WORKTABLE, TM_GET_WORKTABLE,(WPARAM)_pWorktable);
	_rcWorktable.x = _pWorktable[0];
	_rcWorktable.y = _pWorktable[1];
	_rcWorktable.width = _pWorktable[2];
	_rcWorktable.height = _pWorktable[3];
	DRECT _rectBound;
	
	// �߿��Ƿ񳬹���λ
	static CSimuCutHelper _s_SimuCutHelper;
	ASSERT(!strFilePosition_.IsEmpty());
	_rectBound = _s_SimuCutHelper.GetBoundRect(_pFileTarget->GetCurrentCamGroup());
	_DoWCSAdjust(_rectBound);
	if (_IsCheckLimitX.bValue && _IsReferedX.bValue
		&& (_rectBound.GetLeft() < _rcWorktable.GetLeft() || _rectBound.GetRight() > _rcWorktable.GetRight()))
		return true;

	if (_IsCheckLimitY.bValue && _IsReferedY.bValue
		&& (_rectBound.GetBottom() < _rcWorktable.GetBottom() || _rectBound.GetTop() > _rcWorktable.GetTop()))
		return true;

	return false;
}

// ��ָ���ӹ���Χ�ڴ��ض�λ�ÿ�ʼ�ĺ󲿣����ڴ˷�Χ�ڷ��ؿ��ַ����� ---- �ƺ��� 2016-09-14
CStringA CControlTarget::_Mid(const CStringA& strSelection_, __int64 nStartPos_)
{
	if (strSelection_.IsEmpty())
	{
		ASSERT(FALSE);
		return "";
	}

	int _nIndex = strSelection_.Find(_T(';'));
	CString _strSection = _nIndex == -1 ? strSelection_ : strSelection_.Mid(0, _nIndex);
	__int64 _nLastEndPos = -1;
	CString _strRet;
	while(!_strSection.IsEmpty())
	{
		__int64 _nStart = 0;
		__int64 _nEnd = 0;
		int _nCount = sscanf_s(_strSection, _T("%lld,%lld"), &_nStart, &_nEnd);
		ASSERT(_nCount == 2);

		// Ĭ�ϴ������ļ������ǵ����ģ�"a,b;c,d"��a < b < c < d�� ---- �ƺ��� 2016-09-14
		ASSERT(_nLastEndPos <= _nStart && _nStart <= _nEnd);

		// ��ǰλ�ò��ڴ������������ڡ� ---- �ƺ��� 2016-09-14
		if (nStartPos_ < _nStart
			&& _nLastEndPos == -1)
		{
			return "";
		}

		// ��ǰλ���������������Ŀ�϶�ڣ�����"a,b;c,d", ��ǰλ�� > b && ��ǰλ�� < c�� ---- �ƺ��� 2016-09-14
		if (nStartPos_ < _nStart
			&& _nLastEndPos > 0
			&& nStartPos_ > _nLastEndPos)
		{
			_strRet.Format(_T("%lld,%lld;"), _nStart, _nEnd);
			if (_nIndex != -1)
				_strRet += strSelection_.Right(strSelection_.GetLength() - _nIndex - 1);
			break;
		}

		// ��ǰλ����ij�������ڡ� ---- �ƺ��� 2016-09-14
		if (nStartPos_ >= _nStart && nStartPos_ < _nEnd)
		{
			_strRet.Format(_T("%lld,%lld;"), nStartPos_, _nEnd);
			if (_nIndex != -1)
				_strRet += strSelection_.Right(strSelection_.GetLength() - _nIndex - 1);
			break;
		}

		// ��ǰλ�øպ���ij��������յ㡣 ---- �ƺ��� 2016-09-14
		if (nStartPos_ == _nEnd && _nIndex != -1)
		{
			_strRet = strSelection_.Right(strSelection_.GetLength() - _nIndex - 1);
			break;
		}

		if (_nIndex == -1)
			break;

		_nLastEndPos = _nEnd;
		int _nNextIndex = strSelection_.Find(_T(';'), _nIndex + 1);
		_strSection = _nNextIndex == -1
			? strSelection_.Right(strSelection_.GetLength() - _nIndex - 1)
			: strSelection_.Mid(_nIndex + 1, _nNextIndex - _nIndex);
		_nIndex = _nNextIndex;
	}

	// ������һ���Ƿֺţ���ɾ���� ---- �ƺ��� 2016-09-14
	int _nLen = _strRet.GetLength();
	if (_nLen > 0 && _strRet[_nLen - 1] == _T(';'))
	{
		_strRet.Delete(_nLen - 1);
	}

	return _strRet;
}

void CControlTarget::_DoWCSAdjust(DRECT& rcRect_)
{
	CWCSAdjustTarget* _pWCSAdjustTarget = GetWCSAdjustTarget();
	if (!_pWCSAdjustTarget)
		return;

	DRECT _rcOrg = rcRect_;
	DPOINT2 _ptTopLeft (_rcOrg.GetLeft(), _rcOrg.GetTop());
	DPOINT2 _ptRightBottom(_rcOrg.GetRight(), _rcOrg.GetBottom());
	DPOINT2 _ptBottomLeft(_rcOrg.GetLeft(), _rcOrg.GetBottom());
	DPOINT2 _ptTopRight(_rcOrg.GetRight(), _rcOrg.GetTop());
	_ptTopLeft = _pWCSAdjustTarget->DoWCSAdjust(_ptTopLeft);
	_ptRightBottom = _pWCSAdjustTarget->DoWCSAdjust(_ptRightBottom);
	_ptBottomLeft = _pWCSAdjustTarget->DoWCSAdjust(_ptBottomLeft);
	_ptTopRight = _pWCSAdjustTarget->DoWCSAdjust(_ptTopRight);
	double _nLeft = min(min(min(_ptTopLeft.x, _ptTopRight.x), _ptBottomLeft.x), _ptRightBottom.x);
	double _nRight = max(max(max(_ptTopLeft.x, _ptTopRight.x), _ptBottomLeft.x), _ptRightBottom.x);
	double _nBottom = min(min(min(_ptTopLeft.y, _ptTopRight.y), _ptBottomLeft.y), _ptRightBottom.y);
	double _nTop = max(max(max(_ptTopLeft.y, _ptTopRight.y), _ptBottomLeft.y), _ptRightBottom.y);
	DRECT _rcNew;
	_rcNew.x = _nLeft;
	_rcNew.y = _nBottom;
	_rcNew.width = _nRight - _nLeft;
	_rcNew.height = _nTop - _nBottom;
	rcRect_ = _rcNew;
}

// ����Cad��ID�ҵ���Ӧ��Cad
static bool _FindObjectByID(IN CCadObject* pCadObject_, IN int nID_, OUT CCadObject** ppResult_)
{
	if (pCadObject_->GetID() == nID_)
	{
		*ppResult_ = pCadObject_;
		return true;
	}

	if (pCadObject_->GetType() == cadtext)
	{
		CCadText* _pCadText = dynamic_cast<CCadText*>(pCadObject_);
		ASSERT(_pCadText);
		if (_FindObjectByID(_pCadText->GetTextGroup(), nID_, ppResult_))
			return true;
	}
	if (pCadObject_->GetType() == cadgroup)
	{
		CCadGroup* _pCadGroup = dynamic_cast<CCadGroup*>(pCadObject_);
		ASSERT(_pCadGroup);
		for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
		{
			CCadObject* _pCad = _pCadGroup->GetAt(_i);
			ASSERT(_pCad);
			if (_FindObjectByID(_pCad, nID_, ppResult_))
				return true;
		}
	}

	return false;
}

__int64 CControlTarget::_SelectionFirst(const CStringA& strSelection_)
{
	if (strSelection_.IsEmpty())
	{
		ASSERT(FALSE);
		return 0;
	}

	int _nIndex = strSelection_.Find(_T(';'));
	CString _strSection = _nIndex == -1 ? strSelection_ : strSelection_.Mid(0, _nIndex);
	__int64 _nLastEndPos = -1;
	CString _strRet;
	if(!_strSection.IsEmpty())
	{
		__int64 _nStart = 0;
		__int64 _nEnd = 0;
		int _nCount = sscanf_s(_strSection, _T("%lld,%lld"), &_nStart, &_nEnd);
		ASSERT(_nCount == 2);
		return _nStart;
	}
	return 0;
}


void _GetCadIDObj(IN CCadObject* pCadObject_, OUT vectorUINT& setIDs_)
{
	setIDs_.push_back(pCadObject_->GetID());
	if (pCadObject_->GetType() == cadtext)
	{
		CCadText* _pCadText = dynamic_cast<CCadText*>(pCadObject_);
		ASSERT(_pCadText);
		_GetCadIDObj(_pCadText->GetTextGroup(), setIDs_);

	}
	if (pCadObject_->GetType() == cadgroup)
	{
		CCadGroup* _pCadGroup = dynamic_cast<CCadGroup*>(pCadObject_);
		ASSERT(_pCadGroup);
		for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
		{
			CCadObject* _pCad = _pCadGroup->GetAt(_i);
			ASSERT(_pCad);
			_GetCadIDObj(_pCad, setIDs_);
		}
	}
}

void _GetCadIDList(IN CadObjectList* pListCads_, OUT vectorUINT& setIDs_)
{
	for (CadObjectList::iterator _it = pListCads_->begin(); _it != pListCads_->end(); _it++)
	{
		_GetCadIDObj(*_it, setIDs_);
	}
}

void _GetCamGroupByCadID(IN nce::CCamGroup* pCCamGroup_, IN vectorUINT setIDs_, OUT nce::CCamGroup* pOutCCamGroup_)
{
	ASSERT(pCCamGroup_);
	CamObjectList* _plistCamObjs = pCCamGroup_->GetObjectsList();
	for (CamObjectList::const_iterator _it = _plistCamObjs->begin(); _it != _plistCamObjs->end(); _it++)
	{
		// ����Ҫ�����غϵ�CAM
		CCamObject* _pCam = *_it;
		CCadObject* _pCad = NULL;

		// ����Cam�е�CadID�����ҵ���Ӧ��Cad
		int _nID = (int)_pCam->GetKey_DBL("CadID");
		if (std::find(setIDs_.begin(), setIDs_.end(), _nID) != setIDs_.end())
		{
			pOutCCamGroup_->GetObjectsList()->push_back(_pCam);
		}
	}
	return;
	for (int _i = 0; _i < setIDs_.size(); _i++)
	{
		CCamObject* _pCamObject = NULL;
		SendTargetMessage(ID_TARGET_CADTOCAM, TN_GETCAM_BYCADID, setIDs_[_i], (LPARAM)&_pCamObject);
		if (_pCamObject != NULL)
		{
			pOutCCamGroup_->GetObjectsList()->push_back(_pCamObject);
		}
	}

}

void  CControlTarget::_SendGasPressureInfo()
{
	CString _flag = NceGetPrivateProfileString(_T("GasCheck"), _T("GNGasCheck"), _T("0"));
	if ("1" != _flag)
	{
		return;
	}
	CStateManager* _pStateManager = GetStateManager();
	ASSERT(_pStateManager);
	bool _bAirCheck = false;
	bool _bOxygenCheck = false;
	bool _bNitrogenCheck = false;
	CFileTarget* _pFileTarget = GetFileTarget();
	ASSERT(_pFileTarget);	
	nce::ParamVector* _pParamVector = _pFileTarget->GetCurrentCadParams();
	nce::CCadGroup* _pCurrentCadGroup = _pFileTarget->GetCurrentCadGroup();

	for (size_t _i = 0; _i < _pParamVector->size(); _i++)
	{

		if (_bAirCheck && _bOxygenCheck && _bNitrogenCheck)
		{
			continue;
		}
		if (_pStateManager->IsSelectedMach())
		{
			bool _isSelect = false;
			//�ж�ѡ��ͼ����ѡ������������Ƿ�Ҫ����ѹ�;���
			for (int _j = 0; _j < _pCurrentCadGroup->GetNumOfChild(); _j++)
			{
				if (_pCurrentCadGroup->GetAt(_j)->IsSelected())
				{
					if (_i == _pCurrentCadGroup->GetAt(_j)->GetParamIndex())
					{
						_isSelect = true;
					}
				}
			}

			if(!_isSelect)
			{
				continue;
			}
		}
		else
		{
			//�жϵ�ǰ������ͼ����ѡ������������Ƿ�Ҫ����ѹ�;���
			for (int _j = 0; _j < _pCurrentCadGroup->GetNumOfChild(); _j++)
			{
				if (_i == _pCurrentCadGroup->GetAt(_j)->GetParamIndex())
				{
						CParam* _pParam = _pParamVector->at(_i);
						if(_pParam->GetKey(c_szOutput) == _T("0"))
						{
							continue;
						}
						//��ȴ���ж�
						if (_pParam->GetKey(c_szCoolBlowType) == _T("0"))
						{
							_bAirCheck = true;
						}
						if (_pParam->GetKey(c_szCoolBlowType) == _T("1"))
						{
							_bNitrogenCheck = true;
						}
						if (_pParam->GetKey(c_szCoolBlowType) == _T("2"))
						{
							_bOxygenCheck = true;
						}
						if (_pParam->GetKey(c_szCoolBlowType) == _T("3"))
						{
							_bNitrogenCheck = true;
						}
						if (_pParam->GetKey(c_szCoolBlowType) == _T("4"))
						{
							_bOxygenCheck = true;
						}

						//���׷�ʽ
						//ֱ�Ӵ���
						if (_pParam->GetKey(c_szPerforateType) == _T("0"))
						{
							//�и������ж�
							if (_pParam->GetKey(c_szCutBlowType) == _T("0"))
							{
								_bAirCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("1"))
							{
								_bNitrogenCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("2"))
							{
								_bOxygenCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("3"))
							{
								_bNitrogenCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("4"))
							{
								_bOxygenCheck = true;
							}
						}
						//�������׻�ֶδ���
						if (_pParam->GetKey(c_szPerforateType) == _T("1") || _pParam->GetKey(c_szPerforateType) == _T("2"))
						{
							//�и������ж�
							if (_pParam->GetKey(c_szCutBlowType) == _T("0"))
							{
								_bAirCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("1"))
							{
								_bNitrogenCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("2"))
							{
								_bOxygenCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("3"))
							{
								_bNitrogenCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("4"))
							{
								_bOxygenCheck = true;
							}

							//���������ж�
							if (_pParam->GetKey(c_szPerBlowType) == _T("0"))
							{
								_bAirCheck = true;
							}
							if (_pParam->GetKey(c_szPerBlowType) == _T("1"))
							{
								_bNitrogenCheck = true;
							}
							if (_pParam->GetKey(c_szPerBlowType) == _T("2"))
							{
								_bOxygenCheck = true;
							}
							if (_pParam->GetKey(c_szPerBlowType) == _T("3"))
							{
								_bNitrogenCheck = true;
							}
							if (_pParam->GetKey(c_szPerBlowType) == _T("4"))
							{
								_bOxygenCheck = true;
							}

						}
						//��������
						if (_pParam->GetKey(c_szPerforateType) == _T("3"))
						{
                                                       //�и������ж�
							if (_pParam->GetKey(c_szCutBlowType) == _T("0"))
							{
								_bAirCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("1"))
							{
								_bNitrogenCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("2"))
							{
								_bOxygenCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("3"))
							{
								_bNitrogenCheck = true;
							}
							if (_pParam->GetKey(c_szCutBlowType) == _T("4"))
							{
								_bOxygenCheck = true;
							}
							//һ��
							if (_pParam->GetKey(c_szFirstSegPunch) == _T("1"))
							{
								if (_pParam->GetKey(c_szFirstSegBlowType) == _T("0"))
								{
									_bAirCheck = true;
								}
								if (_pParam->GetKey(c_szFirstSegBlowType) == _T("1"))
								{
									_bNitrogenCheck = true;
								}
								if (_pParam->GetKey(c_szFirstSegBlowType) == _T("2"))
								{
									_bOxygenCheck = true;
								}
								if (_pParam->GetKey(c_szFirstSegBlowType) == _T("3"))
								{
									_bNitrogenCheck = true;
								}
								if (_pParam->GetKey(c_szFirstSegBlowType) == _T("4"))
								{
									_bOxygenCheck = true;
								}
							}
							//����
							if (_pParam->GetKey(c_szSecondSegPunch) == _T("1"))
							{
								if (_pParam->GetKey(c_szSecondSegBlowType) == _T("0"))
								{
									_bAirCheck = true;
								}
								if (_pParam->GetKey(c_szSecondSegBlowType) == _T("1"))
								{
									_bNitrogenCheck = true;
								}
								if (_pParam->GetKey(c_szSecondSegBlowType) == _T("2"))
								{
									_bOxygenCheck = true;
								}
								if (_pParam->GetKey(c_szSecondSegBlowType) == _T("3"))
								{
									_bNitrogenCheck = true;
								}
								if (_pParam->GetKey(c_szSecondSegBlowType) == _T("4"))
								{
									_bOxygenCheck = true;
								}
							}
							//����
							if (_pParam->GetKey(c_szThirdSegPunch) == _T("1"))
							{
								if (_pParam->GetKey(c_szThirdSegBlowType) == _T("0"))
								{
									_bAirCheck = true;
								}
								if (_pParam->GetKey(c_szThirdSegBlowType) == _T("1"))
								{
									_bNitrogenCheck = true;
								}
								if (_pParam->GetKey(c_szThirdSegBlowType) == _T("2"))
								{
									_bOxygenCheck = true;
								}
								if (_pParam->GetKey(c_szThirdSegBlowType) == _T("3"))
								{
									_bNitrogenCheck = true;
								}
								if (_pParam->GetKey(c_szThirdSegBlowType) == _T("4"))
								{
									_bOxygenCheck = true;
								}
							}

						}
					}
					//��ӹ���ͬʱ����Ҫ�ж�һ��ͨ��ͼ���е���������
					CParamManager* _pParamManager = GetParamManager();

					ParameterValue _DefaultBlowType;
					_pParamManager->GetParameterValue("GP_DefaultBlowType", &_DefaultBlowType);
					if(0 == _DefaultBlowType.iValue)
					{
						_bAirCheck = true;
					}
					else if ((1 == _DefaultBlowType.iValue) || (3 == _DefaultBlowType.iValue))
					{
						_bNitrogenCheck = true;
					}
					else if ((2 == _DefaultBlowType.iValue) || (4 == _DefaultBlowType.iValue))
					{
						_bOxygenCheck = true;
					}
					CString _strCheckAir("EnableCheckAir");
					SendTargetMessage(ID_TARGET_PARAMMANAGER, TM_SET_PARAMVALUE, WPARAM(_strCheckAir.GetBuffer()), (LPARAM)&_bAirCheck);

					CString _strCheckOxygen("EnableCheckOxygen");
					SendTargetMessage(ID_TARGET_PARAMMANAGER, TM_SET_PARAMVALUE, WPARAM(_strCheckOxygen.GetBuffer()), (LPARAM)&_bOxygenCheck);

					CString _strCheckNitrogen("EnableCheckNitrogen");
					SendTargetMessage(ID_TARGET_PARAMMANAGER, TM_SET_PARAMVALUE, WPARAM(_strCheckNitrogen.GetBuffer()), (LPARAM)&_bNitrogenCheck);
				}
			}
		}
		
}
void CControlTarget::SetSelectMach(bool _bSelectMach)
{
	m_bSelectMach = _bSelectMach;
}
bool CControlTarget::GetSelectMach()
{
	return m_bSelectMach;
}