d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
143 Commits
25 Branches
6 Tags
221 MiB
Tree: 58873c35c7
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '58873c35c7'
${ noResults }
source-engine/tools/actbusy/actbusytool.cpp

1224 lines
35 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Act busy tool; main UI smarts class
//
//=============================================================================
#include "toolutils/basetoolsystem.h"
#include "toolutils/recentfilelist.h"
#include "toolutils/toolmenubar.h"
#include "toolutils/toolswitchmenubutton.h"
#include "toolutils/toolfilemenubutton.h"
#include "toolutils/tooleditmenubutton.h"
#include "toolutils/toolmenubutton.h"
#include "vgui_controls/Menu.h"
#include "tier1/KeyValues.h"
#include "toolutils/enginetools_int.h"
#include "toolframework/ienginetool.h"
#include "vgui/IInput.h"
#include "vgui/KeyCode.h"
#include "vgui_controls/FileOpenDialog.h"
#include "filesystem.h"
#include "actbusydoc.h"
#include "vgui/ilocalize.h"
#include "dme_controls/elementpropertiestree.h"
#include "actbusytool.h"
#include "movieobjects/dmeeditortypedictionary.h"
#include "dme_controls/attributestringchoicepanel.h"
#include "matsys_controls/mdlsequencepicker.h"
#include "istudiorender.h"
#include "materialsystem/imaterialsystem.h"
#include "VGuiMatSurface/IMatSystemSurface.h"
#include "toolutils/toolwindowfactory.h"
#include "toolutils/basepropertiescontainer.h"
#include "toolutils/savewindowpositions.h"
#include "tier2/fileutils.h"
#include "tier3/tier3.h"
#include "vgui/ivgui.h"
using namespace vgui;
//-----------------------------------------------------------------------------
// Singleton interfaces
//-----------------------------------------------------------------------------
CDmeEditorTypeDictionary *g_pEditorTypeDict;
//-----------------------------------------------------------------------------
// Methods needed by scenedatabase. They have to live here instead of toolutils
// because this is a DLL but toolutils is only a static library
//-----------------------------------------------------------------------------
const char *GetVGuiControlsModuleName()
{
return "ActBusyTool";
}
//-----------------------------------------------------------------------------
// Connect, disconnect
//-----------------------------------------------------------------------------
bool ConnectTools( CreateInterfaceFn factory )
{
return (g_pMDLCache != NULL) && (studiorender != NULL) && (materials != NULL) && (g_pMatSystemSurface != NULL);
}
void DisconnectTools( )
{
}
//-----------------------------------------------------------------------------
// Implementation of the act busy tool
//-----------------------------------------------------------------------------
class CActBusyTool : public CBaseToolSystem, public IFileMenuCallbacks, public IActBusyDocCallback
{
DECLARE_CLASS_SIMPLE( CActBusyTool, CBaseToolSystem );
public:
CActBusyTool();
// Inherited from IToolSystem
virtual const char *GetToolName() { return "ActBusy Script Editor"; }
virtual const char *GetBindingsContextFile() { return "cfg/ActBusy.kb"; }
virtual bool Init();
virtual void Shutdown();
virtual bool CanQuit();
// Inherited from IFileMenuCallbacks
virtual int GetFileMenuItemsEnabled( );
virtual void AddRecentFilesToMenu( vgui::Menu *menu );
virtual bool GetPerforceFileName( char *pFileName, int nMaxLen );
virtual vgui::Panel* GetRootPanel() { return this; }
// Inherited from IActBusyDocCallback
virtual void OnDocChanged( const char *pReason, int nNotifySource, int nNotifyFlags );
// Inherited from CBaseToolSystem
virtual vgui::HScheme GetToolScheme();
virtual vgui::Menu *CreateActionMenu( vgui::Panel *pParent );
virtual void OnCommand( const char *cmd );
virtual const char *GetRegistryName() { return "ActBusy"; }
virtual vgui::MenuBar *CreateMenuBar( CBaseToolSystem *pParent );
virtual void OnToolActivate();
virtual void OnToolDeactivate();
virtual CActBusyDoc *GetDocument();
virtual CBasePropertiesContainer *GetProperties();
virtual CMDLSequencePicker *GetSequencePicker();
virtual void SetupFileOpenDialog( vgui::FileOpenDialog *pDialog, bool bOpenFile, const char *pFileFormat, KeyValues *pContextKeyValues );
virtual bool OnReadFileFromDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues );
virtual bool OnWriteFileToDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues );
virtual void OnFileOperationCompleted( const char *pFileType, bool bWroteFile, vgui::FileOpenStateMachine::CompletionState_t state, KeyValues *pContextKeyValues );
public:
// Commands related to the file menu
MESSAGE_FUNC( OnNew, "OnNew" );
MESSAGE_FUNC( OnOpen, "OnOpen" );
MESSAGE_FUNC( OnSave, "OnSave" );
MESSAGE_FUNC( OnSaveAs, "OnSaveAs" );
MESSAGE_FUNC( OnClose, "OnClose" );
MESSAGE_FUNC( OnCloseNoSave, "OnCloseNoSave" );
MESSAGE_FUNC( OnMarkNotDirty, "OnMarkNotDirty" );
MESSAGE_FUNC( OnExit, "OnExit" );
void PerformNew();
void OpenFileFromHistory( int slot, const char *pCommand );
void OpenSpecificFile( const char *pFileName );
// Commands related to the edit menu
KEYBINDING_FUNC( undo, KEY_Z, vgui::MODIFIER_CONTROL, OnUndo, "#undo_help", 0 );
KEYBINDING_FUNC( redo, KEY_Z, vgui::MODIFIER_CONTROL | vgui::MODIFIER_SHIFT, OnRedo, "#redo_help", 0 );
void OnDescribeUndo();
// Commands related to the actbusy menu
void OnNewActBusy();
void OnDeleteActBusy();
private:
// Flags for HideStandardFields
enum EditorTypeStandardFields_t
{
EDITOR_FIELD_NAME = 0x1,
EDITOR_FIELD_TYPE = 0x2,
EDITOR_FIELD_ID = 0x4,
EDITOR_FIELD_EDITORTYPE = 0x8,
};
void HideStandardFields( CDmeEditorType *pEditorType, int nFieldFlags );
// Creates a new document
void NewDocument( );
// Loads up a new document
bool LoadDocument( const char *pDocName );
// Updates the menu bar based on the current file
void UpdateMenuBar( );
// Shows element properties
void ShowElementProperties( );
// Create custom editors
void InitEditorDict();
void CreateTools( CActBusyDoc *doc );
void InitTools();
void DestroyTools();
void ToggleToolWindow( Panel *tool, const char *toolName );
void ShowToolWindow( Panel *tool, const char *toolName, bool visible );
void OnToggleProperties();
void OnToggleSequencePicker();
void OnDefaultLayout();
void DestroyToolContainers();
virtual const char *GetLogoTextureName();
private:
// All editable data
CActBusyDoc *m_pDoc;
// The menu bar
CToolFileMenuBar *m_pMenuBar;
// Element properties for editing actbusy
vgui::DHANDLE< CBasePropertiesContainer > m_hProperties;
// The sequence picker!
vgui::DHANDLE< CMDLSequencePicker > m_hMDLSequencePicker;
CToolWindowFactory< ToolWindow > m_ToolWindowFactory;
CUtlVector< DmElementHandle_t > m_toolElements;
};
//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
CActBusyTool *g_pActBusyTool = NULL;
void CreateTools()
{
g_pActBusyTool = new CActBusyTool();
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CActBusyTool::CActBusyTool()
{
m_pMenuBar = NULL;
m_pDoc = NULL;
}
//-----------------------------------------------------------------------------
// Init, shutdown
//-----------------------------------------------------------------------------
bool CActBusyTool::Init( )
{
m_pDoc = NULL;
m_RecentFiles.LoadFromRegistry( GetRegistryName() );
// NOTE: This has to happen before BaseClass::Init
g_pVGuiLocalize->AddFile( "resource/toolactbusy_%language%.txt" );
if ( !BaseClass::Init( ) )
return false;
g_pDataModel->SetUndoDepth( 256 );
InitEditorDict();
return true;
}
void CActBusyTool::Shutdown()
{
m_RecentFiles.SaveToRegistry( GetRegistryName() );
{
CDisableUndoScopeGuard guard;
int nElements = m_toolElements.Count();
for ( int i = 0; i < nElements; ++i )
{
g_pDataModel->DestroyElement( m_toolElements[ i ] );
}
}
BaseClass::Shutdown();
}
//-----------------------------------------------------------------------------
// Tool activation/deactivation
//-----------------------------------------------------------------------------
void CActBusyTool::OnToolActivate()
{
BaseClass::OnToolActivate();
}
void CActBusyTool::OnToolDeactivate()
{
BaseClass::OnToolDeactivate();
}
//-----------------------------------------------------------------------------
// Hides standard fields
//-----------------------------------------------------------------------------
void CActBusyTool::HideStandardFields( CDmeEditorType *pEditorType, int nFieldFlags )
{
CDmeEditorAttributeInfo *pInfo;
if ( nFieldFlags & EDITOR_FIELD_NAME )
{
pInfo = CreateElement< CDmeEditorAttributeInfo >( "name info", DMFILEID_INVALID );
pInfo->m_bIsVisible = false;
pEditorType->AddAttributeInfo( "name", pInfo );
m_toolElements.AddToTail( pInfo->GetHandle() );
}
if ( nFieldFlags & EDITOR_FIELD_TYPE )
{
pInfo = CreateElement< CDmeEditorAttributeInfo >( "type info", DMFILEID_INVALID );
pInfo->m_bIsVisible = false;
pEditorType->AddAttributeInfo( "type", pInfo );
m_toolElements.AddToTail( pInfo->GetHandle() );
}
if ( nFieldFlags & EDITOR_FIELD_ID )
{
pInfo = CreateElement< CDmeEditorAttributeInfo >( "id info", DMFILEID_INVALID );
pInfo->m_bIsVisible = false;
pEditorType->AddAttributeInfo( "id", pInfo );
m_toolElements.AddToTail( pInfo->GetHandle() );
}
if ( nFieldFlags & EDITOR_FIELD_EDITORTYPE )
{
pInfo = CreateElement< CDmeEditorAttributeInfo >( "editor type info", DMFILEID_INVALID );
pInfo->m_bIsVisible = false;
pEditorType->AddAttributeInfo( "editorType", pInfo );
m_toolElements.AddToTail( pInfo->GetHandle() );
}
}
//-----------------------------------------------------------------------------
// Create custom editors
//-----------------------------------------------------------------------------
void CActBusyTool::InitEditorDict()
{
CDmeEditorAttributeInfo *pInfo, *pArrayInfo;
// FIXME: This eventually will move to an .fgd-like file.
g_pEditorTypeDict = CreateElement< CDmeEditorTypeDictionary >( "DmeEditorTypeDictionary", DMFILEID_INVALID );
m_toolElements.AddToTail( g_pEditorTypeDict->GetHandle() );
CDmeEditorType *pActBusyList = CreateElement< CDmeEditorType >( "actBusyList", DMFILEID_INVALID );
HideStandardFields( pActBusyList, EDITOR_FIELD_NAME | EDITOR_FIELD_TYPE | EDITOR_FIELD_ID | EDITOR_FIELD_EDITORTYPE );
g_pEditorTypeDict->AddEditorType( pActBusyList );
m_toolElements.AddToTail( pActBusyList->GetHandle() );
pInfo = CreateElement< CDmeEditorAttributeInfo >( "children info", DMFILEID_INVALID );
pActBusyList->AddAttributeInfo( "children", pInfo );
m_toolElements.AddToTail( pInfo->GetHandle() );
pArrayInfo = CreateElement< CDmeEditorAttributeInfo >( "hide text info", DMFILEID_INVALID );
pInfo->SetArrayInfo( pArrayInfo );
pArrayInfo->SetValue( "hideText", true );
m_toolElements.AddToTail( pArrayInfo->GetHandle() );
CDmeEditorType *pActBusyType = CreateElement< CDmeEditorType >( "actBusy", DMFILEID_INVALID );
HideStandardFields( pActBusyType, EDITOR_FIELD_TYPE | EDITOR_FIELD_ID | EDITOR_FIELD_EDITORTYPE );
m_toolElements.AddToTail( pActBusyType->GetHandle() );
// anims only accept activity names
pInfo = CreateElement< CDmeEditorAttributeInfo >( "busy anim info", DMFILEID_INVALID );
pActBusyType->AddAttributeInfo( "busy_anim", pInfo );
pInfo->m_Widget = "sequencepicker";
pInfo->SetValue( "texttype", "activityName" );
m_toolElements.AddToTail( pInfo->GetHandle() );
pInfo = CreateElement< CDmeEditorAttributeInfo >( "entry anim info", DMFILEID_INVALID );
pActBusyType->AddAttributeInfo( "entry_anim", pInfo );
pInfo->m_Widget = "sequencepicker";
pInfo->SetValue( "texttype", "activityName" );
m_toolElements.AddToTail( pInfo->GetHandle() );
pInfo = CreateElement< CDmeEditorAttributeInfo >( "exit anim info", DMFILEID_INVALID );
pActBusyType->AddAttributeInfo( "exit_anim", pInfo );
pInfo->m_Widget = "sequencepicker";
pInfo->SetValue( "texttype", "activityName" );
m_toolElements.AddToTail( pInfo->GetHandle() );
// sequences only accept sequence names
pInfo = CreateElement< CDmeEditorAttributeInfo >( "busy sequence info", DMFILEID_INVALID );
pActBusyType->AddAttributeInfo( "busy_sequence", pInfo );
pInfo->m_Widget = "sequencepicker";
pInfo->SetValue( "texttype", "sequenceName" );
m_toolElements.AddToTail( pInfo->GetHandle() );
pInfo = CreateElement< CDmeEditorAttributeInfo >( "entry sequence info", DMFILEID_INVALID );
pActBusyType->AddAttributeInfo( "entry_sequence", pInfo );
pInfo->m_Widget = "sequencepicker";
pInfo->SetValue( "texttype", "sequenceName" );
m_toolElements.AddToTail( pInfo->GetHandle() );
pInfo = CreateElement< CDmeEditorAttributeInfo >( "exit sequence info", DMFILEID_INVALID );
pActBusyType->AddAttributeInfo( "exit_sequence", pInfo );
pInfo->m_Widget = "sequencepicker";
pInfo->SetValue( "texttype", "sequenceName" );
m_toolElements.AddToTail( pInfo->GetHandle() );
CDmeEditorStringChoicesInfo *pChoicesInfo = CreateElement< CDmeEditorStringChoicesInfo >( "interrupts info", DMFILEID_INVALID );
pActBusyType->AddAttributeInfo( "interrupts", pChoicesInfo );
pChoicesInfo->m_Widget = "stringchoice";
m_toolElements.AddToTail( pChoicesInfo->AddChoice( "BA_INT_NONE", "No Interrupts" )->GetHandle() );
m_toolElements.AddToTail( pChoicesInfo->AddChoice( "BA_INT_DANGER", "Danger" )->GetHandle() );
m_toolElements.AddToTail( pChoicesInfo->AddChoice( "BA_INT_PLAYER", "Player" )->GetHandle() );
m_toolElements.AddToTail( pChoicesInfo->AddChoice( "BA_INT_AMBUSH", "Ambush" )->GetHandle() );
m_toolElements.AddToTail( pChoicesInfo->AddChoice( "BA_INT_COMBAT", "Combat" )->GetHandle() );
m_toolElements.AddToTail( pChoicesInfo->AddChoice( "BA_INT_ZOMBIESLUMP", "Zombie Slump" )->GetHandle() );
m_toolElements.AddToTail( pChoicesInfo->GetHandle() );
g_pEditorTypeDict->AddEditorType( pActBusyType );
}
//-----------------------------------------------------------------------------
//
// The View menu
//
//-----------------------------------------------------------------------------
class CActBusyViewMenuButton : public CToolMenuButton
{
DECLARE_CLASS_SIMPLE( CActBusyViewMenuButton, CToolMenuButton );
public:
CActBusyViewMenuButton( CActBusyTool *parent, const char *panelName, const char *text, vgui::Panel *pActionSignalTarget );
virtual void OnShowMenu(vgui::Menu *menu);
private:
CActBusyTool *m_pTool;
};
CActBusyViewMenuButton::CActBusyViewMenuButton( CActBusyTool *parent, const char *panelName, const char *text, vgui::Panel *pActionSignalTarget )
: BaseClass( parent, panelName, text, pActionSignalTarget )
{
m_pTool = parent;
AddCheckableMenuItem( "properties", "#ActBusyProperties", new KeyValues( "Command", "command", "OnToggleProperties" ), pActionSignalTarget );
AddCheckableMenuItem( "picker", "#ActBusyViewSequencePicker", new KeyValues( "Command", "command", "OnToggleSequencePicker" ), pActionSignalTarget );
AddSeparator();
AddMenuItem( "defaultlayout", "#ActBusyViewDefault", new KeyValues ( "Command", "command", "OnDefaultLayout"), pActionSignalTarget );
SetMenu(m_pMenu);
}
void CActBusyViewMenuButton::OnShowMenu(vgui::Menu *menu)
{
BaseClass::OnShowMenu( menu );
// Update the menu
int id;
CActBusyDoc *pDoc = m_pTool->GetDocument();
if ( pDoc )
{
id = m_Items.Find( "properties" );
m_pMenu->SetItemEnabled( id, true );
Panel *p;
p = m_pTool->GetProperties();
Assert( p );
m_pMenu->SetMenuItemChecked( id, ( p && p->GetParent() ) ? true : false );
id = m_Items.Find( "picker" );
m_pMenu->SetItemEnabled( id, true );
p = m_pTool->GetSequencePicker();
Assert( p );
m_pMenu->SetMenuItemChecked( id, ( p && p->GetParent() ) ? true : false );
}
else
{
id = m_Items.Find( "properties" );
m_pMenu->SetItemEnabled( id, false );
id = m_Items.Find( "picker" );
m_pMenu->SetItemEnabled( id, false );
}
}
//-----------------------------------------------------------------------------
//
// The ActBusy menu
//
//-----------------------------------------------------------------------------
class CActBusyMenuButton : public CToolMenuButton
{
DECLARE_CLASS_SIMPLE( CActBusyMenuButton, CToolMenuButton );
public:
CActBusyMenuButton( CActBusyTool *parent, const char *panelName, const char *text, vgui::Panel *pActionSignalTarget );
virtual void OnShowMenu(vgui::Menu *menu);
private:
CActBusyTool *m_pTool;
};
CActBusyMenuButton::CActBusyMenuButton( CActBusyTool *parent, const char *panelName, const char *text, vgui::Panel *pActionSignalTarget )
: BaseClass( parent, panelName, text, pActionSignalTarget )
{
m_pTool = parent;
AddMenuItem( "NewActBusy", "#ActBusyNewActBusy", new KeyValues( "Command", "command", "OnNewActBusy" ), pActionSignalTarget );
AddMenuItem( "DeleteActBusy", "#ActBusyDeleteActBusy", new KeyValues( "Command", "command", "OnDeleteActBusy" ), pActionSignalTarget );
SetMenu(m_pMenu);
}
void CActBusyMenuButton::OnShowMenu(vgui::Menu *menu)
{
BaseClass::OnShowMenu( menu );
// Update the menu
int id;
CActBusyDoc *pDoc = m_pTool->GetDocument();
if ( pDoc )
{
id = m_Items.Find( "NewActBusy" );
m_pMenu->SetItemEnabled( id, true );
id = m_Items.Find( "DeleteActBusy" );
m_pMenu->SetItemEnabled( id, true );
}
else
{
id = m_Items.Find( "NewActBusy" );
m_pMenu->SetItemEnabled( id, false );
id = m_Items.Find( "DeleteActBusy" );
m_pMenu->SetItemEnabled( id, false );
}
}
//-----------------------------------------------------------------------------
// Initializes the menu bar
//-----------------------------------------------------------------------------
vgui::MenuBar *CActBusyTool::CreateMenuBar( CBaseToolSystem *pParent )
{
m_pMenuBar = new CToolFileMenuBar( pParent, "ActBusyMenuBar" );
// Sets info in the menu bar
char title[ 64 ];
ComputeMenuBarTitle( title, sizeof( title ) );
m_pMenuBar->SetInfo( title );
m_pMenuBar->SetToolName( GetToolName() );
UpdateMenuBar();
// Add menu buttons
CToolMenuButton *pFileButton = CreateToolFileMenuButton( m_pMenuBar, "File", "&File", GetActionTarget(), this );
CToolMenuButton *pEditButton = CreateToolEditMenuButton( this, "Edit", "&Edit", GetActionTarget() );
CActBusyMenuButton *pActBusyButton = new CActBusyMenuButton( this, "ActBusy", "&ActBusy", GetActionTarget() );
CToolMenuButton *pSwitchButton = CreateToolSwitchMenuButton( m_pMenuBar, "Switcher", "&Tools", GetActionTarget() );
CActBusyViewMenuButton *pViewButton = new CActBusyViewMenuButton( this, "View", "&View", GetActionTarget() );
m_pMenuBar->AddButton( pFileButton );
m_pMenuBar->AddButton( pEditButton );
m_pMenuBar->AddButton( pActBusyButton );
m_pMenuBar->AddButton( pViewButton );
m_pMenuBar->AddButton( pSwitchButton );
return m_pMenuBar;
}
//-----------------------------------------------------------------------------
// Updates the menu bar based on the current file
//-----------------------------------------------------------------------------
void CActBusyTool::UpdateMenuBar( )
{
if ( !m_pDoc )
{
m_pMenuBar->SetFileName( "#ActBusyNoFile" );
return;
}
if ( m_pDoc->IsDirty() )
{
char sz[ 512 ];
Q_snprintf( sz, sizeof( sz ), "* %s", m_pDoc->GetFileName() );
m_pMenuBar->SetFileName( sz );
}
else
{
m_pMenuBar->SetFileName( m_pDoc->GetFileName() );
}
}
//-----------------------------------------------------------------------------
// Inherited from IFileMenuCallbacks
//-----------------------------------------------------------------------------
int CActBusyTool::GetFileMenuItemsEnabled( )
{
int nFlags;
if ( !m_pDoc )
{
nFlags = FILE_NEW | FILE_OPEN | FILE_RECENT | FILE_CLEAR_RECENT | FILE_EXIT;
}
else
{
nFlags = FILE_ALL;
}
if ( m_RecentFiles.IsEmpty() )
{
nFlags &= ~(FILE_RECENT | FILE_CLEAR_RECENT);
}
return nFlags;
}
void CActBusyTool::AddRecentFilesToMenu( vgui::Menu *pMenu )
{
m_RecentFiles.AddToMenu( pMenu, GetActionTarget(), "OnRecent" );
}
//-----------------------------------------------------------------------------
// Returns the file name for perforce
//-----------------------------------------------------------------------------
bool CActBusyTool::GetPerforceFileName( char *pFileName, int nMaxLen )
{
if ( !m_pDoc )
return false;
Q_strncpy( pFileName, m_pDoc->GetFileName(), nMaxLen );
return true;
}
//-----------------------------------------------------------------------------
// Derived classes can implement this to get a new scheme to be applied to this tool
//-----------------------------------------------------------------------------
vgui::HScheme CActBusyTool::GetToolScheme()
{
return vgui::scheme()->LoadSchemeFromFile( "Resource/BoxRocket.res", "BoxRocket" );
}
//-----------------------------------------------------------------------------
// Creates the action menu
//-----------------------------------------------------------------------------
vgui::Menu *CActBusyTool::CreateActionMenu( vgui::Panel *pParent )
{
vgui::Menu *pActionMenu = new Menu( pParent, "ActionMenu" );
pActionMenu->AddMenuItem( "#ToolHide", new KeyValues( "Command", "command", "HideActionMenu" ), GetActionTarget() );
return pActionMenu;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
//-----------------------------------------------------------------------------
void CActBusyTool::OnExit()
{
windowposmgr->SavePositions( "cfg/actbusy.txt", "ActBusy" );
// Throw up a "save" dialog?
enginetools->Command( "quit\n" );
}
//-----------------------------------------------------------------------------
// Handle commands from the action menu and other menus
//-----------------------------------------------------------------------------
void CActBusyTool::OnCommand( const char *cmd )
{
if ( !V_stricmp( cmd, "HideActionMenu" ) )
{
if ( GetActionMenu() )
{
GetActionMenu()->SetVisible( false );
}
}
else if ( !V_stricmp( cmd, "OnNewActBusy" ) )
{
OnNewActBusy();
}
else if ( !V_stricmp( cmd, "OnDeleteActBusy" ) )
{
OnDeleteActBusy();
}
else if ( !V_stricmp( cmd, "OnToggleProperties" ) )
{
OnToggleProperties();
}
else if ( !V_stricmp( cmd, "OnToggleSequencePicker" ) )
{
OnToggleSequencePicker();
}
else if ( !V_stricmp( cmd, "OnDefaultLayout" ) )
{
OnDefaultLayout();
}
else if ( !V_stricmp( cmd, "OnUndo" ) )
{
OnUndo();
}
else if ( !V_stricmp( cmd, "OnRedo" ) )
{
OnRedo();
}
else if ( !V_stricmp( cmd, "OnDescribeUndo" ) )
{
OnDescribeUndo();
}
else if ( const char *pSuffix = StringAfterPrefix( cmd, "OnRecent" ) )
{
int idx = Q_atoi( pSuffix );
g_pActBusyTool->OpenFileFromHistory( idx, cmd );
}
else if( const char *pSuffixTool = StringAfterPrefix( cmd, "OnTool" ) )
{
int idx = Q_atoi( pSuffixTool );
enginetools->SwitchToTool( idx );
}
else
{
BaseClass::OnCommand( cmd );
}
}
//-----------------------------------------------------------------------------
// Derived classes can implement this to get notified when files are saved/loaded
//-----------------------------------------------------------------------------
void CActBusyTool::OnFileOperationCompleted( const char *pFileType, bool bWroteFile, vgui::FileOpenStateMachine::CompletionState_t state, KeyValues *pContextKeyValues )
{
if ( bWroteFile )
{
OnMarkNotDirty();
}
if ( !pContextKeyValues )
return;
if ( state != FileOpenStateMachine::SUCCESSFUL )
return;
if ( !Q_stricmp( pContextKeyValues->GetName(), "OnNew" ) )
{
PerformNew();
return;
}
if ( !Q_stricmp( pContextKeyValues->GetName(), "OnClose" ) )
{
OnCloseNoSave();
return;
}
if ( !Q_stricmp( pContextKeyValues->GetName(), "OnQuit" ) )
{
OnCloseNoSave();
vgui::ivgui()->PostMessage( GetVPanel(), new KeyValues( "OnExit" ), 0 );
return;
}
}
//-----------------------------------------------------------------------------
// Called by SaveFile to allow clients to set up the save dialog
//-----------------------------------------------------------------------------
void CActBusyTool::SetupFileOpenDialog( vgui::FileOpenDialog *pDialog, bool bOpenFile, const char *pFileFormat, KeyValues *pContextKeyValues )
{
// Compute starting directory
char pStartingDir[ MAX_PATH ];
GetModSubdirectory( "scripts", pStartingDir, sizeof(pStartingDir) );
if ( bOpenFile )
{
pDialog->SetTitle( "Open ActBusy .TXT File", true );
}
else
{
pDialog->SetTitle( "Save ActBusy .TXT File As", true );
}
pDialog->SetStartDirectoryContext( "actbusy_session", pStartingDir );
pDialog->AddFilter( "*.txt", "ActBusy .TXT (*.txt)", true );
}
//-----------------------------------------------------------------------------
// Called by SaveFile to allow clients to actually write the file out
//-----------------------------------------------------------------------------
bool CActBusyTool::OnReadFileFromDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues )
{
OnCloseNoSave();
return LoadDocument( pFileName );
}
//-----------------------------------------------------------------------------
// Called by SaveFile to allow clients to actually write the file out
//-----------------------------------------------------------------------------
bool CActBusyTool::OnWriteFileToDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues )
{
if ( !m_pDoc )
return true;
m_pDoc->SetFileName( pFileName );
m_pDoc->SaveToFile( );
UpdateMenuBar();
return true;
}
//-----------------------------------------------------------------------------
// Command handlers
//-----------------------------------------------------------------------------
void CActBusyTool::PerformNew()
{
OnCloseNoSave();
NewDocument();
}
void CActBusyTool::OnNew()
{
if ( m_pDoc )
{
if ( m_pDoc->IsDirty() )
{
SaveFile( m_pDoc->GetFileName(), "actbusy", FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY,
new KeyValues( "OnNew" ) );
return;
}
}
PerformNew();
}
void CActBusyTool::OnOpen()
{
int nFlags = 0;
const char *pSaveFileName = NULL;
if ( m_pDoc && m_pDoc->IsDirty() )
{
nFlags = FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY;
pSaveFileName = m_pDoc->GetFileName();
}
OpenFile( "actbusy", pSaveFileName, "actbusy", nFlags );
}
void CActBusyTool::OnSave()
{
if ( m_pDoc )
{
SaveFile( m_pDoc->GetFileName(), "actbusy", FOSM_SHOW_PERFORCE_DIALOGS );
}
}
void CActBusyTool::OnSaveAs()
{
if ( m_pDoc )
{
SaveFile( NULL, "actbusy", FOSM_SHOW_PERFORCE_DIALOGS );
}
}
void CActBusyTool::OnClose()
{
if ( m_pDoc && m_pDoc->IsDirty() )
{
SaveFile( m_pDoc->GetFileName(), "actbusy", FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY,
new KeyValues( "OnClose" ) );
return;
}
OnCloseNoSave();
}
void CActBusyTool::OnCloseNoSave()
{
DestroyTools();
if ( m_pDoc )
{
CAppNotifyScopeGuard( "CActBusyTool::OnCloseNoSave", 0 );
delete m_pDoc;
m_pDoc = NULL;
if ( m_hProperties )
{
m_hProperties->SetObject( NULL );
}
}
UpdateMenuBar( );
}
void CActBusyTool::OnMarkNotDirty()
{
if ( m_pDoc )
{
m_pDoc->SetDirty( false );
}
}
//-----------------------------------------------------------------------------
// Open a specific file
//-----------------------------------------------------------------------------
void CActBusyTool::OpenSpecificFile( const char *pFileName )
{
int nFlags = 0;
const char *pSaveFileName = NULL;
if ( m_pDoc )
{
// File is already open
if ( !Q_stricmp( m_pDoc->GetFileName(), pFileName ) )
return;
if ( m_pDoc->IsDirty() )
{
nFlags = FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY;
pSaveFileName = m_pDoc->GetFileName();
}
else
{
OnCloseNoSave();
}
}
OpenFile( pFileName, "actbusy", pSaveFileName, "actbusy", nFlags );
}
//-----------------------------------------------------------------------------
// Show the save document query dialog
//-----------------------------------------------------------------------------
void CActBusyTool::OpenFileFromHistory( int slot, const char *pCommand )
{
const char *pFileName = m_RecentFiles.GetFile( slot );
if ( pFileName )
{
OpenSpecificFile( pFileName );
}
}
bool CActBusyTool::CanQuit()
{
if ( m_pDoc && m_pDoc->IsDirty() )
{
// Show Save changes Yes/No/Cancel and re-quit if hit yes/no
SaveFile( m_pDoc->GetFileName(), "actbusy", FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY,
new KeyValues( "OnQuit" ) );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Various command handlers related to the Edit menu
//-----------------------------------------------------------------------------
void CActBusyTool::OnUndo()
{
CDisableUndoScopeGuard guard;
g_pDataModel->Undo();
}
void CActBusyTool::OnRedo()
{
CDisableUndoScopeGuard guard;
g_pDataModel->Redo();
}
void CActBusyTool::OnDescribeUndo()
{
CUtlVector< UndoInfo_t > list;
g_pDataModel->GetUndoInfo( list );
Msg( "%i operations in stack\n", list.Count() );
for ( int i = list.Count() - 1; i >= 0; --i )
{
UndoInfo_t& entry = list[ i ];
if ( entry.terminator )
{
Msg( "[ '%s' ] - %i operations\n", entry.undo, entry.numoperations );
}
Msg( " +%s\n", entry.desc );
}
}
//-----------------------------------------------------------------------------
// Commands related to the actbusy menu
//-----------------------------------------------------------------------------
void CActBusyTool::OnNewActBusy()
{
if ( m_pDoc )
{
m_pDoc->CreateActBusy();
}
}
void CActBusyTool::OnDeleteActBusy()
{
}
//-----------------------------------------------------------------------------
// Inherited from IActBusyDocCallback
//-----------------------------------------------------------------------------
void CActBusyTool::OnDocChanged( const char *pReason, int nNotifySource, int nNotifyFlags )
{
UpdateMenuBar();
if ( ( nNotifySource != NOTIFY_SOURCE_PROPERTIES_TREE ) && m_hProperties.Get() )
{
m_hProperties->Refresh();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
// Output : CActBusyDoc
//-----------------------------------------------------------------------------
CActBusyDoc *CActBusyTool::GetDocument()
{
return m_pDoc;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
// Output : virtual CBasePropertiesContainer
//-----------------------------------------------------------------------------
CBasePropertiesContainer *CActBusyTool::GetProperties()
{
return m_hProperties.Get();
}
CMDLSequencePicker *CActBusyTool::GetSequencePicker()
{
return m_hMDLSequencePicker.Get();
}
//-----------------------------------------------------------------------------
// Initializes the tools
//-----------------------------------------------------------------------------
void CActBusyTool::InitTools()
{
ShowElementProperties();
// FIXME: There are no tool windows here; how should this work?
// These panels are saved
windowposmgr->RegisterPanel( "picker", m_hMDLSequencePicker, false );
windowposmgr->RegisterPanel( "properties", m_hProperties, false );
if ( !windowposmgr->LoadPositions( "cfg/actbusy.txt", this, &m_ToolWindowFactory, "ActBusy" ) )
{
OnDefaultLayout();
}
}
//-----------------------------------------------------------------------------
// Loads up a new document
//-----------------------------------------------------------------------------
bool CActBusyTool::LoadDocument( const char *pDocName )
{
Assert( !m_pDoc );
DestroyTools();
m_pDoc = new CActBusyDoc( this );
if ( !m_pDoc->LoadFromFile( pDocName ) )
{
delete m_pDoc;
m_pDoc = NULL;
Warning( "Fatal error loading '%s'\n", pDocName );
return false;
}
// ShowMiniViewport( false );
CreateTools( m_pDoc );
m_RecentFiles.Add( pDocName, "actbusy" );
UpdateMenuBar( );
InitTools();
return true;
}
//-----------------------------------------------------------------------------
// Loads up a new document
//-----------------------------------------------------------------------------
void CActBusyTool::NewDocument( )
{
Assert( !m_pDoc );
m_pDoc = new CActBusyDoc( this );
m_pDoc->CreateNew( );
// ShowMiniViewport( false );
CreateTools( m_pDoc );
UpdateMenuBar( );
InitTools();
}
//-----------------------------------------------------------------------------
// Shows element properties
//-----------------------------------------------------------------------------
void CActBusyTool::ShowElementProperties( )
{
if ( !m_pDoc )
return;
if ( !m_pDoc->GetRootObject() )
return;
// It should already exist
Assert( m_hProperties.Get() );
if ( m_hProperties.Get() )
{
m_hProperties->SetObject( m_pDoc->GetRootObject() );
}
}
void CActBusyTool::DestroyTools()
{
int c = ToolWindow::GetToolWindowCount();
for ( int i = c - 1; i >= 0 ; --i )
{
ToolWindow *kill = ToolWindow::GetToolWindow( i );
delete kill;
}
UnregisterAllToolWindows();
if ( m_hProperties.Get() )
{
windowposmgr->UnregisterPanel( m_hProperties.Get() );
delete m_hProperties.Get();
m_hProperties = NULL;
}
if ( m_hMDLSequencePicker.Get() )
{
windowposmgr->UnregisterPanel( m_hMDLSequencePicker.Get() );
delete m_hMDLSequencePicker.Get();
m_hMDLSequencePicker = NULL;
}
}
void CActBusyTool::CreateTools( CActBusyDoc *doc )
{
if ( !m_hProperties.Get() )
{
m_hProperties = new CBasePropertiesContainer( NULL, m_pDoc, g_pEditorTypeDict );
}
if ( !m_hMDLSequencePicker.Get() )
{
m_hMDLSequencePicker = new CMDLSequencePicker( NULL );
SETUP_PANEL( m_hMDLSequencePicker.Get() );
m_hMDLSequencePicker->Activate();
}
RegisterToolWindow( m_hProperties );
RegisterToolWindow( m_hMDLSequencePicker );
}
void CActBusyTool::ShowToolWindow( Panel *tool, const char *toolName, bool visible )
{
Assert( tool );
if ( tool->GetParent() == NULL && visible )
{
m_ToolWindowFactory.InstanceToolWindow( this, false, tool, toolName, false );
}
else if ( !visible )
{
ToolWindow *tw = dynamic_cast< ToolWindow * >( tool->GetParent()->GetParent() );
Assert( tw );
tw->RemovePage( tool );
}
}
void CActBusyTool::ToggleToolWindow( Panel *tool, const char *toolName )
{
Assert( tool );
if ( tool->GetParent() == NULL )
{
ShowToolWindow( tool, toolName, true );
}
else
{
ShowToolWindow( tool, toolName, false );
}
}
void CActBusyTool::DestroyToolContainers()
{
int c = ToolWindow::GetToolWindowCount();
for ( int i = c - 1; i >= 0 ; --i )
{
ToolWindow *kill = ToolWindow::GetToolWindow( i );
delete kill;
}
}
void CActBusyTool::OnDefaultLayout()
{
int y = m_pMenuBar->GetTall();
int usew, useh;
GetSize( usew, useh );
DestroyToolContainers();
Assert( ToolWindow::GetToolWindowCount() == 0 );
CBasePropertiesContainer *properties = GetProperties();
CMDLSequencePicker *picker = GetSequencePicker();
// Need three containers
ToolWindow *propertyWindow = m_ToolWindowFactory.InstanceToolWindow( GetClientArea(), false, properties, "#ActBusyProperties", false );
ToolWindow *pickerWindow = m_ToolWindowFactory.InstanceToolWindow( GetClientArea(), false, picker, "#ActBusyViewSequencePicker", false );
int halfScreen = usew / 2;
int bottom = useh - y;
propertyWindow->SetBounds( 0, y, halfScreen, bottom );
pickerWindow->SetBounds( halfScreen, y, halfScreen, bottom );
}
void CActBusyTool::OnToggleProperties()
{
ToggleToolWindow( m_hProperties.Get(), "#ActBusyProperties" );
}
void CActBusyTool::OnToggleSequencePicker()
{
ToggleToolWindow( m_hMDLSequencePicker.Get(), "#ActBusyViewSequencePicker" );
}
const char *CActBusyTool::GetLogoTextureName()
{
return "vgui/tools/actbusy/actbusy_logo";
}