ui/input.c

   1 #include "hw/qdev.h"
   2 #include "sysemu/sysemu.h"
   3 #include "qapi-types.h"
   4 #include "qmp-commands.h"
   5 #include "trace.h"
   6 #include "ui/input.h"
   7 #include "ui/console.h"
   8
   9 struct QemuInputHandlerState {
  10     DeviceState       *dev;
  11     QemuInputHandler  *handler;
  12     int               id;
  13     int               events;
  14     QemuConsole       *con;
  15     QTAILQ_ENTRY(QemuInputHandlerState) node;
  16 };
  17 static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
  18     QTAILQ_HEAD_INITIALIZER(handlers);
  19 static NotifierList mouse_mode_notifiers =
  20     NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
  21
  22 QemuInputHandlerState *qemu_input_handler_register(DeviceState *dev,
  23                                                    QemuInputHandler *handler)
  24 {
  25     QemuInputHandlerState *s = g_new0(QemuInputHandlerState, 1);
  26     static int id = 1;
  27
  28     s->dev = dev;
  29     s->handler = handler;
  30     s->id = id++;
  31     QTAILQ_INSERT_TAIL(&handlers, s, node);
  32
  33     qemu_input_check_mode_change();
  34     return s;
  35 }
  36
  37 void qemu_input_handler_activate(QemuInputHandlerState *s)
  38 {
  39     QTAILQ_REMOVE(&handlers, s, node);
  40     QTAILQ_INSERT_HEAD(&handlers, s, node);
  41     qemu_input_check_mode_change();
  42 }
  43
  44 void qemu_input_handler_deactivate(QemuInputHandlerState *s)
  45 {
  46     QTAILQ_REMOVE(&handlers, s, node);
  47     QTAILQ_INSERT_TAIL(&handlers, s, node);
  48     qemu_input_check_mode_change();
  49 }
  50
  51 void qemu_input_handler_unregister(QemuInputHandlerState *s)
  52 {
  53     QTAILQ_REMOVE(&handlers, s, node);
  54     g_free(s);
  55     qemu_input_check_mode_change();
  56 }
  57
  58 void qemu_input_handler_bind(QemuInputHandlerState *s,
  59                              const char *device_id, int head,
  60                              Error **errp)
  61 {
  62     DeviceState *dev;
  63     QemuConsole *con;
  64
  65     dev = qdev_find_recursive(sysbus_get_default(), device_id);
  66     if (dev == NULL) {
  67         error_set(errp, QERR_DEVICE_NOT_FOUND, device_id);
  68         return;
  69     }
  70
  71     con = qemu_console_lookup_by_device(dev, head);
  72     if (con == NULL) {
  73         error_setg(errp, "Device %s is not bound to a QemuConsole", device_id);
  74         return;
  75     }
  76
  77     s->con = con;
  78 }
  79
  80 static QemuInputHandlerState*
  81 qemu_input_find_handler(uint32_t mask, QemuConsole *con)
  82 {
  83     QemuInputHandlerState *s;
  84
  85     QTAILQ_FOREACH(s, &handlers, node) {
  86         if (s->con == NULL || s->con != con) {
  87             continue;
  88         }
  89         if (mask & s->handler->mask) {
  90             return s;
  91         }
  92     }
  93
  94     QTAILQ_FOREACH(s, &handlers, node) {
  95         if (s->con != NULL) {
  96             continue;
  97         }
  98         if (mask & s->handler->mask) {
  99             return s;
 100         }
 101     }
 102     return NULL;
 103 }
 104
 105 static void qemu_input_transform_abs_rotate(InputEvent *evt)
 106 {
 107     switch (graphic_rotate) {
 108     case 90:
 109         if (evt->abs->axis == INPUT_AXIS_X) {
 110             evt->abs->axis = INPUT_AXIS_Y;
 111         } else if (evt->abs->axis == INPUT_AXIS_Y) {
 112             evt->abs->axis = INPUT_AXIS_X;
 113             evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value;
 114         }
 115         break;
 116     case 180:
 117         evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value;
 118         break;
 119     case 270:
 120         if (evt->abs->axis == INPUT_AXIS_X) {
 121             evt->abs->axis = INPUT_AXIS_Y;
 122             evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value;
 123         } else if (evt->abs->axis == INPUT_AXIS_Y) {
 124             evt->abs->axis = INPUT_AXIS_X;
 125         }
 126         break;
 127     }
 128 }
 129
 130 static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
 131 {
 132     const char *name;
 133     int qcode, idx = -1;
 134
 135     if (src) {
 136         idx = qemu_console_get_index(src);
 137     }
 138     switch (evt->kind) {
 139     case INPUT_EVENT_KIND_KEY:
 140         switch (evt->key->key->kind) {
 141         case KEY_VALUE_KIND_NUMBER:
 142             qcode = qemu_input_key_number_to_qcode(evt->key->key->number);
 143             name = QKeyCode_lookup[qcode];
 144             trace_input_event_key_number(idx, evt->key->key->number,
 145                                          name, evt->key->down);
 146             break;
 147         case KEY_VALUE_KIND_QCODE:
 148             name = QKeyCode_lookup[evt->key->key->qcode];
 149             trace_input_event_key_qcode(idx, name, evt->key->down);
 150             break;
 151         case KEY_VALUE_KIND_MAX:
 152             /* keep gcc happy */
 153             break;
 154         }
 155         break;
 156     case INPUT_EVENT_KIND_BTN:
 157         name = InputButton_lookup[evt->btn->button];
 158         trace_input_event_btn(idx, name, evt->btn->down);
 159         break;
 160     case INPUT_EVENT_KIND_REL:
 161         name = InputAxis_lookup[evt->rel->axis];
 162         trace_input_event_rel(idx, name, evt->rel->value);
 163         break;
 164     case INPUT_EVENT_KIND_ABS:
 165         name = InputAxis_lookup[evt->abs->axis];
 166         trace_input_event_abs(idx, name, evt->abs->value);
 167         break;
 168     case INPUT_EVENT_KIND_MAX:
 169         /* keep gcc happy */
 170         break;
 171     }
 172 }
 173
 174 void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
 175 {
 176     QemuInputHandlerState *s;
 177
 178     if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
 179         return;
 180     }
 181
 182     qemu_input_event_trace(src, evt);
 183
 184     /* pre processing */
 185     if (graphic_rotate && (evt->kind == INPUT_EVENT_KIND_ABS)) {
 186             qemu_input_transform_abs_rotate(evt);
 187     }
 188
 189     /* send event */
 190     s = qemu_input_find_handler(1 << evt->kind, src);
 191     if (!s) {
 192         return;
 193     }
 194     s->handler->event(s->dev, src, evt);
 195     s->events++;
 196 }
 197
 198 void qemu_input_event_sync(void)
 199 {
 200     QemuInputHandlerState *s;
 201
 202     if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
 203         return;
 204     }
 205
 206     trace_input_event_sync();
 207
 208     QTAILQ_FOREACH(s, &handlers, node) {
 209         if (!s->events) {
 210             continue;
 211         }
 212         if (s->handler->sync) {
 213             s->handler->sync(s->dev);
 214         }
 215         s->events = 0;
 216     }
 217 }
 218
 219 InputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
 220 {
 221     InputEvent *evt = g_new0(InputEvent, 1);
 222     evt->key = g_new0(InputKeyEvent, 1);
 223     evt->kind = INPUT_EVENT_KIND_KEY;
 224     evt->key->key = key;
 225     evt->key->down = down;
 226     return evt;
 227 }
 228
 229 void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
 230 {
 231     InputEvent *evt;
 232     evt = qemu_input_event_new_key(key, down);
 233     qemu_input_event_send(src, evt);
 234     qemu_input_event_sync();
 235     qapi_free_InputEvent(evt);
 236 }
 237
 238 void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
 239 {
 240     KeyValue *key = g_new0(KeyValue, 1);
 241     key->kind = KEY_VALUE_KIND_NUMBER;
 242     key->number = num;
 243     qemu_input_event_send_key(src, key, down);
 244 }
 245
 246 void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
 247 {
 248     KeyValue *key = g_new0(KeyValue, 1);
 249     key->kind = KEY_VALUE_KIND_QCODE;
 250     key->qcode = q;
 251     qemu_input_event_send_key(src, key, down);
 252 }
 253
 254 InputEvent *qemu_input_event_new_btn(InputButton btn, bool down)
 255 {
 256     InputEvent *evt = g_new0(InputEvent, 1);
 257     evt->btn = g_new0(InputBtnEvent, 1);
 258     evt->kind = INPUT_EVENT_KIND_BTN;
 259     evt->btn->button = btn;
 260     evt->btn->down = down;
 261     return evt;
 262 }
 263
 264 void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
 265 {
 266     InputEvent *evt;
 267     evt = qemu_input_event_new_btn(btn, down);
 268     qemu_input_event_send(src, evt);
 269     qapi_free_InputEvent(evt);
 270 }
 271
 272 void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map,
 273                                uint32_t button_old, uint32_t button_new)
 274 {
 275     InputButton btn;
 276     uint32_t mask;
 277
 278     for (btn = 0; btn < INPUT_BUTTON_MAX; btn++) {
 279         mask = button_map[btn];
 280         if ((button_old & mask) == (button_new & mask)) {
 281             continue;
 282         }
 283         qemu_input_queue_btn(src, btn, button_new & mask);
 284     }
 285 }
 286
 287 bool qemu_input_is_absolute(void)
 288 {
 289     QemuInputHandlerState *s;
 290
 291     s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS,
 292                                 NULL);
 293     return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
 294 }
 295
 296 int qemu_input_scale_axis(int value, int size_in, int size_out)
 297 {
 298     if (size_in < 2) {
 299         return size_out / 2;
 300     }
 301     return (int64_t)value * (size_out - 1) / (size_in - 1);
 302 }
 303
 304 InputEvent *qemu_input_event_new_move(InputEventKind kind,
 305                                       InputAxis axis, int value)
 306 {
 307     InputEvent *evt = g_new0(InputEvent, 1);
 308     InputMoveEvent *move = g_new0(InputMoveEvent, 1);
 309
 310     evt->kind = kind;
 311     evt->data = move;
 312     move->axis = axis;
 313     move->value = value;
 314     return evt;
 315 }
 316
 317 void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
 318 {
 319     InputEvent *evt;
 320     evt = qemu_input_event_new_move(INPUT_EVENT_KIND_REL, axis, value);
 321     qemu_input_event_send(src, evt);
 322     qapi_free_InputEvent(evt);
 323 }
 324
 325 void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value, int size)
 326 {
 327     InputEvent *evt;
 328     int scaled = qemu_input_scale_axis(value, size, INPUT_EVENT_ABS_SIZE);
 329     evt = qemu_input_event_new_move(INPUT_EVENT_KIND_ABS, axis, scaled);
 330     qemu_input_event_send(src, evt);
 331     qapi_free_InputEvent(evt);
 332 }
 333
 334 void qemu_input_check_mode_change(void)
 335 {
 336     static int current_is_absolute;
 337     int is_absolute;
 338
 339     is_absolute = qemu_input_is_absolute();
 340
 341     if (is_absolute != current_is_absolute) {
 342         trace_input_mouse_mode(is_absolute);
 343         notifier_list_notify(&mouse_mode_notifiers, NULL);
 344     }
 345
 346     current_is_absolute = is_absolute;
 347 }
 348
 349 void qemu_add_mouse_mode_change_notifier(Notifier *notify)
 350 {
 351     notifier_list_add(&mouse_mode_notifiers, notify);
 352 }
 353
 354 void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
 355 {
 356     notifier_remove(notify);
 357 }
 358
 359 MouseInfoList *qmp_query_mice(Error **errp)
 360 {
 361     MouseInfoList *mice_list = NULL;
 362     MouseInfoList *info;
 363     QemuInputHandlerState *s;
 364     bool current = true;
 365
 366     QTAILQ_FOREACH(s, &handlers, node) {
 367         if (!(s->handler->mask &
 368               (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) {
 369             continue;
 370         }
 371
 372         info = g_new0(MouseInfoList, 1);
 373         info->value = g_new0(MouseInfo, 1);
 374         info->value->index = s->id;
 375         info->value->name = g_strdup(s->handler->name);
 376         info->value->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
 377         info->value->current = current;
 378
 379         current = false;
 380         info->next = mice_list;
 381         mice_list = info;
 382     }
 383
 384     return mice_list;
 385 }
 386
 387 void do_mouse_set(Monitor *mon, const QDict *qdict)
 388 {
 389     QemuInputHandlerState *s;
 390     int index = qdict_get_int(qdict, "index");
 391     int found = 0;
 392
 393     QTAILQ_FOREACH(s, &handlers, node) {
 394         if (s->id != index) {
 395             continue;
 396         }
 397         if (!(s->handler->mask & (INPUT_EVENT_MASK_REL |
 398                                   INPUT_EVENT_MASK_ABS))) {
 399             error_report("Input device '%s' is not a mouse", s->handler->name);
 400             return;
 401         }
 402         found = 1;
 403         qemu_input_handler_activate(s);
 404         break;
 405     }
 406
 407     if (!found) {
 408         error_report("Mouse at index '%d' not found", index);
 409     }
 410
 411     qemu_input_check_mode_change();
 412 }