When removing a pane, don't change the active pane unless the active
[tmux-openbsd.git] / window.c
blob874f47235c1e3d7b5287d6b91eaf09b63a99dd15
1 /* $OpenBSD$ */
3 /*
4 * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
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>
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <fnmatch.h>
25 #include <paths.h>
26 #include <pwd.h>
27 #include <signal.h>
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <termios.h>
32 #include <unistd.h>
33 #include <util.h>
35 #include "tmux.h"
38 * Each window is attached to a number of panes, each of which is a pty. This
39 * file contains code to handle them.
41 * A pane has two buffers attached, these are filled and emptied by the main
42 * server poll loop. Output data is received from pty's in screen format,
43 * translated and returned as a series of escape sequences and strings via
44 * input_parse (in input.c). Input data is received as key codes and written
45 * directly via input_key.
47 * Each pane also has a "virtual" screen (screen.c) which contains the current
48 * state and is redisplayed when the window is reattached to a client.
50 * Windows are stored directly on a global array and wrapped in any number of
51 * winlink structs to be linked onto local session RB trees. A reference count
52 * is maintained and a window removed from the global list and destroyed when
53 * it reaches zero.
56 /* Global window list. */
57 struct windows windows;
59 void window_pane_read_callback(struct bufferevent *, void *);
60 void window_pane_error_callback(struct bufferevent *, short, void *);
62 RB_GENERATE(winlinks, winlink, entry, winlink_cmp);
64 int
65 winlink_cmp(struct winlink *wl1, struct winlink *wl2)
67 return (wl1->idx - wl2->idx);
70 struct winlink *
71 winlink_find_by_window(struct winlinks *wwl, struct window *w)
73 struct winlink *wl;
75 RB_FOREACH(wl, winlinks, wwl) {
76 if (wl->window == w)
77 return (wl);
80 return (NULL);
83 struct winlink *
84 winlink_find_by_index(struct winlinks *wwl, int idx)
86 struct winlink wl;
88 if (idx < 0)
89 fatalx("bad index");
91 wl.idx = idx;
92 return (RB_FIND(winlinks, wwl, &wl));
95 int
96 winlink_next_index(struct winlinks *wwl, int idx)
98 int i;
100 i = idx;
101 do {
102 if (winlink_find_by_index(wwl, i) == NULL)
103 return (i);
104 if (i == INT_MAX)
105 i = 0;
106 else
107 i++;
108 } while (i != idx);
109 return (-1);
112 u_int
113 winlink_count(struct winlinks *wwl)
115 struct winlink *wl;
116 u_int n;
118 n = 0;
119 RB_FOREACH(wl, winlinks, wwl)
120 n++;
122 return (n);
125 struct winlink *
126 winlink_add(struct winlinks *wwl, struct window *w, int idx)
128 struct winlink *wl;
130 if (idx < 0) {
131 if ((idx = winlink_next_index(wwl, -idx - 1)) == -1)
132 return (NULL);
133 } else if (winlink_find_by_index(wwl, idx) != NULL)
134 return (NULL);
136 wl = xcalloc(1, sizeof *wl);
137 wl->idx = idx;
138 wl->window = w;
139 RB_INSERT(winlinks, wwl, wl);
141 w->references++;
143 return (wl);
146 void
147 winlink_remove(struct winlinks *wwl, struct winlink *wl)
149 struct window *w = wl->window;
151 RB_REMOVE(winlinks, wwl, wl);
152 if (wl->status_text != NULL)
153 xfree(wl->status_text);
154 xfree(wl);
156 if (w->references == 0)
157 fatal("bad reference count");
158 w->references--;
159 if (w->references == 0)
160 window_destroy(w);
163 struct winlink *
164 winlink_next(struct winlink *wl)
166 return (RB_NEXT(winlinks, wwl, wl));
169 struct winlink *
170 winlink_previous(struct winlink *wl)
172 return (RB_PREV(winlinks, wwl, wl));
175 struct winlink *
176 winlink_next_by_number(struct winlink *wl, struct session *s, int n)
178 for (; n > 0; n--) {
179 if ((wl = RB_NEXT(winlinks, wwl, wl)) == NULL)
180 wl = RB_MIN(winlinks, &s->windows);
183 return (wl);
186 struct winlink *
187 winlink_previous_by_number(struct winlink *wl, struct session *s, int n)
189 for (; n > 0; n--) {
190 if ((wl = RB_PREV(winlinks, wwl, wl)) == NULL)
191 wl = RB_MAX(winlinks, &s->windows);
194 return (wl);
197 void
198 winlink_stack_push(struct winlink_stack *stack, struct winlink *wl)
200 if (wl == NULL)
201 return;
203 winlink_stack_remove(stack, wl);
204 TAILQ_INSERT_HEAD(stack, wl, sentry);
207 void
208 winlink_stack_remove(struct winlink_stack *stack, struct winlink *wl)
210 struct winlink *wl2;
212 if (wl == NULL)
213 return;
215 TAILQ_FOREACH(wl2, stack, sentry) {
216 if (wl2 == wl) {
217 TAILQ_REMOVE(stack, wl, sentry);
218 return;
224 window_index(struct window *s, u_int *i)
226 for (*i = 0; *i < ARRAY_LENGTH(&windows); (*i)++) {
227 if (s == ARRAY_ITEM(&windows, *i))
228 return (0);
230 return (-1);
233 struct window *
234 window_create1(u_int sx, u_int sy)
236 struct window *w;
237 u_int i;
239 w = xcalloc(1, sizeof *w);
240 w->name = NULL;
241 w->flags = 0;
243 TAILQ_INIT(&w->panes);
244 w->active = NULL;
246 w->lastlayout = -1;
247 w->layout_root = NULL;
249 w->sx = sx;
250 w->sy = sy;
252 queue_window_name(w);
254 options_init(&w->options, &global_w_options);
256 for (i = 0; i < ARRAY_LENGTH(&windows); i++) {
257 if (ARRAY_ITEM(&windows, i) == NULL) {
258 ARRAY_SET(&windows, i, w);
259 break;
262 if (i == ARRAY_LENGTH(&windows))
263 ARRAY_ADD(&windows, w);
264 w->references = 0;
266 return (w);
269 struct window *
270 window_create(const char *name, const char *cmd, const char *shell,
271 const char *cwd, struct environ *env, struct termios *tio,
272 u_int sx, u_int sy, u_int hlimit,char **cause)
274 struct window *w;
275 struct window_pane *wp;
277 w = window_create1(sx, sy);
278 wp = window_add_pane(w, hlimit);
279 layout_init(w);
280 if (window_pane_spawn(wp, cmd, shell, cwd, env, tio, cause) != 0) {
281 window_destroy(w);
282 return (NULL);
284 w->active = TAILQ_FIRST(&w->panes);
285 if (name != NULL) {
286 w->name = xstrdup(name);
287 options_set_number(&w->options, "automatic-rename", 0);
288 } else
289 w->name = default_window_name(w);
290 return (w);
293 void
294 window_destroy(struct window *w)
296 u_int i;
298 if (window_index(w, &i) != 0)
299 fatalx("index not found");
300 ARRAY_SET(&windows, i, NULL);
301 while (!ARRAY_EMPTY(&windows) && ARRAY_LAST(&windows) == NULL)
302 ARRAY_TRUNC(&windows, 1);
304 if (w->layout_root != NULL)
305 layout_free(w);
307 evtimer_del(&w->name_timer);
309 options_free(&w->options);
311 window_destroy_panes(w);
313 if (w->name != NULL)
314 xfree(w->name);
315 xfree(w);
318 void
319 window_resize(struct window *w, u_int sx, u_int sy)
321 w->sx = sx;
322 w->sy = sy;
325 void
326 window_set_active_pane(struct window *w, struct window_pane *wp)
328 w->active = wp;
329 while (!window_pane_visible(w->active)) {
330 w->active = TAILQ_PREV(w->active, window_panes, entry);
331 if (w->active == NULL)
332 w->active = TAILQ_LAST(&w->panes, window_panes);
333 if (w->active == wp)
334 return;
338 void
339 window_set_active_at(struct window *w, u_int x, u_int y)
341 struct window_pane *wp;
343 TAILQ_FOREACH(wp, &w->panes, entry) {
344 if (!window_pane_visible(wp))
345 continue;
346 if (x < wp->xoff || x >= wp->xoff + wp->sx)
347 continue;
348 if (y < wp->yoff || y >= wp->yoff + wp->sy)
349 continue;
350 window_set_active_pane(w, wp);
351 break;
355 struct window_pane *
356 window_add_pane(struct window *w, u_int hlimit)
358 struct window_pane *wp;
360 wp = window_pane_create(w, w->sx, w->sy, hlimit);
361 if (TAILQ_EMPTY(&w->panes))
362 TAILQ_INSERT_HEAD(&w->panes, wp, entry);
363 else
364 TAILQ_INSERT_AFTER(&w->panes, w->active, wp, entry);
365 return (wp);
368 void
369 window_remove_pane(struct window *w, struct window_pane *wp)
371 if (wp == w->active) {
372 w->active = TAILQ_PREV(wp, window_panes, entry);
373 if (w->active == NULL)
374 w->active = TAILQ_NEXT(wp, entry);
377 TAILQ_REMOVE(&w->panes, wp, entry);
378 window_pane_destroy(wp);
381 struct window_pane *
382 window_pane_at_index(struct window *w, u_int idx)
384 struct window_pane *wp;
385 u_int n;
387 n = 0;
388 TAILQ_FOREACH(wp, &w->panes, entry) {
389 if (n == idx)
390 return (wp);
391 n++;
393 return (NULL);
396 struct window_pane *
397 window_pane_next_by_number(struct window *w, struct window_pane *wp, u_int n)
399 for (; n > 0; n--) {
400 if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
401 wp = TAILQ_FIRST(&w->panes);
404 return (wp);
407 struct window_pane *
408 window_pane_previous_by_number(struct window *w, struct window_pane *wp,
409 u_int n)
411 for (; n > 0; n--) {
412 if ((wp = TAILQ_PREV(wp, window_panes, entry)) == NULL)
413 wp = TAILQ_LAST(&w->panes, window_panes);
416 return (wp);
419 u_int
420 window_pane_index(struct window *w, struct window_pane *wp)
422 struct window_pane *wq;
423 u_int n;
425 n = 0;
426 TAILQ_FOREACH(wq, &w->panes, entry) {
427 if (wp == wq)
428 break;
429 n++;
431 return (n);
434 u_int
435 window_count_panes(struct window *w)
437 struct window_pane *wp;
438 u_int n;
440 n = 0;
441 TAILQ_FOREACH(wp, &w->panes, entry)
442 n++;
443 return (n);
446 void
447 window_destroy_panes(struct window *w)
449 struct window_pane *wp;
451 while (!TAILQ_EMPTY(&w->panes)) {
452 wp = TAILQ_FIRST(&w->panes);
453 TAILQ_REMOVE(&w->panes, wp, entry);
454 window_pane_destroy(wp);
458 struct window_pane *
459 window_pane_create(struct window *w, u_int sx, u_int sy, u_int hlimit)
461 struct window_pane *wp;
463 wp = xcalloc(1, sizeof *wp);
464 wp->window = w;
466 wp->cmd = NULL;
467 wp->shell = NULL;
468 wp->cwd = NULL;
470 wp->fd = -1;
471 wp->event = NULL;
473 wp->mode = NULL;
475 wp->layout_cell = NULL;
477 wp->xoff = 0;
478 wp->yoff = 0;
480 wp->sx = sx;
481 wp->sy = sy;
483 wp->pipe_fd = -1;
484 wp->pipe_off = 0;
485 wp->pipe_event = NULL;
487 wp->saved_grid = NULL;
489 screen_init(&wp->base, sx, sy, hlimit);
490 wp->screen = &wp->base;
492 input_init(wp);
494 return (wp);
497 void
498 window_pane_destroy(struct window_pane *wp)
500 window_pane_reset_mode(wp);
502 if (wp->fd != -1) {
503 close(wp->fd);
504 bufferevent_free(wp->event);
507 input_free(wp);
509 screen_free(&wp->base);
510 if (wp->saved_grid != NULL)
511 grid_destroy(wp->saved_grid);
513 if (wp->pipe_fd != -1) {
514 close(wp->pipe_fd);
515 bufferevent_free(wp->pipe_event);
518 if (wp->cwd != NULL)
519 xfree(wp->cwd);
520 if (wp->shell != NULL)
521 xfree(wp->shell);
522 if (wp->cmd != NULL)
523 xfree(wp->cmd);
524 xfree(wp);
528 window_pane_spawn(struct window_pane *wp, const char *cmd, const char *shell,
529 const char *cwd, struct environ *env, struct termios *tio, char **cause)
531 struct winsize ws;
532 int mode;
533 char *argv0;
534 const char *ptr;
535 struct termios tio2;
537 if (wp->fd != -1) {
538 close(wp->fd);
539 bufferevent_free(wp->event);
541 if (cmd != NULL) {
542 if (wp->cmd != NULL)
543 xfree(wp->cmd);
544 wp->cmd = xstrdup(cmd);
546 if (shell != NULL) {
547 if (wp->shell != NULL)
548 xfree(wp->shell);
549 wp->shell = xstrdup(shell);
551 if (cwd != NULL) {
552 if (wp->cwd != NULL)
553 xfree(wp->cwd);
554 wp->cwd = xstrdup(cwd);
557 memset(&ws, 0, sizeof ws);
558 ws.ws_col = screen_size_x(&wp->base);
559 ws.ws_row = screen_size_y(&wp->base);
561 switch (wp->pid = forkpty(&wp->fd, wp->tty, NULL, &ws)) {
562 case -1:
563 wp->fd = -1;
564 xasprintf(cause, "%s: %s", cmd, strerror(errno));
565 return (-1);
566 case 0:
567 if (chdir(wp->cwd) != 0)
568 chdir("/");
570 if (tcgetattr(STDIN_FILENO, &tio2) != 0)
571 fatal("tcgetattr failed");
572 if (tio != NULL)
573 memcpy(tio2.c_cc, tio->c_cc, sizeof tio2.c_cc);
574 tio2.c_cc[VERASE] = '\177';
575 if (tcsetattr(STDIN_FILENO, TCSANOW, &tio2) != 0)
576 fatal("tcgetattr failed");
578 closefrom(STDERR_FILENO + 1);
580 environ_push(env);
582 clear_signals(1);
583 log_close();
585 if (*wp->cmd != '\0') {
586 /* Set SHELL but only if it is currently not useful. */
587 shell = getenv("SHELL");
588 if (shell == NULL || *shell == '\0' || areshell(shell))
589 setenv("SHELL", wp->shell, 1);
591 execl(_PATH_BSHELL, "sh", "-c", wp->cmd, (char *) NULL);
592 fatal("execl failed");
595 /* No command; fork a login shell. */
596 ptr = strrchr(wp->shell, '/');
597 if (ptr != NULL && *(ptr + 1) != '\0')
598 xasprintf(&argv0, "-%s", ptr + 1);
599 else
600 xasprintf(&argv0, "-%s", wp->shell);
601 setenv("SHELL", wp->shell, 1);
602 execl(wp->shell, argv0, (char *) NULL);
603 fatal("execl failed");
606 if ((mode = fcntl(wp->fd, F_GETFL)) == -1)
607 fatal("fcntl failed");
608 if (fcntl(wp->fd, F_SETFL, mode|O_NONBLOCK) == -1)
609 fatal("fcntl failed");
610 wp->event = bufferevent_new(wp->fd,
611 window_pane_read_callback, NULL, window_pane_error_callback, wp);
612 bufferevent_enable(wp->event, EV_READ|EV_WRITE);
614 return (0);
617 /* ARGSUSED */
618 void
619 window_pane_read_callback(unused struct bufferevent *bufev, void *data)
621 struct window_pane *wp = data;
622 char *new_data;
623 size_t new_size;
625 new_size = EVBUFFER_LENGTH(wp->event->input) - wp->pipe_off;
626 if (wp->pipe_fd != -1 && new_size > 0) {
627 new_data = EVBUFFER_DATA(wp->event->input);
628 bufferevent_write(wp->pipe_event, new_data, new_size);
631 input_parse(wp);
633 wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);
636 /* ARGSUSED */
637 void
638 window_pane_error_callback(
639 unused struct bufferevent *bufev, unused short what, void *data)
641 struct window_pane *wp = data;
643 server_destroy_pane(wp);
646 void
647 window_pane_resize(struct window_pane *wp, u_int sx, u_int sy)
649 struct winsize ws;
651 if (sx == wp->sx && sy == wp->sy)
652 return;
653 wp->sx = sx;
654 wp->sy = sy;
656 memset(&ws, 0, sizeof ws);
657 ws.ws_col = sx;
658 ws.ws_row = sy;
660 screen_resize(&wp->base, sx, sy);
661 if (wp->mode != NULL)
662 wp->mode->resize(wp, sx, sy);
664 if (wp->fd != -1 && ioctl(wp->fd, TIOCSWINSZ, &ws) == -1)
665 fatal("ioctl failed");
669 * Enter alternative screen mode. A copy of the visible screen is saved and the
670 * history is not updated
672 void
673 window_pane_alternate_on(struct window_pane *wp, struct grid_cell *gc)
675 struct screen *s = &wp->base;
676 u_int sx, sy;
678 if (wp->saved_grid != NULL)
679 return;
680 if (!options_get_number(&wp->window->options, "alternate-screen"))
681 return;
682 sx = screen_size_x(s);
683 sy = screen_size_y(s);
685 wp->saved_grid = grid_create(sx, sy, 0);
686 grid_duplicate_lines(wp->saved_grid, 0, s->grid, screen_hsize(s), sy);
687 wp->saved_cx = s->cx;
688 wp->saved_cy = s->cy;
689 memcpy(&wp->saved_cell, gc, sizeof wp->saved_cell);
691 grid_view_clear(s->grid, 0, 0, sx, sy);
693 wp->base.grid->flags &= ~GRID_HISTORY;
695 wp->flags |= PANE_REDRAW;
698 /* Exit alternate screen mode and restore the copied grid. */
699 void
700 window_pane_alternate_off(struct window_pane *wp, struct grid_cell *gc)
702 struct screen *s = &wp->base;
703 u_int sx, sy;
705 if (wp->saved_grid == NULL)
706 return;
707 if (!options_get_number(&wp->window->options, "alternate-screen"))
708 return;
709 sx = screen_size_x(s);
710 sy = screen_size_y(s);
713 * If the current size is bigger, temporarily resize to the old size
714 * before copying back.
716 if (sy > wp->saved_grid->sy)
717 screen_resize(s, sx, wp->saved_grid->sy);
719 /* Restore the grid, cursor position and cell. */
720 grid_duplicate_lines(s->grid, screen_hsize(s), wp->saved_grid, 0, sy);
721 s->cx = wp->saved_cx;
722 if (s->cx > screen_size_x(s) - 1)
723 s->cx = screen_size_x(s) - 1;
724 s->cy = wp->saved_cy;
725 if (s->cy > screen_size_y(s) - 1)
726 s->cy = screen_size_y(s) - 1;
727 memcpy(gc, &wp->saved_cell, sizeof *gc);
730 * Turn history back on (so resize can use it) and then resize back to
731 * the current size.
733 wp->base.grid->flags |= GRID_HISTORY;
734 if (sy > wp->saved_grid->sy)
735 screen_resize(s, sx, sy);
737 grid_destroy(wp->saved_grid);
738 wp->saved_grid = NULL;
740 wp->flags |= PANE_REDRAW;
744 window_pane_set_mode(struct window_pane *wp, const struct window_mode *mode)
746 struct screen *s;
748 if (wp->mode != NULL)
749 return (1);
750 wp->mode = mode;
752 if ((s = wp->mode->init(wp)) != NULL)
753 wp->screen = s;
754 wp->flags |= PANE_REDRAW;
755 return (0);
758 void
759 window_pane_reset_mode(struct window_pane *wp)
761 if (wp->mode == NULL)
762 return;
764 wp->mode->free(wp);
765 wp->mode = NULL;
767 wp->screen = &wp->base;
768 wp->flags |= PANE_REDRAW;
771 void
772 window_pane_key(struct window_pane *wp, struct session *sess, int key)
774 struct window_pane *wp2;
776 if (!window_pane_visible(wp))
777 return;
779 if (wp->mode != NULL) {
780 if (wp->mode->key != NULL)
781 wp->mode->key(wp, sess, key);
782 return;
785 if (wp->fd == -1)
786 return;
787 input_key(wp, key);
788 if (options_get_number(&wp->window->options, "synchronize-panes")) {
789 TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
790 if (wp2 == wp || wp2->mode != NULL)
791 continue;
792 if (wp2->fd != -1 && window_pane_visible(wp2))
793 input_key(wp2, key);
798 void
799 window_pane_mouse(
800 struct window_pane *wp, struct session *sess, struct mouse_event *m)
802 if (!window_pane_visible(wp))
803 return;
805 if (m->x < wp->xoff || m->x >= wp->xoff + wp->sx)
806 return;
807 if (m->y < wp->yoff || m->y >= wp->yoff + wp->sy)
808 return;
809 m->x -= wp->xoff;
810 m->y -= wp->yoff;
812 if (wp->mode != NULL) {
813 if (wp->mode->mouse != NULL)
814 wp->mode->mouse(wp, sess, m);
815 } else if (wp->fd != -1)
816 input_mouse(wp, m);
820 window_pane_visible(struct window_pane *wp)
822 struct window *w = wp->window;
824 if (wp->xoff >= w->sx || wp->yoff >= w->sy)
825 return (0);
826 if (wp->xoff + wp->sx > w->sx || wp->yoff + wp->sy > w->sy)
827 return (0);
828 return (1);
831 char *
832 window_pane_search(struct window_pane *wp, const char *searchstr, u_int *lineno)
834 struct screen *s = &wp->base;
835 char *newsearchstr, *line, *msg;
836 u_int i;
838 msg = NULL;
839 xasprintf(&newsearchstr, "*%s*", searchstr);
841 for (i = 0; i < screen_size_y(s); i++) {
842 line = grid_view_string_cells(s->grid, 0, i, screen_size_x(s));
843 if (fnmatch(newsearchstr, line, 0) == 0) {
844 msg = line;
845 if (lineno != NULL)
846 *lineno = i;
847 break;
849 xfree(line);
852 xfree(newsearchstr);
853 return (msg);
856 /* Find the pane directly above another. */
857 struct window_pane *
858 window_pane_find_up(struct window_pane *wp)
860 struct window_pane *wp2;
861 u_int left, top;
863 if (wp == NULL || !window_pane_visible(wp))
864 return (NULL);
866 top = wp->yoff;
867 if (top == 0)
868 top = wp->window->sy + 1;
869 left = wp->xoff;
871 TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
872 if (!window_pane_visible(wp2))
873 continue;
874 if (wp2->yoff + wp2->sy + 1 != top)
875 continue;
876 if (left >= wp2->xoff && left <= wp2->xoff + wp2->sx)
877 return (wp2);
879 return (NULL);
882 /* Find the pane directly below another. */
883 struct window_pane *
884 window_pane_find_down(struct window_pane *wp)
886 struct window_pane *wp2;
887 u_int left, bottom;
889 if (wp == NULL || !window_pane_visible(wp))
890 return (NULL);
892 bottom = wp->yoff + wp->sy + 1;
893 if (bottom >= wp->window->sy)
894 bottom = 0;
895 left = wp->xoff;
897 TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
898 if (!window_pane_visible(wp2))
899 continue;
900 if (wp2->yoff != bottom)
901 continue;
902 if (left >= wp2->xoff && left <= wp2->xoff + wp2->sx)
903 return (wp2);
905 return (NULL);
909 * Find the pane directly to the left of another, adjacent to the left side and
910 * containing the top edge.
912 struct window_pane *
913 window_pane_find_left(struct window_pane *wp)
915 struct window_pane *wp2;
916 u_int left, top;
918 if (wp == NULL || !window_pane_visible(wp))
919 return (NULL);
921 left = wp->xoff;
922 if (left == 0)
923 left = wp->window->sx + 1;
924 top = wp->yoff;
926 TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
927 if (!window_pane_visible(wp2))
928 continue;
929 if (wp2->xoff + wp2->sx + 1 != left)
930 continue;
931 if (top >= wp2->yoff && top <= wp2->yoff + wp2->sy)
932 return (wp2);
934 return (NULL);
938 * Find the pane directly to the right of another, that is adjacent to the
939 * right edge and including the top edge.
941 struct window_pane *
942 window_pane_find_right(struct window_pane *wp)
944 struct window_pane *wp2;
945 u_int right, top;
947 if (wp == NULL || !window_pane_visible(wp))
948 return (NULL);
950 right = wp->xoff + wp->sx + 1;
951 if (right >= wp->window->sx)
952 right = 0;
953 top = wp->yoff;
955 TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
956 if (!window_pane_visible(wp2))
957 continue;
958 if (wp2->xoff != right)
959 continue;
960 if (top >= wp2->yoff && top <= wp2->yoff + wp2->sy)
961 return (wp2);
963 return (NULL);