home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource4 / 235_01 / ovfmove.c < prev    next >
Text File  |  1987-06-18  |  9KB  |  270 lines
  1. /*  026   6-Jan-87  ovfmove.c
  2.  
  3.         Copyright (c) 1987 by Blue Sky Software.  All rights reserved.
  4. */
  5.  
  6. #include <stdio.h>
  7. #include "ov.h"
  8.  
  9. /* The following define will effect the speed of some screen updates - for
  10.    the PC set it to 1 - make it higher for slower terminals with hardware
  11.    (firmware?) scrolling */
  12.  
  13. #define SCROLL_LIMIT 1         /* #lines to update b 4 just rewritting screen */
  14.  
  15. extern WINDOW cw;
  16. extern FILE_ENT files[];
  17.  
  18.  
  19. /******************************************************************************
  20.  **                           M O V E _ F I L E                              **
  21.  *****************************************************************************/
  22.  
  23. move_file(move_cmd)    /* move the file pointer around, scroll if needed */
  24. register int move_cmd;
  25. {
  26.  
  27.    register int dif;
  28.    int currow, scrolled = FALSE;
  29.    int last_idx, wrap_factor, redisplayed = FALSE;
  30.  
  31.    if (cw.nfiles == 0)                 /* don't even try if no files in dir */
  32.       return;
  33.  
  34.    if (move_cmd == PGUP || move_cmd == PGDN) { /* special case PgUp & PgDn */
  35.       pagedisp(move_cmd);                      /* all done by pagedisp() */
  36.       return;
  37.     }
  38.  
  39.    last_idx = cw.curidx;               /* remember where we were */
  40.  
  41.    wrap_factor = (cw.nrows * cw.ncols) - 1;  /* used for right/left wrap */
  42.  
  43.    /* translate left/right movement to up/down if only 1 column displayed */
  44.  
  45.    if (cw.ncols == 1)
  46.       move_cmd = move_cmd == RIGHT ? DOWN : (move_cmd == LEFT ? UP : move_cmd);
  47.  
  48.    switch (move_cmd) {
  49.  
  50.       case LEFT:                       /* left arrow */
  51.          cw.curidx -= cw.nrows;
  52.          if (cw.curidx < 0) {
  53.             cw.curidx += wrap_factor;
  54.             while (cw.curidx >= cw.nfiles)
  55.                cw.curidx -= cw.nrows;
  56.             if (cw.curidx == cw.nfiles - cw.nrows - 1)
  57.                cw.curidx += cw.nrows;
  58.           }
  59.           break;
  60.  
  61.       case RIGHT:                      /* right arrow */
  62.          cw.curidx += cw.nrows;
  63.          if (cw.curidx >= cw.nfiles) {
  64.             cw.curidx -= wrap_factor;
  65.             while (cw.curidx < 0)
  66.                cw.curidx += cw.nrows;
  67.             if (cw.curidx == cw.nrows)
  68.                cw.curidx = 0;
  69.          }
  70.          break;
  71.  
  72.       case UP:                         /* up arrow */
  73.          cw.curidx--;
  74.          if (cw.curidx < 0)
  75.             cw.curidx = cw.nfiles-1;
  76.          break;
  77.  
  78.       case DOWN:                       /* down arrow */
  79.          cw.curidx++;
  80.          if (cw.curidx >= cw.nfiles)
  81.             cw.curidx = 0;
  82.          break;
  83.  
  84.       case HOME:                       /* home key */
  85.          cw.curidx = 0;
  86.          break;
  87.  
  88.       case END:                        /* end key */
  89.          cw.curidx = cw.nfiles - 1;
  90.          break;
  91.    }
  92.  
  93.    /* scroll or redisplay the screen if the current position is not displayed */
  94.  
  95.    if (!on_screen(cw.curidx)) {        /* screen need to be adjusted? */
  96.  
  97.       /* if the display needs to be adjusted by less than SCROLL_LIMIT
  98.          rows in the display area, use the scroll routines, otherwise
  99.          just redisplay using new nbase value */
  100.  
  101.       currow = idx2lr(cw.curidx);      /* needed several times below */
  102.  
  103.       dif = (currow < cw.nbase) ? currow - cw.nbase :
  104.                                   currow - cw.nbase - cw.ndrows + 1;
  105.  
  106.       if (abs(dif) <= SCROLL_LIMIT) {    /* scroll? */
  107.  
  108.          fp_off(last_idx);               /* this way, ptr doesn't move */
  109.  
  110.          if (dif > 0)
  111.             while (dif--)
  112.                scroll_dn();
  113.          else
  114.             while (dif++)
  115.                scroll_up();
  116.          scrolled = TRUE;                 /* saves a call to fp_on() */
  117.  
  118.       } else {                            /* redisplay screen */
  119.  
  120.          adjust_window();                 /* recalc cw.nbase, etc */
  121.          update_window(1);                /* redisplay file names */
  122.          redisplayed = TRUE;              /* avoid extra fp_*() calls */
  123.       }
  124.    }
  125.  
  126.    /* deselect the last item if the file pointer has moved and the last
  127.       item is still displayed (and the screen wasn't adjusted) */
  128.  
  129.    if (!redisplayed && !scrolled && cw.curidx != last_idx &&
  130.        on_screen(last_idx))
  131.       fp_off(last_idx);
  132.  
  133.    /* highlight the current file if the file pointer moved and the screen
  134.       wasn't adjusted (adjustments set the pointer) */
  135.  
  136.    if (!redisplayed && !scrolled && cw.curidx != last_idx)
  137.       fp_on(cw.curidx);
  138. }
  139.  
  140.  
  141. /*****************************************************************************
  142.                                P A G E D I S P
  143.  *****************************************************************************/
  144.  
  145. static int
  146. pagedisp(dir)          /* page the file display indicated direction */
  147. int dir;
  148. {
  149.    int newidx;
  150.    register int newnbase = cw.nbase;
  151.  
  152.    if (dir == PGUP) {                  /* page up a screen? */
  153.  
  154.       newnbase -= cw.ndrows;           /* backup a screen */
  155.  
  156.    } else {                            /* must want to page down */
  157.  
  158.       newnbase += cw.ndrows;
  159.       if (newnbase + cw.ndrows > cw.nrows)  /* don't leave part of the  */
  160.          newnbase = cw.nrows - cw.ndrows;   /*   screen blank if avoidable */
  161.    }
  162.  
  163.    if (newnbase < 0)                   /* adjustments can go too far */
  164.       newnbase = 0;
  165.  
  166.    if (newnbase == cw.nbase) {         /* is the page the same? */
  167.       if (dir == PGUP)                 /* up direction? */
  168.          newidx = newnbase;            /* yes, goto top to page */
  169.       else
  170.          newidx = cw.nfiles - 1;       /* no, goto last file */
  171.       fp_off(cw.curidx);               /* move file pointer */
  172.       fp_on(cw.curidx = newidx);
  173.  
  174.    } else {            /* the page base changed, redisplay window */
  175.  
  176.       cw.nbase = newnbase;             /*  this is the one to use now      */
  177.       if (!on_screen(cw.curidx))       /*  will the old current file show? */
  178.          cw.curidx = newnbase;         /*  if not, we know this one will   */
  179.       update_window(1);                /*  display names at new offset     */
  180.    }
  181. }
  182.  
  183.  
  184. /******************************************************************************
  185.                         F P _ O N / O F F
  186.  *****************************************************************************/
  187.  
  188. int ALTCALL
  189. fp_on(i)               /* turn on the file pointer */
  190. register int i;
  191. {
  192.    gotorc(idx2sr(i),idx2sc(i));
  193.    disp_file(&files[i],1);
  194.    if (cw.showall)
  195.       disp_path(i);
  196. }
  197.  
  198. int ALTCALL
  199. fp_off(i)              /* turn off the file pointer */
  200. register int i;
  201. {
  202.    gotorc(idx2sr(i),idx2sc(i));
  203.    disp_file(&files[i],0);
  204. }
  205.  
  206.  
  207. /******************************************************************************
  208.                             O N _ S C R E E N
  209.  *****************************************************************************/
  210.  
  211. int ALTCALL
  212. on_screen(idx)         /* determine if file[idx] is currently displayed */
  213. register int idx;
  214. {
  215.    /* this used to be a macro, but it generates a lot of code */
  216.  
  217.    return(idx2lr(idx) >= idx2lr(cw.nbase) &&
  218.           idx2lr(idx) <= min(cw.nrows-1,idx2lr(cw.nbase)+cw.ndrows-1));
  219. }
  220.  
  221.  
  222. /******************************************************************************
  223.  **                    S C R O L L _ U P                                     **
  224.  *****************************************************************************/
  225.  
  226. static int
  227. scroll_up() {          /* scroll the file display up */
  228.  
  229.    register int m;
  230.  
  231.    cw.nbase -= 1;
  232.    insert_line(cw.fnrow+1,cw.ndrows-1);
  233.  
  234.    gotorc(cw.fnrow,0);                 /* cursor to first display position */
  235.  
  236.    /* display a row of file names */
  237.  
  238.    for (m = cw.nbase; m < cw.nfiles; m += cw.nrows)
  239.       disp_file(&files[m],m == cw.curidx);
  240.  
  241.    if (cw.showall)
  242.       disp_path(cw.curidx);
  243. }
  244.  
  245.  
  246. /******************************************************************************
  247.  **                    S C R O L L _ D N                                     **
  248.  *****************************************************************************/
  249.  
  250. static int
  251. scroll_dn() {          /* scr