mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 06:06:50 +00:00
1596 lines
45 KiB
C++
1596 lines
45 KiB
C++
//========= Copyright 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 "tier2/tier2.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::LoadCordonCallback, 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 );
|
|
Postload( 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 );
|
|
|
|
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 );
|
|
|
|
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 = CordonSaveVMF( &File, NULL );
|
|
|
|
if ( m_bIsCordoning )
|
|
{
|
|
CSaveInfo SaveInfo;
|
|
|
|
SaveInfo.SetVisiblesOnly( false );
|
|
CMapWorld *pCordonWorld = CordonCreateWorld();
|
|
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 ];
|
|
|
|
V_strcpy_safe( 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 = 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 = 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>
|