SDC/A5_QD_CF_REVIEW.git

#include "StdAfx.h"
#include "SignalControl_NetServer.h"
#include "SignalControl_Network.h"
#include "IOCPNetwork/NetServer.h"
#include "CHAutoDrsConnector/AutoDrsConnectorInfo.h"
 
using namespace CHSignalControls_Network;
 
CSignalControl_NetServer::CSignalControl_NetServer(ISignalControl_NetServer2Parent* pISCNS2P) : m_pISCNS2P(pISCNS2P)
{
    m_pMessageProcessor = new CMessageProcessor(static_cast<IMessageProcessor2Parent*>(this));
    m_pNetServer = new CNetServer();
    //InitNetwork();
}
 
CSignalControl_NetServer::~CSignalControl_NetServer(void)
{
    //DeinitNetwork();
 
    if (m_pNetServer)
    {
        delete m_pNetServer;
        m_pNetServer = NULL;
    }
 
    if (m_pMessageProcessor)
    {
        delete m_pMessageProcessor;
        m_pMessageProcessor = NULL;
    }
}
 
BOOL CSignalControl_NetServer::InitNetwork()
{
    BOOL bResult = FALSE;
 
    if (m_pNetServer)
    {
        const int nClientCount = 4;
        m_pNetServer->SetIN2P(static_cast<IIOCPNetwork2Parent*>(this));
        m_pNetServer->SetClientInfo(Socket_SignalClient, nClientCount, NETCODE_NETWORK_SIGNAL, NETVER_NETWORK_SIGNAL, FALSE,1004);
 
        bResult = m_pNetServer->InitNetwork(ServerMode, nClientCount, NETPORT_NETWORK_SIGNAL, _T(""), TRUE);
    }
 
    if (m_pISCNS2P)
    {
        if (bResult)
        {
            m_pISCNS2P->ISCNS2P_DisplayMessage(_T("[SignalControl_NetServer] Init NetServer Success!"));
        }
        else
        {
            m_pISCNS2P->ISCNS2P_DisplayMessage(_T("[SignalControl_NetServer] Init NetServer Fail!"));
        }
    }
 
    return bResult;
}
 
void CSignalControl_NetServer::DeinitNetwork()
{
    if (m_pNetServer==NULL) return;
 
    m_pNetServer->DeinitNetwork();
    m_pNetServer->CleanUp();
}
 
void CHSignalControls_Network::CSignalControl_NetServer::IOCPNet2P_Connected( int Type )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_DisplayMessage(_T("[SignalControl_NetServer] [%d]TypeClient is Connected!"), Type);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::IOCPNet2P_Disconnected( int Type, int nModuleNo /*= -1*/ )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_DisplayMessage(_T("[SignalControl_NetServer] [%d]Client is Disconnected!"), nModuleNo);
    }
}
 
BOOL CHSignalControls_Network::CSignalControl_NetServer::IOCPNet2P_Received( int Type, CNetPacket* pPacket, int nContext /*= -1*/ )
{
    CSingleLock myLock(&m_csReceivePacket);
    myLock.Lock();
    
    if (m_pMessageProcessor==NULL) return FALSE;
 
    if (pPacket==NULL)  return FALSE;
 
    switch(Type)    
    {
    case Socket_SignalClient:
        {
            CNetPacket* pCopyPacket = new CNetPacket(pPacket); // copy
            m_pMessageProcessor->AddMessageProcessData(pPacket->GetPacketCode(),(WPARAM)pCopyPacket,(LPARAM)nContext);
        }
        break;
 
    default:
        return FALSE;
        break;
    }
 
    return TRUE;
}
 
void CSignalControl_NetServer::IMP2P_ProcessMessageData( CMessageProcessData* pData )
{
    if (pData==NULL) return;
 
    if (m_pISCNS2P==NULL) return;
 
    CNetPacket *pPacket = (CNetPacket*)pData->m_wParam;
    int nContext = (int)pData->m_lParam;
 
    CString strLog = _T("");
 
    switch(pData->m_unMsg)
    {
    case SC2SS_MODULE_INDEX:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [MODULE_INDEX] Message Received!"), pPacket->GetModuleNo());
        Process_ModuleIndex(pPacket->GetModuleNo(), nContext);
        break;
 
    case SC2SS_COMMAND_LIGHT:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_LIGHT] Message Received!"), pPacket->GetModuleNo());
        Process_CommandLight(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_COMMAND_LENS:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_LENS] Message Received!"), pPacket->GetModuleNo());
        Process_CommandLens(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_COMMAND_MOTOR_GO:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_MOTOR_GO] Message Received!"), pPacket->GetModuleNo());
        Process_CommandMotorGo(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_COMMAND_GLASS_GO:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_GLASS_GO] Message Received!"), pPacket->GetModuleNo());
        Process_CommandGlassGo(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_COMMAND_JOG:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_JOG] Message Received!"), pPacket->GetModuleNo());
        Process_CommandJog(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_COMMAND_JOG_SPEED:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_JOG_SPEED] Message Received!"), pPacket->GetModuleNo());
        Process_CommandJogSpeed(pPacket->GetModuleNo(), pPacket);
        break;
        
    case SC2SS_COMMAND_AFM:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_AFM] Message Received!"), pPacket->GetModuleNo());
        Process_CommandAfm(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_COMMAND_AFM_JOG:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_AFM_JOG] Message Received!"), pPacket->GetModuleNo());
        Process_CommandAfmJog(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_COMMAND_AFM_JOG_SPEED:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_AFM_SPEED] Message Received!"), pPacket->GetModuleNo());
        Process_CommandAfmJogSpeed(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_COMMAND_AFM_HOME:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [COMMAND_AFM_HOME] Message Received!"), pPacket->GetModuleNo());
        Process_CommandAfmHome(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_ACK_STATUS_LIGHT:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_LIGHT] Message Received!"), pPacket->GetModuleNo());
        Process_AckStatusLight(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_ACK_STATUS_LENS:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_LENS] Message Received!"), pPacket->GetModuleNo());
        Process_AckStatusLens(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_ACK_STATUS_MODULE_POS:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_MODULE_POS] Message Received!"), pPacket->GetModuleNo());
        Process_AckStatusModulePos(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_ACK_STATUS_JOG_SPEED:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_JOG_SPEED] Message Received!"), pPacket->GetModuleNo());
        Process_AckStatusJogSpeed(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_ACK_STATUS_AFM:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_STATUS_AFM] Message Received!"), pPacket->GetModuleNo());
        Process_AckStatusAfm(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_ACK_COMMAND_LOADING:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_COMMAND_LOADING] Message Received!"), pPacket->GetModuleNo());
        Process_AckCommandLoading(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_ACK_COMMAND_REVIEWRESULT:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_COMMAND_REVIEWRESULT] Message Received!"), pPacket->GetModuleNo());
        Process_AckCommandReviewResult(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_ACK_COMMAND_PLANSTART:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_COMMAND_PLANSTART] Message Received!"), pPacket->GetModuleNo());
        Process_AckCommandPlanStart(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_ACK_COMMAND_PLANEND:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [ACK_COMMAND_PLANEND] Message Received!"), pPacket->GetModuleNo());
        Process_AckCommandPlanEnd(pPacket->GetModuleNo(), pPacket);
        break;
 
    case SC2SS_STATUS_REVIEWRESULT:
        strLog.Format(_T("[SignalControl_NetServer] [%d]Client [STATUS_REVIEWRESULT] Message Received!"), pPacket->GetModuleNo());
        Process_StatusReviewResult(pPacket->GetModuleNo(), pPacket);
        break;
    }
 
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_DisplayMessage(strLog);
    }
 
    delete pPacket;
}
 
void CSignalControl_NetServer::Process_ModuleIndex(int nModuleIndex, int nContext)
{
    if (m_pISCNS2P==NULL || m_pNetServer==NULL) return;
 
    CNetJoiner* pJoiner = NULL;
    int nClientCount= m_pNetServer->GetClientCount();
    for (int i = 0; i < nClientCount; i++)
    {
        pJoiner = m_pNetServer->GetJoinerArray(i);
        if (pJoiner && reinterpret_cast<int>(pJoiner->GetSocketContext()) == nContext)
        {
            pJoiner->SetModuleNo(nModuleIndex, FALSE);
            return;
        }
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandLight( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_LIGHT, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nLevel = pPacket->GetInt(0);
        m_pISCNS2P->ISCNS2P_CommandLight(nModuleIndex, nLevel);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandLens( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_LENS, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nLevel = pPacket->GetInt(0);
        m_pISCNS2P->ISCNS2P_CommandLens(nModuleIndex, nLevel);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandMotorGo( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_MOTOR_GO, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nPosUmX = pPacket->GetInt(0);
        int nPosUmY = pPacket->GetInt(1);
        m_pISCNS2P->ISCNS2P_CommandMotorGo(nModuleIndex, nPosUmX, nPosUmY);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandGlassGo( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_GLASS_GO, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nPosUmX = pPacket->GetInt(0);
        int nPosUmY = pPacket->GetInt(1);
        m_pISCNS2P->ISCNS2P_CommandGlassGo(nModuleIndex, nPosUmX, nPosUmY);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandJog( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_JOG, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nJog = pPacket->GetInt(0);
        m_pISCNS2P->ISCNS2P_CommandJog(nModuleIndex, nJog);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandJogSpeed( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_JOG_SPEED, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nSpeed = pPacket->GetInt(0);
        m_pISCNS2P->ISCNS2P_CommandJogSpeed(nModuleIndex, nSpeed);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandAfm( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_AFM, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nAfm = pPacket->GetInt(0);
        m_pISCNS2P->ISCNS2P_CommandAfm(nModuleIndex, nAfm);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandAfmJog( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_AFM_JOG, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nJog = pPacket->GetInt(0);
        m_pISCNS2P->ISCNS2P_CommandAfmJog(nModuleIndex, nJog);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandAfmJogSpeed( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_AFM_JOG_SPEED, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nSpeed = pPacket->GetInt(0);
        m_pISCNS2P->ISCNS2P_CommandAfmJogSpeed(nModuleIndex, nSpeed);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_CommandAfmHome( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_COMMAND_AFM_HOME, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nAfmHome = pPacket->GetInt(0);
        m_pISCNS2P->ISCNS2P_CommandAfmHome(nModuleIndex);
    }
}
 
// status
void CHSignalControls_Network::CSignalControl_NetServer::Process_StatusReviewResult( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pNetServer==NULL || pPacket==NULL) return;
 
    m_pNetServer->SendToClient(nModuleIndex, SS2SC_ACK_STATUS_REVIEWRESULT, NET_RESULT_SUCCESS);
 
    if (m_pISCNS2P)
    {
        int nModuleIndex = pPacket->GetInt(0);
        int nPlanIndex = pPacket->GetInt(1);
        int nResultCount = pPacket->GetInt(2);
        CSignalControlResultData* pResultData = (CSignalControlResultData*)pPacket->GetBuffer();
        m_pISCNS2P->ISCNS2P_StatusReviewResult(nModuleIndex, nPlanIndex, nResultCount, pResultData);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusLight( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_AckStatusLight(nModuleIndex);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusLens( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_AckStatusLens(nModuleIndex);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusModulePos( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_AckStatusModulePos(nModuleIndex);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusJogSpeed( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_AckStatusJogSpeed(nModuleIndex);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_AckStatusAfm( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_AckStatusAfm(nModuleIndex);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_AckCommandLoading( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_AckCommandLoading(nModuleIndex);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_AckCommandReviewResult( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_AckCommandReviewResult(nModuleIndex);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_AckCommandPlanStart( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_AckCommandPlanStart(nModuleIndex);
    }
}
 
void CHSignalControls_Network::CSignalControl_NetServer::Process_AckCommandPlanEnd( int nModuleIndex, CNetPacket *pPacket )
{
    if (m_pISCNS2P)
    {
        m_pISCNS2P->ISCNS2P_AckCommandPlanStart(nModuleIndex);
    }
}
 
int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusLight( int nModuleIndex, int nLight )
{
    if (m_pNetServer==NULL) return 0;
 
    CNetPacket *pPacket = m_pNetServer->GetPacket();
    if (pPacket==NULL) return 0;
 
    pPacket->SetInt(nLight);
 
    return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_LIGHT, NET_RESULT_SUCCESS, pPacket);
}
 
int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusLens( int nModuleIndex, int nLens )
{
    if (m_pNetServer==NULL) return 0;
 
    CNetPacket *pPacket = m_pNetServer->GetPacket();
    if (pPacket==NULL) return 0;
 
    pPacket->SetInt(nLens);
 
    return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_LENS, NET_RESULT_SUCCESS, pPacket);
}
 
int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusModulePos( int nModuleIndex, int nPosUmX, int nPosUmY )
{
    if (m_pNetServer==NULL) return 0;
 
    CNetPacket *pPacket = m_pNetServer->GetPacket();
    if (pPacket==NULL) return 0;
 
    pPacket->SetInt(nPosUmX);
    pPacket->SetInt(nPosUmY);
 
    return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_MODULE_POS, NET_RESULT_SUCCESS, pPacket);
}
 
int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusJogSpeed( int nModuleIndex, double dJogSpeed )
{
    if (m_pNetServer==NULL) return 0;
 
    CNetPacket *pPacket = m_pNetServer->GetPacket();
    if (pPacket==NULL) return 0;
 
    pPacket->SetDouble(dJogSpeed);
 
    return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_JOG_SPEED, NET_RESULT_SUCCESS, pPacket);
}
 
int CHSignalControls_Network::CSignalControl_NetServer::Send_StatusAfm( int nModuleIndex, int nAfm )
{
    if (m_pNetServer==NULL) return 0;
 
    CNetPacket *pPacket = m_pNetServer->GetPacket();
    if (pPacket==NULL) return 0;
 
    pPacket->SetInt(nAfm);
 
    return m_pNetServer->SendToClient(nModuleIndex, SS2SC_STATUS_AFM, NET_RESULT_SUCCESS, pPacket);
}
 
int CHSignalControls_Network::CSignalControl_NetServer::Send_CommandLoading( char* pTrasferData )
{
    if (m_pNetServer==NULL) return 0;
 
    BOOL bRetValue = TRUE;
 
    int nClientCount= m_pNetServer->GetClientCount();
    for (int nIdx=0; nIdx<nClientCount; nIdx++)
    {
        CNetPacket *pPacket = m_pNetServer->GetPacket();
        if (pPacket==NULL) continue;
 
        int nSize = sizeof(SDrsTransferData);
        pPacket->SetBuffer(nSize, pTrasferData);
 
        bRetValue = bRetValue & m_pNetServer->SendToClient(nIdx, SS2SC_COMMAND_LOADING, NET_RESULT_SUCCESS, pPacket);
    }
 
    return bRetValue;
}
 
int CHSignalControls_Network::CSignalControl_NetServer::Send_CommandReviewResult( int nModuleIndex, int nPlanIndex, int nResultCount, char* pResultData, int nMagLevel , int nDrsEtcCount)
{
    if (m_pNetServer==NULL) return 0;
 
    CNetPacket *pPacket = m_pNetServer->GetPacket();
    if (pPacket==NULL) return 0;
 
    pPacket->SetInt(nModuleIndex);
    pPacket->SetInt(nPlanIndex);
    pPacket->SetInt(nResultCount);
    pPacket->SetInt(nMagLevel);
    pPacket->SetInt(nDrsEtcCount);
    pPacket->SetBuffer(sizeof(CSignalControlResultData)*nResultCount, pResultData);
 
    return m_pNetServer->SendToClient(nModuleIndex, SS2SC_COMMAND_REVIEWRESULT, NET_RESULT_SUCCESS, pPacket);
}
 
int CHSignalControls_Network::CSignalControl_NetServer::Send_CommandPlanStart( int nPlanIndex )
{
    if (m_pNetServer==NULL) return 0;
 
    BOOL bRetValue = TRUE;
 
    int nClientCount= m_pNetServer->GetClientCount();
    for (int nIdx=0; nIdx<nClientCount; nIdx++)
    {
        CNetPacket *pPacket = m_pNetServer->GetPacket();
        if (pPacket==NULL) continue;
 
        pPacket->SetInt(nPlanIndex);
 
        bRetValue = bRetValue & m_pNetServer->SendToClient(nIdx, SS2SC_COMMAND_PLANSTART, NET_RESULT_SUCCESS, pPacket);
    }
 
    return bRetValue;
}
 
int CHSignalControls_Network::CSignalControl_NetServer::Send_CommandPlanEnd( int nPlanIndex )
{
    if (m_pNetServer==NULL) return 0;
 
    BOOL bRetValue = TRUE;
 
    int nClientCount= m_pNetServer->GetClientCount();
    for (int nIdx=0; nIdx<nClientCount; nIdx++)
    {
        CNetPacket *pPacket = m_pNetServer->GetPacket();
        if (pPacket==NULL) continue;
 
        pPacket->SetInt(nPlanIndex);
 
        bRetValue = bRetValue & m_pNetServer->SendToClient(nIdx, SS2SC_COMMAND_PLANEND, NET_RESULT_SUCCESS, pPacket);
    }
 
    return bRetValue;
}