1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
/* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#include "common/array.h"
#include "common/file.h"
#ifndef COMMON_MACRESMAN_H
#define COMMON_MACRESMAN_H
namespace Common {
class FSNode;
typedef Common::Array<uint16> MacResIDArray;
typedef Common::Array<uint32> MacResTagArray;
/**
* Class for reading Mac Binary files.
* Is able to read dumped resource forks too.
*/
class MacResManager {
public:
MacResManager();
~MacResManager();
bool open(Common::String filename);
bool open(Common::FSNode path, Common::String filename);
void close();
bool hasDataFork();
bool hasResFork();
bool isMacBinary(Common::SeekableReadStream &stream);
/**
* Read resource from the Mac Binary file
* @param typeID FourCC with type ID
* @param resID Resource ID to fetch
* @return Pointer to a SeekableReadStream with loaded resource
*/
Common::SeekableReadStream *getResource(uint32 typeID, uint16 resID);
/**
* Read resource from the Mac Binary file
* @param filename filename of the resource
* @return Pointer to a SeekableReadStream with loaded resource
*/
Common::SeekableReadStream *getResource(const Common::String &filename);
Common::SeekableReadStream *getDataFork();
Common::String getResName(uint32 typeID, uint16 resID);
uint32 getResForkSize();
bool getResForkMD5(char *md5str, uint32 length);
Common::String getBaseFileName() { return _baseFileName; }
/**
* Convert cursor from crsr format to format suitable for feeding to CursorMan
* @param data Pointer to the cursor data
* @param datasize Size of the cursor data
* @param cursor Pointer to memory where result cursor will be stored. The memory
* block will be malloc()'ed
* @param w Pointer to int where the cursor width will be stored
* @param h Pointer to int where the cursor height will be stored
* @param hotspot_x Storage for cursor hotspot X coordinate
* @param hotspot_Y Storage for cursor hotspot Y coordinate
* @param keycolor Pointer to int where the transpared color value will be stored
* @param colored If set to true then colored cursor will be returned (if any).
* b/w version will be used otherwise
* @param palette Pointer to memory where the cursor palette will be stored.
* The memory will be malloc()'ed
* @param palSize Pointer to integer where the palette size will be stored.
*/
void convertCrsrCursor(byte *data, int datasize, byte **cursor, int *w, int *h,
int *hotspot_x, int *hotspot_y, int *keycolor, bool colored, byte **palette, int *palSize);
/**
* Return list of resource IDs with specified type ID
*/
MacResIDArray getResIDArray(uint32 typeID);
/**
* Return list of resource tags
*/
MacResTagArray getResTagArray();
private:
Common::SeekableReadStream *_stream;
Common::String _baseFileName;
bool load(Common::SeekableReadStream &stream);
bool loadFromRawFork(Common::SeekableReadStream &stream);
bool loadFromMacBinary(Common::SeekableReadStream &stream);
bool loadFromAppleDouble(Common::SeekableReadStream &stream);
enum {
kResForkNone = 0,
kResForkRaw,
kResForkMacBinary,
kResForkAppleDouble
} _mode;
void readMap();
struct ResMap {
uint16 resAttr;
uint16 typeOffset;
uint16 nameOffset;
uint16 numTypes;
};
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
|
