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

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

TAPI编程

开发平台：

Visual C++

TALKDLG.CPP：源码内容
  1. // talkdlg.cpp : implementation file
  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 <mmsystem.h>
  11. #include "wavex.h"
  12. //#include "wavexg.h"
  13. #include "callinfo.h"
  14. #include "lineinfo.h"
  15. #include "talkdlg.h"
  16. #include "helpid.h"
  18. #ifdef _DEBUG
  19. #undef THIS_FILE
  20. static char BASED_CODE THIS_FILE[] = __FILE__;
  21. #endif
  23. /////////////////////////////////////////////////////////////////////////////
  24. // CTalkDlg dialog
  26. CTalkDlg::CTalkDlg(CWnd* pParent /*=NULL*/)
  27. : CDialog(CTalkDlg::IDD, pParent)
  28. {
  29. //{{AFX_DATA_INIT(CTalkDlg)
  30. m_csDialString = _T("");
  31. //}}AFX_DATA_INIT
  32. // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
  33. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  34. SetHelpID(HIDD_TALKER32_DialogMain);
  35. }
  37. void CTalkDlg::DoDataExchange(CDataExchange* pDX)
  38. {
  39. CDialog::DoDataExchange(pDX);
  40. //{{AFX_DATA_MAP(CTalkDlg)
  41. DDX_Control(pDX, IDC_DIAL, m_btnDial);
  42. DDX_Control(pDX, IDC_EDIT1, m_ctlDialString);
  43. DDX_Control(pDX, IDC_CALLS, m_ctlActiveCalls);
  44. DDX_Control(pDX, IDC_LINEFRAME, m_ctlLineFrame);
  45. DDX_Control(pDX, IDC_NUMBER0, m_ctlLineNum0);
  46. DDX_Control(pDX, IDC_INFO0, m_btnInfo0);
  47. DDX_Control(pDX, IDC_ACTION0, m_btnAction0);
  48. DDX_Control(pDX, IDC_IND0, m_ctlFrame0);
  49. DDX_Text(pDX, IDC_EDIT1, m_csDialString);
  50. //}}AFX_DATA_MAP
  51. }
  53. BEGIN_MESSAGE_MAP(CTalkDlg, CDialog)
  54. //{{AFX_MSG_MAP(CTalkDlg)
  55. ON_WM_PAINT()
  56. ON_WM_QUERYDRAGICON()
  57. ON_WM_DESTROY()
  58. ON_BN_CLICKED(IDC_DIAL, OnDial)
  59. ON_MESSAGE(MM_WOM_DONE, OnWomDone) // Finish playing WAVE
  60. ON_MESSAGE(MM_WIM_DATA, OnWimData) // Finish recording WAVE 
  61. ON_BN_CLICKED(IDC_CLEAR, OnClear)
  62. ON_BN_CLICKED(ID_CONTEXT_HELP, OnContextHelp)
  63. ON_WM_SETFOCUS()
  64. ON_WM_ACTIVATE()
  65. //}}AFX_MSG_MAP
  66. END_MESSAGE_MAP()
  68. /////////////////////////////////////////////////////////////////////////////
  69. // CTalkDlg message handlers
  71. BOOL CTalkDlg::OnInitDialog()
  72. {
  74. DWORD i;
  75. char szBuf[16];
  76. CTapiLine *ptlTemp;
  77. CDialog::OnInitDialog();
  78. CenterWindow();
  79. // SetHelpID(HIDD_TALKER32_DialogMain);
  81. // set the control ID so that the TapiApp object knows where to send notification messages
  82. ((CTalkApp *)AfxGetApp())->SetNotificationControlID(IDC_TAPIALERT);
  84. m_dwLines = ((CTalkApp *)AfxGetApp())->m_dwLines;
  85. m_LineControls[0].uiActionID = IDC_ACTION0;
  86. m_LineControls[0].uiInfoID = IDC_INFO0;
  87. m_LineControls[0].pbtnAction = &m_btnAction0;
  88. m_LineControls[0].pbtnInfo = &m_btnInfo0;
  89. m_LineControls[0].pFrame = &m_ctlFrame0;
  90. m_LineControls[0].pctlLineNum = &m_ctlLineNum0;
  91. m_LineControls[0].pInfoDlg = NULL;
  92. m_nLastX =  95;   
  93. m_nLastY =  25;
  94. m_uiLastID = CONTROL_ARRAY_START;
  95. memset((PBYTE)&(m_LineControls[1]), 0, sizeof(LINECONTROL)*(MAXLINES-1)); // zeroinit
  96. //difference between non-existent & non-functional line:ctlLine=0-nonexist, hline=0-nonfunct
  97. for(i=0; i< m_dwLines; i++)
  98. {
  99. if(NULL == (ptlTemp = ((CTalkApp *)AfxGetApp())->GetTapiLine(i))) continue;
  100. if(i) if(FALSE == CreateLineWindows(&(m_LineControls[i]))) continue;
  101. m_LineControls[i].pctlLine = ptlTemp; // save the line pointer for future ref
  102. sprintf(szBuf, "%d", i);
  103. (m_LineControls[i].pctlLineNum)->SetWindowText(szBuf);
  104. if(NULL != ptlTemp->ctlGetHLine()) // Line functional
  105. (m_LineControls[i].pFrame)->m_Colorref = GREEN; //green=OK
  106. else 
  107. {
  108. (m_LineControls[i].pFrame)->m_Colorref = BLACK; //black=nonfunctional
  109. (m_LineControls[i].pbtnAction)->EnableWindow(FALSE);
  110. }
  111. m_LineControls[0].pInfoDlg = NULL;
  112. (m_LineControls[i].pFrame)->Invalidate();
  113. }
  115. if(!m_dwLines) // remove the pilot windows
  116. {
  117. m_btnAction0.ShowWindow(SW_HIDE);
  118. m_btnInfo0.ShowWindow(SW_HIDE);
  119. m_ctlFrame0.ShowWindow(SW_HIDE);
  120. m_ctlLineNum0.ShowWindow(SW_HIDE);
  121. MessageBox("No TAPI lines found, check TAPI configuration", "Talker32", MB_ICONEXCLAMATION); 
  122. }
  123. m_btnDial.EnableWindow(FALSE);
  124. return TRUE;  // return TRUE  unless you set the focus to a control
  125. }
  127. // If you add a minimize button to your dialog, you will need the code below
  128. //  to draw the icon.  For MFC applications using the document/view model,
  129. //  this is automatically done for you by the framework.
  131. BOOL CTalkDlg::CreateLineWindows(PLINECONTROL pLineControl)
  132. {
  133. CRect rCur, rNew, rWork;
  134. CFont *pcfTemp = m_btnAction0.GetFont();
  135. POINT pntNew;
  137. if(NULL == (pLineControl->pctlLineNum = new CStatic)) return FALSE;
  138. if(NULL == (pLineControl->pFrame = new CXstatic)) return FALSE;
  139. if(NULL == (pLineControl->pbtnAction = new CButton)) return FALSE;
  140. if(NULL == (pLineControl->pbtnInfo = new CButton)) return FALSE;
  141. m_uiLastID++;
  143. // Get the position & IDs for the new controls
  144. if(FALSE == DetermineLinePos(&pntNew)) return FALSE; // main wnd too small
  145. rNew.left = pntNew.x;
  146. rNew.top = pntNew.y;
  147. rNew.right = pntNew.x + 8; 
  148. rNew.bottom = pntNew.y + 10;
  149. rWork = rNew;
  150. MapDialogRect(&rWork);    // convert from dialog base units to screen units
  151. if(!pLineControl->pctlLineNum->Create(" ", m_ctlLineNum0.GetStyle(), rWork, 
  152. this, m_uiLastID)) return FALSE;
  153. pLineControl->pctlLineNum->ShowWindow(SW_SHOW);
  154. pLineControl->pctlLineNum->SetFont(pcfTemp);
  155. m_uiLastID++;
  156. m_nLastX = rNew.left; // Save new values
  157. m_nLastY = rNew.top; 
  158. rCur = rNew;
  159. GetNextRect(&rCur, &rNew, 13, 0, 10, 10);  // Lamp
  160. rWork = rNew;
  161. MapDialogRect(&rWork);   // convert from dialog base units to screen units
  162. if(!pLineControl->pFrame->Create(" ", m_ctlFrame0.GetStyle(), rWork, 
  163. this, m_uiLastID)) return FALSE;
  164. pLineControl->pFrame->ShowWindow(SW_SHOW);
  165. m_uiLastID++;
  166. rCur = rNew;
  167. GetNextRect(&rCur, &rNew, 15, 0, 35, 15);  // Action button
  168. rWork = rNew;
  169. MapDialogRect(&rWork);
  170. if(!pLineControl->pbtnAction->Create("Call", m_btnAction0.GetButtonStyle(), rWork, 
  171. this, m_uiLastID)) return FALSE;
  172. pLineControl->uiActionID = m_uiLastID;
  173. pLineControl->pbtnAction->ShowWindow(SW_SHOW);
  174. pLineControl->pbtnAction->SetFont(pcfTemp);
  175. m_uiLastID++;
  176. rCur = rNew;
  177. GetNextRect(&rCur, &rNew, 40, 0, 20, 15);  // Info button
  178. rWork = rNew;
  179. MapDialogRect(&rWork);
  180. if(!pLineControl->pbtnInfo->Create("Info", m_btnInfo0.GetButtonStyle(), rWork, 
  181. this, m_uiLastID)) return FALSE;
  182. pLineControl->uiInfoID = m_uiLastID;
  183. pLineControl->pbtnInfo->ShowWindow(SW_SHOW);
  184. pLineControl->pbtnInfo->SetFont(pcfTemp);
  185. return TRUE;
  186. //may use DeferWindowPos ?...
  187. }
  189. void CTalkDlg::GetNextRect(RECT *pLastRect, RECT *pNewRect, int ndX, int ndY, int nW, int nH)
  190. {
  191. // put bounds check here
  192. pNewRect->top = pLastRect->top + ndY;
  193. pNewRect->bottom = pNewRect->top + nH;
  194. pNewRect->left = pLastRect->left + ndX;
  195. pNewRect->right = pNewRect->left + nW;
  196. }
  198. // Calculate position for new line of controls; resize window if needed
  199. BOOL CTalkDlg::DetermineLinePos(POINT *ppntNew)
  200. {
  201. CRect rctLimit1, rctNew;
  202. CRect rcT(10, 10, 10, 10);
  204. MapDialogRect(&rcT); // isn't it a shame...
  205. //LONG ldbu = GetDialogBaseUnits();
  206. m_ctlLineFrame.GetWindowRect(&rctLimit1);
  207. ScreenToClient(&rctLimit1);
  208. // the real rect
  209. CRect rctLimit((rctLimit1.left*10)/rcT.left, (rctLimit1.top*10)/rcT.top,
  210. (rctLimit1.right*10)/rcT.right ,(rctLimit1.bottom*10)/rcT.bottom);
  212. if(m_nLastY > (rctLimit.bottom - 40))  // resize window; start next row
  213. {
  214. AddColumn();   
  215. ppntNew->x = m_nLastX + 100; 
  216. ppntNew->y = rctLimit.top + 20; // 25 it should be
  217. }
  218. else 
  219. {
  220. ppntNew->x = m_nLastX;
  221. ppntNew->y = m_nLastY + 20;
  222. }
  223. // if(ppntNew->x > (rctLimit1.right - 100)) return FALSE; // need to resize the main wnd
  224. return TRUE;
  225. }
  227. // add a new column of controls
  228. void CTalkDlg::AddColumn()
  229. {
  230. CRect rctMain, rctFrame;
  231. CRect rcT(100, 100, 100, 100);
  233. MapDialogRect(&rcT);
  235. GetWindowRect(&rctMain);   // resize main window
  236. rctMain.right += rcT.left; // do everything in dialog units ONLY
  237. MoveWindow(&rctMain);
  238. m_ctlLineFrame.GetWindowRect(&rctFrame); // resize frame
  239. ScreenToClient(&rctFrame);
  240. rctFrame.right += rcT.left; // only horizontally
  241. m_ctlLineFrame.MoveWindow(&rctFrame);
  242. }
  244. void CTalkDlg::OnPaint() 
  245. {
  246. if (IsIconic())
  247. {
  248. CPaintDC dc(this); // device context for painting
  250. SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
  252. // Center icon in client rectangle
  253. int cxIcon = GetSystemMetrics(SM_CXICON);
  254. int cyIcon = GetSystemMetrics(SM_CYICON);
  255. CRect rect;
  256. GetClientRect(&rect);
  257. int x = (rect.Width() - cxIcon + 1) / 2;
  258. int y = (rect.Height() - cyIcon + 1) / 2;
  260. // Draw the icon
  261. dc.DrawIcon(x, y, m_hIcon);
  262. }
  263. else
  264. {
  265. CDialog::OnPaint();
  266. }
  267. }
  269. // The system calls this to obtain the cursor to display while the user drags
  270. //  the minimized window.
  271. HCURSOR CTalkDlg::OnQueryDragIcon()
  272. {
  273. return (HCURSOR) m_hIcon;
  274. }
  276. // User clicked on Action button; find out what to do & do it
  277. void CTalkDlg::OnAction(DWORD dwIndex) 
  278. {
  279. PLINECONTROL plcTemp = &m_LineControls[dwIndex];
  280. LONG lrc;
  281. CTapiCall *pCall = plcTemp->pctlLine->ctlGetActiveCall();
  282. WORD wCallState;
  283. CString csTemp;
  284. LPTSTR lpTemp;
  286. plcTemp->pbtnAction->GetWindowText(csTemp);
  287. plcTemp->pbtnAction->EnableWindow(FALSE); // disable for now
  288. // find out what the line state is
  289. if(pCall == NULL && !csTemp.CompareNoCase("Call")) // no active calls, try to call
  290. {
  291. UpdateData(); // to get m_csDialString
  292. if(m_csDialString.IsEmpty()) lpTemp = NULL;
  293. else lpTemp = m_csDialString.GetBuffer(256);
  294. lrc = plcTemp->pctlLine->ctlLineMakeCall((LPCTSTR)lpTemp, 0);
  295. if(lrc < 0)
  296. { 
  297. csTemp.Format("Make call failed reason=%lx", lrc);
  298. MessageBox(csTemp); // restore call state-WHERE?
  299. }
  300. else return;
  301. }
  302. else 
  303. {
  304. wCallState = pCall->GetCallState();
  305. switch (wCallState) // find out what to do depending on state
  306. {
  307. case MAKING:
  308. case PROGRESS:
  309. case CONNECTED:
  310. case HOLD:
  311. if(!csTemp.CompareNoCase("Hangup")) 
  312. {
  313. ((CTalkApp *)AfxGetApp())->m_wLineOptions[dwIndex] &= ~PLAY_ONCE;
  314. plcTemp->pctlLine->ctlLineDrop();
  315. }
  316. return; //break;
  318. case OFFERING:
  319. if(!csTemp.CompareNoCase("Pickup"))
  320. lrc = plcTemp->pctlLine->ctlLineAnswer(); 
  321. if(lrc < 0) TRACE("*** TALKER32 ***: Answer failed rc=%lxn",lrc); 
  322. break;
  324. case ANSWERING:   // do nothing
  325. break;
  327. case DROPPING:   // unclear what to do
  328. break;
  330. case DISCONNECTED:
  331. if(!csTemp.CompareNoCase("Hangup")) 
  332. plcTemp->pctlLine->ctlLineDrop();
  333. break;
  335. default:
  336. break;
  337. }
  338. }
  340. plcTemp->pbtnAction->EnableWindow(TRUE); // reenable
  341. }
  343. // User clicked on Info button; find out what to do & do it
  344. void CTalkDlg::OnInfo(DWORD dwIndex) 
  345. {
  346. CTapiLine *pLine = (&m_LineControls[dwIndex])->pctlLine;
  347. // set the line in the info dialog, let it do the rest
  348. CString csTemp;
  349. csTemp.Format("Line #%d information", dwIndex);
  351. // Always destroy before creation
  352. DestroyPropSheet(dwIndex);
  354. if(m_LineControls[dwIndex].pInfoDlg == NULL) // reallocate brand new
  355. m_LineControls[dwIndex].pInfoDlg = (LPVOID)new CInfo(csTemp, NULL, 0, pLine);
  356. if(m_LineControls[dwIndex].pInfoDlg != NULL)
  357. ((CInfo *)m_LineControls[dwIndex].pInfoDlg)->Create();
  358. return;    
  360. /***PLINECONTROL plcTemp = &m_LineControls[dwIndex]; // temporary for testing play!!!
  361. CTapiCall *pCall = plcTemp->pctlLine->ctlGetActiveCall();
  362. if(pCall != NULL) pCall->Play("record1.wav");
  363. ***/
  364. }
  366. // Update the indicator & other status
  367. void CTalkDlg::UpdateDisplayStatus(DWORD dwLineID)
  368. {
  369. CTapiCall *pCall;
  370. WORD wCallState = IDLE;
  371. DWORD dwError = NULL;
  372. CString csTemp, csWaveName;
  373. int nNum;
  375. if(dwLineID == 0xffff || dwLineID >= m_dwLines) {return;} // update all lines info
  376. PLINECONTROL plcTemp = &m_LineControls[dwLineID];
  377. if(NULL != (pCall = plcTemp->pctlLine->ctlGetActiveCall()))
  378. {
  379. wCallState = pCall->GetCallState(); // No active call==state IDLE
  380. dwError = pCall->GetCallError();
  381. }
  382. switch(wCallState)
  383. {
  384. case IDLE:
  385. m_LineControls[dwLineID].pFrame->m_Colorref = GREEN;
  386. m_LineControls[dwLineID].pbtnAction->SetWindowText("Call");
  387. m_LineControls[dwLineID].pbtnAction->EnableWindow();
  388. DestroyPropSheet(dwLineID, TRUE);  // destroy if has calls
  389. // if(1 == m_ctlActiveCalls.GetCount())  // the last one
  390. // {
  391. // m_ctlActiveCalls.ResetContent();
  392. // m_btnDial.EnableWindow(FALSE);
  393. // }
  394. csTemp.Format("line %d", dwLineID);
  395. nNum = m_ctlActiveCalls.FindString(-1, (LPCTSTR) csTemp);
  396. if(nNum != CB_ERR) m_ctlActiveCalls.DeleteString(nNum);
  397. break;
  399. case MAKING:
  400. case PROGRESS:
  401. m_LineControls[dwLineID].pFrame->m_Colorref = PURPLE;
  402. m_LineControls[dwLineID].pbtnAction->SetWindowText("Hangup");
  403. csTemp.Format("line %d", dwLineID);
  404. nNum = m_ctlActiveCalls.FindString(-1, (LPCTSTR) csTemp);
  405. if(nNum == CB_ERR) nNum = m_ctlActiveCalls.AddString((LPCTSTR) csTemp);
  406. m_ctlActiveCalls.SetCurSel(nNum);
  407. m_btnDial.EnableWindow();
  408. m_LineControls[dwLineID].pbtnAction->EnableWindow();
  409. break;
  411. case OFFERING:
  412. m_LineControls[dwLineID].pFrame->m_Colorref = BROWN;
  413. m_LineControls[dwLineID].pbtnAction->SetWindowText("Pickup");
  414. m_LineControls[dwLineID].pbtnAction->EnableWindow();
  415. if(((CTalkApp *)AfxGetApp())->m_wLineOptions[dwLineID] & AUTOANSWER) //answer immediately
  416. PostMessage(WM_COMMAND, MAKELONG(m_LineControls[dwLineID].uiActionID, BN_CLICKED), 
  417. (LPARAM)m_LineControls[dwLineID].pbtnAction->GetSafeHwnd()); 
  418. break;
  420. case ANSWERING:
  421. m_LineControls[dwLineID].pFrame->m_Colorref = BROWN;
  422. m_LineControls[dwLineID].pbtnAction->SetWindowText("Hangup");
  423. m_LineControls[dwLineID].pbtnAction->EnableWindow(FALSE);
  424. break;
  426. case CONNECTED:
  427. m_LineControls[dwLineID].pFrame->m_Colorref = YELLOW;
  428. m_LineControls[dwLineID].pbtnAction->SetWindowText("Hangup");
  429. csTemp.Format("line %d", dwLineID);
  430. nNum = m_ctlActiveCalls.FindString(-1, (LPCTSTR) csTemp);
  431. if(nNum == CB_ERR) nNum = m_ctlActiveCalls.AddString((LPCTSTR) csTemp);
  432. m_ctlActiveCalls.SetCurSel(nNum);
  433. m_btnDial.EnableWindow();
  434. m_LineControls[dwLineID].pbtnAction->EnableWindow();
  435. if(((CTalkApp *)AfxGetApp())->m_wLineOptions[dwLineID] & AUTOPLAY) //play immediately
  436. {
  437. if(!(((CTalkApp *)AfxGetApp())->m_wLineOptions[dwLineID] & PLAY_ONCE)) break;
  438. ((CTalkApp *)AfxGetApp())->m_wLineOptions[dwLineID] &= ~PLAY_ONCE;
  439. csTemp.Format("line%d", dwLineID);
  440. csWaveName = AfxGetApp()->GetProfileString((LPCTSTR)csTemp, "WaveFile", "");
  441. if(csWaveName.IsEmpty()) csWaveName = "play.wav";
  442. pCall->Play(csWaveName.GetBuffer(128));
  443. }
  444. break;
  446. case HOLD:
  447. m_LineControls[dwLineID].pFrame->m_Colorref = BLUE;
  448. m_LineControls[dwLineID].pbtnAction->SetWindowText("Hangup");
  449. m_LineControls[dwLineID].pbtnAction->EnableWindow();
  450. break;
  452. case STOP_MAKING:
  453. case DROPPING:
  454. case DISCONNECTED:
  455. m_LineControls[dwLineID].pFrame->m_Colorref = ORANGE;
  456. m_LineControls[dwLineID].pbtnAction->SetWindowText("Hangup");
  457. csTemp.Format("line %d", dwLineID);
  458. if(1 == m_ctlActiveCalls.GetCount())  // the last one
  459. {
  460. m_ctlActiveCalls.ResetContent();
  461. m_btnDial.EnableWindow(FALSE);
  462. }
  463. nNum = m_ctlActiveCalls.FindString(-1, (LPCTSTR) csTemp);
  464. if(nNum != CB_ERR) m_ctlActiveCalls.DeleteString(nNum);
  465. break;
  467. default:
  468. break;
  469. }
  470. if(dwError != NULL)   // indication that something went wrong
  471. {
  472. m_LineControls[dwLineID].pFrame->m_Colorref = RED;
  473. m_LineControls[dwLineID].pbtnAction->SetWindowText("Hangup");
  474. m_LineControls[dwLineID].pbtnAction->EnableWindow();
  475. }
  476. UpdateData();
  477. m_LineControls[dwLineID].pFrame->Invalidate();
  478. }
  480. void CTalkDlg::DestroyPropSheet(DWORD dwIndex, BOOL bDestroyIfCalls)
  481. {
  482. DWORD i;
  483. // Destroy specific one
  484. if(dwIndex != 0xffffffff) 
  485. {
  486. if(m_LineControls[dwIndex].pInfoDlg != NULL)
  487. {
  488. if(bDestroyIfCalls &&
  489.   ((CInfo *)m_LineControls[dwIndex].pInfoDlg)->m_LineInfo.m_dwCalls == 0)
  490. return;
  491. if(((CInfo *)m_LineControls[dwIndex].pInfoDlg)->m_hWnd && 
  492. ((CInfo *)m_LineControls[dwIndex].pInfoDlg)->IsWindowVisible())
  493. ((CInfo *)m_LineControls[dwIndex].pInfoDlg)->DestroyWindow();
  494. delete ((CInfo *)m_LineControls[dwIndex].pInfoDlg);
  495. m_LineControls[dwIndex].pInfoDlg = NULL;
  496. }
  497. return;
  498. }
  499. for(i=0; i < m_dwLines; i++)
  500. {
  501. // Destroy prop sheets if any
  502. if(m_LineControls[i].pInfoDlg != NULL)
  503. {
  504. if(bDestroyIfCalls && 
  505.   ((CInfo *)m_LineControls[i].pInfoDlg)->m_LineInfo.m_dwCalls == 0)
  506. continue;
  507. if(((CInfo *)m_LineControls[i].pInfoDlg)->m_hWnd && 
  508. ((CInfo *)m_LineControls[i].pInfoDlg)->IsWindowVisible())
  509. ((CInfo *)m_LineControls[i].pInfoDlg)->DestroyWindow();
  510. delete ((CInfo *)m_LineControls[i].pInfoDlg);
  511. m_LineControls[i].pInfoDlg = NULL;
  512. }
  513. }
  514. }
  516. void CTalkDlg::OnDestroy() 
  517. {
  518. DWORD i;
  519. // destroy all allocated controls
  520. for(i = 1; i < m_dwLines; i++)
  521. {
  522. if(NULL != m_LineControls[i].pctlLineNum) delete m_LineControls[i].pctlLineNum;
  523. m_LineControls[i].pctlLineNum = NULL;
  524. if(NULL != m_LineControls[i].pFrame) delete m_LineControls[i].pFrame;
  525. m_LineControls[i].pFrame = NULL;
  526. if(NULL != m_LineControls[i].pbtnAction) delete m_LineControls[i].pbtnAction;
  527. m_LineControls[i].pbtnAction = NULL;
  528. if(NULL != m_LineControls[i].pbtnInfo) delete m_LineControls[i].pbtnInfo;
  529. m_LineControls[i].pbtnInfo = NULL;
  530. DestroyPropSheet(); // remove all
  531. }
  533. CDialog::OnDestroy();
  534. }
  536. BOOL CTalkDlg::OnCommand(WPARAM wParam, LPARAM lParam) 
  537. {
  538. DWORD i;
  540. if(wParam == IDC_TAPIALERT)
  541. {
  542. UpdateDisplayStatus((DWORD) lParam);
  543. return TRUE;
  544. }
  545. WORD wID = LOWORD(wParam);
  547. if((wID < (CONTROL_ARRAY_START + 1)) && wID > IDC_IND0) goto CommandFinish; // not in array
  548. if(!lParam || !wID || HIWORD(wParam) != BN_CLICKED) goto CommandFinish;
  549. for(i=0; i< m_dwLines; i++)
  550. {
  551. if(m_LineControls[i].uiActionID == wID) // Action button clicked
  552. {
  553. OnAction(i);
  554. break;
  555. }
  556. else if(m_LineControls[i].uiInfoID == wID) // Info button clicked
  557. {
  558. OnInfo(i);
  559. break;
  560. }
  561. }
  563. switch(wID) // Handle digits here
  564. {
  565. case IDC_0:
  566. AddDigit("0");
  567. break;
  568. case IDC_1:
  569. AddDigit("1");
  570. break;
  571. case IDC_2:
  572. AddDigit("2");
  573. break;
  574. case IDC_3:
  575. AddDigit("3");
  576. break;
  577. case IDC_4:
  578. AddDigit("4");
  579. break;
  580. case IDC_5:
  581. AddDigit("5");
  582. break;
  583. case IDC_6:
  584. AddDigit("6");
  585. break;
  586. case IDC_7:
  587. AddDigit("7");
  588. break;
  589. case IDC_8:
  590. AddDigit("8");
  591. break;
  592. case IDC_9:
  593. AddDigit("9");
  594. break;
  595. case IDC_POUND:
  596. AddDigit("#");
  597. break;
  598. case IDC_STAR:
  599. AddDigit("*");
  600. break;
  601. default:
  602. break;
  603. }
  605. CommandFinish:
  606. return CDialog::OnCommand(wParam, lParam);
  607. }
  609. void CTalkDlg::AddDigit(LPCSTR lpDigit)
  610. {
  611. if(lpDigit == NULL) // Clear
  612. {
  613.   m_csDialString.Empty();
  614. UpdateData(FALSE);
  615. return;
  616. }
  617. if(m_ctlDialString.GetSel())
  618. {
  619. m_ctlDialString.ReplaceSel(lpDigit);
  620. UpdateData(TRUE);
  621. }
  622. else
  623. {
  624. UpdateData(TRUE); // retrieve
  625. m_csDialString += lpDigit;
  626. UpdateData(FALSE); // save
  627. }
  628. }
  630. // If there is a call, try to dial on it
  631. void CTalkDlg::OnDial() 
  632. {
  633. int nNum;
  634. DWORD i;
  635. CString csTemp, csTemp1; 
  636. LONG lrc;
  638. // first, get the currently selected call
  639. nNum = m_ctlActiveCalls.GetCurSel();
  640. if(nNum == CB_ERR) return;
  641. m_ctlActiveCalls.GetLBText(nNum, csTemp);
  642. for(i=0; i<m_dwLines; i++)
  643. {
  644. csTemp1.Format("line %d", i);
  645. if(!csTemp.Compare((LPCTSTR) csTemp1)) break;
  646. }
  647. if(i >= m_dwLines) i--;
  648. UpdateData();
  649. lrc = m_LineControls[i].pctlLine->ctlLineDial(NULL, (LPCSTR) m_csDialString, 0L); // Country code=0 for now
  650. if(lrc < 0) 
  651. {
  652. char szErr[48];
  653. if(!((CTalkApp *)AfxGetApp())->Code2Error(lrc, szErr, 46))
  654. csTemp.Format("Dial on line %d failed reason=%lx", i, lrc);
  655. else
  656. csTemp.Format("Dial on line %d failed reason=%s", i, szErr);
  657. AfxMessageBox(csTemp);
  658. }
  659. }
  661. // Find the pCall using hWave, finish palying on that call.
  662. LONG CTalkDlg::OnWomDone(UINT wParam, LONG lParam)
  663. {
  664. CTapiCall *pCall = (CTapiCall *)(((CTalkApp *)AfxGetApp())->GetCallByParm(KEY_WAVEOUTHANDLE, (DWORD) wParam));
  665. if(pCall != NULL) 
  666. {
  667. // For MT implementation, signal the semaphore here 
  668. pCall->FinishPlay(wParam, lParam); // override this for MT implementation
  669. } 
  670. //::WavexFinishPlay(wParam, lParam);
  671. return TRUE;
  672. }
  674. // End of recording handler
  675. LONG CTalkDlg::OnWimData(UINT wParam, LONG lParam)
  676. {
  677. TRACE("*** TALKER32 ***: WIM_DATA wParam=%lx, lParam=%lxn", wParam, lParam);
  678. CTapiCall *pCall = (CTapiCall *)(((CTalkApp *)AfxGetApp())->GetCallByParm(KEY_WAVEINHANDLE, (DWORD) wParam));
  679. if(pCall != NULL) 
  680. {
  681. // For MT implementation, signal the semaphore here 
  682. pCall->FinishRecord(wParam, lParam); // override this for MT implementation
  683. }
  684. //::WavexFinishRecord(wParam, lParam, NULL);  
  685. return TRUE;
  686. }
  689. void CTalkDlg::OnCancel() 
  690. {
  691. // lineConfigDialog(0, m_hWnd, "tapi/line");
  692. ((CTalkApp *)AfxGetApp())->Cleanup();
  693. // may have to wait until all calls are actually closed
  694. CDialog::OnCancel();
  695. }
  697. void CTalkDlg::OnOK() 
  698. {
  699. }
  701. void CTalkDlg::OnClear() 
  702. {
  703. AddDigit(NULL);
  704. }
  706. void CTalkDlg::OnContextHelp() 
  707. {
  708. CDialog::WinHelp(HIDD_TALKER32_DialogMain, HELP_CONTEXT);
  709. }
  711. void CTalkDlg::OnSetFocus(CWnd* pOldWnd) 
  712. {
  713. CDialog::OnSetFocus(pOldWnd);
  714. ((CTalkApp *)AfxGetApp())->SetHelpId(HIDD_TALKER32_DialogMain);
  715. }
  716. void CTalkDlg::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized) 
  717. {
  718. CDialog::OnActivate(nState, pWndOther, bMinimized);
  719. ((CTalkApp *)AfxGetApp())->SetHelpId(HIDD_TALKER32_DialogMain);
  720. }
  722. /*************************
  723. void CTalkDlg::OnCheck1() 
  724. {
  725. CTapiCall *pCall = m_LineControls[0].pctlLine->ctlGetActiveCall();
  726. if(pCall == NULL) return;
  727. if(m_ctlMonitor.GetCheck())
  728. {
  729. LONG lrc = lineMonitorDigits(pCall->m_hCall, LINEDIGITMODE_DTMF);
  730. if(lrc) AfxMessageBox("Monitor failed");
  731. }
  732. else
  733. lineMonitorDigits(pCall->m_hCall,0);
  734. }
  736. void CTalkDlg::OnCheck2() 
  737. {
  738. if(m_ctlGather.GetCheck())
  739. {
  740. CTapiCall *pCall = m_LineControls[0].pctlLine->ctlGetActiveCall();
  741. if(pCall == NULL) return;
  743. // LONG lrc = pCall->GatherDigits(20, "*#", 10000, 5000, "");
  744. LPSTR lpDigits = (LPSTR)malloc(2048);
  745. LPSTR lpDelimit = (LPSTR) malloc(16);
  746. lstrcpy(lpDelimit, "*#");
  747. memset(lpDigits, 0, sizeof(lpDigits));
  748. LONG lrc = lineGatherDigits(pCall->m_hCall, LINEDIGITMODE_DTMF, lpDigits,
  749. 20, lpDelimit, 8000, 5000);
  750. if(lrc) AfxMessageBox("Gather failed");
  751. }
  752. }
  753. *********************/