xref: /titanic_41/usr/src/ucblib/libcurses/cr_put.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)
1 /*
2  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 
6 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
7 /*	  All Rights Reserved  	*/
8 
9 /*
10  * Copyright (c) 1980 Regents of the University of California.
11  * All rights reserved.  The Berkeley software License Agreement
12  * specifies the terms and conditions for redistribution.
13  */
14 
15 #pragma ident	"%Z%%M%	%I%	%E% SMI"
16 
17 /*LINTLIBRARY*/
18 
19 #ifndef lint
20 static char
21 sccsid[] = "@(#)cr_put.c 1.7 89/03/27 SMI"; /* from UCB 5.1 85/06/07 */
22 #endif	/* not lint */
23 
24 #include	<string.h>
25 #include	"curses.ext"
26 #include	<term.h>
27 
28 #define	HARDTABS	8
29 
30 /* forward declarations */
31 
32 /* should be static, but we may have prior application-dependency, sigh!  */
33 void fgoto(void);
34 int plodput(char);
35 int plod(int);
36 int tabcol(int, int);
37 
38 /*
39  * Terminal driving and line formatting routines.
40  * Basic motion optimizations are done here as well
41  * as formatting of lines (printing of control characters,
42  * line numbering and the like).
43  */
44 
45 /*
46  * Sync the position of the output cursor.
47  * Most work here is rounding for terminal boundaries getting the
48  * column position implied by wraparound or the lack thereof and
49  * rolling up the screen to get destline on the screen.
50  */
51 
52 static int	outcol, outline, destcol, destline;
53 
54 WINDOW		*_win;
55 
56 int
mvcur(int ly,int lx,int y,int x)57 mvcur(int ly, int lx, int y, int x)
58 {
59 #ifdef DEBUG
60 	fprintf(outf, "MVCUR: moving cursor from (%d,%d) to (%d,%d)\n",
61 		ly, lx, y, x);
62 #endif
63 	destcol = x;
64 	destline = y;
65 	outcol = lx;
66 	outline = ly;
67 	fgoto();
68 	return (OK);
69 }
70 
71 void
fgoto(void)72 fgoto(void)
73 {
74 	char	*cgp;
75 	int	l, c;
76 
77 	if (destcol >= COLS) {
78 		destline += destcol / COLS;
79 		destcol %= COLS;
80 	}
81 	if (outcol >= COLS) {
82 		l = (outcol + 1) / COLS;
83 		outline += l;
84 		outcol %= COLS;
85 		if (AM == 0) {
86 			while (l > 0) {
87 				if (_pfast)
88 					if (CR)
89 						(void) _puts(CR);
90 					else
91 						(void) _putchar('\r');
92 				if (NL)
93 					(void) _puts(NL);
94 				else
95 					(void) _putchar('\n');
96 				l--;
97 			}
98 			outcol = 0;
99 		}
100 		if (outline > LINES - 1) {
101 			destline -= outline - (LINES - 1);
102 			outline = LINES - 1;
103 		}
104 	}
105 	if (destline >= LINES) {
106 		l = destline;
107 		destline = LINES - 1;
108 		if (outline < LINES - 1) {
109 			c = destcol;
110 			if (_pfast == 0 && !CA)
111 				destcol = 0;
112 			fgoto();
113 			destcol = c;
114 		}
115 		while (l >= LINES) {
116 			/*
117 			 * The following linefeed (or simulation thereof)
118 			 * is supposed to scroll up the screen, since we
119 			 * are on the bottom line.  We make the assumption
120 			 * that linefeed will scroll.  If ns is in the
121 			 * capability list this won't work.  We should
122 			 * probably have an sc capability but sf will
123 			 * generally take the place if it works.
124 			 *
125 			 * Superbee glitch:  in the middle of the screen we
126 			 * have to use esc B (down) because linefeed screws up
127 			 * in "Efficient Paging" (what a joke) mode (which is
128 			 * essential in some SB's because CRLF mode puts garbage
129 			 * in at end of memory), but you must use linefeed to
130 			 * scroll since down arrow won't go past memory end.
131 			 * I turned this off after recieving Paul Eggert's
132 			 * Superbee description which wins better.
133 			 */
134 			if (NL /* && !XB */ && _pfast)
135 				(void) _puts(NL);
136 			else
137 				(void) _putchar('\n');
138 			l--;
139 			if (_pfast == 0)
140 				outcol = 0;
141 		}
142 	}
143 	if (destline < outline && !(CA || UP))
144 		destline = outline;
145 	if (CA) {
146 		cgp = tgoto(CM, destcol, destline);
147 		if (plod((int)strlen(cgp)) > 0)
148 			(void) plod(0);
149 		else
150 			(void) tputs(cgp, 0, _putchar);
151 	}
152 	else
153 		(void) plod(0);
154 	outline = destline;
155 	outcol = destcol;
156 }
157 
158 /*
159  * Move (slowly) to destination.
160  * Hard thing here is using home cursor on really deficient terminals.
161  * Otherwise just use cursor motions, hacking use of tabs and overtabbing
162  * and backspace.
163  */
164 
165 static int plodcnt, plodflg;
166 
167 int
plodput(char c)168 plodput(char c)
169 {
170 	if (plodflg)
171 		plodcnt--;
172 	else
173 		(void) _putchar(c);
174 	return (OK);
175 }
176 
177 int
plod(int cnt)178 plod(int cnt)
179 {
180 	int i, j, k;
181 	int soutcol, soutline;
182 
183 	plodcnt = plodflg = cnt;
184 	soutcol = outcol;
185 	soutline = outline;
186 	/*
187 	 * Consider homing and moving down/right from there, vs moving
188 	 * directly with local motions to the right spot.
189 	 */
190 	if (HO) {
191 		/*
192 		 * i is the cost to home and tab/space to the right to
193 		 * get to the proper column.  This assumes ND space costs
194 		 * 1 char.  So i+destcol is cost of motion with home.
195 		 */
196 		if (GT)
197 			i = (destcol / HARDTABS) + (destcol % HARDTABS);
198 		else
199 			i = destcol;
200 		/*
201 		 * j is cost to move locally without homing
202 		 */
203 		if (destcol >= outcol) {	/* if motion is to the right */
204 			j = destcol / HARDTABS - outcol / HARDTABS;
205 			if (GT && j)
206 				j += destcol % HARDTABS;
207 			else
208 				j = destcol - outcol;
209 		}
210 		else
211 			/* leftward motion only works if we can backspace. */
212 			if (outcol - destcol <= i && (BS || BC))
213 				i = j = outcol - destcol;
214 					/* cheaper to backspace */
215 			else
216 				j = i + 1; /* impossibly expensive */
217 
218 		/* k is the absolute value of vertical distance */
219 		k = outline - destline;
220 		if (k < 0)
221 			k = -k;
222 		j += k;
223 
224 		/*
225 		 * Decision.  We may not have a choice if no UP.
226 		 */
227 		if (i + destline < j || (!UP && destline < outline)) {
228 			/*
229 			 * Cheaper to home.  Do it now and pretend it's a
230 			 * regular local motion.
231 			 */
232 			(void) tputs(HO, 0, plodput);
233 			outcol = outline = 0;
234 		} else if (LL) {
235 			/*
236 			 * Quickly consider homing down and moving from there.
237 			 * Assume cost of LL is 2.
238 			 */
239 			k = (LINES - 1) - destline;
240 			if (i + k + 2 < j && (k <= 0 || UP)) {
241 				(void) tputs(LL, 0, plodput);
242 				outcol = 0;
243 				outline = LINES - 1;
244 			}
245 		}
246 	}
247 	else
248 	/*
249 	 * No home and no up means it's impossible.
250 	 */
251 		if (!UP && destline < outline)
252 			return (-1);
253 	if (GT)
254 		i = destcol % HARDTABS + destcol / HARDTABS;
255 	else
256 		i = destcol;
257 /*
258  *	if (BT && outcol > destcol &&
259  *	    (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
260  *		j *= (k = (int)strlen(BT));
261  *		if ((k += (destcol&7)) > 4)
262  *			j += 8 - (destcol&7);
263  *		else
264  *			j += k;
265  *	}
266  *	else
267  */
268 		j = outcol - destcol;
269 	/*
270 	 * If we will later need a \n which will turn into a \r\n by
271 	 * the system or the terminal, then don't bother to try to \r.
272 	 */
273 	if ((NONL || !_pfast) && outline < destline)
274 		goto dontcr;
275 	/*
276 	 * If the terminal will do a \r\n and there isn't room for it,
277 	 * then we can't afford a \r.
278 	 */
279 	if (NC && outline >= destline)
280 		goto dontcr;
281 	/*
282 	 * If it will be cheaper, or if we can't back up, then send
283 	 * a return preliminarily.
284 	 */
285 	if (j > i + 1 || outcol > destcol && !BS && !BC) {
286 		/*
287 		 * BUG: this doesn't take the (possibly long) length
288 		 * of CR into account.
289 		 */
290 		if (CR)
291 			(void) tputs(CR, 0, plodput);
292 		else
293 			(void) plodput('\r');
294 		if (NC) {
295 			if (NL)
296 				(void) tputs(NL, 0, plodput);
297 			else
298 				(void) plodput('\n');
299 			outline++;
300 		}
301 		outcol = 0;
302 	}
303 dontcr:
304 	while (outline < destline) {
305 		outline++;
306 		if (NL)
307 			(void) tputs(NL, 0, plodput);
308 		else
309 			(void) plodput('\n');
310 		if (plodcnt < 0)
311 			goto out;
312 		if (NONL || _pfast == 0)
313 			outcol = 0;
314 	}
315 	if (BT)
316 		k = (int)strlen(BT);
317 	while (outcol > destcol) {
318 		if (plodcnt < 0)
319 			goto out;
320 /*
321  *		if (BT && outcol - destcol > k + 4) {
322  *			(void) tputs(BT, 0, plodput);
323  *			outcol--;
324  *			outcol &= ~7;
325  *			continue;
326  *		}
327  */
328 		outcol--;
329 		if (BC)
330 			(void) tputs(BC, 0, plodput);
331 		else
332 			(void) plodput('\b');
333 	}
334 	while (outline > destline) {
335 		outline--;
336 		(void) tputs(UP, 0, plodput);
337 		if (plodcnt < 0)
338 			goto out;
339 	}
340 	if (GT && destcol - outcol > 1) {
341 		for (;;) {
342 			i = tabcol(outcol, HARDTABS);
343 			if (i > destcol)
344 				break;
345 			if (TA)
346 				(void) tputs(TA, 0, plodput);
347 			else
348 				(void) plodput('\t');
349 			outcol = i;
350 		}
351 		if (destcol - outcol > 4 && i < COLS && (BC || BS)) {
352 			if (TA)
353 				(void) tputs(TA, 0, plodput);
354 			else
355 				(void) plodput('\t');
356 			outcol = i;
357 			while (outcol > destcol) {
358 				outcol--;
359 				if (BC)
360 					(void) tputs(BC, 0, plodput);
361 				else
362 					(void) plodput('\b');
363 			}
364 		}
365 	}
366 	while (outcol < destcol) {
367 		/*
368 		 * move one char to the right.  We don't use ND space
369 		 * because it's better to just print the char we are
370 		 * moving over.
371 		 */
372 		if (_win != NULL)
373 			if (plodflg)	/* avoid a complex calculation */
374 				plodcnt--;
375 			else {
376 				i = curscr->_y[outline][outcol];
377 				if ((i&_STANDOUT) == (curscr->_flags&_STANDOUT))
378 					(void) _putchar(i & 0177);
379 				else
380 					goto nondes;
381 			}
382 		else
383 nondes:
384 			if (ND)
385 				(void) tputs(ND, 0, plodput);
386 		else
387 			(void) plodput(' ');
388 		outcol++;
389 		if (plodcnt < 0)
390 			goto out;
391 	}
392 out:
393 	if (plodflg) {
394 		outcol = soutcol;
395 		outline = soutline;
396 	}
397 	return (plodcnt);
398 }
399 
400 /*
401  * Return the column number that results from being in column col and
402  * hitting a tab, where tabs are set every ts columns.  Work right for
403  * the case where col > COLS, even if ts does not divide COLS.
404  */
405 
406 int
tabcol(int col,int ts)407 tabcol(int col, int ts)
408 {
409 	int offset;
410 
411 	if (col >= COLS) {
412 		offset = COLS * (col / COLS);
413 		col -= offset;
414 	}
415 	else
416 		offset = 0;
417 	return (col + ts - (col % ts) + offset);
418 }
419