macresman.h

Go to the documentation of this file.

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#include "common/array.h"
#include "common/fs.h"
#include "common/rect.h"
#include "common/str.h"
#include "common/str-array.h"
 
#ifndef COMMON_MACRESMAN_H
#define COMMON_MACRESMAN_H
 
namespace Common {
 
typedef Array<uint16> MacResIDArray;
typedef Array<uint32> MacResTagArray;
typedef bool (* ProgressUpdateCallback)(void *, int);
 
struct MacFinderInfoData {
    byte data[16];
};
 
struct MacFinderExtendedInfoData {
    byte data[16];
};
 
struct MacFinderInfo {
    enum FinderFlags {
        kFinderFlagAlias = (1 << 15),
        kFinderFlagInvisible = (1 << 14),
        kFinderFlagBundle = (1 << 13),
        kFinderFlagNameLocked = (1 << 12),
        kFinderFlagStationery = (1 << 11),
        kFinderFlagCustomIcon = (1 << 10),
        kFinderFlagInited = (1 << 8),
        kFinderFlagNoInit = (1 << 7),
        kFinderFlagShared = (1 << 6),
 
        kFinderFlagColorBit2 = (1 << 3),
        kFinderFlagColorBit1 = (1 << 2),
        kFinderFlagColorBit0 = (1 << 1),
    };
 
    MacFinderInfo();
    explicit MacFinderInfo(const MacFinderInfoData &data);
 
    MacFinderInfoData toData() const;
 
    uint32 type;
    uint32 creator;
    uint16 flags;
    Common::Point position;
    int16 windowID;
};
 
struct MacFinderExtendedInfo {
    static const uint kDataSize = 16;
 
    MacFinderExtendedInfo();
    explicit MacFinderExtendedInfo(const MacFinderExtendedInfoData &data);
 
    MacFinderExtendedInfoData toData() const;
 
    int16 iconID;
    int16 commentID;
    int32 homeDirectoryID;
};
 
class MacResManager {
 
#define MBI_INFOHDR 128
 
public:
    MacResManager();
    ~MacResManager();
 
    bool open(const Path &fileName);
 
    bool open(const Path &fileName, Archive &archive);
 
    static SeekableReadStream *openFileOrDataFork(const Path &fileName, Archive &archive);
    static SeekableReadStream *openFileOrDataFork(const Path &fileName);
 
    static SeekableReadStream *openDataForkFromMacBinary(SeekableReadStream *inStream, DisposeAfterUse::Flag disposeAfterUse = DisposeAfterUse::NO);
 
    static void writeMacBinary(SeekableWriteStream *outStream, SeekableReadStream *dataFork, SeekableReadStream *resourceFork, const Common::String &name, const MacFinderInfo &info, TimeDate *created = nullptr, TimeDate *modified = nullptr);
 
    static bool exists(const Path &fileName);
 
    static bool getFileFinderInfo(const Path &fileName, Archive &archive, MacFinderInfo &outFinderInfo);
    static bool getFileFinderInfo(const Path &fileName, Archive &archive, MacFinderInfo &outFinderInfo, MacFinderExtendedInfo &outFinderExtendedInfo);
    static bool getFileFinderInfo(const Path &fileName, MacFinderInfo &outFinderInfo);
    static bool getFileFinderInfo(const Path &fileName, MacFinderInfo &outFinderInfo, MacFinderExtendedInfo &outFinderExtendedInfo);
 
    static void listFiles(Array<Path> &files, const Path &pattern);
 
    void close();
 
    bool hasResFork() const;
 
    bool hasDataFork() const;
 
    bool isMacFile() const { return _mode != kResForkNone; }
 
    int getMode() const { return _mode; }
 
    SeekableReadStream *getResource(uint32 typeID, uint16 resID);
 
    SeekableReadStream *getResource(const String &filename);
 
    SeekableReadStream *getResource(uint32 typeID, const String &filename);
 
    static int getDataForkOffset() { return MBI_INFOHDR; }
 
    String getResName(uint32 typeID, uint16 resID) const;
 
    uint32 getResLength(uint32 typeID, uint16 resID);
 
    uint16 getResID(uint32 typeID, const Common::String &filename);
 
    uint32 getResForkDataSize() const;
 
    uint32 getResForkSize() const {
        if (!hasResFork())
            return 0;
        return _resForkSize;
    }
 
    uint32 getDataForkSize() const {
        if (!hasDataFork())
            return 0;
        return _dataLength;
    }
 
    String computeResForkMD5AsString(uint32 length = 0, bool tail = false, ProgressUpdateCallback progressUpdateCallback = nullptr, void *callbackParameter = nullptr) const;
 
    Path getBaseFileName() const { return _baseFileName; }
 
    void setBaseFileName(Common::Path str) { _baseFileName = str; }
 
    String getOriginalFileName() const { return _originalFileName; }
 
    MacResIDArray getResIDArray(uint32 typeID);
 
    MacResTagArray getResTagArray();
 
    bool loadFromMacBinary(SeekableReadStream *stream);
 
     void dumpRaw();
 
    static bool isMacBinary(SeekableReadStream &stream);
 
    struct MacVers {
        byte majorVer;
        byte minorVer;
        byte devStage;
        String devStr;
        byte preReleaseVer;
        uint16 region;
        String str;
        String msg;
    };
    static MacVers *parseVers(SeekableReadStream *vvers);
 
    enum {
        kResForkNone = 0,
        kResForkRaw,
        kResForkMacBinary,
        kResForkAppleDouble
    } _mode;
 
    static Path constructAppleDoubleName(const Path &name);
 
private:
    SeekableReadStream *_stream;
    Path _baseFileName;
    String _originalFileName;
 
    bool load(SeekableReadStream *stream);
 
    bool loadFromRawFork(SeekableReadStream *stream);
    bool loadFromAppleDouble(SeekableReadStream *stream);
 
public:
    static bool getFinderInfoFromMacBinary(SeekableReadStream *stream, MacFinderInfo &outFinderInfo, MacFinderExtendedInfo &outFinderExtendedInfo);
 
private:
    static bool getFinderInfoFromAppleDouble(SeekableReadStream *stream, MacFinderInfo &outFinderInfo, MacFinderExtendedInfo &outFinderExtendedInfo);
 
    static bool readAndValidateMacBinaryHeader(SeekableReadStream &stream, byte (&outMacBinaryHeader)[MBI_INFOHDR]);
 
    static Path disassembleAppleDoubleName(const Path &name, bool *isAppleDouble);
 
    static SeekableReadStream *openAppleDoubleWithAppleOrOSXNaming(Archive& archive, const Path &fileName);
 
    static bool isRawFork(SeekableReadStream &stream);
 
    void readMap();
 
    struct ResMap {
        uint16 resAttr;
        uint16 typeOffset;
        uint16 nameOffset;
        uint16 numTypes;
 
        void reset() {
            resAttr = 0;
            typeOffset = 0;
            nameOffset = 0;
            numTypes = 0;
        }
 
        ResMap() { reset(); }
    };
 
    struct ResType {
        uint32 id;
        uint16 items;
        uint16 offset;
    };
 
    struct Resource {
        uint16 id;
        int16 nameOffset;
        byte attr;
        uint32 dataOffset;
        char *name;
    };
 
    typedef Resource *ResPtr;
 
    int32 _resForkOffset;
    uint32 _resForkSize;
 
    uint32 _dataOffset;
    uint32 _dataLength;
    uint32 _mapOffset;
    uint32 _mapLength;
    ResMap _resMap;
    ResType *_resTypes;
    ResPtr  *_resLists;
};
 
} // End of namespace Common
 
#endif