reactos/rosapps/devutils/vmingw/project.cpp

/********************************************************************
*	Module:	project.cpp. This is part of Visual-MinGW.
*
*	Purpose:	Procedures to manage a loaded project.
*
*	Authors:	Manu B.
*
*	License:	Visual-MinGW is covered by GNU General Public License, 
*			Copyright (C) 2001  Manu B.
*			See license.htm for more details.
*
*	Revisions:	
*
********************************************************************/
#include <windows.h>
#include <stdio.h>

#include "project.h"
#include "rsrc.h"

extern CMessageBox MsgBox;

// For dialogs.
extern CWinApp 	winApp;

WORD AppendPath(char * dirBuffer, WORD offset, char * absolutePath);

bool CheckFile(CFileItem * file){
	if (!file)
		return false;

	char * fileName = file->szFileName;
	char * s = fileName;
	char * dot = fileName;
	char * bkslash = fileName+1;
	// Valid relative path ?
	if (*dot == '.' && *bkslash == '\\'){
		s+=2;
		// Find backslashes & dots.
		while (*s != '\0'){
			if (*s == '\\'){
				bkslash = s;
			}else if (*s == '.'){
				dot = s;
			}
			s++;
		}
		if (*bkslash != '\0'){
			file->nFileOffset = (bkslash - fileName) +1;
		}else{
			file->nFileOffset = 0;
			return false;
		}
			
		if (dot != fileName)
			file->nFileExtension = (dot - fileName) +1;
		else
			file->nFileExtension = 0;
		return true;
	}
return false;
}

WORD AppendPath(char * dirBuffer, WORD offset, char * absolutePath){
	WORD len = 0;
	if (absolutePath[0] == '.'){
		if (absolutePath[1] == '\\' && absolutePath[2] != '\0'){
			dirBuffer[offset-1] = '\\';
			strcpy(&dirBuffer[offset], &absolutePath[2]);
			len = strlen(&dirBuffer[offset]);
			len++;
		}
	}
return len;
}


/********************************************************************
*	Class:	COptionsDlg.
*
*	Purpose:
*
*	Revisions:	
*
********************************************************************/
COptionsDlg::COptionsDlg(){
	pProject = NULL;
	pMakefile = NULL;
}

COptionsDlg::~COptionsDlg(){
}

LRESULT CALLBACK COptionsDlg::CDlgProc(UINT Message, WPARAM wParam, LPARAM lParam){
	switch(Message){
		case WM_INITDIALOG:
			return OnInitDialog((HWND) wParam, lParam);
		
		case WM_NOTIFY:
			OnNotify((int) wParam, (LPNMHDR) lParam);
			break;
		
		case WM_COMMAND:
			OnCommand(HIWORD(wParam), LOWORD(wParam), (HWND) lParam);
			break;

		case WM_CLOSE:
			EndDlg(0); 
			break;
	}
return FALSE;
}

BOOL COptionsDlg::OnInitDialog(HWND, LPARAM lInitParam){
	// Set pointers.
	pProject = (CProject *) lInitParam;
	if (pProject == NULL)
		return TRUE;

	// Tab control handle and TCITEM.
	_hWndTab = ::GetDlgItem(_hWnd, IDC_OPTION_TABS);
	tcitem.mask = TCIF_TEXT | TCIF_PARAM;

	// Insert General tab.
	HWND hwndChild = GeneralDlg.Create(this, IDD_GENERAL_PANE, NULL, (long) pProject);
	tcitem.pszText = "General";
	tcitem.lParam = (long) &GeneralDlg;
	::SendMessage(_hWndTab, TCM_INSERTITEM, 0, 
		(LPARAM)&tcitem);
	SetChildPosition(hwndChild);
	
	// Insert Compiler tab item.
	CompilerDlg.Create(this, IDD_COMPILER, &Pos, (long) pProject);
	tcitem.pszText = "Compiler";
	tcitem.lParam = (long) &CompilerDlg;
	::SendMessage(_hWndTab, TCM_INSERTITEM, 1, 
		(LPARAM)&tcitem);

	// Insert Linker tab.
	LinkerDlg.Create(this, IDD_LINKER, &Pos, (long) pProject);
	tcitem.pszText = "Linker";
	tcitem.lParam = (long) &LinkerDlg;
	::SendMessage(_hWndTab, TCM_INSERTITEM, 2, 
		(LPARAM)&tcitem);

	// Insert Archives tab.
	ZipDlg.Create(this, IDD_ZIP, &Pos, (long) pProject);
	tcitem.pszText = "Archives";
	tcitem.lParam = (long) &ZipDlg;
	::SendMessage(_hWndTab, TCM_INSERTITEM, 3, 
		(LPARAM)&tcitem);

	// Show the dialog and default pane.
	Show();
	GeneralDlg.Show();
	GeneralDlg.SetFocus();
return TRUE;
}

BOOL COptionsDlg::OnCommand(WORD wNotifyCode, WORD wID, HWND hwndCtl){
	switch (wID){
		case IDOK:
			GeneralDlg.OnCommand(wNotifyCode, wID, hwndCtl);
			CompilerDlg.OnCommand(wNotifyCode, wID, hwndCtl);
			LinkerDlg.OnCommand(wNotifyCode, wID, hwndCtl);
			ZipDlg.OnCommand(wNotifyCode, wID, hwndCtl);
			pProject->buildMakefile = true;
			pProject->modified = true;
			EndDlg(IDOK);
			return TRUE;

		case IDCANCEL:
			EndDlg(IDCANCEL);
			break;
	}
return 0;
}

BOOL COptionsDlg::EndDlg(int nResult){
	GeneralDlg.EndDlg(0);
	CompilerDlg.EndDlg(0);
	LinkerDlg.EndDlg(0);
	ZipDlg.EndDlg(0);
	if (_hWnd){
		BOOL result = ::EndDialog(_hWnd, nResult);
		_hWnd = 0;
		return result;
	}
return false;
}


/********************************************************************
*	Class:	CGeneralDlg.
*
*	Purpose:
*
*	Revisions:	
*
********************************************************************/
CGeneralDlg::CGeneralDlg(){
	pProject = NULL;
	pMakefile = NULL;
}

CGeneralDlg::~CGeneralDlg(){
}

LRESULT CALLBACK CGeneralDlg::CDlgProc(UINT Message, WPARAM wParam, LPARAM lParam){
	switch(Message){
		case WM_INITDIALOG:
			return OnInitDialog((HWND) wParam, lParam);
		
		case WM_COMMAND:
			OnCommand(HIWORD(wParam), LOWORD(wParam), (HWND) lParam);
			break;

		case WM_CLOSE:
			EndDlg(0); 
			break;
	}
return FALSE;
}

BOOL CGeneralDlg::OnInitDialog(HWND, LPARAM lInitParam){
	/* Set pointers */
	pProject = (CProject *) lInitParam;
	if (pProject == NULL || &pProject->Makefile == NULL)
		return TRUE;
	pMakefile = &pProject->Makefile;

	/* Get control handles */
	hStatLib 	= GetItem(IDC_STATLIB);
	hDll 		= GetItem(IDC_DLL);
	hConsole 	= GetItem(IDC_CONSOLE);
	hGuiExe 	= GetItem(IDC_GUIEXE);
	hDbgSym 	= GetItem(IDC_DBGSYM);
	hLangC 	= GetItem(IDC_LANGC);
	hLangCpp 	= GetItem(IDC_LANGCPP);
	hMkfName 	= GetItem(IDC_MKF_NAME);
	hMkfDir 	= GetItem(IDC_MKF_DIR);
	hUserMkf 	= GetItem(IDC_USER_MKF);
	hTgtName 	= GetItem(IDC_TGT_NAME);
	hTgtDir 	= GetItem(IDC_TGT_DIR);

	/* Set buttons state */
	switch(pMakefile->buildWhat){
		case BUILD_STATLIB:
			::SendMessage(hStatLib, BM_SETCHECK, BST_CHECKED, 0);
		break;
		case BUILD_DLL:
			::SendMessage(hDll, BM_SETCHECK, BST_CHECKED, 0);
		break;
		case BUILD_EXE:
			::SendMessage(hConsole, BM_SETCHECK, BST_CHECKED, 0);
		break;
		case BUILD_GUIEXE:
			::SendMessage(hGuiExe, BM_SETCHECK, BST_CHECKED, 0);
		break;
	}
	if (pMakefile->debug)
		::SendMessage(hDbgSym, BM_SETCHECK, BST_CHECKED, 0);

	if (pMakefile->lang == LANGCPP)
		::SendMessage(hLangCpp, BM_SETCHECK, BST_CHECKED, 0);
	else
		::SendMessage(hLangC, BM_SETCHECK, BST_CHECKED, 0);

	/* Set text */
	char name[64];
	if (pMakefile->nFileOffset){
		strcpy(name, &pMakefile->szFileName[pMakefile->nFileOffset]);
	}else{
		strcpy(name, "noname");
	}

	SetItemText(hMkfName,	name);
	SetItemText(hMkfDir,		pMakefile->mkfDir);
	SetItemText(hTgtName,	pMakefile->target);
	SetItemText(hTgtDir, 		pMakefile->tgtDir);
return TRUE;
}

BOOL CGeneralDlg::OnCommand(WORD, WORD wID, HWND){
	switch (wID){
		case IDOK:{
			/* Get text */
			char name[64];
			GetItemText(hMkfName,	name,	64);
			GetItemText(hMkfDir,		pMakefile->mkfDir,	MAX_PATH);
			GetItemText(hTgtName, 	pMakefile->target,	64);
			GetItemText(hTgtDir,		pMakefile->tgtDir,	MAX_PATH);

			pMakefile->GetFullPath(pMakefile->szFileName, pProject->nFileOffset, name);
			//@@TODO check if directories exist.

			/* Get buttons state */
			char * pExt = strrchr(pMakefile->target, '.');
			if (!pExt){
				int len = strlen(pMakefile->target);
				if (!len){
					strcpy(pMakefile->target, "noname");
					len = strlen(pMakefile->target);
				}
				pExt = pMakefile->target + len;
			}
			if (BST_CHECKED == ::SendMessage(hStatLib, BM_GETCHECK, 0, 0)){
				pMakefile->buildWhat = BUILD_STATLIB;
				strcpy(pExt, ".a");
			}else if (BST_CHECKED == ::SendMessage(hDll, BM_GETCHECK, 0, 0)){
				pMakefile->buildWhat = BUILD_DLL;
				strcpy(pExt, ".dll");
			}else if (BST_CHECKED == ::SendMessage(hConsole, BM_GETCHECK, 0, 0)){
				pMakefile->buildWhat = BUILD_EXE;
				strcpy(pExt, ".exe");
			}else if (BST_CHECKED == ::SendMessage(hGuiExe, BM_GETCHECK, 0, 0)){
				pMakefile->buildWhat = BUILD_GUIEXE;
				strcpy(pExt, ".exe");
			}
			pMakefile->debug = 
				(BST_CHECKED==::SendMessage(hDbgSym, BM_GETCHECK, 0, 0));

			if (BST_CHECKED == ::SendMessage(hLangCpp, BM_GETCHECK, 0, 0)){
				pMakefile->lang = LANGCPP;
				strcpy(pMakefile->cc, "g++");
			}else{
				pMakefile->lang = LANGC;
				strcpy(pMakefile->cc, "gcc");
			}
		}
		return TRUE;

		case IDCANCEL:
		return FALSE;
	}
return FALSE;
}


/********************************************************************
*	Class:	CCompilerDlg.
*
*	Purpose:
*
*	Revisions:	
*
********************************************************************/
CCompilerDlg::CCompilerDlg(){
	pProject = NULL;
	pMakefile = NULL;
}

CCompilerDlg::~CCompilerDlg(){
}

LRESULT CALLBACK CCompilerDlg::CDlgProc(UINT Message, WPARAM wParam, LPARAM lParam){
	switch(Message){
		case WM_INITDIALOG:
			return OnInitDialog((HWND) wParam, lParam);
		
		case WM_COMMAND:
			OnCommand(HIWORD(wParam), LOWORD(wParam), (HWND) lParam);
			break;

		case WM_CLOSE:
			EndDlg(0); 
			break;
	}
return FALSE;
}

BOOL CCompilerDlg::OnInitDialog(HWND, LPARAM lInitParam){
	// Set pointers.
	pProject = (CProject *) lInitParam;
	if (pProject == NULL || &pProject->Makefile == NULL)
		return TRUE;
	pMakefile = &pProject->Makefile;

	hCppFlags	= GetItem(IDC_CPPFLAGS);
	hWarning	= GetItem(IDC_WARNING);
	hOptimiz	= GetItem(IDC_OPTIMIZ);
	hCFlags	= GetItem(IDC_CFLAGS);
	hIncDirs	= GetItem(IDC_INCDIRS);

	SetItemText(hCppFlags, pMakefile->cppFlags);
	SetItemText(hWarning, pMakefile->warning);
	SetItemText(hOptimiz, 	pMakefile->optimize);
	SetItemText(hCFlags, 	pMakefile->cFlags);
	SetItemText(hIncDirs, 	pMakefile->incDirs);
return TRUE;
}

BOOL CCompilerDlg::OnCommand(WORD, WORD wID, HWND){
	switch (wID){
		case IDOK:
			GetItemText(hCppFlags,	pMakefile->cppFlags,	256);
			GetItemText(hWarning,	pMakefile->warning,	64);
			GetItemText(hOptimiz, 	pMakefile->optimize,	64);
			GetItemText(hCFlags, 	pMakefile->cFlags,	64);
			GetItemText(hIncDirs, 	pMakefile->incDirs, 	256);
		return TRUE;

		case IDCANCEL:
		return FALSE;
	}
return FALSE;
}


/********************************************************************
*	Class:	CLinkerDlg.
*
*	Purpose:
*
*	Revisions:	
*
********************************************************************/
CLinkerDlg::CLinkerDlg(){
	pProject = NULL;
	pMakefile = NULL;
}

CLinkerDlg::~CLinkerDlg(){
}

LRESULT CALLBACK CLinkerDlg::CDlgProc(UINT Message, WPARAM wParam, LPARAM lParam){
	switch(Message){
		case WM_INITDIALOG:
			return OnInitDialog((HWND) wParam, lParam);
		
		case WM_COMMAND:
			OnCommand(HIWORD(wParam), LOWORD(wParam), (HWND) lParam);
			break;

		case WM_CLOSE:
			EndDlg(0); 
			break;
	}
return FALSE;
}

BOOL CLinkerDlg::OnInitDialog(HWND, LPARAM lInitParam){
	// Set pointers.
	pProject = (CProject *) lInitParam;
	if (pProject == NULL || &pProject->Makefile == NULL)
		return TRUE;
	pMakefile = &pProject->Makefile;

	hLdStrip	= GetItem(IDC_LDSTRIP);
	hLdOpts	= GetItem(IDC_LDOPTS);
	hLdLibs	= GetItem(IDC_LDLIBS);
	hLibsDirs	= GetItem(IDC_LIBDIRS);

	SetItemText(hLdStrip, 	pMakefile->ldStrip);
	SetItemText(hLdOpts, 	pMakefile->ldOpts);
	SetItemText(hLdLibs, 	pMakefile->ldLibs);
	SetItemText(hLibsDirs, 	pMakefile->libDirs);
return TRUE;
}

BOOL CLinkerDlg::OnCommand(WORD, WORD wID, HWND){
	switch (wID){
		case IDOK:
			GetItemText(hLdStrip, 	pMakefile->ldStrip,	32);
			GetItemText(hLdOpts, 	pMakefile->ldOpts,	64);
			GetItemText(hLdLibs, 	pMakefile->ldLibs,	64);
			GetItemText(hLibsDirs,	pMakefile->libDirs,	256);
		return TRUE;

		case IDCANCEL:
		return FALSE;
	}
return FALSE;
}


/********************************************************************
*	Class:	CZipDlg.
*
*	Purpose:
*
*	Revisions:	
*
********************************************************************/
CZipDlg::CZipDlg(){
	pProject = NULL;
	pMakefile = NULL;
}

CZipDlg::~CZipDlg(){
}

LRESULT CALLBACK CZipDlg::CDlgProc(UINT Message, WPARAM wParam, LPARAM lParam){
	switch(Message){
		case WM_INITDIALOG:
			return OnInitDialog((HWND) wParam, lParam);
		
		case WM_COMMAND:
			OnCommand(HIWORD(wParam), LOWORD(wParam), (HWND) lParam);
			break;

		case WM_CLOSE:
			EndDlg(0); 
			break;
	}
return FALSE;
}

BOOL CZipDlg::OnInitDialog(HWND, LPARAM lInitParam){
	// Set pointers.
	pProject = (CProject *) lInitParam;
	if (pProject == NULL || &pProject->Makefile == NULL)
		return TRUE;
	pMakefile = &pProject->Makefile;

	hZipDir = GetItem(IDC_ZIP_DIR);
	hZipFlags = GetItem(IDC_ZIPFLAGS);
	SetItemText(hZipDir, pProject->zipDir);
	SetItemText(hZipFlags, pProject->zipFlags);
return TRUE;
}

BOOL CZipDlg::OnCommand(WORD, WORD wID, HWND){
	switch (wID){
		case IDOK:
			GetItemText(hZipDir, pProject->zipDir, MAX_PATH);
			GetItemText(hZipFlags, pProject->zipFlags, 256);
		return TRUE;

		case IDCANCEL:
		return FALSE;
	}
return FALSE;
}


/********************************************************************
*	Class:	CNewModuleDlg.
*
*	Purpose:
*
*	Revisions:	
*
********************************************************************/
CNewModuleDlg::CNewModuleDlg(){
	pProject = NULL;
}

CNewModuleDlg::~CNewModuleDlg(){
}

LRESULT CALLBACK CNewModuleDlg::CDlgProc(UINT Message, WPARAM wParam, LPARAM lParam){

	char		fileName[64];
	bool		createHeader = true;
	HWND wCreateHeader = GetItem(IDC_HEADER);

	switch(Message){
		case WM_INITDIALOG:
			pProject = (CProject *) lParam;
			if (createHeader)
				::SendMessage(wCreateHeader, BM_SETCHECK, BST_CHECKED, 0);
				strcpy(fileName, "new.cpp");
				::SetDlgItemText(_hWnd, 301, fileName);
			return TRUE;
	
		case WM_COMMAND:
			if (LOWORD(wParam) == IDCANCEL){
				fileName[0] = 0;
				EndDlg(IDCANCEL);
				return FALSE;
			}else if(LOWORD(wParam) == IDOK){
				::GetDlgItemText(_hWnd, 301, fileName, 64);
				createHeader = BST_CHECKED ==
						 ::SendMessage(wCreateHeader, BM_GETCHECK, 0, 0);
				pProject->NewModule(fileName, createHeader);
				EndDlg(IDCANCEL);
				return TRUE;
			}
			break; 

		case WM_CLOSE:
			EndDlg(0); 
			break;
	}
return FALSE;
}


/********************************************************************
*	Class:	CProject.
*
*	Purpose:	Project management.
*
*	Revisions:	
*
********************************************************************/
//@@TODO close project Dlg's before closing Project.
CProject::CProject(){
	prjVer = 40;
}

CProject::~CProject(){
}

void CProject::Reset(){
	szFileName[MAX_PATH - 1] = '\0';	// security.
	szFileName[0] 		= '\0';
	szDirBuffer[0] 		= '\0';
	nFileOffset			= 0;
	nFileExtension		= 0;

	strcpy	(zipDir,	".");
	strcpy	(zipFlags,	"*.*");
	numFiles 			= 0;
	loaded			= false;
	modified			= false;
	buildMakefile		= true;

	compilerName[0]		= '\0';

	Makefile.Init();
}

bool CProject::NoProject(void){
	if (!loaded){
		MsgBox.DisplayWarning("No project loaded");
		// Or directly show open project dlg.
		return true;
	}
return false;
}

int CProject::CloseDecision(void){
	if (loaded){
		return MsgBox.Ask("Close current project ?", false);
	}
return IDNO;
}

bool CProject::SwitchCurrentDir(void){
	// Switch to Project Directory
	szDirBuffer[nFileOffset-1] = '\0';
return ::SetCurrentDirectory(szDirBuffer);
}

bool CProject::RelativeToAbsolute(char * relativePath){
	if (*szDirBuffer && nFileOffset){
		if (relativePath[0] == '.' && relativePath[1] == '\\' 
									&& relativePath[2] != '\0'){
			szDirBuffer[nFileOffset-1] = '\\';
			strcpy(&szDirBuffer[nFileOffset], &relativePath[2]);
			return true;
		}
	}
return false;
}


/********************************************************************
*	New Project.
********************************************************************/
bool CProject::New(char * fileName, WORD fileOffset){
	// Load default values.
	Reset();

	// Copy project file's directory.
	strcpy(szFileName, fileName);
	nFileOffset = fileOffset;

	strncpy(szDirBuffer, szFileName, (nFileOffset - 1));
	szDirBuffer[nFileOffset-1] = '\0';
	strcpy(winApp.projectDir, szDirBuffer);

	// Makefile: Get target name.
	nFileExtension = winApp.FileDlg.GetFileExtension();
	strcpy(Makefile.target, &szFileName[nFileOffset]);
	char * pExt = strrchr(Makefile.target, '.');
	if (pExt){
		*pExt='\0';
	}
	loaded = true;

	AddFiles();
	
	Makefile.GetFullPath(szFileName, nFileOffset, "makefile");

	buildMakefile = true;
	OptionsDlg();
	SavePrjFile(IDYES);
return true;
}

/********************************************************************
*	Open Project.
********************************************************************/
bool CProject::Open(char * fileName, WORD fileOffset){
	// Initialize project tree view.
	Reset();

	// Copy project file's directory.
	strcpy(szFileName, fileName);
	nFileOffset = fileOffset;

	strncpy(szDirBuffer, szFileName, (nFileOffset - 1));
	szDirBuffer[nFileOffset-1] = '\0';
	strcpy(winApp.projectDir, szDirBuffer);

	// Load project file in a buffer.
	if (!PrjFile.Load(szFileName)){
		MsgBox.DisplayFatal("Can't load project file !");
		//@@ should close inifile ?
		return false;
	}

	char name[64];
	*name = '\0';
	// [Project] section
	int signature = PrjFile.GetInt(		"Signature", 		"Project"	);
	if (signature != prjVer){
		MsgBox.DisplayFatal("Bad signature in the project file !");
		return false;
	}

	numFiles = PrjFile.GetInt(			"NumFiles"	);
	PrjFile.GetString(compilerName, 		"Compiler"	);
	buildMakefile = PrjFile.GetInt(			"BuildMakefile"	);

	// [Archives] section
	PrjFile.GetString(zipDir, 			"Directory", 	"Archives"	);
	PrjFile.GetString(zipFlags, 			"Flags");

	// [Makefile] section
	PrjFile.GetString(Makefile.make, 		"Make", 		"Makefile"	);
	PrjFile.GetString(Makefile.cc, 			"CC"		);
	PrjFile.GetString(Makefile.wres, 		"WRES"	);
	PrjFile.GetString(Makefile.test, 		"TEST"	);
	PrjFile.GetString(name, 			"Makefile"	);
	PrjFile.GetString(Makefile.mkfDir, 		"MakefileDir");
	PrjFile.GetString(Makefile.target, 		"Target"	);
	PrjFile.GetString(Makefile.tgtDir, 		"TargetDir"	);
	Makefile.buildWhat 	= PrjFile.GetInt( 	"Build"	);
	Makefile.debug 		= PrjFile.GetInt( 	"Debug"	);
	Makefile.lang 		= PrjFile.GetInt( 	"Lang"	);
	PrjFile.GetString(Makefile.cppFlags,		"CppFlags"	);
	PrjFile.GetString(Makefile.warning, 		"CcWarning");
	PrjFile.GetString(Makefile.optimize, 		"CcOptimize");
	PrjFile.GetString(Makefile.cFlags, 		"CcFlags"	);
	PrjFile.GetString(Makefile.incDirs,		"IncDirs"	);
	PrjFile.GetString(Makefile.ldStrip, 		"LdStrip"	);
	PrjFile.GetString(Makefile.ldOpts, 		"LdOptions"	);
	PrjFile.GetString(Makefile.ldLibs, 		"LdLibraries");
	PrjFile.GetString(Makefile.libDirs, 		"LdLibDirs"	);

	Makefile.GetFullPath(szFileName, nFileOffset, name);

	if (numFiles){
		CFileItem * srcFile;
		// [FileXX] section
		char fileNumber [8];
		char fileSection [16];
	
		for (int n=1; n<=numFiles; n++){
			itoa(n, fileNumber, 10);
			strcpy(fileSection, "File");
			strcat(fileSection, fileNumber);
	
			// SrcFile
			srcFile = new CFileItem;
			srcFile->isInProject = true;
			PrjFile.GetString(srcFile->szFileName,	"Name", 	fileSection);
			CheckFile(srcFile);
			::GetFileType(srcFile);
			srcFile->show 	= PrjFile.GetInt(	"Show"	);
	
			if(!winApp.Manager.OpenFile(srcFile)){
				delete srcFile;
				return false;
			}
		}
	}
	loaded = true;
return true;
}

int CProject::SavePrjFile(int decision){
	if (!loaded || !modified)
		return decision;
	if (decision == IDNO || decision == IDCANCEL)
		return decision;

	/* Ask ? */
	if (decision == IDASK){
		decision = MsgBox.AskToSave(true); // Cancel button.
		if (decision != IDYES)
			return decision; // IDNO or IDCANCEL.
	}

	CProjectView * pProjectView = &winApp.Manager.ProjectView;
 	FILE * file;
	CFileItem * srcFile;
	int count = 0;

	numFiles = pProjectView->Length();

	file = fopen(szFileName, "w");
	if (!file){
		MsgBox.DisplayFatal("Can't save project file !");
		return decision;
	}

	// [Project]
	fprintf (file, "[Project]\nSignature = %d"		, prjVer			);
	fprintf (file, "\nNumFiles = %d"			, numFiles			);
	fprintf (file, "\nCompiler = %s"			, compilerName		);
	fprintf (file, "\nBuildMakefile = %d"			, buildMakefile		);

	// [Archives]
	fprintf (file, "\n\n[Archives]\nDirectory = %s"	, zipDir			);
	fprintf (file, "\nFlags = %s"				, zipFlags			);

	// [Makefile]
	fprintf (file, "\n\n[Makefile]\nMAKE = %s"		, Makefile.make		);
	fprintf (file, "\nCC = %s"				, Makefile.cc		);
	fprintf (file, "\nWRES = %s"				, Makefile.wres		);
	fprintf (file, "\nTEST = %s"				, Makefile.test		);
	fprintf (file, "\nMakefile = %s"				, &Makefile.szFileName[Makefile.nFileOffset]);
	fprintf (file, "\nMakefileDir = %s"			, Makefile.mkfDir		);
	fprintf (file, "\nTarget = %s"				, Makefile.target		);
	fprintf (file, "\nTargetDir = %s"			, Makefile.tgtDir		);
	fprintf (file, "\nBuild = %d"				, Makefile.buildWhat	);
	fprintf (file, "\nDebug = %d"				, Makefile.debug		);
	fprintf (file, "\nLang = %d"				, Makefile.lang		);
	fprintf (file, "\nCppFlags = %s"			, Makefile.cppFlags	);
	fprintf (file, "\nCcWarning = %s"			, Makefile.warning	);
	fprintf (file, "\nCcOptimize = %s"			, Makefile.optimize	);
	fprintf (file, "\nCcFlags = %s"				, Makefile.cFlags		);
	fprintf (file, "\nIncDirs = %s"				, Makefile.incDirs		);
	fprintf (file, "\nLdStrip = %s"				, Makefile.ldStrip		);
	fprintf (file, "\nLdOptions = %s"			, Makefile.ldOpts		);
	fprintf (file, "\nLdLibraries = %s"			, Makefile.ldLibs		);
	fprintf (file, "\nLdLibDirs = %s"			, Makefile.libDirs		);

	/* [Filexx] */
	srcFile = (CFileItem *) pProjectView->First();
	while (srcFile){
		count++;
		fprintf (file, "\n\n[File%d"			, count			);
		fprintf (file, "]\nName = %s"			, srcFile->szFileName	);
		fprintf (file, "\nShow = %d" 			, 0				);
		srcFile = (CFileItem *) pProjectView->Next();
	}
	fprintf (file, "\n");
	fclose(file);
	modified = false;
return decision;
}

bool CProject::NewModule(char * name, bool createHeader){
	if (NoProject())
		return false;

	SwitchCurrentDir();

	CFileItem * srcFile = winApp.Manager.ProjectView.NewFile(name);
	if (!srcFile){
		MsgBox.DisplayWarning("Can't create file : %s", name);
		return false;
	}
	if (createHeader && srcFile->type != H_FILE){
		char header[64];
		strcpy(header, name);
		char ext[] = "h";
		ChangeFileExt(header, ext);

		if (!winApp.Manager.ProjectView.NewFile(header)){
			MsgBox.DisplayWarning("Can't create file : %s", header);
			return false;
		}
	}
return true;
}

bool CProject::AddFiles(void){
	if (NoProject())
		return false;

	CFileItem * srcFile;
	char srcFiles[2048];
	srcFiles [0] = 0;
	WORD fileOffset;

	// Show Open dialog.
	if (!winApp.FileDlg.Open(&winApp, srcFiles, 2048, ADD_SRC_FILE))
		return false;  // canceled by user

	// Check if srcFiles path includes projectDir.
	int n = 0;
	int maxlen = nFileOffset - 1;
	while (n<maxlen){
		// @@ shouldn't be case sensitive.
		if (srcFiles[n] != szFileName[n])
			break;
		n++;
	}

	if (srcFiles[n] == '\\' || srcFiles[n] == '\0'){
		// We are in the project, copy directory name.
		n++;
		char relativePath[MAX_PATH];
		relativePath[0] = '.';
		relativePath[1] = '\\';
		int nn = 2;

		fileOffset = winApp.FileDlg.GetFileOffset();
		maxlen = fileOffset - 1;
		while (n<maxlen){
			relativePath[nn] = srcFiles[n];
			n++;
			nn++;
		}
		if (nn > 2){
			relativePath[nn] = '\\';
			nn++;
		}
		relativePath[nn] = '\0';

		// Append each file name.
		fileOffset = winApp.FileDlg.GetFileOffset();

		while (fileOffset){
			// Try to add each file to the project.
			srcFile = new CFileItem;
			strcpy(srcFile->szFileName, relativePath);

			strcat(srcFile->szFileName, &srcFiles[fileOffset]);

			CheckFile(srcFile);
			::GetFileType(srcFile);
			srcFile->show 	= 0;
			srcFile->isInProject = true;
	
			if(!winApp.Manager.ProjectView.OpenFile(srcFile)){
				delete srcFile;
				return false;
			}

			fileOffset = winApp.FileDlg.GetNextFileOffset();
		}
		modified = true;
		buildMakefile = true;
		return true;
	}
	MsgBox.DisplayString("Out of the project");
return false;
}

/********************************************************************
*	Dialogs.
********************************************************************/
bool CProject::OptionsDlg(void){
/**/	if (NoProject())
		return false;

	_OptionsDlg.CreateModal(&winApp, IDD_OPTION, (LPARAM) this);
return true;
}

bool CProject::NewModuleDlg(void){
	if (NoProject())
		return false;

	_NewModuleDlg.CreateModal(&winApp, IDD_NEW_MODULE, (LPARAM) this);
return true;
}

/********************************************************************
*	Project Commands.
********************************************************************/
void CProject::ZipSrcs(void){
	if (NoProject() || winApp.Process.isRunning())
		return;

	// Switch to Project Directory
	SwitchCurrentDir();

	winApp.Report.Clear();

	char fileName[64];
	char date[16];
	date[0] = 0;

	// Archive name = zipDir\month+day+year+src.zip
	GetDateFormat(LOCALE_USER_DEFAULT, 0, NULL, "MMddyyyy", 
				date, 16);

	if (*zipDir == '\0')
		strcpy (zipDir, ".");
	strcpy (fileName, zipDir);
	strcat (fileName, "\\");
	strcat (fileName, date);
	strcat (fileName, "src");
	strcat (fileName, ".zip");

	char msgBuf[128];
	sprintf(msgBuf, "Create archive > %s", fileName);
	winApp.Report.Append(msgBuf, LVOUT_NORMAL);

	// Put the command line and the run flag in the command stack.
	winApp.Process.AddTask(
		"zip ", 
		OUTERR_PIPE,
		LVOUT_NORMAL);

	winApp.Process.CmdCat(fileName);
	if (*zipFlags){
		winApp.Process.CmdCat(" ");
		winApp.Process.CmdCat(zipFlags);
	}
	
	winApp.Process.Run();
}

void CProject::Explore(HWND hwnd){
	if (NoProject())
		return;

	if(ShellExecute(hwnd, "explore", szDirBuffer, NULL, NULL, SW_SHOWMAXIMIZED) 
			< (HINSTANCE) 32){
		MsgBox.DisplayString("Can't launch Explorer");
		return;
	}
}

/********************************************************************
*	Compiler Commands.
********************************************************************/
void CProject::Build(void){
	if (NoProject() || winApp.Process.isRunning())
		return;

	winApp.Report.Clear();
	winApp.Report.Append("Invoking compiler...", LVOUT_NORMAL);

	// Save modified files
	winApp.Manager.ProjectView.SaveAll(IDYES); // Silent.

	// Switch to Makefile Directory
	Makefile.SwitchCurrentDir();

	/* Build makefile ? */
	if (buildMakefile){
		winApp.Report.Append("Building makefile...", LVOUT_NORMAL);

		// Fill buffers and initialize a new process.
		Makefile.Build(&winApp.Manager.ProjectView, &winApp.Process);
		buildMakefile = false;
		modified = true;
	}

	// Put the command line and the run flag in the command stack.
	winApp.Process.AddTask(
		Makefile.make, 
		OUTERR_PIPE,
		LVOUT_ERROR);

	winApp.Process.CmdCat(" -f ");
	winApp.Process.CmdCat(&Makefile.szFileName[Makefile.nFileOffset]);
	if (Makefile.debug)
		winApp.Process.CmdCat(" debug");

	winApp.Process.Run();
}

void CProject::RebuildAll(void){
	if (NoProject() || winApp.Process.isRunning())
		return;

	// Switch to Makefile Directory
	Makefile.SwitchCurrentDir();

	winApp.Report.Clear();
	winApp.Report.Append("Invoking compiler...", LVOUT_NORMAL);

	// Save modified files
	winApp.Manager.ProjectView.SaveAll(IDYES); // Silent.

	// Build makefile.
	Makefile.Build(&winApp.Manager.ProjectView, &winApp.Process);
	buildMakefile = false;
	modified = true;

	// Make clean.
	winApp.Process.AddTask(
		Makefile.make, 
		OUTERR_PIPE,
		LVOUT_ERROR);

	winApp.Process.CmdCat(" -f ");
	winApp.Process.CmdCat(&Makefile.szFileName[Makefile.nFileOffset]);
	winApp.Process.CmdCat(" clean");
	
	// Build.
	winApp.Process.AddTask(
		Makefile.make, 
		OUTERR_PIPE,
		LVOUT_ERROR);

	winApp.Process.CmdCat(" -f ");
	winApp.Process.CmdCat(&Makefile.szFileName[Makefile.nFileOffset]);
	if (Makefile.debug)
		winApp.Process.CmdCat(" debug");

	winApp.Process.Run();
}

void CProject::RunTarget(void){
	if (NoProject() || winApp.Process.isRunning())
		return;

	if (Makefile.buildWhat == BUILD_STATLIB 
		|| Makefile.buildWhat ==BUILD_DLL)
		return;

	winApp.Report.Clear();
	winApp.Report.Append("Run target...", LVOUT_NORMAL);

	// Put the command line and the run flag in the command stack.
	winApp.Process.AddTask(szDirBuffer, NO_PIPE, STDOUT_NONE);
	winApp.Process.CmdCat("\\");
	if (Makefile.tgtDir[0] == '.'){
		if (Makefile.tgtDir[1] == '.' && Makefile.tgtDir[2] == '\\' 
									&& Makefile.tgtDir[3] != '\0'){
			winApp.Process.CmdCat(&Makefile.tgtDir[3]);
		}else{
			// Invalid dir, try ".\target".
			winApp.Process.CmdCat(".");
		}
	}
	winApp.Process.CmdCat("\\");
	winApp.Process.CmdCat(Makefile.target);
	
	winApp.Process.Run();
}

void CProject::MakeClean(void){
	if (NoProject() || winApp.Process.isRunning())
		return;

	// Switch to Makefile Directory
	Makefile.SwitchCurrentDir();

	winApp.Report.Clear();
	winApp.Report.Append("Deleting objects...", LVOUT_NORMAL);

	// Put the command line and the output flag in the command stack.
	winApp.Process.AddTask(
		Makefile.make, 
		OUTERR_PIPE,
		LVOUT_ERROR);

	winApp.Process.CmdCat(" -f ");
	winApp.Process.CmdCat(&Makefile.szFileName[Makefile.nFileOffset]);
	winApp.Process.CmdCat(" clean");
	
	winApp.Process.Run();
}

void CProject::BuildMakefile(void){
	if (NoProject() || winApp.Process.isRunning())
		return;

	// Switch to Project Directory
	Makefile.SwitchCurrentDir();

	winApp.Report.Clear();
	winApp.Report.Append("Building makefile...", LVOUT_NORMAL);

	// Fill buffers and initialize a new process.
	Makefile.Build(&winApp.Manager.ProjectView, &winApp.Process);
	buildMakefile = false;
	modified = true;
	// Run the process.
	winApp.Process.Run();
}


/********************************************************************
*	Class:	CMakefile.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CMakefile::CMakefile(){
	Init();
}

CMakefile::~CMakefile(){
}

void CMakefile::Init(void){
	szFileName[MAX_PATH - 1] = '\0';	// security.
	szFileName[0] 		= '\0';
	nFileOffset			= 0;
	strcpy	(mkfDir,	".");

	strcpy	(cc, 		"gcc");
	strcpy	(make, 	"make");
	strcpy	(wres, 	"windres");
	strcpy	(test, 	"gcc -v");

	target[0] 			= '\0';
	strcpy	(tgtDir,	".");
	buildWhat			= BUILD_EXE;
	debug			= false;
	lang				= LANGC;

	cppFlags[0]		= '\0';
	strcpy	(warning, 	"-W -Wall -pedantic");
	strcpy	(optimize, 	"-O2");
	cFlags[0]			= '\0';
	incDirs[0] 			= '\0';

	strcpy	(ldStrip, 	"-s");
	ldOpts[0]			= '\0';
	ldLibs[0]			= '\0';
	libDirs[0] 			= '\0';
	*arFlags = '\0';
}

void CMakefile::GetFullPath(char * prjFileName, WORD offset, char * name){
	// Copy project directory and append makefile relative dir.
	strncpy(szFileName, prjFileName, offset);
	WORD len = AppendPath(szFileName, offset, mkfDir);
	// Increment file offset.
	if (len){
		offset += len;
	}else{
		strcpy(mkfDir, ".");
	}
	// Append makefile name.
	szFileName[offset-1] = '\\';
	if (*name){
		strcpy(&szFileName[offset], name);
	}else{
		strcpy(name, "makefile");
	}
	nFileOffset = offset;
}

bool CMakefile::SwitchCurrentDir(void){
	// Switch to Makefile Directory.
	if (nFileOffset < 2)
		return false;
	szFileName[nFileOffset-1] = '\0';
	bool result = SetCurrentDirectory(szFileName);
	szFileName[nFileOffset-1] = '\\';
return result;
}

void CMakefile::Build(CProjectView * Tree, CProcess* /*Process*/){
	SrcList2Buffers(Tree);
	// Write the first part of the Makefile.
	Write();

	/* Invokes compiler to get dependencies with something like: 
		"gcc -MM file1.cpp file2.cpp ..." */

	CTask * task = winApp.Process.AddTask(
		depBuf, 
		OUTERR_PIPE,
		STDOUT_FILE_APPEND);
	strcpy(task->szFileName, szFileName);
}

void CMakefile::SrcList2Buffers(CProjectView * Tree){

	// 1. Begin to fill each buffer.
	strcpy(depBuf, cc);
	if (*cppFlags != '\0'){
		strcat(depBuf, " ");
		strcat(depBuf, cppFlags);
	}
	strcat(depBuf, " -MM ");
	if (*incDirs != '\0'){
		strcat(depBuf, incDirs);
		strcat(depBuf, " ");
	}

	strcpy(srcBuf, "\nSRCS\t=\\\n");
	strcpy(objBuf, "\nOBJS\t=\\\n");
	resBuf [0] = 0;

	// 2. Parse the module list and retrieve sources files names.
	CFileItem* srcFile;

	if(!Tree->First())
		return; // The list is empty, nothing to search.

	do {	srcFile = (CFileItem *) Tree->GetCurrent();

		if (srcFile->type == C_FILE || srcFile->type == RC_FILE){
			// Source files and objects buffers.
			strcat (srcBuf, "\t");
			strcat (srcBuf, &srcFile->szFileName[srcFile->nFileOffset]);
			strcat (srcBuf, "\\\n");

			// Change file extension.
			char ext[] = "o";
			strcpy(objFile, &srcFile->szFileName[srcFile->nFileOffset]);
			ChangeFileExt(objFile, ext);
			strcat (objBuf, "\t");
			strcat (objBuf, objFile);
			strcat (objBuf, "\\\n");

			if (srcFile->type == C_FILE){
				// Dependencies buffer.
				strcat(depBuf, &srcFile->szFileName[srcFile->nFileOffset]);
				strcat(depBuf, " ");
			}else if (srcFile->type == RC_FILE){
				// Resource buffer.
				strcat (resBuf, objFile);
				strcat (resBuf, ": ");
				strcat (resBuf, &srcFile->szFileName[srcFile->nFileOffset]);
				strcat (resBuf, "\n\n");
			}
		}
	} while (Tree->Next());

	int len = strlen(srcBuf);
	srcBuf[len-2] = '\n';
	srcBuf[len-1] = 0;

	len = strlen(objBuf);
	objBuf[len-2] = '\n';
	objBuf[len-1] = 0;
}

void CMakefile::Write(void){
	FILE * file;

	file = fopen(szFileName, "w");
	if (!file){
		MsgBox.DisplayString("Can't open file :\r\n%s", szFileName);
		return;
	}

	/* Signature */
	fprintf (file, "# Generated automatically by Visual-MinGW.\n");
	fprintf (file, "# http://visual-mingw.sourceforge.net/\n");

	/* Standard defines */
	fprintf (file, "\nCC = %s", 			cc);
	fprintf (file, "\nWRES = %s", 			wres		);
	fprintf (file, "\nDLLWRAP = dllwrap" 			);
	fprintf (file, "\nCPPFLAGS = %s", 				cppFlags	);

	if (buildWhat == BUILD_GUIEXE)
		fprintf (file, "\nLDBASEFLAGS = -mwindows %s %s", 	ldOpts, ldLibs	);
	else
		fprintf (file, "\nLDBASEFLAGS = %s %s", 		ldOpts, ldLibs	);
	fprintf (file, "\nINCDIRS = %s",				incDirs	);
	fprintf (file, "\nOPTIMIZ = %s",				optimize	);
	fprintf (file, "\nSTRIP = %s",					ldStrip	);
	/* Debug symbols ? Language ? */
	fprintf (file, "\n\nifeq ($(MAKECMDGOALS),debug)");
	if (lang == LANGCPP){
		fprintf (file, "\nCXXFLAGS = %s $(INCDIRS) -g %s", warning, cFlags);
		fprintf (file, "\nLDFLAGS = $(LDBASEFLAGS)");
		fprintf (file, "\nelse");
		fprintf (file, "\nCXXFLAGS = %s $(INCDIRS) $(OPTIMIZ) %s", warning, cFlags);
		fprintf (file, "\nLDFLAGS = $(STRIP) $(LDBASEFLAGS)");
		fprintf (file, "\nendif");
	}else{
		fprintf (file, "\nCFLAGS = %s $(INCDIRS) -g %s", warning, cFlags);
		fprintf (file, "\nLDFLAGS = $(LDBASEFLAGS)");
		fprintf (file, "\nelse");
		fprintf (file, "\nCFLAGS = %s $(INCDIRS) $(OPTIMIZ) %s", warning, cFlags);
		fprintf (file, "\nLDFLAGS = $(STRIP) $(LDBASEFLAGS)");
		fprintf (file, "\nendif");
	}
	/* Directories */
	fprintf (file, "\n\nSRCDIR = %s", 						mkfDir	);
	fprintf (file, "\nBINDIR = %s", 						tgtDir		);
	fprintf (file, "\nLIBDIRS = %s",						libDirs	);
	/* Rule to compile rc files */
	fprintf (file, "\n\n%c.o : %c.rc\n\t$(WRES) $(CPPFLAGS) $< $@", 	'%', '%'				);
	/* List of objects */
	fprintf (file, "\n%s", 								objBuf	);
	/* Target */
	fprintf (file, "\nTARGET =\t$(BINDIR)\\%s" , 				target	);
	/* all, alldebug */
	fprintf (file, "\n\n# Targets\n"								);
	fprintf (file, "all:\t$(TARGET)\n\ndebug:\t$(TARGET)\n\n"									);
	/* clean */
	fprintf (file, "cleanobjs:\n\trm -f $(OBJS)\n\n"						);
	fprintf (file, "cleanbin:\n\trm -f $(TARGET)\n\n"						);
	fprintf (file, "clean:\tcleanobjs cleanbin\n\n"						);
	/* Dependencies */
	fprintf (file, "# Dependency rules\n"								);
	/* Language */
	if (buildWhat == BUILD_STATLIB){
		fprintf (file, "$(TARGET): $(OBJS)\n\t$(AR) -ru $(BINDIR)\\%s", 	target);
		fprintf (file, " $(OBJS) $(INCDIRS) $(LIBDIRS)\n\n%s", 		resBuf);
	}else if (buildWhat == BUILD_DLL){
		fprintf (file, "$(TARGET): $(OBJS)\n\t$(DLLWRAP) -o $@ $(OBJS) $(LDFLAGS)\n\n"	);
	}else if (lang == LANGCPP){
		fprintf (file, "$(TARGET): $(OBJS)\n\t$(CXX) -o $(BINDIR)\\%s", 	target);
		fprintf (file, " $(OBJS) $(INCDIRS) $(LIBDIRS) $(LDFLAGS)\n\n%s",resBuf);
	}else{
		fprintf (file, "$(TARGET): $(OBJS)\n\t$(CC) -o $(BINDIR)\\%s", 	target);
		fprintf (file, " $(OBJS) $(INCDIRS) $(LIBDIRS) $(LDFLAGS)\n\n%s",resBuf);
	}
	fclose(file);
}


/********************************************************************
*	Class:	CCompiler.
*
*	Purpose:	
*
*	Revisions:	
*
********************************************************************/
CCompiler::CCompiler(){
	make[0] 		= '\0';
	cc[0] 		= '\0';
	cFlags[0] 		= '\0';
	ldFlags[0]		= '\0';
	wres[0] 		= '\0';
	debug[0] 		= '\0';
	test[0] 		= '\0';
}

CCompiler::~CCompiler(){
}

bool CCompiler::LoadData(char * fullpath){
	Load(fullpath);
	// [Common] section
	GetString(make, 		"MAKE", 		"Common");
	GetString(cc,		"CC"	 		);
	GetString(cFlags, 	"CFLAGS" 		);
	GetString(ldFlags, 	"LDFLAGS" 		);
	GetString(wres, 		"WRES" 		);
	GetString(debug, 	"DEBUG" 		);
	GetString(test, 		"TEST" 		);
return true;
}