window.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
  15  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  16  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <sys/types.h>
  20 #include <sys/ioctl.h>
  21
  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>
  34
  35 #include "tmux.h"
  36
  37 /*
  38  * Each window is attached to a number of panes, each of which is a pty. This
  39  * file contains code to handle them.
  40  *
  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.
  46  *
  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.
  49  *
  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.
  54  */
  55
  56 /* Global window list. */
  57 struct windows windows;
  58
  59 void    window_pane_read_callback(struct bufferevent *, void *);
  60 void    window_pane_error_callback(struct bufferevent *, short, void *);
  61
  62 RB_GENERATE(winlinks, winlink, entry, winlink_cmp);
  63
  64 int
  65 winlink_cmp(struct winlink *wl1, struct winlink *wl2)
  66 {
  67         return (wl1->idx - wl2->idx);
  68 }
  69
  70 struct winlink *
  71 winlink_find_by_window(struct winlinks *wwl, struct window *w)
  72 {
  73         struct winlink  *wl;
  74
  75         RB_FOREACH(wl, winlinks, wwl) {
  76                 if (wl->window == w)
  77                         return (wl);
  78         }
  79
  80         return (NULL);
  81 }
  82
  83 struct winlink *
  84 winlink_find_by_index(struct winlinks *wwl, int idx)
  85 {
  86         struct winlink  wl;
  87
  88         if (idx < 0)
  89                 fatalx("bad index");
  90
  91         wl.idx = idx;
  92         return (RB_FIND(winlinks, wwl, &wl));
  93 }
  94
  95 int
  96 winlink_next_index(struct winlinks *wwl, int idx)
  97 {
  98         int     i;
  99
 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);
 110 }
 111
 112 u_int
 113 winlink_count(struct winlinks *wwl)
 114 {
 115         struct winlink  *wl;
 116         u_int            n;
 117
 118         n = 0;
 119         RB_FOREACH(wl, winlinks, wwl)
 120                 n++;
 121
 122         return (n);
 123 }
 124
 125 struct winlink *
 126 winlink_add(struct winlinks *wwl, struct window *w, int idx)
 127 {
 128         struct winlink  *wl;
 129
 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);
 135
 136         wl = xcalloc(1, sizeof *wl);
 137         wl->idx = idx;
 138         wl->window = w;
 139         RB_INSERT(winlinks, wwl, wl);
 140
 141         w->references++;
 142
 143         return (wl);
 144 }
 145
 146 void
 147 winlink_remove(struct winlinks *wwl, struct winlink *wl)
 148 {
 149         struct window   *w = wl->window;
 150
 151         RB_REMOVE(winlinks, wwl, wl);
 152         if (wl->status_text != NULL)
 153                 xfree(wl->status_text);
 154         xfree(wl);
 155
 156         if (w->references == 0)
 157                 fatal("bad reference count");
 158         w->references--;
 159         if (w->references == 0)
 160                 window_destroy(w);
 161 }
 162
 163 struct winlink *
 164 winlink_next(struct winlink *wl)
 165 {
 166         return (RB_NEXT(winlinks, wwl, wl));
 167 }
 168
 169 struct winlink *
 170 winlink_previous(struct winlink *wl)
 171 {
 172         return (RB_PREV(winlinks, wwl, wl));
 173 }
 174
 175 void
 176 winlink_stack_push(struct winlink_stack *stack, struct winlink *wl)
 177 {
 178         if (wl == NULL)
 179                 return;
 180
 181         winlink_stack_remove(stack, wl);
 182         TAILQ_INSERT_HEAD(stack, wl, sentry);
 183 }
 184
 185 void
 186 winlink_stack_remove(struct winlink_stack *stack, struct winlink *wl)
 187 {
 188         struct winlink  *wl2;
 189
 190         if (wl == NULL)
 191                 return;
 192
 193         TAILQ_FOREACH(wl2, stack, sentry) {
 194                 if (wl2 == wl) {
 195                         TAILQ_REMOVE(stack, wl, sentry);
 196                         return;
 197                 }
 198         }
 199 }
 200
 201 int
 202 window_index(struct window *s, u_int *i)
 203 {
 204         for (*i = 0; *i < ARRAY_LENGTH(&windows); (*i)++) {
 205                 if (s == ARRAY_ITEM(&windows, *i))
 206                         return (0);
 207         }
 208         return (-1);
 209 }
 210
 211 struct window *
 212 window_create1(u_int sx, u_int sy)
 213 {
 214         struct window   *w;
 215         u_int            i;
 216
 217         w = xcalloc(1, sizeof *w);
 218         w->name = NULL;
 219         w->flags = 0;
 220
 221         TAILQ_INIT(&w->panes);
 222         w->active = NULL;
 223
 224         w->lastlayout = -1;
 225         w->layout_root = NULL;
 226
 227         w->sx = sx;
 228         w->sy = sy;
 229
 230         queue_window_name(w);
 231
 232         options_init(&w->options, &global_w_options);
 233
 234         for (i = 0; i < ARRAY_LENGTH(&windows); i++) {
 235                 if (ARRAY_ITEM(&windows, i) == NULL) {
 236                         ARRAY_SET(&windows, i, w);
 237                         break;
 238                 }
 239         }
 240         if (i == ARRAY_LENGTH(&windows))
 241                 ARRAY_ADD(&windows, w);
 242         w->references = 0;
 243
 244         return (w);
 245 }
 246
 247 struct window *
 248 window_create(const char *name, const char *cmd, const char *shell,
 249     const char *cwd, struct environ *env, struct termios *tio,
 250     u_int sx, u_int sy, u_int hlimit,char **cause)
 251 {
 252         struct window           *w;
 253         struct window_pane      *wp;
 254
 255         w = window_create1(sx, sy);
 256         wp = window_add_pane(w, hlimit);
 257         layout_init(w);
 258         if (window_pane_spawn(wp, cmd, shell, cwd, env, tio, cause) != 0) {
 259                 window_destroy(w);
 260                 return (NULL);
 261         }
 262         w->active = TAILQ_FIRST(&w->panes);
 263         if (name != NULL) {
 264                 w->name = xstrdup(name);
 265                 options_set_number(&w->options, "automatic-rename", 0);
 266         } else
 267                 w->name = default_window_name(w);
 268         return (w);
 269 }
 270
 271 void
 272 window_destroy(struct window *w)
 273 {
 274         u_int   i;
 275
 276         if (window_index(w, &i) != 0)
 277                 fatalx("index not found");
 278         ARRAY_SET(&windows, i, NULL);
 279         while (!ARRAY_EMPTY(&windows) && ARRAY_LAST(&windows) == NULL)
 280                 ARRAY_TRUNC(&windows, 1);
 281
 282         if (w->layout_root != NULL)
 283                 layout_free(w);
 284
 285         evtimer_del(&w->name_timer);
 286
 287         options_free(&w->options);
 288
 289         window_destroy_panes(w);
 290
 291         if (w->name != NULL)
 292                 xfree(w->name);
 293         xfree(w);
 294 }
 295
 296 void
 297 window_resize(struct window *w, u_int sx, u_int sy)
 298 {
 299         w->sx = sx;
 300         w->sy = sy;
 301 }
 302
 303 void
 304 window_set_active_pane(struct window *w, struct window_pane *wp)
 305 {
 306         w->active = wp;
 307         while (!window_pane_visible(w->active)) {
 308                 w->active = TAILQ_PREV(w->active, window_panes, entry);
 309                 if (w->active == NULL)
 310                         w->active = TAILQ_LAST(&w->panes, window_panes);
 311                 if (w->active == wp)
 312                         return;
 313         }
 314 }
 315
 316 void
 317 window_set_active_at(struct window *w, u_int x, u_int y)
 318 {
 319         struct window_pane      *wp;
 320
 321         TAILQ_FOREACH(wp, &w->panes, entry) {
 322                 if (!window_pane_visible(wp))
 323                         continue;
 324                 if (x < wp->xoff || x >= wp->xoff + wp->sx)
 325                         continue;
 326                 if (y < wp->yoff || y >= wp->yoff + wp->sy)
 327                         continue;
 328                 window_set_active_pane(w, wp);
 329                 break;
 330         }
 331 }
 332
 333 struct window_pane *
 334 window_add_pane(struct window *w, u_int hlimit)
 335 {
 336         struct window_pane      *wp;
 337
 338         wp = window_pane_create(w, w->sx, w->sy, hlimit);
 339         if (TAILQ_EMPTY(&w->panes))
 340                 TAILQ_INSERT_HEAD(&w->panes, wp, entry);
 341         else
 342                 TAILQ_INSERT_AFTER(&w->panes, w->active, wp, entry);
 343         return (wp);
 344 }
 345
 346 void
 347 window_remove_pane(struct window *w, struct window_pane *wp)
 348 {
 349         w->active = TAILQ_PREV(wp, window_panes, entry);
 350         if (w->active == NULL)
 351                 w->active = TAILQ_NEXT(wp, entry);
 352
 353         TAILQ_REMOVE(&w->panes, wp, entry);
 354         window_pane_destroy(wp);
 355 }
 356
 357 struct window_pane *
 358 window_pane_at_index(struct window *w, u_int idx)
 359 {
 360         struct window_pane      *wp;
 361         u_int                    n;
 362
 363         n = 0;
 364         TAILQ_FOREACH(wp, &w->panes, entry) {
 365                 if (n == idx)
 366                         return (wp);
 367                 n++;
 368         }
 369         return (NULL);
 370 }
 371
 372 u_int
 373 window_pane_index(struct window *w, struct window_pane *wp)
 374 {
 375         struct window_pane      *wq;
 376         u_int                    n;
 377
 378         n = 0;
 379         TAILQ_FOREACH(wq, &w->panes, entry) {
 380                 if (wp == wq)
 381                         break;
 382                 n++;
 383         }
 384         return (n);
 385 }
 386
 387 u_int
 388 window_count_panes(struct window *w)
 389 {
 390         struct window_pane      *wp;
 391         u_int                    n;
 392
 393         n = 0;
 394         TAILQ_FOREACH(wp, &w->panes, entry)
 395                 n++;
 396         return (n);
 397 }
 398
 399 void
 400 window_destroy_panes(struct window *w)
 401 {
 402         struct window_pane      *wp;
 403
 404         while (!TAILQ_EMPTY(&w->panes)) {
 405                 wp = TAILQ_FIRST(&w->panes);
 406                 TAILQ_REMOVE(&w->panes, wp, entry);
 407                 window_pane_destroy(wp);
 408         }
 409 }
 410
 411 struct window_pane *
 412 window_pane_create(struct window *w, u_int sx, u_int sy, u_int hlimit)
 413 {
 414         struct window_pane      *wp;
 415
 416         wp = xcalloc(1, sizeof *wp);
 417         wp->window = w;
 418
 419         wp->cmd = NULL;
 420         wp->shell = NULL;
 421         wp->cwd = NULL;
 422
 423         wp->fd = -1;
 424         wp->event = NULL;
 425
 426         wp->mode = NULL;
 427
 428         wp->layout_cell = NULL;
 429
 430         wp->xoff = 0;
 431         wp->yoff = 0;
 432
 433         wp->sx = sx;
 434         wp->sy = sy;
 435
 436         wp->pipe_fd = -1;
 437         wp->pipe_off = 0;
 438         wp->pipe_event = NULL;
 439
 440         wp->saved_grid = NULL;
 441
 442         screen_init(&wp->base, sx, sy, hlimit);
 443         wp->screen = &wp->base;
 444
 445         input_init(wp);
 446
 447         return (wp);
 448 }
 449
 450 void
 451 window_pane_destroy(struct window_pane *wp)
 452 {
 453         if (wp->fd != -1) {
 454                 close(wp->fd);
 455                 bufferevent_free(wp->event);
 456         }
 457
 458         input_free(wp);
 459
 460         window_pane_reset_mode(wp);
 461         screen_free(&wp->base);
 462         if (wp->saved_grid != NULL)
 463                 grid_destroy(wp->saved_grid);
 464
 465         if (wp->pipe_fd != -1) {
 466                 close(wp->pipe_fd);
 467                 bufferevent_free(wp->pipe_event);
 468         }
 469
 470         if (wp->cwd != NULL)
 471                 xfree(wp->cwd);
 472         if (wp->shell != NULL)
 473                 xfree(wp->shell);
 474         if (wp->cmd != NULL)
 475                 xfree(wp->cmd);
 476         xfree(wp);
 477 }
 478
 479 int
 480 window_pane_spawn(struct window_pane *wp, const char *cmd, const char *shell,
 481     const char *cwd, struct environ *env, struct termios *tio, char **cause)
 482 {
 483         struct winsize   ws;
 484         int              mode;
 485         char            *argv0;
 486         const char      *ptr;
 487         struct termios   tio2;
 488
 489         if (wp->fd != -1) {
 490                 close(wp->fd);
 491                 bufferevent_free(wp->event);
 492         }
 493         if (cmd != NULL) {
 494                 if (wp->cmd != NULL)
 495                         xfree(wp->cmd);
 496                 wp->cmd = xstrdup(cmd);
 497         }
 498         if (shell != NULL) {
 499                 if (wp->shell != NULL)
 500                         xfree(wp->shell);
 501                 wp->shell = xstrdup(shell);
 502         }
 503         if (cwd != NULL) {
 504                 if (wp->cwd != NULL)
 505                         xfree(wp->cwd);
 506                 wp->cwd = xstrdup(cwd);
 507         }
 508
 509         memset(&ws, 0, sizeof ws);
 510         ws.ws_col = screen_size_x(&wp->base);
 511         ws.ws_row = screen_size_y(&wp->base);
 512
 513         switch (wp->pid = forkpty(&wp->fd, wp->tty, NULL, &ws)) {
 514         case -1:
 515                 wp->fd = -1;
 516                 xasprintf(cause, "%s: %s", cmd, strerror(errno));
 517                 return (-1);
 518         case 0:
 519                 if (chdir(wp->cwd) != 0)
 520                         chdir("/");
 521
 522                 if (tcgetattr(STDIN_FILENO, &tio2) != 0)
 523                         fatal("tcgetattr failed");
 524                 if (tio != NULL)
 525                         memcpy(tio2.c_cc, tio->c_cc, sizeof tio2.c_cc);
 526                 tio2.c_cc[VERASE] = '\177';
 527                 if (tcsetattr(STDIN_FILENO, TCSANOW, &tio2) != 0)
 528                         fatal("tcgetattr failed");
 529
 530                 environ_push(env);
 531
 532                 clear_signals();
 533                 log_close();
 534
 535                 if (*wp->cmd != '\0') {
 536                         /* Set SHELL but only if it is currently not useful. */
 537                         shell = getenv("SHELL");
 538                         if (shell == NULL || *shell == '\0' || areshell(shell))
 539                                 setenv("SHELL", wp->shell, 1);
 540
 541                         execl(_PATH_BSHELL, "sh", "-c", wp->cmd, (char *) NULL);
 542                         fatal("execl failed");
 543                 }
 544
 545                 /* No command; fork a login shell. */
 546                 ptr = strrchr(wp->shell, '/');
 547                 if (ptr != NULL && *(ptr + 1) != '\0')
 548                         xasprintf(&argv0, "-%s", ptr + 1);
 549                 else
 550                         xasprintf(&argv0, "-%s", wp->shell);
 551                 setenv("SHELL", wp->shell, 1);
 552                 execl(wp->shell, argv0, (char *) NULL);
 553                 fatal("execl failed");
 554         }
 555
 556         if ((mode = fcntl(wp->fd, F_GETFL)) == -1)
 557                 fatal("fcntl failed");
 558         if (fcntl(wp->fd, F_SETFL, mode|O_NONBLOCK) == -1)
 559                 fatal("fcntl failed");
 560         if (fcntl(wp->fd, F_SETFD, FD_CLOEXEC) == -1)
 561                 fatal("fcntl failed");
 562         wp->event = bufferevent_new(wp->fd,
 563             window_pane_read_callback, NULL, window_pane_error_callback, wp);
 564         bufferevent_enable(wp->event, EV_READ|EV_WRITE);
 565
 566         return (0);
 567 }
 568
 569 /* ARGSUSED */
 570 void
 571 window_pane_read_callback(unused struct bufferevent *bufev, void *data)
 572 {
 573         struct window_pane     *wp = data;
 574         char                   *new_data;
 575         size_t                  new_size;
 576
 577         new_size = EVBUFFER_LENGTH(wp->event->input) - wp->pipe_off;
 578         if (wp->pipe_fd != -1 && new_size > 0) {
 579                 new_data = EVBUFFER_DATA(wp->event->input);
 580                 bufferevent_write(wp->pipe_event, new_data, new_size);
 581         }
 582
 583         input_parse(wp);
 584
 585         wp->pipe_off = EVBUFFER_LENGTH(wp->event->input);
 586 }
 587
 588 /* ARGSUSED */
 589 void
 590 window_pane_error_callback(
 591     unused struct bufferevent *bufev, unused short what, void *data)
 592 {
 593         struct window_pane *wp = data;
 594
 595         server_destroy_pane(wp);
 596 }
 597
 598 void
 599 window_pane_resize(struct window_pane *wp, u_int sx, u_int sy)
 600 {
 601         struct winsize  ws;
 602
 603         if (sx == wp->sx && sy == wp->sy)
 604                 return;
 605         wp->sx = sx;
 606         wp->sy = sy;
 607
 608         memset(&ws, 0, sizeof ws);
 609         ws.ws_col = sx;
 610         ws.ws_row = sy;
 611
 612         screen_resize(&wp->base, sx, sy);
 613         if (wp->mode != NULL)
 614                 wp->mode->resize(wp, sx, sy);
 615
 616         if (wp->fd != -1 && ioctl(wp->fd, TIOCSWINSZ, &ws) == -1)
 617                 fatal("ioctl failed");
 618 }
 619
 620 /*
 621  * Enter alternative screen mode. A copy of the visible screen is saved and the
 622  * history is not updated
 623  */
 624 void
 625 window_pane_alternate_on(struct window_pane *wp, struct grid_cell *gc)
 626 {
 627         struct screen   *s = &wp->base;
 628         u_int            sx, sy;
 629
 630         if (wp->saved_grid != NULL)
 631                 return;
 632         if (!options_get_number(&wp->window->options, "alternate-screen"))
 633                 return;
 634         sx = screen_size_x(s);
 635         sy = screen_size_y(s);
 636
 637         wp->saved_grid = grid_create(sx, sy, 0);
 638         grid_duplicate_lines(wp->saved_grid, 0, s->grid, screen_hsize(s), sy);
 639         wp->saved_cx = s->cx;
 640         wp->saved_cy = s->cy;
 641         memcpy(&wp->saved_cell, gc, sizeof wp->saved_cell);
 642
 643         grid_view_clear(s->grid, 0, 0, sx, sy);
 644
 645         wp->base.grid->flags &= ~GRID_HISTORY;
 646
 647         wp->flags |= PANE_REDRAW;
 648 }
 649
 650 /* Exit alternate screen mode and restore the copied grid. */
 651 void
 652 window_pane_alternate_off(struct window_pane *wp, struct grid_cell *gc)
 653 {
 654         struct screen   *s = &wp->base;
 655         u_int            sx, sy;
 656
 657         if (wp->saved_grid == NULL)
 658                 return;
 659         if (!options_get_number(&wp->window->options, "alternate-screen"))
 660                 return;
 661         sx = screen_size_x(s);
 662         sy = screen_size_y(s);
 663
 664         /*
 665          * If the current size is bigger, temporarily resize to the old size
 666          * before copying back.
 667          */
 668         if (sy > wp->saved_grid->sy)
 669                 screen_resize(s, sx, wp->saved_grid->sy);
 670
 671         /* Restore the grid, cursor position and cell. */
 672         grid_duplicate_lines(s->grid, screen_hsize(s), wp->saved_grid, 0, sy);
 673         s->cx = wp->saved_cx;
 674         if (s->cx > screen_size_x(s) - 1)
 675                 s->cx = screen_size_x(s) - 1;
 676         s->cy = wp->saved_cy;
 677         if (s->cy > screen_size_y(s) - 1)
 678                 s->cy = screen_size_y(s) - 1;
 679         memcpy(gc, &wp->saved_cell, sizeof *gc);
 680
 681         /*
 682          * Turn history back on (so resize can use it) and then resize back to
 683          * the current size.
 684          */
 685         wp->base.grid->flags |= GRID_HISTORY;
 686         if (sy > wp->saved_grid->sy)
 687                 screen_resize(s, sx, sy);
 688
 689         grid_destroy(wp->saved_grid);
 690         wp->saved_grid = NULL;
 691
 692         wp->flags |= PANE_REDRAW;
 693 }
 694
 695 int
 696 window_pane_set_mode(struct window_pane *wp, const struct window_mode *mode)
 697 {
 698         struct screen   *s;
 699
 700         if (wp->mode != NULL)
 701                 return (1);
 702         wp->mode = mode;
 703
 704         if ((s = wp->mode->init(wp)) != NULL)
 705                 wp->screen = s;
 706         wp->flags |= PANE_REDRAW;
 707         return (0);
 708 }
 709
 710 void
 711 window_pane_reset_mode(struct window_pane *wp)
 712 {
 713         if (wp->mode == NULL)
 714                 return;
 715
 716         wp->mode->free(wp);
 717         wp->mode = NULL;
 718
 719         wp->screen = &wp->base;
 720         wp->flags |= PANE_REDRAW;
 721 }
 722
 723 void
 724 window_pane_key(struct window_pane *wp, struct session *sess, int key)
 725 {
 726         struct window_pane      *wp2;
 727
 728         if (!window_pane_visible(wp))
 729                 return;
 730
 731         if (wp->mode != NULL) {
 732                 if (wp->mode->key != NULL)
 733                         wp->mode->key(wp, sess, key);
 734                 return;
 735         }
 736
 737         if (wp->fd == -1)
 738                 return;
 739         input_key(wp, key);
 740         if (options_get_number(&wp->window->options, "synchronize-panes")) {
 741                 TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
 742                         if (wp2 == wp || wp2->mode != NULL)
 743                                 continue;
 744                         if (wp2->fd != -1 && window_pane_visible(wp2))
 745                                 input_key(wp2, key);
 746                 }
 747         }
 748 }
 749
 750 void
 751 window_pane_mouse(
 752     struct window_pane *wp, struct session *sess, struct mouse_event *m)
 753 {
 754         if (!window_pane_visible(wp))
 755                 return;
 756
 757         if (m->x < wp->xoff || m->x >= wp->xoff + wp->sx)
 758                 return;
 759         if (m->y < wp->yoff || m->y >= wp->yoff + wp->sy)
 760                 return;
 761         m->x -= wp->xoff;
 762         m->y -= wp->yoff;
 763
 764         if (wp->mode != NULL) {
 765                 if (wp->mode->mouse != NULL)
 766                         wp->mode->mouse(wp, sess, m);
 767         } else if (wp->fd != -1)
 768                 input_mouse(wp, m);
 769 }
 770
 771 int
 772 window_pane_visible(struct window_pane *wp)
 773 {
 774         struct window   *w = wp->window;
 775
 776         if (wp->xoff >= w->sx || wp->yoff >= w->sy)
 777                 return (0);
 778         if (wp->xoff + wp->sx > w->sx || wp->yoff + wp->sy > w->sy)
 779                 return (0);
 780         return (1);
 781 }
 782
 783 char *
 784 window_pane_search(struct window_pane *wp, const char *searchstr, u_int *lineno)
 785 {
 786         struct screen   *s = &wp->base;
 787         char            *newsearchstr, *line, *msg;
 788         u_int            i;
 789
 790         msg = NULL;
 791         xasprintf(&newsearchstr, "*%s*", searchstr);
 792
 793         for (i = 0; i < screen_size_y(s); i++) {
 794                 line = grid_view_string_cells(s->grid, 0, i, screen_size_x(s));
 795                 if (fnmatch(newsearchstr, line, 0) == 0) {
 796                         msg = line;
 797                         if (lineno != NULL)
 798                                 *lineno = i;
 799                         break;
 800                 }
 801                 xfree(line);
 802         }
 803
 804         xfree(newsearchstr);
 805         return (msg);
 806 }
 807
 808 /* Find the pane directly above another. */
 809 struct window_pane *
 810 window_pane_find_up(struct window_pane *wp)
 811 {
 812         struct window_pane     *wp2;
 813         u_int                   left, top;
 814
 815         if (wp == NULL || !window_pane_visible(wp))
 816                 return (NULL);
 817
 818         top = wp->yoff;
 819         if (top == 0)
 820                 top = wp->window->sy + 1;
 821         left = wp->xoff;
 822
 823         TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
 824                 if (!window_pane_visible(wp2))
 825                         continue;
 826                 if (wp2->yoff + wp2->sy + 1 != top)
 827                         continue;
 828                 if (left >= wp2->xoff && left <= wp2->xoff + wp2->sx)
 829                         return (wp2);
 830         }
 831         return (NULL);
 832 }
 833
 834 /* Find the pane directly below another. */
 835 struct window_pane *
 836 window_pane_find_down(struct window_pane *wp)
 837 {
 838         struct window_pane     *wp2;
 839         u_int                   left, bottom;
 840
 841         if (wp == NULL || !window_pane_visible(wp))
 842                 return (NULL);
 843
 844         bottom = wp->yoff + wp->sy + 1;
 845         if (bottom >= wp->window->sy)
 846                 bottom = 0;
 847         left = wp->xoff;
 848
 849         TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
 850                 if (!window_pane_visible(wp2))
 851                         continue;
 852                 if (wp2->yoff != bottom)
 853                         continue;
 854                 if (left >= wp2->xoff && left <= wp2->xoff + wp2->sx)
 855                         return (wp2);
 856         }
 857         return (NULL);
 858 }
 859
 860 /*
 861  * Find the pane directly to the left of another, adjacent to the left side and
 862  * containing the top edge.
 863  */
 864 struct window_pane *
 865 window_pane_find_left(struct window_pane *wp)
 866 {
 867         struct window_pane     *wp2;
 868         u_int                   left, top;
 869
 870         if (wp == NULL || !window_pane_visible(wp))
 871                 return (NULL);
 872
 873         left = wp->xoff;
 874         if (left == 0)
 875                 left = wp->window->sx + 1;
 876         top = wp->yoff;
 877
 878         TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
 879                 if (!window_pane_visible(wp2))
 880                         continue;
 881                 if (wp2->xoff + wp2->sx + 1 != left)
 882                         continue;
 883                 if (top >= wp2->yoff && top <= wp2->yoff + wp2->sy)
 884                         return (wp2);
 885         }
 886         return (NULL);
 887 }
 888
 889 /*
 890  * Find the pane directly to the right of another, that is adjacent to the
 891  * right edge and including the top edge.
 892  */
 893 struct window_pane *
 894 window_pane_find_right(struct window_pane *wp)
 895 {
 896         struct window_pane     *wp2;
 897         u_int                   right, top;
 898
 899         if (wp == NULL || !window_pane_visible(wp))
 900                 return (NULL);
 901
 902         right = wp->xoff + wp->sx + 1;
 903         if (right >= wp->window->sx)
 904                 right = 0;
 905         top = wp->yoff;
 906
 907         TAILQ_FOREACH(wp2, &wp->window->panes, entry) {
 908                 if (!window_pane_visible(wp2))
 909                         continue;
 910                 if (wp2->xoff != right)
 911                         continue;
 912                 if (top >= wp2->yoff && top <= wp2->yoff + wp2->sy)
 913                         return (wp2);
 914         }
 915         return (NULL);
 916 }