text: //========= Copyright Valve Corporation, All rights reserved. ============//
  //
  // Purpose: A simple .mp3 player example
  //
  //=============================================================================
  
  #include "cbase.h"
  
  #if 1
  #include "mp3player.h"
  #include "KeyValues.h"
  #include "filesystem.h"
  
  #include "vgui_controls/MenuButton.h"
  #include "vgui_controls/Menu.h"
  #include "vgui_controls/Button.h"
  #include "vgui_controls/CheckButton.h"
  #include "vgui_controls/Slider.h"
  #include "vgui_controls/ListPanel.h"
  #include "vgui/IPanel.h"
  #include "vgui/IVGui.h"
  #include "vgui/ISurface.h"
  #include "vgui/IInput.h"
  #include "vgui/ILocalize.h"
  #include "vgui_controls/PHandle.h"
  
  #include "vgui_controls/PropertySheet.h"
  #include "vgui_controls/PropertyPage.h"
  #include "vgui_controls/TreeView.h"
  #include "vgui_controls/FileOpenDialog.h"
  #include "vgui_controls/DirectorySelectDialog.h"
  #include "checksum_crc.h"
  
  #include "engine/IEngineSound.h"
  
  // memdbgon must be the last include file in a .cpp file!!!
  #include "tier0/memdbgon.h"
  
  using namespace vgui;
  
  // Singleton
  static CMP3Player *g_pPlayer = NULL;
  
  vgui::Panel *GetSDKRootPanel();
  
  // Time between songs
  #define END_GAP_TIME	1.0f
  
  #define SOUND_ROOT "sound"
  
  #define MUTED_VOLUME		0.02f
  
  #define TREE_TEXT_COLOR		Color( 200, 255, 200, 255 )
  #define LIST_TEXT_COLOR		TREE_TEXT_COLOR
  
  #define DB_FILENAME			"resource/mp3player_db.txt"
  #define MP3_SETTINGS_FILE	"resource/mp3settings.txt"
  
  #define MP3_DEFAULT_MP3DIR "c:\\my music"
  
  CMP3Player *GetMP3Player()
  {
  	Assert( g_pPlayer );
  	return g_pPlayer;
  }
  
  static void mp3_f()
  {
  	CMP3Player *player = GetMP3Player();
  	if ( player )
  	{
  		player->SetVisible( !player->IsVisible() );
  	}
  }
  void MP3Player_Create( vgui::VPANEL parent )
  {
  	Assert( !g_pPlayer );
  
  	new CMP3Player( parent, "MP3Player" );
  
  #if 0
  	mp3_f();
  #endif
  }
  
  void MP3Player_Destroy()
  {
  	if ( g_pPlayer )
  	{
  		g_pPlayer->MarkForDeletion();
  		g_pPlayer = NULL;
  	}
  }
  
  static ConCommand mp3( "mp3", mp3_f, "Show/hide mp3 player UI." );
  
  //-----------------------------------------------------------------------------
  // Purpose: This assumes artist/album/file.mp3!!!
  // Input  : *relative - 
  //			*artist - 
  //			artistlen - 
  //			*album - 
  //			albumlen - 
  // Output : static bool
  //-----------------------------------------------------------------------------
  static bool SplitArtistAlbum( char const *relative, char *artist, size_t artistlen, char *album, size_t albumlen )
  {
  	artist[ 0 ] = 0;
  	album[ 0 ] = 0;
  	char str[ 512 ];
  	Q_strncpy( str, relative, sizeof( str ) );
  
  	char seps[] = "/\\";
  	char *p = strtok( str, seps );
  	int pos = 0;
  	while ( p )
  	{
  		switch ( pos )
  		{
  		default:
  			break;
  		case 0:
              Q_strncpy( artist, p, artistlen );
  			break;
  		case 1:
  			Q_strncpy( album, p, albumlen );
  			break;
  		case 2:
  			if ( !Q_stristr( p, ".mp3" ) )
  			{
  				artist[ 0 ] = 0;
  				album[ 0 ] = 0;
  				return false;
  			}
  			return true;
  			break;
  		}
  
  		++pos;
  		p = strtok( NULL, seps );
  	}
  	return false;
  }
  
  //-----------------------------------------------------------------------------
  // Purpose: 
  //-----------------------------------------------------------------------------
  class CMP3FileListPage : public PropertyPage
  {
  	DECLARE_CLASS_SIMPLE( CMP3FileListPage, PropertyPage );
  
  public:
  
  	CMP3FileListPage( Panel *parent, CMP3Player *player, char const *panelName ) : 
  	  BaseClass( parent, panelName ),
  	  m_pPlayer( player )
  	{
  		m_pList = new ListPanel( this, "FileList" );
  		m_pList->AddColumnHeader( 0, "File", "File", 200, ListPanel::COLUMN_RESIZEWITHWINDOW );
  		m_pList->AddColumnHeader( 1, "Artist", "Artist", 150, ListPanel::COLUMN_RESIZEWITHWINDOW );
  		m_pList->AddColumnHeader( 2, "Album", "Album", 150, ListPanel::COLUMN_RESIZEWITHWINDOW );
  	}
  
  	void Reset()
  	{
  		m_pList->DeleteAllItems();
  	}
  
  	virtual void ApplySchemeSettings( IScheme *pScheme )
  	{
  		BaseClass::ApplySchemeSettings( pScheme );
  
  		m_pList->SetFont( pScheme->GetFont( "DefaultVerySmall" ) );
  		m_pList->SetFgColor( LIST_TEXT_COLOR );
  	}
  
  	virtual void PerformLayout()
  	{
  		BaseClass::PerformLayout();
  
  		int w, h;
  		GetSize( w, h );
  		m_pList->SetBounds( 0, 0, w, h );
  	}
  
  	void AddSong( int songIndex )
  	{
  		Assert( m_pPlayer );
  
  		const MP3File_t* songInfo = m_pPlayer->GetSongInfo( songIndex );
  		if ( !songInfo )
  		{
  			return;
  		}
  
  		KeyValues *kv = new KeyValues( "LI" );
  		kv->SetString( "File", songInfo->shortname.String() );
  		char fn[ 512 ];
  		if ( g_pFullFileSystem->String( songInfo->filename, fn, sizeof( fn ) ) )
  		{
  			char artist[ 256 ];
  			char album[ 256 ];
  			if ( SplitArtistAlbum( fn, artist, sizeof( artist ), album, sizeof( album ) ) )
  			{
  				kv->SetString( "Artist", artist );
  				kv->SetString( "Album", album );
  			}
  		}
  		kv->SetInt( "SongIndex", songIndex );
  		m_pList->AddItem( kv, 0, false, false );
  		kv->deleteThis();
  	}
  
  	void GetSelectedSongs( CUtlVector< int >&list )
  	{
  		list.RemoveAll();
  
  		int selCount = m_pList->GetSelectedItemsCount();
  		if ( selCount <= 0 )
  		{
  			return;
  		}
  		for ( int i = 0; i < selCount; ++i )
  		{
  			int itemId = m_pList->GetSelectedItem( 0 );
  			KeyValues *kv = m_pList->GetItem( itemId );
  			if ( !kv )
  			{
  				continue;
  			}
  			int song = kv->GetInt( "SongIndex", -1 );
  			if ( song == -1 )
  			{
  				continue;
  			}
  			list.AddToTail( song );
  		}
  	}
  
  	MESSAGE_FUNC_INT( OnOpenContextMenu, "OpenContextMenu", itemID );
  
  	virtual void OnCommand( char const *cmd );
  
  	MESSAGE_FUNC( OnItemSelected, "ItemSelected" )
  	{
  		CUtlVector< int > songList;
  		GetSelectedSongs( songList );
  		m_pPlayer->SelectedSongs( CMP3Player::SONG_FROM_FILELIST, songList );
  	}
  
  private:
  
  	CMP3Player		*m_pPlayer;
  	ListPanel		*m_pList;
  
  	DHANDLE< Menu >	m_hMenu;
  };
  
  void CMP3FileListPage::OnOpenContextMenu( int itemID )
  {
  	if ( m_hMenu.Get() != NULL )
  	{
  		delete m_hMenu.Get();
  	}
  
  	m_hMenu = new Menu( this, "FileListContext" );
  	m_hMenu->AddMenuItem( "AddToPlaylist", "#PlaylistAdd", "addsong", this );
  
  	int x, y;
  	input()->GetCursorPos( x, y );
  
  	m_hMenu->SetPos( x, y );
  	m_hMenu->SetVisible( true );
  }
  
  void CMP3FileListPage::OnCommand( char const *cmd )
  {
  	if ( !Q_stricmp( cmd, "addsong" ) )
  	{
  		// Get selected item
  		int c = m_pList->GetSelectedItemsCount();
  		if ( c > 0 )
  		{
  			int itemId = m_pList->GetSelectedItem( 0 );
  			KeyValues *kv = m_pList->GetItem( itemId );
  			if ( kv )
  			{
  				int songIndex = kv->GetInt( "SongIndex" );
  				m_pPlayer->AddToPlayList( songIndex, false );
  			}
  		}
  	}
  	else
  	{
  		BaseClass::OnCommand( cmd );
  	}
  }
  
  class CMP3PlayListPage : public PropertyPage
  {
  	DECLARE_CLASS_SIMPLE( CMP3PlayListPage, PropertyPage );
  
  public:
  
  	CMP3PlayListPage( Panel *parent, CMP3Player *player, char const *panelName ) : 
  	  BaseClass( parent, panelName ),
  	  m_pPlayer( player )
  	{
  		m_pList = new ListPanel( this, "PlayList" );
  		m_pList->AddColumnHeader( 0, "File", "File", 400, ListPanel::COLUMN_RESIZEWITHWINDOW );
  		m_pList->AddColumnHeader( 1, "Artist", "Artist", 150, ListPanel::COLUMN_RESIZEWITHWINDOW );
  		m_pList->AddColumnHeader( 2, "Album", "Album", 150, ListPanel::COLUMN_RESIZEWITHWINDOW );
  	}
  
  	void Reset()
  	{
  		m_pList->DeleteAllItems();
  	}
  
  	virtual void ApplySchemeSettings( IScheme *pScheme )
  	{
  		BaseClass::ApplySchemeSettings( pScheme );
  
  		m_pList->SetFont( pScheme->GetFont( "DefaultVerySmall" ) );
  		m_pList->SetFgColor( LIST_TEXT_COLOR );
  	}
  
  	virtual void PerformLayout()
  	{
  		BaseClass::PerformLayout();
  
  		int w, h;
  		GetSize( w, h );
  		m_pList->SetBounds( 0, 0, w, h );
  	}
  
  	void AddSong( int songIndex )
  	{
  		Assert( m_pPlayer );
  
  		const MP3File_t* songInfo = m_pPlayer->GetSongInfo( songIndex );
  		if ( !songInfo )
  		{
  			return;
  		}
  
  		KeyValues *kv = new KeyValues( "LI" );
  		kv->SetString( "File", songInfo->shortname.String() );
  		char fn[ 512 ];
  		if ( g_pFullFileSystem->String( songInfo->filename, fn, sizeof( fn ) ) )
  		{
  			char artist[ 256 ];
  			char album[ 256 ];
  			if ( SplitArtistAlbum( fn, artist, sizeof( artist ), album, sizeof( album ) ) )
  			{
  				kv->SetString( "Artist", artist );
  				kv->SetString( "Album", album );
  			}
  		}
  		kv->SetInt( "SongIndex", songIndex );
  		m_pList->AddItem( kv, 0, false, false );
  		kv->deleteThis();
  	}
  
  	void RemoveSong( int songIndex )
  	{
  		// Get selected item
  		int c = m_pList->GetSelectedItemsCount();
  		if ( c > 0 )
  		{
  			int itemId = m_pList->GetSelectedItem( 0 );
  			KeyValues *kv = m_pList->GetItem( itemId );
  			if ( kv && ( kv->GetInt( "SongIndex", -1 ) == songIndex ) )
  			{
  				m_pList->RemoveItem( itemId );
  			}
  		}
  	}
  
  	void GetSelectedSongs( CUtlVector< int >&list )
  	{
  		list.RemoveAll();
  
  		int selCount = m_pList->GetSelectedItemsCount();
  		if ( selCount <= 0 )
  		{
  			return;
  		}
  		for ( int i = 0; i < selCount; ++i )
  		{
  			int itemId = m_pList->GetSelectedItem( 0 );
  			KeyValues *kv = m_pList->GetItem( itemId );
  			if ( !kv )
  			{
  				continue;
  			}
  			int song = kv->GetInt( "SongIndex", -1 );
  			if ( song == -1 )
  			{
  				continue;
  			}
  			list.AddToTail( song );
  		}
  	}
  
  
  	MESSAGE_FUNC_INT( OnOpenContextMenu, "OpenContextMenu", itemID );
  
  	virtual void OnCommand( char const *cmd );
  
  	MESSAGE_FUNC( OnItemSelected, "ItemSelected" )
  	{
  		CUtlVector< int > songList;
  		GetSelectedSongs( songList );
  		m_pPlayer->SelectedSongs( CMP3Player::SONG_FROM_PLAYLIST, songList );
  	}
  
  	void OnItemPlaying( int listIndex )
  	{	
  		int itemId = m_pList->GetItemIDFromRow( listIndex );
  		m_pList->ClearSelectedItems();
  		m_pList->SetSingleSelectedItem( itemId );
  	}
  
  private:
  
  	CMP3Player		*m_pPlayer;
  	ListPanel		*m_pList;
  
  	DHANDLE< Menu >	m_hMenu;
  };
  
  void CMP3PlayListPage::OnOpenContextMenu( int itemID )
  {
  	if ( m_hMenu.Get() != NULL )
  	{
  		delete m_hMenu.Get();
  	}
  
  	m_hMenu = new Menu( this, "PlayListContext" );
  	m_hMenu->AddMenuItem( "Remove", "#PlayListRemove", "removesong", this );
  	m_hMenu->AddMenuItem( "Clear", "#PlayListClear", "clear", this );
  
  	m_hMenu->AddMenuItem( "Load", "#PlayListLoad", "load", this );
  	m_hMenu->AddMenuItem( "Save", "#PlayListSave", "save", this );
  
  	int x, y;
  	input()->GetCursorPos( x, y );
  
  	m_hMenu->SetPos( x, y );
  	m_hMenu->SetVisible( true );
  }
  
  void CMP3PlayListPage::OnCommand( char const *cmd )
  {
  	if ( !Q_stricmp( cmd, "removesong" ) )
  	{
  		// Get selected item
  		int c = m_pList->GetSelectedItemsCount();
  		if ( c > 0 )
  		{
  			int itemId = m_pList->GetSelectedItem( 0 );
  			KeyValues *kv = m_pList->GetItem( itemId );
  			if ( kv )
  			{
  				int songIndex = kv->GetInt( "SongIndex" );
  				m_pPlayer->RemoveFromPlayList( songIndex );
  			}
  		}
  	}
  	else if ( !Q_stricmp( cmd, "clear" ) )
  	{
  		m_pPlayer->ClearPlayList();
  	}
  	else if ( !Q_stricmp( cmd, "load" ) )
  	{
  		m_pPlayer->OnLoadPlayList();
  	}
  	else if ( !Q_stricmp( cmd, "save" ) )
  	{
  		m_pPlayer->OnSavePlayList();
  	}
  	else if ( !Q_stricmp( cmd, "saveas" ) )
  	{
  		m_pPlayer->OnSavePlayListAs();
  	}
  	else
  	{
  		BaseClass::OnCommand( cmd );
  	}
  }
  
  class CMP3FileSheet : public PropertySheet
  {
  	DECLARE_CLASS_SIMPLE( CMP3FileSheet, PropertySheet );
  
  public:
  
  	CMP3FileSheet( CMP3Player *player, char const *panelName );
  
  	void		ResetFileList()
  	{
  		if ( m_pFileList )
  		{
  			m_pFileList->Reset();
  		}
  	}
  
  	void		AddSongToFileList( int songIndex )
  	{
  		if ( m_pFileList )
  		{
  			m_pFileList->AddSong( songIndex );
  		}
  	}
  
  	void		ResetPlayList()
  	{
  		if ( m_pPlayList )
  		{
  			m_pPlayList->Reset();
  		}
  	}
  	void		AddSongToPlayList( int songIndex )
  	{
  		if ( m_pPlayList )
  		{
  			m_pPlayList->AddSong( songIndex );
  		}
  	}
  
  	void		RemoveSongFromPlayList( int songIndex )
  	{
  		if ( m_pPlayList )
  		{
  			m_pPlayList->RemoveSong( songIndex );
  		}
  	}
  
  	void OnPlayListItemPlaying( int listIndex )
  	{
  		if ( m_pPlayList )
  		{
  			m_pPlayList->OnItemPlaying( listIndex );
  		}
  	}
  
  protected:
  
  	CMP3Player			*m_pPlayer;
  
  	CMP3PlayListPage	*m_pPlayList;
  	CMP3FileListPage	*m_pFileList;
  };
  
  CMP3FileSheet::CMP3FileSheet( CMP3Player *player, char const *panelName ) :
  	BaseClass( (Panel *)player, panelName ),
  	m_pPlayer( player )
  {
  	m_pPlayList = new CMP3PlayListPage( this, player, "PlayList" );
  	m_pFileList = new CMP3FileListPage( this, player, "FileList" );
  
  	AddPage( m_pPlayList, "#PlayListTab" );
  	AddPage( m_pFileList, "#FileListTab" );
  
  	SetActivePage( m_pPlayList );
  }	
  
  class CMP3TreeControl : public TreeView
  {
  	DECLARE_CLASS_SIMPLE( CMP3TreeControl, TreeView );
  
  public:
  
  	CMP3TreeControl( CMP3Player *player, char const *panelName );
  
  	int GetSelectedSongIndex();
  
  	MESSAGE_FUNC( OnTreeViewItemSelected, "TreeViewItemSelected" )
  	{
  		CUtlVector< int > songList;
  		int idx = GetSelectedSongIndex();
  		if ( idx != -1 )
  		{
  			songList.AddToTail( idx );
  		}
  
  		m_pPlayer->SelectedSongs( CMP3Player::SONG_FROM_TREE, songList );
  
  		if ( vgui::input()->IsMouseDown( MOUSE_RIGHT ) )
  		{
  			OpenContextMenu();
  		}
  	}
  
  	virtual void OnCommand( char const *cmd );
  
  private:
  	void OpenContextMenu();
  
  
  	CMP3Player *m_pPlayer;
  	DHANDLE< Menu >	m_hMenu;
  };
  
  CMP3TreeControl::CMP3TreeControl( CMP3Player *player, char const *panelName ) :
  	BaseClass( (Panel *)player, panelName ),
  	m_pPlayer( player )
  {
  	AddActionSignalTarget( this );
  }
  
  int CMP3TreeControl::GetSelectedSongIndex()
  {
  	CUtlVector< KeyValues * > kv;
  	GetSelectedItemData( kv );
  	if ( !kv.Count() )
  	{
  		return -1;
  	}
  	return kv[ 0 ]->GetInt( "SongIndex", -1 );
  }
  
  void CMP3TreeControl::OpenContextMenu()
  {
  	if ( m_hMenu.Get() != NULL )
  	{
  		delete m_hMenu.Get();
  	}
  
  	m_hMenu = new Menu( this, "TreeContext" );
  	m_hMenu->AddMenuItem( "AddToPlaylist", "#PlaylistAdd", "addsong", this );
  	m_hMenu->AddMenuItem( "AddToPlaylist", "#PlaySong", "playsong", this );
  
  	int x, y;
  	input()->GetCursorPos( x, y );
  
  	m_hMenu->SetPos( x, y );
  	m_hMenu->SetVisible( true );
  }
  
  void CMP3TreeControl::OnCommand( char const *cmd )
  {
  	if ( !Q_stricmp( cmd, "addsong" ) )
  	{
  		// Get selected item
  		int songIndex = GetSelectedSongIndex();
  		if ( songIndex >= 0 )
  		{
  			m_pPlayer->AddToPlayList( songIndex, false );
  		}
  	}
  	else if ( !Q_stricmp( cmd, "playsong" ) )
  	{
  		int songIndex = GetSelectedSongIndex();
  		if ( songIndex >= 0 )
  		{
  			m_pPlayer->AddToPlayList( songIndex, true );
  		}
  	}
  	else
  	{
  		BaseClass::OnCommand( cmd );
  	}
  }
  
  class CMP3SongProgress : public Slider
  {
  	DECLARE_CLASS_SIMPLE( CMP3SongProgress, Slider );
  
  public:
  
  	CMP3SongProgress( Panel *parent, char const *panelName ) :
  		BaseClass( parent, panelName )
  	{
  		SetPaintEnabled( false );
  		SetRange( 0, 100 );
  	}
  
  	void	SetProgress( float frac )
  	{
  		SetValue( (int)( frac * 100.0f + 0.5f ), false );
  	}
  
  	virtual void PaintBackground()
  	{
  		//BaseClass::PaintBackground();
  		
  		int w, h;
  		GetSize( w, h );
  		
  		float frac = (float)GetValue() * 0.01f;
  
  		int barend = ( int )( (float)( w - 2 ) * frac + 0.5f );
  		
  		surface()->DrawSetColor( GetBgColor() );
  		surface()->DrawFilledRect( 0, 0, w, h );
  		surface()->DrawSetColor( GetFgColor() );
  		surface()->DrawFilledRect( 1, 1, barend, h - 1 );
  	}
  
  	virtual void ApplySchemeSettings( IScheme *pScheme )
  	{
  		BaseClass::ApplySchemeSettings( pScheme );
  
  		SetFgColor( TREE_TEXT_COLOR );
  		SetBgColor( pScheme->GetColor( "BorderDark", Color( 0, 0, 0, 255 ) ) );
  	}
  };
  
  CMP3Player::CMP3Player( VPANEL parent, char const *panelName ) :
  	BaseClass( NULL, panelName ),
  	m_SelectionFrom( SONG_FROM_UNKNOWN ),
  	m_bDirty( false ),
  	m_bSettingsDirty( false ),
  	m_PlayListFileName( UTL_INVAL_SYMBOL ),
  	m_bSavingFile( false ),
  	m_bEnableAutoAdvance( true )
  {
  	g_pPlayer = this;
  
  	// Get strings...
  	g_pVGuiLocalize->AddFile( "resource/mp3player_%language%.txt" );
  	SetParent( parent );
  
  	SetMoveable( true );
  	SetSizeable( true );
  	SetMenuButtonVisible( false );
  	SetMinimizeButtonVisible( false );
  	SetMaximizeButtonVisible( false );
  	SetCloseButtonVisible( true );
  
  	m_pOptions = new MenuButton( this, "Menu", "#MP3Menu" );
  
  	Menu *options = new Menu( m_pOptions, "Options" );
  	options->AddMenuItem( "AddDir", "#AddDirectory", new KeyValues( "Command", "command", "adddirectory" ), this );
  	options->AddMenuItem( "AddGame", "#AddGameSongs", new KeyValues( "Command", "command", "addgamesongs" ), this );
  	options->AddMenuItem( "Refresh", "#RefreshDb", new KeyValues( "Command", "command", "refresh" ), this );
  
  	m_pOptions->SetMenu( options );
  
  	m_pTree = new CMP3TreeControl( this, "Tree" );
  	m_pTree->MakeReadyForUse();
  
  	// Make tree use small font
  	IScheme *pscheme = scheme()->GetIScheme( GetScheme() );
  	HFont treeFont = pscheme->GetFont( "DefaultVerySmall" );
  	m_pTree->SetFont( treeFont );
  
  	m_pFileSheet = new CMP3FileSheet( this, "FileSheet" );
  
  	m_pPlay = new Button( this, "Play", "#Play", this, "play" );
  	m_pStop = new Button( this, "Stop", "#Stop", this, "stop" );
  	m_pNext = new Button( this, "NextTrack", "#Next", this, "nexttrack" );
  	m_pPrev = new Button( this, "PrevTrack", "#Prev", this, "prevtrack" );
  	m_pMute = new CheckButton( this, "Mute", "#Mute" );
  	m_pShuffle = new CheckButton( this, "Shuffle", "#Shuffle" );
  
  	m_pVolume = new Slider( this, "Volume" );
  	m_pVolume->SetRange( (int)( MUTED_VOLUME * 100.0f ), 100 );
  	m_pVolume->SetValue( 100 );
  
  	m_pCurrentSong = new Label( this, "SongName", "#NoSong" );
  	m_pDuration = new Label( this, "SongDuration", "" );
  	
  	m_pSongProgress = new CMP3SongProgress( this, "Progress" );
  	m_pSongProgress->AddActionSignalTarget( this );
  	
  	SetSize( 400, 450 );
  
  	SetMinimumSize( 350, 400 );
  
  	SetTitle( "#MP3PlayerTitle", true );
  
  	LoadControlSettings( "resource/MP3Player.res" );
  
  	m_pCurrentSong->SetText( "#NoSong" );
  	m_pDuration->SetText( "" );
  
  	m_nCurrentFile = -1;
  	m_bFirstTime = true;
  	m_bPlaying = false;
  	m_SongStart = -1.0f;
  	m_nSongGuid = 0;
  	m_nCurrentSong = 0;
  	m_nCurrentPlaylistSong = 0;
  	m_flCurrentVolume = 1.0f;
  	m_bMuted = false;
  
  	vgui::ivgui()->AddTickSignal( GetVPanel(), 100 );
  }
  
  CMP3Player::~CMP3Player()
  {
  	if ( m_bDirty )
  	{
  		SaveDb( DB_FILENAME );
  	}
  	if ( m_bSettingsDirty )
  	{
  		SaveSettings();
  	}
  	DeleteSoundDirectories();
  	RemoveTempSounds();
  }
  
  void CMP3Player::DeleteSoundDirectories()
  {
  	int c = m_SoundDirectories.Count();
  	for ( int i = c - 1 ; i >= 0 ; --i )
  	{
  		delete m_SoundDirectories[ i ];
  	}
  	m_SoundDirectories.RemoveAll();
  }
  
  void CMP3Player::RemoveTempSounds()
  {
  	FileFindHandle_t fh;
  
  	char path[ 512 ];
  	Q_strncpy( path, "sound/_mp3/*.mp3", sizeof( path ) );
  
  	char const *fn = g_pFullFileSystem->FindFirstEx( path, "MOD", &fh );
  	if ( fn )
  	{
  		do
  		{
  			if ( fn[0] != '.'  )
  			{
  				char ext[ 10 ];
  				Q_ExtractFileExtension( fn, ext, sizeof( ext ) );
  
  				if ( !Q_stricmp( ext, "mp3" ) )
  				{
  					char killname[ 512 ];
  					Q_snprintf( killname, sizeof( killname ), "sound/_mp3/%s", fn );
  					g_pFullFileSystem->RemoveFile( killname, "MOD" );
  				}
  			}
  
  			fn = g_pFullFileSystem->FindNext( fh );
  
  		} while ( fn );
  
  		g_pFullFileSystem->FindClose( fh );
  	}
  }
  
  void CMP3Player::WipeSoundDirectories()
  {
  	int c = m_SoundDirectories.Count();
  	for ( int i = c - 1 ; i >= 0 ; --i )
  	{
  		SoundDirectory_t *sd = m_SoundDirectories[ i ];
  		sd->m_pTree->DeleteSubdirectories();
  		sd->m_pTree->m_FilesInDirectory.RemoveAll();
  	}
  }
  
  void CMP3Player::AddGameSounds( bool recurse )
  {
  	SoundDirectory_t *gamesounds = NULL;
  	int idx = FindSoundDirectory( "" );
  	if ( idx == m_SoundDirectories.InvalidIndex() )
  	{
  		gamesounds = new SoundDirectory_t( m_SoundDirectories.Count() );
  		gamesounds->m_bGameSound = true;
  		gamesounds->m_Root = "";
  		gamesounds->m_pTree = new MP3Dir_t();
  		gamesounds->m_pTree->m_DirName = "Game Sounds";
  		gamesounds->m_pTree->m_FullDirPath = "";
  
  		m_SoundDirectories.AddToTail( gamesounds );
  	}
  	else
  	{
  		gamesounds = m_SoundDirectories[ idx ];
  		if ( recurse )
  		{
  			gamesounds->m_pTree->DeleteSubdirectories();
  			gamesounds->m_pTree->m_FilesInDirectory.RemoveAll();
  		}
  	}
  	
  	if ( recurse && gamesounds )
  	{
  		m_nFilesAdded = 0;
  		RecursiveFindMP3Files( gamesounds, SOUND_ROOT, "GAME" );
  	}
  }
  
  void CMP3Player::OnRefresh()
  {
  	CUtlVector< CUtlSymbol > dirnames;
  	int i, c;
  	
  	CUtlVector< FileNameHandle_t >	m_PlayListFiles;
  	
  	int pcount = m_PlayList.Count();
  	for ( i = 0; i < pcount; ++i )
  	{
  		m_PlayListFiles.AddToTail( m_Files[ m_PlayList[ i ] ].filename );
  	}
  
  	m_Files.RemoveAll();
  	WipeSoundDirectories();
  	ClearPlayList();
  
  	c = m_SoundDirectories.Count();
  	for ( i = 0; i < c; ++i )
  	{
  		SoundDirectory_t *sd = m_SoundDirectories[ i ];
  
  		// Now enumerate all .mp3 files in subfolders of this
  		if ( sd->m_bGameSound )
  		{
  			m_nFilesAdded = 0;
  			RecursiveFindMP3Files( sd, SOUND_ROOT, "GAME" );
  		}
  		else
  		{
  			// Add to search path
  			g_pFullFileSystem->AddSearchPath( sd->m_Root.String(), "MP3" );
  			// Don't pollute regular searches...
  			g_pFullFileSystem->MarkPathIDByRequestOnly( "MP3", true );
  
  			m_nFilesAdded = 0;
  			RecursiveFindMP3Files( sd, "", "MP3" );
  		}
  	}
  
  	for ( i = 0; i < pcount; ++i )
  	{
  		char fn[ 512 ];
  		if ( g_pFullFileSystem->String( m_PlayListFiles[ i ], fn, sizeof( fn ) ) )
  		{
  			// Find index for song
  			int songIndex = FindSong( fn );
  			if ( songIndex >= 0 )
  			{
  				AddToPlayList( songIndex, false );
  			}
  		}
  	}
  
  	PopulateTree();
  
  	m_bDirty = true;
  }
  
  void CMP3Player::SetVisible( bool state )
  {
  	BaseClass::SetVisible( state );
  	if ( m_bFirstTime && state )
  	{
  		MoveToCenterOfScreen();
  
  		m_bFirstTime = false;
  
  		LoadSettings();
  		if ( !RestoreDb( DB_FILENAME ) && m_Files.Count() == 0 )
  		{
  			// Load the "game" stuff
  			OnRefresh();
  		}
  		
  		PopulateTree();
  	}
  }
  
  void CMP3Player::ApplySchemeSettings(IScheme *pScheme)
  {
  	BaseClass::ApplySchemeSettings(pScheme);
  
  	HFont treeFont = pScheme->GetFont( "DefaultVerySmall" );
  	m_pTree->SetFont( treeFont );
  }
  
  void CMP3Player::OnCommand( char const *cmd )
  {
  	if ( !Q_stricmp( cmd, "OnClose" ) )
  	{
  		SetVisible( false );
  	}
  	else if ( !Q_stricmp( cmd, "play" ) )
  	{
  		OnPlay();
  	}
  	else if ( !Q_stricmp( cmd, "stop" ) )
  	{
  		OnStop();
  	}
  	else if ( !Q_stricmp( cmd, "nexttrack" ) )
  	{
  		OnNextTrack();
  	}
  	else if ( !Q_stricmp( cmd, "prevtrack" ) )
  	{
  		OnPrevTrack();
  	}
  	else if ( !Q_stricmp( cmd, "refresh" ) )
  	{
  		OnRefresh();
  	}
  	else if ( !Q_stricmp( cmd, "adddirectory" ) )
  	{
  		ShowDirectorySelectDialog();
  	}
  	else if ( !Q_stricmp( cmd, "addgamesongs" ) )
  	{
  		AddGameSounds( true );
  		PopulateTree();
  	}
  	else
  	{
  		BaseClass::OnCommand( cmd );
  	}
  }
  
  void CMP3Player::SplitFile( CUtlVector< CUtlSymbol >& splitList, char const *relative )
  {
  	char work[ 512 ];
  	Q_strncpy( work, relative, sizeof( work ) );
  	char const *separators = "/\\";
  
  	char *token = strtok( work, separators );
  	while ( token )
  	{
  		CUtlSymbol sym = token;
  		splitList.AddToTail( sym );
  
  		token = strtok( NULL, separators );
  	}
  
  }
  
  MP3Dir_t *CMP3Player::FindOrAddSubdirectory( MP3Dir_t *parent, char const *dirname )
  {
  	Assert( parent );
  
  	int c = parent->m_Subdirectories.Count();
  	for ( int i = 0; i < c; ++i )
  	{
  		MP3Dir_t *sub = parent->m_Subdirectories[ i ];
  		if ( !Q_stricmp( sub->m_DirName.String(), dirname ) )
  		{
  			return sub;
  		}
  	}
  
  	// Add a new subdir
  	MP3Dir_t *sub = new MP3Dir_t();
  	sub->m_DirName = dirname;
  	char fullpath[ 512 ];
  	if ( !parent->m_FullDirPath.String()[0] )
  	{
  		Q_snprintf( fullpath, sizeof( fullpath ), "%s", dirname );
  	}
  	else
  	{
  		Q_snprintf( fullpath, sizeof( fullpath ), "%s\\%s", parent->m_FullDirPath.String(), dirname );
  	}
  	sub->m_FullDirPath = fullpath;
  	parent->AddSubDirectory( sub );
  
  	return sub;
  }
  
  int CMP3Player::AddSplitFileToDirectoryTree_R( int songIndex, MP3Dir_t *parent, CUtlVector< CUtlSymbol >& splitList, int level )
  {
  	char const *current = splitList[ level ].String();
  	if ( !current )
  	{
  		return -1;
  	}
  
  	if ( level == splitList.Count() -1 )
  	{
  		// It's a filename, add if not already in list
  		if ( songIndex != -1 &&
  			 parent->m_FilesInDirectory.Find( songIndex ) == parent->m_FilesInDirectory.InvalidIndex() )
  		{
  			parent->m_FilesInDirectory.AddToTail( songIndex );
  		}
  		return songIndex;
  	}
  
  	// It's a directory
  	MP3Dir_t *subdir = FindOrAddSubdirectory( parent, current );
  	return AddSplitFileToDirectoryTree_R( songIndex, subdir, splitList, level + 1 );
  }
  
  int CMP3Player::AddFileToDirectoryTree( SoundDirectory_t *dir, char const *relative )
  {
  	// AddSong
  	int songIndex = AddSong( relative, dir->GetIndex() );
  
  	CUtlVector< CUtlSymbol > list;
  	SplitFile( list, relative );
  
  	return AddSplitFileToDirectoryTree_R( songIndex, dir->m_pTree, list, 0 );
  }
  
  void CMP3Player::RecursiveFindMP3Files( SoundDirectory_t *root, char const *current, char const *pathID )
  {
  	FileFindHandle_t fh;
  
  #if 0
  	if ( m_nFilesAdded >= 200 )
  		return;
  #endif
  
  	char path[ 512 ];
  	if ( current[ 0 ] )
  	{
          Q_snprintf( path, sizeof( path ), "%s/*.*", current );
  	}
  	else
  	{
  		Q_snprintf( path, sizeof( path ), "*.*" );
  	}
  
  	Q_FixSlashes( path );
  
  	char const *fn = g_pFullFileSystem->FindFirstEx( path, pathID, &fh );
  	if ( fn )
  	{
  		do
  		{
  			if ( fn[0] != '.' && Q_strnicmp( fn, "_mp3", 4 ) )
  			{
  				if ( g_pFullFileSystem->FindIsDirectory( fh ) )
  				{
  					char nextdir[ 512 ];
  					if ( current[ 0 ] )
  					{
  						Q_snprintf( nextdir, sizeof( nextdir ), "%s/%s", current, fn );
  					}
  					else
  					{
  						Q_snprintf( nextdir, sizeof( nextdir ), "%s", fn );
  					}
  
  					RecursiveFindMP3Files( root, nextdir, pathID );
  				}
  				else
  				{
  					char ext[ 10 ];
  					Q_ExtractFileExtension( fn, ext, sizeof( ext ) );
  
  					if ( !Q_stricmp( ext, "mp3" ) )
  					{
  						char relative[ 512 ];
  						if ( root->m_bGameSound )
  						{
  							Q_snprintf( relative, sizeof( relative ), "%s/%s", current + Q_strlen( SOUND_ROOT"/" ), fn );
  						}
  						else
  						{
  							if ( current[ 0 ] )
  							{
  								Q_snprintf( relative, sizeof( relative ), "%s/%s", current, fn );
  							}
  							else
  							{
  								Q_snprintf( relative, sizeof( relative ), "%s", fn );
  							}
  						}
  						Msg( "Found '%s/%s'\n", current, fn );
  
  						Q_FixSlashes( relative );
  						++m_nFilesAdded;
  						AddFileToDirectoryTree( root, relative );
  					}
  				}
  			}
  
  			fn = g_pFullFileSystem->FindNext( fh );
  
  		} while ( fn );
  
  		g_pFullFileSystem->FindClose( fh );
  	}
  }
  
  int CMP3Player::FindSong( char const *relative )
  {
  	Assert( !Q_stristr( relative, "/" ) );
  
  	FileNameHandle_t handle = g_pFullFileSystem->FindOrAddFileName( relative );
  	int c = m_Files.Count();
  	for ( int i = 0 ; i < c ; ++i )
  	{
  		const MP3File_t& mp3 = m_Files[ i ];
  		if ( mp3.filename == handle )
  		{
  			return i;
  		}
  	}
  	return -1;
  }
  
  int CMP3Player::AddSong( char const *relative, int dirnum )
  {
  	int songIndex = FindSong( relative );
  	
  	if ( songIndex == -1 )
  	{
  #if 0
  		if ( m_Files.Count() >= 200 )
  			return -1;
  #endif
  
  		MP3File_t mp3;
  
  		Assert( !Q_stristr( relative, "/" ) );
  
  		mp3.filename = g_pFullFileSystem->FindOrAddFileName( relative );
  
  		char shortname[ 256 ];
  		Q_FileBase( relative, shortname, sizeof( shortname ) );
  		Q_SetExtension( shortname, ".mp3", sizeof( shortname ) );
  		mp3.shortname = shortname;
  		mp3.flags = ( dirnum == 0 ) ? MP3File_t::FLAG_FROMGAME : MP3File_t::FLAG_FROMFS;
  		mp3.dirnum = dirnum;
  		songIndex = m_Files.AddToTail( mp3 );
  
  		m_bDirty = true;
  	}
  	
  	return songIndex;
  }
  
  void CMP3Player::RecursiveAddToTree( MP3Dir_t *current, int parentIndex )
  {
  	if ( !current )
  	{
  		return;
  	}
  
  	// Add all files at current level and then recurse through any directories
  	int i, c;
  	c = current->m_Subdirectories.Count();
  	for ( i = 0 ; i < c; ++i )
  	{
  		MP3Dir_t *sub = current->m_Subdirectories[ i ];
  		Assert( sub );
  		
  		KeyValues *kv = new KeyValues( "TVI" );
  		kv->SetString( "Text", sub->m_DirName.String() );
  		kv->SetPtr( "MP3Dir", sub );
  
  		int index = m_pTree->AddItem( kv, parentIndex );
  		m_pTree->SetItemFgColor( index, TREE_TEXT_COLOR );
  
  		// Recurse...
  		RecursiveAddToTree( sub, index );
  	}
  
  	// Add raw files
  	c = current->m_FilesInDirectory.Count();
  	for ( i = 0; i < c; ++i )
  	{
  		MP3File_t *song = &m_Files[ current->m_FilesInDirectory[ i ] ];
  
  		KeyValues *kv = new KeyValues( "TVI" );
  
  		kv->SetString( "Text", song->shortname.String() );
  		kv->SetInt( "SongIndex", current->m_FilesInDirectory[ i ] );
  
  		int index = m_pTree->AddItem( kv, parentIndex );
  		m_pTree->SetItemFgColor( index, TREE_TEXT_COLOR );
  	}
  }
  
  void CMP3Player::OnTreeViewItemSelected()
  {
  	PopulateLists();
  }
  
  void CMP3Player::PopulateTree()
  {
  	m_pTree->RemoveAll();
  
  	// Now populate tree
  	KeyValues *kv = new KeyValues( "TVI" );
  	kv->SetString( "Text", "Songs" );
  
  	int rootIndex = m_pTree->AddItem( kv, -1 );
  	m_pTree->SetItemFgColor( rootIndex, TREE_TEXT_COLOR );
  
  	int dircount = m_SoundDirectories.Count();
  	for ( int dirnum = 0; dirnum < dircount; ++dirnum )
  	{
  		MP3Dir_t *tree = m_SoundDirectories[ dirnum ]->m_pTree;
  		if ( !tree )
  			continue;
  
  		char const *dirname = tree->m_DirName.String();
  
  		kv = new KeyValues( "TVI" );
  		kv->SetString( "Text", dirname );
  
  		int index = m_pTree->AddItem( kv, rootIndex );
  
  		RecursiveAddToTree( tree, index );
  
  		m_pTree->SetItemFgColor( index, TREE_TEXT_COLOR );
  	}
  
  	m_pTree->ExpandItem( rootIndex, true );
  
  	PopulateLists();
  }
  
  // Instead of including windows.h
  extern "C"
  {
  	extern int __stdcall CopyFileA( char *pszSource, char *pszDest, int bFailIfExists );
  };
  
  void CMP3Player::GetLocalCopyOfSong( const MP3File_t &mp3, char *outsong, size_t outlen )
  {
  	outsong[ 0 ] = 0;
  	char fn[ 512 ];
  	if ( !g_pFullFileSystem->String( mp3.filename, fn, sizeof( fn ) ) )
  	{
  		return;
  	}
  
  	if ( mp3.flags == MP3File_t::FLAG_FROMGAME )
  	{
  		Q_FixSlashes( fn );
  		Q_strncpy( outsong, fn, outlen );
  		return;
  	}
  
  	// Get temp filename from crc
  	CRC32_t crc;
  	CRC32_Init( &crc );
  	CRC32_ProcessBuffer( &crc, fn, Q_strlen( fn ) );
  	CRC32_Final( &crc );
  
  	char hexname[ 16 ];
  	Q_binarytohex( (const byte *)&crc, sizeof( crc ), hexname, sizeof( hexname ) );
  
  	char hexfilename[ 512 ];
  	Q_snprintf( hexfilename, sizeof( hexfilename ), "sound/_mp3/%s.mp3", hexname );
  
  	Q_FixSlashes( hexfilename );
  
  	if ( g_pFullFileSystem->FileExists( hexfilename, "MOD" ) )
  	{
  		Q_snprintf( outsong, outlen, "_mp3/%s.mp3", hexname );
  	}
  	else
  	{
  		// Make a local copy
  		char mp3_temp_path[ 512 ];
  		Q_snprintf( mp3_temp_path, sizeof( mp3_temp_path ), "sound/_mp3" );
  		g_pFullFileSystem->CreateDirHierarchy( mp3_temp_path, "MOD" );
  
  		char destpath[ 512 ];
  		Q_snprintf( destpath, sizeof( destpath ), "%s/%s", engine->GetGameDirectory(), hexfilename );
  		Q_FixSlashes( destpath );
  
  		char sourcepath[ 512 ];
  
  		Assert( mp3.dirnum >= 0 && mp3.dirnum < m_SoundDirectories.Count() );
  		SoundDirectory_t *sdir = m_SoundDirectories[ mp3.dirnum ];
  		Q_snprintf( sourcepath, sizeof( sourcepath ), "%s/%s", sdir->m_Root.String(), fn );
  		Q_FixSlashes( sourcepath );
  
  		// !!!HACK HACK:
  		// Total hack right now, using windows OS calls to copy file to full destination
  		int success = ::CopyFileA( sourcepath, destpath, TRUE );
  		if ( success > 0 )
  		{
  			Q_snprintf( outsong, outlen, "_mp3/%s.mp3", hexname );
  		}
  	}
  
  	Q_FixSlashes( outsong );
  }
  
  void CMP3Player::PlaySong( int songIndex, float skipTime /*= 0.0f */ ) 
  {
  	MP3File_t& song = m_Files[ songIndex ];
  
  	float volume = 1.0f;
  
  	char soundname[ 512 ];
  
  	soundname[ 0 ] = 0;
  
  	if ( song.playbackfilename == (FileNameHandle_t)0 )
  	{
  		GetLocalCopyOfSong( song, soundname, sizeof( soundname ) );
  		if ( !soundname[ 0 ] )
  		{
  			return;
  		}
  
  		Assert( !Q_stristr( soundname, "/" ) );
  		song.playbackfilename = g_pFullFileSystem->FindOrAddFileName( soundname );
  
  
  	}
  	else
  	{
  		if ( !g_pFullFileSystem->String( song.playbackfilename, soundname, sizeof( soundname ) ) )
  		{
  			return;
  		}
  	}
  
  	// Msg( "Playing '%s'\n", soundname );
  
  	if ( !soundname[ 0 ] )
  	{
  		return;
  	}
  
  	if ( m_bPlaying )
  	{
  		OnStop();
  	}
  
  	char drymix[ 512 ];
  	Q_snprintf( drymix, sizeof( drymix ), "#%s", soundname );
  
  	enginesound->EmitAmbientSound(
  		drymix, 
  		volume,
  		PITCH_NORM,
  		0,
  		skipTime == 0.0f ? 0.0f : ( gpGlobals->curtime + skipTime  ) ); 
  
  	m_nSongGuid = enginesound->GetGuidForLastSoundEmitted();
  
  	m_nCurrentSong = songIndex;
  	m_bPlaying = true;
  	m_LastSong = song.playbackfilename;
  	m_SongStart = gpGlobals->realtime;
  	m_flSongDuration = GetMP3Duration( soundname );
  
  	m_pCurrentSong->SetText( song.shortname.String() );
  	
  	m_nSongMinutes = (int)( m_flSongDuration / 60.0f );
  	m_nSongSeconds = (int)( m_flSongDuration - (float)( m_nSongMinutes * 60 ) );
  
  	char durationstr[ 256 ];
  	Q_snprintf( durationstr, sizeof( durationstr ), "0:00 / %i:%02i", m_nSongMinutes, m_nSongSeconds );
  
  	m_pDuration->SetText( durationstr );
  	
  	m_pSongProgress->SetProgress( 0.0f );
  }
  
  void CMP3Player::OnStop()
  {
  	if ( m_bPlaying )
  	{
  		m_bPlaying = false;
  
  		if ( m_nSongGuid != 0 )
  		{
  			enginesound->StopSoundByGuid( m_nSongGuid );
  			m_nSongGuid = 0;
  		}
  
  		m_LastSong = (FileNameHandle_t)0;
  		m_pCurrentSong->SetText( "#NoSong" );
  		m_pSongProgress->SetProgress( 0.0f );
  		m_pDuration->SetText( "" );
  	}
  }
  
  float CMP3Player::GetMP3Duration( char const *songname )
  {
  	return enginesound->GetSoundDuration( songname );
  }
  
  void CMP3Player::SelectedSongs( SongListSource_t from, CUtlVector< int >& songIndexList )
  {
  	m_SelectedSongs.RemoveAll();
  	m_SelectionFrom = from;
  
  	int i, c;
  	c = songIndexList.Count();
  	for ( i = 0; i < c; ++i )
  	{
  		m_SelectedSongs.AddToTail( songIndexList[ i ] );
  	}
  }
  
  void CMP3Player::OnPlay()
  {
  	int c = m_SelectedSongs.Count();
  
  	for ( int i = 0 ; i < c; ++i )
  	{
  		int songIndex = m_SelectedSongs[ i ];
  		if ( songIndex < 0 || songIndex >= m_Files.Count() )
  		{
  			continue;
  		}
  		if ( m_SelectionFrom == SONG_FROM_PLAYLIST )
  		{
  			// Can only play one song at a time from playlist...
  			PlaySong( songIndex );
  			break;
  		}
  		else
  		{
  			AddToPlayList( songIndex, i == 0 );
  		}
  	}
  }
  
  void CMP3Player::OnTick()
  {
  	BaseClass::OnTick();
  
  	if ( !m_bPlaying )
  	{
  		return;
  	}
  
  	float newVol = (float)m_pVolume->GetValue() / 100.0f;
  
  	bool volumeChanged = ( newVol != m_flCurrentVolume );
  	if ( volumeChanged )
  	{
  		m_flCurrentVolume = newVol;
  	}
  	bool muteChanged = m_bMuted != m_pMute->IsSelected();
  	if ( muteChanged )
  	{
  		m_bMuted = m_pMute->IsSelected();
  	}
  
  	if ( m_nSongGuid == 0 )
  	{
  		return;
  	}
  
  	bool playing = enginesound->IsSoundStillPlaying( m_nSongGuid );
  	if ( playing )
  	{
  		if ( muteChanged )
  		{
  			if ( m_bMuted )
  			{
  				OnChangeVolume( MUTED_VOLUME );
  			}
  			else
  			{
  				OnChangeVolume( m_flCurrentVolume );
  			}
  		}
  
  		if ( volumeChanged )
  		{
  			// Msg( "set volume %f\n", m_flCurrentVolume );
  			OnChangeVolume( m_flCurrentVolume );
  		}
  
  		if ( m_flSongDuration >= 0.001f )
  		{
  			float elapsed = gpGlobals->realtime - m_SongStart;
  
  			float frac = elapsed / m_flSongDuration;
  			frac = clamp( frac, 0.0f, 1.0f );
  			m_pSongProgress->SetProgress( frac );
  
  			int minutes = ( int ) ( elapsed / 60.0f );
  			int seconds = (int)( elapsed - ( 60 * minutes ) );
  			char durationstr[ 256 ];
  			Q_snprintf( durationstr, sizeof( durationstr ), "%i:%02i / %i:%02i", minutes, seconds, m_nSongMinutes, m_nSongSeconds );
  
  			m_pDuration->SetText( durationstr );
  		}
  		return;
  	}
  
  	if ( !m_bEnableAutoAdvance )
  	{
  		// If we got disconnected completely, reset the flag
  		if ( !engine->IsConnected() )
  		{
  			m_bEnableAutoAdvance = true;
  		}
  		return;
  	}
  
  	// No song playing...
  	m_nSongGuid = 0;
  	OnNextTrack();
  }
  
  void CMP3Player::OnChangeVolume( float newVol )
  {
  	if ( !m_bPlaying )
  	{
  		return;
  	}
  
  	if ( !m_nSongGuid )
  		return;
  
  	enginesound->SetVolumeByGuid( m_nSongGuid, newVol );
  }
  
  void CMP3Player::GoToNextSong( int skip )
  {
  	bool shuffle = m_pShuffle->IsSelected();
  
  	int nextSong = 0;
  
  	if ( m_PlayList.Count() > 0 )
  	{
  		if ( shuffle )
  		{
  			m_nCurrentPlaylistSong = random->RandomInt( 0, m_PlayList.Count() - 1 );
  		}
  		else
  		{
  			m_nCurrentPlaylistSong = ( m_nCurrentPlaylistSong + skip ) % m_PlayList.Count();
  			if ( m_nCurrentPlaylistSong < 0 )
  			{
  				m_nCurrentPlaylistSong = m_PlayList.Count() - 1;
  			}
  		}
  		nextSong = m_PlayList[ m_nCurrentPlaylistSong ];
  
  		m_pFileSheet->OnPlayListItemPlaying( m_nCurrentPlaylistSong );
  	}
  	else
  	{
  		if ( shuffle )
  		{
  			nextSong = random->RandomInt( 0, m_Files.Count() - 1 );
  		}
  		else
  		{
  			nextSong = ( m_nCurrentSong + skip ) % m_Files.Count();
  			if ( nextSong < 0 )
  			{
  				nextSong = m_Files.Count() - 1;
  			}
  		}
  	}
  
  	PlaySong( nextSong );
  }
  
  void CMP3Player::OnNextTrack()
  {
  	if ( m_Files.Count() == 0 )
  	{
  		return;
  	}
  
  	GoToNextSong( +1 );
  }
  
  void CMP3Player::OnPrevTrack()
  {
  	if ( m_Files.Count() == 0 )
  	{
  		return;
  	}
  
  	GoToNextSong( -1 );
  }
  
  void CMP3Player::RemoveFSSongs()
  {
  	int c = m_Files.Count();
  	for ( int i = c - 1; i >= 0; --i )
  	{
  		MP3File_t& mp3 = m_Files[ i ];
  		if ( mp3.flags == MP3File_t::FLAG_FROMGAME )
  			continue;
  
  		m_Files.Remove( i );
  	}
  }
  
  int CMP3Player::FindSoundDirectory( char const *fullpath )
  {
  	CUtlSymbol sym = fullpath;
  	int c = m_SoundDirectories.Count();
  	for ( int i = 0; i < c; ++i )
  	{
  		if ( sym == m_SoundDirectories[ i ]->m_Root )
  			return i;
  	}
  
  	return m_SoundDirectories.InvalidIndex();
  }
  
  SoundDirectory_t *CMP3Player::AddSoundDirectory( char const *fullpath, bool recurse )
  {
  	// RemoveFSSongs();
  	m_bDirty = true;
  	m_bSettingsDirty = true;
  
  	CUtlSymbol sym = fullpath;
  	int sdi = FindSoundDirectory( fullpath );
  	if ( sdi == m_SoundDirectories.InvalidIndex() )
  	{
  		SoundDirectory_t *sounddir = new SoundDirectory_t( m_SoundDirectories.Count() );
  		sounddir->m_bGameSound = false;
  		sounddir->m_Root = sym;
  		sounddir->m_pTree = new MP3Dir_t();
  		sounddir->m_pTree->m_DirName = fullpath;
  		sounddir->m_pTree->m_FullDirPath = fullpath;
  	
  		sdi = m_SoundDirectories.AddToTail( sounddir );
  
  		// Add to search path
  		g_pFullFileSystem->AddSearchPath( fullpath, "MP3" );
  		// Don't pollute regular searches...
  		g_pFullFileSystem->MarkPathIDByRequestOnly( "MP3", true );
  
  		// Now enumerate all .mp3 files in subfolders of this
  		if ( recurse )
  		{
  			m_nFilesAdded = 0;
  			RecursiveFindMP3Files( sounddir, "", "MP3" );
  		}
  	}
  
  	return m_SoundDirectories[ sdi ];
  }
  
  void CMP3Player::PopulateLists()
  {
  	CUtlVector< KeyValues * > kv;
  	m_pTree->GetSelectedItemData( kv );
  	if ( !kv.Count() )
  	{
  		return;
  	}
  
  	MP3Dir_t *dir = static_cast< MP3Dir_t * >( kv[ 0 ]->GetPtr( "MP3Dir", 0 ) );
  	if ( !dir )
  	{
  		return;
  	}
  
  	int i, c;
  	c = dir->m_FilesInDirectory.Count();
  	if ( !c )
  	{
  		return;
  	}
  
  	m_pFileSheet->ResetFileList();
  	for ( i = 0; i < c ; ++i )
  	{
  		m_pFileSheet->AddSongToFileList( dir->m_FilesInDirectory[ i ] );
  	}
  }
  
  MP3File_t *CMP3Player::GetSongInfo( int songIndex )
  {
  	if ( songIndex < 0 || songIndex >= m_Files.Count() )
  	{
  		return NULL;
  	}
  	return &m_Files[ songIndex ];
  }
  
  void CMP3Player::AddToPlayList( int songIndex, bool playNow )
  {
  	m_pFileSheet->AddSongToPlayList( songIndex );
  	m_PlayList.AddToTail( songIndex );
  
  	if ( playNow )
  	{
  		PlaySong( songIndex );
  		SetPlayListSong( m_PlayList.Count() - 1 );
  	}
  
  	// refresh the playlist
  }
  
  void CMP3Player::RemoveFromPlayList( int songIndex )
  {
  	m_pFileSheet->RemoveSongFromPlayList( songIndex );
  	m_PlayList.FindAndRemove( songIndex );
  
  	SetPlayListSong( m_nCurrentPlaylistSong );
  }
  
  void CMP3Player::ClearPlayList()
  {
  	m_pFileSheet->ResetPlayList();
  	m_PlayList.RemoveAll();
  	m_nCurrentPlaylistSong = 0;
  }
  
  void CMP3Player::OnLoadPlayList()
  {
  	ShowFileOpenDialog( false );
  }
  
  void CMP3Player::OnSavePlayList()
  {
  	if ( UTL_INVAL_SYMBOL == m_PlayListFileName )
  	{
  		OnSavePlayListAs();
  		return;
  	}
  
  	SavePlayList( m_PlayListFileName.String() );
  }
  
  void CMP3Player::OnSavePlayListAs()
  {
  	ShowFileOpenDialog( true );
  }
  
  void CMP3Player::RestoreSongs( KeyValues *songs )
  {
  	Assert( m_Files.Count() == 0 );
  
  	for ( KeyValues *song = songs->GetFirstSubKey(); song != NULL; song = song->GetNextKey() )
  	{
  		int flags = 0;
  		int game = song->GetInt( "fromgame", 0 );
  		if ( game )
  		{
  			flags |= MP3File_t::FLAG_FROMGAME;
  		}
  		int fs = song->GetInt( "fromfs", 0 );
  		if ( fs )
  		{
  			flags |= MP3File_t::FLAG_FROMFS;
  		}
  
  		int subdir = song->GetInt( "subdirindex", 0 );
  
  		char shortname[ 512 ];
  		char filename[ 512 ];
  
  		Q_strncpy( shortname, song->GetString( "short", "" ), sizeof( shortname ) );
  		Q_strncpy( filename, song->GetString( "filename", "" ), sizeof( filename ) );
  
  		MP3File_t file;
  		file.dirnum = subdir;
  		file.flags = flags;
  		file.shortname = shortname;
  		file.filename = g_pFullFileSystem->FindOrAddFileName( filename );
  		m_Files.AddToTail( file );
  	}
  }
  
  void CMP3Player::RestoreDirectory( KeyValues *dir, SoundDirectory_t *sd )
  {
  	for ( KeyValues *kv = dir->GetFirstSubKey(); kv; kv = kv->GetNextKey() )
  	{
  		if ( !Q_stricmp( kv->GetName(), "name" ) )
  		{
  			sd->m_Root = kv->GetString();
  		}
  		else if ( !Q_stricmp( kv->GetName(), "gamesounds" ) )
  		{
  			sd->m_bGameSound = kv->GetInt() ? true : false;
  		}
  		else if ( !Q_stricmp( kv->GetName(), "dirname" ) )
  		{
  			sd->m_pTree->m_DirName = kv->GetString();
  		}
  		else if ( !Q_stricmp( kv->GetName(), "fullpath" ) )
  		{
  			sd->m_pTree->m_FullDirPath = kv->GetString();
  		}
  		else if ( !Q_stricmp( kv->GetName(), "files" ) )
  		{
  			for ( KeyValues *f = kv->GetFirstSubKey(); f != NULL; f = f->GetNextKey() )
  			{
  				if ( !Q_stricmp( f->GetName(), "file" ) )
  				{
  					int songIndex = f->GetInt();
  					if ( songIndex >= 0 && songIndex < m_Files.Count() )
  					{
  						char fn[ 512 ];
  						if ( g_pFullFileSystem->String( m_Files[ songIndex ].filename, fn, sizeof( fn ) ) )
  						{
  							AddFileToDirectoryTree( sd, fn );
  						}
  					}
  				}
  			}
  		}
  		else
  		{
  			Warning( "Unknown key '%s'\n", kv->GetName() );
  		}
  	}
  }
  
  void CMP3Player::RestoreDirectories( KeyValues *dirs )
  {
  	for ( KeyValues *dir = dirs->GetFirstSubKey(); dir != NULL; dir = dir->GetNextKey() )
  	{
  		char const *dirpath = dir->GetString( "fullpath", "" );
  		if ( dirpath  )
  		{
  			int sdi = FindSoundDirectory( dirpath );
  			if ( sdi == m_SoundDirectories.InvalidIndex() )
  			{
  				SoundDirectory_t *sd = AddSoundDirectory( dirpath, false );
  				sdi = sd->GetIndex();
  			}
  			RestoreDirectory( dir, m_SoundDirectories[ sdi ] );
  		}
  	}
  }
  
  bool CMP3Player::RestoreDb( char const *filename )
  {
  	KeyValues *kv = new KeyValues( "db" );
  	Assert( kv );
  	if ( !kv->LoadFromFile( g_pFullFileSystem, filename, "MOD" ) )
  	{
  		Warning( "Unable to load '%s'\n", filename );
  		return false;
  	}
  
  	KeyValues *songs = kv;
  
  	Assert( !Q_stricmp( songs->GetName(), "songs" ) );
  	RestoreSongs( songs );
  	KeyValues *dirs = songs->GetNextKey();
  	Assert( !Q_stricmp( dirs->GetName(), "directories" ) );
  	RestoreDirectories( dirs );
  
  	kv->deleteThis();
  
  	return true;
  }
  
  void bpr( int level, CUtlBuffer& buf, char const *fmt, ... )
  {
  	char txt[ 4096 ];
  	va_list argptr;
  	va_start( argptr, fmt );
  	_vsnprintf( txt, sizeof( txt ) - 1, fmt, argptr );
  	va_end( argptr );
  
  	int indent = 2;
  	for ( int i = 0; i < ( indent * level ); ++i )
  	{
  		buf.Printf( " " );
  	}
  	buf.Printf( "%s", txt );
  }
  
  void CMP3Player::SaveDbFile( int level, CUtlBuffer& buf, MP3File_t *file, int filenumber )
  {
  	bpr( level, buf, "file\n" );
  	bpr( level, buf, "{\n" );
  
  	bpr( level + 1, buf, "filenumber %i\n", filenumber );
  
  	if ( file->flags & MP3File_t::FLAG_FROMGAME )
  	{
  		bpr( level + 1, buf, "fromgame 1\n" );
  	}
  	if ( file->flags & MP3File_t::FLAG_FROMFS )
  	{
  		bpr( level + 1, buf, "fromfs 1\n" );
  	}
  
  	bpr( level + 1, buf, "subdirindex %i\n", file->dirnum );
  
  	bpr( level + 1, buf, "short \"%s\"\n", file->shortname.String() );
  	char fn[ 512 ];
  	if ( g_pFullFileSystem->String( file->filename, fn, sizeof( fn ) ) )
  	{
  		bpr( level + 1, buf, "filename \"%s\"\n", fn );
  	}
  	else
  	{
  		Assert( 0 );
  	}
  
  	bpr( level, buf, "}\n" );
  }
  
  void CMP3Player::FlattenDirectoryFileList_R( MP3Dir_t *dir, CUtlVector< int >& list )
  {
  	int i, c;
  	c = dir->m_FilesInDirectory.Count();
  	for ( i = 0; i < c; ++i )
  	{
  		int songIndex = dir->m_FilesInDirectory[ i ];
  		if ( list.Find( songIndex ) == list.InvalidIndex() )
  		{
  			list.AddToTail( songIndex );
  		}
  	}
  
  	c = dir->m_Subdirectories.Count();
  	for ( i = 0; i < c; ++i )
  	{
  		FlattenDirectoryFileList_R( dir->m_Subdirectories[ i ], list );
  	}
  }
  
  void CMP3Player::SaveDbDirectory( int level, CUtlBuffer& buf, SoundDirectory_t *sd )
  {
  	bpr( level, buf, "directory\n" );
  	bpr( level, buf, "{\n" );
  
  	bpr( level + 1, buf, "gamesounds %i\n", sd->m_bGameSound ? 1 : 0 );
  	bpr( level + 1, buf, "name \"%s\"\n", sd->m_Root.String() );
  	bpr( level + 1, buf, "dirname \"%s\"\n", sd->m_pTree->m_DirName.String() );
  	bpr( level + 1, buf, "fullpath \"%s\"\n", sd->m_pTree->m_FullDirPath.String() );
  
  	CUtlVector< int > files;
  	if ( sd->m_pTree )
  	{
  		FlattenDirectoryFileList_R( sd->m_pTree, files );
  	}
  
  	int i, c;
  	
  	c = files.Count();
  	if ( c > 0 )
  	{
  		bpr( level + 1, buf, "files\n" );
  		bpr( level + 1, buf, "{\n" );
  		for ( i = 0; i < c; ++i )
  		{
  			bpr( level + 2, buf, "file %i\n", files[ i ] );
  		}
  		bpr( level + 1, buf, "}\n" );
  	}
  
  	bpr( level, buf, "}\n" );
  }
  
  void CMP3Player::SaveDb( char const *filename )
  {
  	int i, c;
  
  	CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
  
  	buf.Printf( "// mp3 database, automatically generated\n" );
  
  	bpr( 0, buf, "songs\n{\n" );
  
  	c = m_Files.Count();
  	for ( i = 0; i < c; ++i )
  	{
  		MP3File_t* file = &m_Files[ i ];
  		SaveDbFile( 1, buf, file, i );
  	}
  
  	bpr( 0, buf, "}\n" );
  
  	bpr( 0, buf, "directories\n{\n" );
  
  	c = m_SoundDirectories.Count();
  	for ( i = 0; i < c; ++i )
  	{
  		SoundDirectory_t *sd = m_SoundDirectories[ i ];
  
  		if ( sd->m_pTree )
  		{
  			SaveDbDirectory( 1, buf, sd );
  		}
  	}
  
  	bpr( 0, buf, "}\n" );
  
  	FileHandle_t fh = g_pFullFileSystem->Open( filename, "wb" );
  	if ( FILESYSTEM_INVALID_HANDLE != fh )
  	{
  		g_pFullFileSystem->Write( buf.Base(), buf.TellPut(), fh );
  		g_pFullFileSystem->Close( fh );
  		m_bDirty = false;
  	}
  	else
  	{
  		Warning( "Unable to open '%s' for writing\n", filename );
  	}
  }
  
  void CMP3Player::OnSave()
  {
  	SaveDb( DB_FILENAME );
  }
  
  void CMP3Player::OnSliderMoved()
  {
  	if ( !m_bPlaying )
  	{
  		return;
  	}
  
  // The engine only allows 4 seconds of skip ahead right now and you have to be connected to get it to work
  //  until this is relaxed we can't do this this way...
  #if 0
  	float frac = (float)m_pSongProgress->GetValue() / 100.0f;
  
  	float offset = frac * m_flSongDuration;
  	PlaySong( m_nCurrentSong, -offset );
  #endif
  }
  
  void CMP3Player::LoadPlayList( char const *filename )
  {
  	KeyValues *kv = new KeyValues( "playlist" );
  	Assert( kv );
  	if ( !kv->LoadFromFile( g_pFullFileSystem, filename, "MOD" ) )
  	{
  		Warning( "Unable to load '%s'\n", MP3_SETTINGS_FILE );
  		return;
  	}
  
  	m_PlayListFileName = filename;
  
  	for ( KeyValues *song = kv->GetFirstSubKey(); song != NULL; song = song->GetNextKey() )
  	{
  		if ( !Q_stricmp( song->GetName(), "song" ) )
  		{
  			char const *songname = song->GetString( "relativepath" );
  			if ( !songname || !songname[ 0 ] )
  				continue;
  
  			char const *dirname = song->GetString( "directory" );
  			int flags = 0;
  			int game = song->GetInt( "fromgame", 0 );
  			if ( game )
  			{
  				flags |= MP3File_t::FLAG_FROMGAME;
  			}
  			int fs = song->GetInt( "fromfs", 0 );
  			if ( fs )
  			{
  				flags |= MP3File_t::FLAG_FROMFS;
  			}
  
  			int songIndex = -1;
  
  			// Find index
  			int idx = FindSong( songname );
  			if ( idx == -1 )
  			{
  				// See if directory exists...
  				if ( flags & MP3File_t::FLAG_FROMGAME )
  				{
  					songIndex = AddSong( songname, 0 );
  				}
  				else if ( dirname )
  				{
  					SoundDirectory_t *sd = NULL;
  					int dirnum = FindSoundDirectory( dirname );
  					if ( dirnum == -1 )
  					{
  						sd = AddSoundDirectory( dirname, false );
  					}
  					else
  					{
  						sd = m_SoundDirectories[ dirnum ];
  					}
  
  					if ( sd )
  					{
  						songIndex = AddFileToDirectoryTree( sd, songname );
  					}
  				}
  			}
  			else
  			{
  				songIndex = idx;
  			}
  
  			if ( songIndex >= 0 )
  			{
  				m_PlayList.AddToTail( songIndex );
  			}
  		}
  	}
  
  	kv->deleteThis();
  
  	PopulateTree();
  	PopulateLists();
  }
  
  void CMP3Player::SavePlayList( char const *filename )
  {
  	FileHandle_t fh = g_pFullFileSystem->Open( filename, "wb" );
  	if ( FILESYSTEM_INVALID_HANDLE != fh )
  	{
  		m_PlayListFileName = filename;
  
  		CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
  
  		buf.Printf( "// mp3 playlist\n" );
  
  		bpr( 0, buf, "playlist\n{\n" );
  
  		int c = m_PlayList.Count();
  		for ( int i = 0; i < c; ++i )
  		{
  			MP3File_t& song = m_Files[ m_PlayList[ i ] ];
  			char fn[ 512 ];
  			if ( g_pFullFileSystem->String( song.filename, fn, sizeof( fn ) ) )
  			{
  				char dirname[ 512 ];
  				dirname[0]=0;
  				if ( song.dirnum >= 0 )
  				{
  					SoundDirectory_t *sd = m_SoundDirectories[ song.dirnum ];
  
  					Q_strncpy( dirname, sd->m_Root.String(), sizeof( dirname ) );
  				}
  
  				bpr( 1, buf, "song\n" );
  				{
  					bpr( 2, buf, "%s 1\n", song.flags == MP3File_t::FLAG_FROMFS ? "fromfs" : "fromgame" );
  
  					if ( dirname[0])
  					{
  						bpr( 2, buf, "directory \"%s\"\n", dirname );
  					}
  					bpr( 2, buf, "relativepath \"%s\"\n", fn );
  				}
  				bpr( 1, buf, "\n" );
  			}
  		}
  
  		bpr( 0, buf, "}\n" );
  
  		g_pFullFileSystem->Close( fh );
  
  		SetMostRecentPlayList( filename );
  	}
  }
  
  void CMP3Player::SetMostRecentPlayList( char const *filename )
  {
  	m_PlayListFileName = filename;
  	m_bSettingsDirty = true;
  }
  
  void CMP3Player::LoadSettings()
  {
  	KeyValues *kv = new KeyValues( "settings" );
  	Assert( kv );
  	if ( !kv->LoadFromFile( g_pFullFileSystem, MP3_SETTINGS_FILE, "MOD" ) )
  	{
  		Warning( "Unable to load '%s'\n", MP3_SETTINGS_FILE );
  		return;
  	}
  
  	char const *filename = kv->GetString( "mostrecentplaylist", "" );
  	if ( filename && filename[ 0 ] )
  	{
  		LoadPlayList( filename );
  	}
  
  	KeyValues *dirs = kv->FindKey( "directories", false );
  	if ( dirs )
  	{
  		for ( KeyValues *sub = dirs; sub ; sub = sub->GetNextKey() )
  		{
  			char const *dirname = sub->GetString( "dirname", "" );
  			if ( dirname && dirname[ 0 ] )
  			{
  				AddSoundDirectory( dirname, false ); 
  			}
  			else if ( dirname )
  			{
  				AddGameSounds( false );
  			}
  		}
  	}
  
  	kv->deleteThis();
  
  	m_bSettingsDirty = false;
  }
  
  void CMP3Player::ShowFileOpenDialog( bool saving )
  {
  	m_bSavingFile = saving;
  	if ( m_hSaveLoadPlaylist.Get() )
  	{
  		m_hSaveLoadPlaylist.Get()->MarkForDeletion();
  	}
  
  	m_hSaveLoadPlaylist = new FileOpenDialog( this, "Choose Playlist", !saving );
  	if ( m_hSaveLoadPlaylist.Get() )
  	{
  		m_hSaveLoadPlaylist->SetStartDirectory( "resource/" );
  		m_hSaveLoadPlaylist->AddFilter( "*.txt", "Playlists", true );
  		m_hSaveLoadPlaylist->DoModal( m_bSavingFile );
  	}
  }
  
  void CMP3Player::OnFileSelected( char const *fullpath )
  {
  	if ( m_bSavingFile )
  	{
  		SavePlayList( fullpath );
  		m_PlayListFileName = fullpath;
  	}
  	else
  	{
  		m_PlayListFileName = fullpath;
  		LoadPlayList( fullpath );
  		m_nCurrentPlaylistSong = 0;
  	}
  
  	if ( m_hSaveLoadPlaylist.Get() )
  	{
  		m_hSaveLoadPlaylist.Get()->MarkForDeletion();
  	}
  }
  
  
  void CMP3Player::ShowDirectorySelectDialog()
  {
  	if ( m_hDirectorySelect.Get() )
  	{
  		m_hDirectorySelect.Get()->MarkForDeletion();
  	}
  
  	m_hDirectorySelect = new DirectorySelectDialog( this, "Choose Directory" );
  	if ( m_hDirectorySelect.Get() )
  	{
  		m_hDirectorySelect->MakeReadyForUse();
  		m_hDirectorySelect->SetStartDirectory( MP3_DEFAULT_MP3DIR );
  		m_hDirectorySelect->SetFgColor( TREE_TEXT_COLOR );
  		m_hDirectorySelect->DoModal();
  	}
  }
  
  void CMP3Player::OnDirectorySelected( KeyValues *params )
  {
  	if ( m_hDirectorySelect.Get() )
  	{
  		m_hDirectorySelect.Get()->MarkForDeletion();
  	}
  
  	char const *fullpath = params->GetString( "dir", "" );
  	if ( fullpath && fullpath[ 0 ] )
  	{
  		char dir[ 512 ];
  		Q_strncpy( dir, fullpath, sizeof( dir ) );
  		Q_StripTrailingSlash( dir );
  		AddSoundDirectory( dir, true );
  		PopulateTree();
  		m_bDirty = true;
  	}
  }
  
  void CMP3Player::SaveSettings()
  {
  	if ( !m_bSettingsDirty )
  	{
  		return;
  	}
  
  	m_bSettingsDirty = false;
  
  	FileHandle_t fh = g_pFullFileSystem->Open( MP3_SETTINGS_FILE, "wb" );
  	if ( FILESYSTEM_INVALID_HANDLE != fh )
  	{
  		CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
  
  		buf.Printf( "// mp3 settings, automatically generated\n" );
  
  		bpr( 0, buf, "settings\n{\n" );
  
  		// FIXME:  Move to function if there are more settings to save...
  		if ( UTL_INVAL_SYMBOL != m_PlayListFileName )
  		{
  			bpr( 1, buf, "mostrecentplaylist \"%s\"\n", m_PlayListFileName.String() );
  		}
  
  		int c;
  		c = m_SoundDirectories.Count();
  		if ( c > 0 )
  		{
  			bpr( 1, buf, "directories\n" );
  			bpr( 1, buf, "{\n" );
  
  			for ( int i = 0; i < c; ++i )
  			{
  				SoundDirectory_t *sd = m_SoundDirectories[ i ];
  				Assert( sd );
  
  				bpr( 2, buf, "dirname \"%s\"\n", sd->m_Root.String() );
  			}
  
  			bpr( 1, buf, "}\n" );
  		}
  
  		bpr( 0, buf, "}\n" );
  
  		g_pFullFileSystem->Write( buf.Base(), buf.TellPut(), fh );
  		g_pFullFileSystem->Close( fh );
  	}
  }
  
  void CMP3Player::SetPlayListSong( int listIndex )
  {
  	if ( m_PlayList.Count() > 0 )
  	{
          m_nCurrentPlaylistSong = listIndex % m_PlayList.Count();
  	}
  	else
  	{
  		m_nCurrentPlaylistSong = 0;
  	}
  }
  
  void CMP3Player::EnableAutoAdvance( bool state )
  {
  	m_bEnableAutoAdvance = state;
  }
  
  //-----------------------------------------------------------------------------
  // Purpose: The purpose of this is that when a changelevel occurs, the engine calls
  //  StopAllSounds several times, and the OnTick handler thinks the song has finished playing 
  //  and so it moves to the next song.  This causes the play list to skip ahead by > 1 song during a level
  //  change.
  //-----------------------------------------------------------------------------
  class CMP3PlayerGameSystem : public CAutoGameSystem
  {
  public:
  	CMP3PlayerGameSystem()
  	{
  	}
  
  	virtual void LevelInitPreEntity()
  	{
  		g_pPlayer->EnableAutoAdvance( true );
  	}
  
  	virtual void LevelShutdownPostEntity()
  	{
  		// If we are still connected, disable auto advance until we get into the next level
  		if ( engine->IsConnected() )
  		{
  			g_pPlayer->EnableAutoAdvance( false );
  		}
  	}
  };
  
  static CMP3PlayerGameSystem g_MP3Helper;
  
  #else
  
  void MP3Player_Create( vgui::VPANEL parent )
  {
  }
  
  void MP3Player_Destroy()
  {
  }
  
  #endif
  