path: root/src/input.c

#include "term.h"
#include "unicode/utf8.h"

#include <string.h>

struct seqbuf {
    char *p;
    size_t left;
    bool overflow;
};

static inline void sb_init(struct seqbuf *sb, char *buf, size_t buf_sz)
{
    sb->p = buf;
    sb->left = buf_sz;
    sb->overflow = false;
}

static inline void sb_ch(struct seqbuf *sb, char c)
{
    if (!sb->left) { sb->overflow = true; return; }
    *sb->p++ = c;
    sb->left--;
}

static inline void sb_bytes(struct seqbuf *sb, const char *s, size_t len)
{
    if (sb->overflow || len > sb->left) {
        sb->overflow = true;
        sb->left = 0;
        return;
    }
    memcpy(sb->p, s, len);
    sb->p += len;
    sb->left -= len;
}

static inline void sb_u32(struct seqbuf *sb, uint32_t val)
{
    char tmp[10];
    char *end = tmp + sizeof(tmp);
    char *p = end;
    do {
        *--p = (char)('0' + (val % 10));
        val /= 10;
    } while (val);
    sb_bytes(sb, p, (size_t)(end - p));
}

static inline size_t sb_len(const struct seqbuf *sb, const char *buf)
{
    return (size_t)(sb->p - buf);
}

struct kitty_desc {
    uint32_t code;
    char     final;
};

static const struct kitty_desc kitty_desc[TERM_KEY_COUNT] = {
    [TERM_KEY_RETURN]    = { 13,  'u' },
    [TERM_KEY_BACKSPACE] = { 127, 'u' },
    [TERM_KEY_TAB]       = { 9,   'u' },
    [TERM_KEY_ESCAPE]    = { 27,  'u' },

    [TERM_KEY_UP]        = { 1, 'A' },
    [TERM_KEY_DOWN]      = { 1, 'B' },
    [TERM_KEY_RIGHT]     = { 1, 'C' },
    [TERM_KEY_LEFT]      = { 1, 'D' },
    [TERM_KEY_HOME]      = { 1, 'H' },
    [TERM_KEY_END]       = { 1, 'F' },
    [TERM_KEY_PAGE_UP]   = { 5, '~' },
    [TERM_KEY_PAGE_DOWN] = { 6, '~' },
    [TERM_KEY_INSERT]    = { 2, '~' },
    [TERM_KEY_DELETE]    = { 3, '~' },

    [TERM_KEY_F1]  = { 1,  'P' },
    [TERM_KEY_F2]  = { 1,  'Q' },
    [TERM_KEY_F3]  = { 13, '~' },
    [TERM_KEY_F4]  = { 1,  'S' },
    [TERM_KEY_F5]  = { 15, '~' },
    [TERM_KEY_F6]  = { 17, '~' },
    [TERM_KEY_F7]  = { 18, '~' },
    [TERM_KEY_F8]  = { 19, '~' },
    [TERM_KEY_F9]  = { 20, '~' },
    [TERM_KEY_F10] = { 21, '~' },
    [TERM_KEY_F11] = { 23, '~' },
    [TERM_KEY_F12] = { 24, '~' },
    [TERM_KEY_F13] = { 57376, 'u' },
    [TERM_KEY_F14] = { 57377, 'u' },
    [TERM_KEY_F15] = { 57378, 'u' },
    [TERM_KEY_F16] = { 57379, 'u' },
    [TERM_KEY_F17] = { 57380, 'u' },
    [TERM_KEY_F18] = { 57381, 'u' },
    [TERM_KEY_F19] = { 57382, 'u' },
    [TERM_KEY_F20] = { 57383, 'u' },
    [TERM_KEY_F21] = { 57384, 'u' },
    [TERM_KEY_F22] = { 57385, 'u' },
    [TERM_KEY_F23] = { 57386, 'u' },
    [TERM_KEY_F24] = { 57387, 'u' },
    [TERM_KEY_F25] = { 57388, 'u' },
    [TERM_KEY_F26] = { 57389, 'u' },
    [TERM_KEY_F27] = { 57390, 'u' },
    [TERM_KEY_F28] = { 57391, 'u' },
    [TERM_KEY_F29] = { 57392, 'u' },
    [TERM_KEY_F30] = { 57393, 'u' },
    [TERM_KEY_F31] = { 57394, 'u' },
    [TERM_KEY_F32] = { 57395, 'u' },
    [TERM_KEY_F33] = { 57396, 'u' },
    [TERM_KEY_F34] = { 57397, 'u' },
    [TERM_KEY_F35] = { 57398, 'u' },

    [TERM_KEY_KP_0] = { 57399, 'u' },
    [TERM_KEY_KP_1] = { 57400, 'u' },
    [TERM_KEY_KP_2] = { 57401, 'u' },
    [TERM_KEY_KP_3] = { 57402, 'u' },
    [TERM_KEY_KP_4] = { 57403, 'u' },
    [TERM_KEY_KP_5] = { 57404, 'u' },
    [TERM_KEY_KP_6] = { 57405, 'u' },
    [TERM_KEY_KP_7] = { 57406, 'u' },
    [TERM_KEY_KP_8] = { 57407, 'u' },
    [TERM_KEY_KP_9] = { 57408, 'u' },
    [TERM_KEY_KP_DECIMAL]   = { 57409, 'u' },
    [TERM_KEY_KP_DIVIDE]    = { 57410, 'u' },
    [TERM_KEY_KP_MULTIPLY]  = { 57411, 'u' },
    [TERM_KEY_KP_SUBTRACT]  = { 57412, 'u' },
    [TERM_KEY_KP_ADD]       = { 57413, 'u' },
    [TERM_KEY_KP_ENTER]     = { 57414, 'u' },
    [TERM_KEY_KP_EQUAL]     = { 57415, 'u' },
    [TERM_KEY_KP_SEPARATOR] = { 57416, 'u' },
    [TERM_KEY_KP_LEFT]      = { 57417, 'u' },
    [TERM_KEY_KP_RIGHT]     = { 57418, 'u' },
    [TERM_KEY_KP_UP]        = { 57419, 'u' },
    [TERM_KEY_KP_DOWN]      = { 57420, 'u' },
    [TERM_KEY_KP_PAGE_UP]   = { 57421, 'u' },
    [TERM_KEY_KP_PAGE_DOWN] = { 57422, 'u' },
    [TERM_KEY_KP_HOME]      = { 57423, 'u' },
    [TERM_KEY_KP_END]       = { 57424, 'u' },
    [TERM_KEY_KP_INSERT]    = { 57425, 'u' },
    [TERM_KEY_KP_DELETE]    = { 57426, 'u' },
    [TERM_KEY_KP_BEGIN]     = { 1,     'E' },

    [TERM_KEY_CAPS_LOCK]    = { 57358, 'u' },
    [TERM_KEY_SCROLL_LOCK]  = { 57359, 'u' },
    [TERM_KEY_NUM_LOCK]     = { 57360, 'u' },
    [TERM_KEY_PRINT_SCREEN] = { 57361, 'u' },
    [TERM_KEY_PAUSE]        = { 57362, 'u' },
    [TERM_KEY_MENU]         = { 57363, 'u' },

    [TERM_KEY_MEDIA_PLAY]    = { 57428, 'u' },
    [TERM_KEY_MEDIA_PAUSE]   = { 57429, 'u' },
    [TERM_KEY_MEDIA_STOP]    = { 57432, 'u' },
    [TERM_KEY_MEDIA_FORWARD] = { 57433, 'u' },
    [TERM_KEY_MEDIA_REWIND]  = { 57434, 'u' },
    [TERM_KEY_MEDIA_NEXT]    = { 57435, 'u' },
    [TERM_KEY_MEDIA_PREV]    = { 57436, 'u' },
    [TERM_KEY_MEDIA_RECORD]  = { 57437, 'u' },
    [TERM_KEY_VOLUME_DOWN]   = { 57438, 'u' },
    [TERM_KEY_VOLUME_UP]     = { 57439, 'u' },
    [TERM_KEY_MUTE]          = { 57440, 'u' },

    [TERM_KEY_LSHIFT] = { 57441, 'u' },
    [TERM_KEY_LCTRL]  = { 57442, 'u' },
    [TERM_KEY_LALT]   = { 57443, 'u' },
    [TERM_KEY_LSUPER] = { 57444, 'u' },
    [TERM_KEY_LHYPER] = { 57445, 'u' },
    [TERM_KEY_LMETA]  = { 57446, 'u' },
    [TERM_KEY_RSHIFT] = { 57447, 'u' },
    [TERM_KEY_RCTRL]  = { 57448, 'u' },
    [TERM_KEY_RALT]   = { 57449, 'u' },
    [TERM_KEY_RSUPER] = { 57450, 'u' },
    [TERM_KEY_RHYPER] = { 57451, 'u' },
    [TERM_KEY_RMETA]  = { 57452, 'u' },
    [TERM_KEY_ISO_LEVEL3_SHIFT] = { 57453, 'u' },
    [TERM_KEY_ISO_LEVEL5_SHIFT] = { 57454, 'u' },
};

struct legacy_desc {
    uint8_t tilde;
    char    final;
    bool    app_cursor;
    char    keypad_ss3;
    enum term_key equiv;
};

static const struct legacy_desc legacy_desc[TERM_KEY_COUNT] = {
    [TERM_KEY_UP]        = { .tilde = 0, .final = 'A', .app_cursor = true },
    [TERM_KEY_DOWN]      = { .tilde = 0, .final = 'B', .app_cursor = true },
    [TERM_KEY_RIGHT]     = { .tilde = 0, .final = 'C', .app_cursor = true },
    [TERM_KEY_LEFT]      = { .tilde = 0, .final = 'D', .app_cursor = true },
    [TERM_KEY_HOME]      = { .tilde = 0, .final = 'H', .app_cursor = true },
    [TERM_KEY_END]       = { .tilde = 0, .final = 'F', .app_cursor = true },
    [TERM_KEY_PAGE_UP]   = { .tilde = 5, .final = '~' },
    [TERM_KEY_PAGE_DOWN] = { .tilde = 6, .final = '~' },
    [TERM_KEY_INSERT]    = { .tilde = 2, .final = '~' },
    [TERM_KEY_DELETE]    = { .tilde = 3, .final = '~' },

    [TERM_KEY_F1]  = { .tilde = 0, .final = 'P' },
    [TERM_KEY_F2]  = { .tilde = 0, .final = 'Q' },
    [TERM_KEY_F3]  = { .tilde = 0, .final = 'R' },
    [TERM_KEY_F4]  = { .tilde = 0, .final = 'S' },
    [TERM_KEY_F5]  = { .tilde = 15, .final = '~' },
    [TERM_KEY_F6]  = { .tilde = 17, .final = '~' },
    [TERM_KEY_F7]  = { .tilde = 18, .final = '~' },
    [TERM_KEY_F8]  = { .tilde = 19, .final = '~' },
    [TERM_KEY_F9]  = { .tilde = 20, .final = '~' },
    [TERM_KEY_F10] = { .tilde = 21, .final = '~' },
    [TERM_KEY_F11] = { .tilde = 23, .final = '~' },
    [TERM_KEY_F12] = { .tilde = 24, .final = '~' },

    [TERM_KEY_KP_0] = { .keypad_ss3 = 'p' },
    [TERM_KEY_KP_1] = { .keypad_ss3 = 'q' },
    [TERM_KEY_KP_2] = { .keypad_ss3 = 'r' },
    [TERM_KEY_KP_3] = { .keypad_ss3 = 's' },
    [TERM_KEY_KP_4] = { .keypad_ss3 = 't' },
    [TERM_KEY_KP_5] = { .keypad_ss3 = 'u' },
    [TERM_KEY_KP_6] = { .keypad_ss3 = 'v' },
    [TERM_KEY_KP_7] = { .keypad_ss3 = 'w' },
    [TERM_KEY_KP_8] = { .keypad_ss3 = 'x' },
    [TERM_KEY_KP_9] = { .keypad_ss3 = 'y' },
    [TERM_KEY_KP_DECIMAL]   = { .keypad_ss3 = 'n' },
    [TERM_KEY_KP_DIVIDE]    = { .keypad_ss3 = 'o' },
    [TERM_KEY_KP_MULTIPLY]  = { .keypad_ss3 = 'j' },
    [TERM_KEY_KP_SUBTRACT]  = { .keypad_ss3 = 'm' },
    [TERM_KEY_KP_ADD]       = { .keypad_ss3 = 'k' },
    [TERM_KEY_KP_ENTER]     = { .keypad_ss3 = 'M', .equiv = TERM_KEY_RETURN },
    [TERM_KEY_KP_LEFT]      = { .equiv = TERM_KEY_LEFT },
    [TERM_KEY_KP_RIGHT]     = { .equiv = TERM_KEY_RIGHT },
    [TERM_KEY_KP_UP]        = { .equiv = TERM_KEY_UP },
    [TERM_KEY_KP_DOWN]      = { .equiv = TERM_KEY_DOWN },
    [TERM_KEY_KP_PAGE_UP]   = { .equiv = TERM_KEY_PAGE_UP },
    [TERM_KEY_KP_PAGE_DOWN] = { .equiv = TERM_KEY_PAGE_DOWN },
    [TERM_KEY_KP_HOME]      = { .equiv = TERM_KEY_HOME },
    [TERM_KEY_KP_END]       = { .equiv = TERM_KEY_END },
    [TERM_KEY_KP_INSERT]    = { .equiv = TERM_KEY_INSERT },
    [TERM_KEY_KP_DELETE]    = { .equiv = TERM_KEY_DELETE },
    [TERM_KEY_KP_BEGIN]     = { .tilde = 0, .final = 'E' },
};

enum input_mod_key {
    MOD_KEY_SHIFT = 0,
    MOD_KEY_CTRL,
    MOD_KEY_ALT,
    MOD_KEY_SUPER,
    MOD_KEY_HYPER,
    MOD_KEY_META,
    MOD_KEY_ISO3,
    MOD_KEY_ISO5,
    MOD_KEY_COUNT,
};

struct mod_desc {
    enum input_mod_key group;
    enum term_key      partner;
};

static const struct mod_desc mod_desc[TERM_KEY_COUNT] = {
    [TERM_KEY_LSHIFT] = { MOD_KEY_SHIFT, TERM_KEY_RSHIFT },
    [TERM_KEY_RSHIFT] = { MOD_KEY_SHIFT, TERM_KEY_LSHIFT },
    [TERM_KEY_LCTRL]  = { MOD_KEY_CTRL,  TERM_KEY_RCTRL },
    [TERM_KEY_RCTRL]  = { MOD_KEY_CTRL,  TERM_KEY_LCTRL },
    [TERM_KEY_LALT]   = { MOD_KEY_ALT,   TERM_KEY_RALT },
    [TERM_KEY_RALT]   = { MOD_KEY_ALT,   TERM_KEY_LALT },
    [TERM_KEY_LSUPER] = { MOD_KEY_SUPER, TERM_KEY_RSUPER },
    [TERM_KEY_RSUPER] = { MOD_KEY_SUPER, TERM_KEY_LSUPER },
    [TERM_KEY_LHYPER] = { MOD_KEY_HYPER, TERM_KEY_RHYPER },
    [TERM_KEY_RHYPER] = { MOD_KEY_HYPER, TERM_KEY_LHYPER },
    [TERM_KEY_LMETA]  = { MOD_KEY_META,  TERM_KEY_RMETA },
    [TERM_KEY_RMETA]  = { MOD_KEY_META,  TERM_KEY_LMETA },
    [TERM_KEY_ISO_LEVEL3_SHIFT] = { MOD_KEY_ISO3, TERM_KEY_NONE },
    [TERM_KEY_ISO_LEVEL5_SHIFT] = { MOD_KEY_ISO5, TERM_KEY_NONE },
};

static const unsigned mod_group_input_mod[MOD_KEY_COUNT] = {
    TERM_MOD_SHIFT, TERM_MOD_CTRL, TERM_MOD_ALT,
    TERM_MOD_SUPER, TERM_MOD_HYPER, TERM_MOD_META,
    0, 0,
};

static inline bool key_is_modifier(enum term_key k)
{
    return (unsigned)k < TERM_KEY_COUNT &&
           (mod_desc[k].partner != TERM_KEY_NONE ||
            mod_desc[k].group == MOD_KEY_ISO3 ||
            mod_desc[k].group == MOD_KEY_ISO5);
}

static inline bool key_is_lock(enum term_key k)
{
    return k == TERM_KEY_CAPS_LOCK || k == TERM_KEY_SCROLL_LOCK ||
           k == TERM_KEY_NUM_LOCK;
}

static unsigned effective_mods(const struct term_keyboard_state *s,
                               const struct term_key_event *ev)
{
    unsigned mods = ev->mods;
    if (!key_is_modifier(ev->key)) return mods;

    const struct mod_desc *d = &mod_desc[ev->key];
    if (d->group >= MOD_KEY_ISO3) return mods;

    unsigned bit = mod_group_input_mod[d->group];
    bool other_held = term_keyboard_key_down(s, d->partner);
    if (ev->action != TERM_KEY_RELEASE || other_held) mods |= bit;
    else                                           mods &= ~bit;
    return mods;
}

static unsigned lock_mod_bit(enum term_key key)
{
    if (key == TERM_KEY_CAPS_LOCK) return TERM_MOD_CAPS;
    if (key == TERM_KEY_NUM_LOCK)  return TERM_MOD_NUM;
    return 0;
}

static unsigned toggle_locks(enum term_key key, enum term_key_action action,
                             unsigned mods)
{
    unsigned bit = lock_mod_bit(key);
    if (bit && action == TERM_KEY_PRESS) mods ^= bit;
    return mods;
}

/* Convert logical input modifiers to terminal protocol bits. */
static inline unsigned protocol_modifiers(unsigned mods)
{
    return mods & 0xff;
}

static void format_kitty(struct seqbuf *sb, uint32_t code, char final,
                         unsigned flags, bool functional, uint32_t shifted,
                         uint32_t base, unsigned mods, unsigned event,
                         bool report_text, uint32_t text)
{
    sb_bytes(sb, "\033[", 2);
    if (final != 'u' && final != '~' && code <= 1 && !shifted && !base &&
        !mods && !(flags & TERM_KEYBOARD_EVENT_TYPES) && !report_text) {
        sb_ch(sb, final);
        return;
    }

    sb_u32(sb, code);
    if ((flags & TERM_KEYBOARD_ALTERNATE_KEYS) && !functional) {
        if (shifted) {
            sb_ch(sb, ':');
            sb_u32(sb, shifted);
        }
        if (base) {
            sb_ch(sb, ':');
            if (!shifted) sb_ch(sb, ':');
            sb_u32(sb, base);
        }
    }
    if (mods || (flags & TERM_KEYBOARD_EVENT_TYPES) || report_text) {
        sb_ch(sb, ';');
        sb_u32(sb, mods + 1);
    }
    if ((flags & TERM_KEYBOARD_EVENT_TYPES) && event != 1) {
        sb_ch(sb, ':');
        sb_u32(sb, event);
    }
    if (report_text) {
        sb_ch(sb, ';');
        sb_u32(sb, text);
    }
    sb_ch(sb, final);
}

static bool encode_kitty(const struct term_keyboard_state *s,
                         const struct term_key_event *ev,
                         const struct term_modes *m,
                         struct seqbuf *sb)
{
    unsigned flags = m->keyboard;
    unsigned event = ev->action == TERM_KEY_PRESS ? 1u :
                     ev->action == TERM_KEY_REPEAT ? 2u : 3u;
    if (!flags) return ev->action == TERM_KEY_RELEASE;

    const struct kitty_desc *d = &kitty_desc[ev->key];
    bool functional = d->code != 0;
    char final = functional ? d->final : 'u';
    bool all = (flags & TERM_KEYBOARD_ALL_KEYS) != 0;

    if ((key_is_modifier(ev->key) || key_is_lock(ev->key)) && !all)
        return true;

    unsigned mods = effective_mods(s, ev);
    mods = toggle_locks(ev->key, ev->action, mods);

    bool plain_control = ev->key == TERM_KEY_RETURN || ev->key == TERM_KEY_TAB ||
                         ev->key == TERM_KEY_BACKSPACE;
    if (ev->action == TERM_KEY_RELEASE &&
        (!(flags & TERM_KEYBOARD_EVENT_TYPES) || (!all && plain_control)))
        return true;

    const unsigned command_mods = TERM_MOD_ALT | TERM_MOD_CTRL |
                                  TERM_MOD_SUPER | TERM_MOD_HYPER |
                                  TERM_MOD_META;
    uint32_t text = ev->text;
    bool has_text = text >= 32 && !(text >= 127 && text < 160) &&
                    !(mods & command_mods);
    if (!all && has_text) return ev->action == TERM_KEY_RELEASE;
    if (!all && plain_control && !(protocol_modifiers(mods) & 63))
        return ev->action == TERM_KEY_RELEASE;
    if (!(flags & (TERM_KEYBOARD_DISAMBIGUATE | TERM_KEYBOARD_EVENT_TYPES | TERM_KEYBOARD_ALL_KEYS)))
        return ev->action == TERM_KEY_RELEASE;

    uint32_t code = d->code, shifted = 0, base = 0;
    if (!functional) {
        code = ev->codepoint;
        if (flags & TERM_KEYBOARD_ALTERNATE_KEYS) {
            shifted = (mods & TERM_MOD_SHIFT) ? ev->shifted : 0;
            base = ev->base;
            if (shifted == code) shifted = 0;
            if (base == code) base = 0;
        }
    }
    if (!code) return true;

    bool report_text = all && (flags & TERM_KEYBOARD_ASSOCIATED_TEXT) && has_text &&
                       ev->action != TERM_KEY_RELEASE;
    format_kitty(sb, code, final, flags, functional, shifted, base, protocol_modifiers(mods),
                 event, report_text, text);
    return true;
}

static uint32_t control_base_char(const struct term_key_event *ev)
{
    uint32_t ch = ((ev->mods & TERM_MOD_SHIFT) && ev->shifted)
        ? ev->shifted : ev->codepoint;
    return ch < 0x80 ? ch : 0;
}

static bool encode_legacy(const struct term_key_event *ev,
                          const struct term_modes *m,
                          struct seqbuf *sb)
{
    if (m->app_keypad && (unsigned)ev->keypad < TERM_KEY_COUNT &&
        legacy_desc[ev->keypad].keypad_ss3) {
        sb_bytes(sb, "\033O", 2);
        sb_ch(sb, legacy_desc[ev->keypad].keypad_ss3);
        return true;
    }

    uint32_t ch = control_base_char(ev);
    if ((ev->mods & TERM_MOD_CTRL) && ch) {
        if ((ch >= 'a' && ch <= 'z') || (ch >= '@' && ch <= '_')) {
            sb_ch(sb, (char)(ch & 0x1f));
            return true;
        }
        if (ch == ' ') { sb_ch(sb, 0); return true; }
        if (ch == '-') { sb_ch(sb, 0x1f); return true; }
    }

    unsigned csi = protocol_modifiers(ev->mods) & 63;
    unsigned p = csi + 1;
    bool shift = (ev->mods & TERM_MOD_SHIFT) != 0;

    enum term_key k = ev->key;
    if ((unsigned)k < TERM_KEY_COUNT && legacy_desc[k].equiv != TERM_KEY_NONE)
        k = legacy_desc[k].equiv;

    if ((unsigned)k < TERM_KEY_COUNT) {
        const struct legacy_desc *d = &legacy_desc[k];
        if (d->final) {
            if (d->tilde) {
                sb_bytes(sb, "\033[", 2);
                sb_u32(sb, d->tilde);
                if (csi) {
                    sb_ch(sb, ';');
                    sb_u32(sb, p);
                }
                sb_ch(sb, '~');
                return true;
            }
            if (csi) {
                sb_bytes(sb, "\033[1;", 4);
                sb_u32(sb, p);
                sb_ch(sb, d->final);
                return true;
            }
            sb_ch(sb, '\033');
            sb_ch(sb, d->app_cursor && !m->app_cursor ? '[' : 'O');
            sb_ch(sb, d->final);
            return true;
        }
    }

    switch (k) {
    case TERM_KEY_RETURN:    sb_ch(sb, '\r'); return true;
    case TERM_KEY_BACKSPACE:
        sb_ch(sb, m->backarrow_bs ? '\x08' : '\x7f');
        return true;
    case TERM_KEY_TAB:
        if (shift) { sb_bytes(sb, "\033[Z", 3); }
        else       { sb_ch(sb, '\t'); }
        return true;
    case TERM_KEY_ESCAPE:    sb_ch(sb, '\033'); return true;
    default:                 break;
    }

    if (ev->text && !ev->text_deferred) {
        char tmp[8];
        size_t n = (size_t)utf8_encode(ev->text, tmp);
        sb_bytes(sb, tmp, n);
        return true;
    }
    return false;
}

void term_keyboard_update(struct term_keyboard_state *s, const struct term_key_event *ev)
{
    if (!s || !ev || ev->key <= TERM_KEY_NONE || ev->key >= TERM_KEY_COUNT)
        return;
    if (ev->action == TERM_KEY_RELEASE)
        s->down[ev->key >> 6] &= ~(1ull << (ev->key & 63));
    else if (ev->action == TERM_KEY_PRESS || ev->action == TERM_KEY_REPEAT)
        s->down[ev->key >> 6] |= 1ull << (ev->key & 63);
}

bool term_keyboard_key_down(const struct term_keyboard_state *s, enum term_key key)
{
    return s && key > TERM_KEY_NONE && (unsigned)key < TERM_KEY_COUNT &&
           ((s->down[key >> 6] >> (key & 63)) & 1);
}

static inline bool legacy_is_escape(const struct term_key_event *ev,
                                    const struct term_modes *m)
{
    if (m->app_keypad && (unsigned)ev->keypad < TERM_KEY_COUNT &&
        legacy_desc[ev->keypad].keypad_ss3)
        return true;
    if ((ev->mods & TERM_MOD_CTRL) && control_base_char(ev) == '[')
        return true;
    enum term_key k = ev->key;
    if ((unsigned)k < TERM_KEY_COUNT && legacy_desc[k].equiv != TERM_KEY_NONE)
        k = legacy_desc[k].equiv;
    if ((unsigned)k < TERM_KEY_COUNT && legacy_desc[k].final)
        return true;
    if (k == TERM_KEY_ESCAPE)
        return true;
    if (k == TERM_KEY_TAB && (ev->mods & TERM_MOD_SHIFT))
        return true;
    if (ev->text == '\033')
        return true;
    return false;
}

struct term_input_result term_input_encode_key(const struct term_keyboard_state *s,
                                         const struct term_key_event *ev,
                                         const struct term_modes *m,
                                         char *buf, size_t buf_sz)
{
    struct term_input_result out = {0};
    if (!ev || !m || !buf ||
        (ev->action != TERM_KEY_PRESS && ev->action != TERM_KEY_REPEAT &&
         ev->action != TERM_KEY_RELEASE) ||
        (unsigned)ev->key >= TERM_KEY_COUNT)
        return out;

    struct seqbuf sb;
    sb_init(&sb, buf, buf_sz);

    bool handled = encode_kitty(s, ev, m, &sb);
    if (!handled) {
        if (ev->action == TERM_KEY_RELEASE)
            return out;

        if ((ev->mods & TERM_MOD_ALT) && !legacy_is_escape(ev, m))
            sb_ch(&sb, '\033');

        handled = encode_legacy(ev, m, &sb);
    }

    if (!handled)
        return out;

    if (sb.overflow) {
        out.status = TERM_INPUT_BUFFER_FULL;
        out.len = 0;
    } else {
        out.len = sb_len(&sb, buf);
        out.status = out.len ? TERM_INPUT_BYTES : TERM_INPUT_CONSUMED;
    }
    return out;
}

struct term_input_result term_input_encode_mouse(const struct term_mouse_event *ev,
                                           const struct term_modes *m,
                                           char *buf, size_t buf_sz)
{
    struct term_input_result out = {0};
    if (!ev || !m || !buf) return out;

    if (!m->mouse || (ev->mods & TERM_MOD_SHIFT)) return out;

    out.status = TERM_INPUT_CONSUMED;
    if (ev->kind == TERM_MOUSE_LEAVE) return out;
    struct term_vector2i cell = ev->pos;
    if (cell.x < 0 || cell.y < 0 || cell.x >= m->grid.x || cell.y >= m->grid.y)
        return out;
    if (m->mouse == TERM_MOUSE_X10 && (ev->kind == TERM_MOUSE_RELEASE || ev->kind == TERM_MOUSE_MOTION)) {
        return out;
    }
    if (ev->kind == TERM_MOUSE_MOTION && (m->mouse == TERM_MOUSE_NORMAL ||
                       (m->mouse == TERM_MOUSE_BUTTON && ev->button == TERM_MOUSE_BUTTON_NONE))) {
        return out;
    }
    int button;
    if (ev->button >= TERM_MOUSE_BUTTON_PRIMARY && ev->button <= TERM_MOUSE_BUTTON_NONE)
        button = ev->button;
    else if (ev->button >= TERM_MOUSE_BUTTON_EXTRA_1 && ev->button <= TERM_MOUSE_BUTTON_EXTRA_4)
        button = 128 + ev->button - TERM_MOUSE_BUTTON_EXTRA_1;
    else if (ev->button >= TERM_MOUSE_WHEEL_UP && ev->button <= TERM_MOUSE_WHEEL_RIGHT)
        button = 64 + ev->button - TERM_MOUSE_WHEEL_UP;
    else {
        return out;
    }

    int mods = 0;
    if (ev->mods & TERM_MOD_ALT)  mods |= 8;
    if (ev->mods & TERM_MOD_CTRL) mods |= 16;

    int code = button | mods | (ev->kind == TERM_MOUSE_MOTION ? 32 : 0);
    int legacy_code = ev->kind == TERM_MOUSE_RELEASE ? 3 | mods : code;
    struct term_vector2i report = m->mouse_encoding == TERM_MOUSE_ENC_SGR_PIXELS
        ? ev->pixel : cell;
    if (report.x < 0 || report.y < 0)
        return out;
    uint32_t report_x = (uint32_t)report.x + 1;
    uint32_t report_y = (uint32_t)report.y + 1;

    struct seqbuf sb;
    sb_init(&sb, buf, buf_sz);

    if (m->mouse_encoding == TERM_MOUSE_ENC_SGR ||
        m->mouse_encoding == TERM_MOUSE_ENC_SGR_PIXELS) {
        sb_bytes(&sb, "\033[<", 3);
        sb_u32(&sb, (uint32_t)code);
        sb_ch(&sb, ';');
        sb_u32(&sb, report_x);
        sb_ch(&sb, ';');
        sb_u32(&sb, report_y);
        sb_ch(&sb, ev->kind == TERM_MOUSE_RELEASE ? 'm' : 'M');
    } else if (m->mouse_encoding == TERM_MOUSE_ENC_URXVT) {
        sb_bytes(&sb, "\033[", 2);
        sb_u32(&sb, (uint32_t)(legacy_code + 32));
        sb_ch(&sb, ';');
        sb_u32(&sb, (uint32_t)(cell.x + 1));
        sb_ch(&sb, ';');
        sb_u32(&sb, (uint32_t)(cell.y + 1));
        sb_ch(&sb, 'M');
    } else if (m->mouse_encoding == TERM_MOUSE_ENC_UTF8) {
        const unsigned values[3] = {
            (unsigned)legacy_code + 32, (unsigned)cell.x + 33,
            (unsigned)cell.y + 33,
        };
        sb_bytes(&sb, "\033[M", 3);
        for (int i = 0; i < 3; i++) {
            char tmp[8];
            size_t n = (size_t)utf8_encode(values[i], tmp);
            sb_bytes(&sb, tmp, n);
        }
    } else {
        if (legacy_code > 223 || cell.x > 222 || cell.y > 222)
            return out;
        char tmp[6] = {
            '\033', '[', 'M',
            (char)(legacy_code + 32),
            (char)(cell.x + 33),
            (char)(cell.y + 33),
        };
        sb_bytes(&sb, tmp, 6);
    }

    if (sb.overflow) {
        out.status = TERM_INPUT_BUFFER_FULL;
        out.len = 0;
        return out;
    }
    out.len = sb_len(&sb, buf);
    out.status = TERM_INPUT_BYTES;
    return out;
}

/* Bidi controls can make pasted text look different from what runs. */
static bool is_direction_format(uint32_t cp)
{
    return cp == 0x061c ||
           (cp >= 0x200e && cp <= 0x200f) ||
           (cp >= 0x202a && cp <= 0x202e) ||
           (cp >= 0x2066 && cp <= 0x2069) ||
           cp == 0xfeff;
}

struct term_input_result term_input_encode_paste(const struct term_modes *m,
                                                 const char *text, size_t len,
                                                 char *buf, size_t capacity)
{
    struct term_input_result out = {0};
    if (!m || !buf || (!text && len)) return out;

    struct seqbuf sb;
    sb_init(&sb, buf, capacity);
    if (m->bracketed_paste) sb_bytes(&sb, "\033[200~", 6);
    size_t body = sb_len(&sb, buf);
    for (size_t i = 0; i < len;) {
        if (sb.overflow) break;
        size_t start = i;
        while (i < len && (unsigned char)text[i] >= 0x20 && (unsigned char)text[i] < 0x7f)
            i++;
        if (i > start) {
            sb_bytes(&sb, text + start, i - start);
            continue;
        }
        unsigned char c = (unsigned char)text[i];
        if (c < 0x80) {
            if (c == '\r' || c == '\n') {
                sb_ch(&sb, '\r');
                if (c == '\r' && i + 1 < len && text[i + 1] == '\n') i++;
            } else if (c == '\t') {
                sb_ch(&sb, '\t');
            }
            i++;
            continue;
        }
        uint32_t cp;
        int n = utf8_decode_one(text + i, len - i, &cp);
        if (!n) { i++; continue; }
        if (cp >= 0xa0 && !is_direction_format(cp)) {
            sb_bytes(&sb, text + i, (size_t)n);
        }
        i += (size_t)n;
    }

    out.status = TERM_INPUT_CONSUMED;
    if (!sb.overflow && sb_len(&sb, buf) == body) return out;
    if (m->bracketed_paste) sb_bytes(&sb, "\033[201~", 6);
    if (sb.overflow) {
        out.status = TERM_INPUT_BUFFER_FULL;
        return out;
    }
    out.len = sb_len(&sb, buf);
    out.status = TERM_INPUT_BYTES;
    return out;
}