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