1 /* $Id: layout.c,v 1.1.1.1 2011/03/10 09:15:38 jmmv Exp $ */ 2 3 /* 4 * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER 15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/types.h> 20 21 #include <stdlib.h> 22 23 #include "tmux.h" 24 25 /* 26 * The window layout is a tree of cells each of which can be one of: a 27 * left-right container for a list of cells, a top-bottom container for a list 28 * of cells, or a container for a window pane. 29 * 30 * Each window has a pointer to the root of its layout tree (containing its 31 * panes), every pane has a pointer back to the cell containing it, and each 32 * cell a pointer to its parent cell. 33 */ 34 35 int layout_resize_pane_grow(struct layout_cell *, enum layout_type, int); 36 int layout_resize_pane_shrink(struct layout_cell *, enum layout_type, int); 37 38 struct layout_cell * 39 layout_create_cell(struct layout_cell *lcparent) 40 { 41 struct layout_cell *lc; 42 43 lc = xmalloc(sizeof *lc); 44 lc->type = LAYOUT_WINDOWPANE; 45 lc->parent = lcparent; 46 47 TAILQ_INIT(&lc->cells); 48 49 lc->sx = UINT_MAX; 50 lc->sy = UINT_MAX; 51 52 lc->xoff = UINT_MAX; 53 lc->yoff = UINT_MAX; 54 55 lc->wp = NULL; 56 57 return (lc); 58 } 59 60 void 61 layout_free_cell(struct layout_cell *lc) 62 { 63 struct layout_cell *lcchild; 64 65 switch (lc->type) { 66 case LAYOUT_LEFTRIGHT: 67 case LAYOUT_TOPBOTTOM: 68 while (!TAILQ_EMPTY(&lc->cells)) { 69 lcchild = TAILQ_FIRST(&lc->cells); 70 TAILQ_REMOVE(&lc->cells, lcchild, entry); 71 layout_free_cell(lcchild); 72 } 73 break; 74 case LAYOUT_WINDOWPANE: 75 if (lc->wp != NULL) 76 lc->wp->layout_cell = NULL; 77 break; 78 } 79 80 xfree(lc); 81 } 82 83 void 84 layout_print_cell(struct layout_cell *lc, const char *hdr, u_int n) 85 { 86 struct layout_cell *lcchild; 87 88 log_debug( 89 "%s:%*s%p type %u [parent %p] wp=%p [%u,%u %ux%u]", hdr, n, " ", lc, 90 lc->type, lc->parent, lc->wp, lc->xoff, lc->yoff, lc->sx, lc->sy); 91 switch (lc->type) { 92 case LAYOUT_LEFTRIGHT: 93 case LAYOUT_TOPBOTTOM: 94 TAILQ_FOREACH(lcchild, &lc->cells, entry) 95 layout_print_cell(lcchild, hdr, n + 1); 96 break; 97 case LAYOUT_WINDOWPANE: 98 break; 99 } 100 } 101 102 void 103 layout_set_size( 104 struct layout_cell *lc, u_int sx, u_int sy, u_int xoff, u_int yoff) 105 { 106 lc->sx = sx; 107 lc->sy = sy; 108 109 lc->xoff = xoff; 110 lc->yoff = yoff; 111 } 112 113 void 114 layout_make_leaf(struct layout_cell *lc, struct window_pane *wp) 115 { 116 lc->type = LAYOUT_WINDOWPANE; 117 118 TAILQ_INIT(&lc->cells); 119 120 wp->layout_cell = lc; 121 lc->wp = wp; 122 } 123 124 void 125 layout_make_node(struct layout_cell *lc, enum layout_type type) 126 { 127 if (type == LAYOUT_WINDOWPANE) 128 fatalx("bad layout type"); 129 lc->type = type; 130 131 TAILQ_INIT(&lc->cells); 132 133 if (lc->wp != NULL) 134 lc->wp->layout_cell = NULL; 135 lc->wp = NULL; 136 } 137 138 /* Fix cell offsets based on their sizes. */ 139 void 140 layout_fix_offsets(struct layout_cell *lc) 141 { 142 struct layout_cell *lcchild; 143 u_int xoff, yoff; 144 145 if (lc->type == LAYOUT_LEFTRIGHT) { 146 xoff = lc->xoff; 147 TAILQ_FOREACH(lcchild, &lc->cells, entry) { 148 lcchild->xoff = xoff; 149 lcchild->yoff = lc->yoff; 150 if (lcchild->type != LAYOUT_WINDOWPANE) 151 layout_fix_offsets(lcchild); 152 xoff += lcchild->sx + 1; 153 } 154 } else { 155 yoff = lc->yoff; 156 TAILQ_FOREACH(lcchild, &lc->cells, entry) { 157 lcchild->xoff = lc->xoff; 158 lcchild->yoff = yoff; 159 if (lcchild->type != LAYOUT_WINDOWPANE) 160 layout_fix_offsets(lcchild); 161 yoff += lcchild->sy + 1; 162 } 163 } 164 } 165 166 /* Update pane offsets and sizes based on their cells. */ 167 void 168 layout_fix_panes(struct window *w, u_int wsx, u_int wsy) 169 { 170 struct window_pane *wp; 171 struct layout_cell *lc; 172 u_int sx, sy; 173 174 TAILQ_FOREACH(wp, &w->panes, entry) { 175 if ((lc = wp->layout_cell) == NULL) 176 continue; 177 wp->xoff = lc->xoff; 178 wp->yoff = lc->yoff; 179 180 /* 181 * Layout cells are limited by the smallest size of other cells 182 * within the same row or column; if this isn't the case 183 * resizing becomes difficult. 184 * 185 * However, panes do not have to take up their entire cell, so 186 * they can be cropped to the window edge if the layout 187 * overflows and they are partly visible. 188 * 189 * This stops cells being hidden unnecessarily. 190 */ 191 192 /* 193 * Work out the horizontal size. If the pane is actually 194 * outside the window or the entire pane is already visible, 195 * don't crop. 196 */ 197 if (lc->xoff >= wsx || lc->xoff + lc->sx < wsx) 198 sx = lc->sx; 199 else { 200 sx = wsx - lc->xoff; 201 if (sx < 1) 202 sx = lc->sx; 203 } 204 205 /* 206 * Similarly for the vertical size; the minimum vertical size 207 * is two because scroll regions cannot be one line. 208 */ 209 if (lc->yoff >= wsy || lc->yoff + lc->sy < wsy) 210 sy = lc->sy; 211 else { 212 sy = wsy - lc->yoff; 213 if (sy < 2) 214 sy = lc->sy; 215 } 216 217 window_pane_resize(wp, sx, sy); 218 } 219 } 220 221 /* Count the number of available cells in a layout. */ 222 u_int 223 layout_count_cells(struct layout_cell *lc) 224 { 225 struct layout_cell *lcchild; 226 u_int n; 227 228 switch (lc->type) { 229 case LAYOUT_WINDOWPANE: 230 return (1); 231 case LAYOUT_LEFTRIGHT: 232 case LAYOUT_TOPBOTTOM: 233 n = 0; 234 TAILQ_FOREACH(lcchild, &lc->cells, entry) 235 n += layout_count_cells(lcchild); 236 return (n); 237 default: 238 fatalx("bad layout type"); 239 } 240 } 241 242 /* Calculate how much size is available to be removed from a cell. */ 243 u_int 244 layout_resize_check(struct layout_cell *lc, enum layout_type type) 245 { 246 struct layout_cell *lcchild; 247 u_int available, minimum; 248 249 if (lc->type == LAYOUT_WINDOWPANE) { 250 /* Space available in this cell only. */ 251 if (type == LAYOUT_LEFTRIGHT) 252 available = lc->sx; 253 else 254 available = lc->sy; 255 256 if (available > PANE_MINIMUM) 257 available -= PANE_MINIMUM; 258 else 259 available = 0; 260 } else if (lc->type == type) { 261 /* Same type: total of available space in all child cells. */ 262 available = 0; 263 TAILQ_FOREACH(lcchild, &lc->cells, entry) 264 available += layout_resize_check(lcchild, type); 265 } else { 266 /* Different type: minimum of available space in child cells. */ 267 minimum = UINT_MAX; 268 TAILQ_FOREACH(lcchild, &lc->cells, entry) { 269 available = layout_resize_check(lcchild, type); 270 if (available < minimum) 271 minimum = available; 272 } 273 available = minimum; 274 } 275 276 return (available); 277 } 278 279 /* 280 * Adjust cell size evenly, including altering its children. This function 281 * expects the change to have already been bounded to the space available. 282 */ 283 void 284 layout_resize_adjust(struct layout_cell *lc, enum layout_type type, int change) 285 { 286 struct layout_cell *lcchild; 287 288 /* Adjust the cell size. */ 289 if (type == LAYOUT_LEFTRIGHT) 290 lc->sx += change; 291 else 292 lc->sy += change; 293 294 /* If this is a leaf cell, that is all that is necessary. */ 295 if (type == LAYOUT_WINDOWPANE) 296 return; 297 298 /* Child cell runs in a different direction. */ 299 if (lc->type != type) { 300 TAILQ_FOREACH(lcchild, &lc->cells, entry) 301 layout_resize_adjust(lcchild, type, change); 302 return; 303 } 304 305 /* 306 * Child cell runs in the same direction. Adjust each child equally 307 * until no further change is possible. 308 */ 309 while (change != 0) { 310 TAILQ_FOREACH(lcchild, &lc->cells, entry) { 311 if (change == 0) 312 break; 313 if (change > 0) { 314 layout_resize_adjust(lcchild, type, 1); 315 change--; 316 continue; 317 } 318 if (layout_resize_check(lcchild, type) > 0) { 319 layout_resize_adjust(lcchild, type, -1); 320 change++; 321 } 322 } 323 } 324 } 325 326 /* Destroy a cell and redistribute the space. */ 327 void 328 layout_destroy_cell(struct layout_cell *lc, struct layout_cell **lcroot) 329 { 330 struct layout_cell *lcother, *lcparent; 331 332 /* 333 * If no parent, this is the last pane so window close is imminent and 334 * there is no need to resize anything. 335 */ 336 lcparent = lc->parent; 337 if (lcparent == NULL) { 338 layout_free_cell(lc); 339 *lcroot = NULL; 340 return; 341 } 342 343 /* Merge the space into the previous or next cell. */ 344 if (lc == TAILQ_FIRST(&lcparent->cells)) 345 lcother = TAILQ_NEXT(lc, entry); 346 else 347 lcother = TAILQ_PREV(lc, layout_cells, entry); 348 if (lcparent->type == LAYOUT_LEFTRIGHT) 349 layout_resize_adjust(lcother, lcparent->type, lc->sx + 1); 350 else 351 layout_resize_adjust(lcother, lcparent->type, lc->sy + 1); 352 353 /* Remove this from the parent's list. */ 354 TAILQ_REMOVE(&lcparent->cells, lc, entry); 355 layout_free_cell(lc); 356 357 /* 358 * If the parent now has one cell, remove the parent from the tree and 359 * replace it by that cell. 360 */ 361 lc = TAILQ_FIRST(&lcparent->cells); 362 if (TAILQ_NEXT(lc, entry) == NULL) { 363 TAILQ_REMOVE(&lcparent->cells, lc, entry); 364 365 lc->parent = lcparent->parent; 366 if (lc->parent == NULL) { 367 lc->xoff = 0; lc->yoff = 0; 368 *lcroot = lc; 369 } else 370 TAILQ_REPLACE(&lc->parent->cells, lcparent, lc, entry); 371 372 layout_free_cell(lcparent); 373 } 374 } 375 376 void 377 layout_init(struct window *w) 378 { 379 struct layout_cell *lc; 380 381 lc = w->layout_root = layout_create_cell(NULL); 382 layout_set_size(lc, w->sx, w->sy, 0, 0); 383 layout_make_leaf(lc, TAILQ_FIRST(&w->panes)); 384 385 layout_fix_panes(w, w->sx, w->sy); 386 } 387 388 void 389 layout_free(struct window *w) 390 { 391 layout_free_cell(w->layout_root); 392 } 393 394 /* Resize the entire layout after window resize. */ 395 void 396 layout_resize(struct window *w, u_int sx, u_int sy) 397 { 398 struct layout_cell *lc = w->layout_root; 399 int xlimit, ylimit, xchange, ychange; 400 401 /* 402 * Adjust horizontally. Do not attempt to reduce the layout lower than 403 * the minimum (more than the amount returned by layout_resize_check). 404 * 405 * This can mean that the window size is smaller than the total layout 406 * size: redrawing this is handled at a higher level, but it does leave 407 * a problem with growing the window size here: if the current size is 408 * < the minimum, growing proportionately by adding to each pane is 409 * wrong as it would keep the layout size larger than the window size. 410 * Instead, spread the difference between the minimum and the new size 411 * out proportionately - this should leave the layout fitting the new 412 * window size. 413 */ 414 xchange = sx - w->sx; 415 xlimit = layout_resize_check(lc, LAYOUT_LEFTRIGHT); 416 if (xchange < 0 && xchange < -xlimit) 417 xchange = -xlimit; 418 if (xlimit == 0) { 419 if (sx <= lc->sx) /* lc->sx is minimum possible */ 420 xchange = 0; 421 else 422 xchange = sx - lc->sx; 423 } 424 if (xchange != 0) 425 layout_resize_adjust(lc, LAYOUT_LEFTRIGHT, xchange); 426 427 /* Adjust vertically in a similar fashion. */ 428 ychange = sy - w->sy; 429 ylimit = layout_resize_check(lc, LAYOUT_TOPBOTTOM); 430 if (ychange < 0 && ychange < -ylimit) 431 ychange = -ylimit; 432 if (ylimit == 0) { 433 if (sy <= lc->sy) /* lc->sy is minimum possible */ 434 ychange = 0; 435 else 436 ychange = sy - lc->sy; 437 } 438 if (ychange != 0) 439 layout_resize_adjust(lc, LAYOUT_TOPBOTTOM, ychange); 440 441 /* Fix cell offsets. */ 442 layout_fix_offsets(lc); 443 layout_fix_panes(w, sx, sy); 444 } 445 446 /* Resize a single pane within the layout. */ 447 void 448 layout_resize_pane(struct window_pane *wp, enum layout_type type, int change) 449 { 450 struct layout_cell *lc, *lcparent; 451 int needed, size; 452 453 lc = wp->layout_cell; 454 455 /* Find next parent of the same type. */ 456 lcparent = lc->parent; 457 while (lcparent != NULL && lcparent->type != type) { 458 lc = lcparent; 459 lcparent = lc->parent; 460 } 461 if (lcparent == NULL) 462 return; 463 464 /* If this is the last cell, move back one. */ 465 if (lc == TAILQ_LAST(&lcparent->cells, layout_cells)) 466 lc = TAILQ_PREV(lc, layout_cells, entry); 467 468 /* Grow or shrink the cell. */ 469 needed = change; 470 while (needed != 0) { 471 if (change > 0) { 472 size = layout_resize_pane_grow(lc, type, needed); 473 needed -= size; 474 } else { 475 size = layout_resize_pane_shrink(lc, type, needed); 476 needed += size; 477 } 478 479 if (size == 0) /* no more change possible */ 480 break; 481 } 482 483 /* Fix cell offsets. */ 484 layout_fix_offsets(wp->window->layout_root); 485 layout_fix_panes(wp->window, wp->window->sx, wp->window->sy); 486 } 487 488 int 489 layout_resize_pane_grow( 490 struct layout_cell *lc, enum layout_type type, int needed) 491 { 492 struct layout_cell *lcadd, *lcremove; 493 u_int size; 494 495 /* Growing. Always add to the current cell. */ 496 lcadd = lc; 497 498 /* Look towards the tail for a suitable cell for reduction. */ 499 lcremove = TAILQ_NEXT(lc, entry); 500 while (lcremove != NULL) { 501 size = layout_resize_check(lcremove, type); 502 if (size > 0) 503 break; 504 lcremove = TAILQ_NEXT(lcremove, entry); 505 } 506 507 /* If none found, look towards the head. */ 508 if (lcremove == NULL) { 509 lcremove = TAILQ_PREV(lc, layout_cells, entry); 510 while (lcremove != NULL) { 511 size = layout_resize_check(lcremove, type); 512 if (size > 0) 513 break; 514 lcremove = TAILQ_PREV(lcremove, layout_cells, entry); 515 } 516 if (lcremove == NULL) 517 return (0); 518 } 519 520 /* Change the cells. */ 521 if (size > (u_int) needed) 522 size = needed; 523 layout_resize_adjust(lcadd, type, size); 524 layout_resize_adjust(lcremove, type, -size); 525 return (size); 526 } 527 528 int 529 layout_resize_pane_shrink( 530 struct layout_cell *lc, enum layout_type type, int needed) 531 { 532 struct layout_cell *lcadd, *lcremove; 533 u_int size; 534 535 /* Shrinking. Find cell to remove from by walking towards head. */ 536 lcremove = lc; 537 do { 538 size = layout_resize_check(lcremove, type); 539 if (size != 0) 540 break; 541 lcremove = TAILQ_PREV(lcremove, layout_cells, entry); 542 } while (lcremove != NULL); 543 if (lcremove == NULL) 544 return (0); 545 546 /* And add onto the next cell (from the original cell). */ 547 lcadd = TAILQ_NEXT(lc, entry); 548 if (lcadd == NULL) 549 return (0); 550 551 /* Change the cells. */ 552 if (size > (u_int) -needed) 553 size = -needed; 554 layout_resize_adjust(lcadd, type, size); 555 layout_resize_adjust(lcremove, type, -size); 556 return (size); 557 } 558 559 /* Assign window pane to newly split cell. */ 560 void 561 layout_assign_pane(struct layout_cell *lc, struct window_pane *wp) 562 { 563 layout_make_leaf(lc, wp); 564 layout_fix_panes(wp->window, wp->window->sx, wp->window->sy); 565 } 566 567 /* 568 * Split a pane into two. size is a hint, or -1 for default half/half 569 * split. This must be followed by layout_assign_pane before much else happens! 570 **/ 571 struct layout_cell * 572 layout_split_pane(struct window_pane *wp, enum layout_type type, int size) 573 { 574 struct layout_cell *lc, *lcparent, *lcnew; 575 u_int sx, sy, xoff, yoff, size1, size2; 576 577 lc = wp->layout_cell; 578 579 /* Copy the old cell size. */ 580 sx = lc->sx; 581 sy = lc->sy; 582 xoff = lc->xoff; 583 yoff = lc->yoff; 584 585 /* Check there is enough space for the two new panes. */ 586 switch (type) { 587 case LAYOUT_LEFTRIGHT: 588 if (sx < PANE_MINIMUM * 2 + 1) 589 return (NULL); 590 break; 591 case LAYOUT_TOPBOTTOM: 592 if (sy < PANE_MINIMUM * 2 + 1) 593 return (NULL); 594 break; 595 default: 596 fatalx("bad layout type"); 597 } 598 599 if (lc->parent != NULL && lc->parent->type == type) { 600 /* 601 * If the parent exists and is of the same type as the split, 602 * create a new cell and insert it after this one. 603 */ 604 605 /* Create the new child cell. */ 606 lcnew = layout_create_cell(lc->parent); 607 TAILQ_INSERT_AFTER(&lc->parent->cells, lc, lcnew, entry); 608 } else { 609 /* 610 * Otherwise create a new parent and insert it. 611 */ 612 613 /* Create and insert the replacement parent. */ 614 lcparent = layout_create_cell(lc->parent); 615 layout_make_node(lcparent, type); 616 layout_set_size(lcparent, sx, sy, xoff, yoff); 617 if (lc->parent == NULL) 618 wp->window->layout_root = lcparent; 619 else 620 TAILQ_REPLACE(&lc->parent->cells, lc, lcparent, entry); 621 622 /* Insert the old cell. */ 623 lc->parent = lcparent; 624 TAILQ_INSERT_HEAD(&lcparent->cells, lc, entry); 625 626 /* Create the new child cell. */ 627 lcnew = layout_create_cell(lcparent); 628 TAILQ_INSERT_TAIL(&lcparent->cells, lcnew, entry); 629 } 630 631 /* Set new cell sizes. size is the target size or -1 for middle split, 632 * size1 is the size of the top/left and size2 the bottom/right. 633 */ 634 switch (type) { 635 case LAYOUT_LEFTRIGHT: 636 if (size < 0) 637 size2 = ((sx + 1) / 2) - 1; 638 else 639 size2 = size; 640 if (size2 < PANE_MINIMUM) 641 size2 = PANE_MINIMUM; 642 else if (size2 > sx - 2) 643 size2 = sx - 2; 644 size1 = sx - 1 - size2; 645 layout_set_size(lc, size1, sy, xoff, yoff); 646 layout_set_size(lcnew, size2, sy, xoff + lc->sx + 1, yoff); 647 break; 648 case LAYOUT_TOPBOTTOM: 649 if (size < 0) 650 size2 = ((sy + 1) / 2) - 1; 651 else 652 size2 = size; 653 if (size2 < PANE_MINIMUM) 654 size2 = PANE_MINIMUM; 655 else if (size2 > sy - 2) 656 size2 = sy - 2; 657 size1 = sy - 1 - size2; 658 layout_set_size(lc, sx, size1, xoff, yoff); 659 layout_set_size(lcnew, sx, size2, xoff, yoff + lc->sy + 1); 660 break; 661 default: 662 fatalx("bad layout type"); 663 } 664 665 /* Assign the panes. */ 666 layout_make_leaf(lc, wp); 667 668 return (lcnew); 669 } 670 671 /* Destroy the cell associated with a pane. */ 672 void 673 layout_close_pane(struct window_pane *wp) 674 { 675 /* Remove the cell. */ 676 layout_destroy_cell(wp->layout_cell, &wp->window->layout_root); 677 678 /* Fix pane offsets and sizes. */ 679 if (wp->window->layout_root != NULL) { 680 layout_fix_offsets(wp->window->layout_root); 681 layout_fix_panes(wp->window, wp->window->sx, wp->window->sy); 682 } 683 } 684