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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
|
/* 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$
*
*/
/**
* @file
* Macintosh resource fork manager used in engines:
* - groovie
* - mohawk
* - sci
* - scumm
*/
#include "common/array.h"
#include "common/fs.h"
#include "common/str.h"
#ifndef COMMON_MACRESMAN_H
#define COMMON_MACRESMAN_H
namespace Common {
typedef Array<uint16> MacResIDArray;
typedef Array<uint32> MacResTagArray;
/**
* Class for handling Mac data and resource forks.
* It can read from raw, MacBinary, and AppleDouble formats.
*/
class MacResManager {
public:
MacResManager();
~MacResManager();
/**
* Open a Mac data/resource fork pair.
* @param filename The base file name of the file
* @note This will check for the raw resource fork, MacBinary, and AppleDouble formats.
* @return True on success
*/
bool open(String filename);
/**
* Open a Mac data/resource fork pair.
* @param path The path that holds the forks
* @param filename The base file name of the file
* @note This will check for the raw resource fork, MacBinary, and AppleDouble formats.
* @return True on success
*/
bool open(FSNode path, String filename);
/**
* Close the Mac data/resource fork pair.
*/
void close();
/**
* Query whether or not we have a data fork present.
* @return True if the data fork is present
*/
bool hasDataFork() const;
/**
* Query whether or not we have a data fork present.
* @return True if the resource fork is present
*/
bool hasResFork() const;
/**
* Check if the given stream is in the MacBinary format.
* @param stream The stream we're checking
*/
static bool isMacBinary(SeekableReadStream &stream);
/**
* Read resource from the MacBinary file
* @param typeID FourCC of the type
* @param resID Resource ID to fetch
* @return Pointer to a SeekableReadStream with loaded resource
*/
SeekableReadStream *getResource(uint32 typeID, uint16 resID);
/**
* Read resource from the MacBinary file
* @note This will take the first resource that matches this name, regardless of type
* @param filename file name of the resource
* @return Pointer to a SeekableReadStream with loaded resource
*/
SeekableReadStream *getResource(const String &filename);
/**
* Read resource from the MacBinary file
* @param typeID FourCC of the type
* @param filename file name of the resource
* @return Pointer to a SeekableReadStream with loaded resource
*/
SeekableReadStream *getResource(uint32 typeID, const String &filename);
/**
* Retrieve the data fork
* @return The stream if present, 0 otherwise
*/
SeekableReadStream *getDataFork();
/**
* Get the name of a given resource
* @param typeID FourCC of the type
* @param resID Resource ID to fetch
* @return The name of a given resource and an empty string if not present
*/
String getResName(uint32 typeID, uint16 resID) const;
/**
* Get the size of the data portion of the resource fork
* @return The size of the data portion of the resource fork
*/
uint32 getResForkDataSize() const;
/**
* Calculate the MD5 checksum of the resource fork
* @param length The maximum length to compute for
* @return The MD5 checksum of the resource fork
*/
String computeResForkMD5AsString(uint32 length = 0) const;
/**
* Get the base file name of the data/resource fork pair
* @return The base file name of the data/resource fork pair
*/
String getBaseFileName() const { return _baseFileName; }
/**
* Convert cursor from crsr format to format suitable for feeding to CursorMan
* @param data Pointer to the cursor datax
* @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 hotspotX Storage for cursor hotspot X coordinate
* @param hotspotY 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.
*/
static void convertCrsrCursor(SeekableReadStream *data, byte **cursor, int &w, int &h, int &hotspotX,
int &hotspotY, 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:
SeekableReadStream *_stream;
String _baseFileName;
bool load(SeekableReadStream &stream);
bool loadFromRawFork(SeekableReadStream &stream);
bool loadFromMacBinary(SeekableReadStream &stream);
bool loadFromAppleDouble(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
|
