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