tmux/layout.c
Nicholas Marriott d210d99cce Make mouse event structure clearer by defining events (up, click, drag)
and simplifying how buttons and wheels are represented, from Ailin
Nemui. Should be no functional changes.
2012-10-26 14:35:42 +00:00

821 lines
20 KiB
C

/* $OpenBSD$ */
/*
* Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.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 <string.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.
*/
int layout_resize_pane_grow(struct layout_cell *, enum layout_type, int);
int layout_resize_pane_shrink(struct layout_cell *, enum layout_type, int);
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;
log_debug(
"%s:%*s%p type %u [parent %p] wp=%p [%u,%u %ux%u]", hdr, n, " ", lc,
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;
}
}
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 based on their sizes. */
void
layout_fix_offsets(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_offsets(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_offsets(lcchild);
yoff += lcchild->sy + 1;
}
}
}
/* Update pane offsets and sizes based on their cells. */
void
layout_fix_panes(struct window *w, u_int wsx, u_int wsy)
{
struct window_pane *wp;
struct layout_cell *lc;
u_int sx, sy;
TAILQ_FOREACH(wp, &w->panes, entry) {
if ((lc = wp->layout_cell) == NULL)
continue;
wp->xoff = lc->xoff;
wp->yoff = lc->yoff;
/*
* Layout cells are limited by the smallest size of other cells
* within the same row or column; if this isn't the case
* resizing becomes difficult.
*
* However, panes do not have to take up their entire cell, so
* they can be cropped to the window edge if the layout
* overflows and they are partly visible.
*
* This stops cells being hidden unnecessarily.
*/
/*
* Work out the horizontal size. If the pane is actually
* outside the window or the entire pane is already visible,
* don't crop.
*/
if (lc->xoff >= wsx || lc->xoff + lc->sx < wsx)
sx = lc->sx;
else {
sx = wsx - lc->xoff;
if (sx < 1)
sx = lc->sx;
}
/*
* Similarly for the vertical size; the minimum vertical size
* is two because scroll regions cannot be one line.
*/
if (lc->yoff >= wsy || lc->yoff + lc->sy < wsy)
sy = lc->sy;
else {
sy = wsy - lc->yoff;
if (sy < 2)
sy = lc->sy;
}
window_pane_resize(wp, sx, 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 n;
switch (lc->type) {
case LAYOUT_WINDOWPANE:
return (1);
case LAYOUT_LEFTRIGHT:
case LAYOUT_TOPBOTTOM:
n = 0;
TAILQ_FOREACH(lcchild, &lc->cells, entry)
n += layout_count_cells(lcchild);
return (n);
default:
fatalx("bad layout type");
}
}
/* Calculate how much size is available to be removed from a cell. */
u_int
layout_resize_check(struct layout_cell *lc, enum layout_type type)
{
struct layout_cell *lcchild;
u_int available, minimum;
if (lc->type == LAYOUT_WINDOWPANE) {
/* Space available in this cell only. */
if (type == LAYOUT_LEFTRIGHT)
available = lc->sx;
else
available = lc->sy;
if (available > PANE_MINIMUM)
available -= PANE_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(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(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 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(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(lcchild, type, 1);
change--;
continue;
}
if (layout_resize_check(lcchild, type) > 0) {
layout_resize_adjust(lcchild, type, -1);
change++;
}
}
}
}
/* Destroy a cell and redistribute the space. */
void
layout_destroy_cell(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 (lcparent->type == LAYOUT_LEFTRIGHT)
layout_resize_adjust(lcother, lcparent->type, lc->sx + 1);
else
layout_resize_adjust(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 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, TAILQ_FIRST(&w->panes));
layout_fix_panes(w, w->sx, w->sy);
}
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 - w->sx;
xlimit = layout_resize_check(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(lc, LAYOUT_LEFTRIGHT, xchange);
/* Adjust vertically in a similar fashion. */
ychange = sy - w->sy;
ylimit = layout_resize_check(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(lc, LAYOUT_TOPBOTTOM, ychange);
/* Fix cell offsets. */
layout_fix_offsets(lc);
layout_fix_panes(w, sx, sy);
}
/* Resize a single pane within the layout. */
void
layout_resize_pane(struct window_pane *wp, enum layout_type type, int change)
{
struct layout_cell *lc, *lcparent;
int needed, 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;
/* If this is the last cell, move back one. */
if (lc == TAILQ_LAST(&lcparent->cells, layout_cells))
lc = TAILQ_PREV(lc, layout_cells, entry);
/* Grow or shrink the cell. */
needed = change;
while (needed != 0) {
if (change > 0) {
size = layout_resize_pane_grow(lc, type, needed);
needed -= size;
} else {
size = layout_resize_pane_shrink(lc, type, needed);
needed += size;
}
if (size == 0) /* no more change possible */
break;
}
/* Fix cell offsets. */
layout_fix_offsets(wp->window->layout_root);
layout_fix_panes(wp->window, wp->window->sx, wp->window->sy);
notify_window_layout_changed(wp->window);
}
void
layout_resize_pane_mouse(struct client *c)
{
struct window *w;
struct window_pane *wp;
struct mouse_event *m = &c->tty.mouse;
int pane_border;
w = c->session->curw->window;
pane_border = 0;
if (m->event & MOUSE_EVENT_DRAG && m->flags & MOUSE_RESIZE_PANE) {
TAILQ_FOREACH(wp, &w->panes, entry) {
if (wp->xoff + wp->sx == m->lx &&
wp->yoff <= 1 + m->ly &&
wp->yoff + wp->sy >= m->ly) {
layout_resize_pane(wp, LAYOUT_LEFTRIGHT,
m->x - m->lx);
pane_border = 1;
}
if (wp->yoff + wp->sy == m->ly &&
wp->xoff <= 1 + m->lx &&
wp->xoff + wp->sx >= m->lx) {
layout_resize_pane(wp, LAYOUT_TOPBOTTOM,
m->y - m->ly);
pane_border = 1;
}
}
if (pane_border)
server_redraw_window(w);
} else if (~m->event & MOUSE_EVENT_UP) {
TAILQ_FOREACH(wp, &w->panes, entry) {
if ((wp->xoff + wp->sx == m->x &&
wp->yoff <= 1 + m->y &&
wp->yoff + wp->sy >= m->y) ||
(wp->yoff + wp->sy == m->y &&
wp->xoff <= 1 + m->x &&
wp->xoff + wp->sx >= m->x)) {
pane_border = 1;
}
}
}
if (pane_border)
m->flags |= MOUSE_RESIZE_PANE;
else
m->flags &= ~MOUSE_RESIZE_PANE;
}
int
layout_resize_pane_grow(
struct layout_cell *lc, enum layout_type type, int needed)
{
struct layout_cell *lcadd, *lcremove;
u_int size;
/* 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(lcremove, type);
if (size > 0)
break;
lcremove = TAILQ_NEXT(lcremove, entry);
}
/* If none found, look towards the head. */
if (lcremove == NULL) {
lcremove = TAILQ_PREV(lc, layout_cells, entry);
while (lcremove != NULL) {
size = layout_resize_check(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(lcadd, type, size);
layout_resize_adjust(lcremove, type, -size);
return (size);
}
int
layout_resize_pane_shrink(
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(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(lcadd, type, size);
layout_resize_adjust(lcremove, type, -size);
return (size);
}
/* Assign window pane to newly split cell. */
void
layout_assign_pane(struct layout_cell *lc, struct window_pane *wp)
{
layout_make_leaf(lc, wp);
layout_fix_panes(wp->window, wp->window->sx, wp->window->sy);
}
/*
* 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 insert_before)
{
struct layout_cell *lc, *lcparent, *lcnew, *lc1, *lc2;
u_int sx, sy, xoff, yoff, size1, size2;
lc = wp->layout_cell;
/* 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 (sy < PANE_MINIMUM * 2 + 1)
return (NULL);
break;
default:
fatalx("bad layout type");
}
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.
*/
/* Create the new child cell. */
lcparent = lc->parent;
lcnew = layout_create_cell(lcparent);
if (insert_before)
TAILQ_INSERT_BEFORE(lc, lcnew, entry);
else
TAILQ_INSERT_AFTER(&lcparent->cells, lc, 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 (insert_before)
TAILQ_INSERT_HEAD(&lcparent->cells, lcnew, entry);
else
TAILQ_INSERT_TAIL(&lcparent->cells, lcnew, entry);
}
if (insert_before) {
lc1 = lcnew;
lc2 = lc;
} else {
lc1 = lc;
lc2 = lcnew;
}
/* Set 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.
*/
switch (type) {
case LAYOUT_LEFTRIGHT:
if (size < 0)
size2 = ((sx + 1) / 2) - 1;
else
size2 = size;
if (size2 < PANE_MINIMUM)
size2 = PANE_MINIMUM;
else if (size2 > sx - 2)
size2 = sx - 2;
size1 = sx - 1 - size2;
layout_set_size(lc1, size1, sy, xoff, yoff);
layout_set_size(lc2, size2, sy, xoff + lc1->sx + 1, yoff);
break;
case LAYOUT_TOPBOTTOM:
if (size < 0)
size2 = ((sy + 1) / 2) - 1;
else
size2 = size;
if (size2 < PANE_MINIMUM)
size2 = PANE_MINIMUM;
else if (size2 > sy - 2)
size2 = sy - 2;
size1 = sy - 1 - size2;
layout_set_size(lc1, sx, size1, xoff, yoff);
layout_set_size(lc2, sx, size2, xoff, yoff + lc1->sy + 1);
break;
default:
fatalx("bad layout type");
}
/* Assign the panes. */
layout_make_leaf(lc, wp);
return (lcnew);
}
/* Destroy the cell associated with a pane. */
void
layout_close_pane(struct window_pane *wp)
{
/* Remove the cell. */
layout_destroy_cell(wp->layout_cell, &wp->window->layout_root);
/* Fix pane offsets and sizes. */
if (wp->window->layout_root != NULL) {
layout_fix_offsets(wp->window->layout_root);
layout_fix_panes(wp->window, wp->window->sx, wp->window->sy);
}
notify_window_layout_changed(wp->window);
}
/* Add layout to list. */
void
layout_list_add(struct window *w)
{
struct last_layout *ll, *ll_last;
char *layout;
u_int limit;
layout = layout_dump(w);
ll_last = w->layout_list_last;
if (ll_last != NULL && strcmp(ll_last->layout, layout) == 0) {
free(layout);
return;
}
ll = xmalloc(sizeof *ll);
ll->layout = layout;
if (ll_last == NULL)
TAILQ_INSERT_TAIL(&w->layout_list, ll, entry);
else
TAILQ_INSERT_AFTER(&w->layout_list, ll_last, ll, entry);
w->layout_list_size++;
w->layout_list_last = ll;
limit = options_get_number(&w->options, "layout-history-limit");
while (w->layout_list_size > limit) {
ll = TAILQ_LAST(&w->layout_list, last_layouts);
if (ll == w->layout_list_last)
ll = TAILQ_FIRST(&w->layout_list);
TAILQ_REMOVE(&w->layout_list, ll, entry);
w->layout_list_size--;
free(ll->layout);
free(ll);
}
}
/* Apply next layout from list. */
const char *
layout_list_redo(struct window *w)
{
struct last_layout *ll, *ll_last;
ll_last = w->layout_list_last;
if (ll_last == NULL)
return (NULL);
ll = TAILQ_NEXT(ll_last, entry);
if (ll == NULL)
return (NULL);
w->layout_list_last = ll;
return (ll->layout);
}
/* Apply previous layout from list. */
const char *
layout_list_undo(struct window *w)
{
struct last_layout *ll, *ll_last;
ll_last = w->layout_list_last;
if (ll_last == NULL)
return (NULL);
ll = TAILQ_PREV(ll_last, last_layouts, entry);
if (ll == NULL)
return (NULL);
w->layout_list_last = ll;
return (ll->layout);
}