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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
0AVDConfDlg.cpp
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：17k
源码类别：

多媒体编程

开发平台：

Visual C++

0AVDConfDlg.cpp：源码内容
  3. #include "stdafx.h"
  4. #include "rtccore.h"
  6. #include "AVDConf.h"
  7. #include "AVDConfDlg.h"
  8. #include "MakeCallDlg.h"
  9. #include "incomingdlg.h"
  11. #include "defines.h"
  13. #ifdef _DEBUG
  14. #define new DEBUG_NEW
  15. #undef THIS_FILE
  16. static char THIS_FILE[] = __FILE__;
  17. #endif
  20. BSTR g_bstrAddr;
  25. class CAboutDlg : public CDialog
  26. {
  27. public:
  28. CAboutDlg();
  32. enum { IDD = IDD_ABOUTBOX };
  37. protected:
  38. virtual void DoDataExchange(CDataExchange* pDX);    
  42. protected:
  45. DECLARE_MESSAGE_MAP()
  46. };
  48. CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
  49. {
  52. }
  54. void CAboutDlg::DoDataExchange(CDataExchange* pDX)
  55. {
  56. CDialog::DoDataExchange(pDX);
  59. }
  61. BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
  65. END_MESSAGE_MAP()
  70. CAVDConfDlg::CAVDConfDlg(CWnd* pParent )
  71. : CDialog(CAVDConfDlg::IDD, pParent)
  72. {
  76. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  77. }
  79. void CAVDConfDlg::DoDataExchange(CDataExchange* pDX)
  80. {
  81. CDialog::DoDataExchange(pDX);
  83. DDX_Control(pDX, IDC_WHITEBOARD, m_cWhiteboard);
  84. DDX_Control(pDX, IDC_MESSAGING, m_cMessaging);
  85. DDX_Control(pDX, IDC_TUNING, m_cTuning);
  86.   DDX_Control(pDX, IDC_MAKECALL, m_cMakeCall);
  87.   DDX_Control(pDX, IDC_APPCALL, m_cAppCall);
  89. }
  91. BEGIN_MESSAGE_MAP(CAVDConfDlg, CDialog)
  93. ON_WM_PAINT()
  94. ON_WM_QUERYDRAGICON()
  95. ON_BN_CLICKED(IDC_MAKECALL, OnMakecall)
  96. ON_BN_CLICKED(IDC_APPCALL, OnAppcall)
  97. ON_BN_CLICKED(IDC_TUNING, OnTuning)
  98. ON_BN_CLICKED(IDC_MESSAGING, OnMessaging)
  99. ON_BN_CLICKED(IDM_ABOUTBOX, OnAboutbox)
  100. ON_BN_CLICKED(IDC_WHITEBOARD, OnWhiteboard)
  102. END_MESSAGE_MAP()
  105. BOOL CAVDConfDlg::OnInitDialog()
  106. {
  107. CDialog::OnInitDialog();
  110. SetIcon(m_hIcon, TRUE);
  111. SetIcon(m_hIcon, FALSE);
  114. if (InitRTCClient() != S_OK)
  115. {
  117. MessageBox ( "Initialization Error" );
  118. m_cMakeCall.EnableWindow ( FALSE );
  119. m_cAppCall.EnableWindow ( FALSE );
  120. m_cMessaging.EnableWindow ( FALSE );
  121. m_cTuning.EnableWindow ( FALSE );
  122. m_cWhiteboard.EnableWindow ( FALSE );
  123. }
  125. return TRUE;  
  126. }
  129. void CAVDConfDlg::OnPaint() 
  130. {
  131. if (IsIconic())
  132. {
  133. CPaintDC dc(this); 
  135. SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
  138. int cxIcon = GetSystemMetrics(SM_CXICON);
  139. int cyIcon = GetSystemMetrics(SM_CYICON);
  140. CRect rect;
  141. GetClientRect(&rect);
  142. int x = (rect.Width() - cxIcon + 1) / 2;
  143. int y = (rect.Height() - cyIcon + 1) / 2;
  146. dc.DrawIcon(x, y, m_hIcon);
  147. }
  148. else
  149. {
  150. CDialog::OnPaint();
  151. }
  152. }
  155. HCURSOR CAVDConfDlg::OnQueryDragIcon()
  156. {
  157. return (HCURSOR) m_hIcon;
  158. }
  161. void CAVDConfDlg::OnMakecall() 
  162. {
  163. MakeCallDlg cDlg;
  166. if (cDlg.DoModal() == IDOK)
  167. {
  168. /
  169. MakeCall (RTCST_PC_TO_PC, g_bstrAddr);
  170. }
  171. }
  175. void CAVDConfDlg::OnMessaging() 
  176. {
  177.   MakeCallDlg cDlg;
  178.  
  179. if (cDlg.DoModal() == IDOK)
  180.   {  
  181. MakeCall (RTCST_IM, g_bstrAddr);
  182. }
  183. }
  186. void CAVDConfDlg::OnAppcall() 
  187. {
  188. HRESULT hr;
  189. VARIANT_BOOL vbool = VARIANT_FALSE;
  191. m_pClient->get_IsT120AppletRunning(RTCTA_APPSHARING, &vbool);
  193. if (vbool == VARIANT_FALSE)
  194. { 
  195. hr = m_pClient->StartT120Applet ( RTCTA_APPSHARING );
  196. }
  197. }
  200. void CAVDConfDlg::OnWhiteboard() 
  201. {
  202. HRESULT hr;
  203. VARIANT_BOOL vbool = VARIANT_FALSE;
  205. m_pClient->get_IsT120AppletRunning(RTCTA_WHITEBOARD, &vbool);
  207. if (vbool == VARIANT_FALSE)
  208. { 
  209. hr = m_pClient->StartT120Applet ( RTCTA_WHITEBOARD );
  210. }
  211. }
  214. HRESULT CAVDConfDlg::MakeCall(RTC_SESSION_TYPE enType, BSTR bstrURI)
  215. {
  216.     HRESULT hr;
  218. if (enType != RTCST_IM)
  219.     {
  220.         
  221. if ((m_AVDlg) && (m_AVDlg.GetState () != RTCSS_IDLE))
  222.         {
  223. MessageBoxW (m_hWnd, L"An audio/video call is in progress!", NULL, MB_OK );
  224.             return S_FALSE;
  225.         }
  226.     }
  228.     IRTCSession * pSession = NULL;
  230.     hr = m_pClient->CreateSession(enType, NULL, NULL, 0, &pSession);
  232.     if (FAILED(hr))
  233.     {
  234.         return hr;
  235.     }
  237.     
  238.     hr = pSession->AddParticipant(bstrURI, NULL, &m_Participant);
  240. if (FAILED(hr))
  241.     {
  242.         SAFE_RELEASE(pSession);
  243.         return hr;
  244.     }
  246.     
  247.     hr = AddSession(pSession, enType);
  248.     
  249.     if (FAILED(hr))
  250.     {  
  251.             
  252.         return hr;
  253.     }
  255.     return S_OK;
  256. }
  259. HRESULT CAVDConfDlg::InitRTCClient()
  260. {
  261. HRESULT hr;
  263. m_pClient = NULL;
  264. m_pEvents = NULL;
  266. hr = CoInitialize(NULL);
  268. if (FAILED(hr))
  269. {
  270. return hr;
  271. }
  273. hr = CoCreateInstance (CLSID_RTCClient, NULL,
  274. CLSCTX_INPROC_SERVER, IID_IRTCClient,
  275. (LPVOID *)&m_pClient);
  277. if (FAILED(hr))
  278. {
  279. return hr;
  280. }
  282. hr = m_pClient->Initialize();
  284. if (FAILED(hr))
  285. {
  286. SAFE_RELEASE(m_pClient);
  287. return hr;
  288. }
  290. m_pClient->SetPreferredMediaTypes ( RTCMT_ALL, VARIANT_TRUE );
  292. long lEventMask = RTCEF_SESSION_STATE_CHANGE |
  293.   RTCEF_MESSAGING |
  294.   RTCEF_MEDIA |
  295.   RTCEF_INTENSITY |
  296.   RTCEF_CLIENT;
  298. hr = m_pClient->put_EventFilter( lEventMask );
  300.     if ( FAILED(hr) )
  301.     {
  302.         SAFE_RELEASE(m_pClient);
  303.         return hr;
  304.     }
  306.     m_pEvents = new CRTCEvents;
  308.     if (!m_pEvents)
  309.     {
  310.         SAFE_RELEASE(m_pClient);
  311.         return hr;
  312.     }
  314.     hr = m_pEvents->Advise( m_pClient, m_hWnd );
  316.     if ( FAILED(hr) )
  317.     {
  318.         SAFE_RELEASE(m_pClient);
  319.         return hr;
  320.     }
  322.     
  323.     hr = m_pClient->put_ListenForIncomingSessions(RTCLM_BOTH); 
  327.     if ( FAILED(hr) )
  328.     {
  329.     
  330.         SAFE_RELEASE(m_pClient);
  331.         return hr;
  332.     }
  335. if (m_AVDlg)
  336. m_AVDlg.SetState (RTCSS_IDLE);
  338. return S_OK;
  339. }
  342. LRESULT CAVDConfDlg::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  343. {
  344. switch (message)
  345. {
  346. case WM_RTC_EVENT:
  347. OnRTCEvent (message, wParam, lParam);
  348. break;
  349. }
  350. return CDialog::WindowProc(message, wParam, lParam);
  351. }
  354. HRESULT CAVDConfDlg::OnRTCEvent(UINT message, WPARAM wParam, LPARAM lParam)
  355. {
  356.     IDispatch * pDisp = (IDispatch *)lParam;
  357.     RTC_EVENT enEvent = (RTC_EVENT)wParam;
  358.     HRESULT hr;
  360.    
  361.     switch ( wParam )
  362.     {
  363.         case RTCE_SESSION_STATE_CHANGE:
  364.             {
  365.                 IRTCSessionStateChangeEvent * pEvent = NULL;
  366.                 
  367.                 
  368. hr = pDisp->QueryInterface( IID_IRTCSessionStateChangeEvent,
  369.                                             (void **)&pEvent );
  371.                 if (SUCCEEDED(hr))
  372.                 {
  373.                     OnRTCSessionStateChangeEvent(pEvent);
  374.                     SAFE_RELEASE(pEvent);
  375.                 }              
  376.             }
  377.             break;
  379.         case RTCE_MESSAGING:
  380.             {
  381.                 IRTCMessagingEvent * pEvent = NULL;
  382.                 
  383.                 
  384.                 hr = pDisp->QueryInterface( IID_IRTCMessagingEvent,
  385.                                             (void **)&pEvent );
  387.                 if (SUCCEEDED(hr))
  388.                 {
  389.                     OnRTCMessagingEvent(pEvent);
  390.                     SAFE_RELEASE(pEvent);
  391.                 }              
  392.             }
  393.             break;
  395.         case RTCE_MEDIA:
  396.             {
  397.                 IRTCMediaEvent * pEvent = NULL;
  399.                 
  400.                 hr = pDisp->QueryInterface( IID_IRTCMediaEvent,
  401.                                             (void **)&pEvent );
  403.                 if (SUCCEEDED(hr))
  404.                 {
  405.                     OnRTCMediaEvent(pEvent);
  406.                     SAFE_RELEASE(pEvent);
  407.                 }
  408.             }
  409.             break;
  411.         case RTCE_INTENSITY:
  412.             {
  413.                 IRTCIntensityEvent * pEvent = NULL;
  415.                 
  416.                 hr = pDisp->QueryInterface( IID_IRTCIntensityEvent,
  417.                                             (void **)&pEvent );
  419.                 if (SUCCEEDED(hr))
  420.                 {
  421.                     OnRTCIntensityEvent(pEvent);
  422.                     SAFE_RELEASE(pEvent);
  423.                 }
  424.             }
  425.             break;
  427.         case RTCE_CLIENT:
  428.             {
  429.                 IRTCClientEvent * pEvent = NULL;
  431.                 
  432.                 hr = pDisp->QueryInterface( IID_IRTCClientEvent,
  433.                                             (void **)&pEvent );
  435.                 if (SUCCEEDED(hr))
  436.                 {
  437.                     OnRTCClientEvent(pEvent);
  438.                     SAFE_RELEASE(pEvent);
  439.                 }
  440.             }
  441.             break;
  442.     }
  444.     
  445.     SAFE_RELEASE(pDisp);
  447.     return S_OK;
  448. }
  457. void CAVDConfDlg::OnTuning() 
  458. {
  459. if (m_pClient)
  460. m_pClient->InvokeTuningWizard((OAHWND)m_hWnd);
  461. }
  469. void CAVDConfDlg::OnRTCSessionStateChangeEvent(IRTCSessionStateChangeEvent *pEvent)
  470. {
  471.     IRTCSession * pSession = NULL;
  472.     RTC_SESSION_STATE enState;
  473.     HRESULT hr;
  475.     
  476. hr = pEvent->get_State(&enState);
  478.     if (FAILED(hr))
  479.     {
  480.         
  481.         return;
  482.     }
  484.     
  485. hr = pEvent->get_Session(&pSession);
  487.     if (FAILED(hr))
  488.     {
  489.         
  490.         return;
  491.     }
  493.     switch ( enState )
  494. {
  495. case RTCSS_INCOMING:
  496.         {
  499.             
  500.             RTC_SESSION_TYPE enType;
  501.             
  502. hr = pSession->get_Type(&enType);
  504.             if (FAILED(hr))
  505.             {
  506.                 
  507.                 SAFE_RELEASE(pSession);
  508.                 return;
  509.             }            
  511.             if (enType == RTCST_IM)
  512.             {
  513.                 
  514.                 m_pClient->PlayRing(RTCRT_MESSAGE, VARIANT_TRUE);
  515.             }
  516.             else            
  517.             {
  518.                 
  519.                 if ((m_AVDlg) && (m_AVDlg.GetState() != RTCSS_IDLE))
  520.                 {
  521.                     
  522.                     
  523.                     pSession->Terminate(RTCTR_BUSY);
  525.                     SAFE_RELEASE(pSession);
  526.                     return;
  527.                 }
  528.                     
  529.                 
  530.                 IRTCEnumParticipants * pEnum = NULL;
  531.                 IRTCParticipant * pParticipant = NULL;
  533.                 hr = pSession->EnumerateParticipants(&pEnum);
  535.                 if (FAILED(hr))
  536.                 {
  537.                     
  538.                     SAFE_RELEASE(pSession);
  539.                     return;
  540.                 }
  542.                 hr = pEnum->Next(1, &pParticipant, NULL);
  544.                 SAFE_RELEASE(pEnum);
  546.                 if (hr != S_OK)
  547.                 {
  548.                     
  549.                     SAFE_RELEASE(pSession);
  550.                     return;
  551.                 }
  553.                 
  554.                 BSTR bstrURI = NULL;
  556.                 hr = pParticipant->get_UserURI(&bstrURI);
  558.                 if (FAILED(hr))
  559.                 {
  560.                     
  561.                     SAFE_RELEASE(pSession);
  562.                     SAFE_RELEASE(pParticipant);
  563.                     return;
  564.                 }
  566.                 
  567.                 BSTR bstrName = NULL;
  568.                 hr = pParticipant->get_Name(&bstrName);
  570.                 SAFE_RELEASE(pParticipant);
  572.                 if (FAILED(hr))
  573.                 {
  574.                     
  575.                     SAFE_FREE_STRING(bstrURI);
  576.                     SAFE_RELEASE(pSession);
  577.                     return;
  578.                 }
  580.                 
  581.                 m_pClient->PlayRing(RTCRT_PHONE, VARIANT_TRUE);
  583.                 
  584.                 BOOL fAccept;
  585. CIncomingDlg cDlg;    
  586. SESSION_DATA pData;
  588. pData.bstrName = bstrName;
  589. pData.bstrURI = bstrURI;
  591. SetWindowLong ( m_hWnd, GWL_USERDATA, (LONG)&pData);
  594. fAccept = (cDlg.DoModal() == IDOK);
  597. SAFE_FREE_STRING(bstrURI);
  598. SAFE_FREE_STRING(bstrName);
  599.                     
  600.                 if (fAccept)
  601.                 {
  602.                     
  603.                     hr = pSession->Answer();
  605.                     if (FAILED(hr))
  606.                     {
  607.                         
  608.                         SAFE_RELEASE(pSession);
  609.                         return;
  610.                     }
  611.                 }
  612.                 else
  613.                 {
  614.                     
  615.                     pSession->Terminate(RTCTR_REJECT);
  617. SAFE_RELEASE(pSession);
  618.                     return;
  619.                 }
  620.             }  
  621.             
  622.             
  623.             
  624.             hr = AddSession(pSession, enType);
  626.             if (FAILED(hr))
  627.             {
  628.                 
  629.                 SAFE_RELEASE(pSession);
  630.                 return;
  631.             }
  632.         }        
  633. break;
  634. }
  636.     
  637. if (m_AVDlg)
  638. m_AVDlg.SetState (enState);
  639. }
  647. void CAVDConfDlg::OnRTCMediaEvent(IRTCMediaEvent *pEvent)
  648. {
  649.     long lMediaType;
  650.     RTC_MEDIA_EVENT_TYPE enType;
  651.     RTC_MEDIA_EVENT_REASON enReason;
  652.     HRESULT hr;
  654. hr = pEvent->get_MediaType(&lMediaType);
  656.     if (FAILED(hr))
  657.     {
  658.         
  659.         return;
  660.     }
  662.     hr = pEvent->get_EventType(&enType);   
  663.     if (FAILED(hr))
  664.     {
  665.         
  666.         return;
  667.     }
  669.     hr = pEvent->get_EventReason(&enReason);
  671.     if (FAILED(hr))
  672.     {
  673.         
  674.         return;
  675.     }
  677. if ((m_AVDlg) && (m_AVDlg.GetState () != RTCSS_IDLE))
  678.     {
  679.         
  680.         m_AVDlg.DeliverMedia(lMediaType, enType, enReason);
  681.     }
  682. }
  690. void CAVDConfDlg::OnRTCIntensityEvent(IRTCIntensityEvent *pEvent)
  691. {
  692.     RTC_AUDIO_DEVICE enDevice;
  693.     long lLevel, lMin, lMax;
  694.     HRESULT hr;
  696.     
  697. hr = pEvent->get_Direction(&enDevice);
  699.     if (FAILED(hr))
  700.     {
  701.         
  702.         return;
  703.     }
  705.     hr = pEvent->get_Level(&lLevel);
  707.     if (FAILED(hr))
  708.     {
  709.         
  710.         return;
  711.     }
  713.     hr = pEvent->get_Min(&lMin);
  715.     if (FAILED(hr))
  716.     {
  717.         
  718.         return;
  719.     }
  721.     hr = pEvent->get_Max(&lMax);
  723.     if (FAILED(hr))
  724.     {
  725.         
  726.         return;
  727.     }
  729.     
  730.     if ((lMax - lMin) == 0)
  731.     {
  732.         lLevel = 0;
  733.     }
  734.     else
  735.     {
  736.         lLevel = (lLevel - lMin) * 100 / (lMax - lMin);
  737.     }
  739. if (m_AVDlg.GetState () != RTCSS_IDLE)
  740.     {
  741.         
  742.         m_AVDlg.DeliverIntensity(enDevice, lLevel);
  743.     }
  744. }
  752. void CAVDConfDlg::OnRTCClientEvent(IRTCClientEvent *pEvent)
  753. {
  754.     HRESULT hr;
  756.     
  757.     RTC_CLIENT_EVENT_TYPE enEventType;
  759.     hr = pEvent->get_EventType(&enEventType);
  761.     if (FAILED(hr))
  762.     {
  763.         
  764.         return;
  765.     }
  767.     if ( enEventType == RTCCET_ASYNC_CLEANUP_DONE )
  768.     {
  769.         m_pClient->Shutdown();
  770. SAFE_RELEASE(m_pClient);
  772.         
  773.         DestroyWindow();
  774.     }
  775.     else
  776.     {
  777.         if (m_AVDlg.GetState() != RTCSS_IDLE)
  778.         {
  779.             
  780.             m_AVDlg.DeliverClient(enEventType);
  781.         }
  782.     }
  783. }
  792. HRESULT CAVDConfDlg::AddSession(IRTCSession *pSession, RTC_SESSION_TYPE enType)
  793. {
  794.     
  795.     BOOL fAVSession = (enType != RTCST_IM);
  797.     
  799. if (fAVSession)
  800. {
  801. BOOL ret = m_AVDlg.Create (IDD_AVDLG,this);
  802. if (!ret)
  803. {
  804. MessageBox ( "Error Creating Dialog" );
  805. }
  806. m_AVDlg.ShowWindow (SW_SHOW);
  807. m_AVDlg.SetParentClient (m_pClient);
  808. m_AVDlg.SetSession (pSession);
  809. }
  810. else
  811. {
  812. BOOL ret = m_cMessageDlg.Create (IDD_MESSAGEDLG, this);
  813. if (!ret)
  814. {
  815. MessageBox ( "Error Creating Dialog" );
  816. }
  817. m_cMessageDlg.ShowWindow (SW_SHOW);
  818. m_cMessageDlg.SetParentClient ( m_pClient );
  819. m_cMessageDlg.SetSession (pSession);
  821. }
  823. return S_OK;
  824. }
  834. HRESULT CAVDConfDlg::OnRTCMessagingEvent(IRTCMessagingEvent *pEvent)
  835. {
  836.     IRTCSession * pSession = NULL;
  837.     
  838.     IRTCParticipant * pParticipant = NULL;
  839.     RTC_MESSAGING_EVENT_TYPE enType;
  840.     RTC_MESSAGING_USER_STATUS enStatus;
  841.     BSTR bstrContentType = NULL;
  842.     BSTR bstrMessage = NULL;
  843.     HRESULT hr;
  845.     hr = pEvent->get_Session(&pSession);
  847.     if (FAILED(hr))
  848.     {
  849.         
  850.         return S_FALSE;
  851.     }
  852.     
  853.     hr = pEvent->get_EventType(&enType);
  855.     if (FAILED(hr))
  856.     {
  857.         
  858.         return S_FALSE;
  859.     }
  861.     hr = pEvent->get_Participant(&pParticipant);
  863.     if (FAILED(hr))
  864.     {
  865.         
  866.         return S_FALSE;
  867.     }
  869.     if (enType == RTCMSET_MESSAGE)
  870.     {
  871.         hr = pEvent->get_MessageHeader(&bstrContentType);
  873.         if (FAILED(hr))
  874.         {
  875.             
  876.             SAFE_RELEASE(pParticipant);
  877.             return S_FALSE;
  878.         }
  880.         hr = pEvent->get_Message(&bstrMessage);
  882.         if (FAILED(hr))
  883.         {
  884.             
  885.             SAFE_RELEASE(pParticipant);
  886.             SAFE_FREE_STRING(bstrContentType);
  887.             return S_FALSE;
  888.         }
  890.         
  891.         if (m_cMessageDlg)
  892. m_cMessageDlg.DeliverMessage(pParticipant, bstrContentType, bstrMessage);
  894.         SAFE_FREE_STRING(bstrContentType);
  895.         SAFE_FREE_STRING(bstrMessage);
  896.     }
  897.     else if (enType == RTCMSET_STATUS)
  898.     {
  899.         hr = pEvent->get_UserStatus(&enStatus);
  901.         if (FAILED(hr))
  902.         {
  903.             
  904.             return S_FALSE;
  905.         }
  907.         
  908.         m_cMessageDlg.DeliverUserStatus(pParticipant, enStatus);
  909.     }
  911.     SAFE_RELEASE(pParticipant); 
  913. return S_OK;
  914. }
  922. void CAVDConfDlg::OnOK() 
  923. {
  924. if (m_pClient)
  925. {
  926. m_pClient->StopT120Applets();
  928. m_pClient->PrepareForShutdown();
  930. if (m_pEvents)
  931. {
  932. m_pEvents->Unadvise( m_pClient);
  933. }
  934. }
  937. CDialog::OnOK();
  938. }
  947. void CAVDConfDlg::OnCancel ()
  948. {
  949. MessageBox ( "Please use the shutdownnbutton to quit." );
  950. return;
  951. }
  959. void CAVDConfDlg::OnAboutbox() 
  960. {
  961. CAboutDlg dlgAbout;
  962. dlgAbout.DoModal();
  963. }