home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / gnu / djgpp / contrib / windows / src / video.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-02  |  6.5 KB  |  320 lines
  1. /**********************************************************************
  2.  *  
  3.  *  NAME:           video.cpp
  4.  *  
  5.  *  DESCRIPTION:    video functions for Turbo C video library
  6.  *  
  7.  *  copyright (c) 1990 J. Alan Eldridge
  8.  * 
  9.  *  M O D I F I C A T I O N   H I S T O R Y
  10.  *
  11.  *  when        who                 what
  12.  *  -------------------------------------------------------------------
  13.  *  08/05/90    J. Alan Eldridge    created
  14.  *
  15.  *  08/12/90    JAE                 removed some error checking,
  16.  *                                  made some functions void
  17.  *  
  18.  *  12/21/90    JAE                 un-object-oriented it, because
  19.  *                                  it just didn't seem to fit
  20.  *
  21.  *********************************************************************/
  22.  
  23. #include    "aedef.h"
  24. #include    "vidchr.h"
  25. #include    "video.h"
  26.  
  27. #if defined(__TURBOC__)
  28. #include    "envutils.h"
  29. #endif
  30.  
  31. //  static storage for video driver
  32.  
  33. static  struct text_info    tInfo;  //  so we can put the world back
  34.  
  35. static  uchar   mode;           //  mode we're in
  36. static  uchar   nRows,          //  size of physical display
  37.                 nCols;
  38. static  uchar   cRow,           //  current cursor position
  39.                 cCol;
  40. static  uchar   fOpen,          //  device has been opened
  41.                 fColor,         //  device has color support
  42.                 fSaved;         //  image has been saved
  43. static  vidchr  *pSvImg;        //  ptr to saved image
  44.  
  45. static  uchar   curscnt,        //  count for show/hide cursor
  46.                 curstype;       //  type cursor would be if shown
  47.  
  48. //  global for default video attribute
  49.  
  50. uchar   vid_defaultatt = vid_mkatt(LIGHTGRAY,BLACK);
  51.  
  52. //  globals to avoid function call overhead
  53.  
  54. int     vid_ROWS, vid_COLS, vid_ISCOLOR;
  55.  
  56. //  flags handling
  57.  
  58. static void
  59. zflags()    
  60. {
  61.     vid_ROWS = vid_COLS = 0;
  62.     fOpen = fColor = fSaved = vid_ISCOLOR = FALSE;
  63. } 
  64.  
  65. int
  66. vid_isopen()
  67. {
  68.     return fOpen;
  69. }
  70.  
  71. int
  72. vid_iscolor()
  73. {
  74.     return fColor;
  75. }
  76.  
  77. //  write (up to) one row of screen memory
  78.  
  79. int
  80. vid_write(
  81.     uchar   atRow,
  82.     uchar   atCol,
  83.     vidchr   *pBuf,
  84.     uchar   nChrs)
  85. {
  86.     ++atRow, ++atCol;
  87.     return puttext(atCol, atRow, atCol + nChrs - 1, atRow, pBuf) ? OK : ERR;
  88. }
  89.  
  90. //  read (up to) one row of screen memory
  91.  
  92. int
  93. vid_read(
  94.     uchar   atRow,
  95.     uchar   atCol,
  96.     vidchr   *pBuf,
  97.     uchar   nChrs)
  98. {
  99.     ++atRow, ++atCol;
  100.     return gettext(atCol, atRow, atCol + nChrs - 1, atRow, pBuf) ? OK : ERR;
  101. }
  102.  
  103. //  set physical cursor position
  104.  
  105. int
  106. vid_setcpos(
  107.     uchar   atRow,
  108.     uchar   atCol)
  109. {
  110.     if (atRow < nRows && atCol < nCols) {
  111.         cCol = atCol++;
  112.         cRow = atRow++;
  113.         gotoxy(atCol, atRow);
  114.         return OK;
  115.     } else
  116.         return ERR;
  117. }
  118.  
  119. //  get physical cursor position
  120.  
  121. void
  122. vid_getcpos(
  123.     uchar   *pRC)
  124. {
  125.     pRC[0] = cRow;
  126.     pRC[1] = cCol;
  127. }
  128.  
  129. //  clear the screen
  130.  
  131. void
  132. vid_clear(
  133.     uchar   att)
  134. {
  135.     textattr(att);
  136.     clrscr();
  137. }
  138.  
  139. //  initialize the video mode & try to save the image
  140.  
  141. void
  142. vid_open(
  143.     int     newMode,
  144.     char    *evar)
  145. {
  146.     struct text_info    newInfo;
  147.     
  148.     if (fOpen) return;
  149.     
  150.     zflags();
  151.     newMode = vid_envmode(newMode, evar);
  152.     gettextinfo(&tInfo);
  153.     if (newMode != LASTMODE) {
  154.         textmode(newMode);
  155.         gettextinfo(&newInfo);
  156.     } else
  157.         newInfo = tInfo;
  158.     mode = newInfo.currmode;
  159.     vid_ROWS = nRows = newInfo.screenheight;
  160.     vid_COLS = nCols = newInfo.screenwidth;
  161.     if (newInfo.currmode != MONO && newInfo.currmode != BW80 &&
  162.         newInfo.currmode != BW40)
  163.         vid_ISCOLOR = fColor = TRUE;
  164.     pSvImg = new vidchr [ tInfo.screenwidth * tInfo.screenheight ];
  165.     if (pSvImg) {
  166.         gettext(1, 1, tInfo.screenwidth, tInfo.screenheight, pSvImg);
  167.         fSaved = TRUE;
  168.     }
  169.     curscnt = 0;
  170.     _setcursortype(curstype = _NORMALCURSOR);
  171.     fOpen = TRUE;
  172.     atexit(vid_close);
  173. }
  174.  
  175. //  restore saved video mode & image
  176.  
  177. void
  178. vid_close()
  179. {
  180.     if (fOpen) {
  181.         textmode(tInfo.currmode);
  182.         textattr(tInfo.normattr);
  183.         if (fSaved) {
  184.             puttext(1, 1, tInfo.screenwidth, tInfo.screenheight, pSvImg);
  185.             delete pSvImg;
  186.             gotoxy(tInfo.curx, tInfo.cury);
  187.         } else {
  188.             clrscr();
  189.             gotoxy(1, 1);
  190.         }
  191.     }
  192.     _setcursortype(_NORMALCURSOR);
  193.     zflags();
  194. }
  195.         
  196. //  parse environment variable & return desired video mode
  197.  
  198. int
  199. vid_envmode(
  200.     int     mode,
  201.     char    *varName)
  202. {
  203. #if defined(__TURBOC__)
  204.     static struct {
  205.         char    *name;
  206.         int     mode;
  207.     } eVals[] = {
  208.         "MONO",     MONO,
  209.         "CO40",     C40,
  210.         "BW40",     BW40,
  211.         "CO80",     C80,
  212.         "BW80",     BW80,
  213.         "C4350",    C4350,
  214.         "",         LASTMODE
  215.     };
  216.     
  217.     int     nVals;    
  218.     char    *vals[2];
  219.     
  220.     if (!varName || !varName[0])
  221.         return mode;
  222.         
  223.     if (nVals = envParse(varName, ";, \t", vals, 2, 0)) {
  224.         for (int n = 0; eVals[n].name[0]; n++) {
  225.             if (!stricmp(vals[0], eVals[n].name) 
  226.                 || (nVals > 1 && !stricmp(vals[1], eVals[n].name))) {
  227.                 mode = eVals[n].mode;
  228.                 break;
  229.             }
  230.         }
  231.         if (!stricmp(vals[0], "BIOS") || (nVals > 1 && !stricmp(vals[1], "BIOS")))
  232.             directvideo = 0;
  233.     }
  234.     return mode;
  235. #else
  236.     return LASTMODE;
  237. #endif
  238. }
  239.  
  240. int
  241. vid_rows()
  242. {
  243.     return nRows;
  244. }
  245.  
  246. int
  247. vid_cols()
  248. {
  249.     return nCols;
  250. }
  251.  
  252. //  high level cursor handling
  253.  
  254. void
  255. vid_hidecursor(int newcnt)
  256. {
  257.     int musthide = !curscnt;
  258.     
  259.     if (newcnt)
  260.         curscnt = newcnt;
  261.     else
  262.         curscnt--;
  263.         
  264.     if (musthide)
  265.         _setcursortype(_NOCURSOR);
  266. }
  267.  
  268. void
  269. vid_showcursor()
  270. {
  271.     if (curscnt < 0)
  272.         ++curscnt;
  273.     if (curscnt == 0)
  274.         _setcursortype(curstype);
  275. }
  276.  
  277. void
  278. vid_forcecursor(int &oldcnt)
  279. {
  280.     oldcnt = curscnt;
  281.     curscnt = 0;
  282.     _setcursortype(curstype);
  283. }
  284.     
  285. int
  286. vid_cursortype(int type)
  287. {
  288.     int oldtype = curstype;
  289.     
  290.     curstype = type;
  291.     if (curscnt == 0)
  292.         _setcursortype(curstype);
  293.     return oldtype;
  294. }
  295.  
  296. int
  297. vid_cursortype()
  298. {
  299.     return curstype;
  300. }
  301.  
  302. #if NOT_NEEDED
  303.  
  304. //  this class exists just to make sure the screen 
  305. //  gets put back when the program exits: the destructor
  306. //  for the static variable Video calls vid_close()
  307.  
  308. class video {
  309. public:
  310.     ~video()
  311.         { vid_close(); }
  312. };
  313.  
  314. static video Video;
  315.  
  316. #endif
  317.  
  318.  
  319.  
  320.