contrib/less/forwback.c

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