Annotation of embedaddon/tmux/session.c, revision 1.1
1.1 ! misho 1: /* $OpenBSD$ */
! 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/time.h>
! 21:
! 22: #include <string.h>
! 23: #include <stdlib.h>
! 24: #include <unistd.h>
! 25: #include <time.h>
! 26:
! 27: #include "tmux.h"
! 28:
! 29: struct sessions sessions;
! 30: static u_int next_session_id;
! 31: struct session_groups session_groups;
! 32:
! 33: static void session_free(int, short, void *);
! 34:
! 35: static void session_lock_timer(int, short, void *);
! 36:
! 37: static struct winlink *session_next_alert(struct winlink *);
! 38: static struct winlink *session_previous_alert(struct winlink *);
! 39:
! 40: static void session_group_remove(struct session *);
! 41: static u_int session_group_count(struct session_group *);
! 42: static void session_group_synchronize1(struct session *, struct session *);
! 43:
! 44: static u_int session_group_count(struct session_group *);
! 45: static void session_group_synchronize1(struct session *, struct session *);
! 46:
! 47: RB_GENERATE(sessions, session, entry, session_cmp);
! 48:
! 49: int
! 50: session_cmp(struct session *s1, struct session *s2)
! 51: {
! 52: return (strcmp(s1->name, s2->name));
! 53: }
! 54:
! 55: RB_GENERATE(session_groups, session_group, entry, session_group_cmp);
! 56:
! 57: int
! 58: session_group_cmp(struct session_group *s1, struct session_group *s2)
! 59: {
! 60: return (strcmp(s1->name, s2->name));
! 61: }
! 62:
! 63: /*
! 64: * Find if session is still alive. This is true if it is still on the global
! 65: * sessions list.
! 66: */
! 67: int
! 68: session_alive(struct session *s)
! 69: {
! 70: struct session *s_loop;
! 71:
! 72: RB_FOREACH(s_loop, sessions, &sessions) {
! 73: if (s_loop == s)
! 74: return (1);
! 75: }
! 76: return (0);
! 77: }
! 78:
! 79: /* Find session by name. */
! 80: struct session *
! 81: session_find(const char *name)
! 82: {
! 83: struct session s;
! 84:
! 85: s.name = (char *) name;
! 86: return (RB_FIND(sessions, &sessions, &s));
! 87: }
! 88:
! 89: /* Find session by id parsed from a string. */
! 90: struct session *
! 91: session_find_by_id_str(const char *s)
! 92: {
! 93: const char *errstr;
! 94: u_int id;
! 95:
! 96: if (*s != '$')
! 97: return (NULL);
! 98:
! 99: id = strtonum(s + 1, 0, UINT_MAX, &errstr);
! 100: if (errstr != NULL)
! 101: return (NULL);
! 102: return (session_find_by_id(id));
! 103: }
! 104:
! 105: /* Find session by id. */
! 106: struct session *
! 107: session_find_by_id(u_int id)
! 108: {
! 109: struct session *s;
! 110:
! 111: RB_FOREACH(s, sessions, &sessions) {
! 112: if (s->id == id)
! 113: return (s);
! 114: }
! 115: return (NULL);
! 116: }
! 117:
! 118: /* Create a new session. */
! 119: struct session *
! 120: session_create(const char *prefix, const char *name, int argc, char **argv,
! 121: const char *path, const char *cwd, struct environ *env, struct termios *tio,
! 122: int idx, u_int sx, u_int sy, char **cause)
! 123: {
! 124: struct session *s;
! 125: struct winlink *wl;
! 126:
! 127: s = xcalloc(1, sizeof *s);
! 128: s->references = 1;
! 129: s->flags = 0;
! 130:
! 131: s->cwd = xstrdup(cwd);
! 132:
! 133: s->curw = NULL;
! 134: TAILQ_INIT(&s->lastw);
! 135: RB_INIT(&s->windows);
! 136:
! 137: s->environ = environ_create();
! 138: if (env != NULL)
! 139: environ_copy(env, s->environ);
! 140:
! 141: s->options = options_create(global_s_options);
! 142: s->hooks = hooks_create(global_hooks);
! 143:
! 144: status_update_saved(s);
! 145:
! 146: s->tio = NULL;
! 147: if (tio != NULL) {
! 148: s->tio = xmalloc(sizeof *s->tio);
! 149: memcpy(s->tio, tio, sizeof *s->tio);
! 150: }
! 151:
! 152: s->sx = sx;
! 153: s->sy = sy;
! 154:
! 155: if (name != NULL) {
! 156: s->name = xstrdup(name);
! 157: s->id = next_session_id++;
! 158: } else {
! 159: s->name = NULL;
! 160: do {
! 161: s->id = next_session_id++;
! 162: free(s->name);
! 163: if (prefix != NULL)
! 164: xasprintf(&s->name, "%s-%u", prefix, s->id);
! 165: else
! 166: xasprintf(&s->name, "%u", s->id);
! 167: } while (RB_FIND(sessions, &sessions, s) != NULL);
! 168: }
! 169: RB_INSERT(sessions, &sessions, s);
! 170:
! 171: log_debug("new session %s $%u", s->name, s->id);
! 172:
! 173: if (gettimeofday(&s->creation_time, NULL) != 0)
! 174: fatal("gettimeofday failed");
! 175: session_update_activity(s, &s->creation_time);
! 176:
! 177: if (argc >= 0) {
! 178: wl = session_new(s, NULL, argc, argv, path, cwd, idx, cause);
! 179: if (wl == NULL) {
! 180: session_destroy(s);
! 181: return (NULL);
! 182: }
! 183: session_select(s, RB_ROOT(&s->windows)->idx);
! 184: }
! 185:
! 186: log_debug("session %s created", s->name);
! 187:
! 188: return (s);
! 189: }
! 190:
! 191: /* Remove a reference from a session. */
! 192: void
! 193: session_unref(struct session *s)
! 194: {
! 195: log_debug("session %s has %d references", s->name, s->references);
! 196:
! 197: s->references--;
! 198: if (s->references == 0)
! 199: event_once(-1, EV_TIMEOUT, session_free, s, NULL);
! 200: }
! 201:
! 202: /* Free session. */
! 203: static void
! 204: session_free(__unused int fd, __unused short events, void *arg)
! 205: {
! 206: struct session *s = arg;
! 207:
! 208: log_debug("session %s freed (%d references)", s->name, s->references);
! 209:
! 210: if (s->references == 0) {
! 211: environ_free(s->environ);
! 212:
! 213: options_free(s->options);
! 214: hooks_free(s->hooks);
! 215:
! 216: free(s->name);
! 217: free(s);
! 218: }
! 219: }
! 220:
! 221: /* Destroy a session. */
! 222: void
! 223: session_destroy(struct session *s)
! 224: {
! 225: struct winlink *wl;
! 226:
! 227: log_debug("session %s destroyed", s->name);
! 228: s->curw = NULL;
! 229:
! 230: RB_REMOVE(sessions, &sessions, s);
! 231: notify_session("session-closed", s);
! 232:
! 233: free(s->tio);
! 234:
! 235: if (event_initialized(&s->lock_timer))
! 236: event_del(&s->lock_timer);
! 237:
! 238: session_group_remove(s);
! 239:
! 240: while (!TAILQ_EMPTY(&s->lastw))
! 241: winlink_stack_remove(&s->lastw, TAILQ_FIRST(&s->lastw));
! 242: while (!RB_EMPTY(&s->windows)) {
! 243: wl = RB_ROOT(&s->windows);
! 244: notify_session_window("window-unlinked", s, wl->window);
! 245: winlink_remove(&s->windows, wl);
! 246: }
! 247:
! 248: free((void *)s->cwd);
! 249:
! 250: session_unref(s);
! 251: }
! 252:
! 253: /* Check a session name is valid: not empty and no colons or periods. */
! 254: int
! 255: session_check_name(const char *name)
! 256: {
! 257: return (*name != '\0' && name[strcspn(name, ":.")] == '\0');
! 258: }
! 259:
! 260: /* Lock session if it has timed out. */
! 261: static void
! 262: session_lock_timer(__unused int fd, __unused short events, void *arg)
! 263: {
! 264: struct session *s = arg;
! 265:
! 266: if (s->flags & SESSION_UNATTACHED)
! 267: return;
! 268:
! 269: log_debug("session %s locked, activity time %lld", s->name,
! 270: (long long)s->activity_time.tv_sec);
! 271:
! 272: server_lock_session(s);
! 273: recalculate_sizes();
! 274: }
! 275:
! 276: /* Update activity time. */
! 277: void
! 278: session_update_activity(struct session *s, struct timeval *from)
! 279: {
! 280: struct timeval *last = &s->last_activity_time;
! 281: struct timeval tv;
! 282:
! 283: memcpy(last, &s->activity_time, sizeof *last);
! 284: if (from == NULL)
! 285: gettimeofday(&s->activity_time, NULL);
! 286: else
! 287: memcpy(&s->activity_time, from, sizeof s->activity_time);
! 288:
! 289: log_debug("session %s activity %lld.%06d (last %lld.%06d)", s->name,
! 290: (long long)s->activity_time.tv_sec, (int)s->activity_time.tv_usec,
! 291: (long long)last->tv_sec, (int)last->tv_usec);
! 292:
! 293: if (evtimer_initialized(&s->lock_timer))
! 294: evtimer_del(&s->lock_timer);
! 295: else
! 296: evtimer_set(&s->lock_timer, session_lock_timer, s);
! 297:
! 298: if (~s->flags & SESSION_UNATTACHED) {
! 299: timerclear(&tv);
! 300: tv.tv_sec = options_get_number(s->options, "lock-after-time");
! 301: if (tv.tv_sec != 0)
! 302: evtimer_add(&s->lock_timer, &tv);
! 303: }
! 304: }
! 305:
! 306: /* Find the next usable session. */
! 307: struct session *
! 308: session_next_session(struct session *s)
! 309: {
! 310: struct session *s2;
! 311:
! 312: if (RB_EMPTY(&sessions) || !session_alive(s))
! 313: return (NULL);
! 314:
! 315: s2 = RB_NEXT(sessions, &sessions, s);
! 316: if (s2 == NULL)
! 317: s2 = RB_MIN(sessions, &sessions);
! 318: if (s2 == s)
! 319: return (NULL);
! 320: return (s2);
! 321: }
! 322:
! 323: /* Find the previous usable session. */
! 324: struct session *
! 325: session_previous_session(struct session *s)
! 326: {
! 327: struct session *s2;
! 328:
! 329: if (RB_EMPTY(&sessions) || !session_alive(s))
! 330: return (NULL);
! 331:
! 332: s2 = RB_PREV(sessions, &sessions, s);
! 333: if (s2 == NULL)
! 334: s2 = RB_MAX(sessions, &sessions);
! 335: if (s2 == s)
! 336: return (NULL);
! 337: return (s2);
! 338: }
! 339:
! 340: /* Create a new window on a session. */
! 341: struct winlink *
! 342: session_new(struct session *s, const char *name, int argc, char **argv,
! 343: const char *path, const char *cwd, int idx, char **cause)
! 344: {
! 345: struct window *w;
! 346: struct winlink *wl;
! 347: struct environ *env;
! 348: const char *shell;
! 349: u_int hlimit;
! 350:
! 351: if ((wl = winlink_add(&s->windows, idx)) == NULL) {
! 352: xasprintf(cause, "index in use: %d", idx);
! 353: return (NULL);
! 354: }
! 355: wl->session = s;
! 356:
! 357: shell = options_get_string(s->options, "default-shell");
! 358: if (*shell == '\0' || areshell(shell))
! 359: shell = _PATH_BSHELL;
! 360:
! 361: hlimit = options_get_number(s->options, "history-limit");
! 362: env = environ_for_session(s);
! 363: w = window_create_spawn(name, argc, argv, path, shell, cwd, env, s->tio,
! 364: s->sx, s->sy, hlimit, cause);
! 365: if (w == NULL) {
! 366: winlink_remove(&s->windows, wl);
! 367: environ_free(env);
! 368: return (NULL);
! 369: }
! 370: winlink_set_window(wl, w);
! 371: environ_free(env);
! 372: notify_session_window("window-linked", s, w);
! 373:
! 374: session_group_synchronize_from(s);
! 375: return (wl);
! 376: }
! 377:
! 378: /* Attach a window to a session. */
! 379: struct winlink *
! 380: session_attach(struct session *s, struct window *w, int idx, char **cause)
! 381: {
! 382: struct winlink *wl;
! 383:
! 384: if ((wl = winlink_add(&s->windows, idx)) == NULL) {
! 385: xasprintf(cause, "index in use: %d", idx);
! 386: return (NULL);
! 387: }
! 388: wl->session = s;
! 389: winlink_set_window(wl, w);
! 390: notify_session_window("window-linked", s, w);
! 391:
! 392: session_group_synchronize_from(s);
! 393: return (wl);
! 394: }
! 395:
! 396: /* Detach a window from a session. */
! 397: int
! 398: session_detach(struct session *s, struct winlink *wl)
! 399: {
! 400: if (s->curw == wl &&
! 401: session_last(s) != 0 &&
! 402: session_previous(s, 0) != 0)
! 403: session_next(s, 0);
! 404:
! 405: wl->flags &= ~WINLINK_ALERTFLAGS;
! 406: notify_session_window("window-unlinked", s, wl->window);
! 407: winlink_stack_remove(&s->lastw, wl);
! 408: winlink_remove(&s->windows, wl);
! 409:
! 410: session_group_synchronize_from(s);
! 411:
! 412: if (RB_EMPTY(&s->windows)) {
! 413: session_destroy(s);
! 414: return (1);
! 415: }
! 416: return (0);
! 417: }
! 418:
! 419: /* Return if session has window. */
! 420: int
! 421: session_has(struct session *s, struct window *w)
! 422: {
! 423: struct winlink *wl;
! 424:
! 425: TAILQ_FOREACH(wl, &w->winlinks, wentry) {
! 426: if (wl->session == s)
! 427: return (1);
! 428: }
! 429: return (0);
! 430: }
! 431:
! 432: /*
! 433: * Return 1 if a window is linked outside this session (not including session
! 434: * groups). The window must be in this session!
! 435: */
! 436: int
! 437: session_is_linked(struct session *s, struct window *w)
! 438: {
! 439: struct session_group *sg;
! 440:
! 441: if ((sg = session_group_contains(s)) != NULL)
! 442: return (w->references != session_group_count(sg));
! 443: return (w->references != 1);
! 444: }
! 445:
! 446: static struct winlink *
! 447: session_next_alert(struct winlink *wl)
! 448: {
! 449: while (wl != NULL) {
! 450: if (wl->flags & WINLINK_ALERTFLAGS)
! 451: break;
! 452: wl = winlink_next(wl);
! 453: }
! 454: return (wl);
! 455: }
! 456:
! 457: /* Move session to next window. */
! 458: int
! 459: session_next(struct session *s, int alert)
! 460: {
! 461: struct winlink *wl;
! 462:
! 463: if (s->curw == NULL)
! 464: return (-1);
! 465:
! 466: wl = winlink_next(s->curw);
! 467: if (alert)
! 468: wl = session_next_alert(wl);
! 469: if (wl == NULL) {
! 470: wl = RB_MIN(winlinks, &s->windows);
! 471: if (alert && ((wl = session_next_alert(wl)) == NULL))
! 472: return (-1);
! 473: }
! 474: return (session_set_current(s, wl));
! 475: }
! 476:
! 477: static struct winlink *
! 478: session_previous_alert(struct winlink *wl)
! 479: {
! 480: while (wl != NULL) {
! 481: if (wl->flags & WINLINK_ALERTFLAGS)
! 482: break;
! 483: wl = winlink_previous(wl);
! 484: }
! 485: return (wl);
! 486: }
! 487:
! 488: /* Move session to previous window. */
! 489: int
! 490: session_previous(struct session *s, int alert)
! 491: {
! 492: struct winlink *wl;
! 493:
! 494: if (s->curw == NULL)
! 495: return (-1);
! 496:
! 497: wl = winlink_previous(s->curw);
! 498: if (alert)
! 499: wl = session_previous_alert(wl);
! 500: if (wl == NULL) {
! 501: wl = RB_MAX(winlinks, &s->windows);
! 502: if (alert && (wl = session_previous_alert(wl)) == NULL)
! 503: return (-1);
! 504: }
! 505: return (session_set_current(s, wl));
! 506: }
! 507:
! 508: /* Move session to specific window. */
! 509: int
! 510: session_select(struct session *s, int idx)
! 511: {
! 512: struct winlink *wl;
! 513:
! 514: wl = winlink_find_by_index(&s->windows, idx);
! 515: return (session_set_current(s, wl));
! 516: }
! 517:
! 518: /* Move session to last used window. */
! 519: int
! 520: session_last(struct session *s)
! 521: {
! 522: struct winlink *wl;
! 523:
! 524: wl = TAILQ_FIRST(&s->lastw);
! 525: if (wl == NULL)
! 526: return (-1);
! 527: if (wl == s->curw)
! 528: return (1);
! 529:
! 530: return (session_set_current(s, wl));
! 531: }
! 532:
! 533: /* Set current winlink to wl .*/
! 534: int
! 535: session_set_current(struct session *s, struct winlink *wl)
! 536: {
! 537: if (wl == NULL)
! 538: return (-1);
! 539: if (wl == s->curw)
! 540: return (1);
! 541:
! 542: winlink_stack_remove(&s->lastw, wl);
! 543: winlink_stack_push(&s->lastw, s->curw);
! 544: s->curw = wl;
! 545: winlink_clear_flags(wl);
! 546: window_update_activity(wl->window);
! 547: return (0);
! 548: }
! 549:
! 550: /* Find the session group containing a session. */
! 551: struct session_group *
! 552: session_group_contains(struct session *target)
! 553: {
! 554: struct session_group *sg;
! 555: struct session *s;
! 556:
! 557: RB_FOREACH(sg, session_groups, &session_groups) {
! 558: TAILQ_FOREACH(s, &sg->sessions, gentry) {
! 559: if (s == target)
! 560: return (sg);
! 561: }
! 562: }
! 563: return (NULL);
! 564: }
! 565:
! 566: /* Find session group by name. */
! 567: struct session_group *
! 568: session_group_find(const char *name)
! 569: {
! 570: struct session_group sg;
! 571:
! 572: sg.name = name;
! 573: return (RB_FIND(session_groups, &session_groups, &sg));
! 574: }
! 575:
! 576: /* Create a new session group. */
! 577: struct session_group *
! 578: session_group_new(const char *name)
! 579: {
! 580: struct session_group *sg;
! 581:
! 582: if ((sg = session_group_find(name)) != NULL)
! 583: return (sg);
! 584:
! 585: sg = xcalloc(1, sizeof *sg);
! 586: sg->name = xstrdup(name);
! 587: TAILQ_INIT(&sg->sessions);
! 588:
! 589: RB_INSERT(session_groups, &session_groups, sg);
! 590: return (sg);
! 591: }
! 592:
! 593: /* Add a session to a session group. */
! 594: void
! 595: session_group_add(struct session_group *sg, struct session *s)
! 596: {
! 597: if (session_group_contains(s) == NULL)
! 598: TAILQ_INSERT_TAIL(&sg->sessions, s, gentry);
! 599: }
! 600:
! 601: /* Remove a session from its group and destroy the group if empty. */
! 602: static void
! 603: session_group_remove(struct session *s)
! 604: {
! 605: struct session_group *sg;
! 606:
! 607: if ((sg = session_group_contains(s)) == NULL)
! 608: return;
! 609: TAILQ_REMOVE(&sg->sessions, s, gentry);
! 610: if (TAILQ_EMPTY(&sg->sessions)) {
! 611: RB_REMOVE(session_groups, &session_groups, sg);
! 612: free(sg);
! 613: }
! 614: }
! 615:
! 616: /* Count number of sessions in session group. */
! 617: static u_int
! 618: session_group_count(struct session_group *sg)
! 619: {
! 620: struct session *s;
! 621: u_int n;
! 622:
! 623: n = 0;
! 624: TAILQ_FOREACH(s, &sg->sessions, gentry)
! 625: n++;
! 626: return (n);
! 627: }
! 628:
! 629: /* Synchronize a session to its session group. */
! 630: void
! 631: session_group_synchronize_to(struct session *s)
! 632: {
! 633: struct session_group *sg;
! 634: struct session *target;
! 635:
! 636: if ((sg = session_group_contains(s)) == NULL)
! 637: return;
! 638:
! 639: target = NULL;
! 640: TAILQ_FOREACH(target, &sg->sessions, gentry) {
! 641: if (target != s)
! 642: break;
! 643: }
! 644: if (target != NULL)
! 645: session_group_synchronize1(target, s);
! 646: }
! 647:
! 648: /* Synchronize a session group to a session. */
! 649: void
! 650: session_group_synchronize_from(struct session *target)
! 651: {
! 652: struct session_group *sg;
! 653: struct session *s;
! 654:
! 655: if ((sg = session_group_contains(target)) == NULL)
! 656: return;
! 657:
! 658: TAILQ_FOREACH(s, &sg->sessions, gentry) {
! 659: if (s != target)
! 660: session_group_synchronize1(target, s);
! 661: }
! 662: }
! 663:
! 664: /*
! 665: * Synchronize a session with a target session. This means destroying all
! 666: * winlinks then recreating them, then updating the current window, last window
! 667: * stack and alerts.
! 668: */
! 669: static void
! 670: session_group_synchronize1(struct session *target, struct session *s)
! 671: {
! 672: struct winlinks old_windows, *ww;
! 673: struct winlink_stack old_lastw;
! 674: struct winlink *wl, *wl2;
! 675:
! 676: /* Don't do anything if the session is empty (it'll be destroyed). */
! 677: ww = &target->windows;
! 678: if (RB_EMPTY(ww))
! 679: return;
! 680:
! 681: /* If the current window has vanished, move to the next now. */
! 682: if (s->curw != NULL &&
! 683: winlink_find_by_index(ww, s->curw->idx) == NULL &&
! 684: session_last(s) != 0 && session_previous(s, 0) != 0)
! 685: session_next(s, 0);
! 686:
! 687: /* Save the old pointer and reset it. */
! 688: memcpy(&old_windows, &s->windows, sizeof old_windows);
! 689: RB_INIT(&s->windows);
! 690:
! 691: /* Link all the windows from the target. */
! 692: RB_FOREACH(wl, winlinks, ww) {
! 693: wl2 = winlink_add(&s->windows, wl->idx);
! 694: wl2->session = s;
! 695: winlink_set_window(wl2, wl->window);
! 696: notify_session_window("window-linked", s, wl2->window);
! 697: wl2->flags |= wl->flags & WINLINK_ALERTFLAGS;
! 698: }
! 699:
! 700: /* Fix up the current window. */
! 701: if (s->curw != NULL)
! 702: s->curw = winlink_find_by_index(&s->windows, s->curw->idx);
! 703: else
! 704: s->curw = winlink_find_by_index(&s->windows, target->curw->idx);
! 705:
! 706: /* Fix up the last window stack. */
! 707: memcpy(&old_lastw, &s->lastw, sizeof old_lastw);
! 708: TAILQ_INIT(&s->lastw);
! 709: TAILQ_FOREACH(wl, &old_lastw, sentry) {
! 710: wl2 = winlink_find_by_index(&s->windows, wl->idx);
! 711: if (wl2 != NULL)
! 712: TAILQ_INSERT_TAIL(&s->lastw, wl2, sentry);
! 713: }
! 714:
! 715: /* Then free the old winlinks list. */
! 716: while (!RB_EMPTY(&old_windows)) {
! 717: wl = RB_ROOT(&old_windows);
! 718: wl2 = winlink_find_by_window_id(&s->windows, wl->window->id);
! 719: if (wl2 == NULL)
! 720: notify_session_window("window-unlinked", s, wl->window);
! 721: winlink_remove(&old_windows, wl);
! 722: }
! 723: }
! 724:
! 725: /* Renumber the windows across winlinks attached to a specific session. */
! 726: void
! 727: session_renumber_windows(struct session *s)
! 728: {
! 729: struct winlink *wl, *wl1, *wl_new;
! 730: struct winlinks old_wins;
! 731: struct winlink_stack old_lastw;
! 732: int new_idx, new_curw_idx;
! 733:
! 734: /* Save and replace old window list. */
! 735: memcpy(&old_wins, &s->windows, sizeof old_wins);
! 736: RB_INIT(&s->windows);
! 737:
! 738: /* Start renumbering from the base-index if it's set. */
! 739: new_idx = options_get_number(s->options, "base-index");
! 740: new_curw_idx = 0;
! 741:
! 742: /* Go through the winlinks and assign new indexes. */
! 743: RB_FOREACH(wl, winlinks, &old_wins) {
! 744: wl_new = winlink_add(&s->windows, new_idx);
! 745: wl_new->session = s;
! 746: winlink_set_window(wl_new, wl->window);
! 747: wl_new->flags |= wl->flags & WINLINK_ALERTFLAGS;
! 748:
! 749: if (wl == s->curw)
! 750: new_curw_idx = wl_new->idx;
! 751:
! 752: new_idx++;
! 753: }
! 754:
! 755: /* Fix the stack of last windows now. */
! 756: memcpy(&old_lastw, &s->lastw, sizeof old_lastw);
! 757: TAILQ_INIT(&s->lastw);
! 758: TAILQ_FOREACH(wl, &old_lastw, sentry) {
! 759: wl_new = winlink_find_by_window(&s->windows, wl->window);
! 760: if (wl_new != NULL)
! 761: TAILQ_INSERT_TAIL(&s->lastw, wl_new, sentry);
! 762: }
! 763:
! 764: /* Set the current window. */
! 765: s->curw = winlink_find_by_index(&s->windows, new_curw_idx);
! 766:
! 767: /* Free the old winlinks (reducing window references too). */
! 768: RB_FOREACH_SAFE(wl, winlinks, &old_wins, wl1)
! 769: winlink_remove(&old_wins, wl);
! 770: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to session.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / tmux