|
|
//========= Copyright � 1996-2009, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=====================================================================================//
#include "stdafx.h"
#include "Manifest.h"
#include "CustomMessages.h"
#include "GlobalFunctions.h"
#include "MainFrm.h"
#include "MapDoc.h"
#include "MapSolid.h"
#include "MapWorld.h"
#include "MapInstance.h"
#include "ToolManager.h"
#include "ChunkFile.h"
#include "ManifestDialog.h"
#include "History.h"
#include "HelperFactory.h"
#include "SaveInfo.h"
#include "p4lib/ip4.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
IMPLEMENT_DYNCREATE(CManifest, CMapDoc)
BEGIN_MESSAGE_MAP(CManifest, CMapDoc) //{{AFX_MSG_MAP(CManifest)
ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs) //}}AFX_MSG_MAP
END_MESSAGE_MAP()
IMPLEMENT_MAPCLASS( CManifestInstance )
//-----------------------------------------------------------------------------
// Purpose: default constructor
//-----------------------------------------------------------------------------
CManifestMap::CManifestMap( void ) { m_Map = NULL; m_RelativeMapFileName = ""; m_AbsoluteMapFileName = ""; m_FriendlyName = "unnamed"; m_bTopLevelMap = false; m_bPrimaryMap = false; m_bProtected = false; m_bReadOnly = false; m_bIsVersionControlled = false; m_bCheckedOut = false; m_bDefaultCheckin = false; m_bVisible = true; m_Entity = NULL; m_InternalID = 0; }
//-----------------------------------------------------------------------------
// Purpose: returns true if the manifest map is editable
//-----------------------------------------------------------------------------
bool CManifestMap::IsEditable( void ) { return ( m_bProtected == false && m_bReadOnly == false && m_bPrimaryMap ); }
//-----------------------------------------------------------------------------
// Purpose: default constructor
//-----------------------------------------------------------------------------
CManifestInstance::CManifestInstance( void ) : CMapEntity() { m_pManifestMap = NULL; }
//-----------------------------------------------------------------------------
// Purpose: default constructor
//-----------------------------------------------------------------------------
CManifestInstance::CManifestInstance( CManifestMap *pManifestMap ) : CMapEntity() { m_pManifestMap = pManifestMap; }
//-----------------------------------------------------------------------------
// Purpose: returns true if the manifest map this instance owns is editable
//-----------------------------------------------------------------------------
bool CManifestInstance::IsEditable( void ) { return m_pManifestMap->IsEditable(); }
//-----------------------------------------------------------------------------
// Purpose: default constructor
//-----------------------------------------------------------------------------
CManifest::CManifest( void ) : CMapDoc() { m_bIsValid = false; m_bRelocateSave = false; m_ManifestDir[ 0 ] = 0; m_pPrimaryMap = NULL; m_ManifestWorld = NULL; m_NextInternalID = 1; m_bManifestChanged = false; m_bManifestUserPrefsChanged = false; m_pSaveUndo = m_pUndo; m_pSaveRedo = m_pRedo; m_bReadOnly = true; m_bIsVersionControlled = false; m_bCheckedOut = false; m_bDefaultCheckin = false; }
//-----------------------------------------------------------------------------
// Purpose: default destructor
//-----------------------------------------------------------------------------
CManifest::~CManifest( void ) { m_Maps.PurgeAndDeleteElements(); }
//-----------------------------------------------------------------------------
// Purpose: this function will parse through the known keys for the manifest map entry
// Input : szKey - the key name
// szValue - the value
// pManifestMap - the manifest map this belongs to
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadKeyInfoCallback( const char *szKey, const char *szValue, CManifest *pDoc ) { if ( !stricmp( szKey, "NextInternalID" ) ) { pDoc->m_NextInternalID = atoi( szValue ); }
return ChunkFile_Ok; }
//-----------------------------------------------------------------------------
// Purpose: this function is responsible for setting up the manifest map about to be read in
// Input : pFile - the chunk file being read
// pDoc - the owning manifest document
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadManifestInfoCallback( CChunkFile *pFile, CManifest *pDoc ) { ChunkFileResult_t eResult = pFile->ReadChunk( ( KeyHandler_t )LoadKeyInfoCallback, pDoc );
return( eResult ); }
//-----------------------------------------------------------------------------
// Purpose: this function will parse through the known keys for the manifest map entry
// Input : szKey - the key name
// szValue - the value
// pManifestMap - the manifest map this belongs to
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadKeyCallback( const char *szKey, const char *szValue, CManifestMap *pManifestMap ) { if ( !stricmp( szKey, "InternalID" ) ) { pManifestMap->m_InternalID = atoi( szValue ); } else if ( !stricmp( szKey, "Name" ) ) { pManifestMap->m_FriendlyName = szValue; } else if ( !stricmp( szKey, "File" ) ) { pManifestMap->m_RelativeMapFileName = szValue; pManifestMap->m_AbsoluteMapFileName += szValue; if ( !pManifestMap->m_Map->LoadVMF( pManifestMap->m_AbsoluteMapFileName, VMF_LOAD_ACTIVATE | VMF_LOAD_IS_SUBMAP ) ) { delete pManifestMap->m_Map; pManifestMap->m_Map = NULL; } pManifestMap->m_bReadOnly = true; } else if ( !stricmp( szKey, "TopLevel" ) ) { pManifestMap->m_bTopLevelMap = ( atoi( szValue ) == 1 ); }
return ChunkFile_Ok; }
//-----------------------------------------------------------------------------
// Purpose: this function is responsible for setting up the manifest map about to be read in
// Input : pFile - the chunk file being read
// pDoc - the owning manifest document
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadManifestVMFCallback( CChunkFile *pFile, CManifest *pDoc ) { char FileName[ MAX_PATH ];
strcpy( FileName, pDoc->m_ManifestDir );
CManifestMap *pManifestMap = pDoc->CreateNewMap( FileName, "", false ); SetActiveMapDoc( pManifestMap->m_Map );
ChunkFileResult_t eResult = pFile->ReadChunk( ( KeyHandler_t )LoadKeyCallback, pManifestMap );
if ( pManifestMap->m_Map ) { pManifestMap->m_Map->SetEditable( false ); } SetActiveMapDoc( pDoc );
return( eResult ); }
//-----------------------------------------------------------------------------
// Purpose: this function will load the VMF chunk
// Input : pFile - the chunk file being read
// pDoc - the owning manifest document
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadManifestMapsCallback( CChunkFile *pFile, CManifest *pDoc ) { CChunkHandlerMap Handlers; Handlers.AddHandler( "VMF", ( ChunkHandler_t )LoadManifestVMFCallback, pDoc ); pFile->PushHandlers(&Handlers);
ChunkFileResult_t eResult = ChunkFile_Ok;
eResult = pFile->ReadChunk();
pFile->PopHandlers();
return( eResult ); }
typedef struct SManifestLoadPrefs { CManifest *pDoc; CManifestMap *pManifestMap; } TManifestLoadPrefs;
//-----------------------------------------------------------------------------
// Purpose: this function will parse through the known keys for the manifest map entry
// Input : szKey - the key name
// szValue - the value
// pManifestMap - the manifest map this belongs to
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadKeyPrefsCallback( const char *szKey, const char *szValue, TManifestLoadPrefs *pManifestLoadPrefs ) { if ( !stricmp( szKey, "InternalID" ) ) { pManifestLoadPrefs->pManifestMap = pManifestLoadPrefs->pDoc->FindMapByID( atoi( szValue ) ); } else if ( !stricmp( szKey, "IsPrimary" ) ) { if ( pManifestLoadPrefs->pManifestMap ) { pManifestLoadPrefs->pManifestMap->m_bPrimaryMap = ( atoi( szValue ) == 1 ); } } else if ( !stricmp( szKey, "IsProtected" ) ) { if ( pManifestLoadPrefs->pManifestMap ) { pManifestLoadPrefs->pManifestMap->m_bProtected = ( atoi( szValue ) == 1 ); } } else if ( !stricmp( szKey, "IsVisible" ) ) { if ( pManifestLoadPrefs->pManifestMap ) { pManifestLoadPrefs->pManifestMap->m_bVisible = ( atoi( szValue ) == 1 ); } }
return ChunkFile_Ok; }
//-----------------------------------------------------------------------------
// Purpose: this function is responsible for setting up the manifest map about to be read in
// Input : pFile - the chunk file being read
// pDoc - the owning manifest document
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadManifestVMFPrefsCallback( CChunkFile *pFile, CManifest *pDoc ) { TManifestLoadPrefs ManifestLoadPrefs; ManifestLoadPrefs.pDoc = pDoc; ManifestLoadPrefs.pManifestMap = NULL;
ChunkFileResult_t eResult = pFile->ReadChunk( ( KeyHandler_t )LoadKeyPrefsCallback, &ManifestLoadPrefs );
return( eResult ); }
//-----------------------------------------------------------------------------
// Purpose: this function will load the VMF chunk
// Input : pFile - the chunk file being read
// pDoc - the owning manifest document
// Output : ChunkFileResult_t - result of the parsing
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadManifestMapsPrefsCallback( CChunkFile *pFile, CManifest *pDoc ) { CChunkHandlerMap Handlers; Handlers.AddHandler( "VMF", ( ChunkHandler_t )LoadManifestVMFPrefsCallback, pDoc ); pFile->PushHandlers(&Handlers);
ChunkFileResult_t eResult = ChunkFile_Ok;
eResult = pFile->ReadChunk();
pFile->PopHandlers();
return( eResult ); }
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
ChunkFileResult_t CManifest::LoadManifestCordoningPrefsCallback( CChunkFile *pFile, CManifest *pDoc ) { CChunkHandlerMap Handlers; Handlers.AddHandler( "cordons", ( ChunkHandler_t )CMapDoc::LoadCordonsCallback, pDoc ); pFile->PushHandlers(&Handlers);
ChunkFileResult_t eResult = ChunkFile_Ok;
eResult = pFile->ReadChunk();
pFile->PopHandlers();
return( eResult ); }
//-----------------------------------------------------------------------------
// Purpose: This function will load in a vmf manifest
// Input : pszFileName - the file name of the manifest to load
// Output : returns true if the load was successful
//-----------------------------------------------------------------------------
bool CManifest::LoadVMFManifest( const char *pszFileName ) { FILE *fp = fopen( pszFileName, "rb" ); if ( !fp ) { return false; }
V_StripExtension( pszFileName, m_ManifestDir, sizeof( m_ManifestDir ) ); strcat( m_ManifestDir, "\\" );
CChunkFile File; ChunkFileResult_t eResult = File.Open( pszFileName, ChunkFile_Read );
m_bLoading = true;
if (eResult == ChunkFile_Ok) { //
// Set up handlers for the subchunks that we are interested in.
//
CChunkHandlerMap Handlers; Handlers.AddHandler( "Info", ( ChunkHandler_t )CManifest::LoadManifestInfoCallback, this ); Handlers.AddHandler( "Maps", ( ChunkHandler_t )CManifest::LoadManifestMapsCallback, this );
Handlers.SetErrorHandler( ( ChunkErrorHandler_t )CMapDoc::HandleLoadError, this);
File.PushHandlers(&Handlers);
while (eResult == ChunkFile_Ok) { eResult = File.ReadChunk(); }
if (eResult == ChunkFile_EOF) { eResult = ChunkFile_Ok; }
File.PopHandlers(); }
if (eResult == ChunkFile_Ok) { } else { GetMainWnd()->MessageBox( File.GetErrorText( eResult ), "Error loading manifest!", MB_OK | MB_ICONEXCLAMATION ); }
if ( GetNumMaps() == 0 ) { GetMainWnd()->MessageBox( File.GetErrorText( eResult ), "Manifest file does not contain any maps!", MB_OK | MB_ICONEXCLAMATION ); return false; }
SetActiveMapDoc( this ); PostloadDocument( pszFileName ); m_ManifestWorld->PostloadWorld();
bool bSetIDs = false;
for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
if ( pManifestMap->m_InternalID == 0 ) { pManifestMap->m_InternalID = m_NextInternalID; m_NextInternalID++; bSetIDs = true; }
if ( pManifestMap->m_Map == NULL || pManifestMap->m_Map->GetMapWorld() == NULL ) { pManifestMap->m_bPrimaryMap = false; RemoveSubMap( pManifestMap ); i = -1; } }
LoadVMFManifestUserPrefs( pszFileName );
for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
if ( pManifestMap->m_bPrimaryMap ) { SetPrimaryMap( pManifestMap ); } }
if ( !m_pPrimaryMap ) { SetPrimaryMap( GetMap( 0 ) ); }
m_bLoading = false; m_bIsValid = true;
m_bManifestChanged = bSetIDs;
GetMainWnd()->m_ManifestFilterControl.UpdateManifestList();
return true; }
//-----------------------------------------------------------------------------
// Purpose: this function will load the user prefs for the manifest file.
// Input : pszFileName - the manifest file name.
// Output : true if prefs were loaded.
//-----------------------------------------------------------------------------
bool CManifest::LoadVMFManifestUserPrefs( const char *pszFileName ) { char UserName[ MAX_PATH ], FileName[ MAX_PATH ], UserPrefsFileName[ MAX_PATH ]; DWORD UserNameSize;
m_bManifestUserPrefsChanged = false;
UserNameSize = sizeof( UserName ); if ( GetUserName( UserName, &UserNameSize ) == 0 ) { strcpy( UserPrefsFileName, "default" ); }
strcpy( FileName, m_ManifestDir ); sprintf( UserPrefsFileName, "%s.vmm_prefs", UserName ); strcat( FileName, UserPrefsFileName );
FILE *fp = fopen( FileName, "rb" ); if ( !fp ) { return false; }
CChunkFile File; ChunkFileResult_t eResult = File.Open( FileName, ChunkFile_Read );
m_bLoading = true;
if ( eResult == ChunkFile_Ok ) { //
// Set up handlers for the subchunks that we are interested in.
//
CChunkHandlerMap Handlers; Handlers.AddHandler( "Maps", ( ChunkHandler_t )CManifest::LoadManifestMapsPrefsCallback, this ); Handlers.AddHandler( "cordoning", ( ChunkHandler_t )CManifest::LoadManifestCordoningPrefsCallback, this );
Handlers.SetErrorHandler( ( ChunkErrorHandler_t )CMapDoc::HandleLoadError, this);
File.PushHandlers(&Handlers);
while( eResult == ChunkFile_Ok ) { eResult = File.ReadChunk(); }
if ( eResult == ChunkFile_EOF ) { eResult = ChunkFile_Ok; }
File.PopHandlers(); }
if ( eResult == ChunkFile_Ok ) { } else { // no pref message for now
// GetMainWnd()->MessageBox( File.GetErrorText( eResult ), "Error loading manifest!", MB_OK | MB_ICONEXCLAMATION );
}
return true; }
//-----------------------------------------------------------------------------
// Purpose: this function will load in a manifest file ( and its user prefs )
// Input : pszFileName - the name of the manifest file.
// Output : returns true if the manifest was loaded.
//-----------------------------------------------------------------------------
bool CManifest::Load( const char *pszFileName ) { if ( !LoadVMFManifest( pszFileName ) ) { return false; }
return true; }
//-----------------------------------------------------------------------------
// Purpose: This function will save the manifest, the associated maps, and user prefs.
// Input : pszFileName - the name of the manifest
// bForce - if true, we need to save all files, as we are relocating.
// Output : returns true if all files saved successfully.
//-----------------------------------------------------------------------------
bool CManifest::Save( const char *pszFileName, bool bForce ) { bool bSuccess = true;
if ( bForce || m_bManifestChanged ) { if ( !SaveVMFManifest( pszFileName ) ) { bSuccess = false; } }
if ( !SaveVMFManifestMaps( pszFileName ) ) { bSuccess = false; }
// if ( bForce || m_bManifestUserPrefsChanged )
{ if ( !SaveVMFManifestUserPrefs( pszFileName ) ) { bSuccess = false; } }
return bSuccess; }
//-----------------------------------------------------------------------------
// Purpose: this function will save the manifest file and all modified maps. If we are
// relocating the manifest to a new place, all maps will be saved relative to
// the new place
// Input : the file name the manifest should be saved as
// Output : returns true if the save was completely successful. A partial save will
// return false.
//-----------------------------------------------------------------------------
bool CManifest::SaveVMFManifest( const char *pszFileName ) { bool bSaved = true; CChunkFile File;
ChunkFileResult_t eResult = File.Open( pszFileName, ChunkFile_Write ); if (eResult != ChunkFile_Ok) { GetMainWnd()->MessageBox( File.GetErrorText( eResult ), "Error saving Manifest!" , MB_OK | MB_ICONEXCLAMATION ); bSaved = false; } else { eResult = File.BeginChunk( "Info" ); eResult = File.WriteKeyValueInt( "NextInternalID", m_NextInternalID ); eResult = File.EndChunk();
eResult = File.BeginChunk( "Maps" ); if (eResult == ChunkFile_Ok) { for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
ChunkFileResult_t eResult = File.BeginChunk("VMF"); if (eResult == ChunkFile_Ok) { eResult = File.WriteKeyValue( "Name", pManifestMap->m_FriendlyName ); eResult = File.WriteKeyValue( "File", pManifestMap->m_RelativeMapFileName ); eResult = File.WriteKeyValueInt( "InternalID", pManifestMap->m_InternalID ); if ( pManifestMap->m_bTopLevelMap == true ) { eResult = File.WriteKeyValue( "TopLevel", "1" ); }
eResult = File.EndChunk(); } } }
if (eResult == ChunkFile_Ok) { eResult = File.EndChunk(); } else { GetMainWnd()->MessageBox( File.GetErrorText( eResult ), "Error saving Manifest!", MB_OK | MB_ICONEXCLAMATION ); bSaved = false; }
File.Close(); }
V_StripExtension( pszFileName, m_ManifestDir, sizeof( m_ManifestDir ) ); CreateDirectory( m_ManifestDir, NULL ); strcat( m_ManifestDir, "\\" );
if ( bSaved ) { m_bManifestChanged = false; }
return bSaved; }
//-----------------------------------------------------------------------------
// Purpose: This function will save all maps associated with a manifest. Only modified
// maps are saved unless we are relocating the manifest.
// Input : pszFileName - the name of the manifest file
// Output : returns true if the maps were saved successfully.
//-----------------------------------------------------------------------------
bool CManifest::SaveVMFManifestMaps( const char *pszFileName ) { bool bSaved = true;
for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
if ( m_bRelocateSave ) { char FileName[ MAX_PATH ];
strcpy( FileName, m_ManifestDir ); strcat( FileName, pManifestMap->m_RelativeMapFileName ); pManifestMap->m_AbsoluteMapFileName = FileName; }
if ( ( pManifestMap->m_Map->IsModified() || m_bRelocateSave ) ) { if ( pManifestMap->m_Map->SaveVMF( pManifestMap->m_AbsoluteMapFileName, 0 ) == false ) { bSaved = false; } } }
if ( !bSaved ) { GetMainWnd()->MessageBox( "Not all pieces of the manifest were saved!", "Error saving Manifest!", MB_OK | MB_ICONEXCLAMATION ); }
return bSaved; }
//-----------------------------------------------------------------------------
// Purpose: this function will save the user prefs of the manifest.
// Input : pszFileName - the name of the manifest file.
// Output : returns true if the prefs were saved.
//-----------------------------------------------------------------------------
bool CManifest::SaveVMFManifestUserPrefs( const char *pszFileName ) { bool bSaved = true; CChunkFile File; char UserName[ MAX_PATH ], FileName[ MAX_PATH ], UserPrefsFileName[ MAX_PATH ]; DWORD UserNameSize;
UserNameSize = sizeof( UserName ); if ( GetUserName( UserName, &UserNameSize ) == 0 ) { strcpy( UserPrefsFileName, "default" ); }
strcpy( FileName, m_ManifestDir ); sprintf( UserPrefsFileName, "%s.vmm_prefs", UserName ); strcat( FileName, UserPrefsFileName );
ChunkFileResult_t eResult = File.Open( FileName, ChunkFile_Write ); if (eResult != ChunkFile_Ok) { GetMainWnd()->MessageBox( File.GetErrorText( eResult ), "Error saving Manifest User Prefs!" , MB_OK | MB_ICONEXCLAMATION ); bSaved = false; } else { eResult = File.BeginChunk( "Maps" ); if (eResult == ChunkFile_Ok) { for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
ChunkFileResult_t eResult = File.BeginChunk("VMF"); if (eResult == ChunkFile_Ok) { eResult = File.WriteKeyValueInt( "InternalID", pManifestMap->m_InternalID ); if ( pManifestMap->m_bPrimaryMap ) { eResult = File.WriteKeyValue( "IsPrimary", "1" ); } if ( pManifestMap->m_bProtected == true ) { eResult = File.WriteKeyValue( "IsProtected", "1" ); } if ( pManifestMap->m_bVisible == false ) { eResult = File.WriteKeyValue( "IsVisible", "0" ); }
eResult = File.EndChunk(); } } }
if (eResult == ChunkFile_Ok) { eResult = File.EndChunk(); } else { GetMainWnd()->MessageBox( File.GetErrorText( eResult ), "Error saving Manifest User Prefs!", MB_OK | MB_ICONEXCLAMATION ); bSaved = false; }
eResult = File.BeginChunk( "cordoning" ); eResult = Cordon_SaveVMF( &File, NULL );
if ( m_bIsCordoning ) { CSaveInfo SaveInfo;
SaveInfo.SetVisiblesOnly( false ); CMapWorld *pCordonWorld = Cordon_CreateWorld(); eResult = pCordonWorld->SaveSolids( &File, &SaveInfo, 0 ); }
eResult = File.EndChunk();
File.Close(); }
if ( bSaved ) { m_bManifestUserPrefsChanged = false; }
return bSaved; }
//-----------------------------------------------------------------------------
// Purpose: this function will initialize the manifest
//-----------------------------------------------------------------------------
void CManifest::Initialize( void ) { __super::Initialize();
m_ManifestWorld = new CMapWorld( this ); m_ManifestWorld->CullTree_Build(); }
//-----------------------------------------------------------------------------
// Purpose: this function will update the manifest and all of its sub maps
//-----------------------------------------------------------------------------
void CManifest::Update( void ) { __super::Update();
for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
pManifestMap->m_Map->Update(); } }
//-----------------------------------------------------------------------------
// Purpose: this function allows you to indicate if the user prefs have been modified.
// Input : bModified - the new status of the user prefs
//-----------------------------------------------------------------------------
void CManifest::SetManifestPrefsModifiedFlag( bool bModified ) { m_bManifestUserPrefsChanged = bModified; }
//-----------------------------------------------------------------------------
// Purpose: this function handles the routing of the manifest's modified flag down to the primary map
// Input : bModified - the new modified status
//-----------------------------------------------------------------------------
void CManifest::SetModifiedFlag( BOOL bModified ) { if ( m_pPrimaryMap ) { m_pPrimaryMap->m_Map->SetModifiedFlag( bModified ); } if ( bModified == false ) { for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
if ( pManifestMap->m_Map->IsModified() ) { bModified = true; break; } } }
if ( bModified != IsModified() ) { GetMainWnd()->m_ManifestFilterControl.Invalidate(); }
__super::SetModifiedFlag( bModified ); }
//-----------------------------------------------------------------------------
// Purpose: this function will return the full path to a sub map.
// Input : pManifestMapFileName - the relative name of the sub map
// Output : pOutputPath - the full path to the sub map
//-----------------------------------------------------------------------------
void CManifest::GetFullMapPath( const char *pManifestMapFileName, char *pOutputPath ) { strcpy( pOutputPath, m_ManifestDir ); strcat( pOutputPath, pManifestMapFileName ); }
//-----------------------------------------------------------------------------
// Purpose: this function will attempt to find the manifest map that owns the map doc
// Input : pMap - the map doc to look up
// Output : returns a pointer to the owning manifest map, otherwise NULL
//-----------------------------------------------------------------------------
CManifestMap *CManifest::FindMap( CMapDoc *pMap ) { for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
if ( pManifestMap->m_Map == pMap ) { return pManifestMap; } }
return NULL; }
//-----------------------------------------------------------------------------
// Purpose: this function will attempt to look up a map by its internal id.
// Input : InternalID - the internal ID.
// Output : returns the manifest map if one is found.
//-----------------------------------------------------------------------------
CManifestMap *CManifest::FindMapByID( int InternalID ) { for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
if ( pManifestMap->m_InternalID == InternalID ) { return pManifestMap; } }
return NULL; }
//-----------------------------------------------------------------------------
// Purpose: this function will set the manifest map as the primary map. All entity / brush
// operations happen exclusively on the primary map.
// Input : pManifestMap - the manifest map to make primary
//-----------------------------------------------------------------------------
void CManifest::SetPrimaryMap( CManifestMap *pManifestMap ) { if ( m_pPrimaryMap ) { m_pPrimaryMap->m_bPrimaryMap = false; m_pPrimaryMap->m_Map->m_nNextMapObjectID = m_nNextMapObjectID; m_pPrimaryMap->m_Map->m_nNextMapObjectID = m_nNextNodeID; m_pPrimaryMap->m_Map->SetEditable( false ); }
ClearSelection(); CheckFileStatus();
m_pPrimaryMap = pManifestMap; if ( m_pPrimaryMap ) { m_pPrimaryMap->m_bPrimaryMap = true; m_pWorld = m_pPrimaryMap->m_Map->GetMapWorld(); m_VisGroups = m_pPrimaryMap->m_Map->m_VisGroups; m_RootVisGroups = m_pPrimaryMap->m_Map->m_RootVisGroups; m_nNextMapObjectID = m_pPrimaryMap->m_Map->m_nNextMapObjectID; m_nNextNodeID = m_pPrimaryMap->m_Map->m_nNextMapObjectID; m_pPrimaryMap->m_Map->SetEditable( !m_pPrimaryMap->m_bReadOnly );
m_pUndo = m_pPrimaryMap->m_Map->m_pUndo; m_pRedo = m_pPrimaryMap->m_Map->m_pRedo; CHistory::SetHistory( m_pPrimaryMap->m_Map->m_pUndo );
// m_pSelection = m_pPrimaryMap->m_Map->m_pSelection;
}
m_bManifestUserPrefsChanged = true;
GetMainWnd()->GlobalNotify( WM_MAPDOC_CHANGED ); GetMainWnd()->m_ManifestFilterControl.Invalidate(); UpdateAllViews( MAPVIEW_UPDATE_SELECTION | MAPVIEW_UPDATE_TOOL | MAPVIEW_RENDER_NOW ); }
//-----------------------------------------------------------------------------
// Purpose: sets the visibility flag of a sub map.
// Input : pManifestMap - the map to set the flag
// bIsVisible - the visiblity status
//-----------------------------------------------------------------------------
void CManifest::SetVisibility( CManifestMap *pManifestMap, bool bIsVisible ) { pManifestMap->m_bVisible = bIsVisible;
GetMainWnd()->m_ManifestFilterControl.Invalidate(); UpdateAllViews( MAPVIEW_UPDATE_SELECTION | MAPVIEW_UPDATE_TOOL | MAPVIEW_RENDER_NOW ); }
//-----------------------------------------------------------------------------
// Purpose: this function will create and default a new manifest map, add it to the world
// Input : AbsoluteFileName - the full path of the vmf file
// RelativeFileName - the relative path of the vmf file
// Output : returns a pointer to the newly created manifest map.
//-----------------------------------------------------------------------------
CManifestMap *CManifest::CreateNewMap( const char *AbsoluteFileName, const char *RelativeFileName, bool bSetID ) { CManifestMap *pManifestMap = new CManifestMap();
pManifestMap->m_AbsoluteMapFileName = AbsoluteFileName; pManifestMap->m_RelativeMapFileName = RelativeFileName; pManifestMap->m_Map = new CMapDoc(); SetActiveMapDoc( pManifestMap->m_Map ); pManifestMap->m_Map->SetManifest( this ); pManifestMap->m_Map->SetEditable( false );
pManifestMap->m_Entity = new CManifestInstance( pManifestMap );
pManifestMap->m_Entity->SetPlaceholder( true ); pManifestMap->m_Entity->SetOrigin( Vector( 0.0f, 0.0f, 0.0f ) ); pManifestMap->m_Entity->SetClass( "func_instance" ); pManifestMap->m_Entity->SetKeyValue( "classname", "func_instance" );
// ensure we are a pure instance of only the instance helper!
pManifestMap->m_Entity->RemoveAllChildren(); CHelperInfo HI;
HI.SetName( "instance" );
CMapClass *pHelper = CHelperFactory::CreateHelper( &HI, pManifestMap->m_Entity ); if ( pHelper != NULL ) { pManifestMap->m_Entity->AddHelper( pHelper, false ); }
if ( bSetID ) { pManifestMap->m_InternalID = m_NextInternalID; m_NextInternalID++; }
CMapInstance *pMapInstance = pManifestMap->m_Entity->GetChildOfType( ( CMapInstance * )NULL ); if ( pMapInstance ) { pMapInstance->SetManifest( pManifestMap ); } AddManifestObjectToWorld( pManifestMap->m_Entity ); m_Maps.AddToTail( pManifestMap );
m_bManifestChanged = true;
return pManifestMap; }
//-----------------------------------------------------------------------------
// Purpose: This function will move the selection of the active map to a new sub map.
// Input : pManifestMap - the sub map the selection shoud be moved to
// CenterContents - if the contents should be centered
//-----------------------------------------------------------------------------
void CManifest::MoveSelectionToSubmap( CManifestMap *pManifestMap, bool CenterContents ) { #if 0
if ( s_Clipboard.Objects.Count() != 0 ) { return false; } #endif
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc(); if ( !pDoc ) { return; }
pDoc->Copy(); if ( pDoc->GetClipboardCount() == 0 ) { return; } pDoc->Delete();
pManifestMap->m_Map->ManifestPaste( pManifestMap->m_Map->GetMapWorld(), Vector( 0.0f, 0.0f, 0.0f ), QAngle( 0.0f, 0.0f, 0.0f ), NULL, false, NULL ); pManifestMap->m_Entity->CalcBounds( TRUE ); UpdateAllViews( MAPVIEW_UPDATE_SELECTION | MAPVIEW_UPDATE_TOOL | MAPVIEW_RENDER_NOW ); }
//-----------------------------------------------------------------------------
// Purpose: this function will cut the selection and move it into a newly created
// map doc and manifest map.
// Input : FriendlyName - this is the text friendly name that the user can refer
// to the map as
// FileName - The relative file name for this new map to be saved as
// CenterContents - whether or not we should center the contents in the new map
// Output : returns a pointer to the newly created manifest map.
//-----------------------------------------------------------------------------
CManifestMap *CManifest::MoveSelectionToNewSubmap( CString &FriendlyName, CString &FileName, bool CenterContents ) { #if 0
if ( s_Clipboard.Objects.Count() != 0 ) { return false; } #endif
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if ( !pDoc ) { return NULL; }
pDoc->Copy(); if ( pDoc->GetClipboardCount() == 0 ) { return NULL; } char AbsoluteFileName[ MAX_PATH ];
strcpy( AbsoluteFileName, m_ManifestDir ); strcat( AbsoluteFileName, FileName );
CManifestMap *pManifestMap = CreateNewMap( AbsoluteFileName, FileName, true ); pManifestMap->m_FriendlyName = FriendlyName;
pManifestMap->m_Map->Initialize(); if ( pManifestMap->m_Map->SaveVMF( pManifestMap->m_AbsoluteMapFileName, 0 ) == false ) { m_bLoading = false; SetActiveMapDoc( this ); delete pManifestMap; return NULL; } pDoc->Delete(); pManifestMap->m_Map->ManifestPaste( pManifestMap->m_Map->GetMapWorld(), Vector( 0.0f, 0.0f, 0.0f ), QAngle( 0.0f, 0.0f, 0.0f ), NULL, false, NULL ); pManifestMap->m_Entity->CalcBounds( TRUE ); SetPrimaryMap( pManifestMap );
SetActiveMapDoc( this ); __super::SetModifiedFlag( true ); pDoc->SetModifiedFlag( true ); pManifestMap->m_Map->SetModifiedFlag( true );
UpdateAllViews( MAPVIEW_UPDATE_SELECTION | MAPVIEW_UPDATE_TOOL | MAPVIEW_RENDER_NOW ); GetMainWnd()->m_ManifestFilterControl.UpdateManifestList();
return pManifestMap; }
//-----------------------------------------------------------------------------
// Purpose: this function will add a new sub map to the manifest.
// Input : FriendlyName - the friendly name string
// FileName - the file name of the sub map
// Output : returns a pointer to the new manifest map.
//-----------------------------------------------------------------------------
CManifestMap *CManifest::AddNewSubmap( CString &FriendlyName, CString &FileName ) { char AbsoluteFileName[ MAX_PATH ];
strcpy( AbsoluteFileName, m_ManifestDir ); strcat( AbsoluteFileName, FileName );
CManifestMap *pManifestMap = CreateNewMap( AbsoluteFileName, FileName, true );
pManifestMap->m_FriendlyName = FriendlyName;
pManifestMap->m_Map->Initialize(); pManifestMap->m_Entity->CalcBounds( TRUE );
if ( pManifestMap->m_Map->SaveVMF( pManifestMap->m_AbsoluteMapFileName, 0 ) == false ) { m_bLoading = false; SetActiveMapDoc( this ); delete pManifestMap; return NULL; }
SetPrimaryMap( pManifestMap ); SetActiveMapDoc( this ); __super::SetModifiedFlag( true );
UpdateAllViews( MAPVIEW_UPDATE_SELECTION | MAPVIEW_UPDATE_TOOL | MAPVIEW_RENDER_NOW ); GetMainWnd()->m_ManifestFilterControl.UpdateManifestList();
return pManifestMap; }
//-----------------------------------------------------------------------------
// Purpose: This function add an external vmf file to the manifest
// Input : pszFileName - the absolute file name of the vmf file
// bFromInstance - if the map is coming from a func_instance somewhere
// Output : returns true if the map could be loaded and the manifest was created
//-----------------------------------------------------------------------------
bool CManifest::AddExistingMap( const char *pszFileName, bool bFromInstance ) { char AbsoluteFileName[ MAX_PATH ], RelativeFileName[ MAX_PATH ];
char FileExt[ MAX_PATH ];
_splitpath_s( pszFileName, NULL, 0, NULL, 0, RelativeFileName, sizeof( RelativeFileName ), FileExt, sizeof( FileExt ) ); strcat( RelativeFileName, FileExt );
strcpy( AbsoluteFileName, m_ManifestDir ); strcat( AbsoluteFileName, RelativeFileName ); CManifestMap *pManifestMap = CreateNewMap( AbsoluteFileName, RelativeFileName, true );
m_bLoading = true; if ( !pManifestMap->m_Map->LoadVMF( pszFileName, VMF_LOAD_ACTIVATE | VMF_LOAD_IS_SUBMAP ) ) { m_bLoading = false; SetActiveMapDoc( this ); delete pManifestMap; return false; }
if ( pManifestMap->m_Map->SaveVMF( pManifestMap->m_AbsoluteMapFileName, 0 ) == false ) { m_bLoading = false; SetActiveMapDoc( this ); delete pManifestMap; return false; }
pManifestMap->m_Map->GetMapWorld()->CullTree_Build(); pManifestMap->m_Entity->PostUpdate( Notify_Changed ); if ( m_Maps.Count() == 1 ) { pManifestMap->m_bTopLevelMap = true; }
SetPrimaryMap( pManifestMap );
m_bLoading = false;
SetActiveMapDoc( this ); __super::SetModifiedFlag( true );
GetMainWnd()->m_ManifestFilterControl.UpdateManifestList();
if ( GetPathName().GetLength() == 0 ) { char ManifestFile[ MAX_PATH ];
strcpy( ManifestFile, pszFileName ); V_SetExtension( ManifestFile, ".vmm", sizeof( ManifestFile ) );
m_bRelocateSave = true; OnSaveDocument( ManifestFile ); m_bRelocateSave = false;
SetPathName( ManifestFile, false ); }
return true; }
//-----------------------------------------------------------------------------
// Purpose: This function will allow the user to browse to an exist map to add to the manifest.
//-----------------------------------------------------------------------------
bool CManifest::AddExistingMap( void ) { char szInitialDir[ MAX_PATH ]; strcpy( szInitialDir, GetPathName() ); if ( szInitialDir[ 0 ] == '\0' ) { strcpy( szInitialDir, g_pGameConfig->szMapDir ); }
CFileDialog dlg( TRUE, NULL, NULL, OFN_LONGNAMES | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, "Valve Map Files (*.vmf)|*.vmf||" ); dlg.m_ofn.lpstrInitialDir = szInitialDir; int iRvl = dlg.DoModal();
if ( iRvl == IDCANCEL ) { return false; }
//
// Get the directory they browsed to for next time.
//
CString str = dlg.GetPathName(); int nSlash = str.ReverseFind( '\\' ); if ( nSlash != -1 ) { strcpy( szInitialDir, str.Left( nSlash ) ); }
if ( str.Find('.') == -1 ) { switch ( dlg.m_ofn.nFilterIndex ) { case 1: str += ".vmf"; break; } }
return AddExistingMap( str, false ); }
//-----------------------------------------------------------------------------
// Purpose: This function will remove the sub map from the manifest
// Input : pManifestMap - the sub map to be removed
// Output : returns true if it was successful
//-----------------------------------------------------------------------------
bool CManifest::RemoveSubMap( CManifestMap *pManifestMap ) { if ( m_Maps.Count() > 1 ) { m_Maps.FindAndRemove( pManifestMap );
const CMapObjectList *pChildren = m_ManifestWorld->GetChildren(); FOR_EACH_OBJ( *pChildren, pos ) { CMapClass *pChild = (CUtlReference< CMapClass >)pChildren->Element( pos ); CMapEntity *pEntity = dynamic_cast< CMapEntity * >( pChild );
if ( pEntity && stricmp( pEntity->GetClassName(), "func_instance" ) == 0 ) { CMapInstance *pMapInstance = pEntity->GetChildOfType( ( CMapInstance * )NULL ); if ( pMapInstance ) { if ( pMapInstance->GetManifestMap() == pManifestMap ) { m_ManifestWorld->RemoveObjectFromWorld( pChild, true ); break; } } } }
delete pManifestMap;
return true; }
return false; }
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CManifest::CheckOut( ) { if ( !p4 ) { return false; }
if ( !p4->OpenFileForEdit( GetPathName() ) ) { return false; }
CheckFileStatus();
return true; }
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CManifest::AddToVersionControl( ) { if ( !p4 ) { return false; }
if ( !p4->OpenFileForAdd( GetPathName() ) ) { return false; }
CheckFileStatus();
return true; }
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CManifest::CheckFileStatus( void ) { P4File_t FileInfo;
m_bReadOnly = !g_pFullFileSystem->IsFileWritable( GetPathName() ); m_bCheckedOut = false; m_bIsVersionControlled = false; if ( p4 != NULL && p4->GetFileInfo( GetPathName(), &FileInfo ) == true ) { m_bIsVersionControlled = true; if ( FileInfo.m_eOpenState == P4FILE_OPENED_FOR_ADD || FileInfo.m_eOpenState == P4FILE_OPENED_FOR_EDIT ) { m_bCheckedOut = true; } }
for( int i = 0; i < GetNumMaps(); i++ ) { CManifestMap *pManifestMap = GetMap( i );
pManifestMap->m_bReadOnly = !g_pFullFileSystem->IsFileWritable( pManifestMap->m_AbsoluteMapFileName ); pManifestMap->m_bCheckedOut = false; pManifestMap->m_bIsVersionControlled = false;
if ( p4 != NULL && p4->GetFileInfo( pManifestMap->m_AbsoluteMapFileName, &FileInfo ) == true ) { pManifestMap->m_bIsVersionControlled = true; if ( FileInfo.m_eOpenState == P4FILE_OPENED_FOR_ADD || FileInfo.m_eOpenState == P4FILE_OPENED_FOR_EDIT ) { pManifestMap->m_bCheckedOut = true; } } } }
//-----------------------------------------------------------------------------
// Purpose: This function will clear the selection
//-----------------------------------------------------------------------------
void CManifest::ClearSelection( void ) { SelectFace( NULL, 0, scClear | scSaveChanges ); SelectObject( NULL, scClear | scSaveChanges ); }
//-----------------------------------------------------------------------------
// Purpose: This function will add the object to the primary map of the manifest
// Input : pObject - a pointer to the object to be added
// pParent - a pointer to the parent of this object
//-----------------------------------------------------------------------------
void CManifest::AddObjectToWorld(CMapClass *pObject, CMapClass *pParent) { m_pPrimaryMap->m_Map->AddObjectToWorld( pObject, pParent );
m_pPrimaryMap->m_Entity->PostUpdate( Notify_Changed ); }
//-----------------------------------------------------------------------------
// Purpose: This function will pass on the notification that a map has been updated
// Input : pInstanceMapDoc - the map that was updated
//-----------------------------------------------------------------------------
void CManifest::UpdateInstanceMap( CMapDoc *pInstanceMapDoc ) { const CMapObjectList *pChildren = m_ManifestWorld->GetChildren(); FOR_EACH_OBJ( *pChildren, pos ) { CMapClass *pChild = (CUtlReference< CMapClass >)pChildren->Element( pos ); CMapEntity *pEntity = dynamic_cast< CMapEntity * >( pChild );
if ( pEntity && stricmp( pEntity->GetClassName(), "func_instance" ) == 0 ) { CMapInstance *pMapInstance = pEntity->GetChildOfType( ( CMapInstance * )NULL ); if ( pMapInstance ) { if ( pMapInstance->GetInstancedMap() == pInstanceMapDoc ) { pMapInstance->UpdateInstanceMap(); m_ManifestWorld->UpdateChild( pMapInstance ); } } } } }
//-----------------------------------------------------------------------------
// Purpose: this function will add the object to the local manifest world. the
// only objects that should be added are ManifestInstance.
// Input : pObject - a pointer to the object to be added
// pParent - a pointer to the parent of this object
//-----------------------------------------------------------------------------
void CManifest::AddManifestObjectToWorld( CMapClass *pObject, CMapClass *pParent ) { m_ManifestWorld->AddObjectToWorld( pObject, pParent ); }
//-----------------------------------------------------------------------------
// Purpose: Removes an object from the manifest world.
// Input : pObject - object to remove from the world.
// bChildren - whether we're removing the object's children as well.
//-----------------------------------------------------------------------------
void CManifest::RemoveManifestObjectFromWorld( CMapClass *pObject, bool bRemoveChildren ) { m_ManifestWorld->RemoveObjectFromWorld( pObject, bRemoveChildren ); }
//-----------------------------------------------------------------------------
// Purpose: this function will start the loading process for a manifest
// Input : lpszPathName - the absoltue path of the manifest file
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CManifest::OnOpenDocument(LPCTSTR lpszPathName) { Initialize();
if (!SelectDocType()) { return FALSE; }
//
// Call any per-class PreloadWorld functions here.
//
CMapSolid::PreloadWorld();
if ( !Load( lpszPathName ) ) { return FALSE; }
SetModifiedFlag( FALSE ); Msg( mwStatus, "Opened %s", lpszPathName ); SetActiveMapDoc( this );
//
// We set the active doc before loading for displacements (and maybe other
// things), but visgroups aren't available until after map load. We have to refresh
// the visgroups here or they won't be correct.
//
GetMainWnd()->GlobalNotify( WM_MAPDOC_CHANGED );
m_pToolManager->SetTool( TOOL_POINTER );
return(TRUE); }
//-----------------------------------------------------------------------------
// Purpose: This function will save out the manifest
// Input : lpszPathName - the absolute filename of the manifest
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CManifest::OnSaveDocument(LPCTSTR lpszPathName) { if ( !Save( lpszPathName, m_bRelocateSave ) ) { return FALSE; }
SetModifiedFlag( FALSE );
return TRUE; }
//-----------------------------------------------------------------------------
// Purpose: this function will be called when the use select Save As. This will
// allow all of the submaps to be relocated relative to a new save location
// of the manifest itself. Directories should be created automatically.
//-----------------------------------------------------------------------------
void CManifest::OnFileSaveAs(void) { m_bRelocateSave = true;
__super::OnFileSaveAs();
m_bRelocateSave = false; }
//-----------------------------------------------------------------------------
// Purpose: this function will delete the manifest world and rest of the contents.
//-----------------------------------------------------------------------------
void CManifest::DeleteContents( void ) { m_pSelection->RemoveAll();
if ( m_ManifestWorld ) { delete m_ManifestWorld; m_ManifestWorld = NULL; }
m_pWorld = NULL; m_VisGroups = NULL; m_RootVisGroups = NULL; m_pUndo = m_pSaveUndo; m_pRedo = m_pSaveRedo;
__super::DeleteContents(); }
#include <tier0/memdbgoff.h>
|