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