]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * QEMU System Emulator | |
3 | * | |
4 | * Copyright (c) 2003-2008 Fabrice Bellard | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
24 | ||
25 | #include "sysemu/sysemu.h" | |
26 | #include "monitor/monitor.h" | |
27 | #include "ui/console.h" | |
28 | #include "qapi/error.h" | |
29 | #include "qmp-commands.h" | |
30 | #include "qapi-types.h" | |
31 | #include "ui/keymaps.h" | |
32 | ||
33 | struct QEMUPutMouseEntry { | |
34 | QEMUPutMouseEvent *qemu_put_mouse_event; | |
35 | void *qemu_put_mouse_event_opaque; | |
36 | int qemu_put_mouse_event_absolute; | |
37 | char *qemu_put_mouse_event_name; | |
38 | ||
39 | int index; | |
40 | ||
41 | /* used internally by qemu for handling mice */ | |
42 | QTAILQ_ENTRY(QEMUPutMouseEntry) node; | |
43 | }; | |
44 | ||
45 | struct QEMUPutKbdEntry { | |
46 | QEMUPutKBDEvent *put_kbd; | |
47 | void *opaque; | |
48 | QTAILQ_ENTRY(QEMUPutKbdEntry) next; | |
49 | }; | |
50 | ||
51 | struct QEMUPutLEDEntry { | |
52 | QEMUPutLEDEvent *put_led; | |
53 | void *opaque; | |
54 | QTAILQ_ENTRY(QEMUPutLEDEntry) next; | |
55 | }; | |
56 | ||
57 | static QTAILQ_HEAD(, QEMUPutLEDEntry) led_handlers = | |
58 | QTAILQ_HEAD_INITIALIZER(led_handlers); | |
59 | static QTAILQ_HEAD(, QEMUPutKbdEntry) kbd_handlers = | |
60 | QTAILQ_HEAD_INITIALIZER(kbd_handlers); | |
61 | static QTAILQ_HEAD(, QEMUPutMouseEntry) mouse_handlers = | |
62 | QTAILQ_HEAD_INITIALIZER(mouse_handlers); | |
63 | static NotifierList mouse_mode_notifiers = | |
64 | NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers); | |
65 | ||
66 | static const int key_defs[] = { | |
67 | [Q_KEY_CODE_SHIFT] = 0x2a, | |
68 | [Q_KEY_CODE_SHIFT_R] = 0x36, | |
69 | ||
70 | [Q_KEY_CODE_ALT] = 0x38, | |
71 | [Q_KEY_CODE_ALT_R] = 0xb8, | |
72 | [Q_KEY_CODE_ALTGR] = 0x64, | |
73 | [Q_KEY_CODE_ALTGR_R] = 0xe4, | |
74 | [Q_KEY_CODE_CTRL] = 0x1d, | |
75 | [Q_KEY_CODE_CTRL_R] = 0x9d, | |
76 | ||
77 | [Q_KEY_CODE_MENU] = 0xdd, | |
78 | ||
79 | [Q_KEY_CODE_ESC] = 0x01, | |
80 | ||
81 | [Q_KEY_CODE_1] = 0x02, | |
82 | [Q_KEY_CODE_2] = 0x03, | |
83 | [Q_KEY_CODE_3] = 0x04, | |
84 | [Q_KEY_CODE_4] = 0x05, | |
85 | [Q_KEY_CODE_5] = 0x06, | |
86 | [Q_KEY_CODE_6] = 0x07, | |
87 | [Q_KEY_CODE_7] = 0x08, | |
88 | [Q_KEY_CODE_8] = 0x09, | |
89 | [Q_KEY_CODE_9] = 0x0a, | |
90 | [Q_KEY_CODE_0] = 0x0b, | |
91 | [Q_KEY_CODE_MINUS] = 0x0c, | |
92 | [Q_KEY_CODE_EQUAL] = 0x0d, | |
93 | [Q_KEY_CODE_BACKSPACE] = 0x0e, | |
94 | ||
95 | [Q_KEY_CODE_TAB] = 0x0f, | |
96 | [Q_KEY_CODE_Q] = 0x10, | |
97 | [Q_KEY_CODE_W] = 0x11, | |
98 | [Q_KEY_CODE_E] = 0x12, | |
99 | [Q_KEY_CODE_R] = 0x13, | |
100 | [Q_KEY_CODE_T] = 0x14, | |
101 | [Q_KEY_CODE_Y] = 0x15, | |
102 | [Q_KEY_CODE_U] = 0x16, | |
103 | [Q_KEY_CODE_I] = 0x17, | |
104 | [Q_KEY_CODE_O] = 0x18, | |
105 | [Q_KEY_CODE_P] = 0x19, | |
106 | [Q_KEY_CODE_BRACKET_LEFT] = 0x1a, | |
107 | [Q_KEY_CODE_BRACKET_RIGHT] = 0x1b, | |
108 | [Q_KEY_CODE_RET] = 0x1c, | |
109 | ||
110 | [Q_KEY_CODE_A] = 0x1e, | |
111 | [Q_KEY_CODE_S] = 0x1f, | |
112 | [Q_KEY_CODE_D] = 0x20, | |
113 | [Q_KEY_CODE_F] = 0x21, | |
114 | [Q_KEY_CODE_G] = 0x22, | |
115 | [Q_KEY_CODE_H] = 0x23, | |
116 | [Q_KEY_CODE_J] = 0x24, | |
117 | [Q_KEY_CODE_K] = 0x25, | |
118 | [Q_KEY_CODE_L] = 0x26, | |
119 | [Q_KEY_CODE_SEMICOLON] = 0x27, | |
120 | [Q_KEY_CODE_APOSTROPHE] = 0x28, | |
121 | [Q_KEY_CODE_GRAVE_ACCENT] = 0x29, | |
122 | ||
123 | [Q_KEY_CODE_BACKSLASH] = 0x2b, | |
124 | [Q_KEY_CODE_Z] = 0x2c, | |
125 | [Q_KEY_CODE_X] = 0x2d, | |
126 | [Q_KEY_CODE_C] = 0x2e, | |
127 | [Q_KEY_CODE_V] = 0x2f, | |
128 | [Q_KEY_CODE_B] = 0x30, | |
129 | [Q_KEY_CODE_N] = 0x31, | |
130 | [Q_KEY_CODE_M] = 0x32, | |
131 | [Q_KEY_CODE_COMMA] = 0x33, | |
132 | [Q_KEY_CODE_DOT] = 0x34, | |
133 | [Q_KEY_CODE_SLASH] = 0x35, | |
134 | ||
135 | [Q_KEY_CODE_ASTERISK] = 0x37, | |
136 | ||
137 | [Q_KEY_CODE_SPC] = 0x39, | |
138 | [Q_KEY_CODE_CAPS_LOCK] = 0x3a, | |
139 | [Q_KEY_CODE_F1] = 0x3b, | |
140 | [Q_KEY_CODE_F2] = 0x3c, | |
141 | [Q_KEY_CODE_F3] = 0x3d, | |
142 | [Q_KEY_CODE_F4] = 0x3e, | |
143 | [Q_KEY_CODE_F5] = 0x3f, | |
144 | [Q_KEY_CODE_F6] = 0x40, | |
145 | [Q_KEY_CODE_F7] = 0x41, | |
146 | [Q_KEY_CODE_F8] = 0x42, | |
147 | [Q_KEY_CODE_F9] = 0x43, | |
148 | [Q_KEY_CODE_F10] = 0x44, | |
149 | [Q_KEY_CODE_NUM_LOCK] = 0x45, | |
150 | [Q_KEY_CODE_SCROLL_LOCK] = 0x46, | |
151 | ||
152 | [Q_KEY_CODE_KP_DIVIDE] = 0xb5, | |
153 | [Q_KEY_CODE_KP_MULTIPLY] = 0x37, | |
154 | [Q_KEY_CODE_KP_SUBTRACT] = 0x4a, | |
155 | [Q_KEY_CODE_KP_ADD] = 0x4e, | |
156 | [Q_KEY_CODE_KP_ENTER] = 0x9c, | |
157 | [Q_KEY_CODE_KP_DECIMAL] = 0x53, | |
158 | [Q_KEY_CODE_SYSRQ] = 0x54, | |
159 | ||
160 | [Q_KEY_CODE_KP_0] = 0x52, | |
161 | [Q_KEY_CODE_KP_1] = 0x4f, | |
162 | [Q_KEY_CODE_KP_2] = 0x50, | |
163 | [Q_KEY_CODE_KP_3] = 0x51, | |
164 | [Q_KEY_CODE_KP_4] = 0x4b, | |
165 | [Q_KEY_CODE_KP_5] = 0x4c, | |
166 | [Q_KEY_CODE_KP_6] = 0x4d, | |
167 | [Q_KEY_CODE_KP_7] = 0x47, | |
168 | [Q_KEY_CODE_KP_8] = 0x48, | |
169 | [Q_KEY_CODE_KP_9] = 0x49, | |
170 | ||
171 | [Q_KEY_CODE_LESS] = 0x56, | |
172 | ||
173 | [Q_KEY_CODE_F11] = 0x57, | |
174 | [Q_KEY_CODE_F12] = 0x58, | |
175 | ||
176 | [Q_KEY_CODE_PRINT] = 0xb7, | |
177 | ||
178 | [Q_KEY_CODE_HOME] = 0xc7, | |
179 | [Q_KEY_CODE_PGUP] = 0xc9, | |
180 | [Q_KEY_CODE_PGDN] = 0xd1, | |
181 | [Q_KEY_CODE_END] = 0xcf, | |
182 | ||
183 | [Q_KEY_CODE_LEFT] = 0xcb, | |
184 | [Q_KEY_CODE_UP] = 0xc8, | |
185 | [Q_KEY_CODE_DOWN] = 0xd0, | |
186 | [Q_KEY_CODE_RIGHT] = 0xcd, | |
187 | ||
188 | [Q_KEY_CODE_INSERT] = 0xd2, | |
189 | [Q_KEY_CODE_DELETE] = 0xd3, | |
190 | #ifdef NEED_CPU_H | |
191 | #if defined(TARGET_SPARC) && !defined(TARGET_SPARC64) | |
192 | [Q_KEY_CODE_STOP] = 0xf0, | |
193 | [Q_KEY_CODE_AGAIN] = 0xf1, | |
194 | [Q_KEY_CODE_PROPS] = 0xf2, | |
195 | [Q_KEY_CODE_UNDO] = 0xf3, | |
196 | [Q_KEY_CODE_FRONT] = 0xf4, | |
197 | [Q_KEY_CODE_COPY] = 0xf5, | |
198 | [Q_KEY_CODE_OPEN] = 0xf6, | |
199 | [Q_KEY_CODE_PASTE] = 0xf7, | |
200 | [Q_KEY_CODE_FIND] = 0xf8, | |
201 | [Q_KEY_CODE_CUT] = 0xf9, | |
202 | [Q_KEY_CODE_LF] = 0xfa, | |
203 | [Q_KEY_CODE_HELP] = 0xfb, | |
204 | [Q_KEY_CODE_META_L] = 0xfc, | |
205 | [Q_KEY_CODE_META_R] = 0xfd, | |
206 | [Q_KEY_CODE_COMPOSE] = 0xfe, | |
207 | #endif | |
208 | #endif | |
209 | [Q_KEY_CODE_MAX] = 0, | |
210 | }; | |
211 | ||
212 | int index_from_key(const char *key) | |
213 | { | |
214 | int i; | |
215 | ||
216 | for (i = 0; QKeyCode_lookup[i] != NULL; i++) { | |
217 | if (!strcmp(key, QKeyCode_lookup[i])) { | |
218 | break; | |
219 | } | |
220 | } | |
221 | ||
222 | /* Return Q_KEY_CODE_MAX if the key is invalid */ | |
223 | return i; | |
224 | } | |
225 | ||
226 | int index_from_keycode(int code) | |
227 | { | |
228 | int i; | |
229 | ||
230 | for (i = 0; i < Q_KEY_CODE_MAX; i++) { | |
231 | if (key_defs[i] == code) { | |
232 | break; | |
233 | } | |
234 | } | |
235 | ||
236 | /* Return Q_KEY_CODE_MAX if the code is invalid */ | |
237 | return i; | |
238 | } | |
239 | ||
240 | static int *keycodes; | |
241 | static int keycodes_size; | |
242 | static QEMUTimer *key_timer; | |
243 | ||
244 | static int keycode_from_keyvalue(const KeyValue *value) | |
245 | { | |
246 | if (value->kind == KEY_VALUE_KIND_QCODE) { | |
247 | return key_defs[value->qcode]; | |
248 | } else { | |
249 | assert(value->kind == KEY_VALUE_KIND_NUMBER); | |
250 | return value->number; | |
251 | } | |
252 | } | |
253 | ||
254 | static void free_keycodes(void) | |
255 | { | |
256 | g_free(keycodes); | |
257 | keycodes = NULL; | |
258 | keycodes_size = 0; | |
259 | } | |
260 | ||
261 | static void release_keys(void *opaque) | |
262 | { | |
263 | while (keycodes_size > 0) { | |
264 | if (keycodes[--keycodes_size] & SCANCODE_GREY) { | |
265 | kbd_put_keycode(SCANCODE_EMUL0); | |
266 | } | |
267 | kbd_put_keycode(keycodes[keycodes_size] | SCANCODE_UP); | |
268 | } | |
269 | ||
270 | free_keycodes(); | |
271 | } | |
272 | ||
273 | void qmp_send_key(KeyValueList *keys, bool has_hold_time, int64_t hold_time, | |
274 | Error **errp) | |
275 | { | |
276 | int keycode; | |
277 | KeyValueList *p; | |
278 | ||
279 | if (!key_timer) { | |
280 | key_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, release_keys, NULL); | |
281 | } | |
282 | ||
283 | if (keycodes != NULL) { | |
284 | timer_del(key_timer); | |
285 | release_keys(NULL); | |
286 | } | |
287 | ||
288 | if (!has_hold_time) { | |
289 | hold_time = 100; | |
290 | } | |
291 | ||
292 | for (p = keys; p != NULL; p = p->next) { | |
293 | /* key down events */ | |
294 | keycode = keycode_from_keyvalue(p->value); | |
295 | if (keycode < 0x01 || keycode > 0xff) { | |
296 | error_setg(errp, "invalid hex keycode 0x%x", keycode); | |
297 | free_keycodes(); | |
298 | return; | |
299 | } | |
300 | ||
301 | if (keycode & SCANCODE_GREY) { | |
302 | kbd_put_keycode(SCANCODE_EMUL0); | |
303 | } | |
304 | kbd_put_keycode(keycode & SCANCODE_KEYCODEMASK); | |
305 | ||
306 | keycodes = g_realloc(keycodes, sizeof(int) * (keycodes_size + 1)); | |
307 | keycodes[keycodes_size++] = keycode; | |
308 | } | |
309 | ||
310 | /* delayed key up events */ | |
311 | timer_mod(key_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + | |
312 | muldiv64(get_ticks_per_sec(), hold_time, 1000)); | |
313 | } | |
314 | ||
315 | QEMUPutKbdEntry *qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque) | |
316 | { | |
317 | QEMUPutKbdEntry *entry; | |
318 | ||
319 | entry = g_malloc0(sizeof(QEMUPutKbdEntry)); | |
320 | entry->put_kbd = func; | |
321 | entry->opaque = opaque; | |
322 | QTAILQ_INSERT_HEAD(&kbd_handlers, entry, next); | |
323 | return entry; | |
324 | } | |
325 | ||
326 | void qemu_remove_kbd_event_handler(QEMUPutKbdEntry *entry) | |
327 | { | |
328 | QTAILQ_REMOVE(&kbd_handlers, entry, next); | |
329 | } | |
330 | ||
331 | static void check_mode_change(void) | |
332 | { | |
333 | static int current_is_absolute, current_has_absolute; | |
334 | int is_absolute; | |
335 | int has_absolute; | |
336 | ||
337 | is_absolute = kbd_mouse_is_absolute(); | |
338 | has_absolute = kbd_mouse_has_absolute(); | |
339 | ||
340 | if (is_absolute != current_is_absolute || | |
341 | has_absolute != current_has_absolute) { | |
342 | notifier_list_notify(&mouse_mode_notifiers, NULL); | |
343 | } | |
344 | ||
345 | current_is_absolute = is_absolute; | |
346 | current_has_absolute = has_absolute; | |
347 | } | |
348 | ||
349 | QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, | |
350 | void *opaque, int absolute, | |
351 | const char *name) | |
352 | { | |
353 | QEMUPutMouseEntry *s; | |
354 | static int mouse_index = 0; | |
355 | ||
356 | s = g_malloc0(sizeof(QEMUPutMouseEntry)); | |
357 | ||
358 | s->qemu_put_mouse_event = func; | |
359 | s->qemu_put_mouse_event_opaque = opaque; | |
360 | s->qemu_put_mouse_event_absolute = absolute; | |
361 | s->qemu_put_mouse_event_name = g_strdup(name); | |
362 | s->index = mouse_index++; | |
363 | ||
364 | QTAILQ_INSERT_TAIL(&mouse_handlers, s, node); | |
365 | ||
366 | check_mode_change(); | |
367 | ||
368 | return s; | |
369 | } | |
370 | ||
371 | void qemu_activate_mouse_event_handler(QEMUPutMouseEntry *entry) | |
372 | { | |
373 | QTAILQ_REMOVE(&mouse_handlers, entry, node); | |
374 | QTAILQ_INSERT_HEAD(&mouse_handlers, entry, node); | |
375 | ||
376 | check_mode_change(); | |
377 | } | |
378 | ||
379 | void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry) | |
380 | { | |
381 | QTAILQ_REMOVE(&mouse_handlers, entry, node); | |
382 | ||
383 | g_free(entry->qemu_put_mouse_event_name); | |
384 | g_free(entry); | |
385 | ||
386 | check_mode_change(); | |
387 | } | |
388 | ||
389 | QEMUPutLEDEntry *qemu_add_led_event_handler(QEMUPutLEDEvent *func, | |
390 | void *opaque) | |
391 | { | |
392 | QEMUPutLEDEntry *s; | |
393 | ||
394 | s = g_malloc0(sizeof(QEMUPutLEDEntry)); | |
395 | ||
396 | s->put_led = func; | |
397 | s->opaque = opaque; | |
398 | QTAILQ_INSERT_TAIL(&led_handlers, s, next); | |
399 | return s; | |
400 | } | |
401 | ||
402 | void qemu_remove_led_event_handler(QEMUPutLEDEntry *entry) | |
403 | { | |
404 | if (entry == NULL) | |
405 | return; | |
406 | QTAILQ_REMOVE(&led_handlers, entry, next); | |
407 | g_free(entry); | |
408 | } | |
409 | ||
410 | void kbd_put_keycode(int keycode) | |
411 | { | |
412 | QEMUPutKbdEntry *entry = QTAILQ_FIRST(&kbd_handlers); | |
413 | ||
414 | if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { | |
415 | return; | |
416 | } | |
417 | if (entry) { | |
418 | entry->put_kbd(entry->opaque, keycode); | |
419 | } | |
420 | } | |
421 | ||
422 | void kbd_put_ledstate(int ledstate) | |
423 | { | |
424 | QEMUPutLEDEntry *cursor; | |
425 | ||
426 | QTAILQ_FOREACH(cursor, &led_handlers, next) { | |
427 | cursor->put_led(cursor->opaque, ledstate); | |
428 | } | |
429 | } | |
430 | ||
431 | void kbd_mouse_event(int dx, int dy, int dz, int buttons_state) | |
432 | { | |
433 | QEMUPutMouseEntry *entry; | |
434 | QEMUPutMouseEvent *mouse_event; | |
435 | void *mouse_event_opaque; | |
436 | int width, height; | |
437 | ||
438 | if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) { | |
439 | return; | |
440 | } | |
441 | if (QTAILQ_EMPTY(&mouse_handlers)) { | |
442 | return; | |
443 | } | |
444 | ||
445 | entry = QTAILQ_FIRST(&mouse_handlers); | |
446 | ||
447 | mouse_event = entry->qemu_put_mouse_event; | |
448 | mouse_event_opaque = entry->qemu_put_mouse_event_opaque; | |
449 | ||
450 | if (mouse_event) { | |
451 | if (entry->qemu_put_mouse_event_absolute) { | |
452 | width = 0x7fff; | |
453 | height = 0x7fff; | |
454 | } else { | |
455 | width = graphic_width - 1; | |
456 | height = graphic_height - 1; | |
457 | } | |
458 | ||
459 | switch (graphic_rotate) { | |
460 | case 0: | |
461 | mouse_event(mouse_event_opaque, | |
462 | dx, dy, dz, buttons_state); | |
463 | break; | |
464 | case 90: | |
465 | mouse_event(mouse_event_opaque, | |
466 | width - dy, dx, dz, buttons_state); | |
467 | break; | |
468 | case 180: | |
469 | mouse_event(mouse_event_opaque, | |
470 | width - dx, height - dy, dz, buttons_state); | |
471 | break; | |
472 | case 270: | |
473 | mouse_event(mouse_event_opaque, | |
474 | dy, height - dx, dz, buttons_state); | |
475 | break; | |
476 | } | |
477 | } | |
478 | } | |
479 | ||
480 | int kbd_mouse_is_absolute(void) | |
481 | { | |
482 | if (QTAILQ_EMPTY(&mouse_handlers)) { | |
483 | return 0; | |
484 | } | |
485 | ||
486 | return QTAILQ_FIRST(&mouse_handlers)->qemu_put_mouse_event_absolute; | |
487 | } | |
488 | ||
489 | int kbd_mouse_has_absolute(void) | |
490 | { | |
491 | QEMUPutMouseEntry *entry; | |
492 | ||
493 | QTAILQ_FOREACH(entry, &mouse_handlers, node) { | |
494 | if (entry->qemu_put_mouse_event_absolute) { | |
495 | return 1; | |
496 | } | |
497 | } | |
498 | ||
499 | return 0; | |
500 | } | |
501 | ||
502 | MouseInfoList *qmp_query_mice(Error **errp) | |
503 | { | |
504 | MouseInfoList *mice_list = NULL; | |
505 | QEMUPutMouseEntry *cursor; | |
506 | bool current = true; | |
507 | ||
508 | QTAILQ_FOREACH(cursor, &mouse_handlers, node) { | |
509 | MouseInfoList *info = g_malloc0(sizeof(*info)); | |
510 | info->value = g_malloc0(sizeof(*info->value)); | |
511 | info->value->name = g_strdup(cursor->qemu_put_mouse_event_name); | |
512 | info->value->index = cursor->index; | |
513 | info->value->absolute = !!cursor->qemu_put_mouse_event_absolute; | |
514 | info->value->current = current; | |
515 | ||
516 | current = false; | |
517 | ||
518 | info->next = mice_list; | |
519 | mice_list = info; | |
520 | } | |
521 | ||
522 | return mice_list; | |
523 | } | |
524 | ||
525 | void do_mouse_set(Monitor *mon, const QDict *qdict) | |
526 | { | |
527 | QEMUPutMouseEntry *cursor; | |
528 | int index = qdict_get_int(qdict, "index"); | |
529 | int found = 0; | |
530 | ||
531 | if (QTAILQ_EMPTY(&mouse_handlers)) { | |
532 | monitor_printf(mon, "No mouse devices connected\n"); | |
533 | return; | |
534 | } | |
535 | ||
536 | QTAILQ_FOREACH(cursor, &mouse_handlers, node) { | |
537 | if (cursor->index == index) { | |
538 | found = 1; | |
539 | qemu_activate_mouse_event_handler(cursor); | |
540 | break; | |
541 | } | |
542 | } | |
543 | ||
544 | if (!found) { | |
545 | monitor_printf(mon, "Mouse at given index not found\n"); | |
546 | } | |
547 | ||
548 | check_mode_change(); | |
549 | } | |
550 | ||
551 | void qemu_add_mouse_mode_change_notifier(Notifier *notify) | |
552 | { | |
553 | notifier_list_add(&mouse_mode_notifiers, notify); | |
554 | } | |
555 | ||
556 | void qemu_remove_mouse_mode_change_notifier(Notifier *notify) | |
557 | { | |
558 | notifier_remove(notify); | |
559 | } |