vitalif
/
mirror_qemu
mirror of https://github.com/proxmox/mirror_qemu
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

input: Convert to new qapi union layout 

We have two issues with our qapi union layout:
1) Even though the QMP wire format spells the tag 'type', the
C code spells it 'kind', requiring some hacks in the generator.
2) The C struct uses an anonymous union, which places all tag
values in the same namespace as all non-variant members. This
leads to spurious collisions if a tag value matches a non-variant
member's name.

Make the conversion to the new layout for input-related code.

Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1445898903-12082-20-git-send-email-eblake@redhat.com>
[Commit message tweaked slightly]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
master
Eric Blake 2015-10-26 16:34:58 -06:00 committed by Markus Armbruster
parent 130257dc44
commit 568c73a478
9 changed files with 125 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
hmp.c
View File

@ -1735,15 +1735,15 @@ void hmp_sendkey(Monitor *mon, const QDict *qdict)
if (*endp != '\0') { if (*endp != '\0') {
goto err_out; goto err_out;
} }
keylist->value->kind = KEY_VALUE_KIND_NUMBER; keylist->value->type = KEY_VALUE_KIND_NUMBER;
keylist->value->number = value; keylist->value->u.number = value;
} else { } else {
int idx = index_from_key(keyname_buf); int idx = index_from_key(keyname_buf);
if (idx == Q_KEY_CODE_MAX) { if (idx == Q_KEY_CODE_MAX) {
goto err_out; goto err_out;
} }
keylist->value->kind = KEY_VALUE_KIND_QCODE; keylist->value->type = KEY_VALUE_KIND_QCODE;
keylist->value->qcode = idx; keylist->value->u.qcode = idx;
} }
if (!separator) { if (!separator) {

12
hw/char/escc.c
View File

@ -842,13 +842,13 @@ static void sunkbd_handle_event(DeviceState *dev, QemuConsole *src,
ChannelState *s = (ChannelState *)dev; ChannelState *s = (ChannelState *)dev;
int qcode, keycode; int qcode, keycode;
assert(evt->kind == INPUT_EVENT_KIND_KEY); assert(evt->type == INPUT_EVENT_KIND_KEY);
qcode = qemu_input_key_value_to_qcode(evt->key->key); qcode = qemu_input_key_value_to_qcode(evt->u.key->key);
trace_escc_sunkbd_event_in(qcode, QKeyCode_lookup[qcode], trace_escc_sunkbd_event_in(qcode, QKeyCode_lookup[qcode],
evt->key->down); evt->u.key->down);
if (qcode == Q_KEY_CODE_CAPS_LOCK) { if (qcode == Q_KEY_CODE_CAPS_LOCK) {
if (evt->key->down) { if (evt->u.key->down) {
s->caps_lock_mode ^= 1; s->caps_lock_mode ^= 1;
if (s->caps_lock_mode == 2) { if (s->caps_lock_mode == 2) {
return; /* Drop second press */ return; /* Drop second press */
@ -862,7 +862,7 @@ static void sunkbd_handle_event(DeviceState *dev, QemuConsole *src,
} }
if (qcode == Q_KEY_CODE_NUM_LOCK) { if (qcode == Q_KEY_CODE_NUM_LOCK) {
if (evt->key->down) { if (evt->u.key->down) {
s->num_lock_mode ^= 1; s->num_lock_mode ^= 1;
if (s->num_lock_mode == 2) { if (s->num_lock_mode == 2) {
return; /* Drop second press */ return; /* Drop second press */
@ -876,7 +876,7 @@ static void sunkbd_handle_event(DeviceState *dev, QemuConsole *src,
} }
keycode = qcode_to_keycode[qcode]; keycode = qcode_to_keycode[qcode];
if (!evt->key->down) { if (!evt->u.key->down) {
keycode |= 0x80; keycode |= 0x80;
} }
trace_escc_sunkbd_event_out(keycode); trace_escc_sunkbd_event_out(keycode);

32
hw/input/hid.c
View File

@ -119,33 +119,33 @@ static void hid_pointer_event(DeviceState *dev, QemuConsole *src,
assert(hs->n < QUEUE_LENGTH); assert(hs->n < QUEUE_LENGTH);
e = &hs->ptr.queue[(hs->head + hs->n) & QUEUE_MASK]; e = &hs->ptr.queue[(hs->head + hs->n) & QUEUE_MASK];
switch (evt->kind) { switch (evt->type) {
case INPUT_EVENT_KIND_REL: case INPUT_EVENT_KIND_REL:
if (evt->rel->axis == INPUT_AXIS_X) { if (evt->u.rel->axis == INPUT_AXIS_X) {
e->xdx += evt->rel->value; e->xdx += evt->u.rel->value;
} else if (evt->rel->axis == INPUT_AXIS_Y) { } else if (evt->u.rel->axis == INPUT_AXIS_Y) {
e->ydy += evt->rel->value; e->ydy += evt->u.rel->value;
} }
break; break;
case INPUT_EVENT_KIND_ABS: case INPUT_EVENT_KIND_ABS:
if (evt->rel->axis == INPUT_AXIS_X) { if (evt->u.rel->axis == INPUT_AXIS_X) {
e->xdx = evt->rel->value; e->xdx = evt->u.rel->value;
} else if (evt->rel->axis == INPUT_AXIS_Y) { } else if (evt->u.rel->axis == INPUT_AXIS_Y) {
e->ydy = evt->rel->value; e->ydy = evt->u.rel->value;
} }
break; break;
case INPUT_EVENT_KIND_BTN: case INPUT_EVENT_KIND_BTN:
if (evt->btn->down) { if (evt->u.btn->down) {
e->buttons_state |= bmap[evt->btn->button]; e->buttons_state |= bmap[evt->u.btn->button];
if (evt->btn->button == INPUT_BUTTON_WHEEL_UP) { if (evt->u.btn->button == INPUT_BUTTON_WHEEL_UP) {
e->dz--; e->dz--;
} else if (evt->btn->button == INPUT_BUTTON_WHEEL_DOWN) { } else if (evt->u.btn->button == INPUT_BUTTON_WHEEL_DOWN) {
e->dz++; e->dz++;
} }
} else { } else {
e->buttons_state &= ~bmap[evt->btn->button]; e->buttons_state &= ~bmap[evt->u.btn->button];
} }
break; break;
@ -223,8 +223,8 @@ static void hid_keyboard_event(DeviceState *dev, QemuConsole *src,
int scancodes[3], i, count; int scancodes[3], i, count;
int slot; int slot;
count = qemu_input_key_value_to_scancode(evt->key->key, count = qemu_input_key_value_to_scancode(evt->u.key->key,
evt->key->down, evt->u.key->down,
scancodes); scancodes);
if (hs->n + count > QUEUE_LENGTH) { if (hs->n + count > QUEUE_LENGTH) {
fprintf(stderr, "usb-kbd: warning: key event queue full\n"); fprintf(stderr, "usb-kbd: warning: key event queue full\n");

24
hw/input/ps2.c
View File

@ -183,8 +183,8 @@ static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
int scancodes[3], i, count; int scancodes[3], i, count;
qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER); qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
count = qemu_input_key_value_to_scancode(evt->key->key, count = qemu_input_key_value_to_scancode(evt->u.key->key,
evt->key->down, evt->u.key->down,
scancodes); scancodes);
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
ps2_put_keycode(s, scancodes[i]); ps2_put_keycode(s, scancodes[i]);
@ -393,25 +393,25 @@ static void ps2_mouse_event(DeviceState *dev, QemuConsole *src,
if (!(s->mouse_status & MOUSE_STATUS_ENABLED)) if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
return; return;
switch (evt->kind) { switch (evt->type) {
case INPUT_EVENT_KIND_REL: case INPUT_EVENT_KIND_REL:
if (evt->rel->axis == INPUT_AXIS_X) { if (evt->u.rel->axis == INPUT_AXIS_X) {
s->mouse_dx += evt->rel->value; s->mouse_dx += evt->u.rel->value;
} else if (evt->rel->axis == INPUT_AXIS_Y) { } else if (evt->u.rel->axis == INPUT_AXIS_Y) {
s->mouse_dy -= evt->rel->value; s->mouse_dy -= evt->u.rel->value;
} }
break; break;
case INPUT_EVENT_KIND_BTN: case INPUT_EVENT_KIND_BTN:
if (evt->btn->down) { if (evt->u.btn->down) {
s->mouse_buttons |= bmap[evt->btn->button]; s->mouse_buttons |= bmap[evt->u.btn->button];
if (evt->btn->button == INPUT_BUTTON_WHEEL_UP) { if (evt->u.btn->button == INPUT_BUTTON_WHEEL_UP) {
s->mouse_dz--; s->mouse_dz--;
} else if (evt->btn->button == INPUT_BUTTON_WHEEL_DOWN) { } else if (evt->u.btn->button == INPUT_BUTTON_WHEEL_DOWN) {
s->mouse_dz++; s->mouse_dz++;
} }
} else { } else {
s->mouse_buttons &= ~bmap[evt->btn->button]; s->mouse_buttons &= ~bmap[evt->u.btn->button];
} }
break; break;

27
hw/input/virtio-input-hid.c
View File

@ -191,44 +191,45 @@ static void virtio_input_handle_event(DeviceState *dev, QemuConsole *src,
virtio_input_event event; virtio_input_event event;
int qcode; int qcode;
switch (evt->kind) { switch (evt->type) {
case INPUT_EVENT_KIND_KEY: case INPUT_EVENT_KIND_KEY:
qcode = qemu_input_key_value_to_qcode(evt->key->key); qcode = qemu_input_key_value_to_qcode(evt->u.key->key);
if (qcode && keymap_qcode[qcode]) { if (qcode && keymap_qcode[qcode]) {
event.type = cpu_to_le16(EV_KEY); event.type = cpu_to_le16(EV_KEY);
event.code = cpu_to_le16(keymap_qcode[qcode]); event.code = cpu_to_le16(keymap_qcode[qcode]);
event.value = cpu_to_le32(evt->key->down ? 1 : 0); event.value = cpu_to_le32(evt->u.key->down ? 1 : 0);
virtio_input_send(vinput, &event); virtio_input_send(vinput, &event);
} else { } else {
if (evt->key->down) { if (evt->u.key->down) {
fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__, fprintf(stderr, "%s: unmapped key: %d [%s]\n", __func__,
qcode, QKeyCode_lookup[qcode]); qcode, QKeyCode_lookup[qcode]);
} }
} }
break; break;
case INPUT_EVENT_KIND_BTN: case INPUT_EVENT_KIND_BTN:
if (keymap_button[evt->btn->button]) { if (keymap_button[evt->u.btn->button]) {
event.type = cpu_to_le16(EV_KEY); event.type = cpu_to_le16(EV_KEY);
event.code = cpu_to_le16(keymap_button[evt->btn->button]); event.code = cpu_to_le16(keymap_button[evt->u.btn->button]);
event.value = cpu_to_le32(evt->btn->down ? 1 : 0); event.value = cpu_to_le32(evt->u.btn->down ? 1 : 0);
virtio_input_send(vinput, &event); virtio_input_send(vinput, &event);
} else { } else {
if (evt->btn->down) { if (evt->u.btn->down) {
fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__, fprintf(stderr, "%s: unmapped button: %d [%s]\n", __func__,
evt->btn->button, InputButton_lookup[evt->btn->button]); evt->u.btn->button,
InputButton_lookup[evt->u.btn->button]);
} }
} }
break; break;
case INPUT_EVENT_KIND_REL: case INPUT_EVENT_KIND_REL:
event.type = cpu_to_le16(EV_REL); event.type = cpu_to_le16(EV_REL);
event.code = cpu_to_le16(axismap_rel[evt->rel->axis]); event.code = cpu_to_le16(axismap_rel[evt->u.rel->axis]);
event.value = cpu_to_le32(evt->rel->value); event.value = cpu_to_le32(evt->u.rel->value);
virtio_input_send(vinput, &event); virtio_input_send(vinput, &event);
break; break;
case INPUT_EVENT_KIND_ABS: case INPUT_EVENT_KIND_ABS:
event.type = cpu_to_le16(EV_ABS); event.type = cpu_to_le16(EV_ABS);
event.code = cpu_to_le16(axismap_abs[evt->abs->axis]); event.code = cpu_to_le16(axismap_abs[evt->u.abs->axis]);
event.value = cpu_to_le32(evt->abs->value); event.value = cpu_to_le32(evt->u.abs->value);
virtio_input_send(vinput, &event); virtio_input_send(vinput, &event);
break; break;
default: default:

20
ui/console.c
View File

@ -2016,7 +2016,7 @@ static VcHandler *vc_handler = text_console_init;
static CharDriverState *vc_init(const char *id, ChardevBackend *backend, static CharDriverState *vc_init(const char *id, ChardevBackend *backend,
ChardevReturn *ret, Error **errp) ChardevReturn *ret, Error **errp)
{ {
return vc_handler(backend->vc, errp); return vc_handler(backend->u.vc, errp);
} }
void register_vc_handler(VcHandler *handler) void register_vc_handler(VcHandler *handler)
@ -2057,30 +2057,30 @@ static void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend,
{ {
int val; int val;
backend->vc = g_new0(ChardevVC, 1); backend->u.vc = g_new0(ChardevVC, 1);
val = qemu_opt_get_number(opts, "width", 0); val = qemu_opt_get_number(opts, "width", 0);
if (val != 0) { if (val != 0) {
backend->vc->has_width = true; backend->u.vc->has_width = true;
backend->vc->width = val; backend->u.vc->width = val;
} }
val = qemu_opt_get_number(opts, "height", 0); val = qemu_opt_get_number(opts, "height", 0);
if (val != 0) { if (val != 0) {
backend->vc->has_height = true; backend->u.vc->has_height = true;
backend->vc->height = val; backend->u.vc->height = val;
} }
val = qemu_opt_get_number(opts, "cols", 0); val = qemu_opt_get_number(opts, "cols", 0);
if (val != 0) { if (val != 0) {
backend->vc->has_cols = true; backend->u.vc->has_cols = true;
backend->vc->cols = val; backend->u.vc->cols = val;
} }
val = qemu_opt_get_number(opts, "rows", 0); val = qemu_opt_get_number(opts, "rows", 0);
if (val != 0) { if (val != 0) {
backend->vc->has_rows = true; backend->u.vc->has_rows = true;
backend->vc->rows = val; backend->u.vc->rows = val;
} }
} }

20
ui/input-keymap.c
View File

@ -139,11 +139,11 @@ static int number_to_qcode[0x100];
int qemu_input_key_value_to_number(const KeyValue *value) int qemu_input_key_value_to_number(const KeyValue *value)
{ {
if (value->kind == KEY_VALUE_KIND_QCODE) { if (value->type == KEY_VALUE_KIND_QCODE) {
return qcode_to_number[value->qcode]; return qcode_to_number[value->u.qcode];
} else { } else {
assert(value->kind == KEY_VALUE_KIND_NUMBER); assert(value->type == KEY_VALUE_KIND_NUMBER);
return value->number; return value->u.number;
} }
} }
@ -166,11 +166,11 @@ int qemu_input_key_number_to_qcode(uint8_t nr)
int qemu_input_key_value_to_qcode(const KeyValue *value) int qemu_input_key_value_to_qcode(const KeyValue *value)
{ {
if (value->kind == KEY_VALUE_KIND_QCODE) { if (value->type == KEY_VALUE_KIND_QCODE) {
return value->qcode; return value->u.qcode;
} else { } else {
assert(value->kind == KEY_VALUE_KIND_NUMBER); assert(value->type == KEY_VALUE_KIND_NUMBER);
return qemu_input_key_number_to_qcode(value->number); return qemu_input_key_number_to_qcode(value->u.number);
} }
} }
@ -180,8 +180,8 @@ int qemu_input_key_value_to_scancode(const KeyValue *value, bool down,
int keycode = qemu_input_key_value_to_number(value); int keycode = qemu_input_key_value_to_number(value);
int count = 0; int count = 0;
if (value->kind == KEY_VALUE_KIND_QCODE && if (value->type == KEY_VALUE_KIND_QCODE &&
value->qcode == Q_KEY_CODE_PAUSE) { value->u.qcode == Q_KEY_CODE_PAUSE) {
/* specific case */ /* specific case */
int v = down ? 0 : 0x80; int v = down ? 0 : 0x80;
codes[count++] = 0xe1; codes[count++] = 0xe1;

21
ui/input-legacy.c
View File

@ -113,8 +113,8 @@ static void legacy_kbd_event(DeviceState *dev, QemuConsole *src,
if (!entry || !entry->put_kbd) { if (!entry || !entry->put_kbd) {
return; return;
} }
count = qemu_input_key_value_to_scancode(evt->key->key, count = qemu_input_key_value_to_scancode(evt->u.key->key,
evt->key->down, evt->u.key->down,
scancodes); scancodes);
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
entry->put_kbd(entry->opaque, scancodes[i]); entry->put_kbd(entry->opaque, scancodes[i]);
@ -150,21 +150,22 @@ static void legacy_mouse_event(DeviceState *dev, QemuConsole *src,
}; };
QEMUPutMouseEntry *s = (QEMUPutMouseEntry *)dev; QEMUPutMouseEntry *s = (QEMUPutMouseEntry *)dev;
switch (evt->kind) { switch (evt->type) {
case INPUT_EVENT_KIND_BTN: case INPUT_EVENT_KIND_BTN:
if (evt->btn->down) { if (evt->u.btn->down) {
s->buttons |= bmap[evt->btn->button]; s->buttons |= bmap[evt->u.btn->button];
} else { } else {
s->buttons &= ~bmap[evt->btn->button]; s->buttons &= ~bmap[evt->u.btn->button];
} }
if (evt->btn->down && evt->btn->button == INPUT_BUTTON_WHEEL_UP) { if (evt->u.btn->down && evt->u.btn->button == INPUT_BUTTON_WHEEL_UP) {
s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque, s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque,
s->axis[INPUT_AXIS_X], s->axis[INPUT_AXIS_X],
s->axis[INPUT_AXIS_Y], s->axis[INPUT_AXIS_Y],
-1, -1,
s->buttons); s->buttons);
} }
if (evt->btn->down && evt->btn->button == INPUT_BUTTON_WHEEL_DOWN) { if (evt->u.btn->down &&
evt->u.btn->button == INPUT_BUTTON_WHEEL_DOWN) {
s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque, s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque,
s->axis[INPUT_AXIS_X], s->axis[INPUT_AXIS_X],
s->axis[INPUT_AXIS_Y], s->axis[INPUT_AXIS_Y],
@ -173,10 +174,10 @@ static void legacy_mouse_event(DeviceState *dev, QemuConsole *src,
} }
break; break;
case INPUT_EVENT_KIND_ABS: case INPUT_EVENT_KIND_ABS:
s->axis[evt->abs->axis] = evt->abs->value; s->axis[evt->u.abs->axis] = evt->u.abs->value;
break; break;
case INPUT_EVENT_KIND_REL: case INPUT_EVENT_KIND_REL:
s->axis[evt->rel->axis] += evt->rel->value; s->axis[evt->u.rel->axis] += evt->u.rel->value;
break; break;
default: default:
break; break;

84
ui/input.c
View File

@ -147,10 +147,10 @@ void qmp_x_input_send_event(bool has_console, int64_t console,
for (e = events; e != NULL; e = e->next) { for (e = events; e != NULL; e = e->next) {
InputEvent *event = e->value; InputEvent *event = e->value;
if (!qemu_input_find_handler(1 << event->kind, con)) { if (!qemu_input_find_handler(1 << event->type, con)) {
error_setg(errp, "Input handler not found for " error_setg(errp, "Input handler not found for "
"event type %s", "event type %s",
InputEventKind_lookup[event->kind]); InputEventKind_lookup[event->type]);
return; return;
} }
} }
@ -168,22 +168,22 @@ static void qemu_input_transform_abs_rotate(InputEvent *evt)
{ {
switch (graphic_rotate) { switch (graphic_rotate) {
case 90: case 90:
if (evt->abs->axis == INPUT_AXIS_X) { if (evt->u.abs->axis == INPUT_AXIS_X) {
evt->abs->axis = INPUT_AXIS_Y; evt->u.abs->axis = INPUT_AXIS_Y;
} else if (evt->abs->axis == INPUT_AXIS_Y) { } else if (evt->u.abs->axis == INPUT_AXIS_Y) {
evt->abs->axis = INPUT_AXIS_X; evt->u.abs->axis = INPUT_AXIS_X;
evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value; evt->u.abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->u.abs->value;
} }
break; break;
case 180: case 180:
evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value; evt->u.abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->u.abs->value;
break; break;
case 270: case 270:
if (evt->abs->axis == INPUT_AXIS_X) { if (evt->u.abs->axis == INPUT_AXIS_X) {
evt->abs->axis = INPUT_AXIS_Y; evt->u.abs->axis = INPUT_AXIS_Y;
evt->abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->abs->value; evt->u.abs->value = INPUT_EVENT_ABS_SIZE - 1 - evt->u.abs->value;
} else if (evt->abs->axis == INPUT_AXIS_Y) { } else if (evt->u.abs->axis == INPUT_AXIS_Y) {
evt->abs->axis = INPUT_AXIS_X; evt->u.abs->axis = INPUT_AXIS_X;
} }
break; break;
} }
@ -197,18 +197,18 @@ static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
if (src) { if (src) {
idx = qemu_console_get_index(src); idx = qemu_console_get_index(src);
} }
switch (evt->kind) { switch (evt->type) {
case INPUT_EVENT_KIND_KEY: case INPUT_EVENT_KIND_KEY:
switch (evt->key->key->kind) { switch (evt->u.key->key->type) {
case KEY_VALUE_KIND_NUMBER: case KEY_VALUE_KIND_NUMBER:
qcode = qemu_input_key_number_to_qcode(evt->key->key->number); qcode = qemu_input_key_number_to_qcode(evt->u.key->key->u.number);
name = QKeyCode_lookup[qcode]; name = QKeyCode_lookup[qcode];
trace_input_event_key_number(idx, evt->key->key->number, trace_input_event_key_number(idx, evt->u.key->key->u.number,
name, evt->key->down); name, evt->u.key->down);
break; break;
case KEY_VALUE_KIND_QCODE: case KEY_VALUE_KIND_QCODE:
name = QKeyCode_lookup[evt->key->key->qcode]; name = QKeyCode_lookup[evt->u.key->key->u.qcode];
trace_input_event_key_qcode(idx, name, evt->key->down); trace_input_event_key_qcode(idx, name, evt->u.key->down);
break; break;
case KEY_VALUE_KIND_MAX: case KEY_VALUE_KIND_MAX:
/* keep gcc happy */ /* keep gcc happy */
@ -216,16 +216,16 @@ static void qemu_input_event_trace(QemuConsole *src, InputEvent *evt)
} }
break; break;
case INPUT_EVENT_KIND_BTN: case INPUT_EVENT_KIND_BTN:
name = InputButton_lookup[evt->btn->button]; name = InputButton_lookup[evt->u.btn->button];
trace_input_event_btn(idx, name, evt->btn->down); trace_input_event_btn(idx, name, evt->u.btn->down);
break; break;
case INPUT_EVENT_KIND_REL: case INPUT_EVENT_KIND_REL:
name = InputAxis_lookup[evt->rel->axis]; name = InputAxis_lookup[evt->u.rel->axis];
trace_input_event_rel(idx, name, evt->rel->value); trace_input_event_rel(idx, name, evt->u.rel->value);
break; break;
case INPUT_EVENT_KIND_ABS: case INPUT_EVENT_KIND_ABS:
name = InputAxis_lookup[evt->abs->axis]; name = InputAxis_lookup[evt->u.abs->axis];
trace_input_event_abs(idx, name, evt->abs->value); trace_input_event_abs(idx, name, evt->u.abs->value);
break; break;
case INPUT_EVENT_KIND_MAX: case INPUT_EVENT_KIND_MAX:
/* keep gcc happy */ /* keep gcc happy */
@ -311,12 +311,12 @@ void qemu_input_event_send(QemuConsole *src, InputEvent *evt)
qemu_input_event_trace(src, evt); qemu_input_event_trace(src, evt);
/* pre processing */ /* pre processing */
if (graphic_rotate && (evt->kind == INPUT_EVENT_KIND_ABS)) { if (graphic_rotate && (evt->type == INPUT_EVENT_KIND_ABS)) {
qemu_input_transform_abs_rotate(evt); qemu_input_transform_abs_rotate(evt);
} }
/* send event */ /* send event */
s = qemu_input_find_handler(1 << evt->kind, src); s = qemu_input_find_handler(1 << evt->type, src);
if (!s) { if (!s) {
return; return;
} }
@ -348,10 +348,10 @@ void qemu_input_event_sync(void)
InputEvent *qemu_input_event_new_key(KeyValue *key, bool down) InputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
{ {
InputEvent *evt = g_new0(InputEvent, 1); InputEvent *evt = g_new0(InputEvent, 1);
evt->key = g_new0(InputKeyEvent, 1); evt->u.key = g_new0(InputKeyEvent, 1);
evt->kind = INPUT_EVENT_KIND_KEY; evt->type = INPUT_EVENT_KIND_KEY;
evt->key->key = key; evt->u.key->key = key;
evt->key->down = down; evt->u.key->down = down;
return evt; return evt;
} }
@ -372,16 +372,16 @@ void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down) void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
{ {
KeyValue *key = g_new0(KeyValue, 1); KeyValue *key = g_new0(KeyValue, 1);
key->kind = KEY_VALUE_KIND_NUMBER; key->type = KEY_VALUE_KIND_NUMBER;
key->number = num; key->u.number = num;
qemu_input_event_send_key(src, key, down); qemu_input_event_send_key(src, key, down);
} }
void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down) void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
{ {
KeyValue *key = g_new0(KeyValue, 1); KeyValue *key = g_new0(KeyValue, 1);
key->kind = KEY_VALUE_KIND_QCODE; key->type = KEY_VALUE_KIND_QCODE;
key->qcode = q; key->u.qcode = q;
qemu_input_event_send_key(src, key, down); qemu_input_event_send_key(src, key, down);
} }
@ -398,10 +398,10 @@ void qemu_input_event_send_key_delay(uint32_t delay_ms)
InputEvent *qemu_input_event_new_btn(InputButton btn, bool down) InputEvent *qemu_input_event_new_btn(InputButton btn, bool down)
{ {
InputEvent *evt = g_new0(InputEvent, 1); InputEvent *evt = g_new0(InputEvent, 1);
evt->btn = g_new0(InputBtnEvent, 1); evt->u.btn = g_new0(InputBtnEvent, 1);
evt->kind = INPUT_EVENT_KIND_BTN; evt->type = INPUT_EVENT_KIND_BTN;
evt->btn->button = btn; evt->u.btn->button = btn;
evt->btn->down = down; evt->u.btn->down = down;
return evt; return evt;
} }
@ -451,8 +451,8 @@ InputEvent *qemu_input_event_new_move(InputEventKind kind,
InputEvent *evt = g_new0(InputEvent, 1); InputEvent *evt = g_new0(InputEvent, 1);
InputMoveEvent *move = g_new0(InputMoveEvent, 1); InputMoveEvent *move = g_new0(InputMoveEvent, 1);
evt->kind = kind; evt->type = kind;
evt->data = move; evt->u.data = move;
move->axis = axis; move->axis = axis;
move->value = value; move->value = value;
return evt; return evt;