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

#include "pch.h"
#include "resource.h"		// 主符号
#include "CGeneratorDlg.h"
#include "afxdialogex.h"

#include "CConfigDlg.h"

// CGenDlg 对话框

IMPLEMENT_DYNAMIC(CGeneratorDlg, CDiosBasicDlg)

CGeneratorDlg::CGeneratorDlg(CWnd* pParent /*=nullptr*/)
	: CDiosBasicDlg(Dev_Generator,IDD_DIALOG1, pParent)
{
}

CGeneratorDlg::~CGeneratorDlg()
{
}

void CGeneratorDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	//Rad
	DDX_Control(pDX, IDC_EDIT1, m_Edit_KV);
	DDX_Control(pDX, IDC_EDIT3, m_Edit_MA);
	DDX_Control(pDX, IDC_EDIT4, m_Edit_MS);
	DDX_Control(pDX, IDC_EDIT2, m_Edit_MAS);
	DDX_Control(pDX, IDC_EDIT5, m_Edit_Density);
	DDX_Control(pDX, IDC_EDIT6, m_Edit_Field);
	DDX_Control(pDX, IDC_EDIT7, m_Edit_Film);
	DDX_Control(pDX, IDC_RADIO1, m_radio_fo_small);
	DDX_Control(pDX, IDC_RADIO2, m_radio_fo_large);
	DDX_Control(pDX, IDC_EDIT8, m_Edit_FocusSize);
	DDX_Control(pDX, IDC_RADIO3, m_radio_et_noAEC2P);
	DDX_Control(pDX, IDC_RADIO4, m_radio_et_noAEC3P);
	DDX_Control(pDX, IDC_RADIO8, m_radio_et_noAECMASMA);
	DDX_Control(pDX, IDC_RADIO5, m_radio_et_AEC1P);
	DDX_Control(pDX, IDC_RADIO6, m_radio_et_AEC2P);
	DDX_Control(pDX, IDC_RADIO7, m_radio_et_AEC3P);
	DDX_Control(pDX, IDC_RADIO9, m_radio_et_AECMASMA);
	DDX_Control(pDX, IDC_RADIO10, m_radio_ws_table);
	DDX_Control(pDX, IDC_RADIO11, m_radio_ws_wall);
	DDX_Control(pDX, IDC_RADIO12, m_radio_ws_conventional);
	DDX_Control(pDX, IDC_RADIO13, m_radio_ws_mobile);
	DDX_Control(pDX, IDC_RADIO14, m_radio_ws_free);
	DDX_Control(pDX, IDC_RADIO15, m_radio_ws_tomo);
	DDX_Control(pDX, IDC_EDIT15, m_Edit_postmas);
	DDX_Control(pDX, IDC_EDIT13, m_Edit_postkv);
	DDX_Control(pDX, IDC_EDIT16, m_Edit_postms);
	DDX_Control(pDX, IDC_EDIT14, m_Edit_postma);
	DDX_Control(pDX, IDC_EDIT17, m_Edit_tubeheat);
	DDX_Control(pDX, IDC_EDIT12, m_Edit_gensynstate);
	DDX_Control(pDX, IDC_EDIT11, m_Edit_genstate);
	DDX_Control(pDX, IDC_EDIT9, m_Edit_expmode);
	DDX_Control(pDX, IDC_EDIT10, m_Edit_exammode);
	DDX_Control(pDX, IDC_EDIT18, m_Edit_tubetargetmaterial);
	DDX_Control(pDX, IDC_EDIT19, m_Edit_tubeangle);
	DDX_Control(pDX, IDC_EDIT20, m_Edit_RadFrameRate);
	DDX_Control(pDX, IDC_EDIT21, m_Edit_genEXPstate);
	//Flu
	DDX_Control(pDX, IDC_EDIT22, m_Edit_FluKV);
	DDX_Control(pDX, IDC_EDIT23, m_Edit_FluMA);
	DDX_Control(pDX, IDC_EDIT24, m_Edit_FluPPS);
	DDX_Control(pDX, IDC_EDIT25, m_Edit_FluPluseWidth);
	DDX_Control(pDX, IDC_RADIO19, m_radio_FluMode_Not);
	DDX_Control(pDX, IDC_RADIO20, m_radio_FluMode_CF);
	DDX_Control(pDX, IDC_RADIO21, m_radio_FluMode_PF);
	DDX_Control(pDX, IDC_RADIO22, m_radio_FluMode_HCF);
	DDX_Control(pDX, IDC_RADIO23, m_radio_FluMode_HPF);
	DDX_Control(pDX, IDC_RADIO16, m_radio_ABS_OFF);
	DDX_Control(pDX, IDC_RADIO17, m_radio_ABS_OnKV);
	DDX_Control(pDX, IDC_RADIO18, m_radio_ABS_OnKVMA);
	DDX_Control(pDX, IDC_EDIT26, m_Edit_FluABSCurve);
	DDX_Control(pDX, IDC_EDIT27, m_Edit_FluDoseLever);
	DDX_Control(pDX, IDC_EDIT28, m_Edit_FluCurrEXI);
	DDX_Control(pDX, IDC_EDIT29, m_Edit_FluTarEXI);
	DDX_Control(pDX, IDC_EDIT30, m_Edit_FluMag);
	DDX_Control(pDX, IDC_EDIT31, m_Edit_FluResetTime);
	DDX_Control(pDX, IDC_EDIT33, m_Edit_FluPre);
	DDX_Control(pDX, IDC_EDIT34, m_Edit_FluEXP);
	DDX_Control(pDX, IDC_EDIT35, m_Edit_FluIntTimer);
	DDX_Control(pDX, IDC_EDIT36, m_Edit_FluAccTimer);
	DDX_Control(pDX, IDC_EDIT37, m_Edit_FluHandSwitch);
	DDX_Control(pDX, IDC_EDIT38, m_Edit_FluFootSwitch);
	DDX_Control(pDX, IDC_EDIT39, m_Edit_DirectlyNotifyKey);
	DDX_Control(pDX, IDC_EDIT40, m_Edit_DirectlyNotifyValue);
	DDX_Control(pDX, IDC_EDIT41, m_Edit_DirectlyCMD);
}


BEGIN_MESSAGE_MAP(CGeneratorDlg, CDialogEx)
	//Rad
	ON_BN_CLICKED(IDC_BUTTON3, &CGeneratorDlg::OnBnClickedButton3)
	ON_BN_CLICKED(IDC_BUTTON1, &CGeneratorDlg::OnBnClickedButton1)
	ON_BN_CLICKED(IDC_BUTTON2, &CGeneratorDlg::OnBnClickedButton2)
	ON_BN_CLICKED(IDC_BUTTON4, &CGeneratorDlg::OnBnClickedButton4)
	ON_BN_CLICKED(IDC_BUTTON5, &CGeneratorDlg::OnBnClickedButton5)
	ON_BN_CLICKED(IDC_BUTTON6, &CGeneratorDlg::OnBnClickedButton6)
	ON_BN_CLICKED(IDC_BUTTON7, &CGeneratorDlg::OnBnClickedButton7)
	ON_BN_CLICKED(IDC_BUTTON8, &CGeneratorDlg::OnBnClickedButton8)
	ON_BN_CLICKED(IDC_BUTTON9, &CGeneratorDlg::OnBnClickedButton9)
	ON_BN_CLICKED(IDC_BUTTON10, &CGeneratorDlg::OnBnClickedButton10)
	ON_BN_CLICKED(IDC_BUTTON11, &CGeneratorDlg::OnBnClickedButton11)
	ON_BN_CLICKED(IDC_BUTTON12, &CGeneratorDlg::OnBnClickedButton12)
	ON_BN_CLICKED(IDC_BUTTON13, &CGeneratorDlg::OnBnClickedButton13)
	ON_BN_CLICKED(IDC_BUTTON14, &CGeneratorDlg::OnBnClickedButton14)
	ON_BN_CLICKED(IDC_BUTTON15, &CGeneratorDlg::OnBnClickedButton15)
	ON_BN_CLICKED(IDC_BUTTON16, &CGeneratorDlg::OnBnClickedButton16)
	ON_BN_CLICKED(IDC_BUTTON17, &CGeneratorDlg::OnBnClickedButton17)
	ON_BN_CLICKED(IDC_BUTTON18, &CGeneratorDlg::OnBnClickedButton18)
	ON_BN_CLICKED(IDC_BUTTON19, &CGeneratorDlg::OnBnClickedButton19)
	ON_BN_CLICKED(IDC_BUTTON20, &CGeneratorDlg::OnBnClickedButton20)
	ON_BN_CLICKED(IDC_BUTTON21, &CGeneratorDlg::OnBnClickedButton21)
	ON_BN_CLICKED(IDC_BUTTON22, &CGeneratorDlg::OnBnClickedButton22)
	ON_BN_CLICKED(IDC_BUTTON23, &CGeneratorDlg::OnBnClickedButton23)
	ON_BN_CLICKED(IDC_BUTTON28, &CGeneratorDlg::OnBnClickedButton28)
	ON_BN_CLICKED(IDC_BUTTON25, &CGeneratorDlg::OnBnClickedButton25)
	ON_BN_CLICKED(IDC_BUTTON36, &CGeneratorDlg::OnBnClickedButton36)
	ON_BN_CLICKED(IDC_RADIO1, &CGeneratorDlg::OnBnClickedRadio1)
	ON_BN_CLICKED(IDC_RADIO2, &CGeneratorDlg::OnBnClickedRadio2)
	ON_BN_CLICKED(IDC_RADIO3, &CGeneratorDlg::OnBnClickedRadio3)
	ON_BN_CLICKED(IDC_RADIO4, &CGeneratorDlg::OnBnClickedRadio4)
	ON_BN_CLICKED(IDC_RADIO8, &CGeneratorDlg::OnBnClickedRadio8)
	ON_BN_CLICKED(IDC_RADIO5, &CGeneratorDlg::OnBnClickedRadio5)
	ON_BN_CLICKED(IDC_RADIO6, &CGeneratorDlg::OnBnClickedRadio6)
	ON_BN_CLICKED(IDC_RADIO7, &CGeneratorDlg::OnBnClickedRadio7)
	ON_BN_CLICKED(IDC_RADIO9, &CGeneratorDlg::OnBnClickedRadio9)
	ON_BN_CLICKED(IDC_RADIO10, &CGeneratorDlg::OnBnClickedRadio10)
	ON_BN_CLICKED(IDC_RADIO11, &CGeneratorDlg::OnBnClickedRadio11)
	ON_BN_CLICKED(IDC_RADIO12, &CGeneratorDlg::OnBnClickedRadio12)
	ON_BN_CLICKED(IDC_RADIO13, &CGeneratorDlg::OnBnClickedRadio13)
	ON_BN_CLICKED(IDC_RADIO14, &CGeneratorDlg::OnBnClickedRadio14)
	ON_BN_CLICKED(IDC_RADIO15, &CGeneratorDlg::OnBnClickedRadio15)
	ON_EN_KILLFOCUS(IDC_EDIT1, &CGeneratorDlg::OnEnKillfocusEdit1)
	ON_EN_KILLFOCUS(IDC_EDIT2, &CGeneratorDlg::OnEnKillfocusEdit2)
	ON_EN_KILLFOCUS(IDC_EDIT3, &CGeneratorDlg::OnEnKillfocusEdit3)
	ON_EN_KILLFOCUS(IDC_EDIT4, &CGeneratorDlg::OnEnKillfocusEdit4)
	ON_EN_KILLFOCUS(IDC_EDIT5, &CGeneratorDlg::OnEnKillfocusEdit5)
	ON_EN_KILLFOCUS(IDC_EDIT6, &CGeneratorDlg::OnEnKillfocusEdit6)
	ON_EN_KILLFOCUS(IDC_EDIT7, &CGeneratorDlg::OnEnKillfocusEdit7)
	ON_EN_KILLFOCUS(IDC_EDIT9, &CGeneratorDlg::OnEnKillfocusEdit9)
	ON_EN_KILLFOCUS(IDC_EDIT20, &CGeneratorDlg::OnEnKillfocusEdit20)
	//Flu
	ON_BN_CLICKED(IDC_BUTTON37, &CGeneratorDlg::OnBnClickedButton37)
	ON_BN_CLICKED(IDC_BUTTON38, &CGeneratorDlg::OnBnClickedButton38)
	ON_BN_CLICKED(IDC_BUTTON39, &CGeneratorDlg::OnBnClickedButton39)
	ON_BN_CLICKED(IDC_BUTTON40, &CGeneratorDlg::OnBnClickedButton40)
	ON_BN_CLICKED(IDC_BUTTON41, &CGeneratorDlg::OnBnClickedButton41)
	ON_BN_CLICKED(IDC_BUTTON42, &CGeneratorDlg::OnBnClickedButton42)
	ON_BN_CLICKED(IDC_BUTTON43, &CGeneratorDlg::OnBnClickedButton43)
	ON_BN_CLICKED(IDC_BUTTON44, &CGeneratorDlg::OnBnClickedButton44)
	ON_BN_CLICKED(IDC_RADIO19, &CGeneratorDlg::OnBnClickedRadio19)
	ON_BN_CLICKED(IDC_RADIO20, &CGeneratorDlg::OnBnClickedRadio20)
	ON_BN_CLICKED(IDC_RADIO21, &CGeneratorDlg::OnBnClickedRadio21)
	ON_BN_CLICKED(IDC_RADIO22, &CGeneratorDlg::OnBnClickedRadio22)
	ON_BN_CLICKED(IDC_RADIO23, &CGeneratorDlg::OnBnClickedRadio23)
	ON_BN_CLICKED(IDC_RADIO16, &CGeneratorDlg::OnBnClickedRadio16)
	ON_BN_CLICKED(IDC_RADIO17, &CGeneratorDlg::OnBnClickedRadio17)
	ON_BN_CLICKED(IDC_RADIO18, &CGeneratorDlg::OnBnClickedRadio18)
	ON_BN_CLICKED(IDC_BUTTON45, &CGeneratorDlg::OnBnClickedButton45)
	ON_BN_CLICKED(IDC_BUTTON46, &CGeneratorDlg::OnBnClickedButton46)
	ON_BN_CLICKED(IDC_BUTTON47, &CGeneratorDlg::OnBnClickedButton47)
	ON_BN_CLICKED(IDC_BUTTON48, &CGeneratorDlg::OnBnClickedButton48)
	ON_BN_CLICKED(IDC_BUTTON49, &CGeneratorDlg::OnBnClickedButton49)
	ON_BN_CLICKED(IDC_BUTTON50, &CGeneratorDlg::OnBnClickedButton50)
	ON_BN_CLICKED(IDC_BUTTON52, &CGeneratorDlg::OnBnClickedButton52)
	ON_BN_CLICKED(IDC_BUTTON53, &CGeneratorDlg::OnBnClickedButton53)
	ON_BN_CLICKED(IDC_BUTTON54, &CGeneratorDlg::OnBnClickedButton54)
	ON_EN_KILLFOCUS(IDC_EDIT22, &CGeneratorDlg::OnEnKillfocusEdit22)
	ON_EN_KILLFOCUS(IDC_EDIT23, &CGeneratorDlg::OnEnKillfocusEdit23)
	ON_EN_KILLFOCUS(IDC_EDIT24, &CGeneratorDlg::OnEnKillfocusEdit24)
	ON_EN_KILLFOCUS(IDC_EDIT25, &CGeneratorDlg::OnEnKillfocusEdit25)
	ON_EN_KILLFOCUS(IDC_EDIT26, &CGeneratorDlg::OnEnKillfocusEdit26)
	ON_EN_KILLFOCUS(IDC_EDIT27, &CGeneratorDlg::OnEnKillfocusEdit27)
	ON_EN_KILLFOCUS(IDC_EDIT28, &CGeneratorDlg::OnEnKillfocusEdit28)
	ON_EN_KILLFOCUS(IDC_EDIT29, &CGeneratorDlg::OnEnKillfocusEdit29)
	ON_EN_KILLFOCUS(IDC_EDIT30, &CGeneratorDlg::OnEnKillfocusEdit30)
	ON_EN_KILLFOCUS(IDC_EDIT31, &CGeneratorDlg::OnEnKillfocusEdit31)
	ON_EN_KILLFOCUS(IDC_EDIT33, &CGeneratorDlg::OnEnKillfocusEdit33)
	ON_EN_KILLFOCUS(IDC_EDIT34, &CGeneratorDlg::OnEnKillfocusEdit34)
	//启用滚动条
	ON_WM_MOUSEWHEEL()
	ON_WM_VSCROLL()
	//ON_WM_HSCROLL()
END_MESSAGE_MAP()


// CGenDlg 消息处理程序

//初始化配置
BOOL CGeneratorDlg::OnInitDialog()
{
	CDiosBasicDlg::OnInitDialog();

	return TRUE;
}

//设备初始化
bool CGeneratorDlg::AppInitial(bool act)
{
	CString log;
	return CreatMode(act);
}
//获取初始值
bool CGeneratorDlg::GetInitData()
{
	CString log;
	CString tempStr;
	string strTempValue;
	if (m_pDevice != nullptr)
	{
		m_nWS = atoi(DevGetValue(nsGEN::AttrKey::WORKSTATION).c_str());
		tempStr.Format("%d", m_nWS);
		SetWorkStation((nsGEN::AttrKey::GENWS_TYPE)m_nWS);

		m_nKV = atoi(DevGetValue(nsGEN::AttrKey::KV).c_str());
		tempStr.Format("%d", m_nKV);
		m_Edit_KV.SetWindowText(tempStr);

		m_fMAS = atof(DevGetValue(nsGEN::AttrKey::MAS).c_str());
		tempStr.Format("%.2f", m_fMAS);
		m_Edit_MAS.SetWindowText(tempStr);

		m_fMA = atof(DevGetValue(nsGEN::AttrKey::MA).c_str());
		tempStr.Format("%.2f", m_fMA);
		m_Edit_MA.SetWindowText(tempStr);

		m_fMS = atof(DevGetValue(nsGEN::AttrKey::MS).c_str());
		tempStr.Format("%.2f", m_fMS);
		m_Edit_MS.SetWindowText(tempStr);

		m_nAECDensity = atoi(DevGetValue(nsGEN::AttrKey::AECDENSITY).c_str());
		tempStr.Format("%d", m_nAECDensity);
		m_Edit_Density.SetWindowText(tempStr);

		m_nAECField = atoi(DevGetValue(nsGEN::AttrKey::AECFIELD).c_str());
		tempStr.Format("%d", m_nAECField);
		m_Edit_Field.SetWindowText(tempStr);

		m_nAECFilm = atoi(DevGetValue(nsGEN::AttrKey::AECFILM).c_str());
		tempStr.Format("%d", m_nAECFilm);
		m_Edit_Film.SetWindowText(tempStr);

		m_nFO = atoi(DevGetValue(nsGEN::AttrKey::FOCUS).c_str());
		SetFocus((nsGEN::AttrKey::FOCUS_TYPE)m_nFO);
		tempStr.Format("%f", m_nFOSize);
		m_Edit_FocusSize.SetWindowText(tempStr);

		m_nET = atoi(DevGetValue(nsGEN::AttrKey::TECHMODE).c_str());
		SetTechMode((nsGEN::AttrKey::TECHMODE_TYPE)m_nET);

		m_fpostKV = atof(DevGetValue(nsGEN::AttrKey::POSTKV).c_str());
		tempStr.Format("%.2f", m_fpostKV);
		m_Edit_postkv.SetWindowText(tempStr);

		m_fpostMAS = atof(DevGetValue(nsGEN::AttrKey::POSTMAS).c_str());
		tempStr.Format("%.2f", m_fpostMAS);
		m_Edit_postmas.SetWindowText(tempStr);

		m_fpostMS = atof(DevGetValue(nsGEN::AttrKey::POSTMS).c_str());
		tempStr.Format("%.2f", m_fpostMS);
		m_Edit_postms.SetWindowText(tempStr);

		m_fpostMA = atof(DevGetValue(nsGEN::AttrKey::POSTMA).c_str());
		tempStr.Format("%.2f", m_fpostMA);
		m_Edit_postma.SetWindowText(tempStr);

		strTempValue = DevGetValue(nsGEN::AttrKey::TUBEHEAT);
		m_Edit_tubeheat.SetWindowText(strTempValue.c_str());

		strTempValue = DevGetValue(nsGEN::AttrKey::GENSYNSTATE);
		int synstate = atoi(strTempValue.c_str());
		SetGenSynStatus((nsGEN::AttrKey::GENERATOR_SYNC)synstate);

		strTempValue = DevGetValue(nsGEN::AttrKey::GENSTATE);
		int unitstate = atoi(strTempValue.c_str());
		SetGenStatus((nsGEN::AttrKey::GENERATOR_STATUS)unitstate);

		strTempValue = DevGetValue(nsGEN::AttrKey::EXPMODE);
		m_Edit_expmode.SetWindowText(strTempValue.c_str());

		strTempValue = DevGetValue(nsGEN::AttrKey::EXAMMODE);
		m_Edit_exammode.SetWindowText(strTempValue.c_str());

		strTempValue = DevGetValue(nsGEN::AttrKey::TUBETARGETMATERIAL);
		m_Edit_tubetargetmaterial.SetWindowText(strTempValue.c_str());

		strTempValue = DevGetValue(nsGEN::AttrKey::TUBEANGLE);
		m_Edit_tubeangle.SetWindowText(strTempValue.c_str());

		GetDlgItem(IDC_BUTTON21)->SetWindowText("ExpDisable");

		m_nFluKV = atoi(DevGetValue(nsGEN::AttrKey::FLUKV).c_str());
		tempStr.Format("%d", m_nFluKV);
		m_Edit_FluKV.SetWindowText(tempStr);

		m_fFluMA = atof(DevGetValue(nsGEN::AttrKey::FLUMA).c_str());
		tempStr.Format("%.2f", m_fFluMA);
		m_Edit_FluMA.SetWindowText(tempStr);

		m_fPPS = atof(DevGetValue(nsGEN::AttrKey::FLUPPS).c_str());
		tempStr.Format("%.1f", m_fPPS);
		m_Edit_FluPPS.SetWindowText(tempStr);

		m_nFluMode = nsGEN::AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_PF;
		SetFluMode((nsGEN::AttrKey::GENERATOR_FLUMode)m_nFluMode);

		m_nABSMode = nsGEN::AttrKey::GENERATOR_ABSStatus::GENERATOR_ABS_OFF;
		SetABSMode((nsGEN::AttrKey::GENERATOR_ABSStatus)m_nABSMode);

		m_nFluIntTimer = atoi(DevGetValue(nsGEN::AttrKey::FLUIntTime).c_str());
		tempStr.Format("%d", m_nFluIntTimer);
		m_Edit_FluIntTimer.SetWindowText(tempStr);

		m_nFluAccTimer = atoi(DevGetValue(nsGEN::AttrKey::FLUAccTime).c_str());
		tempStr.Format("%d", m_nFluAccTimer);
		m_Edit_FluAccTimer.SetWindowText(tempStr);

	}
	return true;
}
//设置消息对照表
void CGeneratorDlg::SetMagMap()
{
	auto HW_UNKNOWN = [this](int NotifyCode, string key, string context)
	{
		CString strNotify;
		strNotify.Format("GEN can not deal with Attribute[%s] \n", key.c_str());
		ToolsDlgLog(strNotify);
	};
	//Rad
	auto HW_KV = [this](int NotifyCode, string key, string context)//KV
	{
		m_nKV = atoi(context.c_str());
		m_Edit_KV.SetWindowText(context.c_str());
	};
	auto HW_MA = [this](int NotifyCode, string key, string context)//MA
	{
		m_fMA = atof(context.c_str());
		m_Edit_MA.SetWindowText(context.c_str());
	};
	auto HW_MS = [this](int NotifyCode, string key, string context)//MS
	{
		m_fMS = atof(context.c_str());
		m_Edit_MS.SetWindowText(context.c_str());
	};
	auto HW_MAS = [this](int NotifyCode, string key, string context)//MAS
	{
		m_fMAS = atof(context.c_str());
		m_Edit_MAS.SetWindowText(context.c_str());
	};
	auto HW_FOCUS = [this](int NotifyCode, string key, string context)//FOCUS
	{
		m_nFO = atoi(context.c_str());
		SetFocus((nsGEN::AttrKey::FOCUS_TYPE)m_nFO);
	};
	auto HW_FOCUSSIZE = [this](int NotifyCode, string key, string context)//FOCUSSIZE
	{
		m_nFOSize = atof(context.c_str());
		m_Edit_FocusSize.SetWindowText(context.c_str());
	};
	auto HW_WORKSTATION = [this](int NotifyCode, string key, string context)//WORKSTATION
	{
		//m_nWS = atoi(context.c_str());
		//SetWorkStation((nsGEN::AttrKey::GENWS_TYPE)m_nWS);
	};
	auto HW_TECHMODE = [this](int NotifyCode, string key, string context)//TECHMODE
	{
		m_nET = atoi(context.c_str());
		SetTechMode((nsGEN::AttrKey::TECHMODE_TYPE)m_nET);
	};
	auto HW_AECDENSITY = [this](int NotifyCode, string key, string context)//AECDENSITY
	{
		m_nAECDensity = atof(context.c_str());
		m_Edit_Density.SetWindowText(context.c_str());
	};
	auto HW_AECFIELD = [this](int NotifyCode, string key, string context)//AECFIELD
	{
		m_Edit_Field.SetWindowText(context.c_str());
	};
	auto HW_AECFILM = [this](int NotifyCode, string key, string context)//AECFILM
	{
		m_Edit_Film.SetWindowText(context.c_str());
	};
	auto HW_TUBEHEAT = [this](int NotifyCode, string key, string context)//TUBEHEAT
	{
		m_Edit_tubeheat.SetWindowText(context.c_str());
	};
	auto HW_POSTKV = [this](int NotifyCode, string key, string context)//POSTKV
	{
		m_fpostKV = atof(context.c_str());
		m_Edit_postkv.SetWindowText(context.c_str());
	};
	auto HW_POSTMA = [this](int NotifyCode, string key, string context)//POSTMA
	{
		m_fpostMA = atof(context.c_str());
		m_Edit_postma.SetWindowText(context.c_str());
	};
	auto HW_POSTMS = [this](int NotifyCode, string key, string context)//POSTMS
	{
		m_fpostMS = atof(context.c_str());
		m_Edit_postms.SetWindowText(context.c_str());
	};
	auto HW_POSTMAS = [this](int NotifyCode, string key, string context)//POSTMAS
	{
		m_fpostMAS = atof(context.c_str());
		m_Edit_postmas.SetWindowText(context.c_str());
	};
	auto HW_GENSYNSTATE = [this](int NotifyCode, string key, string context)//GENSYNSTATE
	{
		CString strNotify;
		int synstate = atoi(context.c_str());
		SetGenSynStatus((nsGEN::AttrKey::GENERATOR_SYNC)synstate);
	};
	auto HW_GENSTATE = [this](int NotifyCode, string key, string context)//GENSTATE
	{
		CString strNotify;
		int unitstate = atoi(context.c_str());
		SetGenStatus((nsGEN::AttrKey::GENERATOR_STATUS)unitstate);
	};
	auto HW_EXPMODE = [this](int NotifyCode, string key, string context)//EXPMODE
	{
		m_Edit_expmode.SetWindowText(context.c_str());
	};
	auto HW_EXAMMODE = [this](int NotifyCode, string key, string context)//EXAMMODE
	{
		m_Edit_exammode.SetWindowText(context.c_str());
	};
	auto HW_TUBETARGETMATERIAL = [this](int NotifyCode, string key, string context)//TUBETARGETMATERIAL
	{
		m_Edit_tubetargetmaterial.SetWindowText(context.c_str());
	};
	auto HW_TUBEANGLE = [this](int NotifyCode, string key, string context)//TUBEANGLE
	{
		m_Edit_tubeangle.SetWindowText(context.c_str());
	};
	//Flu
	auto HW_FluKV = [this](int NotifyCode, string key, string context)//KV
	{
		m_nFluKV = atoi(context.c_str());
		m_Edit_FluKV.SetWindowText(context.c_str());
	};
	auto HW_FluMA = [this](int NotifyCode, string key, string context)//MA
	{
		m_fFluMA = atof(context.c_str());
		m_Edit_FluMA.SetWindowText(context.c_str());
	};
	auto HW_PPS = [this](int NotifyCode, string key, string context)//PPS
	{
		m_fPPS = atof(context.c_str());
		m_Edit_FluPPS.SetWindowText(context.c_str());
	};
	auto HW_PluseWidth = [this](int NotifyCode, string key, string context)//PluseWidth
	{
		m_nPluseWidth = atoi(context.c_str());
		m_Edit_FluPluseWidth.SetWindowText(context.c_str());
	};
	auto HW_FluMode = [this](int NotifyCode, string key, string context)//FluMode
	{
		m_nFluMode = atoi(context.c_str());
		SetFluMode((nsGEN::AttrKey::GENERATOR_FLUMode)m_nFluMode);
	};
	auto HW_ABSMode = [this](int NotifyCode, string key, string context)//ABSMode
	{
		m_nABSMode = atoi(context.c_str());
		SetABSMode((nsGEN::AttrKey::GENERATOR_ABSStatus)m_nABSMode);
	};
	auto HW_ABSCurve = [this](int NotifyCode, string key, string context)//ABSCurve
	{
		m_nABSCurve = atoi(context.c_str());
		m_Edit_FluABSCurve.SetWindowText(context.c_str());
	};
	auto HW_DoseLever = [this](int NotifyCode, string key, string context)//DoseLever
	{
		m_nDoseLever = atoi(context.c_str());
		m_Edit_FluDoseLever.SetWindowText(context.c_str());
	};
	auto HW_CurrEXI = [this](int NotifyCode, string key, string context)//CurrEXI
	{
		m_nCurrEXI = atoi(context.c_str());
		m_Edit_FluCurrEXI.SetWindowText(context.c_str());
	};
	auto HW_TargetEXI = [this](int NotifyCode, string key, string context)//TargetEXI
	{
		m_nTarEXI = atoi(context.c_str());
		m_Edit_FluTarEXI.SetWindowText(context.c_str());
	};
	auto HW_MAG = [this](int NotifyCode, string key, string context)//MAG
	{
		m_nMag = atoi(context.c_str());
		m_Edit_FluMag.SetWindowText(context.c_str());
	};
	auto HW_HandSwitch = [this](int NotifyCode, string key, string context)//HandSwitch
	{
		m_nHandSwitch = atoi(context.c_str());
		m_Edit_FluHandSwitch.SetWindowText(context.c_str());
	};
	auto HW_FootSwitch = [this](int NotifyCode, string key, string context)//FootSwitch
	{
		m_nFootSwitch = atoi(context.c_str());
		m_Edit_FluFootSwitch.SetWindowText(context.c_str());
	};
	auto HW_FluPre = [this](int NotifyCode, string key, string context)//FluPre
	{
		m_nFluPre = atoi(context.c_str());
		m_Edit_FluPre.SetWindowText(context.c_str());
	};
	auto HW_FluEXP = [this](int NotifyCode, string key, string context)//FluEXP
	{
		m_nFluEXP = atoi(context.c_str());
		m_Edit_FluEXP.SetWindowText(context.c_str());
	};
	auto HW_FluIntTimer = [this](int NotifyCode, string key, string context)//FluIntTimer
	{
		m_nFluIntTimer = atoi(context.c_str());
		m_Edit_FluIntTimer.SetWindowText(context.c_str());
	};
	auto HW_FluAccTimer = [this](int NotifyCode, string key, string context)//FluAccTimer
	{
		m_nFluAccTimer = atoi(context.c_str());
		m_Edit_FluAccTimer.SetWindowText(context.c_str());
	};

	//Generator
	m_mapFrame["UnKnown"] = tFrameMapItem(HW_UNKNOWN);
	//Rad
	m_mapFrame[nsGEN::AttrKey::KV] = tFrameMapItem(HW_KV);
	m_mapFrame[nsGEN::AttrKey::MA] = tFrameMapItem(HW_MA);
	m_mapFrame[nsGEN::AttrKey::MS] = tFrameMapItem(HW_MS);
	m_mapFrame[nsGEN::AttrKey::MAS] = tFrameMapItem(HW_MAS);
	m_mapFrame[nsGEN::AttrKey::FOCUS] = tFrameMapItem(HW_FOCUS);
	m_mapFrame[nsGEN::AttrKey::FOCUSSIZE] = tFrameMapItem(HW_FOCUSSIZE);
	m_mapFrame[nsGEN::AttrKey::WORKSTATION] = tFrameMapItem(HW_WORKSTATION);
	m_mapFrame[nsGEN::AttrKey::TECHMODE] = tFrameMapItem(HW_TECHMODE);
	m_mapFrame[nsGEN::AttrKey::AECDENSITY] = tFrameMapItem(HW_AECDENSITY);
	m_mapFrame[nsGEN::AttrKey::AECFIELD] = tFrameMapItem(HW_AECFIELD);
	m_mapFrame[nsGEN::AttrKey::AECFILM] = tFrameMapItem(HW_AECFILM);
	m_mapFrame[nsGEN::AttrKey::TUBEHEAT] = tFrameMapItem(HW_TUBEHEAT);
	m_mapFrame[nsGEN::AttrKey::POSTKV] = tFrameMapItem(HW_POSTKV);
	m_mapFrame[nsGEN::AttrKey::POSTMA] = tFrameMapItem(HW_POSTMA);
	m_mapFrame[nsGEN::AttrKey::POSTMS] = tFrameMapItem(HW_POSTMS);
	m_mapFrame[nsGEN::AttrKey::POSTMAS] = tFrameMapItem(HW_POSTMAS);
	m_mapFrame[nsGEN::AttrKey::GENSYNSTATE] = tFrameMapItem(HW_GENSYNSTATE);
	m_mapFrame[nsGEN::AttrKey::GENSTATE] = tFrameMapItem(HW_GENSTATE);
	m_mapFrame[nsGEN::AttrKey::EXPMODE] = tFrameMapItem(HW_EXPMODE);
	m_mapFrame[nsGEN::AttrKey::EXAMMODE] = tFrameMapItem(HW_EXAMMODE);
	m_mapFrame[nsGEN::AttrKey::TUBETARGETMATERIAL] = tFrameMapItem(HW_TUBETARGETMATERIAL);
	m_mapFrame[nsGEN::AttrKey::TUBEANGLE] = tFrameMapItem(HW_TUBEANGLE);
	//Flu
	m_mapFrame[nsGEN::AttrKey::FLUKV] = tFrameMapItem(HW_FluKV);
	m_mapFrame[nsGEN::AttrKey::FLUMA] = tFrameMapItem(HW_FluMA);
	m_mapFrame[nsGEN::AttrKey::FLUPPS] = tFrameMapItem(HW_PPS);
	m_mapFrame[nsGEN::AttrKey::FLUpulseWidth] = tFrameMapItem(HW_PluseWidth);
	m_mapFrame[nsGEN::AttrKey::FLUMode] = tFrameMapItem(HW_FluMode);
	m_mapFrame[nsGEN::AttrKey::FLUABSStatus] = tFrameMapItem(HW_ABSMode);
	m_mapFrame[nsGEN::AttrKey::FLUCurve] = tFrameMapItem(HW_ABSCurve);
	m_mapFrame[nsGEN::AttrKey::FLUDoseLevel] = tFrameMapItem(HW_DoseLever);
	m_mapFrame["CurrentEXI"] = tFrameMapItem(HW_CurrEXI);
	m_mapFrame["TargetEXI"] = tFrameMapItem(HW_TargetEXI);
	m_mapFrame[nsGEN::AttrKey::FLUMag] = tFrameMapItem(HW_MAG);
	m_mapFrame[nsGEN::AttrKey::GENHANDSWITCH] = tFrameMapItem(HW_HandSwitch);
	m_mapFrame[nsGEN::AttrKey::GENFOOTSWITCH] = tFrameMapItem(HW_FootSwitch);
	m_mapFrame["FluPre"] = tFrameMapItem(HW_FluPre);
	m_mapFrame["FluEXP"] = tFrameMapItem(HW_FluEXP);
	m_mapFrame[nsGEN::AttrKey::FLUIntTime] = tFrameMapItem(HW_FluIntTimer);
	m_mapFrame[nsGEN::AttrKey::FLUAccTime] = tFrameMapItem(HW_FluAccTimer);
}

void CGeneratorDlg::SetFocus(nsGEN::AttrKey::FOCUS_TYPE type)
{
	CString log;
	m_radio_fo_small.SetCheck(FALSE);
	m_radio_fo_large.SetCheck(FALSE);
	switch (type)
	{
		case nsGEN::AttrKey::FOCUS_SMALL:
			m_radio_fo_small.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::FOCUS_LARGE:
			m_radio_fo_large.SetCheck(TRUE);
			break;
		default:
			log.Format("(GEN)- can not deal with Focus[%d] \n", (int)type);
			mLog::Warn(log);
			ToolsDlgLog(log);
			break;
	}
}
void CGeneratorDlg::SetTechMode(nsGEN::AttrKey::TECHMODE_TYPE type)
{
	CString log;
	m_radio_et_noAEC2P.SetCheck(FALSE);
	m_radio_et_noAEC3P.SetCheck(FALSE);
	m_radio_et_noAECMASMA.SetCheck(FALSE);
	m_radio_et_AEC1P.SetCheck(FALSE);
	m_radio_et_AEC2P.SetCheck(FALSE);
	m_radio_et_AEC3P.SetCheck(FALSE);
	m_radio_et_AECMASMA.SetCheck(FALSE);
	switch (type)
	{
		case nsGEN::AttrKey::TECHMODE_NOAEC_3P:
			m_radio_et_noAEC3P.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::TECHMODE_NOAEC_2P:
			m_radio_et_noAEC2P.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::TECHMODE_AEC_3P:
			m_radio_et_AEC3P.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::TECHMODE_AEC_2P:
			m_radio_et_AEC2P.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::TECHMODE_AEC_1P:
			m_radio_et_AEC1P.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::TECHMODE_AEC_ReduceMA:
			break;
		case nsGEN::AttrKey::TECHMODE_NOAEC_MAS_MA:
			m_radio_et_noAECMASMA.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::TECHMODE_AEC_MAS_MA:
			m_radio_et_AECMASMA.SetCheck(TRUE);
			break;
		default:
			log.Format("(GEN)- can not deal with TechMode[%d] \n", (int)type);
			mLog::Warn(log);
			ToolsDlgLog(log);
			break;
	}
	ShowPageElements(FALSE, TRUE, FALSE, type);
}
void CGeneratorDlg::SetWorkStation(nsGEN::AttrKey::GENWS_TYPE type)
{
	CString log;
	m_radio_ws_table.SetCheck(FALSE);
	m_radio_ws_wall.SetCheck(FALSE);
	m_radio_ws_conventional.SetCheck(FALSE);
	m_radio_ws_mobile.SetCheck(FALSE);
	m_radio_ws_free.SetCheck(FALSE);
	m_radio_ws_tomo.SetCheck(FALSE);
	switch (type)
	{
		case nsGEN::AttrKey::TABLE:
			m_radio_ws_table.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::WALL:
			m_radio_ws_wall.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::CONVENTIONAL:
			m_radio_ws_conventional.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::MOBILE:
			m_radio_ws_mobile.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::FREE_WALL:
			m_radio_ws_free.SetCheck(TRUE);
			break;
		case nsGEN::AttrKey::TOMO:
			m_radio_ws_tomo.SetCheck(TRUE);
			break;
		default:
			log.Format("(GEN)- can not deal with WorkStation[%d] \n", (int)type);
			mLog::Warn(log);
			ToolsDlgLog(log);
			break;
	}
}
void CGeneratorDlg::SetGenSynStatus(nsGEN::AttrKey::GENERATOR_SYNC type)
{
	CString log;
	switch (type)
	{
		case nsGEN::AttrKey::GENERATOR_SYNC_ERR:
		{
			m_Edit_gensynstate.SetWindowText("err");
		}break;
		case nsGEN::AttrKey::GENERATOR_RAD_OFF:
		{
			m_Edit_gensynstate.SetWindowText("PR0");
		}break;
		case nsGEN::AttrKey::GENERATOR_RAD_PREPARE:
		{
			m_Edit_gensynstate.SetWindowText("PR1");
		}break;
		case nsGEN::AttrKey::GENERATOR_RAD_READY:
		{
			m_Edit_gensynstate.SetWindowText("PR2");
		}break;
		case nsGEN::AttrKey::GENERATOR_RAD_XRAYON:
		{
			m_Edit_gensynstate.SetWindowText("XR1");
		}break;
		case nsGEN::AttrKey::GENERATOR_RAD_XRAYOFF:
		{
			m_Edit_gensynstate.SetWindowText("XR0");
		}break;
		default:
			log.Format("%d", (int)type);
			m_Edit_gensynstate.SetWindowText(log);
			log.Format("(GEN)- can not deal with synstate[%d] \n", (int)type);
			mLog::Warn(log);
			ToolsDlgLog(log);
			break;
	}
}
void CGeneratorDlg::SetGenStatus(nsGEN::AttrKey::GENERATOR_STATUS type)
{
	CString log;
	switch (type)
	{
		case nsGEN::AttrKey::GENERATOR_STATUS_SHUTDOWN:
		{
			m_Edit_genstate.SetWindowText("shutdown");
		}break;
		case nsGEN::AttrKey::GENERATOR_STATUS_INIT:
		{
			m_Edit_genstate.SetWindowText("init");
		}break;
		case nsGEN::AttrKey::GENERATOR_STATUS_SLEEP:
		{
			m_Edit_genstate.SetWindowText("sleep");
		}break;
		case nsGEN::AttrKey::GENERATOR_STATUS_CHARGING:
		{
			m_Edit_genstate.SetWindowText("charging");
		}break;
		case nsGEN::AttrKey::GENERATOR_STATUS_STANDBY:
		{
			m_Edit_genstate.SetWindowText("standby");
		}break;
		case nsGEN::AttrKey::GENERATOR_STATUS_EXP:
		{
			m_Edit_genstate.SetWindowText("exposure");
		}break;
		case nsGEN::AttrKey::GENERATOR_STATUS_ERROR:
		{
			m_Edit_genstate.SetWindowText("error");
		}break;
		default:
			log.Format("(GEN)- can not deal with unitstate[%d] \n", (int)type);
			mLog::Warn(log);
			ToolsDlgLog(log);
			break;
	}
}
void CGeneratorDlg::SetFluMode(nsGEN::AttrKey::GENERATOR_FLUMode type)
{
	CString log;
	m_radio_FluMode_Not.SetCheck(FALSE);
	m_radio_FluMode_CF.SetCheck(FALSE);
	m_radio_FluMode_PF.SetCheck(FALSE);
	m_radio_FluMode_HCF.SetCheck(FALSE);
	m_radio_FluMode_HPF.SetCheck(FALSE);
	switch (type)
	{
		case nsGEN::AttrKey::GENERATOR_FLMODE_NOTFLU:
		{
			m_radio_FluMode_Not.SetCheck(TRUE);
		}break;
		case nsGEN::AttrKey::GENERATOR_FLMODE_CF:
		{
			m_radio_FluMode_CF.SetCheck(TRUE);
		}break;
		case nsGEN::AttrKey::GENERATOR_FLMODE_PF:
		{
			m_radio_FluMode_PF.SetCheck(TRUE);
		}break;
		case nsGEN::AttrKey::GENERATOR_FLMODE_HCF:
		{
			m_radio_FluMode_HCF.SetCheck(TRUE);
		}break;
		case nsGEN::AttrKey::GENERATOR_FLMODE_HPF:
		{
			m_radio_FluMode_HPF.SetCheck(TRUE);
		}break;
		default:
			log.Format("(GEN)- can not deal with FluMode[%d] \n", (int)type);
			mLog::Warn(log);
			ToolsDlgLog(log);
			break;
	}
}
void CGeneratorDlg::SetABSMode(nsGEN::AttrKey::GENERATOR_ABSStatus type)
{
	CString log;
	m_radio_ABS_OFF.SetCheck(FALSE);
	m_radio_ABS_OnKV.SetCheck(FALSE);
	m_radio_ABS_OnKVMA.SetCheck(FALSE);
	switch (type)
	{
		case nsGEN::AttrKey::GENERATOR_ABS_OFF:
		{
			m_radio_ABS_OFF.SetCheck(TRUE);
		}break;
		case nsGEN::AttrKey::GENERATOR_ABS_ON_KV:
		{
			m_radio_ABS_OnKV.SetCheck(TRUE);
		}break;
		case nsGEN::AttrKey::GENERATOR_ABS_ON_KVMA:
		{
			m_radio_ABS_OnKVMA.SetCheck(TRUE);
		}break;
		default:
			log.Format("(GEN)- can not deal with ABSMode[%d] \n", (int)type);
			mLog::Warn(log);
			ToolsDlgLog(log);
			break;
	}
}

void CGeneratorDlg::InitPageElements(bool act)
{
	if (act)
	{
		ShowPageElements(FALSE, TRUE, FALSE, -1);
		SetMagMap();
		GetInitData();
	}
	else
	{
		ShowPageElements(TRUE, FALSE, TRUE, -1);
	}
}
//设置窗口元素显示
void CGeneratorDlg::ShowPageElements(bool init, bool exit, bool cfg, int pointMode, bool general)
{
	__super::ShowPageElements(init, exit, cfg, general);

	bool kv = false;
	bool mas = false;
	bool ma = false;
	bool ms = false;
	bool aec = false;
	switch (pointMode)
	{
		case nsGEN::AttrKey::TECHMODE_NOAEC_3P:
		{
			kv = exit;
			mas = false;
			ma = exit;
			ms = exit;
			aec = false;
		}break;
		case nsGEN::AttrKey::TECHMODE_NOAEC_2P:
		{
			kv = exit;
			mas = exit;
			ma = false;
			ms = false;
			aec = false;
		}break;
		case nsGEN::AttrKey::TECHMODE_AEC_3P:
		{
			kv = exit;
			mas = false;
			ma = exit;
			ms = exit;
			aec = exit;
		}break;
		case nsGEN::AttrKey::TECHMODE_AEC_2P:
		{
			kv = exit;
			mas = exit;
			ma = false;
			ms = false;
			aec = exit;
		}break;
		case nsGEN::AttrKey::TECHMODE_AEC_1P:
		{
			kv = exit;
			mas = false;
			ma = false;
			ms = false;
			aec = exit;
		}break;
		case nsGEN::AttrKey::TECHMODE_AEC_ReduceMA:
		{
			kv = exit;
			mas = false;
			ma = exit;
			ms = false;
			aec = false;
		}break;
		case nsGEN::AttrKey::TECHMODE_NOAEC_MAS_MA:
		{
			kv = exit;
			mas = exit;
			ma = exit;
			ms = false;
			aec = false;
		}break;
		case nsGEN::AttrKey::TECHMODE_AEC_MAS_MA:
		{
			kv = exit;
			mas = exit;
			ma = exit;
			ms = false;
			aec = exit;
		}break;
		default:
			break;
	}
	
	//KV
	GetDlgItem(IDC_BUTTON4)->EnableWindow(kv);
	GetDlgItem(IDC_BUTTON5)->EnableWindow(kv);
	GetDlgItem(IDC_EDIT1)->EnableWindow(kv);
	GetDlgItem(IDC_BUTTON6)->EnableWindow(kv);
	//MAS
	GetDlgItem(IDC_BUTTON7)->EnableWindow(mas);
	GetDlgItem(IDC_BUTTON8)->EnableWindow(mas);
	GetDlgItem(IDC_EDIT2)->EnableWindow(mas);
	GetDlgItem(IDC_BUTTON9)->EnableWindow(mas);
	//MA
	GetDlgItem(IDC_BUTTON10)->EnableWindow(ma);
	GetDlgItem(IDC_BUTTON11)->EnableWindow(ma);
	GetDlgItem(IDC_EDIT3)->EnableWindow(ma);
	GetDlgItem(IDC_BUTTON12)->EnableWindow(ma);
	//MS
	GetDlgItem(IDC_BUTTON13)->EnableWindow(ms);
	GetDlgItem(IDC_BUTTON14)->EnableWindow(ms);
	GetDlgItem(IDC_EDIT4)->EnableWindow(ms);
	GetDlgItem(IDC_BUTTON15)->EnableWindow(ms);
	//AEC
	GetDlgItem(IDC_BUTTON16)->EnableWindow(aec);
	GetDlgItem(IDC_BUTTON17)->EnableWindow(aec);
	GetDlgItem(IDC_EDIT5)->EnableWindow(aec);
	GetDlgItem(IDC_BUTTON18)->EnableWindow(aec);
	GetDlgItem(IDC_BUTTON19)->EnableWindow(aec);
	GetDlgItem(IDC_EDIT6)->EnableWindow(aec);
	GetDlgItem(IDC_BUTTON20)->EnableWindow(aec);
	GetDlgItem(IDC_EDIT7)->EnableWindow(aec);
	//focus
	GetDlgItem(IDC_RADIO1)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO2)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT8)->EnableWindow(aec);
	//tech
	GetDlgItem(IDC_RADIO3)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO4)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO5)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO6)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO7)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO8)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO9)->EnableWindow(exit);
	//ws
	GetDlgItem(IDC_RADIO10)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO11)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO12)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO13)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO14)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO15)->EnableWindow(exit);
	//expEnable
	GetDlgItem(IDC_BUTTON21)->EnableWindow(exit);
	//reset
	GetDlgItem(IDC_BUTTON22)->EnableWindow(exit);
	//APR
	GetDlgItem(IDC_BUTTON23)->EnableWindow(exit);
	//expMode
	GetDlgItem(IDC_BUTTON25)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT9)->EnableWindow(exit);
	//examMode
	GetDlgItem(IDC_BUTTON26)->EnableWindow(general);
	GetDlgItem(IDC_EDIT10)->EnableWindow(general);
	//devStatus
	GetDlgItem(IDC_BUTTON27)->EnableWindow(general);
	GetDlgItem(IDC_EDIT11)->EnableWindow(general);
	//expStatus
	GetDlgItem(IDC_BUTTON28)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT12)->EnableWindow(exit);
	//postKV
	GetDlgItem(IDC_BUTTON29)->EnableWindow(general);
	GetDlgItem(IDC_EDIT13)->EnableWindow(general);
	//postMA
	GetDlgItem(IDC_BUTTON30)->EnableWindow(general);
	GetDlgItem(IDC_EDIT14)->EnableWindow(general);
	//postMAS
	GetDlgItem(IDC_BUTTON31)->EnableWindow(general);
	GetDlgItem(IDC_EDIT15)->EnableWindow(general);
	//postMS
	GetDlgItem(IDC_BUTTON32)->EnableWindow(general);
	GetDlgItem(IDC_EDIT16)->EnableWindow(general);
	//tubeHeat
	GetDlgItem(IDC_BUTTON33)->EnableWindow(general);
	GetDlgItem(IDC_EDIT17)->EnableWindow(general);
	//tubeTarMat
	GetDlgItem(IDC_BUTTON34)->EnableWindow(general);
	GetDlgItem(IDC_EDIT18)->EnableWindow(general);
	//tubeAngle
	GetDlgItem(IDC_BUTTON35)->EnableWindow(general);
	GetDlgItem(IDC_EDIT19)->EnableWindow(general);
	//点片帧率
	GetDlgItem(IDC_BUTTON36)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT20)->EnableWindow(exit);
	//设置曝光状态
	GetDlgItem(IDC_EDIT21)->EnableWindow(exit);

	//KV
	GetDlgItem(IDC_BUTTON37)->EnableWindow(exit);
	GetDlgItem(IDC_BUTTON38)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT22)->EnableWindow(exit);
	GetDlgItem(IDC_BUTTON39)->EnableWindow(exit);
	//MAS
	GetDlgItem(IDC_BUTTON40)->EnableWindow(exit);
	GetDlgItem(IDC_BUTTON41)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT23)->EnableWindow(exit);
	GetDlgItem(IDC_BUTTON42)->EnableWindow(exit);
	//PPS
	GetDlgItem(IDC_BUTTON43)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT24)->EnableWindow(exit);
	//PluseWidth
	GetDlgItem(IDC_BUTTON44)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT25)->EnableWindow(exit);
	//FluMode
	GetDlgItem(IDC_RADIO19)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO20)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO21)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO22)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO23)->EnableWindow(exit);
	//ABSMode
	GetDlgItem(IDC_RADIO16)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO17)->EnableWindow(exit);
	GetDlgItem(IDC_RADIO18)->EnableWindow(exit);
	//ABSCurve
	GetDlgItem(IDC_BUTTON45)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT26)->EnableWindow(exit);
	//DoseLever
	GetDlgItem(IDC_BUTTON46)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT27)->EnableWindow(exit);
	//SetCurrEXI
	GetDlgItem(IDC_BUTTON47)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT28)->EnableWindow(exit);
	//TargetEXI
	GetDlgItem(IDC_BUTTON48)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT29)->EnableWindow(exit);
	//SetMAG
	GetDlgItem(IDC_BUTTON49)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT30)->EnableWindow(exit);
	//ResetTime
	GetDlgItem(IDC_BUTTON50)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT31)->EnableWindow(exit);
	//SetAPF
	GetDlgItem(IDC_BUTTON52)->EnableWindow(exit);
	//FluPre
	GetDlgItem(IDC_BUTTON53)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT33)->EnableWindow(exit);
	//FluEXP
	GetDlgItem(IDC_BUTTON54)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT34)->EnableWindow(exit);
	//FluIntTimer
	GetDlgItem(IDC_BUTTON55)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT35)->EnableWindow(exit);
	//FluAccTimer
	GetDlgItem(IDC_BUTTON56)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT36)->EnableWindow(exit);
	//HandSwitch
	GetDlgItem(IDC_BUTTON57)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT37)->EnableWindow(exit);
	//FootSwitch
	GetDlgItem(IDC_BUTTON58)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT38)->EnableWindow(exit);

	//test
	GetDlgItem(IDC_BUTTON59)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT39)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT40)->EnableWindow(exit);
	GetDlgItem(IDC_BUTTON60)->EnableWindow(exit);
	GetDlgItem(IDC_EDIT41)->EnableWindow(exit);

}

//设置悬停提示
void CGeneratorDlg::SetToolTipsMsgMap()
{
	m_Ttc.AddTool(GetDlgItem(IDC_EDIT39), _T("Notify Key"));
	m_Ttc.AddTool(GetDlgItem(IDC_EDIT40), _T("Notify Value"));
}


//选择配置
void CGeneratorDlg::OnBnClickedButton3()
{
	CString log;
	nsCFG::CConfigDlg dlgcfg(Dev_Generator, 
							 m_strCfgLib, 
							 m_strCfgFile);
	dlgcfg.DoModal();
	
	if (m_strCfgFile.empty())
	{
		log.Format("(GEN)- GEN m_strCfgFile is empty");
		mLog::Warn(log);
		ToolsDlgLog(log);
	}
	else
	{
		ShowPageElements(TRUE, FALSE, TRUE, -1);
	}
}

//初始化
void CGeneratorDlg::OnBnClickedButton1()
{
	CString log;
	if(m_pDriver == nullptr)
		if (!m_pDevice)
		{
			if (this->AppInitial(true))
			{
				ShowPageElements(FALSE, TRUE, FALSE, -1);
				SetMagMap();
				GetInitData();
				mLog::Debug("(GEN)- GEN Initial success");
			}
			else
			{
				log.Format("(GEN)- GEN Initial fail");
				mLog::Error(log);
				ToolsDlgLog(log);
			}
		}
		else
		{
			log.Format("(GEN)- m_pDevice not empty");
			mLog::Warn(log);
			ToolsDlgLog(log);
		}
	else
	{
		log.Format("(GEN)- m_pDriver not empty");
		mLog::Warn(log);
		ToolsDlgLog(log);
	}
}

//退出
void CGeneratorDlg::OnBnClickedButton2()
{
	if (AppInitial(false))
	{
		ShowPageElements(TRUE, FALSE, TRUE, -1);
	}
}

//set KV
void CGeneratorDlg::OnBnClickedButton4()
{
	DevActionValue(nsGEN::ActionKey::SetValue_KV, { to_string(m_nKV) });
}
//KV-
void CGeneratorDlg::OnBnClickedButton5()
{
	DevAction(nsGEN::ActionKey::DecParam_KV);
}
//KV+
void CGeneratorDlg::OnBnClickedButton6()
{
	DevAction(nsGEN::ActionKey::IncParam_KV);
}
//set MAS
void CGeneratorDlg::OnBnClickedButton7()
{
	DevActionValue(nsGEN::ActionKey::SetValue_MAS, { to_string(m_fMAS) });
}
//MAS-
void CGeneratorDlg::OnBnClickedButton8()
{
	DevAction(nsGEN::ActionKey::DecParam_MAS);
}
//MAS+
void CGeneratorDlg::OnBnClickedButton9()
{
	DevAction(nsGEN::ActionKey::IncParam_MAS);
}
//set MA
void CGeneratorDlg::OnBnClickedButton10()
{
	DevActionValue(nsGEN::ActionKey::SetValue_MA, { to_string(m_fMA) });
}
//MA-
void CGeneratorDlg::OnBnClickedButton11()
{
	DevAction(nsGEN::ActionKey::DecParam_MA);
}
//MA+
void CGeneratorDlg::OnBnClickedButton12()
{
	DevAction(nsGEN::ActionKey::IncParam_MA);
}
//set MS
void CGeneratorDlg::OnBnClickedButton13()
{
	DevActionValue(nsGEN::ActionKey::SetValue_MS, { to_string(m_fMS) });
}
//MS-
void CGeneratorDlg::OnBnClickedButton14()
{
	DevAction(nsGEN::ActionKey::DecParam_MS);
}
//MS+
void CGeneratorDlg::OnBnClickedButton15()
{
	DevAction(nsGEN::ActionKey::IncParam_MS);
}
//set Density
void CGeneratorDlg::OnBnClickedButton16()
{
	DevActionValue(nsGEN::ActionKey::SetValue_AECDENSITY, { to_string(m_nAECDensity) });
}
//Density-
void CGeneratorDlg::OnBnClickedButton17()
{
	DevAction(nsGEN::ActionKey::DecParam_AECDENSITY);
}
//Density+
void CGeneratorDlg::OnBnClickedButton18()
{
	DevAction(nsGEN::ActionKey::IncParam_AECDENSITY);
}
//set Field
void CGeneratorDlg::OnBnClickedButton19()
{
	DevActionValue(nsGEN::ActionKey::SetValue_AECFIELD, { to_string(m_nAECField) });
}
//set Film
void CGeneratorDlg::OnBnClickedButton20()
{
	DevActionValue(nsGEN::ActionKey::SetValue_AECFILM, { to_string(m_nAECFilm) });
}
//Exp enable
void CGeneratorDlg::OnBnClickedButton21()
{
	if (m_bExpEnable)
	{
		GetDlgItem(IDC_BUTTON21)->SetWindowText("ExpDisable");
		m_bExpEnable = false;
		DevAction(nsGEN::ActionKey::SetExpDisable);
	}
	else
	{
		m_bExpEnable = true;
		GetDlgItem(IDC_BUTTON21)->SetWindowText("ExpEnable");
		DevAction(nsGEN::ActionKey::SetExpEnable);
	}
}
//Reset
void CGeneratorDlg::OnBnClickedButton22()
{
	DevAction(nsGEN::ActionKey::Reset);
}
//SetAPR
void CGeneratorDlg::OnBnClickedButton23()
{
	map<string, string> param;
	param[nsGEN::AttrKey::FOCUS] = to_string(m_nFO);
	param[nsGEN::AttrKey::TECHMODE] = to_string(m_nET);
	param[nsGEN::AttrKey::AECFILM] = "1";
	param[nsGEN::AttrKey::AECFIELD] = "1";
	param[nsGEN::AttrKey::AECDENSITY] = to_string(m_nAECDensity);
	param[nsGEN::AttrKey::KV] = to_string(m_nKV);
	param[nsGEN::AttrKey::MA] = to_string(m_fMA);
	param[nsGEN::AttrKey::MS] = to_string(m_fMS);
	param[nsGEN::AttrKey::MAS] = to_string(m_fMAS);
	param[nsGEN::AttrKey::WORKSTATION] = to_string(m_nWS);
	DevActionKeyValue(nsGEN::ActionKey::SetAPR, param, true);
}
//软同步曝光
void CGeneratorDlg::OnBnClickedButton28()
{
	ToolsDlgLog("send soft_syn EXP allow");
	CString tempStr;
	m_Edit_genEXPstate.GetWindowText(tempStr);
	string param = tempStr.GetBuffer();
	DevActionValue(nsGEN::ActionKey::SetGeneratortoSyncStatus, { param });
}
//设置曝光模式
void CGeneratorDlg::OnBnClickedButton25()
{
	char data[20]{0};
	strncpy_s(data, m_bExpMode.c_str(),19);
	DevActionValue(nsGEN::ActionKey::SetExpMode, { data });
}
//设置点片帧率
void CGeneratorDlg::OnBnClickedButton36()
{
	DevActionValue(nsGEN::ActionKey::SetFrameRate, { to_string(m_bRADFrameRate) });
}
//SetFluKV
void CGeneratorDlg::OnBnClickedButton37()
{
	DevActionValue(nsGEN::ActionKey::SetValue_FluKV, { to_string(m_nFluKV) });
}
//FluKV-
void CGeneratorDlg::OnBnClickedButton38()
{
	DevAction(nsGEN::ActionKey::DecParam_FluKV);
}
//FluKV+
void CGeneratorDlg::OnBnClickedButton39()
{
	DevAction(nsGEN::ActionKey::IncParam_FluKV);
}
//SetFluMA
void CGeneratorDlg::OnBnClickedButton40()
{
	DevActionValue(nsGEN::ActionKey::SetValue_FluMA, { to_string(m_fFluMA) });
}
//FluMA-
void CGeneratorDlg::OnBnClickedButton41()
{
	DevAction(nsGEN::ActionKey::DecParam_FluMA);
}
//FluMA+
void CGeneratorDlg::OnBnClickedButton42()
{
	DevAction(nsGEN::ActionKey::IncParam_FluMA);
}
//SetPPS
void CGeneratorDlg::OnBnClickedButton43()
{
	DevActionValue(nsGEN::ActionKey::SetValue_PPS, { to_string(m_fPPS) });
}
//PluseWidth
void CGeneratorDlg::OnBnClickedButton44()
{
	DevActionValue(nsGEN::ActionKey::SetValue_PluseWidth, { to_string(m_nPluseWidth) });
}
//ABSCurve
void CGeneratorDlg::OnBnClickedButton45()
{
	DevActionValue(nsGEN::ActionKey::SetValue_ABSCurve, { to_string(m_nABSCurve) });
}
//DoseLever
void CGeneratorDlg::OnBnClickedButton46()
{
	DevActionValue(nsGEN::ActionKey::SetValue_FluDoseLever, { to_string(m_nDoseLever) });
}
//SetCurrEXI
void CGeneratorDlg::OnBnClickedButton47()
{
	DevActionValue(nsGEN::ActionKey::SetFrameRate, { to_string(m_nCurrEXI) });
}
//TargetEXI
void CGeneratorDlg::OnBnClickedButton48()
{
	DevActionValue("SetCurrentEXI", { to_string(m_nTarEXI) });
}
//SetMAG
void CGeneratorDlg::OnBnClickedButton49()
{
	DevActionValue(nsGEN::ActionKey::SetValue_FluMAG, { to_string(m_nMag) });
}
//ResetTime
void CGeneratorDlg::OnBnClickedButton50()
{
	DevActionValue(nsGEN::ActionKey::SetFrameRate, { to_string(m_nResetTime) });
}
//SetAPF
void CGeneratorDlg::OnBnClickedButton52()
{
	map<string, string> param;
	param[nsGEN::AttrKey::WORKSTATION] = to_string(m_nWS);
	param[nsGEN::AttrKey::FLUMode] = to_string(m_nFluMode);
	param[nsGEN::AttrKey::FLUABSStatus] = to_string(m_nABSMode);
	param[nsGEN::AttrKey::FLUDoseLevel] = to_string(m_nDoseLever);
	param[nsGEN::AttrKey::FLUKV] = to_string(m_nFluKV);
	param[nsGEN::AttrKey::FLUMA] = to_string(m_fFluMA);
	param[nsGEN::AttrKey::FLUPPS] = to_string(m_fPPS);
	DevActionKeyValue(nsGEN::ActionKey::SetValue_APF, param, true);
}
//FluPre
void CGeneratorDlg::OnBnClickedButton53()
{
	DevActionValue(nsGEN::ActionKey::SetFrameRate, { to_string(m_nFluPre) });
}
//FluEXP
void CGeneratorDlg::OnBnClickedButton54()
{
	DevActionValue(nsGEN::ActionKey::SetFrameRate, { to_string(m_nFluEXP) });
}
//DirectlyNotify
void CGeneratorDlg::OnBnClickedButton59()
{
	CString tempStrKey, tempStrValue;
	m_Edit_DirectlyNotifyKey.GetWindowText(tempStrKey);
	m_Edit_DirectlyNotifyValue.GetWindowText(tempStrValue);
	map<string, string> param;
	param["NotifyKey"] = tempStrKey.GetString();
	param["NotifyValue"] = tempStrValue.GetString();
	DevActionKeyValue("DirectlyNotify", param);
}
//DirectlyCMD
void CGeneratorDlg::OnBnClickedButton60()
{
	CString tempStrCMD;
	m_Edit_DirectlyCMD.GetWindowText(tempStrCMD);
	map<string, string> param;
	param["CMDText"] = tempStrCMD.GetString();
	DevActionKeyValue("DirectlyCMD", param);
}

//select fcus small
void CGeneratorDlg::OnBnClickedRadio1()
{
	m_nFO = nsGEN::AttrKey::FOCUS_TYPE::FOCUS_SMALL;
	DevActionValue(nsGEN::ActionKey::SetValue_FOCUS, { to_string(m_nFO) });
}
//select fcus large
void CGeneratorDlg::OnBnClickedRadio2()
{
	m_nFO = nsGEN::AttrKey::FOCUS_TYPE::FOCUS_LARGE;
	DevActionValue(nsGEN::ActionKey::SetValue_FOCUS, { to_string(m_nFO) });
}
//NoAEC2P
void CGeneratorDlg::OnBnClickedRadio3()
{
	m_nET = nsGEN::AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_2P;
	DevActionValue(nsGEN::ActionKey::SetValue_TECHMODE, { to_string(m_nET) });
	ShowPageElements(FALSE, TRUE, FALSE, m_nET);
}
//NoAEC3P
void CGeneratorDlg::OnBnClickedRadio4()
{
	m_nET = nsGEN::AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_3P;
	DevActionValue(nsGEN::ActionKey::SetValue_TECHMODE, { to_string(m_nET) });
	ShowPageElements(FALSE, TRUE, FALSE, m_nET);
}
//NoAECMAS+MA
void CGeneratorDlg::OnBnClickedRadio8()
{
	m_nET = nsGEN::AttrKey::TECHMODE_TYPE::TECHMODE_NOAEC_MAS_MA;
	DevActionValue(nsGEN::ActionKey::SetValue_TECHMODE, { to_string(m_nET) });
	ShowPageElements(FALSE, TRUE, FALSE, m_nET);
}
//AEC1P
void CGeneratorDlg::OnBnClickedRadio5()
{
	m_nET = nsGEN::AttrKey::TECHMODE_TYPE::TECHMODE_AEC_1P;
	DevActionValue(nsGEN::ActionKey::SetValue_TECHMODE, { to_string(m_nET) });
	ShowPageElements(FALSE, TRUE, FALSE, m_nET);
}
//AEC2P
void CGeneratorDlg::OnBnClickedRadio6()
{
	m_nET = nsGEN::AttrKey::TECHMODE_TYPE::TECHMODE_AEC_2P;
	DevActionValue(nsGEN::ActionKey::SetValue_TECHMODE, { to_string(m_nET) });
	ShowPageElements(FALSE, TRUE, FALSE, m_nET);
}
//AEC3P
void CGeneratorDlg::OnBnClickedRadio7()
{
	m_nET = nsGEN::AttrKey::TECHMODE_TYPE::TECHMODE_AEC_3P;
	DevActionValue(nsGEN::ActionKey::SetValue_TECHMODE, { to_string(m_nET) });
	ShowPageElements(FALSE, TRUE, FALSE, m_nET);
}
//AECMAS+MA
void CGeneratorDlg::OnBnClickedRadio9()
{
	m_nET = nsGEN::AttrKey::TECHMODE_TYPE::TECHMODE_AEC_MAS_MA;
	DevActionValue(nsGEN::ActionKey::SetValue_TECHMODE, { to_string(m_nET) });
	ShowPageElements(FALSE, TRUE, FALSE, m_nET);
}
//Table
void CGeneratorDlg::OnBnClickedRadio10()
{
	m_nWS = nsGEN::AttrKey::GENWS_TYPE::TABLE;
	DevActionValue(nsGEN::ActionKey::SetValue_WORKSTATION, { "Table" });
}
//Wall
void CGeneratorDlg::OnBnClickedRadio11()
{
	m_nWS = nsGEN::AttrKey::GENWS_TYPE::WALL;
	DevActionValue(nsGEN::ActionKey::SetValue_WORKSTATION, { "Wall" });
}
//Conventional
void CGeneratorDlg::OnBnClickedRadio12()
{
	m_nWS = nsGEN::AttrKey::GENWS_TYPE::CONVENTIONAL;
	DevActionValue(nsGEN::ActionKey::SetValue_WORKSTATION, { "Direct" });
}
//Mobile
void CGeneratorDlg::OnBnClickedRadio13()
{
	m_nWS = nsGEN::AttrKey::GENWS_TYPE::MOBILE;
	DevActionValue(nsGEN::ActionKey::SetValue_WORKSTATION, { "Mobile" });
}
//Free
void CGeneratorDlg::OnBnClickedRadio14()
{
	m_nWS = nsGEN::AttrKey::GENWS_TYPE::FREE_WALL;
	DevActionValue(nsGEN::ActionKey::SetValue_WORKSTATION, { "Free" });
}
//Tomo
void CGeneratorDlg::OnBnClickedRadio15()
{
	m_nWS = nsGEN::AttrKey::GENWS_TYPE::TOMO;
	DevActionValue(nsGEN::ActionKey::SetValue_WORKSTATION, { "Tomo" });
}
//ABSOff
void CGeneratorDlg::OnBnClickedRadio16()
{
	m_nABSMode = nsGEN::AttrKey::GENERATOR_ABSStatus::GENERATOR_ABS_OFF;
	DevActionValue(nsGEN::ActionKey::SetValue_ABSMode, { to_string(m_nABSMode) });
}
//ABSOnKV
void CGeneratorDlg::OnBnClickedRadio17()
{
	m_nABSMode = nsGEN::AttrKey::GENERATOR_ABSStatus::GENERATOR_ABS_ON_KV;
	DevActionValue(nsGEN::ActionKey::SetValue_ABSMode, { to_string(m_nABSMode) });
}
//ABSOnKVMA
void CGeneratorDlg::OnBnClickedRadio18()
{
	m_nABSMode = nsGEN::AttrKey::GENERATOR_ABSStatus::GENERATOR_ABS_ON_KVMA;
	DevActionValue(nsGEN::ActionKey::SetValue_ABSMode, { to_string(m_nABSMode) });
}
//FluModeNot
void CGeneratorDlg::OnBnClickedRadio19()
{
	m_nFluMode = nsGEN::AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_NOTFLU;
	DevActionValue(nsGEN::ActionKey::SetFLFMode, { "NotFlu" });
}
//FluModeCF
void CGeneratorDlg::OnBnClickedRadio20()
{
	m_nFluMode = nsGEN::AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_CF;
	DevActionValue(nsGEN::ActionKey::SetFLFMode, { "CF" });
}
//FluModePF
void CGeneratorDlg::OnBnClickedRadio21()
{
	m_nFluMode = nsGEN::AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_PF;
	DevActionValue(nsGEN::ActionKey::SetFLFMode, { "PF" });
}
//FluModeHCF
void CGeneratorDlg::OnBnClickedRadio22()
{
	m_nFluMode = nsGEN::AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_HCF;
	DevActionValue(nsGEN::ActionKey::SetFLFMode, { "HLCF" });
}
//FluModeHPF
void CGeneratorDlg::OnBnClickedRadio23()
{
	m_nFluMode = nsGEN::AttrKey::GENERATOR_FLUMode::GENERATOR_FLMODE_HPF;
	DevActionValue(nsGEN::ActionKey::SetFLFMode, { "HLF" });
}


//KV_Value
void CGeneratorDlg::OnEnKillfocusEdit1()
{
	CString tempStr;
	m_Edit_KV.GetWindowText(tempStr);
	m_nKV = atoi(tempStr);
}
//MAS_Value
void CGeneratorDlg::OnEnKillfocusEdit2()
{
	CString tempStr;
	m_Edit_MAS.GetWindowText(tempStr);
	m_fMAS = atof(tempStr);
}
//MA_Value
void CGeneratorDlg::OnEnKillfocusEdit3()
{
	CString tempStr;
	m_Edit_MA.GetWindowText(tempStr);
	m_fMA = atof(tempStr);
}
//MS_Value
void CGeneratorDlg::OnEnKillfocusEdit4()
{
	CString tempStr;
	m_Edit_MS.GetWindowText(tempStr);
	m_fMS = atof(tempStr);
}
//Density_Value
void CGeneratorDlg::OnEnKillfocusEdit5()
{
	CString tempStr;
	m_Edit_Density.GetWindowText(tempStr);
	m_nAECDensity = atof(tempStr);
}
//Field_Value
void CGeneratorDlg::OnEnKillfocusEdit6()
{
	CString tempStr;
	m_Edit_Field.GetWindowText(tempStr);
	m_nAECField = atof(tempStr);
}
//Film_Value
void CGeneratorDlg::OnEnKillfocusEdit7()
{
	CString tempStr;
	m_Edit_Film.GetWindowText(tempStr);
	m_nAECFilm = atof(tempStr);
}
//EXPmode_Value
void CGeneratorDlg::OnEnKillfocusEdit9()
{
	CString tempStr;
	m_Edit_expmode.GetWindowText(tempStr);
	m_bExpMode = tempStr;
}
//RADFrameRate_Value
void CGeneratorDlg::OnEnKillfocusEdit20()
{
	CString tempStr;
	m_Edit_RadFrameRate.GetWindowText(tempStr);
	m_bRADFrameRate = atof(tempStr);
}
//FluKV_Value
void CGeneratorDlg::OnEnKillfocusEdit22()
{
	CString tempStr;
	m_Edit_FluKV.GetWindowText(tempStr);
	m_nFluKV = atoi(tempStr);
}
//FluMA_Value
void CGeneratorDlg::OnEnKillfocusEdit23()
{
	CString tempStr;
	m_Edit_FluMA.GetWindowText(tempStr);
	m_fFluMA = atof(tempStr);
}
//PPS_Value
void CGeneratorDlg::OnEnKillfocusEdit24()
{
	CString tempStr;
	m_Edit_FluPPS.GetWindowText(tempStr);
	m_fPPS = atof(tempStr);
}
//PluseWidth_Value
void CGeneratorDlg::OnEnKillfocusEdit25()
{
	CString tempStr;
	m_Edit_FluPluseWidth.GetWindowText(tempStr);
	m_nPluseWidth = atoi(tempStr);
}
//ABSCurve_Value
void CGeneratorDlg::OnEnKillfocusEdit26()
{
	CString tempStr;
	m_Edit_FluABSCurve.GetWindowText(tempStr);
	m_nABSCurve = atoi(tempStr);
}
//DoseLever_Value
void CGeneratorDlg::OnEnKillfocusEdit27()
{
	CString tempStr;
	m_Edit_FluDoseLever.GetWindowText(tempStr);
	m_nDoseLever = atoi(tempStr);
}
//CurrEXI_Value
void CGeneratorDlg::OnEnKillfocusEdit28()
{
	CString tempStr;
	m_Edit_FluCurrEXI.GetWindowText(tempStr);
	m_nCurrEXI = atoi(tempStr);
}
//TargetEXI_Value
void CGeneratorDlg::OnEnKillfocusEdit29()
{
	CString tempStr;
	m_Edit_FluTarEXI.GetWindowText(tempStr);
	m_nTarEXI = atoi(tempStr);
}
//MAG_Value
void CGeneratorDlg::OnEnKillfocusEdit30()
{
	CString tempStr;
	m_Edit_FluMag.GetWindowText(tempStr);
	m_nMag = atoi(tempStr);
}
//ResetTime_Value
void CGeneratorDlg::OnEnKillfocusEdit31()
{
	CString tempStr;
	m_Edit_FluResetTime.GetWindowText(tempStr);
	m_nResetTime = atoi(tempStr);
}
//FluPre_Value
void CGeneratorDlg::OnEnKillfocusEdit33()
{
	CString tempStr;
	m_Edit_FluPre.GetWindowText(tempStr);
	m_nFluPre = atoi(tempStr);
}
//FluEXP_Value
void CGeneratorDlg::OnEnKillfocusEdit34()
{
	CString tempStr;
	m_Edit_FluEXP.GetWindowText(tempStr);
	m_nFluEXP = atoi(tempStr);
}