ctrlmediaframe.cpp

著名的下载软件核心Shareaza

}

void CMediaFrame::OnUpdateMediaSizeFill(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( Settings.MediaPlayer.Zoom == smzFill );
}

void CMediaFrame::OnMediaSizeFill() 
{
	ZoomTo( smzFill );
}

void CMediaFrame::OnUpdateMediaSizeDistort(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( Settings.MediaPlayer.Zoom == smzDistort );
}

void CMediaFrame::OnMediaSizeDistort() 
{
	ZoomTo( smzDistort );
}

void CMediaFrame::OnUpdateMediaSizeOne(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( Settings.MediaPlayer.Zoom == 1 );
}

void CMediaFrame::OnMediaSizeOne() 
{
	ZoomTo( (MediaZoom)1 );
}

void CMediaFrame::OnUpdateMediaSizeTwo(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( Settings.MediaPlayer.Zoom == 2 );
}

void CMediaFrame::OnMediaSizeTwo() 
{
	ZoomTo( (MediaZoom)2 );
}

void CMediaFrame::OnUpdateMediaSizeThree(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( Settings.MediaPlayer.Zoom == 3 );
}

void CMediaFrame::OnMediaSizeThree() 
{
	ZoomTo( (MediaZoom)3 );
}

void CMediaFrame::OnUpdateMediaAspectDefault(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( Settings.MediaPlayer.Zoom != smzDistort );
	pCmdUI->SetCheck( Settings.MediaPlayer.Aspect == smaDefault );
}

void CMediaFrame::OnMediaAspectDefault() 
{
	AspectTo( smaDefault );
}

void CMediaFrame::OnUpdateMediaAspect43(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( Settings.MediaPlayer.Zoom != smzDistort );
	pCmdUI->SetCheck( fabs( Settings.MediaPlayer.Aspect - 4.0f/3.0f ) < 0.1f );
}

void CMediaFrame::OnMediaAspect43() 
{
	AspectTo( (4.0f/3.0f) );
}

void CMediaFrame::OnUpdateMediaAspect169(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( Settings.MediaPlayer.Zoom != smzDistort );
	pCmdUI->SetCheck( fabs( Settings.MediaPlayer.Aspect - 16.0f/9.0f ) < 0.1f );
}

void CMediaFrame::OnMediaAspect169() 
{
	AspectTo( (16.0f/9.0f) );
}

void CMediaFrame::OnUpdateMediaPlaylist(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_bListVisible );
}

void CMediaFrame::OnMediaPlaylist() 
{
	m_bListVisible = ! m_bListVisible;
	m_tBarTime = GetTickCount();
	OnSize( SIZE_INTERNAL, 0, 0 );
}

void CMediaFrame::OnUpdateMediaStatus(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_bStatusVisible );
}

void CMediaFrame::OnMediaStatus() 
{
	m_bStatusVisible = ! m_bStatusVisible;
	OnSize( SIZE_INTERNAL, 0, 0 );
}

void CMediaFrame::OnUpdateMediaVis(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( ! m_bFullScreen );
}

void CMediaFrame::OnMediaVis() 
{
	CMediaVisDlg dlg( this );
	if ( dlg.DoModal() == IDOK ) PrepareVis();
}

void CMediaFrame::OnUpdateMediaSettings(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( ! m_bFullScreen );
}

void CMediaFrame::OnMediaSettings() 
{
	CSettingsManagerDlg::Run( _T("CMediaSettingsPage") );
}

void CMediaFrame::OnUpdateMediaMute(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck( m_bMute );
}

void CMediaFrame::OnMediaMute() 
{
	m_bMute = ! m_bMute;
	if ( m_pPlayer != NULL ) m_pPlayer->SetVolume( m_bMute ? 0 : Settings.MediaPlayer.Volume );
}

/////////////////////////////////////////////////////////////////////////////
// CMediaFrame public media operations

BOOL CMediaFrame::PlayFile(LPCTSTR pszFile)
{
	UpdateWindow();

	DWORD tNow = GetTickCount();

	if ( tNow - m_tLastPlay < 500 )
	{
		m_tLastPlay = tNow;
		return EnqueueFile( pszFile );
	}
	else
	{
		m_tLastPlay = tNow;
		return m_wndList.Open( pszFile );
	}
}

BOOL CMediaFrame::EnqueueFile(LPCTSTR pszFile)
{
	m_bAutoPlay = FALSE;
	BOOL bResult = m_wndList.Enqueue( pszFile, TRUE );
	m_bAutoPlay = TRUE;
	return bResult;
}

BOOL CMediaFrame::IsPlaying()
{
	return m_pPlayer != NULL && m_nState == smsPlaying;
}

void CMediaFrame::OnFileDelete(LPCTSTR pszFile)
{
	if ( m_sFile.CompareNoCase( pszFile ) == 0 )
	{
		if ( m_pPlayer ) m_pPlayer->Close();
	}
}

float CMediaFrame::GetPosition()
{
	if ( m_pPlayer != NULL && m_nState >= smsOpen && m_nLength > 0 )
	{
		return (float)m_nPosition / (float)m_nLength;
	}
	else
	{
		return 0;
	}
}

BOOL CMediaFrame::SeekTo(float nPosition)
{
	if ( m_pPlayer != NULL && m_nState >= smsPaused && m_nLength > 0 )
	{
		m_nPosition = (LONGLONG)( nPosition * (float)m_nLength );
		m_pPlayer->SetPosition( m_nPosition );
		OnTimer( 1 );
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

float CMediaFrame::GetVolume()
{
	return (float)Settings.MediaPlayer.Volume;
}

BOOL CMediaFrame::SetVolume(float nVolume)
{
	Settings.MediaPlayer.Volume = (double)nVolume;
	if ( m_pPlayer != NULL ) m_pPlayer->SetVolume( m_bMute ? 0 : Settings.MediaPlayer.Volume );
	OnTimer( 1 );
	return ( m_pPlayer != NULL );
}

/////////////////////////////////////////////////////////////////////////////
// CMediaFrame private media operations

BOOL CMediaFrame::Prepare()
{
	m_bThumbPlay = FALSE;

	if ( m_pPlayer != NULL ) return TRUE;
	if ( GetSafeHwnd() == NULL ) return FALSE;
	
	CWaitCursor pCursor;
	CLSID pCLSID;
	
	if ( Plugins.LookupCLSID( _T("MediaPlayer"), _T("Default"), pCLSID ) )
	{
		HINSTANCE hRes = AfxGetResourceHandle();
		CoCreateInstance( pCLSID, NULL, CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER,
			IID_IMediaPlayer, (void**)&m_pPlayer );
		AfxSetResourceHandle( hRes );
	}
	
	if ( m_pPlayer == NULL )
	{
		pCursor.Restore();
		CString strMessage;
		Skin.LoadString( strMessage, IDS_MEDIA_PLUGIN_CREATE );
		AfxMessageBox( strMessage, MB_ICONEXCLAMATION );
		return FALSE;
	}
	
	m_pPlayer->Create( GetSafeHwnd() );
	m_pPlayer->SetZoom( Settings.MediaPlayer.Zoom );
	m_pPlayer->SetAspect( Settings.MediaPlayer.Aspect );
	m_pPlayer->SetVolume( m_bMute ? 0 : Settings.MediaPlayer.Volume );
	
	if ( m_bmLogo.m_hObject ) m_pPlayer->SetLogoBitmap( (HBITMAP)m_bmLogo.m_hObject );
	
	if ( TRUE )
	{
		HINSTANCE hRes = AfxGetResourceHandle();
		PrepareVis();
		AfxSetResourceHandle( hRes );
	}
	
	OnSize( SIZE_INTERNAL, 0, 0 );
	UpdateState();
	
	return TRUE;
}

BOOL CMediaFrame::PrepareVis()
{
	if ( m_pPlayer == NULL ) return FALSE;
	
	IAudioVisPlugin* pPlugin = NULL;
	CLSID pCLSID;
	
	if ( GUIDX::Decode( Settings.MediaPlayer.VisCLSID, &pCLSID ) &&
		 Plugins.LookupEnable( pCLSID, TRUE ) )
	{
		HRESULT hr = CoCreateInstance( pCLSID, NULL,
			CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER, IID_IAudioVisPlugin,
			(void**)&pPlugin );
		
		if ( SUCCEEDED(hr) && pPlugin != NULL )
		{
			if ( Settings.MediaPlayer.VisPath.GetLength() )
			{
				IWrappedPluginControl* pWrap = NULL;
				
				hr = pPlugin->QueryInterface( IID_IWrappedPluginControl,
					(void**)&pWrap );

				if ( SUCCEEDED(hr) && pWrap != NULL )
				{
					BSTR bsPath = Settings.MediaPlayer.VisPath.AllocSysString();
					hr = pWrap->Load( bsPath, 0 );
					SysFreeString( bsPath );
					pWrap->Release();
				}
				
				if ( FAILED(hr) )
				{
					pPlugin->Release();
					pPlugin = NULL;
				}
			}
		}
	}
	
	m_pPlayer->SetPluginSize( Settings.MediaPlayer.VisSize );
	m_pPlayer->SetPlugin( pPlugin );
	
	if ( pPlugin != NULL ) pPlugin->Release();
	
	return TRUE;
}

BOOL CMediaFrame::OpenFile(LPCTSTR pszFile)
{
	if ( ! Prepare() ) return FALSE;
	
	if ( m_sFile == pszFile )
	{
		m_pPlayer->Stop();
		UpdateState();
		return TRUE;
	}
	
	CWaitCursor pCursor;
	m_sFile.Empty();
	m_pMetadata.Clear();
	
	HINSTANCE hRes = AfxGetResourceHandle();
	
	BSTR bsFile = CString( pszFile ).AllocSysString();
	HRESULT hr = m_pPlayer->Open( bsFile );
	SysFreeString( bsFile );

	AfxSetResourceHandle( hRes );
	
	UpdateState();
	pCursor.Restore();
	m_tMetadata = GetTickCount();
	
	if ( FAILED(hr) )
	{
		LPCTSTR pszBase = _tcsrchr( pszFile, '\\' );
		pszBase = pszBase ? pszBase + 1 : pszFile;
		CString strMessage, strFormat;
		LoadString( strFormat, IDS_MEDIA_LOAD_FAIL );
		strMessage.Format( strFormat, pszBase );
		m_pMetadata.Add( _T("Error"), strMessage );
		LoadString( strMessage, IDS_MEDIA_LOAD_FAIL_HELP );
		m_pMetadata.Add( _T("Error"), strMessage );
		return FALSE;
	}
	
	m_sFile = pszFile;
	
	if ( CLibraryFile* pFile = LibraryMaps.LookupFileByPath( m_sFile, TRUE ) )
	{
		m_pMetadata.Add( _T("Filename"), pFile->m_sName );
		m_pMetadata.Setup( pFile->m_pSchema, FALSE );
		m_pMetadata.Combine( pFile->m_pMetadata );
		m_pMetadata.Clean( 1024 );
		Library.Unlock();
		
		CMetaItem* pWidth	= m_pMetadata.Find( _T("Width") );
		CMetaItem* pHeight	= m_pMetadata.Find( _T("Height") );
		
		if ( pWidth != NULL && pHeight != NULL )
		{
			pWidth->m_sKey = _T("Dimensions");
			pWidth->m_sValue += 'x' + pHeight->m_sValue;
			m_pMetadata.Remove( _T("Height") );
		}
	}
	
	if ( hr != S_OK )
	{
		CString strMessage;
		LoadString( strMessage, IDS_MEDIA_PARTIAL_RENDER );
		m_pMetadata.Add( _T("Warning"), strMessage );
	}
	
	return TRUE;
}

void CMediaFrame::Cleanup()
{
	m_sFile.Empty();
	m_pMetadata.Clear();
	
	if ( m_pPlayer != NULL )
	{
		HINSTANCE hRes = AfxGetResourceHandle();
		m_pPlayer->Close();
		m_pPlayer->Destroy();
		m_pPlayer->Release();
		m_pPlayer = NULL;
		AfxSetResourceHandle( hRes );
	}
	
	UpdateState();
	Invalidate();
}

void CMediaFrame::ZoomTo(MediaZoom nZoom)
{
	if ( Settings.MediaPlayer.Zoom == nZoom ) return;
	Settings.MediaPlayer.Zoom = nZoom;
	if ( m_pPlayer == NULL ) return;
	m_pPlayer->SetZoom( Settings.MediaPlayer.Zoom );
}

void CMediaFrame::AspectTo(double nAspect)
{
	if ( Settings.MediaPlayer.Aspect == nAspect ) return;
	Settings.MediaPlayer.Aspect = nAspect;
	if ( m_pPlayer == NULL ) return;
	m_pPlayer->SetAspect( Settings.MediaPlayer.Aspect );
}

void CMediaFrame::UpdateState()
{
	m_nState = smsNull;
	
	if ( m_pPlayer ) m_pPlayer->GetState( &m_nState );
	
	if ( m_nState >= smsOpen )
	{
		m_nLength = 0;
		m_pPlayer->GetLength( &m_nLength );
		int nLength = (int)( m_nLength / TIME_FACTOR );
		
		m_nPosition = 0;
		m_pPlayer->GetPosition( &m_nPosition );
		int nPosition = (int)( m_nPosition / TIME_FACTOR );
		
		m_wndPosition.EnableWindow( TRUE );
		m_wndPosition.SetRangeMax( (int)nLength );
		m_wndPosition.SetPos( (int)nPosition );
		
		double nSpeed = 1.0f;
		m_pPlayer->GetSpeed( &nSpeed );
		m_wndSpeed.SetPos( (int)( nSpeed * 100 ) );
		m_wndSpeed.EnableWindow( TRUE );
		
		if ( ! m_bMute )
		{
			Settings.MediaPlayer.Volume = 1.0f;
			m_pPlayer->GetVolume( &Settings.MediaPlayer.Volume );
		}
		
		if ( m_nState == smsPlaying && nPosition >= nLength )
		{
			m_wndList.GetNext();
		}
	}
	else
	{
		m_wndPosition.SetPos( 0 );
		m_wndPosition.SetRange( 0, 0 );
		m_wndPosition.EnableWindow( FALSE );
		m_wndSpeed.SetPos( 100 );
		m_wndSpeed.EnableWindow( FALSE );
	}
	
	m_wndVolume.SetPos( (int)( Settings.MediaPlayer.Volume * 100 ) );
	
	if ( m_bStatusVisible )
	{
		InvalidateRect( &m_rcStatus );
	}
}

void CMediaFrame::OnNewCurrent(NMHDR* pNotify, LRESULT* pResult)
{
	int nCurrent = m_wndList.GetCurrent();
	m_wndList.UpdateWindow();

	if ( nCurrent >= 0 )
	{
		if ( OpenFile( m_wndList.GetPath( nCurrent ) ) )
		{
			if ( m_bAutoPlay )
			{
				m_pPlayer->Play();
				UpdateState();
			}
		}
		else if ( m_bAutoPlay )
		{
			m_bAutoPlay = FALSE;
			m_wndList.Reset();
			m_bAutoPlay = TRUE;
		}
	}
	else if ( m_wndList.GetItemCount() > 0 )
	{
		m_wndList.Reset( FALSE );
		nCurrent = m_wndList.GetNext( FALSE );

		m_bAutoPlay = m_bAutoPlay && Settings.MediaPlayer.Repeat;

		if ( nCurrent >= 0 )
			m_wndList.SetCurrent( nCurrent );
		else
			Cleanup();

		m_bAutoPlay = TRUE;
	}
	else
	{
		Cleanup();
	}

	*pResult = 0;
}