]>
Commit | Line | Data |
---|---|---|
e0d2bd51 GH |
1 | /* |
2 | * This work is licensed under the terms of the GNU GPL, version 2 or | |
3 | * (at your option) any later version. See the COPYING file in the | |
4 | * top-level directory. | |
5 | */ | |
6 | ||
7 | #include "qemu/osdep.h" | |
da34e65c | 8 | #include "qapi/error.h" |
e0d2bd51 GH |
9 | #include "qemu-common.h" |
10 | #include "qemu/config-file.h" | |
11 | #include "qemu/sockets.h" | |
12 | #include "sysemu/sysemu.h" | |
13 | #include "ui/input.h" | |
0e066b2c | 14 | #include "qom/object_interfaces.h" |
e0d2bd51 GH |
15 | |
16 | #include <sys/ioctl.h> | |
17 | #include "standard-headers/linux/input.h" | |
18 | ||
19 | static int linux_to_qcode[KEY_CNT] = { | |
20 | [KEY_ESC] = Q_KEY_CODE_ESC, | |
21 | [KEY_1] = Q_KEY_CODE_1, | |
22 | [KEY_2] = Q_KEY_CODE_2, | |
23 | [KEY_3] = Q_KEY_CODE_3, | |
24 | [KEY_4] = Q_KEY_CODE_4, | |
25 | [KEY_5] = Q_KEY_CODE_5, | |
26 | [KEY_6] = Q_KEY_CODE_6, | |
27 | [KEY_7] = Q_KEY_CODE_7, | |
28 | [KEY_8] = Q_KEY_CODE_8, | |
29 | [KEY_9] = Q_KEY_CODE_9, | |
30 | [KEY_0] = Q_KEY_CODE_0, | |
31 | [KEY_MINUS] = Q_KEY_CODE_MINUS, | |
32 | [KEY_EQUAL] = Q_KEY_CODE_EQUAL, | |
33 | [KEY_BACKSPACE] = Q_KEY_CODE_BACKSPACE, | |
34 | [KEY_TAB] = Q_KEY_CODE_TAB, | |
35 | [KEY_Q] = Q_KEY_CODE_Q, | |
36 | [KEY_W] = Q_KEY_CODE_W, | |
37 | [KEY_E] = Q_KEY_CODE_E, | |
38 | [KEY_R] = Q_KEY_CODE_R, | |
39 | [KEY_T] = Q_KEY_CODE_T, | |
40 | [KEY_Y] = Q_KEY_CODE_Y, | |
41 | [KEY_U] = Q_KEY_CODE_U, | |
42 | [KEY_I] = Q_KEY_CODE_I, | |
43 | [KEY_O] = Q_KEY_CODE_O, | |
44 | [KEY_P] = Q_KEY_CODE_P, | |
45 | [KEY_LEFTBRACE] = Q_KEY_CODE_BRACKET_LEFT, | |
46 | [KEY_RIGHTBRACE] = Q_KEY_CODE_BRACKET_RIGHT, | |
47 | [KEY_ENTER] = Q_KEY_CODE_RET, | |
48 | [KEY_LEFTCTRL] = Q_KEY_CODE_CTRL, | |
49 | [KEY_A] = Q_KEY_CODE_A, | |
50 | [KEY_S] = Q_KEY_CODE_S, | |
51 | [KEY_D] = Q_KEY_CODE_D, | |
52 | [KEY_F] = Q_KEY_CODE_F, | |
53 | [KEY_G] = Q_KEY_CODE_G, | |
54 | [KEY_H] = Q_KEY_CODE_H, | |
55 | [KEY_J] = Q_KEY_CODE_J, | |
56 | [KEY_K] = Q_KEY_CODE_K, | |
57 | [KEY_L] = Q_KEY_CODE_L, | |
58 | [KEY_SEMICOLON] = Q_KEY_CODE_SEMICOLON, | |
59 | [KEY_APOSTROPHE] = Q_KEY_CODE_APOSTROPHE, | |
60 | [KEY_GRAVE] = Q_KEY_CODE_GRAVE_ACCENT, | |
61 | [KEY_LEFTSHIFT] = Q_KEY_CODE_SHIFT, | |
62 | [KEY_BACKSLASH] = Q_KEY_CODE_BACKSLASH, | |
63 | [KEY_102ND] = Q_KEY_CODE_LESS, | |
64 | [KEY_Z] = Q_KEY_CODE_Z, | |
65 | [KEY_X] = Q_KEY_CODE_X, | |
66 | [KEY_C] = Q_KEY_CODE_C, | |
67 | [KEY_V] = Q_KEY_CODE_V, | |
68 | [KEY_B] = Q_KEY_CODE_B, | |
69 | [KEY_N] = Q_KEY_CODE_N, | |
70 | [KEY_M] = Q_KEY_CODE_M, | |
71 | [KEY_COMMA] = Q_KEY_CODE_COMMA, | |
72 | [KEY_DOT] = Q_KEY_CODE_DOT, | |
73 | [KEY_SLASH] = Q_KEY_CODE_SLASH, | |
74 | [KEY_RIGHTSHIFT] = Q_KEY_CODE_SHIFT_R, | |
75 | [KEY_LEFTALT] = Q_KEY_CODE_ALT, | |
76 | [KEY_SPACE] = Q_KEY_CODE_SPC, | |
77 | [KEY_CAPSLOCK] = Q_KEY_CODE_CAPS_LOCK, | |
78 | [KEY_F1] = Q_KEY_CODE_F1, | |
79 | [KEY_F2] = Q_KEY_CODE_F2, | |
80 | [KEY_F3] = Q_KEY_CODE_F3, | |
81 | [KEY_F4] = Q_KEY_CODE_F4, | |
82 | [KEY_F5] = Q_KEY_CODE_F5, | |
83 | [KEY_F6] = Q_KEY_CODE_F6, | |
84 | [KEY_F7] = Q_KEY_CODE_F7, | |
85 | [KEY_F8] = Q_KEY_CODE_F8, | |
86 | [KEY_F9] = Q_KEY_CODE_F9, | |
87 | [KEY_F10] = Q_KEY_CODE_F10, | |
88 | [KEY_NUMLOCK] = Q_KEY_CODE_NUM_LOCK, | |
89 | [KEY_SCROLLLOCK] = Q_KEY_CODE_SCROLL_LOCK, | |
90 | [KEY_KP0] = Q_KEY_CODE_KP_0, | |
91 | [KEY_KP1] = Q_KEY_CODE_KP_1, | |
92 | [KEY_KP2] = Q_KEY_CODE_KP_2, | |
93 | [KEY_KP3] = Q_KEY_CODE_KP_3, | |
94 | [KEY_KP4] = Q_KEY_CODE_KP_4, | |
95 | [KEY_KP5] = Q_KEY_CODE_KP_5, | |
96 | [KEY_KP6] = Q_KEY_CODE_KP_6, | |
97 | [KEY_KP7] = Q_KEY_CODE_KP_7, | |
98 | [KEY_KP8] = Q_KEY_CODE_KP_8, | |
99 | [KEY_KP9] = Q_KEY_CODE_KP_9, | |
100 | [KEY_KPMINUS] = Q_KEY_CODE_KP_SUBTRACT, | |
101 | [KEY_KPPLUS] = Q_KEY_CODE_KP_ADD, | |
102 | [KEY_KPDOT] = Q_KEY_CODE_KP_DECIMAL, | |
103 | [KEY_KPENTER] = Q_KEY_CODE_KP_ENTER, | |
104 | [KEY_KPSLASH] = Q_KEY_CODE_KP_DIVIDE, | |
105 | [KEY_KPASTERISK] = Q_KEY_CODE_KP_MULTIPLY, | |
106 | [KEY_F11] = Q_KEY_CODE_F11, | |
107 | [KEY_F12] = Q_KEY_CODE_F12, | |
108 | [KEY_RIGHTCTRL] = Q_KEY_CODE_CTRL_R, | |
109 | [KEY_SYSRQ] = Q_KEY_CODE_SYSRQ, | |
110 | [KEY_RIGHTALT] = Q_KEY_CODE_ALT_R, | |
111 | [KEY_HOME] = Q_KEY_CODE_HOME, | |
112 | [KEY_UP] = Q_KEY_CODE_UP, | |
113 | [KEY_PAGEUP] = Q_KEY_CODE_PGUP, | |
114 | [KEY_LEFT] = Q_KEY_CODE_LEFT, | |
115 | [KEY_RIGHT] = Q_KEY_CODE_RIGHT, | |
116 | [KEY_END] = Q_KEY_CODE_END, | |
117 | [KEY_DOWN] = Q_KEY_CODE_DOWN, | |
118 | [KEY_PAGEDOWN] = Q_KEY_CODE_PGDN, | |
119 | [KEY_INSERT] = Q_KEY_CODE_INSERT, | |
120 | [KEY_DELETE] = Q_KEY_CODE_DELETE, | |
121 | [KEY_LEFTMETA] = Q_KEY_CODE_META_L, | |
122 | [KEY_RIGHTMETA] = Q_KEY_CODE_META_R, | |
123 | [KEY_MENU] = Q_KEY_CODE_MENU, | |
124 | }; | |
125 | ||
126 | static int qemu_input_linux_to_qcode(unsigned int lnx) | |
127 | { | |
128 | assert(lnx < KEY_CNT); | |
129 | return linux_to_qcode[lnx]; | |
130 | } | |
131 | ||
2e6a64cb GH |
132 | static bool linux_is_button(unsigned int lnx) |
133 | { | |
134 | if (lnx < 0x100) { | |
135 | return false; | |
136 | } | |
137 | if (lnx >= 0x160 && lnx < 0x2c0) { | |
138 | return false; | |
139 | } | |
140 | return true; | |
141 | } | |
142 | ||
0e066b2c GH |
143 | #define TYPE_INPUT_LINUX "input-linux" |
144 | #define INPUT_LINUX(obj) \ | |
145 | OBJECT_CHECK(InputLinux, (obj), TYPE_INPUT_LINUX) | |
146 | #define INPUT_LINUX_GET_CLASS(obj) \ | |
147 | OBJECT_GET_CLASS(InputLinuxClass, (obj), TYPE_INPUT_LINUX) | |
148 | #define INPUT_LINUX_CLASS(klass) \ | |
149 | OBJECT_CLASS_CHECK(InputLinuxClass, (klass), TYPE_INPUT_LINUX) | |
150 | ||
e0d2bd51 | 151 | typedef struct InputLinux InputLinux; |
0e066b2c | 152 | typedef struct InputLinuxClass InputLinuxClass; |
e0d2bd51 GH |
153 | |
154 | struct InputLinux { | |
0e066b2c GH |
155 | Object parent; |
156 | ||
157 | char *evdev; | |
e0d2bd51 | 158 | int fd; |
a6ccabd6 | 159 | bool repeat; |
e0d2bd51 GH |
160 | bool grab_request; |
161 | bool grab_active; | |
46d921be | 162 | bool grab_all; |
e0d2bd51 GH |
163 | bool keydown[KEY_CNT]; |
164 | int keycount; | |
165 | int wheel; | |
0e066b2c | 166 | bool initialized; |
2e6a64cb GH |
167 | |
168 | bool has_rel_x; | |
169 | bool has_abs_x; | |
170 | int num_keys; | |
171 | int num_btns; | |
1684907c JC |
172 | struct input_event event; |
173 | int read_offset; | |
2e6a64cb | 174 | |
46d921be | 175 | QTAILQ_ENTRY(InputLinux) next; |
e0d2bd51 GH |
176 | }; |
177 | ||
0e066b2c GH |
178 | struct InputLinuxClass { |
179 | ObjectClass parent_class; | |
180 | }; | |
181 | ||
46d921be GH |
182 | static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs); |
183 | ||
e0d2bd51 GH |
184 | static void input_linux_toggle_grab(InputLinux *il) |
185 | { | |
186 | intptr_t request = !il->grab_active; | |
46d921be | 187 | InputLinux *item; |
e0d2bd51 GH |
188 | int rc; |
189 | ||
190 | rc = ioctl(il->fd, EVIOCGRAB, request); | |
191 | if (rc < 0) { | |
192 | return; | |
193 | } | |
194 | il->grab_active = !il->grab_active; | |
46d921be GH |
195 | |
196 | if (!il->grab_all) { | |
197 | return; | |
198 | } | |
199 | QTAILQ_FOREACH(item, &inputs, next) { | |
200 | if (item == il || item->grab_all) { | |
201 | /* avoid endless loops */ | |
202 | continue; | |
203 | } | |
204 | if (item->grab_active != il->grab_active) { | |
205 | input_linux_toggle_grab(item); | |
206 | } | |
207 | } | |
e0d2bd51 GH |
208 | } |
209 | ||
2330e9e7 GH |
210 | static void input_linux_handle_keyboard(InputLinux *il, |
211 | struct input_event *event) | |
212 | { | |
213 | if (event->type == EV_KEY) { | |
214 | if (event->value > 2 || (event->value > 1 && !il->repeat)) { | |
215 | /* | |
216 | * ignore autorepeat + unknown key events | |
217 | * 0 == up, 1 == down, 2 == autorepeat, other == undefined | |
218 | */ | |
219 | return; | |
220 | } | |
221 | if (event->code >= KEY_CNT) { | |
222 | /* | |
223 | * Should not happen. But better safe than sorry, | |
224 | * and we make Coverity happy too. | |
225 | */ | |
226 | return; | |
227 | } | |
228 | ||
229 | /* keep track of key state */ | |
230 | if (!il->keydown[event->code] && event->value) { | |
231 | il->keydown[event->code] = true; | |
232 | il->keycount++; | |
233 | } | |
234 | if (il->keydown[event->code] && !event->value) { | |
235 | il->keydown[event->code] = false; | |
236 | il->keycount--; | |
237 | } | |
238 | ||
239 | /* send event to guest when grab is active */ | |
240 | if (il->grab_active) { | |
241 | int qcode = qemu_input_linux_to_qcode(event->code); | |
242 | qemu_input_event_send_key_qcode(NULL, qcode, event->value); | |
243 | } | |
244 | ||
245 | /* hotkey -> record switch request ... */ | |
246 | if (il->keydown[KEY_LEFTCTRL] && | |
247 | il->keydown[KEY_RIGHTCTRL]) { | |
248 | il->grab_request = true; | |
249 | } | |
250 | ||
251 | /* | |
252 | * ... and do the switch when all keys are lifted, so we | |
253 | * confuse neither guest nor host with keys which seem to | |
254 | * be stuck due to missing key-up events. | |
255 | */ | |
256 | if (il->grab_request && !il->keycount) { | |
257 | il->grab_request = false; | |
258 | input_linux_toggle_grab(il); | |
259 | } | |
260 | } | |
261 | } | |
262 | ||
e0d2bd51 GH |
263 | static void input_linux_event_mouse_button(int button) |
264 | { | |
265 | qemu_input_queue_btn(NULL, button, true); | |
266 | qemu_input_event_sync(); | |
267 | qemu_input_queue_btn(NULL, button, false); | |
268 | qemu_input_event_sync(); | |
269 | } | |
270 | ||
d4df42c4 GH |
271 | static void input_linux_handle_mouse(InputLinux *il, struct input_event *event) |
272 | { | |
273 | if (!il->grab_active) { | |
274 | return; | |
275 | } | |
276 | ||
277 | switch (event->type) { | |
278 | case EV_KEY: | |
279 | switch (event->code) { | |
280 | case BTN_LEFT: | |
281 | qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event->value); | |
282 | break; | |
283 | case BTN_RIGHT: | |
284 | qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event->value); | |
285 | break; | |
286 | case BTN_MIDDLE: | |
287 | qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event->value); | |
288 | break; | |
289 | case BTN_GEAR_UP: | |
290 | qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event->value); | |
291 | break; | |
292 | case BTN_GEAR_DOWN: | |
293 | qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN, | |
294 | event->value); | |
295 | break; | |
1266b68c FL |
296 | case BTN_SIDE: |
297 | qemu_input_queue_btn(NULL, INPUT_BUTTON_SIDE, event->value); | |
298 | break; | |
299 | case BTN_EXTRA: | |
300 | qemu_input_queue_btn(NULL, INPUT_BUTTON_EXTRA, event->value); | |
301 | break; | |
d4df42c4 GH |
302 | }; |
303 | break; | |
304 | case EV_REL: | |
305 | switch (event->code) { | |
306 | case REL_X: | |
307 | qemu_input_queue_rel(NULL, INPUT_AXIS_X, event->value); | |
308 | break; | |
309 | case REL_Y: | |
310 | qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event->value); | |
311 | break; | |
312 | case REL_WHEEL: | |
313 | il->wheel = event->value; | |
314 | break; | |
315 | } | |
316 | break; | |
317 | case EV_SYN: | |
318 | qemu_input_event_sync(); | |
319 | if (il->wheel != 0) { | |
320 | input_linux_event_mouse_button((il->wheel > 0) | |
321 | ? INPUT_BUTTON_WHEEL_UP | |
322 | : INPUT_BUTTON_WHEEL_DOWN); | |
323 | il->wheel = 0; | |
324 | } | |
325 | break; | |
326 | } | |
327 | } | |
328 | ||
2e6a64cb | 329 | static void input_linux_event(void *opaque) |
e0d2bd51 GH |
330 | { |
331 | InputLinux *il = opaque; | |
e0d2bd51 | 332 | int rc; |
1684907c JC |
333 | int read_size; |
334 | uint8_t *p = (uint8_t *)&il->event; | |
e0d2bd51 GH |
335 | |
336 | for (;;) { | |
1684907c JC |
337 | read_size = sizeof(il->event) - il->read_offset; |
338 | rc = read(il->fd, &p[il->read_offset], read_size); | |
339 | if (rc != read_size) { | |
e0d2bd51 GH |
340 | if (rc < 0 && errno != EAGAIN) { |
341 | fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno)); | |
342 | qemu_set_fd_handler(il->fd, NULL, NULL, NULL); | |
343 | close(il->fd); | |
1684907c JC |
344 | } else if (rc > 0) { |
345 | il->read_offset += rc; | |
e0d2bd51 GH |
346 | } |
347 | break; | |
348 | } | |
1684907c | 349 | il->read_offset = 0; |
e0d2bd51 | 350 | |
2e6a64cb | 351 | if (il->num_keys) { |
1684907c | 352 | input_linux_handle_keyboard(il, &il->event); |
2e6a64cb GH |
353 | } |
354 | if (il->has_rel_x && il->num_btns) { | |
1684907c | 355 | input_linux_handle_mouse(il, &il->event); |
2e6a64cb | 356 | } |
e0d2bd51 GH |
357 | } |
358 | } | |
359 | ||
0e066b2c | 360 | static void input_linux_complete(UserCreatable *uc, Error **errp) |
e0d2bd51 | 361 | { |
0e066b2c | 362 | InputLinux *il = INPUT_LINUX(uc); |
2a57c55f GH |
363 | uint8_t evtmap, relmap, absmap; |
364 | uint8_t keymap[KEY_CNT / 8], keystate[KEY_CNT / 8]; | |
2e6a64cb | 365 | unsigned int i; |
e0d2bd51 GH |
366 | int rc, ver; |
367 | ||
e0d2bd51 GH |
368 | if (!il->evdev) { |
369 | error_setg(errp, "no input device specified"); | |
0e066b2c | 370 | return; |
e0d2bd51 GH |
371 | } |
372 | ||
373 | il->fd = open(il->evdev, O_RDWR); | |
374 | if (il->fd < 0) { | |
375 | error_setg_file_open(errp, errno, il->evdev); | |
0e066b2c | 376 | return; |
e0d2bd51 GH |
377 | } |
378 | qemu_set_nonblock(il->fd); | |
379 | ||
380 | rc = ioctl(il->fd, EVIOCGVERSION, &ver); | |
381 | if (rc < 0) { | |
382 | error_setg(errp, "%s: is not an evdev device", il->evdev); | |
383 | goto err_close; | |
384 | } | |
385 | ||
386 | rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap); | |
ce47d3d4 GH |
387 | if (rc < 0) { |
388 | error_setg(errp, "%s: failed to read event bits", il->evdev); | |
389 | goto err_close; | |
390 | } | |
e0d2bd51 GH |
391 | |
392 | if (evtmap & (1 << EV_REL)) { | |
2e6a64cb | 393 | relmap = 0; |
ce47d3d4 | 394 | rc = ioctl(il->fd, EVIOCGBIT(EV_REL, sizeof(relmap)), &relmap); |
2e6a64cb GH |
395 | if (relmap & (1 << REL_X)) { |
396 | il->has_rel_x = true; | |
ce47d3d4 GH |
397 | } |
398 | } | |
399 | ||
400 | if (evtmap & (1 << EV_ABS)) { | |
2e6a64cb GH |
401 | absmap = 0; |
402 | rc = ioctl(il->fd, EVIOCGBIT(EV_ABS, sizeof(absmap)), &absmap); | |
403 | if (absmap & (1 << ABS_X)) { | |
404 | il->has_abs_x = true; | |
ce47d3d4 GH |
405 | } |
406 | } | |
407 | ||
2e6a64cb GH |
408 | if (evtmap & (1 << EV_KEY)) { |
409 | memset(keymap, 0, sizeof(keymap)); | |
410 | rc = ioctl(il->fd, EVIOCGBIT(EV_KEY, sizeof(keymap)), keymap); | |
2a57c55f | 411 | rc = ioctl(il->fd, EVIOCGKEY(sizeof(keystate)), keystate); |
2e6a64cb GH |
412 | for (i = 0; i < KEY_CNT; i++) { |
413 | if (keymap[i / 8] & (1 << (i % 8))) { | |
414 | if (linux_is_button(i)) { | |
415 | il->num_btns++; | |
416 | } else { | |
417 | il->num_keys++; | |
418 | } | |
2a57c55f GH |
419 | if (keystate[i / 8] & (1 << (i % 8))) { |
420 | il->keydown[i] = true; | |
421 | il->keycount++; | |
422 | } | |
2e6a64cb GH |
423 | } |
424 | } | |
e0d2bd51 | 425 | } |
2e6a64cb GH |
426 | |
427 | qemu_set_fd_handler(il->fd, input_linux_event, NULL, il); | |
2a57c55f GH |
428 | if (il->keycount) { |
429 | /* delay grab until all keys are released */ | |
430 | il->grab_request = true; | |
431 | } else { | |
432 | input_linux_toggle_grab(il); | |
433 | } | |
46d921be | 434 | QTAILQ_INSERT_TAIL(&inputs, il, next); |
0e066b2c GH |
435 | il->initialized = true; |
436 | return; | |
e0d2bd51 GH |
437 | |
438 | err_close: | |
439 | close(il->fd); | |
0e066b2c GH |
440 | return; |
441 | } | |
442 | ||
443 | static void input_linux_instance_finalize(Object *obj) | |
444 | { | |
445 | InputLinux *il = INPUT_LINUX(obj); | |
446 | ||
447 | if (il->initialized) { | |
448 | QTAILQ_REMOVE(&inputs, il, next); | |
449 | close(il->fd); | |
450 | } | |
451 | g_free(il->evdev); | |
e0d2bd51 GH |
452 | } |
453 | ||
0e066b2c GH |
454 | static char *input_linux_get_evdev(Object *obj, Error **errp) |
455 | { | |
456 | InputLinux *il = INPUT_LINUX(obj); | |
457 | ||
458 | return g_strdup(il->evdev); | |
459 | } | |
460 | ||
461 | static void input_linux_set_evdev(Object *obj, const char *value, | |
462 | Error **errp) | |
463 | { | |
464 | InputLinux *il = INPUT_LINUX(obj); | |
465 | ||
466 | if (il->evdev) { | |
467 | error_setg(errp, "evdev property already set"); | |
468 | return; | |
469 | } | |
470 | il->evdev = g_strdup(value); | |
471 | } | |
472 | ||
473 | static bool input_linux_get_grab_all(Object *obj, Error **errp) | |
474 | { | |
475 | InputLinux *il = INPUT_LINUX(obj); | |
476 | ||
477 | return il->grab_all; | |
478 | } | |
479 | ||
480 | static void input_linux_set_grab_all(Object *obj, bool value, | |
481 | Error **errp) | |
482 | { | |
483 | InputLinux *il = INPUT_LINUX(obj); | |
484 | ||
485 | il->grab_all = value; | |
486 | } | |
487 | ||
488 | static bool input_linux_get_repeat(Object *obj, Error **errp) | |
489 | { | |
490 | InputLinux *il = INPUT_LINUX(obj); | |
491 | ||
492 | return il->repeat; | |
493 | } | |
494 | ||
495 | static void input_linux_set_repeat(Object *obj, bool value, | |
496 | Error **errp) | |
497 | { | |
498 | InputLinux *il = INPUT_LINUX(obj); | |
499 | ||
500 | il->repeat = value; | |
501 | } | |
502 | ||
503 | static void input_linux_instance_init(Object *obj) | |
504 | { | |
505 | object_property_add_str(obj, "evdev", | |
506 | input_linux_get_evdev, | |
507 | input_linux_set_evdev, NULL); | |
508 | object_property_add_bool(obj, "grab_all", | |
509 | input_linux_get_grab_all, | |
510 | input_linux_set_grab_all, NULL); | |
511 | object_property_add_bool(obj, "repeat", | |
512 | input_linux_get_repeat, | |
513 | input_linux_set_repeat, NULL); | |
514 | } | |
515 | ||
516 | static void input_linux_class_init(ObjectClass *oc, void *data) | |
517 | { | |
518 | UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc); | |
519 | ||
520 | ucc->complete = input_linux_complete; | |
521 | } | |
522 | ||
523 | static const TypeInfo input_linux_info = { | |
524 | .name = TYPE_INPUT_LINUX, | |
525 | .parent = TYPE_OBJECT, | |
526 | .class_size = sizeof(InputLinuxClass), | |
527 | .class_init = input_linux_class_init, | |
528 | .instance_size = sizeof(InputLinux), | |
529 | .instance_init = input_linux_instance_init, | |
530 | .instance_finalize = input_linux_instance_finalize, | |
531 | .interfaces = (InterfaceInfo[]) { | |
532 | { TYPE_USER_CREATABLE }, | |
533 | { } | |
534 | } | |
e0d2bd51 GH |
535 | }; |
536 | ||
0e066b2c | 537 | static void register_types(void) |
e0d2bd51 | 538 | { |
0e066b2c | 539 | type_register_static(&input_linux_info); |
e0d2bd51 | 540 | } |
0e066b2c GH |
541 | |
542 | type_init(register_types); |