blob: 8d94870434fb49f84e7f027003e7a4529a62bc27 [file] [log] [blame]
Jan Arne Petersencba9e472012-06-21 21:52:19 +02001/*
2 * Copyright © 2012 Openismus GmbH
Jan Arne Petersen620cd622012-09-09 23:08:32 +02003 * Copyright © 2012 Intel Corporation
Jan Arne Petersencba9e472012-06-21 21:52:19 +02004 *
5 * Permission to use, copy, modify, distribute, and sell this software and
6 * its documentation for any purpose is hereby granted without fee, provided
7 * that the above copyright notice appear in all copies and that both that
8 * copyright notice and this permission notice appear in supporting
9 * documentation, and that the name of the copyright holders not be used in
10 * advertising or publicity pertaining to distribution of the software
11 * without specific, written prior permission. The copyright holders make
12 * no representations about the suitability of this software for any
13 * purpose. It is provided "as is" without express or implied warranty.
14 *
15 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
16 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
17 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
18 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
19 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
20 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
21 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22 */
23
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27
28#include <linux/input.h>
29#include <cairo.h>
30
31#include "window.h"
Jan Arne Petersen30b66ef2012-09-09 23:08:41 +020032#include "input-method-client-protocol.h"
Jan Arne Petersene475f292013-01-16 21:26:44 +010033#include "text-client-protocol.h"
Jan Arne Petersene475f292013-01-16 21:26:44 +010034
Jan Arne Petersencba9e472012-06-21 21:52:19 +020035struct virtual_keyboard {
36 struct input_panel *input_panel;
37 struct input_method *input_method;
Jan Arne Petersen620cd622012-09-09 23:08:32 +020038 struct input_method_context *context;
Jan Arne Petersencba9e472012-06-21 21:52:19 +020039 struct display *display;
Jan Arne Petersen43f4aa82012-09-09 23:08:43 +020040 char *preedit_string;
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +010041 uint32_t preedit_style;
Jan Arne Petersencd997062012-11-18 19:06:44 +010042 struct {
43 xkb_mod_mask_t shift_mask;
44 } keysym;
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +010045 uint32_t serial;
Jan Arne Petersene475f292013-01-16 21:26:44 +010046 uint32_t content_hint;
47 uint32_t content_purpose;
Jan Arne Petersen0eabcaa2013-01-31 15:52:20 +010048 char *surrounding_text;
Jan Arne Petersene475f292013-01-16 21:26:44 +010049 struct window *window;
50 struct widget *widget;
Jan Arne Petersencba9e472012-06-21 21:52:19 +020051};
52
Jan Arne Petersen892f1c32012-09-09 23:08:42 +020053enum key_type {
54 keytype_default,
55 keytype_backspace,
56 keytype_enter,
57 keytype_space,
58 keytype_switch,
59 keytype_symbols,
Jan Arne Petersen8aba11d2012-09-17 15:28:07 +020060 keytype_tab,
61 keytype_arrow_up,
62 keytype_arrow_left,
63 keytype_arrow_right,
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +010064 keytype_arrow_down,
65 keytype_style
Jan Arne Petersen892f1c32012-09-09 23:08:42 +020066};
67
68struct key {
69 enum key_type key_type;
70
71 char *label;
72 char *alt;
73
74 unsigned int width;
75};
76
Jan Arne Petersene475f292013-01-16 21:26:44 +010077struct layout {
78 const struct key *keys;
79 uint32_t count;
80
81 uint32_t columns;
82 uint32_t rows;
83};
84
85static const struct key normal_keys[] = {
Jan Arne Petersen892f1c32012-09-09 23:08:42 +020086 { keytype_default, "q", "Q", 1},
87 { keytype_default, "w", "W", 1},
88 { keytype_default, "e", "E", 1},
89 { keytype_default, "r", "R", 1},
90 { keytype_default, "t", "T", 1},
91 { keytype_default, "y", "Y", 1},
92 { keytype_default, "u", "U", 1},
93 { keytype_default, "i", "I", 1},
94 { keytype_default, "o", "O", 1},
95 { keytype_default, "p", "P", 1},
96 { keytype_backspace, "<--", "<--", 2},
97
98 { keytype_tab, "->|", "->|", 1},
99 { keytype_default, "a", "A", 1},
100 { keytype_default, "s", "S", 1},
101 { keytype_default, "d", "D", 1},
102 { keytype_default, "f", "F", 1},
103 { keytype_default, "g", "G", 1},
104 { keytype_default, "h", "H", 1},
105 { keytype_default, "j", "J", 1},
106 { keytype_default, "k", "K", 1},
107 { keytype_default, "l", "L", 1},
108 { keytype_enter, "Enter", "Enter", 2},
109
110 { keytype_switch, "ABC", "abc", 2},
111 { keytype_default, "z", "Z", 1},
112 { keytype_default, "x", "X", 1},
113 { keytype_default, "c", "C", 1},
114 { keytype_default, "v", "V", 1},
115 { keytype_default, "b", "B", 1},
116 { keytype_default, "n", "N", 1},
117 { keytype_default, "m", "M", 1},
118 { keytype_default, ",", ",", 1},
119 { keytype_default, ".", ".", 1},
120 { keytype_switch, "ABC", "abc", 1},
121
Jan Arne Petersen8aba11d2012-09-17 15:28:07 +0200122 { keytype_symbols, "?123", "?123", 1},
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100123 { keytype_space, "", "", 5},
Jan Arne Petersen8aba11d2012-09-17 15:28:07 +0200124 { keytype_arrow_up, "/\\", "/\\", 1},
125 { keytype_arrow_left, "<", "<", 1},
126 { keytype_arrow_right, ">", ">", 1},
127 { keytype_arrow_down, "\\/", "\\/", 1},
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100128 { keytype_style, "", "", 2}
129};
130
Jan Arne Petersene475f292013-01-16 21:26:44 +0100131static const struct key numeric_keys[] = {
132 { keytype_default, "1", "1", 1},
133 { keytype_default, "2", "2", 1},
134 { keytype_default, "3", "3", 1},
135 { keytype_default, "4", "4", 1},
136 { keytype_default, "5", "5", 1},
137 { keytype_default, "6", "6", 1},
138 { keytype_default, "7", "7", 1},
139 { keytype_default, "8", "8", 1},
140 { keytype_default, "9", "9", 1},
141 { keytype_default, "0", "0", 1},
142 { keytype_backspace, "<--", "<--", 2},
143
144 { keytype_space, "", "", 4},
145 { keytype_enter, "Enter", "Enter", 2},
146 { keytype_arrow_up, "/\\", "/\\", 1},
147 { keytype_arrow_left, "<", "<", 1},
148 { keytype_arrow_right, ">", ">", 1},
149 { keytype_arrow_down, "\\/", "\\/", 1},
150 { keytype_style, "", "", 2}
151};
152
153static const struct layout normal_layout = {
154 normal_keys,
155 sizeof(normal_keys) / sizeof(*normal_keys),
156 12,
157 4
158};
159
160static const struct layout numeric_layout = {
161 numeric_keys,
162 sizeof(numeric_keys) / sizeof(*numeric_keys),
163 12,
164 2
165};
166
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100167static const char *style_labels[] = {
168 "none",
169 "default",
170 "active",
171 "inactive",
172 "highlight",
173 "underline",
174 "selection",
175 "incorrect"
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200176};
177
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200178static const double key_width = 60;
179static const double key_height = 50;
180
181enum keyboard_state {
182 keyboardstate_default,
183 keyboardstate_uppercase
184};
185
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200186struct keyboard {
187 struct virtual_keyboard *keyboard;
188 struct window *window;
189 struct widget *widget;
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200190
191 enum keyboard_state state;
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200192};
193
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100194static const char *
195label_from_key(struct keyboard *keyboard,
196 const struct key *key)
197{
198 if (key->key_type == keytype_style)
199 return style_labels[keyboard->keyboard->preedit_style];
200
201 if (keyboard->state == keyboardstate_default)
202 return key->label;
203 else
204 return key->alt;
205}
206
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200207static void
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100208draw_key(struct keyboard *keyboard,
209 const struct key *key,
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200210 cairo_t *cr,
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200211 unsigned int row,
212 unsigned int col)
213{
214 const char *label;
215 cairo_text_extents_t extents;
216
217 cairo_save(cr);
218 cairo_rectangle(cr,
219 col * key_width, row * key_height,
220 key->width * key_width, key_height);
221 cairo_clip(cr);
222
223 /* Paint frame */
224 cairo_rectangle(cr,
225 col * key_width, row * key_height,
226 key->width * key_width, key_height);
227 cairo_set_line_width(cr, 3);
228 cairo_stroke(cr);
229
230 /* Paint text */
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100231 label = label_from_key(keyboard, key);
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200232 cairo_text_extents(cr, label, &extents);
233
234 cairo_translate(cr,
235 col * key_width,
236 row * key_height);
237 cairo_translate(cr,
238 (key->width * key_width - extents.width) / 2,
239 (key_height - extents.y_bearing) / 2);
240 cairo_show_text(cr, label);
241
242 cairo_restore(cr);
243}
244
Jan Arne Petersene475f292013-01-16 21:26:44 +0100245static const struct layout *
246get_current_layout(struct virtual_keyboard *keyboard)
247{
248 switch (keyboard->content_purpose) {
249 case TEXT_MODEL_CONTENT_PURPOSE_DIGITS:
250 case TEXT_MODEL_CONTENT_PURPOSE_NUMBER:
251 return &numeric_layout;
252 default:
253 return &normal_layout;
254 }
255}
256
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200257static void
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200258redraw_handler(struct widget *widget, void *data)
259{
260 struct keyboard *keyboard = data;
261 cairo_surface_t *surface;
262 struct rectangle allocation;
263 cairo_t *cr;
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200264 unsigned int i;
265 unsigned int row = 0, col = 0;
Jan Arne Petersene475f292013-01-16 21:26:44 +0100266 const struct layout *layout;
267
268 layout = get_current_layout(keyboard->keyboard);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200269
270 surface = window_get_surface(keyboard->window);
271 widget_get_allocation(keyboard->widget, &allocation);
272
273 cr = cairo_create(surface);
274 cairo_rectangle(cr, allocation.x, allocation.y, allocation.width, allocation.height);
275 cairo_clip(cr);
276
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200277 cairo_select_font_face(cr, "sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
278 cairo_set_font_size(cr, 16);
279
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200280 cairo_translate(cr, allocation.x, allocation.y);
281
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200282 cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200283 cairo_set_source_rgba(cr, 1, 1, 1, 0.75);
Jan Arne Petersene475f292013-01-16 21:26:44 +0100284 cairo_rectangle(cr, 0, 0, layout->columns * key_width, layout->rows * key_height);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200285 cairo_paint(cr);
286
287 cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
288
Jan Arne Petersene475f292013-01-16 21:26:44 +0100289 for (i = 0; i < layout->count; ++i) {
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200290 cairo_set_source_rgb(cr, 0, 0, 0);
Jan Arne Petersene475f292013-01-16 21:26:44 +0100291 draw_key(keyboard, &layout->keys[i], cr, row, col);
292 col += layout->keys[i].width;
293 if (col >= layout->columns) {
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200294 row += 1;
295 col = 0;
296 }
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200297 }
298
299 cairo_destroy(cr);
300 cairo_surface_destroy(surface);
301}
302
303static void
304resize_handler(struct widget *widget,
305 int32_t width, int32_t height, void *data)
306{
307 /* struct keyboard *keyboard = data; */
308}
309
310static void
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100311virtual_keyboard_commit_preedit(struct virtual_keyboard *keyboard)
312{
313 if (!keyboard->preedit_string ||
314 strlen(keyboard->preedit_string) == 0)
315 return;
316
Jan Arne Petersen46535312013-01-16 21:26:38 +0100317 input_method_context_preedit_cursor(keyboard->context,
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100318 keyboard->serial,
Jan Arne Petersen46535312013-01-16 21:26:38 +0100319 0);
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100320 input_method_context_preedit_string(keyboard->context,
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100321 keyboard->serial,
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100322 "",
Jan Arne Petersen46535312013-01-16 21:26:38 +0100323 "");
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100324 input_method_context_commit_string(keyboard->context,
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100325 keyboard->serial,
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100326 keyboard->preedit_string,
327 strlen(keyboard->preedit_string));
328 free(keyboard->preedit_string);
329 keyboard->preedit_string = strdup("");
330}
331
332static void
Jan Arne Petersen2dc3b3f2013-01-16 21:26:48 +0100333virtual_keyboard_send_preedit(struct virtual_keyboard *keyboard,
334 int32_t cursor)
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100335{
Jan Arne Petersen2dc3b3f2013-01-16 21:26:48 +0100336 uint32_t index = strlen(keyboard->preedit_string);
337
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100338 if (keyboard->preedit_style)
339 input_method_context_preedit_styling(keyboard->context,
340 keyboard->serial,
341 0,
342 strlen(keyboard->preedit_string),
343 keyboard->preedit_style);
Jan Arne Petersen2dc3b3f2013-01-16 21:26:48 +0100344 if (cursor > 0)
345 index = cursor;
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100346 input_method_context_preedit_cursor(keyboard->context,
347 keyboard->serial,
Jan Arne Petersen2dc3b3f2013-01-16 21:26:48 +0100348 index);
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100349 input_method_context_preedit_string(keyboard->context,
350 keyboard->serial,
351 keyboard->preedit_string,
352 keyboard->preedit_string);
353}
354
355static void
Jan Arne Petersencd997062012-11-18 19:06:44 +0100356keyboard_handle_key(struct keyboard *keyboard, uint32_t time, const struct key *key, struct input *input, enum wl_pointer_button_state state)
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200357{
358 const char *label = keyboard->state == keyboardstate_default ? key->label : key->alt;
Jan Arne Petersencd997062012-11-18 19:06:44 +0100359 xkb_mod_mask_t mod_mask = keyboard->state == keyboardstate_default ? 0 : keyboard->keyboard->keysym.shift_mask;
360 uint32_t key_state = (state == WL_POINTER_BUTTON_STATE_PRESSED) ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED;
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200361
362 switch (key->key_type) {
363 case keytype_default:
Jan Arne Petersencd997062012-11-18 19:06:44 +0100364 if (state != WL_POINTER_BUTTON_STATE_PRESSED)
365 break;
366
Jan Arne Petersen43f4aa82012-09-09 23:08:43 +0200367 keyboard->keyboard->preedit_string = strcat(keyboard->keyboard->preedit_string,
368 label);
Jan Arne Petersen2dc3b3f2013-01-16 21:26:48 +0100369 virtual_keyboard_send_preedit(keyboard->keyboard, -1);
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200370 break;
371 case keytype_backspace:
Jan Arne Petersencd997062012-11-18 19:06:44 +0100372 if (state != WL_POINTER_BUTTON_STATE_PRESSED)
373 break;
374
Jan Arne Petersene202bae2012-09-09 23:08:44 +0200375 if (strlen(keyboard->keyboard->preedit_string) == 0) {
376 input_method_context_delete_surrounding_text(keyboard->keyboard->context,
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100377 keyboard->keyboard->serial,
Jan Arne Petersene202bae2012-09-09 23:08:44 +0200378 -1, 1);
Jan Arne Petersen633c83d2012-09-17 15:28:08 +0200379 } else {
380 keyboard->keyboard->preedit_string[strlen(keyboard->keyboard->preedit_string) - 1] = '\0';
Jan Arne Petersen2dc3b3f2013-01-16 21:26:48 +0100381 virtual_keyboard_send_preedit(keyboard->keyboard, -1);
Jan Arne Petersene202bae2012-09-09 23:08:44 +0200382 }
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200383 break;
384 case keytype_enter:
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100385 virtual_keyboard_commit_preedit(keyboard->keyboard);
Jan Arne Petersend9be93b2012-11-18 19:06:43 +0100386 input_method_context_keysym(keyboard->keyboard->context,
387 display_get_serial(keyboard->keyboard->display),
388 time,
Jan Arne Petersencd997062012-11-18 19:06:44 +0100389 XKB_KEY_Return, key_state, mod_mask);
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200390 break;
391 case keytype_space:
Jan Arne Petersencd997062012-11-18 19:06:44 +0100392 if (state != WL_POINTER_BUTTON_STATE_PRESSED)
393 break;
Jan Arne Petersen43f4aa82012-09-09 23:08:43 +0200394 keyboard->keyboard->preedit_string = strcat(keyboard->keyboard->preedit_string,
395 " ");
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100396 virtual_keyboard_commit_preedit(keyboard->keyboard);
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200397 break;
398 case keytype_switch:
Jan Arne Petersencd997062012-11-18 19:06:44 +0100399 if (state != WL_POINTER_BUTTON_STATE_PRESSED)
400 break;
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200401 if (keyboard->state == keyboardstate_default)
402 keyboard->state = keyboardstate_uppercase;
403 else
404 keyboard->state = keyboardstate_default;
405 break;
406 case keytype_symbols:
Jan Arne Petersencd997062012-11-18 19:06:44 +0100407 if (state != WL_POINTER_BUTTON_STATE_PRESSED)
408 break;
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200409 break;
410 case keytype_tab:
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100411 virtual_keyboard_commit_preedit(keyboard->keyboard);
Jan Arne Petersend9be93b2012-11-18 19:06:43 +0100412 input_method_context_keysym(keyboard->keyboard->context,
413 display_get_serial(keyboard->keyboard->display),
414 time,
Jan Arne Petersencd997062012-11-18 19:06:44 +0100415 XKB_KEY_Tab, key_state, mod_mask);
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200416 break;
Jan Arne Petersen8aba11d2012-09-17 15:28:07 +0200417 case keytype_arrow_up:
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100418 virtual_keyboard_commit_preedit(keyboard->keyboard);
Jan Arne Petersend9be93b2012-11-18 19:06:43 +0100419 input_method_context_keysym(keyboard->keyboard->context,
420 display_get_serial(keyboard->keyboard->display),
421 time,
Jan Arne Petersencd997062012-11-18 19:06:44 +0100422 XKB_KEY_Up, key_state, mod_mask);
Jan Arne Petersen8aba11d2012-09-17 15:28:07 +0200423 break;
424 case keytype_arrow_left:
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100425 virtual_keyboard_commit_preedit(keyboard->keyboard);
Jan Arne Petersend9be93b2012-11-18 19:06:43 +0100426 input_method_context_keysym(keyboard->keyboard->context,
427 display_get_serial(keyboard->keyboard->display),
428 time,
Jan Arne Petersencd997062012-11-18 19:06:44 +0100429 XKB_KEY_Left, key_state, mod_mask);
Jan Arne Petersen8aba11d2012-09-17 15:28:07 +0200430 break;
431 case keytype_arrow_right:
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100432 virtual_keyboard_commit_preedit(keyboard->keyboard);
Jan Arne Petersend9be93b2012-11-18 19:06:43 +0100433 input_method_context_keysym(keyboard->keyboard->context,
434 display_get_serial(keyboard->keyboard->display),
435 time,
Jan Arne Petersencd997062012-11-18 19:06:44 +0100436 XKB_KEY_Right, key_state, mod_mask);
Jan Arne Petersen8aba11d2012-09-17 15:28:07 +0200437 break;
438 case keytype_arrow_down:
Jan Arne Petersen5ec05fb2012-11-05 03:26:42 +0100439 virtual_keyboard_commit_preedit(keyboard->keyboard);
Jan Arne Petersend9be93b2012-11-18 19:06:43 +0100440 input_method_context_keysym(keyboard->keyboard->context,
441 display_get_serial(keyboard->keyboard->display),
442 time,
Jan Arne Petersencd997062012-11-18 19:06:44 +0100443 XKB_KEY_Down, key_state, mod_mask);
Jan Arne Petersen8aba11d2012-09-17 15:28:07 +0200444 break;
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100445 case keytype_style:
446 if (state != WL_POINTER_BUTTON_STATE_PRESSED)
447 break;
448 keyboard->keyboard->preedit_style = (keyboard->keyboard->preedit_style + 1) % 8; /* TODO */
Jan Arne Petersen2dc3b3f2013-01-16 21:26:48 +0100449 virtual_keyboard_send_preedit(keyboard->keyboard, -1);
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100450 break;
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200451 }
452}
453
454static void
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200455button_handler(struct widget *widget,
456 struct input *input, uint32_t time,
457 uint32_t button,
458 enum wl_pointer_button_state state, void *data)
459{
460 struct keyboard *keyboard = data;
461 struct rectangle allocation;
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200462 int32_t x, y;
463 int row, col;
464 unsigned int i;
Jan Arne Petersene475f292013-01-16 21:26:44 +0100465 const struct layout *layout;
466
467 layout = get_current_layout(keyboard->keyboard);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200468
Jan Arne Petersencd997062012-11-18 19:06:44 +0100469 if (button != BTN_LEFT) {
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200470 return;
471 }
472
473 input_get_position(input, &x, &y);
474
475 widget_get_allocation(keyboard->widget, &allocation);
476 x -= allocation.x;
477 y -= allocation.y;
478
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200479 row = y / key_height;
Jan Arne Petersene475f292013-01-16 21:26:44 +0100480 col = x / key_width + row * layout->columns;
481 for (i = 0; i < layout->count; ++i) {
482 col -= layout->keys[i].width;
Rob Bradford053fe762012-10-09 18:44:34 +0100483 if (col < 0) {
Jan Arne Petersene475f292013-01-16 21:26:44 +0100484 keyboard_handle_key(keyboard, time, &layout->keys[i], input, state);
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200485 break;
Rob Bradford053fe762012-10-09 18:44:34 +0100486 }
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200487 }
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200488
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200489 widget_schedule_redraw(widget);
490}
491
492static void
Jan Arne Petersencb08f4d2012-09-09 23:08:40 +0200493input_method_context_surrounding_text(void *data,
494 struct input_method_context *context,
495 const char *text,
496 uint32_t cursor,
497 uint32_t anchor)
498{
Jan Arne Petersene475f292013-01-16 21:26:44 +0100499 struct virtual_keyboard *keyboard = data;
Jan Arne Petersene475f292013-01-16 21:26:44 +0100500
Jan Arne Petersen0eabcaa2013-01-31 15:52:20 +0100501 free(keyboard->surrounding_text);
502 keyboard->surrounding_text = strdup(text);
Jan Arne Petersencb08f4d2012-09-09 23:08:40 +0200503}
504
Jan Arne Petersenc1e481e2012-09-09 23:08:46 +0200505static void
506input_method_context_reset(void *data,
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100507 struct input_method_context *context,
508 uint32_t serial)
Jan Arne Petersenc1e481e2012-09-09 23:08:46 +0200509{
510 struct virtual_keyboard *keyboard = data;
511
512 fprintf(stderr, "Reset pre-edit buffer\n");
513
514 if (strlen(keyboard->preedit_string)) {
Jan Arne Petersen46535312013-01-16 21:26:38 +0100515 input_method_context_preedit_cursor(context,
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100516 serial,
Jan Arne Petersen46535312013-01-16 21:26:38 +0100517 0);
Jan Arne Petersenc1e481e2012-09-09 23:08:46 +0200518 input_method_context_preedit_string(context,
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100519 serial,
Jan Arne Petersenc1e481e2012-09-09 23:08:46 +0200520 "",
Jan Arne Petersen46535312013-01-16 21:26:38 +0100521 "");
Jan Arne Petersenc1e481e2012-09-09 23:08:46 +0200522 free(keyboard->preedit_string);
523 keyboard->preedit_string = strdup("");
524 }
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100525
526 keyboard->serial = serial;
Jan Arne Petersenc1e481e2012-09-09 23:08:46 +0200527}
528
Jan Arne Petersene475f292013-01-16 21:26:44 +0100529static void
530input_method_context_content_type(void *data,
531 struct input_method_context *context,
532 uint32_t hint,
533 uint32_t purpose)
534{
535 struct virtual_keyboard *keyboard = data;
536
537 keyboard->content_hint = hint;
538 keyboard->content_purpose = purpose;
539}
540
Jan Arne Petersen2dc3b3f2013-01-16 21:26:48 +0100541static void
542input_method_context_invoke_action(void *data,
543 struct input_method_context *context,
544 uint32_t button,
545 uint32_t index)
546{
547 struct virtual_keyboard *keyboard = data;
548
549 if (button != BTN_LEFT)
550 return;
551
552 virtual_keyboard_send_preedit(keyboard, index);
553}
554
Jan Arne Petersen0eabcaa2013-01-31 15:52:20 +0100555static void
556input_method_context_commit(void *data,
557 struct input_method_context *context)
558{
559 struct virtual_keyboard *keyboard = data;
560 const struct layout *layout;
561
562 layout = get_current_layout(keyboard);
563
564 if (keyboard->surrounding_text)
565 fprintf(stderr, "Surrounding text updated: %s\n", keyboard->surrounding_text);
566
567 window_schedule_resize(keyboard->window,
568 layout->columns * key_width,
569 layout->rows * key_height);
570
571 widget_schedule_redraw(keyboard->widget);
572}
573
Jan Arne Petersencb08f4d2012-09-09 23:08:40 +0200574static const struct input_method_context_listener input_method_context_listener = {
575 input_method_context_surrounding_text,
Jan Arne Petersene475f292013-01-16 21:26:44 +0100576 input_method_context_reset,
Jan Arne Petersen2dc3b3f2013-01-16 21:26:48 +0100577 input_method_context_content_type,
Jan Arne Petersen0eabcaa2013-01-31 15:52:20 +0100578 input_method_context_invoke_action,
579 input_method_context_commit
Jan Arne Petersencb08f4d2012-09-09 23:08:40 +0200580};
581
582static void
Jan Arne Petersen620cd622012-09-09 23:08:32 +0200583input_method_activate(void *data,
584 struct input_method *input_method,
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100585 struct input_method_context *context,
586 uint32_t serial)
Jan Arne Petersen620cd622012-09-09 23:08:32 +0200587{
588 struct virtual_keyboard *keyboard = data;
Jan Arne Petersencd997062012-11-18 19:06:44 +0100589 struct wl_array modifiers_map;
Jan Arne Petersen620cd622012-09-09 23:08:32 +0200590
591 if (keyboard->context)
592 input_method_context_destroy(keyboard->context);
593
Jan Arne Petersen43f4aa82012-09-09 23:08:43 +0200594 if (keyboard->preedit_string)
595 free(keyboard->preedit_string);
596
597 keyboard->preedit_string = strdup("");
Jan Arne Petersenc7d2a982013-01-16 21:26:39 +0100598 keyboard->serial = serial;
Jan Arne Petersen43f4aa82012-09-09 23:08:43 +0200599
Jan Arne Petersen620cd622012-09-09 23:08:32 +0200600 keyboard->context = context;
Jan Arne Petersencb08f4d2012-09-09 23:08:40 +0200601 input_method_context_add_listener(context,
602 &input_method_context_listener,
603 keyboard);
Jan Arne Petersencd997062012-11-18 19:06:44 +0100604
605 wl_array_init(&modifiers_map);
606 keysym_modifiers_add(&modifiers_map, "Shift");
607 keysym_modifiers_add(&modifiers_map, "Control");
608 keysym_modifiers_add(&modifiers_map, "Mod1");
609 input_method_context_modifiers_map(context, &modifiers_map);
610 keyboard->keysym.shift_mask = keysym_modifiers_get_mask(&modifiers_map, "Shift");
611 wl_array_release(&modifiers_map);
Jan Arne Petersen620cd622012-09-09 23:08:32 +0200612}
613
614static void
615input_method_deactivate(void *data,
616 struct input_method *input_method,
617 struct input_method_context *context)
618{
619 struct virtual_keyboard *keyboard = data;
620
621 if (!keyboard->context)
622 return;
623
624 input_method_context_destroy(keyboard->context);
625 keyboard->context = NULL;
626}
627
628static const struct input_method_listener input_method_listener = {
629 input_method_activate,
630 input_method_deactivate
631};
632
633static void
Kristian Høgsbergfa80e112012-10-10 21:34:26 -0400634global_handler(struct display *display, uint32_t name,
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200635 const char *interface, uint32_t version, void *data)
636{
637 struct virtual_keyboard *keyboard = data;
638
639 if (!strcmp(interface, "input_panel")) {
Kristian Høgsbergfa80e112012-10-10 21:34:26 -0400640 keyboard->input_panel =
641 display_bind(display, name, &input_panel_interface, 1);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200642 } else if (!strcmp(interface, "input_method")) {
Kristian Høgsbergfa80e112012-10-10 21:34:26 -0400643 keyboard->input_method =
644 display_bind(display, name,
645 &input_method_interface, 1);
Jan Arne Petersen620cd622012-09-09 23:08:32 +0200646 input_method_add_listener(keyboard->input_method, &input_method_listener, keyboard);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200647 }
648}
649
650static void
651keyboard_create(struct output *output, struct virtual_keyboard *virtual_keyboard)
652{
653 struct keyboard *keyboard;
Jan Arne Petersene475f292013-01-16 21:26:44 +0100654 const struct layout *layout;
Jan Arne Petersenffbb20f2013-01-16 21:26:55 +0100655 struct input_panel_surface *ips;
Jan Arne Petersene475f292013-01-16 21:26:44 +0100656
657 layout = get_current_layout(virtual_keyboard);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200658
659 keyboard = malloc(sizeof *keyboard);
660 memset(keyboard, 0, sizeof *keyboard);
661
662 keyboard->keyboard = virtual_keyboard;
Kristian Høgsberg0636ac32012-06-27 10:22:15 -0400663 keyboard->window = window_create_custom(virtual_keyboard->display);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200664 keyboard->widget = window_add_widget(keyboard->window, keyboard);
Jan Arne Petersene475f292013-01-16 21:26:44 +0100665 virtual_keyboard->window = keyboard->window;
666 virtual_keyboard->widget = keyboard->widget;
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200667
668 window_set_title(keyboard->window, "Virtual keyboard");
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200669 window_set_user_data(keyboard->window, keyboard);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200670
671 widget_set_redraw_handler(keyboard->widget, redraw_handler);
672 widget_set_resize_handler(keyboard->widget, resize_handler);
673 widget_set_button_handler(keyboard->widget, button_handler);
674
Jan Arne Petersen892f1c32012-09-09 23:08:42 +0200675 window_schedule_resize(keyboard->window,
Jan Arne Petersene475f292013-01-16 21:26:44 +0100676 layout->columns * key_width,
677 layout->rows * key_height);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200678
Jan Arne Petersenffbb20f2013-01-16 21:26:55 +0100679
680 ips = input_panel_get_input_panel_surface(virtual_keyboard->input_panel,
681 window_get_wl_surface(keyboard->window));
682
683 input_panel_surface_set_toplevel(ips, INPUT_PANEL_SURFACE_POSITION_CENTER_BOTTOM);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200684}
685
686static void
687handle_output_configure(struct output *output, void *data)
688{
689 struct virtual_keyboard *virtual_keyboard = data;
690
691 /* skip existing outputs */
692 if (output_get_user_data(output))
693 return;
694
695 output_set_user_data(output, virtual_keyboard);
696
697 keyboard_create(output, virtual_keyboard);
698}
699
700int
701main(int argc, char *argv[])
702{
703 struct virtual_keyboard virtual_keyboard;
704
Jan Arne Petersen49a3fb32013-01-16 21:26:41 +0100705 memset(&virtual_keyboard, 0, sizeof virtual_keyboard);
706
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200707 virtual_keyboard.display = display_create(argc, argv);
708 if (virtual_keyboard.display == NULL) {
709 fprintf(stderr, "failed to create display: %m\n");
710 return -1;
711 }
712
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200713 display_set_user_data(virtual_keyboard.display, &virtual_keyboard);
Kristian Høgsbergfa80e112012-10-10 21:34:26 -0400714 display_set_global_handler(virtual_keyboard.display, global_handler);
Jan Arne Petersencba9e472012-06-21 21:52:19 +0200715 display_set_output_configure_handler(virtual_keyboard.display, handle_output_configure);
716
717 display_run(virtual_keyboard.display);
718
719 return 0;
720}