[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_x_input_send_event(bool has_console, int64_t console,
                            InputEventList *events, Error **errp)
{
    InputEventList *e;
    QemuConsole *con;

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