[mirror_qemu.git] / ui / input.c

#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;
    QTAILQ_ENTRY(QemuInputHandlerState) node;
};
static QTAILQ_HEAD(, QemuInputHandlerState) handlers =
    QTAILQ_HEAD_INITIALIZER(handlers);
static NotifierList mouse_mode_notifiers =
    NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);

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_unregister(QemuInputHandlerState *s)
{
    QTAILQ_REMOVE(&handlers, s, node);
    g_free(s);
    qemu_input_check_mode_change();
}

static QemuInputHandlerState*
qemu_input_find_handler(uint32_t mask)
{
    QemuInputHandlerState *s;

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

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 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:
            trace_input_event_key_number(idx, evt->key->key->number,
                                         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;
    }
}

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);
    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);
    qemu_input_event_send(src, evt);
    qemu_input_event_sync();
    qapi_free_InputEvent(evt);
}

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);
}

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