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
240
241
242
243
|
/* 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$
*/
#ifndef GRAPHICS_CURSORMAN_H
#define GRAPHICS_CURSORMAN_H
#include "common/scummsys.h"
#include "common/stack.h"
#include "common/singleton.h"
#ifdef ENABLE_RGB_COLOR
#include "graphics/pixelformat.h"
#include "common/system.h"
#endif
namespace Graphics {
class CursorManager : public Common::Singleton<CursorManager> {
public:
/** Query whether the mouse cursor is visible. */
bool isVisible();
/** Show or hide the mouse cursor. */
bool showMouse(bool visible);
/**
* Push a new cursor onto the stack, and set it in the backend. A local
* copy will be made of the cursor data, so the original buffer can be
* safely freed afterwards.
*
* @param buf the new cursor data
* @param w the width
* @param h the height
* @param hotspotX the hotspot X coordinate
* @param hotspotY the hotspot Y coordinate
* @param keycolor the index for the transparent color
* @param targetScale the scale for which the cursor is designed
*
* @note It is ok for the buffer to be a NULL pointer. It is sometimes
* useful to push a "dummy" cursor and modify it later. The
* cursor will be added to the stack, but not to the backend.
*/
void pushCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor = 0xFFFFFFFF, int targetScale = 1);
/**
* Pop a cursor from the stack, and restore the previous one to the
* backend. If there is no previous cursor, the cursor is hidden.
*/
void popCursor();
/**
* Replace the current cursor on the stack. If the stack is empty, the
* cursor is pushed instead. It's a slightly more optimized way of
* popping the old cursor before pushing the new one.
*
* @param buf the new cursor data
* @param w the width
* @param h the height
* @param hotspotX the hotspot X coordinate
* @param hotspotY the hotspot Y coordinate
* @param keycolor the index for the transparent color
* @param targetScale the scale for which the cursor is designed
*/
void replaceCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor = 0xFFFFFFFF, int targetScale = 1);
/**
* Pop all of the cursors and cursor palettes from their respective stacks.
* The purpose is to ensure that all unecessary cursors are removed from the
* stack when returning to the launcher from an engine.
*
*/
void popAllCursors();
/**
* Enable/Disable the current cursor palette.
*
* @param disable
*/
void disableCursorPalette(bool disable);
/**
* Push a new cursor palette onto the stack, and set it in the backend.
* The palette entries from 'start' till (start+num-1) will be replaced
* so a full palette updated is accomplished via start=0, num=256.
*
* The palette data is specified in the same interleaved RGBA format as
* used by all backends.
*
* @param colors the new palette data, in interleaved RGB format
* @param start the first palette entry to be updated
* @param num the number of palette entries to be updated
*
* @note If num is zero, the cursor palette is disabled.
*/
void pushCursorPalette(const byte *colors, uint start, uint num);
/**
* Pop a cursor palette from the stack, and restore the previous one to
* the backend. If there is no previous palette, the cursor palette is
* disabled instead.
*/
void popCursorPalette();
/**
* Replace the current cursor palette on the stack. If the stack is
* empty, the palette is pushed instead. It's a slightly more optimized
* way of popping the old palette before pushing the new one.
*
* @param colors the new palette data, in interleaved RGB format
* @param start the first palette entry to be updated
* @param num the number of palette entries to be updated
*
* @note If num is zero, the cursor palette is disabled.
*/
void replaceCursorPalette(const byte *colors, uint start, uint num);
#ifdef ENABLE_RGB_COLOR
/**
* Push a new cursor pixel format onto the stack, and set it in the backend.
*
* @param format the new format data, in a Graphics::PixelFormat
*/
void pushCursorFormat(PixelFormat format);
/**
* Pop a cursor pixel format from the stack, and restore the previous one to
* the backend. If there is no previous format, the screen format is
* used instead.
*/
void popCursorFormat();
/**
* Replace the current cursor pixel format on the stack. If the stack is
* empty, the format is pushed instead. It's a slightly more optimized
* way of popping the old format before pushing the new one.
*
* @param format the new format data, in a Graphics::PixelFormat
*/
void replaceCursorFormat(PixelFormat format);
#endif
private:
friend class Common::Singleton<SingletonBaseType>;
CursorManager();
struct Cursor {
byte *_data;
bool _visible;
uint _width;
uint _height;
int _hotspotX;
int _hotspotY;
uint32 _keycolor;
byte _targetScale;
uint _size;
Cursor(const byte *data, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor = 0xFFFFFFFF, int targetScale = 1, uint8 bitDepth = 8) {
#ifdef ENABLE_RGB_COLOR
{ //limit the lifespan of the format value to minimize impact on memory usage
Graphics::PixelFormat f = g_system->getScreenFormat();
_size = w * h * f.bytesPerPixel;
_keycolor = keycolor & ((1 << (f.bytesPerPixel << 3)) - 1);
}
#else
_size = w * h;
_keycolor = keycolor & 0xFF;
#endif
_data = new byte[_size];
if (data && _data)
memcpy(_data, data, _size);
_width = w;
_height = h;
_hotspotX = hotspotX;
_hotspotY = hotspotY;
_targetScale = targetScale;
}
~Cursor() {
delete[] _data;
}
};
struct Palette {
byte *_data;
uint _start;
uint _num;
uint _size;
bool _disabled;
Palette(const byte *colors, uint start, uint num) {
_start = start;
_num = num;
_size = 4 * num;
if (num) {
_data = new byte[_size];
memcpy(_data, colors, _size);
} else {
_data = NULL;
}
_disabled = false;
}
~Palette() {
delete[] _data;
}
};
Common::Stack<Cursor *> _cursorStack;
Common::Stack<Palette *> _cursorPaletteStack;
#ifdef ENABLE_RGB_COLOR
Common::Stack<Graphics::PixelFormat *> _cursorFormatStack;
#endif
};
} // End of namespace Graphics
#define CursorMan (::Graphics::CursorManager::instance())
#endif
|
