home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 388_01 / curses / curses.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-24  |  8.6 KB  |  515 lines
  1. /*
  2.  * curses.c    
  3.  *
  4.  * Stdscr Curses for PC Class Machines.
  5.  *
  6.  * Copyright 1990, 1993 by Anthony Howe.  All rights reserved.  No warranty.
  7.  *
  8.  *
  9.  * DESCRIPTION:
  10.  * This is a quick and dirty curses.  It assumes that only stdscr is
  11.  * used and so writes directly to the screen via the bios rather than 
  12.  * wait for a refresh().
  13.  */
  14.  
  15. #include <dos.h>
  16. #include <ctype.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #include "curses.h"
  20. #include "unctrl.h"
  21.  
  22. #define ISFUNCKEY(x)    (0x100 <= (x))
  23.  
  24. SCREEN _tty;
  25. WINDOW _stdscr;
  26. chtype A_NORMAL;
  27. chtype A_REVERSE;
  28.  
  29. WINDOW *
  30. initscr()
  31. {
  32.     int i;
  33.  
  34.     _tty.mode = GetVideoMode();
  35.     _tty.page = GetDisplayPage();
  36.     _stdscr.mcol = _tty.width = GetScreenWidth();
  37.     
  38.     switch (_tty.mode) {
  39.     case 0:
  40.     case 1:
  41.     case 2:
  42.     case 3:
  43.         /* Common colour modes. */
  44.         _stdscr.mrow = _tty.height = SCREEN_HEIGHT;
  45.         _tty.seg = 0xb800;
  46.         break;
  47.     case 7:
  48.         /* Common monochrome mode. */
  49.         _stdscr.mrow = _tty.height = SCREEN_HEIGHT;
  50.         _tty.seg = 0xb000;
  51.         break;
  52.     default:
  53.         return (NULL);
  54.     }
  55.  
  56.     /* Fetch screen attributes from bottom-left corner. */
  57.     mvcur(-1, -1, _tty.height-1, 0);
  58.     A_NORMAL = GetChtype(_tty.page) & A_ATTRIBUTES;
  59.     A_REVERSE = ((A_NORMAL & 0x0700) << 4) | ((A_NORMAL & 0xf000) >> 4);
  60.  
  61.     _stdscr.attr = A_NORMAL;
  62.     _stdscr.back = A_NORMAL | ' ';
  63.     _stdscr.flags |=  _FULLWIN;
  64.     _stdscr.row = _stdscr.col = _stdscr.brow = _stdscr.bcol = 0;
  65.  
  66.     /* Create a dynamic array. */
  67.     _stdscr.display = (chtype far **) malloc
  68.         (_tty.height * sizeof (chtype far *)
  69.     );
  70.     if (_stdscr.display == NULL)
  71.         return (NULL);
  72.  
  73.     _stdscr.display[0] = MK_FP(_tty.seg, 0);
  74.     _stdscr.flags |= _MEMMAP;
  75.  
  76.     for (i = 1; i < LINES; ++i) 
  77.         _stdscr.display[i] = _stdscr.display[i-1] + _tty.width;
  78.  
  79.     clear();
  80.     echo();
  81.     nl();
  82.     scrollok(stdscr, FALSE);
  83.     return (&_stdscr);
  84. }
  85.  
  86. int
  87. addch(c)
  88. chtype c;
  89. {
  90.     int n;
  91.  
  92.     switch (c) {
  93.     case '\t':
  94.         n = 8-(_stdscr.col&7);
  95.         while (0 < n--)
  96.             addch(' ');
  97.         break;
  98.     case '\r':
  99.         _stdscr.col = 0;
  100.         break;
  101.     case '\n':
  102.         clrtoeol();
  103.         if (_tty._crlf)
  104.             _stdscr.col = 0;
  105.         ++_stdscr.row;
  106.         break;
  107.     case '\b':
  108.         if (0 < _stdscr.col)
  109.             --_stdscr.col;
  110.         else if (0 < _stdscr.row)
  111.             --_stdscr.row;
  112.         break;
  113.     default:
  114.         c |= _stdscr.attr;
  115.         if (_stdscr.display[_stdscr.row][_stdscr.col] != c) { 
  116.             _stdscr.display[_stdscr.row][_stdscr.col] = c;
  117.         }
  118.         ++_stdscr.col;
  119.     }
  120.     if (COLS <= _stdscr.col) {
  121.         _stdscr.col = 0;
  122.         ++_stdscr.row;
  123.     }
  124.     if (LINES <= _stdscr.row && (_stdscr.flags & _SCROLLOK)) {
  125.         /* Scroll up one line. */
  126.         ScrollUp(1, _stdscr.back, 0, 0, LINES, COLS);
  127.         move(LINES-1, 0);
  128.         clrtoeol();
  129.     }
  130.  
  131.     return (OK);
  132. }
  133.  
  134. int
  135. addnstr(s, n)
  136. char *s;
  137. int n;
  138. {
  139.     if (n < 0)
  140.         n = strlen(s);
  141.     while (0 < n-- && *s)
  142.         addch(*s++);
  143.     while (0 < n--)
  144.         addch(' ');
  145.     return (OK);
  146. }
  147.  
  148. #ifdef __STDC__
  149. int
  150. printw(char *fmt, ...)
  151. #else
  152. int
  153. printw(fmt)
  154. char *fmt;
  155. #endif /* __STDC__ */
  156. {
  157.     int i;
  158.     va_list args;
  159.     va_start(args, fmt);
  160.     i = vwprintw(stdscr, fmt, args);
  161.     va_end(args);
  162.     return (i);
  163. }
  164.  
  165. #ifdef __STDC__
  166. int
  167. mvprintw(int row, int col, char *fmt, ...)
  168. #else
  169. int
  170. mvprintw(row, col, fmt)
  171. int row, col;
  172. char *fmt;
  173. #endif /* __STDC__ */
  174. {
  175.     int i;
  176.     va_list args;
  177.     move(row, col);
  178.     va_start(args, fmt);
  179.     i = vwprintw(stdscr, fmt, args);
  180.     va_end(args);
  181.     return (i);
  182. }
  183.  
  184. int 
  185. vwprintw(w, fmt, args)
  186. WINDOW *w;
  187. char *fmt;
  188. va_list args;
  189. {
  190.     int i;
  191.     char buffer[BUFSIZ];
  192.     i = vsprintf(buffer, fmt, args);
  193.     addstr(buffer);
  194.     return (i);
  195. }
  196.  
  197. int
  198. beep()
  199. {
  200.     AddChar(_tty.page, 7);
  201.     mvcur(-1, -1, _stdscr.row, _stdscr.col);
  202.     return (OK);
  203. }
  204.  
  205. int
  206. endwin()
  207. {
  208.     chtype blank = ' ' | A_NORMAL;
  209.     mvcur(-1, -1, _tty.height-1, 0);
  210.     PutChtype(_tty.page, blank);
  211.     return (OK);
  212. }
  213.  
  214. int
  215. clrtobot()
  216. {
  217.     int row, col;
  218.  
  219.     if (LINES <= _stdscr.row)
  220.         return (ERR);
  221.     getyx(stdscr, row, col);
  222.     do {
  223.         if (clrtoeol() == ERR)
  224.             return (ERR);
  225.         _stdscr.col = 0;
  226.     } while (++_stdscr.row < LINES);
  227.     move(row, col);
  228.     return (OK);
  229. }
  230.  
  231. int
  232. clrtoeol()
  233. {
  234.     register int i;
  235.     register chtype far *ptr;
  236.  
  237.     if (COLS <= _stdscr.col)
  238.         return (ERR);
  239.     ptr = &_stdscr.display[_stdscr.row][_stdscr.col];
  240.     for (i = _stdscr.col; i < COLS; ++i, ++ptr) { 
  241.         if (*ptr != _stdscr.back) {
  242.             for (; i < COLS; ++i, ++ptr)
  243.                 *ptr = _stdscr.back;
  244.             break;
  245.         }
  246.     }
  247.     return (OK);
  248. } 
  249.  
  250. int
  251. refresh()
  252. {
  253.     if (!(_stdscr.flags & _LEAVEOK))
  254.         mvcur(-1, -1, _stdscr.row, _stdscr.col);
  255.     _stdscr.flags &= ~_CLEAROK;
  256.     return (OK);
  257. }
  258.  
  259. int
  260. clearok(w, bf)
  261. WINDOW *w;
  262. int bf;
  263. {
  264.     if (bf)
  265.         _stdscr.flags |= _CLEAROK;
  266.     else
  267.         _stdscr.flags &= ~_CLEAROK;
  268.     return (OK);
  269. }
  270.  
  271. int
  272. idlok(w, bf)
  273. WINDOW *w;
  274. int bf;
  275. {
  276.     if (bf)
  277.         _stdscr.flags |= _IDLOK;
  278.     else
  279.         _stdscr.flags &= ~_IDLOK;
  280.     return (OK);
  281. }
  282.  
  283. int
  284. scrollok(w, bf)
  285. WINDOW *w;
  286. int bf;
  287. {
  288.     if (bf)
  289.         _stdscr.flags |= _SCROLLOK;
  290.     else
  291.         _stdscr.flags &= ~_SCROLLOK;
  292.     return (OK);
  293. }
  294.  
  295. int
  296. keypad(w, bf)
  297. WINDOW *w;
  298. int bf;
  299. {
  300.     if (bf)
  301.         _stdscr.flags |= _KEYPAD;
  302.     else
  303.         _stdscr.flags &= ~_KEYPAD;
  304.     return (OK);
  305. }
  306.  
  307. int
  308. leaveok(w, bf)
  309. WINDOW *w;
  310. int bf;
  311. {
  312.     if (bf)
  313.         _stdscr.flags |= _LEAVEOK;
  314.     else
  315.         _stdscr.flags &= ~_LEAVEOK;
  316.     return (OK);
  317. }
  318.  
  319. int
  320. getch()
  321. {
  322.     KEY c;
  323.     refresh();
  324.     if (_stdscr.flags & _KEYPAD) {
  325.         c.val = GetKey();
  326.         if (c.key.ascii == 0) {
  327.             c.key.ascii = c.key.extended;
  328.             c.key.extended = 0x01;
  329.         } else {
  330.             c.key.extended = 0;
  331.             if (_tty._echo)
  332.                 addch(c.key.ascii);
  333.         }
  334.     } else {
  335.         static int scancode;
  336.         if (scancode != 0) {
  337.             /* Return previous saved scancode. */
  338.             c.val = scancode;
  339.             scancode = 0;
  340.         } else {
  341.             c.val = GetKey();
  342.             if (c.key.ascii == 0) {
  343.                 /* Remember scancode for next call 
  344.                  * of getch().  Return ^[ this call.
  345.                  */
  346.                 c.key.ascii = 0x1b;
  347.                 scancode = c.key.extended;
  348.             }
  349.             c.key.extended = 0;
  350.             if (_tty._echo)
  351.                 addch(c.key.ascii);
  352.         }
  353.     }
  354.     return (c.val);
  355. }
  356.  
  357. char *
  358. unctrl(ch)
  359. int ch;
  360. {
  361.     static char buf[5];
  362.     static char *ctrls[] = {
  363.         "^?",
  364.         "^@", "^A", "^B", "^C", "^D", "^E", "^F", "^G", 
  365.         "^H", "^I", "^J", "^K", "^L", "^M", "^N", "^O", 
  366.         "^P", "^Q", "^R", "^S", "^T", "^U", "^V", "^W", 
  367.         "^X", "^Y", "^Z", "^[", "^\\", "^]", "^^", "^_"
  368.     };
  369.     if (ch == 0x7f) {
  370.         return (ctrls[0]);
  371.     } else if (0x7f < ch) {
  372.         (void) sprintf(buf, "\\%03o", ch);
  373.     } else if (iscntrl(ch)) {
  374.         return (ctrls[ch+1]);
  375.     } else {
  376.         *buf = ch;
  377.         buf[1] = '\0';
  378.     } 
  379.     return (buf);
  380. }
  381.  
  382. typedef struct key_entry_t {
  383.     int code;
  384.     int (*func)(void);
  385. } key_entry_t;
  386.  
  387. static int fld_done(void);
  388. static int fld_erase(void);
  389. static int fld_kill(void);
  390. static int fld_left(void);
  391. static int fld_insert(void);
  392.  
  393. static key_entry_t table[] = {
  394.     { '\b', fld_erase },
  395.     { CTRL('x'), fld_kill },
  396.     { '\r', fld_done },
  397.     { '\n', fld_done },
  398.     { KEY_LEFT, fld_erase },
  399.     { KEY_BACKSPACE, fld_erase },    
  400.     { -1, fld_insert }
  401. };
  402.  
  403. static int fld_row;
  404. static int fld_col;
  405. static int fld_key;
  406. static int fld_echo;
  407. static int fld_index;
  408. static int fld_length;
  409. static char *fld_buffer;
  410.  
  411. int
  412. getnstr(buf, len)
  413. char *buf;
  414. int len;
  415. {
  416.     key_entry_t *k;
  417.  
  418.     fld_index = 0;
  419.     fld_buffer = buf;
  420.     fld_length = len < 0 ? COLS : len;
  421.     if (--fld_length < 1)
  422.         return (ERR);
  423.     getyx(stdscr, fld_row, fld_col);
  424.     fld_echo = _tty._echo;
  425.     noecho();
  426.  
  427.     for (;;) {
  428.         fld_key = getch();
  429.         for (k = table; k->code != -1 && k->code != fld_key; ++k)
  430.             ;
  431.         if (k->func != NULL && !(k->func)()) {
  432.             fld_buffer[fld_index] = '\0';
  433.             break;
  434.         }
  435.     }
  436.  
  437.     if (fld_echo)
  438.         echo();
  439.     return (OK);
  440. }
  441.     
  442. static int
  443. fld_done()
  444. {
  445.     return (FALSE);
  446. }
  447.  
  448. static int
  449. fld_left()
  450. {
  451.     int row, col, max_row, max_col;
  452.  
  453.     getyx(stdscr, row, col);
  454.     getmaxyx(stdscr, max_row, max_col);
  455.     if (0 < fld_index) {
  456.         --fld_index;
  457.         /* Assume that if 0 < fld_index then fld_row <= row 
  458.          * and fld_col < col.  So when fld_index == 0, then
  459.          * fld_row == row and fld_col == col. 
  460.          */
  461.         if (0 < col) {
  462.             --col;
  463.         } else if (0 < row) {
  464.             /* Handle reverse line wrap. */
  465.             --row;
  466.             col = max_col-1;
  467.         }
  468.         move(row, col);
  469.     }
  470.     return (TRUE);
  471. }
  472.  
  473. static int
  474. fld_erase()
  475. {
  476.     int row, col;
  477.  
  478.     if (0 < fld_index) {
  479.         fld_left();
  480.         getyx(stdscr, row, col);
  481.         addch(' ');
  482.         move(row, col);
  483.         fld_buffer[fld_index] = '\0';
  484.     }
  485.     return (TRUE);
  486. }
  487.  
  488. static int
  489. fld_kill()
  490. {
  491.     move(fld_row, fld_col);
  492.     while (0 < fld_index--)
  493.         addch(' ');
  494.     move(fld_row, fld_col);
  495.     fld_buffer[0] = '\0';
  496.     fld_index = 0;
  497.     return    (TRUE);
  498. }
  499.  
  500. static int
  501. fld_insert()
  502. {
  503.     if (fld_index < fld_length) {
  504.         if (!ISFUNCKEY(fld_key)) {
  505.             fld_buffer[fld_index++] = fld_key;
  506.             if (fld_echo)
  507.                 addch(fld_key);
  508.         } else {
  509.             beep();
  510.         }
  511.     }
  512.     return (fld_index < fld_length);
  513. }
  514.  
  515.