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 "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;

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


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

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

        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;

        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__