ui/cursor.c

   1 #include "qemu/osdep.h"
   2 #include "ui/console.h"
   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 */
  18     if (sscanf(xpm[line], "%u %u %u %u",
  19                &width, &height, &colors, &chars) != 4) {
  20         fprintf(stderr, "%s: header parse error: \"%s\"\n",
  21                 __func__, xpm[line]);
  22         return NULL;
  23     }
  24     if (chars != 1) {
  25         fprintf(stderr, "%s: chars != 1 not supported\n", __func__);
  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",
  43                 __func__, xpm[line]);
  44         return NULL;
  45     }
  46
  47     /* parse pixel data */
  48     c = cursor_alloc(width, height);
  49     assert(c != NULL);
  50
  51     for (pixel = 0, y = 0; y < height; y++, line++) {
  52         for (x = 0; x < height; x++, pixel++) {
  53             idx = xpm[line][x];
  54             c->data[pixel] = ctab[idx];
  55         }
  56     }
  57     return c;
  58 }
  59
  60 /* nice for debugging */
  61 void cursor_print_ascii_art(QEMUCursor *c, const char *prefix)
  62 {
  63     uint32_t *data = c->data;
  64     int x,y;
  65
  66     for (y = 0; y < c->height; y++) {
  67         fprintf(stderr, "%s: %2d: |", prefix, y);
  68         for (x = 0; x < c->width; x++, data++) {
  69             if ((*data & 0xff000000) != 0xff000000) {
  70                 fprintf(stderr, " "); /* transparent */
  71             } else if ((*data & 0x00ffffff) == 0x00ffffff) {
  72                 fprintf(stderr, "."); /* white */
  73             } else if ((*data & 0x00ffffff) == 0x00000000) {
  74                 fprintf(stderr, "X"); /* black */
  75             } else {
  76                 fprintf(stderr, "o"); /* other */
  77             }
  78         }
  79         fprintf(stderr, "|\n");
  80     }
  81 }
  82
  83 QEMUCursor *cursor_builtin_hidden(void)
  84 {
  85     return cursor_parse_xpm(cursor_hidden_xpm);
  86 }
  87
  88 QEMUCursor *cursor_builtin_left_ptr(void)
  89 {
  90     return cursor_parse_xpm(cursor_left_ptr_xpm);
  91 }
  92
  93 QEMUCursor *cursor_alloc(uint16_t width, uint16_t height)
  94 {
  95     QEMUCursor *c;
  96     size_t datasize = width * height * sizeof(uint32_t);
  97
  98     /* Modern physical hardware typically uses 512x512 sprites */
  99     if (width > 512 || height > 512) {
 100         return NULL;
 101     }
 102
 103     c = g_malloc0(sizeof(QEMUCursor) + datasize);
 104     c->width  = width;
 105     c->height = height;
 106     c->refcount = 1;
 107     return c;
 108 }
 109
 110 QEMUCursor *cursor_ref(QEMUCursor *c)
 111 {
 112     c->refcount++;
 113     return c;
 114 }
 115
 116 void cursor_unref(QEMUCursor *c)
 117 {
 118     if (c == NULL)
 119         return;
 120     c->refcount--;
 121     if (c->refcount)
 122         return;
 123     g_free(c);
 124 }
 125
 126 int cursor_get_mono_bpl(QEMUCursor *c)
 127 {
 128     return DIV_ROUND_UP(c->width, 8);
 129 }
 130
 131 void cursor_set_mono(QEMUCursor *c,
 132                      uint32_t foreground, uint32_t background, uint8_t *image,
 133                      int transparent, uint8_t *mask)
 134 {
 135     uint32_t *data = c->data;
 136     uint8_t bit;
 137     int x,y,bpl;
 138     bool expand_bitmap_only = image == mask;
 139     bool has_inverted_colors = false;
 140     const uint32_t inverted = 0x80000000;
 141
 142     /*
 143      * Converts a monochrome bitmap with XOR mask 'image' and AND mask 'mask':
 144      * https://docs.microsoft.com/en-us/windows-hardware/drivers/display/drawing-monochrome-pointers
 145      */
 146     bpl = cursor_get_mono_bpl(c);
 147     for (y = 0; y < c->height; y++) {
 148         bit = 0x80;
 149         for (x = 0; x < c->width; x++, data++) {
 150             if (transparent && mask[x/8] & bit) {
 151                 if (!expand_bitmap_only && image[x / 8] & bit) {
 152                     *data = inverted;
 153                     has_inverted_colors = true;
 154                 } else {
 155                     *data = 0x00000000;
 156                 }
 157             } else if (!transparent && !(mask[x/8] & bit)) {
 158                 *data = 0x00000000;
 159             } else if (image[x/8] & bit) {
 160                 *data = 0xff000000 | foreground;
 161             } else {
 162                 *data = 0xff000000 | background;
 163             }
 164             bit >>= 1;
 165             if (bit == 0) {
 166                 bit = 0x80;
 167             }
 168         }
 169         mask  += bpl;
 170         image += bpl;
 171     }
 172
 173     /*
 174      * If there are any pixels with inverted colors, create an outline (fill
 175      * transparent neighbors with the background color) and use the foreground
 176      * color as "inverted" color.
 177      */
 178     if (has_inverted_colors) {
 179         data = c->data;
 180         for (y = 0; y < c->height; y++) {
 181             for (x = 0; x < c->width; x++, data++) {
 182                 if (*data == 0 /* transparent */ &&
 183                         ((x > 0 && data[-1] == inverted) ||
 184                          (x + 1 < c->width && data[1] == inverted) ||
 185                          (y > 0 && data[-c->width] == inverted) ||
 186                          (y + 1 < c->height && data[c->width] == inverted))) {
 187                     *data = 0xff000000 | background;
 188                 }
 189             }
 190         }
 191         data = c->data;
 192         for (x = 0; x < c->width * c->height; x++, data++) {
 193             if (*data == inverted) {
 194                 *data = 0xff000000 | foreground;
 195             }
 196         }
 197     }
 198 }
 199
 200 void cursor_get_mono_image(QEMUCursor *c, int foreground, uint8_t *image)
 201 {
 202     uint32_t *data = c->data;
 203     uint8_t bit;
 204     int x,y,bpl;
 205
 206     bpl = cursor_get_mono_bpl(c);
 207     memset(image, 0, bpl * c->height);
 208     for (y = 0; y < c->height; y++) {
 209         bit = 0x80;
 210         for (x = 0; x < c->width; x++, data++) {
 211             if (((*data & 0xff000000) == 0xff000000) &&
 212                 ((*data & 0x00ffffff) == foreground)) {
 213                 image[x/8] |= bit;
 214             }
 215             bit >>= 1;
 216             if (bit == 0) {
 217                 bit = 0x80;
 218             }
 219         }
 220         image += bpl;
 221     }
 222 }
 223
 224 void cursor_get_mono_mask(QEMUCursor *c, int transparent, uint8_t *mask)
 225 {
 226     uint32_t *data = c->data;
 227     uint8_t bit;
 228     int x,y,bpl;
 229
 230     bpl = cursor_get_mono_bpl(c);
 231     memset(mask, 0, bpl * c->height);
 232     for (y = 0; y < c->height; y++) {
 233         bit = 0x80;
 234         for (x = 0; x < c->width; x++, data++) {
 235             if ((*data & 0xff000000) != 0xff000000) {
 236                 if (transparent != 0) {
 237                     mask[x/8] |= bit;
 238                 }
 239             } else {
 240                 if (transparent == 0) {
 241                     mask[x/8] |= bit;
 242                 }
 243             }
 244             bit >>= 1;
 245             if (bit == 0) {
 246                 bit = 0x80;
 247             }
 248         }
 249         mask += bpl;
 250     }
 251 }