4 * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
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.
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.
19 #include <sys/types.h>
20 #include <sys/ioctl.h>
31 void tty_read_callback(struct bufferevent
*, void *);
32 void tty_error_callback(struct bufferevent
*, short, void *);
34 int tty_try_256(struct tty
*, u_char
, const char *);
35 int tty_try_88(struct tty
*, u_char
, const char *);
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
*);
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
*);
49 #define tty_use_acs(tty) \
50 (tty_term_has(tty->term, TTYC_ACSC) && !((tty)->flags & TTY_UTF8))
53 tty_init(struct tty
*tty
, int fd
, char *term
)
57 memset(tty
, 0, sizeof *tty
);
60 if (term
== NULL
|| *term
== '\0')
61 tty
->termname
= xstrdup("unknown");
63 tty
->termname
= xstrdup(term
);
66 if ((path
= ttyname(fd
)) == NULL
)
67 fatalx("ttyname failed");
68 tty
->path
= xstrdup(path
);
75 tty_resize(struct tty
*tty
)
80 if (ioctl(tty
->fd
, TIOCGWINSZ
, &ws
) != -1) {
91 if (sx
== tty
->sx
&& sy
== tty
->sy
)
99 tty
->rupper
= UINT_MAX
;
100 tty
->rlower
= UINT_MAX
;
103 * If the terminal has been started, reset the actual scroll region and
104 * cursor position, as this may not have happened.
106 if (tty
->flags
& TTY_STARTED
) {
107 tty_cursor(tty
, 0, 0);
108 tty_region(tty
, 0, tty
->sy
- 1);
115 tty_open(struct tty
*tty
, const char *overrides
, char **cause
)
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");
128 tty
->term
= tty_term_find(tty
->termname
, tty
->fd
, overrides
, cause
);
129 if (tty
->term
== NULL
) {
133 tty
->flags
|= TTY_OPENED
;
135 tty
->flags
&= ~(TTY_NOCURSOR
|TTY_FREEZE
|TTY_ESCAPE
);
137 tty
->event
= bufferevent_new(
138 tty
->fd
, tty_read_callback
, NULL
, tty_error_callback
, tty
);
149 tty_read_callback(unused
struct bufferevent
*bufev
, void *data
)
151 struct tty
*tty
= data
;
153 while (tty_keys_next(tty
))
160 unused
struct bufferevent
*bufev
, unused
short what
, unused
void *data
)
165 tty_start_tty(struct tty
*tty
)
173 if ((mode
= fcntl(tty
->fd
, F_GETFL
)) == -1)
174 fatal("fcntl failed");
175 if (fcntl(tty
->fd
, F_SETFL
, mode
|O_NONBLOCK
) == -1)
176 fatal("fcntl failed");
178 bufferevent_enable(tty
->event
, EV_READ
|EV_WRITE
);
180 if (tcgetattr(tty
->fd
, &tty
->tio
) != 0)
181 fatal("tcgetattr failed");
182 memcpy(&tio
, &tty
->tio
, sizeof tio
);
183 tio
.c_iflag
&= ~(IXON
|IXOFF
|ICRNL
|INLCR
|IGNCR
|IMAXBEL
|ISTRIP
);
184 tio
.c_iflag
|= IGNBRK
;
185 tio
.c_oflag
&= ~(OPOST
|ONLCR
|OCRNL
|ONLRET
);
186 tio
.c_lflag
&= ~(IEXTEN
|ICANON
|ECHO
|ECHOE
|ECHONL
|ECHOCTL
|
187 ECHOPRT
|ECHOKE
|ECHOCTL
|ISIG
);
190 if (tcsetattr(tty
->fd
, TCSANOW
, &tio
) != 0)
191 fatal("tcsetattr failed");
192 tcflush(tty
->fd
, TCIOFLUSH
);
194 tty_putcode(tty
, TTYC_SMCUP
);
196 tty_putcode(tty
, TTYC_SGR0
);
197 memcpy(&tty
->cell
, &grid_default_cell
, sizeof tty
->cell
);
199 tty_putcode(tty
, TTYC_RMKX
);
200 if (tty_use_acs(tty
))
201 tty_putcode(tty
, TTYC_ENACS
);
202 tty_putcode(tty
, TTYC_CLEAR
);
204 tty_putcode(tty
, TTYC_CNORM
);
205 if (tty_term_has(tty
->term
, TTYC_KMOUS
))
206 tty_puts(tty
, "\033[?1000l");
211 tty
->rlower
= UINT_MAX
;
212 tty
->rupper
= UINT_MAX
;
214 tty
->mode
= MODE_CURSOR
;
216 tty
->flags
|= TTY_STARTED
;
220 tty_stop_tty(struct tty
*tty
)
225 if (!(tty
->flags
& TTY_STARTED
))
227 tty
->flags
&= ~TTY_STARTED
;
229 bufferevent_disable(tty
->event
, EV_READ
|EV_WRITE
);
232 * Be flexible about error handling and try not kill the server just
233 * because the fd is invalid. Things like ssh -t can easily leave us
236 if (ioctl(tty
->fd
, TIOCGWINSZ
, &ws
) == -1)
238 if (tcsetattr(tty
->fd
, TCSANOW
, &tty
->tio
) == -1)
241 tty_raw(tty
, tty_term_string2(tty
->term
, TTYC_CSR
, 0, ws
.ws_row
- 1));
242 if (tty_use_acs(tty
))
243 tty_raw(tty
, tty_term_string(tty
->term
, TTYC_RMACS
));
244 tty_raw(tty
, tty_term_string(tty
->term
, TTYC_SGR0
));
245 tty_raw(tty
, tty_term_string(tty
->term
, TTYC_RMKX
));
246 tty_raw(tty
, tty_term_string(tty
->term
, TTYC_CLEAR
));
248 tty_raw(tty
, tty_term_string(tty
->term
, TTYC_CNORM
));
249 if (tty_term_has(tty
->term
, TTYC_KMOUS
))
250 tty_raw(tty
, "\033[?1000l");
252 tty_raw(tty
, tty_term_string(tty
->term
, TTYC_RMCUP
));
254 if ((mode
= fcntl(tty
->fd
, F_GETFL
)) != -1)
255 fcntl(tty
->fd
, F_SETFL
, mode
& ~O_NONBLOCK
);
259 tty_close(struct tty
*tty
)
261 if (tty
->log_fd
!= -1) {
266 evtimer_del(&tty
->key_timer
);
269 if (tty
->flags
& TTY_OPENED
) {
270 bufferevent_free(tty
->event
);
272 tty_term_free(tty
->term
);
275 tty
->flags
&= ~TTY_OPENED
;
285 tty_free(struct tty
*tty
)
289 if (tty
->path
!= NULL
)
291 if (tty
->termname
!= NULL
)
292 xfree(tty
->termname
);
296 tty_raw(struct tty
*tty
, const char *s
)
298 write(tty
->fd
, s
, strlen(s
));
302 tty_putcode(struct tty
*tty
, enum tty_code_code code
)
304 tty_puts(tty
, tty_term_string(tty
->term
, code
));
308 tty_putcode1(struct tty
*tty
, enum tty_code_code code
, int a
)
312 tty_puts(tty
, tty_term_string1(tty
->term
, code
, a
));
316 tty_putcode2(struct tty
*tty
, enum tty_code_code code
, int a
, int b
)
320 tty_puts(tty
, tty_term_string2(tty
->term
, code
, a
, b
));
324 tty_puts(struct tty
*tty
, const char *s
)
328 bufferevent_write(tty
->event
, s
, strlen(s
));
330 if (tty
->log_fd
!= -1)
331 write(tty
->log_fd
, s
, strlen(s
));
335 tty_putc(struct tty
*tty
, u_char ch
)
340 if (tty
->cell
.attr
& GRID_ATTR_CHARSET
) {
341 acs
= tty_acs_get(tty
, ch
);
343 bufferevent_write(tty
->event
, acs
, strlen(acs
));
345 bufferevent_write(tty
->event
, &ch
, 1);
347 bufferevent_write(tty
->event
, &ch
, 1);
349 if (ch
>= 0x20 && ch
!= 0x7f) {
351 if (tty
->term
->flags
& TERM_EARLYWRAP
)
356 if (tty
->cy
!= tty
->rlower
)
362 if (tty
->log_fd
!= -1)
363 write(tty
->log_fd
, &ch
, 1);
367 tty_pututf8(struct tty
*tty
, const struct grid_utf8
*gu
)
371 size
= grid_utf8_size(gu
);
372 bufferevent_write(tty
->event
, gu
->data
, size
);
373 if (tty
->log_fd
!= -1)
374 write(tty
->log_fd
, gu
->data
, size
);
375 tty
->cx
+= gu
->width
;
379 tty_set_title(struct tty
*tty
, const char *title
)
381 if (strstr(tty
->termname
, "xterm") == NULL
&&
382 strstr(tty
->termname
, "rxvt") == NULL
&&
383 strcmp(tty
->termname
, "screen") != 0)
386 tty_puts(tty
, "\033]0;");
387 tty_puts(tty
, title
);
388 tty_putc(tty
, '\007');
392 tty_update_mode(struct tty
*tty
, int mode
)
396 if (tty
->flags
& TTY_NOCURSOR
)
397 mode
&= ~MODE_CURSOR
;
399 changed
= mode
^ tty
->mode
;
400 if (changed
& MODE_CURSOR
) {
401 if (mode
& MODE_CURSOR
)
402 tty_putcode(tty
, TTYC_CNORM
);
404 tty_putcode(tty
, TTYC_CIVIS
);
406 if (changed
& ALL_MOUSE_MODES
) {
407 if (mode
& ALL_MOUSE_MODES
) {
408 if (mode
& MODE_MOUSE_STANDARD
)
409 tty_puts(tty
, "\033[?1000h");
410 else if (mode
& MODE_MOUSE_HIGHLIGHT
)
411 tty_puts(tty
, "\033[?1001h");
412 else if (mode
& MODE_MOUSE_BUTTON
)
413 tty_puts(tty
, "\033[?1002h");
414 else if (mode
& MODE_MOUSE_ANY
)
415 tty_puts(tty
, "\033[?1003h");
417 if (tty
->mode
& MODE_MOUSE_STANDARD
)
418 tty_puts(tty
, "\033[?1000l");
419 else if (tty
->mode
& MODE_MOUSE_HIGHLIGHT
)
420 tty_puts(tty
, "\033[?1001l");
421 else if (tty
->mode
& MODE_MOUSE_BUTTON
)
422 tty_puts(tty
, "\033[?1002l");
423 else if (tty
->mode
& MODE_MOUSE_ANY
)
424 tty_puts(tty
, "\033[?1003l");
427 if (changed
& MODE_KKEYPAD
) {
428 if (mode
& MODE_KKEYPAD
)
429 tty_putcode(tty
, TTYC_SMKX
);
431 tty_putcode(tty
, TTYC_RMKX
);
438 struct tty
*tty
, enum tty_code_code code
, enum tty_code_code code1
, u_int n
)
440 if (tty_term_has(tty
->term
, code
))
441 tty_putcode1(tty
, code
, n
);
444 tty_putcode(tty
, code1
);
449 * Redraw scroll region using data from screen (already updated). Used when
450 * CSR not supported, or window is a pane that doesn't take up the full
451 * width of the terminal.
454 tty_redraw_region(struct tty
*tty
, const struct tty_ctx
*ctx
)
456 struct window_pane
*wp
= ctx
->wp
;
457 struct screen
*s
= wp
->screen
;
461 * If region is >= 50% of the screen, just schedule a window redraw. In
462 * most cases, this is likely to be followed by some more scrolling -
463 * without this, the entire pane ends up being redrawn many times which
464 * can be much more data.
466 if (ctx
->orupper
- ctx
->orlower
>= screen_size_y(s
) / 2) {
467 wp
->flags
|= PANE_REDRAW
;
471 if (ctx
->ocy
< ctx
->orupper
|| ctx
->ocy
> ctx
->orlower
) {
472 for (i
= ctx
->ocy
; i
< screen_size_y(s
); i
++)
473 tty_draw_line(tty
, s
, i
, wp
->xoff
, wp
->yoff
);
475 for (i
= ctx
->orupper
; i
<= ctx
->orlower
; i
++)
476 tty_draw_line(tty
, s
, i
, wp
->xoff
, wp
->yoff
);
481 tty_draw_line(struct tty
*tty
, struct screen
*s
, u_int py
, u_int ox
, u_int oy
)
483 const struct grid_cell
*gc
;
484 struct grid_line
*gl
;
485 struct grid_cell tmpgc
;
486 const struct grid_utf8
*gu
;
489 tty_update_mode(tty
, tty
->mode
& ~MODE_CURSOR
);
491 sx
= screen_size_x(s
);
492 if (sx
> s
->grid
->linedata
[s
->grid
->hsize
+ py
].cellsize
)
493 sx
= s
->grid
->linedata
[s
->grid
->hsize
+ py
].cellsize
;
498 * Don't move the cursor to the start permission if it will wrap there
503 gl
= &s
->grid
->linedata
[s
->grid
->hsize
+ py
- 1];
504 if (oy
+ py
== 0 || gl
== NULL
|| !(gl
->flags
& GRID_LINE_WRAPPED
) ||
505 tty
->cx
< tty
->sx
|| ox
!= 0 ||
506 (oy
+ py
!= tty
->cy
+ 1 && tty
->cy
!= s
->rlower
+ oy
))
507 tty_cursor(tty
, ox
, oy
+ py
);
509 for (i
= 0; i
< sx
; i
++) {
510 gc
= grid_view_peek_cell(s
->grid
, i
, py
);
513 if (gc
->flags
& GRID_FLAG_UTF8
)
514 gu
= grid_view_peek_utf8(s
->grid
, i
, py
);
516 if (screen_check_selection(s
, i
, py
)) {
517 memcpy(&tmpgc
, &s
->sel
.cell
, sizeof tmpgc
);
518 tmpgc
.data
= gc
->data
;
519 tmpgc
.flags
= gc
->flags
&
520 ~(GRID_FLAG_FG256
|GRID_FLAG_BG256
);
521 tmpgc
.flags
|= s
->sel
.cell
.flags
&
522 (GRID_FLAG_FG256
|GRID_FLAG_BG256
);
523 tty_cell(tty
, &tmpgc
, gu
);
525 tty_cell(tty
, gc
, gu
);
529 tty_update_mode(tty
, tty
->mode
);
534 tty_cursor(tty
, ox
+ sx
, oy
+ py
);
535 if (screen_size_x(s
) >= tty
->sx
&& tty_term_has(tty
->term
, TTYC_EL
))
536 tty_putcode(tty
, TTYC_EL
);
538 for (i
= sx
; i
< screen_size_x(s
); i
++)
541 tty_update_mode(tty
, tty
->mode
);
545 tty_write(void (*cmdfn
)(
546 struct tty
*, const struct tty_ctx
*), const struct tty_ctx
*ctx
)
548 struct window_pane
*wp
= ctx
->wp
;
552 /* wp can be NULL if updating the screen but not the terminal. */
556 if (wp
->window
->flags
& WINDOW_REDRAW
|| wp
->flags
& PANE_REDRAW
)
558 if (!window_pane_visible(wp
))
561 for (i
= 0; i
< ARRAY_LENGTH(&clients
); i
++) {
562 c
= ARRAY_ITEM(&clients
, i
);
563 if (c
== NULL
|| c
->session
== NULL
)
565 if (c
->flags
& CLIENT_SUSPENDED
)
568 if (c
->session
->curw
->window
== wp
->window
) {
569 if (c
->tty
.term
== NULL
)
571 if (c
->tty
.flags
& (TTY_FREEZE
|TTY_BACKOFF
))
579 tty_cmd_insertcharacter(struct tty
*tty
, const struct tty_ctx
*ctx
)
581 struct window_pane
*wp
= ctx
->wp
;
582 struct screen
*s
= wp
->screen
;
585 if (wp
->xoff
!= 0 || screen_size_x(s
) < tty
->sx
) {
586 tty_draw_line(tty
, wp
->screen
, ctx
->ocy
, wp
->xoff
, wp
->yoff
);
592 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->ocy
);
594 if (tty_term_has(tty
->term
, TTYC_ICH
) ||
595 tty_term_has(tty
->term
, TTYC_ICH1
))
596 tty_emulate_repeat(tty
, TTYC_ICH
, TTYC_ICH1
, ctx
->num
);
597 else if (tty_term_has(tty
->term
, TTYC_SMIR
) &&
598 tty_term_has(tty
->term
, TTYC_RMIR
)) {
599 tty_putcode(tty
, TTYC_SMIR
);
600 for (i
= 0; i
< ctx
->num
; i
++)
602 tty_putcode(tty
, TTYC_RMIR
);
604 tty_draw_line(tty
, wp
->screen
, ctx
->ocy
, wp
->xoff
, wp
->yoff
);
608 tty_cmd_deletecharacter(struct tty
*tty
, const struct tty_ctx
*ctx
)
610 struct window_pane
*wp
= ctx
->wp
;
611 struct screen
*s
= wp
->screen
;
613 if (wp
->xoff
!= 0 || screen_size_x(s
) < tty
->sx
||
614 (!tty_term_has(tty
->term
, TTYC_DCH
) &&
615 !tty_term_has(tty
->term
, TTYC_DCH1
))) {
616 tty_draw_line(tty
, wp
->screen
, ctx
->ocy
, wp
->xoff
, wp
->yoff
);
622 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->ocy
);
624 if (tty_term_has(tty
->term
, TTYC_DCH
) ||
625 tty_term_has(tty
->term
, TTYC_DCH1
))
626 tty_emulate_repeat(tty
, TTYC_DCH
, TTYC_DCH1
, ctx
->num
);
630 tty_cmd_insertline(struct tty
*tty
, const struct tty_ctx
*ctx
)
632 struct window_pane
*wp
= ctx
->wp
;
633 struct screen
*s
= wp
->screen
;
635 if (wp
->xoff
!= 0 || screen_size_x(s
) < tty
->sx
||
636 !tty_term_has(tty
->term
, TTYC_CSR
) ||
637 !tty_term_has(tty
->term
, TTYC_IL1
)) {
638 tty_redraw_region(tty
, ctx
);
644 tty_region_pane(tty
, ctx
, ctx
->orupper
, ctx
->orlower
);
645 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->ocy
);
647 tty_emulate_repeat(tty
, TTYC_IL
, TTYC_IL1
, ctx
->num
);
651 tty_cmd_deleteline(struct tty
*tty
, const struct tty_ctx
*ctx
)
653 struct window_pane
*wp
= ctx
->wp
;
654 struct screen
*s
= wp
->screen
;
656 if (wp
->xoff
!= 0 || screen_size_x(s
) < tty
->sx
||
657 !tty_term_has(tty
->term
, TTYC_CSR
) ||
658 !tty_term_has(tty
->term
, TTYC_DL1
)) {
659 tty_redraw_region(tty
, ctx
);
665 tty_region_pane(tty
, ctx
, ctx
->orupper
, ctx
->orlower
);
666 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->ocy
);
668 tty_emulate_repeat(tty
, TTYC_DL
, TTYC_DL1
, ctx
->num
);
672 tty_cmd_clearline(struct tty
*tty
, const struct tty_ctx
*ctx
)
674 struct window_pane
*wp
= ctx
->wp
;
675 struct screen
*s
= wp
->screen
;
680 tty_cursor_pane(tty
, ctx
, 0, ctx
->ocy
);
682 if (wp
->xoff
== 0 && screen_size_x(s
) >= tty
->sx
&&
683 tty_term_has(tty
->term
, TTYC_EL
)) {
684 tty_putcode(tty
, TTYC_EL
);
686 for (i
= 0; i
< screen_size_x(s
); i
++)
692 tty_cmd_clearendofline(struct tty
*tty
, const struct tty_ctx
*ctx
)
694 struct window_pane
*wp
= ctx
->wp
;
695 struct screen
*s
= wp
->screen
;
700 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->ocy
);
702 if (wp
->xoff
== 0 && screen_size_x(s
) >= tty
->sx
&&
703 tty_term_has(tty
->term
, TTYC_EL
))
704 tty_putcode(tty
, TTYC_EL
);
706 for (i
= ctx
->ocx
; i
< screen_size_x(s
); i
++)
712 tty_cmd_clearstartofline(struct tty
*tty
, const struct tty_ctx
*ctx
)
714 struct window_pane
*wp
= ctx
->wp
;
719 if (wp
->xoff
== 0 && tty_term_has(tty
->term
, TTYC_EL1
)) {
720 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->ocy
);
721 tty_putcode(tty
, TTYC_EL1
);
723 tty_cursor_pane(tty
, ctx
, 0, ctx
->ocy
);
724 for (i
= 0; i
< ctx
->ocx
+ 1; i
++)
730 tty_cmd_reverseindex(struct tty
*tty
, const struct tty_ctx
*ctx
)
732 struct window_pane
*wp
= ctx
->wp
;
733 struct screen
*s
= wp
->screen
;
735 if (ctx
->ocy
!= ctx
->orupper
)
738 if (wp
->xoff
!= 0 || screen_size_x(s
) < tty
->sx
||
739 !tty_term_has(tty
->term
, TTYC_CSR
) ||
740 !tty_term_has(tty
->term
, TTYC_RI
)) {
741 tty_redraw_region(tty
, ctx
);
747 tty_region_pane(tty
, ctx
, ctx
->orupper
, ctx
->orlower
);
748 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->orupper
);
750 tty_putcode(tty
, TTYC_RI
);
754 tty_cmd_linefeed(struct tty
*tty
, const struct tty_ctx
*ctx
)
756 struct window_pane
*wp
= ctx
->wp
;
757 struct screen
*s
= wp
->screen
;
759 if (ctx
->ocy
!= ctx
->orlower
)
762 if (wp
->xoff
!= 0 || screen_size_x(s
) < tty
->sx
||
763 !tty_term_has(tty
->term
, TTYC_CSR
)) {
764 tty_redraw_region(tty
, ctx
);
769 * If this line wrapped naturally (ctx->num is nonzero), don't do
770 * anything - the cursor can just be moved to the last cell and wrap
773 if (ctx
->num
&& !(tty
->term
->flags
& TERM_EARLYWRAP
))
778 tty_region_pane(tty
, ctx
, ctx
->orupper
, ctx
->orlower
);
779 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->ocy
);
785 tty_cmd_clearendofscreen(struct tty
*tty
, const struct tty_ctx
*ctx
)
787 struct window_pane
*wp
= ctx
->wp
;
788 struct screen
*s
= wp
->screen
;
793 tty_region_pane(tty
, ctx
, 0, screen_size_y(s
) - 1);
794 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->ocy
);
796 if (wp
->xoff
== 0 && screen_size_x(s
) >= tty
->sx
&&
797 tty_term_has(tty
->term
, TTYC_EL
)) {
798 tty_putcode(tty
, TTYC_EL
);
799 if (ctx
->ocy
!= screen_size_y(s
) - 1) {
800 tty_cursor_pane(tty
, ctx
, 0, ctx
->ocy
+ 1);
801 for (i
= ctx
->ocy
+ 1; i
< screen_size_y(s
); i
++) {
802 tty_putcode(tty
, TTYC_EL
);
803 if (i
== screen_size_y(s
) - 1)
805 tty_emulate_repeat(tty
, TTYC_CUD
, TTYC_CUD1
, 1);
810 for (i
= ctx
->ocx
; i
< screen_size_x(s
); i
++)
812 for (j
= ctx
->ocy
+ 1; j
< screen_size_y(s
); j
++) {
813 tty_cursor_pane(tty
, ctx
, 0, j
);
814 for (i
= 0; i
< screen_size_x(s
); i
++)
821 tty_cmd_clearstartofscreen(struct tty
*tty
, const struct tty_ctx
*ctx
)
823 struct window_pane
*wp
= ctx
->wp
;
824 struct screen
*s
= wp
->screen
;
829 tty_region_pane(tty
, ctx
, 0, screen_size_y(s
) - 1);
830 tty_cursor_pane(tty
, ctx
, 0, 0);
832 if (wp
->xoff
== 0 && screen_size_x(s
) >= tty
->sx
&&
833 tty_term_has(tty
->term
, TTYC_EL
)) {
834 for (i
= 0; i
< ctx
->ocy
; i
++) {
835 tty_putcode(tty
, TTYC_EL
);
836 tty_emulate_repeat(tty
, TTYC_CUD
, TTYC_CUD1
, 1);
840 for (j
= 0; j
< ctx
->ocy
; j
++) {
841 tty_cursor_pane(tty
, ctx
, 0, j
);
842 for (i
= 0; i
< screen_size_x(s
); i
++)
846 for (i
= 0; i
<= ctx
->ocx
; i
++)
851 tty_cmd_clearscreen(struct tty
*tty
, const struct tty_ctx
*ctx
)
853 struct window_pane
*wp
= ctx
->wp
;
854 struct screen
*s
= wp
->screen
;
859 tty_region_pane(tty
, ctx
, 0, screen_size_y(s
) - 1);
860 tty_cursor_pane(tty
, ctx
, 0, 0);
862 if (wp
->xoff
== 0 && screen_size_x(s
) >= tty
->sx
&&
863 tty_term_has(tty
->term
, TTYC_EL
)) {
864 for (i
= 0; i
< screen_size_y(s
); i
++) {
865 tty_putcode(tty
, TTYC_EL
);
866 if (i
!= screen_size_y(s
) - 1) {
867 tty_emulate_repeat(tty
, TTYC_CUD
, TTYC_CUD1
, 1);
872 for (j
= 0; j
< screen_size_y(s
); j
++) {
873 tty_cursor_pane(tty
, ctx
, 0, j
);
874 for (i
= 0; i
< screen_size_x(s
); i
++)
881 tty_cmd_alignmenttest(struct tty
*tty
, const struct tty_ctx
*ctx
)
883 struct window_pane
*wp
= ctx
->wp
;
884 struct screen
*s
= wp
->screen
;
889 tty_region_pane(tty
, ctx
, 0, screen_size_y(s
) - 1);
891 for (j
= 0; j
< screen_size_y(s
); j
++) {
892 tty_cursor_pane(tty
, ctx
, 0, j
);
893 for (i
= 0; i
< screen_size_x(s
); i
++)
899 tty_cmd_cell(struct tty
*tty
, const struct tty_ctx
*ctx
)
901 struct window_pane
*wp
= ctx
->wp
;
902 struct screen
*s
= wp
->screen
;
905 tty_region_pane(tty
, ctx
, ctx
->orupper
, ctx
->orlower
);
907 /* Is the cursor in the very last position? */
908 if (ctx
->ocx
> wp
->sx
- ctx
->last_width
) {
909 if (wp
->xoff
!= 0 || wp
->sx
!= tty
->sx
) {
911 * The pane doesn't fill the entire line, the linefeed
912 * will already have happened, so just move the cursor.
914 tty_cursor_pane(tty
, ctx
, 0, ctx
->ocy
+ 1);
915 } else if (tty
->cx
< tty
->sx
) {
917 * The cursor isn't in the last position already, so
918 * move as far left as possinble and redraw the last
919 * cell to move into the last position.
921 cx
= screen_size_x(s
) - ctx
->last_width
;
922 tty_cursor_pane(tty
, ctx
, cx
, ctx
->ocy
);
923 tty_cell(tty
, &ctx
->last_cell
, &ctx
->last_utf8
);
926 tty_cursor_pane(tty
, ctx
, ctx
->ocx
, ctx
->ocy
);
928 tty_cell(tty
, ctx
->cell
, ctx
->utf8
);
932 tty_cmd_utf8character(struct tty
*tty
, const struct tty_ctx
*ctx
)
934 struct window_pane
*wp
= ctx
->wp
;
937 * Cannot rely on not being a partial character, so just redraw the
940 tty_draw_line(tty
, wp
->screen
, ctx
->ocy
, wp
->xoff
, wp
->yoff
);
945 struct tty
*tty
, const struct grid_cell
*gc
, const struct grid_utf8
*gu
)
949 /* Skip last character if terminal is stupid. */
950 if (tty
->term
->flags
& TERM_EARLYWRAP
&&
951 tty
->cy
== tty
->sy
- 1 && tty
->cx
== tty
->sx
- 1)
954 /* If this is a padding character, do nothing. */
955 if (gc
->flags
& GRID_FLAG_PADDING
)
958 /* Set the attributes. */
959 tty_attributes(tty
, gc
);
961 /* If not UTF-8, write directly. */
962 if (!(gc
->flags
& GRID_FLAG_UTF8
)) {
963 if (gc
->data
< 0x20 || gc
->data
== 0x7f)
965 tty_putc(tty
, gc
->data
);
969 /* If the terminal doesn't support UTF-8, write underscores. */
970 if (!(tty
->flags
& TTY_UTF8
)) {
971 for (i
= 0; i
< gu
->width
; i
++)
976 /* Otherwise, write UTF-8. */
977 tty_pututf8(tty
, gu
);
981 tty_reset(struct tty
*tty
)
983 struct grid_cell
*gc
= &tty
->cell
;
985 if (memcmp(gc
, &grid_default_cell
, sizeof *gc
) == 0)
988 if ((gc
->attr
& GRID_ATTR_CHARSET
) && tty_use_acs(tty
))
989 tty_putcode(tty
, TTYC_RMACS
);
990 tty_putcode(tty
, TTYC_SGR0
);
991 memcpy(gc
, &grid_default_cell
, sizeof *gc
);
994 /* Set region inside pane. */
997 struct tty
*tty
, const struct tty_ctx
*ctx
, u_int rupper
, u_int rlower
)
999 struct window_pane
*wp
= ctx
->wp
;
1001 tty_region(tty
, wp
->yoff
+ rupper
, wp
->yoff
+ rlower
);
1004 /* Set region at absolute position. */
1006 tty_region(struct tty
*tty
, u_int rupper
, u_int rlower
)
1008 if (tty
->rlower
== rlower
&& tty
->rupper
== rupper
)
1010 if (!tty_term_has(tty
->term
, TTYC_CSR
))
1013 tty
->rupper
= rupper
;
1014 tty
->rlower
= rlower
;
1017 * Some terminals (such as PuTTY) do not correctly reset the cursor to
1018 * 0,0 if it is beyond the last column (they do not reset their wrap
1019 * flag so further output causes a line feed). As a workaround, do an
1020 * explicit move to 0 first.
1022 if (tty
->cx
>= tty
->sx
)
1023 tty_cursor(tty
, 0, tty
->cy
);
1025 tty_putcode2(tty
, TTYC_CSR
, tty
->rupper
, tty
->rlower
);
1026 tty_cursor(tty
, 0, 0);
1029 /* Move cursor inside pane. */
1031 tty_cursor_pane(struct tty
*tty
, const struct tty_ctx
*ctx
, u_int cx
, u_int cy
)
1033 struct window_pane
*wp
= ctx
->wp
;
1035 tty_cursor(tty
, wp
->xoff
+ cx
, wp
->yoff
+ cy
);
1038 /* Move cursor to absolute position. */
1040 tty_cursor(struct tty
*tty
, u_int cx
, u_int cy
)
1042 struct tty_term
*term
= tty
->term
;
1046 if (cx
> tty
->sx
- 1)
1053 if (cx
== thisx
&& cy
== thisy
)
1056 /* Very end of the line, just use absolute movement. */
1057 if (thisx
> tty
->sx
- 1)
1060 /* Move to home position (0, 0). */
1061 if (cx
== 0 && cy
== 0 && tty_term_has(term
, TTYC_HOME
)) {
1062 tty_putcode(tty
, TTYC_HOME
);
1066 /* Zero on the next line. */
1067 if (cx
== 0 && cy
== thisy
+ 1 && thisy
!= tty
->rlower
) {
1068 tty_putc(tty
, '\r');
1069 tty_putc(tty
, '\n');
1073 /* Moving column or row. */
1076 * Moving column only, row staying the same.
1081 tty_putc(tty
, '\r');
1085 /* One to the left. */
1086 if (cx
== thisx
- 1 && tty_term_has(term
, TTYC_CUB1
)) {
1087 tty_putcode(tty
, TTYC_CUB1
);
1091 /* One to the right. */
1092 if (cx
== thisx
+ 1 && tty_term_has(term
, TTYC_CUF1
)) {
1093 tty_putcode(tty
, TTYC_CUF1
);
1097 /* Calculate difference. */
1098 change
= thisx
- cx
; /* +ve left, -ve right */
1101 * Use HPA if change is larger than absolute, otherwise move
1102 * the cursor with CUB/CUF.
1104 if ((u_int
) abs(change
) > cx
&& tty_term_has(term
, TTYC_HPA
)) {
1105 tty_putcode1(tty
, TTYC_HPA
, cx
);
1107 } else if (change
> 0 && tty_term_has(term
, TTYC_CUB
)) {
1108 tty_putcode1(tty
, TTYC_CUB
, change
);
1110 } else if (change
< 0 && tty_term_has(term
, TTYC_CUF
)) {
1111 tty_putcode1(tty
, TTYC_CUF
, -change
);
1114 } else if (cx
== thisx
) {
1116 * Moving row only, column staying the same.
1120 if (thisy
!= tty
->rupper
&&
1121 cy
== thisy
- 1 && tty_term_has(term
, TTYC_CUU1
)) {
1122 tty_putcode(tty
, TTYC_CUU1
);
1127 if (thisy
!= tty
->rlower
&&
1128 cy
== thisy
+ 1 && tty_term_has(term
, TTYC_CUD1
)) {
1129 tty_putcode(tty
, TTYC_CUD1
);
1133 /* Calculate difference. */
1134 change
= thisy
- cy
; /* +ve up, -ve down */
1137 * Try to use VPA if change is larger than absolute or if this
1138 * change would cross the scroll region, otherwise use CUU/CUD.
1140 if ((u_int
) abs(change
) > cy
||
1141 (change
< 0 && cy
- change
> tty
->rlower
) ||
1142 (change
> 0 && cy
- change
< tty
->rupper
)) {
1143 if (tty_term_has(term
, TTYC_VPA
)) {
1144 tty_putcode1(tty
, TTYC_VPA
, cy
);
1147 } else if (change
> 0 && tty_term_has(term
, TTYC_CUU
)) {
1148 tty_putcode1(tty
, TTYC_CUU
, change
);
1150 } else if (change
< 0 && tty_term_has(term
, TTYC_CUD
)) {
1151 tty_putcode1(tty
, TTYC_CUD
, -change
);
1157 /* Absolute movement. */
1158 tty_putcode2(tty
, TTYC_CUP
, cy
, cx
);
1166 tty_attributes(struct tty
*tty
, const struct grid_cell
*gc
)
1168 struct grid_cell
*tc
= &tty
->cell
, gc2
;
1171 memcpy(&gc2
, gc
, sizeof gc2
);
1174 * If no setab, try to use the reverse attribute as a best-effort for a
1175 * non-default background. This is a bit of a hack but it doesn't do
1176 * any serious harm and makes a couple of applications happier.
1178 if (!tty_term_has(tty
->term
, TTYC_SETAB
)) {
1179 if (gc2
.attr
& GRID_ATTR_REVERSE
) {
1180 if (gc2
.fg
!= 7 && gc2
.fg
!= 8)
1181 gc2
.attr
&= ~GRID_ATTR_REVERSE
;
1183 if (gc2
.bg
!= 0 && gc2
.bg
!= 8)
1184 gc2
.attr
|= GRID_ATTR_REVERSE
;
1188 /* Fix up the colours if necessary. */
1189 tty_check_fg(tty
, &gc2
);
1190 tty_check_bg(tty
, &gc2
);
1192 /* If any bits are being cleared, reset everything. */
1193 if (tc
->attr
& ~gc2
.attr
)
1197 * Set the colours. This may call tty_reset() (so it comes next) and
1198 * may add to (NOT remove) the desired attributes by changing new_attr.
1200 tty_colours(tty
, &gc2
);
1202 /* Filter out attribute bits already set. */
1203 changed
= gc2
.attr
& ~tc
->attr
;
1204 tc
->attr
= gc2
.attr
;
1206 /* Set the attributes. */
1207 if (changed
& GRID_ATTR_BRIGHT
)
1208 tty_putcode(tty
, TTYC_BOLD
);
1209 if (changed
& GRID_ATTR_DIM
)
1210 tty_putcode(tty
, TTYC_DIM
);
1211 if (changed
& GRID_ATTR_ITALICS
)
1212 tty_putcode(tty
, TTYC_SMSO
);
1213 if (changed
& GRID_ATTR_UNDERSCORE
)
1214 tty_putcode(tty
, TTYC_SMUL
);
1215 if (changed
& GRID_ATTR_BLINK
)
1216 tty_putcode(tty
, TTYC_BLINK
);
1217 if (changed
& GRID_ATTR_REVERSE
) {
1218 if (tty_term_has(tty
->term
, TTYC_REV
))
1219 tty_putcode(tty
, TTYC_REV
);
1220 else if (tty_term_has(tty
->term
, TTYC_SMSO
))
1221 tty_putcode(tty
, TTYC_SMSO
);
1223 if (changed
& GRID_ATTR_HIDDEN
)
1224 tty_putcode(tty
, TTYC_INVIS
);
1225 if ((changed
& GRID_ATTR_CHARSET
) && tty_use_acs(tty
))
1226 tty_putcode(tty
, TTYC_SMACS
);
1230 tty_colours(struct tty
*tty
, const struct grid_cell
*gc
)
1232 struct grid_cell
*tc
= &tty
->cell
;
1233 u_char fg
= gc
->fg
, bg
= gc
->bg
, flags
= gc
->flags
;
1234 int have_ax
, fg_default
, bg_default
;
1236 /* No changes? Nothing is necessary. */
1237 if (fg
== tc
->fg
&& bg
== tc
->bg
&&
1238 ((flags
^ tc
->flags
) & (GRID_FLAG_FG256
|GRID_FLAG_BG256
)) == 0)
1242 * Is either the default colour? This is handled specially because the
1243 * best solution might be to reset both colours to default, in which
1244 * case if only one is default need to fall onward to set the other
1247 fg_default
= (fg
== 8 && !(flags
& GRID_FLAG_FG256
));
1248 bg_default
= (bg
== 8 && !(flags
& GRID_FLAG_BG256
));
1249 if (fg_default
|| bg_default
) {
1251 * If don't have AX but do have op, send sgr0 (op can't
1252 * actually be used because it is sometimes the same as sgr0
1253 * and sometimes isn't). This resets both colours to default.
1255 * Otherwise, try to set the default colour only as needed.
1257 have_ax
= tty_term_has(tty
->term
, TTYC_AX
);
1258 if (!have_ax
&& tty_term_has(tty
->term
, TTYC_OP
))
1262 (tc
->fg
!= 8 || tc
->flags
& GRID_FLAG_FG256
)) {
1264 tty_puts(tty
, "\033[39m");
1265 else if (tc
->fg
!= 7 ||
1266 tc
->flags
& GRID_FLAG_FG256
)
1267 tty_putcode1(tty
, TTYC_SETAF
, 7);
1269 tc
->flags
&= ~GRID_FLAG_FG256
;
1272 (tc
->bg
!= 8 || tc
->flags
& GRID_FLAG_BG256
)) {
1274 tty_puts(tty
, "\033[49m");
1275 else if (tc
->bg
!= 0 ||
1276 tc
->flags
& GRID_FLAG_BG256
)
1277 tty_putcode1(tty
, TTYC_SETAB
, 0);
1279 tc
->flags
&= ~GRID_FLAG_BG256
;
1284 /* Set the foreground colour. */
1285 if (!fg_default
&& (fg
!= tc
->fg
||
1286 ((flags
& GRID_FLAG_FG256
) != (tc
->flags
& GRID_FLAG_FG256
))))
1287 tty_colours_fg(tty
, gc
);
1290 * Set the background colour. This must come after the foreground as
1291 * tty_colour_fg() can call tty_reset().
1293 if (!bg_default
&& (bg
!= tc
->bg
||
1294 ((flags
& GRID_FLAG_BG256
) != (tc
->flags
& GRID_FLAG_BG256
))))
1295 tty_colours_bg(tty
, gc
);
1299 tty_check_fg(struct tty
*tty
, struct grid_cell
*gc
)
1303 /* Is this a 256-colour colour? */
1304 if (gc
->flags
& GRID_FLAG_FG256
) {
1305 /* And not a 256 colour mode? */
1306 if (!(tty
->term
->flags
& TERM_88COLOURS
) &&
1307 !(tty
->term_flags
& TERM_88COLOURS
) &&
1308 !(tty
->term
->flags
& TERM_256COLOURS
) &&
1309 !(tty
->term_flags
& TERM_256COLOURS
)) {
1310 gc
->fg
= colour_256to16(gc
->fg
);
1313 gc
->attr
|= GRID_ATTR_BRIGHT
;
1315 gc
->attr
&= ~GRID_ATTR_BRIGHT
;
1316 gc
->flags
&= ~GRID_FLAG_FG256
;
1321 /* Is this an aixterm colour? */
1322 colours
= tty_term_number(tty
->term
, TTYC_COLORS
);
1323 if (gc
->fg
>= 90 && gc
->fg
<= 97 && colours
< 16) {
1325 gc
->attr
|= GRID_ATTR_BRIGHT
;
1330 tty_check_bg(struct tty
*tty
, struct grid_cell
*gc
)
1334 /* Is this a 256-colour colour? */
1335 if (gc
->flags
& GRID_FLAG_BG256
) {
1337 * And not a 256 colour mode? Translate to 16-colour
1338 * palette. Bold background doesn't exist portably, so just
1339 * discard the bold bit if set.
1341 if (!(tty
->term
->flags
& TERM_88COLOURS
) &&
1342 !(tty
->term_flags
& TERM_88COLOURS
) &&
1343 !(tty
->term
->flags
& TERM_256COLOURS
) &&
1344 !(tty
->term_flags
& TERM_256COLOURS
)) {
1345 gc
->bg
= colour_256to16(gc
->bg
);
1348 gc
->attr
&= ~GRID_ATTR_BRIGHT
;
1349 gc
->flags
&= ~GRID_FLAG_BG256
;
1354 /* Is this an aixterm colour? */
1355 colours
= tty_term_number(tty
->term
, TTYC_COLORS
);
1356 if (gc
->bg
>= 100 && gc
->bg
<= 107 && colours
< 16) {
1358 gc
->attr
|= GRID_ATTR_BRIGHT
;
1363 tty_colours_fg(struct tty
*tty
, const struct grid_cell
*gc
)
1365 struct grid_cell
*tc
= &tty
->cell
;
1369 /* Is this a 256-colour colour? */
1370 if (gc
->flags
& GRID_FLAG_FG256
) {
1371 /* Try as 256 colours or translating to 88. */
1372 if (tty_try_256(tty
, fg
, "38") == 0)
1374 if (tty_try_88(tty
, fg
, "38") == 0)
1376 /* Else already handled by tty_check_fg. */
1380 /* Is this an aixterm bright colour? */
1381 if (fg
>= 90 && fg
<= 97) {
1382 xsnprintf(s
, sizeof s
, "\033[%dm", fg
);
1387 /* Otherwise set the foreground colour. */
1388 tty_putcode1(tty
, TTYC_SETAF
, fg
);
1391 /* Save the new values in the terminal current cell. */
1393 tc
->flags
&= ~GRID_FLAG_FG256
;
1394 tc
->flags
|= gc
->flags
& GRID_FLAG_FG256
;
1398 tty_colours_bg(struct tty
*tty
, const struct grid_cell
*gc
)
1400 struct grid_cell
*tc
= &tty
->cell
;
1404 /* Is this a 256-colour colour? */
1405 if (gc
->flags
& GRID_FLAG_BG256
) {
1406 /* Try as 256 colours or translating to 88. */
1407 if (tty_try_256(tty
, bg
, "48") == 0)
1409 if (tty_try_88(tty
, bg
, "48") == 0)
1411 /* Else already handled by tty_check_bg. */
1415 /* Is this an aixterm bright colour? */
1416 if (bg
>= 100 && bg
<= 107) {
1417 /* 16 colour terminals or above only. */
1418 if (tty_term_number(tty
->term
, TTYC_COLORS
) >= 16) {
1419 xsnprintf(s
, sizeof s
, "\033[%dm", bg
);
1424 /* no such thing as a bold background */
1427 /* Otherwise set the background colour. */
1428 tty_putcode1(tty
, TTYC_SETAB
, bg
);
1431 /* Save the new values in the terminal current cell. */
1433 tc
->flags
&= ~GRID_FLAG_BG256
;
1434 tc
->flags
|= gc
->flags
& GRID_FLAG_BG256
;
1438 tty_try_256(struct tty
*tty
, u_char colour
, const char *type
)
1442 if (!(tty
->term
->flags
& TERM_256COLOURS
) &&
1443 !(tty
->term_flags
& TERM_256COLOURS
))
1446 xsnprintf(s
, sizeof s
, "\033[%s;5;%hhum", type
, colour
);
1452 tty_try_88(struct tty
*tty
, u_char colour
, const char *type
)
1456 if (!(tty
->term
->flags
& TERM_88COLOURS
) &&
1457 !(tty
->term_flags
& TERM_88COLOURS
))
1459 colour
= colour_256to88(colour
);
1461 xsnprintf(s
, sizeof s
, "\033[%s;5;%hhum", type
, colour
);