Peter Maydell | e16f4c8 | 2016-01-29 17:49:51 +0000 | [diff] [blame] | 1 | #include "qemu/osdep.h" |
Paolo Bonzini | 28ecbae | 2012-11-28 12:06:30 +0100 | [diff] [blame] | 2 | #include "ui/console.h" |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 3 | |
| 4 | #include "cursor_hidden.xpm" |
| 5 | #include "cursor_left_ptr.xpm" |
| 6 | |
| 7 | /* for creating built-in cursors */ |
| 8 | static 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 Weil | 1c46785 | 2012-02-25 14:11:46 +0100 | [diff] [blame] | 18 | if (sscanf(xpm[line], "%u %u %u %u", |
| 19 | &width, &height, &colors, &chars) != 4) { |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 20 | fprintf(stderr, "%s: header parse error: \"%s\"\n", |
Alistair Francis | a89f364 | 2017-11-08 14:56:31 -0800 | [diff] [blame] | 21 | __func__, xpm[line]); |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 22 | return NULL; |
| 23 | } |
| 24 | if (chars != 1) { |
Alistair Francis | a89f364 | 2017-11-08 14:56:31 -0800 | [diff] [blame] | 25 | fprintf(stderr, "%s: chars != 1 not supported\n", __func__); |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 26 | 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 Francis | a89f364 | 2017-11-08 14:56:31 -0800 | [diff] [blame] | 43 | __func__, xpm[line]); |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 44 | 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 */ |
| 59 | void 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 | |
| 81 | QEMUCursor *cursor_builtin_hidden(void) |
| 82 | { |
Eduardo Habkost | 9be3859 | 2016-06-13 18:57:58 -0300 | [diff] [blame] | 83 | return cursor_parse_xpm(cursor_hidden_xpm); |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 84 | } |
| 85 | |
| 86 | QEMUCursor *cursor_builtin_left_ptr(void) |
| 87 | { |
Eduardo Habkost | 9be3859 | 2016-06-13 18:57:58 -0300 | [diff] [blame] | 88 | return cursor_parse_xpm(cursor_left_ptr_xpm); |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | QEMUCursor *cursor_alloc(int width, int height) |
| 92 | { |
| 93 | QEMUCursor *c; |
| 94 | int datasize = width * height * sizeof(uint32_t); |
| 95 | |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 96 | c = g_malloc0(sizeof(QEMUCursor) + datasize); |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 97 | c->width = width; |
| 98 | c->height = height; |
| 99 | c->refcount = 1; |
| 100 | return c; |
| 101 | } |
| 102 | |
| 103 | void cursor_get(QEMUCursor *c) |
| 104 | { |
| 105 | c->refcount++; |
| 106 | } |
| 107 | |
| 108 | void cursor_put(QEMUCursor *c) |
| 109 | { |
| 110 | if (c == NULL) |
| 111 | return; |
| 112 | c->refcount--; |
| 113 | if (c->refcount) |
| 114 | return; |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 115 | g_free(c); |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 116 | } |
| 117 | |
| 118 | int cursor_get_mono_bpl(QEMUCursor *c) |
| 119 | { |
Marc-André Lureau | 935b333 | 2017-06-22 13:04:16 +0200 | [diff] [blame] | 120 | return DIV_ROUND_UP(c->width, 8); |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 121 | } |
| 122 | |
| 123 | void 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 Wu | 36ffc12 | 2018-09-03 16:54:47 +0200 | [diff] [blame] | 130 | bool expand_bitmap_only = image == mask; |
| 131 | bool has_inverted_colors = false; |
| 132 | const uint32_t inverted = 0x80000000; |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 133 | |
Peter Wu | 36ffc12 | 2018-09-03 16:54:47 +0200 | [diff] [blame] | 134 | /* |
| 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 Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 138 | 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 Wu | 36ffc12 | 2018-09-03 16:54:47 +0200 | [diff] [blame] | 143 | if (!expand_bitmap_only && image[x / 8] & bit) { |
| 144 | *data = inverted; |
| 145 | has_inverted_colors = true; |
| 146 | } else { |
| 147 | *data = 0x00000000; |
| 148 | } |
Gerd Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 149 | } 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 Wu | 36ffc12 | 2018-09-03 16:54:47 +0200 | [diff] [blame] | 164 | |
| 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 Hoffmann | 254e595 | 2010-05-21 11:54:32 +0200 | [diff] [blame] | 190 | } |
| 191 | |
| 192 | void 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 | |
| 216 | void 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 | } |