blob: 1d62ddd4d072f6c60926db9d23150b510e783c3e [file] [log] [blame]
Peter Maydelle16f4c82016-01-29 17:49:51 +00001#include "qemu/osdep.h"
Paolo Bonzini28ecbae2012-11-28 12:06:30 +01002#include "ui/console.h"
Gerd Hoffmann254e5952010-05-21 11:54:32 +02003
4#include "cursor_hidden.xpm"
5#include "cursor_left_ptr.xpm"
6
7/* for creating built-in cursors */
8static QEMUCursor *cursor_parse_xpm(const char *xpm[])
9{
10 QEMUCursor *c;
11 uint32_t ctab[128];
12 unsigned int width, height, colors, chars;
13 unsigned int line = 0, i, r, g, b, x, y, pixel;
14 char name[16];
15 uint8_t idx;
16
17 /* parse header line: width, height, #colors, #chars */
Stefan Weil1c467852012-02-25 14:11:46 +010018 if (sscanf(xpm[line], "%u %u %u %u",
19 &width, &height, &colors, &chars) != 4) {
Gerd Hoffmann254e5952010-05-21 11:54:32 +020020 fprintf(stderr, "%s: header parse error: \"%s\"\n",
Alistair Francisa89f3642017-11-08 14:56:31 -080021 __func__, xpm[line]);
Gerd Hoffmann254e5952010-05-21 11:54:32 +020022 return NULL;
23 }
24 if (chars != 1) {
Alistair Francisa89f3642017-11-08 14:56:31 -080025 fprintf(stderr, "%s: chars != 1 not supported\n", __func__);
Gerd Hoffmann254e5952010-05-21 11:54:32 +020026 return NULL;
27 }
28 line++;
29
30 /* parse color table */
31 for (i = 0; i < colors; i++, line++) {
32 if (sscanf(xpm[line], "%c c %15s", &idx, name) == 2) {
33 if (sscanf(name, "#%02x%02x%02x", &r, &g, &b) == 3) {
34 ctab[idx] = (0xff << 24) | (b << 16) | (g << 8) | r;
35 continue;
36 }
37 if (strcmp(name, "None") == 0) {
38 ctab[idx] = 0x00000000;
39 continue;
40 }
41 }
42 fprintf(stderr, "%s: color parse error: \"%s\"\n",
Alistair Francisa89f3642017-11-08 14:56:31 -080043 __func__, xpm[line]);
Gerd Hoffmann254e5952010-05-21 11:54:32 +020044 return NULL;
45 }
46
47 /* parse pixel data */
48 c = cursor_alloc(width, height);
49 for (pixel = 0, y = 0; y < height; y++, line++) {
50 for (x = 0; x < height; x++, pixel++) {
51 idx = xpm[line][x];
52 c->data[pixel] = ctab[idx];
53 }
54 }
55 return c;
56}
57
58/* nice for debugging */
59void cursor_print_ascii_art(QEMUCursor *c, const char *prefix)
60{
61 uint32_t *data = c->data;
62 int x,y;
63
64 for (y = 0; y < c->height; y++) {
65 fprintf(stderr, "%s: %2d: |", prefix, y);
66 for (x = 0; x < c->width; x++, data++) {
67 if ((*data & 0xff000000) != 0xff000000) {
68 fprintf(stderr, " "); /* transparent */
69 } else if ((*data & 0x00ffffff) == 0x00ffffff) {
70 fprintf(stderr, "."); /* white */
71 } else if ((*data & 0x00ffffff) == 0x00000000) {
72 fprintf(stderr, "X"); /* black */
73 } else {
74 fprintf(stderr, "o"); /* other */
75 }
76 }
77 fprintf(stderr, "|\n");
78 }
79}
80
81QEMUCursor *cursor_builtin_hidden(void)
82{
Eduardo Habkost9be38592016-06-13 18:57:58 -030083 return cursor_parse_xpm(cursor_hidden_xpm);
Gerd Hoffmann254e5952010-05-21 11:54:32 +020084}
85
86QEMUCursor *cursor_builtin_left_ptr(void)
87{
Eduardo Habkost9be38592016-06-13 18:57:58 -030088 return cursor_parse_xpm(cursor_left_ptr_xpm);
Gerd Hoffmann254e5952010-05-21 11:54:32 +020089}
90
91QEMUCursor *cursor_alloc(int width, int height)
92{
93 QEMUCursor *c;
94 int datasize = width * height * sizeof(uint32_t);
95
Anthony Liguori7267c092011-08-20 22:09:37 -050096 c = g_malloc0(sizeof(QEMUCursor) + datasize);
Gerd Hoffmann254e5952010-05-21 11:54:32 +020097 c->width = width;
98 c->height = height;
99 c->refcount = 1;
100 return c;
101}
102
103void cursor_get(QEMUCursor *c)
104{
105 c->refcount++;
106}
107
108void cursor_put(QEMUCursor *c)
109{
110 if (c == NULL)
111 return;
112 c->refcount--;
113 if (c->refcount)
114 return;
Anthony Liguori7267c092011-08-20 22:09:37 -0500115 g_free(c);
Gerd Hoffmann254e5952010-05-21 11:54:32 +0200116}
117
118int cursor_get_mono_bpl(QEMUCursor *c)
119{
Marc-André Lureau935b3332017-06-22 13:04:16 +0200120 return DIV_ROUND_UP(c->width, 8);
Gerd Hoffmann254e5952010-05-21 11:54:32 +0200121}
122
123void cursor_set_mono(QEMUCursor *c,
124 uint32_t foreground, uint32_t background, uint8_t *image,
125 int transparent, uint8_t *mask)
126{
127 uint32_t *data = c->data;
128 uint8_t bit;
129 int x,y,bpl;
Peter Wu36ffc122018-09-03 16:54:47 +0200130 bool expand_bitmap_only = image == mask;
131 bool has_inverted_colors = false;
132 const uint32_t inverted = 0x80000000;
Gerd Hoffmann254e5952010-05-21 11:54:32 +0200133
Peter Wu36ffc122018-09-03 16:54:47 +0200134 /*
135 * Converts a monochrome bitmap with XOR mask 'image' and AND mask 'mask':
136 * https://docs.microsoft.com/en-us/windows-hardware/drivers/display/drawing-monochrome-pointers
137 */
Gerd Hoffmann254e5952010-05-21 11:54:32 +0200138 bpl = cursor_get_mono_bpl(c);
139 for (y = 0; y < c->height; y++) {
140 bit = 0x80;
141 for (x = 0; x < c->width; x++, data++) {
142 if (transparent && mask[x/8] & bit) {
Peter Wu36ffc122018-09-03 16:54:47 +0200143 if (!expand_bitmap_only && image[x / 8] & bit) {
144 *data = inverted;
145 has_inverted_colors = true;
146 } else {
147 *data = 0x00000000;
148 }
Gerd Hoffmann254e5952010-05-21 11:54:32 +0200149 } else if (!transparent && !(mask[x/8] & bit)) {
150 *data = 0x00000000;
151 } else if (image[x/8] & bit) {
152 *data = 0xff000000 | foreground;
153 } else {
154 *data = 0xff000000 | background;
155 }
156 bit >>= 1;
157 if (bit == 0) {
158 bit = 0x80;
159 }
160 }
161 mask += bpl;
162 image += bpl;
163 }
Peter Wu36ffc122018-09-03 16:54:47 +0200164
165 /*
166 * If there are any pixels with inverted colors, create an outline (fill
167 * transparent neighbors with the background color) and use the foreground
168 * color as "inverted" color.
169 */
170 if (has_inverted_colors) {
171 data = c->data;
172 for (y = 0; y < c->height; y++) {
173 for (x = 0; x < c->width; x++, data++) {
174 if (*data == 0 /* transparent */ &&
175 ((x > 0 && data[-1] == inverted) ||
176 (x + 1 < c->width && data[1] == inverted) ||
177 (y > 0 && data[-c->width] == inverted) ||
178 (y + 1 < c->height && data[c->width] == inverted))) {
179 *data = 0xff000000 | background;
180 }
181 }
182 }
183 data = c->data;
184 for (x = 0; x < c->width * c->height; x++, data++) {
185 if (*data == inverted) {
186 *data = 0xff000000 | foreground;
187 }
188 }
189 }
Gerd Hoffmann254e5952010-05-21 11:54:32 +0200190}
191
192void cursor_get_mono_image(QEMUCursor *c, int foreground, uint8_t *image)
193{
194 uint32_t *data = c->data;
195 uint8_t bit;
196 int x,y,bpl;
197
198 bpl = cursor_get_mono_bpl(c);
199 memset(image, 0, bpl * c->height);
200 for (y = 0; y < c->height; y++) {
201 bit = 0x80;
202 for (x = 0; x < c->width; x++, data++) {
203 if (((*data & 0xff000000) == 0xff000000) &&
204 ((*data & 0x00ffffff) == foreground)) {
205 image[x/8] |= bit;
206 }
207 bit >>= 1;
208 if (bit == 0) {
209 bit = 0x80;
210 }
211 }
212 image += bpl;
213 }
214}
215
216void cursor_get_mono_mask(QEMUCursor *c, int transparent, uint8_t *mask)
217{
218 uint32_t *data = c->data;
219 uint8_t bit;
220 int x,y,bpl;
221
222 bpl = cursor_get_mono_bpl(c);
223 memset(mask, 0, bpl * c->height);
224 for (y = 0; y < c->height; y++) {
225 bit = 0x80;
226 for (x = 0; x < c->width; x++, data++) {
227 if ((*data & 0xff000000) != 0xff000000) {
228 if (transparent != 0) {
229 mask[x/8] |= bit;
230 }
231 } else {
232 if (transparent == 0) {
233 mask[x/8] |= bit;
234 }
235 }
236 bit >>= 1;
237 if (bit == 0) {
238 bit = 0x80;
239 }
240 }
241 mask += bpl;
242 }
243}