mirror of
https://github.com/tmux/tmux.git
synced 2026-06-24 05:58:27 +00:00
95afd7549c
is generated and cached in the client: it holds positions and sizes of panes, borders and so on. The scene is invalidated when a pane is moved or resized or relevant option is changed. This scene is then drawn to the client as needed and text and colours are filled in. With Michael Grant.
1677 lines
40 KiB
C
1677 lines
40 KiB
C
/* $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. 'Node' will be used to refer to
|
|
* a cell which contains a list of cells, and 'leaf' to refer to a cell that
|
|
* contains a window pane. A leaf is considered to be 'tiled' if it is to be
|
|
* drawn as a part of the tiled layout. A 'neighbour' is a sibling that is also
|
|
* tiled. A cell's 'split' size refers to the side that is shortened when
|
|
* splitting it, determined by the parent's type.
|
|
*
|
|
* 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. Every cell has a position in the root
|
|
* layout tree. This position is retained through cell state changes such as
|
|
* floating or hiding.
|
|
*/
|
|
|
|
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 *);
|
|
|
|
/* Create a new 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->flags = 0;
|
|
lc->parent = lcparent;
|
|
|
|
TAILQ_INIT(&lc->cells);
|
|
|
|
lc->sx = UINT_MAX;
|
|
lc->sy = UINT_MAX;
|
|
|
|
lc->xoff = INT_MAX;
|
|
lc->yoff = INT_MAX;
|
|
|
|
lc->wp = NULL;
|
|
|
|
return (lc);
|
|
}
|
|
|
|
/* Free a layout cell. */
|
|
void
|
|
layout_free_cell(struct layout_cell *lc)
|
|
{
|
|
struct layout_cell *lcchild;
|
|
|
|
if (lc == NULL)
|
|
return;
|
|
|
|
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->parent = NULL;
|
|
lc->wp->layout_cell = NULL;
|
|
}
|
|
break;
|
|
}
|
|
|
|
free(lc);
|
|
}
|
|
|
|
/* Log a cell. */
|
|
void
|
|
layout_print_cell(struct layout_cell *lc, const char *hdr, u_int n)
|
|
{
|
|
struct layout_cell *lcchild;
|
|
const char *type;
|
|
|
|
if (lc == NULL)
|
|
return;
|
|
|
|
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 [%d,%d %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;
|
|
}
|
|
}
|
|
|
|
/* Search for a cell by the border position. */
|
|
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 ((int)x >= lcchild->xoff &&
|
|
(int)x < lcchild->xoff + (int)lcchild->sx &&
|
|
(int)y >= lcchild->yoff &&
|
|
(int)y < lcchild->yoff + (int)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 ((int)x < lcchild->xoff &&
|
|
(int)x >= last->xoff + (int)last->sx)
|
|
return (last);
|
|
break;
|
|
case LAYOUT_TOPBOTTOM:
|
|
if ((int)y < lcchild->yoff &&
|
|
(int)y >= last->yoff + (int)last->sy)
|
|
return (last);
|
|
break;
|
|
case LAYOUT_WINDOWPANE:
|
|
break;
|
|
}
|
|
|
|
last = lcchild;
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
/* Set cell size. */
|
|
void
|
|
layout_set_size(struct layout_cell *lc, u_int sx, u_int sy, int xoff, int yoff)
|
|
{
|
|
lc->sx = sx;
|
|
lc->sy = sy;
|
|
|
|
lc->xoff = xoff;
|
|
lc->yoff = yoff;
|
|
}
|
|
|
|
/* Make a cell a leaf cell. */
|
|
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;
|
|
}
|
|
|
|
/* Make a cell a node cell. */
|
|
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 z-indexes. */
|
|
void
|
|
layout_fix_zindexes(struct window *w, struct layout_cell *lc)
|
|
{
|
|
struct layout_cell *lcchild;
|
|
|
|
if (lc == NULL)
|
|
return;
|
|
|
|
switch (lc->type) {
|
|
case LAYOUT_WINDOWPANE:
|
|
TAILQ_INSERT_TAIL(&w->z_index, lc->wp, zentry);
|
|
break;
|
|
case LAYOUT_LEFTRIGHT:
|
|
case LAYOUT_TOPBOTTOM:
|
|
TAILQ_FOREACH(lcchild, &lc->cells, entry)
|
|
layout_fix_zindexes(w, lcchild);
|
|
return;
|
|
default:
|
|
fatalx("bad layout type");
|
|
}
|
|
}
|
|
|
|
static int
|
|
layout_cell_is_tiled(struct layout_cell *lc)
|
|
{
|
|
int is_leaf = lc->type == LAYOUT_WINDOWPANE;
|
|
int is_floating = lc->flags & LAYOUT_CELL_FLOATING;
|
|
|
|
return is_leaf && !is_floating;
|
|
}
|
|
|
|
static int
|
|
layout_cell_has_tiled_child(struct layout_cell *lc)
|
|
{
|
|
struct layout_cell *lcchild;
|
|
|
|
if (lc->type == LAYOUT_WINDOWPANE)
|
|
return (0);
|
|
|
|
TAILQ_FOREACH(lcchild, &lc->cells, entry) {
|
|
if (layout_cell_is_tiled(lcchild) ||
|
|
layout_cell_has_tiled_child(lcchild))
|
|
return (1);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
layout_cell_is_first_tiled(struct layout_cell *lc)
|
|
{
|
|
struct layout_cell *lcchild, *lcparent = lc->parent;
|
|
|
|
if (lcparent == NULL)
|
|
return (layout_cell_is_tiled(lc));
|
|
|
|
TAILQ_FOREACH(lcchild, &lcparent->cells, entry) {
|
|
if (layout_cell_is_tiled(lcchild) ||
|
|
layout_cell_has_tiled_child(lcchild))
|
|
break;
|
|
}
|
|
|
|
return (lcchild == lc);
|
|
}
|
|
|
|
|
|
/* Fix cell offsets for a child cell. */
|
|
static void
|
|
layout_fix_offsets1(struct layout_cell *lc)
|
|
{
|
|
struct layout_cell *lcchild;
|
|
int xoff, yoff;
|
|
|
|
if (lc->type == LAYOUT_LEFTRIGHT) {
|
|
xoff = lc->xoff;
|
|
TAILQ_FOREACH(lcchild, &lc->cells, entry) {
|
|
if (!layout_cell_is_tiled(lcchild) &&
|
|
!layout_cell_has_tiled_child(lcchild))
|
|
continue;
|
|
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) {
|
|
if (!layout_cell_is_tiled(lcchild) &&
|
|
!layout_cell_has_tiled_child(lcchild))
|
|
continue;
|
|
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;
|
|
|
|
/* Root consists of a single floating cell */
|
|
if (lc->flags & LAYOUT_CELL_FLOATING)
|
|
return;
|
|
|
|
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 == NULL)
|
|
return (0);
|
|
if (next->type == LAYOUT_TOPBOTTOM &&
|
|
!layout_cell_is_first_tiled(lc))
|
|
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, *edge;
|
|
|
|
while (lc != w->layout_root) {
|
|
next = lc->parent;
|
|
if (next == NULL)
|
|
return (0);
|
|
if (next->type == LAYOUT_TOPBOTTOM) {
|
|
edge = TAILQ_LAST(&next->cells, layout_cells);
|
|
while (edge != NULL) {
|
|
if (~edge->flags & LAYOUT_CELL_FLOATING)
|
|
break;
|
|
edge = TAILQ_PREV(edge, layout_cells, entry);
|
|
}
|
|
if (lc != edge)
|
|
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_horizontal_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, scrollbars, sb_pos, sb_w, sb_pad;
|
|
int old_xoff, old_yoff, changed = 0;
|
|
u_int sx, sy, old_sx, old_sy;
|
|
|
|
status = window_get_pane_status(w);
|
|
scrollbars = options_get_number(w->options, "pane-scrollbars");
|
|
sb_pos = options_get_number(w->options, "pane-scrollbars-position");
|
|
|
|
TAILQ_FOREACH(wp, &w->panes, entry) {
|
|
if ((lc = wp->layout_cell) == NULL || wp == skip)
|
|
continue;
|
|
|
|
old_xoff = wp->xoff;
|
|
old_yoff = wp->yoff;
|
|
old_sx = wp->sx;
|
|
old_sy = wp->sy;
|
|
|
|
wp->xoff = lc->xoff;
|
|
wp->yoff = lc->yoff;
|
|
sx = lc->sx;
|
|
sy = lc->sy;
|
|
|
|
if (!window_pane_is_floating(wp) &&
|
|
layout_add_horizontal_border(w, lc, status)) {
|
|
if (status == PANE_STATUS_TOP)
|
|
wp->yoff++;
|
|
sy--;
|
|
}
|
|
|
|
if (window_pane_show_scrollbar(wp, scrollbars)) {
|
|
sb_w = wp->scrollbar_style.width;
|
|
sb_pad = wp->scrollbar_style.pad;
|
|
if (sb_w < 1)
|
|
sb_w = 1;
|
|
if (sb_pad < 0)
|
|
sb_pad = 0;
|
|
if (sb_pos == PANE_SCROLLBARS_LEFT) {
|
|
if ((int)sx - sb_w < PANE_MINIMUM) {
|
|
wp->xoff = wp->xoff +
|
|
(int)sx - PANE_MINIMUM;
|
|
sx = PANE_MINIMUM;
|
|
} else {
|
|
sx = sx - sb_w - sb_pad;
|
|
wp->xoff = wp->xoff + sb_w + sb_pad;
|
|
}
|
|
} else /* sb_pos == PANE_SCROLLBARS_RIGHT */
|
|
if ((int)sx - sb_w - sb_pad < PANE_MINIMUM)
|
|
sx = PANE_MINIMUM;
|
|
else
|
|
sx = sx - sb_w - sb_pad;
|
|
wp->flags |= PANE_REDRAWSCROLLBAR;
|
|
}
|
|
|
|
window_pane_resize(wp, sx, sy);
|
|
|
|
if (wp->xoff != old_xoff ||
|
|
wp->yoff != old_yoff ||
|
|
wp->sx != old_sx ||
|
|
wp->sy != old_sy)
|
|
changed = 1;
|
|
}
|
|
if (changed)
|
|
redraw_invalidate_scene(w);
|
|
}
|
|
|
|
/* 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 = 0;
|
|
|
|
switch (lc->type) {
|
|
case LAYOUT_WINDOWPANE:
|
|
return (1);
|
|
case LAYOUT_LEFTRIGHT:
|
|
case LAYOUT_TOPBOTTOM:
|
|
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;
|
|
struct style *sb_style = &w->active->scrollbar_style;
|
|
u_int available, minimum;
|
|
int status, scrollbars;
|
|
|
|
status = window_get_pane_status(w);
|
|
scrollbars = options_get_number(w->options, "pane-scrollbars");
|
|
|
|
if (lc->type == LAYOUT_WINDOWPANE) {
|
|
/* Space available in this cell only. */
|
|
if (type == LAYOUT_LEFTRIGHT) {
|
|
available = lc->sx;
|
|
if (scrollbars)
|
|
minimum = PANE_MINIMUM + sb_style->width +
|
|
sb_style->pad;
|
|
else
|
|
minimum = PANE_MINIMUM;
|
|
} else {
|
|
available = lc->sy;
|
|
if (layout_add_horizontal_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) {
|
|
if (!layout_cell_is_tiled(lcchild) &&
|
|
!layout_cell_has_tiled_child(lcchild))
|
|
continue;
|
|
layout_resize_adjust(w, lcchild, type, change);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If a node doesn't contain any tiled cells, there is nothing to do.
|
|
*/
|
|
if (!layout_cell_has_tiled_child(lc))
|
|
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 (!layout_cell_is_tiled(lcchild) &&
|
|
!layout_cell_has_tiled_child(lcchild))
|
|
continue;
|
|
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++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Find and return the nearest neighbour to a cell in a specific direction. */
|
|
static struct layout_cell *
|
|
layout_cell_get_neighbour_direction(struct layout_cell *lc, int direction)
|
|
{
|
|
struct layout_cell *lcn = lc;
|
|
|
|
while (1) {
|
|
if (direction)
|
|
lcn = TAILQ_NEXT(lcn, entry);
|
|
else
|
|
lcn = TAILQ_PREV(lcn, layout_cells, entry);
|
|
|
|
if (lcn == NULL ||
|
|
layout_cell_is_tiled(lcn) ||
|
|
layout_cell_has_tiled_child(lcn))
|
|
return (lcn);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Find and return the nearest neighbour. Prefers cells "after" the specified
|
|
* cell. This behavior defines how cell dimensions are redistributed when a cell
|
|
* is hidden/shown and floated/tiled.
|
|
*/
|
|
struct layout_cell *
|
|
layout_cell_get_neighbour(struct layout_cell *lc)
|
|
{
|
|
struct layout_cell *lcother, *lcparent = lc->parent;
|
|
int direction = 1;
|
|
|
|
if (lcparent == NULL)
|
|
return (NULL);
|
|
|
|
if (lc == TAILQ_LAST(&lcparent->cells, layout_cells))
|
|
direction = !direction;
|
|
|
|
lcother = layout_cell_get_neighbour_direction(lc, direction);
|
|
if (lcother == NULL)
|
|
lcother = layout_cell_get_neighbour_direction(lc, !direction);
|
|
|
|
return (lcother);
|
|
}
|
|
|
|
|
|
/* 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 = NULL, *lcparent;
|
|
int change;
|
|
|
|
/* If no parent, this is the last pane in a window. */
|
|
lcparent = lc->parent;
|
|
if (lcparent == NULL) {
|
|
if (lc->wp != NULL)
|
|
*lcroot = NULL;
|
|
layout_free_cell(lc);
|
|
return;
|
|
}
|
|
|
|
if (!layout_cell_is_tiled(lc)) {
|
|
TAILQ_REMOVE(&lcparent->cells, lc, entry);
|
|
layout_free_cell(lc);
|
|
goto out;
|
|
}
|
|
|
|
lcother = layout_cell_get_neighbour(lc);
|
|
if (lcother != NULL) {
|
|
if (lcparent->type == LAYOUT_LEFTRIGHT)
|
|
change = lc->sx + 1;
|
|
else
|
|
change = lc->sy + 1;
|
|
layout_resize_adjust(w, lcother, lcparent->type, change);
|
|
} else
|
|
layout_remove_tile(w, lcparent);
|
|
|
|
/* Remove this from the parent's list. */
|
|
TAILQ_REMOVE(&lcparent->cells, lc, entry);
|
|
layout_free_cell(lc);
|
|
|
|
out:
|
|
/*
|
|
* 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 (lc != NULL && TAILQ_NEXT(lc, entry) == NULL) {
|
|
TAILQ_REMOVE(&lcparent->cells, lc, entry);
|
|
|
|
lc->parent = lcparent->parent;
|
|
if (lc->parent == NULL) {
|
|
if (layout_cell_is_tiled(lc)) {
|
|
lc->xoff = 0;
|
|
lc->yoff = 0;
|
|
}
|
|
*lcroot = lc;
|
|
} else
|
|
TAILQ_REPLACE(&lc->parent->cells, lcparent, lc, entry);
|
|
|
|
layout_free_cell(lcparent);
|
|
}
|
|
}
|
|
|
|
/* Initialize layout for pane. */
|
|
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);
|
|
}
|
|
|
|
/* Free layout for pane. */
|
|
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.
|
|
*/
|
|
if (lc->type == LAYOUT_WINDOWPANE && (lc->flags & LAYOUT_CELL_FLOATING))
|
|
return;
|
|
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);
|
|
}
|
|
|
|
/* Resize a floating pane to an absolute size. */
|
|
void
|
|
layout_resize_floating_pane_to(struct window_pane *wp, enum layout_type type,
|
|
u_int size, char **cause)
|
|
{
|
|
struct layout_cell *lc = wp->layout_cell;
|
|
|
|
if (~lc->flags & LAYOUT_CELL_FLOATING) {
|
|
*cause = xstrdup("pane is not floating");
|
|
return;
|
|
}
|
|
|
|
if (window_pane_get_pane_lines(wp) != PANE_LINES_NONE &&
|
|
size >= PANE_MINIMUM + 2)
|
|
size -= 2;
|
|
if (size < PANE_MINIMUM || size > PANE_MAXIMUM) {
|
|
*cause = xstrdup("size is too big or too small");
|
|
return;
|
|
}
|
|
|
|
if (type == LAYOUT_TOPBOTTOM) {
|
|
if (lc->sy == size)
|
|
return;
|
|
lc->sy = size;
|
|
} else {
|
|
if (lc->sx == size)
|
|
return;
|
|
lc->sx = size;
|
|
}
|
|
redraw_invalidate_scene(wp->window);
|
|
}
|
|
|
|
/* Resize a floating pane relative to its current size. */
|
|
void
|
|
layout_resize_floating_pane(struct window_pane *wp, enum layout_type type,
|
|
int change, int opposite, char **cause)
|
|
{
|
|
struct layout_cell *lc = wp->layout_cell;
|
|
u_int size;
|
|
|
|
if (~lc->flags & LAYOUT_CELL_FLOATING) {
|
|
*cause = xstrdup("pane is not floating");
|
|
return;
|
|
}
|
|
if (change == 0)
|
|
return;
|
|
|
|
if (type == LAYOUT_TOPBOTTOM) {
|
|
size = lc->sy + change;
|
|
if (size < PANE_MINIMUM || size > PANE_MAXIMUM) {
|
|
*cause = xstrdup("change is too big or too small");
|
|
return;
|
|
}
|
|
lc->sy = size;
|
|
if (opposite)
|
|
lc->yoff -= change;
|
|
} else {
|
|
size = lc->sx + change;
|
|
if (size < PANE_MINIMUM || size > PANE_MAXIMUM) {
|
|
*cause = xstrdup("change is too big or too small");
|
|
return;
|
|
}
|
|
lc->sx = size;
|
|
if (opposite)
|
|
lc->xoff -= change;
|
|
}
|
|
redraw_invalidate_scene(wp->window);
|
|
}
|
|
|
|
/* Resize a layout cell. */
|
|
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 = wp->layout_cell, *lcparent;
|
|
|
|
/* 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)) {
|
|
do
|
|
lc = TAILQ_PREV(lc, layout_cells, entry);
|
|
while (lc->flags & LAYOUT_CELL_FLOATING);
|
|
}
|
|
|
|
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 new 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) {
|
|
if (!layout_cell_is_tiled(lcchild) &&
|
|
!layout_cell_has_tiled_child(lcchild))
|
|
continue;
|
|
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 (!layout_cell_is_tiled(lcchild) &&
|
|
!layout_cell_has_tiled_child(lcchild))
|
|
continue;
|
|
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;
|
|
lcchild->yoff = lc->yoff;
|
|
} 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;
|
|
struct style *sb_style = &wp->scrollbar_style;
|
|
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;
|
|
int scrollbars;
|
|
|
|
/*
|
|
* 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 = window_get_pane_status(wp->window);
|
|
scrollbars = options_get_number(wp->window->options, "pane-scrollbars");
|
|
|
|
/* 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 (scrollbars) {
|
|
minimum = PANE_MINIMUM * 2 + sb_style->width +
|
|
sb_style->pad;
|
|
} else
|
|
minimum = PANE_MINIMUM * 2 + 1;
|
|
if (sx < minimum)
|
|
return (NULL);
|
|
break;
|
|
case LAYOUT_TOPBOTTOM:
|
|
if (layout_add_horizontal_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);
|
|
}
|
|
|
|
/*
|
|
* Creates a cell for a new floating pane. This must be followed by
|
|
* layout_assign_pane before much else happens!
|
|
*/
|
|
struct layout_cell *
|
|
layout_floating_pane(struct window *w, struct window_pane *wp, u_int sx,
|
|
u_int sy, int ox, int oy)
|
|
{
|
|
struct layout_cell *lc, *lcnew, *lcparent;
|
|
|
|
if (wp == NULL)
|
|
lc = w->layout_root;
|
|
else
|
|
lc = wp->layout_cell;
|
|
lcparent = lc->parent;
|
|
|
|
if (lcparent == NULL) {
|
|
/*
|
|
* Adding a pane to a root that isn't node. Must create and
|
|
* insert a new root.
|
|
*/
|
|
lcparent = layout_create_cell(NULL);
|
|
layout_make_node(lcparent, LAYOUT_TOPBOTTOM);
|
|
layout_set_size(lcparent, w->sx, w->sy, 0, 0);
|
|
w->layout_root = lcparent;
|
|
|
|
/* Insert the old cell. */
|
|
lc->parent = lcparent;
|
|
TAILQ_INSERT_HEAD(&lcparent->cells, lc, entry);
|
|
}
|
|
|
|
lcnew = layout_create_cell(lcparent);
|
|
TAILQ_INSERT_AFTER(&lcparent->cells, lc, lcnew, entry);
|
|
lcnew->flags |= LAYOUT_CELL_FLOATING;
|
|
layout_set_size(lcnew, sx, sy, ox, oy);
|
|
|
|
return (lcnew);
|
|
}
|
|
|
|
/* Destroy the cell associated with a pane. */
|
|
void
|
|
layout_close_pane(struct window_pane *wp)
|
|
{
|
|
struct window *w = wp->window;
|
|
|
|
if (wp->layout_cell == NULL)
|
|
return;
|
|
|
|
/* Remove the cell. */
|
|
layout_destroy_cell(w, wp->layout_cell, &w->layout_root);
|
|
wp->layout_cell = NULL;
|
|
|
|
/* 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);
|
|
}
|
|
|
|
/* Spread out cells inside a parent cell. */
|
|
int
|
|
layout_spread_cell(struct window *w, struct layout_cell *parent)
|
|
{
|
|
struct layout_cell *lc;
|
|
u_int number, each, size, this, remainder;
|
|
int change, changed, status;
|
|
|
|
number = 0;
|
|
TAILQ_FOREACH (lc, &parent->cells, entry)
|
|
number++;
|
|
if (number <= 1)
|
|
return (0);
|
|
status = window_get_pane_status(w);
|
|
|
|
if (parent->type == LAYOUT_LEFTRIGHT)
|
|
size = parent->sx;
|
|
else if (parent->type == LAYOUT_TOPBOTTOM) {
|
|
if (layout_add_horizontal_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);
|
|
|
|
/*
|
|
* Remaining space after assigning that which can be evenly
|
|
* distributed.
|
|
*/
|
|
remainder = size - (number * (each + 1)) + 1;
|
|
|
|
changed = 0;
|
|
TAILQ_FOREACH (lc, &parent->cells, entry) {
|
|
change = 0;
|
|
if (parent->type == LAYOUT_LEFTRIGHT) {
|
|
change = each - (int)lc->sx;
|
|
if (remainder > 0) {
|
|
change++;
|
|
remainder--;
|
|
}
|
|
layout_resize_adjust(w, lc, LAYOUT_LEFTRIGHT, change);
|
|
} else if (parent->type == LAYOUT_TOPBOTTOM) {
|
|
if (layout_add_horizontal_border(w, lc, status))
|
|
this = each + 1;
|
|
else
|
|
this = each;
|
|
if (remainder > 0) {
|
|
this++;
|
|
remainder--;
|
|
}
|
|
change = this - (int)lc->sy;
|
|
layout_resize_adjust(w, lc, LAYOUT_TOPBOTTOM, change);
|
|
}
|
|
if (change != 0)
|
|
changed = 1;
|
|
}
|
|
return (changed);
|
|
}
|
|
|
|
/* Spread out cells evenly. */
|
|
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);
|
|
}
|
|
|
|
/* Get a new tiled cell. */
|
|
struct layout_cell *
|
|
layout_get_tiled_cell(struct cmdq_item *item, struct args *args,
|
|
struct window *w, struct window_pane *wp, int flags, char **cause)
|
|
{
|
|
struct layout_cell *lc;
|
|
enum layout_type type;
|
|
u_int curval;
|
|
int size = -1;
|
|
|
|
if (window_pane_is_floating(wp)) {
|
|
*cause = xstrdup("can't split a floating pane");
|
|
return (NULL);
|
|
}
|
|
|
|
type = LAYOUT_TOPBOTTOM;
|
|
if (args_has(args, 'h'))
|
|
type = LAYOUT_LEFTRIGHT;
|
|
|
|
if (args_has(args, 'l') || args_has(args, 'p')) {
|
|
if (args_has(args, 'f')) {
|
|
if (type == LAYOUT_TOPBOTTOM)
|
|
curval = w->sy;
|
|
else
|
|
curval = w->sx;
|
|
} else {
|
|
if (type == LAYOUT_TOPBOTTOM)
|
|
curval = wp->sy;
|
|
else
|
|
curval = wp->sx;
|
|
}
|
|
}
|
|
|
|
if (args_has(args, 'l')) {
|
|
size = args_percentage_and_expand(args, 'l', 0, INT_MAX, curval,
|
|
item, cause);
|
|
} else if (args_has(args, 'p')) {
|
|
size = args_strtonum_and_expand(args, 'p', 0, 100, item,
|
|
cause);
|
|
if (*cause == NULL)
|
|
size = curval * size / 100;
|
|
}
|
|
if (*cause != NULL) {
|
|
*cause = xstrdup("invalid tiled geometry");
|
|
return (NULL);
|
|
}
|
|
|
|
if (args_has(args, 'b'))
|
|
flags |= SPAWN_BEFORE;
|
|
if (args_has(args, 'f'))
|
|
flags |= SPAWN_FULLSIZE;
|
|
|
|
window_push_zoom(wp->window, 1, args_has(args, 'Z'));
|
|
lc = layout_split_pane(wp, type, size, flags);
|
|
if (lc == NULL)
|
|
*cause = xstrdup("no space for a new pane");
|
|
|
|
return (lc);
|
|
}
|
|
|
|
/* Get a new floating cell. */
|
|
struct layout_cell *
|
|
layout_get_floating_cell(struct cmdq_item *item, struct args *args,
|
|
struct window *w, struct window_pane *wp, char **cause)
|
|
{
|
|
struct layout_cell *lcnew;
|
|
int sx = w->sx / 2, sy = w->sy / 4;
|
|
int ox = INT_MAX, oy = INT_MAX;
|
|
char *error;
|
|
|
|
if (args_has(args, 'x')) {
|
|
sx = args_percentage_and_expand(args, 'x', 0, w->sx - 1, w->sx,
|
|
item, &error);
|
|
if (error != NULL) {
|
|
xasprintf(cause, "position %s", error);
|
|
free(error);
|
|
return (NULL);
|
|
}
|
|
}
|
|
if (args_has(args, 'y')) {
|
|
sy = args_percentage_and_expand(args, 'y', 0, w->sy - 1, w->sy,
|
|
item, &error);
|
|
if (error != NULL) {
|
|
xasprintf(cause, "position %s", error);
|
|
free(error);
|
|
return (NULL);
|
|
}
|
|
}
|
|
if (args_has(args, 'X')) {
|
|
ox = args_percentage_and_expand(args, 'X', -sx, w->sx,
|
|
w->sx, item, &error);
|
|
if (error != NULL) {
|
|
xasprintf(cause, "size %s", error);
|
|
free(error);
|
|
return (NULL);
|
|
}
|
|
}
|
|
if (args_has(args, 'Y')) {
|
|
oy = args_percentage_and_expand(args, 'Y', -sy, w->sy,
|
|
w->sy, item, &error);
|
|
if (error != NULL) {
|
|
xasprintf(cause, "size %s", error);
|
|
free(error);
|
|
return (NULL);
|
|
}
|
|
}
|
|
|
|
if (ox == INT_MAX) {
|
|
if (w->last_new_pane_x == 0)
|
|
ox = 4;
|
|
else {
|
|
ox = w->last_new_pane_x + 4;
|
|
if (w->last_new_pane_x > w->sx)
|
|
ox = 4;
|
|
}
|
|
w->last_new_pane_x = ox;
|
|
}
|
|
if (oy == INT_MAX) {
|
|
if (w->last_new_pane_y == 0)
|
|
oy = 2;
|
|
else {
|
|
oy = w->last_new_pane_y + 2;
|
|
if (w->last_new_pane_y > w->sy)
|
|
oy = 2;
|
|
}
|
|
w->last_new_pane_y = oy;
|
|
}
|
|
|
|
if (sx < PANE_MINIMUM || sx > PANE_MAXIMUM) {
|
|
*cause = xstrdup("invalid width");
|
|
return (NULL);
|
|
}
|
|
if (sy < PANE_MINIMUM || sy > PANE_MAXIMUM) {
|
|
*cause = xstrdup("invalid height");
|
|
return (NULL);
|
|
}
|
|
|
|
lcnew = layout_floating_pane(w, wp, sx, sy, ox, oy);
|
|
return (lcnew);
|
|
}
|
|
|
|
/*
|
|
* Removes a cell from the tiled layout by giving the cell's space to the
|
|
* nearest neighbour.
|
|
*/
|
|
int
|
|
layout_remove_tile(struct window *w, struct layout_cell *lc)
|
|
{
|
|
struct layout_cell *lcneighbour, *lcparent;
|
|
enum layout_type type;
|
|
int change;
|
|
|
|
if (lc->flags & LAYOUT_CELL_FLOATING)
|
|
return (0);
|
|
|
|
lcneighbour = layout_cell_get_neighbour(lc);
|
|
if (lcneighbour == NULL) {
|
|
if (lc->parent != NULL)
|
|
layout_remove_tile(w, lc->parent);
|
|
} else if ((lcparent = lcneighbour->parent) != NULL) {
|
|
type = lcparent->type;
|
|
/*
|
|
* Adding the size of the layout cell plus its border to the
|
|
* neighbour.
|
|
*/
|
|
if (type == LAYOUT_TOPBOTTOM)
|
|
change = lc->sy + 1;
|
|
else
|
|
change = lc->sx + 1;
|
|
layout_resize_adjust(w, lcneighbour, type, change);
|
|
}
|
|
|
|
/* Zeroing out the cell geometry until the cell is retiled. */
|
|
layout_set_size(lc, 0, 0, 0, 0);
|
|
return (1);
|
|
}
|