?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Do not leak command in formats, from Romain Francoise.
[tmux-openbsd.git] / layout-set.c
blob98ed9736560faa23b6db85cd2c24692613362d08
1 /* $OpenBSD$ */
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 *);
34 void layout_set_tiled(struct window *);
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 },
44 { "tiled", layout_set_tiled },
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
79 w->lastlayout = layout;
80 return (layout);
81 }
82
83 u_int
84 layout_set_next(struct window *w)
85 {
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 }
95
96 if (layout_sets[layout].arrange != NULL)
97 layout_sets[layout].arrange(w);
98 w->lastlayout = layout;
99 return (layout);
100 }
101
102 u_int
103 layout_set_previous(struct window *w)
104 {
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 }
116
117 if (layout_sets[layout].arrange != NULL)
118 layout_sets[layout].arrange(w);
119 w->lastlayout = layout;
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? */
138 width = (w->sx - (n - 1)) / n;
139 if (width < PANE_MINIMUM)
140 width = PANE_MINIMUM;
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);
153 layout_set_size(lcnew, width, w->sy, xoff, 0);
154 layout_make_leaf(lcnew, wp);
155 TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
156
157 i++;
158 xoff += width + 1;
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? */
191 height = (w->sy - (n - 1)) / n;
192 if (height < PANE_MINIMUM)
193 height = PANE_MINIMUM;
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);
206 layout_set_size(lcnew, w->sx, height, 0, yoff);
207 layout_make_leaf(lcnew, wp);
208 TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
209
210 i++;
211 yoff += height + 1;
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, otherheight, width, height;
235 u_int used, 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
245 /* How many rows and columns will be needed, not counting main? */
246 columns = (w->sx + 1) / (PANE_MINIMUM + 1); /* maximum columns */
247 if (columns == 0)
248 columns = 1;
249 rows = 1 + (n - 1) / columns;
250 columns = 1 + (n - 1) / rows;
251 width = (w->sx - (n - 1)) / columns;
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
256 /* Get the optional other pane height and add one for separator line. */
257 otherheight = options_get_number(&w->options, "other-pane-height") + 1;
258
259 /*
260 * If an other pane height was specified, honour it so long as it
261 * doesn't shrink the main height to less than the main-pane-height
262 */
263 if (otherheight > 1 && w->sy - otherheight > mainheight)
264 mainheight = w->sy - otherheight;
265 if (mainheight < PANE_MINIMUM + 1)
266 mainheight = PANE_MINIMUM + 1;
267
268 /* Try and make everything fit. */
269 totalrows = rows * (PANE_MINIMUM + 1) - 1;
270 if (mainheight + totalrows > w->sy) {
271 if (totalrows + PANE_MINIMUM + 1 > w->sy)
272 mainheight = PANE_MINIMUM + 2;
273 else
274 mainheight = w->sy - totalrows;
275 height = PANE_MINIMUM;
276 } else
277 height = (w->sy - mainheight - (rows - 1)) / rows;
278
279 /* Free old tree and create a new root. */
280 layout_free(w);
281 lc = w->layout_root = layout_create_cell(NULL);
282 layout_set_size(lc, w->sx, mainheight + rows * (height + 1) - 1, 0, 0);
283 layout_make_node(lc, LAYOUT_TOPBOTTOM);
284
285 /* Create the main pane. */
286 lcmain = layout_create_cell(lc);
287 layout_set_size(lcmain, w->sx, mainheight - 1, 0, 0);
288 layout_make_leaf(lcmain, TAILQ_FIRST(&w->panes));
289 TAILQ_INSERT_TAIL(&lc->cells, lcmain, entry);
290
291 /* Create a grid of the remaining cells. */
292 wp = TAILQ_NEXT(TAILQ_FIRST(&w->panes), entry);
293 for (j = 0; j < rows; j++) {
294 /* If this is the last cell, all done. */
295 if (wp == NULL)
296 break;
297
298 /* Create the new row. */
299 lcrow = layout_create_cell(lc);
300 layout_set_size(lcrow, w->sx, height, 0, 0);
301 TAILQ_INSERT_TAIL(&lc->cells, lcrow, entry);
302
303 /* If only one column, just use the row directly. */
304 if (columns == 1) {
305 layout_make_leaf(lcrow, wp);
306 wp = TAILQ_NEXT(wp, entry);
307 continue;
308 }
309
310 /* Add in the columns. */
311 layout_make_node(lcrow, LAYOUT_LEFTRIGHT);
312 for (i = 0; i < columns; i++) {
313 /* Create and add a pane cell. */
314 lcchild = layout_create_cell(lcrow);
315 layout_set_size(lcchild, width, height, 0, 0);
316 layout_make_leaf(lcchild, wp);
317 TAILQ_INSERT_TAIL(&lcrow->cells, lcchild, entry);
318
319 /* Move to the next cell. */
320 if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
321 break;
322 }
323
324 /* Adjust the row to fit the full width if necessary. */
325 if (i == columns)
326 i--;
327 used = ((i + 1) * (width + 1)) - 1;
328 if (w->sx <= used)
329 continue;
330 lcchild = TAILQ_LAST(&lcrow->cells, layout_cells);
331 layout_resize_adjust(lcchild, LAYOUT_LEFTRIGHT, w->sx - used);
332 }
333
334 /* Adjust the last row height to fit if necessary. */
335 used = mainheight + (rows * height) + rows - 1;
336 if (w->sy > used) {
337 lcrow = TAILQ_LAST(&lc->cells, layout_cells);
338 layout_resize_adjust(lcrow, LAYOUT_TOPBOTTOM, w->sy - used);
339 }
340
341 /* Fix cell offsets. */
342 layout_fix_offsets(lc);
343 layout_fix_panes(w, w->sx, w->sy);
344
345 layout_print_cell(w->layout_root, __func__, 1);
346
347 server_redraw_window(w);
348 }
349
350 void
351 layout_set_main_v(struct window *w)
352 {
353 struct window_pane *wp;
354 struct layout_cell *lc, *lcmain, *lccolumn, *lcchild;
355 u_int n, mainwidth, otherwidth, width, height;
356 u_int used, i, j, columns, rows, totalcolumns;
357
358 layout_print_cell(w->layout_root, __func__, 1);
359
360 /* Get number of panes. */
361 n = window_count_panes(w);
362 if (n <= 1)
363 return;
364 n--; /* take off main pane */
365
366 /* How many rows and columns will be needed, not counting main? */
367 rows = (w->sy + 1) / (PANE_MINIMUM + 1); /* maximum rows */
368 if (rows == 0)
369 rows = 1;
370 columns = 1 + (n - 1) / rows;
371 rows = 1 + (n - 1) / columns;
372 height = (w->sy - (n - 1)) / rows;
373
374 /* Get the main pane width and add one for separator line. */
375 mainwidth = options_get_number(&w->options, "main-pane-width") + 1;
376
377 /* Get the optional other pane width and add one for separator line. */
378 otherwidth = options_get_number(&w->options, "other-pane-width") + 1;
379
380 /*
381 * If an other pane width was specified, honour it so long as it
382 * doesn't shrink the main width to less than the main-pane-width
383 */
384 if (otherwidth > 1 && w->sx - otherwidth > mainwidth)
385 mainwidth = w->sx - otherwidth;
386 if (mainwidth < PANE_MINIMUM + 1)
387 mainwidth = PANE_MINIMUM + 1;
388
389 /* Try and make everything fit. */
390 totalcolumns = columns * (PANE_MINIMUM + 1) - 1;
391 if (mainwidth + totalcolumns > w->sx) {
392 if (totalcolumns + PANE_MINIMUM + 1 > w->sx)
393 mainwidth = PANE_MINIMUM + 2;
394 else
395 mainwidth = w->sx - totalcolumns;
396 width = PANE_MINIMUM;
397 } else
398 width = (w->sx - mainwidth - (columns - 1)) / columns;
399
400 /* Free old tree and create a new root. */
401 layout_free(w);
402 lc = w->layout_root = layout_create_cell(NULL);
403 layout_set_size(lc, mainwidth + columns * (width + 1) - 1, w->sy, 0, 0);
404 layout_make_node(lc, LAYOUT_LEFTRIGHT);
405
406 /* Create the main pane. */
407 lcmain = layout_create_cell(lc);
408 layout_set_size(lcmain, mainwidth - 1, w->sy, 0, 0);
409 layout_make_leaf(lcmain, TAILQ_FIRST(&w->panes));
410 TAILQ_INSERT_TAIL(&lc->cells, lcmain, entry);
411
412 /* Create a grid of the remaining cells. */
413 wp = TAILQ_NEXT(TAILQ_FIRST(&w->panes), entry);
414 for (j = 0; j < columns; j++) {
415 /* If this is the last cell, all done. */
416 if (wp == NULL)
417 break;
418
419 /* Create the new column. */
420 lccolumn = layout_create_cell(lc);
421 layout_set_size(lccolumn, width, w->sy, 0, 0);
422 TAILQ_INSERT_TAIL(&lc->cells, lccolumn, entry);
423
424 /* If only one row, just use the row directly. */
425 if (rows == 1) {
426 layout_make_leaf(lccolumn, wp);
427 wp = TAILQ_NEXT(wp, entry);
428 continue;
429 }
430
431 /* Add in the rows. */
432 layout_make_node(lccolumn, LAYOUT_TOPBOTTOM);
433 for (i = 0; i < rows; i++) {
434 /* Create and add a pane cell. */
435 lcchild = layout_create_cell(lccolumn);
436 layout_set_size(lcchild, width, height, 0, 0);
437 layout_make_leaf(lcchild, wp);
438 TAILQ_INSERT_TAIL(&lccolumn->cells, lcchild, entry);
439
440 /* Move to the next cell. */
441 if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
442 break;
443 }
444
445 /* Adjust the column to fit the full height if necessary. */
446 if (i == rows)
447 i--;
448 used = ((i + 1) * (height + 1)) - 1;
449 if (w->sy <= used)
450 continue;
451 lcchild = TAILQ_LAST(&lccolumn->cells, layout_cells);
452 layout_resize_adjust(lcchild, LAYOUT_TOPBOTTOM, w->sy - used);
453 }
454
455 /* Adjust the last column width to fit if necessary. */
456 used = mainwidth + (columns * width) + columns - 1;
457 if (w->sx > used) {
458 lccolumn = TAILQ_LAST(&lc->cells, layout_cells);
459 layout_resize_adjust(lccolumn, LAYOUT_LEFTRIGHT, w->sx - used);
460 }
461
462 /* Fix cell offsets. */
463 layout_fix_offsets(lc);
464 layout_fix_panes(w, w->sx, w->sy);
465
466 layout_print_cell(w->layout_root, __func__, 1);
467
468 server_redraw_window(w);
469 }
470
471 void
472 layout_set_tiled(struct window *w)
473 {
474 struct window_pane *wp;
475 struct layout_cell *lc, *lcrow, *lcchild;
476 u_int n, width, height, used;
477 u_int i, j, columns, rows;
478
479 layout_print_cell(w->layout_root, __func__, 1);
480
481 /* Get number of panes. */
482 n = window_count_panes(w);
483 if (n <= 1)
484 return;
485
486 /* How many rows and columns are wanted? */
487 rows = columns = 1;
488 while (rows * columns < n) {
489 rows++;
490 if (rows * columns < n)
491 columns++;
492 }
493
494 /* What width and height should they be? */
495 width = (w->sx - (columns - 1)) / columns;
496 if (width < PANE_MINIMUM)
497 width = PANE_MINIMUM;
498 height = (w->sy - (rows - 1)) / rows;
499 if (height < PANE_MINIMUM)
500 height = PANE_MINIMUM;
501
502 /* Free old tree and create a new root. */
503 layout_free(w);
504 lc = w->layout_root = layout_create_cell(NULL);
505 layout_set_size(lc, (width + 1) * columns - 1,
506 (height + 1) * rows - 1, 0, 0);
507 layout_make_node(lc, LAYOUT_TOPBOTTOM);
508
509 /* Create a grid of the cells. */
510 wp = TAILQ_FIRST(&w->panes);
511 for (j = 0; j < rows; j++) {
512 /* If this is the last cell, all done. */
513 if (wp == NULL)
514 break;
515
516 /* Create the new row. */
517 lcrow = layout_create_cell(lc);
518 layout_set_size(lcrow, w->sx, height, 0, 0);
519 TAILQ_INSERT_TAIL(&lc->cells, lcrow, entry);
520
521 /* If only one column, just use the row directly. */
522 if (n - (j * columns) == 1 || columns == 1) {
523 layout_make_leaf(lcrow, wp);
524 wp = TAILQ_NEXT(wp, entry);
525 continue;
526 }
527
528 /* Add in the columns. */
529 layout_make_node(lcrow, LAYOUT_LEFTRIGHT);
530 for (i = 0; i < columns; i++) {
531 /* Create and add a pane cell. */
532 lcchild = layout_create_cell(lcrow);
533 layout_set_size(lcchild, width, height, 0, 0);
534 layout_make_leaf(lcchild, wp);
535 TAILQ_INSERT_TAIL(&lcrow->cells, lcchild, entry);
536
537 /* Move to the next cell. */
538 if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
539 break;
540 }
541
542 /*
543 * Adjust the row and columns to fit the full width if
544 * necessary.
545 */
546 if (i == columns)
547 i--;
548 used = ((i + 1) * (width + 1)) - 1;
549 if (w->sx <= used)
550 continue;
551 lcchild = TAILQ_LAST(&lcrow->cells, layout_cells);
552 layout_resize_adjust(lcchild, LAYOUT_LEFTRIGHT, w->sx - used);
553 }
554
555 /* Adjust the last row height to fit if necessary. */
556 used = (rows * height) + rows - 1;
557 if (w->sy > used) {
558 lcrow = TAILQ_LAST(&lc->cells, layout_cells);
559 layout_resize_adjust(lcrow, LAYOUT_TOPBOTTOM, w->sy - used);
560 }
561
562 /* Fix cell offsets. */
563 layout_fix_offsets(lc);
564 layout_fix_panes(w, w->sx, w->sy);
565
566 layout_print_cell(w->layout_root, __func__, 1);
567
568 server_redraw_window(w);
569 }