Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/tmux/resize.c	Lines:	0	69	0.0 %
Date:	2017-11-07	Branches:	0	74	0.0 %


/* $OpenBSD: resize.c,v 1.24 2017/08/28 12:36:38 nicm Exp $ */

/*
 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>

#include <string.h>

#include "tmux.h"

/*
 * Recalculate window and session sizes.
 *
 * Every session has the size of the smallest client it is attached to and
 * every window the size of the smallest session it is attached to.
 *
 * So, when a client is resized or a session attached to or detached from a
 * client, the window sizes must be recalculated. For each session, find the
 * smallest client it is attached to, and resize it to that size. Then for
 * every window, find the smallest session it is attached to, resize it to that
 * size and clear and redraw every client with it as the current window.
 *
 * This is quite inefficient - better/additional data structures are needed
 * to make it better.
 *
 * As a side effect, this function updates the SESSION_UNATTACHED flag. This
 * flag is necessary to make sure unattached sessions do not limit the size of
 * windows that are attached both to them and to other (attached) sessions.
 */

void
recalculate_sizes(void)
{
	struct session		*s;
	struct client		*c;
	struct window		*w;
	struct window_pane	*wp;
	u_int			 ssx, ssy, has, limit;
	int			 flag, has_status, is_zoomed, forced;

	RB_FOREACH(s, sessions, &sessions) {
		has_status = options_get_number(s->options, "status");

		s->attached = 0;
		ssx = ssy = UINT_MAX;
		TAILQ_FOREACH(c, &clients, entry) {
			if (c->flags & CLIENT_SUSPENDED)
				continue;
			if ((c->flags & (CLIENT_CONTROL|CLIENT_SIZECHANGED)) ==
			    CLIENT_CONTROL)
				continue;
			if (c->session == s) {
				if (c->tty.sx < ssx)
					ssx = c->tty.sx;
				if (has_status &&
				    !(c->flags & CLIENT_CONTROL) &&
				    c->tty.sy > 1 && c->tty.sy - 1 < ssy)
					ssy = c->tty.sy - 1;
				else if (c->tty.sy < ssy)
					ssy = c->tty.sy;
				s->attached++;
			}
		}
		if (ssx == UINT_MAX || ssy == UINT_MAX) {
			s->flags |= SESSION_UNATTACHED;
			continue;
		}
		s->flags &= ~SESSION_UNATTACHED;

		if (has_status && ssy == 0)
			ssy = 1;

		if (s->sx == ssx && s->sy == ssy)
			continue;

		log_debug("session $%u size %u,%u (was %u,%u)", s->id, ssx, ssy,
		    s->sx, s->sy);

		s->sx = ssx;
		s->sy = ssy;

		status_update_saved(s);
	}

	RB_FOREACH(w, windows, &windows) {
		if (w->active == NULL)
			continue;
		flag = options_get_number(w->options, "aggressive-resize");

		ssx = ssy = UINT_MAX;
		RB_FOREACH(s, sessions, &sessions) {
			if (s->flags & SESSION_UNATTACHED)
				continue;
			if (flag)
				has = s->curw->window == w;
			else
				has = session_has(s, w);
			if (has) {
				if (s->sx < ssx)
					ssx = s->sx;
				if (s->sy < ssy)
					ssy = s->sy;
			}
		}
		if (ssx == UINT_MAX || ssy == UINT_MAX)
			continue;

		forced = 0;
		limit = options_get_number(w->options, "force-width");
		if (limit >= PANE_MINIMUM && ssx > limit) {
			ssx = limit;
			forced |= WINDOW_FORCEWIDTH;
		}
		limit = options_get_number(w->options, "force-height");
		if (limit >= PANE_MINIMUM && ssy > limit) {
			ssy = limit;
			forced |= WINDOW_FORCEHEIGHT;
		}

		if (w->sx == ssx && w->sy == ssy)
			continue;
		log_debug("window @%u size %u,%u (was %u,%u)", w->id, ssx, ssy,
		    w->sx, w->sy);

		w->flags &= ~(WINDOW_FORCEWIDTH|WINDOW_FORCEHEIGHT);
		w->flags |= forced;

		is_zoomed = w->flags & WINDOW_ZOOMED;
		if (is_zoomed)
			window_unzoom(w);
		layout_resize(w, ssx, ssy);
		window_resize(w, ssx, ssy);
		if (is_zoomed && window_pane_visible(w->active))
			window_zoom(w->active);

		/*
		 * If the current pane is now not visible, move to the next
		 * that is.
		 */
		wp = w->active;
		while (!window_pane_visible(w->active)) {
			w->active = TAILQ_PREV(w->active, window_panes, entry);
			if (w->active == NULL)
				w->active = TAILQ_LAST(&w->panes, window_panes);
			if (w->active == wp)
			       break;
		}
		if (w->active == w->last)
			w->last = NULL;

		server_redraw_window(w);
		notify_window("window-layout-changed", w);
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: resize.c,v 1.24 2017/08/28 12:36:38 nicm Exp $ */
2
3			/*
4			* Copyright (c) 2007 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 <string.h>
22
23			#include "tmux.h"
24
25			/*
26			* Recalculate window and session sizes.
27			*
28			* Every session has the size of the smallest client it is attached to and
29			* every window the size of the smallest session it is attached to.
30			*
31			* So, when a client is resized or a session attached to or detached from a
32			* client, the window sizes must be recalculated. For each session, find the
33			* smallest client it is attached to, and resize it to that size. Then for
34			* every window, find the smallest session it is attached to, resize it to that
35			* size and clear and redraw every client with it as the current window.
36			*
37			* This is quite inefficient - better/additional data structures are needed
38			* to make it better.
39			*
40			* As a side effect, this function updates the SESSION_UNATTACHED flag. This
41			* flag is necessary to make sure unattached sessions do not limit the size of
42			* windows that are attached both to them and to other (attached) sessions.
43			*/
44
45			void
46			recalculate_sizes(void)
47			{
48			struct session *s;
49			struct client *c;
50			struct window *w;
51			struct window_pane *wp;
52			u_int ssx, ssy, has, limit;
53			int flag, has_status, is_zoomed, forced;
54
55			RB_FOREACH(s, sessions, &sessions) {
56			has_status = options_get_number(s->options, "status");
57
58			s->attached = 0;
59			ssx = ssy = UINT_MAX;
60			TAILQ_FOREACH(c, &clients, entry) {
61			if (c->flags & CLIENT_SUSPENDED)
62			continue;
63			if ((c->flags & (CLIENT_CONTROL\|CLIENT_SIZECHANGED)) ==
64			CLIENT_CONTROL)
65			continue;
66			if (c->session == s) {
67			if (c->tty.sx < ssx)
68			ssx = c->tty.sx;
69			if (has_status &&
70			!(c->flags & CLIENT_CONTROL) &&
71			c->tty.sy > 1 && c->tty.sy - 1 < ssy)
72			ssy = c->tty.sy - 1;
73			else if (c->tty.sy < ssy)
74			ssy = c->tty.sy;
75			s->attached++;
76			}
77			}
78			if (ssx == UINT_MAX \|\| ssy == UINT_MAX) {
79			s->flags \|= SESSION_UNATTACHED;
80			continue;
81			}
82			s->flags &= ~SESSION_UNATTACHED;
83
84			if (has_status && ssy == 0)
85			ssy = 1;
86
87			if (s->sx == ssx && s->sy == ssy)
88			continue;
89
90			log_debug("session $%u size %u,%u (was %u,%u)", s->id, ssx, ssy,
91			s->sx, s->sy);
92
93			s->sx = ssx;
94			s->sy = ssy;
95
96			status_update_saved(s);
97			}
98
99			RB_FOREACH(w, windows, &windows) {
100			if (w->active == NULL)
101			continue;
102			flag = options_get_number(w->options, "aggressive-resize");
103
104			ssx = ssy = UINT_MAX;
105			RB_FOREACH(s, sessions, &sessions) {
106			if (s->flags & SESSION_UNATTACHED)
107			continue;
108			if (flag)
109			has = s->curw->window == w;
110			else
111			has = session_has(s, w);
112			if (has) {
113			if (s->sx < ssx)
114			ssx = s->sx;
115			if (s->sy < ssy)
116			ssy = s->sy;
117			}
118			}
119			if (ssx == UINT_MAX \|\| ssy == UINT_MAX)
120			continue;
121
122			forced = 0;
123			limit = options_get_number(w->options, "force-width");
124			if (limit >= PANE_MINIMUM && ssx > limit) {
125			ssx = limit;
126			forced \|= WINDOW_FORCEWIDTH;
127			}
128			limit = options_get_number(w->options, "force-height");
129			if (limit >= PANE_MINIMUM && ssy > limit) {
130			ssy = limit;
131			forced \|= WINDOW_FORCEHEIGHT;
132			}
133
134			if (w->sx == ssx && w->sy == ssy)
135			continue;
136			log_debug("window @%u size %u,%u (was %u,%u)", w->id, ssx, ssy,
137			w->sx, w->sy);
138
139			w->flags &= ~(WINDOW_FORCEWIDTH\|WINDOW_FORCEHEIGHT);
140			w->flags \|= forced;
141
142			is_zoomed = w->flags & WINDOW_ZOOMED;
143			if (is_zoomed)
144			window_unzoom(w);
145			layout_resize(w, ssx, ssy);
146			window_resize(w, ssx, ssy);
147			if (is_zoomed && window_pane_visible(w->active))
148			window_zoom(w->active);
149
150			/*
151			* If the current pane is now not visible, move to the next
152			* that is.
153			*/
154			wp = w->active;
155			while (!window_pane_visible(w->active)) {
156			w->active = TAILQ_PREV(w->active, window_panes, entry);
157			if (w->active == NULL)
158			w->active = TAILQ_LAST(&w->panes, window_panes);
159			if (w->active == wp)
160			break;
161			}
162			if (w->active == w->last)
163			w->last = NULL;
164
165			server_redraw_window(w);
166			notify_window("window-layout-changed", w);
167			}
168			}