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文件的参数---- 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 - 选中加工图形走边框后，删除某图形，接着走边框将返回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是不一样的
	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;
	}

	//如果焦点窗口是编辑框，则不进行手动操作 ---- 杨开锦 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;
		}

		// 当前位置在某个区间内。 ---- 黄海燕 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;
		}

		// 当前位置刚好是某个区间的终点。 ---- 黄海燕 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;
}