IoCommon.h

#ifndef IOCOMMON_H
#define IOCOMMON_H
 
#include "FileInfo.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
typedef bool (*ValidFileMethod)(LPCTSTR, void *);
 
typedef enum 
{
    IO_FILE_OK = 1,
 
    IO_FILE_UNKNOWN_ERROR = 0,
    IO_FILE_CANT_OPEN_FILE = -1,
    IO_FILE_UNKNOWN_FILE_TYPE = -2,
    IO_FILE_BAD_FILE_FORMAT = -3,
    IO_FILE_MEMORY_ERROR = -4, 
    IO_FILE_CRITICAL_ERROR = -5, // A catched exception was thrown meaning that a critical error occured when reading saving the file
    IO_SAVE_FILE_DISK_FULL = -6,
    IO_SAVE_FILE_ACCESS_DENIED = -7,
    IO_SAVE_EMPTY_FILE = -8,
    IO_CANT_SAVE_IN_THIS_FORMAT = -9,
    IO_LOAD_EMPTY_FILE = -10,
    IO_USER_ABORT_OPERATION = -11,
    IO_CUSTOM_ERROR = -12,
} IO_FILE_RESULT;
 
typedef enum IoShowDialog
{
    IO_NO_DIALOG = 0,           // No dialog to display
    IO_DIALOG_RECOMMENDED = 1,  // Better to display dialog to define a compression factor for example. The IO works without it.
    IO_NEED_DIALOG = 2,     // Dialog absolutely needed to read the format (ie raw format). The IO does not works without it.
} IoShowDialog;
 
//! @struct IoLogInfo
//! @brief Provides log detail info to IoFile
typedef struct IoLogInfo
{
    enum loglevel
    {
        LOG_NONE = 0,
        LOG_ALL = 0xFF,
        LOG_INFO = 0x01,
        LOG_WARNING = 0x02,
        LOG_ERROR = 0x04,
    } level;
    CXString txt;
 
public:
    IoLogInfo()
    {
        level = LOG_NONE;
    }
 
    IoLogInfo(const CXString& txt, loglevel level)
    {
        this->txt = txt;
        this->level = level;
    }
} IoLogInfo;
 
class DLL_TOOLSFUNCTION CIoOptions
{
    public:
        typedef enum
        {
            IOOPTIONS_NONE = 0x00,
            IOOPTIONS_LOAD = 0x01, // Save mode otherwise
            IOOPTIONS_SHOWALLDLGOPTIONS = 0x02, // this display all options when (ie update mode) defining format options for a batch process for example.
            IOOPTIONS_ALLOW_GLOBALOPTIONS = 0x04, // Allow to display global options such log report event accordingly to global prefs (overidde default options, in case we have another way to display log)
 
            // these are global options load automatically and shared among all parser
            IOOPTIONS_GLOBAL_PREFS = 0xFFFF0000,
            IOOPTIONS_GLOBAL_SHOWLOG = 0x00010000, // this display the log option 
        } IoOptionsFlags;
 
    private:
        unsigned options; // runtime options
        CXArray<IoLogInfo, IoLogInfo&> log;
 
    protected:
        CXCriticalSection threadLock;
        CCustomData parserData; // Store specific parser options for serialization
 
    public:
        CIoOptions(bool isLoading);
        virtual ~CIoOptions();
 
        void SetFlag(IoOptionsFlags flag, bool set); 
        bool IsFlagSet(IoOptionsFlags flag) const;
 
        // Init parser options from provided or previously saved data
        virtual void InitFromSavedPrefs(const CCustomData& data) = 0; // Init options from saved prefs data. GetParserOptions must be called after InitFromSavedPrefs, if some specific settings must be set by the called
        virtual const CCustomData& SaveToSavedPrefs() = 0; // Save struct to saved prefs data
 
        CCustomData& GetParserOptions() { return parserData; } // Use when caller provide the reading and saving options. GetParserOptions allows to provide extra parser settings, such an FBX password for example. If settings come from saved prefs, InitFromSavedPrefs to initialize the data.
        const CCustomData& GetParserOptions() const { return parserData; } // Use when caller provide the reading and saving options. GetParserOptions allows to provide extra parser settings, such an FBX password for example. If settings come from saved prefs, InitFromSavedPrefs to initialize the data.
 
        void AddLogInfo(IoLogInfo::loglevel level, const CXString& txt);
        void AddLogInfo(IoLogInfo::loglevel level, unsigned int errorCode, LPCTSTR filename = NULL);
 
#ifndef MOOTOOLS_NO_UI
        void DisplayLog(unsigned int loglevel, CWnd *pParent);
#endif
};
 
#define IO_FILECLASS_ID MAKE_CUSTOM_ID('I', 'O', 'C', 'L')
 
typedef enum FILE_PARSER_FLAGS
{
    FILE_PARSER_DEFAULT = 0x00,
    FILE_PARSER_SAVING = 0x00,  // Set it to 0 so we just have to check FILE_PARSER_LOADING to see if loading
    FILE_PARSER_LOADING = 0x01,
    FILE_PARSER_SILENT_MODE = 0x02, // No dialogs, no messages
    FILE_PARSER_SHOW_DIALOG = 0x04, // Always show export dialogs (apply to bitmap export only, 3d export only use FILE_PARSER_SILENT_MODE or not)
    // TODO: FILE_PARSER_PARAMETERS_PROVIDED should be deprecated, as CFileIo::iodata is intended to store only collected data 
    // Parameters of the parser are provided using GetCustomData() 
    // We don't take care of default settings, and don't save settings in preferences files 
    FILE_PARSER_PARAMETERS_PROVIDED = 0x08,
    FILE_PARSER_QUICK_MODE = 0x10, // Try to open in quick mode
    FILE_PARSER_SHOW_FILE_DIALOG = 0x20, // a name might be provided, but the file selector must be shown to the user (apply to bitmap export only, 3d export only use FILE_PARSER_SILENT_MODE or not)
} FILE_PARSER_FLAGS;
 
class CFileIo;
class CFileParser;
 
class CFileIo;
class DLL_TOOLSFUNCTION CFileParser
{
protected:
    CFileIo *io;
    CXWnd *pParent;
 
public:
    CFileParser(CFileIo& io);
    virtual ~CFileParser();
 
    CFileIo *GetIoMgr() { return io; };
 
    // Parser flags
    bool IsSilentMode() const;
    bool IsFlagSet(FILE_PARSER_FLAGS flag) const;
 
    // Load/Save process
    IoShowDialog MustShowDialog();
};      
 
class DLL_TOOLSFUNCTION CFileIo
{
    friend CFileParser;
 
    private:
        CFileInfo fileInfo;
        unsigned int flags;
 
        unsigned int altParserClass;
        CCustomData iodata; // Store extra information collected from the parser. This is not related to I/O settings, but allow to get some additional information after file has been readed or saved
        int ioError;
        CXString errorTxt;
 
    protected:
        CFileParser *ioparser;
        CXWnd *pParent;
 
        virtual CFileParser *InitParser();
        virtual void CloseParser();
 
        bool CanTryAnotherParser() const { return fileInfo.CanTryAnotherParser(); }
        void TryNextParser() { fileInfo.TryNextParser(); }
 
    public:
        CFileIo(const CFileNameSpec&, unsigned int flags, CXWnd *pParent = NULL);
        CFileIo(unsigned int fileclass, unsigned int flags, CXWnd *pParent = NULL);
        virtual ~CFileIo();
 
        CXWnd *GetParentWnd()
        {
            return pParent;
        };
 
        CCustomData& GetCustomData() { return iodata; };
 
        CXString GetCurrentShortFileName(void);
        CXString GetCurrentCompleteFileName(void);
        CXString GetCurrentFilePath(void);
        void SetAlternativeClass(unsigned int altClass);
        unsigned int GetAlternativeClass() const;
        bool IsMultiParserExtension() const { return (fileInfo.GetParserNbr() > 1); }
 
#ifndef MOOTOOLS_NO_UI
        bool FileDialogBox(int type, bool makeNameUnique = false); // makeNameUnique is useful only for saving dialog box
#ifndef MOOTOOLS_NO_MULTIPLE_FILEDLG
        bool SelectFilesFromList(CXStringArray&, CXStringArray&);
#endif
#endif
 
#ifndef MOOTOOLS_CRUNCHERSDK
        bool GetFileList(CXStringArray&, ValidFileMethod, void *, bool);
        static bool FindMatchingFile(CXString& findname, const CXString& basename, int value);
#endif
 
        bool IsLoading() const { return IsFlagSet(FILE_PARSER_LOADING); }
 
        bool IsURL(bool trueOnlyIfFileURL) const
        {
            if (trueOnlyIfFileURL)
                return (fileInfo.IsURL() && fileInfo.IsFile());
 
            return fileInfo.IsURL();
        }
 
        CXString GetName() const
        {
            return fileInfo.GetName();
        }
 
        CXString GetCompleteName() const
        {
            return fileInfo.GetCompleteName();
        }
 
        CXString GetPath() const
        {
            return fileInfo.GetPath();
        }
 
        CXString GetExtension() const
        {
            return fileInfo.GetExtension();
        }
 
        CXString GetNameWithoutExt() const
        {
            return fileInfo.GetNameWithoutExt();
        }
 
        void SetNewFileName(const CFileNameSpec& filespec)
        {
#ifdef _DEBUG
            XASSERT(filespec.GetClass() == GetClass());
#endif
            fileInfo.Init(filespec);
        }
 
        unsigned int GetKindOf(void) const
        {
            return fileInfo.GetKindOf();
        }
 
        unsigned int GetClass(void) const
        {
            return fileInfo.GetClass();
        }
 
        unsigned int GetProperties(void) const
        {
            return fileInfo.GetProperties();
        }
 
        unsigned int GetParser() const
        {
            if (IsLoading())
                return fileInfo.GetLoader();
 
            return fileInfo.GetSaver();
        }
 
        // Errors information
        bool ReportIoError(CIoOptions *options = NULL, unsigned int level = IoLogInfo::LOG_WARNING|IoLogInfo::LOG_ERROR);
        bool ReportIoError(const CXString& error);
        CXString GetIoErrorTxt() const;
        static CXString GetIoErrorTxtFromCode(bool loading, int code, LPCTSTR filename = NULL);
 
        int GetIoError() const
        {
            return ioError;
        };
 
        void SetIoError(IO_FILE_RESULT error, CIoOptions *options = NULL, IoLogInfo::loglevel level = IoLogInfo::LOG_ERROR);
        void SetIoError(const CXString& error, CIoOptions *options = NULL, IoLogInfo::loglevel level = IoLogInfo::LOG_ERROR);
 
        // Load and save flags
        unsigned int GetFlags() const { return flags; };
        void SetFlag(FILE_PARSER_FLAGS state, bool set);
        bool IsFlagSet(unsigned int state) const;
        void SetSilentMode(bool silent) { SetFlag(FILE_PARSER_SILENT_MODE, silent); }
        bool IsSilentMode() { return IsFlagSet(FILE_PARSER_SILENT_MODE); }
 
        // Parser information
        static IoShowDialog HasDialog(unsigned int fileclass, bool loading);
 
        // Settings options
        static CXString GetPreferencesFilePath();
        bool SaveIoParameters(bool loading, const CCustomData& iodata, unsigned int fileclass) const; // Return true if some prefs are saved, false otherwise
        bool LoadIoParameters(bool loading, CCustomData& iodata, unsigned int fileclass) const;  // Return true if some prefs are loaded modifying iodata, false otherwise
};
 
END_MOOTOOLS_NAMESPACE
 
#endif /* IOBMAPMGR_H */