lineinfo.cpp

TAPI编程应用

// lineinfo.cpp : implementation file for CLineInfo
// (c) Dialogic corp 1995, 1996

#include "stdafx.h"
#include <tapi.h>
#include "tapiapp.h"
#include "tapiline.h"
#include "tapicall.h"
#include "talker32.h"
#include "talkdlg.h"
#include "callinfo.h"
#include "lineinfo.h"
#include "helpid.h"
#include "wavedlg.h"

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CLineInfo property page

IMPLEMENT_DYNCREATE(CLineInfo, CPropertyPage)

CLineInfo::CLineInfo() : CPropertyPage(CLineInfo::IDD)
{
	//{{AFX_DATA_INIT(CLineInfo)
	m_csLineInfo = _T("");
	m_fAuto = FALSE;
	m_csDisplayWaveName = _T("");
	m_fAutoPlay = FALSE;
	//}}AFX_DATA_INIT
	m_pParent = NULL;
	m_csWaveName = "play.wav";
}

CLineInfo::~CLineInfo()
{
}

void CLineInfo::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CLineInfo)
	DDX_Control(pDX, IDC_WAVENAME, m_ctlWaveName);
	DDX_Control(pDX, IDC_AUTOPLAY, m_btnAutoPlay);
	DDX_Control(pDX, IDC_DEVCAPS, m_btnDevCaps);
	DDX_Control(pDX, IDC_AUTOANSWER, m_btnAutoAnswer);
	DDX_Text(pDX, IDC_LINEINFO, m_csLineInfo);
	DDX_Check(pDX, IDC_AUTOANSWER, m_fAuto);
	DDX_Text(pDX, IDC_WAVENAME, m_csDisplayWaveName);
	DDX_Check(pDX, IDC_AUTOPLAY, m_fAutoPlay);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CLineInfo, CPropertyPage)
	//{{AFX_MSG_MAP(CLineInfo)
	ON_BN_CLICKED(IDC_DEVCAPS, OnDevcaps)
	ON_BN_CLICKED(IDC_CONFIG, OnConfig)
	ON_BN_CLICKED(IDC_AUTOANSWER, OnAutoanswer)
	ON_BN_CLICKED(IDC_BROWSE, OnBrowse)
	ON_BN_CLICKED(IDC_GETDEVSTATUS, OnGetdevstatus)
	ON_BN_CLICKED(IDC_AUTOPLAY, OnAutoplay)
	ON_WM_SETFOCUS()
	ON_WM_DESTROY()
	ON_BN_CLICKED(IDC_WAVEFORMAT, OnWaveformat)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

// call lineGetLineDevCaps & display results
void CLineInfo::DisplayDevCaps()
{

	LPLINEDEVCAPS lpDC;
	if(m_pLine->ctlLineGetCaps(&lpDC)) return;
	if(lpDC == NULL) return;
	// display status
	m_csLineInfo.Empty();
	CString csTemp;
	csTemp.Format("dwPermanentLineID = %d,\r\ndwAddressModes = %d,\r\ndwGenerateToneModes = %d\r\n",
			lpDC->dwPermanentLineID, lpDC->dwAddressModes, lpDC->dwGenerateToneModes);
	m_csLineInfo += csTemp;
	csTemp.Format("dwMonitorDigitModes = %d,\r\ndwMediaModes = %d,\r\ndwMaxRate = %d\r\n",
			lpDC->dwMonitorDigitModes, lpDC->dwMediaModes, lpDC->dwMaxRate);
	m_csLineInfo += csTemp;
	if(m_pLine->m_csName.IsEmpty())
		csTemp.Format("Line name = %s\r\n", (LPSTR)((LPBYTE)lpDC + lpDC->dwLineNameOffset));
	else
		csTemp.Format("Line name = %s\r\n", m_pLine->m_csName);
	m_csLineInfo += csTemp;
	csTemp.Format("Provider info = %s\r\n", (LPCTSTR)((LPBYTE)lpDC + lpDC->dwProviderInfoOffset));
	m_csLineInfo += csTemp;
	if(m_pLine->IsRemote())
		csTemp.Format("Line is operating on remote machine!\r\n");
	else
		csTemp.Format("Wave/In ID = %d, Wave/Out ID = %d\r\n", m_pLine->ctlGetWaveInID(), m_pLine->ctlGetWaveOutID());
	m_csLineInfo += csTemp;
	UpdateData(FALSE);
	delete lpDC; 	
}


// call lineGetLineDevStatus & display results
void CLineInfo::DisplayDevStatus()
{
	CString csTemp;

	LPLINEDEVSTATUS lpDS = m_pLine->ctlGetLineDevStatus();
	if(lpDS == NULL) 
	{
		m_csLineInfo.Format("Status unavailable!\r\n");
		UpdateData(FALSE);
		return;
	}
	// display status
	m_csLineInfo.Empty();
	csTemp.Format("dwNumOpens = %d,\r\ndwOpenMediaModes = %d,\r\ndwNumActiveCalls = %d\r\n",
			lpDS->dwNumOpens, lpDS->dwOpenMediaModes, lpDS->dwNumActiveCalls);
	m_csLineInfo += csTemp;
	csTemp.Format("dwNumOnHoldCalls = %d,\r\ndwNumOnHoldPendCalls = %d,\r\ndwLineFeatures = %d\r\n",
			lpDS->dwNumOnHoldCalls, lpDS->dwNumOnHoldPendCalls, lpDS->dwLineFeatures);
	m_csLineInfo += csTemp;
	UpdateData(FALSE);
	delete lpDS; 	
}

/////////////////////////////////////////////////////////////////////////////
// CLineInfo message handlers

BOOL CLineInfo::OnInitDialog() 
{
	CPropertyPage::OnInitDialog();
	WORD wOptions = ((CTalkApp *)AfxGetApp())->m_wLineOptions[m_pLine->ctlGetLineID()];
	if(wOptions & AUTOANSWER) m_fAuto = TRUE;
	if(wOptions & AUTOPLAY) m_fAutoPlay = TRUE;
	FitWaveName();
	if(m_pLine != NULL)	DisplayDevStatus();
	m_nFormatID = 10;			// default = 11k 8bit PCM
	m_dwRecFileSize = 65534;	// default
		
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CLineInfo::OnDevcaps() 
{
	if(m_pLine==NULL) return;
	if(m_pLine != NULL) DisplayDevCaps();		
}


void CLineInfo::OnConfig() 
{
	m_pLine->ctlConfigDialog(GetSafeHwnd(), "tapi/line");	
}

void CLineInfo::OnAutoanswer() 
{
	CString csTemp;

	csTemp.Format("line%d", m_pLine->ctlGetLineID());
	if(m_btnAutoAnswer.GetCheck())
	{
		AfxGetApp()->WriteProfileString(csTemp, "AutoAnswer", "yes");
		((CTalkApp *)AfxGetApp())->m_wLineOptions[m_pLine->ctlGetLineID()] |= AUTOANSWER;
	}
	else 
	{
		AfxGetApp()->WriteProfileString(csTemp, "AutoAnswer", "no");
		((CTalkApp *)AfxGetApp())->m_wLineOptions[m_pLine->ctlGetLineID()] &= ~AUTOANSWER;
	}
	UpdateData();
}

void CLineInfo::OnAutoplay() 
{
	CString csTemp;

	csTemp.Format("line%d", m_pLine->ctlGetLineID());
	if(m_btnAutoPlay.GetCheck())
	{
		AfxGetApp()->WriteProfileString(csTemp, "AutoPlay", "yes");
		((CTalkApp *)AfxGetApp())->m_wLineOptions[m_pLine->ctlGetLineID()] |= AUTOPLAY;
	}
	else 
	{
		AfxGetApp()->WriteProfileString(csTemp, "AutoPlay", "no");
		((CTalkApp *)AfxGetApp())->m_wLineOptions[m_pLine->ctlGetLineID()] &= ~AUTOPLAY;
	}
	UpdateData();
}


// Select the wave file to play
void CLineInfo::OnBrowse() 
{
	CString csTemp;

	csTemp.Format("line%d", m_pLine->ctlGetLineID());

	CString csFilter = "Wave Files(*.wav)|*.wav|All Files(*.*)|*.*||";
	CFileDialog dlg(TRUE, NULL, m_csWaveName, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
				(LPCTSTR) csFilter, this);
	if(IDOK == dlg.DoModal())
	{
		m_csWaveName = dlg.GetPathName();
		AfxGetApp()->WriteProfileString(csTemp, "Wave Play File", m_csWaveName);
		FitWaveName();
		UpdateData(FALSE);		
		m_pParent->m_CallInfo[0].m_pWaveName = &m_csWaveName;
	}

	DWORD  dwDesiredAccess = GENERIC_READ;	// access (read-write) mode 
    DWORD  dwShareMode = 0;	// share mode 
    LPSECURITY_ATTRIBUTES  lpSecurityAttributes = NULL;	// address of security descriptor 
    DWORD  dwCreationDistribution = OPEN_EXISTING;	// how to create 
    HANDLE  hF = CreateFile((LPCTSTR)m_csWaveName, dwDesiredAccess, 
		dwShareMode, lpSecurityAttributes, dwCreationDistribution, FILE_ATTRIBUTE_NORMAL,NULL);
	if(hF == INVALID_HANDLE_VALUE) 
	TRACE("Openfailed err=%d\n", GetLastError());
	else CloseHandle(hF);
}

// Fit the wave file name into available space
void CLineInfo::FitWaveName()
{
	int nChars = 0, nLen, nInd1, nInd2;
	// find out how much space is available
	CDC *pDC  = m_ctlWaveName.GetDC();
	if(pDC) 
	{
		TEXTMETRIC myTM;
		if(pDC->GetTextMetrics(&myTM))
		{
			CRect cr;
			m_ctlWaveName.GetClientRect(&cr);
			nChars = (cr.right - cr.left)/myTM.tmAveCharWidth;
		}
		m_ctlWaveName.ReleaseDC(pDC);
	}
	if(nChars < 25 || nChars > 40) nChars = 25;		// just in case
	nLen = m_csWaveName.GetLength();
	if(nLen <= nChars)		// fits already
	{
		m_csDisplayWaveName = m_csWaveName;
		goto FinishFit;
	}
	nInd1 = m_csWaveName.Find('\\');
	nInd2 = m_csWaveName.ReverseFind('\\');
	if(nInd1 && nInd2 && nInd2 > nInd1) 			// remove all between ind1 & ind2
	{
		m_csDisplayWaveName = m_csWaveName.Left(nInd1+1) + (LPCTSTR) "..." +m_csWaveName.Right(nLen - nInd2); 
	}
	else m_csDisplayWaveName = m_csWaveName;
	FinishFit:
	m_csDisplayWaveName.MakeLower();
}

void CLineInfo::OnGetdevstatus() 
{
	DisplayDevStatus();		
}

void CLineInfo::OnSetFocus(CWnd* pOldWnd) 
{
	CPropertyPage::OnSetFocus(pOldWnd);
	((CTalkApp *)AfxGetApp())->SetHelpId(HIDD_TALKER32_DialogLineInfo);
	
}

void CLineInfo::OnWaveformat() 
{
	CWaveDlg dlg(this); // bring up the format dialog	
	dlg.m_nFormatID = m_nFormatID;
	dlg.m_csFileName = m_csWaveName;
	if(IDOK == dlg.DoModal())
		m_nFormatID = dlg.m_nFormatID;
}

/////////////////////////////////////////////////////////////////////////////
// CInfo

IMPLEMENT_DYNAMIC(CInfo, CPropertySheet)

CInfo::CInfo(UINT nIDCaption, CWnd* pParentWnd, UINT iSelectPage)
	:CPropertySheet(nIDCaption, pParentWnd, iSelectPage)
{
	m_pbtnClose = NULL;
	m_pbtnHelp = NULL;
	BuildSheet();
}

CInfo::CInfo(LPCTSTR pszCaption, CWnd* pParentWnd, UINT iSelectPage, LPVOID lpLine)
	:CPropertySheet(pszCaption, pParentWnd, iSelectPage)
{
	m_pbtnClose = NULL;
	m_pbtnHelp = NULL;
	BuildSheet(lpLine);
}

CInfo::~CInfo()
{
}

BEGIN_MESSAGE_MAP(CInfo, CPropertySheet)
	//{{AFX_MSG_MAP(CInfo)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_WM_SHOWWINDOW()
	ON_BN_CLICKED(IDCANCEL, OnClose)
	ON_BN_CLICKED(ID_HELP, OnContextHelp)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

void CInfo::BuildSheet(LPVOID lpLine)
{
	DWORD i;
	CString csTemp;
	OSVERSIONINFO verinfo;
	BOOL bNT = FALSE;

	verinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	if(GetVersionEx(&verinfo) && 
		verinfo.dwPlatformId == VER_PLATFORM_WIN32_NT) bNT = TRUE;	

	// find out the number of calls; can handle only one for now
	m_LineInfo.m_dwCalls = 0;
	if(lpLine == NULL) return;
	m_LineInfo.m_pLine = (CTapiLine *)lpLine;
	m_LineInfo.m_pParent = this; 
	CTapiCall *pCall = m_LineInfo.m_pLine->ctlGetActiveCall();
	if(pCall != NULL)
	{
		m_LineInfo.m_dwCalls = 1;
		m_LineInfo.m_ppCalls[0] = pCall;
	}

	m_LineInfo.m_csLineName.Empty();
	m_LineInfo.m_bRemote = FALSE;
	LPLINEDEVCAPS lpDC;
	if(!m_LineInfo.m_pLine->ctlLineGetCaps(&lpDC))			// extract line name
	{
		if(lpDC != NULL) 
		{
			m_LineInfo.m_csLineName.Format("%s", (LPSTR)((LPBYTE)lpDC + lpDC->dwLineNameOffset));
			if(bNT)
				m_LineInfo.m_bRemote = IsLineRemote(lpDC);	// find out if line is remote
			delete lpDC;
		}
	}
	// set the wave file name
	csTemp.Format("line%d", m_LineInfo.m_pLine->ctlGetLineID());
	m_LineInfo.m_csWaveName = AfxGetApp()->GetProfileString((LPCTSTR)csTemp, "Wave Play File", "");
	m_LineInfo.m_csWaveRecName = AfxGetApp()->GetProfileString((LPCTSTR)csTemp, "Wave Record File", "");
	if(m_LineInfo.m_csWaveName.IsEmpty()) 		// 
		m_LineInfo.m_csWaveName = "play.wav";
	if(m_LineInfo.m_csWaveRecName.IsEmpty()) 		// 
		m_LineInfo.m_csWaveRecName.Format("record%.2d.wav",m_LineInfo.m_pLine->ctlGetLineID());

	AddPage(&m_LineInfo);
	for(i = 0; i < m_LineInfo.m_dwCalls; i++)
	{
		m_CallInfo[i].m_csCaption.Format("Call %d", i+1);
		m_CallInfo[i].m_pCall = m_LineInfo.m_ppCalls[i];
		m_CallInfo[i].m_pLine = (CTapiLine *)lpLine;
		m_CallInfo[i].m_pWaveName = &m_LineInfo.m_csWaveName;
		m_CallInfo[i].m_pWaveRecName = &m_LineInfo.m_csWaveRecName;
		m_CallInfo[i].m_pLineName = &m_LineInfo.m_csLineName;
		m_CallInfo[i].m_bRemote = m_LineInfo.m_bRemote;
		m_CallInfo[i].m_bRunningOnNT = bNT;
		m_CallInfo[i].m_pnWaveFormatID = &m_LineInfo.m_nFormatID;
		m_CallInfo[i].m_pdwRecFileSize = &m_LineInfo.m_dwRecFileSize;
		AddPage(&m_CallInfo[i]);	// where to init call info page?
	}
}

void CInfo::CreateCloseButton()
{
	CRect crctw;
	
	if(m_pbtnClose) return;
	m_pbtnClose = new CButton;
	m_pbtnHelp = new CButton;
	GetWindowRect(&crctw);
	crctw.InflateRect(10,15);
	MoveWindow(&crctw);
	GetWindowRect(&crctw);
	
	CRect crctb(crctw.Width()-60, crctw.Height()-50, crctw.Width()-20, crctw.Height()-30); 
	m_pbtnClose->Create("Close", BS_PUSHBUTTON, crctb, this, IDCANCEL);	//special ID
	CFont *pcfTemp = m_LineInfo.m_btnDevCaps.GetFont();	//a little dirty, but works
	m_pbtnClose->SetFont(pcfTemp);
	m_pbtnClose->ShowWindow(SW_SHOW);
	crctb.left -= 60;
	crctb.right -= 60;
	m_pbtnHelp->Create("Help", BS_PUSHBUTTON, crctb, this, ID_HELP);	//special ID
	m_pbtnHelp->SetFont(pcfTemp);
	m_pbtnHelp->ShowWindow(SW_SHOW);
}

/////////////////////////////////////////////////////////////////////////////
// CInfo message handlers


int CInfo::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CPropertySheet::OnCreate(lpCreateStruct) == -1)
		return -1;
	
//	CreateCloseButton();	
	return 0;
}

void CInfo::OnDestroy() 
{
	CPropertySheet::OnDestroy();
	
	if(m_pbtnClose==NULL) return;
	delete m_pbtnClose;
	m_pbtnClose = NULL;
	delete m_pbtnHelp;
	m_pbtnHelp = NULL;
}

void CInfo::OnShowWindow(BOOL bShow, UINT nStatus) 
{
	CPropertySheet::OnShowWindow(bShow, nStatus);
	
	CreateCloseButton();	
	if(m_pbtnClose) 
	m_pbtnClose->ShowWindow(SW_SHOW);
	if(m_pbtnHelp) 
	m_pbtnHelp->ShowWindow(SW_SHOW);
}

void CInfo::OnClose() 
{
	PostMessage(WM_CLOSE,0,0);
}

void CInfo::OnContextHelp() 
{
	((CTalkApp *)AfxGetApp())->OnHelp();
//	CPropertySheet::WinHelp(HIDD_TALKER32_DialogLineInfo, HELP_CONTEXT);
}

// Determine if the line is running on the remote computer
// Since MS doesn't provide a standard way, use whatever mechanism is available for the SP
// Override this function to implement a better way
/***	Moved to talker32.cpp
BOOL IsLineRemote(LPLINEDEVCAPS lpDC)
{
	int nInd;
	CString csTemp;

	if(!lpDC->dwLineNameOffset) return FALSE;
	csTemp.Format("%s", (LPSTR)((LPBYTE)lpDC + lpDC->dwLineNameOffset));
	csTemp.MakeUpper();
	if(-1 == csTemp.Find("DXXXB")) return FALSE;		// non-Dialogic TSP
	if(-1 == (nInd = csTemp.Find("\\"))) return FALSE;	// computer name not a part of board name
	csTemp = csTemp.Left(nInd);
	char szName[MAX_COMPUTERNAME_LENGTH+1];
	DWORD dwSize = MAX_COMPUTERNAME_LENGTH+1;
	if(!GetComputerName(szName, &dwSize)) return FALSE;	// Name unavailable for some reason
	if(!strcmpi(szName, (LPCTSTR)csTemp)) return FALSE;	// Same name
	return TRUE;					 // Finally, the names ARE different
} ***/