dialog.cpp

csta协议的开发

/////////////////////////////////////////////////////////////////////////////
// CPickupCallDlg message handlers
/////////////////////////////////////////////////////////////////////////////
// CGetDeviceListDlg dialog


CGetDeviceListDlg::CGetDeviceListDlg(CWnd* pParent /*=NULL*/)
  : CDialog(CGetDeviceListDlg::IDD, pParent)
{
  //{{AFX_DATA_INIT(CGetDeviceListDlg)
  m_nLevel = -1;
  //}}AFX_DATA_INIT
}

void CGetDeviceListDlg::DoDataExchange(CDataExchange* pDX)
{
  CDialog::DoDataExchange(pDX);
  //{{AFX_DATA_MAP(CGetDeviceListDlg)
  DDX_CBIndex(pDX, IDC_LEVEL, m_nLevel);
  //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CGetDeviceListDlg, CDialog)
  //{{AFX_MSG_MAP(CGetDeviceListDlg)
    // NOTE: the ClassWizard will add message map macros here
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CGetDeviceListDlg message handlers
/////////////////////////////////////////////////////////////////////////////
// CSnapshotCallDlg dialog


CSnapshotCallDlg::CSnapshotCallDlg(CWnd* pParent /*=NULL*/)
  : CDialog(CSnapshotCallDlg::IDD, pParent)
{
  //{{AFX_DATA_INIT(CSnapshotCallDlg)
  m_sCallID = "";
  m_sDeviceID = "";
  m_nDeviceType = -1;
  //}}AFX_DATA_INIT
}

void CSnapshotCallDlg::DoDataExchange(CDataExchange* pDX)
{
  CDialog::DoDataExchange(pDX);
  //{{AFX_DATA_MAP(CSnapshotCallDlg)
  DDX_Text(pDX, IDC_CALL_ID, m_sCallID);
  DDV_MaxChars(pDX, m_sCallID, 15);
  DDX_Text(pDX, IDC_DEVICE_ID, m_sDeviceID);
  DDV_MaxChars(pDX, m_sDeviceID, 32);
  DDX_CBIndex(pDX, IDC_DEVICE_TYPE, m_nDeviceType);
  //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CSnapshotCallDlg, CDialog)
  //{{AFX_MSG_MAP(CSnapshotCallDlg)
    // NOTE: the ClassWizard will add message map macros here
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CSnapshotCallDlg message handlers
/////////////////////////////////////////////////////////////////////////////
// CSnapshotDeviceDlg dialog


CSnapshotDeviceDlg::CSnapshotDeviceDlg(CWnd* pParent /*=NULL*/)
  : CDialog(CSnapshotDeviceDlg::IDD, pParent)
{
  //{{AFX_DATA_INIT(CSnapshotDeviceDlg)
  m_sDeviceID = "";
  //}}AFX_DATA_INIT
}

void CSnapshotDeviceDlg::DoDataExchange(CDataExchange* pDX)
{
  CDialog::DoDataExchange(pDX);
  //{{AFX_DATA_MAP(CSnapshotDeviceDlg)
  DDX_Text(pDX, IDC_DEVICE_ID, m_sDeviceID);
  DDV_MaxChars(pDX, m_sDeviceID, 32);
  //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CSnapshotDeviceDlg, CDialog)
  //{{AFX_MSG_MAP(CSnapshotDeviceDlg)
    // NOTE: the ClassWizard will add message map macros here
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CSnapshotDeviceDlg message handlers
/////////////////////////////////////////////////////////////////////////////
// CMonitorStartDlg dialog


CMonitorStartDlg::CMonitorStartDlg(CWnd* pParent /*=NULL*/)
  : CDialog(CMonitorStartDlg::IDD, pParent)
{
  //{{AFX_DATA_INIT(CMonitorStartDlg)
  m_bBackInService = FALSE;
  m_bCallCleared = FALSE;
  m_bCallInformation = FALSE;
  m_bConferenced = FALSE;
  m_bConnectionCleared = FALSE;
  m_bDelivered = FALSE;
  m_bDiverted = FALSE;
  m_bDoNotDisturb = FALSE;
  m_bEstablished = FALSE;
  m_bFailed = FALSE;
  m_bForwarding = FALSE;
  m_bHeld = FALSE;
  m_bLoggedOff = FALSE;
  m_bLoggedOn = FALSE;
  m_bMessageWaiting = FALSE;
  m_bNetworkReached = FALSE;
  m_bNotReady = FALSE;
  m_bOriginated = FALSE;
  m_bOutOfService = FALSE;
  m_nPrivateFilter = 0;
  m_bQueued = FALSE;
  m_bReady = FALSE;
  m_bRetrieved = FALSE;
  m_bServiceInitiated = FALSE;
  m_bTransferred = FALSE;
  m_bWorkNotReady = FALSE;
  m_bWorkReady = FALSE;
  m_sDeviceID = "";
  //}}AFX_DATA_INIT
}

void CMonitorStartDlg::DoDataExchange(CDataExchange* pDX)
{
  CDialog::DoDataExchange(pDX);
  //{{AFX_DATA_MAP(CMonitorStartDlg)
  DDX_Check(pDX, IDC_BACK_IN_SERVICE, m_bBackInService);
  DDX_Check(pDX, IDC_CALL_CLEARED, m_bCallCleared);
  DDX_Check(pDX, IDC_CALL_INFORMATION, m_bCallInformation);
  DDX_Check(pDX, IDC_CONFERENCED, m_bConferenced);
  DDX_Check(pDX, IDC_CONNECTION_CLEARED, m_bConnectionCleared);
  DDX_Check(pDX, IDC_DELIVERED, m_bDelivered);
  DDX_Check(pDX, IDC_DIVERTED, m_bDiverted);
  DDX_Check(pDX, IDC_DO_NOT_DISTURB, m_bDoNotDisturb);
  DDX_Check(pDX, IDC_ESTABLISHED, m_bEstablished);
  DDX_Check(pDX, IDC_FAILED, m_bFailed);
  DDX_Check(pDX, IDC_FORWARDING, m_bForwarding);
  DDX_Check(pDX, IDC_HELD, m_bHeld);
  DDX_Check(pDX, IDC_LOGGED_OFF, m_bLoggedOff);
  DDX_Check(pDX, IDC_LOGGED_ON, m_bLoggedOn);
  DDX_Check(pDX, IDC_MESSAGE_WAITING, m_bMessageWaiting);
  DDX_Check(pDX, IDC_NETWORK_REACHED, m_bNetworkReached);
  DDX_Check(pDX, IDC_NOT_READY, m_bNotReady);
  DDX_Check(pDX, IDC_ORIGINATED, m_bOriginated);
  DDX_Check(pDX, IDC_OUT_OF_SERVICE, m_bOutOfService);
  DDX_Text(pDX, IDC_PRIVATE_FILTER, m_nPrivateFilter);
  DDX_Check(pDX, IDC_QUEUED, m_bQueued);
  DDX_Check(pDX, IDC_READY, m_bReady);
  DDX_Check(pDX, IDC_RETRIEVED, m_bRetrieved);
  DDX_Check(pDX, IDC_SERVICE_INITIATED, m_bServiceInitiated);
  DDX_Check(pDX, IDC_TRANSFERRED, m_bTransferred);
  DDX_Check(pDX, IDC_WORK_NOT_READY, m_bWorkNotReady);
  DDX_Check(pDX, IDC_WORK_READY, m_bWorkReady);
  DDX_Text(pDX, IDC_DEVICE_ID, m_sDeviceID);
  DDV_MaxChars(pDX, m_sDeviceID, 32);
  //}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CMonitorStartDlg, CDialog)
  //{{AFX_MSG_MAP(CMonitorStartDlg)
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMonitorStartDlg message handlers
BOOL CMonitorStartDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	BOOL bEnable = FALSE;
	GetDlgItem(IDC_BACK_IN_SERVICE)->EnableWindow( bEnable );
	GetDlgItem(IDC_CALL_CLEARED)->EnableWindow( bEnable );
	GetDlgItem(IDC_CALL_INFORMATION)->EnableWindow( bEnable );
	GetDlgItem(IDC_CONFERENCED)->EnableWindow( bEnable );
	GetDlgItem(IDC_CONNECTION_CLEARED)->EnableWindow( bEnable );
	GetDlgItem(IDC_DELIVERED)->EnableWindow( bEnable );
	GetDlgItem(IDC_DIVERTED)->EnableWindow( bEnable );
	GetDlgItem(IDC_DO_NOT_DISTURB)->EnableWindow( bEnable );
	GetDlgItem(IDC_ESTABLISHED)->EnableWindow( bEnable );
	GetDlgItem(IDC_FAILED)->EnableWindow( bEnable );
	GetDlgItem(IDC_FORWARDING)->EnableWindow( bEnable );
	GetDlgItem(IDC_HELD)->EnableWindow( bEnable );
	GetDlgItem(IDC_LOGGED_OFF)->EnableWindow( bEnable );
	GetDlgItem(IDC_LOGGED_ON)->EnableWindow( bEnable );
	GetDlgItem(IDC_MESSAGE_WAITING)->EnableWindow( bEnable );
	GetDlgItem(IDC_NETWORK_REACHED)->EnableWindow( bEnable );
	GetDlgItem(IDC_NOT_READY)->EnableWindow( bEnable );
	GetDlgItem(IDC_ORIGINATED)->EnableWindow( bEnable );
	GetDlgItem(IDC_OUT_OF_SERVICE)->EnableWindow( bEnable );
	GetDlgItem(IDC_PRIVATE_FILTER)->EnableWindow( bEnable );
	GetDlgItem(IDC_QUEUED)->EnableWindow( bEnable );
	GetDlgItem(IDC_READY)->EnableWindow( bEnable );
	GetDlgItem(IDC_RETRIEVED)->EnableWindow( bEnable );
	GetDlgItem(IDC_SERVICE_INITIATED)->EnableWindow( bEnable );
	GetDlgItem(IDC_TRANSFERRED)->EnableWindow( bEnable );
	GetDlgItem(IDC_WORK_NOT_READY)->EnableWindow( bEnable );
	GetDlgItem(IDC_WORK_READY)->EnableWindow( bEnable );
  
  CString captionText;
  switch (m_nDialogType) {
    case CSTA_MONITOR_DEVICE :
      captionText = "Monitor Device";
      break;
    case CSTA_MONITOR_CALL :
      captionText = "Monitor Call";
      break;
    case CSTA_MONITOR_CALLS_VIA_DEVICE :
      captionText = "Monitor Calls via Device";
      break;
    default :
      captionText = "Unknown Type";
      break;
  }
  SetWindowText (captionText);
  
  return TRUE;  // return TRUE  unless you set the focus to a control
}
/////////////////////////////////////////////////////////////////////////////
// CMonitorCallDlg dialog


CMonitorCallDlg::CMonitorCallDlg(CWnd* pParent /*=NULL*/)
  : CDialog(CMonitorCallDlg::IDD, pParent)
{
  //{{AFX_DATA_INIT(CMonitorCallDlg)
  m_bBackInService = FALSE;
  m_bCallCleared = FALSE;
  m_bCallInformation = FALSE;
  m_bConferenced = FALSE;
  m_bConnectionCleared = FALSE;
  m_bDelivered = FALSE;
  m_sCallID = "";
  m_sDeviceID = "";
  m_nDeviceType = -1;
  m_bDiverted = FALSE;
  m_bDoNotDisturb = FALSE;
  m_bEstablished = FALSE;
  m_bFailed = FALSE;
  m_bForwarding = FALSE;
  m_bHeld = FALSE;
  m_bLoggedOff = FALSE;
  m_bLoggedOn = FALSE;
  m_bMessageWaiting = FALSE;
  m_bNetworkReached = FALSE;
  m_bNotReady = FALSE;
  m_bOriginated = FALSE;
  m_bOutOfService = FALSE;
  m_bPrivateFilter = "";
  m_bQueued = FALSE;
  m_bReady = FALSE;
  m_bRetrieved = FALSE;
  m_bServiceInitiated = FALSE;
  m_bTransferred = FALSE;
  m_bWorkNotReady = FALSE;
  m_bWorkReady = FALSE;
  //}}AFX_DATA_INIT
}

void CMonitorCallDlg::DoDataExchange(CDataExchange* pDX)
{
  CDialog::DoDataExchange(pDX);
  //{{AFX_DATA_MAP(CMonitorCallDlg)
  DDX_Check(pDX, IDC_BACK_IN_SERVICE, m_bBackInService);
  DDX_Check(pDX, IDC_CALL_CLEARED, m_bCallCleared);
  DDX_Check(pDX, IDC_CALL_INFORMATION, m_bCallInformation);
  DDX_Check(pDX, IDC_CONFERENCED, m_bConferenced);
  DDX_Check(pDX, IDC_CONNECTION_CLEARED, m_bConnectionCleared);
  DDX_Check(pDX, IDC_DELIVERED, m_bDelivered);
  DDX_Text(pDX, IDC_CALL_ID, m_sCallID);
  DDV_MaxChars(pDX, m_sCallID, 20);
  DDX_Text(pDX, IDC_DEVICE_ID, m_sDeviceID);
  DDX_CBIndex(pDX, IDC_DEVICE_TYPE, m_nDeviceType);
  DDX_Check(pDX, IDC_DIVERTED, m_bDiverted);
  DDX_Check(pDX, IDC_DO_NOT_DISTURB, m_bDoNotDisturb);
  DDX_Check(pDX, IDC_ESTABLISHED, m_bEstablished);
  DDX_Check(pDX, IDC_FAILED, m_bFailed);
  DDX_Check(pDX, IDC_FORWARDING, m_bForwarding);
  DDX_Check(pDX, IDC_HELD, m_bHeld);
  DDX_Check(pDX, IDC_LOGGED_OFF, m_bLoggedOff);
  DDX_Check(pDX, IDC_LOGGED_ON, m_bLoggedOn);
  DDX_Check(pDX, IDC_MESSAGE_WAITING, m_bMessageWaiting);
  DDX_Check(pDX, IDC_NETWORK_REACHED, m_bNetworkReached);
  DDX_Check(pDX, IDC_NOT_READY, m_bNotReady);
  DDX_Check(pDX, IDC_ORIGINATED, m_bOriginated);
  DDX_Check(pDX, IDC_OUT_OF_SERVICE, m_bOutOfService);
  DDX_Text(pDX, IDC_PRIVATE_FILTER, m_bPrivateFilter);
  DDX_Check(pDX, IDC_QUEUED, m_bQueued);
  DDX_Check(pDX, IDC_READY, m_bReady);
  DDX_Check(pDX, IDC_RETRIEVED, m_bRetrieved);
  DDX_Check(pDX, IDC_SERVICE_INITIATED, m_bServiceInitiated);
  DDX_Check(pDX, IDC_TRANSFERRED, m_bTransferred);
  DDX_Check(pDX, IDC_WORK_NOT_READY, m_bWorkNotReady);
  DDX_Check(pDX, IDC_WORK_READY, m_bWorkReady);
  //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CMonitorCallDlg, CDialog)
  //{{AFX_MSG_MAP(CMonitorCallDlg)
    // NOTE: the ClassWizard will add message map macros here
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CMonitorCallDlg message handlers
/////////////////////////////////////////////////////////////////////////////
// CEscSrvDlg dialog


CEscSrvDlg::CEscSrvDlg(CWnd* pParent /*=NULL*/)
  : CDialog(CEscSrvDlg::IDD, pParent)
{
  //{{AFX_DATA_INIT(CEscSrvDlg)
  m_edCallID = 0;
  m_edCorrelator = "";
  m_edDeviceID = "";
  m_edVendor = "";
  //}}AFX_DATA_INIT
}

void CEscSrvDlg::DoDataExchange(CDataExchange* pDX)
{
  CDialog::DoDataExchange(pDX);
  //{{AFX_DATA_MAP(CEscSrvDlg)
  DDX_Text(pDX, IDC_ED_CALL_ID, m_edCallID);
  DDX_Text(pDX, IDC_ED_CORRELATOR, m_edCorrelator);
  DDV_MaxChars(pDX, m_edCorrelator, 40);
  DDX_Text(pDX, IDC_ED_DEVICE_ID, m_edDeviceID);
  DDV_MaxChars(pDX, m_edDeviceID, 64);
  DDX_Text(pDX, IDC_ED_VENDOR, m_edVendor);
  DDV_MaxChars(pDX, m_edVendor, 32);
  //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CEscSrvDlg, CDialog)
  //{{AFX_MSG_MAP(CEscSrvDlg)
  ON_BN_CLICKED(IDC_OPT_DYNAMIC, OnOptDynamic)
  ON_BN_CLICKED(IDC_OPT_STATIC, OnOptStatic)
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CEscSrvDlg message handlers

void CEscSrvDlg::OnOptDynamic()
{
  m_deviceID = DYNAMIC_ID;
}

void CEscSrvDlg::OnOptStatic()
{                            
  m_deviceID = STATIC_ID;
}
/////////////////////////////////////////////////////////////////////////////
// CRouteRegister dialog


CRouteRegister::CRouteRegister(CWnd* pParent /*=NULL*/)
	: CDialog(CRouteRegister::IDD, pParent)
{
	//{{AFX_DATA_INIT(CRouteRegister)
	m_bBackUp = FALSE;
	m_sRoutingDevice = "";
	//}}AFX_DATA_INIT
}

void CRouteRegister::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CRouteRegister)
	DDX_Text(pDX, IDC_CALLING_DEVICE, m_sRoutingDevice);
    DDX_Check(pDX, IDC_BACKUP, m_bBackUp);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CRouteRegister, CDialog)
	//{{AFX_MSG_MAP(CRouteRegister)
		// NOTE: the ClassWizard will add message map macros here
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CRouteRegister message handlers
/////////////////////////////////////////////////////////////////////////////
// CRouteRegisterCancelDlg dialog


CRouteRegisterCancelDlg::CRouteRegisterCancelDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CRouteRegisterCancelDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CRouteRegisterCancelDlg)
	m_nRouteRegID = 0;
	//}}AFX_DATA_INIT
}

void CRouteRegisterCancelDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CRouteRegisterCancelDlg)
	DDX_Text(pDX, IDC_ROUTE_REG_ID, m_nRouteRegID);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CRouteRegisterCancelDlg, CDialog)
	//{{AFX_MSG_MAP(CRouteRegisterCancelDlg)
		// NOTE: the ClassWizard will add message map macros here
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////