status.c revision 1.115
1/* $OpenBSD: status.c,v 1.115 2014/10/02 10:39:43 nicm Exp $ */ 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/time.h> 21 22#include <errno.h> 23#include <limits.h> 24#include <stdarg.h> 25#include <stdlib.h> 26#include <string.h> 27#include <time.h> 28#include <unistd.h> 29 30#include "tmux.h" 31 32char *status_redraw_get_left( 33 struct client *, time_t, int, struct grid_cell *, size_t *); 34char *status_redraw_get_right( 35 struct client *, time_t, int, struct grid_cell *, size_t *); 36char *status_find_job(struct client *, char **); 37void status_job_free(void *); 38void status_job_callback(struct job *); 39char *status_print( 40 struct client *, struct winlink *, time_t, struct grid_cell *); 41void status_replace1(struct client *, char **, char **, char *, size_t, int); 42void status_message_callback(int, short, void *); 43 44const char *status_prompt_up_history(u_int *); 45const char *status_prompt_down_history(u_int *); 46void status_prompt_add_history(const char *); 47char *status_prompt_complete(const char *); 48 49/* Status prompt history. */ 50ARRAY_DECL(, char *) status_prompt_history = ARRAY_INITIALIZER; 51 52/* Status output tree. */ 53RB_GENERATE(status_out_tree, status_out, entry, status_out_cmp); 54 55/* Output tree comparison function. */ 56int 57status_out_cmp(struct status_out *so1, struct status_out *so2) 58{ 59 return (strcmp(so1->cmd, so2->cmd)); 60} 61 62/* Get screen line of status line. -1 means off. */ 63int 64status_at_line(struct client *c) 65{ 66 struct session *s = c->session; 67 68 if (!options_get_number(&s->options, "status")) 69 return (-1); 70 71 if (options_get_number(&s->options, "status-position") == 0) 72 return (0); 73 return (c->tty.sy - 1); 74} 75 76/* Retrieve options for left string. */ 77char * 78status_redraw_get_left(struct client *c, 79 time_t t, int utf8flag, struct grid_cell *gc, size_t *size) 80{ 81 struct session *s = c->session; 82 char *left; 83 size_t leftlen; 84 85 style_apply_update(gc, &s->options, "status-left-style"); 86 87 left = status_replace(c, NULL, 88 NULL, NULL, options_get_string(&s->options, "status-left"), t, 1); 89 90 *size = options_get_number(&s->options, "status-left-length"); 91 leftlen = screen_write_cstrlen(utf8flag, "%s", left); 92 if (leftlen < *size) 93 *size = leftlen; 94 return (left); 95} 96 97/* Retrieve options for right string. */ 98char * 99status_redraw_get_right(struct client *c, 100 time_t t, int utf8flag, struct grid_cell *gc, size_t *size) 101{ 102 struct session *s = c->session; 103 char *right; 104 size_t rightlen; 105 106 style_apply_update(gc, &s->options, "status-right-style"); 107 108 right = status_replace(c, NULL, 109 NULL, NULL, options_get_string(&s->options, "status-right"), t, 1); 110 111 *size = options_get_number(&s->options, "status-right-length"); 112 rightlen = screen_write_cstrlen(utf8flag, "%s", right); 113 if (rightlen < *size) 114 *size = rightlen; 115 return (right); 116} 117 118/* Set window at window list position. */ 119void 120status_set_window_at(struct client *c, u_int x) 121{ 122 struct session *s = c->session; 123 struct winlink *wl; 124 struct options *oo; 125 size_t len; 126 127 x += c->wlmouse; 128 RB_FOREACH(wl, winlinks, &s->windows) { 129 oo = &wl->window->options; 130 131 len = strlen(options_get_string(oo, "window-status-separator")); 132 if (x < wl->status_width && session_select(s, wl->idx) == 0) 133 server_redraw_session(s); 134 x -= wl->status_width + len; 135 } 136} 137 138/* Draw status for client on the last lines of given context. */ 139int 140status_redraw(struct client *c) 141{ 142 struct screen_write_ctx ctx; 143 struct session *s = c->session; 144 struct winlink *wl; 145 struct screen old_status, window_list; 146 struct grid_cell stdgc, lgc, rgc, gc; 147 struct options *oo; 148 time_t t; 149 char *left, *right, *sep; 150 u_int offset, needed; 151 u_int wlstart, wlwidth, wlavailable, wloffset, wlsize; 152 size_t llen, rlen, seplen; 153 int larrow, rarrow, utf8flag; 154 155 /* No status line? */ 156 if (c->tty.sy == 0 || !options_get_number(&s->options, "status")) 157 return (1); 158 left = right = NULL; 159 larrow = rarrow = 0; 160 161 /* Update status timer. */ 162 if (gettimeofday(&c->status_timer, NULL) != 0) 163 fatal("gettimeofday failed"); 164 t = c->status_timer.tv_sec; 165 166 /* Set up default colour. */ 167 style_apply(&stdgc, &s->options, "status-style"); 168 169 /* Create the target screen. */ 170 memcpy(&old_status, &c->status, sizeof old_status); 171 screen_init(&c->status, c->tty.sx, 1, 0); 172 screen_write_start(&ctx, NULL, &c->status); 173 for (offset = 0; offset < c->tty.sx; offset++) 174 screen_write_putc(&ctx, &stdgc, ' '); 175 screen_write_stop(&ctx); 176 177 /* If the height is one line, blank status line. */ 178 if (c->tty.sy <= 1) 179 goto out; 180 181 /* Get UTF-8 flag. */ 182 utf8flag = options_get_number(&s->options, "status-utf8"); 183 184 /* Work out left and right strings. */ 185 memcpy(&lgc, &stdgc, sizeof lgc); 186 left = status_redraw_get_left(c, t, utf8flag, &lgc, &llen); 187 memcpy(&rgc, &stdgc, sizeof rgc); 188 right = status_redraw_get_right(c, t, utf8flag, &rgc, &rlen); 189 190 /* 191 * Figure out how much space we have for the window list. If there 192 * isn't enough space, just show a blank status line. 193 */ 194 needed = 0; 195 if (llen != 0) 196 needed += llen + 1; 197 if (rlen != 0) 198 needed += rlen + 1; 199 if (c->tty.sx == 0 || c->tty.sx <= needed) 200 goto out; 201 wlavailable = c->tty.sx - needed; 202 203 /* Calculate the total size needed for the window list. */ 204 wlstart = wloffset = wlwidth = 0; 205 RB_FOREACH(wl, winlinks, &s->windows) { 206 free(wl->status_text); 207 memcpy(&wl->status_cell, &stdgc, sizeof wl->status_cell); 208 wl->status_text = status_print(c, wl, t, &wl->status_cell); 209 wl->status_width = 210 screen_write_cstrlen(utf8flag, "%s", wl->status_text); 211 212 if (wl == s->curw) 213 wloffset = wlwidth; 214 215 oo = &wl->window->options; 216 sep = options_get_string(oo, "window-status-separator"); 217 seplen = screen_write_strlen(utf8flag, "%s", sep); 218 wlwidth += wl->status_width + seplen; 219 } 220 221 /* Create a new screen for the window list. */ 222 screen_init(&window_list, wlwidth, 1, 0); 223 224 /* And draw the window list into it. */ 225 screen_write_start(&ctx, NULL, &window_list); 226 RB_FOREACH(wl, winlinks, &s->windows) { 227 screen_write_cnputs(&ctx, 228 -1, &wl->status_cell, utf8flag, "%s", wl->status_text); 229 230 oo = &wl->window->options; 231 sep = options_get_string(oo, "window-status-separator"); 232 screen_write_nputs(&ctx, -1, &stdgc, utf8flag, "%s", sep); 233 } 234 screen_write_stop(&ctx); 235 236 /* If there is enough space for the total width, skip to draw now. */ 237 if (wlwidth <= wlavailable) 238 goto draw; 239 240 /* Find size of current window text. */ 241 wlsize = s->curw->status_width; 242 243 /* 244 * If the current window is already on screen, good to draw from the 245 * start and just leave off the end. 246 */ 247 if (wloffset + wlsize < wlavailable) { 248 if (wlavailable > 0) { 249 rarrow = 1; 250 wlavailable--; 251 } 252 wlwidth = wlavailable; 253 } else { 254 /* 255 * Work out how many characters we need to omit from the 256 * start. There are wlavailable characters to fill, and 257 * wloffset + wlsize must be the last. So, the start character 258 * is wloffset + wlsize - wlavailable. 259 */ 260 if (wlavailable > 0) { 261 larrow = 1; 262 wlavailable--; 263 } 264 265 wlstart = wloffset + wlsize - wlavailable; 266 if (wlavailable > 0 && wlwidth > wlstart + wlavailable + 1) { 267 rarrow = 1; 268 wlstart++; 269 wlavailable--; 270 } 271 wlwidth = wlavailable; 272 } 273 274 /* Bail if anything is now too small too. */ 275 if (wlwidth == 0 || wlavailable == 0) { 276 screen_free(&window_list); 277 goto out; 278 } 279 280 /* 281 * Now the start position is known, work out the state of the left and 282 * right arrows. 283 */ 284 offset = 0; 285 RB_FOREACH(wl, winlinks, &s->windows) { 286 if (wl->flags & WINLINK_ALERTFLAGS && 287 larrow == 1 && offset < wlstart) 288 larrow = -1; 289 290 offset += wl->status_width; 291 292 if (wl->flags & WINLINK_ALERTFLAGS && 293 rarrow == 1 && offset > wlstart + wlwidth) 294 rarrow = -1; 295 } 296 297draw: 298 /* Begin drawing. */ 299 screen_write_start(&ctx, NULL, &c->status); 300 301 /* Draw the left string and arrow. */ 302 screen_write_cursormove(&ctx, 0, 0); 303 if (llen != 0) { 304 screen_write_cnputs(&ctx, llen, &lgc, utf8flag, "%s", left); 305 screen_write_putc(&ctx, &stdgc, ' '); 306 } 307 if (larrow != 0) { 308 memcpy(&gc, &stdgc, sizeof gc); 309 if (larrow == -1) 310 gc.attr ^= GRID_ATTR_REVERSE; 311 screen_write_putc(&ctx, &gc, '<'); 312 } 313 314 /* Draw the right string and arrow. */ 315 if (rarrow != 0) { 316 screen_write_cursormove(&ctx, c->tty.sx - rlen - 2, 0); 317 memcpy(&gc, &stdgc, sizeof gc); 318 if (rarrow == -1) 319 gc.attr ^= GRID_ATTR_REVERSE; 320 screen_write_putc(&ctx, &gc, '>'); 321 } else 322 screen_write_cursormove(&ctx, c->tty.sx - rlen - 1, 0); 323 if (rlen != 0) { 324 screen_write_putc(&ctx, &stdgc, ' '); 325 screen_write_cnputs(&ctx, rlen, &rgc, utf8flag, "%s", right); 326 } 327 328 /* Figure out the offset for the window list. */ 329 if (llen != 0) 330 wloffset = llen + 1; 331 else 332 wloffset = 0; 333 if (wlwidth < wlavailable) { 334 switch (options_get_number(&s->options, "status-justify")) { 335 case 1: /* centered */ 336 wloffset += (wlavailable - wlwidth) / 2; 337 break; 338 case 2: /* right */ 339 wloffset += (wlavailable - wlwidth); 340 break; 341 } 342 } 343 if (larrow != 0) 344 wloffset++; 345 346 /* Copy the window list. */ 347 c->wlmouse = -wloffset + wlstart; 348 screen_write_cursormove(&ctx, wloffset, 0); 349 screen_write_copy(&ctx, &window_list, wlstart, 0, wlwidth, 1); 350 screen_free(&window_list); 351 352 screen_write_stop(&ctx); 353 354out: 355 free(left); 356 free(right); 357 358 if (grid_compare(c->status.grid, old_status.grid) == 0) { 359 screen_free(&old_status); 360 return (0); 361 } 362 screen_free(&old_status); 363 return (1); 364} 365 366/* Replace a single special sequence (prefixed by #). */ 367void 368status_replace1(struct client *c, char **iptr, char **optr, char *out, 369 size_t outsize, int jobsflag) 370{ 371 char ch, tmp[256], *ptr, *endptr; 372 size_t ptrlen; 373 long limit; 374 375 errno = 0; 376 limit = strtol(*iptr, &endptr, 10); 377 if ((limit == 0 && errno != EINVAL) || 378 (limit == LONG_MIN && errno != ERANGE) || 379 (limit == LONG_MAX && errno != ERANGE) || 380 limit != 0) 381 *iptr = endptr; 382 if (limit <= 0) 383 limit = LONG_MAX; 384 385 switch (*(*iptr)++) { 386 case '(': 387 if (!jobsflag) { 388 ch = ')'; 389 goto skip_to; 390 } 391 if ((ptr = status_find_job(c, iptr)) == NULL) 392 return; 393 goto do_replace; 394 case '[': 395 /* 396 * Embedded style, handled at display time. Leave present and 397 * skip input until ]. 398 */ 399 ch = ']'; 400 goto skip_to; 401 case '{': 402 ptr = (char *) "#{"; 403 goto do_replace; 404 default: 405 xsnprintf(tmp, sizeof tmp, "#%c", *(*iptr - 1)); 406 ptr = tmp; 407 goto do_replace; 408 } 409 410 return; 411 412do_replace: 413 ptrlen = strlen(ptr); 414 if ((size_t) limit < ptrlen) 415 ptrlen = limit; 416 417 if (*optr + ptrlen >= out + outsize - 1) 418 return; 419 while (ptrlen > 0 && *ptr != '\0') { 420 *(*optr)++ = *ptr++; 421 ptrlen--; 422 } 423 424 return; 425 426skip_to: 427 *(*optr)++ = '#'; 428 429 (*iptr)--; /* include ch */ 430 while (**iptr != ch && **iptr != '\0') { 431 if (*optr >= out + outsize - 1) 432 break; 433 *(*optr)++ = *(*iptr)++; 434 } 435} 436 437/* Replace special sequences in fmt. */ 438char * 439status_replace(struct client *c, struct session *s, struct winlink *wl, 440 struct window_pane *wp, const char *fmt, time_t t, int jobsflag) 441{ 442 static char out[BUFSIZ]; 443 char in[BUFSIZ], ch, *iptr, *optr, *expanded; 444 size_t len; 445 struct format_tree *ft; 446 447 if (fmt == NULL) 448 return (xstrdup("")); 449 450 if (s == NULL && c != NULL) 451 s = c->session; 452 if (wl == NULL && s != NULL) 453 wl = s->curw; 454 if (wp == NULL && wl != NULL) 455 wp = wl->window->active; 456 457 len = strftime(in, sizeof in, fmt, localtime(&t)); 458 in[len] = '\0'; 459 460 iptr = in; 461 optr = out; 462 463 while (*iptr != '\0') { 464 if (optr >= out + (sizeof out) - 1) 465 break; 466 ch = *iptr++; 467 468 if (ch != '#' || *iptr == '\0') { 469 *optr++ = ch; 470 continue; 471 } 472 status_replace1(c, &iptr, &optr, out, sizeof out, jobsflag); 473 } 474 *optr = '\0'; 475 476 ft = format_create(); 477 if (c != NULL) 478 format_client(ft, c); 479 if (s != NULL) 480 format_session(ft, s); 481 if (s != NULL && wl != NULL) 482 format_winlink(ft, s, wl); 483 if (wp != NULL) 484 format_window_pane(ft, wp); 485 expanded = format_expand(ft, out); 486 format_free(ft); 487 return (expanded); 488} 489 490/* Figure out job name and get its result, starting it off if necessary. */ 491char * 492status_find_job(struct client *c, char **iptr) 493{ 494 struct status_out *so, so_find; 495 char *cmd; 496 int lastesc; 497 size_t len; 498 499 if (**iptr == '\0') 500 return (NULL); 501 if (**iptr == ')') { /* no command given */ 502 (*iptr)++; 503 return (NULL); 504 } 505 506 cmd = xmalloc(strlen(*iptr) + 1); 507 len = 0; 508 509 lastesc = 0; 510 for (; **iptr != '\0'; (*iptr)++) { 511 if (!lastesc && **iptr == ')') 512 break; /* unescaped ) is the end */ 513 if (!lastesc && **iptr == '\\') { 514 lastesc = 1; 515 continue; /* skip \ if not escaped */ 516 } 517 lastesc = 0; 518 cmd[len++] = **iptr; 519 } 520 if (**iptr == '\0') /* no terminating ) */ { 521 free(cmd); 522 return (NULL); 523 } 524 (*iptr)++; /* skip final ) */ 525 cmd[len] = '\0'; 526 527 /* First try in the new tree. */ 528 so_find.cmd = cmd; 529 so = RB_FIND(status_out_tree, &c->status_new, &so_find); 530 if (so != NULL && so->out != NULL) { 531 free(cmd); 532 return (so->out); 533 } 534 535 /* If not found at all, start the job and add to the tree. */ 536 if (so == NULL) { 537 job_run(cmd, NULL, status_job_callback, status_job_free, c); 538 c->references++; 539 540 so = xmalloc(sizeof *so); 541 so->cmd = xstrdup(cmd); 542 so->out = NULL; 543 RB_INSERT(status_out_tree, &c->status_new, so); 544 } 545 546 /* Lookup in the old tree. */ 547 so_find.cmd = cmd; 548 so = RB_FIND(status_out_tree, &c->status_old, &so_find); 549 free(cmd); 550 if (so != NULL) 551 return (so->out); 552 return (NULL); 553} 554 555/* Free job tree. */ 556void 557status_free_jobs(struct status_out_tree *sotree) 558{ 559 struct status_out *so, *so_next; 560 561 so_next = RB_MIN(status_out_tree, sotree); 562 while (so_next != NULL) { 563 so = so_next; 564 so_next = RB_NEXT(status_out_tree, sotree, so); 565 566 RB_REMOVE(status_out_tree, sotree, so); 567 free(so->out); 568 free(so->cmd); 569 free(so); 570 } 571} 572 573/* Update jobs on status interval. */ 574void 575status_update_jobs(struct client *c) 576{ 577 /* Free the old tree. */ 578 status_free_jobs(&c->status_old); 579 580 /* Move the new to old. */ 581 memcpy(&c->status_old, &c->status_new, sizeof c->status_old); 582 RB_INIT(&c->status_new); 583} 584 585/* Free status job. */ 586void 587status_job_free(void *data) 588{ 589 struct client *c = data; 590 591 c->references--; 592} 593 594/* Job has finished: save its result. */ 595void 596status_job_callback(struct job *job) 597{ 598 struct client *c = job->data; 599 struct status_out *so, so_find; 600 char *line, *buf; 601 size_t len; 602 603 if (c->flags & CLIENT_DEAD) 604 return; 605 606 so_find.cmd = job->cmd; 607 so = RB_FIND(status_out_tree, &c->status_new, &so_find); 608 if (so == NULL || so->out != NULL) 609 return; 610 611 buf = NULL; 612 if ((line = evbuffer_readline(job->event->input)) == NULL) { 613 len = EVBUFFER_LENGTH(job->event->input); 614 buf = xmalloc(len + 1); 615 if (len != 0) 616 memcpy(buf, EVBUFFER_DATA(job->event->input), len); 617 buf[len] = '\0'; 618 } else 619 buf = line; 620 621 so->out = buf; 622 server_status_client(c); 623} 624 625/* Return winlink status line entry and adjust gc as necessary. */ 626char * 627status_print( 628 struct client *c, struct winlink *wl, time_t t, struct grid_cell *gc) 629{ 630 struct options *oo = &wl->window->options; 631 struct session *s = c->session; 632 const char *fmt; 633 char *text; 634 635 style_apply_update(gc, oo, "window-status-style"); 636 fmt = options_get_string(oo, "window-status-format"); 637 if (wl == s->curw) { 638 style_apply_update(gc, oo, "window-status-current-style"); 639 fmt = options_get_string(oo, "window-status-current-format"); 640 } 641 if (wl == TAILQ_FIRST(&s->lastw)) 642 style_apply_update(gc, oo, "window-status-last-style"); 643 644 if (wl->flags & WINLINK_BELL) 645 style_apply_update(gc, oo, "window-status-bell-style"); 646 else if (wl->flags & (WINLINK_ACTIVITY|WINLINK_SILENCE)) 647 style_apply_update(gc, oo, "window-status-activity-style"); 648 649 text = status_replace(c, NULL, wl, NULL, fmt, t, 1); 650 return (text); 651} 652 653/* Set a status line message. */ 654void printflike2 655status_message_set(struct client *c, const char *fmt, ...) 656{ 657 struct timeval tv; 658 struct message_entry *msg; 659 va_list ap; 660 int delay; 661 u_int i, limit; 662 663 status_prompt_clear(c); 664 status_message_clear(c); 665 666 va_start(ap, fmt); 667 xvasprintf(&c->message_string, fmt, ap); 668 va_end(ap); 669 670 ARRAY_EXPAND(&c->message_log, 1); 671 msg = &ARRAY_LAST(&c->message_log); 672 msg->msg_time = time(NULL); 673 msg->msg = xstrdup(c->message_string); 674 675 limit = options_get_number(&global_options, "message-limit"); 676 if (ARRAY_LENGTH(&c->message_log) > limit) { 677 limit = ARRAY_LENGTH(&c->message_log) - limit; 678 for (i = 0; i < limit; i++) { 679 msg = &ARRAY_FIRST(&c->message_log); 680 free(msg->msg); 681 ARRAY_REMOVE(&c->message_log, 0); 682 } 683 } 684 685 delay = options_get_number(&c->session->options, "display-time"); 686 tv.tv_sec = delay / 1000; 687 tv.tv_usec = (delay % 1000) * 1000L; 688 689 if (event_initialized(&c->message_timer)) 690 evtimer_del(&c->message_timer); 691 evtimer_set(&c->message_timer, status_message_callback, c); 692 evtimer_add(&c->message_timer, &tv); 693 694 c->tty.flags |= (TTY_NOCURSOR|TTY_FREEZE); 695 c->flags |= CLIENT_STATUS; 696} 697 698/* Clear status line message. */ 699void 700status_message_clear(struct client *c) 701{ 702 if (c->message_string == NULL) 703 return; 704 705 free(c->message_string); 706 c->message_string = NULL; 707 708 c->tty.flags &= ~(TTY_NOCURSOR|TTY_FREEZE); 709 c->flags |= CLIENT_REDRAW; /* screen was frozen and may have changed */ 710 711 screen_reinit(&c->status); 712} 713 714/* Clear status line message after timer expires. */ 715void 716status_message_callback(unused int fd, unused short event, void *data) 717{ 718 struct client *c = data; 719 720 status_message_clear(c); 721} 722 723/* Draw client message on status line of present else on last line. */ 724int 725status_message_redraw(struct client *c) 726{ 727 struct screen_write_ctx ctx; 728 struct session *s = c->session; 729 struct screen old_status; 730 size_t len; 731 struct grid_cell gc; 732 int utf8flag; 733 734 if (c->tty.sx == 0 || c->tty.sy == 0) 735 return (0); 736 memcpy(&old_status, &c->status, sizeof old_status); 737 screen_init(&c->status, c->tty.sx, 1, 0); 738 739 utf8flag = options_get_number(&s->options, "status-utf8"); 740 741 len = screen_write_strlen(utf8flag, "%s", c->message_string); 742 if (len > c->tty.sx) 743 len = c->tty.sx; 744 745 style_apply(&gc, &s->options, "message-style"); 746 747 screen_write_start(&ctx, NULL, &c->status); 748 749 screen_write_cursormove(&ctx, 0, 0); 750 screen_write_nputs(&ctx, len, &gc, utf8flag, "%s", c->message_string); 751 for (; len < c->tty.sx; len++) 752 screen_write_putc(&ctx, &gc, ' '); 753 754 screen_write_stop(&ctx); 755 756 if (grid_compare(c->status.grid, old_status.grid) == 0) { 757 screen_free(&old_status); 758 return (0); 759 } 760 screen_free(&old_status); 761 return (1); 762} 763 764/* Enable status line prompt. */ 765void 766status_prompt_set(struct client *c, const char *msg, const char *input, 767 int (*callbackfn)(void *, const char *), void (*freefn)(void *), 768 void *data, int flags) 769{ 770 int keys; 771 772 status_message_clear(c); 773 status_prompt_clear(c); 774 775 c->prompt_string = status_replace(c, NULL, NULL, NULL, msg, 776 time(NULL), 0); 777 778 c->prompt_buffer = status_replace(c, NULL, NULL, NULL, input, 779 time(NULL), 0); 780 c->prompt_index = strlen(c->prompt_buffer); 781 782 c->prompt_callbackfn = callbackfn; 783 c->prompt_freefn = freefn; 784 c->prompt_data = data; 785 786 c->prompt_hindex = 0; 787 788 c->prompt_flags = flags; 789 790 keys = options_get_number(&c->session->options, "status-keys"); 791 if (keys == MODEKEY_EMACS) 792 mode_key_init(&c->prompt_mdata, &mode_key_tree_emacs_edit); 793 else 794 mode_key_init(&c->prompt_mdata, &mode_key_tree_vi_edit); 795 796 c->tty.flags |= (TTY_NOCURSOR|TTY_FREEZE); 797 c->flags |= CLIENT_STATUS; 798} 799 800/* Remove status line prompt. */ 801void 802status_prompt_clear(struct client *c) 803{ 804 if (c->prompt_string == NULL) 805 return; 806 807 if (c->prompt_freefn != NULL && c->prompt_data != NULL) 808 c->prompt_freefn(c->prompt_data); 809 810 free(c->prompt_string); 811 c->prompt_string = NULL; 812 813 free(c->prompt_buffer); 814 c->prompt_buffer = NULL; 815 816 c->tty.flags &= ~(TTY_NOCURSOR|TTY_FREEZE); 817 c->flags |= CLIENT_REDRAW; /* screen was frozen and may have changed */ 818 819 screen_reinit(&c->status); 820} 821 822/* Update status line prompt with a new prompt string. */ 823void 824status_prompt_update(struct client *c, const char *msg, const char *input) 825{ 826 free(c->prompt_string); 827 c->prompt_string = status_replace(c, NULL, NULL, NULL, msg, 828 time(NULL), 0); 829 830 free(c->prompt_buffer); 831 c->prompt_buffer = status_replace(c, NULL, NULL, NULL, input, 832 time(NULL), 0); 833 c->prompt_index = strlen(c->prompt_buffer); 834 835 c->prompt_hindex = 0; 836 837 c->flags |= CLIENT_STATUS; 838} 839 840/* Draw client prompt on status line of present else on last line. */ 841int 842status_prompt_redraw(struct client *c) 843{ 844 struct screen_write_ctx ctx; 845 struct session *s = c->session; 846 struct screen old_status; 847 size_t i, size, left, len, off; 848 struct grid_cell gc, *gcp; 849 int utf8flag; 850 851 if (c->tty.sx == 0 || c->tty.sy == 0) 852 return (0); 853 memcpy(&old_status, &c->status, sizeof old_status); 854 screen_init(&c->status, c->tty.sx, 1, 0); 855 856 utf8flag = options_get_number(&s->options, "status-utf8"); 857 858 len = screen_write_strlen(utf8flag, "%s", c->prompt_string); 859 if (len > c->tty.sx) 860 len = c->tty.sx; 861 off = 0; 862 863 /* Change colours for command mode. */ 864 if (c->prompt_mdata.mode == 1) 865 style_apply(&gc, &s->options, "message-command-style"); 866 else 867 style_apply(&gc, &s->options, "message-style"); 868 869 screen_write_start(&ctx, NULL, &c->status); 870 871 screen_write_cursormove(&ctx, 0, 0); 872 screen_write_nputs(&ctx, len, &gc, utf8flag, "%s", c->prompt_string); 873 874 left = c->tty.sx - len; 875 if (left != 0) { 876 size = screen_write_strlen(utf8flag, "%s", c->prompt_buffer); 877 if (c->prompt_index >= left) { 878 off = c->prompt_index - left + 1; 879 if (c->prompt_index == size) 880 left--; 881 size = left; 882 } 883 screen_write_nputs( 884 &ctx, left, &gc, utf8flag, "%s", c->prompt_buffer + off); 885 886 for (i = len + size; i < c->tty.sx; i++) 887 screen_write_putc(&ctx, &gc, ' '); 888 } 889 890 screen_write_stop(&ctx); 891 892 /* Apply fake cursor. */ 893 off = len + c->prompt_index - off; 894 gcp = grid_view_get_cell(c->status.grid, off, 0); 895 gcp->attr ^= GRID_ATTR_REVERSE; 896 897 if (grid_compare(c->status.grid, old_status.grid) == 0) { 898 screen_free(&old_status); 899 return (0); 900 } 901 screen_free(&old_status); 902 return (1); 903} 904 905/* Handle keys in prompt. */ 906void 907status_prompt_key(struct client *c, int key) 908{ 909 struct session *sess = c->session; 910 struct options *oo = &sess->options; 911 struct paste_buffer *pb; 912 char *s, *first, *last, word[64], swapc; 913 const char *histstr; 914 const char *wsep = NULL; 915 u_char ch; 916 size_t size, n, off, idx; 917 918 size = strlen(c->prompt_buffer); 919 switch (mode_key_lookup(&c->prompt_mdata, key, NULL)) { 920 case MODEKEYEDIT_CURSORLEFT: 921 if (c->prompt_index > 0) { 922 c->prompt_index--; 923 c->flags |= CLIENT_STATUS; 924 } 925 break; 926 case MODEKEYEDIT_SWITCHMODE: 927 c->flags |= CLIENT_STATUS; 928 break; 929 case MODEKEYEDIT_SWITCHMODEAPPEND: 930 c->flags |= CLIENT_STATUS; 931 /* FALLTHROUGH */ 932 case MODEKEYEDIT_CURSORRIGHT: 933 if (c->prompt_index < size) { 934 c->prompt_index++; 935 c->flags |= CLIENT_STATUS; 936 } 937 break; 938 case MODEKEYEDIT_SWITCHMODEBEGINLINE: 939 c->flags |= CLIENT_STATUS; 940 /* FALLTHROUGH */ 941 case MODEKEYEDIT_STARTOFLINE: 942 if (c->prompt_index != 0) { 943 c->prompt_index = 0; 944 c->flags |= CLIENT_STATUS; 945 } 946 break; 947 case MODEKEYEDIT_SWITCHMODEAPPENDLINE: 948 c->flags |= CLIENT_STATUS; 949 /* FALLTHROUGH */ 950 case MODEKEYEDIT_ENDOFLINE: 951 if (c->prompt_index != size) { 952 c->prompt_index = size; 953 c->flags |= CLIENT_STATUS; 954 } 955 break; 956 case MODEKEYEDIT_COMPLETE: 957 if (*c->prompt_buffer == '\0') 958 break; 959 960 idx = c->prompt_index; 961 if (idx != 0) 962 idx--; 963 964 /* Find the word we are in. */ 965 first = c->prompt_buffer + idx; 966 while (first > c->prompt_buffer && *first != ' ') 967 first--; 968 while (*first == ' ') 969 first++; 970 last = c->prompt_buffer + idx; 971 while (*last != '\0' && *last != ' ') 972 last++; 973 while (*last == ' ') 974 last--; 975 if (*last != '\0') 976 last++; 977 if (last <= first || 978 ((size_t) (last - first)) > (sizeof word) - 1) 979 break; 980 memcpy(word, first, last - first); 981 word[last - first] = '\0'; 982 983 /* And try to complete it. */ 984 if ((s = status_prompt_complete(word)) == NULL) 985 break; 986 987 /* Trim out word. */ 988 n = size - (last - c->prompt_buffer) + 1; /* with \0 */ 989 memmove(first, last, n); 990 size -= last - first; 991 992 /* Insert the new word. */ 993 size += strlen(s); 994 off = first - c->prompt_buffer; 995 c->prompt_buffer = xrealloc(c->prompt_buffer, 1, size + 1); 996 first = c->prompt_buffer + off; 997 memmove(first + strlen(s), first, n); 998 memcpy(first, s, strlen(s)); 999 1000 c->prompt_index = (first - c->prompt_buffer) + strlen(s); 1001 free(s); 1002 1003 c->flags |= CLIENT_STATUS; 1004 break; 1005 case MODEKEYEDIT_BACKSPACE: 1006 if (c->prompt_index != 0) { 1007 if (c->prompt_index == size) 1008 c->prompt_buffer[--c->prompt_index] = '\0'; 1009 else { 1010 memmove(c->prompt_buffer + c->prompt_index - 1, 1011 c->prompt_buffer + c->prompt_index, 1012 size + 1 - c->prompt_index); 1013 c->prompt_index--; 1014 } 1015 c->flags |= CLIENT_STATUS; 1016 } 1017 break; 1018 case MODEKEYEDIT_DELETE: 1019 case MODEKEYEDIT_SWITCHMODESUBSTITUTE: 1020 if (c->prompt_index != size) { 1021 memmove(c->prompt_buffer + c->prompt_index, 1022 c->prompt_buffer + c->prompt_index + 1, 1023 size + 1 - c->prompt_index); 1024 c->flags |= CLIENT_STATUS; 1025 } 1026 break; 1027 case MODEKEYEDIT_DELETELINE: 1028 case MODEKEYEDIT_SWITCHMODESUBSTITUTELINE: 1029 *c->prompt_buffer = '\0'; 1030 c->prompt_index = 0; 1031 c->flags |= CLIENT_STATUS; 1032 break; 1033 case MODEKEYEDIT_DELETETOENDOFLINE: 1034 case MODEKEYEDIT_SWITCHMODECHANGELINE: 1035 if (c->prompt_index < size) { 1036 c->prompt_buffer[c->prompt_index] = '\0'; 1037 c->flags |= CLIENT_STATUS; 1038 } 1039 break; 1040 case MODEKEYEDIT_DELETEWORD: 1041 wsep = options_get_string(oo, "word-separators"); 1042 idx = c->prompt_index; 1043 1044 /* Find a non-separator. */ 1045 while (idx != 0) { 1046 idx--; 1047 if (!strchr(wsep, c->prompt_buffer[idx])) 1048 break; 1049 } 1050 1051 /* Find the separator at the beginning of the word. */ 1052 while (idx != 0) { 1053 idx--; 1054 if (strchr(wsep, c->prompt_buffer[idx])) { 1055 /* Go back to the word. */ 1056 idx++; 1057 break; 1058 } 1059 } 1060 1061 memmove(c->prompt_buffer + idx, 1062 c->prompt_buffer + c->prompt_index, 1063 size + 1 - c->prompt_index); 1064 memset(c->prompt_buffer + size - (c->prompt_index - idx), 1065 '\0', c->prompt_index - idx); 1066 c->prompt_index = idx; 1067 c->flags |= CLIENT_STATUS; 1068 break; 1069 case MODEKEYEDIT_NEXTSPACE: 1070 wsep = " "; 1071 /* FALLTHROUGH */ 1072 case MODEKEYEDIT_NEXTWORD: 1073 if (wsep == NULL) 1074 wsep = options_get_string(oo, "word-separators"); 1075 1076 /* Find a separator. */ 1077 while (c->prompt_index != size) { 1078 c->prompt_index++; 1079 if (strchr(wsep, c->prompt_buffer[c->prompt_index])) 1080 break; 1081 } 1082 1083 /* Find the word right after the separation. */ 1084 while (c->prompt_index != size) { 1085 c->prompt_index++; 1086 if (!strchr(wsep, c->prompt_buffer[c->prompt_index])) 1087 break; 1088 } 1089 1090 c->flags |= CLIENT_STATUS; 1091 break; 1092 case MODEKEYEDIT_NEXTSPACEEND: 1093 wsep = " "; 1094 /* FALLTHROUGH */ 1095 case MODEKEYEDIT_NEXTWORDEND: 1096 if (wsep == NULL) 1097 wsep = options_get_string(oo, "word-separators"); 1098 1099 /* Find a word. */ 1100 while (c->prompt_index != size) { 1101 c->prompt_index++; 1102 if (!strchr(wsep, c->prompt_buffer[c->prompt_index])) 1103 break; 1104 } 1105 1106 /* Find the separator at the end of the word. */ 1107 while (c->prompt_index != size) { 1108 c->prompt_index++; 1109 if (strchr(wsep, c->prompt_buffer[c->prompt_index])) 1110 break; 1111 } 1112 1113 /* Back up to the end-of-word like vi. */ 1114 if (options_get_number(oo, "status-keys") == MODEKEY_VI && 1115 c->prompt_index != 0) 1116 c->prompt_index--; 1117 1118 c->flags |= CLIENT_STATUS; 1119 break; 1120 case MODEKEYEDIT_PREVIOUSSPACE: 1121 wsep = " "; 1122 /* FALLTHROUGH */ 1123 case MODEKEYEDIT_PREVIOUSWORD: 1124 if (wsep == NULL) 1125 wsep = options_get_string(oo, "word-separators"); 1126 1127 /* Find a non-separator. */ 1128 while (c->prompt_index != 0) { 1129 c->prompt_index--; 1130 if (!strchr(wsep, c->prompt_buffer[c->prompt_index])) 1131 break; 1132 } 1133 1134 /* Find the separator at the beginning of the word. */ 1135 while (c->prompt_index != 0) { 1136 c->prompt_index--; 1137 if (strchr(wsep, c->prompt_buffer[c->prompt_index])) { 1138 /* Go back to the word. */ 1139 c->prompt_index++; 1140 break; 1141 } 1142 } 1143 1144 c->flags |= CLIENT_STATUS; 1145 break; 1146 case MODEKEYEDIT_HISTORYUP: 1147 histstr = status_prompt_up_history(&c->prompt_hindex); 1148 if (histstr == NULL) 1149 break; 1150 free(c->prompt_buffer); 1151 c->prompt_buffer = xstrdup(histstr); 1152 c->prompt_index = strlen(c->prompt_buffer); 1153 c->flags |= CLIENT_STATUS; 1154 break; 1155 case MODEKEYEDIT_HISTORYDOWN: 1156 histstr = status_prompt_down_history(&c->prompt_hindex); 1157 if (histstr == NULL) 1158 break; 1159 free(c->prompt_buffer); 1160 c->prompt_buffer = xstrdup(histstr); 1161 c->prompt_index = strlen(c->prompt_buffer); 1162 c->flags |= CLIENT_STATUS; 1163 break; 1164 case MODEKEYEDIT_PASTE: 1165 if ((pb = paste_get_top()) == NULL) 1166 break; 1167 for (n = 0; n < pb->size; n++) { 1168 ch = (u_char) pb->data[n]; 1169 if (ch < 32 || ch == 127) 1170 break; 1171 } 1172 1173 c->prompt_buffer = xrealloc(c->prompt_buffer, 1, size + n + 1); 1174 if (c->prompt_index == size) { 1175 memcpy(c->prompt_buffer + c->prompt_index, pb->data, n); 1176 c->prompt_index += n; 1177 c->prompt_buffer[c->prompt_index] = '\0'; 1178 } else { 1179 memmove(c->prompt_buffer + c->prompt_index + n, 1180 c->prompt_buffer + c->prompt_index, 1181 size + 1 - c->prompt_index); 1182 memcpy(c->prompt_buffer + c->prompt_index, pb->data, n); 1183 c->prompt_index += n; 1184 } 1185 1186 c->flags |= CLIENT_STATUS; 1187 break; 1188 case MODEKEYEDIT_TRANSPOSECHARS: 1189 idx = c->prompt_index; 1190 if (idx < size) 1191 idx++; 1192 if (idx >= 2) { 1193 swapc = c->prompt_buffer[idx - 2]; 1194 c->prompt_buffer[idx - 2] = c->prompt_buffer[idx - 1]; 1195 c->prompt_buffer[idx - 1] = swapc; 1196 c->prompt_index = idx; 1197 c->flags |= CLIENT_STATUS; 1198 } 1199 break; 1200 case MODEKEYEDIT_ENTER: 1201 if (*c->prompt_buffer != '\0') 1202 status_prompt_add_history(c->prompt_buffer); 1203 if (c->prompt_callbackfn(c->prompt_data, c->prompt_buffer) == 0) 1204 status_prompt_clear(c); 1205 break; 1206 case MODEKEYEDIT_CANCEL: 1207 if (c->prompt_callbackfn(c->prompt_data, NULL) == 0) 1208 status_prompt_clear(c); 1209 break; 1210 case MODEKEY_OTHER: 1211 if ((key & 0xff00) != 0 || key < 32 || key == 127) 1212 break; 1213 c->prompt_buffer = xrealloc(c->prompt_buffer, 1, size + 2); 1214 1215 if (c->prompt_index == size) { 1216 c->prompt_buffer[c->prompt_index++] = key; 1217 c->prompt_buffer[c->prompt_index] = '\0'; 1218 } else { 1219 memmove(c->prompt_buffer + c->prompt_index + 1, 1220 c->prompt_buffer + c->prompt_index, 1221 size + 1 - c->prompt_index); 1222 c->prompt_buffer[c->prompt_index++] = key; 1223 } 1224 1225 if (c->prompt_flags & PROMPT_SINGLE) { 1226 if (c->prompt_callbackfn( 1227 c->prompt_data, c->prompt_buffer) == 0) 1228 status_prompt_clear(c); 1229 } 1230 1231 c->flags |= CLIENT_STATUS; 1232 break; 1233 default: 1234 break; 1235 } 1236} 1237 1238/* Get previous line from the history. */ 1239const char * 1240status_prompt_up_history(u_int *idx) 1241{ 1242 u_int size; 1243 1244 /* 1245 * History runs from 0 to size - 1. 1246 * 1247 * Index is from 0 to size. Zero is empty. 1248 */ 1249 1250 size = ARRAY_LENGTH(&status_prompt_history); 1251 if (size == 0 || *idx == size) 1252 return (NULL); 1253 (*idx)++; 1254 return (ARRAY_ITEM(&status_prompt_history, size - *idx)); 1255} 1256 1257/* Get next line from the history. */ 1258const char * 1259status_prompt_down_history(u_int *idx) 1260{ 1261 u_int size; 1262 1263 size = ARRAY_LENGTH(&status_prompt_history); 1264 if (size == 0 || *idx == 0) 1265 return (""); 1266 (*idx)--; 1267 if (*idx == 0) 1268 return (""); 1269 return (ARRAY_ITEM(&status_prompt_history, size - *idx)); 1270} 1271 1272/* Add line to the history. */ 1273void 1274status_prompt_add_history(const char *line) 1275{ 1276 u_int size; 1277 1278 size = ARRAY_LENGTH(&status_prompt_history); 1279 if (size > 0 && strcmp(ARRAY_LAST(&status_prompt_history), line) == 0) 1280 return; 1281 1282 if (size == PROMPT_HISTORY) { 1283 free(ARRAY_FIRST(&status_prompt_history)); 1284 ARRAY_REMOVE(&status_prompt_history, 0); 1285 } 1286 1287 ARRAY_ADD(&status_prompt_history, xstrdup(line)); 1288} 1289 1290/* Complete word. */ 1291char * 1292status_prompt_complete(const char *s) 1293{ 1294 const struct cmd_entry **cmdent; 1295 const struct options_table_entry *oe; 1296 ARRAY_DECL(, const char *) list; 1297 char *prefix, *s2; 1298 u_int i; 1299 size_t j; 1300 1301 if (*s == '\0') 1302 return (NULL); 1303 1304 /* First, build a list of all the possible matches. */ 1305 ARRAY_INIT(&list); 1306 for (cmdent = cmd_table; *cmdent != NULL; cmdent++) { 1307 if (strncmp((*cmdent)->name, s, strlen(s)) == 0) 1308 ARRAY_ADD(&list, (*cmdent)->name); 1309 } 1310 for (oe = server_options_table; oe->name != NULL; oe++) { 1311 if (strncmp(oe->name, s, strlen(s)) == 0) 1312 ARRAY_ADD(&list, oe->name); 1313 } 1314 for (oe = session_options_table; oe->name != NULL; oe++) { 1315 if (strncmp(oe->name, s, strlen(s)) == 0) 1316 ARRAY_ADD(&list, oe->name); 1317 } 1318 for (oe = window_options_table; oe->name != NULL; oe++) { 1319 if (strncmp(oe->name, s, strlen(s)) == 0) 1320 ARRAY_ADD(&list, oe->name); 1321 } 1322 1323 /* If none, bail now. */ 1324 if (ARRAY_LENGTH(&list) == 0) { 1325 ARRAY_FREE(&list); 1326 return (NULL); 1327 } 1328 1329 /* If an exact match, return it, with a trailing space. */ 1330 if (ARRAY_LENGTH(&list) == 1) { 1331 xasprintf(&s2, "%s ", ARRAY_FIRST(&list)); 1332 ARRAY_FREE(&list); 1333 return (s2); 1334 } 1335 1336 /* Now loop through the list and find the longest common prefix. */ 1337 prefix = xstrdup(ARRAY_FIRST(&list)); 1338 for (i = 1; i < ARRAY_LENGTH(&list); i++) { 1339 s = ARRAY_ITEM(&list, i); 1340 1341 j = strlen(s); 1342 if (j > strlen(prefix)) 1343 j = strlen(prefix); 1344 for (; j > 0; j--) { 1345 if (prefix[j - 1] != s[j - 1]) 1346 prefix[j - 1] = '\0'; 1347 } 1348 } 1349 1350 ARRAY_FREE(&list); 1351 return (prefix); 1352} 1353