GrpcPrint/PrintS/StateManager.cpp

#include "StateManager.h"
#include "Logger.h"
#include "utils/Average.h"
#include "SystemInfo.h"
#include "LanguageManager.h"
#include "Toast.h"
#include "global.h"
#include "plc/SignalService.h"
#include "external/imgui/imgui_internal.h"
#include <time.h>
#include "utils/TimeHelper.h"

StateManager::StateManager()
	:m_ScannerCtrl(NULL)
	//,m_GTSController(NULL)
	, m_ComServer(NULL)
	, m_StateThread(INVALID_HANDLE_VALUE)
	, m_RunFlag(false)
	, m_PrintCabinDoorOpenAlarmLastState(true)
{
	m_LastLayerIndex = 0;
	m_MStatueFilePath= g_AppPath + "MStatue";
}


StateManager::~StateManager()
{
	m_SFile->flush();
	m_SFile->close();
	DeleteCriticalSection(&m_NotifiesCS);
	delete m_SFile;
	if (m_Buzzer)delete m_Buzzer;
}

void StateManager::Init(ScannerCtrl* psc, CoreCommunication* cc, ComServer* pcs,BasePurifier* pbp, RemoteClient* rc)
{
	m_IoCfgWrapper = ConfigManager::GetInstance()->GetIoCfgWrapper();
	m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
	m_AxisCfgs = ConfigManager::GetInstance()->GetAxisSetting();
	m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
	m_AlarmCfgWrapper = ConfigManager::GetInstance()->GetAlarmCfg();
	m_MachineCfg = ConfigManager::GetInstance()->GetMachineCfg();
	m_Machine = ConfigManager::GetInstance()->GetMachine();
	m_PowderEstimateCfg = ConfigManager::GetInstance()->GetPowderEstimateCfg();
	InitializeCriticalSection(&m_NotifiesCS);
	m_ScannerCtrl = psc;
	m_CoreCommunication = cc;
	m_ComServer = pcs;
	m_Purifier = pbp;
	m_RemoteClient = rc;
	m_LogTime = GetTickCount64();
	m_TotalRunTime = m_LogTime;
	m_TotalLaserTime = m_LogTime;
	m_MStatueSaveTime = m_LogTime;
	m_SFile = new ofstream();
	m_SFile->open(m_MStatueFilePath.c_str(), ios::binary);
	if (m_IoCfgWrapper->m_Buzzer) {
		m_Buzzer = new Buzzer();
		m_Buzzer->Init();
	}
	m_LaserPS = BaseCtrl::GetState();
}

void StateManager::Start()
{
	if (m_StateThread != INVALID_HANDLE_VALUE)return;
	m_RunFlag = true;
	m_StateThread = AtlCreateThread(StateProc, this);
}

void StateManager::Stop()
{
	m_RunFlag = false;
	if (m_StateThread != INVALID_HANDLE_VALUE) {
		if (WaitForSingleObject(m_StateThread, 500) == WAIT_TIMEOUT) {
			TerminateThread(m_StateThread, 0);
		}
		CloseHandle(m_StateThread);
		m_StateThread = INVALID_HANDLE_VALUE;
	}
}

DWORD WINAPI StateManager::StateProc(StateManager* _this)
{
	if (_this) {
		_this->StateRun();
	}
	return 0;
}

void StateManager::StateRun()
{
	Average<double, 20> PrintPressure;
	SignalService& alarmService = SignalService::GetInstance();
	Oxygenstat oxygenStat;
	EnvState envState;
	bool CheckOxyReady = false;
	uint64_t smBegtick = GetTickCount64();
//	Sleep(1000);
//	m_PrintCabinDoorOpenAlarmLastState = m_AlarmCfgWrapper->m_PrintCabinDoorLockOpenAlarm->m_IsAlarm;
	
	while (m_RunFlag) {

		m_Purifier->UpdateShowStat();
		m_CoreCommunication->GetEnvState(envState);
		EnterCriticalSection(&g_SystemInfo->m_InfoCs);
		g_SystemInfo->m_FanFrequency = m_Purifier->GetFanFreq();
		g_SystemInfo->m_EnvState = envState;
		if (m_ExtCfg->m_ComGetOxygen) {
			m_ComServer->m_OxygenClient->GetOxygenStat(1, oxygenStat);
			g_SystemInfo->m_ComPrintOxygen1 = oxygenStat.concentrationValue;
			g_SystemInfo->m_PrintTemp1 = oxygenStat.tempValue;
			g_SystemInfo->m_PrintHumidity1 = oxygenStat.humidityValue;
			bool iscon1 = oxygenStat.baseStat.isConnected;
			m_ComServer->m_OxygenClient->GetOxygenStat(2, oxygenStat);
			g_SystemInfo->m_ComPrintOxygen2 = oxygenStat.concentrationValue;
			g_SystemInfo->m_PrintTemp2 = oxygenStat.tempValue;
			g_SystemInfo->m_PrintHumidity2 = oxygenStat.humidityValue;
			bool iscon2 = oxygenStat.baseStat.isConnected;
			m_ComServer->m_OxygenClient->GetOxygenStat(3, oxygenStat);
			g_SystemInfo->m_ComOutsideOxygen = oxygenStat.concentrationValue;
			g_SystemInfo->m_IsOxygenSensorConnect = (iscon1&&iscon2);
		}
		else {
			g_SystemInfo->m_ComPrintOxygen1 = envState.m_PrintOxygen1Analog;
			g_SystemInfo->m_ComPrintOxygen2 = envState.m_PrintOxygen2Analog;
			g_SystemInfo->m_ComOutsideOxygen = envState.m_OutsideOxygenAnalog;
		}
		if (m_RunCfg->m_PowderStickCalcLength != 0.0f)g_SystemInfo->m_PowderQtyPos = envState.m_PowderLevelValue / m_RunCfg->m_PowderStickCalcLength;
		if (g_SystemInfo->m_PowderQtyPos > 1.0f)g_SystemInfo->m_PowderQtyPos = 1.0f;
		g_SystemInfo->m_WindValue = m_Purifier->GetWindValue(0.0);

		if (m_ComServer->m_TempCtrlClient && m_ComServer->m_TempCtrlClient->GetConfig()->m_Enable) {
			g_SystemInfo->m_IsHeatingConnect = m_ComServer->m_TempCtrlClient->IsComConnected();
		}
		LeaveCriticalSection(&g_SystemInfo->m_InfoCs);
		SignalService::GetInstance().SetPurifierIsConnect(m_Purifier->IsConnectAlarm());


		if (BaseCtrl::IsStart() || BaseCtrl::IsPause()) {
			FileProcessor* job = m_ScannerCtrl->GetJobController()->GetJob();
			uint64_t dnow = GetTickCount64();
			bool hasStopAlarm = false;
			bool hasPauseAlarm = false;

			if (BaseCtrl::IsStart()) {
				alarmService.JudgeStopAlarm(m_ScannerCtrl->m_StopAlarms);
				char alarmBuffer[1024];
				 //AlarmCfg* stoplog = alarmService.JudgeStopAlarm();
				if (!m_ScannerCtrl->m_StopAlarms.empty())
				{
					hasStopAlarm = true;
					m_ScannerCtrl->StopWork();
					for (auto al : m_ScannerCtrl->m_StopAlarms) {
						sprintf_s(alarmBuffer, sizeof(alarmBuffer), u8"%s%s %s", _(u8"停止打印，原因：").c_str(), al->m_ShowContent.c_str(), al->m_AlarmInfo.c_str());
						AlarmShowInfo* asi = new AlarmShowInfo;
						asi->m_JobName = job->GetJobTitle();
						asi->m_JobId = job->GetJobUid();
						std::time(&asi->m_HappenTime);
						asi->m_LayerIndex = job->GetCurrentLayerIndex();
						asi->m_AlarmCode = al->m_Code;
						asi->m_AlarmName = al->m_ShowContent.c_str();
						asi->m_AlarmContent = alarmBuffer;
						asi->m_AlarmShowInfo = al->m_AlarmInfo;
						asi->m_AlarmType = ALARM_TYPE_STOP;
						AddAlarmNotify(asi);
						string jobname = "";
						if (job)jobname = job->GetJobTitle();
						g_log->m_LogDao->AddHistoryAlarm(jobname, ALARM_TYPE_STOP, alarmBuffer);
					}
					m_RemoteClient->SetNeedSendAlarm(true);
					if (m_Buzzer)m_Buzzer->SetStopAlarmEnable();
				}
				else {
					alarmService.JudgePauseAlarm(m_ScannerCtrl->m_PauseAlarms);
					if (!m_ScannerCtrl->m_PauseAlarms.empty()) {
						hasPauseAlarm = true;
						m_ScannerCtrl->PauseWork();
						BaseCtrl::SetPauseState(BaseCtrl::AlarmPause);
						for (auto al : m_ScannerCtrl->m_PauseAlarms) {
							sprintf_s(alarmBuffer, sizeof(alarmBuffer), u8"%s%s %s", _(u8"暂停打印，原因：").c_str(), al->m_ShowContent.c_str(), al->m_AlarmInfo.c_str());
							AlarmShowInfo* asi = new AlarmShowInfo;
							asi->m_JobName = job->GetJobTitle();
							asi->m_JobId = job->GetJobUid();
							std::time(&asi->m_HappenTime);
							asi->m_LayerIndex = job->GetCurrentLayerIndex();
							asi->m_AlarmCode = al->m_Code;
							asi->m_AlarmName = al->m_ShowContent.c_str();
							asi->m_AlarmShowInfo = al->m_AlarmInfo;
							asi->m_AlarmContent = alarmBuffer;
							asi->m_AlarmType = ALARM_TYPE_PAUSE;
							AddAlarmNotify(asi);
							string jobname = "";
							if (job)jobname = job->GetJobTitle();
							g_log->m_LogDao->AddHistoryAlarm(jobname, ALARM_TYPE_PAUSE, alarmBuffer);
						}

						m_RemoteClient->SetNeedSendAlarm(true);
						if (m_Buzzer)m_Buzzer->SetPauseAlarmEnable();
					}
				}
				if (m_RunCfg->m_PrintRestEnable && job && job->m_BeginPrintTime != 0L) {
					g_SystemInfo->m_PrintRemainTime = m_RunCfg->m_PrintContinueMinute * 60 * 1000 - (dnow - job->m_BeginPrintTime);
					if (g_SystemInfo->m_PrintRemainTime < 0)g_SystemInfo->m_PrintRemainTime = 0;
					if ((dnow - job->m_BeginPrintTime) > (m_RunCfg->m_PrintContinueMinute * 60 * 1000)) {
						m_ScannerCtrl->PauseAuto();
						BaseCtrl::SetPauseState(BaseCtrl::PrintRestPause);
					}
				}

				vector<AlarmCfg*> warns;
				string warnInfo = alarmService.JudgeWarns(warns);

				if ((dnow - m_LastWarnInfo) > (m_RunCfg->m_WarnAlarmNotifySecond * 1000)) {
					if (warnInfo != "") {
						g_Toast->AddToast(new ToastBean(warnInfo, 3000, Toast::COLOR_ORANGE));
					}
					m_LastWarnInfo = dnow;
				}
			}

			if (job) {
				double pt = (double)(dnow - job->m_BeginPrintTime) / 1000.0;
				//if (job->m_FirstStartTime == 0L)job->m_FirstStartTime = dnow;
				double currentPrintTime = (double)(dnow - job->m_FirstStartTime) / 1000.0;
				//g_SystemInfo->m_StateBean.realCostSeconds = job->GetJobbean()->m_SpendSecond + currentPrintTime;
				g_SystemInfo->m_StateBean.realCostSeconds = job->GetJobbean()->m_PrintSecond + pt;
				g_SystemInfo->m_StateBean.remainMil = job->GetMetaData()->GetRemainTime();
				job->GetJobbean()->m_CurrentPrintedTime = currentPrintTime;
				job->GetJobbean()->m_EveryPrintedTime = pt;
				//job->GetJobbean()->m_MoldPos = m_GTSController->Mold()->GetState()->realPos;
				bool needPersist = false;
				int layerIndex = job->GetJobbean()->m_PrintedLayerIndex;
				if (layerIndex != m_LastLayerIndex) {
					needPersist = true;
					m_LastLayerIndex = layerIndex;
				}
				if ((dnow - m_LogTime) > m_RunCfg->m_LogPersistInteval || needPersist) {
					LayerStatus layerStatus;
					layerStatus.m_JobId = job->GetJobbean()->m_Id;
					layerStatus.m_LayerIndex = layerIndex;
					time(&layerStatus.m_InsertTitme);
					layerStatus.m_SpendSecond = job->GetJobbean()->m_SpendSecond + currentPrintTime;
					//layerStatus.m_MoldPos = m_GTSController->Mold()->GetState()->realPos;

					EnterCriticalSection(&g_SystemInfo->m_InfoCs);
					layerStatus.m_PrintOxygen1 = g_SystemInfo->m_ComPrintOxygen1;
					layerStatus.m_PrintOxygen2 = g_SystemInfo->m_ComPrintOxygen2;
					layerStatus.m_OutsideOxygen = g_SystemInfo->m_ComOutsideOxygen;

					layerStatus.m_PrintTemp1 = g_SystemInfo->m_PrintTemp1;
					layerStatus.m_PrintTemp2 = g_SystemInfo->m_PrintTemp2;
					layerStatus.m_PrintHumidity1 = g_SystemInfo->m_PrintHumidity1;
					layerStatus.m_PrintHumidity2 = g_SystemInfo->m_PrintHumidity2;
					layerStatus.m_PlateTemp = g_SystemInfo->m_PlatformTemp;
					layerStatus.m_FanFrequency = g_SystemInfo->m_FanFrequency;
					layerStatus.m_WindRate = g_SystemInfo->m_WindValue;
					layerStatus.m_PrintPressure = g_SystemInfo->m_EnvState.m_PrintPressureAnalog;
					LeaveCriticalSection(&g_SystemInfo->m_InfoCs);
					g_log->m_LogDao->LogLayerStatus(layerStatus);
					m_LogTime = dnow;
				}
			}
			if ((dnow - m_TotalRunTime) > m_RunCfg->m_StatisticsInteval) {
				EnterCriticalSection(&g_SystemInfo->m_MStatueCS);
				g_SystemInfo->m_MStatue.m_TotalPrintTime = g_SystemInfo->m_MStatue.m_TotalPrintTime + (dnow - m_TotalRunTime);
				LeaveCriticalSection(&g_SystemInfo->m_MStatueCS);
				m_TotalRunTime = dnow;
			}
		}
		else if (BaseCtrl::IsStandBy()) {

			if (BaseCtrl::IsPauseStanBy()) {
				if (BaseCtrl::GetPauseState() == BaseCtrl::PrintRestPause) {
					uint64_t dnow = GetTickCount64();
					EnterCriticalSection(&m_ScannerCtrl->GetJobController()->m_cs);
					FileProcessor* job = m_ScannerCtrl->GetJobController()->GetJob();
					if (m_RunCfg->m_PrintRestEnable && job && job->m_AutoPauseTime != 0L && job->m_IsAutoCtrl) {
						g_SystemInfo->m_PauseRemainTime = m_RunCfg->m_PrintRestMinutes * 60 * 1000 - (dnow - job->m_AutoPauseTime);
						if (g_SystemInfo->m_PauseRemainTime < 0)g_SystemInfo->m_PauseRemainTime = 0;
						if ((dnow - job->m_AutoPauseTime) > (m_RunCfg->m_PrintRestMinutes * 60 * 1000)) {
							job->m_AutoPauseTime = GetTickCount64();
							m_ScannerCtrl->BeginWork();
						}
						double pt = (double)(dnow - job->m_BeginPrintTime) / 1000.0;
						g_SystemInfo->m_StateBean.realCostSeconds = job->GetJobbean()->m_PrintSecond + pt;
						//if (job->m_FirstStartTime == 0L)job->m_FirstStartTime = GetTickCount64();
						//double currentPrintTime = (double)(dnow - job->m_FirstStartTime) / 1000.0;
						//g_SystemInfo->m_StateBean.realCostSeconds = job->GetJobbean()->m_SpendSecond + currentPrintTime;
					}
					LeaveCriticalSection(&m_ScannerCtrl->GetJobController()->m_cs);
				}
				/*else if (BaseCtrl::GetPauseState() == BaseCtrl::AlarmAutoPause) {
					if (m_CurrentAutoAlarm)
					{
						if (m_AutoAlarmProc.find(m_CurrentAutoAlarm) != m_AutoAlarmProc.end())
						{
							EnterCriticalSection(&m_AutoAlarmCS);
							if (m_ReadyRestartPrint) {
								m_ScannerCtrl->BeginWork();

								m_ReadyRestartPrint = false;
							}
							else {
								if (m_AutoAlarmHandle == INVALID_HANDLE_VALUE) {
									m_AutoAlarmHandle = AtlCreateThread(m_AutoAlarmProc[m_CurrentAutoAlarm], this);
								}
							}
							LeaveCriticalSection(&m_AutoAlarmCS);
						}
					}
				}*/
			}
		}

		m_IoCfgWrapper->AutoCtrlHeating(m_ComServer->m_TempCtrlClient);

		if (m_AlarmCfgWrapper->m_PrintCabinDoorOpenAlarm->m_IsEnable && m_AlarmCfgWrapper->m_PrintCabinDoorOpenAlarm->m_IsAlarm) {
			vector<ScannerControlCfg*>* laserCfg = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
			for (size_t laserIndex = 0; laserIndex < laserCfg->size(); laserIndex++) {
				ScannerControlCfg* lcfg = (*laserCfg)[laserIndex];
				if (lcfg->m_LaserEnable && lcfg->m_LaserEnable->IsActive()) {
					lcfg->m_LaserEnable->SetActive(false);
				}
			}
		}


		m_Machine->AutoCtrlLamp();

		if (m_IoCfgWrapper->m_ScannerCool) {
			bool isLaserOn = false;
			//振镜冷却随激光器开启
			vector<ScannerControlCfg*>* laserCfgs = ConfigManager::GetInstance()->GetMatchScannerControlCfg();
			for (size_t i = 0; i < laserCfgs->size(); i++) {
				ScannerControlCfg* laserCfg = (*laserCfgs)[i];
				if (laserCfg->m_LaserEnable && laserCfg->m_LaserEnable->IsActive())
				{
					isLaserOn = true;
					break;
				}
			}

			if (isLaserOn) {
				if (!m_IoCfgWrapper->m_ScannerCool->IsActive() && !m_RunCfg->m_IsDebugMode) {
					m_IoCfgWrapper->m_ScannerCool->SetActive(true);
				}
			}
			else {
				if (m_IoCfgWrapper->m_ScannerCool->IsActive() && !m_RunCfg->m_IsDebugMode) {
					m_IoCfgWrapper->m_ScannerCool->SetActive(false);
				}
			}
		}

		//振镜冷却随激光器开启
		/*if (m_IoCfgWrapper->m_Laser->IsActive()) {
			if (m_IoCfgWrapper->m_ScannerCool) {
				if (!m_IoCfgWrapper->m_ScannerCool->IsActive() && !m_RunCfg->m_IsDebugMode) {
					m_IoCfgWrapper->m_ScannerCool->SetActive(true);
				}
			}
		}
		else {
			if (m_IoCfgWrapper->m_ScannerCool) {
				if (m_IoCfgWrapper->m_ScannerCool->IsActive() && !m_RunCfg->m_IsDebugMode) {
					m_IoCfgWrapper->m_ScannerCool->SetActive(false);
				}
			}
		}*/

		if (CheckOxyReady){
			if (m_AlarmCfgWrapper->m_PrintCabinDoorOpenAlarm->m_IsAlarm && !m_PrintCabinDoorOpenAlarmLastState) {
				EnterCriticalSection(&g_SystemInfo->m_InfoCs);
				if (g_SystemInfo->m_ComPrintOxygen1 < m_RunCfg->m_DangerousOxygen || g_SystemInfo->m_ComPrintOxygen2 < m_RunCfg->m_DangerousOxygen) {
					AddDangerNotify(_(u8"舱门打开时氧含量过低，请等待三分钟后再进行舱内操作。").c_str());
				}
				LeaveCriticalSection(&g_SystemInfo->m_InfoCs);
			}
		}
		else {
			uint64_t smNowtic = GetTickCount64();
			if (smNowtic - smBegtick > 10000)
			{
				CheckOxyReady = true;
			}
		}
		
		if (m_ComServer->m_SimpleSupplyClient && m_ComServer->m_SimpleSupplyClient->IsServerConnected()) {
			if (m_ExtCfg->m_UsePowderStick) {
				if ((m_PowderEstimateCfg->m_StartSupplyQty > g_SystemInfo->GetPowderQty()*100.0f) && m_PowderEstimateCfg->m_AutoSupplyEnable) {
					if (!m_ComServer->m_SimpleSupplyClient->IsAutoSuppling() && BaseCtrl::IsStart()) {
						m_ComServer->m_SimpleSupplyClient->AutoSupply();
					}
				}
			}
			else {
				IOCfg* supplyPos = m_PowderEstimateCfg->m_PEVec[m_PowderEstimateCfg->m_StartSupplyPos]->m_PosSensor;
				if (supplyPos && !supplyPos->IsActive() && m_PowderEstimateCfg->m_AutoSupplyEnable) {
					if (!m_ComServer->m_SimpleSupplyClient->IsAutoSuppling() && BaseCtrl::IsStart()) {
						m_ComServer->m_SimpleSupplyClient->AutoSupply();

					}
				}
			}
		}


		m_PrintCabinDoorOpenAlarmLastState = m_AlarmCfgWrapper->m_PrintCabinDoorOpenAlarm->m_IsAlarm;
		BaseCtrl::PrintState ps = BaseCtrl::GetState();
		switch (ps) {
		case  BaseCtrl::PAUSE: {
			g_SystemInfo->m_StateBean.systemState = _(u8"暂停中").c_str();
		}break;
		case  BaseCtrl::STOP: {
			g_SystemInfo->m_StateBean.systemState = _(u8"停止中").c_str();
		}break;
		case  BaseCtrl::STANDBY: {
			g_SystemInfo->m_StateBean.systemState = _(u8"就绪").c_str();
		}break;
		case  BaseCtrl::STANDBY_PAUSE: {
			g_SystemInfo->m_StateBean.systemState = _(u8"暂停中断").c_str();
		}break;
		case  BaseCtrl::STANDBY_STOP: {
			g_SystemInfo->m_StateBean.systemState = _(u8"停止中断").c_str();
		}break;
		case  BaseCtrl::PRINTING: {
			g_SystemInfo->m_StateBean.systemState = _(u8"正在打印").c_str();
		}break;
		case  BaseCtrl::PREPRINT: {
			switch (BaseCtrl::GetPreState()) {
			case ScannerCtrl::CheckIO: {
				g_SystemInfo->m_StateBean.systemState = _(u8"检查").c_str();
			}break;
			case ScannerCtrl::Purifying: {
				g_SystemInfo->m_StateBean.systemState = _(u8"除氧").c_str();
			}break;
			case ScannerCtrl::Dedusting: {
				g_SystemInfo->m_StateBean.systemState = _(u8"循环").c_str();
			}break;
			case ScannerCtrl::WaitConfirm: {
				g_SystemInfo->m_StateBean.systemState = _(u8"等待确认").c_str();
			}break;
			case ScannerCtrl::AutoHeatingScanner: {
				g_SystemInfo->m_StateBean.systemState = _(u8"振镜预热").c_str();
			}break;
			case ScannerCtrl::PreFinished: {
				g_SystemInfo->m_StateBean.systemState = _(u8"准备打印").c_str();
			}break;
			}
		}break;
		case ScannerCtrl::FINISH: {
			g_SystemInfo->m_StateBean.systemState = _(u8"完成").c_str();
		}break;
		}

		if (m_LaserPS != ps) {
			m_RemoteClient->SendStateChangeMsg();
		}
		m_LaserPS = ps;

		uint64_t nowtick = GetTickCount64();
		time(&g_SystemInfo->m_StateBean.currentTime);
		if ((nowtick- m_MStatueSaveTime)>100) {
			EnterCriticalSection(&g_SystemInfo->m_MStatueCS);
			m_SFile->seekp(0, ios::beg);
			m_SFile->write((char*)&g_SystemInfo->m_MStatue, sizeof(MStatue));
			LeaveCriticalSection(&g_SystemInfo->m_MStatueCS);
			m_MStatueSaveTime = nowtick;
		}
		Sleep(30);
	}
}


void StateManager::DrawNotify(void)
{
	size_t nsize = 0;
	EnterCriticalSection(&m_NotifiesCS);
	nsize = m_AlarmNotifies.size();
	LeaveCriticalSection(&m_NotifiesCS);

	if (nsize > 0) {
		ImGui::OpenPopup(_(u8"信息提示").c_str());
		if (ImGui::BeginPopupModal(_(u8"信息提示").c_str(), NULL, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize)) {
			EnterCriticalSection(&m_NotifiesCS);
			AlarmShowInfo* info = m_AlarmNotifies[0];
			ImGui::Text(_(u8"任务名：%s").c_str(), info->m_JobName.c_str());
			ImGui::Text(_(u8"报警层：%u").c_str(), info->m_LayerIndex + 1);
			ImGui::Text(_(u8"报警时间：%s").c_str(), TimeHelper::Time2Str(info->m_HappenTime).c_str());
			ImGui::Text(_(u8"报警类型：%s").c_str(), AlarmCfg::GetTypeInfo(info->m_AlarmType).c_str());
			ImGui::TextColored(Toast::COLOR_RED, _(u8"报警项目：%s").c_str(), info->m_AlarmName.c_str());
			ImGui::Text(_(u8"报警信息：").c_str());
			ImGui::TextColored(Toast::COLOR_RED, info->m_AlarmShowInfo.c_str());

			if (m_RemoteClient->IsNeedSendAlarm())
			{
				std::time(&info->m_TFlag);
				int idif = info->m_TFlag - info->m_HappenTime;
				if (((idif % 10) == 0) && m_LastSendAlarmFlag != idif) {
					m_RemoteClient->SendAlarmMsg(info);
					m_LastSendAlarmFlag = idif;
				}
			}
			LeaveCriticalSection(&m_NotifiesCS);
			ImGui::Separator();
			if (ImGui::Button(_(u8"确定").c_str(), ImVec2(120, 0))) {
				EnterCriticalSection(&m_NotifiesCS);
				for (size_t i = 0; i < m_AlarmNotifies.size(); i++) {
					delete m_AlarmNotifies[i];
				}
				m_AlarmNotifies.clear();
				LeaveCriticalSection(&m_NotifiesCS);

				if (m_Buzzer)m_Buzzer->SetStopAlarmDisable();
				if (m_Buzzer)m_Buzzer->SetPauseAlarmDisable();
				ImGui::CloseCurrentPopup();
			}
			ImGui::EndPopup();
		}
	}
}


void StateManager::DrawOxygenReady()
{
	if (BaseCtrl::GetPreState()!= BaseCtrl::WaitConfirm) {
		return;
	}
	ImGui::OpenPopup(_(u8"可打印提示").c_str());
	if (ImGui::BeginPopupModal(_(u8"可打印提示").c_str(), NULL, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize)) {
		ImGui::Text(_(u8"氧含量已达到可打印状态，是否开始打印？").c_str());
		char buffer[256];
		sprintf_s(buffer, sizeof(buffer),_(u8"准备在第 %u 层开始打印").c_str(), m_ScannerCtrl->GetJobController()->GetJob()->GetStartIndex()+1);
		ImGui::TextColored(Toast::COLOR_ORANGE,buffer);
		if (m_RunCfg->m_IsDebugMode) {
			ImGui::TextColored(Toast::COLOR_ORANGE, _(u8"注意，本次打印在调试模式下进行！").c_str());
		}
		if (m_ScannerCtrl->IsHeatingScannerEnable()) {
			ImGui::Separator();
			ImGui::Checkbox(_(u8"振镜预热").c_str(), &m_ScannerCtrl->GetJobController()->GetJob()->m_AutoHeatingScanner);
		}
		ImGui::Separator();
		if (ImGui::Button(_(u8"开始").c_str(),ImVec2(120, 0))) {
			BaseCtrl::SetPreState(BaseCtrl::SummitConfirm);
			ImGui::CloseCurrentPopup();
		}
		ImGui::SetItemDefaultFocus();
		ImGui::SameLine();
		if (ImGui::Button(_(u8"取消").c_str(), ImVec2(120, 0))) { 
			BaseCtrl::SetPreState(BaseCtrl::CancelConfirm);
			ImGui::CloseCurrentPopup(); 
		}
		ImGui::EndPopup();
	}
}

void StateManager::AddNotify(string notify)
{
	EnterCriticalSection(&m_NotifiesCS);
	m_Notifies.push_back(notify);
	LeaveCriticalSection(&m_NotifiesCS);
}

void StateManager::AddDangerNotify(string notify)
{
	EnterCriticalSection(&m_NotifiesCS);
	m_DangerNotifies.push_back(notify);
	LeaveCriticalSection(&m_NotifiesCS);
}

void StateManager::ResetTotalPrintTime()
{
	EnterCriticalSection(&g_SystemInfo->m_MStatueCS);
	g_SystemInfo->m_MStatue.m_TotalPrintTime = 0;
	m_TotalRunTime = GetTickCount64();
	m_SFile->seekp(0, ios::beg);
	m_SFile->write((char*)&g_SystemInfo->m_MStatue, sizeof(MStatue));
	LeaveCriticalSection(&g_SystemInfo->m_MStatueCS);
}

void StateManager::DrawDangerNotify()
{
	
	size_t nsize = 0;
	EnterCriticalSection(&m_NotifiesCS);
	nsize = m_DangerNotifies.size();
	LeaveCriticalSection(&m_NotifiesCS);

	if (nsize > 0) {
		ImGui::SetNextWindowPos(ImVec2(300, 400));
		ImGui::Begin(_(u8"危险信息提示").c_str(), 0, ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize);
		ImGui::SetWindowFontScale(1.2);
			EnterCriticalSection(&m_NotifiesCS);
			for (unsigned int i = 0; i < m_DangerNotifies.size(); i++)
			{
			ImGui::TextColored(Toast::COLOR_RED, "%s", m_DangerNotifies[i].c_str());
			}
			LeaveCriticalSection(&m_NotifiesCS);

			ImGui::Separator();
			if (ImGui::Button(_(u8"确定").c_str(), ImVec2(120, 0))) {
				EnterCriticalSection(&m_NotifiesCS);
				m_DangerNotifies.clear();
				LeaveCriticalSection(&m_NotifiesCS);
		}
		ImGui::End();
	}
}


void StateManager::AddAlarmNotify(AlarmShowInfo* info)
{
	if (!info)return;
	m_LastSendAlarmFlag = -1;
	EnterCriticalSection(&m_NotifiesCS);
	m_AlarmNotifies.push_back(info);
	LeaveCriticalSection(&m_NotifiesCS);
}

string StateManager::m_MStatueFilePath = "";