Annotation of src/usr.bin/tmux/layout-set.c, Revision 1.7
1.7 ! nicm 1: /* $OpenBSD: layout-set.c,v 1.6 2010/04/25 20:28:13 nicm Exp $ */
1.1 nicm 2:
3: /*
4: * Copyright (c) 2009 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 <string.h>
22:
23: #include "tmux.h"
24:
25: /*
26: * Set window layouts - predefined methods to arrange windows. These are one-off
27: * and generate a layout tree.
28: */
29:
30: void layout_set_even_h(struct window *);
31: void layout_set_even_v(struct window *);
32: void layout_set_main_h(struct window *);
33: void layout_set_main_v(struct window *);
1.6 nicm 34: void layout_set_tiled(struct window *);
1.1 nicm 35:
36: const struct {
37: const char *name;
38: void (*arrange)(struct window *);
39: } layout_sets[] = {
40: { "even-horizontal", layout_set_even_h },
41: { "even-vertical", layout_set_even_v },
42: { "main-horizontal", layout_set_main_h },
43: { "main-vertical", layout_set_main_v },
1.6 nicm 44: { "tiled", layout_set_tiled },
1.1 nicm 45: };
46:
47: const char *
48: layout_set_name(u_int layout)
49: {
50: return (layout_sets[layout].name);
51: }
52:
53: int
54: layout_set_lookup(const char *name)
55: {
56: u_int i;
57: int matched = -1;
58:
59: for (i = 0; i < nitems(layout_sets); i++) {
60: if (strncmp(layout_sets[i].name, name, strlen(name)) == 0) {
61: if (matched != -1) /* ambiguous */
62: return (-1);
63: matched = i;
64: }
65: }
66:
67: return (matched);
68: }
69:
70: u_int
71: layout_set_select(struct window *w, u_int layout)
72: {
73: if (layout > nitems(layout_sets) - 1)
74: layout = nitems(layout_sets) - 1;
75:
76: if (layout_sets[layout].arrange != NULL)
77: layout_sets[layout].arrange(w);
78:
1.3 nicm 79: w->lastlayout = layout;
1.1 nicm 80: return (layout);
81: }
82:
83: u_int
84: layout_set_next(struct window *w)
85: {
1.3 nicm 86: u_int layout;
87:
88: if (w->lastlayout == -1)
89: layout = 0;
90: else {
91: layout = w->lastlayout + 1;
92: if (layout > nitems(layout_sets) - 1)
93: layout = 0;
94: }
1.1 nicm 95:
96: if (layout_sets[layout].arrange != NULL)
97: layout_sets[layout].arrange(w);
1.3 nicm 98: w->lastlayout = layout;
1.1 nicm 99: return (layout);
100: }
101:
102: u_int
103: layout_set_previous(struct window *w)
104: {
1.3 nicm 105: u_int layout;
106:
107: if (w->lastlayout == -1)
108: layout = nitems(layout_sets) - 1;
109: else {
110: layout = w->lastlayout;
111: if (layout == 0)
112: layout = nitems(layout_sets) - 1;
113: else
114: layout--;
115: }
1.1 nicm 116:
117: if (layout_sets[layout].arrange != NULL)
118: layout_sets[layout].arrange(w);
1.3 nicm 119: w->lastlayout = layout;
1.1 nicm 120: return (layout);
121: }
122:
123: void
124: layout_set_even_h(struct window *w)
125: {
126: struct window_pane *wp;
127: struct layout_cell *lc, *lcnew;
128: u_int i, n, width, xoff;
129:
130: layout_print_cell(w->layout_root, __func__, 1);
131:
132: /* Get number of panes. */
133: n = window_count_panes(w);
134: if (n <= 1)
135: return;
136:
137: /* How many can we fit? */
1.7 ! nicm 138: width = (w->sx - (n - 1)) / n;
! 139: if (width < PANE_MINIMUM)
! 140: width = PANE_MINIMUM;
1.1 nicm 141:
142: /* Free the old root and construct a new. */
143: layout_free(w);
144: lc = w->layout_root = layout_create_cell(NULL);
145: layout_set_size(lc, w->sx, w->sy, 0, 0);
146: layout_make_node(lc, LAYOUT_LEFTRIGHT);
147:
148: /* Build new leaf cells. */
149: i = xoff = 0;
150: TAILQ_FOREACH(wp, &w->panes, entry) {
151: /* Create child cell. */
152: lcnew = layout_create_cell(lc);
1.7 ! nicm 153: layout_set_size(lcnew, width, w->sy, xoff, 0);
1.1 nicm 154: layout_make_leaf(lcnew, wp);
155: TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
156:
157: i++;
1.7 ! nicm 158: xoff += width + 1;
1.1 nicm 159: }
160:
161: /* Allocate any remaining space. */
162: if (w->sx > xoff - 1) {
163: lc = TAILQ_LAST(&lc->cells, layout_cells);
164: layout_resize_adjust(lc, LAYOUT_LEFTRIGHT, w->sx - (xoff - 1));
165: }
166:
167: /* Fix cell offsets. */
168: layout_fix_offsets(lc);
169: layout_fix_panes(w, w->sx, w->sy);
170:
171: layout_print_cell(w->layout_root, __func__, 1);
172:
173: server_redraw_window(w);
174: }
175:
176: void
177: layout_set_even_v(struct window *w)
178: {
179: struct window_pane *wp;
180: struct layout_cell *lc, *lcnew;
181: u_int i, n, height, yoff;
182:
183: layout_print_cell(w->layout_root, __func__, 1);
184:
185: /* Get number of panes. */
186: n = window_count_panes(w);
187: if (n <= 1)
188: return;
189:
190: /* How many can we fit? */
1.7 ! nicm 191: height = (w->sy - (n - 1)) / n;
! 192: if (height < PANE_MINIMUM)
! 193: height = PANE_MINIMUM;
1.1 nicm 194:
195: /* Free the old root and construct a new. */
196: layout_free(w);
197: lc = w->layout_root = layout_create_cell(NULL);
198: layout_set_size(lc, w->sx, w->sy, 0, 0);
199: layout_make_node(lc, LAYOUT_TOPBOTTOM);
200:
201: /* Build new leaf cells. */
202: i = yoff = 0;
203: TAILQ_FOREACH(wp, &w->panes, entry) {
204: /* Create child cell. */
205: lcnew = layout_create_cell(lc);
1.7 ! nicm 206: layout_set_size(lcnew, w->sx, height, 0, yoff);
1.1 nicm 207: layout_make_leaf(lcnew, wp);
208: TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
209:
210: i++;
1.7 ! nicm 211: yoff += height + 1;
1.1 nicm 212: }
213:
214: /* Allocate any remaining space. */
215: if (w->sy > yoff - 1) {
216: lc = TAILQ_LAST(&lc->cells, layout_cells);
217: layout_resize_adjust(lc, LAYOUT_TOPBOTTOM, w->sy - (yoff - 1));
218: }
219:
220: /* Fix cell offsets. */
221: layout_fix_offsets(lc);
222: layout_fix_panes(w, w->sx, w->sy);
223:
224: layout_print_cell(w->layout_root, __func__, 1);
225:
226: server_redraw_window(w);
227: }
228:
229: void
230: layout_set_main_h(struct window *w)
231: {
232: struct window_pane *wp;
233: struct layout_cell *lc, *lcmain, *lcrow, *lcchild;
234: u_int n, mainheight, width, height, used;
235: u_int i, j, columns, rows, totalrows;
236:
237: layout_print_cell(w->layout_root, __func__, 1);
238:
239: /* Get number of panes. */
240: n = window_count_panes(w);
241: if (n <= 1)
242: return;
243: n--; /* take off main pane */
244:
1.7 ! nicm 245: /* How many rows and columns will be needed, not counting main? */
! 246: columns = (w->sx + 1) / (PANE_MINIMUM + 1); /* maximum columns */
1.5 nicm 247: if (columns == 0)
248: columns = 1;
1.1 nicm 249: rows = 1 + (n - 1) / columns;
250: columns = 1 + (n - 1) / rows;
1.7 ! nicm 251: width = (w->sx - (n - 1)) / columns;
1.1 nicm 252:
253: /* Get the main pane height and add one for separator line. */
254: mainheight = options_get_number(&w->options, "main-pane-height") + 1;
255: if (mainheight < PANE_MINIMUM + 1)
256: mainheight = PANE_MINIMUM + 1;
257:
258: /* Try and make everything fit. */
259: totalrows = rows * (PANE_MINIMUM + 1) - 1;
260: if (mainheight + totalrows > w->sy) {
261: if (totalrows + PANE_MINIMUM + 1 > w->sy)
262: mainheight = PANE_MINIMUM + 2;
263: else
264: mainheight = w->sy - totalrows;
1.7 ! nicm 265: height = PANE_MINIMUM;
1.1 nicm 266: } else
1.7 ! nicm 267: height = (w->sy - mainheight - (rows - 1)) / rows;
1.1 nicm 268:
269: /* Free old tree and create a new root. */
270: layout_free(w);
271: lc = w->layout_root = layout_create_cell(NULL);
1.7 ! nicm 272: layout_set_size(lc, w->sx, mainheight + rows * (height + 1) - 1, 0, 0);
1.1 nicm 273: layout_make_node(lc, LAYOUT_TOPBOTTOM);
274:
275: /* Create the main pane. */
276: lcmain = layout_create_cell(lc);
277: layout_set_size(lcmain, w->sx, mainheight - 1, 0, 0);
278: layout_make_leaf(lcmain, TAILQ_FIRST(&w->panes));
279: TAILQ_INSERT_TAIL(&lc->cells, lcmain, entry);
280:
281: /* Create a grid of the remaining cells. */
282: wp = TAILQ_NEXT(TAILQ_FIRST(&w->panes), entry);
283: for (j = 0; j < rows; j++) {
284: /* If this is the last cell, all done. */
285: if (wp == NULL)
286: break;
287:
288: /* Create the new row. */
289: lcrow = layout_create_cell(lc);
1.7 ! nicm 290: layout_set_size(lcrow, w->sx, height, 0, 0);
1.1 nicm 291: TAILQ_INSERT_TAIL(&lc->cells, lcrow, entry);
292:
293: /* If only one column, just use the row directly. */
294: if (columns == 1) {
295: layout_make_leaf(lcrow, wp);
296: wp = TAILQ_NEXT(wp, entry);
297: continue;
298: }
299:
1.4 nicm 300: /* Add in the columns. */
1.1 nicm 301: layout_make_node(lcrow, LAYOUT_LEFTRIGHT);
302: for (i = 0; i < columns; i++) {
303: /* Create and add a pane cell. */
304: lcchild = layout_create_cell(lcrow);
1.7 ! nicm 305: layout_set_size(lcchild, width, height, 0, 0);
1.1 nicm 306: layout_make_leaf(lcchild, wp);
307: TAILQ_INSERT_TAIL(&lcrow->cells, lcchild, entry);
308:
309: /* Move to the next cell. */
310: if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
311: break;
312: }
313:
314: /* Adjust the row to fit the full width if necessary. */
315: if (i == columns)
316: i--;
1.7 ! nicm 317: used = ((i + 1) * (width + 1)) - 1;
1.4 nicm 318: if (w->sx <= used)
319: continue;
320: lcchild = TAILQ_LAST(&lcrow->cells, layout_cells);
321: layout_resize_adjust(lcchild, LAYOUT_LEFTRIGHT, w->sx - used);
1.1 nicm 322: }
323:
324: /* Adjust the last row height to fit if necessary. */
1.7 ! nicm 325: used = mainheight + (rows * height) + rows - 1;
1.1 nicm 326: if (w->sy > used) {
327: lcrow = TAILQ_LAST(&lc->cells, layout_cells);
328: layout_resize_adjust(lcrow, LAYOUT_TOPBOTTOM, w->sy - used);
329: }
330:
331: /* Fix cell offsets. */
332: layout_fix_offsets(lc);
333: layout_fix_panes(w, w->sx, w->sy);
334:
335: layout_print_cell(w->layout_root, __func__, 1);
336:
337: server_redraw_window(w);
338: }
339:
340: void
341: layout_set_main_v(struct window *w)
342: {
343: struct window_pane *wp;
344: struct layout_cell *lc, *lcmain, *lccolumn, *lcchild;
345: u_int n, mainwidth, width, height, used;
346: u_int i, j, columns, rows, totalcolumns;
347:
348: layout_print_cell(w->layout_root, __func__, 1);
349:
350: /* Get number of panes. */
351: n = window_count_panes(w);
352: if (n <= 1)
353: return;
354: n--; /* take off main pane */
355:
1.7 ! nicm 356: /* How many rows and columns will be needed, not counting main? */
! 357: rows = (w->sy + 1) / (PANE_MINIMUM + 1); /* maximum rows */
1.5 nicm 358: if (rows == 0)
359: rows = 1;
1.1 nicm 360: columns = 1 + (n - 1) / rows;
361: rows = 1 + (n - 1) / columns;
1.7 ! nicm 362: height = (w->sy - (n - 1)) / rows;
1.1 nicm 363:
364: /* Get the main pane width and add one for separator line. */
365: mainwidth = options_get_number(&w->options, "main-pane-width") + 1;
366: if (mainwidth < PANE_MINIMUM + 1)
367: mainwidth = PANE_MINIMUM + 1;
368:
369: /* Try and make everything fit. */
370: totalcolumns = columns * (PANE_MINIMUM + 1) - 1;
371: if (mainwidth + totalcolumns > w->sx) {
372: if (totalcolumns + PANE_MINIMUM + 1 > w->sx)
373: mainwidth = PANE_MINIMUM + 2;
374: else
375: mainwidth = w->sx - totalcolumns;
1.7 ! nicm 376: width = PANE_MINIMUM;
1.1 nicm 377: } else
1.7 ! nicm 378: width = (w->sx - mainwidth - (columns - 1)) / columns;
1.1 nicm 379:
380: /* Free old tree and create a new root. */
381: layout_free(w);
382: lc = w->layout_root = layout_create_cell(NULL);
1.7 ! nicm 383: layout_set_size(lc, mainwidth + columns * (width + 1) - 1, w->sy, 0, 0);
1.1 nicm 384: layout_make_node(lc, LAYOUT_LEFTRIGHT);
385:
386: /* Create the main pane. */
387: lcmain = layout_create_cell(lc);
388: layout_set_size(lcmain, mainwidth - 1, w->sy, 0, 0);
389: layout_make_leaf(lcmain, TAILQ_FIRST(&w->panes));
390: TAILQ_INSERT_TAIL(&lc->cells, lcmain, entry);
391:
392: /* Create a grid of the remaining cells. */
393: wp = TAILQ_NEXT(TAILQ_FIRST(&w->panes), entry);
394: for (j = 0; j < columns; j++) {
395: /* If this is the last cell, all done. */
396: if (wp == NULL)
397: break;
398:
399: /* Create the new column. */
400: lccolumn = layout_create_cell(lc);
1.7 ! nicm 401: layout_set_size(lccolumn, width, w->sy, 0, 0);
1.1 nicm 402: TAILQ_INSERT_TAIL(&lc->cells, lccolumn, entry);
403:
404: /* If only one row, just use the row directly. */
405: if (rows == 1) {
406: layout_make_leaf(lccolumn, wp);
407: wp = TAILQ_NEXT(wp, entry);
408: continue;
409: }
410:
411: /* Add in the rows. */
412: layout_make_node(lccolumn, LAYOUT_TOPBOTTOM);
413: for (i = 0; i < rows; i++) {
414: /* Create and add a pane cell. */
415: lcchild = layout_create_cell(lccolumn);
1.7 ! nicm 416: layout_set_size(lcchild, width, height, 0, 0);
1.1 nicm 417: layout_make_leaf(lcchild, wp);
418: TAILQ_INSERT_TAIL(&lccolumn->cells, lcchild, entry);
419:
420: /* Move to the next cell. */
421: if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
422: break;
423: }
424:
425: /* Adjust the column to fit the full height if necessary. */
426: if (i == rows)
427: i--;
1.7 ! nicm 428: used = ((i + 1) * (height + 1)) - 1;
1.4 nicm 429: if (w->sy <= used)
430: continue;
431: lcchild = TAILQ_LAST(&lccolumn->cells, layout_cells);
432: layout_resize_adjust(lcchild, LAYOUT_TOPBOTTOM, w->sy - used);
1.1 nicm 433: }
434:
435: /* Adjust the last column width to fit if necessary. */
1.7 ! nicm 436: used = mainwidth + (columns * width) + columns - 1;
1.1 nicm 437: if (w->sx > used) {
438: lccolumn = TAILQ_LAST(&lc->cells, layout_cells);
439: layout_resize_adjust(lccolumn, LAYOUT_LEFTRIGHT, w->sx - used);
1.6 nicm 440: }
441:
442: /* Fix cell offsets. */
443: layout_fix_offsets(lc);
444: layout_fix_panes(w, w->sx, w->sy);
445:
446: layout_print_cell(w->layout_root, __func__, 1);
447:
448: server_redraw_window(w);
449: }
450:
451: void
452: layout_set_tiled(struct window *w)
453: {
454: struct window_pane *wp;
455: struct layout_cell *lc, *lcrow, *lcchild;
456: u_int n, width, height, used;
457: u_int i, j, columns, rows;
458:
459: layout_print_cell(w->layout_root, __func__, 1);
460:
461: /* Get number of panes. */
462: n = window_count_panes(w);
463: if (n <= 1)
464: return;
465:
466: /* How many rows and columns are wanted? */
467: rows = columns = 1;
468: while (rows * columns < n) {
469: rows++;
470: if (rows * columns < n)
471: columns++;
472: }
473:
474: /* What width and height should they be? */
1.7 ! nicm 475: width = (w->sx - (columns - 1)) / columns;
! 476: if (width < PANE_MINIMUM)
! 477: width = PANE_MINIMUM;
! 478: height = (w->sy - (rows - 1)) / rows;
! 479: if (height < PANE_MINIMUM)
! 480: height = PANE_MINIMUM;
1.6 nicm 481:
482: /* Free old tree and create a new root. */
483: layout_free(w);
484: lc = w->layout_root = layout_create_cell(NULL);
1.7 ! nicm 485: layout_set_size(lc, (width + 1) * columns - 1,
! 486: (height + 1) * rows - 1, 0, 0);
1.6 nicm 487: layout_make_node(lc, LAYOUT_TOPBOTTOM);
488:
489: /* Create a grid of the cells. */
490: wp = TAILQ_FIRST(&w->panes);
491: for (j = 0; j < rows; j++) {
492: /* If this is the last cell, all done. */
493: if (wp == NULL)
494: break;
495:
496: /* Create the new row. */
497: lcrow = layout_create_cell(lc);
1.7 ! nicm 498: layout_set_size(lcrow, w->sx, height, 0, 0);
1.6 nicm 499: TAILQ_INSERT_TAIL(&lc->cells, lcrow, entry);
500:
501: /* If only one column, just use the row directly. */
502: if (n - (j * columns) == 1) {
503: layout_make_leaf(lcrow, wp);
504: wp = TAILQ_NEXT(wp, entry);
505: continue;
506: }
507:
508: /* Add in the columns. */
509: layout_make_node(lcrow, LAYOUT_LEFTRIGHT);
510: for (i = 0; i < columns; i++) {
511: /* Create and add a pane cell. */
512: lcchild = layout_create_cell(lcrow);
1.7 ! nicm 513: layout_set_size(lcchild, width, height, 0, 0);
1.6 nicm 514: layout_make_leaf(lcchild, wp);
515: TAILQ_INSERT_TAIL(&lcrow->cells, lcchild, entry);
516:
517: /* Move to the next cell. */
518: if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
519: break;
520: }
521:
522: /*
523: * Adjust the row and columns to fit the full width if
524: * necessary.
525: */
526: if (i == columns)
527: i--;
1.7 ! nicm 528: used = ((i + 1) * (width + 1)) - 1;
1.6 nicm 529: if (w->sx <= used)
530: continue;
531: lcchild = TAILQ_LAST(&lcrow->cells, layout_cells);
532: layout_resize_adjust(lcchild, LAYOUT_LEFTRIGHT, w->sx - used);
533: }
534:
535: /* Adjust the last row height to fit if necessary. */
1.7 ! nicm 536: used = (rows * height) + rows - 1;
1.6 nicm 537: if (w->sy > used) {
538: lcrow = TAILQ_LAST(&lc->cells, layout_cells);
539: layout_resize_adjust(lcrow, LAYOUT_TOPBOTTOM, w->sy - used);
1.1 nicm 540: }
541:
542: /* Fix cell offsets. */
543: layout_fix_offsets(lc);
544: layout_fix_panes(w, w->sx, w->sy);
545:
546: layout_print_cell(w->layout_root, __func__, 1);
547:
548: server_redraw_window(w);
549: }
![[BACK]](/icons/back.gif){kind=icon}
Return to layout-set.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux