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 "File.h"

#include "Utils/String.h"

#include "Utils/StringList.h"

#include "archive/zip.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_X3FL			5

#define GAME_MAX			(GAME_X3FL)

#define GAME_ALLNEW			(1 << 31)

#define FILEVERSION 4.30f

#define WRITECHUNK		50000

class CPackages;

class CGameExe;

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 BaseFileType {TYPE_BASE, TYPE_SPK, TYPE_XSP, TYPE_ARCHIVE};

// spk header struct

tstruct SSPKHeader {

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

	float fVersion;

	int iValueCompression;

	unsigned long lValueCompressSize;

} SSPKHeader;

tstruct SSPKHeader2 {

	SSPKHeader2 () : iFileCompression(0), iDataCompression(0), iNumFiles(0), lSize(0), lFullSize(0) { }

	int iNumFiles;

	long lSize;

	long lFullSize;

	int iFileCompression;

	int iDataCompression;

} SSPKHeader2;

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

{

public:

	// static functions

	static Utils::WString ConvertGameToString(int game);

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

	static Utils::WString ErrorString(int error, const Utils::WString &errorStr = Utils::WString::Null());

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

	static int CheckFile(const Utils::WString &filename, float* version = NULL);

	CBaseFile();

	virtual ~CBaseFile();

	// Virtual Functions

	virtual Utils::WString getFullPackageName(int language, const Utils::WString &byString) const;

	virtual Utils::WString getFullPackageName(int language, bool includeVersion = true, const Utils::WString &byString = L"by") const;

	virtual Utils::WString getFullPackageName(const Utils::WString &format, int lang) const;

	virtual Utils::String createValuesLine() const;

	virtual bool loadPackageData(const Utils::WString& sFirst, const Utils::WString& sRest, const Utils::WString& sMainGame, Utils::WStringList& otherGames, Utils::WStringList& gameAddons, CProgressInfo* progress);

	virtual bool GeneratePackagerScript(bool wildcard, Utils::CStringList* list, int game, const Utils::CStringList& gameAddons, bool datafile = false);

	virtual bool GeneratePackagerScriptFile(bool wildcard, Utils::CStringList* list, int game, const Utils::CStringList& gameAddons);

	// Getters

	Utils::WString getNameValidFile() const;

	const CLinkList<C_File> &fileList() const;

	CLinkList<C_File>& fileList(FileType type, CLinkList<C_File> &list) const;

	CLinkList<C_File>& fileList(FileType type);

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

	C_File *icon() const { return m_pIconFile; }

	const Utils::WString &iconExt() const { return _sIconExt; }

	int dataCompression () const { return m_SHeader2.iDataCompression; }

	float fileVersion () const { return m_SHeader.fVersion; }

	size_t fileSize() const;

	//const Utils::String& getLanguageName(int lang) const { return name(lang); }

	Utils::WString getAutosaveName() const;

	bool IsMod();

	bool IsFakePatch() const;

	// Setters

	void setAutosaveName() { this->setFilename(getAutosaveName()); }

	void addWebMirror(const Utils::String& str);

	void removeWebMirror(const Utils::String& str);

	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, const Utils::String& ext) { if (m_pIconFile) delete m_pIconFile; _sIconExt = ext.c_str(); m_pIconFile = file; _changed(); }

	void setFtpAddr(const Utils::String& str) { _sFtpAddr = str; }

	// Game Compatability

	SGameCompat* GetGameCompatability(int game);

	bool RemoveGameCompatability(int game);

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

	bool CheckGameCompatability(int game);

	bool checkGameVersionCompatability(int game, const Utils::WString &sVersion, int iVersion) const;

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

	// Web Mirrors

	bool anyWebMirrors() { return !_lMirrors.empty(); }

	const Utils::CStringList &webMirrors() const { return _lMirrors; }

	int getMaxWebMirrors() { return _lMirrors.size(); }

	Utils::String getWebMirror(size_t i) { if ( i >= 0 && i < _lMirrors.size() ) return _lMirrors.get(i)->str; return Utils::String::Null(); }

	void clearWebMirrors() { _lMirrors.clear(); }

	// Files

	C_File *GetFirstFile(int type) const;

	C_File *GetNextFile(C_File *prev) const;

	C_File *GetPrevFile(C_File *next) const;

	C_File* findMatchingMod(C_File* f) const;

	void convertNormalMod(C_File *f, const Utils::String &to) const;

	void convertFakePatch(C_File *f) const;

	void convertAutoText(C_File *f) const;

	void renameFile(C_File *f, const Utils::String &baseName) const;

	size_t countFiles(FileType filetype) const;

	C_File* findFileAt(FileType filetype, size_t pos) const;

	C_File* findFile(const Utils::WString& file, FileType type, const Utils::WString& dir = Utils::WString::Null(), int game = 0) const;

	void addFileScript(FileType filetype, bool shared, bool packed, const Utils::WString &rest, const Utils::WString &sMainGame, Utils::WStringList &otherGames, Utils::WStringList &gameAddons, CProgressInfo *progress = NULL);

	void AddFile(C_File* file);

	C_File* addFile(const Utils::WString& file, const Utils::WString& dir, FileType type, int game = 0, bool packed = false);

	C_File* appendFile(const Utils::WString& file, int type, int game, bool packed, const Utils::WString& dir = Utils::WString::Null(), CProgressInfo* progress = NULL);

	bool addFileNow(const Utils::String&, const Utils::String&, FileType type, CProgressInfo* progress = NULL);

	bool removeFile(size_t pos);

	bool removeFile(C_File* files);

	bool removeFile(const Utils::String &file, FileType type, const Utils::String &dir = Utils::String::Null(), int game = 0);

	void removeAllFiles(FileType type, int game);

	Utils::String createFilesLine(SSPKHeader2 *header, CProgressInfo* = NULL) const;

	// error handling

	void ClearError () { _sLastError = ""; _iLastError = SPKERR_NONE; }

	int lastError() const { return _iLastError; }

	const Utils::WString lastErrorString() const { return _sLastError; }

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

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

	virtual bool writeFile(const Utils::String &filename, CProgressInfo* = NULL) const;

	virtual bool readFile(const Utils::String &filename, int readType = SPKREAD_ALL, CProgressInfo *progress = NULL);

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

	virtual bool extractFile(int file, const Utils::String &dir, bool includedir = true, CProgressInfo *progress = NULL);

	virtual bool extractFile(C_File *file, const Utils::String &dir, bool includedir = true, CProgressInfo *progress = NULL);

	virtual bool extractFile(int filenum, const Utils::String &dir, unsigned int game, const Utils::WStringList &gameAddons, bool includedir = true, CProgressInfo *progress = NULL);

	virtual bool extractFile(C_File *file, const Utils::String &dir, unsigned int game, const Utils::WStringList &gameAddons, bool includedir = true, CProgressInfo *progress = NULL);

	virtual bool extractAll(const Utils::String &dir, int game, const Utils::CStringList &gameAddons, bool includedir = true, CProgressInfo *progress = NULL);

	virtual bool saveToArchive(const Utils::String &filename, int game, const CGameExe *exes, CProgressInfo *progress = NULL);

	virtual void addGeneratedFiles(HZIP &hz) {};

	void ClearFileData();

	// 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 );

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

	// installing

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

	bool installFiles(const Utils::WString &destdir, CProgressInfo *progress, CLinkList<C_File> *spklist, Utils::WStringList *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; }

	Utils::WString createUpdateFile(const Utils::WString &dir) const;

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

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

	Utils::WString fileSizeString() const;

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

	void addNeededLibrary(const Utils::WString &scriptName, const Utils::WString &author, const Utils::WString &minVersion);

	bool isPackageNeeded(const Utils::WString &scriptName, const Utils::WString &author);

	SNeededLibrary *findPackageNeeded(const Utils::WString &scriptName, const Utils::WString &author);

	void removePackageNeeded(const Utils::WString &scriptName, const Utils::WString &author);

	void ClearNeededPackages();

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

	bool AutoGenerateUpdateFile() { return m_bAutoGenerateUpdateFile; }

	void removeFakePatchOrder(bool after, const Utils::String &scriptName, const Utils::String &author);

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

	void addFakePatchOrder(bool after, const Utils::String &scriptName, const Utils::String &author);

	bool anyFakePatchOrder() const { if ( !_lFakePatchBefore.empty() || !_lFakePatchAfter.empty() ) return true; return false; }

	const Utils::CStringList &getFakePatchBeforeOrder() const { return _lFakePatchBefore; }

	const Utils::CStringList &getFakePatchAfterOrder() const { return _lFakePatchAfter; }

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

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

	virtual bool readCommands(int iLang, CLinkList<SCommandSlot> &list);

	virtual bool readWingCommands(int iLang, CLinkList<SCommandSlot> &list);

	int  FindFirstGameInPackage();

	bool IsAnyGameInPackage();

	bool IsMultipleGamesInPackage();

	bool IsGameInPackage(int game);

	virtual BaseFileType type () const { return BaseFileType::TYPE_BASE; }

	virtual int GetType() { return type(); }

	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 computeSigned(bool updateFiles) const;

	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;

	bool _parseHeader(const Utils::String &header);

	bool _parseFileHeader(const Utils::String& header);

	bool _parseFilesLine(const Utils::String& line);

	void _readValues(const Utils::String& values);

	void _readFiles(const Utils::String& values);

	void _install_adjustFakePatches(CPackages *pPackages);

	void _install_renameText(CPackages *pPackages);

	bool _install_uncompress(C_File *fit, CProgressInfo *progress, Utils::WStringList *errorStr, bool *uncomprToFile);

	bool _install_setEnabled(bool bEnable, C_File *fit);

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

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

	C_File *_install_checkFile(C_File *pFile, Utils::WStringList *errorStr, bool *bDoFile, CLinkList<C_File> *pFileList);

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

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

	void _install_writeFile(C_File *pFile, const Utils::WString &sDestination, Utils::WStringList *errorStr);

	int _read_FileHeader(CFileIO &File, int iReadType, int iMaxProgress, int iDoneLen, CProgressInfo *pProgress);

	int _read_Header(CFileIO &File, 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::WString &wares, enum WareTypes eType);

	bool _readCommands(int iLang, int iStartID, CLinkList<SCommandSlot> &list);

	Utils::WString _replaceFilename(const Utils::WString &fname);

protected:

	SSPKHeader m_SHeader;

	SSPKHeader2 m_SHeader2;

	C_File *m_pIconFile;

	Utils::WString _sIconExt;

	Utils::WString _sLastError;

	int _iLastError;

	CLinkList<C_File>  m_lFiles;

	CLinkList<C_File>  m_lTempFiles;

	Utils::CStringList _lMirrors;			//TODO: move to CorePackage

	Utils::CStringList _lFakePatchBefore;

	Utils::CStringList _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	_bCombineFiles;

	bool	m_bOverrideFiles;

	Utils::String	_sFtpAddr;

	bool			m_bAutoGenerateUpdateFile;

	bool			m_bUpdate;

};

class SPKEXPORT CArchiveFile : public CBaseFile

{

public:

	CArchiveFile();

	virtual ~CArchiveFile();

	virtual Utils::WString getFullPackageName(const Utils::WString& format, int lang) const override { return L"Archive(" + name() + L")"; }

	virtual Utils::WString getFullPackageName(int language, const Utils::WString& byString) const override { return L"Archive(" + name() + L")"; }

	virtual Utils::WString getFullPackageName(int language, bool includeVersion = true, const Utils::WString& byString = L"by") const override { return L"Archive(" + name() + L")"; }

	virtual BaseFileType type() const override { return BaseFileType::TYPE_ARCHIVE; }

};

#endif //__BASEFILE_H__