?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add remain-on-exit-format to set text shown when pane is dead.
[tmux-openbsd.git] / window.c
blob2ca3833c139731ff568a1d3f32c21acf6ea42dd5
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include <sys/types.h>
20 #include <sys/ioctl.h>
21
22 #include <ctype.h>
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <fnmatch.h>
26 #include <regex.h>
27 #include <signal.h>
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <time.h>
32 #include <unistd.h>
33 #include <util.h>
34 #include <vis.h>
35
36 #include "tmux.h"
37
38 /*
39 * Each window is attached to a number of panes, each of which is a pty. This
40 * file contains code to handle them.
41 *
42 * A pane has two buffers attached, these are filled and emptied by the main
43 * server poll loop. Output data is received from pty's in screen format,
44 * translated and returned as a series of escape sequences and strings via
45 * input_parse (in input.c). Input data is received as key codes and written
46 * directly via input_key.
47 *
48 * Each pane also has a "virtual" screen (screen.c) which contains the current
49 * state and is redisplayed when the window is reattached to a client.
50 *
51 * Windows are stored directly on a global array and wrapped in any number of
52 * winlink structs to be linked onto local session RB trees. A reference count
53 * is maintained and a window removed from the global list and destroyed when
54 * it reaches zero.
55 */
56
57 /* Global window list. */
58 struct windows windows;
59
60 /* Global panes tree. */
61 struct window_pane_tree all_window_panes;
62 static u_int next_window_pane_id;
63 static u_int next_window_id;
64 static u_int next_active_point;
65
66 struct window_pane_input_data {
67 struct cmdq_item *item;
68 u_int wp;
69 };
70
71 static struct window_pane *window_pane_create(struct window *, u_int, u_int,
72 u_int);
73 static void window_pane_destroy(struct window_pane *);
74
75 RB_GENERATE(windows, window, entry, window_cmp);
76 RB_GENERATE(winlinks, winlink, entry, winlink_cmp);
77 RB_GENERATE(window_pane_tree, window_pane, tree_entry, window_pane_cmp);
78
79 int
80 window_cmp(struct window *w1, struct window *w2)
81 {
82 return (w1->id - w2->id);
83 }
84
85 int
86 winlink_cmp(struct winlink *wl1, struct winlink *wl2)
87 {
88 return (wl1->idx - wl2->idx);
89 }
90
91 int
92 window_pane_cmp(struct window_pane *wp1, struct window_pane *wp2)
93 {
94 return (wp1->id - wp2->id);
95 }
96
97 struct winlink *
98 winlink_find_by_window(struct winlinks *wwl, struct window *w)
99 {
100 struct winlink *wl;
101
102 RB_FOREACH(wl, winlinks, wwl) {
103 if (wl->window == w)
104 return (wl);
105 }
106
107 return (NULL);
108 }
109
110 struct winlink *
111 winlink_find_by_index(struct winlinks *wwl, int idx)
112 {
113 struct winlink wl;
114
115 if (idx < 0)
116 fatalx("bad index");
117
118 wl.idx = idx;
119 return (RB_FIND(winlinks, wwl, &wl));
120 }
121
122 struct winlink *
123 winlink_find_by_window_id(struct winlinks *wwl, u_int id)
124 {
125 struct winlink *wl;
126
127 RB_FOREACH(wl, winlinks, wwl) {
128 if (wl->window->id == id)
129 return (wl);
130 }
131 return (NULL);
132 }
133
134 static int
135 winlink_next_index(struct winlinks *wwl, int idx)
136 {
137 int i;
138
139 i = idx;
140 do {
141 if (winlink_find_by_index(wwl, i) == NULL)
142 return (i);
143 if (i == INT_MAX)
144 i = 0;
145 else
146 i++;
147 } while (i != idx);
148 return (-1);
149 }
150
151 u_int
152 winlink_count(struct winlinks *wwl)
153 {
154 struct winlink *wl;
155 u_int n;
156
157 n = 0;
158 RB_FOREACH(wl, winlinks, wwl)
159 n++;
160
161 return (n);
162 }
163
164 struct winlink *
165 winlink_add(struct winlinks *wwl, int idx)
166 {
167 struct winlink *wl;
168
169 if (idx < 0) {
170 if ((idx = winlink_next_index(wwl, -idx - 1)) == -1)
171 return (NULL);
172 } else if (winlink_find_by_index(wwl, idx) != NULL)
173 return (NULL);
174
175 wl = xcalloc(1, sizeof *wl);
176 wl->idx = idx;
177 RB_INSERT(winlinks, wwl, wl);
178
179 return (wl);
180 }
181
182 void
183 winlink_set_window(struct winlink *wl, struct window *w)
184 {
185 if (wl->window != NULL) {
186 TAILQ_REMOVE(&wl->window->winlinks, wl, wentry);
187 window_remove_ref(wl->window, __func__);
188 }
189 TAILQ_INSERT_TAIL(&w->winlinks, wl, wentry);
190 wl->window = w;
191 window_add_ref(w, __func__);
192 }
193
194 void
195 winlink_remove(struct winlinks *wwl, struct winlink *wl)
196 {
197 struct window *w = wl->window;
198
199 if (w != NULL) {
200 TAILQ_REMOVE(&w->winlinks, wl, wentry);
201 window_remove_ref(w, __func__);
202 }
203
204 RB_REMOVE(winlinks, wwl, wl);
205 free(wl);
206 }
207
208 struct winlink *
209 winlink_next(struct winlink *wl)
210 {
211 return (RB_NEXT(winlinks, wwl, wl));
212 }
213
214 struct winlink *
215 winlink_previous(struct winlink *wl)
216 {
217 return (RB_PREV(winlinks, wwl, wl));
218 }
219
220 struct winlink *
221 winlink_next_by_number(struct winlink *wl, struct session *s, int n)
222 {
223 for (; n > 0; n--) {
224 if ((wl = RB_NEXT(winlinks, wwl, wl)) == NULL)
225 wl = RB_MIN(winlinks, &s->windows);
226 }
227
228 return (wl);
229 }
230
231 struct winlink *
232 winlink_previous_by_number(struct winlink *wl, struct session *s, int n)
233 {
234 for (; n > 0; n--) {
235 if ((wl = RB_PREV(winlinks, wwl, wl)) == NULL)
236 wl = RB_MAX(winlinks, &s->windows);
237 }
238
239 return (wl);
240 }
241
242 void
243 winlink_stack_push(struct winlink_stack *stack, struct winlink *wl)
244 {
245 if (wl == NULL)
246 return;
247
248 winlink_stack_remove(stack, wl);
249 TAILQ_INSERT_HEAD(stack, wl, sentry);
250 }
251
252 void
253 winlink_stack_remove(struct winlink_stack *stack, struct winlink *wl)
254 {
255 struct winlink *wl2;
256
257 if (wl == NULL)
258 return;
259
260 TAILQ_FOREACH(wl2, stack, sentry) {
261 if (wl2 == wl) {
262 TAILQ_REMOVE(stack, wl, sentry);
263 return;
264 }
265 }
266 }
267
268 struct window *
269 window_find_by_id_str(const char *s)
270 {
271 const char *errstr;
272 u_int id;
273
274 if (*s != '@')
275 return (NULL);
276
277 id = strtonum(s + 1, 0, UINT_MAX, &errstr);
278 if (errstr != NULL)
279 return (NULL);
280 return (window_find_by_id(id));
281 }
282
283 struct window *
284 window_find_by_id(u_int id)
285 {
286 struct window w;
287
288 w.id = id;
289 return (RB_FIND(windows, &windows, &w));
290 }
291
292 void
293 window_update_activity(struct window *w)
294 {
295 gettimeofday(&w->activity_time, NULL);
296 alerts_queue(w, WINDOW_ACTIVITY);
297 }
298
299 struct window *
300 window_create(u_int sx, u_int sy, u_int xpixel, u_int ypixel)
301 {
302 struct window *w;
303
304 if (xpixel == 0)
305 xpixel = DEFAULT_XPIXEL;
306 if (ypixel == 0)
307 ypixel = DEFAULT_YPIXEL;
308
309 w = xcalloc(1, sizeof *w);
310 w->name = xstrdup("");
311 w->flags = 0;
312
313 TAILQ_INIT(&w->panes);
314 w->active = NULL;
315
316 w->lastlayout = -1;
317 w->layout_root = NULL;
318
319 w->sx = sx;
320 w->sy = sy;
321 w->manual_sx = sx;
322 w->manual_sy = sy;
323 w->xpixel = xpixel;
324 w->ypixel = ypixel;
325
326 w->options = options_create(global_w_options);
327
328 w->references = 0;
329 TAILQ_INIT(&w->winlinks);
330
331 w->id = next_window_id++;
332 RB_INSERT(windows, &windows, w);
333
334 window_update_activity(w);
335
336 log_debug("%s: @%u create %ux%u (%ux%u)", __func__, w->id, sx, sy,
337 w->xpixel, w->ypixel);
338 return (w);
339 }
340
341 static void
342 window_destroy(struct window *w)
343 {
344 log_debug("window @%u destroyed (%d references)", w->id, w->references);
345
346 RB_REMOVE(windows, &windows, w);
347
348 if (w->layout_root != NULL)
349 layout_free_cell(w->layout_root);
350 if (w->saved_layout_root != NULL)
351 layout_free_cell(w->saved_layout_root);
352 free(w->old_layout);
353
354 window_destroy_panes(w);
355
356 if (event_initialized(&w->name_event))
357 evtimer_del(&w->name_event);
358
359 if (event_initialized(&w->alerts_timer))
360 evtimer_del(&w->alerts_timer);
361 if (event_initialized(&w->offset_timer))
362 event_del(&w->offset_timer);
363
364 options_free(w->options);
365
366 free(w->name);
367 free(w);
368 }
369
370 int
371 window_pane_destroy_ready(struct window_pane *wp)
372 {
373 int n;
374
375 if (wp->pipe_fd != -1) {
376 if (EVBUFFER_LENGTH(wp->pipe_event->output) != 0)
377 return (0);
378 if (ioctl(wp->fd, FIONREAD, &n) != -1 && n > 0)
379 return (0);
380 }
381
382 if (~wp->flags & PANE_EXITED)
383 return (0);
384 return (1);
385 }
386
387 void
388 window_add_ref(struct window *w, const char *from)
389 {
390 w->references++;
391 log_debug("%s: @%u %s, now %d", __func__, w->id, from, w->references);
392 }
393
394 void
395 window_remove_ref(struct window *w, const char *from)
396 {
397 w->references--;
398 log_debug("%s: @%u %s, now %d", __func__, w->id, from, w->references);
399
400 if (w->references == 0)
401 window_destroy(w);
402 }
403
404 void
405 window_set_name(struct window *w, const char *new_name)
406 {
407 free(w->name);
408 utf8_stravis(&w->name, new_name, VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL);
409 notify_window("window-renamed", w);
410 }
411
412 void
413 window_resize(struct window *w, u_int sx, u_int sy, int xpixel, int ypixel)
414 {
415 if (xpixel == 0)
416 xpixel = DEFAULT_XPIXEL;
417 if (ypixel == 0)
418 ypixel = DEFAULT_YPIXEL;
419
420 log_debug("%s: @%u resize %ux%u (%ux%u)", __func__, w->id, sx, sy,
421 xpixel == -1 ? w->xpixel : (u_int)xpixel,
422 ypixel == -1 ? w->ypixel : (u_int)ypixel);
423 w->sx = sx;
424 w->sy = sy;
425 if (xpixel != -1)
426 w->xpixel = xpixel;
427 if (ypixel != -1)
428 w->ypixel = ypixel;
429 }
430
431 void
432 window_pane_send_resize(struct window_pane *wp, u_int sx, u_int sy)
433 {
434 struct window *w = wp->window;
435 struct winsize ws;
436
437 if (wp->fd == -1)
438 return;
439
440 log_debug("%s: %%%u resize to %u,%u", __func__, wp->id, sx, sy);
441
442 memset(&ws, 0, sizeof ws);
443 ws.ws_col = sx;
444 ws.ws_row = sy;
445 ws.ws_xpixel = w->xpixel * ws.ws_col;
446 ws.ws_ypixel = w->ypixel * ws.ws_row;
447 if (ioctl(wp->fd, TIOCSWINSZ, &ws) == -1)
448 fatal("ioctl failed");
449 }
450
451 int
452 window_has_pane(struct window *w, struct window_pane *wp)
453 {
454 struct window_pane *wp1;
455
456 TAILQ_FOREACH(wp1, &w->panes, entry) {
457 if (wp1 == wp)
458 return (1);
459 }
460 return (0);
461 }
462
463 void
464 window_update_focus(struct window *w)
465 {
466 if (w != NULL) {
467 log_debug("%s: @%u", __func__, w->id);
468 window_pane_update_focus(w->active);
469 }
470 }
471
472 void
473 window_pane_update_focus(struct window_pane *wp)
474 {
475 struct client *c;
476 int focused = 0;
477
478 if (wp != NULL) {
479 if (wp != wp->window->active)
480 focused = 0;
481 else {
482 TAILQ_FOREACH(c, &clients, entry) {
483 if (c->session != NULL &&
484 c->session->attached != 0 &&
485 (c->flags & CLIENT_FOCUSED) &&
486 c->session->curw->window == wp->window) {
487 focused = 1;
488 break;
489 }
490 }
491 }
492 if (!focused && (wp->flags & PANE_FOCUSED)) {
493 log_debug("%s: %%%u focus out", __func__, wp->id);
494 if (wp->base.mode & MODE_FOCUSON)
495 bufferevent_write(wp->event, "\033[O", 3);
496 notify_pane("pane-focus-out", wp);
497 wp->flags &= ~PANE_FOCUSED;
498 } else if (focused && (~wp->flags & PANE_FOCUSED)) {
499 log_debug("%s: %%%u focus in", __func__, wp->id);
500 if (wp->base.mode & MODE_FOCUSON)
501 bufferevent_write(wp->event, "\033[I", 3);
502 notify_pane("pane-focus-in", wp);
503 wp->flags |= PANE_FOCUSED;
504 } else
505 log_debug("%s: %%%u focus unchanged", __func__, wp->id);
506 }
507 }
508
509 int
510 window_set_active_pane(struct window *w, struct window_pane *wp, int notify)
511 {
512 log_debug("%s: pane %%%u", __func__, wp->id);
513
514 if (wp == w->active)
515 return (0);
516 w->last = w->active;
517
518 w->active = wp;
519 w->active->active_point = next_active_point++;
520 w->active->flags |= PANE_CHANGED;
521
522 if (options_get_number(global_options, "focus-events")) {
523 window_pane_update_focus(w->last);
524 window_pane_update_focus(w->active);
525 }
526
527 tty_update_window_offset(w);
528
529 if (notify)
530 notify_window("window-pane-changed", w);
531 return (1);
532 }
533
534 static int
535 window_pane_get_palette(struct window_pane *wp, int c)
536 {
537 if (wp == NULL)
538 return (-1);
539 return (colour_palette_get(&wp->palette, c));
540 }
541
542 void
543 window_redraw_active_switch(struct window *w, struct window_pane *wp)
544 {
545 struct grid_cell *gc1, *gc2;
546 int c1, c2;
547
548 if (wp == w->active)
549 return;
550
551 for (;;) {
552 /*
553 * If the active and inactive styles or palettes are different,
554 * need to redraw the panes.
555 */
556 gc1 = &wp->cached_gc;
557 gc2 = &wp->cached_active_gc;
558 if (!grid_cells_look_equal(gc1, gc2))
559 wp->flags |= PANE_REDRAW;
560 else {
561 c1 = window_pane_get_palette(wp, gc1->fg);
562 c2 = window_pane_get_palette(wp, gc2->fg);
563 if (c1 != c2)
564 wp->flags |= PANE_REDRAW;
565 else {
566 c1 = window_pane_get_palette(wp, gc1->bg);
567 c2 = window_pane_get_palette(wp, gc2->bg);
568 if (c1 != c2)
569 wp->flags |= PANE_REDRAW;
570 }
571 }
572 if (wp == w->active)
573 break;
574 wp = w->active;
575 }
576 }
577
578 struct window_pane *
579 window_get_active_at(struct window *w, u_int x, u_int y)
580 {
581 struct window_pane *wp;
582
583 TAILQ_FOREACH(wp, &w->panes, entry) {
584 if (!window_pane_visible(wp))
585 continue;
586 if (x < wp->xoff || x > wp->xoff + wp->sx)
587 continue;
588 if (y < wp->yoff || y > wp->yoff + wp->sy)
589 continue;
590 return (wp);
591 }
592 return (NULL);
593 }
594
595 struct window_pane *
596 window_find_string(struct window *w, const char *s)
597 {
598 u_int x, y, top = 0, bottom = w->sy - 1;
599 int status;
600
601 x = w->sx / 2;
602 y = w->sy / 2;
603
604 status = options_get_number(w->options, "pane-border-status");
605 if (status == PANE_STATUS_TOP)
606 top++;
607 else if (status == PANE_STATUS_BOTTOM)
608 bottom--;
609
610 if (strcasecmp(s, "top") == 0)
611 y = top;
612 else if (strcasecmp(s, "bottom") == 0)
613 y = bottom;
614 else if (strcasecmp(s, "left") == 0)
615 x = 0;
616 else if (strcasecmp(s, "right") == 0)
617 x = w->sx - 1;
618 else if (strcasecmp(s, "top-left") == 0) {
619 x = 0;
620 y = top;
621 } else if (strcasecmp(s, "top-right") == 0) {
622 x = w->sx - 1;
623 y = top;
624 } else if (strcasecmp(s, "bottom-left") == 0) {
625 x = 0;
626 y = bottom;
627 } else if (strcasecmp(s, "bottom-right") == 0) {
628 x = w->sx - 1;
629 y = bottom;
630 } else
631 return (NULL);
632
633 return (window_get_active_at(w, x, y));
634 }
635
636 int
637 window_zoom(struct window_pane *wp)
638 {
639 struct window *w = wp->window;
640 struct window_pane *wp1;
641
642 if (w->flags & WINDOW_ZOOMED)
643 return (-1);
644
645 if (window_count_panes(w) == 1)
646 return (-1);
647
648 if (w->active != wp)
649 window_set_active_pane(w, wp, 1);
650
651 TAILQ_FOREACH(wp1, &w->panes, entry) {
652 wp1->saved_layout_cell = wp1->layout_cell;
653 wp1->layout_cell = NULL;
654 }
655
656 w->saved_layout_root = w->layout_root;
657 layout_init(w, wp);
658 w->flags |= WINDOW_ZOOMED;
659 notify_window("window-layout-changed", w);
660
661 return (0);
662 }
663
664 int
665 window_unzoom(struct window *w)
666 {
667 struct window_pane *wp;
668
669 if (!(w->flags & WINDOW_ZOOMED))
670 return (-1);
671
672 w->flags &= ~WINDOW_ZOOMED;
673 layout_free(w);
674 w->layout_root = w->saved_layout_root;
675 w->saved_layout_root = NULL;
676
677 TAILQ_FOREACH(wp, &w->panes, entry) {
678 wp->layout_cell = wp->saved_layout_cell;
679 wp->saved_layout_cell = NULL;
680 }
681 layout_fix_panes(w, NULL);
682 notify_window("window-layout-changed", w);
683
684 return (0);
685 }
686
687 int
688 window_push_zoom(struct window *w, int always, int flag)
689 {
690 log_debug("%s: @%u %d", __func__, w->id,
691 flag && (w->flags & WINDOW_ZOOMED));
692 if (flag && (always || (w->flags & WINDOW_ZOOMED)))
693 w->flags |= WINDOW_WASZOOMED;
694 else
695 w->flags &= ~WINDOW_WASZOOMED;
696 return (window_unzoom(w) == 0);
697 }
698
699 int
700 window_pop_zoom(struct window *w)
701 {
702 log_debug("%s: @%u %d", __func__, w->id,
703 !!(w->flags & WINDOW_WASZOOMED));
704 if (w->flags & WINDOW_WASZOOMED)
705 return (window_zoom(w->active) == 0);
706 return (0);
707 }
708
709 struct window_pane *
710 window_add_pane(struct window *w, struct window_pane *other, u_int hlimit,
711 int flags)
712 {
713 struct window_pane *wp;
714
715 if (other == NULL)
716 other = w->active;
717
718 wp = window_pane_create(w, w->sx, w->sy, hlimit);
719 if (TAILQ_EMPTY(&w->panes)) {
720 log_debug("%s: @%u at start", __func__, w->id);
721 TAILQ_INSERT_HEAD(&w->panes, wp, entry);
722 } else if (flags & SPAWN_BEFORE) {
723 log_debug("%s: @%u before %%%u", __func__, w->id, wp->id);
724 if (flags & SPAWN_FULLSIZE)
725 TAILQ_INSERT_HEAD(&w->panes, wp, entry);
726 else
727 TAILQ_INSERT_BEFORE(other, wp, entry);
728 } else {
729 log_debug("%s: @%u after %%%u", __func__, w->id, wp->id);
730 if (flags & SPAWN_FULLSIZE)
731 TAILQ_INSERT_TAIL(&w->panes, wp, entry);
732 else
733 TAILQ_INSERT_AFTER(&w->panes, other, wp, entry);
734 }
735 return (wp);
736 }
737
738 void
739 window_lost_pane(struct window *w, struct window_pane *wp)
740 {
741 log_debug("%s: @%u pane %%%u", __func__, w->id, wp->id);
742
743 if (wp == marked_pane.wp)
744 server_clear_marked();
745
746 if (wp == w->active) {
747 w->active = w->last;
748 w->last = NULL;
749 if (w->active == NULL) {
750 w->active = TAILQ_PREV(wp, window_panes, entry);
751 if (w->active == NULL)
752 w->active = TAILQ_NEXT(wp, entry);
753 }
754 if (w->active != NULL) {
755 w->active->flags |= PANE_CHANGED;
756 notify_window("window-pane-changed", w);
757 window_update_focus(w);
758 }
759 } else if (wp == w->last)
760 w->last = NULL;
761 }
762
763 void
764 window_remove_pane(struct window *w, struct window_pane *wp)
765 {
766 window_lost_pane(w, wp);
767
768 TAILQ_REMOVE(&w->panes, wp, entry);
769 window_pane_destroy(wp);
770 }
771
772 struct window_pane *
773 window_pane_at_index(struct window *w, u_int idx)
774 {
775 struct window_pane *wp;
776 u_int n;
777
778 n = options_get_number(w->options, "pane-base-index");
779 TAILQ_FOREACH(wp, &w->panes, entry) {
780 if (n == idx)
781 return (wp);
782 n++;
783 }
784 return (NULL);
785 }
786
787 struct window_pane *
788 window_pane_next_by_number(struct window *w, struct window_pane *wp, u_int n)
789 {
790 for (; n > 0; n--) {
791 if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
792 wp = TAILQ_FIRST(&w->panes);
793 }
794
795 return (wp);
796 }
797
798 struct window_pane *
799 window_pane_previous_by_number(struct window *w, struct window_pane *wp,
800 u_int n)
801 {
802 for (; n > 0; n--) {
803 if ((wp = TAILQ_PREV(wp, window_panes, entry)) == NULL)
804 wp = TAILQ_LAST(&w->panes, window_panes);
805 }
806
807 return (wp);
808 }
809
810 int
811 window_pane_index(struct window_pane *wp, u_int *i)
812 {
813 struct window_pane *wq;
814 struct window *w = wp->window;
815
816 *i = options_get_number(w->options, "pane-base-index");
817 TAILQ_FOREACH(wq, &w->panes, entry) {
818 if (wp == wq) {
819 return (0);
820 }
821 (*i)++;
822 }
823
824 return (-1);
825 }
826
827 u_int
828 window_count_panes(struct window *w)
829 {
830 struct window_pane *wp;
831 u_int n;
832
833 n = 0;
834 TAILQ_FOREACH(wp, &w->panes, entry)
835 n++;
836 return (n);
837 }
838
839 void
840 window_destroy_panes(struct window *w)
841 {
842 struct window_pane *wp;
843
844 while (!TAILQ_EMPTY(&w->panes)) {
845 wp = TAILQ_FIRST(&w->panes);
846 TAILQ_REMOVE(&w->panes, wp, entry);
847 window_pane_destroy(wp);
848 }
849 }
850
851 const char *
852 window_printable_flags(struct winlink *wl, int escape)
853 {
854 struct session *s = wl->session;
855 static char flags[32];
856 int pos;
857
858 pos = 0;
859 if (wl->flags & WINLINK_ACTIVITY) {
860 flags[pos++] = '#';
861 if (escape)
862 flags[pos++] = '#';
863 }
864 if (wl->flags & WINLINK_BELL)
865 flags[pos++] = '!';
866 if (wl->flags & WINLINK_SILENCE)
867 flags[pos++] = '~';
868 if (wl == s->curw)
869 flags[pos++] = '*';
870 if (wl == TAILQ_FIRST(&s->lastw))
871 flags[pos++] = '-';
872 if (server_check_marked() && wl == marked_pane.wl)
873 flags[pos++] = 'M';
874 if (wl->window->flags & WINDOW_ZOOMED)
875 flags[pos++] = 'Z';
876 flags[pos] = '\0';
877 return (flags);
878 }
879
880 struct window_pane *
881 window_pane_find_by_id_str(const char *s)
882 {
883 const char *errstr;
884 u_int id;
885
886 if (*s != '%')
887 return (NULL);
888
889 id = strtonum(s + 1, 0, UINT_MAX, &errstr);
890 if (errstr != NULL)
891 return (NULL);
892 return (window_pane_find_by_id(id));
893 }
894
895 struct window_pane *
896 window_pane_find_by_id(u_int id)
897 {
898 struct window_pane wp;
899
900 wp.id = id;
901 return (RB_FIND(window_pane_tree, &all_window_panes, &wp));
902 }
903
904 static struct window_pane *
905 window_pane_create(struct window *w, u_int sx, u_int sy, u_int hlimit)
906 {
907 struct window_pane *wp;
908 char host[HOST_NAME_MAX + 1];
909
910 wp = xcalloc(1, sizeof *wp);
911 wp->window = w;
912 wp->options = options_create(w->options);
913 wp->flags = PANE_STYLECHANGED;
914
915 wp->id = next_window_pane_id++;
916 RB_INSERT(window_pane_tree, &all_window_panes, wp);
917
918 wp->fd = -1;
919
920 TAILQ_INIT(&wp->modes);
921
922 TAILQ_INIT (&wp->resize_queue);
923
924 wp->sx = sx;
925 wp->sy = sy;
926
927 wp->pipe_fd = -1;
928
929 colour_palette_init(&wp->palette);
930 colour_palette_from_option(&wp->palette, wp->options);
931
932 screen_init(&wp->base, sx, sy, hlimit);
933 wp->screen = &wp->base;
934
935 screen_init(&wp->status_screen, 1, 1, 0);
936
937 if (gethostname(host, sizeof host) == 0)
938 screen_set_title(&wp->base, host);
939
940 return (wp);
941 }
942
943 static void
944 window_pane_destroy(struct window_pane *wp)
945 {
946 struct window_pane_resize *r;
947 struct window_pane_resize *r1;
948
949 window_pane_reset_mode_all(wp);
950 free(wp->searchstr);
951
952 if (wp->fd != -1) {
953 bufferevent_free(wp->event);
954 close(wp->fd);
955 }
956 if (wp->ictx != NULL)
957 input_free(wp->ictx);
958
959 screen_free(&wp->status_screen);
960
961 screen_free(&wp->base);
962
963 if (wp->pipe_fd != -1) {
964 bufferevent_free(wp->pipe_event);
965 close(wp->pipe_fd);
966 }
967
968 if (event_initialized(&wp->resize_timer))
969 event_del(&wp->resize_timer);
970 TAILQ_FOREACH_SAFE(r, &wp->resize_queue, entry, r1) {
971 TAILQ_REMOVE(&wp->resize_queue, r, entry);
972 free(r);
973 }
974
975 RB_REMOVE(window_pane_tree, &all_window_panes, wp);
976
977 options_free(wp->options);
978 free((void *)wp->cwd);
979 free(wp->shell);
980 cmd_free_argv(wp->argc, wp->argv);
981 colour_palette_free(&wp->palette);
982 free(wp);
983 }
984
985 static void
986 window_pane_read_callback(__unused struct bufferevent *bufev, void *data)
987 {
988 struct window_pane *wp = data;
989 struct evbuffer *evb = wp->event->input;
990 struct window_pane_offset *wpo = &wp->pipe_offset;
991 size_t size = EVBUFFER_LENGTH(evb);
992 char *new_data;
993 size_t new_size;
994 struct client *c;
995
996 if (wp->pipe_fd != -1) {
997 new_data = window_pane_get_new_data(wp, wpo, &new_size);
998 if (new_size > 0) {
999 bufferevent_write(wp->pipe_event, new_data, new_size);
1000 window_pane_update_used_data(wp, wpo, new_size);
1001 }
1002 }
1003
1004 log_debug("%%%u has %zu bytes", wp->id, size);
1005 TAILQ_FOREACH(c, &clients, entry) {
1006 if (c->session != NULL && (c->flags & CLIENT_CONTROL))
1007 control_write_output(c, wp);
1008 }
1009 input_parse_pane(wp);
1010 bufferevent_disable(wp->event, EV_READ);
1011 }
1012
1013 static void
1014 window_pane_error_callback(__unused struct bufferevent *bufev,
1015 __unused short what, void *data)
1016 {
1017 struct window_pane *wp = data;
1018
1019 log_debug("%%%u error", wp->id);
1020 wp->flags |= PANE_EXITED;
1021
1022 if (window_pane_destroy_ready(wp))
1023 server_destroy_pane(wp, 1);
1024 }
1025
1026 void
1027 window_pane_set_event(struct window_pane *wp)
1028 {
1029 setblocking(wp->fd, 0);
1030
1031 wp->event = bufferevent_new(wp->fd, window_pane_read_callback,
1032 NULL, window_pane_error_callback, wp);
1033 wp->ictx = input_init(wp, wp->event, &wp->palette);
1034
1035 bufferevent_enable(wp->event, EV_READ|EV_WRITE);
1036 }
1037
1038 void
1039 window_pane_resize(struct window_pane *wp, u_int sx, u_int sy)
1040 {
1041 struct window_mode_entry *wme;
1042 struct window_pane_resize *r;
1043
1044 if (sx == wp->sx && sy == wp->sy)
1045 return;
1046
1047 r = xmalloc (sizeof *r);
1048 r->sx = sx;
1049 r->sy = sy;
1050 r->osx = wp->sx;
1051 r->osy = wp->sy;
1052 TAILQ_INSERT_TAIL (&wp->resize_queue, r, entry);
1053
1054 wp->sx = sx;
1055 wp->sy = sy;
1056
1057 log_debug("%s: %%%u resize %ux%u", __func__, wp->id, sx, sy);
1058 screen_resize(&wp->base, sx, sy, wp->base.saved_grid == NULL);
1059
1060 wme = TAILQ_FIRST(&wp->modes);
1061 if (wme != NULL && wme->mode->resize != NULL)
1062 wme->mode->resize(wme, sx, sy);
1063 }
1064
1065 int
1066 window_pane_set_mode(struct window_pane *wp, struct window_pane *swp,
1067 const struct window_mode *mode, struct cmd_find_state *fs,
1068 struct args *args)
1069 {
1070 struct window_mode_entry *wme;
1071
1072 if (!TAILQ_EMPTY(&wp->modes) && TAILQ_FIRST(&wp->modes)->mode == mode)
1073 return (1);
1074
1075 TAILQ_FOREACH(wme, &wp->modes, entry) {
1076 if (wme->mode == mode)
1077 break;
1078 }
1079 if (wme != NULL) {
1080 TAILQ_REMOVE(&wp->modes, wme, entry);
1081 TAILQ_INSERT_HEAD(&wp->modes, wme, entry);
1082 } else {
1083 wme = xcalloc(1, sizeof *wme);
1084 wme->wp = wp;
1085 wme->swp = swp;
1086 wme->mode = mode;
1087 wme->prefix = 1;
1088 TAILQ_INSERT_HEAD(&wp->modes, wme, entry);
1089 wme->screen = wme->mode->init(wme, fs, args);
1090 }
1091
1092 wp->screen = wme->screen;
1093 wp->flags |= (PANE_REDRAW|PANE_CHANGED);
1094
1095 server_redraw_window_borders(wp->window);
1096 server_status_window(wp->window);
1097 notify_pane("pane-mode-changed", wp);
1098
1099 return (0);
1100 }
1101
1102 void
1103 window_pane_reset_mode(struct window_pane *wp)
1104 {
1105 struct window_mode_entry *wme, *next;
1106
1107 if (TAILQ_EMPTY(&wp->modes))
1108 return;
1109
1110 wme = TAILQ_FIRST(&wp->modes);
1111 TAILQ_REMOVE(&wp->modes, wme, entry);
1112 wme->mode->free(wme);
1113 free(wme);
1114
1115 next = TAILQ_FIRST(&wp->modes);
1116 if (next == NULL) {
1117 log_debug("%s: no next mode", __func__);
1118 wp->screen = &wp->base;
1119 } else {
1120 log_debug("%s: next mode is %s", __func__, next->mode->name);
1121 wp->screen = next->screen;
1122 if (next->mode->resize != NULL)
1123 next->mode->resize(next, wp->sx, wp->sy);
1124 }
1125 wp->flags |= (PANE_REDRAW|PANE_CHANGED);
1126
1127 server_redraw_window_borders(wp->window);
1128 server_status_window(wp->window);
1129 notify_pane("pane-mode-changed", wp);
1130 }
1131
1132 void
1133 window_pane_reset_mode_all(struct window_pane *wp)
1134 {
1135 while (!TAILQ_EMPTY(&wp->modes))
1136 window_pane_reset_mode(wp);
1137 }
1138
1139 static void
1140 window_pane_copy_key(struct window_pane *wp, key_code key)
1141 {
1142 struct window_pane *loop;
1143
1144 TAILQ_FOREACH(loop, &wp->window->panes, entry) {
1145 if (loop != wp &&
1146 TAILQ_EMPTY(&loop->modes) &&
1147 loop->fd != -1 &&
1148 (~loop->flags & PANE_INPUTOFF) &&
1149 window_pane_visible(loop) &&
1150 options_get_number(loop->options, "synchronize-panes"))
1151 input_key_pane(loop, key, NULL);
1152 }
1153 }
1154
1155 int
1156 window_pane_key(struct window_pane *wp, struct client *c, struct session *s,
1157 struct winlink *wl, key_code key, struct mouse_event *m)
1158 {
1159 struct window_mode_entry *wme;
1160
1161 if (KEYC_IS_MOUSE(key) && m == NULL)
1162 return (-1);
1163
1164 wme = TAILQ_FIRST(&wp->modes);
1165 if (wme != NULL) {
1166 if (wme->mode->key != NULL && c != NULL) {
1167 key &= ~KEYC_MASK_FLAGS;
1168 wme->mode->key(wme, c, s, wl, key, m);
1169 }
1170 return (0);
1171 }
1172
1173 if (wp->fd == -1 || wp->flags & PANE_INPUTOFF)
1174 return (0);
1175
1176 if (input_key_pane(wp, key, m) != 0)
1177 return (-1);
1178
1179 if (KEYC_IS_MOUSE(key))
1180 return (0);
1181 if (options_get_number(wp->options, "synchronize-panes"))
1182 window_pane_copy_key(wp, key);
1183 return (0);
1184 }
1185
1186 int
1187 window_pane_visible(struct window_pane *wp)
1188 {
1189 if (~wp->window->flags & WINDOW_ZOOMED)
1190 return (1);
1191 return (wp == wp->window->active);
1192 }
1193
1194 u_int
1195 window_pane_search(struct window_pane *wp, const char *term, int regex,
1196 int ignore)
1197 {
1198 struct screen *s = &wp->base;
1199 regex_t r;
1200 char *new = NULL, *line;
1201 u_int i;
1202 int flags = 0, found;
1203 size_t n;
1204
1205 if (!regex) {
1206 if (ignore)
1207 flags |= FNM_CASEFOLD;
1208 xasprintf(&new, "*%s*", term);
1209 } else {
1210 if (ignore)
1211 flags |= REG_ICASE;
1212 if (regcomp(&r, term, flags|REG_EXTENDED) != 0)
1213 return (0);
1214 }
1215
1216 for (i = 0; i < screen_size_y(s); i++) {
1217 line = grid_view_string_cells(s->grid, 0, i, screen_size_x(s));
1218 for (n = strlen(line); n > 0; n--) {
1219 if (!isspace((u_char)line[n - 1]))
1220 break;
1221 line[n - 1] = '\0';
1222 }
1223 log_debug("%s: %s", __func__, line);
1224 if (!regex)
1225 found = (fnmatch(new, line, flags) == 0);
1226 else
1227 found = (regexec(&r, line, 0, NULL, 0) == 0);
1228 free(line);
1229 if (found)
1230 break;
1231 }
1232 if (!regex)
1233 free(new);
1234 else
1235 regfree(&r);
1236
1237 if (i == screen_size_y(s))
1238 return (0);
1239 return (i + 1);
1240 }
1241
1242 /* Get MRU pane from a list. */
1243 static struct window_pane *
1244 window_pane_choose_best(struct window_pane **list, u_int size)
1245 {
1246 struct window_pane *next, *best;
1247 u_int i;
1248
1249 if (size == 0)
1250 return (NULL);
1251
1252 best = list[0];
1253 for (i = 1; i < size; i++) {
1254 next = list[i];
1255 if (next->active_point > best->active_point)
1256 best = next;
1257 }
1258 return (best);
1259 }
1260
1261 /*
1262 * Find the pane directly above another. We build a list of those adjacent to
1263 * top edge and then choose the best.
1264 */
1265 struct window_pane *
1266 window_pane_find_up(struct window_pane *wp)
1267 {
1268 struct window *w;
1269 struct window_pane *next, *best, **list;
1270 u_int edge, left, right, end, size;
1271 int status, found;
1272
1273 if (wp == NULL)
1274 return (NULL);
1275 w = wp->window;
1276 status = options_get_number(w->options, "pane-border-status");
1277
1278 list = NULL;
1279 size = 0;
1280
1281 edge = wp->yoff;
1282 if (status == PANE_STATUS_TOP) {
1283 if (edge == 1)
1284 edge = w->sy + 1;
1285 } else if (status == PANE_STATUS_BOTTOM) {
1286 if (edge == 0)
1287 edge = w->sy;
1288 } else {
1289 if (edge == 0)
1290 edge = w->sy + 1;
1291 }
1292
1293 left = wp->xoff;
1294 right = wp->xoff + wp->sx;
1295
1296 TAILQ_FOREACH(next, &w->panes, entry) {
1297 if (next == wp)
1298 continue;
1299 if (next->yoff + next->sy + 1 != edge)
1300 continue;
1301 end = next->xoff + next->sx - 1;
1302
1303 found = 0;
1304 if (next->xoff < left && end > right)
1305 found = 1;
1306 else if (next->xoff >= left && next->xoff <= right)
1307 found = 1;
1308 else if (end >= left && end <= right)
1309 found = 1;
1310 if (!found)
1311 continue;
1312 list = xreallocarray(list, size + 1, sizeof *list);
1313 list[size++] = next;
1314 }
1315
1316 best = window_pane_choose_best(list, size);
1317 free(list);
1318 return (best);
1319 }
1320
1321 /* Find the pane directly below another. */
1322 struct window_pane *
1323 window_pane_find_down(struct window_pane *wp)
1324 {
1325 struct window *w;
1326 struct window_pane *next, *best, **list;
1327 u_int edge, left, right, end, size;
1328 int status, found;
1329
1330 if (wp == NULL)
1331 return (NULL);
1332 w = wp->window;
1333 status = options_get_number(w->options, "pane-border-status");
1334
1335 list = NULL;
1336 size = 0;
1337
1338 edge = wp->yoff + wp->sy + 1;
1339 if (status == PANE_STATUS_TOP) {
1340 if (edge >= w->sy)
1341 edge = 1;
1342 } else if (status == PANE_STATUS_BOTTOM) {
1343 if (edge >= w->sy - 1)
1344 edge = 0;
1345 } else {
1346 if (edge >= w->sy)
1347 edge = 0;
1348 }
1349
1350 left = wp->xoff;
1351 right = wp->xoff + wp->sx;
1352
1353 TAILQ_FOREACH(next, &w->panes, entry) {
1354 if (next == wp)
1355 continue;
1356 if (next->yoff != edge)
1357 continue;
1358 end = next->xoff + next->sx - 1;
1359
1360 found = 0;
1361 if (next->xoff < left && end > right)
1362 found = 1;
1363 else if (next->xoff >= left && next->xoff <= right)
1364 found = 1;
1365 else if (end >= left && end <= right)
1366 found = 1;
1367 if (!found)
1368 continue;
1369 list = xreallocarray(list, size + 1, sizeof *list);
1370 list[size++] = next;
1371 }
1372
1373 best = window_pane_choose_best(list, size);
1374 free(list);
1375 return (best);
1376 }
1377
1378 /* Find the pane directly to the left of another. */
1379 struct window_pane *
1380 window_pane_find_left(struct window_pane *wp)
1381 {
1382 struct window *w;
1383 struct window_pane *next, *best, **list;
1384 u_int edge, top, bottom, end, size;
1385 int found;
1386
1387 if (wp == NULL)
1388 return (NULL);
1389 w = wp->window;
1390
1391 list = NULL;
1392 size = 0;
1393
1394 edge = wp->xoff;
1395 if (edge == 0)
1396 edge = w->sx + 1;
1397
1398 top = wp->yoff;
1399 bottom = wp->yoff + wp->sy;
1400
1401 TAILQ_FOREACH(next, &w->panes, entry) {
1402 if (next == wp)
1403 continue;
1404 if (next->xoff + next->sx + 1 != edge)
1405 continue;
1406 end = next->yoff + next->sy - 1;
1407
1408 found = 0;
1409 if (next->yoff < top && end > bottom)
1410 found = 1;
1411 else if (next->yoff >= top && next->yoff <= bottom)
1412 found = 1;
1413 else if (end >= top && end <= bottom)
1414 found = 1;
1415 if (!found)
1416 continue;
1417 list = xreallocarray(list, size + 1, sizeof *list);
1418 list[size++] = next;
1419 }
1420
1421 best = window_pane_choose_best(list, size);
1422 free(list);
1423 return (best);
1424 }
1425
1426 /* Find the pane directly to the right of another. */
1427 struct window_pane *
1428 window_pane_find_right(struct window_pane *wp)
1429 {
1430 struct window *w;
1431 struct window_pane *next, *best, **list;
1432 u_int edge, top, bottom, end, size;
1433 int found;
1434
1435 if (wp == NULL)
1436 return (NULL);
1437 w = wp->window;
1438
1439 list = NULL;
1440 size = 0;
1441
1442 edge = wp->xoff + wp->sx + 1;
1443 if (edge >= w->sx)
1444 edge = 0;
1445
1446 top = wp->yoff;
1447 bottom = wp->yoff + wp->sy;
1448
1449 TAILQ_FOREACH(next, &w->panes, entry) {
1450 if (next == wp)
1451 continue;
1452 if (next->xoff != edge)
1453 continue;
1454 end = next->yoff + next->sy - 1;
1455
1456 found = 0;
1457 if (next->yoff < top && end > bottom)
1458 found = 1;
1459 else if (next->yoff >= top && next->yoff <= bottom)
1460 found = 1;
1461 else if (end >= top && end <= bottom)
1462 found = 1;
1463 if (!found)
1464 continue;
1465 list = xreallocarray(list, size + 1, sizeof *list);
1466 list[size++] = next;
1467 }
1468
1469 best = window_pane_choose_best(list, size);
1470 free(list);
1471 return (best);
1472 }
1473
1474 /* Clear alert flags for a winlink */
1475 void
1476 winlink_clear_flags(struct winlink *wl)
1477 {
1478 struct winlink *loop;
1479
1480 wl->window->flags &= ~WINDOW_ALERTFLAGS;
1481 TAILQ_FOREACH(loop, &wl->window->winlinks, wentry) {
1482 if ((loop->flags & WINLINK_ALERTFLAGS) != 0) {
1483 loop->flags &= ~WINLINK_ALERTFLAGS;
1484 server_status_session(loop->session);
1485 }
1486 }
1487 }
1488
1489 /* Shuffle window indexes up. */
1490 int
1491 winlink_shuffle_up(struct session *s, struct winlink *wl, int before)
1492 {
1493 int idx, last;
1494
1495 if (wl == NULL)
1496 return (-1);
1497 if (before)
1498 idx = wl->idx;
1499 else
1500 idx = wl->idx + 1;
1501
1502 /* Find the next free index. */
1503 for (last = idx; last < INT_MAX; last++) {
1504 if (winlink_find_by_index(&s->windows, last) == NULL)
1505 break;
1506 }
1507 if (last == INT_MAX)
1508 return (-1);
1509
1510 /* Move everything from last - 1 to idx up a bit. */
1511 for (; last > idx; last--) {
1512 wl = winlink_find_by_index(&s->windows, last - 1);
1513 RB_REMOVE(winlinks, &s->windows, wl);
1514 wl->idx++;
1515 RB_INSERT(winlinks, &s->windows, wl);
1516 }
1517
1518 return (idx);
1519 }
1520
1521 static void
1522 window_pane_input_callback(struct client *c, __unused const char *path,
1523 int error, int closed, struct evbuffer *buffer, void *data)
1524 {
1525 struct window_pane_input_data *cdata = data;
1526 struct window_pane *wp;
1527 u_char *buf = EVBUFFER_DATA(buffer);
1528 size_t len = EVBUFFER_LENGTH(buffer);
1529
1530 wp = window_pane_find_by_id(cdata->wp);
1531 if (wp == NULL || closed || error != 0 || (c->flags & CLIENT_DEAD)) {
1532 if (wp == NULL)
1533 c->flags |= CLIENT_EXIT;
1534
1535 evbuffer_drain(buffer, len);
1536 cmdq_continue(cdata->item);
1537
1538 server_client_unref(c);
1539 free(cdata);
1540 return;
1541 }
1542 input_parse_buffer(wp, buf, len);
1543 evbuffer_drain(buffer, len);
1544 }
1545
1546 int
1547 window_pane_start_input(struct window_pane *wp, struct cmdq_item *item,
1548 char **cause)
1549 {
1550 struct client *c = cmdq_get_client(item);
1551 struct window_pane_input_data *cdata;
1552
1553 if (~wp->flags & PANE_EMPTY) {
1554 *cause = xstrdup("pane is not empty");
1555 return (-1);
1556 }
1557 if (c->flags & (CLIENT_DEAD|CLIENT_EXITED))
1558 return (1);
1559 if (c->session != NULL)
1560 return (1);
1561
1562 cdata = xmalloc(sizeof *cdata);
1563 cdata->item = item;
1564 cdata->wp = wp->id;
1565
1566 c->references++;
1567 file_read(c, "-", window_pane_input_callback, cdata);
1568
1569 return (0);
1570 }
1571
1572 void *
1573 window_pane_get_new_data(struct window_pane *wp,
1574 struct window_pane_offset *wpo, size_t *size)
1575 {
1576 size_t used = wpo->used - wp->base_offset;
1577
1578 *size = EVBUFFER_LENGTH(wp->event->input) - used;
1579 return (EVBUFFER_DATA(wp->event->input) + used);
1580 }
1581
1582 void
1583 window_pane_update_used_data(struct window_pane *wp,
1584 struct window_pane_offset *wpo, size_t size)
1585 {
1586 size_t used = wpo->used - wp->base_offset;
1587
1588 if (size > EVBUFFER_LENGTH(wp->event->input) - used)
1589 size = EVBUFFER_LENGTH(wp->event->input) - used;
1590 wpo->used += size;
1591 }