1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/* Sets the termbox input mode. Termbox has two input modes:
* 1. Esc input mode.
* When ESC sequence is in the buffer and it doesn't match any known
* ESC sequence => ESC means TB_KEY_ESC.
* 2. Alt input mode.
* When ESC sequence is in the buffer and it doesn't match any known
* sequence => ESC enables TB_MOD_ALT modifier for the next keyboard event.
*
* If 'mode' is TB_INPUT_CURRENT, it returns the current input mode.
*/
int tb_select_input_mode(int mode);
/* Possible values for mode. */
#define TB_INPUT_CURRENT 0x0
#define TB_INPUT_ESC 0x1
#define TB_INPUT_ALT 0x2
#define TB_INPUT_MOUSE 0x4
// if s1 starts with s2 returns true, else false
// len is the length of s1
// s2 should be null-terminated
static bool starts_with(const char *s1, int len, const char *s2)
{
int n = 0;
while (*s2 && n < len) {
if (*s1++ != *s2++)
return false;
n++;
}
return *s2 == 0;
}
// convert escape sequence to event, and return consumed bytes on success (failure == 0)
static int parse_escape_seq(struct tb_event *event, const char *buf, int len)
{
if (len >= 6 && starts_with(buf, len, "\033[M")) {
switch (buf[3] & 3) {
case 0:
if (buf[3] == 0x60)
event->key = TB_KEY_MOUSE_WHEEL_UP;
else
event->key = TB_KEY_MOUSE_LEFT;
break;
case 1:
if (buf[3] == 0x61)
event->key = TB_KEY_MOUSE_WHEEL_DOWN;
else
event->key = TB_KEY_MOUSE_MIDDLE;
break;
case 2:
event->key = TB_KEY_MOUSE_RIGHT;
break;
case 3:
event->key = TB_KEY_MOUSE_RELEASE;
break;
default:
return -6;
}
event->type = TB_EVENT_MOUSE; // TB_EVENT_KEY by default
// the coord is 1,1 for upper left
event->x = buf[4] - 1 - 32;
event->y = buf[5] - 1 - 32;
return 6;
}
// it's pretty simple here, find 'starts_with' match and return
// success, else return failure
int i;
for (i = 0; keys[i]; i++) {
if (starts_with(buf, len, keys[i])) {
event->ch = 0;
event->key = 0xFFFF-i;
return strlen(keys[i]);
}
}
return 0;
}
static bool extract_event(struct tb_event *event, struct bytebuffer *inbuf, int inputmode)
{
const char *buf = inbuf->buf;
const int len = inbuf->len;
if (len == 0)
return false;
if (buf[0] == '\033') {
int n = parse_escape_seq(event, buf, len);
if (n != 0) {
bool success = true;
if (n < 0) {
success = false;
n = -n;
}
bytebuffer_truncate(inbuf, n);
return success;
} else {
// it's not escape sequence, then it's ALT or ESC,
// check inputmode
if (inputmode&TB_INPUT_ESC) {
// if we're in escape mode, fill ESC event, pop
// buffer, return success
event->ch = 0;
event->key = TB_KEY_ESC;
event->mod = 0;
bytebuffer_truncate(inbuf, 1);
return true;
}
if (inputmode&TB_INPUT_ALT) {
// if we're in alt mode, set ALT modifier to
// event and redo parsing
event->mod = TB_MOD_ALT;
bytebuffer_truncate(inbuf, 1);
return extract_event(event, inbuf, inputmode);
}
assert(!"never got here");
}
}
// if we're here, this is not an escape sequence and not an alt sequence
// so, it's a FUNCTIONAL KEY or a UNICODE character
// first of all check if it's a functional key
if ((unsigned char)buf[0] <= TB_KEY_SPACE ||
(unsigned char)buf[0] == TB_KEY_BACKSPACE2)
{
// fill event, pop buffer, return success */
event->ch = 0;
event->key = (uint16_t)buf[0];
bytebuffer_truncate(inbuf, 1);
return true;
}
// feh... we got utf8 here
// check if there is all bytes
if (len >= tb_utf8_char_length(buf[0])) {
/* everything ok, fill event, pop buffer, return success */
tb_utf8_char_to_unicode(&event->ch, buf);
event->key = 0;
bytebuffer_truncate(inbuf, tb_utf8_char_length(buf[0]));
return true;
}
// event isn't recognized, perhaps there is not enough bytes in utf8
// sequence
return false;
}
|