Add a -T flag to capture-pane to stop at the last used cell instead of
[tmux-openbsd.git] / layout-custom.c
blob932b30e752ba9a0c936dce8b2dfcac74d7194b86
1 /* $OpenBSD$ */
3 /*
4 * Copyright (c) 2010 Nicholas Marriott <nicholas.marriott@gmail.com>
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 #include <sys/types.h>
21 #include <ctype.h>
22 #include <string.h>
24 #include "tmux.h"
26 static struct layout_cell *layout_find_bottomright(struct layout_cell *);
27 static u_short layout_checksum(const char *);
28 static int layout_append(struct layout_cell *, char *,
29 size_t);
30 static struct layout_cell *layout_construct(struct layout_cell *,
31 const char **);
32 static void layout_assign(struct window_pane **,
33 struct layout_cell *);
35 /* Find the bottom-right cell. */
36 static struct layout_cell *
37 layout_find_bottomright(struct layout_cell *lc)
39 if (lc->type == LAYOUT_WINDOWPANE)
40 return (lc);
41 lc = TAILQ_LAST(&lc->cells, layout_cells);
42 return (layout_find_bottomright(lc));
45 /* Calculate layout checksum. */
46 static u_short
47 layout_checksum(const char *layout)
49 u_short csum;
51 csum = 0;
52 for (; *layout != '\0'; layout++) {
53 csum = (csum >> 1) + ((csum & 1) << 15);
54 csum += *layout;
56 return (csum);
59 /* Dump layout as a string. */
60 char *
61 layout_dump(struct layout_cell *root)
63 char layout[8192], *out;
65 *layout = '\0';
66 if (layout_append(root, layout, sizeof layout) != 0)
67 return (NULL);
69 xasprintf(&out, "%04hx,%s", layout_checksum(layout), layout);
70 return (out);
73 /* Append information for a single cell. */
74 static int
75 layout_append(struct layout_cell *lc, char *buf, size_t len)
77 struct layout_cell *lcchild;
78 char tmp[64];
79 size_t tmplen;
80 const char *brackets = "][";
82 if (len == 0)
83 return (-1);
85 if (lc->wp != NULL) {
86 tmplen = xsnprintf(tmp, sizeof tmp, "%ux%u,%u,%u,%u",
87 lc->sx, lc->sy, lc->xoff, lc->yoff, lc->wp->id);
88 } else {
89 tmplen = xsnprintf(tmp, sizeof tmp, "%ux%u,%u,%u",
90 lc->sx, lc->sy, lc->xoff, lc->yoff);
92 if (tmplen > (sizeof tmp) - 1)
93 return (-1);
94 if (strlcat(buf, tmp, len) >= len)
95 return (-1);
97 switch (lc->type) {
98 case LAYOUT_LEFTRIGHT:
99 brackets = "}{";
100 /* FALLTHROUGH */
101 case LAYOUT_TOPBOTTOM:
102 if (strlcat(buf, &brackets[1], len) >= len)
103 return (-1);
104 TAILQ_FOREACH(lcchild, &lc->cells, entry) {
105 if (layout_append(lcchild, buf, len) != 0)
106 return (-1);
107 if (strlcat(buf, ",", len) >= len)
108 return (-1);
110 buf[strlen(buf) - 1] = brackets[0];
111 break;
112 case LAYOUT_WINDOWPANE:
113 break;
116 return (0);
119 /* Check layout sizes fit. */
120 static int
121 layout_check(struct layout_cell *lc)
123 struct layout_cell *lcchild;
124 u_int n = 0;
126 switch (lc->type) {
127 case LAYOUT_WINDOWPANE:
128 break;
129 case LAYOUT_LEFTRIGHT:
130 TAILQ_FOREACH(lcchild, &lc->cells, entry) {
131 if (lcchild->sy != lc->sy)
132 return (0);
133 if (!layout_check(lcchild))
134 return (0);
135 n += lcchild->sx + 1;
137 if (n - 1 != lc->sx)
138 return (0);
139 break;
140 case LAYOUT_TOPBOTTOM:
141 TAILQ_FOREACH(lcchild, &lc->cells, entry) {
142 if (lcchild->sx != lc->sx)
143 return (0);
144 if (!layout_check(lcchild))
145 return (0);
146 n += lcchild->sy + 1;
148 if (n - 1 != lc->sy)
149 return (0);
150 break;
152 return (1);
155 /* Parse a layout string and arrange window as layout. */
157 layout_parse(struct window *w, const char *layout, char **cause)
159 struct layout_cell *lc, *lcchild;
160 struct window_pane *wp;
161 u_int npanes, ncells, sx = 0, sy = 0;
162 u_short csum;
164 /* Check validity. */
165 if (sscanf(layout, "%hx,", &csum) != 1)
166 return (-1);
167 layout += 5;
168 if (csum != layout_checksum(layout)) {
169 *cause = xstrdup("invalid layout");
170 return (-1);
173 /* Build the layout. */
174 lc = layout_construct(NULL, &layout);
175 if (lc == NULL) {
176 *cause = xstrdup("invalid layout");
177 return (-1);
179 if (*layout != '\0') {
180 *cause = xstrdup("invalid layout");
181 goto fail;
184 /* Check this window will fit into the layout. */
185 for (;;) {
186 npanes = window_count_panes(w);
187 ncells = layout_count_cells(lc);
188 if (npanes > ncells) {
189 xasprintf(cause, "have %u panes but need %u", npanes,
190 ncells);
191 goto fail;
193 if (npanes == ncells)
194 break;
196 /* Fewer panes than cells - close the bottom right. */
197 lcchild = layout_find_bottomright(lc);
198 layout_destroy_cell(w, lcchild, &lc);
202 * It appears older versions of tmux were able to generate layouts with
203 * an incorrect top cell size - if it is larger than the top child then
204 * correct that (if this is still wrong the check code will catch it).
206 switch (lc->type) {
207 case LAYOUT_WINDOWPANE:
208 break;
209 case LAYOUT_LEFTRIGHT:
210 TAILQ_FOREACH(lcchild, &lc->cells, entry) {
211 sy = lcchild->sy + 1;
212 sx += lcchild->sx + 1;
214 break;
215 case LAYOUT_TOPBOTTOM:
216 TAILQ_FOREACH(lcchild, &lc->cells, entry) {
217 sx = lcchild->sx + 1;
218 sy += lcchild->sy + 1;
220 break;
222 if (lc->type != LAYOUT_WINDOWPANE && (lc->sx != sx || lc->sy != sy)) {
223 log_debug("fix layout %u,%u to %u,%u", lc->sx, lc->sy, sx,sy);
224 layout_print_cell(lc, __func__, 0);
225 lc->sx = sx - 1; lc->sy = sy - 1;
228 /* Check the new layout. */
229 if (!layout_check(lc)) {
230 *cause = xstrdup("size mismatch after applying layout");
231 return (-1);
234 /* Resize to the layout size. */
235 window_resize(w, lc->sx, lc->sy, -1, -1);
237 /* Destroy the old layout and swap to the new. */
238 layout_free_cell(w->layout_root);
239 w->layout_root = lc;
241 /* Assign the panes into the cells. */
242 wp = TAILQ_FIRST(&w->panes);
243 layout_assign(&wp, lc);
245 /* Update pane offsets and sizes. */
246 layout_fix_offsets(w);
247 layout_fix_panes(w, NULL);
248 recalculate_sizes();
250 layout_print_cell(lc, __func__, 0);
252 notify_window("window-layout-changed", w);
254 return (0);
256 fail:
257 layout_free_cell(lc);
258 return (-1);
261 /* Assign panes into cells. */
262 static void
263 layout_assign(struct window_pane **wp, struct layout_cell *lc)
265 struct layout_cell *lcchild;
267 switch (lc->type) {
268 case LAYOUT_WINDOWPANE:
269 layout_make_leaf(lc, *wp);
270 *wp = TAILQ_NEXT(*wp, entry);
271 return;
272 case LAYOUT_LEFTRIGHT:
273 case LAYOUT_TOPBOTTOM:
274 TAILQ_FOREACH(lcchild, &lc->cells, entry)
275 layout_assign(wp, lcchild);
276 return;
280 /* Construct a cell from all or part of a layout tree. */
281 static struct layout_cell *
282 layout_construct(struct layout_cell *lcparent, const char **layout)
284 struct layout_cell *lc, *lcchild;
285 u_int sx, sy, xoff, yoff;
286 const char *saved;
288 if (!isdigit((u_char) **layout))
289 return (NULL);
290 if (sscanf(*layout, "%ux%u,%u,%u", &sx, &sy, &xoff, &yoff) != 4)
291 return (NULL);
293 while (isdigit((u_char) **layout))
294 (*layout)++;
295 if (**layout != 'x')
296 return (NULL);
297 (*layout)++;
298 while (isdigit((u_char) **layout))
299 (*layout)++;
300 if (**layout != ',')
301 return (NULL);
302 (*layout)++;
303 while (isdigit((u_char) **layout))
304 (*layout)++;
305 if (**layout != ',')
306 return (NULL);
307 (*layout)++;
308 while (isdigit((u_char) **layout))
309 (*layout)++;
310 if (**layout == ',') {
311 saved = *layout;
312 (*layout)++;
313 while (isdigit((u_char) **layout))
314 (*layout)++;
315 if (**layout == 'x')
316 *layout = saved;
319 lc = layout_create_cell(lcparent);
320 lc->sx = sx;
321 lc->sy = sy;
322 lc->xoff = xoff;
323 lc->yoff = yoff;
325 switch (**layout) {
326 case ',':
327 case '}':
328 case ']':
329 case '\0':
330 return (lc);
331 case '{':
332 lc->type = LAYOUT_LEFTRIGHT;
333 break;
334 case '[':
335 lc->type = LAYOUT_TOPBOTTOM;
336 break;
337 default:
338 goto fail;
341 do {
342 (*layout)++;
343 lcchild = layout_construct(lc, layout);
344 if (lcchild == NULL)
345 goto fail;
346 TAILQ_INSERT_TAIL(&lc->cells, lcchild, entry);
347 } while (**layout == ',');
349 switch (lc->type) {
350 case LAYOUT_LEFTRIGHT:
351 if (**layout != '}')
352 goto fail;
353 break;
354 case LAYOUT_TOPBOTTOM:
355 if (**layout != ']')
356 goto fail;
357 break;
358 default:
359 goto fail;
361 (*layout)++;
363 return (lc);
365 fail:
366 layout_free_cell(lc);
367 return (NULL);