[mirror_qemu.git] / ui / input.c

#include "hw/qdev.h"
#include "sysemu/sysemu.h"
#include "qapi-types.h"
#include "qmp-commands.h"
#include "trace.h"
#include "ui/input.h"
#include "ui/console.h"

struct QemuInputHandlerState {
    DeviceState       *dev;
    QemuInputHandler  *handler;
    int               id;
    int               events;
    QemuConsole       *con;
    QTAILQ_ENTRY(QemuInputHandlerState) node;
};

typedef struct QemuInputEventQueue QemuInputEventQueue;
struct QemuInputEventQueue {
    enum {
        QEMU_INPUT_QUEUE_DELAY = 1,
        QEMU_INPUT_QUEUE_EVENT,
        QEMU_INPUT_QUEUE_SYNC,
    } type;
    QEMUTimer *timer;
    uint32_t delay_ms;
    QemuConsole *src;
    InputEvent *evt;
    QTAILQ_ENTRY(QemuInputEventQueue) node;
};

static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
    QTAILQ_HEAD_INITIALIZER(handlers);
static NotifierList mouse_mode_notifiers =
    NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);

static QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue) kbd_queue =
    QTAILQ_HEAD_INITIALIZER(kbd_queue);
static QEMUTimer *kbd_timer;
static uint32_t kbd_default_delay_ms = 10;

QemuInputHandlerState *qemu_input_handler_register(DeviceState *dev,
                                                   QemuInputHandler *handler)
{
    QemuInputHandlerState *s = g_new0(QemuInputHandlerState, 1);
    static int id = 1;

    s->dev = dev;
    s->handler = handler;
    s->id = id++;
    QTAILQ_INSERT_TAIL(&handlers, s, node);

    qemu_input_check_mode_change();
    return s;
}

void qemu_input_handler_activate(QemuInputHandlerState *s)
{
    QTAILQ_REMOVE(&handlers, s, node);
    QTAILQ_INSERT_HEAD(&handlers, s, node);
    qemu_input_check_mode_change();
}

void qemu_input_handler_deactivate(QemuInputHandlerState *s)
{
    QTAILQ_REMOVE(&handlers, s, node);
    QTAILQ_INSERT_TAIL(&handlers, s, node);
    qemu_input_check_mode_change();
}

void qemu_input_handler_unregister(QemuInputHandlerState *s)
{
    QTAILQ_REMOVE(&handlers, s, node);
    g_free(s);
    qemu_input_check_mode_change();
}

void qemu_input_handler_bind(QemuInputHandlerState *s,
                             const char *device_id, int head,
                             Error **errp)
{
    DeviceState *dev;
    QemuConsole *con;

    dev = qdev_find_recursive(sysbus_get_default(), device_id);
    if (dev == NULL) {
        error_set(errp, QERR_DEVICE_NOT_FOUND, device_id);
        return;
    }

    con = qemu_console_lookup_by_device(dev, head);
    if (con == NULL) {
        error_setg(errp, "Device %s is not bound to a QemuConsole", device_id);
        return;
    }

    s->con = con;
}

static QemuInputHandlerState*
qemu_input_find_handler(uint32_t mask, QemuConsole *con)
{
    QemuInputHandlerState *s;

    QTAILQ_FOREACH(s, &handlers, node) {
        if (s->con == NULL || s->con != con) {
            continue;
        }
        if (mask & s->handler->mask) {
            return s;
        }
    }

    QTAILQ_FOREACH(s, &handlers, node) {
        if (s->con != NULL) {
            continue;
        }
        if (mask & s->handler->mask) {
            return s;
        }
    }
    return NULL;
}

void qmp_input_send_event(int64_t console, InputEventList *events,
                          Error **errp)
{
    InputEventList *e;
    QemuConsole *con;

    con = qemu_console_lookup_by_index(console);
    if (!con) {
        error_setg(errp, "console %" PRId64 " not found", console);
        return;
    }

    if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
        error_setg(errp, "VM not running");
        return;
    }

    for (e = events; e != NULL; e = e->next) {
        InputEvent *event = e->value;

        if (!qemu_input_find_handler(1 << event->kind, con)) {
            error_setg(errp, "Input handler not found for "
                             "event type %s",
                            InputEventKind_lookup[event->kind]);
            return;
        }
    }

    for (e = events; e != NULL; e = e->next) {
        InputEvent *event = e->value;

        qemu_input_event_send(con, event);
    }

    qemu_input_event_sync();
}

static void qemu_input_transform_abs_rotate(InputEvent *evt)
{
    switch (graphic_rotate) {
    case 90:
        if (evt->abs->axis == INPUT_AXIS_X) {
            evt->abs->axis = INPUT_AXIS_Y;
        } else if (evt->abs->axis == INPUT_AXIS_Y) {
            evt->abs->axis = INPUT_AXIS_X;
            evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value;
        }
        break;
    case 180:
        evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value;
        break;
    case 270:
        if (evt->abs->axis == INPUT_AXIS_X) {
            evt->abs->axis = INPUT_AXIS_Y;
            evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value;
        } else if (evt->abs->axis == INPUT_AXIS_Y) {
            evt->abs->axis = INPUT_AXIS_X;
        }
        break;
    }
}

static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
{
    const char *name;
    int qcode, idx = -1;

    if (src) {
        idx = qemu_console_get_index(src);
    }
    switch (evt->kind) {
    case INPUT_EVENT_KIND_KEY:
        switch (evt->key->key->kind) {
        case KEY_VALUE_KIND_NUMBER:
            qcode = qemu_input_key_number_to_qcode(evt->key->key->number);
            name = QKeyCode_lookup[qcode];
            trace_input_event_key_number(idx, evt->key->key->number,
                                         name, evt->key->down);
            break;
        case KEY_VALUE_KIND_QCODE:
            name = QKeyCode_lookup[evt->key->key->qcode];
            trace_input_event_key_qcode(idx, name, evt->key->down);
            break;
        case KEY_VALUE_KIND_MAX:
            /* keep gcc happy */
            break;
        }
        break;
    case INPUT_EVENT_KIND_BTN:
        name = InputButton_lookup[evt->btn->button];
        trace_input_event_btn(idx, name, evt->btn->down);
        break;
    case INPUT_EVENT_KIND_REL:
        name = InputAxis_lookup[evt->rel->axis];
        trace_input_event_rel(idx, name, evt->rel->value);
        break;
    case INPUT_EVENT_KIND_ABS:
        name = InputAxis_lookup[evt->abs->axis];
        trace_input_event_abs(idx, name, evt->abs->value);
        break;
    case INPUT_EVENT_KIND_MAX:
        /* keep gcc happy */
        break;
    }
}

static void qemu_input_queue_process(void *opaque)
{
    struct QemuInputEventQueueHead *queue = opaque;
    QemuInputEventQueue *item;

    g_assert(!QTAILQ_EMPTY(queue));
    item = QTAILQ_FIRST(queue);
    g_assert(item->type == QEMU_INPUT_QUEUE_DELAY);
    QTAILQ_REMOVE(queue, item, node);
    g_free(item);

    while (!QTAILQ_EMPTY(queue)) {
        item = QTAILQ_FIRST(queue);
        switch (item->type) {
        case QEMU_INPUT_QUEUE_DELAY:
            timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
                      + item->delay_ms);
            return;
        case QEMU_INPUT_QUEUE_EVENT:
            qemu_input_event_send(item->src, item->evt);
            qapi_free_InputEvent(item->evt);
            break;
        case QEMU_INPUT_QUEUE_SYNC:
            qemu_input_event_sync();
            break;
        }
        QTAILQ_REMOVE(queue, item, node);
        g_free(item);
    }
}

static void qemu_input_queue_delay(struct QemuInputEventQueueHead *queue,
                                   QEMUTimer *timer, uint32_t delay_ms)
{
    QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
    bool start_timer = QTAILQ_EMPTY(queue);

    item->type = QEMU_INPUT_QUEUE_DELAY;
    item->delay_ms = delay_ms;
    item->timer = timer;
    QTAILQ_INSERT_TAIL(queue, item, node);

    if (start_timer) {
        timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
                  + item->delay_ms);
    }
}

static void qemu_input_queue_event(struct QemuInputEventQueueHead *queue,
                                   QemuConsole *src, InputEvent *evt)
{
    QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);

    item->type = QEMU_INPUT_QUEUE_EVENT;
    item->src = src;
    item->evt = evt;
    QTAILQ_INSERT_TAIL(queue, item, node);
}

static void qemu_input_queue_sync(struct QemuInputEventQueueHead *queue)
{
    QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);

    item->type = QEMU_INPUT_QUEUE_SYNC;
    QTAILQ_INSERT_TAIL(queue, item, node);
}

void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
{
    QemuInputHandlerState *s;

    if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
        return;
    }

    qemu_input_event_trace(src, evt);

    /* pre processing */
    if (graphic_rotate && (evt->kind == INPUT_EVENT_KIND_ABS)) {
            qemu_input_transform_abs_rotate(evt);
    }

    /* send event */
    s = qemu_input_find_handler(1 << evt->kind, src);
    if (!s) {
        return;
    }
    s->handler->event(s->dev, src, evt);
    s->events++;
}

void qemu_input_event_sync(void)
{
    QemuInputHandlerState *s;

    if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
        return;
    }

    trace_input_event_sync();

    QTAILQ_FOREACH(s, &handlers, node) {
        if (!s->events) {
            continue;
        }
        if (s->handler->sync) {
            s->handler->sync(s->dev);
        }
        s->events = 0;
    }
}

InputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
{
    InputEvent *evt = g_new0(InputEvent, 1);
    evt->key = g_new0(InputKeyEvent, 1);
    evt->kind = INPUT_EVENT_KIND_KEY;
    evt->key->key = key;
    evt->key->down = down;
    return evt;
}

void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
{
    InputEvent *evt;
    evt = qemu_input_event_new_key(key, down);
    if (QTAILQ_EMPTY(&kbd_queue)) {
        qemu_input_event_send(src, evt);
        qemu_input_event_sync();
        qapi_free_InputEvent(evt);
    } else {
        qemu_input_queue_event(&kbd_queue, src, evt);
        qemu_input_queue_sync(&kbd_queue);
    }
}

void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
{
    KeyValue *key = g_new0(KeyValue, 1);
    key->kind = KEY_VALUE_KIND_NUMBER;
    key->number = num;
    qemu_input_event_send_key(src, key, down);
}

void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
{
    KeyValue *key = g_new0(KeyValue, 1);
    key->kind = KEY_VALUE_KIND_QCODE;
    key->qcode = q;
    qemu_input_event_send_key(src, key, down);
}

void qemu_input_event_send_key_delay(uint32_t delay_ms)
{
    if (!kbd_timer) {
        kbd_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, qemu_input_queue_process,
                                 &kbd_queue);
    }
    qemu_input_queue_delay(&kbd_queue, kbd_timer,
                           delay_ms ? delay_ms : kbd_default_delay_ms);
}

InputEvent *qemu_input_event_new_btn(InputButton btn, bool down)
{
    InputEvent *evt = g_new0(InputEvent, 1);
    evt->btn = g_new0(InputBtnEvent, 1);
    evt->kind = INPUT_EVENT_KIND_BTN;
    evt->btn->button = btn;
    evt->btn->down = down;
    return evt;
}

void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
{
    InputEvent *evt;
    evt = qemu_input_event_new_btn(btn, down);
    qemu_input_event_send(src, evt);
    qapi_free_InputEvent(evt);
}

void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map,
                               uint32_t button_old, uint32_t button_new)
{
    InputButton btn;
    uint32_t mask;

    for (btn = 0; btn < INPUT_BUTTON_MAX; btn++) {
        mask = button_map[btn];
        if ((button_old & mask) == (button_new & mask)) {
            continue;
        }
        qemu_input_queue_btn(src, btn, button_new & mask);
    }
}

bool qemu_input_is_absolute(void)
{
    QemuInputHandlerState *s;

    s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS,
                                NULL);
    return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
}

int qemu_input_scale_axis(int value, int size_in, int size_out)
{
    if (size_in < 2) {
        return size_out / 2;
    }
    return (int64_t)value * (size_out - 1) / (size_in - 1);
}

InputEvent *qemu_input_event_new_move(InputEventKind kind,
                                      InputAxis axis, int value)
{
    InputEvent *evt = g_new0(InputEvent, 1);
    InputMoveEvent *move = g_new0(InputMoveEvent, 1);

    evt->kind = kind;
    evt->data = move;
    move->axis = axis;
    move->value = value;
    return evt;
}

void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
{
    InputEvent *evt;
    evt = qemu_input_event_new_move(INPUT_EVENT_KIND_REL, axis, value);
    qemu_input_event_send(src, evt);
    qapi_free_InputEvent(evt);
}

void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value, int size)
{
    InputEvent *evt;
    int scaled = qemu_input_scale_axis(value, size, INPUT_EVENT_ABS_SIZE);
    evt = qemu_input_event_new_move(INPUT_EVENT_KIND_ABS, axis, scaled);
    qemu_input_event_send(src, evt);
    qapi_free_InputEvent(evt);
}

void qemu_input_check_mode_change(void)
{
    static int current_is_absolute;
    int is_absolute;

    is_absolute = qemu_input_is_absolute();

    if (is_absolute != current_is_absolute) {
        trace_input_mouse_mode(is_absolute);
        notifier_list_notify(&mouse_mode_notifiers, NULL);
    }

    current_is_absolute = is_absolute;
}

void qemu_add_mouse_mode_change_notifier(Notifier *notify)
{
    notifier_list_add(&mouse_mode_notifiers, notify);
}

void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
{
    notifier_remove(notify);
}

MouseInfoList *qmp_query_mice(Error **errp)
{
    MouseInfoList *mice_list = NULL;
    MouseInfoList *info;
    QemuInputHandlerState *s;
    bool current = true;

    QTAILQ_FOREACH(s, &handlers, node) {
        if (!(s->handler->mask &
              (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) {
            continue;
        }

        info = g_new0(MouseInfoList, 1);
        info->value = g_new0(MouseInfo, 1);
        info->value->index = s->id;
        info->value->name = g_strdup(s->handler->name);
        info->value->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
        info->value->current = current;

        current = false;
        info->next = mice_list;
        mice_list = info;
    }

    return mice_list;
}

void do_mouse_set(Monitor *mon, const QDict *qdict)
{
    QemuInputHandlerState *s;
    int index = qdict_get_int(qdict, "index");
    int found = 0;

    QTAILQ_FOREACH(s, &handlers, node) {
        if (s->id != index) {
            continue;
        }
        if (!(s->handler->mask & (INPUT_EVENT_MASK_REL |
                                  INPUT_EVENT_MASK_ABS))) {
            error_report("Input device '%s' is not a mouse", s->handler->name);
            return;
        }
        found = 1;
        qemu_input_handler_activate(s);
        break;
    }

    if (!found) {
        error_report("Mouse at index '%d' not found", index);
    }

    qemu_input_check_mode_change();
}
Commit	Line	Data
6f5943cf	1	#include "hw/qdev.h"
c8b405b6 GH	2	#include "sysemu/sysemu.h"
c8b405b6 GH	3	#include "qapi-types.h"
e842c68d	4	#include "qmp-commands.h"
c43ce551	5	#include "trace.h"
c8b405b6	6	#include "ui/input.h"
c43ce551	7	#include "ui/console.h"
c8b405b6 GH	8
	9	struct QemuInputHandlerState {
	10	DeviceState *dev;
	11	QemuInputHandler *handler;
	12	int id;
	13	int events;
6f5943cf	14	QemuConsole *con;
c8b405b6 GH	15	QTAILQ_ENTRY(QemuInputHandlerState) node;
c8b405b6 GH	16	};
be1a7176 GH	17
	18	typedef struct QemuInputEventQueue QemuInputEventQueue;
	19	struct QemuInputEventQueue {
	20	enum {
	21	QEMU_INPUT_QUEUE_DELAY = 1,
	22	QEMU_INPUT_QUEUE_EVENT,
	23	QEMU_INPUT_QUEUE_SYNC,
	24	} type;
	25	QEMUTimer *timer;
	26	uint32_t delay_ms;
	27	QemuConsole *src;
	28	InputEvent *evt;
	29	QTAILQ_ENTRY(QemuInputEventQueue) node;
	30	};
	31
c8b405b6 GH	32	static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
c8b405b6 GH	33	QTAILQ_HEAD_INITIALIZER(handlers);
4a33f45e GH	34	static NotifierList mouse_mode_notifiers =
4a33f45e GH	35	NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
c8b405b6	36
be1a7176 GH	37	static QTAILQ_HEAD(QemuInputEventQueueHead, QemuInputEventQueue) kbd_queue =
	38	QTAILQ_HEAD_INITIALIZER(kbd_queue);
	39	static QEMUTimer *kbd_timer;
	40	static uint32_t kbd_default_delay_ms = 10;
	41
c8b405b6 GH	42	QemuInputHandlerState qemu_input_handler_register(DeviceState dev,
	43	QemuInputHandler *handler)
	44	{
	45	QemuInputHandlerState *s = g_new0(QemuInputHandlerState, 1);
	46	static int id = 1;
	47
	48	s->dev = dev;
	49	s->handler = handler;
	50	s->id = id++;
	51	QTAILQ_INSERT_TAIL(&handlers, s, node);
4a33f45e GH	52
4a33f45e GH	53	qemu_input_check_mode_change();
c8b405b6 GH	54	return s;
	55	}
	56
	57	void qemu_input_handler_activate(QemuInputHandlerState *s)
	58	{
	59	QTAILQ_REMOVE(&handlers, s, node);
	60	QTAILQ_INSERT_HEAD(&handlers, s, node);
4a33f45e	61	qemu_input_check_mode_change();
c8b405b6 GH	62	}
c8b405b6 GH	63
528728fd GH	64	void qemu_input_handler_deactivate(QemuInputHandlerState *s)
	65	{
	66	QTAILQ_REMOVE(&handlers, s, node);
	67	QTAILQ_INSERT_TAIL(&handlers, s, node);
	68	qemu_input_check_mode_change();
	69	}
	70
c8b405b6 GH	71	void qemu_input_handler_unregister(QemuInputHandlerState *s)
	72	{
	73	QTAILQ_REMOVE(&handlers, s, node);
	74	g_free(s);
4a33f45e	75	qemu_input_check_mode_change();
c8b405b6 GH	76	}
c8b405b6 GH	77
6f5943cf GH	78	void qemu_input_handler_bind(QemuInputHandlerState *s,
	79	const char *device_id, int head,
	80	Error **errp)
	81	{
	82	DeviceState *dev;
	83	QemuConsole *con;
	84
	85	dev = qdev_find_recursive(sysbus_get_default(), device_id);
	86	if (dev == NULL) {
	87	error_set(errp, QERR_DEVICE_NOT_FOUND, device_id);
	88	return;
	89	}
	90
	91	con = qemu_console_lookup_by_device(dev, head);
	92	if (con == NULL) {
	93	error_setg(errp, "Device %s is not bound to a QemuConsole", device_id);
	94	return;
	95	}
	96
	97	s->con = con;
	98	}
	99
c8b405b6	100	static QemuInputHandlerState*
6f5943cf	101	qemu_input_find_handler(uint32_t mask, QemuConsole *con)
c8b405b6 GH	102	{
	103	QemuInputHandlerState *s;
	104
	105	QTAILQ_FOREACH(s, &handlers, node) {
6f5943cf GH	106	if (s->con == NULL \|\| s->con != con) {
	107	continue;
	108	}
	109	if (mask & s->handler->mask) {
	110	return s;
	111	}
	112	}
	113
	114	QTAILQ_FOREACH(s, &handlers, node) {
	115	if (s->con != NULL) {
	116	continue;
	117	}
c8b405b6 GH	118	if (mask & s->handler->mask) {
	119	return s;
	120	}
	121	}
	122	return NULL;
	123	}
	124
50c6617f MT	125	void qmp_input_send_event(int64_t console, InputEventList *events,
	126	Error **errp)
	127	{
	128	InputEventList *e;
	129	QemuConsole *con;
	130
	131	con = qemu_console_lookup_by_index(console);
	132	if (!con) {
	133	error_setg(errp, "console %" PRId64 " not found", console);
	134	return;
	135	}
	136
	137	if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
	138	error_setg(errp, "VM not running");
	139	return;
	140	}
	141
	142	for (e = events; e != NULL; e = e->next) {
	143	InputEvent *event = e->value;
	144
	145	if (!qemu_input_find_handler(1 << event->kind, con)) {
	146	error_setg(errp, "Input handler not found for "
	147	"event type %s",
	148	InputEventKind_lookup[event->kind]);
	149	return;
	150	}
	151	}
	152
	153	for (e = events; e != NULL; e = e->next) {
	154	InputEvent *event = e->value;
	155
	156	qemu_input_event_send(con, event);
	157	}
	158
	159	qemu_input_event_sync();
	160	}
	161
d3535431 GH	162	static void qemu_input_transform_abs_rotate(InputEvent *evt)
	163	{
	164	switch (graphic_rotate) {
	165	case 90:
	166	if (evt->abs->axis == INPUT_AXIS_X) {
	167	evt->abs->axis = INPUT_AXIS_Y;
	168	} else if (evt->abs->axis == INPUT_AXIS_Y) {
	169	evt->abs->axis = INPUT_AXIS_X;
	170	evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value;
	171	}
	172	break;
	173	case 180:
	174	evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value;
	175	break;
	176	case 270:
	177	if (evt->abs->axis == INPUT_AXIS_X) {
	178	evt->abs->axis = INPUT_AXIS_Y;
	179	evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value;
	180	} else if (evt->abs->axis == INPUT_AXIS_Y) {
	181	evt->abs->axis = INPUT_AXIS_X;
	182	}
	183	break;
	184	}
	185	}
	186
c43ce551 GH	187	static void qemu_input_event_trace(QemuConsole src, InputEvent evt)
	188	{
	189	const char *name;
2386a907	190	int qcode, idx = -1;
c43ce551 GH	191
	192	if (src) {
	193	idx = qemu_console_get_index(src);
	194	}
	195	switch (evt->kind) {
	196	case INPUT_EVENT_KIND_KEY:
	197	switch (evt->key->key->kind) {
	198	case KEY_VALUE_KIND_NUMBER:
2386a907 GH	199	qcode = qemu_input_key_number_to_qcode(evt->key->key->number);
2386a907 GH	200	name = QKeyCode_lookup[qcode];
c43ce551	201	trace_input_event_key_number(idx, evt->key->key->number,
2386a907	202	name, evt->key->down);
c43ce551 GH	203	break;
	204	case KEY_VALUE_KIND_QCODE:
	205	name = QKeyCode_lookup[evt->key->key->qcode];
	206	trace_input_event_key_qcode(idx, name, evt->key->down);
	207	break;
	208	case KEY_VALUE_KIND_MAX:
	209	/* keep gcc happy */
	210	break;
	211	}
	212	break;
	213	case INPUT_EVENT_KIND_BTN:
	214	name = InputButton_lookup[evt->btn->button];
	215	trace_input_event_btn(idx, name, evt->btn->down);
	216	break;
	217	case INPUT_EVENT_KIND_REL:
	218	name = InputAxis_lookup[evt->rel->axis];
	219	trace_input_event_rel(idx, name, evt->rel->value);
	220	break;
	221	case INPUT_EVENT_KIND_ABS:
	222	name = InputAxis_lookup[evt->abs->axis];
	223	trace_input_event_abs(idx, name, evt->abs->value);
	224	break;
	225	case INPUT_EVENT_KIND_MAX:
	226	/* keep gcc happy */
	227	break;
	228	}
	229	}
	230
be1a7176 GH	231	static void qemu_input_queue_process(void *opaque)
	232	{
	233	struct QemuInputEventQueueHead *queue = opaque;
	234	QemuInputEventQueue *item;
	235
	236	g_assert(!QTAILQ_EMPTY(queue));
	237	item = QTAILQ_FIRST(queue);
	238	g_assert(item->type == QEMU_INPUT_QUEUE_DELAY);
	239	QTAILQ_REMOVE(queue, item, node);
	240	g_free(item);
	241
	242	while (!QTAILQ_EMPTY(queue)) {
	243	item = QTAILQ_FIRST(queue);
	244	switch (item->type) {
	245	case QEMU_INPUT_QUEUE_DELAY:
	246	timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
	247	+ item->delay_ms);
	248	return;
	249	case QEMU_INPUT_QUEUE_EVENT:
	250	qemu_input_event_send(item->src, item->evt);
	251	qapi_free_InputEvent(item->evt);
	252	break;
	253	case QEMU_INPUT_QUEUE_SYNC:
	254	qemu_input_event_sync();
	255	break;
	256	}
	257	QTAILQ_REMOVE(queue, item, node);
	258	g_free(item);
	259	}
	260	}
	261
	262	static void qemu_input_queue_delay(struct QemuInputEventQueueHead *queue,
	263	QEMUTimer *timer, uint32_t delay_ms)
	264	{
	265	QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
	266	bool start_timer = QTAILQ_EMPTY(queue);
	267
	268	item->type = QEMU_INPUT_QUEUE_DELAY;
	269	item->delay_ms = delay_ms;
	270	item->timer = timer;
	271	QTAILQ_INSERT_TAIL(queue, item, node);
	272
	273	if (start_timer) {
	274	timer_mod(item->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)
	275	+ item->delay_ms);
	276	}
	277	}
	278
	279	static void qemu_input_queue_event(struct QemuInputEventQueueHead *queue,
	280	QemuConsole src, InputEvent evt)
	281	{
	282	QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
	283
	284	item->type = QEMU_INPUT_QUEUE_EVENT;
	285	item->src = src;
	286	item->evt = evt;
	287	QTAILQ_INSERT_TAIL(queue, item, node);
	288	}
	289
	290	static void qemu_input_queue_sync(struct QemuInputEventQueueHead *queue)
	291	{
	292	QemuInputEventQueue *item = g_new0(QemuInputEventQueue, 1);
	293
	294	item->type = QEMU_INPUT_QUEUE_SYNC;
295	QTAILQ_INSERT_TAIL(queue, item, node);
296	}
297
c8b405b6 GH	298	void qemu_input_event_send(QemuConsole src, InputEvent evt)
	299	{
	300	QemuInputHandlerState *s;
	301
	302	if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
	303	return;
	304	}
	305
c43ce551 GH	306	qemu_input_event_trace(src, evt);
c43ce551 GH	307
d3535431 GH	308	/* pre processing */
	309	if (graphic_rotate && (evt->kind == INPUT_EVENT_KIND_ABS)) {
	310	qemu_input_transform_abs_rotate(evt);
	311	}
	312
	313	/* send event */
6f5943cf	314	s = qemu_input_find_handler(1 << evt->kind, src);
bdcc3a28 GH	315	if (!s) {
	316	return;
	317	}
c8b405b6 GH	318	s->handler->event(s->dev, src, evt);
	319	s->events++;
	320	}
	321
	322	void qemu_input_event_sync(void)
	323	{
	324	QemuInputHandlerState *s;
	325
	326	if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
	327	return;
	328	}
	329
c43ce551 GH	330	trace_input_event_sync();
c43ce551 GH	331
c8b405b6 GH	332	QTAILQ_FOREACH(s, &handlers, node) {
	333	if (!s->events) {
	334	continue;
	335	}
	336	if (s->handler->sync) {
	337	s->handler->sync(s->dev);
	338	}
	339	s->events = 0;
	340	}
	341	}
65671475 GH	342
	343	InputEvent qemu_input_event_new_key(KeyValue key, bool down)
	344	{
	345	InputEvent *evt = g_new0(InputEvent, 1);
	346	evt->key = g_new0(InputKeyEvent, 1);
	347	evt->kind = INPUT_EVENT_KIND_KEY;
	348	evt->key->key = key;
	349	evt->key->down = down;
	350	return evt;
	351	}
	352
	353	void qemu_input_event_send_key(QemuConsole src, KeyValue key, bool down)
	354	{
	355	InputEvent *evt;
	356	evt = qemu_input_event_new_key(key, down);
be1a7176 GH	357	if (QTAILQ_EMPTY(&kbd_queue)) {
	358	qemu_input_event_send(src, evt);
	359	qemu_input_event_sync();
	360	qapi_free_InputEvent(evt);
	361	} else {
	362	qemu_input_queue_event(&kbd_queue, src, evt);
	363	qemu_input_queue_sync(&kbd_queue);
	364	}
65671475 GH	365	}
	366
	367	void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
	368	{
	369	KeyValue *key = g_new0(KeyValue, 1);
	370	key->kind = KEY_VALUE_KIND_NUMBER;
	371	key->number = num;
	372	qemu_input_event_send_key(src, key, down);
	373	}
	374
	375	void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
	376	{
	377	KeyValue *key = g_new0(KeyValue, 1);
	378	key->kind = KEY_VALUE_KIND_QCODE;
	379	key->qcode = q;
	380	qemu_input_event_send_key(src, key, down);
	381	}
43579403	382
be1a7176 GH	383	void qemu_input_event_send_key_delay(uint32_t delay_ms)
	384	{
	385	if (!kbd_timer) {
	386	kbd_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, qemu_input_queue_process,
	387	&kbd_queue);
	388	}
	389	qemu_input_queue_delay(&kbd_queue, kbd_timer,
	390	delay_ms ? delay_ms : kbd_default_delay_ms);
	391	}
	392
43579403 GH	393	InputEvent *qemu_input_event_new_btn(InputButton btn, bool down)
	394	{
	395	InputEvent *evt = g_new0(InputEvent, 1);
	396	evt->btn = g_new0(InputBtnEvent, 1);
	397	evt->kind = INPUT_EVENT_KIND_BTN;
	398	evt->btn->button = btn;
	399	evt->btn->down = down;
	400	return evt;
	401	}
	402
	403	void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
	404	{
	405	InputEvent *evt;
	406	evt = qemu_input_event_new_btn(btn, down);
	407	qemu_input_event_send(src, evt);
	408	qapi_free_InputEvent(evt);
	409	}
	410
	411	void qemu_input_update_buttons(QemuConsole src, uint32_t button_map,
	412	uint32_t button_old, uint32_t button_new)
	413	{
	414	InputButton btn;
	415	uint32_t mask;
	416
	417	for (btn = 0; btn < INPUT_BUTTON_MAX; btn++) {
	418	mask = button_map[btn];
	419	if ((button_old & mask) == (button_new & mask)) {
	420	continue;
	421	}
	422	qemu_input_queue_btn(src, btn, button_new & mask);
	423	}
	424	}
	425
502c8db5 GH	426	bool qemu_input_is_absolute(void)
	427	{
	428	QemuInputHandlerState *s;
	429
6f5943cf GH	430	s = qemu_input_find_handler(INPUT_EVENT_MASK_REL \| INPUT_EVENT_MASK_ABS,
6f5943cf GH	431	NULL);
502c8db5 GH	432	return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
	433	}
	434
43579403 GH	435	int qemu_input_scale_axis(int value, int size_in, int size_out)
	436	{
	437	if (size_in < 2) {
	438	return size_out / 2;
	439	}
	440	return (int64_t)value * (size_out - 1) / (size_in - 1);
	441	}
	442
	443	InputEvent *qemu_input_event_new_move(InputEventKind kind,
	444	InputAxis axis, int value)
	445	{
	446	InputEvent *evt = g_new0(InputEvent, 1);
	447	InputMoveEvent *move = g_new0(InputMoveEvent, 1);
	448
	449	evt->kind = kind;
	450	evt->data = move;
	451	move->axis = axis;
	452	move->value = value;
	453	return evt;
	454	}
	455
	456	void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
	457	{
	458	InputEvent *evt;
	459	evt = qemu_input_event_new_move(INPUT_EVENT_KIND_REL, axis, value);
	460	qemu_input_event_send(src, evt);
	461	qapi_free_InputEvent(evt);
	462	}
	463
	464	void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value, int size)
	465	{
	466	InputEvent *evt;
	467	int scaled = qemu_input_scale_axis(value, size, INPUT_EVENT_ABS_SIZE);
	468	evt = qemu_input_event_new_move(INPUT_EVENT_KIND_ABS, axis, scaled);
	469	qemu_input_event_send(src, evt);
	470	qapi_free_InputEvent(evt);
	471	}
4a33f45e GH	472
	473	void qemu_input_check_mode_change(void)
	474	{
	475	static int current_is_absolute;
	476	int is_absolute;
	477
	478	is_absolute = qemu_input_is_absolute();
	479
	480	if (is_absolute != current_is_absolute) {
a8dfb1c3	481	trace_input_mouse_mode(is_absolute);
4a33f45e GH	482	notifier_list_notify(&mouse_mode_notifiers, NULL);
	483	}
	484
	485	current_is_absolute = is_absolute;
	486	}
	487
	488	void qemu_add_mouse_mode_change_notifier(Notifier *notify)
	489	{
	490	notifier_list_add(&mouse_mode_notifiers, notify);
	491	}
	492
	493	void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
	494	{
	495	notifier_remove(notify);
	496	}
e842c68d GH	497
	498	MouseInfoList qmp_query_mice(Error *errp)
	499	{
	500	MouseInfoList *mice_list = NULL;
	501	MouseInfoList *info;
	502	QemuInputHandlerState *s;
	503	bool current = true;
	504
	505	QTAILQ_FOREACH(s, &handlers, node) {
	506	if (!(s->handler->mask &
	507	(INPUT_EVENT_MASK_REL \| INPUT_EVENT_MASK_ABS))) {
	508	continue;
	509	}
	510
	511	info = g_new0(MouseInfoList, 1);
	512	info->value = g_new0(MouseInfo, 1);
	513	info->value->index = s->id;
	514	info->value->name = g_strdup(s->handler->name);
	515	info->value->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
	516	info->value->current = current;
	517
	518	current = false;
	519	info->next = mice_list;
	520	mice_list = info;
	521	}
	522
	523	return mice_list;
	524	}
70b52f62 GH	525
	526	void do_mouse_set(Monitor mon, const QDict qdict)
	527	{
	528	QemuInputHandlerState *s;
	529	int index = qdict_get_int(qdict, "index");
	530	int found = 0;
	531
	532	QTAILQ_FOREACH(s, &handlers, node) {
0419f78f HB	533	if (s->id != index) {
0419f78f HB	534	continue;
70b52f62	535	}
0419f78f HB	536	if (!(s->handler->mask & (INPUT_EVENT_MASK_REL \|
	537	INPUT_EVENT_MASK_ABS))) {
	538	error_report("Input device '%s' is not a mouse", s->handler->name);
	539	return;
	540	}
	541	found = 1;
	542	qemu_input_handler_activate(s);
	543	break;
70b52f62 GH	544	}
	545
	546	if (!found) {
0419f78f	547	error_report("Mouse at index '%d' not found", index);
70b52f62 GH	548	}
	549
	550	qemu_input_check_mode_change();
	551	}