1 /* interestingtimes.c - cursor control
2 *
3 * Copyright 2015 Rob Landley <rob@landley.net>
4 */
5
6 #include "toys.h"
7
tty_fd(void)8 int tty_fd(void)
9 {
10 int i, j;
11
12 for (i = 0; i<3; i++) if (isatty(j = (i+1)%3)) return j;
13
14 return notstdio(open("/dev/tty", O_RDWR));
15 }
16
17 // Quick and dirty query size of terminal, doesn't do ANSI probe fallback.
18 // set x=80 y=25 before calling to provide defaults. Returns 0 if couldn't
19 // determine size.
20
terminal_size(unsigned * xx,unsigned * yy)21 int terminal_size(unsigned *xx, unsigned *yy)
22 {
23 struct winsize ws;
24 unsigned i, x = 0, y = 0;
25 char *s;
26
27 // stdin, stdout, stderr
28 for (i=0; i<3; i++) {
29 memset(&ws, 0, sizeof(ws));
30 if (isatty(i) && !ioctl(i, TIOCGWINSZ, &ws)) {
31 if (ws.ws_col) x = ws.ws_col;
32 if (ws.ws_row) y = ws.ws_row;
33
34 break;
35 }
36 }
37 s = getenv("COLUMNS");
38 if (s) sscanf(s, "%u", &x);
39 s = getenv("LINES");
40 if (s) sscanf(s, "%u", &y);
41
42 // Never return 0 for either value, leave it at default instead.
43 if (xx && x) *xx = x;
44 if (yy && y) *yy = y;
45
46 return x || y;
47 }
48
49 // Query terminal size, sending ANSI probe if necesary. (Probe queries xterm
50 // size through serial connection, when local TTY doesn't know but remote does.)
51 // Returns 0 if ANSI probe sent, 1 if size determined from tty or environment
52
terminal_probesize(unsigned * xx,unsigned * yy)53 int terminal_probesize(unsigned *xx, unsigned *yy)
54 {
55 if (terminal_size(xx, yy) && (!xx || *xx) && (!yy || *yy)) return 1;
56
57 // Send probe: bookmark cursor position, jump to bottom right,
58 // query position, return cursor to bookmarked position.
59 xprintf("\033[s\033[999C\033[999B\033[6n\033[u");
60
61 return 0;
62 }
63
xsetspeed(struct termios * tio,int speed)64 void xsetspeed(struct termios *tio, int speed)
65 {
66 int i, speeds[] = {50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400,
67 4800, 9600, 19200, 38400, 57600, 115200, 230400, 460800,
68 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
69 2500000, 3000000, 3500000, 4000000};
70
71 // Find speed in table, adjust to constant
72 for (i = 0; i < ARRAY_LEN(speeds); i++) if (speeds[i] == speed) break;
73 if (i == ARRAY_LEN(speeds)) error_exit("unknown speed: %d", speed);
74 cfsetspeed(tio, i+1+4081*(i>15));
75 }
76
77
78 // Reset terminal to known state, saving copy of old state if old != NULL.
set_terminal(int fd,int raw,int speed,struct termios * old)79 int set_terminal(int fd, int raw, int speed, struct termios *old)
80 {
81 struct termios termio;
82 int i = tcgetattr(fd, &termio);
83
84 // Fetch local copy of old terminfo, and copy struct contents to *old if set
85 if (i) return i;
86 if (old) *old = termio;
87
88 // the following are the bits set for an xterm. Linux text mode TTYs by
89 // default add two additional bits that only matter for serial processing
90 // (turn serial line break into an interrupt, and XON/XOFF flow control)
91
92 // Any key unblocks output, swap CR and NL on input
93 termio.c_iflag = IXANY|ICRNL|INLCR;
94 if (toys.which->flags & TOYFLAG_LOCALE) termio.c_iflag |= IUTF8;
95
96 // Output appends CR to NL, does magic undocumented postprocessing
97 termio.c_oflag = ONLCR|OPOST;
98
99 // Leave serial port speed alone
100 // termio.c_cflag = C_READ|CS8|EXTB;
101
102 // Generate signals, input entire line at once, echo output
103 // erase, line kill, escape control characters with ^
104 // erase line char at a time
105 // "extended" behavior: ctrl-V quotes next char, ctrl-R reprints unread chars,
106 // ctrl-W erases word
107 termio.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOKE|IEXTEN;
108
109 if (raw) cfmakeraw(&termio);
110
111 if (speed) {
112 int i, speeds[] = {50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400,
113 4800, 9600, 19200, 38400, 57600, 115200, 230400, 460800,
114 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
115 2500000, 3000000, 3500000, 4000000};
116
117 // Find speed in table, adjust to constant
118 for (i = 0; i < ARRAY_LEN(speeds); i++) if (speeds[i] == speed) break;
119 if (i == ARRAY_LEN(speeds)) error_exit("unknown speed: %d", speed);
120 cfsetspeed(&termio, i+1+4081*(i>15));
121 }
122
123 return tcsetattr(fd, TCSAFLUSH, &termio);
124 }
125
xset_terminal(int fd,int raw,int speed,struct termios * old)126 void xset_terminal(int fd, int raw, int speed, struct termios *old)
127 {
128 if (-1 != set_terminal(fd, raw, speed, old)) return;
129
130 sprintf(libbuf, "/proc/self/fd/%d", fd);
131 libbuf[readlink0(libbuf, libbuf, sizeof(libbuf))] = 0;
132 perror_exit("tcsetattr %s", libbuf);
133 }
134
135 struct scan_key_list {
136 int key;
137 char *seq;
138 } static const scan_key_list[] = {
139 {KEY_UP, "\033[A"}, {KEY_DOWN, "\033[B"},
140 {KEY_RIGHT, "\033[C"}, {KEY_LEFT, "\033[D"},
141
142 {KEY_UP|KEY_SHIFT, "\033[1;2A"}, {KEY_DOWN|KEY_SHIFT, "\033[1;2B"},
143 {KEY_RIGHT|KEY_SHIFT, "\033[1;2C"}, {KEY_LEFT|KEY_SHIFT, "\033[1;2D"},
144
145 {KEY_UP|KEY_ALT, "\033[1;3A"}, {KEY_DOWN|KEY_ALT, "\033[1;3B"},
146 {KEY_RIGHT|KEY_ALT, "\033[1;3C"}, {KEY_LEFT|KEY_ALT, "\033[1;3D"},
147
148 {KEY_UP|KEY_CTRL, "\033[1;5A"}, {KEY_DOWN|KEY_CTRL, "\033[1;5B"},
149 {KEY_RIGHT|KEY_CTRL, "\033[1;5C"}, {KEY_LEFT|KEY_CTRL, "\033[1;5D"},
150
151 // VT102/VT220 escapes.
152 {KEY_HOME, "\033[1~"},
153 {KEY_HOME|KEY_CTRL, "\033[1;5~"},
154 {KEY_INSERT, "\033[2~"},
155 {KEY_DELETE, "\033[3~"},
156 {KEY_END, "\033[4~"},
157 {KEY_END|KEY_CTRL, "\033[4;5~"},
158 {KEY_PGUP, "\033[5~"},
159 {KEY_PGDN, "\033[6~"},
160 // "Normal" "PC" escapes (xterm).
161 {KEY_HOME, "\033OH"},
162 {KEY_END, "\033OF"},
163 // "Application" "PC" escapes (gnome-terminal).
164 {KEY_HOME, "\033[H"},
165 {KEY_END, "\033[F"},
166 {KEY_HOME|KEY_CTRL, "\033[1;5H"},
167 {KEY_END|KEY_CTRL, "\033[1;5F"},
168
169 {KEY_FN+1, "\033OP"}, {KEY_FN+2, "\033OQ"}, {KEY_FN+3, "\033OR"},
170 {KEY_FN+4, "\033OS"}, {KEY_FN+5, "\033[15~"}, {KEY_FN+6, "\033[17~"},
171 {KEY_FN+7, "\033[18~"}, {KEY_FN+8, "\033[19~"}, {KEY_FN+9, "\033[20~"},
172 };
173
174 // Scan stdin for a keypress, parsing known escape sequences, including
175 // responses to screen size queries.
176 // Blocks for timeout_ms milliseconds, 0=return immediately, -1=wait forever.
177 // Returns 0-255=literal, -1=EOF, -2=TIMEOUT, -3=RESIZE, 256+= a KEY_ constant.
178 // Scratch space is necessary because last char of !seq could start new seq.
179 // Zero out first byte of scratch before first call to scan_key.
scan_key_getsize(char * scratch,int timeout_ms,unsigned * xx,unsigned * yy)180 int scan_key_getsize(char *scratch, int timeout_ms, unsigned *xx, unsigned *yy)
181 {
182 struct pollfd pfd;
183 int maybe, i, j;
184 char *test;
185
186 for (;;) {
187 pfd.fd = 0;
188 pfd.events = POLLIN;
189 pfd.revents = 0;
190
191 maybe = 0;
192 if (*scratch) {
193 int pos[6];
194 unsigned x, y;
195
196 // Check for return from terminal size probe
197 memset(pos, 0, 6*sizeof(int));
198 scratch[(1+*scratch)&15] = 0;
199 sscanf(scratch+1, "\033%n[%n%3u%n;%n%3u%nR%n", pos, pos+1, &y,
200 pos+2, pos+3, &x, pos+4, pos+5);
201 if (pos[5]) {
202 // Recognized X/Y position, consume and return
203 *scratch = 0;
204 if (xx) *xx = x;
205 if (yy) *yy = y;
206 return -3;
207 } else for (i=0; i<6; i++) if (pos[i]==*scratch) maybe = 1;
208
209 // Check sequences
210 for (i = 0; i<ARRAY_LEN(scan_key_list); i++) {
211 test = scan_key_list[i].seq;
212 for (j = 0; j<*scratch; j++) if (scratch[j+1] != test[j]) break;
213 if (j == *scratch) {
214 maybe = 1;
215 if (!test[j]) {
216 // We recognized current sequence: consume and return
217 *scratch = 0;
218 return 256+scan_key_list[i].key;
219 }
220 }
221 }
222
223 // If current data can't be a known sequence, return next raw char
224 if (!maybe) break;
225 }
226
227 // Need more data to decide
228
229 // 30ms is about the gap between characters at 300 baud
230 if (maybe || timeout_ms != -1)
231 if (!xpoll(&pfd, 1, maybe ? 30 : timeout_ms)) break;
232
233 // Read 1 byte so we don't overshoot sequence match. (We can deviate
234 // and fail to match, but match consumes entire buffer.)
235 if (toys.signal>0 || 1 != read(0, scratch+1+*scratch, 1))
236 return (toys.signal>0) ? -3 : -1;
237 ++*scratch;
238 }
239
240 // Was not a sequence
241 if (!*scratch) return -2;
242 i = scratch[1];
243 if (--*scratch) memmove(scratch+1, scratch+2, *scratch);
244
245 return i;
246 }
247
248 // Wrapper that ignores results from ANSI probe to update screensize.
249 // Otherwise acts like scan_key_getsize().
scan_key(char * scratch,int timeout_ms)250 int scan_key(char *scratch, int timeout_ms)
251 {
252 return scan_key_getsize(scratch, timeout_ms, NULL, NULL);
253 }
254
tty_esc(char * s)255 void tty_esc(char *s)
256 {
257 printf("\033[%s", s);
258 }
259
tty_jump(int x,int y)260 void tty_jump(int x, int y)
261 {
262 char s[32];
263
264 sprintf(s, "%d;%dH", y+1, x+1);
265 tty_esc(s);
266 }
267
tty_reset(void)268 void tty_reset(void)
269 {
270 set_terminal(0, 0, 0, 0);
271 tty_esc("?25h");
272 tty_esc("0m");
273 tty_jump(0, 999);
274 tty_esc("K");
275 fflush(0);
276 }
277
278 // If you call set_terminal(), use sigatexit(tty_sigreset);
tty_sigreset(int i)279 void tty_sigreset(int i)
280 {
281 tty_reset();
282 _exit(i ? 128+i : 0);
283 }
284
start_redraw(unsigned * width,unsigned * height)285 void start_redraw(unsigned *width, unsigned *height)
286 {
287 // If never signaled, do raw mode setup.
288 if (!toys.signal) {
289 *width = 80;
290 *height = 25;
291 set_terminal(0, 1, 0, 0);
292 sigatexit(tty_sigreset);
293 xsignal(SIGWINCH, generic_signal);
294 }
295 if (toys.signal != -1) {
296 toys.signal = -1;
297 terminal_probesize(width, height);
298 }
299 xprintf("\033[H\033[J");
300 }
301