1726 lines
54 KiB
C++
1726 lines
54 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "dme_controls/AssetBuilder.h"
|
|
#include "dme_controls/DmePanel.h"
|
|
#include "dme_controls/dmecontrols_utils.h"
|
|
#include "tier1/KeyValues.h"
|
|
#include "vgui_controls/ListPanel.h"
|
|
#include "vgui_controls/MenuButton.h"
|
|
#include "vgui_controls/TextEntry.h"
|
|
#include "vgui_controls/MessageBox.h"
|
|
#include "vgui_controls/ComboBox.h"
|
|
#include "vgui_controls/FileOpenDialog.h"
|
|
#include "vgui_controls/Splitter.h"
|
|
#include "vgui_controls/FileOpenStateMachine.h"
|
|
#include "vgui_controls/PropertySheet.h"
|
|
#include "vgui_controls/PropertyPage.h"
|
|
#include "vgui/ischeme.h"
|
|
#include "vgui/IVGui.h"
|
|
#include "vgui/ISurface.h"
|
|
#include "tier1/tier1.h"
|
|
#include "movieobjects/dmemakefile.h"
|
|
#include "matsys_controls/picker.h"
|
|
#include "tier2/fileutils.h"
|
|
#include "vgui/keycode.h"
|
|
#include "filesystem.h"
|
|
#include "movieobjects/idmemakefileutils.h"
|
|
#include "tier3/tier3.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
using namespace vgui;
|
|
|
|
#define ASSET_FILE_FORMAT "model"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compile status bar
|
|
//-----------------------------------------------------------------------------
|
|
class CCompileStatusBar : public vgui::EditablePanel
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CCompileStatusBar, EditablePanel );
|
|
|
|
public:
|
|
enum CompileStatus_t
|
|
{
|
|
NOT_COMPILING,
|
|
CURRENTLY_COMPILING,
|
|
COMPILATION_FAILED,
|
|
COMPILATION_SUCCESSFUL
|
|
};
|
|
|
|
CCompileStatusBar( vgui::Panel *pParent, const char *pPanelName );
|
|
virtual ~CCompileStatusBar();
|
|
|
|
virtual void PaintBackground();
|
|
|
|
void SetStatus( CompileStatus_t status, const char *pMessage );
|
|
|
|
private:
|
|
vgui::Label *m_pStatus;
|
|
CompileStatus_t m_Status;
|
|
int m_CompilingId;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
CCompileStatusBar::CCompileStatusBar( vgui::Panel *pParent, const char *pPanelName ) :
|
|
BaseClass( pParent, pPanelName )
|
|
{
|
|
m_pStatus = new vgui::Label( this, "StatusLabel", "" );
|
|
m_pStatus->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_DOWNANDRIGHT, 0, 0, 0, 0 );
|
|
m_pStatus->SetContentAlignment( vgui::Label::a_center );
|
|
m_pStatus->SetTextColorState( vgui::Label::CS_BRIGHT );
|
|
SetStatus( NOT_COMPILING, "" );
|
|
SetPaintBackgroundEnabled( true );
|
|
m_CompilingId = vgui::surface()->DrawGetTextureId( "vgui/progressbar" );
|
|
if ( m_CompilingId == -1 ) // we didn't find it, so create a new one
|
|
{
|
|
m_CompilingId = vgui::surface()->CreateNewTextureID();
|
|
vgui::surface()->DrawSetTextureFile( m_CompilingId, "vgui/progressbar", true, false );
|
|
}
|
|
}
|
|
|
|
CCompileStatusBar::~CCompileStatusBar()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets compile status
|
|
//-----------------------------------------------------------------------------
|
|
void CCompileStatusBar::SetStatus( CompileStatus_t status, const char *pMessage )
|
|
{
|
|
m_Status = status;
|
|
m_pStatus->SetText( pMessage );
|
|
}
|
|
|
|
|
|
void CCompileStatusBar::PaintBackground()
|
|
{
|
|
int w, h;
|
|
GetSize( w, h );
|
|
|
|
switch( m_Status )
|
|
{
|
|
case NOT_COMPILING:
|
|
break;
|
|
|
|
case COMPILATION_FAILED:
|
|
vgui::surface()->DrawSetColor( 255, 0, 0, 255 );
|
|
vgui::surface()->DrawFilledRect( 0, 0, w, h );
|
|
break;
|
|
|
|
case COMPILATION_SUCCESSFUL:
|
|
vgui::surface()->DrawSetColor( 0, 255, 0, 255 );
|
|
vgui::surface()->DrawFilledRect( 0, 0, w, h );
|
|
break;
|
|
|
|
case CURRENTLY_COMPILING:
|
|
{
|
|
float du = Plat_FloatTime() / 5.0f;
|
|
du -= (int)du;
|
|
du = 1.0f - du;
|
|
|
|
Vertex_t verts[4];
|
|
verts[0].Init( Vector2D( 0.0f, 0.0f ), Vector2D( du, 0.0f ) );
|
|
verts[1].Init( Vector2D( w, 0.0f ), Vector2D( 1.0f + du, 0.0f ) );
|
|
verts[2].Init( Vector2D( w, h ), Vector2D( 1.0f + du, 1.0f ) );
|
|
verts[3].Init( Vector2D( 0.0f, h ), Vector2D( du, 1.0f ) );
|
|
|
|
vgui::surface()->DrawSetColor( 255, 255, 255, 255 );
|
|
vgui::surface()->DrawSetTexture( m_CompilingId );
|
|
vgui::surface()->DrawTexturedPolygon( 4, verts );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Asset Builder
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_DMEPANEL_FACTORY( CAssetBuilder, DmeMakefile, "DmeMakeFileDefault", "MakeFile Editor", true );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Static data
|
|
//-----------------------------------------------------------------------------
|
|
static PickerList_t s_AssetTypes;
|
|
static bool s_bAssetTypeListBuilt = false;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Builds the list of asset types
|
|
//-----------------------------------------------------------------------------
|
|
void BuildAssetTypeList( )
|
|
{
|
|
if ( s_bAssetTypeListBuilt )
|
|
return;
|
|
|
|
s_bAssetTypeListBuilt = true;
|
|
|
|
CDisableUndoScopeGuard guard;
|
|
|
|
int hFactory = g_pDataModel->GetFirstFactory();
|
|
while ( g_pDataModel->IsValidFactory( hFactory ) )
|
|
{
|
|
// Add all DmeElements that inherit from DmeMakefile
|
|
const char *pFactoryName = g_pDataModel->GetFactoryName( hFactory );
|
|
CDmElement *pElement = GetElement< CDmElement >( g_pDataModel->CreateElement( pFactoryName, "temp" ) );
|
|
CDmeMakefile *pMakeFile = CastElement<CDmeMakefile>( pElement );
|
|
if ( pMakeFile && pMakeFile->GetMakefileType() )
|
|
{
|
|
int i = s_AssetTypes.AddToTail();
|
|
s_AssetTypes[i].m_pChoiceString = pMakeFile->GetMakefileType()->m_pHumanReadableName;
|
|
s_AssetTypes[i].m_pChoiceValue = pFactoryName;
|
|
}
|
|
DestroyElement( pElement );
|
|
|
|
hFactory = g_pDataModel->GetNextFactory( hFactory );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Builds the list of asset types
|
|
//-----------------------------------------------------------------------------
|
|
static PickerList_t &BuildAssetSubTypeList( const char **ppSubTypes, PickerList_t &pickerList )
|
|
{
|
|
if ( !ppSubTypes )
|
|
return s_AssetTypes;
|
|
|
|
pickerList.RemoveAll();
|
|
|
|
CDisableUndoScopeGuard guard;
|
|
|
|
int nCount = s_AssetTypes.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
// Add all DmeElements that inherit from DmeMakefile
|
|
CDmElement *pElement = GetElement< CDmElement >( g_pDataModel->CreateElement( s_AssetTypes[i].m_pChoiceValue, "temp" ) );
|
|
CDmeMakefile *pMakeFile = CastElement< CDmeMakefile >( pElement );
|
|
|
|
for ( int j = 0; ppSubTypes[j]; ++j )
|
|
{
|
|
if ( !pElement->IsA( ppSubTypes[j] ) )
|
|
continue;
|
|
|
|
int k = pickerList.AddToTail();
|
|
pickerList[k].m_pChoiceString = pMakeFile->GetMakefileType()->m_pHumanReadableName;
|
|
pickerList[k].m_pChoiceValue = s_AssetTypes[i].m_pChoiceValue;
|
|
break;
|
|
}
|
|
DestroyElement( pElement );
|
|
}
|
|
|
|
return pickerList;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Shows the overwrite existing file dialog
|
|
//-----------------------------------------------------------------------------
|
|
static void OverwriteFileDialog( vgui::Panel *pActionTarget, const char *pFileName, KeyValues *pOkCommand )
|
|
{
|
|
if ( !g_pFullFileSystem->FileExists( pFileName ) )
|
|
{
|
|
pActionTarget->PostMessage( pActionTarget->GetVPanel(), pOkCommand );
|
|
return;
|
|
}
|
|
|
|
char pBuf[1024];
|
|
Q_snprintf( pBuf, sizeof(pBuf), "File already exists. Overwrite it?\n\n\"%s\"\n", pFileName );
|
|
vgui::MessageBox *pMessageBox = new vgui::MessageBox( "Overwrite Existing File?", pBuf, pActionTarget );
|
|
pMessageBox->AddActionSignalTarget( pActionTarget );
|
|
pMessageBox->SetOKButtonVisible( true );
|
|
pMessageBox->SetOKButtonText( "Yes" );
|
|
pMessageBox->SetCancelButtonVisible( true );
|
|
pMessageBox->SetCancelButtonText( "No" );
|
|
pMessageBox->SetCloseButtonVisible( false );
|
|
pMessageBox->SetCommand( pOkCommand );
|
|
pMessageBox->DoModal();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Utility to load a makefile
|
|
//-----------------------------------------------------------------------------
|
|
static CDmeMakefile *ReadMakefile( const char *pFileName, CDmElement **ppRoot = NULL )
|
|
{
|
|
if ( ppRoot )
|
|
{
|
|
*ppRoot = NULL;
|
|
}
|
|
|
|
CDmElement *pRoot;
|
|
DmFileId_t fileid = g_pDataModel->RestoreFromFile( pFileName, NULL, NULL, &pRoot, CR_DELETE_OLD );
|
|
if ( fileid == DMFILEID_INVALID || !pRoot )
|
|
{
|
|
Warning( "Unable to read makefile \"%s\"!\n", pFileName );
|
|
return NULL;
|
|
}
|
|
|
|
CDmeMakefile *pMakeFile = CastElement< CDmeMakefile >( pRoot );
|
|
if ( !pMakeFile )
|
|
{
|
|
CDmElement *pElement = CastElement< CDmElement >( pRoot );
|
|
pMakeFile = pElement->GetValueElement< CDmeMakefile >( "makefile" );
|
|
if ( !pMakeFile )
|
|
{
|
|
DmFileId_t fileId = pRoot->GetFileId();
|
|
DestroyElement( pRoot );
|
|
if ( fileId != DMFILEID_INVALID && g_pDataModel->GetFileName( fileId )[0] )
|
|
{
|
|
g_pDataModel->RemoveFileId( fileId );
|
|
}
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if ( ppRoot )
|
|
{
|
|
*ppRoot = CastElement< CDmElement >( pRoot );
|
|
}
|
|
return pMakeFile;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sort by MDL name
|
|
//-----------------------------------------------------------------------------
|
|
static int __cdecl TypeSortFunc( vgui::ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 )
|
|
{
|
|
const char *string1 = item1.kv->GetString("type");
|
|
const char *string2 = item2.kv->GetString("type");
|
|
int nRetVal = Q_stricmp( string1, string2 );
|
|
if ( nRetVal != 0 )
|
|
return nRetVal;
|
|
|
|
string1 = item1.kv->GetString("file");
|
|
string2 = item2.kv->GetString("file");
|
|
nRetVal = Q_stricmp( string1, string2 );
|
|
if ( nRetVal != 0 )
|
|
return nRetVal;
|
|
|
|
int nIndex1 = item1.kv->GetInt( "index" );
|
|
int nIndex2 = item2.kv->GetInt( "index" );
|
|
return nIndex1 - nIndex2;
|
|
}
|
|
|
|
static int __cdecl FileSortFunc( vgui::ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 )
|
|
{
|
|
const char *string1 = item1.kv->GetString("file");
|
|
const char *string2 = item2.kv->GetString("file");
|
|
int nRetVal = Q_stricmp( string1, string2 );
|
|
if ( nRetVal != 0 )
|
|
return nRetVal;
|
|
|
|
string1 = item1.kv->GetString("type");
|
|
string2 = item2.kv->GetString("type");
|
|
nRetVal = Q_stricmp( string1, string2 );
|
|
if ( nRetVal != 0 )
|
|
return nRetVal;
|
|
|
|
int nIndex1 = item1.kv->GetInt( "index" );
|
|
int nIndex2 = item2.kv->GetInt( "index" );
|
|
return nIndex1 - nIndex2;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
CAssetBuilder::CAssetBuilder( vgui::Panel *pParent, const char *pPanelName ) :
|
|
BaseClass( pParent, pPanelName )
|
|
{
|
|
m_hContextMenu = NULL;
|
|
m_hRootMakefile = NULL;
|
|
m_bIsCompiling = false;
|
|
m_bDestroyMakefileOnClose = true;
|
|
|
|
m_pInputOutputSheet = new vgui::PropertySheet( this, "InputOutputSheet" );
|
|
m_pInputOutputSheet->AddActionSignalTarget( this );
|
|
|
|
m_pInputPage = new PropertyPage( m_pInputOutputSheet, "InputPage" );
|
|
m_pOutputPage = new PropertyPage( m_pInputOutputSheet, "OutputPage" );
|
|
m_pCompilePage = new PropertyPage( m_pInputOutputSheet, "CompilePage" );
|
|
m_pOutputPreviewPage = new PropertyPage( m_pInputOutputSheet, "OutputPreviewPage" );
|
|
|
|
m_pPropertiesSplitter = new vgui::Splitter( m_pInputPage, "PropertiesSplitter", SPLITTER_MODE_VERTICAL, 1 );
|
|
|
|
vgui::Panel *pSplitterLeftSide = m_pPropertiesSplitter->GetChild( 0 );
|
|
vgui::Panel *pSplitterRightSide = m_pPropertiesSplitter->GetChild( 1 );
|
|
m_pDmePanel = new CDmePanel( pSplitterRightSide, "CompileOptions" );
|
|
m_pDmePanel->AddActionSignalTarget( this );
|
|
|
|
m_pOututPreviewPanel = new CDmePanel( m_pOutputPreviewPage, "OutputPreview", false );
|
|
m_pOututPreviewPanel->AddActionSignalTarget( this );
|
|
|
|
m_pSourcesList = new vgui::ListPanel( pSplitterLeftSide, "SourcesList" );
|
|
m_pSourcesList->AddColumnHeader( 0, "type", "type", 100, 0 );
|
|
m_pSourcesList->AddColumnHeader( 1, "file", "file", 52, 0 );
|
|
m_pSourcesList->AddActionSignalTarget( this );
|
|
m_pSourcesList->SetSortFunc( 0, TypeSortFunc );
|
|
m_pSourcesList->SetSortFunc( 1, FileSortFunc );
|
|
m_pSourcesList->SetSortColumn( 0 );
|
|
// m_pSourcesList->SetSelectIndividualCells( true );
|
|
m_pSourcesList->SetEmptyListText("No sources");
|
|
// m_pSourcesList->SetDragEnabled( true );
|
|
|
|
m_pOutputList = new vgui::ListPanel( m_pOutputPage, "OutputList" );
|
|
m_pOutputList->AddColumnHeader( 0, "type", "type", 100, 0 );
|
|
m_pOutputList->AddColumnHeader( 1, "file", "file", 52, 0 );
|
|
m_pOutputList->AddActionSignalTarget( this );
|
|
m_pOutputList->SetSortFunc( 0, TypeSortFunc );
|
|
m_pOutputList->SetSortFunc( 1, FileSortFunc );
|
|
m_pOutputList->SetSortColumn( 0 );
|
|
m_pOutputList->SetEmptyListText("No outputs");
|
|
|
|
m_pCompileOutput = new vgui::TextEntry( m_pCompilePage, "CompileOutput" );
|
|
m_pCompileOutput->SetMultiline( true );
|
|
m_pCompileOutput->SetVerticalScrollbar( true );
|
|
m_pCompile = new vgui::Button( this, "CompileButton", "Compile", this, "OnCompile" );
|
|
m_pPublish = new vgui::Button( this, "PublishButton", "Publish", this, "OnPublish" );
|
|
m_pAbortCompile = new vgui::Button( this, "AbortCompileButton", "AbortCompile", this, "OnAbortCompile" );
|
|
m_pCompileStatusBar = new CCompileStatusBar( this, "CompileStatus" );
|
|
|
|
m_pInputPage->LoadControlSettingsAndUserConfig( "resource/assetbuilderinputpage.res" );
|
|
m_pOutputPage->LoadControlSettingsAndUserConfig( "resource/assetbuilderoutputpage.res" );
|
|
m_pCompilePage->LoadControlSettingsAndUserConfig( "resource/assetbuildercompilepage.res" );
|
|
m_pOutputPreviewPage->LoadControlSettingsAndUserConfig( "resource/assetbuilderoutputpreviewpage.res" );
|
|
|
|
// Load layout settings; has to happen before pinning occurs in code
|
|
LoadControlSettingsAndUserConfig( "resource/assetbuilder.res" );
|
|
|
|
// NOTE: Page adding happens *after* LoadControlSettingsAndUserConfig
|
|
// because the layout of the sheet is correct at this point.
|
|
m_pInputOutputSheet->AddPage( m_pInputPage, "Input" );
|
|
m_pInputOutputSheet->AddPage( m_pOutputPage, "Output" );
|
|
m_pInputOutputSheet->AddPage( m_pCompilePage, "Compile" );
|
|
m_pInputOutputSheet->AddPage( m_pOutputPreviewPage, "Preview" );
|
|
|
|
m_pCompile->SetEnabled( false );
|
|
m_pPublish->SetEnabled( false );
|
|
m_pAbortCompile->SetEnabled( false );
|
|
}
|
|
|
|
CAssetBuilder::~CAssetBuilder()
|
|
{
|
|
if ( m_bDestroyMakefileOnClose )
|
|
{
|
|
CleanupMakefile();
|
|
}
|
|
CleanupContextMenu();
|
|
SaveUserConfig();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Default behavior is to destroy the makefile when we close
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::DestroyMakefileOnClose( bool bEnable )
|
|
{
|
|
m_bDestroyMakefileOnClose = bEnable;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Builds a unique list of file IDs
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::BuildFileIDList( CDmeMakefile *pMakeFile, CUtlVector<DmFileId_t> &fileIds )
|
|
{
|
|
if ( !pMakeFile )
|
|
return;
|
|
|
|
// NOTE: Not hugely efficient. If the CDmeDependencyMakefile starts
|
|
// getting large, we can optimize this
|
|
DmFileId_t id = pMakeFile->GetFileId();
|
|
int nCount = fileIds.Count();
|
|
int i;
|
|
for ( i = 0; i < nCount; ++i )
|
|
{
|
|
if ( fileIds[i] == id )
|
|
break;
|
|
}
|
|
|
|
if ( i == nCount )
|
|
{
|
|
fileIds.AddToTail( id );
|
|
}
|
|
|
|
int nSourceCount = pMakeFile->GetSourceCount();
|
|
for ( int i = 0; i < nSourceCount; ++i )
|
|
{
|
|
CDmeSource *pSource = pMakeFile->GetSource(i);
|
|
BuildFileIDList( pSource->GetDependentMakefile(), fileIds );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Removes a makefile from memory
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::CleanupMakefile()
|
|
{
|
|
m_hMakefileStack.Clear();
|
|
m_pDmePanel->SetDmeElement( NULL );
|
|
m_pOututPreviewPanel->SetDmeElement( NULL );
|
|
|
|
if ( !m_hRootMakefile.Get() )
|
|
return;
|
|
|
|
// First, build a list of unique file IDs
|
|
CUtlVector<DmFileId_t> fileIds;
|
|
BuildFileIDList( m_hRootMakefile, fileIds );
|
|
|
|
CDisableUndoScopeGuard guard;
|
|
|
|
m_hRootMakefile = NULL;
|
|
|
|
int nCount = fileIds.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
if ( fileIds[i] != DMFILEID_INVALID && g_pDataModel->GetFileName( fileIds[i] )[0] )
|
|
{
|
|
g_pDataModel->RemoveFileId( fileIds[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Marks the file as dirty (or not)
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::SetDirty()
|
|
{
|
|
PostActionSignal( new KeyValues( "DmeElementChanged" ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the current makefile
|
|
//-----------------------------------------------------------------------------
|
|
CDmeMakefile *CAssetBuilder::GetMakeFile()
|
|
{
|
|
return m_hMakefile.Get();
|
|
}
|
|
|
|
CDmeMakefile *CAssetBuilder::GetRootMakeFile()
|
|
{
|
|
return m_hRootMakefile.Get();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Resets the lists; called when file name changes
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::Refresh()
|
|
{
|
|
RefreshSourceList();
|
|
RefreshOutputList();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Resets the root makefile
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::SetRootMakefile( CDmeMakefile *pMakeFile )
|
|
{
|
|
CleanupMakefile();
|
|
|
|
if ( pMakeFile )
|
|
{
|
|
m_hRootMakefile = pMakeFile;
|
|
m_hMakefileStack.Push( m_hRootMakefile );
|
|
}
|
|
SetCurrentMakefile( pMakeFile );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Resets the current makefile
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::SetCurrentMakefile( CDmeMakefile *pMakeFile )
|
|
{
|
|
m_hMakefile = pMakeFile;
|
|
m_pDmePanel->SetDmeElement( NULL );
|
|
m_pOututPreviewPanel->SetDmeElement( pMakeFile, true, "DmeMakeFileOutputPreview" );
|
|
RefreshSourceList();
|
|
RefreshOutputList();
|
|
|
|
// Lets the asset builder update the title bar
|
|
PostActionSignal( new KeyValues( "UpdateFileName" ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Hook into the DME panel framework
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::SetDmeElement( CDmeMakefile *pMakeFile )
|
|
{
|
|
SetRootMakefile( pMakeFile );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Refresh the source list
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::RefreshSourceList( )
|
|
{
|
|
m_pSourcesList->RemoveAll();
|
|
if ( !m_hMakefile.Get() )
|
|
return;
|
|
|
|
DmeMakefileType_t *pSourceTypes = m_hMakefile->GetSourceTypes();
|
|
for ( int i = 0; pSourceTypes[i].m_pTypeName; ++i )
|
|
{
|
|
CUtlVector< CDmeHandle< CDmeSource > > sources;
|
|
m_hMakefile->GetSources( pSourceTypes[i].m_pTypeName, sources );
|
|
int nCount = sources.Count();
|
|
for ( int j = 0; j < nCount; ++j )
|
|
{
|
|
char pFullPath[MAX_PATH];
|
|
m_hMakefile->GetSourceFullPath( sources[j], pFullPath, sizeof(pFullPath) );
|
|
|
|
KeyValues *pItemKeys = new KeyValues( "node", "type", pSourceTypes[i].m_pHumanReadableName );
|
|
pItemKeys->SetString( "file", pFullPath );
|
|
pItemKeys->SetInt( "sourceTypeIndex", i );
|
|
pItemKeys->SetInt( "index", j ); // for sorting in the listpanel
|
|
SetElementKeyValue( pItemKeys, "dmeSource", sources[j] );
|
|
m_pSourcesList->AddItem( pItemKeys, 0, false, false );
|
|
}
|
|
}
|
|
|
|
m_pSourcesList->SortList();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Refreshes the output list
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::RefreshOutputList()
|
|
{
|
|
m_pOutputList->RemoveAll();
|
|
m_pCompile->SetEnabled( false );
|
|
m_pPublish->SetEnabled( false );
|
|
if ( !m_hMakefile.Get() )
|
|
return;
|
|
|
|
CUtlVector<CUtlString> outputs;
|
|
m_hMakefile->GetOutputs( outputs );
|
|
int nCount = outputs.Count();
|
|
for ( int j = 0; j < nCount; ++j )
|
|
{
|
|
KeyValues *pItemKeys = new KeyValues( "node", "type", "Output" );
|
|
pItemKeys->SetString( "file", outputs[j] );
|
|
pItemKeys->SetInt( "index", j );
|
|
m_pOutputList->AddItem( pItemKeys, 0, false, false );
|
|
}
|
|
|
|
bool bEnabled = ( nCount > 0 ) && ( g_pDmeMakefileUtils != NULL );
|
|
m_pCompile->SetEnabled( bEnabled );
|
|
m_pPublish->SetEnabled( bEnabled );
|
|
|
|
m_pOutputList->SortList();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Selects a particular source
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::SelectSource( CDmeSource *pSource )
|
|
{
|
|
int nItemID = m_pSourcesList->FirstItem();
|
|
for ( ; nItemID != m_pSourcesList->InvalidItemID(); nItemID = m_pSourcesList->NextItem( nItemID ) )
|
|
{
|
|
KeyValues *kv = m_pSourcesList->GetItem( nItemID );
|
|
if ( GetElementKeyValue< CDmeSource >( kv, "dmeSource" ) != pSource )
|
|
continue;
|
|
|
|
m_pSourcesList->SetSingleSelectedItem( nItemID );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called by the picker popped up in OnFileNew
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnPicked( KeyValues *kv )
|
|
{
|
|
const char *pValue = kv->GetString( "choice" );
|
|
|
|
KeyValues *pContextKeys = kv->FindKey( "OnAddSource" );
|
|
if ( pContextKeys )
|
|
{
|
|
OnSourceFileAdded( "", pValue );
|
|
return;
|
|
}
|
|
|
|
CDisableUndoScopeGuard guard;
|
|
CDmeMakefile *pMakeFile = GetElement< CDmeMakefile >( g_pDataModel->CreateElement( pValue, "unnamed" ) );
|
|
if ( !pMakeFile )
|
|
return;
|
|
|
|
DmeMakefileType_t *pType = pMakeFile->GetMakefileType();
|
|
|
|
char pContext[MAX_PATH];
|
|
Q_snprintf( pContext, sizeof(pContext), "asset_builder_session_%s", pType->m_pTypeName );
|
|
|
|
char pStartingDir[MAX_PATH];
|
|
pMakeFile->GetDefaultDirectory( pType->m_pDefaultDirectoryID, pStartingDir, sizeof(pStartingDir) );
|
|
g_pFullFileSystem->CreateDirHierarchy( pStartingDir );
|
|
|
|
KeyValues *pDialogKeys = new KeyValues( "NewSourceFileSelected", "makefileType", pValue );
|
|
FileOpenDialog *pDialog = new FileOpenDialog( this, "Select Asset Builder File Name", false, pDialogKeys );
|
|
pDialog->SetStartDirectoryContext( pContext, pStartingDir );
|
|
pDialog->AddFilter( pType->m_pFileFilter, pType->m_pFileFilterString, true );
|
|
pDialog->SetDeleteSelfOnClose( true );
|
|
pDialog->AddActionSignalTarget( this );
|
|
pDialog->DoModal( false );
|
|
DestroyElement( pMakeFile );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Creates a new source file, hooks it in
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnNewSourceFile( )
|
|
{
|
|
KeyValues *pKeyValues = GetSelectedSourceKeyvalues();
|
|
CDmeSource *pSource = GetElementKeyValue< CDmeSource >( pKeyValues, "dmeSource" );
|
|
if ( !pSource )
|
|
return;
|
|
|
|
BuildAssetTypeList();
|
|
|
|
PickerList_t typePickerList;
|
|
PickerList_t &pickerList = BuildAssetSubTypeList( pSource->GetSourceMakefileTypes(), typePickerList );
|
|
|
|
// Create a list indicating which type of asset to create
|
|
CPickerFrame *pPicker = new CPickerFrame( this, "Select Sub-Asset Type", "Asset Type", "assetType" );
|
|
pPicker->DoModal( pickerList );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the button to add a file is clicked
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnAddSource( )
|
|
{
|
|
if ( !m_hMakefile.Get() )
|
|
return;
|
|
|
|
PickerList_t sourceType;
|
|
|
|
DmeMakefileType_t *pSourceTypes = m_hMakefile->GetSourceTypes();
|
|
for ( int i = 0; pSourceTypes[i].m_pTypeName; ++i )
|
|
{
|
|
if ( pSourceTypes[i].m_bIsSingleton )
|
|
{
|
|
if ( m_hMakefile->HasSourceOfType( pSourceTypes[i].m_pTypeName ) )
|
|
continue;
|
|
}
|
|
|
|
int j = sourceType.AddToTail( );
|
|
sourceType[j].m_pChoiceString = pSourceTypes[i].m_pHumanReadableName;
|
|
sourceType[j].m_pChoiceValue = pSourceTypes[i].m_pTypeName;
|
|
}
|
|
|
|
if ( sourceType.Count() == 0 )
|
|
return;
|
|
|
|
KeyValues *pContextKeys = new KeyValues( "OnAddSource" );
|
|
CPickerFrame *pPicker = new CPickerFrame( this, "Select Source Type", "Source Type", "sourceType" );
|
|
pPicker->DoModal( sourceType, pContextKeys );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the curerntly selected row
|
|
//-----------------------------------------------------------------------------
|
|
int CAssetBuilder::GetSelectedRow( )
|
|
{
|
|
int nItemID = m_pSourcesList->GetSelectedItem( 0 );
|
|
return ( nItemID != -1 ) ? m_pSourcesList->GetItemCurrentRow( nItemID ) : -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Selects a particular row of the source list
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::SelectSourceListRow( int nRow )
|
|
{
|
|
int nVisibleRowCount = m_pSourcesList->GetItemCount();
|
|
if ( nVisibleRowCount == 0 || nRow < 0 )
|
|
return;
|
|
|
|
if ( nRow >= nVisibleRowCount )
|
|
{
|
|
nRow = nVisibleRowCount - 1;
|
|
}
|
|
|
|
int nNewItemID = m_pSourcesList->GetItemIDFromRow( nRow );
|
|
m_pSourcesList->SetSingleSelectedItem( nNewItemID );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the button to remove a file is clicked
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnRemoveSource( )
|
|
{
|
|
int nCount = m_pSourcesList->GetSelectedItemsCount();
|
|
if ( nCount == 0 || !m_hMakefile.Get() )
|
|
return;
|
|
|
|
int nRow = GetSelectedRow();
|
|
Assert( nRow >= 0 );
|
|
|
|
// Update the selection to be reasonable after deletion
|
|
CDisableUndoScopeGuard guard;
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
int nItemID = m_pSourcesList->GetSelectedItem( i );
|
|
KeyValues *pKeyValues = m_pSourcesList->GetItem( nItemID );
|
|
CDmeSource *pSource = GetElementKeyValue< CDmeSource >( pKeyValues, "dmeSource" );
|
|
if ( pSource )
|
|
{
|
|
m_hMakefile->RemoveSource( pSource );
|
|
DestroyElement( pSource );
|
|
SetDirty( );
|
|
}
|
|
}
|
|
|
|
RefreshSourceList();
|
|
|
|
SelectSourceListRow( nRow );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called to make a particular source the currently selected source
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnZoomInSource()
|
|
{
|
|
// Called to zoom into the currently selected source
|
|
CDmeSource *pSource = GetSelectedSource( );
|
|
if ( !pSource )
|
|
return;
|
|
|
|
CDmeMakefile *pChild = m_hMakefile->FindDependentMakefile( pSource );
|
|
if ( pChild )
|
|
{
|
|
CDmeHandle< CDmeMakefile > hChild;
|
|
hChild = pChild;
|
|
m_hMakefileStack.Push( hChild );
|
|
SetCurrentMakefile( pChild );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called to zoom out of a particular source
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnZoomOutSource()
|
|
{
|
|
// Called to zoom into the currently selected source
|
|
if ( m_hMakefileStack.Count() <= 1 )
|
|
return;
|
|
|
|
CDmeMakefile *pOldParent = m_hMakefileStack.Top().Get();
|
|
m_hMakefileStack.Pop( );
|
|
CDmeMakefile *pParent = m_hMakefileStack.Top().Get();
|
|
if ( pParent )
|
|
{
|
|
SetCurrentMakefile( pParent );
|
|
CDmeSource *pSource = pParent->FindAssociatedSource( pOldParent );
|
|
if ( pSource )
|
|
{
|
|
SelectSource( pSource );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when a key is typed
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnKeyCodeTyped( vgui::KeyCode code )
|
|
{
|
|
if ( code == KEY_DELETE )
|
|
{
|
|
OnRemoveSource();
|
|
return;
|
|
}
|
|
|
|
if ( code == KEY_ENTER )
|
|
{
|
|
OnZoomInSource();
|
|
return;
|
|
}
|
|
|
|
BaseClass::OnKeyCodeTyped( code );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when we're browsing for a source file and one was selected
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnSourceFileAdded( const char *pFileName, const char *pTypeName )
|
|
{
|
|
CDmeSource *pSource = NULL;
|
|
{
|
|
CDisableUndoScopeGuard guard;
|
|
pSource = m_hMakefile->AddSource( pTypeName, pFileName );
|
|
}
|
|
SetDirty( );
|
|
RefreshSourceList( );
|
|
SelectSource( pSource );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the file open dialog for browsing source files selects something
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnNewSourceFileSelected( const char *pFileName, KeyValues *kv )
|
|
{
|
|
int nCount = m_pSourcesList->GetSelectedItemsCount();
|
|
if ( nCount != 1 || !m_hMakefile.Get() )
|
|
return;
|
|
|
|
int nItemID = m_pSourcesList->GetSelectedItem( 0 );
|
|
KeyValues *pKeyValues = m_pSourcesList->GetItem( nItemID );
|
|
CDmeSource *pSource = GetElementKeyValue< CDmeSource >( pKeyValues, "dmeSource" );
|
|
if ( !pSource )
|
|
return;
|
|
|
|
const char *pMakeFileType = kv->GetString( "makefileType" );
|
|
|
|
{
|
|
CDisableUndoScopeGuard guard;
|
|
m_hMakefile->SetSourceFullPath( pSource, pFileName );
|
|
|
|
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( pFileName );
|
|
CDmeMakefile *pSourceMakeFile = CreateElement< CDmeMakefile >( pMakeFileType, pFileName, fileid );
|
|
pSourceMakeFile->SetFileName( pFileName );
|
|
|
|
m_hMakefile->SetAssociation( pSource, pSourceMakeFile );
|
|
SetDirty( );
|
|
}
|
|
|
|
pKeyValues->SetString( "file", pFileName );
|
|
m_pSourcesList->ApplyItemChanges( nItemID );
|
|
m_pSourcesList->SortList();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the file open dialog for browsing source files selects something
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnFileSelected( KeyValues *kv )
|
|
{
|
|
const char *pFileName = kv->GetString( "fullpath", NULL );
|
|
if ( !pFileName )
|
|
return;
|
|
|
|
KeyValues *pDialogKeys = kv->FindKey( "SelectSourceFile" );
|
|
if ( pDialogKeys )
|
|
{
|
|
OnSourceFileNameChanged( pFileName );
|
|
return;
|
|
}
|
|
|
|
pDialogKeys = kv->FindKey( "NewSourceFileSelected" );
|
|
if ( pDialogKeys )
|
|
{
|
|
if ( !g_pFullFileSystem->FileExists( pFileName ) )
|
|
{
|
|
OnNewSourceFileSelected( pFileName, pDialogKeys );
|
|
}
|
|
else
|
|
{
|
|
OnSourceFileNameChanged( pFileName );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Shows the source file browser
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::ShowSourceFileBrowser( const char *pTitle, DmeMakefileType_t *pSourceType, KeyValues *pDialogKeys )
|
|
{
|
|
char pContext[MAX_PATH];
|
|
Q_snprintf( pContext, sizeof(pContext), "asset_builder_session_%s", pSourceType->m_pTypeName );
|
|
|
|
char pStartingDir[MAX_PATH];
|
|
m_hMakefile->GetDefaultDirectory( pSourceType->m_pDefaultDirectoryID, pStartingDir, sizeof(pStartingDir) );
|
|
g_pFullFileSystem->CreateDirHierarchy( pStartingDir );
|
|
|
|
FileOpenDialog *pDialog = new FileOpenDialog( this, pTitle, true, pDialogKeys );
|
|
pDialog->SetStartDirectoryContext( pContext, pStartingDir );
|
|
pDialog->AddFilter( pSourceType->m_pFileFilter, pSourceType->m_pFileFilterString, true );
|
|
pDialog->SetDeleteSelfOnClose( true );
|
|
pDialog->AddActionSignalTarget( this );
|
|
pDialog->DoModal( false );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the button to browse for a source file is clicked
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnBrowseSourceFile( )
|
|
{
|
|
KeyValues *pKeyValues = GetSelectedSourceKeyvalues();
|
|
if ( !pKeyValues )
|
|
return;
|
|
|
|
int nSourceTypeIndex = pKeyValues->GetInt( "sourceTypeIndex", -1 );
|
|
|
|
KeyValues *pDialogKeys = new KeyValues( "SelectSourceFile" );
|
|
DmeMakefileType_t &sourceType = m_hMakefile->GetSourceTypes()[nSourceTypeIndex];
|
|
ShowSourceFileBrowser( "Select Source File", &sourceType, pDialogKeys );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Command handler
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnCommand( const char *pCommand )
|
|
{
|
|
if ( !Q_stricmp( pCommand, "OnCompile" ) )
|
|
{
|
|
OnCompile();
|
|
return;
|
|
}
|
|
|
|
if ( !Q_stricmp( pCommand, "OnAbortCompile" ) )
|
|
{
|
|
OnAbortCompile();
|
|
return;
|
|
}
|
|
|
|
if ( !Q_stricmp( pCommand, "OnPublish" ) )
|
|
{
|
|
OnPublish();
|
|
return;
|
|
}
|
|
|
|
BaseClass::OnCommand( pCommand );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Cleans up the context menu
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::CleanupContextMenu()
|
|
{
|
|
if ( m_hContextMenu.Get() )
|
|
{
|
|
m_hContextMenu->MarkForDeletion();
|
|
m_hContextMenu = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called to open a context-sensitive menu for a particular menu item
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnOpenContextMenu( KeyValues *kv )
|
|
{
|
|
CleanupContextMenu();
|
|
if ( !m_hMakefile.Get() )
|
|
return;
|
|
|
|
Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL );
|
|
int nItemID = kv->GetInt( "itemID", -1 );
|
|
|
|
if ( pPanel != m_pSourcesList )
|
|
return;
|
|
|
|
m_hContextMenu = new Menu( this, "ActionMenu" );
|
|
m_hContextMenu->AddMenuItem( "Add...", new KeyValues( "AddSource" ), this );
|
|
int nCount = m_pSourcesList->GetSelectedItemsCount();
|
|
if ( nCount > 0 )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "Remove", new KeyValues( "RemoveSource" ), this );
|
|
}
|
|
|
|
bool bShowZoomIn = false;
|
|
bool bShowZoomOut = m_hMakefileStack.Count() > 1;
|
|
bool bShowLoadSourceFile = false;
|
|
bool bHasValidSourceFile = false;
|
|
if ( nCount == 1 && nItemID != -1 )
|
|
{
|
|
KeyValues *kv = m_pSourcesList->GetItem( nItemID );
|
|
CDmeSource *pSource = GetElementKeyValue< CDmeSource >( kv, "dmeSource" );
|
|
if ( pSource )
|
|
{
|
|
bHasValidSourceFile = pSource->GetRelativeFileName()[0] != 0;
|
|
if ( m_hMakefile->FindDependentMakefile( pSource ) )
|
|
{
|
|
bShowZoomIn = true;
|
|
}
|
|
else
|
|
{
|
|
bShowLoadSourceFile = bHasValidSourceFile;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bShowZoomIn || bShowZoomOut )
|
|
{
|
|
m_hContextMenu->AddSeparator();
|
|
if ( bShowZoomIn )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "Zoom In", new KeyValues( "ZoomInSource" ), this );
|
|
}
|
|
if ( bShowZoomOut )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "Zoom Out", new KeyValues( "ZoomOutSource" ), this );
|
|
}
|
|
}
|
|
|
|
if ( nCount == 1 )
|
|
{
|
|
m_hContextMenu->AddSeparator();
|
|
m_hContextMenu->AddMenuItem( "New Source File...", new KeyValues( "NewSourceFile" ), this );
|
|
m_hContextMenu->AddMenuItem( "Select Source File...", new KeyValues( "BrowseSourceFile" ), this );
|
|
if ( bShowLoadSourceFile )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "Load Source File", new KeyValues( "LoadSourceFile" ), this );
|
|
}
|
|
if ( bHasValidSourceFile )
|
|
{
|
|
m_hContextMenu->AddMenuItem( "Edit Source File", new KeyValues( "EditSourceFile" ), this );
|
|
}
|
|
}
|
|
|
|
Menu::PlaceContextMenu( this, m_hContextMenu.Get() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when a list panel's selection changes
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnSourceItemSelectionChanged( )
|
|
{
|
|
int nCount = m_pSourcesList->GetSelectedItemsCount();
|
|
if ( nCount != 1 )
|
|
{
|
|
m_pDmePanel->SetDmeElement( NULL );
|
|
return;
|
|
}
|
|
|
|
int nItemID = m_pSourcesList->GetSelectedItem( 0 );
|
|
KeyValues *pKeyValues = m_pSourcesList->GetItem( nItemID );
|
|
CDmeSource *pSource = GetElementKeyValue< CDmeSource >( pKeyValues, "dmeSource" );
|
|
m_pDmePanel->SetDmeElement( pSource );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when a list panel's selection changes
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnItemSelected( KeyValues *kv )
|
|
{
|
|
Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL );
|
|
if ( pPanel == m_pSourcesList )
|
|
{
|
|
OnSourceItemSelectionChanged();
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when a list panel's selection changes
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnItemDeselected( KeyValues *kv )
|
|
{
|
|
Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL );
|
|
if ( pPanel == m_pSourcesList )
|
|
{
|
|
OnSourceItemSelectionChanged();
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the selected source (if there's only 1 source selected)
|
|
//-----------------------------------------------------------------------------
|
|
CDmeSource *CAssetBuilder::GetSelectedSource( )
|
|
{
|
|
int nCount = m_pSourcesList->GetSelectedItemsCount();
|
|
if ( nCount != 1 || !m_hMakefile.Get() )
|
|
return NULL;
|
|
|
|
int nItemID = m_pSourcesList->GetSelectedItem( 0 );
|
|
KeyValues *pKeyValues = m_pSourcesList->GetItem( nItemID );
|
|
return GetElementKeyValue< CDmeSource >( pKeyValues, "dmeSource" );
|
|
}
|
|
|
|
KeyValues *CAssetBuilder::GetSelectedSourceKeyvalues( )
|
|
{
|
|
int nCount = m_pSourcesList->GetSelectedItemsCount();
|
|
if ( nCount != 1 || !m_hMakefile.Get() )
|
|
return NULL;
|
|
|
|
int nItemID = m_pSourcesList->GetSelectedItem( 0 );
|
|
return m_pSourcesList->GetItem( nItemID );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the source file name changes
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnSourceFileNameChanged( const char *pFileName )
|
|
{
|
|
int nCount = m_pSourcesList->GetSelectedItemsCount();
|
|
if ( nCount != 1 || !m_hMakefile.Get() )
|
|
return;
|
|
|
|
int nItemID = m_pSourcesList->GetSelectedItem( 0 );
|
|
KeyValues *pKeyValues = m_pSourcesList->GetItem( nItemID );
|
|
CDmeSource *pSource = GetElementKeyValue< CDmeSource >( pKeyValues, "dmeSource" );
|
|
if ( !pSource )
|
|
return;
|
|
|
|
{
|
|
CDisableUndoScopeGuard guard;
|
|
m_hMakefile->SetSourceFullPath( pSource, pFileName );
|
|
SetDirty( );
|
|
}
|
|
|
|
pKeyValues->SetString( "file", pFileName );
|
|
m_pSourcesList->ApplyItemChanges( nItemID );
|
|
m_pSourcesList->SortList();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called during compilation
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnLoadSourceFile()
|
|
{
|
|
CDmeSource *pSource = GetSelectedSource( );
|
|
if ( !pSource )
|
|
return;
|
|
|
|
char pFullPath[MAX_PATH];
|
|
m_hMakefile->GetSourceFullPath( pSource, pFullPath, sizeof(pFullPath) );
|
|
|
|
{
|
|
CDisableUndoScopeGuard guard;
|
|
|
|
CDmElement *pRoot;
|
|
CDmeMakefile *pMakeFile = ReadMakefile( pFullPath, &pRoot );
|
|
if ( !pMakeFile )
|
|
return;
|
|
|
|
// Successfully loaded a makefile. Set up the association.
|
|
m_hMakefile->SetAssociation( pSource, pMakeFile );
|
|
|
|
// Refresh the dme panel... setting association could provoke changes
|
|
m_pDmePanel->SetDmeElement( pSource, true );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called to open an external editor for this source file
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnEditSourceFile()
|
|
{
|
|
CDmeSource *pSource = GetSelectedSource( );
|
|
if ( pSource )
|
|
{
|
|
pSource->OpenEditor();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finishes compilation
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::FinishCompilation( CompilationState_t state )
|
|
{
|
|
// NOTE: compilation can cause the makefile to be completely
|
|
// rebuilt if it's sitting in the output file. Therefore,
|
|
// Detach the source preview panel from the source and refresh the
|
|
// source list to get it to correctly reconnect to the new source elements
|
|
m_pDmePanel->SetDmeElement( NULL );
|
|
int nRow = GetSelectedRow();
|
|
|
|
m_pOututPreviewPanel->SetDmeElement( m_hMakefile, true, "DmeMakeFileOutputPreview" );
|
|
m_bIsCompiling = false;
|
|
|
|
// NOTE: Sort of side-effecty. These two things must be done after
|
|
// m_pOututPreviewPanel->SetDmeElement, since that's what reloads the output element,
|
|
// which is also what can cause a reload of the makefile
|
|
RefreshSourceList();
|
|
SelectSourceListRow( nRow );
|
|
|
|
// Lets the asset builder update the title bar
|
|
// (compilation could have changed the dirty state if the makefile is in the file)
|
|
PostActionSignal( new KeyValues( "UpdateFileName" ) );
|
|
|
|
if ( state == COMPILATION_FAILED )
|
|
{
|
|
char pBuf[256];
|
|
Q_snprintf( pBuf, sizeof(pBuf), "Compilation Error (return code %d)", g_pDmeMakefileUtils->GetExitCode() );
|
|
m_pCompileStatusBar->SetStatus( CCompileStatusBar::COMPILATION_FAILED, pBuf );
|
|
}
|
|
else
|
|
{
|
|
m_pCompileStatusBar->SetStatus( CCompileStatusBar::COMPILATION_SUCCESSFUL, "Compile Successful!" );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called during compilation
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnTick()
|
|
{
|
|
BaseClass::OnTick();
|
|
|
|
if ( m_bIsCompiling )
|
|
{
|
|
int nLen = g_pDmeMakefileUtils->GetCompileOutputSize( );
|
|
char *pBuf = (char*)_alloca( nLen+1 );
|
|
CompilationState_t state = g_pDmeMakefileUtils->UpdateCompilation( pBuf, nLen );
|
|
if ( nLen > 0 )
|
|
{
|
|
m_pCompileOutput->InsertString( pBuf );
|
|
}
|
|
Assert( m_hMakefile.Get() );
|
|
if ( state != COMPILATION_NOT_COMPLETE )
|
|
{
|
|
FinishCompilation( state );
|
|
}
|
|
}
|
|
|
|
if ( !m_bIsCompiling )
|
|
{
|
|
m_pAbortCompile->SetEnabled( false );
|
|
vgui::ivgui()->RemoveTickSignal( GetVPanel() );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Abort compile asset
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnAbortCompile()
|
|
{
|
|
if ( m_bIsCompiling )
|
|
{
|
|
g_pDmeMakefileUtils->AbortCurrentCompilation();
|
|
m_bIsCompiling = false;
|
|
m_pAbortCompile->SetEnabled( false );
|
|
m_pCompileStatusBar->SetStatus( CCompileStatusBar::COMPILATION_FAILED, "Compile Aborted" );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compile asset
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnCompile( )
|
|
{
|
|
if ( !m_hMakefile.Get() )
|
|
return;
|
|
|
|
OnAbortCompile();
|
|
|
|
m_pCompileOutput->SetText( "" );
|
|
g_pDmeMakefileUtils->PerformCompile( m_hMakefile, false );
|
|
m_bIsCompiling = true;
|
|
m_pAbortCompile->SetEnabled( true );
|
|
m_pCompileStatusBar->SetStatus( CCompileStatusBar::CURRENTLY_COMPILING, "Compiling..." );
|
|
|
|
vgui::ivgui()->AddTickSignal( GetVPanel(), 10 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compile, then publish
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilder::OnPublish( )
|
|
{
|
|
if ( !m_hMakefile.Get() )
|
|
return;
|
|
|
|
OnAbortCompile();
|
|
|
|
m_pCompileOutput->SetText( "" );
|
|
g_pDmeMakefileUtils->PerformCompile( m_hMakefile, false );
|
|
m_bIsCompiling = true;
|
|
m_pAbortCompile->SetEnabled( true );
|
|
m_pCompileStatusBar->SetStatus( CCompileStatusBar::CURRENTLY_COMPILING, "Compiling..." );
|
|
vgui::ivgui()->AddTickSignal( GetVPanel(), 10 );
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
CAssetBuilderFrame::CAssetBuilderFrame( vgui::Panel *pParent, const char *pTitle ) :
|
|
BaseClass( pParent, "AssetBuilderFrame" )
|
|
{
|
|
m_TitleString = pTitle;
|
|
|
|
SetMenuButtonVisible( true );
|
|
SetImages( "resource/downarrow" );
|
|
|
|
m_pAssetBuilder = new CAssetBuilder( this, "AssetBuilder" );
|
|
m_pAssetBuilder->AddActionSignalTarget( this );
|
|
|
|
vgui::Menu *pMenu = new vgui::Menu( NULL, "FileMenu" );
|
|
pMenu->AddMenuItem( "new", "#AssetBuilder_FileNew", new KeyValues( "FileNew" ), this );
|
|
pMenu->AddMenuItem( "open", "#AssetBuilder_FileOpen", new KeyValues( "FileOpen" ), this );
|
|
pMenu->AddMenuItem( "save", "#AssetBuilder_FileSave", new KeyValues( "FileSave" ), this );
|
|
pMenu->AddMenuItem( "saveas", "#AssetBuilder_FileSaveAs", new KeyValues( "FileSaveAs" ), this );
|
|
SetSysMenu( pMenu );
|
|
|
|
m_pFileOpenStateMachine = new vgui::FileOpenStateMachine( this, this );
|
|
m_pFileOpenStateMachine->AddActionSignalTarget( this );
|
|
|
|
// Load layout settings; has to happen before pinning occurs in code
|
|
LoadControlSettingsAndUserConfig( "resource/assetbuilderframe.res" );
|
|
|
|
UpdateFileName();
|
|
}
|
|
|
|
CAssetBuilderFrame::~CAssetBuilderFrame()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Inherited from IFileOpenStateMachineClient
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::SetupFileOpenDialog( vgui::FileOpenDialog *pDialog, bool bOpenFile, const char *pFileFormat, KeyValues *pContextKeyValues )
|
|
{
|
|
// Compute starting directory
|
|
char pStartingDir[ MAX_PATH ];
|
|
GetModContentSubdirectory( "", pStartingDir, sizeof(pStartingDir) );
|
|
|
|
if ( bOpenFile )
|
|
{
|
|
// Clear out the existing makefile if we're opening a file
|
|
m_pAssetBuilder->SetRootMakefile( NULL );
|
|
pDialog->SetTitle( "Open Asset MakeFile", true );
|
|
}
|
|
else
|
|
{
|
|
pDialog->SetTitle( "Save Asset MakeFile As", true );
|
|
}
|
|
|
|
pDialog->SetStartDirectoryContext( "asset_browser_makefile", pStartingDir );
|
|
pDialog->AddFilter( "*.*", "All Files (*.*)", false );
|
|
pDialog->AddFilter( "*.dmx", "Asset MakeFiles (*.dmx)", true, "keyvalues2" );
|
|
}
|
|
|
|
bool CAssetBuilderFrame::OnReadFileFromDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues )
|
|
{
|
|
CDmElement *pRoot;
|
|
CDmeMakefile *pMakeFile = ReadMakefile( pFileName, &pRoot );
|
|
if ( !pMakeFile )
|
|
return false;
|
|
|
|
Reset( pMakeFile );
|
|
return true;
|
|
}
|
|
|
|
bool CAssetBuilderFrame::OnWriteFileToDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues )
|
|
{
|
|
// Recompute relative paths for each source now that we know the file name
|
|
// NOTE: This also updates the name of the fileID in the datamodel system
|
|
CDmeMakefile *pMakefile = m_pAssetBuilder->GetMakeFile();
|
|
bool bOk;
|
|
{
|
|
CDisableUndoScopeGuard guard;
|
|
bOk = pMakefile->SetFileName( pFileName );
|
|
}
|
|
if ( !bOk )
|
|
{
|
|
vgui::MessageBox *pError = new vgui::MessageBox( "#AssetBuilder_CannotRenameSourceFiles", "#AssetBuilder_CannotRenameSourceFilesText", this );
|
|
pError->DoModal();
|
|
return false;
|
|
}
|
|
|
|
CDmElement *pRoot = GetElement< CDmElement >( g_pDataModel->GetFileRoot( pMakefile->GetFileId() ) );
|
|
if ( !pRoot )
|
|
{
|
|
pRoot = pMakefile;
|
|
}
|
|
bOk = g_pDataModel->SaveToFile( pFileName, NULL, g_pDataModel->GetDefaultEncoding( pFileFormat ), pFileFormat, pRoot );
|
|
m_pAssetBuilder->Refresh();
|
|
return bOk;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Updates the file name
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::UpdateFileName( )
|
|
{
|
|
CDmeMakefile *pMakeFile = m_pAssetBuilder->GetMakeFile();
|
|
if ( !pMakeFile )
|
|
{
|
|
SetTitle( m_TitleString.Get(), true );
|
|
return;
|
|
}
|
|
|
|
DmeMakefileType_t *pMakefileType = pMakeFile->GetMakefileType();
|
|
|
|
DmFileId_t fileId = pMakeFile->GetFileId();
|
|
const char *pFileName = ( fileId != DMFILEID_INVALID ) ? g_pDataModel->GetFileName( fileId ) : "<unnamed>";
|
|
if ( !pFileName || !pFileName[0] )
|
|
{
|
|
pFileName = "<unnamed>";
|
|
}
|
|
|
|
char pBuf[2*MAX_PATH];
|
|
if ( m_TitleString.Get() )
|
|
{
|
|
Q_snprintf( pBuf, sizeof(pBuf), "%s - %s - %s%s", m_TitleString.Get(), pMakefileType->m_pHumanReadableName, pFileName, pMakeFile->IsDirty() ? " *" : "" );
|
|
}
|
|
else
|
|
{
|
|
Q_snprintf( pBuf, sizeof(pBuf), "%s - %s%s", pMakefileType->m_pHumanReadableName, pFileName, pMakeFile->IsDirty() ? " *" : "" );
|
|
}
|
|
SetTitle( pBuf, true );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Marks the file as dirty (or not)
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::SetDirty( bool bDirty )
|
|
{
|
|
CDmeMakefile *pMakeFile = m_pAssetBuilder->GetMakeFile();
|
|
if ( pMakeFile && ( pMakeFile->IsDirty() != bDirty ) )
|
|
{
|
|
pMakeFile->SetDirty( bDirty );
|
|
|
|
// Necessary because we draw a * if it's dirty before the name
|
|
UpdateFileName();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the asset builder changes something
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::OnDmeElementChanged()
|
|
{
|
|
SetDirty( true );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Resets the state
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::Reset( CDmeMakefile *pMakeFile )
|
|
{
|
|
// NOTE: Don't need to call SetDirty because we call UpdateFileName below
|
|
m_pAssetBuilder->SetRootMakefile( pMakeFile );
|
|
UpdateFileName();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the file open dialog for selecting the new asset name is selected
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::OnPerformFileNew( KeyValues *kv )
|
|
{
|
|
const char *pMakefileType = kv->GetString( "makefileType" );
|
|
const char *pFileName = kv->GetString( "fileName" );
|
|
CDmeMakefile *pMakeFile;
|
|
{
|
|
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( pFileName );
|
|
CDisableUndoScopeGuard guard;
|
|
pMakeFile = CreateElement< CDmeMakefile >( pMakefileType, pFileName, fileid );
|
|
}
|
|
if ( !pMakeFile )
|
|
return;
|
|
|
|
pMakeFile->SetFileName( pFileName );
|
|
Reset( pMakeFile );
|
|
SetDirty( true );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the file open dialog for browsing source files selects something
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::OnFileSelected( KeyValues *kv )
|
|
{
|
|
const char *pFileName = kv->GetString( "fullpath", NULL );
|
|
if ( !pFileName )
|
|
return;
|
|
|
|
KeyValues *pDialogKeys = kv->FindKey( "OnFileNew" );
|
|
if ( pDialogKeys )
|
|
{
|
|
KeyValues *pOkCommand = new KeyValues( "PerformFileNew", "makefileType", pDialogKeys->GetString( "makefileType" ) );
|
|
pOkCommand->SetString( "fileName", pFileName );
|
|
OverwriteFileDialog( this, pFileName, pOkCommand );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called by the picker popped up in OnFileNew
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::OnPicked( KeyValues *kv )
|
|
{
|
|
const char *pValue = kv->GetString( "choice" );
|
|
|
|
CDisableUndoScopeGuard guard;
|
|
CDmeMakefile *pMakeFile = GetElement< CDmeMakefile >( g_pDataModel->CreateElement( pValue, "unnamed" ) );
|
|
if ( !pMakeFile )
|
|
return;
|
|
|
|
DmeMakefileType_t *pType = pMakeFile->GetMakefileType();
|
|
|
|
char pContext[MAX_PATH];
|
|
Q_snprintf( pContext, sizeof(pContext), "asset_builder_session_%s", pType->m_pTypeName );
|
|
|
|
char pStartingDir[MAX_PATH];
|
|
pMakeFile->GetDefaultDirectory( pType->m_pDefaultDirectoryID, pStartingDir, sizeof(pStartingDir) );
|
|
g_pFullFileSystem->CreateDirHierarchy( pStartingDir );
|
|
|
|
char pTitle[MAX_PATH];
|
|
Q_snprintf( pTitle, sizeof(pTitle), "Select %s File Name", pType->m_pHumanReadableName );
|
|
|
|
KeyValues *pDialogKeys = new KeyValues( "OnFileNew", "makefileType", pValue );
|
|
FileOpenDialog *pDialog = new FileOpenDialog( this, pTitle, false, pDialogKeys );
|
|
pDialog->SetStartDirectoryContext( pContext, pStartingDir );
|
|
pDialog->AddFilter( pType->m_pFileFilter, pType->m_pFileFilterString, true );
|
|
pDialog->SetDeleteSelfOnClose( true );
|
|
pDialog->AddActionSignalTarget( this );
|
|
pDialog->DoModal( false );
|
|
DestroyElement( pMakeFile );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called by the file open state machine when an operation has completed
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::OnFileStateMachineFinished( KeyValues *pKeyValues )
|
|
{
|
|
KeyValues *pNewFile = pKeyValues->FindKey( "FileNew" );
|
|
if ( pNewFile )
|
|
{
|
|
if ( pKeyValues->GetInt( "wroteFile", 0 ) != 0 )
|
|
{
|
|
SetDirty( false );
|
|
UpdateFileName();
|
|
}
|
|
if ( pKeyValues->GetInt( "completionState", FileOpenStateMachine::IN_PROGRESS ) == FileOpenStateMachine::SUCCESSFUL )
|
|
{
|
|
ShowNewAssetPicker();
|
|
}
|
|
return;
|
|
}
|
|
|
|
KeyValues *pSaveFile = pKeyValues->FindKey( "FileSave" );
|
|
if ( pSaveFile )
|
|
{
|
|
if ( pKeyValues->GetInt( "wroteFile", 0 ) != 0 )
|
|
{
|
|
SetDirty( false );
|
|
UpdateFileName();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Shows a picker for creating a new asset
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::ShowNewAssetPicker( )
|
|
{
|
|
BuildAssetTypeList();
|
|
|
|
// Create a list indicating which type of asset to create
|
|
CPickerFrame *pPicker = new CPickerFrame( this, "Select Asset Type", "Asset Type", "assetType" );
|
|
pPicker->DoModal( s_AssetTypes );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Creates a new file
|
|
//-----------------------------------------------------------------------------
|
|
void CAssetBuilderFrame::OnFileNew( )
|
|
{
|
|
CDmeMakefile *pMakeFile = m_pAssetBuilder->GetMakeFile();
|
|
if ( pMakeFile && pMakeFile->IsDirty() )
|
|
{
|
|
KeyValues *pContextKeyValues = new KeyValues( "FileNew" );
|
|
const char *pFileName = g_pDataModel->GetFileName( pMakeFile->GetFileId() );
|
|
m_pFileOpenStateMachine->SaveFile( pContextKeyValues, pFileName, ASSET_FILE_FORMAT, FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY );
|
|
return;
|
|
}
|
|
|
|
ShowNewAssetPicker();
|
|
}
|
|
|
|
void CAssetBuilderFrame::OnFileOpen( )
|
|
{
|
|
int nFlags = 0;
|
|
const char *pFileName = NULL;
|
|
CDmeMakefile *pMakeFile = m_pAssetBuilder->GetMakeFile();
|
|
if ( pMakeFile && pMakeFile->IsDirty() )
|
|
{
|
|
nFlags = FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY;
|
|
pFileName = g_pDataModel->GetFileName( pMakeFile->GetFileId() );
|
|
}
|
|
KeyValues *pContextKeyValues = new KeyValues( "FileOpen" );
|
|
m_pFileOpenStateMachine->OpenFile( ASSET_FILE_FORMAT, pContextKeyValues, pFileName, NULL, nFlags );
|
|
}
|
|
|
|
void CAssetBuilderFrame::OnFileSave( )
|
|
{
|
|
CDmeMakefile *pMakeFile = m_pAssetBuilder->GetMakeFile();
|
|
if ( !pMakeFile )
|
|
return;
|
|
|
|
KeyValues *pContextKeyValues = new KeyValues( "FileSave" );
|
|
const char *pFileName = g_pDataModel->GetFileName( pMakeFile->GetFileId() );
|
|
m_pFileOpenStateMachine->SaveFile( pContextKeyValues, pFileName, ASSET_FILE_FORMAT, FOSM_SHOW_PERFORCE_DIALOGS );
|
|
}
|
|
|
|
void CAssetBuilderFrame::OnFileSaveAs( )
|
|
{
|
|
CDmeMakefile *pMakeFile = m_pAssetBuilder->GetMakeFile();
|
|
if ( !pMakeFile )
|
|
return;
|
|
|
|
KeyValues *pContextKeyValues = new KeyValues( "FileSave" );
|
|
m_pFileOpenStateMachine->SaveFile( pContextKeyValues, NULL, ASSET_FILE_FORMAT, FOSM_SHOW_PERFORCE_DIALOGS );
|
|
}
|
|
|
|
|