?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Style: uint -> u_int and a missing else.
[tmux-openbsd.git] / tty.c
blobbffb1f93766490898a941eeffde4f9b63d8748cc
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include <sys/types.h>
20 #include <sys/ioctl.h>
21
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <termios.h>
27 #include <unistd.h>
28
29 #include "tmux.h"
30
31 void tty_read_callback(struct bufferevent *, void *);
32 void tty_error_callback(struct bufferevent *, short, void *);
33
34 int tty_try_256(struct tty *, u_char, const char *);
35 int tty_try_88(struct tty *, u_char, const char *);
36
37 void tty_colours(struct tty *, const struct grid_cell *);
38 void tty_check_fg(struct tty *, struct grid_cell *);
39 void tty_check_bg(struct tty *, struct grid_cell *);
40 void tty_colours_fg(struct tty *, const struct grid_cell *);
41 void tty_colours_bg(struct tty *, const struct grid_cell *);
42
43 void tty_redraw_region(struct tty *, const struct tty_ctx *);
44 void tty_emulate_repeat(
45 struct tty *, enum tty_code_code, enum tty_code_code, u_int);
46 void tty_cell(struct tty *,
47 const struct grid_cell *, const struct grid_utf8 *);
48
49 #define tty_use_acs(tty) \
50 (tty_term_has(tty->term, TTYC_ACSC) && !((tty)->flags & TTY_UTF8))
51
52 void
53 tty_init(struct tty *tty, int fd, char *term)
54 {
55 char *path;
56
57 memset(tty, 0, sizeof *tty);
58 tty->log_fd = -1;
59
60 if (term == NULL || *term == '\0')
61 tty->termname = xstrdup("unknown");
62 else
63 tty->termname = xstrdup(term);
64 tty->fd = fd;
65
66 if ((path = ttyname(fd)) == NULL)
67 fatalx("ttyname failed");
68 tty->path = xstrdup(path);
69
70 tty->flags = 0;
71 tty->term_flags = 0;
72 }
73
74 int
75 tty_resize(struct tty *tty)
76 {
77 struct winsize ws;
78 u_int sx, sy;
79
80 if (ioctl(tty->fd, TIOCGWINSZ, &ws) != -1) {
81 sx = ws.ws_col;
82 if (sx == 0)
83 sx = 80;
84 sy = ws.ws_row;
85 if (sy == 0)
86 sy = 24;
87 } else {
88 sx = 80;
89 sy = 24;
90 }
91 if (sx == tty->sx && sy == tty->sy)
92 return (0);
93 tty->sx = sx;
94 tty->sy = sy;
95
96 tty->cx = UINT_MAX;
97 tty->cy = UINT_MAX;
98
99 tty->rupper = UINT_MAX;
100 tty->rlower = UINT_MAX;
101
102 /*
103 * If the terminal has been started, reset the actual scroll region and
104 * cursor position, as this may not have happened.
105 */
106 if (tty->flags & TTY_STARTED) {
107 tty_cursor(tty, 0, 0);
108 tty_region(tty, 0, tty->sy - 1);
109 }
110
111 return (1);
112 }
113
114 int
115 tty_open(struct tty *tty, const char *overrides, char **cause)
116 {
117 char out[64];
118 int fd;
119
120 if (debug_level > 3) {
121 xsnprintf(out, sizeof out, "tmux-out-%ld.log", (long) getpid());
122 fd = open(out, O_WRONLY|O_CREAT|O_TRUNC, 0644);
123 if (fd != -1 && fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
124 fatal("fcntl failed");
125 tty->log_fd = fd;
126 }
127
128 tty->term = tty_term_find(tty->termname, tty->fd, overrides, cause);
129 if (tty->term == NULL) {
130 tty_close(tty);
131 return (-1);
132 }
133 tty->flags |= TTY_OPENED;
134
135 tty->flags &= ~(TTY_NOCURSOR|TTY_FREEZE|TTY_ESCAPE);
136
137 tty->event = bufferevent_new(
138 tty->fd, tty_read_callback, NULL, tty_error_callback, tty);
139
140 tty_start_tty(tty);
141
142 tty_keys_init(tty);
143
144 return (0);
145 }
146
147 /* ARGSUSED */
148 void
149 tty_read_callback(unused struct bufferevent *bufev, void *data)
150 {
151 struct tty *tty = data;
152
153 while (tty_keys_next(tty))
154 ;
155 }
156
157 /* ARGSUSED */
158 void
159 tty_error_callback(
160 unused struct bufferevent *bufev, unused short what, unused void *data)
161 {
162 }
163
164 void
165 tty_start_tty(struct tty *tty)
166 {
167 struct termios tio;
168
169 if (tty->fd == -1 || tcgetattr(tty->fd, &tty->tio) != 0)
170 return;
171
172 setblocking(tty->fd, 0);
173
174 bufferevent_enable(tty->event, EV_READ|EV_WRITE);
175
176 memcpy(&tio, &tty->tio, sizeof tio);
177 tio.c_iflag &= ~(IXON|IXOFF|ICRNL|INLCR|IGNCR|IMAXBEL|ISTRIP);
178 tio.c_iflag |= IGNBRK;
179 tio.c_oflag &= ~(OPOST|ONLCR|OCRNL|ONLRET);
180 tio.c_lflag &= ~(IEXTEN|ICANON|ECHO|ECHOE|ECHONL|ECHOCTL|
181 ECHOPRT|ECHOKE|ECHOCTL|ISIG);
182 tio.c_cc[VMIN] = 1;
183 tio.c_cc[VTIME] = 0;
184 if (tcsetattr(tty->fd, TCSANOW, &tio) == 0)
185 tcflush(tty->fd, TCIOFLUSH);
186
187 tty_putcode(tty, TTYC_SMCUP);
188
189 tty_putcode(tty, TTYC_SGR0);
190 memcpy(&tty->cell, &grid_default_cell, sizeof tty->cell);
191
192 tty_putcode(tty, TTYC_RMKX);
193 if (tty_use_acs(tty))
194 tty_putcode(tty, TTYC_ENACS);
195 tty_putcode(tty, TTYC_CLEAR);
196
197 tty_putcode(tty, TTYC_CNORM);
198 if (tty_term_has(tty->term, TTYC_KMOUS))
199 tty_puts(tty, "\033[?1000l");
200
201 tty->cx = UINT_MAX;
202 tty->cy = UINT_MAX;
203
204 tty->rlower = UINT_MAX;
205 tty->rupper = UINT_MAX;
206
207 tty->mode = MODE_CURSOR;
208
209 tty->flags |= TTY_STARTED;
210 }
211
212 void
213 tty_stop_tty(struct tty *tty)
214 {
215 struct winsize ws;
216
217 if (!(tty->flags & TTY_STARTED))
218 return;
219 tty->flags &= ~TTY_STARTED;
220
221 bufferevent_disable(tty->event, EV_READ|EV_WRITE);
222
223 /*
224 * Be flexible about error handling and try not kill the server just
225 * because the fd is invalid. Things like ssh -t can easily leave us
226 * with a dead tty.
227 */
228 if (ioctl(tty->fd, TIOCGWINSZ, &ws) == -1)
229 return;
230 if (tcsetattr(tty->fd, TCSANOW, &tty->tio) == -1)
231 return;
232
233 setblocking(tty->fd, 1);
234
235 tty_raw(tty, tty_term_string2(tty->term, TTYC_CSR, 0, ws.ws_row - 1));
236 if (tty_use_acs(tty))
237 tty_raw(tty, tty_term_string(tty->term, TTYC_RMACS));
238 tty_raw(tty, tty_term_string(tty->term, TTYC_SGR0));
239 tty_raw(tty, tty_term_string(tty->term, TTYC_RMKX));
240 tty_raw(tty, tty_term_string(tty->term, TTYC_CLEAR));
241
242 tty_raw(tty, tty_term_string(tty->term, TTYC_CNORM));
243 if (tty_term_has(tty->term, TTYC_KMOUS))
244 tty_raw(tty, "\033[?1000l");
245
246 tty_raw(tty, tty_term_string(tty->term, TTYC_RMCUP));
247 }
248
249 void
250 tty_close(struct tty *tty)
251 {
252 if (tty->log_fd != -1) {
253 close(tty->log_fd);
254 tty->log_fd = -1;
255 }
256
257 evtimer_del(&tty->key_timer);
258 tty_stop_tty(tty);
259
260 if (tty->flags & TTY_OPENED) {
261 bufferevent_free(tty->event);
262
263 tty_term_free(tty->term);
264 tty_keys_free(tty);
265
266 tty->flags &= ~TTY_OPENED;
267 }
268
269 if (tty->fd != -1) {
270 close(tty->fd);
271 tty->fd = -1;
272 }
273 }
274
275 void
276 tty_free(struct tty *tty)
277 {
278 tty_close(tty);
279
280 if (tty->path != NULL)
281 xfree(tty->path);
282 if (tty->termname != NULL)
283 xfree(tty->termname);
284 }
285
286 void
287 tty_raw(struct tty *tty, const char *s)
288 {
289 write(tty->fd, s, strlen(s));
290 }
291
292 void
293 tty_putcode(struct tty *tty, enum tty_code_code code)
294 {
295 tty_puts(tty, tty_term_string(tty->term, code));
296 }
297
298 void
299 tty_putcode1(struct tty *tty, enum tty_code_code code, int a)
300 {
301 if (a < 0)
302 return;
303 tty_puts(tty, tty_term_string1(tty->term, code, a));
304 }
305
306 void
307 tty_putcode2(struct tty *tty, enum tty_code_code code, int a, int b)
308 {
309 if (a < 0 || b < 0)
310 return;
311 tty_puts(tty, tty_term_string2(tty->term, code, a, b));
312 }
313
314 void
315 tty_puts(struct tty *tty, const char *s)
316 {
317 if (*s == '\0')
318 return;
319 bufferevent_write(tty->event, s, strlen(s));
320
321 if (tty->log_fd != -1)
322 write(tty->log_fd, s, strlen(s));
323 }
324
325 void
326 tty_putc(struct tty *tty, u_char ch)
327 {
328 const char *acs;
329 u_int sx;
330
331 if (tty->cell.attr & GRID_ATTR_CHARSET) {
332 acs = tty_acs_get(tty, ch);
333 if (acs != NULL)
334 bufferevent_write(tty->event, acs, strlen(acs));
335 else
336 bufferevent_write(tty->event, &ch, 1);
337 } else
338 bufferevent_write(tty->event, &ch, 1);
339
340 if (ch >= 0x20 && ch != 0x7f) {
341 sx = tty->sx;
342 if (tty->term->flags & TERM_EARLYWRAP)
343 sx--;
344
345 if (tty->cx >= sx) {
346 tty->cx = 1;
347 if (tty->cy != tty->rlower)
348 tty->cy++;
349 } else
350 tty->cx++;
351 }
352
353 if (tty->log_fd != -1)
354 write(tty->log_fd, &ch, 1);
355 }
356
357 void
358 tty_pututf8(struct tty *tty, const struct grid_utf8 *gu)
359 {
360 size_t size;
361
362 size = grid_utf8_size(gu);
363 bufferevent_write(tty->event, gu->data, size);
364 if (tty->log_fd != -1)
365 write(tty->log_fd, gu->data, size);
366 tty->cx += gu->width;
367 }
368
369 void
370 tty_set_title(struct tty *tty, const char *title)
371 {
372 if (strstr(tty->termname, "xterm") == NULL &&
373 strstr(tty->termname, "rxvt") == NULL &&
374 strcmp(tty->termname, "screen") != 0)
375 return;
376
377 tty_puts(tty, "\033]0;");
378 tty_puts(tty, title);
379 tty_putc(tty, '\007');
380 }
381
382 void
383 tty_update_mode(struct tty *tty, int mode)
384 {
385 int changed;
386
387 if (tty->flags & TTY_NOCURSOR)
388 mode &= ~MODE_CURSOR;
389
390 changed = mode ^ tty->mode;
391 if (changed & MODE_CURSOR) {
392 if (mode & MODE_CURSOR)
393 tty_putcode(tty, TTYC_CNORM);
394 else
395 tty_putcode(tty, TTYC_CIVIS);
396 }
397 if (changed & ALL_MOUSE_MODES) {
398 if (mode & ALL_MOUSE_MODES) {
399 if (mode & MODE_MOUSE_UTF8)
400 tty_puts(tty, "\033[?1005h");
401 if (mode & MODE_MOUSE_ANY)
402 tty_puts(tty, "\033[?1003h");
403 else if (mode & MODE_MOUSE_BUTTON)
404 tty_puts(tty, "\033[?1002h");
405 else if (mode & MODE_MOUSE_STANDARD)
406 tty_puts(tty, "\033[?1000h");
407 } else {
408 if (tty->mode & MODE_MOUSE_ANY)
409 tty_puts(tty, "\033[?1003l");
410 else if (tty->mode & MODE_MOUSE_BUTTON)
411 tty_puts(tty, "\033[?1002l");
412 else if (tty->mode & MODE_MOUSE_STANDARD)
413 tty_puts(tty, "\033[?1000l");
414 if (tty->mode & MODE_MOUSE_UTF8)
415 tty_puts(tty, "\033[?1005l");
416 }
417 }
418 if (changed & MODE_KKEYPAD) {
419 if (mode & MODE_KKEYPAD)
420 tty_putcode(tty, TTYC_SMKX);
421 else
422 tty_putcode(tty, TTYC_RMKX);
423 }
424 tty->mode = mode;
425 }
426
427 void
428 tty_emulate_repeat(
429 struct tty *tty, enum tty_code_code code, enum tty_code_code code1, u_int n)
430 {
431 if (tty_term_has(tty->term, code))
432 tty_putcode1(tty, code, n);
433 else {
434 while (n-- > 0)
435 tty_putcode(tty, code1);
436 }
437 }
438
439 /*
440 * Redraw scroll region using data from screen (already updated). Used when
441 * CSR not supported, or window is a pane that doesn't take up the full
442 * width of the terminal.
443 */
444 void
445 tty_redraw_region(struct tty *tty, const struct tty_ctx *ctx)
446 {
447 struct window_pane *wp = ctx->wp;
448 struct screen *s = wp->screen;
449 u_int i;
450
451 /*
452 * If region is >= 50% of the screen, just schedule a window redraw. In
453 * most cases, this is likely to be followed by some more scrolling -
454 * without this, the entire pane ends up being redrawn many times which
455 * can be much more data.
456 */
457 if (ctx->orlower - ctx->orupper >= screen_size_y(s) / 2) {
458 wp->flags |= PANE_REDRAW;
459 return;
460 }
461
462 if (ctx->ocy < ctx->orupper || ctx->ocy > ctx->orlower) {
463 for (i = ctx->ocy; i < screen_size_y(s); i++)
464 tty_draw_line(tty, s, i, wp->xoff, wp->yoff);
465 } else {
466 for (i = ctx->orupper; i <= ctx->orlower; i++)
467 tty_draw_line(tty, s, i, wp->xoff, wp->yoff);
468 }
469 }
470
471 void
472 tty_draw_line(struct tty *tty, struct screen *s, u_int py, u_int ox, u_int oy)
473 {
474 const struct grid_cell *gc;
475 struct grid_line *gl;
476 struct grid_cell tmpgc;
477 const struct grid_utf8 *gu;
478 u_int i, sx;
479
480 tty_update_mode(tty, tty->mode & ~MODE_CURSOR);
481
482 sx = screen_size_x(s);
483 if (sx > s->grid->linedata[s->grid->hsize + py].cellsize)
484 sx = s->grid->linedata[s->grid->hsize + py].cellsize;
485 if (sx > tty->sx)
486 sx = tty->sx;
487
488 /*
489 * Don't move the cursor to the start permission if it will wrap there
490 * itself.
491 */
492 gl = NULL;
493 if (py != 0)
494 gl = &s->grid->linedata[s->grid->hsize + py - 1];
495 if (oy + py == 0 || gl == NULL || !(gl->flags & GRID_LINE_WRAPPED) ||
496 tty->cx < tty->sx || ox != 0 ||
497 (oy + py != tty->cy + 1 && tty->cy != s->rlower + oy))
498 tty_cursor(tty, ox, oy + py);
499
500 for (i = 0; i < sx; i++) {
501 gc = grid_view_peek_cell(s->grid, i, py);
502
503 gu = NULL;
504 if (gc->flags & GRID_FLAG_UTF8)
505 gu = grid_view_peek_utf8(s->grid, i, py);
506
507 if (screen_check_selection(s, i, py)) {
508 memcpy(&tmpgc, &s->sel.cell, sizeof tmpgc);
509 tmpgc.data = gc->data;
510 tmpgc.flags = gc->flags &
511 ~(GRID_FLAG_FG256|GRID_FLAG_BG256);
512 tmpgc.flags |= s->sel.cell.flags &
513 (GRID_FLAG_FG256|GRID_FLAG_BG256);
514 tty_cell(tty, &tmpgc, gu);
515 } else
516 tty_cell(tty, gc, gu);
517 }
518
519 if (sx >= tty->sx) {
520 tty_update_mode(tty, tty->mode);
521 return;
522 }
523 tty_reset(tty);
524
525 tty_cursor(tty, ox + sx, oy + py);
526 if (screen_size_x(s) >= tty->sx && tty_term_has(tty->term, TTYC_EL))
527 tty_putcode(tty, TTYC_EL);
528 else {
529 for (i = sx; i < screen_size_x(s); i++)
530 tty_putc(tty, ' ');
531 }
532 tty_update_mode(tty, tty->mode);
533 }
534
535 void
536 tty_write(void (*cmdfn)(
537 struct tty *, const struct tty_ctx *), const struct tty_ctx *ctx)
538 {
539 struct window_pane *wp = ctx->wp;
540 struct client *c;
541 u_int i;
542
543 /* wp can be NULL if updating the screen but not the terminal. */
544 if (wp == NULL)
545 return;
546
547 if (wp->window->flags & WINDOW_REDRAW || wp->flags & PANE_REDRAW)
548 return;
549 if (!window_pane_visible(wp))
550 return;
551
552 for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
553 c = ARRAY_ITEM(&clients, i);
554 if (c == NULL || c->session == NULL)
555 continue;
556 if (c->flags & CLIENT_SUSPENDED)
557 continue;
558
559 if (c->session->curw->window == wp->window) {
560 if (c->tty.term == NULL)
561 continue;
562 if (c->tty.flags & (TTY_FREEZE|TTY_BACKOFF))
563 continue;
564 cmdfn(&c->tty, ctx);
565 }
566 }
567 }
568
569 void
570 tty_cmd_insertcharacter(struct tty *tty, const struct tty_ctx *ctx)
571 {
572 struct window_pane *wp = ctx->wp;
573 struct screen *s = wp->screen;
574 u_int i;
575
576 if (wp->xoff != 0 || screen_size_x(s) < tty->sx) {
577 tty_draw_line(tty, wp->screen, ctx->ocy, wp->xoff, wp->yoff);
578 return;
579 }
580
581 tty_reset(tty);
582
583 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
584
585 if (tty_term_has(tty->term, TTYC_ICH) ||
586 tty_term_has(tty->term, TTYC_ICH1))
587 tty_emulate_repeat(tty, TTYC_ICH, TTYC_ICH1, ctx->num);
588 else if (tty_term_has(tty->term, TTYC_SMIR) &&
589 tty_term_has(tty->term, TTYC_RMIR)) {
590 tty_putcode(tty, TTYC_SMIR);
591 for (i = 0; i < ctx->num; i++)
592 tty_putc(tty, ' ');
593 tty_putcode(tty, TTYC_RMIR);
594 } else
595 tty_draw_line(tty, wp->screen, ctx->ocy, wp->xoff, wp->yoff);
596 }
597
598 void
599 tty_cmd_deletecharacter(struct tty *tty, const struct tty_ctx *ctx)
600 {
601 struct window_pane *wp = ctx->wp;
602 struct screen *s = wp->screen;
603
604 if (wp->xoff != 0 || screen_size_x(s) < tty->sx ||
605 (!tty_term_has(tty->term, TTYC_DCH) &&
606 !tty_term_has(tty->term, TTYC_DCH1))) {
607 tty_draw_line(tty, wp->screen, ctx->ocy, wp->xoff, wp->yoff);
608 return;
609 }
610
611 tty_reset(tty);
612
613 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
614
615 if (tty_term_has(tty->term, TTYC_DCH) ||
616 tty_term_has(tty->term, TTYC_DCH1))
617 tty_emulate_repeat(tty, TTYC_DCH, TTYC_DCH1, ctx->num);
618 }
619
620 void
621 tty_cmd_insertline(struct tty *tty, const struct tty_ctx *ctx)
622 {
623 struct window_pane *wp = ctx->wp;
624 struct screen *s = wp->screen;
625
626 if (wp->xoff != 0 || screen_size_x(s) < tty->sx ||
627 !tty_term_has(tty->term, TTYC_CSR) ||
628 !tty_term_has(tty->term, TTYC_IL1)) {
629 tty_redraw_region(tty, ctx);
630 return;
631 }
632
633 tty_reset(tty);
634
635 tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
636 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
637
638 tty_emulate_repeat(tty, TTYC_IL, TTYC_IL1, ctx->num);
639 }
640
641 void
642 tty_cmd_deleteline(struct tty *tty, const struct tty_ctx *ctx)
643 {
644 struct window_pane *wp = ctx->wp;
645 struct screen *s = wp->screen;
646
647 if (wp->xoff != 0 || screen_size_x(s) < tty->sx ||
648 !tty_term_has(tty->term, TTYC_CSR) ||
649 !tty_term_has(tty->term, TTYC_DL1)) {
650 tty_redraw_region(tty, ctx);
651 return;
652 }
653
654 tty_reset(tty);
655
656 tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
657 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
658
659 tty_emulate_repeat(tty, TTYC_DL, TTYC_DL1, ctx->num);
660 }
661
662 void
663 tty_cmd_clearline(struct tty *tty, const struct tty_ctx *ctx)
664 {
665 struct window_pane *wp = ctx->wp;
666 struct screen *s = wp->screen;
667 u_int i;
668
669 tty_reset(tty);
670
671 tty_cursor_pane(tty, ctx, 0, ctx->ocy);
672
673 if (wp->xoff == 0 && screen_size_x(s) >= tty->sx &&
674 tty_term_has(tty->term, TTYC_EL)) {
675 tty_putcode(tty, TTYC_EL);
676 } else {
677 for (i = 0; i < screen_size_x(s); i++)
678 tty_putc(tty, ' ');
679 }
680 }
681
682 void
683 tty_cmd_clearendofline(struct tty *tty, const struct tty_ctx *ctx)
684 {
685 struct window_pane *wp = ctx->wp;
686 struct screen *s = wp->screen;
687 u_int i;
688
689 tty_reset(tty);
690
691 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
692
693 if (wp->xoff == 0 && screen_size_x(s) >= tty->sx &&
694 tty_term_has(tty->term, TTYC_EL))
695 tty_putcode(tty, TTYC_EL);
696 else {
697 for (i = ctx->ocx; i < screen_size_x(s); i++)
698 tty_putc(tty, ' ');
699 }
700 }
701
702 void
703 tty_cmd_clearstartofline(struct tty *tty, const struct tty_ctx *ctx)
704 {
705 struct window_pane *wp = ctx->wp;
706 u_int i;
707
708 tty_reset(tty);
709
710 if (wp->xoff == 0 && tty_term_has(tty->term, TTYC_EL1)) {
711 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
712 tty_putcode(tty, TTYC_EL1);
713 } else {
714 tty_cursor_pane(tty, ctx, 0, ctx->ocy);
715 for (i = 0; i < ctx->ocx + 1; i++)
716 tty_putc(tty, ' ');
717 }
718 }
719
720 void
721 tty_cmd_reverseindex(struct tty *tty, const struct tty_ctx *ctx)
722 {
723 struct window_pane *wp = ctx->wp;
724 struct screen *s = wp->screen;
725
726 if (ctx->ocy != ctx->orupper)
727 return;
728
729 if (wp->xoff != 0 || screen_size_x(s) < tty->sx ||
730 !tty_term_has(tty->term, TTYC_CSR) ||
731 !tty_term_has(tty->term, TTYC_RI)) {
732 tty_redraw_region(tty, ctx);
733 return;
734 }
735
736 tty_reset(tty);
737
738 tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
739 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->orupper);
740
741 tty_putcode(tty, TTYC_RI);
742 }
743
744 void
745 tty_cmd_linefeed(struct tty *tty, const struct tty_ctx *ctx)
746 {
747 struct window_pane *wp = ctx->wp;
748 struct screen *s = wp->screen;
749
750 if (ctx->ocy != ctx->orlower)
751 return;
752
753 if (wp->xoff != 0 || screen_size_x(s) < tty->sx ||
754 !tty_term_has(tty->term, TTYC_CSR)) {
755 tty_redraw_region(tty, ctx);
756 return;
757 }
758
759 /*
760 * If this line wrapped naturally (ctx->num is nonzero), don't do
761 * anything - the cursor can just be moved to the last cell and wrap
762 * naturally.
763 */
764 if (ctx->num && !(tty->term->flags & TERM_EARLYWRAP))
765 return;
766
767 tty_reset(tty);
768
769 tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
770 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
771
772 tty_putc(tty, '\n');
773 }
774
775 void
776 tty_cmd_clearendofscreen(struct tty *tty, const struct tty_ctx *ctx)
777 {
778 struct window_pane *wp = ctx->wp;
779 struct screen *s = wp->screen;
780 u_int i, j;
781
782 tty_reset(tty);
783
784 tty_region_pane(tty, ctx, 0, screen_size_y(s) - 1);
785 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
786
787 if (wp->xoff == 0 && screen_size_x(s) >= tty->sx &&
788 tty_term_has(tty->term, TTYC_EL)) {
789 tty_putcode(tty, TTYC_EL);
790 if (ctx->ocy != screen_size_y(s) - 1) {
791 tty_cursor_pane(tty, ctx, 0, ctx->ocy + 1);
792 for (i = ctx->ocy + 1; i < screen_size_y(s); i++) {
793 tty_putcode(tty, TTYC_EL);
794 if (i == screen_size_y(s) - 1)
795 continue;
796 tty_emulate_repeat(tty, TTYC_CUD, TTYC_CUD1, 1);
797 tty->cy++;
798 }
799 }
800 } else {
801 for (i = ctx->ocx; i < screen_size_x(s); i++)
802 tty_putc(tty, ' ');
803 for (j = ctx->ocy + 1; j < screen_size_y(s); j++) {
804 tty_cursor_pane(tty, ctx, 0, j);
805 for (i = 0; i < screen_size_x(s); i++)
806 tty_putc(tty, ' ');
807 }
808 }
809 }
810
811 void
812 tty_cmd_clearstartofscreen(struct tty *tty, const struct tty_ctx *ctx)
813 {
814 struct window_pane *wp = ctx->wp;
815 struct screen *s = wp->screen;
816 u_int i, j;
817
818 tty_reset(tty);
819
820 tty_region_pane(tty, ctx, 0, screen_size_y(s) - 1);
821 tty_cursor_pane(tty, ctx, 0, 0);
822
823 if (wp->xoff == 0 && screen_size_x(s) >= tty->sx &&
824 tty_term_has(tty->term, TTYC_EL)) {
825 for (i = 0; i < ctx->ocy; i++) {
826 tty_putcode(tty, TTYC_EL);
827 tty_emulate_repeat(tty, TTYC_CUD, TTYC_CUD1, 1);
828 tty->cy++;
829 }
830 } else {
831 for (j = 0; j < ctx->ocy; j++) {
832 tty_cursor_pane(tty, ctx, 0, j);
833 for (i = 0; i < screen_size_x(s); i++)
834 tty_putc(tty, ' ');
835 }
836 }
837 for (i = 0; i <= ctx->ocx; i++)
838 tty_putc(tty, ' ');
839 }
840
841 void
842 tty_cmd_clearscreen(struct tty *tty, const struct tty_ctx *ctx)
843 {
844 struct window_pane *wp = ctx->wp;
845 struct screen *s = wp->screen;
846 u_int i, j;
847
848 tty_reset(tty);
849
850 tty_region_pane(tty, ctx, 0, screen_size_y(s) - 1);
851 tty_cursor_pane(tty, ctx, 0, 0);
852
853 if (wp->xoff == 0 && screen_size_x(s) >= tty->sx &&
854 tty_term_has(tty->term, TTYC_EL)) {
855 for (i = 0; i < screen_size_y(s); i++) {
856 tty_putcode(tty, TTYC_EL);
857 if (i != screen_size_y(s) - 1) {
858 tty_emulate_repeat(tty, TTYC_CUD, TTYC_CUD1, 1);
859 tty->cy++;
860 }
861 }
862 } else {
863 for (j = 0; j < screen_size_y(s); j++) {
864 tty_cursor_pane(tty, ctx, 0, j);
865 for (i = 0; i < screen_size_x(s); i++)
866 tty_putc(tty, ' ');
867 }
868 }
869 }
870
871 void
872 tty_cmd_alignmenttest(struct tty *tty, const struct tty_ctx *ctx)
873 {
874 struct window_pane *wp = ctx->wp;
875 struct screen *s = wp->screen;
876 u_int i, j;
877
878 tty_reset(tty);
879
880 tty_region_pane(tty, ctx, 0, screen_size_y(s) - 1);
881
882 for (j = 0; j < screen_size_y(s); j++) {
883 tty_cursor_pane(tty, ctx, 0, j);
884 for (i = 0; i < screen_size_x(s); i++)
885 tty_putc(tty, 'E');
886 }
887 }
888
889 void
890 tty_cmd_cell(struct tty *tty, const struct tty_ctx *ctx)
891 {
892 struct window_pane *wp = ctx->wp;
893 struct screen *s = wp->screen;
894 u_int cx;
895 u_int width;
896 const struct grid_cell *gc = ctx->cell;
897 const struct grid_utf8 *gu = ctx->utf8;
898
899 if (gc->flags & GRID_FLAG_UTF8)
900 width = gu->width;
901 else
902 width = 1;
903
904 tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
905
906 /* Is the cursor in the very last position? */
907 if (ctx->ocx > wp->sx - width) {
908 if (wp->xoff != 0 || wp->sx != tty->sx) {
909 /*
910 * The pane doesn't fill the entire line, the linefeed
911 * will already have happened, so just move the cursor.
912 */
913 tty_cursor_pane(tty, ctx, 0, ctx->ocy + 1);
914 } else if (tty->cx < tty->sx) {
915 /*
916 * The cursor isn't in the last position already, so
917 * move as far left as possible and redraw the last
918 * cell to move into the last position.
919 */
920 cx = screen_size_x(s) - width;
921 tty_cursor_pane(tty, ctx, cx, ctx->ocy);
922 tty_cell(tty, &ctx->last_cell, &ctx->last_utf8);
923 }
924 } else
925 tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
926
927 tty_cell(tty, ctx->cell, ctx->utf8);
928 }
929
930 void
931 tty_cmd_utf8character(struct tty *tty, const struct tty_ctx *ctx)
932 {
933 struct window_pane *wp = ctx->wp;
934
935 /*
936 * Cannot rely on not being a partial character, so just redraw the
937 * whole line.
938 */
939 tty_draw_line(tty, wp->screen, ctx->ocy, wp->xoff, wp->yoff);
940 }
941
942 void
943 tty_cmd_rawstring(struct tty *tty, const struct tty_ctx *ctx)
944 {
945 u_int i;
946 u_char *str = ctx->ptr;
947
948 for (i = 0; i < ctx->num; i++)
949 tty_putc(tty, str[i]);
950 }
951
952 void
953 tty_cell(
954 struct tty *tty, const struct grid_cell *gc, const struct grid_utf8 *gu)
955 {
956 u_int i;
957
958 /* Skip last character if terminal is stupid. */
959 if (tty->term->flags & TERM_EARLYWRAP &&
960 tty->cy == tty->sy - 1 && tty->cx == tty->sx - 1)
961 return;
962
963 /* If this is a padding character, do nothing. */
964 if (gc->flags & GRID_FLAG_PADDING)
965 return;
966
967 /* Set the attributes. */
968 tty_attributes(tty, gc);
969
970 /* If not UTF-8, write directly. */
971 if (!(gc->flags & GRID_FLAG_UTF8)) {
972 if (gc->data < 0x20 || gc->data == 0x7f)
973 return;
974 tty_putc(tty, gc->data);
975 return;
976 }
977
978 /* If the terminal doesn't support UTF-8, write underscores. */
979 if (!(tty->flags & TTY_UTF8)) {
980 for (i = 0; i < gu->width; i++)
981 tty_putc(tty, '_');
982 return;
983 }
984
985 /* Otherwise, write UTF-8. */
986 tty_pututf8(tty, gu);
987 }
988
989 void
990 tty_reset(struct tty *tty)
991 {
992 struct grid_cell *gc = &tty->cell;
993
994 if (memcmp(gc, &grid_default_cell, sizeof *gc) == 0)
995 return;
996
997 if ((gc->attr & GRID_ATTR_CHARSET) && tty_use_acs(tty))
998 tty_putcode(tty, TTYC_RMACS);
999 tty_putcode(tty, TTYC_SGR0);
1000 memcpy(gc, &grid_default_cell, sizeof *gc);
1001 }
1002
1003 /* Set region inside pane. */
1004 void
1005 tty_region_pane(
1006 struct tty *tty, const struct tty_ctx *ctx, u_int rupper, u_int rlower)
1007 {
1008 struct window_pane *wp = ctx->wp;
1009
1010 tty_region(tty, wp->yoff + rupper, wp->yoff + rlower);
1011 }
1012
1013 /* Set region at absolute position. */
1014 void
1015 tty_region(struct tty *tty, u_int rupper, u_int rlower)
1016 {
1017 if (tty->rlower == rlower && tty->rupper == rupper)
1018 return;
1019 if (!tty_term_has(tty->term, TTYC_CSR))
1020 return;
1021
1022 tty->rupper = rupper;
1023 tty->rlower = rlower;
1024
1025 /*
1026 * Some terminals (such as PuTTY) do not correctly reset the cursor to
1027 * 0,0 if it is beyond the last column (they do not reset their wrap
1028 * flag so further output causes a line feed). As a workaround, do an
1029 * explicit move to 0 first.
1030 */
1031 if (tty->cx >= tty->sx)
1032 tty_cursor(tty, 0, tty->cy);
1033
1034 tty_putcode2(tty, TTYC_CSR, tty->rupper, tty->rlower);
1035 tty_cursor(tty, 0, 0);
1036 }
1037
1038 /* Move cursor inside pane. */
1039 void
1040 tty_cursor_pane(struct tty *tty, const struct tty_ctx *ctx, u_int cx, u_int cy)
1041 {
1042 struct window_pane *wp = ctx->wp;
1043
1044 tty_cursor(tty, wp->xoff + cx, wp->yoff + cy);
1045 }
1046
1047 /* Move cursor to absolute position. */
1048 void
1049 tty_cursor(struct tty *tty, u_int cx, u_int cy)
1050 {
1051 struct tty_term *term = tty->term;
1052 u_int thisx, thisy;
1053 int change;
1054
1055 if (cx > tty->sx - 1)
1056 cx = tty->sx - 1;
1057
1058 thisx = tty->cx;
1059 thisy = tty->cy;
1060
1061 /* No change. */
1062 if (cx == thisx && cy == thisy)
1063 return;
1064
1065 /* Very end of the line, just use absolute movement. */
1066 if (thisx > tty->sx - 1)
1067 goto absolute;
1068
1069 /* Move to home position (0, 0). */
1070 if (cx == 0 && cy == 0 && tty_term_has(term, TTYC_HOME)) {
1071 tty_putcode(tty, TTYC_HOME);
1072 goto out;
1073 }
1074
1075 /* Zero on the next line. */
1076 if (cx == 0 && cy == thisy + 1 && thisy != tty->rlower) {
1077 tty_putc(tty, '\r');
1078 tty_putc(tty, '\n');
1079 goto out;
1080 }
1081
1082 /* Moving column or row. */
1083 if (cy == thisy) {
1084 /*
1085 * Moving column only, row staying the same.
1086 */
1087
1088 /* To left edge. */
1089 if (cx == 0) {
1090 tty_putc(tty, '\r');
1091 goto out;
1092 }
1093
1094 /* One to the left. */
1095 if (cx == thisx - 1 && tty_term_has(term, TTYC_CUB1)) {
1096 tty_putcode(tty, TTYC_CUB1);
1097 goto out;
1098 }
1099
1100 /* One to the right. */
1101 if (cx == thisx + 1 && tty_term_has(term, TTYC_CUF1)) {
1102 tty_putcode(tty, TTYC_CUF1);
1103 goto out;
1104 }
1105
1106 /* Calculate difference. */
1107 change = thisx - cx; /* +ve left, -ve right */
1108
1109 /*
1110 * Use HPA if change is larger than absolute, otherwise move
1111 * the cursor with CUB/CUF.
1112 */
1113 if ((u_int) abs(change) > cx && tty_term_has(term, TTYC_HPA)) {
1114 tty_putcode1(tty, TTYC_HPA, cx);
1115 goto out;
1116 } else if (change > 0 && tty_term_has(term, TTYC_CUB)) {
1117 tty_putcode1(tty, TTYC_CUB, change);
1118 goto out;
1119 } else if (change < 0 && tty_term_has(term, TTYC_CUF)) {
1120 tty_putcode1(tty, TTYC_CUF, -change);
1121 goto out;
1122 }
1123 } else if (cx == thisx) {
1124 /*
1125 * Moving row only, column staying the same.
1126 */
1127
1128 /* One above. */
1129 if (thisy != tty->rupper &&
1130 cy == thisy - 1 && tty_term_has(term, TTYC_CUU1)) {
1131 tty_putcode(tty, TTYC_CUU1);
1132 goto out;
1133 }
1134
1135 /* One below. */
1136 if (thisy != tty->rlower &&
1137 cy == thisy + 1 && tty_term_has(term, TTYC_CUD1)) {
1138 tty_putcode(tty, TTYC_CUD1);
1139 goto out;
1140 }
1141
1142 /* Calculate difference. */
1143 change = thisy - cy; /* +ve up, -ve down */
1144
1145 /*
1146 * Try to use VPA if change is larger than absolute or if this
1147 * change would cross the scroll region, otherwise use CUU/CUD.
1148 */
1149 if ((u_int) abs(change) > cy ||
1150 (change < 0 && cy - change > tty->rlower) ||
1151 (change > 0 && cy - change < tty->rupper)) {
1152 if (tty_term_has(term, TTYC_VPA)) {
1153 tty_putcode1(tty, TTYC_VPA, cy);
1154 goto out;
1155 }
1156 } else if (change > 0 && tty_term_has(term, TTYC_CUU)) {
1157 tty_putcode1(tty, TTYC_CUU, change);
1158 goto out;
1159 } else if (change < 0 && tty_term_has(term, TTYC_CUD)) {
1160 tty_putcode1(tty, TTYC_CUD, -change);
1161 goto out;
1162 }
1163 }
1164
1165 absolute:
1166 /* Absolute movement. */
1167 tty_putcode2(tty, TTYC_CUP, cy, cx);
1168
1169 out:
1170 tty->cx = cx;
1171 tty->cy = cy;
1172 }
1173
1174 void
1175 tty_attributes(struct tty *tty, const struct grid_cell *gc)
1176 {
1177 struct grid_cell *tc = &tty->cell, gc2;
1178 u_char changed;
1179
1180 memcpy(&gc2, gc, sizeof gc2);
1181
1182 /*
1183 * If no setab, try to use the reverse attribute as a best-effort for a
1184 * non-default background. This is a bit of a hack but it doesn't do
1185 * any serious harm and makes a couple of applications happier.
1186 */
1187 if (!tty_term_has(tty->term, TTYC_SETAB)) {
1188 if (gc2.attr & GRID_ATTR_REVERSE) {
1189 if (gc2.fg != 7 && gc2.fg != 8)
1190 gc2.attr &= ~GRID_ATTR_REVERSE;
1191 } else {
1192 if (gc2.bg != 0 && gc2.bg != 8)
1193 gc2.attr |= GRID_ATTR_REVERSE;
1194 }
1195 }
1196
1197 /* Fix up the colours if necessary. */
1198 tty_check_fg(tty, &gc2);
1199 tty_check_bg(tty, &gc2);
1200
1201 /* If any bits are being cleared, reset everything. */
1202 if (tc->attr & ~gc2.attr)
1203 tty_reset(tty);
1204
1205 /*
1206 * Set the colours. This may call tty_reset() (so it comes next) and
1207 * may add to (NOT remove) the desired attributes by changing new_attr.
1208 */
1209 tty_colours(tty, &gc2);
1210
1211 /* Filter out attribute bits already set. */
1212 changed = gc2.attr & ~tc->attr;
1213 tc->attr = gc2.attr;
1214
1215 /* Set the attributes. */
1216 if (changed & GRID_ATTR_BRIGHT)
1217 tty_putcode(tty, TTYC_BOLD);
1218 if (changed & GRID_ATTR_DIM)
1219 tty_putcode(tty, TTYC_DIM);
1220 if (changed & GRID_ATTR_ITALICS)
1221 tty_putcode(tty, TTYC_SMSO);
1222 if (changed & GRID_ATTR_UNDERSCORE)
1223 tty_putcode(tty, TTYC_SMUL);
1224 if (changed & GRID_ATTR_BLINK)
1225 tty_putcode(tty, TTYC_BLINK);
1226 if (changed & GRID_ATTR_REVERSE) {
1227 if (tty_term_has(tty->term, TTYC_REV))
1228 tty_putcode(tty, TTYC_REV);
1229 else if (tty_term_has(tty->term, TTYC_SMSO))
1230 tty_putcode(tty, TTYC_SMSO);
1231 }
1232 if (changed & GRID_ATTR_HIDDEN)
1233 tty_putcode(tty, TTYC_INVIS);
1234 if ((changed & GRID_ATTR_CHARSET) && tty_use_acs(tty))
1235 tty_putcode(tty, TTYC_SMACS);
1236 }
1237
1238 void
1239 tty_colours(struct tty *tty, const struct grid_cell *gc)
1240 {
1241 struct grid_cell *tc = &tty->cell;
1242 u_char fg = gc->fg, bg = gc->bg, flags = gc->flags;
1243 int have_ax, fg_default, bg_default;
1244
1245 /* No changes? Nothing is necessary. */
1246 if (fg == tc->fg && bg == tc->bg &&
1247 ((flags ^ tc->flags) & (GRID_FLAG_FG256|GRID_FLAG_BG256)) == 0)
1248 return;
1249
1250 /*
1251 * Is either the default colour? This is handled specially because the
1252 * best solution might be to reset both colours to default, in which
1253 * case if only one is default need to fall onward to set the other
1254 * colour.
1255 */
1256 fg_default = (fg == 8 && !(flags & GRID_FLAG_FG256));
1257 bg_default = (bg == 8 && !(flags & GRID_FLAG_BG256));
1258 if (fg_default || bg_default) {
1259 /*
1260 * If don't have AX but do have op, send sgr0 (op can't
1261 * actually be used because it is sometimes the same as sgr0
1262 * and sometimes isn't). This resets both colours to default.
1263 *
1264 * Otherwise, try to set the default colour only as needed.
1265 */
1266 have_ax = tty_term_has(tty->term, TTYC_AX);
1267 if (!have_ax && tty_term_has(tty->term, TTYC_OP))
1268 tty_reset(tty);
1269 else {
1270 if (fg_default &&
1271 (tc->fg != 8 || tc->flags & GRID_FLAG_FG256)) {
1272 if (have_ax)
1273 tty_puts(tty, "\033[39m");
1274 else if (tc->fg != 7 ||
1275 tc->flags & GRID_FLAG_FG256)
1276 tty_putcode1(tty, TTYC_SETAF, 7);
1277 tc->fg = 8;
1278 tc->flags &= ~GRID_FLAG_FG256;
1279 }
1280 if (bg_default &&
1281 (tc->bg != 8 || tc->flags & GRID_FLAG_BG256)) {
1282 if (have_ax)
1283 tty_puts(tty, "\033[49m");
1284 else if (tc->bg != 0 ||
1285 tc->flags & GRID_FLAG_BG256)
1286 tty_putcode1(tty, TTYC_SETAB, 0);
1287 tc->bg = 8;
1288 tc->flags &= ~GRID_FLAG_BG256;
1289 }
1290 }
1291 }
1292
1293 /* Set the foreground colour. */
1294 if (!fg_default && (fg != tc->fg ||
1295 ((flags & GRID_FLAG_FG256) != (tc->flags & GRID_FLAG_FG256))))
1296 tty_colours_fg(tty, gc);
1297
1298 /*
1299 * Set the background colour. This must come after the foreground as
1300 * tty_colour_fg() can call tty_reset().
1301 */
1302 if (!bg_default && (bg != tc->bg ||
1303 ((flags & GRID_FLAG_BG256) != (tc->flags & GRID_FLAG_BG256))))
1304 tty_colours_bg(tty, gc);
1305 }
1306
1307 void
1308 tty_check_fg(struct tty *tty, struct grid_cell *gc)
1309 {
1310 u_int colours;
1311
1312 /* Is this a 256-colour colour? */
1313 if (gc->flags & GRID_FLAG_FG256) {
1314 /* And not a 256 colour mode? */
1315 if (!(tty->term->flags & TERM_88COLOURS) &&
1316 !(tty->term_flags & TERM_88COLOURS) &&
1317 !(tty->term->flags & TERM_256COLOURS) &&
1318 !(tty->term_flags & TERM_256COLOURS)) {
1319 gc->fg = colour_256to16(gc->fg);
1320 if (gc->fg & 8) {
1321 gc->fg &= 7;
1322 gc->attr |= GRID_ATTR_BRIGHT;
1323 } else
1324 gc->attr &= ~GRID_ATTR_BRIGHT;
1325 gc->flags &= ~GRID_FLAG_FG256;
1326 }
1327 return;
1328 }
1329
1330 /* Is this an aixterm colour? */
1331 colours = tty_term_number(tty->term, TTYC_COLORS);
1332 if (gc->fg >= 90 && gc->fg <= 97 && colours < 16) {
1333 gc->fg -= 90;
1334 gc->attr |= GRID_ATTR_BRIGHT;
1335 }
1336 }
1337
1338 void
1339 tty_check_bg(struct tty *tty, struct grid_cell *gc)
1340 {
1341 u_int colours;
1342
1343 /* Is this a 256-colour colour? */
1344 if (gc->flags & GRID_FLAG_BG256) {
1345 /*
1346 * And not a 256 colour mode? Translate to 16-colour
1347 * palette. Bold background doesn't exist portably, so just
1348 * discard the bold bit if set.
1349 */
1350 if (!(tty->term->flags & TERM_88COLOURS) &&
1351 !(tty->term_flags & TERM_88COLOURS) &&
1352 !(tty->term->flags & TERM_256COLOURS) &&
1353 !(tty->term_flags & TERM_256COLOURS)) {
1354 gc->bg = colour_256to16(gc->bg);
1355 if (gc->bg & 8)
1356 gc->bg &= 7;
1357 gc->attr &= ~GRID_ATTR_BRIGHT;
1358 gc->flags &= ~GRID_FLAG_BG256;
1359 }
1360 return;
1361 }
1362
1363 /* Is this an aixterm colour? */
1364 colours = tty_term_number(tty->term, TTYC_COLORS);
1365 if (gc->bg >= 100 && gc->bg <= 107 && colours < 16) {
1366 gc->bg -= 90;
1367 gc->attr |= GRID_ATTR_BRIGHT;
1368 }
1369 }
1370
1371 void
1372 tty_colours_fg(struct tty *tty, const struct grid_cell *gc)
1373 {
1374 struct grid_cell *tc = &tty->cell;
1375 u_char fg = gc->fg;
1376 char s[32];
1377
1378 /* Is this a 256-colour colour? */
1379 if (gc->flags & GRID_FLAG_FG256) {
1380 /* Try as 256 colours or translating to 88. */
1381 if (tty_try_256(tty, fg, "38") == 0)
1382 goto save_fg;
1383 if (tty_try_88(tty, fg, "38") == 0)
1384 goto save_fg;
1385 /* Else already handled by tty_check_fg. */
1386 return;
1387 }
1388
1389 /* Is this an aixterm bright colour? */
1390 if (fg >= 90 && fg <= 97) {
1391 xsnprintf(s, sizeof s, "\033[%dm", fg);
1392 tty_puts(tty, s);
1393 goto save_fg;
1394 }
1395
1396 /* Otherwise set the foreground colour. */
1397 tty_putcode1(tty, TTYC_SETAF, fg);
1398
1399 save_fg:
1400 /* Save the new values in the terminal current cell. */
1401 tc->fg = fg;
1402 tc->flags &= ~GRID_FLAG_FG256;
1403 tc->flags |= gc->flags & GRID_FLAG_FG256;
1404 }
1405
1406 void
1407 tty_colours_bg(struct tty *tty, const struct grid_cell *gc)
1408 {
1409 struct grid_cell *tc = &tty->cell;
1410 u_char bg = gc->bg;
1411 char s[32];
1412
1413 /* Is this a 256-colour colour? */
1414 if (gc->flags & GRID_FLAG_BG256) {
1415 /* Try as 256 colours or translating to 88. */
1416 if (tty_try_256(tty, bg, "48") == 0)
1417 goto save_bg;
1418 if (tty_try_88(tty, bg, "48") == 0)
1419 goto save_bg;
1420 /* Else already handled by tty_check_bg. */
1421 return;
1422 }
1423
1424 /* Is this an aixterm bright colour? */
1425 if (bg >= 100 && bg <= 107) {
1426 /* 16 colour terminals or above only. */
1427 if (tty_term_number(tty->term, TTYC_COLORS) >= 16) {
1428 xsnprintf(s, sizeof s, "\033[%dm", bg);
1429 tty_puts(tty, s);
1430 goto save_bg;
1431 }
1432 bg -= 100;
1433 /* no such thing as a bold background */
1434 }
1435
1436 /* Otherwise set the background colour. */
1437 tty_putcode1(tty, TTYC_SETAB, bg);
1438
1439 save_bg:
1440 /* Save the new values in the terminal current cell. */
1441 tc->bg = bg;
1442 tc->flags &= ~GRID_FLAG_BG256;
1443 tc->flags |= gc->flags & GRID_FLAG_BG256;
1444 }
1445
1446 int
1447 tty_try_256(struct tty *tty, u_char colour, const char *type)
1448 {
1449 char s[32];
1450
1451 if (!(tty->term->flags & TERM_256COLOURS) &&
1452 !(tty->term_flags & TERM_256COLOURS))
1453 return (-1);
1454
1455 xsnprintf(s, sizeof s, "\033[%s;5;%hhum", type, colour);
1456 tty_puts(tty, s);
1457 return (0);
1458 }
1459
1460 int
1461 tty_try_88(struct tty *tty, u_char colour, const char *type)
1462 {
1463 char s[32];
1464
1465 if (!(tty->term->flags & TERM_88COLOURS) &&
1466 !(tty->term_flags & TERM_88COLOURS))
1467 return (-1);
1468 colour = colour_256to88(colour);
1469
1470 xsnprintf(s, sizeof s, "\033[%s;5;%hhum", type, colour);
1471 tty_puts(tty, s);
1472 return (0);
1473 }