hr = pEvent->get_State(&enState);
    if (FAILED(hr))
    {
        
        return;
    }
    
	hr = pEvent->get_Session(&pSession);
    if (FAILED(hr))
    {
        
        return;
    }
    switch ( enState )
	{
	case RTCSS_INCOMING:
        {
			
            
            RTC_SESSION_TYPE enType;
            
			hr = pSession->get_Type(&enType);
            if (FAILED(hr))
            {
                
                SAFE_RELEASE(pSession);
                return;
            }            
            if (enType == RTCST_IM)
            {
                
                m_pClient->PlayRing(RTCRT_MESSAGE, VARIANT_TRUE);
            }
            else            
            {
                
                if ((m_AVDlg) && (m_AVDlg.GetState() != RTCSS_IDLE))
                {
                    
                    
                    pSession->Terminate(RTCTR_BUSY);
                    SAFE_RELEASE(pSession);
                    return;
                }
                    
                
                IRTCEnumParticipants * pEnum = NULL;
                IRTCParticipant * pParticipant = NULL;
                hr = pSession->EnumerateParticipants(&pEnum);
                if (FAILED(hr))
                {
                    
                    SAFE_RELEASE(pSession);
                    return;
                }
                hr = pEnum->Next(1, &pParticipant, NULL);
                SAFE_RELEASE(pEnum);
                if (hr != S_OK)
                {
                    
                    SAFE_RELEASE(pSession);
                    return;
                }
                
                BSTR bstrURI = NULL;
                hr = pParticipant->get_UserURI(&bstrURI);
                if (FAILED(hr))
                {
                    
                    SAFE_RELEASE(pSession);
                    SAFE_RELEASE(pParticipant);
                    return;
                }
                
                BSTR bstrName = NULL;
                hr = pParticipant->get_Name(&bstrName);
                SAFE_RELEASE(pParticipant);
                if (FAILED(hr))
                {
                    
                    SAFE_FREE_STRING(bstrURI);
                    SAFE_RELEASE(pSession);
                    return;
                }
                
                m_pClient->PlayRing(RTCRT_PHONE, VARIANT_TRUE);
                
                BOOL fAccept;
				CIncomingDlg	cDlg;	   
				SESSION_DATA	pData;
				pData.bstrName = bstrName;
				pData.bstrURI = bstrURI;
				SetWindowLong ( m_hWnd, GWL_USERDATA, (LONG)&pData);
				
				
				fAccept = (cDlg.DoModal() == IDOK);
				
				SAFE_FREE_STRING(bstrURI);
				SAFE_FREE_STRING(bstrName);
                    
                if (fAccept)
                {
                    
                    hr = pSession->Answer();
                    if (FAILED(hr))
                    {
                        
                        SAFE_RELEASE(pSession);
                        return;
                    }
                }
                else
                {
                    
                    pSession->Terminate(RTCTR_REJECT);
					SAFE_RELEASE(pSession);
                    return;
                }
            }  
            
            
            
            hr = AddSession(pSession, enType);
            if (FAILED(hr))
            {
                
                SAFE_RELEASE(pSession);
                return;
            }
        }        
		break;
	}
    
	if (m_AVDlg)
		m_AVDlg.SetState (enState);
}
void CAVDConfDlg::OnRTCMediaEvent(IRTCMediaEvent *pEvent)
{
    long lMediaType;
    RTC_MEDIA_EVENT_TYPE enType;
    RTC_MEDIA_EVENT_REASON enReason;
    HRESULT hr;
	hr = pEvent->get_MediaType(&lMediaType);
    if (FAILED(hr))
    {
        
        return;
    }
    hr = pEvent->get_EventType(&enType);			  
    if (FAILED(hr))
    {
        
        return;
    }
    hr = pEvent->get_EventReason(&enReason);
    if (FAILED(hr))
    {
        
        return;
    }
	if ((m_AVDlg) && (m_AVDlg.GetState () != RTCSS_IDLE))
    {
        
        m_AVDlg.DeliverMedia(lMediaType, enType, enReason);
    }
}
void CAVDConfDlg::OnRTCIntensityEvent(IRTCIntensityEvent *pEvent)
{
    RTC_AUDIO_DEVICE enDevice;
    long lLevel, lMin, lMax;
    HRESULT hr;
    
	hr = pEvent->get_Direction(&enDevice);
    if (FAILED(hr))
    {
        
        return;
    }
    hr = pEvent->get_Level(&lLevel);
    if (FAILED(hr))
    {
        
        return;
    }
    hr = pEvent->get_Min(&lMin);
    if (FAILED(hr))
    {
        
        return;
    }
    hr = pEvent->get_Max(&lMax);
    if (FAILED(hr))
    {
        
        return;
    }
    
    if ((lMax - lMin) == 0)
    {
        lLevel = 0;
    }
    else
    {
        lLevel = (lLevel - lMin) * 100 / (lMax - lMin);
    }
	if (m_AVDlg.GetState () != RTCSS_IDLE)
    {
        
        m_AVDlg.DeliverIntensity(enDevice, lLevel);
    }
}
void CAVDConfDlg::OnRTCClientEvent(IRTCClientEvent *pEvent)
{
    HRESULT hr;
    
    RTC_CLIENT_EVENT_TYPE enEventType;
    hr = pEvent->get_EventType(&enEventType);
    if (FAILED(hr))
    {
        
        return;
    }
    if ( enEventType == RTCCET_ASYNC_CLEANUP_DONE )
    {
        m_pClient->Shutdown();
		SAFE_RELEASE(m_pClient);
		
        
        DestroyWindow();
    }
    else
    {
        if (m_AVDlg.GetState() != RTCSS_IDLE)
        {
            
            m_AVDlg.DeliverClient(enEventType);
        }
    }
}
HRESULT CAVDConfDlg::AddSession(IRTCSession *pSession, RTC_SESSION_TYPE enType)
{
    
    BOOL fAVSession = (enType != RTCST_IM);
    
	
	if (fAVSession)
	{
		BOOL ret = m_AVDlg.Create (IDD_AVDLG,this);
		if (!ret)
		{
			MessageBox ( "Error Creating Dialog" );
		}
		m_AVDlg.ShowWindow (SW_SHOW);
		m_AVDlg.SetParentClient (m_pClient);
		m_AVDlg.SetSession (pSession);
	}
	else
	{
		BOOL ret = m_cMessageDlg.Create (IDD_MESSAGEDLG, this);
		if (!ret)
		{
			MessageBox ( "Error Creating Dialog" );
		}
		m_cMessageDlg.ShowWindow (SW_SHOW);
		m_cMessageDlg.SetParentClient ( m_pClient );
		m_cMessageDlg.SetSession (pSession);
	}
	return S_OK;
}
HRESULT CAVDConfDlg::OnRTCMessagingEvent(IRTCMessagingEvent *pEvent)
{
    IRTCSession * pSession = NULL;
    
    IRTCParticipant * pParticipant = NULL;
    RTC_MESSAGING_EVENT_TYPE enType;
    RTC_MESSAGING_USER_STATUS enStatus;
    BSTR bstrContentType = NULL;
    BSTR bstrMessage = NULL;
    HRESULT hr;
    hr = pEvent->get_Session(&pSession);
    if (FAILED(hr))
    {
        
        return S_FALSE;
    }
    
    hr = pEvent->get_EventType(&enType);
    if (FAILED(hr))
    {
        
        return S_FALSE;
    }
    hr = pEvent->get_Participant(&pParticipant);
    if (FAILED(hr))
    {
        
        return S_FALSE;
    }
    if (enType == RTCMSET_MESSAGE)
    {
        hr = pEvent->get_MessageHeader(&bstrContentType);
        if (FAILED(hr))
        {
            
            SAFE_RELEASE(pParticipant);
            return S_FALSE;
        }
        hr = pEvent->get_Message(&bstrMessage);
        if (FAILED(hr))
        {
            
            SAFE_RELEASE(pParticipant);
            SAFE_FREE_STRING(bstrContentType);
            return S_FALSE;
        }
        
        if (m_cMessageDlg)
			m_cMessageDlg.DeliverMessage(pParticipant, bstrContentType, bstrMessage);
        SAFE_FREE_STRING(bstrContentType);
        SAFE_FREE_STRING(bstrMessage);
    }
    else if (enType == RTCMSET_STATUS)
    {
        hr = pEvent->get_UserStatus(&enStatus);
        if (FAILED(hr))
        {
            
            return S_FALSE;
        }
        
        m_cMessageDlg.DeliverUserStatus(pParticipant, enStatus);
    }
    SAFE_RELEASE(pParticipant); 
	
	return S_OK;
}
void CAVDConfDlg::OnOK() 
{
	if (m_pClient)
	{
		m_pClient->StopT120Applets();
		m_pClient->PrepareForShutdown();
		if (m_pEvents)
		{
			m_pEvents->Unadvise( m_pClient);
		}
	}
	CDialog::OnOK();
}
void CAVDConfDlg::OnCancel ()
{	
	MessageBox ( "Please use the shutdown\nbutton to quit." );
	return;
}
void CAVDConfDlg::OnAboutbox() 
{
	CAboutDlg dlgAbout;
	dlgAbout.DoModal();
}