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