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
;
69 struct client_file
*file
;
72 static struct window_pane
*window_pane_create(struct window
*, u_int
, u_int
,
74 static void window_pane_destroy(struct window_pane
*);
76 RB_GENERATE(windows
, window
, entry
, window_cmp
);
77 RB_GENERATE(winlinks
, winlink
, entry
, winlink_cmp
);
78 RB_GENERATE(window_pane_tree
, window_pane
, tree_entry
, window_pane_cmp
);
81 window_cmp(struct window
*w1
, struct window
*w2
)
83 return (w1
->id
- w2
->id
);
87 winlink_cmp(struct winlink
*wl1
, struct winlink
*wl2
)
89 return (wl1
->idx
- wl2
->idx
);
93 window_pane_cmp(struct window_pane
*wp1
, struct window_pane
*wp2
)
95 return (wp1
->id
- wp2
->id
);
99 winlink_find_by_window(struct winlinks
*wwl
, struct window
*w
)
103 RB_FOREACH(wl
, winlinks
, wwl
) {
112 winlink_find_by_index(struct winlinks
*wwl
, int idx
)
120 return (RB_FIND(winlinks
, wwl
, &wl
));
124 winlink_find_by_window_id(struct winlinks
*wwl
, u_int id
)
128 RB_FOREACH(wl
, winlinks
, wwl
) {
129 if (wl
->window
->id
== id
)
136 winlink_next_index(struct winlinks
*wwl
, int idx
)
142 if (winlink_find_by_index(wwl
, i
) == NULL
)
153 winlink_count(struct winlinks
*wwl
)
159 RB_FOREACH(wl
, winlinks
, wwl
)
166 winlink_add(struct winlinks
*wwl
, int idx
)
171 if ((idx
= winlink_next_index(wwl
, -idx
- 1)) == -1)
173 } else if (winlink_find_by_index(wwl
, idx
) != NULL
)
176 wl
= xcalloc(1, sizeof *wl
);
178 RB_INSERT(winlinks
, wwl
, wl
);
184 winlink_set_window(struct winlink
*wl
, struct window
*w
)
186 if (wl
->window
!= NULL
) {
187 TAILQ_REMOVE(&wl
->window
->winlinks
, wl
, wentry
);
188 window_remove_ref(wl
->window
, __func__
);
190 TAILQ_INSERT_TAIL(&w
->winlinks
, wl
, wentry
);
192 window_add_ref(w
, __func__
);
196 winlink_remove(struct winlinks
*wwl
, struct winlink
*wl
)
198 struct window
*w
= wl
->window
;
201 TAILQ_REMOVE(&w
->winlinks
, wl
, wentry
);
202 window_remove_ref(w
, __func__
);
205 RB_REMOVE(winlinks
, wwl
, wl
);
210 winlink_next(struct winlink
*wl
)
212 return (RB_NEXT(winlinks
, wwl
, wl
));
216 winlink_previous(struct winlink
*wl
)
218 return (RB_PREV(winlinks
, wwl
, wl
));
222 winlink_next_by_number(struct winlink
*wl
, struct session
*s
, int n
)
225 if ((wl
= RB_NEXT(winlinks
, wwl
, wl
)) == NULL
)
226 wl
= RB_MIN(winlinks
, &s
->windows
);
233 winlink_previous_by_number(struct winlink
*wl
, struct session
*s
, int n
)
236 if ((wl
= RB_PREV(winlinks
, wwl
, wl
)) == NULL
)
237 wl
= RB_MAX(winlinks
, &s
->windows
);
244 winlink_stack_push(struct winlink_stack
*stack
, struct winlink
*wl
)
249 winlink_stack_remove(stack
, wl
);
250 TAILQ_INSERT_HEAD(stack
, wl
, sentry
);
251 wl
->flags
|= WINLINK_VISITED
;
255 winlink_stack_remove(struct winlink_stack
*stack
, struct winlink
*wl
)
257 if (wl
!= NULL
&& (wl
->flags
& WINLINK_VISITED
)) {
258 TAILQ_REMOVE(stack
, wl
, sentry
);
259 wl
->flags
&= ~WINLINK_VISITED
;
264 window_find_by_id_str(const char *s
)
272 id
= strtonum(s
+ 1, 0, UINT_MAX
, &errstr
);
275 return (window_find_by_id(id
));
279 window_find_by_id(u_int id
)
284 return (RB_FIND(windows
, &windows
, &w
));
288 window_update_activity(struct window
*w
)
290 gettimeofday(&w
->activity_time
, NULL
);
291 alerts_queue(w
, WINDOW_ACTIVITY
);
295 window_create(u_int sx
, u_int sy
, u_int xpixel
, u_int ypixel
)
300 xpixel
= DEFAULT_XPIXEL
;
302 ypixel
= DEFAULT_YPIXEL
;
304 w
= xcalloc(1, sizeof *w
);
305 w
->name
= xstrdup("");
308 TAILQ_INIT(&w
->panes
);
309 TAILQ_INIT(&w
->last_panes
);
313 w
->layout_root
= NULL
;
322 w
->options
= options_create(global_w_options
);
325 TAILQ_INIT(&w
->winlinks
);
327 w
->id
= next_window_id
++;
328 RB_INSERT(windows
, &windows
, w
);
330 window_set_fill_character(w
);
331 window_update_activity(w
);
333 log_debug("%s: @%u create %ux%u (%ux%u)", __func__
, w
->id
, sx
, sy
,
334 w
->xpixel
, w
->ypixel
);
339 window_destroy(struct window
*w
)
341 log_debug("window @%u destroyed (%d references)", w
->id
, w
->references
);
344 RB_REMOVE(windows
, &windows
, w
);
346 if (w
->layout_root
!= NULL
)
347 layout_free_cell(w
->layout_root
);
348 if (w
->saved_layout_root
!= NULL
)
349 layout_free_cell(w
->saved_layout_root
);
352 window_destroy_panes(w
);
354 if (event_initialized(&w
->name_event
))
355 evtimer_del(&w
->name_event
);
357 if (event_initialized(&w
->alerts_timer
))
358 evtimer_del(&w
->alerts_timer
);
359 if (event_initialized(&w
->offset_timer
))
360 event_del(&w
->offset_timer
);
362 options_free(w
->options
);
363 free(w
->fill_character
);
370 window_pane_destroy_ready(struct window_pane
*wp
)
374 if (wp
->pipe_fd
!= -1) {
375 if (EVBUFFER_LENGTH(wp
->pipe_event
->output
) != 0)
377 if (ioctl(wp
->fd
, FIONREAD
, &n
) != -1 && n
> 0)
381 if (~wp
->flags
& PANE_EXITED
)
387 window_add_ref(struct window
*w
, const char *from
)
390 log_debug("%s: @%u %s, now %d", __func__
, w
->id
, from
, w
->references
);
394 window_remove_ref(struct window
*w
, const char *from
)
397 log_debug("%s: @%u %s, now %d", __func__
, w
->id
, from
, w
->references
);
399 if (w
->references
== 0)
404 window_set_name(struct window
*w
, const char *new_name
)
407 utf8_stravis(&w
->name
, new_name
, VIS_OCTAL
|VIS_CSTYLE
|VIS_TAB
|VIS_NL
);
408 notify_window("window-renamed", w
);
412 window_resize(struct window
*w
, u_int sx
, u_int sy
, int xpixel
, int ypixel
)
415 xpixel
= DEFAULT_XPIXEL
;
417 ypixel
= DEFAULT_YPIXEL
;
419 log_debug("%s: @%u resize %ux%u (%ux%u)", __func__
, w
->id
, sx
, sy
,
420 xpixel
== -1 ? w
->xpixel
: (u_int
)xpixel
,
421 ypixel
== -1 ? w
->ypixel
: (u_int
)ypixel
);
431 window_pane_send_resize(struct window_pane
*wp
, u_int sx
, u_int sy
)
433 struct window
*w
= wp
->window
;
439 log_debug("%s: %%%u resize to %u,%u", __func__
, wp
->id
, sx
, sy
);
441 memset(&ws
, 0, sizeof ws
);
444 ws
.ws_xpixel
= w
->xpixel
* ws
.ws_col
;
445 ws
.ws_ypixel
= w
->ypixel
* ws
.ws_row
;
446 if (ioctl(wp
->fd
, TIOCSWINSZ
, &ws
) == -1)
447 fatal("ioctl failed");
451 window_has_pane(struct window
*w
, struct window_pane
*wp
)
453 struct window_pane
*wp1
;
455 TAILQ_FOREACH(wp1
, &w
->panes
, entry
) {
463 window_update_focus(struct window
*w
)
466 log_debug("%s: @%u", __func__
, w
->id
);
467 window_pane_update_focus(w
->active
);
472 window_pane_update_focus(struct window_pane
*wp
)
478 if (wp
!= wp
->window
->active
)
481 TAILQ_FOREACH(c
, &clients
, entry
) {
482 if (c
->session
!= NULL
&&
483 c
->session
->attached
!= 0 &&
484 (c
->flags
& CLIENT_FOCUSED
) &&
485 c
->session
->curw
->window
== wp
->window
) {
491 if (!focused
&& (wp
->flags
& PANE_FOCUSED
)) {
492 log_debug("%s: %%%u focus out", __func__
, wp
->id
);
493 if (wp
->base
.mode
& MODE_FOCUSON
)
494 bufferevent_write(wp
->event
, "\033[O", 3);
495 notify_pane("pane-focus-out", wp
);
496 wp
->flags
&= ~PANE_FOCUSED
;
497 } else if (focused
&& (~wp
->flags
& PANE_FOCUSED
)) {
498 log_debug("%s: %%%u focus in", __func__
, wp
->id
);
499 if (wp
->base
.mode
& MODE_FOCUSON
)
500 bufferevent_write(wp
->event
, "\033[I", 3);
501 notify_pane("pane-focus-in", wp
);
502 wp
->flags
|= PANE_FOCUSED
;
504 log_debug("%s: %%%u focus unchanged", __func__
, wp
->id
);
509 window_set_active_pane(struct window
*w
, struct window_pane
*wp
, int notify
)
511 struct window_pane
*lastwp
;
513 log_debug("%s: pane %%%u", __func__
, wp
->id
);
519 window_pane_stack_remove(&w
->last_panes
, wp
);
520 window_pane_stack_push(&w
->last_panes
, lastwp
);
523 w
->active
->active_point
= next_active_point
++;
524 w
->active
->flags
|= PANE_CHANGED
;
526 if (options_get_number(global_options
, "focus-events")) {
527 window_pane_update_focus(lastwp
);
528 window_pane_update_focus(w
->active
);
531 tty_update_window_offset(w
);
534 notify_window("window-pane-changed", w
);
539 window_pane_get_palette(struct window_pane
*wp
, int c
)
543 return (colour_palette_get(&wp
->palette
, c
));
547 window_redraw_active_switch(struct window
*w
, struct window_pane
*wp
)
549 struct grid_cell
*gc1
, *gc2
;
557 * If the active and inactive styles or palettes are different,
558 * need to redraw the panes.
560 gc1
= &wp
->cached_gc
;
561 gc2
= &wp
->cached_active_gc
;
562 if (!grid_cells_look_equal(gc1
, gc2
))
563 wp
->flags
|= PANE_REDRAW
;
565 c1
= window_pane_get_palette(wp
, gc1
->fg
);
566 c2
= window_pane_get_palette(wp
, gc2
->fg
);
568 wp
->flags
|= PANE_REDRAW
;
570 c1
= window_pane_get_palette(wp
, gc1
->bg
);
571 c2
= window_pane_get_palette(wp
, gc2
->bg
);
573 wp
->flags
|= PANE_REDRAW
;
583 window_get_active_at(struct window
*w
, u_int x
, u_int y
)
585 struct window_pane
*wp
;
587 TAILQ_FOREACH(wp
, &w
->panes
, entry
) {
588 if (!window_pane_visible(wp
))
590 if (x
< wp
->xoff
|| x
> wp
->xoff
+ wp
->sx
)
592 if (y
< wp
->yoff
|| y
> wp
->yoff
+ wp
->sy
)
600 window_find_string(struct window
*w
, const char *s
)
602 u_int x
, y
, top
= 0, bottom
= w
->sy
- 1;
608 status
= options_get_number(w
->options
, "pane-border-status");
609 if (status
== PANE_STATUS_TOP
)
611 else if (status
== PANE_STATUS_BOTTOM
)
614 if (strcasecmp(s
, "top") == 0)
616 else if (strcasecmp(s
, "bottom") == 0)
618 else if (strcasecmp(s
, "left") == 0)
620 else if (strcasecmp(s
, "right") == 0)
622 else if (strcasecmp(s
, "top-left") == 0) {
625 } else if (strcasecmp(s
, "top-right") == 0) {
628 } else if (strcasecmp(s
, "bottom-left") == 0) {
631 } else if (strcasecmp(s
, "bottom-right") == 0) {
637 return (window_get_active_at(w
, x
, y
));
641 window_zoom(struct window_pane
*wp
)
643 struct window
*w
= wp
->window
;
644 struct window_pane
*wp1
;
646 if (w
->flags
& WINDOW_ZOOMED
)
649 if (window_count_panes(w
) == 1)
653 window_set_active_pane(w
, wp
, 1);
655 TAILQ_FOREACH(wp1
, &w
->panes
, entry
) {
656 wp1
->saved_layout_cell
= wp1
->layout_cell
;
657 wp1
->layout_cell
= NULL
;
660 w
->saved_layout_root
= w
->layout_root
;
662 w
->flags
|= WINDOW_ZOOMED
;
663 notify_window("window-layout-changed", w
);
669 window_unzoom(struct window
*w
)
671 struct window_pane
*wp
;
673 if (!(w
->flags
& WINDOW_ZOOMED
))
676 w
->flags
&= ~WINDOW_ZOOMED
;
678 w
->layout_root
= w
->saved_layout_root
;
679 w
->saved_layout_root
= NULL
;
681 TAILQ_FOREACH(wp
, &w
->panes
, entry
) {
682 wp
->layout_cell
= wp
->saved_layout_cell
;
683 wp
->saved_layout_cell
= NULL
;
685 layout_fix_panes(w
, NULL
);
686 notify_window("window-layout-changed", w
);
692 window_push_zoom(struct window
*w
, int always
, int flag
)
694 log_debug("%s: @%u %d", __func__
, w
->id
,
695 flag
&& (w
->flags
& WINDOW_ZOOMED
));
696 if (flag
&& (always
|| (w
->flags
& WINDOW_ZOOMED
)))
697 w
->flags
|= WINDOW_WASZOOMED
;
699 w
->flags
&= ~WINDOW_WASZOOMED
;
700 return (window_unzoom(w
) == 0);
704 window_pop_zoom(struct window
*w
)
706 log_debug("%s: @%u %d", __func__
, w
->id
,
707 !!(w
->flags
& WINDOW_WASZOOMED
));
708 if (w
->flags
& WINDOW_WASZOOMED
)
709 return (window_zoom(w
->active
) == 0);
714 window_add_pane(struct window
*w
, struct window_pane
*other
, u_int hlimit
,
717 struct window_pane
*wp
;
722 wp
= window_pane_create(w
, w
->sx
, w
->sy
, hlimit
);
723 if (TAILQ_EMPTY(&w
->panes
)) {
724 log_debug("%s: @%u at start", __func__
, w
->id
);
725 TAILQ_INSERT_HEAD(&w
->panes
, wp
, entry
);
726 } else if (flags
& SPAWN_BEFORE
) {
727 log_debug("%s: @%u before %%%u", __func__
, w
->id
, wp
->id
);
728 if (flags
& SPAWN_FULLSIZE
)
729 TAILQ_INSERT_HEAD(&w
->panes
, wp
, entry
);
731 TAILQ_INSERT_BEFORE(other
, wp
, entry
);
733 log_debug("%s: @%u after %%%u", __func__
, w
->id
, wp
->id
);
734 if (flags
& SPAWN_FULLSIZE
)
735 TAILQ_INSERT_TAIL(&w
->panes
, wp
, entry
);
737 TAILQ_INSERT_AFTER(&w
->panes
, other
, wp
, entry
);
743 window_lost_pane(struct window
*w
, struct window_pane
*wp
)
745 log_debug("%s: @%u pane %%%u", __func__
, w
->id
, wp
->id
);
747 if (wp
== marked_pane
.wp
)
748 server_clear_marked();
750 window_pane_stack_remove(&w
->last_panes
, wp
);
751 if (wp
== w
->active
) {
752 w
->active
= TAILQ_FIRST(&w
->last_panes
);
753 if (w
->active
== NULL
) {
754 w
->active
= TAILQ_PREV(wp
, window_panes
, entry
);
755 if (w
->active
== NULL
)
756 w
->active
= TAILQ_NEXT(wp
, entry
);
758 if (w
->active
!= NULL
) {
759 window_pane_stack_remove(&w
->last_panes
, w
->active
);
760 w
->active
->flags
|= PANE_CHANGED
;
761 notify_window("window-pane-changed", w
);
762 window_update_focus(w
);
768 window_remove_pane(struct window
*w
, struct window_pane
*wp
)
770 window_lost_pane(w
, wp
);
772 TAILQ_REMOVE(&w
->panes
, wp
, entry
);
773 window_pane_destroy(wp
);
777 window_pane_at_index(struct window
*w
, u_int idx
)
779 struct window_pane
*wp
;
782 n
= options_get_number(w
->options
, "pane-base-index");
783 TAILQ_FOREACH(wp
, &w
->panes
, entry
) {
792 window_pane_next_by_number(struct window
*w
, struct window_pane
*wp
, u_int n
)
795 if ((wp
= TAILQ_NEXT(wp
, entry
)) == NULL
)
796 wp
= TAILQ_FIRST(&w
->panes
);
803 window_pane_previous_by_number(struct window
*w
, struct window_pane
*wp
,
807 if ((wp
= TAILQ_PREV(wp
, window_panes
, entry
)) == NULL
)
808 wp
= TAILQ_LAST(&w
->panes
, window_panes
);
815 window_pane_index(struct window_pane
*wp
, u_int
*i
)
817 struct window_pane
*wq
;
818 struct window
*w
= wp
->window
;
820 *i
= options_get_number(w
->options
, "pane-base-index");
821 TAILQ_FOREACH(wq
, &w
->panes
, entry
) {
832 window_count_panes(struct window
*w
)
834 struct window_pane
*wp
;
838 TAILQ_FOREACH(wp
, &w
->panes
, entry
)
844 window_destroy_panes(struct window
*w
)
846 struct window_pane
*wp
;
848 while (!TAILQ_EMPTY(&w
->last_panes
)) {
849 wp
= TAILQ_FIRST(&w
->last_panes
);
850 window_pane_stack_remove(&w
->last_panes
, wp
);
853 while (!TAILQ_EMPTY(&w
->panes
)) {
854 wp
= TAILQ_FIRST(&w
->panes
);
855 TAILQ_REMOVE(&w
->panes
, wp
, entry
);
856 window_pane_destroy(wp
);
861 window_printable_flags(struct winlink
*wl
, int escape
)
863 struct session
*s
= wl
->session
;
864 static char flags
[32];
868 if (wl
->flags
& WINLINK_ACTIVITY
) {
873 if (wl
->flags
& WINLINK_BELL
)
875 if (wl
->flags
& WINLINK_SILENCE
)
879 if (wl
== TAILQ_FIRST(&s
->lastw
))
881 if (server_check_marked() && wl
== marked_pane
.wl
)
883 if (wl
->window
->flags
& WINDOW_ZOOMED
)
890 window_pane_find_by_id_str(const char *s
)
898 id
= strtonum(s
+ 1, 0, UINT_MAX
, &errstr
);
901 return (window_pane_find_by_id(id
));
905 window_pane_find_by_id(u_int id
)
907 struct window_pane wp
;
910 return (RB_FIND(window_pane_tree
, &all_window_panes
, &wp
));
913 static struct window_pane
*
914 window_pane_create(struct window
*w
, u_int sx
, u_int sy
, u_int hlimit
)
916 struct window_pane
*wp
;
917 char host
[HOST_NAME_MAX
+ 1];
919 wp
= xcalloc(1, sizeof *wp
);
921 wp
->options
= options_create(w
->options
);
922 wp
->flags
= PANE_STYLECHANGED
;
924 wp
->id
= next_window_pane_id
++;
925 RB_INSERT(window_pane_tree
, &all_window_panes
, wp
);
929 TAILQ_INIT(&wp
->modes
);
931 TAILQ_INIT (&wp
->resize_queue
);
938 colour_palette_init(&wp
->palette
);
939 colour_palette_from_option(&wp
->palette
, wp
->options
);
941 screen_init(&wp
->base
, sx
, sy
, hlimit
);
942 wp
->screen
= &wp
->base
;
943 window_pane_default_cursor(wp
);
945 screen_init(&wp
->status_screen
, 1, 1, 0);
947 if (gethostname(host
, sizeof host
) == 0)
948 screen_set_title(&wp
->base
, host
);
954 window_pane_destroy(struct window_pane
*wp
)
956 struct window_pane_resize
*r
;
957 struct window_pane_resize
*r1
;
959 window_pane_reset_mode_all(wp
);
963 bufferevent_free(wp
->event
);
966 if (wp
->ictx
!= NULL
)
967 input_free(wp
->ictx
);
969 screen_free(&wp
->status_screen
);
971 screen_free(&wp
->base
);
973 if (wp
->pipe_fd
!= -1) {
974 bufferevent_free(wp
->pipe_event
);
978 if (event_initialized(&wp
->resize_timer
))
979 event_del(&wp
->resize_timer
);
980 TAILQ_FOREACH_SAFE(r
, &wp
->resize_queue
, entry
, r1
) {
981 TAILQ_REMOVE(&wp
->resize_queue
, r
, entry
);
985 RB_REMOVE(window_pane_tree
, &all_window_panes
, wp
);
987 options_free(wp
->options
);
988 free((void *)wp
->cwd
);
990 cmd_free_argv(wp
->argc
, wp
->argv
);
991 colour_palette_free(&wp
->palette
);
996 window_pane_read_callback(__unused
struct bufferevent
*bufev
, void *data
)
998 struct window_pane
*wp
= data
;
999 struct evbuffer
*evb
= wp
->event
->input
;
1000 struct window_pane_offset
*wpo
= &wp
->pipe_offset
;
1001 size_t size
= EVBUFFER_LENGTH(evb
);
1006 if (wp
->pipe_fd
!= -1) {
1007 new_data
= window_pane_get_new_data(wp
, wpo
, &new_size
);
1009 bufferevent_write(wp
->pipe_event
, new_data
, new_size
);
1010 window_pane_update_used_data(wp
, wpo
, new_size
);
1014 log_debug("%%%u has %zu bytes", wp
->id
, size
);
1015 TAILQ_FOREACH(c
, &clients
, entry
) {
1016 if (c
->session
!= NULL
&& (c
->flags
& CLIENT_CONTROL
))
1017 control_write_output(c
, wp
);
1019 input_parse_pane(wp
);
1020 bufferevent_disable(wp
->event
, EV_READ
);
1024 window_pane_error_callback(__unused
struct bufferevent
*bufev
,
1025 __unused
short what
, void *data
)
1027 struct window_pane
*wp
= data
;
1029 log_debug("%%%u error", wp
->id
);
1030 wp
->flags
|= PANE_EXITED
;
1032 if (window_pane_destroy_ready(wp
))
1033 server_destroy_pane(wp
, 1);
1037 window_pane_set_event(struct window_pane
*wp
)
1039 setblocking(wp
->fd
, 0);
1041 wp
->event
= bufferevent_new(wp
->fd
, window_pane_read_callback
,
1042 NULL
, window_pane_error_callback
, wp
);
1043 if (wp
->event
== NULL
)
1044 fatalx("out of memory");
1045 wp
->ictx
= input_init(wp
, wp
->event
, &wp
->palette
);
1047 bufferevent_enable(wp
->event
, EV_READ
|EV_WRITE
);
1051 window_pane_resize(struct window_pane
*wp
, u_int sx
, u_int sy
)
1053 struct window_mode_entry
*wme
;
1054 struct window_pane_resize
*r
;
1056 if (sx
== wp
->sx
&& sy
== wp
->sy
)
1059 r
= xmalloc(sizeof *r
);
1064 TAILQ_INSERT_TAIL (&wp
->resize_queue
, r
, entry
);
1069 log_debug("%s: %%%u resize %ux%u", __func__
, wp
->id
, sx
, sy
);
1070 screen_resize(&wp
->base
, sx
, sy
, wp
->base
.saved_grid
== NULL
);
1072 wme
= TAILQ_FIRST(&wp
->modes
);
1073 if (wme
!= NULL
&& wme
->mode
->resize
!= NULL
)
1074 wme
->mode
->resize(wme
, sx
, sy
);
1078 window_pane_set_mode(struct window_pane
*wp
, struct window_pane
*swp
,
1079 const struct window_mode
*mode
, struct cmd_find_state
*fs
,
1082 struct window_mode_entry
*wme
;
1084 if (!TAILQ_EMPTY(&wp
->modes
) && TAILQ_FIRST(&wp
->modes
)->mode
== mode
)
1087 TAILQ_FOREACH(wme
, &wp
->modes
, entry
) {
1088 if (wme
->mode
== mode
)
1092 TAILQ_REMOVE(&wp
->modes
, wme
, entry
);
1093 TAILQ_INSERT_HEAD(&wp
->modes
, wme
, entry
);
1095 wme
= xcalloc(1, sizeof *wme
);
1100 TAILQ_INSERT_HEAD(&wp
->modes
, wme
, entry
);
1101 wme
->screen
= wme
->mode
->init(wme
, fs
, args
);
1104 wp
->screen
= wme
->screen
;
1105 wp
->flags
|= (PANE_REDRAW
|PANE_CHANGED
);
1107 server_redraw_window_borders(wp
->window
);
1108 server_status_window(wp
->window
);
1109 notify_pane("pane-mode-changed", wp
);
1115 window_pane_reset_mode(struct window_pane
*wp
)
1117 struct window_mode_entry
*wme
, *next
;
1119 if (TAILQ_EMPTY(&wp
->modes
))
1122 wme
= TAILQ_FIRST(&wp
->modes
);
1123 TAILQ_REMOVE(&wp
->modes
, wme
, entry
);
1124 wme
->mode
->free(wme
);
1127 next
= TAILQ_FIRST(&wp
->modes
);
1129 wp
->flags
&= ~PANE_UNSEENCHANGES
;
1130 log_debug("%s: no next mode", __func__
);
1131 wp
->screen
= &wp
->base
;
1133 log_debug("%s: next mode is %s", __func__
, next
->mode
->name
);
1134 wp
->screen
= next
->screen
;
1135 if (next
->mode
->resize
!= NULL
)
1136 next
->mode
->resize(next
, wp
->sx
, wp
->sy
);
1138 wp
->flags
|= (PANE_REDRAW
|PANE_CHANGED
);
1140 server_redraw_window_borders(wp
->window
);
1141 server_status_window(wp
->window
);
1142 notify_pane("pane-mode-changed", wp
);
1146 window_pane_reset_mode_all(struct window_pane
*wp
)
1148 while (!TAILQ_EMPTY(&wp
->modes
))
1149 window_pane_reset_mode(wp
);
1153 window_pane_copy_key(struct window_pane
*wp
, key_code key
)
1155 struct window_pane
*loop
;
1157 TAILQ_FOREACH(loop
, &wp
->window
->panes
, entry
) {
1159 TAILQ_EMPTY(&loop
->modes
) &&
1161 (~loop
->flags
& PANE_INPUTOFF
) &&
1162 window_pane_visible(loop
) &&
1163 options_get_number(loop
->options
, "synchronize-panes"))
1164 input_key_pane(loop
, key
, NULL
);
1169 window_pane_key(struct window_pane
*wp
, struct client
*c
, struct session
*s
,
1170 struct winlink
*wl
, key_code key
, struct mouse_event
*m
)
1172 struct window_mode_entry
*wme
;
1174 if (KEYC_IS_MOUSE(key
) && m
== NULL
)
1177 wme
= TAILQ_FIRST(&wp
->modes
);
1179 if (wme
->mode
->key
!= NULL
&& c
!= NULL
) {
1180 key
&= ~KEYC_MASK_FLAGS
;
1181 wme
->mode
->key(wme
, c
, s
, wl
, key
, m
);
1186 if (wp
->fd
== -1 || wp
->flags
& PANE_INPUTOFF
)
1189 if (input_key_pane(wp
, key
, m
) != 0)
1192 if (KEYC_IS_MOUSE(key
))
1194 if (options_get_number(wp
->options
, "synchronize-panes"))
1195 window_pane_copy_key(wp
, key
);
1200 window_pane_visible(struct window_pane
*wp
)
1202 if (~wp
->window
->flags
& WINDOW_ZOOMED
)
1204 return (wp
== wp
->window
->active
);
1208 window_pane_search(struct window_pane
*wp
, const char *term
, int regex
,
1211 struct screen
*s
= &wp
->base
;
1213 char *new = NULL
, *line
;
1215 int flags
= 0, found
;
1220 flags
|= FNM_CASEFOLD
;
1221 xasprintf(&new, "*%s*", term
);
1225 if (regcomp(&r
, term
, flags
|REG_EXTENDED
) != 0)
1229 for (i
= 0; i
< screen_size_y(s
); i
++) {
1230 line
= grid_view_string_cells(s
->grid
, 0, i
, screen_size_x(s
));
1231 for (n
= strlen(line
); n
> 0; n
--) {
1232 if (!isspace((u_char
)line
[n
- 1]))
1236 log_debug("%s: %s", __func__
, line
);
1238 found
= (fnmatch(new, line
, flags
) == 0);
1240 found
= (regexec(&r
, line
, 0, NULL
, 0) == 0);
1250 if (i
== screen_size_y(s
))
1255 /* Get MRU pane from a list. */
1256 static struct window_pane
*
1257 window_pane_choose_best(struct window_pane
**list
, u_int size
)
1259 struct window_pane
*next
, *best
;
1266 for (i
= 1; i
< size
; i
++) {
1268 if (next
->active_point
> best
->active_point
)
1275 * Find the pane directly above another. We build a list of those adjacent to
1276 * top edge and then choose the best.
1278 struct window_pane
*
1279 window_pane_find_up(struct window_pane
*wp
)
1282 struct window_pane
*next
, *best
, **list
;
1283 u_int edge
, left
, right
, end
, size
;
1289 status
= options_get_number(w
->options
, "pane-border-status");
1295 if (status
== PANE_STATUS_TOP
) {
1298 } else if (status
== PANE_STATUS_BOTTOM
) {
1307 right
= wp
->xoff
+ wp
->sx
;
1309 TAILQ_FOREACH(next
, &w
->panes
, entry
) {
1312 if (next
->yoff
+ next
->sy
+ 1 != edge
)
1314 end
= next
->xoff
+ next
->sx
- 1;
1317 if (next
->xoff
< left
&& end
> right
)
1319 else if (next
->xoff
>= left
&& next
->xoff
<= right
)
1321 else if (end
>= left
&& end
<= right
)
1325 list
= xreallocarray(list
, size
+ 1, sizeof *list
);
1326 list
[size
++] = next
;
1329 best
= window_pane_choose_best(list
, size
);
1334 /* Find the pane directly below another. */
1335 struct window_pane
*
1336 window_pane_find_down(struct window_pane
*wp
)
1339 struct window_pane
*next
, *best
, **list
;
1340 u_int edge
, left
, right
, end
, size
;
1346 status
= options_get_number(w
->options
, "pane-border-status");
1351 edge
= wp
->yoff
+ wp
->sy
+ 1;
1352 if (status
== PANE_STATUS_TOP
) {
1355 } else if (status
== PANE_STATUS_BOTTOM
) {
1356 if (edge
>= w
->sy
- 1)
1364 right
= wp
->xoff
+ wp
->sx
;
1366 TAILQ_FOREACH(next
, &w
->panes
, entry
) {
1369 if (next
->yoff
!= edge
)
1371 end
= next
->xoff
+ next
->sx
- 1;
1374 if (next
->xoff
< left
&& end
> right
)
1376 else if (next
->xoff
>= left
&& next
->xoff
<= right
)
1378 else if (end
>= left
&& end
<= right
)
1382 list
= xreallocarray(list
, size
+ 1, sizeof *list
);
1383 list
[size
++] = next
;
1386 best
= window_pane_choose_best(list
, size
);
1391 /* Find the pane directly to the left of another. */
1392 struct window_pane
*
1393 window_pane_find_left(struct window_pane
*wp
)
1396 struct window_pane
*next
, *best
, **list
;
1397 u_int edge
, top
, bottom
, end
, size
;
1412 bottom
= wp
->yoff
+ wp
->sy
;
1414 TAILQ_FOREACH(next
, &w
->panes
, entry
) {
1417 if (next
->xoff
+ next
->sx
+ 1 != edge
)
1419 end
= next
->yoff
+ next
->sy
- 1;
1422 if (next
->yoff
< top
&& end
> bottom
)
1424 else if (next
->yoff
>= top
&& next
->yoff
<= bottom
)
1426 else if (end
>= top
&& end
<= bottom
)
1430 list
= xreallocarray(list
, size
+ 1, sizeof *list
);
1431 list
[size
++] = next
;
1434 best
= window_pane_choose_best(list
, size
);
1439 /* Find the pane directly to the right of another. */
1440 struct window_pane
*
1441 window_pane_find_right(struct window_pane
*wp
)
1444 struct window_pane
*next
, *best
, **list
;
1445 u_int edge
, top
, bottom
, end
, size
;
1455 edge
= wp
->xoff
+ wp
->sx
+ 1;
1460 bottom
= wp
->yoff
+ wp
->sy
;
1462 TAILQ_FOREACH(next
, &w
->panes
, entry
) {
1465 if (next
->xoff
!= edge
)
1467 end
= next
->yoff
+ next
->sy
- 1;
1470 if (next
->yoff
< top
&& end
> bottom
)
1472 else if (next
->yoff
>= top
&& next
->yoff
<= bottom
)
1474 else if (end
>= top
&& end
<= bottom
)
1478 list
= xreallocarray(list
, size
+ 1, sizeof *list
);
1479 list
[size
++] = next
;
1482 best
= window_pane_choose_best(list
, size
);
1488 window_pane_stack_push(struct window_panes
*stack
, struct window_pane
*wp
)
1491 window_pane_stack_remove(stack
, wp
);
1492 TAILQ_INSERT_HEAD(stack
, wp
, sentry
);
1493 wp
->flags
|= PANE_VISITED
;
1498 window_pane_stack_remove(struct window_panes
*stack
, struct window_pane
*wp
)
1500 if (wp
!= NULL
&& (wp
->flags
& PANE_VISITED
)) {
1501 TAILQ_REMOVE(stack
, wp
, sentry
);
1502 wp
->flags
&= ~PANE_VISITED
;
1506 /* Clear alert flags for a winlink */
1508 winlink_clear_flags(struct winlink
*wl
)
1510 struct winlink
*loop
;
1512 wl
->window
->flags
&= ~WINDOW_ALERTFLAGS
;
1513 TAILQ_FOREACH(loop
, &wl
->window
->winlinks
, wentry
) {
1514 if ((loop
->flags
& WINLINK_ALERTFLAGS
) != 0) {
1515 loop
->flags
&= ~WINLINK_ALERTFLAGS
;
1516 server_status_session(loop
->session
);
1521 /* Shuffle window indexes up. */
1523 winlink_shuffle_up(struct session
*s
, struct winlink
*wl
, int before
)
1534 /* Find the next free index. */
1535 for (last
= idx
; last
< INT_MAX
; last
++) {
1536 if (winlink_find_by_index(&s
->windows
, last
) == NULL
)
1539 if (last
== INT_MAX
)
1542 /* Move everything from last - 1 to idx up a bit. */
1543 for (; last
> idx
; last
--) {
1544 wl
= winlink_find_by_index(&s
->windows
, last
- 1);
1545 RB_REMOVE(winlinks
, &s
->windows
, wl
);
1547 RB_INSERT(winlinks
, &s
->windows
, wl
);
1554 window_pane_input_callback(struct client
*c
, __unused
const char *path
,
1555 int error
, int closed
, struct evbuffer
*buffer
, void *data
)
1557 struct window_pane_input_data
*cdata
= data
;
1558 struct window_pane
*wp
;
1559 u_char
*buf
= EVBUFFER_DATA(buffer
);
1560 size_t len
= EVBUFFER_LENGTH(buffer
);
1562 wp
= window_pane_find_by_id(cdata
->wp
);
1563 if (cdata
->file
!= NULL
&& (wp
== NULL
|| c
->flags
& CLIENT_DEAD
)) {
1566 c
->flags
|= CLIENT_EXIT
;
1568 file_cancel(cdata
->file
);
1569 } else if (cdata
->file
== NULL
|| closed
|| error
!= 0) {
1570 cmdq_continue(cdata
->item
);
1571 server_client_unref(c
);
1574 input_parse_buffer(wp
, buf
, len
);
1575 evbuffer_drain(buffer
, len
);
1579 window_pane_start_input(struct window_pane
*wp
, struct cmdq_item
*item
,
1582 struct client
*c
= cmdq_get_client(item
);
1583 struct window_pane_input_data
*cdata
;
1585 if (~wp
->flags
& PANE_EMPTY
) {
1586 *cause
= xstrdup("pane is not empty");
1589 if (c
->flags
& (CLIENT_DEAD
|CLIENT_EXITED
))
1591 if (c
->session
!= NULL
)
1594 cdata
= xmalloc(sizeof *cdata
);
1597 cdata
->file
= file_read(c
, "-", window_pane_input_callback
, cdata
);
1604 window_pane_get_new_data(struct window_pane
*wp
,
1605 struct window_pane_offset
*wpo
, size_t *size
)
1607 size_t used
= wpo
->used
- wp
->base_offset
;
1609 *size
= EVBUFFER_LENGTH(wp
->event
->input
) - used
;
1610 return (EVBUFFER_DATA(wp
->event
->input
) + used
);
1614 window_pane_update_used_data(struct window_pane
*wp
,
1615 struct window_pane_offset
*wpo
, size_t size
)
1617 size_t used
= wpo
->used
- wp
->base_offset
;
1619 if (size
> EVBUFFER_LENGTH(wp
->event
->input
) - used
)
1620 size
= EVBUFFER_LENGTH(wp
->event
->input
) - used
;
1625 window_set_fill_character(struct window
*w
)
1628 struct utf8_data
*ud
;
1630 free(w
->fill_character
);
1631 w
->fill_character
= NULL
;
1633 value
= options_get_string(w
->options
, "fill-character");
1634 if (*value
!= '\0' && utf8_isvalid(value
)) {
1635 ud
= utf8_fromcstr(value
);
1636 if (ud
!= NULL
&& ud
[0].width
== 1)
1637 w
->fill_character
= ud
;
1642 window_pane_default_cursor(struct window_pane
*wp
)
1644 struct screen
*s
= wp
->screen
;
1647 c
= options_get_number(wp
->options
, "cursor-colour");
1648 s
->default_ccolour
= c
;
1650 c
= options_get_number(wp
->options
, "cursor-style");
1651 s
->default_mode
= 0;
1652 screen_set_cursor_style(c
, &s
->default_cstyle
, &s
->default_mode
);