?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'obsd-master'
[tmux.git] / layout-set.c
blobc702817dc7eebabdf3e3fb9b6b1a6d90f587bc0b
1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
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 <stdlib.h>
22 #include <string.h>
23
24 #include "tmux.h"
25
26 /*
27 * Set window layouts - predefined methods to arrange windows. These are
28 * one-off and generate a layout tree.
29 */
30
31 static void layout_set_even_h(struct window *);
32 static void layout_set_even_v(struct window *);
33 static void layout_set_main_h(struct window *);
34 static void layout_set_main_v(struct window *);
35 static void layout_set_tiled(struct window *);
36
37 static const struct {
38 const char *name;
39 void (*arrange)(struct window *);
40 } layout_sets[] = {
41 { "even-horizontal", layout_set_even_h },
42 { "even-vertical", layout_set_even_v },
43 { "main-horizontal", layout_set_main_h },
44 { "main-vertical", layout_set_main_v },
45 { "tiled", layout_set_tiled },
46 };
47
48 int
49 layout_set_lookup(const char *name)
50 {
51 u_int i;
52 int matched = -1;
53
54 for (i = 0; i < nitems(layout_sets); i++) {
55 if (strncmp(layout_sets[i].name, name, strlen(name)) == 0) {
56 if (matched != -1) /* ambiguous */
57 return (-1);
58 matched = i;
59 }
60 }
61
62 return (matched);
63 }
64
65 u_int
66 layout_set_select(struct window *w, u_int layout)
67 {
68 if (layout > nitems(layout_sets) - 1)
69 layout = nitems(layout_sets) - 1;
70
71 if (layout_sets[layout].arrange != NULL)
72 layout_sets[layout].arrange(w);
73
74 w->lastlayout = layout;
75 return (layout);
76 }
77
78 u_int
79 layout_set_next(struct window *w)
80 {
81 u_int layout;
82
83 if (w->lastlayout == -1)
84 layout = 0;
85 else {
86 layout = w->lastlayout + 1;
87 if (layout > nitems(layout_sets) - 1)
88 layout = 0;
89 }
90
91 if (layout_sets[layout].arrange != NULL)
92 layout_sets[layout].arrange(w);
93 w->lastlayout = layout;
94 return (layout);
95 }
96
97 u_int
98 layout_set_previous(struct window *w)
99 {
100 u_int layout;
101
102 if (w->lastlayout == -1)
103 layout = nitems(layout_sets) - 1;
104 else {
105 layout = w->lastlayout;
106 if (layout == 0)
107 layout = nitems(layout_sets) - 1;
108 else
109 layout--;
110 }
111
112 if (layout_sets[layout].arrange != NULL)
113 layout_sets[layout].arrange(w);
114 w->lastlayout = layout;
115 return (layout);
116 }
117
118 static void
119 layout_set_even(struct window *w, enum layout_type type)
120 {
121 struct window_pane *wp;
122 struct layout_cell *lc, *lcnew;
123 u_int n, sx, sy;
124
125 layout_print_cell(w->layout_root, __func__, 1);
126
127 /* Get number of panes. */
128 n = window_count_panes(w);
129 if (n <= 1)
130 return;
131
132 /* Free the old root and construct a new. */
133 layout_free(w);
134 lc = w->layout_root = layout_create_cell(NULL);
135 if (type == LAYOUT_LEFTRIGHT) {
136 sx = (n * (PANE_MINIMUM + 1)) - 1;
137 if (sx < w->sx)
138 sx = w->sx;
139 sy = w->sy;
140 } else {
141 sy = (n * (PANE_MINIMUM + 1)) - 1;
142 if (sy < w->sy)
143 sy = w->sy;
144 sx = w->sx;
145 }
146 layout_set_size(lc, sx, sy, 0, 0);
147 layout_make_node(lc, type);
148
149 /* Build new leaf cells. */
150 TAILQ_FOREACH(wp, &w->panes, entry) {
151 lcnew = layout_create_cell(lc);
152 layout_make_leaf(lcnew, wp);
153 lcnew->sx = w->sx;
154 lcnew->sy = w->sy;
155 TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
156 }
157
158 /* Spread out cells. */
159 layout_spread_cell(w, lc);
160
161 /* Fix cell offsets. */
162 layout_fix_offsets(w);
163 layout_fix_panes(w, NULL);
164
165 layout_print_cell(w->layout_root, __func__, 1);
166
167 window_resize(w, lc->sx, lc->sy, -1, -1);
168 notify_window("window-layout-changed", w);
169 server_redraw_window(w);
170 }
171
172 static void
173 layout_set_even_h(struct window *w)
174 {
175 layout_set_even(w, LAYOUT_LEFTRIGHT);
176 }
177
178 static void
179 layout_set_even_v(struct window *w)
180 {
181 layout_set_even(w, LAYOUT_TOPBOTTOM);
182 }
183
184 static void
185 layout_set_main_h(struct window *w)
186 {
187 struct window_pane *wp;
188 struct layout_cell *lc, *lcmain, *lcother, *lcchild;
189 u_int n, mainh, otherh, sx, sy;
190 char *cause;
191 const char *s;
192
193 layout_print_cell(w->layout_root, __func__, 1);
194
195 /* Get number of panes. */
196 n = window_count_panes(w);
197 if (n <= 1)
198 return;
199 n--; /* take off main pane */
200
201 /* Find available height - take off one line for the border. */
202 sy = w->sy - 1;
203
204 /* Get the main pane height. */
205 s = options_get_string(w->options, "main-pane-height");
206 mainh = args_string_percentage(s, 0, sy, sy, &cause);
207 if (cause != NULL) {
208 mainh = 24;
209 free(cause);
210 }
211
212 /* Work out the other pane height. */
213 if (mainh + PANE_MINIMUM >= sy) {
214 if (sy <= PANE_MINIMUM + PANE_MINIMUM)
215 mainh = PANE_MINIMUM;
216 else
217 mainh = sy - PANE_MINIMUM;
218 otherh = PANE_MINIMUM;
219 } else {
220 s = options_get_string(w->options, "other-pane-height");
221 otherh = args_string_percentage(s, 0, sy, sy, &cause);
222 if (cause != NULL || otherh == 0) {
223 otherh = sy - mainh;
224 free(cause);
225 } else if (otherh > sy || sy - otherh < mainh)
226 otherh = sy - mainh;
227 else
228 mainh = sy - otherh;
229 }
230
231 /* Work out what width is needed. */
232 sx = (n * (PANE_MINIMUM + 1)) - 1;
233 if (sx < w->sx)
234 sx = w->sx;
235
236 /* Free old tree and create a new root. */
237 layout_free(w);
238 lc = w->layout_root = layout_create_cell(NULL);
239 layout_set_size(lc, sx, mainh + otherh + 1, 0, 0);
240 layout_make_node(lc, LAYOUT_TOPBOTTOM);
241
242 /* Create the main pane. */
243 lcmain = layout_create_cell(lc);
244 layout_set_size(lcmain, sx, mainh, 0, 0);
245 layout_make_leaf(lcmain, TAILQ_FIRST(&w->panes));
246 TAILQ_INSERT_TAIL(&lc->cells, lcmain, entry);
247
248 /* Create the other pane. */
249 lcother = layout_create_cell(lc);
250 layout_set_size(lcother, sx, otherh, 0, 0);
251 if (n == 1) {
252 wp = TAILQ_NEXT(TAILQ_FIRST(&w->panes), entry);
253 layout_make_leaf(lcother, wp);
254 TAILQ_INSERT_TAIL(&lc->cells, lcother, entry);
255 } else {
256 layout_make_node(lcother, LAYOUT_LEFTRIGHT);
257 TAILQ_INSERT_TAIL(&lc->cells, lcother, entry);
258
259 /* Add the remaining panes as children. */
260 TAILQ_FOREACH(wp, &w->panes, entry) {
261 if (wp == TAILQ_FIRST(&w->panes))
262 continue;
263 lcchild = layout_create_cell(lcother);
264 layout_set_size(lcchild, PANE_MINIMUM, otherh, 0, 0);
265 layout_make_leaf(lcchild, wp);
266 TAILQ_INSERT_TAIL(&lcother->cells, lcchild, entry);
267 }
268 layout_spread_cell(w, lcother);
269 }
270
271 /* Fix cell offsets. */
272 layout_fix_offsets(w);
273 layout_fix_panes(w, NULL);
274
275 layout_print_cell(w->layout_root, __func__, 1);
276
277 window_resize(w, lc->sx, lc->sy, -1, -1);
278 notify_window("window-layout-changed", w);
279 server_redraw_window(w);
280 }
281
282 static void
283 layout_set_main_v(struct window *w)
284 {
285 struct window_pane *wp;
286 struct layout_cell *lc, *lcmain, *lcother, *lcchild;
287 u_int n, mainw, otherw, sx, sy;
288 char *cause;
289 const char *s;
290
291 layout_print_cell(w->layout_root, __func__, 1);
292
293 /* Get number of panes. */
294 n = window_count_panes(w);
295 if (n <= 1)
296 return;
297 n--; /* take off main pane */
298
299 /* Find available width - take off one line for the border. */
300 sx = w->sx - 1;
301
302 /* Get the main pane width. */
303 s = options_get_string(w->options, "main-pane-width");
304 mainw = args_string_percentage(s, 0, sx, sx, &cause);
305 if (cause != NULL) {
306 mainw = 80;
307 free(cause);
308 }
309
310 /* Work out the other pane width. */
311 if (mainw + PANE_MINIMUM >= sx) {
312 if (sx <= PANE_MINIMUM + PANE_MINIMUM)
313 mainw = PANE_MINIMUM;
314 else
315 mainw = sx - PANE_MINIMUM;
316 otherw = PANE_MINIMUM;
317 } else {
318 s = options_get_string(w->options, "other-pane-width");
319 otherw = args_string_percentage(s, 0, sx, sx, &cause);
320 if (cause != NULL || otherw == 0) {
321 otherw = sx - mainw;
322 free(cause);
323 } else if (otherw > sx || sx - otherw < mainw)
324 otherw = sx - mainw;
325 else
326 mainw = sx - otherw;
327 }
328
329 /* Work out what height is needed. */
330 sy = (n * (PANE_MINIMUM + 1)) - 1;
331 if (sy < w->sy)
332 sy = w->sy;
333
334 /* Free old tree and create a new root. */
335 layout_free(w);
336 lc = w->layout_root = layout_create_cell(NULL);
337 layout_set_size(lc, mainw + otherw + 1, sy, 0, 0);
338 layout_make_node(lc, LAYOUT_LEFTRIGHT);
339
340 /* Create the main pane. */
341 lcmain = layout_create_cell(lc);
342 layout_set_size(lcmain, mainw, sy, 0, 0);
343 layout_make_leaf(lcmain, TAILQ_FIRST(&w->panes));
344 TAILQ_INSERT_TAIL(&lc->cells, lcmain, entry);
345
346 /* Create the other pane. */
347 lcother = layout_create_cell(lc);
348 layout_set_size(lcother, otherw, sy, 0, 0);
349 if (n == 1) {
350 wp = TAILQ_NEXT(TAILQ_FIRST(&w->panes), entry);
351 layout_make_leaf(lcother, wp);
352 TAILQ_INSERT_TAIL(&lc->cells, lcother, entry);
353 } else {
354 layout_make_node(lcother, LAYOUT_TOPBOTTOM);
355 TAILQ_INSERT_TAIL(&lc->cells, lcother, entry);
356
357 /* Add the remaining panes as children. */
358 TAILQ_FOREACH(wp, &w->panes, entry) {
359 if (wp == TAILQ_FIRST(&w->panes))
360 continue;
361 lcchild = layout_create_cell(lcother);
362 layout_set_size(lcchild, otherw, PANE_MINIMUM, 0, 0);
363 layout_make_leaf(lcchild, wp);
364 TAILQ_INSERT_TAIL(&lcother->cells, lcchild, entry);
365 }
366 layout_spread_cell(w, lcother);
367 }
368
369 /* Fix cell offsets. */
370 layout_fix_offsets(w);
371 layout_fix_panes(w, NULL);
372
373 layout_print_cell(w->layout_root, __func__, 1);
374
375 window_resize(w, lc->sx, lc->sy, -1, -1);
376 notify_window("window-layout-changed", w);
377 server_redraw_window(w);
378 }
379
380 void
381 layout_set_tiled(struct window *w)
382 {
383 struct window_pane *wp;
384 struct layout_cell *lc, *lcrow, *lcchild;
385 u_int n, width, height, used, sx, sy;
386 u_int i, j, columns, rows;
387
388 layout_print_cell(w->layout_root, __func__, 1);
389
390 /* Get number of panes. */
391 n = window_count_panes(w);
392 if (n <= 1)
393 return;
394
395 /* How many rows and columns are wanted? */
396 rows = columns = 1;
397 while (rows * columns < n) {
398 rows++;
399 if (rows * columns < n)
400 columns++;
401 }
402
403 /* What width and height should they be? */
404 width = (w->sx - (columns - 1)) / columns;
405 if (width < PANE_MINIMUM)
406 width = PANE_MINIMUM;
407 height = (w->sy - (rows - 1)) / rows;
408 if (height < PANE_MINIMUM)
409 height = PANE_MINIMUM;
410
411 /* Free old tree and create a new root. */
412 layout_free(w);
413 lc = w->layout_root = layout_create_cell(NULL);
414 sx = ((width + 1) * columns) - 1;
415 if (sx < w->sx)
416 sx = w->sx;
417 sy = ((height + 1) * rows) - 1;
418 if (sy < w->sy)
419 sy = w->sy;
420 layout_set_size(lc, sx, sy, 0, 0);
421 layout_make_node(lc, LAYOUT_TOPBOTTOM);
422
423 /* Create a grid of the cells. */
424 wp = TAILQ_FIRST(&w->panes);
425 for (j = 0; j < rows; j++) {
426 /* If this is the last cell, all done. */
427 if (wp == NULL)
428 break;
429
430 /* Create the new row. */
431 lcrow = layout_create_cell(lc);
432 layout_set_size(lcrow, w->sx, height, 0, 0);
433 TAILQ_INSERT_TAIL(&lc->cells, lcrow, entry);
434
435 /* If only one column, just use the row directly. */
436 if (n - (j * columns) == 1 || columns == 1) {
437 layout_make_leaf(lcrow, wp);
438 wp = TAILQ_NEXT(wp, entry);
439 continue;
440 }
441
442 /* Add in the columns. */
443 layout_make_node(lcrow, LAYOUT_LEFTRIGHT);
444 for (i = 0; i < columns; i++) {
445 /* Create and add a pane cell. */
446 lcchild = layout_create_cell(lcrow);
447 layout_set_size(lcchild, width, height, 0, 0);
448 layout_make_leaf(lcchild, wp);
449 TAILQ_INSERT_TAIL(&lcrow->cells, lcchild, entry);
450
451 /* Move to the next cell. */
452 if ((wp = TAILQ_NEXT(wp, entry)) == NULL)
453 break;
454 }
455
456 /*
457 * Adjust the row and columns to fit the full width if
458 * necessary.
459 */
460 if (i == columns)
461 i--;
462 used = ((i + 1) * (width + 1)) - 1;
463 if (w->sx <= used)
464 continue;
465 lcchild = TAILQ_LAST(&lcrow->cells, layout_cells);
466 layout_resize_adjust(w, lcchild, LAYOUT_LEFTRIGHT,
467 w->sx - used);
468 }
469
470 /* Adjust the last row height to fit if necessary. */
471 used = (rows * height) + rows - 1;
472 if (w->sy > used) {
473 lcrow = TAILQ_LAST(&lc->cells, layout_cells);
474 layout_resize_adjust(w, lcrow, LAYOUT_TOPBOTTOM,
475 w->sy - used);
476 }
477
478 /* Fix cell offsets. */
479 layout_fix_offsets(w);
480 layout_fix_panes(w, NULL);
481
482 layout_print_cell(w->layout_root, __func__, 1);
483
484 window_resize(w, lc->sx, lc->sy, -1, -1);
485 notify_window("window-layout-changed", w);
486 server_redraw_window(w);
487 }
tmux -- terminal multiplexer similar to GNU Screen