Subversion Repositories spk

Rev

Rev 6 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

// SpkFile.h: interface for the CSpkFile class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_SPKFILE_H__E35FA619_B901_479F_BE42_2FF1519BA4D3__INCLUDED_)
#define AFX_SPKFILE_H__E35FA619_B901_479F_BE42_2FF1519BA4D3__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "lists.h"
#include "StringList.h"
#include "File.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 LIBRARYVERSION 1.84f
#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 {SETTING_INTEGER, SETTING_STRING, SETTING_CHECK};
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 {SCRIPTTYPE_CUSTOM, SCRIPTTYPE_OTHER, SCRIPTTYPE_NAVIGATION, SCRIPTTYPE_COMBAT, SCRIPTTYPE_MISSION, SCRIPTTYPE_ALPLUGIN, SCRIPTTYPE_HOTKEY, SCRIPTTYPE_SHIPUPGRADE, SCRIPTTYPE_SHIPCOMMAND, SCRIPTTYPE_STATIONCOMMAND,
                SCRIPTTYPE_FLEET, SCRIPTTYPE_TRADE, SCRIPTTYPE_PIRACY, SCRIPTTYPE_CHEAT, SCRIPTTYPE_EXTENSION, SCRIPTTYPE_REBALANCE, SCRIPTTYPE_FIX, SCRIPTTYPE_GENERALMOD, SCRIPTTYPE_TOTAL, SCRIPTTYPE_WINGCOMMAND, SCRIPTTYPE_MAX};

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 SSettingType {
        CyString        sKey;
        int             iType;
} SSettingType;

tstruct SNeededLibrary {
        CyString        sName;
        CyString        sAuthor;
        CyString        sMinVersion;
} SNeededLibrary;

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

typedef struct SSettingString : public SSettingType {
        SSettingString () { iType = SETTING_STRING; }
        CyString sValue;
} SSettingString;

typedef struct SSettingInteger : public SSettingType {
        SSettingInteger () { iType = SETTING_INTEGER; }
        int iValue;
} SSettingInteger;

typedef struct SSettingCheck : public SSettingType {
        SSettingCheck () { iType = SETTING_CHECK; }
        bool bValue ;
} SSettingCheck;

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 SWaresText {
        int             iLang;
        CyString  sName;
        CyString  sDesc;
} SWaresText;

typedef struct SWares {
        CyString  sID;
        char    cType;
        long    iPrice;
        int             iSize;
        int             iVolumn;
        int             iNotority;
        bool    bEnabled;
        int             iPosID;
        int             iDescID;
        int             iTextID;
        int             iTextPage;
        CLinkList<SWaresText> lText;
        int             iUsed;
} SWares;

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


class SPKEXPORT CBaseFile 
{
public:
        static CyString ConvertGameToString(int game);
        static int GetGameFromString(CyString 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);
        C_File *GetNextFile(C_File *prev);
        C_File *GetPrevFile(C_File *next);

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

        virtual CyString CreateValuesLine ();

        virtual bool LoadPackageData(CyString first, CyString rest);
        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();

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

        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 CSpkFile : public CBaseFile
{
public:
        static int ConvertScriptType(CyString sType);
        static CyString GetScriptTypeStringStatic(int type);
        static CyString GetWareText(SWares *w, int lang);
        static CyString GetWareDesc(SWares *w, int lang);

        // get functions
        CyString GetScriptTypeString(int lang);
        CyString GetCustomScriptType () { return m_sScriptType; }
        CyString GetCustomScriptType (int lang);
        CyString GetOtherName ()                { return m_sOtherName; }
        CyString GetOtherAuthor ()      { return m_sOtherAuthor; }
        CLinkList<SWares> *GetWaresList() { return &m_lWares; }
        CLinkList<SSettingType> *GetSettingsList() { return &m_lSettings; }

        bool CheckValidReadmes ();

        bool   IsCustomStart () { return (m_iPackageType == PACKAGETYPE_CUSTOMSTART) ? true : false;  }
        bool   IsPackageUpdate () { return (m_iPackageType == PACKAGETYPE_UPDATE) ? true : false; }
        bool   IsPatch ()               { return (m_iPackageType == PACKAGETYPE_PATCH) ? true: false; }
        bool   IsLibrary ()             { return (m_iPackageType == PACKAGETYPE_LIBRARY) ? true: false; }
        bool   IsAnotherMod()   { if ( (m_sOtherName.Empty()) || (m_sOtherAuthor.Empty()) ) return false; return true; }
        bool   IsForceProfile() { return m_bForceProfile; }
        int             GetScriptType() { return m_iScriptType; }
        int             GetPackageType() { return m_iPackageType; }

        // Custom Start
        CyString GetCustomStartName();

        // set functions
        void SetScriptType              ( CyString str ) { m_sScriptType = str; m_bChanged = true; }
        void SetAnotherMod ( CyString name, CyString author ) { m_sOtherName = name; m_sOtherAuthor = author; m_bChanged = true; }
        void SetForceProfile ( bool p ) { m_bForceProfile = p; m_bChanged = true; }

        void SetPackageType(int i)
        {
                m_iPackageType = i;
                if ( i == PACKAGETYPE_UPDATE )
                {
                        if ( !this->FindPackageNeeded("<package>", "<author>") )
                                this->AddNeededLibrary("<package>", "<author>", "1.00");
                }
                else
                        this->RemovePackageNeeded("<package>", "<author>");
                m_bChanged = true;
        }
        void SetPatch() { this->SetPackageType(PACKAGETYPE_PATCH); }
        void SetLibrary() { this->SetPackageType(PACKAGETYPE_LIBRARY); }
        void SetCustomStart() { this->SetPackageType(PACKAGETYPE_CUSTOMSTART); }
        void SetPackageUpdate() { this->SetPackageType(PACKAGETYPE_UPDATE); }
        void SetNormalPackage() { this->SetPackageType(PACKAGETYPE_NORMAL); }
        void SetScriptType(int i) { SetNormalPackage(); m_iScriptType = i; m_bChanged = true; }

        virtual bool LoadPackageData(CyString first, CyString rest);
        virtual bool GeneratePackagerScript(bool wildcard, CyStringList *list, bool datafile = false);

        CSpkFile();
        virtual ~CSpkFile();

        bool IsMatchingMod ( CyString mod );

        /// reading of files
        virtual bool ReadFileToMemory ( C_File *file );
        virtual bool ParseValueLine ( CyString line );

        // writing of files
        CyString CreateValuesLine ();
        bool WriteHeader ( FILE *id, int, int );

        SWares *FindWare ( CyString id );
        void AddWare ( CyString  );
        void AddWareText ( CyString );
        void AddWare ( SWares * );
        void AddWareText ( SWares *, int, CyString, CyString );
        void RemoveWare ( CyString );
        void RemoveWareText ( CyString, int );
        void ClearWareText ( SWares * );
        void ClearWareText ( CyString );
        void ClearWares ();
        bool AnyWares() { return !m_lWares.empty(); }

        int CheckValidCustomStart ();

        bool UpdateSigned (bool updateFiles);

        SSettingType *AddSetting ( CyString key, int type );
        void ClearSettings ();
        void ConvertSetting ( SSettingType *t, CyString set );
        CyString GetSetting ( SSettingType *t );
        bool AnySettings() { return !m_lSettings.empty(); }

        // installer usage
        CyString GetLastReadme () { return m_sLastReadme; }
        CyString GetCustomMap () { return m_sCustomMap; }

        void SetCustomMap ( CyString map ) { m_sCustomMap = map; }
        void SetLastReadme ( CyString r ) { m_sLastReadme = r; }

        virtual int GetType () { return TYPE_SPK; }

        void MergePackage(CBaseFile *p);

protected:
        virtual void Delete ();
        virtual void SetDefaults ();
        virtual bool CheckHeader(CyString header);

        // varibles
        CyString m_sOtherAuthor;
        CyString m_sOtherName;
        CyString m_sScriptType;

        bool m_bForceProfile;
        int m_iPackageType;
        int m_iScriptType;

        CLinkList<SWares> m_lWares;
        CLinkList<SSettingType> m_lSettings;

        SWares *m_pLastWare;

        // installer varibles
        CyString m_sLastReadme;
        CyString m_sCustomMap;
};

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 // !defined(AFX_SPKFILE_H__E35FA619_B901_479F_BE42_2FF1519BA4D3__INCLUDED_)