2476 lines
52 KiB
C++
2476 lines
52 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: A simple .mp3 player example
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "cbase.h"
|
|
|
|
#if 0
|
|
#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
|