Subversion Repositories spk

// BaseFile.h: interface for the CBaseFile class.

//

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

#ifndef __BASEFILE_H__

#define __BASEFILE_H__

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include "lists.h"

#include "StringList.h"

#include "File.h"

#include "Utils/String.h"

#include "Utils/StringList.h"

#include "Package/CorePackage.h"

#define GAME_ALL			0

#define GAME_X2				1

#define GAME_X3				2

#define GAME_X3TC			3

#define GAME_X3AP			4

#define GAME_XREBIRTH		5

#define GAME_MAX			(GAME_XREBIRTH)

#define FILEVERSION 4.20f

#define WRITECHUNK		50000

class CPackages;

namespace SPK {

	class CTextDB;

}

using namespace SPK;

enum {

	READFLAG_NONE = 0,

	READFLAG_NOUNCOMPRESS = 1

};

enum {SPKFILE_INVALID, SPKFILE_SINGLE, SPKFILE_MULTI, SPKFILE_SINGLESHIP, SPKFILE_OLD, SPKFILE_BASE};

enum {SPKREAD_ALL, SPKREAD_NODATA, SPKREAD_VALUES, SPKREAD_HEADER};

enum {DELETESTATE_NONE, DELETESTATE_WAITING, DELETESTATE_DONE};

enum {SPKINSTALL_CREATEDIRECTORY, SPKINSTALL_CREATEDIRECTORY_FAIL, SPKINSTALL_WRITEFILE, SPKINSTALL_WRITEFILE_FAIL, SPKINSTALL_DELETEFILE, SPKINSTALL_DELETEFILE_FAIL,

		SPKINSTALL_SKIPFILE, SPKINSTALL_REMOVEDIR, SPKINSTALL_ENABLEFILE, SPKINSTALL_DISABLEFILE, SPKINSTALL_ENABLEFILE_FAIL, SPKINSTALL_DISABLEFILE_FAIL,

		SPKINSTALL_UNINSTALL_MOVE, SPKINSTALL_UNINSTALL_COPY, SPKINSTALL_UNINSTALL_MOVE_FAIL, SPKINSTALL_UNINSTALL_COPY_FAIL, SPKINSTALL_UNINSTALL_REMOVE, SPKINSTALL_UNINSTALL_REMOVE_FAIL,

		SPKINSTALL_ORIGINAL_BACKUP, SPKINSTALL_ORIGINAL_RESTORE, SPKINSTALL_ORIGINAL_BACKUP_FAIL, SPKINSTALL_ORIGINAL_RESTORE_FAIL, SPKINSTALL_FAKEPATCH, SPKINSTALL_FAKEPATCH_FAIL, 

		SPKINSTALL_MISSINGFILE, SPKINSTALL_SHARED, SPKINSTALL_SHARED_FAIL, SPKINSTALL_ORPHANED, SPKINSTALL_ORPHANED_FAIL, SPKINSTALL_UNCOMPRESS_FAIL, SPKINSTALL_AUTOTEXT, SPKINSTALL_AUTOTEXT_FAIL

};

enum {PACKAGETYPE_NORMAL, PACKAGETYPE_LIBRARY, PACKAGETYPE_CUSTOMSTART, PACKAGETYPE_PATCH, PACKAGETYPE_UPDATE, PACKAGETYPE_MOD, PACKAGETYPE_SHIP, PACKAGETYPE_FAKEPATCH};

enum {TYPE_BASE, TYPE_SPK, TYPE_XSP, TYPE_ARCHIVE};

// text pages

#define TEXTPAGE_RACE		1266

#define TEXTPAGE_OBJECTS	17

#define TEXTPAGE_CLASS		2006

#define TEXTPAGE_CARGOCLASS	1999

enum WareTypes {

	Ware_BuiltIn,

	Ware_EMP,

	Ware_Custom

};

tstruct SWareEntry {

	Utils::String name;

	Utils::String description;

	enum WareTypes type;

	Utils::String id;

	int			  relval;

	int			  notority;

	int			  position;

} SWareEntry;

// spk header struct

tstruct SSPKHeader {

	SSPKHeader () { fVersion = 0; iValueCompression = lValueCompressSize = 0; }

	float fVersion;

	int iValueCompression;

	unsigned long lValueCompressSize;

} SSPKHeader;

tstruct SNeededLibrary {

	Utils::String	sName;

	Utils::String	sAuthor;

	Utils::String	sMinVersion;

} SNeededLibrary;

tstruct SGameCompat {

	int			iGame;

	Utils::String	sVersion;

	int			iVersion;

} SGameCompat;

tstruct SSPKHeader2 {

	SSPKHeader2 () { iNumFiles = 0; lSize = 0; lFullSize = 0; }

	int iNumFiles;

	long lSize;

	long lFullSize;

	int iFileCompression;

	int iDataCompression;

} SSPKHeader2;

typedef struct SNames {

	int iLanguage;

	Utils::String sName;

} SNames;

class SPKEXPORT CBaseFile : public SPK::Package::CCorePackage

{

public:

	static Utils::String ConvertGameToString(int game);

	static int GetGameFromString(const Utils::String &game);

	static CyString ErrorString(int error, CyString errorStr = NullString);

	CBaseFile();

	virtual ~CBaseFile();

	// Get basic Settings

	virtual CyString GetFullPackageName(int language, CyString byString) { return GetFullPackageName(language, true, byString); }

	virtual CyString GetFullPackageName(int language, bool includeVersion = true, CyString byString = "by") 

	{ 

		CyString p;

		if ( language == -1 )

			p = this->name();

		else

			p = GetLanguageName(language);

		if ( includeVersion )

		{

			p += " V";

			p += this->version();

		}

		p += " ";

		p += byString + " " + this->author();

		return p;

	}

	CLinkList<C_File> *GetFileList() { return &m_lFiles; }

	C_File *GetIcon () { return m_pIconFile; }

	CyString GetIconExt () { return m_sIconExt; }

	CyString GetNameValidFile ();

	int GetDataCompression () { return m_SHeader2.iDataCompression; }

	float GetFileVersion () { return m_SHeader.fVersion; }

	long GetFullFileSize ();

	CyString GetLanguageName ( int lang );

	virtual CyString GetFullPackageName(CyString format, int lang);

	Utils::String GetAutosaveName();

	void SetAutosaveName() { this->setFilename(GetAutosaveName()); }

	SGameCompat *GetGameCompatability(int game);

	bool RemoveGameCompatability(int game);

	void AddGameCompatability(int game, const Utils::String &version);

	bool CheckGameCompatability(int game);

	bool CheckGameVersionCompatability(int game, CyString sVersion, int iVersion);

	bool AnyGameCompatability() { return !m_lGames.empty(); }

	bool AnyWebMirrors() { return !m_lMirrors.Empty(); }

	CyStringList *GetWebMirrors() { return &m_lMirrors; }

	int GetMaxWebMirrors() { return m_lMirrors.Count(); }

	CyString GetWebMirror(int i) { if ( i >= 0 && i < m_lMirrors.Count() ) return m_lMirrors.StringAt(i); return NullString; }

	void ClearWebMirrors() { m_lMirrors.Clear(); }

	CLinkList<C_File> *fileList(int type) const;

	C_File *GetFirstFile(int type) const;

	C_File *GetNextFile(C_File *prev) const;

	C_File *GetPrevFile(C_File *next) const;

	virtual Utils::String CreateValuesLine () const;

	virtual bool LoadPackageData(const Utils::String &sFfirst, const Utils::String &sRest);

	virtual bool GeneratePackagerScript(bool wildcard, CyStringList *list, bool datafile = false);

	virtual bool GeneratePackagerScriptFile(bool wildcard, CyStringList *list);

	void ConvertNormalMod(C_File *f, CyString to);

	void ConvertFakePatch(C_File *f);

	void ConvertAutoText(C_File *f);

	C_File *FindMatchingMod(C_File *f);

	void RenameFile(C_File *f, CyString baseName);

	// set basic settings

	void AddWebMirror		( CyString str ) { m_lMirrors.PushBack(str, "", true); _changed(); }

	void RemoveWebMirror	( CyString str ) { m_lMirrors.Remove(str, true); _changed(); }

	void SetDataCompression ( int c )       { m_SHeader2.iDataCompression = c; }

	void SetFileCompression ( int c )       { m_SHeader2.iFileCompression = c; }

	void SetValueCompression( int c )       { m_SHeader.iValueCompression = c; }

	void SetIcon ( C_File *file, CyString ext ) { if ( m_pIconFile ) delete m_pIconFile; m_sIconExt = ext; m_pIconFile = file; _changed(); }

	void SetFtpAddr			( CyString str ) { m_sFtpAddr = str; }

	void AddFileScript(int filetype, bool shared, CyString rest);

	bool IsMod();

	bool IsFakePatch() const;

	// error handling

	void ClearError () { m_sLastError = ""; m_iLastError = SPKERR_NONE; }

	int GetLastError () { return m_iLastError; }

	CyString GetLastErrorString() { return m_sLastError; }

	// file handling

	void AddFile ( C_File *file );

	C_File *AddFile ( CyString, CyString, int type, int game = 0 );

	C_File *AppendFile ( CyString file, int type, int game, CyString dir = NullString, CProgressInfo *progress = NULL );

	C_File *FindFile ( CyString, int, CyString = NullString, int game = 0 );

	bool AddFileNow ( CyString, CyString, int type, CProgressInfo *progress = NULL );

	int CountFiles ( int filetype );

	C_File *FindFileAt ( int filetype, int pos );

	virtual bool RemoveFile ( int pos );

	virtual bool RemoveFile ( C_File *files );

	virtual bool RemoveFile ( CyString file, int type, CyString dir = NullString, int game = 0 );

	void RemoveAllFiles ( int type, int game );

	CyString CreateFilesLine ( bool updateheader, CProgressInfo * = NULL );

	virtual bool WriteHeader(CFileIO &file, int iHeader, int iLength);

	virtual bool WriteData(CFileIO &file, CProgressInfo * = NULL );

	virtual bool WriteFile ( CyString filename, CProgressInfo * = NULL );

	virtual bool ReadFile ( CyString filename, int readType = SPKREAD_ALL, CProgressInfo *progress = NULL );

	bool readFile(CFileIO &File, int readtype, CProgressInfo *progress);

	virtual bool ExtractFile ( C_File *file, CyString dir, bool includedir = true, CProgressInfo *progress = NULL );

	virtual bool ExtractFile ( int file, CyString dir, bool includedir = true, CProgressInfo *progress = NULL );

	virtual bool ExtractAll ( CyString dir, int game, bool includedir = true, CProgressInfo *progress = NULL );

	virtual bool SaveToArchive(CyString filename, int game, CProgressInfo *progress = NULL);

	void ClearFileData();

	CLinkList<SNames> *GetNamesList() { return &m_lNames; }

	// reading files

	void ReadAllFilesToMemory ();

	void ReadIconFileToMemory ();

	bool ReadFileToMemory(C_File *f);

	// compression

	void RecompressAllFiles ( int compresstype, CProgressInfo *progress );

	void CompressAllFiles ( int compresstype, CProgressInfo *progress = NULL, CProgressInfo *overallProgress = NULL, int level = DEFAULT_COMPRESSION_LEVEL );

	bool UncompressAllFiles ( CProgressInfo * = NULL );

	// static functions

	static Utils::String readEndOfLine(std::fstream &stream, int *line = NULL, bool upper = true);

	static CyString GetEndOfLine ( FILE *id, int *line = NULL, bool upper = true );

	static int CheckFile ( CyString filename, float *version = NULL );

	bool IsFileAdded(C_File *f) { return m_lFiles.FindData(f); }

	// installing

	void SwitchFilePointer(C_File *oldFile, C_File *newFile);

	bool InstallFiles ( CyString destdir, CProgressInfo *progress, CLinkList<C_File> *spklist, CyStringList *errorStr, bool enabled = true, CPackages *packages = NULL );

	virtual bool IsPatch () { return false; }

	// installer functions

	bool IsProfileEnabled () { return m_bProfile; }

	bool IsEnabled () { return m_bEnable; }

	bool IsModifiedEnabled () { return m_bModifiedEnabled; }

	bool IsGlobalEnabled () { return m_bGlobal; }

	void SetProfileEnabled ( bool en ) { m_bProfile = en; }

	void SetEnabled ( bool en ) { m_bEnable = en; }

	void SetModifiedEnabled ( bool en ) { m_bModifiedEnabled = en; }

	void SetGlobalEnabled ( bool en ) { m_bGlobal = en; }

	int  GetLoadError() { return m_iLoadError; }

	void SetLoadError(int i) { m_iLoadError = i; }

	CyString CreateUpdateFile(CyString dir);

	// language functions

	void RemoveLanguageName ( int lang );

	void AddLanguageName ( int lang, const Utils::String &name );

	void ClearNames ();

	virtual bool ParseValueLine(const Utils::String &line);

	CLinkList<SGameCompat>  *GetGameCompatabilityList() { return &m_lGames; }

	CyString GetFullFileSizeString();

	CLinkList<SNeededLibrary> *GetNeededLibraries() { return &m_lNeededLibrarys; }

	void AddNeededLibrary(const Utils::String &scriptName, const Utils::String &author, const Utils::String &minVersion);

	bool IsPackageNeeded(const Utils::String &scriptName, const Utils::String &author);

	SNeededLibrary *FindPackageNeeded(const Utils::String &scriptName, const Utils::String &author);

	void RemovePackageNeeded(const Utils::String &scriptName, const Utils::String &author);

	void ClearNeededPackages();

	bool AnyDependacies() { return (m_lNeededLibrarys.size()) ? true: false; }

	bool AutoGenerateUpdateFile() { return m_bAutoGenerateUpdateFile; }

	void RemoveFakePatchOrder(bool after, CyString scriptName, CyString author);

	void RemoveFakePatchOrder(CyString scriptName, CyString author);

	void AddFakePatchOrder(bool after, CyString scriptName, CyString author);

	bool AnyFakePatchOrder() { if ( !m_lFakePatchBefore.Empty() || !m_lFakePatchAfter.Empty() ) return true; return false; }

	CyStringList &GetFakePatchBeforeOrder() { return m_lFakePatchBefore; }

	CyStringList &GetFakePatchAfterOrder() { return m_lFakePatchAfter; }

	void updateTextDB() { this->_resetTextDB(); }

	virtual bool readWares(int iLang, CLinkList<SWareEntry> &list, const Utils::String &empWares);

//	bool IsChanged() { return m_bChanged; }

//	void SetChanged(bool b) { m_bChanged = b; }

	int  FindFirstGameInPackage();

	bool IsAnyGameInPackage();

	bool IsMultipleGamesInPackage();

	bool IsGameInPackage(int game);

	virtual int GetType () { return TYPE_BASE; }

	bool AnyFileType ( int type );

	CBaseFile *GetParent () { return m_pParent; }

	void SetParent ( CBaseFile *file ) { m_pParent = file; }

	int ParseLanguage(const Utils::String &lang) const;

	virtual bool UpdateSigned (bool updateFiles);

	int GetNum() { return m_iNum; }

	void SetNum(int i) { m_iNum = i; }

	bool	IsFullyLoaded() { return m_bFullyLoaded; }

	virtual bool   IsSigned ()		{ return m_bSigned;}

	void SetOverrideFiles(bool b) { m_bOverrideFiles = b; }

	bool IsUpdateChecked () { return m_bUpdate; }

	void SetUpdateChecked ( bool en ) { m_bUpdate = en; }

	unsigned char *CreateData(size_t *size, CProgressInfo *progress = NULL);

protected:

	virtual void Delete ();

	virtual void SetDefaults ();

	// reading of files

	virtual bool CheckHeader(const Utils::String header) const;

	virtual bool ParseHeader ( CyString header );

	virtual bool ParseFileHeader ( CyString header );

	virtual bool ParseFilesLine ( CyString line );

	virtual void ReadValues ( CyString values );

	virtual void ReadFiles ( CyString values );

	void _install_adjustFakePatches(CPackages *pPackages);

	void _install_renameText(CPackages *pPackages);

	bool _install_uncompress(C_File *fit, CProgressInfo *progress, CyStringList *errorStr, bool *uncomprToFile);

	bool _install_setEnabled(bool bEnable, C_File *fit);

	bool _install_checkVersion(C_File *pFile, const Utils::String &sDestination);

	Utils::String _install_adjustFilepointer(C_File *pFile, bool bEnabled, const Utils::String &sDestination);

	C_File *_install_checkFile(C_File *pFile, CyStringList *errorStr, bool *bDoFile, CLinkList<C_File> *pFileList);

	bool _install_checkFileEnable(C_File *pCheckFile, C_File *fit, const Utils::String &sDestination, bool bEnabled, CyStringList *errorStr);

	bool _install_createDirectory(CDirIO &Dir, const Utils::String &sTo, C_File *pFile, CyStringList *errorStr);

	void _install_writeFile(C_File *pFile, const Utils::String &sDestination, CyStringList *errorStr);

	int _read_FileHeader(std::fstream &stream, int iReadType, int iMaxProgress, int iDoneLen, CProgressInfo *pProgress);

	int _read_Header(std::fstream &stream, int iReadType, int iMaxProgress, CProgressInfo *pProgress);

	CFileIO *_startRead();

	void _addFile(C_File *file, bool dontChange = false);

	void _updateTextDB(C_File *file);

	void _resetTextDB();

	void _addWaresToList(int iLang, CLinkList<SWareEntry> &list, const Utils::String &wares, enum WareTypes eType);

protected:

	SSPKHeader m_SHeader;

	SSPKHeader2 m_SHeader2;

	C_File *m_pIconFile;

	CyString m_sIconExt;

	CyString m_sLastError;

	int m_iLastError;

	CLinkList<C_File>  m_lFiles;

	CLinkList<SNames> m_lNames;			//TODO: move to CorePackage

	CyStringList m_lMirrors;			//TODO: move to CorePackage

	CyStringList m_lFakePatchBefore;

	CyStringList m_lFakePatchAfter;

	CTextDB	*_pTextDB;

	CLinkList<SGameCompat> m_lGames;

	bool m_bSigned;

	bool m_bFullyLoaded;

	//installer varibles

	bool m_bEnable;

	bool m_bModifiedEnabled;

	bool m_bGlobal;

	bool m_bProfile;

	int m_iLoadError;

	CBaseFile *m_pParent;

	int m_iNum;

	CLinkList<SNeededLibrary> m_lNeededLibrarys;

	bool	m_bOverrideFiles;

	CyString	m_sFtpAddr;

	bool	m_bAutoGenerateUpdateFile;

	bool m_bUpdate;

};

class SPKEXPORT CArchiveFile : public CBaseFile

{

public:

	CArchiveFile();

	virtual ~CArchiveFile();

	virtual CyString GetFullPackageName(CyString format, int lang) { return CyString("Archive(") + this->name() + ")"; }

	virtual CyString GetFullPackageName(int language, CyString byString) { return CyString("Archive(") + this->name() + ")"; }

	virtual CyString GetFullPackageName(int language, bool includeVersion = true, CyString byString = "by") { return CyString("Archive(") + this->name() + ")"; }

	virtual int GetType () { return TYPE_ARCHIVE; }

};

#endif //__BASEFILE_H__