ui: Add more mouse buttons to SPICE
[qemu.git] / ui / spice-input.c
1 /*
2 * Copyright (C) 2010 Red Hat, Inc.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 or
7 * (at your option) version 3 of the License.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #include "qemu/osdep.h"
19
20 #include <spice.h>
21 #include <spice/enums.h>
22
23 #include "ui/qemu-spice.h"
24 #include "ui/console.h"
25 #include "keymaps.h"
26 #include "ui/input.h"
27
28 /* keyboard bits */
29
30 typedef struct QemuSpiceKbd {
31 SpiceKbdInstance sin;
32 int ledstate;
33 bool emul0;
34 size_t pauseseq;
35 } QemuSpiceKbd;
36
37 static void kbd_push_key(SpiceKbdInstance *sin, uint8_t frag);
38 static uint8_t kbd_get_leds(SpiceKbdInstance *sin);
39 static void kbd_leds(void *opaque, int l);
40
41 static const SpiceKbdInterface kbd_interface = {
42 .base.type = SPICE_INTERFACE_KEYBOARD,
43 .base.description = "qemu keyboard",
44 .base.major_version = SPICE_INTERFACE_KEYBOARD_MAJOR,
45 .base.minor_version = SPICE_INTERFACE_KEYBOARD_MINOR,
46 .push_scan_freg = kbd_push_key,
47 .get_leds = kbd_get_leds,
48 };
49
50 static void kbd_push_key(SpiceKbdInstance *sin, uint8_t scancode)
51 {
52 static const uint8_t pauseseq[] = { 0xe1, 0x1d, 0x45, 0xe1, 0x9d, 0xc5 };
53 QemuSpiceKbd *kbd = container_of(sin, QemuSpiceKbd, sin);
54 int keycode;
55 bool up;
56
57 if (scancode == SCANCODE_EMUL0) {
58 kbd->emul0 = true;
59 return;
60 }
61
62 if (scancode == pauseseq[kbd->pauseseq]) {
63 kbd->pauseseq++;
64 if (kbd->pauseseq == G_N_ELEMENTS(pauseseq)) {
65 qemu_input_event_send_key_qcode(NULL, Q_KEY_CODE_PAUSE, true);
66 kbd->pauseseq = 0;
67 }
68 return;
69 } else {
70 kbd->pauseseq = 0;
71 }
72
73 keycode = scancode & ~SCANCODE_UP;
74 up = scancode & SCANCODE_UP;
75 if (kbd->emul0) {
76 kbd->emul0 = false;
77 keycode |= SCANCODE_GREY;
78 }
79
80 qemu_input_event_send_key_number(NULL, keycode, !up);
81 }
82
83 static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
84 {
85 QemuSpiceKbd *kbd = container_of(sin, QemuSpiceKbd, sin);
86 return kbd->ledstate;
87 }
88
89 static void kbd_leds(void *opaque, int ledstate)
90 {
91 QemuSpiceKbd *kbd = opaque;
92
93 kbd->ledstate = 0;
94 if (ledstate & QEMU_SCROLL_LOCK_LED) {
95 kbd->ledstate |= SPICE_KEYBOARD_MODIFIER_FLAGS_SCROLL_LOCK;
96 }
97 if (ledstate & QEMU_NUM_LOCK_LED) {
98 kbd->ledstate |= SPICE_KEYBOARD_MODIFIER_FLAGS_NUM_LOCK;
99 }
100 if (ledstate & QEMU_CAPS_LOCK_LED) {
101 kbd->ledstate |= SPICE_KEYBOARD_MODIFIER_FLAGS_CAPS_LOCK;
102 }
103 spice_server_kbd_leds(&kbd->sin, kbd->ledstate);
104 }
105
106 /* mouse bits */
107
108 typedef struct QemuSpicePointer {
109 SpiceMouseInstance mouse;
110 SpiceTabletInstance tablet;
111 int width, height;
112 uint32_t last_bmask;
113 Notifier mouse_mode;
114 bool absolute;
115 } QemuSpicePointer;
116
117 static void spice_update_buttons(QemuSpicePointer *pointer,
118 int wheel, uint32_t button_mask)
119 {
120 static uint32_t bmap[INPUT_BUTTON__MAX] = {
121 [INPUT_BUTTON_LEFT] = 0x01,
122 [INPUT_BUTTON_MIDDLE] = 0x04,
123 [INPUT_BUTTON_RIGHT] = 0x02,
124 [INPUT_BUTTON_WHEEL_UP] = 0x10,
125 [INPUT_BUTTON_WHEEL_DOWN] = 0x20,
126 [INPUT_BUTTON_SIDE] = 0x40,
127 [INPUT_BUTTON_EXTRA] = 0x80,
128 };
129
130 if (wheel < 0) {
131 button_mask |= 0x10;
132 }
133 if (wheel > 0) {
134 button_mask |= 0x20;
135 }
136
137 if (pointer->last_bmask == button_mask) {
138 return;
139 }
140 qemu_input_update_buttons(NULL, bmap, pointer->last_bmask, button_mask);
141 pointer->last_bmask = button_mask;
142 }
143
144 static void mouse_motion(SpiceMouseInstance *sin, int dx, int dy, int dz,
145 uint32_t buttons_state)
146 {
147 QemuSpicePointer *pointer = container_of(sin, QemuSpicePointer, mouse);
148 spice_update_buttons(pointer, dz, buttons_state);
149 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
150 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
151 qemu_input_event_sync();
152 }
153
154 static void mouse_buttons(SpiceMouseInstance *sin, uint32_t buttons_state)
155 {
156 QemuSpicePointer *pointer = container_of(sin, QemuSpicePointer, mouse);
157 spice_update_buttons(pointer, 0, buttons_state);
158 qemu_input_event_sync();
159 }
160
161 static const SpiceMouseInterface mouse_interface = {
162 .base.type = SPICE_INTERFACE_MOUSE,
163 .base.description = "mouse",
164 .base.major_version = SPICE_INTERFACE_MOUSE_MAJOR,
165 .base.minor_version = SPICE_INTERFACE_MOUSE_MINOR,
166 .motion = mouse_motion,
167 .buttons = mouse_buttons,
168 };
169
170 static void tablet_set_logical_size(SpiceTabletInstance* sin, int width, int height)
171 {
172 QemuSpicePointer *pointer = container_of(sin, QemuSpicePointer, tablet);
173
174 if (height < 16) {
175 height = 16;
176 }
177 if (width < 16) {
178 width = 16;
179 }
180 pointer->width = width;
181 pointer->height = height;
182 }
183
184 static void tablet_position(SpiceTabletInstance* sin, int x, int y,
185 uint32_t buttons_state)
186 {
187 QemuSpicePointer *pointer = container_of(sin, QemuSpicePointer, tablet);
188
189 spice_update_buttons(pointer, 0, buttons_state);
190 qemu_input_queue_abs(NULL, INPUT_AXIS_X, x, 0, pointer->width);
191 qemu_input_queue_abs(NULL, INPUT_AXIS_Y, y, 0, pointer->height);
192 qemu_input_event_sync();
193 }
194
195
196 static void tablet_wheel(SpiceTabletInstance* sin, int wheel,
197 uint32_t buttons_state)
198 {
199 QemuSpicePointer *pointer = container_of(sin, QemuSpicePointer, tablet);
200
201 spice_update_buttons(pointer, wheel, buttons_state);
202 qemu_input_event_sync();
203 }
204
205 static void tablet_buttons(SpiceTabletInstance *sin,
206 uint32_t buttons_state)
207 {
208 QemuSpicePointer *pointer = container_of(sin, QemuSpicePointer, tablet);
209
210 spice_update_buttons(pointer, 0, buttons_state);
211 qemu_input_event_sync();
212 }
213
214 static const SpiceTabletInterface tablet_interface = {
215 .base.type = SPICE_INTERFACE_TABLET,
216 .base.description = "tablet",
217 .base.major_version = SPICE_INTERFACE_TABLET_MAJOR,
218 .base.minor_version = SPICE_INTERFACE_TABLET_MINOR,
219 .set_logical_size = tablet_set_logical_size,
220 .position = tablet_position,
221 .wheel = tablet_wheel,
222 .buttons = tablet_buttons,
223 };
224
225 static void mouse_mode_notifier(Notifier *notifier, void *data)
226 {
227 QemuSpicePointer *pointer = container_of(notifier, QemuSpicePointer, mouse_mode);
228 bool is_absolute = qemu_input_is_absolute();
229
230 if (pointer->absolute == is_absolute) {
231 return;
232 }
233
234 if (is_absolute) {
235 qemu_spice_add_interface(&pointer->tablet.base);
236 } else {
237 spice_server_remove_interface(&pointer->tablet.base);
238 }
239 pointer->absolute = is_absolute;
240 }
241
242 void qemu_spice_input_init(void)
243 {
244 QemuSpiceKbd *kbd;
245 QemuSpicePointer *pointer;
246
247 kbd = g_malloc0(sizeof(*kbd));
248 kbd->sin.base.sif = &kbd_interface.base;
249 qemu_spice_add_interface(&kbd->sin.base);
250 qemu_add_led_event_handler(kbd_leds, kbd);
251
252 pointer = g_malloc0(sizeof(*pointer));
253 pointer->mouse.base.sif = &mouse_interface.base;
254 pointer->tablet.base.sif = &tablet_interface.base;
255 qemu_spice_add_interface(&pointer->mouse.base);
256
257 pointer->absolute = false;
258 pointer->mouse_mode.notify = mouse_mode_notifier;
259 qemu_add_mouse_mode_change_notifier(&pointer->mouse_mode);
260 mouse_mode_notifier(&pointer->mouse_mode, NULL);
261 }