?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This commit was manufactured by cvs2svn to create tag 'TMUX_1_2'.
[tmux.git] / layout-set.c
blobe3275142e335bc20d2201195351a764a7fd16c85
1 /* $Id: layout-set.c,v 1.5 2010-02-05 01:29:04 tcunha Exp $ */
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
35 const struct {
36 const char *name;
37 void (*arrange)(struct window *);
38 } layout_sets[] = {
39 { "even-horizontal", layout_set_even_h },
40 { "even-vertical", layout_set_even_v },
41 { "main-horizontal", layout_set_main_h },
42 { "main-vertical", layout_set_main_v },
43 };
44
45 const char *
46 layout_set_name(u_int layout)
47 {
48 return (layout_sets[layout].name);
49 }
50
51 int
52 layout_set_lookup(const char *name)
53 {
54 u_int i;
55 int matched = -1;
56
57 for (i = 0; i < nitems(layout_sets); i++) {
58 if (strncmp(layout_sets[i].name, name, strlen(name)) == 0) {
59 if (matched != -1) /* ambiguous */
60 return (-1);
61 matched = i;
62 }
63 }
64
65 return (matched);
66 }
67
68 u_int
69 layout_set_select(struct window *w, u_int layout)
70 {
71 if (layout > nitems(layout_sets) - 1)
72 layout = nitems(layout_sets) - 1;
73
74 if (layout_sets[layout].arrange != NULL)
75 layout_sets[layout].arrange(w);
76
77 w->lastlayout = layout;
78 return (layout);
79 }
80
81 u_int
82 layout_set_next(struct window *w)
83 {
84 u_int layout;
85
86 if (w->lastlayout == -1)
87 layout = 0;
88 else {
89 layout = w->lastlayout + 1;
90 if (layout > nitems(layout_sets) - 1)
91 layout = 0;
92 }
93
94 if (layout_sets[layout].arrange != NULL)
95 layout_sets[layout].arrange(w);
96 w->lastlayout = layout;
97 return (layout);
98 }
99
100 u_int
101 layout_set_previous(struct window *w)
102 {
103 u_int layout;
104
105 if (w->lastlayout == -1)
106 layout = nitems(layout_sets) - 1;
107 else {
108 layout = w->lastlayout;
109 if (layout == 0)
110 layout = nitems(layout_sets) - 1;
111 else
112 layout--;
113 }
114
115 if (layout_sets[layout].arrange != NULL)
116 layout_sets[layout].arrange(w);
117 w->lastlayout = layout;
118 return (layout);
119 }
120
121 void
122 layout_set_even_h(struct window *w)
123 {
124 struct window_pane *wp;
125 struct layout_cell *lc, *lcnew;
126 u_int i, n, width, xoff;
127
128 layout_print_cell(w->layout_root, __func__, 1);
129
130 /* Get number of panes. */
131 n = window_count_panes(w);
132 if (n <= 1)
133 return;
134
135 /* How many can we fit? */
136 if (w->sx / n < PANE_MINIMUM + 1)
137 width = PANE_MINIMUM + 1;
138 else
139 width = w->sx / n;
140
141 /* Free the old root and construct a new. */
142 layout_free(w);
143 lc = w->layout_root = layout_create_cell(NULL);
144 layout_set_size(lc, w->sx, w->sy, 0, 0);
145 layout_make_node(lc, LAYOUT_LEFTRIGHT);
146
147 /* Build new leaf cells. */
148 i = xoff = 0;
149 TAILQ_FOREACH(wp, &w->panes, entry) {
150 /* Create child cell. */
151 lcnew = layout_create_cell(lc);
152 layout_set_size(lcnew, width - 1, w->sy, xoff, 0);
153 layout_make_leaf(lcnew, wp);
154 TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
155
156 i++;
157 xoff += width;
158 }
159
160 /* Allocate any remaining space. */
161 if (w->sx > xoff - 1) {
162 lc = TAILQ_LAST(&lc->cells, layout_cells);
163 layout_resize_adjust(lc, LAYOUT_LEFTRIGHT, w->sx - (xoff - 1));
164 }
165
166 /* Fix cell offsets. */
167 layout_fix_offsets(lc);
168 layout_fix_panes(w, w->sx, w->sy);
169
170 layout_print_cell(w->layout_root, __func__, 1);
171
172 server_redraw_window(w);
173 }
174
175 void
176 layout_set_even_v(struct window *w)
177 {
178 struct window_pane *wp;
179 struct layout_cell *lc, *lcnew;
180 u_int i, n, height, yoff;
181
182 layout_print_cell(w->layout_root, __func__, 1);
183
184 /* Get number of panes. */
185 n = window_count_panes(w);
186 if (n <= 1)
187 return;
188
189 /* How many can we fit? */
190 if (w->sy / n < PANE_MINIMUM + 1)
191 height = PANE_MINIMUM + 1;
192 else
193 height = w->sy / n;
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 - 1, 0, yoff);
207 layout_make_leaf(lcnew, wp);
208 TAILQ_INSERT_TAIL(&lc->cells, lcnew, entry);
209
210 i++;
211 yoff += height;
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
245 /* How many rows and columns will be needed? */
246 columns = w->sx / (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 / 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 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;
265 height = PANE_MINIMUM + 1;
266 } else
267 height = (w->sy - mainheight) / rows;
268
269 /* Free old tree and create a new root. */
270 layout_free(w);
271 lc = w->layout_root = layout_create_cell(NULL);
272 layout_set_size(lc, w->sx, mainheight + rows * height, 0, 0);
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);
290 layout_set_size(lcrow, w->sx, height - 1, 0, 0);
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
300 /* Add in the columns. */
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);
305 layout_set_size(lcchild, width - 1, height - 1, 0, 0);
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--;
317 used = ((i + 1) * width) - 1;
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);
322 }
323
324 /* Adjust the last row height to fit if necessary. */
325 used = mainheight + (rows * height) - 1;
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
356 /* How many rows and columns will be needed? */
357 rows = w->sy / (PANE_MINIMUM + 1); /* maximum rows */
358 if (rows == 0)
359 rows = 1;
360 columns = 1 + (n - 1) / rows;
361 rows = 1 + (n - 1) / columns;
362 height = w->sy / rows;
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;
376 width = PANE_MINIMUM + 1;
377 } else
378 width = (w->sx - mainwidth) / columns;
379
380 /* Free old tree and create a new root. */
381 layout_free(w);
382 lc = w->layout_root = layout_create_cell(NULL);
383 layout_set_size(lc, mainwidth + columns * width, w->sy, 0, 0);
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);
401 layout_set_size(lccolumn, width - 1, w->sy, 0, 0);
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);
416 layout_set_size(lcchild, width - 1, height - 1, 0, 0);
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--;
428 used = ((i + 1) * height) - 1;
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);
433 }
434
435 /* Adjust the last column width to fit if necessary. */
436 used = mainwidth + (columns * width) - 1;
437 if (w->sx > used) {
438 lccolumn = TAILQ_LAST(&lc->cells, layout_cells);
439 layout_resize_adjust(lccolumn, LAYOUT_LEFTRIGHT, w->sx - used);
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 }
tmux -- terminal multiplexer similar to GNU Screen