Category : C Source Code
Archive   : CURSESNT.ZIP
Filename : CURSES68.C

/****************************************************************/
/* Low-level I/O functions of the PCcurses package, 'C' version */
/****************************************************************/
/* NOTE! NOTE! NOTE! NOTE! NOTE! NOTE! NOTE! NOTE! */
/* This version is for a 68000 stand-alone VT100 version */
/****************************************************************/
/* This version of curses is based on ncurses, a curses version */
/* originally written by Pavel Curtis at Cornell University. */
/* I have made substantial changes to make it run on IBM PC's, */
/* and therefore consider myself free make it public domain. */
/* Bjorn Larsson ([email protected]) */
/****************************************************************/
/* 1.4: Functional: 900114 */
/****************************************************************/

#include
#include

typedef struct
{
char *name; /* Device/file name */
int (* inch) (); /* Address of input routine */
int (* outch) (); /* Address of output routine */
int (* intst) (); /* Address of input test routine */
int id;
} _chan_desc;

static char _curses_curse68_rcsid[] = "@(#)curses68.c v.1.4 - 900114";

extern _chan_desc _chan_tab[]; /* This one may be accessed */

static char clearseq[] = "\033[2J\033[H";
static char seqbuf[20];

static char isrev = 0;

static int myrow = 1000;
static int mycol = 1000;

/****************************************************************/
/* _Cursescattr() writes char 'chr' with attributes 'attr' to */
/* the current cursor location. */
/****************************************************************/

void _cursescattr(chr, attr)
char chr;
char attr;
{
if ((attr & 0x70) == 0x70)
{
if(!isrev)
{
(*_chan_tab[1].outch)(0x1b);
(*_chan_tab[1].outch)('[');
(*_chan_tab[1].outch)('7');
(*_chan_tab[1].outch)('m');
isrev = 1;
} /* if */
}
else
{
if (isrev)
{
(*_chan_tab[1].outch)(0x1b);
(*_chan_tab[1].outch)('[');
(*_chan_tab[1].outch)('0');
(*_chan_tab[1].outch)('m');
isrev = 0;
} /* if */
} /* else */
if ((_cursvar.cursrow < LINES-1) || (_cursvar.curscol < COLS-1))
{
(*_chan_tab[1].outch)(chr);
if (mycol++ >= 80)
{
mycol = 0;
myrow++;
} /* if */
} /* if */
} /* _cursescattr */

/****************************************************************/
/* _Cursescursor() sets the cursor position in video page 0. */
/* 'row' and 'column' are the cursor address. If 'row' is set */
/* to 25, no cursor at all is displayed. */
/****************************************************************/

void _cursescursor(row, column)
int row;
int column;
{
char *p;
char buf[15];

if ((row == myrow) && (column == mycol))
return;
(*_chan_tab[1].outch)(0x1b);
sprintf(seqbuf,"\033[%d;%dH",row+1, column+1);
for (p = seqbuf; *p; p++)
(*_chan_tab[1].outch)(*p);
myrow = row;
mycol = column;
}/* _cursescursor */

/****************************************************************/
/* _Cursesgcols() returns the current number of columns on the */
/* screen. */
/****************************************************************/

int _cursesgcols()
{
return(80);
} /* _cursesgcols */

/****************************************************************/
/* _Cursesputc() outputs character 'chr' to screen in tty */
/* fashion. If a colour mode is active, the character is writ- */
/* ten with colour 'colour'. */
/****************************************************************/

void _cursesputc(chr, color)
char chr;
char color;
{
if (_cursvar.cursrow >= LINES-1)
return;
if (_cursvar.curscol >= COLS-1)
return;
(*_chan_tab[1].outch)(chr);
if (mycol++ >= 80)
{
mycol = 0;
myrow++;
} /* if */
} /* _cursesputc */

/****************************************************************/
/* _Cursesscroll() scrolls a window in the current page up or */
/* down. Urow, lcol, lrow,rcol are the window coordinates. */
/* Lines is the number of lines to scroll. If 0, clears the */
/* window, if < 0 scrolls down, > 0 scrolls up. Blanks areas */
/* that are left, and sets character attributes to attr. If in */
/* a colour graphics mode, fills them with the colour 'attr' */
/* instead. */
/****************************************************************/

void _cursesscroll(urow, lcol, lrow, rcol, lines, attr)
int urow;
int lcol;
int lrow;
int rcol;
int lines;
char attr;
{
char *p;

for (p = clearseq; *p; p++)
(*_chan_tab[1].outch)(*p);
} /* _cursesscroll */

/****************************************************************/
/* _Cursesgcmode() returns the current cursor type. Bits 8-15 */
/* of the return value is the start scan row, and bits 0-7 is */
/* the end scan row. */
/****************************************************************/

int _cursesgcmode()
{
return(0x0f00);
} /* _cursesgcmode */

/****************************************************************/
/* _Cursescmode() sets the cursor type to begin in scan line */
/* startrow and end in scan line endrow. Both values should be */
/* 0-31. */
/****************************************************************/

void _cursescmode(startrow, endrow)
int startrow;
int endrow;
{
} /* _cursescmode */

/****************************************************************/
/* _Curseskey() returns the next key code struck at the key- */
/* board. If the low 8 bits are 0, the upper bits contain the */
/* extended character code. If bit 0-7 are non-zero, the upper */
/* bits = 0. */
/****************************************************************/

int _curseskey()
{
return ((*_chan_tab[1].inch)());
} /* _curseskey */

/****************************************************************/
/* _Curseskeytst() returns 1 if a keyboard character is avail- */
/* able, 0 otherwise. */
/****************************************************************/

char _curseskeytst()
{
return((*_chan_tab[1].intst)());
} /*_curseskeytst */

/****************************************************************/
/* _Cursesgcb() returns 1 if MSDOS BREAK CHECK is on, else 0. */
/****************************************************************/

int _cursesgcb()
{
return(1);
} /* _cursesgcb */

/****************************************************************/
/* _Cursesscb() sets MSDOS BREAK CHECK according to 'setting'. */
/****************************************************************/

void _cursesscb(setting)
int setting;
{
} /* _cursesscb */

#undef getch

/****************************************************************/
/* Getch() read one character from the keyboard without any */
/* interpretation whatever. */
/****************************************************************/

int getch()
{
return ((*_chan_tab[1].inch)());
} /* getch */