1 | /* |
2 | * QEMU System Emulator |
3 | * |
4 | * Copyright (c) 2003-2008 Fabrice Bellard |
5 | * |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
7 | * of this software and associated documentation files (the "Software"), to deal |
8 | * in the Software without restriction, including without limitation the rights |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
10 | * copies of the Software, and to permit persons to whom the Software is |
11 | * furnished to do so, subject to the following conditions: |
12 | * |
13 | * The above copyright notice and this permission notice shall be included in |
14 | * all copies or substantial portions of the Software. |
15 | * |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
22 | * THE SOFTWARE. |
23 | */ |
24 | |
25 | #include "qemu/osdep.h" |
26 | #include "qapi/qapi-commands-ui.h" |
27 | #include "ui/console.h" |
28 | #include "keymaps.h" |
29 | #include "ui/input.h" |
30 | |
31 | struct QEMUPutMouseEntry { |
32 | QEMUPutMouseEvent *qemu_put_mouse_event; |
33 | void *qemu_put_mouse_event_opaque; |
34 | int qemu_put_mouse_event_absolute; |
35 | |
36 | /* new input core */ |
37 | QemuInputHandler h; |
38 | QemuInputHandlerState *s; |
39 | int axis[INPUT_AXIS__MAX]; |
40 | int buttons; |
41 | }; |
42 | |
43 | struct QEMUPutKbdEntry { |
44 | QEMUPutKBDEvent *put_kbd; |
45 | void *opaque; |
46 | QemuInputHandlerState *s; |
47 | }; |
48 | |
49 | struct QEMUPutLEDEntry { |
50 | QEMUPutLEDEvent *put_led; |
51 | void *opaque; |
52 | QTAILQ_ENTRY(QEMUPutLEDEntry) next; |
53 | }; |
54 | |
55 | static QTAILQ_HEAD(, QEMUPutLEDEntry) led_handlers = |
56 | QTAILQ_HEAD_INITIALIZER(led_handlers); |
57 | |
58 | int index_from_key(const char *key, size_t key_length) |
59 | { |
60 | int i; |
61 | |
62 | for (i = 0; i < Q_KEY_CODE__MAX; i++) { |
63 | if (!strncmp(key, QKeyCode_str(i), key_length) && |
64 | !QKeyCode_str(i)[key_length]) { |
65 | break; |
66 | } |
67 | } |
68 | |
69 | /* Return Q_KEY_CODE__MAX if the key is invalid */ |
70 | return i; |
71 | } |
72 | |
73 | static KeyValue *copy_key_value(KeyValue *src) |
74 | { |
75 | KeyValue *dst = g_new(KeyValue, 1); |
76 | memcpy(dst, src, sizeof(*src)); |
77 | if (dst->type == KEY_VALUE_KIND_NUMBER) { |
78 | QKeyCode code = qemu_input_key_number_to_qcode(dst->u.number.data); |
79 | dst->type = KEY_VALUE_KIND_QCODE; |
80 | dst->u.qcode.data = code; |
81 | } |
82 | return dst; |
83 | } |
84 | |
85 | void qmp_send_key(KeyValueList *keys, bool has_hold_time, int64_t hold_time, |
86 | Error **errp) |
87 | { |
88 | KeyValueList *p; |
89 | KeyValue **up = NULL; |
90 | int count = 0; |
91 | |
92 | if (!has_hold_time) { |
93 | hold_time = 0; /* use default */ |
94 | } |
95 | |
96 | for (p = keys; p != NULL; p = p->next) { |
97 | qemu_input_event_send_key(NULL, copy_key_value(p->value), true); |
98 | qemu_input_event_send_key_delay(hold_time); |
99 | up = g_realloc(up, sizeof(*up) * (count+1)); |
100 | up[count] = copy_key_value(p->value); |
101 | count++; |
102 | } |
103 | while (count) { |
104 | count--; |
105 | qemu_input_event_send_key(NULL, up[count], false); |
106 | qemu_input_event_send_key_delay(hold_time); |
107 | } |
108 | g_free(up); |
109 | } |
110 | |
111 | static void legacy_kbd_event(DeviceState *dev, QemuConsole *src, |
112 | InputEvent *evt) |
113 | { |
114 | QEMUPutKbdEntry *entry = (QEMUPutKbdEntry *)dev; |
115 | int scancodes[3], i, count; |
116 | InputKeyEvent *key = evt->u.key.data; |
117 | |
118 | if (!entry || !entry->put_kbd) { |
119 | return; |
120 | } |
121 | count = qemu_input_key_value_to_scancode(key->key, |
122 | key->down, |
123 | scancodes); |
124 | for (i = 0; i < count; i++) { |
125 | entry->put_kbd(entry->opaque, scancodes[i]); |
126 | } |
127 | } |
128 | |
129 | static QemuInputHandler legacy_kbd_handler = { |
130 | .name = "legacy-kbd" , |
131 | .mask = INPUT_EVENT_MASK_KEY, |
132 | .event = legacy_kbd_event, |
133 | }; |
134 | |
135 | QEMUPutKbdEntry *qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque) |
136 | { |
137 | QEMUPutKbdEntry *entry; |
138 | |
139 | entry = g_new0(QEMUPutKbdEntry, 1); |
140 | entry->put_kbd = func; |
141 | entry->opaque = opaque; |
142 | entry->s = qemu_input_handler_register((DeviceState *)entry, |
143 | &legacy_kbd_handler); |
144 | qemu_input_handler_activate(entry->s); |
145 | return entry; |
146 | } |
147 | |
148 | static void legacy_mouse_event(DeviceState *dev, QemuConsole *src, |
149 | InputEvent *evt) |
150 | { |
151 | static const int bmap[INPUT_BUTTON__MAX] = { |
152 | [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON, |
153 | [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON, |
154 | [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON, |
155 | }; |
156 | QEMUPutMouseEntry *s = (QEMUPutMouseEntry *)dev; |
157 | InputBtnEvent *btn; |
158 | InputMoveEvent *move; |
159 | |
160 | switch (evt->type) { |
161 | case INPUT_EVENT_KIND_BTN: |
162 | btn = evt->u.btn.data; |
163 | if (btn->down) { |
164 | s->buttons |= bmap[btn->button]; |
165 | } else { |
166 | s->buttons &= ~bmap[btn->button]; |
167 | } |
168 | if (btn->down && btn->button == INPUT_BUTTON_WHEEL_UP) { |
169 | s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque, |
170 | s->axis[INPUT_AXIS_X], |
171 | s->axis[INPUT_AXIS_Y], |
172 | -1, |
173 | s->buttons); |
174 | } |
175 | if (btn->down && btn->button == INPUT_BUTTON_WHEEL_DOWN) { |
176 | s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque, |
177 | s->axis[INPUT_AXIS_X], |
178 | s->axis[INPUT_AXIS_Y], |
179 | 1, |
180 | s->buttons); |
181 | } |
182 | break; |
183 | case INPUT_EVENT_KIND_ABS: |
184 | move = evt->u.abs.data; |
185 | s->axis[move->axis] = move->value; |
186 | break; |
187 | case INPUT_EVENT_KIND_REL: |
188 | move = evt->u.rel.data; |
189 | s->axis[move->axis] += move->value; |
190 | break; |
191 | default: |
192 | break; |
193 | } |
194 | } |
195 | |
196 | static void legacy_mouse_sync(DeviceState *dev) |
197 | { |
198 | QEMUPutMouseEntry *s = (QEMUPutMouseEntry *)dev; |
199 | |
200 | s->qemu_put_mouse_event(s->qemu_put_mouse_event_opaque, |
201 | s->axis[INPUT_AXIS_X], |
202 | s->axis[INPUT_AXIS_Y], |
203 | 0, |
204 | s->buttons); |
205 | |
206 | if (!s->qemu_put_mouse_event_absolute) { |
207 | s->axis[INPUT_AXIS_X] = 0; |
208 | s->axis[INPUT_AXIS_Y] = 0; |
209 | } |
210 | } |
211 | |
212 | QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, |
213 | void *opaque, int absolute, |
214 | const char *name) |
215 | { |
216 | QEMUPutMouseEntry *s; |
217 | |
218 | s = g_new0(QEMUPutMouseEntry, 1); |
219 | |
220 | s->qemu_put_mouse_event = func; |
221 | s->qemu_put_mouse_event_opaque = opaque; |
222 | s->qemu_put_mouse_event_absolute = absolute; |
223 | |
224 | s->h.name = name; |
225 | s->h.mask = INPUT_EVENT_MASK_BTN | |
226 | (absolute ? INPUT_EVENT_MASK_ABS : INPUT_EVENT_MASK_REL); |
227 | s->h.event = legacy_mouse_event; |
228 | s->h.sync = legacy_mouse_sync; |
229 | s->s = qemu_input_handler_register((DeviceState *)s, |
230 | &s->h); |
231 | |
232 | return s; |
233 | } |
234 | |
235 | void qemu_activate_mouse_event_handler(QEMUPutMouseEntry *entry) |
236 | { |
237 | qemu_input_handler_activate(entry->s); |
238 | } |
239 | |
240 | void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry) |
241 | { |
242 | qemu_input_handler_unregister(entry->s); |
243 | |
244 | g_free(entry); |
245 | } |
246 | |
247 | QEMUPutLEDEntry *qemu_add_led_event_handler(QEMUPutLEDEvent *func, |
248 | void *opaque) |
249 | { |
250 | QEMUPutLEDEntry *s; |
251 | |
252 | s = g_new0(QEMUPutLEDEntry, 1); |
253 | |
254 | s->put_led = func; |
255 | s->opaque = opaque; |
256 | QTAILQ_INSERT_TAIL(&led_handlers, s, next); |
257 | return s; |
258 | } |
259 | |
260 | void qemu_remove_led_event_handler(QEMUPutLEDEntry *entry) |
261 | { |
262 | if (entry == NULL) |
263 | return; |
264 | QTAILQ_REMOVE(&led_handlers, entry, next); |
265 | g_free(entry); |
266 | } |
267 | |
268 | void kbd_put_ledstate(int ledstate) |
269 | { |
270 | QEMUPutLEDEntry *cursor; |
271 | |
272 | QTAILQ_FOREACH(cursor, &led_handlers, next) { |
273 | cursor->put_led(cursor->opaque, ledstate); |
274 | } |
275 | } |
276 | |