Annotation of qemu/input.c, revision 1.1

1.1     ! root        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.h"
        !            26: #include "net.h"
        !            27: #include "monitor.h"
        !            28: #include "console.h"
        !            29: #include "qjson.h"
        !            30: 
        !            31: static QEMUPutKBDEvent *qemu_put_kbd_event;
        !            32: static void *qemu_put_kbd_event_opaque;
        !            33: static QTAILQ_HEAD(, QEMUPutLEDEntry) led_handlers = QTAILQ_HEAD_INITIALIZER(led_handlers);
        !            34: static QTAILQ_HEAD(, QEMUPutMouseEntry) mouse_handlers =
        !            35:     QTAILQ_HEAD_INITIALIZER(mouse_handlers);
        !            36: static NotifierList mouse_mode_notifiers = 
        !            37:     NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
        !            38: 
        !            39: void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
        !            40: {
        !            41:     qemu_put_kbd_event_opaque = opaque;
        !            42:     qemu_put_kbd_event = func;
        !            43: }
        !            44: 
        !            45: void qemu_remove_kbd_event_handler(void)
        !            46: {
        !            47:     qemu_put_kbd_event_opaque = NULL;
        !            48:     qemu_put_kbd_event = NULL;
        !            49: }
        !            50: 
        !            51: static void check_mode_change(void)
        !            52: {
        !            53:     static int current_is_absolute, current_has_absolute;
        !            54:     int is_absolute;
        !            55:     int has_absolute;
        !            56: 
        !            57:     is_absolute = kbd_mouse_is_absolute();
        !            58:     has_absolute = kbd_mouse_has_absolute();
        !            59: 
        !            60:     if (is_absolute != current_is_absolute ||
        !            61:         has_absolute != current_has_absolute) {
        !            62:         notifier_list_notify(&mouse_mode_notifiers);
        !            63:     }
        !            64: 
        !            65:     current_is_absolute = is_absolute;
        !            66:     current_has_absolute = has_absolute;
        !            67: }
        !            68: 
        !            69: QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
        !            70:                                                 void *opaque, int absolute,
        !            71:                                                 const char *name)
        !            72: {
        !            73:     QEMUPutMouseEntry *s;
        !            74:     static int mouse_index = 0;
        !            75: 
        !            76:     s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
        !            77: 
        !            78:     s->qemu_put_mouse_event = func;
        !            79:     s->qemu_put_mouse_event_opaque = opaque;
        !            80:     s->qemu_put_mouse_event_absolute = absolute;
        !            81:     s->qemu_put_mouse_event_name = qemu_strdup(name);
        !            82:     s->index = mouse_index++;
        !            83: 
        !            84:     QTAILQ_INSERT_TAIL(&mouse_handlers, s, node);
        !            85: 
        !            86:     check_mode_change();
        !            87: 
        !            88:     return s;
        !            89: }
        !            90: 
        !            91: void qemu_activate_mouse_event_handler(QEMUPutMouseEntry *entry)
        !            92: {
        !            93:     QTAILQ_REMOVE(&mouse_handlers, entry, node);
        !            94:     QTAILQ_INSERT_HEAD(&mouse_handlers, entry, node);
        !            95: 
        !            96:     check_mode_change();
        !            97: }
        !            98: 
        !            99: void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
        !           100: {
        !           101:     QTAILQ_REMOVE(&mouse_handlers, entry, node);
        !           102: 
        !           103:     qemu_free(entry->qemu_put_mouse_event_name);
        !           104:     qemu_free(entry);
        !           105: 
        !           106:     check_mode_change();
        !           107: }
        !           108: 
        !           109: QEMUPutLEDEntry *qemu_add_led_event_handler(QEMUPutLEDEvent *func,
        !           110:                                             void *opaque)
        !           111: {
        !           112:     QEMUPutLEDEntry *s;
        !           113: 
        !           114:     s = qemu_mallocz(sizeof(QEMUPutLEDEntry));
        !           115: 
        !           116:     s->put_led = func;
        !           117:     s->opaque = opaque;
        !           118:     QTAILQ_INSERT_TAIL(&led_handlers, s, next);
        !           119:     return s;
        !           120: }
        !           121: 
        !           122: void qemu_remove_led_event_handler(QEMUPutLEDEntry *entry)
        !           123: {
        !           124:     if (entry == NULL)
        !           125:         return;
        !           126:     QTAILQ_REMOVE(&led_handlers, entry, next);
        !           127:     qemu_free(entry);
        !           128: }
        !           129: 
        !           130: void kbd_put_keycode(int keycode)
        !           131: {
        !           132:     if (qemu_put_kbd_event) {
        !           133:         qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
        !           134:     }
        !           135: }
        !           136: 
        !           137: void kbd_put_ledstate(int ledstate)
        !           138: {
        !           139:     QEMUPutLEDEntry *cursor;
        !           140: 
        !           141:     QTAILQ_FOREACH(cursor, &led_handlers, next) {
        !           142:         cursor->put_led(cursor->opaque, ledstate);
        !           143:     }
        !           144: }
        !           145: 
        !           146: void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
        !           147: {
        !           148:     QEMUPutMouseEntry *entry;
        !           149:     QEMUPutMouseEvent *mouse_event;
        !           150:     void *mouse_event_opaque;
        !           151:     int width;
        !           152: 
        !           153:     if (QTAILQ_EMPTY(&mouse_handlers)) {
        !           154:         return;
        !           155:     }
        !           156: 
        !           157:     entry = QTAILQ_FIRST(&mouse_handlers);
        !           158: 
        !           159:     mouse_event = entry->qemu_put_mouse_event;
        !           160:     mouse_event_opaque = entry->qemu_put_mouse_event_opaque;
        !           161: 
        !           162:     if (mouse_event) {
        !           163:         if (graphic_rotate) {
        !           164:             if (entry->qemu_put_mouse_event_absolute)
        !           165:                 width = 0x7fff;
        !           166:             else
        !           167:                 width = graphic_width - 1;
        !           168:             mouse_event(mouse_event_opaque,
        !           169:                         width - dy, dx, dz, buttons_state);
        !           170:         } else
        !           171:             mouse_event(mouse_event_opaque,
        !           172:                         dx, dy, dz, buttons_state);
        !           173:     }
        !           174: }
        !           175: 
        !           176: int kbd_mouse_is_absolute(void)
        !           177: {
        !           178:     if (QTAILQ_EMPTY(&mouse_handlers)) {
        !           179:         return 0;
        !           180:     }
        !           181: 
        !           182:     return QTAILQ_FIRST(&mouse_handlers)->qemu_put_mouse_event_absolute;
        !           183: }
        !           184: 
        !           185: int kbd_mouse_has_absolute(void)
        !           186: {
        !           187:     QEMUPutMouseEntry *entry;
        !           188: 
        !           189:     QTAILQ_FOREACH(entry, &mouse_handlers, node) {
        !           190:         if (entry->qemu_put_mouse_event_absolute) {
        !           191:             return 1;
        !           192:         }
        !           193:     }
        !           194: 
        !           195:     return 0;
        !           196: }
        !           197: 
        !           198: static void info_mice_iter(QObject *data, void *opaque)
        !           199: {
        !           200:     QDict *mouse;
        !           201:     Monitor *mon = opaque;
        !           202: 
        !           203:     mouse = qobject_to_qdict(data);
        !           204:     monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n",
        !           205:                   (qdict_get_bool(mouse, "current") ? '*' : ' '),
        !           206:                    qdict_get_int(mouse, "index"), qdict_get_str(mouse, "name"),
        !           207:                    qdict_get_bool(mouse, "absolute") ? " (absolute)" : "");
        !           208: }
        !           209: 
        !           210: void do_info_mice_print(Monitor *mon, const QObject *data)
        !           211: {
        !           212:     QList *mice_list;
        !           213: 
        !           214:     mice_list = qobject_to_qlist(data);
        !           215:     if (qlist_empty(mice_list)) {
        !           216:         monitor_printf(mon, "No mouse devices connected\n");
        !           217:         return;
        !           218:     }
        !           219: 
        !           220:     qlist_iter(mice_list, info_mice_iter, mon);
        !           221: }
        !           222: 
        !           223: void do_info_mice(Monitor *mon, QObject **ret_data)
        !           224: {
        !           225:     QEMUPutMouseEntry *cursor;
        !           226:     QList *mice_list;
        !           227:     int current;
        !           228: 
        !           229:     mice_list = qlist_new();
        !           230: 
        !           231:     if (QTAILQ_EMPTY(&mouse_handlers)) {
        !           232:         goto out;
        !           233:     }
        !           234: 
        !           235:     current = QTAILQ_FIRST(&mouse_handlers)->index;
        !           236: 
        !           237:     QTAILQ_FOREACH(cursor, &mouse_handlers, node) {
        !           238:         QObject *obj;
        !           239:         obj = qobject_from_jsonf("{ 'name': %s,"
        !           240:                                  "  'index': %d,"
        !           241:                                  "  'current': %i,"
        !           242:                                  "  'absolute': %i }",
        !           243:                                  cursor->qemu_put_mouse_event_name,
        !           244:                                  cursor->index,
        !           245:                                  cursor->index == current,
        !           246:                                  !!cursor->qemu_put_mouse_event_absolute);
        !           247:         qlist_append_obj(mice_list, obj);
        !           248:     }
        !           249: 
        !           250: out:
        !           251:     *ret_data = QOBJECT(mice_list);
        !           252: }
        !           253: 
        !           254: void do_mouse_set(Monitor *mon, const QDict *qdict)
        !           255: {
        !           256:     QEMUPutMouseEntry *cursor;
        !           257:     int index = qdict_get_int(qdict, "index");
        !           258:     int found = 0;
        !           259: 
        !           260:     if (QTAILQ_EMPTY(&mouse_handlers)) {
        !           261:         monitor_printf(mon, "No mouse devices connected\n");
        !           262:         return;
        !           263:     }
        !           264: 
        !           265:     QTAILQ_FOREACH(cursor, &mouse_handlers, node) {
        !           266:         if (cursor->index == index) {
        !           267:             found = 1;
        !           268:             qemu_activate_mouse_event_handler(cursor);
        !           269:             break;
        !           270:         }
        !           271:     }
        !           272: 
        !           273:     if (!found) {
        !           274:         monitor_printf(mon, "Mouse at given index not found\n");
        !           275:     }
        !           276: 
        !           277:     check_mode_change();
        !           278: }
        !           279: 
        !           280: void qemu_add_mouse_mode_change_notifier(Notifier *notify)
        !           281: {
        !           282:     notifier_list_add(&mouse_mode_notifiers, notify);
        !           283: }
        !           284: 
        !           285: void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
        !           286: {
        !           287:     notifier_list_remove(&mouse_mode_notifiers, notify);
        !           288: }

unix.superglobalmegacorp.com