xref: /openbsd-src/usr.bin/tmux/screen.c (revision 43003dfe3ad45d1698bed8a37f2b0f5b14f20d4f)
1 /* $OpenBSD: screen.c,v 1.11 2009/08/08 13:29:27 nicm Exp $ */
2 
3 /*
4  * Copyright (c) 2007 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 <stdlib.h>
22 #include <string.h>
23 #include <vis.h>
24 
25 #include "tmux.h"
26 
27 void	screen_resize_x(struct screen *, u_int);
28 void	screen_resize_y(struct screen *, u_int);
29 
30 /* Create a new screen. */
31 void
32 screen_init(struct screen *s, u_int sx, u_int sy, u_int hlimit)
33 {
34 	s->grid = grid_create(sx, sy, hlimit);
35 
36 	s->title = xstrdup("");
37 
38 	s->tabs = NULL;
39 
40 	screen_reinit(s);
41 }
42 
43 /* Reinitialise screen. */
44 void
45 screen_reinit(struct screen *s)
46 {
47 	s->cx = 0;
48 	s->cy = 0;
49 
50 	s->rupper = 0;
51 	s->rlower = screen_size_y(s) - 1;
52 
53 	s->mode = MODE_CURSOR;
54 
55 	screen_reset_tabs(s);
56 
57 	grid_clear_lines(s->grid, s->grid->hsize, s->grid->sy);
58 
59 	screen_clear_selection(s);
60 }
61 
62 /* Destroy a screen. */
63 void
64 screen_free(struct screen *s)
65 {
66 	if (s->tabs != NULL)
67 		xfree(s->tabs);
68 	xfree(s->title);
69 	grid_destroy(s->grid);
70 }
71 
72 /* Reset tabs to default, eight spaces apart. */
73 void
74 screen_reset_tabs(struct screen *s)
75 {
76 	u_int	i;
77 
78 	if (s->tabs != NULL)
79 		xfree(s->tabs);
80 
81 	if ((s->tabs = bit_alloc(screen_size_x(s))) == NULL)
82 		fatal("bit_alloc failed");
83 	for (i = 8; i < screen_size_x(s); i += 8)
84 		bit_set(s->tabs, i);
85 }
86 
87 /* Set screen title. */
88 void
89 screen_set_title(struct screen *s, const char *title)
90 {
91 	char	tmp[BUFSIZ];
92 
93 	strnvis(tmp, title, sizeof tmp, VIS_OCTAL|VIS_TAB|VIS_NL);
94 
95 	xfree(s->title);
96 	s->title = xstrdup(tmp);
97 }
98 
99 /* Resize screen. */
100 void
101 screen_resize(struct screen *s, u_int sx, u_int sy)
102 {
103 	if (sx < 1)
104 		sx = 1;
105 	if (sy < 1)
106 		sy = 1;
107 
108 	if (sx != screen_size_x(s)) {
109 		screen_resize_x(s, sx);
110 
111 		/*
112 		 * It is unclear what should happen to tabs on resize. xterm
113 		 * seems to try and maintain them, rxvt resets them. Resetting
114 		 * is simpler and more reliable so let's do that.
115 		 */
116 		screen_reset_tabs(s);
117 	}
118 
119 	if (sy != screen_size_y(s))
120 		screen_resize_y(s, sy);
121 }
122 
123 void
124 screen_resize_x(struct screen *s, u_int sx)
125 {
126 	struct grid		*gd = s->grid;
127 
128 	if (sx == 0)
129 		fatalx("zero size");
130 
131 	/*
132 	 * Treat resizing horizontally simply: just ensure the cursor is
133 	 * on-screen and change the size. Don't bother to truncate any lines -
134 	 * then the data should be accessible if the size is then incrased.
135 	 *
136 	 * The only potential wrinkle is if UTF-8 double-width characters are
137 	 * left in the last column, but UTF-8 terminals should deal with this
138 	 * sanely.
139 	 */
140 	if (s->cx >= sx)
141 		s->cx = sx - 1;
142 	gd->sx = sx;
143 }
144 
145 void
146 screen_resize_y(struct screen *s, u_int sy)
147 {
148 	struct grid	*gd = s->grid;
149 	u_int		 needed, available, oldy, i;
150 
151 	if (sy == 0)
152 		fatalx("zero size");
153 	oldy = screen_size_y(s);
154 
155 	/*
156 	 * When resizing:
157 	 *
158 	 * If the height is decreasing, delete lines from the bottom until
159 	 * hitting the cursor, then push lines from the top into the history.
160 	 *
161 	 * When increasing, pull as many lines as possible from the history to
162 	 * the top, then fill the remaining with blanks at the bottom.
163 	 */
164 
165 	/* Size decreasing. */
166 	if (sy < oldy) {
167 		needed = oldy - sy;
168 
169 		/* Delete as many lines as possible from the bottom. */
170 		available = oldy - 1 - s->cy;
171 		if (available > 0) {
172 			if (available > needed)
173 				available = needed;
174 			grid_view_delete_lines(gd, oldy - available, available);
175 		}
176 		needed -= available;
177 
178 		/*
179 		 * Now just increase the history size, if possible, to take
180 		 * over the lines which are left. If history is off, delete
181 		 * lines from the top.
182 		 *
183 		 * XXX Should apply history limit?
184 		 */
185 		available = s->cy;
186 		if (gd->flags & GRID_HISTORY)
187 			gd->hsize += needed;
188 		else if (needed > 0 && available > 0) {
189 			if (available > needed)
190 				available = needed;
191 			grid_view_delete_lines(gd, 0, available);
192 		}
193 		s->cy -= needed;
194  	}
195 
196 	/* Resize line arrays. */
197 	gd->linedata = xrealloc(
198 	    gd->linedata, gd->hsize + sy, sizeof *gd->linedata);
199 
200 	/* Size increasing. */
201 	if (sy > oldy) {
202 		needed = sy - oldy;
203 
204 		/*
205 		 * Try to pull as much as possible out of the history, if is
206 		 * is enabled.
207 		 */
208 		available = gd->hsize;
209 		if (gd->flags & GRID_HISTORY && available > 0) {
210 			if (available > needed)
211 				available = needed;
212 			gd->hsize -= available;
213 			s->cy += available;
214 		} else
215 			available = 0;
216 		needed -= available;
217 
218 		/* Then fill the rest in with blanks. */
219 		for (i = gd->hsize + sy - needed; i < gd->hsize + sy; i++)
220 			memset(&gd->linedata[i], 0, sizeof gd->linedata[i]);
221 	}
222 
223 	/* Set the new size, and reset the scroll region. */
224 	gd->sy = sy;
225 	s->rupper = 0;
226 	s->rlower = screen_size_y(s) - 1;
227 }
228 
229 /* Set selection. */
230 void
231 screen_set_selection(struct screen *s,
232     u_int sx, u_int sy, u_int ex, u_int ey, struct grid_cell *gc)
233 {
234 	struct screen_sel	*sel = &s->sel;
235 
236 	memcpy(&sel->cell, gc, sizeof sel->cell);
237 
238 	sel->flag = 1;
239 	if (ey < sy || (sy == ey && ex < sx)) {
240 		sel->sx = ex; sel->sy = ey;
241 		sel->ex = sx; sel->ey = sy;
242 	} else {
243 		sel->sx = sx; sel->sy = sy;
244 		sel->ex = ex; sel->ey = ey;
245 	}
246 }
247 
248 /* Clear selection. */
249 void
250 screen_clear_selection(struct screen *s)
251 {
252 	struct screen_sel	*sel = &s->sel;
253 
254 	sel->flag = 0;
255 }
256 
257 /* Check if cell in selection. */
258 int
259 screen_check_selection(struct screen *s, u_int px, u_int py)
260 {
261 	struct screen_sel	*sel = &s->sel;
262 
263 	if (!sel->flag || py < sel->sy || py > sel->ey)
264 		return (0);
265 
266 	if (py == sel->sy && py == sel->ey) {
267 		if (px < sel->sx || px > sel->ex)
268 			return (0);
269 		return (1);
270 	}
271 
272 	if ((py == sel->sy && px < sel->sx) || (py == sel->ey && px > sel->ex))
273 		return (0);
274 	return (1);
275 }
276