Merge branch 'clh' into liuyang

mrDarker

2025-08-27 3e0ceaf4e569ea1f57a14de2f6135d1f1a50d080

 SourceCode/Bond/Servo/ServoDlg.cpp

@@ -9,36 +9,39 @@
#include "Common.h"
#include "Log.h"
#include "SecsTestDlg.h"
#include "AlarmDlg.h"
#include <chrono>
#include <thread>
#include <cmath>
#include "HmTab.h"
#include "CRobotCmdContainerDlg.h"
#include "CRobotCmdTestDlg.h"
#include "LoginDlg.h"
#include "ChangePasswordDlg.h"
#include "UserManagerDlg.h"
#include "SystemLogManagerDlg.h"
#include "UserManager.h"
#include "SystemLogManager.h"
#include "PortConfigurationDlg.h"
#include "CHMPropertyDlg.h"
#include "CPageVarialbles.h"
#include "CPageReport.h"
#include "CPageCollectionEvent.h"
#include "CControlJobDlg.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// Image
#define IMAGE_ROBOT            2

#define INDICATE_BONDER1      1
#define INDICATE_BONDER2      2
#define INDICATE_FLIPER         3
#define INDICATE_ALIGNER      4
#define INDICATE_LPORT4         5
#define INDICATE_LPORT3         6
#define INDICATE_LPORT2         7
#define INDICATE_LPORT1         8
#define INDICATE_ROBOT_ARM1      9
#define INDICATE_ROBOT_ARM2      10
#define INDICATE_VACUUM_BAKE   11
#define INDICATE_BAKE_COOLING   12
#define INDICATE_MEASUREMENT   13


/* 创建终端的定时器 */
#define TIMER_ID_CREATE_TERMINAL      1

/* 运行时间定时器 */
#define TIMER_ID_UPDATE_RUMTIME         2

/* Test */
#define TIMER_ID_TEST               3


// 用于应用程序“关于”菜单项的 CAboutDlg 对话框
@@ -77,30 +80,31 @@
// CServoDlg 对话框



CServoDlg::CServoDlg(CWnd* pParent /*=NULL*/)
   : CDialogEx(IDD_SERVO_DIALOG, pParent)
{
   m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
   m_crBkgnd = APPDLG_BACKGROUND_COLOR;
   m_hbrBkgnd = nullptr;
   m_bShowLogWnd = FALSE;
   m_bShowAlarmWnd = FALSE;
   m_bIsRobotMoving = FALSE;
   m_pLogDlg = nullptr;
   m_pAlarmDlg = nullptr;
   m_pTerminalDisplayDlg = nullptr;
   m_pObserver = nullptr;
   m_pPanelMaster = nullptr;
   m_pPanelEquipment = nullptr;
   m_pPanelAttributes = nullptr;
   m_pPageGraph1 = nullptr;
   m_pPageGraph2 = nullptr;
   m_pPageAlarm = nullptr;
   m_pPageLog = nullptr;
   m_pPageTransferLog = nullptr;
   m_pPageRecipe = nullptr;
   m_pTopToolbar = nullptr;
   m_pMyStatusbar = nullptr;
   m_pRobotTaskDlg = nullptr;
}

void CServoDlg::DoDataExchange(CDataExchange* pDX)
{
   CDialogEx::DoDataExchange(pDX);
   DDX_Control(pDX, IDC_BUTTON_LOG, m_btnLog);
   DDX_Control(pDX, IDC_BUTTON_ALARM, m_btnAlarm);
}

BEGIN_MESSAGE_MAP(CServoDlg, CDialogEx)
@@ -111,11 +115,8 @@
   ON_BN_CLICKED(IDCANCEL, &CServoDlg::OnBnClickedCancel)
   ON_WM_CTLCOLOR()
   ON_WM_DESTROY()
   ON_BN_CLICKED(IDC_BUTTON_LOG, &CServoDlg::OnBnClickedButtonLog)
   ON_WM_SIZE()
   ON_WM_CLOSE()
   ON_MESSAGE(ID_MSG_LOGDLG_HIDE, &CServoDlg::OnLogDlgHide)
   ON_MESSAGE(ID_MSG_ALARMDLG_HIDE, &CServoDlg::OnAlarmDlgHide)
   ON_WM_MOVING()
   ON_WM_MOVE()
   ON_COMMAND(ID_MENU_FILE_EXIT, &CServoDlg::OnMenuFileExit)
@@ -124,10 +125,8 @@
   ON_UPDATE_COMMAND_UI(ID_MENU_FILE_SETTINGS, &CServoDlg::OnUpdateMenuFileSettings)
   ON_COMMAND(ID_MENU_FILE_SECSTEST, &CServoDlg::OnMenuFileSecsTest)
   ON_UPDATE_COMMAND_UI(ID_MENU_FILE_SECSTEST, &CServoDlg::OnUpdateMenuFileSecsTest)
   ON_COMMAND(ID_MENU_WND_LOG, &CServoDlg::OnMenuWndLog)
   ON_UPDATE_COMMAND_UI(ID_MENU_WND_LOG, &CServoDlg::OnUpdateMenuWndLog)
   ON_COMMAND(ID_MENU_WND_ALARM, &CServoDlg::OnMenuWndAlarm)
   ON_UPDATE_COMMAND_UI(ID_MENU_WND_ALARM, &CServoDlg::OnUpdateMenuWndAlarm)
   ON_COMMAND(ID_MENU_PROJECT_VARIABLE_LIST, &CServoDlg::OnMenuProjectVarialbleList)
   ON_UPDATE_COMMAND_UI(ID_MENU_PROJECT_VARIABLE_LIST, &CServoDlg::OnUpdateMenuProjectVarialbleList)
   ON_COMMAND(ID_MENU_TEST_MESSAGE_SET, &CServoDlg::OnMenuTestMessageSet)
   ON_UPDATE_COMMAND_UI(ID_MENU_TEST_MESSAGE_SET, &CServoDlg::OnUpdateMenuTestMessageSet)
   ON_COMMAND(ID_MENU_TEST_MESSAGE_CLEAR, &CServoDlg::OnMenuTestMessageClear)
@@ -135,11 +134,10 @@
   ON_COMMAND(ID_MENU_HELP_ABOUT, &CServoDlg::OnMenuHelpAbout)
   ON_WM_INITMENUPOPUP()
   ON_WM_TIMER()
   ON_WM_ERASEBKGND()
   ON_BN_CLICKED(IDC_BUTTON_ALARM, &CServoDlg::OnBnClickedButtonAlarm)
   ON_BN_CLICKED(IDC_BUTTON_ALARM, &CServoDlg::OnBnClickedButtonAlarm)
   ON_NOTIFY(BYSERVOGRAPH_ITEM_CLICKED, IDC_SERVO_GRAPH1, &CServoDlg::OnGraphItemClicked)
   ON_MESSAGE(ID_MSG_PANEL_RESIZE, OnPanelResize)
   ON_NOTIFY(BYHMTAB_SEL_CHANGED, IDC_TAB1, &CServoDlg::OnTabSelChanged)
   ON_MESSAGE(ID_MSG_TOOLBAR_BTN_CLICKED, &CServoDlg::OnToolbarBtnClicked)
   ON_MESSAGE(ID_MSG_STATUSBAR_BTN_CLICKED, &CServoDlg::OnStatusbarBtnClicked)
END_MESSAGE_MAP()


@@ -160,21 +158,6 @@
            const char* pszText;
            if (pAny->getStringValue("text", pszText)) {
               ShowTerminalText(pszText);
            }
         }
         else if (RX_CODE_EQ_ALIVE == code) {
            // 通知设备状态
            SERVO::CEquipment* pEquipment = nullptr;
            if (pAny->getPtrValue("ptr", (void*&)pEquipment)) {
               if (pEquipment != nullptr) {
                  int nID = pEquipment->getID();
                  BOOL bAlive = pEquipment->isAlive();
                  if (EQ_ID_EFEM == nID) {
                     DeviceStatus status = bAlive ? DeviceStatus::ONLINE : DeviceStatus::OFFLINE;
                     UpdateDeviceStatus(INDICATE_ROBOT_ARM1, status);
                     UpdateDeviceStatus(INDICATE_ROBOT_ARM2, status);
                  }
               }
            }
         }
         else if (RX_CODE_SELECT_EQUIPMENT == code) {
@@ -205,7 +188,112 @@
               }
            }
         }
         else if (RX_CODE_MASTER_STATE_CHANGED == code) {
            SERVO::MASTERSTATE state = theApp.m_model.getMaster().getState();
            if (state == SERVO::MASTERSTATE::READY) {
               m_pTopToolbar->GetBtn(IDC_BUTTON_RUN)->EnableWindow(TRUE);
               m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_BATCH)->EnableWindow(TRUE);
               m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_CT)->EnableWindow(TRUE);
               m_pTopToolbar->GetBtn(IDC_BUTTON_STOP)->EnableWindow(FALSE);
               m_pMyStatusbar->setBackgroundColor(STATUSBAR_BK_NORMAL);
               m_pMyStatusbar->setForegroundColor(RGB(0, 0, 0));
               KillTimer(TIMER_ID_UPDATE_RUMTIME);
               CString strText;
               GetRuntimeFormatText(strText, "");
               m_pMyStatusbar->setRunTimeText((LPTSTR)(LPCTSTR)strText);
            }
            else if (state == SERVO::MASTERSTATE::STARTING) {
               m_pMyStatusbar->setBackgroundColor(STATUSBAR_BK_STARTING);
               m_pMyStatusbar->setForegroundColor(RGB(0, 0, 0));
               m_pMyStatusbar->setRunTimeText("正在启动...");
            }
            else if (state == SERVO::MASTERSTATE::MSERROR) {
               m_pTopToolbar->GetBtn(IDC_BUTTON_RUN)->EnableWindow(TRUE);
               m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_BATCH)->EnableWindow(TRUE);
               m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_CT)->EnableWindow(TRUE);
               m_pTopToolbar->GetBtn(IDC_BUTTON_STOP)->EnableWindow(FALSE);
               m_pMyStatusbar->setBackgroundColor(STATUSBAR_BK_ALARM);
               m_pMyStatusbar->setForegroundColor(RGB(0, 0, 0));
               m_pMyStatusbar->setRunTimeText("启动失败.");
            }
            else if (state == SERVO::MASTERSTATE::RUNNING || state == SERVO::MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER
               || state == SERVO::MASTERSTATE::RUNNING_BATCH) {
               m_pTopToolbar->GetBtn(IDC_BUTTON_RUN)->EnableWindow(FALSE);
               m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_BATCH)->EnableWindow(FALSE);
               m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_CT)->EnableWindow(FALSE);
               m_pTopToolbar->GetBtn(IDC_BUTTON_STOP)->EnableWindow(TRUE);
               m_pMyStatusbar->setBackgroundColor(STATUSBAR_BK_RUNNING);
               m_pMyStatusbar->setForegroundColor(RGB(255, 255, 255));
               SetTimer(TIMER_ID_UPDATE_RUMTIME, 500, nullptr);
            }
         }
         else if (RX_CODE_EQ_ROBOT_TASK == code) {
            int exCode;
            if (pAny->getIntValue("exCode", exCode)) {
               if (exCode == ROBOT_EVENT_CREATE) {
                  SERVO::CRobotTask* pTask = theApp.m_model.getMaster().getActiveRobotTask();
                  ASSERT(pTask);
                  if (m_pRobotTaskDlg) {
                     m_pRobotTaskDlg->SetRobotTask(pTask);
                  }

                  SERVO::CEquipment* pEq1, * pEq2;
                  pEq1 = theApp.m_model.getMaster().getEquipment(pTask->getSrcPosition());
                  pEq2 = theApp.m_model.getMaster().getEquipment(pTask->getTarPosition());
                  if (pEq1 != nullptr && pEq2 != nullptr) {
                     CString strText;
                     if (theApp.m_model.getMaster().getContinuousTransferCount() > 0) {
                        strText.Format(_T("[%d]%s --> %s"),
                           theApp.m_model.getMaster().getContinuousTransferCount(),
                           pEq1->getName().c_str(), pEq2->getName().c_str());
                     }
                     else {
                        strText.Format(_T("%s --> %s"),
                           pEq1->getName().c_str(), pEq2->getName().c_str());
                     }
                     m_pMyStatusbar->setCurTaskBtnText((LPTSTR)(LPCTSTR)strText);
                  }
               }
               else if (exCode == ROBOT_EVENT_FINISH) {
                  m_pMyStatusbar->setCurTaskBtnText("无");
               }
               else if (exCode == ROBOT_EVENT_ABORT) {
                  m_pMyStatusbar->setCurTaskBtnText("无");
               }
               else if (exCode == ROBOT_EVENT_RESTORE) {
                  m_pMyStatusbar->setCurTaskBtnText("无");
               }
            }
         }
         else if (RX_CODE_LOADPORT_STATUS_CHANGED == code) {
            SERVO::CLoadPort* pLoadPort = nullptr;
            if (pAny->getPtrValue("ptr", (void*&)pLoadPort)) {
               //CPortConfigurationDlg dlg;
               //dlg.setCurSelPort(pLoadPort->getIndex());
               //dlg.DoModal();
            }
         }

         if (RX_CODE_PASSIVE_STATUS_CHANGED == code) {
            int state = 0;
            pAny->getIntValue("exCode", state);

            if (STATE::NOT_CONNECTED == state) {
               m_pMyStatusbar->setCimBtnText("Disconnected");
               //m_labelPassiveState.setBackground(DISCONNECTED_BACKGROUND);
               //m_labelPassiveState.setForeground(DISCONNECTED_FOREGROUND, TRUE);
            }
            else if (STATE::NOT_SELECTED == state) {
               m_pMyStatusbar->setCimBtnText("Not Selected");
               //m_labelPassiveState.setBackground(NOT_SELECTED_BACKGROUND);
               //m_labelPassiveState.setForeground(NOT_SELECTED_FOREGROUND, TRUE);
            }
            else if (STATE::SELECTED == state) {
               m_pMyStatusbar->setCimBtnText("Selected");
               //m_labelPassiveState.setBackground(SELECTED_BACKGROUND);
               //m_labelPassiveState.setForeground(SELECTED_FOREGROUND, TRUE);
            }
         }
         pAny->release();
      }, [&]() -> void {
         // onComplete
@@ -249,96 +337,54 @@
   SetIcon(m_hIcon, FALSE);      // 设置小图标


                           // 菜单
   // model init
   theApp.m_model.init();
   SetTimer(TIMER_ID_TEST, 1000, nullptr);

   // 菜单
   CMenu menu;
   menu.LoadMenu(IDR_MENU_APP);
   SetMenu(&menu);



   // ͼʾ
   m_pGraph = CServoGraph::Hook(GetDlgItem(IDC_SERVO_GRAPH1)->GetSafeHwnd());
   CString strPath;
   strPath.Format(_T("%s\\res\\Servo001.bmp"), (LPTSTR)(LPCTSTR)theApp.m_strAppDir);
   m_pGraph->AddImage(1, (LPTSTR)(LPCTSTR)strPath, 0, 0);

   strPath.Format(_T("%s\\res\\Robot001.bmp"), (LPTSTR)(LPCTSTR)theApp.m_strAppDir);
   m_pGraph->AddImage(IMAGE_ROBOT, (LPTSTR)(LPCTSTR)strPath, 170, 270);

   // 添加指示器
   // Bonder
   m_pGraph->AddIndicateBox(INDICATE_BONDER1, 220, 172, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_BONDER1, "10", "Bonder 1");
   m_pGraph->AddIndicateBox(INDICATE_BONDER2, 220, 516, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_BONDER2, "11", "Bonder 2");
   // toolbar
   m_pTopToolbar = new CTopToolbar();
   m_pTopToolbar->Create(IDD_TOP_TOOLBAR, this);
   m_pTopToolbar->ShowWindow(SW_SHOW);
   m_pTopToolbar->GetBtn(IDC_BUTTON_STOP)->EnableWindow(FALSE);
   m_pTopToolbar->GetBtn(IDC_BUTTON_ALARM)->EnableWindow(FALSE);
   HMENU hMenu = m_pTopToolbar->GetOperatorMenu();
   ASSERT(hMenu);
   ::EnableMenuItem(hMenu, ID_OPEATOR_SWITCH, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
   m_pTopToolbar->GetBtn(IDC_BUTTON_JOBS)->EnableWindow(TRUE);


   // 翻转
   m_pGraph->AddIndicateBox(INDICATE_FLIPER, 338, 172, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_FLIPER, "8", "Fliper");
   // Tab
   m_pPageGraph1 = new CPageGraph1();
   m_pPageGraph1->Create(IDD_PAGE_GRAPH1, this);
   m_pPageGraph2 = new CPageGraph2();
   m_pPageGraph2->Create(IDD_PAGE_GRAPH2, this);
   m_pPageRecipe = new CPageRecipe();
   m_pPageRecipe->Create(IDD_PAGE_RECIPE, this);
   m_pPageAlarm = new CPageAlarm();
   m_pPageAlarm->Create(IDD_DIALOG_ALARM, this);
   m_pPageLog = new CPageLog();
   m_pPageLog->Create(IDD_DIALOG_LOG, this);
   m_pPageTransferLog = new CPageTransferLog();
   m_pPageTransferLog->Create(IDD_PAGE_TRANSFER_LOG, this);


   // 对位
   m_pGraph->AddIndicateBox(INDICATE_ALIGNER, 428, 172, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_ALIGNER, "7", "Aligner");


   // Load port 4
   m_pGraph->AddIndicateBox(INDICATE_LPORT4, 518, 172, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_LPORT4, "4", "LPort4");


   // Load port 3
   m_pGraph->AddIndicateBox(INDICATE_LPORT3, 606, 172, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_LPORT3, "3", "LPort3");


   // Load port 2
   m_pGraph->AddIndicateBox(INDICATE_LPORT2, 690, 172, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_LPORT2, "2", "LPort2");


   // Load port 1
   m_pGraph->AddIndicateBox(INDICATE_LPORT1, 774, 172, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_LPORT1, "1", "LPort1");


   // Robot
   m_pGraph->AddIndicateBox(INDICATE_ROBOT_ARM1, 190, 294, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_ROBOT_ARM1, "5", "Robot");
   m_pGraph->AddIndicateBox(INDICATE_ROBOT_ARM2, 243, 294, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_ROBOT_ARM2, "6", "Robot");




   // Vacuum bake
   m_pGraph->AddIndicateBox(INDICATE_VACUUM_BAKE, 396, 516, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_VACUUM_BAKE, "9", "Vacuum bake");


   // Bake cooling
   m_pGraph->AddIndicateBox(INDICATE_BAKE_COOLING, 566, 516, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_BAKE_COOLING, "12", "Bake cooling");


   // 精度检
   m_pGraph->AddIndicateBox(INDICATE_MEASUREMENT, 737, 516, 48, RGB(22, 22, 22),
      RGB(255, 127, 39), EQ_BOX_OFFLINE);
   m_pGraph->SetBoxText(INDICATE_MEASUREMENT, "13", "Measurement");

   CHmTab* m_pTab = CHmTab::Hook(GetDlgItem(IDC_TAB1)->m_hWnd);
   m_pTab->SetPaddingLeft(20);
   m_pTab->SetItemMarginLeft(18);
   m_pTab->AddItem("״̬ͼ", FALSE);
   m_pTab->AddItem("连接图", TRUE);
   m_pTab->AddItem("配方", TRUE);
   m_pTab->AddItem("报警", TRUE);
   m_pTab->AddItem("日志", TRUE);
   m_pTab->AddItem("搬运", TRUE);
   m_pTab->SetCurSel(0);
   m_pTab->SetBkgndColor(RGB(222, 222, 222));
   ShowChildPage(0);


   m_pPanelMaster = new CPanelMaster();
@@ -350,6 +396,12 @@
   m_pPanelAttributes->Create(IDD_PANEL_ATTRIBUTES, this);
   

   // statusbar
   m_pMyStatusbar = new CMyStatusbar();
   m_pMyStatusbar->Create(IDD_STATUSBAR, this);
   m_pMyStatusbar->ShowWindow(SW_SHOW);



   // 调整初始窗口位置
   CRect rcWnd;
@@ -359,27 +411,25 @@
   MoveWindow((width - rcWnd.Width()) / 2, 0, rcWnd.Width(), rcWnd.Height(), TRUE);


   // model init
   theApp.m_model.init();


   SetTimer(TIMER_ID_CREATE_TERMINAL, 3000, nullptr);
   InitRxWindows();
   OnBnClickedButtonLog();
   UpdateLogBtn();
   UpdateAlarmBtn();
   Resize();


   // 相当于延时调用master的初始化
   theApp.m_model.m_master.init();
   theApp.m_model.loadPortParams();


   // 绑定数据
   {
      SERVO::CEquipment* pEquipment = theApp.m_model.m_master.getEquipment(EQ_ID_EFEM);
      m_pGraph->SetIndicateBoxData(INDICATE_ROBOT_ARM1, pEquipment);
   }
   // 初始化master以后需要控件绑定数据
   m_pPageGraph1->BindEquipmentToGraph();


   // 更新登录状态
   UpdateLoginStatus();
   //SystemLogManager::getInstance.log(SystemLogManager::LogType::Info, _T("BondEq启动..."));
   //SystemLogManager::getInstance.


   return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
@@ -526,32 +576,36 @@
   pCmdUI->Enable(TRUE);
}

void CServoDlg::OnMenuWndLog()
{
   OnBnClickedButtonLog();
}

void CServoDlg::OnUpdateMenuWndLog(CCmdUI* pCmdUI)
{
   pCmdUI->SetCheck(m_bShowLogWnd);
}

void CServoDlg::OnMenuWndAlarm()
{
   OnBnClickedButtonAlarm();
}

void CServoDlg::OnUpdateMenuWndAlarm(CCmdUI* pCmdUI)
{
   pCmdUI->SetCheck(m_bShowAlarmWnd);
}

void CServoDlg::OnMenuFileExit()
{
   PostMessage(WM_CLOSE);
}

void CServoDlg::OnUpdateMenuFileExit(CCmdUI* pCmdUI)
{
   pCmdUI->Enable(TRUE);
}

void CServoDlg::OnMenuProjectVarialbleList()
{
   CHMPropertyDlg dlg(_T("Variable | Rreport | Collection Event"), 658, 788);

   CPageCollectionEvent* pPage1 = new CPageCollectionEvent();
   pPage1->Create(IDD_PAGE_COLLECTION_EVENT);
   dlg.addPage(pPage1, "Event");

   CPageReport* pPage2 = new CPageReport();
   pPage2->Create(IDD_PAGE_REPORT);
   dlg.addPage(pPage2, "Report");

   CPageVarialbles* pPage3 = new CPageVarialbles();
   pPage3->Create(IDD_PAGE_VARIABLE);
   dlg.addPage(pPage3, "Variable");

   dlg.DoModal();
}

void CServoDlg::OnUpdateMenuProjectVarialbleList(CCmdUI* pCmdUI)
{
   pCmdUI->Enable(TRUE);
}
@@ -623,16 +677,23 @@
{
   CDialogEx::OnDestroy();

   if (m_pLogDlg != nullptr) {
      m_pLogDlg->DestroyWindow();
      delete m_pLogDlg;
      m_pLogDlg = nullptr;

   if (m_pTopToolbar != nullptr) {
      m_pTopToolbar->DestroyWindow();
      delete m_pTopToolbar;
      m_pTopToolbar = nullptr;
   }

   if (m_pAlarmDlg != nullptr) {
      m_pAlarmDlg->DestroyWindow();
      delete m_pAlarmDlg;
      m_pAlarmDlg = nullptr;
   if (m_pMyStatusbar != nullptr) {
      m_pMyStatusbar->DestroyWindow();
      delete m_pMyStatusbar;
      m_pMyStatusbar = nullptr;
   }

   if (m_pRobotTaskDlg != nullptr) {
      m_pRobotTaskDlg->DestroyWindow();
      delete m_pRobotTaskDlg;
      m_pRobotTaskDlg = nullptr;
   }

   if (m_pTerminalDisplayDlg != nullptr) {
@@ -659,6 +720,42 @@
      m_pPanelAttributes = nullptr;
   }
   
   if (m_pPageGraph1 != nullptr) {
      m_pPageGraph1->DestroyWindow();
      delete m_pPageGraph1;
      m_pPageGraph1 = nullptr;
   }

   if (m_pPageGraph2 != nullptr) {
      m_pPageGraph2->DestroyWindow();
      delete m_pPageGraph2;
      m_pPageGraph2 = nullptr;
   }

   if (m_pPageRecipe != nullptr) {
      m_pPageRecipe->DestroyWindow();
      delete m_pPageRecipe;
      m_pPageRecipe = nullptr;
   }

   if (m_pPageAlarm != nullptr) {
      m_pPageAlarm->DestroyWindow();
      delete m_pPageAlarm;
      m_pPageAlarm = nullptr;
   }

   if (m_pPageLog != nullptr) {
      m_pPageLog->DestroyWindow();
      delete m_pPageLog;
      m_pPageLog = nullptr;
   }

   if (m_pPageTransferLog != nullptr) {
      m_pPageTransferLog->DestroyWindow();
      delete m_pPageTransferLog;
      m_pPageTransferLog = nullptr;
   }

   if (m_hbrBkgnd != nullptr) {
      ::DeleteObject(m_hbrBkgnd);
   }
@@ -670,271 +767,74 @@

}

void CServoDlg::OnBnClickedButtonAlarm()
{
   m_bShowAlarmWnd = !m_bShowAlarmWnd;

   // 如果要显示报警窗口，则隐藏日志窗口
   if (m_bShowLogWnd) {
      m_bShowLogWnd = false;
      if (m_pLogDlg != nullptr) {
         m_pLogDlg->ShowWindow(SW_HIDE);
         UpdateLogBtn();
      }
   }

   if (m_pAlarmDlg == nullptr) {
      m_pAlarmDlg = new CAlarmDlg();
      m_pAlarmDlg->Create(IDD_DIALOG_ALARM, this);

      CRect rcWnd;
      GetWindowRect(&rcWnd);
      int nHeight = GetSystemMetrics(SM_CYSCREEN) - rcWnd.bottom - 38;
      if (nHeight < 280) nHeight = 280;
      m_pAlarmDlg->MoveWindow(rcWnd.left, rcWnd.bottom - 8, rcWnd.Width(), nHeight);
   }
   ASSERT(m_pAlarmDlg);
   m_pAlarmDlg->ShowWindow(m_bShowAlarmWnd ? SW_SHOW : SW_HIDE);

   UpdateAlarmBtn();
}

void CServoDlg::OnBnClickedButtonLog()
{
   m_bShowLogWnd = !m_bShowLogWnd;

   // 如果要显示日志窗口，则隐藏报警窗口
   if (m_bShowLogWnd) {
      m_bShowAlarmWnd = false;
      if (m_pAlarmDlg != nullptr) {
         m_pAlarmDlg->ShowWindow(SW_HIDE);
         UpdateAlarmBtn();
      }
   }

   if (m_pLogDlg == nullptr) {
      m_pLogDlg = new CLogDlg();
      m_pLogDlg->Create(IDD_DIALOG_LOG, this);

      CRect rcWnd;
      GetWindowRect(&rcWnd);
      int nHeight = GetSystemMetrics(SM_CYSCREEN) - rcWnd.bottom - 38;
      if (nHeight < 280) nHeight = 280;
      m_pLogDlg->MoveWindow(rcWnd.left, rcWnd.bottom - 8, rcWnd.Width(), nHeight);
   }
   ASSERT(m_pLogDlg);
   m_pLogDlg->ShowWindow(m_bShowLogWnd ? SW_SHOW : SW_HIDE);
	
   UpdateLogBtn();
}

void CServoDlg::UpdateLogBtn()
{
   m_btnLog.SetFrameColor(BS_NORMAL, BTN_LOG_FRAME_NORMAL);
   m_btnLog.SetFrameColor(BS_HOVER, BTN_LOG_FRAME_HOVER);
   m_btnLog.SetFrameColor(BS_PRESS, BTN_LOG_FRAME_PRESS);
   m_btnLog.SetBkgndColor(BS_NORMAL, m_bShowLogWnd ? BTN_LOG_BKGND_PRESS : BTN_LOG_BKGND_NORMAL);
   m_btnLog.SetBkgndColor(BS_HOVER, BTN_LOG_BKGND_HOVER);
   m_btnLog.SetBkgndColor(BS_PRESS, BTN_LOG_BKGND_PRESS);
   m_btnLog.Invalidate();
}

void CServoDlg::UpdateAlarmBtn()
{
   m_btnAlarm.SetFrameColor(BS_NORMAL, BTN_ALARM_FRAME_NORMAL);
   m_btnAlarm.SetFrameColor(BS_HOVER, BTN_ALARM_FRAME_HOVER);
   m_btnAlarm.SetFrameColor(BS_PRESS, BTN_ALARM_FRAME_PRESS);
   m_btnAlarm.SetBkgndColor(BS_NORMAL, m_bShowAlarmWnd ? BTN_ALARM_BKGND_PRESS : BTN_ALARM_BKGND_NORMAL);
   m_btnAlarm.SetBkgndColor(BS_HOVER, BTN_ALARM_BKGND_HOVER);
   m_btnAlarm.SetBkgndColor(BS_PRESS, BTN_ALARM_BKGND_PRESS);
   m_btnAlarm.Invalidate();
}

void CServoDlg::UpdateRobotPosition(float percentage)
{
   // 限制百分比范围在 [0, 1] 之间
   if (percentage < 0.0f) percentage = 0.0f;
   if (percentage > 1.0f) percentage = 1.0f;

   // 根据百分比计算目标 X 坐标
   int startX = m_pGraph->GetImage(IMAGE_ROBOT)->x;
   int endX = static_cast<int>(170 + percentage * (700 - 170));

   int arm1Offset = 20;  // 从图片到ARM1的偏移
   int arm2Offset = 73;  // 从图片到ARM2的偏移

   // 计算移动所需的时间
   int distance = abs(endX - startX);
   int duration = static_cast<int>((distance / 100.0) * 1000);

   auto startTime = std::chrono::steady_clock::now();
   auto endTime = startTime + std::chrono::milliseconds(duration);

   // 开始移动，设置标记
   m_bIsRobotMoving = TRUE;

   // 开始平滑移动
   while (std::chrono::steady_clock::now() < endTime) {
      auto currentTime = std::chrono::steady_clock::now();
      float progress = std::chrono::duration<float, std::milli>(currentTime - startTime).count() / duration;
      progress = min(progress, 1.0f);

      // 根据进度计算当前位置
      int currentX = static_cast<int>(startX + progress * (endX - startX));
      m_pGraph->UpdateImageCoordinates(IMAGE_ROBOT, currentX, 270);
      m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, currentX + arm1Offset, 294);
      m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, currentX + arm2Offset, 294);

      // 刷新界面
      Invalidate();
      UpdateWindow();

      // 控制帧率约为 60 FPS
      std::this_thread::sleep_for(std::chrono::milliseconds(16));
   }

   // 确保最后位置精确到目标位置
   m_pGraph->UpdateImageCoordinates(IMAGE_ROBOT, endX, 270);
   m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, endX + arm1Offset, 294);
   m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, endX + arm2Offset, 294);

   // 界面重绘
   Invalidate();

   // 动画结束，设置标记
   m_bIsRobotMoving = FALSE;
}

void CServoDlg::RotateRobot(float angleInDegrees)
{
   // 将角度转换为弧度
   float angleInRadians = static_cast<float>(std::acos(-1)) / 180.0f * angleInDegrees;

   // 获取机器人图片的当前坐标和中心
   auto* pImage = m_pGraph->GetImage(IMAGE_ROBOT);
   if (!pImage) return;

   // 更新 Rotate 图片的角度，确保角度保持在 [0, 360) 范围内
   m_pGraph->UpdateImageAngle(IMAGE_ROBOT, static_cast<float>(fmod(pImage->angle + angleInDegrees + 360, 360)));

   int cx = pImage->x + pImage->bmWidth / 2;  // 图片中心 X
   int cy = pImage->y + pImage->bmHeight / 2; // 图片中心 Y

   // 旋转指示框的坐标
   auto* pRobot1 = m_pGraph->GetIndicateBox(INDICATE_ROBOT_ARM1);
   auto* pRobot2 = m_pGraph->GetIndicateBox(INDICATE_ROBOT_ARM2);

   if (pRobot1 && pRobot2) {
      int newArmX1 = pImage->x + 20;
      int newArmY1 = 294;

      int newArmX2 = pImage->x + 73;
      int newArmY2 = 294;

      if (angleInDegrees != 0.0f) {
         // 计算指示框1的新坐标
         newArmX1 = static_cast<int>(cx + (pRobot1->x - cx) * cos(angleInRadians) - (pRobot1->y - cy) * sin(angleInRadians));
         newArmY1 = static_cast<int>(cy + (pRobot1->x - cx) * sin(angleInRadians) + (pRobot1->y - cy) * cos(angleInRadians));

         // 计算指示框2的新坐标
         newArmX2 = static_cast<int>(cx + (pRobot2->x - cx) * cos(angleInRadians) - (pRobot2->y - cy) * sin(angleInRadians));
         newArmY2 = static_cast<int>(cy + (pRobot2->x - cx) * sin(angleInRadians) + (pRobot2->y - cy) * cos(angleInRadians));
      }

      // 更新指示框的位置
      m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM1, newArmX1, newArmY1);
      m_pGraph->UpdateIndicateBoxCoordinates(INDICATE_ROBOT_ARM2, newArmX2, newArmY2);
   }

   // 强制重绘界面
   Invalidate();
}

void CServoDlg::UpdateDeviceStatus(int id, DeviceStatus status)
{
   // 根据状态设置颜色
   COLORREF newBackgroundColor;
   COLORREF newFrameColor1;
   COLORREF newFrameColor2;

   switch (status) {
   case ONLINE:
      newBackgroundColor = EQ_BOX_ONLINE;
      newFrameColor1 = EQ_BOX_FRAME1;
      newFrameColor2 = EQ_BOX_FRAME2;
      break;
   case OFFLINE:
      newBackgroundColor = RGB(222, 222, 222);
      newFrameColor1 = EQ_BOX_FRAME1;
      newFrameColor2 = EQ_BOX_FRAME2;
      break;
   default:
      newBackgroundColor = RGB(255, 255, 255); // 默认白色背景
      newFrameColor1 = RGB(0, 0, 0);           // 默认黑色框架1
      newFrameColor2 = RGB(0, 0, 0);           // 默认黑色框架2
      break;
   }

   m_pGraph->UpdateIndicateBox1Colors(id, newBackgroundColor, newFrameColor1, newFrameColor2);

   // 刷新界面
   Invalidate();
   UpdateWindow();
}

void CServoDlg::OnSize(UINT nType, int cx, int cy)
{
   CDialogEx::OnSize(nType, cx, cy);
   if (GetDlgItem(IDC_SERVO_GRAPH1) == nullptr) return;
   if (GetDlgItem(IDC_TAB1) == nullptr) return;
   if (m_pPageGraph1 == nullptr) return;
   if (m_pPageGraph2 == nullptr) return;
   if (m_pPageRecipe == nullptr) return;
   if (m_pPageAlarm == nullptr) return;
   if (m_pPageLog == nullptr) return;
   if (m_pPageTransferLog == nullptr) return;
	
   Resize();
   Invalidate();
}

#define TOOLBAR_HEIGHT      78
#define STATUSBAR_HEIGHT   38
void CServoDlg::Resize()
{
   CRect rcClient, rcItem;
   CWnd* pItem = nullptr;
   int x, y;
   int x, y, y2;
   GetClientRect(&rcClient);

   x = 0;
   y = 0;
   y2 = rcClient.bottom - STATUSBAR_HEIGHT;
   m_pTopToolbar->MoveWindow(0, 0, rcClient.Width(), TOOLBAR_HEIGHT);
   y += TOOLBAR_HEIGHT;


	

   int nPanelWidth = 0;
   if (m_pPanelMaster != nullptr) {
      nPanelWidth = m_pPanelMaster->getPanelWidth();
      m_pPanelMaster->MoveWindow(x, y, nPanelWidth, rcClient.Height());
      m_pPanelMaster->MoveWindow(x, y, nPanelWidth, y2 - y);
      x += nPanelWidth;
   }

   if (m_pPanelEquipment != nullptr && m_pPanelEquipment->IsWindowVisible()) {
      nPanelWidth = m_pPanelEquipment->getPanelWidth();
      m_pPanelEquipment->MoveWindow(x, y, nPanelWidth, rcClient.Height());
      m_pPanelEquipment->MoveWindow(x, y, nPanelWidth, y2 - y);
      x += nPanelWidth;
   }

   if (m_pPanelAttributes != nullptr && m_pPanelAttributes->IsWindowVisible()) {
      nPanelWidth = m_pPanelAttributes->getPanelWidth();
      m_pPanelAttributes->MoveWindow(x, y, nPanelWidth, rcClient.Height());
      m_pPanelAttributes->MoveWindow(x, y, nPanelWidth, y2 - y);
      x += nPanelWidth;
   }

   pItem = GetDlgItem(IDC_SERVO_GRAPH1);
   pItem->GetClientRect(&rcItem);
   pItem->MoveWindow(x, y, rcItem.Width(), rcItem.Height());

   pItem = GetDlgItem(IDC_TAB1);
   pItem->GetWindowRect(rcItem);
   pItem->MoveWindow(x, y, rcClient.Width() - x, rcItem.Height());
   y += rcItem.Height();
   y += 8;

   x = rcClient.right - 8;
   pItem = GetDlgItem(IDC_BUTTON_LOG);
   pItem->GetClientRect(&rcItem);
   x -= rcItem.Width();
   pItem->MoveWindow(x, rcClient.bottom - 8 - rcItem.Height(), rcItem.Width(), rcItem.Height());
   x -= 8;

   pItem = GetDlgItem(IDC_BUTTON_ALARM);
   pItem->GetClientRect(&rcItem);
   x -= rcItem.Width();
   pItem->MoveWindow(x, rcClient.bottom - 8 - rcItem.Height(), rcItem.Width(), rcItem.Height());
   m_pPageGraph1->MoveWindow(x, y, rcClient.Width() - x, y2 - y);
   m_pPageGraph2->MoveWindow(x, y, rcClient.Width() - x, y2 - y);
   m_pPageRecipe->MoveWindow(x, y, rcClient.Width() - x, y2 - y);
   m_pPageAlarm->MoveWindow(x, y, rcClient.Width() - x, y2 - y);
   m_pPageLog->MoveWindow(x, y, rcClient.Width() - x, y2 - y);
   m_pPageTransferLog->MoveWindow(x, y, rcClient.Width() - x, y2 - y);


   m_pMyStatusbar->MoveWindow(0, y2, rcClient.Width(), STATUSBAR_HEIGHT);
}

void CServoDlg::OnClose()
@@ -944,32 +844,6 @@
   CDialogEx::OnClose();
}

LRESULT CServoDlg::OnLogDlgHide(WPARAM wParam, LPARAM lParam)
{
   m_bShowLogWnd = FALSE;
   UpdateLogBtn();
   LOGE("OnLogDlgHide");

   unsigned int DATAID, RPTID;
   DATAID = 111;
   RPTID = 1001;
   std::vector<std::string> v;
   v.push_back("abc");
   v.push_back("def");
   theApp.m_model.m_hsmsPassive.requestEventReportSend(DATAID, RPTID, v);

   return 0;
}

LRESULT CServoDlg::OnAlarmDlgHide(WPARAM wParam, LPARAM lParam)
{
   m_bShowAlarmWnd = FALSE;
   UpdateAlarmBtn();
   LOGE("OnAlarmDlgHide");

   return 0;
}

void CServoDlg::OnMoving(UINT fwSide, LPRECT pRect)
{
   CDialogEx::OnMoving(fwSide, pRect);
@@ -977,17 +851,6 @@

void CServoDlg::OnMove(int x, int y)
{
   if (m_pLogDlg != nullptr && !m_pLogDlg->IsZoomed()) {
      CRect rcWnd;
      GetWindowRect(&rcWnd);
      m_pLogDlg->SetWindowPos(nullptr, rcWnd.left, rcWnd.bottom - 8, 0, 0, SWP_NOSIZE);
   }

   if (m_pAlarmDlg != nullptr && !m_pAlarmDlg->IsZoomed()) {
      CRect rcWnd;
      GetWindowRect(&rcWnd);
      m_pAlarmDlg->SetWindowPos(nullptr, rcWnd.left, rcWnd.bottom - 8, 0, 0, SWP_NOSIZE);
   }

   CDialogEx::OnMove(x, y);
}
@@ -1010,40 +873,256 @@
      m_pTerminalDisplayDlg->Create(IDD_DIALOG_TERMINAL_DISPLAY, this);
   }

   if (TIMER_ID_UPDATE_RUMTIME == nIDEvent) {
      static int index = 0; index++;
      if (index >= 4) index = 0;
      static char* status[] = {"|", "/", "--", "\\"};

      CString strText;
      GetRuntimeFormatText(strText, status[index]);
      m_pMyStatusbar->setRunTimeText((LPTSTR)(LPCTSTR)strText);
   }

   else if(TIMER_ID_TEST == nIDEvent){
      static __int64 tttt = 0;
      tttt++;
      theApp.m_model.m_hsmsPassive.setVariableValue("CJobSpace", tttt % 10);
      theApp.m_model.m_hsmsPassive.setVariableValue("PJobSpace", tttt % 5);
   }


   CDialogEx::OnTimer(nIDEvent);
}


BOOL CServoDlg::OnEraseBkgnd(CDC* pDC)
{
   // TODO: 在此添加消息处理程序代码和/或调用默认值
   if (m_bIsRobotMoving) {
      // 禁止刷新背景，避免闪烁
      return TRUE;
   }
	
   return CDialogEx::OnEraseBkgnd(pDC);
}

void CServoDlg::OnGraphItemClicked(NMHDR* pNMHDR, LRESULT* pResult)
{
   BYSERVOGRAPH_NMHDR* pGraphNmhdr = reinterpret_cast<BYSERVOGRAPH_NMHDR*>(pNMHDR);
   CString s; s.Format(_T("OnGraphItemClicked %d"), pGraphNmhdr->dwData);
   SERVO::CEquipment* pEquipment = (SERVO::CEquipment*)m_pGraph->GetIndicateBoxData(pGraphNmhdr->dwData);
   if (pEquipment != nullptr) {
      AfxMessageBox(pEquipment->getName().c_str());
   }
	
	
   *pResult = 0;
}

LRESULT CServoDlg::OnPanelResize(WPARAM wParam, LPARAM lParam)
{
   int width = wParam;
   int width = (int)wParam;
   // m_pPanel->SetPanelWidth(width);
   Resize();

   return 0;
}

void CServoDlg::OnTabSelChanged(NMHDR* nmhdr, LRESULT* result)
{
   BYHMTAB_NMHDR* pNmhdrex = (BYHMTAB_NMHDR*)nmhdr;
   ShowChildPage((int)pNmhdrex->dwData);

   *result = 0;
}

void CServoDlg::ShowChildPage(int index)
{
   ASSERT(0 <= index && index < 6);
   static CWnd* pPages[] = { m_pPageGraph1, m_pPageGraph2, m_pPageRecipe, m_pPageAlarm, m_pPageLog, m_pPageTransferLog };
   for (int i = 0; i < 6; i++) {
      pPages[i]->ShowWindow(i == index ? SW_SHOW : SW_HIDE);
   }
}

void CServoDlg::UpdateLoginStatus()
{
   HMENU hMenu = m_pTopToolbar->GetOperatorMenu();
   UserManager& userManager = UserManager::getInstance();
   if (userManager.isLoggedIn())
   {
      ::EnableMenuItem(hMenu, ID_OPEATOR_LOGIN, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
      ::EnableMenuItem(hMenu, ID_OPERATOR_CHANGE_PASSWORD, MF_BYCOMMAND | MF_ENABLED);
      ::EnableMenuItem(hMenu, ID_OPERATOR_SYSTEM_LOG, MF_BYCOMMAND | MF_ENABLED);
      ::EnableMenuItem(hMenu, ID_OPEATOR_SWITCH, MF_BYCOMMAND | MF_ENABLED);
      ::EnableMenuItem(hMenu, ID_OPERATOR_LOGOUT, MF_BYCOMMAND | MF_ENABLED);

      if (userManager.getCurrentUserRole() == UserRole::SuperAdmin) {
         ::EnableMenuItem(hMenu, ID_OPEATOR_USER_MANAGER, MF_BYCOMMAND | MF_ENABLED);
      }
      else {
         ::EnableMenuItem(hMenu, ID_OPEATOR_USER_MANAGER, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
      }

      m_pTopToolbar->SetOperatorBtnText(userManager.getCurrentUser().c_str());
   }
   else {
      ::EnableMenuItem(hMenu, ID_OPEATOR_LOGIN, MF_BYCOMMAND | MF_ENABLED);
      ::EnableMenuItem(hMenu, ID_OPERATOR_CHANGE_PASSWORD, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
      ::EnableMenuItem(hMenu, ID_OPEATOR_USER_MANAGER, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
      ::EnableMenuItem(hMenu, ID_OPERATOR_SYSTEM_LOG, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
      ::EnableMenuItem(hMenu, ID_OPEATOR_SWITCH, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
      ::EnableMenuItem(hMenu, ID_OPERATOR_LOGOUT, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);

      m_pTopToolbar->SetOperatorBtnText(_T("未登录"));
   }
}

LRESULT CServoDlg::OnToolbarBtnClicked(WPARAM wParam, LPARAM lParam)
{
   int id = (int)lParam;
   if (id == IDC_BUTTON_RUN) {
      if (theApp.m_model.getMaster().getState() == SERVO::MASTERSTATE::MSERROR) {
         AfxMessageBox("当前有机台发生错误，不能启动，请确认解决问题后再尝试重新启动！");
      }
      else {
         if (theApp.m_model.getMaster().start() == 0) {
            m_pTopToolbar->GetBtn(IDC_BUTTON_RUN)->EnableWindow(FALSE);
            m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_BATCH)->EnableWindow(FALSE);
            m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_CT)->EnableWindow(FALSE);
         }
      }
   }
   else if (id == IDC_BUTTON_RUN_BATCH) {
      if (theApp.m_model.getMaster().getState() == SERVO::MASTERSTATE::MSERROR) {
         AfxMessageBox("当前有机台发生错误，不能启动，请确认解决问题后再尝试重新启动！");
      }
      else {
         if (theApp.m_model.getMaster().startBatch() == 0) {
            m_pTopToolbar->GetBtn(IDC_BUTTON_RUN)->EnableWindow(FALSE);
            m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_BATCH)->EnableWindow(FALSE);
            m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_CT)->EnableWindow(FALSE);
         }
      }
   }
   else if (id == IDC_BUTTON_RUN_CT) {
      if (theApp.m_model.getMaster().getState() == SERVO::MASTERSTATE::MSERROR) {
         AfxMessageBox("当前有机台发生错误，不能启动，请确认解决问题后再尝试重新启动！");
      }
      else {
         if (theApp.m_model.getMaster().startContinuousTransfer() == 0) {
            m_pTopToolbar->GetBtn(IDC_BUTTON_RUN)->EnableWindow(FALSE);
            m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_BATCH)->EnableWindow(FALSE);
            m_pTopToolbar->GetBtn(IDC_BUTTON_RUN_CT)->EnableWindow(FALSE);
         }
      }
   }
   else if (id == IDC_BUTTON_STOP) {
      if (theApp.m_model.getMaster().stop() == 0) {
         m_pTopToolbar->GetBtn(IDC_BUTTON_STOP)->EnableWindow(FALSE);
      }
   }
   else if (id == IDC_BUTTON_JOBS) {
      CControlJobDlg dlg;
      dlg.SetControlJob(theApp.m_model.m_master.getControlJob());
      dlg.DoModal();
   }
   else if (id == IDC_BUTTON_PORT_CONFIG) {
      CPortConfigurationDlg dlg;
      dlg.DoModal();
   }
   else if (id == IDC_BUTTON_ROBOT) {
      theApp.m_model.getMaster().clearError();
      SERVO::CEFEM* pEFEM = (SERVO::CEFEM*)theApp.m_model.getMaster().getEquipment(EQ_ID_EFEM);
      CRobotCmdTestDlg dlg;
      dlg.SetEFEM(pEFEM);
      dlg.DoModal();
   }
   else if (id == IDC_BUTTON_SETTINGS) {
      SERVO::CEquipment* pEq = theApp.m_model.m_master.getEquipment(EQ_ID_EFEM);
      ((SERVO::CEFEM*)pEq)->printDebugRobotState();
      pEq->printDebugString001();
      pEq = theApp.m_model.m_master.getEquipment(EQ_ID_Bonder1);
      pEq->printDebugString001();
      pEq = theApp.m_model.m_master.getEquipment(EQ_ID_Bonder2);
      pEq->printDebugString001();

   }
   else if (id == IDC_BUTTON_OPERATOR) {
      int menuId = (int)wParam;
      SystemLogManager& logManager = SystemLogManager::getInstance();
      UserManager& userManager = UserManager::getInstance();
      if (menuId == 0) {
         CLoginDlg loginDlg;
         loginDlg.DoModal();
      }
      else if (1 == menuId) {
         CChangePasswordDlg changePasswordDlg;
         changePasswordDlg.DoModal();
      }
      else if (2 == menuId) {
         CUserManagerDlg dlg;
         if (dlg.DoModal() != IDOK) {
            logManager.log(SystemLogManager::LogType::Operation, _T("用户管理的预操作被取消！"));
         }
      }
      else if (3 == menuId) {
         CSystemLogManagerDlg dlg;
         dlg.DoModal();
      }
      else if (4 == menuId) {
         int ret = AfxMessageBox(_T("是否切换用户？切换用户会退出当前账号！"), MB_OKCANCEL | MB_ICONEXCLAMATION);
         if (ret != IDOK) {
            return 0;
         }

         logManager.log(SystemLogManager::LogType::Operation, _T("确认切换角色！"));
         if (userManager.isLoggedIn()) {
            logManager.log(SystemLogManager::LogType::Info, _T("退出登录！"));
            userManager.logout();
         }

         CLoginDlg loginDlg;
         loginDlg.DoModal();
      }
      else {
         CString cstrMessage;
         cstrMessage.Format(_T("是否退出用户 [%s]？"), userManager.getCurrentUser().c_str());
         int ret = AfxMessageBox(_T(cstrMessage), MB_OKCANCEL | MB_ICONEXCLAMATION);
         if (ret != IDOK) {
            return 0;
         }

         logManager.log(SystemLogManager::LogType::Info, _T("退出登录！"));
         userManager.logout();
      }

      UpdateLoginStatus();
   }

   return 0;
}

LRESULT CServoDlg::OnStatusbarBtnClicked(WPARAM wParam, LPARAM lParam)
{
   int id = (int)lParam;
   int x = (int)wParam;
   if (id == IDC_BUTTON_ROBOTTASK) {
      if (m_pRobotTaskDlg == nullptr) {
         m_pRobotTaskDlg = new CRobotTaskDlg();
         m_pRobotTaskDlg->Create(IDD_DIALOG_ROBOT_TASK, this);
      }

      CRect rcBar;
      int h = 258;
      int w = 388;
      m_pRobotTaskDlg->SetRobotTask(theApp.m_model.getMaster().getActiveRobotTask());
      m_pMyStatusbar->GetWindowRect(rcBar);
      m_pRobotTaskDlg->MoveWindow(x, rcBar.top - h, w, h);
      m_pRobotTaskDlg->ShowWindow(SW_SHOW);
   }
   else if (id == IDC_BUTTON_CIM) {
      AfxMessageBox("IDC_BUTTON_CIM");
   }
   return 0;
}

CString& CServoDlg::GetRuntimeFormatText(CString& strText, const char* pszSuffix)
{
   ULONGLONG ullRunTime = (ULONGLONG)(theApp.m_model.getMaster().getRunTime() * 0.001);
   int h, m, s;
   h = int(ullRunTime / 3600);
   m = int((ullRunTime % 3600) / 60);
   s = int(ullRunTime % 60);

   SERVO::MASTERSTATE state = theApp.m_model.getMaster().getState();
   if (state == SERVO::MASTERSTATE::RUNNING) {
      strText.Format(_T("正在运行：%02d:%02d:%02d   %s"), h, m, s, pszSuffix);
   }
   else if (state == SERVO::MASTERSTATE::RUNNING_CONTINUOUS_TRANSFER) {
      strText.Format(_T("千传模式：%02d:%02d:%02d   %s"), h, m, s, pszSuffix);
   }
   else if (state == SERVO::MASTERSTATE::RUNNING_BATCH) {
      strText.Format(_T("JOB模式：%02d:%02d:%02d   %s"), h, m, s, pszSuffix);
   }
   else {
      strText.Format(_T("已运行：%02d:%02d:%02d   %s"), h, m, s, pszSuffix);
   }

   return strText;
}