开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > TAPI编程 > 查看源码
CALLINFO.CPP
资源名称：tapi3.zip　[点击查看]
上传用户：chinamans
上传日期：2013-03-17
资源大小：202k
文件大小：18k
源码类别：

TAPI编程

开发平台：

Visual C++

CALLINFO.CPP：源码内容
  1. // callinfo.cpp : implementation file for callinfo class
  2. // (c) Dialogic corp 1995, 1996
  4. #include "stdafx.h"
  5. #include <tapi.h>
  6. #include "tapiapp.h"
  7. #include "tapiline.h"
  8. #include "tapicall.h"
  9. #include "talker32.h"
  10. #include "talkdlg.h"
  11. #include "callinfo.h"
  12. #include "lineinfo.h"
  13. #include "helpid.h"
  14. #include "tonedlg.h"
  16. #ifdef _DEBUG
  17. #undef THIS_FILE
  18. static char BASED_CODE THIS_FILE[] = __FILE__;
  19. #endif
  21. #define CALLINFO_TIMER_ID 1
  22. #define WAVE_TIMER_ID 2
  24. UINT uiMsg;
  25. /////////////////////////////////////////////////////////////////////////////
  26. // CCallInfo property page
  28. IMPLEMENT_DYNCREATE(CCallInfo, CPropertyPage)
  30. CCallInfo::CCallInfo() : CPropertyPage(CCallInfo::IDD)
  31. {
  32. //{{AFX_DATA_INIT(CCallInfo)
  33. m_csCallInfo = _T("");
  34. m_csCallState = _T("");
  35. m_csCallAction = _T("");
  36. m_csGathered = _T("");
  37. m_csLastDigit = _T("");
  38. m_csGatherRes = _T("");
  39. //}}AFX_DATA_INIT
  40. m_pWaveName = NULL;
  41. m_nRecTime = 0;
  42. m_uiMsg = RegisterWindowMessage("TALKER32 callinfo alert");
  43. uiMsg = m_uiMsg;
  44. SetHelpID(HIDD_TALKER32_DialogCallInfo);
  45. }
  47. CCallInfo::~CCallInfo()
  48. {
  49. }
  51. void CCallInfo::DoDataExchange(CDataExchange* pDX)
  52. {
  53. CPropertyPage::DoDataExchange(pDX);
  54. //{{AFX_DATA_MAP(CCallInfo)
  55. DDX_Control(pDX, IDC_CALLALERT, m_btnCallAlert);
  56. DDX_Control(pDX, IDC_VOLUME, m_ctlVolume);
  57. DDX_Control(pDX, IDC_STOP, m_btnStop);
  58. DDX_Control(pDX, IDC_PAUSE, m_btnPause);
  59. DDX_Control(pDX, IDC_GATHER, m_btnGather);
  60. DDX_Control(pDX, IDC_MONITOR, m_btnMonitor);
  61. DDX_Control(pDX, IDC_RECORD, m_btnRecord);
  62. DDX_Control(pDX, IDC_PLAY, m_btnPlay);
  63. DDX_Text(pDX, IDC_CALLINFO, m_csCallInfo);
  64. DDX_Text(pDX, IDC_STATE, m_csCallState);
  65. DDX_Text(pDX, IDC_ACTIVITY, m_csCallAction);
  66. DDX_Text(pDX, IDC_GATHERED, m_csGathered);
  67. DDX_Text(pDX, IDC_LASTDIGIT, m_csLastDigit);
  68. DDX_Text(pDX, IDC_GATHERRES, m_csGatherRes);
  69. //}}AFX_DATA_MAP
  70. }
  73. BEGIN_MESSAGE_MAP(CCallInfo, CPropertyPage)
  74. //{{AFX_MSG_MAP(CCallInfo)
  75. ON_BN_CLICKED(IDC_PLAY, OnPlay)
  76. ON_BN_CLICKED(IDC_RECORD, OnRecord)
  77. ON_BN_CLICKED(IDC_REFRESH, OnRefresh)
  78. ON_WM_CLOSE()
  79. ON_WM_TIMER()
  80. ON_BN_CLICKED(IDC_INFOBTN, OnInfobtn)
  81. ON_BN_CLICKED(IDC_MONITOR, OnMonitor)
  82. ON_WM_DESTROY()
  83. ON_BN_CLICKED(IDC_CALLALERT, OnCallalert)
  84. ON_BN_CLICKED(IDC_GATHER, OnGather)
  85. ON_BN_CLICKED(IDC_PAUSE, OnPause)
  86. ON_BN_CLICKED(IDC_STOP, OnStop)
  87. ON_WM_HSCROLL()
  88. ON_REGISTERED_MESSAGE(uiMsg, OnDynamicAlert)
  89. ON_BN_CLICKED(IDC_GENTONE, OnGentone)
  90. ON_WM_SETFOCUS()
  91. //}}AFX_MSG_MAP
  92. END_MESSAGE_MAP()
  95. void CCallInfo::DisplayCallInfo(BOOL bUpdateCallInfo)
  96. {
  97. if(m_pCall == NULL) return;
  98. if(NULL == m_pLine->ctlGetActiveCall())  // call no longer active
  99. {
  100. if(m_pCall) {
  101. m_pCall->m_hStatusWnd = NULL;
  102. m_pCall->m_hCallAlertWnd = NULL;
  103. m_pCall->m_uiAlertMsg = NULL;
  104.    }
  105. m_pCall = NULL;
  106. ::PostMessage(::GetParent(m_hWnd), WM_CLOSE, 0, NULL);
  107. KillTimer(CALLINFO_TIMER_ID);
  108. return;
  109. }
  110. // display status
  111. WORD wState = m_pCall->GetCallState();
  112. WORD wDir = m_pCall->GetCallDirection();
  113. CString csTemp;
  115. m_csCallState = "State =";
  116. switch(wState)
  117. {
  118. case IDLE:
  119. csTemp = "idle";
  120. break;
  121. case MAKING:
  122. csTemp = "making";
  123. break;
  124. case STOP_MAKING:
  125. csTemp = "stop making";
  126. break;
  127. case PROGRESS:
  128. csTemp = "progress";
  129. break;
  130. case DIALING:
  131. csTemp = "dialing";
  132. break;
  133.   case OFFERING:
  134. csTemp = "offering";
  135. break;
  136.   case ANSWERING:
  137. csTemp = "answering";
  138. break;
  139.   case CONNECTED:
  140. csTemp = "connected";
  141. break;
  142. case HOLD:
  143. csTemp = "hold";
  144. break;
  145.   case DROPPING:
  146. csTemp = "dropping";
  147. break;
  148.   case DISCONNECTED: 
  149. csTemp = "disconnected";
  150. break;
  151. default:
  152. csTemp = "undefined";
  153. break;
  154. }
  155. m_csCallState += csTemp;
  156. DWORD dwWaveStatus = m_pCall->GetWaveStatus();
  157. DWORD dwPRStatus;
  158. switch(dwWaveStatus)
  159. {
  160. case WAVE_IDLE:
  161. csTemp = "Idle";
  162. m_btnPause.SetWindowText("Pause");
  163. m_btnStop.EnableWindow(FALSE);
  164. KillTimer(WAVE_TIMER_ID);
  165. m_nRecTime = 0;
  166. break;
  167. case PREPARING_TO_PLAY:
  168. case PLAYING:
  169. case FINISHING_PLAY:
  170. csTemp = "Playing";
  171. m_btnPause.SetWindowText("Pause");
  172. m_btnStop.EnableWindow();
  173. break;
  174. case PAUSED:
  175. csTemp = "Paused";
  176. m_btnPause.SetWindowText("Resume");
  177. break;
  178. case PREPARING_TO_RECORD:
  179. case RECORDING:  
  180. case FINISHING_RECORD:
  181. csTemp.Format("Recording, %d seconds left", m_nRecTime);
  182. m_btnStop.EnableWindow();
  183. break;
  184. case WAVE_DISFUNCTIONAL:
  185. csTemp = "Wave disabled";
  186. m_btnStop.EnableWindow(FALSE);
  187. // m_nRecTime = 0;
  188. // check the dev specific play/record status
  189. dwPRStatus = m_pCall->GetRecPlayStatus();
  190. switch(dwPRStatus) // all possible cases for dev specific play/record
  191. {
  192. case WAVE_IDLE:
  193. KillTimer(WAVE_TIMER_ID);
  194. m_nRecTime = 0;
  195. break;
  196. case PREPARING_TO_RECORD:
  197. case RECORDING:
  198. csTemp.Format("Recording, %d seconds left", m_nRecTime);
  199. m_btnStop.EnableWindow();
  200. break;
  201. case PREPARING_TO_PLAY:
  202. case PLAYING:
  203. case FINISHING_PLAY:
  204. csTemp = "Playing";
  205. m_btnStop.EnableWindow();
  206. break;
  207. case FAILED_START:
  208. csTemp = "Wave disabled";
  209. m_pLine->ctlUpdateDevSpecStatus(DEVSPEC_IDLE);
  210. MessageBox("WAVE function failed to start", NULL, MB_ICONSTOP);
  211. m_btnStop.EnableWindow(FALSE);
  212. break;
  213. case WAVE_FAILED:
  214. csTemp = "Wave disabled";
  215. m_pLine->ctlUpdateDevSpecStatus(DEVSPEC_IDLE);
  216. MessageBox("WAVE function failed to complete", NULL, MB_ICONSTOP);
  217. m_btnStop.EnableWindow(FALSE);
  218. break;
  219. }
  220. break;
  221. default:
  222. csTemp = "Not available";
  223. m_btnStop.EnableWindow(FALSE);
  224. m_nRecTime = 0;
  225. break;
  226. }  //end-switch
  228. m_csCallAction = "Action:";
  229. m_csCallAction += csTemp;
  230. if(wState != CONNECTED)
  231. m_btnStop.EnableWindow(FALSE);
  232. // Determine if WAVE play/record are available thru TAPI extensions
  233. // Make it available if: local system, wave driver not installed OR remote system
  234. if(dwWaveStatus == WAVE_DISFUNCTIONAL && m_bRunningOnNT)
  235. {
  236. m_btnPlay.SetWindowText("PlayX");
  237. m_btnRecord.SetWindowText("RecordX");
  238. m_btnPlay.EnableWindow(wState == CONNECTED);
  239. m_btnRecord.EnableWindow(wState == CONNECTED);
  240. }
  241. else
  242. {
  243. m_btnPlay.EnableWindow(wState == CONNECTED && dwWaveStatus == WAVE_IDLE);
  244. m_btnRecord.EnableWindow(wState == CONNECTED && dwWaveStatus == WAVE_IDLE);
  245. }
  246. m_btnPause.EnableWindow(dwWaveStatus==PREPARING_TO_PLAY || dwWaveStatus==PLAYING || // dwWaveStatus==WAVE_IDLE ||
  247. dwWaveStatus== PAUSED); //PREPARING_TO_RECORD || dwWaveStatus==RECORDING);
  249. UpdateData(FALSE);
  250. if(!bUpdateCallInfo) return;
  252. //UpdateDigitsMonitorStatus(); // do not read gathered
  253. m_csCallInfo.Empty();
  254. LPLINECALLSTATUS lpLCI = ((CTalkApp *)AfxGetApp())->GetCallStatus(m_pCall->m_hCall);
  255. if(lpLCI == NULL) return; // failed for some reason
  257. char szState[48];
  258. if(!((CTalkApp *)AfxGetApp())->Code2CallState(lpLCI->dwCallState, szState, 46))
  259. csTemp.Format("state = %lxrnstatemode = %lxrnprivilege = %lxrnfeatures = %lxrn",
  260. lpLCI->dwCallState, lpLCI->dwCallStateMode, lpLCI->dwCallPrivilege,lpLCI->dwCallFeatures);
  261. else
  262. csTemp.Format("state = %srnstatemode = %lxrnprivilege = %lxrnfeatures = %lxrn",
  263. szState, lpLCI->dwCallStateMode, lpLCI->dwCallPrivilege,lpLCI->dwCallFeatures);
  264. m_csCallInfo += csTemp;
  265. m_btnMonitor.EnableWindow(lpLCI->dwCallState == LINECALLSTATE_CONNECTED || lpLCI->dwCallState == LINECALLSTATE_DIALTONE);
  266. m_btnGather.EnableWindow(lpLCI->dwCallState == LINECALLSTATE_CONNECTED);
  267. UpdateData(FALSE);
  268. delete (PBYTE) lpLCI; 
  269. }
  271. void CCallInfo::UpdateDigitsMonitorStatus(BOOL bReadGathered, UINT wParam, LONG lParam)
  272. {
  273. MONITORSTATE msMonState ={0, 0, 0L, 0L, 0};
  274. BOOL bUpdateMon = FALSE;
  276. // Check/update monitor & gather state here
  277. if(lParam) // this is always != 0 for the parametrized alert
  278. {
  279. if(wParam) // Monitor result
  280. {
  281. msMonState.wState |= MONITOR_DIGITS;
  282. msMonState.wLastDigit = (WORD) wParam;
  283. bUpdateMon = TRUE;
  284. }    
  285. else  // gather result
  286. {
  287. msMonState.dwGatherResult = lParam;
  288. msMonState.wState &= ~START_GATHER;
  289. }
  290. }
  291. else if(!wParam)  // non-parametrized alert
  292. {
  293. m_pCall->GetMonitorState(&msMonState);
  294. bUpdateMon = TRUE;
  295. }
  296. if(bUpdateMon)
  297. {
  298. if(msMonState.wState & MONITOR_DIGITS)
  299. {
  300. m_btnMonitor.SetWindowText("Stop Monitor");
  301. m_csLastDigit.Format("%c", LOBYTE(msMonState.wLastDigit));
  302. }
  303. else 
  304. m_btnMonitor.SetWindowText("Monitor Digits");
  305. }
  306. if(msMonState.wState & START_GATHER)   // gathering in progress
  307. m_btnGather.SetWindowText("Stop Gather");
  308. else if(bReadGathered && msMonState.dwGatherResult) // read result if available
  309. {
  310. if(msMonState.dwGatherResult != LINEGATHERTERM_CANCEL)
  311. {
  312. m_pCall->m_szDigits[20] = 0;
  313. m_csGathered = m_pCall->m_szDigits;
  314. int i;
  315. for(i=0; i<lstrlen(m_pCall->m_szDigits); i++)
  316. {
  317. if(m_pCall->m_szDigits[i] != '*' && m_pCall->m_szDigits[i] != '#'
  318.  && !isdigit(m_pCall->m_szDigits[i]))
  319.  {
  320.   m_csGathered.Empty();
  321. break;
  322.  }
  323. }
  324. }
  325. m_csGatherRes.Format("%d",msMonState.dwGatherResult);
  326. m_pCall->UpdateMonitorState(RESET_GATHER_RESULT, 0L, 0L); 
  327. m_btnGather.SetWindowText("Gather Digits");
  328. }
  329. UpdateData(FALSE); //from data to controls
  330. }
  332. /////////////////////////////////////////////////////////////////////////////
  333. // CCallInfo message handlers
  335. BOOL CCallInfo::OnInitDialog() 
  336. {
  337. CPropertyPage::OnInitDialog();
  339. SetHelpID(HIDD_TALKER32_DialogCallInfo);
  340. if(!m_csCaption.IsEmpty()) SetWindowText(m_csCaption);
  341. m_ctlVolume.SetRange(0, MAX_REL_VOLUME);
  342. if(m_pCall)
  343. m_ctlVolume.SetPos((int) ((MAX_REL_VOLUME * (int) (m_pCall->GetWaveVolume()))/MAX_ABS_VOLUME));
  344. else
  345. m_ctlVolume.SetPos(MAX_REL_VOLUME);
  346. SetTimer(CALLINFO_TIMER_ID, 2000, NULL);
  347. DisplayCallInfo(TRUE);
  348. UpdateDigitsMonitorStatus(TRUE, 0, 0); // get monitoring & gathering result from the status structure
  349. if(m_pCall) 
  350. {
  351. m_pCall->m_hStatusWnd = m_hWnd; // register self to the pCall
  352. m_pCall->m_hCallAlertWnd = m_btnCallAlert.GetSafeHwnd(); // register self to the pCall
  353. m_pCall->m_dwCallAlert = IDC_CALLALERT;
  354. m_pCall->m_uiAlertMsg = m_uiMsg;
  355. }
  356.   return TRUE;  // return TRUE unless you set the focus to a control
  357.               // EXCEPTION: OCX Property Pages should return FALSE
  358. }
  360. void CCallInfo::OnPlay() 
  361. {
  362. long lrc;
  363. if(m_pWaveName == NULL || m_pWaveName->IsEmpty()) 
  364. {
  365. AfxMessageBox("No file to play");
  366. return;
  367. }
  368. if(m_pCall) 
  369. {
  370. SetTimer(WAVE_TIMER_ID, 500, NULL);
  371. if(WAVE_DISFUNCTIONAL ==  m_pCall->GetWaveStatus())  // use devspecific
  372. {
  373. lrc = m_pCall->PlayEx(m_pWaveName->GetBuffer(128));
  374. if(lrc < 0) 
  375. AfxMessageBox("Failed to start playing");
  376. }
  377. else
  378. m_pCall->Play(m_pWaveName->GetBuffer(128));
  379. }
  380. DisplayCallInfo();
  381. }
  383. void CCallInfo::OnRecord() 
  384. {
  385. if(m_pCall)
  386. {
  387. if(*m_pnWaveFormatID == 0 )
  388. m_nRecTime = *m_pdwRecFileSize/3000;
  389. else if(*m_pnWaveFormatID == 1 )
  390. m_nRecTime = *m_pdwRecFileSize/4000;
  391. else if(*m_pnWaveFormatID == 2  || *m_pnWaveFormatID == 5 || *m_pnWaveFormatID == 8)
  392. m_nRecTime = *m_pdwRecFileSize/6000;
  393. else if(*m_pnWaveFormatID == 3 || *m_pnWaveFormatID == 6 || *m_pnWaveFormatID == 9)
  394. m_nRecTime = *m_pdwRecFileSize/8000;
  395. else
  396. m_nRecTime = *m_pdwRecFileSize/11000;
  397. SetTimer(WAVE_TIMER_ID, 1000, NULL);
  398. if(WAVE_DISFUNCTIONAL ==  m_pCall->GetWaveStatus())  // use devspecific
  399. {
  400. if(m_pWaveRecName->IsEmpty()) 
  401. m_pWaveRecName->Format("%s","C:\WINNT35\SYSTEM32\TESTREC.WAV");
  402. TRACE("Recording into %sn", m_pWaveRecName->GetBuffer(120));
  403. m_pCall->RecordEx(m_pWaveRecName->GetBuffer(120), m_nRecTime, *m_pnWaveFormatID);
  404. }
  405. else
  406. m_pCall->Record(*m_pnWaveFormatID, *m_pdwRecFileSize);
  407. }
  408. DisplayCallInfo();
  409. }
  411. void CCallInfo::OnRefresh() 
  412. {
  413. DisplayCallInfo(TRUE); // update=FALSE by default
  414. }
  416. void CCallInfo::OnClose() 
  417. {
  418. KillTimer(CALLINFO_TIMER_ID);
  419. CPropertyPage::OnClose();
  420. }
  422. void CCallInfo::OnTimer(UINT nIDEvent) 
  423. {
  424. //if(nIDEvent == CALLINFO_TIMER_ID && !m_nRecTime) DisplayCallInfo(TRUE);
  425. if(nIDEvent == WAVE_TIMER_ID) 
  426. {
  427. if(m_nRecTime >1) m_nRecTime -=1; 
  428. else m_nRecTime = 0;
  429. DisplayCallInfo();
  430. }
  431. CPropertyPage::OnTimer(nIDEvent);
  432. }
  434. // Get call info
  435. void CCallInfo::OnInfobtn() 
  436. {
  437. CString csTemp;
  439. m_csCallInfo.Empty();
  440. LPLINECALLINFO lpLCI = ((CTalkApp *)AfxGetApp())->GetCallInfo(m_pCall->m_hCall);
  441. if(lpLCI == NULL) return; // failed for some reason
  443. csTemp.Format("hLine = %lxrndwLineDeviceID = %drndwBearerMode = %lxrn",
  444. lpLCI->hLine, lpLCI->dwLineDeviceID, lpLCI->dwBearerMode);
  445. m_csCallInfo += csTemp;
  446. csTemp.Format("dwMediaMode = %lxrndwCallStates = %lxrndwMonitorDigitModes = %lxrnCallerID flags = %lxrnCalledID flags = %lxrn",
  447. lpLCI->dwMediaMode, lpLCI->dwCallStates, lpLCI->dwMonitorDigitModes,lpLCI->dwCallerIDFlags,lpLCI->dwCalledIDFlags);
  448. m_csCallInfo += csTemp;
  450.     if (lpLCI->dwCallerIDFlags & LINECALLPARTYID_NAME && lpLCI->dwCallerIDNameSize)
  451.     {
  452.          csTemp.Format("Caller name=%srn",(LPSTR)(((LPSTR)(lpLCI))+lpLCI->dwCallerIDNameOffset));
  453. m_csCallInfo += csTemp;
  454.     } 
  456.     if (lpLCI->dwCallerIDFlags & LINECALLPARTYID_ADDRESS && lpLCI->dwCallerIDSize)
  457.     {
  458.          csTemp.Format("Caller number=%srn", (LPSTR)(((LPSTR)(lpLCI))+lpLCI->dwCallerIDOffset));      
  459. m_csCallInfo += csTemp;
  460.     } 
  461. UpdateData(FALSE);
  462. delete (PBYTE) lpLCI; 
  464. }
  466. void CCallInfo::OnMonitor() 
  467. {
  468. LONG lrc;
  469. CString csTemp;
  470. HCALL hCall;
  472. if(m_pCall) hCall = m_pCall->m_hCall; // protect this 
  473. m_btnMonitor.GetWindowText(csTemp);
  474. if(!csTemp.CompareNoCase("Monitor Digits")) // currently not monitoring
  475. {
  476. lrc = m_pCall->MonitorDigits(LINEDIGITMODE_DTMF);
  477. if(!lrc) m_btnMonitor.SetWindowText("Stop Monitor");
  478. }
  479. else
  480. {
  481. lrc = m_pCall->MonitorDigits(0);
  482. m_btnMonitor.SetWindowText("Monitor Digits");
  483. }
  484. }
  486. void CCallInfo::OnDestroy() 
  487. {
  488. CPropertyPage::OnDestroy();
  490. if(m_pCall) 
  491. {
  492. m_pCall->m_hStatusWnd = NULL;
  493. m_pCall->m_hCallAlertWnd = NULL;
  494. m_pCall->m_dwCallAlert = NULL;
  495. m_pCall->m_uiAlertMsg = m_uiMsg;
  496. }
  497. }
  499. // Alert message w/o parameters 
  500. void CCallInfo::OnCallalert() 
  501. {
  502. UpdateDigitsMonitorStatus(TRUE); // get monitoring & gathering result
  503. }
  505. // Alert message w/parameters 
  506. LONG CCallInfo::OnDynamicAlert(UINT wParam, LONG lParam)
  507. {
  508. if(!wParam)  // gather result
  509. UpdateDigitsMonitorStatus(TRUE, 0, lParam); // get gathering result
  510. else 
  511. UpdateDigitsMonitorStatus(FALSE, wParam, lParam); // get monitoring result
  512. return 0;
  513. }
  515. void CCallInfo::OnGather() 
  516. {
  517. CString csTemp;
  518. LONG lrc;
  519. char szErr[48];
  521. if(m_pCall == NULL) return;
  522. m_btnGather.GetWindowText(csTemp);
  524. if(!csTemp.CompareNoCase("Gather Digits")) // currently not gathering
  525. {
  526. m_csGathered.Empty();
  527. m_csGatherRes.Empty();
  528. UpdateData(FALSE);
  529. lrc = m_pCall->GatherDigits(20, "*#", 10000, 5000, NULL);
  530. if(lrc)
  531. {
  532. if(!((CTalkApp *)AfxGetApp())->Code2Error(lrc, szErr, 46))
  533. csTemp.Format("lineGatherDigits failed reason=%lx", lrc);
  534. else
  535. csTemp.Format("lineGatherDigits failed reason=%s", szErr);
  536. AfxMessageBox(csTemp);
  537. }
  538. else m_btnGather.SetWindowText("Stop Gather");
  539. }
  540. else    // user said stop 
  541. {
  542. lrc = m_pCall->GatherDigits(0, "", 0, 0, NULL);
  543. if(lrc)
  544. {
  545. if(!((CTalkApp *)AfxGetApp())->Code2Error(lrc, szErr, 46))
  546. csTemp.Format("attempt to cancel lineGatherDigits failed reason=%lx", lrc);
  547. else
  548. csTemp.Format("attempt to cancel lineGatherDigits failed reason=%s", szErr);
  549. AfxMessageBox(csTemp);
  550. }
  551. // else m_btnGather.SetWindowText("Gather Digits"); // consider it done...
  552. }
  553. }
  555. void CCallInfo::OnPause() 
  556. {
  557. if(!m_pCall) return;
  558. DWORD dwWaveStatus = m_pCall->GetWaveStatus();
  559. if(dwWaveStatus == PLAYING) 
  560. m_pCall->Pause();
  561. else if(dwWaveStatus == PAUSED)
  562. m_pCall->Resume();
  563. DisplayCallInfo();
  564. }
  566. void CCallInfo::OnStop() 
  567. {
  568. m_pCall->StopWave();
  569. DisplayCallInfo();
  570. }
  572. void CCallInfo::OnSetFocus(CWnd* pOldWnd) 
  573. {
  574. CPropertyPage::OnSetFocus(pOldWnd);
  575. ((CTalkApp *)AfxGetApp())->SetHelpId(HIDD_TALKER32_DialogCallInfo);
  576. }
  578. void CCallInfo::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  579. {
  580. int nP;
  581. if(nSBCode == SB_THUMBPOSITION || nSBCode == SB_THUMBTRACK) nP = nPos;
  582. else nP = m_ctlVolume.GetPos();
  583. if(m_pCall) m_pCall->SetWaveVolume((DWORD) ((MAX_ABS_VOLUME/MAX_REL_VOLUME) * nP)); 
  584. CPropertyPage::OnHScroll(nSBCode, nPos, pScrollBar);
  585. }
  587. void CCallInfo::OnGentone() 
  588. {
  589. // display tone selection dialog
  590. CToneDlg dlg(this);
  591. //LPLINEGENERATETONE lplgT = NULL;
  592. dlg.m_bRunningOnNT = m_bRunningOnNT;
  593. if(IDCANCEL == dlg.DoModal()) return;
  594. if(dlg.m_bBeep) 
  595. lineGenerateTone(m_pCall->m_hCall, LINETONEMODE_BEEP, dlg.m_dwDur, 0, 0);
  596. else
  597. {
  598. LINEGENERATETONE lgt[2];
  599. DWORD dwNum = 1;
  600. LONG lrc;
  602. // lplgT = (LPLINEGENERATETONE)new char[200*sizeof(LINEGENERATETONE)];
  603. // if(!lplgT) return;
  604. lgt[0].dwFrequency = dlg.m_dwF1;
  605. lgt[0].dwVolume = dlg.m_dwA1;
  606. lgt[0].dwCadenceOn = dlg.m_dwDur/2;
  607. lgt[0].dwCadenceOff = dlg.m_dwDur/2;
  608. if(dlg.m_dwF2)
  609. {
  610. lgt[1].dwFrequency = dlg.m_dwF2;
  611. lgt[1].dwVolume = dlg.m_dwA2;
  612. lgt[1].dwCadenceOn = dlg.m_dwDur/2;
  613. lgt[1].dwCadenceOff = dlg.m_dwDur/2;
  614. dwNum++;
  615. }
  616. if(lrc = lineGenerateTone(m_pCall->m_hCall, LINETONEMODE_CUSTOM, 
  617. dlg.m_dwDur, dwNum, lgt))
  618. {
  619. CString csTemp;
  620. csTemp.Format("lineGenerateTone failed rc=%lx", lrc);
  621. AfxMessageBox(csTemp);
  622. }
  623. // if(lplgT) delete lplgT;
  624. }
  625. }
  627. /* 
  628.  #define SB_LINEUP           0
  629. #define SB_LINELEFT         0
  630. #define SB_LINEDOWN         1
  631. #define SB_LINERIGHT        1
  632. #define SB_PAGEUP           2
  633. #define SB_PAGELEFT         2
  634. #define SB_PAGEDOWN         3
  635. #define SB_PAGERIGHT        3
  636. #define SB_THUMBPOSITION    4
  637. #define SB_THUMBTRACK       5
  638. #define SB_TOP              6
  639. #define SB_LEFT             6
  640. #define SB_BOTTOM           7
  641. #define SB_RIGHT            7
  642. #define SB_ENDSCROLL        8
  643. */