Annotation of embedaddon/tmux/layout.c, revision 1.1
1.1 ! misho 1: /* $OpenBSD$ */
! 2:
! 3: /*
! 4: * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
! 5: * Copyright (c) 2016 Stephen Kent <smkent@smkent.net>
! 6: *
! 7: * Permission to use, copy, modify, and distribute this software for any
! 8: * purpose with or without fee is hereby granted, provided that the above
! 9: * copyright notice and this permission notice appear in all copies.
! 10: *
! 11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 15: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
! 16: * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
! 17: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 18: */
! 19:
! 20: #include <sys/types.h>
! 21:
! 22: #include <stdlib.h>
! 23:
! 24: #include "tmux.h"
! 25:
! 26: /*
! 27: * The window layout is a tree of cells each of which can be one of: a
! 28: * left-right container for a list of cells, a top-bottom container for a list
! 29: * of cells, or a container for a window pane.
! 30: *
! 31: * Each window has a pointer to the root of its layout tree (containing its
! 32: * panes), every pane has a pointer back to the cell containing it, and each
! 33: * cell a pointer to its parent cell.
! 34: */
! 35:
! 36: static u_int layout_resize_check(struct window *, struct layout_cell *,
! 37: enum layout_type);
! 38: static int layout_resize_pane_grow(struct window *, struct layout_cell *,
! 39: enum layout_type, int, int);
! 40: static int layout_resize_pane_shrink(struct window *, struct layout_cell *,
! 41: enum layout_type, int);
! 42: static int layout_need_status(struct layout_cell *, int);
! 43: static u_int layout_new_pane_size(struct window *, u_int,
! 44: struct layout_cell *, enum layout_type, u_int, u_int,
! 45: u_int);
! 46: static int layout_set_size_check(struct window *, struct layout_cell *,
! 47: enum layout_type, int);
! 48: static void layout_resize_child_cells(struct window *,
! 49: struct layout_cell *);
! 50:
! 51: struct layout_cell *
! 52: layout_create_cell(struct layout_cell *lcparent)
! 53: {
! 54: struct layout_cell *lc;
! 55:
! 56: lc = xmalloc(sizeof *lc);
! 57: lc->type = LAYOUT_WINDOWPANE;
! 58: lc->parent = lcparent;
! 59:
! 60: TAILQ_INIT(&lc->cells);
! 61:
! 62: lc->sx = UINT_MAX;
! 63: lc->sy = UINT_MAX;
! 64:
! 65: lc->xoff = UINT_MAX;
! 66: lc->yoff = UINT_MAX;
! 67:
! 68: lc->wp = NULL;
! 69:
! 70: return (lc);
! 71: }
! 72:
! 73: void
! 74: layout_free_cell(struct layout_cell *lc)
! 75: {
! 76: struct layout_cell *lcchild;
! 77:
! 78: switch (lc->type) {
! 79: case LAYOUT_LEFTRIGHT:
! 80: case LAYOUT_TOPBOTTOM:
! 81: while (!TAILQ_EMPTY(&lc->cells)) {
! 82: lcchild = TAILQ_FIRST(&lc->cells);
! 83: TAILQ_REMOVE(&lc->cells, lcchild, entry);
! 84: layout_free_cell(lcchild);
! 85: }
! 86: break;
! 87: case LAYOUT_WINDOWPANE:
! 88: if (lc->wp != NULL)
! 89: lc->wp->layout_cell = NULL;
! 90: break;
! 91: }
! 92:
! 93: free(lc);
! 94: }
! 95:
! 96: void
! 97: layout_print_cell(struct layout_cell *lc, const char *hdr, u_int n)
! 98: {
! 99: struct layout_cell *lcchild;
! 100:
! 101: log_debug("%s:%*s%p type %u [parent %p] wp=%p [%u,%u %ux%u]", hdr, n,
! 102: " ", lc, lc->type, lc->parent, lc->wp, lc->xoff, lc->yoff, lc->sx,
! 103: lc->sy);
! 104: switch (lc->type) {
! 105: case LAYOUT_LEFTRIGHT:
! 106: case LAYOUT_TOPBOTTOM:
! 107: TAILQ_FOREACH(lcchild, &lc->cells, entry)
! 108: layout_print_cell(lcchild, hdr, n + 1);
! 109: break;
! 110: case LAYOUT_WINDOWPANE:
! 111: break;
! 112: }
! 113: }
! 114:
! 115: void
! 116: layout_set_size(struct layout_cell *lc, u_int sx, u_int sy, u_int xoff,
! 117: u_int yoff)
! 118: {
! 119: lc->sx = sx;
! 120: lc->sy = sy;
! 121:
! 122: lc->xoff = xoff;
! 123: lc->yoff = yoff;
! 124: }
! 125:
! 126: void
! 127: layout_make_leaf(struct layout_cell *lc, struct window_pane *wp)
! 128: {
! 129: lc->type = LAYOUT_WINDOWPANE;
! 130:
! 131: TAILQ_INIT(&lc->cells);
! 132:
! 133: wp->layout_cell = lc;
! 134: lc->wp = wp;
! 135: }
! 136:
! 137: void
! 138: layout_make_node(struct layout_cell *lc, enum layout_type type)
! 139: {
! 140: if (type == LAYOUT_WINDOWPANE)
! 141: fatalx("bad layout type");
! 142: lc->type = type;
! 143:
! 144: TAILQ_INIT(&lc->cells);
! 145:
! 146: if (lc->wp != NULL)
! 147: lc->wp->layout_cell = NULL;
! 148: lc->wp = NULL;
! 149: }
! 150:
! 151: /* Fix cell offsets based on their sizes. */
! 152: void
! 153: layout_fix_offsets(struct layout_cell *lc)
! 154: {
! 155: struct layout_cell *lcchild;
! 156: u_int xoff, yoff;
! 157:
! 158: if (lc->type == LAYOUT_LEFTRIGHT) {
! 159: xoff = lc->xoff;
! 160: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
! 161: lcchild->xoff = xoff;
! 162: lcchild->yoff = lc->yoff;
! 163: if (lcchild->type != LAYOUT_WINDOWPANE)
! 164: layout_fix_offsets(lcchild);
! 165: xoff += lcchild->sx + 1;
! 166: }
! 167: } else {
! 168: yoff = lc->yoff;
! 169: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
! 170: lcchild->xoff = lc->xoff;
! 171: lcchild->yoff = yoff;
! 172: if (lcchild->type != LAYOUT_WINDOWPANE)
! 173: layout_fix_offsets(lcchild);
! 174: yoff += lcchild->sy + 1;
! 175: }
! 176: }
! 177: }
! 178:
! 179: /*
! 180: * Returns 1 if we need to reserve space for the pane status line. This is the
! 181: * case for the most upper panes only.
! 182: */
! 183: static int
! 184: layout_need_status(struct layout_cell *lc, int at_top)
! 185: {
! 186: struct layout_cell *first_lc;
! 187:
! 188: if (lc->parent) {
! 189: if (lc->parent->type == LAYOUT_LEFTRIGHT)
! 190: return (layout_need_status(lc->parent, at_top));
! 191:
! 192: if (at_top)
! 193: first_lc = TAILQ_FIRST(&lc->parent->cells);
! 194: else
! 195: first_lc = TAILQ_LAST(&lc->parent->cells,layout_cells);
! 196: if (lc == first_lc)
! 197: return (layout_need_status(lc->parent, at_top));
! 198: return (0);
! 199: }
! 200: return (1);
! 201: }
! 202:
! 203: /* Update pane offsets and sizes based on their cells. */
! 204: void
! 205: layout_fix_panes(struct window *w, u_int wsx, u_int wsy)
! 206: {
! 207: struct window_pane *wp;
! 208: struct layout_cell *lc;
! 209: u_int sx, sy;
! 210: int shift, status, at_top;
! 211:
! 212: status = options_get_number(w->options, "pane-border-status");
! 213: at_top = (status == 1);
! 214: TAILQ_FOREACH(wp, &w->panes, entry) {
! 215: if ((lc = wp->layout_cell) == NULL)
! 216: continue;
! 217:
! 218: if (status != 0)
! 219: shift = layout_need_status(lc, at_top);
! 220: else
! 221: shift = 0;
! 222:
! 223: wp->xoff = lc->xoff;
! 224: wp->yoff = lc->yoff;
! 225:
! 226: if (shift && at_top)
! 227: wp->yoff += 1;
! 228:
! 229: /*
! 230: * Layout cells are limited by the smallest size of other cells
! 231: * within the same row or column; if this isn't the case
! 232: * resizing becomes difficult.
! 233: *
! 234: * However, panes do not have to take up their entire cell, so
! 235: * they can be cropped to the window edge if the layout
! 236: * overflows and they are partly visible.
! 237: *
! 238: * This stops cells being hidden unnecessarily.
! 239: */
! 240:
! 241: /*
! 242: * Work out the horizontal size. If the pane is actually
! 243: * outside the window or the entire pane is already visible,
! 244: * don't crop.
! 245: */
! 246: if (lc->xoff >= wsx || lc->xoff + lc->sx < wsx)
! 247: sx = lc->sx;
! 248: else {
! 249: sx = wsx - lc->xoff;
! 250: if (sx < 1)
! 251: sx = lc->sx;
! 252: }
! 253:
! 254: /*
! 255: * Similarly for the vertical size; the minimum vertical size
! 256: * is two because scroll regions cannot be one line.
! 257: */
! 258: if (lc->yoff >= wsy || lc->yoff + lc->sy < wsy)
! 259: sy = lc->sy;
! 260: else {
! 261: sy = wsy - lc->yoff;
! 262: if (sy < 2)
! 263: sy = lc->sy;
! 264: }
! 265:
! 266: if (shift)
! 267: sy -= 1;
! 268:
! 269: window_pane_resize(wp, sx, sy);
! 270: }
! 271: }
! 272:
! 273: /* Count the number of available cells in a layout. */
! 274: u_int
! 275: layout_count_cells(struct layout_cell *lc)
! 276: {
! 277: struct layout_cell *lcchild;
! 278: u_int count;
! 279:
! 280: switch (lc->type) {
! 281: case LAYOUT_WINDOWPANE:
! 282: return (1);
! 283: case LAYOUT_LEFTRIGHT:
! 284: case LAYOUT_TOPBOTTOM:
! 285: count = 0;
! 286: TAILQ_FOREACH(lcchild, &lc->cells, entry)
! 287: count += layout_count_cells(lcchild);
! 288: return (count);
! 289: default:
! 290: fatalx("bad layout type");
! 291: }
! 292: }
! 293:
! 294: /* Calculate how much size is available to be removed from a cell. */
! 295: static u_int
! 296: layout_resize_check(struct window *w, struct layout_cell *lc,
! 297: enum layout_type type)
! 298: {
! 299: struct layout_cell *lcchild;
! 300: u_int available, minimum;
! 301:
! 302: if (lc->type == LAYOUT_WINDOWPANE) {
! 303: /* Space available in this cell only. */
! 304: minimum = PANE_MINIMUM;
! 305: if (type == LAYOUT_LEFTRIGHT)
! 306: available = lc->sx;
! 307: else {
! 308: available = lc->sy;
! 309: minimum += layout_need_status(lc,
! 310: options_get_number(w->options,
! 311: "pane-border-status") == 1);
! 312: }
! 313: if (available > minimum)
! 314: available -= minimum;
! 315: else
! 316: available = 0;
! 317: } else if (lc->type == type) {
! 318: /* Same type: total of available space in all child cells. */
! 319: available = 0;
! 320: TAILQ_FOREACH(lcchild, &lc->cells, entry)
! 321: available += layout_resize_check(w, lcchild, type);
! 322: } else {
! 323: /* Different type: minimum of available space in child cells. */
! 324: minimum = UINT_MAX;
! 325: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
! 326: available = layout_resize_check(w, lcchild, type);
! 327: if (available < minimum)
! 328: minimum = available;
! 329: }
! 330: available = minimum;
! 331: }
! 332:
! 333: return (available);
! 334: }
! 335:
! 336: /*
! 337: * Adjust cell size evenly, including altering its children. This function
! 338: * expects the change to have already been bounded to the space available.
! 339: */
! 340: void
! 341: layout_resize_adjust(struct window *w, struct layout_cell *lc,
! 342: enum layout_type type, int change)
! 343: {
! 344: struct layout_cell *lcchild;
! 345:
! 346: /* Adjust the cell size. */
! 347: if (type == LAYOUT_LEFTRIGHT)
! 348: lc->sx += change;
! 349: else
! 350: lc->sy += change;
! 351:
! 352: /* If this is a leaf cell, that is all that is necessary. */
! 353: if (type == LAYOUT_WINDOWPANE)
! 354: return;
! 355:
! 356: /* Child cell runs in a different direction. */
! 357: if (lc->type != type) {
! 358: TAILQ_FOREACH(lcchild, &lc->cells, entry)
! 359: layout_resize_adjust(w, lcchild, type, change);
! 360: return;
! 361: }
! 362:
! 363: /*
! 364: * Child cell runs in the same direction. Adjust each child equally
! 365: * until no further change is possible.
! 366: */
! 367: while (change != 0) {
! 368: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
! 369: if (change == 0)
! 370: break;
! 371: if (change > 0) {
! 372: layout_resize_adjust(w, lcchild, type, 1);
! 373: change--;
! 374: continue;
! 375: }
! 376: if (layout_resize_check(w, lcchild, type) > 0) {
! 377: layout_resize_adjust(w, lcchild, type, -1);
! 378: change++;
! 379: }
! 380: }
! 381: }
! 382: }
! 383:
! 384: /* Destroy a cell and redistribute the space. */
! 385: void
! 386: layout_destroy_cell(struct window *w, struct layout_cell *lc,
! 387: struct layout_cell **lcroot)
! 388: {
! 389: struct layout_cell *lcother, *lcparent;
! 390:
! 391: /*
! 392: * If no parent, this is the last pane so window close is imminent and
! 393: * there is no need to resize anything.
! 394: */
! 395: lcparent = lc->parent;
! 396: if (lcparent == NULL) {
! 397: layout_free_cell(lc);
! 398: *lcroot = NULL;
! 399: return;
! 400: }
! 401:
! 402: /* Merge the space into the previous or next cell. */
! 403: if (lc == TAILQ_FIRST(&lcparent->cells))
! 404: lcother = TAILQ_NEXT(lc, entry);
! 405: else
! 406: lcother = TAILQ_PREV(lc, layout_cells, entry);
! 407: if (lcparent->type == LAYOUT_LEFTRIGHT)
! 408: layout_resize_adjust(w, lcother, lcparent->type, lc->sx + 1);
! 409: else
! 410: layout_resize_adjust(w, lcother, lcparent->type, lc->sy + 1);
! 411:
! 412: /* Remove this from the parent's list. */
! 413: TAILQ_REMOVE(&lcparent->cells, lc, entry);
! 414: layout_free_cell(lc);
! 415:
! 416: /*
! 417: * If the parent now has one cell, remove the parent from the tree and
! 418: * replace it by that cell.
! 419: */
! 420: lc = TAILQ_FIRST(&lcparent->cells);
! 421: if (TAILQ_NEXT(lc, entry) == NULL) {
! 422: TAILQ_REMOVE(&lcparent->cells, lc, entry);
! 423:
! 424: lc->parent = lcparent->parent;
! 425: if (lc->parent == NULL) {
! 426: lc->xoff = 0; lc->yoff = 0;
! 427: *lcroot = lc;
! 428: } else
! 429: TAILQ_REPLACE(&lc->parent->cells, lcparent, lc, entry);
! 430:
! 431: layout_free_cell(lcparent);
! 432: }
! 433: }
! 434:
! 435: void
! 436: layout_init(struct window *w, struct window_pane *wp)
! 437: {
! 438: struct layout_cell *lc;
! 439:
! 440: lc = w->layout_root = layout_create_cell(NULL);
! 441: layout_set_size(lc, w->sx, w->sy, 0, 0);
! 442: layout_make_leaf(lc, wp);
! 443:
! 444: layout_fix_panes(w, w->sx, w->sy);
! 445: }
! 446:
! 447: void
! 448: layout_free(struct window *w)
! 449: {
! 450: layout_free_cell(w->layout_root);
! 451: }
! 452:
! 453: /* Resize the entire layout after window resize. */
! 454: void
! 455: layout_resize(struct window *w, u_int sx, u_int sy)
! 456: {
! 457: struct layout_cell *lc = w->layout_root;
! 458: int xlimit, ylimit, xchange, ychange;
! 459:
! 460: /*
! 461: * Adjust horizontally. Do not attempt to reduce the layout lower than
! 462: * the minimum (more than the amount returned by layout_resize_check).
! 463: *
! 464: * This can mean that the window size is smaller than the total layout
! 465: * size: redrawing this is handled at a higher level, but it does leave
! 466: * a problem with growing the window size here: if the current size is
! 467: * < the minimum, growing proportionately by adding to each pane is
! 468: * wrong as it would keep the layout size larger than the window size.
! 469: * Instead, spread the difference between the minimum and the new size
! 470: * out proportionately - this should leave the layout fitting the new
! 471: * window size.
! 472: */
! 473: xchange = sx - w->sx;
! 474: xlimit = layout_resize_check(w, lc, LAYOUT_LEFTRIGHT);
! 475: if (xchange < 0 && xchange < -xlimit)
! 476: xchange = -xlimit;
! 477: if (xlimit == 0) {
! 478: if (sx <= lc->sx) /* lc->sx is minimum possible */
! 479: xchange = 0;
! 480: else
! 481: xchange = sx - lc->sx;
! 482: }
! 483: if (xchange != 0)
! 484: layout_resize_adjust(w, lc, LAYOUT_LEFTRIGHT, xchange);
! 485:
! 486: /* Adjust vertically in a similar fashion. */
! 487: ychange = sy - w->sy;
! 488: ylimit = layout_resize_check(w, lc, LAYOUT_TOPBOTTOM);
! 489: if (ychange < 0 && ychange < -ylimit)
! 490: ychange = -ylimit;
! 491: if (ylimit == 0) {
! 492: if (sy <= lc->sy) /* lc->sy is minimum possible */
! 493: ychange = 0;
! 494: else
! 495: ychange = sy - lc->sy;
! 496: }
! 497: if (ychange != 0)
! 498: layout_resize_adjust(w, lc, LAYOUT_TOPBOTTOM, ychange);
! 499:
! 500: /* Fix cell offsets. */
! 501: layout_fix_offsets(lc);
! 502: layout_fix_panes(w, sx, sy);
! 503: }
! 504:
! 505: /* Resize a pane to an absolute size. */
! 506: void
! 507: layout_resize_pane_to(struct window_pane *wp, enum layout_type type,
! 508: u_int new_size)
! 509: {
! 510: struct layout_cell *lc, *lcparent;
! 511: int change, size;
! 512:
! 513: lc = wp->layout_cell;
! 514:
! 515: /* Find next parent of the same type. */
! 516: lcparent = lc->parent;
! 517: while (lcparent != NULL && lcparent->type != type) {
! 518: lc = lcparent;
! 519: lcparent = lc->parent;
! 520: }
! 521: if (lcparent == NULL)
! 522: return;
! 523:
! 524: /* Work out the size adjustment. */
! 525: if (type == LAYOUT_LEFTRIGHT)
! 526: size = lc->sx;
! 527: else
! 528: size = lc->sy;
! 529: if (lc == TAILQ_LAST(&lcparent->cells, layout_cells))
! 530: change = size - new_size;
! 531: else
! 532: change = new_size - size;
! 533:
! 534: /* Resize the pane. */
! 535: layout_resize_pane(wp, type, change, 1);
! 536: }
! 537:
! 538: /* Resize a single pane within the layout. */
! 539: void
! 540: layout_resize_pane(struct window_pane *wp, enum layout_type type, int change,
! 541: int opposite)
! 542: {
! 543: struct window *w = wp->window;
! 544: struct layout_cell *lc, *lcparent;
! 545: int needed, size;
! 546:
! 547: lc = wp->layout_cell;
! 548:
! 549: /* Find next parent of the same type. */
! 550: lcparent = lc->parent;
! 551: while (lcparent != NULL && lcparent->type != type) {
! 552: lc = lcparent;
! 553: lcparent = lc->parent;
! 554: }
! 555: if (lcparent == NULL)
! 556: return;
! 557:
! 558: /* If this is the last cell, move back one. */
! 559: if (lc == TAILQ_LAST(&lcparent->cells, layout_cells))
! 560: lc = TAILQ_PREV(lc, layout_cells, entry);
! 561:
! 562: /* Grow or shrink the cell. */
! 563: needed = change;
! 564: while (needed != 0) {
! 565: if (change > 0) {
! 566: size = layout_resize_pane_grow(w, lc, type, needed,
! 567: opposite);
! 568: needed -= size;
! 569: } else {
! 570: size = layout_resize_pane_shrink(w, lc, type, needed);
! 571: needed += size;
! 572: }
! 573:
! 574: if (size == 0) /* no more change possible */
! 575: break;
! 576: }
! 577:
! 578: /* Fix cell offsets. */
! 579: layout_fix_offsets(wp->window->layout_root);
! 580: layout_fix_panes(wp->window, wp->window->sx, wp->window->sy);
! 581: notify_window("window-layout-changed", wp->window);
! 582: }
! 583:
! 584: /* Helper function to grow pane. */
! 585: static int
! 586: layout_resize_pane_grow(struct window *w, struct layout_cell *lc,
! 587: enum layout_type type, int needed, int opposite)
! 588: {
! 589: struct layout_cell *lcadd, *lcremove;
! 590: u_int size = 0;
! 591:
! 592: /* Growing. Always add to the current cell. */
! 593: lcadd = lc;
! 594:
! 595: /* Look towards the tail for a suitable cell for reduction. */
! 596: lcremove = TAILQ_NEXT(lc, entry);
! 597: while (lcremove != NULL) {
! 598: size = layout_resize_check(w, lcremove, type);
! 599: if (size > 0)
! 600: break;
! 601: lcremove = TAILQ_NEXT(lcremove, entry);
! 602: }
! 603:
! 604: /* If none found, look towards the head. */
! 605: if (opposite && lcremove == NULL) {
! 606: lcremove = TAILQ_PREV(lc, layout_cells, entry);
! 607: while (lcremove != NULL) {
! 608: size = layout_resize_check(w, lcremove, type);
! 609: if (size > 0)
! 610: break;
! 611: lcremove = TAILQ_PREV(lcremove, layout_cells, entry);
! 612: }
! 613: }
! 614: if (lcremove == NULL)
! 615: return (0);
! 616:
! 617: /* Change the cells. */
! 618: if (size > (u_int) needed)
! 619: size = needed;
! 620: layout_resize_adjust(w, lcadd, type, size);
! 621: layout_resize_adjust(w, lcremove, type, -size);
! 622: return (size);
! 623: }
! 624:
! 625: /* Helper function to shrink pane. */
! 626: static int
! 627: layout_resize_pane_shrink(struct window *w, struct layout_cell *lc,
! 628: enum layout_type type, int needed)
! 629: {
! 630: struct layout_cell *lcadd, *lcremove;
! 631: u_int size;
! 632:
! 633: /* Shrinking. Find cell to remove from by walking towards head. */
! 634: lcremove = lc;
! 635: do {
! 636: size = layout_resize_check(w, lcremove, type);
! 637: if (size != 0)
! 638: break;
! 639: lcremove = TAILQ_PREV(lcremove, layout_cells, entry);
! 640: } while (lcremove != NULL);
! 641: if (lcremove == NULL)
! 642: return (0);
! 643:
! 644: /* And add onto the next cell (from the original cell). */
! 645: lcadd = TAILQ_NEXT(lc, entry);
! 646: if (lcadd == NULL)
! 647: return (0);
! 648:
! 649: /* Change the cells. */
! 650: if (size > (u_int) -needed)
! 651: size = -needed;
! 652: layout_resize_adjust(w, lcadd, type, size);
! 653: layout_resize_adjust(w, lcremove, type, -size);
! 654: return (size);
! 655: }
! 656:
! 657: /* Assign window pane to newly split cell. */
! 658: void
! 659: layout_assign_pane(struct layout_cell *lc, struct window_pane *wp)
! 660: {
! 661: layout_make_leaf(lc, wp);
! 662: layout_fix_panes(wp->window, wp->window->sx, wp->window->sy);
! 663: }
! 664:
! 665: /* Calculate the new pane size for resized parent. */
! 666: static u_int
! 667: layout_new_pane_size(struct window *w, u_int previous, struct layout_cell *lc,
! 668: enum layout_type type, u_int size, u_int count_left, u_int size_left)
! 669: {
! 670: u_int new_size, min, max, available;
! 671:
! 672: /* If this is the last cell, it can take all of the remaining size. */
! 673: if (count_left == 1)
! 674: return (size_left);
! 675:
! 676: /* How much is available in this parent? */
! 677: available = layout_resize_check(w, lc, type);
! 678:
! 679: /*
! 680: * Work out the minimum size of this cell and the new size
! 681: * proportionate to the previous size.
! 682: */
! 683: min = (PANE_MINIMUM + 1) * (count_left - 1);
! 684: if (type == LAYOUT_LEFTRIGHT) {
! 685: if (lc->sx - available > min)
! 686: min = lc->sx - available;
! 687: new_size = (lc->sx * size) / previous;
! 688: } else {
! 689: if (lc->sy - available > min)
! 690: min = lc->sy - available;
! 691: new_size = (lc->sy * size) / previous;
! 692: }
! 693:
! 694: /* Check against the maximum and minimum size. */
! 695: max = size_left - min;
! 696: if (new_size > max)
! 697: new_size = max;
! 698: if (new_size < PANE_MINIMUM)
! 699: new_size = PANE_MINIMUM;
! 700: return (new_size);
! 701: }
! 702:
! 703: /* Check if the cell and all its children can be resized to a specific size. */
! 704: static int
! 705: layout_set_size_check(struct window *w, struct layout_cell *lc,
! 706: enum layout_type type, int size)
! 707: {
! 708: struct layout_cell *lcchild;
! 709: u_int new_size, available, previous, count, idx;
! 710:
! 711: /* Cells with no children must just be bigger than minimum. */
! 712: if (lc->type == LAYOUT_WINDOWPANE)
! 713: return (size >= PANE_MINIMUM);
! 714: available = size;
! 715:
! 716: /* Count number of children. */
! 717: count = 0;
! 718: TAILQ_FOREACH(lcchild, &lc->cells, entry)
! 719: count++;
! 720:
! 721: /* Check new size will work for each child. */
! 722: if (lc->type == type) {
! 723: if (type == LAYOUT_LEFTRIGHT)
! 724: previous = lc->sx;
! 725: else
! 726: previous = lc->sy;
! 727:
! 728: idx = 0;
! 729: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
! 730: new_size = layout_new_pane_size(w, previous, lcchild,
! 731: type, size, count - idx, available);
! 732: if (new_size > available)
! 733: return (0);
! 734:
! 735: available -= (new_size + 1);
! 736: if (!layout_set_size_check(w, lcchild, type, new_size))
! 737: return (0);
! 738:
! 739: idx++;
! 740: }
! 741: } else {
! 742: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
! 743: if (lcchild->type == LAYOUT_WINDOWPANE)
! 744: continue;
! 745: if (!layout_set_size_check(w, lcchild, type, size))
! 746: return (0);
! 747: }
! 748: }
! 749:
! 750: return (1);
! 751: }
! 752:
! 753: /* Resize all child cells to fit within the current cell. */
! 754: static void
! 755: layout_resize_child_cells(struct window *w, struct layout_cell *lc)
! 756: {
! 757: struct layout_cell *lcchild;
! 758: u_int previous, available, count, idx;
! 759:
! 760: if (lc->type == LAYOUT_WINDOWPANE)
! 761: return;
! 762:
! 763: /* What is the current size used? */
! 764: count = 0;
! 765: previous = 0;
! 766: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
! 767: count++;
! 768: if (lc->type == LAYOUT_LEFTRIGHT)
! 769: previous += lcchild->sx;
! 770: else if (lc->type == LAYOUT_TOPBOTTOM)
! 771: previous += lcchild->sy;
! 772: }
! 773: previous += (count - 1);
! 774:
! 775: /* And how much is available? */
! 776: available = 0;
! 777: if (lc->type == LAYOUT_LEFTRIGHT)
! 778: available = lc->sx;
! 779: else if (lc->type == LAYOUT_TOPBOTTOM)
! 780: available = lc->sy;
! 781:
! 782: /* Resize children into the new size. */
! 783: idx = 0;
! 784: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
! 785: if (lc->type == LAYOUT_TOPBOTTOM) {
! 786: lcchild->sx = lc->sx;
! 787: lcchild->xoff = lc->xoff;
! 788: } else {
! 789: lcchild->sx = layout_new_pane_size(w, previous, lcchild,
! 790: lc->type, lc->sx, count - idx, available);
! 791: available -= (lcchild->sx + 1);
! 792: }
! 793: if (lc->type == LAYOUT_LEFTRIGHT)
! 794: lcchild->sy = lc->sy;
! 795: else {
! 796: lcchild->sy = layout_new_pane_size(w, previous, lcchild,
! 797: lc->type, lc->sy, count - idx, available);
! 798: available -= (lcchild->sy + 1);
! 799: }
! 800: layout_resize_child_cells(w, lcchild);
! 801: idx++;
! 802: }
! 803: }
! 804:
! 805: /*
! 806: * Split a pane into two. size is a hint, or -1 for default half/half
! 807: * split. This must be followed by layout_assign_pane before much else happens!
! 808: */
! 809: struct layout_cell *
! 810: layout_split_pane(struct window_pane *wp, enum layout_type type, int size,
! 811: int insert_before, int full_size)
! 812: {
! 813: struct layout_cell *lc, *lcparent, *lcnew, *lc1, *lc2;
! 814: u_int sx, sy, xoff, yoff, size1, size2;
! 815: u_int new_size, saved_size, resize_first = 0;
! 816:
! 817: /*
! 818: * If full_size is specified, add a new cell at the top of the window
! 819: * layout. Otherwise, split the cell for the current pane.
! 820: */
! 821: if (full_size)
! 822: lc = wp->window->layout_root;
! 823: else
! 824: lc = wp->layout_cell;
! 825:
! 826: /* Copy the old cell size. */
! 827: sx = lc->sx;
! 828: sy = lc->sy;
! 829: xoff = lc->xoff;
! 830: yoff = lc->yoff;
! 831:
! 832: /* Check there is enough space for the two new panes. */
! 833: switch (type) {
! 834: case LAYOUT_LEFTRIGHT:
! 835: if (sx < PANE_MINIMUM * 2 + 1)
! 836: return (NULL);
! 837: break;
! 838: case LAYOUT_TOPBOTTOM:
! 839: if (sy < PANE_MINIMUM * 2 + 1)
! 840: return (NULL);
! 841: break;
! 842: default:
! 843: fatalx("bad layout type");
! 844: }
! 845:
! 846: /*
! 847: * Calculate new cell sizes. size is the target size or -1 for middle
! 848: * split, size1 is the size of the top/left and size2 the bottom/right.
! 849: */
! 850: if (type == LAYOUT_LEFTRIGHT)
! 851: saved_size = sx;
! 852: else
! 853: saved_size = sy;
! 854: if (size < 0)
! 855: size2 = ((saved_size + 1) / 2) - 1;
! 856: else if (insert_before)
! 857: size2 = saved_size - size - 1;
! 858: else
! 859: size2 = size;
! 860: if (size2 < PANE_MINIMUM)
! 861: size2 = PANE_MINIMUM;
! 862: else if (size2 > saved_size - 2)
! 863: size2 = saved_size - 2;
! 864: size1 = saved_size - 1 - size2;
! 865:
! 866: /* Which size are we using? */
! 867: if (insert_before)
! 868: new_size = size2;
! 869: else
! 870: new_size = size1;
! 871:
! 872: /* Confirm there is enough space for full size pane. */
! 873: if (full_size && !layout_set_size_check(wp->window, lc, type, new_size))
! 874: return (NULL);
! 875:
! 876: if (lc->parent != NULL && lc->parent->type == type) {
! 877: /*
! 878: * If the parent exists and is of the same type as the split,
! 879: * create a new cell and insert it after this one.
! 880: */
! 881: lcparent = lc->parent;
! 882: lcnew = layout_create_cell(lcparent);
! 883: if (insert_before)
! 884: TAILQ_INSERT_BEFORE(lc, lcnew, entry);
! 885: else
! 886: TAILQ_INSERT_AFTER(&lcparent->cells, lc, lcnew, entry);
! 887: } else if (full_size && lc->parent == NULL && lc->type == type) {
! 888: /*
! 889: * If the new full size pane is the same type as the root
! 890: * split, insert the new pane under the existing root cell
! 891: * instead of creating a new root cell. The existing layout
! 892: * must be resized before inserting the new cell.
! 893: */
! 894: if (lc->type == LAYOUT_LEFTRIGHT) {
! 895: lc->sx = new_size;
! 896: layout_resize_child_cells(wp->window, lc);
! 897: lc->sx = saved_size;
! 898: } else if (lc->type == LAYOUT_TOPBOTTOM) {
! 899: lc->sy = new_size;
! 900: layout_resize_child_cells(wp->window, lc);
! 901: lc->sy = saved_size;
! 902: }
! 903: resize_first = 1;
! 904:
! 905: /* Create the new cell. */
! 906: lcnew = layout_create_cell(lc);
! 907: size = saved_size - 1 - new_size;
! 908: if (lc->type == LAYOUT_LEFTRIGHT)
! 909: layout_set_size(lcnew, size, sy, 0, 0);
! 910: else if (lc->type == LAYOUT_TOPBOTTOM)
! 911: layout_set_size(lcnew, sx, size, 0, 0);
! 912: if (insert_before)
! 913: TAILQ_INSERT_HEAD(&lc->cells, lcnew, entry);
! 914: else
! 915: TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
! 916: } else {
! 917: /*
! 918: * Otherwise create a new parent and insert it.
! 919: */
! 920:
! 921: /* Create and insert the replacement parent. */
! 922: lcparent = layout_create_cell(lc->parent);
! 923: layout_make_node(lcparent, type);
! 924: layout_set_size(lcparent, sx, sy, xoff, yoff);
! 925: if (lc->parent == NULL)
! 926: wp->window->layout_root = lcparent;
! 927: else
! 928: TAILQ_REPLACE(&lc->parent->cells, lc, lcparent, entry);
! 929:
! 930: /* Insert the old cell. */
! 931: lc->parent = lcparent;
! 932: TAILQ_INSERT_HEAD(&lcparent->cells, lc, entry);
! 933:
! 934: /* Create the new child cell. */
! 935: lcnew = layout_create_cell(lcparent);
! 936: if (insert_before)
! 937: TAILQ_INSERT_HEAD(&lcparent->cells, lcnew, entry);
! 938: else
! 939: TAILQ_INSERT_TAIL(&lcparent->cells, lcnew, entry);
! 940: }
! 941: if (insert_before) {
! 942: lc1 = lcnew;
! 943: lc2 = lc;
! 944: } else {
! 945: lc1 = lc;
! 946: lc2 = lcnew;
! 947: }
! 948:
! 949: /*
! 950: * Set new cell sizes. size1 is the size of the top/left and size2 the
! 951: * bottom/right.
! 952: */
! 953: if (!resize_first && type == LAYOUT_LEFTRIGHT) {
! 954: layout_set_size(lc1, size1, sy, xoff, yoff);
! 955: layout_set_size(lc2, size2, sy, xoff + lc1->sx + 1, yoff);
! 956: } else if (!resize_first && type == LAYOUT_TOPBOTTOM) {
! 957: layout_set_size(lc1, sx, size1, xoff, yoff);
! 958: layout_set_size(lc2, sx, size2, xoff, yoff + lc1->sy + 1);
! 959: }
! 960: if (full_size) {
! 961: if (!resize_first)
! 962: layout_resize_child_cells(wp->window, lc);
! 963: layout_fix_offsets(wp->window->layout_root);
! 964: } else
! 965: layout_make_leaf(lc, wp);
! 966:
! 967: return (lcnew);
! 968: }
! 969:
! 970: /* Destroy the cell associated with a pane. */
! 971: void
! 972: layout_close_pane(struct window_pane *wp)
! 973: {
! 974: struct window *w = wp->window;
! 975:
! 976: /* Remove the cell. */
! 977: layout_destroy_cell(w, wp->layout_cell, &w->layout_root);
! 978:
! 979: /* Fix pane offsets and sizes. */
! 980: if (w->layout_root != NULL) {
! 981: layout_fix_offsets(w->layout_root);
! 982: layout_fix_panes(w, w->sx, w->sy);
! 983: }
! 984: notify_window("window-layout-changed", w);
! 985: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to layout.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