Annotation of src/usr.bin/tmux/layout-custom.c, Revision 1.1
1.1 ! nicm 1: /* $OpenBSD: layout-set.c,v 1.6 2010/04/25 20:28:13 nicm Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2010 Nicholas Marriott <nicm@users.sourceforge.net>
! 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:
! 26: u_short layout_checksum(const char *);
! 27: int layout_append(struct layout_cell *, char *, size_t);
! 28: struct layout_cell *layout_construct(struct layout_cell *, const char **);
! 29: void layout_assign(struct window_pane **, struct layout_cell *);
! 30:
! 31: /* Calculate layout checksum. */
! 32: u_short
! 33: layout_checksum(const char *layout)
! 34: {
! 35: u_short csum;
! 36:
! 37: csum = 0;
! 38: for (; *layout != '\0'; layout++) {
! 39: csum = (csum >> 1) + ((csum & 1) << 15);
! 40: csum += *layout;
! 41: }
! 42: return (csum);
! 43: }
! 44:
! 45: /* Dump layout as a string. */
! 46: char *
! 47: layout_dump(struct window *w)
! 48: {
! 49: char layout[BUFSIZ], *out;
! 50:
! 51: *layout = '\0';
! 52: if (layout_append(w->layout_root, layout, sizeof layout) != 0)
! 53: return (NULL);
! 54:
! 55: xasprintf(&out, "%4x,%s", layout_checksum(layout), layout);
! 56: return (out);
! 57: }
! 58:
! 59: /* Append information for a single cell. */
! 60: int
! 61: layout_append(struct layout_cell *lc, char *buf, size_t len)
! 62: {
! 63: struct layout_cell *lcchild;
! 64: char tmp[64];
! 65: size_t tmplen;
! 66: const char *brackets = "][";
! 67:
! 68: if (len == 0)
! 69: return (-1);
! 70:
! 71: tmplen = xsnprintf(tmp, sizeof tmp,
! 72: "%ux%u,%u,%u", lc->sx, lc->sy, lc->xoff, lc->yoff);
! 73: if (tmplen > (sizeof tmp) - 1)
! 74: return (-1);
! 75: if (strlcat(buf, tmp, len) >= len)
! 76: return (-1);
! 77:
! 78: switch (lc->type) {
! 79: case LAYOUT_LEFTRIGHT:
! 80: brackets = "}{";
! 81: /* FALLTHROUGH */
! 82: case LAYOUT_TOPBOTTOM:
! 83: if (strlcat(buf, &brackets[1], len) >= len)
! 84: return (-1);
! 85: TAILQ_FOREACH(lcchild, &lc->cells, entry) {
! 86: if (layout_append(lcchild, buf, len) != 0)
! 87: return (-1);
! 88: if (strlcat(buf, ",", len) >= len)
! 89: return (-1);
! 90: }
! 91: buf[strlen(buf) - 1] = brackets[0];
! 92: break;
! 93: case LAYOUT_WINDOWPANE:
! 94: break;
! 95: }
! 96:
! 97: return (0);
! 98: }
! 99:
! 100: /* Parse a layout string and arrange window as layout. */
! 101: int
! 102: layout_parse(struct window *w, const char *layout)
! 103: {
! 104: struct layout_cell *lc, *lcchild;
! 105: struct window_pane *wp;
! 106: u_int npanes, ncells, sx, sy;
! 107: u_short csum;
! 108:
! 109: /* Check validity. */
! 110: if (sscanf(layout, "%hx,", &csum) != 1)
! 111: return (-1);
! 112: layout += 5;
! 113: if (csum != layout_checksum(layout))
! 114: return (-1);
! 115:
! 116: /* Build the layout. */
! 117: lc = layout_construct(NULL, &layout);
! 118: if (lc == NULL)
! 119: return (-1);
! 120: if (*layout != '\0')
! 121: goto fail;
! 122:
! 123: /* Check this window will fit into the layout. */
! 124: for (;;) {
! 125: npanes = window_count_panes(w);
! 126: ncells = layout_count_cells(lc);
! 127: if (npanes > ncells)
! 128: goto fail;
! 129: if (npanes == ncells)
! 130: break;
! 131:
! 132: /* Fewer panes than cells - close the bottom right. */
! 133: lcchild = layout_find_bottomright(lc);
! 134: layout_destroy_cell(lcchild, &lc);
! 135: }
! 136:
! 137: /* Save the old window size and resize to the layout size. */
! 138: sx = w->sx; sy = w->sy;
! 139: window_resize(w, lc->sx, lc->sy);
! 140:
! 141: /* Destroy the old layout and swap to the new. */
! 142: layout_free_cell(w->layout_root);
! 143: w->layout_root = lc;
! 144:
! 145: /* Assign the panes into the cells. */
! 146: wp = TAILQ_FIRST(&w->panes);
! 147: layout_assign(&wp, lc);
! 148:
! 149: /* Update pane offsets and sizes. */
! 150: layout_fix_offsets(lc);
! 151: layout_fix_panes(w, lc->sx, lc->sy);
! 152:
! 153: /* Then resize the layout back to the original window size. */
! 154: layout_resize(w, sx, sy);
! 155: window_resize(w, sx, sy);
! 156:
! 157: layout_print_cell(lc, __func__, 0);
! 158:
! 159: return (0);
! 160:
! 161: fail:
! 162: layout_free_cell(lc);
! 163: return (-1);
! 164: }
! 165:
! 166: /* Assign panes into cells. */
! 167: void
! 168: layout_assign(struct window_pane **wp, struct layout_cell *lc)
! 169: {
! 170: struct layout_cell *lcchild;
! 171:
! 172: switch (lc->type) {
! 173: case LAYOUT_WINDOWPANE:
! 174: layout_make_leaf(lc, *wp);
! 175: *wp = TAILQ_NEXT(*wp, entry);
! 176: return;
! 177: case LAYOUT_LEFTRIGHT:
! 178: case LAYOUT_TOPBOTTOM:
! 179: TAILQ_FOREACH(lcchild, &lc->cells, entry)
! 180: layout_assign(wp, lcchild);
! 181: return;
! 182: }
! 183: }
! 184:
! 185: /* Construct a cell from all or part of a layout tree. */
! 186: struct layout_cell *
! 187: layout_construct(struct layout_cell *lcparent, const char **layout)
! 188: {
! 189: struct layout_cell *lc, *lcchild;
! 190: u_int sx, sy, xoff, yoff;
! 191:
! 192: if (!isdigit((u_char) **layout))
! 193: return (NULL);
! 194: if (sscanf(*layout, "%ux%u,%u,%u", &sx, &sy, &xoff, &yoff) != 4)
! 195: return (NULL);
! 196:
! 197: while (isdigit((u_char) **layout))
! 198: (*layout)++;
! 199: if (**layout != 'x')
! 200: return (NULL);
! 201: (*layout)++;
! 202: while (isdigit((u_char) **layout))
! 203: (*layout)++;
! 204: if (**layout != ',')
! 205: return (NULL);
! 206: (*layout)++;
! 207: while (isdigit((u_char) **layout))
! 208: (*layout)++;
! 209: if (**layout != ',')
! 210: return (NULL);
! 211: (*layout)++;
! 212: while (isdigit((u_char) **layout))
! 213: (*layout)++;
! 214:
! 215: lc = layout_create_cell(lcparent);
! 216: lc->sx = sx;
! 217: lc->sy = sy;
! 218: lc->xoff = xoff;
! 219: lc->yoff = yoff;
! 220:
! 221: switch (**layout) {
! 222: case ',':
! 223: case '}':
! 224: case ']':
! 225: case '\0':
! 226: return (lc);
! 227: case '{':
! 228: lc->type = LAYOUT_LEFTRIGHT;
! 229: break;
! 230: case '[':
! 231: lc->type = LAYOUT_TOPBOTTOM;
! 232: break;
! 233: default:
! 234: goto fail;
! 235: }
! 236:
! 237: do {
! 238: (*layout)++;
! 239: lcchild = layout_construct(lc, layout);
! 240: if (lcchild == NULL)
! 241: goto fail;
! 242: TAILQ_INSERT_TAIL(&lc->cells, lcchild, entry);
! 243: } while (**layout == ',');
! 244:
! 245: switch (lc->type) {
! 246: case LAYOUT_LEFTRIGHT:
! 247: if (**layout != '}')
! 248: goto fail;
! 249: break;
! 250: case LAYOUT_TOPBOTTOM:
! 251: if (**layout != ']')
! 252: goto fail;
! 253: break;
! 254: default:
! 255: goto fail;
! 256: }
! 257: (*layout)++;
! 258:
! 259: return (lc);
! 260:
! 261: fail:
! 262: layout_free_cell(lc);
! 263: return (NULL);
! 264: }
![[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