home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / CLIPPER / NFSRC.ZIP / VIDEO1.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-16  |  10.8 KB  |  425 lines
  1. /*
  2.  * File......: VIDEO1.C
  3.  * Author....: Robert A. DiFalco
  4.  * CIS ID....: 71610,1705
  5.  * Date......: $Date:   15 Aug 1991 23:29:26  $
  6.  * Revision..: $Revision:   1.3  $
  7.  * Log file..: $Logfile:   E:/nanfor/src/video1.c_v  $
  8.  * 
  9.  * This function is an original work by Robert A. DiFalco and is placed
  10.  * in the public domain.
  11.  *
  12.  * Modification history:
  13.  * ---------------------
  14.  *
  15.  * $Log:   E:/nanfor/src/video1.c_v  $
  16.  * 
  17.  *    Rev 1.3   15 Aug 1991 23:29:26   GLENN
  18.  * Robert made, in his words, some "big ol hairy ass changes" which 
  19.  * included using the Clipper internals _gtPreExt() and _gtPostExt()
  20.  * to avoid conflict with dispBegin() and dispEnd() display buffers.
  21.  *  
  22.  * Forest's documentation was left unscathed. 
  23.  *  
  24.  * 
  25.  *    Rev 1.2   15 Aug 1991 23:08:40   GLENN
  26.  * Forest Belt proofread/edited/cleaned up doc
  27.  * 
  28.  *    Rev 1.1   23 May 1991 02:22:16   GLENN
  29.  * Change to internal function _ftscrptr().
  30.  * 
  31.  *    Rev 1.0   01 Apr 1991 01:03:02   GLENN
  32.  * Nanforum Toolkit
  33.  * 
  34.  *
  35.  */
  36.  
  37.  
  38. #include <extend.h>
  39.  
  40. #define VIDMODE  *(unsigned char far *) 0x00449lu
  41. #define MONO     0xB000
  42. #define COLOR    0xB800
  43. #define VIDSEG   ((7 == VIDMODE) ? MONO : COLOR )
  44.  
  45. #define MK_FP(seg,ofs)  ((void far *) (((unsigned long)(seg) << 16) | \
  46.                         (unsigned)(ofs)));
  47.  
  48. /*
  49.  *    INTERNALS WARNING! INTERNALS WARNING!
  50.  *    _gtMaxRow() and _gtMaxCol() are internals.  Use with caution.
  51.  *
  52.  */
  53.  
  54. int _gtMaxRow(void);
  55. int _gtMaxCol(void);
  56.  
  57.  
  58. /*  $DOC$
  59.  *  $FUNCNAME$
  60.  *     FT_VIDSTR()
  61.  *  $CATEGORY$
  62.  *     Video
  63.  *  $ONELINER$
  64.  *     Display string on screen in specified attribute
  65.  *  $SYNTAX$
  66.  *     FT_VIDSTR( <nRow>, <nCol>, <cString> [, <nColor> ] ) -> NIL
  67.  *  $ARGUMENTS$
  68.  *     <nRow> and <nCol> are the screen coordinates.
  69.  *
  70.  *     <cString> is the string to be printed on the screen.
  71.  *
  72.  *     <nColor> is an integer representing the color attribute.
  73.  *     The formula is:
  74.  *
  75.  *       nFore + ( nBack * 16 )
  76.  *
  77.  *     FT_VIDSTR() will display the string in the current color if
  78.  *     <nColor> is not passed.
  79.  *  $RETURNS$
  80.  *     NIL
  81.  *  $DESCRIPTION$
  82.  *     This is a high speed function to display a string of any ASCII
  83.  *     characters on screen in a specified color attribute.  This function
  84.  *     is useful for constructing screens with a lot of text or repetitive
  85.  *     screen prints where speed is important.
  86.  *  $EXAMPLES$
  87.  *     FT_VIDSTR( 10, 20, "Enter Name :", 165 )
  88.  *             
  89.  *     This example will print the specified text at coordinates 10, 20
  90.  *     in bright white on top of Magenta.
  91.  *
  92.  *  $END$
  93.  */
  94.  
  95.  
  96. CLIPPER FT_VIDSTR(void)
  97. {
  98.    char far *scrPtr;
  99.    int i, j;
  100.  
  101.    int vidSeg  = VIDSEG;
  102.    int numCols = _gtMaxCol() + 1;
  103.  
  104.    int iTRow   = _parni(1);
  105.    int iLCol   = _parni(2);
  106.    char *cStr  = _parc(3);
  107.    int iLen    = _parclen(3);
  108.    int iAttr   = _parni(4);
  109.    int iIsAttr = ISNUM(4);
  110.  
  111.    _gtPreExt();
  112.  
  113.    for ( i = 0, j = iLCol; i < iLen; ++i, ++j ) {
  114.       scrPtr = MK_FP( vidSeg, ( ( iTRow * numCols ) + j ) * 2 );
  115.       *scrPtr++ = cStr[i];
  116.    
  117.       if ( iIsAttr )
  118.          *scrPtr = (unsigned char) iAttr;
  119.    }
  120.    
  121.    _gtPostExt();
  122.    _ret();
  123.    return;
  124. }
  125.  
  126.  
  127. /*  $DOC$
  128.  *  $FUNCNAME$
  129.  *     FT_WRTCHR()
  130.  *  $CATEGORY$
  131.  *     Video
  132.  *  $ONELINER$
  133.  *     Display character on screen
  134.  *  $SYNTAX$
  135.  *     FT_WRTCHR( <nRow>, <nCol>, <cChar>, <nColor> ) -> NIL
  136.  *  $ARGUMENTS$
  137.  *     <nRow> and <nCol> are the screen coordinates.
  138.  *
  139.  *     <cChar> is the single character to print on the screen.
  140.  *
  141.  *     <nColor> is an integer representing the color attribute.
  142.  *     The formula is:
  143.  *
  144.  *        nFore + ( nBack * 16 )
  145.  *  $RETURNS$
  146.  *     NIL
  147.  *  $DESCRIPTION$
  148.  *     This is a high speed function to display a single ASCII character
  149.  *     on screen in a specified color attribute.  This function is useful
  150.  *     for constructing screens with a lot of text or repetitive screen prints
  151.  *     where speed is important.  It is faster and requires less memory than
  152.  *     FT_VIDSTR().  A working example is contained in ClrTable.Prg.
  153.  *  $EXAMPLES$
  154.  *      FOR nX = 1 to MaxRow()
  155.  *         FOR nY = 1 to MaxCol()
  156.  *            FT_PRNTCHR( nX, nY, "∙", (nX - 1)+(nY * 16) )
  157.  *         NEXT
  158.  *      NEXT
  159.  *
  160.  *      This example will write the ASCII character 249 to every location
  161.  *      on screen in every possible color combination.  It will recognize
  162.  *      the status of SetBlink().  It uses direct video writes for speed.
  163.  *
  164.  *  $END$
  165.  */
  166.  
  167. CLIPPER FT_WRTCHR(void)
  168. {
  169.    char far *scrPtr;
  170.    
  171.    int  iTRow  = _parni(1);
  172.    int  iLCol  = _parni(2);
  173.    char *cChar = _parc(3);
  174.    int  iAttr  = _parni(4);
  175.  
  176.    _gtPreExt();
  177.    scrPtr = MK_FP( VIDSEG, ( ( iTRow * _gtMaxCol()+1 ) + iLCol ) * 2 );
  178.    *scrPtr++ = cChar[0];
  179.    
  180.    if( ISNUM( 4 ) )
  181.       *scrPtr = (unsigned char) iAttr;
  182.  
  183.    _gtPostExt();
  184.    _ret();
  185.    return;
  186. }
  187.  
  188.  
  189. /*  $DOC$
  190.  *  $FUNCNAME$
  191.  *     FT_CLS()
  192.  *  $CATEGORY$
  193.  *     Video
  194.  *  $ONELINER$
  195.  *     Clear screen
  196.  *  $SYNTAX$
  197.  *     FT_CLS( <nTRow>, <nLCol>, <nBRow>, <nRCol>, <nColor> ) -> NIL
  198.  *  $ARGUMENTS$
  199.  *     <nTRow>, <nLCol>, <nBRow> and  <nRCol> are the screen coordinates
  200.  *     to clear.
  201.  *
  202.  *     <nColor> is an integer representing the color attribute.
  203.  *     The formula is:
  204.  *
  205.  *       nFore + ( nBack * 16 )
  206.  *
  207.  *     The default is black.
  208.  *  $RETURNS$
  209.  *     NIL
  210.  *  $DESCRIPTION$
  211.  *     This is a high speed function to clear the screen at the given
  212.  *     coordinates with the given color attribute.  This does not change
  213.  *     Clipper's color settings.  It uses direct video writes for speed.
  214.  *
  215.  *  $EXAMPLES$
  216.  *     FT_CLS( 0, 0, MaxRow(), MaxCol(), 165 )
  217.  * 
  218.  *     This example will clear the entire screen with the colors
  219.  *     bright white on magenta.
  220.  *  $END$
  221.  */
  222.  
  223. CLIPPER FT_CLS(void)
  224. {
  225.    char far *scptr;
  226.    int i, j;
  227.    
  228.    int vidSeg  = VIDSEG;
  229.    int numCols = _gtMaxCol() + 1;
  230.  
  231.    int iTRow = ISNUM(1) ? _parni(1) : 0;
  232.    int iLCol = ISNUM(2) ? _parni(2) : 0;
  233.    int iBRow = ISNUM(3) ? _parni(3) : _gtMaxRow();
  234.    int iRCol = ISNUM(4) ? _parni(4) : _gtMaxCol();
  235.    int iAttr = _parni(5);
  236.    
  237.    int fIsAttr = ISNUM(5);
  238.  
  239.    _gtPreExt();
  240.    for (i = iTRow; i <= iBRow; ++i) {
  241.       scptr = MK_FP( vidSeg, ( ( i * numCols ) + iLCol ) * 2 );
  242.       
  243.       for (j = iLCol; j <= iRCol; ++j) {
  244.          *scptr++ = 32;
  245.    
  246.          if( fIsAttr )
  247.             *scptr++ = (unsigned char) iAttr;
  248.          else
  249.             *scptr++;
  250.        }
  251.    }
  252.    _gtPostExt();
  253.    _ret();
  254.    return;
  255.  
  256. }
  257.  
  258.  
  259.  
  260. /*  $DOC$
  261.  *  $FUNCNAME$
  262.  *     FT_SETATTR()
  263.  *  $CATEGORY$
  264.  *     Video
  265.  *  $ONELINER$
  266.  *     Change color attributes of screen region
  267.  *  $SYNTAX$
  268.  *     FT_SETATTR( <nTRow>, <nLCol>, <nBRow>, <nRCol>, <nColor> ) -> NIL
  269.  *  $ARGUMENTS$
  270.  *     <nTRow>, <nLCol>, <nBRow>, and <nRCol> are the coordinates of the
  271.  *     screen region.
  272.  *
  273.  *     <nColor> is an integer representing the new color attribute.
  274.  *     The formula is:
  275.  *
  276.  *         nFore + ( nBack * 16 )
  277.  *  $RETURNS$
  278.  *     NIL
  279.  *  $DESCRIPTION$
  280.  *     This is a high speed function to change the colors of a specified
  281.  *     region of the screen without disturbing any text.  Uses direct
  282.  *     video writes.
  283.  *  $EXAMPLES$
  284.  *     FT_SETATTR( 0, 0, MaxRow(), MaxCol(), 165 )
  285.  * 
  286.  *     This example will change the entire screen's colors to bright white on
  287.  *     magenta without changing or overwriting any text on the screen.
  288.  *  $END$
  289.  */
  290.  
  291. CLIPPER FT_SETATTR(void)
  292. {
  293.    char far *scptr;
  294.    int    i, j;
  295.    
  296.    int iTRow = ISNUM(1) ? _parni(1) : 0;
  297.    int iLCol = ISNUM(2) ? _parni(2) : 0;
  298.    int iBRow = ISNUM(3) ? _parni(3) : _gtMaxRow();
  299.    int iRCol = ISNUM(4) ? _parni(4) : _gtMaxCol();
  300.  
  301.    int iAttr = _parni(5);
  302.  
  303.    int vidSeg  = VIDSEG;
  304.    int numCols = _gtMaxCol() + 1;
  305.  
  306.    _gtPreExt();
  307.   
  308.    for (i = iTRow; i <= iBRow; ++i) {
  309.       scptr = MK_FP( vidSeg, ( ( i * numCols ) + iLCol ) * 2 );
  310.       scptr++;
  311.  
  312.       for (j = iLCol; j <= iRCol; ++j) {
  313.          *scptr = (unsigned char) iAttr;
  314.          scptr += 2;
  315.       }
  316.    }
  317.  
  318.    _gtPostExt();
  319.    _ret();
  320.    return;
  321. }
  322.  
  323.  
  324.  
  325. /*  $DOC$
  326.  *  $FUNCNAME$
  327.  *     FT_REVATTR()
  328.  *  $CATEGORY$
  329.  *     Video
  330.  *  $ONELINER$
  331.  *     Reverse colors of specified screen coordinates
  332.  *  $SYNTAX$
  333.  *     FT_REVATTR( <nTRow>, <nLCol>, <nBRow>, <nRCol> ) -> NIL
  334.  *  $ARGUMENTS$
  335.  *     <nTRow>, <nLCol>, <nBRow>, and <nRCol> are the coordinates of the
  336.  *     screen region.
  337.  *  $RETURNS$
  338.  *     NIL
  339.  *  $DESCRIPTION$
  340.  *     This is a high speed function to reverse the color of a specified
  341.  *     screen region without disturbing any text on the screen.  This
  342.  *     function will correctly reverse the color attributes in a region
  343.  *     containing multiple color combinations.
  344.  *  $EXAMPLES$
  345.  *     FT_REVATTR( 0, 0, MaxRow(), MaxCol() )
  346.  *  
  347.  *     This example will change the entire screen's colors to their reverse
  348.  *     attributes without changing  or overwriting any text.
  349.  *  $END$
  350.  */
  351.  
  352.  
  353. CLIPPER FT_REVATTR(void)
  354. {
  355.    char far *scrPtr;
  356.    int i, j;
  357.    
  358.    int iTRow = ISNUM(1) ? _parni(1) : 0;
  359.    int iLCol = ISNUM(2) ? _parni(2) : 0;
  360.    int iBRow = ISNUM(3) ? _parni(3) : _gtMaxRow();
  361.    int iRCol = ISNUM(4) ? _parni(4) : _gtMaxCol();
  362.  
  363.    int vidSeg  = VIDSEG;
  364.    int numCols = _gtMaxCol() + 1;
  365.  
  366.    _gtPreExt();
  367.    for (i = iTRow; i <= iBRow; ++i) {
  368.       scrPtr = MK_FP( vidSeg, ( ( i * numCols ) + iLCol ) * 2 );
  369.       scrPtr++;
  370.  
  371.       for (j = iLCol; j <= iRCol; ++j) {
  372.         *scrPtr = (*scrPtr>>4)|((*scrPtr&0x07)<<4)|
  373.                  (*scrPtr&0x08)|(*scrPtr&128);
  374.         scrPtr += 2;
  375.       }
  376.    }
  377.    _gtPostExt();
  378.    _ret();
  379.    return;
  380. }
  381.  
  382. /*  $DOC$
  383.  *  $FUNCNAME$
  384.  *     FT_REVCHR()
  385.  *  $CATEGORY$
  386.  *     Video
  387.  *  $ONELINER$
  388.  *     Reverse the color of a single character on the screen
  389.  *  $SYNTAX$
  390.  *     FT_REVCHR( <nTRow>, <nLCol> ) -> NIL
  391.  *  $ARGUMENTS$
  392.  *     <nTRow>, <nLCol> are the screen coordinates of the character.
  393.  *  $RETURNS$
  394.  *     NIL
  395.  *  $DESCRIPTION$
  396.  *     This is a high speed function to reverse the color of a single
  397.  *     character on the screen without changing the character itself.
  398.  *     This function is the same as FT_REVATTR() except that it changes
  399.  *     only one character on screen and hence is faster and uses less memory.
  400.  *  $EXAMPLES$
  401.  *     FT_REVCHR( 10, 20 )
  402.  * 
  403.  *     This example will change the text and background at 10, 20 to it's
  404.  *     reverse color attributes without changing or overwriting the
  405.  *     character itself.
  406.  *  $END$
  407.  */
  408.  
  409. CLIPPER FT_REVCHR(void)
  410. {
  411.    char far *scrPtr;
  412.    
  413.    int iTRow = _parni(1);
  414.    int iLCol = _parni(2);
  415.  
  416.    _gtPreExt();
  417.    scrPtr = MK_FP( VIDSEG, ( ( iTRow * _gtMaxCol()+1 ) + iLCol ) * 2 );
  418.    scrPtr++;
  419.    *scrPtr = (*scrPtr>>4)|((*scrPtr&0x07)<<4)|(*scrPtr&0x08)|(*scrPtr&128);
  420.    _gtPostExt();
  421.    _ret();
  422. }
  423.  
  424.  
  425.