4 * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net>
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.
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.
19 #include <sys/types.h>
26 * The window layout is a tree of cells each of which can be one of: a
27 * left-right container for a list of cells, a top-bottom container for a list
28 * of cells, or a container for a window pane.
30 * Each window has a pointer to the root of its layout tree (containing its
31 * panes), every pane has a pointer back to the cell containing it, and each
32 * cell a pointer to its parent cell.
35 int layout_resize_pane_grow(struct layout_cell
*, enum layout_type
, int);
36 int layout_resize_pane_shrink(struct layout_cell
*, enum layout_type
, int);
39 layout_create_cell(struct layout_cell
*lcparent
)
41 struct layout_cell
*lc
;
43 lc
= xmalloc(sizeof *lc
);
44 lc
->type
= LAYOUT_WINDOWPANE
;
45 lc
->parent
= lcparent
;
47 TAILQ_INIT(&lc
->cells
);
61 layout_free_cell(struct layout_cell
*lc
)
63 struct layout_cell
*lcchild
;
66 case LAYOUT_LEFTRIGHT
:
67 case LAYOUT_TOPBOTTOM
:
68 while (!TAILQ_EMPTY(&lc
->cells
)) {
69 lcchild
= TAILQ_FIRST(&lc
->cells
);
70 TAILQ_REMOVE(&lc
->cells
, lcchild
, entry
);
71 layout_free_cell(lcchild
);
74 case LAYOUT_WINDOWPANE
:
76 lc
->wp
->layout_cell
= NULL
;
84 layout_print_cell(struct layout_cell
*lc
, const char *hdr
, u_int n
)
86 struct layout_cell
*lcchild
;
89 "%s:%*s%p type %u [parent %p] wp=%p [%u,%u %ux%u]", hdr
, n
, " ", lc
,
90 lc
->type
, lc
->parent
, lc
->wp
, lc
->xoff
, lc
->yoff
, lc
->sx
, lc
->sy
);
92 case LAYOUT_LEFTRIGHT
:
93 case LAYOUT_TOPBOTTOM
:
94 TAILQ_FOREACH(lcchild
, &lc
->cells
, entry
)
95 layout_print_cell(lcchild
, hdr
, n
+ 1);
97 case LAYOUT_WINDOWPANE
:
104 struct layout_cell
*lc
, u_int sx
, u_int sy
, u_int xoff
, u_int yoff
)
114 layout_make_leaf(struct layout_cell
*lc
, struct window_pane
*wp
)
116 lc
->type
= LAYOUT_WINDOWPANE
;
118 TAILQ_INIT(&lc
->cells
);
120 wp
->layout_cell
= lc
;
125 layout_make_node(struct layout_cell
*lc
, enum layout_type type
)
127 if (type
== LAYOUT_WINDOWPANE
)
128 fatalx("bad layout type");
131 TAILQ_INIT(&lc
->cells
);
134 lc
->wp
->layout_cell
= NULL
;
138 /* Fix cell offsets based on their sizes. */
140 layout_fix_offsets(struct layout_cell
*lc
)
142 struct layout_cell
*lcchild
;
145 if (lc
->type
== LAYOUT_LEFTRIGHT
) {
147 TAILQ_FOREACH(lcchild
, &lc
->cells
, entry
) {
148 lcchild
->xoff
= xoff
;
149 lcchild
->yoff
= lc
->yoff
;
150 if (lcchild
->type
!= LAYOUT_WINDOWPANE
)
151 layout_fix_offsets(lcchild
);
152 xoff
+= lcchild
->sx
+ 1;
156 TAILQ_FOREACH(lcchild
, &lc
->cells
, entry
) {
157 lcchild
->xoff
= lc
->xoff
;
158 lcchild
->yoff
= yoff
;
159 if (lcchild
->type
!= LAYOUT_WINDOWPANE
)
160 layout_fix_offsets(lcchild
);
161 yoff
+= lcchild
->sy
+ 1;
166 /* Update pane offsets and sizes based on their cells. */
168 layout_fix_panes(struct window
*w
, u_int wsx
, u_int wsy
)
170 struct window_pane
*wp
;
171 struct layout_cell
*lc
;
174 TAILQ_FOREACH(wp
, &w
->panes
, entry
) {
175 if ((lc
= wp
->layout_cell
) == NULL
)
181 * Layout cells are limited by the smallest size of other cells
182 * within the same row or column; if this isn't the case
183 * resizing becomes difficult.
185 * However, panes do not have to take up their entire cell, so
186 * they can be cropped to the window edge if the layout
187 * overflows and they are partly visible.
189 * This stops cells being hidden unnecessarily.
193 * Work out the horizontal size. If the pane is actually
194 * outside the window or the entire pane is already visible,
197 if (lc
->xoff
>= wsx
|| lc
->xoff
+ lc
->sx
< wsx
)
206 * Similarly for the vertical size; the minimum vertical size
207 * is two because scroll regions cannot be one line.
209 if (lc
->yoff
>= wsy
|| lc
->yoff
+ lc
->sy
< wsy
)
217 window_pane_resize(wp
, sx
, sy
);
221 /* Count the number of available cells in a layout. */
223 layout_count_cells(struct layout_cell
*lc
)
225 struct layout_cell
*lcchild
;
229 case LAYOUT_WINDOWPANE
:
231 case LAYOUT_LEFTRIGHT
:
232 case LAYOUT_TOPBOTTOM
:
234 TAILQ_FOREACH(lcchild
, &lc
->cells
, entry
)
235 n
+= layout_count_cells(lcchild
);
238 fatalx("bad layout type");
242 /* Calculate how much size is available to be removed from a cell. */
244 layout_resize_check(struct layout_cell
*lc
, enum layout_type type
)
246 struct layout_cell
*lcchild
;
247 u_int available
, minimum
;
249 if (lc
->type
== LAYOUT_WINDOWPANE
) {
250 /* Space available in this cell only. */
251 if (type
== LAYOUT_LEFTRIGHT
)
256 if (available
> PANE_MINIMUM
)
257 available
-= PANE_MINIMUM
;
260 } else if (lc
->type
== type
) {
261 /* Same type: total of available space in all child cells. */
263 TAILQ_FOREACH(lcchild
, &lc
->cells
, entry
)
264 available
+= layout_resize_check(lcchild
, type
);
266 /* Different type: minimum of available space in child cells. */
268 TAILQ_FOREACH(lcchild
, &lc
->cells
, entry
) {
269 available
= layout_resize_check(lcchild
, type
);
270 if (available
< minimum
)
280 * Adjust cell size evenly, including altering its children. This function
281 * expects the change to have already been bounded to the space available.
284 layout_resize_adjust(struct layout_cell
*lc
, enum layout_type type
, int change
)
286 struct layout_cell
*lcchild
;
288 /* Adjust the cell size. */
289 if (type
== LAYOUT_LEFTRIGHT
)
294 /* If this is a leaf cell, that is all that is necessary. */
295 if (type
== LAYOUT_WINDOWPANE
)
298 /* Child cell runs in a different direction. */
299 if (lc
->type
!= type
) {
300 TAILQ_FOREACH(lcchild
, &lc
->cells
, entry
)
301 layout_resize_adjust(lcchild
, type
, change
);
306 * Child cell runs in the same direction. Adjust each child equally
307 * until no further change is possible.
309 while (change
!= 0) {
310 TAILQ_FOREACH(lcchild
, &lc
->cells
, entry
) {
314 layout_resize_adjust(lcchild
, type
, 1);
318 if (layout_resize_check(lcchild
, type
) > 0) {
319 layout_resize_adjust(lcchild
, type
, -1);
326 /* Destroy a cell and redistribute the space. */
328 layout_destroy_cell(struct layout_cell
*lc
, struct layout_cell
**lcroot
)
330 struct layout_cell
*lcother
, *lcparent
;
333 * If no parent, this is the last pane so window close is imminent and
334 * there is no need to resize anything.
336 lcparent
= lc
->parent
;
337 if (lcparent
== NULL
) {
338 layout_free_cell(lc
);
343 /* Merge the space into the previous or next cell. */
344 if (lc
== TAILQ_FIRST(&lcparent
->cells
))
345 lcother
= TAILQ_NEXT(lc
, entry
);
347 lcother
= TAILQ_PREV(lc
, layout_cells
, entry
);
348 if (lcparent
->type
== LAYOUT_LEFTRIGHT
)
349 layout_resize_adjust(lcother
, lcparent
->type
, lc
->sx
+ 1);
351 layout_resize_adjust(lcother
, lcparent
->type
, lc
->sy
+ 1);
353 /* Remove this from the parent's list. */
354 TAILQ_REMOVE(&lcparent
->cells
, lc
, entry
);
355 layout_free_cell(lc
);
358 * If the parent now has one cell, remove the parent from the tree and
359 * replace it by that cell.
361 lc
= TAILQ_FIRST(&lcparent
->cells
);
362 if (TAILQ_NEXT(lc
, entry
) == NULL
) {
363 TAILQ_REMOVE(&lcparent
->cells
, lc
, entry
);
365 lc
->parent
= lcparent
->parent
;
366 if (lc
->parent
== NULL
) {
367 lc
->xoff
= 0; lc
->yoff
= 0;
370 TAILQ_REPLACE(&lc
->parent
->cells
, lcparent
, lc
, entry
);
372 layout_free_cell(lcparent
);
377 layout_init(struct window
*w
, struct window_pane
*wp
)
379 struct layout_cell
*lc
;
381 lc
= w
->layout_root
= layout_create_cell(NULL
);
382 layout_set_size(lc
, w
->sx
, w
->sy
, 0, 0);
383 layout_make_leaf(lc
, wp
);
385 layout_fix_panes(w
, w
->sx
, w
->sy
);
389 layout_free(struct window
*w
)
391 layout_free_cell(w
->layout_root
);
394 /* Resize the entire layout after window resize. */
396 layout_resize(struct window
*w
, u_int sx
, u_int sy
)
398 struct layout_cell
*lc
= w
->layout_root
;
399 int xlimit
, ylimit
, xchange
, ychange
;
402 * Adjust horizontally. Do not attempt to reduce the layout lower than
403 * the minimum (more than the amount returned by layout_resize_check).
405 * This can mean that the window size is smaller than the total layout
406 * size: redrawing this is handled at a higher level, but it does leave
407 * a problem with growing the window size here: if the current size is
408 * < the minimum, growing proportionately by adding to each pane is
409 * wrong as it would keep the layout size larger than the window size.
410 * Instead, spread the difference between the minimum and the new size
411 * out proportionately - this should leave the layout fitting the new
414 xchange
= sx
- w
->sx
;
415 xlimit
= layout_resize_check(lc
, LAYOUT_LEFTRIGHT
);
416 if (xchange
< 0 && xchange
< -xlimit
)
419 if (sx
<= lc
->sx
) /* lc->sx is minimum possible */
422 xchange
= sx
- lc
->sx
;
425 layout_resize_adjust(lc
, LAYOUT_LEFTRIGHT
, xchange
);
427 /* Adjust vertically in a similar fashion. */
428 ychange
= sy
- w
->sy
;
429 ylimit
= layout_resize_check(lc
, LAYOUT_TOPBOTTOM
);
430 if (ychange
< 0 && ychange
< -ylimit
)
433 if (sy
<= lc
->sy
) /* lc->sy is minimum possible */
436 ychange
= sy
- lc
->sy
;
439 layout_resize_adjust(lc
, LAYOUT_TOPBOTTOM
, ychange
);
441 /* Fix cell offsets. */
442 layout_fix_offsets(lc
);
443 layout_fix_panes(w
, sx
, sy
);
446 /* Resize a pane to an absolute size. */
448 layout_resize_pane_to(struct window_pane
*wp
, enum layout_type type
,
451 struct layout_cell
*lc
, *lcparent
;
454 lc
= wp
->layout_cell
;
456 /* Find next parent of the same type. */
457 lcparent
= lc
->parent
;
458 while (lcparent
!= NULL
&& lcparent
->type
!= type
) {
460 lcparent
= lc
->parent
;
462 if (lcparent
== NULL
)
465 /* Work out the size adjustment. */
466 if (type
== LAYOUT_LEFTRIGHT
)
470 if (lc
== TAILQ_LAST(&lcparent
->cells
, layout_cells
))
471 change
= size
- new_size
;
473 change
= new_size
- size
;
475 /* Resize the pane. */
476 layout_resize_pane(wp
, type
, change
);
479 /* Resize a single pane within the layout. */
481 layout_resize_pane(struct window_pane
*wp
, enum layout_type type
, int change
)
483 struct layout_cell
*lc
, *lcparent
;
486 lc
= wp
->layout_cell
;
488 /* Find next parent of the same type. */
489 lcparent
= lc
->parent
;
490 while (lcparent
!= NULL
&& lcparent
->type
!= type
) {
492 lcparent
= lc
->parent
;
494 if (lcparent
== NULL
)
497 /* If this is the last cell, move back one. */
498 if (lc
== TAILQ_LAST(&lcparent
->cells
, layout_cells
))
499 lc
= TAILQ_PREV(lc
, layout_cells
, entry
);
501 /* Grow or shrink the cell. */
503 while (needed
!= 0) {
505 size
= layout_resize_pane_grow(lc
, type
, needed
);
508 size
= layout_resize_pane_shrink(lc
, type
, needed
);
512 if (size
== 0) /* no more change possible */
516 /* Fix cell offsets. */
517 layout_fix_offsets(wp
->window
->layout_root
);
518 layout_fix_panes(wp
->window
, wp
->window
->sx
, wp
->window
->sy
);
519 notify_window_layout_changed(wp
->window
);
522 /* Resize pane based on mouse events. */
524 layout_resize_pane_mouse(struct client
*c
)
527 struct window_pane
*wp
;
528 struct mouse_event
*m
= &c
->tty
.mouse
;
531 w
= c
->session
->curw
->window
;
534 if (m
->event
& MOUSE_EVENT_DRAG
&& m
->flags
& MOUSE_RESIZE_PANE
) {
535 TAILQ_FOREACH(wp
, &w
->panes
, entry
) {
536 if (!window_pane_visible(wp
))
539 if (wp
->xoff
+ wp
->sx
== m
->lx
&&
540 wp
->yoff
<= 1 + m
->ly
&&
541 wp
->yoff
+ wp
->sy
>= m
->ly
) {
542 layout_resize_pane(wp
, LAYOUT_LEFTRIGHT
,
546 if (wp
->yoff
+ wp
->sy
== m
->ly
&&
547 wp
->xoff
<= 1 + m
->lx
&&
548 wp
->xoff
+ wp
->sx
>= m
->lx
) {
549 layout_resize_pane(wp
, LAYOUT_TOPBOTTOM
,
555 server_redraw_window(w
);
556 } else if (m
->event
& MOUSE_EVENT_DOWN
) {
557 TAILQ_FOREACH(wp
, &w
->panes
, entry
) {
558 if ((wp
->xoff
+ wp
->sx
== m
->x
&&
559 wp
->yoff
<= 1 + m
->y
&&
560 wp
->yoff
+ wp
->sy
>= m
->y
) ||
561 (wp
->yoff
+ wp
->sy
== m
->y
&&
562 wp
->xoff
<= 1 + m
->x
&&
563 wp
->xoff
+ wp
->sx
>= m
->x
)) {
569 m
->flags
|= MOUSE_RESIZE_PANE
;
571 m
->flags
&= ~MOUSE_RESIZE_PANE
;
574 /* Helper function to grow pane. */
576 layout_resize_pane_grow(
577 struct layout_cell
*lc
, enum layout_type type
, int needed
)
579 struct layout_cell
*lcadd
, *lcremove
;
582 /* Growing. Always add to the current cell. */
585 /* Look towards the tail for a suitable cell for reduction. */
586 lcremove
= TAILQ_NEXT(lc
, entry
);
587 while (lcremove
!= NULL
) {
588 size
= layout_resize_check(lcremove
, type
);
591 lcremove
= TAILQ_NEXT(lcremove
, entry
);
594 /* If none found, look towards the head. */
595 if (lcremove
== NULL
) {
596 lcremove
= TAILQ_PREV(lc
, layout_cells
, entry
);
597 while (lcremove
!= NULL
) {
598 size
= layout_resize_check(lcremove
, type
);
601 lcremove
= TAILQ_PREV(lcremove
, layout_cells
, entry
);
603 if (lcremove
== NULL
)
607 /* Change the cells. */
608 if (size
> (u_int
) needed
)
610 layout_resize_adjust(lcadd
, type
, size
);
611 layout_resize_adjust(lcremove
, type
, -size
);
615 /* Helper function to shrink pane. */
617 layout_resize_pane_shrink(
618 struct layout_cell
*lc
, enum layout_type type
, int needed
)
620 struct layout_cell
*lcadd
, *lcremove
;
623 /* Shrinking. Find cell to remove from by walking towards head. */
626 size
= layout_resize_check(lcremove
, type
);
629 lcremove
= TAILQ_PREV(lcremove
, layout_cells
, entry
);
630 } while (lcremove
!= NULL
);
631 if (lcremove
== NULL
)
634 /* And add onto the next cell (from the original cell). */
635 lcadd
= TAILQ_NEXT(lc
, entry
);
639 /* Change the cells. */
640 if (size
> (u_int
) -needed
)
642 layout_resize_adjust(lcadd
, type
, size
);
643 layout_resize_adjust(lcremove
, type
, -size
);
647 /* Assign window pane to newly split cell. */
649 layout_assign_pane(struct layout_cell
*lc
, struct window_pane
*wp
)
651 layout_make_leaf(lc
, wp
);
652 layout_fix_panes(wp
->window
, wp
->window
->sx
, wp
->window
->sy
);
656 * Split a pane into two. size is a hint, or -1 for default half/half
657 * split. This must be followed by layout_assign_pane before much else happens!
661 struct window_pane
*wp
, enum layout_type type
, int size
, int insert_before
)
663 struct layout_cell
*lc
, *lcparent
, *lcnew
, *lc1
, *lc2
;
664 u_int sx
, sy
, xoff
, yoff
, size1
, size2
;
666 lc
= wp
->layout_cell
;
668 /* Copy the old cell size. */
674 /* Check there is enough space for the two new panes. */
676 case LAYOUT_LEFTRIGHT
:
677 if (sx
< PANE_MINIMUM
* 2 + 1)
680 case LAYOUT_TOPBOTTOM
:
681 if (sy
< PANE_MINIMUM
* 2 + 1)
685 fatalx("bad layout type");
688 if (lc
->parent
!= NULL
&& lc
->parent
->type
== type
) {
690 * If the parent exists and is of the same type as the split,
691 * create a new cell and insert it after this one.
694 /* Create the new child cell. */
695 lcparent
= lc
->parent
;
696 lcnew
= layout_create_cell(lcparent
);
698 TAILQ_INSERT_BEFORE(lc
, lcnew
, entry
);
700 TAILQ_INSERT_AFTER(&lcparent
->cells
, lc
, lcnew
, entry
);
703 * Otherwise create a new parent and insert it.
706 /* Create and insert the replacement parent. */
707 lcparent
= layout_create_cell(lc
->parent
);
708 layout_make_node(lcparent
, type
);
709 layout_set_size(lcparent
, sx
, sy
, xoff
, yoff
);
710 if (lc
->parent
== NULL
)
711 wp
->window
->layout_root
= lcparent
;
713 TAILQ_REPLACE(&lc
->parent
->cells
, lc
, lcparent
, entry
);
715 /* Insert the old cell. */
716 lc
->parent
= lcparent
;
717 TAILQ_INSERT_HEAD(&lcparent
->cells
, lc
, entry
);
719 /* Create the new child cell. */
720 lcnew
= layout_create_cell(lcparent
);
722 TAILQ_INSERT_HEAD(&lcparent
->cells
, lcnew
, entry
);
724 TAILQ_INSERT_TAIL(&lcparent
->cells
, lcnew
, entry
);
734 /* Set new cell sizes. size is the target size or -1 for middle split,
735 * size1 is the size of the top/left and size2 the bottom/right.
738 case LAYOUT_LEFTRIGHT
:
740 size2
= ((sx
+ 1) / 2) - 1;
743 if (size2
< PANE_MINIMUM
)
744 size2
= PANE_MINIMUM
;
745 else if (size2
> sx
- 2)
747 size1
= sx
- 1 - size2
;
748 layout_set_size(lc1
, size1
, sy
, xoff
, yoff
);
749 layout_set_size(lc2
, size2
, sy
, xoff
+ lc1
->sx
+ 1, yoff
);
751 case LAYOUT_TOPBOTTOM
:
753 size2
= ((sy
+ 1) / 2) - 1;
756 if (size2
< PANE_MINIMUM
)
757 size2
= PANE_MINIMUM
;
758 else if (size2
> sy
- 2)
760 size1
= sy
- 1 - size2
;
761 layout_set_size(lc1
, sx
, size1
, xoff
, yoff
);
762 layout_set_size(lc2
, sx
, size2
, xoff
, yoff
+ lc1
->sy
+ 1);
765 fatalx("bad layout type");
768 /* Assign the panes. */
769 layout_make_leaf(lc
, wp
);
774 /* Destroy the cell associated with a pane. */
776 layout_close_pane(struct window_pane
*wp
)
778 /* Remove the cell. */
779 layout_destroy_cell(wp
->layout_cell
, &wp
->window
->layout_root
);
781 /* Fix pane offsets and sizes. */
782 if (wp
->window
->layout_root
!= NULL
) {
783 layout_fix_offsets(wp
->window
->layout_root
);
784 layout_fix_panes(wp
->window
, wp
->window
->sx
, wp
->window
->sy
);
786 notify_window_layout_changed(wp
->window
);