ui/input: Remove QAPI wrappers from QemuInputEvent
QAPI represents union members with wrapper structs and pointer indirections. They are useful at the QMP boundary, but unnecessary for QEMU's internal input events and make handlers more verbose. Define QemuInputEvent as a plain internal tagged union and convert input handlers, queues, and replay code to access payloads directly. Signed-off-by: Akihiko Odaki <odaki@rsg.ci.i.u-tokyo.ac.jp> Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com> Message-ID: <20260520-input-v3-2-7c9e4c7abe34@rsg.ci.i.u-tokyo.ac.jp>
Akihiko Odaki committed
May 20, 2026 at 15:47 UTC
d0cc63dcceb6d2a812fb2b26068fc87da114aa46
19 files changed
+299
-331
chardev/msmouse.c
+3
-7
@@ -125,8 +125,6 @@ static void msmouse_input_event(DeviceState *dev, QemuConsole *src,
125
QemuInputEvent *evt)
126
{
127
MouseChardev *mouse = MOUSE_CHARDEV(dev);
128
- InputMoveEvent *move;
129
- InputBtnEvent *btn;
128
129
/* Ignore events if serial mouse powered down. */
130
if (!MSMOUSE_PWR(mouse->tiocm)) {
@@ -135,14 +133,12 @@ static void msmouse_input_event(DeviceState *dev, QemuConsole *src,
133
134
switch (evt->type) {
135
case INPUT_EVENT_KIND_REL:
138
- move = evt->u.rel.data;
139
- mouse->axis[move->axis] += move->value;
136
+ mouse->axis[evt->rel.axis] += evt->rel.value;
137
break;
138
139
case INPUT_EVENT_KIND_BTN:
143
- btn = evt->u.btn.data;
144
- mouse->btns[btn->button] = btn->down;
145
- mouse->btnc[btn->button] = true;
140
+ mouse->btns[evt->btn.button] = evt->btn.down;
141
+ mouse->btnc[evt->btn.button] = true;
142
break;
143
144
default:
chardev/wctablet.c
+2
-6
@@ -149,18 +149,14 @@ static void wctablet_input_event(DeviceState *dev, QemuConsole *src,
149
QemuInputEvent *evt)
150
{
151
TabletChardev *tablet = (TabletChardev *)dev;
152
- InputMoveEvent *move;
153
- InputBtnEvent *btn;
152
153
switch (evt->type) {
154
case INPUT_EVENT_KIND_ABS:
157
- move = evt->u.abs.data;
158
- tablet->axis[move->axis] = move->value;
155
+ tablet->axis[evt->abs.axis] = evt->abs.value;
156
break;
157
158
case INPUT_EVENT_KIND_BTN:
162
- btn = evt->u.btn.data;
163
- tablet->btns[btn->button] = btn->down;
159
+ tablet->btns[evt->btn.button] = evt->btn.down;
160
break;
161
162
default:
hw/arm/musicpal.c
+5
-6
@@ -1069,8 +1069,7 @@ static void musicpal_key_event(DeviceState *dev, QemuConsole *src,
1069
QemuInputEvent *evt)
1070
{
1071
musicpal_key_state *s = MUSICPAL_KEY(dev);
1072
- InputKeyEvent *key = evt->u.key.data;
1073
- int qcode = qemu_input_key_value_to_qcode(key->key);
1072
+ int qcode = qemu_input_key_value_to_qcode(&evt->key.key);
1073
uint32_t event = 0;
1074
int i;
1075
@@ -1113,14 +1112,14 @@ static void musicpal_key_event(DeviceState *dev, QemuConsole *src,
1112
* but do not repeat already-pressed buttons for the other key inputs.
1113
*/
1114
if (!(event & (MP_KEY_WHEEL_NAV | MP_KEY_WHEEL_VOL))) {
1116
- if (key->down && (s->pressed_keys & event)) {
1115
+ if (evt->key.down && (s->pressed_keys & event)) {
1116
event = 0;
1117
}
1118
}
1119
1120
if (event) {
1121
/* Raise GPIO pin first if repeating a key */
1123
- if (key->down && (s->pressed_keys & event)) {
1122
+ if (evt->key.down && (s->pressed_keys & event)) {
1123
for (i = 0; i <= 7; i++) {
1124
if (event & (1 << i)) {
1125
qemu_set_irq(s->out[i], 1);
@@ -1129,10 +1128,10 @@ static void musicpal_key_event(DeviceState *dev, QemuConsole *src,
1128
}
1129
for (i = 0; i <= 7; i++) {
1130
if (event & (1 << i)) {
1132
- qemu_set_irq(s->out[i], !key->down);
1131
+ qemu_set_irq(s->out[i], !evt->key.down);
1132
}
1133
}
1135
- if (key->down) {
1134
+ if (evt->key.down) {
1135
s->pressed_keys |= event;
1136
} else {
1137
s->pressed_keys &= ~event;
hw/char/escc.c
+13
-19
@@ -798,16 +798,14 @@ static void sunkbd_handle_event(DeviceState *dev, QemuConsole *src,
798
{
799
ESCCChannelState *s = (ESCCChannelState *)dev;
800
int qcode, keycode;
801
- InputKeyEvent *key;
801
802
assert(evt->type == INPUT_EVENT_KIND_KEY);
804
- key = evt->u.key.data;
805
- qcode = qemu_input_key_value_to_qcode(key->key);
803
+ qcode = qemu_input_key_value_to_qcode(&evt->key.key);
804
trace_escc_sunkbd_event_in(qcode, QKeyCode_str(qcode),
807
- key->down);
805
+ evt->key.down);
806
807
if (qcode == Q_KEY_CODE_CAPS_LOCK) {
810
- if (key->down) {
808
+ if (evt->key.down) {
809
s->caps_lock_mode ^= 1;
810
if (s->caps_lock_mode == 2) {
811
return; /* Drop second press */
@@ -821,7 +819,7 @@ static void sunkbd_handle_event(DeviceState *dev, QemuConsole *src,
819
}
820
821
if (qcode == Q_KEY_CODE_NUM_LOCK) {
824
- if (key->down) {
822
+ if (evt->key.down) {
823
s->num_lock_mode ^= 1;
824
if (s->num_lock_mode == 2) {
825
return; /* Drop second press */
@@ -839,7 +837,7 @@ static void sunkbd_handle_event(DeviceState *dev, QemuConsole *src,
837
}
838
839
keycode = qemu_input_map_qcode_to_sun[qcode];
842
- if (!key->down) {
840
+ if (!evt->key.down) {
841
keycode |= 0x80;
842
}
843
trace_escc_sunkbd_event_out(keycode);
@@ -957,8 +955,6 @@ static void sunmouse_handle_event(DeviceState *dev, QemuConsole *src,
955
QemuInputEvent *evt)
956
{
957
ESCCChannelState *s = (ESCCChannelState *)dev;
960
- InputMoveEvent *move;
961
- InputBtnEvent *btn;
958
static const int bmap[INPUT_BUTTON__MAX] = {
959
[INPUT_BUTTON_LEFT] = 0x4,
960
[INPUT_BUTTON_MIDDLE] = 0x2,
@@ -967,21 +963,19 @@ static void sunmouse_handle_event(DeviceState *dev, QemuConsole *src,
963
964
switch (evt->type) {
965
case INPUT_EVENT_KIND_REL:
970
- move = evt->u.rel.data;
971
- if (move->axis == INPUT_AXIS_X) {
972
- s->sunmouse_dx += move->value;
973
- } else if (move->axis == INPUT_AXIS_Y) {
974
- s->sunmouse_dy -= move->value;
966
+ if (evt->rel.axis == INPUT_AXIS_X) {
967
+ s->sunmouse_dx += evt->rel.value;
968
+ } else if (evt->rel.axis == INPUT_AXIS_Y) {
969
+ s->sunmouse_dy -= evt->rel.value;
970
}
971
break;
972
973
case INPUT_EVENT_KIND_BTN:
979
- btn = evt->u.btn.data;
980
- if (bmap[btn->button]) {
981
- if (btn->down) {
982
- s->sunmouse_buttons |= bmap[btn->button];
974
+ if (bmap[evt->btn.button]) {
975
+ if (evt->btn.down) {
976
+ s->sunmouse_buttons |= bmap[evt->btn.button];
977
} else {
984
- s->sunmouse_buttons &= ~bmap[btn->button];
978
+ s->sunmouse_buttons &= ~bmap[evt->btn.button];
979
}
980
/* Indicate we have a supported button event */
981
s->sunmouse_buttons |= 0x80;
hw/display/xenfb.c
+13
-19
@@ -203,16 +203,15 @@ static void xenfb_key_event(DeviceState *dev, QemuConsole *src,
203
QemuInputEvent *evt)
204
{
205
struct XenInput *xenfb = (struct XenInput *)dev;
206
- InputKeyEvent *key = evt->u.key.data;
207
- int qcode = qemu_input_key_value_to_qcode(key->key);
206
+ int qcode = qemu_input_key_value_to_qcode(&evt->key.key);
207
int lnx;
208
209
if (qcode < qemu_input_map_qcode_to_linux_len) {
210
lnx = qemu_input_map_qcode_to_linux[qcode];
211
212
if (lnx) {
214
- trace_xenfb_key_event(xenfb, lnx, key->down);
215
- xenfb_send_key(xenfb, key->down, lnx);
213
+ trace_xenfb_key_event(xenfb, lnx, evt->key.down);
214
+ xenfb_send_key(xenfb, evt->key.down, lnx);
215
}
216
}
217
}
@@ -230,32 +229,29 @@ static void xenfb_mouse_event(DeviceState *dev, QemuConsole *src,
229
QemuInputEvent *evt)
230
{
231
struct XenInput *xenfb = (struct XenInput *)dev;
233
- InputBtnEvent *btn;
234
- InputMoveEvent *move;
232
QemuConsole *con;
233
DisplaySurface *surface;
234
int scale;
235
236
switch (evt->type) {
237
case INPUT_EVENT_KIND_BTN:
241
- btn = evt->u.btn.data;
242
- switch (btn->button) {
238
+ switch (evt->btn.button) {
239
case INPUT_BUTTON_LEFT:
244
- xenfb_send_key(xenfb, btn->down, BTN_LEFT);
240
+ xenfb_send_key(xenfb, evt->btn.down, BTN_LEFT);
241
break;
242
case INPUT_BUTTON_RIGHT:
247
- xenfb_send_key(xenfb, btn->down, BTN_LEFT + 1);
243
+ xenfb_send_key(xenfb, evt->btn.down, BTN_LEFT + 1);
244
break;
245
case INPUT_BUTTON_MIDDLE:
250
- xenfb_send_key(xenfb, btn->down, BTN_LEFT + 2);
246
+ xenfb_send_key(xenfb, evt->btn.down, BTN_LEFT + 2);
247
break;
248
case INPUT_BUTTON_WHEEL_UP:
253
- if (btn->down) {
249
+ if (evt->btn.down) {
250
xenfb->wheel--;
251
}
252
break;
253
case INPUT_BUTTON_WHEEL_DOWN:
258
- if (btn->down) {
254
+ if (evt->btn.down) {
255
xenfb->wheel++;
256
}
257
break;
@@ -265,9 +261,8 @@ static void xenfb_mouse_event(DeviceState *dev, QemuConsole *src,
261
break;
262
263
case INPUT_EVENT_KIND_ABS:
268
- move = evt->u.abs.data;
264
if (xenfb->raw_pointer_wanted) {
270
- xenfb->axis[move->axis] = move->value;
265
+ xenfb->axis[evt->abs.axis] = evt->abs.value;
266
} else {
267
con = qemu_console_lookup_by_index(0);
268
if (!con) {
@@ -275,7 +270,7 @@ static void xenfb_mouse_event(DeviceState *dev, QemuConsole *src,
270
return;
271
}
272
surface = qemu_console_surface(con);
278
- switch (move->axis) {
273
+ switch (evt->abs.axis) {
274
case INPUT_AXIS_X:
275
scale = surface_width(surface) - 1;
276
break;
@@ -285,13 +280,12 @@ static void xenfb_mouse_event(DeviceState *dev, QemuConsole *src,
280
default:
281
g_assert_not_reached();
282
}
288
- xenfb->axis[move->axis] = move->value * scale / 0x7fff;
283
+ xenfb->axis[evt->abs.axis] = evt->abs.value * scale / 0x7fff;
284
}
285
break;
286
287
case INPUT_EVENT_KIND_REL:
293
- move = evt->u.rel.data;
294
- xenfb->axis[move->axis] += move->value;
288
+ xenfb->axis[evt->rel.axis] += evt->rel.value;
289
break;
290
291
default:
hw/input/adb-kbd.c
+2
-2
@@ -311,7 +311,7 @@ static void adb_keyboard_event(DeviceState *dev, QemuConsole *src,
311
KBDState *s = (KBDState *)dev;
312
int qcode, keycode;
313
314
- qcode = qemu_input_key_value_to_qcode(evt->u.key.data->key);
314
+ qcode = qemu_input_key_value_to_qcode(&evt->key.key);
315
if (qcode >= ARRAY_SIZE(qcode_to_adb_keycode)) {
316
return;
317
}
@@ -321,7 +321,7 @@ static void adb_keyboard_event(DeviceState *dev, QemuConsole *src,
321
trace_adb_device_kbd_no_key();
322
return;
323
}
324
- if (evt->u.key.data->down == false) { /* if key release event */
324
+ if (evt->key.down == false) { /* if key release event */
325
keycode = keycode | 0x80; /* create keyboard break code */
326
}
327
hw/input/adb-mouse.c
+8
-12
@@ -59,8 +59,6 @@ static void adb_mouse_handle_event(DeviceState *dev, QemuConsole *src,
59
QemuInputEvent *evt)
60
{
61
MouseState *s = (MouseState *)dev;
62
- InputMoveEvent *move;
63
- InputBtnEvent *btn;
62
static const int bmap[INPUT_BUTTON__MAX] = {
63
[INPUT_BUTTON_LEFT] = ADB_MOUSE_BUTTON_LEFT,
64
[INPUT_BUTTON_RIGHT] = ADB_MOUSE_BUTTON_RIGHT,
@@ -68,21 +66,19 @@ static void adb_mouse_handle_event(DeviceState *dev, QemuConsole *src,
66
67
switch (evt->type) {
68
case INPUT_EVENT_KIND_REL:
71
- move = evt->u.rel.data;
72
- if (move->axis == INPUT_AXIS_X) {
73
- s->dx += move->value;
74
- } else if (move->axis == INPUT_AXIS_Y) {
75
- s->dy += move->value;
69
+ if (evt->rel.axis == INPUT_AXIS_X) {
70
+ s->dx += evt->rel.value;
71
+ } else if (evt->rel.axis == INPUT_AXIS_Y) {
72
+ s->dy += evt->rel.value;
73
}
74
break;
75
76
case INPUT_EVENT_KIND_BTN:
80
- btn = evt->u.btn.data;
81
- if (bmap[btn->button]) {
82
- if (btn->down) {
83
- s->buttons_state |= bmap[btn->button];
77
+ if (bmap[evt->btn.button]) {
78
+ if (evt->btn.down) {
79
+ s->buttons_state |= bmap[evt->btn.button];
80
} else {
85
- s->buttons_state &= ~bmap[btn->button];
81
+ s->buttons_state &= ~bmap[evt->btn.button];
82
}
83
}
84
break;
hw/input/hid.c
+15
-21
@@ -119,42 +119,37 @@ static void hid_pointer_event(DeviceState *dev, QemuConsole *src,
119
};
120
HIDState *hs = (HIDState *)dev;
121
HIDPointerEvent *e;
122
- InputMoveEvent *move;
123
- InputBtnEvent *btn;
122
123
assert(hs->n < QUEUE_LENGTH);
124
e = &hs->ptr.queue[(hs->head + hs->n) & QUEUE_MASK];
125
126
switch (evt->type) {
127
case INPUT_EVENT_KIND_REL:
130
- move = evt->u.rel.data;
131
- if (move->axis == INPUT_AXIS_X) {
132
- e->xdx += move->value;
133
- } else if (move->axis == INPUT_AXIS_Y) {
134
- e->ydy += move->value;
128
+ if (evt->rel.axis == INPUT_AXIS_X) {
129
+ e->xdx += evt->rel.value;
130
+ } else if (evt->rel.axis == INPUT_AXIS_Y) {
131
+ e->ydy += evt->rel.value;
132
}
133
break;
134
135
case INPUT_EVENT_KIND_ABS:
139
- move = evt->u.abs.data;
140
- if (move->axis == INPUT_AXIS_X) {
141
- e->xdx = move->value;
142
- } else if (move->axis == INPUT_AXIS_Y) {
143
- e->ydy = move->value;
136
+ if (evt->abs.axis == INPUT_AXIS_X) {
137
+ e->xdx = evt->abs.value;
138
+ } else if (evt->abs.axis == INPUT_AXIS_Y) {
139
+ e->ydy = evt->abs.value;
140
}
141
break;
142
143
case INPUT_EVENT_KIND_BTN:
148
- btn = evt->u.btn.data;
149
- if (btn->down) {
150
- e->buttons_state |= bmap[btn->button];
151
- if (btn->button == INPUT_BUTTON_WHEEL_UP) {
144
+ if (evt->btn.down) {
145
+ e->buttons_state |= bmap[evt->btn.button];
146
+ if (evt->btn.button == INPUT_BUTTON_WHEEL_UP) {
147
e->dz--;
153
- } else if (btn->button == INPUT_BUTTON_WHEEL_DOWN) {
148
+ } else if (evt->btn.button == INPUT_BUTTON_WHEEL_DOWN) {
149
e->dz++;
150
}
151
} else {
157
- e->buttons_state &= ~bmap[btn->button];
152
+ e->buttons_state &= ~bmap[evt->btn.button];
153
}
154
break;
155
@@ -231,10 +226,9 @@ static void hid_keyboard_event(DeviceState *dev, QemuConsole *src,
226
HIDState *hs = (HIDState *)dev;
227
int scancodes[3], i, count;
228
int slot;
234
- InputKeyEvent *key = evt->u.key.data;
229
236
- count = qemu_input_key_value_to_scancode(key->key,
237
- key->down,
230
+ count = qemu_input_key_value_to_scancode(&evt->key.key,
231
+ evt->key.down,
232
scancodes);
233
if (hs->n + count > QUEUE_LENGTH) {
234
trace_hid_kbd_queue_full();
hw/input/ps2.c
+31
-36
@@ -313,7 +313,6 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
313
QemuInputEvent *evt)
314
{
315
PS2KbdState *s = (PS2KbdState *)dev;
316
- InputKeyEvent *key = evt->u.key.data;
316
int qcode;
317
uint16_t keycode = 0;
318
int mod;
@@ -325,12 +324,12 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
324
325
qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
326
assert(evt->type == INPUT_EVENT_KIND_KEY);
328
- qcode = qemu_input_key_value_to_qcode(key->key);
327
+ qcode = qemu_input_key_value_to_qcode(&evt->key.key);
328
329
mod = ps2_modifier_bit(qcode);
331
- trace_ps2_keyboard_event(s, qcode, key->down, mod,
330
+ trace_ps2_keyboard_event(s, qcode, evt->key.down, mod,
331
s->modifiers, s->scancode_set, s->translate);
333
- if (key->down) {
332
+ if (evt->key.down) {
333
s->modifiers |= mod;
334
} else {
335
s->modifiers &= ~mod;
@@ -339,14 +338,14 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
338
if (s->scancode_set == 1) {
339
if (qcode == Q_KEY_CODE_PAUSE) {
340
if (s->modifiers & (MOD_CTRL_L | MOD_CTRL_R)) {
342
- if (key->down) {
341
+ if (evt->key.down) {
342
ps2_put_keycode(s, 0xe0);
343
ps2_put_keycode(s, 0x46);
344
ps2_put_keycode(s, 0xe0);
345
ps2_put_keycode(s, 0xc6);
346
}
347
} else {
349
- if (key->down) {
348
+ if (evt->key.down) {
349
ps2_put_keycode(s, 0xe1);
350
ps2_put_keycode(s, 0x1d);
351
ps2_put_keycode(s, 0x45);
@@ -357,7 +356,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
356
}
357
} else if (qcode == Q_KEY_CODE_PRINT) {
358
if (s->modifiers & MOD_ALT_L) {
360
- if (key->down) {
359
+ if (evt->key.down) {
360
ps2_put_keycode(s, 0xb8);
361
ps2_put_keycode(s, 0x38);
362
ps2_put_keycode(s, 0x54);
@@ -367,7 +366,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
366
ps2_put_keycode(s, 0x38);
367
}
368
} else if (s->modifiers & MOD_ALT_R) {
370
- if (key->down) {
369
+ if (evt->key.down) {
370
ps2_put_keycode(s, 0xe0);
371
ps2_put_keycode(s, 0xb8);
372
ps2_put_keycode(s, 0xe0);
@@ -382,7 +381,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
381
}
382
} else if (s->modifiers & (MOD_SHIFT_L | MOD_CTRL_L |
383
MOD_SHIFT_R | MOD_CTRL_R)) {
385
- if (key->down) {
384
+ if (evt->key.down) {
385
ps2_put_keycode(s, 0xe0);
386
ps2_put_keycode(s, 0x37);
387
} else {
@@ -390,7 +389,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
389
ps2_put_keycode(s, 0xb7);
390
}
391
} else {
393
- if (key->down) {
392
+ if (evt->key.down) {
393
ps2_put_keycode(s, 0xe0);
394
ps2_put_keycode(s, 0x2a);
395
ps2_put_keycode(s, 0xe0);
@@ -403,7 +402,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
402
}
403
}
404
} else if ((qcode == Q_KEY_CODE_LANG1 || qcode == Q_KEY_CODE_LANG2)
406
- && !key->down) {
405
+ && !evt->key.down) {
406
/* Ignore release for these keys */
407
} else {
408
if (qcode < qemu_input_map_qcode_to_atset1_len) {
@@ -413,7 +412,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
412
if (keycode & 0xff00) {
413
ps2_put_keycode(s, keycode >> 8);
414
}
416
- if (!key->down) {
415
+ if (!evt->key.down) {
416
keycode |= 0x80;
417
}
418
ps2_put_keycode(s, keycode & 0xff);
@@ -425,7 +424,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
424
} else if (s->scancode_set == 2) {
425
if (qcode == Q_KEY_CODE_PAUSE) {
426
if (s->modifiers & (MOD_CTRL_L | MOD_CTRL_R)) {
428
- if (key->down) {
427
+ if (evt->key.down) {
428
ps2_put_keycode(s, 0xe0);
429
ps2_put_keycode(s, 0x7e);
430
ps2_put_keycode(s, 0xe0);
@@ -433,7 +432,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
432
ps2_put_keycode(s, 0x7e);
433
}
434
} else {
436
- if (key->down) {
435
+ if (evt->key.down) {
436
ps2_put_keycode(s, 0xe1);
437
ps2_put_keycode(s, 0x14);
438
ps2_put_keycode(s, 0x77);
@@ -446,7 +445,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
445
}
446
} else if (qcode == Q_KEY_CODE_PRINT) {
447
if (s->modifiers & MOD_ALT_L) {
449
- if (key->down) {
448
+ if (evt->key.down) {
449
ps2_put_keycode(s, 0xf0);
450
ps2_put_keycode(s, 0x11);
451
ps2_put_keycode(s, 0x11);
@@ -459,7 +458,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
458
ps2_put_keycode(s, 0x11);
459
}
460
} else if (s->modifiers & MOD_ALT_R) {
462
- if (key->down) {
461
+ if (evt->key.down) {
462
ps2_put_keycode(s, 0xe0);
463
ps2_put_keycode(s, 0xf0);
464
ps2_put_keycode(s, 0x11);
@@ -477,7 +476,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
476
}
477
} else if (s->modifiers & (MOD_SHIFT_L | MOD_CTRL_L |
478
MOD_SHIFT_R | MOD_CTRL_R)) {
480
- if (key->down) {
479
+ if (evt->key.down) {
480
ps2_put_keycode(s, 0xe0);
481
ps2_put_keycode(s, 0x7c);
482
} else {
@@ -486,7 +485,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
485
ps2_put_keycode(s, 0x7c);
486
}
487
} else {
489
- if (key->down) {
488
+ if (evt->key.down) {
489
ps2_put_keycode(s, 0xe0);
490
ps2_put_keycode(s, 0x12);
491
ps2_put_keycode(s, 0xe0);
@@ -501,7 +500,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
500
}
501
}
502
} else if ((qcode == Q_KEY_CODE_LANG1 || qcode == Q_KEY_CODE_LANG2) &&
504
- !key->down) {
503
+ !evt->key.down) {
504
/* Ignore release for these keys */
505
} else {
506
if (qcode < qemu_input_map_qcode_to_atset2_len) {
@@ -511,7 +510,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
510
if (keycode & 0xff00) {
511
ps2_put_keycode(s, keycode >> 8);
512
}
514
- if (!key->down) {
513
+ if (!evt->key.down) {
514
ps2_put_keycode(s, 0xf0);
515
}
516
ps2_put_keycode(s, keycode & 0xff);
@@ -526,7 +525,7 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
525
}
526
if (keycode) {
527
/* FIXME: break code should be configured on a key by key basis */
529
- if (!key->down) {
528
+ if (!evt->key.down) {
529
ps2_put_keycode(s, 0xf0);
530
}
531
ps2_put_keycode(s, keycode);
@@ -797,8 +796,6 @@ static void ps2_mouse_event(DeviceState *dev, QemuConsole *src,
796
[INPUT_BUTTON_EXTRA] = PS2_MOUSE_BUTTON_EXTRA,
797
};
798
PS2MouseState *s = (PS2MouseState *)dev;
800
- InputMoveEvent *move;
801
- InputBtnEvent *btn;
799
800
/* check if deltas are recorded when disabled */
801
if (!(s->mouse_status & MOUSE_STATUS_ENABLED)) {
@@ -807,31 +804,29 @@ static void ps2_mouse_event(DeviceState *dev, QemuConsole *src,
804
805
switch (evt->type) {
806
case INPUT_EVENT_KIND_REL:
810
- move = evt->u.rel.data;
811
- if (move->axis == INPUT_AXIS_X) {
812
- s->mouse_dx += move->value;
813
- } else if (move->axis == INPUT_AXIS_Y) {
814
- s->mouse_dy -= move->value;
807
+ if (evt->rel.axis == INPUT_AXIS_X) {
808
+ s->mouse_dx += evt->rel.value;
809
+ } else if (evt->rel.axis == INPUT_AXIS_Y) {
810
+ s->mouse_dy -= evt->rel.value;
811
}
812
break;
813
814
case INPUT_EVENT_KIND_BTN:
819
- btn = evt->u.btn.data;
820
- if (btn->down) {
821
- s->mouse_buttons |= bmap[btn->button];
822
- if (btn->button == INPUT_BUTTON_WHEEL_UP) {
815
+ if (evt->btn.down) {
816
+ s->mouse_buttons |= bmap[evt->btn.button];
817
+ if (evt->btn.button == INPUT_BUTTON_WHEEL_UP) {
818
s->mouse_dz--;
824
- } else if (btn->button == INPUT_BUTTON_WHEEL_DOWN) {
819
+ } else if (evt->btn.button == INPUT_BUTTON_WHEEL_DOWN) {
820
s->mouse_dz++;
821
}
822
828
- if (btn->button == INPUT_BUTTON_WHEEL_RIGHT) {
823
+ if (evt->btn.button == INPUT_BUTTON_WHEEL_RIGHT) {
824
s->mouse_dw--;
830
- } else if (btn->button == INPUT_BUTTON_WHEEL_LEFT) {
825
+ } else if (evt->btn.button == INPUT_BUTTON_WHEEL_LEFT) {
826
s->mouse_dw++;
827
}
828
} else {
834
- s->mouse_buttons &= ~bmap[btn->button];
829
+ s->mouse_buttons &= ~bmap[evt->btn.button];
830
}
831
break;
832
hw/input/stellaris_gamepad.c
+4
-5
@@ -19,14 +19,13 @@ static void stellaris_gamepad_event(DeviceState *dev, QemuConsole *src,
19
QemuInputEvent *evt)
20
{
21
StellarisGamepad *s = STELLARIS_GAMEPAD(dev);
22
- InputKeyEvent *key = evt->u.key.data;
23
- int qcode = qemu_input_key_value_to_qcode(key->key);
22
+ int qcode = qemu_input_key_value_to_qcode(&evt->key.key);
23
int i;
24
25
for (i = 0; i < s->num_buttons; i++) {
27
- if (s->keycodes[i] == qcode && s->pressed[i] != key->down) {
28
- s->pressed[i] = key->down;
29
- qemu_set_irq(s->irqs[i], key->down);
26
+ if (s->keycodes[i] == qcode && s->pressed[i] != evt->key.down) {
27
+ s->pressed[i] = evt->key.down;
28
+ qemu_set_irq(s->irqs[i], evt->key.down);
29
}
30
}
31
}
hw/input/virtio-input-hid.c
+22
-31
@@ -84,80 +84,71 @@ static void virtio_input_handle_event(DeviceState *dev, QemuConsole *src,
84
VirtIOInput *vinput = VIRTIO_INPUT(dev);
85
virtio_input_event event;
86
int qcode;
87
- InputKeyEvent *key;
88
- InputMoveEvent *move;
89
- InputBtnEvent *btn;
90
- InputMultiTouchEvent *mtt;
87
88
switch (evt->type) {
89
case INPUT_EVENT_KIND_KEY:
94
- key = evt->u.key.data;
95
- qcode = qemu_input_key_value_to_qcode(key->key);
90
+ qcode = qemu_input_key_value_to_qcode(&evt->key.key);
91
if (qcode < qemu_input_map_qcode_to_linux_len &&
92
qemu_input_map_qcode_to_linux[qcode]) {
93
event.type = cpu_to_le16(EV_KEY);
94
event.code = cpu_to_le16(qemu_input_map_qcode_to_linux[qcode]);
100
- event.value = cpu_to_le32(key->down ? 1 : 0);
95
+ event.value = cpu_to_le32(evt->key.down ? 1 : 0);
96
virtio_input_send(vinput, &event);
97
} else {
103
- if (key->down) {
98
+ if (evt->key.down) {
99
fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__,
100
qcode, QKeyCode_str(qcode));
101
}
102
}
103
break;
104
case INPUT_EVENT_KIND_BTN:
110
- btn = evt->u.btn.data;
111
- if ((btn->button == INPUT_BUTTON_WHEEL_UP ||
112
- btn->button == INPUT_BUTTON_WHEEL_DOWN) &&
113
- btn->down) {
105
+ if ((evt->btn.button == INPUT_BUTTON_WHEEL_UP ||
106
+ evt->btn.button == INPUT_BUTTON_WHEEL_DOWN) &&
107
+ evt->btn.down) {
108
event.type = cpu_to_le16(EV_REL);
109
event.code = cpu_to_le16(REL_WHEEL);
116
- event.value = cpu_to_le32(btn->button == INPUT_BUTTON_WHEEL_UP
110
+ event.value = cpu_to_le32(evt->btn.button == INPUT_BUTTON_WHEEL_UP
111
? 1 : -1);
112
virtio_input_send(vinput, &event);
119
- } else if (keymap_button[btn->button]) {
113
+ } else if (keymap_button[evt->btn.button]) {
114
event.type = cpu_to_le16(EV_KEY);
121
- event.code = cpu_to_le16(keymap_button[btn->button]);
122
- event.value = cpu_to_le32(btn->down ? 1 : 0);
115
+ event.code = cpu_to_le16(keymap_button[evt->btn.button]);
116
+ event.value = cpu_to_le32(evt->btn.down ? 1 : 0);
117
virtio_input_send(vinput, &event);
118
} else {
125
- if (btn->down) {
119
+ if (evt->btn.down) {
120
fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__,
127
- btn->button,
128
- InputButton_str(btn->button));
121
+ evt->btn.button,
122
+ InputButton_str(evt->btn.button));
123
}
124
}
125
break;
126
case INPUT_EVENT_KIND_REL:
133
- move = evt->u.rel.data;
127
event.type = cpu_to_le16(EV_REL);
135
- event.code = cpu_to_le16(axismap_rel[move->axis]);
136
- event.value = cpu_to_le32(move->value);
128
+ event.code = cpu_to_le16(axismap_rel[evt->rel.axis]);
129
+ event.value = cpu_to_le32(evt->rel.value);
130
virtio_input_send(vinput, &event);
131
break;
132
case INPUT_EVENT_KIND_ABS:
140
- move = evt->u.abs.data;
133
event.type = cpu_to_le16(EV_ABS);
142
- event.code = cpu_to_le16(axismap_abs[move->axis]);
143
- event.value = cpu_to_le32(move->value);
134
+ event.code = cpu_to_le16(axismap_abs[evt->abs.axis]);
135
+ event.value = cpu_to_le32(evt->abs.value);
136
virtio_input_send(vinput, &event);
137
break;
138
case INPUT_EVENT_KIND_MTT:
147
- mtt = evt->u.mtt.data;
148
- if (mtt->type == INPUT_MULTI_TOUCH_TYPE_DATA) {
139
+ if (evt->mtt.type == INPUT_MULTI_TOUCH_TYPE_DATA) {
140
event.type = cpu_to_le16(EV_ABS);
150
- event.code = cpu_to_le16(axismap_tch[mtt->axis]);
151
- event.value = cpu_to_le32(mtt->value);
141
+ event.code = cpu_to_le16(axismap_tch[evt->mtt.axis]);
142
+ event.value = cpu_to_le32(evt->mtt.value);
143
virtio_input_send(vinput, &event);
144
} else {
145
event.type = cpu_to_le16(EV_ABS);
146
event.code = cpu_to_le16(ABS_MT_SLOT);
156
- event.value = cpu_to_le32(mtt->slot);
147
+ event.value = cpu_to_le32(evt->mtt.slot);
148
virtio_input_send(vinput, &event);
149
event.type = cpu_to_le16(EV_ABS);
150
event.code = cpu_to_le16(ABS_MT_TRACKING_ID);
160
- event.value = cpu_to_le32(mtt->tracking_id);
151
+ event.value = cpu_to_le32(evt->mtt.tracking_id);
152
virtio_input_send(vinput, &event);
153
}
154
break;
hw/m68k/next-kbd.c
+4
-5
@@ -247,16 +247,15 @@ static void nextkbd_event(DeviceState *dev, QemuConsole *src,
247
{
248
NextKBDState *s = NEXTKBD(dev);
249
int qcode, keycode;
250
- bool key_down = evt->u.key.data->down;
250
252
- qcode = qemu_input_key_value_to_qcode(evt->u.key.data->key);
251
+ qcode = qemu_input_key_value_to_qcode(&evt->key.key);
252
if (qcode >= ARRAY_SIZE(qcode_to_nextkbd_keycode)) {
253
return;
254
}
255
256
/* Shift key currently has no keycode, so handle separately */
257
if (qcode == Q_KEY_CODE_SHIFT) {
259
- if (key_down) {
258
+ if (evt->key.down) {
259
s->shift |= KD_LSHIFT;
260
} else {
261
s->shift &= ~KD_LSHIFT;
@@ -264,7 +263,7 @@ static void nextkbd_event(DeviceState *dev, QemuConsole *src,
263
}
264
265
if (qcode == Q_KEY_CODE_SHIFT_R) {
267
- if (key_down) {
266
+ if (evt->key.down) {
267
s->shift |= KD_RSHIFT;
268
} else {
269
s->shift &= ~KD_RSHIFT;
@@ -277,7 +276,7 @@ static void nextkbd_event(DeviceState *dev, QemuConsole *src,
276
}
277
278
/* If key release event, create keyboard break code */
280
- if (!key_down) {
279
+ if (!evt->key.down) {
280
keycode |= 0x80;
281
}
282
include/qemu/typedefs.h
+1
-1
@@ -94,7 +94,7 @@ typedef struct QBool QBool;
94
typedef struct QDict QDict;
95
typedef struct QEMUBH QEMUBH;
96
typedef struct QemuConsole QemuConsole;
97
-typedef struct InputEvent QemuInputEvent;
97
+typedef struct QemuInputEvent QemuInputEvent;
98
typedef struct QEMUCursor QEMUCursor;
99
typedef struct QEMUFile QEMUFile;
100
typedef struct QemuMutex QemuMutex;
include/ui/input.h
+16
@@ -18,6 +18,22 @@
18
typedef struct QemuInputHandler QemuInputHandler;
19
typedef struct QemuInputHandlerState QemuInputHandlerState;
20
21
+typedef struct QemuInputKeyEvent {
22
+ KeyValue key;
23
+ bool down;
24
+} QemuInputKeyEvent;
25
+
26
+typedef struct QemuInputEvent {
27
+ InputEventKind type;
28
+ union {
29
+ QemuInputKeyEvent key;
30
+ InputBtnEvent btn;
31
+ InputMoveEvent rel;
32
+ InputMoveEvent abs;
33
+ InputMultiTouchEvent mtt;
34
+ };
35
+} QemuInputEvent;
36
+
37
typedef void (*QemuInputHandlerEvent)(DeviceState *dev, QemuConsole *src,
38
QemuInputEvent *evt);
39
typedef void (*QemuInputHandlerSync)(DeviceState *dev);
replay/replay-events.c
+1
-1
@@ -42,7 +42,7 @@ static void replay_run_event(Event *event)
42
break;
43
case REPLAY_ASYNC_EVENT_INPUT:
44
qemu_input_event_send_impl(NULL, (QemuInputEvent *)event->opaque);
45
- qapi_free_InputEvent((InputEvent *)event->opaque);
45
+ g_free(event->opaque);
46
break;
47
case REPLAY_ASYNC_EVENT_INPUT_SYNC:
48
qemu_input_event_sync_impl();
replay/replay-input.c
+41
-60
@@ -19,25 +19,20 @@
19
20
void replay_save_input_event(QemuInputEvent *evt)
21
{
22
- InputKeyEvent *key;
23
- InputBtnEvent *btn;
24
- InputMoveEvent *move;
25
- InputMultiTouchEvent *mtt;
22
replay_put_dword(evt->type);
23
24
switch (evt->type) {
25
case INPUT_EVENT_KIND_KEY:
30
- key = evt->u.key.data;
31
- replay_put_dword(key->key->type);
26
+ replay_put_dword(evt->key.key.type);
27
33
- switch (key->key->type) {
28
+ switch (evt->key.key.type) {
29
case KEY_VALUE_KIND_NUMBER:
35
- replay_put_qword(key->key->u.number.data);
36
- replay_put_byte(key->down);
30
+ replay_put_qword(evt->key.key.u.number.data);
31
+ replay_put_byte(evt->key.down);
32
break;
33
case KEY_VALUE_KIND_QCODE:
39
- replay_put_dword(key->key->u.qcode.data);
40
- replay_put_byte(key->down);
34
+ replay_put_dword(evt->key.key.u.qcode.data);
35
+ replay_put_byte(evt->key.down);
36
break;
37
case KEY_VALUE_KIND__MAX:
38
/* keep gcc happy */
@@ -45,27 +40,23 @@ void replay_save_input_event(QemuInputEvent *evt)
40
}
41
break;
42
case INPUT_EVENT_KIND_BTN:
48
- btn = evt->u.btn.data;
49
- replay_put_dword(btn->button);
50
- replay_put_byte(btn->down);
43
+ replay_put_dword(evt->btn.button);
44
+ replay_put_byte(evt->btn.down);
45
break;
46
case INPUT_EVENT_KIND_REL:
53
- move = evt->u.rel.data;
54
- replay_put_dword(move->axis);
55
- replay_put_qword(move->value);
47
+ replay_put_dword(evt->rel.axis);
48
+ replay_put_qword(evt->rel.value);
49
break;
50
case INPUT_EVENT_KIND_ABS:
58
- move = evt->u.abs.data;
59
- replay_put_dword(move->axis);
60
- replay_put_qword(move->value);
51
+ replay_put_dword(evt->abs.axis);
52
+ replay_put_qword(evt->abs.value);
53
break;
54
case INPUT_EVENT_KIND_MTT:
63
- mtt = evt->u.mtt.data;
64
- replay_put_dword(mtt->type);
65
- replay_put_qword(mtt->slot);
66
- replay_put_qword(mtt->tracking_id);
67
- replay_put_dword(mtt->axis);
68
- replay_put_qword(mtt->value);
55
+ replay_put_dword(evt->mtt.type);
56
+ replay_put_qword(evt->mtt.slot);
57
+ replay_put_qword(evt->mtt.tracking_id);
58
+ replay_put_dword(evt->mtt.axis);
59
+ replay_put_qword(evt->mtt.value);
60
break;
61
case INPUT_EVENT_KIND__MAX:
62
/* keep gcc happy */
@@ -75,29 +66,21 @@ void replay_save_input_event(QemuInputEvent *evt)
66
67
QemuInputEvent *replay_read_input_event(void)
68
{
78
- QemuInputEvent evt;
79
- KeyValue keyValue;
80
- InputKeyEvent key;
81
- key.key = &keyValue;
82
- InputBtnEvent btn;
83
- InputMoveEvent rel;
84
- InputMoveEvent abs;
85
- InputMultiTouchEvent mtt;
69
+ QemuInputEvent *evt = g_new(QemuInputEvent, 1);
70
87
- evt.type = replay_get_dword();
88
- switch (evt.type) {
71
+ evt->type = replay_get_dword();
72
+ switch (evt->type) {
73
case INPUT_EVENT_KIND_KEY:
90
- evt.u.key.data = &key;
91
- evt.u.key.data->key->type = replay_get_dword();
74
+ evt->key.key.type = replay_get_dword();
75
93
- switch (evt.u.key.data->key->type) {
76
+ switch (evt->key.key.type) {
77
case KEY_VALUE_KIND_NUMBER:
95
- evt.u.key.data->key->u.number.data = replay_get_qword();
96
- evt.u.key.data->down = replay_get_byte();
78
+ evt->key.key.u.number.data = replay_get_qword();
79
+ evt->key.down = replay_get_byte();
80
break;
81
case KEY_VALUE_KIND_QCODE:
99
- evt.u.key.data->key->u.qcode.data = (QKeyCode)replay_get_dword();
100
- evt.u.key.data->down = replay_get_byte();
82
+ evt->key.key.u.qcode.data = (QKeyCode)replay_get_dword();
83
+ evt->key.down = replay_get_byte();
84
break;
85
case KEY_VALUE_KIND__MAX:
86
/* keep gcc happy */
@@ -105,34 +88,30 @@ QemuInputEvent *replay_read_input_event(void)
88
}
89
break;
90
case INPUT_EVENT_KIND_BTN:
108
- evt.u.btn.data = &btn;
109
- evt.u.btn.data->button = (InputButton)replay_get_dword();
110
- evt.u.btn.data->down = replay_get_byte();
91
+ evt->btn.button = (InputButton)replay_get_dword();
92
+ evt->btn.down = replay_get_byte();
93
break;
94
case INPUT_EVENT_KIND_REL:
113
- evt.u.rel.data = &rel;
114
- evt.u.rel.data->axis = (InputAxis)replay_get_dword();
115
- evt.u.rel.data->value = replay_get_qword();
95
+ evt->rel.axis = (InputAxis)replay_get_dword();
96
+ evt->rel.value = replay_get_qword();
97
break;
98
case INPUT_EVENT_KIND_ABS:
118
- evt.u.abs.data = &abs;
119
- evt.u.abs.data->axis = (InputAxis)replay_get_dword();
120
- evt.u.abs.data->value = replay_get_qword();
99
+ evt->abs.axis = (InputAxis)replay_get_dword();
100
+ evt->abs.value = replay_get_qword();
101
break;
102
case INPUT_EVENT_KIND_MTT:
123
- evt.u.mtt.data = &mtt;
124
- evt.u.mtt.data->type = (InputMultiTouchType)replay_get_dword();
125
- evt.u.mtt.data->slot = replay_get_qword();
126
- evt.u.mtt.data->tracking_id = replay_get_qword();
127
- evt.u.mtt.data->axis = (InputAxis)replay_get_dword();
128
- evt.u.mtt.data->value = replay_get_qword();
103
+ evt->mtt.type = (InputMultiTouchType)replay_get_dword();
104
+ evt->mtt.slot = replay_get_qword();
105
+ evt->mtt.tracking_id = replay_get_qword();
106
+ evt->mtt.axis = (InputAxis)replay_get_dword();
107
+ evt->mtt.value = replay_get_qword();
108
break;
109
case INPUT_EVENT_KIND__MAX:
110
/* keep gcc happy */
111
break;
112
}
113
135
- return QAPI_CLONE(InputEvent, &evt);
114
+ return evt;
115
}
116
117
void replay_input_event(QemuConsole *src, QemuInputEvent *evt)
@@ -140,7 +119,9 @@ void replay_input_event(QemuConsole *src, QemuInputEvent *evt)
119
if (replay_mode == REPLAY_MODE_PLAY) {
120
/* Nothing */
121
} else if (replay_mode == REPLAY_MODE_RECORD) {
143
- replay_add_input_event(QAPI_CLONE(InputEvent, evt));
122
+ QemuInputEvent *clone = g_new(QemuInputEvent, 1);
123
+ *clone = *evt;
124
+ replay_add_input_event(clone);
125
} else {
126
qemu_input_event_send_impl(src, evt);
127
}
ui/input-legacy.c
+9
-14
@@ -118,39 +118,36 @@ static void legacy_mouse_event(DeviceState *dev, QemuConsole *src,
118
[INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
119
};
120
QEMUPutMouseEntry *s = (QEMUPutMouseEntry *)dev;
121
- InputBtnEvent *btn;
122
- InputMoveEvent *move;
121
122
switch (evt->type) {
123
case INPUT_EVENT_KIND_BTN:
126
- btn = evt->u.btn.data;
127
- if (btn->down) {
128
- s->buttons |= bmap[btn->button];
124
+ if (evt->btn.down) {
125
+ s->buttons |= bmap[evt->btn.button];
126
} else {
130
- s->buttons &= ~bmap[btn->button];
127
+ s->buttons &= ~bmap[evt->btn.button];
128
}
132
- if (btn->down && btn->button == INPUT_BUTTON_WHEEL_UP) {
129
+ if (evt->btn.down && evt->btn.button == INPUT_BUTTON_WHEEL_UP) {
130
s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque,
131
s->axis[INPUT_AXIS_X],
132
s->axis[INPUT_AXIS_Y],
133
-1,
134
s->buttons);
135
}
139
- if (btn->down && btn->button == INPUT_BUTTON_WHEEL_DOWN) {
136
+ if (evt->btn.down && evt->btn.button == INPUT_BUTTON_WHEEL_DOWN) {
137
s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque,
138
s->axis[INPUT_AXIS_X],
139
s->axis[INPUT_AXIS_Y],
140
1,
141
s->buttons);
142
}
146
- if (btn->down && btn->button == INPUT_BUTTON_WHEEL_RIGHT) {
143
+ if (evt->btn.down && evt->btn.button == INPUT_BUTTON_WHEEL_RIGHT) {
144
s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque,
145
s->axis[INPUT_AXIS_X],
146
s->axis[INPUT_AXIS_Y],
147
-2,
148
s->buttons);
149
}
153
- if (btn->down && btn->button == INPUT_BUTTON_WHEEL_LEFT) {
150
+ if (evt->btn.down && evt->btn.button == INPUT_BUTTON_WHEEL_LEFT) {
151
s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque,
152
s->axis[INPUT_AXIS_X],
153
s->axis[INPUT_AXIS_Y],
@@ -159,12 +156,10 @@ static void legacy_mouse_event(DeviceState *dev, QemuConsole *src,
156
}
157
break;
158
case INPUT_EVENT_KIND_ABS:
162
- move = evt->u.abs.data;
163
- s->axis[move->axis] = move->value;
159
+ s->axis[evt->abs.axis] = evt->abs.value;
160
break;
161
case INPUT_EVENT_KIND_REL:
166
- move = evt->u.rel.data;
167
- s->axis[move->axis] += move->value;
162
+ s->axis[evt->rel.axis] += evt->rel.value;
163
break;
164
default:
165
break;
ui/input.c
+102
-75
@@ -30,7 +30,7 @@ struct QemuInputEventQueue {
30
QEMUTimer *timer;
31
uint32_t delay_ms;
32
QemuConsole *src;
33
- QemuInputEvent *evt;
33
+ QemuInputEvent evt;
34
QTAILQ_ENTRY(QemuInputEventQueue) node;
35
};
36
@@ -159,16 +159,54 @@ void qmp_input_send_event(const char *device,
159
}
160
161
for (e = events; e != NULL; e = e->next) {
162
- InputEvent *evt = e->value;
162
+ InputEvent *qapi = e->value;
163
+ QemuInputEvent evt;
164
+
165
+ evt.type = qapi->type;
166
+
167
+ switch (qapi->type) {
168
+ case INPUT_EVENT_KIND_KEY: {
169
+ KeyValue *key = qapi->u.key.data->key;
170
+ QKeyCode code;
171
+
172
+ switch (key->type) {
173
+ case KEY_VALUE_KIND_NUMBER:
174
+ code = qemu_input_key_number_to_qcode(key->u.number.data);
175
+ break;
176
+ case KEY_VALUE_KIND_QCODE:
177
+ code = key->u.qcode.data;
178
+ break;
179
+ default:
180
+ g_assert_not_reached();
181
+ }
182
+
183
+ evt.key.key.type = KEY_VALUE_KIND_QCODE;
184
+ evt.key.key.u.qcode.data = code;
185
+ evt.key.down = qapi->u.key.data->down;
186
+ break;
187
+ }
188
164
- if (evt->type == INPUT_EVENT_KIND_KEY &&
165
- evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER) {
166
- KeyValue *key = evt->u.key.data->key;
167
- QKeyCode code = qemu_input_key_number_to_qcode(key->u.number.data);
168
- qemu_input_event_send_key_qcode(con, code, evt->u.key.data->down);
169
- } else {
170
- qemu_input_event_send(con, evt);
189
+ case INPUT_EVENT_KIND_BTN:
190
+ evt.btn = *qapi->u.btn.data;
191
+ break;
192
+
193
+ case INPUT_EVENT_KIND_REL:
194
+ evt.rel = *qapi->u.rel.data;
195
+ break;
196
+
197
+ case INPUT_EVENT_KIND_ABS:
198
+ evt.abs = *qapi->u.abs.data;
199
+ break;
200
+
201
+ case INPUT_EVENT_KIND_MTT:
202
+ evt.mtt = *qapi->u.mtt.data;
203
+ break;
204
+
205
+ default:
206
+ g_assert_not_reached();
207
}
208
+
209
+ qemu_input_event_send(con, &evt);
210
}
211
212
qemu_input_event_sync();
@@ -178,7 +216,7 @@ static void qemu_input_event_trace(QemuConsole *src, QemuInputEvent *evt)
216
{
217
const char *name;
218
int qcode, idx = -1;
181
- InputKeyEvent *key;
219
+ QemuInputKeyEvent *key;
220
InputBtnEvent *btn;
221
InputMoveEvent *move;
222
InputMultiTouchEvent *mtt;
@@ -188,16 +226,16 @@ static void qemu_input_event_trace(QemuConsole *src, QemuInputEvent *evt)
226
}
227
switch (evt->type) {
228
case INPUT_EVENT_KIND_KEY:
191
- key = evt->u.key.data;
192
- switch (key->key->type) {
229
+ key = &evt->key;
230
+ switch (evt->key.key.type) {
231
case KEY_VALUE_KIND_NUMBER:
194
- qcode = qemu_input_key_number_to_qcode(key->key->u.number.data);
232
+ qcode = qemu_input_key_number_to_qcode(key->key.u.number.data);
233
name = QKeyCode_str(qcode);
196
- trace_input_event_key_number(idx, key->key->u.number.data,
234
+ trace_input_event_key_number(idx, key->key.u.number.data,
235
name, key->down);
236
break;
237
case KEY_VALUE_KIND_QCODE:
200
- name = QKeyCode_str(key->key->u.qcode.data);
238
+ name = QKeyCode_str(key->key.u.qcode.data);
239
trace_input_event_key_qcode(idx, name, key->down);
240
break;
241
case KEY_VALUE_KIND__MAX:
@@ -206,22 +244,22 @@ static void qemu_input_event_trace(QemuConsole *src, QemuInputEvent *evt)
244
}
245
break;
246
case INPUT_EVENT_KIND_BTN:
209
- btn = evt->u.btn.data;
247
+ btn = &evt->btn;
248
name = btn->button < INPUT_BUTTON__MAX ? InputButton_str(btn->button) : "invalid";
249
trace_input_event_btn(idx, name, btn->down);
250
break;
251
case INPUT_EVENT_KIND_REL:
214
- move = evt->u.rel.data;
252
+ move = &evt->rel;
253
name = move->axis < INPUT_AXIS__MAX ? InputAxis_str(move->axis) : "invalid";
254
trace_input_event_rel(idx, name, move->value);
255
break;
256
case INPUT_EVENT_KIND_ABS:
219
- move = evt->u.abs.data;
257
+ move = &evt->abs;
258
name = move->axis < INPUT_AXIS__MAX ? InputAxis_str(move->axis) : "invalid";
259
trace_input_event_abs(idx, name, move->value);
260
break;
261
case INPUT_EVENT_KIND_MTT:
224
- mtt = evt->u.mtt.data;
262
+ mtt = &evt->mtt;
263
name = mtt->axis < INPUT_AXIS__MAX ? InputAxis_str(mtt->axis) : "invalid";
264
trace_input_event_mtt(idx, name, mtt->value);
265
break;
@@ -251,8 +289,7 @@ static void qemu_input_queue_process(void *opaque)
289
+ item->delay_ms);
290
return;
291
case QEMU_INPUT_QUEUE_EVENT:
254
- qemu_input_event_send(item->src, item->evt);
255
- qapi_free_InputEvent(item->evt);
292
+ qemu_input_event_send(item->src, &item->evt);
293
break;
294
case QEMU_INPUT_QUEUE_SYNC:
295
qemu_input_event_sync();
@@ -289,7 +326,7 @@ static void qemu_input_queue_event(QemuInputEventQueueHead *queue,
326
327
item->type = QEMU_INPUT_QUEUE_EVENT;
328
item->src = src;
292
- item->evt = evt;
329
+ item->evt = *evt;
330
QTAILQ_INSERT_TAIL(queue, item, node);
331
queue_count++;
332
}
@@ -323,7 +360,7 @@ void qemu_input_event_send(QemuConsole *src, QemuInputEvent *evt)
360
/* Expect all parts of QEMU to send events with QCodes exclusively.
361
* Key numbers are only supported as end-user input via QMP */
362
assert(!(evt->type == INPUT_EVENT_KIND_KEY &&
326
- evt->u.key.data->key->type == KEY_VALUE_KIND_NUMBER));
363
+ evt->key.key.type == KEY_VALUE_KIND_NUMBER));
364
365
366
/*
@@ -335,8 +372,8 @@ void qemu_input_event_send(QemuConsole *src, QemuInputEvent *evt)
372
* need to deal with this mistake
373
*/
374
if (evt->type == INPUT_EVENT_KIND_KEY &&
338
- evt->u.key.data->key->u.qcode.data == Q_KEY_CODE_SYSRQ) {
339
- evt->u.key.data->key->u.qcode.data = Q_KEY_CODE_PRINT;
375
+ evt->key.key.u.qcode.data == Q_KEY_CODE_SYSRQ) {
376
+ evt->key.key.u.qcode.data = Q_KEY_CODE_PRINT;
377
}
378
379
if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
@@ -372,29 +409,24 @@ void qemu_input_event_sync(void)
409
replay_input_sync_event();
410
}
411
375
-static QemuInputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
376
-{
377
- QemuInputEvent *evt = g_new0(QemuInputEvent, 1);
378
- evt->u.key.data = g_new0(InputKeyEvent, 1);
379
- evt->type = INPUT_EVENT_KIND_KEY;
380
- evt->u.key.data->key = key;
381
- evt->u.key.data->down = down;
382
- return evt;
383
-}
384
-
412
void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
413
{
387
- QemuInputEvent *evt;
388
- evt = qemu_input_event_new_key(key, down);
414
+ QemuInputEvent evt = {
415
+ .type = INPUT_EVENT_KIND_KEY,
416
+ .key = {
417
+ .key = *key,
418
+ .down = down,
419
+ },
420
+ };
421
+
422
+ g_free(key);
423
+
424
if (QTAILQ_EMPTY(&kbd_queue)) {
390
- qemu_input_event_send(src, evt);
425
+ qemu_input_event_send(src, &evt);
426
qemu_input_event_sync();
392
- qapi_free_InputEvent(evt);
427
} else if (queue_count < queue_limit) {
394
- qemu_input_queue_event(&kbd_queue, src, evt);
428
+ qemu_input_queue_event(&kbd_queue, src, &evt);
429
qemu_input_queue_sync(&kbd_queue);
396
- } else {
397
- qapi_free_InputEvent(evt);
430
}
431
}
432
@@ -431,13 +463,12 @@ void qemu_input_event_send_key_delay(uint32_t delay_ms)
463
464
void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
465
{
434
- InputBtnEvent bevt = {
435
- .button = btn,
436
- .down = down,
437
- };
466
QemuInputEvent evt = {
467
.type = INPUT_EVENT_KIND_BTN,
440
- .u.btn.data = &bevt,
468
+ .btn = {
469
+ .button = btn,
470
+ .down = down,
471
+ }
472
};
473
474
qemu_input_event_send(src, &evt);
@@ -482,13 +513,12 @@ int qemu_input_scale_axis(int value,
513
514
void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
515
{
485
- InputMoveEvent move = {
486
- .axis = axis,
487
- .value = value,
488
- };
516
QemuInputEvent evt = {
517
.type = INPUT_EVENT_KIND_REL,
491
- .u.rel.data = &move,
518
+ .rel = {
519
+ .axis = axis,
520
+ .value = value,
521
+ },
522
};
523
524
qemu_input_event_send(src, &evt);
@@ -497,15 +527,14 @@ void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
527
void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value,
528
int min_in, int max_in)
529
{
500
- InputMoveEvent move = {
501
- .axis = axis,
502
- .value = qemu_input_scale_axis(value, min_in, max_in,
503
- INPUT_EVENT_ABS_MIN,
504
- INPUT_EVENT_ABS_MAX),
505
- };
530
QemuInputEvent evt = {
531
.type = INPUT_EVENT_KIND_ABS,
508
- .u.abs.data = &move,
532
+ .abs = {
533
+ .axis = axis,
534
+ .value = qemu_input_scale_axis(value, min_in, max_in,
535
+ INPUT_EVENT_ABS_MIN,
536
+ INPUT_EVENT_ABS_MAX),
537
+ },
538
};
539
540
qemu_input_event_send(src, &evt);
@@ -514,14 +543,13 @@ void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value,
543
void qemu_input_queue_mtt(QemuConsole *src, InputMultiTouchType type,
544
int slot, int tracking_id)
545
{
517
- InputMultiTouchEvent mtt = {
518
- .type = type,
519
- .slot = slot,
520
- .tracking_id = tracking_id,
521
- };
546
QemuInputEvent evt = {
547
.type = INPUT_EVENT_KIND_MTT,
524
- .u.mtt.data = &mtt,
548
+ .mtt = {
549
+ .type = type,
550
+ .slot = slot,
551
+ .tracking_id = tracking_id,
552
+ },
553
};
554
555
qemu_input_event_send(src, &evt);
@@ -530,18 +558,17 @@ void qemu_input_queue_mtt(QemuConsole *src, InputMultiTouchType type,
558
void qemu_input_queue_mtt_abs(QemuConsole *src, InputAxis axis, int value,
559
int min_in, int max_in, int slot, int tracking_id)
560
{
533
- InputMultiTouchEvent mtt = {
534
- .type = INPUT_MULTI_TOUCH_TYPE_DATA,
535
- .slot = slot,
536
- .tracking_id = tracking_id,
537
- .axis = axis,
538
- .value = qemu_input_scale_axis(value, min_in, max_in,
539
- INPUT_EVENT_ABS_MIN,
540
- INPUT_EVENT_ABS_MAX),
541
- };
561
QemuInputEvent evt = {
562
.type = INPUT_EVENT_KIND_MTT,
544
- .u.mtt.data = &mtt,
563
+ .mtt = {
564
+ .type = INPUT_MULTI_TOUCH_TYPE_DATA,
565
+ .slot = slot,
566
+ .tracking_id = tracking_id,
567
+ .axis = axis,
568
+ .value = qemu_input_scale_axis(value, min_in, max_in,
569
+ INPUT_EVENT_ABS_MIN,
570
+ INPUT_EVENT_ABS_MAX),
571
+ }
572
};
573
574
qemu_input_event_send(src, &evt);
ui/vdagent.c
+7
-11
@@ -241,22 +241,19 @@ static void vdagent_pointer_event(DeviceState *dev, QemuConsole *src,
241
};
242
243
VDAgentChardev *vd = container_of(dev, struct VDAgentChardev, mouse_dev);
244
- InputMoveEvent *move;
245
- InputBtnEvent *btn;
244
uint32_t xres, yres;
245
246
switch (evt->type) {
247
case INPUT_EVENT_KIND_ABS:
250
- move = evt->u.abs.data;
248
xres = qemu_console_get_width(src, 1024);
249
yres = qemu_console_get_height(src, 768);
253
- if (move->axis == INPUT_AXIS_X) {
254
- vd->mouse_x = qemu_input_scale_axis(move->value,
250
+ if (evt->abs.axis == INPUT_AXIS_X) {
251
+ vd->mouse_x = qemu_input_scale_axis(evt->abs.value,
252
INPUT_EVENT_ABS_MIN,
253
INPUT_EVENT_ABS_MAX,
254
0, xres);
258
- } else if (move->axis == INPUT_AXIS_Y) {
259
- vd->mouse_y = qemu_input_scale_axis(move->value,
255
+ } else if (evt->abs.axis == INPUT_AXIS_Y) {
256
+ vd->mouse_y = qemu_input_scale_axis(evt->abs.value,
257
INPUT_EVENT_ABS_MIN,
258
INPUT_EVENT_ABS_MAX,
259
0, yres);
@@ -265,11 +262,10 @@ static void vdagent_pointer_event(DeviceState *dev, QemuConsole *src,
262
break;
263
264
case INPUT_EVENT_KIND_BTN:
268
- btn = evt->u.btn.data;
269
- if (btn->down) {
270
- vd->mouse_btn |= bmap[btn->button];
265
+ if (evt->btn.down) {
266
+ vd->mouse_btn |= bmap[evt->btn.button];
267
} else {
272
- vd->mouse_btn &= ~bmap[btn->button];
268
+ vd->mouse_btn &= ~bmap[evt->btn.button];
269
}
270
break;
271