4 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 #include <sys/types.h>
20 #include <sys/ioctl.h>
39 * Each window is attached to a number of panes, each of which is a pty. This
40 * file contains code to handle them.
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.
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.
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
57 /* Global window list. */
58 struct windows windows
;
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
;
66 struct window_pane_input_data
{
67 struct cmdq_item
*item
;
71 static struct window_pane
*window_pane_create(struct window
*, u_int
, u_int
,
73 static void window_pane_destroy(struct window_pane
*);
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
);
80 window_cmp(struct window
*w1
, struct window
*w2
)
82 return (w1
->id
- w2
->id
);
86 winlink_cmp(struct winlink
*wl1
, struct winlink
*wl2
)
88 return (wl1
->idx
- wl2
->idx
);
92 window_pane_cmp(struct window_pane
*wp1
, struct window_pane
*wp2
)
94 return (wp1
->id
- wp2
->id
);
98 winlink_find_by_window(struct winlinks
*wwl
, struct window
*w
)
102 RB_FOREACH(wl
, winlinks
, wwl
) {
111 winlink_find_by_index(struct winlinks
*wwl
, int idx
)
119 return (RB_FIND(winlinks
, wwl
, &wl
));
123 winlink_find_by_window_id(struct winlinks
*wwl
, u_int id
)
127 RB_FOREACH(wl
, winlinks
, wwl
) {
128 if (wl
->window
->id
== id
)
135 winlink_next_index(struct winlinks
*wwl
, int idx
)
141 if (winlink_find_by_index(wwl
, i
) == NULL
)
152 winlink_count(struct winlinks
*wwl
)
158 RB_FOREACH(wl
, winlinks
, wwl
)
165 winlink_add(struct winlinks
*wwl
, int idx
)
170 if ((idx
= winlink_next_index(wwl
, -idx
- 1)) == -1)
172 } else if (winlink_find_by_index(wwl
, idx
) != NULL
)
175 wl
= xcalloc(1, sizeof *wl
);
177 RB_INSERT(winlinks
, wwl
, wl
);
183 winlink_set_window(struct winlink
*wl
, struct window
*w
)
185 if (wl
->window
!= NULL
) {
186 TAILQ_REMOVE(&wl
->window
->winlinks
, wl
, wentry
);
187 window_remove_ref(wl
->window
, __func__
);
189 TAILQ_INSERT_TAIL(&w
->winlinks
, wl
, wentry
);
191 window_add_ref(w
, __func__
);
195 winlink_remove(struct winlinks
*wwl
, struct winlink
*wl
)
197 struct window
*w
= wl
->window
;
200 TAILQ_REMOVE(&w
->winlinks
, wl
, wentry
);
201 window_remove_ref(w
, __func__
);
204 RB_REMOVE(winlinks
, wwl
, wl
);
209 winlink_next(struct winlink
*wl
)
211 return (RB_NEXT(winlinks
, wwl
, wl
));
215 winlink_previous(struct winlink
*wl
)
217 return (RB_PREV(winlinks
, wwl
, wl
));
221 winlink_next_by_number(struct winlink
*wl
, struct session
*s
, int n
)
224 if ((wl
= RB_NEXT(winlinks
, wwl
, wl
)) == NULL
)
225 wl
= RB_MIN(winlinks
, &s
->windows
);
232 winlink_previous_by_number(struct winlink
*wl
, struct session
*s
, int n
)
235 if ((wl
= RB_PREV(winlinks
, wwl
, wl
)) == NULL
)
236 wl
= RB_MAX(winlinks
, &s
->windows
);
243 winlink_stack_push(struct winlink_stack
*stack
, struct winlink
*wl
)
248 winlink_stack_remove(stack
, wl
);
249 TAILQ_INSERT_HEAD(stack
, wl
, sentry
);
253 winlink_stack_remove(struct winlink_stack
*stack
, struct winlink
*wl
)
260 TAILQ_FOREACH(wl2
, stack
, sentry
) {
262 TAILQ_REMOVE(stack
, wl
, sentry
);
269 window_find_by_id_str(const char *s
)
277 id
= strtonum(s
+ 1, 0, UINT_MAX
, &errstr
);
280 return (window_find_by_id(id
));
284 window_find_by_id(u_int id
)
289 return (RB_FIND(windows
, &windows
, &w
));
293 window_update_activity(struct window
*w
)
295 gettimeofday(&w
->activity_time
, NULL
);
296 alerts_queue(w
, WINDOW_ACTIVITY
);
300 window_create(u_int sx
, u_int sy
, u_int xpixel
, u_int ypixel
)
305 xpixel
= DEFAULT_XPIXEL
;
307 ypixel
= DEFAULT_YPIXEL
;
309 w
= xcalloc(1, sizeof *w
);
310 w
->name
= xstrdup("");
313 TAILQ_INIT(&w
->panes
);
317 w
->layout_root
= NULL
;
326 w
->options
= options_create(global_w_options
);
329 TAILQ_INIT(&w
->winlinks
);
331 w
->id
= next_window_id
++;
332 RB_INSERT(windows
, &windows
, w
);
334 window_update_activity(w
);
336 log_debug("%s: @%u create %ux%u (%ux%u)", __func__
, w
->id
, sx
, sy
,
337 w
->xpixel
, w
->ypixel
);
342 window_destroy(struct window
*w
)
344 log_debug("window @%u destroyed (%d references)", w
->id
, w
->references
);
346 RB_REMOVE(windows
, &windows
, w
);
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
);
354 window_destroy_panes(w
);
356 if (event_initialized(&w
->name_event
))
357 evtimer_del(&w
->name_event
);
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
);
364 options_free(w
->options
);
371 window_pane_destroy_ready(struct window_pane
*wp
)
375 if (wp
->pipe_fd
!= -1) {
376 if (EVBUFFER_LENGTH(wp
->pipe_event
->output
) != 0)
378 if (ioctl(wp
->fd
, FIONREAD
, &n
) != -1 && n
> 0)
382 if (~wp
->flags
& PANE_EXITED
)
388 window_add_ref(struct window
*w
, const char *from
)
391 log_debug("%s: @%u %s, now %d", __func__
, w
->id
, from
, w
->references
);
395 window_remove_ref(struct window
*w
, const char *from
)
398 log_debug("%s: @%u %s, now %d", __func__
, w
->id
, from
, w
->references
);
400 if (w
->references
== 0)
405 window_set_name(struct window
*w
, const char *new_name
)
408 utf8_stravis(&w
->name
, new_name
, VIS_OCTAL
|VIS_CSTYLE
|VIS_TAB
|VIS_NL
);
409 notify_window("window-renamed", w
);
413 window_resize(struct window
*w
, u_int sx
, u_int sy
, int xpixel
, int ypixel
)
416 xpixel
= DEFAULT_XPIXEL
;
418 ypixel
= DEFAULT_YPIXEL
;
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
);
432 window_pane_send_resize(struct window_pane
*wp
, u_int sx
, u_int sy
)
434 struct window
*w
= wp
->window
;
440 log_debug("%s: %%%u resize to %u,%u", __func__
, wp
->id
, sx
, sy
);
442 memset(&ws
, 0, sizeof ws
);
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");
452 window_has_pane(struct window
*w
, struct window_pane
*wp
)
454 struct window_pane
*wp1
;
456 TAILQ_FOREACH(wp1
, &w
->panes
, entry
) {
464 window_update_focus(struct window
*w
)
467 log_debug("%s: @%u", __func__
, w
->id
);
468 window_pane_update_focus(w
->active
);
473 window_pane_update_focus(struct window_pane
*wp
)
479 if (wp
!= wp
->window
->active
)
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
) {
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
;
505 log_debug("%s: %%%u focus unchanged", __func__
, wp
->id
);
510 window_set_active_pane(struct window
*w
, struct window_pane
*wp
, int notify
)
512 log_debug("%s: pane %%%u", __func__
, wp
->id
);
519 w
->active
->active_point
= next_active_point
++;
520 w
->active
->flags
|= PANE_CHANGED
;
522 if (options_get_number(global_options
, "focus-events")) {
523 window_pane_update_focus(w
->last
);
524 window_pane_update_focus(w
->active
);
527 tty_update_window_offset(w
);
530 notify_window("window-pane-changed", w
);
535 window_pane_get_palette(struct window_pane
*wp
, int c
)
539 return (colour_palette_get(&wp
->palette
, c
));
543 window_redraw_active_switch(struct window
*w
, struct window_pane
*wp
)
545 struct grid_cell
*gc1
, *gc2
;
553 * If the active and inactive styles or palettes are different,
554 * need to redraw the panes.
556 gc1
= &wp
->cached_gc
;
557 gc2
= &wp
->cached_active_gc
;
558 if (!grid_cells_look_equal(gc1
, gc2
))
559 wp
->flags
|= PANE_REDRAW
;
561 c1
= window_pane_get_palette(wp
, gc1
->fg
);
562 c2
= window_pane_get_palette(wp
, gc2
->fg
);
564 wp
->flags
|= PANE_REDRAW
;
566 c1
= window_pane_get_palette(wp
, gc1
->bg
);
567 c2
= window_pane_get_palette(wp
, gc2
->bg
);
569 wp
->flags
|= PANE_REDRAW
;
579 window_get_active_at(struct window
*w
, u_int x
, u_int y
)
581 struct window_pane
*wp
;
583 TAILQ_FOREACH(wp
, &w
->panes
, entry
) {
584 if (!window_pane_visible(wp
))
586 if (x
< wp
->xoff
|| x
> wp
->xoff
+ wp
->sx
)
588 if (y
< wp
->yoff
|| y
> wp
->yoff
+ wp
->sy
)
596 window_find_string(struct window
*w
, const char *s
)
598 u_int x
, y
, top
= 0, bottom
= w
->sy
- 1;
604 status
= options_get_number(w
->options
, "pane-border-status");
605 if (status
== PANE_STATUS_TOP
)
607 else if (status
== PANE_STATUS_BOTTOM
)
610 if (strcasecmp(s
, "top") == 0)
612 else if (strcasecmp(s
, "bottom") == 0)
614 else if (strcasecmp(s
, "left") == 0)
616 else if (strcasecmp(s
, "right") == 0)
618 else if (strcasecmp(s
, "top-left") == 0) {
621 } else if (strcasecmp(s
, "top-right") == 0) {
624 } else if (strcasecmp(s
, "bottom-left") == 0) {
627 } else if (strcasecmp(s
, "bottom-right") == 0) {
633 return (window_get_active_at(w
, x
, y
));
637 window_zoom(struct window_pane
*wp
)
639 struct window
*w
= wp
->window
;
640 struct window_pane
*wp1
;
642 if (w
->flags
& WINDOW_ZOOMED
)
645 if (window_count_panes(w
) == 1)
649 window_set_active_pane(w
, wp
, 1);
651 TAILQ_FOREACH(wp1
, &w
->panes
, entry
) {
652 wp1
->saved_layout_cell
= wp1
->layout_cell
;
653 wp1
->layout_cell
= NULL
;
656 w
->saved_layout_root
= w
->layout_root
;
658 w
->flags
|= WINDOW_ZOOMED
;
659 notify_window("window-layout-changed", w
);
665 window_unzoom(struct window
*w
)
667 struct window_pane
*wp
;
669 if (!(w
->flags
& WINDOW_ZOOMED
))
672 w
->flags
&= ~WINDOW_ZOOMED
;
674 w
->layout_root
= w
->saved_layout_root
;
675 w
->saved_layout_root
= NULL
;
677 TAILQ_FOREACH(wp
, &w
->panes
, entry
) {
678 wp
->layout_cell
= wp
->saved_layout_cell
;
679 wp
->saved_layout_cell
= NULL
;
681 layout_fix_panes(w
, NULL
);
682 notify_window("window-layout-changed", w
);
688 window_push_zoom(struct window
*w
, int always
, int flag
)
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
;
695 w
->flags
&= ~WINDOW_WASZOOMED
;
696 return (window_unzoom(w
) == 0);
700 window_pop_zoom(struct window
*w
)
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);
710 window_add_pane(struct window
*w
, struct window_pane
*other
, u_int hlimit
,
713 struct window_pane
*wp
;
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
);
727 TAILQ_INSERT_BEFORE(other
, wp
, entry
);
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
);
733 TAILQ_INSERT_AFTER(&w
->panes
, other
, wp
, entry
);
739 window_lost_pane(struct window
*w
, struct window_pane
*wp
)
741 log_debug("%s: @%u pane %%%u", __func__
, w
->id
, wp
->id
);
743 if (wp
== marked_pane
.wp
)
744 server_clear_marked();
746 if (wp
== w
->active
) {
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
);
754 if (w
->active
!= NULL
) {
755 w
->active
->flags
|= PANE_CHANGED
;
756 notify_window("window-pane-changed", w
);
758 } else if (wp
== w
->last
)
763 window_remove_pane(struct window
*w
, struct window_pane
*wp
)
765 window_lost_pane(w
, wp
);
767 TAILQ_REMOVE(&w
->panes
, wp
, entry
);
768 window_pane_destroy(wp
);
772 window_pane_at_index(struct window
*w
, u_int idx
)
774 struct window_pane
*wp
;
777 n
= options_get_number(w
->options
, "pane-base-index");
778 TAILQ_FOREACH(wp
, &w
->panes
, entry
) {
787 window_pane_next_by_number(struct window
*w
, struct window_pane
*wp
, u_int n
)
790 if ((wp
= TAILQ_NEXT(wp
, entry
)) == NULL
)
791 wp
= TAILQ_FIRST(&w
->panes
);
798 window_pane_previous_by_number(struct window
*w
, struct window_pane
*wp
,
802 if ((wp
= TAILQ_PREV(wp
, window_panes
, entry
)) == NULL
)
803 wp
= TAILQ_LAST(&w
->panes
, window_panes
);
810 window_pane_index(struct window_pane
*wp
, u_int
*i
)
812 struct window_pane
*wq
;
813 struct window
*w
= wp
->window
;
815 *i
= options_get_number(w
->options
, "pane-base-index");
816 TAILQ_FOREACH(wq
, &w
->panes
, entry
) {
827 window_count_panes(struct window
*w
)
829 struct window_pane
*wp
;
833 TAILQ_FOREACH(wp
, &w
->panes
, entry
)
839 window_destroy_panes(struct window
*w
)
841 struct window_pane
*wp
;
843 while (!TAILQ_EMPTY(&w
->panes
)) {
844 wp
= TAILQ_FIRST(&w
->panes
);
845 TAILQ_REMOVE(&w
->panes
, wp
, entry
);
846 window_pane_destroy(wp
);
851 window_printable_flags(struct winlink
*wl
, int escape
)
853 struct session
*s
= wl
->session
;
854 static char flags
[32];
858 if (wl
->flags
& WINLINK_ACTIVITY
) {
863 if (wl
->flags
& WINLINK_BELL
)
865 if (wl
->flags
& WINLINK_SILENCE
)
869 if (wl
== TAILQ_FIRST(&s
->lastw
))
871 if (server_check_marked() && wl
== marked_pane
.wl
)
873 if (wl
->window
->flags
& WINDOW_ZOOMED
)
880 window_pane_find_by_id_str(const char *s
)
888 id
= strtonum(s
+ 1, 0, UINT_MAX
, &errstr
);
891 return (window_pane_find_by_id(id
));
895 window_pane_find_by_id(u_int id
)
897 struct window_pane wp
;
900 return (RB_FIND(window_pane_tree
, &all_window_panes
, &wp
));
903 static struct window_pane
*
904 window_pane_create(struct window
*w
, u_int sx
, u_int sy
, u_int hlimit
)
906 struct window_pane
*wp
;
907 char host
[HOST_NAME_MAX
+ 1];
909 wp
= xcalloc(1, sizeof *wp
);
911 wp
->options
= options_create(w
->options
);
912 wp
->flags
= PANE_STYLECHANGED
;
914 wp
->id
= next_window_pane_id
++;
915 RB_INSERT(window_pane_tree
, &all_window_panes
, wp
);
919 TAILQ_INIT(&wp
->modes
);
921 TAILQ_INIT (&wp
->resize_queue
);
928 colour_palette_init(&wp
->palette
);
929 colour_palette_from_option(&wp
->palette
, wp
->options
);
931 screen_init(&wp
->base
, sx
, sy
, hlimit
);
932 wp
->screen
= &wp
->base
;
934 screen_init(&wp
->status_screen
, 1, 1, 0);
936 if (gethostname(host
, sizeof host
) == 0)
937 screen_set_title(&wp
->base
, host
);
943 window_pane_destroy(struct window_pane
*wp
)
945 struct window_pane_resize
*r
;
946 struct window_pane_resize
*r1
;
948 window_pane_reset_mode_all(wp
);
952 bufferevent_free(wp
->event
);
955 if (wp
->ictx
!= NULL
)
956 input_free(wp
->ictx
);
958 screen_free(&wp
->status_screen
);
960 screen_free(&wp
->base
);
962 if (wp
->pipe_fd
!= -1) {
963 bufferevent_free(wp
->pipe_event
);
967 if (event_initialized(&wp
->resize_timer
))
968 event_del(&wp
->resize_timer
);
969 TAILQ_FOREACH_SAFE(r
, &wp
->resize_queue
, entry
, r1
) {
970 TAILQ_REMOVE(&wp
->resize_queue
, r
, entry
);
974 RB_REMOVE(window_pane_tree
, &all_window_panes
, wp
);
976 options_free(wp
->options
);
977 free((void *)wp
->cwd
);
979 cmd_free_argv(wp
->argc
, wp
->argv
);
980 colour_palette_free(&wp
->palette
);
985 window_pane_read_callback(__unused
struct bufferevent
*bufev
, void *data
)
987 struct window_pane
*wp
= data
;
988 struct evbuffer
*evb
= wp
->event
->input
;
989 struct window_pane_offset
*wpo
= &wp
->pipe_offset
;
990 size_t size
= EVBUFFER_LENGTH(evb
);
995 if (wp
->pipe_fd
!= -1) {
996 new_data
= window_pane_get_new_data(wp
, wpo
, &new_size
);
998 bufferevent_write(wp
->pipe_event
, new_data
, new_size
);
999 window_pane_update_used_data(wp
, wpo
, new_size
);
1003 log_debug("%%%u has %zu bytes", wp
->id
, size
);
1004 TAILQ_FOREACH(c
, &clients
, entry
) {
1005 if (c
->session
!= NULL
&& (c
->flags
& CLIENT_CONTROL
))
1006 control_write_output(c
, wp
);
1008 input_parse_pane(wp
);
1009 bufferevent_disable(wp
->event
, EV_READ
);
1013 window_pane_error_callback(__unused
struct bufferevent
*bufev
,
1014 __unused
short what
, void *data
)
1016 struct window_pane
*wp
= data
;
1018 log_debug("%%%u error", wp
->id
);
1019 wp
->flags
|= PANE_EXITED
;
1021 if (window_pane_destroy_ready(wp
))
1022 server_destroy_pane(wp
, 1);
1026 window_pane_set_event(struct window_pane
*wp
)
1028 setblocking(wp
->fd
, 0);
1030 wp
->event
= bufferevent_new(wp
->fd
, window_pane_read_callback
,
1031 NULL
, window_pane_error_callback
, wp
);
1032 wp
->ictx
= input_init(wp
, wp
->event
, &wp
->palette
);
1034 bufferevent_enable(wp
->event
, EV_READ
|EV_WRITE
);
1038 window_pane_resize(struct window_pane
*wp
, u_int sx
, u_int sy
)
1040 struct window_mode_entry
*wme
;
1041 struct window_pane_resize
*r
;
1043 if (sx
== wp
->sx
&& sy
== wp
->sy
)
1046 r
= xmalloc (sizeof *r
);
1051 TAILQ_INSERT_TAIL (&wp
->resize_queue
, r
, entry
);
1056 log_debug("%s: %%%u resize %ux%u", __func__
, wp
->id
, sx
, sy
);
1057 screen_resize(&wp
->base
, sx
, sy
, wp
->base
.saved_grid
== NULL
);
1059 wme
= TAILQ_FIRST(&wp
->modes
);
1060 if (wme
!= NULL
&& wme
->mode
->resize
!= NULL
)
1061 wme
->mode
->resize(wme
, sx
, sy
);
1065 window_pane_set_mode(struct window_pane
*wp
, struct window_pane
*swp
,
1066 const struct window_mode
*mode
, struct cmd_find_state
*fs
,
1069 struct window_mode_entry
*wme
;
1071 if (!TAILQ_EMPTY(&wp
->modes
) && TAILQ_FIRST(&wp
->modes
)->mode
== mode
)
1074 TAILQ_FOREACH(wme
, &wp
->modes
, entry
) {
1075 if (wme
->mode
== mode
)
1079 TAILQ_REMOVE(&wp
->modes
, wme
, entry
);
1080 TAILQ_INSERT_HEAD(&wp
->modes
, wme
, entry
);
1082 wme
= xcalloc(1, sizeof *wme
);
1087 TAILQ_INSERT_HEAD(&wp
->modes
, wme
, entry
);
1088 wme
->screen
= wme
->mode
->init(wme
, fs
, args
);
1091 wp
->screen
= wme
->screen
;
1092 wp
->flags
|= (PANE_REDRAW
|PANE_CHANGED
);
1094 server_redraw_window_borders(wp
->window
);
1095 server_status_window(wp
->window
);
1096 notify_pane("pane-mode-changed", wp
);
1102 window_pane_reset_mode(struct window_pane
*wp
)
1104 struct window_mode_entry
*wme
, *next
;
1106 if (TAILQ_EMPTY(&wp
->modes
))
1109 wme
= TAILQ_FIRST(&wp
->modes
);
1110 TAILQ_REMOVE(&wp
->modes
, wme
, entry
);
1111 wme
->mode
->free(wme
);
1114 next
= TAILQ_FIRST(&wp
->modes
);
1116 log_debug("%s: no next mode", __func__
);
1117 wp
->screen
= &wp
->base
;
1119 log_debug("%s: next mode is %s", __func__
, next
->mode
->name
);
1120 wp
->screen
= next
->screen
;
1121 if (next
->mode
->resize
!= NULL
)
1122 next
->mode
->resize(next
, wp
->sx
, wp
->sy
);
1124 wp
->flags
|= (PANE_REDRAW
|PANE_CHANGED
);
1126 server_redraw_window_borders(wp
->window
);
1127 server_status_window(wp
->window
);
1128 notify_pane("pane-mode-changed", wp
);
1132 window_pane_reset_mode_all(struct window_pane
*wp
)
1134 while (!TAILQ_EMPTY(&wp
->modes
))
1135 window_pane_reset_mode(wp
);
1139 window_pane_copy_key(struct window_pane
*wp
, key_code key
)
1141 struct window_pane
*loop
;
1143 TAILQ_FOREACH(loop
, &wp
->window
->panes
, entry
) {
1145 TAILQ_EMPTY(&loop
->modes
) &&
1147 (~loop
->flags
& PANE_INPUTOFF
) &&
1148 window_pane_visible(loop
) &&
1149 options_get_number(loop
->options
, "synchronize-panes"))
1150 input_key_pane(loop
, key
, NULL
);
1155 window_pane_key(struct window_pane
*wp
, struct client
*c
, struct session
*s
,
1156 struct winlink
*wl
, key_code key
, struct mouse_event
*m
)
1158 struct window_mode_entry
*wme
;
1160 if (KEYC_IS_MOUSE(key
) && m
== NULL
)
1163 wme
= TAILQ_FIRST(&wp
->modes
);
1165 if (wme
->mode
->key
!= NULL
&& c
!= NULL
) {
1166 key
&= ~KEYC_MASK_FLAGS
;
1167 wme
->mode
->key(wme
, c
, s
, wl
, key
, m
);
1172 if (wp
->fd
== -1 || wp
->flags
& PANE_INPUTOFF
)
1175 if (input_key_pane(wp
, key
, m
) != 0)
1178 if (KEYC_IS_MOUSE(key
))
1180 if (options_get_number(wp
->options
, "synchronize-panes"))
1181 window_pane_copy_key(wp
, key
);
1186 window_pane_visible(struct window_pane
*wp
)
1188 if (~wp
->window
->flags
& WINDOW_ZOOMED
)
1190 return (wp
== wp
->window
->active
);
1194 window_pane_search(struct window_pane
*wp
, const char *term
, int regex
,
1197 struct screen
*s
= &wp
->base
;
1199 char *new = NULL
, *line
;
1201 int flags
= 0, found
;
1206 flags
|= FNM_CASEFOLD
;
1207 xasprintf(&new, "*%s*", term
);
1211 if (regcomp(&r
, term
, flags
|REG_EXTENDED
) != 0)
1215 for (i
= 0; i
< screen_size_y(s
); i
++) {
1216 line
= grid_view_string_cells(s
->grid
, 0, i
, screen_size_x(s
));
1217 for (n
= strlen(line
); n
> 0; n
--) {
1218 if (!isspace((u_char
)line
[n
- 1]))
1222 log_debug("%s: %s", __func__
, line
);
1224 found
= (fnmatch(new, line
, flags
) == 0);
1226 found
= (regexec(&r
, line
, 0, NULL
, 0) == 0);
1236 if (i
== screen_size_y(s
))
1241 /* Get MRU pane from a list. */
1242 static struct window_pane
*
1243 window_pane_choose_best(struct window_pane
**list
, u_int size
)
1245 struct window_pane
*next
, *best
;
1252 for (i
= 1; i
< size
; i
++) {
1254 if (next
->active_point
> best
->active_point
)
1261 * Find the pane directly above another. We build a list of those adjacent to
1262 * top edge and then choose the best.
1264 struct window_pane
*
1265 window_pane_find_up(struct window_pane
*wp
)
1268 struct window_pane
*next
, *best
, **list
;
1269 u_int edge
, left
, right
, end
, size
;
1275 status
= options_get_number(w
->options
, "pane-border-status");
1281 if (status
== PANE_STATUS_TOP
) {
1284 } else if (status
== PANE_STATUS_BOTTOM
) {
1293 right
= wp
->xoff
+ wp
->sx
;
1295 TAILQ_FOREACH(next
, &w
->panes
, entry
) {
1298 if (next
->yoff
+ next
->sy
+ 1 != edge
)
1300 end
= next
->xoff
+ next
->sx
- 1;
1303 if (next
->xoff
< left
&& end
> right
)
1305 else if (next
->xoff
>= left
&& next
->xoff
<= right
)
1307 else if (end
>= left
&& end
<= right
)
1311 list
= xreallocarray(list
, size
+ 1, sizeof *list
);
1312 list
[size
++] = next
;
1315 best
= window_pane_choose_best(list
, size
);
1320 /* Find the pane directly below another. */
1321 struct window_pane
*
1322 window_pane_find_down(struct window_pane
*wp
)
1325 struct window_pane
*next
, *best
, **list
;
1326 u_int edge
, left
, right
, end
, size
;
1332 status
= options_get_number(w
->options
, "pane-border-status");
1337 edge
= wp
->yoff
+ wp
->sy
+ 1;
1338 if (status
== PANE_STATUS_TOP
) {
1341 } else if (status
== PANE_STATUS_BOTTOM
) {
1342 if (edge
>= w
->sy
- 1)
1350 right
= wp
->xoff
+ wp
->sx
;
1352 TAILQ_FOREACH(next
, &w
->panes
, entry
) {
1355 if (next
->yoff
!= edge
)
1357 end
= next
->xoff
+ next
->sx
- 1;
1360 if (next
->xoff
< left
&& end
> right
)
1362 else if (next
->xoff
>= left
&& next
->xoff
<= right
)
1364 else if (end
>= left
&& end
<= right
)
1368 list
= xreallocarray(list
, size
+ 1, sizeof *list
);
1369 list
[size
++] = next
;
1372 best
= window_pane_choose_best(list
, size
);
1377 /* Find the pane directly to the left of another. */
1378 struct window_pane
*
1379 window_pane_find_left(struct window_pane
*wp
)
1382 struct window_pane
*next
, *best
, **list
;
1383 u_int edge
, top
, bottom
, end
, size
;
1398 bottom
= wp
->yoff
+ wp
->sy
;
1400 TAILQ_FOREACH(next
, &w
->panes
, entry
) {
1403 if (next
->xoff
+ next
->sx
+ 1 != edge
)
1405 end
= next
->yoff
+ next
->sy
- 1;
1408 if (next
->yoff
< top
&& end
> bottom
)
1410 else if (next
->yoff
>= top
&& next
->yoff
<= bottom
)
1412 else if (end
>= top
&& end
<= bottom
)
1416 list
= xreallocarray(list
, size
+ 1, sizeof *list
);
1417 list
[size
++] = next
;
1420 best
= window_pane_choose_best(list
, size
);
1425 /* Find the pane directly to the right of another. */
1426 struct window_pane
*
1427 window_pane_find_right(struct window_pane
*wp
)
1430 struct window_pane
*next
, *best
, **list
;
1431 u_int edge
, top
, bottom
, end
, size
;
1441 edge
= wp
->xoff
+ wp
->sx
+ 1;
1446 bottom
= wp
->yoff
+ wp
->sy
;
1448 TAILQ_FOREACH(next
, &w
->panes
, entry
) {
1451 if (next
->xoff
!= edge
)
1453 end
= next
->yoff
+ next
->sy
- 1;
1456 if (next
->yoff
< top
&& end
> bottom
)
1458 else if (next
->yoff
>= top
&& next
->yoff
<= bottom
)
1460 else if (end
>= top
&& end
<= bottom
)
1464 list
= xreallocarray(list
, size
+ 1, sizeof *list
);
1465 list
[size
++] = next
;
1468 best
= window_pane_choose_best(list
, size
);
1473 /* Clear alert flags for a winlink */
1475 winlink_clear_flags(struct winlink
*wl
)
1477 struct winlink
*loop
;
1479 wl
->window
->flags
&= ~WINDOW_ALERTFLAGS
;
1480 TAILQ_FOREACH(loop
, &wl
->window
->winlinks
, wentry
) {
1481 if ((loop
->flags
& WINLINK_ALERTFLAGS
) != 0) {
1482 loop
->flags
&= ~WINLINK_ALERTFLAGS
;
1483 server_status_session(loop
->session
);
1488 /* Shuffle window indexes up. */
1490 winlink_shuffle_up(struct session
*s
, struct winlink
*wl
, int before
)
1501 /* Find the next free index. */
1502 for (last
= idx
; last
< INT_MAX
; last
++) {
1503 if (winlink_find_by_index(&s
->windows
, last
) == NULL
)
1506 if (last
== INT_MAX
)
1509 /* Move everything from last - 1 to idx up a bit. */
1510 for (; last
> idx
; last
--) {
1511 wl
= winlink_find_by_index(&s
->windows
, last
- 1);
1512 RB_REMOVE(winlinks
, &s
->windows
, wl
);
1514 RB_INSERT(winlinks
, &s
->windows
, wl
);
1521 window_pane_input_callback(struct client
*c
, __unused
const char *path
,
1522 int error
, int closed
, struct evbuffer
*buffer
, void *data
)
1524 struct window_pane_input_data
*cdata
= data
;
1525 struct window_pane
*wp
;
1526 u_char
*buf
= EVBUFFER_DATA(buffer
);
1527 size_t len
= EVBUFFER_LENGTH(buffer
);
1529 wp
= window_pane_find_by_id(cdata
->wp
);
1530 if (wp
== NULL
|| closed
|| error
!= 0 || (c
->flags
& CLIENT_DEAD
)) {
1532 c
->flags
|= CLIENT_EXIT
;
1534 evbuffer_drain(buffer
, len
);
1535 cmdq_continue(cdata
->item
);
1537 server_client_unref(c
);
1541 input_parse_buffer(wp
, buf
, len
);
1542 evbuffer_drain(buffer
, len
);
1546 window_pane_start_input(struct window_pane
*wp
, struct cmdq_item
*item
,
1549 struct client
*c
= cmdq_get_client(item
);
1550 struct window_pane_input_data
*cdata
;
1552 if (~wp
->flags
& PANE_EMPTY
) {
1553 *cause
= xstrdup("pane is not empty");
1556 if (c
->flags
& (CLIENT_DEAD
|CLIENT_EXITED
))
1558 if (c
->session
!= NULL
)
1561 cdata
= xmalloc(sizeof *cdata
);
1566 file_read(c
, "-", window_pane_input_callback
, cdata
);
1572 window_pane_get_new_data(struct window_pane
*wp
,
1573 struct window_pane_offset
*wpo
, size_t *size
)
1575 size_t used
= wpo
->used
- wp
->base_offset
;
1577 *size
= EVBUFFER_LENGTH(wp
->event
->input
) - used
;
1578 return (EVBUFFER_DATA(wp
->event
->input
) + used
);
1582 window_pane_update_used_data(struct window_pane
*wp
,
1583 struct window_pane_offset
*wpo
, size_t size
)
1585 size_t used
= wpo
->used
- wp
->base_offset
;
1587 if (size
> EVBUFFER_LENGTH(wp
->event
->input
) - used
)
1588 size
= EVBUFFER_LENGTH(wp
->event
->input
) - used
;