1/* interestingtimes.c - cursor control
2 *
3 * Copyright 2015 Rob Landley <rob@landley.net>
4 */
5
6#include "toys.h"
7
8int xgettty(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 xopen("/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
21int 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 (!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
53int 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("\e[s\e[999C\e[999B\e[6n\e[u");
60
61  return 0;
62}
63
64// Wrapper that parses results from ANSI probe to update screensize.
65// Otherwise acts like scan_key()
66int scan_key_getsize(char *scratch, int miliwait, unsigned *xx, unsigned *yy)
67{
68  int key;
69
70  if (512&(key = scan_key(scratch, miliwait))) {
71    if (key>0) {
72      if (xx) *xx = (key>>10)&1023;
73      if (yy) *yy = (key>>20)&1023;
74      toys.signal = SIGWINCH;
75
76      return -3;
77    }
78  }
79
80  return key;
81}
82
83// Reset terminal to known state, saving copy of old state if old != NULL.
84int set_terminal(int fd, int raw, struct termios *old)
85{
86  struct termios termio;
87
88  // Fetch local copy of old terminfo, and copy struct contents to *old if set
89  if (!tcgetattr(fd, &termio) && old) *old = termio;
90
91  // the following are the bits set for an xterm. Linux text mode TTYs by
92  // default add two additional bits that only matter for serial processing
93  // (turn serial line break into an interrupt, and XON/XOFF flow control)
94
95  // Any key unblocks output, swap CR and NL on input
96  termio.c_iflag = IXANY|ICRNL|INLCR;
97  if (toys.which->flags & TOYFLAG_LOCALE) termio.c_iflag |= IUTF8;
98
99  // Output appends CR to NL, does magic undocumented postprocessing
100  termio.c_oflag = ONLCR|OPOST;
101
102  // Leave serial port speed alone
103  // termio.c_cflag = C_READ|CS8|EXTB;
104
105  // Generate signals, input entire line at once, echo output
106  // erase, line kill, escape control characters with ^
107  // erase line char at a time
108  // "extended" behavior: ctrl-V quotes next char, ctrl-R reprints unread chars,
109  // ctrl-W erases word
110  termio.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOKE|IEXTEN;
111
112  if (raw) cfmakeraw(&termio);
113
114  return tcsetattr(fd, TCSANOW, &termio);
115}
116
117void xset_terminal(int fd, int raw, struct termios *old)
118{
119  if (-1 == set_terminal(fd, raw, old)) perror_exit("bad tty fd#%d", fd);
120}
121
122struct scan_key_list {
123  char *name, *seq;
124} static const scan_key_list[] = TAGGED_ARRAY(KEY,
125  // up down right left pgup pgdn home end ins
126  {"UP", "\033[A"}, {"DOWN", "\033[B"}, {"RIGHT", "\033[C"}, {"LEFT", "\033[D"},
127  {"PGUP", "\033[5~"}, {"PGDN", "\033[6~"}, {"HOME", "\033OH"},
128  {"END", "\033OF"}, {"INSERT", "\033[2~"},
129
130  {"F1", "\033OP"}, {"F2", "\033OQ"}, {"F3", "\033OR"}, {"F4", "\033OS"},
131  {"F5", "\033[15~"}, {"F6", "\033[17~"}, {"F7", "\033[18~"},
132  {"F8", "\033[19~"}, {"F9", "\033[20~"},
133
134  {"SUP", "\033[1;2A"}, {"AUP", "\033[1;3A"}, {"CUP", "\033[1;5A"},
135  {"SDOWN", "\033[1;2B"}, {"ADOWN", "\033[1;3B"}, {"CDOWN", "\033[1;5B"},
136  {"SRIGHT", "\033[1;2C"}, {"ARIGHT", "\033[1;3C"}, {"CRIGHT", "\033[1;5C"},
137  {"SLEFT", "\033[1;2D"}, {"ALEFT", "\033[1;3D"}, {"CLEFT", "\033[1;5D"},
138
139  {"SF1", "\033O1;2P"}, {"AF1", "\033O1;3P"}, {"CF1", "\033[1;5P"}
140);
141
142// Scan stdin for a keypress, parsing known escape sequences
143// Blocks for miliwait miliseconds, none 0, forever if -1
144// Returns: 0-255=literal, -1=EOF, -2=NONE, 256-...=index into scan_key_list
145// >512 is x<<9+y<<21
146// scratch space is necessary because last char of !seq could start new seq
147// Zero out first byte of scratch before first call to scan_key
148// block=0 allows fetching multiple characters before updating display
149int scan_key(char *scratch, int miliwait)
150{
151  struct pollfd pfd;
152  int maybe, i, j;
153  char *test;
154
155  for (;;) {
156    pfd.fd = 0;
157    pfd.events = POLLIN;
158    pfd.revents = 0;
159
160    maybe = 0;
161    if (*scratch) {
162      int pos[6];
163      unsigned x, y;
164
165      // Check for return from terminal size probe
166      memset(pos, 0, 6*sizeof(int));
167      scratch[(1+*scratch)&15] = 0;
168      sscanf(scratch+1, "\033%n[%n%3u%n;%n%3u%nR%n", pos, pos+1, &y,
169             pos+2, pos+3, &x, pos+4, pos+5);
170      if (pos[5]) {
171        // Recognized X/Y position, consume and return
172        *scratch = 0;
173        return 512+(x<<10)+(y<<20);
174      } else for (i=0; i<6; i++) if (pos[i]==*scratch) maybe = 1;
175
176      // Check sequences
177      for (i = 0; i<ARRAY_LEN(scan_key_list); i++) {
178        test = scan_key_list[i].seq;
179        for (j = 0; j<*scratch; j++) if (scratch[j+1] != test[j]) break;
180        if (j == *scratch) {
181          maybe = 1;
182          if (!test[j]) {
183            // We recognized current sequence: consume and return
184            *scratch = 0;
185            return 256+i;
186          }
187        }
188      }
189
190      // If current data can't be a known sequence, return next raw char
191      if (!maybe) break;
192    }
193
194    // Need more data to decide
195
196    // 30 miliseconds is about the gap between characters at 300 baud
197    if (maybe || miliwait != -1)
198      if (!xpoll(&pfd, 1, maybe ? 30 : miliwait)) break;
199
200    // Read 1 byte so we don't overshoot sequence match. (We can deviate
201    // and fail to match, but match consumes entire buffer.)
202    if (toys.signal || 1 != read(0, scratch+1+*scratch, 1))
203      return toys.signal ? -3 : -1;
204    ++*scratch;
205  }
206
207  // Was not a sequence
208  if (!*scratch) return -2;
209  i = scratch[1];
210  if (--*scratch) memmove(scratch+1, scratch+2, *scratch);
211
212  return i;
213}
214
215void tty_esc(char *s)
216{
217  printf("\033[%s", s);
218}
219
220void tty_jump(int x, int y)
221{
222  char s[32];
223
224  sprintf(s, "%d;%dH", y+1, x+1);
225  tty_esc(s);
226}
227
228void tty_reset(void)
229{
230  set_terminal(1, 0, 0);
231  tty_esc("?25h");
232  tty_esc("0m");
233  tty_jump(0, 999);
234  tty_esc("K");
235  fflush(0);
236}
237
238// If you call set_terminal(), use sigatexit(tty_sigreset);
239void tty_sigreset(int i)
240{
241  tty_reset();
242  _exit(128+i);
243}
244