diff options
Diffstat (limited to '')
| -rw-r--r-- | layout.c | 1120 |
1 files changed, 1120 insertions, 0 deletions
diff --git a/layout.c b/layout.c new file mode 100644 index 0000000..04a13b0 --- /dev/null +++ b/layout.c @@ -0,0 +1,1120 @@ +/* $OpenBSD$ */ + +/* + * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com> + * Copyright (c) 2016 Stephen Kent <smkent@smkent.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> + +#include <stdlib.h> + +#include "tmux.h" + +/* + * The window layout is a tree of cells each of which can be one of: a + * left-right container for a list of cells, a top-bottom container for a list + * of cells, or a container for a window pane. + * + * Each window has a pointer to the root of its layout tree (containing its + * panes), every pane has a pointer back to the cell containing it, and each + * cell a pointer to its parent cell. + */ + +static u_int layout_resize_check(struct window *, struct layout_cell *, + enum layout_type); +static int layout_resize_pane_grow(struct window *, struct layout_cell *, + enum layout_type, int, int); +static int layout_resize_pane_shrink(struct window *, struct layout_cell *, + enum layout_type, int); +static u_int layout_new_pane_size(struct window *, u_int, + struct layout_cell *, enum layout_type, u_int, u_int, + u_int); +static int layout_set_size_check(struct window *, struct layout_cell *, + enum layout_type, int); +static void layout_resize_child_cells(struct window *, + struct layout_cell *); + +struct layout_cell * +layout_create_cell(struct layout_cell *lcparent) +{ + struct layout_cell *lc; + + lc = xmalloc(sizeof *lc); + lc->type = LAYOUT_WINDOWPANE; + lc->parent = lcparent; + + TAILQ_INIT(&lc->cells); + + lc->sx = UINT_MAX; + lc->sy = UINT_MAX; + + lc->xoff = UINT_MAX; + lc->yoff = UINT_MAX; + + lc->wp = NULL; + + return (lc); +} + +void +layout_free_cell(struct layout_cell *lc) +{ + struct layout_cell *lcchild; + + switch (lc->type) { + case LAYOUT_LEFTRIGHT: + case LAYOUT_TOPBOTTOM: + while (!TAILQ_EMPTY(&lc->cells)) { + lcchild = TAILQ_FIRST(&lc->cells); + TAILQ_REMOVE(&lc->cells, lcchild, entry); + layout_free_cell(lcchild); + } + break; + case LAYOUT_WINDOWPANE: + if (lc->wp != NULL) + lc->wp->layout_cell = NULL; + break; + } + + free(lc); +} + +void +layout_print_cell(struct layout_cell *lc, const char *hdr, u_int n) +{ + struct layout_cell *lcchild; + const char *type; + + switch (lc->type) { + case LAYOUT_LEFTRIGHT: + type = "LEFTRIGHT"; + break; + case LAYOUT_TOPBOTTOM: + type = "TOPBOTTOM"; + break; + case LAYOUT_WINDOWPANE: + type = "WINDOWPANE"; + break; + default: + type = "UNKNOWN"; + break; + } + log_debug("%s:%*s%p type %s [parent %p] wp=%p [%u,%u %ux%u]", hdr, n, + " ", lc, type, lc->parent, lc->wp, lc->xoff, lc->yoff, lc->sx, + lc->sy); + switch (lc->type) { + case LAYOUT_LEFTRIGHT: + case LAYOUT_TOPBOTTOM: + TAILQ_FOREACH(lcchild, &lc->cells, entry) + layout_print_cell(lcchild, hdr, n + 1); + break; + case LAYOUT_WINDOWPANE: + break; + } +} + +struct layout_cell * +layout_search_by_border(struct layout_cell *lc, u_int x, u_int y) +{ + struct layout_cell *lcchild, *last = NULL; + + TAILQ_FOREACH(lcchild, &lc->cells, entry) { + if (x >= lcchild->xoff && x < lcchild->xoff + lcchild->sx && + y >= lcchild->yoff && y < lcchild->yoff + lcchild->sy) { + /* Inside the cell - recurse. */ + return (layout_search_by_border(lcchild, x, y)); + } + + if (last == NULL) { + last = lcchild; + continue; + } + + switch (lc->type) { + case LAYOUT_LEFTRIGHT: + if (x < lcchild->xoff && x >= last->xoff + last->sx) + return (last); + break; + case LAYOUT_TOPBOTTOM: + if (y < lcchild->yoff && y >= last->yoff + last->sy) + return (last); + break; + case LAYOUT_WINDOWPANE: + break; + } + + last = lcchild; + } + + return (NULL); +} + +void +layout_set_size(struct layout_cell *lc, u_int sx, u_int sy, u_int xoff, + u_int yoff) +{ + lc->sx = sx; + lc->sy = sy; + + lc->xoff = xoff; + lc->yoff = yoff; +} + +void +layout_make_leaf(struct layout_cell *lc, struct window_pane *wp) +{ + lc->type = LAYOUT_WINDOWPANE; + + TAILQ_INIT(&lc->cells); + + wp->layout_cell = lc; + lc->wp = wp; +} + +void +layout_make_node(struct layout_cell *lc, enum layout_type type) +{ + if (type == LAYOUT_WINDOWPANE) + fatalx("bad layout type"); + lc->type = type; + + TAILQ_INIT(&lc->cells); + + if (lc->wp != NULL) + lc->wp->layout_cell = NULL; + lc->wp = NULL; +} + +/* Fix cell offsets for a child cell. */ +static void +layout_fix_offsets1(struct layout_cell *lc) +{ + struct layout_cell *lcchild; + u_int xoff, yoff; + + if (lc->type == LAYOUT_LEFTRIGHT) { + xoff = lc->xoff; + TAILQ_FOREACH(lcchild, &lc->cells, entry) { + lcchild->xoff = xoff; + lcchild->yoff = lc->yoff; + if (lcchild->type != LAYOUT_WINDOWPANE) + layout_fix_offsets1(lcchild); + xoff += lcchild->sx + 1; + } + } else { + yoff = lc->yoff; + TAILQ_FOREACH(lcchild, &lc->cells, entry) { + lcchild->xoff = lc->xoff; + lcchild->yoff = yoff; + if (lcchild->type != LAYOUT_WINDOWPANE) + layout_fix_offsets1(lcchild); + yoff += lcchild->sy + 1; + } + } +} + +/* Update cell offsets based on their sizes. */ +void +layout_fix_offsets(struct window *w) +{ + struct layout_cell *lc = w->layout_root; + + lc->xoff = 0; + lc->yoff = 0; + + layout_fix_offsets1(lc); +} + +/* Is this a top cell? */ +static int +layout_cell_is_top(struct window *w, struct layout_cell *lc) +{ + struct layout_cell *next; + + while (lc != w->layout_root) { + next = lc->parent; + if (next->type == LAYOUT_TOPBOTTOM && + lc != TAILQ_FIRST(&next->cells)) + return (0); + lc = next; + } + return (1); +} + +/* Is this a bottom cell? */ +static int +layout_cell_is_bottom(struct window *w, struct layout_cell *lc) +{ + struct layout_cell *next; + + while (lc != w->layout_root) { + next = lc->parent; + if (next->type == LAYOUT_TOPBOTTOM && + lc != TAILQ_LAST(&next->cells, layout_cells)) + return (0); + lc = next; + } + return (1); +} + +/* + * Returns 1 if we need to add an extra line for the pane status line. This is + * the case for the most upper or lower panes only. + */ +static int +layout_add_border(struct window *w, struct layout_cell *lc, int status) +{ + if (status == PANE_STATUS_TOP) + return (layout_cell_is_top(w, lc)); + if (status == PANE_STATUS_BOTTOM) + return (layout_cell_is_bottom(w, lc)); + return (0); +} + +/* Update pane offsets and sizes based on their cells. */ +void +layout_fix_panes(struct window *w, struct window_pane *skip) +{ + struct window_pane *wp; + struct layout_cell *lc; + int status; + + status = options_get_number(w->options, "pane-border-status"); + TAILQ_FOREACH(wp, &w->panes, entry) { + if ((lc = wp->layout_cell) == NULL || wp == skip) + continue; + + wp->xoff = lc->xoff; + wp->yoff = lc->yoff; + + if (layout_add_border(w, lc, status)) { + if (status == PANE_STATUS_TOP) + wp->yoff++; + window_pane_resize(wp, lc->sx, lc->sy - 1); + } else + window_pane_resize(wp, lc->sx, lc->sy); + } +} + +/* Count the number of available cells in a layout. */ +u_int +layout_count_cells(struct layout_cell *lc) +{ + struct layout_cell *lcchild; + u_int count; + + switch (lc->type) { + case LAYOUT_WINDOWPANE: + return (1); + case LAYOUT_LEFTRIGHT: + case LAYOUT_TOPBOTTOM: + count = 0; + TAILQ_FOREACH(lcchild, &lc->cells, entry) + count += layout_count_cells(lcchild); + return (count); + default: + fatalx("bad layout type"); + } +} + +/* Calculate how much size is available to be removed from a cell. */ +static u_int +layout_resize_check(struct window *w, struct layout_cell *lc, + enum layout_type type) +{ + struct layout_cell *lcchild; + u_int available, minimum; + int status; + + status = options_get_number(w->options, "pane-border-status"); + if (lc->type == LAYOUT_WINDOWPANE) { + /* Space available in this cell only. */ + if (type == LAYOUT_LEFTRIGHT) { + available = lc->sx; + minimum = PANE_MINIMUM; + } else { + available = lc->sy; + if (layout_add_border(w, lc, status)) + minimum = PANE_MINIMUM + 1; + else + minimum = PANE_MINIMUM; + } + if (available > minimum) + available -= minimum; + else + available = 0; + } else if (lc->type == type) { + /* Same type: total of available space in all child cells. */ + available = 0; + TAILQ_FOREACH(lcchild, &lc->cells, entry) + available += layout_resize_check(w, lcchild, type); + } else { + /* Different type: minimum of available space in child cells. */ + minimum = UINT_MAX; + TAILQ_FOREACH(lcchild, &lc->cells, entry) { + available = layout_resize_check(w, lcchild, type); + if (available < minimum) + minimum = available; + } + available = minimum; + } + + return (available); +} + +/* + * Adjust cell size evenly, including altering its children. This function + * expects the change to have already been bounded to the space available. + */ +void +layout_resize_adjust(struct window *w, struct layout_cell *lc, + enum layout_type type, int change) +{ + struct layout_cell *lcchild; + + /* Adjust the cell size. */ + if (type == LAYOUT_LEFTRIGHT) + lc->sx += change; + else + lc->sy += change; + + /* If this is a leaf cell, that is all that is necessary. */ + if (type == LAYOUT_WINDOWPANE) + return; + + /* Child cell runs in a different direction. */ + if (lc->type != type) { + TAILQ_FOREACH(lcchild, &lc->cells, entry) + layout_resize_adjust(w, lcchild, type, change); + return; + } + + /* + * Child cell runs in the same direction. Adjust each child equally + * until no further change is possible. + */ + while (change != 0) { + TAILQ_FOREACH(lcchild, &lc->cells, entry) { + if (change == 0) + break; + if (change > 0) { + layout_resize_adjust(w, lcchild, type, 1); + change--; + continue; + } + if (layout_resize_check(w, lcchild, type) > 0) { + layout_resize_adjust(w, lcchild, type, -1); + change++; + } + } + } +} + +/* Destroy a cell and redistribute the space. */ +void +layout_destroy_cell(struct window *w, struct layout_cell *lc, + struct layout_cell **lcroot) +{ + struct layout_cell *lcother, *lcparent; + + /* + * If no parent, this is the last pane so window close is imminent and + * there is no need to resize anything. + */ + lcparent = lc->parent; + if (lcparent == NULL) { + layout_free_cell(lc); + *lcroot = NULL; + return; + } + + /* Merge the space into the previous or next cell. */ + if (lc == TAILQ_FIRST(&lcparent->cells)) + lcother = TAILQ_NEXT(lc, entry); + else + lcother = TAILQ_PREV(lc, layout_cells, entry); + if (lcother != NULL && lcparent->type == LAYOUT_LEFTRIGHT) + layout_resize_adjust(w, lcother, lcparent->type, lc->sx + 1); + else if (lcother != NULL) + layout_resize_adjust(w, lcother, lcparent->type, lc->sy + 1); + + /* Remove this from the parent's list. */ + TAILQ_REMOVE(&lcparent->cells, lc, entry); + layout_free_cell(lc); + + /* + * If the parent now has one cell, remove the parent from the tree and + * replace it by that cell. + */ + lc = TAILQ_FIRST(&lcparent->cells); + if (TAILQ_NEXT(lc, entry) == NULL) { + TAILQ_REMOVE(&lcparent->cells, lc, entry); + + lc->parent = lcparent->parent; + if (lc->parent == NULL) { + lc->xoff = 0; lc->yoff = 0; + *lcroot = lc; + } else + TAILQ_REPLACE(&lc->parent->cells, lcparent, lc, entry); + + layout_free_cell(lcparent); + } +} + +void +layout_init(struct window *w, struct window_pane *wp) +{ + struct layout_cell *lc; + + lc = w->layout_root = layout_create_cell(NULL); + layout_set_size(lc, w->sx, w->sy, 0, 0); + layout_make_leaf(lc, wp); + layout_fix_panes(w, NULL); +} + +void +layout_free(struct window *w) +{ + layout_free_cell(w->layout_root); +} + +/* Resize the entire layout after window resize. */ +void +layout_resize(struct window *w, u_int sx, u_int sy) +{ + struct layout_cell *lc = w->layout_root; + int xlimit, ylimit, xchange, ychange; + + /* + * Adjust horizontally. Do not attempt to reduce the layout lower than + * the minimum (more than the amount returned by layout_resize_check). + * + * This can mean that the window size is smaller than the total layout + * size: redrawing this is handled at a higher level, but it does leave + * a problem with growing the window size here: if the current size is + * < the minimum, growing proportionately by adding to each pane is + * wrong as it would keep the layout size larger than the window size. + * Instead, spread the difference between the minimum and the new size + * out proportionately - this should leave the layout fitting the new + * window size. + */ + xchange = sx - lc->sx; + xlimit = layout_resize_check(w, lc, LAYOUT_LEFTRIGHT); + if (xchange < 0 && xchange < -xlimit) + xchange = -xlimit; + if (xlimit == 0) { + if (sx <= lc->sx) /* lc->sx is minimum possible */ + xchange = 0; + else + xchange = sx - lc->sx; + } + if (xchange != 0) + layout_resize_adjust(w, lc, LAYOUT_LEFTRIGHT, xchange); + + /* Adjust vertically in a similar fashion. */ + ychange = sy - lc->sy; + ylimit = layout_resize_check(w, lc, LAYOUT_TOPBOTTOM); + if (ychange < 0 && ychange < -ylimit) + ychange = -ylimit; + if (ylimit == 0) { + if (sy <= lc->sy) /* lc->sy is minimum possible */ + ychange = 0; + else + ychange = sy - lc->sy; + } + if (ychange != 0) + layout_resize_adjust(w, lc, LAYOUT_TOPBOTTOM, ychange); + + /* Fix cell offsets. */ + layout_fix_offsets(w); + layout_fix_panes(w, NULL); +} + +/* Resize a pane to an absolute size. */ +void +layout_resize_pane_to(struct window_pane *wp, enum layout_type type, + u_int new_size) +{ + struct layout_cell *lc, *lcparent; + int change, size; + + lc = wp->layout_cell; + + /* Find next parent of the same type. */ + lcparent = lc->parent; + while (lcparent != NULL && lcparent->type != type) { + lc = lcparent; + lcparent = lc->parent; + } + if (lcparent == NULL) + return; + + /* Work out the size adjustment. */ + if (type == LAYOUT_LEFTRIGHT) + size = lc->sx; + else + size = lc->sy; + if (lc == TAILQ_LAST(&lcparent->cells, layout_cells)) + change = size - new_size; + else + change = new_size - size; + + /* Resize the pane. */ + layout_resize_pane(wp, type, change, 1); +} + +void +layout_resize_layout(struct window *w, struct layout_cell *lc, + enum layout_type type, int change, int opposite) +{ + int needed, size; + + /* Grow or shrink the cell. */ + needed = change; + while (needed != 0) { + if (change > 0) { + size = layout_resize_pane_grow(w, lc, type, needed, + opposite); + needed -= size; + } else { + size = layout_resize_pane_shrink(w, lc, type, needed); + needed += size; + } + + if (size == 0) /* no more change possible */ + break; + } + + /* Fix cell offsets. */ + layout_fix_offsets(w); + layout_fix_panes(w, NULL); + notify_window("window-layout-changed", w); +} + +/* Resize a single pane within the layout. */ +void +layout_resize_pane(struct window_pane *wp, enum layout_type type, int change, + int opposite) +{ + struct layout_cell *lc, *lcparent; + + lc = wp->layout_cell; + + /* Find next parent of the same type. */ + lcparent = lc->parent; + while (lcparent != NULL && lcparent->type != type) { + lc = lcparent; + lcparent = lc->parent; + } + if (lcparent == NULL) + return; + + /* If this is the last cell, move back one. */ + if (lc == TAILQ_LAST(&lcparent->cells, layout_cells)) + lc = TAILQ_PREV(lc, layout_cells, entry); + + layout_resize_layout(wp->window, lc, type, change, opposite); +} + +/* Helper function to grow pane. */ +static int +layout_resize_pane_grow(struct window *w, struct layout_cell *lc, + enum layout_type type, int needed, int opposite) +{ + struct layout_cell *lcadd, *lcremove; + u_int size = 0; + + /* Growing. Always add to the current cell. */ + lcadd = lc; + + /* Look towards the tail for a suitable cell for reduction. */ + lcremove = TAILQ_NEXT(lc, entry); + while (lcremove != NULL) { + size = layout_resize_check(w, lcremove, type); + if (size > 0) + break; + lcremove = TAILQ_NEXT(lcremove, entry); + } + + /* If none found, look towards the head. */ + if (opposite && lcremove == NULL) { + lcremove = TAILQ_PREV(lc, layout_cells, entry); + while (lcremove != NULL) { + size = layout_resize_check(w, lcremove, type); + if (size > 0) + break; + lcremove = TAILQ_PREV(lcremove, layout_cells, entry); + } + } + if (lcremove == NULL) + return (0); + + /* Change the cells. */ + if (size > (u_int) needed) + size = needed; + layout_resize_adjust(w, lcadd, type, size); + layout_resize_adjust(w, lcremove, type, -size); + return (size); +} + +/* Helper function to shrink pane. */ +static int +layout_resize_pane_shrink(struct window *w, struct layout_cell *lc, + enum layout_type type, int needed) +{ + struct layout_cell *lcadd, *lcremove; + u_int size; + + /* Shrinking. Find cell to remove from by walking towards head. */ + lcremove = lc; + do { + size = layout_resize_check(w, lcremove, type); + if (size != 0) + break; + lcremove = TAILQ_PREV(lcremove, layout_cells, entry); + } while (lcremove != NULL); + if (lcremove == NULL) + return (0); + + /* And add onto the next cell (from the original cell). */ + lcadd = TAILQ_NEXT(lc, entry); + if (lcadd == NULL) + return (0); + + /* Change the cells. */ + if (size > (u_int) -needed) + size = -needed; + layout_resize_adjust(w, lcadd, type, size); + layout_resize_adjust(w, lcremove, type, -size); + return (size); +} + +/* Assign window pane to newly split cell. */ +void +layout_assign_pane(struct layout_cell *lc, struct window_pane *wp, + int do_not_resize) +{ + layout_make_leaf(lc, wp); + if (do_not_resize) + layout_fix_panes(wp->window, wp); + else + layout_fix_panes(wp->window, NULL); +} + +/* Calculate the new pane size for resized parent. */ +static u_int +layout_new_pane_size(struct window *w, u_int previous, struct layout_cell *lc, + enum layout_type type, u_int size, u_int count_left, u_int size_left) +{ + u_int new_size, min, max, available; + + /* If this is the last cell, it can take all of the remaining size. */ + if (count_left == 1) + return (size_left); + + /* How much is available in this parent? */ + available = layout_resize_check(w, lc, type); + + /* + * Work out the minimum size of this cell and the new size + * proportionate to the previous size. + */ + min = (PANE_MINIMUM + 1) * (count_left - 1); + if (type == LAYOUT_LEFTRIGHT) { + if (lc->sx - available > min) + min = lc->sx - available; + new_size = (lc->sx * size) / previous; + } else { + if (lc->sy - available > min) + min = lc->sy - available; + new_size = (lc->sy * size) / previous; + } + + /* Check against the maximum and minimum size. */ + max = size_left - min; + if (new_size > max) + new_size = max; + if (new_size < PANE_MINIMUM) + new_size = PANE_MINIMUM; + return (new_size); +} + +/* Check if the cell and all its children can be resized to a specific size. */ +static int +layout_set_size_check(struct window *w, struct layout_cell *lc, + enum layout_type type, int size) +{ + struct layout_cell *lcchild; + u_int new_size, available, previous, count, idx; + + /* Cells with no children must just be bigger than minimum. */ + if (lc->type == LAYOUT_WINDOWPANE) + return (size >= PANE_MINIMUM); + available = size; + + /* Count number of children. */ + count = 0; + TAILQ_FOREACH(lcchild, &lc->cells, entry) + count++; + + /* Check new size will work for each child. */ + if (lc->type == type) { + if (available < (count * 2) - 1) + return (0); + + if (type == LAYOUT_LEFTRIGHT) + previous = lc->sx; + else + previous = lc->sy; + + idx = 0; + TAILQ_FOREACH(lcchild, &lc->cells, entry) { + new_size = layout_new_pane_size(w, previous, lcchild, + type, size, count - idx, available); + if (idx == count - 1) { + if (new_size > available) + return (0); + available -= new_size; + } else { + if (new_size + 1 > available) + return (0); + available -= new_size + 1; + } + if (!layout_set_size_check(w, lcchild, type, new_size)) + return (0); + idx++; + } + } else { + TAILQ_FOREACH(lcchild, &lc->cells, entry) { + if (lcchild->type == LAYOUT_WINDOWPANE) + continue; + if (!layout_set_size_check(w, lcchild, type, size)) + return (0); + } + } + + return (1); +} + +/* Resize all child cells to fit within the current cell. */ +static void +layout_resize_child_cells(struct window *w, struct layout_cell *lc) +{ + struct layout_cell *lcchild; + u_int previous, available, count, idx; + + if (lc->type == LAYOUT_WINDOWPANE) + return; + + /* What is the current size used? */ + count = 0; + previous = 0; + TAILQ_FOREACH(lcchild, &lc->cells, entry) { + count++; + if (lc->type == LAYOUT_LEFTRIGHT) + previous += lcchild->sx; + else if (lc->type == LAYOUT_TOPBOTTOM) + previous += lcchild->sy; + } + previous += (count - 1); + + /* And how much is available? */ + available = 0; + if (lc->type == LAYOUT_LEFTRIGHT) + available = lc->sx; + else if (lc->type == LAYOUT_TOPBOTTOM) + available = lc->sy; + + /* Resize children into the new size. */ + idx = 0; + TAILQ_FOREACH(lcchild, &lc->cells, entry) { + if (lc->type == LAYOUT_TOPBOTTOM) { + lcchild->sx = lc->sx; + lcchild->xoff = lc->xoff; + } else { + lcchild->sx = layout_new_pane_size(w, previous, lcchild, + lc->type, lc->sx, count - idx, available); + available -= (lcchild->sx + 1); + } + if (lc->type == LAYOUT_LEFTRIGHT) + lcchild->sy = lc->sy; + else { + lcchild->sy = layout_new_pane_size(w, previous, lcchild, + lc->type, lc->sy, count - idx, available); + available -= (lcchild->sy + 1); + } + layout_resize_child_cells(w, lcchild); + idx++; + } +} + +/* + * Split a pane into two. size is a hint, or -1 for default half/half + * split. This must be followed by layout_assign_pane before much else happens! + */ +struct layout_cell * +layout_split_pane(struct window_pane *wp, enum layout_type type, int size, + int flags) +{ + struct layout_cell *lc, *lcparent, *lcnew, *lc1, *lc2; + u_int sx, sy, xoff, yoff, size1, size2, minimum; + u_int new_size, saved_size, resize_first = 0; + int full_size = (flags & SPAWN_FULLSIZE), status; + + /* + * If full_size is specified, add a new cell at the top of the window + * layout. Otherwise, split the cell for the current pane. + */ + if (full_size) + lc = wp->window->layout_root; + else + lc = wp->layout_cell; + status = options_get_number(wp->window->options, "pane-border-status"); + + /* Copy the old cell size. */ + sx = lc->sx; + sy = lc->sy; + xoff = lc->xoff; + yoff = lc->yoff; + + /* Check there is enough space for the two new panes. */ + switch (type) { + case LAYOUT_LEFTRIGHT: + if (sx < PANE_MINIMUM * 2 + 1) + return (NULL); + break; + case LAYOUT_TOPBOTTOM: + if (layout_add_border(wp->window, lc, status)) + minimum = PANE_MINIMUM * 2 + 2; + else + minimum = PANE_MINIMUM * 2 + 1; + if (sy < minimum) + return (NULL); + break; + default: + fatalx("bad layout type"); + } + + /* + * Calculate new cell sizes. size is the target size or -1 for middle + * split, size1 is the size of the top/left and size2 the bottom/right. + */ + if (type == LAYOUT_LEFTRIGHT) + saved_size = sx; + else + saved_size = sy; + if (size < 0) + size2 = ((saved_size + 1) / 2) - 1; + else if (flags & SPAWN_BEFORE) + size2 = saved_size - size - 1; + else + size2 = size; + if (size2 < PANE_MINIMUM) + size2 = PANE_MINIMUM; + else if (size2 > saved_size - 2) + size2 = saved_size - 2; + size1 = saved_size - 1 - size2; + + /* Which size are we using? */ + if (flags & SPAWN_BEFORE) + new_size = size2; + else + new_size = size1; + + /* Confirm there is enough space for full size pane. */ + if (full_size && !layout_set_size_check(wp->window, lc, type, new_size)) + return (NULL); + + if (lc->parent != NULL && lc->parent->type == type) { + /* + * If the parent exists and is of the same type as the split, + * create a new cell and insert it after this one. + */ + lcparent = lc->parent; + lcnew = layout_create_cell(lcparent); + if (flags & SPAWN_BEFORE) + TAILQ_INSERT_BEFORE(lc, lcnew, entry); + else + TAILQ_INSERT_AFTER(&lcparent->cells, lc, lcnew, entry); + } else if (full_size && lc->parent == NULL && lc->type == type) { + /* + * If the new full size pane is the same type as the root + * split, insert the new pane under the existing root cell + * instead of creating a new root cell. The existing layout + * must be resized before inserting the new cell. + */ + if (lc->type == LAYOUT_LEFTRIGHT) { + lc->sx = new_size; + layout_resize_child_cells(wp->window, lc); + lc->sx = saved_size; + } else if (lc->type == LAYOUT_TOPBOTTOM) { + lc->sy = new_size; + layout_resize_child_cells(wp->window, lc); + lc->sy = saved_size; + } + resize_first = 1; + + /* Create the new cell. */ + lcnew = layout_create_cell(lc); + size = saved_size - 1 - new_size; + if (lc->type == LAYOUT_LEFTRIGHT) + layout_set_size(lcnew, size, sy, 0, 0); + else if (lc->type == LAYOUT_TOPBOTTOM) + layout_set_size(lcnew, sx, size, 0, 0); + if (flags & SPAWN_BEFORE) + TAILQ_INSERT_HEAD(&lc->cells, lcnew, entry); + else + TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry); + } else { + /* + * Otherwise create a new parent and insert it. + */ + + /* Create and insert the replacement parent. */ + lcparent = layout_create_cell(lc->parent); + layout_make_node(lcparent, type); + layout_set_size(lcparent, sx, sy, xoff, yoff); + if (lc->parent == NULL) + wp->window->layout_root = lcparent; + else + TAILQ_REPLACE(&lc->parent->cells, lc, lcparent, entry); + + /* Insert the old cell. */ + lc->parent = lcparent; + TAILQ_INSERT_HEAD(&lcparent->cells, lc, entry); + + /* Create the new child cell. */ + lcnew = layout_create_cell(lcparent); + if (flags & SPAWN_BEFORE) + TAILQ_INSERT_HEAD(&lcparent->cells, lcnew, entry); + else + TAILQ_INSERT_TAIL(&lcparent->cells, lcnew, entry); + } + if (flags & SPAWN_BEFORE) { + lc1 = lcnew; + lc2 = lc; + } else { + lc1 = lc; + lc2 = lcnew; + } + + /* + * Set new cell sizes. size1 is the size of the top/left and size2 the + * bottom/right. + */ + if (!resize_first && type == LAYOUT_LEFTRIGHT) { + layout_set_size(lc1, size1, sy, xoff, yoff); + layout_set_size(lc2, size2, sy, xoff + lc1->sx + 1, yoff); + } else if (!resize_first && type == LAYOUT_TOPBOTTOM) { + layout_set_size(lc1, sx, size1, xoff, yoff); + layout_set_size(lc2, sx, size2, xoff, yoff + lc1->sy + 1); + } + if (full_size) { + if (!resize_first) + layout_resize_child_cells(wp->window, lc); + layout_fix_offsets(wp->window); + } else + layout_make_leaf(lc, wp); + + return (lcnew); +} + +/* Destroy the cell associated with a pane. */ +void +layout_close_pane(struct window_pane *wp) +{ + struct window *w = wp->window; + + /* Remove the cell. */ + layout_destroy_cell(w, wp->layout_cell, &w->layout_root); + + /* Fix pane offsets and sizes. */ + if (w->layout_root != NULL) { + layout_fix_offsets(w); + layout_fix_panes(w, NULL); + } + notify_window("window-layout-changed", w); +} + +int +layout_spread_cell(struct window *w, struct layout_cell *parent) +{ + struct layout_cell *lc; + u_int number, each, size, this; + int change, changed, status; + + number = 0; + TAILQ_FOREACH (lc, &parent->cells, entry) + number++; + if (number <= 1) + return (0); + status = options_get_number(w->options, "pane-border-status"); + + if (parent->type == LAYOUT_LEFTRIGHT) + size = parent->sx; + else if (parent->type == LAYOUT_TOPBOTTOM) { + if (layout_add_border(w, parent, status)) + size = parent->sy - 1; + else + size = parent->sy; + } else + return (0); + if (size < number - 1) + return (0); + each = (size - (number - 1)) / number; + if (each == 0) + return (0); + + changed = 0; + TAILQ_FOREACH (lc, &parent->cells, entry) { + if (TAILQ_NEXT(lc, entry) == NULL) + each = size - ((each + 1) * (number - 1)); + change = 0; + if (parent->type == LAYOUT_LEFTRIGHT) { + change = each - (int)lc->sx; + layout_resize_adjust(w, lc, LAYOUT_LEFTRIGHT, change); + } else if (parent->type == LAYOUT_TOPBOTTOM) { + if (layout_add_border(w, lc, status)) + this = each + 1; + else + this = each; + change = this - (int)lc->sy; + layout_resize_adjust(w, lc, LAYOUT_TOPBOTTOM, change); + } + if (change != 0) + changed = 1; + } + return (changed); +} + +void +layout_spread_out(struct window_pane *wp) +{ + struct layout_cell *parent; + struct window *w = wp->window; + + parent = wp->layout_cell->parent; + if (parent == NULL) + return; + + do { + if (layout_spread_cell(w, parent)) { + layout_fix_offsets(w); + layout_fix_panes(w, NULL); + break; + } + } while ((parent = parent->parent) != NULL); +} |