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"

#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 {PLUGIN_NORMAL, PLUGIN_STABLE, PLUGIN_EXPERIMENTAL, PLUGIN_CHEAT, PLUGIN_MOD}; // filters for browsing packages

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 {
        CyString        sName;
        CyString        sAuthor;
        CyString        sMinVersion;
} SNeededLibrary;

tstruct SGameCompat {
        int                     iGame;
        CyString        sVersion;
        int                     iVersion;
} SGameCompat;

tstruct SSPKHeader2 {
        SSPKHeader2 () { iNumFiles = 0; lSize = 0; lFullSize = 0; }
        int iNumFiles;
        long lSize;
        long lFullSize;
        int iFileCompression;
        int iDataCompression;
} SSPKHeader2;

tstruct SInstallText {
        int             iLanguage;
        CyString        sBefore;
        CyString        sAfter;
} SInstallText;

typedef struct SNames {
        int iLanguage;
        CyString sName;
} SNames;


class SPKEXPORT CBaseFile 
{
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
        CyString GetName ()                     { return m_sName; }
        CyString GetVersion ()          { return m_sVersion; }
        CyString GetAuthor ()           { return m_sAuthor; }
        CyString GetWebSite ()          { return m_sWebSite; }
        CyString GetWebAddress ()       { return m_sWebAddress; }
        CyString GetEmail ()            { return m_sEmail; }
        CyString GetCreationDate ()     { return m_sCreationDate; }
        CyString GetDescription ()      { return m_sDescription; }
        CyString GetForumLink ()        { return m_sForumLink; }
        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 = m_sName;
                else
                        p = GetLanguageName(language);
                if ( includeVersion )
                {
                        p += " V";
                        p += m_sVersion;
                }
                p += " ";
                p += byString + " " + m_sAuthor;
                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);
        CyString GetAutosaveName();
        void SetAutosaveName() { m_sFilename = GetAutosaveName(); }
        SGameCompat *GetGameCompatability(int game);
        bool RemoveGameCompatability(int game);
        void AddGameCompatability(int game, CyString 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> *GetFileList(int type);
        C_File *GetFirstFile(int type) const;
        C_File *GetNextFile(C_File *prev) const;
        C_File *GetPrevFile(C_File *next) const;

        int GetRecommended() { return m_iRecommended; }
        int GetEaseOfUse() { return m_iEaseOfUse; }
        int GetGameChanging() { return m_iGameChanging; }

        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 SetName                    ( CyString str ) { m_sName = str.Remove ( '|' ); m_bChanged = true; }
        void SetVersion                 ( CyString str ) { m_sVersion = str; m_bChanged = true; }
        void SetAuthor                  ( CyString str ) { m_sAuthor = str.Remove ( '|' ); m_bChanged = true; }
        void SetWebAddress              ( CyString str ) { m_sWebAddress = str; m_bChanged = true; }
        void SetWebSite                 ( CyString str ) { m_sWebSite = str; m_bChanged = true; }
        void SetEmail                   ( CyString str ) { m_sEmail = str; m_bChanged = true; }
        void SetCreationDate    ( CyString str ) { m_sCreationDate = str; m_bChanged = true; }
        void AddWebMirror               ( CyString str ) { m_lMirrors.PushBack(str, "", true); m_bChanged = true; }
        void RemoveWebMirror    ( CyString str ) { m_lMirrors.Remove(str, true); m_bChanged = true; }
        void SetDescription             ( CyString str ) { m_sDescription = str; m_bChanged = true; }
        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 SetForumLink               ( CyString str ) { m_sForumLink = str; m_bChanged = true; }
        void SetIcon ( C_File *file, CyString ext ) { if ( m_pIconFile ) delete m_pIconFile; m_sIconExt = ext; m_pIconFile = file; m_bChanged = true; }
        void SetFtpAddr                 ( CyString str ) { m_sFtpAddr = str; }

        void AddFileScript(int filetype, bool shared, CyString rest);
        void SetFilename ( CyString str ) { m_sFilename = str; }
        CyString GetFilename() { return m_sFilename; }
        CyString GetExportFilename() { return m_sExportFilename; }

        void SetRecommended ( int i ) { m_iRecommended = i; m_bChanged = true; }
        void SetGameChanging ( int i ) { m_iGameChanging = i; m_bChanged = true; }
        void SetEaseOfUse ( int i ) { m_iEaseOfUse = i; m_bChanged = true; }

        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 ( FILE *id, int, int );
        virtual bool WriteData ( FILE *id, CProgressInfo * = NULL );
        virtual bool WriteFile ( CyString filename, CProgressInfo * = NULL );
        virtual bool ReadFile ( CyString filename, int readType = SPKREAD_ALL, CProgressInfo *progress = NULL );
        virtual bool ReadFile ( FILE *id, 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, int level = DEFAULT_COMPRESSION_LEVEL );
        bool UncompressAllFiles ( CProgressInfo * = NULL );

        // static functions
        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, CyString name );
        void ClearNames ();

        virtual bool ParseValueLine(const Utils::String &line);
        int     ParseInstallText(CyString lang);

        CLinkList<SInstallText> *GetInstallTextList() { return &m_lInstallText; }
        CLinkList<SInstallText> *GetUninstallTextList() { return &m_lUninstallText; }
        CLinkList<SGameCompat>  *GetGameCompatabilityList() { return &m_lGames; }
        CyString GetInstallAfterText ( int lang, bool noDefault = false ) { return GetAfterText ( &m_lInstallText, lang, noDefault ); }
        CyString GetInstallBeforeText ( int lang, bool noDefault = false ) { return GetBeforeText ( &m_lInstallText, lang, noDefault ); }
        CyString GetUninstallAfterText ( int lang, bool noDefault = false ) { return GetAfterText ( &m_lUninstallText, lang, noDefault ); }
        CyString GetUninstallBeforeText ( int lang, bool noDefault = false ) { return GetBeforeText ( &m_lUninstallText, lang, noDefault ); }

        SInstallText *AddInstallBeforeText ( int lang, CyString data ) { return AddInstallText ( true, true, lang, data ); }
        SInstallText *AddInstallAfterText ( int lang, CyString data ) { return AddInstallText ( false, true, lang, data ); }
        SInstallText *AddUninstallBeforeText ( int lang, CyString data ) { return AddInstallText ( true, false, lang, data ); }
        SInstallText *AddUninstallAfterText ( int lang, CyString data ) { return AddInstallText ( false, false, lang, data ); }
        SInstallText *FindInstallText ( int lang ) { return FindInstallText ( true, lang ); }
        SInstallText *FindUninstallText ( int lang ) { return FindInstallText ( false, lang ); }
        void AddInstallText ( SInstallText * );
        void AddUninstallText ( SInstallText * );
        void RemoveInstallText ( int lang ) { RemoveInstallText ( true, lang ); }
        void RemoveUninstallText ( int lang  ) { RemoveInstallText ( false, lang ); }
        bool IsThereInstallText () { return IsThereInstallText ( true ); }
        bool IsThereUninstallText () { return IsThereInstallText ( false ); }

        CyString GetFullFileSizeString();

        CLinkList<SNeededLibrary> *GetNeededLibraries() { return &m_lNeededLibrarys; }
        void AddNeededLibrary(CyString scriptName, CyString author, CyString minVersion);
        bool IsPackageNeeded(CyString scriptName, CyString author);
        SNeededLibrary *FindPackageNeeded(CyString scriptName, CyString author);
        void RemovePackageNeeded(CyString scriptName, CyString 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; }
        int             GetPluginType() { return m_iPluginType; }
        void    SetPluginType(int i) { m_iPluginType = i; m_bChanged = true; }

        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(CyString lang);

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

        SInstallText *AddInstallText ( bool before, bool install, int lang, CyString data );
        SInstallText *FindInstallText ( bool install, int lang );
        void RemoveInstallText ( bool install, int lang );
        bool IsThereInstallText ( bool );

        CyString GetAfterText ( CLinkList<SInstallText> *list, int lang, bool noDefault = false );
        CyString GetBeforeText ( CLinkList<SInstallText> *list, int lang, bool noDefault = false );

        void _install_adjustFakePatches(CPackages *pPackages);

        int m_iType;
        SSPKHeader m_SHeader;
        SSPKHeader2 m_SHeader2;

        CyString m_sName;
        CyString m_sVersion;
        CyString m_sAuthor;
        CyString m_sWebSite;
        CyString m_sWebAddress;
        CyString m_sEmail;
        CyString m_sDescription;
        CyString m_sCreationDate;
        CyString m_sForumLink;

        C_File *m_pIconFile;
        CyString m_sIconExt;
        CyString m_sLastError;
        int m_iLastError;

        CyString m_sFilename;
        CyString m_sExportFilename;

        CLinkList<C_File>  m_lFiles;
        CLinkList<SNames> m_lNames;
        CLinkList<SInstallText> m_lInstallText;
        CLinkList<SInstallText> m_lUninstallText;
        CyStringList m_lMirrors;
        CyStringList m_lFakePatchBefore;
        CyStringList m_lFakePatchAfter;

        int m_iPluginType;
        CLinkList<SGameCompat> m_lGames;

        // package stats
        int m_iRecommended;
        int m_iEaseOfUse;
        int m_iGameChanging;

        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;
        bool    m_bChanged;

        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(") + m_sName + ")"; }
        virtual CyString GetFullPackageName(int language, CyString byString) { return CyString("Archive(") + m_sName + ")"; }
        virtual CyString GetFullPackageName(int language, bool includeVersion = true, CyString byString = "by") { return CyString("Archive(") + m_sName + ")"; }
        virtual int GetType () { return TYPE_ARCHIVE; }
};

#endif //__BASEFILE_H__