blob: 0e805746cfe95a88a0904829472cda3203d0914e [file] [log] [blame]
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +01001/*
2 * Copyright © 2012 Intel Corporation
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 */
22
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
Kristian Høgsberg1199b162012-11-27 13:41:48 -050026#include <unistd.h>
27#include <sys/mman.h>
28
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +010029
30#include <linux/input.h>
31
32#include "window.h"
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +010033#include "input-method-client-protocol.h"
34
35enum compose_state {
36 state_normal,
37 state_compose
38};
39
40struct compose_seq {
41 uint32_t keys[4];
42
43 const char *text;
44};
45
46struct simple_im {
47 struct input_method *input_method;
48 struct input_method_context *context;
Kristian Høgsberg8c036162012-11-27 13:47:16 -050049 struct xkb_context *xkb_context;
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +010050 struct display *display;
51 struct wl_keyboard *keyboard;
52 struct keyboard_input *keyboard_input;
53 enum compose_state compose_state;
54 struct compose_seq compose_seq;
55};
56
57static const struct compose_seq compose_seqs[] = {
58 { { XKB_KEY_quotedbl, XKB_KEY_A, 0 }, "Ä" },
59 { { XKB_KEY_quotedbl, XKB_KEY_O, 0 }, "Ö" },
60 { { XKB_KEY_quotedbl, XKB_KEY_U, 0 }, "Ü" },
61 { { XKB_KEY_quotedbl, XKB_KEY_a, 0 }, "ä" },
62 { { XKB_KEY_quotedbl, XKB_KEY_o, 0 }, "ö" },
63 { { XKB_KEY_quotedbl, XKB_KEY_u, 0 }, "ü" },
64 { { XKB_KEY_apostrophe, XKB_KEY_A, 0 }, "Á" },
65 { { XKB_KEY_apostrophe, XKB_KEY_a, 0 }, "á" },
66 { { XKB_KEY_O, XKB_KEY_C, 0 }, "©" },
67 { { XKB_KEY_O, XKB_KEY_R, 0 }, "®" },
68 { { XKB_KEY_s, XKB_KEY_s, 0 }, "ß" },
69};
70
71static const uint32_t ignore_keys_on_compose[] = {
72 XKB_KEY_Shift_L,
73 XKB_KEY_Shift_R
74};
75
Kristian Høgsberg1199b162012-11-27 13:41:48 -050076typedef void (*keyboard_input_key_handler_t)(struct keyboard_input *keyboard_input,
Kristian Høgsberg79bfde22012-11-27 13:57:27 -050077 uint32_t serial,
Kristian Høgsberg1199b162012-11-27 13:41:48 -050078 uint32_t time, uint32_t key, uint32_t unicode,
79 enum wl_keyboard_key_state state, void *data);
80
81struct keyboard_input {
82 struct xkb_context *xkb_context;
83
84 uint32_t modifiers;
85
86 struct xkb_keymap *keymap;
87 struct xkb_state *state;
88 xkb_mod_mask_t control_mask;
89 xkb_mod_mask_t alt_mask;
90 xkb_mod_mask_t shift_mask;
91
92 void *user_data;
93 keyboard_input_key_handler_t key_handler;
94};
95
96static struct keyboard_input*
97keyboard_input_create(struct xkb_context *xkb_context)
98{
99 struct keyboard_input *keyboard_input;
100
101 keyboard_input = calloc(1, sizeof *keyboard_input);
102 keyboard_input->xkb_context = xkb_context;
103
104 return keyboard_input;
105}
106
107static void
108keyboard_input_handle_keymap(struct keyboard_input *keyboard_input,
109 uint32_t format, int fd, uint32_t size)
110{
111 char *map_str;
112
113 if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
114 close(fd);
115 return;
116 }
117
118 map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
119 if (map_str == MAP_FAILED) {
120 close(fd);
121 return;
122 }
123
124 keyboard_input->keymap = xkb_map_new_from_string(keyboard_input->xkb_context,
125 map_str,
126 XKB_KEYMAP_FORMAT_TEXT_V1,
127 0);
128
129 munmap(map_str, size);
130 close(fd);
131
132 if (!keyboard_input->keymap) {
133 fprintf(stderr, "failed to compile keymap\n");
134 return;
135 }
136
137 keyboard_input->state = xkb_state_new(keyboard_input->keymap);
138 if (!keyboard_input->state) {
139 fprintf(stderr, "failed to create XKB state\n");
140 xkb_map_unref(keyboard_input->keymap);
141 return;
142 }
143
144 keyboard_input->control_mask =
145 1 << xkb_map_mod_get_index(keyboard_input->keymap, "Control");
146 keyboard_input->alt_mask =
147 1 << xkb_map_mod_get_index(keyboard_input->keymap, "Mod1");
148 keyboard_input->shift_mask =
149 1 << xkb_map_mod_get_index(keyboard_input->keymap, "Shift");
150}
151
152static void
153keyboard_input_handle_key(struct keyboard_input *keyboard_input,
154 uint32_t serial, uint32_t time,
155 uint32_t key, uint32_t state_w)
156{
157 uint32_t code;
158 uint32_t num_syms;
159 const xkb_keysym_t *syms;
160 xkb_keysym_t sym;
161 enum wl_keyboard_key_state state = state_w;
162
163 if (!keyboard_input->state)
164 return;
165
166 code = key + 8;
167 num_syms = xkb_key_get_syms(keyboard_input->state, code, &syms);
168
169 sym = XKB_KEY_NoSymbol;
170 if (num_syms == 1)
171 sym = syms[0];
172
173 if (keyboard_input->key_handler)
Kristian Høgsberg79bfde22012-11-27 13:57:27 -0500174 (*keyboard_input->key_handler)(keyboard_input, serial, time, key, sym,
Kristian Høgsberg1199b162012-11-27 13:41:48 -0500175 state, keyboard_input->user_data);
176}
177
178static void
179keyboard_input_handle_modifiers(struct keyboard_input *keyboard_input,
180 uint32_t serial, uint32_t mods_depressed,
181 uint32_t mods_latched, uint32_t mods_locked,
182 uint32_t group)
183{
184 xkb_mod_mask_t mask;
185
186 xkb_state_update_mask(keyboard_input->state, mods_depressed, mods_latched,
187 mods_locked, 0, 0, group);
188 mask = xkb_state_serialize_mods(keyboard_input->state,
189 XKB_STATE_DEPRESSED |
190 XKB_STATE_LATCHED);
191
192 keyboard_input->modifiers = 0;
193 if (mask & keyboard_input->control_mask)
194 keyboard_input->modifiers |= MOD_CONTROL_MASK;
195 if (mask & keyboard_input->alt_mask)
196 keyboard_input->modifiers |= MOD_ALT_MASK;
197 if (mask & keyboard_input->shift_mask)
198 keyboard_input->modifiers |= MOD_SHIFT_MASK;
199
200}
201
202static void
203keyboard_input_set_user_data(struct keyboard_input *keyboard_input, void *data)
204{
205 keyboard_input->user_data = data;
206}
207
208static void
209keyboard_input_set_key_handler(struct keyboard_input *keyboard_input,
210 keyboard_input_key_handler_t handler)
211{
212 keyboard_input->key_handler = handler;
213}
214
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +0100215static void
216input_method_context_surrounding_text(void *data,
217 struct input_method_context *context,
218 const char *text,
219 uint32_t cursor,
220 uint32_t anchor)
221{
222 fprintf(stderr, "Surrounding text updated: %s\n", text);
223}
224
225static void
226input_method_context_reset(void *data,
227 struct input_method_context *context)
228{
229 struct simple_im *keyboard = data;
230
231 fprintf(stderr, "Reset pre-edit buffer\n");
232
233 keyboard->compose_state = state_normal;
234}
235
236static const struct input_method_context_listener input_method_context_listener = {
237 input_method_context_surrounding_text,
238 input_method_context_reset
239};
240
241static void
242input_method_keyboard_keymap(void *data,
243 struct wl_keyboard *wl_keyboard,
244 uint32_t format,
245 int32_t fd,
246 uint32_t size)
247{
248 struct simple_im *keyboard = data;
249
250 keyboard_input_handle_keymap(keyboard->keyboard_input, format, fd, size);
251}
252
253static void
254input_method_keyboard_key(void *data,
255 struct wl_keyboard *wl_keyboard,
256 uint32_t serial,
257 uint32_t time,
258 uint32_t key,
259 uint32_t state_w)
260{
261 struct simple_im *keyboard = data;
262
263 keyboard_input_handle_key(keyboard->keyboard_input, serial,
264 time, key, state_w);
265}
266
267static void
268input_method_keyboard_modifiers(void *data,
269 struct wl_keyboard *wl_keyboard,
270 uint32_t serial,
271 uint32_t mods_depressed,
272 uint32_t mods_latched,
273 uint32_t mods_locked,
274 uint32_t group)
275{
276 struct simple_im *keyboard = data;
277 struct input_method_context *context = keyboard->context;
278
279 keyboard_input_handle_modifiers(keyboard->keyboard_input, serial,
280 mods_depressed, mods_latched, mods_locked, group);
281
282 input_method_context_modifiers(context, serial,
283 mods_depressed, mods_depressed,
284 mods_latched, group);
285}
286
287static const struct wl_keyboard_listener input_method_keyboard_listener = {
288 input_method_keyboard_keymap,
289 NULL, /* enter */
290 NULL, /* leave */
291 input_method_keyboard_key,
292 input_method_keyboard_modifiers
293};
294
295static void
296input_method_activate(void *data,
297 struct input_method *input_method,
298 struct input_method_context *context)
299{
300 struct simple_im *keyboard = data;
301
302 if (keyboard->context)
303 input_method_context_destroy(keyboard->context);
304
305 keyboard->compose_state = state_normal;
306
307 keyboard->context = context;
308 input_method_context_add_listener(context,
309 &input_method_context_listener,
310 keyboard);
311 keyboard->keyboard = input_method_context_grab_keyboard(context);
312 wl_keyboard_add_listener(keyboard->keyboard,
313 &input_method_keyboard_listener,
314 keyboard);
315}
316
317static void
318input_method_deactivate(void *data,
319 struct input_method *input_method,
320 struct input_method_context *context)
321{
322 struct simple_im *keyboard = data;
323
324 if (!keyboard->context)
325 return;
326
327 input_method_context_destroy(keyboard->context);
328 keyboard->context = NULL;
329}
330
331static const struct input_method_listener input_method_listener = {
332 input_method_activate,
333 input_method_deactivate
334};
335
336static void
337global_handler(struct display *display, uint32_t name,
338 const char *interface, uint32_t version, void *data)
339{
340 struct simple_im *keyboard = data;
341
342 if (!strcmp(interface, "input_method")) {
343 keyboard->input_method =
344 display_bind(display, name,
345 &input_method_interface, 1);
346 input_method_add_listener(keyboard->input_method, &input_method_listener, keyboard);
347 }
348}
349
350static int
351compare_compose_keys(const void *c1, const void *c2)
352{
353 const struct compose_seq *cs1 = c1;
354 const struct compose_seq *cs2 = c2;
355 int i;
356
357 for (i = 0; cs1->keys[i] != 0 && cs2->keys[i] != 0; i++) {
358 if (cs1->keys[i] != cs2->keys[i])
359 return cs1->keys[i] - cs2->keys[i];
360 }
361
362 if (cs1->keys[i] == cs2->keys[i]
363 || cs1->keys[i] == 0)
364 return 0;
365
366 return cs1->keys[i] - cs2->keys[i];
367}
368
369static void
370simple_im_key_handler(struct keyboard_input *keyboard_input,
Kristian Høgsberg79bfde22012-11-27 13:57:27 -0500371 uint32_t serial, uint32_t time, uint32_t key, uint32_t sym,
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +0100372 enum wl_keyboard_key_state state, void *data)
373{
374 struct simple_im *keyboard = data;
375 struct input_method_context *context = keyboard->context;
376 char text[64];
377
378 if (sym == XKB_KEY_Multi_key &&
379 state == WL_KEYBOARD_KEY_STATE_RELEASED &&
380 keyboard->compose_state == state_normal) {
381 keyboard->compose_state = state_compose;
382 memset(&keyboard->compose_seq, 0, sizeof(struct compose_seq));
383 return;
384 }
385
386 if (keyboard->compose_state == state_compose) {
387 uint32_t i = 0;
388 struct compose_seq *cs;
389
390 if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
391 return;
392
393 for (i = 0; i < sizeof(ignore_keys_on_compose) / sizeof(ignore_keys_on_compose[0]); i++) {
394 if (sym == ignore_keys_on_compose[i]) {
Kristian Høgsberg79bfde22012-11-27 13:57:27 -0500395 input_method_context_key(context, serial, time, key, state);
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +0100396 return;
397 }
398 }
399
400 for (i = 0; keyboard->compose_seq.keys[i] != 0; i++);
401
402 keyboard->compose_seq.keys[i] = sym;
403
404 cs = bsearch (&keyboard->compose_seq, compose_seqs,
405 sizeof(compose_seqs) / sizeof(compose_seqs[0]),
406 sizeof(compose_seqs[0]), compare_compose_keys);
407
408 if (cs) {
409 if (cs->keys[i + 1] == 0) {
410 input_method_context_preedit_string(keyboard->context,
411 "", 0);
412 input_method_context_commit_string(keyboard->context,
413 cs->text,
414 strlen(cs->text));
415 keyboard->compose_state = state_normal;
416 } else {
417 uint32_t j = 0, idx = 0;
418
419 for (; j <= i; j++) {
420 idx += xkb_keysym_to_utf8(cs->keys[j], text + idx, sizeof(text) - idx);
421 }
422
423 input_method_context_preedit_string(keyboard->context,
424 text,
425 strlen(text));
426 }
427 } else {
428 uint32_t j = 0, idx = 0;
429
430 for (; j <= i; j++) {
431 idx += xkb_keysym_to_utf8(keyboard->compose_seq.keys[j], text + idx, sizeof(text) - idx);
432 }
433 input_method_context_preedit_string(keyboard->context,
434 "", 0);
435 input_method_context_commit_string(keyboard->context,
436 text,
437 strlen(text));
438 keyboard->compose_state = state_normal;
439 }
440 return;
441 }
442
443 if (xkb_keysym_to_utf8(sym, text, sizeof(text)) <= 0) {
Kristian Høgsberg79bfde22012-11-27 13:57:27 -0500444 input_method_context_key(context, serial, time, key, state);
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +0100445 return;
446 }
447
448 if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
449 return;
450
451 input_method_context_commit_string(keyboard->context,
452 text,
453 strlen(text));
454}
455
456int
457main(int argc, char *argv[])
458{
459 struct simple_im simple_im;
460
461 memset(&simple_im, 0, sizeof(simple_im));
462
463 simple_im.display = display_create(argc, argv);
464 if (simple_im.display == NULL) {
465 fprintf(stderr, "failed to create display: %m\n");
466 return -1;
467 }
468
Kristian Høgsberg8c036162012-11-27 13:47:16 -0500469 simple_im.xkb_context = xkb_context_new(0);
470 if (simple_im.xkb_context == NULL) {
471 fprintf(stderr, "Failed to create XKB context\n");
472 return -1;
473 }
474
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +0100475 simple_im.context = NULL;
Kristian Høgsberg8c036162012-11-27 13:47:16 -0500476 simple_im.keyboard_input = keyboard_input_create(simple_im.xkb_context);
Jan Arne Petersene9fba2b2012-11-18 19:06:50 +0100477 keyboard_input_set_user_data(simple_im.keyboard_input, &simple_im);
478 keyboard_input_set_key_handler(simple_im.keyboard_input, simple_im_key_handler);
479
480 display_set_user_data(simple_im.display, &simple_im);
481 display_set_global_handler(simple_im.display, global_handler);
482
483 display_run(simple_im.display);
484
485 return 0;
486}