1 /* $OpenBSD: layout.c,v 1.5 2010/01/07 20:52:18 nicm 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 /* Calculate how much size is available to be removed from a cell. */ 222 u_int 223 layout_resize_check(struct layout_cell *lc, enum layout_type type) 224 { 225 struct layout_cell *lcchild; 226 u_int available, minimum; 227 228 if (lc->type == LAYOUT_WINDOWPANE) { 229 /* Space available in this cell only. */ 230 if (type == LAYOUT_LEFTRIGHT) 231 available = lc->sx; 232 else 233 available = lc->sy; 234 235 if (available > PANE_MINIMUM) 236 available -= PANE_MINIMUM; 237 else 238 available = 0; 239 } else if (lc->type == type) { 240 /* Same type: total of available space in all child cells. */ 241 available = 0; 242 TAILQ_FOREACH(lcchild, &lc->cells, entry) 243 available += layout_resize_check(lcchild, type); 244 } else { 245 /* Different type: minimum of available space in child cells. */ 246 minimum = UINT_MAX; 247 TAILQ_FOREACH(lcchild, &lc->cells, entry) { 248 available = layout_resize_check(lcchild, type); 249 if (available < minimum) 250 minimum = available; 251 } 252 available = minimum; 253 } 254 255 return (available); 256 } 257 258 /* 259 * Adjust cell size evenly, including altering its children. This function 260 * expects the change to have already been bounded to the space available. 261 */ 262 void 263 layout_resize_adjust(struct layout_cell *lc, enum layout_type type, int change) 264 { 265 struct layout_cell *lcchild; 266 267 /* Adjust the cell size. */ 268 if (type == LAYOUT_LEFTRIGHT) 269 lc->sx += change; 270 else 271 lc->sy += change; 272 273 /* If this is a leaf cell, that is all that is necessary. */ 274 if (type == LAYOUT_WINDOWPANE) 275 return; 276 277 /* Child cell runs in a different direction. */ 278 if (lc->type != type) { 279 TAILQ_FOREACH(lcchild, &lc->cells, entry) 280 layout_resize_adjust(lcchild, type, change); 281 return; 282 } 283 284 /* 285 * Child cell runs in the same direction. Adjust each child equally 286 * until no further change is possible. 287 */ 288 while (change != 0) { 289 TAILQ_FOREACH(lcchild, &lc->cells, entry) { 290 if (change == 0) 291 break; 292 if (change > 0) { 293 layout_resize_adjust(lcchild, type, 1); 294 change--; 295 continue; 296 } 297 if (layout_resize_check(lcchild, type) > 0) { 298 layout_resize_adjust(lcchild, type, -1); 299 change++; 300 } 301 } 302 } 303 } 304 305 void 306 layout_init(struct window *w) 307 { 308 struct layout_cell *lc; 309 310 lc = w->layout_root = layout_create_cell(NULL); 311 layout_set_size(lc, w->sx, w->sy, 0, 0); 312 layout_make_leaf(lc, TAILQ_FIRST(&w->panes)); 313 314 layout_fix_panes(w, w->sx, w->sy); 315 } 316 317 void 318 layout_free(struct window *w) 319 { 320 layout_free_cell(w->layout_root); 321 } 322 323 /* Resize the entire layout after window resize. */ 324 void 325 layout_resize(struct window *w, u_int sx, u_int sy) 326 { 327 struct layout_cell *lc = w->layout_root; 328 int xlimit, ylimit, xchange, ychange; 329 330 /* 331 * Adjust horizontally. Do not attempt to reduce the layout lower than 332 * the minimum (more than the amount returned by layout_resize_check). 333 * 334 * This can mean that the window size is smaller than the total layout 335 * size: redrawing this is handled at a higher level, but it does leave 336 * a problem with growing the window size here: if the current size is 337 * < the minimum, growing proportionately by adding to each pane is 338 * wrong as it would keep the layout size larger than the window size. 339 * Instead, spread the difference between the minimum and the new size 340 * out proportionately - this should leave the layout fitting the new 341 * window size. 342 */ 343 xchange = sx - w->sx; 344 xlimit = layout_resize_check(lc, LAYOUT_LEFTRIGHT); 345 if (xchange < 0 && xchange < -xlimit) 346 xchange = -xlimit; 347 if (xlimit == 0) { 348 if (sx <= lc->sx) /* lc->sx is minimum possible */ 349 xchange = 0; 350 else 351 xchange = sx - lc->sx; 352 } 353 if (xchange != 0) 354 layout_resize_adjust(lc, LAYOUT_LEFTRIGHT, xchange); 355 356 /* Adjust vertically in a similar fashion. */ 357 ychange = sy - w->sy; 358 ylimit = layout_resize_check(lc, LAYOUT_TOPBOTTOM); 359 if (ychange < 0 && ychange < -ylimit) 360 ychange = -ylimit; 361 if (ylimit == 0) { 362 if (sy <= lc->sy) /* lc->sy is minimum possible */ 363 ychange = 0; 364 else 365 ychange = sy - lc->sy; 366 } 367 if (ychange != 0) 368 layout_resize_adjust(lc, LAYOUT_TOPBOTTOM, ychange); 369 370 /* Fix cell offsets. */ 371 layout_fix_offsets(lc); 372 layout_fix_panes(w, sx, sy); 373 } 374 375 /* Resize a single pane within the layout. */ 376 void 377 layout_resize_pane(struct window_pane *wp, enum layout_type type, int change) 378 { 379 struct layout_cell *lc, *lcparent; 380 int needed, size; 381 382 lc = wp->layout_cell; 383 384 /* Find next parent of the same type. */ 385 lcparent = lc->parent; 386 while (lcparent != NULL && lcparent->type != type) { 387 lc = lcparent; 388 lcparent = lc->parent; 389 } 390 if (lcparent == NULL) 391 return; 392 393 /* If this is the last cell, move back one. */ 394 if (lc == TAILQ_LAST(&lcparent->cells, layout_cells)) 395 lc = TAILQ_PREV(lc, layout_cells, entry); 396 397 /* Grow or shrink the cell. */ 398 needed = change; 399 while (needed != 0) { 400 if (change > 0) { 401 size = layout_resize_pane_grow(lc, type, needed); 402 needed -= size; 403 } else { 404 size = layout_resize_pane_shrink(lc, type, needed); 405 needed += size; 406 } 407 408 if (size == 0) /* no more change possible */ 409 break; 410 } 411 412 /* Fix cell offsets. */ 413 layout_fix_offsets(wp->window->layout_root); 414 layout_fix_panes(wp->window, wp->window->sx, wp->window->sy); 415 } 416 417 int 418 layout_resize_pane_grow( 419 struct layout_cell *lc, enum layout_type type, int needed) 420 { 421 struct layout_cell *lcadd, *lcremove; 422 u_int size; 423 424 /* Growing. Always add to the current cell. */ 425 lcadd = lc; 426 427 /* Look towards the tail for a suitable cell for reduction. */ 428 lcremove = TAILQ_NEXT(lc, entry); 429 while (lcremove != NULL) { 430 size = layout_resize_check(lcremove, type); 431 if (size > 0) 432 break; 433 lcremove = TAILQ_NEXT(lcremove, entry); 434 } 435 436 /* If none found, look towards the head. */ 437 if (lcremove == NULL) { 438 lcremove = TAILQ_PREV(lc, layout_cells, entry); 439 while (lcremove != NULL) { 440 size = layout_resize_check(lcremove, type); 441 if (size > 0) 442 break; 443 lcremove = TAILQ_PREV(lcremove, layout_cells, entry); 444 } 445 if (lcremove == NULL) 446 return (0); 447 } 448 449 /* Change the cells. */ 450 if (size > (u_int) needed) 451 size = needed; 452 layout_resize_adjust(lcadd, type, size); 453 layout_resize_adjust(lcremove, type, -size); 454 return (size); 455 } 456 457 int 458 layout_resize_pane_shrink( 459 struct layout_cell *lc, enum layout_type type, int needed) 460 { 461 struct layout_cell *lcadd, *lcremove; 462 u_int size; 463 464 /* Shrinking. Find cell to remove from by walking towards head. */ 465 lcremove = lc; 466 do { 467 size = layout_resize_check(lcremove, type); 468 if (size != 0) 469 break; 470 lcremove = TAILQ_PREV(lcremove, layout_cells, entry); 471 } while (lcremove != NULL); 472 if (lcremove == NULL) 473 return (0); 474 475 /* And add onto the next cell (from the original cell). */ 476 lcadd = TAILQ_NEXT(lc, entry); 477 if (lcadd == NULL) 478 return (0); 479 480 /* Change the cells. */ 481 if (size > (u_int) -needed) 482 size = -needed; 483 layout_resize_adjust(lcadd, type, size); 484 layout_resize_adjust(lcremove, type, -size); 485 return (size); 486 } 487 488 /* Assign window pane to newly split cell. */ 489 void 490 layout_assign_pane(struct layout_cell *lc, struct window_pane *wp) 491 { 492 layout_make_leaf(lc, wp); 493 layout_fix_panes(wp->window, wp->window->sx, wp->window->sy); 494 } 495 496 /* 497 * Split a pane into two. size is a hint, or -1 for default half/half 498 * split. This must be followed by layout_assign_pane before much else happens! 499 **/ 500 struct layout_cell * 501 layout_split_pane(struct window_pane *wp, enum layout_type type, int size) 502 { 503 struct layout_cell *lc, *lcparent, *lcnew; 504 u_int sx, sy, xoff, yoff, size1, size2; 505 506 lc = wp->layout_cell; 507 508 /* Copy the old cell size. */ 509 sx = lc->sx; 510 sy = lc->sy; 511 xoff = lc->xoff; 512 yoff = lc->yoff; 513 514 /* Check there is enough space for the two new panes. */ 515 switch (type) { 516 case LAYOUT_LEFTRIGHT: 517 if (sx < PANE_MINIMUM * 2 + 1) 518 return (NULL); 519 break; 520 case LAYOUT_TOPBOTTOM: 521 if (sy < PANE_MINIMUM * 2 + 1) 522 return (NULL); 523 break; 524 default: 525 fatalx("bad layout type"); 526 } 527 528 if (lc->parent != NULL && lc->parent->type == type) { 529 /* 530 * If the parent exists and is of the same type as the split, 531 * create a new cell and insert it after this one. 532 */ 533 534 /* Create the new child cell. */ 535 lcnew = layout_create_cell(lc->parent); 536 TAILQ_INSERT_AFTER(&lc->parent->cells, lc, lcnew, entry); 537 } else { 538 /* 539 * Otherwise create a new parent and insert it. 540 */ 541 542 /* Create and insert the replacement parent. */ 543 lcparent = layout_create_cell(lc->parent); 544 layout_make_node(lcparent, type); 545 layout_set_size(lcparent, sx, sy, xoff, yoff); 546 if (lc->parent == NULL) 547 wp->window->layout_root = lcparent; 548 else 549 TAILQ_REPLACE(&lc->parent->cells, lc, lcparent, entry); 550 551 /* Insert the old cell. */ 552 lc->parent = lcparent; 553 TAILQ_INSERT_HEAD(&lcparent->cells, lc, entry); 554 555 /* Create the new child cell. */ 556 lcnew = layout_create_cell(lcparent); 557 TAILQ_INSERT_TAIL(&lcparent->cells, lcnew, entry); 558 } 559 560 /* Set new cell sizes. size is the target size or -1 for middle split, 561 * size1 is the size of the top/left and size2 the bottom/right. 562 */ 563 switch (type) { 564 case LAYOUT_LEFTRIGHT: 565 if (size < 0) 566 size2 = ((sx + 1) / 2) - 1; 567 else 568 size2 = size; 569 if (size2 < PANE_MINIMUM) 570 size2 = PANE_MINIMUM; 571 else if (size2 > sx - 2) 572 size2 = sx - 2; 573 size1 = sx - 1 - size2; 574 layout_set_size(lc, size1, sy, xoff, yoff); 575 layout_set_size(lcnew, size2, sy, xoff + lc->sx + 1, yoff); 576 break; 577 case LAYOUT_TOPBOTTOM: 578 if (size < 0) 579 size2 = ((sy + 1) / 2) - 1; 580 else 581 size2 = size; 582 if (size2 < PANE_MINIMUM) 583 size2 = PANE_MINIMUM; 584 else if (size2 > sy - 2) 585 size2 = sy - 2; 586 size1 = sy - 1 - size2; 587 layout_set_size(lc, sx, size1, xoff, yoff); 588 layout_set_size(lcnew, sx, size2, xoff, yoff + lc->sy + 1); 589 break; 590 default: 591 fatalx("bad layout type"); 592 } 593 594 /* Assign the panes. */ 595 layout_make_leaf(lc, wp); 596 597 return (lcnew); 598 } 599 600 /* Destroy the layout associated with a pane and redistribute the space. */ 601 void 602 layout_close_pane(struct window_pane *wp) 603 { 604 struct layout_cell *lc, *lcother, *lcparent; 605 606 lc = wp->layout_cell; 607 lcparent = lc->parent; 608 609 /* 610 * If no parent, this is the last pane so window close is imminent and 611 * there is no need to resize anything. 612 */ 613 if (lcparent == NULL) { 614 layout_free_cell(lc); 615 wp->window->layout_root = NULL; 616 return; 617 } 618 619 /* Merge the space into the previous or next cell. */ 620 if (lc == TAILQ_FIRST(&lcparent->cells)) 621 lcother = TAILQ_NEXT(lc, entry); 622 else 623 lcother = TAILQ_PREV(lc, layout_cells, entry); 624 if (lcparent->type == LAYOUT_LEFTRIGHT) 625 layout_resize_adjust(lcother, lcparent->type, lc->sx + 1); 626 else 627 layout_resize_adjust(lcother, lcparent->type, lc->sy + 1); 628 629 /* Remove this from the parent's list. */ 630 TAILQ_REMOVE(&lcparent->cells, lc, entry); 631 layout_free_cell(lc); 632 633 /* 634 * If the parent now has one cell, remove the parent from the tree and 635 * replace it by that cell. 636 */ 637 lc = TAILQ_FIRST(&lcparent->cells); 638 if (TAILQ_NEXT(lc, entry) == NULL) { 639 TAILQ_REMOVE(&lcparent->cells, lc, entry); 640 641 lc->parent = lcparent->parent; 642 if (lc->parent == NULL) { 643 lc->xoff = 0; lc->yoff = 0; 644 wp->window->layout_root = lc; 645 } else 646 TAILQ_REPLACE(&lc->parent->cells, lcparent, lc, entry); 647 648 layout_free_cell(lcparent); 649 } 650 651 /* Fix pane offsets and sizes. */ 652 layout_fix_offsets(wp->window->layout_root); 653 layout_fix_panes(wp->window, wp->window->sx, wp->window->sy); 654 } 655 656