Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging
[qemu.git] / ui / input.c
1 #include "sysemu/sysemu.h"
2 #include "qapi-types.h"
3 #include "qmp-commands.h"
4 #include "trace.h"
5 #include "ui/input.h"
6 #include "ui/console.h"
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);
17 static NotifierList mouse_mode_notifiers =
18 NOTIFIER_LIST_INITIALIZER(mouse_mode_notifiers);
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);
30
31 qemu_input_check_mode_change();
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);
39 qemu_input_check_mode_change();
40 }
41
42 void qemu_input_handler_unregister(QemuInputHandlerState *s)
43 {
44 QTAILQ_REMOVE(&handlers, s, node);
45 g_free(s);
46 qemu_input_check_mode_change();
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
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
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
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
137 qemu_input_event_trace(src, evt);
138
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 */
145 s = qemu_input_find_handler(1 << evt->kind);
146 s->handler->event(s->dev, src, evt);
147 s->events++;
148 }
149
150 void qemu_input_event_sync(void)
151 {
152 QemuInputHandlerState *s;
153
154 if (!runstate_is_running() && !runstate_check(RUN_STATE_SUSPENDED)) {
155 return;
156 }
157
158 trace_input_event_sync();
159
160 QTAILQ_FOREACH(s, &handlers, node) {
161 if (!s->events) {
162 continue;
163 }
164 if (s->handler->sync) {
165 s->handler->sync(s->dev);
166 }
167 s->events = 0;
168 }
169 }
170
171 InputEvent *qemu_input_event_new_key(KeyValue *key, bool down)
172 {
173 InputEvent *evt = g_new0(InputEvent, 1);
174 evt->key = g_new0(InputKeyEvent, 1);
175 evt->kind = INPUT_EVENT_KIND_KEY;
176 evt->key->key = key;
177 evt->key->down = down;
178 return evt;
179 }
180
181 void qemu_input_event_send_key(QemuConsole *src, KeyValue *key, bool down)
182 {
183 InputEvent *evt;
184 evt = qemu_input_event_new_key(key, down);
185 qemu_input_event_send(src, evt);
186 qemu_input_event_sync();
187 qapi_free_InputEvent(evt);
188 }
189
190 void qemu_input_event_send_key_number(QemuConsole *src, int num, bool down)
191 {
192 KeyValue *key = g_new0(KeyValue, 1);
193 key->kind = KEY_VALUE_KIND_NUMBER;
194 key->number = num;
195 qemu_input_event_send_key(src, key, down);
196 }
197
198 void qemu_input_event_send_key_qcode(QemuConsole *src, QKeyCode q, bool down)
199 {
200 KeyValue *key = g_new0(KeyValue, 1);
201 key->kind = KEY_VALUE_KIND_QCODE;
202 key->qcode = q;
203 qemu_input_event_send_key(src, key, down);
204 }
205
206 InputEvent *qemu_input_event_new_btn(InputButton btn, bool down)
207 {
208 InputEvent *evt = g_new0(InputEvent, 1);
209 evt->btn = g_new0(InputBtnEvent, 1);
210 evt->kind = INPUT_EVENT_KIND_BTN;
211 evt->btn->button = btn;
212 evt->btn->down = down;
213 return evt;
214 }
215
216 void qemu_input_queue_btn(QemuConsole *src, InputButton btn, bool down)
217 {
218 InputEvent *evt;
219 evt = qemu_input_event_new_btn(btn, down);
220 qemu_input_event_send(src, evt);
221 qapi_free_InputEvent(evt);
222 }
223
224 void qemu_input_update_buttons(QemuConsole *src, uint32_t *button_map,
225 uint32_t button_old, uint32_t button_new)
226 {
227 InputButton btn;
228 uint32_t mask;
229
230 for (btn = 0; btn < INPUT_BUTTON_MAX; btn++) {
231 mask = button_map[btn];
232 if ((button_old & mask) == (button_new & mask)) {
233 continue;
234 }
235 qemu_input_queue_btn(src, btn, button_new & mask);
236 }
237 }
238
239 bool qemu_input_is_absolute(void)
240 {
241 QemuInputHandlerState *s;
242
243 s = qemu_input_find_handler(INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS);
244 return (s != NULL) && (s->handler->mask & INPUT_EVENT_MASK_ABS);
245 }
246
247 int qemu_input_scale_axis(int value, int size_in, int size_out)
248 {
249 if (size_in < 2) {
250 return size_out / 2;
251 }
252 return (int64_t)value * (size_out - 1) / (size_in - 1);
253 }
254
255 InputEvent *qemu_input_event_new_move(InputEventKind kind,
256 InputAxis axis, int value)
257 {
258 InputEvent *evt = g_new0(InputEvent, 1);
259 InputMoveEvent *move = g_new0(InputMoveEvent, 1);
260
261 evt->kind = kind;
262 evt->data = move;
263 move->axis = axis;
264 move->value = value;
265 return evt;
266 }
267
268 void qemu_input_queue_rel(QemuConsole *src, InputAxis axis, int value)
269 {
270 InputEvent *evt;
271 evt = qemu_input_event_new_move(INPUT_EVENT_KIND_REL, axis, value);
272 qemu_input_event_send(src, evt);
273 qapi_free_InputEvent(evt);
274 }
275
276 void qemu_input_queue_abs(QemuConsole *src, InputAxis axis, int value, int size)
277 {
278 InputEvent *evt;
279 int scaled = qemu_input_scale_axis(value, size, INPUT_EVENT_ABS_SIZE);
280 evt = qemu_input_event_new_move(INPUT_EVENT_KIND_ABS, axis, scaled);
281 qemu_input_event_send(src, evt);
282 qapi_free_InputEvent(evt);
283 }
284
285 void qemu_input_check_mode_change(void)
286 {
287 static int current_is_absolute;
288 int is_absolute;
289
290 is_absolute = qemu_input_is_absolute();
291
292 if (is_absolute != current_is_absolute) {
293 trace_input_mouse_mode(is_absolute);
294 notifier_list_notify(&mouse_mode_notifiers, NULL);
295 }
296
297 current_is_absolute = is_absolute;
298 }
299
300 void qemu_add_mouse_mode_change_notifier(Notifier *notify)
301 {
302 notifier_list_add(&mouse_mode_notifiers, notify);
303 }
304
305 void qemu_remove_mouse_mode_change_notifier(Notifier *notify)
306 {
307 notifier_remove(notify);
308 }
309
310 MouseInfoList *qmp_query_mice(Error **errp)
311 {
312 MouseInfoList *mice_list = NULL;
313 MouseInfoList *info;
314 QemuInputHandlerState *s;
315 bool current = true;
316
317 QTAILQ_FOREACH(s, &handlers, node) {
318 if (!(s->handler->mask &
319 (INPUT_EVENT_MASK_REL | INPUT_EVENT_MASK_ABS))) {
320 continue;
321 }
322
323 info = g_new0(MouseInfoList, 1);
324 info->value = g_new0(MouseInfo, 1);
325 info->value->index = s->id;
326 info->value->name = g_strdup(s->handler->name);
327 info->value->absolute = s->handler->mask & INPUT_EVENT_MASK_ABS;
328 info->value->current = current;
329
330 current = false;
331 info->next = mice_list;
332 mice_list = info;
333 }
334
335 return mice_list;
336 }
337
338 void do_mouse_set(Monitor *mon, const QDict *qdict)
339 {
340 QemuInputHandlerState *s;
341 int index = qdict_get_int(qdict, "index");
342 int found = 0;
343
344 QTAILQ_FOREACH(s, &handlers, node) {
345 if (s->id == index) {
346 found = 1;
347 qemu_input_handler_activate(s);
348 break;
349 }
350 }
351
352 if (!found) {
353 monitor_printf(mon, "Mouse at given index not found\n");
354 }
355
356 qemu_input_check_mode_change();
357 }