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.
599 lines
19 KiB
599 lines
19 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: Singleton dialog that generates and presents the entity report. |
|
// |
|
//===========================================================================// |
|
|
|
#include "particlesystemdefinitionbrowser.h" |
|
#include "tier1/KeyValues.h" |
|
#include "tier1/utlbuffer.h" |
|
#include "iregistry.h" |
|
#include "vgui/ivgui.h" |
|
#include "vgui_controls/listpanel.h" |
|
#include "vgui_controls/inputdialog.h" |
|
#include "vgui_controls/messagebox.h" |
|
#include "petdoc.h" |
|
#include "pettool.h" |
|
#include "datamodel/dmelement.h" |
|
#include "vgui/keycode.h" |
|
#include "dme_controls/dmecontrols_utils.h" |
|
#include "dme_controls/particlesystempanel.h" |
|
#include "filesystem.h" |
|
#include "vgui_controls/FileOpenDialog.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include <tier0/memdbgon.h> |
|
|
|
|
|
|
|
using namespace vgui; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Sort by particle system definition name |
|
//----------------------------------------------------------------------------- |
|
static int __cdecl ParticleSystemNameSortFunc( vgui::ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 ) |
|
{ |
|
const char *string1 = item1.kv->GetString("name"); |
|
const char *string2 = item2.kv->GetString("name"); |
|
return Q_stricmp( string1, string2 ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Constructor |
|
//----------------------------------------------------------------------------- |
|
CParticleSystemDefinitionBrowser::CParticleSystemDefinitionBrowser( CPetDoc *pDoc, vgui::Panel* pParent, const char *pName ) |
|
: BaseClass( pParent, pName ), m_pDoc( pDoc ) |
|
{ |
|
SetKeyBoardInputEnabled( true ); |
|
SetPaintBackgroundEnabled( true ); |
|
|
|
m_pParticleSystemsDefinitions = new vgui::ListPanel( this, "ParticleSystems" ); |
|
m_pParticleSystemsDefinitions->AddColumnHeader( 0, "name", "Name", 52, ListPanel::COLUMN_RESIZEWITHWINDOW ); |
|
m_pParticleSystemsDefinitions->SetColumnSortable( 0, true ); |
|
m_pParticleSystemsDefinitions->SetEmptyListText( "No Particle System Definitions" ); |
|
m_pParticleSystemsDefinitions->AddActionSignalTarget( this ); |
|
m_pParticleSystemsDefinitions->SetSortFunc( 0, ParticleSystemNameSortFunc ); |
|
m_pParticleSystemsDefinitions->SetSortColumn( 0 ); |
|
|
|
LoadControlSettingsAndUserConfig( "resource/particlesystemdefinitionbrowser.res" ); |
|
|
|
UpdateParticleSystemList(); |
|
} |
|
|
|
CParticleSystemDefinitionBrowser::~CParticleSystemDefinitionBrowser() |
|
{ |
|
SaveUserConfig(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Gets the ith selected particle system |
|
//----------------------------------------------------------------------------- |
|
CDmeParticleSystemDefinition* CParticleSystemDefinitionBrowser::GetSelectedParticleSystem( int i ) |
|
{ |
|
int iSel = m_pParticleSystemsDefinitions->GetSelectedItem( i ); |
|
KeyValues *kv = m_pParticleSystemsDefinitions->GetItem( iSel ); |
|
return GetElementKeyValue< CDmeParticleSystemDefinition >( kv, "particleSystem" ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Deletes the marked objects. |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::DeleteParticleSystems() |
|
{ |
|
int iSel = m_pParticleSystemsDefinitions->GetSelectedItem( 0 ); |
|
int nRow = m_pParticleSystemsDefinitions->GetItemCurrentRow( iSel ) - 1; |
|
{ |
|
// This is undoable |
|
CAppUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Delete Particle Systems", "Delete Particle Systems" ); |
|
|
|
// |
|
// Build a list of objects to delete. |
|
// |
|
CUtlVector< CDmeParticleSystemDefinition* > itemsToDelete; |
|
int nCount = m_pParticleSystemsDefinitions->GetSelectedItemsCount(); |
|
for (int i = 0; i < nCount; i++) |
|
{ |
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( i ); |
|
if ( pParticleSystem ) |
|
{ |
|
itemsToDelete.AddToTail( pParticleSystem ); |
|
} |
|
} |
|
|
|
nCount = itemsToDelete.Count(); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
m_pDoc->DeleteParticleSystemDefinition( itemsToDelete[i] ); |
|
} |
|
} |
|
|
|
// Update the list box selection. |
|
if ( m_pParticleSystemsDefinitions->GetItemCount() > 0 ) |
|
{ |
|
if ( nRow < 0 ) |
|
{ |
|
nRow = 0; |
|
} |
|
else if ( nRow >= m_pParticleSystemsDefinitions->GetItemCount() ) |
|
{ |
|
nRow = m_pParticleSystemsDefinitions->GetItemCount() - 1; |
|
} |
|
|
|
iSel = m_pParticleSystemsDefinitions->GetItemIDFromRow( nRow ); |
|
m_pParticleSystemsDefinitions->SetSingleSelectedItem( iSel ); |
|
} |
|
else |
|
{ |
|
m_pParticleSystemsDefinitions->ClearSelectedItems(); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::LoadKVSection( CDmeParticleSystemDefinition *pNew, KeyValues *pOverridesKv, ParticleFunctionType_t eType ) |
|
{ |
|
// Operator KV |
|
KeyValues *pOperator = pOverridesKv->FindKey( GetParticleFunctionTypeName(eType), NULL ); |
|
if ( !pOperator ) |
|
return; |
|
|
|
// Function |
|
FOR_EACH_TRUE_SUBKEY( pOperator, pFunctionBlock ) |
|
{ |
|
int iFunction = pNew->FindFunction( eType, pFunctionBlock->GetName() ); |
|
if ( iFunction >= 0 ) |
|
{ |
|
CDmeParticleFunction *pDmeFunction = pNew->GetParticleFunction( eType, iFunction ); |
|
// Elements |
|
FOR_EACH_SUBKEY( pFunctionBlock, pAttributeItem ) |
|
{ |
|
CDmAttribute *pAttribute = pDmeFunction->GetAttribute( pAttributeItem->GetName() ); |
|
if ( !pAttribute ) |
|
{ |
|
Warning( "Unable to Find Attribute [%s] in Function [%s] in Operator [%s] for Definition [%s]\n", pAttributeItem->GetName(), pFunctionBlock->GetName(), GetParticleFunctionTypeName(eType), pNew->GetName() ); |
|
} |
|
else |
|
{ |
|
pAttribute->SetValueFromString( pAttributeItem->GetString() ); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
Warning( "Function [%s] not found under Operator [%s] for Definition [%s]\n", pFunctionBlock->GetName(), GetParticleFunctionTypeName(eType), pNew->GetName() ); |
|
} |
|
} |
|
|
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Given a KV, create, add and return an effect |
|
//----------------------------------------------------------------------------- |
|
CDmeParticleSystemDefinition* CParticleSystemDefinitionBrowser::CreateParticleFromKV( KeyValues *pKeyValue ) |
|
{ |
|
CDmeParticleSystemDefinition* pBaseParticleDef = NULL; |
|
|
|
// Get the Base Particle Effect Def |
|
const char* pBaseParticleName = pKeyValue->GetString( "base_effect", "" ); |
|
for ( int i = 0; i < m_pParticleSystemsDefinitions->GetItemCount(); ++i ) |
|
{ |
|
KeyValues *kv = m_pParticleSystemsDefinitions->GetItem( i ); |
|
if ( !V_strcmp( kv->GetString( "name", "" ), pBaseParticleName ) ) |
|
{ |
|
// |
|
pBaseParticleDef = GetElementKeyValue< CDmeParticleSystemDefinition >( kv, "particleSystem" ); |
|
break; |
|
} |
|
} |
|
|
|
// Base Particle could not be found, end; |
|
if ( !pBaseParticleDef ) |
|
{ |
|
Warning( "Unable to to find base particle system [%s]", pBaseParticleName ); |
|
return NULL; |
|
} |
|
|
|
// Create a Copy of the Base Effect |
|
const char *pszNewParticleName = pKeyValue->GetName(); |
|
//CAppUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Copy Particle System", "Copy Particle System" ); |
|
CDmeParticleSystemDefinition *pNew = CastElement<CDmeParticleSystemDefinition>( pBaseParticleDef->Copy() ); |
|
pNew->SetName( pszNewParticleName ); |
|
|
|
// Overrides |
|
// |
|
//"properties" |
|
KeyValues *pProperties = pKeyValue->FindKey( "Properties", NULL ); |
|
if ( pProperties ) |
|
{ |
|
FOR_EACH_SUBKEY( pProperties, pProperty ) |
|
{ |
|
CDmAttribute *pAttribute = pNew->GetAttribute( pProperty->GetName() ); |
|
if ( !pAttribute ) |
|
{ |
|
Warning( "Unable to Find Attribute [%s] in Function [%s]\n", pProperty->GetName(), "Properties" ); |
|
} |
|
else |
|
{ |
|
pAttribute->SetValueFromString( pProperty->GetString() ); |
|
} |
|
} |
|
} |
|
|
|
LoadKVSection( pNew, pKeyValue, FUNCTION_RENDERER ); |
|
LoadKVSection( pNew, pKeyValue, FUNCTION_OPERATOR ); |
|
LoadKVSection( pNew, pKeyValue, FUNCTION_INITIALIZER ); |
|
LoadKVSection( pNew, pKeyValue, FUNCTION_EMITTER ); |
|
LoadKVSection( pNew, pKeyValue, FUNCTION_FORCEGENERATOR ); |
|
LoadKVSection( pNew, pKeyValue, FUNCTION_CONSTRAINT ); |
|
|
|
// Remove copied children |
|
int iChildrenCount = pNew->GetParticleFunctionCount( FUNCTION_CHILDREN ); |
|
for ( int i = iChildrenCount - 1; i >= 0; i-- ) |
|
{ |
|
pNew->RemoveFunction( FUNCTION_CHILDREN, i ); |
|
} |
|
|
|
// Search Children |
|
KeyValues *pChildren = pKeyValue->FindKey( "Children", NULL ); |
|
if ( pChildren ) |
|
{ |
|
FOR_EACH_TRUE_SUBKEY( pChildren, pChild ) |
|
{ |
|
// each Child is its own effect so we need to add it and return it |
|
CDmeParticleSystemDefinition* pChildEffect = CreateParticleFromKV( pChild ); |
|
if ( pChildEffect ) |
|
{ |
|
pNew->AddChild( pChildEffect ); |
|
} |
|
} |
|
} |
|
|
|
m_pDoc->ReplaceParticleSystemDefinition( pNew ); |
|
m_pDoc->UpdateAllParticleSystems(); |
|
return pNew; |
|
} |
|
//----------------------------------------------------------------------------- |
|
// Create from KV |
|
void CParticleSystemDefinitionBrowser::CreateParticleSystemsFromKV( const char *pFileName ) |
|
{ |
|
// |
|
//const char * pFileName = "particles\\_weapon_prefab_override_kv.txt"; |
|
|
|
CUtlBuffer bufRawData; |
|
bool bReadFileOK = g_pFullFileSystem->ReadFile( pFileName, "MOD", bufRawData ); |
|
if ( !bReadFileOK ) |
|
{ |
|
Warning( "Unable to Open KV file [%s]\n", pFileName ); |
|
return; |
|
} |
|
|
|
// Wrap it with a text buffer reader |
|
CUtlBuffer bufText( bufRawData.Base(), bufRawData.TellPut(), CUtlBuffer::READ_ONLY | CUtlBuffer::TEXT_BUFFER ); |
|
|
|
KeyValues *pBaseKeyValue = NULL; |
|
pBaseKeyValue = new KeyValues( "CCreateParticlesFromKV" ); |
|
|
|
if ( !pBaseKeyValue->LoadFromBuffer( NULL, bufText ) ) |
|
{ |
|
Warning( "Unable to Read KV file [%s]\n", pFileName ); |
|
pBaseKeyValue->deleteThis(); |
|
return; |
|
} |
|
|
|
FOR_EACH_TRUE_SUBKEY( pBaseKeyValue, pKVOver ) |
|
{ |
|
CreateParticleFromKV( pKVOver ); |
|
} |
|
|
|
} |
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::OnKeyCodeTyped( vgui::KeyCode code ) |
|
{ |
|
if ( code == KEY_DELETE ) |
|
{ |
|
DeleteParticleSystems(); |
|
} |
|
else |
|
{ |
|
BaseClass::OnKeyCodeTyped( code ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::OnFileSelected(const char *fullpath) |
|
{ |
|
CreateParticleSystemsFromKV( fullpath ); |
|
} |
|
//----------------------------------------------------------------------------- |
|
// Called when the selection changes |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::UpdateParticleSystemSelection() |
|
{ |
|
if ( m_pParticleSystemsDefinitions->GetSelectedItemsCount() == 1 ) |
|
{ |
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( 0 ); |
|
g_pPetTool->SetCurrentParticleSystem( pParticleSystem, false ); |
|
} |
|
else |
|
{ |
|
g_pPetTool->SetCurrentParticleSystem( NULL, false ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Item selection/deselection |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::OnItemSelected( void ) |
|
{ |
|
UpdateParticleSystemSelection(); |
|
} |
|
|
|
void CParticleSystemDefinitionBrowser::OnItemDeselected( void ) |
|
{ |
|
UpdateParticleSystemSelection(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Select a particular node |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::SelectParticleSystem( CDmeParticleSystemDefinition *pFind ) |
|
{ |
|
m_pParticleSystemsDefinitions->ClearSelectedItems(); |
|
for ( int nItemID = m_pParticleSystemsDefinitions->FirstItem(); nItemID != m_pParticleSystemsDefinitions->InvalidItemID(); nItemID = m_pParticleSystemsDefinitions->NextItem( nItemID ) ) |
|
{ |
|
KeyValues *kv = m_pParticleSystemsDefinitions->GetItem( nItemID ); |
|
CDmeParticleSystemDefinition *pParticleSystem = GetElementKeyValue<CDmeParticleSystemDefinition>( kv, "particleSystem" ); |
|
if ( pParticleSystem == pFind ) |
|
{ |
|
m_pParticleSystemsDefinitions->AddSelectedItem( nItemID ); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Called when buttons are clicked |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::OnInputCompleted( KeyValues *pKeyValues ) |
|
{ |
|
const char *pText = pKeyValues->GetString( "text", NULL ); |
|
if ( m_pDoc->IsParticleSystemDefined( pText ) ) |
|
{ |
|
char pBuf[1024]; |
|
Q_snprintf( pBuf, sizeof(pBuf), "Particle System \"%s\" already exists!\n", pText ); |
|
vgui::MessageBox *pMessageBox = new vgui::MessageBox( "Duplicate Particle System Name!\n", pBuf, g_pPetTool->GetRootPanel() ); |
|
pMessageBox->DoModal( ); |
|
return; |
|
} |
|
|
|
if ( pKeyValues->FindKey( "create" ) ) |
|
{ |
|
CDmeParticleSystemDefinition *pParticleSystem = m_pDoc->AddNewParticleSystemDefinition( pText ); |
|
g_pPetTool->SetCurrentParticleSystem( pParticleSystem ); |
|
} |
|
else if ( pKeyValues->FindKey( "copy" ) ) |
|
{ |
|
int nCount = m_pParticleSystemsDefinitions->GetSelectedItemsCount(); |
|
if ( nCount ) |
|
{ |
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( 0 ); |
|
CAppUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Copy Particle System", |
|
"Copy Particle System" ); |
|
CDmeParticleSystemDefinition * pNew = |
|
CastElement<CDmeParticleSystemDefinition>( pParticleSystem->Copy( ) ); |
|
pNew->SetName( pText ); |
|
m_pDoc->AddNewParticleSystemDefinition( pNew, guard ); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Copy to clipboard |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::CopyToClipboard( ) |
|
{ |
|
int nCount = m_pParticleSystemsDefinitions->GetSelectedItemsCount(); |
|
|
|
CUtlVector< KeyValues * > list; |
|
CUtlRBTree< CDmeParticleSystemDefinition* > defs( 0, 0, DefLessFunc( CDmeParticleSystemDefinition* ) ); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( i ); |
|
|
|
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER ); |
|
if ( g_pDataModel->Serialize( buf, "keyvalues2", "pcf", pParticleSystem->GetHandle() ) ) |
|
{ |
|
KeyValues *pData = new KeyValues( "Clipboard" ); |
|
pData->SetString( "pcf", (char*)buf.Base() ); |
|
list.AddToTail( pData ); |
|
} |
|
} |
|
|
|
if ( list.Count() ) |
|
{ |
|
g_pDataModel->SetClipboardData( list ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Paste from clipboard |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::ReplaceDef_r( CUndoScopeGuard& guard, CDmeParticleSystemDefinition *pDef ) |
|
{ |
|
if ( !pDef ) |
|
return; |
|
|
|
m_pDoc->ReplaceParticleSystemDefinition( pDef ); |
|
int nChildCount = pDef->GetParticleFunctionCount( FUNCTION_CHILDREN ); |
|
for ( int i = 0; i < nChildCount; ++i ) |
|
{ |
|
CDmeParticleChild *pChildFunction = static_cast< CDmeParticleChild* >( pDef->GetParticleFunction( FUNCTION_CHILDREN, i ) ); |
|
CDmeParticleSystemDefinition* pChild = pChildFunction->m_Child; |
|
ReplaceDef_r( guard, pChild ); |
|
} |
|
} |
|
|
|
void CParticleSystemDefinitionBrowser::PasteFromClipboard( ) |
|
{ |
|
// This is undoable |
|
CAppUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Paste From Clipboard", "Paste From Clipboard" ); |
|
|
|
bool bRefreshAll = false; |
|
CUtlVector< KeyValues * > list; |
|
g_pDataModel->GetClipboardData( list ); |
|
int nItems = list.Count(); |
|
for ( int i = 0; i < nItems; ++i ) |
|
{ |
|
const char *pData = list[i]->GetString( "pcf" ); |
|
if ( !pData ) |
|
continue; |
|
|
|
int nLen = Q_strlen( pData ); |
|
CUtlBuffer buf( pData, nLen, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY ); |
|
|
|
DmElementHandle_t hRoot; |
|
if ( !g_pDataModel->Unserialize( buf, "keyvalues2", "pcf", NULL, "paste", CR_FORCE_COPY, hRoot ) ) |
|
continue; |
|
|
|
CDmeParticleSystemDefinition *pDef = GetElement<CDmeParticleSystemDefinition>( hRoot ); |
|
if ( !pDef ) |
|
continue; |
|
|
|
ReplaceDef_r( guard, pDef ); |
|
bRefreshAll = true; |
|
} |
|
|
|
guard.Release(); |
|
|
|
if ( bRefreshAll ) |
|
{ |
|
m_pDoc->UpdateAllParticleSystems(); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Called when buttons are clicked |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::OnCommand( const char *pCommand ) |
|
{ |
|
if ( !Q_stricmp( pCommand, "create" ) ) |
|
{ |
|
vgui::InputDialog *pInputDialog = new vgui::InputDialog( g_pPetTool->GetRootPanel(), "Enter Particle System Name", "Name:", "" ); |
|
pInputDialog->SetSmallCaption( true ); |
|
pInputDialog->SetMultiline( false ); |
|
pInputDialog->AddActionSignalTarget( this ); |
|
pInputDialog->DoModal( new KeyValues("create") ); |
|
return; |
|
} |
|
if ( !Q_stricmp( pCommand, "copy" ) ) |
|
{ |
|
vgui::InputDialog *pInputDialog = new vgui::InputDialog( g_pPetTool->GetRootPanel(), "Enter Particle System Name", "Name:", "" ); |
|
pInputDialog->SetSmallCaption( true ); |
|
pInputDialog->SetMultiline( false ); |
|
pInputDialog->AddActionSignalTarget( this ); |
|
pInputDialog->DoModal( new KeyValues("copy") ); |
|
return; |
|
} |
|
if ( !Q_stricmp( pCommand, "Create From KeyValue" ) ) |
|
{ |
|
vgui::FileOpenDialog *pDialog = new vgui::FileOpenDialog( g_pPetTool->GetRootPanel(), "Select KV File", vgui::FOD_OPEN ); |
|
pDialog->SetTitle( "Choose KeyValue File", true ); |
|
pDialog->AddFilter( "*.txt", "KeyValue File (*.txt)", true ); |
|
pDialog->AddActionSignalTarget( this ); |
|
|
|
char szParticlesDir[MAX_PATH]; |
|
pDialog->SetStartDirectory( g_pFullFileSystem->RelativePathToFullPath( "particles", "MOD", szParticlesDir, sizeof(szParticlesDir) ) ); |
|
pDialog->DoModal( new KeyValues( "Create From KeyValue" ) ); |
|
|
|
return; |
|
} |
|
|
|
if ( !Q_stricmp( pCommand, "delete" ) ) |
|
{ |
|
DeleteParticleSystems(); |
|
return; |
|
} |
|
|
|
if ( !Q_stricmp( pCommand, "Save" ) ) |
|
{ |
|
g_pPetTool->Save(); |
|
return; |
|
} |
|
|
|
if ( !Q_stricmp( pCommand, "SaveAndTest" ) ) |
|
{ |
|
g_pPetTool->SaveAndTest(); |
|
return; |
|
} |
|
|
|
BaseClass::OnCommand( pCommand ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
void CParticleSystemDefinitionBrowser::UpdateParticleSystemList(void) |
|
{ |
|
const CDmrParticleSystemList particleSystemList = m_pDoc->GetParticleSystemDefinitionList(); |
|
if ( !particleSystemList.IsValid() ) |
|
return; |
|
|
|
// Maintain selection if possible |
|
CUtlVector< CUtlString > selectedItems; |
|
int nCount = m_pParticleSystemsDefinitions->GetSelectedItemsCount(); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( i ); |
|
if ( pParticleSystem ) |
|
{ |
|
selectedItems.AddToTail( pParticleSystem->GetName() ); |
|
} |
|
} |
|
|
|
m_pParticleSystemsDefinitions->RemoveAll(); |
|
int nSelectedItemCount = selectedItems.Count(); |
|
nCount = particleSystemList.Count(); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
CDmeParticleSystemDefinition *pParticleSystem = particleSystemList[i]; |
|
if ( !pParticleSystem ) |
|
continue; |
|
|
|
const char *pName = pParticleSystem->GetName(); |
|
if ( !pName || !pName[0] ) |
|
{ |
|
pName = "<no name>"; |
|
} |
|
|
|
KeyValues *kv = new KeyValues( "node" ); |
|
kv->SetString( "name", pName ); |
|
SetElementKeyValue( kv, "particleSystem", pParticleSystem ); |
|
|
|
int nItemID = m_pParticleSystemsDefinitions->AddItem( kv, 0, false, false ); |
|
|
|
for ( int j = 0; j < nSelectedItemCount; ++j ) |
|
{ |
|
if ( Q_stricmp( selectedItems[j], pName ) ) |
|
continue; |
|
|
|
m_pParticleSystemsDefinitions->AddSelectedItem( nItemID ); |
|
selectedItems.FastRemove(j); |
|
--nSelectedItemCount; |
|
break; |
|
} |
|
} |
|
m_pParticleSystemsDefinitions->SortList(); |
|
} |
|
|
|
|