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