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;

    byte type[4];
    byte creator[4];
    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 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);

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

    static bool getFinderInfoFromMacBinary(SeekableReadStream *stream, MacFinderInfo &outFinderInfo, MacFinderExtendedInfo &outFinderExtendedInfo);

    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