uint32_t KeyboardEngine::processCompose(uint32_t keyval, uint32_t state) {
// FIXME, should we check if state is 0?
FCITX_UNUSED(state);
if (!m_xkbComposeState) {
return 0;
}
enum xkb_compose_feed_result result = xkb_compose_state_feed(m_xkbComposeState.get(), keyval);
if (result == XKB_COMPOSE_FEED_IGNORED) {
return 0;
}
enum xkb_compose_status status = xkb_compose_state_get_status(m_xkbComposeState.get());
if (status == XKB_COMPOSE_NOTHING) {
return 0;
} else if (status == XKB_COMPOSE_COMPOSED) {
char buffer[FCITX_UTF8_MAX_LENGTH + 1] = {'\0', '\0', '\0', '\0', '\0', '\0', '\0'};
int length = xkb_compose_state_get_utf8(m_xkbComposeState.get(), buffer, sizeof(buffer));
xkb_compose_state_reset(m_xkbComposeState.get());
if (length == 0) {
return INVALID_COMPOSE_RESULT;
}
uint32_t c = 0;
fcitx_utf8_get_char(buffer, &c);
return c;
} else if (status == XKB_COMPOSE_CANCELLED) {
xkb_compose_state_reset(m_xkbComposeState.get());
}
return INVALID_COMPOSE_RESULT;
}
static unsigned int keyboard_read_compose(idev_keyboard *k, const xkb_keysym_t **out) {
_cleanup_free_ char *t = NULL;
term_utf8 u8 = { };
char buf[256], *p;
size_t flen = 0;
int i, r;
r = xkb_compose_state_get_utf8(k->xkb_compose, buf, sizeof(buf));
if (r >= (int)sizeof(buf)) {
t = malloc(r + 1);
if (!t)
return 0;
xkb_compose_state_get_utf8(k->xkb_compose, t, r + 1);
p = t;
} else {
p = buf;
}
for (i = 0; i < r; ++i) {
uint32_t *ucs;
size_t len, j;
len = term_utf8_decode(&u8, &ucs, p[i]);
if (len > 0) {
r = keyboard_resize_bufs(k, flen + len);
if (r < 0)
return 0;
for (j = 0; j < len; ++j)
k->compose_res[flen++] = ucs[j];
}
}
*out = k->compose_res;
return flen;
}
static bool handle_key_press(Keyboard *keyboard, xkb_keycode_t keycode, char *password, char **password_cursor) {
xkb_keysym_t keysym = xkb_state_key_get_one_sym(keyboard->state, keycode);
enum xkb_compose_status status = XKB_COMPOSE_NOTHING;
if (xkb_compose_state_feed(keyboard->compose_state, keysym) == XKB_COMPOSE_FEED_ACCEPTED) {
status = xkb_compose_state_get_status(keyboard->compose_state);
if (status == XKB_COMPOSE_COMPOSED) {
keysym = xkb_compose_state_get_one_sym(keyboard->compose_state);
} else if (status == XKB_COMPOSE_COMPOSING || status == XKB_COMPOSE_CANCELLED) {
return false;
}
}
if (keysym == XKB_KEY_Return) {
return true;
} else if (keysym == XKB_KEY_Escape) {
running = false;
return false;
} else if (keysym == XKB_KEY_BackSpace) {
if (*password_cursor != &password[0]) {
while ((*(--(*password_cursor)) & 0xc0) == 0x80);
**password_cursor = '\0';
}
return false;
}
char buffer[16] = { '\0' };
int len;
if (status == XKB_COMPOSE_COMPOSED) {
len = xkb_compose_state_get_utf8(keyboard->compose_state, buffer, sizeof(buffer));
} else {
len = xkb_state_key_get_utf8(keyboard->state, keycode, buffer, sizeof(buffer));
}
if (len < 1) {
return false;
}
memcpy(*password_cursor, buffer, len + 1);
*password_cursor += len;
return false;
}
/*
* Handle key presses. Fixes state, then looks up the key symbol for the
* given keycode, then looks up the key symbol (as UCS-2), converts it to
* UTF-8 and stores it in the password array.
*
*/
static void handle_key_press(xcb_key_press_event_t *event) {
xkb_keysym_t ksym;
char buffer[128];
int n;
bool ctrl;
bool composed = false;
ksym = xkb_state_key_get_one_sym(xkb_state, event->detail);
ctrl = xkb_state_mod_name_is_active(xkb_state, XKB_MOD_NAME_CTRL, XKB_STATE_MODS_DEPRESSED);
/* The buffer will be null-terminated, so n >= 2 for 1 actual character. */
memset(buffer, '\0', sizeof(buffer));
if (xkb_compose_state && xkb_compose_state_feed(xkb_compose_state, ksym) == XKB_COMPOSE_FEED_ACCEPTED) {
switch (xkb_compose_state_get_status(xkb_compose_state)) {
case XKB_COMPOSE_NOTHING:
break;
case XKB_COMPOSE_COMPOSING:
return;
case XKB_COMPOSE_COMPOSED:
/* xkb_compose_state_get_utf8 doesn't include the terminating byte in the return value
* as xkb_keysym_to_utf8 does. Adding one makes the variable n consistent. */
n = xkb_compose_state_get_utf8(xkb_compose_state, buffer, sizeof(buffer)) + 1;
ksym = xkb_compose_state_get_one_sym(xkb_compose_state);
composed = true;
break;
case XKB_COMPOSE_CANCELLED:
xkb_compose_state_reset(xkb_compose_state);
return;
}
}
if (!composed) {
n = xkb_keysym_to_utf8(ksym, buffer, sizeof(buffer));
}
switch (ksym) {
case XKB_KEY_Return:
case XKB_KEY_KP_Enter:
case XKB_KEY_XF86ScreenSaver:
if (pam_state == STATE_PAM_WRONG)
return;
if (skip_without_validation()) {
clear_input();
return;
}
password[input_position] = '\0';
unlock_state = STATE_KEY_PRESSED;
redraw_screen();
input_done();
skip_repeated_empty_password = true;
return;
default:
skip_repeated_empty_password = false;
}
switch (ksym) {
case XKB_KEY_u:
if (ctrl) {
DEBUG("C-u pressed\n");
clear_input();
return;
}
break;
case XKB_KEY_Escape:
clear_input();
return;
case XKB_KEY_BackSpace:
if (input_position == 0)
return;
/* decrement input_position to point to the previous glyph */
u8_dec(password, &input_position);
password[input_position] = '\0';
/* Hide the unlock indicator after a bit if the password buffer is
* empty. */
START_TIMER(clear_indicator_timeout, 1.0, clear_indicator_cb);
unlock_state = STATE_BACKSPACE_ACTIVE;
redraw_screen();
unlock_state = STATE_KEY_PRESSED;
return;
}
if ((input_position + 8) >= sizeof(password))
return;
#if 0
/* FIXME: handle all of these? */
printf("is_keypad_key = %d\n", xcb_is_keypad_key(sym));
printf("is_private_keypad_key = %d\n", xcb_is_private_keypad_key(sym));
printf("xcb_is_cursor_key = %d\n", xcb_is_cursor_key(sym));
printf("xcb_is_pf_key = %d\n", xcb_is_pf_key(sym));
printf("xcb_is_function_key = %d\n", xcb_is_function_key(sym));
printf("xcb_is_misc_function_key = %d\n", xcb_is_misc_function_key(sym));
printf("xcb_is_modifier_key = %d\n", xcb_is_modifier_key(sym));
#endif
if (n < 2)
return;
/* store it in the password array as UTF-8 */
memcpy(password + input_position, buffer, n - 1);
input_position += n - 1;
DEBUG("current password = %.*s\n", input_position, password);
if (unlock_indicator) {
unlock_state = STATE_KEY_ACTIVE;
redraw_screen();
unlock_state = STATE_KEY_PRESSED;
struct ev_timer *timeout = NULL;
START_TIMER(timeout, TSTAMP_N_SECS(0.25), redraw_timeout);
STOP_TIMER(clear_indicator_timeout);
}
START_TIMER(discard_passwd_timeout, TSTAMP_N_MINS(3), discard_passwd_cb);
}
