You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
602 lines
19 KiB
602 lines
19 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
//============================================================================= |
|
|
|
#include <windows.h> |
|
#undef PropertySheet |
|
|
|
#include "filesystem.h" |
|
#include "dme_controls/soundpicker.h" |
|
#include "tier1/KeyValues.h" |
|
#include "vgui_controls/ListPanel.h" |
|
#include "vgui_controls/Button.h" |
|
#include "vgui_controls/PropertySheet.h" |
|
#include "vgui_controls/PropertyPage.h" |
|
#include "dme_controls/filtercombobox.h" |
|
#include "vgui/ISurface.h" |
|
#include "vgui/iinput.h" |
|
#include "dme_controls/dmecontrols.h" |
|
#include "soundemittersystem/isoundemittersystembase.h" |
|
#include "mathlib/mathlib.h" |
|
|
|
// FIXME: Move sound code out of the engine + into a library! |
|
#include "toolframework/ienginetool.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
|
|
using namespace vgui; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// Sound Picker |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Sort by sound name |
|
//----------------------------------------------------------------------------- |
|
static int __cdecl GameSoundSortFunc( vgui::ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 ) |
|
{ |
|
bool bRoot1 = item1.kv->GetInt("root") != 0; |
|
bool bRoot2 = item2.kv->GetInt("root") != 0; |
|
if ( bRoot1 != bRoot2 ) |
|
return bRoot1 ? -1 : 1; |
|
const char *string1 = item1.kv->GetString("gamesound"); |
|
const char *string2 = item2.kv->GetString("gamesound"); |
|
return Q_stricmp( string1, string2 ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
//----------------------------------------------------------------------------- |
|
CSoundPicker::CSoundPicker( vgui::Panel *pParent, int nFlags ) : |
|
BaseClass( pParent, "Sound Files", "wav", "sound", "wavName" ) |
|
{ |
|
m_nSoundSuppressionCount = 0; |
|
m_nPlayingSound = 0; |
|
|
|
// Connection problem if this failed |
|
Assert( SoundEmitterSystem() ); |
|
|
|
m_pViewsSheet = new vgui::PropertySheet( this, "ViewsSheet" ); |
|
m_pViewsSheet->AddActionSignalTarget( this ); |
|
|
|
// game sounds |
|
m_pGameSoundPage = NULL; |
|
m_pGameSoundList = NULL; |
|
if ( nFlags & PICK_GAMESOUNDS ) |
|
{ |
|
m_pGameSoundPage = new PropertyPage( m_pViewsSheet, "GameSoundPage" ); |
|
m_pGameSoundList = new ListPanel( m_pGameSoundPage, "GameSoundsList" ); |
|
m_pGameSoundList->AddColumnHeader( 0, "GameSound", "Game Sound", 52, 0 ); |
|
m_pGameSoundList->AddActionSignalTarget( this ); |
|
m_pGameSoundList->SetSelectIndividualCells( true ); |
|
m_pGameSoundList->SetEmptyListText("No game sounds"); |
|
m_pGameSoundList->SetDragEnabled( true ); |
|
m_pGameSoundList->SetAutoResize( Panel::PIN_TOPLEFT, Panel::AUTORESIZE_DOWNANDRIGHT, 0, 0, 0, 0 ); |
|
m_pGameSoundList->SetSortFunc( 0, GameSoundSortFunc ); |
|
m_pGameSoundList->SetSortColumn( 0 ); |
|
m_pGameSoundList->SetMultiselectEnabled( ( nFlags & ALLOW_MULTISELECT ) != 0 ); |
|
|
|
// filter selection |
|
m_pGameSoundFilter = new TextEntry( m_pGameSoundPage, "GameSoundFilter" ); |
|
m_pGameSoundFilter->AddActionSignalTarget( this ); |
|
|
|
m_pGameSoundPage->LoadControlSettings( "resource/soundpickergamesoundpage.res" ); |
|
|
|
m_pViewsSheet->AddPage( m_pGameSoundPage, "Game Sounds" ); |
|
} |
|
|
|
// wav files |
|
m_pWavPage = NULL; |
|
if ( nFlags & PICK_WAVFILES ) |
|
{ |
|
m_pWavPage = new PropertyPage( m_pViewsSheet, "WavPage" ); |
|
bool bAllowMultiselect = ( nFlags & ALLOW_MULTISELECT ) != 0; |
|
CreateStandardControls( m_pWavPage, bAllowMultiselect ); |
|
AddExtension( "mp3" ); |
|
|
|
m_pWavPage->LoadControlSettings( "resource/soundpickerwavpage.res" ); |
|
m_pViewsSheet->AddPage( m_pWavPage, "WAVs" ); |
|
} |
|
|
|
LoadControlSettings( "resource/soundpicker.res" ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Destructor |
|
//----------------------------------------------------------------------------- |
|
CSoundPicker::~CSoundPicker() |
|
{ |
|
StopSoundPreview(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: called to open |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::Activate() |
|
{ |
|
BaseClass::Activate(); |
|
if ( m_pGameSoundPage ) |
|
{ |
|
BuildGameSoundList(); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Sets the current sound choice |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::SetSelectedSound( PickType_t type, const char *pSoundName ) |
|
{ |
|
if ( type == PICK_NONE || !pSoundName ) |
|
return; |
|
|
|
if ( m_pGameSoundPage && ( type == PICK_GAMESOUNDS ) ) |
|
{ |
|
m_pViewsSheet->SetActivePage( m_pGameSoundPage ); |
|
m_pGameSoundFilter->SetText( pSoundName ); |
|
} |
|
|
|
if ( m_pWavPage && ( type == PICK_WAVFILES ) ) |
|
{ |
|
m_pViewsSheet->SetActivePage( m_pWavPage ); |
|
SetInitialSelection( pSoundName ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::OnKeyCodePressed( KeyCode code ) |
|
{ |
|
if ( m_pGameSoundPage && ( m_pViewsSheet->GetActivePage() == m_pGameSoundPage ) ) |
|
{ |
|
if (( code == KEY_UP ) || ( code == KEY_DOWN ) || ( code == KEY_PAGEUP ) || ( code == KEY_PAGEDOWN )) |
|
{ |
|
KeyValues *pMsg = new KeyValues( "KeyCodePressed", "code", code ); |
|
vgui::ipanel()->SendMessage( m_pGameSoundList->GetVPanel(), pMsg, GetVPanel() ); |
|
pMsg->deleteThis(); |
|
return; |
|
} |
|
} |
|
|
|
BaseClass::OnKeyCodePressed( code ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: builds the gamesound list |
|
//----------------------------------------------------------------------------- |
|
bool CSoundPicker::IsGameSoundVisible( int hGameSound ) |
|
{ |
|
const char *pSoundName = SoundEmitterSystem()->GetSoundName( hGameSound ); |
|
return ( !m_GameSoundFilter.Length() || Q_stristr( pSoundName, m_GameSoundFilter.Get() ) ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Updates the column header in the chooser |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::UpdateGameSoundColumnHeader( int nMatchCount, int nTotalCount ) |
|
{ |
|
char pColumnTitle[512]; |
|
Q_snprintf( pColumnTitle, sizeof(pColumnTitle), "%s (%d/%d)", |
|
"Game Sound", nMatchCount, nTotalCount ); |
|
m_pGameSoundList->SetColumnHeaderText( 0, pColumnTitle ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: builds the gamesound list |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::BuildGameSoundList() |
|
{ |
|
if ( !m_pGameSoundList ) |
|
return; |
|
|
|
m_pGameSoundList->RemoveAll(); |
|
|
|
int nTotalCount = 0; |
|
int i = SoundEmitterSystem()->First(); |
|
while ( i != SoundEmitterSystem()->InvalidIndex() ) |
|
{ |
|
const char *pSoundName = SoundEmitterSystem()->GetSoundName( i ); |
|
|
|
bool bInRoot = !strchr( pSoundName, '\\' ) && !strchr( pSoundName, '/' ); |
|
KeyValues *kv = new KeyValues( "node", "gamesound", pSoundName ); |
|
kv->SetInt( "gameSoundHandle", i ); |
|
kv->SetInt( "root", bInRoot ); |
|
|
|
int nItemID = m_pGameSoundList->AddItem( kv, 0, false, false ); |
|
m_pGameSoundList->SetItemVisible( nItemID, IsGameSoundVisible( i ) ); |
|
KeyValues *pDrag = new KeyValues( "drag", "text", pSoundName ); |
|
pDrag->SetString( "texttype", "gamesoundName" ); |
|
m_pGameSoundList->SetItemDragData( nItemID, pDrag ); |
|
++nTotalCount; |
|
|
|
i = SoundEmitterSystem()->Next( i ); |
|
} |
|
|
|
m_pGameSoundList->SortList(); |
|
if ( m_pGameSoundList->GetItemCount() > 0 ) |
|
{ |
|
int nItemID = m_pGameSoundList->GetItemIDFromRow( 0 ); |
|
|
|
// This prevents the refreshing of the sound list from playing the sound |
|
++m_nSoundSuppressionCount; |
|
m_pGameSoundList->SetSelectedCell( nItemID, 0 ); |
|
} |
|
|
|
UpdateGameSoundColumnHeader( nTotalCount, nTotalCount ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: refreshes the gamesound list |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::RefreshGameSoundList() |
|
{ |
|
if ( !m_pGameSoundList ) |
|
return; |
|
|
|
// Check the filter matches |
|
int nMatchingGameSounds = 0; |
|
int nTotalCount = 0; |
|
for ( int nItemID = m_pGameSoundList->FirstItem(); nItemID != m_pGameSoundList->InvalidItemID(); nItemID = m_pGameSoundList->NextItem( nItemID ) ) |
|
{ |
|
KeyValues *kv = m_pGameSoundList->GetItem( nItemID ); |
|
int hGameSound = kv->GetInt( "gameSoundHandle", SoundEmitterSystem()->InvalidIndex() ); |
|
if ( hGameSound == SoundEmitterSystem()->InvalidIndex() ) |
|
continue; |
|
bool bIsVisible = IsGameSoundVisible( hGameSound ); |
|
m_pGameSoundList->SetItemVisible( nItemID, bIsVisible ); |
|
if ( bIsVisible ) |
|
{ |
|
++nMatchingGameSounds; |
|
} |
|
++nTotalCount; |
|
} |
|
|
|
UpdateGameSoundColumnHeader( nMatchingGameSounds, nTotalCount ); |
|
|
|
if ( ( m_pGameSoundList->GetSelectedItemsCount() == 0 ) && ( m_pGameSoundList->GetItemCount() > 0 ) ) |
|
{ |
|
int nItemID = m_pGameSoundList->GetItemIDFromRow( 0 ); |
|
// This prevents the refreshing of the sound list from playing the sound |
|
++m_nSoundSuppressionCount; |
|
m_pGameSoundList->SetSelectedCell( nItemID, 0 ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Update filter when text changes |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::OnGameSoundFilterTextChanged( ) |
|
{ |
|
int nLength = m_pGameSoundFilter->GetTextLength(); |
|
m_GameSoundFilter.SetLength( nLength ); |
|
if ( nLength > 0 ) |
|
{ |
|
m_pGameSoundFilter->GetText( m_GameSoundFilter.GetForModify(), nLength+1 ); |
|
} |
|
RefreshGameSoundList(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: refreshes dialog on filter changing |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::OnTextChanged( KeyValues *pKeyValues ) |
|
{ |
|
vgui::Panel *pSource = (vgui::Panel*)pKeyValues->GetPtr( "panel" ); |
|
if ( pSource == m_pGameSoundFilter ) |
|
{ |
|
OnGameSoundFilterTextChanged(); |
|
return; |
|
} |
|
|
|
BaseClass::OnTextChanged( pKeyValues ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when a page is shown |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::RequestGameSoundFilterFocus( ) |
|
{ |
|
m_pGameSoundFilter->SelectAllOnFirstFocus( true ); |
|
m_pGameSoundFilter->RequestFocus(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Called when a page is shown |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::OnPageChanged( ) |
|
{ |
|
StopSoundPreview(); |
|
if ( m_pGameSoundPage && ( m_pViewsSheet->GetActivePage() == m_pGameSoundPage ) ) |
|
{ |
|
RequestGameSoundFilterFocus(); |
|
} |
|
if ( m_pWavPage && ( m_pViewsSheet->GetActivePage() == m_pWavPage ) ) |
|
{ |
|
RequestFilterFocus(); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Stop sound preview |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::StopSoundPreview( ) |
|
{ |
|
if ( m_nPlayingSound != 0 ) |
|
{ |
|
EngineTool()->StopSoundByGuid( m_nPlayingSound ); |
|
m_nPlayingSound = 0; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Plays a gamesound |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::PlayGameSound( const char *pSoundName ) |
|
{ |
|
StopSoundPreview(); |
|
|
|
CSoundParameters params; |
|
if ( SoundEmitterSystem()->GetParametersForSound( pSoundName, params, GENDER_NONE ) ) |
|
{ |
|
m_nPlayingSound = EngineTool()->StartSound( 0, true, -1, CHAN_STATIC, params.soundname, |
|
params.volume, params.soundlevel, vec3_origin, vec3_origin, 0, |
|
params.pitch, false, params.delay_msec / 1000.0f ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Plays a wav file |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::PlayWavSound( const char *pSoundName ) |
|
{ |
|
StopSoundPreview(); |
|
m_nPlayingSound = EngineTool()->StartSound( 0, true, -1, CHAN_STATIC, pSoundName, |
|
VOL_NORM, SNDLVL_NONE, vec3_origin, vec3_origin, 0, PITCH_NORM, false, 0 ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Don't play a sound when the next selection is a default selection |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::OnNextSelectionIsDefault() |
|
{ |
|
++m_nSoundSuppressionCount; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Derived classes have this called when the previewed asset changes |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::OnSelectedAssetPicked( const char *pAssetName ) |
|
{ |
|
bool bPlaySounds = true; |
|
if ( m_nSoundSuppressionCount > 0 ) |
|
{ |
|
--m_nSoundSuppressionCount; |
|
bPlaySounds = false; |
|
} |
|
|
|
if ( pAssetName && bPlaySounds ) |
|
{ |
|
PlayWavSound( pAssetName ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: refreshes dialog on text changing |
|
//----------------------------------------------------------------------------- |
|
void CSoundPicker::OnItemSelected( KeyValues *kv ) |
|
{ |
|
Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL ); |
|
if ( m_pGameSoundList && (pPanel == m_pGameSoundList ) ) |
|
{ |
|
bool bPlaySounds = true; |
|
if ( m_nSoundSuppressionCount > 0 ) |
|
{ |
|
--m_nSoundSuppressionCount; |
|
bPlaySounds = false; |
|
} |
|
|
|
const char *pGameSoundName = GetSelectedSoundName(); |
|
if ( pGameSoundName && bPlaySounds ) |
|
{ |
|
int len = V_strlen( pGameSoundName ); |
|
char *soundname = ( char* )stackalloc( len + 2 ); |
|
soundname[ 0 ] = '#'; // mark sound to bypass the dsp |
|
V_strncpy( soundname + 1, pGameSoundName, len + 1 ); |
|
|
|
PlayGameSound( soundname ); |
|
} |
|
return; |
|
} |
|
|
|
BaseClass::OnItemSelected( kv ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Gets the selected sound type |
|
//----------------------------------------------------------------------------- |
|
CSoundPicker::PickType_t CSoundPicker::GetSelectedSoundType( ) |
|
{ |
|
if ( m_pGameSoundPage && ( m_pViewsSheet->GetActivePage() == m_pGameSoundPage ) ) |
|
return PICK_GAMESOUNDS; |
|
if ( m_pWavPage && ( m_pViewsSheet->GetActivePage() == m_pWavPage ) ) |
|
return PICK_WAVFILES; |
|
return PICK_NONE; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the selected sound count |
|
//----------------------------------------------------------------------------- |
|
int CSoundPicker::GetSelectedSoundCount() |
|
{ |
|
if ( m_pGameSoundPage && ( m_pViewsSheet->GetActivePage() == m_pGameSoundPage ) ) |
|
return m_pGameSoundList->GetSelectedItemsCount(); |
|
|
|
if ( m_pWavPage && ( m_pViewsSheet->GetActivePage() == m_pWavPage ) ) |
|
return GetSelectedAssetCount(); |
|
|
|
return 0; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the selected sound |
|
//----------------------------------------------------------------------------- |
|
const char *CSoundPicker::GetSelectedSoundName( int nSelectionIndex ) |
|
{ |
|
if ( m_pGameSoundPage && ( m_pViewsSheet->GetActivePage() == m_pGameSoundPage ) ) |
|
{ |
|
int nCount = m_pGameSoundList->GetSelectedItemsCount(); |
|
if ( nCount == 0 ) |
|
return NULL; |
|
|
|
if ( nSelectionIndex < 0 ) |
|
{ |
|
nSelectionIndex = nCount - 1; |
|
} |
|
int nIndex = m_pGameSoundList->GetSelectedItem( nSelectionIndex ); |
|
if ( nIndex >= 0 ) |
|
{ |
|
KeyValues *pkv = m_pGameSoundList->GetItem( nIndex ); |
|
return pkv->GetString( "gamesound", NULL ); |
|
} |
|
return NULL; |
|
} |
|
|
|
if ( m_pWavPage && ( m_pViewsSheet->GetActivePage() == m_pWavPage ) ) |
|
return GetSelectedAsset( nSelectionIndex ); |
|
|
|
return NULL; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// Purpose: Modal picker frame |
|
// |
|
//----------------------------------------------------------------------------- |
|
CSoundPickerFrame::CSoundPickerFrame( vgui::Panel *pParent, const char *pTitle, int nFlags ) : |
|
BaseClass( pParent ) |
|
{ |
|
SetAssetPicker( new CSoundPicker( this, nFlags ) ); |
|
LoadControlSettingsAndUserConfig( "resource/soundpickerframe.res" ); |
|
SetTitle( pTitle, false ); |
|
} |
|
|
|
CSoundPickerFrame::~CSoundPickerFrame() |
|
{ |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Activate the dialog |
|
//----------------------------------------------------------------------------- |
|
void CSoundPickerFrame::DoModal( CSoundPicker::PickType_t initialType, const char *pInitialValue, KeyValues *pContextKeyValues ) |
|
{ |
|
vgui::surface()->SetCursor( dc_hourglass ); |
|
CSoundPicker *pPicker = static_cast <CSoundPicker*>( GetAssetPicker() ); |
|
if ( initialType != CSoundPicker::PICK_NONE && pInitialValue ) |
|
{ |
|
pPicker->SetSelectedSound( initialType, pInitialValue ); |
|
} |
|
BaseClass::DoModal( pContextKeyValues ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// On command |
|
//----------------------------------------------------------------------------- |
|
void CSoundPickerFrame::OnCommand( const char *pCommand ) |
|
{ |
|
CSoundPicker *pPicker = static_cast <CSoundPicker*>( GetAssetPicker() ); |
|
if ( !Q_stricmp( pCommand, "Open" ) ) |
|
{ |
|
CSoundPicker::PickType_t type = pPicker->GetSelectedSoundType( ); |
|
if (( type == CSoundPicker::PICK_GAMESOUNDS ) || ( type == CSoundPicker::PICK_WAVFILES )) |
|
{ |
|
const char *pSoundName = pPicker->GetSelectedSoundName(); |
|
|
|
int len = V_strlen( pSoundName ); |
|
char *soundname = ( char* )stackalloc( len + 2 ); |
|
soundname[ 0 ] = '#'; // mark sound to bypass the dsp |
|
V_strncpy( soundname + 1, pSoundName, len + 1 ); |
|
|
|
int nSoundCount = pPicker->GetSelectedSoundCount(); |
|
|
|
KeyValues *pActionKeys = new KeyValues( "SoundSelected" ); |
|
pActionKeys->SetInt( "count", nSoundCount ); |
|
KeyValues *pSoundList = NULL; |
|
if ( type == CSoundPicker::PICK_GAMESOUNDS ) |
|
{ |
|
pActionKeys->SetString( "gamesound", soundname ); |
|
if ( pPicker->IsMultiselectEnabled() ) |
|
{ |
|
pSoundList = pActionKeys->FindKey( "gamesounds", true ); |
|
} |
|
} |
|
else |
|
{ |
|
pActionKeys->SetString( "wav", soundname ); |
|
if ( pPicker->IsMultiselectEnabled() ) |
|
{ |
|
pSoundList = pActionKeys->FindKey( "wavs", true ); |
|
} |
|
} |
|
|
|
if ( pSoundList ) |
|
{ |
|
// Adds them in selection order |
|
for ( int i = 0; i < nSoundCount; ++i ) |
|
{ |
|
char pBuf[32]; |
|
Q_snprintf( pBuf, sizeof(pBuf), "%d", i ); |
|
pSoundName = pPicker->GetSelectedSoundName( i ); |
|
|
|
len = V_strlen( pSoundName ); |
|
soundname = ( char* )malloc( len + 2 ); |
|
soundname[ 0 ] = '#'; // mark sound to bypass the dsp |
|
V_strncpy( soundname + 1, pSoundName, len + 1 ); |
|
|
|
pSoundList->SetString( pBuf, soundname ); |
|
free( soundname ); |
|
} |
|
} |
|
|
|
PostMessageAndClose( pActionKeys ); |
|
CloseModal(); |
|
} |
|
return; |
|
} |
|
|
|
BaseClass::OnCommand( pCommand ); |
|
} |
|
|
|
|
|
|