File:  [Qemu by Fabrice Bellard] / qemu / cursor.c
Revision 1.1.1.3 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:34:51 2018 UTC (23 months, 1 week ago) by root
Branches: qemu, MAIN
CVS tags: qemu1101, HEAD
qemu 1.1.1

    1: #include "qemu-common.h"
    2: #include "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:                 __FUNCTION__, xpm[line]);
   22:         return NULL;
   23:     }
   24:     if (chars != 1) {
   25:         fprintf(stderr, "%s: chars != 1 not supported\n", __FUNCTION__);
   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:                 __FUNCTION__, xpm[line]);
   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: {
   83:     QEMUCursor *c;
   84: 
   85:     c = cursor_parse_xpm(cursor_hidden_xpm);
   86:     return c;
   87: }
   88: 
   89: QEMUCursor *cursor_builtin_left_ptr(void)
   90: {
   91:     QEMUCursor *c;
   92: 
   93:     c = cursor_parse_xpm(cursor_left_ptr_xpm);
   94:     return c;
   95: }
   96: 
   97: QEMUCursor *cursor_alloc(int width, int height)
   98: {
   99:     QEMUCursor *c;
  100:     int datasize = width * height * sizeof(uint32_t);
  101: 
  102:     c = g_malloc0(sizeof(QEMUCursor) + datasize);
  103:     c->width  = width;
  104:     c->height = height;
  105:     c->refcount = 1;
  106:     return c;
  107: }
  108: 
  109: void cursor_get(QEMUCursor *c)
  110: {
  111:     c->refcount++;
  112: }
  113: 
  114: void cursor_put(QEMUCursor *c)
  115: {
  116:     if (c == NULL)
  117:         return;
  118:     c->refcount--;
  119:     if (c->refcount)
  120:         return;
  121:     g_free(c);
  122: }
  123: 
  124: int cursor_get_mono_bpl(QEMUCursor *c)
  125: {
  126:     return (c->width + 7) / 8;
  127: }
  128: 
  129: void cursor_set_mono(QEMUCursor *c,
  130:                      uint32_t foreground, uint32_t background, uint8_t *image,
  131:                      int transparent, uint8_t *mask)
  132: {
  133:     uint32_t *data = c->data;
  134:     uint8_t bit;
  135:     int x,y,bpl;
  136: 
  137:     bpl = cursor_get_mono_bpl(c);
  138:     for (y = 0; y < c->height; y++) {
  139:         bit = 0x80;
  140:         for (x = 0; x < c->width; x++, data++) {
  141:             if (transparent && mask[x/8] & bit) {
  142:                 *data = 0x00000000;
  143:             } else if (!transparent && !(mask[x/8] & bit)) {
  144:                 *data = 0x00000000;
  145:             } else if (image[x/8] & bit) {
  146:                 *data = 0xff000000 | foreground;
  147:             } else {
  148:                 *data = 0xff000000 | background;
  149:             }
  150:             bit >>= 1;
  151:             if (bit == 0) {
  152:                 bit = 0x80;
  153:             }
  154:         }
  155:         mask  += bpl;
  156:         image += bpl;
  157:     }
  158: }
  159: 
  160: void cursor_get_mono_image(QEMUCursor *c, int foreground, uint8_t *image)
  161: {
  162:     uint32_t *data = c->data;
  163:     uint8_t bit;
  164:     int x,y,bpl;
  165: 
  166:     bpl = cursor_get_mono_bpl(c);
  167:     memset(image, 0, bpl * c->height);
  168:     for (y = 0; y < c->height; y++) {
  169:         bit = 0x80;
  170:         for (x = 0; x < c->width; x++, data++) {
  171:             if (((*data & 0xff000000) == 0xff000000) &&
  172:                 ((*data & 0x00ffffff) == foreground)) {
  173:                 image[x/8] |= bit;
  174:             }
  175:             bit >>= 1;
  176:             if (bit == 0) {
  177:                 bit = 0x80;
  178:             }
  179:         }
  180:         image += bpl;
  181:     }
  182: }
  183: 
  184: void cursor_get_mono_mask(QEMUCursor *c, int transparent, uint8_t *mask)
  185: {
  186:     uint32_t *data = c->data;
  187:     uint8_t bit;
  188:     int x,y,bpl;
  189: 
  190:     bpl = cursor_get_mono_bpl(c);
  191:     memset(mask, 0, bpl * c->height);
  192:     for (y = 0; y < c->height; y++) {
  193:         bit = 0x80;
  194:         for (x = 0; x < c->width; x++, data++) {
  195:             if ((*data & 0xff000000) != 0xff000000) {
  196:                 if (transparent != 0) {
  197:                     mask[x/8] |= bit;
  198:                 }
  199:             } else {
  200:                 if (transparent == 0) {
  201:                     mask[x/8] |= bit;
  202:                 }
  203:             }
  204:             bit >>= 1;
  205:             if (bit == 0) {
  206:                 bit = 0x80;
  207:             }
  208:         }
  209:         mask += bpl;
  210:     }
  211: }

unix.superglobalmegacorp.com