csgo/cstrike15_src/hammer/foundrytool.cpp

//====== Copyright � 1996-2005, Valve Corporation, All rights reserved. =======
//
// Purpose: Core Movie Maker UI API
//
//=============================================================================

#include "stdafx.h"
#include "hammer.h"
#include "mapview3d.h"
#include <direct.h>
#include "mapdoc.h"
#include "foundrytool.h"
#include "appframework/AppFramework.h"
#include "vphysics_interface.h"
#include "datacache/idatacache.h"
#include "toolutils/basetoolsystem.h"
#include "toolutils/recentfilelist.h"
#include "toolutils/toolmenubar.h"
#include "toolutils/toolswitchmenubutton.h"
#include "toolutils/tooleditmenubutton.h"
#include "toolutils/miniviewport.h"
#include "toolutils/toolfilemenubutton.h"
#include "toolutils/toolmenubutton.h"
#include "vgui_controls/Menu.h"
#include "tier1/KeyValues.h"
#include "toolutils/enginetools_int.h"
#include "toolframework/ienginetool.h"
#include "vgui/IInput.h"
#include "vgui/KeyCode.h"
#include "vgui_controls/FileOpenDialog.h"
#include "filesystem.h"
#include "vgui/ilocalize.h"
#include "dme_controls/elementpropertiestree.h"
#include "tier0/icommandline.h"
#include "materialsystem/imaterialsystem.h"
#include "vguimatsurface/imatsystemsurface.h"
#include "toolutils/savewindowpositions.h"
#include "toolutils/toolwindowfactory.h"
#include "tier3/tier3.h"
#include "tier2/fileutils.h"
#include "vgui/ivgui.h"
#include "ihammer.h"
#include "mainfrm.h"
#include "vgui/keycode.h"
#include "saveinfo.h"
#include "foundry/iserverfoundry.h"
#include "mapworld.h"
#include "ToolManager.h"
#include "map_shared.h"
#include "scriplib.h"


using namespace vgui;


class CFoundryViewMenuButton;


//-----------------------------------------------------------------------------
// Singleton interfaces
//-----------------------------------------------------------------------------

const char *GetVGuiControlsModuleName()
{
	return "FoundryTool";
}

//-----------------------------------------------------------------------------
// Connect, disconnect
//-----------------------------------------------------------------------------
CreateInterfaceFn g_MainFactory = NULL;
bool ConnectTools( CreateInterfaceFn factory )
{
	g_MainFactory = factory;
	return (materials != NULL) && (g_pMatSystemSurface != NULL);
}

void DisconnectTools( )
{
}


//-----------------------------------------------------------------------------
// Implementation of the Foundry tool
//-----------------------------------------------------------------------------
class CFoundryTool : public CBaseToolSystem, public IServerFoundry, public IFileMenuCallbacks, public IFoundryTool
{
	DECLARE_CLASS_SIMPLE( CFoundryTool, CBaseToolSystem );

public:
	friend class CFoundryViewport;

	CFoundryTool();

	// Inherited from IToolSystem
	virtual const char *GetToolName() { return "Foundry"; }
	virtual const char *GetBindingsContextFile() { return "cfg/Foundry.kb"; }
	virtual bool	Init( );
    virtual void	Shutdown();
	virtual bool	CanQuit( const char *pExitMsg );
	virtual void	OnToolActivate();
	virtual void	OnToolDeactivate();
	virtual void*	QueryInterface( const char *pInterfaceName );
	virtual void	ClientLevelInitPostEntity();
	virtual void	ClientLevelShutdownPreEntity();

	virtual void	ClientPostRender();
	virtual bool	SetupEngineView( Vector &origin, QAngle &angles, float &fov );
	virtual bool	TrapKey( ButtonCode_t key, bool down );

	// Inherited from IServerFoundry.
	virtual bool	GetRestoredEntityReplacementData( int iHammerID, CUtlVector<char> &data );
	virtual void	OnFinishedRestoreSavegame();
	virtual void	MoveEntityTo( int nHammerID, const Vector &vPos, const QAngle &vAngles );
	virtual void	MoveHammerViewTo( const Vector &vPos, const QAngle &vAngles );
	virtual void	EngineGetMouseControl();
	virtual void	EngineReleaseMouseControl();
	virtual void	SelectEntities( int *pHammerIDs, int nIDs );
	virtual void	SelectionClickInCenterOfView( const Vector &vPos, const QAngle &vAngles );

	// Inherited from IFileMenuCallbacks
	virtual int		GetFileMenuItemsEnabled( );
	virtual void	AddRecentFilesToMenu( vgui::Menu *menu );
	virtual bool	GetPerforceFileName( char *pFileName, int nMaxLen );

	// Inherited from IFoundryDocCallback
	virtual void	OnDocChanged( const char *pReason, int nNotifySource, int nNotifyFlags );
	virtual vgui::Panel *GetRootPanel() { return this; }

	// Inherited from CBaseToolSystem
	virtual vgui::HScheme GetToolScheme();
	virtual vgui::Menu *CreateActionMenu( vgui::Panel *pParent );
	virtual void OnCommand( const char *cmd );
	virtual const char *GetRegistryName() { return "FoundryTool"; }
	virtual vgui::MenuBar *CreateMenuBar( CBaseToolSystem *pParent );
	virtual void OnModeChanged();
	virtual CMiniViewport	*CreateMiniViewport( vgui::Panel *parent );

	// Inherited from IFoundryTool
	virtual void DestroyEntity( int iHammerID );
	virtual bool UpdateEntity( int iHammerID, CUtlVector<char*> &keys, CUtlVector<char*> &values );
	virtual void RespawnEntitiesWithEdits( CMapClass **ppEntities, int nEntities );
	virtual void MoveEngineViewTo( const Vector &vPos, const QAngle &vAngles );
	virtual void SwitchToEngine();
	virtual void ConsoleCommand( const char *pConCommand );
	virtual bool ShouldRender3DModels();
	virtual void OnMapDocDestroy( CMapDoc *pDoc );

public:
	MESSAGE_FUNC( OnNew, "OnNew" );
	MESSAGE_FUNC( OnOpen, "OnOpen" );
	MESSAGE_FUNC( OnSave, "OnSave" );
	MESSAGE_FUNC( OnSaveAs, "OnSaveAs" );
	MESSAGE_FUNC( OnClose, "OnClose" );
	MESSAGE_FUNC( OnCloseNoSave, "OnCloseNoSave" );
	MESSAGE_FUNC( OnMarkNotDirty, "OnMarkNotDirty" );
	MESSAGE_FUNC( OnExit, "OnExit" );

	// Commands related to the edit menu
	KEYBINDING_FUNC( undo, KEY_Z, vgui::MODIFIER_CONTROL, OnUndo, "#undo_help", 0 );
	KEYBINDING_FUNC( redo, KEY_Z, vgui::MODIFIER_CONTROL | vgui::MODIFIER_SHIFT, OnRedo, "#redo_help", 0 );
	void		OnDescribeUndo();

	// Methods related to the Foundry menu
	MESSAGE_FUNC( OnUpdateHammerEntity, "UpdateHammerEntity" );
	MESSAGE_FUNC( OnReload, "ReloadMap" );
	MESSAGE_FUNC( OnReloadFromSave, "ReloadFromSave" );
	MESSAGE_FUNC( OnReloadFromSaveSlamEnts, "ReloadFromSaveSlamEnts" );

	// Methods related to the view menu
	MESSAGE_FUNC( OnDefaultLayout, "OnDefaultLayout" );
	MESSAGE_FUNC( OnDrawHammerEntities, "OnDrawHammerEntities" );
	MESSAGE_FUNC( OnDrawHammerModels, "OnDrawHammerModels" );
	MESSAGE_FUNC( OnDrawEntityHighlights, "OnDrawEntityHighlights" );
	MESSAGE_FUNC( OnDrawGameEntities, "OnDrawGameEntities" );
	MESSAGE_FUNC( OnSyncHammerView, "OnSyncHammerView" );
	
	void		SetDefaultMiniViewportBounds( vgui::Panel *pMiniViewport );

	void		PerformNew();
	void		OpenFileFromHistory( int slot );
	void		OpenSpecificFile( const char *pFileName );
	virtual void SetupFileOpenDialog( vgui::FileOpenDialog *pDialog, bool bOpenFile, const char *pFileFormat, KeyValues *pContextKeyValues );
	virtual bool OnReadFileFromDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues );
	virtual bool OnWriteFileToDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues );
	virtual void OnFileOperationCompleted( const char *pFileType, bool bWroteFile, vgui::FileOpenStateMachine::CompletionState_t state, KeyValues *pContextKeyValues );

	// returns the document
	CMapDoc* GetDocument();

private:
	// Called by the engine on exit.
	static bool StaticQuitHandler( void *pvUserData );

	bool GetEntityVMFText( CMapClass *pClass, CUtlVector<char> &data );

		// Loads up a new document
	bool LoadDocument( const char *pDocName );

	// Updates the menu bar based on the current file
	void UpdateMenuBar( );

	void MiniViewport_OnMousePressed( vgui::MouseCode code );

	virtual const char *GetLogoTextureName();

	// Creates, destroys tools
	void CreateTools();
	void DestroyTools();

	// Initializes the tools
	void InitTools();

	// Shows, toggles tool windows
	void ToggleToolWindow( Panel *tool, char const *toolName );
	void ShowToolWindow( Panel *tool, char const *toolName, bool visible );

	// Kills all tool windows
	void DestroyToolContainers();

	// Used to hook DME VMF entities into the render lists
	void DrawVMFEntitiesInEngine( bool bDrawInEngine );

	void AddOriginalEntities( CUtlBuffer &entityBuf, const char *pActualEntityData );
	void AddVMFEntities( CUtlBuffer &entityBuf, const char *pActualEntityData );
	const char* GenerateEntityData( const char *pActualEntityData );
	const char* GetVMFFileName();
	bool IsDocumentDirty();

private:
	// Document
	CMapDoc *m_pMapDoc;		// The REAL document from Hammer.

	char m_pBSPFileName[MAX_PATH];

	// Hammer
	IHammer *m_pHammer;

	Vector m_v3dViewOrigin;
	QAngle m_v3dViewAngles;
	float m_fl3dViewFOV;

	// The menu bar
	CToolFileMenuBar *m_pMenuBar;
	CFoundryViewMenuButton *m_pViewMenuButton;

	// Separate undo context for the act busy tool
	CToolWindowFactory< ToolWindow > m_ToolWindowFactory;

	CUtlVector< DmElementHandle_t > m_toolElements;

	CUtlVector<int> m_SavegameRestoredEnts;
};



//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
CFoundryTool	*g_pFoundryToolImp = NULL;
IFoundryTool	*g_pFoundryTool = NULL;

void CreateTools()
{
	g_pFoundryTool = g_pFoundryToolImp = new CFoundryTool();
}


static ConVar foundry_draw_hammer_models( "foundry_draw_hammer_models", "0", 0 );
static ConVar foundry_draw_hammer_entities( "foundry_draw_hammer_entities", "1", 0 );

static ConVar foundry_auto_pause( "foundry_auto_pause", "2", 0, "If 1, Foundry pauses the game when the engine window loses focus. If 2, Foundry disables AI when the engine window loses focus." );

static bool GetDrawEntitiesCvar()
{
	static ConVarRef val( "r_drawentities" );
	return val.GetBool();
}


CON_COMMAND( foundry_sync_engine_view, "Move engine's 3D view to the same position as Hammer's 3D view." )
{
	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !pDoc )
		return;

	POSITION p = pDoc->GetFirstViewPosition();
	while (p != NULL)
	{
		CMapView3D *pView = dynamic_cast< CMapView3D* >( pDoc->GetNextView(p) );
		if ( pView )
		{
			CCamera *pCamera = pView->GetCamera();

			Vector vPos;
			pCamera->GetViewPoint( vPos );

			QAngle vEngineAngles = pCamera->GetAngles();
			vEngineAngles[YAW] = -vEngineAngles[YAW] + 90.0f; // translate from Hammer's 3D renderer angles to engine angles
			g_pFoundryTool->MoveEngineViewTo( vPos, vEngineAngles );
			return;
		}
	}
}

CON_COMMAND( foundry_send_ents_to_engine, "Send selected entities in Hammer into the engine." )
{
	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !g_pFoundryTool || !pDoc )
		return;

	CSelection *pSelection = pDoc->GetSelection();
	if ( !pSelection || pSelection->IsEmpty() )
		return;

	CUtlVector<CMapClass*> toRespawn;

	const CMapObjectList *pObjectList = pSelection->GetList();
	for ( int i=0; i < pObjectList->Count(); i++ )
	{
		CMapClass *pClass = (CUtlReference< CMapClass >)pObjectList->Element( i );
		toRespawn.AddToTail( pClass );
	}

	g_pFoundryTool->RespawnEntitiesWithEdits( toRespawn.Base(), toRespawn.Count() );
}

CON_COMMAND( foundry_move_focus_to_engine, "Send focus to the engine." )
{
	HWND hWnd = (HWND)enginetools->GetEngineHwnd();
	
	RECT rcWindow;
	::GetWindowRect( hWnd, &rcWindow );
	
	SetCursorPos( (rcWindow.left + rcWindow.right) / 2, (rcWindow.top + rcWindow.bottom) / 2 );	
	::SetFocus( hWnd );
}


class CVisGroupEntList
{
public:
	CUtlVector<CMapClass*> m_Entities;
	CVisGroup *m_pGroup;
};

BOOL FindEntitiesInVisGroupCallback( CMapEntity *pObject, CVisGroupEntList *pList )
{
	CMapClass *pClass = dynamic_cast< CMapClass* >( pObject );

	if ( pClass && pClass->IsInVisGroup( pList->m_pGroup ) )
		pList->m_Entities.AddToTail( pClass );

	return TRUE;
}


CON_COMMAND( foundry_spawn_visgroup, "Spawn all the entities in the specified visgroup." )
{
	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !g_pFoundryTool || !pDoc )
		return;

	if ( args.ArgC() < 2 )
	{
		Warning( "Visgroup name required.\n" );
		return;
	}

	const char *pVisGroupName = args.Arg( 1 );
	CVisGroup *pVisGroup = pDoc->VisGroups_GroupForName( pVisGroupName, false );
	if ( !pVisGroup )
		pVisGroup = pDoc->VisGroups_GroupForName( pVisGroupName, true );

	if ( !pVisGroup )
	{
		Warning( "Can't find visgroup '%s'\n", pVisGroupName );
		return;
	}

	// Now find all objects.
	CVisGroupEntList theList;
	theList.m_pGroup = pVisGroup;
	pDoc->GetMapWorld()->EnumChildren( (ENUMMAPCHILDRENPROC)FindEntitiesInVisGroupCallback, (DWORD)&theList, MAPCLASS_TYPE(CMapEntity) );

	// Recreate them all.
	g_pFoundryTool->RespawnEntitiesWithEdits( theList.m_Entities.Base(), theList.m_Entities.Count() );
}

CON_COMMAND( foundry_remove_selected, "Remove selected entities." )
{
	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !g_pFoundryTool || !pDoc )
		return;

	CSelection *pSelection = pDoc->GetSelection();
	if ( !pSelection || pSelection->IsEmpty() )
		return;

	const CMapObjectList *pObjectList = pSelection->GetList();
	for ( int i=0; i < pObjectList->Count(); i++ )
	{
		CMapClass *pClass = (CUtlReference< CMapClass >)pObjectList->Element( i );

		// Update in Foundry if we are running in that mode
		if ( g_pFoundryTool && pClass )
		{
			servertools->RemoveEntity( pClass->GetHammerID() );
		}
	}
}


//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CFoundryTool::CFoundryTool()
{
	m_pBSPFileName[0] = 0;

	m_pMenuBar = NULL;
	m_pMapDoc = NULL;
	
	m_pHammer = NULL;
	m_v3dViewOrigin.Init();
	m_v3dViewAngles.Init();
	m_fl3dViewFOV = 90;

	m_pViewMenuButton = NULL;
}


//-----------------------------------------------------------------------------
// Init, shutdown
//-----------------------------------------------------------------------------

bool CFoundryTool::Init( )
{
	m_pMapDoc = NULL;
	m_RecentFiles.LoadFromRegistry( GetRegistryName() );

	// NOTE: This has to happen before BaseClass::Init
	g_pVGuiLocalize->AddFile( "resource/toolfoundry_%language%.txt" );

	if ( !BaseClass::Init( ) )
		return false;

	enginetools->InstallQuitHandler( this, &CFoundryTool::StaticQuitHandler );

	// Startup Hammer.
	m_pHammer = (IHammer*)Sys_GetFactoryThis()( INTERFACEVERSION_HAMMER, NULL );
	if ( !m_pHammer )
		Error( "Unable to load hammer_dll.dll" );

	char gamedir[MAX_PATH];
	enginetools->GetGameDir( gamedir, sizeof( gamedir ) );

	m_pHammer->InitFoundryMode( g_MainFactory, NULL, gamedir );
	return true;
}

void CFoundryTool::Shutdown()
{
	m_RecentFiles.SaveToRegistry( GetRegistryName() );

	{
		CDisableUndoScopeGuard guard;
		int nElements = m_toolElements.Count();
		for ( int i = 0; i < nElements; ++i )
		{
			g_pDataModel->DestroyElement( m_toolElements[ i ] );
		}
	}

	m_pMapDoc = NULL;

	BaseClass::Shutdown();
}


//-----------------------------------------------------------------------------
// returns the document
//-----------------------------------------------------------------------------
inline CMapDoc *CFoundryTool::GetDocument()
{
	return m_pMapDoc;
}

	
//-----------------------------------------------------------------------------
// Tool activation/deactivation
//-----------------------------------------------------------------------------
void CFoundryTool::OnToolActivate()
{
	BaseClass::OnToolActivate();
}

void CFoundryTool::OnToolDeactivate()
{
	BaseClass::OnToolDeactivate();
}


//-----------------------------------------------------------------------------
// Used to hook DME VMF entities into the render lists
//-----------------------------------------------------------------------------
void CFoundryTool::DrawVMFEntitiesInEngine( bool bDrawInEngine )
{
}

void CFoundryTool::ClientLevelInitPostEntity()
{
	BaseClass::ClientLevelInitPostEntity();
	DrawVMFEntitiesInEngine( true );
}

void CFoundryTool::ClientLevelShutdownPreEntity()
{
	DrawVMFEntitiesInEngine( false );
	BaseClass::ClientLevelShutdownPreEntity();
}

	
//-----------------------------------------------------------------------------
// Derived classes can implement this to get a new scheme to be applied to this tool
//-----------------------------------------------------------------------------
vgui::HScheme CFoundryTool::GetToolScheme() 
{ 
	return vgui::scheme()->LoadSchemeFromFile( "Resource/BoxRocket.res", "BoxRocket" );
}


//-----------------------------------------------------------------------------
//
// The View menu
//
//-----------------------------------------------------------------------------
class CFoundryViewMenuButton : public CToolMenuButton
{
	DECLARE_CLASS_SIMPLE( CFoundryViewMenuButton, CToolMenuButton );
public:
	CFoundryViewMenuButton( CFoundryTool *parent, const char *panelName, const char *text, vgui::Panel *pActionSignalTarget );
	virtual void OnShowMenu(vgui::Menu *menu);

public:
	int m_menuitemidDrawHammerEntities;
	int m_menuitemidDrawHammerModels;
	int m_menuitemidDrawEntityHighlights;
	int m_menuitemidDrawGameEntities;

private:
	CFoundryTool *m_pTool;
};

CFoundryViewMenuButton::CFoundryViewMenuButton( CFoundryTool *parent, const char *panelName, const char *text, vgui::Panel *pActionSignalTarget )
	: BaseClass( parent, panelName, text, pActionSignalTarget )
{
	m_pTool = parent;

	AddMenuItem( "defaultlayout", "#FoundryViewDefault", new KeyValues( "OnDefaultLayout" ), pActionSignalTarget );

	m_menuitemidDrawHammerEntities = AddCheckableMenuItem( "drawhammerentities", "#FoundryViewDrawHammerEntities", new KeyValues( "OnDrawHammerEntities" ), pActionSignalTarget );
	m_pMenu->SetMenuItemChecked( m_menuitemidDrawHammerEntities, foundry_draw_hammer_entities.GetBool() );
	
	m_menuitemidDrawHammerModels = AddCheckableMenuItem( "drawhammermodels", "#FoundryViewDrawHammerModels", new KeyValues( "OnDrawHammerModels" ), pActionSignalTarget );
	m_pMenu->SetMenuItemChecked( m_menuitemidDrawHammerModels, foundry_draw_hammer_models.GetBool() );
	
	m_menuitemidDrawEntityHighlights = AddCheckableMenuItem( "DrawEntityHighlights", "#FoundryViewDrawEntityHighlights", new KeyValues( "OnDrawEntityHighlights" ), pActionSignalTarget );
	m_pMenu->SetMenuItemChecked( m_menuitemidDrawEntityHighlights, true );

	m_menuitemidDrawGameEntities = AddCheckableMenuItem( "drawgameentities", "#FoundryViewDrawGameEntities", new KeyValues( "OnDrawGameEntities" ), pActionSignalTarget );
	m_pMenu->SetMenuItemChecked( m_menuitemidDrawGameEntities, GetDrawEntitiesCvar() );

	AddMenuItem( "synchammerview", "#FoundrySyncHammerView", new KeyValues( "OnSyncHammerView" ), pActionSignalTarget );

	SetMenu(m_pMenu);
}

void CFoundryViewMenuButton::OnShowMenu(vgui::Menu *menu)
{
	BaseClass::OnShowMenu( menu );
/*
	// Update the menu
	int id;

	if ( m_pTool->GetDocument() )
	{
		id = m_Items.Find( "properties" );
		m_pMenu->SetItemEnabled( id, true );

		Panel *p;
		p = m_pTool->GetProperties();
		Assert( p );
		m_pMenu->SetMenuItemChecked( id, ( p && p->GetParent() ) ? true : false );

		id = m_Items.Find( "entityreport" );
		m_pMenu->SetItemEnabled( id, true );
		
		p = m_pTool->GetEntityReport();
		Assert( p );
		m_pMenu->SetMenuItemChecked( id, ( p && p->GetParent() ) ? true : false );
	}
	else
	{
		id = m_Items.Find( "properties" );
		m_pMenu->SetItemEnabled( id, false );
		id = m_Items.Find( "entityreport" );
		m_pMenu->SetItemEnabled( id, false );
	}
*/
}


//-----------------------------------------------------------------------------
//
// The Tool menu
//
//-----------------------------------------------------------------------------
class CFoundryToolMenuButton : public CToolMenuButton
{
	DECLARE_CLASS_SIMPLE( CFoundryToolMenuButton, CToolMenuButton );
public:
	CFoundryToolMenuButton( CFoundryTool *parent, const char *panelName, const char *text, vgui::Panel *pActionSignalTarget );
	virtual void OnShowMenu(vgui::Menu *menu);

private:
	CFoundryTool *m_pTool;
};

CFoundryToolMenuButton::CFoundryToolMenuButton( CFoundryTool *parent, const char *panelName, const char *text, vgui::Panel *pActionSignalTarget )
	: BaseClass( parent, panelName, text, pActionSignalTarget )
{
	m_pTool = parent;

	AddMenuItem( "updateentity", "#FoundryUpdateHammerEntity", new KeyValues( "UpdateHammerEntity" ), pActionSignalTarget );
	AddMenuItem( "reload", "#FoundryReload", new KeyValues( "ReloadMap" ), pActionSignalTarget );
	AddMenuItem( "reloadsave", "#FoundryReloadFromSave", new KeyValues( "ReloadFromSave" ), pActionSignalTarget );
	AddMenuItem( "reloadsaveslaments", "#FoundryReloadReplaceEnts", new KeyValues( "ReloadFromSaveSlamEnts" ), pActionSignalTarget );

	SetMenu(m_pMenu);
}

void CFoundryToolMenuButton::OnShowMenu(vgui::Menu *menu)
{
	BaseClass::OnShowMenu( menu );

	// Update the menu
	int id;

	CMapDoc *pDoc = m_pTool->GetDocument();
	
	id = m_Items.Find( "reload" );
	m_pMenu->SetItemEnabled( id, pDoc != NULL );
	
	id = m_Items.Find( "reloadsave" );
	m_pMenu->SetItemEnabled( id, pDoc != NULL  );

	id = m_Items.Find( "reloadsaveslaments" );
	m_pMenu->SetItemEnabled( id, pDoc != NULL  );
}


//-----------------------------------------------------------------------------
// Initializes the menu bar
//-----------------------------------------------------------------------------
vgui::MenuBar *CFoundryTool::CreateMenuBar( CBaseToolSystem *pParent ) 
{
	m_pMenuBar = new CToolFileMenuBar( pParent, "Main Menu Bar" );

	// Sets info in the menu bar
	char title[ 64 ];
	ComputeMenuBarTitle( title, sizeof( title ) );
	m_pMenuBar->SetInfo( title );
	m_pMenuBar->SetToolName( GetToolName() );

	// Add menu buttons
	CToolMenuButton *pFileButton = CreateToolFileMenuButton( m_pMenuBar, "File", "&File", GetActionTarget(), this );
	CToolMenuButton *pEditButton = CreateToolEditMenuButton( this, "Edit", "&Edit", GetActionTarget() );
	CFoundryToolMenuButton *pToolButton = new CFoundryToolMenuButton( this, "Foundry", "F&oundry", GetActionTarget() );
	m_pViewMenuButton = new CFoundryViewMenuButton( this, "View", "&View", GetActionTarget() );
	CToolMenuButton *pSwitchButton = CreateToolSwitchMenuButton( m_pMenuBar, "Switcher", "&Tools", GetActionTarget() );

	m_pMenuBar->AddButton( pFileButton );
	m_pMenuBar->AddButton( pEditButton );
	m_pMenuBar->AddButton( pToolButton );
	m_pMenuBar->AddButton( m_pViewMenuButton );
	m_pMenuBar->AddButton( pSwitchButton );

	return m_pMenuBar;
}


// Acts like a viewport but passes mouse input into Foundry.
class CFoundryViewport : public CMiniViewport
{
public:
	DECLARE_CLASS_SIMPLE( CFoundryViewport, CMiniViewport );

	CFoundryViewport( CFoundryTool *pFoundryTool, vgui::Panel *pParent ) :
		CMiniViewport( pParent, "MiniViewport" )
	{
		m_pFoundryTool = pFoundryTool;
	}

	virtual void	OnMousePressed( vgui::MouseCode code )
	{
		m_pFoundryTool->MiniViewport_OnMousePressed( code );
	}

private:
	CFoundryTool *m_pFoundryTool;
};


CMiniViewport* CFoundryTool::CreateMiniViewport( vgui::Panel *parent )
{
	int w, h;
	surface()->GetScreenSize( w, h );

	CMiniViewport *vp = new CFoundryViewport( this, parent );
	Assert( vp );
	vp->SetVisible( true );

	SetDefaultMiniViewportBounds( vp );
	return vp;
}


void CFoundryTool::MiniViewport_OnMousePressed( vgui::MouseCode code )
{
	if ( !m_pMapDoc )
		return;

	CMapView3D *pView = m_pMapDoc->GetFirst3DView();
	if ( !pView )
		return;

	if ( code == MOUSE_LEFT )
	{
		int x, y;
		input()->GetCursorPos( x, y );
		ScreenToLocal( x, y );
		pView->Foundry_OnLButtonDown( x, y );
	}
}


//-----------------------------------------------------------------------------
// Updates the menu bar based on the current file
//-----------------------------------------------------------------------------
void CFoundryTool::UpdateMenuBar( )
{
	if ( !m_pMapDoc )
	{
		m_pMenuBar->SetFileName( "#FoundryNoFile" );
		return;
	}

	const char *pVMFFile = GetVMFFileName();
	if ( !pVMFFile[0] )
	{
		m_pMenuBar->SetFileName( "#FoundryNoFile" );
		return;
	}

	if ( IsDocumentDirty() )
	{
		char sz[ 512 ];
		Q_snprintf( sz, sizeof( sz ), "* %s", pVMFFile );
		m_pMenuBar->SetFileName( sz );
	}
	else
	{
		m_pMenuBar->SetFileName( pVMFFile );
	}
}



//-----------------------------------------------------------------------------
// Destroys all tool windows
//-----------------------------------------------------------------------------
void CFoundryTool::DestroyToolContainers()
{
	int c = ToolWindow::GetToolWindowCount();
	for ( int i = c - 1; i >= 0 ; --i )
	{
		ToolWindow *kill = ToolWindow::GetToolWindow( i );
		delete kill;
	}
}


//-----------------------------------------------------------------------------
// Sets up the default layout
//-----------------------------------------------------------------------------
void CFoundryTool::OnDefaultLayout()
{
	DestroyToolContainers();
}


void CFoundryTool::OnDrawHammerEntities()
{
	foundry_draw_hammer_entities.SetValue( !foundry_draw_hammer_entities.GetInt() );
	if ( m_pViewMenuButton )
	{
		vgui::Menu *pMenu = m_pViewMenuButton->GetMenu();
		if ( pMenu )
			pMenu->SetMenuItemChecked( m_pViewMenuButton->m_menuitemidDrawHammerEntities, foundry_draw_hammer_entities.GetBool() );
	}
}

void CFoundryTool::OnDrawHammerModels()
{
	foundry_draw_hammer_models.SetValue( !foundry_draw_hammer_models.GetInt() );
	if ( m_pViewMenuButton )
	{
		vgui::Menu *pMenu = m_pViewMenuButton->GetMenu();
		if ( pMenu )
			pMenu->SetMenuItemChecked( m_pViewMenuButton->m_menuitemidDrawHammerModels, foundry_draw_hammer_models.GetBool() );
	}
}

void CFoundryTool::OnDrawGameEntities()
{
	bool bDrawGameEntities = !GetDrawEntitiesCvar();

	// Update convar
	char szConCommand[50];

	V_snprintf( szConCommand, 50, "r_drawentities %i\n", (int)bDrawGameEntities); 
	enginetools->Command( szConCommand );

	// Update checkmark in menu
	if ( m_pViewMenuButton )
	{
		vgui::Menu *pMenu = m_pViewMenuButton->GetMenu();
		if ( pMenu )
		{
			pMenu->SetMenuItemChecked( m_pViewMenuButton->m_menuitemidDrawGameEntities, bDrawGameEntities );
		}
	}
}

void CFoundryTool::OnSyncHammerView()
{
	enginetools->Command( "foundry_sync_hammer_view\n" );
}

void CFoundryTool::OnDrawEntityHighlights()
{
	ConVar *pCv = ( ConVar * )cvar->FindVar( "cl_foundry_ShowEntityHighlights" );
	if ( pCv )
	{
		pCv->SetValue( !pCv->GetInt() );

		if ( m_pViewMenuButton )
		{
			vgui::Menu *pMenu = m_pViewMenuButton->GetMenu();
			if ( pMenu )
				pMenu->SetMenuItemChecked( m_pViewMenuButton->m_menuitemidDrawEntityHighlights, pCv->GetBool() );
		}
	}
}


void CFoundryTool::SetDefaultMiniViewportBounds( vgui::Panel *pMiniViewport )
{
	int menuBarY = m_pMenuBar->GetTall();

	int mainPanelWidth, mainPanelHeight;
	GetSize( mainPanelWidth, mainPanelHeight );

	int padding = 3;
	
	int left = padding;
	int top = menuBarY + padding;
	int width = mainPanelWidth - padding*2;
	int height = (mainPanelHeight - menuBarY) - top;

	pMiniViewport->SetBounds( left, top, width, height );
}


//-----------------------------------------------------------------------------
// Creates
//-----------------------------------------------------------------------------
void CFoundryTool::CreateTools()
{
/*
	if ( !m_hProperties.Get() )
	{
		m_hProperties = new CBasePropertiesContainer( NULL, NULL, NULL );
	}

	if ( !m_hEntityReport.Get() )
	{
		m_hEntityReport = new CEntityReportPanel( NULL, this, "EntityReportPanel" );
	}

	RegisterToolWindow( m_hProperties );
	RegisterToolWindow( m_hEntityReport );
*/
}


//-----------------------------------------------------------------------------
// Initializes the tools
//-----------------------------------------------------------------------------
void CFoundryTool::InitTools()
{
	// FIXME: There are no tool windows here; how should this work?
	// These panels are saved
	//windowposmgr->RegisterPanel( "properties", m_hProperties, false );
	//windowposmgr->RegisterPanel( "entityreport", m_hEntityReport, false );

	OnDefaultLayout();
	windowposmgr->LoadPositions( "cfg/foundry.txt", this, &m_ToolWindowFactory, "Foundry" );
}


void CFoundryTool::DestroyTools()
{
	int c = ToolWindow::GetToolWindowCount();
	for ( int i = c - 1; i >= 0 ; --i )
	{
		ToolWindow *kill = ToolWindow::GetToolWindow( i );
		delete kill;
	}

	UnregisterAllToolWindows();
}


void CFoundryTool::ShowToolWindow( Panel *tool, char const *toolName, bool visible )
{
	Assert( tool );

	if ( tool->GetParent() == NULL && visible )
	{
		m_ToolWindowFactory.InstanceToolWindow( this, false, tool, toolName, false );
	}
	else if ( !visible )
	{
		ToolWindow *tw = dynamic_cast< ToolWindow * >( tool->GetParent()->GetParent() );
		Assert( tw );
		tw->RemovePage( tool );
	}
}

void CFoundryTool::ToggleToolWindow( Panel *tool, char const *toolName )
{
	Assert( tool );

	if ( tool->GetParent() == NULL )
	{
		ShowToolWindow( tool, toolName, true );
	}
	else
	{
		ShowToolWindow( tool, toolName, false );
	}
}


//-----------------------------------------------------------------------------
// Creates the action menu
//-----------------------------------------------------------------------------
vgui::Menu *CFoundryTool::CreateActionMenu( vgui::Panel *pParent )
{
	vgui::Menu *pActionMenu = new Menu( pParent, "ActionMenu" );
	pActionMenu->AddMenuItem( "#ToolHide", new KeyValues( "Command", "command", "HideActionMenu" ), GetActionTarget() );
	return pActionMenu;
}

//-----------------------------------------------------------------------------
// Inherited from IFileMenuCallbacks
//-----------------------------------------------------------------------------
int	CFoundryTool::GetFileMenuItemsEnabled( )
{
	int nFlags = FILE_ALL & (~FILE_NEW);
	if ( m_RecentFiles.IsEmpty() )
	{
		nFlags &= ~FILE_RECENT;
	}
	return nFlags;
}

void CFoundryTool::AddRecentFilesToMenu( vgui::Menu *pMenu )
{
	m_RecentFiles.AddToMenu( pMenu, GetActionTarget(), "OnRecent" );
}

bool CFoundryTool::GetPerforceFileName( char *pFileName, int nMaxLen )
{
	if ( !m_pMapDoc )
		return false;

	Q_strncpy( pFileName, GetVMFFileName(), nMaxLen );
	return pFileName[0] != 0;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  :  - 
//-----------------------------------------------------------------------------
void CFoundryTool::OnExit()
{
	windowposmgr->SavePositions( "cfg/foundry.txt", "Foundry" );

	enginetools->Command( "quit\n" );
}

//-----------------------------------------------------------------------------
// Handle commands from the action menu and other menus
//-----------------------------------------------------------------------------
void CFoundryTool::OnCommand( const char *cmd )
{
	if ( !V_stricmp( cmd, "HideActionMenu" ) )
	{
		if ( GetActionMenu() )
		{
			GetActionMenu()->SetVisible( false );
		}
	}
	else if ( const char *pSuffix = StringAfterPrefix( cmd, "OnRecent" ) )
	{
		int idx = Q_atoi( pSuffix );
		OpenFileFromHistory( idx );
	}
	else if ( const char *pSuffix = StringAfterPrefix( cmd, "OnTool" ) )
	{
		int idx = Q_atoi( pSuffix );
		enginetools->SwitchToTool( idx );
	}
	else if ( !V_stricmp( cmd, "OnUndo" ) )
	{
		OnUndo();
	}
	else if ( !V_stricmp( cmd, "OnRedo" ) )
	{
		OnRedo();
	}
	else if ( !V_stricmp( cmd, "OnDescribeUndo" ) )
	{
		OnDescribeUndo();
	}
	else
	{
		BaseClass::OnCommand( cmd );
	}
}


//-----------------------------------------------------------------------------
// Command handlers
//-----------------------------------------------------------------------------
void CFoundryTool::PerformNew()
{
	// Can never do new
	Assert( 0 );
}

void CFoundryTool::OnNew()
{
	if ( m_pMapDoc )
	{
		if ( IsDocumentDirty() )
		{
			SaveFile( GetVMFFileName(), "vmf", FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY,
				new KeyValues( "OnNew" ) );
			return;
		}
	}
	PerformNew();
}

void CFoundryTool::OnOpen( )
{
	int nFlags = 0;
	const char *pSaveFileName = NULL;
	if ( IsDocumentDirty() )
	{
		nFlags = FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY;
		pSaveFileName = GetVMFFileName();
	}

	OpenFile( "bsp", pSaveFileName, "vmf", nFlags );
}

bool CFoundryTool::OnReadFileFromDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues )
{
	OnCloseNoSave();
	if ( !LoadDocument( pFileName ) )
		return false;
	m_RecentFiles.Add( pFileName, pFileFormat );
	m_RecentFiles.SaveToRegistry( GetRegistryName() );
	UpdateMenuBar();
	return true;
}

void CFoundryTool::OnSave()
{
	if ( m_pMapDoc )
	{
		SaveFile( NULL, "vmf", FOSM_SHOW_PERFORCE_DIALOGS );
	}
}

void CFoundryTool::OnSaveAs()
{
	if ( m_pMapDoc )
	{
		SaveFile( GetVMFFileName(), "vmf", FOSM_SHOW_PERFORCE_DIALOGS );
	}
}

bool CFoundryTool::OnWriteFileToDisk( const char *pFileName, const char *pFileFormat, KeyValues *pContextKeyValues )
{
	if ( !m_pMapDoc )
		return true;

	m_pMapDoc->SetPathName( pFileName );
	m_pMapDoc->SaveVMF( pFileName, 0 );

	m_RecentFiles.Add( pFileName, pFileFormat );
	m_RecentFiles.SaveToRegistry( GetRegistryName() );
	UpdateMenuBar();
	return true;
}

void CFoundryTool::OnClose()
{
	if ( IsDocumentDirty() )
	{
		SaveFile( GetVMFFileName(), "vmf", FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY, 
			new KeyValues( "OnClose" ) );
		return;
	}

	OnCloseNoSave();
}

void CFoundryTool::OnCloseNoSave()
{
	
}

void CFoundryTool::OnMarkNotDirty()
{
	// FIXME: Implement
}


//-----------------------------------------------------------------------------
// Open a specific file
//-----------------------------------------------------------------------------
void CFoundryTool::OpenSpecificFile( const char *pFileName )
{
	if ( m_pMapDoc )
	{
		// TODO: close the MFC document here.
		m_pMapDoc = NULL;
	}

	int nFlags = 0;
	const char *pSaveFileName = NULL;

	OpenFile( pFileName, "bsp", pSaveFileName, "vmf", nFlags );
}


//-----------------------------------------------------------------------------
// Show the save document query dialog
//-----------------------------------------------------------------------------
void CFoundryTool::OpenFileFromHistory( int slot )
{
	const char *pFileName = m_RecentFiles.GetFile( slot );
	if ( !pFileName )
		return;
	OpenSpecificFile( pFileName );
}


//-----------------------------------------------------------------------------
// Derived classes can implement this to get notified when files are saved/loaded
//-----------------------------------------------------------------------------
void CFoundryTool::OnFileOperationCompleted( const char *pFileType, bool bWroteFile, vgui::FileOpenStateMachine::CompletionState_t state, KeyValues *pContextKeyValues )
{
	if ( bWroteFile )
	{
		OnMarkNotDirty();
	}

	if ( !pContextKeyValues )
		return;

	if ( state != FileOpenStateMachine::SUCCESSFUL )
		return;

	if ( !Q_stricmp( pContextKeyValues->GetName(), "OnNew" ) )
	{
		PerformNew();
		return;
	}

	if ( !Q_stricmp( pContextKeyValues->GetName(), "OnClose" ) )
	{
		OnCloseNoSave();
		return;
	}

	if ( !Q_stricmp( pContextKeyValues->GetName(), "OnQuit" ) )
	{
		OnCloseNoSave();
		vgui::ivgui()->PostMessage( GetVPanel(), new KeyValues( "OnExit" ), 0 );
		return;
	}

	if ( !Q_stricmp( pContextKeyValues->GetName(), "OnUnload" ) )
	{
		enginetools->Command( "toolunload foundry -nosave\n" );
		return;
	}
}


//-----------------------------------------------------------------------------
// Show the File browser dialog
//-----------------------------------------------------------------------------
void CFoundryTool::SetupFileOpenDialog( vgui::FileOpenDialog *pDialog, bool bOpenFile, const char *pFileFormat, KeyValues *pContextKeyValues )
{
	char pStartingDir[ MAX_PATH ];

	// We open BSPs, but save-as VMFs
	if ( bOpenFile )
	{
		GetModSubdirectory( "maps", pStartingDir, sizeof(pStartingDir) );
		pDialog->SetTitle( "Choose Valve BSP File", true );
		pDialog->SetStartDirectoryContext( "foundry_bsp_session", pStartingDir );
		pDialog->AddFilter( "*.bsp", "Valve BSP File (*.bsp)", true );
	}
	else
	{
		GetModContentSubdirectory( "maps", pStartingDir, sizeof(pStartingDir) );
		pDialog->SetTitle( "Choose Valve VMF File", true );
		pDialog->SetStartDirectoryContext( "foundry_vmf_session", pStartingDir );
		pDialog->AddFilter( "*.vmf", "Valve VMF File (*.vmf)", true );
	}
}


//-----------------------------------------------------------------------------
// Can we quit?
//-----------------------------------------------------------------------------
bool CFoundryTool::CanQuit( const char *pExitMsg )
{
	if ( IsDocumentDirty() )
	{
		// Show Save changes Yes/No/Cancel and re-quit if hit yes/no
		SaveFile( GetVMFFileName(), "vmf", FOSM_SHOW_PERFORCE_DIALOGS | FOSM_SHOW_SAVE_QUERY, new KeyValues( pExitMsg ) );
		return false;
	}

	return true;
}


//-----------------------------------------------------------------------------
// Various command handlers related to the Edit menu
//-----------------------------------------------------------------------------
void CFoundryTool::OnUndo()
{
	CDisableUndoScopeGuard guard;
	g_pDataModel->Undo();
}

void CFoundryTool::OnRedo()
{
	CDisableUndoScopeGuard guard;
	g_pDataModel->Redo();
}

void CFoundryTool::OnDescribeUndo()
{
	CUtlVector< UndoInfo_t > list;
	g_pDataModel->GetUndoInfo( list );

	Msg( "%i operations in stack\n", list.Count() );

	for ( int i = list.Count() - 1; i >= 0; --i )
	{
		UndoInfo_t& entry = list[ i ];
		if ( entry.terminator )
		{
			Msg( "[ '%s' ] - %i operations\n", entry.undo, entry.numoperations );
		}

		Msg( "   +%s\n", entry.desc );
	}
}


//-----------------------------------------------------------------------------
// Foundry menu items
//-----------------------------------------------------------------------------
void CFoundryTool::OnReload()
{
	// Reloads the map, entities only, will reload every entity 
	enginetools->Command( "respawn_entities\n" );
}

void CFoundryTool::OnReloadFromSave()
{
	// Reloads the map from a save point, overrides selected entities
	// for now, this is hardcoded to be info_targets
	enginetools->Command( "load quick\n" );
}

void CFoundryTool::OnUpdateHammerEntity()
{
	enginetools->Command( "foundry_update_entity" );
}

void CFoundryTool::OnReloadFromSaveSlamEnts()
{
	m_SavegameRestoredEnts.Purge();
	enginetools->Command( "load quick * LetToolsOverrideLoadGameEnts\n" );
	enginetools->Execute();
}


//-----------------------------------------------------------------------------
// Background
//-----------------------------------------------------------------------------
const char *CFoundryTool::GetLogoTextureName()
{
	//return "vgui/tools/sampletool/sampletool_logo";
	return NULL;
}


//-----------------------------------------------------------------------------
// Inherited from IFoundryDocCallback
//-----------------------------------------------------------------------------
void CFoundryTool::OnDocChanged( const char *pReason, int nNotifySource, int nNotifyFlags )
{
	UpdateMenuBar();

	/*
	if ( bRefreshUI && m_hProperties.Get() )
	{
		m_hProperties->Refresh();
	}
	*/
}


//-----------------------------------------------------------------------------
// List of all entity classnames to copy over from the original block
//-----------------------------------------------------------------------------
static const char *s_pUseOriginalClasses[] =
{
	"worldspawn",
	"func_occluder",
	NULL
};


//-----------------------------------------------------------------------------
// Always copy the worldspawn and other entities that had data built into them by VBSP out
//-----------------------------------------------------------------------------
void CFoundryTool::AddOriginalEntities( CUtlBuffer &entityBuf, const char *pActualEntityData )
{
	while ( *pActualEntityData )
	{
		pActualEntityData = strchr( pActualEntityData, '{' );
		if ( !pActualEntityData )
			break;

		const char *pBlockStart = pActualEntityData;

		pActualEntityData = strstr( pActualEntityData, "\"classname\"" );
		if ( !pActualEntityData )
			break;

		// Skip "classname"
		pActualEntityData += 11;

		pActualEntityData = strchr( pActualEntityData, '\"' );
		if ( !pActualEntityData )
			break;

		// Skip "
		++pActualEntityData;

		char pClassName[512];
		int j = 0;
		while (*pActualEntityData != 0 && *pActualEntityData != '\"' )
		{
			pClassName[j++] = *pActualEntityData++;	
		}
		pClassName[j] = 0;

		pActualEntityData = strchr( pActualEntityData, '}' );
		if ( !pActualEntityData )
			break;

		// Skip }
		++pActualEntityData;

		for ( int i = 0; s_pUseOriginalClasses[i]; ++i )
		{
			if ( !Q_stricmp( pClassName, s_pUseOriginalClasses[i] ) )
			{
				// Found one we need to keep, add it to the buffer
				int nBytes = (int)( (size_t)pActualEntityData - (size_t)pBlockStart );
				entityBuf.Put( pBlockStart, nBytes );
				entityBuf.PutChar( '\n' );
				break;
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Copy in other entities from the editable VMF
//-----------------------------------------------------------------------------
void CFoundryTool::AddVMFEntities( CUtlBuffer &entityBuf, const char *pActualEntityData )
{
}

bool CFoundryTool::IsDocumentDirty()
{
	return m_pMapDoc && m_pMapDoc->IsModified();
}

//-----------------------------------------------------------------------------
// Create a text block the engine can parse containing the entity data to spawn
//-----------------------------------------------------------------------------
const char* CFoundryTool::GenerateEntityData( const char *pActualEntityData )
{
	return pActualEntityData;
}


const char* CFoundryTool::GetVMFFileName()
{
	if ( m_pMapDoc )
		return m_pMapDoc->GetPathName();
	else
		return "";
}


//-----------------------------------------------------------------------------
// Loads up a new document
//-----------------------------------------------------------------------------
bool CFoundryTool::LoadDocument( const char *pFileName )
{
	Assert( !m_pMapDoc );

	DestroyTools();

	// Store the BSP file name
	Q_strncpy( m_pBSPFileName, pFileName, sizeof( m_pBSPFileName ) );

	// Construct VMF file name from the BSP
	const char *pGame = Q_stristr( pFileName, "\\game\\" );
	if ( !pGame )
		return false;

	// Compute the map name
	char mapname[ 256 ];
	const char *pMaps = Q_stristr( pFileName, "\\maps\\" );
	if ( !pMaps )
		return false;

	Q_strncpy( mapname, pMaps + 6, sizeof( mapname ) );

	int nLen = (int)( (size_t)pGame - (size_t)pFileName ) + 1;
	char vmfFilename[MAX_PATH];
	Q_strncpy( vmfFilename, pFileName, nLen );
	Q_strncat( vmfFilename, "\\content\\", sizeof(vmfFilename) );
	Q_strncat( vmfFilename, pGame + 6, sizeof(vmfFilename) );
	Q_SetExtension( vmfFilename, ".vmf", sizeof(vmfFilename) );

	// Have Hammer load this VMF.
	CHammer *pApp = (CHammer*) AfxGetApp();
	m_pMapDoc = (CMapDoc*)pApp->pMapDocTemplate->OpenDocumentFile( vmfFilename );	


	// Now have the engine load the map.
	char cmd[ 256 ];
	Q_snprintf( cmd, sizeof( cmd ), "disconnect; map %s\n", mapname );
	enginetools->Command( cmd );
	enginetools->Execute( );


	ShowMiniViewport( true );

	CreateTools();
	InitTools();
	return true;
}


//-----------------------------------------------------------------------------
// Create the entities that are in our VMF file
//-----------------------------------------------------------------------------

void* CFoundryTool::QueryInterface( const char *pInterfaceName )
{
	if ( V_stricmp( pInterfaceName, VSERVERFOUNDRY_INTERFACE_VERSION ) == 0 )
		return (IServerFoundry*)this;
	
	return NULL;
}


// This simulates passing entity data through VBSP. We should share the code with VBSP here if the format changes
// and this gets complicated, but it would involve lots of ugly #ifdef HAMMER's chopping up map.cpp.
static bool TransformEntityVMFToBSPFormat( char *pIn, CUtlVector<char> &data )
{
	ParseFromMemory( pIn, V_strlen( pIn ) );

	// Ignore the leading "entity {"
	// Also ignore everything inside "editor"
	if ( !GetToken(true) || V_stricmp(token, "entity") != 0 || !GetToken(true) || V_stricmp(token,"{") != 0 )
	{
		Warning( "Unknown entity format.\n" );
		return false;
	}

	bool bInsideEditorBlock = false;
	bool bValidFile = false;
	int braceLevel = 1;
	while ( 1 )
	{
		char firstToken[MAXTOKEN];
		GetToken( true );
		V_strncpy( firstToken, token, sizeof( firstToken ) );
		if ( firstToken[0] == '}' )
		{
			--braceLevel;
			if ( braceLevel == 0 )
			{
				// If we end the file and we're not somehow in the editor block, then the file is good.
				bValidFile = !bInsideEditorBlock;
				break;
			}
			else
			{
				bInsideEditorBlock = false;
			}
			continue;
		}

		if ( !GetToken( true ) )
			break;

		if ( token[0] == '{' )
		{
			++braceLevel;
			if ( V_stricmp( firstToken, "editor" ) == 0 )
				bInsideEditorBlock = true;

			continue;
		}

		if ( bInsideEditorBlock )
			continue;

		char outStr[MAXTOKEN*2+16];
		V_snprintf( outStr, sizeof( outStr ), "\"%s\" \"%s\"\n", firstToken, token );
		data.AddMultipleToTail( V_strlen( outStr ), outStr );
	}

	if ( !bValidFile )
	{
		Warning( "Invalid entity format.\n" );
		return false;
	}

	data.AddToTail( '}' );
	data.AddToTail( 0 ); // Null-terminate our string.
	return true;
}


static bool LoadFileDataIntoBuffer( const char *pFilename, const char *pFormat, CUtlVector<char> &tempData )
{
	FILE *fp = fopen( pFilename, pFormat );
	if ( !fp )
	{
		return false;
	}
	fseek( fp, 0, SEEK_END );
	tempData.SetSize( ftell( fp ) + 1 );
	fseek( fp, 0, SEEK_SET );
	fread( tempData.Base(), 1, tempData.Count()-1, fp );
	fclose( fp );
	
	return true;
}


bool CFoundryTool::GetEntityVMFText( CMapClass *pClass, CUtlVector<char> &data )
{
	char baseDir[MAX_PATH], cheesyFilename[MAX_PATH];
	_getcwd( baseDir, sizeof( baseDir ) );
	V_ComposeFileName( baseDir, "__foundry_tempchunk.txt", cheesyFilename, sizeof( cheesyFilename ) );

	// Save this entity's data into a temporary file.
	CSaveInfo saveInfo;
	saveInfo.SetVisiblesOnly( false );

	CChunkFile chunkFile;
	chunkFile.Open( cheesyFilename, ChunkFile_Write );
	ChunkFileResult_t result = pClass->SaveVMF( &chunkFile, &saveInfo );
	chunkFile.Close();
	if ( result != ChunkFile_Ok )
	{
		return false;
	}

	// Load the temporary file into memory.
	CUtlVector<char> tempData;
	if ( !LoadFileDataIntoBuffer( cheesyFilename, "rt", tempData ) )
	{
		Warning( "Internal error in GetEntityVMFText\n" );
		return false;
	}

	DeleteFile( cheesyFilename );

	// Convert from the VMF-format entity to the BSP-format entity.
	return TransformEntityVMFToBSPFormat( tempData.Base(), data );
}

bool CFoundryTool::GetRestoredEntityReplacementData( int iHammerID, CUtlVector<char> &data )
{
	CMapDoc *pDoc = g_pFoundryToolImp->GetDocument();
	CSelection *pSelection = pDoc->GetSelection();
	if ( !pSelection || pSelection->IsEmpty() )
		return false;

	const CMapObjectList *pObjectList = pSelection->GetList();
	for ( int i=0; i < pObjectList->Count(); i++ )
	{
		CMapClass *pClass = (CUtlReference< CMapClass >)pObjectList->Element( i );

		if ( pClass->GetID() == iHammerID )
		{
			if ( GetEntityVMFText( pClass, data ) )
			{
				m_SavegameRestoredEnts.AddToTail( pClass->GetID() );
				return true;
			}
			else
			{
				return false;
			}
		}
	}
	
	return false;
}


void CFoundryTool::OnFinishedRestoreSavegame()
{
	CUtlVector<CMapClass*> toRespawn;

	// We're restoring a savegame and slamming any ents that are selected.
	// The savegame is finished, so now slam entities that are selected but weren't in the savegame.
	CMapDoc *pDoc = g_pFoundryToolImp->GetDocument();
	CSelection *pSelection = pDoc->GetSelection();
	if ( pSelection && !pSelection->IsEmpty() )
	{
		const CMapObjectList *pObjectList = pSelection->GetList();
		for ( int i=0; i < pObjectList->Count(); i++ )
		{
			CMapClass *pClass = (CUtlReference< CMapClass >)pObjectList->Element( i );

			if ( m_SavegameRestoredEnts.Find( pClass->GetID() ) == -1 )
			{
				toRespawn.AddToTail( pClass );
			}
		}
	}

	RespawnEntitiesWithEdits( toRespawn.Base(), toRespawn.Count() );

	m_SavegameRestoredEnts.Purge();
}


void CFoundryTool::MoveEntityTo( int nHammerID, const Vector &vPos, const QAngle &vAngles )
{
	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !pDoc )
	{
		Warning( "CFoundryTool::MoveEntityTo - no active CMapDoc\n" );
		return;
	}

	// 
	CMapEntity *pEnt = pDoc->FindEntityByHammerID( nHammerID );
	if ( !pEnt )
	{
		Warning( "CFoundryTool::MoveEntityTo - no entity with HammerID %d\n", nHammerID );
		return;
	}

	Vector vTempPos = vPos;
	pEnt->SetOrigin( vTempPos );

	CEditGameClass *pClass = dynamic_cast< CEditGameClass * >( pEnt );
	if ( pClass )
		pClass->SetAngles( vAngles );
}


void CFoundryTool::ClientPostRender()
{
	if ( !m_pMapDoc || !foundry_draw_hammer_entities.GetBool() )
		return;

	CMapView3D *pView = m_pMapDoc->GetFirst3DView();
	if ( !pView )
		return;


	// Store the old camera view parameters.
	CCamera *pCamera = pView->GetCamera();
	float flOldPitch = pCamera->GetPitch();
	float flOldYaw = pCamera->GetYaw();
	Vector vOldViewPoint;
	pCamera->GetViewPoint( vOldViewPoint );
	float flOldFOV = pCamera->GetFOV();
	float flOldNearClip = pCamera->GetNearClip();
	float flOldFarClip = pCamera->GetFarClip();

	// Move the Hammer camera to the engine's position for rendering.
	Vector vForward;
	AngleVectors( m_v3dViewAngles, &vForward );
	pView->SetCamera( m_v3dViewOrigin, m_v3dViewOrigin + vForward * 100 );
	pView->RenderView2( true );

	// Restore the old camera view parameters.
	pCamera->SetViewPoint( vOldViewPoint );
	pCamera->SetPerspective( flOldFOV, flOldNearClip, flOldFarClip );
	pCamera->SetPitch( flOldPitch );
	pCamera->SetYaw( flOldYaw );
}


bool CFoundryTool::SetupEngineView( Vector &origin, QAngle &angles, float &fov )
{
	m_v3dViewOrigin = origin;
	m_v3dViewAngles = angles;
	m_fl3dViewFOV = fov;

	return BaseClass::SetupEngineView( origin, angles, fov );
}


bool CFoundryTool::TrapKey( ButtonCode_t key, bool down )
{
	return BaseClass::TrapKey( key, down );
}

bool CFoundryTool::UpdateEntity( int iHammerID, CUtlVector<char*> &keys, CUtlVector<char*> &values )
{
	// Find the entity to be updated 
	void *pServerEntity = servertools->FindEntityByHammerID( iHammerID );
	if ( pServerEntity != NULL)
	{
		// Set updated properties
		for ( int i = 0; i < keys.Count(); i++ )
		{
			servertools->SetKeyValue( pServerEntity, keys[i], values[i] );
		}
		return true;
	}

	// Entity not found in running game
	return false;
}

void CFoundryTool::RespawnEntitiesWithEdits( CMapClass **ppEntities, int nEntities )
{
	CUtlVector<char> *pDatas = new CUtlVector<char>[nEntities];
	CUtlVector<CEntityRespawnInfo> respawnInfos;
	respawnInfos.SetSize( nEntities );

	int nValid = 0;
	for ( int i=0; i < nEntities; i++ )
	{
		if ( GetEntityVMFText( ppEntities[i], pDatas[nValid] ) )
		{
			respawnInfos[nValid].m_nHammerID = ppEntities[i]->GetHammerID();
			respawnInfos[nValid].m_pEntText = pDatas[nValid].Base();
			++nValid;
		}

	}

	servertools->RespawnEntitiesWithEdits( respawnInfos.Base(), nValid );

	delete [] pDatas;
}

void CFoundryTool::DestroyEntity( int iHammerID )
{
	servertools->DestroyEntityByHammerId( iHammerID );
}


void CFoundryTool::OnModeChanged()
{
	BaseClass::OnModeChanged();

	// We can get here during shutdown.
	if ( !GetMainWnd() )
		return;

	if ( IsGameInputEnabled() )
	{
		GetMainWnd()->EnableWindow( false );
		
		// Unpause the game.
		if ( foundry_auto_pause.GetInt() == 1 )
			enginetools->Command( "unpause" );
		else if ( foundry_auto_pause.GetInt() == 2 )
			enginetools->Command( "ai_setenabled 1" );
	}
	else
	{
		GetMainWnd()->EnableWindow( true );

		// Pause the game.
		if ( foundry_auto_pause.GetInt() == 1 )
			enginetools->Command( "setpause" );
		else if ( foundry_auto_pause.GetInt() == 2 )
			enginetools->Command( "ai_setenabled 0" );
	}
}	
	
void CFoundryTool::SwitchToEngine()
{
	EngineGetMouseControl();
}


void CFoundryTool::MoveEngineViewTo( const Vector &vPos, const QAngle &vAngles )
{
	servertools->MoveEngineViewTo( vPos, vAngles );
}


void CFoundryTool::MoveHammerViewTo( const Vector &vPos, const QAngle &vAngles )
{
	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !pDoc )
		return;

	POSITION p = pDoc->GetFirstViewPosition();
	while (p != NULL)
	{
		CMapView3D *pView = dynamic_cast< CMapView3D* >( pDoc->GetNextView(p) );
		if ( pView )
		{
			CCamera *pCamera = pView->GetCamera();
			pCamera->SetViewPoint( vPos );
			pCamera->SetPitch( vAngles[PITCH] );
			pCamera->SetYaw( -vAngles[YAW] + 90.0f );
			pCamera->SetRoll( 0 );
			return;
		}
	}
}


void CFoundryTool::EngineGetMouseControl()
{
	// Set focus on the engine window.
	::SetFocus( (HWND)enginetools->GetEngineHwnd() );
	SetMode( true, false );
}


void CFoundryTool::EngineReleaseMouseControl()
{
	SetMode( false, false );
}

void CFoundryTool::SelectEntities( int *pHammerIDs, int nIDs )
{
	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !pDoc )
		return;

	pDoc->ClearEntitySelection();

	for ( int i=0; i < nIDs; i++ )
	{
		CMapEntity *pEnt = pDoc->FindEntityByHammerID( pHammerIDs[i] );
		pDoc->SelectObject( pEnt, scSelect );
	}
}

void CFoundryTool::ConsoleCommand( const char *pConCommand )
{
	enginetools->Command( pConCommand );
}


bool CFoundryTool::ShouldRender3DModels()
{
	return foundry_draw_hammer_models.GetBool();
}

void CFoundryTool::SelectionClickInCenterOfView( const Vector &vPos, const QAngle &vAngles )
{
	// First move the camera
	CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
	if ( !pDoc )
		return;

	CMapView3D *pView = NULL;
	POSITION p = pDoc->GetFirstViewPosition();
	while (p != NULL)
	{
		pView = dynamic_cast< CMapView3D* >( pDoc->GetNextView(p) );
		if ( pView )
			break;
	}

	if ( !pView )
		return;

	CToolManager *pToolManager = pDoc->GetTools();
	pToolManager->SetTool( TOOL_POINTER );
	CBaseTool *pTool = pToolManager->GetActiveTool();
	if ( !pTool )
		return;

	// Setup the camera position.
	CCamera *pCamera = pView->GetCamera();
	CCamera cameraBackup = *pCamera;

	pCamera->SetViewPoint( vPos );
	pCamera->SetPitch( vAngles[PITCH] );
	pCamera->SetYaw( -vAngles[YAW] + 90.0f );
	pCamera->SetRoll( 0 );


	RECT rc;
	pView->GetClientRect( &rc );

	// Simulate a mouse click.
	Vector2D vPoint( (rc.right - rc.left) / 2, (rc.bottom - rc.top) / 2 );
	pTool->OnLMouseDown3D( pView, 0, vPoint );
	pTool->OnLMouseUp3D( pView, 0, vPoint );
	
	// Restore the camera.
	*pCamera = cameraBackup;	
}


// Called by the engine when exiting.
bool CFoundryTool::StaticQuitHandler( void *pvUserData )
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState())
	
	CMainFrame *pFrame = GetMainWnd();
	if ( pFrame )
		pFrame->PostMessageA( WM_CLOSE, 0, 0 );

	// Return false to tell the engine to ignore the quit request. If Hammer finishes up the WM_QUIT, then everything will shutdown properly.
	return false;
}


void CFoundryTool::OnMapDocDestroy( CMapDoc *pDoc )
{
	if ( m_pMapDoc == pDoc )
		m_pMapDoc = NULL;
}