forwback.c revision 161478 
1/* $FreeBSD: head/contrib/less/forwback.c 161478 2006-08-20 15:50:51Z delphij $ */
2/*
3 * Copyright (C) 1984-2005  Mark Nudelman
4 *
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Less License, as specified in the README file.
7 *
8 * For more information about less, or for information on how to
9 * contact the author, see the README file.
10 */
11
12
13/*
14 * Primitives for displaying the file on the screen,
15 * scrolling either forward or backward.
16 */
17
18#include "less.h"
19#include "position.h"
20
21public int hit_eof;	/* Keeps track of how many times we hit end of file */
22public int screen_trashed;
23public int squished;
24public int no_back_scroll = 0;
25
26extern int sigs;
27extern int top_scroll;
28extern int quiet;
29extern int sc_width, sc_height;
30extern int quit_at_eof;
31extern int more_mode;
32extern int plusoption;
33extern int forw_scroll;
34extern int back_scroll;
35extern int ignore_eoi;
36extern int clear_bg;
37extern int final_attr;
38#if TAGS
39extern char *tagoption;
40#endif
41
42/*
43 * Sound the bell to indicate user is trying to move past end of file.
44 */
45	static void
46eof_bell()
47{
48	if (quiet == NOT_QUIET)
49		bell();
50	else
51		vbell();
52}
53
54/*
55 * Check to see if the end of file is currently "displayed".
56 */
57	static void
58eof_check()
59{
60	POSITION pos;
61
62	if (ignore_eoi)
63		return;
64	if (ABORT_SIGS())
65		return;
66	/*
67	 * If the bottom line is empty, we are at EOF.
68	 * If the bottom line ends at the file length,
69	 * we must be just at EOF.
70	 */
71	pos = position(BOTTOM_PLUS_ONE);
72	if (pos == NULL_POSITION || pos == ch_length())
73		hit_eof++;
74}
75
76/*
77 * If the screen is "squished", repaint it.
78 * "Squished" means the first displayed line is not at the top
79 * of the screen; this can happen when we display a short file
80 * for the first time.
81 */
82	static void
83squish_check()
84{
85	if (!squished)
86		return;
87	squished = 0;
88	repaint();
89}
90
91/*
92 * Display n lines, scrolling forward,
93 * starting at position pos in the input file.
94 * "force" means display the n lines even if we hit end of file.
95 * "only_last" means display only the last screenful if n > screen size.
96 * "nblank" is the number of blank lines to draw before the first
97 *   real line.  If nblank > 0, the pos must be NULL_POSITION.
98 *   The first real line after the blanks will start at ch_zero().
99 */
100	public void
101forw(n, pos, force, only_last, nblank)
102	register int n;
103	POSITION pos;
104	int force;
105	int only_last;
106	int nblank;
107{
108	int eof = 0;
109	int nlines = 0;
110	int do_repaint;
111	static int first_time = 1;
112
113	squish_check();
114
115	/*
116	 * do_repaint tells us not to display anything till the end,
117	 * then just repaint the entire screen.
118	 * We repaint if we are supposed to display only the last
119	 * screenful and the request is for more than a screenful.
120	 * Also if the request exceeds the forward scroll limit
121	 * (but not if the request is for exactly a screenful, since
122	 * repainting itself involves scrolling forward a screenful).
123	 */
124	do_repaint = (only_last && n > sc_height-1) ||
125		(forw_scroll >= 0 && n > forw_scroll && n != sc_height-1);
126
127	if (!do_repaint)
128	{
129		if (top_scroll && n >= sc_height - 1 && pos != ch_length())
130		{
131			/*
132			 * Start a new screen.
133			 * {{ This is not really desirable if we happen
134			 *    to hit eof in the middle of this screen,
135			 *    but we don't yet know if that will happen. }}
136			 */
137			pos_clear();
138			add_forw_pos(pos);
139			force = 1;
140			if (more_mode == 0)
141			{
142				if (top_scroll == OPT_ONPLUS || (first_time && top_scroll != OPT_ON))
143					clear();
144				home();
145			}
146		} else
147		{
148			clear_bot();
149		}
150
151		if (pos != position(BOTTOM_PLUS_ONE) || empty_screen())
152		{
153			/*
154			 * This is not contiguous with what is
155			 * currently displayed.  Clear the screen image
156			 * (position table) and start a new screen.
157			 */
158			pos_clear();
159			add_forw_pos(pos);
160			force = 1;
161			if (top_scroll)
162			{
163				if (top_scroll == OPT_ONPLUS)
164					clear();
165				home();
166			} else if (!first_time)
167			{
168				putstr("...skipping...\n");
169			}
170		}
171	}
172
173	while (--n >= 0)
174	{
175		/*
176		 * Read the next line of input.
177		 */
178		if (nblank > 0)
179		{
180			/*
181			 * Still drawing blanks; don't get a line
182			 * from the file yet.
183			 * If this is the last blank line, get ready to
184			 * read a line starting at ch_zero() next time.
185			 */
186			if (--nblank == 0)
187				pos = ch_zero();
188		} else
189		{
190			/*
191			 * Get the next line from the file.
192			 */
193			pos = forw_line(pos);
194			if (pos == NULL_POSITION)
195			{
196				/*
197				 * End of file: stop here unless the top line
198				 * is still empty, or "force" is true.
199				 * Even if force is true, stop when the last
200				 * line in the file reaches the top of screen.
201				 */
202				eof = 1;
203				if (!force && position(TOP) != NULL_POSITION)
204					break;
205				if (!empty_lines(0, 0) &&
206				    !empty_lines(1, 1) &&
207				     empty_lines(2, sc_height-1))
208					break;
209			}
210		}
211		/*
212		 * Add the position of the next line to the position table.
213		 * Display the current line on the screen.
214		 */
215		add_forw_pos(pos);
216		nlines++;
217		if (do_repaint)
218			continue;
219		/*
220		 * If this is the first screen displayed and
221		 * we hit an early EOF (i.e. before the requested
222		 * number of lines), we "squish" the display down
223		 * at the bottom of the screen.
224		 * But don't do this if a + option or a -t option
225		 * was given.  These options can cause us to
226		 * start the display after the beginning of the file,
227		 * and it is not appropriate to squish in that case.
228		 */
229		if ((first_time || more_mode) &&
230		    pos == NULL_POSITION && !top_scroll &&
231#if TAGS
232		    tagoption == NULL &&
233#endif
234		    !plusoption)
235		{
236			squished = 1;
237			continue;
238		}
239		if (top_scroll == OPT_ON)
240			clear_eol();
241		put_line();
242		if (clear_bg && apply_at_specials(final_attr) != AT_NORMAL)
243		{
244			/*
245			 * Writing the last character on the last line
246			 * of the display may have scrolled the screen.
247			 * If we were in standout mode, clear_bg terminals
248			 * will fill the new line with the standout color.
249			 * Now we're in normal mode again, so clear the line.
250			 */
251			clear_eol();
252		}
253	}
254
255	if (ignore_eoi)
256		hit_eof = 0;
257	else if (eof && !ABORT_SIGS())
258		hit_eof++;
259	else
260		eof_check();
261	if (nlines == 0)
262		eof_bell();
263	else if (do_repaint)
264		repaint();
265	first_time = 0;
266	(void) currline(BOTTOM);
267}
268
269/*
270 * Display n lines, scrolling backward.
271 */
272	public void
273back(n, pos, force, only_last)
274	register int n;
275	POSITION pos;
276	int force;
277	int only_last;
278{
279	int nlines = 0;
280	int do_repaint;
281
282	squish_check();
283	do_repaint = (n > get_back_scroll() || (only_last && n > sc_height-1));
284	hit_eof = 0;
285	while (--n >= 0)
286	{
287		/*
288		 * Get the previous line of input.
289		 */
290		pos = back_line(pos);
291		if (pos == NULL_POSITION)
292		{
293			/*
294			 * Beginning of file: stop here unless "force" is true.
295			 */
296			if (!force)
297				break;
298		}
299		/*
300		 * Add the position of the previous line to the position table.
301		 * Display the line on the screen.
302		 */
303		add_back_pos(pos);
304		nlines++;
305		if (!do_repaint)
306		{
307			home();
308			add_line();
309			put_line();
310		}
311	}
312
313	eof_check();
314	if (nlines == 0)
315		eof_bell();
316	else if (do_repaint)
317		repaint();
318	(void) currline(BOTTOM);
319}
320
321/*
322 * Display n more lines, forward.
323 * Start just after the line currently displayed at the bottom of the screen.
324 */
325	public void
326forward(n, force, only_last)
327	int n;
328	int force;
329	int only_last;
330{
331	POSITION pos;
332
333	if (quit_at_eof && hit_eof && !(ch_getflags() & CH_HELPFILE))
334	{
335		/*
336		 * If the -e flag is set and we're trying to go
337		 * forward from end-of-file, go on to the next file.
338		 */
339		if (edit_next(1))
340			quit(QUIT_OK);
341		return;
342	}
343
344	pos = position(BOTTOM_PLUS_ONE);
345	if (pos == NULL_POSITION && (!force || empty_lines(2, sc_height-1)))
346	{
347		if (ignore_eoi)
348		{
349			/*
350			 * ignore_eoi is to support A_F_FOREVER.
351			 * Back up until there is a line at the bottom
352			 * of the screen.
353			 */
354			if (empty_screen())
355				pos = ch_zero();
356			else
357			{
358				do
359				{
360					back(1, position(TOP), 1, 0);
361					pos = position(BOTTOM_PLUS_ONE);
362				} while (pos == NULL_POSITION);
363			}
364		} else
365		{
366			eof_bell();
367			hit_eof++;
368			return;
369		}
370	}
371	forw(n, pos, force, only_last, 0);
372}
373
374/*
375 * Display n more lines, backward.
376 * Start just before the line currently displayed at the top of the screen.
377 */
378	public void
379backward(n, force, only_last)
380	int n;
381	int force;
382	int only_last;
383{
384	POSITION pos;
385
386	pos = position(TOP);
387	if (pos == NULL_POSITION && (!force || position(BOTTOM) == 0))
388	{
389		eof_bell();
390		return;
391	}
392	back(n, pos, force, only_last);
393}
394
395/*
396 * Get the backwards scroll limit.
397 * Must call this function instead of just using the value of
398 * back_scroll, because the default case depends on sc_height and
399 * top_scroll, as well as back_scroll.
400 */
401	public int
402get_back_scroll()
403{
404	if (no_back_scroll)
405		return (0);
406	if (back_scroll >= 0)
407		return (back_scroll);
408	if (top_scroll)
409		return (sc_height - 2);
410	return (10000); /* infinity */
411}
412