tf2/tf2_src/public/panorama/controls/movieplayer.h

//=========== Copyright Valve Corporation, All rights reserved. ===============//
//
// Purpose: 
//=============================================================================//

#ifndef PANORAMA_MOVIEPLAYER_H
#define PANORAMA_MOVIEPLAYER_H

#ifdef _WIN32
#pragma once
#endif

#include "panel2d.h"
#include "../data/iimagesource.h"
#include "../data/panoramavideoplayer.h"
#include "panorama/uischeduleddel.h"

namespace panorama
{
class CToggleButton;
class CLabel;
class CSlider;

DECLARE_PANEL_EVENT0( MoviePlayerAudioStart );
DECLARE_PANEL_EVENT0( MoviePlayerAudioStop );
DECLARE_PANEL_EVENT0( MoviePlayerPlaybackStart );
DECLARE_PANEL_EVENT0( MoviePlayerPlaybackStop );
DECLARE_PANEL_EVENT1( MoviePlayerPlaybackEnded, EVideoPlayerPlaybackError );
DECLARE_PANORAMA_EVENT0( MoviePlayerTogglePlayPause );
DECLARE_PANORAMA_EVENT0( MoviePlayerFastForward );
DECLARE_PANEL_EVENT0( MoviePlayerUIVisible );
DECLARE_PANORAMA_EVENT0( MoviePlayerJumpBack );
DECLARE_PANORAMA_EVENT0( MoviePlayerVolumeControl );
DECLARE_PANORAMA_EVENT0( MoviePlayerFullscreenControl );
DECLARE_PANORAMA_EVENT1( MoviePlayerSetRepresentation, int );
DECLARE_PANORAMA_EVENT0( MoviePlayerSelectVideoQuality );


//-----------------------------------------------------------------------------
// Purpose: Base class for controls that pop above movie button bar
//-----------------------------------------------------------------------------
class CMovieControlPopupBase : public CPanel2D
{
public:
	CMovieControlPopupBase( CPanel2D *pInvokingPanel, const char *pchPanelID );
	virtual ~CMovieControlPopupBase() {}

	void Show( float flVolume );
	void Close();

	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight ) OVERRIDE;

protected:
	bool EventCancelled( const CPanelPtr< IUIPanel > &pPanel, EPanelEventSource_t eSource );

	CPanel2D *m_pInvisibleBackground;
	CPanel2D *m_pInvokingPanel;
	CPanel2D *m_pPopupBackground;
};


//-----------------------------------------------------------------------------
// Purpose: Top level menu for volume slider
//-----------------------------------------------------------------------------
class CVolumeSliderPopup : public CMovieControlPopupBase
{
	DECLARE_PANEL2D( CVolumeSliderPopup, CMovieControlPopupBase );

public:
	CVolumeSliderPopup( CPanel2D *pInvokingPanel, const char *pchPanelID );
	virtual ~CVolumeSliderPopup() {}

	void Show( float flVolume );
	virtual bool OnKeyDown( const KeyData_t &unichar ) OVERRIDE;

private:
	bool EventSliderValueChanged( const CPanelPtr< IUIPanel > &pPanel, float flValue );
	
	CSlider *m_pSlider;
};


//-----------------------------------------------------------------------------
// Purpose: Top level menu for showing video resolutions to select
//-----------------------------------------------------------------------------
class CMovieVideoQualityPopup : public CMovieControlPopupBase
{
	DECLARE_PANEL2D( CMovieVideoQualityPopup, CMovieControlPopupBase );

public:
	CMovieVideoQualityPopup( CPanel2D *pInvokingPanel, const char *pchPanelID );
	virtual ~CMovieVideoQualityPopup() {}

	void AddRepresentation( int iRep, int nHeight );
	void Show( int iFocusRep, int nVideoHeight );

private:
	struct Representation_t
	{
		int m_iRep;
		int m_nHeight;
	};

	bool EventSetRepresentation( int iRep );
	static bool SortRepresentations( const Representation_t &lhs, const Representation_t &rhs );
	
	CUtlVector< Representation_t > m_vecRepresentations;
};


//-----------------------------------------------------------------------------
// Purpose: Movie panel. Just displays the movie
//-----------------------------------------------------------------------------
class CMoviePanel : public CPanel2D
{
	DECLARE_PANEL2D( CMoviePanel, CPanel2D );

public:
	CMoviePanel( CPanel2D *parent, const char *pchPanelID );
	virtual ~CMoviePanel();

	CVideoPlayerPtr GetMovie() { return m_pVideoPlayer; }
	void SetMovie( const char *pchFile );
	void SetMovie( CVideoPlayerPtr pVideoPlayer );
	bool IsSet() { return (m_pVideoPlayer != NULL); }
	void Clear();
	void SetPlaybackVolume( float flVolume );
	void SuggestMovieHeight();

	virtual void Paint();

#ifdef DBGFLAG_VALIDATE
	virtual void ValidateClientPanel( CValidator &validator, const tchar *pchName ) OVERRIDE;
#endif

protected:
	virtual void OnContentSizeTraverse( float *pflContentWidth, float *pflContentHeight, float flMaxWidth, float flMaxHeight, bool bFinalDimensions ) OVERRIDE;
	virtual void OnLayoutTraverse( float flFinalWidth, float flFinalHeight ) OVERRIDE;	
	bool EventVideoPlayerInitialized( IVideoPlayer *pIMovie );

private:
	CVideoPlayerPtr m_pVideoPlayer;
};


//-----------------------------------------------------------------------------
// Purpose: Displays debug info for a movie
//-----------------------------------------------------------------------------
class CMovieDebug : public CPanel2D
{
	DECLARE_PANEL2D( CMovieDebug, CPanel2D );

public:
	CMovieDebug( CPanel2D *pParent, const char *pchID );
	virtual ~CMovieDebug() {}

	void Show( CVideoPlayerPtr pVideoPlayer );

private:
	void Update();

	CVideoPlayerPtr m_pVideoPlayer;
	CLabel *m_pDimensions;
	CLabel *m_pResolution;
	CLabel *m_pFileType;
	CLabel *m_pVideoSegment;
	CLabel *m_pVideoBandwidth;

	panorama::CUIScheduledDel m_scheduledUpdate;
};


//-----------------------------------------------------------------------------
// Purpose: Movie player. Includes UI
//-----------------------------------------------------------------------------
class CMoviePlayer : public CPanel2D
{
	DECLARE_PANEL2D( CMoviePlayer, CPanel2D );

public:
	CMoviePlayer( CPanel2D *parent, const char *pchPanelID );
	virtual ~CMoviePlayer();

	virtual void SetupJavascriptObjectTemplate() OVERRIDE;

	CVideoPlayerPtr GetMovie() { return m_pMoviePanel->GetMovie(); }
	void SetMovie( const char *pchFile );
	void SetMovie( CVideoPlayerPtr pVideoPlayer );
	bool IsSet() { return m_pMoviePanel->IsSet(); }
	void Clear();

	enum EAutoplay
	{
		k_EAutoplayOff,
		k_EAutoplayOnLoad,
		k_EAutoplayOnFocus
	};

	enum EControls
	{
		k_EControlsNone,
		k_EControlsMinimal,
		k_EControlsFull,
		k_EControlsInvalid
	};

	void SetAutoplay( EAutoplay eAutoPlay, bool bSkipPlay = false );
	void SetRepeat( bool bRepeat );
	void SetControls( EControls eControls );
	void SetControls( const char *pchControls );


	virtual bool OnGamePadDown( const GamePadData_t &code ) OVERRIDE;
	virtual bool OnKeyTyped( const KeyData_t &unichar ) OVERRIDE;
	virtual panorama::IUIPanel *OnGetDefaultInputFocus() OVERRIDE;

	void Play();
	void Pause();
	void Stop();
	void TogglePlayPause();
	void FastForward();
	void Rewind();
	void SetPlaybackVolume( float flVolume );

	// title control
	void SetTitleText( const char *pchText );
	void ShowTitle( bool bImmediatelyVisible = false );
	void HideTitle();
	bool BAdjustingVolume();

	virtual bool OnMouseButtonDown( const MouseData_t &code );

protected:
	virtual bool BSetProperties( const CUtlVector< ParsedPanelProperty_t > &vecProperties );

	static EControls EControlsFromString( const char *pchControls );

	bool EventInputFocusSet( const CPanelPtr< IUIPanel > &ptrPanel );
	bool EventInputFocusLost( const CPanelPtr< IUIPanel > &ptrPanel );
	bool EventMovieInitialized( IVideoPlayer *pIMovie );
	bool EventVideoPlayerPlaybackStateChanged( IVideoPlayer *pIMovie );
	bool EventVideoPlayerChangedRepresentation( IVideoPlayer *pIMovie );
	bool EventVideoPlayerEnded( IVideoPlayer *pIMovie );
	bool EventActivated( const CPanelPtr< IUIPanel > &ptrPanel, EPanelEventSource_t eSource );
	bool EventCancelled( const CPanelPtr< IUIPanel > &ptrPanel, EPanelEventSource_t eSource );
	bool EventMovieTogglePlayPause();
	bool EventMoviePlayerFastForward();
	bool EventMoviePlayerJumpBack();
	bool EventMoviePlayerVolumeControl();
	bool EventMoviePlayerSelectQuality();
	bool EventSoundVolumeChanged( ESoundType eSoundType, float flVolume );
	bool EventSoundMuteChanged( bool bMute );
	bool EventSetRepresentation( int iRep );

	void UpdateFullUI();
	void UpdateTimeline();
	void UpdatePlayPauseButton();
	void UpdatePlaybackSpeed();
	void Seek( uint unOffset );
	void RaisePlaybackStartEvents();
	void RaisePlaybackStopEvents();
	void DisplayControls( bool bVisible );
	void DisplayTimeline( bool bVisible );
	bool BAnyControlsVisible();
	bool BControlBarVisible();
	bool BTimelineVisible();
	void UpdateMovingPlayingStyle();
	void UpdateVolumeControls();
	void SetAudioVolumeStyle( CPanoramaSymbol symStyle );

	void ShowTitleInternal( bool bImmediatelyVisible = false );
	void HideTitleInternal();

private:
	CMoviePanel *m_pMoviePanel;
	CPanelPtr< CMovieDebug > m_ptrDebug;

	// minimal UI
	CPanel2D *m_pLoadingThrobber;
	CPanel2D *m_pPlayIndicator;
	CPanoramaSymbol m_symMoviePlaybackStyle;

	// title sections
	CPanel2D *m_pPlaybackTitleAndControls;
	CLabel *m_pPlaybackTitle;
	bool m_bExternalShowTitle;

	// full UI
	CPanel2D *m_pPlaybackControls;
	CPanel2D *m_pPlaybackProgressBar;
	CToggleButton *m_pPlayPauseBtn;
	CLabel *m_pPlaybackSpeed;
	CPanel2D *m_pTimeline;
	CPanel2D *m_pControlBarRow;
	CPanel2D *m_pVolumeControl;
	CLabel *m_pErrorMessage;
	CPanelPtr< CVolumeSliderPopup > m_ptrVolumeSlider;
	CPanelPtr< CMovieVideoQualityPopup > m_ptrVideoQualityPopup;
	CButton *m_pVideoQualityBtn;

	bool m_bInConstructor;
	bool m_bRaisedAudioStartEvent;
	bool m_bRaisedPlaybackStartEvent;
	bool m_bHadFocus;
	bool m_bCloseControlsOnPlay;

	EAutoplay m_eAutoplay;
	EControls m_eControls;
	bool m_bDisableActivatePause;
	bool m_bShowControlsNotFullscreen;
	bool m_bRepeat;
	bool m_bMuted;								// muted flag
	float m_flVolume;							// playback volume, defaults to movie volume setting
	int m_iDesiredVideoRepresentation;			// representation selected by user or -1. Video player might not yet have changed to playing this rep
};


} // namespace panorama

#endif // PANORAMA_MOVIEPLAYER_H