//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: Dialog used to edit properties of a particle system definition // //===========================================================================// #include "dme_controls/ParticleSystemPropertiesPanel.h" #include "tier1/KeyValues.h" #include "tier1/utlbuffer.h" #include "vgui/IVGui.h" #include "vgui_controls/button.h" #include "vgui_controls/listpanel.h" #include "vgui_controls/splitter.h" #include "vgui_controls/messagebox.h" #include "vgui_controls/combobox.h" #include "datamodel/dmelement.h" #include "movieobjects/dmeparticlesystemdefinition.h" #include "dme_controls/elementpropertiestree.h" #include "matsys_controls/picker.h" #include "dme_controls/dmecontrols_utils.h" #include "dme_controls/particlesystempanel.h" #include "dme_controls/dmepanel.h" // memdbgon must be the last include file in a .cpp file!!! #include using namespace vgui; //----------------------------------------------------------------------------- // // Purpose: Picker for particle functions // //----------------------------------------------------------------------------- class CParticleFunctionPickerFrame : public vgui::Frame { DECLARE_CLASS_SIMPLE( CParticleFunctionPickerFrame, vgui::Frame ); public: CParticleFunctionPickerFrame( vgui::Panel *pParent, const char *pTitle ); ~CParticleFunctionPickerFrame(); // Sets the current scene + animation list void DoModal( CDmeParticleSystemDefinition *pParticleSystem, ParticleFunctionType_t type, KeyValues *pContextKeyValues ); // Inherited from Frame virtual void OnCommand( const char *pCommand ); private: // Refreshes the list of particle functions void RefreshParticleFunctions( CDmeParticleSystemDefinition *pDefinition, ParticleFunctionType_t type ); void CleanUpMessage(); vgui::ListPanel *m_pFunctionList; vgui::Button *m_pOpenButton; vgui::Button *m_pCancelButton; KeyValues *m_pContextKeyValues; }; static int __cdecl ParticleFunctionNameSortFunc( vgui::ListPanel *pPanel, const vgui::ListPanelItem &item1, const vgui::ListPanelItem &item2 ) { const char *string1 = item1.kv->GetString( "name" ); const char *string2 = item2.kv->GetString( "name" ); return Q_stricmp( string1, string2 ); } CParticleFunctionPickerFrame::CParticleFunctionPickerFrame( vgui::Panel *pParent, const char *pTitle ) : BaseClass( pParent, "ParticleFunctionPickerFrame" ) { SetDeleteSelfOnClose( true ); m_pContextKeyValues = NULL; m_pFunctionList = new vgui::ListPanel( this, "ParticleFunctionList" ); m_pFunctionList->AddColumnHeader( 0, "name", "Particle Function Name", 52, 0 ); m_pFunctionList->SetSelectIndividualCells( false ); m_pFunctionList->SetMultiselectEnabled( false ); m_pFunctionList->SetEmptyListText( "No particle functions" ); m_pFunctionList->AddActionSignalTarget( this ); m_pFunctionList->SetSortFunc( 0, ParticleFunctionNameSortFunc ); m_pFunctionList->SetSortColumn( 0 ); m_pOpenButton = new vgui::Button( this, "OkButton", "#MessageBox_OK", this, "Ok" ); m_pCancelButton = new vgui::Button( this, "CancelButton", "#MessageBox_Cancel", this, "Cancel" ); SetBlockDragChaining( true ); LoadControlSettingsAndUserConfig( "resource/particlefunctionpicker.res" ); SetTitle( pTitle, false ); } CParticleFunctionPickerFrame::~CParticleFunctionPickerFrame() { CleanUpMessage(); } //----------------------------------------------------------------------------- // Refreshes the list of raw controls //----------------------------------------------------------------------------- void CParticleFunctionPickerFrame::RefreshParticleFunctions( CDmeParticleSystemDefinition *pParticleSystem, ParticleFunctionType_t type ) { m_pFunctionList->RemoveAll(); if ( !pParticleSystem ) return; CUtlVector< IParticleOperatorDefinition *> &list = g_pParticleSystemMgr->GetAvailableParticleOperatorList( type ); int nCount = list.Count(); // Build a list of used operator IDs bool pUsedIDs[OPERATOR_ID_COUNT]; memset( pUsedIDs, 0, sizeof(pUsedIDs) ); int nFunctionCount = pParticleSystem->GetParticleFunctionCount( type ); for ( int i = 0; i < nFunctionCount; ++i ) { const char *pFunctionName = pParticleSystem->GetParticleFunction( type, i )->GetName(); for ( int j = 0; j < nCount; ++j ) { if ( Q_stricmp( pFunctionName, list[j]->GetName() ) ) continue; if ( list[j]->GetId() >= 0 ) { pUsedIDs[ list[j]->GetId() ] = true; } break; } } for ( int i = 0; i < nCount; ++i ) { const char *pFunctionName = list[i]->GetName(); // Look to see if this is in a special operator group if ( list[i]->GetId() >= 0 ) { // Don't display ones that are already in the particle system if ( pUsedIDs[ list[i]->GetId() ] ) continue; } if ( list[i]->GetId() == OPERATOR_SINGLETON ) { // Don't display ones that are already in the particle system if ( pParticleSystem->FindFunction( type, pFunctionName ) >= 0 ) continue; } // Don't display obsolete operators if ( list[i]->IsObsolete() ) continue; KeyValues *kv = new KeyValues( "node", "name", pFunctionName ); m_pFunctionList->AddItem( kv, 0, false, false ); } m_pFunctionList->SortList(); } //----------------------------------------------------------------------------- // Deletes the message //----------------------------------------------------------------------------- void CParticleFunctionPickerFrame::CleanUpMessage() { if ( m_pContextKeyValues ) { m_pContextKeyValues->deleteThis(); m_pContextKeyValues = NULL; } } //----------------------------------------------------------------------------- // Sets the current scene + animation list //----------------------------------------------------------------------------- void CParticleFunctionPickerFrame::DoModal( CDmeParticleSystemDefinition *pParticleSystem, ParticleFunctionType_t type, KeyValues *pContextKeyValues ) { CleanUpMessage(); RefreshParticleFunctions( pParticleSystem, type ); m_pContextKeyValues = pContextKeyValues; BaseClass::DoModal(); } //----------------------------------------------------------------------------- // On command //----------------------------------------------------------------------------- void CParticleFunctionPickerFrame::OnCommand( const char *pCommand ) { if ( !Q_stricmp( pCommand, "Ok" ) ) { int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount(); if ( nSelectedItemCount == 0 ) return; Assert( nSelectedItemCount == 1 ); int nItemID = m_pFunctionList->GetSelectedItem( 0 ); KeyValues *pKeyValues = m_pFunctionList->GetItem( nItemID ); KeyValues *pActionKeys = new KeyValues( "ParticleFunctionPicked" ); pActionKeys->SetString( "name", pKeyValues->GetString( "name" ) ); if ( m_pContextKeyValues ) { pActionKeys->AddSubKey( m_pContextKeyValues ); // This prevents them from being deleted later m_pContextKeyValues = NULL; } PostActionSignal( pActionKeys ); CloseModal(); return; } if ( !Q_stricmp( pCommand, "Cancel" ) ) { CloseModal(); return; } BaseClass::OnCommand( pCommand ); } //----------------------------------------------------------------------------- // // Purpose: Picker for child particle systems // //----------------------------------------------------------------------------- class CParticleChildrenPickerFrame : public vgui::Frame { DECLARE_CLASS_SIMPLE( CParticleChildrenPickerFrame, vgui::Frame ); public: CParticleChildrenPickerFrame( vgui::Panel *pParent, const char *pTitle, IParticleSystemPropertiesPanelQuery *pQuery ); ~CParticleChildrenPickerFrame(); // Sets the current scene + animation list void DoModal( CDmeParticleSystemDefinition *pParticleSystem, KeyValues *pContextKeyValues ); // Inherited from Frame virtual void OnCommand( const char *pCommand ); private: // Refreshes the list of children particle systems void RefreshChildrenList( CDmeParticleSystemDefinition *pDefinition ); void CleanUpMessage(); IParticleSystemPropertiesPanelQuery *m_pQuery; vgui::ListPanel *m_pChildrenList; vgui::Button *m_pOpenButton; vgui::Button *m_pCancelButton; KeyValues *m_pContextKeyValues; }; static int __cdecl ParticleChildrenNameSortFunc( vgui::ListPanel *pPanel, const vgui::ListPanelItem &item1, const vgui::ListPanelItem &item2 ) { const char *string1 = item1.kv->GetString( "name" ); const char *string2 = item2.kv->GetString( "name" ); return Q_stricmp( string1, string2 ); } CParticleChildrenPickerFrame::CParticleChildrenPickerFrame( vgui::Panel *pParent, const char *pTitle, IParticleSystemPropertiesPanelQuery *pQuery ) : BaseClass( pParent, "ParticleChildrenPickerFrame" ), m_pQuery( pQuery ) { SetDeleteSelfOnClose( true ); m_pContextKeyValues = NULL; m_pChildrenList = new vgui::ListPanel( this, "ParticleChildrenList" ); m_pChildrenList->AddColumnHeader( 0, "name", "Particle System Name", 52, 0 ); m_pChildrenList->SetSelectIndividualCells( false ); m_pChildrenList->SetMultiselectEnabled( false ); m_pChildrenList->SetEmptyListText( "No particle systems" ); m_pChildrenList->AddActionSignalTarget( this ); m_pChildrenList->SetSortFunc( 0, ParticleChildrenNameSortFunc ); m_pChildrenList->SetSortColumn( 0 ); m_pOpenButton = new vgui::Button( this, "OkButton", "#MessageBox_OK", this, "Ok" ); m_pCancelButton = new vgui::Button( this, "CancelButton", "#MessageBox_Cancel", this, "Cancel" ); SetBlockDragChaining( true ); LoadControlSettingsAndUserConfig( "resource/particlechildrenpicker.res" ); SetTitle( pTitle, false ); } CParticleChildrenPickerFrame::~CParticleChildrenPickerFrame() { CleanUpMessage(); } //----------------------------------------------------------------------------- // Refreshes the list of raw controls //----------------------------------------------------------------------------- void CParticleChildrenPickerFrame::RefreshChildrenList( CDmeParticleSystemDefinition *pCurrentParticleSystem ) { m_pChildrenList->RemoveAll(); CUtlVector< CDmeParticleSystemDefinition* > definitions; if ( m_pQuery ) { m_pQuery->GetKnownParticleDefinitions( definitions ); } int nCount = definitions.Count(); if ( nCount == 0 ) return; for ( int i = 0; i < nCount; ++i ) { CDmeParticleSystemDefinition *pParticleSystem = definitions[i]; if ( pParticleSystem == pCurrentParticleSystem ) continue; const char *pName = pParticleSystem->GetName(); if ( !pName || !pName[0] ) { pName = ""; } KeyValues *kv = new KeyValues( "node" ); kv->SetString( "name", pName ); SetElementKeyValue( kv, "particleSystem", pParticleSystem ); m_pChildrenList->AddItem( kv, 0, false, false ); } m_pChildrenList->SortList(); } //----------------------------------------------------------------------------- // Deletes the message //----------------------------------------------------------------------------- void CParticleChildrenPickerFrame::CleanUpMessage() { if ( m_pContextKeyValues ) { m_pContextKeyValues->deleteThis(); m_pContextKeyValues = NULL; } } //----------------------------------------------------------------------------- // Sets the current scene + animation list //----------------------------------------------------------------------------- void CParticleChildrenPickerFrame::DoModal( CDmeParticleSystemDefinition *pParticleSystem, KeyValues *pContextKeyValues ) { CleanUpMessage(); RefreshChildrenList( pParticleSystem ); m_pContextKeyValues = pContextKeyValues; BaseClass::DoModal(); } //----------------------------------------------------------------------------- // On command //----------------------------------------------------------------------------- void CParticleChildrenPickerFrame::OnCommand( const char *pCommand ) { if ( !Q_stricmp( pCommand, "Ok" ) ) { int nSelectedItemCount = m_pChildrenList->GetSelectedItemsCount(); if ( nSelectedItemCount == 0 ) return; Assert( nSelectedItemCount == 1 ); int nItemID = m_pChildrenList->GetSelectedItem( 0 ); KeyValues *pKeyValues = m_pChildrenList->GetItem( nItemID ); CDmeParticleSystemDefinition *pParticleSystem = GetElementKeyValue( pKeyValues, "particleSystem" ); KeyValues *pActionKeys = new KeyValues( "ParticleChildPicked" ); SetElementKeyValue( pActionKeys, "particleSystem", pParticleSystem ); if ( m_pContextKeyValues ) { pActionKeys->AddSubKey( m_pContextKeyValues ); // This prevents them from being deleted later m_pContextKeyValues = NULL; } PostActionSignal( pActionKeys ); CloseModal(); return; } if ( !Q_stricmp( pCommand, "Cancel" ) ) { CloseModal(); return; } BaseClass::OnCommand( pCommand ); } //----------------------------------------------------------------------------- // Browser of various particle functions //----------------------------------------------------------------------------- class CParticleFunctionBrowser : public vgui::EditablePanel { DECLARE_CLASS_SIMPLE( CParticleFunctionBrowser, vgui::EditablePanel ); public: // constructor, destructor CParticleFunctionBrowser( vgui::Panel *pParent, const char *pName, ParticleFunctionType_t type, IParticleSystemPropertiesPanelQuery *pQuery ); virtual ~CParticleFunctionBrowser(); // Inherited from Panel virtual void OnKeyCodeTyped( vgui::KeyCode code ); void SetParticleFunctionProperties( CDmeElementPanel *pPanel ); void SetParticleSystem( CDmeParticleSystemDefinition *pOp ); void RefreshParticleFunctionList(); void SelectDefaultFunction(); // Called when a list panel's selection changes void RefreshParticleFunctionProperties( ); private: MESSAGE_FUNC_PARAMS( OnOpenContextMenu, "OpenContextMenu", kv ); MESSAGE_FUNC_PARAMS( OnItemSelected, "ItemSelected", kv ); MESSAGE_FUNC_PARAMS( OnItemDeselected, "ItemDeselected", kv ); MESSAGE_FUNC( OnAdd, "Add" ); MESSAGE_FUNC( OnRemove, "Remove" ); MESSAGE_FUNC( OnRename, "Rename" ); MESSAGE_FUNC( OnMoveUp, "MoveUp" ); MESSAGE_FUNC( OnMoveDown, "MoveDown" ); MESSAGE_FUNC_PARAMS( OnInputCompleted, "InputCompleted", kv ); MESSAGE_FUNC_PARAMS( OnParticleFunctionPicked, "ParticleFunctionPicked", kv ); MESSAGE_FUNC_PARAMS( OnParticleChildPicked, "ParticleChildPicked", kv ); // Cleans up the context menu void CleanupContextMenu(); // Returns the selected particle function CDmeParticleFunction* GetSelectedFunction( ); // Returns the selected particle function CDmeParticleFunction* GetSelectedFunction( int nIndex ); // Select a particular particle function void SelectParticleFunction( CDmeParticleFunction *pFind ); IParticleSystemPropertiesPanelQuery *m_pQuery; CDmeHandle< CDmeParticleSystemDefinition > m_hParticleSystem; vgui::ListPanel *m_pFunctionList; ParticleFunctionType_t m_FuncType; vgui::DHANDLE< vgui::Menu > m_hContextMenu; CDmeElementPanel *m_pParticleFunctionProperties; }; //----------------------------------------------------------------------------- // Sort functions for list panel //----------------------------------------------------------------------------- static int __cdecl ParticleFunctionSortFunc( vgui::ListPanel *pPanel, const vgui::ListPanelItem &item1, const vgui::ListPanelItem &item2 ) { int i1 = item1.kv->GetInt( "index" ); int i2 = item2.kv->GetInt( "index" ); return i1 - i2; } //----------------------------------------------------------------------------- // constructor, destructor //----------------------------------------------------------------------------- CParticleFunctionBrowser::CParticleFunctionBrowser( vgui::Panel *pParent, const char *pName, ParticleFunctionType_t type, IParticleSystemPropertiesPanelQuery *pQuery ) : BaseClass( pParent, pName ), m_pQuery( pQuery ) { SetKeyBoardInputEnabled( true ); m_FuncType = type; m_pFunctionList = new vgui::ListPanel( this, "FunctionList" ); if ( m_FuncType != FUNCTION_CHILDREN ) { m_pFunctionList->AddColumnHeader( 0, "name", "Function Name", 150, 0 ); m_pFunctionList->AddColumnHeader( 1, "type", "Function Type", 150, 0 ); m_pFunctionList->SetEmptyListText( "No particle functions" ); } else { m_pFunctionList->AddColumnHeader( 0, "name", "Label", 150, 0 ); m_pFunctionList->AddColumnHeader( 1, "type", "Child Name", 150, 0 ); m_pFunctionList->SetEmptyListText( "No children" ); } m_pFunctionList->SetSelectIndividualCells( false ); m_pFunctionList->SetMultiselectEnabled( true ); m_pFunctionList->AddActionSignalTarget( this ); m_pFunctionList->SetSortFunc( 0, ParticleFunctionSortFunc ); m_pFunctionList->SetSortColumn( 0 ); m_pFunctionList->AddActionSignalTarget( this ); LoadControlSettings( "resource/particlefunctionbrowser.res" ); } CParticleFunctionBrowser::~CParticleFunctionBrowser() { CleanupContextMenu(); SaveUserConfig(); } //----------------------------------------------------------------------------- // Cleans up the context menu //----------------------------------------------------------------------------- void CParticleFunctionBrowser::CleanupContextMenu() { if ( m_hContextMenu.Get() ) { m_hContextMenu->MarkForDeletion(); m_hContextMenu = NULL; } } //----------------------------------------------------------------------------- // Selects a particular function by default //----------------------------------------------------------------------------- void CParticleFunctionBrowser::SelectDefaultFunction() { if ( m_pFunctionList->GetSelectedItemsCount() == 0 && m_pFunctionList->GetItemCount() > 0 ) { int nItemID = m_pFunctionList->GetItemIDFromRow( 0 ); m_pFunctionList->SetSingleSelectedItem( nItemID ); } } //----------------------------------------------------------------------------- // Sets the particle system properties panel //----------------------------------------------------------------------------- void CParticleFunctionBrowser::SetParticleFunctionProperties( CDmeElementPanel *pPanel ) { m_pParticleFunctionProperties = pPanel; } //----------------------------------------------------------------------------- // Sets/gets the particle system //----------------------------------------------------------------------------- void CParticleFunctionBrowser::SetParticleSystem( CDmeParticleSystemDefinition *pParticleSystem ) { if ( pParticleSystem != m_hParticleSystem.Get() ) { m_hParticleSystem = pParticleSystem; RefreshParticleFunctionList(); SelectDefaultFunction(); } } //----------------------------------------------------------------------------- // Builds the particle function list for the particle system //----------------------------------------------------------------------------- void CParticleFunctionBrowser::RefreshParticleFunctionList() { if ( !m_hParticleSystem.Get() ) return; // Maintain selection if possible CUtlVector< CDmeParticleFunction* > selectedItems; int nCount = m_pFunctionList->GetSelectedItemsCount(); for ( int i = 0; i < nCount; ++i ) { selectedItems.AddToTail( GetSelectedFunction( i ) ); } m_pFunctionList->RemoveAll(); int nSelectedCount = selectedItems.Count(); nCount = m_hParticleSystem->GetParticleFunctionCount( m_FuncType ); for ( int i = 0; i < nCount; ++i ) { CDmeParticleFunction *pFunction = m_hParticleSystem->GetParticleFunction( m_FuncType, i ); KeyValues *kv = new KeyValues( "node", "name", pFunction->GetName() ); kv->SetString( "type", pFunction->GetFunctionType() ); kv->SetInt( "index", i ); SetElementKeyValue( kv, "particleFunction", pFunction ); int nItemID = m_pFunctionList->AddItem( kv, 0, false, false ); for ( int j = 0; j < nSelectedCount; ++j ) { if ( selectedItems[j] == pFunction ) { m_pFunctionList->AddSelectedItem( nItemID ); selectedItems.FastRemove( j ); --nSelectedCount; break; } } } m_pFunctionList->SortList(); } //----------------------------------------------------------------------------- // Returns the selected particle function //----------------------------------------------------------------------------- CDmeParticleFunction* CParticleFunctionBrowser::GetSelectedFunction( int nIndex ) { if ( !m_hParticleSystem.Get() ) return NULL; int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount(); if ( nSelectedItemCount <= nIndex ) return NULL; int nItemID = m_pFunctionList->GetSelectedItem( nIndex ); KeyValues *pKeyValues = m_pFunctionList->GetItem( nItemID ); return GetElementKeyValue( pKeyValues, "particleFunction" ); } //----------------------------------------------------------------------------- // Returns the selected particle function //----------------------------------------------------------------------------- CDmeParticleFunction* CParticleFunctionBrowser::GetSelectedFunction( ) { if ( !m_hParticleSystem.Get() ) return NULL; int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount(); if ( nSelectedItemCount != 1 ) return NULL; int nItemID = m_pFunctionList->GetSelectedItem( 0 ); KeyValues *pKeyValues = m_pFunctionList->GetItem( nItemID ); return GetElementKeyValue( pKeyValues, "particleFunction" ); } void CParticleFunctionBrowser::OnMoveUp( ) { CDmeParticleFunction* pFunction = GetSelectedFunction( ); if ( !pFunction ) return; { CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Move Function Up", "Move Function Up" ); m_hParticleSystem->MoveFunctionUp( m_FuncType, pFunction ); } PostActionSignal( new KeyValues( "ParticleSystemModified" ) ); } void CParticleFunctionBrowser::OnMoveDown( ) { CDmeParticleFunction* pFunction = GetSelectedFunction( ); if ( !pFunction ) return; { CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Move Function Down", "Move Function Down" ); m_hParticleSystem->MoveFunctionDown( m_FuncType, pFunction ); } PostActionSignal( new KeyValues( "ParticleSystemModified" ) ); } //----------------------------------------------------------------------------- // Select a particular particle function //----------------------------------------------------------------------------- void CParticleFunctionBrowser::SelectParticleFunction( CDmeParticleFunction *pFind ) { m_pFunctionList->ClearSelectedItems(); for ( int nItemID = m_pFunctionList->FirstItem(); nItemID != m_pFunctionList->InvalidItemID(); nItemID = m_pFunctionList->NextItem( nItemID ) ) { KeyValues *kv = m_pFunctionList->GetItem( nItemID ); CDmeParticleFunction *pFunction = GetElementKeyValue( kv, "particleFunction" ); if ( pFunction == pFind ) { m_pFunctionList->AddSelectedItem( nItemID ); break; } } } //----------------------------------------------------------------------------- // Add/remove functions //----------------------------------------------------------------------------- void CParticleFunctionBrowser::OnParticleChildPicked( KeyValues *pKeyValues ) { CDmeParticleSystemDefinition *pParticleSystem = GetElementKeyValue( pKeyValues, "particleSystem" ); if ( !pParticleSystem || ( m_FuncType != FUNCTION_CHILDREN ) ) return; CDmeParticleFunction *pFunction; { CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Add Particle System Child", "Add Particle System Child" ); pFunction = m_hParticleSystem->AddChild( pParticleSystem ); } PostActionSignal( new KeyValues( "ParticleSystemModified" ) ); SelectParticleFunction( pFunction ); } void CParticleFunctionBrowser::OnParticleFunctionPicked( KeyValues *pKeyValues ) { if ( m_FuncType == FUNCTION_CHILDREN ) return; const char *pParticleFuncName = pKeyValues->GetString( "name" ); CDmeParticleFunction *pFunction; { CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Add Particle Function", "Add Particle Function" ); pFunction = m_hParticleSystem->AddOperator( m_FuncType, pParticleFuncName ); } PostActionSignal( new KeyValues( "ParticleSystemModified" ) ); SelectParticleFunction( pFunction ); } void CParticleFunctionBrowser::OnAdd( ) { if ( m_FuncType != FUNCTION_CHILDREN ) { CParticleFunctionPickerFrame *pPicker = new CParticleFunctionPickerFrame( this, "Select Particle Function" ); pPicker->DoModal( m_hParticleSystem, m_FuncType, NULL ); } else { CParticleChildrenPickerFrame *pPicker = new CParticleChildrenPickerFrame( this, "Select Child Particle Systems", m_pQuery ); pPicker->DoModal( m_hParticleSystem, NULL ); } } void CParticleFunctionBrowser::OnRemove( ) { int iSel = m_pFunctionList->GetSelectedItem( 0 ); int nRow = m_pFunctionList->GetItemCurrentRow( iSel ) - 1; { CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Remove Particle Function", "Remove Particle Function" ); // // Build a list of objects to delete. // CUtlVector< CDmeParticleFunction* > itemsToDelete; int nCount = m_pFunctionList->GetSelectedItemsCount(); for (int i = 0; i < nCount; i++) { CDmeParticleFunction *pParticleFunction = GetSelectedFunction( i ); if ( pParticleFunction ) { itemsToDelete.AddToTail( pParticleFunction ); } } nCount = itemsToDelete.Count(); for ( int i = 0; i < nCount; ++i ) { m_hParticleSystem->RemoveFunction( m_FuncType, itemsToDelete[i] ); } } PostActionSignal( new KeyValues( "ParticleSystemModified" ) ); // Update the list box selection. if ( m_pFunctionList->GetItemCount() > 0 ) { if ( nRow < 0 ) { nRow = 0; } else if ( nRow >= m_pFunctionList->GetItemCount() ) { nRow = m_pFunctionList->GetItemCount() - 1; } iSel = m_pFunctionList->GetItemIDFromRow( nRow ); m_pFunctionList->SetSingleSelectedItem( iSel ); } else { m_pFunctionList->ClearSelectedItems(); } } //----------------------------------------------------------------------------- // Rename a particle function //----------------------------------------------------------------------------- void CParticleFunctionBrowser::OnInputCompleted( KeyValues *pKeyValues ) { const char *pName = pKeyValues->GetString( "text" ); CDmeParticleFunction *pFunction = GetSelectedFunction(); { CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Rename Particle Function", "Rename Particle Function" ); pFunction->SetName( pName ); } PostActionSignal( new KeyValues( "ParticleSystemModified" ) ); } //----------------------------------------------------------------------------- // Rename a particle function //----------------------------------------------------------------------------- void CParticleFunctionBrowser::OnRename() { int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount(); if ( nSelectedItemCount != 1 ) return; vgui::InputDialog *pInput = new vgui::InputDialog( this, "Rename Particle Function", "Enter new name of particle function" ); pInput->SetMultiline( false ); pInput->DoModal( ); } //----------------------------------------------------------------------------- // Called when a list panel's selection changes //----------------------------------------------------------------------------- void CParticleFunctionBrowser::RefreshParticleFunctionProperties( ) { if ( IsVisible() ) { CDmeParticleFunction *pFunction = GetSelectedFunction(); if ( pFunction ) { m_pParticleFunctionProperties->SetTypeDictionary( pFunction->GetEditorTypeDictionary() ); } m_pParticleFunctionProperties->SetDmeElement( pFunction ); // Notify the outside world so we can get helpers to render correctly in the preview KeyValues *pMessage = new KeyValues( "ParticleFunctionSelChanged" ); SetElementKeyValue( pMessage, "function", pFunction ); PostActionSignal( pMessage ); } } //----------------------------------------------------------------------------- // Called when a list panel's selection changes //----------------------------------------------------------------------------- void CParticleFunctionBrowser::OnItemSelected( KeyValues *kv ) { Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL ); if ( pPanel == m_pFunctionList ) { RefreshParticleFunctionProperties(); return; } } //----------------------------------------------------------------------------- // Called when a list panel's selection changes //----------------------------------------------------------------------------- void CParticleFunctionBrowser::OnItemDeselected( KeyValues *kv ) { Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL ); if ( pPanel == m_pFunctionList ) { RefreshParticleFunctionProperties(); return; } } //----------------------------------------------------------------------------- // Called to open a context-sensitive menu for a particular menu item //----------------------------------------------------------------------------- void CParticleFunctionBrowser::OnOpenContextMenu( KeyValues *kv ) { CleanupContextMenu(); if ( !m_hParticleSystem.Get() ) return; Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL ); if ( pPanel != m_pFunctionList ) return; int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount(); m_hContextMenu = new vgui::Menu( this, "ActionMenu" ); m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_Add", new KeyValues( "Add" ), this ); if ( nSelectedItemCount >= 1 ) { m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_Remove", new KeyValues( "Remove" ), this ); } if ( nSelectedItemCount == 1 ) { m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_Rename", new KeyValues( "Rename" ), this ); m_hContextMenu->AddSeparator(); m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_MoveUp", new KeyValues( "MoveUp" ), this ); m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_MoveDown", new KeyValues( "MoveDown" ), this ); } vgui::Menu::PlaceContextMenu( this, m_hContextMenu.Get() ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CParticleFunctionBrowser::OnKeyCodeTyped( vgui::KeyCode code ) { if ( code == KEY_DELETE ) { OnRemove(); } else { BaseClass::OnKeyCodeTyped( code ); } } //----------------------------------------------------------------------------- // Strings //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Constructor //----------------------------------------------------------------------------- CParticleSystemPropertiesPanel::CParticleSystemPropertiesPanel( IParticleSystemPropertiesPanelQuery *pQuery, vgui::Panel* pParent ) : BaseClass( pParent, "ParticleSystemPropertiesPanel" ), m_pQuery( pQuery ) { SetKeyBoardInputEnabled( true ); m_pSplitter = new vgui::Splitter( this, "Splitter", vgui::SPLITTER_MODE_VERTICAL, 1 ); vgui::Panel *pSplitterLeftSide = m_pSplitter->GetChild( 0 ); vgui::Panel *pSplitterRightSide = m_pSplitter->GetChild( 1 ); m_pFunctionBrowserArea = new vgui::EditablePanel( pSplitterLeftSide, "FunctionBrowserArea" ); m_pFunctionTypeCombo = new vgui::ComboBox( pSplitterLeftSide, "FunctionTypeCombo", PARTICLE_FUNCTION_COUNT+1, false ); m_pFunctionTypeCombo->AddItem( "Properties", new KeyValues( "choice", "index", -1 ) ); m_pFunctionTypeCombo->AddActionSignalTarget( this ); m_pParticleFunctionProperties = new CDmeElementPanel( pSplitterRightSide, "FunctionProperties" ); m_pParticleFunctionProperties->SetAutoResize( vgui::Panel::PIN_TOPLEFT, vgui::Panel::AUTORESIZE_DOWNANDRIGHT, 6, 6, -6, -6 ); m_pParticleFunctionProperties->AddActionSignalTarget( this ); for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i ) { const char *pTypeName = GetParticleFunctionTypeName( (ParticleFunctionType_t)i ); m_pFunctionTypeCombo->AddItem( pTypeName, new KeyValues( "choice", "index", i ) ); m_pParticleFunctionBrowser[i] = new CParticleFunctionBrowser( m_pFunctionBrowserArea, "FunctionBrowser", (ParticleFunctionType_t)i, m_pQuery ); m_pParticleFunctionBrowser[i]->SetParticleFunctionProperties( m_pParticleFunctionProperties ); m_pParticleFunctionBrowser[i]->AddActionSignalTarget( this ); } m_pFunctionTypeCombo->ActivateItemByRow( 0 ); LoadControlSettings( "resource/particlesystempropertiespanel.res" ); } //----------------------------------------------------------------------------- // Sets the particle system to look at //----------------------------------------------------------------------------- void CParticleSystemPropertiesPanel::SetParticleSystem( CDmeParticleSystemDefinition *pParticleSystem ) { m_hParticleSystem = pParticleSystem; for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i ) { m_pParticleFunctionBrowser[i]->SetParticleSystem( pParticleSystem ); } KeyValues *pKeyValues = m_pFunctionTypeCombo->GetActiveItemUserData(); int nPage = pKeyValues->GetInt( "index" ); if ( nPage < 0 ) { if ( m_hParticleSystem.Get() ) { m_pParticleFunctionProperties->SetTypeDictionary( m_hParticleSystem->GetEditorTypeDictionary() ); } m_pParticleFunctionProperties->SetDmeElement( m_hParticleSystem ); } } //----------------------------------------------------------------------------- // Called when something changes in the dmeelement panel //----------------------------------------------------------------------------- void CParticleSystemPropertiesPanel::OnDmeElementChanged( KeyValues *pKeyValues ) { int nNotifyFlags = pKeyValues->GetInt( "notifyFlags" ); OnParticleSystemModified(); if ( nNotifyFlags & ( NOTIFY_CHANGE_TOPOLOGICAL | NOTIFY_CHANGE_ATTRIBUTE_ARRAY_SIZE ) ) { for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i ) { m_pParticleFunctionBrowser[i]->RefreshParticleFunctionList(); } } PostActionSignal( new KeyValues( "ParticleSystemModified" ) ); } void CParticleSystemPropertiesPanel::OnParticleSystemModifiedInternal() { OnParticleSystemModified(); Refresh( false ); PostActionSignal( new KeyValues( "ParticleSystemModified" ) ); } void CParticleSystemPropertiesPanel::OnParticleFunctionSelChanged( KeyValues *pParams ) { // Notify the outside world so we can get helpers to render correctly in the preview CDmeParticleFunction *pFunction = GetElementKeyValue( pParams, "function" ); KeyValues *pMessage = new KeyValues( "ParticleFunctionSelChanged" ); SetElementKeyValue( pMessage, "function", pFunction ); PostActionSignal( pMessage ); } //----------------------------------------------------------------------------- // Refreshes display //----------------------------------------------------------------------------- void CParticleSystemPropertiesPanel::Refresh( bool bValuesOnly ) { for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i ) { m_pParticleFunctionBrowser[i]->RefreshParticleFunctionList(); } m_pParticleFunctionProperties->Refresh( bValuesOnly ? CElementPropertiesTreeInternal::REFRESH_VALUES_ONLY : CElementPropertiesTreeInternal::REFRESH_TREE_VIEW ); } //----------------------------------------------------------------------------- // Purpose: Called when a page is shown //----------------------------------------------------------------------------- void CParticleSystemPropertiesPanel::OnTextChanged( ) { for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i ) { m_pParticleFunctionBrowser[i]->SetVisible( false ); } KeyValues *pKeyValues = m_pFunctionTypeCombo->GetActiveItemUserData(); int nPage = pKeyValues->GetInt( "index" ); if ( nPage < 0 ) { if ( m_hParticleSystem.Get() ) { m_pParticleFunctionProperties->SetTypeDictionary( m_hParticleSystem->GetEditorTypeDictionary() ); } m_pParticleFunctionProperties->SetDmeElement( m_hParticleSystem ); return; } m_pParticleFunctionBrowser[nPage]->SetVisible( true ); m_pParticleFunctionBrowser[nPage]->SelectDefaultFunction(); m_pParticleFunctionBrowser[nPage]->RefreshParticleFunctionProperties(); } //----------------------------------------------------------------------------- // A little panel used as a DmePanel for particle systems //----------------------------------------------------------------------------- class CParticleSystemDmePanel : public vgui::EditablePanel { DECLARE_CLASS_SIMPLE( CParticleSystemDmePanel, vgui::EditablePanel ); public: // constructor, destructor CParticleSystemDmePanel( vgui::Panel *pParent, const char *pName ); virtual ~CParticleSystemDmePanel(); // Set the material to draw void SetDmeElement( CDmeParticleSystemDefinition *pDef ); private: MESSAGE_FUNC_INT( OnElementChangedExternally, "ElementChangedExternally", valuesOnly ); MESSAGE_FUNC( OnParticleSystemModified, "ParticleSystemModified" ); MESSAGE_FUNC_PARAMS( OnParticleFunctionSelChanged, "ParticleFunctionSelChanged", params ); vgui::Splitter *m_Splitter; CParticleSystemPropertiesPanel *m_pProperties; CParticleSystemPreviewPanel *m_pPreview; }; //----------------------------------------------------------------------------- // Dme panel connection //----------------------------------------------------------------------------- IMPLEMENT_DMEPANEL_FACTORY( CParticleSystemDmePanel, DmeParticleSystemDefinition, "DmeParticleSystemDefinitionEditor", "Particle System Editor", true ); //----------------------------------------------------------------------------- // constructor, destructor //----------------------------------------------------------------------------- CParticleSystemDmePanel::CParticleSystemDmePanel( vgui::Panel *pParent, const char *pName ) : BaseClass( pParent, pName ) { m_Splitter = new vgui::Splitter( this, "Splitter", SPLITTER_MODE_HORIZONTAL, 1 ); vgui::Panel *pSplitterTopSide = m_Splitter->GetChild( 0 ); vgui::Panel *pSplitterBottomSide = m_Splitter->GetChild( 1 ); m_Splitter->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_DOWNANDRIGHT, 0, 0, 0, 0 ); m_pProperties = new CParticleSystemPropertiesPanel( NULL, pSplitterBottomSide ); m_pProperties->AddActionSignalTarget( this ); m_pProperties->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_DOWNANDRIGHT, 0, 0, 0, 0 ); m_pPreview = new CParticleSystemPreviewPanel( pSplitterTopSide, "Preview" ); m_pPreview->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_DOWNANDRIGHT, 0, 0, 0, 0 ); } CParticleSystemDmePanel::~CParticleSystemDmePanel() { } //----------------------------------------------------------------------------- // Layout //----------------------------------------------------------------------------- void CParticleSystemDmePanel::SetDmeElement( CDmeParticleSystemDefinition *pDef ) { m_pProperties->SetParticleSystem( pDef ); m_pPreview->SetParticleSystem( pDef ); } //----------------------------------------------------------------------------- // Particle system modified externally to the editor //----------------------------------------------------------------------------- void CParticleSystemDmePanel::OnElementChangedExternally( int valuesOnly ) { m_pProperties->Refresh( valuesOnly != 0 ); } //----------------------------------------------------------------------------- // Called when the selected particle function changes //----------------------------------------------------------------------------- void CParticleSystemDmePanel::OnParticleFunctionSelChanged( KeyValues *pParams ) { CDmeParticleFunction *pFunction = GetElementKeyValue( pParams, "function" ); m_pPreview->SetParticleFunction( pFunction ); } //----------------------------------------------------------------------------- // Communicate to the owning DmePanel //----------------------------------------------------------------------------- void CParticleSystemDmePanel::OnParticleSystemModified() { PostActionSignal( new KeyValues( "DmeElementChanged" ) ); }