diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/miscellany/less-177/position.c

   1 /*
   2  * Routines dealing with the "position" table.
   3  * This is a table which tells the position (in the input file) of the
   4  * first char on each currently displayed line.
   5  *
   6  * {{ The position table is scrolled by moving all the entries.
   7  *    Would be better to have a circular table
   8  *    and just change a couple of pointers. }}
   9  */
  10
  11 #include "less.h"
  12 #include "position.h"
  13
  14 static POSITION *table = NULL;  /* The position table */
  15 static int table_size;
  16
  17 extern int sc_width, sc_height;
  18
  19 /*
  20  * Return the starting file position of a line displayed on the screen.
  21  * The line may be specified as a line number relative to the top
  22  * of the screen, but is usually one of these special cases:
  23  *      the top (first) line on the screen
  24  *      the second line on the screen
  25  *      the bottom line on the screen
  26  *      the line after the bottom line on the screen
  27  */
  28         public POSITION
  29 position(where)
  30         int where;
  31 {
  32         switch (where)
  33         {
  34         case BOTTOM:
  35                 where = sc_height - 2;
  36                 break;
  37         case BOTTOM_PLUS_ONE:
  38                 where = sc_height - 1;
  39                 break;
  40         case MIDDLE:
  41                 where = sc_height / 2;
  42         }
  43         return (table[where]);
  44 }
  45
  46 /*
  47  * Add a new file position to the bottom of the position table.
  48  */
  49         public void
  50 add_forw_pos(pos)
  51         POSITION pos;
  52 {
  53         register int i;
  54
  55         /*
  56          * Scroll the position table up.
  57          */
  58         for (i = 1;  i < sc_height;  i++)
  59                 table[i-1] = table[i];
  60         table[sc_height - 1] = pos;
  61 }
  62
  63 /*
  64  * Add a new file position to the top of the position table.
  65  */
  66         public void
  67 add_back_pos(pos)
  68         POSITION pos;
  69 {
  70         register int i;
  71
  72         /*
  73          * Scroll the position table down.
  74          */
  75         for (i = sc_height - 1;  i > 0;  i--)
  76                 table[i] = table[i-1];
  77         table[0] = pos;
  78 }
  79
  80 /*
  81  * Initialize the position table, done whenever we clear the screen.
  82  */
  83         public void
  84 pos_clear()
  85 {
  86         register int i;
  87
  88         for (i = 0;  i < sc_height;  i++)
  89                 table[i] = NULL_POSITION;
  90 }
  91
  92 /*
  93  * Allocate the position table.
  94  */
  95         public void
  96 pos_init()
  97 {
  98         if (sc_height <= table_size)
  99                 return;
 100         if (table != NULL)
 101                 free((char*)table);
 102         table = (POSITION *) ecalloc(sc_height, sizeof(POSITION));
 103         table_size = sc_height;
 104 }
 105
 106 /*
 107  * See if the byte at a specified position is currently on the screen.
 108  * Check the position table to see if the position falls within its range.
 109  * Return the position table entry if found, -1 if not.
 110  */
 111         public int
 112 onscreen(pos)
 113         POSITION pos;
 114 {
 115         register int i;
 116
 117         if (pos < table[0])
 118                 return (-1);
 119         for (i = 1;  i < sc_height;  i++)
 120                 if (pos < table[i])
 121                         return (i-1);
 122         return (-1);
 123 }
 124
 125 /*
 126  * See if the entire screen is empty.
 127  */
 128         public int
 129 empty_screen()
 130 {
 131         return (empty_lines(0, sc_height-1));
 132 }
 133
 134         public int
 135 empty_lines(s, e)
 136         int s;
 137         int e;
 138 {
 139         register int i;
 140
 141         for (i = s;  i <= e;  i++)
 142                 if (table[i] != NULL_POSITION)
 143                         return (0);
 144         return (1);
 145 }
 146
 147 /*
 148  * Get the current screen position.
 149  * The screen position consists of both a file position and
 150  * a screen line number where the file position is placed on the screen.
 151  * Normally the screen line number is 0, but if we are positioned
 152  * such that the top few lines are empty, we may have to set
 153  * the screen line to a number > 0.
 154  */
 155         public void
 156 get_scrpos(scrpos)
 157         struct scrpos *scrpos;
 158 {
 159         register int i;
 160
 161         /*
 162          * Find the first line on the screen which has something on it,
 163          * and return the screen line number and the file position.
 164          */
 165         for (i = 0; i < sc_height;  i++)
 166                 if (table[i] != NULL_POSITION)
 167                 {
 168                         scrpos->ln = i+1;
 169                         scrpos->pos = table[i];
 170                         return;
 171                 }
 172         /*
 173          * The screen is empty.
 174          */
 175         scrpos->pos = NULL_POSITION;
 176 }
 177
 178 /*
 179  * Adjust a screen line number to be a simple positive integer
 180  * in the range { 0 .. sc_height-2 }.
 181  * (The bottom line, sc_height-1, is reserved for prompts, etc.)
 182  * The given "sline" may be in the range { 1 .. sc_height-1 }
 183  * to refer to lines relative to the top of the screen (starting from 1),
 184  * or it may be in { -1 .. -(sc_height-1) } to refer to lines
 185  * relative to the bottom of the screen.
 186  */
 187         public int
 188 adjsline(sline)
 189         int sline;
 190 {
 191         /*
 192          * Negative screen line number means
 193          * relative to the bottom of the screen.
 194          */
 195         if (sline < 0)
 196                 sline += sc_height;
 197         /*
 198          * Can't be less than 1 or greater than sc_height-1.
 199          */
 200         if (sline <= 0)
 201                 sline = 1;
 202         if (sline >= sc_height)
 203                 sline = sc_height - 1;
 204         /*
 205          * Return zero-based line number, not one-based.
 206          */
 207         return (sline-1);
 208 }