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

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

多媒体编程

开发平台：

Visual C++

AVDConfDlg.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "rtccore_i.c"
  3. #include "rtccore.h"
  4. #include "AVDConf.h"
  5. #include "AVDConfDlg.h"
  6. #include "MakeCallDlg.h"
  7. #include "incomingdlg.h"
  8. #include "defines.h"
  10. #ifdef _DEBUG
  11. #define new DEBUG_NEW
  12. #undef THIS_FILE
  13. static char THIS_FILE[] = __FILE__;
  14. #endif
  15. BSTR g_bstrAddr;
  16. class CAboutDlg : public CDialog
  17. {
  18. public:
  19. CAboutDlg();
  21. enum { IDD = IDD_ABOUTBOX };
  25. protected:
  26. virtual void DoDataExchange(CDataExchange* pDX);    
  28. protected:
  31. DECLARE_MESSAGE_MAP()
  32. };
  33. CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
  34. {
  37. }
  38. void CAboutDlg::DoDataExchange(CDataExchange* pDX)
  39. {
  40. CDialog::DoDataExchange(pDX);
  43. }
  44. BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
  48. END_MESSAGE_MAP()
  49. CAVDConfDlg::CAVDConfDlg(CWnd* pParent )
  50. : CDialog(CAVDConfDlg::IDD, pParent)
  51. {
  55. m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
  56. }
  57. void CAVDConfDlg::DoDataExchange(CDataExchange* pDX)
  58. {
  59. CDialog::DoDataExchange(pDX);
  61. DDX_Control(pDX, IDC_WHITEBOARD, m_cWhiteboard);
  62. DDX_Control(pDX, IDC_MESSAGING, m_cMessaging);
  63. DDX_Control(pDX, IDC_TUNING, m_cTuning);
  64.   DDX_Control(pDX, IDC_MAKECALL, m_cMakeCall);
  65.   DDX_Control(pDX, IDC_APPCALL, m_cAppCall);
  67. }
  68. BEGIN_MESSAGE_MAP(CAVDConfDlg, CDialog)
  70. ON_WM_PAINT()
  71. ON_WM_QUERYDRAGICON()
  72. ON_BN_CLICKED(IDC_MAKECALL, OnMakecall)
  73. ON_BN_CLICKED(IDC_APPCALL, OnAppcall)
  74. ON_BN_CLICKED(IDC_TUNING, OnTuning)
  75. ON_BN_CLICKED(IDC_MESSAGING, OnMessaging)
  76. ON_BN_CLICKED(IDM_ABOUTBOX, OnAboutbox)
  77. ON_BN_CLICKED(IDC_WHITEBOARD, OnWhiteboard)
  79. END_MESSAGE_MAP()
  80. BOOL CAVDConfDlg::OnInitDialog()
  81. {
  82. CDialog::OnInitDialog();
  84. SetIcon(m_hIcon, TRUE);
  85. SetIcon(m_hIcon, FALSE);
  88. if (InitRTCClient() != S_OK)
  89. {
  91. MessageBox ( "Initialization Error" );
  92. m_cMakeCall.EnableWindow ( FALSE );
  93. m_cAppCall.EnableWindow ( FALSE );
  94. m_cMessaging.EnableWindow ( FALSE );
  95. m_cTuning.EnableWindow ( FALSE );
  96. m_cWhiteboard.EnableWindow ( FALSE );
  97. }
  99. return TRUE;  
  100. }
  101. void CAVDConfDlg::OnPaint() 
  102. {
  103. if (IsIconic())
  104. {
  105. CPaintDC dc(this); 
  106. SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
  108. int cxIcon = GetSystemMetrics(SM_CXICON);
  109. int cyIcon = GetSystemMetrics(SM_CYICON);
  110. CRect rect;
  111. GetClientRect(&rect);
  112. int x = (rect.Width() - cxIcon + 1) / 2;
  113. int y = (rect.Height() - cyIcon + 1) / 2;
  115. dc.DrawIcon(x, y, m_hIcon);
  116. }
  117. else
  118. {
  119. CDialog::OnPaint();
  120. }
  121. }
  122. HCURSOR CAVDConfDlg::OnQueryDragIcon()
  123. {
  124. return (HCURSOR) m_hIcon;
  125. }
  126. void CAVDConfDlg::OnMakecall() 
  127. {
  128. MakeCallDlg cDlg;
  130. if (cDlg.DoModal() == IDOK)
  131. {
  133. MakeCall (RTCST_PC_TO_PC, g_bstrAddr);
  134. }
  135. }
  136. void CAVDConfDlg::OnMessaging() 
  137. {
  138.   MakeCallDlg cDlg;
  139.  
  140. if (cDlg.DoModal() == IDOK)
  141.   {  
  142. MakeCall (RTCST_IM, g_bstrAddr);
  143. }
  144. }
  145. void CAVDConfDlg::OnAppcall() 
  146. {
  147. HRESULT hr;
  148. VARIANT_BOOL vbool = VARIANT_FALSE;
  149. m_pClient->get_IsT120AppletRunning(RTCTA_APPSHARING, &vbool);
  150. if (vbool == VARIANT_FALSE)
  151. { 
  152. hr = m_pClient->StartT120Applet ( RTCTA_APPSHARING );
  153. }
  154. }
  155. void CAVDConfDlg::OnWhiteboard() 
  156. {
  157. HRESULT hr;
  158. VARIANT_BOOL vbool = VARIANT_FALSE;
  159. m_pClient->get_IsT120AppletRunning(RTCTA_WHITEBOARD, &vbool);
  160. if (vbool == VARIANT_FALSE)
  161. { 
  162. hr = m_pClient->StartT120Applet ( RTCTA_WHITEBOARD );
  163. }
  164. }
  165. HRESULT CAVDConfDlg::MakeCall(RTC_SESSION_TYPE enType, BSTR bstrURI)
  166. {
  167.     HRESULT hr;
  168. if (enType != RTCST_IM)
  169.     {
  170.         
  171. if ((m_AVDlg) && (m_AVDlg.GetState () != RTCSS_IDLE))
  172.         {
  173. MessageBoxW (m_hWnd, L"An audio/video call is in progress!", NULL, MB_OK );
  174.             return S_FALSE;
  175.         }
  176.     }
  177.     IRTCSession * pSession = NULL;
  178.     hr = m_pClient->CreateSession(enType, NULL, NULL, 0, &pSession);
  179.     if (FAILED(hr))
  180.     {
  181.         return hr;
  182.     }
  183.     
  184.     hr = pSession->AddParticipant(bstrURI, NULL, &m_Participant);
  185. if (FAILED(hr))
  186.     {
  187.         SAFE_RELEASE(pSession);
  188.         return hr;
  189.     }
  190.     
  191.     hr = AddSession(pSession, enType);
  192.     
  193.     if (FAILED(hr))
  194.     {  
  195.             
  196.         return hr;
  197.     }
  198.     return S_OK;
  199. }
  200. HRESULT CAVDConfDlg::InitRTCClient()
  201. {
  202. HRESULT hr;
  203. m_pClient = NULL;
  204. m_pEvents = NULL;
  206. hr = CoInitialize(NULL);
  207. if (FAILED(hr))
  208. {
  209. return hr;
  210. }
  211. hr = CoCreateInstance (CLSID_RTCClient, NULL,
  212. CLSCTX_INPROC_SERVER, IID_IRTCClient,
  213. (LPVOID *)&m_pClient);
  214. if (FAILED(hr))
  215. {
  216. return hr;
  217. }
  218. hr = m_pClient->Initialize();
  219. if (FAILED(hr))
  220. {
  221. SAFE_RELEASE(m_pClient);
  222. return hr;
  223. }
  224. m_pClient->SetPreferredMediaTypes ( RTCMT_ALL, VARIANT_TRUE );
  225. long lEventMask = RTCEF_SESSION_STATE_CHANGE |
  226.   RTCEF_MESSAGING |
  227.   RTCEF_MEDIA |
  228.   RTCEF_INTENSITY |
  229.   RTCEF_CLIENT;
  230. hr = m_pClient->put_EventFilter( lEventMask );
  231.     if ( FAILED(hr) )
  232.     {
  233.         SAFE_RELEASE(m_pClient);
  234.         return hr;
  235.     }
  236.     m_pEvents = new CRTCEvents;
  237.     if (!m_pEvents)
  238.     {
  239.         SAFE_RELEASE(m_pClient);
  240.         return hr;
  241.     }
  242.     hr = m_pEvents->Advise( m_pClient, m_hWnd );
  243.     if ( FAILED(hr) )
  244.     {
  245.         SAFE_RELEASE(m_pClient);
  246.         return hr;
  247.     }
  248.     
  249.     hr = m_pClient->put_ListenForIncomingSessions(RTCLM_BOTH); 
  251.     if ( FAILED(hr) )
  252.     {
  253.     
  254.         SAFE_RELEASE(m_pClient);
  255.         return hr;
  256.     }
  258. if (m_AVDlg)
  259. m_AVDlg.SetState (RTCSS_IDLE);
  260. return S_OK;
  261. }
  262. LRESULT CAVDConfDlg::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  263. {
  264. switch (message)
  265. {
  266. case WM_RTC_EVENT:
  267. OnRTCEvent (message, wParam, lParam);
  268. break;
  269. }
  270. return CDialog::WindowProc(message, wParam, lParam);
  271. }
  272. HRESULT CAVDConfDlg::OnRTCEvent(UINT message, WPARAM wParam, LPARAM lParam)
  273. {
  274.     IDispatch * pDisp = (IDispatch *)lParam;
  275.     RTC_EVENT enEvent = (RTC_EVENT)wParam;
  276.     HRESULT hr;
  277.    
  278.     switch ( wParam )
  279.     {
  280.         case RTCE_SESSION_STATE_CHANGE:
  281.             {
  282.                 IRTCSessionStateChangeEvent * pEvent = NULL;
  283.                 
  284.                 
  285. hr = pDisp->QueryInterface( IID_IRTCSessionStateChangeEvent,
  286.                                             (void **)&pEvent );
  287.                 if (SUCCEEDED(hr))
  288.                 {
  289.                     OnRTCSessionStateChangeEvent(pEvent);
  290.                     SAFE_RELEASE(pEvent);
  291.                 }              
  292.             }
  293.             break;
  294.         case RTCE_MESSAGING:
  295.             {
  296.                 IRTCMessagingEvent * pEvent = NULL;
  297.                 
  298.                 
  299.                 hr = pDisp->QueryInterface( IID_IRTCMessagingEvent,
  300.                                             (void **)&pEvent );
  301.                 if (SUCCEEDED(hr))
  302.                 {
  303.                     OnRTCMessagingEvent(pEvent);
  304.                     SAFE_RELEASE(pEvent);
  305.                 }              
  306.             }
  307.             break;
  308.         case RTCE_MEDIA:
  309.             {
  310.                 IRTCMediaEvent * pEvent = NULL;
  311.                 
  312.                 hr = pDisp->QueryInterface( IID_IRTCMediaEvent,
  313.                                             (void **)&pEvent );
  314.                 if (SUCCEEDED(hr))
  315.                 {
  316.                     OnRTCMediaEvent(pEvent);
  317.                     SAFE_RELEASE(pEvent);
  318.                 }
  319.             }
  320.             break;
  321.         case RTCE_INTENSITY:
  322.             {
  323.                 IRTCIntensityEvent * pEvent = NULL;
  324.                 
  325.                 hr = pDisp->QueryInterface( IID_IRTCIntensityEvent,
  326.                                             (void **)&pEvent );
  327.                 if (SUCCEEDED(hr))
  328.                 {
  329.                     OnRTCIntensityEvent(pEvent);
  330.                     SAFE_RELEASE(pEvent);
  331.                 }
  332.             }
  333.             break;
  334.         case RTCE_CLIENT:
  335.             {
  336.                 IRTCClientEvent * pEvent = NULL;
  337.                 
  338.                 hr = pDisp->QueryInterface( IID_IRTCClientEvent,
  339.                                             (void **)&pEvent );
  340.                 if (SUCCEEDED(hr))
  341.                 {
  342.                     OnRTCClientEvent(pEvent);
  343.                     SAFE_RELEASE(pEvent);
  344.                 }
  345.             }
  346.             break;
  347.     }
  348.     
  349.     SAFE_RELEASE(pDisp);
  350.     return S_OK;
  351. }
  352. void CAVDConfDlg::OnTuning() 
  353. {
  354. if (m_pClient)
  355. m_pClient->InvokeTuningWizard((OAHWND)m_hWnd);
  356. }
  357. void CAVDConfDlg::OnRTCSessionStateChangeEvent(IRTCSessionStateChangeEvent *pEvent)
  358. {
  359.     IRTCSession * pSession = NULL;
  360.     RTC_SESSION_STATE enState;
  361.     HRESULT hr;
  362.     
  363. hr = pEvent->get_State(&enState);
  364.     if (FAILED(hr))
  365.     {
  366.         
  367.         return;
  368.     }
  369.     
  370. hr = pEvent->get_Session(&pSession);
  371.     if (FAILED(hr))
  372.     {
  373.         
  374.         return;
  375.     }
  376.     switch ( enState )
  377. {
  378. case RTCSS_INCOMING:
  379.         {
  381.             
  382.             RTC_SESSION_TYPE enType;
  383.             
  384. hr = pSession->get_Type(&enType);
  385.             if (FAILED(hr))
  386.             {
  387.                 
  388.                 SAFE_RELEASE(pSession);
  389.                 return;
  390.             }            
  391.             if (enType == RTCST_IM)
  392.             {
  393.                 
  394.                 m_pClient->PlayRing(RTCRT_MESSAGE, VARIANT_TRUE);
  395.             }
  396.             else            
  397.             {
  398.                 
  399.                 if ((m_AVDlg) && (m_AVDlg.GetState() != RTCSS_IDLE))
  400.                 {
  401.                     
  402.                     
  403.                     pSession->Terminate(RTCTR_BUSY);
  404.                     SAFE_RELEASE(pSession);
  405.                     return;
  406.                 }
  407.                     
  408.                 
  409.                 IRTCEnumParticipants * pEnum = NULL;
  410.                 IRTCParticipant * pParticipant = NULL;
  411.                 hr = pSession->EnumerateParticipants(&pEnum);
  412.                 if (FAILED(hr))
  413.                 {
  414.                     
  415.                     SAFE_RELEASE(pSession);
  416.                     return;
  417.                 }
  418.                 hr = pEnum->Next(1, &pParticipant, NULL);
  419.                 SAFE_RELEASE(pEnum);
  420.                 if (hr != S_OK)
  421.                 {
  422.                     
  423.                     SAFE_RELEASE(pSession);
  424.                     return;
  425.                 }
  426.                 
  427.                 BSTR bstrURI = NULL;
  428.                 hr = pParticipant->get_UserURI(&bstrURI);
  429.                 if (FAILED(hr))
  430.                 {
  431.                     
  432.                     SAFE_RELEASE(pSession);
  433.                     SAFE_RELEASE(pParticipant);
  434.                     return;
  435.                 }
  436.                 
  437.                 BSTR bstrName = NULL;
  438.                 hr = pParticipant->get_Name(&bstrName);
  439.                 SAFE_RELEASE(pParticipant);
  440.                 if (FAILED(hr))
  441.                 {
  442.                     
  443.                     SAFE_FREE_STRING(bstrURI);
  444.                     SAFE_RELEASE(pSession);
  445.                     return;
  446.                 }
  447.                 
  448.                 m_pClient->PlayRing(RTCRT_PHONE, VARIANT_TRUE);
  449.                 
  450.                 BOOL fAccept;
  451. CIncomingDlg cDlg;    
  452. SESSION_DATA pData;
  453. pData.bstrName = bstrName;
  454. pData.bstrURI = bstrURI;
  455. SetWindowLong ( m_hWnd, GWL_USERDATA, (LONG)&pData);
  458. fAccept = (cDlg.DoModal() == IDOK);
  460. SAFE_FREE_STRING(bstrURI);
  461. SAFE_FREE_STRING(bstrName);
  462.                     
  463.                 if (fAccept)
  464.                 {
  465.                     
  466.                     hr = pSession->Answer();
  467.                     if (FAILED(hr))
  468.                     {
  469.                         
  470.                         SAFE_RELEASE(pSession);
  471.                         return;
  472.                     }
  473.                 }
  474.                 else
  475.                 {
  476.                     
  477.                     pSession->Terminate(RTCTR_REJECT);
  478. SAFE_RELEASE(pSession);
  479.                     return;
  480.                 }
  481.             }  
  482.             
  483.             
  484.             
  485.             hr = AddSession(pSession, enType);
  486.             if (FAILED(hr))
  487.             {
  488.                 
  489.                 SAFE_RELEASE(pSession);
  490.                 return;
  491.             }
  492.         }        
  493. break;
  494. }
  495.     
  496. if (m_AVDlg)
  497. m_AVDlg.SetState (enState);
  498. }
  499. void CAVDConfDlg::OnRTCMediaEvent(IRTCMediaEvent *pEvent)
  500. {
  501.     long lMediaType;
  502.     RTC_MEDIA_EVENT_TYPE enType;
  503.     RTC_MEDIA_EVENT_REASON enReason;
  504.     HRESULT hr;
  505. hr = pEvent->get_MediaType(&lMediaType);
  506.     if (FAILED(hr))
  507.     {
  508.         
  509.         return;
  510.     }
  511.     hr = pEvent->get_EventType(&enType);   
  512.     if (FAILED(hr))
  513.     {
  514.         
  515.         return;
  516.     }
  517.     hr = pEvent->get_EventReason(&enReason);
  518.     if (FAILED(hr))
  519.     {
  520.         
  521.         return;
  522.     }
  523. if ((m_AVDlg) && (m_AVDlg.GetState () != RTCSS_IDLE))
  524.     {
  525.         
  526.         m_AVDlg.DeliverMedia(lMediaType, enType, enReason);
  527.     }
  528. }
  529. void CAVDConfDlg::OnRTCIntensityEvent(IRTCIntensityEvent *pEvent)
  530. {
  531.     RTC_AUDIO_DEVICE enDevice;
  532.     long lLevel, lMin, lMax;
  533.     HRESULT hr;
  534.     
  535. hr = pEvent->get_Direction(&enDevice);
  536.     if (FAILED(hr))
  537.     {
  538.         
  539.         return;
  540.     }
  541.     hr = pEvent->get_Level(&lLevel);
  542.     if (FAILED(hr))
  543.     {
  544.         
  545.         return;
  546.     }
  547.     hr = pEvent->get_Min(&lMin);
  548.     if (FAILED(hr))
  549.     {
  550.         
  551.         return;
  552.     }
  553.     hr = pEvent->get_Max(&lMax);
  554.     if (FAILED(hr))
  555.     {
  556.         
  557.         return;
  558.     }
  559.     
  560.     if ((lMax - lMin) == 0)
  561.     {
  562.         lLevel = 0;
  563.     }
  564.     else
  565.     {
  566.         lLevel = (lLevel - lMin) * 100 / (lMax - lMin);
  567.     }
  568. if (m_AVDlg.GetState () != RTCSS_IDLE)
  569.     {
  570.         
  571.         m_AVDlg.DeliverIntensity(enDevice, lLevel);
  572.     }
  573. }
  574. void CAVDConfDlg::OnRTCClientEvent(IRTCClientEvent *pEvent)
  575. {
  576.     HRESULT hr;
  577.     
  578.     RTC_CLIENT_EVENT_TYPE enEventType;
  579.     hr = pEvent->get_EventType(&enEventType);
  580.     if (FAILED(hr))
  581.     {
  582.         
  583.         return;
  584.     }
  585.     if ( enEventType == RTCCET_ASYNC_CLEANUP_DONE )
  586.     {
  587.         m_pClient->Shutdown();
  588. SAFE_RELEASE(m_pClient);
  590.         
  591.         DestroyWindow();
  592.     }
  593.     else
  594.     {
  595.         if (m_AVDlg.GetState() != RTCSS_IDLE)
  596.         {
  597.             
  598.             m_AVDlg.DeliverClient(enEventType);
  599.         }
  600.     }
  601. }
  602. HRESULT CAVDConfDlg::AddSession(IRTCSession *pSession, RTC_SESSION_TYPE enType)
  603. {
  604.     
  605.     BOOL fAVSession = (enType != RTCST_IM);
  606.     
  608. if (fAVSession)
  609. {
  610. BOOL ret = m_AVDlg.Create (IDD_AVDLG,this);
  611. if (!ret)
  612. {
  613. MessageBox ( "Error Creating Dialog" );
  614. }
  615. m_AVDlg.ShowWindow (SW_SHOW);
  616. m_AVDlg.SetParentClient (m_pClient);
  617. m_AVDlg.SetSession (pSession);
  618. }
  619. else
  620. {
  621. BOOL ret = m_cMessageDlg.Create (IDD_MESSAGEDLG, this);
  622. if (!ret)
  623. {
  624. MessageBox ( "Error Creating Dialog" );
  625. }
  626. m_cMessageDlg.ShowWindow (SW_SHOW);
  627. m_cMessageDlg.SetParentClient ( m_pClient );
  628. m_cMessageDlg.SetSession (pSession);
  629. }
  630. return S_OK;
  631. }
  632. HRESULT CAVDConfDlg::OnRTCMessagingEvent(IRTCMessagingEvent *pEvent)
  633. {
  634.     IRTCSession * pSession = NULL;
  635.     
  636.     IRTCParticipant * pParticipant = NULL;
  637.     RTC_MESSAGING_EVENT_TYPE enType;
  638.     RTC_MESSAGING_USER_STATUS enStatus;
  639.     BSTR bstrContentType = NULL;
  640.     BSTR bstrMessage = NULL;
  641.     HRESULT hr;
  642.     hr = pEvent->get_Session(&pSession);
  643.     if (FAILED(hr))
  644.     {
  645.         
  646.         return S_FALSE;
  647.     }
  648.     
  649.     hr = pEvent->get_EventType(&enType);
  650.     if (FAILED(hr))
  651.     {
  652.         
  653.         return S_FALSE;
  654.     }
  655.     hr = pEvent->get_Participant(&pParticipant);
  656.     if (FAILED(hr))
  657.     {
  658.         
  659.         return S_FALSE;
  660.     }
  661.     if (enType == RTCMSET_MESSAGE)
  662.     {
  663.         hr = pEvent->get_MessageHeader(&bstrContentType);
  664.         if (FAILED(hr))
  665.         {
  666.             
  667.             SAFE_RELEASE(pParticipant);
  668.             return S_FALSE;
  669.         }
  670.         hr = pEvent->get_Message(&bstrMessage);
  671.         if (FAILED(hr))
  672.         {
  673.             
  674.             SAFE_RELEASE(pParticipant);
  675.             SAFE_FREE_STRING(bstrContentType);
  676.             return S_FALSE;
  677.         }
  678.         
  679.         if (m_cMessageDlg)
  680. m_cMessageDlg.DeliverMessage(pParticipant, bstrContentType, bstrMessage);
  681.         SAFE_FREE_STRING(bstrContentType);
  682.         SAFE_FREE_STRING(bstrMessage);
  683.     }
  684.     else if (enType == RTCMSET_STATUS)
  685.     {
  686.         hr = pEvent->get_UserStatus(&enStatus);
  687.         if (FAILED(hr))
  688.         {
  689.             
  690.             return S_FALSE;
  691.         }
  692.         
  693.         m_cMessageDlg.DeliverUserStatus(pParticipant, enStatus);
  694.     }
  695.     SAFE_RELEASE(pParticipant); 
  697. return S_OK;
  698. }
  699. void CAVDConfDlg::OnOK() 
  700. {
  701. if (m_pClient)
  702. {
  703. m_pClient->StopT120Applets();
  704. m_pClient->PrepareForShutdown();
  705. if (m_pEvents)
  706. {
  707. m_pEvents->Unadvise( m_pClient);
  708. }
  709. }
  710. CDialog::OnOK();
  711. }
  712. void CAVDConfDlg::OnCancel ()
  713. {
  714. MessageBox ( "Please use the shutdownnbutton to quit." );
  715. return;
  716. }
  717. void CAVDConfDlg::OnAboutbox() 
  718. {
  719. CAboutDlg dlgAbout;
  720. dlgAbout.DoModal();
  721. }