Annotation of src/usr.bin/tmux/layout-custom.c, Revision 1.22
1.22 ! nicm 1: /* $OpenBSD: layout-custom.c,v 1.21 2022/05/30 12:52:02 nicm Exp $ */
1.1 nicm 2:
3: /*
1.8 nicm 4: * Copyright (c) 2010 Nicholas Marriott <nicholas.marriott@gmail.com>
1.1 nicm 5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15: * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <sys/types.h>
20:
21: #include <ctype.h>
22: #include <string.h>
23:
24: #include "tmux.h"
25:
1.9 nicm 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 *);
1.2 nicm 34:
35: /* Find the bottom-right cell. */
1.9 nicm 36: static struct layout_cell *
1.2 nicm 37: layout_find_bottomright(struct layout_cell *lc)
38: {
39: if (lc->type == LAYOUT_WINDOWPANE)
40: return (lc);
41: lc = TAILQ_LAST(&lc->cells, layout_cells);
42: return (layout_find_bottomright(lc));
43: }
1.1 nicm 44:
45: /* Calculate layout checksum. */
1.9 nicm 46: static u_short
1.1 nicm 47: layout_checksum(const char *layout)
48: {
49: u_short csum;
50:
51: csum = 0;
52: for (; *layout != '\0'; layout++) {
53: csum = (csum >> 1) + ((csum & 1) << 15);
54: csum += *layout;
55: }
56: return (csum);
57: }
58:
59: /* Dump layout as a string. */
60: char *
1.7 nicm 61: layout_dump(struct layout_cell *root)
1.1 nicm 62: {
1.16 nicm 63: char layout[8192], *out;
1.1 nicm 64:
65: *layout = '\0';
1.7 nicm 66: if (layout_append(root, layout, sizeof layout) != 0)
1.1 nicm 67: return (NULL);
68:
1.9 nicm 69: xasprintf(&out, "%04hx,%s", layout_checksum(layout), layout);
1.1 nicm 70: return (out);
71: }
72:
73: /* Append information for a single cell. */
1.9 nicm 74: static int
1.1 nicm 75: layout_append(struct layout_cell *lc, char *buf, size_t len)
76: {
77: struct layout_cell *lcchild;
78: char tmp[64];
79: size_t tmplen;
80: const char *brackets = "][";
81:
82: if (len == 0)
83: return (-1);
84:
1.3 nicm 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);
91: }
1.1 nicm 92: if (tmplen > (sizeof tmp) - 1)
93: return (-1);
94: if (strlcat(buf, tmp, len) >= len)
95: return (-1);
96:
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);
109: }
110: buf[strlen(buf) - 1] = brackets[0];
111: break;
112: case LAYOUT_WINDOWPANE:
113: break;
114: }
115:
116: return (0);
117: }
118:
1.17 nicm 119: /* Check layout sizes fit. */
120: static int
121: layout_check(struct layout_cell *lc)
122: {
123: struct layout_cell *lcchild;
124: u_int n = 0;
125:
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;
136: }
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;
147: }
148: if (n - 1 != lc->sy)
149: return (0);
150: break;
151: }
152: return (1);
153: }
154:
1.1 nicm 155: /* Parse a layout string and arrange window as layout. */
156: int
1.21 nicm 157: layout_parse(struct window *w, const char *layout, char **cause)
1.1 nicm 158: {
159: struct layout_cell *lc, *lcchild;
160: struct window_pane *wp;
1.17 nicm 161: u_int npanes, ncells, sx = 0, sy = 0;
1.1 nicm 162: u_short csum;
163:
164: /* Check validity. */
1.22 ! nicm 165: if (sscanf(layout, "%hx,", &csum) != 1) {
! 166: *cause = xstrdup("invalid layout");
1.1 nicm 167: return (-1);
1.22 ! nicm 168: }
1.1 nicm 169: layout += 5;
1.21 nicm 170: if (csum != layout_checksum(layout)) {
171: *cause = xstrdup("invalid layout");
1.1 nicm 172: return (-1);
1.21 nicm 173: }
1.1 nicm 174:
175: /* Build the layout. */
176: lc = layout_construct(NULL, &layout);
1.21 nicm 177: if (lc == NULL) {
178: *cause = xstrdup("invalid layout");
1.1 nicm 179: return (-1);
1.21 nicm 180: }
181: if (*layout != '\0') {
182: *cause = xstrdup("invalid layout");
1.1 nicm 183: goto fail;
1.21 nicm 184: }
1.1 nicm 185:
186: /* Check this window will fit into the layout. */
187: for (;;) {
188: npanes = window_count_panes(w);
189: ncells = layout_count_cells(lc);
1.21 nicm 190: if (npanes > ncells) {
191: xasprintf(cause, "have %u panes but need %u", npanes,
192: ncells);
1.1 nicm 193: goto fail;
1.21 nicm 194: }
1.1 nicm 195: if (npanes == ncells)
196: break;
197:
198: /* Fewer panes than cells - close the bottom right. */
199: lcchild = layout_find_bottomright(lc);
1.10 nicm 200: layout_destroy_cell(w, lcchild, &lc);
1.1 nicm 201: }
1.17 nicm 202:
203: /*
204: * It appears older versions of tmux were able to generate layouts with
205: * an incorrect top cell size - if it is larger than the top child then
206: * correct that (if this is still wrong the check code will catch it).
207: */
208: switch (lc->type) {
209: case LAYOUT_WINDOWPANE:
210: break;
211: case LAYOUT_LEFTRIGHT:
212: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
213: sy = lcchild->sy + 1;
214: sx += lcchild->sx + 1;
215: }
216: break;
217: case LAYOUT_TOPBOTTOM:
218: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
219: sx = lcchild->sx + 1;
220: sy += lcchild->sy + 1;
221: }
222: break;
223: }
1.18 nicm 224: if (lc->type != LAYOUT_WINDOWPANE && (lc->sx != sx || lc->sy != sy)) {
1.17 nicm 225: log_debug("fix layout %u,%u to %u,%u", lc->sx, lc->sy, sx,sy);
226: layout_print_cell(lc, __func__, 0);
227: lc->sx = sx - 1; lc->sy = sy - 1;
228: }
229:
230: /* Check the new layout. */
1.21 nicm 231: if (!layout_check(lc)) {
232: *cause = xstrdup("size mismatch after applying layout");
1.17 nicm 233: return (-1);
1.21 nicm 234: }
1.1 nicm 235:
1.14 nicm 236: /* Resize to the layout size. */
1.19 nicm 237: window_resize(w, lc->sx, lc->sy, -1, -1);
1.1 nicm 238:
239: /* Destroy the old layout and swap to the new. */
240: layout_free_cell(w->layout_root);
241: w->layout_root = lc;
242:
243: /* Assign the panes into the cells. */
244: wp = TAILQ_FIRST(&w->panes);
245: layout_assign(&wp, lc);
246:
247: /* Update pane offsets and sizes. */
1.15 nicm 248: layout_fix_offsets(w);
1.20 nicm 249: layout_fix_panes(w, NULL);
1.13 nicm 250: recalculate_sizes();
1.1 nicm 251:
252: layout_print_cell(lc, __func__, 0);
1.5 nicm 253:
1.11 nicm 254: notify_window("window-layout-changed", w);
1.1 nicm 255:
256: return (0);
257:
258: fail:
259: layout_free_cell(lc);
260: return (-1);
261: }
262:
263: /* Assign panes into cells. */
1.9 nicm 264: static void
1.1 nicm 265: layout_assign(struct window_pane **wp, struct layout_cell *lc)
266: {
267: struct layout_cell *lcchild;
268:
269: switch (lc->type) {
270: case LAYOUT_WINDOWPANE:
271: layout_make_leaf(lc, *wp);
272: *wp = TAILQ_NEXT(*wp, entry);
273: return;
274: case LAYOUT_LEFTRIGHT:
275: case LAYOUT_TOPBOTTOM:
276: TAILQ_FOREACH(lcchild, &lc->cells, entry)
277: layout_assign(wp, lcchild);
278: return;
279: }
280: }
281:
282: /* Construct a cell from all or part of a layout tree. */
1.9 nicm 283: static struct layout_cell *
1.1 nicm 284: layout_construct(struct layout_cell *lcparent, const char **layout)
285: {
286: struct layout_cell *lc, *lcchild;
287: u_int sx, sy, xoff, yoff;
1.6 nicm 288: const char *saved;
1.1 nicm 289:
290: if (!isdigit((u_char) **layout))
291: return (NULL);
1.6 nicm 292: if (sscanf(*layout, "%ux%u,%u,%u", &sx, &sy, &xoff, &yoff) != 4)
1.1 nicm 293: return (NULL);
294:
295: while (isdigit((u_char) **layout))
296: (*layout)++;
297: if (**layout != 'x')
298: return (NULL);
299: (*layout)++;
300: while (isdigit((u_char) **layout))
301: (*layout)++;
302: if (**layout != ',')
303: return (NULL);
304: (*layout)++;
305: while (isdigit((u_char) **layout))
306: (*layout)++;
307: if (**layout != ',')
308: return (NULL);
309: (*layout)++;
310: while (isdigit((u_char) **layout))
311: (*layout)++;
1.3 nicm 312: if (**layout == ',') {
1.6 nicm 313: saved = *layout;
1.3 nicm 314: (*layout)++;
315: while (isdigit((u_char) **layout))
316: (*layout)++;
1.6 nicm 317: if (**layout == 'x')
318: *layout = saved;
1.3 nicm 319: }
1.1 nicm 320:
321: lc = layout_create_cell(lcparent);
322: lc->sx = sx;
323: lc->sy = sy;
324: lc->xoff = xoff;
325: lc->yoff = yoff;
326:
327: switch (**layout) {
328: case ',':
329: case '}':
330: case ']':
331: case '\0':
332: return (lc);
333: case '{':
334: lc->type = LAYOUT_LEFTRIGHT;
335: break;
336: case '[':
337: lc->type = LAYOUT_TOPBOTTOM;
338: break;
339: default:
340: goto fail;
341: }
342:
343: do {
344: (*layout)++;
345: lcchild = layout_construct(lc, layout);
346: if (lcchild == NULL)
347: goto fail;
348: TAILQ_INSERT_TAIL(&lc->cells, lcchild, entry);
349: } while (**layout == ',');
350:
351: switch (lc->type) {
352: case LAYOUT_LEFTRIGHT:
353: if (**layout != '}')
354: goto fail;
355: break;
356: case LAYOUT_TOPBOTTOM:
357: if (**layout != ']')
358: goto fail;
359: break;
360: default:
361: goto fail;
362: }
363: (*layout)++;
364:
365: return (lc);
366:
367: fail:
368: layout_free_cell(lc);
369: return (NULL);
370: }
![[BACK]](/icons/back.gif){kind=icon}
Return to layout-custom.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux