Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 211 lines (188 sloc) 5.398 kb
68396ea9 »
2011-06-24 Initial commit of d32e8d0 from qemu-kvm
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], "%d %d %d %d", &width, &height, &colors, &chars) != 4) {
19 fprintf(stderr, "%s: header parse error: \"%s\"\n",
20 __FUNCTION__, xpm[line]);
21 return NULL;
22 }
23 if (chars != 1) {
24 fprintf(stderr, "%s: chars != 1 not supported\n", __FUNCTION__);
25 return NULL;
26 }
27 line++;
28
29 /* parse color table */
30 for (i = 0; i < colors; i++, line++) {
31 if (sscanf(xpm[line], "%c c %15s", &idx, name) == 2) {
32 if (sscanf(name, "#%02x%02x%02x", &r, &g, &b) == 3) {
33 ctab[idx] = (0xff << 24) | (b << 16) | (g << 8) | r;
34 continue;
35 }
36 if (strcmp(name, "None") == 0) {
37 ctab[idx] = 0x00000000;
38 continue;
39 }
40 }
41 fprintf(stderr, "%s: color parse error: \"%s\"\n",
42 __FUNCTION__, xpm[line]);
43 return NULL;
44 }
45
46 /* parse pixel data */
47 c = cursor_alloc(width, height);
48 for (pixel = 0, y = 0; y < height; y++, line++) {
49 for (x = 0; x < height; x++, pixel++) {
50 idx = xpm[line][x];
51 c->data[pixel] = ctab[idx];
52 }
53 }
54 return c;
55 }
56
57 /* nice for debugging */
58 void cursor_print_ascii_art(QEMUCursor *c, const char *prefix)
59 {
60 uint32_t *data = c->data;
61 int x,y;
62
63 for (y = 0; y < c->height; y++) {
64 fprintf(stderr, "%s: %2d: |", prefix, y);
65 for (x = 0; x < c->width; x++, data++) {
66 if ((*data & 0xff000000) != 0xff000000) {
67 fprintf(stderr, " "); /* transparent */
68 } else if ((*data & 0x00ffffff) == 0x00ffffff) {
69 fprintf(stderr, "."); /* white */
70 } else if ((*data & 0x00ffffff) == 0x00000000) {
71 fprintf(stderr, "X"); /* black */
72 } else {
73 fprintf(stderr, "o"); /* other */
74 }
75 }
76 fprintf(stderr, "|\n");
77 }
78 }
79
80 QEMUCursor *cursor_builtin_hidden(void)
81 {
82 QEMUCursor *c;
83
84 c = cursor_parse_xpm(cursor_hidden_xpm);
85 return c;
86 }
87
88 QEMUCursor *cursor_builtin_left_ptr(void)
89 {
90 QEMUCursor *c;
91
92 c = cursor_parse_xpm(cursor_left_ptr_xpm);
93 return c;
94 }
95
96 QEMUCursor *cursor_alloc(int width, int height)
97 {
98 QEMUCursor *c;
99 int datasize = width * height * sizeof(uint32_t);
100
101 c = qemu_mallocz(sizeof(QEMUCursor) + datasize);
102 c->width = width;
103 c->height = height;
104 c->refcount = 1;
105 return c;
106 }
107
108 void cursor_get(QEMUCursor *c)
109 {
110 c->refcount++;
111 }
112
113 void cursor_put(QEMUCursor *c)
114 {
115 if (c == NULL)
116 return;
117 c->refcount--;
118 if (c->refcount)
119 return;
120 qemu_free(c);
121 }
122
123 int cursor_get_mono_bpl(QEMUCursor *c)
124 {
125 return (c->width + 7) / 8;
126 }
127
128 void cursor_set_mono(QEMUCursor *c,
129 uint32_t foreground, uint32_t background, uint8_t *image,
130 int transparent, uint8_t *mask)
131 {
132 uint32_t *data = c->data;
133 uint8_t bit;
134 int x,y,bpl;
135
136 bpl = cursor_get_mono_bpl(c);
137 for (y = 0; y < c->height; y++) {
138 bit = 0x80;
139 for (x = 0; x < c->width; x++, data++) {
140 if (transparent && mask[x/8] & bit) {
141 *data = 0x00000000;
142 } else if (!transparent && !(mask[x/8] & bit)) {
143 *data = 0x00000000;
144 } else if (image[x/8] & bit) {
145 *data = 0xff000000 | foreground;
146 } else {
147 *data = 0xff000000 | background;
148 }
149 bit >>= 1;
150 if (bit == 0) {
151 bit = 0x80;
152 }
153 }
154 mask += bpl;
155 image += bpl;
156 }
157 }
158
159 void cursor_get_mono_image(QEMUCursor *c, int foreground, uint8_t *image)
160 {
161 uint32_t *data = c->data;
162 uint8_t bit;
163 int x,y,bpl;
164
165 bpl = cursor_get_mono_bpl(c);
166 memset(image, 0, bpl * c->height);
167 for (y = 0; y < c->height; y++) {
168 bit = 0x80;
169 for (x = 0; x < c->width; x++, data++) {
170 if (((*data & 0xff000000) == 0xff000000) &&
171 ((*data & 0x00ffffff) == foreground)) {
172 image[x/8] |= bit;
173 }
174 bit >>= 1;
175 if (bit == 0) {
176 bit = 0x80;
177 }
178 }
179 image += bpl;
180 }
181 }
182
183 void cursor_get_mono_mask(QEMUCursor *c, int transparent, uint8_t *mask)
184 {
185 uint32_t *data = c->data;
186 uint8_t bit;
187 int x,y,bpl;
188
189 bpl = cursor_get_mono_bpl(c);
190 memset(mask, 0, bpl * c->height);
191 for (y = 0; y < c->height; y++) {
192 bit = 0x80;
193 for (x = 0; x < c->width; x++, data++) {
194 if ((*data & 0xff000000) != 0xff000000) {
195 if (transparent != 0) {
196 mask[x/8] |= bit;
197 }
198 } else {
199 if (transparent == 0) {
200 mask[x/8] |= bit;
201 }
202 }
203 bit >>= 1;
204 if (bit == 0) {
205 bit = 0x80;
206 }
207 }
208 mask += bpl;
209 }
210 }
Something went wrong with that request. Please try again.