// AssimilateDoc.cpp : implementation of the CAssimilateDoc class
//

#include "stdafx.h"
#include "Includes.h"
#include "BuildAll.h"
#include "sourcesafe.h"
#include "gla.h"	// just for string stuff

#include <set>
using namespace std;

#define sSAVEINFOSTRINGCHECK "(SaveInfo):"	// so comment reader can stop these damn things accumulating

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

int giLODLevelOverride = 0;	// MUST default to 0

void SS_DisposingOfCurrent(LPCSTR psFileName, bool bDirty);
static bool FileUsesGLAReference(LPCSTR psFilename, LPCSTR psGLAReference);

keywordArray_t CAssimilateDoc::s_Symbols[] = 
{
	"\\",		TK_BACKSLASH,
	"/",		TK_SLASH,
	".",		TK_DOT,
	"_",		TK_UNDERSCORE,
	"-",		TK_DASH,
	"$",		TK_DOLLAR,
	NULL,		TK_EOF,
};

keywordArray_t CAssimilateDoc::s_Keywords[] = 
{
	"aseanimgrabinit",			TK_AS_GRABINIT,
	"scale",					TK_AS_SCALE,
	"keepmotion",				TK_AS_KEEPMOTION,
	"pcj",						TK_AS_PCJ,
	"aseanimgrab",				TK_AS_GRAB,	
	"aseanimgrab_gla",			TK_AS_GRAB_GLA,
	"aseanimgrabfinalize",		TK_AS_GRABFINALIZE,
	"aseanimconvert",			TK_AS_CONVERT,
	"aseanimconvertmdx",		TK_AS_CONVERTMDX,
	"aseanimconvertmdx_noask",	TK_AS_CONVERTMDX_NOASK,
	NULL,						TK_EOF,
};

keywordArray_t CAssimilateDoc::s_grabKeywords[] = 
{
	"frames",				TK_AS_FRAMES,
	"fill",					TK_AS_FILL,
	"sound",				TK_AS_SOUND,
	"action",				TK_AS_ACTION,
	"enum",					TK_AS_ENUM,
	"loop",					TK_AS_LOOP,
	"qdskipstart",			TK_AS_QDSKIPSTART,	// useful so qdata can quickly skip extra stuff without having to know the syntax of what to skip
	"qdskipstop",			TK_AS_QDSKIPSTOP,
	"additional",			TK_AS_ADDITIONAL,
	"prequat",				TK_AS_PREQUAT,
	"framespeed",			TK_AS_FRAMESPEED,	// retro hack because original format only supported frame speeds on additional sequences, not masters
	"genloopframe",			TK_AS_GENLOOPFRAME,
	NULL,					TK_EOF,
};

keywordArray_t CAssimilateDoc::s_convertKeywords[] = 
{
	"playerparms",			TK_AS_PLAYERPARMS,
	"origin",				TK_AS_ORIGIN,
	"smooth",				TK_AS_SMOOTH,
	"losedupverts",			TK_AS_LOSEDUPVERTS,
	"makeskin",				TK_AS_MAKESKIN,
	"ignorebasedeviations",	TK_AS_IGNOREBASEDEVIATIONS,	// temporary!
	"skew90",				TK_AS_SKEW90,
	"noskew90",				TK_AS_NOSKEW90,
	"skel",					TK_AS_SKEL,
	"makeskel",				TK_AS_MAKESKEL,
	NULL,					TK_EOF,
};

LPCTSTR CAssimilateDoc::GetKeyword(int token, int table)
{
	if ((table == TABLE_ANY) || (table == TABLE_QDT))
	{
		int i = 0;
		while(s_Keywords[i].m_tokenvalue != TK_EOF)
		{
			if (s_Keywords[i].m_tokenvalue == token)
			{
				return s_Keywords[i].m_keyword;
			}
			i++;
		}
	}
	if ((table == TABLE_ANY) || (table == TABLE_GRAB))
	{
		int i = 0;
		while(s_grabKeywords[i].m_tokenvalue != TK_EOF)
		{
			if (s_grabKeywords[i].m_tokenvalue == token)
			{
				return s_grabKeywords[i].m_keyword;
			}
			i++;
		}
	}
	if ((table == TABLE_ANY) || (table == TABLE_CONVERT))
	{
		int i = 0;
		while(s_convertKeywords[i].m_tokenvalue != TK_EOF)
		{
			if (s_convertKeywords[i].m_tokenvalue == token)
			{
				return s_convertKeywords[i].m_keyword;
			}
			i++;
		}
	}
	return NULL;
}

/////////////////////////////////////////////////////////////////////////////
// CAssimilateDoc

IMPLEMENT_DYNCREATE(CAssimilateDoc, CDocument)

BEGIN_MESSAGE_MAP(CAssimilateDoc, CDocument)
	//{{AFX_MSG_MAP(CAssimilateDoc)
	ON_COMMAND(IDM_ADDFILES, OnAddfiles)
	ON_COMMAND(IDM_EXTERNAL, OnExternal)
	ON_COMMAND(IDM_RESEQUENCE, OnResequence)
	ON_COMMAND(IDM_BUILD, OnBuild)	
	ON_COMMAND(IDM_BUILD_MULTILOD, OnBuildMultiLOD)	
	ON_COMMAND(IDM_VALIDATE, OnValidate)		
	ON_COMMAND(IDM_CARWASH,  OnCarWash)
	ON_COMMAND(IDM_VALIDATE_MULTILOD, OnValidateMultiLOD)	
	ON_COMMAND(ID_VIEW_ANIMENUMS, OnViewAnimEnums)	
	ON_UPDATE_COMMAND_UI(ID_VIEW_ANIMENUMS, OnUpdateViewAnimEnums)
	ON_COMMAND(ID_VIEW_FRAMEDETAILS, OnViewFrameDetails)	
	ON_UPDATE_COMMAND_UI(ID_VIEW_FRAMEDETAILS, OnUpdateViewFrameDetails)	
	ON_UPDATE_COMMAND_UI(IDM_RESEQUENCE, OnUpdateResequence)
	ON_UPDATE_COMMAND_UI(ID_FILE_SAVE, OnUpdateFileSave)
	ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_AS, OnUpdateFileSaveAs)
	ON_UPDATE_COMMAND_UI(IDM_EXTERNAL, OnUpdateExternal)
	ON_UPDATE_COMMAND_UI(IDM_VALIDATE, OnUpdateValidate)
	ON_UPDATE_COMMAND_UI(IDM_BUILD, OnUpdateBuild)
	ON_COMMAND(ID_EDIT_BUILDALL, OnEditBuildall)
	ON_COMMAND(IDM_EDIT_BUILDDEPENDANT, OnEditBuildDependant)
	ON_COMMAND(ID_VIEW_FRAMEDETAILSONADDITIONALSEQUENCES, OnViewFramedetailsonadditionalsequences)
	ON_UPDATE_COMMAND_UI(ID_VIEW_FRAMEDETAILSONADDITIONALSEQUENCES, OnUpdateViewFramedetailsonadditionalsequences)
	ON_UPDATE_COMMAND_UI(IDM_EDIT_BUILDDEPENDANT, OnUpdateEditBuilddependant)
	ON_COMMAND(ID_EDIT_LAUNCHMODVIEWONCURRENT, OnEditLaunchmodviewoncurrent)
	ON_UPDATE_COMMAND_UI(ID_EDIT_LAUNCHMODVIEWONCURRENT, OnUpdateEditLaunchmodviewoncurrent)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CAssimilateDoc construction/destruction

CAssimilateDoc::CAssimilateDoc()
{
	// TODO: add one-time construction code here
	Init();
}

CAssimilateDoc::~CAssimilateDoc()
{
}

BOOL CAssimilateDoc::OnNewDocument()
{
	SS_DisposingOfCurrent(m_strPathName, !!IsModified());

	if (!CDocument::OnNewDocument())
		return FALSE;

	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)

	SetTitle("Untitled");	// for some reason MFC doesn't do this from time to time

	return TRUE;
}

void CAssimilateDoc::Init()
{
	m_comments = NULL;
	m_modelList = NULL;
	m_curModel = NULL;
	m_lastModel = NULL;
}

/////////////////////////////////////////////////////////////////////////////
// CAssimilateDoc serialization

CModel* CAssimilateDoc::AddModel()
{
	CModel* thisModel = CModel::Create(m_comments);
	m_comments = NULL;
	if (m_modelList == NULL)
	{
		m_modelList = thisModel;
	}
	else
	{
		CModel* curModel = m_modelList;
		while (curModel->GetNext() != NULL)
		{
			curModel = curModel->GetNext();
		}
		curModel->SetNext(thisModel);
	}
	m_curModel = thisModel;

	return m_curModel;
}

//	remember to account for Mike's m_lastModel and move it down if necessary (until I can throw it away)...
//
void CAssimilateDoc::DeleteModel(CModel *deleteModel)
{
	// linklist is only 1-way, so we need to find the stage previous to this (if any)...
	//
	CModel* prevModel = NULL;
	CModel* scanModel = GetFirstModel();

	while (scanModel && scanModel != deleteModel)
	{
		prevModel = scanModel;
		scanModel = scanModel->GetNext();
	}
	if (scanModel == deleteModel)
	{
		// we found it, so was this the first model in the list?
		//
		if (prevModel)
		{
			prevModel->SetNext(scanModel->GetNext());	// ...no
		}
		else
		{
			m_modelList = scanModel->GetNext();			// ...yes
		}
		scanModel->Delete();
	}

	// fixme: ditch this whenever possible
	// keep Mike's var up to date...
	//
	scanModel = GetFirstModel();	
	while(scanModel && scanModel->GetNext())
	{
		scanModel = scanModel->GetNext();
	}
	m_lastModel = scanModel;
}

void CAssimilateDoc::EndModel()
{
	m_lastModel = m_curModel;
	m_curModel = NULL;
}

// XSI or GLA anim grab...
//
void CAssimilateDoc::ParseGrab(CTokenizer* tokenizer, int iGrabType)
{
	if (m_curModel == NULL)
	{
		tokenizer->Error("Grab without an active model");
		tokenizer->GetToEndOfLine()->Delete();
		return;
	}
	CToken* curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL, 0);
	if (curToken->GetType() != TK_IDENTIFIER)
	{
		tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
		curToken->Delete();
		tokenizer->GetToEndOfLine()->Delete();
		return;
	}
	CString path = curToken->GetStringValue();
	curToken->Delete();

	while(curToken != NULL)
	{
		curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);
		switch(curToken->GetType())
		{
		case TK_SLASH:
		case TK_BACKSLASH:
			path += "/";
			curToken->Delete();
			curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);

			// hack for "8472" as in models/players/8472/blah.car. Arrggh!!!!!!!!!!!!!!!!!!
			//
			if (curToken->GetType() == TK_INT)
			{
				path += curToken->GetStringValue();
				curToken->Delete();
				break;
			}

			if (curToken->GetType() != TK_IDENTIFIER)
			{
				tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			path += curToken->GetStringValue();
			curToken->Delete();
			break;
		case TK_UNDERSCORE:
		case TK_DASH:
			path += curToken->GetStringValue();
			curToken->Delete();
			curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);
			if (curToken->GetType() != TK_IDENTIFIER)
			{
				tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			path += curToken->GetStringValue();
			curToken->Delete();
			break;
		case TK_DOT:
			path += curToken->GetStringValue();
			curToken->Delete();
			curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);
			if (curToken->GetType() != TK_IDENTIFIER)
			{
				tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			path += curToken->GetStringValue();
			curToken->Delete();
			curToken = NULL;
			break;
		case TK_SPACE:
			curToken->Delete();
			curToken = NULL;
			break;
		case TK_EOL:
			tokenizer->PutBackToken(curToken);			
			curToken = NULL;
			break;
		default:
			tokenizer->PutBackToken(curToken);
			curToken = NULL;
			break;
		}
	}

	CString enumname;
	int fill = -1;
	int loop = 0;
	CString sound;
	CString action;	
	int startFrame = 0;
	int targetFrame = 0;
	int framecount = -1;
	int framespeed = iDEFAULTSEQFRAMESPEED;
	bool bFrameSpeedFound = false;
	int iFrameSpeedFromHeader;
	//
	int iStartFrames[MAX_ADDITIONAL_SEQUENCES]={0};
	int iFrameCounts[MAX_ADDITIONAL_SEQUENCES]={0};
	int iLoopFrames [MAX_ADDITIONAL_SEQUENCES]={0};
	int iFrameSpeeds[MAX_ADDITIONAL_SEQUENCES]={0};
	CString csEnums [MAX_ADDITIONAL_SEQUENCES];
	int iAdditionalSeqNum = 0;
	bool bGenLoopFrame = false;

	bool bSomeParamsFound = false;

	curToken = tokenizer->GetToken(TKF_USES_EOL);
	switch (iGrabType)
	{
		case TK_AS_GRAB:
		{			
			while (curToken->GetType() == TK_DASH)
			{
				bSomeParamsFound = true;
				curToken->Delete();
				curToken = tokenizer->GetToken(s_grabKeywords, TKF_USES_EOL, 0);
				switch (curToken->GetType())
				{
				case TK_AS_FRAMES:
					curToken->Delete();

					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					startFrame = curToken->GetIntValue();
					curToken->Delete();

					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					targetFrame = curToken->GetIntValue();
					curToken->Delete();

					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					framecount = curToken->GetIntValue();
					break;
				case TK_AS_FILL:
					curToken->Delete();

					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					fill = curToken->GetIntValue();
					break;
				case TK_AS_ENUM:
					curToken->Delete();

					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_IDENTIFIER)
					{
						tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					enumname = curToken->GetStringValue();
					break;
				case TK_AS_SOUND:
					curToken->Delete();

					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_IDENTIFIER)
					{
						tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					sound = curToken->GetStringValue();
					break;
				case TK_AS_ACTION:
					curToken->Delete();

					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_IDENTIFIER)
					{
						tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					action = curToken->GetStringValue();
					break;
				case TK_AS_LOOP:
					curToken->Delete();

					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					loop = curToken->GetIntValue();
					break;

				case TK_AS_QDSKIPSTART:
				case TK_AS_QDSKIPSTOP:
					//curToken->Delete();	// don't do this, the whole thing relies on case statements leaving one current token for the outside loop to delete
					break;

				case TK_AS_GENLOOPFRAME:
					bGenLoopFrame = true;
					break;

				case TK_AS_FRAMESPEED:	// this is still read in for compatibility, but gets overwritten lower down
					curToken->Delete();

					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					framespeed = curToken->GetIntValue();
					bFrameSpeedFound = true;
					break;

				case TK_AS_PREQUAT:					
					m_curModel->SetPreQuat(true);
					break;
				case TK_AS_ADDITIONAL:
					curToken->Delete();

					if (iAdditionalSeqNum == MAX_ADDITIONAL_SEQUENCES)
					{
						tokenizer->Error(TKERR_USERERROR, va("Trying to define > %d additional sequences for this master",MAX_ADDITIONAL_SEQUENCES));
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}

					// startframe...
					//
					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					iStartFrames[iAdditionalSeqNum] = curToken->GetIntValue();

					// framecount...
					//
					curToken->Delete();
					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					iFrameCounts[iAdditionalSeqNum] = curToken->GetIntValue();

					// loopframe...
					//
					curToken->Delete();
					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					iLoopFrames[iAdditionalSeqNum] = curToken->GetIntValue();

					// framespeed...
					//
					curToken->Delete();
					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_INTEGER)
					{
						tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					iFrameSpeeds[iAdditionalSeqNum] = curToken->GetIntValue();

					// enum...
					//
					curToken->Delete();
					curToken = tokenizer->GetToken(NULL, TKF_USES_EOL, 0);
					if (curToken->GetType() != TK_IDENTIFIER)
					{
						tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}
					csEnums[iAdditionalSeqNum] = curToken->GetStringValue();

					iAdditionalSeqNum++;
					break;

				default:
					tokenizer->Error(TKERR_UNEXPECTED_TOKEN, curToken->GetStringValue());
					curToken->Delete();
					tokenizer->GetToEndOfLine()->Delete();
					return;
				}
				curToken->Delete();
				curToken = tokenizer->GetToken(s_grabKeywords, TKF_USES_EOL, 0);
			}
		}
		break;

		case TK_AS_GRAB_GLA:
		{
			// no additional params permitted for this type currently...
			//
		}
		break;
	}

	path.MakeLower();
	//
	// if no extension, assume ".xsi"... (or ".gla" now)
	//
	if (!(path.GetAt(path.GetLength()-4) == '.'))
	{
		path += (iGrabType == TK_AS_GRAB)?".xsi":".gla";
	}

	if (curToken->GetType() != TK_EOL)
	{
		tokenizer->Error(TKERR_UNEXPECTED_TOKEN, curToken->GetStringValue());
		curToken->Delete();
		tokenizer->GetToEndOfLine()->Delete();
		return;
	}

	// ignore any user params about speed and frame counts, and just re-grab them from the XSI file...
	//
//	if (bSomeParamsFound)
//	{
//	}
//	else
	{
		// at this point, it must be one of the paramless entries in a .CAR file, so we need to
		//	provide the values for: startFrame, targetFrame, framecount
		//
		// read in values from the actual file, in case we need to use them...
		//
		CString nameASE = ((CAssimilateApp*)AfxGetApp())->GetQuakeDir();
				nameASE+= path;
		int iStartFrame, iFrameCount;
		ReadASEHeader( nameASE, iStartFrame, iFrameCount, iFrameSpeedFromHeader, (iGrabType == TK_AS_GRAB_GLA) );

//		if (strstr(nameASE,"death16"))
//		{
//			int z=1;
//		}

		startFrame = 0;	// always
		targetFrame= 0;	// any old shite value
		framecount = iFrameCount;
		
		if (iGrabType != TK_AS_GRAB_GLA)
		{
			if (!bFrameSpeedFound)
			{
				framespeed = iFrameSpeedFromHeader;
			}
		}
	}

	curToken->Delete();

	CSequence* sequence = CSequence::_Create(bGenLoopFrame,(iGrabType == TK_AS_GRAB_GLA), path, startFrame, targetFrame, framecount, framespeed, iFrameSpeedFromHeader);
	m_curModel->AddSequence(sequence);
	sequence->AddComment(m_curModel->ExtractComments());
	sequence->DeriveName();
	if (enumname.IsEmpty())
	{
		sequence->SetEnum(sequence->GetName());
	}
	else
	{
		sequence->SetEnum(enumname);
	}
	sequence->SetFill(fill);
	sequence->SetSound(sound);
	sequence->SetAction(action);
	sequence->SetValidEnum(((CAssimilateApp*)AfxGetApp())->ValidEnum(sequence->GetEnum()));
	sequence->SetLoopFrame(loop);

	for (int i=0; i<MAX_ADDITIONAL_SEQUENCES; i++)
	{
		sequence->AdditionalSeqs[i]->SetStartFrame(iStartFrames[i]);
		sequence->AdditionalSeqs[i]->SetFrameCount(iFrameCounts[i]);
		sequence->AdditionalSeqs[i]->SetFrameSpeed(iFrameSpeeds[i]);
		sequence->AdditionalSeqs[i]->SetLoopFrame (iLoopFrames [i]);
		sequence->AdditionalSeqs[i]->SetEnum	  (csEnums	   [i]);
		sequence->AdditionalSeqs[i]->SetValidEnum (((CAssimilateApp*)AfxGetApp())->ValidEnum(sequence->AdditionalSeqs[i]->GetEnum()));
	}
}


// return = success.  if false ret, return from caller because of error
//
bool Tokenizer_ReadPath(CString& path, CTokenizer* &tokenizer, CToken* &curToken )
{
	curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL, 0);
	if (curToken->GetType() != TK_IDENTIFIER)
	{
		tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
		curToken->Delete();
		tokenizer->GetToEndOfLine()->Delete();
		return false;
	}
	path += curToken->GetStringValue();
	curToken->Delete();

	while(curToken != NULL)
	{
		curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | (path.IsEmpty()?0:TKF_SPACETOKENS), 0);
		switch(curToken->GetType())
		{
		case TK_SLASH:
		case TK_BACKSLASH:
			path += "/";
			curToken->Delete();
			curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);

			// hack for "8472" as in models/players/8472/blah.car. Arrggh!!!!!!!!!!!!!!!!!!
			//
			if (curToken->GetType() == TK_INT)
			{
				path += curToken->GetStringValue();
				curToken->Delete();
				break;
			}

			if (curToken->GetType() != TK_IDENTIFIER)
			{
				tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return false;
			}
			path += curToken->GetStringValue();
			curToken->Delete();
			break;
		case TK_UNDERSCORE:
		case TK_DASH:
			path += curToken->GetStringValue();
			curToken->Delete();
			curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);
			if (curToken->GetType() != TK_IDENTIFIER)
			{
				tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return false;
			}
			path += curToken->GetStringValue();
			curToken->Delete();
			break;
		case TK_DOT:
			path += curToken->GetStringValue();
			curToken->Delete();
			curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);
			if (curToken->GetType() != TK_IDENTIFIER)
			{
				tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return false;
			}
			path += curToken->GetStringValue();
			curToken->Delete();
			curToken = NULL;
			break;
		case TK_SPACE:
		case TK_EOL:
			curToken->Delete();
			curToken = NULL;
			break;
		default:
			tokenizer->PutBackToken(curToken);
			curToken = NULL;
			break;
		}
	}

	return true;
}

void CAssimilateDoc::ParseConvert(CTokenizer* tokenizer, int iTokenType)
{
	if (m_lastModel == NULL)
	{
		tokenizer->Error("Convert without an internal model");
		tokenizer->GetToEndOfLine()->Delete();
		return;
	}
	CToken* curToken = NULL;
	CString path;	

	if (!Tokenizer_ReadPath(path, tokenizer, curToken ))
		return;
/*
	while(curToken != NULL)
	{
		curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);
		switch(curToken->GetType())
		{
		case TK_SLASH:
		case TK_BACKSLASH:
			path += "/";
			curToken->Delete();
			curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);

			// hack for "8472" as in models/players/8472/blah.car. Arrggh!!!!!!!!!!!!!!!!!!
			//
			if (curToken->GetType() == TK_INT)
			{
				path += curToken->GetStringValue();
				curToken->Delete();
				break;
			}

			if (curToken->GetType() != TK_IDENTIFIER)
			{
				tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			path += curToken->GetStringValue();
			curToken->Delete();
			break;
		case TK_UNDERSCORE:
		case TK_DASH:
			path += curToken->GetStringValue();
			curToken->Delete();
			curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);
			if (curToken->GetType() != TK_IDENTIFIER)
			{
				tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			path += curToken->GetStringValue();
			curToken->Delete();
			break;
		case TK_DOT:
			path += curToken->GetStringValue();
			curToken->Delete();
			curToken = tokenizer->GetToken(NULL, TKF_NUMERICIDENTIFIERSTART | TKF_USES_EOL | TKF_SPACETOKENS, 0);
			if (curToken->GetType() != TK_IDENTIFIER)
			{
				tokenizer->Error(TKERR_EXPECTED_IDENTIFIER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			path += curToken->GetStringValue();
			curToken->Delete();
			curToken = NULL;
			break;
		case TK_SPACE:
		case TK_EOL:
			curToken->Delete();
			curToken = NULL;
			break;
		default:
			tokenizer->PutBackToken(curToken);
			curToken = NULL;
			break;
		}
	}
*/
	int originx = 0;	// important to default to 0!
	int originy = 0;	//
	int originz = 0;	//
	int parm1 = 0;
	int parm2 = 0;
	int parm3 = 0;
	int parm4 = 0;

	curToken = tokenizer->GetToken();
	while(curToken->GetType() == TK_DASH)
	{
		curToken->Delete();
		curToken = tokenizer->GetToken(s_convertKeywords, 0, 0);
		switch(curToken->GetType())
		{
		case TK_AS_ORIGIN:
			curToken->Delete();
			curToken = tokenizer->GetToken();
			if (curToken->GetType() != TK_INTEGER)
			{
				tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			originx = curToken->GetIntValue();
			curToken->Delete();
			curToken = tokenizer->GetToken();
			if (curToken->GetType() != TK_INTEGER)
			{
				tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			originy = curToken->GetIntValue();
			curToken->Delete();
			curToken = tokenizer->GetToken();
			if (curToken->GetType() != TK_INTEGER)
			{
				tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			originz = curToken->GetIntValue();
			curToken->Delete();
			curToken = tokenizer->GetToken();
			break;
		case TK_AS_PLAYERPARMS:
			curToken->Delete();
			curToken = tokenizer->GetToken();
			if (curToken->GetType() != TK_INTEGER)
			{
				tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			parm1 = curToken->GetIntValue();
			curToken->Delete();
/* this param no longer exists...
			curToken = tokenizer->GetToken();
			if (curToken->GetType() != TK_INTEGER)
			{
				tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			parm2 = curToken->GetIntValue();
			curToken->Delete();
*/			
			curToken = tokenizer->GetToken();
			if (curToken->GetType() != TK_INTEGER)
			{
				tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			parm3 = curToken->GetIntValue();
			curToken->Delete();

/*	this param no longer exists...
			curToken = tokenizer->GetToken();
			if (curToken->GetType() != TK_INTEGER)
			{
				tokenizer->Error(TKERR_EXPECTED_INTEGER, curToken->GetStringValue());
				curToken->Delete();
				tokenizer->GetToEndOfLine()->Delete();
				return;
			}
			parm4 = curToken->GetIntValue();
			curToken->Delete();
*/			parm4 = 1;

			curToken = tokenizer->GetToken();
			break;
		case TK_AS_SMOOTH:
			curToken->Delete();
			m_lastModel->SetSmooth(true);
			curToken = tokenizer->GetToken();
			break;
		case TK_AS_LOSEDUPVERTS:
			curToken->Delete();
			m_lastModel->SetLoseDupVerts(true);
			curToken = tokenizer->GetToken();
			break;
		case TK_AS_MAKESKIN:
			curToken->Delete();
			m_lastModel->SetMakeSkin(true);
			curToken = tokenizer->GetToken();
			break;
		case TK_AS_IGNOREBASEDEVIATIONS:
			curToken->Delete();
			m_lastModel->SetIgnoreBaseDeviations(true);
			curToken = tokenizer->GetToken();
			break;
		case TK_AS_SKEW90:
			curToken->Delete();
			m_lastModel->SetSkew90(true);
			curToken = tokenizer->GetToken();
			break;
		case TK_AS_NOSKEW90:
			curToken->Delete();
			m_lastModel->SetNoSkew90(true);
			curToken = tokenizer->GetToken();
			break;
/*
		case TK_AS_SKEL:
			{
				CString strSkelPath;
				curToken->Delete();

				if (!Tokenizer_ReadPath(strSkelPath, tokenizer, curToken ))
				{
					return;	
				}
				m_lastModel->SetSkelPath(strSkelPath);
				m_lastModel->SetMakeSkelPath("");
				curToken = tokenizer->GetToken();
			}
			break;
*/
		case TK_AS_MAKESKEL:
			{
				CString strMakeSkelPath;
				curToken->Delete();

				if (!Tokenizer_ReadPath(strMakeSkelPath, tokenizer, curToken))
				{
					return;
				}
				m_lastModel->SetMakeSkelPath(strMakeSkelPath);
//				m_lastModel->SetSkelPath("");
				curToken = tokenizer->GetToken();
			}
			break;
		default:
			tokenizer->Error(TKERR_UNEXPECTED_TOKEN, curToken->GetStringValue());
			curToken->Delete();
			tokenizer->GetToEndOfLine()->Delete();
			return;
		}
	}
	tokenizer->PutBackToken(curToken);
	path.MakeLower();
	m_lastModel->DeriveName(path);
	m_lastModel->SetParms(parm1, parm2, parm3, parm4);
	m_lastModel->SetOrigin(originx, originy, originz);
	m_lastModel->SetConvertType(iTokenType);
}

void CAssimilateDoc::AddComment(LPCTSTR comment)
{
	// some code to stop those damn timestamps accumulating...
	//
	if (!strnicmp(comment,sSAVEINFOSTRINGCHECK,strlen(sSAVEINFOSTRINGCHECK)))
	{
		return;
	}
	CComment* thisComment = CComment::Create(comment);
	if (m_curModel != NULL)
	{
		m_curModel->AddComment(thisComment);
		return;
	}
	if (m_comments == NULL)
	{
		m_comments = thisComment;
	}
	else
	{
		CComment* curComment = m_comments;
		while (curComment->GetNext() != NULL)
		{
			curComment = curComment->GetNext();
		}
		curComment->SetNext(thisComment);
	}
}

///////////////////////////////////////////////

#define	MAX_FOUND_FILES	0x1000
#define MAX_OSPATH MAX_PATH
#include <stdio.h>
#include <io.h>

char **Sys_ListFiles( const char *directory, const char *extension, int *numfiles ) {
	char		search[MAX_OSPATH];
	int			nfiles;
	char		**listCopy;
	char		*list[MAX_FOUND_FILES];
	struct _finddata_t findinfo;
	int			findhandle;
	int			flag;
	int			i;

	if ( !extension) {
		extension = "";
	}

	if ( extension[0] == '/' && extension[1] == 0 ) {
		extension = "";
		flag = 0;
	} else {
		flag = _A_SUBDIR;
	}

	sprintf( search, "%s\\*%s", directory, extension );

	// search
	nfiles = 0;

	findhandle = _findfirst (search, &findinfo);
	if (findhandle == -1) {
		*numfiles = 0;
		return NULL;
	}

	do {
		if ( flag ^ ( findinfo.attrib & _A_SUBDIR ) ) {
			if ( nfiles == MAX_FOUND_FILES - 1 ) {
				break;
			}
			list[ nfiles ] = strdup( strlwr(findinfo.name) );
			nfiles++;
		}
	} while ( _findnext (findhandle, &findinfo) != -1 );

	list[ nfiles ] = 0;

	_findclose (findhandle);

	// return a copy of the list
	*numfiles = nfiles;

	if ( !nfiles ) {
		return NULL;
	}

	listCopy = (char **) malloc( ( nfiles + 1 ) * sizeof( *listCopy ) );
	for ( i = 0 ; i < nfiles ; i++ ) {
		listCopy[i] = list[i];
	}
	listCopy[i] = NULL;

	return listCopy;
}

void	Sys_FreeFileList( char **_list ) {
	int		i;

	if ( !_list ) {
		return;
	}

	for ( i = 0 ; _list[i] ; i++ ) {
		free( _list[i] );
	}

	free( _list );
}

//////////////////////////////////////////

CString strSkippedFiles;
CString strSkippedDirs;
CString strCARsFound;
int iCARsFound = 0;

void AlphaSortCARs(void)
{
	typedef set <string>	SortedStrings_t;
							SortedStrings_t SortedStrings;

	for (int i=0; i<iCARsFound; i++)
	{
		CString strThisFile = strCARsFound;
		int iLoc = strThisFile.Find("\n");
		if (iLoc>=0)
		{
			SortedStrings.insert(SortedStrings.end(), (LPCSTR)(strThisFile.Left(iLoc)));
			strCARsFound= strCARsFound.Mid(iLoc+1);
		}
	}

	// clear files-found string out, and re-enter from sorted set...
	//
	strCARsFound = "";

	for (SortedStrings_t::iterator it = SortedStrings.begin(); it != SortedStrings.end(); ++it)
	{
		strCARsFound += (*it).c_str();
		strCARsFound += "\n";
	}
}

void R_CheckCARs( LPCSTR psDir, int iScanDepth, LPCSTR psGLAReferenceItShouldInclude )
{
	((CMainFrame*)AfxGetMainWnd())->StatusMessage(va("(%d .CAR files found so far) Scanning Dir: %s",iCARsFound,psDir));

	// ignore any dir with "test" in it...
	//
	if (//strstr(psDir,"\\test")
		//||
		strstr(psDir,"\\backup")
		||
		strstr(psDir,"\\ignore_")
		)
	{
		strSkippedDirs += psDir;
		strSkippedDirs += "\n";
		return;
	}

	char	**sysFiles, **dirFiles;//, *args[5];
	int		numSysFiles, i, /*len,*/ numdirs;
	char	altname[MAX_OSPATH];
//	char	command1[MAX_OSPATH];
//	char	command2[MAX_OSPATH];

	dirFiles = Sys_ListFiles(psDir, "/", &numdirs);
	if (numdirs > 2)
	{
//		if (!iScanDepth)	// recursion limiter, to avoid scanning backup subdirs within model subdirs
		{
			for (i=2;i<numdirs;i++)
			{
				sprintf(altname, "%s\\%s", psDir, dirFiles[i]);
				//if (stricmp(altname,"q:\\send\\quake\\baseq3\\models\\players"))	// dont recurse this dir
				{
					R_CheckCARs(altname, iScanDepth+1, psGLAReferenceItShouldInclude );
				}
			}
		}
	}
//	sprintf(command1, "-targa");
//	sprintf(command2, "-outfile");
	sysFiles = Sys_ListFiles( psDir, ".car", &numSysFiles );
	for ( i=0; i<numSysFiles; i++ )
	{
		CString strThisFile = va("%s\\%s", psDir, sysFiles[i]);

		if (strstr((LPCSTR) strThisFile,"copy of "))
		{
			strSkippedFiles += strThisFile;
			strSkippedFiles += "\n";
			continue;
		}

		if (psGLAReferenceItShouldInclude && psGLAReferenceItShouldInclude [0]
			&&
			!FileUsesGLAReference(strThisFile, psGLAReferenceItShouldInclude)
			)
		{
			strSkippedFiles += strThisFile;
			strSkippedFiles += "\n";
			continue;
		}

		strCARsFound += strThisFile + "\n";
		iCARsFound++;
	/*		char	tgain[MAX_OSPATH];
			sprintf(tgain,"%s\\%s", psDir, sysFiles[i]);
			strcpy( altname, tgain );
			len = strlen( altname );
			altname[len-3] = 'j';
			altname[len-2] = 'p';
			altname[len-1] = 'g';
			args[0] = "cjpeg";
			args[1] = command2;
			args[2] = altname;
			args[3] = command1;
			args[4] = tgain;
			//printf("%s", tgain);
	*/		
			/*		len = qmain(5, args);
			if (!len) 
			{
			iNumberOf_FilesConverted++;
			iSizeOf_JPGsWritten += scGetFileLen(altname);
			iSizeOf_TGAsDeleted += scGetFileLen(tgain);
			
			  printf(" nuked!(NOT)");
			  //			remove(tgain);
			  }
			  printf("\n");
			*/
	/*		
			byte * pPixels = NULL;
			int iWidth;
			int iHeight;
			bool bRedundant = ScanTGA(tgain, &pPixels, &iWidth, &iHeight);
			if (pPixels)
			{
				free(pPixels);
			}
			
			if (bRedundant)
			{
				strTGAsWithRedundantAlpha += va("%s\n",tgain);
				iRedundantFilesFound++;
			}
	*/
	}

	Sys_FreeFileList( sysFiles );
	Sys_FreeFileList( dirFiles );
}

void CAssimilateDoc::Parse(CFile* file)
{
	Parse(file->GetFilePath());
}

void CAssimilateDoc::Parse(LPCSTR psFilename)
{	
	gbParseError = false;
	CAlertErrHandler errhandler;
	CTokenizer* tokenizer = CTokenizer::Create(TKF_NOCASEKEYWORDS | TKF_COMMENTTOKENS);
	tokenizer->SetErrHandler(&errhandler);
	tokenizer->SetSymbols(s_Symbols);
	tokenizer->SetKeywords(s_Keywords);
	tokenizer->AddParseFile(psFilename);

	extern bool gbSkipXSIRead_QuestionAsked;
	extern bool gbSkipXSIRead;
	gbSkipXSIRead_QuestionAsked = false;	// opening a new file so reset our question
	gbSkipXSIRead = false;

	int tokType = TK_UNDEFINED;
	while(tokType != TK_EOF)
	{
		CToken* curToken = tokenizer->GetToken();
		tokType = curToken->GetType();
		switch(tokType)
		{
		case TK_EOF:
			curToken->Delete();
			break;
		case TK_DOLLAR:
			curToken->Delete();
			curToken = tokenizer->GetToken();
			switch(curToken->GetType())
			{
			case TK_AS_GRABINIT:
				curToken->Delete();
				AddModel();
				break;
			case TK_AS_SCALE:
				curToken->Delete();
				curToken = tokenizer->GetToken();
				if (curToken->GetType() != TK_FLOAT && curToken->GetType() != TK_INT)
				{
					tokenizer->Error(TKERR_EXPECTED_FLOAT, curToken->GetStringValue());
					curToken->Delete();
					tokenizer->GetToEndOfLine()->Delete();
					return;
				}
				m_curModel->SetScale((curToken->GetType() == TK_FLOAT)?curToken->GetFloatValue():curToken->GetIntValue());
				curToken->Delete();				
				break;
			case TK_AS_KEEPMOTION:
				curToken->Delete();
				m_curModel->SetKeepMotion(true);
				break;
			case TK_AS_PCJ:
				curToken->Delete();
				curToken = tokenizer->GetToken();
				if (curToken->GetType() != TK_IDENTIFIER && curToken->GetType() != TK_DOLLAR)	// eg:  '$pcj pelvis'   or   '$pcj $flatten'
				{
					tokenizer->Error(TKERR_EXPECTED_STRING, curToken->GetStringValue());
					curToken->Delete();
					tokenizer->GetToEndOfLine()->Delete();
					return;
				}
				if (curToken->GetType() == TK_DOLLAR)	// read string after '$' char
				{
					curToken->Delete();
					curToken = tokenizer->GetToken();
					if (curToken->GetType() != TK_IDENTIFIER)
					{
						tokenizer->Error(TKERR_EXPECTED_STRING, curToken->GetStringValue());
						curToken->Delete();
						tokenizer->GetToEndOfLine()->Delete();
						return;
					}

					m_curModel->PCJList_AddEntry(va("$%s",curToken->GetStringValue()));
				}
				else
				{	
					m_curModel->PCJList_AddEntry(curToken->GetStringValue());
				}
				curToken->Delete();
				break;
			case TK_AS_GRAB:
				curToken->Delete();
				ParseGrab(tokenizer,TK_AS_GRAB);
				break;
			case TK_AS_GRAB_GLA:
				curToken->Delete();
				ParseGrab(tokenizer,TK_AS_GRAB_GLA);
				break;
			case TK_AS_GRABFINALIZE:
				curToken->Delete();
				EndModel();
				break;
			case TK_AS_CONVERT:
				curToken->Delete();
				ParseConvert(tokenizer,TK_AS_CONVERT);
				break;
			case TK_AS_CONVERTMDX:
				curToken->Delete();
				ParseConvert(tokenizer,TK_AS_CONVERTMDX);
				break;
			case TK_AS_CONVERTMDX_NOASK:
				curToken->Delete();
				ParseConvert(tokenizer,TK_AS_CONVERTMDX_NOASK);
				break;
			case TK_COMMENT:
				AddComment(curToken->GetStringValue());
				curToken->Delete();
				break;
			default:
				tokenizer->Error(TKERR_UNEXPECTED_TOKEN);
				curToken->Delete();
				break;
			}
			break;
		case TK_COMMENT:
			AddComment(curToken->GetStringValue());
			curToken->Delete();
			break;
		default:
			tokenizer->Error(TKERR_UNEXPECTED_TOKEN);
			curToken->Delete();
			break;
		}
	}
	tokenizer->Delete();
	UpdateAllViews(NULL, AS_NEWFILE, NULL);
	Resequence();
}

void CAssimilateDoc::Write(CFile* file)
{
	CTxtFile* outfile = CTxtFile::Create(file);

/*	// write out time/date stamp...
	//
	CString commentLine;
	CTime time = CTime::GetCurrentTime();
	commentLine.Format("// %s %s updated %s", sSAVEINFOSTRINGCHECK, file->GetFileName(), time.Format("%H:%M %A, %B %d, %Y"));
	outfile->Writeln(commentLine);
*/	
	CModel* curModel = m_modelList;
	while(curModel != NULL)
	{
		curModel->Write(outfile);
		curModel = curModel->GetNext();
	}
	CComment* curComment = m_comments;
	while(curComment != NULL)
	{
		curComment->Write(outfile);
		curComment = curComment->GetNext();
	}
	outfile->Delete();
}

void CAssimilateDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
		Write(ar.GetFile());
	}
	else
	{
		// TODO: add loading code here
		Parse(ar.GetFile());
	}
}

/////////////////////////////////////////////////////////////////////////////
// CAssimilateDoc diagnostics

#ifdef _DEBUG
void CAssimilateDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CAssimilateDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CAssimilateDoc commands

void CAssimilateDoc::DeleteContents() 
{
	// TODO: Add your specialized code here and/or call the base class
	UpdateAllViews(NULL, AS_DELETECONTENTS, NULL);

	while(m_comments != NULL)
	{
		CComment* curComment = m_comments;
		m_comments = curComment->GetNext();
		curComment->Delete();
	}
	while(m_modelList != NULL)
	{
		CModel* curModel = m_modelList;
		m_modelList = curModel->GetNext();
		curModel->Delete();
	}
	m_curModel = NULL;
	m_lastModel = NULL;

	gbReportMissingASEs = true;	
	giFixUpdatedASEFrameCounts = YES;

	CDocument::DeleteContents();
}

CModel* CAssimilateDoc::GetFirstModel()
{
	return m_modelList;
}

int CAssimilateDoc::GetNumModels()
{
	int iCount = 0;
	CModel *theModel = m_modelList;

	while (theModel)
	{
		iCount++;
		theModel = theModel->GetNext();
	}

	return iCount;
}

void CAssimilateDoc::OnAddfiles() 
{
	// TODO: Add your command handler code here
	CFileDialog theDialog(true, ".xsi", NULL, OFN_EXPLORER | OFN_ALLOWMULTISELECT | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST, 
					_T("Anim Files (*.ase)(*.xsi)(*.gla)|*.ase;*.xsi;*.gla|All Files|*.*||"), NULL);
					
////////////
//	Model files (*.MDR)(*.MD3)|*.md?|
////////////
	char filenamebuffer[16384];
	filenamebuffer[0] = '\0';
	theDialog.m_ofn.lpstrFile = filenamebuffer;
	theDialog.m_ofn.nMaxFile = sizeof(filenamebuffer);

	CString 
	strInitialDir = ((CAssimilateApp*)AfxGetApp())->GetQuakeDir();
	strInitialDir+= "models/players";
	strInitialDir.Replace("/","\\");

	theDialog.m_ofn.lpstrInitialDir = strInitialDir;

	int result = theDialog.DoModal();
	if (result != IDOK)
	{
		return;
	}

	CWaitCursor waitcursor;

	POSITION pos = theDialog.GetStartPosition();
	while(pos != NULL)
	{
		CString thisfile = theDialog.GetNextPathName(pos);
/*		int loc = thisfile.Find(':');
		if (loc > 0)
		{
			thisfile = thisfile.Right(thisfile.GetLength() - loc - 1);
		}
*/
		Filename_RemoveBASEQ(thisfile);
		AddFile(thisfile);		
	}
	SetModifiedFlag();
	UpdateAllViews(NULL, AS_NEWFILE, NULL);
	Resequence();	// must be AFTER UpdateAllViews
}

void CAssimilateDoc::AddFile(LPCTSTR name)
{
	CString strTemp(name);
			strTemp.MakeLower();
	if (!strstr(strTemp,"root.xsi") || GetYesNo("You're trying to add \"root.xsi\", which is inherent, you should only do this if you're making a model that has no seperate anim files\n\nProceed?"))
	{	
		// update, ignore any files with a "_1" (2,3, etc) just before the suffix (this skips LOD files)...
		//
//		int iNameLen = strlen(name);

		// (also, only check files of at least namelen "_?.ase")
		//
//		if ( iNameLen>6 && name[iNameLen-6]=='_' && isdigit(name[iNameLen-5]) )
		{
			// this is a LOD filename, so ignore it...
		}
//		else
		{
			CModel *curModel = GetCurrentUserSelectedModel();

			if (!curModel)
			{
				curModel = AddModel();	
			
				CString path = name;
				path.MakeLower();
				path.Replace('\\', '/');
				int loc = path.ReverseFind('.');
				if (loc > -1)
				{
					path = path.Left(loc);
				}
				loc = path.ReverseFind('/');
				path = path.Left(loc);
				path = path + "/root";
				curModel->DeriveName(path);
			}

			// check that we don't already have this file...
			//
			if (!curModel->ContainsFile(name))
			{
				curModel->AddSequence(CSequence::CreateFromFile(name, curModel->ExtractComments()));
			}
		}
	}
}

void CAssimilateDoc::OnExternal()
{		
	bool bCFGWritten = false;

	if (WriteCFGFiles(true,bCFGWritten))
	{
		CString strReport;	

		if (bCFGWritten)
		{		
			if (((CAssimilateApp*)AfxGetApp())->GetMultiPlayerMode())
			{
				strReport = "\n\n( CFG file written for MULTI-PLAYER format )";
			}
			else
			{
				strReport = "\n\n( CFG file written for SINGLE-PLAYER format )";
			}
		}
		else
		{
			strReport = "\n\n( CFG not needed, not written )";
		}

		InfoBox(strReport);
	}
}

// called both from the menu, and now from the Build() member...
//
bool CAssimilateDoc::WriteCFGFiles(bool bPromptForNames, bool &bCFGWritten)
{
	bCFGWritten = false;	

	CModel* curModel = m_modelList;
	while(curModel != NULL)
	{
		bool bThisCFGWritten = false;
		if (!curModel->WriteExternal(bPromptForNames,bThisCFGWritten))
		{
			return false;
		}
		if (bThisCFGWritten)
			bCFGWritten = true;

		curModel = curModel->GetNext();
	}

	return true;
}

void CAssimilateDoc::Resequence()
{
	CModel* curModel = m_modelList;
	while(curModel != NULL)
	{
		curModel->Resequence(true);
		curModel = curModel->GetNext();
	}

	SetModifiedFlag();
	UpdateAllViews(NULL, AS_FILESUPDATED, NULL);	// needed
}

void CAssimilateDoc::OnResequence() 
{
	extern bool gbSkipXSIRead_QuestionAsked;
	extern bool gbSkipXSIRead;
	gbSkipXSIRead_QuestionAsked = false;	// make it happen again
	gbSkipXSIRead = false;
	Resequence();
}

void CAssimilateDoc::OnViewAnimEnums()
{
	gbViewAnimEnums = !gbViewAnimEnums;
	UpdateAllViews(NULL, AS_FILESUPDATED, NULL);
}

void CAssimilateDoc::OnUpdateViewAnimEnums(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(gbViewAnimEnums);
}

void CAssimilateDoc::OnViewFrameDetails()
{
	gbViewFrameDetails = !gbViewFrameDetails;
	UpdateAllViews(NULL, AS_FILESUPDATED, NULL);
}

void CAssimilateDoc::OnUpdateViewFrameDetails(CCmdUI* pCmdUI)
{
	pCmdUI->SetCheck(gbViewFrameDetails);
}


// 1) save qdt, 2) run qdata on it, 3) if success, save .cfg file...
//
bool CAssimilateDoc::Build(bool bAllowedToShowSuccessBox, int iLODLevel, bool bSkipSave)	// damn this stupid Serialize() crap
{
	bool bSuccess = false;

	if (Validate())	// notepad will have been launched with a textfile of errors at this point if faulty
	{
		// seems valid, so save the QDT...
		//
		giLODLevelOverride = iLODLevel;

		if (!bSkipSave)
		{
			OnFileSave();		
		}
		
		CString csQDataLocation = ((CAssimilateApp*)AfxGetApp())->GetQDataFilename();

		// hack-city!!!!!!!!!!
		//
		CModel* curModel = ghAssimilateView->GetDocument()->GetCurrentUserSelectedModel();
		if (curModel->GetPreQuat())
		{
			csQDataLocation.MakeLower();
			csQDataLocation.Replace("carcass","carcass_prequat");
		}
		
		CString params = csQDataLocation;
		
		if (!bSkipSave)
		{
			params += " -keypress";
		}
		params += " -silent";
		params += " ";
		params += m_strPathName;	// += (eg) {"Q:\quake\baseq3\models\players\ste_assimilate_test\ste_testaa.qdt"}
		Filename_AccountForLOD(params, giLODLevelOverride);

		PROCESS_INFORMATION pi;
		STARTUPINFO startupinfo;
		startupinfo.cb = sizeof(startupinfo);
		startupinfo.lpReserved = NULL;
		startupinfo.lpDesktop = NULL;
		startupinfo.lpTitle = NULL;
		startupinfo.dwFlags = 0;
		startupinfo.cbReserved2 = 0;
		startupinfo.lpReserved2 = NULL;

		params.Replace("/","\\");
		csQDataLocation.Replace("/","\\");

		LPTSTR paramsPass = params.GetBuffer(params.GetLength() + 1);

		StartWait();	// ++++++++++++++++++++++++

		if (CreateProcess(csQDataLocation, paramsPass, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &startupinfo, &pi))
		{
			WaitForSingleObject(pi.hProcess, INFINITE);
			EndWait();	// ------------------------
			DWORD result;
			GetExitCodeProcess(pi.hProcess,&result);
			if (result)
			{
				char error[64];
				sprintf(error,"Process returned error: %d",result);
				MessageBox(NULL,error,"Build Failed",MB_OK|MB_ICONERROR);
			}
			CloseHandle(pi.hProcess);

			if (result==0)
			{
				// QData was run successfully at this point, so write the CFG file(s)...
				//
				if (iLODLevel)	// only LOD 0 writes out the CFG file
				{
					bSuccess = true;
				}
				else
				{
					bool bCFGWritten = false;
					if (WriteCFGFiles(false,bCFGWritten))	// false = no name prompt, derive automatically from model name
					{
						// success (on a plate)...
						//
						if (bAllowedToShowSuccessBox)
						{
							CString strReport("Everything seemed to go ok\n\nCAR");

							if (bCFGWritten)
							{
								strReport += " and CFG files written";
								if (((CAssimilateApp*)AfxGetApp())->GetMultiPlayerMode())
								{
									strReport += "\n\n\n\n( CFG file written for MULTI-PLAYER format )";
								}
								else
								{
									strReport += "\n\n\n\n( CFG file written for SINGLE-PLAYER format )";
								}
							}
							else
							{
								strReport += " file written";
								strReport += "\n\n\n\n( CFG file not written for GLA-referencing model )";
							}

							InfoBox(strReport);
						}
						bSuccess = true;
					}
				}
			}
		}
		else
		{
			EndWait();	// ------------------------
			MessageBox(NULL,"Could not spawn process.","Build Failed",MB_OK|MB_ICONERROR);
		}
		params.ReleaseBuffer();
	}	

	giLODLevelOverride = 0;	

	return bSuccess;
}

void CAssimilateDoc::OnBuildMultiLOD()
{
	int iErrors = 0;

	// to save time, I'll run all the validates first, and only if they're all ok will I go on to the build
	//	(which incidentally does a harmless re-validate again)
	//
	for (int i=0; i< 1+EXTRA_LOD_LEVELS; i++)
	{
		iErrors += Validate(false, i)?0:1;
	}

	// go ahead if all clear...  
	//
	// (I'll write them in reverse-LOD order so the last one written is the standard one. This should hopefully avoid
	//	any problems with the current document potentially becoming "(name)_3.qdt" from then on to MFC)
	//
	if (!iErrors)
	{
		for (int i=EXTRA_LOD_LEVELS; i>=0; i--)
		{
			Build(	!i,		// bool bAllowedToShowSuccessBox (ie only on last one)
					i,		// int iLODLevel
					false	// bool bSkipSave
					);
		}
	}
}



// 1) save qdt, 2) run qdata on it, 3) if success, save .cfg file...
//
void CAssimilateDoc::OnBuild()
{	
	Build(	true,	// bool bAllowedToShowSuccessBox, 
			0,		// int iLODLevel
			false	// bool bSkipSave
			);
}


void CAssimilateDoc::ClearModelUserSelectionBools()
{
	CModel* curModel = m_modelList;

	while (curModel)
	{
		curModel->SetUserSelectionBool(false);		
		curModel = curModel->GetNext();
	}
}

// if there's only one model loaded, return that, if none, return NULL, else if >1, return selected one, else NULL
//
CModel* CAssimilateDoc::GetCurrentUserSelectedModel()
{
	CModel *curModel = m_modelList;

	if (!curModel || !curModel->GetNext())
	{
		return curModel;		// 0 or 1 models total loaded
	}

	// more than one loaded, so find the selected one and return that...
	//
	while (curModel)
	{
		if (curModel->GetUserSelectionBool())
		{
			return curModel;
		}

		curModel = curModel->GetNext();
	}

	return NULL;	// multiple loaded, but none selected
}


static bool FileUsesGLAReference(LPCSTR psFilename, LPCSTR psGLAReference)
{
	bool bReturn = false;

	FILE *fHandle = fopen(psFilename,"rt");
	if (fHandle)
	{
		int iLen = filesize(fHandle);
		if (iLen>0)
		{
			char *psText = (char*) malloc(iLen+1);
			if (psText)
			{
				fread(psText,1,iLen,fHandle);
				psText[iLen]='\0';

				strlwr(psText);

				// this is a simple test that could be made more precise, but for now...
				//
				if ( (strstr(psText,"aseanimgrab_gla") || strstr(psText,"makeskel"))
					&&
					strstr(psText,psGLAReference)
					)
				{
					bReturn = true;
				}

				free(psText);
			}
		}
		fclose(fHandle);
	}

	return bReturn;
}



#define sASSUMEPATH "w:\\game\\base"
bool gbCarWash_YesToXSIScan;
bool gbCarWash_DoingScan = false;	// MUST default to this
bool gbQueryGoAhead = true;			// MUST defualt to this
LPCSTR gpsCARWashDirOverride = NULL;// MUST default to this
CString strCarWashErrors;
bool gbCarwashErrorsOccured;
CString strMustContainThisGLA;	// MUST be blank, else name of GLA to be present to be considered
void CAssimilateDoc::OnCarWashActual()
{
	gbCarwashErrorsOccured = false;
	CString strStartDir = gpsCARWashDirOverride?gpsCARWashDirOverride:((CAssimilateApp*)AfxGetApp())->GetQuakeDir();
	strStartDir.Replace("/","\\");

	if (!strStartDir.GetLength())
	{			
		ErrorBox("Quake path not known at this point. Prefs not setup?");
		gbCarwashErrorsOccured = true;
		return;
//		if (!GetYesNo("Quake path not known at this point because you've not loaded anything yet\n\nShould I assume " "\"" sASSUMEPATH "\"" "?"))
//			return;
//
//		strStartDir = sASSUMEPATH;
	}

	// (this app was written so that GetQuakeDir() returns a path with a trailing slash, not nice normally, but here...)
	//
//	if (strStartDir.GetAt(strStartDir.GetLength()-1)=='\\')
//		strStartDir = strStartDir.Left(strStartDir.GetLength()-1);
	if (gpsCARWashDirOverride == NULL)
	{
		strStartDir += "models";//\\players";
	}

	if (gbQueryGoAhead)
	{
		if (!GetYesNo(va("About to scan: \"%s\\*.CAR /s\"\n\n"/*"This can take a LONG time, "*/"Proceed?",strStartDir)))
			return;
	}

	gbCarWash_YesToXSIScan = GetYesNo("Full XSI scan? ( \"NO\" will skip XSI reads, but v3.0 files are quick to read anyway now )");

	CWaitCursor wait;

	strCARsFound.Empty();
	iCARsFound = 0;
	strSkippedDirs.Empty();
	strSkippedFiles.Empty();
	
	R_CheckCARs( strStartDir, 0, strMustContainThisGLA);	//bool bBuildListOnly
	AlphaSortCARs();	// not important to alpha-sort here (during car-wash), just looks nicer
	((CMainFrame*)AfxGetMainWnd())->StatusMessage("Ready");

	// ok, now ready to begin pass 2...
	//
	CString strReport;
	if (!iCARsFound)
	{			
		ASSERT(0);
		strReport = "No suitable .CAR files found for processing!\n\n";

		if (!strSkippedDirs.IsEmpty())
		{
			strReport+= "Skipped Dirs:\n\n";
			strReport+= strSkippedDirs;
		}

		if (!strSkippedFiles.IsEmpty())
		{
			strReport+= "\n\nSkipped Files:\n\n";
			strReport+= strSkippedFiles;
		}
		ErrorBox(strReport);
		gbCarwashErrorsOccured = true;
	}
	else
	{
		//----------------
		gbCarWash_DoingScan = true;
		strCarWashErrors.Empty();
		//----------------

		CString strTotalErrors;

		strReport = "Processed files:\n\n";
		for (int i=0; i<iCARsFound; i++)
		{						
			CString strThisFile = strCARsFound;
			int iLoc = strThisFile.Find("\n");
			if (iLoc>=0)
			{
				strThisFile = strThisFile.Left(iLoc);
				strCARsFound= strCARsFound.Mid(iLoc+1);

				strReport += strThisFile + "\n";

				((CMainFrame*)AfxGetMainWnd())->StatusMessage(va("Scanning File %d/%d: %s",i+1,iCARsFound,(LPCSTR)strThisFile));

				if (1)//strMustContainThisGLA.IsEmpty() || FileUsesGLAReference(strThisFile, strMustContainThisGLA))
				{
					OnNewDocument();
					Parse(strThisFile);
					if (gbParseError)
					{
						strTotalErrors += va("\nParse error in CAR file \"%s\"\n",(LPCSTR)strThisFile);					
					}
					else
					{
						OnValidate();

						if (!strCarWashErrors.IsEmpty())
						{
							// "something is wrong..."	:-)
							//
							strTotalErrors += va("\nError in file \"%s\":\n\n%s\n",(LPCSTR)strThisFile,(LPCSTR)strCarWashErrors);
						}						
						strCarWashErrors.Empty();
					}
				}
			}
			else
			{
				ASSERT(0);
				strThisFile.Insert(0,"I fucked up, the following line didn't seem to have a CR:  (tell me! -Ste)\n\n");
				ErrorBox(strThisFile);
			}
		}

		//----------------
		gbCarWash_DoingScan = false;
		//----------------


		OnNewDocument();	// trash whatever was loaded last

//		strReport = "Processed files:\n\n";
//		strReport+= strCARsFound;
		strReport+= "\n\nSkipped Dirs:\n\n";
		strReport+= strSkippedDirs;
		strReport+= "\n\nSkipped Files:\n\n";
		strReport+= strSkippedFiles;

		if (strTotalErrors.IsEmpty())
		{
			strReport.Insert(0,"(No additional errors found)\n\n");
		}
		else
		{
			strReport+= "\n\nAdditional errors will now be sent to Notepad!...";
			gbCarwashErrorsOccured = true;
		}

		if (gbQueryGoAhead || gbCarwashErrorsOccured)
		{
			InfoBox(strReport);
		}

		if (!strTotalErrors.IsEmpty())
		{
			strTotalErrors.Insert(0, "The following errors occured during CARWash...\n\n");
			SendToNotePad(strTotalErrors, "carwash_errors.txt");
		}
	}

//#define sASSUMEPATH "q:\\quake\\baseq3"
//		strTGAsWithRedundantAlpha.Insert(0,"The following files are defined as 32-bit (ie with alpha), but the alpha channel is blank (ie all 255)...\n\n");
//		SendToNotePad(strTGAsWithRedundantAlpha, "TGAs_With_Redundant_Alpha.txt");

	((CMainFrame*)AfxGetMainWnd())->StatusMessage("Ready");
}

void CAssimilateDoc::OnCarWash()
{
	strMustContainThisGLA.Empty();
	OnCarWashActual();
}


// creates as temp file, then spawns notepad with it...
//
bool SendToNotePad(LPCSTR psWhatever, LPCSTR psLocalFileName)
{
	bool bReturn = false;

	LPCSTR psOutputFileName = va("%s\\%s",scGetTempPath(),psLocalFileName);

	FILE *handle = fopen(psOutputFileName,"wt");
	if (handle)
	{
		fprintf(handle,psWhatever);
		fclose(handle);

		char sExecString[MAX_PATH];

		sprintf(sExecString,"notepad %s",psOutputFileName);

		if (WinExec(sExecString,	//  LPCSTR lpCmdLine,  // address of command line
					SW_SHOWNORMAL	//  UINT uCmdShow      // window style for new application
					)
			>31	// don't ask me, Windoze just uses >31 as OK in this call.
			)
		{
			// ok...
			//
			bReturn = true;
		}
		else
		{
			ErrorBox("Unable to locate/run NOTEPAD on this machine!\n\n(let me know about this -Ste)");		
		}
	}
	else
	{
		ErrorBox(va("Unable to create file \"%s\" for notepad to use!",psOutputFileName));
	}

	return bReturn;
}


// AFX OnXxxx calls need to be void return, but the validate needs to ret a bool for elsewhere, so...
//
void CAssimilateDoc::OnValidate()
{
	Validate(!gbCarWash_DoingScan);	
}

void CAssimilateDoc::OnValidateMultiLOD()
{
	int iErrors = 0;
	for (int i=0; i< 1+EXTRA_LOD_LEVELS; i++)
	{
		iErrors += Validate(false, i)?0:1;
	}

	if (!iErrors)
	{
		InfoBox(va("Everything seems OK\n\n(Original + %d LOD levels checked)",EXTRA_LOD_LEVELS));
	}
}


// checks for things that would stop the build process, such as missing ASE files, invalid loopframes, bad anim enums, etc,
//	and writes all the faults to a text file that it displays via launching notepad
//
bool CAssimilateDoc::Validate(bool bInfoBoxAllowed, int iLODLevel)
{
	OnResequence();

	int		iNumModels = ghAssimilateView->GetDocument()->GetNumModels();
	CModel* curModel = ghAssimilateView->GetDocument()->GetCurrentUserSelectedModel();
	bool	bValidateAll = false;
	int		iFaults = 0;

	StartWait();

	if (iNumModels)
	{
		CString sOutputTextFile;

		sOutputTextFile.Format("%s\\validation_faults%s.txt",scGetTempPath(),iLODLevel?va("_LOD%d",iLODLevel):"");

		FILE *hFile = fopen(sOutputTextFile,"wt");

		if (hFile)
		{
			if (iNumModels>1)
			{
				if (!curModel)	// >1 models, but none selected, so validate all
				{
					bValidateAll = true;
				}
				else
				{
					// >1 models, 1 selected, ask if we should do all...
					//				
					bValidateAll = GetYesNo(va("Validate ALL models?\n\n( NO = model \"%s\" only )",curModel->GetName()));
				}
			}

			if (bValidateAll)
			{
				curModel = ghAssimilateView->GetDocument()->GetFirstModel();			
			}	
			
			if (iLODLevel)
			{
				fprintf(hFile,"(LOD Level %d)\n",iLODLevel);
			}

			while (curModel)
			{
				fprintf(hFile,"\nModel: \"%s\"\n\n",curModel->GetName());

				int iThisModelFaults = iFaults;

				if (	( curModel->GetMakeSkelPath()	&& strlen(curModel->GetMakeSkelPath()) )
//						||
//						( curModel->GetSkelPath()		&& strlen(curModel->GetSkelPath()) )
					)
				{
					// ... then all is fine
				}
				else
				{
					// this is an error, UNLESS you have a GLA sequence...
					//
					if (!curModel->HasGLA())
					{					
						//fprintf(hFile, "Model must have either a 'skel' or 'makeskel' path\n    ( Double-click on the model name in the treeview to edit )\n");
						fprintf(hFile, "Model must have a 'makeskel' path\n    ( Double-click on the top tree item's name (should be a folder), then click \"Makes it's own skeleton\" in the dialog )\n");
						iFaults++;
					}
				}

				//
				// validate all sequences within this model...
				//				
				int iGLACount = 0;
				int iXSICount = 0;
				CSequence* curSequence = curModel->GetFirstSequence();
				while (curSequence)
				{
					// we'll need to check these counts after checking all sequences...
					//
					if (curSequence->IsGLA())
					{
						iGLACount++;
					}
					else
					{
						iXSICount++;
					}

					#define SEQREPORT CString temp;temp.Format("Sequence \"%s\":",curSequence->GetName());while (temp.GetLength()<35)temp+=" ";

					// check 1, does the ASE file exist? (actually this is talking about XSIs/GLAs, but WTF...
					//
					CString nameASE = ((CAssimilateApp*)AfxGetApp())->GetQuakeDir();
							nameASE+= curSequence->GetPath();

					Filename_AccountForLOD(nameASE, iLODLevel);

					const int iNameSpacing=35;

					if (!FileExists(nameASE))
					{
						if (!gbCarWash_DoingScan)	// because this will only duplicate reports otherwise
						{
							SEQREPORT;
							temp += va(" ASE/XSI/GLA file not found: \"%s\"\n",nameASE);
							fprintf(hFile,temp);
							iFaults++;
						}
					}

					// new check, if this is an LOD ASE it must have the same framecount as the base (non-LOD) version...
					//
					if (iLODLevel)
					{
						// read this file's framecount...
						//
						int iStartFrame, iFrameCount, iFrameSpeed;
						curSequence->ReadASEHeader( nameASE, iStartFrame, iFrameCount, iFrameSpeed);

						// read basefile's framecount...
						//
						CString baseASEname = ((CAssimilateApp*)AfxGetApp())->GetQuakeDir();
								baseASEname+= curSequence->GetPath();

						int iStartFrameBASE, iFrameCountBASE, iFrameSpeedBASE;
						curSequence->ReadASEHeader( baseASEname, iStartFrameBASE, iFrameCountBASE, iFrameSpeedBASE);

						// same?...
						//
						if (iFrameCount != iFrameCountBASE)
						{
							SEQREPORT;
							temp += va(" (SERIOUS ERROR) base ASE has %d frames, but this LOD version has %d frames!\n",iFrameCountBASE,iFrameCount);
							fprintf(hFile,temp);							
							iFaults++;
						}
					}

					// check 2, is the loopframe higher than the framecount of that sequence?...
					//
					if (curSequence->GetLoopFrame() >= curSequence->GetFrameCount())
					{
						SEQREPORT;
						temp += va(" loopframe %d is illegal, max = %d\n",curSequence->GetLoopFrame(),curSequence->GetFrameCount()-1);
						fprintf(hFile,temp);							
						iFaults++;
					}

					if (!curModel->IsGhoul2())
					{
						// check 3, is the enum valid?...
						//
						if (curSequence->GetEnumType() == ET_INVALID)
						{
							SEQREPORT;
							temp += va(" invalid animation enum \"%s\"\n",curSequence->GetEnum());
							fprintf(hFile,temp);							
							iFaults++;
						}
					}

					int iEnumUsageCount = curModel->AnimEnumInUse(curSequence->GetEnum());
					if (iEnumUsageCount>1)
					{
						SEQREPORT;
						temp += va(" animation enum \"%s\" is used %d times\n",curSequence->GetEnum(),iEnumUsageCount);
						fprintf(hFile,temp);							
						iFaults++;
					}					

					// a whole bunch of checks for the additional sequences...
					//
					if (!curSequence->IsGLA())
					{
						for (int i=0; i<MAX_ADDITIONAL_SEQUENCES; i++)
						{
							CSequence *additionalSeq = curSequence->AdditionalSeqs[i];

							#define ADDITIONALSEQREPORT CString temp;temp.Format("Sequence \"%s\": (Additional: \"%s\"):",curSequence->GetName(),additionalSeq->GetEnum());while (temp.GetLength()<60)temp+=" ";

							if (additionalSeq->AdditionalSequenceIsValid())
							{
								// check for duplicate enum names...
								//
								int iEnumUsageCount = curModel->AnimEnumInUse(additionalSeq->GetEnum());
								if (iEnumUsageCount>1)
								{
									ADDITIONALSEQREPORT;								
									temp += va(" animation enum \"%s\" is used %d times\n",additionalSeq->GetEnum(),iEnumUsageCount);
									fprintf(hFile,temp);
									iFaults++;
								}

								// additional sequences must actually have some frames...
								//
								if (additionalSeq->GetFrameCount()<=0)
								{
									ADDITIONALSEQREPORT;
									temp += va(" a frame count of %d is illegal (min = 1)\n",additionalSeq->GetFrameCount());
									fprintf(hFile,temp);
									iFaults++;
								}
								else
								{
									// the start/count range of this additional seq can't exceed it's master...
									//
									if (additionalSeq->GetStartFrame() + additionalSeq->GetFrameCount() > curSequence->GetFrameCount())
									{
										ADDITIONALSEQREPORT;
										temp += va(" illegal start/count range of %d..%d exceeds master range of %d..%d\n",
													additionalSeq->GetStartFrame(),
													additionalSeq->GetStartFrame() + additionalSeq->GetFrameCount(),
													curSequence->GetStartFrame(),
													curSequence->GetStartFrame() + curSequence->GetFrameCount()
													);
										fprintf(hFile,temp);
										iFaults++;
									}
									else
									{
										// loopframe of an additional seq must be within its own seq framecount...
										//
										if (additionalSeq->GetLoopFrame() >= additionalSeq->GetFrameCount())
										{
											ADDITIONALSEQREPORT;
											temp += va(" loopframe %d is illegal, max is %d\n",additionalSeq->GetLoopFrame(),additionalSeq->GetFrameCount()-1);
											fprintf(hFile,temp);
											iFaults++;
										}
									}
								}
							}
							else
							{
								// is this additional sequence invalid because of being just empty or being bad?...
								//
								if (strlen(additionalSeq->GetEnum()))
								{
									// it's a bad sequence (probably because of its enum being deleted from anims.h since it was saved)
									//
									ADDITIONALSEQREPORT;								
									temp += va(" this animation enum no longer exists in \"%s\"\n",sDEFAULT_ENUM_FILENAME);
									fprintf(hFile,temp);
									iFaults++;
								}
							}
						}
					}
					curSequence = curSequence->GetNext();
				}

				// special GLA/XSI checks...
				//
				{
					if (iGLACount>1)
					{
						fprintf(hFile, "Model has more than one GLA file specified\n");
						iFaults++;
					}

					if (iGLACount && iXSICount)
					{
						fprintf(hFile, "Model has both GLA and XSI files specified. Pick one method or the other\n");
						iFaults++;
					}

					if (iGLACount && (curModel->GetMakeSkelPath() && strlen(curModel->GetMakeSkelPath())) )
					{
						fprintf(hFile, "Model has both a GLA sequence and a '-makeskel' path, this is meaningless\n");
						iFaults++;
					}

					/*					
					if (iGLACount && (curModel->GetSkelPath() && strlen(curModel->GetSkelPath())) )
					{
						fprintf(hFile, "Model has both a GLA sequence and a '-skel' path, you should probably blank out the 'skel' path\n");
						iFaults++;
					}
					*/
				}

				if (iThisModelFaults == iFaults)
				{
					fprintf(hFile,"(ok)\n");	// just to be nice if reporting on >1 model...
				}
				else
				{
					fprintf(hFile,"\n(%d faults)\n",iFaults-iThisModelFaults);
				}

				curModel = curModel->GetNext();
				if (!bValidateAll)
					break;			

			}// while (curModel)

			fclose(hFile);

			if (iFaults)
			{
				// now run notepad.exe on the file we've just created...
				//
				CString sExecString;

				sExecString.Format("notepad %s",sOutputTextFile);

				if (WinExec(sExecString,	//  LPCSTR lpCmdLine,  // address of command line
							SW_SHOWNORMAL	//  UINT uCmdShow      // window style for new application
							)
					>31	// don't ask me, Windoze just uses >31 as OK in this call.
					)
				{
					// ok.
				}
				else
				{
					ErrorBox("Unable to locate/run NOTEPAD on this machine!\n\n(let me know about this -Ste)");
				}
			}
			else
			{
				if (bInfoBoxAllowed)
				{
					InfoBox("Everything ok\n\n( All files exist, enums exist, and frames seem to be valid ranges )");
				}
			}
		}// if (hFile)
		else
		{
			ErrorBox(va("Arrgh! Unable to create file '%s'!\n\n(let me know about this -Ste)",sOutputTextFile));
		}

	}// if (iNumModels)

	EndWait();

	return !iFaults;

}


void CAssimilateDoc::OnUpdateResequence(CCmdUI* pCmdUI) 
{	
	pCmdUI->Enable(!!GetNumModels());	
}

void CAssimilateDoc::OnUpdateFileSave(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!!GetNumModels());	
}

void CAssimilateDoc::OnUpdateFileSaveAs(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!!GetNumModels());	
}

void CAssimilateDoc::OnUpdateExternal(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!!GetNumModels());		
}

void CAssimilateDoc::OnUpdateValidate(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!!GetNumModels());		
}

void CAssimilateDoc::OnUpdateBuild(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!!GetNumModels());		
}



BOOL CAssimilateDoc::DoFileSave()
{	
	// sourcesafe stuff
	{
		///////////////////////////////////////////
		//
		// some stuff so I can leave the code below untouched...
		//
		LPCSTR filename = (LPCSTR) m_strPathName;
		#define Sys_Printf(blah) StatusText(blah)
		//
		///////////////////////////////////////////
		//
		// check it out first, if necessary...
		//
		if ( SS_FunctionsAvailable() )
		{
			if ( SS_IsUnderSourceControl( filename ) )
			{
				if ( SS_IsCheckedOut( filename ))
				{
					if ( !SS_IsCheckedOutByMe( filename ))
					{
						CString strCheckOuts;
						int iCount;
						
						if (SS_ListCheckOuts( filename, strCheckOuts, iCount ))
						{
							ErrorBox( va("File \"%s\" is checked out by:\n\n%s\n... so you can't save over it...\n\n... so you can't compile...\n\nTough luck matey!....(bwahahahaha!!!!!)",filename,(LPCSTR) strCheckOuts));
							return false;
						}
					}
					else
					{
						Sys_Printf ("(You own this file under SourceSafe)\n");				
					}
				}
				else
				{
					if ( GetYesNo( va("The file \"%s\"\n\n...needs to be checked out so I can save over it\n\nProceed? ('No' will abort the save)",filename) ))
					{
						if (SS_CheckOut( filename ))
						{
							Sys_Printf ("(File checked out ok)\n");				
						}
						else
						{
							ASSERT(0);	// I want to know if this ever happens
							Sys_Printf ("(Error during file checkout, aborting save\n");				
							return false;
						}
					}
					else
					{
						Sys_Printf ("(Checkout cancelled, aborting save\n");				
						return false;
					}
				}
			}
			else
			{
				Sys_Printf ("(This file is not under SourceSafe control)\n");				
			}
		}

		// now do seperate check for files that are still write-protected...
		//
		DWORD dw = GetFileAttributes( filename );

		if (dw != 0xFFFFFFFF && ( dw & FILE_ATTRIBUTE_READONLY ))
		{
			// hmmm, still write protected...
			//
			if (SS_SetupOk())
			{
				if (GetYesNo( va("The file \"%s\" is write-protected, but probably not because of SourceSafe, just as a safety thing.\n\n(Tell me if you believe this is wrong -Ste)\n\nDo you want me to un-writeprotect it so you can save over it? ('No' will abort the save)",filename )))
				{
					if ( !SetFileAttributes( filename, dw&~FILE_ATTRIBUTE_READONLY) )
					{
						ErrorBox("Failed to remove write protect, aborting...");
						return false;
					}
				}
				else
				{
					Sys_Printf ("(File was not write-enabled, aborting save)");
					return false;
				}
			}
			else
			{
				ErrorBox( va("The file \"%s\" is write-protected, but you don't appear to have SourceSafe set up properly on this machine, so I can't tell if the file is protected or just not checked out to you.\n\nIf you really want to edit this you'll have to write-enable it yourself (which I'm deliberately not offering to do for you here <g>)",filename));
			}
		}
	}

	BOOL b = CDocument::DoFileSave();

	if (b == TRUE)
	{
		// sourcesafe
		LPCSTR filename = (LPCSTR) m_strPathName;
		#define Sys_Printf(blah) StatusText(blah)
		if ( SS_FunctionsAvailable() )
		{
			if ( SS_IsUnderSourceControl( filename ))
			{
				if ( SS_IsCheckedOutByMe( filename ))
				{
//					if ( SS_CheckIn( filename ))
//					{
//						Sys_Printf("(Checked in ok)\n");
//					}
//					else
//					{
//						Sys_Printf("Error during CheckIn\n");
//					}
				}
				else
				{
					ErrorBox( va("You do not have file \"%s\" checked out",filename));
				}
			}
			else
			{
				// new bit, if it wasn't under SourceSafe, then ask if they want to add it...
				//
				if (GetYesNo(va("File \"%s\" is not under SourceSafe control, add to database?",filename)))
				{
					if ( SS_Add( filename ))
					{
						Sys_Printf("(File was added to SourceSafe Ok)\n");

						// check it out as well...
						//
						if (SS_CheckOut( filename ))
						{
							Sys_Printf ("(File checked out ok)\n");				
						}
						else
						{
							ASSERT(0);	// I want to know if this ever happens
							Sys_Printf ("( Error during file checkout! )\n");							
						}
					}
					else
					{
						ErrorBox( va("Error adding file \"%s\" to SourceSafe",filename));
					}
				}
			}
		}
	}

	StatusText(NULL);

	return b;
}

BOOL CAssimilateDoc::OnSaveDocument(LPCTSTR lpszPathName) 
{
	CString strFileName = lpszPathName;

	Filename_AccountForLOD(strFileName, giLODLevelOverride);	// this is actually junk now, should lose all this LODoverride stuff

	return CDocument::OnSaveDocument(strFileName);
}


// remember these two from session to session, maybe write to registry sometime?...
//
bool	gbPreValidate = true;
CString strInitialBuildPath = "models/players";
void CAssimilateDoc::OnEditBuildDependant()
{
	CModel* curModel = m_modelList;
	if (curModel)
	{
		CString strStartDir = ((CAssimilateApp*)AfxGetApp())->GetQuakeDir();

		if (!strStartDir.GetLength())
		{
			// should never happen...
			//
			ErrorBox("Base path not known at this point. Prefs not setup?");
			return;
		}

		LPCSTR psCurrentGLAName = curModel->GetMakeSkelPath();

		if (psCurrentGLAName)
		{
			char sCurrentGLAName[1024];
			strcpy(sCurrentGLAName,psCurrentGLAName);
			strMustContainThisGLA = sCurrentGLAName;
			CBuildAll dlgBuildAll(strInitialBuildPath, gbPreValidate);

			if (dlgBuildAll.DoModal() == IDOK)
			{		
				dlgBuildAll.GetData(strInitialBuildPath, gbPreValidate);

				strStartDir += strInitialBuildPath;
				strStartDir.Replace("/","\\");
				while (strStartDir.Replace("\\\\","\\")){}	

				if (gbPreValidate)
				{
					gbQueryGoAhead = false;
					gpsCARWashDirOverride = (LPCSTR) strStartDir;
					
					OnCarWashActual();
					gbQueryGoAhead = true;
					gpsCARWashDirOverride = NULL;

					if (gbCarwashErrorsOccured)
					{
						InfoBox("Build-All aborted because of errors");
						return;
					}
				}

				((CMainFrame*)AfxGetMainWnd())->StatusMessage("Validated Ok, building...");

				//////////////////////// largely block-pasted from CarWash.... :-)

				CWaitCursor wait;

				strCARsFound.Empty();
				iCARsFound = 0;
				strSkippedDirs.Empty();
				strSkippedFiles.Empty();

				// build up a list...
				//	
				R_CheckCARs( strStartDir, 0, strMustContainThisGLA);	//bool bBuildListOnly
				AlphaSortCARs();	// important to do them in alpha-order during build, because of "_humanoid" - type dirs.
				((CMainFrame*)AfxGetMainWnd())->StatusMessage("Ready");

				// ok, now ready to begin pass 2...
				//
				CString strReport;
				if (!iCARsFound)
				{			
					ASSERT(0);
					strReport = "No suitable .CAR files found for processing!\n\n";

					if (!strSkippedDirs.IsEmpty())
					{
						strReport+= "Skipped Dirs:\n\n";
						strReport+= strSkippedDirs;
					}

					if (!strSkippedFiles.IsEmpty())
					{
						strReport+= "\n\nSkipped Files:\n\n";
						strReport+= strSkippedFiles;
					}
					ErrorBox(strReport);
				}
				else
				{
					//----------------
					gbCarWash_DoingScan = true;
					strCarWashErrors.Empty();
					//----------------

					CString strTotalErrors;

					strReport = "Processed files:\n\n";
					for (int i=0; i<iCARsFound; i++)
					{
						CString strThisFile = strCARsFound;
						int iLoc = strThisFile.Find("\n");
						if (iLoc>=0)
						{
							strThisFile = strThisFile.Left(iLoc);
							strCARsFound= strCARsFound.Mid(iLoc+1);

							strReport += strThisFile + "\n";

							((CMainFrame*)AfxGetMainWnd())->StatusMessage(va("Scanning File %d/%d: %s",i+1,iCARsFound,(LPCSTR)strThisFile));

							if (1)//FileUsesGLAReference(strThisFile, sCurrentGLAName))
							{
								OnNewDocument();				
								if (OnOpenDocument_Actual(strThisFile, false))
								{
									if (gbParseError)
									{
										strTotalErrors += va("\nParse error in file \"%s\"\n",(LPCSTR)strThisFile);
										break;
									}
									else
									{
										m_strPathName = strThisFile;	// fucking stupid MFC doesn't set this!!!!!!!!!!!!!
										bool bSuccess = Build(	false,	// bool bAllowedToShowSuccessBox, 
																0,		// int iLODLevel
																true	// bool bSkipSave
																);				

										if (!strCarWashErrors.IsEmpty())
										{
											// "something is wrong..."	:-)
											//
											strTotalErrors += va("\nError in file \"%s\":\n\n%s\n",strThisFile,strCarWashErrors);
										}
										strCarWashErrors.Empty();

										if (!bSuccess)
											break;
									}
								}
								else
								{
									strTotalErrors += va("\nUnable to open file \"%s\"\n",(LPCSTR)strThisFile);
									break;
								}
							}
							else
							{
								// this CAR file doesn't use the current GLA name, so ignore it
							}
						}
						else
						{
							ASSERT(0);
							strThisFile.Insert(0,"I fucked up, the following line didn't seem to have a CR:  (tell me! -Ste)\n\n");
							ErrorBox(strThisFile);
						}
					}

					//----------------
					gbCarWash_DoingScan = false;
					//----------------


					OnNewDocument();	// trash whatever was loaded last

			//		strReport = "Processed files:\n\n";
			//		strReport+= strCARsFound;
					strReport+= "\n\nSkipped Dirs:\n\n";
					strReport+= strSkippedDirs;
					strReport+= "\n\nSkipped Files:\n\n";
					strReport+= strSkippedFiles;

					if (strTotalErrors.IsEmpty())
					{
						strReport.Insert(0,"(No additional errors found)\n\n");
					}
					else
					{
						strReport+= "\n\nAdditional errors will now be sent to Notepad!...";
					}
					InfoBox(strReport);

					if (!strTotalErrors.IsEmpty())
					{
						strTotalErrors.Insert(0, "The following errors occured during build...\n\n");
						SendToNotePad(strTotalErrors, "build_errors.txt");
					}
				}
			}
		}
		else
		{
			ErrorBox("Currently loaded model does not make a skeleton, so there are no dependants\n\n\nDUH!!");
		}
	}
	else
	{
		ErrorBox("No model loaded to build dependants of!\n\n\nDUH!!");
	}

	((CMainFrame*)AfxGetMainWnd())->StatusMessage("Ready");
}

void CAssimilateDoc::OnEditBuildall() 
{
//	if (!GetYesNo("Safety Feature:  Do you really want to rebuild every CAR file in the whole game?"))
//		return;

	// validity-check...
	//
	CString strStartDir = ((CAssimilateApp*)AfxGetApp())->GetQuakeDir();	

	if (!strStartDir.GetLength())
	{
		ErrorBox("Base path not known at this point. Prefs not setup?");
		return;
	}

	CBuildAll dlgBuildAll(strInitialBuildPath, gbPreValidate);

	if (dlgBuildAll.DoModal() == IDOK)
	{		
		dlgBuildAll.GetData(strInitialBuildPath, gbPreValidate);

		strStartDir += strInitialBuildPath;
		strStartDir.Replace("/","\\");
		while (strStartDir.Replace("\\\\","\\")){}	

		if (gbPreValidate)
		{
			gbQueryGoAhead = false;
			gpsCARWashDirOverride = (LPCSTR) strStartDir;
			OnCarWash();
			gbQueryGoAhead = true;
			gpsCARWashDirOverride = NULL;

			if (gbCarwashErrorsOccured)
			{
				InfoBox("Build-All aborted because of errors");
				return;
			}
		}

		((CMainFrame*)AfxGetMainWnd())->StatusMessage("Validated Ok, building...");

		//////////////////////// largely block-pasted from CarWash.... :-)

		CWaitCursor wait;

		strCARsFound.Empty();
		iCARsFound = 0;
		strSkippedDirs.Empty();
		strSkippedFiles.Empty();

		// build up a list...
		//	
		R_CheckCARs( strStartDir, 0, "" );	//bool bBuildListOnly
		AlphaSortCARs();	// important to do them in alpha-order during build, because of "_humanoid" - type dirs.
		((CMainFrame*)AfxGetMainWnd())->StatusMessage("Ready");

		// ok, now ready to begin pass 2...
		//
		CString strReport;
		if (!iCARsFound)
		{			
			ASSERT(0);
			strReport = "No suitable .CAR files found for processing!\n\n";

			if (!strSkippedDirs.IsEmpty())
			{
				strReport+= "Skipped Dirs:\n\n";
				strReport+= strSkippedDirs;
			}

			if (!strSkippedFiles.IsEmpty())
			{
				strReport+= "\n\nSkipped Files:\n\n";
				strReport+= strSkippedFiles;
			}
			ErrorBox(strReport);
		}
		else
		{
			//----------------
			gbCarWash_DoingScan = true;
			strCarWashErrors.Empty();
			//----------------

			CString strTotalErrors;

			strReport = "Processed files:\n\n";
			for (int i=0; i<iCARsFound; i++)
			{
				CString strThisFile = strCARsFound;
				int iLoc = strThisFile.Find("\n");
				if (iLoc>=0)
				{
					strThisFile = strThisFile.Left(iLoc);
					strCARsFound= strCARsFound.Mid(iLoc+1);

					strReport += strThisFile + "\n";

					((CMainFrame*)AfxGetMainWnd())->StatusMessage(va("Scanning File %d/%d: %s",i+1,iCARsFound,(LPCSTR)strThisFile));

					OnNewDocument();				
					if (OnOpenDocument_Actual(strThisFile, false))
					{
						if (gbParseError)
						{
							strTotalErrors += va("\nParse error in file \"%s\"\n",(LPCSTR)strThisFile);
							break;
						}
						else
						{
							m_strPathName = strThisFile;	// fucking stupid MFC doesn't set this!!!!!!!!!!!!!
							bool bSuccess = Build(	false,	// bool bAllowedToShowSuccessBox, 
													0,		// int iLODLevel
													true	// bool bSkipSave
													);				

							if (!strCarWashErrors.IsEmpty())
							{
								// "something is wrong..."	:-)
								//
								strTotalErrors += va("\nError in file \"%s\":\n\n%s\n",strThisFile,strCarWashErrors);
							}
							strCarWashErrors.Empty();

							if (!bSuccess)
								break;
						}
					}
					else
					{
						strTotalErrors += va("\nUnable to open file \"%s\"\n",(LPCSTR)strThisFile);
						break;
					}
				}
				else
				{
					ASSERT(0);
					strThisFile.Insert(0,"I fucked up, the following line didn't seem to have a CR:  (tell me! -Ste)\n\n");
					ErrorBox(strThisFile);
				}
			}

			//----------------
			gbCarWash_DoingScan = false;
			//----------------


			OnNewDocument();	// trash whatever was loaded last

	//		strReport = "Processed files:\n\n";
	//		strReport+= strCARsFound;
			strReport+= "\n\nSkipped Dirs:\n\n";
			strReport+= strSkippedDirs;
			strReport+= "\n\nSkipped Files:\n\n";
			strReport+= strSkippedFiles;

			if (strTotalErrors.IsEmpty())
			{
				strReport.Insert(0,"(No additional errors found)\n\n");
			}
			else
			{
				strReport+= "\n\nAdditional errors will now be sent to Notepad!...";
			}
			InfoBox(strReport);

			if (!strTotalErrors.IsEmpty())
			{
				strTotalErrors.Insert(0, "The following errors occured during build...\n\n");
				SendToNotePad(strTotalErrors, "build_errors.txt");
			}
		}
	}

	((CMainFrame*)AfxGetMainWnd())->StatusMessage("Ready");
}



void SS_DisposingOfCurrent(LPCSTR psFileName, bool bDirty)
{
	if (psFileName[0])
	{
		LPCSTR filename = psFileName;	// compile laziness
		#undef Sys_Printf
		#define Sys_Printf(blah)
		if ( SS_FunctionsAvailable() )
		{
			if ( SS_IsUnderSourceControl( filename ) )
			{
				if ( SS_IsCheckedOutByMe( filename ))
				{
					if (bDirty)
					{
						// if 'need_save' then the user has clicked ok-to-lose-changes, so...
						//
						if ( GetYesNo( va("Since you've decided to lose changes on the file:\n\n\"%s\"\n\n...do you want to Undo Checkout as well?",filename)))
						{
							if (SS_UndoCheckOut( filename ))
							{
								Sys_Printf ("(Undo Checkout performed on map)\n");
							}
							else
							{
								ErrorBox("Undo Checkout failed!\n");
							}
						}
					}
					else
					{
						// if !'need_save' here then the user has saved this out already, so prompt for check in...
						//
						if ( GetYesNo( va("Since you've finished with the file:\n\n\"%s\"\n\n...do you want to do a Check In?",filename)))
						{
							if ( SS_CheckIn( filename ))
							{
								//Sys_Printf ("(CheckIn performed on map)\n");
							}
							else
							{
								ErrorBox("CheckIn failed!\n");
							}
						}
					}
				}
			}
		}
	}
}



BOOL CAssimilateDoc::OnOpenDocument_Actual(LPCTSTR lpszPathName, bool bCheckOut) 
{
	SS_DisposingOfCurrent(m_strPathName, !!IsModified());

	if (bCheckOut)
	{
		// checkout the new file?
		LPCSTR filename = lpszPathName;	// compile-laziness :-)
		if ( SS_FunctionsAvailable() )
		{
			if ( SS_IsUnderSourceControl( filename ) )
			{
				if ( SS_IsCheckedOut( filename ))
				{
					if ( !SS_IsCheckedOutByMe( filename ))
					{
						CString strCheckOuts;
						int iCount;
						
						if (SS_ListCheckOuts( filename, strCheckOuts, iCount ))
						{
							if (!GetYesNo( va("Warning: File \"%s\" is checked out by:\n\n%s\n... Continue loading? ",filename,(LPCSTR) strCheckOuts)))
							{
								return FALSE;
							}
						}
					}
					else
					{
						//InfoBox ("(You own this file under SourceSafe)\n");				
					}
				}
				else
				{
					if ( GetYesNo( va("The file \"%s\"\n\n...is under SourceSafe control, check it out now?",filename) ))
					{
						if (SS_CheckOut( filename ))
						{
							//InfoBox ("(File checked out ok)\n");				
						}
						else
						{
							WarningBox( va("( Problem encountered during check out of file \"%s\" )",filename) );
						}
					}
				}
			}
			else
			{
				//InfoBox ("(This file is not under SourceSafe control)\n");				
			}
		}
	}

	if (!CDocument::OnOpenDocument(lpszPathName))
		return FALSE;
	
	return TRUE;
}


BOOL CAssimilateDoc::OnOpenDocument(LPCTSTR lpszPathName) 
{
	return OnOpenDocument_Actual(lpszPathName, true) ;
}

void CAssimilateDoc::OnCloseDocument() 
{
	SS_DisposingOfCurrent(m_strPathName, !!IsModified());
	
	CDocument::OnCloseDocument();
}

void CAssimilateDoc::OnViewFramedetailsonadditionalsequences() 
{
	gbViewFrameDetails_Additional = !gbViewFrameDetails_Additional;
	UpdateAllViews(NULL, AS_FILESUPDATED, NULL);
}

void CAssimilateDoc::OnUpdateViewFramedetailsonadditionalsequences(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(gbViewFrameDetails_Additional);	
}

void CAssimilateDoc::OnUpdateEditBuilddependant(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!!GetNumModels());			
}



bool RunApp(LPCSTR psAppCommand)
{
	CString strExec = psAppCommand;	// eg "start q:\\bin_nt\\behaved.exe";
			strExec.Replace("/","\\");	// otherwise it only works under NT...

	char sBatchFilename[512];
	
	GetTempPath(sizeof(sBatchFilename), sBatchFilename);
	strcat(sBatchFilename,"~temp.bat");

	FILE *handle = fopen(sBatchFilename,"wt");
	fprintf(handle,strExec);
	fprintf(handle,"\n");
	fclose(handle);

	STARTUPINFO startupinfo;
	PROCESS_INFORMATION	 ProcessInformation;

	GetStartupInfo (&startupinfo);

	BOOL ret = CreateProcess(sBatchFilename,
						//batpath,		// pointer to name of executable module 
						NULL,			// pointer to command line string
						NULL,			// pointer to process security attributes 
						NULL,			// pointer to thread security attributes 
						FALSE,			// handle inheritance flag 
						0 /*DETACHED_PROCESS*/,		// creation flags 
						NULL,			// pointer to new environment block 
						NULL,			// pointer to current directory name 
						&startupinfo,	// pointer to STARTUPINFO 
						&ProcessInformation 	// pointer to PROCESS_INFORMATION  
						);
//	remove(sBatchFilename);	// if you do this, the CreateProcess fails, presumably it needs it for a few seconds

	return !!ret;
}


void CAssimilateDoc::OnEditLaunchmodviewoncurrent() 
{
	char sExecString[MAX_PATH];

	sprintf(sExecString,"start %s.glm",Filename_WithoutExt(m_strPathName));

	if (RunApp(sExecString))
	{
		// ok...
		//		
	}
	else
	{
		ErrorBox(va("CreateProcess() call \"%s\" failed!\n\n(let me know about this -Ste)",sExecString));
	}
}

void CAssimilateDoc::OnUpdateEditLaunchmodviewoncurrent(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!!GetNumModels());
}