home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c025 / 1.ddi / RCIBMLIB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-02-04  |  3.6 KB  |  136 lines
  1. /*            RUN/C SCREEN FUNCTIONS
  2.             for IBM PC and PC clones
  3.  
  4.     Functions:    cls()        (clear screen)
  5.             locate()    (move cursor or report its position)
  6.  
  7.  
  8.     Note:    This source code is provided by Age of Reason, Inc.
  9.         for information only.  AofR guarantees neither correctness
  10.         nor support.  Nevertheless, having disclaimed all that is 
  11.         necessary, we will be happy to provide advice and would
  12.         appreciate any bug reports.
  13.  
  14.     Note:    These functions make use of the IBM PC BIOS video 
  15.         call (function 10H).  To call the BIOS, Lattice C 
  16.         provides a function called int86(), which is used
  17.         in the fucntions below.  If you are not using Lattice,
  18.         then you must find a replacement for this function.
  19.  
  20.         
  21.     Function Descriptions:
  22.  
  23.     -------------------------------------------------
  24.         cls()        clears screen
  25.     -------------------------------------------------
  26.         int locate(row, column, mode)
  27.         int row, column, mode;
  28.  
  29.             if mode == 0: move cursor to (row, column)
  30.                     this is an absolute move
  31.                     1 <= row <= 25
  32.                     1 <= column <= 80
  33.                     no action if target position outside
  34.                         screen area.
  35.             if mode == 1: change cursor by (row, column)
  36.                     this is a relative move
  37.                     -24 <= row <= 24
  38.                     -79 <= column <= 79
  39.                     no action if target position outside
  40.                         screen area.
  41.             if mode == 2: return current cursor row
  42.                     (input row and column args irrelevant)
  43.             if mode == 3: return current cursor column
  44.                     (input row and column args irrelevant)
  45.  
  46.             row and column numbering starts at 1
  47.                 namely, (1,1) is upper-left
  48.             size of screen is governed by MAXROW and MAXCOLUMN.
  49.     -----------------------------------------------------------
  50. */
  51.  
  52. #define MAXROW        25
  53. #define MAXCOLUMN    80
  54.  
  55. /* the following are structures necessary to use the int86() call */
  56.  
  57. struct XREG
  58.     {
  59.     short ax,bx,cx,dx,si,di;
  60.     };
  61.  
  62. struct HREG
  63.     {
  64.     char al,ah,bl,bh,cl,ch,dl,dh;
  65.     };
  66.  
  67. union REGS
  68.     {
  69.     struct XREG x;
  70.     struct HREG h;
  71.     };
  72.  
  73.  
  74. cls()        /* clear screen */
  75. {union REGS r;
  76.  
  77.         /* set up registers for BIOS video call */
  78.     r.h.ah = 6;    /* scroll screen */
  79.     r.h.al = 0;    /* scroll entire window */
  80.     r.h.bh = 7;    /* char attribute = NORMAL or BLACK */
  81.     r.x.cx = 0;    /* top-left corner of window = (0,0) */
  82.     r.h.dl = 79;
  83.     r.h.dh = 24;    /* bottom-right corner of window = (25, 80) */
  84.     int86(0x10, &r, &r);    /* scroll window into bit bucket */
  85.     r.h.ah = 2;    /* set cursor position */
  86.     r.h.bh = r.x.dx = 0;
  87.     int86(0x10, &r, &r);    /* move cursor to upper-left */
  88. }
  89.  
  90. int locate(row, column, mode)    /* get or set cursor position */
  91. int row, column, mode;
  92. {
  93.     switch(mode)
  94.     {    case 0:        loc_amove(row, column);
  95.                 break;
  96.         case 1:        loc_dmove(row, column);
  97.                 break;
  98.         case 2:        loc_where(&row, &column);
  99.                 return(row);
  100.         case 3:        loc_where(&row, &column);
  101.                 return(column);
  102.     }
  103. }
  104.  
  105. loc_where(prow, pcolumn)    /* return cursor position */
  106. int *prow, *pcolumn;
  107. {union REGS r;
  108.  
  109.     r.h.ah = 3;    /* read cursor position */
  110.     r.h.bh = 0;    /* select page 0 */
  111.     int86(0x10, &r, &r);    /* make video call */
  112.     *prow = r.h.dh + 1;    /* add offset of 1 for upper-left = (1,1) */
  113.     *pcolumn = r.h.dl + 1;
  114. }
  115.  
  116. loc_amove(row, column)        /* absolute cursor move */
  117. int row, column;
  118. {union REGS r;
  119.  
  120.     if (row < 1  ||  row > MAXROW  ||  column < 1  ||  column > MAXCOLUMN)
  121.         return;
  122.     r.h.ah = 2;    /* set cursor position */
  123.     r.h.bh = 0;    /* select page 0 */
  124.     r.h.dh = row - 1;
  125.     r.h.dl = column - 1;
  126.     int86(0x10, &r, &r);
  127. }
  128.  
  129. loc_dmove(drow, dcolumn)    /* relaitve cursor move */
  130. int drow, dcolumn;
  131. {int currrow, currcolumn;
  132.  
  133.     loc_where(&currrow, &currcolumn);
  134.     loc_amove(currrow+drow, currcolumn+dcolumn);
  135. }
  136.