1: /* $OpenBSD$ */
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 <stdlib.h>
22: #include <string.h>
23: #include <unistd.h>
24:
25: #include "tmux.h"
26:
27: static void screen_resize_x(struct screen *, u_int);
28: static void screen_resize_y(struct screen *, u_int);
29:
30: static void screen_reflow(struct screen *, u_int);
31:
32: /* Create a new screen. */
33: void
34: screen_init(struct screen *s, u_int sx, u_int sy, u_int hlimit)
35: {
36: s->grid = grid_create(sx, sy, hlimit);
37: s->title = xstrdup("");
38:
39: s->cstyle = 0;
40: s->ccolour = xstrdup("");
41: s->tabs = NULL;
42:
43: screen_reinit(s);
44: }
45:
46: /* Reinitialise screen. */
47: void
48: screen_reinit(struct screen *s)
49: {
50: s->cx = 0;
51: s->cy = 0;
52:
53: s->rupper = 0;
54: s->rlower = screen_size_y(s) - 1;
55:
56: s->mode = MODE_CURSOR | MODE_WRAP;
57:
58: screen_reset_tabs(s);
59:
60: grid_clear_lines(s->grid, s->grid->hsize, s->grid->sy, 8);
61:
62: screen_clear_selection(s);
63: }
64:
65: /* Destroy a screen. */
66: void
67: screen_free(struct screen *s)
68: {
69: free(s->tabs);
70: free(s->title);
71: free(s->ccolour);
72: grid_destroy(s->grid);
73: }
74:
75: /* Reset tabs to default, eight spaces apart. */
76: void
77: screen_reset_tabs(struct screen *s)
78: {
79: u_int i;
80:
81: free(s->tabs);
82:
83: if ((s->tabs = bit_alloc(screen_size_x(s))) == NULL)
84: fatal("bit_alloc failed");
85: for (i = 8; i < screen_size_x(s); i += 8)
86: bit_set(s->tabs, i);
87: }
88:
89: /* Set screen cursor style. */
90: void
91: screen_set_cursor_style(struct screen *s, u_int style)
92: {
93: if (style <= 6)
94: s->cstyle = style;
95: }
96:
97: /* Set screen cursor colour. */
98: void
99: screen_set_cursor_colour(struct screen *s, const char *colour)
100: {
101: free(s->ccolour);
102: s->ccolour = xstrdup(colour);
103: }
104:
105: /* Set screen title. */
106: void
107: screen_set_title(struct screen *s, const char *title)
108: {
109: free(s->title);
110: s->title = xstrdup(title);
111: }
112:
113: /* Resize screen. */
114: void
115: screen_resize(struct screen *s, u_int sx, u_int sy, int reflow)
116: {
117: if (sx < 1)
118: sx = 1;
119: if (sy < 1)
120: sy = 1;
121:
122: if (sx != screen_size_x(s)) {
123: screen_resize_x(s, sx);
124:
125: /*
126: * It is unclear what should happen to tabs on resize. xterm
127: * seems to try and maintain them, rxvt resets them. Resetting
128: * is simpler and more reliable so let's do that.
129: */
130: screen_reset_tabs(s);
131: }
132:
133: if (sy != screen_size_y(s))
134: screen_resize_y(s, sy);
135:
136: if (reflow)
137: screen_reflow(s, sx);
138: }
139:
140: static void
141: screen_resize_x(struct screen *s, u_int sx)
142: {
143: struct grid *gd = s->grid;
144:
145: if (sx == 0)
146: fatalx("zero size");
147:
148: /*
149: * Treat resizing horizontally simply: just ensure the cursor is
150: * on-screen and change the size. Don't bother to truncate any lines -
151: * then the data should be accessible if the size is then increased.
152: *
153: * The only potential wrinkle is if UTF-8 double-width characters are
154: * left in the last column, but UTF-8 terminals should deal with this
155: * sanely.
156: */
157: if (s->cx >= sx)
158: s->cx = sx - 1;
159: gd->sx = sx;
160: }
161:
162: static void
163: screen_resize_y(struct screen *s, u_int sy)
164: {
165: struct grid *gd = s->grid;
166: u_int needed, available, oldy, i;
167:
168: if (sy == 0)
169: fatalx("zero size");
170: oldy = screen_size_y(s);
171:
172: /*
173: * When resizing:
174: *
175: * If the height is decreasing, delete lines from the bottom until
176: * hitting the cursor, then push lines from the top into the history.
177: *
178: * When increasing, pull as many lines as possible from scrolled
179: * history (not explicitly cleared from view) to the top, then fill the
180: * remaining with blanks at the bottom.
181: */
182:
183: /* Size decreasing. */
184: if (sy < oldy) {
185: needed = oldy - sy;
186:
187: /* Delete as many lines as possible from the bottom. */
188: available = oldy - 1 - s->cy;
189: if (available > 0) {
190: if (available > needed)
191: available = needed;
192: grid_view_delete_lines(gd, oldy - available, available,
193: 8);
194: }
195: needed -= available;
196:
197: /*
198: * Now just increase the history size, if possible, to take
199: * over the lines which are left. If history is off, delete
200: * lines from the top.
201: */
202: available = s->cy;
203: if (gd->flags & GRID_HISTORY) {
204: gd->hscrolled += needed;
205: gd->hsize += needed;
206: } else if (needed > 0 && available > 0) {
207: if (available > needed)
208: available = needed;
209: grid_view_delete_lines(gd, 0, available, 8);
210: }
211: s->cy -= needed;
212: }
213:
214: /* Resize line arrays. */
215: gd->linedata = xreallocarray(gd->linedata, gd->hsize + sy,
216: sizeof *gd->linedata);
217:
218: /* Size increasing. */
219: if (sy > oldy) {
220: needed = sy - oldy;
221:
222: /*
223: * Try to pull as much as possible out of scrolled history, if
224: * is is enabled.
225: */
226: available = gd->hscrolled;
227: if (gd->flags & GRID_HISTORY && available > 0) {
228: if (available > needed)
229: available = needed;
230: gd->hscrolled -= available;
231: gd->hsize -= available;
232: s->cy += available;
233: } else
234: available = 0;
235: needed -= available;
236:
237: /* Then fill the rest in with blanks. */
238: for (i = gd->hsize + sy - needed; i < gd->hsize + sy; i++)
239: memset(&gd->linedata[i], 0, sizeof gd->linedata[i]);
240: }
241:
242: /* Set the new size, and reset the scroll region. */
243: gd->sy = sy;
244: s->rupper = 0;
245: s->rlower = screen_size_y(s) - 1;
246: }
247:
248: /* Set selection. */
249: void
250: screen_set_selection(struct screen *s, u_int sx, u_int sy,
251: u_int ex, u_int ey, u_int rectflag, struct grid_cell *gc)
252: {
253: struct screen_sel *sel = &s->sel;
254:
255: memcpy(&sel->cell, gc, sizeof sel->cell);
256: sel->flag = 1;
257: sel->hidden = 0;
258:
259: sel->rectflag = rectflag;
260:
261: sel->sx = sx; sel->sy = sy;
262: sel->ex = ex; sel->ey = ey;
263: }
264:
265: /* Clear selection. */
266: void
267: screen_clear_selection(struct screen *s)
268: {
269: struct screen_sel *sel = &s->sel;
270:
271: sel->flag = 0;
272: sel->hidden = 0;
273: sel->lineflag = LINE_SEL_NONE;
274: }
275:
276: /* Hide selection. */
277: void
278: screen_hide_selection(struct screen *s)
279: {
280: struct screen_sel *sel = &s->sel;
281:
282: sel->hidden = 1;
283: }
284:
285: /* Check if cell in selection. */
286: int
287: screen_check_selection(struct screen *s, u_int px, u_int py)
288: {
289: struct screen_sel *sel = &s->sel;
290: u_int xx;
291:
292: if (!sel->flag || sel->hidden)
293: return (0);
294:
295: if (sel->rectflag) {
296: if (sel->sy < sel->ey) {
297: /* start line < end line -- downward selection. */
298: if (py < sel->sy || py > sel->ey)
299: return (0);
300: } else if (sel->sy > sel->ey) {
301: /* start line > end line -- upward selection. */
302: if (py > sel->sy || py < sel->ey)
303: return (0);
304: } else {
305: /* starting line == ending line. */
306: if (py != sel->sy)
307: return (0);
308: }
309:
310: /*
311: * Need to include the selection start row, but not the cursor
312: * row, which means the selection changes depending on which
313: * one is on the left.
314: */
315: if (sel->ex < sel->sx) {
316: /* Cursor (ex) is on the left. */
317: if (px < sel->ex)
318: return (0);
319:
320: if (px > sel->sx)
321: return (0);
322: } else {
323: /* Selection start (sx) is on the left. */
324: if (px < sel->sx)
325: return (0);
326:
327: if (px > sel->ex)
328: return (0);
329: }
330: } else {
331: /*
332: * Like emacs, keep the top-left-most character, and drop the
333: * bottom-right-most, regardless of copy direction.
334: */
335: if (sel->sy < sel->ey) {
336: /* starting line < ending line -- downward selection. */
337: if (py < sel->sy || py > sel->ey)
338: return (0);
339:
340: if (py == sel->sy && px < sel->sx)
341: return (0);
342:
343: if (py == sel->ey && px > sel->ex)
344: return (0);
345: } else if (sel->sy > sel->ey) {
346: /* starting line > ending line -- upward selection. */
347: if (py > sel->sy || py < sel->ey)
348: return (0);
349:
350: if (py == sel->ey && px < sel->ex)
351: return (0);
352:
353: if (sel->modekeys == MODEKEY_EMACS)
354: xx = sel->sx - 1;
355: else
356: xx = sel->sx;
357: if (py == sel->sy && (sel->sx == 0 || px > xx))
358: return (0);
359: } else {
360: /* starting line == ending line. */
361: if (py != sel->sy)
362: return (0);
363:
364: if (sel->ex < sel->sx) {
365: /* cursor (ex) is on the left */
366: if (sel->modekeys == MODEKEY_EMACS)
367: xx = sel->sx - 1;
368: else
369: xx = sel->sx;
370: if (px > xx || px < sel->ex)
371: return (0);
372: } else {
373: /* selection start (sx) is on the left */
374: if (px < sel->sx || px > sel->ex)
375: return (0);
376: }
377: }
378: }
379:
380: return (1);
381: }
382:
383: /* Get selected grid cell. */
384: void
385: screen_select_cell(struct screen *s, struct grid_cell *dst,
386: const struct grid_cell *src)
387: {
388: if (!s->sel.flag || s->sel.hidden)
389: return;
390:
391: memcpy(dst, &s->sel.cell, sizeof *dst);
392:
393: utf8_copy(&dst->data, &src->data);
394: dst->attr = dst->attr & ~GRID_ATTR_CHARSET;
395: dst->attr |= src->attr & GRID_ATTR_CHARSET;
396: dst->flags = src->flags;
397: }
398:
399: /* Reflow wrapped lines. */
400: static void
401: screen_reflow(struct screen *s, u_int new_x)
402: {
403: struct grid *old = s->grid;
404: u_int change;
405:
406: s->grid = grid_create(old->sx, old->sy, old->hlimit);
407:
408: change = grid_reflow(s->grid, old, new_x);
409: if (change < s->cy)
410: s->cy -= change;
411: else
412: s->cy = 0;
413: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to screen.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / tmux