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

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

TAPI编程

开发平台：

Visual C++

TALKER32.CPP：源码内容
  1. // talker32.cpp : Defines the class behaviors for the application.
  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 "helpid.h"
  12. #include "devspec.h"
  14. #ifdef _DEBUG
  15. #undef THIS_FILE
  16. static char BASED_CODE THIS_FILE[] = __FILE__;
  17. #endif
  19. /////////////////////////////////////////////////////////////////////////////
  20. // CTalkApp
  22. BEGIN_MESSAGE_MAP(CTalkApp, CTapiApp)
  23. //{{AFX_MSG_MAP(CTalkApp)
  24. // NOTE - the ClassWizard will add and remove mapping macros here.
  25. //    DO NOT EDIT what you see in these blocks of generated code!
  26. ON_COMMAND(ID_HELP, OnHelp)
  27. //}}AFX_MSG
  28. END_MESSAGE_MAP()
  30. /////////////////////////////////////////////////////////////////////////////
  31. // CTalkApp construction
  33. CTalkApp::CTalkApp()
  34. {
  35. m_dwTapiAlert = 0;
  36. }
  38. /////////////////////////////////////////////////////////////////////////////
  39. // The one and only CTalkApp object
  41. CTalkApp theApp;
  43. /////////////////////////////////////////////////////////////////////////////
  44. // CTalkApp initialization
  46. BOOL CTalkApp::InitInstance()
  47. {
  48. DWORD i, dwrc;
  49. CString csTemp, csAA;
  51. if(!CTapiApp::InitInstance()) // failed to initialize
  52. return FALSE;
  54. memset((PBYTE)m_ctlLines, 0, sizeof(m_ctlLines));
  55. CStatusBox sbDlg;
  56. sbDlg.m_csStatus = "Initializing TAPI..."; 
  57. sbDlg.Create(IDD_STATUSDLG);
  58. if(m_dwLines > MAXLINES) 
  59. {
  60. AfxMessageBox("This program supports up to 16 lines", MB_ICONEXCLAMATION);
  61. m_dwLines = MAXLINES;
  62. }
  64. // Read optional info
  65. memset((LPBYTE)m_wLineOptions, 0, sizeof(m_wLineOptions));
  66. SetRegistryKey("Dialogic\SystemRelease 4.x");
  68. for(i = 0; i < m_dwLines; i++)
  69. {
  70. dwrc = 0L;
  71. if(NULL == (m_ctlLines[i] = new CTapiLine(i)))  //constructor dn open the line
  72. MessageBox(NULL, "Failed to get Cline", NULL, MB_OK);
  73. else dwrc = m_ctlLines[i]->ctlLineOpen(i);
  74. if(dwrc) 
  75. {
  76. char szErr[48];
  77. if(!Code2Error(dwrc, szErr, 46))
  78. csTemp.Format("Failed to open line %d reason=%lx", i, dwrc);
  79. else
  80. csTemp.Format("Failed to open line %d, reason=%s", i, szErr);
  81. MessageBox(NULL, (LPCTSTR)csTemp, NULL, MB_ICONSTOP);
  82. }
  83. else sbDlg.m_csStatus.Format("Line %d opened", i);
  84. sbDlg.UpdateData(FALSE);    
  85. csTemp.Format("Line%d", i);
  86. csAA = GetProfileString((LPCTSTR)csTemp, "AutoAnswer", "");
  87. if(!csAA.IsEmpty())  // Default mode is no autoanswer
  88. {
  89. csAA.MakeUpper();
  90. if((-1 != csAA.Find("YES")) || (-1 != csAA.Find("ON"))) 
  91. m_wLineOptions[i] |= AUTOANSWER; // set bit 
  92. }
  93. csAA = GetProfileString((LPCTSTR)csTemp, "AutoPlay", "");
  94. if(!csAA.IsEmpty())  // Default mode is no autoplay
  95. {
  96. csAA.MakeUpper();
  97. if((-1 != csAA.Find("YES")) || (-1 != csAA.Find("ON"))) 
  98. m_wLineOptions[i] |= AUTOPLAY; // set bit 
  99. }
  100. }
  102. sbDlg.DestroyWindow();
  103. CTalkDlg dlg;
  104. m_pMainWnd = &dlg;
  105. int nResponse = dlg.DoModal();
  106. if (nResponse == IDOK)
  107. {
  108. // TODO: Place code here to handle when the dialog is
  109. //  dismissed with OK
  110. }
  111. else if (nResponse == IDCANCEL)
  112. {
  113. // TODO: Place code here to handle when the dialog is
  114. //  dismissed with Cancel
  115. }
  117. // Since the dialog has been closed, return FALSE so that we exit the
  118. //  application, rather than start the application's message pump.
  119. return FALSE;
  120. }
  122. // Check for active calls, close them properly; called from the front end before shutting down the app
  123. void CTalkApp::Cleanup()
  124. {
  125. DWORD i;
  127. for(i=0; i<m_dwLines; i++)
  128. m_ctlLines[i]->ctlLineDrop();    
  129. }
  131. // close the lines; if there are active calls shut them
  132. int CTalkApp::ExitInstance() 
  133. {
  134. DWORD i;
  135.  
  136. for(i=0; i<m_dwLines; i++)
  137. {
  138. if(m_ctlLines[i])    
  139. delete m_ctlLines[i];
  140. }
  141. return CTapiApp::ExitInstance();
  142. }
  144. // Get CTapiLine by hLine
  145. CTapiLine * CTalkApp::GetLineByHLine(HLINE hLine)
  146. {
  147. DWORD i;
  149. for(i=0; i < m_dwLines; i++)
  150. {
  151. if(m_ctlLines[i] && m_ctlLines[i]->ctlGetHLine() == hLine) 
  152. { 
  153. return m_ctlLines[i];
  154. }
  155. }
  156. return NULL;
  157. }
  159. // Get CTapiLine by hcall
  160. CTapiLine * CTalkApp::GetLineByCall(HCALL hCall)
  161. {
  162. LPLINECALLINFO lpLCI = GetCallInfo(hCall);
  163. if(lpLCI == NULL) return NULL; // failed for some reason
  165. // implement additional logic here to search thru inactive calls
  166. CTapiLine *pLine = GetLineByHLine(lpLCI->hLine); 
  167. delete (LPBYTE) lpLCI;
  168. return pLine;
  169. }
  171. // Find pCall by specified parameter
  172. LPVOID CTalkApp::GetCallByParm(WORD wKey, DWORD dwValue)
  173. {
  174. DWORD i;
  175. CTapiCall *pCall;
  177. for(i=0; i< m_dwLines; i++)
  178. {
  179. if(NULL == m_ctlLines[i] || (NULL == (pCall = m_ctlLines[i]->ctlGetActiveCall()))) continue;
  180. switch(wKey)
  181. {
  182. case KEY_LINE:
  183.   if(m_ctlLines[i] == (CTapiLine *)dwValue) return (LPVOID)pCall;
  184. break;
  186. case KEY_WAVEINHANDLE:
  187. if(NULL != dwValue && pCall->GetHWaveIn() == dwValue) 
  188. return (LPVOID)pCall;
  189. break;
  191. case KEY_WAVEOUTHANDLE:
  192. if(NULL != dwValue && pCall->GetHWaveOut() == dwValue) 
  193. return (LPVOID)pCall;
  194. break;
  196. default:
  197. break;
  198. }
  199. }
  200. return NULL;  // not found
  201. }
  203. // override of CTapiApp implementation
  204. void CTalkApp::OnLineReply(DWORD dwCallback, DWORD dwRequest, DWORD dwStatus)
  205. {
  206. // first, find the request
  207. TRACE("*** TALKER32 *** :enter OnReply ID=%lx Status=%lxn", dwRequest, dwStatus);
  208. PASYNCCALL pAC = FindAsyncID(dwRequest, FIND_ID);
  209. if(pAC == NULL)  // not found for some reason (???)
  210. {
  211. TRACE1("*** TALKER32 *** :Request ID=%lx not found!n", dwRequest);
  212. return;
  213. }
  214. ASSERT(pAC->dwID == dwRequest);  // sanity check
  216. CTapiLine *pCurLine = (CTapiLine *) pAC->pvLine;
  217. switch (pAC->wFunction)
  218. {
  219. case FUNCTION_MAKECALL:  
  220. if(dwStatus & 0x80000000)  // makecall failed, try to drop 
  221. {
  222. TRACE("*** TALKER32 *** :MakeCall ID=%lx failed, err=%lxn", dwRequest, dwStatus);
  223. // notify the line, let it find out what to do
  224. }
  225. pCurLine->ctlUpdateCallStatus(pAC->wFunction, dwStatus, (CTapiCall *)(pAC->pvCall));
  226. break;
  228. case FUNCTION_DROP:
  229. if(dwStatus & 0x80000000)  // drop failed 
  230. TRACE("*** TALKER32 *** :Drop ID=%lx failed, err=%lxn", dwRequest, dwStatus);
  231. // notify the line, let it find out what to do
  232. pCurLine->ctlUpdateCallStatus(pAC->wFunction, dwStatus, (CTapiCall *)(pAC->pvCall));
  233. break;
  235. case FUNCTION_ANSWER:
  236. // Answer succeeded?...
  237. if(dwStatus & 0x80000000)  // answer failed 
  238. TRACE("*** TALKER32 *** :Answer ID=%lx failed, err=%lxn", dwRequest, dwStatus);
  239. pCurLine->ctlUpdateCallStatus(pAC->wFunction, dwStatus, (CTapiCall *)(pAC->pvCall));
  240. break;
  242. case FUNCTION_DIAL:
  243. if(dwStatus & 0x80000000)  // answer failed 
  244. TRACE("*** TALKER32 *** :Dial ID=%lx failed, err=%lxn", dwRequest, dwStatus);
  245. pCurLine->ctlUpdateCallStatus(pAC->wFunction, dwStatus, (CTapiCall *)(pAC->pvCall));
  246. break;
  248. case FUNCTION_DEVSPEC:  // device specific...
  249. if(dwStatus & 0x80000000)  
  250. TRACE("*** TALKER32 *** :Devspec ID=%lx failed, err=%lxn", dwRequest, dwStatus);
  251. pCurLine->ctlUpdateCallStatus(pAC->wFunction, dwStatus, (CTapiCall *)(pAC->pvCall));
  252. break;
  254. default:
  255. TRACE("*** TALKER32 ***: Undefined async function calln"); 
  256. break;
  257. } // end of switch(wFunction)
  258. TRACE("*** TALKER32 *** :exit OnReply ID=%lxn", dwRequest);
  260. FindAsyncID(dwRequest, REMOVE_ID); // Done, remove the ID from list
  261. }
  263. // Override of CTapiApp OnLineCallInfo implementation
  264. void CTalkApp::OnLineCallInfo(HCALL hCall, DWORD dwCallBack, DWORD dwParm)
  265. {
  266. BOOL brc, bFound = FALSE;
  267. DWORD i;
  269. LPLINECALLINFO lpCI = GetCallInfo(hCall);
  270. TRACE("*** TALKER32 *** :OnLineCallinfo hCall=%lx, DevID=%dn", 
  271. hCall, lpCI->dwLineDeviceID);
  272. if(lpCI == NULL) return;
  273. for(i=0; i < m_dwLines; i++)
  274. {
  275. if(m_ctlLines[i] && m_ctlLines[i]->ctlGetHLine() == lpCI->hLine) 
  276. { 
  277. bFound = TRUE;
  278. break;
  279. }
  280. }
  281. if(bFound) brc = m_ctlLines[i]->ctlUpdateCallInfo(hCall, lpCI); 
  282. if(!bFound || (bFound && brc == FALSE)) delete lpCI;
  283. }
  285. // Override of CTapiApp OnCallState implementation
  286. void CTalkApp::OnCallState(HCALL hCall, DWORD hCallback, DWORD dwCallState,
  287. DWORD dwCallStateDetail, DWORD dwCallPrivilege)
  288. {
  289. // May issue lineGetCallStatus here to get info
  290. CString csTemp;
  291. DWORD dwDiscMode;
  292. LONG lrc;
  294. TRACE("*** TALKER32 *** :OnLineCallState hCall=%lx, state=%lx, detail=%lxn",
  295.  hCall, dwCallState, dwCallStateDetail);
  296. CTapiLine *pclTemp = GetLineByCall(hCall);
  297. if(pclTemp == NULL)  // line not found
  298. {
  299. TRACE("*** TALKER32 ***: OnCallState failed to find linen");
  300. return;
  301. }
  302. CTapiCall *pCall = pclTemp->ctlGetActiveCall();
  303. if(pCall == NULL && dwCallState != LINECALLSTATE_OFFERING 
  304.  && dwCallState != LINECALLSTATE_ACCEPTED ) // call not found - probably offering
  305. {
  306. TRACE("*** TALKER32 ***: OnCallState failed to find calln");
  307. return;
  308. }
  310. switch(dwCallState)
  311. {
  312. case LINECALLSTATE_DIALING:
  313.         case LINECALLSTATE_DIALTONE:
  314.         case LINECALLSTATE_PROCEEDING:
  315.         // not clear what to do if this collides w/Drop -so do nothing
  316. TRACE("*** TALKER32 ***: Callstate = %sn", dwCallState==LINECALLSTATE_DIALTONE ? "Dialtone" :
  317.                 dwCallState==LINECALLSTATE_DIALING ? "Dialing" : "Proceeding");
  318. // pCall->UpdateCallState(CONNECTED, 0xffff, dwCallState);
  319. NotifyFrontEnd(pclTemp->ctlGetLineID());
  320.          break; 
  322. case LINECALLSTATE_OFFERING:
  323. case LINECALLSTATE_ACCEPTED:     
  324. TRACE("*** TALKER32 ***: Callstate = %sn", dwCallState==LINECALLSTATE_OFFERING ? "Offering" : "Accepted");
  325. if(pCall)
  326. {
  327. TRACE("*** TALKER32 ***: Cannot answer, another call is active on this linen");
  328. csTemp.Format("Cannot answer call on line %d, another call still activen", pclTemp->ctlGetLineID());
  329. m_pMainWnd->MessageBox(csTemp);
  330. }  
  331. else if(pclTemp != NULL)
  332. pclTemp->ctlOfferCall(hCall);  // line allocates call & alerts front end
  333.          break;
  335. case LINECALLSTATE_CONNECTED: 
  336. TRACE("*** TALKER32 ***: Callstate = Connectedn");
  337. pCall->UpdateCallState(CONNECTED, 0xffff, dwCallState);
  338. m_wLineOptions[pclTemp->ctlGetLineID()] |= PLAY_ONCE;
  339. NotifyFrontEnd(pclTemp->ctlGetLineID());
  340.             break;
  341.         
  342.         case LINECALLSTATE_DISCONNECTED: 
  343.         case LINECALLSTATE_SPECIALINFO:
  344.         case LINECALLSTATE_BUSY:
  345. if (dwCallState == LINECALLSTATE_DISCONNECTED)
  346. TRACE("*** TALKER32 ***: Callstate = Disconnected, reason=%lxn", dwCallStateDetail);
  347. else if (dwCallState == LINECALLSTATE_BUSY)
  348. TRACE("*** TALKER32 ***: Callstate = BUSY, mode = %lxn", dwCallStateDetail);
  349. else if (dwCallState == LINECALLSTATE_SPECIALINFO)
  350. TRACE("*** TALKER32 ***: Callstate = SPECIALINFO, mode = %lxn", dwCallStateDetail);
  351. dwDiscMode = dwCallStateDetail;
  352. if (dwDiscMode == 0) dwDiscMode = LINEDISCONNECTMODE_NORMAL;
  353. pCall->UpdateCallState(DISCONNECTED, 0xffff, dwCallState);
  354. /*            fCallOK = (discMode == LINEDISCONNECTMODE_NORMAL
  355.                 || discMode == LINEDISCONNECTMODE_UNKNOWN
  356.                 || discMode == LINEDISCONNECTMODE_PICKUP
  357.                 || discMode == LINEDISCONNECTMODE_FORWARDED
  358.                 || discMode == LINEDISCONNECTMODE_UNAVAIL);
  359.  */           
  360.             lrc = pclTemp->ctlLineDrop(pCall); // which will notify front end
  361. if(lrc <0)
  362. TRACE("*** TALKER32 ***: lineDrop failed rc = %lxn", lrc);
  363.             break;
  365.         case LINECALLSTATE_IDLE: 
  366. TRACE("*** TALKER32 ***: Callstate IDLE for hcall=%lxn", hCall);
  367. pCall->UpdateCallState(IDLE, IDLE, dwCallState);
  368.             pclTemp->ctlLineDeallocateCall(pCall);
  369.             break;   
  371. default:
  372. break;
  373. } // switch CALLSTATE
  375. }
  377. // LINE_MONITORDIGITS processor
  378. void CTalkApp::OnMonitorDigits(HCALL hCall, DWORD dwCallBack, DWORD dwDigit, DWORD dwDigitMode)
  379. {
  380. TRACE("***: OnMonitorDigits digit = %lxn", dwDigit);
  381. CTapiLine *pclTemp = GetLineByCall(hCall);
  382. if(pclTemp == NULL)  // line not found
  383. {
  384. TRACE("*** TALKER32 ***: OnMonitorDigits failed to find linen");
  385. return;
  386. }
  387. CTapiCall *pCall = pclTemp->ctlGetActiveCall();
  388. if(pCall == NULL)  
  389. {
  390. TRACE("*** TALKER32 ***: OnMonitorDigits failed to find calln");
  391. return;
  392. }
  393. pCall->UpdateMonitorState(MONITOR_DIGITS, dwDigit, dwDigitMode); // new status
  394. pCall->NotifyCallWindow((UINT)dwDigit, (LONG)dwDigitMode); // post a message that status has changed
  395. }
  397. // LINE_GATHERDIGITS processor
  398. void CTalkApp::OnGatherDigits(HCALL hCall, DWORD dwCallBack, DWORD dwTermination)
  399. {
  400. CString csTemp;
  401. CTapiLine *pclTemp = GetLineByCall(hCall);
  402. TRACE("***: OnGatherDigits term = %lxn", dwTermination);
  403. if(pclTemp == NULL)  // line not found
  404. {
  405. TRACE("*** TALKER32 ***: OnGatherDigits failed to find linen");
  406. return;
  407. }
  408. CTapiCall *pCall = pclTemp->ctlGetActiveCall();
  409. if(pCall == NULL)  
  410. {
  411. TRACE("*** TALKER32 ***: OnGatherDigits failed to find calln");
  412. return;
  413. }
  414. pCall->UpdateMonitorState(END_GATHER_DIGITS, dwTermination, 0L); // new status
  415. // pCall->NotifyCallWindow(); // post a message that status has changed
  416. pCall->NotifyCallWindow(0, (LONG)dwTermination); // post a message that status has changed
  417. }
  419. // Process LINE_MONITORMEDIA callback
  420. void CTalkApp::OnMonitorMedia(DWORD hCall, DWORD dwCallBack, DWORD dwParm1, DWORD dwParm2, DWORD dwParm3)
  421. {
  422. // This is a temp workaround until MS fixes remotesp.tsp to process Devspecific & Generate events
  423. if(dwParm1) return;
  424. switch(dwParm2)
  425. {
  426. case PLAY_WAVE:
  427. case RECORD_WAVE:
  428. OnLineDevSpec(hCall, dwCallBack, dwParm2, dwParm3==55 ? 0 : dwParm3, 1111);
  429. return;
  430. default:
  431. return;
  432. }
  433. }
  435. // Process LINE_DEVSPECIFIC callback
  436. void CTalkApp::OnLineDevSpec(DWORD hCall, DWORD dwCallBack, DWORD dwParm1, DWORD dwParm2, DWORD dwParm3)
  437. {
  438. // the action depends on the meaning of parm1
  439. if(dwParm1 != PLAY_WAVE && dwParm1 != RECORD_WAVE) return;
  440. CTapiLine *pLine = (dwParm3 == 1111 ? GetLineByCall((HCALL) hCall) :
  441.   GetLineByHLine((HLINE)hCall));
  442. if(pLine)
  443. pLine->ctlUpdateDevSpecStatus(dwParm2 ? DEVSPEC_RESULTFAILED : DEVSPEC_IDLE);
  444. }
  446. // translate code into verbal call state
  447. BOOL CTalkApp::Code2CallState(DWORD dwState, LPSTR lpBuf, int nSize)
  448. {
  449. BOOL brc = TRUE;
  450. switch(dwState)
  451. {
  452. case LINECALLSTATE_IDLE:
  453. strncpy(lpBuf, "LINECALLSTATE_IDLE", nSize);
  454. break;
  455. case LINECALLSTATE_OFFERING:
  456. strncpy(lpBuf, "LINECALLSTATE_OFFERING", nSize);
  457. break;
  458. case LINECALLSTATE_ACCEPTED:
  459. strncpy(lpBuf, "LINECALLSTATE_ACCEPTED", nSize);
  460. break;
  461. case LINECALLSTATE_DIALTONE:
  462. strncpy(lpBuf, "LINECALLSTATE_DIALTONE", nSize);
  463. break;
  464. case LINECALLSTATE_DIALING:
  465. strncpy(lpBuf, "LINECALLSTATE_DIALING", nSize);
  466. break;
  467. case LINECALLSTATE_RINGBACK:
  468. strncpy(lpBuf, "LINECALLSTATE_RINGBACK", nSize);
  469. break;
  470. case LINECALLSTATE_BUSY:
  471. strncpy(lpBuf, "LINECALLSTATE_BUSY", nSize);
  472. break;
  473. case LINECALLSTATE_SPECIALINFO:
  474. strncpy(lpBuf, "LINECALLSTATE_SPECIALINFO", nSize);
  475. break;
  476. case LINECALLSTATE_CONNECTED:
  477. strncpy(lpBuf, "LINECALLSTATE_CONNECTED", nSize);
  478. break;
  479. case LINECALLSTATE_PROCEEDING:
  480. strncpy(lpBuf, "LINECALLSTATE_PROCEEDING", nSize);
  481. break;
  482. case LINECALLSTATE_ONHOLD:
  483. strncpy(lpBuf, "LINECALLSTATE_ONHOLD", nSize);
  484. break;
  485. case LINECALLSTATE_DISCONNECTED:
  486. strncpy(lpBuf, "LINECALLSTATE_DISCONNECTED", nSize);
  487. break;
  488. case LINECALLSTATE_UNKNOWN:
  489. strncpy(lpBuf, "LINECALLSTATE_UNKNOWN", nSize);
  490. break;
  491. case LINECALLSTATE_ONHOLDPENDTRANSFER:
  492. strncpy(lpBuf, "LINECALLSTATE_ONHOLDPENDTRANSFER", nSize);
  493. break;
  494. default:
  495. brc = FALSE; // not found
  496. break;
  497. }
  498. return brc;
  499. }
  501. BOOL CTalkApp::Code2Error(DWORD dwErr, LPSTR lpBuf, int nSize)
  502. {
  503. BOOL brc = TRUE;
  504. switch(dwErr)
  505. {
  506. case LINEERR_BADDEVICEID:
  507. strncpy(lpBuf, "LINEERR_BADDEVICEID", nSize);
  508. break;
  509. case LINEERR_INCOMPATIBLEAPIVERSION:
  510. strncpy(lpBuf, "LINEERR_INCOMPATIBLEAPIVERSION", nSize);
  511. break;
  512. case LINEERR_INCOMPATIBLEEXTVERSION:
  513. strncpy(lpBuf, "LINEERR_INCOMPATIBLEEXTVERSION", nSize);
  514. break;
  515. case LINEERR_INUSE:
  516. strncpy(lpBuf, "LINEERR_INUSE", nSize);
  517. break;
  518. case LINEERR_INVALCALLHANDLE:
  519. strncpy(lpBuf, "LINEERR_INVALCALLHANDLE", nSize);
  520. break;
  521. case LINEERR_INVALCALLPRIVILEGE:
  522. strncpy(lpBuf, "LINEERR_INVALCALLPRIVILEGE", nSize);
  523. break;
  524. case LINEERR_INVALCALLSTATE:
  525. strncpy(lpBuf, "LINEERR_INVALCALLSTATE", nSize);
  526. break;
  527. case LINEERR_INVALMEDIAMODE:
  528. strncpy(lpBuf, "LINEERR_INVALMEDIAMODE", nSize);
  529. break;
  530. case LINEERR_INVALPARAM:
  531. strncpy(lpBuf, "LINEERR_INVALPARAM", nSize);
  532. break;
  533. case LINEERR_INVALPOINTER:
  534. strncpy(lpBuf, "LINEERR_INVALPOINTER", nSize);
  535. break;
  536. case LINEERR_OPERATIONFAILED:
  537. strncpy(lpBuf, "LINEERR_OPERATIONFAILED", nSize);
  538. break;
  539. case LINEERR_OPERATIONUNAVAIL:
  540. strncpy(lpBuf, "LINEERR_OPERATIONUNAVAIL", nSize);
  541. break;
  542. default:
  543. brc = FALSE; // not found
  544. break;
  545. }
  546. return brc;
  547. }
  549. void CTalkApp::OnHelp()
  550. {
  551. // if(m_pMainWnd->GetSafeHwnd() == ::GetActiveWindow())
  552. // WinHelp(HIDD_TALKER32_DialogMain, HELP_CONTEXT);
  553. // else
  554. // WinHelp(HIDD_TALKER32_DialogLineInfo, HELP_CONTEXT);
  555. WinHelp(m_nHelpId, HELP_CONTEXT);
  556. }
  558. /////////////////////////////////////////////////////////////////////////////
  559. // CStatusBox dialog
  562. CStatusBox::CStatusBox(CWnd* pParent /*=NULL*/)
  563. : CDialog(CStatusBox::IDD, pParent)
  564. {
  565. //{{AFX_DATA_INIT(CStatusBox)
  566. m_csStatus = _T("");
  567. //}}AFX_DATA_INIT
  568. }
  571. void CStatusBox::DoDataExchange(CDataExchange* pDX)
  572. {
  573. CDialog::DoDataExchange(pDX);
  574. //{{AFX_DATA_MAP(CStatusBox)
  575. DDX_Text(pDX, IDC_STATUS, m_csStatus);
  576. //}}AFX_DATA_MAP
  577. }
  580. BEGIN_MESSAGE_MAP(CStatusBox, CDialog)
  581. //{{AFX_MSG_MAP(CStatusBox)
  582. //}}AFX_MSG_MAP
  583. END_MESSAGE_MAP()
  586. /////////////////////////////////////////////////////////////////////////////
  587. // CStatusBox message handlers
  589. BOOL CStatusBox::OnInitDialog() 
  590. {
  591. CDialog::OnInitDialog();
  593. // TODO: Add extra initialization here
  595. return TRUE;  // return TRUE unless you set the focus to a control
  596.               // EXCEPTION: OCX Property Pages should return FALSE
  597. }