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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > TAPI编程 > 查看源码
TAPISampleDlg.cpp.svn-base
资源名称：TAPISample.rar　[点击查看]
上传用户：c1686688
上传日期：2015-06-15
资源大小：73k
文件大小：11k
源码类别：

TAPI编程

开发平台：

Visual C++

TAPISampleDlg.cpp.svn-base：源码内容
  1. // TAPISampleDlg.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "TAPISample.h"
  6. #include "TAPISampleDlg.h"
  8. #ifdef _DEBUG
  9. #define new DEBUG_NEW
  10. #undef THIS_FILE
  11. static char THIS_FILE[] = __FILE__;
  12. #endif
  14. /////////////////////////////////////////////////////////////////////////////
  15. // CAboutDlg dialog used for App About
  17. class CAboutDlg : public CDialog
  18. {
  19. public:
  20. CAboutDlg();
  22. // Dialog Data
  23. //{{AFX_DATA(CAboutDlg)
  24. enum { IDD = IDD_ABOUTBOX };
  25. //}}AFX_DATA
  27. // ClassWizard generated virtual function overrides
  28. //{{AFX_VIRTUAL(CAboutDlg)
  29. protected:
  30. virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
  31. //}}AFX_VIRTUAL
  33. // Implementation
  34. protected:
  35. //{{AFX_MSG(CAboutDlg)
  36. //}}AFX_MSG
  37. DECLARE_MESSAGE_MAP()
  38. };
  40. CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
  41. {
  42. //{{AFX_DATA_INIT(CAboutDlg)
  43. //}}AFX_DATA_INIT
  44. }
  46. void CAboutDlg::DoDataExchange(CDataExchange* pDX)
  47. {
  48. CDialog::DoDataExchange(pDX);
  49. //{{AFX_DATA_MAP(CAboutDlg)
  50. //}}AFX_DATA_MAP
  51. }
  53. BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
  54. //{{AFX_MSG_MAP(CAboutDlg)
  55. // No message handlers
  56. //}}AFX_MSG_MAP
  57. END_MESSAGE_MAP()
  59. /////////////////////////////////////////////////////////////////////////////
  60. // CTAPISampleDlg dialog
  62. CTAPISampleDlg::CTAPISampleDlg(CWnd* pParent /*=NULL*/)
  63. : CDialog(CTAPISampleDlg::IDD, pParent)
  64. {
  65. //{{AFX_DATA_INIT(CTAPISampleDlg)
  66. // NOTE: the ClassWizard will add member initialization here
  67. //}}AFX_DATA_INIT
  68. // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
  69. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  70. }
  72. void CTAPISampleDlg::DoDataExchange(CDataExchange* pDX)
  73. {
  74. CDialog::DoDataExchange(pDX);
  75. //{{AFX_DATA_MAP(CTAPISampleDlg)
  76. // NOTE: the ClassWizard will add DDX and DDV calls here
  77. //}}AFX_DATA_MAP
  78. }
  80. BEGIN_MESSAGE_MAP(CTAPISampleDlg, CDialog)
  81. //{{AFX_MSG_MAP(CTAPISampleDlg)
  82. ON_WM_SYSCOMMAND()
  83. ON_WM_PAINT()
  84. ON_WM_QUERYDRAGICON()
  85. ON_BN_CLICKED(IDC_BTNWAIT, OnBtnWait)
  86. ON_BN_CLICKED(IDC_BTNOPEN, OnBtnOpen)
  87. ON_BN_CLICKED(IDC_BTNDIAL, OnBtnDial)
  88. ON_BN_CLICKED(IDC_BTNCOMHANDLE, OnBtnComHandle)
  89. ON_BN_CLICKED(IDC_BTNREAD, OnBtnRead)
  90. ON_BN_CLICKED(IDC_BTNWRITE, OnBtnWrite)
  91. ON_BN_CLICKED(IDC_BTNREADCLEAR, OnBtnReadClear)
  92. ON_BN_CLICKED(IDC_BTNWRITECLEAR, OnBtnWriteClear)
  93. //}}AFX_MSG_MAP
  94. END_MESSAGE_MAP()
  96. /////////////////////////////////////////////////////////////////////////////
  97. // CTAPISampleDlg message handlers
  99. BOOL CTAPISampleDlg::OnInitDialog()
  100. {
  101. CDialog::OnInitDialog();
  103. // Add "About..." menu item to system menu.
  105. // IDM_ABOUTBOX must be in the system command range.
  106. ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
  107. ASSERT(IDM_ABOUTBOX < 0xF000);
  109. CMenu* pSysMenu = GetSystemMenu(FALSE);
  110. if (pSysMenu != NULL)
  111. {
  112. CString strAboutMenu;
  113. strAboutMenu.LoadString(IDS_ABOUTBOX);
  114. if (!strAboutMenu.IsEmpty())
  115. {
  116. pSysMenu->AppendMenu(MF_SEPARATOR);
  117. pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
  118. }
  119. }
  121. // Set the icon for this dialog.  The framework does this automatically
  122. //  when the application's main window is not a dialog
  123. SetIcon(m_hIcon, TRUE); // Set big icon
  124. SetIcon(m_hIcon, FALSE); // Set small icon
  126. m_hWaitForCallThread= NULL;
  127. m_hSerialHandle= NULL;
  128. m_bStopReadThread = true;
  129. m_hReadThread = NULL;
  131. GetDlgItem(IDC_BTNWAIT)->EnableWindow(false);
  132. GetDlgItem(IDC_BTNDIAL)->EnableWindow(false);
  133. GetDlgItem(IDC_BTNWRITE)->EnableWindow(false);
  134. GetDlgItem(IDC_BTNREAD)->EnableWindow(false);
  136. return TRUE;  // return TRUE  unless you set the focus to a control
  137. }
  139. void CTAPISampleDlg::OnSysCommand(UINT nID, LPARAM lParam)
  140. {
  141. if ((nID & 0xFFF0) == IDM_ABOUTBOX)
  142. {
  143. CAboutDlg dlgAbout;
  144. dlgAbout.DoModal();
  145. }
  146. else
  147. {
  148. CDialog::OnSysCommand(nID, lParam);
  149. }
  150. }
  152. // If you add a minimize button to your dialog, you will need the code below
  153. //  to draw the icon.  For MFC applications using the document/view model,
  154. //  this is automatically done for you by the framework.
  156. void CTAPISampleDlg::OnPaint() 
  157. {
  158. if (IsIconic())
  159. {
  160. CPaintDC dc(this); // device context for painting
  162. SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
  164. // Center icon in client rectangle
  165. int cxIcon = GetSystemMetrics(SM_CXICON);
  166. int cyIcon = GetSystemMetrics(SM_CYICON);
  167. CRect rect;
  168. GetClientRect(&rect);
  169. int x = (rect.Width() - cxIcon + 1) / 2;
  170. int y = (rect.Height() - cyIcon + 1) / 2;
  172. // Draw the icon
  173. dc.DrawIcon(x, y, m_hIcon);
  174. }
  175. else
  176. {
  177. CDialog::OnPaint();
  178. }
  179. }
  181. // The system calls this to obtain the cursor to display while the user drags
  182. //  the minimized window.
  183. HCURSOR CTAPISampleDlg::OnQueryDragIcon()
  184. {
  185. return (HCURSOR) m_hIcon;
  186. }
  188. void CTAPISampleDlg::OnBtnReadClear() 
  189. {
  190. SetDlgItemText(IDC_EDTREAD,"");
  191. SetDlgItemText(IDC_EDTREADLEN,"");
  192. }
  194. void CTAPISampleDlg::OnBtnWriteClear() 
  195. {
  196. SetDlgItemText(IDC_EDTWRITE,"");
  197. SetDlgItemText(IDC_EDTWRITELEN,"");
  198. }
  200. void CTAPISampleDlg::OnBtnOpen() 
  201. {
  202. int nRet;
  203. CString cszText;
  204. char *szError;
  206. GetDlgItemText(IDC_BTNOPEN,cszText);
  208. if(cszText == "Open")
  209. {
  210. nRet = cCall.Open();
  211. if(nRet)
  212. {
  213. cCall.GetErrorString(nRet,szError);
  214. AfxMessageBox(szError,MB_ICONERROR|MB_OK);
  215. return;
  216. }
  217. SetDlgItemText(IDC_BTNOPEN,"Close");
  218. GetDlgItem(IDC_BTNWAIT)->EnableWindow(true);
  219. GetDlgItem(IDC_BTNDIAL)->EnableWindow(true);
  220. }
  221. else
  222. {
  223. nRet = cCall.Close();
  224. if(nRet)
  225. {
  226. cCall.GetErrorString(nRet,szError);
  227. AfxMessageBox(szError,MB_ICONERROR|MB_OK);
  228. return;
  229. }
  230. SetDlgItemText(IDC_BTNOPEN,"Open");
  231. GetDlgItem(IDC_BTNWAIT)->EnableWindow(false);
  232. GetDlgItem(IDC_BTNDIAL)->EnableWindow(false);
  234. if(m_hWaitForCallThread)
  235. {
  236. TerminateThread(m_hWaitForCallThread,0);
  237. CloseHandle(m_hWaitForCallThread);
  238. m_hWaitForCallThread=NULL;
  239. }
  240. }
  241. }
  244. void CTAPISampleDlg::OnBtnWait() 
  245. {// since the waiting function holds we'll put it in a thread
  246. if(m_hWaitForCallThread)
  247. {
  248. TerminateThread(m_hWaitForCallThread,0);
  249. CloseHandle(m_hWaitForCallThread);
  250. m_hWaitForCallThread=NULL;
  251. }
  252. m_hWaitForCallThread = CreateThread(NULL,0,WaitForCallThread,this,0,0);
  254. GetDlgItem(IDC_BTNWAIT)->EnableWindow(false); // making it disable
  255. }
  257. void CTAPISampleDlg::OnBtnDial() 
  258. {
  259. CString cszText;
  260. char *szText;
  262. GetDlgItemText(IDC_EDTDIALNUMBER,cszText);
  264. int nRet = cCall.MakeOutgoingCall(cszText.GetBuffer(0));
  265. cszText.ReleaseBuffer();
  267. if(nRet)
  268. {
  269. cCall.GetErrorString(nRet,szText);
  270. AfxMessageBox(szText,MB_ICONERROR|MB_OK);
  271. return;
  272. }
  273. GetDlgItem(IDC_BTNCOMHANDLE)->EnableWindow(true);
  274. }
  276. void CTAPISampleDlg::OnBtnComHandle() 
  277. {
  278. long lRet;
  279. CString cszText;
  280. char *szError;
  282. GetDlgItemText(IDC_BTNCOMHANDLE,cszText);
  284. if(cszText == "Get Handle")
  285. {
  286. m_hSerialHandle = cCall.GetHandle("comm/datamodem",&lRet);
  287. if(lRet)
  288. {
  289. m_hSerialHandle = NULL;
  290. cCall.GetErrorString(lRet,szError);
  291. AfxMessageBox(szError,MB_ICONERROR|MB_OK);
  292. return;
  293. }
  294. SetDlgItemText(IDC_BTNCOMHANDLE,"Close Handle");
  295. GetDlgItem(IDC_BTNWRITE)->EnableWindow(true);
  296. GetDlgItem(IDC_BTNREAD)->EnableWindow(true);
  297. SetDlgItemText(IDC_BTNREAD,"Read");
  298. }
  299. else
  300. {
  301. if(m_hReadThread)
  302. {
  303. m_bStopReadThread = true;
  304. Sleep(1000);
  305. TerminateThread(m_hReadThread,0);
  306. CloseHandle(m_hReadThread);
  307. m_hReadThread=NULL;
  308. }
  310. CloseHandle(m_hSerialHandle);
  311. m_hSerialHandle = NULL;
  313. SetDlgItemText(IDC_BTNCOMHANDLE,"Get Handle");
  314. GetDlgItem(IDC_BTNWRITE)->EnableWindow(false);
  315. GetDlgItem(IDC_BTNREAD)->EnableWindow(false);
  316. SetDlgItemText(IDC_BTNREAD,"Read");
  317. }
  318. }
  320. void CTAPISampleDlg::OnBtnRead() 
  321. {
  322. CString cszText;
  324. GetDlgItemText(IDC_BTNREAD,cszText);
  326. if(cszText == "Read")
  327. {
  328. m_bStopReadThread = false;
  329. m_hReadThread = CreateThread(NULL,0,ReadThread,this,0,0);
  330. SetDlgItemText(IDC_BTNREAD,"Stop");
  331. }
  332. else
  333. {
  334. if(m_hReadThread)
  335. {
  336. m_bStopReadThread = true;
  337. Sleep(1000);
  338. TerminateThread(m_hReadThread,0);
  339. CloseHandle(m_hReadThread);
  340. m_hReadThread=NULL;
  341. }
  342. SetDlgItemText(IDC_BTNREAD,"Read");
  343. }
  344. }
  346. void CTAPISampleDlg::OnBtnWrite() 
  347. {
  348. char *szBuff = (char*)malloc(512);
  350. DWORD dwWriteLen =0;
  351. int nRet;
  352. char *szText;
  353. CString cszText;
  355. OVERLAPPED ov;
  356. ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  357. ov.Offset = 0;
  358. ov.OffsetHigh = 0;
  360. GetDlgItemText(IDC_EDTWRITE,szBuff,512);
  362. nRet = WriteFile(m_hSerialHandle,szBuff,strlen(szBuff),&dwWriteLen,&ov);
  363. if(!nRet)
  364. {
  365. if(!nRet)
  366. {
  367. nRet = GetLastError();
  368. if(nRet != ERROR_IO_PENDING)
  369. {
  370. cCall.GetErrorString(nRet,szText);
  371. AfxMessageBox(szText,MB_ICONERROR|MB_OK);
  372. free(szBuff);
  373. return;
  374. }
  375. }
  377. switch(WaitForSingleObject(ov.hEvent,INFINITE))
  378. {
  379. case WAIT_OBJECT_0:
  380. GetOverlappedResult(m_hSerialHandle, &ov, &dwWriteLen,FALSE);
  381. break;
  382. default:
  383. break;
  384. };
  385. }
  386. free(szBuff);
  388. SetDlgItemInt(IDC_EDTWRITELEN,GetDlgItemInt(IDC_EDTWRITELEN)+dwWriteLen);
  389. }
  391. DWORD WINAPI CTAPISampleDlg::WaitForCallThread(LPVOID lpVoid)
  392. {
  393. CTAPISampleDlg *pcDlg = (CTAPISampleDlg *)lpVoid;
  395. char *szError;
  396. int nRet = pcDlg->cCall.GetIncomingCall();
  397. if(nRet)
  398. {
  399. pcDlg->cCall.GetErrorString(nRet,szError);
  400. AfxMessageBox(szError,MB_ICONERROR|MB_OK);
  401. return nRet;
  402. }
  403. pcDlg->GetDlgItem(IDC_BTNWAIT)->EnableWindow(true);
  404. pcDlg->GetDlgItem(IDC_BTNCOMHANDLE)->EnableWindow(true);
  405. return 0;
  406. }
  408. DWORD WINAPI CTAPISampleDlg::ReadThread(LPVOID lpVoid)
  409. {
  410. CTAPISampleDlg *pcDlg = (CTAPISampleDlg *)lpVoid;
  412. char *szBuff = (char*)malloc(512);
  414. DWORD dwReadLen;
  415. int nRet;
  416. char *szText;
  417. CString cszText;
  419. OVERLAPPED ov;
  420. ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  421. ov.Offset = 0;
  422. ov.OffsetHigh = 0;
  424. for(;!pcDlg->m_bStopReadThread;)
  425. {
  426. nRet = ReadFile(pcDlg->m_hSerialHandle,szBuff,512,&dwReadLen,&ov);
  427. if(!nRet)
  428. {
  429. nRet = GetLastError();
  430. if(nRet != ERROR_IO_PENDING)
  431. {
  432. pcDlg->cCall.GetErrorString(nRet,szText);
  433. AfxMessageBox(szText,MB_ICONERROR|MB_OK);
  434. free(szBuff);
  435. return nRet;
  436. }
  437. }
  439. switch(WaitForSingleObject(ov.hEvent,INFINITE))
  440. {
  441. case WAIT_OBJECT_0:
  442. GetOverlappedResult(pcDlg->m_hSerialHandle, &ov, &dwReadLen,FALSE);
  443. break;
  444. default:
  445. break;
  446. };
  447. szBuff[dwReadLen] = 0;
  448. pcDlg->GetDlgItemText(IDC_EDTREAD,cszText);
  449. cszText += szBuff;
  450. pcDlg->SetDlgItemText(IDC_EDTREAD,cszText);
  451. pcDlg->SetDlgItemInt(IDC_EDTREADLEN,pcDlg->GetDlgItemInt(IDC_EDTREADLEN)+dwReadLen);
  452. ((CEdit*)pcDlg->GetDlgItem(IDC_EDTREAD))->LineScroll(((CEdit*)pcDlg->GetDlgItem(IDC_EDTREAD))->GetLineCount());
  453. }
  454. free(szBuff);
  455. return 0;
  456. }